1 /* Output Dwarf2 format symbol table information from GCC.
2 Copyright (C) 1992, 1993, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
3 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
4 Contributed by Gary Funck (gary@intrepid.com).
5 Derived from DWARF 1 implementation of Ron Guilmette (rfg@monkeys.com).
6 Extensively modified by Jason Merrill (jason@cygnus.com).
8 This file is part of GCC.
10 GCC is free software; you can redistribute it and/or modify it under
11 the terms of the GNU General Public License as published by the Free
12 Software Foundation; either version 3, or (at your option) any later
15 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
16 WARRANTY; without even the implied warranty of MERCHANTABILITY or
17 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING3. If not see
22 <http://www.gnu.org/licenses/>. */
24 /* TODO: Emit .debug_line header even when there are no functions, since
25 the file numbers are used by .debug_info. Alternately, leave
26 out locations for types and decls.
27 Avoid talking about ctors and op= for PODs.
28 Factor out common prologue sequences into multiple CIEs. */
30 /* The first part of this file deals with the DWARF 2 frame unwind
31 information, which is also used by the GCC efficient exception handling
32 mechanism. The second part, controlled only by an #ifdef
33 DWARF2_DEBUGGING_INFO, deals with the other DWARF 2 debugging
36 /* DWARF2 Abbreviation Glossary:
38 CFA = Canonical Frame Address
39 a fixed address on the stack which identifies a call frame.
40 We define it to be the value of SP just before the call insn.
41 The CFA register and offset, which may change during the course
42 of the function, are used to calculate its value at runtime.
44 CFI = Call Frame Instruction
45 an instruction for the DWARF2 abstract machine
47 CIE = Common Information Entry
48 information describing information common to one or more FDEs
50 DIE = Debugging Information Entry
52 FDE = Frame Description Entry
53 information describing the stack call frame, in particular,
54 how to restore registers
56 DW_CFA_... = DWARF2 CFA call frame instruction
57 DW_TAG_... = DWARF2 DIE tag */
61 #include "coretypes.h"
68 #include "hard-reg-set.h"
70 #include "insn-config.h"
78 #include "dwarf2out.h"
79 #include "dwarf2asm.h"
85 #include "diagnostic.h"
88 #include "langhooks.h"
93 #ifdef DWARF2_DEBUGGING_INFO
94 static void dwarf2out_source_line (unsigned int, const char *);
97 #ifndef DWARF2_FRAME_INFO
98 # ifdef DWARF2_DEBUGGING_INFO
99 # define DWARF2_FRAME_INFO \
100 (write_symbols == DWARF2_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
102 # define DWARF2_FRAME_INFO 0
106 /* Map register numbers held in the call frame info that gcc has
107 collected using DWARF_FRAME_REGNUM to those that should be output in
108 .debug_frame and .eh_frame. */
109 #ifndef DWARF2_FRAME_REG_OUT
110 #define DWARF2_FRAME_REG_OUT(REGNO, FOR_EH) (REGNO)
113 /* Save the result of dwarf2out_do_frame across PCH. */
114 static GTY(()) bool saved_do_cfi_asm
= 0;
116 /* Decide whether we want to emit frame unwind information for the current
120 dwarf2out_do_frame (void)
122 /* We want to emit correct CFA location expressions or lists, so we
123 have to return true if we're going to output debug info, even if
124 we're not going to output frame or unwind info. */
125 return (write_symbols
== DWARF2_DEBUG
126 || write_symbols
== VMS_AND_DWARF2_DEBUG
127 || DWARF2_FRAME_INFO
|| saved_do_cfi_asm
128 #ifdef DWARF2_UNWIND_INFO
129 || (DWARF2_UNWIND_INFO
130 && (flag_unwind_tables
131 || (flag_exceptions
&& ! USING_SJLJ_EXCEPTIONS
)))
136 /* Decide whether to emit frame unwind via assembler directives. */
139 dwarf2out_do_cfi_asm (void)
143 #ifdef MIPS_DEBUGGING_INFO
146 if (!flag_dwarf2_cfi_asm
|| !dwarf2out_do_frame ())
148 if (saved_do_cfi_asm
|| !eh_personality_libfunc
)
150 if (!HAVE_GAS_CFI_PERSONALITY_DIRECTIVE
)
153 /* Make sure the personality encoding is one the assembler can support.
154 In particular, aligned addresses can't be handled. */
155 enc
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,/*global=*/1);
156 if ((enc
& 0x70) != 0 && (enc
& 0x70) != DW_EH_PE_pcrel
)
158 enc
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,/*global=*/0);
159 if ((enc
& 0x70) != 0 && (enc
& 0x70) != DW_EH_PE_pcrel
)
162 saved_do_cfi_asm
= true;
166 /* The size of the target's pointer type. */
168 #define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
171 /* Array of RTXes referenced by the debugging information, which therefore
172 must be kept around forever. */
173 static GTY(()) VEC(rtx
,gc
) *used_rtx_array
;
175 /* A pointer to the base of a list of incomplete types which might be
176 completed at some later time. incomplete_types_list needs to be a
177 VEC(tree,gc) because we want to tell the garbage collector about
179 static GTY(()) VEC(tree
,gc
) *incomplete_types
;
181 /* A pointer to the base of a table of references to declaration
182 scopes. This table is a display which tracks the nesting
183 of declaration scopes at the current scope and containing
184 scopes. This table is used to find the proper place to
185 define type declaration DIE's. */
186 static GTY(()) VEC(tree
,gc
) *decl_scope_table
;
188 /* Pointers to various DWARF2 sections. */
189 static GTY(()) section
*debug_info_section
;
190 static GTY(()) section
*debug_abbrev_section
;
191 static GTY(()) section
*debug_aranges_section
;
192 static GTY(()) section
*debug_macinfo_section
;
193 static GTY(()) section
*debug_line_section
;
194 static GTY(()) section
*debug_loc_section
;
195 static GTY(()) section
*debug_pubnames_section
;
196 static GTY(()) section
*debug_pubtypes_section
;
197 static GTY(()) section
*debug_str_section
;
198 static GTY(()) section
*debug_ranges_section
;
199 static GTY(()) section
*debug_frame_section
;
201 /* How to start an assembler comment. */
202 #ifndef ASM_COMMENT_START
203 #define ASM_COMMENT_START ";#"
206 typedef struct dw_cfi_struct
*dw_cfi_ref
;
207 typedef struct dw_fde_struct
*dw_fde_ref
;
208 typedef union dw_cfi_oprnd_struct
*dw_cfi_oprnd_ref
;
210 /* Call frames are described using a sequence of Call Frame
211 Information instructions. The register number, offset
212 and address fields are provided as possible operands;
213 their use is selected by the opcode field. */
215 enum dw_cfi_oprnd_type
{
217 dw_cfi_oprnd_reg_num
,
223 typedef union GTY(()) dw_cfi_oprnd_struct
{
224 unsigned int GTY ((tag ("dw_cfi_oprnd_reg_num"))) dw_cfi_reg_num
;
225 HOST_WIDE_INT
GTY ((tag ("dw_cfi_oprnd_offset"))) dw_cfi_offset
;
226 const char * GTY ((tag ("dw_cfi_oprnd_addr"))) dw_cfi_addr
;
227 struct dw_loc_descr_struct
* GTY ((tag ("dw_cfi_oprnd_loc"))) dw_cfi_loc
;
231 typedef struct GTY(()) dw_cfi_struct
{
232 dw_cfi_ref dw_cfi_next
;
233 enum dwarf_call_frame_info dw_cfi_opc
;
234 dw_cfi_oprnd
GTY ((desc ("dw_cfi_oprnd1_desc (%1.dw_cfi_opc)")))
236 dw_cfi_oprnd
GTY ((desc ("dw_cfi_oprnd2_desc (%1.dw_cfi_opc)")))
241 /* This is how we define the location of the CFA. We use to handle it
242 as REG + OFFSET all the time, but now it can be more complex.
243 It can now be either REG + CFA_OFFSET or *(REG + BASE_OFFSET) + CFA_OFFSET.
244 Instead of passing around REG and OFFSET, we pass a copy
245 of this structure. */
246 typedef struct GTY(()) cfa_loc
{
247 HOST_WIDE_INT offset
;
248 HOST_WIDE_INT base_offset
;
250 int indirect
; /* 1 if CFA is accessed via a dereference. */
253 /* All call frame descriptions (FDE's) in the GCC generated DWARF
254 refer to a single Common Information Entry (CIE), defined at
255 the beginning of the .debug_frame section. This use of a single
256 CIE obviates the need to keep track of multiple CIE's
257 in the DWARF generation routines below. */
259 typedef struct GTY(()) dw_fde_struct
{
261 const char *dw_fde_begin
;
262 const char *dw_fde_current_label
;
263 const char *dw_fde_end
;
264 const char *dw_fde_hot_section_label
;
265 const char *dw_fde_hot_section_end_label
;
266 const char *dw_fde_unlikely_section_label
;
267 const char *dw_fde_unlikely_section_end_label
;
268 bool dw_fde_switched_sections
;
269 dw_cfi_ref dw_fde_cfi
;
270 unsigned funcdef_number
;
271 HOST_WIDE_INT stack_realignment
;
272 /* Dynamic realign argument pointer register. */
273 unsigned int drap_reg
;
274 /* Virtual dynamic realign argument pointer register. */
275 unsigned int vdrap_reg
;
276 unsigned all_throwers_are_sibcalls
: 1;
277 unsigned nothrow
: 1;
278 unsigned uses_eh_lsda
: 1;
279 /* Whether we did stack realign in this call frame. */
280 unsigned stack_realign
: 1;
281 /* Whether dynamic realign argument pointer register has been saved. */
282 unsigned drap_reg_saved
: 1;
286 /* Maximum size (in bytes) of an artificially generated label. */
287 #define MAX_ARTIFICIAL_LABEL_BYTES 30
289 /* The size of addresses as they appear in the Dwarf 2 data.
290 Some architectures use word addresses to refer to code locations,
291 but Dwarf 2 info always uses byte addresses. On such machines,
292 Dwarf 2 addresses need to be larger than the architecture's
294 #ifndef DWARF2_ADDR_SIZE
295 #define DWARF2_ADDR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
298 /* The size in bytes of a DWARF field indicating an offset or length
299 relative to a debug info section, specified to be 4 bytes in the
300 DWARF-2 specification. The SGI/MIPS ABI defines it to be the same
303 #ifndef DWARF_OFFSET_SIZE
304 #define DWARF_OFFSET_SIZE 4
307 /* According to the (draft) DWARF 3 specification, the initial length
308 should either be 4 or 12 bytes. When it's 12 bytes, the first 4
309 bytes are 0xffffffff, followed by the length stored in the next 8
312 However, the SGI/MIPS ABI uses an initial length which is equal to
313 DWARF_OFFSET_SIZE. It is defined (elsewhere) accordingly. */
315 #ifndef DWARF_INITIAL_LENGTH_SIZE
316 #define DWARF_INITIAL_LENGTH_SIZE (DWARF_OFFSET_SIZE == 4 ? 4 : 12)
319 #define DWARF_VERSION 2
321 /* Round SIZE up to the nearest BOUNDARY. */
322 #define DWARF_ROUND(SIZE,BOUNDARY) \
323 ((((SIZE) + (BOUNDARY) - 1) / (BOUNDARY)) * (BOUNDARY))
325 /* Offsets recorded in opcodes are a multiple of this alignment factor. */
326 #ifndef DWARF_CIE_DATA_ALIGNMENT
327 #ifdef STACK_GROWS_DOWNWARD
328 #define DWARF_CIE_DATA_ALIGNMENT (-((int) UNITS_PER_WORD))
330 #define DWARF_CIE_DATA_ALIGNMENT ((int) UNITS_PER_WORD)
334 /* CIE identifier. */
335 #if HOST_BITS_PER_WIDE_INT >= 64
336 #define DWARF_CIE_ID \
337 (unsigned HOST_WIDE_INT) (DWARF_OFFSET_SIZE == 4 ? DW_CIE_ID : DW64_CIE_ID)
339 #define DWARF_CIE_ID DW_CIE_ID
342 /* A pointer to the base of a table that contains frame description
343 information for each routine. */
344 static GTY((length ("fde_table_allocated"))) dw_fde_ref fde_table
;
346 /* Number of elements currently allocated for fde_table. */
347 static GTY(()) unsigned fde_table_allocated
;
349 /* Number of elements in fde_table currently in use. */
350 static GTY(()) unsigned fde_table_in_use
;
352 /* Size (in elements) of increments by which we may expand the
354 #define FDE_TABLE_INCREMENT 256
356 /* Get the current fde_table entry we should use. */
358 static inline dw_fde_ref
361 return fde_table_in_use
? &fde_table
[fde_table_in_use
- 1] : NULL
;
364 /* A list of call frame insns for the CIE. */
365 static GTY(()) dw_cfi_ref cie_cfi_head
;
367 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
368 /* Some DWARF extensions (e.g., MIPS/SGI) implement a subprogram
369 attribute that accelerates the lookup of the FDE associated
370 with the subprogram. This variable holds the table index of the FDE
371 associated with the current function (body) definition. */
372 static unsigned current_funcdef_fde
;
375 struct GTY(()) indirect_string_node
{
377 unsigned int refcount
;
382 static GTY ((param_is (struct indirect_string_node
))) htab_t debug_str_hash
;
384 static GTY(()) int dw2_string_counter
;
385 static GTY(()) unsigned long dwarf2out_cfi_label_num
;
387 /* True if the compilation unit places functions in more than one section. */
388 static GTY(()) bool have_multiple_function_sections
= false;
390 /* Whether the default text and cold text sections have been used at all. */
392 static GTY(()) bool text_section_used
= false;
393 static GTY(()) bool cold_text_section_used
= false;
395 /* The default cold text section. */
396 static GTY(()) section
*cold_text_section
;
398 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
400 /* Forward declarations for functions defined in this file. */
402 static char *stripattributes (const char *);
403 static const char *dwarf_cfi_name (unsigned);
404 static dw_cfi_ref
new_cfi (void);
405 static void add_cfi (dw_cfi_ref
*, dw_cfi_ref
);
406 static void add_fde_cfi (const char *, dw_cfi_ref
);
407 static void lookup_cfa_1 (dw_cfi_ref
, dw_cfa_location
*);
408 static void lookup_cfa (dw_cfa_location
*);
409 static void reg_save (const char *, unsigned, unsigned, HOST_WIDE_INT
);
410 #ifdef DWARF2_UNWIND_INFO
411 static void initial_return_save (rtx
);
413 static HOST_WIDE_INT
stack_adjust_offset (const_rtx
, HOST_WIDE_INT
,
415 static void output_cfi (dw_cfi_ref
, dw_fde_ref
, int);
416 static void output_cfi_directive (dw_cfi_ref
);
417 static void output_call_frame_info (int);
418 static void dwarf2out_note_section_used (void);
419 static void dwarf2out_stack_adjust (rtx
, bool);
420 static void dwarf2out_args_size_adjust (HOST_WIDE_INT
, const char *);
421 static void flush_queued_reg_saves (void);
422 static bool clobbers_queued_reg_save (const_rtx
);
423 static void dwarf2out_frame_debug_expr (rtx
, const char *);
425 /* Support for complex CFA locations. */
426 static void output_cfa_loc (dw_cfi_ref
);
427 static void output_cfa_loc_raw (dw_cfi_ref
);
428 static void get_cfa_from_loc_descr (dw_cfa_location
*,
429 struct dw_loc_descr_struct
*);
430 static struct dw_loc_descr_struct
*build_cfa_loc
431 (dw_cfa_location
*, HOST_WIDE_INT
);
432 static struct dw_loc_descr_struct
*build_cfa_aligned_loc
433 (HOST_WIDE_INT
, HOST_WIDE_INT
);
434 static void def_cfa_1 (const char *, dw_cfa_location
*);
436 /* How to start an assembler comment. */
437 #ifndef ASM_COMMENT_START
438 #define ASM_COMMENT_START ";#"
441 /* Data and reference forms for relocatable data. */
442 #define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
443 #define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
445 #ifndef DEBUG_FRAME_SECTION
446 #define DEBUG_FRAME_SECTION ".debug_frame"
449 #ifndef FUNC_BEGIN_LABEL
450 #define FUNC_BEGIN_LABEL "LFB"
453 #ifndef FUNC_END_LABEL
454 #define FUNC_END_LABEL "LFE"
457 #ifndef FRAME_BEGIN_LABEL
458 #define FRAME_BEGIN_LABEL "Lframe"
460 #define CIE_AFTER_SIZE_LABEL "LSCIE"
461 #define CIE_END_LABEL "LECIE"
462 #define FDE_LABEL "LSFDE"
463 #define FDE_AFTER_SIZE_LABEL "LASFDE"
464 #define FDE_END_LABEL "LEFDE"
465 #define LINE_NUMBER_BEGIN_LABEL "LSLT"
466 #define LINE_NUMBER_END_LABEL "LELT"
467 #define LN_PROLOG_AS_LABEL "LASLTP"
468 #define LN_PROLOG_END_LABEL "LELTP"
469 #define DIE_LABEL_PREFIX "DW"
471 /* The DWARF 2 CFA column which tracks the return address. Normally this
472 is the column for PC, or the first column after all of the hard
474 #ifndef DWARF_FRAME_RETURN_COLUMN
476 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (PC_REGNUM)
478 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGISTERS
482 /* The mapping from gcc register number to DWARF 2 CFA column number. By
483 default, we just provide columns for all registers. */
484 #ifndef DWARF_FRAME_REGNUM
485 #define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG)
488 /* Hook used by __throw. */
491 expand_builtin_dwarf_sp_column (void)
493 unsigned int dwarf_regnum
= DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM
);
494 return GEN_INT (DWARF2_FRAME_REG_OUT (dwarf_regnum
, 1));
497 /* Return a pointer to a copy of the section string name S with all
498 attributes stripped off, and an asterisk prepended (for assemble_name). */
501 stripattributes (const char *s
)
503 char *stripped
= XNEWVEC (char, strlen (s
) + 2);
508 while (*s
&& *s
!= ',')
515 /* MEM is a memory reference for the register size table, each element of
516 which has mode MODE. Initialize column C as a return address column. */
519 init_return_column_size (enum machine_mode mode
, rtx mem
, unsigned int c
)
521 HOST_WIDE_INT offset
= c
* GET_MODE_SIZE (mode
);
522 HOST_WIDE_INT size
= GET_MODE_SIZE (Pmode
);
523 emit_move_insn (adjust_address (mem
, mode
, offset
), GEN_INT (size
));
526 /* Generate code to initialize the register size table. */
529 expand_builtin_init_dwarf_reg_sizes (tree address
)
532 enum machine_mode mode
= TYPE_MODE (char_type_node
);
533 rtx addr
= expand_normal (address
);
534 rtx mem
= gen_rtx_MEM (BLKmode
, addr
);
535 bool wrote_return_column
= false;
537 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
539 int rnum
= DWARF2_FRAME_REG_OUT (DWARF_FRAME_REGNUM (i
), 1);
541 if (rnum
< DWARF_FRAME_REGISTERS
)
543 HOST_WIDE_INT offset
= rnum
* GET_MODE_SIZE (mode
);
544 enum machine_mode save_mode
= reg_raw_mode
[i
];
547 if (HARD_REGNO_CALL_PART_CLOBBERED (i
, save_mode
))
548 save_mode
= choose_hard_reg_mode (i
, 1, true);
549 if (DWARF_FRAME_REGNUM (i
) == DWARF_FRAME_RETURN_COLUMN
)
551 if (save_mode
== VOIDmode
)
553 wrote_return_column
= true;
555 size
= GET_MODE_SIZE (save_mode
);
559 emit_move_insn (adjust_address (mem
, mode
, offset
),
560 gen_int_mode (size
, mode
));
564 if (!wrote_return_column
)
565 init_return_column_size (mode
, mem
, DWARF_FRAME_RETURN_COLUMN
);
567 #ifdef DWARF_ALT_FRAME_RETURN_COLUMN
568 init_return_column_size (mode
, mem
, DWARF_ALT_FRAME_RETURN_COLUMN
);
571 targetm
.init_dwarf_reg_sizes_extra (address
);
574 /* Convert a DWARF call frame info. operation to its string name */
577 dwarf_cfi_name (unsigned int cfi_opc
)
581 case DW_CFA_advance_loc
:
582 return "DW_CFA_advance_loc";
584 return "DW_CFA_offset";
586 return "DW_CFA_restore";
590 return "DW_CFA_set_loc";
591 case DW_CFA_advance_loc1
:
592 return "DW_CFA_advance_loc1";
593 case DW_CFA_advance_loc2
:
594 return "DW_CFA_advance_loc2";
595 case DW_CFA_advance_loc4
:
596 return "DW_CFA_advance_loc4";
597 case DW_CFA_offset_extended
:
598 return "DW_CFA_offset_extended";
599 case DW_CFA_restore_extended
:
600 return "DW_CFA_restore_extended";
601 case DW_CFA_undefined
:
602 return "DW_CFA_undefined";
603 case DW_CFA_same_value
:
604 return "DW_CFA_same_value";
605 case DW_CFA_register
:
606 return "DW_CFA_register";
607 case DW_CFA_remember_state
:
608 return "DW_CFA_remember_state";
609 case DW_CFA_restore_state
:
610 return "DW_CFA_restore_state";
612 return "DW_CFA_def_cfa";
613 case DW_CFA_def_cfa_register
:
614 return "DW_CFA_def_cfa_register";
615 case DW_CFA_def_cfa_offset
:
616 return "DW_CFA_def_cfa_offset";
619 case DW_CFA_def_cfa_expression
:
620 return "DW_CFA_def_cfa_expression";
621 case DW_CFA_expression
:
622 return "DW_CFA_expression";
623 case DW_CFA_offset_extended_sf
:
624 return "DW_CFA_offset_extended_sf";
625 case DW_CFA_def_cfa_sf
:
626 return "DW_CFA_def_cfa_sf";
627 case DW_CFA_def_cfa_offset_sf
:
628 return "DW_CFA_def_cfa_offset_sf";
630 /* SGI/MIPS specific */
631 case DW_CFA_MIPS_advance_loc8
:
632 return "DW_CFA_MIPS_advance_loc8";
635 case DW_CFA_GNU_window_save
:
636 return "DW_CFA_GNU_window_save";
637 case DW_CFA_GNU_args_size
:
638 return "DW_CFA_GNU_args_size";
639 case DW_CFA_GNU_negative_offset_extended
:
640 return "DW_CFA_GNU_negative_offset_extended";
643 return "DW_CFA_<unknown>";
647 /* Return a pointer to a newly allocated Call Frame Instruction. */
649 static inline dw_cfi_ref
652 dw_cfi_ref cfi
= GGC_NEW (dw_cfi_node
);
654 cfi
->dw_cfi_next
= NULL
;
655 cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
= 0;
656 cfi
->dw_cfi_oprnd2
.dw_cfi_reg_num
= 0;
661 /* Add a Call Frame Instruction to list of instructions. */
664 add_cfi (dw_cfi_ref
*list_head
, dw_cfi_ref cfi
)
667 dw_fde_ref fde
= current_fde ();
669 /* When DRAP is used, CFA is defined with an expression. Redefine
670 CFA may lead to a different CFA value. */
671 if (fde
&& fde
->drap_reg
!= INVALID_REGNUM
)
672 switch (cfi
->dw_cfi_opc
)
674 case DW_CFA_def_cfa_register
:
675 case DW_CFA_def_cfa_offset
:
676 case DW_CFA_def_cfa_offset_sf
:
678 case DW_CFA_def_cfa_sf
:
685 /* Find the end of the chain. */
686 for (p
= list_head
; (*p
) != NULL
; p
= &(*p
)->dw_cfi_next
)
692 /* Generate a new label for the CFI info to refer to. */
695 dwarf2out_cfi_label (void)
697 static char label
[20];
699 if (dwarf2out_do_cfi_asm ())
701 /* In this case, we will be emitting the asm directive instead of
702 the label, so just return a placeholder to keep the rest of the
704 strcpy (label
, "<do not output>");
708 ASM_GENERATE_INTERNAL_LABEL (label
, "LCFI", dwarf2out_cfi_label_num
++);
709 ASM_OUTPUT_LABEL (asm_out_file
, label
);
715 /* Add CFI to the current fde at the PC value indicated by LABEL if specified,
716 or to the CIE if LABEL is NULL. */
719 add_fde_cfi (const char *label
, dw_cfi_ref cfi
)
721 dw_cfi_ref
*list_head
= &cie_cfi_head
;
723 if (dwarf2out_do_cfi_asm ())
727 output_cfi_directive (cfi
);
729 /* We still have to add the cfi to the list so that
730 lookup_cfa works later on. */
731 list_head
= ¤t_fde ()->dw_fde_cfi
;
733 /* ??? If this is a CFI for the CIE, we don't emit. This
734 assumes that the standard CIE contents that the assembler
735 uses matches the standard CIE contents that the compiler
736 uses. This is probably a bad assumption. I'm not quite
737 sure how to address this for now. */
741 dw_fde_ref fde
= current_fde ();
743 gcc_assert (fde
!= NULL
);
746 label
= dwarf2out_cfi_label ();
748 if (fde
->dw_fde_current_label
== NULL
749 || strcmp (label
, fde
->dw_fde_current_label
) != 0)
753 label
= xstrdup (label
);
755 /* Set the location counter to the new label. */
757 /* If we have a current label, advance from there, otherwise
758 set the location directly using set_loc. */
759 xcfi
->dw_cfi_opc
= fde
->dw_fde_current_label
760 ? DW_CFA_advance_loc4
762 xcfi
->dw_cfi_oprnd1
.dw_cfi_addr
= label
;
763 add_cfi (&fde
->dw_fde_cfi
, xcfi
);
765 fde
->dw_fde_current_label
= label
;
768 list_head
= &fde
->dw_fde_cfi
;
771 add_cfi (list_head
, cfi
);
774 /* Subroutine of lookup_cfa. */
777 lookup_cfa_1 (dw_cfi_ref cfi
, dw_cfa_location
*loc
)
779 switch (cfi
->dw_cfi_opc
)
781 case DW_CFA_def_cfa_offset
:
782 case DW_CFA_def_cfa_offset_sf
:
783 loc
->offset
= cfi
->dw_cfi_oprnd1
.dw_cfi_offset
;
785 case DW_CFA_def_cfa_register
:
786 loc
->reg
= cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
;
789 case DW_CFA_def_cfa_sf
:
790 loc
->reg
= cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
;
791 loc
->offset
= cfi
->dw_cfi_oprnd2
.dw_cfi_offset
;
793 case DW_CFA_def_cfa_expression
:
794 get_cfa_from_loc_descr (loc
, cfi
->dw_cfi_oprnd1
.dw_cfi_loc
);
801 /* Find the previous value for the CFA. */
804 lookup_cfa (dw_cfa_location
*loc
)
809 loc
->reg
= INVALID_REGNUM
;
812 loc
->base_offset
= 0;
814 for (cfi
= cie_cfi_head
; cfi
; cfi
= cfi
->dw_cfi_next
)
815 lookup_cfa_1 (cfi
, loc
);
817 fde
= current_fde ();
819 for (cfi
= fde
->dw_fde_cfi
; cfi
; cfi
= cfi
->dw_cfi_next
)
820 lookup_cfa_1 (cfi
, loc
);
823 /* The current rule for calculating the DWARF2 canonical frame address. */
824 static dw_cfa_location cfa
;
826 /* The register used for saving registers to the stack, and its offset
828 static dw_cfa_location cfa_store
;
830 /* The running total of the size of arguments pushed onto the stack. */
831 static HOST_WIDE_INT args_size
;
833 /* The last args_size we actually output. */
834 static HOST_WIDE_INT old_args_size
;
836 /* Entry point to update the canonical frame address (CFA).
837 LABEL is passed to add_fde_cfi. The value of CFA is now to be
838 calculated from REG+OFFSET. */
841 dwarf2out_def_cfa (const char *label
, unsigned int reg
, HOST_WIDE_INT offset
)
848 def_cfa_1 (label
, &loc
);
851 /* Determine if two dw_cfa_location structures define the same data. */
854 cfa_equal_p (const dw_cfa_location
*loc1
, const dw_cfa_location
*loc2
)
856 return (loc1
->reg
== loc2
->reg
857 && loc1
->offset
== loc2
->offset
858 && loc1
->indirect
== loc2
->indirect
859 && (loc1
->indirect
== 0
860 || loc1
->base_offset
== loc2
->base_offset
));
863 /* This routine does the actual work. The CFA is now calculated from
864 the dw_cfa_location structure. */
867 def_cfa_1 (const char *label
, dw_cfa_location
*loc_p
)
870 dw_cfa_location old_cfa
, loc
;
875 if (cfa_store
.reg
== loc
.reg
&& loc
.indirect
== 0)
876 cfa_store
.offset
= loc
.offset
;
878 loc
.reg
= DWARF_FRAME_REGNUM (loc
.reg
);
879 lookup_cfa (&old_cfa
);
881 /* If nothing changed, no need to issue any call frame instructions. */
882 if (cfa_equal_p (&loc
, &old_cfa
))
887 if (loc
.reg
== old_cfa
.reg
&& !loc
.indirect
)
889 /* Construct a "DW_CFA_def_cfa_offset <offset>" instruction, indicating
890 the CFA register did not change but the offset did. The data
891 factoring for DW_CFA_def_cfa_offset_sf happens in output_cfi, or
892 in the assembler via the .cfi_def_cfa_offset directive. */
894 cfi
->dw_cfi_opc
= DW_CFA_def_cfa_offset_sf
;
896 cfi
->dw_cfi_opc
= DW_CFA_def_cfa_offset
;
897 cfi
->dw_cfi_oprnd1
.dw_cfi_offset
= loc
.offset
;
900 #ifndef MIPS_DEBUGGING_INFO /* SGI dbx thinks this means no offset. */
901 else if (loc
.offset
== old_cfa
.offset
902 && old_cfa
.reg
!= INVALID_REGNUM
905 /* Construct a "DW_CFA_def_cfa_register <register>" instruction,
906 indicating the CFA register has changed to <register> but the
907 offset has not changed. */
908 cfi
->dw_cfi_opc
= DW_CFA_def_cfa_register
;
909 cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
= loc
.reg
;
913 else if (loc
.indirect
== 0)
915 /* Construct a "DW_CFA_def_cfa <register> <offset>" instruction,
916 indicating the CFA register has changed to <register> with
917 the specified offset. The data factoring for DW_CFA_def_cfa_sf
918 happens in output_cfi, or in the assembler via the .cfi_def_cfa
921 cfi
->dw_cfi_opc
= DW_CFA_def_cfa_sf
;
923 cfi
->dw_cfi_opc
= DW_CFA_def_cfa
;
924 cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
= loc
.reg
;
925 cfi
->dw_cfi_oprnd2
.dw_cfi_offset
= loc
.offset
;
929 /* Construct a DW_CFA_def_cfa_expression instruction to
930 calculate the CFA using a full location expression since no
931 register-offset pair is available. */
932 struct dw_loc_descr_struct
*loc_list
;
934 cfi
->dw_cfi_opc
= DW_CFA_def_cfa_expression
;
935 loc_list
= build_cfa_loc (&loc
, 0);
936 cfi
->dw_cfi_oprnd1
.dw_cfi_loc
= loc_list
;
939 add_fde_cfi (label
, cfi
);
942 /* Add the CFI for saving a register. REG is the CFA column number.
943 LABEL is passed to add_fde_cfi.
944 If SREG is -1, the register is saved at OFFSET from the CFA;
945 otherwise it is saved in SREG. */
948 reg_save (const char *label
, unsigned int reg
, unsigned int sreg
, HOST_WIDE_INT offset
)
950 dw_cfi_ref cfi
= new_cfi ();
951 dw_fde_ref fde
= current_fde ();
953 cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
= reg
;
955 /* When stack is aligned, store REG using DW_CFA_expression with
958 && fde
->stack_realign
959 && sreg
== INVALID_REGNUM
)
961 cfi
->dw_cfi_opc
= DW_CFA_expression
;
962 cfi
->dw_cfi_oprnd2
.dw_cfi_reg_num
= reg
;
963 cfi
->dw_cfi_oprnd1
.dw_cfi_loc
964 = build_cfa_aligned_loc (offset
, fde
->stack_realignment
);
966 else if (sreg
== INVALID_REGNUM
)
969 cfi
->dw_cfi_opc
= DW_CFA_offset_extended_sf
;
970 else if (reg
& ~0x3f)
971 cfi
->dw_cfi_opc
= DW_CFA_offset_extended
;
973 cfi
->dw_cfi_opc
= DW_CFA_offset
;
974 cfi
->dw_cfi_oprnd2
.dw_cfi_offset
= offset
;
976 else if (sreg
== reg
)
977 cfi
->dw_cfi_opc
= DW_CFA_same_value
;
980 cfi
->dw_cfi_opc
= DW_CFA_register
;
981 cfi
->dw_cfi_oprnd2
.dw_cfi_reg_num
= sreg
;
984 add_fde_cfi (label
, cfi
);
987 /* Add the CFI for saving a register window. LABEL is passed to reg_save.
988 This CFI tells the unwinder that it needs to restore the window registers
989 from the previous frame's window save area.
991 ??? Perhaps we should note in the CIE where windows are saved (instead of
992 assuming 0(cfa)) and what registers are in the window. */
995 dwarf2out_window_save (const char *label
)
997 dw_cfi_ref cfi
= new_cfi ();
999 cfi
->dw_cfi_opc
= DW_CFA_GNU_window_save
;
1000 add_fde_cfi (label
, cfi
);
1003 /* Add a CFI to update the running total of the size of arguments
1004 pushed onto the stack. */
1007 dwarf2out_args_size (const char *label
, HOST_WIDE_INT size
)
1011 if (size
== old_args_size
)
1014 old_args_size
= size
;
1017 cfi
->dw_cfi_opc
= DW_CFA_GNU_args_size
;
1018 cfi
->dw_cfi_oprnd1
.dw_cfi_offset
= size
;
1019 add_fde_cfi (label
, cfi
);
1022 /* Entry point for saving a register to the stack. REG is the GCC register
1023 number. LABEL and OFFSET are passed to reg_save. */
1026 dwarf2out_reg_save (const char *label
, unsigned int reg
, HOST_WIDE_INT offset
)
1028 reg_save (label
, DWARF_FRAME_REGNUM (reg
), INVALID_REGNUM
, offset
);
1031 /* Entry point for saving the return address in the stack.
1032 LABEL and OFFSET are passed to reg_save. */
1035 dwarf2out_return_save (const char *label
, HOST_WIDE_INT offset
)
1037 reg_save (label
, DWARF_FRAME_RETURN_COLUMN
, INVALID_REGNUM
, offset
);
1040 /* Entry point for saving the return address in a register.
1041 LABEL and SREG are passed to reg_save. */
1044 dwarf2out_return_reg (const char *label
, unsigned int sreg
)
1046 reg_save (label
, DWARF_FRAME_RETURN_COLUMN
, DWARF_FRAME_REGNUM (sreg
), 0);
1049 #ifdef DWARF2_UNWIND_INFO
1050 /* Record the initial position of the return address. RTL is
1051 INCOMING_RETURN_ADDR_RTX. */
1054 initial_return_save (rtx rtl
)
1056 unsigned int reg
= INVALID_REGNUM
;
1057 HOST_WIDE_INT offset
= 0;
1059 switch (GET_CODE (rtl
))
1062 /* RA is in a register. */
1063 reg
= DWARF_FRAME_REGNUM (REGNO (rtl
));
1067 /* RA is on the stack. */
1068 rtl
= XEXP (rtl
, 0);
1069 switch (GET_CODE (rtl
))
1072 gcc_assert (REGNO (rtl
) == STACK_POINTER_REGNUM
);
1077 gcc_assert (REGNO (XEXP (rtl
, 0)) == STACK_POINTER_REGNUM
);
1078 offset
= INTVAL (XEXP (rtl
, 1));
1082 gcc_assert (REGNO (XEXP (rtl
, 0)) == STACK_POINTER_REGNUM
);
1083 offset
= -INTVAL (XEXP (rtl
, 1));
1093 /* The return address is at some offset from any value we can
1094 actually load. For instance, on the SPARC it is in %i7+8. Just
1095 ignore the offset for now; it doesn't matter for unwinding frames. */
1096 gcc_assert (GET_CODE (XEXP (rtl
, 1)) == CONST_INT
);
1097 initial_return_save (XEXP (rtl
, 0));
1104 if (reg
!= DWARF_FRAME_RETURN_COLUMN
)
1105 reg_save (NULL
, DWARF_FRAME_RETURN_COLUMN
, reg
, offset
- cfa
.offset
);
1109 /* Given a SET, calculate the amount of stack adjustment it
1112 static HOST_WIDE_INT
1113 stack_adjust_offset (const_rtx pattern
, HOST_WIDE_INT cur_args_size
,
1114 HOST_WIDE_INT cur_offset
)
1116 const_rtx src
= SET_SRC (pattern
);
1117 const_rtx dest
= SET_DEST (pattern
);
1118 HOST_WIDE_INT offset
= 0;
1121 if (dest
== stack_pointer_rtx
)
1123 code
= GET_CODE (src
);
1125 /* Assume (set (reg sp) (reg whatever)) sets args_size
1127 if (code
== REG
&& src
!= stack_pointer_rtx
)
1129 offset
= -cur_args_size
;
1130 #ifndef STACK_GROWS_DOWNWARD
1133 return offset
- cur_offset
;
1136 if (! (code
== PLUS
|| code
== MINUS
)
1137 || XEXP (src
, 0) != stack_pointer_rtx
1138 || GET_CODE (XEXP (src
, 1)) != CONST_INT
)
1141 /* (set (reg sp) (plus (reg sp) (const_int))) */
1142 offset
= INTVAL (XEXP (src
, 1));
1148 if (MEM_P (src
) && !MEM_P (dest
))
1152 /* (set (mem (pre_dec (reg sp))) (foo)) */
1153 src
= XEXP (dest
, 0);
1154 code
= GET_CODE (src
);
1160 if (XEXP (src
, 0) == stack_pointer_rtx
)
1162 rtx val
= XEXP (XEXP (src
, 1), 1);
1163 /* We handle only adjustments by constant amount. */
1164 gcc_assert (GET_CODE (XEXP (src
, 1)) == PLUS
1165 && GET_CODE (val
) == CONST_INT
);
1166 offset
= -INTVAL (val
);
1173 if (XEXP (src
, 0) == stack_pointer_rtx
)
1175 offset
= GET_MODE_SIZE (GET_MODE (dest
));
1182 if (XEXP (src
, 0) == stack_pointer_rtx
)
1184 offset
= -GET_MODE_SIZE (GET_MODE (dest
));
1199 /* Precomputed args_size for CODE_LABELs and BARRIERs preceeding them,
1200 indexed by INSN_UID. */
1202 static HOST_WIDE_INT
*barrier_args_size
;
1204 /* Helper function for compute_barrier_args_size. Handle one insn. */
1206 static HOST_WIDE_INT
1207 compute_barrier_args_size_1 (rtx insn
, HOST_WIDE_INT cur_args_size
,
1208 VEC (rtx
, heap
) **next
)
1210 HOST_WIDE_INT offset
= 0;
1213 if (! RTX_FRAME_RELATED_P (insn
))
1215 if (prologue_epilogue_contains (insn
)
1216 || sibcall_epilogue_contains (insn
))
1218 else if (GET_CODE (PATTERN (insn
)) == SET
)
1219 offset
= stack_adjust_offset (PATTERN (insn
), cur_args_size
, 0);
1220 else if (GET_CODE (PATTERN (insn
)) == PARALLEL
1221 || GET_CODE (PATTERN (insn
)) == SEQUENCE
)
1223 /* There may be stack adjustments inside compound insns. Search
1225 for (i
= XVECLEN (PATTERN (insn
), 0) - 1; i
>= 0; i
--)
1226 if (GET_CODE (XVECEXP (PATTERN (insn
), 0, i
)) == SET
)
1227 offset
+= stack_adjust_offset (XVECEXP (PATTERN (insn
), 0, i
),
1228 cur_args_size
, offset
);
1233 rtx expr
= find_reg_note (insn
, REG_FRAME_RELATED_EXPR
, NULL_RTX
);
1237 expr
= XEXP (expr
, 0);
1238 if (GET_CODE (expr
) == PARALLEL
1239 || GET_CODE (expr
) == SEQUENCE
)
1240 for (i
= 1; i
< XVECLEN (expr
, 0); i
++)
1242 rtx elem
= XVECEXP (expr
, 0, i
);
1244 if (GET_CODE (elem
) == SET
&& !RTX_FRAME_RELATED_P (elem
))
1245 offset
+= stack_adjust_offset (elem
, cur_args_size
, offset
);
1250 #ifndef STACK_GROWS_DOWNWARD
1254 cur_args_size
+= offset
;
1255 if (cur_args_size
< 0)
1260 rtx dest
= JUMP_LABEL (insn
);
1264 if (barrier_args_size
[INSN_UID (dest
)] < 0)
1266 barrier_args_size
[INSN_UID (dest
)] = cur_args_size
;
1267 VEC_safe_push (rtx
, heap
, *next
, dest
);
1272 return cur_args_size
;
1275 /* Walk the whole function and compute args_size on BARRIERs. */
1278 compute_barrier_args_size (void)
1280 int max_uid
= get_max_uid (), i
;
1282 VEC (rtx
, heap
) *worklist
, *next
, *tmp
;
1284 barrier_args_size
= XNEWVEC (HOST_WIDE_INT
, max_uid
);
1285 for (i
= 0; i
< max_uid
; i
++)
1286 barrier_args_size
[i
] = -1;
1288 worklist
= VEC_alloc (rtx
, heap
, 20);
1289 next
= VEC_alloc (rtx
, heap
, 20);
1290 insn
= get_insns ();
1291 barrier_args_size
[INSN_UID (insn
)] = 0;
1292 VEC_quick_push (rtx
, worklist
, insn
);
1295 while (!VEC_empty (rtx
, worklist
))
1297 rtx prev
, body
, first_insn
;
1298 HOST_WIDE_INT cur_args_size
;
1300 first_insn
= insn
= VEC_pop (rtx
, worklist
);
1301 cur_args_size
= barrier_args_size
[INSN_UID (insn
)];
1302 prev
= prev_nonnote_insn (insn
);
1303 if (prev
&& BARRIER_P (prev
))
1304 barrier_args_size
[INSN_UID (prev
)] = cur_args_size
;
1306 for (; insn
; insn
= NEXT_INSN (insn
))
1308 if (INSN_DELETED_P (insn
) || NOTE_P (insn
))
1310 if (BARRIER_P (insn
))
1315 if (insn
== first_insn
)
1317 else if (barrier_args_size
[INSN_UID (insn
)] < 0)
1319 barrier_args_size
[INSN_UID (insn
)] = cur_args_size
;
1324 /* The insns starting with this label have been
1325 already scanned or are in the worklist. */
1330 body
= PATTERN (insn
);
1331 if (GET_CODE (body
) == SEQUENCE
)
1333 HOST_WIDE_INT dest_args_size
= cur_args_size
;
1334 for (i
= 1; i
< XVECLEN (body
, 0); i
++)
1335 if (INSN_ANNULLED_BRANCH_P (XVECEXP (body
, 0, 0))
1336 && INSN_FROM_TARGET_P (XVECEXP (body
, 0, i
)))
1338 = compute_barrier_args_size_1 (XVECEXP (body
, 0, i
),
1339 dest_args_size
, &next
);
1342 = compute_barrier_args_size_1 (XVECEXP (body
, 0, i
),
1343 cur_args_size
, &next
);
1345 if (INSN_ANNULLED_BRANCH_P (XVECEXP (body
, 0, 0)))
1346 compute_barrier_args_size_1 (XVECEXP (body
, 0, 0),
1347 dest_args_size
, &next
);
1350 = compute_barrier_args_size_1 (XVECEXP (body
, 0, 0),
1351 cur_args_size
, &next
);
1355 = compute_barrier_args_size_1 (insn
, cur_args_size
, &next
);
1359 if (VEC_empty (rtx
, next
))
1362 /* Swap WORKLIST with NEXT and truncate NEXT for next iteration. */
1366 VEC_truncate (rtx
, next
, 0);
1369 VEC_free (rtx
, heap
, worklist
);
1370 VEC_free (rtx
, heap
, next
);
1374 /* Check INSN to see if it looks like a push or a stack adjustment, and
1375 make a note of it if it does. EH uses this information to find out how
1376 much extra space it needs to pop off the stack. */
1379 dwarf2out_stack_adjust (rtx insn
, bool after_p
)
1381 HOST_WIDE_INT offset
;
1385 /* Don't handle epilogues at all. Certainly it would be wrong to do so
1386 with this function. Proper support would require all frame-related
1387 insns to be marked, and to be able to handle saving state around
1388 epilogues textually in the middle of the function. */
1389 if (prologue_epilogue_contains (insn
) || sibcall_epilogue_contains (insn
))
1392 /* If INSN is an instruction from target of an annulled branch, the
1393 effects are for the target only and so current argument size
1394 shouldn't change at all. */
1396 && INSN_ANNULLED_BRANCH_P (XVECEXP (final_sequence
, 0, 0))
1397 && INSN_FROM_TARGET_P (insn
))
1400 /* If only calls can throw, and we have a frame pointer,
1401 save up adjustments until we see the CALL_INSN. */
1402 if (!flag_asynchronous_unwind_tables
&& cfa
.reg
!= STACK_POINTER_REGNUM
)
1404 if (CALL_P (insn
) && !after_p
)
1406 /* Extract the size of the args from the CALL rtx itself. */
1407 insn
= PATTERN (insn
);
1408 if (GET_CODE (insn
) == PARALLEL
)
1409 insn
= XVECEXP (insn
, 0, 0);
1410 if (GET_CODE (insn
) == SET
)
1411 insn
= SET_SRC (insn
);
1412 gcc_assert (GET_CODE (insn
) == CALL
);
1413 dwarf2out_args_size ("", INTVAL (XEXP (insn
, 1)));
1418 if (CALL_P (insn
) && !after_p
)
1420 if (!flag_asynchronous_unwind_tables
)
1421 dwarf2out_args_size ("", args_size
);
1424 else if (BARRIER_P (insn
))
1426 /* Don't call compute_barrier_args_size () if the only
1427 BARRIER is at the end of function. */
1428 if (barrier_args_size
== NULL
&& next_nonnote_insn (insn
))
1429 compute_barrier_args_size ();
1430 if (barrier_args_size
== NULL
)
1434 offset
= barrier_args_size
[INSN_UID (insn
)];
1439 offset
-= args_size
;
1440 #ifndef STACK_GROWS_DOWNWARD
1444 else if (GET_CODE (PATTERN (insn
)) == SET
)
1445 offset
= stack_adjust_offset (PATTERN (insn
), args_size
, 0);
1446 else if (GET_CODE (PATTERN (insn
)) == PARALLEL
1447 || GET_CODE (PATTERN (insn
)) == SEQUENCE
)
1449 /* There may be stack adjustments inside compound insns. Search
1451 for (offset
= 0, i
= XVECLEN (PATTERN (insn
), 0) - 1; i
>= 0; i
--)
1452 if (GET_CODE (XVECEXP (PATTERN (insn
), 0, i
)) == SET
)
1453 offset
+= stack_adjust_offset (XVECEXP (PATTERN (insn
), 0, i
),
1462 label
= dwarf2out_cfi_label ();
1463 dwarf2out_args_size_adjust (offset
, label
);
1466 /* Adjust args_size based on stack adjustment OFFSET. */
1469 dwarf2out_args_size_adjust (HOST_WIDE_INT offset
, const char *label
)
1471 if (cfa
.reg
== STACK_POINTER_REGNUM
)
1472 cfa
.offset
+= offset
;
1474 if (cfa_store
.reg
== STACK_POINTER_REGNUM
)
1475 cfa_store
.offset
+= offset
;
1477 #ifndef STACK_GROWS_DOWNWARD
1481 args_size
+= offset
;
1485 def_cfa_1 (label
, &cfa
);
1486 if (flag_asynchronous_unwind_tables
)
1487 dwarf2out_args_size (label
, args_size
);
1492 /* We delay emitting a register save until either (a) we reach the end
1493 of the prologue or (b) the register is clobbered. This clusters
1494 register saves so that there are fewer pc advances. */
1496 struct GTY(()) queued_reg_save
{
1497 struct queued_reg_save
*next
;
1499 HOST_WIDE_INT cfa_offset
;
1503 static GTY(()) struct queued_reg_save
*queued_reg_saves
;
1505 /* The caller's ORIG_REG is saved in SAVED_IN_REG. */
1506 struct GTY(()) reg_saved_in_data
{
1511 /* A list of registers saved in other registers.
1512 The list intentionally has a small maximum capacity of 4; if your
1513 port needs more than that, you might consider implementing a
1514 more efficient data structure. */
1515 static GTY(()) struct reg_saved_in_data regs_saved_in_regs
[4];
1516 static GTY(()) size_t num_regs_saved_in_regs
;
1518 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
1519 static const char *last_reg_save_label
;
1521 /* Add an entry to QUEUED_REG_SAVES saying that REG is now saved at
1522 SREG, or if SREG is NULL then it is saved at OFFSET to the CFA. */
1525 queue_reg_save (const char *label
, rtx reg
, rtx sreg
, HOST_WIDE_INT offset
)
1527 struct queued_reg_save
*q
;
1529 /* Duplicates waste space, but it's also necessary to remove them
1530 for correctness, since the queue gets output in reverse
1532 for (q
= queued_reg_saves
; q
!= NULL
; q
= q
->next
)
1533 if (REGNO (q
->reg
) == REGNO (reg
))
1538 q
= GGC_NEW (struct queued_reg_save
);
1539 q
->next
= queued_reg_saves
;
1540 queued_reg_saves
= q
;
1544 q
->cfa_offset
= offset
;
1545 q
->saved_reg
= sreg
;
1547 last_reg_save_label
= label
;
1550 /* Output all the entries in QUEUED_REG_SAVES. */
1553 flush_queued_reg_saves (void)
1555 struct queued_reg_save
*q
;
1557 for (q
= queued_reg_saves
; q
; q
= q
->next
)
1560 unsigned int reg
, sreg
;
1562 for (i
= 0; i
< num_regs_saved_in_regs
; i
++)
1563 if (REGNO (regs_saved_in_regs
[i
].orig_reg
) == REGNO (q
->reg
))
1565 if (q
->saved_reg
&& i
== num_regs_saved_in_regs
)
1567 gcc_assert (i
!= ARRAY_SIZE (regs_saved_in_regs
));
1568 num_regs_saved_in_regs
++;
1570 if (i
!= num_regs_saved_in_regs
)
1572 regs_saved_in_regs
[i
].orig_reg
= q
->reg
;
1573 regs_saved_in_regs
[i
].saved_in_reg
= q
->saved_reg
;
1576 reg
= DWARF_FRAME_REGNUM (REGNO (q
->reg
));
1578 sreg
= DWARF_FRAME_REGNUM (REGNO (q
->saved_reg
));
1580 sreg
= INVALID_REGNUM
;
1581 reg_save (last_reg_save_label
, reg
, sreg
, q
->cfa_offset
);
1584 queued_reg_saves
= NULL
;
1585 last_reg_save_label
= NULL
;
1588 /* Does INSN clobber any register which QUEUED_REG_SAVES lists a saved
1589 location for? Or, does it clobber a register which we've previously
1590 said that some other register is saved in, and for which we now
1591 have a new location for? */
1594 clobbers_queued_reg_save (const_rtx insn
)
1596 struct queued_reg_save
*q
;
1598 for (q
= queued_reg_saves
; q
; q
= q
->next
)
1601 if (modified_in_p (q
->reg
, insn
))
1603 for (i
= 0; i
< num_regs_saved_in_regs
; i
++)
1604 if (REGNO (q
->reg
) == REGNO (regs_saved_in_regs
[i
].orig_reg
)
1605 && modified_in_p (regs_saved_in_regs
[i
].saved_in_reg
, insn
))
1612 /* Entry point for saving the first register into the second. */
1615 dwarf2out_reg_save_reg (const char *label
, rtx reg
, rtx sreg
)
1618 unsigned int regno
, sregno
;
1620 for (i
= 0; i
< num_regs_saved_in_regs
; i
++)
1621 if (REGNO (regs_saved_in_regs
[i
].orig_reg
) == REGNO (reg
))
1623 if (i
== num_regs_saved_in_regs
)
1625 gcc_assert (i
!= ARRAY_SIZE (regs_saved_in_regs
));
1626 num_regs_saved_in_regs
++;
1628 regs_saved_in_regs
[i
].orig_reg
= reg
;
1629 regs_saved_in_regs
[i
].saved_in_reg
= sreg
;
1631 regno
= DWARF_FRAME_REGNUM (REGNO (reg
));
1632 sregno
= DWARF_FRAME_REGNUM (REGNO (sreg
));
1633 reg_save (label
, regno
, sregno
, 0);
1636 /* What register, if any, is currently saved in REG? */
1639 reg_saved_in (rtx reg
)
1641 unsigned int regn
= REGNO (reg
);
1643 struct queued_reg_save
*q
;
1645 for (q
= queued_reg_saves
; q
; q
= q
->next
)
1646 if (q
->saved_reg
&& regn
== REGNO (q
->saved_reg
))
1649 for (i
= 0; i
< num_regs_saved_in_regs
; i
++)
1650 if (regs_saved_in_regs
[i
].saved_in_reg
1651 && regn
== REGNO (regs_saved_in_regs
[i
].saved_in_reg
))
1652 return regs_saved_in_regs
[i
].orig_reg
;
1658 /* A temporary register holding an integral value used in adjusting SP
1659 or setting up the store_reg. The "offset" field holds the integer
1660 value, not an offset. */
1661 static dw_cfa_location cfa_temp
;
1663 /* Record call frame debugging information for an expression EXPR,
1664 which either sets SP or FP (adjusting how we calculate the frame
1665 address) or saves a register to the stack or another register.
1666 LABEL indicates the address of EXPR.
1668 This function encodes a state machine mapping rtxes to actions on
1669 cfa, cfa_store, and cfa_temp.reg. We describe these rules so
1670 users need not read the source code.
1672 The High-Level Picture
1674 Changes in the register we use to calculate the CFA: Currently we
1675 assume that if you copy the CFA register into another register, we
1676 should take the other one as the new CFA register; this seems to
1677 work pretty well. If it's wrong for some target, it's simple
1678 enough not to set RTX_FRAME_RELATED_P on the insn in question.
1680 Changes in the register we use for saving registers to the stack:
1681 This is usually SP, but not always. Again, we deduce that if you
1682 copy SP into another register (and SP is not the CFA register),
1683 then the new register is the one we will be using for register
1684 saves. This also seems to work.
1686 Register saves: There's not much guesswork about this one; if
1687 RTX_FRAME_RELATED_P is set on an insn which modifies memory, it's a
1688 register save, and the register used to calculate the destination
1689 had better be the one we think we're using for this purpose.
1690 It's also assumed that a copy from a call-saved register to another
1691 register is saving that register if RTX_FRAME_RELATED_P is set on
1692 that instruction. If the copy is from a call-saved register to
1693 the *same* register, that means that the register is now the same
1694 value as in the caller.
1696 Except: If the register being saved is the CFA register, and the
1697 offset is nonzero, we are saving the CFA, so we assume we have to
1698 use DW_CFA_def_cfa_expression. If the offset is 0, we assume that
1699 the intent is to save the value of SP from the previous frame.
1701 In addition, if a register has previously been saved to a different
1704 Invariants / Summaries of Rules
1706 cfa current rule for calculating the CFA. It usually
1707 consists of a register and an offset.
1708 cfa_store register used by prologue code to save things to the stack
1709 cfa_store.offset is the offset from the value of
1710 cfa_store.reg to the actual CFA
1711 cfa_temp register holding an integral value. cfa_temp.offset
1712 stores the value, which will be used to adjust the
1713 stack pointer. cfa_temp is also used like cfa_store,
1714 to track stores to the stack via fp or a temp reg.
1716 Rules 1- 4: Setting a register's value to cfa.reg or an expression
1717 with cfa.reg as the first operand changes the cfa.reg and its
1718 cfa.offset. Rule 1 and 4 also set cfa_temp.reg and
1721 Rules 6- 9: Set a non-cfa.reg register value to a constant or an
1722 expression yielding a constant. This sets cfa_temp.reg
1723 and cfa_temp.offset.
1725 Rule 5: Create a new register cfa_store used to save items to the
1728 Rules 10-14: Save a register to the stack. Define offset as the
1729 difference of the original location and cfa_store's
1730 location (or cfa_temp's location if cfa_temp is used).
1732 Rules 16-20: If AND operation happens on sp in prologue, we assume
1733 stack is realigned. We will use a group of DW_OP_XXX
1734 expressions to represent the location of the stored
1735 register instead of CFA+offset.
1739 "{a,b}" indicates a choice of a xor b.
1740 "<reg>:cfa.reg" indicates that <reg> must equal cfa.reg.
1743 (set <reg1> <reg2>:cfa.reg)
1744 effects: cfa.reg = <reg1>
1745 cfa.offset unchanged
1746 cfa_temp.reg = <reg1>
1747 cfa_temp.offset = cfa.offset
1750 (set sp ({minus,plus,losum} {sp,fp}:cfa.reg
1751 {<const_int>,<reg>:cfa_temp.reg}))
1752 effects: cfa.reg = sp if fp used
1753 cfa.offset += {+/- <const_int>, cfa_temp.offset} if cfa.reg==sp
1754 cfa_store.offset += {+/- <const_int>, cfa_temp.offset}
1755 if cfa_store.reg==sp
1758 (set fp ({minus,plus,losum} <reg>:cfa.reg <const_int>))
1759 effects: cfa.reg = fp
1760 cfa_offset += +/- <const_int>
1763 (set <reg1> ({plus,losum} <reg2>:cfa.reg <const_int>))
1764 constraints: <reg1> != fp
1766 effects: cfa.reg = <reg1>
1767 cfa_temp.reg = <reg1>
1768 cfa_temp.offset = cfa.offset
1771 (set <reg1> (plus <reg2>:cfa_temp.reg sp:cfa.reg))
1772 constraints: <reg1> != fp
1774 effects: cfa_store.reg = <reg1>
1775 cfa_store.offset = cfa.offset - cfa_temp.offset
1778 (set <reg> <const_int>)
1779 effects: cfa_temp.reg = <reg>
1780 cfa_temp.offset = <const_int>
1783 (set <reg1>:cfa_temp.reg (ior <reg2>:cfa_temp.reg <const_int>))
1784 effects: cfa_temp.reg = <reg1>
1785 cfa_temp.offset |= <const_int>
1788 (set <reg> (high <exp>))
1792 (set <reg> (lo_sum <exp> <const_int>))
1793 effects: cfa_temp.reg = <reg>
1794 cfa_temp.offset = <const_int>
1797 (set (mem (pre_modify sp:cfa_store (???? <reg1> <const_int>))) <reg2>)
1798 effects: cfa_store.offset -= <const_int>
1799 cfa.offset = cfa_store.offset if cfa.reg == sp
1801 cfa.base_offset = -cfa_store.offset
1804 (set (mem ({pre_inc,pre_dec} sp:cfa_store.reg)) <reg>)
1805 effects: cfa_store.offset += -/+ mode_size(mem)
1806 cfa.offset = cfa_store.offset if cfa.reg == sp
1808 cfa.base_offset = -cfa_store.offset
1811 (set (mem ({minus,plus,losum} <reg1>:{cfa_store,cfa_temp} <const_int>))
1814 effects: cfa.reg = <reg1>
1815 cfa.base_offset = -/+ <const_int> - {cfa_store,cfa_temp}.offset
1818 (set (mem <reg1>:{cfa_store,cfa_temp}) <reg2>)
1819 effects: cfa.reg = <reg1>
1820 cfa.base_offset = -{cfa_store,cfa_temp}.offset
1823 (set (mem (postinc <reg1>:cfa_temp <const_int>)) <reg2>)
1824 effects: cfa.reg = <reg1>
1825 cfa.base_offset = -cfa_temp.offset
1826 cfa_temp.offset -= mode_size(mem)
1829 (set <reg> {unspec, unspec_volatile})
1830 effects: target-dependent
1833 (set sp (and: sp <const_int>))
1834 constraints: cfa_store.reg == sp
1835 effects: current_fde.stack_realign = 1
1836 cfa_store.offset = 0
1837 fde->drap_reg = cfa.reg if cfa.reg != sp and cfa.reg != fp
1840 (set (mem ({pre_inc, pre_dec} sp)) (mem (plus (cfa.reg) (const_int))))
1841 effects: cfa_store.offset += -/+ mode_size(mem)
1844 (set (mem ({pre_inc, pre_dec} sp)) fp)
1845 constraints: fde->stack_realign == 1
1846 effects: cfa_store.offset = 0
1847 cfa.reg != HARD_FRAME_POINTER_REGNUM
1850 (set (mem ({pre_inc, pre_dec} sp)) cfa.reg)
1851 constraints: fde->stack_realign == 1
1853 && cfa.indirect == 0
1854 && cfa.reg != HARD_FRAME_POINTER_REGNUM
1855 effects: Use DW_CFA_def_cfa_expression to define cfa
1856 cfa.reg == fde->drap_reg
1859 (set reg fde->drap_reg)
1860 constraints: fde->vdrap_reg == INVALID_REGNUM
1861 effects: fde->vdrap_reg = reg.
1862 (set mem fde->drap_reg)
1863 constraints: fde->drap_reg_saved == 1
1867 dwarf2out_frame_debug_expr (rtx expr
, const char *label
)
1869 rtx src
, dest
, span
;
1870 HOST_WIDE_INT offset
;
1873 /* If RTX_FRAME_RELATED_P is set on a PARALLEL, process each member of
1874 the PARALLEL independently. The first element is always processed if
1875 it is a SET. This is for backward compatibility. Other elements
1876 are processed only if they are SETs and the RTX_FRAME_RELATED_P
1877 flag is set in them. */
1878 if (GET_CODE (expr
) == PARALLEL
|| GET_CODE (expr
) == SEQUENCE
)
1881 int limit
= XVECLEN (expr
, 0);
1884 /* PARALLELs have strict read-modify-write semantics, so we
1885 ought to evaluate every rvalue before changing any lvalue.
1886 It's cumbersome to do that in general, but there's an
1887 easy approximation that is enough for all current users:
1888 handle register saves before register assignments. */
1889 if (GET_CODE (expr
) == PARALLEL
)
1890 for (par_index
= 0; par_index
< limit
; par_index
++)
1892 elem
= XVECEXP (expr
, 0, par_index
);
1893 if (GET_CODE (elem
) == SET
1894 && MEM_P (SET_DEST (elem
))
1895 && (RTX_FRAME_RELATED_P (elem
) || par_index
== 0))
1896 dwarf2out_frame_debug_expr (elem
, label
);
1899 for (par_index
= 0; par_index
< limit
; par_index
++)
1901 elem
= XVECEXP (expr
, 0, par_index
);
1902 if (GET_CODE (elem
) == SET
1903 && (!MEM_P (SET_DEST (elem
)) || GET_CODE (expr
) == SEQUENCE
)
1904 && (RTX_FRAME_RELATED_P (elem
) || par_index
== 0))
1905 dwarf2out_frame_debug_expr (elem
, label
);
1906 else if (GET_CODE (elem
) == SET
1908 && !RTX_FRAME_RELATED_P (elem
))
1910 /* Stack adjustment combining might combine some post-prologue
1911 stack adjustment into a prologue stack adjustment. */
1912 HOST_WIDE_INT offset
= stack_adjust_offset (elem
, args_size
, 0);
1915 dwarf2out_args_size_adjust (offset
, label
);
1921 gcc_assert (GET_CODE (expr
) == SET
);
1923 src
= SET_SRC (expr
);
1924 dest
= SET_DEST (expr
);
1928 rtx rsi
= reg_saved_in (src
);
1933 fde
= current_fde ();
1935 if (GET_CODE (src
) == REG
1937 && fde
->drap_reg
== REGNO (src
)
1938 && (fde
->drap_reg_saved
1939 || GET_CODE (dest
) == REG
))
1942 /* If we are saving dynamic realign argument pointer to a
1943 register, the destination is virtual dynamic realign
1944 argument pointer. It may be used to access argument. */
1945 if (GET_CODE (dest
) == REG
)
1947 gcc_assert (fde
->vdrap_reg
== INVALID_REGNUM
);
1948 fde
->vdrap_reg
= REGNO (dest
);
1953 switch (GET_CODE (dest
))
1956 switch (GET_CODE (src
))
1958 /* Setting FP from SP. */
1960 if (cfa
.reg
== (unsigned) REGNO (src
))
1963 /* Update the CFA rule wrt SP or FP. Make sure src is
1964 relative to the current CFA register.
1966 We used to require that dest be either SP or FP, but the
1967 ARM copies SP to a temporary register, and from there to
1968 FP. So we just rely on the backends to only set
1969 RTX_FRAME_RELATED_P on appropriate insns. */
1970 cfa
.reg
= REGNO (dest
);
1971 cfa_temp
.reg
= cfa
.reg
;
1972 cfa_temp
.offset
= cfa
.offset
;
1976 /* Saving a register in a register. */
1977 gcc_assert (!fixed_regs
[REGNO (dest
)]
1978 /* For the SPARC and its register window. */
1979 || (DWARF_FRAME_REGNUM (REGNO (src
))
1980 == DWARF_FRAME_RETURN_COLUMN
));
1982 /* After stack is aligned, we can only save SP in FP
1983 if drap register is used. In this case, we have
1984 to restore stack pointer with the CFA value and we
1985 don't generate this DWARF information. */
1987 && fde
->stack_realign
1988 && REGNO (src
) == STACK_POINTER_REGNUM
)
1989 gcc_assert (REGNO (dest
) == HARD_FRAME_POINTER_REGNUM
1990 && fde
->drap_reg
!= INVALID_REGNUM
1991 && cfa
.reg
!= REGNO (src
));
1993 queue_reg_save (label
, src
, dest
, 0);
2000 if (dest
== stack_pointer_rtx
)
2004 switch (GET_CODE (XEXP (src
, 1)))
2007 offset
= INTVAL (XEXP (src
, 1));
2010 gcc_assert ((unsigned) REGNO (XEXP (src
, 1))
2012 offset
= cfa_temp
.offset
;
2018 if (XEXP (src
, 0) == hard_frame_pointer_rtx
)
2020 /* Restoring SP from FP in the epilogue. */
2021 gcc_assert (cfa
.reg
== (unsigned) HARD_FRAME_POINTER_REGNUM
);
2022 cfa
.reg
= STACK_POINTER_REGNUM
;
2024 else if (GET_CODE (src
) == LO_SUM
)
2025 /* Assume we've set the source reg of the LO_SUM from sp. */
2028 gcc_assert (XEXP (src
, 0) == stack_pointer_rtx
);
2030 if (GET_CODE (src
) != MINUS
)
2032 if (cfa
.reg
== STACK_POINTER_REGNUM
)
2033 cfa
.offset
+= offset
;
2034 if (cfa_store
.reg
== STACK_POINTER_REGNUM
)
2035 cfa_store
.offset
+= offset
;
2037 else if (dest
== hard_frame_pointer_rtx
)
2040 /* Either setting the FP from an offset of the SP,
2041 or adjusting the FP */
2042 gcc_assert (frame_pointer_needed
);
2044 gcc_assert (REG_P (XEXP (src
, 0))
2045 && (unsigned) REGNO (XEXP (src
, 0)) == cfa
.reg
2046 && GET_CODE (XEXP (src
, 1)) == CONST_INT
);
2047 offset
= INTVAL (XEXP (src
, 1));
2048 if (GET_CODE (src
) != MINUS
)
2050 cfa
.offset
+= offset
;
2051 cfa
.reg
= HARD_FRAME_POINTER_REGNUM
;
2055 gcc_assert (GET_CODE (src
) != MINUS
);
2058 if (REG_P (XEXP (src
, 0))
2059 && REGNO (XEXP (src
, 0)) == cfa
.reg
2060 && GET_CODE (XEXP (src
, 1)) == CONST_INT
)
2062 /* Setting a temporary CFA register that will be copied
2063 into the FP later on. */
2064 offset
= - INTVAL (XEXP (src
, 1));
2065 cfa
.offset
+= offset
;
2066 cfa
.reg
= REGNO (dest
);
2067 /* Or used to save regs to the stack. */
2068 cfa_temp
.reg
= cfa
.reg
;
2069 cfa_temp
.offset
= cfa
.offset
;
2073 else if (REG_P (XEXP (src
, 0))
2074 && REGNO (XEXP (src
, 0)) == cfa_temp
.reg
2075 && XEXP (src
, 1) == stack_pointer_rtx
)
2077 /* Setting a scratch register that we will use instead
2078 of SP for saving registers to the stack. */
2079 gcc_assert (cfa
.reg
== STACK_POINTER_REGNUM
);
2080 cfa_store
.reg
= REGNO (dest
);
2081 cfa_store
.offset
= cfa
.offset
- cfa_temp
.offset
;
2085 else if (GET_CODE (src
) == LO_SUM
2086 && GET_CODE (XEXP (src
, 1)) == CONST_INT
)
2088 cfa_temp
.reg
= REGNO (dest
);
2089 cfa_temp
.offset
= INTVAL (XEXP (src
, 1));
2098 cfa_temp
.reg
= REGNO (dest
);
2099 cfa_temp
.offset
= INTVAL (src
);
2104 gcc_assert (REG_P (XEXP (src
, 0))
2105 && (unsigned) REGNO (XEXP (src
, 0)) == cfa_temp
.reg
2106 && GET_CODE (XEXP (src
, 1)) == CONST_INT
);
2108 if ((unsigned) REGNO (dest
) != cfa_temp
.reg
)
2109 cfa_temp
.reg
= REGNO (dest
);
2110 cfa_temp
.offset
|= INTVAL (XEXP (src
, 1));
2113 /* Skip over HIGH, assuming it will be followed by a LO_SUM,
2114 which will fill in all of the bits. */
2121 case UNSPEC_VOLATILE
:
2122 gcc_assert (targetm
.dwarf_handle_frame_unspec
);
2123 targetm
.dwarf_handle_frame_unspec (label
, expr
, XINT (src
, 1));
2128 /* If this AND operation happens on stack pointer in prologue,
2129 we assume the stack is realigned and we extract the
2131 if (fde
&& XEXP (src
, 0) == stack_pointer_rtx
)
2133 gcc_assert (cfa_store
.reg
== REGNO (XEXP (src
, 0)));
2134 fde
->stack_realign
= 1;
2135 fde
->stack_realignment
= INTVAL (XEXP (src
, 1));
2136 cfa_store
.offset
= 0;
2138 if (cfa
.reg
!= STACK_POINTER_REGNUM
2139 && cfa
.reg
!= HARD_FRAME_POINTER_REGNUM
)
2140 fde
->drap_reg
= cfa
.reg
;
2148 def_cfa_1 (label
, &cfa
);
2153 /* Saving a register to the stack. Make sure dest is relative to the
2155 switch (GET_CODE (XEXP (dest
, 0)))
2160 /* We can't handle variable size modifications. */
2161 gcc_assert (GET_CODE (XEXP (XEXP (XEXP (dest
, 0), 1), 1))
2163 offset
= -INTVAL (XEXP (XEXP (XEXP (dest
, 0), 1), 1));
2165 gcc_assert (REGNO (XEXP (XEXP (dest
, 0), 0)) == STACK_POINTER_REGNUM
2166 && cfa_store
.reg
== STACK_POINTER_REGNUM
);
2168 cfa_store
.offset
+= offset
;
2169 if (cfa
.reg
== STACK_POINTER_REGNUM
)
2170 cfa
.offset
= cfa_store
.offset
;
2172 offset
= -cfa_store
.offset
;
2178 offset
= GET_MODE_SIZE (GET_MODE (dest
));
2179 if (GET_CODE (XEXP (dest
, 0)) == PRE_INC
)
2182 gcc_assert ((REGNO (XEXP (XEXP (dest
, 0), 0))
2183 == STACK_POINTER_REGNUM
)
2184 && cfa_store
.reg
== STACK_POINTER_REGNUM
);
2186 cfa_store
.offset
+= offset
;
2188 /* Rule 18: If stack is aligned, we will use FP as a
2189 reference to represent the address of the stored
2192 && fde
->stack_realign
2193 && src
== hard_frame_pointer_rtx
)
2195 gcc_assert (cfa
.reg
!= HARD_FRAME_POINTER_REGNUM
);
2196 cfa_store
.offset
= 0;
2199 if (cfa
.reg
== STACK_POINTER_REGNUM
)
2200 cfa
.offset
= cfa_store
.offset
;
2202 offset
= -cfa_store
.offset
;
2206 /* With an offset. */
2213 gcc_assert (GET_CODE (XEXP (XEXP (dest
, 0), 1)) == CONST_INT
2214 && REG_P (XEXP (XEXP (dest
, 0), 0)));
2215 offset
= INTVAL (XEXP (XEXP (dest
, 0), 1));
2216 if (GET_CODE (XEXP (dest
, 0)) == MINUS
)
2219 regno
= REGNO (XEXP (XEXP (dest
, 0), 0));
2221 if (cfa_store
.reg
== (unsigned) regno
)
2222 offset
-= cfa_store
.offset
;
2225 gcc_assert (cfa_temp
.reg
== (unsigned) regno
);
2226 offset
-= cfa_temp
.offset
;
2232 /* Without an offset. */
2235 int regno
= REGNO (XEXP (dest
, 0));
2237 if (cfa_store
.reg
== (unsigned) regno
)
2238 offset
= -cfa_store
.offset
;
2241 gcc_assert (cfa_temp
.reg
== (unsigned) regno
);
2242 offset
= -cfa_temp
.offset
;
2249 gcc_assert (cfa_temp
.reg
2250 == (unsigned) REGNO (XEXP (XEXP (dest
, 0), 0)));
2251 offset
= -cfa_temp
.offset
;
2252 cfa_temp
.offset
-= GET_MODE_SIZE (GET_MODE (dest
));
2260 /* If the source operand of this MEM operation is not a
2261 register, basically the source is return address. Here
2262 we only care how much stack grew and we don't save it. */
2266 if (REGNO (src
) != STACK_POINTER_REGNUM
2267 && REGNO (src
) != HARD_FRAME_POINTER_REGNUM
2268 && (unsigned) REGNO (src
) == cfa
.reg
)
2270 /* We're storing the current CFA reg into the stack. */
2272 if (cfa
.offset
== 0)
2275 /* If stack is aligned, putting CFA reg into stack means
2276 we can no longer use reg + offset to represent CFA.
2277 Here we use DW_CFA_def_cfa_expression instead. The
2278 result of this expression equals to the original CFA
2281 && fde
->stack_realign
2282 && cfa
.indirect
== 0
2283 && cfa
.reg
!= HARD_FRAME_POINTER_REGNUM
)
2285 dw_cfa_location cfa_exp
;
2287 gcc_assert (fde
->drap_reg
== cfa
.reg
);
2289 cfa_exp
.indirect
= 1;
2290 cfa_exp
.reg
= HARD_FRAME_POINTER_REGNUM
;
2291 cfa_exp
.base_offset
= offset
;
2294 fde
->drap_reg_saved
= 1;
2296 def_cfa_1 (label
, &cfa_exp
);
2300 /* If the source register is exactly the CFA, assume
2301 we're saving SP like any other register; this happens
2303 def_cfa_1 (label
, &cfa
);
2304 queue_reg_save (label
, stack_pointer_rtx
, NULL_RTX
, offset
);
2309 /* Otherwise, we'll need to look in the stack to
2310 calculate the CFA. */
2311 rtx x
= XEXP (dest
, 0);
2315 gcc_assert (REG_P (x
));
2317 cfa
.reg
= REGNO (x
);
2318 cfa
.base_offset
= offset
;
2320 def_cfa_1 (label
, &cfa
);
2325 def_cfa_1 (label
, &cfa
);
2327 span
= targetm
.dwarf_register_span (src
);
2330 queue_reg_save (label
, src
, NULL_RTX
, offset
);
2333 /* We have a PARALLEL describing where the contents of SRC
2334 live. Queue register saves for each piece of the
2338 HOST_WIDE_INT span_offset
= offset
;
2340 gcc_assert (GET_CODE (span
) == PARALLEL
);
2342 limit
= XVECLEN (span
, 0);
2343 for (par_index
= 0; par_index
< limit
; par_index
++)
2345 rtx elem
= XVECEXP (span
, 0, par_index
);
2347 queue_reg_save (label
, elem
, NULL_RTX
, span_offset
);
2348 span_offset
+= GET_MODE_SIZE (GET_MODE (elem
));
2359 /* Record call frame debugging information for INSN, which either
2360 sets SP or FP (adjusting how we calculate the frame address) or saves a
2361 register to the stack. If INSN is NULL_RTX, initialize our state.
2363 If AFTER_P is false, we're being called before the insn is emitted,
2364 otherwise after. Call instructions get invoked twice. */
2367 dwarf2out_frame_debug (rtx insn
, bool after_p
)
2372 if (insn
== NULL_RTX
)
2376 /* Flush any queued register saves. */
2377 flush_queued_reg_saves ();
2379 /* Set up state for generating call frame debug info. */
2382 == (unsigned long)DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM
));
2384 cfa
.reg
= STACK_POINTER_REGNUM
;
2387 cfa_temp
.offset
= 0;
2389 for (i
= 0; i
< num_regs_saved_in_regs
; i
++)
2391 regs_saved_in_regs
[i
].orig_reg
= NULL_RTX
;
2392 regs_saved_in_regs
[i
].saved_in_reg
= NULL_RTX
;
2394 num_regs_saved_in_regs
= 0;
2396 if (barrier_args_size
)
2398 XDELETEVEC (barrier_args_size
);
2399 barrier_args_size
= NULL
;
2404 if (!NONJUMP_INSN_P (insn
) || clobbers_queued_reg_save (insn
))
2405 flush_queued_reg_saves ();
2407 if (! RTX_FRAME_RELATED_P (insn
))
2409 if (!ACCUMULATE_OUTGOING_ARGS
)
2410 dwarf2out_stack_adjust (insn
, after_p
);
2414 label
= dwarf2out_cfi_label ();
2415 src
= find_reg_note (insn
, REG_FRAME_RELATED_EXPR
, NULL_RTX
);
2417 insn
= XEXP (src
, 0);
2419 insn
= PATTERN (insn
);
2421 dwarf2out_frame_debug_expr (insn
, label
);
2426 /* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used. */
2427 static enum dw_cfi_oprnd_type dw_cfi_oprnd1_desc
2428 (enum dwarf_call_frame_info cfi
);
2430 static enum dw_cfi_oprnd_type
2431 dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi
)
2436 case DW_CFA_GNU_window_save
:
2437 return dw_cfi_oprnd_unused
;
2439 case DW_CFA_set_loc
:
2440 case DW_CFA_advance_loc1
:
2441 case DW_CFA_advance_loc2
:
2442 case DW_CFA_advance_loc4
:
2443 case DW_CFA_MIPS_advance_loc8
:
2444 return dw_cfi_oprnd_addr
;
2447 case DW_CFA_offset_extended
:
2448 case DW_CFA_def_cfa
:
2449 case DW_CFA_offset_extended_sf
:
2450 case DW_CFA_def_cfa_sf
:
2451 case DW_CFA_restore_extended
:
2452 case DW_CFA_undefined
:
2453 case DW_CFA_same_value
:
2454 case DW_CFA_def_cfa_register
:
2455 case DW_CFA_register
:
2456 return dw_cfi_oprnd_reg_num
;
2458 case DW_CFA_def_cfa_offset
:
2459 case DW_CFA_GNU_args_size
:
2460 case DW_CFA_def_cfa_offset_sf
:
2461 return dw_cfi_oprnd_offset
;
2463 case DW_CFA_def_cfa_expression
:
2464 case DW_CFA_expression
:
2465 return dw_cfi_oprnd_loc
;
2472 /* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used. */
2473 static enum dw_cfi_oprnd_type dw_cfi_oprnd2_desc
2474 (enum dwarf_call_frame_info cfi
);
2476 static enum dw_cfi_oprnd_type
2477 dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi
)
2481 case DW_CFA_def_cfa
:
2482 case DW_CFA_def_cfa_sf
:
2484 case DW_CFA_offset_extended_sf
:
2485 case DW_CFA_offset_extended
:
2486 return dw_cfi_oprnd_offset
;
2488 case DW_CFA_register
:
2489 return dw_cfi_oprnd_reg_num
;
2492 return dw_cfi_oprnd_unused
;
2496 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
2498 /* Switch to eh_frame_section. If we don't have an eh_frame_section,
2499 switch to the data section instead, and write out a synthetic label
2503 switch_to_eh_frame_section (void)
2507 #ifdef EH_FRAME_SECTION_NAME
2508 if (eh_frame_section
== 0)
2512 if (EH_TABLES_CAN_BE_READ_ONLY
)
2518 fde_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1,
2520 per_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,
2522 lsda_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,
2524 flags
= ((! flag_pic
2525 || ((fde_encoding
& 0x70) != DW_EH_PE_absptr
2526 && (fde_encoding
& 0x70) != DW_EH_PE_aligned
2527 && (per_encoding
& 0x70) != DW_EH_PE_absptr
2528 && (per_encoding
& 0x70) != DW_EH_PE_aligned
2529 && (lsda_encoding
& 0x70) != DW_EH_PE_absptr
2530 && (lsda_encoding
& 0x70) != DW_EH_PE_aligned
))
2531 ? 0 : SECTION_WRITE
);
2534 flags
= SECTION_WRITE
;
2535 eh_frame_section
= get_section (EH_FRAME_SECTION_NAME
, flags
, NULL
);
2539 if (eh_frame_section
)
2540 switch_to_section (eh_frame_section
);
2543 /* We have no special eh_frame section. Put the information in
2544 the data section and emit special labels to guide collect2. */
2545 switch_to_section (data_section
);
2546 label
= get_file_function_name ("F");
2547 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (PTR_SIZE
));
2548 targetm
.asm_out
.globalize_label (asm_out_file
,
2549 IDENTIFIER_POINTER (label
));
2550 ASM_OUTPUT_LABEL (asm_out_file
, IDENTIFIER_POINTER (label
));
2554 /* Divide OFF by DWARF_CIE_DATA_ALIGNMENT, asserting no remainder. */
2556 static HOST_WIDE_INT
2557 div_data_align (HOST_WIDE_INT off
)
2559 HOST_WIDE_INT r
= off
/ DWARF_CIE_DATA_ALIGNMENT
;
2560 gcc_assert (r
* DWARF_CIE_DATA_ALIGNMENT
== off
);
2564 /* Output a Call Frame Information opcode and its operand(s). */
2567 output_cfi (dw_cfi_ref cfi
, dw_fde_ref fde
, int for_eh
)
2572 if (cfi
->dw_cfi_opc
== DW_CFA_advance_loc
)
2573 dw2_asm_output_data (1, (cfi
->dw_cfi_opc
2574 | (cfi
->dw_cfi_oprnd1
.dw_cfi_offset
& 0x3f)),
2575 "DW_CFA_advance_loc " HOST_WIDE_INT_PRINT_HEX
,
2576 ((unsigned HOST_WIDE_INT
)
2577 cfi
->dw_cfi_oprnd1
.dw_cfi_offset
));
2578 else if (cfi
->dw_cfi_opc
== DW_CFA_offset
)
2580 r
= DWARF2_FRAME_REG_OUT (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
, for_eh
);
2581 dw2_asm_output_data (1, (cfi
->dw_cfi_opc
| (r
& 0x3f)),
2582 "DW_CFA_offset, column 0x%lx", r
);
2583 off
= div_data_align (cfi
->dw_cfi_oprnd2
.dw_cfi_offset
);
2584 dw2_asm_output_data_uleb128 (off
, NULL
);
2586 else if (cfi
->dw_cfi_opc
== DW_CFA_restore
)
2588 r
= DWARF2_FRAME_REG_OUT (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
, for_eh
);
2589 dw2_asm_output_data (1, (cfi
->dw_cfi_opc
| (r
& 0x3f)),
2590 "DW_CFA_restore, column 0x%lx", r
);
2594 dw2_asm_output_data (1, cfi
->dw_cfi_opc
,
2595 "%s", dwarf_cfi_name (cfi
->dw_cfi_opc
));
2597 switch (cfi
->dw_cfi_opc
)
2599 case DW_CFA_set_loc
:
2601 dw2_asm_output_encoded_addr_rtx (
2602 ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0),
2603 gen_rtx_SYMBOL_REF (Pmode
, cfi
->dw_cfi_oprnd1
.dw_cfi_addr
),
2606 dw2_asm_output_addr (DWARF2_ADDR_SIZE
,
2607 cfi
->dw_cfi_oprnd1
.dw_cfi_addr
, NULL
);
2608 fde
->dw_fde_current_label
= cfi
->dw_cfi_oprnd1
.dw_cfi_addr
;
2611 case DW_CFA_advance_loc1
:
2612 dw2_asm_output_delta (1, cfi
->dw_cfi_oprnd1
.dw_cfi_addr
,
2613 fde
->dw_fde_current_label
, NULL
);
2614 fde
->dw_fde_current_label
= cfi
->dw_cfi_oprnd1
.dw_cfi_addr
;
2617 case DW_CFA_advance_loc2
:
2618 dw2_asm_output_delta (2, cfi
->dw_cfi_oprnd1
.dw_cfi_addr
,
2619 fde
->dw_fde_current_label
, NULL
);
2620 fde
->dw_fde_current_label
= cfi
->dw_cfi_oprnd1
.dw_cfi_addr
;
2623 case DW_CFA_advance_loc4
:
2624 dw2_asm_output_delta (4, cfi
->dw_cfi_oprnd1
.dw_cfi_addr
,
2625 fde
->dw_fde_current_label
, NULL
);
2626 fde
->dw_fde_current_label
= cfi
->dw_cfi_oprnd1
.dw_cfi_addr
;
2629 case DW_CFA_MIPS_advance_loc8
:
2630 dw2_asm_output_delta (8, cfi
->dw_cfi_oprnd1
.dw_cfi_addr
,
2631 fde
->dw_fde_current_label
, NULL
);
2632 fde
->dw_fde_current_label
= cfi
->dw_cfi_oprnd1
.dw_cfi_addr
;
2635 case DW_CFA_offset_extended
:
2636 r
= DWARF2_FRAME_REG_OUT (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
, for_eh
);
2637 dw2_asm_output_data_uleb128 (r
, NULL
);
2638 off
= div_data_align (cfi
->dw_cfi_oprnd2
.dw_cfi_offset
);
2639 dw2_asm_output_data_uleb128 (off
, NULL
);
2642 case DW_CFA_def_cfa
:
2643 r
= DWARF2_FRAME_REG_OUT (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
, for_eh
);
2644 dw2_asm_output_data_uleb128 (r
, NULL
);
2645 dw2_asm_output_data_uleb128 (cfi
->dw_cfi_oprnd2
.dw_cfi_offset
, NULL
);
2648 case DW_CFA_offset_extended_sf
:
2649 r
= DWARF2_FRAME_REG_OUT (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
, for_eh
);
2650 dw2_asm_output_data_uleb128 (r
, NULL
);
2651 off
= div_data_align (cfi
->dw_cfi_oprnd2
.dw_cfi_offset
);
2652 dw2_asm_output_data_sleb128 (off
, NULL
);
2655 case DW_CFA_def_cfa_sf
:
2656 r
= DWARF2_FRAME_REG_OUT (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
, for_eh
);
2657 dw2_asm_output_data_uleb128 (r
, NULL
);
2658 off
= div_data_align (cfi
->dw_cfi_oprnd2
.dw_cfi_offset
);
2659 dw2_asm_output_data_sleb128 (off
, NULL
);
2662 case DW_CFA_restore_extended
:
2663 case DW_CFA_undefined
:
2664 case DW_CFA_same_value
:
2665 case DW_CFA_def_cfa_register
:
2666 r
= DWARF2_FRAME_REG_OUT (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
, for_eh
);
2667 dw2_asm_output_data_uleb128 (r
, NULL
);
2670 case DW_CFA_register
:
2671 r
= DWARF2_FRAME_REG_OUT (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
, for_eh
);
2672 dw2_asm_output_data_uleb128 (r
, NULL
);
2673 r
= DWARF2_FRAME_REG_OUT (cfi
->dw_cfi_oprnd2
.dw_cfi_reg_num
, for_eh
);
2674 dw2_asm_output_data_uleb128 (r
, NULL
);
2677 case DW_CFA_def_cfa_offset
:
2678 case DW_CFA_GNU_args_size
:
2679 dw2_asm_output_data_uleb128 (cfi
->dw_cfi_oprnd1
.dw_cfi_offset
, NULL
);
2682 case DW_CFA_def_cfa_offset_sf
:
2683 off
= div_data_align (cfi
->dw_cfi_oprnd1
.dw_cfi_offset
);
2684 dw2_asm_output_data_sleb128 (off
, NULL
);
2687 case DW_CFA_GNU_window_save
:
2690 case DW_CFA_def_cfa_expression
:
2691 case DW_CFA_expression
:
2692 output_cfa_loc (cfi
);
2695 case DW_CFA_GNU_negative_offset_extended
:
2696 /* Obsoleted by DW_CFA_offset_extended_sf. */
2705 /* Similar, but do it via assembler directives instead. */
2708 output_cfi_directive (dw_cfi_ref cfi
)
2710 unsigned long r
, r2
;
2712 switch (cfi
->dw_cfi_opc
)
2714 case DW_CFA_advance_loc
:
2715 case DW_CFA_advance_loc1
:
2716 case DW_CFA_advance_loc2
:
2717 case DW_CFA_advance_loc4
:
2718 case DW_CFA_MIPS_advance_loc8
:
2719 case DW_CFA_set_loc
:
2720 /* Should only be created by add_fde_cfi in a code path not
2721 followed when emitting via directives. The assembler is
2722 going to take care of this for us. */
2726 case DW_CFA_offset_extended
:
2727 case DW_CFA_offset_extended_sf
:
2728 r
= DWARF2_FRAME_REG_OUT (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
, 0);
2729 fprintf (asm_out_file
, "\t.cfi_offset %lu, "HOST_WIDE_INT_PRINT_DEC
"\n",
2730 r
, cfi
->dw_cfi_oprnd2
.dw_cfi_offset
);
2733 case DW_CFA_restore
:
2734 case DW_CFA_restore_extended
:
2735 r
= DWARF2_FRAME_REG_OUT (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
, 0);
2736 fprintf (asm_out_file
, "\t.cfi_restore %lu\n", r
);
2739 case DW_CFA_undefined
:
2740 r
= DWARF2_FRAME_REG_OUT (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
, 0);
2741 fprintf (asm_out_file
, "\t.cfi_undefined %lu\n", r
);
2744 case DW_CFA_same_value
:
2745 r
= DWARF2_FRAME_REG_OUT (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
, 0);
2746 fprintf (asm_out_file
, "\t.cfi_same_value %lu\n", r
);
2749 case DW_CFA_def_cfa
:
2750 case DW_CFA_def_cfa_sf
:
2751 r
= DWARF2_FRAME_REG_OUT (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
, 0);
2752 fprintf (asm_out_file
, "\t.cfi_def_cfa %lu, "HOST_WIDE_INT_PRINT_DEC
"\n",
2753 r
, cfi
->dw_cfi_oprnd2
.dw_cfi_offset
);
2756 case DW_CFA_def_cfa_register
:
2757 r
= DWARF2_FRAME_REG_OUT (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
, 0);
2758 fprintf (asm_out_file
, "\t.cfi_def_cfa_register %lu\n", r
);
2761 case DW_CFA_register
:
2762 r
= DWARF2_FRAME_REG_OUT (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
, 0);
2763 r2
= DWARF2_FRAME_REG_OUT (cfi
->dw_cfi_oprnd2
.dw_cfi_reg_num
, 0);
2764 fprintf (asm_out_file
, "\t.cfi_register %lu, %lu\n", r
, r2
);
2767 case DW_CFA_def_cfa_offset
:
2768 case DW_CFA_def_cfa_offset_sf
:
2769 fprintf (asm_out_file
, "\t.cfi_def_cfa_offset "
2770 HOST_WIDE_INT_PRINT_DEC
"\n",
2771 cfi
->dw_cfi_oprnd1
.dw_cfi_offset
);
2774 case DW_CFA_GNU_args_size
:
2775 fprintf (asm_out_file
, "\t.cfi_escape 0x%x,", DW_CFA_GNU_args_size
);
2776 dw2_asm_output_data_uleb128_raw (cfi
->dw_cfi_oprnd1
.dw_cfi_offset
);
2778 fprintf (asm_out_file
, "\t%s args_size "HOST_WIDE_INT_PRINT_DEC
,
2779 ASM_COMMENT_START
, cfi
->dw_cfi_oprnd1
.dw_cfi_offset
);
2780 fputc ('\n', asm_out_file
);
2783 case DW_CFA_GNU_window_save
:
2784 fprintf (asm_out_file
, "\t.cfi_window_save\n");
2787 case DW_CFA_def_cfa_expression
:
2788 case DW_CFA_expression
:
2789 fprintf (asm_out_file
, "\t.cfi_escape 0x%x,", cfi
->dw_cfi_opc
);
2790 output_cfa_loc_raw (cfi
);
2791 fputc ('\n', asm_out_file
);
2799 /* Output the call frame information used to record information
2800 that relates to calculating the frame pointer, and records the
2801 location of saved registers. */
2804 output_call_frame_info (int for_eh
)
2809 char l1
[20], l2
[20], section_start_label
[20];
2810 bool any_lsda_needed
= false;
2811 char augmentation
[6];
2812 int augmentation_size
;
2813 int fde_encoding
= DW_EH_PE_absptr
;
2814 int per_encoding
= DW_EH_PE_absptr
;
2815 int lsda_encoding
= DW_EH_PE_absptr
;
2818 /* Don't emit a CIE if there won't be any FDEs. */
2819 if (fde_table_in_use
== 0)
2822 /* Nothing to do if the assembler's doing it all. */
2823 if (dwarf2out_do_cfi_asm ())
2826 /* If we make FDEs linkonce, we may have to emit an empty label for
2827 an FDE that wouldn't otherwise be emitted. We want to avoid
2828 having an FDE kept around when the function it refers to is
2829 discarded. Example where this matters: a primary function
2830 template in C++ requires EH information, but an explicit
2831 specialization doesn't. */
2832 if (TARGET_USES_WEAK_UNWIND_INFO
2833 && ! flag_asynchronous_unwind_tables
2836 for (i
= 0; i
< fde_table_in_use
; i
++)
2837 if ((fde_table
[i
].nothrow
|| fde_table
[i
].all_throwers_are_sibcalls
)
2838 && !fde_table
[i
].uses_eh_lsda
2839 && ! DECL_WEAK (fde_table
[i
].decl
))
2840 targetm
.asm_out
.unwind_label (asm_out_file
, fde_table
[i
].decl
,
2841 for_eh
, /* empty */ 1);
2843 /* If we don't have any functions we'll want to unwind out of, don't
2844 emit any EH unwind information. Note that if exceptions aren't
2845 enabled, we won't have collected nothrow information, and if we
2846 asked for asynchronous tables, we always want this info. */
2849 bool any_eh_needed
= !flag_exceptions
|| flag_asynchronous_unwind_tables
;
2851 for (i
= 0; i
< fde_table_in_use
; i
++)
2852 if (fde_table
[i
].uses_eh_lsda
)
2853 any_eh_needed
= any_lsda_needed
= true;
2854 else if (TARGET_USES_WEAK_UNWIND_INFO
&& DECL_WEAK (fde_table
[i
].decl
))
2855 any_eh_needed
= true;
2856 else if (! fde_table
[i
].nothrow
2857 && ! fde_table
[i
].all_throwers_are_sibcalls
)
2858 any_eh_needed
= true;
2860 if (! any_eh_needed
)
2864 /* We're going to be generating comments, so turn on app. */
2869 switch_to_eh_frame_section ();
2872 if (!debug_frame_section
)
2873 debug_frame_section
= get_section (DEBUG_FRAME_SECTION
,
2874 SECTION_DEBUG
, NULL
);
2875 switch_to_section (debug_frame_section
);
2878 ASM_GENERATE_INTERNAL_LABEL (section_start_label
, FRAME_BEGIN_LABEL
, for_eh
);
2879 ASM_OUTPUT_LABEL (asm_out_file
, section_start_label
);
2881 /* Output the CIE. */
2882 ASM_GENERATE_INTERNAL_LABEL (l1
, CIE_AFTER_SIZE_LABEL
, for_eh
);
2883 ASM_GENERATE_INTERNAL_LABEL (l2
, CIE_END_LABEL
, for_eh
);
2884 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4 && !for_eh
)
2885 dw2_asm_output_data (4, 0xffffffff,
2886 "Initial length escape value indicating 64-bit DWARF extension");
2887 dw2_asm_output_delta (for_eh
? 4 : DWARF_OFFSET_SIZE
, l2
, l1
,
2888 "Length of Common Information Entry");
2889 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
2891 /* Now that the CIE pointer is PC-relative for EH,
2892 use 0 to identify the CIE. */
2893 dw2_asm_output_data ((for_eh
? 4 : DWARF_OFFSET_SIZE
),
2894 (for_eh
? 0 : DWARF_CIE_ID
),
2895 "CIE Identifier Tag");
2897 dw2_asm_output_data (1, DW_CIE_VERSION
, "CIE Version");
2899 augmentation
[0] = 0;
2900 augmentation_size
= 0;
2906 z Indicates that a uleb128 is present to size the
2907 augmentation section.
2908 L Indicates the encoding (and thus presence) of
2909 an LSDA pointer in the FDE augmentation.
2910 R Indicates a non-default pointer encoding for
2912 P Indicates the presence of an encoding + language
2913 personality routine in the CIE augmentation. */
2915 fde_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0);
2916 per_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
2917 lsda_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
2919 p
= augmentation
+ 1;
2920 if (eh_personality_libfunc
)
2923 augmentation_size
+= 1 + size_of_encoded_value (per_encoding
);
2924 assemble_external_libcall (eh_personality_libfunc
);
2926 if (any_lsda_needed
)
2929 augmentation_size
+= 1;
2931 if (fde_encoding
!= DW_EH_PE_absptr
)
2934 augmentation_size
+= 1;
2936 if (p
> augmentation
+ 1)
2938 augmentation
[0] = 'z';
2942 /* Ug. Some platforms can't do unaligned dynamic relocations at all. */
2943 if (eh_personality_libfunc
&& per_encoding
== DW_EH_PE_aligned
)
2945 int offset
= ( 4 /* Length */
2947 + 1 /* CIE version */
2948 + strlen (augmentation
) + 1 /* Augmentation */
2949 + size_of_uleb128 (1) /* Code alignment */
2950 + size_of_sleb128 (DWARF_CIE_DATA_ALIGNMENT
)
2952 + 1 /* Augmentation size */
2953 + 1 /* Personality encoding */ );
2954 int pad
= -offset
& (PTR_SIZE
- 1);
2956 augmentation_size
+= pad
;
2958 /* Augmentations should be small, so there's scarce need to
2959 iterate for a solution. Die if we exceed one uleb128 byte. */
2960 gcc_assert (size_of_uleb128 (augmentation_size
) == 1);
2964 dw2_asm_output_nstring (augmentation
, -1, "CIE Augmentation");
2965 dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor");
2966 dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT
,
2967 "CIE Data Alignment Factor");
2969 return_reg
= DWARF2_FRAME_REG_OUT (DWARF_FRAME_RETURN_COLUMN
, for_eh
);
2970 if (DW_CIE_VERSION
== 1)
2971 dw2_asm_output_data (1, return_reg
, "CIE RA Column");
2973 dw2_asm_output_data_uleb128 (return_reg
, "CIE RA Column");
2975 if (augmentation
[0])
2977 dw2_asm_output_data_uleb128 (augmentation_size
, "Augmentation size");
2978 if (eh_personality_libfunc
)
2980 dw2_asm_output_data (1, per_encoding
, "Personality (%s)",
2981 eh_data_format_name (per_encoding
));
2982 dw2_asm_output_encoded_addr_rtx (per_encoding
,
2983 eh_personality_libfunc
,
2987 if (any_lsda_needed
)
2988 dw2_asm_output_data (1, lsda_encoding
, "LSDA Encoding (%s)",
2989 eh_data_format_name (lsda_encoding
));
2991 if (fde_encoding
!= DW_EH_PE_absptr
)
2992 dw2_asm_output_data (1, fde_encoding
, "FDE Encoding (%s)",
2993 eh_data_format_name (fde_encoding
));
2996 for (cfi
= cie_cfi_head
; cfi
!= NULL
; cfi
= cfi
->dw_cfi_next
)
2997 output_cfi (cfi
, NULL
, for_eh
);
2999 /* Pad the CIE out to an address sized boundary. */
3000 ASM_OUTPUT_ALIGN (asm_out_file
,
3001 floor_log2 (for_eh
? PTR_SIZE
: DWARF2_ADDR_SIZE
));
3002 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
3004 /* Loop through all of the FDE's. */
3005 for (i
= 0; i
< fde_table_in_use
; i
++)
3007 fde
= &fde_table
[i
];
3009 /* Don't emit EH unwind info for leaf functions that don't need it. */
3010 if (for_eh
&& !flag_asynchronous_unwind_tables
&& flag_exceptions
3011 && (fde
->nothrow
|| fde
->all_throwers_are_sibcalls
)
3012 && ! (TARGET_USES_WEAK_UNWIND_INFO
&& DECL_WEAK (fde_table
[i
].decl
))
3013 && !fde
->uses_eh_lsda
)
3016 targetm
.asm_out
.unwind_label (asm_out_file
, fde
->decl
, for_eh
, /* empty */ 0);
3017 targetm
.asm_out
.internal_label (asm_out_file
, FDE_LABEL
, for_eh
+ i
* 2);
3018 ASM_GENERATE_INTERNAL_LABEL (l1
, FDE_AFTER_SIZE_LABEL
, for_eh
+ i
* 2);
3019 ASM_GENERATE_INTERNAL_LABEL (l2
, FDE_END_LABEL
, for_eh
+ i
* 2);
3020 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4 && !for_eh
)
3021 dw2_asm_output_data (4, 0xffffffff,
3022 "Initial length escape value indicating 64-bit DWARF extension");
3023 dw2_asm_output_delta (for_eh
? 4 : DWARF_OFFSET_SIZE
, l2
, l1
,
3025 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
3028 dw2_asm_output_delta (4, l1
, section_start_label
, "FDE CIE offset");
3030 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, section_start_label
,
3031 debug_frame_section
, "FDE CIE offset");
3035 if (fde
->dw_fde_switched_sections
)
3037 rtx sym_ref2
= gen_rtx_SYMBOL_REF (Pmode
,
3038 fde
->dw_fde_unlikely_section_label
);
3039 rtx sym_ref3
= gen_rtx_SYMBOL_REF (Pmode
,
3040 fde
->dw_fde_hot_section_label
);
3041 SYMBOL_REF_FLAGS (sym_ref2
) |= SYMBOL_FLAG_LOCAL
;
3042 SYMBOL_REF_FLAGS (sym_ref3
) |= SYMBOL_FLAG_LOCAL
;
3043 dw2_asm_output_encoded_addr_rtx (fde_encoding
, sym_ref3
, false,
3044 "FDE initial location");
3045 dw2_asm_output_delta (size_of_encoded_value (fde_encoding
),
3046 fde
->dw_fde_hot_section_end_label
,
3047 fde
->dw_fde_hot_section_label
,
3048 "FDE address range");
3049 dw2_asm_output_encoded_addr_rtx (fde_encoding
, sym_ref2
, false,
3050 "FDE initial location");
3051 dw2_asm_output_delta (size_of_encoded_value (fde_encoding
),
3052 fde
->dw_fde_unlikely_section_end_label
,
3053 fde
->dw_fde_unlikely_section_label
,
3054 "FDE address range");
3058 rtx sym_ref
= gen_rtx_SYMBOL_REF (Pmode
, fde
->dw_fde_begin
);
3059 SYMBOL_REF_FLAGS (sym_ref
) |= SYMBOL_FLAG_LOCAL
;
3060 dw2_asm_output_encoded_addr_rtx (fde_encoding
,
3063 "FDE initial location");
3064 dw2_asm_output_delta (size_of_encoded_value (fde_encoding
),
3065 fde
->dw_fde_end
, fde
->dw_fde_begin
,
3066 "FDE address range");
3071 if (fde
->dw_fde_switched_sections
)
3073 dw2_asm_output_addr (DWARF2_ADDR_SIZE
,
3074 fde
->dw_fde_hot_section_label
,
3075 "FDE initial location");
3076 dw2_asm_output_delta (DWARF2_ADDR_SIZE
,
3077 fde
->dw_fde_hot_section_end_label
,
3078 fde
->dw_fde_hot_section_label
,
3079 "FDE address range");
3080 dw2_asm_output_addr (DWARF2_ADDR_SIZE
,
3081 fde
->dw_fde_unlikely_section_label
,
3082 "FDE initial location");
3083 dw2_asm_output_delta (DWARF2_ADDR_SIZE
,
3084 fde
->dw_fde_unlikely_section_end_label
,
3085 fde
->dw_fde_unlikely_section_label
,
3086 "FDE address range");
3090 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, fde
->dw_fde_begin
,
3091 "FDE initial location");
3092 dw2_asm_output_delta (DWARF2_ADDR_SIZE
,
3093 fde
->dw_fde_end
, fde
->dw_fde_begin
,
3094 "FDE address range");
3098 if (augmentation
[0])
3100 if (any_lsda_needed
)
3102 int size
= size_of_encoded_value (lsda_encoding
);
3104 if (lsda_encoding
== DW_EH_PE_aligned
)
3106 int offset
= ( 4 /* Length */
3107 + 4 /* CIE offset */
3108 + 2 * size_of_encoded_value (fde_encoding
)
3109 + 1 /* Augmentation size */ );
3110 int pad
= -offset
& (PTR_SIZE
- 1);
3113 gcc_assert (size_of_uleb128 (size
) == 1);
3116 dw2_asm_output_data_uleb128 (size
, "Augmentation size");
3118 if (fde
->uses_eh_lsda
)
3120 ASM_GENERATE_INTERNAL_LABEL (l1
, "LLSDA",
3121 fde
->funcdef_number
);
3122 dw2_asm_output_encoded_addr_rtx (
3123 lsda_encoding
, gen_rtx_SYMBOL_REF (Pmode
, l1
),
3124 false, "Language Specific Data Area");
3128 if (lsda_encoding
== DW_EH_PE_aligned
)
3129 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (PTR_SIZE
));
3131 (size_of_encoded_value (lsda_encoding
), 0,
3132 "Language Specific Data Area (none)");
3136 dw2_asm_output_data_uleb128 (0, "Augmentation size");
3139 /* Loop through the Call Frame Instructions associated with
3141 fde
->dw_fde_current_label
= fde
->dw_fde_begin
;
3142 for (cfi
= fde
->dw_fde_cfi
; cfi
!= NULL
; cfi
= cfi
->dw_cfi_next
)
3143 output_cfi (cfi
, fde
, for_eh
);
3145 /* Pad the FDE out to an address sized boundary. */
3146 ASM_OUTPUT_ALIGN (asm_out_file
,
3147 floor_log2 ((for_eh
? PTR_SIZE
: DWARF2_ADDR_SIZE
)));
3148 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
3151 if (for_eh
&& targetm
.terminate_dw2_eh_frame_info
)
3152 dw2_asm_output_data (4, 0, "End of Table");
3153 #ifdef MIPS_DEBUGGING_INFO
3154 /* Work around Irix 6 assembler bug whereby labels at the end of a section
3155 get a value of 0. Putting .align 0 after the label fixes it. */
3156 ASM_OUTPUT_ALIGN (asm_out_file
, 0);
3159 /* Turn off app to make assembly quicker. */
3164 /* Output a marker (i.e. a label) for the beginning of a function, before
3168 dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED
,
3169 const char *file ATTRIBUTE_UNUSED
)
3171 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3175 current_function_func_begin_label
= NULL
;
3177 #ifdef TARGET_UNWIND_INFO
3178 /* ??? current_function_func_begin_label is also used by except.c
3179 for call-site information. We must emit this label if it might
3181 if ((! flag_exceptions
|| USING_SJLJ_EXCEPTIONS
)
3182 && ! dwarf2out_do_frame ())
3185 if (! dwarf2out_do_frame ())
3189 switch_to_section (function_section (current_function_decl
));
3190 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_BEGIN_LABEL
,
3191 current_function_funcdef_no
);
3192 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, FUNC_BEGIN_LABEL
,
3193 current_function_funcdef_no
);
3194 dup_label
= xstrdup (label
);
3195 current_function_func_begin_label
= dup_label
;
3197 #ifdef TARGET_UNWIND_INFO
3198 /* We can elide the fde allocation if we're not emitting debug info. */
3199 if (! dwarf2out_do_frame ())
3203 /* Expand the fde table if necessary. */
3204 if (fde_table_in_use
== fde_table_allocated
)
3206 fde_table_allocated
+= FDE_TABLE_INCREMENT
;
3207 fde_table
= GGC_RESIZEVEC (dw_fde_node
, fde_table
, fde_table_allocated
);
3208 memset (fde_table
+ fde_table_in_use
, 0,
3209 FDE_TABLE_INCREMENT
* sizeof (dw_fde_node
));
3212 /* Record the FDE associated with this function. */
3213 current_funcdef_fde
= fde_table_in_use
;
3215 /* Add the new FDE at the end of the fde_table. */
3216 fde
= &fde_table
[fde_table_in_use
++];
3217 fde
->decl
= current_function_decl
;
3218 fde
->dw_fde_begin
= dup_label
;
3219 fde
->dw_fde_current_label
= dup_label
;
3220 fde
->dw_fde_hot_section_label
= NULL
;
3221 fde
->dw_fde_hot_section_end_label
= NULL
;
3222 fde
->dw_fde_unlikely_section_label
= NULL
;
3223 fde
->dw_fde_unlikely_section_end_label
= NULL
;
3224 fde
->dw_fde_switched_sections
= false;
3225 fde
->dw_fde_end
= NULL
;
3226 fde
->dw_fde_cfi
= NULL
;
3227 fde
->funcdef_number
= current_function_funcdef_no
;
3228 fde
->nothrow
= crtl
->nothrow
;
3229 fde
->uses_eh_lsda
= crtl
->uses_eh_lsda
;
3230 fde
->all_throwers_are_sibcalls
= crtl
->all_throwers_are_sibcalls
;
3231 fde
->drap_reg
= INVALID_REGNUM
;
3232 fde
->vdrap_reg
= INVALID_REGNUM
;
3234 args_size
= old_args_size
= 0;
3236 /* We only want to output line number information for the genuine dwarf2
3237 prologue case, not the eh frame case. */
3238 #ifdef DWARF2_DEBUGGING_INFO
3240 dwarf2out_source_line (line
, file
);
3243 if (dwarf2out_do_cfi_asm ())
3248 fprintf (asm_out_file
, "\t.cfi_startproc\n");
3250 if (eh_personality_libfunc
)
3252 enc
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
3253 ref
= eh_personality_libfunc
;
3255 /* ??? The GAS support isn't entirely consistent. We have to
3256 handle indirect support ourselves, but PC-relative is done
3257 in the assembler. Further, the assembler can't handle any
3258 of the weirder relocation types. */
3259 if (enc
& DW_EH_PE_indirect
)
3260 ref
= dw2_force_const_mem (ref
, true);
3262 fprintf (asm_out_file
, "\t.cfi_personality 0x%x,", enc
);
3263 output_addr_const (asm_out_file
, ref
);
3264 fputc ('\n', asm_out_file
);
3267 if (crtl
->uses_eh_lsda
)
3271 enc
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
3272 ASM_GENERATE_INTERNAL_LABEL (lab
, "LLSDA",
3273 current_function_funcdef_no
);
3274 ref
= gen_rtx_SYMBOL_REF (Pmode
, lab
);
3275 SYMBOL_REF_FLAGS (ref
) = SYMBOL_FLAG_LOCAL
;
3277 if (enc
& DW_EH_PE_indirect
)
3278 ref
= dw2_force_const_mem (ref
, true);
3280 fprintf (asm_out_file
, "\t.cfi_lsda 0x%x,", enc
);
3281 output_addr_const (asm_out_file
, ref
);
3282 fputc ('\n', asm_out_file
);
3287 /* Output a marker (i.e. a label) for the absolute end of the generated code
3288 for a function definition. This gets called *after* the epilogue code has
3292 dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED
,
3293 const char *file ATTRIBUTE_UNUSED
)
3296 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3298 if (dwarf2out_do_cfi_asm ())
3299 fprintf (asm_out_file
, "\t.cfi_endproc\n");
3301 /* Output a label to mark the endpoint of the code generated for this
3303 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_END_LABEL
,
3304 current_function_funcdef_no
);
3305 ASM_OUTPUT_LABEL (asm_out_file
, label
);
3306 fde
= current_fde ();
3307 gcc_assert (fde
!= NULL
);
3308 fde
->dw_fde_end
= xstrdup (label
);
3312 dwarf2out_frame_init (void)
3314 /* Allocate the initial hunk of the fde_table. */
3315 fde_table
= GGC_CNEWVEC (dw_fde_node
, FDE_TABLE_INCREMENT
);
3316 fde_table_allocated
= FDE_TABLE_INCREMENT
;
3317 fde_table_in_use
= 0;
3319 /* Generate the CFA instructions common to all FDE's. Do it now for the
3320 sake of lookup_cfa. */
3322 /* On entry, the Canonical Frame Address is at SP. */
3323 dwarf2out_def_cfa (NULL
, STACK_POINTER_REGNUM
, INCOMING_FRAME_SP_OFFSET
);
3325 #ifdef DWARF2_UNWIND_INFO
3326 if (DWARF2_UNWIND_INFO
|| DWARF2_FRAME_INFO
)
3327 initial_return_save (INCOMING_RETURN_ADDR_RTX
);
3332 dwarf2out_frame_finish (void)
3334 /* Output call frame information. */
3335 if (DWARF2_FRAME_INFO
)
3336 output_call_frame_info (0);
3338 #ifndef TARGET_UNWIND_INFO
3339 /* Output another copy for the unwinder. */
3340 if (! USING_SJLJ_EXCEPTIONS
&& (flag_unwind_tables
|| flag_exceptions
))
3341 output_call_frame_info (1);
3345 /* Note that the current function section is being used for code. */
3348 dwarf2out_note_section_used (void)
3350 section
*sec
= current_function_section ();
3351 if (sec
== text_section
)
3352 text_section_used
= true;
3353 else if (sec
== cold_text_section
)
3354 cold_text_section_used
= true;
3358 dwarf2out_switch_text_section (void)
3360 dw_fde_ref fde
= current_fde ();
3362 gcc_assert (cfun
&& fde
);
3364 fde
->dw_fde_switched_sections
= true;
3365 fde
->dw_fde_hot_section_label
= crtl
->subsections
.hot_section_label
;
3366 fde
->dw_fde_hot_section_end_label
= crtl
->subsections
.hot_section_end_label
;
3367 fde
->dw_fde_unlikely_section_label
= crtl
->subsections
.cold_section_label
;
3368 fde
->dw_fde_unlikely_section_end_label
= crtl
->subsections
.cold_section_end_label
;
3369 have_multiple_function_sections
= true;
3371 /* Reset the current label on switching text sections, so that we
3372 don't attempt to advance_loc4 between labels in different sections. */
3373 fde
->dw_fde_current_label
= NULL
;
3375 /* There is no need to mark used sections when not debugging. */
3376 if (cold_text_section
!= NULL
)
3377 dwarf2out_note_section_used ();
3381 /* And now, the subset of the debugging information support code necessary
3382 for emitting location expressions. */
3384 /* Data about a single source file. */
3385 struct GTY(()) dwarf_file_data
{
3386 const char * filename
;
3390 /* We need some way to distinguish DW_OP_addr with a direct symbol
3391 relocation from DW_OP_addr with a dtp-relative symbol relocation. */
3392 #define INTERNAL_DW_OP_tls_addr (0x100 + DW_OP_addr)
3395 typedef struct dw_val_struct
*dw_val_ref
;
3396 typedef struct die_struct
*dw_die_ref
;
3397 typedef const struct die_struct
*const_dw_die_ref
;
3398 typedef struct dw_loc_descr_struct
*dw_loc_descr_ref
;
3399 typedef struct dw_loc_list_struct
*dw_loc_list_ref
;
3401 typedef struct GTY(()) deferred_locations_struct
3405 } deferred_locations
;
3407 DEF_VEC_O(deferred_locations
);
3408 DEF_VEC_ALLOC_O(deferred_locations
,gc
);
3410 static GTY(()) VEC(deferred_locations
, gc
) *deferred_locations_list
;
3412 /* Each DIE may have a series of attribute/value pairs. Values
3413 can take on several forms. The forms that are used in this
3414 implementation are listed below. */
3419 dw_val_class_offset
,
3421 dw_val_class_loc_list
,
3422 dw_val_class_range_list
,
3424 dw_val_class_unsigned_const
,
3425 dw_val_class_long_long
,
3428 dw_val_class_die_ref
,
3429 dw_val_class_fde_ref
,
3430 dw_val_class_lbl_id
,
3431 dw_val_class_lineptr
,
3433 dw_val_class_macptr
,
3437 /* Describe a double word constant value. */
3438 /* ??? Every instance of long_long in the code really means CONST_DOUBLE. */
3440 typedef struct GTY(()) dw_long_long_struct
{
3446 /* Describe a floating point constant value, or a vector constant value. */
3448 typedef struct GTY(()) dw_vec_struct
{
3449 unsigned char * GTY((length ("%h.length"))) array
;
3455 /* The dw_val_node describes an attribute's value, as it is
3456 represented internally. */
3458 typedef struct GTY(()) dw_val_struct
{
3459 enum dw_val_class val_class
;
3460 union dw_val_struct_union
3462 rtx
GTY ((tag ("dw_val_class_addr"))) val_addr
;
3463 unsigned HOST_WIDE_INT
GTY ((tag ("dw_val_class_offset"))) val_offset
;
3464 dw_loc_list_ref
GTY ((tag ("dw_val_class_loc_list"))) val_loc_list
;
3465 dw_loc_descr_ref
GTY ((tag ("dw_val_class_loc"))) val_loc
;
3466 HOST_WIDE_INT
GTY ((default)) val_int
;
3467 unsigned HOST_WIDE_INT
GTY ((tag ("dw_val_class_unsigned_const"))) val_unsigned
;
3468 dw_long_long_const
GTY ((tag ("dw_val_class_long_long"))) val_long_long
;
3469 dw_vec_const
GTY ((tag ("dw_val_class_vec"))) val_vec
;
3470 struct dw_val_die_union
3474 } GTY ((tag ("dw_val_class_die_ref"))) val_die_ref
;
3475 unsigned GTY ((tag ("dw_val_class_fde_ref"))) val_fde_index
;
3476 struct indirect_string_node
* GTY ((tag ("dw_val_class_str"))) val_str
;
3477 char * GTY ((tag ("dw_val_class_lbl_id"))) val_lbl_id
;
3478 unsigned char GTY ((tag ("dw_val_class_flag"))) val_flag
;
3479 struct dwarf_file_data
* GTY ((tag ("dw_val_class_file"))) val_file
;
3481 GTY ((desc ("%1.val_class"))) v
;
3485 /* Locations in memory are described using a sequence of stack machine
3488 typedef struct GTY(()) dw_loc_descr_struct
{
3489 dw_loc_descr_ref dw_loc_next
;
3490 enum dwarf_location_atom dw_loc_opc
;
3492 dw_val_node dw_loc_oprnd1
;
3493 dw_val_node dw_loc_oprnd2
;
3497 /* Location lists are ranges + location descriptions for that range,
3498 so you can track variables that are in different places over
3499 their entire life. */
3500 typedef struct GTY(()) dw_loc_list_struct
{
3501 dw_loc_list_ref dw_loc_next
;
3502 const char *begin
; /* Label for begin address of range */
3503 const char *end
; /* Label for end address of range */
3504 char *ll_symbol
; /* Label for beginning of location list.
3505 Only on head of list */
3506 const char *section
; /* Section this loclist is relative to */
3507 dw_loc_descr_ref expr
;
3510 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
3512 static dw_loc_descr_ref
int_loc_descriptor (HOST_WIDE_INT
);
3514 /* Convert a DWARF stack opcode into its string name. */
3517 dwarf_stack_op_name (unsigned int op
)
3522 case INTERNAL_DW_OP_tls_addr
:
3523 return "DW_OP_addr";
3525 return "DW_OP_deref";
3527 return "DW_OP_const1u";
3529 return "DW_OP_const1s";
3531 return "DW_OP_const2u";
3533 return "DW_OP_const2s";
3535 return "DW_OP_const4u";
3537 return "DW_OP_const4s";
3539 return "DW_OP_const8u";
3541 return "DW_OP_const8s";
3543 return "DW_OP_constu";
3545 return "DW_OP_consts";
3549 return "DW_OP_drop";
3551 return "DW_OP_over";
3553 return "DW_OP_pick";
3555 return "DW_OP_swap";
3559 return "DW_OP_xderef";
3567 return "DW_OP_minus";
3579 return "DW_OP_plus";
3580 case DW_OP_plus_uconst
:
3581 return "DW_OP_plus_uconst";
3587 return "DW_OP_shra";
3605 return "DW_OP_skip";
3607 return "DW_OP_lit0";
3609 return "DW_OP_lit1";
3611 return "DW_OP_lit2";
3613 return "DW_OP_lit3";
3615 return "DW_OP_lit4";
3617 return "DW_OP_lit5";
3619 return "DW_OP_lit6";
3621 return "DW_OP_lit7";
3623 return "DW_OP_lit8";
3625 return "DW_OP_lit9";
3627 return "DW_OP_lit10";
3629 return "DW_OP_lit11";
3631 return "DW_OP_lit12";
3633 return "DW_OP_lit13";
3635 return "DW_OP_lit14";
3637 return "DW_OP_lit15";
3639 return "DW_OP_lit16";
3641 return "DW_OP_lit17";
3643 return "DW_OP_lit18";
3645 return "DW_OP_lit19";
3647 return "DW_OP_lit20";
3649 return "DW_OP_lit21";
3651 return "DW_OP_lit22";
3653 return "DW_OP_lit23";
3655 return "DW_OP_lit24";
3657 return "DW_OP_lit25";
3659 return "DW_OP_lit26";
3661 return "DW_OP_lit27";
3663 return "DW_OP_lit28";
3665 return "DW_OP_lit29";
3667 return "DW_OP_lit30";
3669 return "DW_OP_lit31";
3671 return "DW_OP_reg0";
3673 return "DW_OP_reg1";
3675 return "DW_OP_reg2";
3677 return "DW_OP_reg3";
3679 return "DW_OP_reg4";
3681 return "DW_OP_reg5";
3683 return "DW_OP_reg6";
3685 return "DW_OP_reg7";
3687 return "DW_OP_reg8";
3689 return "DW_OP_reg9";
3691 return "DW_OP_reg10";
3693 return "DW_OP_reg11";
3695 return "DW_OP_reg12";
3697 return "DW_OP_reg13";
3699 return "DW_OP_reg14";
3701 return "DW_OP_reg15";
3703 return "DW_OP_reg16";
3705 return "DW_OP_reg17";
3707 return "DW_OP_reg18";
3709 return "DW_OP_reg19";
3711 return "DW_OP_reg20";
3713 return "DW_OP_reg21";
3715 return "DW_OP_reg22";
3717 return "DW_OP_reg23";
3719 return "DW_OP_reg24";
3721 return "DW_OP_reg25";
3723 return "DW_OP_reg26";
3725 return "DW_OP_reg27";
3727 return "DW_OP_reg28";
3729 return "DW_OP_reg29";
3731 return "DW_OP_reg30";
3733 return "DW_OP_reg31";
3735 return "DW_OP_breg0";
3737 return "DW_OP_breg1";
3739 return "DW_OP_breg2";
3741 return "DW_OP_breg3";
3743 return "DW_OP_breg4";
3745 return "DW_OP_breg5";
3747 return "DW_OP_breg6";
3749 return "DW_OP_breg7";
3751 return "DW_OP_breg8";
3753 return "DW_OP_breg9";
3755 return "DW_OP_breg10";
3757 return "DW_OP_breg11";
3759 return "DW_OP_breg12";
3761 return "DW_OP_breg13";
3763 return "DW_OP_breg14";
3765 return "DW_OP_breg15";
3767 return "DW_OP_breg16";
3769 return "DW_OP_breg17";
3771 return "DW_OP_breg18";
3773 return "DW_OP_breg19";
3775 return "DW_OP_breg20";
3777 return "DW_OP_breg21";
3779 return "DW_OP_breg22";
3781 return "DW_OP_breg23";
3783 return "DW_OP_breg24";
3785 return "DW_OP_breg25";
3787 return "DW_OP_breg26";
3789 return "DW_OP_breg27";
3791 return "DW_OP_breg28";
3793 return "DW_OP_breg29";
3795 return "DW_OP_breg30";
3797 return "DW_OP_breg31";
3799 return "DW_OP_regx";
3801 return "DW_OP_fbreg";
3803 return "DW_OP_bregx";
3805 return "DW_OP_piece";
3806 case DW_OP_deref_size
:
3807 return "DW_OP_deref_size";
3808 case DW_OP_xderef_size
:
3809 return "DW_OP_xderef_size";
3812 case DW_OP_push_object_address
:
3813 return "DW_OP_push_object_address";
3815 return "DW_OP_call2";
3817 return "DW_OP_call4";
3818 case DW_OP_call_ref
:
3819 return "DW_OP_call_ref";
3820 case DW_OP_GNU_push_tls_address
:
3821 return "DW_OP_GNU_push_tls_address";
3822 case DW_OP_GNU_uninit
:
3823 return "DW_OP_GNU_uninit";
3825 return "OP_<unknown>";
3829 /* Return a pointer to a newly allocated location description. Location
3830 descriptions are simple expression terms that can be strung
3831 together to form more complicated location (address) descriptions. */
3833 static inline dw_loc_descr_ref
3834 new_loc_descr (enum dwarf_location_atom op
, unsigned HOST_WIDE_INT oprnd1
,
3835 unsigned HOST_WIDE_INT oprnd2
)
3837 dw_loc_descr_ref descr
= GGC_CNEW (dw_loc_descr_node
);
3839 descr
->dw_loc_opc
= op
;
3840 descr
->dw_loc_oprnd1
.val_class
= dw_val_class_unsigned_const
;
3841 descr
->dw_loc_oprnd1
.v
.val_unsigned
= oprnd1
;
3842 descr
->dw_loc_oprnd2
.val_class
= dw_val_class_unsigned_const
;
3843 descr
->dw_loc_oprnd2
.v
.val_unsigned
= oprnd2
;
3848 /* Return a pointer to a newly allocated location description for
3851 static inline dw_loc_descr_ref
3852 new_reg_loc_descr (unsigned int reg
, unsigned HOST_WIDE_INT offset
)
3857 return new_loc_descr ((enum dwarf_location_atom
) (DW_OP_breg0
+ reg
),
3860 return new_loc_descr (DW_OP_bregx
, reg
, offset
);
3863 return new_loc_descr ((enum dwarf_location_atom
) (DW_OP_reg0
+ reg
), 0, 0);
3865 return new_loc_descr (DW_OP_regx
, reg
, 0);
3868 /* Add a location description term to a location description expression. */
3871 add_loc_descr (dw_loc_descr_ref
*list_head
, dw_loc_descr_ref descr
)
3873 dw_loc_descr_ref
*d
;
3875 /* Find the end of the chain. */
3876 for (d
= list_head
; (*d
) != NULL
; d
= &(*d
)->dw_loc_next
)
3882 /* Add a constant OFFSET to a location expression. */
3885 loc_descr_plus_const (dw_loc_descr_ref
*list_head
, HOST_WIDE_INT offset
)
3887 dw_loc_descr_ref loc
;
3890 gcc_assert (*list_head
!= NULL
);
3895 /* Find the end of the chain. */
3896 for (loc
= *list_head
; loc
->dw_loc_next
!= NULL
; loc
= loc
->dw_loc_next
)
3900 if (loc
->dw_loc_opc
== DW_OP_fbreg
3901 || (loc
->dw_loc_opc
>= DW_OP_breg0
&& loc
->dw_loc_opc
<= DW_OP_breg31
))
3902 p
= &loc
->dw_loc_oprnd1
.v
.val_int
;
3903 else if (loc
->dw_loc_opc
== DW_OP_bregx
)
3904 p
= &loc
->dw_loc_oprnd2
.v
.val_int
;
3906 /* If the last operation is fbreg, breg{0..31,x}, optimize by adjusting its
3907 offset. Don't optimize if an signed integer overflow would happen. */
3909 && ((offset
> 0 && *p
<= INTTYPE_MAXIMUM (HOST_WIDE_INT
) - offset
)
3910 || (offset
< 0 && *p
>= INTTYPE_MINIMUM (HOST_WIDE_INT
) - offset
)))
3913 else if (offset
> 0)
3914 loc
->dw_loc_next
= new_loc_descr (DW_OP_plus_uconst
, offset
, 0);
3918 loc
->dw_loc_next
= int_loc_descriptor (offset
);
3919 add_loc_descr (&loc
->dw_loc_next
, new_loc_descr (DW_OP_plus
, 0, 0));
3923 /* Return the size of a location descriptor. */
3925 static unsigned long
3926 size_of_loc_descr (dw_loc_descr_ref loc
)
3928 unsigned long size
= 1;
3930 switch (loc
->dw_loc_opc
)
3933 case INTERNAL_DW_OP_tls_addr
:
3934 size
+= DWARF2_ADDR_SIZE
;
3953 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
3956 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
3961 case DW_OP_plus_uconst
:
3962 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
4000 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
4003 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
4006 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
4009 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
4010 size
+= size_of_sleb128 (loc
->dw_loc_oprnd2
.v
.val_int
);
4013 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
4015 case DW_OP_deref_size
:
4016 case DW_OP_xderef_size
:
4025 case DW_OP_call_ref
:
4026 size
+= DWARF2_ADDR_SIZE
;
4035 /* Return the size of a series of location descriptors. */
4037 static unsigned long
4038 size_of_locs (dw_loc_descr_ref loc
)
4043 /* If there are no skip or bra opcodes, don't fill in the dw_loc_addr
4044 field, to avoid writing to a PCH file. */
4045 for (size
= 0, l
= loc
; l
!= NULL
; l
= l
->dw_loc_next
)
4047 if (l
->dw_loc_opc
== DW_OP_skip
|| l
->dw_loc_opc
== DW_OP_bra
)
4049 size
+= size_of_loc_descr (l
);
4054 for (size
= 0, l
= loc
; l
!= NULL
; l
= l
->dw_loc_next
)
4056 l
->dw_loc_addr
= size
;
4057 size
+= size_of_loc_descr (l
);
4063 /* Output location description stack opcode's operands (if any). */
4066 output_loc_operands (dw_loc_descr_ref loc
)
4068 dw_val_ref val1
= &loc
->dw_loc_oprnd1
;
4069 dw_val_ref val2
= &loc
->dw_loc_oprnd2
;
4071 switch (loc
->dw_loc_opc
)
4073 #ifdef DWARF2_DEBUGGING_INFO
4075 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, val1
->v
.val_addr
, NULL
);
4079 dw2_asm_output_data (2, val1
->v
.val_int
, NULL
);
4083 dw2_asm_output_data (4, val1
->v
.val_int
, NULL
);
4087 gcc_assert (HOST_BITS_PER_LONG
>= 64);
4088 dw2_asm_output_data (8, val1
->v
.val_int
, NULL
);
4095 gcc_assert (val1
->val_class
== dw_val_class_loc
);
4096 offset
= val1
->v
.val_loc
->dw_loc_addr
- (loc
->dw_loc_addr
+ 3);
4098 dw2_asm_output_data (2, offset
, NULL
);
4111 /* We currently don't make any attempt to make sure these are
4112 aligned properly like we do for the main unwind info, so
4113 don't support emitting things larger than a byte if we're
4114 only doing unwinding. */
4119 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
4122 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
4125 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
4128 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
4130 case DW_OP_plus_uconst
:
4131 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
4165 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
4168 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
4171 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
4174 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
4175 dw2_asm_output_data_sleb128 (val2
->v
.val_int
, NULL
);
4178 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
4180 case DW_OP_deref_size
:
4181 case DW_OP_xderef_size
:
4182 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
4185 case INTERNAL_DW_OP_tls_addr
:
4186 if (targetm
.asm_out
.output_dwarf_dtprel
)
4188 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
,
4191 fputc ('\n', asm_out_file
);
4198 /* Other codes have no operands. */
4203 /* Output a sequence of location operations. */
4206 output_loc_sequence (dw_loc_descr_ref loc
)
4208 for (; loc
!= NULL
; loc
= loc
->dw_loc_next
)
4210 /* Output the opcode. */
4211 dw2_asm_output_data (1, loc
->dw_loc_opc
,
4212 "%s", dwarf_stack_op_name (loc
->dw_loc_opc
));
4214 /* Output the operand(s) (if any). */
4215 output_loc_operands (loc
);
4219 /* Output location description stack opcode's operands (if any).
4220 The output is single bytes on a line, suitable for .cfi_escape. */
4223 output_loc_operands_raw (dw_loc_descr_ref loc
)
4225 dw_val_ref val1
= &loc
->dw_loc_oprnd1
;
4226 dw_val_ref val2
= &loc
->dw_loc_oprnd2
;
4228 switch (loc
->dw_loc_opc
)
4231 /* We cannot output addresses in .cfi_escape, only bytes. */
4237 case DW_OP_deref_size
:
4238 case DW_OP_xderef_size
:
4239 fputc (',', asm_out_file
);
4240 dw2_asm_output_data_raw (1, val1
->v
.val_int
);
4245 fputc (',', asm_out_file
);
4246 dw2_asm_output_data_raw (2, val1
->v
.val_int
);
4251 fputc (',', asm_out_file
);
4252 dw2_asm_output_data_raw (4, val1
->v
.val_int
);
4257 gcc_assert (HOST_BITS_PER_LONG
>= 64);
4258 fputc (',', asm_out_file
);
4259 dw2_asm_output_data_raw (8, val1
->v
.val_int
);
4267 gcc_assert (val1
->val_class
== dw_val_class_loc
);
4268 offset
= val1
->v
.val_loc
->dw_loc_addr
- (loc
->dw_loc_addr
+ 3);
4270 fputc (',', asm_out_file
);
4271 dw2_asm_output_data_raw (2, offset
);
4276 case DW_OP_plus_uconst
:
4279 fputc (',', asm_out_file
);
4280 dw2_asm_output_data_uleb128_raw (val1
->v
.val_unsigned
);
4317 fputc (',', asm_out_file
);
4318 dw2_asm_output_data_sleb128_raw (val1
->v
.val_int
);
4322 fputc (',', asm_out_file
);
4323 dw2_asm_output_data_uleb128_raw (val1
->v
.val_unsigned
);
4324 fputc (',', asm_out_file
);
4325 dw2_asm_output_data_sleb128_raw (val2
->v
.val_int
);
4328 case INTERNAL_DW_OP_tls_addr
:
4332 /* Other codes have no operands. */
4338 output_loc_sequence_raw (dw_loc_descr_ref loc
)
4342 /* Output the opcode. */
4343 fprintf (asm_out_file
, "0x%x", loc
->dw_loc_opc
);
4344 output_loc_operands_raw (loc
);
4346 if (!loc
->dw_loc_next
)
4348 loc
= loc
->dw_loc_next
;
4350 fputc (',', asm_out_file
);
4354 /* This routine will generate the correct assembly data for a location
4355 description based on a cfi entry with a complex address. */
4358 output_cfa_loc (dw_cfi_ref cfi
)
4360 dw_loc_descr_ref loc
;
4363 if (cfi
->dw_cfi_opc
== DW_CFA_expression
)
4364 dw2_asm_output_data (1, cfi
->dw_cfi_oprnd2
.dw_cfi_reg_num
, NULL
);
4366 /* Output the size of the block. */
4367 loc
= cfi
->dw_cfi_oprnd1
.dw_cfi_loc
;
4368 size
= size_of_locs (loc
);
4369 dw2_asm_output_data_uleb128 (size
, NULL
);
4371 /* Now output the operations themselves. */
4372 output_loc_sequence (loc
);
4375 /* Similar, but used for .cfi_escape. */
4378 output_cfa_loc_raw (dw_cfi_ref cfi
)
4380 dw_loc_descr_ref loc
;
4383 if (cfi
->dw_cfi_opc
== DW_CFA_expression
)
4384 fprintf (asm_out_file
, "0x%x,", cfi
->dw_cfi_oprnd2
.dw_cfi_reg_num
);
4386 /* Output the size of the block. */
4387 loc
= cfi
->dw_cfi_oprnd1
.dw_cfi_loc
;
4388 size
= size_of_locs (loc
);
4389 dw2_asm_output_data_uleb128_raw (size
);
4390 fputc (',', asm_out_file
);
4392 /* Now output the operations themselves. */
4393 output_loc_sequence_raw (loc
);
4396 /* This function builds a dwarf location descriptor sequence from a
4397 dw_cfa_location, adding the given OFFSET to the result of the
4400 static struct dw_loc_descr_struct
*
4401 build_cfa_loc (dw_cfa_location
*cfa
, HOST_WIDE_INT offset
)
4403 struct dw_loc_descr_struct
*head
, *tmp
;
4405 offset
+= cfa
->offset
;
4409 head
= new_reg_loc_descr (cfa
->reg
, cfa
->base_offset
);
4410 head
->dw_loc_oprnd1
.val_class
= dw_val_class_const
;
4411 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
4412 add_loc_descr (&head
, tmp
);
4415 tmp
= new_loc_descr (DW_OP_plus_uconst
, offset
, 0);
4416 add_loc_descr (&head
, tmp
);
4420 head
= new_reg_loc_descr (cfa
->reg
, offset
);
4425 /* This function builds a dwarf location descriptor sequence for
4426 the address at OFFSET from the CFA when stack is aligned to
4429 static struct dw_loc_descr_struct
*
4430 build_cfa_aligned_loc (HOST_WIDE_INT offset
, HOST_WIDE_INT alignment
)
4432 struct dw_loc_descr_struct
*head
;
4433 unsigned int dwarf_fp
4434 = DWARF_FRAME_REGNUM (HARD_FRAME_POINTER_REGNUM
);
4436 /* When CFA is defined as FP+OFFSET, emulate stack alignment. */
4437 if (cfa
.reg
== HARD_FRAME_POINTER_REGNUM
&& cfa
.indirect
== 0)
4439 head
= new_reg_loc_descr (dwarf_fp
, 0);
4440 add_loc_descr (&head
, int_loc_descriptor (alignment
));
4441 add_loc_descr (&head
, new_loc_descr (DW_OP_and
, 0, 0));
4442 loc_descr_plus_const (&head
, offset
);
4445 head
= new_reg_loc_descr (dwarf_fp
, offset
);
4449 /* This function fills in aa dw_cfa_location structure from a dwarf location
4450 descriptor sequence. */
4453 get_cfa_from_loc_descr (dw_cfa_location
*cfa
, struct dw_loc_descr_struct
*loc
)
4455 struct dw_loc_descr_struct
*ptr
;
4457 cfa
->base_offset
= 0;
4461 for (ptr
= loc
; ptr
!= NULL
; ptr
= ptr
->dw_loc_next
)
4463 enum dwarf_location_atom op
= ptr
->dw_loc_opc
;
4499 cfa
->reg
= op
- DW_OP_reg0
;
4502 cfa
->reg
= ptr
->dw_loc_oprnd1
.v
.val_int
;
4536 cfa
->reg
= op
- DW_OP_breg0
;
4537 cfa
->base_offset
= ptr
->dw_loc_oprnd1
.v
.val_int
;
4540 cfa
->reg
= ptr
->dw_loc_oprnd1
.v
.val_int
;
4541 cfa
->base_offset
= ptr
->dw_loc_oprnd2
.v
.val_int
;
4546 case DW_OP_plus_uconst
:
4547 cfa
->offset
= ptr
->dw_loc_oprnd1
.v
.val_unsigned
;
4550 internal_error ("DW_LOC_OP %s not implemented",
4551 dwarf_stack_op_name (ptr
->dw_loc_opc
));
4555 #endif /* .debug_frame support */
4557 /* And now, the support for symbolic debugging information. */
4558 #ifdef DWARF2_DEBUGGING_INFO
4560 /* .debug_str support. */
4561 static int output_indirect_string (void **, void *);
4563 static void dwarf2out_init (const char *);
4564 static void dwarf2out_finish (const char *);
4565 static void dwarf2out_define (unsigned int, const char *);
4566 static void dwarf2out_undef (unsigned int, const char *);
4567 static void dwarf2out_start_source_file (unsigned, const char *);
4568 static void dwarf2out_end_source_file (unsigned);
4569 static void dwarf2out_begin_block (unsigned, unsigned);
4570 static void dwarf2out_end_block (unsigned, unsigned);
4571 static bool dwarf2out_ignore_block (const_tree
);
4572 static void dwarf2out_global_decl (tree
);
4573 static void dwarf2out_type_decl (tree
, int);
4574 static void dwarf2out_imported_module_or_decl (tree
, tree
, tree
, bool);
4575 static void dwarf2out_imported_module_or_decl_1 (tree
, tree
, tree
,
4577 static void dwarf2out_abstract_function (tree
);
4578 static void dwarf2out_var_location (rtx
);
4579 static void dwarf2out_begin_function (tree
);
4580 static void dwarf2out_set_name (tree
, tree
);
4582 /* The debug hooks structure. */
4584 const struct gcc_debug_hooks dwarf2_debug_hooks
=
4590 dwarf2out_start_source_file
,
4591 dwarf2out_end_source_file
,
4592 dwarf2out_begin_block
,
4593 dwarf2out_end_block
,
4594 dwarf2out_ignore_block
,
4595 dwarf2out_source_line
,
4596 dwarf2out_begin_prologue
,
4597 debug_nothing_int_charstar
, /* end_prologue */
4598 dwarf2out_end_epilogue
,
4599 dwarf2out_begin_function
,
4600 debug_nothing_int
, /* end_function */
4601 dwarf2out_decl
, /* function_decl */
4602 dwarf2out_global_decl
,
4603 dwarf2out_type_decl
, /* type_decl */
4604 dwarf2out_imported_module_or_decl
,
4605 debug_nothing_tree
, /* deferred_inline_function */
4606 /* The DWARF 2 backend tries to reduce debugging bloat by not
4607 emitting the abstract description of inline functions until
4608 something tries to reference them. */
4609 dwarf2out_abstract_function
, /* outlining_inline_function */
4610 debug_nothing_rtx
, /* label */
4611 debug_nothing_int
, /* handle_pch */
4612 dwarf2out_var_location
,
4613 dwarf2out_switch_text_section
,
4615 1 /* start_end_main_source_file */
4619 /* NOTE: In the comments in this file, many references are made to
4620 "Debugging Information Entries". This term is abbreviated as `DIE'
4621 throughout the remainder of this file. */
4623 /* An internal representation of the DWARF output is built, and then
4624 walked to generate the DWARF debugging info. The walk of the internal
4625 representation is done after the entire program has been compiled.
4626 The types below are used to describe the internal representation. */
4628 /* Various DIE's use offsets relative to the beginning of the
4629 .debug_info section to refer to each other. */
4631 typedef long int dw_offset
;
4633 /* Define typedefs here to avoid circular dependencies. */
4635 typedef struct dw_attr_struct
*dw_attr_ref
;
4636 typedef struct dw_line_info_struct
*dw_line_info_ref
;
4637 typedef struct dw_separate_line_info_struct
*dw_separate_line_info_ref
;
4638 typedef struct pubname_struct
*pubname_ref
;
4639 typedef struct dw_ranges_struct
*dw_ranges_ref
;
4640 typedef struct dw_ranges_by_label_struct
*dw_ranges_by_label_ref
;
4642 /* Each entry in the line_info_table maintains the file and
4643 line number associated with the label generated for that
4644 entry. The label gives the PC value associated with
4645 the line number entry. */
4647 typedef struct GTY(()) dw_line_info_struct
{
4648 unsigned long dw_file_num
;
4649 unsigned long dw_line_num
;
4653 /* Line information for functions in separate sections; each one gets its
4655 typedef struct GTY(()) dw_separate_line_info_struct
{
4656 unsigned long dw_file_num
;
4657 unsigned long dw_line_num
;
4658 unsigned long function
;
4660 dw_separate_line_info_entry
;
4662 /* Each DIE attribute has a field specifying the attribute kind,
4663 a link to the next attribute in the chain, and an attribute value.
4664 Attributes are typically linked below the DIE they modify. */
4666 typedef struct GTY(()) dw_attr_struct
{
4667 enum dwarf_attribute dw_attr
;
4668 dw_val_node dw_attr_val
;
4672 DEF_VEC_O(dw_attr_node
);
4673 DEF_VEC_ALLOC_O(dw_attr_node
,gc
);
4675 /* The Debugging Information Entry (DIE) structure. DIEs form a tree.
4676 The children of each node form a circular list linked by
4677 die_sib. die_child points to the node *before* the "first" child node. */
4679 typedef struct GTY((chain_circular ("%h.die_sib"))) die_struct
{
4680 enum dwarf_tag die_tag
;
4682 VEC(dw_attr_node
,gc
) * die_attr
;
4683 dw_die_ref die_parent
;
4684 dw_die_ref die_child
;
4686 dw_die_ref die_definition
; /* ref from a specification to its definition */
4687 dw_offset die_offset
;
4688 unsigned long die_abbrev
;
4690 /* Die is used and must not be pruned as unused. */
4691 int die_perennial_p
;
4692 unsigned int decl_id
;
4696 /* Evaluate 'expr' while 'c' is set to each child of DIE in order. */
4697 #define FOR_EACH_CHILD(die, c, expr) do { \
4698 c = die->die_child; \
4702 } while (c != die->die_child); \
4705 /* The pubname structure */
4707 typedef struct GTY(()) pubname_struct
{
4713 DEF_VEC_O(pubname_entry
);
4714 DEF_VEC_ALLOC_O(pubname_entry
, gc
);
4716 struct GTY(()) dw_ranges_struct
{
4717 /* If this is positive, it's a block number, otherwise it's a
4718 bitwise-negated index into dw_ranges_by_label. */
4722 struct GTY(()) dw_ranges_by_label_struct
{
4727 /* The limbo die list structure. */
4728 typedef struct GTY(()) limbo_die_struct
{
4731 struct limbo_die_struct
*next
;
4735 /* How to start an assembler comment. */
4736 #ifndef ASM_COMMENT_START
4737 #define ASM_COMMENT_START ";#"
4740 /* Define a macro which returns nonzero for a TYPE_DECL which was
4741 implicitly generated for a tagged type.
4743 Note that unlike the gcc front end (which generates a NULL named
4744 TYPE_DECL node for each complete tagged type, each array type, and
4745 each function type node created) the g++ front end generates a
4746 _named_ TYPE_DECL node for each tagged type node created.
4747 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
4748 generate a DW_TAG_typedef DIE for them. */
4750 #define TYPE_DECL_IS_STUB(decl) \
4751 (DECL_NAME (decl) == NULL_TREE \
4752 || (DECL_ARTIFICIAL (decl) \
4753 && is_tagged_type (TREE_TYPE (decl)) \
4754 && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \
4755 /* This is necessary for stub decls that \
4756 appear in nested inline functions. */ \
4757 || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
4758 && (decl_ultimate_origin (decl) \
4759 == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
4761 /* Information concerning the compilation unit's programming
4762 language, and compiler version. */
4764 /* Fixed size portion of the DWARF compilation unit header. */
4765 #define DWARF_COMPILE_UNIT_HEADER_SIZE \
4766 (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 3)
4768 /* Fixed size portion of public names info. */
4769 #define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
4771 /* Fixed size portion of the address range info. */
4772 #define DWARF_ARANGES_HEADER_SIZE \
4773 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
4774 DWARF2_ADDR_SIZE * 2) \
4775 - DWARF_INITIAL_LENGTH_SIZE)
4777 /* Size of padding portion in the address range info. It must be
4778 aligned to twice the pointer size. */
4779 #define DWARF_ARANGES_PAD_SIZE \
4780 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
4781 DWARF2_ADDR_SIZE * 2) \
4782 - (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4))
4784 /* Use assembler line directives if available. */
4785 #ifndef DWARF2_ASM_LINE_DEBUG_INFO
4786 #ifdef HAVE_AS_DWARF2_DEBUG_LINE
4787 #define DWARF2_ASM_LINE_DEBUG_INFO 1
4789 #define DWARF2_ASM_LINE_DEBUG_INFO 0
4793 /* Minimum line offset in a special line info. opcode.
4794 This value was chosen to give a reasonable range of values. */
4795 #define DWARF_LINE_BASE -10
4797 /* First special line opcode - leave room for the standard opcodes. */
4798 #define DWARF_LINE_OPCODE_BASE 10
4800 /* Range of line offsets in a special line info. opcode. */
4801 #define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1)
4803 /* Flag that indicates the initial value of the is_stmt_start flag.
4804 In the present implementation, we do not mark any lines as
4805 the beginning of a source statement, because that information
4806 is not made available by the GCC front-end. */
4807 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
4809 #ifdef DWARF2_DEBUGGING_INFO
4810 /* This location is used by calc_die_sizes() to keep track
4811 the offset of each DIE within the .debug_info section. */
4812 static unsigned long next_die_offset
;
4815 /* Record the root of the DIE's built for the current compilation unit. */
4816 static GTY(()) dw_die_ref comp_unit_die
;
4818 /* A list of DIEs with a NULL parent waiting to be relocated. */
4819 static GTY(()) limbo_die_node
*limbo_die_list
;
4821 /* Filenames referenced by this compilation unit. */
4822 static GTY((param_is (struct dwarf_file_data
))) htab_t file_table
;
4824 /* A hash table of references to DIE's that describe declarations.
4825 The key is a DECL_UID() which is a unique number identifying each decl. */
4826 static GTY ((param_is (struct die_struct
))) htab_t decl_die_table
;
4828 /* A hash table of references to DIE's that describe COMMON blocks.
4829 The key is DECL_UID() ^ die_parent. */
4830 static GTY ((param_is (struct die_struct
))) htab_t common_block_die_table
;
4832 /* Node of the variable location list. */
4833 struct GTY ((chain_next ("%h.next"))) var_loc_node
{
4834 rtx
GTY (()) var_loc_note
;
4835 const char * GTY (()) label
;
4836 const char * GTY (()) section_label
;
4837 struct var_loc_node
* GTY (()) next
;
4840 /* Variable location list. */
4841 struct GTY (()) var_loc_list_def
{
4842 struct var_loc_node
* GTY (()) first
;
4844 /* Do not mark the last element of the chained list because
4845 it is marked through the chain. */
4846 struct var_loc_node
* GTY ((skip ("%h"))) last
;
4848 /* DECL_UID of the variable decl. */
4849 unsigned int decl_id
;
4851 typedef struct var_loc_list_def var_loc_list
;
4854 /* Table of decl location linked lists. */
4855 static GTY ((param_is (var_loc_list
))) htab_t decl_loc_table
;
4857 /* A pointer to the base of a list of references to DIE's that
4858 are uniquely identified by their tag, presence/absence of
4859 children DIE's, and list of attribute/value pairs. */
4860 static GTY((length ("abbrev_die_table_allocated")))
4861 dw_die_ref
*abbrev_die_table
;
4863 /* Number of elements currently allocated for abbrev_die_table. */
4864 static GTY(()) unsigned abbrev_die_table_allocated
;
4866 /* Number of elements in type_die_table currently in use. */
4867 static GTY(()) unsigned abbrev_die_table_in_use
;
4869 /* Size (in elements) of increments by which we may expand the
4870 abbrev_die_table. */
4871 #define ABBREV_DIE_TABLE_INCREMENT 256
4873 /* A pointer to the base of a table that contains line information
4874 for each source code line in .text in the compilation unit. */
4875 static GTY((length ("line_info_table_allocated")))
4876 dw_line_info_ref line_info_table
;
4878 /* Number of elements currently allocated for line_info_table. */
4879 static GTY(()) unsigned line_info_table_allocated
;
4881 /* Number of elements in line_info_table currently in use. */
4882 static GTY(()) unsigned line_info_table_in_use
;
4884 /* A pointer to the base of a table that contains line information
4885 for each source code line outside of .text in the compilation unit. */
4886 static GTY ((length ("separate_line_info_table_allocated")))
4887 dw_separate_line_info_ref separate_line_info_table
;
4889 /* Number of elements currently allocated for separate_line_info_table. */
4890 static GTY(()) unsigned separate_line_info_table_allocated
;
4892 /* Number of elements in separate_line_info_table currently in use. */
4893 static GTY(()) unsigned separate_line_info_table_in_use
;
4895 /* Size (in elements) of increments by which we may expand the
4897 #define LINE_INFO_TABLE_INCREMENT 1024
4899 /* A pointer to the base of a table that contains a list of publicly
4900 accessible names. */
4901 static GTY (()) VEC (pubname_entry
, gc
) * pubname_table
;
4903 /* A pointer to the base of a table that contains a list of publicly
4904 accessible types. */
4905 static GTY (()) VEC (pubname_entry
, gc
) * pubtype_table
;
4907 /* Array of dies for which we should generate .debug_arange info. */
4908 static GTY((length ("arange_table_allocated"))) dw_die_ref
*arange_table
;
4910 /* Number of elements currently allocated for arange_table. */
4911 static GTY(()) unsigned arange_table_allocated
;
4913 /* Number of elements in arange_table currently in use. */
4914 static GTY(()) unsigned arange_table_in_use
;
4916 /* Size (in elements) of increments by which we may expand the
4918 #define ARANGE_TABLE_INCREMENT 64
4920 /* Array of dies for which we should generate .debug_ranges info. */
4921 static GTY ((length ("ranges_table_allocated"))) dw_ranges_ref ranges_table
;
4923 /* Number of elements currently allocated for ranges_table. */
4924 static GTY(()) unsigned ranges_table_allocated
;
4926 /* Number of elements in ranges_table currently in use. */
4927 static GTY(()) unsigned ranges_table_in_use
;
4929 /* Array of pairs of labels referenced in ranges_table. */
4930 static GTY ((length ("ranges_by_label_allocated")))
4931 dw_ranges_by_label_ref ranges_by_label
;
4933 /* Number of elements currently allocated for ranges_by_label. */
4934 static GTY(()) unsigned ranges_by_label_allocated
;
4936 /* Number of elements in ranges_by_label currently in use. */
4937 static GTY(()) unsigned ranges_by_label_in_use
;
4939 /* Size (in elements) of increments by which we may expand the
4941 #define RANGES_TABLE_INCREMENT 64
4943 /* Whether we have location lists that need outputting */
4944 static GTY(()) bool have_location_lists
;
4946 /* Unique label counter. */
4947 static GTY(()) unsigned int loclabel_num
;
4949 #ifdef DWARF2_DEBUGGING_INFO
4950 /* Record whether the function being analyzed contains inlined functions. */
4951 static int current_function_has_inlines
;
4953 #if 0 && defined (MIPS_DEBUGGING_INFO)
4954 static int comp_unit_has_inlines
;
4957 /* The last file entry emitted by maybe_emit_file(). */
4958 static GTY(()) struct dwarf_file_data
* last_emitted_file
;
4960 /* Number of internal labels generated by gen_internal_sym(). */
4961 static GTY(()) int label_num
;
4963 /* Cached result of previous call to lookup_filename. */
4964 static GTY(()) struct dwarf_file_data
* file_table_last_lookup
;
4966 #ifdef DWARF2_DEBUGGING_INFO
4968 /* Offset from the "steady-state frame pointer" to the frame base,
4969 within the current function. */
4970 static HOST_WIDE_INT frame_pointer_fb_offset
;
4972 /* Forward declarations for functions defined in this file. */
4974 static int is_pseudo_reg (const_rtx
);
4975 static tree
type_main_variant (tree
);
4976 static int is_tagged_type (const_tree
);
4977 static const char *dwarf_tag_name (unsigned);
4978 static const char *dwarf_attr_name (unsigned);
4979 static const char *dwarf_form_name (unsigned);
4980 static tree
decl_ultimate_origin (const_tree
);
4981 static tree
decl_class_context (tree
);
4982 static void add_dwarf_attr (dw_die_ref
, dw_attr_ref
);
4983 static inline enum dw_val_class
AT_class (dw_attr_ref
);
4984 static void add_AT_flag (dw_die_ref
, enum dwarf_attribute
, unsigned);
4985 static inline unsigned AT_flag (dw_attr_ref
);
4986 static void add_AT_int (dw_die_ref
, enum dwarf_attribute
, HOST_WIDE_INT
);
4987 static inline HOST_WIDE_INT
AT_int (dw_attr_ref
);
4988 static void add_AT_unsigned (dw_die_ref
, enum dwarf_attribute
, unsigned HOST_WIDE_INT
);
4989 static inline unsigned HOST_WIDE_INT
AT_unsigned (dw_attr_ref
);
4990 static void add_AT_long_long (dw_die_ref
, enum dwarf_attribute
, unsigned long,
4992 static inline void add_AT_vec (dw_die_ref
, enum dwarf_attribute
, unsigned int,
4993 unsigned int, unsigned char *);
4994 static hashval_t
debug_str_do_hash (const void *);
4995 static int debug_str_eq (const void *, const void *);
4996 static void add_AT_string (dw_die_ref
, enum dwarf_attribute
, const char *);
4997 static inline const char *AT_string (dw_attr_ref
);
4998 static int AT_string_form (dw_attr_ref
);
4999 static void add_AT_die_ref (dw_die_ref
, enum dwarf_attribute
, dw_die_ref
);
5000 static void add_AT_specification (dw_die_ref
, dw_die_ref
);
5001 static inline dw_die_ref
AT_ref (dw_attr_ref
);
5002 static inline int AT_ref_external (dw_attr_ref
);
5003 static inline void set_AT_ref_external (dw_attr_ref
, int);
5004 static void add_AT_fde_ref (dw_die_ref
, enum dwarf_attribute
, unsigned);
5005 static void add_AT_loc (dw_die_ref
, enum dwarf_attribute
, dw_loc_descr_ref
);
5006 static inline dw_loc_descr_ref
AT_loc (dw_attr_ref
);
5007 static void add_AT_loc_list (dw_die_ref
, enum dwarf_attribute
,
5009 static inline dw_loc_list_ref
AT_loc_list (dw_attr_ref
);
5010 static void add_AT_addr (dw_die_ref
, enum dwarf_attribute
, rtx
);
5011 static inline rtx
AT_addr (dw_attr_ref
);
5012 static void add_AT_lbl_id (dw_die_ref
, enum dwarf_attribute
, const char *);
5013 static void add_AT_lineptr (dw_die_ref
, enum dwarf_attribute
, const char *);
5014 static void add_AT_macptr (dw_die_ref
, enum dwarf_attribute
, const char *);
5015 static void add_AT_offset (dw_die_ref
, enum dwarf_attribute
,
5016 unsigned HOST_WIDE_INT
);
5017 static void add_AT_range_list (dw_die_ref
, enum dwarf_attribute
,
5019 static inline const char *AT_lbl (dw_attr_ref
);
5020 static dw_attr_ref
get_AT (dw_die_ref
, enum dwarf_attribute
);
5021 static const char *get_AT_low_pc (dw_die_ref
);
5022 static const char *get_AT_hi_pc (dw_die_ref
);
5023 static const char *get_AT_string (dw_die_ref
, enum dwarf_attribute
);
5024 static int get_AT_flag (dw_die_ref
, enum dwarf_attribute
);
5025 static unsigned get_AT_unsigned (dw_die_ref
, enum dwarf_attribute
);
5026 static inline dw_die_ref
get_AT_ref (dw_die_ref
, enum dwarf_attribute
);
5027 static bool is_c_family (void);
5028 static bool is_cxx (void);
5029 static bool is_java (void);
5030 static bool is_fortran (void);
5031 static bool is_ada (void);
5032 static void remove_AT (dw_die_ref
, enum dwarf_attribute
);
5033 static void remove_child_TAG (dw_die_ref
, enum dwarf_tag
);
5034 static void add_child_die (dw_die_ref
, dw_die_ref
);
5035 static dw_die_ref
new_die (enum dwarf_tag
, dw_die_ref
, tree
);
5036 static dw_die_ref
lookup_type_die (tree
);
5037 static void equate_type_number_to_die (tree
, dw_die_ref
);
5038 static hashval_t
decl_die_table_hash (const void *);
5039 static int decl_die_table_eq (const void *, const void *);
5040 static dw_die_ref
lookup_decl_die (tree
);
5041 static hashval_t
common_block_die_table_hash (const void *);
5042 static int common_block_die_table_eq (const void *, const void *);
5043 static hashval_t
decl_loc_table_hash (const void *);
5044 static int decl_loc_table_eq (const void *, const void *);
5045 static var_loc_list
*lookup_decl_loc (const_tree
);
5046 static void equate_decl_number_to_die (tree
, dw_die_ref
);
5047 static void add_var_loc_to_decl (tree
, struct var_loc_node
*);
5048 static void print_spaces (FILE *);
5049 static void print_die (dw_die_ref
, FILE *);
5050 static void print_dwarf_line_table (FILE *);
5051 static dw_die_ref
push_new_compile_unit (dw_die_ref
, dw_die_ref
);
5052 static dw_die_ref
pop_compile_unit (dw_die_ref
);
5053 static void loc_checksum (dw_loc_descr_ref
, struct md5_ctx
*);
5054 static void attr_checksum (dw_attr_ref
, struct md5_ctx
*, int *);
5055 static void die_checksum (dw_die_ref
, struct md5_ctx
*, int *);
5056 static int same_loc_p (dw_loc_descr_ref
, dw_loc_descr_ref
, int *);
5057 static int same_dw_val_p (const dw_val_node
*, const dw_val_node
*, int *);
5058 static int same_attr_p (dw_attr_ref
, dw_attr_ref
, int *);
5059 static int same_die_p (dw_die_ref
, dw_die_ref
, int *);
5060 static int same_die_p_wrap (dw_die_ref
, dw_die_ref
);
5061 static void compute_section_prefix (dw_die_ref
);
5062 static int is_type_die (dw_die_ref
);
5063 static int is_comdat_die (dw_die_ref
);
5064 static int is_symbol_die (dw_die_ref
);
5065 static void assign_symbol_names (dw_die_ref
);
5066 static void break_out_includes (dw_die_ref
);
5067 static hashval_t
htab_cu_hash (const void *);
5068 static int htab_cu_eq (const void *, const void *);
5069 static void htab_cu_del (void *);
5070 static int check_duplicate_cu (dw_die_ref
, htab_t
, unsigned *);
5071 static void record_comdat_symbol_number (dw_die_ref
, htab_t
, unsigned);
5072 static void add_sibling_attributes (dw_die_ref
);
5073 static void build_abbrev_table (dw_die_ref
);
5074 static void output_location_lists (dw_die_ref
);
5075 static int constant_size (unsigned HOST_WIDE_INT
);
5076 static unsigned long size_of_die (dw_die_ref
);
5077 static void calc_die_sizes (dw_die_ref
);
5078 static void mark_dies (dw_die_ref
);
5079 static void unmark_dies (dw_die_ref
);
5080 static void unmark_all_dies (dw_die_ref
);
5081 static unsigned long size_of_pubnames (VEC (pubname_entry
,gc
) *);
5082 static unsigned long size_of_aranges (void);
5083 static enum dwarf_form
value_format (dw_attr_ref
);
5084 static void output_value_format (dw_attr_ref
);
5085 static void output_abbrev_section (void);
5086 static void output_die_symbol (dw_die_ref
);
5087 static void output_die (dw_die_ref
);
5088 static void output_compilation_unit_header (void);
5089 static void output_comp_unit (dw_die_ref
, int);
5090 static const char *dwarf2_name (tree
, int);
5091 static void add_pubname (tree
, dw_die_ref
);
5092 static void add_pubname_string (const char *, dw_die_ref
);
5093 static void add_pubtype (tree
, dw_die_ref
);
5094 static void output_pubnames (VEC (pubname_entry
,gc
) *);
5095 static void add_arange (tree
, dw_die_ref
);
5096 static void output_aranges (void);
5097 static unsigned int add_ranges_num (int);
5098 static unsigned int add_ranges (const_tree
);
5099 static unsigned int add_ranges_by_labels (const char *, const char *);
5100 static void output_ranges (void);
5101 static void output_line_info (void);
5102 static void output_file_names (void);
5103 static dw_die_ref
base_type_die (tree
);
5104 static int is_base_type (tree
);
5105 static bool is_subrange_type (const_tree
);
5106 static dw_die_ref
subrange_type_die (tree
, dw_die_ref
);
5107 static dw_die_ref
modified_type_die (tree
, int, int, dw_die_ref
);
5108 static int type_is_enum (const_tree
);
5109 static unsigned int dbx_reg_number (const_rtx
);
5110 static void add_loc_descr_op_piece (dw_loc_descr_ref
*, int);
5111 static dw_loc_descr_ref
reg_loc_descriptor (rtx
, enum var_init_status
);
5112 static dw_loc_descr_ref
one_reg_loc_descriptor (unsigned int,
5113 enum var_init_status
);
5114 static dw_loc_descr_ref
multiple_reg_loc_descriptor (rtx
, rtx
,
5115 enum var_init_status
);
5116 static dw_loc_descr_ref
based_loc_descr (rtx
, HOST_WIDE_INT
,
5117 enum var_init_status
);
5118 static int is_based_loc (const_rtx
);
5119 static dw_loc_descr_ref
mem_loc_descriptor (rtx
, enum machine_mode mode
,
5120 enum var_init_status
);
5121 static dw_loc_descr_ref
concat_loc_descriptor (rtx
, rtx
,
5122 enum var_init_status
);
5123 static dw_loc_descr_ref
loc_descriptor (rtx
, enum var_init_status
);
5124 static dw_loc_descr_ref
loc_descriptor_from_tree_1 (tree
, int);
5125 static dw_loc_descr_ref
loc_descriptor_from_tree (tree
);
5126 static HOST_WIDE_INT
ceiling (HOST_WIDE_INT
, unsigned int);
5127 static tree
field_type (const_tree
);
5128 static unsigned int simple_type_align_in_bits (const_tree
);
5129 static unsigned int simple_decl_align_in_bits (const_tree
);
5130 static unsigned HOST_WIDE_INT
simple_type_size_in_bits (const_tree
);
5131 static HOST_WIDE_INT
field_byte_offset (const_tree
);
5132 static void add_AT_location_description (dw_die_ref
, enum dwarf_attribute
,
5134 static void add_data_member_location_attribute (dw_die_ref
, tree
);
5135 static void add_const_value_attribute (dw_die_ref
, rtx
);
5136 static void insert_int (HOST_WIDE_INT
, unsigned, unsigned char *);
5137 static HOST_WIDE_INT
extract_int (const unsigned char *, unsigned);
5138 static void insert_float (const_rtx
, unsigned char *);
5139 static rtx
rtl_for_decl_location (tree
);
5140 static void add_location_or_const_value_attribute (dw_die_ref
, tree
,
5141 enum dwarf_attribute
);
5142 static void tree_add_const_value_attribute (dw_die_ref
, tree
);
5143 static void add_name_attribute (dw_die_ref
, const char *);
5144 static void add_comp_dir_attribute (dw_die_ref
);
5145 static void add_bound_info (dw_die_ref
, enum dwarf_attribute
, tree
);
5146 static void add_subscript_info (dw_die_ref
, tree
, bool);
5147 static void add_byte_size_attribute (dw_die_ref
, tree
);
5148 static void add_bit_offset_attribute (dw_die_ref
, tree
);
5149 static void add_bit_size_attribute (dw_die_ref
, tree
);
5150 static void add_prototyped_attribute (dw_die_ref
, tree
);
5151 static dw_die_ref
add_abstract_origin_attribute (dw_die_ref
, tree
);
5152 static void add_pure_or_virtual_attribute (dw_die_ref
, tree
);
5153 static void add_src_coords_attributes (dw_die_ref
, tree
);
5154 static void add_name_and_src_coords_attributes (dw_die_ref
, tree
);
5155 static void push_decl_scope (tree
);
5156 static void pop_decl_scope (void);
5157 static dw_die_ref
scope_die_for (tree
, dw_die_ref
);
5158 static inline int local_scope_p (dw_die_ref
);
5159 static inline int class_scope_p (dw_die_ref
);
5160 static inline int class_or_namespace_scope_p (dw_die_ref
);
5161 static void add_type_attribute (dw_die_ref
, tree
, int, int, dw_die_ref
);
5162 static void add_calling_convention_attribute (dw_die_ref
, tree
);
5163 static const char *type_tag (const_tree
);
5164 static tree
member_declared_type (const_tree
);
5166 static const char *decl_start_label (tree
);
5168 static void gen_array_type_die (tree
, dw_die_ref
);
5169 static void gen_descr_array_type_die (tree
, struct array_descr_info
*, dw_die_ref
);
5171 static void gen_entry_point_die (tree
, dw_die_ref
);
5173 static dw_die_ref
gen_enumeration_type_die (tree
, dw_die_ref
);
5174 static dw_die_ref
gen_formal_parameter_die (tree
, tree
, dw_die_ref
);
5175 static void gen_unspecified_parameters_die (tree
, dw_die_ref
);
5176 static void gen_formal_types_die (tree
, dw_die_ref
);
5177 static void gen_subprogram_die (tree
, dw_die_ref
);
5178 static void gen_variable_die (tree
, tree
, dw_die_ref
);
5179 static void gen_const_die (tree
, dw_die_ref
);
5180 static void gen_label_die (tree
, dw_die_ref
);
5181 static void gen_lexical_block_die (tree
, dw_die_ref
, int);
5182 static void gen_inlined_subroutine_die (tree
, dw_die_ref
, int);
5183 static void gen_field_die (tree
, dw_die_ref
);
5184 static void gen_ptr_to_mbr_type_die (tree
, dw_die_ref
);
5185 static dw_die_ref
gen_compile_unit_die (const char *);
5186 static void gen_inheritance_die (tree
, tree
, dw_die_ref
);
5187 static void gen_member_die (tree
, dw_die_ref
);
5188 static void gen_struct_or_union_type_die (tree
, dw_die_ref
,
5189 enum debug_info_usage
);
5190 static void gen_subroutine_type_die (tree
, dw_die_ref
);
5191 static void gen_typedef_die (tree
, dw_die_ref
);
5192 static void gen_type_die (tree
, dw_die_ref
);
5193 static void gen_block_die (tree
, dw_die_ref
, int);
5194 static void decls_for_scope (tree
, dw_die_ref
, int);
5195 static int is_redundant_typedef (const_tree
);
5196 static void gen_namespace_die (tree
, dw_die_ref
);
5197 static void gen_decl_die (tree
, tree
, dw_die_ref
);
5198 static dw_die_ref
force_decl_die (tree
);
5199 static dw_die_ref
force_type_die (tree
);
5200 static dw_die_ref
setup_namespace_context (tree
, dw_die_ref
);
5201 static dw_die_ref
declare_in_namespace (tree
, dw_die_ref
);
5202 static struct dwarf_file_data
* lookup_filename (const char *);
5203 static void retry_incomplete_types (void);
5204 static void gen_type_die_for_member (tree
, tree
, dw_die_ref
);
5205 static void splice_child_die (dw_die_ref
, dw_die_ref
);
5206 static int file_info_cmp (const void *, const void *);
5207 static dw_loc_list_ref
new_loc_list (dw_loc_descr_ref
, const char *,
5208 const char *, const char *, unsigned);
5209 static void add_loc_descr_to_loc_list (dw_loc_list_ref
*, dw_loc_descr_ref
,
5210 const char *, const char *,
5212 static void output_loc_list (dw_loc_list_ref
);
5213 static char *gen_internal_sym (const char *);
5215 static void prune_unmark_dies (dw_die_ref
);
5216 static void prune_unused_types_mark (dw_die_ref
, int);
5217 static void prune_unused_types_walk (dw_die_ref
);
5218 static void prune_unused_types_walk_attribs (dw_die_ref
);
5219 static void prune_unused_types_prune (dw_die_ref
);
5220 static void prune_unused_types (void);
5221 static int maybe_emit_file (struct dwarf_file_data
*fd
);
5223 /* Section names used to hold DWARF debugging information. */
5224 #ifndef DEBUG_INFO_SECTION
5225 #define DEBUG_INFO_SECTION ".debug_info"
5227 #ifndef DEBUG_ABBREV_SECTION
5228 #define DEBUG_ABBREV_SECTION ".debug_abbrev"
5230 #ifndef DEBUG_ARANGES_SECTION
5231 #define DEBUG_ARANGES_SECTION ".debug_aranges"
5233 #ifndef DEBUG_MACINFO_SECTION
5234 #define DEBUG_MACINFO_SECTION ".debug_macinfo"
5236 #ifndef DEBUG_LINE_SECTION
5237 #define DEBUG_LINE_SECTION ".debug_line"
5239 #ifndef DEBUG_LOC_SECTION
5240 #define DEBUG_LOC_SECTION ".debug_loc"
5242 #ifndef DEBUG_PUBNAMES_SECTION
5243 #define DEBUG_PUBNAMES_SECTION ".debug_pubnames"
5245 #ifndef DEBUG_STR_SECTION
5246 #define DEBUG_STR_SECTION ".debug_str"
5248 #ifndef DEBUG_RANGES_SECTION
5249 #define DEBUG_RANGES_SECTION ".debug_ranges"
5252 /* Standard ELF section names for compiled code and data. */
5253 #ifndef TEXT_SECTION_NAME
5254 #define TEXT_SECTION_NAME ".text"
5257 /* Section flags for .debug_str section. */
5258 #define DEBUG_STR_SECTION_FLAGS \
5259 (HAVE_GAS_SHF_MERGE && flag_merge_debug_strings \
5260 ? SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1 \
5263 /* Labels we insert at beginning sections we can reference instead of
5264 the section names themselves. */
5266 #ifndef TEXT_SECTION_LABEL
5267 #define TEXT_SECTION_LABEL "Ltext"
5269 #ifndef COLD_TEXT_SECTION_LABEL
5270 #define COLD_TEXT_SECTION_LABEL "Ltext_cold"
5272 #ifndef DEBUG_LINE_SECTION_LABEL
5273 #define DEBUG_LINE_SECTION_LABEL "Ldebug_line"
5275 #ifndef DEBUG_INFO_SECTION_LABEL
5276 #define DEBUG_INFO_SECTION_LABEL "Ldebug_info"
5278 #ifndef DEBUG_ABBREV_SECTION_LABEL
5279 #define DEBUG_ABBREV_SECTION_LABEL "Ldebug_abbrev"
5281 #ifndef DEBUG_LOC_SECTION_LABEL
5282 #define DEBUG_LOC_SECTION_LABEL "Ldebug_loc"
5284 #ifndef DEBUG_RANGES_SECTION_LABEL
5285 #define DEBUG_RANGES_SECTION_LABEL "Ldebug_ranges"
5287 #ifndef DEBUG_MACINFO_SECTION_LABEL
5288 #define DEBUG_MACINFO_SECTION_LABEL "Ldebug_macinfo"
5291 /* Definitions of defaults for formats and names of various special
5292 (artificial) labels which may be generated within this file (when the -g
5293 options is used and DWARF2_DEBUGGING_INFO is in effect.
5294 If necessary, these may be overridden from within the tm.h file, but
5295 typically, overriding these defaults is unnecessary. */
5297 static char text_end_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
5298 static char text_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
5299 static char cold_text_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
5300 static char cold_end_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
5301 static char abbrev_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
5302 static char debug_info_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
5303 static char debug_line_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
5304 static char macinfo_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
5305 static char loc_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
5306 static char ranges_section_label
[2 * MAX_ARTIFICIAL_LABEL_BYTES
];
5308 #ifndef TEXT_END_LABEL
5309 #define TEXT_END_LABEL "Letext"
5311 #ifndef COLD_END_LABEL
5312 #define COLD_END_LABEL "Letext_cold"
5314 #ifndef BLOCK_BEGIN_LABEL
5315 #define BLOCK_BEGIN_LABEL "LBB"
5317 #ifndef BLOCK_END_LABEL
5318 #define BLOCK_END_LABEL "LBE"
5320 #ifndef LINE_CODE_LABEL
5321 #define LINE_CODE_LABEL "LM"
5323 #ifndef SEPARATE_LINE_CODE_LABEL
5324 #define SEPARATE_LINE_CODE_LABEL "LSM"
5328 /* We allow a language front-end to designate a function that is to be
5329 called to "demangle" any name before it is put into a DIE. */
5331 static const char *(*demangle_name_func
) (const char *);
5334 dwarf2out_set_demangle_name_func (const char *(*func
) (const char *))
5336 demangle_name_func
= func
;
5339 /* Test if rtl node points to a pseudo register. */
5342 is_pseudo_reg (const_rtx rtl
)
5344 return ((REG_P (rtl
) && REGNO (rtl
) >= FIRST_PSEUDO_REGISTER
)
5345 || (GET_CODE (rtl
) == SUBREG
5346 && REGNO (SUBREG_REG (rtl
)) >= FIRST_PSEUDO_REGISTER
));
5349 /* Return a reference to a type, with its const and volatile qualifiers
5353 type_main_variant (tree type
)
5355 type
= TYPE_MAIN_VARIANT (type
);
5357 /* ??? There really should be only one main variant among any group of
5358 variants of a given type (and all of the MAIN_VARIANT values for all
5359 members of the group should point to that one type) but sometimes the C
5360 front-end messes this up for array types, so we work around that bug
5362 if (TREE_CODE (type
) == ARRAY_TYPE
)
5363 while (type
!= TYPE_MAIN_VARIANT (type
))
5364 type
= TYPE_MAIN_VARIANT (type
);
5369 /* Return nonzero if the given type node represents a tagged type. */
5372 is_tagged_type (const_tree type
)
5374 enum tree_code code
= TREE_CODE (type
);
5376 return (code
== RECORD_TYPE
|| code
== UNION_TYPE
5377 || code
== QUAL_UNION_TYPE
|| code
== ENUMERAL_TYPE
);
5380 /* Convert a DIE tag into its string name. */
5383 dwarf_tag_name (unsigned int tag
)
5387 case DW_TAG_padding
:
5388 return "DW_TAG_padding";
5389 case DW_TAG_array_type
:
5390 return "DW_TAG_array_type";
5391 case DW_TAG_class_type
:
5392 return "DW_TAG_class_type";
5393 case DW_TAG_entry_point
:
5394 return "DW_TAG_entry_point";
5395 case DW_TAG_enumeration_type
:
5396 return "DW_TAG_enumeration_type";
5397 case DW_TAG_formal_parameter
:
5398 return "DW_TAG_formal_parameter";
5399 case DW_TAG_imported_declaration
:
5400 return "DW_TAG_imported_declaration";
5402 return "DW_TAG_label";
5403 case DW_TAG_lexical_block
:
5404 return "DW_TAG_lexical_block";
5406 return "DW_TAG_member";
5407 case DW_TAG_pointer_type
:
5408 return "DW_TAG_pointer_type";
5409 case DW_TAG_reference_type
:
5410 return "DW_TAG_reference_type";
5411 case DW_TAG_compile_unit
:
5412 return "DW_TAG_compile_unit";
5413 case DW_TAG_string_type
:
5414 return "DW_TAG_string_type";
5415 case DW_TAG_structure_type
:
5416 return "DW_TAG_structure_type";
5417 case DW_TAG_subroutine_type
:
5418 return "DW_TAG_subroutine_type";
5419 case DW_TAG_typedef
:
5420 return "DW_TAG_typedef";
5421 case DW_TAG_union_type
:
5422 return "DW_TAG_union_type";
5423 case DW_TAG_unspecified_parameters
:
5424 return "DW_TAG_unspecified_parameters";
5425 case DW_TAG_variant
:
5426 return "DW_TAG_variant";
5427 case DW_TAG_common_block
:
5428 return "DW_TAG_common_block";
5429 case DW_TAG_common_inclusion
:
5430 return "DW_TAG_common_inclusion";
5431 case DW_TAG_inheritance
:
5432 return "DW_TAG_inheritance";
5433 case DW_TAG_inlined_subroutine
:
5434 return "DW_TAG_inlined_subroutine";
5436 return "DW_TAG_module";
5437 case DW_TAG_ptr_to_member_type
:
5438 return "DW_TAG_ptr_to_member_type";
5439 case DW_TAG_set_type
:
5440 return "DW_TAG_set_type";
5441 case DW_TAG_subrange_type
:
5442 return "DW_TAG_subrange_type";
5443 case DW_TAG_with_stmt
:
5444 return "DW_TAG_with_stmt";
5445 case DW_TAG_access_declaration
:
5446 return "DW_TAG_access_declaration";
5447 case DW_TAG_base_type
:
5448 return "DW_TAG_base_type";
5449 case DW_TAG_catch_block
:
5450 return "DW_TAG_catch_block";
5451 case DW_TAG_const_type
:
5452 return "DW_TAG_const_type";
5453 case DW_TAG_constant
:
5454 return "DW_TAG_constant";
5455 case DW_TAG_enumerator
:
5456 return "DW_TAG_enumerator";
5457 case DW_TAG_file_type
:
5458 return "DW_TAG_file_type";
5460 return "DW_TAG_friend";
5461 case DW_TAG_namelist
:
5462 return "DW_TAG_namelist";
5463 case DW_TAG_namelist_item
:
5464 return "DW_TAG_namelist_item";
5465 case DW_TAG_packed_type
:
5466 return "DW_TAG_packed_type";
5467 case DW_TAG_subprogram
:
5468 return "DW_TAG_subprogram";
5469 case DW_TAG_template_type_param
:
5470 return "DW_TAG_template_type_param";
5471 case DW_TAG_template_value_param
:
5472 return "DW_TAG_template_value_param";
5473 case DW_TAG_thrown_type
:
5474 return "DW_TAG_thrown_type";
5475 case DW_TAG_try_block
:
5476 return "DW_TAG_try_block";
5477 case DW_TAG_variant_part
:
5478 return "DW_TAG_variant_part";
5479 case DW_TAG_variable
:
5480 return "DW_TAG_variable";
5481 case DW_TAG_volatile_type
:
5482 return "DW_TAG_volatile_type";
5483 case DW_TAG_dwarf_procedure
:
5484 return "DW_TAG_dwarf_procedure";
5485 case DW_TAG_restrict_type
:
5486 return "DW_TAG_restrict_type";
5487 case DW_TAG_interface_type
:
5488 return "DW_TAG_interface_type";
5489 case DW_TAG_namespace
:
5490 return "DW_TAG_namespace";
5491 case DW_TAG_imported_module
:
5492 return "DW_TAG_imported_module";
5493 case DW_TAG_unspecified_type
:
5494 return "DW_TAG_unspecified_type";
5495 case DW_TAG_partial_unit
:
5496 return "DW_TAG_partial_unit";
5497 case DW_TAG_imported_unit
:
5498 return "DW_TAG_imported_unit";
5499 case DW_TAG_condition
:
5500 return "DW_TAG_condition";
5501 case DW_TAG_shared_type
:
5502 return "DW_TAG_shared_type";
5503 case DW_TAG_MIPS_loop
:
5504 return "DW_TAG_MIPS_loop";
5505 case DW_TAG_format_label
:
5506 return "DW_TAG_format_label";
5507 case DW_TAG_function_template
:
5508 return "DW_TAG_function_template";
5509 case DW_TAG_class_template
:
5510 return "DW_TAG_class_template";
5511 case DW_TAG_GNU_BINCL
:
5512 return "DW_TAG_GNU_BINCL";
5513 case DW_TAG_GNU_EINCL
:
5514 return "DW_TAG_GNU_EINCL";
5516 return "DW_TAG_<unknown>";
5520 /* Convert a DWARF attribute code into its string name. */
5523 dwarf_attr_name (unsigned int attr
)
5528 return "DW_AT_sibling";
5529 case DW_AT_location
:
5530 return "DW_AT_location";
5532 return "DW_AT_name";
5533 case DW_AT_ordering
:
5534 return "DW_AT_ordering";
5535 case DW_AT_subscr_data
:
5536 return "DW_AT_subscr_data";
5537 case DW_AT_byte_size
:
5538 return "DW_AT_byte_size";
5539 case DW_AT_bit_offset
:
5540 return "DW_AT_bit_offset";
5541 case DW_AT_bit_size
:
5542 return "DW_AT_bit_size";
5543 case DW_AT_element_list
:
5544 return "DW_AT_element_list";
5545 case DW_AT_stmt_list
:
5546 return "DW_AT_stmt_list";
5548 return "DW_AT_low_pc";
5550 return "DW_AT_high_pc";
5551 case DW_AT_language
:
5552 return "DW_AT_language";
5554 return "DW_AT_member";
5556 return "DW_AT_discr";
5557 case DW_AT_discr_value
:
5558 return "DW_AT_discr_value";
5559 case DW_AT_visibility
:
5560 return "DW_AT_visibility";
5562 return "DW_AT_import";
5563 case DW_AT_string_length
:
5564 return "DW_AT_string_length";
5565 case DW_AT_common_reference
:
5566 return "DW_AT_common_reference";
5567 case DW_AT_comp_dir
:
5568 return "DW_AT_comp_dir";
5569 case DW_AT_const_value
:
5570 return "DW_AT_const_value";
5571 case DW_AT_containing_type
:
5572 return "DW_AT_containing_type";
5573 case DW_AT_default_value
:
5574 return "DW_AT_default_value";
5576 return "DW_AT_inline";
5577 case DW_AT_is_optional
:
5578 return "DW_AT_is_optional";
5579 case DW_AT_lower_bound
:
5580 return "DW_AT_lower_bound";
5581 case DW_AT_producer
:
5582 return "DW_AT_producer";
5583 case DW_AT_prototyped
:
5584 return "DW_AT_prototyped";
5585 case DW_AT_return_addr
:
5586 return "DW_AT_return_addr";
5587 case DW_AT_start_scope
:
5588 return "DW_AT_start_scope";
5589 case DW_AT_bit_stride
:
5590 return "DW_AT_bit_stride";
5591 case DW_AT_upper_bound
:
5592 return "DW_AT_upper_bound";
5593 case DW_AT_abstract_origin
:
5594 return "DW_AT_abstract_origin";
5595 case DW_AT_accessibility
:
5596 return "DW_AT_accessibility";
5597 case DW_AT_address_class
:
5598 return "DW_AT_address_class";
5599 case DW_AT_artificial
:
5600 return "DW_AT_artificial";
5601 case DW_AT_base_types
:
5602 return "DW_AT_base_types";
5603 case DW_AT_calling_convention
:
5604 return "DW_AT_calling_convention";
5606 return "DW_AT_count";
5607 case DW_AT_data_member_location
:
5608 return "DW_AT_data_member_location";
5609 case DW_AT_decl_column
:
5610 return "DW_AT_decl_column";
5611 case DW_AT_decl_file
:
5612 return "DW_AT_decl_file";
5613 case DW_AT_decl_line
:
5614 return "DW_AT_decl_line";
5615 case DW_AT_declaration
:
5616 return "DW_AT_declaration";
5617 case DW_AT_discr_list
:
5618 return "DW_AT_discr_list";
5619 case DW_AT_encoding
:
5620 return "DW_AT_encoding";
5621 case DW_AT_external
:
5622 return "DW_AT_external";
5623 case DW_AT_explicit
:
5624 return "DW_AT_explicit";
5625 case DW_AT_frame_base
:
5626 return "DW_AT_frame_base";
5628 return "DW_AT_friend";
5629 case DW_AT_identifier_case
:
5630 return "DW_AT_identifier_case";
5631 case DW_AT_macro_info
:
5632 return "DW_AT_macro_info";
5633 case DW_AT_namelist_items
:
5634 return "DW_AT_namelist_items";
5635 case DW_AT_priority
:
5636 return "DW_AT_priority";
5638 return "DW_AT_segment";
5639 case DW_AT_specification
:
5640 return "DW_AT_specification";
5641 case DW_AT_static_link
:
5642 return "DW_AT_static_link";
5644 return "DW_AT_type";
5645 case DW_AT_use_location
:
5646 return "DW_AT_use_location";
5647 case DW_AT_variable_parameter
:
5648 return "DW_AT_variable_parameter";
5649 case DW_AT_virtuality
:
5650 return "DW_AT_virtuality";
5651 case DW_AT_vtable_elem_location
:
5652 return "DW_AT_vtable_elem_location";
5654 case DW_AT_allocated
:
5655 return "DW_AT_allocated";
5656 case DW_AT_associated
:
5657 return "DW_AT_associated";
5658 case DW_AT_data_location
:
5659 return "DW_AT_data_location";
5660 case DW_AT_byte_stride
:
5661 return "DW_AT_byte_stride";
5662 case DW_AT_entry_pc
:
5663 return "DW_AT_entry_pc";
5664 case DW_AT_use_UTF8
:
5665 return "DW_AT_use_UTF8";
5666 case DW_AT_extension
:
5667 return "DW_AT_extension";
5669 return "DW_AT_ranges";
5670 case DW_AT_trampoline
:
5671 return "DW_AT_trampoline";
5672 case DW_AT_call_column
:
5673 return "DW_AT_call_column";
5674 case DW_AT_call_file
:
5675 return "DW_AT_call_file";
5676 case DW_AT_call_line
:
5677 return "DW_AT_call_line";
5679 case DW_AT_MIPS_fde
:
5680 return "DW_AT_MIPS_fde";
5681 case DW_AT_MIPS_loop_begin
:
5682 return "DW_AT_MIPS_loop_begin";
5683 case DW_AT_MIPS_tail_loop_begin
:
5684 return "DW_AT_MIPS_tail_loop_begin";
5685 case DW_AT_MIPS_epilog_begin
:
5686 return "DW_AT_MIPS_epilog_begin";
5687 case DW_AT_MIPS_loop_unroll_factor
:
5688 return "DW_AT_MIPS_loop_unroll_factor";
5689 case DW_AT_MIPS_software_pipeline_depth
:
5690 return "DW_AT_MIPS_software_pipeline_depth";
5691 case DW_AT_MIPS_linkage_name
:
5692 return "DW_AT_MIPS_linkage_name";
5693 case DW_AT_MIPS_stride
:
5694 return "DW_AT_MIPS_stride";
5695 case DW_AT_MIPS_abstract_name
:
5696 return "DW_AT_MIPS_abstract_name";
5697 case DW_AT_MIPS_clone_origin
:
5698 return "DW_AT_MIPS_clone_origin";
5699 case DW_AT_MIPS_has_inlines
:
5700 return "DW_AT_MIPS_has_inlines";
5702 case DW_AT_sf_names
:
5703 return "DW_AT_sf_names";
5704 case DW_AT_src_info
:
5705 return "DW_AT_src_info";
5706 case DW_AT_mac_info
:
5707 return "DW_AT_mac_info";
5708 case DW_AT_src_coords
:
5709 return "DW_AT_src_coords";
5710 case DW_AT_body_begin
:
5711 return "DW_AT_body_begin";
5712 case DW_AT_body_end
:
5713 return "DW_AT_body_end";
5714 case DW_AT_GNU_vector
:
5715 return "DW_AT_GNU_vector";
5717 case DW_AT_VMS_rtnbeg_pd_address
:
5718 return "DW_AT_VMS_rtnbeg_pd_address";
5721 return "DW_AT_<unknown>";
5725 /* Convert a DWARF value form code into its string name. */
5728 dwarf_form_name (unsigned int form
)
5733 return "DW_FORM_addr";
5734 case DW_FORM_block2
:
5735 return "DW_FORM_block2";
5736 case DW_FORM_block4
:
5737 return "DW_FORM_block4";
5739 return "DW_FORM_data2";
5741 return "DW_FORM_data4";
5743 return "DW_FORM_data8";
5744 case DW_FORM_string
:
5745 return "DW_FORM_string";
5747 return "DW_FORM_block";
5748 case DW_FORM_block1
:
5749 return "DW_FORM_block1";
5751 return "DW_FORM_data1";
5753 return "DW_FORM_flag";
5755 return "DW_FORM_sdata";
5757 return "DW_FORM_strp";
5759 return "DW_FORM_udata";
5760 case DW_FORM_ref_addr
:
5761 return "DW_FORM_ref_addr";
5763 return "DW_FORM_ref1";
5765 return "DW_FORM_ref2";
5767 return "DW_FORM_ref4";
5769 return "DW_FORM_ref8";
5770 case DW_FORM_ref_udata
:
5771 return "DW_FORM_ref_udata";
5772 case DW_FORM_indirect
:
5773 return "DW_FORM_indirect";
5775 return "DW_FORM_<unknown>";
5779 /* Determine the "ultimate origin" of a decl. The decl may be an inlined
5780 instance of an inlined instance of a decl which is local to an inline
5781 function, so we have to trace all of the way back through the origin chain
5782 to find out what sort of node actually served as the original seed for the
5786 decl_ultimate_origin (const_tree decl
)
5788 if (!CODE_CONTAINS_STRUCT (TREE_CODE (decl
), TS_DECL_COMMON
))
5791 /* output_inline_function sets DECL_ABSTRACT_ORIGIN for all the
5792 nodes in the function to point to themselves; ignore that if
5793 we're trying to output the abstract instance of this function. */
5794 if (DECL_ABSTRACT (decl
) && DECL_ABSTRACT_ORIGIN (decl
) == decl
)
5797 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
5798 most distant ancestor, this should never happen. */
5799 gcc_assert (!DECL_FROM_INLINE (DECL_ORIGIN (decl
)));
5801 return DECL_ABSTRACT_ORIGIN (decl
);
5804 /* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT
5805 of a virtual function may refer to a base class, so we check the 'this'
5809 decl_class_context (tree decl
)
5811 tree context
= NULL_TREE
;
5813 if (TREE_CODE (decl
) != FUNCTION_DECL
|| ! DECL_VINDEX (decl
))
5814 context
= DECL_CONTEXT (decl
);
5816 context
= TYPE_MAIN_VARIANT
5817 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)))));
5819 if (context
&& !TYPE_P (context
))
5820 context
= NULL_TREE
;
5825 /* Add an attribute/value pair to a DIE. */
5828 add_dwarf_attr (dw_die_ref die
, dw_attr_ref attr
)
5830 /* Maybe this should be an assert? */
5834 if (die
->die_attr
== NULL
)
5835 die
->die_attr
= VEC_alloc (dw_attr_node
, gc
, 1);
5836 VEC_safe_push (dw_attr_node
, gc
, die
->die_attr
, attr
);
5839 static inline enum dw_val_class
5840 AT_class (dw_attr_ref a
)
5842 return a
->dw_attr_val
.val_class
;
5845 /* Add a flag value attribute to a DIE. */
5848 add_AT_flag (dw_die_ref die
, enum dwarf_attribute attr_kind
, unsigned int flag
)
5852 attr
.dw_attr
= attr_kind
;
5853 attr
.dw_attr_val
.val_class
= dw_val_class_flag
;
5854 attr
.dw_attr_val
.v
.val_flag
= flag
;
5855 add_dwarf_attr (die
, &attr
);
5858 static inline unsigned
5859 AT_flag (dw_attr_ref a
)
5861 gcc_assert (a
&& AT_class (a
) == dw_val_class_flag
);
5862 return a
->dw_attr_val
.v
.val_flag
;
5865 /* Add a signed integer attribute value to a DIE. */
5868 add_AT_int (dw_die_ref die
, enum dwarf_attribute attr_kind
, HOST_WIDE_INT int_val
)
5872 attr
.dw_attr
= attr_kind
;
5873 attr
.dw_attr_val
.val_class
= dw_val_class_const
;
5874 attr
.dw_attr_val
.v
.val_int
= int_val
;
5875 add_dwarf_attr (die
, &attr
);
5878 static inline HOST_WIDE_INT
5879 AT_int (dw_attr_ref a
)
5881 gcc_assert (a
&& AT_class (a
) == dw_val_class_const
);
5882 return a
->dw_attr_val
.v
.val_int
;
5885 /* Add an unsigned integer attribute value to a DIE. */
5888 add_AT_unsigned (dw_die_ref die
, enum dwarf_attribute attr_kind
,
5889 unsigned HOST_WIDE_INT unsigned_val
)
5893 attr
.dw_attr
= attr_kind
;
5894 attr
.dw_attr_val
.val_class
= dw_val_class_unsigned_const
;
5895 attr
.dw_attr_val
.v
.val_unsigned
= unsigned_val
;
5896 add_dwarf_attr (die
, &attr
);
5899 static inline unsigned HOST_WIDE_INT
5900 AT_unsigned (dw_attr_ref a
)
5902 gcc_assert (a
&& AT_class (a
) == dw_val_class_unsigned_const
);
5903 return a
->dw_attr_val
.v
.val_unsigned
;
5906 /* Add an unsigned double integer attribute value to a DIE. */
5909 add_AT_long_long (dw_die_ref die
, enum dwarf_attribute attr_kind
,
5910 long unsigned int val_hi
, long unsigned int val_low
)
5914 attr
.dw_attr
= attr_kind
;
5915 attr
.dw_attr_val
.val_class
= dw_val_class_long_long
;
5916 attr
.dw_attr_val
.v
.val_long_long
.hi
= val_hi
;
5917 attr
.dw_attr_val
.v
.val_long_long
.low
= val_low
;
5918 add_dwarf_attr (die
, &attr
);
5921 /* Add a floating point attribute value to a DIE and return it. */
5924 add_AT_vec (dw_die_ref die
, enum dwarf_attribute attr_kind
,
5925 unsigned int length
, unsigned int elt_size
, unsigned char *array
)
5929 attr
.dw_attr
= attr_kind
;
5930 attr
.dw_attr_val
.val_class
= dw_val_class_vec
;
5931 attr
.dw_attr_val
.v
.val_vec
.length
= length
;
5932 attr
.dw_attr_val
.v
.val_vec
.elt_size
= elt_size
;
5933 attr
.dw_attr_val
.v
.val_vec
.array
= array
;
5934 add_dwarf_attr (die
, &attr
);
5937 /* Hash and equality functions for debug_str_hash. */
5940 debug_str_do_hash (const void *x
)
5942 return htab_hash_string (((const struct indirect_string_node
*)x
)->str
);
5946 debug_str_eq (const void *x1
, const void *x2
)
5948 return strcmp ((((const struct indirect_string_node
*)x1
)->str
),
5949 (const char *)x2
) == 0;
5952 static struct indirect_string_node
*
5953 find_AT_string (const char *str
)
5955 struct indirect_string_node
*node
;
5958 if (! debug_str_hash
)
5959 debug_str_hash
= htab_create_ggc (10, debug_str_do_hash
,
5960 debug_str_eq
, NULL
);
5962 slot
= htab_find_slot_with_hash (debug_str_hash
, str
,
5963 htab_hash_string (str
), INSERT
);
5966 node
= (struct indirect_string_node
*)
5967 ggc_alloc_cleared (sizeof (struct indirect_string_node
));
5968 node
->str
= ggc_strdup (str
);
5972 node
= (struct indirect_string_node
*) *slot
;
5978 /* Add a string attribute value to a DIE. */
5981 add_AT_string (dw_die_ref die
, enum dwarf_attribute attr_kind
, const char *str
)
5984 struct indirect_string_node
*node
;
5986 node
= find_AT_string (str
);
5988 attr
.dw_attr
= attr_kind
;
5989 attr
.dw_attr_val
.val_class
= dw_val_class_str
;
5990 attr
.dw_attr_val
.v
.val_str
= node
;
5991 add_dwarf_attr (die
, &attr
);
5994 static inline const char *
5995 AT_string (dw_attr_ref a
)
5997 gcc_assert (a
&& AT_class (a
) == dw_val_class_str
);
5998 return a
->dw_attr_val
.v
.val_str
->str
;
6001 /* Find out whether a string should be output inline in DIE
6002 or out-of-line in .debug_str section. */
6005 AT_string_form (dw_attr_ref a
)
6007 struct indirect_string_node
*node
;
6011 gcc_assert (a
&& AT_class (a
) == dw_val_class_str
);
6013 node
= a
->dw_attr_val
.v
.val_str
;
6017 len
= strlen (node
->str
) + 1;
6019 /* If the string is shorter or equal to the size of the reference, it is
6020 always better to put it inline. */
6021 if (len
<= DWARF_OFFSET_SIZE
|| node
->refcount
== 0)
6022 return node
->form
= DW_FORM_string
;
6024 /* If we cannot expect the linker to merge strings in .debug_str
6025 section, only put it into .debug_str if it is worth even in this
6027 if ((debug_str_section
->common
.flags
& SECTION_MERGE
) == 0
6028 && (len
- DWARF_OFFSET_SIZE
) * node
->refcount
<= len
)
6029 return node
->form
= DW_FORM_string
;
6031 ASM_GENERATE_INTERNAL_LABEL (label
, "LASF", dw2_string_counter
);
6032 ++dw2_string_counter
;
6033 node
->label
= xstrdup (label
);
6035 return node
->form
= DW_FORM_strp
;
6038 /* Add a DIE reference attribute value to a DIE. */
6041 add_AT_die_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
, dw_die_ref targ_die
)
6045 attr
.dw_attr
= attr_kind
;
6046 attr
.dw_attr_val
.val_class
= dw_val_class_die_ref
;
6047 attr
.dw_attr_val
.v
.val_die_ref
.die
= targ_die
;
6048 attr
.dw_attr_val
.v
.val_die_ref
.external
= 0;
6049 add_dwarf_attr (die
, &attr
);
6052 /* Add an AT_specification attribute to a DIE, and also make the back
6053 pointer from the specification to the definition. */
6056 add_AT_specification (dw_die_ref die
, dw_die_ref targ_die
)
6058 add_AT_die_ref (die
, DW_AT_specification
, targ_die
);
6059 gcc_assert (!targ_die
->die_definition
);
6060 targ_die
->die_definition
= die
;
6063 static inline dw_die_ref
6064 AT_ref (dw_attr_ref a
)
6066 gcc_assert (a
&& AT_class (a
) == dw_val_class_die_ref
);
6067 return a
->dw_attr_val
.v
.val_die_ref
.die
;
6071 AT_ref_external (dw_attr_ref a
)
6073 if (a
&& AT_class (a
) == dw_val_class_die_ref
)
6074 return a
->dw_attr_val
.v
.val_die_ref
.external
;
6080 set_AT_ref_external (dw_attr_ref a
, int i
)
6082 gcc_assert (a
&& AT_class (a
) == dw_val_class_die_ref
);
6083 a
->dw_attr_val
.v
.val_die_ref
.external
= i
;
6086 /* Add an FDE reference attribute value to a DIE. */
6089 add_AT_fde_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
, unsigned int targ_fde
)
6093 attr
.dw_attr
= attr_kind
;
6094 attr
.dw_attr_val
.val_class
= dw_val_class_fde_ref
;
6095 attr
.dw_attr_val
.v
.val_fde_index
= targ_fde
;
6096 add_dwarf_attr (die
, &attr
);
6099 /* Add a location description attribute value to a DIE. */
6102 add_AT_loc (dw_die_ref die
, enum dwarf_attribute attr_kind
, dw_loc_descr_ref loc
)
6106 attr
.dw_attr
= attr_kind
;
6107 attr
.dw_attr_val
.val_class
= dw_val_class_loc
;
6108 attr
.dw_attr_val
.v
.val_loc
= loc
;
6109 add_dwarf_attr (die
, &attr
);
6112 static inline dw_loc_descr_ref
6113 AT_loc (dw_attr_ref a
)
6115 gcc_assert (a
&& AT_class (a
) == dw_val_class_loc
);
6116 return a
->dw_attr_val
.v
.val_loc
;
6120 add_AT_loc_list (dw_die_ref die
, enum dwarf_attribute attr_kind
, dw_loc_list_ref loc_list
)
6124 attr
.dw_attr
= attr_kind
;
6125 attr
.dw_attr_val
.val_class
= dw_val_class_loc_list
;
6126 attr
.dw_attr_val
.v
.val_loc_list
= loc_list
;
6127 add_dwarf_attr (die
, &attr
);
6128 have_location_lists
= true;
6131 static inline dw_loc_list_ref
6132 AT_loc_list (dw_attr_ref a
)
6134 gcc_assert (a
&& AT_class (a
) == dw_val_class_loc_list
);
6135 return a
->dw_attr_val
.v
.val_loc_list
;
6138 /* Add an address constant attribute value to a DIE. */
6141 add_AT_addr (dw_die_ref die
, enum dwarf_attribute attr_kind
, rtx addr
)
6145 attr
.dw_attr
= attr_kind
;
6146 attr
.dw_attr_val
.val_class
= dw_val_class_addr
;
6147 attr
.dw_attr_val
.v
.val_addr
= addr
;
6148 add_dwarf_attr (die
, &attr
);
6151 /* Get the RTX from to an address DIE attribute. */
6154 AT_addr (dw_attr_ref a
)
6156 gcc_assert (a
&& AT_class (a
) == dw_val_class_addr
);
6157 return a
->dw_attr_val
.v
.val_addr
;
6160 /* Add a file attribute value to a DIE. */
6163 add_AT_file (dw_die_ref die
, enum dwarf_attribute attr_kind
,
6164 struct dwarf_file_data
*fd
)
6168 attr
.dw_attr
= attr_kind
;
6169 attr
.dw_attr_val
.val_class
= dw_val_class_file
;
6170 attr
.dw_attr_val
.v
.val_file
= fd
;
6171 add_dwarf_attr (die
, &attr
);
6174 /* Get the dwarf_file_data from a file DIE attribute. */
6176 static inline struct dwarf_file_data
*
6177 AT_file (dw_attr_ref a
)
6179 gcc_assert (a
&& AT_class (a
) == dw_val_class_file
);
6180 return a
->dw_attr_val
.v
.val_file
;
6183 /* Add a label identifier attribute value to a DIE. */
6186 add_AT_lbl_id (dw_die_ref die
, enum dwarf_attribute attr_kind
, const char *lbl_id
)
6190 attr
.dw_attr
= attr_kind
;
6191 attr
.dw_attr_val
.val_class
= dw_val_class_lbl_id
;
6192 attr
.dw_attr_val
.v
.val_lbl_id
= xstrdup (lbl_id
);
6193 add_dwarf_attr (die
, &attr
);
6196 /* Add a section offset attribute value to a DIE, an offset into the
6197 debug_line section. */
6200 add_AT_lineptr (dw_die_ref die
, enum dwarf_attribute attr_kind
,
6205 attr
.dw_attr
= attr_kind
;
6206 attr
.dw_attr_val
.val_class
= dw_val_class_lineptr
;
6207 attr
.dw_attr_val
.v
.val_lbl_id
= xstrdup (label
);
6208 add_dwarf_attr (die
, &attr
);
6211 /* Add a section offset attribute value to a DIE, an offset into the
6212 debug_macinfo section. */
6215 add_AT_macptr (dw_die_ref die
, enum dwarf_attribute attr_kind
,
6220 attr
.dw_attr
= attr_kind
;
6221 attr
.dw_attr_val
.val_class
= dw_val_class_macptr
;
6222 attr
.dw_attr_val
.v
.val_lbl_id
= xstrdup (label
);
6223 add_dwarf_attr (die
, &attr
);
6226 /* Add an offset attribute value to a DIE. */
6229 add_AT_offset (dw_die_ref die
, enum dwarf_attribute attr_kind
,
6230 unsigned HOST_WIDE_INT offset
)
6234 attr
.dw_attr
= attr_kind
;
6235 attr
.dw_attr_val
.val_class
= dw_val_class_offset
;
6236 attr
.dw_attr_val
.v
.val_offset
= offset
;
6237 add_dwarf_attr (die
, &attr
);
6240 /* Add an range_list attribute value to a DIE. */
6243 add_AT_range_list (dw_die_ref die
, enum dwarf_attribute attr_kind
,
6244 long unsigned int offset
)
6248 attr
.dw_attr
= attr_kind
;
6249 attr
.dw_attr_val
.val_class
= dw_val_class_range_list
;
6250 attr
.dw_attr_val
.v
.val_offset
= offset
;
6251 add_dwarf_attr (die
, &attr
);
6254 static inline const char *
6255 AT_lbl (dw_attr_ref a
)
6257 gcc_assert (a
&& (AT_class (a
) == dw_val_class_lbl_id
6258 || AT_class (a
) == dw_val_class_lineptr
6259 || AT_class (a
) == dw_val_class_macptr
));
6260 return a
->dw_attr_val
.v
.val_lbl_id
;
6263 /* Get the attribute of type attr_kind. */
6266 get_AT (dw_die_ref die
, enum dwarf_attribute attr_kind
)
6270 dw_die_ref spec
= NULL
;
6275 for (ix
= 0; VEC_iterate (dw_attr_node
, die
->die_attr
, ix
, a
); ix
++)
6276 if (a
->dw_attr
== attr_kind
)
6278 else if (a
->dw_attr
== DW_AT_specification
6279 || a
->dw_attr
== DW_AT_abstract_origin
)
6283 return get_AT (spec
, attr_kind
);
6288 /* Return the "low pc" attribute value, typically associated with a subprogram
6289 DIE. Return null if the "low pc" attribute is either not present, or if it
6290 cannot be represented as an assembler label identifier. */
6292 static inline const char *
6293 get_AT_low_pc (dw_die_ref die
)
6295 dw_attr_ref a
= get_AT (die
, DW_AT_low_pc
);
6297 return a
? AT_lbl (a
) : NULL
;
6300 /* Return the "high pc" attribute value, typically associated with a subprogram
6301 DIE. Return null if the "high pc" attribute is either not present, or if it
6302 cannot be represented as an assembler label identifier. */
6304 static inline const char *
6305 get_AT_hi_pc (dw_die_ref die
)
6307 dw_attr_ref a
= get_AT (die
, DW_AT_high_pc
);
6309 return a
? AT_lbl (a
) : NULL
;
6312 /* Return the value of the string attribute designated by ATTR_KIND, or
6313 NULL if it is not present. */
6315 static inline const char *
6316 get_AT_string (dw_die_ref die
, enum dwarf_attribute attr_kind
)
6318 dw_attr_ref a
= get_AT (die
, attr_kind
);
6320 return a
? AT_string (a
) : NULL
;
6323 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
6324 if it is not present. */
6327 get_AT_flag (dw_die_ref die
, enum dwarf_attribute attr_kind
)
6329 dw_attr_ref a
= get_AT (die
, attr_kind
);
6331 return a
? AT_flag (a
) : 0;
6334 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
6335 if it is not present. */
6337 static inline unsigned
6338 get_AT_unsigned (dw_die_ref die
, enum dwarf_attribute attr_kind
)
6340 dw_attr_ref a
= get_AT (die
, attr_kind
);
6342 return a
? AT_unsigned (a
) : 0;
6345 static inline dw_die_ref
6346 get_AT_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
)
6348 dw_attr_ref a
= get_AT (die
, attr_kind
);
6350 return a
? AT_ref (a
) : NULL
;
6353 static inline struct dwarf_file_data
*
6354 get_AT_file (dw_die_ref die
, enum dwarf_attribute attr_kind
)
6356 dw_attr_ref a
= get_AT (die
, attr_kind
);
6358 return a
? AT_file (a
) : NULL
;
6361 /* Return TRUE if the language is C or C++. */
6366 unsigned int lang
= get_AT_unsigned (comp_unit_die
, DW_AT_language
);
6368 return (lang
== DW_LANG_C
|| lang
== DW_LANG_C89
|| lang
== DW_LANG_ObjC
6369 || lang
== DW_LANG_C99
6370 || lang
== DW_LANG_C_plus_plus
|| lang
== DW_LANG_ObjC_plus_plus
);
6373 /* Return TRUE if the language is C++. */
6378 unsigned int lang
= get_AT_unsigned (comp_unit_die
, DW_AT_language
);
6380 return lang
== DW_LANG_C_plus_plus
|| lang
== DW_LANG_ObjC_plus_plus
;
6383 /* Return TRUE if the language is Fortran. */
6388 unsigned int lang
= get_AT_unsigned (comp_unit_die
, DW_AT_language
);
6390 return (lang
== DW_LANG_Fortran77
6391 || lang
== DW_LANG_Fortran90
6392 || lang
== DW_LANG_Fortran95
);
6395 /* Return TRUE if the language is Java. */
6400 unsigned int lang
= get_AT_unsigned (comp_unit_die
, DW_AT_language
);
6402 return lang
== DW_LANG_Java
;
6405 /* Return TRUE if the language is Ada. */
6410 unsigned int lang
= get_AT_unsigned (comp_unit_die
, DW_AT_language
);
6412 return lang
== DW_LANG_Ada95
|| lang
== DW_LANG_Ada83
;
6415 /* Remove the specified attribute if present. */
6418 remove_AT (dw_die_ref die
, enum dwarf_attribute attr_kind
)
6426 for (ix
= 0; VEC_iterate (dw_attr_node
, die
->die_attr
, ix
, a
); ix
++)
6427 if (a
->dw_attr
== attr_kind
)
6429 if (AT_class (a
) == dw_val_class_str
)
6430 if (a
->dw_attr_val
.v
.val_str
->refcount
)
6431 a
->dw_attr_val
.v
.val_str
->refcount
--;
6433 /* VEC_ordered_remove should help reduce the number of abbrevs
6435 VEC_ordered_remove (dw_attr_node
, die
->die_attr
, ix
);
6440 /* Remove CHILD from its parent. PREV must have the property that
6441 PREV->DIE_SIB == CHILD. Does not alter CHILD. */
6444 remove_child_with_prev (dw_die_ref child
, dw_die_ref prev
)
6446 gcc_assert (child
->die_parent
== prev
->die_parent
);
6447 gcc_assert (prev
->die_sib
== child
);
6450 gcc_assert (child
->die_parent
->die_child
== child
);
6454 prev
->die_sib
= child
->die_sib
;
6455 if (child
->die_parent
->die_child
== child
)
6456 child
->die_parent
->die_child
= prev
;
6459 /* Remove child DIE whose die_tag is TAG. Do nothing if no child
6463 remove_child_TAG (dw_die_ref die
, enum dwarf_tag tag
)
6469 dw_die_ref prev
= c
;
6471 while (c
->die_tag
== tag
)
6473 remove_child_with_prev (c
, prev
);
6474 /* Might have removed every child. */
6475 if (c
== c
->die_sib
)
6479 } while (c
!= die
->die_child
);
6482 /* Add a CHILD_DIE as the last child of DIE. */
6485 add_child_die (dw_die_ref die
, dw_die_ref child_die
)
6487 /* FIXME this should probably be an assert. */
6488 if (! die
|| ! child_die
)
6490 gcc_assert (die
!= child_die
);
6492 child_die
->die_parent
= die
;
6495 child_die
->die_sib
= die
->die_child
->die_sib
;
6496 die
->die_child
->die_sib
= child_die
;
6499 child_die
->die_sib
= child_die
;
6500 die
->die_child
= child_die
;
6503 /* Move CHILD, which must be a child of PARENT or the DIE for which PARENT
6504 is the specification, to the end of PARENT's list of children.
6505 This is done by removing and re-adding it. */
6508 splice_child_die (dw_die_ref parent
, dw_die_ref child
)
6512 /* We want the declaration DIE from inside the class, not the
6513 specification DIE at toplevel. */
6514 if (child
->die_parent
!= parent
)
6516 dw_die_ref tmp
= get_AT_ref (child
, DW_AT_specification
);
6522 gcc_assert (child
->die_parent
== parent
6523 || (child
->die_parent
6524 == get_AT_ref (parent
, DW_AT_specification
)));
6526 for (p
= child
->die_parent
->die_child
; ; p
= p
->die_sib
)
6527 if (p
->die_sib
== child
)
6529 remove_child_with_prev (child
, p
);
6533 add_child_die (parent
, child
);
6536 /* Return a pointer to a newly created DIE node. */
6538 static inline dw_die_ref
6539 new_die (enum dwarf_tag tag_value
, dw_die_ref parent_die
, tree t
)
6541 dw_die_ref die
= GGC_CNEW (die_node
);
6543 die
->die_tag
= tag_value
;
6545 if (parent_die
!= NULL
)
6546 add_child_die (parent_die
, die
);
6549 limbo_die_node
*limbo_node
;
6551 limbo_node
= GGC_CNEW (limbo_die_node
);
6552 limbo_node
->die
= die
;
6553 limbo_node
->created_for
= t
;
6554 limbo_node
->next
= limbo_die_list
;
6555 limbo_die_list
= limbo_node
;
6561 /* Return the DIE associated with the given type specifier. */
6563 static inline dw_die_ref
6564 lookup_type_die (tree type
)
6566 return TYPE_SYMTAB_DIE (type
);
6569 /* Equate a DIE to a given type specifier. */
6572 equate_type_number_to_die (tree type
, dw_die_ref type_die
)
6574 TYPE_SYMTAB_DIE (type
) = type_die
;
6577 /* Returns a hash value for X (which really is a die_struct). */
6580 decl_die_table_hash (const void *x
)
6582 return (hashval_t
) ((const_dw_die_ref
) x
)->decl_id
;
6585 /* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y. */
6588 decl_die_table_eq (const void *x
, const void *y
)
6590 return (((const_dw_die_ref
) x
)->decl_id
== DECL_UID ((const_tree
) y
));
6593 /* Return the DIE associated with a given declaration. */
6595 static inline dw_die_ref
6596 lookup_decl_die (tree decl
)
6598 return (dw_die_ref
) htab_find_with_hash (decl_die_table
, decl
, DECL_UID (decl
));
6601 /* Returns a hash value for X (which really is a var_loc_list). */
6604 decl_loc_table_hash (const void *x
)
6606 return (hashval_t
) ((const var_loc_list
*) x
)->decl_id
;
6609 /* Return nonzero if decl_id of var_loc_list X is the same as
6613 decl_loc_table_eq (const void *x
, const void *y
)
6615 return (((const var_loc_list
*) x
)->decl_id
== DECL_UID ((const_tree
) y
));
6618 /* Return the var_loc list associated with a given declaration. */
6620 static inline var_loc_list
*
6621 lookup_decl_loc (const_tree decl
)
6623 return (var_loc_list
*)
6624 htab_find_with_hash (decl_loc_table
, decl
, DECL_UID (decl
));
6627 /* Equate a DIE to a particular declaration. */
6630 equate_decl_number_to_die (tree decl
, dw_die_ref decl_die
)
6632 unsigned int decl_id
= DECL_UID (decl
);
6635 slot
= htab_find_slot_with_hash (decl_die_table
, decl
, decl_id
, INSERT
);
6637 decl_die
->decl_id
= decl_id
;
6640 /* Add a variable location node to the linked list for DECL. */
6643 add_var_loc_to_decl (tree decl
, struct var_loc_node
*loc
)
6645 unsigned int decl_id
= DECL_UID (decl
);
6649 slot
= htab_find_slot_with_hash (decl_loc_table
, decl
, decl_id
, INSERT
);
6652 temp
= GGC_CNEW (var_loc_list
);
6653 temp
->decl_id
= decl_id
;
6657 temp
= (var_loc_list
*) *slot
;
6661 /* If the current location is the same as the end of the list,
6662 and either both or neither of the locations is uninitialized,
6663 we have nothing to do. */
6664 if ((!rtx_equal_p (NOTE_VAR_LOCATION_LOC (temp
->last
->var_loc_note
),
6665 NOTE_VAR_LOCATION_LOC (loc
->var_loc_note
)))
6666 || ((NOTE_VAR_LOCATION_STATUS (temp
->last
->var_loc_note
)
6667 != NOTE_VAR_LOCATION_STATUS (loc
->var_loc_note
))
6668 && ((NOTE_VAR_LOCATION_STATUS (temp
->last
->var_loc_note
)
6669 == VAR_INIT_STATUS_UNINITIALIZED
)
6670 || (NOTE_VAR_LOCATION_STATUS (loc
->var_loc_note
)
6671 == VAR_INIT_STATUS_UNINITIALIZED
))))
6673 /* Add LOC to the end of list and update LAST. */
6674 temp
->last
->next
= loc
;
6678 /* Do not add empty location to the beginning of the list. */
6679 else if (NOTE_VAR_LOCATION_LOC (loc
->var_loc_note
) != NULL_RTX
)
6686 /* Keep track of the number of spaces used to indent the
6687 output of the debugging routines that print the structure of
6688 the DIE internal representation. */
6689 static int print_indent
;
6691 /* Indent the line the number of spaces given by print_indent. */
6694 print_spaces (FILE *outfile
)
6696 fprintf (outfile
, "%*s", print_indent
, "");
6699 /* Print the information associated with a given DIE, and its children.
6700 This routine is a debugging aid only. */
6703 print_die (dw_die_ref die
, FILE *outfile
)
6709 print_spaces (outfile
);
6710 fprintf (outfile
, "DIE %4ld: %s\n",
6711 die
->die_offset
, dwarf_tag_name (die
->die_tag
));
6712 print_spaces (outfile
);
6713 fprintf (outfile
, " abbrev id: %lu", die
->die_abbrev
);
6714 fprintf (outfile
, " offset: %ld\n", die
->die_offset
);
6716 for (ix
= 0; VEC_iterate (dw_attr_node
, die
->die_attr
, ix
, a
); ix
++)
6718 print_spaces (outfile
);
6719 fprintf (outfile
, " %s: ", dwarf_attr_name (a
->dw_attr
));
6721 switch (AT_class (a
))
6723 case dw_val_class_addr
:
6724 fprintf (outfile
, "address");
6726 case dw_val_class_offset
:
6727 fprintf (outfile
, "offset");
6729 case dw_val_class_loc
:
6730 fprintf (outfile
, "location descriptor");
6732 case dw_val_class_loc_list
:
6733 fprintf (outfile
, "location list -> label:%s",
6734 AT_loc_list (a
)->ll_symbol
);
6736 case dw_val_class_range_list
:
6737 fprintf (outfile
, "range list");
6739 case dw_val_class_const
:
6740 fprintf (outfile
, HOST_WIDE_INT_PRINT_DEC
, AT_int (a
));
6742 case dw_val_class_unsigned_const
:
6743 fprintf (outfile
, HOST_WIDE_INT_PRINT_UNSIGNED
, AT_unsigned (a
));
6745 case dw_val_class_long_long
:
6746 fprintf (outfile
, "constant (%lu,%lu)",
6747 a
->dw_attr_val
.v
.val_long_long
.hi
,
6748 a
->dw_attr_val
.v
.val_long_long
.low
);
6750 case dw_val_class_vec
:
6751 fprintf (outfile
, "floating-point or vector constant");
6753 case dw_val_class_flag
:
6754 fprintf (outfile
, "%u", AT_flag (a
));
6756 case dw_val_class_die_ref
:
6757 if (AT_ref (a
) != NULL
)
6759 if (AT_ref (a
)->die_symbol
)
6760 fprintf (outfile
, "die -> label: %s", AT_ref (a
)->die_symbol
);
6762 fprintf (outfile
, "die -> %ld", AT_ref (a
)->die_offset
);
6765 fprintf (outfile
, "die -> <null>");
6767 case dw_val_class_lbl_id
:
6768 case dw_val_class_lineptr
:
6769 case dw_val_class_macptr
:
6770 fprintf (outfile
, "label: %s", AT_lbl (a
));
6772 case dw_val_class_str
:
6773 if (AT_string (a
) != NULL
)
6774 fprintf (outfile
, "\"%s\"", AT_string (a
));
6776 fprintf (outfile
, "<null>");
6778 case dw_val_class_file
:
6779 fprintf (outfile
, "\"%s\" (%d)", AT_file (a
)->filename
,
6780 AT_file (a
)->emitted_number
);
6786 fprintf (outfile
, "\n");
6789 if (die
->die_child
!= NULL
)
6792 FOR_EACH_CHILD (die
, c
, print_die (c
, outfile
));
6795 if (print_indent
== 0)
6796 fprintf (outfile
, "\n");
6799 /* Print the contents of the source code line number correspondence table.
6800 This routine is a debugging aid only. */
6803 print_dwarf_line_table (FILE *outfile
)
6806 dw_line_info_ref line_info
;
6808 fprintf (outfile
, "\n\nDWARF source line information\n");
6809 for (i
= 1; i
< line_info_table_in_use
; i
++)
6811 line_info
= &line_info_table
[i
];
6812 fprintf (outfile
, "%5d: %4ld %6ld\n", i
,
6813 line_info
->dw_file_num
,
6814 line_info
->dw_line_num
);
6817 fprintf (outfile
, "\n\n");
6820 /* Print the information collected for a given DIE. */
6823 debug_dwarf_die (dw_die_ref die
)
6825 print_die (die
, stderr
);
6828 /* Print all DWARF information collected for the compilation unit.
6829 This routine is a debugging aid only. */
6835 print_die (comp_unit_die
, stderr
);
6836 if (! DWARF2_ASM_LINE_DEBUG_INFO
)
6837 print_dwarf_line_table (stderr
);
6840 /* Start a new compilation unit DIE for an include file. OLD_UNIT is the CU
6841 for the enclosing include file, if any. BINCL_DIE is the DW_TAG_GNU_BINCL
6842 DIE that marks the start of the DIEs for this include file. */
6845 push_new_compile_unit (dw_die_ref old_unit
, dw_die_ref bincl_die
)
6847 const char *filename
= get_AT_string (bincl_die
, DW_AT_name
);
6848 dw_die_ref new_unit
= gen_compile_unit_die (filename
);
6850 new_unit
->die_sib
= old_unit
;
6854 /* Close an include-file CU and reopen the enclosing one. */
6857 pop_compile_unit (dw_die_ref old_unit
)
6859 dw_die_ref new_unit
= old_unit
->die_sib
;
6861 old_unit
->die_sib
= NULL
;
6865 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
6866 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO), ctx)
6868 /* Calculate the checksum of a location expression. */
6871 loc_checksum (dw_loc_descr_ref loc
, struct md5_ctx
*ctx
)
6873 CHECKSUM (loc
->dw_loc_opc
);
6874 CHECKSUM (loc
->dw_loc_oprnd1
);
6875 CHECKSUM (loc
->dw_loc_oprnd2
);
6878 /* Calculate the checksum of an attribute. */
6881 attr_checksum (dw_attr_ref at
, struct md5_ctx
*ctx
, int *mark
)
6883 dw_loc_descr_ref loc
;
6886 CHECKSUM (at
->dw_attr
);
6888 /* We don't care that this was compiled with a different compiler
6889 snapshot; if the output is the same, that's what matters. */
6890 if (at
->dw_attr
== DW_AT_producer
)
6893 switch (AT_class (at
))
6895 case dw_val_class_const
:
6896 CHECKSUM (at
->dw_attr_val
.v
.val_int
);
6898 case dw_val_class_unsigned_const
:
6899 CHECKSUM (at
->dw_attr_val
.v
.val_unsigned
);
6901 case dw_val_class_long_long
:
6902 CHECKSUM (at
->dw_attr_val
.v
.val_long_long
);
6904 case dw_val_class_vec
:
6905 CHECKSUM (at
->dw_attr_val
.v
.val_vec
);
6907 case dw_val_class_flag
:
6908 CHECKSUM (at
->dw_attr_val
.v
.val_flag
);
6910 case dw_val_class_str
:
6911 CHECKSUM_STRING (AT_string (at
));
6914 case dw_val_class_addr
:
6916 gcc_assert (GET_CODE (r
) == SYMBOL_REF
);
6917 CHECKSUM_STRING (XSTR (r
, 0));
6920 case dw_val_class_offset
:
6921 CHECKSUM (at
->dw_attr_val
.v
.val_offset
);
6924 case dw_val_class_loc
:
6925 for (loc
= AT_loc (at
); loc
; loc
= loc
->dw_loc_next
)
6926 loc_checksum (loc
, ctx
);
6929 case dw_val_class_die_ref
:
6930 die_checksum (AT_ref (at
), ctx
, mark
);
6933 case dw_val_class_fde_ref
:
6934 case dw_val_class_lbl_id
:
6935 case dw_val_class_lineptr
:
6936 case dw_val_class_macptr
:
6939 case dw_val_class_file
:
6940 CHECKSUM_STRING (AT_file (at
)->filename
);
6948 /* Calculate the checksum of a DIE. */
6951 die_checksum (dw_die_ref die
, struct md5_ctx
*ctx
, int *mark
)
6957 /* To avoid infinite recursion. */
6960 CHECKSUM (die
->die_mark
);
6963 die
->die_mark
= ++(*mark
);
6965 CHECKSUM (die
->die_tag
);
6967 for (ix
= 0; VEC_iterate (dw_attr_node
, die
->die_attr
, ix
, a
); ix
++)
6968 attr_checksum (a
, ctx
, mark
);
6970 FOR_EACH_CHILD (die
, c
, die_checksum (c
, ctx
, mark
));
6974 #undef CHECKSUM_STRING
6976 /* Do the location expressions look same? */
6978 same_loc_p (dw_loc_descr_ref loc1
, dw_loc_descr_ref loc2
, int *mark
)
6980 return loc1
->dw_loc_opc
== loc2
->dw_loc_opc
6981 && same_dw_val_p (&loc1
->dw_loc_oprnd1
, &loc2
->dw_loc_oprnd1
, mark
)
6982 && same_dw_val_p (&loc1
->dw_loc_oprnd2
, &loc2
->dw_loc_oprnd2
, mark
);
6985 /* Do the values look the same? */
6987 same_dw_val_p (const dw_val_node
*v1
, const dw_val_node
*v2
, int *mark
)
6989 dw_loc_descr_ref loc1
, loc2
;
6992 if (v1
->val_class
!= v2
->val_class
)
6995 switch (v1
->val_class
)
6997 case dw_val_class_const
:
6998 return v1
->v
.val_int
== v2
->v
.val_int
;
6999 case dw_val_class_unsigned_const
:
7000 return v1
->v
.val_unsigned
== v2
->v
.val_unsigned
;
7001 case dw_val_class_long_long
:
7002 return v1
->v
.val_long_long
.hi
== v2
->v
.val_long_long
.hi
7003 && v1
->v
.val_long_long
.low
== v2
->v
.val_long_long
.low
;
7004 case dw_val_class_vec
:
7005 if (v1
->v
.val_vec
.length
!= v2
->v
.val_vec
.length
7006 || v1
->v
.val_vec
.elt_size
!= v2
->v
.val_vec
.elt_size
)
7008 if (memcmp (v1
->v
.val_vec
.array
, v2
->v
.val_vec
.array
,
7009 v1
->v
.val_vec
.length
* v1
->v
.val_vec
.elt_size
))
7012 case dw_val_class_flag
:
7013 return v1
->v
.val_flag
== v2
->v
.val_flag
;
7014 case dw_val_class_str
:
7015 return !strcmp(v1
->v
.val_str
->str
, v2
->v
.val_str
->str
);
7017 case dw_val_class_addr
:
7018 r1
= v1
->v
.val_addr
;
7019 r2
= v2
->v
.val_addr
;
7020 if (GET_CODE (r1
) != GET_CODE (r2
))
7022 gcc_assert (GET_CODE (r1
) == SYMBOL_REF
);
7023 return !strcmp (XSTR (r1
, 0), XSTR (r2
, 0));
7025 case dw_val_class_offset
:
7026 return v1
->v
.val_offset
== v2
->v
.val_offset
;
7028 case dw_val_class_loc
:
7029 for (loc1
= v1
->v
.val_loc
, loc2
= v2
->v
.val_loc
;
7031 loc1
= loc1
->dw_loc_next
, loc2
= loc2
->dw_loc_next
)
7032 if (!same_loc_p (loc1
, loc2
, mark
))
7034 return !loc1
&& !loc2
;
7036 case dw_val_class_die_ref
:
7037 return same_die_p (v1
->v
.val_die_ref
.die
, v2
->v
.val_die_ref
.die
, mark
);
7039 case dw_val_class_fde_ref
:
7040 case dw_val_class_lbl_id
:
7041 case dw_val_class_lineptr
:
7042 case dw_val_class_macptr
:
7045 case dw_val_class_file
:
7046 return v1
->v
.val_file
== v2
->v
.val_file
;
7053 /* Do the attributes look the same? */
7056 same_attr_p (dw_attr_ref at1
, dw_attr_ref at2
, int *mark
)
7058 if (at1
->dw_attr
!= at2
->dw_attr
)
7061 /* We don't care that this was compiled with a different compiler
7062 snapshot; if the output is the same, that's what matters. */
7063 if (at1
->dw_attr
== DW_AT_producer
)
7066 return same_dw_val_p (&at1
->dw_attr_val
, &at2
->dw_attr_val
, mark
);
7069 /* Do the dies look the same? */
7072 same_die_p (dw_die_ref die1
, dw_die_ref die2
, int *mark
)
7078 /* To avoid infinite recursion. */
7080 return die1
->die_mark
== die2
->die_mark
;
7081 die1
->die_mark
= die2
->die_mark
= ++(*mark
);
7083 if (die1
->die_tag
!= die2
->die_tag
)
7086 if (VEC_length (dw_attr_node
, die1
->die_attr
)
7087 != VEC_length (dw_attr_node
, die2
->die_attr
))
7090 for (ix
= 0; VEC_iterate (dw_attr_node
, die1
->die_attr
, ix
, a1
); ix
++)
7091 if (!same_attr_p (a1
, VEC_index (dw_attr_node
, die2
->die_attr
, ix
), mark
))
7094 c1
= die1
->die_child
;
7095 c2
= die2
->die_child
;
7104 if (!same_die_p (c1
, c2
, mark
))
7108 if (c1
== die1
->die_child
)
7110 if (c2
== die2
->die_child
)
7120 /* Do the dies look the same? Wrapper around same_die_p. */
7123 same_die_p_wrap (dw_die_ref die1
, dw_die_ref die2
)
7126 int ret
= same_die_p (die1
, die2
, &mark
);
7128 unmark_all_dies (die1
);
7129 unmark_all_dies (die2
);
7134 /* The prefix to attach to symbols on DIEs in the current comdat debug
7136 static char *comdat_symbol_id
;
7138 /* The index of the current symbol within the current comdat CU. */
7139 static unsigned int comdat_symbol_number
;
7141 /* Calculate the MD5 checksum of the compilation unit DIE UNIT_DIE and its
7142 children, and set comdat_symbol_id accordingly. */
7145 compute_section_prefix (dw_die_ref unit_die
)
7147 const char *die_name
= get_AT_string (unit_die
, DW_AT_name
);
7148 const char *base
= die_name
? lbasename (die_name
) : "anonymous";
7149 char *name
= XALLOCAVEC (char, strlen (base
) + 64);
7152 unsigned char checksum
[16];
7155 /* Compute the checksum of the DIE, then append part of it as hex digits to
7156 the name filename of the unit. */
7158 md5_init_ctx (&ctx
);
7160 die_checksum (unit_die
, &ctx
, &mark
);
7161 unmark_all_dies (unit_die
);
7162 md5_finish_ctx (&ctx
, checksum
);
7164 sprintf (name
, "%s.", base
);
7165 clean_symbol_name (name
);
7167 p
= name
+ strlen (name
);
7168 for (i
= 0; i
< 4; i
++)
7170 sprintf (p
, "%.2x", checksum
[i
]);
7174 comdat_symbol_id
= unit_die
->die_symbol
= xstrdup (name
);
7175 comdat_symbol_number
= 0;
7178 /* Returns nonzero if DIE represents a type, in the sense of TYPE_P. */
7181 is_type_die (dw_die_ref die
)
7183 switch (die
->die_tag
)
7185 case DW_TAG_array_type
:
7186 case DW_TAG_class_type
:
7187 case DW_TAG_interface_type
:
7188 case DW_TAG_enumeration_type
:
7189 case DW_TAG_pointer_type
:
7190 case DW_TAG_reference_type
:
7191 case DW_TAG_string_type
:
7192 case DW_TAG_structure_type
:
7193 case DW_TAG_subroutine_type
:
7194 case DW_TAG_union_type
:
7195 case DW_TAG_ptr_to_member_type
:
7196 case DW_TAG_set_type
:
7197 case DW_TAG_subrange_type
:
7198 case DW_TAG_base_type
:
7199 case DW_TAG_const_type
:
7200 case DW_TAG_file_type
:
7201 case DW_TAG_packed_type
:
7202 case DW_TAG_volatile_type
:
7203 case DW_TAG_typedef
:
7210 /* Returns 1 iff C is the sort of DIE that should go into a COMDAT CU.
7211 Basically, we want to choose the bits that are likely to be shared between
7212 compilations (types) and leave out the bits that are specific to individual
7213 compilations (functions). */
7216 is_comdat_die (dw_die_ref c
)
7218 /* I think we want to leave base types and __vtbl_ptr_type in the main CU, as
7219 we do for stabs. The advantage is a greater likelihood of sharing between
7220 objects that don't include headers in the same order (and therefore would
7221 put the base types in a different comdat). jason 8/28/00 */
7223 if (c
->die_tag
== DW_TAG_base_type
)
7226 if (c
->die_tag
== DW_TAG_pointer_type
7227 || c
->die_tag
== DW_TAG_reference_type
7228 || c
->die_tag
== DW_TAG_const_type
7229 || c
->die_tag
== DW_TAG_volatile_type
)
7231 dw_die_ref t
= get_AT_ref (c
, DW_AT_type
);
7233 return t
? is_comdat_die (t
) : 0;
7236 return is_type_die (c
);
7239 /* Returns 1 iff C is the sort of DIE that might be referred to from another
7240 compilation unit. */
7243 is_symbol_die (dw_die_ref c
)
7245 return (is_type_die (c
)
7246 || (get_AT (c
, DW_AT_declaration
)
7247 && !get_AT (c
, DW_AT_specification
))
7248 || c
->die_tag
== DW_TAG_namespace
7249 || c
->die_tag
== DW_TAG_module
);
7253 gen_internal_sym (const char *prefix
)
7257 ASM_GENERATE_INTERNAL_LABEL (buf
, prefix
, label_num
++);
7258 return xstrdup (buf
);
7261 /* Assign symbols to all worthy DIEs under DIE. */
7264 assign_symbol_names (dw_die_ref die
)
7268 if (is_symbol_die (die
))
7270 if (comdat_symbol_id
)
7272 char *p
= XALLOCAVEC (char, strlen (comdat_symbol_id
) + 64);
7274 sprintf (p
, "%s.%s.%x", DIE_LABEL_PREFIX
,
7275 comdat_symbol_id
, comdat_symbol_number
++);
7276 die
->die_symbol
= xstrdup (p
);
7279 die
->die_symbol
= gen_internal_sym ("LDIE");
7282 FOR_EACH_CHILD (die
, c
, assign_symbol_names (c
));
7285 struct cu_hash_table_entry
7288 unsigned min_comdat_num
, max_comdat_num
;
7289 struct cu_hash_table_entry
*next
;
7292 /* Routines to manipulate hash table of CUs. */
7294 htab_cu_hash (const void *of
)
7296 const struct cu_hash_table_entry
*const entry
=
7297 (const struct cu_hash_table_entry
*) of
;
7299 return htab_hash_string (entry
->cu
->die_symbol
);
7303 htab_cu_eq (const void *of1
, const void *of2
)
7305 const struct cu_hash_table_entry
*const entry1
=
7306 (const struct cu_hash_table_entry
*) of1
;
7307 const struct die_struct
*const entry2
= (const struct die_struct
*) of2
;
7309 return !strcmp (entry1
->cu
->die_symbol
, entry2
->die_symbol
);
7313 htab_cu_del (void *what
)
7315 struct cu_hash_table_entry
*next
,
7316 *entry
= (struct cu_hash_table_entry
*) what
;
7326 /* Check whether we have already seen this CU and set up SYM_NUM
7329 check_duplicate_cu (dw_die_ref cu
, htab_t htable
, unsigned int *sym_num
)
7331 struct cu_hash_table_entry dummy
;
7332 struct cu_hash_table_entry
**slot
, *entry
, *last
= &dummy
;
7334 dummy
.max_comdat_num
= 0;
7336 slot
= (struct cu_hash_table_entry
**)
7337 htab_find_slot_with_hash (htable
, cu
, htab_hash_string (cu
->die_symbol
),
7341 for (; entry
; last
= entry
, entry
= entry
->next
)
7343 if (same_die_p_wrap (cu
, entry
->cu
))
7349 *sym_num
= entry
->min_comdat_num
;
7353 entry
= XCNEW (struct cu_hash_table_entry
);
7355 entry
->min_comdat_num
= *sym_num
= last
->max_comdat_num
;
7356 entry
->next
= *slot
;
7362 /* Record SYM_NUM to record of CU in HTABLE. */
7364 record_comdat_symbol_number (dw_die_ref cu
, htab_t htable
, unsigned int sym_num
)
7366 struct cu_hash_table_entry
**slot
, *entry
;
7368 slot
= (struct cu_hash_table_entry
**)
7369 htab_find_slot_with_hash (htable
, cu
, htab_hash_string (cu
->die_symbol
),
7373 entry
->max_comdat_num
= sym_num
;
7376 /* Traverse the DIE (which is always comp_unit_die), and set up
7377 additional compilation units for each of the include files we see
7378 bracketed by BINCL/EINCL. */
7381 break_out_includes (dw_die_ref die
)
7384 dw_die_ref unit
= NULL
;
7385 limbo_die_node
*node
, **pnode
;
7386 htab_t cu_hash_table
;
7390 dw_die_ref prev
= c
;
7392 while (c
->die_tag
== DW_TAG_GNU_BINCL
|| c
->die_tag
== DW_TAG_GNU_EINCL
7393 || (unit
&& is_comdat_die (c
)))
7395 dw_die_ref next
= c
->die_sib
;
7397 /* This DIE is for a secondary CU; remove it from the main one. */
7398 remove_child_with_prev (c
, prev
);
7400 if (c
->die_tag
== DW_TAG_GNU_BINCL
)
7401 unit
= push_new_compile_unit (unit
, c
);
7402 else if (c
->die_tag
== DW_TAG_GNU_EINCL
)
7403 unit
= pop_compile_unit (unit
);
7405 add_child_die (unit
, c
);
7407 if (c
== die
->die_child
)
7410 } while (c
!= die
->die_child
);
7413 /* We can only use this in debugging, since the frontend doesn't check
7414 to make sure that we leave every include file we enter. */
7418 assign_symbol_names (die
);
7419 cu_hash_table
= htab_create (10, htab_cu_hash
, htab_cu_eq
, htab_cu_del
);
7420 for (node
= limbo_die_list
, pnode
= &limbo_die_list
;
7426 compute_section_prefix (node
->die
);
7427 is_dupl
= check_duplicate_cu (node
->die
, cu_hash_table
,
7428 &comdat_symbol_number
);
7429 assign_symbol_names (node
->die
);
7431 *pnode
= node
->next
;
7434 pnode
= &node
->next
;
7435 record_comdat_symbol_number (node
->die
, cu_hash_table
,
7436 comdat_symbol_number
);
7439 htab_delete (cu_hash_table
);
7442 /* Traverse the DIE and add a sibling attribute if it may have the
7443 effect of speeding up access to siblings. To save some space,
7444 avoid generating sibling attributes for DIE's without children. */
7447 add_sibling_attributes (dw_die_ref die
)
7451 if (! die
->die_child
)
7454 if (die
->die_parent
&& die
!= die
->die_parent
->die_child
)
7455 add_AT_die_ref (die
, DW_AT_sibling
, die
->die_sib
);
7457 FOR_EACH_CHILD (die
, c
, add_sibling_attributes (c
));
7460 /* Output all location lists for the DIE and its children. */
7463 output_location_lists (dw_die_ref die
)
7469 for (ix
= 0; VEC_iterate (dw_attr_node
, die
->die_attr
, ix
, a
); ix
++)
7470 if (AT_class (a
) == dw_val_class_loc_list
)
7471 output_loc_list (AT_loc_list (a
));
7473 FOR_EACH_CHILD (die
, c
, output_location_lists (c
));
7476 /* The format of each DIE (and its attribute value pairs) is encoded in an
7477 abbreviation table. This routine builds the abbreviation table and assigns
7478 a unique abbreviation id for each abbreviation entry. The children of each
7479 die are visited recursively. */
7482 build_abbrev_table (dw_die_ref die
)
7484 unsigned long abbrev_id
;
7485 unsigned int n_alloc
;
7490 /* Scan the DIE references, and mark as external any that refer to
7491 DIEs from other CUs (i.e. those which are not marked). */
7492 for (ix
= 0; VEC_iterate (dw_attr_node
, die
->die_attr
, ix
, a
); ix
++)
7493 if (AT_class (a
) == dw_val_class_die_ref
7494 && AT_ref (a
)->die_mark
== 0)
7496 gcc_assert (AT_ref (a
)->die_symbol
);
7498 set_AT_ref_external (a
, 1);
7501 for (abbrev_id
= 1; abbrev_id
< abbrev_die_table_in_use
; ++abbrev_id
)
7503 dw_die_ref abbrev
= abbrev_die_table
[abbrev_id
];
7504 dw_attr_ref die_a
, abbrev_a
;
7508 if (abbrev
->die_tag
!= die
->die_tag
)
7510 if ((abbrev
->die_child
!= NULL
) != (die
->die_child
!= NULL
))
7513 if (VEC_length (dw_attr_node
, abbrev
->die_attr
)
7514 != VEC_length (dw_attr_node
, die
->die_attr
))
7517 for (ix
= 0; VEC_iterate (dw_attr_node
, die
->die_attr
, ix
, die_a
); ix
++)
7519 abbrev_a
= VEC_index (dw_attr_node
, abbrev
->die_attr
, ix
);
7520 if ((abbrev_a
->dw_attr
!= die_a
->dw_attr
)
7521 || (value_format (abbrev_a
) != value_format (die_a
)))
7531 if (abbrev_id
>= abbrev_die_table_in_use
)
7533 if (abbrev_die_table_in_use
>= abbrev_die_table_allocated
)
7535 n_alloc
= abbrev_die_table_allocated
+ ABBREV_DIE_TABLE_INCREMENT
;
7536 abbrev_die_table
= GGC_RESIZEVEC (dw_die_ref
, abbrev_die_table
,
7539 memset (&abbrev_die_table
[abbrev_die_table_allocated
], 0,
7540 (n_alloc
- abbrev_die_table_allocated
) * sizeof (dw_die_ref
));
7541 abbrev_die_table_allocated
= n_alloc
;
7544 ++abbrev_die_table_in_use
;
7545 abbrev_die_table
[abbrev_id
] = die
;
7548 die
->die_abbrev
= abbrev_id
;
7549 FOR_EACH_CHILD (die
, c
, build_abbrev_table (c
));
7552 /* Return the power-of-two number of bytes necessary to represent VALUE. */
7555 constant_size (unsigned HOST_WIDE_INT value
)
7562 log
= floor_log2 (value
);
7565 log
= 1 << (floor_log2 (log
) + 1);
7570 /* Return the size of a DIE as it is represented in the
7571 .debug_info section. */
7573 static unsigned long
7574 size_of_die (dw_die_ref die
)
7576 unsigned long size
= 0;
7580 size
+= size_of_uleb128 (die
->die_abbrev
);
7581 for (ix
= 0; VEC_iterate (dw_attr_node
, die
->die_attr
, ix
, a
); ix
++)
7583 switch (AT_class (a
))
7585 case dw_val_class_addr
:
7586 size
+= DWARF2_ADDR_SIZE
;
7588 case dw_val_class_offset
:
7589 size
+= DWARF_OFFSET_SIZE
;
7591 case dw_val_class_loc
:
7593 unsigned long lsize
= size_of_locs (AT_loc (a
));
7596 size
+= constant_size (lsize
);
7600 case dw_val_class_loc_list
:
7601 size
+= DWARF_OFFSET_SIZE
;
7603 case dw_val_class_range_list
:
7604 size
+= DWARF_OFFSET_SIZE
;
7606 case dw_val_class_const
:
7607 size
+= size_of_sleb128 (AT_int (a
));
7609 case dw_val_class_unsigned_const
:
7610 size
+= constant_size (AT_unsigned (a
));
7612 case dw_val_class_long_long
:
7613 size
+= 1 + 2*HOST_BITS_PER_LONG
/HOST_BITS_PER_CHAR
; /* block */
7615 case dw_val_class_vec
:
7616 size
+= constant_size (a
->dw_attr_val
.v
.val_vec
.length
7617 * a
->dw_attr_val
.v
.val_vec
.elt_size
)
7618 + a
->dw_attr_val
.v
.val_vec
.length
7619 * a
->dw_attr_val
.v
.val_vec
.elt_size
; /* block */
7621 case dw_val_class_flag
:
7624 case dw_val_class_die_ref
:
7625 if (AT_ref_external (a
))
7626 size
+= DWARF2_ADDR_SIZE
;
7628 size
+= DWARF_OFFSET_SIZE
;
7630 case dw_val_class_fde_ref
:
7631 size
+= DWARF_OFFSET_SIZE
;
7633 case dw_val_class_lbl_id
:
7634 size
+= DWARF2_ADDR_SIZE
;
7636 case dw_val_class_lineptr
:
7637 case dw_val_class_macptr
:
7638 size
+= DWARF_OFFSET_SIZE
;
7640 case dw_val_class_str
:
7641 if (AT_string_form (a
) == DW_FORM_strp
)
7642 size
+= DWARF_OFFSET_SIZE
;
7644 size
+= strlen (a
->dw_attr_val
.v
.val_str
->str
) + 1;
7646 case dw_val_class_file
:
7647 size
+= constant_size (maybe_emit_file (a
->dw_attr_val
.v
.val_file
));
7657 /* Size the debugging information associated with a given DIE. Visits the
7658 DIE's children recursively. Updates the global variable next_die_offset, on
7659 each time through. Uses the current value of next_die_offset to update the
7660 die_offset field in each DIE. */
7663 calc_die_sizes (dw_die_ref die
)
7667 die
->die_offset
= next_die_offset
;
7668 next_die_offset
+= size_of_die (die
);
7670 FOR_EACH_CHILD (die
, c
, calc_die_sizes (c
));
7672 if (die
->die_child
!= NULL
)
7673 /* Count the null byte used to terminate sibling lists. */
7674 next_die_offset
+= 1;
7677 /* Set the marks for a die and its children. We do this so
7678 that we know whether or not a reference needs to use FORM_ref_addr; only
7679 DIEs in the same CU will be marked. We used to clear out the offset
7680 and use that as the flag, but ran into ordering problems. */
7683 mark_dies (dw_die_ref die
)
7687 gcc_assert (!die
->die_mark
);
7690 FOR_EACH_CHILD (die
, c
, mark_dies (c
));
7693 /* Clear the marks for a die and its children. */
7696 unmark_dies (dw_die_ref die
)
7700 gcc_assert (die
->die_mark
);
7703 FOR_EACH_CHILD (die
, c
, unmark_dies (c
));
7706 /* Clear the marks for a die, its children and referred dies. */
7709 unmark_all_dies (dw_die_ref die
)
7719 FOR_EACH_CHILD (die
, c
, unmark_all_dies (c
));
7721 for (ix
= 0; VEC_iterate (dw_attr_node
, die
->die_attr
, ix
, a
); ix
++)
7722 if (AT_class (a
) == dw_val_class_die_ref
)
7723 unmark_all_dies (AT_ref (a
));
7726 /* Return the size of the .debug_pubnames or .debug_pubtypes table
7727 generated for the compilation unit. */
7729 static unsigned long
7730 size_of_pubnames (VEC (pubname_entry
, gc
) * names
)
7736 size
= DWARF_PUBNAMES_HEADER_SIZE
;
7737 for (i
= 0; VEC_iterate (pubname_entry
, names
, i
, p
); i
++)
7738 if (names
!= pubtype_table
7739 || p
->die
->die_offset
!= 0
7740 || !flag_eliminate_unused_debug_types
)
7741 size
+= strlen (p
->name
) + DWARF_OFFSET_SIZE
+ 1;
7743 size
+= DWARF_OFFSET_SIZE
;
7747 /* Return the size of the information in the .debug_aranges section. */
7749 static unsigned long
7750 size_of_aranges (void)
7754 size
= DWARF_ARANGES_HEADER_SIZE
;
7756 /* Count the address/length pair for this compilation unit. */
7757 if (text_section_used
)
7758 size
+= 2 * DWARF2_ADDR_SIZE
;
7759 if (cold_text_section_used
)
7760 size
+= 2 * DWARF2_ADDR_SIZE
;
7761 size
+= 2 * DWARF2_ADDR_SIZE
* arange_table_in_use
;
7763 /* Count the two zero words used to terminated the address range table. */
7764 size
+= 2 * DWARF2_ADDR_SIZE
;
7768 /* Select the encoding of an attribute value. */
7770 static enum dwarf_form
7771 value_format (dw_attr_ref a
)
7773 switch (a
->dw_attr_val
.val_class
)
7775 case dw_val_class_addr
:
7776 return DW_FORM_addr
;
7777 case dw_val_class_range_list
:
7778 case dw_val_class_offset
:
7779 case dw_val_class_loc_list
:
7780 switch (DWARF_OFFSET_SIZE
)
7783 return DW_FORM_data4
;
7785 return DW_FORM_data8
;
7789 case dw_val_class_loc
:
7790 switch (constant_size (size_of_locs (AT_loc (a
))))
7793 return DW_FORM_block1
;
7795 return DW_FORM_block2
;
7799 case dw_val_class_const
:
7800 return DW_FORM_sdata
;
7801 case dw_val_class_unsigned_const
:
7802 switch (constant_size (AT_unsigned (a
)))
7805 return DW_FORM_data1
;
7807 return DW_FORM_data2
;
7809 return DW_FORM_data4
;
7811 return DW_FORM_data8
;
7815 case dw_val_class_long_long
:
7816 return DW_FORM_block1
;
7817 case dw_val_class_vec
:
7818 switch (constant_size (a
->dw_attr_val
.v
.val_vec
.length
7819 * a
->dw_attr_val
.v
.val_vec
.elt_size
))
7822 return DW_FORM_block1
;
7824 return DW_FORM_block2
;
7826 return DW_FORM_block4
;
7830 case dw_val_class_flag
:
7831 return DW_FORM_flag
;
7832 case dw_val_class_die_ref
:
7833 if (AT_ref_external (a
))
7834 return DW_FORM_ref_addr
;
7837 case dw_val_class_fde_ref
:
7838 return DW_FORM_data
;
7839 case dw_val_class_lbl_id
:
7840 return DW_FORM_addr
;
7841 case dw_val_class_lineptr
:
7842 case dw_val_class_macptr
:
7843 return DW_FORM_data
;
7844 case dw_val_class_str
:
7845 return AT_string_form (a
);
7846 case dw_val_class_file
:
7847 switch (constant_size (maybe_emit_file (a
->dw_attr_val
.v
.val_file
)))
7850 return DW_FORM_data1
;
7852 return DW_FORM_data2
;
7854 return DW_FORM_data4
;
7864 /* Output the encoding of an attribute value. */
7867 output_value_format (dw_attr_ref a
)
7869 enum dwarf_form form
= value_format (a
);
7871 dw2_asm_output_data_uleb128 (form
, "(%s)", dwarf_form_name (form
));
7874 /* Output the .debug_abbrev section which defines the DIE abbreviation
7878 output_abbrev_section (void)
7880 unsigned long abbrev_id
;
7882 for (abbrev_id
= 1; abbrev_id
< abbrev_die_table_in_use
; ++abbrev_id
)
7884 dw_die_ref abbrev
= abbrev_die_table
[abbrev_id
];
7888 dw2_asm_output_data_uleb128 (abbrev_id
, "(abbrev code)");
7889 dw2_asm_output_data_uleb128 (abbrev
->die_tag
, "(TAG: %s)",
7890 dwarf_tag_name (abbrev
->die_tag
));
7892 if (abbrev
->die_child
!= NULL
)
7893 dw2_asm_output_data (1, DW_children_yes
, "DW_children_yes");
7895 dw2_asm_output_data (1, DW_children_no
, "DW_children_no");
7897 for (ix
= 0; VEC_iterate (dw_attr_node
, abbrev
->die_attr
, ix
, a_attr
);
7900 dw2_asm_output_data_uleb128 (a_attr
->dw_attr
, "(%s)",
7901 dwarf_attr_name (a_attr
->dw_attr
));
7902 output_value_format (a_attr
);
7905 dw2_asm_output_data (1, 0, NULL
);
7906 dw2_asm_output_data (1, 0, NULL
);
7909 /* Terminate the table. */
7910 dw2_asm_output_data (1, 0, NULL
);
7913 /* Output a symbol we can use to refer to this DIE from another CU. */
7916 output_die_symbol (dw_die_ref die
)
7918 char *sym
= die
->die_symbol
;
7923 if (strncmp (sym
, DIE_LABEL_PREFIX
, sizeof (DIE_LABEL_PREFIX
) - 1) == 0)
7924 /* We make these global, not weak; if the target doesn't support
7925 .linkonce, it doesn't support combining the sections, so debugging
7927 targetm
.asm_out
.globalize_label (asm_out_file
, sym
);
7929 ASM_OUTPUT_LABEL (asm_out_file
, sym
);
7932 /* Return a new location list, given the begin and end range, and the
7933 expression. gensym tells us whether to generate a new internal symbol for
7934 this location list node, which is done for the head of the list only. */
7936 static inline dw_loc_list_ref
7937 new_loc_list (dw_loc_descr_ref expr
, const char *begin
, const char *end
,
7938 const char *section
, unsigned int gensym
)
7940 dw_loc_list_ref retlist
= GGC_CNEW (dw_loc_list_node
);
7942 retlist
->begin
= begin
;
7944 retlist
->expr
= expr
;
7945 retlist
->section
= section
;
7947 retlist
->ll_symbol
= gen_internal_sym ("LLST");
7952 /* Add a location description expression to a location list. */
7955 add_loc_descr_to_loc_list (dw_loc_list_ref
*list_head
, dw_loc_descr_ref descr
,
7956 const char *begin
, const char *end
,
7957 const char *section
)
7961 /* Find the end of the chain. */
7962 for (d
= list_head
; (*d
) != NULL
; d
= &(*d
)->dw_loc_next
)
7965 /* Add a new location list node to the list. */
7966 *d
= new_loc_list (descr
, begin
, end
, section
, 0);
7969 /* Output the location list given to us. */
7972 output_loc_list (dw_loc_list_ref list_head
)
7974 dw_loc_list_ref curr
= list_head
;
7976 ASM_OUTPUT_LABEL (asm_out_file
, list_head
->ll_symbol
);
7978 /* Walk the location list, and output each range + expression. */
7979 for (curr
= list_head
; curr
!= NULL
; curr
= curr
->dw_loc_next
)
7982 /* Don't output an entry that starts and ends at the same address. */
7983 if (strcmp (curr
->begin
, curr
->end
) == 0)
7985 if (!have_multiple_function_sections
)
7987 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, curr
->begin
, curr
->section
,
7988 "Location list begin address (%s)",
7989 list_head
->ll_symbol
);
7990 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, curr
->end
, curr
->section
,
7991 "Location list end address (%s)",
7992 list_head
->ll_symbol
);
7996 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->begin
,
7997 "Location list begin address (%s)",
7998 list_head
->ll_symbol
);
7999 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->end
,
8000 "Location list end address (%s)",
8001 list_head
->ll_symbol
);
8003 size
= size_of_locs (curr
->expr
);
8005 /* Output the block length for this list of location operations. */
8006 gcc_assert (size
<= 0xffff);
8007 dw2_asm_output_data (2, size
, "%s", "Location expression size");
8009 output_loc_sequence (curr
->expr
);
8012 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0,
8013 "Location list terminator begin (%s)",
8014 list_head
->ll_symbol
);
8015 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0,
8016 "Location list terminator end (%s)",
8017 list_head
->ll_symbol
);
8020 /* Output the DIE and its attributes. Called recursively to generate
8021 the definitions of each child DIE. */
8024 output_die (dw_die_ref die
)
8031 /* If someone in another CU might refer to us, set up a symbol for
8032 them to point to. */
8033 if (die
->die_symbol
)
8034 output_die_symbol (die
);
8036 dw2_asm_output_data_uleb128 (die
->die_abbrev
, "(DIE (0x%lx) %s)",
8037 (unsigned long)die
->die_offset
,
8038 dwarf_tag_name (die
->die_tag
));
8040 for (ix
= 0; VEC_iterate (dw_attr_node
, die
->die_attr
, ix
, a
); ix
++)
8042 const char *name
= dwarf_attr_name (a
->dw_attr
);
8044 switch (AT_class (a
))
8046 case dw_val_class_addr
:
8047 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, AT_addr (a
), "%s", name
);
8050 case dw_val_class_offset
:
8051 dw2_asm_output_data (DWARF_OFFSET_SIZE
, a
->dw_attr_val
.v
.val_offset
,
8055 case dw_val_class_range_list
:
8057 char *p
= strchr (ranges_section_label
, '\0');
8059 sprintf (p
, "+" HOST_WIDE_INT_PRINT_HEX
,
8060 a
->dw_attr_val
.v
.val_offset
);
8061 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, ranges_section_label
,
8062 debug_ranges_section
, "%s", name
);
8067 case dw_val_class_loc
:
8068 size
= size_of_locs (AT_loc (a
));
8070 /* Output the block length for this list of location operations. */
8071 dw2_asm_output_data (constant_size (size
), size
, "%s", name
);
8073 output_loc_sequence (AT_loc (a
));
8076 case dw_val_class_const
:
8077 /* ??? It would be slightly more efficient to use a scheme like is
8078 used for unsigned constants below, but gdb 4.x does not sign
8079 extend. Gdb 5.x does sign extend. */
8080 dw2_asm_output_data_sleb128 (AT_int (a
), "%s", name
);
8083 case dw_val_class_unsigned_const
:
8084 dw2_asm_output_data (constant_size (AT_unsigned (a
)),
8085 AT_unsigned (a
), "%s", name
);
8088 case dw_val_class_long_long
:
8090 unsigned HOST_WIDE_INT first
, second
;
8092 dw2_asm_output_data (1,
8093 2 * HOST_BITS_PER_LONG
/ HOST_BITS_PER_CHAR
,
8096 if (WORDS_BIG_ENDIAN
)
8098 first
= a
->dw_attr_val
.v
.val_long_long
.hi
;
8099 second
= a
->dw_attr_val
.v
.val_long_long
.low
;
8103 first
= a
->dw_attr_val
.v
.val_long_long
.low
;
8104 second
= a
->dw_attr_val
.v
.val_long_long
.hi
;
8107 dw2_asm_output_data (HOST_BITS_PER_LONG
/ HOST_BITS_PER_CHAR
,
8108 first
, "long long constant");
8109 dw2_asm_output_data (HOST_BITS_PER_LONG
/ HOST_BITS_PER_CHAR
,
8114 case dw_val_class_vec
:
8116 unsigned int elt_size
= a
->dw_attr_val
.v
.val_vec
.elt_size
;
8117 unsigned int len
= a
->dw_attr_val
.v
.val_vec
.length
;
8121 dw2_asm_output_data (constant_size (len
* elt_size
),
8122 len
* elt_size
, "%s", name
);
8123 if (elt_size
> sizeof (HOST_WIDE_INT
))
8128 for (i
= 0, p
= a
->dw_attr_val
.v
.val_vec
.array
;
8131 dw2_asm_output_data (elt_size
, extract_int (p
, elt_size
),
8132 "fp or vector constant word %u", i
);
8136 case dw_val_class_flag
:
8137 dw2_asm_output_data (1, AT_flag (a
), "%s", name
);
8140 case dw_val_class_loc_list
:
8142 char *sym
= AT_loc_list (a
)->ll_symbol
;
8145 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, sym
, debug_loc_section
,
8150 case dw_val_class_die_ref
:
8151 if (AT_ref_external (a
))
8153 char *sym
= AT_ref (a
)->die_symbol
;
8156 dw2_asm_output_offset (DWARF2_ADDR_SIZE
, sym
, debug_info_section
,
8161 gcc_assert (AT_ref (a
)->die_offset
);
8162 dw2_asm_output_data (DWARF_OFFSET_SIZE
, AT_ref (a
)->die_offset
,
8167 case dw_val_class_fde_ref
:
8171 ASM_GENERATE_INTERNAL_LABEL (l1
, FDE_LABEL
,
8172 a
->dw_attr_val
.v
.val_fde_index
* 2);
8173 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, l1
, debug_frame_section
,
8178 case dw_val_class_lbl_id
:
8179 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, AT_lbl (a
), "%s", name
);
8182 case dw_val_class_lineptr
:
8183 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, AT_lbl (a
),
8184 debug_line_section
, "%s", name
);
8187 case dw_val_class_macptr
:
8188 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, AT_lbl (a
),
8189 debug_macinfo_section
, "%s", name
);
8192 case dw_val_class_str
:
8193 if (AT_string_form (a
) == DW_FORM_strp
)
8194 dw2_asm_output_offset (DWARF_OFFSET_SIZE
,
8195 a
->dw_attr_val
.v
.val_str
->label
,
8197 "%s: \"%s\"", name
, AT_string (a
));
8199 dw2_asm_output_nstring (AT_string (a
), -1, "%s", name
);
8202 case dw_val_class_file
:
8204 int f
= maybe_emit_file (a
->dw_attr_val
.v
.val_file
);
8206 dw2_asm_output_data (constant_size (f
), f
, "%s (%s)", name
,
8207 a
->dw_attr_val
.v
.val_file
->filename
);
8216 FOR_EACH_CHILD (die
, c
, output_die (c
));
8218 /* Add null byte to terminate sibling list. */
8219 if (die
->die_child
!= NULL
)
8220 dw2_asm_output_data (1, 0, "end of children of DIE 0x%lx",
8221 (unsigned long) die
->die_offset
);
8224 /* Output the compilation unit that appears at the beginning of the
8225 .debug_info section, and precedes the DIE descriptions. */
8228 output_compilation_unit_header (void)
8230 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
8231 dw2_asm_output_data (4, 0xffffffff,
8232 "Initial length escape value indicating 64-bit DWARF extension");
8233 dw2_asm_output_data (DWARF_OFFSET_SIZE
,
8234 next_die_offset
- DWARF_INITIAL_LENGTH_SIZE
,
8235 "Length of Compilation Unit Info");
8236 dw2_asm_output_data (2, DWARF_VERSION
, "DWARF version number");
8237 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, abbrev_section_label
,
8238 debug_abbrev_section
,
8239 "Offset Into Abbrev. Section");
8240 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Pointer Size (in bytes)");
8243 /* Output the compilation unit DIE and its children. */
8246 output_comp_unit (dw_die_ref die
, int output_if_empty
)
8248 const char *secname
;
8251 /* Unless we are outputting main CU, we may throw away empty ones. */
8252 if (!output_if_empty
&& die
->die_child
== NULL
)
8255 /* Even if there are no children of this DIE, we must output the information
8256 about the compilation unit. Otherwise, on an empty translation unit, we
8257 will generate a present, but empty, .debug_info section. IRIX 6.5 `nm'
8258 will then complain when examining the file. First mark all the DIEs in
8259 this CU so we know which get local refs. */
8262 build_abbrev_table (die
);
8264 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
8265 next_die_offset
= DWARF_COMPILE_UNIT_HEADER_SIZE
;
8266 calc_die_sizes (die
);
8268 oldsym
= die
->die_symbol
;
8271 tmp
= XALLOCAVEC (char, strlen (oldsym
) + 24);
8273 sprintf (tmp
, ".gnu.linkonce.wi.%s", oldsym
);
8275 die
->die_symbol
= NULL
;
8276 switch_to_section (get_section (secname
, SECTION_DEBUG
, NULL
));
8279 switch_to_section (debug_info_section
);
8281 /* Output debugging information. */
8282 output_compilation_unit_header ();
8285 /* Leave the marks on the main CU, so we can check them in
8290 die
->die_symbol
= oldsym
;
8294 /* Return the DWARF2/3 pubname associated with a decl. */
8297 dwarf2_name (tree decl
, int scope
)
8299 return lang_hooks
.dwarf_name (decl
, scope
? 1 : 0);
8302 /* Add a new entry to .debug_pubnames if appropriate. */
8305 add_pubname_string (const char *str
, dw_die_ref die
)
8310 e
.name
= xstrdup (str
);
8311 VEC_safe_push (pubname_entry
, gc
, pubname_table
, &e
);
8315 add_pubname (tree decl
, dw_die_ref die
)
8318 if (TREE_PUBLIC (decl
))
8319 add_pubname_string (dwarf2_name (decl
, 1), die
);
8322 /* Add a new entry to .debug_pubtypes if appropriate. */
8325 add_pubtype (tree decl
, dw_die_ref die
)
8330 if ((TREE_PUBLIC (decl
)
8331 || die
->die_parent
== comp_unit_die
)
8332 && (die
->die_tag
== DW_TAG_typedef
|| COMPLETE_TYPE_P (decl
)))
8337 if (TYPE_NAME (decl
))
8339 if (TREE_CODE (TYPE_NAME (decl
)) == IDENTIFIER_NODE
)
8340 e
.name
= IDENTIFIER_POINTER (TYPE_NAME (decl
));
8341 else if (TREE_CODE (TYPE_NAME (decl
)) == TYPE_DECL
8342 && DECL_NAME (TYPE_NAME (decl
)))
8343 e
.name
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (decl
)));
8345 e
.name
= xstrdup ((const char *) get_AT_string (die
, DW_AT_name
));
8349 e
.name
= xstrdup (dwarf2_name (decl
, 1));
8351 /* If we don't have a name for the type, there's no point in adding
8353 if (e
.name
&& e
.name
[0] != '\0')
8354 VEC_safe_push (pubname_entry
, gc
, pubtype_table
, &e
);
8358 /* Output the public names table used to speed up access to externally
8359 visible names; or the public types table used to find type definitions. */
8362 output_pubnames (VEC (pubname_entry
, gc
) * names
)
8365 unsigned long pubnames_length
= size_of_pubnames (names
);
8368 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
8369 dw2_asm_output_data (4, 0xffffffff,
8370 "Initial length escape value indicating 64-bit DWARF extension");
8371 if (names
== pubname_table
)
8372 dw2_asm_output_data (DWARF_OFFSET_SIZE
, pubnames_length
,
8373 "Length of Public Names Info");
8375 dw2_asm_output_data (DWARF_OFFSET_SIZE
, pubnames_length
,
8376 "Length of Public Type Names Info");
8377 dw2_asm_output_data (2, DWARF_VERSION
, "DWARF Version");
8378 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_info_section_label
,
8380 "Offset of Compilation Unit Info");
8381 dw2_asm_output_data (DWARF_OFFSET_SIZE
, next_die_offset
,
8382 "Compilation Unit Length");
8384 for (i
= 0; VEC_iterate (pubname_entry
, names
, i
, pub
); i
++)
8386 /* We shouldn't see pubnames for DIEs outside of the main CU. */
8387 if (names
== pubname_table
)
8388 gcc_assert (pub
->die
->die_mark
);
8390 if (names
!= pubtype_table
8391 || pub
->die
->die_offset
!= 0
8392 || !flag_eliminate_unused_debug_types
)
8394 dw2_asm_output_data (DWARF_OFFSET_SIZE
, pub
->die
->die_offset
,
8397 dw2_asm_output_nstring (pub
->name
, -1, "external name");
8401 dw2_asm_output_data (DWARF_OFFSET_SIZE
, 0, NULL
);
8404 /* Add a new entry to .debug_aranges if appropriate. */
8407 add_arange (tree decl
, dw_die_ref die
)
8409 if (! DECL_SECTION_NAME (decl
))
8412 if (arange_table_in_use
== arange_table_allocated
)
8414 arange_table_allocated
+= ARANGE_TABLE_INCREMENT
;
8415 arange_table
= GGC_RESIZEVEC (dw_die_ref
, arange_table
,
8416 arange_table_allocated
);
8417 memset (arange_table
+ arange_table_in_use
, 0,
8418 ARANGE_TABLE_INCREMENT
* sizeof (dw_die_ref
));
8421 arange_table
[arange_table_in_use
++] = die
;
8424 /* Output the information that goes into the .debug_aranges table.
8425 Namely, define the beginning and ending address range of the
8426 text section generated for this compilation unit. */
8429 output_aranges (void)
8432 unsigned long aranges_length
= size_of_aranges ();
8434 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
8435 dw2_asm_output_data (4, 0xffffffff,
8436 "Initial length escape value indicating 64-bit DWARF extension");
8437 dw2_asm_output_data (DWARF_OFFSET_SIZE
, aranges_length
,
8438 "Length of Address Ranges Info");
8439 dw2_asm_output_data (2, DWARF_VERSION
, "DWARF Version");
8440 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_info_section_label
,
8442 "Offset of Compilation Unit Info");
8443 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Size of Address");
8444 dw2_asm_output_data (1, 0, "Size of Segment Descriptor");
8446 /* We need to align to twice the pointer size here. */
8447 if (DWARF_ARANGES_PAD_SIZE
)
8449 /* Pad using a 2 byte words so that padding is correct for any
8451 dw2_asm_output_data (2, 0, "Pad to %d byte boundary",
8452 2 * DWARF2_ADDR_SIZE
);
8453 for (i
= 2; i
< (unsigned) DWARF_ARANGES_PAD_SIZE
; i
+= 2)
8454 dw2_asm_output_data (2, 0, NULL
);
8457 /* It is necessary not to output these entries if the sections were
8458 not used; if the sections were not used, the length will be 0 and
8459 the address may end up as 0 if the section is discarded by ld
8460 --gc-sections, leaving an invalid (0, 0) entry that can be
8461 confused with the terminator. */
8462 if (text_section_used
)
8464 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, text_section_label
, "Address");
8465 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, text_end_label
,
8466 text_section_label
, "Length");
8468 if (cold_text_section_used
)
8470 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, cold_text_section_label
,
8472 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, cold_end_label
,
8473 cold_text_section_label
, "Length");
8476 for (i
= 0; i
< arange_table_in_use
; i
++)
8478 dw_die_ref die
= arange_table
[i
];
8480 /* We shouldn't see aranges for DIEs outside of the main CU. */
8481 gcc_assert (die
->die_mark
);
8483 if (die
->die_tag
== DW_TAG_subprogram
)
8485 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, get_AT_low_pc (die
),
8487 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, get_AT_hi_pc (die
),
8488 get_AT_low_pc (die
), "Length");
8492 /* A static variable; extract the symbol from DW_AT_location.
8493 Note that this code isn't currently hit, as we only emit
8494 aranges for functions (jason 9/23/99). */
8495 dw_attr_ref a
= get_AT (die
, DW_AT_location
);
8496 dw_loc_descr_ref loc
;
8498 gcc_assert (a
&& AT_class (a
) == dw_val_class_loc
);
8501 gcc_assert (loc
->dw_loc_opc
== DW_OP_addr
);
8503 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
,
8504 loc
->dw_loc_oprnd1
.v
.val_addr
, "Address");
8505 dw2_asm_output_data (DWARF2_ADDR_SIZE
,
8506 get_AT_unsigned (die
, DW_AT_byte_size
),
8511 /* Output the terminator words. */
8512 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
8513 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
8516 /* Add a new entry to .debug_ranges. Return the offset at which it
8520 add_ranges_num (int num
)
8522 unsigned int in_use
= ranges_table_in_use
;
8524 if (in_use
== ranges_table_allocated
)
8526 ranges_table_allocated
+= RANGES_TABLE_INCREMENT
;
8527 ranges_table
= GGC_RESIZEVEC (struct dw_ranges_struct
, ranges_table
,
8528 ranges_table_allocated
);
8529 memset (ranges_table
+ ranges_table_in_use
, 0,
8530 RANGES_TABLE_INCREMENT
* sizeof (struct dw_ranges_struct
));
8533 ranges_table
[in_use
].num
= num
;
8534 ranges_table_in_use
= in_use
+ 1;
8536 return in_use
* 2 * DWARF2_ADDR_SIZE
;
8539 /* Add a new entry to .debug_ranges corresponding to a block, or a
8540 range terminator if BLOCK is NULL. */
8543 add_ranges (const_tree block
)
8545 return add_ranges_num (block
? BLOCK_NUMBER (block
) : 0);
8548 /* Add a new entry to .debug_ranges corresponding to a pair of
8552 add_ranges_by_labels (const char *begin
, const char *end
)
8554 unsigned int in_use
= ranges_by_label_in_use
;
8556 if (in_use
== ranges_by_label_allocated
)
8558 ranges_by_label_allocated
+= RANGES_TABLE_INCREMENT
;
8559 ranges_by_label
= GGC_RESIZEVEC (struct dw_ranges_by_label_struct
,
8561 ranges_by_label_allocated
);
8562 memset (ranges_by_label
+ ranges_by_label_in_use
, 0,
8563 RANGES_TABLE_INCREMENT
8564 * sizeof (struct dw_ranges_by_label_struct
));
8567 ranges_by_label
[in_use
].begin
= begin
;
8568 ranges_by_label
[in_use
].end
= end
;
8569 ranges_by_label_in_use
= in_use
+ 1;
8571 return add_ranges_num (-(int)in_use
- 1);
8575 output_ranges (void)
8578 static const char *const start_fmt
= "Offset 0x%x";
8579 const char *fmt
= start_fmt
;
8581 for (i
= 0; i
< ranges_table_in_use
; i
++)
8583 int block_num
= ranges_table
[i
].num
;
8587 char blabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
8588 char elabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
8590 ASM_GENERATE_INTERNAL_LABEL (blabel
, BLOCK_BEGIN_LABEL
, block_num
);
8591 ASM_GENERATE_INTERNAL_LABEL (elabel
, BLOCK_END_LABEL
, block_num
);
8593 /* If all code is in the text section, then the compilation
8594 unit base address defaults to DW_AT_low_pc, which is the
8595 base of the text section. */
8596 if (!have_multiple_function_sections
)
8598 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, blabel
,
8600 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
8601 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, elabel
,
8602 text_section_label
, NULL
);
8605 /* Otherwise, the compilation unit base address is zero,
8606 which allows us to use absolute addresses, and not worry
8607 about whether the target supports cross-section
8611 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
8612 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
8613 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, elabel
, NULL
);
8619 /* Negative block_num stands for an index into ranges_by_label. */
8620 else if (block_num
< 0)
8622 int lab_idx
= - block_num
- 1;
8624 if (!have_multiple_function_sections
)
8628 /* If we ever use add_ranges_by_labels () for a single
8629 function section, all we have to do is to take out
8631 dw2_asm_output_delta (DWARF2_ADDR_SIZE
,
8632 ranges_by_label
[lab_idx
].begin
,
8634 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
8635 dw2_asm_output_delta (DWARF2_ADDR_SIZE
,
8636 ranges_by_label
[lab_idx
].end
,
8637 text_section_label
, NULL
);
8642 dw2_asm_output_addr (DWARF2_ADDR_SIZE
,
8643 ranges_by_label
[lab_idx
].begin
,
8644 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
8645 dw2_asm_output_addr (DWARF2_ADDR_SIZE
,
8646 ranges_by_label
[lab_idx
].end
,
8652 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
8653 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
8659 /* Data structure containing information about input files. */
8662 const char *path
; /* Complete file name. */
8663 const char *fname
; /* File name part. */
8664 int length
; /* Length of entire string. */
8665 struct dwarf_file_data
* file_idx
; /* Index in input file table. */
8666 int dir_idx
; /* Index in directory table. */
8669 /* Data structure containing information about directories with source
8673 const char *path
; /* Path including directory name. */
8674 int length
; /* Path length. */
8675 int prefix
; /* Index of directory entry which is a prefix. */
8676 int count
; /* Number of files in this directory. */
8677 int dir_idx
; /* Index of directory used as base. */
8680 /* Callback function for file_info comparison. We sort by looking at
8681 the directories in the path. */
8684 file_info_cmp (const void *p1
, const void *p2
)
8686 const struct file_info
*const s1
= (const struct file_info
*) p1
;
8687 const struct file_info
*const s2
= (const struct file_info
*) p2
;
8688 const unsigned char *cp1
;
8689 const unsigned char *cp2
;
8691 /* Take care of file names without directories. We need to make sure that
8692 we return consistent values to qsort since some will get confused if
8693 we return the same value when identical operands are passed in opposite
8694 orders. So if neither has a directory, return 0 and otherwise return
8695 1 or -1 depending on which one has the directory. */
8696 if ((s1
->path
== s1
->fname
|| s2
->path
== s2
->fname
))
8697 return (s2
->path
== s2
->fname
) - (s1
->path
== s1
->fname
);
8699 cp1
= (const unsigned char *) s1
->path
;
8700 cp2
= (const unsigned char *) s2
->path
;
8706 /* Reached the end of the first path? If so, handle like above. */
8707 if ((cp1
== (const unsigned char *) s1
->fname
)
8708 || (cp2
== (const unsigned char *) s2
->fname
))
8709 return ((cp2
== (const unsigned char *) s2
->fname
)
8710 - (cp1
== (const unsigned char *) s1
->fname
));
8712 /* Character of current path component the same? */
8713 else if (*cp1
!= *cp2
)
8718 struct file_name_acquire_data
8720 struct file_info
*files
;
8725 /* Traversal function for the hash table. */
8728 file_name_acquire (void ** slot
, void *data
)
8730 struct file_name_acquire_data
*fnad
= (struct file_name_acquire_data
*) data
;
8731 struct dwarf_file_data
*d
= (struct dwarf_file_data
*) *slot
;
8732 struct file_info
*fi
;
8735 gcc_assert (fnad
->max_files
>= d
->emitted_number
);
8737 if (! d
->emitted_number
)
8740 gcc_assert (fnad
->max_files
!= fnad
->used_files
);
8742 fi
= fnad
->files
+ fnad
->used_files
++;
8744 /* Skip all leading "./". */
8746 while (f
[0] == '.' && IS_DIR_SEPARATOR (f
[1]))
8749 /* Create a new array entry. */
8751 fi
->length
= strlen (f
);
8754 /* Search for the file name part. */
8755 f
= strrchr (f
, DIR_SEPARATOR
);
8756 #if defined (DIR_SEPARATOR_2)
8758 char *g
= strrchr (fi
->path
, DIR_SEPARATOR_2
);
8762 if (f
== NULL
|| f
< g
)
8768 fi
->fname
= f
== NULL
? fi
->path
: f
+ 1;
8772 /* Output the directory table and the file name table. We try to minimize
8773 the total amount of memory needed. A heuristic is used to avoid large
8774 slowdowns with many input files. */
8777 output_file_names (void)
8779 struct file_name_acquire_data fnad
;
8781 struct file_info
*files
;
8782 struct dir_info
*dirs
;
8791 if (!last_emitted_file
)
8793 dw2_asm_output_data (1, 0, "End directory table");
8794 dw2_asm_output_data (1, 0, "End file name table");
8798 numfiles
= last_emitted_file
->emitted_number
;
8800 /* Allocate the various arrays we need. */
8801 files
= XALLOCAVEC (struct file_info
, numfiles
);
8802 dirs
= XALLOCAVEC (struct dir_info
, numfiles
);
8805 fnad
.used_files
= 0;
8806 fnad
.max_files
= numfiles
;
8807 htab_traverse (file_table
, file_name_acquire
, &fnad
);
8808 gcc_assert (fnad
.used_files
== fnad
.max_files
);
8810 qsort (files
, numfiles
, sizeof (files
[0]), file_info_cmp
);
8812 /* Find all the different directories used. */
8813 dirs
[0].path
= files
[0].path
;
8814 dirs
[0].length
= files
[0].fname
- files
[0].path
;
8815 dirs
[0].prefix
= -1;
8817 dirs
[0].dir_idx
= 0;
8818 files
[0].dir_idx
= 0;
8821 for (i
= 1; i
< numfiles
; i
++)
8822 if (files
[i
].fname
- files
[i
].path
== dirs
[ndirs
- 1].length
8823 && memcmp (dirs
[ndirs
- 1].path
, files
[i
].path
,
8824 dirs
[ndirs
- 1].length
) == 0)
8826 /* Same directory as last entry. */
8827 files
[i
].dir_idx
= ndirs
- 1;
8828 ++dirs
[ndirs
- 1].count
;
8834 /* This is a new directory. */
8835 dirs
[ndirs
].path
= files
[i
].path
;
8836 dirs
[ndirs
].length
= files
[i
].fname
- files
[i
].path
;
8837 dirs
[ndirs
].count
= 1;
8838 dirs
[ndirs
].dir_idx
= ndirs
;
8839 files
[i
].dir_idx
= ndirs
;
8841 /* Search for a prefix. */
8842 dirs
[ndirs
].prefix
= -1;
8843 for (j
= 0; j
< ndirs
; j
++)
8844 if (dirs
[j
].length
< dirs
[ndirs
].length
8845 && dirs
[j
].length
> 1
8846 && (dirs
[ndirs
].prefix
== -1
8847 || dirs
[j
].length
> dirs
[dirs
[ndirs
].prefix
].length
)
8848 && memcmp (dirs
[j
].path
, dirs
[ndirs
].path
, dirs
[j
].length
) == 0)
8849 dirs
[ndirs
].prefix
= j
;
8854 /* Now to the actual work. We have to find a subset of the directories which
8855 allow expressing the file name using references to the directory table
8856 with the least amount of characters. We do not do an exhaustive search
8857 where we would have to check out every combination of every single
8858 possible prefix. Instead we use a heuristic which provides nearly optimal
8859 results in most cases and never is much off. */
8860 saved
= XALLOCAVEC (int, ndirs
);
8861 savehere
= XALLOCAVEC (int, ndirs
);
8863 memset (saved
, '\0', ndirs
* sizeof (saved
[0]));
8864 for (i
= 0; i
< ndirs
; i
++)
8869 /* We can always save some space for the current directory. But this
8870 does not mean it will be enough to justify adding the directory. */
8871 savehere
[i
] = dirs
[i
].length
;
8872 total
= (savehere
[i
] - saved
[i
]) * dirs
[i
].count
;
8874 for (j
= i
+ 1; j
< ndirs
; j
++)
8877 if (saved
[j
] < dirs
[i
].length
)
8879 /* Determine whether the dirs[i] path is a prefix of the
8884 while (k
!= -1 && k
!= (int) i
)
8889 /* Yes it is. We can possibly save some memory by
8890 writing the filenames in dirs[j] relative to
8892 savehere
[j
] = dirs
[i
].length
;
8893 total
+= (savehere
[j
] - saved
[j
]) * dirs
[j
].count
;
8898 /* Check whether we can save enough to justify adding the dirs[i]
8900 if (total
> dirs
[i
].length
+ 1)
8902 /* It's worthwhile adding. */
8903 for (j
= i
; j
< ndirs
; j
++)
8904 if (savehere
[j
] > 0)
8906 /* Remember how much we saved for this directory so far. */
8907 saved
[j
] = savehere
[j
];
8909 /* Remember the prefix directory. */
8910 dirs
[j
].dir_idx
= i
;
8915 /* Emit the directory name table. */
8917 idx_offset
= dirs
[0].length
> 0 ? 1 : 0;
8918 for (i
= 1 - idx_offset
; i
< ndirs
; i
++)
8919 dw2_asm_output_nstring (dirs
[i
].path
, dirs
[i
].length
- 1,
8920 "Directory Entry: 0x%x", i
+ idx_offset
);
8922 dw2_asm_output_data (1, 0, "End directory table");
8924 /* We have to emit them in the order of emitted_number since that's
8925 used in the debug info generation. To do this efficiently we
8926 generate a back-mapping of the indices first. */
8927 backmap
= XALLOCAVEC (int, numfiles
);
8928 for (i
= 0; i
< numfiles
; i
++)
8929 backmap
[files
[i
].file_idx
->emitted_number
- 1] = i
;
8931 /* Now write all the file names. */
8932 for (i
= 0; i
< numfiles
; i
++)
8934 int file_idx
= backmap
[i
];
8935 int dir_idx
= dirs
[files
[file_idx
].dir_idx
].dir_idx
;
8937 dw2_asm_output_nstring (files
[file_idx
].path
+ dirs
[dir_idx
].length
, -1,
8938 "File Entry: 0x%x", (unsigned) i
+ 1);
8940 /* Include directory index. */
8941 dw2_asm_output_data_uleb128 (dir_idx
+ idx_offset
, NULL
);
8943 /* Modification time. */
8944 dw2_asm_output_data_uleb128 (0, NULL
);
8946 /* File length in bytes. */
8947 dw2_asm_output_data_uleb128 (0, NULL
);
8950 dw2_asm_output_data (1, 0, "End file name table");
8954 /* Output the source line number correspondence information. This
8955 information goes into the .debug_line section. */
8958 output_line_info (void)
8960 char l1
[20], l2
[20], p1
[20], p2
[20];
8961 char line_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
8962 char prev_line_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
8965 unsigned long lt_index
;
8966 unsigned long current_line
;
8969 unsigned long current_file
;
8970 unsigned long function
;
8972 ASM_GENERATE_INTERNAL_LABEL (l1
, LINE_NUMBER_BEGIN_LABEL
, 0);
8973 ASM_GENERATE_INTERNAL_LABEL (l2
, LINE_NUMBER_END_LABEL
, 0);
8974 ASM_GENERATE_INTERNAL_LABEL (p1
, LN_PROLOG_AS_LABEL
, 0);
8975 ASM_GENERATE_INTERNAL_LABEL (p2
, LN_PROLOG_END_LABEL
, 0);
8977 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
8978 dw2_asm_output_data (4, 0xffffffff,
8979 "Initial length escape value indicating 64-bit DWARF extension");
8980 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, l2
, l1
,
8981 "Length of Source Line Info");
8982 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
8984 dw2_asm_output_data (2, DWARF_VERSION
, "DWARF Version");
8985 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, p2
, p1
, "Prolog Length");
8986 ASM_OUTPUT_LABEL (asm_out_file
, p1
);
8988 /* Define the architecture-dependent minimum instruction length (in
8989 bytes). In this implementation of DWARF, this field is used for
8990 information purposes only. Since GCC generates assembly language,
8991 we have no a priori knowledge of how many instruction bytes are
8992 generated for each source line, and therefore can use only the
8993 DW_LNE_set_address and DW_LNS_fixed_advance_pc line information
8994 commands. Accordingly, we fix this as `1', which is "correct
8995 enough" for all architectures, and don't let the target override. */
8996 dw2_asm_output_data (1, 1,
8997 "Minimum Instruction Length");
8999 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START
,
9000 "Default is_stmt_start flag");
9001 dw2_asm_output_data (1, DWARF_LINE_BASE
,
9002 "Line Base Value (Special Opcodes)");
9003 dw2_asm_output_data (1, DWARF_LINE_RANGE
,
9004 "Line Range Value (Special Opcodes)");
9005 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE
,
9006 "Special Opcode Base");
9008 for (opc
= 1; opc
< DWARF_LINE_OPCODE_BASE
; opc
++)
9012 case DW_LNS_advance_pc
:
9013 case DW_LNS_advance_line
:
9014 case DW_LNS_set_file
:
9015 case DW_LNS_set_column
:
9016 case DW_LNS_fixed_advance_pc
:
9024 dw2_asm_output_data (1, n_op_args
, "opcode: 0x%x has %d args",
9028 /* Write out the information about the files we use. */
9029 output_file_names ();
9030 ASM_OUTPUT_LABEL (asm_out_file
, p2
);
9032 /* We used to set the address register to the first location in the text
9033 section here, but that didn't accomplish anything since we already
9034 have a line note for the opening brace of the first function. */
9036 /* Generate the line number to PC correspondence table, encoded as
9037 a series of state machine operations. */
9041 if (cfun
&& in_cold_section_p
)
9042 strcpy (prev_line_label
, crtl
->subsections
.cold_section_label
);
9044 strcpy (prev_line_label
, text_section_label
);
9045 for (lt_index
= 1; lt_index
< line_info_table_in_use
; ++lt_index
)
9047 dw_line_info_ref line_info
= &line_info_table
[lt_index
];
9050 /* Disable this optimization for now; GDB wants to see two line notes
9051 at the beginning of a function so it can find the end of the
9054 /* Don't emit anything for redundant notes. Just updating the
9055 address doesn't accomplish anything, because we already assume
9056 that anything after the last address is this line. */
9057 if (line_info
->dw_line_num
== current_line
9058 && line_info
->dw_file_num
== current_file
)
9062 /* Emit debug info for the address of the current line.
9064 Unfortunately, we have little choice here currently, and must always
9065 use the most general form. GCC does not know the address delta
9066 itself, so we can't use DW_LNS_advance_pc. Many ports do have length
9067 attributes which will give an upper bound on the address range. We
9068 could perhaps use length attributes to determine when it is safe to
9069 use DW_LNS_fixed_advance_pc. */
9071 ASM_GENERATE_INTERNAL_LABEL (line_label
, LINE_CODE_LABEL
, lt_index
);
9074 /* This can handle deltas up to 0xffff. This takes 3 bytes. */
9075 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc
,
9076 "DW_LNS_fixed_advance_pc");
9077 dw2_asm_output_delta (2, line_label
, prev_line_label
, NULL
);
9081 /* This can handle any delta. This takes
9082 4+DWARF2_ADDR_SIZE bytes. */
9083 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
9084 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE
, NULL
);
9085 dw2_asm_output_data (1, DW_LNE_set_address
, NULL
);
9086 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, line_label
, NULL
);
9089 strcpy (prev_line_label
, line_label
);
9091 /* Emit debug info for the source file of the current line, if
9092 different from the previous line. */
9093 if (line_info
->dw_file_num
!= current_file
)
9095 current_file
= line_info
->dw_file_num
;
9096 dw2_asm_output_data (1, DW_LNS_set_file
, "DW_LNS_set_file");
9097 dw2_asm_output_data_uleb128 (current_file
, "%lu", current_file
);
9100 /* Emit debug info for the current line number, choosing the encoding
9101 that uses the least amount of space. */
9102 if (line_info
->dw_line_num
!= current_line
)
9104 line_offset
= line_info
->dw_line_num
- current_line
;
9105 line_delta
= line_offset
- DWARF_LINE_BASE
;
9106 current_line
= line_info
->dw_line_num
;
9107 if (line_delta
>= 0 && line_delta
< (DWARF_LINE_RANGE
- 1))
9108 /* This can handle deltas from -10 to 234, using the current
9109 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE. This
9111 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE
+ line_delta
,
9112 "line %lu", current_line
);
9115 /* This can handle any delta. This takes at least 4 bytes,
9116 depending on the value being encoded. */
9117 dw2_asm_output_data (1, DW_LNS_advance_line
,
9118 "advance to line %lu", current_line
);
9119 dw2_asm_output_data_sleb128 (line_offset
, NULL
);
9120 dw2_asm_output_data (1, DW_LNS_copy
, "DW_LNS_copy");
9124 /* We still need to start a new row, so output a copy insn. */
9125 dw2_asm_output_data (1, DW_LNS_copy
, "DW_LNS_copy");
9128 /* Emit debug info for the address of the end of the function. */
9131 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc
,
9132 "DW_LNS_fixed_advance_pc");
9133 dw2_asm_output_delta (2, text_end_label
, prev_line_label
, NULL
);
9137 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
9138 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE
, NULL
);
9139 dw2_asm_output_data (1, DW_LNE_set_address
, NULL
);
9140 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, text_end_label
, NULL
);
9143 dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
9144 dw2_asm_output_data_uleb128 (1, NULL
);
9145 dw2_asm_output_data (1, DW_LNE_end_sequence
, NULL
);
9150 for (lt_index
= 0; lt_index
< separate_line_info_table_in_use
;)
9152 dw_separate_line_info_ref line_info
9153 = &separate_line_info_table
[lt_index
];
9156 /* Don't emit anything for redundant notes. */
9157 if (line_info
->dw_line_num
== current_line
9158 && line_info
->dw_file_num
== current_file
9159 && line_info
->function
== function
)
9163 /* Emit debug info for the address of the current line. If this is
9164 a new function, or the first line of a function, then we need
9165 to handle it differently. */
9166 ASM_GENERATE_INTERNAL_LABEL (line_label
, SEPARATE_LINE_CODE_LABEL
,
9168 if (function
!= line_info
->function
)
9170 function
= line_info
->function
;
9172 /* Set the address register to the first line in the function. */
9173 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
9174 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE
, NULL
);
9175 dw2_asm_output_data (1, DW_LNE_set_address
, NULL
);
9176 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, line_label
, NULL
);
9180 /* ??? See the DW_LNS_advance_pc comment above. */
9183 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc
,
9184 "DW_LNS_fixed_advance_pc");
9185 dw2_asm_output_delta (2, line_label
, prev_line_label
, NULL
);
9189 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
9190 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE
, NULL
);
9191 dw2_asm_output_data (1, DW_LNE_set_address
, NULL
);
9192 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, line_label
, NULL
);
9196 strcpy (prev_line_label
, line_label
);
9198 /* Emit debug info for the source file of the current line, if
9199 different from the previous line. */
9200 if (line_info
->dw_file_num
!= current_file
)
9202 current_file
= line_info
->dw_file_num
;
9203 dw2_asm_output_data (1, DW_LNS_set_file
, "DW_LNS_set_file");
9204 dw2_asm_output_data_uleb128 (current_file
, "%lu", current_file
);
9207 /* Emit debug info for the current line number, choosing the encoding
9208 that uses the least amount of space. */
9209 if (line_info
->dw_line_num
!= current_line
)
9211 line_offset
= line_info
->dw_line_num
- current_line
;
9212 line_delta
= line_offset
- DWARF_LINE_BASE
;
9213 current_line
= line_info
->dw_line_num
;
9214 if (line_delta
>= 0 && line_delta
< (DWARF_LINE_RANGE
- 1))
9215 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE
+ line_delta
,
9216 "line %lu", current_line
);
9219 dw2_asm_output_data (1, DW_LNS_advance_line
,
9220 "advance to line %lu", current_line
);
9221 dw2_asm_output_data_sleb128 (line_offset
, NULL
);
9222 dw2_asm_output_data (1, DW_LNS_copy
, "DW_LNS_copy");
9226 dw2_asm_output_data (1, DW_LNS_copy
, "DW_LNS_copy");
9234 /* If we're done with a function, end its sequence. */
9235 if (lt_index
== separate_line_info_table_in_use
9236 || separate_line_info_table
[lt_index
].function
!= function
)
9241 /* Emit debug info for the address of the end of the function. */
9242 ASM_GENERATE_INTERNAL_LABEL (line_label
, FUNC_END_LABEL
, function
);
9245 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc
,
9246 "DW_LNS_fixed_advance_pc");
9247 dw2_asm_output_delta (2, line_label
, prev_line_label
, NULL
);
9251 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
9252 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE
, NULL
);
9253 dw2_asm_output_data (1, DW_LNE_set_address
, NULL
);
9254 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, line_label
, NULL
);
9257 /* Output the marker for the end of this sequence. */
9258 dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
9259 dw2_asm_output_data_uleb128 (1, NULL
);
9260 dw2_asm_output_data (1, DW_LNE_end_sequence
, NULL
);
9264 /* Output the marker for the end of the line number info. */
9265 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
9268 /* Given a pointer to a tree node for some base type, return a pointer to
9269 a DIE that describes the given type.
9271 This routine must only be called for GCC type nodes that correspond to
9272 Dwarf base (fundamental) types. */
9275 base_type_die (tree type
)
9277 dw_die_ref base_type_result
;
9278 enum dwarf_type encoding
;
9280 if (TREE_CODE (type
) == ERROR_MARK
|| TREE_CODE (type
) == VOID_TYPE
)
9283 switch (TREE_CODE (type
))
9286 if (TYPE_STRING_FLAG (type
))
9288 if (TYPE_UNSIGNED (type
))
9289 encoding
= DW_ATE_unsigned_char
;
9291 encoding
= DW_ATE_signed_char
;
9293 else if (TYPE_UNSIGNED (type
))
9294 encoding
= DW_ATE_unsigned
;
9296 encoding
= DW_ATE_signed
;
9300 if (DECIMAL_FLOAT_MODE_P (TYPE_MODE (type
)))
9301 encoding
= DW_ATE_decimal_float
;
9303 encoding
= DW_ATE_float
;
9306 case FIXED_POINT_TYPE
:
9307 if (TYPE_UNSIGNED (type
))
9308 encoding
= DW_ATE_unsigned_fixed
;
9310 encoding
= DW_ATE_signed_fixed
;
9313 /* Dwarf2 doesn't know anything about complex ints, so use
9314 a user defined type for it. */
9316 if (TREE_CODE (TREE_TYPE (type
)) == REAL_TYPE
)
9317 encoding
= DW_ATE_complex_float
;
9319 encoding
= DW_ATE_lo_user
;
9323 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */
9324 encoding
= DW_ATE_boolean
;
9328 /* No other TREE_CODEs are Dwarf fundamental types. */
9332 base_type_result
= new_die (DW_TAG_base_type
, comp_unit_die
, type
);
9334 /* This probably indicates a bug. */
9335 if (! TYPE_NAME (type
))
9336 add_name_attribute (base_type_result
, "__unknown__");
9338 add_AT_unsigned (base_type_result
, DW_AT_byte_size
,
9339 int_size_in_bytes (type
));
9340 add_AT_unsigned (base_type_result
, DW_AT_encoding
, encoding
);
9342 return base_type_result
;
9345 /* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the
9346 given input type is a Dwarf "fundamental" type. Otherwise return null. */
9349 is_base_type (tree type
)
9351 switch (TREE_CODE (type
))
9357 case FIXED_POINT_TYPE
:
9365 case QUAL_UNION_TYPE
:
9370 case REFERENCE_TYPE
:
9383 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
9384 node, return the size in bits for the type if it is a constant, or else
9385 return the alignment for the type if the type's size is not constant, or
9386 else return BITS_PER_WORD if the type actually turns out to be an
9389 static inline unsigned HOST_WIDE_INT
9390 simple_type_size_in_bits (const_tree type
)
9392 if (TREE_CODE (type
) == ERROR_MARK
)
9393 return BITS_PER_WORD
;
9394 else if (TYPE_SIZE (type
) == NULL_TREE
)
9396 else if (host_integerp (TYPE_SIZE (type
), 1))
9397 return tree_low_cst (TYPE_SIZE (type
), 1);
9399 return TYPE_ALIGN (type
);
9402 /* Return true if the debug information for the given type should be
9403 emitted as a subrange type. */
9406 is_subrange_type (const_tree type
)
9408 tree subtype
= TREE_TYPE (type
);
9410 /* Subrange types are identified by the fact that they are integer
9411 types, and that they have a subtype which is either an integer type
9412 or an enumeral type. */
9414 if (TREE_CODE (type
) != INTEGER_TYPE
9415 || subtype
== NULL_TREE
)
9418 if (TREE_CODE (subtype
) != INTEGER_TYPE
9419 && TREE_CODE (subtype
) != ENUMERAL_TYPE
9420 && TREE_CODE (subtype
) != BOOLEAN_TYPE
)
9423 if (TREE_CODE (type
) == TREE_CODE (subtype
)
9424 && int_size_in_bytes (type
) == int_size_in_bytes (subtype
)
9425 && TYPE_MIN_VALUE (type
) != NULL
9426 && TYPE_MIN_VALUE (subtype
) != NULL
9427 && tree_int_cst_equal (TYPE_MIN_VALUE (type
), TYPE_MIN_VALUE (subtype
))
9428 && TYPE_MAX_VALUE (type
) != NULL
9429 && TYPE_MAX_VALUE (subtype
) != NULL
9430 && tree_int_cst_equal (TYPE_MAX_VALUE (type
), TYPE_MAX_VALUE (subtype
)))
9432 /* The type and its subtype have the same representation. If in
9433 addition the two types also have the same name, then the given
9434 type is not a subrange type, but rather a plain base type. */
9435 /* FIXME: brobecker/2004-03-22:
9436 Sizetype INTEGER_CSTs nodes are canonicalized. It should
9437 therefore be sufficient to check the TYPE_SIZE node pointers
9438 rather than checking the actual size. Unfortunately, we have
9439 found some cases, such as in the Ada "integer" type, where
9440 this is not the case. Until this problem is solved, we need to
9441 keep checking the actual size. */
9442 tree type_name
= TYPE_NAME (type
);
9443 tree subtype_name
= TYPE_NAME (subtype
);
9445 if (type_name
!= NULL
&& TREE_CODE (type_name
) == TYPE_DECL
)
9446 type_name
= DECL_NAME (type_name
);
9448 if (subtype_name
!= NULL
&& TREE_CODE (subtype_name
) == TYPE_DECL
)
9449 subtype_name
= DECL_NAME (subtype_name
);
9451 if (type_name
== subtype_name
)
9458 /* Given a pointer to a tree node for a subrange type, return a pointer
9459 to a DIE that describes the given type. */
9462 subrange_type_die (tree type
, dw_die_ref context_die
)
9464 dw_die_ref subrange_die
;
9465 const HOST_WIDE_INT size_in_bytes
= int_size_in_bytes (type
);
9467 if (context_die
== NULL
)
9468 context_die
= comp_unit_die
;
9470 subrange_die
= new_die (DW_TAG_subrange_type
, context_die
, type
);
9472 if (int_size_in_bytes (TREE_TYPE (type
)) != size_in_bytes
)
9474 /* The size of the subrange type and its base type do not match,
9475 so we need to generate a size attribute for the subrange type. */
9476 add_AT_unsigned (subrange_die
, DW_AT_byte_size
, size_in_bytes
);
9479 if (TYPE_MIN_VALUE (type
) != NULL
)
9480 add_bound_info (subrange_die
, DW_AT_lower_bound
,
9481 TYPE_MIN_VALUE (type
));
9482 if (TYPE_MAX_VALUE (type
) != NULL
)
9483 add_bound_info (subrange_die
, DW_AT_upper_bound
,
9484 TYPE_MAX_VALUE (type
));
9486 return subrange_die
;
9489 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
9490 entry that chains various modifiers in front of the given type. */
9493 modified_type_die (tree type
, int is_const_type
, int is_volatile_type
,
9494 dw_die_ref context_die
)
9496 enum tree_code code
= TREE_CODE (type
);
9497 dw_die_ref mod_type_die
;
9498 dw_die_ref sub_die
= NULL
;
9499 tree item_type
= NULL
;
9500 tree qualified_type
;
9503 if (code
== ERROR_MARK
)
9506 /* See if we already have the appropriately qualified variant of
9509 = get_qualified_type (type
,
9510 ((is_const_type
? TYPE_QUAL_CONST
: 0)
9511 | (is_volatile_type
? TYPE_QUAL_VOLATILE
: 0)));
9513 /* If we do, then we can just use its DIE, if it exists. */
9516 mod_type_die
= lookup_type_die (qualified_type
);
9518 return mod_type_die
;
9521 name
= qualified_type
? TYPE_NAME (qualified_type
) : NULL
;
9523 /* Handle C typedef types. */
9524 if (name
&& TREE_CODE (name
) == TYPE_DECL
&& DECL_ORIGINAL_TYPE (name
))
9526 tree dtype
= TREE_TYPE (name
);
9528 if (qualified_type
== dtype
)
9530 /* For a named type, use the typedef. */
9531 gen_type_die (qualified_type
, context_die
);
9532 return lookup_type_die (qualified_type
);
9534 else if (is_const_type
< TYPE_READONLY (dtype
)
9535 || is_volatile_type
< TYPE_VOLATILE (dtype
)
9536 || (is_const_type
<= TYPE_READONLY (dtype
)
9537 && is_volatile_type
<= TYPE_VOLATILE (dtype
)
9538 && DECL_ORIGINAL_TYPE (name
) != type
))
9539 /* cv-unqualified version of named type. Just use the unnamed
9540 type to which it refers. */
9541 return modified_type_die (DECL_ORIGINAL_TYPE (name
),
9542 is_const_type
, is_volatile_type
,
9544 /* Else cv-qualified version of named type; fall through. */
9549 mod_type_die
= new_die (DW_TAG_const_type
, comp_unit_die
, type
);
9550 sub_die
= modified_type_die (type
, 0, is_volatile_type
, context_die
);
9552 else if (is_volatile_type
)
9554 mod_type_die
= new_die (DW_TAG_volatile_type
, comp_unit_die
, type
);
9555 sub_die
= modified_type_die (type
, 0, 0, context_die
);
9557 else if (code
== POINTER_TYPE
)
9559 mod_type_die
= new_die (DW_TAG_pointer_type
, comp_unit_die
, type
);
9560 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
,
9561 simple_type_size_in_bits (type
) / BITS_PER_UNIT
);
9562 item_type
= TREE_TYPE (type
);
9564 else if (code
== REFERENCE_TYPE
)
9566 mod_type_die
= new_die (DW_TAG_reference_type
, comp_unit_die
, type
);
9567 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
,
9568 simple_type_size_in_bits (type
) / BITS_PER_UNIT
);
9569 item_type
= TREE_TYPE (type
);
9571 else if (is_subrange_type (type
))
9573 mod_type_die
= subrange_type_die (type
, context_die
);
9574 item_type
= TREE_TYPE (type
);
9576 else if (is_base_type (type
))
9577 mod_type_die
= base_type_die (type
);
9580 gen_type_die (type
, context_die
);
9582 /* We have to get the type_main_variant here (and pass that to the
9583 `lookup_type_die' routine) because the ..._TYPE node we have
9584 might simply be a *copy* of some original type node (where the
9585 copy was created to help us keep track of typedef names) and
9586 that copy might have a different TYPE_UID from the original
9588 if (TREE_CODE (type
) != VECTOR_TYPE
)
9589 return lookup_type_die (type_main_variant (type
));
9591 /* Vectors have the debugging information in the type,
9592 not the main variant. */
9593 return lookup_type_die (type
);
9596 /* Builtin types don't have a DECL_ORIGINAL_TYPE. For those,
9597 don't output a DW_TAG_typedef, since there isn't one in the
9598 user's program; just attach a DW_AT_name to the type. */
9600 && (TREE_CODE (name
) != TYPE_DECL
9601 || (TREE_TYPE (name
) == qualified_type
&& DECL_NAME (name
))))
9603 if (TREE_CODE (name
) == TYPE_DECL
)
9604 /* Could just call add_name_and_src_coords_attributes here,
9605 but since this is a builtin type it doesn't have any
9606 useful source coordinates anyway. */
9607 name
= DECL_NAME (name
);
9608 add_name_attribute (mod_type_die
, IDENTIFIER_POINTER (name
));
9612 equate_type_number_to_die (qualified_type
, mod_type_die
);
9615 /* We must do this after the equate_type_number_to_die call, in case
9616 this is a recursive type. This ensures that the modified_type_die
9617 recursion will terminate even if the type is recursive. Recursive
9618 types are possible in Ada. */
9619 sub_die
= modified_type_die (item_type
,
9620 TYPE_READONLY (item_type
),
9621 TYPE_VOLATILE (item_type
),
9624 if (sub_die
!= NULL
)
9625 add_AT_die_ref (mod_type_die
, DW_AT_type
, sub_die
);
9627 return mod_type_die
;
9630 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
9631 an enumerated type. */
9634 type_is_enum (const_tree type
)
9636 return TREE_CODE (type
) == ENUMERAL_TYPE
;
9639 /* Return the DBX register number described by a given RTL node. */
9642 dbx_reg_number (const_rtx rtl
)
9644 unsigned regno
= REGNO (rtl
);
9646 gcc_assert (regno
< FIRST_PSEUDO_REGISTER
);
9648 #ifdef LEAF_REG_REMAP
9649 if (current_function_uses_only_leaf_regs
)
9651 int leaf_reg
= LEAF_REG_REMAP (regno
);
9653 regno
= (unsigned) leaf_reg
;
9657 return DBX_REGISTER_NUMBER (regno
);
9660 /* Optionally add a DW_OP_piece term to a location description expression.
9661 DW_OP_piece is only added if the location description expression already
9662 doesn't end with DW_OP_piece. */
9665 add_loc_descr_op_piece (dw_loc_descr_ref
*list_head
, int size
)
9667 dw_loc_descr_ref loc
;
9669 if (*list_head
!= NULL
)
9671 /* Find the end of the chain. */
9672 for (loc
= *list_head
; loc
->dw_loc_next
!= NULL
; loc
= loc
->dw_loc_next
)
9675 if (loc
->dw_loc_opc
!= DW_OP_piece
)
9676 loc
->dw_loc_next
= new_loc_descr (DW_OP_piece
, size
, 0);
9680 /* Return a location descriptor that designates a machine register or
9681 zero if there is none. */
9683 static dw_loc_descr_ref
9684 reg_loc_descriptor (rtx rtl
, enum var_init_status initialized
)
9688 if (REGNO (rtl
) >= FIRST_PSEUDO_REGISTER
)
9691 regs
= targetm
.dwarf_register_span (rtl
);
9693 if (hard_regno_nregs
[REGNO (rtl
)][GET_MODE (rtl
)] > 1 || regs
)
9694 return multiple_reg_loc_descriptor (rtl
, regs
, initialized
);
9696 return one_reg_loc_descriptor (dbx_reg_number (rtl
), initialized
);
9699 /* Return a location descriptor that designates a machine register for
9700 a given hard register number. */
9702 static dw_loc_descr_ref
9703 one_reg_loc_descriptor (unsigned int regno
, enum var_init_status initialized
)
9705 dw_loc_descr_ref reg_loc_descr
= new_reg_loc_descr (regno
, 0);
9707 if (initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
9708 add_loc_descr (®_loc_descr
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
9710 return reg_loc_descr
;
9713 /* Given an RTL of a register, return a location descriptor that
9714 designates a value that spans more than one register. */
9716 static dw_loc_descr_ref
9717 multiple_reg_loc_descriptor (rtx rtl
, rtx regs
,
9718 enum var_init_status initialized
)
9722 dw_loc_descr_ref loc_result
= NULL
;
9725 #ifdef LEAF_REG_REMAP
9726 if (current_function_uses_only_leaf_regs
)
9728 int leaf_reg
= LEAF_REG_REMAP (reg
);
9730 reg
= (unsigned) leaf_reg
;
9733 gcc_assert ((unsigned) DBX_REGISTER_NUMBER (reg
) == dbx_reg_number (rtl
));
9734 nregs
= hard_regno_nregs
[REGNO (rtl
)][GET_MODE (rtl
)];
9736 /* Simple, contiguous registers. */
9737 if (regs
== NULL_RTX
)
9739 size
= GET_MODE_SIZE (GET_MODE (rtl
)) / nregs
;
9746 t
= one_reg_loc_descriptor (DBX_REGISTER_NUMBER (reg
),
9747 VAR_INIT_STATUS_INITIALIZED
);
9748 add_loc_descr (&loc_result
, t
);
9749 add_loc_descr_op_piece (&loc_result
, size
);
9755 /* Now onto stupid register sets in non contiguous locations. */
9757 gcc_assert (GET_CODE (regs
) == PARALLEL
);
9759 size
= GET_MODE_SIZE (GET_MODE (XVECEXP (regs
, 0, 0)));
9762 for (i
= 0; i
< XVECLEN (regs
, 0); ++i
)
9766 t
= one_reg_loc_descriptor (REGNO (XVECEXP (regs
, 0, i
)),
9767 VAR_INIT_STATUS_INITIALIZED
);
9768 add_loc_descr (&loc_result
, t
);
9769 size
= GET_MODE_SIZE (GET_MODE (XVECEXP (regs
, 0, 0)));
9770 add_loc_descr_op_piece (&loc_result
, size
);
9773 if (loc_result
&& initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
9774 add_loc_descr (&loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
9778 #endif /* DWARF2_DEBUGGING_INFO */
9780 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
9782 /* Return a location descriptor that designates a constant. */
9784 static dw_loc_descr_ref
9785 int_loc_descriptor (HOST_WIDE_INT i
)
9787 enum dwarf_location_atom op
;
9789 /* Pick the smallest representation of a constant, rather than just
9790 defaulting to the LEB encoding. */
9794 op
= (enum dwarf_location_atom
) (DW_OP_lit0
+ i
);
9797 else if (i
<= 0xffff)
9799 else if (HOST_BITS_PER_WIDE_INT
== 32
9809 else if (i
>= -0x8000)
9811 else if (HOST_BITS_PER_WIDE_INT
== 32
9812 || i
>= -0x80000000)
9818 return new_loc_descr (op
, i
, 0);
9822 #ifdef DWARF2_DEBUGGING_INFO
9824 /* Return a location descriptor that designates a base+offset location. */
9826 static dw_loc_descr_ref
9827 based_loc_descr (rtx reg
, HOST_WIDE_INT offset
,
9828 enum var_init_status initialized
)
9831 dw_loc_descr_ref result
;
9832 dw_fde_ref fde
= current_fde ();
9834 /* We only use "frame base" when we're sure we're talking about the
9835 post-prologue local stack frame. We do this by *not* running
9836 register elimination until this point, and recognizing the special
9837 argument pointer and soft frame pointer rtx's. */
9838 if (reg
== arg_pointer_rtx
|| reg
== frame_pointer_rtx
)
9840 rtx elim
= eliminate_regs (reg
, VOIDmode
, NULL_RTX
);
9844 if (GET_CODE (elim
) == PLUS
)
9846 offset
+= INTVAL (XEXP (elim
, 1));
9847 elim
= XEXP (elim
, 0);
9849 gcc_assert ((SUPPORTS_STACK_ALIGNMENT
9850 && (elim
== hard_frame_pointer_rtx
9851 || elim
== stack_pointer_rtx
))
9852 || elim
== (frame_pointer_needed
9853 ? hard_frame_pointer_rtx
9854 : stack_pointer_rtx
));
9856 /* If drap register is used to align stack, use frame
9857 pointer + offset to access stack variables. If stack
9858 is aligned without drap, use stack pointer + offset to
9859 access stack variables. */
9860 if (crtl
->stack_realign_tried
9861 && cfa
.reg
== HARD_FRAME_POINTER_REGNUM
9862 && reg
== frame_pointer_rtx
)
9865 = DWARF_FRAME_REGNUM (cfa
.indirect
9866 ? HARD_FRAME_POINTER_REGNUM
9867 : STACK_POINTER_REGNUM
);
9868 return new_reg_loc_descr (base_reg
, offset
);
9871 offset
+= frame_pointer_fb_offset
;
9872 return new_loc_descr (DW_OP_fbreg
, offset
, 0);
9876 && fde
->drap_reg
!= INVALID_REGNUM
9877 && (fde
->drap_reg
== REGNO (reg
)
9878 || fde
->vdrap_reg
== REGNO (reg
)))
9880 /* Use cfa+offset to represent the location of arguments passed
9881 on stack when drap is used to align stack. */
9882 return new_loc_descr (DW_OP_fbreg
, offset
, 0);
9885 regno
= dbx_reg_number (reg
);
9887 result
= new_loc_descr ((enum dwarf_location_atom
) (DW_OP_breg0
+ regno
),
9890 result
= new_loc_descr (DW_OP_bregx
, regno
, offset
);
9892 if (initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
9893 add_loc_descr (&result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
9898 /* Return true if this RTL expression describes a base+offset calculation. */
9901 is_based_loc (const_rtx rtl
)
9903 return (GET_CODE (rtl
) == PLUS
9904 && ((REG_P (XEXP (rtl
, 0))
9905 && REGNO (XEXP (rtl
, 0)) < FIRST_PSEUDO_REGISTER
9906 && GET_CODE (XEXP (rtl
, 1)) == CONST_INT
)));
9909 /* Return a descriptor that describes the concatenation of N locations
9910 used to form the address of a memory location. */
9912 static dw_loc_descr_ref
9913 concatn_mem_loc_descriptor (rtx concatn
, enum machine_mode mode
,
9914 enum var_init_status initialized
)
9917 dw_loc_descr_ref cc_loc_result
= NULL
;
9918 unsigned int n
= XVECLEN (concatn
, 0);
9920 for (i
= 0; i
< n
; ++i
)
9922 dw_loc_descr_ref ref
;
9923 rtx x
= XVECEXP (concatn
, 0, i
);
9925 ref
= mem_loc_descriptor (x
, mode
, VAR_INIT_STATUS_INITIALIZED
);
9929 add_loc_descr (&cc_loc_result
, ref
);
9930 add_loc_descr_op_piece (&cc_loc_result
, GET_MODE_SIZE (GET_MODE (x
)));
9933 if (cc_loc_result
&& initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
9934 add_loc_descr (&cc_loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
9936 return cc_loc_result
;
9939 /* Try to handle TLS MEMs, for which mem_loc_descriptor on XEXP (mem, 0)
9942 static dw_loc_descr_ref
9943 tls_mem_loc_descriptor (rtx mem
)
9946 dw_loc_descr_ref loc_result
;
9948 if (MEM_EXPR (mem
) == NULL_TREE
|| MEM_OFFSET (mem
) == NULL_RTX
)
9951 base
= get_base_address (MEM_EXPR (mem
));
9953 || TREE_CODE (base
) != VAR_DECL
9954 || !DECL_THREAD_LOCAL_P (base
))
9957 loc_result
= loc_descriptor_from_tree_1 (MEM_EXPR (mem
), 2);
9958 if (loc_result
== NULL
)
9961 if (INTVAL (MEM_OFFSET (mem
)))
9962 loc_descr_plus_const (&loc_result
, INTVAL (MEM_OFFSET (mem
)));
9967 /* The following routine converts the RTL for a variable or parameter
9968 (resident in memory) into an equivalent Dwarf representation of a
9969 mechanism for getting the address of that same variable onto the top of a
9970 hypothetical "address evaluation" stack.
9972 When creating memory location descriptors, we are effectively transforming
9973 the RTL for a memory-resident object into its Dwarf postfix expression
9974 equivalent. This routine recursively descends an RTL tree, turning
9975 it into Dwarf postfix code as it goes.
9977 MODE is the mode of the memory reference, needed to handle some
9978 autoincrement addressing modes.
9980 CAN_USE_FBREG is a flag whether we can use DW_AT_frame_base in the
9981 location list for RTL.
9983 Return 0 if we can't represent the location. */
9985 static dw_loc_descr_ref
9986 mem_loc_descriptor (rtx rtl
, enum machine_mode mode
,
9987 enum var_init_status initialized
)
9989 dw_loc_descr_ref mem_loc_result
= NULL
;
9990 enum dwarf_location_atom op
;
9992 /* Note that for a dynamically sized array, the location we will generate a
9993 description of here will be the lowest numbered location which is
9994 actually within the array. That's *not* necessarily the same as the
9995 zeroth element of the array. */
9997 rtl
= targetm
.delegitimize_address (rtl
);
9999 switch (GET_CODE (rtl
))
10004 /* POST_INC and POST_DEC can be handled just like a SUBREG. So we
10005 just fall into the SUBREG code. */
10007 /* ... fall through ... */
10010 /* The case of a subreg may arise when we have a local (register)
10011 variable or a formal (register) parameter which doesn't quite fill
10012 up an entire register. For now, just assume that it is
10013 legitimate to make the Dwarf info refer to the whole register which
10014 contains the given subreg. */
10015 rtl
= XEXP (rtl
, 0);
10017 /* ... fall through ... */
10020 /* Whenever a register number forms a part of the description of the
10021 method for calculating the (dynamic) address of a memory resident
10022 object, DWARF rules require the register number be referred to as
10023 a "base register". This distinction is not based in any way upon
10024 what category of register the hardware believes the given register
10025 belongs to. This is strictly DWARF terminology we're dealing with
10026 here. Note that in cases where the location of a memory-resident
10027 data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
10028 OP_CONST (0)) the actual DWARF location descriptor that we generate
10029 may just be OP_BASEREG (basereg). This may look deceptively like
10030 the object in question was allocated to a register (rather than in
10031 memory) so DWARF consumers need to be aware of the subtle
10032 distinction between OP_REG and OP_BASEREG. */
10033 if (REGNO (rtl
) < FIRST_PSEUDO_REGISTER
)
10034 mem_loc_result
= based_loc_descr (rtl
, 0, VAR_INIT_STATUS_INITIALIZED
);
10035 else if (stack_realign_drap
10037 && crtl
->args
.internal_arg_pointer
== rtl
10038 && REGNO (crtl
->drap_reg
) < FIRST_PSEUDO_REGISTER
)
10040 /* If RTL is internal_arg_pointer, which has been optimized
10041 out, use DRAP instead. */
10042 mem_loc_result
= based_loc_descr (crtl
->drap_reg
, 0,
10043 VAR_INIT_STATUS_INITIALIZED
);
10048 mem_loc_result
= mem_loc_descriptor (XEXP (rtl
, 0), GET_MODE (rtl
),
10049 VAR_INIT_STATUS_INITIALIZED
);
10050 if (mem_loc_result
== NULL
)
10051 mem_loc_result
= tls_mem_loc_descriptor (rtl
);
10052 if (mem_loc_result
!= 0)
10053 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_deref
, 0, 0));
10057 rtl
= XEXP (rtl
, 1);
10059 /* ... fall through ... */
10062 /* Some ports can transform a symbol ref into a label ref, because
10063 the symbol ref is too far away and has to be dumped into a constant
10067 /* Alternatively, the symbol in the constant pool might be referenced
10068 by a different symbol. */
10069 if (GET_CODE (rtl
) == SYMBOL_REF
&& CONSTANT_POOL_ADDRESS_P (rtl
))
10072 rtx tmp
= get_pool_constant_mark (rtl
, &marked
);
10074 if (GET_CODE (tmp
) == SYMBOL_REF
)
10077 if (CONSTANT_POOL_ADDRESS_P (tmp
))
10078 get_pool_constant_mark (tmp
, &marked
);
10083 /* If all references to this pool constant were optimized away,
10084 it was not output and thus we can't represent it.
10085 FIXME: might try to use DW_OP_const_value here, though
10086 DW_OP_piece complicates it. */
10091 mem_loc_result
= new_loc_descr (DW_OP_addr
, 0, 0);
10092 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_addr
;
10093 mem_loc_result
->dw_loc_oprnd1
.v
.val_addr
= rtl
;
10094 VEC_safe_push (rtx
, gc
, used_rtx_array
, rtl
);
10098 /* Extract the PLUS expression nested inside and fall into
10099 PLUS code below. */
10100 rtl
= XEXP (rtl
, 1);
10105 /* Turn these into a PLUS expression and fall into the PLUS code
10107 rtl
= gen_rtx_PLUS (word_mode
, XEXP (rtl
, 0),
10108 GEN_INT (GET_CODE (rtl
) == PRE_INC
10109 ? GET_MODE_UNIT_SIZE (mode
)
10110 : -GET_MODE_UNIT_SIZE (mode
)));
10112 /* ... fall through ... */
10116 if (is_based_loc (rtl
))
10117 mem_loc_result
= based_loc_descr (XEXP (rtl
, 0),
10118 INTVAL (XEXP (rtl
, 1)),
10119 VAR_INIT_STATUS_INITIALIZED
);
10122 mem_loc_result
= mem_loc_descriptor (XEXP (rtl
, 0), mode
,
10123 VAR_INIT_STATUS_INITIALIZED
);
10124 if (mem_loc_result
== 0)
10127 if (GET_CODE (XEXP (rtl
, 1)) == CONST_INT
)
10128 loc_descr_plus_const (&mem_loc_result
, INTVAL (XEXP (rtl
, 1)));
10131 dw_loc_descr_ref mem_loc_result2
10132 = mem_loc_descriptor (XEXP (rtl
, 1), mode
,
10133 VAR_INIT_STATUS_INITIALIZED
);
10134 if (mem_loc_result2
== 0)
10136 add_loc_descr (&mem_loc_result
, mem_loc_result2
);
10137 add_loc_descr (&mem_loc_result
,
10138 new_loc_descr (DW_OP_plus
, 0, 0));
10143 /* If a pseudo-reg is optimized away, it is possible for it to
10144 be replaced with a MEM containing a multiply or shift. */
10163 dw_loc_descr_ref op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
,
10164 VAR_INIT_STATUS_INITIALIZED
);
10165 dw_loc_descr_ref op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
,
10166 VAR_INIT_STATUS_INITIALIZED
);
10168 if (op0
== 0 || op1
== 0)
10171 mem_loc_result
= op0
;
10172 add_loc_descr (&mem_loc_result
, op1
);
10173 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
10178 mem_loc_result
= int_loc_descriptor (INTVAL (rtl
));
10182 mem_loc_result
= concatn_mem_loc_descriptor (rtl
, mode
,
10183 VAR_INIT_STATUS_INITIALIZED
);
10187 /* If delegitimize_address couldn't do anything with the UNSPEC, we
10188 can't express it in the debug info. This can happen e.g. with some
10193 gcc_unreachable ();
10196 if (mem_loc_result
&& initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
10197 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
10199 return mem_loc_result
;
10202 /* Return a descriptor that describes the concatenation of two locations.
10203 This is typically a complex variable. */
10205 static dw_loc_descr_ref
10206 concat_loc_descriptor (rtx x0
, rtx x1
, enum var_init_status initialized
)
10208 dw_loc_descr_ref cc_loc_result
= NULL
;
10209 dw_loc_descr_ref x0_ref
= loc_descriptor (x0
, VAR_INIT_STATUS_INITIALIZED
);
10210 dw_loc_descr_ref x1_ref
= loc_descriptor (x1
, VAR_INIT_STATUS_INITIALIZED
);
10212 if (x0_ref
== 0 || x1_ref
== 0)
10215 cc_loc_result
= x0_ref
;
10216 add_loc_descr_op_piece (&cc_loc_result
, GET_MODE_SIZE (GET_MODE (x0
)));
10218 add_loc_descr (&cc_loc_result
, x1_ref
);
10219 add_loc_descr_op_piece (&cc_loc_result
, GET_MODE_SIZE (GET_MODE (x1
)));
10221 if (initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
10222 add_loc_descr (&cc_loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
10224 return cc_loc_result
;
10227 /* Return a descriptor that describes the concatenation of N
10230 static dw_loc_descr_ref
10231 concatn_loc_descriptor (rtx concatn
, enum var_init_status initialized
)
10234 dw_loc_descr_ref cc_loc_result
= NULL
;
10235 unsigned int n
= XVECLEN (concatn
, 0);
10237 for (i
= 0; i
< n
; ++i
)
10239 dw_loc_descr_ref ref
;
10240 rtx x
= XVECEXP (concatn
, 0, i
);
10242 ref
= loc_descriptor (x
, VAR_INIT_STATUS_INITIALIZED
);
10246 add_loc_descr (&cc_loc_result
, ref
);
10247 add_loc_descr_op_piece (&cc_loc_result
, GET_MODE_SIZE (GET_MODE (x
)));
10250 if (cc_loc_result
&& initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
10251 add_loc_descr (&cc_loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
10253 return cc_loc_result
;
10256 /* Output a proper Dwarf location descriptor for a variable or parameter
10257 which is either allocated in a register or in a memory location. For a
10258 register, we just generate an OP_REG and the register number. For a
10259 memory location we provide a Dwarf postfix expression describing how to
10260 generate the (dynamic) address of the object onto the address stack.
10262 If we don't know how to describe it, return 0. */
10264 static dw_loc_descr_ref
10265 loc_descriptor (rtx rtl
, enum var_init_status initialized
)
10267 dw_loc_descr_ref loc_result
= NULL
;
10269 switch (GET_CODE (rtl
))
10272 /* The case of a subreg may arise when we have a local (register)
10273 variable or a formal (register) parameter which doesn't quite fill
10274 up an entire register. For now, just assume that it is
10275 legitimate to make the Dwarf info refer to the whole register which
10276 contains the given subreg. */
10277 rtl
= SUBREG_REG (rtl
);
10279 /* ... fall through ... */
10282 loc_result
= reg_loc_descriptor (rtl
, initialized
);
10286 loc_result
= mem_loc_descriptor (XEXP (rtl
, 0), GET_MODE (rtl
),
10288 if (loc_result
== NULL
)
10289 loc_result
= tls_mem_loc_descriptor (rtl
);
10293 loc_result
= concat_loc_descriptor (XEXP (rtl
, 0), XEXP (rtl
, 1),
10298 loc_result
= concatn_loc_descriptor (rtl
, initialized
);
10303 if (GET_CODE (XEXP (rtl
, 1)) != PARALLEL
)
10305 loc_result
= loc_descriptor (XEXP (XEXP (rtl
, 1), 0), initialized
);
10309 rtl
= XEXP (rtl
, 1);
10314 rtvec par_elems
= XVEC (rtl
, 0);
10315 int num_elem
= GET_NUM_ELEM (par_elems
);
10316 enum machine_mode mode
;
10319 /* Create the first one, so we have something to add to. */
10320 loc_result
= loc_descriptor (XEXP (RTVEC_ELT (par_elems
, 0), 0),
10322 if (loc_result
== NULL
)
10324 mode
= GET_MODE (XEXP (RTVEC_ELT (par_elems
, 0), 0));
10325 add_loc_descr_op_piece (&loc_result
, GET_MODE_SIZE (mode
));
10326 for (i
= 1; i
< num_elem
; i
++)
10328 dw_loc_descr_ref temp
;
10330 temp
= loc_descriptor (XEXP (RTVEC_ELT (par_elems
, i
), 0),
10334 add_loc_descr (&loc_result
, temp
);
10335 mode
= GET_MODE (XEXP (RTVEC_ELT (par_elems
, i
), 0));
10336 add_loc_descr_op_piece (&loc_result
, GET_MODE_SIZE (mode
));
10342 gcc_unreachable ();
10348 /* Similar, but generate the descriptor from trees instead of rtl. This comes
10349 up particularly with variable length arrays. WANT_ADDRESS is 2 if this is
10350 a top-level invocation of loc_descriptor_from_tree; is 1 if this is not a
10351 top-level invocation, and we require the address of LOC; is 0 if we require
10352 the value of LOC. */
10354 static dw_loc_descr_ref
10355 loc_descriptor_from_tree_1 (tree loc
, int want_address
)
10357 dw_loc_descr_ref ret
, ret1
;
10358 int have_address
= 0;
10359 enum dwarf_location_atom op
;
10361 /* ??? Most of the time we do not take proper care for sign/zero
10362 extending the values properly. Hopefully this won't be a real
10365 switch (TREE_CODE (loc
))
10370 case PLACEHOLDER_EXPR
:
10371 /* This case involves extracting fields from an object to determine the
10372 position of other fields. We don't try to encode this here. The
10373 only user of this is Ada, which encodes the needed information using
10374 the names of types. */
10380 case PREINCREMENT_EXPR
:
10381 case PREDECREMENT_EXPR
:
10382 case POSTINCREMENT_EXPR
:
10383 case POSTDECREMENT_EXPR
:
10384 /* There are no opcodes for these operations. */
10388 /* If we already want an address, there's nothing we can do. */
10392 /* Otherwise, process the argument and look for the address. */
10393 return loc_descriptor_from_tree_1 (TREE_OPERAND (loc
, 0), 1);
10396 if (DECL_THREAD_LOCAL_P (loc
))
10399 enum dwarf_location_atom first_op
;
10400 enum dwarf_location_atom second_op
;
10402 if (targetm
.have_tls
)
10404 /* If this is not defined, we have no way to emit the
10406 if (!targetm
.asm_out
.output_dwarf_dtprel
)
10409 /* The way DW_OP_GNU_push_tls_address is specified, we
10410 can only look up addresses of objects in the current
10412 if (DECL_EXTERNAL (loc
) && !targetm
.binds_local_p (loc
))
10414 first_op
= (enum dwarf_location_atom
) INTERNAL_DW_OP_tls_addr
;
10415 second_op
= DW_OP_GNU_push_tls_address
;
10419 if (!targetm
.emutls
.debug_form_tls_address
)
10421 loc
= emutls_decl (loc
);
10422 first_op
= DW_OP_addr
;
10423 second_op
= DW_OP_form_tls_address
;
10426 rtl
= rtl_for_decl_location (loc
);
10427 if (rtl
== NULL_RTX
)
10432 rtl
= XEXP (rtl
, 0);
10433 if (! CONSTANT_P (rtl
))
10436 ret
= new_loc_descr (first_op
, 0, 0);
10437 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_addr
;
10438 ret
->dw_loc_oprnd1
.v
.val_addr
= rtl
;
10440 ret1
= new_loc_descr (second_op
, 0, 0);
10441 add_loc_descr (&ret
, ret1
);
10449 if (DECL_HAS_VALUE_EXPR_P (loc
))
10450 return loc_descriptor_from_tree_1 (DECL_VALUE_EXPR (loc
),
10455 case FUNCTION_DECL
:
10457 rtx rtl
= rtl_for_decl_location (loc
);
10459 if (rtl
== NULL_RTX
)
10461 else if (GET_CODE (rtl
) == CONST_INT
)
10463 HOST_WIDE_INT val
= INTVAL (rtl
);
10464 if (TYPE_UNSIGNED (TREE_TYPE (loc
)))
10465 val
&= GET_MODE_MASK (DECL_MODE (loc
));
10466 ret
= int_loc_descriptor (val
);
10468 else if (GET_CODE (rtl
) == CONST_STRING
)
10470 else if (CONSTANT_P (rtl
))
10472 ret
= new_loc_descr (DW_OP_addr
, 0, 0);
10473 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_addr
;
10474 ret
->dw_loc_oprnd1
.v
.val_addr
= rtl
;
10478 enum machine_mode mode
;
10480 /* Certain constructs can only be represented at top-level. */
10481 if (want_address
== 2)
10482 return loc_descriptor (rtl
, VAR_INIT_STATUS_INITIALIZED
);
10484 mode
= GET_MODE (rtl
);
10487 rtl
= XEXP (rtl
, 0);
10490 ret
= mem_loc_descriptor (rtl
, mode
, VAR_INIT_STATUS_INITIALIZED
);
10496 ret
= loc_descriptor_from_tree_1 (TREE_OPERAND (loc
, 0), 0);
10500 case COMPOUND_EXPR
:
10501 return loc_descriptor_from_tree_1 (TREE_OPERAND (loc
, 1), want_address
);
10504 case VIEW_CONVERT_EXPR
:
10507 return loc_descriptor_from_tree_1 (TREE_OPERAND (loc
, 0), want_address
);
10509 case COMPONENT_REF
:
10510 case BIT_FIELD_REF
:
10512 case ARRAY_RANGE_REF
:
10515 HOST_WIDE_INT bitsize
, bitpos
, bytepos
;
10516 enum machine_mode mode
;
10518 int unsignedp
= TYPE_UNSIGNED (TREE_TYPE (loc
));
10520 obj
= get_inner_reference (loc
, &bitsize
, &bitpos
, &offset
, &mode
,
10521 &unsignedp
, &volatilep
, false);
10526 ret
= loc_descriptor_from_tree_1 (obj
, 1);
10528 || bitpos
% BITS_PER_UNIT
!= 0 || bitsize
% BITS_PER_UNIT
!= 0)
10531 if (offset
!= NULL_TREE
)
10533 /* Variable offset. */
10534 ret1
= loc_descriptor_from_tree_1 (offset
, 0);
10537 add_loc_descr (&ret
, ret1
);
10538 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus
, 0, 0));
10541 bytepos
= bitpos
/ BITS_PER_UNIT
;
10542 loc_descr_plus_const (&ret
, bytepos
);
10549 if (host_integerp (loc
, 0))
10550 ret
= int_loc_descriptor (tree_low_cst (loc
, 0));
10557 /* Get an RTL for this, if something has been emitted. */
10558 rtx rtl
= lookup_constant_def (loc
);
10559 enum machine_mode mode
;
10561 if (!rtl
|| !MEM_P (rtl
))
10563 mode
= GET_MODE (rtl
);
10564 rtl
= XEXP (rtl
, 0);
10565 ret
= mem_loc_descriptor (rtl
, mode
, VAR_INIT_STATUS_INITIALIZED
);
10570 case TRUTH_AND_EXPR
:
10571 case TRUTH_ANDIF_EXPR
:
10576 case TRUTH_XOR_EXPR
:
10581 case TRUTH_OR_EXPR
:
10582 case TRUTH_ORIF_EXPR
:
10587 case FLOOR_DIV_EXPR
:
10588 case CEIL_DIV_EXPR
:
10589 case ROUND_DIV_EXPR
:
10590 case TRUNC_DIV_EXPR
:
10598 case FLOOR_MOD_EXPR
:
10599 case CEIL_MOD_EXPR
:
10600 case ROUND_MOD_EXPR
:
10601 case TRUNC_MOD_EXPR
:
10614 op
= (TYPE_UNSIGNED (TREE_TYPE (loc
)) ? DW_OP_shr
: DW_OP_shra
);
10617 case POINTER_PLUS_EXPR
:
10619 if (TREE_CODE (TREE_OPERAND (loc
, 1)) == INTEGER_CST
10620 && host_integerp (TREE_OPERAND (loc
, 1), 0))
10622 ret
= loc_descriptor_from_tree_1 (TREE_OPERAND (loc
, 0), 0);
10626 loc_descr_plus_const (&ret
, tree_low_cst (TREE_OPERAND (loc
, 1), 0));
10634 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc
, 0))))
10641 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc
, 0))))
10648 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc
, 0))))
10655 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc
, 0))))
10670 ret
= loc_descriptor_from_tree_1 (TREE_OPERAND (loc
, 0), 0);
10671 ret1
= loc_descriptor_from_tree_1 (TREE_OPERAND (loc
, 1), 0);
10672 if (ret
== 0 || ret1
== 0)
10675 add_loc_descr (&ret
, ret1
);
10676 add_loc_descr (&ret
, new_loc_descr (op
, 0, 0));
10679 case TRUTH_NOT_EXPR
:
10693 ret
= loc_descriptor_from_tree_1 (TREE_OPERAND (loc
, 0), 0);
10697 add_loc_descr (&ret
, new_loc_descr (op
, 0, 0));
10703 const enum tree_code code
=
10704 TREE_CODE (loc
) == MIN_EXPR
? GT_EXPR
: LT_EXPR
;
10706 loc
= build3 (COND_EXPR
, TREE_TYPE (loc
),
10707 build2 (code
, integer_type_node
,
10708 TREE_OPERAND (loc
, 0), TREE_OPERAND (loc
, 1)),
10709 TREE_OPERAND (loc
, 1), TREE_OPERAND (loc
, 0));
10712 /* ... fall through ... */
10716 dw_loc_descr_ref lhs
10717 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc
, 1), 0);
10718 dw_loc_descr_ref rhs
10719 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc
, 2), 0);
10720 dw_loc_descr_ref bra_node
, jump_node
, tmp
;
10722 ret
= loc_descriptor_from_tree_1 (TREE_OPERAND (loc
, 0), 0);
10723 if (ret
== 0 || lhs
== 0 || rhs
== 0)
10726 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
10727 add_loc_descr (&ret
, bra_node
);
10729 add_loc_descr (&ret
, rhs
);
10730 jump_node
= new_loc_descr (DW_OP_skip
, 0, 0);
10731 add_loc_descr (&ret
, jump_node
);
10733 add_loc_descr (&ret
, lhs
);
10734 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
10735 bra_node
->dw_loc_oprnd1
.v
.val_loc
= lhs
;
10737 /* ??? Need a node to point the skip at. Use a nop. */
10738 tmp
= new_loc_descr (DW_OP_nop
, 0, 0);
10739 add_loc_descr (&ret
, tmp
);
10740 jump_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
10741 jump_node
->dw_loc_oprnd1
.v
.val_loc
= tmp
;
10745 case FIX_TRUNC_EXPR
:
10749 /* Leave front-end specific codes as simply unknown. This comes
10750 up, for instance, with the C STMT_EXPR. */
10751 if ((unsigned int) TREE_CODE (loc
)
10752 >= (unsigned int) LAST_AND_UNUSED_TREE_CODE
)
10755 #ifdef ENABLE_CHECKING
10756 /* Otherwise this is a generic code; we should just lists all of
10757 these explicitly. We forgot one. */
10758 gcc_unreachable ();
10760 /* In a release build, we want to degrade gracefully: better to
10761 generate incomplete debugging information than to crash. */
10766 /* Show if we can't fill the request for an address. */
10767 if (want_address
&& !have_address
)
10770 /* If we've got an address and don't want one, dereference. */
10771 if (!want_address
&& have_address
&& ret
)
10773 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (loc
));
10775 if (size
> DWARF2_ADDR_SIZE
|| size
== -1)
10777 else if (size
== DWARF2_ADDR_SIZE
)
10780 op
= DW_OP_deref_size
;
10782 add_loc_descr (&ret
, new_loc_descr (op
, size
, 0));
10788 static inline dw_loc_descr_ref
10789 loc_descriptor_from_tree (tree loc
)
10791 return loc_descriptor_from_tree_1 (loc
, 2);
10794 /* Given a value, round it up to the lowest multiple of `boundary'
10795 which is not less than the value itself. */
10797 static inline HOST_WIDE_INT
10798 ceiling (HOST_WIDE_INT value
, unsigned int boundary
)
10800 return (((value
+ boundary
- 1) / boundary
) * boundary
);
10803 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
10804 pointer to the declared type for the relevant field variable, or return
10805 `integer_type_node' if the given node turns out to be an
10806 ERROR_MARK node. */
10809 field_type (const_tree decl
)
10813 if (TREE_CODE (decl
) == ERROR_MARK
)
10814 return integer_type_node
;
10816 type
= DECL_BIT_FIELD_TYPE (decl
);
10817 if (type
== NULL_TREE
)
10818 type
= TREE_TYPE (decl
);
10823 /* Given a pointer to a tree node, return the alignment in bits for
10824 it, or else return BITS_PER_WORD if the node actually turns out to
10825 be an ERROR_MARK node. */
10827 static inline unsigned
10828 simple_type_align_in_bits (const_tree type
)
10830 return (TREE_CODE (type
) != ERROR_MARK
) ? TYPE_ALIGN (type
) : BITS_PER_WORD
;
10833 static inline unsigned
10834 simple_decl_align_in_bits (const_tree decl
)
10836 return (TREE_CODE (decl
) != ERROR_MARK
) ? DECL_ALIGN (decl
) : BITS_PER_WORD
;
10839 /* Return the result of rounding T up to ALIGN. */
10841 static inline HOST_WIDE_INT
10842 round_up_to_align (HOST_WIDE_INT t
, unsigned int align
)
10844 /* We must be careful if T is negative because HOST_WIDE_INT can be
10845 either "above" or "below" unsigned int as per the C promotion
10846 rules, depending on the host, thus making the signedness of the
10847 direct multiplication and division unpredictable. */
10848 unsigned HOST_WIDE_INT u
= (unsigned HOST_WIDE_INT
) t
;
10854 return (HOST_WIDE_INT
) u
;
10857 /* Given a pointer to a FIELD_DECL, compute and return the byte offset of the
10858 lowest addressed byte of the "containing object" for the given FIELD_DECL,
10859 or return 0 if we are unable to determine what that offset is, either
10860 because the argument turns out to be a pointer to an ERROR_MARK node, or
10861 because the offset is actually variable. (We can't handle the latter case
10864 static HOST_WIDE_INT
10865 field_byte_offset (const_tree decl
)
10867 HOST_WIDE_INT object_offset_in_bits
;
10868 HOST_WIDE_INT bitpos_int
;
10870 if (TREE_CODE (decl
) == ERROR_MARK
)
10873 gcc_assert (TREE_CODE (decl
) == FIELD_DECL
);
10875 /* We cannot yet cope with fields whose positions are variable, so
10876 for now, when we see such things, we simply return 0. Someday, we may
10877 be able to handle such cases, but it will be damn difficult. */
10878 if (! host_integerp (bit_position (decl
), 0))
10881 bitpos_int
= int_bit_position (decl
);
10883 #ifdef PCC_BITFIELD_TYPE_MATTERS
10884 if (PCC_BITFIELD_TYPE_MATTERS
)
10887 tree field_size_tree
;
10888 HOST_WIDE_INT deepest_bitpos
;
10889 unsigned HOST_WIDE_INT field_size_in_bits
;
10890 unsigned int type_align_in_bits
;
10891 unsigned int decl_align_in_bits
;
10892 unsigned HOST_WIDE_INT type_size_in_bits
;
10894 type
= field_type (decl
);
10895 type_size_in_bits
= simple_type_size_in_bits (type
);
10896 type_align_in_bits
= simple_type_align_in_bits (type
);
10898 field_size_tree
= DECL_SIZE (decl
);
10900 /* The size could be unspecified if there was an error, or for
10901 a flexible array member. */
10902 if (!field_size_tree
)
10903 field_size_tree
= bitsize_zero_node
;
10905 /* If the size of the field is not constant, use the type size. */
10906 if (host_integerp (field_size_tree
, 1))
10907 field_size_in_bits
= tree_low_cst (field_size_tree
, 1);
10909 field_size_in_bits
= type_size_in_bits
;
10911 decl_align_in_bits
= simple_decl_align_in_bits (decl
);
10913 /* The GCC front-end doesn't make any attempt to keep track of the
10914 starting bit offset (relative to the start of the containing
10915 structure type) of the hypothetical "containing object" for a
10916 bit-field. Thus, when computing the byte offset value for the
10917 start of the "containing object" of a bit-field, we must deduce
10918 this information on our own. This can be rather tricky to do in
10919 some cases. For example, handling the following structure type
10920 definition when compiling for an i386/i486 target (which only
10921 aligns long long's to 32-bit boundaries) can be very tricky:
10923 struct S { int field1; long long field2:31; };
10925 Fortunately, there is a simple rule-of-thumb which can be used
10926 in such cases. When compiling for an i386/i486, GCC will
10927 allocate 8 bytes for the structure shown above. It decides to
10928 do this based upon one simple rule for bit-field allocation.
10929 GCC allocates each "containing object" for each bit-field at
10930 the first (i.e. lowest addressed) legitimate alignment boundary
10931 (based upon the required minimum alignment for the declared
10932 type of the field) which it can possibly use, subject to the
10933 condition that there is still enough available space remaining
10934 in the containing object (when allocated at the selected point)
10935 to fully accommodate all of the bits of the bit-field itself.
10937 This simple rule makes it obvious why GCC allocates 8 bytes for
10938 each object of the structure type shown above. When looking
10939 for a place to allocate the "containing object" for `field2',
10940 the compiler simply tries to allocate a 64-bit "containing
10941 object" at each successive 32-bit boundary (starting at zero)
10942 until it finds a place to allocate that 64- bit field such that
10943 at least 31 contiguous (and previously unallocated) bits remain
10944 within that selected 64 bit field. (As it turns out, for the
10945 example above, the compiler finds it is OK to allocate the
10946 "containing object" 64-bit field at bit-offset zero within the
10949 Here we attempt to work backwards from the limited set of facts
10950 we're given, and we try to deduce from those facts, where GCC
10951 must have believed that the containing object started (within
10952 the structure type). The value we deduce is then used (by the
10953 callers of this routine) to generate DW_AT_location and
10954 DW_AT_bit_offset attributes for fields (both bit-fields and, in
10955 the case of DW_AT_location, regular fields as well). */
10957 /* Figure out the bit-distance from the start of the structure to
10958 the "deepest" bit of the bit-field. */
10959 deepest_bitpos
= bitpos_int
+ field_size_in_bits
;
10961 /* This is the tricky part. Use some fancy footwork to deduce
10962 where the lowest addressed bit of the containing object must
10964 object_offset_in_bits
= deepest_bitpos
- type_size_in_bits
;
10966 /* Round up to type_align by default. This works best for
10968 object_offset_in_bits
10969 = round_up_to_align (object_offset_in_bits
, type_align_in_bits
);
10971 if (object_offset_in_bits
> bitpos_int
)
10973 object_offset_in_bits
= deepest_bitpos
- type_size_in_bits
;
10975 /* Round up to decl_align instead. */
10976 object_offset_in_bits
10977 = round_up_to_align (object_offset_in_bits
, decl_align_in_bits
);
10982 object_offset_in_bits
= bitpos_int
;
10984 return object_offset_in_bits
/ BITS_PER_UNIT
;
10987 /* The following routines define various Dwarf attributes and any data
10988 associated with them. */
10990 /* Add a location description attribute value to a DIE.
10992 This emits location attributes suitable for whole variables and
10993 whole parameters. Note that the location attributes for struct fields are
10994 generated by the routine `data_member_location_attribute' below. */
10997 add_AT_location_description (dw_die_ref die
, enum dwarf_attribute attr_kind
,
10998 dw_loc_descr_ref descr
)
11001 add_AT_loc (die
, attr_kind
, descr
);
11004 /* Attach the specialized form of location attribute used for data members of
11005 struct and union types. In the special case of a FIELD_DECL node which
11006 represents a bit-field, the "offset" part of this special location
11007 descriptor must indicate the distance in bytes from the lowest-addressed
11008 byte of the containing struct or union type to the lowest-addressed byte of
11009 the "containing object" for the bit-field. (See the `field_byte_offset'
11012 For any given bit-field, the "containing object" is a hypothetical object
11013 (of some integral or enum type) within which the given bit-field lives. The
11014 type of this hypothetical "containing object" is always the same as the
11015 declared type of the individual bit-field itself (for GCC anyway... the
11016 DWARF spec doesn't actually mandate this). Note that it is the size (in
11017 bytes) of the hypothetical "containing object" which will be given in the
11018 DW_AT_byte_size attribute for this bit-field. (See the
11019 `byte_size_attribute' function below.) It is also used when calculating the
11020 value of the DW_AT_bit_offset attribute. (See the `bit_offset_attribute'
11021 function below.) */
11024 add_data_member_location_attribute (dw_die_ref die
, tree decl
)
11026 HOST_WIDE_INT offset
;
11027 dw_loc_descr_ref loc_descr
= 0;
11029 if (TREE_CODE (decl
) == TREE_BINFO
)
11031 /* We're working on the TAG_inheritance for a base class. */
11032 if (BINFO_VIRTUAL_P (decl
) && is_cxx ())
11034 /* For C++ virtual bases we can't just use BINFO_OFFSET, as they
11035 aren't at a fixed offset from all (sub)objects of the same
11036 type. We need to extract the appropriate offset from our
11037 vtable. The following dwarf expression means
11039 BaseAddr = ObAddr + *((*ObAddr) - Offset)
11041 This is specific to the V3 ABI, of course. */
11043 dw_loc_descr_ref tmp
;
11045 /* Make a copy of the object address. */
11046 tmp
= new_loc_descr (DW_OP_dup
, 0, 0);
11047 add_loc_descr (&loc_descr
, tmp
);
11049 /* Extract the vtable address. */
11050 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
11051 add_loc_descr (&loc_descr
, tmp
);
11053 /* Calculate the address of the offset. */
11054 offset
= tree_low_cst (BINFO_VPTR_FIELD (decl
), 0);
11055 gcc_assert (offset
< 0);
11057 tmp
= int_loc_descriptor (-offset
);
11058 add_loc_descr (&loc_descr
, tmp
);
11059 tmp
= new_loc_descr (DW_OP_minus
, 0, 0);
11060 add_loc_descr (&loc_descr
, tmp
);
11062 /* Extract the offset. */
11063 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
11064 add_loc_descr (&loc_descr
, tmp
);
11066 /* Add it to the object address. */
11067 tmp
= new_loc_descr (DW_OP_plus
, 0, 0);
11068 add_loc_descr (&loc_descr
, tmp
);
11071 offset
= tree_low_cst (BINFO_OFFSET (decl
), 0);
11074 offset
= field_byte_offset (decl
);
11078 enum dwarf_location_atom op
;
11080 /* The DWARF2 standard says that we should assume that the structure
11081 address is already on the stack, so we can specify a structure field
11082 address by using DW_OP_plus_uconst. */
11084 #ifdef MIPS_DEBUGGING_INFO
11085 /* ??? The SGI dwarf reader does not handle the DW_OP_plus_uconst
11086 operator correctly. It works only if we leave the offset on the
11090 op
= DW_OP_plus_uconst
;
11093 loc_descr
= new_loc_descr (op
, offset
, 0);
11096 add_AT_loc (die
, DW_AT_data_member_location
, loc_descr
);
11099 /* Writes integer values to dw_vec_const array. */
11102 insert_int (HOST_WIDE_INT val
, unsigned int size
, unsigned char *dest
)
11106 *dest
++ = val
& 0xff;
11112 /* Reads integers from dw_vec_const array. Inverse of insert_int. */
11114 static HOST_WIDE_INT
11115 extract_int (const unsigned char *src
, unsigned int size
)
11117 HOST_WIDE_INT val
= 0;
11123 val
|= *--src
& 0xff;
11129 /* Writes floating point values to dw_vec_const array. */
11132 insert_float (const_rtx rtl
, unsigned char *array
)
11134 REAL_VALUE_TYPE rv
;
11138 REAL_VALUE_FROM_CONST_DOUBLE (rv
, rtl
);
11139 real_to_target (val
, &rv
, GET_MODE (rtl
));
11141 /* real_to_target puts 32-bit pieces in each long. Pack them. */
11142 for (i
= 0; i
< GET_MODE_SIZE (GET_MODE (rtl
)) / 4; i
++)
11144 insert_int (val
[i
], 4, array
);
11149 /* Attach a DW_AT_const_value attribute for a variable or a parameter which
11150 does not have a "location" either in memory or in a register. These
11151 things can arise in GNU C when a constant is passed as an actual parameter
11152 to an inlined function. They can also arise in C++ where declared
11153 constants do not necessarily get memory "homes". */
11156 add_const_value_attribute (dw_die_ref die
, rtx rtl
)
11158 switch (GET_CODE (rtl
))
11162 HOST_WIDE_INT val
= INTVAL (rtl
);
11165 add_AT_int (die
, DW_AT_const_value
, val
);
11167 add_AT_unsigned (die
, DW_AT_const_value
, (unsigned HOST_WIDE_INT
) val
);
11172 /* Note that a CONST_DOUBLE rtx could represent either an integer or a
11173 floating-point constant. A CONST_DOUBLE is used whenever the
11174 constant requires more than one word in order to be adequately
11175 represented. We output CONST_DOUBLEs as blocks. */
11177 enum machine_mode mode
= GET_MODE (rtl
);
11179 if (SCALAR_FLOAT_MODE_P (mode
))
11181 unsigned int length
= GET_MODE_SIZE (mode
);
11182 unsigned char *array
= GGC_NEWVEC (unsigned char, length
);
11184 insert_float (rtl
, array
);
11185 add_AT_vec (die
, DW_AT_const_value
, length
/ 4, 4, array
);
11189 /* ??? We really should be using HOST_WIDE_INT throughout. */
11190 gcc_assert (HOST_BITS_PER_LONG
== HOST_BITS_PER_WIDE_INT
);
11192 add_AT_long_long (die
, DW_AT_const_value
,
11193 CONST_DOUBLE_HIGH (rtl
), CONST_DOUBLE_LOW (rtl
));
11200 enum machine_mode mode
= GET_MODE (rtl
);
11201 unsigned int elt_size
= GET_MODE_UNIT_SIZE (mode
);
11202 unsigned int length
= CONST_VECTOR_NUNITS (rtl
);
11203 unsigned char *array
= GGC_NEWVEC (unsigned char, length
* elt_size
);
11207 switch (GET_MODE_CLASS (mode
))
11209 case MODE_VECTOR_INT
:
11210 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
11212 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
11213 HOST_WIDE_INT lo
, hi
;
11215 switch (GET_CODE (elt
))
11223 lo
= CONST_DOUBLE_LOW (elt
);
11224 hi
= CONST_DOUBLE_HIGH (elt
);
11228 gcc_unreachable ();
11231 if (elt_size
<= sizeof (HOST_WIDE_INT
))
11232 insert_int (lo
, elt_size
, p
);
11235 unsigned char *p0
= p
;
11236 unsigned char *p1
= p
+ sizeof (HOST_WIDE_INT
);
11238 gcc_assert (elt_size
== 2 * sizeof (HOST_WIDE_INT
));
11239 if (WORDS_BIG_ENDIAN
)
11244 insert_int (lo
, sizeof (HOST_WIDE_INT
), p0
);
11245 insert_int (hi
, sizeof (HOST_WIDE_INT
), p1
);
11250 case MODE_VECTOR_FLOAT
:
11251 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
11253 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
11254 insert_float (elt
, p
);
11259 gcc_unreachable ();
11262 add_AT_vec (die
, DW_AT_const_value
, length
, elt_size
, array
);
11267 add_AT_string (die
, DW_AT_const_value
, XSTR (rtl
, 0));
11273 add_AT_addr (die
, DW_AT_const_value
, rtl
);
11274 VEC_safe_push (rtx
, gc
, used_rtx_array
, rtl
);
11278 /* In cases where an inlined instance of an inline function is passed
11279 the address of an `auto' variable (which is local to the caller) we
11280 can get a situation where the DECL_RTL of the artificial local
11281 variable (for the inlining) which acts as a stand-in for the
11282 corresponding formal parameter (of the inline function) will look
11283 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not
11284 exactly a compile-time constant expression, but it isn't the address
11285 of the (artificial) local variable either. Rather, it represents the
11286 *value* which the artificial local variable always has during its
11287 lifetime. We currently have no way to represent such quasi-constant
11288 values in Dwarf, so for now we just punt and generate nothing. */
11292 /* No other kinds of rtx should be possible here. */
11293 gcc_unreachable ();
11298 /* Determine whether the evaluation of EXPR references any variables
11299 or functions which aren't otherwise used (and therefore may not be
11302 reference_to_unused (tree
* tp
, int * walk_subtrees
,
11303 void * data ATTRIBUTE_UNUSED
)
11305 if (! EXPR_P (*tp
) && ! CONSTANT_CLASS_P (*tp
))
11306 *walk_subtrees
= 0;
11308 if (DECL_P (*tp
) && ! TREE_PUBLIC (*tp
) && ! TREE_USED (*tp
)
11309 && ! TREE_ASM_WRITTEN (*tp
))
11311 /* ??? The C++ FE emits debug information for using decls, so
11312 putting gcc_unreachable here falls over. See PR31899. For now
11313 be conservative. */
11314 else if (!cgraph_global_info_ready
11315 && (TREE_CODE (*tp
) == VAR_DECL
|| TREE_CODE (*tp
) == FUNCTION_DECL
))
11317 else if (DECL_P (*tp
) && TREE_CODE (*tp
) == VAR_DECL
)
11319 struct varpool_node
*node
= varpool_node (*tp
);
11323 else if (DECL_P (*tp
) && TREE_CODE (*tp
) == FUNCTION_DECL
11324 && (!DECL_EXTERNAL (*tp
) || DECL_DECLARED_INLINE_P (*tp
)))
11326 struct cgraph_node
*node
= cgraph_node (*tp
);
11327 if (node
->process
|| TREE_ASM_WRITTEN (*tp
))
11330 else if (TREE_CODE (*tp
) == STRING_CST
&& !TREE_ASM_WRITTEN (*tp
))
11336 /* Generate an RTL constant from a decl initializer INIT with decl type TYPE,
11337 for use in a later add_const_value_attribute call. */
11340 rtl_for_decl_init (tree init
, tree type
)
11342 rtx rtl
= NULL_RTX
;
11344 /* If a variable is initialized with a string constant without embedded
11345 zeros, build CONST_STRING. */
11346 if (TREE_CODE (init
) == STRING_CST
&& TREE_CODE (type
) == ARRAY_TYPE
)
11348 tree enttype
= TREE_TYPE (type
);
11349 tree domain
= TYPE_DOMAIN (type
);
11350 enum machine_mode mode
= TYPE_MODE (enttype
);
11352 if (GET_MODE_CLASS (mode
) == MODE_INT
&& GET_MODE_SIZE (mode
) == 1
11354 && integer_zerop (TYPE_MIN_VALUE (domain
))
11355 && compare_tree_int (TYPE_MAX_VALUE (domain
),
11356 TREE_STRING_LENGTH (init
) - 1) == 0
11357 && ((size_t) TREE_STRING_LENGTH (init
)
11358 == strlen (TREE_STRING_POINTER (init
)) + 1))
11359 rtl
= gen_rtx_CONST_STRING (VOIDmode
,
11360 ggc_strdup (TREE_STRING_POINTER (init
)));
11362 /* Other aggregates, and complex values, could be represented using
11364 else if (AGGREGATE_TYPE_P (type
) || TREE_CODE (type
) == COMPLEX_TYPE
)
11366 /* Vectors only work if their mode is supported by the target.
11367 FIXME: generic vectors ought to work too. */
11368 else if (TREE_CODE (type
) == VECTOR_TYPE
&& TYPE_MODE (type
) == BLKmode
)
11370 /* If the initializer is something that we know will expand into an
11371 immediate RTL constant, expand it now. We must be careful not to
11372 reference variables which won't be output. */
11373 else if (initializer_constant_valid_p (init
, type
)
11374 && ! walk_tree (&init
, reference_to_unused
, NULL
, NULL
))
11376 /* Convert vector CONSTRUCTOR initializers to VECTOR_CST if
11378 if (TREE_CODE (type
) == VECTOR_TYPE
)
11379 switch (TREE_CODE (init
))
11384 if (TREE_CONSTANT (init
))
11386 VEC(constructor_elt
,gc
) *elts
= CONSTRUCTOR_ELTS (init
);
11387 bool constant_p
= true;
11389 unsigned HOST_WIDE_INT ix
;
11391 /* Even when ctor is constant, it might contain non-*_CST
11392 elements (e.g. { 1.0/0.0 - 1.0/0.0, 0.0 }) and those don't
11393 belong into VECTOR_CST nodes. */
11394 FOR_EACH_CONSTRUCTOR_VALUE (elts
, ix
, value
)
11395 if (!CONSTANT_CLASS_P (value
))
11397 constant_p
= false;
11403 init
= build_vector_from_ctor (type
, elts
);
11413 rtl
= expand_expr (init
, NULL_RTX
, VOIDmode
, EXPAND_INITIALIZER
);
11415 /* If expand_expr returns a MEM, it wasn't immediate. */
11416 gcc_assert (!rtl
|| !MEM_P (rtl
));
11422 /* Generate RTL for the variable DECL to represent its location. */
11425 rtl_for_decl_location (tree decl
)
11429 /* Here we have to decide where we are going to say the parameter "lives"
11430 (as far as the debugger is concerned). We only have a couple of
11431 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
11433 DECL_RTL normally indicates where the parameter lives during most of the
11434 activation of the function. If optimization is enabled however, this
11435 could be either NULL or else a pseudo-reg. Both of those cases indicate
11436 that the parameter doesn't really live anywhere (as far as the code
11437 generation parts of GCC are concerned) during most of the function's
11438 activation. That will happen (for example) if the parameter is never
11439 referenced within the function.
11441 We could just generate a location descriptor here for all non-NULL
11442 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
11443 a little nicer than that if we also consider DECL_INCOMING_RTL in cases
11444 where DECL_RTL is NULL or is a pseudo-reg.
11446 Note however that we can only get away with using DECL_INCOMING_RTL as
11447 a backup substitute for DECL_RTL in certain limited cases. In cases
11448 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
11449 we can be sure that the parameter was passed using the same type as it is
11450 declared to have within the function, and that its DECL_INCOMING_RTL
11451 points us to a place where a value of that type is passed.
11453 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
11454 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
11455 because in these cases DECL_INCOMING_RTL points us to a value of some
11456 type which is *different* from the type of the parameter itself. Thus,
11457 if we tried to use DECL_INCOMING_RTL to generate a location attribute in
11458 such cases, the debugger would end up (for example) trying to fetch a
11459 `float' from a place which actually contains the first part of a
11460 `double'. That would lead to really incorrect and confusing
11461 output at debug-time.
11463 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
11464 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There
11465 are a couple of exceptions however. On little-endian machines we can
11466 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
11467 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
11468 an integral type that is smaller than TREE_TYPE (decl). These cases arise
11469 when (on a little-endian machine) a non-prototyped function has a
11470 parameter declared to be of type `short' or `char'. In such cases,
11471 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
11472 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
11473 passed `int' value. If the debugger then uses that address to fetch
11474 a `short' or a `char' (on a little-endian machine) the result will be
11475 the correct data, so we allow for such exceptional cases below.
11477 Note that our goal here is to describe the place where the given formal
11478 parameter lives during most of the function's activation (i.e. between the
11479 end of the prologue and the start of the epilogue). We'll do that as best
11480 as we can. Note however that if the given formal parameter is modified
11481 sometime during the execution of the function, then a stack backtrace (at
11482 debug-time) will show the function as having been called with the *new*
11483 value rather than the value which was originally passed in. This happens
11484 rarely enough that it is not a major problem, but it *is* a problem, and
11485 I'd like to fix it.
11487 A future version of dwarf2out.c may generate two additional attributes for
11488 any given DW_TAG_formal_parameter DIE which will describe the "passed
11489 type" and the "passed location" for the given formal parameter in addition
11490 to the attributes we now generate to indicate the "declared type" and the
11491 "active location" for each parameter. This additional set of attributes
11492 could be used by debuggers for stack backtraces. Separately, note that
11493 sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also.
11494 This happens (for example) for inlined-instances of inline function formal
11495 parameters which are never referenced. This really shouldn't be
11496 happening. All PARM_DECL nodes should get valid non-NULL
11497 DECL_INCOMING_RTL values. FIXME. */
11499 /* Use DECL_RTL as the "location" unless we find something better. */
11500 rtl
= DECL_RTL_IF_SET (decl
);
11502 /* When generating abstract instances, ignore everything except
11503 constants, symbols living in memory, and symbols living in
11504 fixed registers. */
11505 if (! reload_completed
)
11508 && (CONSTANT_P (rtl
)
11510 && CONSTANT_P (XEXP (rtl
, 0)))
11512 && TREE_CODE (decl
) == VAR_DECL
11513 && TREE_STATIC (decl
))))
11515 rtl
= targetm
.delegitimize_address (rtl
);
11520 else if (TREE_CODE (decl
) == PARM_DECL
)
11522 if (rtl
== NULL_RTX
|| is_pseudo_reg (rtl
))
11524 tree declared_type
= TREE_TYPE (decl
);
11525 tree passed_type
= DECL_ARG_TYPE (decl
);
11526 enum machine_mode dmode
= TYPE_MODE (declared_type
);
11527 enum machine_mode pmode
= TYPE_MODE (passed_type
);
11529 /* This decl represents a formal parameter which was optimized out.
11530 Note that DECL_INCOMING_RTL may be NULL in here, but we handle
11531 all cases where (rtl == NULL_RTX) just below. */
11532 if (dmode
== pmode
)
11533 rtl
= DECL_INCOMING_RTL (decl
);
11534 else if (SCALAR_INT_MODE_P (dmode
)
11535 && GET_MODE_SIZE (dmode
) <= GET_MODE_SIZE (pmode
)
11536 && DECL_INCOMING_RTL (decl
))
11538 rtx inc
= DECL_INCOMING_RTL (decl
);
11541 else if (MEM_P (inc
))
11543 if (BYTES_BIG_ENDIAN
)
11544 rtl
= adjust_address_nv (inc
, dmode
,
11545 GET_MODE_SIZE (pmode
)
11546 - GET_MODE_SIZE (dmode
));
11553 /* If the parm was passed in registers, but lives on the stack, then
11554 make a big endian correction if the mode of the type of the
11555 parameter is not the same as the mode of the rtl. */
11556 /* ??? This is the same series of checks that are made in dbxout.c before
11557 we reach the big endian correction code there. It isn't clear if all
11558 of these checks are necessary here, but keeping them all is the safe
11560 else if (MEM_P (rtl
)
11561 && XEXP (rtl
, 0) != const0_rtx
11562 && ! CONSTANT_P (XEXP (rtl
, 0))
11563 /* Not passed in memory. */
11564 && !MEM_P (DECL_INCOMING_RTL (decl
))
11565 /* Not passed by invisible reference. */
11566 && (!REG_P (XEXP (rtl
, 0))
11567 || REGNO (XEXP (rtl
, 0)) == HARD_FRAME_POINTER_REGNUM
11568 || REGNO (XEXP (rtl
, 0)) == STACK_POINTER_REGNUM
11569 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
11570 || REGNO (XEXP (rtl
, 0)) == ARG_POINTER_REGNUM
11573 /* Big endian correction check. */
11574 && BYTES_BIG_ENDIAN
11575 && TYPE_MODE (TREE_TYPE (decl
)) != GET_MODE (rtl
)
11576 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl
)))
11579 int offset
= (UNITS_PER_WORD
11580 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl
))));
11582 rtl
= gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl
)),
11583 plus_constant (XEXP (rtl
, 0), offset
));
11586 else if (TREE_CODE (decl
) == VAR_DECL
11589 && GET_MODE (rtl
) != TYPE_MODE (TREE_TYPE (decl
))
11590 && BYTES_BIG_ENDIAN
)
11592 int rsize
= GET_MODE_SIZE (GET_MODE (rtl
));
11593 int dsize
= GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl
)));
11595 /* If a variable is declared "register" yet is smaller than
11596 a register, then if we store the variable to memory, it
11597 looks like we're storing a register-sized value, when in
11598 fact we are not. We need to adjust the offset of the
11599 storage location to reflect the actual value's bytes,
11600 else gdb will not be able to display it. */
11602 rtl
= gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl
)),
11603 plus_constant (XEXP (rtl
, 0), rsize
-dsize
));
11606 /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant,
11607 and will have been substituted directly into all expressions that use it.
11608 C does not have such a concept, but C++ and other languages do. */
11609 if (!rtl
&& TREE_CODE (decl
) == VAR_DECL
&& DECL_INITIAL (decl
))
11610 rtl
= rtl_for_decl_init (DECL_INITIAL (decl
), TREE_TYPE (decl
));
11613 rtl
= targetm
.delegitimize_address (rtl
);
11615 /* If we don't look past the constant pool, we risk emitting a
11616 reference to a constant pool entry that isn't referenced from
11617 code, and thus is not emitted. */
11619 rtl
= avoid_constant_pool_reference (rtl
);
11624 /* We need to figure out what section we should use as the base for the
11625 address ranges where a given location is valid.
11626 1. If this particular DECL has a section associated with it, use that.
11627 2. If this function has a section associated with it, use that.
11628 3. Otherwise, use the text section.
11629 XXX: If you split a variable across multiple sections, we won't notice. */
11631 static const char *
11632 secname_for_decl (const_tree decl
)
11634 const char *secname
;
11636 if (VAR_OR_FUNCTION_DECL_P (decl
) && DECL_SECTION_NAME (decl
))
11638 tree sectree
= DECL_SECTION_NAME (decl
);
11639 secname
= TREE_STRING_POINTER (sectree
);
11641 else if (current_function_decl
&& DECL_SECTION_NAME (current_function_decl
))
11643 tree sectree
= DECL_SECTION_NAME (current_function_decl
);
11644 secname
= TREE_STRING_POINTER (sectree
);
11646 else if (cfun
&& in_cold_section_p
)
11647 secname
= crtl
->subsections
.cold_section_label
;
11649 secname
= text_section_label
;
11654 /* Check whether decl is a Fortran COMMON symbol. If not, NULL_TREE is
11655 returned. If so, the decl for the COMMON block is returned, and the
11656 value is the offset into the common block for the symbol. */
11659 fortran_common (tree decl
, HOST_WIDE_INT
*value
)
11661 tree val_expr
, cvar
;
11662 enum machine_mode mode
;
11663 HOST_WIDE_INT bitsize
, bitpos
;
11665 int volatilep
= 0, unsignedp
= 0;
11667 /* If the decl isn't a VAR_DECL, or if it isn't public or static, or if
11668 it does not have a value (the offset into the common area), or if it
11669 is thread local (as opposed to global) then it isn't common, and shouldn't
11670 be handled as such. */
11671 if (TREE_CODE (decl
) != VAR_DECL
11672 || !TREE_PUBLIC (decl
)
11673 || !TREE_STATIC (decl
)
11674 || !DECL_HAS_VALUE_EXPR_P (decl
)
11678 val_expr
= DECL_VALUE_EXPR (decl
);
11679 if (TREE_CODE (val_expr
) != COMPONENT_REF
)
11682 cvar
= get_inner_reference (val_expr
, &bitsize
, &bitpos
, &offset
,
11683 &mode
, &unsignedp
, &volatilep
, true);
11685 if (cvar
== NULL_TREE
11686 || TREE_CODE (cvar
) != VAR_DECL
11687 || DECL_ARTIFICIAL (cvar
)
11688 || !TREE_PUBLIC (cvar
))
11692 if (offset
!= NULL
)
11694 if (!host_integerp (offset
, 0))
11696 *value
= tree_low_cst (offset
, 0);
11699 *value
+= bitpos
/ BITS_PER_UNIT
;
11704 /* Dereference a location expression LOC if DECL is passed by invisible
11707 static dw_loc_descr_ref
11708 loc_by_reference (dw_loc_descr_ref loc
, tree decl
)
11710 HOST_WIDE_INT size
;
11711 enum dwarf_location_atom op
;
11716 if ((TREE_CODE (decl
) != PARM_DECL
11717 && TREE_CODE (decl
) != RESULT_DECL
11718 && (TREE_CODE (decl
) != VAR_DECL
|| TREE_STATIC (decl
)))
11719 || !DECL_BY_REFERENCE (decl
))
11722 size
= int_size_in_bytes (TREE_TYPE (decl
));
11723 if (size
> DWARF2_ADDR_SIZE
|| size
== -1)
11725 else if (size
== DWARF2_ADDR_SIZE
)
11728 op
= DW_OP_deref_size
;
11729 add_loc_descr (&loc
, new_loc_descr (op
, size
, 0));
11733 /* Generate *either* a DW_AT_location attribute or else a DW_AT_const_value
11734 data attribute for a variable or a parameter. We generate the
11735 DW_AT_const_value attribute only in those cases where the given variable
11736 or parameter does not have a true "location" either in memory or in a
11737 register. This can happen (for example) when a constant is passed as an
11738 actual argument in a call to an inline function. (It's possible that
11739 these things can crop up in other ways also.) Note that one type of
11740 constant value which can be passed into an inlined function is a constant
11741 pointer. This can happen for example if an actual argument in an inlined
11742 function call evaluates to a compile-time constant address. */
11745 add_location_or_const_value_attribute (dw_die_ref die
, tree decl
,
11746 enum dwarf_attribute attr
)
11749 dw_loc_descr_ref descr
;
11750 var_loc_list
*loc_list
;
11751 struct var_loc_node
*node
;
11752 if (TREE_CODE (decl
) == ERROR_MARK
)
11755 gcc_assert (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == PARM_DECL
11756 || TREE_CODE (decl
) == RESULT_DECL
);
11758 /* See if we possibly have multiple locations for this variable. */
11759 loc_list
= lookup_decl_loc (decl
);
11761 /* If it truly has multiple locations, the first and last node will
11763 if (loc_list
&& loc_list
->first
!= loc_list
->last
)
11765 const char *endname
, *secname
;
11766 dw_loc_list_ref list
;
11768 enum var_init_status initialized
;
11770 /* Now that we know what section we are using for a base,
11771 actually construct the list of locations.
11772 The first location information is what is passed to the
11773 function that creates the location list, and the remaining
11774 locations just get added on to that list.
11775 Note that we only know the start address for a location
11776 (IE location changes), so to build the range, we use
11777 the range [current location start, next location start].
11778 This means we have to special case the last node, and generate
11779 a range of [last location start, end of function label]. */
11781 node
= loc_list
->first
;
11782 varloc
= NOTE_VAR_LOCATION (node
->var_loc_note
);
11783 secname
= secname_for_decl (decl
);
11785 if (NOTE_VAR_LOCATION_LOC (node
->var_loc_note
))
11786 initialized
= NOTE_VAR_LOCATION_STATUS (node
->var_loc_note
);
11788 initialized
= VAR_INIT_STATUS_INITIALIZED
;
11790 descr
= loc_by_reference (loc_descriptor (varloc
, initialized
), decl
);
11791 list
= new_loc_list (descr
, node
->label
, node
->next
->label
, secname
, 1);
11794 for (; node
->next
; node
= node
->next
)
11795 if (NOTE_VAR_LOCATION_LOC (node
->var_loc_note
) != NULL_RTX
)
11797 /* The variable has a location between NODE->LABEL and
11798 NODE->NEXT->LABEL. */
11799 enum var_init_status initialized
=
11800 NOTE_VAR_LOCATION_STATUS (node
->var_loc_note
);
11801 varloc
= NOTE_VAR_LOCATION (node
->var_loc_note
);
11802 descr
= loc_by_reference (loc_descriptor (varloc
, initialized
),
11804 add_loc_descr_to_loc_list (&list
, descr
,
11805 node
->label
, node
->next
->label
, secname
);
11808 /* If the variable has a location at the last label
11809 it keeps its location until the end of function. */
11810 if (NOTE_VAR_LOCATION_LOC (node
->var_loc_note
) != NULL_RTX
)
11812 char label_id
[MAX_ARTIFICIAL_LABEL_BYTES
];
11813 enum var_init_status initialized
=
11814 NOTE_VAR_LOCATION_STATUS (node
->var_loc_note
);
11816 varloc
= NOTE_VAR_LOCATION (node
->var_loc_note
);
11817 if (!current_function_decl
)
11818 endname
= text_end_label
;
11821 ASM_GENERATE_INTERNAL_LABEL (label_id
, FUNC_END_LABEL
,
11822 current_function_funcdef_no
);
11823 endname
= ggc_strdup (label_id
);
11825 descr
= loc_by_reference (loc_descriptor (varloc
, initialized
),
11827 add_loc_descr_to_loc_list (&list
, descr
,
11828 node
->label
, endname
, secname
);
11831 /* Finally, add the location list to the DIE, and we are done. */
11832 add_AT_loc_list (die
, attr
, list
);
11836 /* Try to get some constant RTL for this decl, and use that as the value of
11839 rtl
= rtl_for_decl_location (decl
);
11840 if (rtl
&& (CONSTANT_P (rtl
) || GET_CODE (rtl
) == CONST_STRING
))
11842 add_const_value_attribute (die
, rtl
);
11846 /* If we have tried to generate the location otherwise, and it
11847 didn't work out (we wouldn't be here if we did), and we have a one entry
11848 location list, try generating a location from that. */
11849 if (loc_list
&& loc_list
->first
)
11851 enum var_init_status status
;
11852 node
= loc_list
->first
;
11853 status
= NOTE_VAR_LOCATION_STATUS (node
->var_loc_note
);
11854 descr
= loc_descriptor (NOTE_VAR_LOCATION (node
->var_loc_note
), status
);
11857 descr
= loc_by_reference (descr
, decl
);
11858 add_AT_location_description (die
, attr
, descr
);
11863 /* We couldn't get any rtl, so try directly generating the location
11864 description from the tree. */
11865 descr
= loc_descriptor_from_tree (decl
);
11868 descr
= loc_by_reference (descr
, decl
);
11869 add_AT_location_description (die
, attr
, descr
);
11872 /* None of that worked, so it must not really have a location;
11873 try adding a constant value attribute from the DECL_INITIAL. */
11874 tree_add_const_value_attribute (die
, decl
);
11877 /* Add VARIABLE and DIE into deferred locations list. */
11880 defer_location (tree variable
, dw_die_ref die
)
11882 deferred_locations entry
;
11883 entry
.variable
= variable
;
11885 VEC_safe_push (deferred_locations
, gc
, deferred_locations_list
, &entry
);
11888 /* Helper function for tree_add_const_value_attribute. Natively encode
11889 initializer INIT into an array. Return true if successful. */
11892 native_encode_initializer (tree init
, unsigned char *array
, int size
)
11896 if (init
== NULL_TREE
)
11900 switch (TREE_CODE (init
))
11903 type
= TREE_TYPE (init
);
11904 if (TREE_CODE (type
) == ARRAY_TYPE
)
11906 tree enttype
= TREE_TYPE (type
);
11907 enum machine_mode mode
= TYPE_MODE (enttype
);
11909 if (GET_MODE_CLASS (mode
) != MODE_INT
|| GET_MODE_SIZE (mode
) != 1)
11911 if (int_size_in_bytes (type
) != size
)
11913 if (size
> TREE_STRING_LENGTH (init
))
11915 memcpy (array
, TREE_STRING_POINTER (init
),
11916 TREE_STRING_LENGTH (init
));
11917 memset (array
+ TREE_STRING_LENGTH (init
),
11918 '\0', size
- TREE_STRING_LENGTH (init
));
11921 memcpy (array
, TREE_STRING_POINTER (init
), size
);
11926 type
= TREE_TYPE (init
);
11927 if (int_size_in_bytes (type
) != size
)
11929 if (TREE_CODE (type
) == ARRAY_TYPE
)
11931 HOST_WIDE_INT min_index
;
11932 unsigned HOST_WIDE_INT cnt
;
11933 int curpos
= 0, fieldsize
;
11934 constructor_elt
*ce
;
11936 if (TYPE_DOMAIN (type
) == NULL_TREE
11937 || !host_integerp (TYPE_MIN_VALUE (TYPE_DOMAIN (type
)), 0))
11940 fieldsize
= int_size_in_bytes (TREE_TYPE (type
));
11941 if (fieldsize
<= 0)
11944 min_index
= tree_low_cst (TYPE_MIN_VALUE (TYPE_DOMAIN (type
)), 0);
11945 memset (array
, '\0', size
);
11947 VEC_iterate (constructor_elt
, CONSTRUCTOR_ELTS (init
), cnt
, ce
);
11950 tree val
= ce
->value
;
11951 tree index
= ce
->index
;
11953 if (index
&& TREE_CODE (index
) == RANGE_EXPR
)
11954 pos
= (tree_low_cst (TREE_OPERAND (index
, 0), 0) - min_index
)
11957 pos
= (tree_low_cst (index
, 0) - min_index
) * fieldsize
;
11962 if (!native_encode_initializer (val
, array
+ pos
, fieldsize
))
11965 curpos
= pos
+ fieldsize
;
11966 if (index
&& TREE_CODE (index
) == RANGE_EXPR
)
11968 int count
= tree_low_cst (TREE_OPERAND (index
, 1), 0)
11969 - tree_low_cst (TREE_OPERAND (index
, 0), 0);
11973 memcpy (array
+ curpos
, array
+ pos
, fieldsize
);
11974 curpos
+= fieldsize
;
11977 gcc_assert (curpos
<= size
);
11981 else if (TREE_CODE (type
) == RECORD_TYPE
11982 || TREE_CODE (type
) == UNION_TYPE
)
11984 tree field
= NULL_TREE
;
11985 unsigned HOST_WIDE_INT cnt
;
11986 constructor_elt
*ce
;
11988 if (int_size_in_bytes (type
) != size
)
11991 if (TREE_CODE (type
) == RECORD_TYPE
)
11992 field
= TYPE_FIELDS (type
);
11995 VEC_iterate (constructor_elt
, CONSTRUCTOR_ELTS (init
), cnt
, ce
);
11996 cnt
++, field
= field
? TREE_CHAIN (field
) : 0)
11998 tree val
= ce
->value
;
11999 int pos
, fieldsize
;
12001 if (ce
->index
!= 0)
12007 if (field
== NULL_TREE
|| DECL_BIT_FIELD (field
))
12010 if (TREE_CODE (TREE_TYPE (field
)) == ARRAY_TYPE
12011 && TYPE_DOMAIN (TREE_TYPE (field
))
12012 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (field
))))
12014 else if (DECL_SIZE_UNIT (field
) == NULL_TREE
12015 || !host_integerp (DECL_SIZE_UNIT (field
), 0))
12017 fieldsize
= tree_low_cst (DECL_SIZE_UNIT (field
), 0);
12018 pos
= int_byte_position (field
);
12019 gcc_assert (pos
+ fieldsize
<= size
);
12021 && !native_encode_initializer (val
, array
+ pos
, fieldsize
))
12027 case VIEW_CONVERT_EXPR
:
12028 case NON_LVALUE_EXPR
:
12029 return native_encode_initializer (TREE_OPERAND (init
, 0), array
, size
);
12031 return native_encode_expr (init
, array
, size
) == size
;
12035 /* If we don't have a copy of this variable in memory for some reason (such
12036 as a C++ member constant that doesn't have an out-of-line definition),
12037 we should tell the debugger about the constant value. */
12040 tree_add_const_value_attribute (dw_die_ref var_die
, tree decl
)
12043 tree type
= TREE_TYPE (decl
);
12046 if (TREE_CODE (decl
) != VAR_DECL
&& TREE_CODE (decl
) != CONST_DECL
)
12049 init
= DECL_INITIAL (decl
);
12050 if (TREE_READONLY (decl
) && ! TREE_THIS_VOLATILE (decl
) && init
)
12055 rtl
= rtl_for_decl_init (init
, type
);
12057 add_const_value_attribute (var_die
, rtl
);
12058 /* If the host and target are sane, try harder. */
12059 else if (CHAR_BIT
== 8 && BITS_PER_UNIT
== 8
12060 && initializer_constant_valid_p (init
, type
))
12062 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (init
));
12063 if (size
> 0 && (int) size
== size
)
12065 unsigned char *array
= GGC_CNEWVEC (unsigned char, size
);
12067 if (native_encode_initializer (init
, array
, size
))
12068 add_AT_vec (var_die
, DW_AT_const_value
, size
, 1, array
);
12073 /* Convert the CFI instructions for the current function into a
12074 location list. This is used for DW_AT_frame_base when we targeting
12075 a dwarf2 consumer that does not support the dwarf3
12076 DW_OP_call_frame_cfa. OFFSET is a constant to be added to all CFA
12079 static dw_loc_list_ref
12080 convert_cfa_to_fb_loc_list (HOST_WIDE_INT offset
)
12083 dw_loc_list_ref list
, *list_tail
;
12085 dw_cfa_location last_cfa
, next_cfa
;
12086 const char *start_label
, *last_label
, *section
;
12088 fde
= current_fde ();
12089 gcc_assert (fde
!= NULL
);
12091 section
= secname_for_decl (current_function_decl
);
12095 next_cfa
.reg
= INVALID_REGNUM
;
12096 next_cfa
.offset
= 0;
12097 next_cfa
.indirect
= 0;
12098 next_cfa
.base_offset
= 0;
12100 start_label
= fde
->dw_fde_begin
;
12102 /* ??? Bald assumption that the CIE opcode list does not contain
12103 advance opcodes. */
12104 for (cfi
= cie_cfi_head
; cfi
; cfi
= cfi
->dw_cfi_next
)
12105 lookup_cfa_1 (cfi
, &next_cfa
);
12107 last_cfa
= next_cfa
;
12108 last_label
= start_label
;
12110 for (cfi
= fde
->dw_fde_cfi
; cfi
; cfi
= cfi
->dw_cfi_next
)
12111 switch (cfi
->dw_cfi_opc
)
12113 case DW_CFA_set_loc
:
12114 case DW_CFA_advance_loc1
:
12115 case DW_CFA_advance_loc2
:
12116 case DW_CFA_advance_loc4
:
12117 if (!cfa_equal_p (&last_cfa
, &next_cfa
))
12119 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
12120 start_label
, last_label
, section
,
12123 list_tail
= &(*list_tail
)->dw_loc_next
;
12124 last_cfa
= next_cfa
;
12125 start_label
= last_label
;
12127 last_label
= cfi
->dw_cfi_oprnd1
.dw_cfi_addr
;
12130 case DW_CFA_advance_loc
:
12131 /* The encoding is complex enough that we should never emit this. */
12132 case DW_CFA_remember_state
:
12133 case DW_CFA_restore_state
:
12134 /* We don't handle these two in this function. It would be possible
12135 if it were to be required. */
12136 gcc_unreachable ();
12139 lookup_cfa_1 (cfi
, &next_cfa
);
12143 if (!cfa_equal_p (&last_cfa
, &next_cfa
))
12145 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
12146 start_label
, last_label
, section
,
12148 list_tail
= &(*list_tail
)->dw_loc_next
;
12149 start_label
= last_label
;
12151 *list_tail
= new_loc_list (build_cfa_loc (&next_cfa
, offset
),
12152 start_label
, fde
->dw_fde_end
, section
,
12158 /* Compute a displacement from the "steady-state frame pointer" to the
12159 frame base (often the same as the CFA), and store it in
12160 frame_pointer_fb_offset. OFFSET is added to the displacement
12161 before the latter is negated. */
12164 compute_frame_pointer_to_fb_displacement (HOST_WIDE_INT offset
)
12168 #ifdef FRAME_POINTER_CFA_OFFSET
12169 reg
= frame_pointer_rtx
;
12170 offset
+= FRAME_POINTER_CFA_OFFSET (current_function_decl
);
12172 reg
= arg_pointer_rtx
;
12173 offset
+= ARG_POINTER_CFA_OFFSET (current_function_decl
);
12176 elim
= eliminate_regs (reg
, VOIDmode
, NULL_RTX
);
12177 if (GET_CODE (elim
) == PLUS
)
12179 offset
+= INTVAL (XEXP (elim
, 1));
12180 elim
= XEXP (elim
, 0);
12183 gcc_assert ((SUPPORTS_STACK_ALIGNMENT
12184 && (elim
== hard_frame_pointer_rtx
12185 || elim
== stack_pointer_rtx
))
12186 || elim
== (frame_pointer_needed
12187 ? hard_frame_pointer_rtx
12188 : stack_pointer_rtx
));
12190 frame_pointer_fb_offset
= -offset
;
12193 /* Generate a DW_AT_name attribute given some string value to be included as
12194 the value of the attribute. */
12197 add_name_attribute (dw_die_ref die
, const char *name_string
)
12199 if (name_string
!= NULL
&& *name_string
!= 0)
12201 if (demangle_name_func
)
12202 name_string
= (*demangle_name_func
) (name_string
);
12204 add_AT_string (die
, DW_AT_name
, name_string
);
12208 /* Generate a DW_AT_comp_dir attribute for DIE. */
12211 add_comp_dir_attribute (dw_die_ref die
)
12213 const char *wd
= get_src_pwd ();
12215 add_AT_string (die
, DW_AT_comp_dir
, remap_debug_filename (wd
));
12218 /* Given a tree node describing an array bound (either lower or upper) output
12219 a representation for that bound. */
12222 add_bound_info (dw_die_ref subrange_die
, enum dwarf_attribute bound_attr
, tree bound
)
12224 switch (TREE_CODE (bound
))
12229 /* All fixed-bounds are represented by INTEGER_CST nodes. */
12231 if (! host_integerp (bound
, 0)
12232 || (bound_attr
== DW_AT_lower_bound
12233 && (((is_c_family () || is_java ()) && integer_zerop (bound
))
12234 || (is_fortran () && integer_onep (bound
)))))
12235 /* Use the default. */
12238 add_AT_unsigned (subrange_die
, bound_attr
, tree_low_cst (bound
, 0));
12242 case VIEW_CONVERT_EXPR
:
12243 add_bound_info (subrange_die
, bound_attr
, TREE_OPERAND (bound
, 0));
12253 dw_die_ref decl_die
= lookup_decl_die (bound
);
12254 dw_loc_descr_ref loc
;
12256 /* ??? Can this happen, or should the variable have been bound
12257 first? Probably it can, since I imagine that we try to create
12258 the types of parameters in the order in which they exist in
12259 the list, and won't have created a forward reference to a
12260 later parameter. */
12261 if (decl_die
!= NULL
)
12262 add_AT_die_ref (subrange_die
, bound_attr
, decl_die
);
12265 loc
= loc_descriptor_from_tree_1 (bound
, 0);
12266 add_AT_location_description (subrange_die
, bound_attr
, loc
);
12273 /* Otherwise try to create a stack operation procedure to
12274 evaluate the value of the array bound. */
12276 dw_die_ref ctx
, decl_die
;
12277 dw_loc_descr_ref loc
;
12279 loc
= loc_descriptor_from_tree (bound
);
12283 if (current_function_decl
== 0)
12284 ctx
= comp_unit_die
;
12286 ctx
= lookup_decl_die (current_function_decl
);
12288 decl_die
= new_die (DW_TAG_variable
, ctx
, bound
);
12289 add_AT_flag (decl_die
, DW_AT_artificial
, 1);
12290 add_type_attribute (decl_die
, TREE_TYPE (bound
), 1, 0, ctx
);
12291 add_AT_loc (decl_die
, DW_AT_location
, loc
);
12293 add_AT_die_ref (subrange_die
, bound_attr
, decl_die
);
12299 /* Add subscript info to TYPE_DIE, describing an array TYPE, collapsing
12300 possibly nested array subscripts in a flat sequence if COLLAPSE_P is true.
12301 Note that the block of subscript information for an array type also
12302 includes information about the element type of the given array type. */
12305 add_subscript_info (dw_die_ref type_die
, tree type
, bool collapse_p
)
12307 unsigned dimension_number
;
12309 dw_die_ref subrange_die
;
12311 for (dimension_number
= 0;
12312 TREE_CODE (type
) == ARRAY_TYPE
&& (dimension_number
== 0 || collapse_p
);
12313 type
= TREE_TYPE (type
), dimension_number
++)
12315 tree domain
= TYPE_DOMAIN (type
);
12317 if (TYPE_STRING_FLAG (type
) && is_fortran () && dimension_number
> 0)
12320 /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
12321 and (in GNU C only) variable bounds. Handle all three forms
12323 subrange_die
= new_die (DW_TAG_subrange_type
, type_die
, NULL
);
12326 /* We have an array type with specified bounds. */
12327 lower
= TYPE_MIN_VALUE (domain
);
12328 upper
= TYPE_MAX_VALUE (domain
);
12330 /* Define the index type. */
12331 if (TREE_TYPE (domain
))
12333 /* ??? This is probably an Ada unnamed subrange type. Ignore the
12334 TREE_TYPE field. We can't emit debug info for this
12335 because it is an unnamed integral type. */
12336 if (TREE_CODE (domain
) == INTEGER_TYPE
12337 && TYPE_NAME (domain
) == NULL_TREE
12338 && TREE_CODE (TREE_TYPE (domain
)) == INTEGER_TYPE
12339 && TYPE_NAME (TREE_TYPE (domain
)) == NULL_TREE
)
12342 add_type_attribute (subrange_die
, TREE_TYPE (domain
), 0, 0,
12346 /* ??? If upper is NULL, the array has unspecified length,
12347 but it does have a lower bound. This happens with Fortran
12349 Since the debugger is definitely going to need to know N
12350 to produce useful results, go ahead and output the lower
12351 bound solo, and hope the debugger can cope. */
12353 add_bound_info (subrange_die
, DW_AT_lower_bound
, lower
);
12355 add_bound_info (subrange_die
, DW_AT_upper_bound
, upper
);
12358 /* Otherwise we have an array type with an unspecified length. The
12359 DWARF-2 spec does not say how to handle this; let's just leave out the
12365 add_byte_size_attribute (dw_die_ref die
, tree tree_node
)
12369 switch (TREE_CODE (tree_node
))
12374 case ENUMERAL_TYPE
:
12377 case QUAL_UNION_TYPE
:
12378 size
= int_size_in_bytes (tree_node
);
12381 /* For a data member of a struct or union, the DW_AT_byte_size is
12382 generally given as the number of bytes normally allocated for an
12383 object of the *declared* type of the member itself. This is true
12384 even for bit-fields. */
12385 size
= simple_type_size_in_bits (field_type (tree_node
)) / BITS_PER_UNIT
;
12388 gcc_unreachable ();
12391 /* Note that `size' might be -1 when we get to this point. If it is, that
12392 indicates that the byte size of the entity in question is variable. We
12393 have no good way of expressing this fact in Dwarf at the present time,
12394 so just let the -1 pass on through. */
12395 add_AT_unsigned (die
, DW_AT_byte_size
, size
);
12398 /* For a FIELD_DECL node which represents a bit-field, output an attribute
12399 which specifies the distance in bits from the highest order bit of the
12400 "containing object" for the bit-field to the highest order bit of the
12403 For any given bit-field, the "containing object" is a hypothetical object
12404 (of some integral or enum type) within which the given bit-field lives. The
12405 type of this hypothetical "containing object" is always the same as the
12406 declared type of the individual bit-field itself. The determination of the
12407 exact location of the "containing object" for a bit-field is rather
12408 complicated. It's handled by the `field_byte_offset' function (above).
12410 Note that it is the size (in bytes) of the hypothetical "containing object"
12411 which will be given in the DW_AT_byte_size attribute for this bit-field.
12412 (See `byte_size_attribute' above). */
12415 add_bit_offset_attribute (dw_die_ref die
, tree decl
)
12417 HOST_WIDE_INT object_offset_in_bytes
= field_byte_offset (decl
);
12418 tree type
= DECL_BIT_FIELD_TYPE (decl
);
12419 HOST_WIDE_INT bitpos_int
;
12420 HOST_WIDE_INT highest_order_object_bit_offset
;
12421 HOST_WIDE_INT highest_order_field_bit_offset
;
12422 HOST_WIDE_INT
unsigned bit_offset
;
12424 /* Must be a field and a bit field. */
12425 gcc_assert (type
&& TREE_CODE (decl
) == FIELD_DECL
);
12427 /* We can't yet handle bit-fields whose offsets are variable, so if we
12428 encounter such things, just return without generating any attribute
12429 whatsoever. Likewise for variable or too large size. */
12430 if (! host_integerp (bit_position (decl
), 0)
12431 || ! host_integerp (DECL_SIZE (decl
), 1))
12434 bitpos_int
= int_bit_position (decl
);
12436 /* Note that the bit offset is always the distance (in bits) from the
12437 highest-order bit of the "containing object" to the highest-order bit of
12438 the bit-field itself. Since the "high-order end" of any object or field
12439 is different on big-endian and little-endian machines, the computation
12440 below must take account of these differences. */
12441 highest_order_object_bit_offset
= object_offset_in_bytes
* BITS_PER_UNIT
;
12442 highest_order_field_bit_offset
= bitpos_int
;
12444 if (! BYTES_BIG_ENDIAN
)
12446 highest_order_field_bit_offset
+= tree_low_cst (DECL_SIZE (decl
), 0);
12447 highest_order_object_bit_offset
+= simple_type_size_in_bits (type
);
12451 = (! BYTES_BIG_ENDIAN
12452 ? highest_order_object_bit_offset
- highest_order_field_bit_offset
12453 : highest_order_field_bit_offset
- highest_order_object_bit_offset
);
12455 add_AT_unsigned (die
, DW_AT_bit_offset
, bit_offset
);
12458 /* For a FIELD_DECL node which represents a bit field, output an attribute
12459 which specifies the length in bits of the given field. */
12462 add_bit_size_attribute (dw_die_ref die
, tree decl
)
12464 /* Must be a field and a bit field. */
12465 gcc_assert (TREE_CODE (decl
) == FIELD_DECL
12466 && DECL_BIT_FIELD_TYPE (decl
));
12468 if (host_integerp (DECL_SIZE (decl
), 1))
12469 add_AT_unsigned (die
, DW_AT_bit_size
, tree_low_cst (DECL_SIZE (decl
), 1));
12472 /* If the compiled language is ANSI C, then add a 'prototyped'
12473 attribute, if arg types are given for the parameters of a function. */
12476 add_prototyped_attribute (dw_die_ref die
, tree func_type
)
12478 if (get_AT_unsigned (comp_unit_die
, DW_AT_language
) == DW_LANG_C89
12479 && TYPE_ARG_TYPES (func_type
) != NULL
)
12480 add_AT_flag (die
, DW_AT_prototyped
, 1);
12483 /* Add an 'abstract_origin' attribute below a given DIE. The DIE is found
12484 by looking in either the type declaration or object declaration
12487 static inline dw_die_ref
12488 add_abstract_origin_attribute (dw_die_ref die
, tree origin
)
12490 dw_die_ref origin_die
= NULL
;
12492 if (TREE_CODE (origin
) != FUNCTION_DECL
)
12494 /* We may have gotten separated from the block for the inlined
12495 function, if we're in an exception handler or some such; make
12496 sure that the abstract function has been written out.
12498 Doing this for nested functions is wrong, however; functions are
12499 distinct units, and our context might not even be inline. */
12503 fn
= TYPE_STUB_DECL (fn
);
12505 fn
= decl_function_context (fn
);
12507 dwarf2out_abstract_function (fn
);
12510 if (DECL_P (origin
))
12511 origin_die
= lookup_decl_die (origin
);
12512 else if (TYPE_P (origin
))
12513 origin_die
= lookup_type_die (origin
);
12515 /* XXX: Functions that are never lowered don't always have correct block
12516 trees (in the case of java, they simply have no block tree, in some other
12517 languages). For these functions, there is nothing we can really do to
12518 output correct debug info for inlined functions in all cases. Rather
12519 than die, we'll just produce deficient debug info now, in that we will
12520 have variables without a proper abstract origin. In the future, when all
12521 functions are lowered, we should re-add a gcc_assert (origin_die)
12525 add_AT_die_ref (die
, DW_AT_abstract_origin
, origin_die
);
12529 /* We do not currently support the pure_virtual attribute. */
12532 add_pure_or_virtual_attribute (dw_die_ref die
, tree func_decl
)
12534 if (DECL_VINDEX (func_decl
))
12536 add_AT_unsigned (die
, DW_AT_virtuality
, DW_VIRTUALITY_virtual
);
12538 if (host_integerp (DECL_VINDEX (func_decl
), 0))
12539 add_AT_loc (die
, DW_AT_vtable_elem_location
,
12540 new_loc_descr (DW_OP_constu
,
12541 tree_low_cst (DECL_VINDEX (func_decl
), 0),
12544 /* GNU extension: Record what type this method came from originally. */
12545 if (debug_info_level
> DINFO_LEVEL_TERSE
)
12546 add_AT_die_ref (die
, DW_AT_containing_type
,
12547 lookup_type_die (DECL_CONTEXT (func_decl
)));
12551 /* Add source coordinate attributes for the given decl. */
12554 add_src_coords_attributes (dw_die_ref die
, tree decl
)
12556 expanded_location s
= expand_location (DECL_SOURCE_LOCATION (decl
));
12558 add_AT_file (die
, DW_AT_decl_file
, lookup_filename (s
.file
));
12559 add_AT_unsigned (die
, DW_AT_decl_line
, s
.line
);
12562 /* Add a DW_AT_name attribute and source coordinate attribute for the
12563 given decl, but only if it actually has a name. */
12566 add_name_and_src_coords_attributes (dw_die_ref die
, tree decl
)
12570 decl_name
= DECL_NAME (decl
);
12571 if (decl_name
!= NULL
&& IDENTIFIER_POINTER (decl_name
) != NULL
)
12573 add_name_attribute (die
, dwarf2_name (decl
, 0));
12574 if (! DECL_ARTIFICIAL (decl
))
12575 add_src_coords_attributes (die
, decl
);
12577 if ((TREE_CODE (decl
) == FUNCTION_DECL
|| TREE_CODE (decl
) == VAR_DECL
)
12578 && TREE_PUBLIC (decl
)
12579 && DECL_ASSEMBLER_NAME (decl
) != DECL_NAME (decl
)
12580 && !DECL_ABSTRACT (decl
)
12581 && !(TREE_CODE (decl
) == VAR_DECL
&& DECL_REGISTER (decl
))
12583 add_AT_string (die
, DW_AT_MIPS_linkage_name
,
12584 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)));
12587 #ifdef VMS_DEBUGGING_INFO
12588 /* Get the function's name, as described by its RTL. This may be different
12589 from the DECL_NAME name used in the source file. */
12590 if (TREE_CODE (decl
) == FUNCTION_DECL
&& TREE_ASM_WRITTEN (decl
))
12592 add_AT_addr (die
, DW_AT_VMS_rtnbeg_pd_address
,
12593 XEXP (DECL_RTL (decl
), 0));
12594 VEC_safe_push (tree
, gc
, used_rtx_array
, XEXP (DECL_RTL (decl
), 0));
12599 /* Push a new declaration scope. */
12602 push_decl_scope (tree scope
)
12604 VEC_safe_push (tree
, gc
, decl_scope_table
, scope
);
12607 /* Pop a declaration scope. */
12610 pop_decl_scope (void)
12612 VEC_pop (tree
, decl_scope_table
);
12615 /* Return the DIE for the scope that immediately contains this type.
12616 Non-named types get global scope. Named types nested in other
12617 types get their containing scope if it's open, or global scope
12618 otherwise. All other types (i.e. function-local named types) get
12619 the current active scope. */
12622 scope_die_for (tree t
, dw_die_ref context_die
)
12624 dw_die_ref scope_die
= NULL
;
12625 tree containing_scope
;
12628 /* Non-types always go in the current scope. */
12629 gcc_assert (TYPE_P (t
));
12631 containing_scope
= TYPE_CONTEXT (t
);
12633 /* Use the containing namespace if it was passed in (for a declaration). */
12634 if (containing_scope
&& TREE_CODE (containing_scope
) == NAMESPACE_DECL
)
12636 if (context_die
== lookup_decl_die (containing_scope
))
12639 containing_scope
= NULL_TREE
;
12642 /* Ignore function type "scopes" from the C frontend. They mean that
12643 a tagged type is local to a parmlist of a function declarator, but
12644 that isn't useful to DWARF. */
12645 if (containing_scope
&& TREE_CODE (containing_scope
) == FUNCTION_TYPE
)
12646 containing_scope
= NULL_TREE
;
12648 if (containing_scope
== NULL_TREE
)
12649 scope_die
= comp_unit_die
;
12650 else if (TYPE_P (containing_scope
))
12652 /* For types, we can just look up the appropriate DIE. But
12653 first we check to see if we're in the middle of emitting it
12654 so we know where the new DIE should go. */
12655 for (i
= VEC_length (tree
, decl_scope_table
) - 1; i
>= 0; --i
)
12656 if (VEC_index (tree
, decl_scope_table
, i
) == containing_scope
)
12661 gcc_assert (debug_info_level
<= DINFO_LEVEL_TERSE
12662 || TREE_ASM_WRITTEN (containing_scope
));
12664 /* If none of the current dies are suitable, we get file scope. */
12665 scope_die
= comp_unit_die
;
12668 scope_die
= lookup_type_die (containing_scope
);
12671 scope_die
= context_die
;
12676 /* Returns nonzero if CONTEXT_DIE is internal to a function. */
12679 local_scope_p (dw_die_ref context_die
)
12681 for (; context_die
; context_die
= context_die
->die_parent
)
12682 if (context_die
->die_tag
== DW_TAG_inlined_subroutine
12683 || context_die
->die_tag
== DW_TAG_subprogram
)
12689 /* Returns nonzero if CONTEXT_DIE is a class. */
12692 class_scope_p (dw_die_ref context_die
)
12694 return (context_die
12695 && (context_die
->die_tag
== DW_TAG_structure_type
12696 || context_die
->die_tag
== DW_TAG_class_type
12697 || context_die
->die_tag
== DW_TAG_interface_type
12698 || context_die
->die_tag
== DW_TAG_union_type
));
12701 /* Returns nonzero if CONTEXT_DIE is a class or namespace, for deciding
12702 whether or not to treat a DIE in this context as a declaration. */
12705 class_or_namespace_scope_p (dw_die_ref context_die
)
12707 return (class_scope_p (context_die
)
12708 || (context_die
&& context_die
->die_tag
== DW_TAG_namespace
));
12711 /* Many forms of DIEs require a "type description" attribute. This
12712 routine locates the proper "type descriptor" die for the type given
12713 by 'type', and adds a DW_AT_type attribute below the given die. */
12716 add_type_attribute (dw_die_ref object_die
, tree type
, int decl_const
,
12717 int decl_volatile
, dw_die_ref context_die
)
12719 enum tree_code code
= TREE_CODE (type
);
12720 dw_die_ref type_die
= NULL
;
12722 /* ??? If this type is an unnamed subrange type of an integral, floating-point
12723 or fixed-point type, use the inner type. This is because we have no
12724 support for unnamed types in base_type_die. This can happen if this is
12725 an Ada subrange type. Correct solution is emit a subrange type die. */
12726 if ((code
== INTEGER_TYPE
|| code
== REAL_TYPE
|| code
== FIXED_POINT_TYPE
)
12727 && TREE_TYPE (type
) != 0 && TYPE_NAME (type
) == 0)
12728 type
= TREE_TYPE (type
), code
= TREE_CODE (type
);
12730 if (code
== ERROR_MARK
12731 /* Handle a special case. For functions whose return type is void, we
12732 generate *no* type attribute. (Note that no object may have type
12733 `void', so this only applies to function return types). */
12734 || code
== VOID_TYPE
)
12737 type_die
= modified_type_die (type
,
12738 decl_const
|| TYPE_READONLY (type
),
12739 decl_volatile
|| TYPE_VOLATILE (type
),
12742 if (type_die
!= NULL
)
12743 add_AT_die_ref (object_die
, DW_AT_type
, type_die
);
12746 /* Given an object die, add the calling convention attribute for the
12747 function call type. */
12749 add_calling_convention_attribute (dw_die_ref subr_die
, tree decl
)
12751 enum dwarf_calling_convention value
= DW_CC_normal
;
12753 value
= ((enum dwarf_calling_convention
)
12754 targetm
.dwarf_calling_convention (TREE_TYPE (decl
)));
12756 /* DWARF doesn't provide a way to identify a program's source-level
12757 entry point. DW_AT_calling_convention attributes are only meant
12758 to describe functions' calling conventions. However, lacking a
12759 better way to signal the Fortran main program, we use this for the
12760 time being, following existing custom. */
12762 && !strcmp (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)), "MAIN__"))
12763 value
= DW_CC_program
;
12765 /* Only add the attribute if the backend requests it, and
12766 is not DW_CC_normal. */
12767 if (value
&& (value
!= DW_CC_normal
))
12768 add_AT_unsigned (subr_die
, DW_AT_calling_convention
, value
);
12771 /* Given a tree pointer to a struct, class, union, or enum type node, return
12772 a pointer to the (string) tag name for the given type, or zero if the type
12773 was declared without a tag. */
12775 static const char *
12776 type_tag (const_tree type
)
12778 const char *name
= 0;
12780 if (TYPE_NAME (type
) != 0)
12784 /* Find the IDENTIFIER_NODE for the type name. */
12785 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
12786 t
= TYPE_NAME (type
);
12788 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
12789 a TYPE_DECL node, regardless of whether or not a `typedef' was
12791 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
12792 && ! DECL_IGNORED_P (TYPE_NAME (type
)))
12794 /* We want to be extra verbose. Don't call dwarf_name if
12795 DECL_NAME isn't set. The default hook for decl_printable_name
12796 doesn't like that, and in this context it's correct to return
12797 0, instead of "<anonymous>" or the like. */
12798 if (DECL_NAME (TYPE_NAME (type
)))
12799 name
= lang_hooks
.dwarf_name (TYPE_NAME (type
), 2);
12802 /* Now get the name as a string, or invent one. */
12803 if (!name
&& t
!= 0)
12804 name
= IDENTIFIER_POINTER (t
);
12807 return (name
== 0 || *name
== '\0') ? 0 : name
;
12810 /* Return the type associated with a data member, make a special check
12811 for bit field types. */
12814 member_declared_type (const_tree member
)
12816 return (DECL_BIT_FIELD_TYPE (member
)
12817 ? DECL_BIT_FIELD_TYPE (member
) : TREE_TYPE (member
));
12820 /* Get the decl's label, as described by its RTL. This may be different
12821 from the DECL_NAME name used in the source file. */
12824 static const char *
12825 decl_start_label (tree decl
)
12828 const char *fnname
;
12830 x
= DECL_RTL (decl
);
12831 gcc_assert (MEM_P (x
));
12834 gcc_assert (GET_CODE (x
) == SYMBOL_REF
);
12836 fnname
= XSTR (x
, 0);
12841 /* These routines generate the internal representation of the DIE's for
12842 the compilation unit. Debugging information is collected by walking
12843 the declaration trees passed in from dwarf2out_decl(). */
12846 gen_array_type_die (tree type
, dw_die_ref context_die
)
12848 dw_die_ref scope_die
= scope_die_for (type
, context_die
);
12849 dw_die_ref array_die
;
12851 /* GNU compilers represent multidimensional array types as sequences of one
12852 dimensional array types whose element types are themselves array types.
12853 We sometimes squish that down to a single array_type DIE with multiple
12854 subscripts in the Dwarf debugging info. The draft Dwarf specification
12855 say that we are allowed to do this kind of compression in C, because
12856 there is no difference between an array of arrays and a multidimensional
12857 array. We don't do this for Ada to remain as close as possible to the
12858 actual representation, which is especially important against the language
12859 flexibilty wrt arrays of variable size. */
12861 bool collapse_nested_arrays
= !is_ada ();
12864 /* Emit DW_TAG_string_type for Fortran character types (with kind 1 only, as
12865 DW_TAG_string_type doesn't have DW_AT_type attribute). */
12866 if (TYPE_STRING_FLAG (type
)
12867 && TREE_CODE (type
) == ARRAY_TYPE
12869 && TYPE_MODE (TREE_TYPE (type
)) == TYPE_MODE (char_type_node
))
12871 HOST_WIDE_INT size
;
12873 array_die
= new_die (DW_TAG_string_type
, scope_die
, type
);
12874 add_name_attribute (array_die
, type_tag (type
));
12875 equate_type_number_to_die (type
, array_die
);
12876 size
= int_size_in_bytes (type
);
12878 add_AT_unsigned (array_die
, DW_AT_byte_size
, size
);
12879 else if (TYPE_DOMAIN (type
) != NULL_TREE
12880 && TYPE_MAX_VALUE (TYPE_DOMAIN (type
)) != NULL_TREE
12881 && DECL_P (TYPE_MAX_VALUE (TYPE_DOMAIN (type
))))
12883 tree szdecl
= TYPE_MAX_VALUE (TYPE_DOMAIN (type
));
12884 dw_loc_descr_ref loc
= loc_descriptor_from_tree (szdecl
);
12886 size
= int_size_in_bytes (TREE_TYPE (szdecl
));
12887 if (loc
&& size
> 0)
12889 add_AT_loc (array_die
, DW_AT_string_length
, loc
);
12890 if (size
!= DWARF2_ADDR_SIZE
)
12891 add_AT_unsigned (array_die
, DW_AT_byte_size
, size
);
12897 /* ??? The SGI dwarf reader fails for array of array of enum types
12898 (e.g. const enum machine_mode insn_operand_mode[2][10]) unless the inner
12899 array type comes before the outer array type. We thus call gen_type_die
12900 before we new_die and must prevent nested array types collapsing for this
12903 #ifdef MIPS_DEBUGGING_INFO
12904 gen_type_die (TREE_TYPE (type
), context_die
);
12905 collapse_nested_arrays
= false;
12908 array_die
= new_die (DW_TAG_array_type
, scope_die
, type
);
12909 add_name_attribute (array_die
, type_tag (type
));
12910 equate_type_number_to_die (type
, array_die
);
12912 if (TREE_CODE (type
) == VECTOR_TYPE
)
12914 /* The frontend feeds us a representation for the vector as a struct
12915 containing an array. Pull out the array type. */
12916 type
= TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type
)));
12917 add_AT_flag (array_die
, DW_AT_GNU_vector
, 1);
12920 /* For Fortran multidimensional arrays use DW_ORD_col_major ordering. */
12922 && TREE_CODE (type
) == ARRAY_TYPE
12923 && TREE_CODE (TREE_TYPE (type
)) == ARRAY_TYPE
12924 && !TYPE_STRING_FLAG (TREE_TYPE (type
)))
12925 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_col_major
);
12928 /* We default the array ordering. SDB will probably do
12929 the right things even if DW_AT_ordering is not present. It's not even
12930 an issue until we start to get into multidimensional arrays anyway. If
12931 SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
12932 then we'll have to put the DW_AT_ordering attribute back in. (But if
12933 and when we find out that we need to put these in, we will only do so
12934 for multidimensional arrays. */
12935 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_row_major
);
12938 #ifdef MIPS_DEBUGGING_INFO
12939 /* The SGI compilers handle arrays of unknown bound by setting
12940 AT_declaration and not emitting any subrange DIEs. */
12941 if (! TYPE_DOMAIN (type
))
12942 add_AT_flag (array_die
, DW_AT_declaration
, 1);
12945 add_subscript_info (array_die
, type
, collapse_nested_arrays
);
12947 /* Add representation of the type of the elements of this array type and
12948 emit the corresponding DIE if we haven't done it already. */
12949 element_type
= TREE_TYPE (type
);
12950 if (collapse_nested_arrays
)
12951 while (TREE_CODE (element_type
) == ARRAY_TYPE
)
12953 if (TYPE_STRING_FLAG (element_type
) && is_fortran ())
12955 element_type
= TREE_TYPE (element_type
);
12958 #ifndef MIPS_DEBUGGING_INFO
12959 gen_type_die (element_type
, context_die
);
12962 add_type_attribute (array_die
, element_type
, 0, 0, context_die
);
12964 if (get_AT (array_die
, DW_AT_name
))
12965 add_pubtype (type
, array_die
);
12968 static dw_loc_descr_ref
12969 descr_info_loc (tree val
, tree base_decl
)
12971 HOST_WIDE_INT size
;
12972 dw_loc_descr_ref loc
, loc2
;
12973 enum dwarf_location_atom op
;
12975 if (val
== base_decl
)
12976 return new_loc_descr (DW_OP_push_object_address
, 0, 0);
12978 switch (TREE_CODE (val
))
12981 return descr_info_loc (TREE_OPERAND (val
, 0), base_decl
);
12983 return loc_descriptor_from_tree_1 (val
, 0);
12985 if (host_integerp (val
, 0))
12986 return int_loc_descriptor (tree_low_cst (val
, 0));
12989 size
= int_size_in_bytes (TREE_TYPE (val
));
12992 loc
= descr_info_loc (TREE_OPERAND (val
, 0), base_decl
);
12995 if (size
== DWARF2_ADDR_SIZE
)
12996 add_loc_descr (&loc
, new_loc_descr (DW_OP_deref
, 0, 0));
12998 add_loc_descr (&loc
, new_loc_descr (DW_OP_deref_size
, size
, 0));
13000 case POINTER_PLUS_EXPR
:
13002 if (host_integerp (TREE_OPERAND (val
, 1), 1)
13003 && (unsigned HOST_WIDE_INT
) tree_low_cst (TREE_OPERAND (val
, 1), 1)
13006 loc
= descr_info_loc (TREE_OPERAND (val
, 0), base_decl
);
13009 loc_descr_plus_const (&loc
, tree_low_cst (TREE_OPERAND (val
, 1), 0));
13015 loc
= descr_info_loc (TREE_OPERAND (val
, 0), base_decl
);
13018 loc2
= descr_info_loc (TREE_OPERAND (val
, 1), base_decl
);
13021 add_loc_descr (&loc
, loc2
);
13022 add_loc_descr (&loc2
, new_loc_descr (op
, 0, 0));
13044 add_descr_info_field (dw_die_ref die
, enum dwarf_attribute attr
,
13045 tree val
, tree base_decl
)
13047 dw_loc_descr_ref loc
;
13049 if (host_integerp (val
, 0))
13051 add_AT_unsigned (die
, attr
, tree_low_cst (val
, 0));
13055 loc
= descr_info_loc (val
, base_decl
);
13059 add_AT_loc (die
, attr
, loc
);
13062 /* This routine generates DIE for array with hidden descriptor, details
13063 are filled into *info by a langhook. */
13066 gen_descr_array_type_die (tree type
, struct array_descr_info
*info
,
13067 dw_die_ref context_die
)
13069 dw_die_ref scope_die
= scope_die_for (type
, context_die
);
13070 dw_die_ref array_die
;
13073 array_die
= new_die (DW_TAG_array_type
, scope_die
, type
);
13074 add_name_attribute (array_die
, type_tag (type
));
13075 equate_type_number_to_die (type
, array_die
);
13077 /* For Fortran multidimensional arrays use DW_ORD_col_major ordering. */
13079 && info
->ndimensions
>= 2)
13080 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_col_major
);
13082 if (info
->data_location
)
13083 add_descr_info_field (array_die
, DW_AT_data_location
, info
->data_location
,
13085 if (info
->associated
)
13086 add_descr_info_field (array_die
, DW_AT_associated
, info
->associated
,
13088 if (info
->allocated
)
13089 add_descr_info_field (array_die
, DW_AT_allocated
, info
->allocated
,
13092 for (dim
= 0; dim
< info
->ndimensions
; dim
++)
13094 dw_die_ref subrange_die
13095 = new_die (DW_TAG_subrange_type
, array_die
, NULL
);
13097 if (info
->dimen
[dim
].lower_bound
)
13099 /* If it is the default value, omit it. */
13100 if ((is_c_family () || is_java ())
13101 && integer_zerop (info
->dimen
[dim
].lower_bound
))
13103 else if (is_fortran ()
13104 && integer_onep (info
->dimen
[dim
].lower_bound
))
13107 add_descr_info_field (subrange_die
, DW_AT_lower_bound
,
13108 info
->dimen
[dim
].lower_bound
,
13111 if (info
->dimen
[dim
].upper_bound
)
13112 add_descr_info_field (subrange_die
, DW_AT_upper_bound
,
13113 info
->dimen
[dim
].upper_bound
,
13115 if (info
->dimen
[dim
].stride
)
13116 add_descr_info_field (subrange_die
, DW_AT_byte_stride
,
13117 info
->dimen
[dim
].stride
,
13121 gen_type_die (info
->element_type
, context_die
);
13122 add_type_attribute (array_die
, info
->element_type
, 0, 0, context_die
);
13124 if (get_AT (array_die
, DW_AT_name
))
13125 add_pubtype (type
, array_die
);
13130 gen_entry_point_die (tree decl
, dw_die_ref context_die
)
13132 tree origin
= decl_ultimate_origin (decl
);
13133 dw_die_ref decl_die
= new_die (DW_TAG_entry_point
, context_die
, decl
);
13135 if (origin
!= NULL
)
13136 add_abstract_origin_attribute (decl_die
, origin
);
13139 add_name_and_src_coords_attributes (decl_die
, decl
);
13140 add_type_attribute (decl_die
, TREE_TYPE (TREE_TYPE (decl
)),
13141 0, 0, context_die
);
13144 if (DECL_ABSTRACT (decl
))
13145 equate_decl_number_to_die (decl
, decl_die
);
13147 add_AT_lbl_id (decl_die
, DW_AT_low_pc
, decl_start_label (decl
));
13151 /* Walk through the list of incomplete types again, trying once more to
13152 emit full debugging info for them. */
13155 retry_incomplete_types (void)
13159 for (i
= VEC_length (tree
, incomplete_types
) - 1; i
>= 0; i
--)
13160 gen_type_die (VEC_index (tree
, incomplete_types
, i
), comp_unit_die
);
13163 /* Determine what tag to use for a record type. */
13165 static enum dwarf_tag
13166 record_type_tag (tree type
)
13168 if (! lang_hooks
.types
.classify_record
)
13169 return DW_TAG_structure_type
;
13171 switch (lang_hooks
.types
.classify_record (type
))
13173 case RECORD_IS_STRUCT
:
13174 return DW_TAG_structure_type
;
13176 case RECORD_IS_CLASS
:
13177 return DW_TAG_class_type
;
13179 case RECORD_IS_INTERFACE
:
13180 return DW_TAG_interface_type
;
13183 gcc_unreachable ();
13187 /* Generate a DIE to represent an enumeration type. Note that these DIEs
13188 include all of the information about the enumeration values also. Each
13189 enumerated type name/value is listed as a child of the enumerated type
13193 gen_enumeration_type_die (tree type
, dw_die_ref context_die
)
13195 dw_die_ref type_die
= lookup_type_die (type
);
13197 if (type_die
== NULL
)
13199 type_die
= new_die (DW_TAG_enumeration_type
,
13200 scope_die_for (type
, context_die
), type
);
13201 equate_type_number_to_die (type
, type_die
);
13202 add_name_attribute (type_die
, type_tag (type
));
13204 else if (! TYPE_SIZE (type
))
13207 remove_AT (type_die
, DW_AT_declaration
);
13209 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the
13210 given enum type is incomplete, do not generate the DW_AT_byte_size
13211 attribute or the DW_AT_element_list attribute. */
13212 if (TYPE_SIZE (type
))
13216 TREE_ASM_WRITTEN (type
) = 1;
13217 add_byte_size_attribute (type_die
, type
);
13218 if (TYPE_STUB_DECL (type
) != NULL_TREE
)
13219 add_src_coords_attributes (type_die
, TYPE_STUB_DECL (type
));
13221 /* If the first reference to this type was as the return type of an
13222 inline function, then it may not have a parent. Fix this now. */
13223 if (type_die
->die_parent
== NULL
)
13224 add_child_die (scope_die_for (type
, context_die
), type_die
);
13226 for (link
= TYPE_VALUES (type
);
13227 link
!= NULL
; link
= TREE_CHAIN (link
))
13229 dw_die_ref enum_die
= new_die (DW_TAG_enumerator
, type_die
, link
);
13230 tree value
= TREE_VALUE (link
);
13232 add_name_attribute (enum_die
,
13233 IDENTIFIER_POINTER (TREE_PURPOSE (link
)));
13235 if (TREE_CODE (value
) == CONST_DECL
)
13236 value
= DECL_INITIAL (value
);
13238 if (host_integerp (value
, TYPE_UNSIGNED (TREE_TYPE (value
))))
13239 /* DWARF2 does not provide a way of indicating whether or
13240 not enumeration constants are signed or unsigned. GDB
13241 always assumes the values are signed, so we output all
13242 values as if they were signed. That means that
13243 enumeration constants with very large unsigned values
13244 will appear to have negative values in the debugger. */
13245 add_AT_int (enum_die
, DW_AT_const_value
,
13246 tree_low_cst (value
, tree_int_cst_sgn (value
) > 0));
13250 add_AT_flag (type_die
, DW_AT_declaration
, 1);
13252 if (get_AT (type_die
, DW_AT_name
))
13253 add_pubtype (type
, type_die
);
13258 /* Generate a DIE to represent either a real live formal parameter decl or to
13259 represent just the type of some formal parameter position in some function
13262 Note that this routine is a bit unusual because its argument may be a
13263 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
13264 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
13265 node. If it's the former then this function is being called to output a
13266 DIE to represent a formal parameter object (or some inlining thereof). If
13267 it's the latter, then this function is only being called to output a
13268 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
13269 argument type of some subprogram type. */
13272 gen_formal_parameter_die (tree node
, tree origin
, dw_die_ref context_die
)
13274 tree node_or_origin
= node
? node
: origin
;
13275 dw_die_ref parm_die
13276 = new_die (DW_TAG_formal_parameter
, context_die
, node
);
13278 switch (TREE_CODE_CLASS (TREE_CODE (node_or_origin
)))
13280 case tcc_declaration
:
13282 origin
= decl_ultimate_origin (node
);
13283 if (origin
!= NULL
)
13284 add_abstract_origin_attribute (parm_die
, origin
);
13287 tree type
= TREE_TYPE (node
);
13288 add_name_and_src_coords_attributes (parm_die
, node
);
13289 if (DECL_BY_REFERENCE (node
))
13290 add_type_attribute (parm_die
, TREE_TYPE (type
), 0, 0,
13293 add_type_attribute (parm_die
, type
,
13294 TREE_READONLY (node
),
13295 TREE_THIS_VOLATILE (node
),
13297 if (DECL_ARTIFICIAL (node
))
13298 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
13302 equate_decl_number_to_die (node
, parm_die
);
13303 if (! DECL_ABSTRACT (node_or_origin
))
13304 add_location_or_const_value_attribute (parm_die
, node_or_origin
,
13310 /* We were called with some kind of a ..._TYPE node. */
13311 add_type_attribute (parm_die
, node_or_origin
, 0, 0, context_die
);
13315 gcc_unreachable ();
13321 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
13322 at the end of an (ANSI prototyped) formal parameters list. */
13325 gen_unspecified_parameters_die (tree decl_or_type
, dw_die_ref context_die
)
13327 new_die (DW_TAG_unspecified_parameters
, context_die
, decl_or_type
);
13330 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
13331 DW_TAG_unspecified_parameters DIE) to represent the types of the formal
13332 parameters as specified in some function type specification (except for
13333 those which appear as part of a function *definition*). */
13336 gen_formal_types_die (tree function_or_method_type
, dw_die_ref context_die
)
13339 tree formal_type
= NULL
;
13340 tree first_parm_type
;
13343 if (TREE_CODE (function_or_method_type
) == FUNCTION_DECL
)
13345 arg
= DECL_ARGUMENTS (function_or_method_type
);
13346 function_or_method_type
= TREE_TYPE (function_or_method_type
);
13351 first_parm_type
= TYPE_ARG_TYPES (function_or_method_type
);
13353 /* Make our first pass over the list of formal parameter types and output a
13354 DW_TAG_formal_parameter DIE for each one. */
13355 for (link
= first_parm_type
; link
; )
13357 dw_die_ref parm_die
;
13359 formal_type
= TREE_VALUE (link
);
13360 if (formal_type
== void_type_node
)
13363 /* Output a (nameless) DIE to represent the formal parameter itself. */
13364 parm_die
= gen_formal_parameter_die (formal_type
, NULL
, context_die
);
13365 if ((TREE_CODE (function_or_method_type
) == METHOD_TYPE
13366 && link
== first_parm_type
)
13367 || (arg
&& DECL_ARTIFICIAL (arg
)))
13368 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
13370 link
= TREE_CHAIN (link
);
13372 arg
= TREE_CHAIN (arg
);
13375 /* If this function type has an ellipsis, add a
13376 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */
13377 if (formal_type
!= void_type_node
)
13378 gen_unspecified_parameters_die (function_or_method_type
, context_die
);
13380 /* Make our second (and final) pass over the list of formal parameter types
13381 and output DIEs to represent those types (as necessary). */
13382 for (link
= TYPE_ARG_TYPES (function_or_method_type
);
13383 link
&& TREE_VALUE (link
);
13384 link
= TREE_CHAIN (link
))
13385 gen_type_die (TREE_VALUE (link
), context_die
);
13388 /* We want to generate the DIE for TYPE so that we can generate the
13389 die for MEMBER, which has been defined; we will need to refer back
13390 to the member declaration nested within TYPE. If we're trying to
13391 generate minimal debug info for TYPE, processing TYPE won't do the
13392 trick; we need to attach the member declaration by hand. */
13395 gen_type_die_for_member (tree type
, tree member
, dw_die_ref context_die
)
13397 gen_type_die (type
, context_die
);
13399 /* If we're trying to avoid duplicate debug info, we may not have
13400 emitted the member decl for this function. Emit it now. */
13401 if (TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type
))
13402 && ! lookup_decl_die (member
))
13404 dw_die_ref type_die
;
13405 gcc_assert (!decl_ultimate_origin (member
));
13407 push_decl_scope (type
);
13408 type_die
= lookup_type_die (type
);
13409 if (TREE_CODE (member
) == FUNCTION_DECL
)
13410 gen_subprogram_die (member
, type_die
);
13411 else if (TREE_CODE (member
) == FIELD_DECL
)
13413 /* Ignore the nameless fields that are used to skip bits but handle
13414 C++ anonymous unions and structs. */
13415 if (DECL_NAME (member
) != NULL_TREE
13416 || TREE_CODE (TREE_TYPE (member
)) == UNION_TYPE
13417 || TREE_CODE (TREE_TYPE (member
)) == RECORD_TYPE
)
13419 gen_type_die (member_declared_type (member
), type_die
);
13420 gen_field_die (member
, type_die
);
13424 gen_variable_die (member
, NULL_TREE
, type_die
);
13430 /* Generate the DWARF2 info for the "abstract" instance of a function which we
13431 may later generate inlined and/or out-of-line instances of. */
13434 dwarf2out_abstract_function (tree decl
)
13436 dw_die_ref old_die
;
13439 int was_abstract
= DECL_ABSTRACT (decl
);
13441 /* Make sure we have the actual abstract inline, not a clone. */
13442 decl
= DECL_ORIGIN (decl
);
13444 old_die
= lookup_decl_die (decl
);
13445 if (old_die
&& get_AT (old_die
, DW_AT_inline
))
13446 /* We've already generated the abstract instance. */
13449 /* Be sure we've emitted the in-class declaration DIE (if any) first, so
13450 we don't get confused by DECL_ABSTRACT. */
13451 if (debug_info_level
> DINFO_LEVEL_TERSE
)
13453 context
= decl_class_context (decl
);
13455 gen_type_die_for_member
13456 (context
, decl
, decl_function_context (decl
) ? NULL
: comp_unit_die
);
13459 /* Pretend we've just finished compiling this function. */
13460 save_fn
= current_function_decl
;
13461 current_function_decl
= decl
;
13462 push_cfun (DECL_STRUCT_FUNCTION (decl
));
13464 set_decl_abstract_flags (decl
, 1);
13465 dwarf2out_decl (decl
);
13466 if (! was_abstract
)
13467 set_decl_abstract_flags (decl
, 0);
13469 current_function_decl
= save_fn
;
13473 /* Helper function of premark_used_types() which gets called through
13474 htab_traverse_resize().
13476 Marks the DIE of a given type in *SLOT as perennial, so it never gets
13477 marked as unused by prune_unused_types. */
13479 premark_used_types_helper (void **slot
, void *data ATTRIBUTE_UNUSED
)
13484 type
= (tree
) *slot
;
13485 die
= lookup_type_die (type
);
13487 die
->die_perennial_p
= 1;
13491 /* Mark all members of used_types_hash as perennial. */
13493 premark_used_types (void)
13495 if (cfun
&& cfun
->used_types_hash
)
13496 htab_traverse (cfun
->used_types_hash
, premark_used_types_helper
, NULL
);
13499 /* Generate a DIE to represent a declared function (either file-scope or
13503 gen_subprogram_die (tree decl
, dw_die_ref context_die
)
13505 char label_id
[MAX_ARTIFICIAL_LABEL_BYTES
];
13506 tree origin
= decl_ultimate_origin (decl
);
13507 dw_die_ref subr_die
;
13510 dw_die_ref old_die
= lookup_decl_die (decl
);
13511 int declaration
= (current_function_decl
!= decl
13512 || class_or_namespace_scope_p (context_die
));
13514 premark_used_types ();
13516 /* It is possible to have both DECL_ABSTRACT and DECLARATION be true if we
13517 started to generate the abstract instance of an inline, decided to output
13518 its containing class, and proceeded to emit the declaration of the inline
13519 from the member list for the class. If so, DECLARATION takes priority;
13520 we'll get back to the abstract instance when done with the class. */
13522 /* The class-scope declaration DIE must be the primary DIE. */
13523 if (origin
&& declaration
&& class_or_namespace_scope_p (context_die
))
13526 gcc_assert (!old_die
);
13529 /* Now that the C++ front end lazily declares artificial member fns, we
13530 might need to retrofit the declaration into its class. */
13531 if (!declaration
&& !origin
&& !old_die
13532 && DECL_CONTEXT (decl
) && TYPE_P (DECL_CONTEXT (decl
))
13533 && !class_or_namespace_scope_p (context_die
)
13534 && debug_info_level
> DINFO_LEVEL_TERSE
)
13535 old_die
= force_decl_die (decl
);
13537 if (origin
!= NULL
)
13539 gcc_assert (!declaration
|| local_scope_p (context_die
));
13541 /* Fixup die_parent for the abstract instance of a nested
13542 inline function. */
13543 if (old_die
&& old_die
->die_parent
== NULL
)
13544 add_child_die (context_die
, old_die
);
13546 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
13547 add_abstract_origin_attribute (subr_die
, origin
);
13551 expanded_location s
= expand_location (DECL_SOURCE_LOCATION (decl
));
13552 struct dwarf_file_data
* file_index
= lookup_filename (s
.file
);
13554 if (!get_AT_flag (old_die
, DW_AT_declaration
)
13555 /* We can have a normal definition following an inline one in the
13556 case of redefinition of GNU C extern inlines.
13557 It seems reasonable to use AT_specification in this case. */
13558 && !get_AT (old_die
, DW_AT_inline
))
13560 /* Detect and ignore this case, where we are trying to output
13561 something we have already output. */
13565 /* If the definition comes from the same place as the declaration,
13566 maybe use the old DIE. We always want the DIE for this function
13567 that has the *_pc attributes to be under comp_unit_die so the
13568 debugger can find it. We also need to do this for abstract
13569 instances of inlines, since the spec requires the out-of-line copy
13570 to have the same parent. For local class methods, this doesn't
13571 apply; we just use the old DIE. */
13572 if ((old_die
->die_parent
== comp_unit_die
|| context_die
== NULL
)
13573 && (DECL_ARTIFICIAL (decl
)
13574 || (get_AT_file (old_die
, DW_AT_decl_file
) == file_index
13575 && (get_AT_unsigned (old_die
, DW_AT_decl_line
)
13576 == (unsigned) s
.line
))))
13578 subr_die
= old_die
;
13580 /* Clear out the declaration attribute and the formal parameters.
13581 Do not remove all children, because it is possible that this
13582 declaration die was forced using force_decl_die(). In such
13583 cases die that forced declaration die (e.g. TAG_imported_module)
13584 is one of the children that we do not want to remove. */
13585 remove_AT (subr_die
, DW_AT_declaration
);
13586 remove_child_TAG (subr_die
, DW_TAG_formal_parameter
);
13590 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
13591 add_AT_specification (subr_die
, old_die
);
13592 if (get_AT_file (old_die
, DW_AT_decl_file
) != file_index
)
13593 add_AT_file (subr_die
, DW_AT_decl_file
, file_index
);
13594 if (get_AT_unsigned (old_die
, DW_AT_decl_line
) != (unsigned) s
.line
)
13595 add_AT_unsigned (subr_die
, DW_AT_decl_line
, s
.line
);
13600 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
13602 if (TREE_PUBLIC (decl
))
13603 add_AT_flag (subr_die
, DW_AT_external
, 1);
13605 add_name_and_src_coords_attributes (subr_die
, decl
);
13606 if (debug_info_level
> DINFO_LEVEL_TERSE
)
13608 add_prototyped_attribute (subr_die
, TREE_TYPE (decl
));
13609 add_type_attribute (subr_die
, TREE_TYPE (TREE_TYPE (decl
)),
13610 0, 0, context_die
);
13613 add_pure_or_virtual_attribute (subr_die
, decl
);
13614 if (DECL_ARTIFICIAL (decl
))
13615 add_AT_flag (subr_die
, DW_AT_artificial
, 1);
13617 if (TREE_PROTECTED (decl
))
13618 add_AT_unsigned (subr_die
, DW_AT_accessibility
, DW_ACCESS_protected
);
13619 else if (TREE_PRIVATE (decl
))
13620 add_AT_unsigned (subr_die
, DW_AT_accessibility
, DW_ACCESS_private
);
13625 if (!old_die
|| !get_AT (old_die
, DW_AT_inline
))
13627 add_AT_flag (subr_die
, DW_AT_declaration
, 1);
13629 /* If this is an explicit function declaration then generate
13630 a DW_AT_explicit attribute. */
13631 if (lang_hooks
.decls
.function_decl_explicit_p (decl
))
13632 add_AT_flag (subr_die
, DW_AT_explicit
, 1);
13634 /* The first time we see a member function, it is in the context of
13635 the class to which it belongs. We make sure of this by emitting
13636 the class first. The next time is the definition, which is
13637 handled above. The two may come from the same source text.
13639 Note that force_decl_die() forces function declaration die. It is
13640 later reused to represent definition. */
13641 equate_decl_number_to_die (decl
, subr_die
);
13644 else if (DECL_ABSTRACT (decl
))
13646 if (DECL_DECLARED_INLINE_P (decl
))
13648 if (cgraph_function_possibly_inlined_p (decl
))
13649 add_AT_unsigned (subr_die
, DW_AT_inline
, DW_INL_declared_inlined
);
13651 add_AT_unsigned (subr_die
, DW_AT_inline
, DW_INL_declared_not_inlined
);
13655 if (cgraph_function_possibly_inlined_p (decl
))
13656 add_AT_unsigned (subr_die
, DW_AT_inline
, DW_INL_inlined
);
13658 add_AT_unsigned (subr_die
, DW_AT_inline
, DW_INL_not_inlined
);
13661 if (DECL_DECLARED_INLINE_P (decl
)
13662 && lookup_attribute ("artificial", DECL_ATTRIBUTES (decl
)))
13663 add_AT_flag (subr_die
, DW_AT_artificial
, 1);
13665 equate_decl_number_to_die (decl
, subr_die
);
13667 else if (!DECL_EXTERNAL (decl
))
13669 HOST_WIDE_INT cfa_fb_offset
;
13671 if (!old_die
|| !get_AT (old_die
, DW_AT_inline
))
13672 equate_decl_number_to_die (decl
, subr_die
);
13674 if (!flag_reorder_blocks_and_partition
)
13676 ASM_GENERATE_INTERNAL_LABEL (label_id
, FUNC_BEGIN_LABEL
,
13677 current_function_funcdef_no
);
13678 add_AT_lbl_id (subr_die
, DW_AT_low_pc
, label_id
);
13679 ASM_GENERATE_INTERNAL_LABEL (label_id
, FUNC_END_LABEL
,
13680 current_function_funcdef_no
);
13681 add_AT_lbl_id (subr_die
, DW_AT_high_pc
, label_id
);
13683 add_pubname (decl
, subr_die
);
13684 add_arange (decl
, subr_die
);
13687 { /* Do nothing for now; maybe need to duplicate die, one for
13688 hot section and one for cold section, then use the hot/cold
13689 section begin/end labels to generate the aranges... */
13691 add_AT_lbl_id (subr_die, DW_AT_low_pc, hot_section_label);
13692 add_AT_lbl_id (subr_die, DW_AT_high_pc, hot_section_end_label);
13693 add_AT_lbl_id (subr_die, DW_AT_lo_user, unlikely_section_label);
13694 add_AT_lbl_id (subr_die, DW_AT_hi_user, cold_section_end_label);
13696 add_pubname (decl, subr_die);
13697 add_arange (decl, subr_die);
13698 add_arange (decl, subr_die);
13702 #ifdef MIPS_DEBUGGING_INFO
13703 /* Add a reference to the FDE for this routine. */
13704 add_AT_fde_ref (subr_die
, DW_AT_MIPS_fde
, current_funcdef_fde
);
13707 cfa_fb_offset
= CFA_FRAME_BASE_OFFSET (decl
);
13709 /* We define the "frame base" as the function's CFA. This is more
13710 convenient for several reasons: (1) It's stable across the prologue
13711 and epilogue, which makes it better than just a frame pointer,
13712 (2) With dwarf3, there exists a one-byte encoding that allows us
13713 to reference the .debug_frame data by proxy, but failing that,
13714 (3) We can at least reuse the code inspection and interpretation
13715 code that determines the CFA position at various points in the
13717 /* ??? Use some command-line or configury switch to enable the use
13718 of dwarf3 DW_OP_call_frame_cfa. At present there are no dwarf
13719 consumers that understand it; fall back to "pure" dwarf2 and
13720 convert the CFA data into a location list. */
13722 dw_loc_list_ref list
= convert_cfa_to_fb_loc_list (cfa_fb_offset
);
13723 if (list
->dw_loc_next
)
13724 add_AT_loc_list (subr_die
, DW_AT_frame_base
, list
);
13726 add_AT_loc (subr_die
, DW_AT_frame_base
, list
->expr
);
13729 /* Compute a displacement from the "steady-state frame pointer" to
13730 the CFA. The former is what all stack slots and argument slots
13731 will reference in the rtl; the later is what we've told the
13732 debugger about. We'll need to adjust all frame_base references
13733 by this displacement. */
13734 compute_frame_pointer_to_fb_displacement (cfa_fb_offset
);
13736 if (cfun
->static_chain_decl
)
13737 add_AT_location_description (subr_die
, DW_AT_static_link
,
13738 loc_descriptor_from_tree (cfun
->static_chain_decl
));
13741 /* Now output descriptions of the arguments for this function. This gets
13742 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
13743 for a FUNCTION_DECL doesn't indicate cases where there was a trailing
13744 `...' at the end of the formal parameter list. In order to find out if
13745 there was a trailing ellipsis or not, we must instead look at the type
13746 associated with the FUNCTION_DECL. This will be a node of type
13747 FUNCTION_TYPE. If the chain of type nodes hanging off of this
13748 FUNCTION_TYPE node ends with a void_type_node then there should *not* be
13749 an ellipsis at the end. */
13751 /* In the case where we are describing a mere function declaration, all we
13752 need to do here (and all we *can* do here) is to describe the *types* of
13753 its formal parameters. */
13754 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
13756 else if (declaration
)
13757 gen_formal_types_die (decl
, subr_die
);
13760 /* Generate DIEs to represent all known formal parameters. */
13761 tree arg_decls
= DECL_ARGUMENTS (decl
);
13764 /* When generating DIEs, generate the unspecified_parameters DIE
13765 instead if we come across the arg "__builtin_va_alist" */
13766 for (parm
= arg_decls
; parm
; parm
= TREE_CHAIN (parm
))
13767 if (TREE_CODE (parm
) == PARM_DECL
)
13769 if (DECL_NAME (parm
)
13770 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (parm
)),
13771 "__builtin_va_alist"))
13772 gen_unspecified_parameters_die (parm
, subr_die
);
13774 gen_decl_die (parm
, NULL
, subr_die
);
13777 /* Decide whether we need an unspecified_parameters DIE at the end.
13778 There are 2 more cases to do this for: 1) the ansi ... declaration -
13779 this is detectable when the end of the arg list is not a
13780 void_type_node 2) an unprototyped function declaration (not a
13781 definition). This just means that we have no info about the
13782 parameters at all. */
13783 fn_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
13784 if (fn_arg_types
!= NULL
)
13786 /* This is the prototyped case, check for.... */
13787 if (TREE_VALUE (tree_last (fn_arg_types
)) != void_type_node
)
13788 gen_unspecified_parameters_die (decl
, subr_die
);
13790 else if (DECL_INITIAL (decl
) == NULL_TREE
)
13791 gen_unspecified_parameters_die (decl
, subr_die
);
13794 /* Output Dwarf info for all of the stuff within the body of the function
13795 (if it has one - it may be just a declaration). */
13796 outer_scope
= DECL_INITIAL (decl
);
13798 /* OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent
13799 a function. This BLOCK actually represents the outermost binding contour
13800 for the function, i.e. the contour in which the function's formal
13801 parameters and labels get declared. Curiously, it appears that the front
13802 end doesn't actually put the PARM_DECL nodes for the current function onto
13803 the BLOCK_VARS list for this outer scope, but are strung off of the
13804 DECL_ARGUMENTS list for the function instead.
13806 The BLOCK_VARS list for the `outer_scope' does provide us with a list of
13807 the LABEL_DECL nodes for the function however, and we output DWARF info
13808 for those in decls_for_scope. Just within the `outer_scope' there will be
13809 a BLOCK node representing the function's outermost pair of curly braces,
13810 and any blocks used for the base and member initializers of a C++
13811 constructor function. */
13812 if (! declaration
&& TREE_CODE (outer_scope
) != ERROR_MARK
)
13814 /* Emit a DW_TAG_variable DIE for a named return value. */
13815 if (DECL_NAME (DECL_RESULT (decl
)))
13816 gen_decl_die (DECL_RESULT (decl
), NULL
, subr_die
);
13818 current_function_has_inlines
= 0;
13819 decls_for_scope (outer_scope
, subr_die
, 0);
13821 #if 0 && defined (MIPS_DEBUGGING_INFO)
13822 if (current_function_has_inlines
)
13824 add_AT_flag (subr_die
, DW_AT_MIPS_has_inlines
, 1);
13825 if (! comp_unit_has_inlines
)
13827 add_AT_flag (comp_unit_die
, DW_AT_MIPS_has_inlines
, 1);
13828 comp_unit_has_inlines
= 1;
13833 /* Add the calling convention attribute if requested. */
13834 add_calling_convention_attribute (subr_die
, decl
);
13838 /* Returns a hash value for X (which really is a die_struct). */
13841 common_block_die_table_hash (const void *x
)
13843 const_dw_die_ref d
= (const_dw_die_ref
) x
;
13844 return (hashval_t
) d
->decl_id
^ htab_hash_pointer (d
->die_parent
);
13847 /* Return nonzero if decl_id and die_parent of die_struct X is the same
13848 as decl_id and die_parent of die_struct Y. */
13851 common_block_die_table_eq (const void *x
, const void *y
)
13853 const_dw_die_ref d
= (const_dw_die_ref
) x
;
13854 const_dw_die_ref e
= (const_dw_die_ref
) y
;
13855 return d
->decl_id
== e
->decl_id
&& d
->die_parent
== e
->die_parent
;
13858 /* Generate a DIE to represent a declared data object.
13859 Either DECL or ORIGIN must be non-null. */
13862 gen_variable_die (tree decl
, tree origin
, dw_die_ref context_die
)
13866 tree decl_or_origin
= decl
? decl
: origin
;
13867 dw_die_ref var_die
;
13868 dw_die_ref old_die
= decl
? lookup_decl_die (decl
) : NULL
;
13869 dw_die_ref origin_die
;
13870 int declaration
= (DECL_EXTERNAL (decl_or_origin
)
13871 /* If DECL is COMDAT and has not actually been
13872 emitted, we cannot take its address; there
13873 might end up being no definition anywhere in
13874 the program. For example, consider the C++
13878 struct S { static const int i = 7; };
13883 int f() { return S<int>::i; }
13885 Here, S<int>::i is not DECL_EXTERNAL, but no
13886 definition is required, so the compiler will
13887 not emit a definition. */
13888 || (TREE_CODE (decl_or_origin
) == VAR_DECL
13889 && DECL_COMDAT (decl_or_origin
)
13890 && !TREE_ASM_WRITTEN (decl_or_origin
))
13891 || class_or_namespace_scope_p (context_die
));
13894 origin
= decl_ultimate_origin (decl
);
13896 com_decl
= fortran_common (decl_or_origin
, &off
);
13898 /* Symbol in common gets emitted as a child of the common block, in the form
13899 of a data member. */
13903 dw_die_ref com_die
;
13904 dw_loc_descr_ref loc
;
13905 die_node com_die_arg
;
13907 var_die
= lookup_decl_die (decl_or_origin
);
13910 if (get_AT (var_die
, DW_AT_location
) == NULL
)
13912 loc
= loc_descriptor_from_tree (com_decl
);
13917 /* Optimize the common case. */
13918 if (loc
->dw_loc_opc
== DW_OP_addr
13919 && loc
->dw_loc_next
== NULL
13920 && GET_CODE (loc
->dw_loc_oprnd1
.v
.val_addr
)
13922 loc
->dw_loc_oprnd1
.v
.val_addr
13923 = plus_constant (loc
->dw_loc_oprnd1
.v
.val_addr
, off
);
13925 loc_descr_plus_const (&loc
, off
);
13927 add_AT_loc (var_die
, DW_AT_location
, loc
);
13928 remove_AT (var_die
, DW_AT_declaration
);
13934 if (common_block_die_table
== NULL
)
13935 common_block_die_table
13936 = htab_create_ggc (10, common_block_die_table_hash
,
13937 common_block_die_table_eq
, NULL
);
13939 field
= TREE_OPERAND (DECL_VALUE_EXPR (decl
), 0);
13940 com_die_arg
.decl_id
= DECL_UID (com_decl
);
13941 com_die_arg
.die_parent
= context_die
;
13942 com_die
= (dw_die_ref
) htab_find (common_block_die_table
, &com_die_arg
);
13943 loc
= loc_descriptor_from_tree (com_decl
);
13944 if (com_die
== NULL
)
13947 = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (com_decl
));
13950 com_die
= new_die (DW_TAG_common_block
, context_die
, decl
);
13951 add_name_and_src_coords_attributes (com_die
, com_decl
);
13954 add_AT_loc (com_die
, DW_AT_location
, loc
);
13955 /* Avoid sharing the same loc descriptor between
13956 DW_TAG_common_block and DW_TAG_variable. */
13957 loc
= loc_descriptor_from_tree (com_decl
);
13959 else if (DECL_EXTERNAL (decl
))
13960 add_AT_flag (com_die
, DW_AT_declaration
, 1);
13961 add_pubname_string (cnam
, com_die
); /* ??? needed? */
13962 com_die
->decl_id
= DECL_UID (com_decl
);
13963 slot
= htab_find_slot (common_block_die_table
, com_die
, INSERT
);
13964 *slot
= (void *) com_die
;
13966 else if (get_AT (com_die
, DW_AT_location
) == NULL
&& loc
)
13968 add_AT_loc (com_die
, DW_AT_location
, loc
);
13969 loc
= loc_descriptor_from_tree (com_decl
);
13970 remove_AT (com_die
, DW_AT_declaration
);
13972 var_die
= new_die (DW_TAG_variable
, com_die
, decl
);
13973 add_name_and_src_coords_attributes (var_die
, decl
);
13974 add_type_attribute (var_die
, TREE_TYPE (decl
), TREE_READONLY (decl
),
13975 TREE_THIS_VOLATILE (decl
), context_die
);
13976 add_AT_flag (var_die
, DW_AT_external
, 1);
13981 /* Optimize the common case. */
13982 if (loc
->dw_loc_opc
== DW_OP_addr
13983 && loc
->dw_loc_next
== NULL
13984 && GET_CODE (loc
->dw_loc_oprnd1
.v
.val_addr
) == SYMBOL_REF
)
13985 loc
->dw_loc_oprnd1
.v
.val_addr
13986 = plus_constant (loc
->dw_loc_oprnd1
.v
.val_addr
, off
);
13988 loc_descr_plus_const (&loc
, off
);
13990 add_AT_loc (var_die
, DW_AT_location
, loc
);
13992 else if (DECL_EXTERNAL (decl
))
13993 add_AT_flag (var_die
, DW_AT_declaration
, 1);
13994 equate_decl_number_to_die (decl
, var_die
);
13998 /* If the compiler emitted a definition for the DECL declaration
13999 and if we already emitted a DIE for it, don't emit a second
14000 DIE for it again. */
14003 && old_die
->die_parent
== context_die
)
14006 /* For static data members, the declaration in the class is supposed
14007 to have DW_TAG_member tag; the specification should still be
14008 DW_TAG_variable referencing the DW_TAG_member DIE. */
14009 if (declaration
&& class_scope_p (context_die
))
14010 var_die
= new_die (DW_TAG_member
, context_die
, decl
);
14012 var_die
= new_die (DW_TAG_variable
, context_die
, decl
);
14015 if (origin
!= NULL
)
14016 origin_die
= add_abstract_origin_attribute (var_die
, origin
);
14018 /* Loop unrolling can create multiple blocks that refer to the same
14019 static variable, so we must test for the DW_AT_declaration flag.
14021 ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
14022 copy decls and set the DECL_ABSTRACT flag on them instead of
14025 ??? Duplicated blocks have been rewritten to use .debug_ranges.
14027 ??? The declare_in_namespace support causes us to get two DIEs for one
14028 variable, both of which are declarations. We want to avoid considering
14029 one to be a specification, so we must test that this DIE is not a
14031 else if (old_die
&& TREE_STATIC (decl
) && ! declaration
14032 && get_AT_flag (old_die
, DW_AT_declaration
) == 1)
14034 /* This is a definition of a C++ class level static. */
14035 add_AT_specification (var_die
, old_die
);
14036 if (DECL_NAME (decl
))
14038 expanded_location s
= expand_location (DECL_SOURCE_LOCATION (decl
));
14039 struct dwarf_file_data
* file_index
= lookup_filename (s
.file
);
14041 if (get_AT_file (old_die
, DW_AT_decl_file
) != file_index
)
14042 add_AT_file (var_die
, DW_AT_decl_file
, file_index
);
14044 if (get_AT_unsigned (old_die
, DW_AT_decl_line
) != (unsigned) s
.line
)
14045 add_AT_unsigned (var_die
, DW_AT_decl_line
, s
.line
);
14050 tree type
= TREE_TYPE (decl
);
14051 bool private_flag_valid
= true;
14053 add_name_and_src_coords_attributes (var_die
, decl
);
14054 if ((TREE_CODE (decl
) == PARM_DECL
14055 || TREE_CODE (decl
) == RESULT_DECL
14056 || (TREE_CODE (decl
) == VAR_DECL
&& !TREE_STATIC (decl
)))
14057 && DECL_BY_REFERENCE (decl
))
14059 add_type_attribute (var_die
, TREE_TYPE (type
), 0, 0, context_die
);
14060 /* DECL_BY_REFERENCE uses the same bit as TREE_PRIVATE,
14061 for PARM_DECL, RESULT_DECL or non-static VAR_DECL. */
14062 private_flag_valid
= false;
14065 add_type_attribute (var_die
, type
, TREE_READONLY (decl
),
14066 TREE_THIS_VOLATILE (decl
), context_die
);
14068 if (TREE_PUBLIC (decl
))
14069 add_AT_flag (var_die
, DW_AT_external
, 1);
14071 if (DECL_ARTIFICIAL (decl
))
14072 add_AT_flag (var_die
, DW_AT_artificial
, 1);
14074 if (TREE_PROTECTED (decl
))
14075 add_AT_unsigned (var_die
, DW_AT_accessibility
, DW_ACCESS_protected
);
14076 else if (private_flag_valid
&& TREE_PRIVATE (decl
))
14077 add_AT_unsigned (var_die
, DW_AT_accessibility
, DW_ACCESS_private
);
14081 add_AT_flag (var_die
, DW_AT_declaration
, 1);
14083 if (decl
&& (DECL_ABSTRACT (decl
) || declaration
))
14084 equate_decl_number_to_die (decl
, var_die
);
14087 && (! DECL_ABSTRACT (decl_or_origin
)
14088 /* Local static vars are shared between all clones/inlines,
14089 so emit DW_AT_location on the abstract DIE if DECL_RTL is
14091 || (TREE_CODE (decl_or_origin
) == VAR_DECL
14092 && TREE_STATIC (decl_or_origin
)
14093 && DECL_RTL_SET_P (decl_or_origin
)))
14094 /* When abstract origin already has DW_AT_location attribute, no need
14095 to add it again. */
14096 && (origin_die
== NULL
|| get_AT (origin_die
, DW_AT_location
) == NULL
))
14098 if (TREE_CODE (decl_or_origin
) == VAR_DECL
&& TREE_STATIC (decl_or_origin
)
14099 && !TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl_or_origin
)))
14100 defer_location (decl_or_origin
, var_die
);
14102 add_location_or_const_value_attribute (var_die
,
14105 add_pubname (decl_or_origin
, var_die
);
14108 tree_add_const_value_attribute (var_die
, decl_or_origin
);
14111 /* Generate a DIE to represent a named constant. */
14114 gen_const_die (tree decl
, dw_die_ref context_die
)
14116 dw_die_ref const_die
;
14117 tree type
= TREE_TYPE (decl
);
14119 const_die
= new_die (DW_TAG_constant
, context_die
, decl
);
14120 add_name_and_src_coords_attributes (const_die
, decl
);
14121 add_type_attribute (const_die
, type
, 1, 0, context_die
);
14122 if (TREE_PUBLIC (decl
))
14123 add_AT_flag (const_die
, DW_AT_external
, 1);
14124 if (DECL_ARTIFICIAL (decl
))
14125 add_AT_flag (const_die
, DW_AT_artificial
, 1);
14126 tree_add_const_value_attribute (const_die
, decl
);
14129 /* Generate a DIE to represent a label identifier. */
14132 gen_label_die (tree decl
, dw_die_ref context_die
)
14134 tree origin
= decl_ultimate_origin (decl
);
14135 dw_die_ref lbl_die
= new_die (DW_TAG_label
, context_die
, decl
);
14137 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
14139 if (origin
!= NULL
)
14140 add_abstract_origin_attribute (lbl_die
, origin
);
14142 add_name_and_src_coords_attributes (lbl_die
, decl
);
14144 if (DECL_ABSTRACT (decl
))
14145 equate_decl_number_to_die (decl
, lbl_die
);
14148 insn
= DECL_RTL_IF_SET (decl
);
14150 /* Deleted labels are programmer specified labels which have been
14151 eliminated because of various optimizations. We still emit them
14152 here so that it is possible to put breakpoints on them. */
14156 && NOTE_KIND (insn
) == NOTE_INSN_DELETED_LABEL
))))
14158 /* When optimization is enabled (via -O) some parts of the compiler
14159 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
14160 represent source-level labels which were explicitly declared by
14161 the user. This really shouldn't be happening though, so catch
14162 it if it ever does happen. */
14163 gcc_assert (!INSN_DELETED_P (insn
));
14165 ASM_GENERATE_INTERNAL_LABEL (label
, "L", CODE_LABEL_NUMBER (insn
));
14166 add_AT_lbl_id (lbl_die
, DW_AT_low_pc
, label
);
14171 /* A helper function for gen_inlined_subroutine_die. Add source coordinate
14172 attributes to the DIE for a block STMT, to describe where the inlined
14173 function was called from. This is similar to add_src_coords_attributes. */
14176 add_call_src_coords_attributes (tree stmt
, dw_die_ref die
)
14178 expanded_location s
= expand_location (BLOCK_SOURCE_LOCATION (stmt
));
14180 add_AT_file (die
, DW_AT_call_file
, lookup_filename (s
.file
));
14181 add_AT_unsigned (die
, DW_AT_call_line
, s
.line
);
14185 /* A helper function for gen_lexical_block_die and gen_inlined_subroutine_die.
14186 Add low_pc and high_pc attributes to the DIE for a block STMT. */
14189 add_high_low_attributes (tree stmt
, dw_die_ref die
)
14191 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
14193 if (BLOCK_FRAGMENT_CHAIN (stmt
))
14197 if (inlined_function_outer_scope_p (stmt
))
14199 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_BEGIN_LABEL
,
14200 BLOCK_NUMBER (stmt
));
14201 add_AT_lbl_id (die
, DW_AT_entry_pc
, label
);
14204 add_AT_range_list (die
, DW_AT_ranges
, add_ranges (stmt
));
14206 chain
= BLOCK_FRAGMENT_CHAIN (stmt
);
14209 add_ranges (chain
);
14210 chain
= BLOCK_FRAGMENT_CHAIN (chain
);
14217 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_BEGIN_LABEL
,
14218 BLOCK_NUMBER (stmt
));
14219 add_AT_lbl_id (die
, DW_AT_low_pc
, label
);
14220 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_END_LABEL
,
14221 BLOCK_NUMBER (stmt
));
14222 add_AT_lbl_id (die
, DW_AT_high_pc
, label
);
14226 /* Generate a DIE for a lexical block. */
14229 gen_lexical_block_die (tree stmt
, dw_die_ref context_die
, int depth
)
14231 dw_die_ref stmt_die
= new_die (DW_TAG_lexical_block
, context_die
, stmt
);
14233 if (! BLOCK_ABSTRACT (stmt
) && TREE_ASM_WRITTEN (stmt
))
14234 add_high_low_attributes (stmt
, stmt_die
);
14236 decls_for_scope (stmt
, stmt_die
, depth
);
14239 /* Generate a DIE for an inlined subprogram. */
14242 gen_inlined_subroutine_die (tree stmt
, dw_die_ref context_die
, int depth
)
14244 tree decl
= block_ultimate_origin (stmt
);
14246 /* Emit info for the abstract instance first, if we haven't yet. We
14247 must emit this even if the block is abstract, otherwise when we
14248 emit the block below (or elsewhere), we may end up trying to emit
14249 a die whose origin die hasn't been emitted, and crashing. */
14250 dwarf2out_abstract_function (decl
);
14252 if (! BLOCK_ABSTRACT (stmt
))
14254 dw_die_ref subr_die
14255 = new_die (DW_TAG_inlined_subroutine
, context_die
, stmt
);
14257 add_abstract_origin_attribute (subr_die
, decl
);
14258 if (TREE_ASM_WRITTEN (stmt
))
14259 add_high_low_attributes (stmt
, subr_die
);
14260 add_call_src_coords_attributes (stmt
, subr_die
);
14262 decls_for_scope (stmt
, subr_die
, depth
);
14263 current_function_has_inlines
= 1;
14266 /* We may get here if we're the outer block of function A that was
14267 inlined into function B that was inlined into function C. When
14268 generating debugging info for C, dwarf2out_abstract_function(B)
14269 would mark all inlined blocks as abstract, including this one.
14270 So, we wouldn't (and shouldn't) expect labels to be generated
14271 for this one. Instead, just emit debugging info for
14272 declarations within the block. This is particularly important
14273 in the case of initializers of arguments passed from B to us:
14274 if they're statement expressions containing declarations, we
14275 wouldn't generate dies for their abstract variables, and then,
14276 when generating dies for the real variables, we'd die (pun
14278 gen_lexical_block_die (stmt
, context_die
, depth
);
14281 /* Generate a DIE for a field in a record, or structure. */
14284 gen_field_die (tree decl
, dw_die_ref context_die
)
14286 dw_die_ref decl_die
;
14288 if (TREE_TYPE (decl
) == error_mark_node
)
14291 decl_die
= new_die (DW_TAG_member
, context_die
, decl
);
14292 add_name_and_src_coords_attributes (decl_die
, decl
);
14293 add_type_attribute (decl_die
, member_declared_type (decl
),
14294 TREE_READONLY (decl
), TREE_THIS_VOLATILE (decl
),
14297 if (DECL_BIT_FIELD_TYPE (decl
))
14299 add_byte_size_attribute (decl_die
, decl
);
14300 add_bit_size_attribute (decl_die
, decl
);
14301 add_bit_offset_attribute (decl_die
, decl
);
14304 if (TREE_CODE (DECL_FIELD_CONTEXT (decl
)) != UNION_TYPE
)
14305 add_data_member_location_attribute (decl_die
, decl
);
14307 if (DECL_ARTIFICIAL (decl
))
14308 add_AT_flag (decl_die
, DW_AT_artificial
, 1);
14310 if (TREE_PROTECTED (decl
))
14311 add_AT_unsigned (decl_die
, DW_AT_accessibility
, DW_ACCESS_protected
);
14312 else if (TREE_PRIVATE (decl
))
14313 add_AT_unsigned (decl_die
, DW_AT_accessibility
, DW_ACCESS_private
);
14315 /* Equate decl number to die, so that we can look up this decl later on. */
14316 equate_decl_number_to_die (decl
, decl_die
);
14320 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
14321 Use modified_type_die instead.
14322 We keep this code here just in case these types of DIEs may be needed to
14323 represent certain things in other languages (e.g. Pascal) someday. */
14326 gen_pointer_type_die (tree type
, dw_die_ref context_die
)
14329 = new_die (DW_TAG_pointer_type
, scope_die_for (type
, context_die
), type
);
14331 equate_type_number_to_die (type
, ptr_die
);
14332 add_type_attribute (ptr_die
, TREE_TYPE (type
), 0, 0, context_die
);
14333 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
, PTR_SIZE
);
14336 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
14337 Use modified_type_die instead.
14338 We keep this code here just in case these types of DIEs may be needed to
14339 represent certain things in other languages (e.g. Pascal) someday. */
14342 gen_reference_type_die (tree type
, dw_die_ref context_die
)
14345 = new_die (DW_TAG_reference_type
, scope_die_for (type
, context_die
), type
);
14347 equate_type_number_to_die (type
, ref_die
);
14348 add_type_attribute (ref_die
, TREE_TYPE (type
), 0, 0, context_die
);
14349 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
, PTR_SIZE
);
14353 /* Generate a DIE for a pointer to a member type. */
14356 gen_ptr_to_mbr_type_die (tree type
, dw_die_ref context_die
)
14359 = new_die (DW_TAG_ptr_to_member_type
,
14360 scope_die_for (type
, context_die
), type
);
14362 equate_type_number_to_die (type
, ptr_die
);
14363 add_AT_die_ref (ptr_die
, DW_AT_containing_type
,
14364 lookup_type_die (TYPE_OFFSET_BASETYPE (type
)));
14365 add_type_attribute (ptr_die
, TREE_TYPE (type
), 0, 0, context_die
);
14368 /* Generate the DIE for the compilation unit. */
14371 gen_compile_unit_die (const char *filename
)
14374 char producer
[250];
14375 const char *language_string
= lang_hooks
.name
;
14378 die
= new_die (DW_TAG_compile_unit
, NULL
, NULL
);
14382 add_name_attribute (die
, filename
);
14383 /* Don't add cwd for <built-in>. */
14384 if (!IS_ABSOLUTE_PATH (filename
) && filename
[0] != '<')
14385 add_comp_dir_attribute (die
);
14388 sprintf (producer
, "%s %s", language_string
, version_string
);
14390 #ifdef MIPS_DEBUGGING_INFO
14391 /* The MIPS/SGI compilers place the 'cc' command line options in the producer
14392 string. The SGI debugger looks for -g, -g1, -g2, or -g3; if they do
14393 not appear in the producer string, the debugger reaches the conclusion
14394 that the object file is stripped and has no debugging information.
14395 To get the MIPS/SGI debugger to believe that there is debugging
14396 information in the object file, we add a -g to the producer string. */
14397 if (debug_info_level
> DINFO_LEVEL_TERSE
)
14398 strcat (producer
, " -g");
14401 add_AT_string (die
, DW_AT_producer
, producer
);
14403 if (strcmp (language_string
, "GNU C++") == 0)
14404 language
= DW_LANG_C_plus_plus
;
14405 else if (strcmp (language_string
, "GNU Ada") == 0)
14406 language
= DW_LANG_Ada95
;
14407 else if (strcmp (language_string
, "GNU F77") == 0)
14408 language
= DW_LANG_Fortran77
;
14409 else if (strcmp (language_string
, "GNU Fortran") == 0)
14410 language
= DW_LANG_Fortran95
;
14411 else if (strcmp (language_string
, "GNU Pascal") == 0)
14412 language
= DW_LANG_Pascal83
;
14413 else if (strcmp (language_string
, "GNU Java") == 0)
14414 language
= DW_LANG_Java
;
14415 else if (strcmp (language_string
, "GNU Objective-C") == 0)
14416 language
= DW_LANG_ObjC
;
14417 else if (strcmp (language_string
, "GNU Objective-C++") == 0)
14418 language
= DW_LANG_ObjC_plus_plus
;
14420 language
= DW_LANG_C89
;
14422 add_AT_unsigned (die
, DW_AT_language
, language
);
14426 /* Generate the DIE for a base class. */
14429 gen_inheritance_die (tree binfo
, tree access
, dw_die_ref context_die
)
14431 dw_die_ref die
= new_die (DW_TAG_inheritance
, context_die
, binfo
);
14433 add_type_attribute (die
, BINFO_TYPE (binfo
), 0, 0, context_die
);
14434 add_data_member_location_attribute (die
, binfo
);
14436 if (BINFO_VIRTUAL_P (binfo
))
14437 add_AT_unsigned (die
, DW_AT_virtuality
, DW_VIRTUALITY_virtual
);
14439 if (access
== access_public_node
)
14440 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_public
);
14441 else if (access
== access_protected_node
)
14442 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_protected
);
14445 /* Generate a DIE for a class member. */
14448 gen_member_die (tree type
, dw_die_ref context_die
)
14451 tree binfo
= TYPE_BINFO (type
);
14454 /* If this is not an incomplete type, output descriptions of each of its
14455 members. Note that as we output the DIEs necessary to represent the
14456 members of this record or union type, we will also be trying to output
14457 DIEs to represent the *types* of those members. However the `type'
14458 function (above) will specifically avoid generating type DIEs for member
14459 types *within* the list of member DIEs for this (containing) type except
14460 for those types (of members) which are explicitly marked as also being
14461 members of this (containing) type themselves. The g++ front- end can
14462 force any given type to be treated as a member of some other (containing)
14463 type by setting the TYPE_CONTEXT of the given (member) type to point to
14464 the TREE node representing the appropriate (containing) type. */
14466 /* First output info about the base classes. */
14469 VEC(tree
,gc
) *accesses
= BINFO_BASE_ACCESSES (binfo
);
14473 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base
); i
++)
14474 gen_inheritance_die (base
,
14475 (accesses
? VEC_index (tree
, accesses
, i
)
14476 : access_public_node
), context_die
);
14479 /* Now output info about the data members and type members. */
14480 for (member
= TYPE_FIELDS (type
); member
; member
= TREE_CHAIN (member
))
14482 /* If we thought we were generating minimal debug info for TYPE
14483 and then changed our minds, some of the member declarations
14484 may have already been defined. Don't define them again, but
14485 do put them in the right order. */
14487 child
= lookup_decl_die (member
);
14489 splice_child_die (context_die
, child
);
14491 gen_decl_die (member
, NULL
, context_die
);
14494 /* Now output info about the function members (if any). */
14495 for (member
= TYPE_METHODS (type
); member
; member
= TREE_CHAIN (member
))
14497 /* Don't include clones in the member list. */
14498 if (DECL_ABSTRACT_ORIGIN (member
))
14501 child
= lookup_decl_die (member
);
14503 splice_child_die (context_die
, child
);
14505 gen_decl_die (member
, NULL
, context_die
);
14509 /* Generate a DIE for a structure or union type. If TYPE_DECL_SUPPRESS_DEBUG
14510 is set, we pretend that the type was never defined, so we only get the
14511 member DIEs needed by later specification DIEs. */
14514 gen_struct_or_union_type_die (tree type
, dw_die_ref context_die
,
14515 enum debug_info_usage usage
)
14517 dw_die_ref type_die
= lookup_type_die (type
);
14518 dw_die_ref scope_die
= 0;
14520 int complete
= (TYPE_SIZE (type
)
14521 && (! TYPE_STUB_DECL (type
)
14522 || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type
))));
14523 int ns_decl
= (context_die
&& context_die
->die_tag
== DW_TAG_namespace
);
14524 complete
= complete
&& should_emit_struct_debug (type
, usage
);
14526 if (type_die
&& ! complete
)
14529 if (TYPE_CONTEXT (type
) != NULL_TREE
14530 && (AGGREGATE_TYPE_P (TYPE_CONTEXT (type
))
14531 || TREE_CODE (TYPE_CONTEXT (type
)) == NAMESPACE_DECL
))
14534 scope_die
= scope_die_for (type
, context_die
);
14536 if (! type_die
|| (nested
&& scope_die
== comp_unit_die
))
14537 /* First occurrence of type or toplevel definition of nested class. */
14539 dw_die_ref old_die
= type_die
;
14541 type_die
= new_die (TREE_CODE (type
) == RECORD_TYPE
14542 ? record_type_tag (type
) : DW_TAG_union_type
,
14544 equate_type_number_to_die (type
, type_die
);
14546 add_AT_specification (type_die
, old_die
);
14548 add_name_attribute (type_die
, type_tag (type
));
14551 remove_AT (type_die
, DW_AT_declaration
);
14553 /* If this type has been completed, then give it a byte_size attribute and
14554 then give a list of members. */
14555 if (complete
&& !ns_decl
)
14557 /* Prevent infinite recursion in cases where the type of some member of
14558 this type is expressed in terms of this type itself. */
14559 TREE_ASM_WRITTEN (type
) = 1;
14560 add_byte_size_attribute (type_die
, type
);
14561 if (TYPE_STUB_DECL (type
) != NULL_TREE
)
14562 add_src_coords_attributes (type_die
, TYPE_STUB_DECL (type
));
14564 /* If the first reference to this type was as the return type of an
14565 inline function, then it may not have a parent. Fix this now. */
14566 if (type_die
->die_parent
== NULL
)
14567 add_child_die (scope_die
, type_die
);
14569 push_decl_scope (type
);
14570 gen_member_die (type
, type_die
);
14573 /* GNU extension: Record what type our vtable lives in. */
14574 if (TYPE_VFIELD (type
))
14576 tree vtype
= DECL_FCONTEXT (TYPE_VFIELD (type
));
14578 gen_type_die (vtype
, context_die
);
14579 add_AT_die_ref (type_die
, DW_AT_containing_type
,
14580 lookup_type_die (vtype
));
14585 add_AT_flag (type_die
, DW_AT_declaration
, 1);
14587 /* We don't need to do this for function-local types. */
14588 if (TYPE_STUB_DECL (type
)
14589 && ! decl_function_context (TYPE_STUB_DECL (type
)))
14590 VEC_safe_push (tree
, gc
, incomplete_types
, type
);
14593 if (get_AT (type_die
, DW_AT_name
))
14594 add_pubtype (type
, type_die
);
14597 /* Generate a DIE for a subroutine _type_. */
14600 gen_subroutine_type_die (tree type
, dw_die_ref context_die
)
14602 tree return_type
= TREE_TYPE (type
);
14603 dw_die_ref subr_die
14604 = new_die (DW_TAG_subroutine_type
,
14605 scope_die_for (type
, context_die
), type
);
14607 equate_type_number_to_die (type
, subr_die
);
14608 add_prototyped_attribute (subr_die
, type
);
14609 add_type_attribute (subr_die
, return_type
, 0, 0, context_die
);
14610 gen_formal_types_die (type
, subr_die
);
14612 if (get_AT (subr_die
, DW_AT_name
))
14613 add_pubtype (type
, subr_die
);
14616 /* Generate a DIE for a type definition. */
14619 gen_typedef_die (tree decl
, dw_die_ref context_die
)
14621 dw_die_ref type_die
;
14624 if (TREE_ASM_WRITTEN (decl
))
14627 TREE_ASM_WRITTEN (decl
) = 1;
14628 type_die
= new_die (DW_TAG_typedef
, context_die
, decl
);
14629 origin
= decl_ultimate_origin (decl
);
14630 if (origin
!= NULL
)
14631 add_abstract_origin_attribute (type_die
, origin
);
14636 add_name_and_src_coords_attributes (type_die
, decl
);
14637 if (DECL_ORIGINAL_TYPE (decl
))
14639 type
= DECL_ORIGINAL_TYPE (decl
);
14641 gcc_assert (type
!= TREE_TYPE (decl
));
14642 equate_type_number_to_die (TREE_TYPE (decl
), type_die
);
14645 type
= TREE_TYPE (decl
);
14647 add_type_attribute (type_die
, type
, TREE_READONLY (decl
),
14648 TREE_THIS_VOLATILE (decl
), context_die
);
14651 if (DECL_ABSTRACT (decl
))
14652 equate_decl_number_to_die (decl
, type_die
);
14654 if (get_AT (type_die
, DW_AT_name
))
14655 add_pubtype (decl
, type_die
);
14658 /* Generate a type description DIE. */
14661 gen_type_die_with_usage (tree type
, dw_die_ref context_die
,
14662 enum debug_info_usage usage
)
14665 struct array_descr_info info
;
14667 if (type
== NULL_TREE
|| type
== error_mark_node
)
14670 if (TYPE_NAME (type
) && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
14671 && DECL_ORIGINAL_TYPE (TYPE_NAME (type
)))
14673 if (TREE_ASM_WRITTEN (type
))
14676 /* Prevent broken recursion; we can't hand off to the same type. */
14677 gcc_assert (DECL_ORIGINAL_TYPE (TYPE_NAME (type
)) != type
);
14679 TREE_ASM_WRITTEN (type
) = 1;
14680 gen_decl_die (TYPE_NAME (type
), NULL
, context_die
);
14684 /* If this is an array type with hidden descriptor, handle it first. */
14685 if (!TREE_ASM_WRITTEN (type
)
14686 && lang_hooks
.types
.get_array_descr_info
14687 && lang_hooks
.types
.get_array_descr_info (type
, &info
))
14689 gen_descr_array_type_die (type
, &info
, context_die
);
14690 TREE_ASM_WRITTEN (type
) = 1;
14694 /* We are going to output a DIE to represent the unqualified version
14695 of this type (i.e. without any const or volatile qualifiers) so
14696 get the main variant (i.e. the unqualified version) of this type
14697 now. (Vectors are special because the debugging info is in the
14698 cloned type itself). */
14699 if (TREE_CODE (type
) != VECTOR_TYPE
)
14700 type
= type_main_variant (type
);
14702 if (TREE_ASM_WRITTEN (type
))
14705 switch (TREE_CODE (type
))
14711 case REFERENCE_TYPE
:
14712 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This
14713 ensures that the gen_type_die recursion will terminate even if the
14714 type is recursive. Recursive types are possible in Ada. */
14715 /* ??? We could perhaps do this for all types before the switch
14717 TREE_ASM_WRITTEN (type
) = 1;
14719 /* For these types, all that is required is that we output a DIE (or a
14720 set of DIEs) to represent the "basis" type. */
14721 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
14722 DINFO_USAGE_IND_USE
);
14726 /* This code is used for C++ pointer-to-data-member types.
14727 Output a description of the relevant class type. */
14728 gen_type_die_with_usage (TYPE_OFFSET_BASETYPE (type
), context_die
,
14729 DINFO_USAGE_IND_USE
);
14731 /* Output a description of the type of the object pointed to. */
14732 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
14733 DINFO_USAGE_IND_USE
);
14735 /* Now output a DIE to represent this pointer-to-data-member type
14737 gen_ptr_to_mbr_type_die (type
, context_die
);
14740 case FUNCTION_TYPE
:
14741 /* Force out return type (in case it wasn't forced out already). */
14742 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
14743 DINFO_USAGE_DIR_USE
);
14744 gen_subroutine_type_die (type
, context_die
);
14748 /* Force out return type (in case it wasn't forced out already). */
14749 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
14750 DINFO_USAGE_DIR_USE
);
14751 gen_subroutine_type_die (type
, context_die
);
14755 gen_array_type_die (type
, context_die
);
14759 gen_array_type_die (type
, context_die
);
14762 case ENUMERAL_TYPE
:
14765 case QUAL_UNION_TYPE
:
14766 /* If this is a nested type whose containing class hasn't been written
14767 out yet, writing it out will cover this one, too. This does not apply
14768 to instantiations of member class templates; they need to be added to
14769 the containing class as they are generated. FIXME: This hurts the
14770 idea of combining type decls from multiple TUs, since we can't predict
14771 what set of template instantiations we'll get. */
14772 if (TYPE_CONTEXT (type
)
14773 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type
))
14774 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type
)))
14776 gen_type_die_with_usage (TYPE_CONTEXT (type
), context_die
, usage
);
14778 if (TREE_ASM_WRITTEN (type
))
14781 /* If that failed, attach ourselves to the stub. */
14782 push_decl_scope (TYPE_CONTEXT (type
));
14783 context_die
= lookup_type_die (TYPE_CONTEXT (type
));
14788 context_die
= declare_in_namespace (type
, context_die
);
14792 if (TREE_CODE (type
) == ENUMERAL_TYPE
)
14794 /* This might have been written out by the call to
14795 declare_in_namespace. */
14796 if (!TREE_ASM_WRITTEN (type
))
14797 gen_enumeration_type_die (type
, context_die
);
14800 gen_struct_or_union_type_die (type
, context_die
, usage
);
14805 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
14806 it up if it is ever completed. gen_*_type_die will set it for us
14807 when appropriate. */
14813 case FIXED_POINT_TYPE
:
14816 /* No DIEs needed for fundamental types. */
14820 /* No Dwarf representation currently defined. */
14824 gcc_unreachable ();
14827 TREE_ASM_WRITTEN (type
) = 1;
14831 gen_type_die (tree type
, dw_die_ref context_die
)
14833 gen_type_die_with_usage (type
, context_die
, DINFO_USAGE_DIR_USE
);
14836 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
14837 things which are local to the given block. */
14840 gen_block_die (tree stmt
, dw_die_ref context_die
, int depth
)
14842 int must_output_die
= 0;
14845 /* Ignore blocks that are NULL. */
14846 if (stmt
== NULL_TREE
)
14849 inlined_func
= inlined_function_outer_scope_p (stmt
);
14851 /* If the block is one fragment of a non-contiguous block, do not
14852 process the variables, since they will have been done by the
14853 origin block. Do process subblocks. */
14854 if (BLOCK_FRAGMENT_ORIGIN (stmt
))
14858 for (sub
= BLOCK_SUBBLOCKS (stmt
); sub
; sub
= BLOCK_CHAIN (sub
))
14859 gen_block_die (sub
, context_die
, depth
+ 1);
14864 /* Determine if we need to output any Dwarf DIEs at all to represent this
14867 /* The outer scopes for inlinings *must* always be represented. We
14868 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */
14869 must_output_die
= 1;
14872 /* Determine if this block directly contains any "significant"
14873 local declarations which we will need to output DIEs for. */
14874 if (debug_info_level
> DINFO_LEVEL_TERSE
)
14875 /* We are not in terse mode so *any* local declaration counts
14876 as being a "significant" one. */
14877 must_output_die
= ((BLOCK_VARS (stmt
) != NULL
14878 || BLOCK_NUM_NONLOCALIZED_VARS (stmt
))
14879 && (TREE_USED (stmt
)
14880 || TREE_ASM_WRITTEN (stmt
)
14881 || BLOCK_ABSTRACT (stmt
)));
14882 else if ((TREE_USED (stmt
)
14883 || TREE_ASM_WRITTEN (stmt
)
14884 || BLOCK_ABSTRACT (stmt
))
14885 && !dwarf2out_ignore_block (stmt
))
14886 must_output_die
= 1;
14889 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
14890 DIE for any block which contains no significant local declarations at
14891 all. Rather, in such cases we just call `decls_for_scope' so that any
14892 needed Dwarf info for any sub-blocks will get properly generated. Note
14893 that in terse mode, our definition of what constitutes a "significant"
14894 local declaration gets restricted to include only inlined function
14895 instances and local (nested) function definitions. */
14896 if (must_output_die
)
14899 gen_inlined_subroutine_die (stmt
, context_die
, depth
);
14901 gen_lexical_block_die (stmt
, context_die
, depth
);
14904 decls_for_scope (stmt
, context_die
, depth
);
14907 /* Process variable DECL (or variable with origin ORIGIN) within
14908 block STMT and add it to CONTEXT_DIE. */
14910 process_scope_var (tree stmt
, tree decl
, tree origin
, dw_die_ref context_die
)
14913 tree decl_or_origin
= decl
? decl
: origin
;
14914 tree ultimate_origin
= origin
? decl_ultimate_origin (origin
) : NULL
;
14916 if (ultimate_origin
)
14917 origin
= ultimate_origin
;
14919 if (TREE_CODE (decl_or_origin
) == FUNCTION_DECL
)
14920 die
= lookup_decl_die (decl_or_origin
);
14921 else if (TREE_CODE (decl_or_origin
) == TYPE_DECL
14922 && TYPE_DECL_IS_STUB (decl_or_origin
))
14923 die
= lookup_type_die (TREE_TYPE (decl_or_origin
));
14927 if (die
!= NULL
&& die
->die_parent
== NULL
)
14928 add_child_die (context_die
, die
);
14929 else if (TREE_CODE (decl_or_origin
) == IMPORTED_DECL
)
14930 dwarf2out_imported_module_or_decl_1 (decl_or_origin
, DECL_NAME (decl_or_origin
),
14931 stmt
, context_die
);
14933 gen_decl_die (decl
, origin
, context_die
);
14936 /* Generate all of the decls declared within a given scope and (recursively)
14937 all of its sub-blocks. */
14940 decls_for_scope (tree stmt
, dw_die_ref context_die
, int depth
)
14946 /* Ignore NULL blocks. */
14947 if (stmt
== NULL_TREE
)
14950 /* Output the DIEs to represent all of the data objects and typedefs
14951 declared directly within this block but not within any nested
14952 sub-blocks. Also, nested function and tag DIEs have been
14953 generated with a parent of NULL; fix that up now. */
14954 for (decl
= BLOCK_VARS (stmt
); decl
!= NULL
; decl
= TREE_CHAIN (decl
))
14955 process_scope_var (stmt
, decl
, NULL_TREE
, context_die
);
14956 for (i
= 0; i
< BLOCK_NUM_NONLOCALIZED_VARS (stmt
); i
++)
14957 process_scope_var (stmt
, NULL
, BLOCK_NONLOCALIZED_VAR (stmt
, i
),
14960 /* If we're at -g1, we're not interested in subblocks. */
14961 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
14964 /* Output the DIEs to represent all sub-blocks (and the items declared
14965 therein) of this block. */
14966 for (subblocks
= BLOCK_SUBBLOCKS (stmt
);
14968 subblocks
= BLOCK_CHAIN (subblocks
))
14969 gen_block_die (subblocks
, context_die
, depth
+ 1);
14972 /* Is this a typedef we can avoid emitting? */
14975 is_redundant_typedef (const_tree decl
)
14977 if (TYPE_DECL_IS_STUB (decl
))
14980 if (DECL_ARTIFICIAL (decl
)
14981 && DECL_CONTEXT (decl
)
14982 && is_tagged_type (DECL_CONTEXT (decl
))
14983 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl
))) == TYPE_DECL
14984 && DECL_NAME (decl
) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl
))))
14985 /* Also ignore the artificial member typedef for the class name. */
14991 /* Returns the DIE for a context. */
14993 static inline dw_die_ref
14994 get_context_die (tree context
)
14998 /* Find die that represents this context. */
14999 if (TYPE_P (context
))
15000 return force_type_die (context
);
15002 return force_decl_die (context
);
15004 return comp_unit_die
;
15007 /* Returns the DIE for decl. A DIE will always be returned. */
15010 force_decl_die (tree decl
)
15012 dw_die_ref decl_die
;
15013 unsigned saved_external_flag
;
15014 tree save_fn
= NULL_TREE
;
15015 decl_die
= lookup_decl_die (decl
);
15018 dw_die_ref context_die
= get_context_die (DECL_CONTEXT (decl
));
15020 decl_die
= lookup_decl_die (decl
);
15024 switch (TREE_CODE (decl
))
15026 case FUNCTION_DECL
:
15027 /* Clear current_function_decl, so that gen_subprogram_die thinks
15028 that this is a declaration. At this point, we just want to force
15029 declaration die. */
15030 save_fn
= current_function_decl
;
15031 current_function_decl
= NULL_TREE
;
15032 gen_subprogram_die (decl
, context_die
);
15033 current_function_decl
= save_fn
;
15037 /* Set external flag to force declaration die. Restore it after
15038 gen_decl_die() call. */
15039 saved_external_flag
= DECL_EXTERNAL (decl
);
15040 DECL_EXTERNAL (decl
) = 1;
15041 gen_decl_die (decl
, NULL
, context_die
);
15042 DECL_EXTERNAL (decl
) = saved_external_flag
;
15045 case NAMESPACE_DECL
:
15046 dwarf2out_decl (decl
);
15050 gcc_unreachable ();
15053 /* We should be able to find the DIE now. */
15055 decl_die
= lookup_decl_die (decl
);
15056 gcc_assert (decl_die
);
15062 /* Returns the DIE for TYPE, that must not be a base type. A DIE is
15063 always returned. */
15066 force_type_die (tree type
)
15068 dw_die_ref type_die
;
15070 type_die
= lookup_type_die (type
);
15073 dw_die_ref context_die
= get_context_die (TYPE_CONTEXT (type
));
15075 type_die
= modified_type_die (type
, TYPE_READONLY (type
),
15076 TYPE_VOLATILE (type
), context_die
);
15077 gcc_assert (type_die
);
15082 /* Force out any required namespaces to be able to output DECL,
15083 and return the new context_die for it, if it's changed. */
15086 setup_namespace_context (tree thing
, dw_die_ref context_die
)
15088 tree context
= (DECL_P (thing
)
15089 ? DECL_CONTEXT (thing
) : TYPE_CONTEXT (thing
));
15090 if (context
&& TREE_CODE (context
) == NAMESPACE_DECL
)
15091 /* Force out the namespace. */
15092 context_die
= force_decl_die (context
);
15094 return context_die
;
15097 /* Emit a declaration DIE for THING (which is either a DECL or a tagged
15098 type) within its namespace, if appropriate.
15100 For compatibility with older debuggers, namespace DIEs only contain
15101 declarations; all definitions are emitted at CU scope. */
15104 declare_in_namespace (tree thing
, dw_die_ref context_die
)
15106 dw_die_ref ns_context
;
15108 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
15109 return context_die
;
15111 /* If this decl is from an inlined function, then don't try to emit it in its
15112 namespace, as we will get confused. It would have already been emitted
15113 when the abstract instance of the inline function was emitted anyways. */
15114 if (DECL_P (thing
) && DECL_ABSTRACT_ORIGIN (thing
))
15115 return context_die
;
15117 ns_context
= setup_namespace_context (thing
, context_die
);
15119 if (ns_context
!= context_die
)
15123 if (DECL_P (thing
))
15124 gen_decl_die (thing
, NULL
, ns_context
);
15126 gen_type_die (thing
, ns_context
);
15128 return context_die
;
15131 /* Generate a DIE for a namespace or namespace alias. */
15134 gen_namespace_die (tree decl
, dw_die_ref context_die
)
15136 dw_die_ref namespace_die
;
15138 /* Namespace aliases have a DECL_ABSTRACT_ORIGIN of the namespace
15139 they are an alias of. */
15140 if (DECL_ABSTRACT_ORIGIN (decl
) == NULL
)
15142 /* Output a real namespace or module. */
15143 context_die
= setup_namespace_context (decl
, comp_unit_die
);
15144 namespace_die
= new_die (is_fortran ()
15145 ? DW_TAG_module
: DW_TAG_namespace
,
15146 context_die
, decl
);
15147 /* For Fortran modules defined in different CU don't add src coords. */
15148 if (namespace_die
->die_tag
== DW_TAG_module
&& DECL_EXTERNAL (decl
))
15149 add_name_attribute (namespace_die
, dwarf2_name (decl
, 0));
15151 add_name_and_src_coords_attributes (namespace_die
, decl
);
15152 if (DECL_EXTERNAL (decl
))
15153 add_AT_flag (namespace_die
, DW_AT_declaration
, 1);
15154 equate_decl_number_to_die (decl
, namespace_die
);
15158 /* Output a namespace alias. */
15160 /* Force out the namespace we are an alias of, if necessary. */
15161 dw_die_ref origin_die
15162 = force_decl_die (DECL_ABSTRACT_ORIGIN (decl
));
15164 if (DECL_CONTEXT (decl
) == NULL_TREE
15165 || TREE_CODE (DECL_CONTEXT (decl
)) == NAMESPACE_DECL
)
15166 context_die
= setup_namespace_context (decl
, comp_unit_die
);
15167 /* Now create the namespace alias DIE. */
15168 namespace_die
= new_die (DW_TAG_imported_declaration
, context_die
, decl
);
15169 add_name_and_src_coords_attributes (namespace_die
, decl
);
15170 add_AT_die_ref (namespace_die
, DW_AT_import
, origin_die
);
15171 equate_decl_number_to_die (decl
, namespace_die
);
15175 /* Generate Dwarf debug information for a decl described by DECL. */
15178 gen_decl_die (tree decl
, tree origin
, dw_die_ref context_die
)
15180 tree decl_or_origin
= decl
? decl
: origin
;
15181 tree class_origin
= NULL
;
15183 if (DECL_P (decl_or_origin
) && DECL_IGNORED_P (decl_or_origin
))
15186 switch (TREE_CODE (decl_or_origin
))
15192 if (!is_fortran ())
15194 /* The individual enumerators of an enum type get output when we output
15195 the Dwarf representation of the relevant enum type itself. */
15199 /* Emit its type. */
15200 gen_type_die (TREE_TYPE (decl
), context_die
);
15202 /* And its containing namespace. */
15203 context_die
= declare_in_namespace (decl
, context_die
);
15205 gen_const_die (decl
, context_die
);
15208 case FUNCTION_DECL
:
15209 /* Don't output any DIEs to represent mere function declarations,
15210 unless they are class members or explicit block externs. */
15211 if (DECL_INITIAL (decl_or_origin
) == NULL_TREE
15212 && DECL_CONTEXT (decl_or_origin
) == NULL_TREE
15213 && (current_function_decl
== NULL_TREE
15214 || DECL_ARTIFICIAL (decl_or_origin
)))
15219 /* This doesn't work because the C frontend sets DECL_ABSTRACT_ORIGIN
15220 on local redeclarations of global functions. That seems broken. */
15221 if (current_function_decl
!= decl
)
15222 /* This is only a declaration. */;
15225 /* If we're emitting a clone, emit info for the abstract instance. */
15226 if (origin
|| DECL_ORIGIN (decl
) != decl
)
15227 dwarf2out_abstract_function (origin
? origin
: DECL_ABSTRACT_ORIGIN (decl
));
15229 /* If we're emitting an out-of-line copy of an inline function,
15230 emit info for the abstract instance and set up to refer to it. */
15231 else if (cgraph_function_possibly_inlined_p (decl
)
15232 && ! DECL_ABSTRACT (decl
)
15233 && ! class_or_namespace_scope_p (context_die
)
15234 /* dwarf2out_abstract_function won't emit a die if this is just
15235 a declaration. We must avoid setting DECL_ABSTRACT_ORIGIN in
15236 that case, because that works only if we have a die. */
15237 && DECL_INITIAL (decl
) != NULL_TREE
)
15239 dwarf2out_abstract_function (decl
);
15240 set_decl_origin_self (decl
);
15243 /* Otherwise we're emitting the primary DIE for this decl. */
15244 else if (debug_info_level
> DINFO_LEVEL_TERSE
)
15246 /* Before we describe the FUNCTION_DECL itself, make sure that we
15247 have described its return type. */
15248 gen_type_die (TREE_TYPE (TREE_TYPE (decl
)), context_die
);
15250 /* And its virtual context. */
15251 if (DECL_VINDEX (decl
) != NULL_TREE
)
15252 gen_type_die (DECL_CONTEXT (decl
), context_die
);
15254 /* And its containing type. */
15256 origin
= decl_class_context (decl
);
15257 if (origin
!= NULL_TREE
)
15258 gen_type_die_for_member (origin
, decl
, context_die
);
15260 /* And its containing namespace. */
15261 context_die
= declare_in_namespace (decl
, context_die
);
15264 /* Now output a DIE to represent the function itself. */
15266 gen_subprogram_die (decl
, context_die
);
15270 /* If we are in terse mode, don't generate any DIEs to represent any
15271 actual typedefs. */
15272 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
15275 /* In the special case of a TYPE_DECL node representing the declaration
15276 of some type tag, if the given TYPE_DECL is marked as having been
15277 instantiated from some other (original) TYPE_DECL node (e.g. one which
15278 was generated within the original definition of an inline function) we
15279 used to generate a special (abbreviated) DW_TAG_structure_type,
15280 DW_TAG_union_type, or DW_TAG_enumeration_type DIE here. But nothing
15281 should be actually referencing those DIEs, as variable DIEs with that
15282 type would be emitted already in the abstract origin, so it was always
15283 removed during unused type prunning. Don't add anything in this
15285 if (TYPE_DECL_IS_STUB (decl
) && decl_ultimate_origin (decl
) != NULL_TREE
)
15288 if (is_redundant_typedef (decl
))
15289 gen_type_die (TREE_TYPE (decl
), context_die
);
15291 /* Output a DIE to represent the typedef itself. */
15292 gen_typedef_die (decl
, context_die
);
15296 if (debug_info_level
>= DINFO_LEVEL_NORMAL
)
15297 gen_label_die (decl
, context_die
);
15302 /* If we are in terse mode, don't generate any DIEs to represent any
15303 variable declarations or definitions. */
15304 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
15307 /* Output any DIEs that are needed to specify the type of this data
15309 if ((TREE_CODE (decl_or_origin
) == RESULT_DECL
15310 || (TREE_CODE (decl_or_origin
) == VAR_DECL
15311 && !TREE_STATIC (decl_or_origin
)))
15312 && DECL_BY_REFERENCE (decl_or_origin
))
15313 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin
)), context_die
);
15315 gen_type_die (TREE_TYPE (decl_or_origin
), context_die
);
15317 /* And its containing type. */
15318 class_origin
= decl_class_context (decl_or_origin
);
15319 if (class_origin
!= NULL_TREE
)
15320 gen_type_die_for_member (class_origin
, decl_or_origin
, context_die
);
15322 /* And its containing namespace. */
15323 context_die
= declare_in_namespace (decl_or_origin
, context_die
);
15325 /* Now output the DIE to represent the data object itself. This gets
15326 complicated because of the possibility that the VAR_DECL really
15327 represents an inlined instance of a formal parameter for an inline
15330 origin
= decl_ultimate_origin (decl
);
15331 if (origin
!= NULL_TREE
&& TREE_CODE (origin
) == PARM_DECL
)
15332 gen_formal_parameter_die (decl
, origin
, context_die
);
15334 gen_variable_die (decl
, origin
, context_die
);
15338 /* Ignore the nameless fields that are used to skip bits but handle C++
15339 anonymous unions and structs. */
15340 if (DECL_NAME (decl
) != NULL_TREE
15341 || TREE_CODE (TREE_TYPE (decl
)) == UNION_TYPE
15342 || TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
)
15344 gen_type_die (member_declared_type (decl
), context_die
);
15345 gen_field_die (decl
, context_die
);
15350 if (DECL_BY_REFERENCE (decl_or_origin
))
15351 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin
)), context_die
);
15353 gen_type_die (TREE_TYPE (decl_or_origin
), context_die
);
15354 gen_formal_parameter_die (decl
, origin
, context_die
);
15357 case NAMESPACE_DECL
:
15358 case IMPORTED_DECL
:
15359 gen_namespace_die (decl
, context_die
);
15363 /* Probably some frontend-internal decl. Assume we don't care. */
15364 gcc_assert ((int)TREE_CODE (decl
) > NUM_TREE_CODES
);
15369 /* Output debug information for global decl DECL. Called from toplev.c after
15370 compilation proper has finished. */
15373 dwarf2out_global_decl (tree decl
)
15375 /* Output DWARF2 information for file-scope tentative data object
15376 declarations, file-scope (extern) function declarations (which
15377 had no corresponding body) and file-scope tagged type declarations
15378 and definitions which have not yet been forced out. */
15379 if (TREE_CODE (decl
) != FUNCTION_DECL
|| !DECL_INITIAL (decl
))
15380 dwarf2out_decl (decl
);
15383 /* Output debug information for type decl DECL. Called from toplev.c
15384 and from language front ends (to record built-in types). */
15386 dwarf2out_type_decl (tree decl
, int local
)
15389 dwarf2out_decl (decl
);
15392 /* Output debug information for imported module or decl DECL.
15393 NAME is non-NULL name in the lexical block if the decl has been renamed.
15394 LEXICAL_BLOCK is the lexical block (which TREE_CODE is a BLOCK)
15395 that DECL belongs to.
15396 LEXICAL_BLOCK_DIE is the DIE of LEXICAL_BLOCK. */
15398 dwarf2out_imported_module_or_decl_1 (tree decl
,
15400 tree lexical_block
,
15401 dw_die_ref lexical_block_die
)
15403 expanded_location xloc
;
15404 dw_die_ref imported_die
= NULL
;
15405 dw_die_ref at_import_die
;
15407 if (TREE_CODE (decl
) == IMPORTED_DECL
)
15409 xloc
= expand_location (DECL_SOURCE_LOCATION (decl
));
15410 decl
= IMPORTED_DECL_ASSOCIATED_DECL (decl
);
15414 xloc
= expand_location (input_location
);
15416 if (TREE_CODE (decl
) == TYPE_DECL
|| TREE_CODE (decl
) == CONST_DECL
)
15418 if (is_base_type (TREE_TYPE (decl
)))
15419 at_import_die
= base_type_die (TREE_TYPE (decl
));
15421 at_import_die
= force_type_die (TREE_TYPE (decl
));
15422 /* For namespace N { typedef void T; } using N::T; base_type_die
15423 returns NULL, but DW_TAG_imported_declaration requires
15424 the DW_AT_import tag. Force creation of DW_TAG_typedef. */
15425 if (!at_import_die
)
15427 gcc_assert (TREE_CODE (decl
) == TYPE_DECL
);
15428 gen_typedef_die (decl
, get_context_die (DECL_CONTEXT (decl
)));
15429 at_import_die
= lookup_type_die (TREE_TYPE (decl
));
15430 gcc_assert (at_import_die
);
15435 at_import_die
= lookup_decl_die (decl
);
15436 if (!at_import_die
)
15438 /* If we're trying to avoid duplicate debug info, we may not have
15439 emitted the member decl for this field. Emit it now. */
15440 if (TREE_CODE (decl
) == FIELD_DECL
)
15442 tree type
= DECL_CONTEXT (decl
);
15444 if (TYPE_CONTEXT (type
)
15445 && TYPE_P (TYPE_CONTEXT (type
))
15446 && !should_emit_struct_debug (TYPE_CONTEXT (type
),
15447 DINFO_USAGE_DIR_USE
))
15449 gen_type_die_for_member (type
, decl
,
15450 get_context_die (TYPE_CONTEXT (type
)));
15452 at_import_die
= force_decl_die (decl
);
15456 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
15457 imported_die
= new_die (DW_TAG_imported_module
,
15461 imported_die
= new_die (DW_TAG_imported_declaration
,
15465 add_AT_file (imported_die
, DW_AT_decl_file
, lookup_filename (xloc
.file
));
15466 add_AT_unsigned (imported_die
, DW_AT_decl_line
, xloc
.line
);
15468 add_AT_string (imported_die
, DW_AT_name
,
15469 IDENTIFIER_POINTER (name
));
15470 add_AT_die_ref (imported_die
, DW_AT_import
, at_import_die
);
15473 /* Output debug information for imported module or decl DECL.
15474 NAME is non-NULL name in context if the decl has been renamed.
15475 CHILD is true if decl is one of the renamed decls as part of
15476 importing whole module. */
15479 dwarf2out_imported_module_or_decl (tree decl
, tree name
, tree context
,
15482 /* dw_die_ref at_import_die; */
15483 dw_die_ref scope_die
;
15485 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
15490 /* To emit DW_TAG_imported_module or DW_TAG_imported_decl, we need two DIEs.
15491 We need decl DIE for reference and scope die. First, get DIE for the decl
15494 /* Get the scope die for decl context. Use comp_unit_die for global module
15495 or decl. If die is not found for non globals, force new die. */
15497 && TYPE_P (context
)
15498 && !should_emit_struct_debug (context
, DINFO_USAGE_DIR_USE
))
15500 scope_die
= get_context_die (context
);
15504 gcc_assert (scope_die
->die_child
);
15505 gcc_assert (scope_die
->die_child
->die_tag
== DW_TAG_imported_module
);
15506 gcc_assert (TREE_CODE (decl
) != NAMESPACE_DECL
);
15507 scope_die
= scope_die
->die_child
;
15510 /* OK, now we have DIEs for decl as well as scope. Emit imported die. */
15511 dwarf2out_imported_module_or_decl_1 (decl
, name
, context
, scope_die
);
15515 /* Write the debugging output for DECL. */
15518 dwarf2out_decl (tree decl
)
15520 dw_die_ref context_die
= comp_unit_die
;
15522 switch (TREE_CODE (decl
))
15527 case FUNCTION_DECL
:
15528 /* What we would really like to do here is to filter out all mere
15529 file-scope declarations of file-scope functions which are never
15530 referenced later within this translation unit (and keep all of ones
15531 that *are* referenced later on) but we aren't clairvoyant, so we have
15532 no idea which functions will be referenced in the future (i.e. later
15533 on within the current translation unit). So here we just ignore all
15534 file-scope function declarations which are not also definitions. If
15535 and when the debugger needs to know something about these functions,
15536 it will have to hunt around and find the DWARF information associated
15537 with the definition of the function.
15539 We can't just check DECL_EXTERNAL to find out which FUNCTION_DECL
15540 nodes represent definitions and which ones represent mere
15541 declarations. We have to check DECL_INITIAL instead. That's because
15542 the C front-end supports some weird semantics for "extern inline"
15543 function definitions. These can get inlined within the current
15544 translation unit (and thus, we need to generate Dwarf info for their
15545 abstract instances so that the Dwarf info for the concrete inlined
15546 instances can have something to refer to) but the compiler never
15547 generates any out-of-lines instances of such things (despite the fact
15548 that they *are* definitions).
15550 The important point is that the C front-end marks these "extern
15551 inline" functions as DECL_EXTERNAL, but we need to generate DWARF for
15552 them anyway. Note that the C++ front-end also plays some similar games
15553 for inline function definitions appearing within include files which
15554 also contain `#pragma interface' pragmas. */
15555 if (DECL_INITIAL (decl
) == NULL_TREE
)
15558 /* If we're a nested function, initially use a parent of NULL; if we're
15559 a plain function, this will be fixed up in decls_for_scope. If
15560 we're a method, it will be ignored, since we already have a DIE. */
15561 if (decl_function_context (decl
)
15562 /* But if we're in terse mode, we don't care about scope. */
15563 && debug_info_level
> DINFO_LEVEL_TERSE
)
15564 context_die
= NULL
;
15568 /* Ignore this VAR_DECL if it refers to a file-scope extern data object
15569 declaration and if the declaration was never even referenced from
15570 within this entire compilation unit. We suppress these DIEs in
15571 order to save space in the .debug section (by eliminating entries
15572 which are probably useless). Note that we must not suppress
15573 block-local extern declarations (whether used or not) because that
15574 would screw-up the debugger's name lookup mechanism and cause it to
15575 miss things which really ought to be in scope at a given point. */
15576 if (DECL_EXTERNAL (decl
) && !TREE_USED (decl
))
15579 /* For local statics lookup proper context die. */
15580 if (TREE_STATIC (decl
) && decl_function_context (decl
))
15581 context_die
= lookup_decl_die (DECL_CONTEXT (decl
));
15583 /* If we are in terse mode, don't generate any DIEs to represent any
15584 variable declarations or definitions. */
15585 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
15590 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
15592 if (!is_fortran ())
15594 if (TREE_STATIC (decl
) && decl_function_context (decl
))
15595 context_die
= lookup_decl_die (DECL_CONTEXT (decl
));
15598 case NAMESPACE_DECL
:
15599 case IMPORTED_DECL
:
15600 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
15602 if (lookup_decl_die (decl
) != NULL
)
15607 /* Don't emit stubs for types unless they are needed by other DIEs. */
15608 if (TYPE_DECL_SUPPRESS_DEBUG (decl
))
15611 /* Don't bother trying to generate any DIEs to represent any of the
15612 normal built-in types for the language we are compiling. */
15613 if (DECL_IS_BUILTIN (decl
))
15615 /* OK, we need to generate one for `bool' so GDB knows what type
15616 comparisons have. */
15618 && TREE_CODE (TREE_TYPE (decl
)) == BOOLEAN_TYPE
15619 && ! DECL_IGNORED_P (decl
))
15620 modified_type_die (TREE_TYPE (decl
), 0, 0, NULL
);
15625 /* If we are in terse mode, don't generate any DIEs for types. */
15626 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
15629 /* If we're a function-scope tag, initially use a parent of NULL;
15630 this will be fixed up in decls_for_scope. */
15631 if (decl_function_context (decl
))
15632 context_die
= NULL
;
15640 gen_decl_die (decl
, NULL
, context_die
);
15643 /* Output a marker (i.e. a label) for the beginning of the generated code for
15644 a lexical block. */
15647 dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED
,
15648 unsigned int blocknum
)
15650 switch_to_section (current_function_section ());
15651 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, BLOCK_BEGIN_LABEL
, blocknum
);
15654 /* Output a marker (i.e. a label) for the end of the generated code for a
15658 dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED
, unsigned int blocknum
)
15660 switch_to_section (current_function_section ());
15661 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, BLOCK_END_LABEL
, blocknum
);
15664 /* Returns nonzero if it is appropriate not to emit any debugging
15665 information for BLOCK, because it doesn't contain any instructions.
15667 Don't allow this for blocks with nested functions or local classes
15668 as we would end up with orphans, and in the presence of scheduling
15669 we may end up calling them anyway. */
15672 dwarf2out_ignore_block (const_tree block
)
15677 for (decl
= BLOCK_VARS (block
); decl
; decl
= TREE_CHAIN (decl
))
15678 if (TREE_CODE (decl
) == FUNCTION_DECL
15679 || (TREE_CODE (decl
) == TYPE_DECL
&& TYPE_DECL_IS_STUB (decl
)))
15681 for (i
= 0; i
< BLOCK_NUM_NONLOCALIZED_VARS (block
); i
++)
15683 decl
= BLOCK_NONLOCALIZED_VAR (block
, i
);
15684 if (TREE_CODE (decl
) == FUNCTION_DECL
15685 || (TREE_CODE (decl
) == TYPE_DECL
&& TYPE_DECL_IS_STUB (decl
)))
15692 /* Hash table routines for file_hash. */
15695 file_table_eq (const void *p1_p
, const void *p2_p
)
15697 const struct dwarf_file_data
*const p1
=
15698 (const struct dwarf_file_data
*) p1_p
;
15699 const char *const p2
= (const char *) p2_p
;
15700 return strcmp (p1
->filename
, p2
) == 0;
15704 file_table_hash (const void *p_p
)
15706 const struct dwarf_file_data
*const p
= (const struct dwarf_file_data
*) p_p
;
15707 return htab_hash_string (p
->filename
);
15710 /* Lookup FILE_NAME (in the list of filenames that we know about here in
15711 dwarf2out.c) and return its "index". The index of each (known) filename is
15712 just a unique number which is associated with only that one filename. We
15713 need such numbers for the sake of generating labels (in the .debug_sfnames
15714 section) and references to those files numbers (in the .debug_srcinfo
15715 and.debug_macinfo sections). If the filename given as an argument is not
15716 found in our current list, add it to the list and assign it the next
15717 available unique index number. In order to speed up searches, we remember
15718 the index of the filename was looked up last. This handles the majority of
15721 static struct dwarf_file_data
*
15722 lookup_filename (const char *file_name
)
15725 struct dwarf_file_data
* created
;
15727 /* Check to see if the file name that was searched on the previous
15728 call matches this file name. If so, return the index. */
15729 if (file_table_last_lookup
15730 && (file_name
== file_table_last_lookup
->filename
15731 || strcmp (file_table_last_lookup
->filename
, file_name
) == 0))
15732 return file_table_last_lookup
;
15734 /* Didn't match the previous lookup, search the table. */
15735 slot
= htab_find_slot_with_hash (file_table
, file_name
,
15736 htab_hash_string (file_name
), INSERT
);
15738 return (struct dwarf_file_data
*) *slot
;
15740 created
= GGC_NEW (struct dwarf_file_data
);
15741 created
->filename
= file_name
;
15742 created
->emitted_number
= 0;
15747 /* If the assembler will construct the file table, then translate the compiler
15748 internal file table number into the assembler file table number, and emit
15749 a .file directive if we haven't already emitted one yet. The file table
15750 numbers are different because we prune debug info for unused variables and
15751 types, which may include filenames. */
15754 maybe_emit_file (struct dwarf_file_data
* fd
)
15756 if (! fd
->emitted_number
)
15758 if (last_emitted_file
)
15759 fd
->emitted_number
= last_emitted_file
->emitted_number
+ 1;
15761 fd
->emitted_number
= 1;
15762 last_emitted_file
= fd
;
15764 if (DWARF2_ASM_LINE_DEBUG_INFO
)
15766 fprintf (asm_out_file
, "\t.file %u ", fd
->emitted_number
);
15767 output_quoted_string (asm_out_file
,
15768 remap_debug_filename (fd
->filename
));
15769 fputc ('\n', asm_out_file
);
15773 return fd
->emitted_number
;
15776 /* Replace DW_AT_name for the decl with name. */
15779 dwarf2out_set_name (tree decl
, tree name
)
15784 die
= TYPE_SYMTAB_DIE (decl
);
15788 attr
= get_AT (die
, DW_AT_name
);
15791 struct indirect_string_node
*node
;
15793 node
= find_AT_string (dwarf2_name (name
, 0));
15794 /* replace the string. */
15795 attr
->dw_attr_val
.v
.val_str
= node
;
15799 add_name_attribute (die
, dwarf2_name (name
, 0));
15801 /* Called by the final INSN scan whenever we see a var location. We
15802 use it to drop labels in the right places, and throw the location in
15803 our lookup table. */
15806 dwarf2out_var_location (rtx loc_note
)
15808 char loclabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
15809 struct var_loc_node
*newloc
;
15811 static rtx last_insn
;
15812 static const char *last_label
;
15815 if (!DECL_P (NOTE_VAR_LOCATION_DECL (loc_note
)))
15817 prev_insn
= PREV_INSN (loc_note
);
15819 newloc
= GGC_CNEW (struct var_loc_node
);
15820 /* If the insn we processed last time is the previous insn
15821 and it is also a var location note, use the label we emitted
15823 if (last_insn
!= NULL_RTX
15824 && last_insn
== prev_insn
15825 && NOTE_P (prev_insn
)
15826 && NOTE_KIND (prev_insn
) == NOTE_INSN_VAR_LOCATION
)
15828 newloc
->label
= last_label
;
15832 ASM_GENERATE_INTERNAL_LABEL (loclabel
, "LVL", loclabel_num
);
15833 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, "LVL", loclabel_num
);
15835 newloc
->label
= ggc_strdup (loclabel
);
15837 newloc
->var_loc_note
= loc_note
;
15838 newloc
->next
= NULL
;
15840 if (cfun
&& in_cold_section_p
)
15841 newloc
->section_label
= crtl
->subsections
.cold_section_label
;
15843 newloc
->section_label
= text_section_label
;
15845 last_insn
= loc_note
;
15846 last_label
= newloc
->label
;
15847 decl
= NOTE_VAR_LOCATION_DECL (loc_note
);
15848 add_var_loc_to_decl (decl
, newloc
);
15851 /* We need to reset the locations at the beginning of each
15852 function. We can't do this in the end_function hook, because the
15853 declarations that use the locations won't have been output when
15854 that hook is called. Also compute have_multiple_function_sections here. */
15857 dwarf2out_begin_function (tree fun
)
15859 htab_empty (decl_loc_table
);
15861 if (function_section (fun
) != text_section
)
15862 have_multiple_function_sections
= true;
15864 dwarf2out_note_section_used ();
15867 /* Output a label to mark the beginning of a source code line entry
15868 and record information relating to this source line, in
15869 'line_info_table' for later output of the .debug_line section. */
15872 dwarf2out_source_line (unsigned int line
, const char *filename
)
15874 if (debug_info_level
>= DINFO_LEVEL_NORMAL
15877 int file_num
= maybe_emit_file (lookup_filename (filename
));
15879 switch_to_section (current_function_section ());
15881 /* If requested, emit something human-readable. */
15882 if (flag_debug_asm
)
15883 fprintf (asm_out_file
, "\t%s %s:%d\n", ASM_COMMENT_START
,
15886 if (DWARF2_ASM_LINE_DEBUG_INFO
)
15888 /* Emit the .loc directive understood by GNU as. */
15889 fprintf (asm_out_file
, "\t.loc %d %d 0\n", file_num
, line
);
15891 /* Indicate that line number info exists. */
15892 line_info_table_in_use
++;
15894 else if (function_section (current_function_decl
) != text_section
)
15896 dw_separate_line_info_ref line_info
;
15897 targetm
.asm_out
.internal_label (asm_out_file
,
15898 SEPARATE_LINE_CODE_LABEL
,
15899 separate_line_info_table_in_use
);
15901 /* Expand the line info table if necessary. */
15902 if (separate_line_info_table_in_use
15903 == separate_line_info_table_allocated
)
15905 separate_line_info_table_allocated
+= LINE_INFO_TABLE_INCREMENT
;
15906 separate_line_info_table
15907 = GGC_RESIZEVEC (dw_separate_line_info_entry
,
15908 separate_line_info_table
,
15909 separate_line_info_table_allocated
);
15910 memset (separate_line_info_table
15911 + separate_line_info_table_in_use
,
15913 (LINE_INFO_TABLE_INCREMENT
15914 * sizeof (dw_separate_line_info_entry
)));
15917 /* Add the new entry at the end of the line_info_table. */
15919 = &separate_line_info_table
[separate_line_info_table_in_use
++];
15920 line_info
->dw_file_num
= file_num
;
15921 line_info
->dw_line_num
= line
;
15922 line_info
->function
= current_function_funcdef_no
;
15926 dw_line_info_ref line_info
;
15928 targetm
.asm_out
.internal_label (asm_out_file
, LINE_CODE_LABEL
,
15929 line_info_table_in_use
);
15931 /* Expand the line info table if necessary. */
15932 if (line_info_table_in_use
== line_info_table_allocated
)
15934 line_info_table_allocated
+= LINE_INFO_TABLE_INCREMENT
;
15936 = GGC_RESIZEVEC (dw_line_info_entry
, line_info_table
,
15937 line_info_table_allocated
);
15938 memset (line_info_table
+ line_info_table_in_use
, 0,
15939 LINE_INFO_TABLE_INCREMENT
* sizeof (dw_line_info_entry
));
15942 /* Add the new entry at the end of the line_info_table. */
15943 line_info
= &line_info_table
[line_info_table_in_use
++];
15944 line_info
->dw_file_num
= file_num
;
15945 line_info
->dw_line_num
= line
;
15950 /* Record the beginning of a new source file. */
15953 dwarf2out_start_source_file (unsigned int lineno
, const char *filename
)
15955 if (flag_eliminate_dwarf2_dups
)
15957 /* Record the beginning of the file for break_out_includes. */
15958 dw_die_ref bincl_die
;
15960 bincl_die
= new_die (DW_TAG_GNU_BINCL
, comp_unit_die
, NULL
);
15961 add_AT_string (bincl_die
, DW_AT_name
, remap_debug_filename (filename
));
15964 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
15966 int file_num
= maybe_emit_file (lookup_filename (filename
));
15968 switch_to_section (debug_macinfo_section
);
15969 dw2_asm_output_data (1, DW_MACINFO_start_file
, "Start new file");
15970 dw2_asm_output_data_uleb128 (lineno
, "Included from line number %d",
15973 dw2_asm_output_data_uleb128 (file_num
, "file %s", filename
);
15977 /* Record the end of a source file. */
15980 dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED
)
15982 if (flag_eliminate_dwarf2_dups
)
15983 /* Record the end of the file for break_out_includes. */
15984 new_die (DW_TAG_GNU_EINCL
, comp_unit_die
, NULL
);
15986 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
15988 switch_to_section (debug_macinfo_section
);
15989 dw2_asm_output_data (1, DW_MACINFO_end_file
, "End file");
15993 /* Called from debug_define in toplev.c. The `buffer' parameter contains
15994 the tail part of the directive line, i.e. the part which is past the
15995 initial whitespace, #, whitespace, directive-name, whitespace part. */
15998 dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED
,
15999 const char *buffer ATTRIBUTE_UNUSED
)
16001 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
16003 switch_to_section (debug_macinfo_section
);
16004 dw2_asm_output_data (1, DW_MACINFO_define
, "Define macro");
16005 dw2_asm_output_data_uleb128 (lineno
, "At line number %d", lineno
);
16006 dw2_asm_output_nstring (buffer
, -1, "The macro");
16010 /* Called from debug_undef in toplev.c. The `buffer' parameter contains
16011 the tail part of the directive line, i.e. the part which is past the
16012 initial whitespace, #, whitespace, directive-name, whitespace part. */
16015 dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED
,
16016 const char *buffer ATTRIBUTE_UNUSED
)
16018 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
16020 switch_to_section (debug_macinfo_section
);
16021 dw2_asm_output_data (1, DW_MACINFO_undef
, "Undefine macro");
16022 dw2_asm_output_data_uleb128 (lineno
, "At line number %d", lineno
);
16023 dw2_asm_output_nstring (buffer
, -1, "The macro");
16027 /* Set up for Dwarf output at the start of compilation. */
16030 dwarf2out_init (const char *filename ATTRIBUTE_UNUSED
)
16032 /* Allocate the file_table. */
16033 file_table
= htab_create_ggc (50, file_table_hash
,
16034 file_table_eq
, NULL
);
16036 /* Allocate the decl_die_table. */
16037 decl_die_table
= htab_create_ggc (10, decl_die_table_hash
,
16038 decl_die_table_eq
, NULL
);
16040 /* Allocate the decl_loc_table. */
16041 decl_loc_table
= htab_create_ggc (10, decl_loc_table_hash
,
16042 decl_loc_table_eq
, NULL
);
16044 /* Allocate the initial hunk of the decl_scope_table. */
16045 decl_scope_table
= VEC_alloc (tree
, gc
, 256);
16047 /* Allocate the initial hunk of the abbrev_die_table. */
16048 abbrev_die_table
= GGC_CNEWVEC (dw_die_ref
, ABBREV_DIE_TABLE_INCREMENT
);
16049 abbrev_die_table_allocated
= ABBREV_DIE_TABLE_INCREMENT
;
16050 /* Zero-th entry is allocated, but unused. */
16051 abbrev_die_table_in_use
= 1;
16053 /* Allocate the initial hunk of the line_info_table. */
16054 line_info_table
= GGC_CNEWVEC (dw_line_info_entry
, LINE_INFO_TABLE_INCREMENT
);
16055 line_info_table_allocated
= LINE_INFO_TABLE_INCREMENT
;
16057 /* Zero-th entry is allocated, but unused. */
16058 line_info_table_in_use
= 1;
16060 /* Allocate the pubtypes and pubnames vectors. */
16061 pubname_table
= VEC_alloc (pubname_entry
, gc
, 32);
16062 pubtype_table
= VEC_alloc (pubname_entry
, gc
, 32);
16064 /* Generate the initial DIE for the .debug section. Note that the (string)
16065 value given in the DW_AT_name attribute of the DW_TAG_compile_unit DIE
16066 will (typically) be a relative pathname and that this pathname should be
16067 taken as being relative to the directory from which the compiler was
16068 invoked when the given (base) source file was compiled. We will fill
16069 in this value in dwarf2out_finish. */
16070 comp_unit_die
= gen_compile_unit_die (NULL
);
16072 incomplete_types
= VEC_alloc (tree
, gc
, 64);
16074 used_rtx_array
= VEC_alloc (rtx
, gc
, 32);
16076 debug_info_section
= get_section (DEBUG_INFO_SECTION
,
16077 SECTION_DEBUG
, NULL
);
16078 debug_abbrev_section
= get_section (DEBUG_ABBREV_SECTION
,
16079 SECTION_DEBUG
, NULL
);
16080 debug_aranges_section
= get_section (DEBUG_ARANGES_SECTION
,
16081 SECTION_DEBUG
, NULL
);
16082 debug_macinfo_section
= get_section (DEBUG_MACINFO_SECTION
,
16083 SECTION_DEBUG
, NULL
);
16084 debug_line_section
= get_section (DEBUG_LINE_SECTION
,
16085 SECTION_DEBUG
, NULL
);
16086 debug_loc_section
= get_section (DEBUG_LOC_SECTION
,
16087 SECTION_DEBUG
, NULL
);
16088 debug_pubnames_section
= get_section (DEBUG_PUBNAMES_SECTION
,
16089 SECTION_DEBUG
, NULL
);
16090 #ifdef DEBUG_PUBTYPES_SECTION
16091 debug_pubtypes_section
= get_section (DEBUG_PUBTYPES_SECTION
,
16092 SECTION_DEBUG
, NULL
);
16094 debug_str_section
= get_section (DEBUG_STR_SECTION
,
16095 DEBUG_STR_SECTION_FLAGS
, NULL
);
16096 debug_ranges_section
= get_section (DEBUG_RANGES_SECTION
,
16097 SECTION_DEBUG
, NULL
);
16098 debug_frame_section
= get_section (DEBUG_FRAME_SECTION
,
16099 SECTION_DEBUG
, NULL
);
16101 ASM_GENERATE_INTERNAL_LABEL (text_end_label
, TEXT_END_LABEL
, 0);
16102 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label
,
16103 DEBUG_ABBREV_SECTION_LABEL
, 0);
16104 ASM_GENERATE_INTERNAL_LABEL (text_section_label
, TEXT_SECTION_LABEL
, 0);
16105 ASM_GENERATE_INTERNAL_LABEL (cold_text_section_label
,
16106 COLD_TEXT_SECTION_LABEL
, 0);
16107 ASM_GENERATE_INTERNAL_LABEL (cold_end_label
, COLD_END_LABEL
, 0);
16109 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label
,
16110 DEBUG_INFO_SECTION_LABEL
, 0);
16111 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label
,
16112 DEBUG_LINE_SECTION_LABEL
, 0);
16113 ASM_GENERATE_INTERNAL_LABEL (ranges_section_label
,
16114 DEBUG_RANGES_SECTION_LABEL
, 0);
16115 switch_to_section (debug_abbrev_section
);
16116 ASM_OUTPUT_LABEL (asm_out_file
, abbrev_section_label
);
16117 switch_to_section (debug_info_section
);
16118 ASM_OUTPUT_LABEL (asm_out_file
, debug_info_section_label
);
16119 switch_to_section (debug_line_section
);
16120 ASM_OUTPUT_LABEL (asm_out_file
, debug_line_section_label
);
16122 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
16124 switch_to_section (debug_macinfo_section
);
16125 ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label
,
16126 DEBUG_MACINFO_SECTION_LABEL
, 0);
16127 ASM_OUTPUT_LABEL (asm_out_file
, macinfo_section_label
);
16130 switch_to_section (text_section
);
16131 ASM_OUTPUT_LABEL (asm_out_file
, text_section_label
);
16132 if (flag_reorder_blocks_and_partition
)
16134 cold_text_section
= unlikely_text_section ();
16135 switch_to_section (cold_text_section
);
16136 ASM_OUTPUT_LABEL (asm_out_file
, cold_text_section_label
);
16140 /* A helper function for dwarf2out_finish called through
16141 ht_forall. Emit one queued .debug_str string. */
16144 output_indirect_string (void **h
, void *v ATTRIBUTE_UNUSED
)
16146 struct indirect_string_node
*node
= (struct indirect_string_node
*) *h
;
16148 if (node
->form
== DW_FORM_strp
)
16150 switch_to_section (debug_str_section
);
16151 ASM_OUTPUT_LABEL (asm_out_file
, node
->label
);
16152 assemble_string (node
->str
, strlen (node
->str
) + 1);
16158 #if ENABLE_ASSERT_CHECKING
16159 /* Verify that all marks are clear. */
16162 verify_marks_clear (dw_die_ref die
)
16166 gcc_assert (! die
->die_mark
);
16167 FOR_EACH_CHILD (die
, c
, verify_marks_clear (c
));
16169 #endif /* ENABLE_ASSERT_CHECKING */
16171 /* Clear the marks for a die and its children.
16172 Be cool if the mark isn't set. */
16175 prune_unmark_dies (dw_die_ref die
)
16181 FOR_EACH_CHILD (die
, c
, prune_unmark_dies (c
));
16184 /* Given DIE that we're marking as used, find any other dies
16185 it references as attributes and mark them as used. */
16188 prune_unused_types_walk_attribs (dw_die_ref die
)
16193 for (ix
= 0; VEC_iterate (dw_attr_node
, die
->die_attr
, ix
, a
); ix
++)
16195 if (a
->dw_attr_val
.val_class
== dw_val_class_die_ref
)
16197 /* A reference to another DIE.
16198 Make sure that it will get emitted. */
16199 prune_unused_types_mark (a
->dw_attr_val
.v
.val_die_ref
.die
, 1);
16201 /* Set the string's refcount to 0 so that prune_unused_types_mark
16202 accounts properly for it. */
16203 if (AT_class (a
) == dw_val_class_str
)
16204 a
->dw_attr_val
.v
.val_str
->refcount
= 0;
16209 /* Mark DIE as being used. If DOKIDS is true, then walk down
16210 to DIE's children. */
16213 prune_unused_types_mark (dw_die_ref die
, int dokids
)
16217 if (die
->die_mark
== 0)
16219 /* We haven't done this node yet. Mark it as used. */
16222 /* We also have to mark its parents as used.
16223 (But we don't want to mark our parents' kids due to this.) */
16224 if (die
->die_parent
)
16225 prune_unused_types_mark (die
->die_parent
, 0);
16227 /* Mark any referenced nodes. */
16228 prune_unused_types_walk_attribs (die
);
16230 /* If this node is a specification,
16231 also mark the definition, if it exists. */
16232 if (get_AT_flag (die
, DW_AT_declaration
) && die
->die_definition
)
16233 prune_unused_types_mark (die
->die_definition
, 1);
16236 if (dokids
&& die
->die_mark
!= 2)
16238 /* We need to walk the children, but haven't done so yet.
16239 Remember that we've walked the kids. */
16242 /* If this is an array type, we need to make sure our
16243 kids get marked, even if they're types. */
16244 if (die
->die_tag
== DW_TAG_array_type
)
16245 FOR_EACH_CHILD (die
, c
, prune_unused_types_mark (c
, 1));
16247 FOR_EACH_CHILD (die
, c
, prune_unused_types_walk (c
));
16251 /* For local classes, look if any static member functions were emitted
16252 and if so, mark them. */
16255 prune_unused_types_walk_local_classes (dw_die_ref die
)
16259 if (die
->die_mark
== 2)
16262 switch (die
->die_tag
)
16264 case DW_TAG_structure_type
:
16265 case DW_TAG_union_type
:
16266 case DW_TAG_class_type
:
16269 case DW_TAG_subprogram
:
16270 if (!get_AT_flag (die
, DW_AT_declaration
)
16271 || die
->die_definition
!= NULL
)
16272 prune_unused_types_mark (die
, 1);
16279 /* Mark children. */
16280 FOR_EACH_CHILD (die
, c
, prune_unused_types_walk_local_classes (c
));
16283 /* Walk the tree DIE and mark types that we actually use. */
16286 prune_unused_types_walk (dw_die_ref die
)
16290 /* Don't do anything if this node is already marked and
16291 children have been marked as well. */
16292 if (die
->die_mark
== 2)
16295 switch (die
->die_tag
)
16297 case DW_TAG_structure_type
:
16298 case DW_TAG_union_type
:
16299 case DW_TAG_class_type
:
16300 if (die
->die_perennial_p
)
16303 for (c
= die
->die_parent
; c
; c
= c
->die_parent
)
16304 if (c
->die_tag
== DW_TAG_subprogram
)
16307 /* Finding used static member functions inside of classes
16308 is needed just for local classes, because for other classes
16309 static member function DIEs with DW_AT_specification
16310 are emitted outside of the DW_TAG_*_type. If we ever change
16311 it, we'd need to call this even for non-local classes. */
16313 prune_unused_types_walk_local_classes (die
);
16315 /* It's a type node --- don't mark it. */
16318 case DW_TAG_const_type
:
16319 case DW_TAG_packed_type
:
16320 case DW_TAG_pointer_type
:
16321 case DW_TAG_reference_type
:
16322 case DW_TAG_volatile_type
:
16323 case DW_TAG_typedef
:
16324 case DW_TAG_array_type
:
16325 case DW_TAG_interface_type
:
16326 case DW_TAG_friend
:
16327 case DW_TAG_variant_part
:
16328 case DW_TAG_enumeration_type
:
16329 case DW_TAG_subroutine_type
:
16330 case DW_TAG_string_type
:
16331 case DW_TAG_set_type
:
16332 case DW_TAG_subrange_type
:
16333 case DW_TAG_ptr_to_member_type
:
16334 case DW_TAG_file_type
:
16335 if (die
->die_perennial_p
)
16338 /* It's a type node --- don't mark it. */
16342 /* Mark everything else. */
16346 if (die
->die_mark
== 0)
16350 /* Now, mark any dies referenced from here. */
16351 prune_unused_types_walk_attribs (die
);
16356 /* Mark children. */
16357 FOR_EACH_CHILD (die
, c
, prune_unused_types_walk (c
));
16360 /* Increment the string counts on strings referred to from DIE's
16364 prune_unused_types_update_strings (dw_die_ref die
)
16369 for (ix
= 0; VEC_iterate (dw_attr_node
, die
->die_attr
, ix
, a
); ix
++)
16370 if (AT_class (a
) == dw_val_class_str
)
16372 struct indirect_string_node
*s
= a
->dw_attr_val
.v
.val_str
;
16374 /* Avoid unnecessarily putting strings that are used less than
16375 twice in the hash table. */
16377 == ((DEBUG_STR_SECTION_FLAGS
& SECTION_MERGE
) ? 1 : 2))
16380 slot
= htab_find_slot_with_hash (debug_str_hash
, s
->str
,
16381 htab_hash_string (s
->str
),
16383 gcc_assert (*slot
== NULL
);
16389 /* Remove from the tree DIE any dies that aren't marked. */
16392 prune_unused_types_prune (dw_die_ref die
)
16396 gcc_assert (die
->die_mark
);
16397 prune_unused_types_update_strings (die
);
16399 if (! die
->die_child
)
16402 c
= die
->die_child
;
16404 dw_die_ref prev
= c
;
16405 for (c
= c
->die_sib
; ! c
->die_mark
; c
= c
->die_sib
)
16406 if (c
== die
->die_child
)
16408 /* No marked children between 'prev' and the end of the list. */
16410 /* No marked children at all. */
16411 die
->die_child
= NULL
;
16414 prev
->die_sib
= c
->die_sib
;
16415 die
->die_child
= prev
;
16420 if (c
!= prev
->die_sib
)
16422 prune_unused_types_prune (c
);
16423 } while (c
!= die
->die_child
);
16427 /* Remove dies representing declarations that we never use. */
16430 prune_unused_types (void)
16433 limbo_die_node
*node
;
16436 #if ENABLE_ASSERT_CHECKING
16437 /* All the marks should already be clear. */
16438 verify_marks_clear (comp_unit_die
);
16439 for (node
= limbo_die_list
; node
; node
= node
->next
)
16440 verify_marks_clear (node
->die
);
16441 #endif /* ENABLE_ASSERT_CHECKING */
16443 /* Set the mark on nodes that are actually used. */
16444 prune_unused_types_walk (comp_unit_die
);
16445 for (node
= limbo_die_list
; node
; node
= node
->next
)
16446 prune_unused_types_walk (node
->die
);
16448 /* Also set the mark on nodes referenced from the
16449 pubname_table or arange_table. */
16450 for (i
= 0; VEC_iterate (pubname_entry
, pubname_table
, i
, pub
); i
++)
16451 prune_unused_types_mark (pub
->die
, 1);
16452 for (i
= 0; i
< arange_table_in_use
; i
++)
16453 prune_unused_types_mark (arange_table
[i
], 1);
16455 /* Get rid of nodes that aren't marked; and update the string counts. */
16456 if (debug_str_hash
)
16457 htab_empty (debug_str_hash
);
16458 prune_unused_types_prune (comp_unit_die
);
16459 for (node
= limbo_die_list
; node
; node
= node
->next
)
16460 prune_unused_types_prune (node
->die
);
16462 /* Leave the marks clear. */
16463 prune_unmark_dies (comp_unit_die
);
16464 for (node
= limbo_die_list
; node
; node
= node
->next
)
16465 prune_unmark_dies (node
->die
);
16468 /* Set the parameter to true if there are any relative pathnames in
16471 file_table_relative_p (void ** slot
, void *param
)
16473 bool *p
= (bool *) param
;
16474 struct dwarf_file_data
*d
= (struct dwarf_file_data
*) *slot
;
16475 if (!IS_ABSOLUTE_PATH (d
->filename
))
16483 /* Output stuff that dwarf requires at the end of every file,
16484 and generate the DWARF-2 debugging info. */
16487 dwarf2out_finish (const char *filename
)
16489 limbo_die_node
*node
, *next_node
;
16490 dw_die_ref die
= 0;
16493 /* Add the name for the main input file now. We delayed this from
16494 dwarf2out_init to avoid complications with PCH. */
16495 add_name_attribute (comp_unit_die
, remap_debug_filename (filename
));
16496 if (!IS_ABSOLUTE_PATH (filename
))
16497 add_comp_dir_attribute (comp_unit_die
);
16498 else if (get_AT (comp_unit_die
, DW_AT_comp_dir
) == NULL
)
16501 htab_traverse (file_table
, file_table_relative_p
, &p
);
16503 add_comp_dir_attribute (comp_unit_die
);
16506 for (i
= 0; i
< VEC_length (deferred_locations
, deferred_locations_list
); i
++)
16508 add_location_or_const_value_attribute (
16509 VEC_index (deferred_locations
, deferred_locations_list
, i
)->die
,
16510 VEC_index (deferred_locations
, deferred_locations_list
, i
)->variable
,
16514 /* Traverse the limbo die list, and add parent/child links. The only
16515 dies without parents that should be here are concrete instances of
16516 inline functions, and the comp_unit_die. We can ignore the comp_unit_die.
16517 For concrete instances, we can get the parent die from the abstract
16519 for (node
= limbo_die_list
; node
; node
= next_node
)
16521 next_node
= node
->next
;
16524 if (die
->die_parent
== NULL
)
16526 dw_die_ref origin
= get_AT_ref (die
, DW_AT_abstract_origin
);
16529 add_child_die (origin
->die_parent
, die
);
16530 else if (die
== comp_unit_die
)
16532 else if (errorcount
> 0 || sorrycount
> 0)
16533 /* It's OK to be confused by errors in the input. */
16534 add_child_die (comp_unit_die
, die
);
16537 /* In certain situations, the lexical block containing a
16538 nested function can be optimized away, which results
16539 in the nested function die being orphaned. Likewise
16540 with the return type of that nested function. Force
16541 this to be a child of the containing function.
16543 It may happen that even the containing function got fully
16544 inlined and optimized out. In that case we are lost and
16545 assign the empty child. This should not be big issue as
16546 the function is likely unreachable too. */
16547 tree context
= NULL_TREE
;
16549 gcc_assert (node
->created_for
);
16551 if (DECL_P (node
->created_for
))
16552 context
= DECL_CONTEXT (node
->created_for
);
16553 else if (TYPE_P (node
->created_for
))
16554 context
= TYPE_CONTEXT (node
->created_for
);
16556 gcc_assert (context
16557 && (TREE_CODE (context
) == FUNCTION_DECL
16558 || TREE_CODE (context
) == NAMESPACE_DECL
));
16560 origin
= lookup_decl_die (context
);
16562 add_child_die (origin
, die
);
16564 add_child_die (comp_unit_die
, die
);
16569 limbo_die_list
= NULL
;
16571 /* Walk through the list of incomplete types again, trying once more to
16572 emit full debugging info for them. */
16573 retry_incomplete_types ();
16575 if (flag_eliminate_unused_debug_types
)
16576 prune_unused_types ();
16578 /* Generate separate CUs for each of the include files we've seen.
16579 They will go into limbo_die_list. */
16580 if (flag_eliminate_dwarf2_dups
)
16581 break_out_includes (comp_unit_die
);
16583 /* Traverse the DIE's and add add sibling attributes to those DIE's
16584 that have children. */
16585 add_sibling_attributes (comp_unit_die
);
16586 for (node
= limbo_die_list
; node
; node
= node
->next
)
16587 add_sibling_attributes (node
->die
);
16589 /* Output a terminator label for the .text section. */
16590 switch_to_section (text_section
);
16591 targetm
.asm_out
.internal_label (asm_out_file
, TEXT_END_LABEL
, 0);
16592 if (flag_reorder_blocks_and_partition
)
16594 switch_to_section (unlikely_text_section ());
16595 targetm
.asm_out
.internal_label (asm_out_file
, COLD_END_LABEL
, 0);
16598 /* We can only use the low/high_pc attributes if all of the code was
16600 if (!have_multiple_function_sections
)
16602 add_AT_lbl_id (comp_unit_die
, DW_AT_low_pc
, text_section_label
);
16603 add_AT_lbl_id (comp_unit_die
, DW_AT_high_pc
, text_end_label
);
16608 unsigned fde_idx
= 0;
16610 /* We need to give .debug_loc and .debug_ranges an appropriate
16611 "base address". Use zero so that these addresses become
16612 absolute. Historically, we've emitted the unexpected
16613 DW_AT_entry_pc instead of DW_AT_low_pc for this purpose.
16614 Emit both to give time for other tools to adapt. */
16615 add_AT_addr (comp_unit_die
, DW_AT_low_pc
, const0_rtx
);
16616 add_AT_addr (comp_unit_die
, DW_AT_entry_pc
, const0_rtx
);
16618 add_AT_range_list (comp_unit_die
, DW_AT_ranges
,
16619 add_ranges_by_labels (text_section_label
,
16621 if (flag_reorder_blocks_and_partition
)
16622 add_ranges_by_labels (cold_text_section_label
,
16625 for (fde_idx
= 0; fde_idx
< fde_table_in_use
; fde_idx
++)
16627 dw_fde_ref fde
= &fde_table
[fde_idx
];
16629 if (fde
->dw_fde_switched_sections
)
16631 add_ranges_by_labels (fde
->dw_fde_hot_section_label
,
16632 fde
->dw_fde_hot_section_end_label
);
16633 add_ranges_by_labels (fde
->dw_fde_unlikely_section_label
,
16634 fde
->dw_fde_unlikely_section_end_label
);
16637 add_ranges_by_labels (fde
->dw_fde_begin
,
16644 /* Output location list section if necessary. */
16645 if (have_location_lists
)
16647 /* Output the location lists info. */
16648 switch_to_section (debug_loc_section
);
16649 ASM_GENERATE_INTERNAL_LABEL (loc_section_label
,
16650 DEBUG_LOC_SECTION_LABEL
, 0);
16651 ASM_OUTPUT_LABEL (asm_out_file
, loc_section_label
);
16652 output_location_lists (die
);
16655 if (debug_info_level
>= DINFO_LEVEL_NORMAL
)
16656 add_AT_lineptr (comp_unit_die
, DW_AT_stmt_list
,
16657 debug_line_section_label
);
16659 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
16660 add_AT_macptr (comp_unit_die
, DW_AT_macro_info
, macinfo_section_label
);
16662 /* Output all of the compilation units. We put the main one last so that
16663 the offsets are available to output_pubnames. */
16664 for (node
= limbo_die_list
; node
; node
= node
->next
)
16665 output_comp_unit (node
->die
, 0);
16667 /* Output the main compilation unit if non-empty or if .debug_macinfo
16668 has been emitted. */
16669 output_comp_unit (comp_unit_die
, debug_info_level
>= DINFO_LEVEL_VERBOSE
);
16671 /* Output the abbreviation table. */
16672 switch_to_section (debug_abbrev_section
);
16673 output_abbrev_section ();
16675 /* Output public names table if necessary. */
16676 if (!VEC_empty (pubname_entry
, pubname_table
))
16678 switch_to_section (debug_pubnames_section
);
16679 output_pubnames (pubname_table
);
16682 #ifdef DEBUG_PUBTYPES_SECTION
16683 /* Output public types table if necessary. */
16684 if (!VEC_empty (pubname_entry
, pubtype_table
))
16686 switch_to_section (debug_pubtypes_section
);
16687 output_pubnames (pubtype_table
);
16691 /* Output the address range information. We only put functions in the arange
16692 table, so don't write it out if we don't have any. */
16693 if (fde_table_in_use
)
16695 switch_to_section (debug_aranges_section
);
16699 /* Output ranges section if necessary. */
16700 if (ranges_table_in_use
)
16702 switch_to_section (debug_ranges_section
);
16703 ASM_OUTPUT_LABEL (asm_out_file
, ranges_section_label
);
16707 /* Output the source line correspondence table. We must do this
16708 even if there is no line information. Otherwise, on an empty
16709 translation unit, we will generate a present, but empty,
16710 .debug_info section. IRIX 6.5 `nm' will then complain when
16711 examining the file. This is done late so that any filenames
16712 used by the debug_info section are marked as 'used'. */
16713 if (! DWARF2_ASM_LINE_DEBUG_INFO
)
16715 switch_to_section (debug_line_section
);
16716 output_line_info ();
16719 /* Have to end the macro section. */
16720 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
16722 switch_to_section (debug_macinfo_section
);
16723 dw2_asm_output_data (1, 0, "End compilation unit");
16726 /* If we emitted any DW_FORM_strp form attribute, output the string
16728 if (debug_str_hash
)
16729 htab_traverse (debug_str_hash
, output_indirect_string
, NULL
);
16733 /* This should never be used, but its address is needed for comparisons. */
16734 const struct gcc_debug_hooks dwarf2_debug_hooks
;
16736 #endif /* DWARF2_DEBUGGING_INFO */
16738 #include "gt-dwarf2out.h"