1 /* Output Dwarf2 format symbol table information from GCC.
2 Copyright (C) 1992, 1993, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
3 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
4 Free Software Foundation, Inc.
5 Contributed by Gary Funck (gary@intrepid.com).
6 Derived from DWARF 1 implementation of Ron Guilmette (rfg@monkeys.com).
7 Extensively modified by Jason Merrill (jason@cygnus.com).
9 This file is part of GCC.
11 GCC is free software; you can redistribute it and/or modify it under
12 the terms of the GNU General Public License as published by the Free
13 Software Foundation; either version 3, or (at your option) any later
16 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
17 WARRANTY; without even the implied warranty of MERCHANTABILITY or
18 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
21 You should have received a copy of the GNU General Public License
22 along with GCC; see the file COPYING3. If not see
23 <http://www.gnu.org/licenses/>. */
25 /* TODO: Emit .debug_line header even when there are no functions, since
26 the file numbers are used by .debug_info. Alternately, leave
27 out locations for types and decls.
28 Avoid talking about ctors and op= for PODs.
29 Factor out common prologue sequences into multiple CIEs. */
31 /* The first part of this file deals with the DWARF 2 frame unwind
32 information, which is also used by the GCC efficient exception handling
33 mechanism. The second part, controlled only by an #ifdef
34 DWARF2_DEBUGGING_INFO, deals with the other DWARF 2 debugging
37 /* DWARF2 Abbreviation Glossary:
39 CFA = Canonical Frame Address
40 a fixed address on the stack which identifies a call frame.
41 We define it to be the value of SP just before the call insn.
42 The CFA register and offset, which may change during the course
43 of the function, are used to calculate its value at runtime.
45 CFI = Call Frame Instruction
46 an instruction for the DWARF2 abstract machine
48 CIE = Common Information Entry
49 information describing information common to one or more FDEs
51 DIE = Debugging Information Entry
53 FDE = Frame Description Entry
54 information describing the stack call frame, in particular,
55 how to restore registers
57 DW_CFA_... = DWARF2 CFA call frame instruction
58 DW_TAG_... = DWARF2 DIE tag */
62 #include "coretypes.h"
68 #include "hard-reg-set.h"
70 #include "insn-config.h"
78 #include "dwarf2out.h"
79 #include "dwarf2asm.h"
84 #include "diagnostic.h"
85 #include "tree-pretty-print.h"
88 #include "langhooks.h"
93 #include "tree-pass.h"
94 #include "tree-flow.h"
96 #ifdef DWARF2_DEBUGGING_INFO
97 static void dwarf2out_source_line (unsigned int, const char *, int, bool);
99 static rtx last_var_location_insn
;
102 #ifdef VMS_DEBUGGING_INFO
103 int vms_file_stats_name (const char *, long long *, long *, char *, int *);
105 /* Define this macro to be a nonzero value if the directory specifications
106 which are output in the debug info should end with a separator. */
107 #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 1
108 /* Define this macro to evaluate to a nonzero value if GCC should refrain
109 from generating indirect strings in DWARF2 debug information, for instance
110 if your target is stuck with an old version of GDB that is unable to
111 process them properly or uses VMS Debug. */
112 #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 1
114 #define DWARF2_DIR_SHOULD_END_WITH_SEPARATOR 0
115 #define DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET 0
118 #ifndef DWARF2_FRAME_INFO
119 # ifdef DWARF2_DEBUGGING_INFO
120 # define DWARF2_FRAME_INFO \
121 (write_symbols == DWARF2_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
123 # define DWARF2_FRAME_INFO 0
127 /* Map register numbers held in the call frame info that gcc has
128 collected using DWARF_FRAME_REGNUM to those that should be output in
129 .debug_frame and .eh_frame. */
130 #ifndef DWARF2_FRAME_REG_OUT
131 #define DWARF2_FRAME_REG_OUT(REGNO, FOR_EH) (REGNO)
134 /* Save the result of dwarf2out_do_frame across PCH. */
135 static GTY(()) bool saved_do_cfi_asm
= 0;
137 /* Decide whether we want to emit frame unwind information for the current
141 dwarf2out_do_frame (void)
143 /* We want to emit correct CFA location expressions or lists, so we
144 have to return true if we're going to output debug info, even if
145 we're not going to output frame or unwind info. */
146 return (write_symbols
== DWARF2_DEBUG
147 || write_symbols
== VMS_AND_DWARF2_DEBUG
148 || DWARF2_FRAME_INFO
|| saved_do_cfi_asm
149 #ifdef DWARF2_UNWIND_INFO
150 || (DWARF2_UNWIND_INFO
151 && (flag_unwind_tables
152 || (flag_exceptions
&& ! USING_SJLJ_EXCEPTIONS
)))
157 /* Decide whether to emit frame unwind via assembler directives. */
160 dwarf2out_do_cfi_asm (void)
164 #ifdef MIPS_DEBUGGING_INFO
167 if (!flag_dwarf2_cfi_asm
|| !dwarf2out_do_frame ())
169 if (saved_do_cfi_asm
)
171 if (!HAVE_GAS_CFI_PERSONALITY_DIRECTIVE
)
174 /* Make sure the personality encoding is one the assembler can support.
175 In particular, aligned addresses can't be handled. */
176 enc
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,/*global=*/1);
177 if ((enc
& 0x70) != 0 && (enc
& 0x70) != DW_EH_PE_pcrel
)
179 enc
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,/*global=*/0);
180 if ((enc
& 0x70) != 0 && (enc
& 0x70) != DW_EH_PE_pcrel
)
183 if (!HAVE_GAS_CFI_SECTIONS_DIRECTIVE
)
185 #ifdef TARGET_UNWIND_INFO
188 if (USING_SJLJ_EXCEPTIONS
|| (!flag_unwind_tables
&& !flag_exceptions
))
193 saved_do_cfi_asm
= true;
197 /* The size of the target's pointer type. */
199 #define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
202 /* Array of RTXes referenced by the debugging information, which therefore
203 must be kept around forever. */
204 static GTY(()) VEC(rtx
,gc
) *used_rtx_array
;
206 /* A pointer to the base of a list of incomplete types which might be
207 completed at some later time. incomplete_types_list needs to be a
208 VEC(tree,gc) because we want to tell the garbage collector about
210 static GTY(()) VEC(tree
,gc
) *incomplete_types
;
212 /* A pointer to the base of a table of references to declaration
213 scopes. This table is a display which tracks the nesting
214 of declaration scopes at the current scope and containing
215 scopes. This table is used to find the proper place to
216 define type declaration DIE's. */
217 static GTY(()) VEC(tree
,gc
) *decl_scope_table
;
219 /* Pointers to various DWARF2 sections. */
220 static GTY(()) section
*debug_info_section
;
221 static GTY(()) section
*debug_abbrev_section
;
222 static GTY(()) section
*debug_aranges_section
;
223 static GTY(()) section
*debug_macinfo_section
;
224 static GTY(()) section
*debug_line_section
;
225 static GTY(()) section
*debug_loc_section
;
226 static GTY(()) section
*debug_pubnames_section
;
227 static GTY(()) section
*debug_pubtypes_section
;
228 static GTY(()) section
*debug_dcall_section
;
229 static GTY(()) section
*debug_vcall_section
;
230 static GTY(()) section
*debug_str_section
;
231 static GTY(()) section
*debug_ranges_section
;
232 static GTY(()) section
*debug_frame_section
;
234 /* Personality decl of current unit. Used only when assembler does not support
236 static GTY(()) rtx current_unit_personality
;
238 /* How to start an assembler comment. */
239 #ifndef ASM_COMMENT_START
240 #define ASM_COMMENT_START ";#"
243 typedef struct dw_cfi_struct
*dw_cfi_ref
;
244 typedef struct dw_fde_struct
*dw_fde_ref
;
245 typedef union dw_cfi_oprnd_struct
*dw_cfi_oprnd_ref
;
247 /* Call frames are described using a sequence of Call Frame
248 Information instructions. The register number, offset
249 and address fields are provided as possible operands;
250 their use is selected by the opcode field. */
252 enum dw_cfi_oprnd_type
{
254 dw_cfi_oprnd_reg_num
,
260 typedef union GTY(()) dw_cfi_oprnd_struct
{
261 unsigned int GTY ((tag ("dw_cfi_oprnd_reg_num"))) dw_cfi_reg_num
;
262 HOST_WIDE_INT
GTY ((tag ("dw_cfi_oprnd_offset"))) dw_cfi_offset
;
263 const char * GTY ((tag ("dw_cfi_oprnd_addr"))) dw_cfi_addr
;
264 struct dw_loc_descr_struct
* GTY ((tag ("dw_cfi_oprnd_loc"))) dw_cfi_loc
;
268 typedef struct GTY(()) dw_cfi_struct
{
269 dw_cfi_ref dw_cfi_next
;
270 enum dwarf_call_frame_info dw_cfi_opc
;
271 dw_cfi_oprnd
GTY ((desc ("dw_cfi_oprnd1_desc (%1.dw_cfi_opc)")))
273 dw_cfi_oprnd
GTY ((desc ("dw_cfi_oprnd2_desc (%1.dw_cfi_opc)")))
278 /* This is how we define the location of the CFA. We use to handle it
279 as REG + OFFSET all the time, but now it can be more complex.
280 It can now be either REG + CFA_OFFSET or *(REG + BASE_OFFSET) + CFA_OFFSET.
281 Instead of passing around REG and OFFSET, we pass a copy
282 of this structure. */
283 typedef struct GTY(()) cfa_loc
{
284 HOST_WIDE_INT offset
;
285 HOST_WIDE_INT base_offset
;
287 BOOL_BITFIELD indirect
: 1; /* 1 if CFA is accessed via a dereference. */
288 BOOL_BITFIELD in_use
: 1; /* 1 if a saved cfa is stored here. */
291 /* All call frame descriptions (FDE's) in the GCC generated DWARF
292 refer to a single Common Information Entry (CIE), defined at
293 the beginning of the .debug_frame section. This use of a single
294 CIE obviates the need to keep track of multiple CIE's
295 in the DWARF generation routines below. */
297 typedef struct GTY(()) dw_fde_struct
{
299 const char *dw_fde_begin
;
300 const char *dw_fde_current_label
;
301 const char *dw_fde_end
;
302 const char *dw_fde_vms_end_prologue
;
303 const char *dw_fde_vms_begin_epilogue
;
304 const char *dw_fde_hot_section_label
;
305 const char *dw_fde_hot_section_end_label
;
306 const char *dw_fde_unlikely_section_label
;
307 const char *dw_fde_unlikely_section_end_label
;
308 dw_cfi_ref dw_fde_cfi
;
309 dw_cfi_ref dw_fde_switch_cfi
; /* Last CFI before switching sections. */
310 HOST_WIDE_INT stack_realignment
;
311 unsigned funcdef_number
;
312 /* Dynamic realign argument pointer register. */
313 unsigned int drap_reg
;
314 /* Virtual dynamic realign argument pointer register. */
315 unsigned int vdrap_reg
;
316 /* These 3 flags are copied from rtl_data in function.h. */
317 unsigned all_throwers_are_sibcalls
: 1;
318 unsigned uses_eh_lsda
: 1;
319 unsigned nothrow
: 1;
320 /* Whether we did stack realign in this call frame. */
321 unsigned stack_realign
: 1;
322 /* Whether dynamic realign argument pointer register has been saved. */
323 unsigned drap_reg_saved
: 1;
324 /* True iff dw_fde_begin label is in text_section or cold_text_section. */
325 unsigned in_std_section
: 1;
326 /* True iff dw_fde_unlikely_section_label is in text_section or
327 cold_text_section. */
328 unsigned cold_in_std_section
: 1;
329 /* True iff switched sections. */
330 unsigned dw_fde_switched_sections
: 1;
331 /* True iff switching from cold to hot section. */
332 unsigned dw_fde_switched_cold_to_hot
: 1;
336 /* Maximum size (in bytes) of an artificially generated label. */
337 #define MAX_ARTIFICIAL_LABEL_BYTES 30
339 /* The size of addresses as they appear in the Dwarf 2 data.
340 Some architectures use word addresses to refer to code locations,
341 but Dwarf 2 info always uses byte addresses. On such machines,
342 Dwarf 2 addresses need to be larger than the architecture's
344 #ifndef DWARF2_ADDR_SIZE
345 #define DWARF2_ADDR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
348 /* The size in bytes of a DWARF field indicating an offset or length
349 relative to a debug info section, specified to be 4 bytes in the
350 DWARF-2 specification. The SGI/MIPS ABI defines it to be the same
353 #ifndef DWARF_OFFSET_SIZE
354 #define DWARF_OFFSET_SIZE 4
357 /* The size in bytes of a DWARF 4 type signature. */
359 #ifndef DWARF_TYPE_SIGNATURE_SIZE
360 #define DWARF_TYPE_SIGNATURE_SIZE 8
363 /* According to the (draft) DWARF 3 specification, the initial length
364 should either be 4 or 12 bytes. When it's 12 bytes, the first 4
365 bytes are 0xffffffff, followed by the length stored in the next 8
368 However, the SGI/MIPS ABI uses an initial length which is equal to
369 DWARF_OFFSET_SIZE. It is defined (elsewhere) accordingly. */
371 #ifndef DWARF_INITIAL_LENGTH_SIZE
372 #define DWARF_INITIAL_LENGTH_SIZE (DWARF_OFFSET_SIZE == 4 ? 4 : 12)
375 /* Round SIZE up to the nearest BOUNDARY. */
376 #define DWARF_ROUND(SIZE,BOUNDARY) \
377 ((((SIZE) + (BOUNDARY) - 1) / (BOUNDARY)) * (BOUNDARY))
379 /* Offsets recorded in opcodes are a multiple of this alignment factor. */
380 #ifndef DWARF_CIE_DATA_ALIGNMENT
381 #ifdef STACK_GROWS_DOWNWARD
382 #define DWARF_CIE_DATA_ALIGNMENT (-((int) UNITS_PER_WORD))
384 #define DWARF_CIE_DATA_ALIGNMENT ((int) UNITS_PER_WORD)
388 /* CIE identifier. */
389 #if HOST_BITS_PER_WIDE_INT >= 64
390 #define DWARF_CIE_ID \
391 (unsigned HOST_WIDE_INT) (DWARF_OFFSET_SIZE == 4 ? DW_CIE_ID : DW64_CIE_ID)
393 #define DWARF_CIE_ID DW_CIE_ID
396 /* A pointer to the base of a table that contains frame description
397 information for each routine. */
398 static GTY((length ("fde_table_allocated"))) dw_fde_ref fde_table
;
400 /* Number of elements currently allocated for fde_table. */
401 static GTY(()) unsigned fde_table_allocated
;
403 /* Number of elements in fde_table currently in use. */
404 static GTY(()) unsigned fde_table_in_use
;
406 /* Size (in elements) of increments by which we may expand the
408 #define FDE_TABLE_INCREMENT 256
410 /* Get the current fde_table entry we should use. */
412 static inline dw_fde_ref
415 return fde_table_in_use
? &fde_table
[fde_table_in_use
- 1] : NULL
;
418 /* A list of call frame insns for the CIE. */
419 static GTY(()) dw_cfi_ref cie_cfi_head
;
421 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
422 /* Some DWARF extensions (e.g., MIPS/SGI) implement a subprogram
423 attribute that accelerates the lookup of the FDE associated
424 with the subprogram. This variable holds the table index of the FDE
425 associated with the current function (body) definition. */
426 static unsigned current_funcdef_fde
;
429 struct GTY(()) indirect_string_node
{
431 unsigned int refcount
;
432 enum dwarf_form form
;
436 static GTY ((param_is (struct indirect_string_node
))) htab_t debug_str_hash
;
438 /* True if the compilation unit has location entries that reference
440 static GTY(()) bool debug_str_hash_forced
= false;
442 static GTY(()) int dw2_string_counter
;
443 static GTY(()) unsigned long dwarf2out_cfi_label_num
;
445 /* True if the compilation unit places functions in more than one section. */
446 static GTY(()) bool have_multiple_function_sections
= false;
448 /* Whether the default text and cold text sections have been used at all. */
450 static GTY(()) bool text_section_used
= false;
451 static GTY(()) bool cold_text_section_used
= false;
453 /* The default cold text section. */
454 static GTY(()) section
*cold_text_section
;
456 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
458 /* Forward declarations for functions defined in this file. */
460 static char *stripattributes (const char *);
461 static const char *dwarf_cfi_name (unsigned);
462 static dw_cfi_ref
new_cfi (void);
463 static void add_cfi (dw_cfi_ref
*, dw_cfi_ref
);
464 static void add_fde_cfi (const char *, dw_cfi_ref
);
465 static void lookup_cfa_1 (dw_cfi_ref
, dw_cfa_location
*, dw_cfa_location
*);
466 static void lookup_cfa (dw_cfa_location
*);
467 static void reg_save (const char *, unsigned, unsigned, HOST_WIDE_INT
);
468 #ifdef DWARF2_UNWIND_INFO
469 static void initial_return_save (rtx
);
471 static HOST_WIDE_INT
stack_adjust_offset (const_rtx
, HOST_WIDE_INT
,
473 static void output_cfi (dw_cfi_ref
, dw_fde_ref
, int);
474 static void output_cfi_directive (dw_cfi_ref
);
475 static void output_call_frame_info (int);
476 static void dwarf2out_note_section_used (void);
477 static void flush_queued_reg_saves (void);
478 static bool clobbers_queued_reg_save (const_rtx
);
479 static void dwarf2out_frame_debug_expr (rtx
, const char *);
481 /* Support for complex CFA locations. */
482 static void output_cfa_loc (dw_cfi_ref
);
483 static void output_cfa_loc_raw (dw_cfi_ref
);
484 static void get_cfa_from_loc_descr (dw_cfa_location
*,
485 struct dw_loc_descr_struct
*);
486 static struct dw_loc_descr_struct
*build_cfa_loc
487 (dw_cfa_location
*, HOST_WIDE_INT
);
488 static struct dw_loc_descr_struct
*build_cfa_aligned_loc
489 (HOST_WIDE_INT
, HOST_WIDE_INT
);
490 static void def_cfa_1 (const char *, dw_cfa_location
*);
492 /* How to start an assembler comment. */
493 #ifndef ASM_COMMENT_START
494 #define ASM_COMMENT_START ";#"
497 /* Data and reference forms for relocatable data. */
498 #define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
499 #define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
501 #ifndef DEBUG_FRAME_SECTION
502 #define DEBUG_FRAME_SECTION ".debug_frame"
505 #ifndef FUNC_BEGIN_LABEL
506 #define FUNC_BEGIN_LABEL "LFB"
509 #ifndef FUNC_END_LABEL
510 #define FUNC_END_LABEL "LFE"
513 #ifndef PROLOGUE_END_LABEL
514 #define PROLOGUE_END_LABEL "LPE"
517 #ifndef EPILOGUE_BEGIN_LABEL
518 #define EPILOGUE_BEGIN_LABEL "LEB"
521 #ifndef FRAME_BEGIN_LABEL
522 #define FRAME_BEGIN_LABEL "Lframe"
524 #define CIE_AFTER_SIZE_LABEL "LSCIE"
525 #define CIE_END_LABEL "LECIE"
526 #define FDE_LABEL "LSFDE"
527 #define FDE_AFTER_SIZE_LABEL "LASFDE"
528 #define FDE_END_LABEL "LEFDE"
529 #define LINE_NUMBER_BEGIN_LABEL "LSLT"
530 #define LINE_NUMBER_END_LABEL "LELT"
531 #define LN_PROLOG_AS_LABEL "LASLTP"
532 #define LN_PROLOG_END_LABEL "LELTP"
533 #define DIE_LABEL_PREFIX "DW"
535 /* The DWARF 2 CFA column which tracks the return address. Normally this
536 is the column for PC, or the first column after all of the hard
538 #ifndef DWARF_FRAME_RETURN_COLUMN
540 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (PC_REGNUM)
542 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGISTERS
546 /* The mapping from gcc register number to DWARF 2 CFA column number. By
547 default, we just provide columns for all registers. */
548 #ifndef DWARF_FRAME_REGNUM
549 #define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG)
552 /* Hook used by __throw. */
555 expand_builtin_dwarf_sp_column (void)
557 unsigned int dwarf_regnum
= DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM
);
558 return GEN_INT (DWARF2_FRAME_REG_OUT (dwarf_regnum
, 1));
561 /* Return a pointer to a copy of the section string name S with all
562 attributes stripped off, and an asterisk prepended (for assemble_name). */
565 stripattributes (const char *s
)
567 char *stripped
= XNEWVEC (char, strlen (s
) + 2);
572 while (*s
&& *s
!= ',')
579 /* MEM is a memory reference for the register size table, each element of
580 which has mode MODE. Initialize column C as a return address column. */
583 init_return_column_size (enum machine_mode mode
, rtx mem
, unsigned int c
)
585 HOST_WIDE_INT offset
= c
* GET_MODE_SIZE (mode
);
586 HOST_WIDE_INT size
= GET_MODE_SIZE (Pmode
);
587 emit_move_insn (adjust_address (mem
, mode
, offset
), GEN_INT (size
));
590 /* Divide OFF by DWARF_CIE_DATA_ALIGNMENT, asserting no remainder. */
592 static inline HOST_WIDE_INT
593 div_data_align (HOST_WIDE_INT off
)
595 HOST_WIDE_INT r
= off
/ DWARF_CIE_DATA_ALIGNMENT
;
596 gcc_assert (r
* DWARF_CIE_DATA_ALIGNMENT
== off
);
600 /* Return true if we need a signed version of a given opcode
601 (e.g. DW_CFA_offset_extended_sf vs DW_CFA_offset_extended). */
604 need_data_align_sf_opcode (HOST_WIDE_INT off
)
606 return DWARF_CIE_DATA_ALIGNMENT
< 0 ? off
> 0 : off
< 0;
609 /* Generate code to initialize the register size table. */
612 expand_builtin_init_dwarf_reg_sizes (tree address
)
615 enum machine_mode mode
= TYPE_MODE (char_type_node
);
616 rtx addr
= expand_normal (address
);
617 rtx mem
= gen_rtx_MEM (BLKmode
, addr
);
618 bool wrote_return_column
= false;
620 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
622 int rnum
= DWARF2_FRAME_REG_OUT (DWARF_FRAME_REGNUM (i
), 1);
624 if (rnum
< DWARF_FRAME_REGISTERS
)
626 HOST_WIDE_INT offset
= rnum
* GET_MODE_SIZE (mode
);
627 enum machine_mode save_mode
= reg_raw_mode
[i
];
630 if (HARD_REGNO_CALL_PART_CLOBBERED (i
, save_mode
))
631 save_mode
= choose_hard_reg_mode (i
, 1, true);
632 if (DWARF_FRAME_REGNUM (i
) == DWARF_FRAME_RETURN_COLUMN
)
634 if (save_mode
== VOIDmode
)
636 wrote_return_column
= true;
638 size
= GET_MODE_SIZE (save_mode
);
642 emit_move_insn (adjust_address (mem
, mode
, offset
),
643 gen_int_mode (size
, mode
));
647 if (!wrote_return_column
)
648 init_return_column_size (mode
, mem
, DWARF_FRAME_RETURN_COLUMN
);
650 #ifdef DWARF_ALT_FRAME_RETURN_COLUMN
651 init_return_column_size (mode
, mem
, DWARF_ALT_FRAME_RETURN_COLUMN
);
654 targetm
.init_dwarf_reg_sizes_extra (address
);
657 /* Convert a DWARF call frame info. operation to its string name */
660 dwarf_cfi_name (unsigned int cfi_opc
)
664 case DW_CFA_advance_loc
:
665 return "DW_CFA_advance_loc";
667 return "DW_CFA_offset";
669 return "DW_CFA_restore";
673 return "DW_CFA_set_loc";
674 case DW_CFA_advance_loc1
:
675 return "DW_CFA_advance_loc1";
676 case DW_CFA_advance_loc2
:
677 return "DW_CFA_advance_loc2";
678 case DW_CFA_advance_loc4
:
679 return "DW_CFA_advance_loc4";
680 case DW_CFA_offset_extended
:
681 return "DW_CFA_offset_extended";
682 case DW_CFA_restore_extended
:
683 return "DW_CFA_restore_extended";
684 case DW_CFA_undefined
:
685 return "DW_CFA_undefined";
686 case DW_CFA_same_value
:
687 return "DW_CFA_same_value";
688 case DW_CFA_register
:
689 return "DW_CFA_register";
690 case DW_CFA_remember_state
:
691 return "DW_CFA_remember_state";
692 case DW_CFA_restore_state
:
693 return "DW_CFA_restore_state";
695 return "DW_CFA_def_cfa";
696 case DW_CFA_def_cfa_register
:
697 return "DW_CFA_def_cfa_register";
698 case DW_CFA_def_cfa_offset
:
699 return "DW_CFA_def_cfa_offset";
702 case DW_CFA_def_cfa_expression
:
703 return "DW_CFA_def_cfa_expression";
704 case DW_CFA_expression
:
705 return "DW_CFA_expression";
706 case DW_CFA_offset_extended_sf
:
707 return "DW_CFA_offset_extended_sf";
708 case DW_CFA_def_cfa_sf
:
709 return "DW_CFA_def_cfa_sf";
710 case DW_CFA_def_cfa_offset_sf
:
711 return "DW_CFA_def_cfa_offset_sf";
713 /* SGI/MIPS specific */
714 case DW_CFA_MIPS_advance_loc8
:
715 return "DW_CFA_MIPS_advance_loc8";
718 case DW_CFA_GNU_window_save
:
719 return "DW_CFA_GNU_window_save";
720 case DW_CFA_GNU_args_size
:
721 return "DW_CFA_GNU_args_size";
722 case DW_CFA_GNU_negative_offset_extended
:
723 return "DW_CFA_GNU_negative_offset_extended";
726 return "DW_CFA_<unknown>";
730 /* Return a pointer to a newly allocated Call Frame Instruction. */
732 static inline dw_cfi_ref
735 dw_cfi_ref cfi
= ggc_alloc_dw_cfi_node ();
737 cfi
->dw_cfi_next
= NULL
;
738 cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
= 0;
739 cfi
->dw_cfi_oprnd2
.dw_cfi_reg_num
= 0;
744 /* Add a Call Frame Instruction to list of instructions. */
747 add_cfi (dw_cfi_ref
*list_head
, dw_cfi_ref cfi
)
750 dw_fde_ref fde
= current_fde ();
752 /* When DRAP is used, CFA is defined with an expression. Redefine
753 CFA may lead to a different CFA value. */
754 /* ??? Of course, this heuristic fails when we're annotating epilogues,
755 because of course we'll always want to redefine the CFA back to the
756 stack pointer on the way out. Where should we move this check? */
757 if (0 && fde
&& fde
->drap_reg
!= INVALID_REGNUM
)
758 switch (cfi
->dw_cfi_opc
)
760 case DW_CFA_def_cfa_register
:
761 case DW_CFA_def_cfa_offset
:
762 case DW_CFA_def_cfa_offset_sf
:
764 case DW_CFA_def_cfa_sf
:
771 /* Find the end of the chain. */
772 for (p
= list_head
; (*p
) != NULL
; p
= &(*p
)->dw_cfi_next
)
778 /* Generate a new label for the CFI info to refer to. FORCE is true
779 if a label needs to be output even when using .cfi_* directives. */
782 dwarf2out_cfi_label (bool force
)
784 static char label
[20];
786 if (!force
&& dwarf2out_do_cfi_asm ())
788 /* In this case, we will be emitting the asm directive instead of
789 the label, so just return a placeholder to keep the rest of the
791 strcpy (label
, "<do not output>");
795 ASM_GENERATE_INTERNAL_LABEL (label
, "LCFI", dwarf2out_cfi_label_num
++);
796 ASM_OUTPUT_LABEL (asm_out_file
, label
);
802 /* True if remember_state should be emitted before following CFI directive. */
803 static bool emit_cfa_remember
;
805 /* Add CFI to the current fde at the PC value indicated by LABEL if specified,
806 or to the CIE if LABEL is NULL. */
809 add_fde_cfi (const char *label
, dw_cfi_ref cfi
)
811 dw_cfi_ref
*list_head
;
813 if (emit_cfa_remember
)
815 dw_cfi_ref cfi_remember
;
817 /* Emit the state save. */
818 emit_cfa_remember
= false;
819 cfi_remember
= new_cfi ();
820 cfi_remember
->dw_cfi_opc
= DW_CFA_remember_state
;
821 add_fde_cfi (label
, cfi_remember
);
824 list_head
= &cie_cfi_head
;
826 if (dwarf2out_do_cfi_asm ())
830 dw_fde_ref fde
= current_fde ();
832 gcc_assert (fde
!= NULL
);
834 /* We still have to add the cfi to the list so that lookup_cfa
835 works later on. When -g2 and above we even need to force
836 emitting of CFI labels and add to list a DW_CFA_set_loc for
837 convert_cfa_to_fb_loc_list purposes. If we're generating
838 DWARF3 output we use DW_OP_call_frame_cfa and so don't use
839 convert_cfa_to_fb_loc_list. */
840 if (dwarf_version
== 2
841 && debug_info_level
> DINFO_LEVEL_TERSE
842 && (write_symbols
== DWARF2_DEBUG
843 || write_symbols
== VMS_AND_DWARF2_DEBUG
))
845 switch (cfi
->dw_cfi_opc
)
847 case DW_CFA_def_cfa_offset
:
848 case DW_CFA_def_cfa_offset_sf
:
849 case DW_CFA_def_cfa_register
:
851 case DW_CFA_def_cfa_sf
:
852 case DW_CFA_def_cfa_expression
:
853 case DW_CFA_restore_state
:
854 if (*label
== 0 || strcmp (label
, "<do not output>") == 0)
855 label
= dwarf2out_cfi_label (true);
857 if (fde
->dw_fde_current_label
== NULL
858 || strcmp (label
, fde
->dw_fde_current_label
) != 0)
862 label
= xstrdup (label
);
864 /* Set the location counter to the new label. */
866 /* It doesn't metter whether DW_CFA_set_loc
867 or DW_CFA_advance_loc4 is added here, those aren't
868 emitted into assembly, only looked up by
869 convert_cfa_to_fb_loc_list. */
870 xcfi
->dw_cfi_opc
= DW_CFA_set_loc
;
871 xcfi
->dw_cfi_oprnd1
.dw_cfi_addr
= label
;
872 add_cfi (&fde
->dw_fde_cfi
, xcfi
);
873 fde
->dw_fde_current_label
= label
;
881 output_cfi_directive (cfi
);
883 list_head
= &fde
->dw_fde_cfi
;
885 /* ??? If this is a CFI for the CIE, we don't emit. This
886 assumes that the standard CIE contents that the assembler
887 uses matches the standard CIE contents that the compiler
888 uses. This is probably a bad assumption. I'm not quite
889 sure how to address this for now. */
893 dw_fde_ref fde
= current_fde ();
895 gcc_assert (fde
!= NULL
);
898 label
= dwarf2out_cfi_label (false);
900 if (fde
->dw_fde_current_label
== NULL
901 || strcmp (label
, fde
->dw_fde_current_label
) != 0)
905 label
= xstrdup (label
);
907 /* Set the location counter to the new label. */
909 /* If we have a current label, advance from there, otherwise
910 set the location directly using set_loc. */
911 xcfi
->dw_cfi_opc
= fde
->dw_fde_current_label
912 ? DW_CFA_advance_loc4
914 xcfi
->dw_cfi_oprnd1
.dw_cfi_addr
= label
;
915 add_cfi (&fde
->dw_fde_cfi
, xcfi
);
917 fde
->dw_fde_current_label
= label
;
920 list_head
= &fde
->dw_fde_cfi
;
923 add_cfi (list_head
, cfi
);
926 /* Subroutine of lookup_cfa. */
929 lookup_cfa_1 (dw_cfi_ref cfi
, dw_cfa_location
*loc
, dw_cfa_location
*remember
)
931 switch (cfi
->dw_cfi_opc
)
933 case DW_CFA_def_cfa_offset
:
934 case DW_CFA_def_cfa_offset_sf
:
935 loc
->offset
= cfi
->dw_cfi_oprnd1
.dw_cfi_offset
;
937 case DW_CFA_def_cfa_register
:
938 loc
->reg
= cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
;
941 case DW_CFA_def_cfa_sf
:
942 loc
->reg
= cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
;
943 loc
->offset
= cfi
->dw_cfi_oprnd2
.dw_cfi_offset
;
945 case DW_CFA_def_cfa_expression
:
946 get_cfa_from_loc_descr (loc
, cfi
->dw_cfi_oprnd1
.dw_cfi_loc
);
949 case DW_CFA_remember_state
:
950 gcc_assert (!remember
->in_use
);
952 remember
->in_use
= 1;
954 case DW_CFA_restore_state
:
955 gcc_assert (remember
->in_use
);
957 remember
->in_use
= 0;
965 /* Find the previous value for the CFA. */
968 lookup_cfa (dw_cfa_location
*loc
)
972 dw_cfa_location remember
;
974 memset (loc
, 0, sizeof (*loc
));
975 loc
->reg
= INVALID_REGNUM
;
978 for (cfi
= cie_cfi_head
; cfi
; cfi
= cfi
->dw_cfi_next
)
979 lookup_cfa_1 (cfi
, loc
, &remember
);
981 fde
= current_fde ();
983 for (cfi
= fde
->dw_fde_cfi
; cfi
; cfi
= cfi
->dw_cfi_next
)
984 lookup_cfa_1 (cfi
, loc
, &remember
);
987 /* The current rule for calculating the DWARF2 canonical frame address. */
988 static dw_cfa_location cfa
;
990 /* The register used for saving registers to the stack, and its offset
992 static dw_cfa_location cfa_store
;
994 /* The current save location around an epilogue. */
995 static dw_cfa_location cfa_remember
;
997 /* The running total of the size of arguments pushed onto the stack. */
998 static HOST_WIDE_INT args_size
;
1000 /* The last args_size we actually output. */
1001 static HOST_WIDE_INT old_args_size
;
1003 /* Entry point to update the canonical frame address (CFA).
1004 LABEL is passed to add_fde_cfi. The value of CFA is now to be
1005 calculated from REG+OFFSET. */
1008 dwarf2out_def_cfa (const char *label
, unsigned int reg
, HOST_WIDE_INT offset
)
1010 dw_cfa_location loc
;
1012 loc
.base_offset
= 0;
1014 loc
.offset
= offset
;
1015 def_cfa_1 (label
, &loc
);
1018 /* Determine if two dw_cfa_location structures define the same data. */
1021 cfa_equal_p (const dw_cfa_location
*loc1
, const dw_cfa_location
*loc2
)
1023 return (loc1
->reg
== loc2
->reg
1024 && loc1
->offset
== loc2
->offset
1025 && loc1
->indirect
== loc2
->indirect
1026 && (loc1
->indirect
== 0
1027 || loc1
->base_offset
== loc2
->base_offset
));
1030 /* This routine does the actual work. The CFA is now calculated from
1031 the dw_cfa_location structure. */
1034 def_cfa_1 (const char *label
, dw_cfa_location
*loc_p
)
1037 dw_cfa_location old_cfa
, loc
;
1042 if (cfa_store
.reg
== loc
.reg
&& loc
.indirect
== 0)
1043 cfa_store
.offset
= loc
.offset
;
1045 loc
.reg
= DWARF_FRAME_REGNUM (loc
.reg
);
1046 lookup_cfa (&old_cfa
);
1048 /* If nothing changed, no need to issue any call frame instructions. */
1049 if (cfa_equal_p (&loc
, &old_cfa
))
1054 if (loc
.reg
== old_cfa
.reg
&& !loc
.indirect
&& !old_cfa
.indirect
)
1056 /* Construct a "DW_CFA_def_cfa_offset <offset>" instruction, indicating
1057 the CFA register did not change but the offset did. The data
1058 factoring for DW_CFA_def_cfa_offset_sf happens in output_cfi, or
1059 in the assembler via the .cfi_def_cfa_offset directive. */
1061 cfi
->dw_cfi_opc
= DW_CFA_def_cfa_offset_sf
;
1063 cfi
->dw_cfi_opc
= DW_CFA_def_cfa_offset
;
1064 cfi
->dw_cfi_oprnd1
.dw_cfi_offset
= loc
.offset
;
1067 #ifndef MIPS_DEBUGGING_INFO /* SGI dbx thinks this means no offset. */
1068 else if (loc
.offset
== old_cfa
.offset
1069 && old_cfa
.reg
!= INVALID_REGNUM
1071 && !old_cfa
.indirect
)
1073 /* Construct a "DW_CFA_def_cfa_register <register>" instruction,
1074 indicating the CFA register has changed to <register> but the
1075 offset has not changed. */
1076 cfi
->dw_cfi_opc
= DW_CFA_def_cfa_register
;
1077 cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
= loc
.reg
;
1081 else if (loc
.indirect
== 0)
1083 /* Construct a "DW_CFA_def_cfa <register> <offset>" instruction,
1084 indicating the CFA register has changed to <register> with
1085 the specified offset. The data factoring for DW_CFA_def_cfa_sf
1086 happens in output_cfi, or in the assembler via the .cfi_def_cfa
1089 cfi
->dw_cfi_opc
= DW_CFA_def_cfa_sf
;
1091 cfi
->dw_cfi_opc
= DW_CFA_def_cfa
;
1092 cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
= loc
.reg
;
1093 cfi
->dw_cfi_oprnd2
.dw_cfi_offset
= loc
.offset
;
1097 /* Construct a DW_CFA_def_cfa_expression instruction to
1098 calculate the CFA using a full location expression since no
1099 register-offset pair is available. */
1100 struct dw_loc_descr_struct
*loc_list
;
1102 cfi
->dw_cfi_opc
= DW_CFA_def_cfa_expression
;
1103 loc_list
= build_cfa_loc (&loc
, 0);
1104 cfi
->dw_cfi_oprnd1
.dw_cfi_loc
= loc_list
;
1107 add_fde_cfi (label
, cfi
);
1110 /* Add the CFI for saving a register. REG is the CFA column number.
1111 LABEL is passed to add_fde_cfi.
1112 If SREG is -1, the register is saved at OFFSET from the CFA;
1113 otherwise it is saved in SREG. */
1116 reg_save (const char *label
, unsigned int reg
, unsigned int sreg
, HOST_WIDE_INT offset
)
1118 dw_cfi_ref cfi
= new_cfi ();
1119 dw_fde_ref fde
= current_fde ();
1121 cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
= reg
;
1123 /* When stack is aligned, store REG using DW_CFA_expression with
1126 && fde
->stack_realign
1127 && sreg
== INVALID_REGNUM
)
1129 cfi
->dw_cfi_opc
= DW_CFA_expression
;
1130 cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
= reg
;
1131 cfi
->dw_cfi_oprnd2
.dw_cfi_loc
1132 = build_cfa_aligned_loc (offset
, fde
->stack_realignment
);
1134 else if (sreg
== INVALID_REGNUM
)
1136 if (need_data_align_sf_opcode (offset
))
1137 cfi
->dw_cfi_opc
= DW_CFA_offset_extended_sf
;
1138 else if (reg
& ~0x3f)
1139 cfi
->dw_cfi_opc
= DW_CFA_offset_extended
;
1141 cfi
->dw_cfi_opc
= DW_CFA_offset
;
1142 cfi
->dw_cfi_oprnd2
.dw_cfi_offset
= offset
;
1144 else if (sreg
== reg
)
1145 cfi
->dw_cfi_opc
= DW_CFA_same_value
;
1148 cfi
->dw_cfi_opc
= DW_CFA_register
;
1149 cfi
->dw_cfi_oprnd2
.dw_cfi_reg_num
= sreg
;
1152 add_fde_cfi (label
, cfi
);
1155 /* Add the CFI for saving a register window. LABEL is passed to reg_save.
1156 This CFI tells the unwinder that it needs to restore the window registers
1157 from the previous frame's window save area.
1159 ??? Perhaps we should note in the CIE where windows are saved (instead of
1160 assuming 0(cfa)) and what registers are in the window. */
1163 dwarf2out_window_save (const char *label
)
1165 dw_cfi_ref cfi
= new_cfi ();
1167 cfi
->dw_cfi_opc
= DW_CFA_GNU_window_save
;
1168 add_fde_cfi (label
, cfi
);
1171 /* Entry point for saving a register to the stack. REG is the GCC register
1172 number. LABEL and OFFSET are passed to reg_save. */
1175 dwarf2out_reg_save (const char *label
, unsigned int reg
, HOST_WIDE_INT offset
)
1177 reg_save (label
, DWARF_FRAME_REGNUM (reg
), INVALID_REGNUM
, offset
);
1180 /* Entry point for saving the return address in the stack.
1181 LABEL and OFFSET are passed to reg_save. */
1184 dwarf2out_return_save (const char *label
, HOST_WIDE_INT offset
)
1186 reg_save (label
, DWARF_FRAME_RETURN_COLUMN
, INVALID_REGNUM
, offset
);
1189 /* Entry point for saving the return address in a register.
1190 LABEL and SREG are passed to reg_save. */
1193 dwarf2out_return_reg (const char *label
, unsigned int sreg
)
1195 reg_save (label
, DWARF_FRAME_RETURN_COLUMN
, DWARF_FRAME_REGNUM (sreg
), 0);
1198 #ifdef DWARF2_UNWIND_INFO
1199 /* Record the initial position of the return address. RTL is
1200 INCOMING_RETURN_ADDR_RTX. */
1203 initial_return_save (rtx rtl
)
1205 unsigned int reg
= INVALID_REGNUM
;
1206 HOST_WIDE_INT offset
= 0;
1208 switch (GET_CODE (rtl
))
1211 /* RA is in a register. */
1212 reg
= DWARF_FRAME_REGNUM (REGNO (rtl
));
1216 /* RA is on the stack. */
1217 rtl
= XEXP (rtl
, 0);
1218 switch (GET_CODE (rtl
))
1221 gcc_assert (REGNO (rtl
) == STACK_POINTER_REGNUM
);
1226 gcc_assert (REGNO (XEXP (rtl
, 0)) == STACK_POINTER_REGNUM
);
1227 offset
= INTVAL (XEXP (rtl
, 1));
1231 gcc_assert (REGNO (XEXP (rtl
, 0)) == STACK_POINTER_REGNUM
);
1232 offset
= -INTVAL (XEXP (rtl
, 1));
1242 /* The return address is at some offset from any value we can
1243 actually load. For instance, on the SPARC it is in %i7+8. Just
1244 ignore the offset for now; it doesn't matter for unwinding frames. */
1245 gcc_assert (CONST_INT_P (XEXP (rtl
, 1)));
1246 initial_return_save (XEXP (rtl
, 0));
1253 if (reg
!= DWARF_FRAME_RETURN_COLUMN
)
1254 reg_save (NULL
, DWARF_FRAME_RETURN_COLUMN
, reg
, offset
- cfa
.offset
);
1258 /* Given a SET, calculate the amount of stack adjustment it
1261 static HOST_WIDE_INT
1262 stack_adjust_offset (const_rtx pattern
, HOST_WIDE_INT cur_args_size
,
1263 HOST_WIDE_INT cur_offset
)
1265 const_rtx src
= SET_SRC (pattern
);
1266 const_rtx dest
= SET_DEST (pattern
);
1267 HOST_WIDE_INT offset
= 0;
1270 if (dest
== stack_pointer_rtx
)
1272 code
= GET_CODE (src
);
1274 /* Assume (set (reg sp) (reg whatever)) sets args_size
1276 if (code
== REG
&& src
!= stack_pointer_rtx
)
1278 offset
= -cur_args_size
;
1279 #ifndef STACK_GROWS_DOWNWARD
1282 return offset
- cur_offset
;
1285 if (! (code
== PLUS
|| code
== MINUS
)
1286 || XEXP (src
, 0) != stack_pointer_rtx
1287 || !CONST_INT_P (XEXP (src
, 1)))
1290 /* (set (reg sp) (plus (reg sp) (const_int))) */
1291 offset
= INTVAL (XEXP (src
, 1));
1297 if (MEM_P (src
) && !MEM_P (dest
))
1301 /* (set (mem (pre_dec (reg sp))) (foo)) */
1302 src
= XEXP (dest
, 0);
1303 code
= GET_CODE (src
);
1309 if (XEXP (src
, 0) == stack_pointer_rtx
)
1311 rtx val
= XEXP (XEXP (src
, 1), 1);
1312 /* We handle only adjustments by constant amount. */
1313 gcc_assert (GET_CODE (XEXP (src
, 1)) == PLUS
1314 && CONST_INT_P (val
));
1315 offset
= -INTVAL (val
);
1322 if (XEXP (src
, 0) == stack_pointer_rtx
)
1324 offset
= GET_MODE_SIZE (GET_MODE (dest
));
1331 if (XEXP (src
, 0) == stack_pointer_rtx
)
1333 offset
= -GET_MODE_SIZE (GET_MODE (dest
));
1348 /* Precomputed args_size for CODE_LABELs and BARRIERs preceeding them,
1349 indexed by INSN_UID. */
1351 static HOST_WIDE_INT
*barrier_args_size
;
1353 /* Helper function for compute_barrier_args_size. Handle one insn. */
1355 static HOST_WIDE_INT
1356 compute_barrier_args_size_1 (rtx insn
, HOST_WIDE_INT cur_args_size
,
1357 VEC (rtx
, heap
) **next
)
1359 HOST_WIDE_INT offset
= 0;
1362 if (! RTX_FRAME_RELATED_P (insn
))
1364 if (prologue_epilogue_contains (insn
))
1366 else if (GET_CODE (PATTERN (insn
)) == SET
)
1367 offset
= stack_adjust_offset (PATTERN (insn
), cur_args_size
, 0);
1368 else if (GET_CODE (PATTERN (insn
)) == PARALLEL
1369 || GET_CODE (PATTERN (insn
)) == SEQUENCE
)
1371 /* There may be stack adjustments inside compound insns. Search
1373 for (i
= XVECLEN (PATTERN (insn
), 0) - 1; i
>= 0; i
--)
1374 if (GET_CODE (XVECEXP (PATTERN (insn
), 0, i
)) == SET
)
1375 offset
+= stack_adjust_offset (XVECEXP (PATTERN (insn
), 0, i
),
1376 cur_args_size
, offset
);
1381 rtx expr
= find_reg_note (insn
, REG_FRAME_RELATED_EXPR
, NULL_RTX
);
1385 expr
= XEXP (expr
, 0);
1386 if (GET_CODE (expr
) == PARALLEL
1387 || GET_CODE (expr
) == SEQUENCE
)
1388 for (i
= 1; i
< XVECLEN (expr
, 0); i
++)
1390 rtx elem
= XVECEXP (expr
, 0, i
);
1392 if (GET_CODE (elem
) == SET
&& !RTX_FRAME_RELATED_P (elem
))
1393 offset
+= stack_adjust_offset (elem
, cur_args_size
, offset
);
1398 #ifndef STACK_GROWS_DOWNWARD
1402 cur_args_size
+= offset
;
1403 if (cur_args_size
< 0)
1408 rtx dest
= JUMP_LABEL (insn
);
1412 if (barrier_args_size
[INSN_UID (dest
)] < 0)
1414 barrier_args_size
[INSN_UID (dest
)] = cur_args_size
;
1415 VEC_safe_push (rtx
, heap
, *next
, dest
);
1420 return cur_args_size
;
1423 /* Walk the whole function and compute args_size on BARRIERs. */
1426 compute_barrier_args_size (void)
1428 int max_uid
= get_max_uid (), i
;
1430 VEC (rtx
, heap
) *worklist
, *next
, *tmp
;
1432 barrier_args_size
= XNEWVEC (HOST_WIDE_INT
, max_uid
);
1433 for (i
= 0; i
< max_uid
; i
++)
1434 barrier_args_size
[i
] = -1;
1436 worklist
= VEC_alloc (rtx
, heap
, 20);
1437 next
= VEC_alloc (rtx
, heap
, 20);
1438 insn
= get_insns ();
1439 barrier_args_size
[INSN_UID (insn
)] = 0;
1440 VEC_quick_push (rtx
, worklist
, insn
);
1443 while (!VEC_empty (rtx
, worklist
))
1445 rtx prev
, body
, first_insn
;
1446 HOST_WIDE_INT cur_args_size
;
1448 first_insn
= insn
= VEC_pop (rtx
, worklist
);
1449 cur_args_size
= barrier_args_size
[INSN_UID (insn
)];
1450 prev
= prev_nonnote_insn (insn
);
1451 if (prev
&& BARRIER_P (prev
))
1452 barrier_args_size
[INSN_UID (prev
)] = cur_args_size
;
1454 for (; insn
; insn
= NEXT_INSN (insn
))
1456 if (INSN_DELETED_P (insn
) || NOTE_P (insn
))
1458 if (BARRIER_P (insn
))
1463 if (insn
== first_insn
)
1465 else if (barrier_args_size
[INSN_UID (insn
)] < 0)
1467 barrier_args_size
[INSN_UID (insn
)] = cur_args_size
;
1472 /* The insns starting with this label have been
1473 already scanned or are in the worklist. */
1478 body
= PATTERN (insn
);
1479 if (GET_CODE (body
) == SEQUENCE
)
1481 HOST_WIDE_INT dest_args_size
= cur_args_size
;
1482 for (i
= 1; i
< XVECLEN (body
, 0); i
++)
1483 if (INSN_ANNULLED_BRANCH_P (XVECEXP (body
, 0, 0))
1484 && INSN_FROM_TARGET_P (XVECEXP (body
, 0, i
)))
1486 = compute_barrier_args_size_1 (XVECEXP (body
, 0, i
),
1487 dest_args_size
, &next
);
1490 = compute_barrier_args_size_1 (XVECEXP (body
, 0, i
),
1491 cur_args_size
, &next
);
1493 if (INSN_ANNULLED_BRANCH_P (XVECEXP (body
, 0, 0)))
1494 compute_barrier_args_size_1 (XVECEXP (body
, 0, 0),
1495 dest_args_size
, &next
);
1498 = compute_barrier_args_size_1 (XVECEXP (body
, 0, 0),
1499 cur_args_size
, &next
);
1503 = compute_barrier_args_size_1 (insn
, cur_args_size
, &next
);
1507 if (VEC_empty (rtx
, next
))
1510 /* Swap WORKLIST with NEXT and truncate NEXT for next iteration. */
1514 VEC_truncate (rtx
, next
, 0);
1517 VEC_free (rtx
, heap
, worklist
);
1518 VEC_free (rtx
, heap
, next
);
1521 /* Add a CFI to update the running total of the size of arguments
1522 pushed onto the stack. */
1525 dwarf2out_args_size (const char *label
, HOST_WIDE_INT size
)
1529 if (size
== old_args_size
)
1532 old_args_size
= size
;
1535 cfi
->dw_cfi_opc
= DW_CFA_GNU_args_size
;
1536 cfi
->dw_cfi_oprnd1
.dw_cfi_offset
= size
;
1537 add_fde_cfi (label
, cfi
);
1540 /* Record a stack adjustment of OFFSET bytes. */
1543 dwarf2out_stack_adjust (HOST_WIDE_INT offset
, const char *label
)
1545 if (cfa
.reg
== STACK_POINTER_REGNUM
)
1546 cfa
.offset
+= offset
;
1548 if (cfa_store
.reg
== STACK_POINTER_REGNUM
)
1549 cfa_store
.offset
+= offset
;
1551 if (ACCUMULATE_OUTGOING_ARGS
)
1554 #ifndef STACK_GROWS_DOWNWARD
1558 args_size
+= offset
;
1562 def_cfa_1 (label
, &cfa
);
1563 if (flag_asynchronous_unwind_tables
)
1564 dwarf2out_args_size (label
, args_size
);
1567 /* Check INSN to see if it looks like a push or a stack adjustment, and
1568 make a note of it if it does. EH uses this information to find out
1569 how much extra space it needs to pop off the stack. */
1572 dwarf2out_notice_stack_adjust (rtx insn
, bool after_p
)
1574 HOST_WIDE_INT offset
;
1578 /* Don't handle epilogues at all. Certainly it would be wrong to do so
1579 with this function. Proper support would require all frame-related
1580 insns to be marked, and to be able to handle saving state around
1581 epilogues textually in the middle of the function. */
1582 if (prologue_epilogue_contains (insn
))
1585 /* If INSN is an instruction from target of an annulled branch, the
1586 effects are for the target only and so current argument size
1587 shouldn't change at all. */
1589 && INSN_ANNULLED_BRANCH_P (XVECEXP (final_sequence
, 0, 0))
1590 && INSN_FROM_TARGET_P (insn
))
1593 /* If only calls can throw, and we have a frame pointer,
1594 save up adjustments until we see the CALL_INSN. */
1595 if (!flag_asynchronous_unwind_tables
&& cfa
.reg
!= STACK_POINTER_REGNUM
)
1597 if (CALL_P (insn
) && !after_p
)
1599 /* Extract the size of the args from the CALL rtx itself. */
1600 insn
= PATTERN (insn
);
1601 if (GET_CODE (insn
) == PARALLEL
)
1602 insn
= XVECEXP (insn
, 0, 0);
1603 if (GET_CODE (insn
) == SET
)
1604 insn
= SET_SRC (insn
);
1605 gcc_assert (GET_CODE (insn
) == CALL
);
1606 dwarf2out_args_size ("", INTVAL (XEXP (insn
, 1)));
1611 if (CALL_P (insn
) && !after_p
)
1613 if (!flag_asynchronous_unwind_tables
)
1614 dwarf2out_args_size ("", args_size
);
1617 else if (BARRIER_P (insn
))
1619 /* Don't call compute_barrier_args_size () if the only
1620 BARRIER is at the end of function. */
1621 if (barrier_args_size
== NULL
&& next_nonnote_insn (insn
))
1622 compute_barrier_args_size ();
1623 if (barrier_args_size
== NULL
)
1627 offset
= barrier_args_size
[INSN_UID (insn
)];
1632 offset
-= args_size
;
1633 #ifndef STACK_GROWS_DOWNWARD
1637 else if (GET_CODE (PATTERN (insn
)) == SET
)
1638 offset
= stack_adjust_offset (PATTERN (insn
), args_size
, 0);
1639 else if (GET_CODE (PATTERN (insn
)) == PARALLEL
1640 || GET_CODE (PATTERN (insn
)) == SEQUENCE
)
1642 /* There may be stack adjustments inside compound insns. Search
1644 for (offset
= 0, i
= XVECLEN (PATTERN (insn
), 0) - 1; i
>= 0; i
--)
1645 if (GET_CODE (XVECEXP (PATTERN (insn
), 0, i
)) == SET
)
1646 offset
+= stack_adjust_offset (XVECEXP (PATTERN (insn
), 0, i
),
1655 label
= dwarf2out_cfi_label (false);
1656 dwarf2out_stack_adjust (offset
, label
);
1661 /* We delay emitting a register save until either (a) we reach the end
1662 of the prologue or (b) the register is clobbered. This clusters
1663 register saves so that there are fewer pc advances. */
1665 struct GTY(()) queued_reg_save
{
1666 struct queued_reg_save
*next
;
1668 HOST_WIDE_INT cfa_offset
;
1672 static GTY(()) struct queued_reg_save
*queued_reg_saves
;
1674 /* The caller's ORIG_REG is saved in SAVED_IN_REG. */
1675 struct GTY(()) reg_saved_in_data
{
1680 /* A list of registers saved in other registers.
1681 The list intentionally has a small maximum capacity of 4; if your
1682 port needs more than that, you might consider implementing a
1683 more efficient data structure. */
1684 static GTY(()) struct reg_saved_in_data regs_saved_in_regs
[4];
1685 static GTY(()) size_t num_regs_saved_in_regs
;
1687 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
1688 static const char *last_reg_save_label
;
1690 /* Add an entry to QUEUED_REG_SAVES saying that REG is now saved at
1691 SREG, or if SREG is NULL then it is saved at OFFSET to the CFA. */
1694 queue_reg_save (const char *label
, rtx reg
, rtx sreg
, HOST_WIDE_INT offset
)
1696 struct queued_reg_save
*q
;
1698 /* Duplicates waste space, but it's also necessary to remove them
1699 for correctness, since the queue gets output in reverse
1701 for (q
= queued_reg_saves
; q
!= NULL
; q
= q
->next
)
1702 if (REGNO (q
->reg
) == REGNO (reg
))
1707 q
= ggc_alloc_queued_reg_save ();
1708 q
->next
= queued_reg_saves
;
1709 queued_reg_saves
= q
;
1713 q
->cfa_offset
= offset
;
1714 q
->saved_reg
= sreg
;
1716 last_reg_save_label
= label
;
1719 /* Output all the entries in QUEUED_REG_SAVES. */
1722 flush_queued_reg_saves (void)
1724 struct queued_reg_save
*q
;
1726 for (q
= queued_reg_saves
; q
; q
= q
->next
)
1729 unsigned int reg
, sreg
;
1731 for (i
= 0; i
< num_regs_saved_in_regs
; i
++)
1732 if (REGNO (regs_saved_in_regs
[i
].orig_reg
) == REGNO (q
->reg
))
1734 if (q
->saved_reg
&& i
== num_regs_saved_in_regs
)
1736 gcc_assert (i
!= ARRAY_SIZE (regs_saved_in_regs
));
1737 num_regs_saved_in_regs
++;
1739 if (i
!= num_regs_saved_in_regs
)
1741 regs_saved_in_regs
[i
].orig_reg
= q
->reg
;
1742 regs_saved_in_regs
[i
].saved_in_reg
= q
->saved_reg
;
1745 reg
= DWARF_FRAME_REGNUM (REGNO (q
->reg
));
1747 sreg
= DWARF_FRAME_REGNUM (REGNO (q
->saved_reg
));
1749 sreg
= INVALID_REGNUM
;
1750 reg_save (last_reg_save_label
, reg
, sreg
, q
->cfa_offset
);
1753 queued_reg_saves
= NULL
;
1754 last_reg_save_label
= NULL
;
1757 /* Does INSN clobber any register which QUEUED_REG_SAVES lists a saved
1758 location for? Or, does it clobber a register which we've previously
1759 said that some other register is saved in, and for which we now
1760 have a new location for? */
1763 clobbers_queued_reg_save (const_rtx insn
)
1765 struct queued_reg_save
*q
;
1767 for (q
= queued_reg_saves
; q
; q
= q
->next
)
1770 if (modified_in_p (q
->reg
, insn
))
1772 for (i
= 0; i
< num_regs_saved_in_regs
; i
++)
1773 if (REGNO (q
->reg
) == REGNO (regs_saved_in_regs
[i
].orig_reg
)
1774 && modified_in_p (regs_saved_in_regs
[i
].saved_in_reg
, insn
))
1781 /* Entry point for saving the first register into the second. */
1784 dwarf2out_reg_save_reg (const char *label
, rtx reg
, rtx sreg
)
1787 unsigned int regno
, sregno
;
1789 for (i
= 0; i
< num_regs_saved_in_regs
; i
++)
1790 if (REGNO (regs_saved_in_regs
[i
].orig_reg
) == REGNO (reg
))
1792 if (i
== num_regs_saved_in_regs
)
1794 gcc_assert (i
!= ARRAY_SIZE (regs_saved_in_regs
));
1795 num_regs_saved_in_regs
++;
1797 regs_saved_in_regs
[i
].orig_reg
= reg
;
1798 regs_saved_in_regs
[i
].saved_in_reg
= sreg
;
1800 regno
= DWARF_FRAME_REGNUM (REGNO (reg
));
1801 sregno
= DWARF_FRAME_REGNUM (REGNO (sreg
));
1802 reg_save (label
, regno
, sregno
, 0);
1805 /* What register, if any, is currently saved in REG? */
1808 reg_saved_in (rtx reg
)
1810 unsigned int regn
= REGNO (reg
);
1812 struct queued_reg_save
*q
;
1814 for (q
= queued_reg_saves
; q
; q
= q
->next
)
1815 if (q
->saved_reg
&& regn
== REGNO (q
->saved_reg
))
1818 for (i
= 0; i
< num_regs_saved_in_regs
; i
++)
1819 if (regs_saved_in_regs
[i
].saved_in_reg
1820 && regn
== REGNO (regs_saved_in_regs
[i
].saved_in_reg
))
1821 return regs_saved_in_regs
[i
].orig_reg
;
1827 /* A temporary register holding an integral value used in adjusting SP
1828 or setting up the store_reg. The "offset" field holds the integer
1829 value, not an offset. */
1830 static dw_cfa_location cfa_temp
;
1832 /* A subroutine of dwarf2out_frame_debug, process a REG_DEF_CFA note. */
1835 dwarf2out_frame_debug_def_cfa (rtx pat
, const char *label
)
1837 memset (&cfa
, 0, sizeof (cfa
));
1839 switch (GET_CODE (pat
))
1842 cfa
.reg
= REGNO (XEXP (pat
, 0));
1843 cfa
.offset
= INTVAL (XEXP (pat
, 1));
1847 cfa
.reg
= REGNO (pat
);
1851 /* Recurse and define an expression. */
1855 def_cfa_1 (label
, &cfa
);
1858 /* A subroutine of dwarf2out_frame_debug, process a REG_ADJUST_CFA note. */
1861 dwarf2out_frame_debug_adjust_cfa (rtx pat
, const char *label
)
1865 gcc_assert (GET_CODE (pat
) == SET
);
1866 dest
= XEXP (pat
, 0);
1867 src
= XEXP (pat
, 1);
1869 switch (GET_CODE (src
))
1872 gcc_assert (REGNO (XEXP (src
, 0)) == cfa
.reg
);
1873 cfa
.offset
-= INTVAL (XEXP (src
, 1));
1883 cfa
.reg
= REGNO (dest
);
1884 gcc_assert (cfa
.indirect
== 0);
1886 def_cfa_1 (label
, &cfa
);
1889 /* A subroutine of dwarf2out_frame_debug, process a REG_CFA_OFFSET note. */
1892 dwarf2out_frame_debug_cfa_offset (rtx set
, const char *label
)
1894 HOST_WIDE_INT offset
;
1895 rtx src
, addr
, span
;
1897 src
= XEXP (set
, 1);
1898 addr
= XEXP (set
, 0);
1899 gcc_assert (MEM_P (addr
));
1900 addr
= XEXP (addr
, 0);
1902 /* As documented, only consider extremely simple addresses. */
1903 switch (GET_CODE (addr
))
1906 gcc_assert (REGNO (addr
) == cfa
.reg
);
1907 offset
= -cfa
.offset
;
1910 gcc_assert (REGNO (XEXP (addr
, 0)) == cfa
.reg
);
1911 offset
= INTVAL (XEXP (addr
, 1)) - cfa
.offset
;
1917 span
= targetm
.dwarf_register_span (src
);
1919 /* ??? We'd like to use queue_reg_save, but we need to come up with
1920 a different flushing heuristic for epilogues. */
1922 reg_save (label
, DWARF_FRAME_REGNUM (REGNO (src
)), INVALID_REGNUM
, offset
);
1925 /* We have a PARALLEL describing where the contents of SRC live.
1926 Queue register saves for each piece of the PARALLEL. */
1929 HOST_WIDE_INT span_offset
= offset
;
1931 gcc_assert (GET_CODE (span
) == PARALLEL
);
1933 limit
= XVECLEN (span
, 0);
1934 for (par_index
= 0; par_index
< limit
; par_index
++)
1936 rtx elem
= XVECEXP (span
, 0, par_index
);
1938 reg_save (label
, DWARF_FRAME_REGNUM (REGNO (elem
)),
1939 INVALID_REGNUM
, span_offset
);
1940 span_offset
+= GET_MODE_SIZE (GET_MODE (elem
));
1945 /* A subroutine of dwarf2out_frame_debug, process a REG_CFA_REGISTER note. */
1948 dwarf2out_frame_debug_cfa_register (rtx set
, const char *label
)
1951 unsigned sregno
, dregno
;
1953 src
= XEXP (set
, 1);
1954 dest
= XEXP (set
, 0);
1957 sregno
= DWARF_FRAME_RETURN_COLUMN
;
1959 sregno
= DWARF_FRAME_REGNUM (REGNO (src
));
1961 dregno
= DWARF_FRAME_REGNUM (REGNO (dest
));
1963 /* ??? We'd like to use queue_reg_save, but we need to come up with
1964 a different flushing heuristic for epilogues. */
1965 reg_save (label
, sregno
, dregno
, 0);
1968 /* A subroutine of dwarf2out_frame_debug, process a REG_CFA_RESTORE note. */
1971 dwarf2out_frame_debug_cfa_restore (rtx reg
, const char *label
)
1973 dw_cfi_ref cfi
= new_cfi ();
1974 unsigned int regno
= DWARF_FRAME_REGNUM (REGNO (reg
));
1976 cfi
->dw_cfi_opc
= (regno
& ~0x3f ? DW_CFA_restore_extended
: DW_CFA_restore
);
1977 cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
= regno
;
1979 add_fde_cfi (label
, cfi
);
1982 /* Record call frame debugging information for an expression EXPR,
1983 which either sets SP or FP (adjusting how we calculate the frame
1984 address) or saves a register to the stack or another register.
1985 LABEL indicates the address of EXPR.
1987 This function encodes a state machine mapping rtxes to actions on
1988 cfa, cfa_store, and cfa_temp.reg. We describe these rules so
1989 users need not read the source code.
1991 The High-Level Picture
1993 Changes in the register we use to calculate the CFA: Currently we
1994 assume that if you copy the CFA register into another register, we
1995 should take the other one as the new CFA register; this seems to
1996 work pretty well. If it's wrong for some target, it's simple
1997 enough not to set RTX_FRAME_RELATED_P on the insn in question.
1999 Changes in the register we use for saving registers to the stack:
2000 This is usually SP, but not always. Again, we deduce that if you
2001 copy SP into another register (and SP is not the CFA register),
2002 then the new register is the one we will be using for register
2003 saves. This also seems to work.
2005 Register saves: There's not much guesswork about this one; if
2006 RTX_FRAME_RELATED_P is set on an insn which modifies memory, it's a
2007 register save, and the register used to calculate the destination
2008 had better be the one we think we're using for this purpose.
2009 It's also assumed that a copy from a call-saved register to another
2010 register is saving that register if RTX_FRAME_RELATED_P is set on
2011 that instruction. If the copy is from a call-saved register to
2012 the *same* register, that means that the register is now the same
2013 value as in the caller.
2015 Except: If the register being saved is the CFA register, and the
2016 offset is nonzero, we are saving the CFA, so we assume we have to
2017 use DW_CFA_def_cfa_expression. If the offset is 0, we assume that
2018 the intent is to save the value of SP from the previous frame.
2020 In addition, if a register has previously been saved to a different
2023 Invariants / Summaries of Rules
2025 cfa current rule for calculating the CFA. It usually
2026 consists of a register and an offset.
2027 cfa_store register used by prologue code to save things to the stack
2028 cfa_store.offset is the offset from the value of
2029 cfa_store.reg to the actual CFA
2030 cfa_temp register holding an integral value. cfa_temp.offset
2031 stores the value, which will be used to adjust the
2032 stack pointer. cfa_temp is also used like cfa_store,
2033 to track stores to the stack via fp or a temp reg.
2035 Rules 1- 4: Setting a register's value to cfa.reg or an expression
2036 with cfa.reg as the first operand changes the cfa.reg and its
2037 cfa.offset. Rule 1 and 4 also set cfa_temp.reg and
2040 Rules 6- 9: Set a non-cfa.reg register value to a constant or an
2041 expression yielding a constant. This sets cfa_temp.reg
2042 and cfa_temp.offset.
2044 Rule 5: Create a new register cfa_store used to save items to the
2047 Rules 10-14: Save a register to the stack. Define offset as the
2048 difference of the original location and cfa_store's
2049 location (or cfa_temp's location if cfa_temp is used).
2051 Rules 16-20: If AND operation happens on sp in prologue, we assume
2052 stack is realigned. We will use a group of DW_OP_XXX
2053 expressions to represent the location of the stored
2054 register instead of CFA+offset.
2058 "{a,b}" indicates a choice of a xor b.
2059 "<reg>:cfa.reg" indicates that <reg> must equal cfa.reg.
2062 (set <reg1> <reg2>:cfa.reg)
2063 effects: cfa.reg = <reg1>
2064 cfa.offset unchanged
2065 cfa_temp.reg = <reg1>
2066 cfa_temp.offset = cfa.offset
2069 (set sp ({minus,plus,losum} {sp,fp}:cfa.reg
2070 {<const_int>,<reg>:cfa_temp.reg}))
2071 effects: cfa.reg = sp if fp used
2072 cfa.offset += {+/- <const_int>, cfa_temp.offset} if cfa.reg==sp
2073 cfa_store.offset += {+/- <const_int>, cfa_temp.offset}
2074 if cfa_store.reg==sp
2077 (set fp ({minus,plus,losum} <reg>:cfa.reg <const_int>))
2078 effects: cfa.reg = fp
2079 cfa_offset += +/- <const_int>
2082 (set <reg1> ({plus,losum} <reg2>:cfa.reg <const_int>))
2083 constraints: <reg1> != fp
2085 effects: cfa.reg = <reg1>
2086 cfa_temp.reg = <reg1>
2087 cfa_temp.offset = cfa.offset
2090 (set <reg1> (plus <reg2>:cfa_temp.reg sp:cfa.reg))
2091 constraints: <reg1> != fp
2093 effects: cfa_store.reg = <reg1>
2094 cfa_store.offset = cfa.offset - cfa_temp.offset
2097 (set <reg> <const_int>)
2098 effects: cfa_temp.reg = <reg>
2099 cfa_temp.offset = <const_int>
2102 (set <reg1>:cfa_temp.reg (ior <reg2>:cfa_temp.reg <const_int>))
2103 effects: cfa_temp.reg = <reg1>
2104 cfa_temp.offset |= <const_int>
2107 (set <reg> (high <exp>))
2111 (set <reg> (lo_sum <exp> <const_int>))
2112 effects: cfa_temp.reg = <reg>
2113 cfa_temp.offset = <const_int>
2116 (set (mem (pre_modify sp:cfa_store (???? <reg1> <const_int>))) <reg2>)
2117 effects: cfa_store.offset -= <const_int>
2118 cfa.offset = cfa_store.offset if cfa.reg == sp
2120 cfa.base_offset = -cfa_store.offset
2123 (set (mem ({pre_inc,pre_dec} sp:cfa_store.reg)) <reg>)
2124 effects: cfa_store.offset += -/+ mode_size(mem)
2125 cfa.offset = cfa_store.offset if cfa.reg == sp
2127 cfa.base_offset = -cfa_store.offset
2130 (set (mem ({minus,plus,losum} <reg1>:{cfa_store,cfa_temp} <const_int>))
2133 effects: cfa.reg = <reg1>
2134 cfa.base_offset = -/+ <const_int> - {cfa_store,cfa_temp}.offset
2137 (set (mem <reg1>:{cfa_store,cfa_temp}) <reg2>)
2138 effects: cfa.reg = <reg1>
2139 cfa.base_offset = -{cfa_store,cfa_temp}.offset
2142 (set (mem (postinc <reg1>:cfa_temp <const_int>)) <reg2>)
2143 effects: cfa.reg = <reg1>
2144 cfa.base_offset = -cfa_temp.offset
2145 cfa_temp.offset -= mode_size(mem)
2148 (set <reg> {unspec, unspec_volatile})
2149 effects: target-dependent
2152 (set sp (and: sp <const_int>))
2153 constraints: cfa_store.reg == sp
2154 effects: current_fde.stack_realign = 1
2155 cfa_store.offset = 0
2156 fde->drap_reg = cfa.reg if cfa.reg != sp and cfa.reg != fp
2159 (set (mem ({pre_inc, pre_dec} sp)) (mem (plus (cfa.reg) (const_int))))
2160 effects: cfa_store.offset += -/+ mode_size(mem)
2163 (set (mem ({pre_inc, pre_dec} sp)) fp)
2164 constraints: fde->stack_realign == 1
2165 effects: cfa_store.offset = 0
2166 cfa.reg != HARD_FRAME_POINTER_REGNUM
2169 (set (mem ({pre_inc, pre_dec} sp)) cfa.reg)
2170 constraints: fde->stack_realign == 1
2172 && cfa.indirect == 0
2173 && cfa.reg != HARD_FRAME_POINTER_REGNUM
2174 effects: Use DW_CFA_def_cfa_expression to define cfa
2175 cfa.reg == fde->drap_reg */
2178 dwarf2out_frame_debug_expr (rtx expr
, const char *label
)
2180 rtx src
, dest
, span
;
2181 HOST_WIDE_INT offset
;
2184 /* If RTX_FRAME_RELATED_P is set on a PARALLEL, process each member of
2185 the PARALLEL independently. The first element is always processed if
2186 it is a SET. This is for backward compatibility. Other elements
2187 are processed only if they are SETs and the RTX_FRAME_RELATED_P
2188 flag is set in them. */
2189 if (GET_CODE (expr
) == PARALLEL
|| GET_CODE (expr
) == SEQUENCE
)
2192 int limit
= XVECLEN (expr
, 0);
2195 /* PARALLELs have strict read-modify-write semantics, so we
2196 ought to evaluate every rvalue before changing any lvalue.
2197 It's cumbersome to do that in general, but there's an
2198 easy approximation that is enough for all current users:
2199 handle register saves before register assignments. */
2200 if (GET_CODE (expr
) == PARALLEL
)
2201 for (par_index
= 0; par_index
< limit
; par_index
++)
2203 elem
= XVECEXP (expr
, 0, par_index
);
2204 if (GET_CODE (elem
) == SET
2205 && MEM_P (SET_DEST (elem
))
2206 && (RTX_FRAME_RELATED_P (elem
) || par_index
== 0))
2207 dwarf2out_frame_debug_expr (elem
, label
);
2210 for (par_index
= 0; par_index
< limit
; par_index
++)
2212 elem
= XVECEXP (expr
, 0, par_index
);
2213 if (GET_CODE (elem
) == SET
2214 && (!MEM_P (SET_DEST (elem
)) || GET_CODE (expr
) == SEQUENCE
)
2215 && (RTX_FRAME_RELATED_P (elem
) || par_index
== 0))
2216 dwarf2out_frame_debug_expr (elem
, label
);
2217 else if (GET_CODE (elem
) == SET
2219 && !RTX_FRAME_RELATED_P (elem
))
2221 /* Stack adjustment combining might combine some post-prologue
2222 stack adjustment into a prologue stack adjustment. */
2223 HOST_WIDE_INT offset
= stack_adjust_offset (elem
, args_size
, 0);
2226 dwarf2out_stack_adjust (offset
, label
);
2232 gcc_assert (GET_CODE (expr
) == SET
);
2234 src
= SET_SRC (expr
);
2235 dest
= SET_DEST (expr
);
2239 rtx rsi
= reg_saved_in (src
);
2244 fde
= current_fde ();
2246 switch (GET_CODE (dest
))
2249 switch (GET_CODE (src
))
2251 /* Setting FP from SP. */
2253 if (cfa
.reg
== (unsigned) REGNO (src
))
2256 /* Update the CFA rule wrt SP or FP. Make sure src is
2257 relative to the current CFA register.
2259 We used to require that dest be either SP or FP, but the
2260 ARM copies SP to a temporary register, and from there to
2261 FP. So we just rely on the backends to only set
2262 RTX_FRAME_RELATED_P on appropriate insns. */
2263 cfa
.reg
= REGNO (dest
);
2264 cfa_temp
.reg
= cfa
.reg
;
2265 cfa_temp
.offset
= cfa
.offset
;
2269 /* Saving a register in a register. */
2270 gcc_assert (!fixed_regs
[REGNO (dest
)]
2271 /* For the SPARC and its register window. */
2272 || (DWARF_FRAME_REGNUM (REGNO (src
))
2273 == DWARF_FRAME_RETURN_COLUMN
));
2275 /* After stack is aligned, we can only save SP in FP
2276 if drap register is used. In this case, we have
2277 to restore stack pointer with the CFA value and we
2278 don't generate this DWARF information. */
2280 && fde
->stack_realign
2281 && REGNO (src
) == STACK_POINTER_REGNUM
)
2282 gcc_assert (REGNO (dest
) == HARD_FRAME_POINTER_REGNUM
2283 && fde
->drap_reg
!= INVALID_REGNUM
2284 && cfa
.reg
!= REGNO (src
));
2286 queue_reg_save (label
, src
, dest
, 0);
2293 if (dest
== stack_pointer_rtx
)
2297 switch (GET_CODE (XEXP (src
, 1)))
2300 offset
= INTVAL (XEXP (src
, 1));
2303 gcc_assert ((unsigned) REGNO (XEXP (src
, 1))
2305 offset
= cfa_temp
.offset
;
2311 if (XEXP (src
, 0) == hard_frame_pointer_rtx
)
2313 /* Restoring SP from FP in the epilogue. */
2314 gcc_assert (cfa
.reg
== (unsigned) HARD_FRAME_POINTER_REGNUM
);
2315 cfa
.reg
= STACK_POINTER_REGNUM
;
2317 else if (GET_CODE (src
) == LO_SUM
)
2318 /* Assume we've set the source reg of the LO_SUM from sp. */
2321 gcc_assert (XEXP (src
, 0) == stack_pointer_rtx
);
2323 if (GET_CODE (src
) != MINUS
)
2325 if (cfa
.reg
== STACK_POINTER_REGNUM
)
2326 cfa
.offset
+= offset
;
2327 if (cfa_store
.reg
== STACK_POINTER_REGNUM
)
2328 cfa_store
.offset
+= offset
;
2330 else if (dest
== hard_frame_pointer_rtx
)
2333 /* Either setting the FP from an offset of the SP,
2334 or adjusting the FP */
2335 gcc_assert (frame_pointer_needed
);
2337 gcc_assert (REG_P (XEXP (src
, 0))
2338 && (unsigned) REGNO (XEXP (src
, 0)) == cfa
.reg
2339 && CONST_INT_P (XEXP (src
, 1)));
2340 offset
= INTVAL (XEXP (src
, 1));
2341 if (GET_CODE (src
) != MINUS
)
2343 cfa
.offset
+= offset
;
2344 cfa
.reg
= HARD_FRAME_POINTER_REGNUM
;
2348 gcc_assert (GET_CODE (src
) != MINUS
);
2351 if (REG_P (XEXP (src
, 0))
2352 && REGNO (XEXP (src
, 0)) == cfa
.reg
2353 && CONST_INT_P (XEXP (src
, 1)))
2355 /* Setting a temporary CFA register that will be copied
2356 into the FP later on. */
2357 offset
= - INTVAL (XEXP (src
, 1));
2358 cfa
.offset
+= offset
;
2359 cfa
.reg
= REGNO (dest
);
2360 /* Or used to save regs to the stack. */
2361 cfa_temp
.reg
= cfa
.reg
;
2362 cfa_temp
.offset
= cfa
.offset
;
2366 else if (REG_P (XEXP (src
, 0))
2367 && REGNO (XEXP (src
, 0)) == cfa_temp
.reg
2368 && XEXP (src
, 1) == stack_pointer_rtx
)
2370 /* Setting a scratch register that we will use instead
2371 of SP for saving registers to the stack. */
2372 gcc_assert (cfa
.reg
== STACK_POINTER_REGNUM
);
2373 cfa_store
.reg
= REGNO (dest
);
2374 cfa_store
.offset
= cfa
.offset
- cfa_temp
.offset
;
2378 else if (GET_CODE (src
) == LO_SUM
2379 && CONST_INT_P (XEXP (src
, 1)))
2381 cfa_temp
.reg
= REGNO (dest
);
2382 cfa_temp
.offset
= INTVAL (XEXP (src
, 1));
2391 cfa_temp
.reg
= REGNO (dest
);
2392 cfa_temp
.offset
= INTVAL (src
);
2397 gcc_assert (REG_P (XEXP (src
, 0))
2398 && (unsigned) REGNO (XEXP (src
, 0)) == cfa_temp
.reg
2399 && CONST_INT_P (XEXP (src
, 1)));
2401 if ((unsigned) REGNO (dest
) != cfa_temp
.reg
)
2402 cfa_temp
.reg
= REGNO (dest
);
2403 cfa_temp
.offset
|= INTVAL (XEXP (src
, 1));
2406 /* Skip over HIGH, assuming it will be followed by a LO_SUM,
2407 which will fill in all of the bits. */
2414 case UNSPEC_VOLATILE
:
2415 gcc_assert (targetm
.dwarf_handle_frame_unspec
);
2416 targetm
.dwarf_handle_frame_unspec (label
, expr
, XINT (src
, 1));
2421 /* If this AND operation happens on stack pointer in prologue,
2422 we assume the stack is realigned and we extract the
2424 if (fde
&& XEXP (src
, 0) == stack_pointer_rtx
)
2426 gcc_assert (cfa_store
.reg
== REGNO (XEXP (src
, 0)));
2427 fde
->stack_realign
= 1;
2428 fde
->stack_realignment
= INTVAL (XEXP (src
, 1));
2429 cfa_store
.offset
= 0;
2431 if (cfa
.reg
!= STACK_POINTER_REGNUM
2432 && cfa
.reg
!= HARD_FRAME_POINTER_REGNUM
)
2433 fde
->drap_reg
= cfa
.reg
;
2441 def_cfa_1 (label
, &cfa
);
2446 /* Saving a register to the stack. Make sure dest is relative to the
2448 switch (GET_CODE (XEXP (dest
, 0)))
2453 /* We can't handle variable size modifications. */
2454 gcc_assert (GET_CODE (XEXP (XEXP (XEXP (dest
, 0), 1), 1))
2456 offset
= -INTVAL (XEXP (XEXP (XEXP (dest
, 0), 1), 1));
2458 gcc_assert (REGNO (XEXP (XEXP (dest
, 0), 0)) == STACK_POINTER_REGNUM
2459 && cfa_store
.reg
== STACK_POINTER_REGNUM
);
2461 cfa_store
.offset
+= offset
;
2462 if (cfa
.reg
== STACK_POINTER_REGNUM
)
2463 cfa
.offset
= cfa_store
.offset
;
2465 offset
= -cfa_store
.offset
;
2471 offset
= GET_MODE_SIZE (GET_MODE (dest
));
2472 if (GET_CODE (XEXP (dest
, 0)) == PRE_INC
)
2475 gcc_assert ((REGNO (XEXP (XEXP (dest
, 0), 0))
2476 == STACK_POINTER_REGNUM
)
2477 && cfa_store
.reg
== STACK_POINTER_REGNUM
);
2479 cfa_store
.offset
+= offset
;
2481 /* Rule 18: If stack is aligned, we will use FP as a
2482 reference to represent the address of the stored
2485 && fde
->stack_realign
2486 && src
== hard_frame_pointer_rtx
)
2488 gcc_assert (cfa
.reg
!= HARD_FRAME_POINTER_REGNUM
);
2489 cfa_store
.offset
= 0;
2492 if (cfa
.reg
== STACK_POINTER_REGNUM
)
2493 cfa
.offset
= cfa_store
.offset
;
2495 offset
= -cfa_store
.offset
;
2499 /* With an offset. */
2506 gcc_assert (CONST_INT_P (XEXP (XEXP (dest
, 0), 1))
2507 && REG_P (XEXP (XEXP (dest
, 0), 0)));
2508 offset
= INTVAL (XEXP (XEXP (dest
, 0), 1));
2509 if (GET_CODE (XEXP (dest
, 0)) == MINUS
)
2512 regno
= REGNO (XEXP (XEXP (dest
, 0), 0));
2514 if (cfa_store
.reg
== (unsigned) regno
)
2515 offset
-= cfa_store
.offset
;
2518 gcc_assert (cfa_temp
.reg
== (unsigned) regno
);
2519 offset
-= cfa_temp
.offset
;
2525 /* Without an offset. */
2528 int regno
= REGNO (XEXP (dest
, 0));
2530 if (cfa_store
.reg
== (unsigned) regno
)
2531 offset
= -cfa_store
.offset
;
2534 gcc_assert (cfa_temp
.reg
== (unsigned) regno
);
2535 offset
= -cfa_temp
.offset
;
2542 gcc_assert (cfa_temp
.reg
2543 == (unsigned) REGNO (XEXP (XEXP (dest
, 0), 0)));
2544 offset
= -cfa_temp
.offset
;
2545 cfa_temp
.offset
-= GET_MODE_SIZE (GET_MODE (dest
));
2553 /* If the source operand of this MEM operation is not a
2554 register, basically the source is return address. Here
2555 we only care how much stack grew and we don't save it. */
2559 if (REGNO (src
) != STACK_POINTER_REGNUM
2560 && REGNO (src
) != HARD_FRAME_POINTER_REGNUM
2561 && (unsigned) REGNO (src
) == cfa
.reg
)
2563 /* We're storing the current CFA reg into the stack. */
2565 if (cfa
.offset
== 0)
2568 /* If stack is aligned, putting CFA reg into stack means
2569 we can no longer use reg + offset to represent CFA.
2570 Here we use DW_CFA_def_cfa_expression instead. The
2571 result of this expression equals to the original CFA
2574 && fde
->stack_realign
2575 && cfa
.indirect
== 0
2576 && cfa
.reg
!= HARD_FRAME_POINTER_REGNUM
)
2578 dw_cfa_location cfa_exp
;
2580 gcc_assert (fde
->drap_reg
== cfa
.reg
);
2582 cfa_exp
.indirect
= 1;
2583 cfa_exp
.reg
= HARD_FRAME_POINTER_REGNUM
;
2584 cfa_exp
.base_offset
= offset
;
2587 fde
->drap_reg_saved
= 1;
2589 def_cfa_1 (label
, &cfa_exp
);
2593 /* If the source register is exactly the CFA, assume
2594 we're saving SP like any other register; this happens
2596 def_cfa_1 (label
, &cfa
);
2597 queue_reg_save (label
, stack_pointer_rtx
, NULL_RTX
, offset
);
2602 /* Otherwise, we'll need to look in the stack to
2603 calculate the CFA. */
2604 rtx x
= XEXP (dest
, 0);
2608 gcc_assert (REG_P (x
));
2610 cfa
.reg
= REGNO (x
);
2611 cfa
.base_offset
= offset
;
2613 def_cfa_1 (label
, &cfa
);
2618 def_cfa_1 (label
, &cfa
);
2620 span
= targetm
.dwarf_register_span (src
);
2623 queue_reg_save (label
, src
, NULL_RTX
, offset
);
2626 /* We have a PARALLEL describing where the contents of SRC
2627 live. Queue register saves for each piece of the
2631 HOST_WIDE_INT span_offset
= offset
;
2633 gcc_assert (GET_CODE (span
) == PARALLEL
);
2635 limit
= XVECLEN (span
, 0);
2636 for (par_index
= 0; par_index
< limit
; par_index
++)
2638 rtx elem
= XVECEXP (span
, 0, par_index
);
2640 queue_reg_save (label
, elem
, NULL_RTX
, span_offset
);
2641 span_offset
+= GET_MODE_SIZE (GET_MODE (elem
));
2652 /* Record call frame debugging information for INSN, which either
2653 sets SP or FP (adjusting how we calculate the frame address) or saves a
2654 register to the stack. If INSN is NULL_RTX, initialize our state.
2656 If AFTER_P is false, we're being called before the insn is emitted,
2657 otherwise after. Call instructions get invoked twice. */
2660 dwarf2out_frame_debug (rtx insn
, bool after_p
)
2664 bool handled_one
= false;
2666 if (insn
== NULL_RTX
)
2670 /* Flush any queued register saves. */
2671 flush_queued_reg_saves ();
2673 /* Set up state for generating call frame debug info. */
2676 == (unsigned long)DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM
));
2678 cfa
.reg
= STACK_POINTER_REGNUM
;
2681 cfa_temp
.offset
= 0;
2683 for (i
= 0; i
< num_regs_saved_in_regs
; i
++)
2685 regs_saved_in_regs
[i
].orig_reg
= NULL_RTX
;
2686 regs_saved_in_regs
[i
].saved_in_reg
= NULL_RTX
;
2688 num_regs_saved_in_regs
= 0;
2690 if (barrier_args_size
)
2692 XDELETEVEC (barrier_args_size
);
2693 barrier_args_size
= NULL
;
2698 if (!NONJUMP_INSN_P (insn
) || clobbers_queued_reg_save (insn
))
2699 flush_queued_reg_saves ();
2701 if (!RTX_FRAME_RELATED_P (insn
))
2703 /* ??? This should be done unconditionally since stack adjustments
2704 matter if the stack pointer is not the CFA register anymore but
2705 is still used to save registers. */
2706 if (!ACCUMULATE_OUTGOING_ARGS
)
2707 dwarf2out_notice_stack_adjust (insn
, after_p
);
2711 label
= dwarf2out_cfi_label (false);
2713 for (note
= REG_NOTES (insn
); note
; note
= XEXP (note
, 1))
2714 switch (REG_NOTE_KIND (note
))
2716 case REG_FRAME_RELATED_EXPR
:
2717 insn
= XEXP (note
, 0);
2720 case REG_CFA_DEF_CFA
:
2721 dwarf2out_frame_debug_def_cfa (XEXP (note
, 0), label
);
2725 case REG_CFA_ADJUST_CFA
:
2730 if (GET_CODE (n
) == PARALLEL
)
2731 n
= XVECEXP (n
, 0, 0);
2733 dwarf2out_frame_debug_adjust_cfa (n
, label
);
2737 case REG_CFA_OFFSET
:
2740 n
= single_set (insn
);
2741 dwarf2out_frame_debug_cfa_offset (n
, label
);
2745 case REG_CFA_REGISTER
:
2750 if (GET_CODE (n
) == PARALLEL
)
2751 n
= XVECEXP (n
, 0, 0);
2753 dwarf2out_frame_debug_cfa_register (n
, label
);
2757 case REG_CFA_RESTORE
:
2762 if (GET_CODE (n
) == PARALLEL
)
2763 n
= XVECEXP (n
, 0, 0);
2766 dwarf2out_frame_debug_cfa_restore (n
, label
);
2770 case REG_CFA_SET_VDRAP
:
2774 dw_fde_ref fde
= current_fde ();
2777 gcc_assert (fde
->vdrap_reg
== INVALID_REGNUM
);
2779 fde
->vdrap_reg
= REGNO (n
);
2791 insn
= PATTERN (insn
);
2793 dwarf2out_frame_debug_expr (insn
, label
);
2796 /* Determine if we need to save and restore CFI information around this
2797 epilogue. If SIBCALL is true, then this is a sibcall epilogue. If
2798 we do need to save/restore, then emit the save now, and insert a
2799 NOTE_INSN_CFA_RESTORE_STATE at the appropriate place in the stream. */
2802 dwarf2out_cfi_begin_epilogue (rtx insn
)
2804 bool saw_frp
= false;
2807 /* Scan forward to the return insn, noticing if there are possible
2808 frame related insns. */
2809 for (i
= NEXT_INSN (insn
); i
; i
= NEXT_INSN (i
))
2814 /* Look for both regular and sibcalls to end the block. */
2815 if (returnjump_p (i
))
2817 if (CALL_P (i
) && SIBLING_CALL_P (i
))
2820 if (GET_CODE (PATTERN (i
)) == SEQUENCE
)
2823 rtx seq
= PATTERN (i
);
2825 if (returnjump_p (XVECEXP (seq
, 0, 0)))
2827 if (CALL_P (XVECEXP (seq
, 0, 0))
2828 && SIBLING_CALL_P (XVECEXP (seq
, 0, 0)))
2831 for (idx
= 0; idx
< XVECLEN (seq
, 0); idx
++)
2832 if (RTX_FRAME_RELATED_P (XVECEXP (seq
, 0, idx
)))
2836 if (RTX_FRAME_RELATED_P (i
))
2840 /* If the port doesn't emit epilogue unwind info, we don't need a
2841 save/restore pair. */
2845 /* Otherwise, search forward to see if the return insn was the last
2846 basic block of the function. If so, we don't need save/restore. */
2847 gcc_assert (i
!= NULL
);
2848 i
= next_real_insn (i
);
2852 /* Insert the restore before that next real insn in the stream, and before
2853 a potential NOTE_INSN_EPILOGUE_BEG -- we do need these notes to be
2854 properly nested. This should be after any label or alignment. This
2855 will be pushed into the CFI stream by the function below. */
2858 rtx p
= PREV_INSN (i
);
2861 if (NOTE_KIND (p
) == NOTE_INSN_BASIC_BLOCK
)
2865 emit_note_before (NOTE_INSN_CFA_RESTORE_STATE
, i
);
2867 emit_cfa_remember
= true;
2869 /* And emulate the state save. */
2870 gcc_assert (!cfa_remember
.in_use
);
2872 cfa_remember
.in_use
= 1;
2875 /* A "subroutine" of dwarf2out_cfi_begin_epilogue. Emit the restore
2879 dwarf2out_frame_debug_restore_state (void)
2881 dw_cfi_ref cfi
= new_cfi ();
2882 const char *label
= dwarf2out_cfi_label (false);
2884 cfi
->dw_cfi_opc
= DW_CFA_restore_state
;
2885 add_fde_cfi (label
, cfi
);
2887 gcc_assert (cfa_remember
.in_use
);
2889 cfa_remember
.in_use
= 0;
2894 /* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used. */
2895 static enum dw_cfi_oprnd_type dw_cfi_oprnd1_desc
2896 (enum dwarf_call_frame_info cfi
);
2898 static enum dw_cfi_oprnd_type
2899 dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi
)
2904 case DW_CFA_GNU_window_save
:
2905 case DW_CFA_remember_state
:
2906 case DW_CFA_restore_state
:
2907 return dw_cfi_oprnd_unused
;
2909 case DW_CFA_set_loc
:
2910 case DW_CFA_advance_loc1
:
2911 case DW_CFA_advance_loc2
:
2912 case DW_CFA_advance_loc4
:
2913 case DW_CFA_MIPS_advance_loc8
:
2914 return dw_cfi_oprnd_addr
;
2917 case DW_CFA_offset_extended
:
2918 case DW_CFA_def_cfa
:
2919 case DW_CFA_offset_extended_sf
:
2920 case DW_CFA_def_cfa_sf
:
2921 case DW_CFA_restore
:
2922 case DW_CFA_restore_extended
:
2923 case DW_CFA_undefined
:
2924 case DW_CFA_same_value
:
2925 case DW_CFA_def_cfa_register
:
2926 case DW_CFA_register
:
2927 case DW_CFA_expression
:
2928 return dw_cfi_oprnd_reg_num
;
2930 case DW_CFA_def_cfa_offset
:
2931 case DW_CFA_GNU_args_size
:
2932 case DW_CFA_def_cfa_offset_sf
:
2933 return dw_cfi_oprnd_offset
;
2935 case DW_CFA_def_cfa_expression
:
2936 return dw_cfi_oprnd_loc
;
2943 /* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used. */
2944 static enum dw_cfi_oprnd_type dw_cfi_oprnd2_desc
2945 (enum dwarf_call_frame_info cfi
);
2947 static enum dw_cfi_oprnd_type
2948 dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi
)
2952 case DW_CFA_def_cfa
:
2953 case DW_CFA_def_cfa_sf
:
2955 case DW_CFA_offset_extended_sf
:
2956 case DW_CFA_offset_extended
:
2957 return dw_cfi_oprnd_offset
;
2959 case DW_CFA_register
:
2960 return dw_cfi_oprnd_reg_num
;
2962 case DW_CFA_expression
:
2963 return dw_cfi_oprnd_loc
;
2966 return dw_cfi_oprnd_unused
;
2970 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
2972 /* Switch [BACK] to eh_frame_section. If we don't have an eh_frame_section,
2973 switch to the data section instead, and write out a synthetic start label
2974 for collect2 the first time around. */
2977 switch_to_eh_frame_section (bool back
)
2981 #ifdef EH_FRAME_SECTION_NAME
2982 if (eh_frame_section
== 0)
2986 if (EH_TABLES_CAN_BE_READ_ONLY
)
2992 fde_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1,
2994 per_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2,
2996 lsda_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0,
2998 flags
= ((! flag_pic
2999 || ((fde_encoding
& 0x70) != DW_EH_PE_absptr
3000 && (fde_encoding
& 0x70) != DW_EH_PE_aligned
3001 && (per_encoding
& 0x70) != DW_EH_PE_absptr
3002 && (per_encoding
& 0x70) != DW_EH_PE_aligned
3003 && (lsda_encoding
& 0x70) != DW_EH_PE_absptr
3004 && (lsda_encoding
& 0x70) != DW_EH_PE_aligned
))
3005 ? 0 : SECTION_WRITE
);
3008 flags
= SECTION_WRITE
;
3009 eh_frame_section
= get_section (EH_FRAME_SECTION_NAME
, flags
, NULL
);
3013 if (eh_frame_section
)
3014 switch_to_section (eh_frame_section
);
3017 /* We have no special eh_frame section. Put the information in
3018 the data section and emit special labels to guide collect2. */
3019 switch_to_section (data_section
);
3023 label
= get_file_function_name ("F");
3024 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (PTR_SIZE
));
3025 targetm
.asm_out
.globalize_label (asm_out_file
,
3026 IDENTIFIER_POINTER (label
));
3027 ASM_OUTPUT_LABEL (asm_out_file
, IDENTIFIER_POINTER (label
));
3032 /* Switch [BACK] to the eh or debug frame table section, depending on
3036 switch_to_frame_table_section (int for_eh
, bool back
)
3039 switch_to_eh_frame_section (back
);
3042 if (!debug_frame_section
)
3043 debug_frame_section
= get_section (DEBUG_FRAME_SECTION
,
3044 SECTION_DEBUG
, NULL
);
3045 switch_to_section (debug_frame_section
);
3049 /* Output a Call Frame Information opcode and its operand(s). */
3052 output_cfi (dw_cfi_ref cfi
, dw_fde_ref fde
, int for_eh
)
3057 if (cfi
->dw_cfi_opc
== DW_CFA_advance_loc
)
3058 dw2_asm_output_data (1, (cfi
->dw_cfi_opc
3059 | (cfi
->dw_cfi_oprnd1
.dw_cfi_offset
& 0x3f)),
3060 "DW_CFA_advance_loc " HOST_WIDE_INT_PRINT_HEX
,
3061 ((unsigned HOST_WIDE_INT
)
3062 cfi
->dw_cfi_oprnd1
.dw_cfi_offset
));
3063 else if (cfi
->dw_cfi_opc
== DW_CFA_offset
)
3065 r
= DWARF2_FRAME_REG_OUT (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
, for_eh
);
3066 dw2_asm_output_data (1, (cfi
->dw_cfi_opc
| (r
& 0x3f)),
3067 "DW_CFA_offset, column %#lx", r
);
3068 off
= div_data_align (cfi
->dw_cfi_oprnd2
.dw_cfi_offset
);
3069 dw2_asm_output_data_uleb128 (off
, NULL
);
3071 else if (cfi
->dw_cfi_opc
== DW_CFA_restore
)
3073 r
= DWARF2_FRAME_REG_OUT (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
, for_eh
);
3074 dw2_asm_output_data (1, (cfi
->dw_cfi_opc
| (r
& 0x3f)),
3075 "DW_CFA_restore, column %#lx", r
);
3079 dw2_asm_output_data (1, cfi
->dw_cfi_opc
,
3080 "%s", dwarf_cfi_name (cfi
->dw_cfi_opc
));
3082 switch (cfi
->dw_cfi_opc
)
3084 case DW_CFA_set_loc
:
3086 dw2_asm_output_encoded_addr_rtx (
3087 ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0),
3088 gen_rtx_SYMBOL_REF (Pmode
, cfi
->dw_cfi_oprnd1
.dw_cfi_addr
),
3091 dw2_asm_output_addr (DWARF2_ADDR_SIZE
,
3092 cfi
->dw_cfi_oprnd1
.dw_cfi_addr
, NULL
);
3093 fde
->dw_fde_current_label
= cfi
->dw_cfi_oprnd1
.dw_cfi_addr
;
3096 case DW_CFA_advance_loc1
:
3097 dw2_asm_output_delta (1, cfi
->dw_cfi_oprnd1
.dw_cfi_addr
,
3098 fde
->dw_fde_current_label
, NULL
);
3099 fde
->dw_fde_current_label
= cfi
->dw_cfi_oprnd1
.dw_cfi_addr
;
3102 case DW_CFA_advance_loc2
:
3103 dw2_asm_output_delta (2, cfi
->dw_cfi_oprnd1
.dw_cfi_addr
,
3104 fde
->dw_fde_current_label
, NULL
);
3105 fde
->dw_fde_current_label
= cfi
->dw_cfi_oprnd1
.dw_cfi_addr
;
3108 case DW_CFA_advance_loc4
:
3109 dw2_asm_output_delta (4, cfi
->dw_cfi_oprnd1
.dw_cfi_addr
,
3110 fde
->dw_fde_current_label
, NULL
);
3111 fde
->dw_fde_current_label
= cfi
->dw_cfi_oprnd1
.dw_cfi_addr
;
3114 case DW_CFA_MIPS_advance_loc8
:
3115 dw2_asm_output_delta (8, cfi
->dw_cfi_oprnd1
.dw_cfi_addr
,
3116 fde
->dw_fde_current_label
, NULL
);
3117 fde
->dw_fde_current_label
= cfi
->dw_cfi_oprnd1
.dw_cfi_addr
;
3120 case DW_CFA_offset_extended
:
3121 r
= DWARF2_FRAME_REG_OUT (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
, for_eh
);
3122 dw2_asm_output_data_uleb128 (r
, NULL
);
3123 off
= div_data_align (cfi
->dw_cfi_oprnd2
.dw_cfi_offset
);
3124 dw2_asm_output_data_uleb128 (off
, NULL
);
3127 case DW_CFA_def_cfa
:
3128 r
= DWARF2_FRAME_REG_OUT (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
, for_eh
);
3129 dw2_asm_output_data_uleb128 (r
, NULL
);
3130 dw2_asm_output_data_uleb128 (cfi
->dw_cfi_oprnd2
.dw_cfi_offset
, NULL
);
3133 case DW_CFA_offset_extended_sf
:
3134 r
= DWARF2_FRAME_REG_OUT (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
, for_eh
);
3135 dw2_asm_output_data_uleb128 (r
, NULL
);
3136 off
= div_data_align (cfi
->dw_cfi_oprnd2
.dw_cfi_offset
);
3137 dw2_asm_output_data_sleb128 (off
, NULL
);
3140 case DW_CFA_def_cfa_sf
:
3141 r
= DWARF2_FRAME_REG_OUT (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
, for_eh
);
3142 dw2_asm_output_data_uleb128 (r
, NULL
);
3143 off
= div_data_align (cfi
->dw_cfi_oprnd2
.dw_cfi_offset
);
3144 dw2_asm_output_data_sleb128 (off
, NULL
);
3147 case DW_CFA_restore_extended
:
3148 case DW_CFA_undefined
:
3149 case DW_CFA_same_value
:
3150 case DW_CFA_def_cfa_register
:
3151 r
= DWARF2_FRAME_REG_OUT (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
, for_eh
);
3152 dw2_asm_output_data_uleb128 (r
, NULL
);
3155 case DW_CFA_register
:
3156 r
= DWARF2_FRAME_REG_OUT (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
, for_eh
);
3157 dw2_asm_output_data_uleb128 (r
, NULL
);
3158 r
= DWARF2_FRAME_REG_OUT (cfi
->dw_cfi_oprnd2
.dw_cfi_reg_num
, for_eh
);
3159 dw2_asm_output_data_uleb128 (r
, NULL
);
3162 case DW_CFA_def_cfa_offset
:
3163 case DW_CFA_GNU_args_size
:
3164 dw2_asm_output_data_uleb128 (cfi
->dw_cfi_oprnd1
.dw_cfi_offset
, NULL
);
3167 case DW_CFA_def_cfa_offset_sf
:
3168 off
= div_data_align (cfi
->dw_cfi_oprnd1
.dw_cfi_offset
);
3169 dw2_asm_output_data_sleb128 (off
, NULL
);
3172 case DW_CFA_GNU_window_save
:
3175 case DW_CFA_def_cfa_expression
:
3176 case DW_CFA_expression
:
3177 output_cfa_loc (cfi
);
3180 case DW_CFA_GNU_negative_offset_extended
:
3181 /* Obsoleted by DW_CFA_offset_extended_sf. */
3190 /* Similar, but do it via assembler directives instead. */
3193 output_cfi_directive (dw_cfi_ref cfi
)
3195 unsigned long r
, r2
;
3197 switch (cfi
->dw_cfi_opc
)
3199 case DW_CFA_advance_loc
:
3200 case DW_CFA_advance_loc1
:
3201 case DW_CFA_advance_loc2
:
3202 case DW_CFA_advance_loc4
:
3203 case DW_CFA_MIPS_advance_loc8
:
3204 case DW_CFA_set_loc
:
3205 /* Should only be created by add_fde_cfi in a code path not
3206 followed when emitting via directives. The assembler is
3207 going to take care of this for us. */
3211 case DW_CFA_offset_extended
:
3212 case DW_CFA_offset_extended_sf
:
3213 r
= DWARF2_FRAME_REG_OUT (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
, 1);
3214 fprintf (asm_out_file
, "\t.cfi_offset %lu, "HOST_WIDE_INT_PRINT_DEC
"\n",
3215 r
, cfi
->dw_cfi_oprnd2
.dw_cfi_offset
);
3218 case DW_CFA_restore
:
3219 case DW_CFA_restore_extended
:
3220 r
= DWARF2_FRAME_REG_OUT (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
, 1);
3221 fprintf (asm_out_file
, "\t.cfi_restore %lu\n", r
);
3224 case DW_CFA_undefined
:
3225 r
= DWARF2_FRAME_REG_OUT (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
, 1);
3226 fprintf (asm_out_file
, "\t.cfi_undefined %lu\n", r
);
3229 case DW_CFA_same_value
:
3230 r
= DWARF2_FRAME_REG_OUT (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
, 1);
3231 fprintf (asm_out_file
, "\t.cfi_same_value %lu\n", r
);
3234 case DW_CFA_def_cfa
:
3235 case DW_CFA_def_cfa_sf
:
3236 r
= DWARF2_FRAME_REG_OUT (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
, 1);
3237 fprintf (asm_out_file
, "\t.cfi_def_cfa %lu, "HOST_WIDE_INT_PRINT_DEC
"\n",
3238 r
, cfi
->dw_cfi_oprnd2
.dw_cfi_offset
);
3241 case DW_CFA_def_cfa_register
:
3242 r
= DWARF2_FRAME_REG_OUT (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
, 1);
3243 fprintf (asm_out_file
, "\t.cfi_def_cfa_register %lu\n", r
);
3246 case DW_CFA_register
:
3247 r
= DWARF2_FRAME_REG_OUT (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
, 1);
3248 r2
= DWARF2_FRAME_REG_OUT (cfi
->dw_cfi_oprnd2
.dw_cfi_reg_num
, 1);
3249 fprintf (asm_out_file
, "\t.cfi_register %lu, %lu\n", r
, r2
);
3252 case DW_CFA_def_cfa_offset
:
3253 case DW_CFA_def_cfa_offset_sf
:
3254 fprintf (asm_out_file
, "\t.cfi_def_cfa_offset "
3255 HOST_WIDE_INT_PRINT_DEC
"\n",
3256 cfi
->dw_cfi_oprnd1
.dw_cfi_offset
);
3259 case DW_CFA_remember_state
:
3260 fprintf (asm_out_file
, "\t.cfi_remember_state\n");
3262 case DW_CFA_restore_state
:
3263 fprintf (asm_out_file
, "\t.cfi_restore_state\n");
3266 case DW_CFA_GNU_args_size
:
3267 fprintf (asm_out_file
, "\t.cfi_escape %#x,", DW_CFA_GNU_args_size
);
3268 dw2_asm_output_data_uleb128_raw (cfi
->dw_cfi_oprnd1
.dw_cfi_offset
);
3270 fprintf (asm_out_file
, "\t%s args_size "HOST_WIDE_INT_PRINT_DEC
,
3271 ASM_COMMENT_START
, cfi
->dw_cfi_oprnd1
.dw_cfi_offset
);
3272 fputc ('\n', asm_out_file
);
3275 case DW_CFA_GNU_window_save
:
3276 fprintf (asm_out_file
, "\t.cfi_window_save\n");
3279 case DW_CFA_def_cfa_expression
:
3280 case DW_CFA_expression
:
3281 fprintf (asm_out_file
, "\t.cfi_escape %#x,", cfi
->dw_cfi_opc
);
3282 output_cfa_loc_raw (cfi
);
3283 fputc ('\n', asm_out_file
);
3291 DEF_VEC_P (dw_cfi_ref
);
3292 DEF_VEC_ALLOC_P (dw_cfi_ref
, heap
);
3294 /* Output CFIs to bring current FDE to the same state as after executing
3295 CFIs in CFI chain. DO_CFI_ASM is true if .cfi_* directives shall
3296 be emitted, false otherwise. If it is false, FDE and FOR_EH are the
3297 other arguments to pass to output_cfi. */
3300 output_cfis (dw_cfi_ref cfi
, bool do_cfi_asm
, dw_fde_ref fde
, bool for_eh
)
3302 struct dw_cfi_struct cfi_buf
;
3304 dw_cfi_ref cfi_args_size
= NULL
, cfi_cfa
= NULL
, cfi_cfa_offset
= NULL
;
3305 VEC (dw_cfi_ref
, heap
) *regs
= VEC_alloc (dw_cfi_ref
, heap
, 32);
3306 unsigned int len
, idx
;
3308 for (;; cfi
= cfi
->dw_cfi_next
)
3309 switch (cfi
? cfi
->dw_cfi_opc
: DW_CFA_nop
)
3311 case DW_CFA_advance_loc
:
3312 case DW_CFA_advance_loc1
:
3313 case DW_CFA_advance_loc2
:
3314 case DW_CFA_advance_loc4
:
3315 case DW_CFA_MIPS_advance_loc8
:
3316 case DW_CFA_set_loc
:
3317 /* All advances should be ignored. */
3319 case DW_CFA_remember_state
:
3321 dw_cfi_ref args_size
= cfi_args_size
;
3323 /* Skip everything between .cfi_remember_state and
3324 .cfi_restore_state. */
3325 for (cfi2
= cfi
->dw_cfi_next
; cfi2
; cfi2
= cfi2
->dw_cfi_next
)
3326 if (cfi2
->dw_cfi_opc
== DW_CFA_restore_state
)
3328 else if (cfi2
->dw_cfi_opc
== DW_CFA_GNU_args_size
)
3331 gcc_assert (cfi2
->dw_cfi_opc
!= DW_CFA_remember_state
);
3338 cfi_args_size
= args_size
;
3342 case DW_CFA_GNU_args_size
:
3343 cfi_args_size
= cfi
;
3345 case DW_CFA_GNU_window_save
:
3348 case DW_CFA_offset_extended
:
3349 case DW_CFA_offset_extended_sf
:
3350 case DW_CFA_restore
:
3351 case DW_CFA_restore_extended
:
3352 case DW_CFA_undefined
:
3353 case DW_CFA_same_value
:
3354 case DW_CFA_register
:
3355 case DW_CFA_val_offset
:
3356 case DW_CFA_val_offset_sf
:
3357 case DW_CFA_expression
:
3358 case DW_CFA_val_expression
:
3359 case DW_CFA_GNU_negative_offset_extended
:
3360 if (VEC_length (dw_cfi_ref
, regs
) <= cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
)
3361 VEC_safe_grow_cleared (dw_cfi_ref
, heap
, regs
,
3362 cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
+ 1);
3363 VEC_replace (dw_cfi_ref
, regs
, cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
, cfi
);
3365 case DW_CFA_def_cfa
:
3366 case DW_CFA_def_cfa_sf
:
3367 case DW_CFA_def_cfa_expression
:
3369 cfi_cfa_offset
= cfi
;
3371 case DW_CFA_def_cfa_register
:
3374 case DW_CFA_def_cfa_offset
:
3375 case DW_CFA_def_cfa_offset_sf
:
3376 cfi_cfa_offset
= cfi
;
3379 gcc_assert (cfi
== NULL
);
3381 len
= VEC_length (dw_cfi_ref
, regs
);
3382 for (idx
= 0; idx
< len
; idx
++)
3384 cfi2
= VEC_replace (dw_cfi_ref
, regs
, idx
, NULL
);
3386 && cfi2
->dw_cfi_opc
!= DW_CFA_restore
3387 && cfi2
->dw_cfi_opc
!= DW_CFA_restore_extended
)
3390 output_cfi_directive (cfi2
);
3392 output_cfi (cfi2
, fde
, for_eh
);
3395 if (cfi_cfa
&& cfi_cfa_offset
&& cfi_cfa_offset
!= cfi_cfa
)
3397 gcc_assert (cfi_cfa
->dw_cfi_opc
!= DW_CFA_def_cfa_expression
);
3399 switch (cfi_cfa_offset
->dw_cfi_opc
)
3401 case DW_CFA_def_cfa_offset
:
3402 cfi_buf
.dw_cfi_opc
= DW_CFA_def_cfa
;
3403 cfi_buf
.dw_cfi_oprnd2
= cfi_cfa_offset
->dw_cfi_oprnd1
;
3405 case DW_CFA_def_cfa_offset_sf
:
3406 cfi_buf
.dw_cfi_opc
= DW_CFA_def_cfa_sf
;
3407 cfi_buf
.dw_cfi_oprnd2
= cfi_cfa_offset
->dw_cfi_oprnd1
;
3409 case DW_CFA_def_cfa
:
3410 case DW_CFA_def_cfa_sf
:
3411 cfi_buf
.dw_cfi_opc
= cfi_cfa_offset
->dw_cfi_opc
;
3412 cfi_buf
.dw_cfi_oprnd2
= cfi_cfa_offset
->dw_cfi_oprnd2
;
3419 else if (cfi_cfa_offset
)
3420 cfi_cfa
= cfi_cfa_offset
;
3424 output_cfi_directive (cfi_cfa
);
3426 output_cfi (cfi_cfa
, fde
, for_eh
);
3429 cfi_cfa_offset
= NULL
;
3431 && cfi_args_size
->dw_cfi_oprnd1
.dw_cfi_offset
)
3434 output_cfi_directive (cfi_args_size
);
3436 output_cfi (cfi_args_size
, fde
, for_eh
);
3438 cfi_args_size
= NULL
;
3441 VEC_free (dw_cfi_ref
, heap
, regs
);
3444 else if (do_cfi_asm
)
3445 output_cfi_directive (cfi
);
3447 output_cfi (cfi
, fde
, for_eh
);
3454 /* Output one FDE. */
3457 output_fde (dw_fde_ref fde
, bool for_eh
, bool second
,
3458 char *section_start_label
, int fde_encoding
, char *augmentation
,
3459 bool any_lsda_needed
, int lsda_encoding
)
3461 const char *begin
, *end
;
3462 static unsigned int j
;
3463 char l1
[20], l2
[20];
3466 targetm
.asm_out
.emit_unwind_label (asm_out_file
, fde
->decl
, for_eh
,
3468 targetm
.asm_out
.internal_label (asm_out_file
, FDE_LABEL
,
3470 ASM_GENERATE_INTERNAL_LABEL (l1
, FDE_AFTER_SIZE_LABEL
, for_eh
+ j
);
3471 ASM_GENERATE_INTERNAL_LABEL (l2
, FDE_END_LABEL
, for_eh
+ j
);
3472 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4 && !for_eh
)
3473 dw2_asm_output_data (4, 0xffffffff, "Initial length escape value"
3474 " indicating 64-bit DWARF extension");
3475 dw2_asm_output_delta (for_eh
? 4 : DWARF_OFFSET_SIZE
, l2
, l1
,
3477 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
3480 dw2_asm_output_delta (4, l1
, section_start_label
, "FDE CIE offset");
3482 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, section_start_label
,
3483 debug_frame_section
, "FDE CIE offset");
3485 if (!fde
->dw_fde_switched_sections
)
3487 begin
= fde
->dw_fde_begin
;
3488 end
= fde
->dw_fde_end
;
3492 /* For the first section, prefer dw_fde_begin over
3493 dw_fde_{hot,cold}_section_label, as the latter
3494 might be separated from the real start of the
3495 function by alignment padding. */
3497 begin
= fde
->dw_fde_begin
;
3498 else if (fde
->dw_fde_switched_cold_to_hot
)
3499 begin
= fde
->dw_fde_hot_section_label
;
3501 begin
= fde
->dw_fde_unlikely_section_label
;
3502 if (second
^ fde
->dw_fde_switched_cold_to_hot
)
3503 end
= fde
->dw_fde_unlikely_section_end_label
;
3505 end
= fde
->dw_fde_hot_section_end_label
;
3510 rtx sym_ref
= gen_rtx_SYMBOL_REF (Pmode
, begin
);
3511 SYMBOL_REF_FLAGS (sym_ref
) |= SYMBOL_FLAG_LOCAL
;
3512 dw2_asm_output_encoded_addr_rtx (fde_encoding
, sym_ref
, false,
3513 "FDE initial location");
3514 dw2_asm_output_delta (size_of_encoded_value (fde_encoding
),
3515 end
, begin
, "FDE address range");
3519 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, begin
, "FDE initial location");
3520 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, end
, begin
, "FDE address range");
3523 if (augmentation
[0])
3525 if (any_lsda_needed
)
3527 int size
= size_of_encoded_value (lsda_encoding
);
3529 if (lsda_encoding
== DW_EH_PE_aligned
)
3531 int offset
= ( 4 /* Length */
3532 + 4 /* CIE offset */
3533 + 2 * size_of_encoded_value (fde_encoding
)
3534 + 1 /* Augmentation size */ );
3535 int pad
= -offset
& (PTR_SIZE
- 1);
3538 gcc_assert (size_of_uleb128 (size
) == 1);
3541 dw2_asm_output_data_uleb128 (size
, "Augmentation size");
3543 if (fde
->uses_eh_lsda
)
3545 ASM_GENERATE_INTERNAL_LABEL (l1
, second
? "LLSDAC" : "LLSDA",
3546 fde
->funcdef_number
);
3547 dw2_asm_output_encoded_addr_rtx (lsda_encoding
,
3548 gen_rtx_SYMBOL_REF (Pmode
, l1
),
3550 "Language Specific Data Area");
3554 if (lsda_encoding
== DW_EH_PE_aligned
)
3555 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (PTR_SIZE
));
3556 dw2_asm_output_data (size_of_encoded_value (lsda_encoding
), 0,
3557 "Language Specific Data Area (none)");
3561 dw2_asm_output_data_uleb128 (0, "Augmentation size");
3564 /* Loop through the Call Frame Instructions associated with
3566 fde
->dw_fde_current_label
= begin
;
3567 if (!fde
->dw_fde_switched_sections
)
3568 for (cfi
= fde
->dw_fde_cfi
; cfi
!= NULL
; cfi
= cfi
->dw_cfi_next
)
3569 output_cfi (cfi
, fde
, for_eh
);
3572 if (fde
->dw_fde_switch_cfi
)
3573 for (cfi
= fde
->dw_fde_cfi
; cfi
!= NULL
; cfi
= cfi
->dw_cfi_next
)
3575 output_cfi (cfi
, fde
, for_eh
);
3576 if (cfi
== fde
->dw_fde_switch_cfi
)
3582 dw_cfi_ref cfi_next
= fde
->dw_fde_cfi
;
3584 if (fde
->dw_fde_switch_cfi
)
3586 cfi_next
= fde
->dw_fde_switch_cfi
->dw_cfi_next
;
3587 fde
->dw_fde_switch_cfi
->dw_cfi_next
= NULL
;
3588 output_cfis (fde
->dw_fde_cfi
, false, fde
, for_eh
);
3589 fde
->dw_fde_switch_cfi
->dw_cfi_next
= cfi_next
;
3591 for (cfi
= cfi_next
; cfi
!= NULL
; cfi
= cfi
->dw_cfi_next
)
3592 output_cfi (cfi
, fde
, for_eh
);
3595 /* If we are to emit a ref/link from function bodies to their frame tables,
3596 do it now. This is typically performed to make sure that tables
3597 associated with functions are dragged with them and not discarded in
3598 garbage collecting links. We need to do this on a per function basis to
3599 cope with -ffunction-sections. */
3601 #ifdef ASM_OUTPUT_DWARF_TABLE_REF
3602 /* Switch to the function section, emit the ref to the tables, and
3603 switch *back* into the table section. */
3604 switch_to_section (function_section (fde
->decl
));
3605 ASM_OUTPUT_DWARF_TABLE_REF (section_start_label
);
3606 switch_to_frame_table_section (for_eh
, true);
3609 /* Pad the FDE out to an address sized boundary. */
3610 ASM_OUTPUT_ALIGN (asm_out_file
,
3611 floor_log2 ((for_eh
? PTR_SIZE
: DWARF2_ADDR_SIZE
)));
3612 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
3617 /* Return true if frame description entry FDE is needed for EH. */
3620 fde_needed_for_eh_p (dw_fde_ref fde
)
3622 if (flag_asynchronous_unwind_tables
)
3625 if (TARGET_USES_WEAK_UNWIND_INFO
&& DECL_WEAK (fde
->decl
))
3628 if (fde
->uses_eh_lsda
)
3631 /* If exceptions are enabled, we have collected nothrow info. */
3632 if (flag_exceptions
&& (fde
->all_throwers_are_sibcalls
|| fde
->nothrow
))
3638 /* Output the call frame information used to record information
3639 that relates to calculating the frame pointer, and records the
3640 location of saved registers. */
3643 output_call_frame_info (int for_eh
)
3648 char l1
[20], l2
[20], section_start_label
[20];
3649 bool any_lsda_needed
= false;
3650 char augmentation
[6];
3651 int augmentation_size
;
3652 int fde_encoding
= DW_EH_PE_absptr
;
3653 int per_encoding
= DW_EH_PE_absptr
;
3654 int lsda_encoding
= DW_EH_PE_absptr
;
3656 rtx personality
= NULL
;
3659 /* Don't emit a CIE if there won't be any FDEs. */
3660 if (fde_table_in_use
== 0)
3663 /* Nothing to do if the assembler's doing it all. */
3664 if (dwarf2out_do_cfi_asm ())
3667 /* If we don't have any functions we'll want to unwind out of, don't emit
3668 any EH unwind information. If we make FDEs linkonce, we may have to
3669 emit an empty label for an FDE that wouldn't otherwise be emitted. We
3670 want to avoid having an FDE kept around when the function it refers to
3671 is discarded. Example where this matters: a primary function template
3672 in C++ requires EH information, an explicit specialization doesn't. */
3675 bool any_eh_needed
= false;
3677 for (i
= 0; i
< fde_table_in_use
; i
++)
3678 if (fde_table
[i
].uses_eh_lsda
)
3679 any_eh_needed
= any_lsda_needed
= true;
3680 else if (fde_needed_for_eh_p (&fde_table
[i
]))
3681 any_eh_needed
= true;
3682 else if (TARGET_USES_WEAK_UNWIND_INFO
)
3683 targetm
.asm_out
.emit_unwind_label (asm_out_file
, fde_table
[i
].decl
,
3690 /* We're going to be generating comments, so turn on app. */
3694 /* Switch to the proper frame section, first time. */
3695 switch_to_frame_table_section (for_eh
, false);
3697 ASM_GENERATE_INTERNAL_LABEL (section_start_label
, FRAME_BEGIN_LABEL
, for_eh
);
3698 ASM_OUTPUT_LABEL (asm_out_file
, section_start_label
);
3700 /* Output the CIE. */
3701 ASM_GENERATE_INTERNAL_LABEL (l1
, CIE_AFTER_SIZE_LABEL
, for_eh
);
3702 ASM_GENERATE_INTERNAL_LABEL (l2
, CIE_END_LABEL
, for_eh
);
3703 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4 && !for_eh
)
3704 dw2_asm_output_data (4, 0xffffffff,
3705 "Initial length escape value indicating 64-bit DWARF extension");
3706 dw2_asm_output_delta (for_eh
? 4 : DWARF_OFFSET_SIZE
, l2
, l1
,
3707 "Length of Common Information Entry");
3708 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
3710 /* Now that the CIE pointer is PC-relative for EH,
3711 use 0 to identify the CIE. */
3712 dw2_asm_output_data ((for_eh
? 4 : DWARF_OFFSET_SIZE
),
3713 (for_eh
? 0 : DWARF_CIE_ID
),
3714 "CIE Identifier Tag");
3716 /* Use the CIE version 3 for DWARF3; allow DWARF2 to continue to
3717 use CIE version 1, unless that would produce incorrect results
3718 due to overflowing the return register column. */
3719 return_reg
= DWARF2_FRAME_REG_OUT (DWARF_FRAME_RETURN_COLUMN
, for_eh
);
3721 if (return_reg
>= 256 || dwarf_version
> 2)
3723 dw2_asm_output_data (1, dw_cie_version
, "CIE Version");
3725 augmentation
[0] = 0;
3726 augmentation_size
= 0;
3728 personality
= current_unit_personality
;
3734 z Indicates that a uleb128 is present to size the
3735 augmentation section.
3736 L Indicates the encoding (and thus presence) of
3737 an LSDA pointer in the FDE augmentation.
3738 R Indicates a non-default pointer encoding for
3740 P Indicates the presence of an encoding + language
3741 personality routine in the CIE augmentation. */
3743 fde_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0);
3744 per_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
3745 lsda_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
3747 p
= augmentation
+ 1;
3751 augmentation_size
+= 1 + size_of_encoded_value (per_encoding
);
3752 assemble_external_libcall (personality
);
3754 if (any_lsda_needed
)
3757 augmentation_size
+= 1;
3759 if (fde_encoding
!= DW_EH_PE_absptr
)
3762 augmentation_size
+= 1;
3764 if (p
> augmentation
+ 1)
3766 augmentation
[0] = 'z';
3770 /* Ug. Some platforms can't do unaligned dynamic relocations at all. */
3771 if (personality
&& per_encoding
== DW_EH_PE_aligned
)
3773 int offset
= ( 4 /* Length */
3775 + 1 /* CIE version */
3776 + strlen (augmentation
) + 1 /* Augmentation */
3777 + size_of_uleb128 (1) /* Code alignment */
3778 + size_of_sleb128 (DWARF_CIE_DATA_ALIGNMENT
)
3780 + 1 /* Augmentation size */
3781 + 1 /* Personality encoding */ );
3782 int pad
= -offset
& (PTR_SIZE
- 1);
3784 augmentation_size
+= pad
;
3786 /* Augmentations should be small, so there's scarce need to
3787 iterate for a solution. Die if we exceed one uleb128 byte. */
3788 gcc_assert (size_of_uleb128 (augmentation_size
) == 1);
3792 dw2_asm_output_nstring (augmentation
, -1, "CIE Augmentation");
3793 if (dw_cie_version
>= 4)
3795 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "CIE Address Size");
3796 dw2_asm_output_data (1, 0, "CIE Segment Size");
3798 dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor");
3799 dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT
,
3800 "CIE Data Alignment Factor");
3802 if (dw_cie_version
== 1)
3803 dw2_asm_output_data (1, return_reg
, "CIE RA Column");
3805 dw2_asm_output_data_uleb128 (return_reg
, "CIE RA Column");
3807 if (augmentation
[0])
3809 dw2_asm_output_data_uleb128 (augmentation_size
, "Augmentation size");
3812 dw2_asm_output_data (1, per_encoding
, "Personality (%s)",
3813 eh_data_format_name (per_encoding
));
3814 dw2_asm_output_encoded_addr_rtx (per_encoding
,
3819 if (any_lsda_needed
)
3820 dw2_asm_output_data (1, lsda_encoding
, "LSDA Encoding (%s)",
3821 eh_data_format_name (lsda_encoding
));
3823 if (fde_encoding
!= DW_EH_PE_absptr
)
3824 dw2_asm_output_data (1, fde_encoding
, "FDE Encoding (%s)",
3825 eh_data_format_name (fde_encoding
));
3828 for (cfi
= cie_cfi_head
; cfi
!= NULL
; cfi
= cfi
->dw_cfi_next
)
3829 output_cfi (cfi
, NULL
, for_eh
);
3831 /* Pad the CIE out to an address sized boundary. */
3832 ASM_OUTPUT_ALIGN (asm_out_file
,
3833 floor_log2 (for_eh
? PTR_SIZE
: DWARF2_ADDR_SIZE
));
3834 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
3836 /* Loop through all of the FDE's. */
3837 for (i
= 0; i
< fde_table_in_use
; i
++)
3840 fde
= &fde_table
[i
];
3842 /* Don't emit EH unwind info for leaf functions that don't need it. */
3843 if (for_eh
&& !fde_needed_for_eh_p (fde
))
3846 for (k
= 0; k
< (fde
->dw_fde_switched_sections
? 2 : 1); k
++)
3847 output_fde (fde
, for_eh
, k
, section_start_label
, fde_encoding
,
3848 augmentation
, any_lsda_needed
, lsda_encoding
);
3851 if (for_eh
&& targetm
.terminate_dw2_eh_frame_info
)
3852 dw2_asm_output_data (4, 0, "End of Table");
3853 #ifdef MIPS_DEBUGGING_INFO
3854 /* Work around Irix 6 assembler bug whereby labels at the end of a section
3855 get a value of 0. Putting .align 0 after the label fixes it. */
3856 ASM_OUTPUT_ALIGN (asm_out_file
, 0);
3859 /* Turn off app to make assembly quicker. */
3864 /* Emit .cfi_startproc and .cfi_personality/.cfi_lsda if needed. */
3867 dwarf2out_do_cfi_startproc (bool second
)
3871 rtx personality
= get_personality_function (current_function_decl
);
3873 fprintf (asm_out_file
, "\t.cfi_startproc\n");
3877 enc
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
3880 /* ??? The GAS support isn't entirely consistent. We have to
3881 handle indirect support ourselves, but PC-relative is done
3882 in the assembler. Further, the assembler can't handle any
3883 of the weirder relocation types. */
3884 if (enc
& DW_EH_PE_indirect
)
3885 ref
= dw2_force_const_mem (ref
, true);
3887 fprintf (asm_out_file
, "\t.cfi_personality %#x,", enc
);
3888 output_addr_const (asm_out_file
, ref
);
3889 fputc ('\n', asm_out_file
);
3892 if (crtl
->uses_eh_lsda
)
3896 enc
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
3897 ASM_GENERATE_INTERNAL_LABEL (lab
, second
? "LLSDAC" : "LLSDA",
3898 current_function_funcdef_no
);
3899 ref
= gen_rtx_SYMBOL_REF (Pmode
, lab
);
3900 SYMBOL_REF_FLAGS (ref
) = SYMBOL_FLAG_LOCAL
;
3902 if (enc
& DW_EH_PE_indirect
)
3903 ref
= dw2_force_const_mem (ref
, true);
3905 fprintf (asm_out_file
, "\t.cfi_lsda %#x,", enc
);
3906 output_addr_const (asm_out_file
, ref
);
3907 fputc ('\n', asm_out_file
);
3911 /* Output a marker (i.e. a label) for the beginning of a function, before
3915 dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED
,
3916 const char *file ATTRIBUTE_UNUSED
)
3918 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3923 current_function_func_begin_label
= NULL
;
3925 #ifdef TARGET_UNWIND_INFO
3926 /* ??? current_function_func_begin_label is also used by except.c
3927 for call-site information. We must emit this label if it might
3929 if ((! flag_exceptions
|| USING_SJLJ_EXCEPTIONS
)
3930 && ! dwarf2out_do_frame ())
3933 if (! dwarf2out_do_frame ())
3937 fnsec
= function_section (current_function_decl
);
3938 switch_to_section (fnsec
);
3939 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_BEGIN_LABEL
,
3940 current_function_funcdef_no
);
3941 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, FUNC_BEGIN_LABEL
,
3942 current_function_funcdef_no
);
3943 dup_label
= xstrdup (label
);
3944 current_function_func_begin_label
= dup_label
;
3946 #ifdef TARGET_UNWIND_INFO
3947 /* We can elide the fde allocation if we're not emitting debug info. */
3948 if (! dwarf2out_do_frame ())
3952 /* Expand the fde table if necessary. */
3953 if (fde_table_in_use
== fde_table_allocated
)
3955 fde_table_allocated
+= FDE_TABLE_INCREMENT
;
3956 fde_table
= GGC_RESIZEVEC (dw_fde_node
, fde_table
, fde_table_allocated
);
3957 memset (fde_table
+ fde_table_in_use
, 0,
3958 FDE_TABLE_INCREMENT
* sizeof (dw_fde_node
));
3961 /* Record the FDE associated with this function. */
3962 current_funcdef_fde
= fde_table_in_use
;
3964 /* Add the new FDE at the end of the fde_table. */
3965 fde
= &fde_table
[fde_table_in_use
++];
3966 fde
->decl
= current_function_decl
;
3967 fde
->dw_fde_begin
= dup_label
;
3968 fde
->dw_fde_current_label
= dup_label
;
3969 fde
->dw_fde_hot_section_label
= NULL
;
3970 fde
->dw_fde_hot_section_end_label
= NULL
;
3971 fde
->dw_fde_unlikely_section_label
= NULL
;
3972 fde
->dw_fde_unlikely_section_end_label
= NULL
;
3973 fde
->dw_fde_switched_sections
= 0;
3974 fde
->dw_fde_switched_cold_to_hot
= 0;
3975 fde
->dw_fde_end
= NULL
;
3976 fde
->dw_fde_vms_end_prologue
= NULL
;
3977 fde
->dw_fde_vms_begin_epilogue
= NULL
;
3978 fde
->dw_fde_cfi
= NULL
;
3979 fde
->dw_fde_switch_cfi
= NULL
;
3980 fde
->funcdef_number
= current_function_funcdef_no
;
3981 fde
->all_throwers_are_sibcalls
= crtl
->all_throwers_are_sibcalls
;
3982 fde
->uses_eh_lsda
= crtl
->uses_eh_lsda
;
3983 fde
->nothrow
= crtl
->nothrow
;
3984 fde
->drap_reg
= INVALID_REGNUM
;
3985 fde
->vdrap_reg
= INVALID_REGNUM
;
3986 if (flag_reorder_blocks_and_partition
)
3988 section
*unlikelysec
;
3989 if (first_function_block_is_cold
)
3990 fde
->in_std_section
= 1;
3993 = (fnsec
== text_section
3994 || (cold_text_section
&& fnsec
== cold_text_section
));
3995 unlikelysec
= unlikely_text_section ();
3996 fde
->cold_in_std_section
3997 = (unlikelysec
== text_section
3998 || (cold_text_section
&& unlikelysec
== cold_text_section
));
4003 = (fnsec
== text_section
4004 || (cold_text_section
&& fnsec
== cold_text_section
));
4005 fde
->cold_in_std_section
= 0;
4008 args_size
= old_args_size
= 0;
4010 /* We only want to output line number information for the genuine dwarf2
4011 prologue case, not the eh frame case. */
4012 #ifdef DWARF2_DEBUGGING_INFO
4014 dwarf2out_source_line (line
, file
, 0, true);
4017 if (dwarf2out_do_cfi_asm ())
4018 dwarf2out_do_cfi_startproc (false);
4021 rtx personality
= get_personality_function (current_function_decl
);
4022 if (!current_unit_personality
)
4023 current_unit_personality
= personality
;
4025 /* We cannot keep a current personality per function as without CFI
4026 asm, at the point where we emit the CFI data, there is no current
4027 function anymore. */
4028 if (personality
&& current_unit_personality
!= personality
)
4029 sorry ("multiple EH personalities are supported only with assemblers "
4030 "supporting .cfi_personality directive");
4034 /* Output a marker (i.e. a label) for the end of the generated code
4035 for a function prologue. This gets called *after* the prologue code has
4039 dwarf2out_vms_end_prologue (unsigned int line ATTRIBUTE_UNUSED
,
4040 const char *file ATTRIBUTE_UNUSED
)
4043 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4045 /* Output a label to mark the endpoint of the code generated for this
4047 ASM_GENERATE_INTERNAL_LABEL (label
, PROLOGUE_END_LABEL
,
4048 current_function_funcdef_no
);
4049 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, PROLOGUE_END_LABEL
,
4050 current_function_funcdef_no
);
4051 fde
= &fde_table
[fde_table_in_use
- 1];
4052 fde
->dw_fde_vms_end_prologue
= xstrdup (label
);
4055 /* Output a marker (i.e. a label) for the beginning of the generated code
4056 for a function epilogue. This gets called *before* the prologue code has
4060 dwarf2out_vms_begin_epilogue (unsigned int line ATTRIBUTE_UNUSED
,
4061 const char *file ATTRIBUTE_UNUSED
)
4064 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4066 fde
= &fde_table
[fde_table_in_use
- 1];
4067 if (fde
->dw_fde_vms_begin_epilogue
)
4070 /* Output a label to mark the endpoint of the code generated for this
4072 ASM_GENERATE_INTERNAL_LABEL (label
, EPILOGUE_BEGIN_LABEL
,
4073 current_function_funcdef_no
);
4074 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, EPILOGUE_BEGIN_LABEL
,
4075 current_function_funcdef_no
);
4076 fde
->dw_fde_vms_begin_epilogue
= xstrdup (label
);
4079 /* Output a marker (i.e. a label) for the absolute end of the generated code
4080 for a function definition. This gets called *after* the epilogue code has
4084 dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED
,
4085 const char *file ATTRIBUTE_UNUSED
)
4088 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4090 #ifdef DWARF2_DEBUGGING_INFO
4091 last_var_location_insn
= NULL_RTX
;
4094 if (dwarf2out_do_cfi_asm ())
4095 fprintf (asm_out_file
, "\t.cfi_endproc\n");
4097 /* Output a label to mark the endpoint of the code generated for this
4099 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_END_LABEL
,
4100 current_function_funcdef_no
);
4101 ASM_OUTPUT_LABEL (asm_out_file
, label
);
4102 fde
= current_fde ();
4103 gcc_assert (fde
!= NULL
);
4104 fde
->dw_fde_end
= xstrdup (label
);
4108 dwarf2out_frame_init (void)
4110 /* Allocate the initial hunk of the fde_table. */
4111 fde_table
= ggc_alloc_cleared_vec_dw_fde_node (FDE_TABLE_INCREMENT
);
4112 fde_table_allocated
= FDE_TABLE_INCREMENT
;
4113 fde_table_in_use
= 0;
4115 /* Generate the CFA instructions common to all FDE's. Do it now for the
4116 sake of lookup_cfa. */
4118 /* On entry, the Canonical Frame Address is at SP. */
4119 dwarf2out_def_cfa (NULL
, STACK_POINTER_REGNUM
, INCOMING_FRAME_SP_OFFSET
);
4121 #ifdef DWARF2_UNWIND_INFO
4122 if (DWARF2_UNWIND_INFO
|| DWARF2_FRAME_INFO
)
4123 initial_return_save (INCOMING_RETURN_ADDR_RTX
);
4128 dwarf2out_frame_finish (void)
4130 /* Output call frame information. */
4131 if (DWARF2_FRAME_INFO
)
4132 output_call_frame_info (0);
4134 #ifndef TARGET_UNWIND_INFO
4135 /* Output another copy for the unwinder. */
4136 if (! USING_SJLJ_EXCEPTIONS
&& (flag_unwind_tables
|| flag_exceptions
))
4137 output_call_frame_info (1);
4141 /* Note that the current function section is being used for code. */
4144 dwarf2out_note_section_used (void)
4146 section
*sec
= current_function_section ();
4147 if (sec
== text_section
)
4148 text_section_used
= true;
4149 else if (sec
== cold_text_section
)
4150 cold_text_section_used
= true;
4154 dwarf2out_switch_text_section (void)
4156 dw_fde_ref fde
= current_fde ();
4158 gcc_assert (cfun
&& fde
&& !fde
->dw_fde_switched_sections
);
4160 fde
->dw_fde_switched_sections
= 1;
4161 fde
->dw_fde_switched_cold_to_hot
= !in_cold_section_p
;
4163 fde
->dw_fde_hot_section_label
= crtl
->subsections
.hot_section_label
;
4164 fde
->dw_fde_hot_section_end_label
= crtl
->subsections
.hot_section_end_label
;
4165 fde
->dw_fde_unlikely_section_label
= crtl
->subsections
.cold_section_label
;
4166 fde
->dw_fde_unlikely_section_end_label
= crtl
->subsections
.cold_section_end_label
;
4167 have_multiple_function_sections
= true;
4169 /* Reset the current label on switching text sections, so that we
4170 don't attempt to advance_loc4 between labels in different sections. */
4171 fde
->dw_fde_current_label
= NULL
;
4173 /* There is no need to mark used sections when not debugging. */
4174 if (cold_text_section
!= NULL
)
4175 dwarf2out_note_section_used ();
4177 if (dwarf2out_do_cfi_asm ())
4178 fprintf (asm_out_file
, "\t.cfi_endproc\n");
4180 /* Now do the real section switch. */
4181 switch_to_section (current_function_section ());
4183 if (dwarf2out_do_cfi_asm ())
4185 dwarf2out_do_cfi_startproc (true);
4186 /* As this is a different FDE, insert all current CFI instructions
4188 output_cfis (fde
->dw_fde_cfi
, true, fde
, true);
4192 dw_cfi_ref cfi
= fde
->dw_fde_cfi
;
4194 cfi
= fde
->dw_fde_cfi
;
4196 while (cfi
->dw_cfi_next
!= NULL
)
4197 cfi
= cfi
->dw_cfi_next
;
4198 fde
->dw_fde_switch_cfi
= cfi
;
4203 /* And now, the subset of the debugging information support code necessary
4204 for emitting location expressions. */
4206 /* Data about a single source file. */
4207 struct GTY(()) dwarf_file_data
{
4208 const char * filename
;
4212 typedef struct dw_val_struct
*dw_val_ref
;
4213 typedef struct die_struct
*dw_die_ref
;
4214 typedef const struct die_struct
*const_dw_die_ref
;
4215 typedef struct dw_loc_descr_struct
*dw_loc_descr_ref
;
4216 typedef struct dw_loc_list_struct
*dw_loc_list_ref
;
4218 typedef struct GTY(()) deferred_locations_struct
4222 } deferred_locations
;
4224 DEF_VEC_O(deferred_locations
);
4225 DEF_VEC_ALLOC_O(deferred_locations
,gc
);
4227 static GTY(()) VEC(deferred_locations
, gc
) *deferred_locations_list
;
4229 DEF_VEC_P(dw_die_ref
);
4230 DEF_VEC_ALLOC_P(dw_die_ref
,heap
);
4232 /* Each DIE may have a series of attribute/value pairs. Values
4233 can take on several forms. The forms that are used in this
4234 implementation are listed below. */
4239 dw_val_class_offset
,
4241 dw_val_class_loc_list
,
4242 dw_val_class_range_list
,
4244 dw_val_class_unsigned_const
,
4245 dw_val_class_const_double
,
4248 dw_val_class_die_ref
,
4249 dw_val_class_fde_ref
,
4250 dw_val_class_lbl_id
,
4251 dw_val_class_lineptr
,
4253 dw_val_class_macptr
,
4256 dw_val_class_vms_delta
4259 /* Describe a floating point constant value, or a vector constant value. */
4261 typedef struct GTY(()) dw_vec_struct
{
4262 unsigned char * GTY((length ("%h.length"))) array
;
4268 /* The dw_val_node describes an attribute's value, as it is
4269 represented internally. */
4271 typedef struct GTY(()) dw_val_struct
{
4272 enum dw_val_class val_class
;
4273 union dw_val_struct_union
4275 rtx
GTY ((tag ("dw_val_class_addr"))) val_addr
;
4276 unsigned HOST_WIDE_INT
GTY ((tag ("dw_val_class_offset"))) val_offset
;
4277 dw_loc_list_ref
GTY ((tag ("dw_val_class_loc_list"))) val_loc_list
;
4278 dw_loc_descr_ref
GTY ((tag ("dw_val_class_loc"))) val_loc
;
4279 HOST_WIDE_INT
GTY ((default)) val_int
;
4280 unsigned HOST_WIDE_INT
GTY ((tag ("dw_val_class_unsigned_const"))) val_unsigned
;
4281 double_int
GTY ((tag ("dw_val_class_const_double"))) val_double
;
4282 dw_vec_const
GTY ((tag ("dw_val_class_vec"))) val_vec
;
4283 struct dw_val_die_union
4287 } GTY ((tag ("dw_val_class_die_ref"))) val_die_ref
;
4288 unsigned GTY ((tag ("dw_val_class_fde_ref"))) val_fde_index
;
4289 struct indirect_string_node
* GTY ((tag ("dw_val_class_str"))) val_str
;
4290 char * GTY ((tag ("dw_val_class_lbl_id"))) val_lbl_id
;
4291 unsigned char GTY ((tag ("dw_val_class_flag"))) val_flag
;
4292 struct dwarf_file_data
* GTY ((tag ("dw_val_class_file"))) val_file
;
4293 unsigned char GTY ((tag ("dw_val_class_data8"))) val_data8
[8];
4294 struct dw_val_vms_delta_union
4298 } GTY ((tag ("dw_val_class_vms_delta"))) val_vms_delta
;
4300 GTY ((desc ("%1.val_class"))) v
;
4304 /* Locations in memory are described using a sequence of stack machine
4307 typedef struct GTY(()) dw_loc_descr_struct
{
4308 dw_loc_descr_ref dw_loc_next
;
4309 ENUM_BITFIELD (dwarf_location_atom
) dw_loc_opc
: 8;
4310 /* Used to distinguish DW_OP_addr with a direct symbol relocation
4311 from DW_OP_addr with a dtp-relative symbol relocation. */
4312 unsigned int dtprel
: 1;
4314 dw_val_node dw_loc_oprnd1
;
4315 dw_val_node dw_loc_oprnd2
;
4319 /* Location lists are ranges + location descriptions for that range,
4320 so you can track variables that are in different places over
4321 their entire life. */
4322 typedef struct GTY(()) dw_loc_list_struct
{
4323 dw_loc_list_ref dw_loc_next
;
4324 const char *begin
; /* Label for begin address of range */
4325 const char *end
; /* Label for end address of range */
4326 char *ll_symbol
; /* Label for beginning of location list.
4327 Only on head of list */
4328 const char *section
; /* Section this loclist is relative to */
4329 dw_loc_descr_ref expr
;
4332 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
4334 static dw_loc_descr_ref
int_loc_descriptor (HOST_WIDE_INT
);
4336 /* Convert a DWARF stack opcode into its string name. */
4339 dwarf_stack_op_name (unsigned int op
)
4344 return "DW_OP_addr";
4346 return "DW_OP_deref";
4348 return "DW_OP_const1u";
4350 return "DW_OP_const1s";
4352 return "DW_OP_const2u";
4354 return "DW_OP_const2s";
4356 return "DW_OP_const4u";
4358 return "DW_OP_const4s";
4360 return "DW_OP_const8u";
4362 return "DW_OP_const8s";
4364 return "DW_OP_constu";
4366 return "DW_OP_consts";
4370 return "DW_OP_drop";
4372 return "DW_OP_over";
4374 return "DW_OP_pick";
4376 return "DW_OP_swap";
4380 return "DW_OP_xderef";
4388 return "DW_OP_minus";
4400 return "DW_OP_plus";
4401 case DW_OP_plus_uconst
:
4402 return "DW_OP_plus_uconst";
4408 return "DW_OP_shra";
4426 return "DW_OP_skip";
4428 return "DW_OP_lit0";
4430 return "DW_OP_lit1";
4432 return "DW_OP_lit2";
4434 return "DW_OP_lit3";
4436 return "DW_OP_lit4";
4438 return "DW_OP_lit5";
4440 return "DW_OP_lit6";
4442 return "DW_OP_lit7";
4444 return "DW_OP_lit8";
4446 return "DW_OP_lit9";
4448 return "DW_OP_lit10";
4450 return "DW_OP_lit11";
4452 return "DW_OP_lit12";
4454 return "DW_OP_lit13";
4456 return "DW_OP_lit14";
4458 return "DW_OP_lit15";
4460 return "DW_OP_lit16";
4462 return "DW_OP_lit17";
4464 return "DW_OP_lit18";
4466 return "DW_OP_lit19";
4468 return "DW_OP_lit20";
4470 return "DW_OP_lit21";
4472 return "DW_OP_lit22";
4474 return "DW_OP_lit23";
4476 return "DW_OP_lit24";
4478 return "DW_OP_lit25";
4480 return "DW_OP_lit26";
4482 return "DW_OP_lit27";
4484 return "DW_OP_lit28";
4486 return "DW_OP_lit29";
4488 return "DW_OP_lit30";
4490 return "DW_OP_lit31";
4492 return "DW_OP_reg0";
4494 return "DW_OP_reg1";
4496 return "DW_OP_reg2";
4498 return "DW_OP_reg3";
4500 return "DW_OP_reg4";
4502 return "DW_OP_reg5";
4504 return "DW_OP_reg6";
4506 return "DW_OP_reg7";
4508 return "DW_OP_reg8";
4510 return "DW_OP_reg9";
4512 return "DW_OP_reg10";
4514 return "DW_OP_reg11";
4516 return "DW_OP_reg12";
4518 return "DW_OP_reg13";
4520 return "DW_OP_reg14";
4522 return "DW_OP_reg15";
4524 return "DW_OP_reg16";
4526 return "DW_OP_reg17";
4528 return "DW_OP_reg18";
4530 return "DW_OP_reg19";
4532 return "DW_OP_reg20";
4534 return "DW_OP_reg21";
4536 return "DW_OP_reg22";
4538 return "DW_OP_reg23";
4540 return "DW_OP_reg24";
4542 return "DW_OP_reg25";
4544 return "DW_OP_reg26";
4546 return "DW_OP_reg27";
4548 return "DW_OP_reg28";
4550 return "DW_OP_reg29";
4552 return "DW_OP_reg30";
4554 return "DW_OP_reg31";
4556 return "DW_OP_breg0";
4558 return "DW_OP_breg1";
4560 return "DW_OP_breg2";
4562 return "DW_OP_breg3";
4564 return "DW_OP_breg4";
4566 return "DW_OP_breg5";
4568 return "DW_OP_breg6";
4570 return "DW_OP_breg7";
4572 return "DW_OP_breg8";
4574 return "DW_OP_breg9";
4576 return "DW_OP_breg10";
4578 return "DW_OP_breg11";
4580 return "DW_OP_breg12";
4582 return "DW_OP_breg13";
4584 return "DW_OP_breg14";
4586 return "DW_OP_breg15";
4588 return "DW_OP_breg16";
4590 return "DW_OP_breg17";
4592 return "DW_OP_breg18";
4594 return "DW_OP_breg19";
4596 return "DW_OP_breg20";
4598 return "DW_OP_breg21";
4600 return "DW_OP_breg22";
4602 return "DW_OP_breg23";
4604 return "DW_OP_breg24";
4606 return "DW_OP_breg25";
4608 return "DW_OP_breg26";
4610 return "DW_OP_breg27";
4612 return "DW_OP_breg28";
4614 return "DW_OP_breg29";
4616 return "DW_OP_breg30";
4618 return "DW_OP_breg31";
4620 return "DW_OP_regx";
4622 return "DW_OP_fbreg";
4624 return "DW_OP_bregx";
4626 return "DW_OP_piece";
4627 case DW_OP_deref_size
:
4628 return "DW_OP_deref_size";
4629 case DW_OP_xderef_size
:
4630 return "DW_OP_xderef_size";
4634 case DW_OP_push_object_address
:
4635 return "DW_OP_push_object_address";
4637 return "DW_OP_call2";
4639 return "DW_OP_call4";
4640 case DW_OP_call_ref
:
4641 return "DW_OP_call_ref";
4642 case DW_OP_implicit_value
:
4643 return "DW_OP_implicit_value";
4644 case DW_OP_stack_value
:
4645 return "DW_OP_stack_value";
4646 case DW_OP_form_tls_address
:
4647 return "DW_OP_form_tls_address";
4648 case DW_OP_call_frame_cfa
:
4649 return "DW_OP_call_frame_cfa";
4650 case DW_OP_bit_piece
:
4651 return "DW_OP_bit_piece";
4653 case DW_OP_GNU_push_tls_address
:
4654 return "DW_OP_GNU_push_tls_address";
4655 case DW_OP_GNU_uninit
:
4656 return "DW_OP_GNU_uninit";
4657 case DW_OP_GNU_encoded_addr
:
4658 return "DW_OP_GNU_encoded_addr";
4661 return "OP_<unknown>";
4665 /* Return a pointer to a newly allocated location description. Location
4666 descriptions are simple expression terms that can be strung
4667 together to form more complicated location (address) descriptions. */
4669 static inline dw_loc_descr_ref
4670 new_loc_descr (enum dwarf_location_atom op
, unsigned HOST_WIDE_INT oprnd1
,
4671 unsigned HOST_WIDE_INT oprnd2
)
4673 dw_loc_descr_ref descr
= ggc_alloc_cleared_dw_loc_descr_node ();
4675 descr
->dw_loc_opc
= op
;
4676 descr
->dw_loc_oprnd1
.val_class
= dw_val_class_unsigned_const
;
4677 descr
->dw_loc_oprnd1
.v
.val_unsigned
= oprnd1
;
4678 descr
->dw_loc_oprnd2
.val_class
= dw_val_class_unsigned_const
;
4679 descr
->dw_loc_oprnd2
.v
.val_unsigned
= oprnd2
;
4684 /* Return a pointer to a newly allocated location description for
4687 static inline dw_loc_descr_ref
4688 new_reg_loc_descr (unsigned int reg
, unsigned HOST_WIDE_INT offset
)
4691 return new_loc_descr ((enum dwarf_location_atom
) (DW_OP_breg0
+ reg
),
4694 return new_loc_descr (DW_OP_bregx
, reg
, offset
);
4697 /* Add a location description term to a location description expression. */
4700 add_loc_descr (dw_loc_descr_ref
*list_head
, dw_loc_descr_ref descr
)
4702 dw_loc_descr_ref
*d
;
4704 /* Find the end of the chain. */
4705 for (d
= list_head
; (*d
) != NULL
; d
= &(*d
)->dw_loc_next
)
4711 /* Add a constant OFFSET to a location expression. */
4714 loc_descr_plus_const (dw_loc_descr_ref
*list_head
, HOST_WIDE_INT offset
)
4716 dw_loc_descr_ref loc
;
4719 gcc_assert (*list_head
!= NULL
);
4724 /* Find the end of the chain. */
4725 for (loc
= *list_head
; loc
->dw_loc_next
!= NULL
; loc
= loc
->dw_loc_next
)
4729 if (loc
->dw_loc_opc
== DW_OP_fbreg
4730 || (loc
->dw_loc_opc
>= DW_OP_breg0
&& loc
->dw_loc_opc
<= DW_OP_breg31
))
4731 p
= &loc
->dw_loc_oprnd1
.v
.val_int
;
4732 else if (loc
->dw_loc_opc
== DW_OP_bregx
)
4733 p
= &loc
->dw_loc_oprnd2
.v
.val_int
;
4735 /* If the last operation is fbreg, breg{0..31,x}, optimize by adjusting its
4736 offset. Don't optimize if an signed integer overflow would happen. */
4738 && ((offset
> 0 && *p
<= INTTYPE_MAXIMUM (HOST_WIDE_INT
) - offset
)
4739 || (offset
< 0 && *p
>= INTTYPE_MINIMUM (HOST_WIDE_INT
) - offset
)))
4742 else if (offset
> 0)
4743 loc
->dw_loc_next
= new_loc_descr (DW_OP_plus_uconst
, offset
, 0);
4747 loc
->dw_loc_next
= int_loc_descriptor (-offset
);
4748 add_loc_descr (&loc
->dw_loc_next
, new_loc_descr (DW_OP_minus
, 0, 0));
4752 #ifdef DWARF2_DEBUGGING_INFO
4753 /* Add a constant OFFSET to a location list. */
4756 loc_list_plus_const (dw_loc_list_ref list_head
, HOST_WIDE_INT offset
)
4759 for (d
= list_head
; d
!= NULL
; d
= d
->dw_loc_next
)
4760 loc_descr_plus_const (&d
->expr
, offset
);
4764 /* Return the size of a location descriptor. */
4766 static unsigned long
4767 size_of_loc_descr (dw_loc_descr_ref loc
)
4769 unsigned long size
= 1;
4771 switch (loc
->dw_loc_opc
)
4774 size
+= DWARF2_ADDR_SIZE
;
4793 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
4796 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
4801 case DW_OP_plus_uconst
:
4802 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
4840 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
4843 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
4846 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
4849 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
4850 size
+= size_of_sleb128 (loc
->dw_loc_oprnd2
.v
.val_int
);
4853 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
4855 case DW_OP_bit_piece
:
4856 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
4857 size
+= size_of_uleb128 (loc
->dw_loc_oprnd2
.v
.val_unsigned
);
4859 case DW_OP_deref_size
:
4860 case DW_OP_xderef_size
:
4869 case DW_OP_call_ref
:
4870 size
+= DWARF2_ADDR_SIZE
;
4872 case DW_OP_implicit_value
:
4873 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
)
4874 + loc
->dw_loc_oprnd1
.v
.val_unsigned
;
4883 /* Return the size of a series of location descriptors. */
4885 static unsigned long
4886 size_of_locs (dw_loc_descr_ref loc
)
4891 /* If there are no skip or bra opcodes, don't fill in the dw_loc_addr
4892 field, to avoid writing to a PCH file. */
4893 for (size
= 0, l
= loc
; l
!= NULL
; l
= l
->dw_loc_next
)
4895 if (l
->dw_loc_opc
== DW_OP_skip
|| l
->dw_loc_opc
== DW_OP_bra
)
4897 size
+= size_of_loc_descr (l
);
4902 for (size
= 0, l
= loc
; l
!= NULL
; l
= l
->dw_loc_next
)
4904 l
->dw_loc_addr
= size
;
4905 size
+= size_of_loc_descr (l
);
4911 #ifdef DWARF2_DEBUGGING_INFO
4912 static HOST_WIDE_INT
extract_int (const unsigned char *, unsigned);
4915 /* Output location description stack opcode's operands (if any). */
4918 output_loc_operands (dw_loc_descr_ref loc
)
4920 dw_val_ref val1
= &loc
->dw_loc_oprnd1
;
4921 dw_val_ref val2
= &loc
->dw_loc_oprnd2
;
4923 switch (loc
->dw_loc_opc
)
4925 #ifdef DWARF2_DEBUGGING_INFO
4928 dw2_asm_output_data (2, val1
->v
.val_int
, NULL
);
4932 dw2_asm_output_data (4, val1
->v
.val_int
, NULL
);
4936 gcc_assert (HOST_BITS_PER_WIDE_INT
>= 64);
4937 dw2_asm_output_data (8, val1
->v
.val_int
, NULL
);
4944 gcc_assert (val1
->val_class
== dw_val_class_loc
);
4945 offset
= val1
->v
.val_loc
->dw_loc_addr
- (loc
->dw_loc_addr
+ 3);
4947 dw2_asm_output_data (2, offset
, NULL
);
4950 case DW_OP_implicit_value
:
4951 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
4952 switch (val2
->val_class
)
4954 case dw_val_class_const
:
4955 dw2_asm_output_data (val1
->v
.val_unsigned
, val2
->v
.val_int
, NULL
);
4957 case dw_val_class_vec
:
4959 unsigned int elt_size
= val2
->v
.val_vec
.elt_size
;
4960 unsigned int len
= val2
->v
.val_vec
.length
;
4964 if (elt_size
> sizeof (HOST_WIDE_INT
))
4969 for (i
= 0, p
= val2
->v
.val_vec
.array
;
4972 dw2_asm_output_data (elt_size
, extract_int (p
, elt_size
),
4973 "fp or vector constant word %u", i
);
4976 case dw_val_class_const_double
:
4978 unsigned HOST_WIDE_INT first
, second
;
4980 if (WORDS_BIG_ENDIAN
)
4982 first
= val2
->v
.val_double
.high
;
4983 second
= val2
->v
.val_double
.low
;
4987 first
= val2
->v
.val_double
.low
;
4988 second
= val2
->v
.val_double
.high
;
4990 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
4992 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
4996 case dw_val_class_addr
:
4997 gcc_assert (val1
->v
.val_unsigned
== DWARF2_ADDR_SIZE
);
4998 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, val2
->v
.val_addr
, NULL
);
5013 case DW_OP_implicit_value
:
5014 /* We currently don't make any attempt to make sure these are
5015 aligned properly like we do for the main unwind info, so
5016 don't support emitting things larger than a byte if we're
5017 only doing unwinding. */
5022 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
5025 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
5028 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
5031 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
5033 case DW_OP_plus_uconst
:
5034 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
5068 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
5071 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
5074 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
5077 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
5078 dw2_asm_output_data_sleb128 (val2
->v
.val_int
, NULL
);
5081 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
5083 case DW_OP_bit_piece
:
5084 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
5085 dw2_asm_output_data_uleb128 (val2
->v
.val_unsigned
, NULL
);
5087 case DW_OP_deref_size
:
5088 case DW_OP_xderef_size
:
5089 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
5095 if (targetm
.asm_out
.output_dwarf_dtprel
)
5097 targetm
.asm_out
.output_dwarf_dtprel (asm_out_file
,
5100 fputc ('\n', asm_out_file
);
5107 #ifdef DWARF2_DEBUGGING_INFO
5108 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, val1
->v
.val_addr
, NULL
);
5116 /* Other codes have no operands. */
5121 /* Output a sequence of location operations. */
5124 output_loc_sequence (dw_loc_descr_ref loc
)
5126 for (; loc
!= NULL
; loc
= loc
->dw_loc_next
)
5128 /* Output the opcode. */
5129 dw2_asm_output_data (1, loc
->dw_loc_opc
,
5130 "%s", dwarf_stack_op_name (loc
->dw_loc_opc
));
5132 /* Output the operand(s) (if any). */
5133 output_loc_operands (loc
);
5137 /* Output location description stack opcode's operands (if any).
5138 The output is single bytes on a line, suitable for .cfi_escape. */
5141 output_loc_operands_raw (dw_loc_descr_ref loc
)
5143 dw_val_ref val1
= &loc
->dw_loc_oprnd1
;
5144 dw_val_ref val2
= &loc
->dw_loc_oprnd2
;
5146 switch (loc
->dw_loc_opc
)
5149 case DW_OP_implicit_value
:
5150 /* We cannot output addresses in .cfi_escape, only bytes. */
5156 case DW_OP_deref_size
:
5157 case DW_OP_xderef_size
:
5158 fputc (',', asm_out_file
);
5159 dw2_asm_output_data_raw (1, val1
->v
.val_int
);
5164 fputc (',', asm_out_file
);
5165 dw2_asm_output_data_raw (2, val1
->v
.val_int
);
5170 fputc (',', asm_out_file
);
5171 dw2_asm_output_data_raw (4, val1
->v
.val_int
);
5176 gcc_assert (HOST_BITS_PER_WIDE_INT
>= 64);
5177 fputc (',', asm_out_file
);
5178 dw2_asm_output_data_raw (8, val1
->v
.val_int
);
5186 gcc_assert (val1
->val_class
== dw_val_class_loc
);
5187 offset
= val1
->v
.val_loc
->dw_loc_addr
- (loc
->dw_loc_addr
+ 3);
5189 fputc (',', asm_out_file
);
5190 dw2_asm_output_data_raw (2, offset
);
5195 case DW_OP_plus_uconst
:
5198 fputc (',', asm_out_file
);
5199 dw2_asm_output_data_uleb128_raw (val1
->v
.val_unsigned
);
5202 case DW_OP_bit_piece
:
5203 fputc (',', asm_out_file
);
5204 dw2_asm_output_data_uleb128_raw (val1
->v
.val_unsigned
);
5205 dw2_asm_output_data_uleb128_raw (val2
->v
.val_unsigned
);
5242 fputc (',', asm_out_file
);
5243 dw2_asm_output_data_sleb128_raw (val1
->v
.val_int
);
5247 fputc (',', asm_out_file
);
5248 dw2_asm_output_data_uleb128_raw (val1
->v
.val_unsigned
);
5249 fputc (',', asm_out_file
);
5250 dw2_asm_output_data_sleb128_raw (val2
->v
.val_int
);
5254 /* Other codes have no operands. */
5260 output_loc_sequence_raw (dw_loc_descr_ref loc
)
5264 /* Output the opcode. */
5265 fprintf (asm_out_file
, "%#x", loc
->dw_loc_opc
);
5266 output_loc_operands_raw (loc
);
5268 if (!loc
->dw_loc_next
)
5270 loc
= loc
->dw_loc_next
;
5272 fputc (',', asm_out_file
);
5276 /* This routine will generate the correct assembly data for a location
5277 description based on a cfi entry with a complex address. */
5280 output_cfa_loc (dw_cfi_ref cfi
)
5282 dw_loc_descr_ref loc
;
5285 if (cfi
->dw_cfi_opc
== DW_CFA_expression
)
5287 dw2_asm_output_data (1, cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
, NULL
);
5288 loc
= cfi
->dw_cfi_oprnd2
.dw_cfi_loc
;
5291 loc
= cfi
->dw_cfi_oprnd1
.dw_cfi_loc
;
5293 /* Output the size of the block. */
5294 size
= size_of_locs (loc
);
5295 dw2_asm_output_data_uleb128 (size
, NULL
);
5297 /* Now output the operations themselves. */
5298 output_loc_sequence (loc
);
5301 /* Similar, but used for .cfi_escape. */
5304 output_cfa_loc_raw (dw_cfi_ref cfi
)
5306 dw_loc_descr_ref loc
;
5309 if (cfi
->dw_cfi_opc
== DW_CFA_expression
)
5311 fprintf (asm_out_file
, "%#x,", cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
);
5312 loc
= cfi
->dw_cfi_oprnd2
.dw_cfi_loc
;
5315 loc
= cfi
->dw_cfi_oprnd1
.dw_cfi_loc
;
5317 /* Output the size of the block. */
5318 size
= size_of_locs (loc
);
5319 dw2_asm_output_data_uleb128_raw (size
);
5320 fputc (',', asm_out_file
);
5322 /* Now output the operations themselves. */
5323 output_loc_sequence_raw (loc
);
5326 /* This function builds a dwarf location descriptor sequence from a
5327 dw_cfa_location, adding the given OFFSET to the result of the
5330 static struct dw_loc_descr_struct
*
5331 build_cfa_loc (dw_cfa_location
*cfa
, HOST_WIDE_INT offset
)
5333 struct dw_loc_descr_struct
*head
, *tmp
;
5335 offset
+= cfa
->offset
;
5339 head
= new_reg_loc_descr (cfa
->reg
, cfa
->base_offset
);
5340 head
->dw_loc_oprnd1
.val_class
= dw_val_class_const
;
5341 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
5342 add_loc_descr (&head
, tmp
);
5345 tmp
= new_loc_descr (DW_OP_plus_uconst
, offset
, 0);
5346 add_loc_descr (&head
, tmp
);
5350 head
= new_reg_loc_descr (cfa
->reg
, offset
);
5355 /* This function builds a dwarf location descriptor sequence for
5356 the address at OFFSET from the CFA when stack is aligned to
5359 static struct dw_loc_descr_struct
*
5360 build_cfa_aligned_loc (HOST_WIDE_INT offset
, HOST_WIDE_INT alignment
)
5362 struct dw_loc_descr_struct
*head
;
5363 unsigned int dwarf_fp
5364 = DWARF_FRAME_REGNUM (HARD_FRAME_POINTER_REGNUM
);
5366 /* When CFA is defined as FP+OFFSET, emulate stack alignment. */
5367 if (cfa
.reg
== HARD_FRAME_POINTER_REGNUM
&& cfa
.indirect
== 0)
5369 head
= new_reg_loc_descr (dwarf_fp
, 0);
5370 add_loc_descr (&head
, int_loc_descriptor (alignment
));
5371 add_loc_descr (&head
, new_loc_descr (DW_OP_and
, 0, 0));
5372 loc_descr_plus_const (&head
, offset
);
5375 head
= new_reg_loc_descr (dwarf_fp
, offset
);
5379 /* This function fills in aa dw_cfa_location structure from a dwarf location
5380 descriptor sequence. */
5383 get_cfa_from_loc_descr (dw_cfa_location
*cfa
, struct dw_loc_descr_struct
*loc
)
5385 struct dw_loc_descr_struct
*ptr
;
5387 cfa
->base_offset
= 0;
5391 for (ptr
= loc
; ptr
!= NULL
; ptr
= ptr
->dw_loc_next
)
5393 enum dwarf_location_atom op
= ptr
->dw_loc_opc
;
5429 cfa
->reg
= op
- DW_OP_reg0
;
5432 cfa
->reg
= ptr
->dw_loc_oprnd1
.v
.val_int
;
5466 cfa
->reg
= op
- DW_OP_breg0
;
5467 cfa
->base_offset
= ptr
->dw_loc_oprnd1
.v
.val_int
;
5470 cfa
->reg
= ptr
->dw_loc_oprnd1
.v
.val_int
;
5471 cfa
->base_offset
= ptr
->dw_loc_oprnd2
.v
.val_int
;
5476 case DW_OP_plus_uconst
:
5477 cfa
->offset
= ptr
->dw_loc_oprnd1
.v
.val_unsigned
;
5480 internal_error ("DW_LOC_OP %s not implemented",
5481 dwarf_stack_op_name (ptr
->dw_loc_opc
));
5485 #endif /* .debug_frame support */
5487 /* And now, the support for symbolic debugging information. */
5488 #ifdef DWARF2_DEBUGGING_INFO
5490 /* .debug_str support. */
5491 static int output_indirect_string (void **, void *);
5493 static void dwarf2out_init (const char *);
5494 static void dwarf2out_finish (const char *);
5495 static void dwarf2out_assembly_start (void);
5496 static void dwarf2out_define (unsigned int, const char *);
5497 static void dwarf2out_undef (unsigned int, const char *);
5498 static void dwarf2out_start_source_file (unsigned, const char *);
5499 static void dwarf2out_end_source_file (unsigned);
5500 static void dwarf2out_function_decl (tree
);
5501 static void dwarf2out_begin_block (unsigned, unsigned);
5502 static void dwarf2out_end_block (unsigned, unsigned);
5503 static bool dwarf2out_ignore_block (const_tree
);
5504 static void dwarf2out_global_decl (tree
);
5505 static void dwarf2out_type_decl (tree
, int);
5506 static void dwarf2out_imported_module_or_decl (tree
, tree
, tree
, bool);
5507 static void dwarf2out_imported_module_or_decl_1 (tree
, tree
, tree
,
5509 static void dwarf2out_abstract_function (tree
);
5510 static void dwarf2out_var_location (rtx
);
5511 static void dwarf2out_direct_call (tree
);
5512 static void dwarf2out_virtual_call_token (tree
, int);
5513 static void dwarf2out_copy_call_info (rtx
, rtx
);
5514 static void dwarf2out_virtual_call (int);
5515 static void dwarf2out_begin_function (tree
);
5516 static void dwarf2out_set_name (tree
, tree
);
5518 /* The debug hooks structure. */
5520 const struct gcc_debug_hooks dwarf2_debug_hooks
=
5524 dwarf2out_assembly_start
,
5527 dwarf2out_start_source_file
,
5528 dwarf2out_end_source_file
,
5529 dwarf2out_begin_block
,
5530 dwarf2out_end_block
,
5531 dwarf2out_ignore_block
,
5532 dwarf2out_source_line
,
5533 dwarf2out_begin_prologue
,
5534 #if VMS_DEBUGGING_INFO
5535 dwarf2out_vms_end_prologue
,
5536 dwarf2out_vms_begin_epilogue
,
5538 debug_nothing_int_charstar
,
5539 debug_nothing_int_charstar
,
5541 dwarf2out_end_epilogue
,
5542 dwarf2out_begin_function
,
5543 debug_nothing_int
, /* end_function */
5544 dwarf2out_function_decl
, /* function_decl */
5545 dwarf2out_global_decl
,
5546 dwarf2out_type_decl
, /* type_decl */
5547 dwarf2out_imported_module_or_decl
,
5548 debug_nothing_tree
, /* deferred_inline_function */
5549 /* The DWARF 2 backend tries to reduce debugging bloat by not
5550 emitting the abstract description of inline functions until
5551 something tries to reference them. */
5552 dwarf2out_abstract_function
, /* outlining_inline_function */
5553 debug_nothing_rtx
, /* label */
5554 debug_nothing_int
, /* handle_pch */
5555 dwarf2out_var_location
,
5556 dwarf2out_switch_text_section
,
5557 dwarf2out_direct_call
,
5558 dwarf2out_virtual_call_token
,
5559 dwarf2out_copy_call_info
,
5560 dwarf2out_virtual_call
,
5562 1 /* start_end_main_source_file */
5566 /* NOTE: In the comments in this file, many references are made to
5567 "Debugging Information Entries". This term is abbreviated as `DIE'
5568 throughout the remainder of this file. */
5570 /* An internal representation of the DWARF output is built, and then
5571 walked to generate the DWARF debugging info. The walk of the internal
5572 representation is done after the entire program has been compiled.
5573 The types below are used to describe the internal representation. */
5575 /* Various DIE's use offsets relative to the beginning of the
5576 .debug_info section to refer to each other. */
5578 typedef long int dw_offset
;
5580 /* Define typedefs here to avoid circular dependencies. */
5582 typedef struct dw_attr_struct
*dw_attr_ref
;
5583 typedef struct dw_line_info_struct
*dw_line_info_ref
;
5584 typedef struct dw_separate_line_info_struct
*dw_separate_line_info_ref
;
5585 typedef struct pubname_struct
*pubname_ref
;
5586 typedef struct dw_ranges_struct
*dw_ranges_ref
;
5587 typedef struct dw_ranges_by_label_struct
*dw_ranges_by_label_ref
;
5588 typedef struct comdat_type_struct
*comdat_type_node_ref
;
5590 /* Each entry in the line_info_table maintains the file and
5591 line number associated with the label generated for that
5592 entry. The label gives the PC value associated with
5593 the line number entry. */
5595 typedef struct GTY(()) dw_line_info_struct
{
5596 unsigned long dw_file_num
;
5597 unsigned long dw_line_num
;
5601 /* Line information for functions in separate sections; each one gets its
5603 typedef struct GTY(()) dw_separate_line_info_struct
{
5604 unsigned long dw_file_num
;
5605 unsigned long dw_line_num
;
5606 unsigned long function
;
5608 dw_separate_line_info_entry
;
5610 /* Each DIE attribute has a field specifying the attribute kind,
5611 a link to the next attribute in the chain, and an attribute value.
5612 Attributes are typically linked below the DIE they modify. */
5614 typedef struct GTY(()) dw_attr_struct
{
5615 enum dwarf_attribute dw_attr
;
5616 dw_val_node dw_attr_val
;
5620 DEF_VEC_O(dw_attr_node
);
5621 DEF_VEC_ALLOC_O(dw_attr_node
,gc
);
5623 /* The Debugging Information Entry (DIE) structure. DIEs form a tree.
5624 The children of each node form a circular list linked by
5625 die_sib. die_child points to the node *before* the "first" child node. */
5627 typedef struct GTY((chain_circular ("%h.die_sib"))) die_struct
{
5628 enum dwarf_tag die_tag
;
5629 union die_symbol_or_type_node
5631 char * GTY ((tag ("0"))) die_symbol
;
5632 comdat_type_node_ref
GTY ((tag ("1"))) die_type_node
;
5634 GTY ((desc ("dwarf_version >= 4"))) die_id
;
5635 VEC(dw_attr_node
,gc
) * die_attr
;
5636 dw_die_ref die_parent
;
5637 dw_die_ref die_child
;
5639 dw_die_ref die_definition
; /* ref from a specification to its definition */
5640 dw_offset die_offset
;
5641 unsigned long die_abbrev
;
5643 /* Die is used and must not be pruned as unused. */
5644 int die_perennial_p
;
5645 unsigned int decl_id
;
5649 /* Evaluate 'expr' while 'c' is set to each child of DIE in order. */
5650 #define FOR_EACH_CHILD(die, c, expr) do { \
5651 c = die->die_child; \
5655 } while (c != die->die_child); \
5658 /* The pubname structure */
5660 typedef struct GTY(()) pubname_struct
{
5666 DEF_VEC_O(pubname_entry
);
5667 DEF_VEC_ALLOC_O(pubname_entry
, gc
);
5669 struct GTY(()) dw_ranges_struct
{
5670 /* If this is positive, it's a block number, otherwise it's a
5671 bitwise-negated index into dw_ranges_by_label. */
5675 struct GTY(()) dw_ranges_by_label_struct
{
5680 /* The comdat type node structure. */
5681 typedef struct GTY(()) comdat_type_struct
5683 dw_die_ref root_die
;
5684 dw_die_ref type_die
;
5685 char signature
[DWARF_TYPE_SIGNATURE_SIZE
];
5686 struct comdat_type_struct
*next
;
5690 /* The limbo die list structure. */
5691 typedef struct GTY(()) limbo_die_struct
{
5694 struct limbo_die_struct
*next
;
5698 typedef struct GTY(()) skeleton_chain_struct
5702 struct skeleton_chain_struct
*parent
;
5704 skeleton_chain_node
;
5706 /* How to start an assembler comment. */
5707 #ifndef ASM_COMMENT_START
5708 #define ASM_COMMENT_START ";#"
5711 /* Define a macro which returns nonzero for a TYPE_DECL which was
5712 implicitly generated for a tagged type.
5714 Note that unlike the gcc front end (which generates a NULL named
5715 TYPE_DECL node for each complete tagged type, each array type, and
5716 each function type node created) the g++ front end generates a
5717 _named_ TYPE_DECL node for each tagged type node created.
5718 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
5719 generate a DW_TAG_typedef DIE for them. */
5721 #define TYPE_DECL_IS_STUB(decl) \
5722 (DECL_NAME (decl) == NULL_TREE \
5723 || (DECL_ARTIFICIAL (decl) \
5724 && is_tagged_type (TREE_TYPE (decl)) \
5725 && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \
5726 /* This is necessary for stub decls that \
5727 appear in nested inline functions. */ \
5728 || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
5729 && (decl_ultimate_origin (decl) \
5730 == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
5732 /* Information concerning the compilation unit's programming
5733 language, and compiler version. */
5735 /* Fixed size portion of the DWARF compilation unit header. */
5736 #define DWARF_COMPILE_UNIT_HEADER_SIZE \
5737 (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 3)
5739 /* Fixed size portion of the DWARF comdat type unit header. */
5740 #define DWARF_COMDAT_TYPE_UNIT_HEADER_SIZE \
5741 (DWARF_COMPILE_UNIT_HEADER_SIZE + DWARF_TYPE_SIGNATURE_SIZE \
5742 + DWARF_OFFSET_SIZE)
5744 /* Fixed size portion of public names info. */
5745 #define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
5747 /* Fixed size portion of the address range info. */
5748 #define DWARF_ARANGES_HEADER_SIZE \
5749 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
5750 DWARF2_ADDR_SIZE * 2) \
5751 - DWARF_INITIAL_LENGTH_SIZE)
5753 /* Size of padding portion in the address range info. It must be
5754 aligned to twice the pointer size. */
5755 #define DWARF_ARANGES_PAD_SIZE \
5756 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
5757 DWARF2_ADDR_SIZE * 2) \
5758 - (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4))
5760 /* Use assembler line directives if available. */
5761 #ifndef DWARF2_ASM_LINE_DEBUG_INFO
5762 #ifdef HAVE_AS_DWARF2_DEBUG_LINE
5763 #define DWARF2_ASM_LINE_DEBUG_INFO 1
5765 #define DWARF2_ASM_LINE_DEBUG_INFO 0
5769 /* Minimum line offset in a special line info. opcode.
5770 This value was chosen to give a reasonable range of values. */
5771 #define DWARF_LINE_BASE -10
5773 /* First special line opcode - leave room for the standard opcodes. */
5774 #define DWARF_LINE_OPCODE_BASE 10
5776 /* Range of line offsets in a special line info. opcode. */
5777 #define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1)
5779 /* Flag that indicates the initial value of the is_stmt_start flag.
5780 In the present implementation, we do not mark any lines as
5781 the beginning of a source statement, because that information
5782 is not made available by the GCC front-end. */
5783 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
5785 /* Maximum number of operations per instruction bundle. */
5786 #ifndef DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN
5787 #define DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN 1
5790 #ifdef DWARF2_DEBUGGING_INFO
5791 /* This location is used by calc_die_sizes() to keep track
5792 the offset of each DIE within the .debug_info section. */
5793 static unsigned long next_die_offset
;
5796 /* Record the root of the DIE's built for the current compilation unit. */
5797 static GTY(()) dw_die_ref comp_unit_die
;
5799 /* A list of type DIEs that have been separated into comdat sections. */
5800 static GTY(()) comdat_type_node
*comdat_type_list
;
5802 /* A list of DIEs with a NULL parent waiting to be relocated. */
5803 static GTY(()) limbo_die_node
*limbo_die_list
;
5805 /* A list of DIEs for which we may have to generate
5806 DW_AT_{,MIPS_}linkage_name once their DECL_ASSEMBLER_NAMEs are set. */
5807 static GTY(()) limbo_die_node
*deferred_asm_name
;
5809 /* Filenames referenced by this compilation unit. */
5810 static GTY((param_is (struct dwarf_file_data
))) htab_t file_table
;
5812 /* A hash table of references to DIE's that describe declarations.
5813 The key is a DECL_UID() which is a unique number identifying each decl. */
5814 static GTY ((param_is (struct die_struct
))) htab_t decl_die_table
;
5816 /* A hash table of references to DIE's that describe COMMON blocks.
5817 The key is DECL_UID() ^ die_parent. */
5818 static GTY ((param_is (struct die_struct
))) htab_t common_block_die_table
;
5820 typedef struct GTY(()) die_arg_entry_struct
{
5825 DEF_VEC_O(die_arg_entry
);
5826 DEF_VEC_ALLOC_O(die_arg_entry
,gc
);
5828 /* Node of the variable location list. */
5829 struct GTY ((chain_next ("%h.next"))) var_loc_node
{
5830 /* Either NOTE_INSN_VAR_LOCATION, or, for SRA optimized variables,
5831 EXPR_LIST chain. For small bitsizes, bitsize is encoded
5832 in mode of the EXPR_LIST node and first EXPR_LIST operand
5833 is either NOTE_INSN_VAR_LOCATION for a piece with a known
5834 location or NULL for padding. For larger bitsizes,
5835 mode is 0 and first operand is a CONCAT with bitsize
5836 as first CONCAT operand and NOTE_INSN_VAR_LOCATION resp.
5837 NULL as second operand. */
5839 const char * GTY (()) label
;
5840 struct var_loc_node
* GTY (()) next
;
5843 /* Variable location list. */
5844 struct GTY (()) var_loc_list_def
{
5845 struct var_loc_node
* GTY (()) first
;
5847 /* Pointer to the last but one or last element of the
5848 chained list. If the list is empty, both first and
5849 last are NULL, if the list contains just one node
5850 or the last node certainly is not redundant, it points
5851 to the last node, otherwise points to the last but one.
5852 Do not mark it for GC because it is marked through the chain. */
5853 struct var_loc_node
* GTY ((skip ("%h"))) last
;
5855 /* DECL_UID of the variable decl. */
5856 unsigned int decl_id
;
5858 typedef struct var_loc_list_def var_loc_list
;
5861 /* Table of decl location linked lists. */
5862 static GTY ((param_is (var_loc_list
))) htab_t decl_loc_table
;
5864 /* A pointer to the base of a list of references to DIE's that
5865 are uniquely identified by their tag, presence/absence of
5866 children DIE's, and list of attribute/value pairs. */
5867 static GTY((length ("abbrev_die_table_allocated")))
5868 dw_die_ref
*abbrev_die_table
;
5870 /* Number of elements currently allocated for abbrev_die_table. */
5871 static GTY(()) unsigned abbrev_die_table_allocated
;
5873 /* Number of elements in type_die_table currently in use. */
5874 static GTY(()) unsigned abbrev_die_table_in_use
;
5876 /* Size (in elements) of increments by which we may expand the
5877 abbrev_die_table. */
5878 #define ABBREV_DIE_TABLE_INCREMENT 256
5880 /* A pointer to the base of a table that contains line information
5881 for each source code line in .text in the compilation unit. */
5882 static GTY((length ("line_info_table_allocated")))
5883 dw_line_info_ref line_info_table
;
5885 /* Number of elements currently allocated for line_info_table. */
5886 static GTY(()) unsigned line_info_table_allocated
;
5888 /* Number of elements in line_info_table currently in use. */
5889 static GTY(()) unsigned line_info_table_in_use
;
5891 /* A pointer to the base of a table that contains line information
5892 for each source code line outside of .text in the compilation unit. */
5893 static GTY ((length ("separate_line_info_table_allocated")))
5894 dw_separate_line_info_ref separate_line_info_table
;
5896 /* Number of elements currently allocated for separate_line_info_table. */
5897 static GTY(()) unsigned separate_line_info_table_allocated
;
5899 /* Number of elements in separate_line_info_table currently in use. */
5900 static GTY(()) unsigned separate_line_info_table_in_use
;
5902 /* Size (in elements) of increments by which we may expand the
5904 #define LINE_INFO_TABLE_INCREMENT 1024
5906 /* A pointer to the base of a table that contains a list of publicly
5907 accessible names. */
5908 static GTY (()) VEC (pubname_entry
, gc
) * pubname_table
;
5910 /* A pointer to the base of a table that contains a list of publicly
5911 accessible types. */
5912 static GTY (()) VEC (pubname_entry
, gc
) * pubtype_table
;
5914 /* Array of dies for which we should generate .debug_arange info. */
5915 static GTY((length ("arange_table_allocated"))) dw_die_ref
*arange_table
;
5917 /* Number of elements currently allocated for arange_table. */
5918 static GTY(()) unsigned arange_table_allocated
;
5920 /* Number of elements in arange_table currently in use. */
5921 static GTY(()) unsigned arange_table_in_use
;
5923 /* Size (in elements) of increments by which we may expand the
5925 #define ARANGE_TABLE_INCREMENT 64
5927 /* Array of dies for which we should generate .debug_ranges info. */
5928 static GTY ((length ("ranges_table_allocated"))) dw_ranges_ref ranges_table
;
5930 /* Number of elements currently allocated for ranges_table. */
5931 static GTY(()) unsigned ranges_table_allocated
;
5933 /* Number of elements in ranges_table currently in use. */
5934 static GTY(()) unsigned ranges_table_in_use
;
5936 /* Array of pairs of labels referenced in ranges_table. */
5937 static GTY ((length ("ranges_by_label_allocated")))
5938 dw_ranges_by_label_ref ranges_by_label
;
5940 /* Number of elements currently allocated for ranges_by_label. */
5941 static GTY(()) unsigned ranges_by_label_allocated
;
5943 /* Number of elements in ranges_by_label currently in use. */
5944 static GTY(()) unsigned ranges_by_label_in_use
;
5946 /* Size (in elements) of increments by which we may expand the
5948 #define RANGES_TABLE_INCREMENT 64
5950 /* Whether we have location lists that need outputting */
5951 static GTY(()) bool have_location_lists
;
5953 /* Unique label counter. */
5954 static GTY(()) unsigned int loclabel_num
;
5956 /* Unique label counter for point-of-call tables. */
5957 static GTY(()) unsigned int poc_label_num
;
5959 /* The direct call table structure. */
5961 typedef struct GTY(()) dcall_struct
{
5962 unsigned int poc_label_num
;
5964 dw_die_ref targ_die
;
5968 DEF_VEC_O(dcall_entry
);
5969 DEF_VEC_ALLOC_O(dcall_entry
, gc
);
5971 /* The virtual call table structure. */
5973 typedef struct GTY(()) vcall_struct
{
5974 unsigned int poc_label_num
;
5975 unsigned int vtable_slot
;
5979 DEF_VEC_O(vcall_entry
);
5980 DEF_VEC_ALLOC_O(vcall_entry
, gc
);
5982 /* Pointers to the direct and virtual call tables. */
5983 static GTY (()) VEC (dcall_entry
, gc
) * dcall_table
= NULL
;
5984 static GTY (()) VEC (vcall_entry
, gc
) * vcall_table
= NULL
;
5986 /* A hash table to map INSN_UIDs to vtable slot indexes. */
5988 struct GTY (()) vcall_insn
{
5990 unsigned int vtable_slot
;
5993 static GTY ((param_is (struct vcall_insn
))) htab_t vcall_insn_table
;
5995 #ifdef DWARF2_DEBUGGING_INFO
5996 /* Record whether the function being analyzed contains inlined functions. */
5997 static int current_function_has_inlines
;
5999 #if 0 && defined (MIPS_DEBUGGING_INFO)
6000 static int comp_unit_has_inlines
;
6003 /* The last file entry emitted by maybe_emit_file(). */
6004 static GTY(()) struct dwarf_file_data
* last_emitted_file
;
6006 /* Number of internal labels generated by gen_internal_sym(). */
6007 static GTY(()) int label_num
;
6009 /* Cached result of previous call to lookup_filename. */
6010 static GTY(()) struct dwarf_file_data
* file_table_last_lookup
;
6012 static GTY(()) VEC(die_arg_entry
,gc
) *tmpl_value_parm_die_table
;
6014 #ifdef DWARF2_DEBUGGING_INFO
6016 /* Offset from the "steady-state frame pointer" to the frame base,
6017 within the current function. */
6018 static HOST_WIDE_INT frame_pointer_fb_offset
;
6020 /* Forward declarations for functions defined in this file. */
6022 static int is_pseudo_reg (const_rtx
);
6023 static tree
type_main_variant (tree
);
6024 static int is_tagged_type (const_tree
);
6025 static const char *dwarf_tag_name (unsigned);
6026 static const char *dwarf_attr_name (unsigned);
6027 static const char *dwarf_form_name (unsigned);
6028 static tree
decl_ultimate_origin (const_tree
);
6029 static tree
decl_class_context (tree
);
6030 static void add_dwarf_attr (dw_die_ref
, dw_attr_ref
);
6031 static inline enum dw_val_class
AT_class (dw_attr_ref
);
6032 static void add_AT_flag (dw_die_ref
, enum dwarf_attribute
, unsigned);
6033 static inline unsigned AT_flag (dw_attr_ref
);
6034 static void add_AT_int (dw_die_ref
, enum dwarf_attribute
, HOST_WIDE_INT
);
6035 static inline HOST_WIDE_INT
AT_int (dw_attr_ref
);
6036 static void add_AT_unsigned (dw_die_ref
, enum dwarf_attribute
, unsigned HOST_WIDE_INT
);
6037 static inline unsigned HOST_WIDE_INT
AT_unsigned (dw_attr_ref
);
6038 static void add_AT_double (dw_die_ref
, enum dwarf_attribute
,
6039 HOST_WIDE_INT
, unsigned HOST_WIDE_INT
);
6040 static inline void add_AT_vec (dw_die_ref
, enum dwarf_attribute
, unsigned int,
6041 unsigned int, unsigned char *);
6042 static void add_AT_data8 (dw_die_ref
, enum dwarf_attribute
, unsigned char *);
6043 static hashval_t
debug_str_do_hash (const void *);
6044 static int debug_str_eq (const void *, const void *);
6045 static void add_AT_string (dw_die_ref
, enum dwarf_attribute
, const char *);
6046 static inline const char *AT_string (dw_attr_ref
);
6047 static enum dwarf_form
AT_string_form (dw_attr_ref
);
6048 static void add_AT_die_ref (dw_die_ref
, enum dwarf_attribute
, dw_die_ref
);
6049 static void add_AT_specification (dw_die_ref
, dw_die_ref
);
6050 static inline dw_die_ref
AT_ref (dw_attr_ref
);
6051 static inline int AT_ref_external (dw_attr_ref
);
6052 static inline void set_AT_ref_external (dw_attr_ref
, int);
6053 static void add_AT_fde_ref (dw_die_ref
, enum dwarf_attribute
, unsigned);
6054 static void add_AT_loc (dw_die_ref
, enum dwarf_attribute
, dw_loc_descr_ref
);
6055 static inline dw_loc_descr_ref
AT_loc (dw_attr_ref
);
6056 static void add_AT_loc_list (dw_die_ref
, enum dwarf_attribute
,
6058 static inline dw_loc_list_ref
AT_loc_list (dw_attr_ref
);
6059 static void add_AT_addr (dw_die_ref
, enum dwarf_attribute
, rtx
);
6060 static inline rtx
AT_addr (dw_attr_ref
);
6061 static void add_AT_lbl_id (dw_die_ref
, enum dwarf_attribute
, const char *);
6062 static void add_AT_lineptr (dw_die_ref
, enum dwarf_attribute
, const char *);
6063 static void add_AT_macptr (dw_die_ref
, enum dwarf_attribute
, const char *);
6064 static void add_AT_offset (dw_die_ref
, enum dwarf_attribute
,
6065 unsigned HOST_WIDE_INT
);
6066 static void add_AT_range_list (dw_die_ref
, enum dwarf_attribute
,
6068 static inline const char *AT_lbl (dw_attr_ref
);
6069 static dw_attr_ref
get_AT (dw_die_ref
, enum dwarf_attribute
);
6070 static const char *get_AT_low_pc (dw_die_ref
);
6071 static const char *get_AT_hi_pc (dw_die_ref
);
6072 static const char *get_AT_string (dw_die_ref
, enum dwarf_attribute
);
6073 static int get_AT_flag (dw_die_ref
, enum dwarf_attribute
);
6074 static unsigned get_AT_unsigned (dw_die_ref
, enum dwarf_attribute
);
6075 static inline dw_die_ref
get_AT_ref (dw_die_ref
, enum dwarf_attribute
);
6076 static bool is_cxx (void);
6077 static bool is_fortran (void);
6078 static bool is_ada (void);
6079 static void remove_AT (dw_die_ref
, enum dwarf_attribute
);
6080 static void remove_child_TAG (dw_die_ref
, enum dwarf_tag
);
6081 static void add_child_die (dw_die_ref
, dw_die_ref
);
6082 static dw_die_ref
new_die (enum dwarf_tag
, dw_die_ref
, tree
);
6083 static dw_die_ref
lookup_type_die (tree
);
6084 static void equate_type_number_to_die (tree
, dw_die_ref
);
6085 static hashval_t
decl_die_table_hash (const void *);
6086 static int decl_die_table_eq (const void *, const void *);
6087 static dw_die_ref
lookup_decl_die (tree
);
6088 static hashval_t
common_block_die_table_hash (const void *);
6089 static int common_block_die_table_eq (const void *, const void *);
6090 static hashval_t
decl_loc_table_hash (const void *);
6091 static int decl_loc_table_eq (const void *, const void *);
6092 static var_loc_list
*lookup_decl_loc (const_tree
);
6093 static void equate_decl_number_to_die (tree
, dw_die_ref
);
6094 static struct var_loc_node
*add_var_loc_to_decl (tree
, rtx
, const char *);
6095 static void print_spaces (FILE *);
6096 static void print_die (dw_die_ref
, FILE *);
6097 static void print_dwarf_line_table (FILE *);
6098 static dw_die_ref
push_new_compile_unit (dw_die_ref
, dw_die_ref
);
6099 static dw_die_ref
pop_compile_unit (dw_die_ref
);
6100 static void loc_checksum (dw_loc_descr_ref
, struct md5_ctx
*);
6101 static void attr_checksum (dw_attr_ref
, struct md5_ctx
*, int *);
6102 static void die_checksum (dw_die_ref
, struct md5_ctx
*, int *);
6103 static void checksum_sleb128 (HOST_WIDE_INT
, struct md5_ctx
*);
6104 static void checksum_uleb128 (unsigned HOST_WIDE_INT
, struct md5_ctx
*);
6105 static void loc_checksum_ordered (dw_loc_descr_ref
, struct md5_ctx
*);
6106 static void attr_checksum_ordered (enum dwarf_tag
, dw_attr_ref
,
6107 struct md5_ctx
*, int *);
6108 struct checksum_attributes
;
6109 static void collect_checksum_attributes (struct checksum_attributes
*, dw_die_ref
);
6110 static void die_checksum_ordered (dw_die_ref
, struct md5_ctx
*, int *);
6111 static void checksum_die_context (dw_die_ref
, struct md5_ctx
*);
6112 static void generate_type_signature (dw_die_ref
, comdat_type_node
*);
6113 static int same_loc_p (dw_loc_descr_ref
, dw_loc_descr_ref
, int *);
6114 static int same_dw_val_p (const dw_val_node
*, const dw_val_node
*, int *);
6115 static int same_attr_p (dw_attr_ref
, dw_attr_ref
, int *);
6116 static int same_die_p (dw_die_ref
, dw_die_ref
, int *);
6117 static int same_die_p_wrap (dw_die_ref
, dw_die_ref
);
6118 static void compute_section_prefix (dw_die_ref
);
6119 static int is_type_die (dw_die_ref
);
6120 static int is_comdat_die (dw_die_ref
);
6121 static int is_symbol_die (dw_die_ref
);
6122 static void assign_symbol_names (dw_die_ref
);
6123 static void break_out_includes (dw_die_ref
);
6124 static int is_declaration_die (dw_die_ref
);
6125 static int should_move_die_to_comdat (dw_die_ref
);
6126 static dw_die_ref
clone_as_declaration (dw_die_ref
);
6127 static dw_die_ref
clone_die (dw_die_ref
);
6128 static dw_die_ref
clone_tree (dw_die_ref
);
6129 static void copy_declaration_context (dw_die_ref
, dw_die_ref
);
6130 static void generate_skeleton_ancestor_tree (skeleton_chain_node
*);
6131 static void generate_skeleton_bottom_up (skeleton_chain_node
*);
6132 static dw_die_ref
generate_skeleton (dw_die_ref
);
6133 static dw_die_ref
remove_child_or_replace_with_skeleton (dw_die_ref
,
6135 static void break_out_comdat_types (dw_die_ref
);
6136 static dw_die_ref
copy_ancestor_tree (dw_die_ref
, dw_die_ref
, htab_t
);
6137 static void copy_decls_walk (dw_die_ref
, dw_die_ref
, htab_t
);
6138 static void copy_decls_for_unworthy_types (dw_die_ref
);
6140 static hashval_t
htab_cu_hash (const void *);
6141 static int htab_cu_eq (const void *, const void *);
6142 static void htab_cu_del (void *);
6143 static int check_duplicate_cu (dw_die_ref
, htab_t
, unsigned *);
6144 static void record_comdat_symbol_number (dw_die_ref
, htab_t
, unsigned);
6145 static void add_sibling_attributes (dw_die_ref
);
6146 static void build_abbrev_table (dw_die_ref
);
6147 static void output_location_lists (dw_die_ref
);
6148 static int constant_size (unsigned HOST_WIDE_INT
);
6149 static unsigned long size_of_die (dw_die_ref
);
6150 static void calc_die_sizes (dw_die_ref
);
6151 static void mark_dies (dw_die_ref
);
6152 static void unmark_dies (dw_die_ref
);
6153 static void unmark_all_dies (dw_die_ref
);
6154 static unsigned long size_of_pubnames (VEC (pubname_entry
,gc
) *);
6155 static unsigned long size_of_aranges (void);
6156 static enum dwarf_form
value_format (dw_attr_ref
);
6157 static void output_value_format (dw_attr_ref
);
6158 static void output_abbrev_section (void);
6159 static void output_die_symbol (dw_die_ref
);
6160 static void output_die (dw_die_ref
);
6161 static void output_compilation_unit_header (void);
6162 static void output_comp_unit (dw_die_ref
, int);
6163 static void output_comdat_type_unit (comdat_type_node
*);
6164 static const char *dwarf2_name (tree
, int);
6165 static void add_pubname (tree
, dw_die_ref
);
6166 static void add_pubname_string (const char *, dw_die_ref
);
6167 static void add_pubtype (tree
, dw_die_ref
);
6168 static void output_pubnames (VEC (pubname_entry
,gc
) *);
6169 static void add_arange (tree
, dw_die_ref
);
6170 static void output_aranges (void);
6171 static unsigned int add_ranges_num (int);
6172 static unsigned int add_ranges (const_tree
);
6173 static void add_ranges_by_labels (dw_die_ref
, const char *, const char *,
6175 static void output_ranges (void);
6176 static void output_line_info (void);
6177 static void output_file_names (void);
6178 static dw_die_ref
base_type_die (tree
);
6179 static int is_base_type (tree
);
6180 static dw_die_ref
subrange_type_die (tree
, tree
, tree
, dw_die_ref
);
6181 static dw_die_ref
modified_type_die (tree
, int, int, dw_die_ref
);
6182 static dw_die_ref
generic_parameter_die (tree
, tree
, bool, dw_die_ref
);
6183 static dw_die_ref
template_parameter_pack_die (tree
, tree
, dw_die_ref
);
6184 static int type_is_enum (const_tree
);
6185 static unsigned int dbx_reg_number (const_rtx
);
6186 static void add_loc_descr_op_piece (dw_loc_descr_ref
*, int);
6187 static dw_loc_descr_ref
reg_loc_descriptor (rtx
, enum var_init_status
);
6188 static dw_loc_descr_ref
one_reg_loc_descriptor (unsigned int,
6189 enum var_init_status
);
6190 static dw_loc_descr_ref
multiple_reg_loc_descriptor (rtx
, rtx
,
6191 enum var_init_status
);
6192 static dw_loc_descr_ref
based_loc_descr (rtx
, HOST_WIDE_INT
,
6193 enum var_init_status
);
6194 static int is_based_loc (const_rtx
);
6195 static int resolve_one_addr (rtx
*, void *);
6196 static dw_loc_descr_ref
mem_loc_descriptor (rtx
, enum machine_mode mode
,
6197 enum var_init_status
);
6198 static dw_loc_descr_ref
concat_loc_descriptor (rtx
, rtx
,
6199 enum var_init_status
);
6200 static dw_loc_descr_ref
loc_descriptor (rtx
, enum machine_mode mode
,
6201 enum var_init_status
);
6202 static dw_loc_list_ref
loc_list_from_tree (tree
, int);
6203 static dw_loc_descr_ref
loc_descriptor_from_tree (tree
, int);
6204 static HOST_WIDE_INT
ceiling (HOST_WIDE_INT
, unsigned int);
6205 static tree
field_type (const_tree
);
6206 static unsigned int simple_type_align_in_bits (const_tree
);
6207 static unsigned int simple_decl_align_in_bits (const_tree
);
6208 static unsigned HOST_WIDE_INT
simple_type_size_in_bits (const_tree
);
6209 static HOST_WIDE_INT
field_byte_offset (const_tree
);
6210 static void add_AT_location_description (dw_die_ref
, enum dwarf_attribute
,
6212 static void add_data_member_location_attribute (dw_die_ref
, tree
);
6213 static bool add_const_value_attribute (dw_die_ref
, rtx
);
6214 static void insert_int (HOST_WIDE_INT
, unsigned, unsigned char *);
6215 static void insert_double (double_int
, unsigned char *);
6216 static void insert_float (const_rtx
, unsigned char *);
6217 static rtx
rtl_for_decl_location (tree
);
6218 static bool add_location_or_const_value_attribute (dw_die_ref
, tree
,
6219 enum dwarf_attribute
);
6220 static bool tree_add_const_value_attribute (dw_die_ref
, tree
);
6221 static bool tree_add_const_value_attribute_for_decl (dw_die_ref
, tree
);
6222 static void add_name_attribute (dw_die_ref
, const char *);
6223 static void add_comp_dir_attribute (dw_die_ref
);
6224 static void add_bound_info (dw_die_ref
, enum dwarf_attribute
, tree
);
6225 static void add_subscript_info (dw_die_ref
, tree
, bool);
6226 static void add_byte_size_attribute (dw_die_ref
, tree
);
6227 static void add_bit_offset_attribute (dw_die_ref
, tree
);
6228 static void add_bit_size_attribute (dw_die_ref
, tree
);
6229 static void add_prototyped_attribute (dw_die_ref
, tree
);
6230 static dw_die_ref
add_abstract_origin_attribute (dw_die_ref
, tree
);
6231 static void add_pure_or_virtual_attribute (dw_die_ref
, tree
);
6232 static void add_src_coords_attributes (dw_die_ref
, tree
);
6233 static void add_name_and_src_coords_attributes (dw_die_ref
, tree
);
6234 static void push_decl_scope (tree
);
6235 static void pop_decl_scope (void);
6236 static dw_die_ref
scope_die_for (tree
, dw_die_ref
);
6237 static inline int local_scope_p (dw_die_ref
);
6238 static inline int class_scope_p (dw_die_ref
);
6239 static inline int class_or_namespace_scope_p (dw_die_ref
);
6240 static void add_type_attribute (dw_die_ref
, tree
, int, int, dw_die_ref
);
6241 static void add_calling_convention_attribute (dw_die_ref
, tree
);
6242 static const char *type_tag (const_tree
);
6243 static tree
member_declared_type (const_tree
);
6245 static const char *decl_start_label (tree
);
6247 static void gen_array_type_die (tree
, dw_die_ref
);
6248 static void gen_descr_array_type_die (tree
, struct array_descr_info
*, dw_die_ref
);
6250 static void gen_entry_point_die (tree
, dw_die_ref
);
6252 static dw_die_ref
gen_enumeration_type_die (tree
, dw_die_ref
);
6253 static dw_die_ref
gen_formal_parameter_die (tree
, tree
, bool, dw_die_ref
);
6254 static dw_die_ref
gen_formal_parameter_pack_die (tree
, tree
, dw_die_ref
, tree
*);
6255 static void gen_unspecified_parameters_die (tree
, dw_die_ref
);
6256 static void gen_formal_types_die (tree
, dw_die_ref
);
6257 static void gen_subprogram_die (tree
, dw_die_ref
);
6258 static void gen_variable_die (tree
, tree
, dw_die_ref
);
6259 static void gen_const_die (tree
, dw_die_ref
);
6260 static void gen_label_die (tree
, dw_die_ref
);
6261 static void gen_lexical_block_die (tree
, dw_die_ref
, int);
6262 static void gen_inlined_subroutine_die (tree
, dw_die_ref
, int);
6263 static void gen_field_die (tree
, dw_die_ref
);
6264 static void gen_ptr_to_mbr_type_die (tree
, dw_die_ref
);
6265 static dw_die_ref
gen_compile_unit_die (const char *);
6266 static void gen_inheritance_die (tree
, tree
, dw_die_ref
);
6267 static void gen_member_die (tree
, dw_die_ref
);
6268 static void gen_struct_or_union_type_die (tree
, dw_die_ref
,
6269 enum debug_info_usage
);
6270 static void gen_subroutine_type_die (tree
, dw_die_ref
);
6271 static void gen_typedef_die (tree
, dw_die_ref
);
6272 static void gen_type_die (tree
, dw_die_ref
);
6273 static void gen_block_die (tree
, dw_die_ref
, int);
6274 static void decls_for_scope (tree
, dw_die_ref
, int);
6275 static int is_redundant_typedef (const_tree
);
6276 static bool is_naming_typedef_decl (const_tree
);
6277 static inline dw_die_ref
get_context_die (tree
);
6278 static void gen_namespace_die (tree
, dw_die_ref
);
6279 static void gen_decl_die (tree
, tree
, dw_die_ref
);
6280 static dw_die_ref
force_decl_die (tree
);
6281 static dw_die_ref
force_type_die (tree
);
6282 static dw_die_ref
setup_namespace_context (tree
, dw_die_ref
);
6283 static dw_die_ref
declare_in_namespace (tree
, dw_die_ref
);
6284 static struct dwarf_file_data
* lookup_filename (const char *);
6285 static void retry_incomplete_types (void);
6286 static void gen_type_die_for_member (tree
, tree
, dw_die_ref
);
6287 static void gen_generic_params_dies (tree
);
6288 static void gen_tagged_type_die (tree
, dw_die_ref
, enum debug_info_usage
);
6289 static void gen_type_die_with_usage (tree
, dw_die_ref
, enum debug_info_usage
);
6290 static void splice_child_die (dw_die_ref
, dw_die_ref
);
6291 static int file_info_cmp (const void *, const void *);
6292 static dw_loc_list_ref
new_loc_list (dw_loc_descr_ref
, const char *,
6293 const char *, const char *);
6294 static void output_loc_list (dw_loc_list_ref
);
6295 static char *gen_internal_sym (const char *);
6297 static void prune_unmark_dies (dw_die_ref
);
6298 static void prune_unused_types_mark (dw_die_ref
, int);
6299 static void prune_unused_types_walk (dw_die_ref
);
6300 static void prune_unused_types_walk_attribs (dw_die_ref
);
6301 static void prune_unused_types_prune (dw_die_ref
);
6302 static void prune_unused_types (void);
6303 static int maybe_emit_file (struct dwarf_file_data
*fd
);
6304 static inline const char *AT_vms_delta1 (dw_attr_ref
);
6305 static inline const char *AT_vms_delta2 (dw_attr_ref
);
6306 static inline void add_AT_vms_delta (dw_die_ref
, enum dwarf_attribute
,
6307 const char *, const char *);
6308 static void append_entry_to_tmpl_value_parm_die_table (dw_die_ref
, tree
);
6309 static void gen_remaining_tmpl_value_param_die_attribute (void);
6311 /* Section names used to hold DWARF debugging information. */
6312 #ifndef DEBUG_INFO_SECTION
6313 #define DEBUG_INFO_SECTION ".debug_info"
6315 #ifndef DEBUG_ABBREV_SECTION
6316 #define DEBUG_ABBREV_SECTION ".debug_abbrev"
6318 #ifndef DEBUG_ARANGES_SECTION
6319 #define DEBUG_ARANGES_SECTION ".debug_aranges"
6321 #ifndef DEBUG_MACINFO_SECTION
6322 #define DEBUG_MACINFO_SECTION ".debug_macinfo"
6324 #ifndef DEBUG_LINE_SECTION
6325 #define DEBUG_LINE_SECTION ".debug_line"
6327 #ifndef DEBUG_LOC_SECTION
6328 #define DEBUG_LOC_SECTION ".debug_loc"
6330 #ifndef DEBUG_PUBNAMES_SECTION
6331 #define DEBUG_PUBNAMES_SECTION ".debug_pubnames"
6333 #ifndef DEBUG_PUBTYPES_SECTION
6334 #define DEBUG_PUBTYPES_SECTION ".debug_pubtypes"
6336 #ifndef DEBUG_DCALL_SECTION
6337 #define DEBUG_DCALL_SECTION ".debug_dcall"
6339 #ifndef DEBUG_VCALL_SECTION
6340 #define DEBUG_VCALL_SECTION ".debug_vcall"
6342 #ifndef DEBUG_STR_SECTION
6343 #define DEBUG_STR_SECTION ".debug_str"
6345 #ifndef DEBUG_RANGES_SECTION
6346 #define DEBUG_RANGES_SECTION ".debug_ranges"
6349 /* Standard ELF section names for compiled code and data. */
6350 #ifndef TEXT_SECTION_NAME
6351 #define TEXT_SECTION_NAME ".text"
6354 /* Section flags for .debug_str section. */
6355 #define DEBUG_STR_SECTION_FLAGS \
6356 (HAVE_GAS_SHF_MERGE && flag_merge_debug_strings \
6357 ? SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1 \
6360 /* Labels we insert at beginning sections we can reference instead of
6361 the section names themselves. */
6363 #ifndef TEXT_SECTION_LABEL
6364 #define TEXT_SECTION_LABEL "Ltext"
6366 #ifndef COLD_TEXT_SECTION_LABEL
6367 #define COLD_TEXT_SECTION_LABEL "Ltext_cold"
6369 #ifndef DEBUG_LINE_SECTION_LABEL
6370 #define DEBUG_LINE_SECTION_LABEL "Ldebug_line"
6372 #ifndef DEBUG_INFO_SECTION_LABEL
6373 #define DEBUG_INFO_SECTION_LABEL "Ldebug_info"
6375 #ifndef DEBUG_ABBREV_SECTION_LABEL
6376 #define DEBUG_ABBREV_SECTION_LABEL "Ldebug_abbrev"
6378 #ifndef DEBUG_LOC_SECTION_LABEL
6379 #define DEBUG_LOC_SECTION_LABEL "Ldebug_loc"
6381 #ifndef DEBUG_RANGES_SECTION_LABEL
6382 #define DEBUG_RANGES_SECTION_LABEL "Ldebug_ranges"
6384 #ifndef DEBUG_MACINFO_SECTION_LABEL
6385 #define DEBUG_MACINFO_SECTION_LABEL "Ldebug_macinfo"
6388 /* Mangled name attribute to use. This used to be a vendor extension
6389 until DWARF 4 standardized it. */
6390 #define AT_linkage_name \
6391 (dwarf_version >= 4 ? DW_AT_linkage_name : DW_AT_MIPS_linkage_name)
6394 /* Definitions of defaults for formats and names of various special
6395 (artificial) labels which may be generated within this file (when the -g
6396 options is used and DWARF2_DEBUGGING_INFO is in effect.
6397 If necessary, these may be overridden from within the tm.h file, but
6398 typically, overriding these defaults is unnecessary. */
6400 static char text_end_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
6401 static char text_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
6402 static char cold_text_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
6403 static char cold_end_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
6404 static char abbrev_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
6405 static char debug_info_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
6406 static char debug_line_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
6407 static char macinfo_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
6408 static char loc_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
6409 static char ranges_section_label
[2 * MAX_ARTIFICIAL_LABEL_BYTES
];
6411 #ifndef TEXT_END_LABEL
6412 #define TEXT_END_LABEL "Letext"
6414 #ifndef COLD_END_LABEL
6415 #define COLD_END_LABEL "Letext_cold"
6417 #ifndef BLOCK_BEGIN_LABEL
6418 #define BLOCK_BEGIN_LABEL "LBB"
6420 #ifndef BLOCK_END_LABEL
6421 #define BLOCK_END_LABEL "LBE"
6423 #ifndef LINE_CODE_LABEL
6424 #define LINE_CODE_LABEL "LM"
6426 #ifndef SEPARATE_LINE_CODE_LABEL
6427 #define SEPARATE_LINE_CODE_LABEL "LSM"
6431 /* We allow a language front-end to designate a function that is to be
6432 called to "demangle" any name before it is put into a DIE. */
6434 static const char *(*demangle_name_func
) (const char *);
6437 dwarf2out_set_demangle_name_func (const char *(*func
) (const char *))
6439 demangle_name_func
= func
;
6442 /* Test if rtl node points to a pseudo register. */
6445 is_pseudo_reg (const_rtx rtl
)
6447 return ((REG_P (rtl
) && REGNO (rtl
) >= FIRST_PSEUDO_REGISTER
)
6448 || (GET_CODE (rtl
) == SUBREG
6449 && REGNO (SUBREG_REG (rtl
)) >= FIRST_PSEUDO_REGISTER
));
6452 /* Return a reference to a type, with its const and volatile qualifiers
6456 type_main_variant (tree type
)
6458 type
= TYPE_MAIN_VARIANT (type
);
6460 /* ??? There really should be only one main variant among any group of
6461 variants of a given type (and all of the MAIN_VARIANT values for all
6462 members of the group should point to that one type) but sometimes the C
6463 front-end messes this up for array types, so we work around that bug
6465 if (TREE_CODE (type
) == ARRAY_TYPE
)
6466 while (type
!= TYPE_MAIN_VARIANT (type
))
6467 type
= TYPE_MAIN_VARIANT (type
);
6472 /* Return nonzero if the given type node represents a tagged type. */
6475 is_tagged_type (const_tree type
)
6477 enum tree_code code
= TREE_CODE (type
);
6479 return (code
== RECORD_TYPE
|| code
== UNION_TYPE
6480 || code
== QUAL_UNION_TYPE
|| code
== ENUMERAL_TYPE
);
6483 /* Convert a DIE tag into its string name. */
6486 dwarf_tag_name (unsigned int tag
)
6490 case DW_TAG_padding
:
6491 return "DW_TAG_padding";
6492 case DW_TAG_array_type
:
6493 return "DW_TAG_array_type";
6494 case DW_TAG_class_type
:
6495 return "DW_TAG_class_type";
6496 case DW_TAG_entry_point
:
6497 return "DW_TAG_entry_point";
6498 case DW_TAG_enumeration_type
:
6499 return "DW_TAG_enumeration_type";
6500 case DW_TAG_formal_parameter
:
6501 return "DW_TAG_formal_parameter";
6502 case DW_TAG_imported_declaration
:
6503 return "DW_TAG_imported_declaration";
6505 return "DW_TAG_label";
6506 case DW_TAG_lexical_block
:
6507 return "DW_TAG_lexical_block";
6509 return "DW_TAG_member";
6510 case DW_TAG_pointer_type
:
6511 return "DW_TAG_pointer_type";
6512 case DW_TAG_reference_type
:
6513 return "DW_TAG_reference_type";
6514 case DW_TAG_compile_unit
:
6515 return "DW_TAG_compile_unit";
6516 case DW_TAG_string_type
:
6517 return "DW_TAG_string_type";
6518 case DW_TAG_structure_type
:
6519 return "DW_TAG_structure_type";
6520 case DW_TAG_subroutine_type
:
6521 return "DW_TAG_subroutine_type";
6522 case DW_TAG_typedef
:
6523 return "DW_TAG_typedef";
6524 case DW_TAG_union_type
:
6525 return "DW_TAG_union_type";
6526 case DW_TAG_unspecified_parameters
:
6527 return "DW_TAG_unspecified_parameters";
6528 case DW_TAG_variant
:
6529 return "DW_TAG_variant";
6530 case DW_TAG_common_block
:
6531 return "DW_TAG_common_block";
6532 case DW_TAG_common_inclusion
:
6533 return "DW_TAG_common_inclusion";
6534 case DW_TAG_inheritance
:
6535 return "DW_TAG_inheritance";
6536 case DW_TAG_inlined_subroutine
:
6537 return "DW_TAG_inlined_subroutine";
6539 return "DW_TAG_module";
6540 case DW_TAG_ptr_to_member_type
:
6541 return "DW_TAG_ptr_to_member_type";
6542 case DW_TAG_set_type
:
6543 return "DW_TAG_set_type";
6544 case DW_TAG_subrange_type
:
6545 return "DW_TAG_subrange_type";
6546 case DW_TAG_with_stmt
:
6547 return "DW_TAG_with_stmt";
6548 case DW_TAG_access_declaration
:
6549 return "DW_TAG_access_declaration";
6550 case DW_TAG_base_type
:
6551 return "DW_TAG_base_type";
6552 case DW_TAG_catch_block
:
6553 return "DW_TAG_catch_block";
6554 case DW_TAG_const_type
:
6555 return "DW_TAG_const_type";
6556 case DW_TAG_constant
:
6557 return "DW_TAG_constant";
6558 case DW_TAG_enumerator
:
6559 return "DW_TAG_enumerator";
6560 case DW_TAG_file_type
:
6561 return "DW_TAG_file_type";
6563 return "DW_TAG_friend";
6564 case DW_TAG_namelist
:
6565 return "DW_TAG_namelist";
6566 case DW_TAG_namelist_item
:
6567 return "DW_TAG_namelist_item";
6568 case DW_TAG_packed_type
:
6569 return "DW_TAG_packed_type";
6570 case DW_TAG_subprogram
:
6571 return "DW_TAG_subprogram";
6572 case DW_TAG_template_type_param
:
6573 return "DW_TAG_template_type_param";
6574 case DW_TAG_template_value_param
:
6575 return "DW_TAG_template_value_param";
6576 case DW_TAG_thrown_type
:
6577 return "DW_TAG_thrown_type";
6578 case DW_TAG_try_block
:
6579 return "DW_TAG_try_block";
6580 case DW_TAG_variant_part
:
6581 return "DW_TAG_variant_part";
6582 case DW_TAG_variable
:
6583 return "DW_TAG_variable";
6584 case DW_TAG_volatile_type
:
6585 return "DW_TAG_volatile_type";
6586 case DW_TAG_dwarf_procedure
:
6587 return "DW_TAG_dwarf_procedure";
6588 case DW_TAG_restrict_type
:
6589 return "DW_TAG_restrict_type";
6590 case DW_TAG_interface_type
:
6591 return "DW_TAG_interface_type";
6592 case DW_TAG_namespace
:
6593 return "DW_TAG_namespace";
6594 case DW_TAG_imported_module
:
6595 return "DW_TAG_imported_module";
6596 case DW_TAG_unspecified_type
:
6597 return "DW_TAG_unspecified_type";
6598 case DW_TAG_partial_unit
:
6599 return "DW_TAG_partial_unit";
6600 case DW_TAG_imported_unit
:
6601 return "DW_TAG_imported_unit";
6602 case DW_TAG_condition
:
6603 return "DW_TAG_condition";
6604 case DW_TAG_shared_type
:
6605 return "DW_TAG_shared_type";
6606 case DW_TAG_type_unit
:
6607 return "DW_TAG_type_unit";
6608 case DW_TAG_rvalue_reference_type
:
6609 return "DW_TAG_rvalue_reference_type";
6610 case DW_TAG_template_alias
:
6611 return "DW_TAG_template_alias";
6612 case DW_TAG_GNU_template_parameter_pack
:
6613 return "DW_TAG_GNU_template_parameter_pack";
6614 case DW_TAG_GNU_formal_parameter_pack
:
6615 return "DW_TAG_GNU_formal_parameter_pack";
6616 case DW_TAG_MIPS_loop
:
6617 return "DW_TAG_MIPS_loop";
6618 case DW_TAG_format_label
:
6619 return "DW_TAG_format_label";
6620 case DW_TAG_function_template
:
6621 return "DW_TAG_function_template";
6622 case DW_TAG_class_template
:
6623 return "DW_TAG_class_template";
6624 case DW_TAG_GNU_BINCL
:
6625 return "DW_TAG_GNU_BINCL";
6626 case DW_TAG_GNU_EINCL
:
6627 return "DW_TAG_GNU_EINCL";
6628 case DW_TAG_GNU_template_template_param
:
6629 return "DW_TAG_GNU_template_template_param";
6631 return "DW_TAG_<unknown>";
6635 /* Convert a DWARF attribute code into its string name. */
6638 dwarf_attr_name (unsigned int attr
)
6643 return "DW_AT_sibling";
6644 case DW_AT_location
:
6645 return "DW_AT_location";
6647 return "DW_AT_name";
6648 case DW_AT_ordering
:
6649 return "DW_AT_ordering";
6650 case DW_AT_subscr_data
:
6651 return "DW_AT_subscr_data";
6652 case DW_AT_byte_size
:
6653 return "DW_AT_byte_size";
6654 case DW_AT_bit_offset
:
6655 return "DW_AT_bit_offset";
6656 case DW_AT_bit_size
:
6657 return "DW_AT_bit_size";
6658 case DW_AT_element_list
:
6659 return "DW_AT_element_list";
6660 case DW_AT_stmt_list
:
6661 return "DW_AT_stmt_list";
6663 return "DW_AT_low_pc";
6665 return "DW_AT_high_pc";
6666 case DW_AT_language
:
6667 return "DW_AT_language";
6669 return "DW_AT_member";
6671 return "DW_AT_discr";
6672 case DW_AT_discr_value
:
6673 return "DW_AT_discr_value";
6674 case DW_AT_visibility
:
6675 return "DW_AT_visibility";
6677 return "DW_AT_import";
6678 case DW_AT_string_length
:
6679 return "DW_AT_string_length";
6680 case DW_AT_common_reference
:
6681 return "DW_AT_common_reference";
6682 case DW_AT_comp_dir
:
6683 return "DW_AT_comp_dir";
6684 case DW_AT_const_value
:
6685 return "DW_AT_const_value";
6686 case DW_AT_containing_type
:
6687 return "DW_AT_containing_type";
6688 case DW_AT_default_value
:
6689 return "DW_AT_default_value";
6691 return "DW_AT_inline";
6692 case DW_AT_is_optional
:
6693 return "DW_AT_is_optional";
6694 case DW_AT_lower_bound
:
6695 return "DW_AT_lower_bound";
6696 case DW_AT_producer
:
6697 return "DW_AT_producer";
6698 case DW_AT_prototyped
:
6699 return "DW_AT_prototyped";
6700 case DW_AT_return_addr
:
6701 return "DW_AT_return_addr";
6702 case DW_AT_start_scope
:
6703 return "DW_AT_start_scope";
6704 case DW_AT_bit_stride
:
6705 return "DW_AT_bit_stride";
6706 case DW_AT_upper_bound
:
6707 return "DW_AT_upper_bound";
6708 case DW_AT_abstract_origin
:
6709 return "DW_AT_abstract_origin";
6710 case DW_AT_accessibility
:
6711 return "DW_AT_accessibility";
6712 case DW_AT_address_class
:
6713 return "DW_AT_address_class";
6714 case DW_AT_artificial
:
6715 return "DW_AT_artificial";
6716 case DW_AT_base_types
:
6717 return "DW_AT_base_types";
6718 case DW_AT_calling_convention
:
6719 return "DW_AT_calling_convention";
6721 return "DW_AT_count";
6722 case DW_AT_data_member_location
:
6723 return "DW_AT_data_member_location";
6724 case DW_AT_decl_column
:
6725 return "DW_AT_decl_column";
6726 case DW_AT_decl_file
:
6727 return "DW_AT_decl_file";
6728 case DW_AT_decl_line
:
6729 return "DW_AT_decl_line";
6730 case DW_AT_declaration
:
6731 return "DW_AT_declaration";
6732 case DW_AT_discr_list
:
6733 return "DW_AT_discr_list";
6734 case DW_AT_encoding
:
6735 return "DW_AT_encoding";
6736 case DW_AT_external
:
6737 return "DW_AT_external";
6738 case DW_AT_explicit
:
6739 return "DW_AT_explicit";
6740 case DW_AT_frame_base
:
6741 return "DW_AT_frame_base";
6743 return "DW_AT_friend";
6744 case DW_AT_identifier_case
:
6745 return "DW_AT_identifier_case";
6746 case DW_AT_macro_info
:
6747 return "DW_AT_macro_info";
6748 case DW_AT_namelist_items
:
6749 return "DW_AT_namelist_items";
6750 case DW_AT_priority
:
6751 return "DW_AT_priority";
6753 return "DW_AT_segment";
6754 case DW_AT_specification
:
6755 return "DW_AT_specification";
6756 case DW_AT_static_link
:
6757 return "DW_AT_static_link";
6759 return "DW_AT_type";
6760 case DW_AT_use_location
:
6761 return "DW_AT_use_location";
6762 case DW_AT_variable_parameter
:
6763 return "DW_AT_variable_parameter";
6764 case DW_AT_virtuality
:
6765 return "DW_AT_virtuality";
6766 case DW_AT_vtable_elem_location
:
6767 return "DW_AT_vtable_elem_location";
6769 case DW_AT_allocated
:
6770 return "DW_AT_allocated";
6771 case DW_AT_associated
:
6772 return "DW_AT_associated";
6773 case DW_AT_data_location
:
6774 return "DW_AT_data_location";
6775 case DW_AT_byte_stride
:
6776 return "DW_AT_byte_stride";
6777 case DW_AT_entry_pc
:
6778 return "DW_AT_entry_pc";
6779 case DW_AT_use_UTF8
:
6780 return "DW_AT_use_UTF8";
6781 case DW_AT_extension
:
6782 return "DW_AT_extension";
6784 return "DW_AT_ranges";
6785 case DW_AT_trampoline
:
6786 return "DW_AT_trampoline";
6787 case DW_AT_call_column
:
6788 return "DW_AT_call_column";
6789 case DW_AT_call_file
:
6790 return "DW_AT_call_file";
6791 case DW_AT_call_line
:
6792 return "DW_AT_call_line";
6794 case DW_AT_signature
:
6795 return "DW_AT_signature";
6796 case DW_AT_main_subprogram
:
6797 return "DW_AT_main_subprogram";
6798 case DW_AT_data_bit_offset
:
6799 return "DW_AT_data_bit_offset";
6800 case DW_AT_const_expr
:
6801 return "DW_AT_const_expr";
6802 case DW_AT_enum_class
:
6803 return "DW_AT_enum_class";
6804 case DW_AT_linkage_name
:
6805 return "DW_AT_linkage_name";
6807 case DW_AT_MIPS_fde
:
6808 return "DW_AT_MIPS_fde";
6809 case DW_AT_MIPS_loop_begin
:
6810 return "DW_AT_MIPS_loop_begin";
6811 case DW_AT_MIPS_tail_loop_begin
:
6812 return "DW_AT_MIPS_tail_loop_begin";
6813 case DW_AT_MIPS_epilog_begin
:
6814 return "DW_AT_MIPS_epilog_begin";
6815 #if VMS_DEBUGGING_INFO
6816 case DW_AT_HP_prologue
:
6817 return "DW_AT_HP_prologue";
6819 case DW_AT_MIPS_loop_unroll_factor
:
6820 return "DW_AT_MIPS_loop_unroll_factor";
6822 case DW_AT_MIPS_software_pipeline_depth
:
6823 return "DW_AT_MIPS_software_pipeline_depth";
6824 case DW_AT_MIPS_linkage_name
:
6825 return "DW_AT_MIPS_linkage_name";
6826 #if VMS_DEBUGGING_INFO
6827 case DW_AT_HP_epilogue
:
6828 return "DW_AT_HP_epilogue";
6830 case DW_AT_MIPS_stride
:
6831 return "DW_AT_MIPS_stride";
6833 case DW_AT_MIPS_abstract_name
:
6834 return "DW_AT_MIPS_abstract_name";
6835 case DW_AT_MIPS_clone_origin
:
6836 return "DW_AT_MIPS_clone_origin";
6837 case DW_AT_MIPS_has_inlines
:
6838 return "DW_AT_MIPS_has_inlines";
6840 case DW_AT_sf_names
:
6841 return "DW_AT_sf_names";
6842 case DW_AT_src_info
:
6843 return "DW_AT_src_info";
6844 case DW_AT_mac_info
:
6845 return "DW_AT_mac_info";
6846 case DW_AT_src_coords
:
6847 return "DW_AT_src_coords";
6848 case DW_AT_body_begin
:
6849 return "DW_AT_body_begin";
6850 case DW_AT_body_end
:
6851 return "DW_AT_body_end";
6852 case DW_AT_GNU_vector
:
6853 return "DW_AT_GNU_vector";
6854 case DW_AT_GNU_guarded_by
:
6855 return "DW_AT_GNU_guarded_by";
6856 case DW_AT_GNU_pt_guarded_by
:
6857 return "DW_AT_GNU_pt_guarded_by";
6858 case DW_AT_GNU_guarded
:
6859 return "DW_AT_GNU_guarded";
6860 case DW_AT_GNU_pt_guarded
:
6861 return "DW_AT_GNU_pt_guarded";
6862 case DW_AT_GNU_locks_excluded
:
6863 return "DW_AT_GNU_locks_excluded";
6864 case DW_AT_GNU_exclusive_locks_required
:
6865 return "DW_AT_GNU_exclusive_locks_required";
6866 case DW_AT_GNU_shared_locks_required
:
6867 return "DW_AT_GNU_shared_locks_required";
6868 case DW_AT_GNU_odr_signature
:
6869 return "DW_AT_GNU_odr_signature";
6870 case DW_AT_GNU_template_name
:
6871 return "DW_AT_GNU_template_name";
6873 case DW_AT_VMS_rtnbeg_pd_address
:
6874 return "DW_AT_VMS_rtnbeg_pd_address";
6877 return "DW_AT_<unknown>";
6881 /* Convert a DWARF value form code into its string name. */
6884 dwarf_form_name (unsigned int form
)
6889 return "DW_FORM_addr";
6890 case DW_FORM_block2
:
6891 return "DW_FORM_block2";
6892 case DW_FORM_block4
:
6893 return "DW_FORM_block4";
6895 return "DW_FORM_data2";
6897 return "DW_FORM_data4";
6899 return "DW_FORM_data8";
6900 case DW_FORM_string
:
6901 return "DW_FORM_string";
6903 return "DW_FORM_block";
6904 case DW_FORM_block1
:
6905 return "DW_FORM_block1";
6907 return "DW_FORM_data1";
6909 return "DW_FORM_flag";
6911 return "DW_FORM_sdata";
6913 return "DW_FORM_strp";
6915 return "DW_FORM_udata";
6916 case DW_FORM_ref_addr
:
6917 return "DW_FORM_ref_addr";
6919 return "DW_FORM_ref1";
6921 return "DW_FORM_ref2";
6923 return "DW_FORM_ref4";
6925 return "DW_FORM_ref8";
6926 case DW_FORM_ref_udata
:
6927 return "DW_FORM_ref_udata";
6928 case DW_FORM_indirect
:
6929 return "DW_FORM_indirect";
6930 case DW_FORM_sec_offset
:
6931 return "DW_FORM_sec_offset";
6932 case DW_FORM_exprloc
:
6933 return "DW_FORM_exprloc";
6934 case DW_FORM_flag_present
:
6935 return "DW_FORM_flag_present";
6936 case DW_FORM_ref_sig8
:
6937 return "DW_FORM_ref_sig8";
6939 return "DW_FORM_<unknown>";
6943 /* Determine the "ultimate origin" of a decl. The decl may be an inlined
6944 instance of an inlined instance of a decl which is local to an inline
6945 function, so we have to trace all of the way back through the origin chain
6946 to find out what sort of node actually served as the original seed for the
6950 decl_ultimate_origin (const_tree decl
)
6952 if (!CODE_CONTAINS_STRUCT (TREE_CODE (decl
), TS_DECL_COMMON
))
6955 /* output_inline_function sets DECL_ABSTRACT_ORIGIN for all the
6956 nodes in the function to point to themselves; ignore that if
6957 we're trying to output the abstract instance of this function. */
6958 if (DECL_ABSTRACT (decl
) && DECL_ABSTRACT_ORIGIN (decl
) == decl
)
6961 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
6962 most distant ancestor, this should never happen. */
6963 gcc_assert (!DECL_FROM_INLINE (DECL_ORIGIN (decl
)));
6965 return DECL_ABSTRACT_ORIGIN (decl
);
6968 /* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT
6969 of a virtual function may refer to a base class, so we check the 'this'
6973 decl_class_context (tree decl
)
6975 tree context
= NULL_TREE
;
6977 if (TREE_CODE (decl
) != FUNCTION_DECL
|| ! DECL_VINDEX (decl
))
6978 context
= DECL_CONTEXT (decl
);
6980 context
= TYPE_MAIN_VARIANT
6981 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)))));
6983 if (context
&& !TYPE_P (context
))
6984 context
= NULL_TREE
;
6989 /* Add an attribute/value pair to a DIE. */
6992 add_dwarf_attr (dw_die_ref die
, dw_attr_ref attr
)
6994 /* Maybe this should be an assert? */
6998 if (die
->die_attr
== NULL
)
6999 die
->die_attr
= VEC_alloc (dw_attr_node
, gc
, 1);
7000 VEC_safe_push (dw_attr_node
, gc
, die
->die_attr
, attr
);
7003 static inline enum dw_val_class
7004 AT_class (dw_attr_ref a
)
7006 return a
->dw_attr_val
.val_class
;
7009 /* Add a flag value attribute to a DIE. */
7012 add_AT_flag (dw_die_ref die
, enum dwarf_attribute attr_kind
, unsigned int flag
)
7016 attr
.dw_attr
= attr_kind
;
7017 attr
.dw_attr_val
.val_class
= dw_val_class_flag
;
7018 attr
.dw_attr_val
.v
.val_flag
= flag
;
7019 add_dwarf_attr (die
, &attr
);
7022 static inline unsigned
7023 AT_flag (dw_attr_ref a
)
7025 gcc_assert (a
&& AT_class (a
) == dw_val_class_flag
);
7026 return a
->dw_attr_val
.v
.val_flag
;
7029 /* Add a signed integer attribute value to a DIE. */
7032 add_AT_int (dw_die_ref die
, enum dwarf_attribute attr_kind
, HOST_WIDE_INT int_val
)
7036 attr
.dw_attr
= attr_kind
;
7037 attr
.dw_attr_val
.val_class
= dw_val_class_const
;
7038 attr
.dw_attr_val
.v
.val_int
= int_val
;
7039 add_dwarf_attr (die
, &attr
);
7042 static inline HOST_WIDE_INT
7043 AT_int (dw_attr_ref a
)
7045 gcc_assert (a
&& AT_class (a
) == dw_val_class_const
);
7046 return a
->dw_attr_val
.v
.val_int
;
7049 /* Add an unsigned integer attribute value to a DIE. */
7052 add_AT_unsigned (dw_die_ref die
, enum dwarf_attribute attr_kind
,
7053 unsigned HOST_WIDE_INT unsigned_val
)
7057 attr
.dw_attr
= attr_kind
;
7058 attr
.dw_attr_val
.val_class
= dw_val_class_unsigned_const
;
7059 attr
.dw_attr_val
.v
.val_unsigned
= unsigned_val
;
7060 add_dwarf_attr (die
, &attr
);
7063 static inline unsigned HOST_WIDE_INT
7064 AT_unsigned (dw_attr_ref a
)
7066 gcc_assert (a
&& AT_class (a
) == dw_val_class_unsigned_const
);
7067 return a
->dw_attr_val
.v
.val_unsigned
;
7070 /* Add an unsigned double integer attribute value to a DIE. */
7073 add_AT_double (dw_die_ref die
, enum dwarf_attribute attr_kind
,
7074 HOST_WIDE_INT high
, unsigned HOST_WIDE_INT low
)
7078 attr
.dw_attr
= attr_kind
;
7079 attr
.dw_attr_val
.val_class
= dw_val_class_const_double
;
7080 attr
.dw_attr_val
.v
.val_double
.high
= high
;
7081 attr
.dw_attr_val
.v
.val_double
.low
= low
;
7082 add_dwarf_attr (die
, &attr
);
7085 /* Add a floating point attribute value to a DIE and return it. */
7088 add_AT_vec (dw_die_ref die
, enum dwarf_attribute attr_kind
,
7089 unsigned int length
, unsigned int elt_size
, unsigned char *array
)
7093 attr
.dw_attr
= attr_kind
;
7094 attr
.dw_attr_val
.val_class
= dw_val_class_vec
;
7095 attr
.dw_attr_val
.v
.val_vec
.length
= length
;
7096 attr
.dw_attr_val
.v
.val_vec
.elt_size
= elt_size
;
7097 attr
.dw_attr_val
.v
.val_vec
.array
= array
;
7098 add_dwarf_attr (die
, &attr
);
7101 /* Add an 8-byte data attribute value to a DIE. */
7104 add_AT_data8 (dw_die_ref die
, enum dwarf_attribute attr_kind
,
7105 unsigned char data8
[8])
7109 attr
.dw_attr
= attr_kind
;
7110 attr
.dw_attr_val
.val_class
= dw_val_class_data8
;
7111 memcpy (attr
.dw_attr_val
.v
.val_data8
, data8
, 8);
7112 add_dwarf_attr (die
, &attr
);
7115 /* Hash and equality functions for debug_str_hash. */
7118 debug_str_do_hash (const void *x
)
7120 return htab_hash_string (((const struct indirect_string_node
*)x
)->str
);
7124 debug_str_eq (const void *x1
, const void *x2
)
7126 return strcmp ((((const struct indirect_string_node
*)x1
)->str
),
7127 (const char *)x2
) == 0;
7130 /* Add STR to the indirect string hash table. */
7132 static struct indirect_string_node
*
7133 find_AT_string (const char *str
)
7135 struct indirect_string_node
*node
;
7138 if (! debug_str_hash
)
7139 debug_str_hash
= htab_create_ggc (10, debug_str_do_hash
,
7140 debug_str_eq
, NULL
);
7142 slot
= htab_find_slot_with_hash (debug_str_hash
, str
,
7143 htab_hash_string (str
), INSERT
);
7146 node
= ggc_alloc_cleared_indirect_string_node ();
7147 node
->str
= ggc_strdup (str
);
7151 node
= (struct indirect_string_node
*) *slot
;
7157 /* Add a string attribute value to a DIE. */
7160 add_AT_string (dw_die_ref die
, enum dwarf_attribute attr_kind
, const char *str
)
7163 struct indirect_string_node
*node
;
7165 node
= find_AT_string (str
);
7167 attr
.dw_attr
= attr_kind
;
7168 attr
.dw_attr_val
.val_class
= dw_val_class_str
;
7169 attr
.dw_attr_val
.v
.val_str
= node
;
7170 add_dwarf_attr (die
, &attr
);
7173 /* Create a label for an indirect string node, ensuring it is going to
7174 be output, unless its reference count goes down to zero. */
7177 gen_label_for_indirect_string (struct indirect_string_node
*node
)
7184 ASM_GENERATE_INTERNAL_LABEL (label
, "LASF", dw2_string_counter
);
7185 ++dw2_string_counter
;
7186 node
->label
= xstrdup (label
);
7189 /* Create a SYMBOL_REF rtx whose value is the initial address of a
7190 debug string STR. */
7193 get_debug_string_label (const char *str
)
7195 struct indirect_string_node
*node
= find_AT_string (str
);
7197 debug_str_hash_forced
= true;
7199 gen_label_for_indirect_string (node
);
7201 return gen_rtx_SYMBOL_REF (Pmode
, node
->label
);
7204 static inline const char *
7205 AT_string (dw_attr_ref a
)
7207 gcc_assert (a
&& AT_class (a
) == dw_val_class_str
);
7208 return a
->dw_attr_val
.v
.val_str
->str
;
7211 /* Find out whether a string should be output inline in DIE
7212 or out-of-line in .debug_str section. */
7214 static enum dwarf_form
7215 AT_string_form (dw_attr_ref a
)
7217 struct indirect_string_node
*node
;
7220 gcc_assert (a
&& AT_class (a
) == dw_val_class_str
);
7222 node
= a
->dw_attr_val
.v
.val_str
;
7226 len
= strlen (node
->str
) + 1;
7228 /* If the string is shorter or equal to the size of the reference, it is
7229 always better to put it inline. */
7230 if (len
<= DWARF_OFFSET_SIZE
|| node
->refcount
== 0)
7231 return node
->form
= DW_FORM_string
;
7233 /* If we cannot expect the linker to merge strings in .debug_str
7234 section, only put it into .debug_str if it is worth even in this
7236 if (DWARF2_INDIRECT_STRING_SUPPORT_MISSING_ON_TARGET
7237 || ((debug_str_section
->common
.flags
& SECTION_MERGE
) == 0
7238 && (len
- DWARF_OFFSET_SIZE
) * node
->refcount
<= len
))
7239 return node
->form
= DW_FORM_string
;
7241 gen_label_for_indirect_string (node
);
7243 return node
->form
= DW_FORM_strp
;
7246 /* Add a DIE reference attribute value to a DIE. */
7249 add_AT_die_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
, dw_die_ref targ_die
)
7253 attr
.dw_attr
= attr_kind
;
7254 attr
.dw_attr_val
.val_class
= dw_val_class_die_ref
;
7255 attr
.dw_attr_val
.v
.val_die_ref
.die
= targ_die
;
7256 attr
.dw_attr_val
.v
.val_die_ref
.external
= 0;
7257 add_dwarf_attr (die
, &attr
);
7260 /* Add an AT_specification attribute to a DIE, and also make the back
7261 pointer from the specification to the definition. */
7264 add_AT_specification (dw_die_ref die
, dw_die_ref targ_die
)
7266 add_AT_die_ref (die
, DW_AT_specification
, targ_die
);
7267 gcc_assert (!targ_die
->die_definition
);
7268 targ_die
->die_definition
= die
;
7271 static inline dw_die_ref
7272 AT_ref (dw_attr_ref a
)
7274 gcc_assert (a
&& AT_class (a
) == dw_val_class_die_ref
);
7275 return a
->dw_attr_val
.v
.val_die_ref
.die
;
7279 AT_ref_external (dw_attr_ref a
)
7281 if (a
&& AT_class (a
) == dw_val_class_die_ref
)
7282 return a
->dw_attr_val
.v
.val_die_ref
.external
;
7288 set_AT_ref_external (dw_attr_ref a
, int i
)
7290 gcc_assert (a
&& AT_class (a
) == dw_val_class_die_ref
);
7291 a
->dw_attr_val
.v
.val_die_ref
.external
= i
;
7294 /* Add an FDE reference attribute value to a DIE. */
7297 add_AT_fde_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
, unsigned int targ_fde
)
7301 attr
.dw_attr
= attr_kind
;
7302 attr
.dw_attr_val
.val_class
= dw_val_class_fde_ref
;
7303 attr
.dw_attr_val
.v
.val_fde_index
= targ_fde
;
7304 add_dwarf_attr (die
, &attr
);
7307 /* Add a location description attribute value to a DIE. */
7310 add_AT_loc (dw_die_ref die
, enum dwarf_attribute attr_kind
, dw_loc_descr_ref loc
)
7314 attr
.dw_attr
= attr_kind
;
7315 attr
.dw_attr_val
.val_class
= dw_val_class_loc
;
7316 attr
.dw_attr_val
.v
.val_loc
= loc
;
7317 add_dwarf_attr (die
, &attr
);
7320 static inline dw_loc_descr_ref
7321 AT_loc (dw_attr_ref a
)
7323 gcc_assert (a
&& AT_class (a
) == dw_val_class_loc
);
7324 return a
->dw_attr_val
.v
.val_loc
;
7328 add_AT_loc_list (dw_die_ref die
, enum dwarf_attribute attr_kind
, dw_loc_list_ref loc_list
)
7332 attr
.dw_attr
= attr_kind
;
7333 attr
.dw_attr_val
.val_class
= dw_val_class_loc_list
;
7334 attr
.dw_attr_val
.v
.val_loc_list
= loc_list
;
7335 add_dwarf_attr (die
, &attr
);
7336 have_location_lists
= true;
7339 static inline dw_loc_list_ref
7340 AT_loc_list (dw_attr_ref a
)
7342 gcc_assert (a
&& AT_class (a
) == dw_val_class_loc_list
);
7343 return a
->dw_attr_val
.v
.val_loc_list
;
7346 static inline dw_loc_list_ref
*
7347 AT_loc_list_ptr (dw_attr_ref a
)
7349 gcc_assert (a
&& AT_class (a
) == dw_val_class_loc_list
);
7350 return &a
->dw_attr_val
.v
.val_loc_list
;
7353 /* Add an address constant attribute value to a DIE. */
7356 add_AT_addr (dw_die_ref die
, enum dwarf_attribute attr_kind
, rtx addr
)
7360 attr
.dw_attr
= attr_kind
;
7361 attr
.dw_attr_val
.val_class
= dw_val_class_addr
;
7362 attr
.dw_attr_val
.v
.val_addr
= addr
;
7363 add_dwarf_attr (die
, &attr
);
7366 /* Get the RTX from to an address DIE attribute. */
7369 AT_addr (dw_attr_ref a
)
7371 gcc_assert (a
&& AT_class (a
) == dw_val_class_addr
);
7372 return a
->dw_attr_val
.v
.val_addr
;
7375 /* Add a file attribute value to a DIE. */
7378 add_AT_file (dw_die_ref die
, enum dwarf_attribute attr_kind
,
7379 struct dwarf_file_data
*fd
)
7383 attr
.dw_attr
= attr_kind
;
7384 attr
.dw_attr_val
.val_class
= dw_val_class_file
;
7385 attr
.dw_attr_val
.v
.val_file
= fd
;
7386 add_dwarf_attr (die
, &attr
);
7389 /* Get the dwarf_file_data from a file DIE attribute. */
7391 static inline struct dwarf_file_data
*
7392 AT_file (dw_attr_ref a
)
7394 gcc_assert (a
&& AT_class (a
) == dw_val_class_file
);
7395 return a
->dw_attr_val
.v
.val_file
;
7398 /* Add a vms delta attribute value to a DIE. */
7401 add_AT_vms_delta (dw_die_ref die
, enum dwarf_attribute attr_kind
,
7402 const char *lbl1
, const char *lbl2
)
7406 attr
.dw_attr
= attr_kind
;
7407 attr
.dw_attr_val
.val_class
= dw_val_class_vms_delta
;
7408 attr
.dw_attr_val
.v
.val_vms_delta
.lbl1
= xstrdup (lbl1
);
7409 attr
.dw_attr_val
.v
.val_vms_delta
.lbl2
= xstrdup (lbl2
);
7410 add_dwarf_attr (die
, &attr
);
7413 /* Add a label identifier attribute value to a DIE. */
7416 add_AT_lbl_id (dw_die_ref die
, enum dwarf_attribute attr_kind
, const char *lbl_id
)
7420 attr
.dw_attr
= attr_kind
;
7421 attr
.dw_attr_val
.val_class
= dw_val_class_lbl_id
;
7422 attr
.dw_attr_val
.v
.val_lbl_id
= xstrdup (lbl_id
);
7423 add_dwarf_attr (die
, &attr
);
7426 /* Add a section offset attribute value to a DIE, an offset into the
7427 debug_line section. */
7430 add_AT_lineptr (dw_die_ref die
, enum dwarf_attribute attr_kind
,
7435 attr
.dw_attr
= attr_kind
;
7436 attr
.dw_attr_val
.val_class
= dw_val_class_lineptr
;
7437 attr
.dw_attr_val
.v
.val_lbl_id
= xstrdup (label
);
7438 add_dwarf_attr (die
, &attr
);
7441 /* Add a section offset attribute value to a DIE, an offset into the
7442 debug_macinfo section. */
7445 add_AT_macptr (dw_die_ref die
, enum dwarf_attribute attr_kind
,
7450 attr
.dw_attr
= attr_kind
;
7451 attr
.dw_attr_val
.val_class
= dw_val_class_macptr
;
7452 attr
.dw_attr_val
.v
.val_lbl_id
= xstrdup (label
);
7453 add_dwarf_attr (die
, &attr
);
7456 /* Add an offset attribute value to a DIE. */
7459 add_AT_offset (dw_die_ref die
, enum dwarf_attribute attr_kind
,
7460 unsigned HOST_WIDE_INT offset
)
7464 attr
.dw_attr
= attr_kind
;
7465 attr
.dw_attr_val
.val_class
= dw_val_class_offset
;
7466 attr
.dw_attr_val
.v
.val_offset
= offset
;
7467 add_dwarf_attr (die
, &attr
);
7470 /* Add an range_list attribute value to a DIE. */
7473 add_AT_range_list (dw_die_ref die
, enum dwarf_attribute attr_kind
,
7474 long unsigned int offset
)
7478 attr
.dw_attr
= attr_kind
;
7479 attr
.dw_attr_val
.val_class
= dw_val_class_range_list
;
7480 attr
.dw_attr_val
.v
.val_offset
= offset
;
7481 add_dwarf_attr (die
, &attr
);
7484 /* Return the start label of a delta attribute. */
7486 static inline const char *
7487 AT_vms_delta1 (dw_attr_ref a
)
7489 gcc_assert (a
&& (AT_class (a
) == dw_val_class_vms_delta
));
7490 return a
->dw_attr_val
.v
.val_vms_delta
.lbl1
;
7493 /* Return the end label of a delta attribute. */
7495 static inline const char *
7496 AT_vms_delta2 (dw_attr_ref a
)
7498 gcc_assert (a
&& (AT_class (a
) == dw_val_class_vms_delta
));
7499 return a
->dw_attr_val
.v
.val_vms_delta
.lbl2
;
7502 static inline const char *
7503 AT_lbl (dw_attr_ref a
)
7505 gcc_assert (a
&& (AT_class (a
) == dw_val_class_lbl_id
7506 || AT_class (a
) == dw_val_class_lineptr
7507 || AT_class (a
) == dw_val_class_macptr
));
7508 return a
->dw_attr_val
.v
.val_lbl_id
;
7511 /* Get the attribute of type attr_kind. */
7514 get_AT (dw_die_ref die
, enum dwarf_attribute attr_kind
)
7518 dw_die_ref spec
= NULL
;
7523 for (ix
= 0; VEC_iterate (dw_attr_node
, die
->die_attr
, ix
, a
); ix
++)
7524 if (a
->dw_attr
== attr_kind
)
7526 else if (a
->dw_attr
== DW_AT_specification
7527 || a
->dw_attr
== DW_AT_abstract_origin
)
7531 return get_AT (spec
, attr_kind
);
7536 /* Return the "low pc" attribute value, typically associated with a subprogram
7537 DIE. Return null if the "low pc" attribute is either not present, or if it
7538 cannot be represented as an assembler label identifier. */
7540 static inline const char *
7541 get_AT_low_pc (dw_die_ref die
)
7543 dw_attr_ref a
= get_AT (die
, DW_AT_low_pc
);
7545 return a
? AT_lbl (a
) : NULL
;
7548 /* Return the "high pc" attribute value, typically associated with a subprogram
7549 DIE. Return null if the "high pc" attribute is either not present, or if it
7550 cannot be represented as an assembler label identifier. */
7552 static inline const char *
7553 get_AT_hi_pc (dw_die_ref die
)
7555 dw_attr_ref a
= get_AT (die
, DW_AT_high_pc
);
7557 return a
? AT_lbl (a
) : NULL
;
7560 /* Return the value of the string attribute designated by ATTR_KIND, or
7561 NULL if it is not present. */
7563 static inline const char *
7564 get_AT_string (dw_die_ref die
, enum dwarf_attribute attr_kind
)
7566 dw_attr_ref a
= get_AT (die
, attr_kind
);
7568 return a
? AT_string (a
) : NULL
;
7571 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
7572 if it is not present. */
7575 get_AT_flag (dw_die_ref die
, enum dwarf_attribute attr_kind
)
7577 dw_attr_ref a
= get_AT (die
, attr_kind
);
7579 return a
? AT_flag (a
) : 0;
7582 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
7583 if it is not present. */
7585 static inline unsigned
7586 get_AT_unsigned (dw_die_ref die
, enum dwarf_attribute attr_kind
)
7588 dw_attr_ref a
= get_AT (die
, attr_kind
);
7590 return a
? AT_unsigned (a
) : 0;
7593 static inline dw_die_ref
7594 get_AT_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
)
7596 dw_attr_ref a
= get_AT (die
, attr_kind
);
7598 return a
? AT_ref (a
) : NULL
;
7601 static inline struct dwarf_file_data
*
7602 get_AT_file (dw_die_ref die
, enum dwarf_attribute attr_kind
)
7604 dw_attr_ref a
= get_AT (die
, attr_kind
);
7606 return a
? AT_file (a
) : NULL
;
7609 /* Return TRUE if the language is C++. */
7614 unsigned int lang
= get_AT_unsigned (comp_unit_die
, DW_AT_language
);
7616 return lang
== DW_LANG_C_plus_plus
|| lang
== DW_LANG_ObjC_plus_plus
;
7619 /* Return TRUE if the language is Fortran. */
7624 unsigned int lang
= get_AT_unsigned (comp_unit_die
, DW_AT_language
);
7626 return (lang
== DW_LANG_Fortran77
7627 || lang
== DW_LANG_Fortran90
7628 || lang
== DW_LANG_Fortran95
);
7631 /* Return TRUE if the language is Ada. */
7636 unsigned int lang
= get_AT_unsigned (comp_unit_die
, DW_AT_language
);
7638 return lang
== DW_LANG_Ada95
|| lang
== DW_LANG_Ada83
;
7641 /* Remove the specified attribute if present. */
7644 remove_AT (dw_die_ref die
, enum dwarf_attribute attr_kind
)
7652 for (ix
= 0; VEC_iterate (dw_attr_node
, die
->die_attr
, ix
, a
); ix
++)
7653 if (a
->dw_attr
== attr_kind
)
7655 if (AT_class (a
) == dw_val_class_str
)
7656 if (a
->dw_attr_val
.v
.val_str
->refcount
)
7657 a
->dw_attr_val
.v
.val_str
->refcount
--;
7659 /* VEC_ordered_remove should help reduce the number of abbrevs
7661 VEC_ordered_remove (dw_attr_node
, die
->die_attr
, ix
);
7666 /* Remove CHILD from its parent. PREV must have the property that
7667 PREV->DIE_SIB == CHILD. Does not alter CHILD. */
7670 remove_child_with_prev (dw_die_ref child
, dw_die_ref prev
)
7672 gcc_assert (child
->die_parent
== prev
->die_parent
);
7673 gcc_assert (prev
->die_sib
== child
);
7676 gcc_assert (child
->die_parent
->die_child
== child
);
7680 prev
->die_sib
= child
->die_sib
;
7681 if (child
->die_parent
->die_child
== child
)
7682 child
->die_parent
->die_child
= prev
;
7685 /* Replace OLD_CHILD with NEW_CHILD. PREV must have the property that
7686 PREV->DIE_SIB == OLD_CHILD. Does not alter OLD_CHILD. */
7689 replace_child (dw_die_ref old_child
, dw_die_ref new_child
, dw_die_ref prev
)
7691 dw_die_ref parent
= old_child
->die_parent
;
7693 gcc_assert (parent
== prev
->die_parent
);
7694 gcc_assert (prev
->die_sib
== old_child
);
7696 new_child
->die_parent
= parent
;
7697 if (prev
== old_child
)
7699 gcc_assert (parent
->die_child
== old_child
);
7700 new_child
->die_sib
= new_child
;
7704 prev
->die_sib
= new_child
;
7705 new_child
->die_sib
= old_child
->die_sib
;
7707 if (old_child
->die_parent
->die_child
== old_child
)
7708 old_child
->die_parent
->die_child
= new_child
;
7711 /* Move all children from OLD_PARENT to NEW_PARENT. */
7714 move_all_children (dw_die_ref old_parent
, dw_die_ref new_parent
)
7717 new_parent
->die_child
= old_parent
->die_child
;
7718 old_parent
->die_child
= NULL
;
7719 FOR_EACH_CHILD (new_parent
, c
, c
->die_parent
= new_parent
);
7722 /* Remove child DIE whose die_tag is TAG. Do nothing if no child
7726 remove_child_TAG (dw_die_ref die
, enum dwarf_tag tag
)
7732 dw_die_ref prev
= c
;
7734 while (c
->die_tag
== tag
)
7736 remove_child_with_prev (c
, prev
);
7737 /* Might have removed every child. */
7738 if (c
== c
->die_sib
)
7742 } while (c
!= die
->die_child
);
7745 /* Add a CHILD_DIE as the last child of DIE. */
7748 add_child_die (dw_die_ref die
, dw_die_ref child_die
)
7750 /* FIXME this should probably be an assert. */
7751 if (! die
|| ! child_die
)
7753 gcc_assert (die
!= child_die
);
7755 child_die
->die_parent
= die
;
7758 child_die
->die_sib
= die
->die_child
->die_sib
;
7759 die
->die_child
->die_sib
= child_die
;
7762 child_die
->die_sib
= child_die
;
7763 die
->die_child
= child_die
;
7766 /* Move CHILD, which must be a child of PARENT or the DIE for which PARENT
7767 is the specification, to the end of PARENT's list of children.
7768 This is done by removing and re-adding it. */
7771 splice_child_die (dw_die_ref parent
, dw_die_ref child
)
7775 /* We want the declaration DIE from inside the class, not the
7776 specification DIE at toplevel. */
7777 if (child
->die_parent
!= parent
)
7779 dw_die_ref tmp
= get_AT_ref (child
, DW_AT_specification
);
7785 gcc_assert (child
->die_parent
== parent
7786 || (child
->die_parent
7787 == get_AT_ref (parent
, DW_AT_specification
)));
7789 for (p
= child
->die_parent
->die_child
; ; p
= p
->die_sib
)
7790 if (p
->die_sib
== child
)
7792 remove_child_with_prev (child
, p
);
7796 add_child_die (parent
, child
);
7799 /* Return a pointer to a newly created DIE node. */
7801 static inline dw_die_ref
7802 new_die (enum dwarf_tag tag_value
, dw_die_ref parent_die
, tree t
)
7804 dw_die_ref die
= ggc_alloc_cleared_die_node ();
7806 die
->die_tag
= tag_value
;
7808 if (parent_die
!= NULL
)
7809 add_child_die (parent_die
, die
);
7812 limbo_die_node
*limbo_node
;
7814 limbo_node
= ggc_alloc_cleared_limbo_die_node ();
7815 limbo_node
->die
= die
;
7816 limbo_node
->created_for
= t
;
7817 limbo_node
->next
= limbo_die_list
;
7818 limbo_die_list
= limbo_node
;
7824 /* Return the DIE associated with the given type specifier. */
7826 static inline dw_die_ref
7827 lookup_type_die (tree type
)
7829 return TYPE_SYMTAB_DIE (type
);
7832 /* Equate a DIE to a given type specifier. */
7835 equate_type_number_to_die (tree type
, dw_die_ref type_die
)
7837 TYPE_SYMTAB_DIE (type
) = type_die
;
7840 /* Returns a hash value for X (which really is a die_struct). */
7843 decl_die_table_hash (const void *x
)
7845 return (hashval_t
) ((const_dw_die_ref
) x
)->decl_id
;
7848 /* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y. */
7851 decl_die_table_eq (const void *x
, const void *y
)
7853 return (((const_dw_die_ref
) x
)->decl_id
== DECL_UID ((const_tree
) y
));
7856 /* Return the DIE associated with a given declaration. */
7858 static inline dw_die_ref
7859 lookup_decl_die (tree decl
)
7861 return (dw_die_ref
) htab_find_with_hash (decl_die_table
, decl
, DECL_UID (decl
));
7864 /* Returns a hash value for X (which really is a var_loc_list). */
7867 decl_loc_table_hash (const void *x
)
7869 return (hashval_t
) ((const var_loc_list
*) x
)->decl_id
;
7872 /* Return nonzero if decl_id of var_loc_list X is the same as
7876 decl_loc_table_eq (const void *x
, const void *y
)
7878 return (((const var_loc_list
*) x
)->decl_id
== DECL_UID ((const_tree
) y
));
7881 /* Return the var_loc list associated with a given declaration. */
7883 static inline var_loc_list
*
7884 lookup_decl_loc (const_tree decl
)
7886 if (!decl_loc_table
)
7888 return (var_loc_list
*)
7889 htab_find_with_hash (decl_loc_table
, decl
, DECL_UID (decl
));
7892 /* Equate a DIE to a particular declaration. */
7895 equate_decl_number_to_die (tree decl
, dw_die_ref decl_die
)
7897 unsigned int decl_id
= DECL_UID (decl
);
7900 slot
= htab_find_slot_with_hash (decl_die_table
, decl
, decl_id
, INSERT
);
7902 decl_die
->decl_id
= decl_id
;
7905 /* Return how many bits covers PIECE EXPR_LIST. */
7908 decl_piece_bitsize (rtx piece
)
7910 int ret
= (int) GET_MODE (piece
);
7913 gcc_assert (GET_CODE (XEXP (piece
, 0)) == CONCAT
7914 && CONST_INT_P (XEXP (XEXP (piece
, 0), 0)));
7915 return INTVAL (XEXP (XEXP (piece
, 0), 0));
7918 /* Return pointer to the location of location note in PIECE EXPR_LIST. */
7921 decl_piece_varloc_ptr (rtx piece
)
7923 if ((int) GET_MODE (piece
))
7924 return &XEXP (piece
, 0);
7926 return &XEXP (XEXP (piece
, 0), 1);
7929 /* Create an EXPR_LIST for location note LOC_NOTE covering BITSIZE bits.
7930 Next is the chain of following piece nodes. */
7933 decl_piece_node (rtx loc_note
, HOST_WIDE_INT bitsize
, rtx next
)
7935 if (bitsize
<= (int) MAX_MACHINE_MODE
)
7936 return alloc_EXPR_LIST (bitsize
, loc_note
, next
);
7938 return alloc_EXPR_LIST (0, gen_rtx_CONCAT (VOIDmode
,
7943 /* Return rtx that should be stored into loc field for
7944 LOC_NOTE and BITPOS/BITSIZE. */
7947 construct_piece_list (rtx loc_note
, HOST_WIDE_INT bitpos
,
7948 HOST_WIDE_INT bitsize
)
7952 loc_note
= decl_piece_node (loc_note
, bitsize
, NULL_RTX
);
7954 loc_note
= decl_piece_node (NULL_RTX
, bitpos
, loc_note
);
7959 /* This function either modifies location piece list *DEST in
7960 place (if SRC and INNER is NULL), or copies location piece list
7961 *SRC to *DEST while modifying it. Location BITPOS is modified
7962 to contain LOC_NOTE, any pieces overlapping it are removed resp.
7963 not copied and if needed some padding around it is added.
7964 When modifying in place, DEST should point to EXPR_LIST where
7965 earlier pieces cover PIECE_BITPOS bits, when copying SRC points
7966 to the start of the whole list and INNER points to the EXPR_LIST
7967 where earlier pieces cover PIECE_BITPOS bits. */
7970 adjust_piece_list (rtx
*dest
, rtx
*src
, rtx
*inner
,
7971 HOST_WIDE_INT bitpos
, HOST_WIDE_INT piece_bitpos
,
7972 HOST_WIDE_INT bitsize
, rtx loc_note
)
7975 bool copy
= inner
!= NULL
;
7979 /* First copy all nodes preceeding the current bitpos. */
7980 while (src
!= inner
)
7982 *dest
= decl_piece_node (*decl_piece_varloc_ptr (*src
),
7983 decl_piece_bitsize (*src
), NULL_RTX
);
7984 dest
= &XEXP (*dest
, 1);
7985 src
= &XEXP (*src
, 1);
7988 /* Add padding if needed. */
7989 if (bitpos
!= piece_bitpos
)
7991 *dest
= decl_piece_node (NULL_RTX
, bitpos
- piece_bitpos
,
7992 copy
? NULL_RTX
: *dest
);
7993 dest
= &XEXP (*dest
, 1);
7995 else if (*dest
&& decl_piece_bitsize (*dest
) == bitsize
)
7998 /* A piece with correct bitpos and bitsize already exist,
7999 just update the location for it and return. */
8000 *decl_piece_varloc_ptr (*dest
) = loc_note
;
8003 /* Add the piece that changed. */
8004 *dest
= decl_piece_node (loc_note
, bitsize
, copy
? NULL_RTX
: *dest
);
8005 dest
= &XEXP (*dest
, 1);
8006 /* Skip over pieces that overlap it. */
8007 diff
= bitpos
- piece_bitpos
+ bitsize
;
8010 while (diff
> 0 && *src
)
8013 diff
-= decl_piece_bitsize (piece
);
8015 src
= &XEXP (piece
, 1);
8018 *src
= XEXP (piece
, 1);
8019 free_EXPR_LIST_node (piece
);
8022 /* Add padding if needed. */
8023 if (diff
< 0 && *src
)
8027 *dest
= decl_piece_node (NULL_RTX
, -diff
, copy
? NULL_RTX
: *dest
);
8028 dest
= &XEXP (*dest
, 1);
8032 /* Finally copy all nodes following it. */
8035 *dest
= decl_piece_node (*decl_piece_varloc_ptr (*src
),
8036 decl_piece_bitsize (*src
), NULL_RTX
);
8037 dest
= &XEXP (*dest
, 1);
8038 src
= &XEXP (*src
, 1);
8042 /* Add a variable location node to the linked list for DECL. */
8044 static struct var_loc_node
*
8045 add_var_loc_to_decl (tree decl
, rtx loc_note
, const char *label
)
8047 unsigned int decl_id
;
8050 struct var_loc_node
*loc
= NULL
;
8051 HOST_WIDE_INT bitsize
= -1, bitpos
= -1;
8053 if (DECL_DEBUG_EXPR_IS_FROM (decl
))
8055 tree realdecl
= DECL_DEBUG_EXPR (decl
);
8056 if (realdecl
&& handled_component_p (realdecl
))
8058 HOST_WIDE_INT maxsize
;
8061 = get_ref_base_and_extent (realdecl
, &bitpos
, &bitsize
, &maxsize
);
8062 if (!DECL_P (innerdecl
)
8063 || DECL_IGNORED_P (innerdecl
)
8064 || TREE_STATIC (innerdecl
)
8066 || bitpos
+ bitsize
> 256
8067 || bitsize
!= maxsize
)
8073 decl_id
= DECL_UID (decl
);
8074 slot
= htab_find_slot_with_hash (decl_loc_table
, decl
, decl_id
, INSERT
);
8077 temp
= ggc_alloc_cleared_var_loc_list ();
8078 temp
->decl_id
= decl_id
;
8082 temp
= (var_loc_list
*) *slot
;
8086 struct var_loc_node
*last
= temp
->last
, *unused
= NULL
;
8087 rtx
*piece_loc
= NULL
, last_loc_note
;
8088 int piece_bitpos
= 0;
8092 gcc_assert (last
->next
== NULL
);
8094 if (bitsize
!= -1 && GET_CODE (last
->loc
) == EXPR_LIST
)
8096 piece_loc
= &last
->loc
;
8099 int cur_bitsize
= decl_piece_bitsize (*piece_loc
);
8100 if (piece_bitpos
+ cur_bitsize
> bitpos
)
8102 piece_bitpos
+= cur_bitsize
;
8103 piece_loc
= &XEXP (*piece_loc
, 1);
8107 /* TEMP->LAST here is either pointer to the last but one or
8108 last element in the chained list, LAST is pointer to the
8110 if (label
&& strcmp (last
->label
, label
) == 0)
8112 /* For SRA optimized variables if there weren't any real
8113 insns since last note, just modify the last node. */
8114 if (piece_loc
!= NULL
)
8116 adjust_piece_list (piece_loc
, NULL
, NULL
,
8117 bitpos
, piece_bitpos
, bitsize
, loc_note
);
8120 /* If the last note doesn't cover any instructions, remove it. */
8121 if (temp
->last
!= last
)
8123 temp
->last
->next
= NULL
;
8126 gcc_assert (strcmp (last
->label
, label
) != 0);
8130 gcc_assert (temp
->first
== temp
->last
);
8131 memset (temp
->last
, '\0', sizeof (*temp
->last
));
8132 temp
->last
->loc
= construct_piece_list (loc_note
, bitpos
, bitsize
);
8136 if (bitsize
== -1 && NOTE_P (last
->loc
))
8137 last_loc_note
= last
->loc
;
8138 else if (piece_loc
!= NULL
8139 && *piece_loc
!= NULL_RTX
8140 && piece_bitpos
== bitpos
8141 && decl_piece_bitsize (*piece_loc
) == bitsize
)
8142 last_loc_note
= *decl_piece_varloc_ptr (*piece_loc
);
8144 last_loc_note
= NULL_RTX
;
8145 /* If the current location is the same as the end of the list,
8146 and either both or neither of the locations is uninitialized,
8147 we have nothing to do. */
8148 if (last_loc_note
== NULL_RTX
8149 || (!rtx_equal_p (NOTE_VAR_LOCATION_LOC (last_loc_note
),
8150 NOTE_VAR_LOCATION_LOC (loc_note
)))
8151 || ((NOTE_VAR_LOCATION_STATUS (last_loc_note
)
8152 != NOTE_VAR_LOCATION_STATUS (loc_note
))
8153 && ((NOTE_VAR_LOCATION_STATUS (last_loc_note
)
8154 == VAR_INIT_STATUS_UNINITIALIZED
)
8155 || (NOTE_VAR_LOCATION_STATUS (loc_note
)
8156 == VAR_INIT_STATUS_UNINITIALIZED
))))
8158 /* Add LOC to the end of list and update LAST. If the last
8159 element of the list has been removed above, reuse its
8160 memory for the new node, otherwise allocate a new one. */
8164 memset (loc
, '\0', sizeof (*loc
));
8167 loc
= ggc_alloc_cleared_var_loc_node ();
8168 if (bitsize
== -1 || piece_loc
== NULL
)
8169 loc
->loc
= construct_piece_list (loc_note
, bitpos
, bitsize
);
8171 adjust_piece_list (&loc
->loc
, &last
->loc
, piece_loc
,
8172 bitpos
, piece_bitpos
, bitsize
, loc_note
);
8174 /* Ensure TEMP->LAST will point either to the new last but one
8175 element of the chain, or to the last element in it. */
8176 if (last
!= temp
->last
)
8184 loc
= ggc_alloc_cleared_var_loc_node ();
8187 loc
->loc
= construct_piece_list (loc_note
, bitpos
, bitsize
);
8192 /* Keep track of the number of spaces used to indent the
8193 output of the debugging routines that print the structure of
8194 the DIE internal representation. */
8195 static int print_indent
;
8197 /* Indent the line the number of spaces given by print_indent. */
8200 print_spaces (FILE *outfile
)
8202 fprintf (outfile
, "%*s", print_indent
, "");
8205 /* Print a type signature in hex. */
8208 print_signature (FILE *outfile
, char *sig
)
8212 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
8213 fprintf (outfile
, "%02x", sig
[i
] & 0xff);
8216 /* Print the information associated with a given DIE, and its children.
8217 This routine is a debugging aid only. */
8220 print_die (dw_die_ref die
, FILE *outfile
)
8226 print_spaces (outfile
);
8227 fprintf (outfile
, "DIE %4ld: %s\n",
8228 die
->die_offset
, dwarf_tag_name (die
->die_tag
));
8229 print_spaces (outfile
);
8230 fprintf (outfile
, " abbrev id: %lu", die
->die_abbrev
);
8231 fprintf (outfile
, " offset: %ld\n", die
->die_offset
);
8232 if (dwarf_version
>= 4 && die
->die_id
.die_type_node
)
8234 print_spaces (outfile
);
8235 fprintf (outfile
, " signature: ");
8236 print_signature (outfile
, die
->die_id
.die_type_node
->signature
);
8237 fprintf (outfile
, "\n");
8240 for (ix
= 0; VEC_iterate (dw_attr_node
, die
->die_attr
, ix
, a
); ix
++)
8242 print_spaces (outfile
);
8243 fprintf (outfile
, " %s: ", dwarf_attr_name (a
->dw_attr
));
8245 switch (AT_class (a
))
8247 case dw_val_class_addr
:
8248 fprintf (outfile
, "address");
8250 case dw_val_class_offset
:
8251 fprintf (outfile
, "offset");
8253 case dw_val_class_loc
:
8254 fprintf (outfile
, "location descriptor");
8256 case dw_val_class_loc_list
:
8257 fprintf (outfile
, "location list -> label:%s",
8258 AT_loc_list (a
)->ll_symbol
);
8260 case dw_val_class_range_list
:
8261 fprintf (outfile
, "range list");
8263 case dw_val_class_const
:
8264 fprintf (outfile
, HOST_WIDE_INT_PRINT_DEC
, AT_int (a
));
8266 case dw_val_class_unsigned_const
:
8267 fprintf (outfile
, HOST_WIDE_INT_PRINT_UNSIGNED
, AT_unsigned (a
));
8269 case dw_val_class_const_double
:
8270 fprintf (outfile
, "constant ("HOST_WIDE_INT_PRINT_DEC
","\
8271 HOST_WIDE_INT_PRINT_UNSIGNED
")",
8272 a
->dw_attr_val
.v
.val_double
.high
,
8273 a
->dw_attr_val
.v
.val_double
.low
);
8275 case dw_val_class_vec
:
8276 fprintf (outfile
, "floating-point or vector constant");
8278 case dw_val_class_flag
:
8279 fprintf (outfile
, "%u", AT_flag (a
));
8281 case dw_val_class_die_ref
:
8282 if (AT_ref (a
) != NULL
)
8284 if (dwarf_version
>= 4 && AT_ref (a
)->die_id
.die_type_node
)
8286 fprintf (outfile
, "die -> signature: ");
8287 print_signature (outfile
,
8288 AT_ref (a
)->die_id
.die_type_node
->signature
);
8290 else if (dwarf_version
< 4 && AT_ref (a
)->die_id
.die_symbol
)
8291 fprintf (outfile
, "die -> label: %s",
8292 AT_ref (a
)->die_id
.die_symbol
);
8294 fprintf (outfile
, "die -> %ld", AT_ref (a
)->die_offset
);
8297 fprintf (outfile
, "die -> <null>");
8299 case dw_val_class_vms_delta
:
8300 fprintf (outfile
, "delta: @slotcount(%s-%s)",
8301 AT_vms_delta2 (a
), AT_vms_delta1 (a
));
8303 case dw_val_class_lbl_id
:
8304 case dw_val_class_lineptr
:
8305 case dw_val_class_macptr
:
8306 fprintf (outfile
, "label: %s", AT_lbl (a
));
8308 case dw_val_class_str
:
8309 if (AT_string (a
) != NULL
)
8310 fprintf (outfile
, "\"%s\"", AT_string (a
));
8312 fprintf (outfile
, "<null>");
8314 case dw_val_class_file
:
8315 fprintf (outfile
, "\"%s\" (%d)", AT_file (a
)->filename
,
8316 AT_file (a
)->emitted_number
);
8318 case dw_val_class_data8
:
8322 for (i
= 0; i
< 8; i
++)
8323 fprintf (outfile
, "%02x", a
->dw_attr_val
.v
.val_data8
[i
]);
8330 fprintf (outfile
, "\n");
8333 if (die
->die_child
!= NULL
)
8336 FOR_EACH_CHILD (die
, c
, print_die (c
, outfile
));
8339 if (print_indent
== 0)
8340 fprintf (outfile
, "\n");
8343 /* Print the contents of the source code line number correspondence table.
8344 This routine is a debugging aid only. */
8347 print_dwarf_line_table (FILE *outfile
)
8350 dw_line_info_ref line_info
;
8352 fprintf (outfile
, "\n\nDWARF source line information\n");
8353 for (i
= 1; i
< line_info_table_in_use
; i
++)
8355 line_info
= &line_info_table
[i
];
8356 fprintf (outfile
, "%5d: %4ld %6ld\n", i
,
8357 line_info
->dw_file_num
,
8358 line_info
->dw_line_num
);
8361 fprintf (outfile
, "\n\n");
8364 /* Print the information collected for a given DIE. */
8367 debug_dwarf_die (dw_die_ref die
)
8369 print_die (die
, stderr
);
8372 /* Print all DWARF information collected for the compilation unit.
8373 This routine is a debugging aid only. */
8379 print_die (comp_unit_die
, stderr
);
8380 if (! DWARF2_ASM_LINE_DEBUG_INFO
)
8381 print_dwarf_line_table (stderr
);
8384 /* Start a new compilation unit DIE for an include file. OLD_UNIT is the CU
8385 for the enclosing include file, if any. BINCL_DIE is the DW_TAG_GNU_BINCL
8386 DIE that marks the start of the DIEs for this include file. */
8389 push_new_compile_unit (dw_die_ref old_unit
, dw_die_ref bincl_die
)
8391 const char *filename
= get_AT_string (bincl_die
, DW_AT_name
);
8392 dw_die_ref new_unit
= gen_compile_unit_die (filename
);
8394 new_unit
->die_sib
= old_unit
;
8398 /* Close an include-file CU and reopen the enclosing one. */
8401 pop_compile_unit (dw_die_ref old_unit
)
8403 dw_die_ref new_unit
= old_unit
->die_sib
;
8405 old_unit
->die_sib
= NULL
;
8409 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
8410 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO), ctx)
8412 /* Calculate the checksum of a location expression. */
8415 loc_checksum (dw_loc_descr_ref loc
, struct md5_ctx
*ctx
)
8419 tem
= (loc
->dtprel
<< 8) | ((unsigned int) loc
->dw_loc_opc
);
8421 CHECKSUM (loc
->dw_loc_oprnd1
);
8422 CHECKSUM (loc
->dw_loc_oprnd2
);
8425 /* Calculate the checksum of an attribute. */
8428 attr_checksum (dw_attr_ref at
, struct md5_ctx
*ctx
, int *mark
)
8430 dw_loc_descr_ref loc
;
8433 CHECKSUM (at
->dw_attr
);
8435 /* We don't care that this was compiled with a different compiler
8436 snapshot; if the output is the same, that's what matters. */
8437 if (at
->dw_attr
== DW_AT_producer
)
8440 switch (AT_class (at
))
8442 case dw_val_class_const
:
8443 CHECKSUM (at
->dw_attr_val
.v
.val_int
);
8445 case dw_val_class_unsigned_const
:
8446 CHECKSUM (at
->dw_attr_val
.v
.val_unsigned
);
8448 case dw_val_class_const_double
:
8449 CHECKSUM (at
->dw_attr_val
.v
.val_double
);
8451 case dw_val_class_vec
:
8452 CHECKSUM (at
->dw_attr_val
.v
.val_vec
);
8454 case dw_val_class_flag
:
8455 CHECKSUM (at
->dw_attr_val
.v
.val_flag
);
8457 case dw_val_class_str
:
8458 CHECKSUM_STRING (AT_string (at
));
8461 case dw_val_class_addr
:
8463 gcc_assert (GET_CODE (r
) == SYMBOL_REF
);
8464 CHECKSUM_STRING (XSTR (r
, 0));
8467 case dw_val_class_offset
:
8468 CHECKSUM (at
->dw_attr_val
.v
.val_offset
);
8471 case dw_val_class_loc
:
8472 for (loc
= AT_loc (at
); loc
; loc
= loc
->dw_loc_next
)
8473 loc_checksum (loc
, ctx
);
8476 case dw_val_class_die_ref
:
8477 die_checksum (AT_ref (at
), ctx
, mark
);
8480 case dw_val_class_fde_ref
:
8481 case dw_val_class_vms_delta
:
8482 case dw_val_class_lbl_id
:
8483 case dw_val_class_lineptr
:
8484 case dw_val_class_macptr
:
8487 case dw_val_class_file
:
8488 CHECKSUM_STRING (AT_file (at
)->filename
);
8491 case dw_val_class_data8
:
8492 CHECKSUM (at
->dw_attr_val
.v
.val_data8
);
8500 /* Calculate the checksum of a DIE. */
8503 die_checksum (dw_die_ref die
, struct md5_ctx
*ctx
, int *mark
)
8509 /* To avoid infinite recursion. */
8512 CHECKSUM (die
->die_mark
);
8515 die
->die_mark
= ++(*mark
);
8517 CHECKSUM (die
->die_tag
);
8519 for (ix
= 0; VEC_iterate (dw_attr_node
, die
->die_attr
, ix
, a
); ix
++)
8520 attr_checksum (a
, ctx
, mark
);
8522 FOR_EACH_CHILD (die
, c
, die_checksum (c
, ctx
, mark
));
8526 #undef CHECKSUM_STRING
8528 /* For DWARF-4 types, include the trailing NULL when checksumming strings. */
8529 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
8530 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO) + 1, ctx)
8531 #define CHECKSUM_SLEB128(FOO) checksum_sleb128 ((FOO), ctx)
8532 #define CHECKSUM_ULEB128(FOO) checksum_uleb128 ((FOO), ctx)
8533 #define CHECKSUM_ATTR(FOO) \
8534 if (FOO) attr_checksum_ordered (die->die_tag, (FOO), ctx, mark)
8536 /* Calculate the checksum of a number in signed LEB128 format. */
8539 checksum_sleb128 (HOST_WIDE_INT value
, struct md5_ctx
*ctx
)
8546 byte
= (value
& 0x7f);
8548 more
= !((value
== 0 && (byte
& 0x40) == 0)
8549 || (value
== -1 && (byte
& 0x40) != 0));
8558 /* Calculate the checksum of a number in unsigned LEB128 format. */
8561 checksum_uleb128 (unsigned HOST_WIDE_INT value
, struct md5_ctx
*ctx
)
8565 unsigned char byte
= (value
& 0x7f);
8568 /* More bytes to follow. */
8576 /* Checksum the context of the DIE. This adds the names of any
8577 surrounding namespaces or structures to the checksum. */
8580 checksum_die_context (dw_die_ref die
, struct md5_ctx
*ctx
)
8584 int tag
= die
->die_tag
;
8586 if (tag
!= DW_TAG_namespace
8587 && tag
!= DW_TAG_structure_type
8588 && tag
!= DW_TAG_class_type
)
8591 name
= get_AT_string (die
, DW_AT_name
);
8593 spec
= get_AT_ref (die
, DW_AT_specification
);
8597 if (die
->die_parent
!= NULL
)
8598 checksum_die_context (die
->die_parent
, ctx
);
8600 CHECKSUM_ULEB128 ('C');
8601 CHECKSUM_ULEB128 (tag
);
8603 CHECKSUM_STRING (name
);
8606 /* Calculate the checksum of a location expression. */
8609 loc_checksum_ordered (dw_loc_descr_ref loc
, struct md5_ctx
*ctx
)
8611 /* Special case for lone DW_OP_plus_uconst: checksum as if the location
8612 were emitted as a DW_FORM_sdata instead of a location expression. */
8613 if (loc
->dw_loc_opc
== DW_OP_plus_uconst
&& loc
->dw_loc_next
== NULL
)
8615 CHECKSUM_ULEB128 (DW_FORM_sdata
);
8616 CHECKSUM_SLEB128 ((HOST_WIDE_INT
) loc
->dw_loc_oprnd1
.v
.val_unsigned
);
8620 /* Otherwise, just checksum the raw location expression. */
8623 CHECKSUM_ULEB128 (loc
->dw_loc_opc
);
8624 CHECKSUM (loc
->dw_loc_oprnd1
);
8625 CHECKSUM (loc
->dw_loc_oprnd2
);
8626 loc
= loc
->dw_loc_next
;
8630 /* Calculate the checksum of an attribute. */
8633 attr_checksum_ordered (enum dwarf_tag tag
, dw_attr_ref at
,
8634 struct md5_ctx
*ctx
, int *mark
)
8636 dw_loc_descr_ref loc
;
8639 if (AT_class (at
) == dw_val_class_die_ref
)
8641 dw_die_ref target_die
= AT_ref (at
);
8643 /* For pointer and reference types, we checksum only the (qualified)
8644 name of the target type (if there is a name). For friend entries,
8645 we checksum only the (qualified) name of the target type or function.
8646 This allows the checksum to remain the same whether the target type
8647 is complete or not. */
8648 if ((at
->dw_attr
== DW_AT_type
8649 && (tag
== DW_TAG_pointer_type
8650 || tag
== DW_TAG_reference_type
8651 || tag
== DW_TAG_rvalue_reference_type
8652 || tag
== DW_TAG_ptr_to_member_type
))
8653 || (at
->dw_attr
== DW_AT_friend
8654 && tag
== DW_TAG_friend
))
8656 dw_attr_ref name_attr
= get_AT (target_die
, DW_AT_name
);
8658 if (name_attr
!= NULL
)
8660 dw_die_ref decl
= get_AT_ref (target_die
, DW_AT_specification
);
8664 CHECKSUM_ULEB128 ('N');
8665 CHECKSUM_ULEB128 (at
->dw_attr
);
8666 if (decl
->die_parent
!= NULL
)
8667 checksum_die_context (decl
->die_parent
, ctx
);
8668 CHECKSUM_ULEB128 ('E');
8669 CHECKSUM_STRING (AT_string (name_attr
));
8674 /* For all other references to another DIE, we check to see if the
8675 target DIE has already been visited. If it has, we emit a
8676 backward reference; if not, we descend recursively. */
8677 if (target_die
->die_mark
> 0)
8679 CHECKSUM_ULEB128 ('R');
8680 CHECKSUM_ULEB128 (at
->dw_attr
);
8681 CHECKSUM_ULEB128 (target_die
->die_mark
);
8685 dw_die_ref decl
= get_AT_ref (target_die
, DW_AT_specification
);
8689 target_die
->die_mark
= ++(*mark
);
8690 CHECKSUM_ULEB128 ('T');
8691 CHECKSUM_ULEB128 (at
->dw_attr
);
8692 if (decl
->die_parent
!= NULL
)
8693 checksum_die_context (decl
->die_parent
, ctx
);
8694 die_checksum_ordered (target_die
, ctx
, mark
);
8699 CHECKSUM_ULEB128 ('A');
8700 CHECKSUM_ULEB128 (at
->dw_attr
);
8702 switch (AT_class (at
))
8704 case dw_val_class_const
:
8705 CHECKSUM_ULEB128 (DW_FORM_sdata
);
8706 CHECKSUM_SLEB128 (at
->dw_attr_val
.v
.val_int
);
8709 case dw_val_class_unsigned_const
:
8710 CHECKSUM_ULEB128 (DW_FORM_sdata
);
8711 CHECKSUM_SLEB128 ((int) at
->dw_attr_val
.v
.val_unsigned
);
8714 case dw_val_class_const_double
:
8715 CHECKSUM_ULEB128 (DW_FORM_block
);
8716 CHECKSUM_ULEB128 (sizeof (at
->dw_attr_val
.v
.val_double
));
8717 CHECKSUM (at
->dw_attr_val
.v
.val_double
);
8720 case dw_val_class_vec
:
8721 CHECKSUM_ULEB128 (DW_FORM_block
);
8722 CHECKSUM_ULEB128 (sizeof (at
->dw_attr_val
.v
.val_vec
));
8723 CHECKSUM (at
->dw_attr_val
.v
.val_vec
);
8726 case dw_val_class_flag
:
8727 CHECKSUM_ULEB128 (DW_FORM_flag
);
8728 CHECKSUM_ULEB128 (at
->dw_attr_val
.v
.val_flag
? 1 : 0);
8731 case dw_val_class_str
:
8732 CHECKSUM_ULEB128 (DW_FORM_string
);
8733 CHECKSUM_STRING (AT_string (at
));
8736 case dw_val_class_addr
:
8738 gcc_assert (GET_CODE (r
) == SYMBOL_REF
);
8739 CHECKSUM_ULEB128 (DW_FORM_string
);
8740 CHECKSUM_STRING (XSTR (r
, 0));
8743 case dw_val_class_offset
:
8744 CHECKSUM_ULEB128 (DW_FORM_sdata
);
8745 CHECKSUM_ULEB128 (at
->dw_attr_val
.v
.val_offset
);
8748 case dw_val_class_loc
:
8749 for (loc
= AT_loc (at
); loc
; loc
= loc
->dw_loc_next
)
8750 loc_checksum_ordered (loc
, ctx
);
8753 case dw_val_class_fde_ref
:
8754 case dw_val_class_lbl_id
:
8755 case dw_val_class_lineptr
:
8756 case dw_val_class_macptr
:
8759 case dw_val_class_file
:
8760 CHECKSUM_ULEB128 (DW_FORM_string
);
8761 CHECKSUM_STRING (AT_file (at
)->filename
);
8764 case dw_val_class_data8
:
8765 CHECKSUM (at
->dw_attr_val
.v
.val_data8
);
8773 struct checksum_attributes
8775 dw_attr_ref at_name
;
8776 dw_attr_ref at_type
;
8777 dw_attr_ref at_friend
;
8778 dw_attr_ref at_accessibility
;
8779 dw_attr_ref at_address_class
;
8780 dw_attr_ref at_allocated
;
8781 dw_attr_ref at_artificial
;
8782 dw_attr_ref at_associated
;
8783 dw_attr_ref at_binary_scale
;
8784 dw_attr_ref at_bit_offset
;
8785 dw_attr_ref at_bit_size
;
8786 dw_attr_ref at_bit_stride
;
8787 dw_attr_ref at_byte_size
;
8788 dw_attr_ref at_byte_stride
;
8789 dw_attr_ref at_const_value
;
8790 dw_attr_ref at_containing_type
;
8791 dw_attr_ref at_count
;
8792 dw_attr_ref at_data_location
;
8793 dw_attr_ref at_data_member_location
;
8794 dw_attr_ref at_decimal_scale
;
8795 dw_attr_ref at_decimal_sign
;
8796 dw_attr_ref at_default_value
;
8797 dw_attr_ref at_digit_count
;
8798 dw_attr_ref at_discr
;
8799 dw_attr_ref at_discr_list
;
8800 dw_attr_ref at_discr_value
;
8801 dw_attr_ref at_encoding
;
8802 dw_attr_ref at_endianity
;
8803 dw_attr_ref at_explicit
;
8804 dw_attr_ref at_is_optional
;
8805 dw_attr_ref at_location
;
8806 dw_attr_ref at_lower_bound
;
8807 dw_attr_ref at_mutable
;
8808 dw_attr_ref at_ordering
;
8809 dw_attr_ref at_picture_string
;
8810 dw_attr_ref at_prototyped
;
8811 dw_attr_ref at_small
;
8812 dw_attr_ref at_segment
;
8813 dw_attr_ref at_string_length
;
8814 dw_attr_ref at_threads_scaled
;
8815 dw_attr_ref at_upper_bound
;
8816 dw_attr_ref at_use_location
;
8817 dw_attr_ref at_use_UTF8
;
8818 dw_attr_ref at_variable_parameter
;
8819 dw_attr_ref at_virtuality
;
8820 dw_attr_ref at_visibility
;
8821 dw_attr_ref at_vtable_elem_location
;
8824 /* Collect the attributes that we will want to use for the checksum. */
8827 collect_checksum_attributes (struct checksum_attributes
*attrs
, dw_die_ref die
)
8832 for (ix
= 0; VEC_iterate (dw_attr_node
, die
->die_attr
, ix
, a
); ix
++)
8843 attrs
->at_friend
= a
;
8845 case DW_AT_accessibility
:
8846 attrs
->at_accessibility
= a
;
8848 case DW_AT_address_class
:
8849 attrs
->at_address_class
= a
;
8851 case DW_AT_allocated
:
8852 attrs
->at_allocated
= a
;
8854 case DW_AT_artificial
:
8855 attrs
->at_artificial
= a
;
8857 case DW_AT_associated
:
8858 attrs
->at_associated
= a
;
8860 case DW_AT_binary_scale
:
8861 attrs
->at_binary_scale
= a
;
8863 case DW_AT_bit_offset
:
8864 attrs
->at_bit_offset
= a
;
8866 case DW_AT_bit_size
:
8867 attrs
->at_bit_size
= a
;
8869 case DW_AT_bit_stride
:
8870 attrs
->at_bit_stride
= a
;
8872 case DW_AT_byte_size
:
8873 attrs
->at_byte_size
= a
;
8875 case DW_AT_byte_stride
:
8876 attrs
->at_byte_stride
= a
;
8878 case DW_AT_const_value
:
8879 attrs
->at_const_value
= a
;
8881 case DW_AT_containing_type
:
8882 attrs
->at_containing_type
= a
;
8885 attrs
->at_count
= a
;
8887 case DW_AT_data_location
:
8888 attrs
->at_data_location
= a
;
8890 case DW_AT_data_member_location
:
8891 attrs
->at_data_member_location
= a
;
8893 case DW_AT_decimal_scale
:
8894 attrs
->at_decimal_scale
= a
;
8896 case DW_AT_decimal_sign
:
8897 attrs
->at_decimal_sign
= a
;
8899 case DW_AT_default_value
:
8900 attrs
->at_default_value
= a
;
8902 case DW_AT_digit_count
:
8903 attrs
->at_digit_count
= a
;
8906 attrs
->at_discr
= a
;
8908 case DW_AT_discr_list
:
8909 attrs
->at_discr_list
= a
;
8911 case DW_AT_discr_value
:
8912 attrs
->at_discr_value
= a
;
8914 case DW_AT_encoding
:
8915 attrs
->at_encoding
= a
;
8917 case DW_AT_endianity
:
8918 attrs
->at_endianity
= a
;
8920 case DW_AT_explicit
:
8921 attrs
->at_explicit
= a
;
8923 case DW_AT_is_optional
:
8924 attrs
->at_is_optional
= a
;
8926 case DW_AT_location
:
8927 attrs
->at_location
= a
;
8929 case DW_AT_lower_bound
:
8930 attrs
->at_lower_bound
= a
;
8933 attrs
->at_mutable
= a
;
8935 case DW_AT_ordering
:
8936 attrs
->at_ordering
= a
;
8938 case DW_AT_picture_string
:
8939 attrs
->at_picture_string
= a
;
8941 case DW_AT_prototyped
:
8942 attrs
->at_prototyped
= a
;
8945 attrs
->at_small
= a
;
8948 attrs
->at_segment
= a
;
8950 case DW_AT_string_length
:
8951 attrs
->at_string_length
= a
;
8953 case DW_AT_threads_scaled
:
8954 attrs
->at_threads_scaled
= a
;
8956 case DW_AT_upper_bound
:
8957 attrs
->at_upper_bound
= a
;
8959 case DW_AT_use_location
:
8960 attrs
->at_use_location
= a
;
8962 case DW_AT_use_UTF8
:
8963 attrs
->at_use_UTF8
= a
;
8965 case DW_AT_variable_parameter
:
8966 attrs
->at_variable_parameter
= a
;
8968 case DW_AT_virtuality
:
8969 attrs
->at_virtuality
= a
;
8971 case DW_AT_visibility
:
8972 attrs
->at_visibility
= a
;
8974 case DW_AT_vtable_elem_location
:
8975 attrs
->at_vtable_elem_location
= a
;
8983 /* Calculate the checksum of a DIE, using an ordered subset of attributes. */
8986 die_checksum_ordered (dw_die_ref die
, struct md5_ctx
*ctx
, int *mark
)
8990 struct checksum_attributes attrs
;
8992 CHECKSUM_ULEB128 ('D');
8993 CHECKSUM_ULEB128 (die
->die_tag
);
8995 memset (&attrs
, 0, sizeof (attrs
));
8997 decl
= get_AT_ref (die
, DW_AT_specification
);
8999 collect_checksum_attributes (&attrs
, decl
);
9000 collect_checksum_attributes (&attrs
, die
);
9002 CHECKSUM_ATTR (attrs
.at_name
);
9003 CHECKSUM_ATTR (attrs
.at_accessibility
);
9004 CHECKSUM_ATTR (attrs
.at_address_class
);
9005 CHECKSUM_ATTR (attrs
.at_allocated
);
9006 CHECKSUM_ATTR (attrs
.at_artificial
);
9007 CHECKSUM_ATTR (attrs
.at_associated
);
9008 CHECKSUM_ATTR (attrs
.at_binary_scale
);
9009 CHECKSUM_ATTR (attrs
.at_bit_offset
);
9010 CHECKSUM_ATTR (attrs
.at_bit_size
);
9011 CHECKSUM_ATTR (attrs
.at_bit_stride
);
9012 CHECKSUM_ATTR (attrs
.at_byte_size
);
9013 CHECKSUM_ATTR (attrs
.at_byte_stride
);
9014 CHECKSUM_ATTR (attrs
.at_const_value
);
9015 CHECKSUM_ATTR (attrs
.at_containing_type
);
9016 CHECKSUM_ATTR (attrs
.at_count
);
9017 CHECKSUM_ATTR (attrs
.at_data_location
);
9018 CHECKSUM_ATTR (attrs
.at_data_member_location
);
9019 CHECKSUM_ATTR (attrs
.at_decimal_scale
);
9020 CHECKSUM_ATTR (attrs
.at_decimal_sign
);
9021 CHECKSUM_ATTR (attrs
.at_default_value
);
9022 CHECKSUM_ATTR (attrs
.at_digit_count
);
9023 CHECKSUM_ATTR (attrs
.at_discr
);
9024 CHECKSUM_ATTR (attrs
.at_discr_list
);
9025 CHECKSUM_ATTR (attrs
.at_discr_value
);
9026 CHECKSUM_ATTR (attrs
.at_encoding
);
9027 CHECKSUM_ATTR (attrs
.at_endianity
);
9028 CHECKSUM_ATTR (attrs
.at_explicit
);
9029 CHECKSUM_ATTR (attrs
.at_is_optional
);
9030 CHECKSUM_ATTR (attrs
.at_location
);
9031 CHECKSUM_ATTR (attrs
.at_lower_bound
);
9032 CHECKSUM_ATTR (attrs
.at_mutable
);
9033 CHECKSUM_ATTR (attrs
.at_ordering
);
9034 CHECKSUM_ATTR (attrs
.at_picture_string
);
9035 CHECKSUM_ATTR (attrs
.at_prototyped
);
9036 CHECKSUM_ATTR (attrs
.at_small
);
9037 CHECKSUM_ATTR (attrs
.at_segment
);
9038 CHECKSUM_ATTR (attrs
.at_string_length
);
9039 CHECKSUM_ATTR (attrs
.at_threads_scaled
);
9040 CHECKSUM_ATTR (attrs
.at_upper_bound
);
9041 CHECKSUM_ATTR (attrs
.at_use_location
);
9042 CHECKSUM_ATTR (attrs
.at_use_UTF8
);
9043 CHECKSUM_ATTR (attrs
.at_variable_parameter
);
9044 CHECKSUM_ATTR (attrs
.at_virtuality
);
9045 CHECKSUM_ATTR (attrs
.at_visibility
);
9046 CHECKSUM_ATTR (attrs
.at_vtable_elem_location
);
9047 CHECKSUM_ATTR (attrs
.at_type
);
9048 CHECKSUM_ATTR (attrs
.at_friend
);
9050 /* Checksum the child DIEs, except for nested types and member functions. */
9053 dw_attr_ref name_attr
;
9056 name_attr
= get_AT (c
, DW_AT_name
);
9057 if ((is_type_die (c
) || c
->die_tag
== DW_TAG_subprogram
)
9058 && name_attr
!= NULL
)
9060 CHECKSUM_ULEB128 ('S');
9061 CHECKSUM_ULEB128 (c
->die_tag
);
9062 CHECKSUM_STRING (AT_string (name_attr
));
9066 /* Mark this DIE so it gets processed when unmarking. */
9067 if (c
->die_mark
== 0)
9069 die_checksum_ordered (c
, ctx
, mark
);
9071 } while (c
!= die
->die_child
);
9073 CHECKSUM_ULEB128 (0);
9077 #undef CHECKSUM_STRING
9078 #undef CHECKSUM_ATTR
9079 #undef CHECKSUM_LEB128
9080 #undef CHECKSUM_ULEB128
9082 /* Generate the type signature for DIE. This is computed by generating an
9083 MD5 checksum over the DIE's tag, its relevant attributes, and its
9084 children. Attributes that are references to other DIEs are processed
9085 by recursion, using the MARK field to prevent infinite recursion.
9086 If the DIE is nested inside a namespace or another type, we also
9087 need to include that context in the signature. The lower 64 bits
9088 of the resulting MD5 checksum comprise the signature. */
9091 generate_type_signature (dw_die_ref die
, comdat_type_node
*type_node
)
9095 unsigned char checksum
[16];
9099 name
= get_AT_string (die
, DW_AT_name
);
9100 decl
= get_AT_ref (die
, DW_AT_specification
);
9102 /* First, compute a signature for just the type name (and its surrounding
9103 context, if any. This is stored in the type unit DIE for link-time
9104 ODR (one-definition rule) checking. */
9106 if (is_cxx() && name
!= NULL
)
9108 md5_init_ctx (&ctx
);
9110 /* Checksum the names of surrounding namespaces and structures. */
9111 if (decl
!= NULL
&& decl
->die_parent
!= NULL
)
9112 checksum_die_context (decl
->die_parent
, &ctx
);
9114 md5_process_bytes (&die
->die_tag
, sizeof (die
->die_tag
), &ctx
);
9115 md5_process_bytes (name
, strlen (name
) + 1, &ctx
);
9116 md5_finish_ctx (&ctx
, checksum
);
9118 add_AT_data8 (type_node
->root_die
, DW_AT_GNU_odr_signature
, &checksum
[8]);
9121 /* Next, compute the complete type signature. */
9123 md5_init_ctx (&ctx
);
9125 die
->die_mark
= mark
;
9127 /* Checksum the names of surrounding namespaces and structures. */
9128 if (decl
!= NULL
&& decl
->die_parent
!= NULL
)
9129 checksum_die_context (decl
->die_parent
, &ctx
);
9131 /* Checksum the DIE and its children. */
9132 die_checksum_ordered (die
, &ctx
, &mark
);
9133 unmark_all_dies (die
);
9134 md5_finish_ctx (&ctx
, checksum
);
9136 /* Store the signature in the type node and link the type DIE and the
9137 type node together. */
9138 memcpy (type_node
->signature
, &checksum
[16 - DWARF_TYPE_SIGNATURE_SIZE
],
9139 DWARF_TYPE_SIGNATURE_SIZE
);
9140 die
->die_id
.die_type_node
= type_node
;
9141 type_node
->type_die
= die
;
9143 /* If the DIE is a specification, link its declaration to the type node
9146 decl
->die_id
.die_type_node
= type_node
;
9149 /* Do the location expressions look same? */
9151 same_loc_p (dw_loc_descr_ref loc1
, dw_loc_descr_ref loc2
, int *mark
)
9153 return loc1
->dw_loc_opc
== loc2
->dw_loc_opc
9154 && same_dw_val_p (&loc1
->dw_loc_oprnd1
, &loc2
->dw_loc_oprnd1
, mark
)
9155 && same_dw_val_p (&loc1
->dw_loc_oprnd2
, &loc2
->dw_loc_oprnd2
, mark
);
9158 /* Do the values look the same? */
9160 same_dw_val_p (const dw_val_node
*v1
, const dw_val_node
*v2
, int *mark
)
9162 dw_loc_descr_ref loc1
, loc2
;
9165 if (v1
->val_class
!= v2
->val_class
)
9168 switch (v1
->val_class
)
9170 case dw_val_class_const
:
9171 return v1
->v
.val_int
== v2
->v
.val_int
;
9172 case dw_val_class_unsigned_const
:
9173 return v1
->v
.val_unsigned
== v2
->v
.val_unsigned
;
9174 case dw_val_class_const_double
:
9175 return v1
->v
.val_double
.high
== v2
->v
.val_double
.high
9176 && v1
->v
.val_double
.low
== v2
->v
.val_double
.low
;
9177 case dw_val_class_vec
:
9178 if (v1
->v
.val_vec
.length
!= v2
->v
.val_vec
.length
9179 || v1
->v
.val_vec
.elt_size
!= v2
->v
.val_vec
.elt_size
)
9181 if (memcmp (v1
->v
.val_vec
.array
, v2
->v
.val_vec
.array
,
9182 v1
->v
.val_vec
.length
* v1
->v
.val_vec
.elt_size
))
9185 case dw_val_class_flag
:
9186 return v1
->v
.val_flag
== v2
->v
.val_flag
;
9187 case dw_val_class_str
:
9188 return !strcmp(v1
->v
.val_str
->str
, v2
->v
.val_str
->str
);
9190 case dw_val_class_addr
:
9191 r1
= v1
->v
.val_addr
;
9192 r2
= v2
->v
.val_addr
;
9193 if (GET_CODE (r1
) != GET_CODE (r2
))
9195 return !rtx_equal_p (r1
, r2
);
9197 case dw_val_class_offset
:
9198 return v1
->v
.val_offset
== v2
->v
.val_offset
;
9200 case dw_val_class_loc
:
9201 for (loc1
= v1
->v
.val_loc
, loc2
= v2
->v
.val_loc
;
9203 loc1
= loc1
->dw_loc_next
, loc2
= loc2
->dw_loc_next
)
9204 if (!same_loc_p (loc1
, loc2
, mark
))
9206 return !loc1
&& !loc2
;
9208 case dw_val_class_die_ref
:
9209 return same_die_p (v1
->v
.val_die_ref
.die
, v2
->v
.val_die_ref
.die
, mark
);
9211 case dw_val_class_fde_ref
:
9212 case dw_val_class_vms_delta
:
9213 case dw_val_class_lbl_id
:
9214 case dw_val_class_lineptr
:
9215 case dw_val_class_macptr
:
9218 case dw_val_class_file
:
9219 return v1
->v
.val_file
== v2
->v
.val_file
;
9221 case dw_val_class_data8
:
9222 return !memcmp (v1
->v
.val_data8
, v2
->v
.val_data8
, 8);
9229 /* Do the attributes look the same? */
9232 same_attr_p (dw_attr_ref at1
, dw_attr_ref at2
, int *mark
)
9234 if (at1
->dw_attr
!= at2
->dw_attr
)
9237 /* We don't care that this was compiled with a different compiler
9238 snapshot; if the output is the same, that's what matters. */
9239 if (at1
->dw_attr
== DW_AT_producer
)
9242 return same_dw_val_p (&at1
->dw_attr_val
, &at2
->dw_attr_val
, mark
);
9245 /* Do the dies look the same? */
9248 same_die_p (dw_die_ref die1
, dw_die_ref die2
, int *mark
)
9254 /* To avoid infinite recursion. */
9256 return die1
->die_mark
== die2
->die_mark
;
9257 die1
->die_mark
= die2
->die_mark
= ++(*mark
);
9259 if (die1
->die_tag
!= die2
->die_tag
)
9262 if (VEC_length (dw_attr_node
, die1
->die_attr
)
9263 != VEC_length (dw_attr_node
, die2
->die_attr
))
9266 for (ix
= 0; VEC_iterate (dw_attr_node
, die1
->die_attr
, ix
, a1
); ix
++)
9267 if (!same_attr_p (a1
, VEC_index (dw_attr_node
, die2
->die_attr
, ix
), mark
))
9270 c1
= die1
->die_child
;
9271 c2
= die2
->die_child
;
9280 if (!same_die_p (c1
, c2
, mark
))
9284 if (c1
== die1
->die_child
)
9286 if (c2
== die2
->die_child
)
9296 /* Do the dies look the same? Wrapper around same_die_p. */
9299 same_die_p_wrap (dw_die_ref die1
, dw_die_ref die2
)
9302 int ret
= same_die_p (die1
, die2
, &mark
);
9304 unmark_all_dies (die1
);
9305 unmark_all_dies (die2
);
9310 /* The prefix to attach to symbols on DIEs in the current comdat debug
9312 static char *comdat_symbol_id
;
9314 /* The index of the current symbol within the current comdat CU. */
9315 static unsigned int comdat_symbol_number
;
9317 /* Calculate the MD5 checksum of the compilation unit DIE UNIT_DIE and its
9318 children, and set comdat_symbol_id accordingly. */
9321 compute_section_prefix (dw_die_ref unit_die
)
9323 const char *die_name
= get_AT_string (unit_die
, DW_AT_name
);
9324 const char *base
= die_name
? lbasename (die_name
) : "anonymous";
9325 char *name
= XALLOCAVEC (char, strlen (base
) + 64);
9328 unsigned char checksum
[16];
9331 /* Compute the checksum of the DIE, then append part of it as hex digits to
9332 the name filename of the unit. */
9334 md5_init_ctx (&ctx
);
9336 die_checksum (unit_die
, &ctx
, &mark
);
9337 unmark_all_dies (unit_die
);
9338 md5_finish_ctx (&ctx
, checksum
);
9340 sprintf (name
, "%s.", base
);
9341 clean_symbol_name (name
);
9343 p
= name
+ strlen (name
);
9344 for (i
= 0; i
< 4; i
++)
9346 sprintf (p
, "%.2x", checksum
[i
]);
9350 comdat_symbol_id
= unit_die
->die_id
.die_symbol
= xstrdup (name
);
9351 comdat_symbol_number
= 0;
9354 /* Returns nonzero if DIE represents a type, in the sense of TYPE_P. */
9357 is_type_die (dw_die_ref die
)
9359 switch (die
->die_tag
)
9361 case DW_TAG_array_type
:
9362 case DW_TAG_class_type
:
9363 case DW_TAG_interface_type
:
9364 case DW_TAG_enumeration_type
:
9365 case DW_TAG_pointer_type
:
9366 case DW_TAG_reference_type
:
9367 case DW_TAG_rvalue_reference_type
:
9368 case DW_TAG_string_type
:
9369 case DW_TAG_structure_type
:
9370 case DW_TAG_subroutine_type
:
9371 case DW_TAG_union_type
:
9372 case DW_TAG_ptr_to_member_type
:
9373 case DW_TAG_set_type
:
9374 case DW_TAG_subrange_type
:
9375 case DW_TAG_base_type
:
9376 case DW_TAG_const_type
:
9377 case DW_TAG_file_type
:
9378 case DW_TAG_packed_type
:
9379 case DW_TAG_volatile_type
:
9380 case DW_TAG_typedef
:
9387 /* Returns 1 iff C is the sort of DIE that should go into a COMDAT CU.
9388 Basically, we want to choose the bits that are likely to be shared between
9389 compilations (types) and leave out the bits that are specific to individual
9390 compilations (functions). */
9393 is_comdat_die (dw_die_ref c
)
9395 /* I think we want to leave base types and __vtbl_ptr_type in the main CU, as
9396 we do for stabs. The advantage is a greater likelihood of sharing between
9397 objects that don't include headers in the same order (and therefore would
9398 put the base types in a different comdat). jason 8/28/00 */
9400 if (c
->die_tag
== DW_TAG_base_type
)
9403 if (c
->die_tag
== DW_TAG_pointer_type
9404 || c
->die_tag
== DW_TAG_reference_type
9405 || c
->die_tag
== DW_TAG_rvalue_reference_type
9406 || c
->die_tag
== DW_TAG_const_type
9407 || c
->die_tag
== DW_TAG_volatile_type
)
9409 dw_die_ref t
= get_AT_ref (c
, DW_AT_type
);
9411 return t
? is_comdat_die (t
) : 0;
9414 return is_type_die (c
);
9417 /* Returns 1 iff C is the sort of DIE that might be referred to from another
9418 compilation unit. */
9421 is_symbol_die (dw_die_ref c
)
9423 return (is_type_die (c
)
9424 || is_declaration_die (c
)
9425 || c
->die_tag
== DW_TAG_namespace
9426 || c
->die_tag
== DW_TAG_module
);
9430 gen_internal_sym (const char *prefix
)
9434 ASM_GENERATE_INTERNAL_LABEL (buf
, prefix
, label_num
++);
9435 return xstrdup (buf
);
9438 /* Assign symbols to all worthy DIEs under DIE. */
9441 assign_symbol_names (dw_die_ref die
)
9445 if (is_symbol_die (die
))
9447 if (comdat_symbol_id
)
9449 char *p
= XALLOCAVEC (char, strlen (comdat_symbol_id
) + 64);
9451 sprintf (p
, "%s.%s.%x", DIE_LABEL_PREFIX
,
9452 comdat_symbol_id
, comdat_symbol_number
++);
9453 die
->die_id
.die_symbol
= xstrdup (p
);
9456 die
->die_id
.die_symbol
= gen_internal_sym ("LDIE");
9459 FOR_EACH_CHILD (die
, c
, assign_symbol_names (c
));
9462 struct cu_hash_table_entry
9465 unsigned min_comdat_num
, max_comdat_num
;
9466 struct cu_hash_table_entry
*next
;
9469 /* Routines to manipulate hash table of CUs. */
9471 htab_cu_hash (const void *of
)
9473 const struct cu_hash_table_entry
*const entry
=
9474 (const struct cu_hash_table_entry
*) of
;
9476 return htab_hash_string (entry
->cu
->die_id
.die_symbol
);
9480 htab_cu_eq (const void *of1
, const void *of2
)
9482 const struct cu_hash_table_entry
*const entry1
=
9483 (const struct cu_hash_table_entry
*) of1
;
9484 const struct die_struct
*const entry2
= (const struct die_struct
*) of2
;
9486 return !strcmp (entry1
->cu
->die_id
.die_symbol
, entry2
->die_id
.die_symbol
);
9490 htab_cu_del (void *what
)
9492 struct cu_hash_table_entry
*next
,
9493 *entry
= (struct cu_hash_table_entry
*) what
;
9503 /* Check whether we have already seen this CU and set up SYM_NUM
9506 check_duplicate_cu (dw_die_ref cu
, htab_t htable
, unsigned int *sym_num
)
9508 struct cu_hash_table_entry dummy
;
9509 struct cu_hash_table_entry
**slot
, *entry
, *last
= &dummy
;
9511 dummy
.max_comdat_num
= 0;
9513 slot
= (struct cu_hash_table_entry
**)
9514 htab_find_slot_with_hash (htable
, cu
, htab_hash_string (cu
->die_id
.die_symbol
),
9518 for (; entry
; last
= entry
, entry
= entry
->next
)
9520 if (same_die_p_wrap (cu
, entry
->cu
))
9526 *sym_num
= entry
->min_comdat_num
;
9530 entry
= XCNEW (struct cu_hash_table_entry
);
9532 entry
->min_comdat_num
= *sym_num
= last
->max_comdat_num
;
9533 entry
->next
= *slot
;
9539 /* Record SYM_NUM to record of CU in HTABLE. */
9541 record_comdat_symbol_number (dw_die_ref cu
, htab_t htable
, unsigned int sym_num
)
9543 struct cu_hash_table_entry
**slot
, *entry
;
9545 slot
= (struct cu_hash_table_entry
**)
9546 htab_find_slot_with_hash (htable
, cu
, htab_hash_string (cu
->die_id
.die_symbol
),
9550 entry
->max_comdat_num
= sym_num
;
9553 /* Traverse the DIE (which is always comp_unit_die), and set up
9554 additional compilation units for each of the include files we see
9555 bracketed by BINCL/EINCL. */
9558 break_out_includes (dw_die_ref die
)
9561 dw_die_ref unit
= NULL
;
9562 limbo_die_node
*node
, **pnode
;
9563 htab_t cu_hash_table
;
9567 dw_die_ref prev
= c
;
9569 while (c
->die_tag
== DW_TAG_GNU_BINCL
|| c
->die_tag
== DW_TAG_GNU_EINCL
9570 || (unit
&& is_comdat_die (c
)))
9572 dw_die_ref next
= c
->die_sib
;
9574 /* This DIE is for a secondary CU; remove it from the main one. */
9575 remove_child_with_prev (c
, prev
);
9577 if (c
->die_tag
== DW_TAG_GNU_BINCL
)
9578 unit
= push_new_compile_unit (unit
, c
);
9579 else if (c
->die_tag
== DW_TAG_GNU_EINCL
)
9580 unit
= pop_compile_unit (unit
);
9582 add_child_die (unit
, c
);
9584 if (c
== die
->die_child
)
9587 } while (c
!= die
->die_child
);
9590 /* We can only use this in debugging, since the frontend doesn't check
9591 to make sure that we leave every include file we enter. */
9595 assign_symbol_names (die
);
9596 cu_hash_table
= htab_create (10, htab_cu_hash
, htab_cu_eq
, htab_cu_del
);
9597 for (node
= limbo_die_list
, pnode
= &limbo_die_list
;
9603 compute_section_prefix (node
->die
);
9604 is_dupl
= check_duplicate_cu (node
->die
, cu_hash_table
,
9605 &comdat_symbol_number
);
9606 assign_symbol_names (node
->die
);
9608 *pnode
= node
->next
;
9611 pnode
= &node
->next
;
9612 record_comdat_symbol_number (node
->die
, cu_hash_table
,
9613 comdat_symbol_number
);
9616 htab_delete (cu_hash_table
);
9619 /* Return non-zero if this DIE is a declaration. */
9622 is_declaration_die (dw_die_ref die
)
9627 for (ix
= 0; VEC_iterate (dw_attr_node
, die
->die_attr
, ix
, a
); ix
++)
9628 if (a
->dw_attr
== DW_AT_declaration
)
9634 /* Return non-zero if this DIE is nested inside a subprogram. */
9637 is_nested_in_subprogram (dw_die_ref die
)
9639 dw_die_ref decl
= get_AT_ref (die
, DW_AT_specification
);
9643 return local_scope_p (decl
);
9646 /* Return non-zero if this is a type DIE that should be moved to a
9647 COMDAT .debug_types section. */
9650 should_move_die_to_comdat (dw_die_ref die
)
9652 switch (die
->die_tag
)
9654 case DW_TAG_class_type
:
9655 case DW_TAG_structure_type
:
9656 case DW_TAG_enumeration_type
:
9657 case DW_TAG_union_type
:
9658 /* Don't move declarations, inlined instances, or types nested in a
9660 if (is_declaration_die (die
)
9661 || get_AT (die
, DW_AT_abstract_origin
)
9662 || is_nested_in_subprogram (die
))
9665 case DW_TAG_array_type
:
9666 case DW_TAG_interface_type
:
9667 case DW_TAG_pointer_type
:
9668 case DW_TAG_reference_type
:
9669 case DW_TAG_rvalue_reference_type
:
9670 case DW_TAG_string_type
:
9671 case DW_TAG_subroutine_type
:
9672 case DW_TAG_ptr_to_member_type
:
9673 case DW_TAG_set_type
:
9674 case DW_TAG_subrange_type
:
9675 case DW_TAG_base_type
:
9676 case DW_TAG_const_type
:
9677 case DW_TAG_file_type
:
9678 case DW_TAG_packed_type
:
9679 case DW_TAG_volatile_type
:
9680 case DW_TAG_typedef
:
9686 /* Make a clone of DIE. */
9689 clone_die (dw_die_ref die
)
9695 clone
= ggc_alloc_cleared_die_node ();
9696 clone
->die_tag
= die
->die_tag
;
9698 for (ix
= 0; VEC_iterate (dw_attr_node
, die
->die_attr
, ix
, a
); ix
++)
9699 add_dwarf_attr (clone
, a
);
9704 /* Make a clone of the tree rooted at DIE. */
9707 clone_tree (dw_die_ref die
)
9710 dw_die_ref clone
= clone_die (die
);
9712 FOR_EACH_CHILD (die
, c
, add_child_die (clone
, clone_tree(c
)));
9717 /* Make a clone of DIE as a declaration. */
9720 clone_as_declaration (dw_die_ref die
)
9727 /* If the DIE is already a declaration, just clone it. */
9728 if (is_declaration_die (die
))
9729 return clone_die (die
);
9731 /* If the DIE is a specification, just clone its declaration DIE. */
9732 decl
= get_AT_ref (die
, DW_AT_specification
);
9734 return clone_die (decl
);
9736 clone
= ggc_alloc_cleared_die_node ();
9737 clone
->die_tag
= die
->die_tag
;
9739 for (ix
= 0; VEC_iterate (dw_attr_node
, die
->die_attr
, ix
, a
); ix
++)
9741 /* We don't want to copy over all attributes.
9742 For example we don't want DW_AT_byte_size because otherwise we will no
9743 longer have a declaration and GDB will treat it as a definition. */
9747 case DW_AT_artificial
:
9748 case DW_AT_containing_type
:
9749 case DW_AT_external
:
9752 case DW_AT_virtuality
:
9753 case DW_AT_linkage_name
:
9754 case DW_AT_MIPS_linkage_name
:
9755 add_dwarf_attr (clone
, a
);
9757 case DW_AT_byte_size
:
9763 if (die
->die_id
.die_type_node
)
9764 add_AT_die_ref (clone
, DW_AT_signature
, die
);
9766 add_AT_flag (clone
, DW_AT_declaration
, 1);
9770 /* Copy the declaration context to the new compile unit DIE. This includes
9771 any surrounding namespace or type declarations. If the DIE has an
9772 AT_specification attribute, it also includes attributes and children
9773 attached to the specification. */
9776 copy_declaration_context (dw_die_ref unit
, dw_die_ref die
)
9779 dw_die_ref new_decl
;
9781 decl
= get_AT_ref (die
, DW_AT_specification
);
9790 /* Copy the type node pointer from the new DIE to the original
9791 declaration DIE so we can forward references later. */
9792 decl
->die_id
.die_type_node
= die
->die_id
.die_type_node
;
9794 remove_AT (die
, DW_AT_specification
);
9796 for (ix
= 0; VEC_iterate (dw_attr_node
, decl
->die_attr
, ix
, a
); ix
++)
9798 if (a
->dw_attr
!= DW_AT_name
9799 && a
->dw_attr
!= DW_AT_declaration
9800 && a
->dw_attr
!= DW_AT_external
)
9801 add_dwarf_attr (die
, a
);
9804 FOR_EACH_CHILD (decl
, c
, add_child_die (die
, clone_tree(c
)));
9807 if (decl
->die_parent
!= NULL
9808 && decl
->die_parent
->die_tag
!= DW_TAG_compile_unit
9809 && decl
->die_parent
->die_tag
!= DW_TAG_type_unit
)
9811 new_decl
= copy_ancestor_tree (unit
, decl
, NULL
);
9812 if (new_decl
!= NULL
)
9814 remove_AT (new_decl
, DW_AT_signature
);
9815 add_AT_specification (die
, new_decl
);
9820 /* Generate the skeleton ancestor tree for the given NODE, then clone
9821 the DIE and add the clone into the tree. */
9824 generate_skeleton_ancestor_tree (skeleton_chain_node
*node
)
9826 if (node
->new_die
!= NULL
)
9829 node
->new_die
= clone_as_declaration (node
->old_die
);
9831 if (node
->parent
!= NULL
)
9833 generate_skeleton_ancestor_tree (node
->parent
);
9834 add_child_die (node
->parent
->new_die
, node
->new_die
);
9838 /* Generate a skeleton tree of DIEs containing any declarations that are
9839 found in the original tree. We traverse the tree looking for declaration
9840 DIEs, and construct the skeleton from the bottom up whenever we find one. */
9843 generate_skeleton_bottom_up (skeleton_chain_node
*parent
)
9845 skeleton_chain_node node
;
9848 dw_die_ref prev
= NULL
;
9849 dw_die_ref next
= NULL
;
9851 node
.parent
= parent
;
9853 first
= c
= parent
->old_die
->die_child
;
9857 if (prev
== NULL
|| prev
->die_sib
== c
)
9860 next
= (c
== first
? NULL
: c
->die_sib
);
9862 node
.new_die
= NULL
;
9863 if (is_declaration_die (c
))
9865 /* Clone the existing DIE, move the original to the skeleton
9866 tree (which is in the main CU), and put the clone, with
9867 all the original's children, where the original came from. */
9868 dw_die_ref clone
= clone_die (c
);
9869 move_all_children (c
, clone
);
9871 replace_child (c
, clone
, prev
);
9872 generate_skeleton_ancestor_tree (parent
);
9873 add_child_die (parent
->new_die
, c
);
9877 generate_skeleton_bottom_up (&node
);
9878 } while (next
!= NULL
);
9881 /* Wrapper function for generate_skeleton_bottom_up. */
9884 generate_skeleton (dw_die_ref die
)
9886 skeleton_chain_node node
;
9889 node
.new_die
= NULL
;
9892 /* If this type definition is nested inside another type,
9893 always leave at least a declaration in its place. */
9894 if (die
->die_parent
!= NULL
&& is_type_die (die
->die_parent
))
9895 node
.new_die
= clone_as_declaration (die
);
9897 generate_skeleton_bottom_up (&node
);
9898 return node
.new_die
;
9901 /* Remove the DIE from its parent, possibly replacing it with a cloned
9902 declaration. The original DIE will be moved to a new compile unit
9903 so that existing references to it follow it to the new location. If
9904 any of the original DIE's descendants is a declaration, we need to
9905 replace the original DIE with a skeleton tree and move the
9906 declarations back into the skeleton tree. */
9909 remove_child_or_replace_with_skeleton (dw_die_ref child
, dw_die_ref prev
)
9911 dw_die_ref skeleton
;
9913 skeleton
= generate_skeleton (child
);
9914 if (skeleton
== NULL
)
9915 remove_child_with_prev (child
, prev
);
9918 skeleton
->die_id
.die_type_node
= child
->die_id
.die_type_node
;
9919 replace_child (child
, skeleton
, prev
);
9925 /* Traverse the DIE and set up additional .debug_types sections for each
9926 type worthy of being placed in a COMDAT section. */
9929 break_out_comdat_types (dw_die_ref die
)
9933 dw_die_ref prev
= NULL
;
9934 dw_die_ref next
= NULL
;
9935 dw_die_ref unit
= NULL
;
9937 first
= c
= die
->die_child
;
9941 if (prev
== NULL
|| prev
->die_sib
== c
)
9944 next
= (c
== first
? NULL
: c
->die_sib
);
9945 if (should_move_die_to_comdat (c
))
9947 dw_die_ref replacement
;
9948 comdat_type_node_ref type_node
;
9950 /* Create a new type unit DIE as the root for the new tree, and
9951 add it to the list of comdat types. */
9952 unit
= new_die (DW_TAG_type_unit
, NULL
, NULL
);
9953 add_AT_unsigned (unit
, DW_AT_language
,
9954 get_AT_unsigned (comp_unit_die
, DW_AT_language
));
9955 type_node
= ggc_alloc_cleared_comdat_type_node ();
9956 type_node
->root_die
= unit
;
9957 type_node
->next
= comdat_type_list
;
9958 comdat_type_list
= type_node
;
9960 /* Generate the type signature. */
9961 generate_type_signature (c
, type_node
);
9963 /* Copy the declaration context, attributes, and children of the
9964 declaration into the new compile unit DIE. */
9965 copy_declaration_context (unit
, c
);
9967 /* Remove this DIE from the main CU. */
9968 replacement
= remove_child_or_replace_with_skeleton (c
, prev
);
9970 /* Break out nested types into their own type units. */
9971 break_out_comdat_types (c
);
9973 /* Add the DIE to the new compunit. */
9974 add_child_die (unit
, c
);
9976 if (replacement
!= NULL
)
9979 else if (c
->die_tag
== DW_TAG_namespace
9980 || c
->die_tag
== DW_TAG_class_type
9981 || c
->die_tag
== DW_TAG_structure_type
9982 || c
->die_tag
== DW_TAG_union_type
)
9984 /* Look for nested types that can be broken out. */
9985 break_out_comdat_types (c
);
9987 } while (next
!= NULL
);
9990 /* Structure to map a DIE in one CU to its copy in a comdat type unit. */
9992 struct decl_table_entry
9998 /* Routines to manipulate hash table of copied declarations. */
10001 htab_decl_hash (const void *of
)
10003 const struct decl_table_entry
*const entry
=
10004 (const struct decl_table_entry
*) of
;
10006 return htab_hash_pointer (entry
->orig
);
10010 htab_decl_eq (const void *of1
, const void *of2
)
10012 const struct decl_table_entry
*const entry1
=
10013 (const struct decl_table_entry
*) of1
;
10014 const struct die_struct
*const entry2
= (const struct die_struct
*) of2
;
10016 return entry1
->orig
== entry2
;
10020 htab_decl_del (void *what
)
10022 struct decl_table_entry
*entry
= (struct decl_table_entry
*) what
;
10027 /* Copy DIE and its ancestors, up to, but not including, the compile unit
10028 or type unit entry, to a new tree. Adds the new tree to UNIT and returns
10029 a pointer to the copy of DIE. If DECL_TABLE is provided, it is used
10030 to check if the ancestor has already been copied into UNIT. */
10033 copy_ancestor_tree (dw_die_ref unit
, dw_die_ref die
, htab_t decl_table
)
10035 dw_die_ref parent
= die
->die_parent
;
10036 dw_die_ref new_parent
= unit
;
10038 void **slot
= NULL
;
10039 struct decl_table_entry
*entry
= NULL
;
10043 /* Check if the entry has already been copied to UNIT. */
10044 slot
= htab_find_slot_with_hash (decl_table
, die
,
10045 htab_hash_pointer (die
), INSERT
);
10046 if (*slot
!= HTAB_EMPTY_ENTRY
)
10048 entry
= (struct decl_table_entry
*) *slot
;
10049 return entry
->copy
;
10052 /* Record in DECL_TABLE that DIE has been copied to UNIT. */
10053 entry
= XCNEW (struct decl_table_entry
);
10055 entry
->copy
= NULL
;
10059 if (parent
!= NULL
)
10061 dw_die_ref spec
= get_AT_ref (parent
, DW_AT_specification
);
10064 if (parent
->die_tag
!= DW_TAG_compile_unit
10065 && parent
->die_tag
!= DW_TAG_type_unit
)
10066 new_parent
= copy_ancestor_tree (unit
, parent
, decl_table
);
10069 copy
= clone_as_declaration (die
);
10070 add_child_die (new_parent
, copy
);
10072 if (decl_table
!= NULL
)
10074 /* Record the pointer to the copy. */
10075 entry
->copy
= copy
;
10081 /* Walk the DIE and its children, looking for references to incomplete
10082 or trivial types that are unmarked (i.e., that are not in the current
10086 copy_decls_walk (dw_die_ref unit
, dw_die_ref die
, htab_t decl_table
)
10092 for (ix
= 0; VEC_iterate (dw_attr_node
, die
->die_attr
, ix
, a
); ix
++)
10094 if (AT_class (a
) == dw_val_class_die_ref
)
10096 dw_die_ref targ
= AT_ref (a
);
10097 comdat_type_node_ref type_node
= targ
->die_id
.die_type_node
;
10099 struct decl_table_entry
*entry
;
10101 if (targ
->die_mark
!= 0 || type_node
!= NULL
)
10104 slot
= htab_find_slot_with_hash (decl_table
, targ
,
10105 htab_hash_pointer (targ
), INSERT
);
10107 if (*slot
!= HTAB_EMPTY_ENTRY
)
10109 /* TARG has already been copied, so we just need to
10110 modify the reference to point to the copy. */
10111 entry
= (struct decl_table_entry
*) *slot
;
10112 a
->dw_attr_val
.v
.val_die_ref
.die
= entry
->copy
;
10116 dw_die_ref parent
= unit
;
10117 dw_die_ref copy
= clone_tree (targ
);
10119 /* Make sure the cloned tree is marked as part of the
10123 /* Record in DECL_TABLE that TARG has been copied.
10124 Need to do this now, before the recursive call,
10125 because DECL_TABLE may be expanded and SLOT
10126 would no longer be a valid pointer. */
10127 entry
= XCNEW (struct decl_table_entry
);
10128 entry
->orig
= targ
;
10129 entry
->copy
= copy
;
10132 /* If TARG has surrounding context, copy its ancestor tree
10133 into the new type unit. */
10134 if (targ
->die_parent
!= NULL
10135 && targ
->die_parent
->die_tag
!= DW_TAG_compile_unit
10136 && targ
->die_parent
->die_tag
!= DW_TAG_type_unit
)
10137 parent
= copy_ancestor_tree (unit
, targ
->die_parent
,
10140 add_child_die (parent
, copy
);
10141 a
->dw_attr_val
.v
.val_die_ref
.die
= copy
;
10143 /* Make sure the newly-copied DIE is walked. If it was
10144 installed in a previously-added context, it won't
10145 get visited otherwise. */
10146 if (parent
!= unit
)
10148 /* Find the highest point of the newly-added tree,
10149 mark each node along the way, and walk from there. */
10150 parent
->die_mark
= 1;
10151 while (parent
->die_parent
10152 && parent
->die_parent
->die_mark
== 0)
10154 parent
= parent
->die_parent
;
10155 parent
->die_mark
= 1;
10157 copy_decls_walk (unit
, parent
, decl_table
);
10163 FOR_EACH_CHILD (die
, c
, copy_decls_walk (unit
, c
, decl_table
));
10166 /* Copy declarations for "unworthy" types into the new comdat section.
10167 Incomplete types, modified types, and certain other types aren't broken
10168 out into comdat sections of their own, so they don't have a signature,
10169 and we need to copy the declaration into the same section so that we
10170 don't have an external reference. */
10173 copy_decls_for_unworthy_types (dw_die_ref unit
)
10178 decl_table
= htab_create (10, htab_decl_hash
, htab_decl_eq
, htab_decl_del
);
10179 copy_decls_walk (unit
, unit
, decl_table
);
10180 htab_delete (decl_table
);
10181 unmark_dies (unit
);
10184 /* Traverse the DIE and add a sibling attribute if it may have the
10185 effect of speeding up access to siblings. To save some space,
10186 avoid generating sibling attributes for DIE's without children. */
10189 add_sibling_attributes (dw_die_ref die
)
10193 if (! die
->die_child
)
10196 if (die
->die_parent
&& die
!= die
->die_parent
->die_child
)
10197 add_AT_die_ref (die
, DW_AT_sibling
, die
->die_sib
);
10199 FOR_EACH_CHILD (die
, c
, add_sibling_attributes (c
));
10202 /* Output all location lists for the DIE and its children. */
10205 output_location_lists (dw_die_ref die
)
10211 for (ix
= 0; VEC_iterate (dw_attr_node
, die
->die_attr
, ix
, a
); ix
++)
10212 if (AT_class (a
) == dw_val_class_loc_list
)
10213 output_loc_list (AT_loc_list (a
));
10215 FOR_EACH_CHILD (die
, c
, output_location_lists (c
));
10218 /* The format of each DIE (and its attribute value pairs) is encoded in an
10219 abbreviation table. This routine builds the abbreviation table and assigns
10220 a unique abbreviation id for each abbreviation entry. The children of each
10221 die are visited recursively. */
10224 build_abbrev_table (dw_die_ref die
)
10226 unsigned long abbrev_id
;
10227 unsigned int n_alloc
;
10232 /* Scan the DIE references, and mark as external any that refer to
10233 DIEs from other CUs (i.e. those which are not marked). */
10234 for (ix
= 0; VEC_iterate (dw_attr_node
, die
->die_attr
, ix
, a
); ix
++)
10235 if (AT_class (a
) == dw_val_class_die_ref
10236 && AT_ref (a
)->die_mark
== 0)
10238 gcc_assert (dwarf_version
>= 4 || AT_ref (a
)->die_id
.die_symbol
);
10239 set_AT_ref_external (a
, 1);
10242 for (abbrev_id
= 1; abbrev_id
< abbrev_die_table_in_use
; ++abbrev_id
)
10244 dw_die_ref abbrev
= abbrev_die_table
[abbrev_id
];
10245 dw_attr_ref die_a
, abbrev_a
;
10249 if (abbrev
->die_tag
!= die
->die_tag
)
10251 if ((abbrev
->die_child
!= NULL
) != (die
->die_child
!= NULL
))
10254 if (VEC_length (dw_attr_node
, abbrev
->die_attr
)
10255 != VEC_length (dw_attr_node
, die
->die_attr
))
10258 for (ix
= 0; VEC_iterate (dw_attr_node
, die
->die_attr
, ix
, die_a
); ix
++)
10260 abbrev_a
= VEC_index (dw_attr_node
, abbrev
->die_attr
, ix
);
10261 if ((abbrev_a
->dw_attr
!= die_a
->dw_attr
)
10262 || (value_format (abbrev_a
) != value_format (die_a
)))
10272 if (abbrev_id
>= abbrev_die_table_in_use
)
10274 if (abbrev_die_table_in_use
>= abbrev_die_table_allocated
)
10276 n_alloc
= abbrev_die_table_allocated
+ ABBREV_DIE_TABLE_INCREMENT
;
10277 abbrev_die_table
= GGC_RESIZEVEC (dw_die_ref
, abbrev_die_table
,
10280 memset (&abbrev_die_table
[abbrev_die_table_allocated
], 0,
10281 (n_alloc
- abbrev_die_table_allocated
) * sizeof (dw_die_ref
));
10282 abbrev_die_table_allocated
= n_alloc
;
10285 ++abbrev_die_table_in_use
;
10286 abbrev_die_table
[abbrev_id
] = die
;
10289 die
->die_abbrev
= abbrev_id
;
10290 FOR_EACH_CHILD (die
, c
, build_abbrev_table (c
));
10293 /* Return the power-of-two number of bytes necessary to represent VALUE. */
10296 constant_size (unsigned HOST_WIDE_INT value
)
10303 log
= floor_log2 (value
);
10306 log
= 1 << (floor_log2 (log
) + 1);
10311 /* Return the size of a DIE as it is represented in the
10312 .debug_info section. */
10314 static unsigned long
10315 size_of_die (dw_die_ref die
)
10317 unsigned long size
= 0;
10321 size
+= size_of_uleb128 (die
->die_abbrev
);
10322 for (ix
= 0; VEC_iterate (dw_attr_node
, die
->die_attr
, ix
, a
); ix
++)
10324 switch (AT_class (a
))
10326 case dw_val_class_addr
:
10327 size
+= DWARF2_ADDR_SIZE
;
10329 case dw_val_class_offset
:
10330 size
+= DWARF_OFFSET_SIZE
;
10332 case dw_val_class_loc
:
10334 unsigned long lsize
= size_of_locs (AT_loc (a
));
10336 /* Block length. */
10337 if (dwarf_version
>= 4)
10338 size
+= size_of_uleb128 (lsize
);
10340 size
+= constant_size (lsize
);
10344 case dw_val_class_loc_list
:
10345 size
+= DWARF_OFFSET_SIZE
;
10347 case dw_val_class_range_list
:
10348 size
+= DWARF_OFFSET_SIZE
;
10350 case dw_val_class_const
:
10351 size
+= size_of_sleb128 (AT_int (a
));
10353 case dw_val_class_unsigned_const
:
10354 size
+= constant_size (AT_unsigned (a
));
10356 case dw_val_class_const_double
:
10357 size
+= 2 * HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
;
10358 if (HOST_BITS_PER_WIDE_INT
>= 64)
10359 size
++; /* block */
10361 case dw_val_class_vec
:
10362 size
+= constant_size (a
->dw_attr_val
.v
.val_vec
.length
10363 * a
->dw_attr_val
.v
.val_vec
.elt_size
)
10364 + a
->dw_attr_val
.v
.val_vec
.length
10365 * a
->dw_attr_val
.v
.val_vec
.elt_size
; /* block */
10367 case dw_val_class_flag
:
10368 if (dwarf_version
>= 4)
10369 /* Currently all add_AT_flag calls pass in 1 as last argument,
10370 so DW_FORM_flag_present can be used. If that ever changes,
10371 we'll need to use DW_FORM_flag and have some optimization
10372 in build_abbrev_table that will change those to
10373 DW_FORM_flag_present if it is set to 1 in all DIEs using
10374 the same abbrev entry. */
10375 gcc_assert (a
->dw_attr_val
.v
.val_flag
== 1);
10379 case dw_val_class_die_ref
:
10380 if (AT_ref_external (a
))
10382 /* In DWARF4, we use DW_FORM_sig8; for earlier versions
10383 we use DW_FORM_ref_addr. In DWARF2, DW_FORM_ref_addr
10384 is sized by target address length, whereas in DWARF3
10385 it's always sized as an offset. */
10386 if (dwarf_version
>= 4)
10387 size
+= DWARF_TYPE_SIGNATURE_SIZE
;
10388 else if (dwarf_version
== 2)
10389 size
+= DWARF2_ADDR_SIZE
;
10391 size
+= DWARF_OFFSET_SIZE
;
10394 size
+= DWARF_OFFSET_SIZE
;
10396 case dw_val_class_fde_ref
:
10397 size
+= DWARF_OFFSET_SIZE
;
10399 case dw_val_class_lbl_id
:
10400 size
+= DWARF2_ADDR_SIZE
;
10402 case dw_val_class_lineptr
:
10403 case dw_val_class_macptr
:
10404 size
+= DWARF_OFFSET_SIZE
;
10406 case dw_val_class_str
:
10407 if (AT_string_form (a
) == DW_FORM_strp
)
10408 size
+= DWARF_OFFSET_SIZE
;
10410 size
+= strlen (a
->dw_attr_val
.v
.val_str
->str
) + 1;
10412 case dw_val_class_file
:
10413 size
+= constant_size (maybe_emit_file (a
->dw_attr_val
.v
.val_file
));
10415 case dw_val_class_data8
:
10418 case dw_val_class_vms_delta
:
10419 size
+= DWARF_OFFSET_SIZE
;
10422 gcc_unreachable ();
10429 /* Size the debugging information associated with a given DIE. Visits the
10430 DIE's children recursively. Updates the global variable next_die_offset, on
10431 each time through. Uses the current value of next_die_offset to update the
10432 die_offset field in each DIE. */
10435 calc_die_sizes (dw_die_ref die
)
10439 die
->die_offset
= next_die_offset
;
10440 next_die_offset
+= size_of_die (die
);
10442 FOR_EACH_CHILD (die
, c
, calc_die_sizes (c
));
10444 if (die
->die_child
!= NULL
)
10445 /* Count the null byte used to terminate sibling lists. */
10446 next_die_offset
+= 1;
10449 /* Set the marks for a die and its children. We do this so
10450 that we know whether or not a reference needs to use FORM_ref_addr; only
10451 DIEs in the same CU will be marked. We used to clear out the offset
10452 and use that as the flag, but ran into ordering problems. */
10455 mark_dies (dw_die_ref die
)
10459 gcc_assert (!die
->die_mark
);
10462 FOR_EACH_CHILD (die
, c
, mark_dies (c
));
10465 /* Clear the marks for a die and its children. */
10468 unmark_dies (dw_die_ref die
)
10472 if (dwarf_version
< 4)
10473 gcc_assert (die
->die_mark
);
10476 FOR_EACH_CHILD (die
, c
, unmark_dies (c
));
10479 /* Clear the marks for a die, its children and referred dies. */
10482 unmark_all_dies (dw_die_ref die
)
10488 if (!die
->die_mark
)
10492 FOR_EACH_CHILD (die
, c
, unmark_all_dies (c
));
10494 for (ix
= 0; VEC_iterate (dw_attr_node
, die
->die_attr
, ix
, a
); ix
++)
10495 if (AT_class (a
) == dw_val_class_die_ref
)
10496 unmark_all_dies (AT_ref (a
));
10499 /* Return the size of the .debug_pubnames or .debug_pubtypes table
10500 generated for the compilation unit. */
10502 static unsigned long
10503 size_of_pubnames (VEC (pubname_entry
, gc
) * names
)
10505 unsigned long size
;
10509 size
= DWARF_PUBNAMES_HEADER_SIZE
;
10510 for (i
= 0; VEC_iterate (pubname_entry
, names
, i
, p
); i
++)
10511 if (names
!= pubtype_table
10512 || p
->die
->die_offset
!= 0
10513 || !flag_eliminate_unused_debug_types
)
10514 size
+= strlen (p
->name
) + DWARF_OFFSET_SIZE
+ 1;
10516 size
+= DWARF_OFFSET_SIZE
;
10520 /* Return the size of the information in the .debug_aranges section. */
10522 static unsigned long
10523 size_of_aranges (void)
10525 unsigned long size
;
10527 size
= DWARF_ARANGES_HEADER_SIZE
;
10529 /* Count the address/length pair for this compilation unit. */
10530 if (text_section_used
)
10531 size
+= 2 * DWARF2_ADDR_SIZE
;
10532 if (cold_text_section_used
)
10533 size
+= 2 * DWARF2_ADDR_SIZE
;
10534 size
+= 2 * DWARF2_ADDR_SIZE
* arange_table_in_use
;
10536 /* Count the two zero words used to terminated the address range table. */
10537 size
+= 2 * DWARF2_ADDR_SIZE
;
10541 /* Select the encoding of an attribute value. */
10543 static enum dwarf_form
10544 value_format (dw_attr_ref a
)
10546 switch (a
->dw_attr_val
.val_class
)
10548 case dw_val_class_addr
:
10549 /* Only very few attributes allow DW_FORM_addr. */
10550 switch (a
->dw_attr
)
10553 case DW_AT_high_pc
:
10554 case DW_AT_entry_pc
:
10555 case DW_AT_trampoline
:
10556 return DW_FORM_addr
;
10560 switch (DWARF2_ADDR_SIZE
)
10563 return DW_FORM_data1
;
10565 return DW_FORM_data2
;
10567 return DW_FORM_data4
;
10569 return DW_FORM_data8
;
10571 gcc_unreachable ();
10573 case dw_val_class_range_list
:
10574 case dw_val_class_loc_list
:
10575 if (dwarf_version
>= 4)
10576 return DW_FORM_sec_offset
;
10578 case dw_val_class_vms_delta
:
10579 case dw_val_class_offset
:
10580 switch (DWARF_OFFSET_SIZE
)
10583 return DW_FORM_data4
;
10585 return DW_FORM_data8
;
10587 gcc_unreachable ();
10589 case dw_val_class_loc
:
10590 if (dwarf_version
>= 4)
10591 return DW_FORM_exprloc
;
10592 switch (constant_size (size_of_locs (AT_loc (a
))))
10595 return DW_FORM_block1
;
10597 return DW_FORM_block2
;
10599 gcc_unreachable ();
10601 case dw_val_class_const
:
10602 return DW_FORM_sdata
;
10603 case dw_val_class_unsigned_const
:
10604 switch (constant_size (AT_unsigned (a
)))
10607 return DW_FORM_data1
;
10609 return DW_FORM_data2
;
10611 return DW_FORM_data4
;
10613 return DW_FORM_data8
;
10615 gcc_unreachable ();
10617 case dw_val_class_const_double
:
10618 switch (HOST_BITS_PER_WIDE_INT
)
10621 return DW_FORM_data2
;
10623 return DW_FORM_data4
;
10625 return DW_FORM_data8
;
10628 return DW_FORM_block1
;
10630 case dw_val_class_vec
:
10631 switch (constant_size (a
->dw_attr_val
.v
.val_vec
.length
10632 * a
->dw_attr_val
.v
.val_vec
.elt_size
))
10635 return DW_FORM_block1
;
10637 return DW_FORM_block2
;
10639 return DW_FORM_block4
;
10641 gcc_unreachable ();
10643 case dw_val_class_flag
:
10644 if (dwarf_version
>= 4)
10646 /* Currently all add_AT_flag calls pass in 1 as last argument,
10647 so DW_FORM_flag_present can be used. If that ever changes,
10648 we'll need to use DW_FORM_flag and have some optimization
10649 in build_abbrev_table that will change those to
10650 DW_FORM_flag_present if it is set to 1 in all DIEs using
10651 the same abbrev entry. */
10652 gcc_assert (a
->dw_attr_val
.v
.val_flag
== 1);
10653 return DW_FORM_flag_present
;
10655 return DW_FORM_flag
;
10656 case dw_val_class_die_ref
:
10657 if (AT_ref_external (a
))
10658 return dwarf_version
>= 4 ? DW_FORM_sig8
: DW_FORM_ref_addr
;
10660 return DW_FORM_ref
;
10661 case dw_val_class_fde_ref
:
10662 return DW_FORM_data
;
10663 case dw_val_class_lbl_id
:
10664 return DW_FORM_addr
;
10665 case dw_val_class_lineptr
:
10666 case dw_val_class_macptr
:
10667 return dwarf_version
>= 4 ? DW_FORM_sec_offset
: DW_FORM_data
;
10668 case dw_val_class_str
:
10669 return AT_string_form (a
);
10670 case dw_val_class_file
:
10671 switch (constant_size (maybe_emit_file (a
->dw_attr_val
.v
.val_file
)))
10674 return DW_FORM_data1
;
10676 return DW_FORM_data2
;
10678 return DW_FORM_data4
;
10680 gcc_unreachable ();
10683 case dw_val_class_data8
:
10684 return DW_FORM_data8
;
10687 gcc_unreachable ();
10691 /* Output the encoding of an attribute value. */
10694 output_value_format (dw_attr_ref a
)
10696 enum dwarf_form form
= value_format (a
);
10698 dw2_asm_output_data_uleb128 (form
, "(%s)", dwarf_form_name (form
));
10701 /* Output the .debug_abbrev section which defines the DIE abbreviation
10705 output_abbrev_section (void)
10707 unsigned long abbrev_id
;
10709 for (abbrev_id
= 1; abbrev_id
< abbrev_die_table_in_use
; ++abbrev_id
)
10711 dw_die_ref abbrev
= abbrev_die_table
[abbrev_id
];
10713 dw_attr_ref a_attr
;
10715 dw2_asm_output_data_uleb128 (abbrev_id
, "(abbrev code)");
10716 dw2_asm_output_data_uleb128 (abbrev
->die_tag
, "(TAG: %s)",
10717 dwarf_tag_name (abbrev
->die_tag
));
10719 if (abbrev
->die_child
!= NULL
)
10720 dw2_asm_output_data (1, DW_children_yes
, "DW_children_yes");
10722 dw2_asm_output_data (1, DW_children_no
, "DW_children_no");
10724 for (ix
= 0; VEC_iterate (dw_attr_node
, abbrev
->die_attr
, ix
, a_attr
);
10727 dw2_asm_output_data_uleb128 (a_attr
->dw_attr
, "(%s)",
10728 dwarf_attr_name (a_attr
->dw_attr
));
10729 output_value_format (a_attr
);
10732 dw2_asm_output_data (1, 0, NULL
);
10733 dw2_asm_output_data (1, 0, NULL
);
10736 /* Terminate the table. */
10737 dw2_asm_output_data (1, 0, NULL
);
10740 /* Output a symbol we can use to refer to this DIE from another CU. */
10743 output_die_symbol (dw_die_ref die
)
10745 char *sym
= die
->die_id
.die_symbol
;
10750 if (strncmp (sym
, DIE_LABEL_PREFIX
, sizeof (DIE_LABEL_PREFIX
) - 1) == 0)
10751 /* We make these global, not weak; if the target doesn't support
10752 .linkonce, it doesn't support combining the sections, so debugging
10754 targetm
.asm_out
.globalize_label (asm_out_file
, sym
);
10756 ASM_OUTPUT_LABEL (asm_out_file
, sym
);
10759 /* Return a new location list, given the begin and end range, and the
10762 static inline dw_loc_list_ref
10763 new_loc_list (dw_loc_descr_ref expr
, const char *begin
, const char *end
,
10764 const char *section
)
10766 dw_loc_list_ref retlist
= ggc_alloc_cleared_dw_loc_list_node ();
10768 retlist
->begin
= begin
;
10769 retlist
->end
= end
;
10770 retlist
->expr
= expr
;
10771 retlist
->section
= section
;
10776 /* Generate a new internal symbol for this location list node, if it
10777 hasn't got one yet. */
10780 gen_llsym (dw_loc_list_ref list
)
10782 gcc_assert (!list
->ll_symbol
);
10783 list
->ll_symbol
= gen_internal_sym ("LLST");
10786 /* Output the location list given to us. */
10789 output_loc_list (dw_loc_list_ref list_head
)
10791 dw_loc_list_ref curr
= list_head
;
10793 ASM_OUTPUT_LABEL (asm_out_file
, list_head
->ll_symbol
);
10795 /* Walk the location list, and output each range + expression. */
10796 for (curr
= list_head
; curr
!= NULL
; curr
= curr
->dw_loc_next
)
10798 unsigned long size
;
10799 /* Don't output an entry that starts and ends at the same address. */
10800 if (strcmp (curr
->begin
, curr
->end
) == 0)
10802 if (!have_multiple_function_sections
)
10804 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, curr
->begin
, curr
->section
,
10805 "Location list begin address (%s)",
10806 list_head
->ll_symbol
);
10807 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, curr
->end
, curr
->section
,
10808 "Location list end address (%s)",
10809 list_head
->ll_symbol
);
10813 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->begin
,
10814 "Location list begin address (%s)",
10815 list_head
->ll_symbol
);
10816 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->end
,
10817 "Location list end address (%s)",
10818 list_head
->ll_symbol
);
10820 size
= size_of_locs (curr
->expr
);
10822 /* Output the block length for this list of location operations. */
10823 gcc_assert (size
<= 0xffff);
10824 dw2_asm_output_data (2, size
, "%s", "Location expression size");
10826 output_loc_sequence (curr
->expr
);
10829 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0,
10830 "Location list terminator begin (%s)",
10831 list_head
->ll_symbol
);
10832 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0,
10833 "Location list terminator end (%s)",
10834 list_head
->ll_symbol
);
10837 /* Output a type signature. */
10840 output_signature (const char *sig
, const char *name
)
10844 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
10845 dw2_asm_output_data (1, sig
[i
], i
== 0 ? "%s" : NULL
, name
);
10848 /* Output the DIE and its attributes. Called recursively to generate
10849 the definitions of each child DIE. */
10852 output_die (dw_die_ref die
)
10856 unsigned long size
;
10859 /* If someone in another CU might refer to us, set up a symbol for
10860 them to point to. */
10861 if (dwarf_version
< 4 && die
->die_id
.die_symbol
)
10862 output_die_symbol (die
);
10864 dw2_asm_output_data_uleb128 (die
->die_abbrev
, "(DIE (%#lx) %s)",
10865 (unsigned long)die
->die_offset
,
10866 dwarf_tag_name (die
->die_tag
));
10868 for (ix
= 0; VEC_iterate (dw_attr_node
, die
->die_attr
, ix
, a
); ix
++)
10870 const char *name
= dwarf_attr_name (a
->dw_attr
);
10872 switch (AT_class (a
))
10874 case dw_val_class_addr
:
10875 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, AT_addr (a
), "%s", name
);
10878 case dw_val_class_offset
:
10879 dw2_asm_output_data (DWARF_OFFSET_SIZE
, a
->dw_attr_val
.v
.val_offset
,
10883 case dw_val_class_range_list
:
10885 char *p
= strchr (ranges_section_label
, '\0');
10887 sprintf (p
, "+" HOST_WIDE_INT_PRINT_HEX
,
10888 a
->dw_attr_val
.v
.val_offset
);
10889 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, ranges_section_label
,
10890 debug_ranges_section
, "%s", name
);
10895 case dw_val_class_loc
:
10896 size
= size_of_locs (AT_loc (a
));
10898 /* Output the block length for this list of location operations. */
10899 if (dwarf_version
>= 4)
10900 dw2_asm_output_data_uleb128 (size
, "%s", name
);
10902 dw2_asm_output_data (constant_size (size
), size
, "%s", name
);
10904 output_loc_sequence (AT_loc (a
));
10907 case dw_val_class_const
:
10908 /* ??? It would be slightly more efficient to use a scheme like is
10909 used for unsigned constants below, but gdb 4.x does not sign
10910 extend. Gdb 5.x does sign extend. */
10911 dw2_asm_output_data_sleb128 (AT_int (a
), "%s", name
);
10914 case dw_val_class_unsigned_const
:
10915 dw2_asm_output_data (constant_size (AT_unsigned (a
)),
10916 AT_unsigned (a
), "%s", name
);
10919 case dw_val_class_const_double
:
10921 unsigned HOST_WIDE_INT first
, second
;
10923 if (HOST_BITS_PER_WIDE_INT
>= 64)
10924 dw2_asm_output_data (1,
10925 2 * HOST_BITS_PER_WIDE_INT
10926 / HOST_BITS_PER_CHAR
,
10929 if (WORDS_BIG_ENDIAN
)
10931 first
= a
->dw_attr_val
.v
.val_double
.high
;
10932 second
= a
->dw_attr_val
.v
.val_double
.low
;
10936 first
= a
->dw_attr_val
.v
.val_double
.low
;
10937 second
= a
->dw_attr_val
.v
.val_double
.high
;
10940 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
10942 dw2_asm_output_data (HOST_BITS_PER_WIDE_INT
/ HOST_BITS_PER_CHAR
,
10947 case dw_val_class_vec
:
10949 unsigned int elt_size
= a
->dw_attr_val
.v
.val_vec
.elt_size
;
10950 unsigned int len
= a
->dw_attr_val
.v
.val_vec
.length
;
10954 dw2_asm_output_data (constant_size (len
* elt_size
),
10955 len
* elt_size
, "%s", name
);
10956 if (elt_size
> sizeof (HOST_WIDE_INT
))
10961 for (i
= 0, p
= a
->dw_attr_val
.v
.val_vec
.array
;
10963 i
++, p
+= elt_size
)
10964 dw2_asm_output_data (elt_size
, extract_int (p
, elt_size
),
10965 "fp or vector constant word %u", i
);
10969 case dw_val_class_flag
:
10970 if (dwarf_version
>= 4)
10972 /* Currently all add_AT_flag calls pass in 1 as last argument,
10973 so DW_FORM_flag_present can be used. If that ever changes,
10974 we'll need to use DW_FORM_flag and have some optimization
10975 in build_abbrev_table that will change those to
10976 DW_FORM_flag_present if it is set to 1 in all DIEs using
10977 the same abbrev entry. */
10978 gcc_assert (AT_flag (a
) == 1);
10979 if (flag_debug_asm
)
10980 fprintf (asm_out_file
, "\t\t\t%s %s\n",
10981 ASM_COMMENT_START
, name
);
10984 dw2_asm_output_data (1, AT_flag (a
), "%s", name
);
10987 case dw_val_class_loc_list
:
10989 char *sym
= AT_loc_list (a
)->ll_symbol
;
10992 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, sym
, debug_loc_section
,
10997 case dw_val_class_die_ref
:
10998 if (AT_ref_external (a
))
11000 if (dwarf_version
>= 4)
11002 comdat_type_node_ref type_node
=
11003 AT_ref (a
)->die_id
.die_type_node
;
11005 gcc_assert (type_node
);
11006 output_signature (type_node
->signature
, name
);
11010 char *sym
= AT_ref (a
)->die_id
.die_symbol
;
11014 /* In DWARF2, DW_FORM_ref_addr is sized by target address
11015 length, whereas in DWARF3 it's always sized as an
11017 if (dwarf_version
== 2)
11018 size
= DWARF2_ADDR_SIZE
;
11020 size
= DWARF_OFFSET_SIZE
;
11021 dw2_asm_output_offset (size
, sym
, debug_info_section
, "%s",
11027 gcc_assert (AT_ref (a
)->die_offset
);
11028 dw2_asm_output_data (DWARF_OFFSET_SIZE
, AT_ref (a
)->die_offset
,
11033 case dw_val_class_fde_ref
:
11037 ASM_GENERATE_INTERNAL_LABEL (l1
, FDE_LABEL
,
11038 a
->dw_attr_val
.v
.val_fde_index
* 2);
11039 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, l1
, debug_frame_section
,
11044 case dw_val_class_vms_delta
:
11045 dw2_asm_output_vms_delta (DWARF_OFFSET_SIZE
,
11046 AT_vms_delta2 (a
), AT_vms_delta1 (a
),
11050 case dw_val_class_lbl_id
:
11051 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, AT_lbl (a
), "%s", name
);
11054 case dw_val_class_lineptr
:
11055 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, AT_lbl (a
),
11056 debug_line_section
, "%s", name
);
11059 case dw_val_class_macptr
:
11060 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, AT_lbl (a
),
11061 debug_macinfo_section
, "%s", name
);
11064 case dw_val_class_str
:
11065 if (AT_string_form (a
) == DW_FORM_strp
)
11066 dw2_asm_output_offset (DWARF_OFFSET_SIZE
,
11067 a
->dw_attr_val
.v
.val_str
->label
,
11069 "%s: \"%s\"", name
, AT_string (a
));
11071 dw2_asm_output_nstring (AT_string (a
), -1, "%s", name
);
11074 case dw_val_class_file
:
11076 int f
= maybe_emit_file (a
->dw_attr_val
.v
.val_file
);
11078 dw2_asm_output_data (constant_size (f
), f
, "%s (%s)", name
,
11079 a
->dw_attr_val
.v
.val_file
->filename
);
11083 case dw_val_class_data8
:
11087 for (i
= 0; i
< 8; i
++)
11088 dw2_asm_output_data (1, a
->dw_attr_val
.v
.val_data8
[i
],
11089 i
== 0 ? "%s" : NULL
, name
);
11094 gcc_unreachable ();
11098 FOR_EACH_CHILD (die
, c
, output_die (c
));
11100 /* Add null byte to terminate sibling list. */
11101 if (die
->die_child
!= NULL
)
11102 dw2_asm_output_data (1, 0, "end of children of DIE %#lx",
11103 (unsigned long) die
->die_offset
);
11106 /* Output the compilation unit that appears at the beginning of the
11107 .debug_info section, and precedes the DIE descriptions. */
11110 output_compilation_unit_header (void)
11112 int ver
= dwarf_version
;
11114 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
11115 dw2_asm_output_data (4, 0xffffffff,
11116 "Initial length escape value indicating 64-bit DWARF extension");
11117 dw2_asm_output_data (DWARF_OFFSET_SIZE
,
11118 next_die_offset
- DWARF_INITIAL_LENGTH_SIZE
,
11119 "Length of Compilation Unit Info");
11120 dw2_asm_output_data (2, ver
, "DWARF version number");
11121 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, abbrev_section_label
,
11122 debug_abbrev_section
,
11123 "Offset Into Abbrev. Section");
11124 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Pointer Size (in bytes)");
11127 /* Output the compilation unit DIE and its children. */
11130 output_comp_unit (dw_die_ref die
, int output_if_empty
)
11132 const char *secname
;
11133 char *oldsym
, *tmp
;
11135 /* Unless we are outputting main CU, we may throw away empty ones. */
11136 if (!output_if_empty
&& die
->die_child
== NULL
)
11139 /* Even if there are no children of this DIE, we must output the information
11140 about the compilation unit. Otherwise, on an empty translation unit, we
11141 will generate a present, but empty, .debug_info section. IRIX 6.5 `nm'
11142 will then complain when examining the file. First mark all the DIEs in
11143 this CU so we know which get local refs. */
11146 build_abbrev_table (die
);
11148 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
11149 next_die_offset
= DWARF_COMPILE_UNIT_HEADER_SIZE
;
11150 calc_die_sizes (die
);
11152 oldsym
= die
->die_id
.die_symbol
;
11155 tmp
= XALLOCAVEC (char, strlen (oldsym
) + 24);
11157 sprintf (tmp
, ".gnu.linkonce.wi.%s", oldsym
);
11159 die
->die_id
.die_symbol
= NULL
;
11160 switch_to_section (get_section (secname
, SECTION_DEBUG
, NULL
));
11163 switch_to_section (debug_info_section
);
11165 /* Output debugging information. */
11166 output_compilation_unit_header ();
11169 /* Leave the marks on the main CU, so we can check them in
11170 output_pubnames. */
11174 die
->die_id
.die_symbol
= oldsym
;
11178 /* Output a comdat type unit DIE and its children. */
11181 output_comdat_type_unit (comdat_type_node
*node
)
11183 const char *secname
;
11186 #if defined (OBJECT_FORMAT_ELF)
11190 /* First mark all the DIEs in this CU so we know which get local refs. */
11191 mark_dies (node
->root_die
);
11193 build_abbrev_table (node
->root_die
);
11195 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
11196 next_die_offset
= DWARF_COMDAT_TYPE_UNIT_HEADER_SIZE
;
11197 calc_die_sizes (node
->root_die
);
11199 #if defined (OBJECT_FORMAT_ELF)
11200 secname
= ".debug_types";
11201 tmp
= XALLOCAVEC (char, 4 + DWARF_TYPE_SIGNATURE_SIZE
* 2);
11202 sprintf (tmp
, "wt.");
11203 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
11204 sprintf (tmp
+ 3 + i
* 2, "%02x", node
->signature
[i
] & 0xff);
11205 comdat_key
= get_identifier (tmp
);
11206 targetm
.asm_out
.named_section (secname
,
11207 SECTION_DEBUG
| SECTION_LINKONCE
,
11210 tmp
= XALLOCAVEC (char, 18 + DWARF_TYPE_SIGNATURE_SIZE
* 2);
11211 sprintf (tmp
, ".gnu.linkonce.wt.");
11212 for (i
= 0; i
< DWARF_TYPE_SIGNATURE_SIZE
; i
++)
11213 sprintf (tmp
+ 17 + i
* 2, "%02x", node
->signature
[i
] & 0xff);
11215 switch_to_section (get_section (secname
, SECTION_DEBUG
, NULL
));
11218 /* Output debugging information. */
11219 output_compilation_unit_header ();
11220 output_signature (node
->signature
, "Type Signature");
11221 dw2_asm_output_data (DWARF_OFFSET_SIZE
, node
->type_die
->die_offset
,
11222 "Offset to Type DIE");
11223 output_die (node
->root_die
);
11225 unmark_dies (node
->root_die
);
11228 /* Return the DWARF2/3 pubname associated with a decl. */
11230 static const char *
11231 dwarf2_name (tree decl
, int scope
)
11233 return lang_hooks
.dwarf_name (decl
, scope
? 1 : 0);
11236 /* Add a new entry to .debug_pubnames if appropriate. */
11239 add_pubname_string (const char *str
, dw_die_ref die
)
11241 if (targetm
.want_debug_pub_sections
)
11246 e
.name
= xstrdup (str
);
11247 VEC_safe_push (pubname_entry
, gc
, pubname_table
, &e
);
11252 add_pubname (tree decl
, dw_die_ref die
)
11254 if (targetm
.want_debug_pub_sections
&& TREE_PUBLIC (decl
))
11256 const char *name
= dwarf2_name (decl
, 1);
11258 add_pubname_string (name
, die
);
11262 /* Add a new entry to .debug_pubtypes if appropriate. */
11265 add_pubtype (tree decl
, dw_die_ref die
)
11269 if (!targetm
.want_debug_pub_sections
)
11273 if ((TREE_PUBLIC (decl
)
11274 || die
->die_parent
== comp_unit_die
)
11275 && (die
->die_tag
== DW_TAG_typedef
|| COMPLETE_TYPE_P (decl
)))
11280 if (TYPE_NAME (decl
))
11282 if (TREE_CODE (TYPE_NAME (decl
)) == IDENTIFIER_NODE
)
11283 e
.name
= IDENTIFIER_POINTER (TYPE_NAME (decl
));
11284 else if (TREE_CODE (TYPE_NAME (decl
)) == TYPE_DECL
11285 && DECL_NAME (TYPE_NAME (decl
)))
11286 e
.name
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (decl
)));
11288 e
.name
= xstrdup ((const char *) get_AT_string (die
, DW_AT_name
));
11293 e
.name
= dwarf2_name (decl
, 1);
11295 e
.name
= xstrdup (e
.name
);
11298 /* If we don't have a name for the type, there's no point in adding
11299 it to the table. */
11300 if (e
.name
&& e
.name
[0] != '\0')
11301 VEC_safe_push (pubname_entry
, gc
, pubtype_table
, &e
);
11305 /* Output the public names table used to speed up access to externally
11306 visible names; or the public types table used to find type definitions. */
11309 output_pubnames (VEC (pubname_entry
, gc
) * names
)
11312 unsigned long pubnames_length
= size_of_pubnames (names
);
11315 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
11316 dw2_asm_output_data (4, 0xffffffff,
11317 "Initial length escape value indicating 64-bit DWARF extension");
11318 if (names
== pubname_table
)
11319 dw2_asm_output_data (DWARF_OFFSET_SIZE
, pubnames_length
,
11320 "Length of Public Names Info");
11322 dw2_asm_output_data (DWARF_OFFSET_SIZE
, pubnames_length
,
11323 "Length of Public Type Names Info");
11324 /* Version number for pubnames/pubtypes is still 2, even in DWARF3. */
11325 dw2_asm_output_data (2, 2, "DWARF Version");
11326 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_info_section_label
,
11327 debug_info_section
,
11328 "Offset of Compilation Unit Info");
11329 dw2_asm_output_data (DWARF_OFFSET_SIZE
, next_die_offset
,
11330 "Compilation Unit Length");
11332 for (i
= 0; VEC_iterate (pubname_entry
, names
, i
, pub
); i
++)
11334 /* We shouldn't see pubnames for DIEs outside of the main CU. */
11335 if (names
== pubname_table
)
11336 gcc_assert (pub
->die
->die_mark
);
11338 if (names
!= pubtype_table
11339 || pub
->die
->die_offset
!= 0
11340 || !flag_eliminate_unused_debug_types
)
11342 dw2_asm_output_data (DWARF_OFFSET_SIZE
, pub
->die
->die_offset
,
11345 dw2_asm_output_nstring (pub
->name
, -1, "external name");
11349 dw2_asm_output_data (DWARF_OFFSET_SIZE
, 0, NULL
);
11352 /* Add a new entry to .debug_aranges if appropriate. */
11355 add_arange (tree decl
, dw_die_ref die
)
11357 if (! DECL_SECTION_NAME (decl
))
11360 if (arange_table_in_use
== arange_table_allocated
)
11362 arange_table_allocated
+= ARANGE_TABLE_INCREMENT
;
11363 arange_table
= GGC_RESIZEVEC (dw_die_ref
, arange_table
,
11364 arange_table_allocated
);
11365 memset (arange_table
+ arange_table_in_use
, 0,
11366 ARANGE_TABLE_INCREMENT
* sizeof (dw_die_ref
));
11369 arange_table
[arange_table_in_use
++] = die
;
11372 /* Output the information that goes into the .debug_aranges table.
11373 Namely, define the beginning and ending address range of the
11374 text section generated for this compilation unit. */
11377 output_aranges (void)
11380 unsigned long aranges_length
= size_of_aranges ();
11382 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
11383 dw2_asm_output_data (4, 0xffffffff,
11384 "Initial length escape value indicating 64-bit DWARF extension");
11385 dw2_asm_output_data (DWARF_OFFSET_SIZE
, aranges_length
,
11386 "Length of Address Ranges Info");
11387 /* Version number for aranges is still 2, even in DWARF3. */
11388 dw2_asm_output_data (2, 2, "DWARF Version");
11389 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_info_section_label
,
11390 debug_info_section
,
11391 "Offset of Compilation Unit Info");
11392 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Size of Address");
11393 dw2_asm_output_data (1, 0, "Size of Segment Descriptor");
11395 /* We need to align to twice the pointer size here. */
11396 if (DWARF_ARANGES_PAD_SIZE
)
11398 /* Pad using a 2 byte words so that padding is correct for any
11400 dw2_asm_output_data (2, 0, "Pad to %d byte boundary",
11401 2 * DWARF2_ADDR_SIZE
);
11402 for (i
= 2; i
< (unsigned) DWARF_ARANGES_PAD_SIZE
; i
+= 2)
11403 dw2_asm_output_data (2, 0, NULL
);
11406 /* It is necessary not to output these entries if the sections were
11407 not used; if the sections were not used, the length will be 0 and
11408 the address may end up as 0 if the section is discarded by ld
11409 --gc-sections, leaving an invalid (0, 0) entry that can be
11410 confused with the terminator. */
11411 if (text_section_used
)
11413 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, text_section_label
, "Address");
11414 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, text_end_label
,
11415 text_section_label
, "Length");
11417 if (cold_text_section_used
)
11419 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, cold_text_section_label
,
11421 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, cold_end_label
,
11422 cold_text_section_label
, "Length");
11425 for (i
= 0; i
< arange_table_in_use
; i
++)
11427 dw_die_ref die
= arange_table
[i
];
11429 /* We shouldn't see aranges for DIEs outside of the main CU. */
11430 gcc_assert (die
->die_mark
);
11432 if (die
->die_tag
== DW_TAG_subprogram
)
11434 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, get_AT_low_pc (die
),
11436 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, get_AT_hi_pc (die
),
11437 get_AT_low_pc (die
), "Length");
11441 /* A static variable; extract the symbol from DW_AT_location.
11442 Note that this code isn't currently hit, as we only emit
11443 aranges for functions (jason 9/23/99). */
11444 dw_attr_ref a
= get_AT (die
, DW_AT_location
);
11445 dw_loc_descr_ref loc
;
11447 gcc_assert (a
&& AT_class (a
) == dw_val_class_loc
);
11450 gcc_assert (loc
->dw_loc_opc
== DW_OP_addr
);
11452 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
,
11453 loc
->dw_loc_oprnd1
.v
.val_addr
, "Address");
11454 dw2_asm_output_data (DWARF2_ADDR_SIZE
,
11455 get_AT_unsigned (die
, DW_AT_byte_size
),
11460 /* Output the terminator words. */
11461 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
11462 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
11465 /* Add a new entry to .debug_ranges. Return the offset at which it
11468 static unsigned int
11469 add_ranges_num (int num
)
11471 unsigned int in_use
= ranges_table_in_use
;
11473 if (in_use
== ranges_table_allocated
)
11475 ranges_table_allocated
+= RANGES_TABLE_INCREMENT
;
11476 ranges_table
= GGC_RESIZEVEC (struct dw_ranges_struct
, ranges_table
,
11477 ranges_table_allocated
);
11478 memset (ranges_table
+ ranges_table_in_use
, 0,
11479 RANGES_TABLE_INCREMENT
* sizeof (struct dw_ranges_struct
));
11482 ranges_table
[in_use
].num
= num
;
11483 ranges_table_in_use
= in_use
+ 1;
11485 return in_use
* 2 * DWARF2_ADDR_SIZE
;
11488 /* Add a new entry to .debug_ranges corresponding to a block, or a
11489 range terminator if BLOCK is NULL. */
11491 static unsigned int
11492 add_ranges (const_tree block
)
11494 return add_ranges_num (block
? BLOCK_NUMBER (block
) : 0);
11497 /* Add a new entry to .debug_ranges corresponding to a pair of
11501 add_ranges_by_labels (dw_die_ref die
, const char *begin
, const char *end
,
11504 unsigned int in_use
= ranges_by_label_in_use
;
11505 unsigned int offset
;
11507 if (in_use
== ranges_by_label_allocated
)
11509 ranges_by_label_allocated
+= RANGES_TABLE_INCREMENT
;
11510 ranges_by_label
= GGC_RESIZEVEC (struct dw_ranges_by_label_struct
,
11512 ranges_by_label_allocated
);
11513 memset (ranges_by_label
+ ranges_by_label_in_use
, 0,
11514 RANGES_TABLE_INCREMENT
11515 * sizeof (struct dw_ranges_by_label_struct
));
11518 ranges_by_label
[in_use
].begin
= begin
;
11519 ranges_by_label
[in_use
].end
= end
;
11520 ranges_by_label_in_use
= in_use
+ 1;
11522 offset
= add_ranges_num (-(int)in_use
- 1);
11525 add_AT_range_list (die
, DW_AT_ranges
, offset
);
11531 output_ranges (void)
11534 static const char *const start_fmt
= "Offset %#x";
11535 const char *fmt
= start_fmt
;
11537 for (i
= 0; i
< ranges_table_in_use
; i
++)
11539 int block_num
= ranges_table
[i
].num
;
11543 char blabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
11544 char elabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
11546 ASM_GENERATE_INTERNAL_LABEL (blabel
, BLOCK_BEGIN_LABEL
, block_num
);
11547 ASM_GENERATE_INTERNAL_LABEL (elabel
, BLOCK_END_LABEL
, block_num
);
11549 /* If all code is in the text section, then the compilation
11550 unit base address defaults to DW_AT_low_pc, which is the
11551 base of the text section. */
11552 if (!have_multiple_function_sections
)
11554 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, blabel
,
11555 text_section_label
,
11556 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
11557 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, elabel
,
11558 text_section_label
, NULL
);
11561 /* Otherwise, the compilation unit base address is zero,
11562 which allows us to use absolute addresses, and not worry
11563 about whether the target supports cross-section
11567 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
11568 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
11569 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, elabel
, NULL
);
11575 /* Negative block_num stands for an index into ranges_by_label. */
11576 else if (block_num
< 0)
11578 int lab_idx
= - block_num
- 1;
11580 if (!have_multiple_function_sections
)
11582 gcc_unreachable ();
11584 /* If we ever use add_ranges_by_labels () for a single
11585 function section, all we have to do is to take out
11586 the #if 0 above. */
11587 dw2_asm_output_delta (DWARF2_ADDR_SIZE
,
11588 ranges_by_label
[lab_idx
].begin
,
11589 text_section_label
,
11590 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
11591 dw2_asm_output_delta (DWARF2_ADDR_SIZE
,
11592 ranges_by_label
[lab_idx
].end
,
11593 text_section_label
, NULL
);
11598 dw2_asm_output_addr (DWARF2_ADDR_SIZE
,
11599 ranges_by_label
[lab_idx
].begin
,
11600 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
11601 dw2_asm_output_addr (DWARF2_ADDR_SIZE
,
11602 ranges_by_label
[lab_idx
].end
,
11608 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
11609 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
11615 /* Data structure containing information about input files. */
11618 const char *path
; /* Complete file name. */
11619 const char *fname
; /* File name part. */
11620 int length
; /* Length of entire string. */
11621 struct dwarf_file_data
* file_idx
; /* Index in input file table. */
11622 int dir_idx
; /* Index in directory table. */
11625 /* Data structure containing information about directories with source
11629 const char *path
; /* Path including directory name. */
11630 int length
; /* Path length. */
11631 int prefix
; /* Index of directory entry which is a prefix. */
11632 int count
; /* Number of files in this directory. */
11633 int dir_idx
; /* Index of directory used as base. */
11636 /* Callback function for file_info comparison. We sort by looking at
11637 the directories in the path. */
11640 file_info_cmp (const void *p1
, const void *p2
)
11642 const struct file_info
*const s1
= (const struct file_info
*) p1
;
11643 const struct file_info
*const s2
= (const struct file_info
*) p2
;
11644 const unsigned char *cp1
;
11645 const unsigned char *cp2
;
11647 /* Take care of file names without directories. We need to make sure that
11648 we return consistent values to qsort since some will get confused if
11649 we return the same value when identical operands are passed in opposite
11650 orders. So if neither has a directory, return 0 and otherwise return
11651 1 or -1 depending on which one has the directory. */
11652 if ((s1
->path
== s1
->fname
|| s2
->path
== s2
->fname
))
11653 return (s2
->path
== s2
->fname
) - (s1
->path
== s1
->fname
);
11655 cp1
= (const unsigned char *) s1
->path
;
11656 cp2
= (const unsigned char *) s2
->path
;
11662 /* Reached the end of the first path? If so, handle like above. */
11663 if ((cp1
== (const unsigned char *) s1
->fname
)
11664 || (cp2
== (const unsigned char *) s2
->fname
))
11665 return ((cp2
== (const unsigned char *) s2
->fname
)
11666 - (cp1
== (const unsigned char *) s1
->fname
));
11668 /* Character of current path component the same? */
11669 else if (*cp1
!= *cp2
)
11670 return *cp1
- *cp2
;
11674 struct file_name_acquire_data
11676 struct file_info
*files
;
11681 /* Traversal function for the hash table. */
11684 file_name_acquire (void ** slot
, void *data
)
11686 struct file_name_acquire_data
*fnad
= (struct file_name_acquire_data
*) data
;
11687 struct dwarf_file_data
*d
= (struct dwarf_file_data
*) *slot
;
11688 struct file_info
*fi
;
11691 gcc_assert (fnad
->max_files
>= d
->emitted_number
);
11693 if (! d
->emitted_number
)
11696 gcc_assert (fnad
->max_files
!= fnad
->used_files
);
11698 fi
= fnad
->files
+ fnad
->used_files
++;
11700 /* Skip all leading "./". */
11702 while (f
[0] == '.' && IS_DIR_SEPARATOR (f
[1]))
11705 /* Create a new array entry. */
11707 fi
->length
= strlen (f
);
11710 /* Search for the file name part. */
11711 f
= strrchr (f
, DIR_SEPARATOR
);
11712 #if defined (DIR_SEPARATOR_2)
11714 char *g
= strrchr (fi
->path
, DIR_SEPARATOR_2
);
11718 if (f
== NULL
|| f
< g
)
11724 fi
->fname
= f
== NULL
? fi
->path
: f
+ 1;
11728 /* Output the directory table and the file name table. We try to minimize
11729 the total amount of memory needed. A heuristic is used to avoid large
11730 slowdowns with many input files. */
11733 output_file_names (void)
11735 struct file_name_acquire_data fnad
;
11737 struct file_info
*files
;
11738 struct dir_info
*dirs
;
11746 if (!last_emitted_file
)
11748 dw2_asm_output_data (1, 0, "End directory table");
11749 dw2_asm_output_data (1, 0, "End file name table");
11753 numfiles
= last_emitted_file
->emitted_number
;
11755 /* Allocate the various arrays we need. */
11756 files
= XALLOCAVEC (struct file_info
, numfiles
);
11757 dirs
= XALLOCAVEC (struct dir_info
, numfiles
);
11759 fnad
.files
= files
;
11760 fnad
.used_files
= 0;
11761 fnad
.max_files
= numfiles
;
11762 htab_traverse (file_table
, file_name_acquire
, &fnad
);
11763 gcc_assert (fnad
.used_files
== fnad
.max_files
);
11765 qsort (files
, numfiles
, sizeof (files
[0]), file_info_cmp
);
11767 /* Find all the different directories used. */
11768 dirs
[0].path
= files
[0].path
;
11769 dirs
[0].length
= files
[0].fname
- files
[0].path
;
11770 dirs
[0].prefix
= -1;
11772 dirs
[0].dir_idx
= 0;
11773 files
[0].dir_idx
= 0;
11776 for (i
= 1; i
< numfiles
; i
++)
11777 if (files
[i
].fname
- files
[i
].path
== dirs
[ndirs
- 1].length
11778 && memcmp (dirs
[ndirs
- 1].path
, files
[i
].path
,
11779 dirs
[ndirs
- 1].length
) == 0)
11781 /* Same directory as last entry. */
11782 files
[i
].dir_idx
= ndirs
- 1;
11783 ++dirs
[ndirs
- 1].count
;
11789 /* This is a new directory. */
11790 dirs
[ndirs
].path
= files
[i
].path
;
11791 dirs
[ndirs
].length
= files
[i
].fname
- files
[i
].path
;
11792 dirs
[ndirs
].count
= 1;
11793 dirs
[ndirs
].dir_idx
= ndirs
;
11794 files
[i
].dir_idx
= ndirs
;
11796 /* Search for a prefix. */
11797 dirs
[ndirs
].prefix
= -1;
11798 for (j
= 0; j
< ndirs
; j
++)
11799 if (dirs
[j
].length
< dirs
[ndirs
].length
11800 && dirs
[j
].length
> 1
11801 && (dirs
[ndirs
].prefix
== -1
11802 || dirs
[j
].length
> dirs
[dirs
[ndirs
].prefix
].length
)
11803 && memcmp (dirs
[j
].path
, dirs
[ndirs
].path
, dirs
[j
].length
) == 0)
11804 dirs
[ndirs
].prefix
= j
;
11809 /* Now to the actual work. We have to find a subset of the directories which
11810 allow expressing the file name using references to the directory table
11811 with the least amount of characters. We do not do an exhaustive search
11812 where we would have to check out every combination of every single
11813 possible prefix. Instead we use a heuristic which provides nearly optimal
11814 results in most cases and never is much off. */
11815 saved
= XALLOCAVEC (int, ndirs
);
11816 savehere
= XALLOCAVEC (int, ndirs
);
11818 memset (saved
, '\0', ndirs
* sizeof (saved
[0]));
11819 for (i
= 0; i
< ndirs
; i
++)
11824 /* We can always save some space for the current directory. But this
11825 does not mean it will be enough to justify adding the directory. */
11826 savehere
[i
] = dirs
[i
].length
;
11827 total
= (savehere
[i
] - saved
[i
]) * dirs
[i
].count
;
11829 for (j
= i
+ 1; j
< ndirs
; j
++)
11832 if (saved
[j
] < dirs
[i
].length
)
11834 /* Determine whether the dirs[i] path is a prefix of the
11838 k
= dirs
[j
].prefix
;
11839 while (k
!= -1 && k
!= (int) i
)
11840 k
= dirs
[k
].prefix
;
11844 /* Yes it is. We can possibly save some memory by
11845 writing the filenames in dirs[j] relative to
11847 savehere
[j
] = dirs
[i
].length
;
11848 total
+= (savehere
[j
] - saved
[j
]) * dirs
[j
].count
;
11853 /* Check whether we can save enough to justify adding the dirs[i]
11855 if (total
> dirs
[i
].length
+ 1)
11857 /* It's worthwhile adding. */
11858 for (j
= i
; j
< ndirs
; j
++)
11859 if (savehere
[j
] > 0)
11861 /* Remember how much we saved for this directory so far. */
11862 saved
[j
] = savehere
[j
];
11864 /* Remember the prefix directory. */
11865 dirs
[j
].dir_idx
= i
;
11870 /* Emit the directory name table. */
11871 idx_offset
= dirs
[0].length
> 0 ? 1 : 0;
11872 for (i
= 1 - idx_offset
; i
< ndirs
; i
++)
11873 dw2_asm_output_nstring (dirs
[i
].path
,
11875 - !DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
,
11876 "Directory Entry: %#x", i
+ idx_offset
);
11878 dw2_asm_output_data (1, 0, "End directory table");
11880 /* We have to emit them in the order of emitted_number since that's
11881 used in the debug info generation. To do this efficiently we
11882 generate a back-mapping of the indices first. */
11883 backmap
= XALLOCAVEC (int, numfiles
);
11884 for (i
= 0; i
< numfiles
; i
++)
11885 backmap
[files
[i
].file_idx
->emitted_number
- 1] = i
;
11887 /* Now write all the file names. */
11888 for (i
= 0; i
< numfiles
; i
++)
11890 int file_idx
= backmap
[i
];
11891 int dir_idx
= dirs
[files
[file_idx
].dir_idx
].dir_idx
;
11893 #ifdef VMS_DEBUGGING_INFO
11894 #define MAX_VMS_VERSION_LEN 6 /* ";32768" */
11896 /* Setting these fields can lead to debugger miscomparisons,
11897 but VMS Debug requires them to be set correctly. */
11902 int maxfilelen
= strlen (files
[file_idx
].path
)
11903 + dirs
[dir_idx
].length
11904 + MAX_VMS_VERSION_LEN
+ 1;
11905 char *filebuf
= XALLOCAVEC (char, maxfilelen
);
11907 vms_file_stats_name (files
[file_idx
].path
, 0, 0, 0, &ver
);
11908 snprintf (filebuf
, maxfilelen
, "%s;%d",
11909 files
[file_idx
].path
+ dirs
[dir_idx
].length
, ver
);
11911 dw2_asm_output_nstring
11912 (filebuf
, -1, "File Entry: %#x", (unsigned) i
+ 1);
11914 /* Include directory index. */
11915 dw2_asm_output_data_uleb128 (dir_idx
+ idx_offset
, NULL
);
11917 /* Modification time. */
11918 dw2_asm_output_data_uleb128
11919 ((vms_file_stats_name (files
[file_idx
].path
, &cdt
, 0, 0, 0) == 0)
11923 /* File length in bytes. */
11924 dw2_asm_output_data_uleb128
11925 ((vms_file_stats_name (files
[file_idx
].path
, 0, &siz
, 0, 0) == 0)
11929 dw2_asm_output_nstring (files
[file_idx
].path
+ dirs
[dir_idx
].length
, -1,
11930 "File Entry: %#x", (unsigned) i
+ 1);
11932 /* Include directory index. */
11933 dw2_asm_output_data_uleb128 (dir_idx
+ idx_offset
, NULL
);
11935 /* Modification time. */
11936 dw2_asm_output_data_uleb128 (0, NULL
);
11938 /* File length in bytes. */
11939 dw2_asm_output_data_uleb128 (0, NULL
);
11943 dw2_asm_output_data (1, 0, "End file name table");
11947 /* Output the source line number correspondence information. This
11948 information goes into the .debug_line section. */
11951 output_line_info (void)
11953 char l1
[20], l2
[20], p1
[20], p2
[20];
11954 char line_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
11955 char prev_line_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
11957 unsigned n_op_args
;
11958 unsigned long lt_index
;
11959 unsigned long current_line
;
11962 unsigned long current_file
;
11963 unsigned long function
;
11964 int ver
= dwarf_version
;
11966 ASM_GENERATE_INTERNAL_LABEL (l1
, LINE_NUMBER_BEGIN_LABEL
, 0);
11967 ASM_GENERATE_INTERNAL_LABEL (l2
, LINE_NUMBER_END_LABEL
, 0);
11968 ASM_GENERATE_INTERNAL_LABEL (p1
, LN_PROLOG_AS_LABEL
, 0);
11969 ASM_GENERATE_INTERNAL_LABEL (p2
, LN_PROLOG_END_LABEL
, 0);
11971 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
11972 dw2_asm_output_data (4, 0xffffffff,
11973 "Initial length escape value indicating 64-bit DWARF extension");
11974 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, l2
, l1
,
11975 "Length of Source Line Info");
11976 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
11978 dw2_asm_output_data (2, ver
, "DWARF Version");
11979 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, p2
, p1
, "Prolog Length");
11980 ASM_OUTPUT_LABEL (asm_out_file
, p1
);
11982 /* Define the architecture-dependent minimum instruction length (in
11983 bytes). In this implementation of DWARF, this field is used for
11984 information purposes only. Since GCC generates assembly language,
11985 we have no a priori knowledge of how many instruction bytes are
11986 generated for each source line, and therefore can use only the
11987 DW_LNE_set_address and DW_LNS_fixed_advance_pc line information
11988 commands. Accordingly, we fix this as `1', which is "correct
11989 enough" for all architectures, and don't let the target override. */
11990 dw2_asm_output_data (1, 1,
11991 "Minimum Instruction Length");
11994 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_MAX_OPS_PER_INSN
,
11995 "Maximum Operations Per Instruction");
11996 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START
,
11997 "Default is_stmt_start flag");
11998 dw2_asm_output_data (1, DWARF_LINE_BASE
,
11999 "Line Base Value (Special Opcodes)");
12000 dw2_asm_output_data (1, DWARF_LINE_RANGE
,
12001 "Line Range Value (Special Opcodes)");
12002 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE
,
12003 "Special Opcode Base");
12005 for (opc
= 1; opc
< DWARF_LINE_OPCODE_BASE
; opc
++)
12009 case DW_LNS_advance_pc
:
12010 case DW_LNS_advance_line
:
12011 case DW_LNS_set_file
:
12012 case DW_LNS_set_column
:
12013 case DW_LNS_fixed_advance_pc
:
12021 dw2_asm_output_data (1, n_op_args
, "opcode: %#x has %d args",
12025 /* Write out the information about the files we use. */
12026 output_file_names ();
12027 ASM_OUTPUT_LABEL (asm_out_file
, p2
);
12029 /* We used to set the address register to the first location in the text
12030 section here, but that didn't accomplish anything since we already
12031 have a line note for the opening brace of the first function. */
12033 /* Generate the line number to PC correspondence table, encoded as
12034 a series of state machine operations. */
12038 if (cfun
&& in_cold_section_p
)
12039 strcpy (prev_line_label
, crtl
->subsections
.cold_section_label
);
12041 strcpy (prev_line_label
, text_section_label
);
12042 for (lt_index
= 1; lt_index
< line_info_table_in_use
; ++lt_index
)
12044 dw_line_info_ref line_info
= &line_info_table
[lt_index
];
12047 /* Disable this optimization for now; GDB wants to see two line notes
12048 at the beginning of a function so it can find the end of the
12051 /* Don't emit anything for redundant notes. Just updating the
12052 address doesn't accomplish anything, because we already assume
12053 that anything after the last address is this line. */
12054 if (line_info
->dw_line_num
== current_line
12055 && line_info
->dw_file_num
== current_file
)
12059 /* Emit debug info for the address of the current line.
12061 Unfortunately, we have little choice here currently, and must always
12062 use the most general form. GCC does not know the address delta
12063 itself, so we can't use DW_LNS_advance_pc. Many ports do have length
12064 attributes which will give an upper bound on the address range. We
12065 could perhaps use length attributes to determine when it is safe to
12066 use DW_LNS_fixed_advance_pc. */
12068 ASM_GENERATE_INTERNAL_LABEL (line_label
, LINE_CODE_LABEL
, lt_index
);
12071 /* This can handle deltas up to 0xffff. This takes 3 bytes. */
12072 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc
,
12073 "DW_LNS_fixed_advance_pc");
12074 dw2_asm_output_delta (2, line_label
, prev_line_label
, NULL
);
12078 /* This can handle any delta. This takes
12079 4+DWARF2_ADDR_SIZE bytes. */
12080 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
12081 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE
, NULL
);
12082 dw2_asm_output_data (1, DW_LNE_set_address
, NULL
);
12083 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, line_label
, NULL
);
12086 strcpy (prev_line_label
, line_label
);
12088 /* Emit debug info for the source file of the current line, if
12089 different from the previous line. */
12090 if (line_info
->dw_file_num
!= current_file
)
12092 current_file
= line_info
->dw_file_num
;
12093 dw2_asm_output_data (1, DW_LNS_set_file
, "DW_LNS_set_file");
12094 dw2_asm_output_data_uleb128 (current_file
, "%lu", current_file
);
12097 /* Emit debug info for the current line number, choosing the encoding
12098 that uses the least amount of space. */
12099 if (line_info
->dw_line_num
!= current_line
)
12101 line_offset
= line_info
->dw_line_num
- current_line
;
12102 line_delta
= line_offset
- DWARF_LINE_BASE
;
12103 current_line
= line_info
->dw_line_num
;
12104 if (line_delta
>= 0 && line_delta
< (DWARF_LINE_RANGE
- 1))
12105 /* This can handle deltas from -10 to 234, using the current
12106 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE. This
12108 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE
+ line_delta
,
12109 "line %lu", current_line
);
12112 /* This can handle any delta. This takes at least 4 bytes,
12113 depending on the value being encoded. */
12114 dw2_asm_output_data (1, DW_LNS_advance_line
,
12115 "advance to line %lu", current_line
);
12116 dw2_asm_output_data_sleb128 (line_offset
, NULL
);
12117 dw2_asm_output_data (1, DW_LNS_copy
, "DW_LNS_copy");
12121 /* We still need to start a new row, so output a copy insn. */
12122 dw2_asm_output_data (1, DW_LNS_copy
, "DW_LNS_copy");
12125 /* Emit debug info for the address of the end of the function. */
12128 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc
,
12129 "DW_LNS_fixed_advance_pc");
12130 dw2_asm_output_delta (2, text_end_label
, prev_line_label
, NULL
);
12134 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
12135 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE
, NULL
);
12136 dw2_asm_output_data (1, DW_LNE_set_address
, NULL
);
12137 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, text_end_label
, NULL
);
12140 dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
12141 dw2_asm_output_data_uleb128 (1, NULL
);
12142 dw2_asm_output_data (1, DW_LNE_end_sequence
, NULL
);
12147 for (lt_index
= 0; lt_index
< separate_line_info_table_in_use
;)
12149 dw_separate_line_info_ref line_info
12150 = &separate_line_info_table
[lt_index
];
12153 /* Don't emit anything for redundant notes. */
12154 if (line_info
->dw_line_num
== current_line
12155 && line_info
->dw_file_num
== current_file
12156 && line_info
->function
== function
)
12160 /* Emit debug info for the address of the current line. If this is
12161 a new function, or the first line of a function, then we need
12162 to handle it differently. */
12163 ASM_GENERATE_INTERNAL_LABEL (line_label
, SEPARATE_LINE_CODE_LABEL
,
12165 if (function
!= line_info
->function
)
12167 function
= line_info
->function
;
12169 /* Set the address register to the first line in the function. */
12170 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
12171 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE
, NULL
);
12172 dw2_asm_output_data (1, DW_LNE_set_address
, NULL
);
12173 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, line_label
, NULL
);
12177 /* ??? See the DW_LNS_advance_pc comment above. */
12180 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc
,
12181 "DW_LNS_fixed_advance_pc");
12182 dw2_asm_output_delta (2, line_label
, prev_line_label
, NULL
);
12186 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
12187 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE
, NULL
);
12188 dw2_asm_output_data (1, DW_LNE_set_address
, NULL
);
12189 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, line_label
, NULL
);
12193 strcpy (prev_line_label
, line_label
);
12195 /* Emit debug info for the source file of the current line, if
12196 different from the previous line. */
12197 if (line_info
->dw_file_num
!= current_file
)
12199 current_file
= line_info
->dw_file_num
;
12200 dw2_asm_output_data (1, DW_LNS_set_file
, "DW_LNS_set_file");
12201 dw2_asm_output_data_uleb128 (current_file
, "%lu", current_file
);
12204 /* Emit debug info for the current line number, choosing the encoding
12205 that uses the least amount of space. */
12206 if (line_info
->dw_line_num
!= current_line
)
12208 line_offset
= line_info
->dw_line_num
- current_line
;
12209 line_delta
= line_offset
- DWARF_LINE_BASE
;
12210 current_line
= line_info
->dw_line_num
;
12211 if (line_delta
>= 0 && line_delta
< (DWARF_LINE_RANGE
- 1))
12212 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE
+ line_delta
,
12213 "line %lu", current_line
);
12216 dw2_asm_output_data (1, DW_LNS_advance_line
,
12217 "advance to line %lu", current_line
);
12218 dw2_asm_output_data_sleb128 (line_offset
, NULL
);
12219 dw2_asm_output_data (1, DW_LNS_copy
, "DW_LNS_copy");
12223 dw2_asm_output_data (1, DW_LNS_copy
, "DW_LNS_copy");
12231 /* If we're done with a function, end its sequence. */
12232 if (lt_index
== separate_line_info_table_in_use
12233 || separate_line_info_table
[lt_index
].function
!= function
)
12238 /* Emit debug info for the address of the end of the function. */
12239 ASM_GENERATE_INTERNAL_LABEL (line_label
, FUNC_END_LABEL
, function
);
12242 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc
,
12243 "DW_LNS_fixed_advance_pc");
12244 dw2_asm_output_delta (2, line_label
, prev_line_label
, NULL
);
12248 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
12249 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE
, NULL
);
12250 dw2_asm_output_data (1, DW_LNE_set_address
, NULL
);
12251 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, line_label
, NULL
);
12254 /* Output the marker for the end of this sequence. */
12255 dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
12256 dw2_asm_output_data_uleb128 (1, NULL
);
12257 dw2_asm_output_data (1, DW_LNE_end_sequence
, NULL
);
12261 /* Output the marker for the end of the line number info. */
12262 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
12265 /* Return the size of the .debug_dcall table for the compilation unit. */
12267 static unsigned long
12268 size_of_dcall_table (void)
12270 unsigned long size
;
12273 tree last_poc_decl
= NULL
;
12275 /* Header: version + debug info section pointer + pointer size. */
12276 size
= 2 + DWARF_OFFSET_SIZE
+ 1;
12278 /* Each entry: code label + DIE offset. */
12279 for (i
= 0; VEC_iterate (dcall_entry
, dcall_table
, i
, p
); i
++)
12281 gcc_assert (p
->targ_die
!= NULL
);
12282 /* Insert a "from" entry when the point-of-call DIE offset changes. */
12283 if (p
->poc_decl
!= last_poc_decl
)
12285 dw_die_ref poc_die
= lookup_decl_die (p
->poc_decl
);
12286 gcc_assert (poc_die
);
12287 last_poc_decl
= p
->poc_decl
;
12289 size
+= (DWARF_OFFSET_SIZE
12290 + size_of_uleb128 (poc_die
->die_offset
));
12292 size
+= DWARF_OFFSET_SIZE
+ size_of_uleb128 (p
->targ_die
->die_offset
);
12298 /* Output the direct call table used to disambiguate PC values when
12299 identical function have been merged. */
12302 output_dcall_table (void)
12305 unsigned long dcall_length
= size_of_dcall_table ();
12307 char poc_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
12308 tree last_poc_decl
= NULL
;
12310 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
12311 dw2_asm_output_data (4, 0xffffffff,
12312 "Initial length escape value indicating 64-bit DWARF extension");
12313 dw2_asm_output_data (DWARF_OFFSET_SIZE
, dcall_length
,
12314 "Length of Direct Call Table");
12315 dw2_asm_output_data (2, 4, "Version number");
12316 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_info_section_label
,
12317 debug_info_section
,
12318 "Offset of Compilation Unit Info");
12319 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Pointer Size (in bytes)");
12321 for (i
= 0; VEC_iterate (dcall_entry
, dcall_table
, i
, p
); i
++)
12323 /* Insert a "from" entry when the point-of-call DIE offset changes. */
12324 if (p
->poc_decl
!= last_poc_decl
)
12326 dw_die_ref poc_die
= lookup_decl_die (p
->poc_decl
);
12327 last_poc_decl
= p
->poc_decl
;
12330 dw2_asm_output_data (DWARF_OFFSET_SIZE
, 0, "New caller");
12331 dw2_asm_output_data_uleb128 (poc_die
->die_offset
,
12332 "Caller DIE offset");
12335 ASM_GENERATE_INTERNAL_LABEL (poc_label
, "LPOC", p
->poc_label_num
);
12336 dw2_asm_output_addr (DWARF_OFFSET_SIZE
, poc_label
, "Point of call");
12337 dw2_asm_output_data_uleb128 (p
->targ_die
->die_offset
,
12338 "Callee DIE offset");
12342 /* Return the size of the .debug_vcall table for the compilation unit. */
12344 static unsigned long
12345 size_of_vcall_table (void)
12347 unsigned long size
;
12351 /* Header: version + pointer size. */
12354 /* Each entry: code label + vtable slot index. */
12355 for (i
= 0; VEC_iterate (vcall_entry
, vcall_table
, i
, p
); i
++)
12356 size
+= DWARF_OFFSET_SIZE
+ size_of_uleb128 (p
->vtable_slot
);
12361 /* Output the virtual call table used to disambiguate PC values when
12362 identical function have been merged. */
12365 output_vcall_table (void)
12368 unsigned long vcall_length
= size_of_vcall_table ();
12370 char poc_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
12372 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
12373 dw2_asm_output_data (4, 0xffffffff,
12374 "Initial length escape value indicating 64-bit DWARF extension");
12375 dw2_asm_output_data (DWARF_OFFSET_SIZE
, vcall_length
,
12376 "Length of Virtual Call Table");
12377 dw2_asm_output_data (2, 4, "Version number");
12378 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Pointer Size (in bytes)");
12380 for (i
= 0; VEC_iterate (vcall_entry
, vcall_table
, i
, p
); i
++)
12382 ASM_GENERATE_INTERNAL_LABEL (poc_label
, "LPOC", p
->poc_label_num
);
12383 dw2_asm_output_addr (DWARF_OFFSET_SIZE
, poc_label
, "Point of call");
12384 dw2_asm_output_data_uleb128 (p
->vtable_slot
, "Vtable slot");
12388 /* Given a pointer to a tree node for some base type, return a pointer to
12389 a DIE that describes the given type.
12391 This routine must only be called for GCC type nodes that correspond to
12392 Dwarf base (fundamental) types. */
12395 base_type_die (tree type
)
12397 dw_die_ref base_type_result
;
12398 enum dwarf_type encoding
;
12400 if (TREE_CODE (type
) == ERROR_MARK
|| TREE_CODE (type
) == VOID_TYPE
)
12403 /* If this is a subtype that should not be emitted as a subrange type,
12404 use the base type. See subrange_type_for_debug_p. */
12405 if (TREE_CODE (type
) == INTEGER_TYPE
&& TREE_TYPE (type
) != NULL_TREE
)
12406 type
= TREE_TYPE (type
);
12408 switch (TREE_CODE (type
))
12411 if ((dwarf_version
>= 4 || !dwarf_strict
)
12412 && TYPE_NAME (type
)
12413 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
12414 && DECL_IS_BUILTIN (TYPE_NAME (type
))
12415 && DECL_NAME (TYPE_NAME (type
)))
12417 const char *name
= IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type
)));
12418 if (strcmp (name
, "char16_t") == 0
12419 || strcmp (name
, "char32_t") == 0)
12421 encoding
= DW_ATE_UTF
;
12425 if (TYPE_STRING_FLAG (type
))
12427 if (TYPE_UNSIGNED (type
))
12428 encoding
= DW_ATE_unsigned_char
;
12430 encoding
= DW_ATE_signed_char
;
12432 else if (TYPE_UNSIGNED (type
))
12433 encoding
= DW_ATE_unsigned
;
12435 encoding
= DW_ATE_signed
;
12439 if (DECIMAL_FLOAT_MODE_P (TYPE_MODE (type
)))
12441 if (dwarf_version
>= 3 || !dwarf_strict
)
12442 encoding
= DW_ATE_decimal_float
;
12444 encoding
= DW_ATE_lo_user
;
12447 encoding
= DW_ATE_float
;
12450 case FIXED_POINT_TYPE
:
12451 if (!(dwarf_version
>= 3 || !dwarf_strict
))
12452 encoding
= DW_ATE_lo_user
;
12453 else if (TYPE_UNSIGNED (type
))
12454 encoding
= DW_ATE_unsigned_fixed
;
12456 encoding
= DW_ATE_signed_fixed
;
12459 /* Dwarf2 doesn't know anything about complex ints, so use
12460 a user defined type for it. */
12462 if (TREE_CODE (TREE_TYPE (type
)) == REAL_TYPE
)
12463 encoding
= DW_ATE_complex_float
;
12465 encoding
= DW_ATE_lo_user
;
12469 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */
12470 encoding
= DW_ATE_boolean
;
12474 /* No other TREE_CODEs are Dwarf fundamental types. */
12475 gcc_unreachable ();
12478 base_type_result
= new_die (DW_TAG_base_type
, comp_unit_die
, type
);
12480 add_AT_unsigned (base_type_result
, DW_AT_byte_size
,
12481 int_size_in_bytes (type
));
12482 add_AT_unsigned (base_type_result
, DW_AT_encoding
, encoding
);
12484 return base_type_result
;
12487 /* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the
12488 given input type is a Dwarf "fundamental" type. Otherwise return null. */
12491 is_base_type (tree type
)
12493 switch (TREE_CODE (type
))
12499 case FIXED_POINT_TYPE
:
12507 case QUAL_UNION_TYPE
:
12508 case ENUMERAL_TYPE
:
12509 case FUNCTION_TYPE
:
12512 case REFERENCE_TYPE
:
12519 gcc_unreachable ();
12525 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
12526 node, return the size in bits for the type if it is a constant, or else
12527 return the alignment for the type if the type's size is not constant, or
12528 else return BITS_PER_WORD if the type actually turns out to be an
12529 ERROR_MARK node. */
12531 static inline unsigned HOST_WIDE_INT
12532 simple_type_size_in_bits (const_tree type
)
12534 if (TREE_CODE (type
) == ERROR_MARK
)
12535 return BITS_PER_WORD
;
12536 else if (TYPE_SIZE (type
) == NULL_TREE
)
12538 else if (host_integerp (TYPE_SIZE (type
), 1))
12539 return tree_low_cst (TYPE_SIZE (type
), 1);
12541 return TYPE_ALIGN (type
);
12544 /* Similarly, but return a double_int instead of UHWI. */
12546 static inline double_int
12547 double_int_type_size_in_bits (const_tree type
)
12549 if (TREE_CODE (type
) == ERROR_MARK
)
12550 return uhwi_to_double_int (BITS_PER_WORD
);
12551 else if (TYPE_SIZE (type
) == NULL_TREE
)
12552 return double_int_zero
;
12553 else if (TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
)
12554 return tree_to_double_int (TYPE_SIZE (type
));
12556 return uhwi_to_double_int (TYPE_ALIGN (type
));
12559 /* Given a pointer to a tree node for a subrange type, return a pointer
12560 to a DIE that describes the given type. */
12563 subrange_type_die (tree type
, tree low
, tree high
, dw_die_ref context_die
)
12565 dw_die_ref subrange_die
;
12566 const HOST_WIDE_INT size_in_bytes
= int_size_in_bytes (type
);
12568 if (context_die
== NULL
)
12569 context_die
= comp_unit_die
;
12571 subrange_die
= new_die (DW_TAG_subrange_type
, context_die
, type
);
12573 if (int_size_in_bytes (TREE_TYPE (type
)) != size_in_bytes
)
12575 /* The size of the subrange type and its base type do not match,
12576 so we need to generate a size attribute for the subrange type. */
12577 add_AT_unsigned (subrange_die
, DW_AT_byte_size
, size_in_bytes
);
12581 add_bound_info (subrange_die
, DW_AT_lower_bound
, low
);
12583 add_bound_info (subrange_die
, DW_AT_upper_bound
, high
);
12585 return subrange_die
;
12588 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
12589 entry that chains various modifiers in front of the given type. */
12592 modified_type_die (tree type
, int is_const_type
, int is_volatile_type
,
12593 dw_die_ref context_die
)
12595 enum tree_code code
= TREE_CODE (type
);
12596 dw_die_ref mod_type_die
;
12597 dw_die_ref sub_die
= NULL
;
12598 tree item_type
= NULL
;
12599 tree qualified_type
;
12600 tree name
, low
, high
;
12602 if (code
== ERROR_MARK
)
12605 /* See if we already have the appropriately qualified variant of
12608 = get_qualified_type (type
,
12609 ((is_const_type
? TYPE_QUAL_CONST
: 0)
12610 | (is_volatile_type
? TYPE_QUAL_VOLATILE
: 0)));
12612 if (qualified_type
== sizetype
12613 && TYPE_NAME (qualified_type
)
12614 && TREE_CODE (TYPE_NAME (qualified_type
)) == TYPE_DECL
)
12616 #ifdef ENABLE_CHECKING
12617 gcc_assert (TREE_CODE (TREE_TYPE (TYPE_NAME (qualified_type
)))
12619 && TYPE_PRECISION (TREE_TYPE (TYPE_NAME (qualified_type
)))
12620 == TYPE_PRECISION (qualified_type
)
12621 && TYPE_UNSIGNED (TREE_TYPE (TYPE_NAME (qualified_type
)))
12622 == TYPE_UNSIGNED (qualified_type
));
12624 qualified_type
= TREE_TYPE (TYPE_NAME (qualified_type
));
12627 /* If we do, then we can just use its DIE, if it exists. */
12628 if (qualified_type
)
12630 mod_type_die
= lookup_type_die (qualified_type
);
12632 return mod_type_die
;
12635 name
= qualified_type
? TYPE_NAME (qualified_type
) : NULL
;
12637 /* Handle C typedef types. */
12638 if (name
&& TREE_CODE (name
) == TYPE_DECL
&& DECL_ORIGINAL_TYPE (name
)
12639 && !DECL_ARTIFICIAL (name
))
12641 tree dtype
= TREE_TYPE (name
);
12643 if (qualified_type
== dtype
)
12645 /* For a named type, use the typedef. */
12646 gen_type_die (qualified_type
, context_die
);
12647 return lookup_type_die (qualified_type
);
12649 else if (is_const_type
< TYPE_READONLY (dtype
)
12650 || is_volatile_type
< TYPE_VOLATILE (dtype
)
12651 || (is_const_type
<= TYPE_READONLY (dtype
)
12652 && is_volatile_type
<= TYPE_VOLATILE (dtype
)
12653 && DECL_ORIGINAL_TYPE (name
) != type
))
12654 /* cv-unqualified version of named type. Just use the unnamed
12655 type to which it refers. */
12656 return modified_type_die (DECL_ORIGINAL_TYPE (name
),
12657 is_const_type
, is_volatile_type
,
12659 /* Else cv-qualified version of named type; fall through. */
12664 mod_type_die
= new_die (DW_TAG_const_type
, comp_unit_die
, type
);
12665 sub_die
= modified_type_die (type
, 0, is_volatile_type
, context_die
);
12667 else if (is_volatile_type
)
12669 mod_type_die
= new_die (DW_TAG_volatile_type
, comp_unit_die
, type
);
12670 sub_die
= modified_type_die (type
, 0, 0, context_die
);
12672 else if (code
== POINTER_TYPE
)
12674 mod_type_die
= new_die (DW_TAG_pointer_type
, comp_unit_die
, type
);
12675 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
,
12676 simple_type_size_in_bits (type
) / BITS_PER_UNIT
);
12677 item_type
= TREE_TYPE (type
);
12678 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (item_type
)))
12679 add_AT_unsigned (mod_type_die
, DW_AT_address_class
,
12680 TYPE_ADDR_SPACE (item_type
));
12682 else if (code
== REFERENCE_TYPE
)
12684 if (TYPE_REF_IS_RVALUE (type
) && dwarf_version
>= 4)
12685 mod_type_die
= new_die (DW_TAG_rvalue_reference_type
, comp_unit_die
,
12688 mod_type_die
= new_die (DW_TAG_reference_type
, comp_unit_die
, type
);
12689 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
,
12690 simple_type_size_in_bits (type
) / BITS_PER_UNIT
);
12691 item_type
= TREE_TYPE (type
);
12692 if (!ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (item_type
)))
12693 add_AT_unsigned (mod_type_die
, DW_AT_address_class
,
12694 TYPE_ADDR_SPACE (item_type
));
12696 else if (code
== INTEGER_TYPE
12697 && TREE_TYPE (type
) != NULL_TREE
12698 && subrange_type_for_debug_p (type
, &low
, &high
))
12700 mod_type_die
= subrange_type_die (type
, low
, high
, context_die
);
12701 item_type
= TREE_TYPE (type
);
12703 else if (is_base_type (type
))
12704 mod_type_die
= base_type_die (type
);
12707 gen_type_die (type
, context_die
);
12709 /* We have to get the type_main_variant here (and pass that to the
12710 `lookup_type_die' routine) because the ..._TYPE node we have
12711 might simply be a *copy* of some original type node (where the
12712 copy was created to help us keep track of typedef names) and
12713 that copy might have a different TYPE_UID from the original
12715 if (TREE_CODE (type
) != VECTOR_TYPE
)
12716 return lookup_type_die (type_main_variant (type
));
12718 /* Vectors have the debugging information in the type,
12719 not the main variant. */
12720 return lookup_type_die (type
);
12723 /* Builtin types don't have a DECL_ORIGINAL_TYPE. For those,
12724 don't output a DW_TAG_typedef, since there isn't one in the
12725 user's program; just attach a DW_AT_name to the type.
12726 Don't attach a DW_AT_name to DW_TAG_const_type or DW_TAG_volatile_type
12727 if the base type already has the same name. */
12729 && ((TREE_CODE (name
) != TYPE_DECL
12730 && (qualified_type
== TYPE_MAIN_VARIANT (type
)
12731 || (!is_const_type
&& !is_volatile_type
)))
12732 || (TREE_CODE (name
) == TYPE_DECL
12733 && TREE_TYPE (name
) == qualified_type
12734 && DECL_NAME (name
))))
12736 if (TREE_CODE (name
) == TYPE_DECL
)
12737 /* Could just call add_name_and_src_coords_attributes here,
12738 but since this is a builtin type it doesn't have any
12739 useful source coordinates anyway. */
12740 name
= DECL_NAME (name
);
12741 add_name_attribute (mod_type_die
, IDENTIFIER_POINTER (name
));
12743 /* This probably indicates a bug. */
12744 else if (mod_type_die
&& mod_type_die
->die_tag
== DW_TAG_base_type
)
12745 add_name_attribute (mod_type_die
, "__unknown__");
12747 if (qualified_type
)
12748 equate_type_number_to_die (qualified_type
, mod_type_die
);
12751 /* We must do this after the equate_type_number_to_die call, in case
12752 this is a recursive type. This ensures that the modified_type_die
12753 recursion will terminate even if the type is recursive. Recursive
12754 types are possible in Ada. */
12755 sub_die
= modified_type_die (item_type
,
12756 TYPE_READONLY (item_type
),
12757 TYPE_VOLATILE (item_type
),
12760 if (sub_die
!= NULL
)
12761 add_AT_die_ref (mod_type_die
, DW_AT_type
, sub_die
);
12763 return mod_type_die
;
12766 /* Generate DIEs for the generic parameters of T.
12767 T must be either a generic type or a generic function.
12768 See http://gcc.gnu.org/wiki/TemplateParmsDwarf for more. */
12771 gen_generic_params_dies (tree t
)
12775 dw_die_ref die
= NULL
;
12777 if (!t
|| (TYPE_P (t
) && !COMPLETE_TYPE_P (t
)))
12781 die
= lookup_type_die (t
);
12782 else if (DECL_P (t
))
12783 die
= lookup_decl_die (t
);
12787 parms
= lang_hooks
.get_innermost_generic_parms (t
);
12789 /* T has no generic parameter. It means T is neither a generic type
12790 or function. End of story. */
12793 parms_num
= TREE_VEC_LENGTH (parms
);
12794 args
= lang_hooks
.get_innermost_generic_args (t
);
12795 for (i
= 0; i
< parms_num
; i
++)
12797 tree parm
, arg
, arg_pack_elems
;
12799 parm
= TREE_VEC_ELT (parms
, i
);
12800 arg
= TREE_VEC_ELT (args
, i
);
12801 arg_pack_elems
= lang_hooks
.types
.get_argument_pack_elems (arg
);
12802 gcc_assert (parm
&& TREE_VALUE (parm
) && arg
);
12804 if (parm
&& TREE_VALUE (parm
) && arg
)
12806 /* If PARM represents a template parameter pack,
12807 emit a DW_TAG_GNU_template_parameter_pack DIE, followed
12808 by DW_TAG_template_*_parameter DIEs for the argument
12809 pack elements of ARG. Note that ARG would then be
12810 an argument pack. */
12811 if (arg_pack_elems
)
12812 template_parameter_pack_die (TREE_VALUE (parm
),
12816 generic_parameter_die (TREE_VALUE (parm
), arg
,
12817 true /* Emit DW_AT_name */, die
);
12822 /* Create and return a DIE for PARM which should be
12823 the representation of a generic type parameter.
12824 For instance, in the C++ front end, PARM would be a template parameter.
12825 ARG is the argument to PARM.
12826 EMIT_NAME_P if tree, the DIE will have DW_AT_name attribute set to the
12828 PARENT_DIE is the parent DIE which the new created DIE should be added to,
12829 as a child node. */
12832 generic_parameter_die (tree parm
, tree arg
,
12834 dw_die_ref parent_die
)
12836 dw_die_ref tmpl_die
= NULL
;
12837 const char *name
= NULL
;
12839 if (!parm
|| !DECL_NAME (parm
) || !arg
)
12842 /* We support non-type generic parameters and arguments,
12843 type generic parameters and arguments, as well as
12844 generic generic parameters (a.k.a. template template parameters in C++)
12846 if (TREE_CODE (parm
) == PARM_DECL
)
12847 /* PARM is a nontype generic parameter */
12848 tmpl_die
= new_die (DW_TAG_template_value_param
, parent_die
, parm
);
12849 else if (TREE_CODE (parm
) == TYPE_DECL
)
12850 /* PARM is a type generic parameter. */
12851 tmpl_die
= new_die (DW_TAG_template_type_param
, parent_die
, parm
);
12852 else if (lang_hooks
.decls
.generic_generic_parameter_decl_p (parm
))
12853 /* PARM is a generic generic parameter.
12854 Its DIE is a GNU extension. It shall have a
12855 DW_AT_name attribute to represent the name of the template template
12856 parameter, and a DW_AT_GNU_template_name attribute to represent the
12857 name of the template template argument. */
12858 tmpl_die
= new_die (DW_TAG_GNU_template_template_param
,
12861 gcc_unreachable ();
12867 /* If PARM is a generic parameter pack, it means we are
12868 emitting debug info for a template argument pack element.
12869 In other terms, ARG is a template argument pack element.
12870 In that case, we don't emit any DW_AT_name attribute for
12874 name
= IDENTIFIER_POINTER (DECL_NAME (parm
));
12876 add_AT_string (tmpl_die
, DW_AT_name
, name
);
12879 if (!lang_hooks
.decls
.generic_generic_parameter_decl_p (parm
))
12881 /* DWARF3, 5.6.8 says if PARM is a non-type generic parameter
12882 TMPL_DIE should have a child DW_AT_type attribute that is set
12883 to the type of the argument to PARM, which is ARG.
12884 If PARM is a type generic parameter, TMPL_DIE should have a
12885 child DW_AT_type that is set to ARG. */
12886 tmpl_type
= TYPE_P (arg
) ? arg
: TREE_TYPE (arg
);
12887 add_type_attribute (tmpl_die
, tmpl_type
, 0,
12888 TREE_THIS_VOLATILE (tmpl_type
),
12893 /* So TMPL_DIE is a DIE representing a
12894 a generic generic template parameter, a.k.a template template
12895 parameter in C++ and arg is a template. */
12897 /* The DW_AT_GNU_template_name attribute of the DIE must be set
12898 to the name of the argument. */
12899 name
= dwarf2_name (TYPE_P (arg
) ? TYPE_NAME (arg
) : arg
, 1);
12901 add_AT_string (tmpl_die
, DW_AT_GNU_template_name
, name
);
12904 if (TREE_CODE (parm
) == PARM_DECL
)
12905 /* So PARM is a non-type generic parameter.
12906 DWARF3 5.6.8 says we must set a DW_AT_const_value child
12907 attribute of TMPL_DIE which value represents the value
12909 We must be careful here:
12910 The value of ARG might reference some function decls.
12911 We might currently be emitting debug info for a generic
12912 type and types are emitted before function decls, we don't
12913 know if the function decls referenced by ARG will actually be
12914 emitted after cgraph computations.
12915 So must defer the generation of the DW_AT_const_value to
12916 after cgraph is ready. */
12917 append_entry_to_tmpl_value_parm_die_table (tmpl_die
, arg
);
12923 /* Generate and return a DW_TAG_GNU_template_parameter_pack DIE representing.
12924 PARM_PACK must be a template parameter pack. The returned DIE
12925 will be child DIE of PARENT_DIE. */
12928 template_parameter_pack_die (tree parm_pack
,
12929 tree parm_pack_args
,
12930 dw_die_ref parent_die
)
12935 gcc_assert (parent_die
&& parm_pack
);
12937 die
= new_die (DW_TAG_GNU_template_parameter_pack
, parent_die
, parm_pack
);
12938 add_name_and_src_coords_attributes (die
, parm_pack
);
12939 for (j
= 0; j
< TREE_VEC_LENGTH (parm_pack_args
); j
++)
12940 generic_parameter_die (parm_pack
,
12941 TREE_VEC_ELT (parm_pack_args
, j
),
12942 false /* Don't emit DW_AT_name */,
12947 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
12948 an enumerated type. */
12951 type_is_enum (const_tree type
)
12953 return TREE_CODE (type
) == ENUMERAL_TYPE
;
12956 /* Return the DBX register number described by a given RTL node. */
12958 static unsigned int
12959 dbx_reg_number (const_rtx rtl
)
12961 unsigned regno
= REGNO (rtl
);
12963 gcc_assert (regno
< FIRST_PSEUDO_REGISTER
);
12965 #ifdef LEAF_REG_REMAP
12966 if (current_function_uses_only_leaf_regs
)
12968 int leaf_reg
= LEAF_REG_REMAP (regno
);
12969 if (leaf_reg
!= -1)
12970 regno
= (unsigned) leaf_reg
;
12974 return DBX_REGISTER_NUMBER (regno
);
12977 /* Optionally add a DW_OP_piece term to a location description expression.
12978 DW_OP_piece is only added if the location description expression already
12979 doesn't end with DW_OP_piece. */
12982 add_loc_descr_op_piece (dw_loc_descr_ref
*list_head
, int size
)
12984 dw_loc_descr_ref loc
;
12986 if (*list_head
!= NULL
)
12988 /* Find the end of the chain. */
12989 for (loc
= *list_head
; loc
->dw_loc_next
!= NULL
; loc
= loc
->dw_loc_next
)
12992 if (loc
->dw_loc_opc
!= DW_OP_piece
)
12993 loc
->dw_loc_next
= new_loc_descr (DW_OP_piece
, size
, 0);
12997 /* Return a location descriptor that designates a machine register or
12998 zero if there is none. */
13000 static dw_loc_descr_ref
13001 reg_loc_descriptor (rtx rtl
, enum var_init_status initialized
)
13005 if (REGNO (rtl
) >= FIRST_PSEUDO_REGISTER
)
13008 /* We only use "frame base" when we're sure we're talking about the
13009 post-prologue local stack frame. We do this by *not* running
13010 register elimination until this point, and recognizing the special
13011 argument pointer and soft frame pointer rtx's.
13012 Use DW_OP_fbreg offset DW_OP_stack_value in this case. */
13013 if ((rtl
== arg_pointer_rtx
|| rtl
== frame_pointer_rtx
)
13014 && eliminate_regs (rtl
, VOIDmode
, NULL_RTX
) != rtl
)
13016 dw_loc_descr_ref result
= NULL
;
13018 if (dwarf_version
>= 4 || !dwarf_strict
)
13020 result
= mem_loc_descriptor (rtl
, VOIDmode
, initialized
);
13022 add_loc_descr (&result
,
13023 new_loc_descr (DW_OP_stack_value
, 0, 0));
13028 regs
= targetm
.dwarf_register_span (rtl
);
13030 if (hard_regno_nregs
[REGNO (rtl
)][GET_MODE (rtl
)] > 1 || regs
)
13031 return multiple_reg_loc_descriptor (rtl
, regs
, initialized
);
13033 return one_reg_loc_descriptor (dbx_reg_number (rtl
), initialized
);
13036 /* Return a location descriptor that designates a machine register for
13037 a given hard register number. */
13039 static dw_loc_descr_ref
13040 one_reg_loc_descriptor (unsigned int regno
, enum var_init_status initialized
)
13042 dw_loc_descr_ref reg_loc_descr
;
13046 = new_loc_descr ((enum dwarf_location_atom
) (DW_OP_reg0
+ regno
), 0, 0);
13048 reg_loc_descr
= new_loc_descr (DW_OP_regx
, regno
, 0);
13050 if (initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
13051 add_loc_descr (®_loc_descr
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
13053 return reg_loc_descr
;
13056 /* Given an RTL of a register, return a location descriptor that
13057 designates a value that spans more than one register. */
13059 static dw_loc_descr_ref
13060 multiple_reg_loc_descriptor (rtx rtl
, rtx regs
,
13061 enum var_init_status initialized
)
13063 int nregs
, size
, i
;
13065 dw_loc_descr_ref loc_result
= NULL
;
13068 #ifdef LEAF_REG_REMAP
13069 if (current_function_uses_only_leaf_regs
)
13071 int leaf_reg
= LEAF_REG_REMAP (reg
);
13072 if (leaf_reg
!= -1)
13073 reg
= (unsigned) leaf_reg
;
13076 gcc_assert ((unsigned) DBX_REGISTER_NUMBER (reg
) == dbx_reg_number (rtl
));
13077 nregs
= hard_regno_nregs
[REGNO (rtl
)][GET_MODE (rtl
)];
13079 /* Simple, contiguous registers. */
13080 if (regs
== NULL_RTX
)
13082 size
= GET_MODE_SIZE (GET_MODE (rtl
)) / nregs
;
13087 dw_loc_descr_ref t
;
13089 t
= one_reg_loc_descriptor (DBX_REGISTER_NUMBER (reg
),
13090 VAR_INIT_STATUS_INITIALIZED
);
13091 add_loc_descr (&loc_result
, t
);
13092 add_loc_descr_op_piece (&loc_result
, size
);
13098 /* Now onto stupid register sets in non contiguous locations. */
13100 gcc_assert (GET_CODE (regs
) == PARALLEL
);
13102 size
= GET_MODE_SIZE (GET_MODE (XVECEXP (regs
, 0, 0)));
13105 for (i
= 0; i
< XVECLEN (regs
, 0); ++i
)
13107 dw_loc_descr_ref t
;
13109 t
= one_reg_loc_descriptor (REGNO (XVECEXP (regs
, 0, i
)),
13110 VAR_INIT_STATUS_INITIALIZED
);
13111 add_loc_descr (&loc_result
, t
);
13112 size
= GET_MODE_SIZE (GET_MODE (XVECEXP (regs
, 0, 0)));
13113 add_loc_descr_op_piece (&loc_result
, size
);
13116 if (loc_result
&& initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
13117 add_loc_descr (&loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
13121 #endif /* DWARF2_DEBUGGING_INFO */
13123 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
13125 /* Return a location descriptor that designates a constant. */
13127 static dw_loc_descr_ref
13128 int_loc_descriptor (HOST_WIDE_INT i
)
13130 enum dwarf_location_atom op
;
13132 /* Pick the smallest representation of a constant, rather than just
13133 defaulting to the LEB encoding. */
13137 op
= (enum dwarf_location_atom
) (DW_OP_lit0
+ i
);
13138 else if (i
<= 0xff)
13139 op
= DW_OP_const1u
;
13140 else if (i
<= 0xffff)
13141 op
= DW_OP_const2u
;
13142 else if (HOST_BITS_PER_WIDE_INT
== 32
13143 || i
<= 0xffffffff)
13144 op
= DW_OP_const4u
;
13151 op
= DW_OP_const1s
;
13152 else if (i
>= -0x8000)
13153 op
= DW_OP_const2s
;
13154 else if (HOST_BITS_PER_WIDE_INT
== 32
13155 || i
>= -0x80000000)
13156 op
= DW_OP_const4s
;
13161 return new_loc_descr (op
, i
, 0);
13165 #ifdef DWARF2_DEBUGGING_INFO
13166 /* Return loc description representing "address" of integer value.
13167 This can appear only as toplevel expression. */
13169 static dw_loc_descr_ref
13170 address_of_int_loc_descriptor (int size
, HOST_WIDE_INT i
)
13173 dw_loc_descr_ref loc_result
= NULL
;
13175 if (!(dwarf_version
>= 4 || !dwarf_strict
))
13182 else if (i
<= 0xff)
13184 else if (i
<= 0xffff)
13186 else if (HOST_BITS_PER_WIDE_INT
== 32
13187 || i
<= 0xffffffff)
13190 litsize
= 1 + size_of_uleb128 ((unsigned HOST_WIDE_INT
) i
);
13196 else if (i
>= -0x8000)
13198 else if (HOST_BITS_PER_WIDE_INT
== 32
13199 || i
>= -0x80000000)
13202 litsize
= 1 + size_of_sleb128 (i
);
13204 /* Determine if DW_OP_stack_value or DW_OP_implicit_value
13205 is more compact. For DW_OP_stack_value we need:
13206 litsize + 1 (DW_OP_stack_value)
13207 and for DW_OP_implicit_value:
13208 1 (DW_OP_implicit_value) + 1 (length) + size. */
13209 if ((int) DWARF2_ADDR_SIZE
>= size
&& litsize
+ 1 <= 1 + 1 + size
)
13211 loc_result
= int_loc_descriptor (i
);
13212 add_loc_descr (&loc_result
,
13213 new_loc_descr (DW_OP_stack_value
, 0, 0));
13217 loc_result
= new_loc_descr (DW_OP_implicit_value
,
13219 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_const
;
13220 loc_result
->dw_loc_oprnd2
.v
.val_int
= i
;
13224 /* Return a location descriptor that designates a base+offset location. */
13226 static dw_loc_descr_ref
13227 based_loc_descr (rtx reg
, HOST_WIDE_INT offset
,
13228 enum var_init_status initialized
)
13230 unsigned int regno
;
13231 dw_loc_descr_ref result
;
13232 dw_fde_ref fde
= current_fde ();
13234 /* We only use "frame base" when we're sure we're talking about the
13235 post-prologue local stack frame. We do this by *not* running
13236 register elimination until this point, and recognizing the special
13237 argument pointer and soft frame pointer rtx's. */
13238 if (reg
== arg_pointer_rtx
|| reg
== frame_pointer_rtx
)
13240 rtx elim
= eliminate_regs (reg
, VOIDmode
, NULL_RTX
);
13244 if (GET_CODE (elim
) == PLUS
)
13246 offset
+= INTVAL (XEXP (elim
, 1));
13247 elim
= XEXP (elim
, 0);
13249 gcc_assert ((SUPPORTS_STACK_ALIGNMENT
13250 && (elim
== hard_frame_pointer_rtx
13251 || elim
== stack_pointer_rtx
))
13252 || elim
== (frame_pointer_needed
13253 ? hard_frame_pointer_rtx
13254 : stack_pointer_rtx
));
13256 /* If drap register is used to align stack, use frame
13257 pointer + offset to access stack variables. If stack
13258 is aligned without drap, use stack pointer + offset to
13259 access stack variables. */
13260 if (crtl
->stack_realign_tried
13261 && reg
== frame_pointer_rtx
)
13264 = DWARF_FRAME_REGNUM ((fde
&& fde
->drap_reg
!= INVALID_REGNUM
)
13265 ? HARD_FRAME_POINTER_REGNUM
13266 : STACK_POINTER_REGNUM
);
13267 return new_reg_loc_descr (base_reg
, offset
);
13270 offset
+= frame_pointer_fb_offset
;
13271 return new_loc_descr (DW_OP_fbreg
, offset
, 0);
13276 && (fde
->drap_reg
== REGNO (reg
)
13277 || fde
->vdrap_reg
== REGNO (reg
)))
13279 /* Use cfa+offset to represent the location of arguments passed
13280 on the stack when drap is used to align stack.
13281 Only do this when not optimizing, for optimized code var-tracking
13282 is supposed to track where the arguments live and the register
13283 used as vdrap or drap in some spot might be used for something
13284 else in other part of the routine. */
13285 return new_loc_descr (DW_OP_fbreg
, offset
, 0);
13288 regno
= dbx_reg_number (reg
);
13290 result
= new_loc_descr ((enum dwarf_location_atom
) (DW_OP_breg0
+ regno
),
13293 result
= new_loc_descr (DW_OP_bregx
, regno
, offset
);
13295 if (initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
13296 add_loc_descr (&result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
13301 /* Return true if this RTL expression describes a base+offset calculation. */
13304 is_based_loc (const_rtx rtl
)
13306 return (GET_CODE (rtl
) == PLUS
13307 && ((REG_P (XEXP (rtl
, 0))
13308 && REGNO (XEXP (rtl
, 0)) < FIRST_PSEUDO_REGISTER
13309 && CONST_INT_P (XEXP (rtl
, 1)))));
13312 /* Try to handle TLS MEMs, for which mem_loc_descriptor on XEXP (mem, 0)
13315 static dw_loc_descr_ref
13316 tls_mem_loc_descriptor (rtx mem
)
13319 dw_loc_descr_ref loc_result
;
13321 if (MEM_EXPR (mem
) == NULL_TREE
|| MEM_OFFSET (mem
) == NULL_RTX
)
13324 base
= get_base_address (MEM_EXPR (mem
));
13326 || TREE_CODE (base
) != VAR_DECL
13327 || !DECL_THREAD_LOCAL_P (base
))
13330 loc_result
= loc_descriptor_from_tree (MEM_EXPR (mem
), 1);
13331 if (loc_result
== NULL
)
13334 if (INTVAL (MEM_OFFSET (mem
)))
13335 loc_descr_plus_const (&loc_result
, INTVAL (MEM_OFFSET (mem
)));
13340 /* Output debug info about reason why we failed to expand expression as dwarf
13344 expansion_failed (tree expr
, rtx rtl
, char const *reason
)
13346 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
13348 fprintf (dump_file
, "Failed to expand as dwarf: ");
13350 print_generic_expr (dump_file
, expr
, dump_flags
);
13353 fprintf (dump_file
, "\n");
13354 print_rtl (dump_file
, rtl
);
13356 fprintf (dump_file
, "\nReason: %s\n", reason
);
13360 /* Helper function for const_ok_for_output, called either directly
13361 or via for_each_rtx. */
13364 const_ok_for_output_1 (rtx
*rtlp
, void *data ATTRIBUTE_UNUSED
)
13368 if (GET_CODE (rtl
) == UNSPEC
)
13370 /* If delegitimize_address couldn't do anything with the UNSPEC, assume
13371 we can't express it in the debug info. */
13372 #ifdef ENABLE_CHECKING
13373 inform (current_function_decl
13374 ? DECL_SOURCE_LOCATION (current_function_decl
)
13375 : UNKNOWN_LOCATION
,
13376 "non-delegitimized UNSPEC %d found in variable location",
13379 expansion_failed (NULL_TREE
, rtl
,
13380 "UNSPEC hasn't been delegitimized.\n");
13384 if (GET_CODE (rtl
) != SYMBOL_REF
)
13387 if (CONSTANT_POOL_ADDRESS_P (rtl
))
13390 get_pool_constant_mark (rtl
, &marked
);
13391 /* If all references to this pool constant were optimized away,
13392 it was not output and thus we can't represent it. */
13395 expansion_failed (NULL_TREE
, rtl
,
13396 "Constant was removed from constant pool.\n");
13401 if (SYMBOL_REF_TLS_MODEL (rtl
) != TLS_MODEL_NONE
)
13404 /* Avoid references to external symbols in debug info, on several targets
13405 the linker might even refuse to link when linking a shared library,
13406 and in many other cases the relocations for .debug_info/.debug_loc are
13407 dropped, so the address becomes zero anyway. Hidden symbols, guaranteed
13408 to be defined within the same shared library or executable are fine. */
13409 if (SYMBOL_REF_EXTERNAL_P (rtl
))
13411 tree decl
= SYMBOL_REF_DECL (rtl
);
13413 if (decl
== NULL
|| !targetm
.binds_local_p (decl
))
13415 expansion_failed (NULL_TREE
, rtl
,
13416 "Symbol not defined in current TU.\n");
13424 /* Return true if constant RTL can be emitted in DW_OP_addr or
13425 DW_AT_const_value. TLS SYMBOL_REFs, external SYMBOL_REFs or
13426 non-marked constant pool SYMBOL_REFs can't be referenced in it. */
13429 const_ok_for_output (rtx rtl
)
13431 if (GET_CODE (rtl
) == SYMBOL_REF
)
13432 return const_ok_for_output_1 (&rtl
, NULL
) == 0;
13434 if (GET_CODE (rtl
) == CONST
)
13435 return for_each_rtx (&XEXP (rtl
, 0), const_ok_for_output_1
, NULL
) == 0;
13440 /* The following routine converts the RTL for a variable or parameter
13441 (resident in memory) into an equivalent Dwarf representation of a
13442 mechanism for getting the address of that same variable onto the top of a
13443 hypothetical "address evaluation" stack.
13445 When creating memory location descriptors, we are effectively transforming
13446 the RTL for a memory-resident object into its Dwarf postfix expression
13447 equivalent. This routine recursively descends an RTL tree, turning
13448 it into Dwarf postfix code as it goes.
13450 MODE is the mode of the memory reference, needed to handle some
13451 autoincrement addressing modes.
13453 CAN_USE_FBREG is a flag whether we can use DW_AT_frame_base in the
13454 location list for RTL.
13456 Return 0 if we can't represent the location. */
13458 static dw_loc_descr_ref
13459 mem_loc_descriptor (rtx rtl
, enum machine_mode mode
,
13460 enum var_init_status initialized
)
13462 dw_loc_descr_ref mem_loc_result
= NULL
;
13463 enum dwarf_location_atom op
;
13464 dw_loc_descr_ref op0
, op1
;
13466 /* Note that for a dynamically sized array, the location we will generate a
13467 description of here will be the lowest numbered location which is
13468 actually within the array. That's *not* necessarily the same as the
13469 zeroth element of the array. */
13471 rtl
= targetm
.delegitimize_address (rtl
);
13473 switch (GET_CODE (rtl
))
13478 return mem_loc_descriptor (XEXP (rtl
, 0), mode
, initialized
);
13481 /* The case of a subreg may arise when we have a local (register)
13482 variable or a formal (register) parameter which doesn't quite fill
13483 up an entire register. For now, just assume that it is
13484 legitimate to make the Dwarf info refer to the whole register which
13485 contains the given subreg. */
13486 if (!subreg_lowpart_p (rtl
))
13488 rtl
= SUBREG_REG (rtl
);
13489 if (GET_MODE_SIZE (GET_MODE (rtl
)) > DWARF2_ADDR_SIZE
)
13491 if (GET_MODE_CLASS (GET_MODE (rtl
)) != MODE_INT
)
13493 mem_loc_result
= mem_loc_descriptor (rtl
, mode
, initialized
);
13497 /* Whenever a register number forms a part of the description of the
13498 method for calculating the (dynamic) address of a memory resident
13499 object, DWARF rules require the register number be referred to as
13500 a "base register". This distinction is not based in any way upon
13501 what category of register the hardware believes the given register
13502 belongs to. This is strictly DWARF terminology we're dealing with
13503 here. Note that in cases where the location of a memory-resident
13504 data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
13505 OP_CONST (0)) the actual DWARF location descriptor that we generate
13506 may just be OP_BASEREG (basereg). This may look deceptively like
13507 the object in question was allocated to a register (rather than in
13508 memory) so DWARF consumers need to be aware of the subtle
13509 distinction between OP_REG and OP_BASEREG. */
13510 if (REGNO (rtl
) < FIRST_PSEUDO_REGISTER
)
13511 mem_loc_result
= based_loc_descr (rtl
, 0, VAR_INIT_STATUS_INITIALIZED
);
13512 else if (stack_realign_drap
13514 && crtl
->args
.internal_arg_pointer
== rtl
13515 && REGNO (crtl
->drap_reg
) < FIRST_PSEUDO_REGISTER
)
13517 /* If RTL is internal_arg_pointer, which has been optimized
13518 out, use DRAP instead. */
13519 mem_loc_result
= based_loc_descr (crtl
->drap_reg
, 0,
13520 VAR_INIT_STATUS_INITIALIZED
);
13526 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
,
13527 VAR_INIT_STATUS_INITIALIZED
);
13532 int shift
= DWARF2_ADDR_SIZE
13533 - GET_MODE_SIZE (GET_MODE (XEXP (rtl
, 0)));
13534 shift
*= BITS_PER_UNIT
;
13535 if (GET_CODE (rtl
) == SIGN_EXTEND
)
13539 mem_loc_result
= op0
;
13540 add_loc_descr (&mem_loc_result
, int_loc_descriptor (shift
));
13541 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_shl
, 0, 0));
13542 add_loc_descr (&mem_loc_result
, int_loc_descriptor (shift
));
13543 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
13548 mem_loc_result
= mem_loc_descriptor (XEXP (rtl
, 0), GET_MODE (rtl
),
13549 VAR_INIT_STATUS_INITIALIZED
);
13550 if (mem_loc_result
== NULL
)
13551 mem_loc_result
= tls_mem_loc_descriptor (rtl
);
13552 if (mem_loc_result
!= 0)
13554 if (GET_MODE_SIZE (GET_MODE (rtl
)) > DWARF2_ADDR_SIZE
)
13556 expansion_failed (NULL_TREE
, rtl
, "DWARF address size mismatch");
13559 else if (GET_MODE_SIZE (GET_MODE (rtl
)) == DWARF2_ADDR_SIZE
)
13560 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_deref
, 0, 0));
13562 add_loc_descr (&mem_loc_result
,
13563 new_loc_descr (DW_OP_deref_size
,
13564 GET_MODE_SIZE (GET_MODE (rtl
)), 0));
13568 rtx new_rtl
= avoid_constant_pool_reference (rtl
);
13569 if (new_rtl
!= rtl
)
13570 return mem_loc_descriptor (new_rtl
, mode
, initialized
);
13575 rtl
= XEXP (rtl
, 1);
13577 /* ... fall through ... */
13580 /* Some ports can transform a symbol ref into a label ref, because
13581 the symbol ref is too far away and has to be dumped into a constant
13585 if (GET_CODE (rtl
) == SYMBOL_REF
13586 && SYMBOL_REF_TLS_MODEL (rtl
) != TLS_MODEL_NONE
)
13588 dw_loc_descr_ref temp
;
13590 /* If this is not defined, we have no way to emit the data. */
13591 if (!targetm
.have_tls
|| !targetm
.asm_out
.output_dwarf_dtprel
)
13594 temp
= new_loc_descr (DW_OP_addr
, 0, 0);
13595 temp
->dw_loc_oprnd1
.val_class
= dw_val_class_addr
;
13596 temp
->dw_loc_oprnd1
.v
.val_addr
= rtl
;
13597 temp
->dtprel
= true;
13599 mem_loc_result
= new_loc_descr (DW_OP_GNU_push_tls_address
, 0, 0);
13600 add_loc_descr (&mem_loc_result
, temp
);
13605 if (!const_ok_for_output (rtl
))
13609 mem_loc_result
= new_loc_descr (DW_OP_addr
, 0, 0);
13610 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_addr
;
13611 mem_loc_result
->dw_loc_oprnd1
.v
.val_addr
= rtl
;
13612 VEC_safe_push (rtx
, gc
, used_rtx_array
, rtl
);
13618 expansion_failed (NULL_TREE
, rtl
,
13619 "CONCAT/CONCATN/VAR_LOCATION is handled only by loc_descriptor");
13623 /* Extract the PLUS expression nested inside and fall into
13624 PLUS code below. */
13625 rtl
= XEXP (rtl
, 1);
13630 /* Turn these into a PLUS expression and fall into the PLUS code
13632 rtl
= gen_rtx_PLUS (word_mode
, XEXP (rtl
, 0),
13633 GEN_INT (GET_CODE (rtl
) == PRE_INC
13634 ? GET_MODE_UNIT_SIZE (mode
)
13635 : -GET_MODE_UNIT_SIZE (mode
)));
13637 /* ... fall through ... */
13641 if (is_based_loc (rtl
))
13642 mem_loc_result
= based_loc_descr (XEXP (rtl
, 0),
13643 INTVAL (XEXP (rtl
, 1)),
13644 VAR_INIT_STATUS_INITIALIZED
);
13647 mem_loc_result
= mem_loc_descriptor (XEXP (rtl
, 0), mode
,
13648 VAR_INIT_STATUS_INITIALIZED
);
13649 if (mem_loc_result
== 0)
13652 if (CONST_INT_P (XEXP (rtl
, 1)))
13653 loc_descr_plus_const (&mem_loc_result
, INTVAL (XEXP (rtl
, 1)));
13656 dw_loc_descr_ref mem_loc_result2
13657 = mem_loc_descriptor (XEXP (rtl
, 1), mode
,
13658 VAR_INIT_STATUS_INITIALIZED
);
13659 if (mem_loc_result2
== 0)
13661 add_loc_descr (&mem_loc_result
, mem_loc_result2
);
13662 add_loc_descr (&mem_loc_result
,
13663 new_loc_descr (DW_OP_plus
, 0, 0));
13668 /* If a pseudo-reg is optimized away, it is possible for it to
13669 be replaced with a MEM containing a multiply or shift. */
13711 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
,
13712 VAR_INIT_STATUS_INITIALIZED
);
13713 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
,
13714 VAR_INIT_STATUS_INITIALIZED
);
13716 if (op0
== 0 || op1
== 0)
13719 mem_loc_result
= op0
;
13720 add_loc_descr (&mem_loc_result
, op1
);
13721 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
13725 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
,
13726 VAR_INIT_STATUS_INITIALIZED
);
13727 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
,
13728 VAR_INIT_STATUS_INITIALIZED
);
13730 if (op0
== 0 || op1
== 0)
13733 mem_loc_result
= op0
;
13734 add_loc_descr (&mem_loc_result
, op1
);
13735 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_over
, 0, 0));
13736 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_over
, 0, 0));
13737 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_div
, 0, 0));
13738 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_mul
, 0, 0));
13739 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_minus
, 0, 0));
13755 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
,
13756 VAR_INIT_STATUS_INITIALIZED
);
13761 mem_loc_result
= op0
;
13762 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
13766 mem_loc_result
= int_loc_descriptor (INTVAL (rtl
));
13794 if (GET_MODE_SIZE (GET_MODE (XEXP (rtl
, 0))) > DWARF2_ADDR_SIZE
13795 || GET_MODE_SIZE (GET_MODE (XEXP (rtl
, 1))) > DWARF2_ADDR_SIZE
)
13799 enum machine_mode op_mode
= GET_MODE (XEXP (rtl
, 0));
13801 if (op_mode
== VOIDmode
)
13802 op_mode
= GET_MODE (XEXP (rtl
, 1));
13803 if (op_mode
!= VOIDmode
&& GET_MODE_CLASS (op_mode
) != MODE_INT
)
13806 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
,
13807 VAR_INIT_STATUS_INITIALIZED
);
13808 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
,
13809 VAR_INIT_STATUS_INITIALIZED
);
13811 if (op0
== 0 || op1
== 0)
13814 if (op_mode
!= VOIDmode
13815 && GET_MODE_SIZE (op_mode
) < DWARF2_ADDR_SIZE
)
13817 int shift
= DWARF2_ADDR_SIZE
- GET_MODE_SIZE (op_mode
);
13818 shift
*= BITS_PER_UNIT
;
13819 /* For eq/ne, if the operands are known to be zero-extended,
13820 there is no need to do the fancy shifting up. */
13821 if (op
== DW_OP_eq
|| op
== DW_OP_ne
)
13823 dw_loc_descr_ref last0
, last1
;
13825 last0
->dw_loc_next
!= NULL
;
13826 last0
= last0
->dw_loc_next
)
13829 last1
->dw_loc_next
!= NULL
;
13830 last1
= last1
->dw_loc_next
)
13832 /* deref_size zero extends, and for constants we can check
13833 whether they are zero extended or not. */
13834 if (((last0
->dw_loc_opc
== DW_OP_deref_size
13835 && last0
->dw_loc_oprnd1
.v
.val_int
13836 <= GET_MODE_SIZE (op_mode
))
13837 || (CONST_INT_P (XEXP (rtl
, 0))
13838 && (unsigned HOST_WIDE_INT
) INTVAL (XEXP (rtl
, 0))
13839 == (INTVAL (XEXP (rtl
, 0))
13840 & GET_MODE_MASK (op_mode
))))
13841 && ((last1
->dw_loc_opc
== DW_OP_deref_size
13842 && last1
->dw_loc_oprnd1
.v
.val_int
13843 <= GET_MODE_SIZE (op_mode
))
13844 || (CONST_INT_P (XEXP (rtl
, 1))
13845 && (unsigned HOST_WIDE_INT
)
13846 INTVAL (XEXP (rtl
, 1))
13847 == (INTVAL (XEXP (rtl
, 1))
13848 & GET_MODE_MASK (op_mode
)))))
13851 add_loc_descr (&op0
, int_loc_descriptor (shift
));
13852 add_loc_descr (&op0
, new_loc_descr (DW_OP_shl
, 0, 0));
13853 if (CONST_INT_P (XEXP (rtl
, 1)))
13854 op1
= int_loc_descriptor (INTVAL (XEXP (rtl
, 1)) << shift
);
13857 add_loc_descr (&op1
, int_loc_descriptor (shift
));
13858 add_loc_descr (&op1
, new_loc_descr (DW_OP_shl
, 0, 0));
13864 mem_loc_result
= op0
;
13865 add_loc_descr (&mem_loc_result
, op1
);
13866 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
13867 if (STORE_FLAG_VALUE
!= 1)
13869 add_loc_descr (&mem_loc_result
,
13870 int_loc_descriptor (STORE_FLAG_VALUE
));
13871 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_mul
, 0, 0));
13892 if (GET_MODE_SIZE (GET_MODE (XEXP (rtl
, 0))) > DWARF2_ADDR_SIZE
13893 || GET_MODE_SIZE (GET_MODE (XEXP (rtl
, 1))) > DWARF2_ADDR_SIZE
)
13897 enum machine_mode op_mode
= GET_MODE (XEXP (rtl
, 0));
13899 if (op_mode
== VOIDmode
)
13900 op_mode
= GET_MODE (XEXP (rtl
, 1));
13901 if (op_mode
!= VOIDmode
&& GET_MODE_CLASS (op_mode
) != MODE_INT
)
13904 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
,
13905 VAR_INIT_STATUS_INITIALIZED
);
13906 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
,
13907 VAR_INIT_STATUS_INITIALIZED
);
13909 if (op0
== 0 || op1
== 0)
13912 if (op_mode
!= VOIDmode
13913 && GET_MODE_SIZE (op_mode
) < DWARF2_ADDR_SIZE
)
13915 HOST_WIDE_INT mask
= GET_MODE_MASK (op_mode
);
13916 dw_loc_descr_ref last0
, last1
;
13918 last0
->dw_loc_next
!= NULL
;
13919 last0
= last0
->dw_loc_next
)
13922 last1
->dw_loc_next
!= NULL
;
13923 last1
= last1
->dw_loc_next
)
13925 if (CONST_INT_P (XEXP (rtl
, 0)))
13926 op0
= int_loc_descriptor (INTVAL (XEXP (rtl
, 0)) & mask
);
13927 /* deref_size zero extends, so no need to mask it again. */
13928 else if (last0
->dw_loc_opc
!= DW_OP_deref_size
13929 || last0
->dw_loc_oprnd1
.v
.val_int
13930 > GET_MODE_SIZE (op_mode
))
13932 add_loc_descr (&op0
, int_loc_descriptor (mask
));
13933 add_loc_descr (&op0
, new_loc_descr (DW_OP_and
, 0, 0));
13935 if (CONST_INT_P (XEXP (rtl
, 1)))
13936 op1
= int_loc_descriptor (INTVAL (XEXP (rtl
, 1)) & mask
);
13937 /* deref_size zero extends, so no need to mask it again. */
13938 else if (last1
->dw_loc_opc
!= DW_OP_deref_size
13939 || last1
->dw_loc_oprnd1
.v
.val_int
13940 > GET_MODE_SIZE (op_mode
))
13942 add_loc_descr (&op1
, int_loc_descriptor (mask
));
13943 add_loc_descr (&op1
, new_loc_descr (DW_OP_and
, 0, 0));
13948 HOST_WIDE_INT bias
= 1;
13949 bias
<<= (DWARF2_ADDR_SIZE
* BITS_PER_UNIT
- 1);
13950 add_loc_descr (&op0
, new_loc_descr (DW_OP_plus_uconst
, bias
, 0));
13951 if (CONST_INT_P (XEXP (rtl
, 1)))
13952 op1
= int_loc_descriptor ((unsigned HOST_WIDE_INT
) bias
13953 + INTVAL (XEXP (rtl
, 1)));
13955 add_loc_descr (&op1
, new_loc_descr (DW_OP_plus_uconst
,
13965 if (GET_MODE_CLASS (GET_MODE (XEXP (rtl
, 0))) != MODE_INT
13966 || GET_MODE_SIZE (GET_MODE (XEXP (rtl
, 0))) > DWARF2_ADDR_SIZE
13967 || GET_MODE (XEXP (rtl
, 0)) != GET_MODE (XEXP (rtl
, 1)))
13970 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
,
13971 VAR_INIT_STATUS_INITIALIZED
);
13972 op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
,
13973 VAR_INIT_STATUS_INITIALIZED
);
13975 if (op0
== 0 || op1
== 0)
13978 add_loc_descr (&op0
, new_loc_descr (DW_OP_dup
, 0, 0));
13979 add_loc_descr (&op1
, new_loc_descr (DW_OP_swap
, 0, 0));
13980 add_loc_descr (&op1
, new_loc_descr (DW_OP_over
, 0, 0));
13981 if (GET_CODE (rtl
) == UMIN
|| GET_CODE (rtl
) == UMAX
)
13983 if (GET_MODE_SIZE (GET_MODE (XEXP (rtl
, 0))) < DWARF2_ADDR_SIZE
)
13985 HOST_WIDE_INT mask
= GET_MODE_MASK (GET_MODE (XEXP (rtl
, 0)));
13986 add_loc_descr (&op0
, int_loc_descriptor (mask
));
13987 add_loc_descr (&op0
, new_loc_descr (DW_OP_and
, 0, 0));
13988 add_loc_descr (&op1
, int_loc_descriptor (mask
));
13989 add_loc_descr (&op1
, new_loc_descr (DW_OP_and
, 0, 0));
13993 HOST_WIDE_INT bias
= 1;
13994 bias
<<= (DWARF2_ADDR_SIZE
* BITS_PER_UNIT
- 1);
13995 add_loc_descr (&op0
, new_loc_descr (DW_OP_plus_uconst
, bias
, 0));
13996 add_loc_descr (&op1
, new_loc_descr (DW_OP_plus_uconst
, bias
, 0));
13999 else if (GET_MODE_SIZE (GET_MODE (XEXP (rtl
, 0))) < DWARF2_ADDR_SIZE
)
14001 int shift
= DWARF2_ADDR_SIZE
14002 - GET_MODE_SIZE (GET_MODE (XEXP (rtl
, 0)));
14003 shift
*= BITS_PER_UNIT
;
14004 add_loc_descr (&op0
, int_loc_descriptor (shift
));
14005 add_loc_descr (&op0
, new_loc_descr (DW_OP_shl
, 0, 0));
14006 add_loc_descr (&op1
, int_loc_descriptor (shift
));
14007 add_loc_descr (&op1
, new_loc_descr (DW_OP_shl
, 0, 0));
14010 if (GET_CODE (rtl
) == SMIN
|| GET_CODE (rtl
) == UMIN
)
14014 mem_loc_result
= op0
;
14015 add_loc_descr (&mem_loc_result
, op1
);
14016 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
14018 dw_loc_descr_ref bra_node
, drop_node
;
14020 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
14021 add_loc_descr (&mem_loc_result
, bra_node
);
14022 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_swap
, 0, 0));
14023 drop_node
= new_loc_descr (DW_OP_drop
, 0, 0);
14024 add_loc_descr (&mem_loc_result
, drop_node
);
14025 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
14026 bra_node
->dw_loc_oprnd1
.v
.val_loc
= drop_node
;
14032 if (CONST_INT_P (XEXP (rtl
, 1))
14033 && CONST_INT_P (XEXP (rtl
, 2))
14034 && ((unsigned) INTVAL (XEXP (rtl
, 1))
14035 + (unsigned) INTVAL (XEXP (rtl
, 2))
14036 <= GET_MODE_BITSIZE (GET_MODE (rtl
)))
14037 && GET_MODE_BITSIZE (GET_MODE (rtl
)) <= DWARF2_ADDR_SIZE
14038 && GET_MODE_BITSIZE (GET_MODE (XEXP (rtl
, 0))) <= DWARF2_ADDR_SIZE
)
14041 op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
,
14042 VAR_INIT_STATUS_INITIALIZED
);
14045 if (GET_CODE (rtl
) == SIGN_EXTRACT
)
14049 mem_loc_result
= op0
;
14050 size
= INTVAL (XEXP (rtl
, 1));
14051 shift
= INTVAL (XEXP (rtl
, 2));
14052 if (BITS_BIG_ENDIAN
)
14053 shift
= GET_MODE_BITSIZE (GET_MODE (XEXP (rtl
, 0)))
14055 if (shift
+ size
!= (int) DWARF2_ADDR_SIZE
)
14057 add_loc_descr (&mem_loc_result
,
14058 int_loc_descriptor (DWARF2_ADDR_SIZE
14060 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_shl
, 0, 0));
14062 if (size
!= (int) DWARF2_ADDR_SIZE
)
14064 add_loc_descr (&mem_loc_result
,
14065 int_loc_descriptor (DWARF2_ADDR_SIZE
- size
));
14066 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
14076 /* In theory, we could implement the above. */
14077 /* DWARF cannot represent the unsigned compare operations
14104 case FLOAT_TRUNCATE
:
14106 case UNSIGNED_FLOAT
:
14109 case FRACT_CONVERT
:
14110 case UNSIGNED_FRACT_CONVERT
:
14112 case UNSIGNED_SAT_FRACT
:
14124 case VEC_DUPLICATE
:
14127 /* If delegitimize_address couldn't do anything with the UNSPEC, we
14128 can't express it in the debug info. This can happen e.g. with some
14133 resolve_one_addr (&rtl
, NULL
);
14137 #ifdef ENABLE_CHECKING
14138 print_rtl (stderr
, rtl
);
14139 gcc_unreachable ();
14145 if (mem_loc_result
&& initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
14146 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
14148 return mem_loc_result
;
14151 /* Return a descriptor that describes the concatenation of two locations.
14152 This is typically a complex variable. */
14154 static dw_loc_descr_ref
14155 concat_loc_descriptor (rtx x0
, rtx x1
, enum var_init_status initialized
)
14157 dw_loc_descr_ref cc_loc_result
= NULL
;
14158 dw_loc_descr_ref x0_ref
14159 = loc_descriptor (x0
, VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
14160 dw_loc_descr_ref x1_ref
14161 = loc_descriptor (x1
, VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
14163 if (x0_ref
== 0 || x1_ref
== 0)
14166 cc_loc_result
= x0_ref
;
14167 add_loc_descr_op_piece (&cc_loc_result
, GET_MODE_SIZE (GET_MODE (x0
)));
14169 add_loc_descr (&cc_loc_result
, x1_ref
);
14170 add_loc_descr_op_piece (&cc_loc_result
, GET_MODE_SIZE (GET_MODE (x1
)));
14172 if (initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
14173 add_loc_descr (&cc_loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
14175 return cc_loc_result
;
14178 /* Return a descriptor that describes the concatenation of N
14181 static dw_loc_descr_ref
14182 concatn_loc_descriptor (rtx concatn
, enum var_init_status initialized
)
14185 dw_loc_descr_ref cc_loc_result
= NULL
;
14186 unsigned int n
= XVECLEN (concatn
, 0);
14188 for (i
= 0; i
< n
; ++i
)
14190 dw_loc_descr_ref ref
;
14191 rtx x
= XVECEXP (concatn
, 0, i
);
14193 ref
= loc_descriptor (x
, VOIDmode
, VAR_INIT_STATUS_INITIALIZED
);
14197 add_loc_descr (&cc_loc_result
, ref
);
14198 add_loc_descr_op_piece (&cc_loc_result
, GET_MODE_SIZE (GET_MODE (x
)));
14201 if (cc_loc_result
&& initialized
== VAR_INIT_STATUS_UNINITIALIZED
)
14202 add_loc_descr (&cc_loc_result
, new_loc_descr (DW_OP_GNU_uninit
, 0, 0));
14204 return cc_loc_result
;
14207 /* Output a proper Dwarf location descriptor for a variable or parameter
14208 which is either allocated in a register or in a memory location. For a
14209 register, we just generate an OP_REG and the register number. For a
14210 memory location we provide a Dwarf postfix expression describing how to
14211 generate the (dynamic) address of the object onto the address stack.
14213 MODE is mode of the decl if this loc_descriptor is going to be used in
14214 .debug_loc section where DW_OP_stack_value and DW_OP_implicit_value are
14215 allowed, VOIDmode otherwise.
14217 If we don't know how to describe it, return 0. */
14219 static dw_loc_descr_ref
14220 loc_descriptor (rtx rtl
, enum machine_mode mode
,
14221 enum var_init_status initialized
)
14223 dw_loc_descr_ref loc_result
= NULL
;
14225 switch (GET_CODE (rtl
))
14228 /* The case of a subreg may arise when we have a local (register)
14229 variable or a formal (register) parameter which doesn't quite fill
14230 up an entire register. For now, just assume that it is
14231 legitimate to make the Dwarf info refer to the whole register which
14232 contains the given subreg. */
14233 loc_result
= loc_descriptor (SUBREG_REG (rtl
), mode
, initialized
);
14237 loc_result
= reg_loc_descriptor (rtl
, initialized
);
14242 loc_result
= loc_descriptor (XEXP (rtl
, 0), mode
, initialized
);
14246 loc_result
= mem_loc_descriptor (XEXP (rtl
, 0), GET_MODE (rtl
),
14248 if (loc_result
== NULL
)
14249 loc_result
= tls_mem_loc_descriptor (rtl
);
14250 if (loc_result
== NULL
)
14252 rtx new_rtl
= avoid_constant_pool_reference (rtl
);
14253 if (new_rtl
!= rtl
)
14254 loc_result
= loc_descriptor (new_rtl
, mode
, initialized
);
14259 loc_result
= concat_loc_descriptor (XEXP (rtl
, 0), XEXP (rtl
, 1),
14264 loc_result
= concatn_loc_descriptor (rtl
, initialized
);
14269 if (GET_CODE (PAT_VAR_LOCATION_LOC (rtl
)) != PARALLEL
)
14271 rtx loc
= PAT_VAR_LOCATION_LOC (rtl
);
14272 if (GET_CODE (loc
) == EXPR_LIST
)
14273 loc
= XEXP (loc
, 0);
14274 loc_result
= loc_descriptor (loc
, mode
, initialized
);
14278 rtl
= XEXP (rtl
, 1);
14283 rtvec par_elems
= XVEC (rtl
, 0);
14284 int num_elem
= GET_NUM_ELEM (par_elems
);
14285 enum machine_mode mode
;
14288 /* Create the first one, so we have something to add to. */
14289 loc_result
= loc_descriptor (XEXP (RTVEC_ELT (par_elems
, 0), 0),
14290 VOIDmode
, initialized
);
14291 if (loc_result
== NULL
)
14293 mode
= GET_MODE (XEXP (RTVEC_ELT (par_elems
, 0), 0));
14294 add_loc_descr_op_piece (&loc_result
, GET_MODE_SIZE (mode
));
14295 for (i
= 1; i
< num_elem
; i
++)
14297 dw_loc_descr_ref temp
;
14299 temp
= loc_descriptor (XEXP (RTVEC_ELT (par_elems
, i
), 0),
14300 VOIDmode
, initialized
);
14303 add_loc_descr (&loc_result
, temp
);
14304 mode
= GET_MODE (XEXP (RTVEC_ELT (par_elems
, i
), 0));
14305 add_loc_descr_op_piece (&loc_result
, GET_MODE_SIZE (mode
));
14311 if (mode
!= VOIDmode
&& mode
!= BLKmode
)
14312 loc_result
= address_of_int_loc_descriptor (GET_MODE_SIZE (mode
),
14317 if (mode
== VOIDmode
)
14318 mode
= GET_MODE (rtl
);
14320 if (mode
!= VOIDmode
&& (dwarf_version
>= 4 || !dwarf_strict
))
14322 gcc_assert (mode
== GET_MODE (rtl
) || VOIDmode
== GET_MODE (rtl
));
14324 /* Note that a CONST_DOUBLE rtx could represent either an integer
14325 or a floating-point constant. A CONST_DOUBLE is used whenever
14326 the constant requires more than one word in order to be
14327 adequately represented. We output CONST_DOUBLEs as blocks. */
14328 loc_result
= new_loc_descr (DW_OP_implicit_value
,
14329 GET_MODE_SIZE (mode
), 0);
14330 if (SCALAR_FLOAT_MODE_P (mode
))
14332 unsigned int length
= GET_MODE_SIZE (mode
);
14333 unsigned char *array
14334 = (unsigned char*) ggc_alloc_atomic (length
);
14336 insert_float (rtl
, array
);
14337 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
14338 loc_result
->dw_loc_oprnd2
.v
.val_vec
.length
= length
/ 4;
14339 loc_result
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= 4;
14340 loc_result
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
14344 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_const_double
;
14345 loc_result
->dw_loc_oprnd2
.v
.val_double
14346 = rtx_to_double_int (rtl
);
14352 if (mode
== VOIDmode
)
14353 mode
= GET_MODE (rtl
);
14355 if (mode
!= VOIDmode
&& (dwarf_version
>= 4 || !dwarf_strict
))
14357 unsigned int elt_size
= GET_MODE_UNIT_SIZE (GET_MODE (rtl
));
14358 unsigned int length
= CONST_VECTOR_NUNITS (rtl
);
14359 unsigned char *array
= (unsigned char *)
14360 ggc_alloc_atomic (length
* elt_size
);
14364 gcc_assert (mode
== GET_MODE (rtl
) || VOIDmode
== GET_MODE (rtl
));
14365 switch (GET_MODE_CLASS (mode
))
14367 case MODE_VECTOR_INT
:
14368 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
14370 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
14371 double_int val
= rtx_to_double_int (elt
);
14373 if (elt_size
<= sizeof (HOST_WIDE_INT
))
14374 insert_int (double_int_to_shwi (val
), elt_size
, p
);
14377 gcc_assert (elt_size
== 2 * sizeof (HOST_WIDE_INT
));
14378 insert_double (val
, p
);
14383 case MODE_VECTOR_FLOAT
:
14384 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
14386 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
14387 insert_float (elt
, p
);
14392 gcc_unreachable ();
14395 loc_result
= new_loc_descr (DW_OP_implicit_value
,
14396 length
* elt_size
, 0);
14397 loc_result
->dw_loc_oprnd2
.val_class
= dw_val_class_vec
;
14398 loc_result
->dw_loc_oprnd2
.v
.val_vec
.length
= length
;
14399 loc_result
->dw_loc_oprnd2
.v
.val_vec
.elt_size
= elt_size
;
14400 loc_result
->dw_loc_oprnd2
.v
.val_vec
.array
= array
;
14405 if (mode
== VOIDmode
14406 || GET_CODE (XEXP (rtl
, 0)) == CONST_INT
14407 || GET_CODE (XEXP (rtl
, 0)) == CONST_DOUBLE
14408 || GET_CODE (XEXP (rtl
, 0)) == CONST_VECTOR
)
14410 loc_result
= loc_descriptor (XEXP (rtl
, 0), mode
, initialized
);
14415 if (!const_ok_for_output (rtl
))
14418 if (mode
!= VOIDmode
&& GET_MODE_SIZE (mode
) == DWARF2_ADDR_SIZE
14419 && (dwarf_version
>= 4 || !dwarf_strict
))
14421 loc_result
= new_loc_descr (DW_OP_addr
, 0, 0);
14422 loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_addr
;
14423 loc_result
->dw_loc_oprnd1
.v
.val_addr
= rtl
;
14424 add_loc_descr (&loc_result
, new_loc_descr (DW_OP_stack_value
, 0, 0));
14425 VEC_safe_push (rtx
, gc
, used_rtx_array
, rtl
);
14430 if (GET_MODE_CLASS (mode
) == MODE_INT
&& GET_MODE (rtl
) == mode
14431 && GET_MODE_SIZE (GET_MODE (rtl
)) <= DWARF2_ADDR_SIZE
14432 && (dwarf_version
>= 4 || !dwarf_strict
))
14434 /* Value expression. */
14435 loc_result
= mem_loc_descriptor (rtl
, VOIDmode
, initialized
);
14437 add_loc_descr (&loc_result
,
14438 new_loc_descr (DW_OP_stack_value
, 0, 0));
14446 /* We need to figure out what section we should use as the base for the
14447 address ranges where a given location is valid.
14448 1. If this particular DECL has a section associated with it, use that.
14449 2. If this function has a section associated with it, use that.
14450 3. Otherwise, use the text section.
14451 XXX: If you split a variable across multiple sections, we won't notice. */
14453 static const char *
14454 secname_for_decl (const_tree decl
)
14456 const char *secname
;
14458 if (VAR_OR_FUNCTION_DECL_P (decl
) && DECL_SECTION_NAME (decl
))
14460 tree sectree
= DECL_SECTION_NAME (decl
);
14461 secname
= TREE_STRING_POINTER (sectree
);
14463 else if (current_function_decl
&& DECL_SECTION_NAME (current_function_decl
))
14465 tree sectree
= DECL_SECTION_NAME (current_function_decl
);
14466 secname
= TREE_STRING_POINTER (sectree
);
14468 else if (cfun
&& in_cold_section_p
)
14469 secname
= crtl
->subsections
.cold_section_label
;
14471 secname
= text_section_label
;
14476 /* Return true when DECL_BY_REFERENCE is defined and set for DECL. */
14479 decl_by_reference_p (tree decl
)
14481 return ((TREE_CODE (decl
) == PARM_DECL
|| TREE_CODE (decl
) == RESULT_DECL
14482 || TREE_CODE (decl
) == VAR_DECL
)
14483 && DECL_BY_REFERENCE (decl
));
14486 /* Helper function for dw_loc_list. Compute proper Dwarf location descriptor
14489 static dw_loc_descr_ref
14490 dw_loc_list_1 (tree loc
, rtx varloc
, int want_address
,
14491 enum var_init_status initialized
)
14493 int have_address
= 0;
14494 dw_loc_descr_ref descr
;
14495 enum machine_mode mode
;
14497 if (want_address
!= 2)
14499 gcc_assert (GET_CODE (varloc
) == VAR_LOCATION
);
14501 if (GET_CODE (PAT_VAR_LOCATION_LOC (varloc
)) != PARALLEL
)
14503 varloc
= PAT_VAR_LOCATION_LOC (varloc
);
14504 if (GET_CODE (varloc
) == EXPR_LIST
)
14505 varloc
= XEXP (varloc
, 0);
14506 mode
= GET_MODE (varloc
);
14507 if (MEM_P (varloc
))
14509 rtx addr
= XEXP (varloc
, 0);
14510 descr
= mem_loc_descriptor (addr
, mode
, initialized
);
14515 rtx x
= avoid_constant_pool_reference (varloc
);
14517 descr
= mem_loc_descriptor (x
, mode
, initialized
);
14521 descr
= mem_loc_descriptor (varloc
, mode
, initialized
);
14528 if (GET_CODE (varloc
) == VAR_LOCATION
)
14529 mode
= DECL_MODE (PAT_VAR_LOCATION_DECL (varloc
));
14531 mode
= DECL_MODE (loc
);
14532 descr
= loc_descriptor (varloc
, mode
, initialized
);
14539 if (want_address
== 2 && !have_address
14540 && (dwarf_version
>= 4 || !dwarf_strict
))
14542 if (int_size_in_bytes (TREE_TYPE (loc
)) > DWARF2_ADDR_SIZE
)
14544 expansion_failed (loc
, NULL_RTX
,
14545 "DWARF address size mismatch");
14548 add_loc_descr (&descr
, new_loc_descr (DW_OP_stack_value
, 0, 0));
14551 /* Show if we can't fill the request for an address. */
14552 if (want_address
&& !have_address
)
14554 expansion_failed (loc
, NULL_RTX
,
14555 "Want address and only have value");
14559 /* If we've got an address and don't want one, dereference. */
14560 if (!want_address
&& have_address
)
14562 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (loc
));
14563 enum dwarf_location_atom op
;
14565 if (size
> DWARF2_ADDR_SIZE
|| size
== -1)
14567 expansion_failed (loc
, NULL_RTX
,
14568 "DWARF address size mismatch");
14571 else if (size
== DWARF2_ADDR_SIZE
)
14574 op
= DW_OP_deref_size
;
14576 add_loc_descr (&descr
, new_loc_descr (op
, size
, 0));
14582 /* Create a DW_OP_piece or DW_OP_bit_piece for bitsize, or return NULL
14583 if it is not possible. */
14585 static dw_loc_descr_ref
14586 new_loc_descr_op_bit_piece (HOST_WIDE_INT bitsize
, HOST_WIDE_INT offset
)
14588 if ((bitsize
% BITS_PER_UNIT
) == 0 && offset
== 0)
14589 return new_loc_descr (DW_OP_piece
, bitsize
/ BITS_PER_UNIT
, 0);
14590 else if (dwarf_version
>= 3 || !dwarf_strict
)
14591 return new_loc_descr (DW_OP_bit_piece
, bitsize
, offset
);
14596 /* Helper function for dw_loc_list. Compute proper Dwarf location descriptor
14597 for VAR_LOC_NOTE for variable DECL that has been optimized by SRA. */
14599 static dw_loc_descr_ref
14600 dw_sra_loc_expr (tree decl
, rtx loc
)
14603 unsigned int padsize
= 0;
14604 dw_loc_descr_ref descr
, *descr_tail
;
14605 unsigned HOST_WIDE_INT decl_size
;
14607 enum var_init_status initialized
;
14609 if (DECL_SIZE (decl
) == NULL
14610 || !host_integerp (DECL_SIZE (decl
), 1))
14613 decl_size
= tree_low_cst (DECL_SIZE (decl
), 1);
14615 descr_tail
= &descr
;
14617 for (p
= loc
; p
; p
= XEXP (p
, 1))
14619 unsigned int bitsize
= decl_piece_bitsize (p
);
14620 rtx loc_note
= *decl_piece_varloc_ptr (p
);
14621 dw_loc_descr_ref cur_descr
;
14622 dw_loc_descr_ref
*tail
, last
= NULL
;
14623 unsigned int opsize
= 0;
14625 if (loc_note
== NULL_RTX
14626 || NOTE_VAR_LOCATION_LOC (loc_note
) == NULL_RTX
)
14628 padsize
+= bitsize
;
14631 initialized
= NOTE_VAR_LOCATION_STATUS (loc_note
);
14632 varloc
= NOTE_VAR_LOCATION (loc_note
);
14633 cur_descr
= dw_loc_list_1 (decl
, varloc
, 2, initialized
);
14634 if (cur_descr
== NULL
)
14636 padsize
+= bitsize
;
14640 /* Check that cur_descr either doesn't use
14641 DW_OP_*piece operations, or their sum is equal
14642 to bitsize. Otherwise we can't embed it. */
14643 for (tail
= &cur_descr
; *tail
!= NULL
;
14644 tail
= &(*tail
)->dw_loc_next
)
14645 if ((*tail
)->dw_loc_opc
== DW_OP_piece
)
14647 opsize
+= (*tail
)->dw_loc_oprnd1
.v
.val_unsigned
14651 else if ((*tail
)->dw_loc_opc
== DW_OP_bit_piece
)
14653 opsize
+= (*tail
)->dw_loc_oprnd1
.v
.val_unsigned
;
14657 if (last
!= NULL
&& opsize
!= bitsize
)
14659 padsize
+= bitsize
;
14663 /* If there is a hole, add DW_OP_*piece after empty DWARF
14664 expression, which means that those bits are optimized out. */
14667 if (padsize
> decl_size
)
14669 decl_size
-= padsize
;
14670 *descr_tail
= new_loc_descr_op_bit_piece (padsize
, 0);
14671 if (*descr_tail
== NULL
)
14673 descr_tail
= &(*descr_tail
)->dw_loc_next
;
14676 *descr_tail
= cur_descr
;
14678 if (bitsize
> decl_size
)
14680 decl_size
-= bitsize
;
14683 HOST_WIDE_INT offset
= 0;
14684 if (GET_CODE (varloc
) == VAR_LOCATION
14685 && GET_CODE (PAT_VAR_LOCATION_LOC (varloc
)) != PARALLEL
)
14687 varloc
= PAT_VAR_LOCATION_LOC (varloc
);
14688 if (GET_CODE (varloc
) == EXPR_LIST
)
14689 varloc
= XEXP (varloc
, 0);
14693 if (GET_CODE (varloc
) == CONST
14694 || GET_CODE (varloc
) == SIGN_EXTEND
14695 || GET_CODE (varloc
) == ZERO_EXTEND
)
14696 varloc
= XEXP (varloc
, 0);
14697 else if (GET_CODE (varloc
) == SUBREG
)
14698 varloc
= SUBREG_REG (varloc
);
14703 /* DW_OP_bit_size offset should be zero for register
14704 or implicit location descriptions and empty location
14705 descriptions, but for memory addresses needs big endian
14707 if (MEM_P (varloc
))
14709 unsigned HOST_WIDE_INT memsize
14710 = INTVAL (MEM_SIZE (varloc
)) * BITS_PER_UNIT
;
14711 if (memsize
!= bitsize
)
14713 if (BYTES_BIG_ENDIAN
!= WORDS_BIG_ENDIAN
14714 && (memsize
> BITS_PER_WORD
|| bitsize
> BITS_PER_WORD
))
14716 if (memsize
< bitsize
)
14718 if (BITS_BIG_ENDIAN
)
14719 offset
= memsize
- bitsize
;
14723 *descr_tail
= new_loc_descr_op_bit_piece (bitsize
, offset
);
14724 if (*descr_tail
== NULL
)
14726 descr_tail
= &(*descr_tail
)->dw_loc_next
;
14730 /* If there were any non-empty expressions, add padding till the end of
14732 if (descr
!= NULL
&& decl_size
!= 0)
14734 *descr_tail
= new_loc_descr_op_bit_piece (decl_size
, 0);
14735 if (*descr_tail
== NULL
)
14741 /* Return the dwarf representation of the location list LOC_LIST of
14742 DECL. WANT_ADDRESS has the same meaning as in loc_list_from_tree
14745 static dw_loc_list_ref
14746 dw_loc_list (var_loc_list
*loc_list
, tree decl
, int want_address
)
14748 const char *endname
, *secname
;
14750 enum var_init_status initialized
;
14751 struct var_loc_node
*node
;
14752 dw_loc_descr_ref descr
;
14753 char label_id
[MAX_ARTIFICIAL_LABEL_BYTES
];
14754 dw_loc_list_ref list
= NULL
;
14755 dw_loc_list_ref
*listp
= &list
;
14757 /* Now that we know what section we are using for a base,
14758 actually construct the list of locations.
14759 The first location information is what is passed to the
14760 function that creates the location list, and the remaining
14761 locations just get added on to that list.
14762 Note that we only know the start address for a location
14763 (IE location changes), so to build the range, we use
14764 the range [current location start, next location start].
14765 This means we have to special case the last node, and generate
14766 a range of [last location start, end of function label]. */
14768 secname
= secname_for_decl (decl
);
14770 for (node
= loc_list
->first
; node
; node
= node
->next
)
14771 if (GET_CODE (node
->loc
) == EXPR_LIST
14772 || NOTE_VAR_LOCATION_LOC (node
->loc
) != NULL_RTX
)
14774 if (GET_CODE (node
->loc
) == EXPR_LIST
)
14776 /* This requires DW_OP_{,bit_}piece, which is not usable
14777 inside DWARF expressions. */
14778 if (want_address
!= 2)
14780 descr
= dw_sra_loc_expr (decl
, node
->loc
);
14786 initialized
= NOTE_VAR_LOCATION_STATUS (node
->loc
);
14787 varloc
= NOTE_VAR_LOCATION (node
->loc
);
14788 descr
= dw_loc_list_1 (decl
, varloc
, want_address
, initialized
);
14792 /* The variable has a location between NODE->LABEL and
14793 NODE->NEXT->LABEL. */
14795 endname
= node
->next
->label
;
14796 /* If the variable has a location at the last label
14797 it keeps its location until the end of function. */
14798 else if (!current_function_decl
)
14799 endname
= text_end_label
;
14802 ASM_GENERATE_INTERNAL_LABEL (label_id
, FUNC_END_LABEL
,
14803 current_function_funcdef_no
);
14804 endname
= ggc_strdup (label_id
);
14807 *listp
= new_loc_list (descr
, node
->label
, endname
, secname
);
14808 listp
= &(*listp
)->dw_loc_next
;
14812 /* Try to avoid the overhead of a location list emitting a location
14813 expression instead, but only if we didn't have more than one
14814 location entry in the first place. If some entries were not
14815 representable, we don't want to pretend a single entry that was
14816 applies to the entire scope in which the variable is
14818 if (list
&& loc_list
->first
->next
)
14824 /* Return if the loc_list has only single element and thus can be represented
14825 as location description. */
14828 single_element_loc_list_p (dw_loc_list_ref list
)
14830 gcc_assert (!list
->dw_loc_next
|| list
->ll_symbol
);
14831 return !list
->ll_symbol
;
14834 /* To each location in list LIST add loc descr REF. */
14837 add_loc_descr_to_each (dw_loc_list_ref list
, dw_loc_descr_ref ref
)
14839 dw_loc_descr_ref copy
;
14840 add_loc_descr (&list
->expr
, ref
);
14841 list
= list
->dw_loc_next
;
14844 copy
= ggc_alloc_dw_loc_descr_node ();
14845 memcpy (copy
, ref
, sizeof (dw_loc_descr_node
));
14846 add_loc_descr (&list
->expr
, copy
);
14847 while (copy
->dw_loc_next
)
14849 dw_loc_descr_ref new_copy
= ggc_alloc_dw_loc_descr_node ();
14850 memcpy (new_copy
, copy
->dw_loc_next
, sizeof (dw_loc_descr_node
));
14851 copy
->dw_loc_next
= new_copy
;
14854 list
= list
->dw_loc_next
;
14858 /* Given two lists RET and LIST
14859 produce location list that is result of adding expression in LIST
14860 to expression in RET on each possition in program.
14861 Might be destructive on both RET and LIST.
14863 TODO: We handle only simple cases of RET or LIST having at most one
14864 element. General case would inolve sorting the lists in program order
14865 and merging them that will need some additional work.
14866 Adding that will improve quality of debug info especially for SRA-ed
14870 add_loc_list (dw_loc_list_ref
*ret
, dw_loc_list_ref list
)
14879 if (!list
->dw_loc_next
)
14881 add_loc_descr_to_each (*ret
, list
->expr
);
14884 if (!(*ret
)->dw_loc_next
)
14886 add_loc_descr_to_each (list
, (*ret
)->expr
);
14890 expansion_failed (NULL_TREE
, NULL_RTX
,
14891 "Don't know how to merge two non-trivial"
14892 " location lists.\n");
14897 /* LOC is constant expression. Try a luck, look it up in constant
14898 pool and return its loc_descr of its address. */
14900 static dw_loc_descr_ref
14901 cst_pool_loc_descr (tree loc
)
14903 /* Get an RTL for this, if something has been emitted. */
14904 rtx rtl
= lookup_constant_def (loc
);
14905 enum machine_mode mode
;
14907 if (!rtl
|| !MEM_P (rtl
))
14912 gcc_assert (GET_CODE (XEXP (rtl
, 0)) == SYMBOL_REF
);
14914 /* TODO: We might get more coverage if we was actually delaying expansion
14915 of all expressions till end of compilation when constant pools are fully
14917 if (!TREE_ASM_WRITTEN (SYMBOL_REF_DECL (XEXP (rtl
, 0))))
14919 expansion_failed (loc
, NULL_RTX
,
14920 "CST value in contant pool but not marked.");
14923 mode
= GET_MODE (rtl
);
14924 rtl
= XEXP (rtl
, 0);
14925 return mem_loc_descriptor (rtl
, mode
, VAR_INIT_STATUS_INITIALIZED
);
14928 /* Return dw_loc_list representing address of addr_expr LOC
14929 by looking for innder INDIRECT_REF expression and turing it
14930 into simple arithmetics. */
14932 static dw_loc_list_ref
14933 loc_list_for_address_of_addr_expr_of_indirect_ref (tree loc
, bool toplev
)
14936 HOST_WIDE_INT bitsize
, bitpos
, bytepos
;
14937 enum machine_mode mode
;
14939 int unsignedp
= TYPE_UNSIGNED (TREE_TYPE (loc
));
14940 dw_loc_list_ref list_ret
= NULL
, list_ret1
= NULL
;
14942 obj
= get_inner_reference (TREE_OPERAND (loc
, 0),
14943 &bitsize
, &bitpos
, &offset
, &mode
,
14944 &unsignedp
, &volatilep
, false);
14946 if (bitpos
% BITS_PER_UNIT
)
14948 expansion_failed (loc
, NULL_RTX
, "bitfield access");
14951 if (!INDIRECT_REF_P (obj
))
14953 expansion_failed (obj
,
14954 NULL_RTX
, "no indirect ref in inner refrence");
14957 if (!offset
&& !bitpos
)
14958 list_ret
= loc_list_from_tree (TREE_OPERAND (obj
, 0), toplev
? 2 : 1);
14960 && int_size_in_bytes (TREE_TYPE (loc
)) <= DWARF2_ADDR_SIZE
14961 && (dwarf_version
>= 4 || !dwarf_strict
))
14963 list_ret
= loc_list_from_tree (TREE_OPERAND (obj
, 0), 0);
14968 /* Variable offset. */
14969 list_ret1
= loc_list_from_tree (offset
, 0);
14970 if (list_ret1
== 0)
14972 add_loc_list (&list_ret
, list_ret1
);
14975 add_loc_descr_to_each (list_ret
,
14976 new_loc_descr (DW_OP_plus
, 0, 0));
14978 bytepos
= bitpos
/ BITS_PER_UNIT
;
14980 add_loc_descr_to_each (list_ret
,
14981 new_loc_descr (DW_OP_plus_uconst
,
14983 else if (bytepos
< 0)
14984 loc_list_plus_const (list_ret
, bytepos
);
14985 add_loc_descr_to_each (list_ret
,
14986 new_loc_descr (DW_OP_stack_value
, 0, 0));
14992 /* Generate Dwarf location list representing LOC.
14993 If WANT_ADDRESS is false, expression computing LOC will be computed
14994 If WANT_ADDRESS is 1, expression computing address of LOC will be returned
14995 if WANT_ADDRESS is 2, expression computing address useable in location
14996 will be returned (i.e. DW_OP_reg can be used
14997 to refer to register values). */
14999 static dw_loc_list_ref
15000 loc_list_from_tree (tree loc
, int want_address
)
15002 dw_loc_descr_ref ret
= NULL
, ret1
= NULL
;
15003 dw_loc_list_ref list_ret
= NULL
, list_ret1
= NULL
;
15004 int have_address
= 0;
15005 enum dwarf_location_atom op
;
15007 /* ??? Most of the time we do not take proper care for sign/zero
15008 extending the values properly. Hopefully this won't be a real
15011 switch (TREE_CODE (loc
))
15014 expansion_failed (loc
, NULL_RTX
, "ERROR_MARK");
15017 case PLACEHOLDER_EXPR
:
15018 /* This case involves extracting fields from an object to determine the
15019 position of other fields. We don't try to encode this here. The
15020 only user of this is Ada, which encodes the needed information using
15021 the names of types. */
15022 expansion_failed (loc
, NULL_RTX
, "PLACEHOLDER_EXPR");
15026 expansion_failed (loc
, NULL_RTX
, "CALL_EXPR");
15027 /* There are no opcodes for these operations. */
15030 case PREINCREMENT_EXPR
:
15031 case PREDECREMENT_EXPR
:
15032 case POSTINCREMENT_EXPR
:
15033 case POSTDECREMENT_EXPR
:
15034 expansion_failed (loc
, NULL_RTX
, "PRE/POST INDCREMENT/DECREMENT");
15035 /* There are no opcodes for these operations. */
15039 /* If we already want an address, see if there is INDIRECT_REF inside
15040 e.g. for &this->field. */
15043 list_ret
= loc_list_for_address_of_addr_expr_of_indirect_ref
15044 (loc
, want_address
== 2);
15047 else if (decl_address_ip_invariant_p (TREE_OPERAND (loc
, 0))
15048 && (ret
= cst_pool_loc_descr (loc
)))
15051 /* Otherwise, process the argument and look for the address. */
15052 if (!list_ret
&& !ret
)
15053 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 1);
15057 expansion_failed (loc
, NULL_RTX
, "need address of ADDR_EXPR");
15063 if (DECL_THREAD_LOCAL_P (loc
))
15066 enum dwarf_location_atom first_op
;
15067 enum dwarf_location_atom second_op
;
15068 bool dtprel
= false;
15070 if (targetm
.have_tls
)
15072 /* If this is not defined, we have no way to emit the
15074 if (!targetm
.asm_out
.output_dwarf_dtprel
)
15077 /* The way DW_OP_GNU_push_tls_address is specified, we
15078 can only look up addresses of objects in the current
15080 if (DECL_EXTERNAL (loc
) && !targetm
.binds_local_p (loc
))
15082 first_op
= DW_OP_addr
;
15084 second_op
= DW_OP_GNU_push_tls_address
;
15088 if (!targetm
.emutls
.debug_form_tls_address
15089 || !(dwarf_version
>= 3 || !dwarf_strict
))
15091 loc
= emutls_decl (loc
);
15092 first_op
= DW_OP_addr
;
15093 second_op
= DW_OP_form_tls_address
;
15096 rtl
= rtl_for_decl_location (loc
);
15097 if (rtl
== NULL_RTX
)
15102 rtl
= XEXP (rtl
, 0);
15103 if (! CONSTANT_P (rtl
))
15106 ret
= new_loc_descr (first_op
, 0, 0);
15107 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_addr
;
15108 ret
->dw_loc_oprnd1
.v
.val_addr
= rtl
;
15109 ret
->dtprel
= dtprel
;
15111 ret1
= new_loc_descr (second_op
, 0, 0);
15112 add_loc_descr (&ret
, ret1
);
15120 if (DECL_HAS_VALUE_EXPR_P (loc
))
15121 return loc_list_from_tree (DECL_VALUE_EXPR (loc
),
15126 case FUNCTION_DECL
:
15129 var_loc_list
*loc_list
= lookup_decl_loc (loc
);
15131 if (loc_list
&& loc_list
->first
)
15133 list_ret
= dw_loc_list (loc_list
, loc
, want_address
);
15134 have_address
= want_address
!= 0;
15137 rtl
= rtl_for_decl_location (loc
);
15138 if (rtl
== NULL_RTX
)
15140 expansion_failed (loc
, NULL_RTX
, "DECL has no RTL");
15143 else if (CONST_INT_P (rtl
))
15145 HOST_WIDE_INT val
= INTVAL (rtl
);
15146 if (TYPE_UNSIGNED (TREE_TYPE (loc
)))
15147 val
&= GET_MODE_MASK (DECL_MODE (loc
));
15148 ret
= int_loc_descriptor (val
);
15150 else if (GET_CODE (rtl
) == CONST_STRING
)
15152 expansion_failed (loc
, NULL_RTX
, "CONST_STRING");
15155 else if (CONSTANT_P (rtl
) && const_ok_for_output (rtl
))
15157 ret
= new_loc_descr (DW_OP_addr
, 0, 0);
15158 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_addr
;
15159 ret
->dw_loc_oprnd1
.v
.val_addr
= rtl
;
15163 enum machine_mode mode
;
15165 /* Certain constructs can only be represented at top-level. */
15166 if (want_address
== 2)
15168 ret
= loc_descriptor (rtl
, VOIDmode
,
15169 VAR_INIT_STATUS_INITIALIZED
);
15174 mode
= GET_MODE (rtl
);
15177 rtl
= XEXP (rtl
, 0);
15180 ret
= mem_loc_descriptor (rtl
, mode
, VAR_INIT_STATUS_INITIALIZED
);
15183 expansion_failed (loc
, rtl
,
15184 "failed to produce loc descriptor for rtl");
15191 if (!integer_zerop (TREE_OPERAND (loc
, 1)))
15195 case MISALIGNED_INDIRECT_REF
:
15196 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 0);
15200 case COMPOUND_EXPR
:
15201 return loc_list_from_tree (TREE_OPERAND (loc
, 1), want_address
);
15204 case VIEW_CONVERT_EXPR
:
15207 return loc_list_from_tree (TREE_OPERAND (loc
, 0), want_address
);
15209 case COMPONENT_REF
:
15210 case BIT_FIELD_REF
:
15212 case ARRAY_RANGE_REF
:
15213 case REALPART_EXPR
:
15214 case IMAGPART_EXPR
:
15217 HOST_WIDE_INT bitsize
, bitpos
, bytepos
;
15218 enum machine_mode mode
;
15220 int unsignedp
= TYPE_UNSIGNED (TREE_TYPE (loc
));
15222 obj
= get_inner_reference (loc
, &bitsize
, &bitpos
, &offset
, &mode
,
15223 &unsignedp
, &volatilep
, false);
15225 gcc_assert (obj
!= loc
);
15227 list_ret
= loc_list_from_tree (obj
,
15229 && !bitpos
&& !offset
? 2 : 1);
15230 /* TODO: We can extract value of the small expression via shifting even
15231 for nonzero bitpos. */
15234 if (bitpos
% BITS_PER_UNIT
!= 0 || bitsize
% BITS_PER_UNIT
!= 0)
15236 expansion_failed (loc
, NULL_RTX
,
15237 "bitfield access");
15241 if (offset
!= NULL_TREE
)
15243 /* Variable offset. */
15244 list_ret1
= loc_list_from_tree (offset
, 0);
15245 if (list_ret1
== 0)
15247 add_loc_list (&list_ret
, list_ret1
);
15250 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_plus
, 0, 0));
15253 bytepos
= bitpos
/ BITS_PER_UNIT
;
15255 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_plus_uconst
, bytepos
, 0));
15256 else if (bytepos
< 0)
15257 loc_list_plus_const (list_ret
, bytepos
);
15264 if ((want_address
|| !host_integerp (loc
, 0))
15265 && (ret
= cst_pool_loc_descr (loc
)))
15267 else if (want_address
== 2
15268 && host_integerp (loc
, 0)
15269 && (ret
= address_of_int_loc_descriptor
15270 (int_size_in_bytes (TREE_TYPE (loc
)),
15271 tree_low_cst (loc
, 0))))
15273 else if (host_integerp (loc
, 0))
15274 ret
= int_loc_descriptor (tree_low_cst (loc
, 0));
15277 expansion_failed (loc
, NULL_RTX
,
15278 "Integer operand is not host integer");
15287 if ((ret
= cst_pool_loc_descr (loc
)))
15290 /* We can construct small constants here using int_loc_descriptor. */
15291 expansion_failed (loc
, NULL_RTX
,
15292 "constructor or constant not in constant pool");
15295 case TRUTH_AND_EXPR
:
15296 case TRUTH_ANDIF_EXPR
:
15301 case TRUTH_XOR_EXPR
:
15306 case TRUTH_OR_EXPR
:
15307 case TRUTH_ORIF_EXPR
:
15312 case FLOOR_DIV_EXPR
:
15313 case CEIL_DIV_EXPR
:
15314 case ROUND_DIV_EXPR
:
15315 case TRUNC_DIV_EXPR
:
15316 if (TYPE_UNSIGNED (TREE_TYPE (loc
)))
15325 case FLOOR_MOD_EXPR
:
15326 case CEIL_MOD_EXPR
:
15327 case ROUND_MOD_EXPR
:
15328 case TRUNC_MOD_EXPR
:
15329 if (TYPE_UNSIGNED (TREE_TYPE (loc
)))
15334 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 0);
15335 list_ret1
= loc_list_from_tree (TREE_OPERAND (loc
, 1), 0);
15336 if (list_ret
== 0 || list_ret1
== 0)
15339 add_loc_list (&list_ret
, list_ret1
);
15342 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_over
, 0, 0));
15343 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_over
, 0, 0));
15344 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_div
, 0, 0));
15345 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_mul
, 0, 0));
15346 add_loc_descr_to_each (list_ret
, new_loc_descr (DW_OP_minus
, 0, 0));
15358 op
= (TYPE_UNSIGNED (TREE_TYPE (loc
)) ? DW_OP_shr
: DW_OP_shra
);
15361 case POINTER_PLUS_EXPR
:
15363 if (host_integerp (TREE_OPERAND (loc
, 1), 0))
15365 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 0);
15369 loc_list_plus_const (list_ret
, tree_low_cst (TREE_OPERAND (loc
, 1), 0));
15377 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc
, 0))))
15384 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc
, 0))))
15391 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc
, 0))))
15398 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc
, 0))))
15413 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 0);
15414 list_ret1
= loc_list_from_tree (TREE_OPERAND (loc
, 1), 0);
15415 if (list_ret
== 0 || list_ret1
== 0)
15418 add_loc_list (&list_ret
, list_ret1
);
15421 add_loc_descr_to_each (list_ret
, new_loc_descr (op
, 0, 0));
15424 case TRUTH_NOT_EXPR
:
15438 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 0);
15442 add_loc_descr_to_each (list_ret
, new_loc_descr (op
, 0, 0));
15448 const enum tree_code code
=
15449 TREE_CODE (loc
) == MIN_EXPR
? GT_EXPR
: LT_EXPR
;
15451 loc
= build3 (COND_EXPR
, TREE_TYPE (loc
),
15452 build2 (code
, integer_type_node
,
15453 TREE_OPERAND (loc
, 0), TREE_OPERAND (loc
, 1)),
15454 TREE_OPERAND (loc
, 1), TREE_OPERAND (loc
, 0));
15457 /* ... fall through ... */
15461 dw_loc_descr_ref lhs
15462 = loc_descriptor_from_tree (TREE_OPERAND (loc
, 1), 0);
15463 dw_loc_list_ref rhs
15464 = loc_list_from_tree (TREE_OPERAND (loc
, 2), 0);
15465 dw_loc_descr_ref bra_node
, jump_node
, tmp
;
15467 list_ret
= loc_list_from_tree (TREE_OPERAND (loc
, 0), 0);
15468 if (list_ret
== 0 || lhs
== 0 || rhs
== 0)
15471 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
15472 add_loc_descr_to_each (list_ret
, bra_node
);
15474 add_loc_list (&list_ret
, rhs
);
15475 jump_node
= new_loc_descr (DW_OP_skip
, 0, 0);
15476 add_loc_descr_to_each (list_ret
, jump_node
);
15478 add_loc_descr_to_each (list_ret
, lhs
);
15479 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15480 bra_node
->dw_loc_oprnd1
.v
.val_loc
= lhs
;
15482 /* ??? Need a node to point the skip at. Use a nop. */
15483 tmp
= new_loc_descr (DW_OP_nop
, 0, 0);
15484 add_loc_descr_to_each (list_ret
, tmp
);
15485 jump_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
15486 jump_node
->dw_loc_oprnd1
.v
.val_loc
= tmp
;
15490 case FIX_TRUNC_EXPR
:
15494 /* Leave front-end specific codes as simply unknown. This comes
15495 up, for instance, with the C STMT_EXPR. */
15496 if ((unsigned int) TREE_CODE (loc
)
15497 >= (unsigned int) LAST_AND_UNUSED_TREE_CODE
)
15499 expansion_failed (loc
, NULL_RTX
,
15500 "language specific tree node");
15504 #ifdef ENABLE_CHECKING
15505 /* Otherwise this is a generic code; we should just lists all of
15506 these explicitly. We forgot one. */
15507 gcc_unreachable ();
15509 /* In a release build, we want to degrade gracefully: better to
15510 generate incomplete debugging information than to crash. */
15515 if (!ret
&& !list_ret
)
15518 if (want_address
== 2 && !have_address
15519 && (dwarf_version
>= 4 || !dwarf_strict
))
15521 if (int_size_in_bytes (TREE_TYPE (loc
)) > DWARF2_ADDR_SIZE
)
15523 expansion_failed (loc
, NULL_RTX
,
15524 "DWARF address size mismatch");
15528 add_loc_descr (&ret
, new_loc_descr (DW_OP_stack_value
, 0, 0));
15530 add_loc_descr_to_each (list_ret
,
15531 new_loc_descr (DW_OP_stack_value
, 0, 0));
15534 /* Show if we can't fill the request for an address. */
15535 if (want_address
&& !have_address
)
15537 expansion_failed (loc
, NULL_RTX
,
15538 "Want address and only have value");
15542 gcc_assert (!ret
|| !list_ret
);
15544 /* If we've got an address and don't want one, dereference. */
15545 if (!want_address
&& have_address
)
15547 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (loc
));
15549 if (size
> DWARF2_ADDR_SIZE
|| size
== -1)
15551 expansion_failed (loc
, NULL_RTX
,
15552 "DWARF address size mismatch");
15555 else if (size
== DWARF2_ADDR_SIZE
)
15558 op
= DW_OP_deref_size
;
15561 add_loc_descr (&ret
, new_loc_descr (op
, size
, 0));
15563 add_loc_descr_to_each (list_ret
, new_loc_descr (op
, size
, 0));
15566 list_ret
= new_loc_list (ret
, NULL
, NULL
, NULL
);
15571 /* Same as above but return only single location expression. */
15572 static dw_loc_descr_ref
15573 loc_descriptor_from_tree (tree loc
, int want_address
)
15575 dw_loc_list_ref ret
= loc_list_from_tree (loc
, want_address
);
15578 if (ret
->dw_loc_next
)
15580 expansion_failed (loc
, NULL_RTX
,
15581 "Location list where only loc descriptor needed");
15587 /* Given a value, round it up to the lowest multiple of `boundary'
15588 which is not less than the value itself. */
15590 static inline HOST_WIDE_INT
15591 ceiling (HOST_WIDE_INT value
, unsigned int boundary
)
15593 return (((value
+ boundary
- 1) / boundary
) * boundary
);
15596 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
15597 pointer to the declared type for the relevant field variable, or return
15598 `integer_type_node' if the given node turns out to be an
15599 ERROR_MARK node. */
15602 field_type (const_tree decl
)
15606 if (TREE_CODE (decl
) == ERROR_MARK
)
15607 return integer_type_node
;
15609 type
= DECL_BIT_FIELD_TYPE (decl
);
15610 if (type
== NULL_TREE
)
15611 type
= TREE_TYPE (decl
);
15616 /* Given a pointer to a tree node, return the alignment in bits for
15617 it, or else return BITS_PER_WORD if the node actually turns out to
15618 be an ERROR_MARK node. */
15620 static inline unsigned
15621 simple_type_align_in_bits (const_tree type
)
15623 return (TREE_CODE (type
) != ERROR_MARK
) ? TYPE_ALIGN (type
) : BITS_PER_WORD
;
15626 static inline unsigned
15627 simple_decl_align_in_bits (const_tree decl
)
15629 return (TREE_CODE (decl
) != ERROR_MARK
) ? DECL_ALIGN (decl
) : BITS_PER_WORD
;
15632 /* Return the result of rounding T up to ALIGN. */
15634 static inline double_int
15635 round_up_to_align (double_int t
, unsigned int align
)
15637 double_int alignd
= uhwi_to_double_int (align
);
15638 t
= double_int_add (t
, alignd
);
15639 t
= double_int_add (t
, double_int_minus_one
);
15640 t
= double_int_div (t
, alignd
, true, TRUNC_DIV_EXPR
);
15641 t
= double_int_mul (t
, alignd
);
15645 /* Given a pointer to a FIELD_DECL, compute and return the byte offset of the
15646 lowest addressed byte of the "containing object" for the given FIELD_DECL,
15647 or return 0 if we are unable to determine what that offset is, either
15648 because the argument turns out to be a pointer to an ERROR_MARK node, or
15649 because the offset is actually variable. (We can't handle the latter case
15652 static HOST_WIDE_INT
15653 field_byte_offset (const_tree decl
)
15655 double_int object_offset_in_bits
;
15656 double_int object_offset_in_bytes
;
15657 double_int bitpos_int
;
15659 if (TREE_CODE (decl
) == ERROR_MARK
)
15662 gcc_assert (TREE_CODE (decl
) == FIELD_DECL
);
15664 /* We cannot yet cope with fields whose positions are variable, so
15665 for now, when we see such things, we simply return 0. Someday, we may
15666 be able to handle such cases, but it will be damn difficult. */
15667 if (TREE_CODE (bit_position (decl
)) != INTEGER_CST
)
15670 bitpos_int
= tree_to_double_int (bit_position (decl
));
15672 #ifdef PCC_BITFIELD_TYPE_MATTERS
15673 if (PCC_BITFIELD_TYPE_MATTERS
)
15676 tree field_size_tree
;
15677 double_int deepest_bitpos
;
15678 double_int field_size_in_bits
;
15679 unsigned int type_align_in_bits
;
15680 unsigned int decl_align_in_bits
;
15681 double_int type_size_in_bits
;
15683 type
= field_type (decl
);
15684 type_size_in_bits
= double_int_type_size_in_bits (type
);
15685 type_align_in_bits
= simple_type_align_in_bits (type
);
15687 field_size_tree
= DECL_SIZE (decl
);
15689 /* The size could be unspecified if there was an error, or for
15690 a flexible array member. */
15691 if (!field_size_tree
)
15692 field_size_tree
= bitsize_zero_node
;
15694 /* If the size of the field is not constant, use the type size. */
15695 if (TREE_CODE (field_size_tree
) == INTEGER_CST
)
15696 field_size_in_bits
= tree_to_double_int (field_size_tree
);
15698 field_size_in_bits
= type_size_in_bits
;
15700 decl_align_in_bits
= simple_decl_align_in_bits (decl
);
15702 /* The GCC front-end doesn't make any attempt to keep track of the
15703 starting bit offset (relative to the start of the containing
15704 structure type) of the hypothetical "containing object" for a
15705 bit-field. Thus, when computing the byte offset value for the
15706 start of the "containing object" of a bit-field, we must deduce
15707 this information on our own. This can be rather tricky to do in
15708 some cases. For example, handling the following structure type
15709 definition when compiling for an i386/i486 target (which only
15710 aligns long long's to 32-bit boundaries) can be very tricky:
15712 struct S { int field1; long long field2:31; };
15714 Fortunately, there is a simple rule-of-thumb which can be used
15715 in such cases. When compiling for an i386/i486, GCC will
15716 allocate 8 bytes for the structure shown above. It decides to
15717 do this based upon one simple rule for bit-field allocation.
15718 GCC allocates each "containing object" for each bit-field at
15719 the first (i.e. lowest addressed) legitimate alignment boundary
15720 (based upon the required minimum alignment for the declared
15721 type of the field) which it can possibly use, subject to the
15722 condition that there is still enough available space remaining
15723 in the containing object (when allocated at the selected point)
15724 to fully accommodate all of the bits of the bit-field itself.
15726 This simple rule makes it obvious why GCC allocates 8 bytes for
15727 each object of the structure type shown above. When looking
15728 for a place to allocate the "containing object" for `field2',
15729 the compiler simply tries to allocate a 64-bit "containing
15730 object" at each successive 32-bit boundary (starting at zero)
15731 until it finds a place to allocate that 64- bit field such that
15732 at least 31 contiguous (and previously unallocated) bits remain
15733 within that selected 64 bit field. (As it turns out, for the
15734 example above, the compiler finds it is OK to allocate the
15735 "containing object" 64-bit field at bit-offset zero within the
15738 Here we attempt to work backwards from the limited set of facts
15739 we're given, and we try to deduce from those facts, where GCC
15740 must have believed that the containing object started (within
15741 the structure type). The value we deduce is then used (by the
15742 callers of this routine) to generate DW_AT_location and
15743 DW_AT_bit_offset attributes for fields (both bit-fields and, in
15744 the case of DW_AT_location, regular fields as well). */
15746 /* Figure out the bit-distance from the start of the structure to
15747 the "deepest" bit of the bit-field. */
15748 deepest_bitpos
= double_int_add (bitpos_int
, field_size_in_bits
);
15750 /* This is the tricky part. Use some fancy footwork to deduce
15751 where the lowest addressed bit of the containing object must
15753 object_offset_in_bits
15754 = double_int_sub (deepest_bitpos
, type_size_in_bits
);
15756 /* Round up to type_align by default. This works best for
15758 object_offset_in_bits
15759 = round_up_to_align (object_offset_in_bits
, type_align_in_bits
);
15761 if (double_int_ucmp (object_offset_in_bits
, bitpos_int
) > 0)
15763 object_offset_in_bits
15764 = double_int_sub (deepest_bitpos
, type_size_in_bits
);
15766 /* Round up to decl_align instead. */
15767 object_offset_in_bits
15768 = round_up_to_align (object_offset_in_bits
, decl_align_in_bits
);
15773 object_offset_in_bits
= bitpos_int
;
15775 object_offset_in_bytes
15776 = double_int_div (object_offset_in_bits
,
15777 uhwi_to_double_int (BITS_PER_UNIT
), true,
15779 return double_int_to_shwi (object_offset_in_bytes
);
15782 /* The following routines define various Dwarf attributes and any data
15783 associated with them. */
15785 /* Add a location description attribute value to a DIE.
15787 This emits location attributes suitable for whole variables and
15788 whole parameters. Note that the location attributes for struct fields are
15789 generated by the routine `data_member_location_attribute' below. */
15792 add_AT_location_description (dw_die_ref die
, enum dwarf_attribute attr_kind
,
15793 dw_loc_list_ref descr
)
15797 if (single_element_loc_list_p (descr
))
15798 add_AT_loc (die
, attr_kind
, descr
->expr
);
15800 add_AT_loc_list (die
, attr_kind
, descr
);
15803 /* Add DW_AT_accessibility attribute to DIE if needed. */
15806 add_accessibility_attribute (dw_die_ref die
, tree decl
)
15808 if (TREE_PROTECTED (decl
))
15809 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_protected
);
15810 else if (TREE_PRIVATE (decl
))
15811 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_private
);
15814 /* Attach the specialized form of location attribute used for data members of
15815 struct and union types. In the special case of a FIELD_DECL node which
15816 represents a bit-field, the "offset" part of this special location
15817 descriptor must indicate the distance in bytes from the lowest-addressed
15818 byte of the containing struct or union type to the lowest-addressed byte of
15819 the "containing object" for the bit-field. (See the `field_byte_offset'
15822 For any given bit-field, the "containing object" is a hypothetical object
15823 (of some integral or enum type) within which the given bit-field lives. The
15824 type of this hypothetical "containing object" is always the same as the
15825 declared type of the individual bit-field itself (for GCC anyway... the
15826 DWARF spec doesn't actually mandate this). Note that it is the size (in
15827 bytes) of the hypothetical "containing object" which will be given in the
15828 DW_AT_byte_size attribute for this bit-field. (See the
15829 `byte_size_attribute' function below.) It is also used when calculating the
15830 value of the DW_AT_bit_offset attribute. (See the `bit_offset_attribute'
15831 function below.) */
15834 add_data_member_location_attribute (dw_die_ref die
, tree decl
)
15836 HOST_WIDE_INT offset
;
15837 dw_loc_descr_ref loc_descr
= 0;
15839 if (TREE_CODE (decl
) == TREE_BINFO
)
15841 /* We're working on the TAG_inheritance for a base class. */
15842 if (BINFO_VIRTUAL_P (decl
) && is_cxx ())
15844 /* For C++ virtual bases we can't just use BINFO_OFFSET, as they
15845 aren't at a fixed offset from all (sub)objects of the same
15846 type. We need to extract the appropriate offset from our
15847 vtable. The following dwarf expression means
15849 BaseAddr = ObAddr + *((*ObAddr) - Offset)
15851 This is specific to the V3 ABI, of course. */
15853 dw_loc_descr_ref tmp
;
15855 /* Make a copy of the object address. */
15856 tmp
= new_loc_descr (DW_OP_dup
, 0, 0);
15857 add_loc_descr (&loc_descr
, tmp
);
15859 /* Extract the vtable address. */
15860 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
15861 add_loc_descr (&loc_descr
, tmp
);
15863 /* Calculate the address of the offset. */
15864 offset
= tree_low_cst (BINFO_VPTR_FIELD (decl
), 0);
15865 gcc_assert (offset
< 0);
15867 tmp
= int_loc_descriptor (-offset
);
15868 add_loc_descr (&loc_descr
, tmp
);
15869 tmp
= new_loc_descr (DW_OP_minus
, 0, 0);
15870 add_loc_descr (&loc_descr
, tmp
);
15872 /* Extract the offset. */
15873 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
15874 add_loc_descr (&loc_descr
, tmp
);
15876 /* Add it to the object address. */
15877 tmp
= new_loc_descr (DW_OP_plus
, 0, 0);
15878 add_loc_descr (&loc_descr
, tmp
);
15881 offset
= tree_low_cst (BINFO_OFFSET (decl
), 0);
15884 offset
= field_byte_offset (decl
);
15888 if (dwarf_version
> 2)
15890 /* Don't need to output a location expression, just the constant. */
15891 add_AT_int (die
, DW_AT_data_member_location
, offset
);
15896 enum dwarf_location_atom op
;
15898 /* The DWARF2 standard says that we should assume that the structure
15899 address is already on the stack, so we can specify a structure
15900 field address by using DW_OP_plus_uconst. */
15902 #ifdef MIPS_DEBUGGING_INFO
15903 /* ??? The SGI dwarf reader does not handle the DW_OP_plus_uconst
15904 operator correctly. It works only if we leave the offset on the
15908 op
= DW_OP_plus_uconst
;
15911 loc_descr
= new_loc_descr (op
, offset
, 0);
15915 add_AT_loc (die
, DW_AT_data_member_location
, loc_descr
);
15918 /* Writes integer values to dw_vec_const array. */
15921 insert_int (HOST_WIDE_INT val
, unsigned int size
, unsigned char *dest
)
15925 *dest
++ = val
& 0xff;
15931 /* Reads integers from dw_vec_const array. Inverse of insert_int. */
15933 static HOST_WIDE_INT
15934 extract_int (const unsigned char *src
, unsigned int size
)
15936 HOST_WIDE_INT val
= 0;
15942 val
|= *--src
& 0xff;
15948 /* Writes double_int values to dw_vec_const array. */
15951 insert_double (double_int val
, unsigned char *dest
)
15953 unsigned char *p0
= dest
;
15954 unsigned char *p1
= dest
+ sizeof (HOST_WIDE_INT
);
15956 if (WORDS_BIG_ENDIAN
)
15962 insert_int ((HOST_WIDE_INT
) val
.low
, sizeof (HOST_WIDE_INT
), p0
);
15963 insert_int ((HOST_WIDE_INT
) val
.high
, sizeof (HOST_WIDE_INT
), p1
);
15966 /* Writes floating point values to dw_vec_const array. */
15969 insert_float (const_rtx rtl
, unsigned char *array
)
15971 REAL_VALUE_TYPE rv
;
15975 REAL_VALUE_FROM_CONST_DOUBLE (rv
, rtl
);
15976 real_to_target (val
, &rv
, GET_MODE (rtl
));
15978 /* real_to_target puts 32-bit pieces in each long. Pack them. */
15979 for (i
= 0; i
< GET_MODE_SIZE (GET_MODE (rtl
)) / 4; i
++)
15981 insert_int (val
[i
], 4, array
);
15986 /* Attach a DW_AT_const_value attribute for a variable or a parameter which
15987 does not have a "location" either in memory or in a register. These
15988 things can arise in GNU C when a constant is passed as an actual parameter
15989 to an inlined function. They can also arise in C++ where declared
15990 constants do not necessarily get memory "homes". */
15993 add_const_value_attribute (dw_die_ref die
, rtx rtl
)
15995 switch (GET_CODE (rtl
))
15999 HOST_WIDE_INT val
= INTVAL (rtl
);
16002 add_AT_int (die
, DW_AT_const_value
, val
);
16004 add_AT_unsigned (die
, DW_AT_const_value
, (unsigned HOST_WIDE_INT
) val
);
16009 /* Note that a CONST_DOUBLE rtx could represent either an integer or a
16010 floating-point constant. A CONST_DOUBLE is used whenever the
16011 constant requires more than one word in order to be adequately
16014 enum machine_mode mode
= GET_MODE (rtl
);
16016 if (SCALAR_FLOAT_MODE_P (mode
))
16018 unsigned int length
= GET_MODE_SIZE (mode
);
16019 unsigned char *array
= (unsigned char *) ggc_alloc_atomic (length
);
16021 insert_float (rtl
, array
);
16022 add_AT_vec (die
, DW_AT_const_value
, length
/ 4, 4, array
);
16025 add_AT_double (die
, DW_AT_const_value
,
16026 CONST_DOUBLE_HIGH (rtl
), CONST_DOUBLE_LOW (rtl
));
16032 enum machine_mode mode
= GET_MODE (rtl
);
16033 unsigned int elt_size
= GET_MODE_UNIT_SIZE (mode
);
16034 unsigned int length
= CONST_VECTOR_NUNITS (rtl
);
16035 unsigned char *array
= (unsigned char *) ggc_alloc_atomic
16036 (length
* elt_size
);
16040 switch (GET_MODE_CLASS (mode
))
16042 case MODE_VECTOR_INT
:
16043 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
16045 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
16046 double_int val
= rtx_to_double_int (elt
);
16048 if (elt_size
<= sizeof (HOST_WIDE_INT
))
16049 insert_int (double_int_to_shwi (val
), elt_size
, p
);
16052 gcc_assert (elt_size
== 2 * sizeof (HOST_WIDE_INT
));
16053 insert_double (val
, p
);
16058 case MODE_VECTOR_FLOAT
:
16059 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
16061 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
16062 insert_float (elt
, p
);
16067 gcc_unreachable ();
16070 add_AT_vec (die
, DW_AT_const_value
, length
, elt_size
, array
);
16075 if (dwarf_version
>= 4 || !dwarf_strict
)
16077 dw_loc_descr_ref loc_result
;
16078 resolve_one_addr (&rtl
, NULL
);
16080 loc_result
= new_loc_descr (DW_OP_addr
, 0, 0);
16081 loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_addr
;
16082 loc_result
->dw_loc_oprnd1
.v
.val_addr
= rtl
;
16083 add_loc_descr (&loc_result
, new_loc_descr (DW_OP_stack_value
, 0, 0));
16084 add_AT_loc (die
, DW_AT_location
, loc_result
);
16085 VEC_safe_push (rtx
, gc
, used_rtx_array
, rtl
);
16091 if (CONSTANT_P (XEXP (rtl
, 0)))
16092 return add_const_value_attribute (die
, XEXP (rtl
, 0));
16095 if (!const_ok_for_output (rtl
))
16098 if (dwarf_version
>= 4 || !dwarf_strict
)
16103 /* In cases where an inlined instance of an inline function is passed
16104 the address of an `auto' variable (which is local to the caller) we
16105 can get a situation where the DECL_RTL of the artificial local
16106 variable (for the inlining) which acts as a stand-in for the
16107 corresponding formal parameter (of the inline function) will look
16108 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not
16109 exactly a compile-time constant expression, but it isn't the address
16110 of the (artificial) local variable either. Rather, it represents the
16111 *value* which the artificial local variable always has during its
16112 lifetime. We currently have no way to represent such quasi-constant
16113 values in Dwarf, so for now we just punt and generate nothing. */
16121 if (GET_CODE (XEXP (rtl
, 0)) == CONST_STRING
16122 && MEM_READONLY_P (rtl
)
16123 && GET_MODE (rtl
) == BLKmode
)
16125 add_AT_string (die
, DW_AT_const_value
, XSTR (XEXP (rtl
, 0), 0));
16131 /* No other kinds of rtx should be possible here. */
16132 gcc_unreachable ();
16137 /* Determine whether the evaluation of EXPR references any variables
16138 or functions which aren't otherwise used (and therefore may not be
16141 reference_to_unused (tree
* tp
, int * walk_subtrees
,
16142 void * data ATTRIBUTE_UNUSED
)
16144 if (! EXPR_P (*tp
) && ! CONSTANT_CLASS_P (*tp
))
16145 *walk_subtrees
= 0;
16147 if (DECL_P (*tp
) && ! TREE_PUBLIC (*tp
) && ! TREE_USED (*tp
)
16148 && ! TREE_ASM_WRITTEN (*tp
))
16150 /* ??? The C++ FE emits debug information for using decls, so
16151 putting gcc_unreachable here falls over. See PR31899. For now
16152 be conservative. */
16153 else if (!cgraph_global_info_ready
16154 && (TREE_CODE (*tp
) == VAR_DECL
|| TREE_CODE (*tp
) == FUNCTION_DECL
))
16156 else if (TREE_CODE (*tp
) == VAR_DECL
)
16158 struct varpool_node
*node
= varpool_get_node (*tp
);
16159 if (!node
|| !node
->needed
)
16162 else if (TREE_CODE (*tp
) == FUNCTION_DECL
16163 && (!DECL_EXTERNAL (*tp
) || DECL_DECLARED_INLINE_P (*tp
)))
16165 /* The call graph machinery must have finished analyzing,
16166 optimizing and gimplifying the CU by now.
16167 So if *TP has no call graph node associated
16168 to it, it means *TP will not be emitted. */
16169 if (!cgraph_get_node (*tp
))
16172 else if (TREE_CODE (*tp
) == STRING_CST
&& !TREE_ASM_WRITTEN (*tp
))
16178 /* Generate an RTL constant from a decl initializer INIT with decl type TYPE,
16179 for use in a later add_const_value_attribute call. */
16182 rtl_for_decl_init (tree init
, tree type
)
16184 rtx rtl
= NULL_RTX
;
16186 /* If a variable is initialized with a string constant without embedded
16187 zeros, build CONST_STRING. */
16188 if (TREE_CODE (init
) == STRING_CST
&& TREE_CODE (type
) == ARRAY_TYPE
)
16190 tree enttype
= TREE_TYPE (type
);
16191 tree domain
= TYPE_DOMAIN (type
);
16192 enum machine_mode mode
= TYPE_MODE (enttype
);
16194 if (GET_MODE_CLASS (mode
) == MODE_INT
&& GET_MODE_SIZE (mode
) == 1
16196 && integer_zerop (TYPE_MIN_VALUE (domain
))
16197 && compare_tree_int (TYPE_MAX_VALUE (domain
),
16198 TREE_STRING_LENGTH (init
) - 1) == 0
16199 && ((size_t) TREE_STRING_LENGTH (init
)
16200 == strlen (TREE_STRING_POINTER (init
)) + 1))
16202 rtl
= gen_rtx_CONST_STRING (VOIDmode
,
16203 ggc_strdup (TREE_STRING_POINTER (init
)));
16204 rtl
= gen_rtx_MEM (BLKmode
, rtl
);
16205 MEM_READONLY_P (rtl
) = 1;
16208 /* Other aggregates, and complex values, could be represented using
16210 else if (AGGREGATE_TYPE_P (type
) || TREE_CODE (type
) == COMPLEX_TYPE
)
16212 /* Vectors only work if their mode is supported by the target.
16213 FIXME: generic vectors ought to work too. */
16214 else if (TREE_CODE (type
) == VECTOR_TYPE
&& TYPE_MODE (type
) == BLKmode
)
16216 /* If the initializer is something that we know will expand into an
16217 immediate RTL constant, expand it now. We must be careful not to
16218 reference variables which won't be output. */
16219 else if (initializer_constant_valid_p (init
, type
)
16220 && ! walk_tree (&init
, reference_to_unused
, NULL
, NULL
))
16222 /* Convert vector CONSTRUCTOR initializers to VECTOR_CST if
16224 if (TREE_CODE (type
) == VECTOR_TYPE
)
16225 switch (TREE_CODE (init
))
16230 if (TREE_CONSTANT (init
))
16232 VEC(constructor_elt
,gc
) *elts
= CONSTRUCTOR_ELTS (init
);
16233 bool constant_p
= true;
16235 unsigned HOST_WIDE_INT ix
;
16237 /* Even when ctor is constant, it might contain non-*_CST
16238 elements (e.g. { 1.0/0.0 - 1.0/0.0, 0.0 }) and those don't
16239 belong into VECTOR_CST nodes. */
16240 FOR_EACH_CONSTRUCTOR_VALUE (elts
, ix
, value
)
16241 if (!CONSTANT_CLASS_P (value
))
16243 constant_p
= false;
16249 init
= build_vector_from_ctor (type
, elts
);
16259 rtl
= expand_expr (init
, NULL_RTX
, VOIDmode
, EXPAND_INITIALIZER
);
16261 /* If expand_expr returns a MEM, it wasn't immediate. */
16262 gcc_assert (!rtl
|| !MEM_P (rtl
));
16268 /* Generate RTL for the variable DECL to represent its location. */
16271 rtl_for_decl_location (tree decl
)
16275 /* Here we have to decide where we are going to say the parameter "lives"
16276 (as far as the debugger is concerned). We only have a couple of
16277 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
16279 DECL_RTL normally indicates where the parameter lives during most of the
16280 activation of the function. If optimization is enabled however, this
16281 could be either NULL or else a pseudo-reg. Both of those cases indicate
16282 that the parameter doesn't really live anywhere (as far as the code
16283 generation parts of GCC are concerned) during most of the function's
16284 activation. That will happen (for example) if the parameter is never
16285 referenced within the function.
16287 We could just generate a location descriptor here for all non-NULL
16288 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
16289 a little nicer than that if we also consider DECL_INCOMING_RTL in cases
16290 where DECL_RTL is NULL or is a pseudo-reg.
16292 Note however that we can only get away with using DECL_INCOMING_RTL as
16293 a backup substitute for DECL_RTL in certain limited cases. In cases
16294 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
16295 we can be sure that the parameter was passed using the same type as it is
16296 declared to have within the function, and that its DECL_INCOMING_RTL
16297 points us to a place where a value of that type is passed.
16299 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
16300 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
16301 because in these cases DECL_INCOMING_RTL points us to a value of some
16302 type which is *different* from the type of the parameter itself. Thus,
16303 if we tried to use DECL_INCOMING_RTL to generate a location attribute in
16304 such cases, the debugger would end up (for example) trying to fetch a
16305 `float' from a place which actually contains the first part of a
16306 `double'. That would lead to really incorrect and confusing
16307 output at debug-time.
16309 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
16310 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There
16311 are a couple of exceptions however. On little-endian machines we can
16312 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
16313 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
16314 an integral type that is smaller than TREE_TYPE (decl). These cases arise
16315 when (on a little-endian machine) a non-prototyped function has a
16316 parameter declared to be of type `short' or `char'. In such cases,
16317 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
16318 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
16319 passed `int' value. If the debugger then uses that address to fetch
16320 a `short' or a `char' (on a little-endian machine) the result will be
16321 the correct data, so we allow for such exceptional cases below.
16323 Note that our goal here is to describe the place where the given formal
16324 parameter lives during most of the function's activation (i.e. between the
16325 end of the prologue and the start of the epilogue). We'll do that as best
16326 as we can. Note however that if the given formal parameter is modified
16327 sometime during the execution of the function, then a stack backtrace (at
16328 debug-time) will show the function as having been called with the *new*
16329 value rather than the value which was originally passed in. This happens
16330 rarely enough that it is not a major problem, but it *is* a problem, and
16331 I'd like to fix it.
16333 A future version of dwarf2out.c may generate two additional attributes for
16334 any given DW_TAG_formal_parameter DIE which will describe the "passed
16335 type" and the "passed location" for the given formal parameter in addition
16336 to the attributes we now generate to indicate the "declared type" and the
16337 "active location" for each parameter. This additional set of attributes
16338 could be used by debuggers for stack backtraces. Separately, note that
16339 sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also.
16340 This happens (for example) for inlined-instances of inline function formal
16341 parameters which are never referenced. This really shouldn't be
16342 happening. All PARM_DECL nodes should get valid non-NULL
16343 DECL_INCOMING_RTL values. FIXME. */
16345 /* Use DECL_RTL as the "location" unless we find something better. */
16346 rtl
= DECL_RTL_IF_SET (decl
);
16348 /* When generating abstract instances, ignore everything except
16349 constants, symbols living in memory, and symbols living in
16350 fixed registers. */
16351 if (! reload_completed
)
16354 && (CONSTANT_P (rtl
)
16356 && CONSTANT_P (XEXP (rtl
, 0)))
16358 && TREE_CODE (decl
) == VAR_DECL
16359 && TREE_STATIC (decl
))))
16361 rtl
= targetm
.delegitimize_address (rtl
);
16366 else if (TREE_CODE (decl
) == PARM_DECL
)
16368 if (rtl
== NULL_RTX
|| is_pseudo_reg (rtl
))
16370 tree declared_type
= TREE_TYPE (decl
);
16371 tree passed_type
= DECL_ARG_TYPE (decl
);
16372 enum machine_mode dmode
= TYPE_MODE (declared_type
);
16373 enum machine_mode pmode
= TYPE_MODE (passed_type
);
16375 /* This decl represents a formal parameter which was optimized out.
16376 Note that DECL_INCOMING_RTL may be NULL in here, but we handle
16377 all cases where (rtl == NULL_RTX) just below. */
16378 if (dmode
== pmode
)
16379 rtl
= DECL_INCOMING_RTL (decl
);
16380 else if (SCALAR_INT_MODE_P (dmode
)
16381 && GET_MODE_SIZE (dmode
) <= GET_MODE_SIZE (pmode
)
16382 && DECL_INCOMING_RTL (decl
))
16384 rtx inc
= DECL_INCOMING_RTL (decl
);
16387 else if (MEM_P (inc
))
16389 if (BYTES_BIG_ENDIAN
)
16390 rtl
= adjust_address_nv (inc
, dmode
,
16391 GET_MODE_SIZE (pmode
)
16392 - GET_MODE_SIZE (dmode
));
16399 /* If the parm was passed in registers, but lives on the stack, then
16400 make a big endian correction if the mode of the type of the
16401 parameter is not the same as the mode of the rtl. */
16402 /* ??? This is the same series of checks that are made in dbxout.c before
16403 we reach the big endian correction code there. It isn't clear if all
16404 of these checks are necessary here, but keeping them all is the safe
16406 else if (MEM_P (rtl
)
16407 && XEXP (rtl
, 0) != const0_rtx
16408 && ! CONSTANT_P (XEXP (rtl
, 0))
16409 /* Not passed in memory. */
16410 && !MEM_P (DECL_INCOMING_RTL (decl
))
16411 /* Not passed by invisible reference. */
16412 && (!REG_P (XEXP (rtl
, 0))
16413 || REGNO (XEXP (rtl
, 0)) == HARD_FRAME_POINTER_REGNUM
16414 || REGNO (XEXP (rtl
, 0)) == STACK_POINTER_REGNUM
16415 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
16416 || REGNO (XEXP (rtl
, 0)) == ARG_POINTER_REGNUM
16419 /* Big endian correction check. */
16420 && BYTES_BIG_ENDIAN
16421 && TYPE_MODE (TREE_TYPE (decl
)) != GET_MODE (rtl
)
16422 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl
)))
16425 int offset
= (UNITS_PER_WORD
16426 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl
))));
16428 rtl
= gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl
)),
16429 plus_constant (XEXP (rtl
, 0), offset
));
16432 else if (TREE_CODE (decl
) == VAR_DECL
16435 && GET_MODE (rtl
) != TYPE_MODE (TREE_TYPE (decl
))
16436 && BYTES_BIG_ENDIAN
)
16438 int rsize
= GET_MODE_SIZE (GET_MODE (rtl
));
16439 int dsize
= GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl
)));
16441 /* If a variable is declared "register" yet is smaller than
16442 a register, then if we store the variable to memory, it
16443 looks like we're storing a register-sized value, when in
16444 fact we are not. We need to adjust the offset of the
16445 storage location to reflect the actual value's bytes,
16446 else gdb will not be able to display it. */
16448 rtl
= gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl
)),
16449 plus_constant (XEXP (rtl
, 0), rsize
-dsize
));
16452 /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant,
16453 and will have been substituted directly into all expressions that use it.
16454 C does not have such a concept, but C++ and other languages do. */
16455 if (!rtl
&& TREE_CODE (decl
) == VAR_DECL
&& DECL_INITIAL (decl
))
16456 rtl
= rtl_for_decl_init (DECL_INITIAL (decl
), TREE_TYPE (decl
));
16459 rtl
= targetm
.delegitimize_address (rtl
);
16461 /* If we don't look past the constant pool, we risk emitting a
16462 reference to a constant pool entry that isn't referenced from
16463 code, and thus is not emitted. */
16465 rtl
= avoid_constant_pool_reference (rtl
);
16467 /* Try harder to get a rtl. If this symbol ends up not being emitted
16468 in the current CU, resolve_addr will remove the expression referencing
16470 if (rtl
== NULL_RTX
16471 && TREE_CODE (decl
) == VAR_DECL
16472 && !DECL_EXTERNAL (decl
)
16473 && TREE_STATIC (decl
)
16474 && DECL_NAME (decl
)
16475 && !DECL_HARD_REGISTER (decl
)
16476 && DECL_MODE (decl
) != VOIDmode
)
16478 rtl
= make_decl_rtl_for_debug (decl
);
16480 || GET_CODE (XEXP (rtl
, 0)) != SYMBOL_REF
16481 || SYMBOL_REF_DECL (XEXP (rtl
, 0)) != decl
)
16488 /* Check whether decl is a Fortran COMMON symbol. If not, NULL_TREE is
16489 returned. If so, the decl for the COMMON block is returned, and the
16490 value is the offset into the common block for the symbol. */
16493 fortran_common (tree decl
, HOST_WIDE_INT
*value
)
16495 tree val_expr
, cvar
;
16496 enum machine_mode mode
;
16497 HOST_WIDE_INT bitsize
, bitpos
;
16499 int volatilep
= 0, unsignedp
= 0;
16501 /* If the decl isn't a VAR_DECL, or if it isn't static, or if
16502 it does not have a value (the offset into the common area), or if it
16503 is thread local (as opposed to global) then it isn't common, and shouldn't
16504 be handled as such. */
16505 if (TREE_CODE (decl
) != VAR_DECL
16506 || !TREE_STATIC (decl
)
16507 || !DECL_HAS_VALUE_EXPR_P (decl
)
16511 val_expr
= DECL_VALUE_EXPR (decl
);
16512 if (TREE_CODE (val_expr
) != COMPONENT_REF
)
16515 cvar
= get_inner_reference (val_expr
, &bitsize
, &bitpos
, &offset
,
16516 &mode
, &unsignedp
, &volatilep
, true);
16518 if (cvar
== NULL_TREE
16519 || TREE_CODE (cvar
) != VAR_DECL
16520 || DECL_ARTIFICIAL (cvar
)
16521 || !TREE_PUBLIC (cvar
))
16525 if (offset
!= NULL
)
16527 if (!host_integerp (offset
, 0))
16529 *value
= tree_low_cst (offset
, 0);
16532 *value
+= bitpos
/ BITS_PER_UNIT
;
16537 /* Generate *either* a DW_AT_location attribute or else a DW_AT_const_value
16538 data attribute for a variable or a parameter. We generate the
16539 DW_AT_const_value attribute only in those cases where the given variable
16540 or parameter does not have a true "location" either in memory or in a
16541 register. This can happen (for example) when a constant is passed as an
16542 actual argument in a call to an inline function. (It's possible that
16543 these things can crop up in other ways also.) Note that one type of
16544 constant value which can be passed into an inlined function is a constant
16545 pointer. This can happen for example if an actual argument in an inlined
16546 function call evaluates to a compile-time constant address. */
16549 add_location_or_const_value_attribute (dw_die_ref die
, tree decl
,
16550 enum dwarf_attribute attr
)
16553 dw_loc_list_ref list
;
16554 var_loc_list
*loc_list
;
16556 if (TREE_CODE (decl
) == ERROR_MARK
)
16559 gcc_assert (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == PARM_DECL
16560 || TREE_CODE (decl
) == RESULT_DECL
);
16562 /* Try to get some constant RTL for this decl, and use that as the value of
16565 rtl
= rtl_for_decl_location (decl
);
16566 if (rtl
&& (CONSTANT_P (rtl
) || GET_CODE (rtl
) == CONST_STRING
)
16567 && add_const_value_attribute (die
, rtl
))
16570 /* See if we have single element location list that is equivalent to
16571 a constant value. That way we are better to use add_const_value_attribute
16572 rather than expanding constant value equivalent. */
16573 loc_list
= lookup_decl_loc (decl
);
16576 && loc_list
->first
->next
== NULL
16577 && NOTE_P (loc_list
->first
->loc
)
16578 && NOTE_VAR_LOCATION (loc_list
->first
->loc
)
16579 && NOTE_VAR_LOCATION_LOC (loc_list
->first
->loc
))
16581 struct var_loc_node
*node
;
16583 node
= loc_list
->first
;
16584 rtl
= NOTE_VAR_LOCATION_LOC (node
->loc
);
16585 if (GET_CODE (rtl
) == EXPR_LIST
)
16586 rtl
= XEXP (rtl
, 0);
16587 if ((CONSTANT_P (rtl
) || GET_CODE (rtl
) == CONST_STRING
)
16588 && add_const_value_attribute (die
, rtl
))
16591 list
= loc_list_from_tree (decl
, decl_by_reference_p (decl
) ? 0 : 2);
16594 add_AT_location_description (die
, attr
, list
);
16597 /* None of that worked, so it must not really have a location;
16598 try adding a constant value attribute from the DECL_INITIAL. */
16599 return tree_add_const_value_attribute_for_decl (die
, decl
);
16602 /* Add VARIABLE and DIE into deferred locations list. */
16605 defer_location (tree variable
, dw_die_ref die
)
16607 deferred_locations entry
;
16608 entry
.variable
= variable
;
16610 VEC_safe_push (deferred_locations
, gc
, deferred_locations_list
, &entry
);
16613 /* Helper function for tree_add_const_value_attribute. Natively encode
16614 initializer INIT into an array. Return true if successful. */
16617 native_encode_initializer (tree init
, unsigned char *array
, int size
)
16621 if (init
== NULL_TREE
)
16625 switch (TREE_CODE (init
))
16628 type
= TREE_TYPE (init
);
16629 if (TREE_CODE (type
) == ARRAY_TYPE
)
16631 tree enttype
= TREE_TYPE (type
);
16632 enum machine_mode mode
= TYPE_MODE (enttype
);
16634 if (GET_MODE_CLASS (mode
) != MODE_INT
|| GET_MODE_SIZE (mode
) != 1)
16636 if (int_size_in_bytes (type
) != size
)
16638 if (size
> TREE_STRING_LENGTH (init
))
16640 memcpy (array
, TREE_STRING_POINTER (init
),
16641 TREE_STRING_LENGTH (init
));
16642 memset (array
+ TREE_STRING_LENGTH (init
),
16643 '\0', size
- TREE_STRING_LENGTH (init
));
16646 memcpy (array
, TREE_STRING_POINTER (init
), size
);
16651 type
= TREE_TYPE (init
);
16652 if (int_size_in_bytes (type
) != size
)
16654 if (TREE_CODE (type
) == ARRAY_TYPE
)
16656 HOST_WIDE_INT min_index
;
16657 unsigned HOST_WIDE_INT cnt
;
16658 int curpos
= 0, fieldsize
;
16659 constructor_elt
*ce
;
16661 if (TYPE_DOMAIN (type
) == NULL_TREE
16662 || !host_integerp (TYPE_MIN_VALUE (TYPE_DOMAIN (type
)), 0))
16665 fieldsize
= int_size_in_bytes (TREE_TYPE (type
));
16666 if (fieldsize
<= 0)
16669 min_index
= tree_low_cst (TYPE_MIN_VALUE (TYPE_DOMAIN (type
)), 0);
16670 memset (array
, '\0', size
);
16672 VEC_iterate (constructor_elt
, CONSTRUCTOR_ELTS (init
), cnt
, ce
);
16675 tree val
= ce
->value
;
16676 tree index
= ce
->index
;
16678 if (index
&& TREE_CODE (index
) == RANGE_EXPR
)
16679 pos
= (tree_low_cst (TREE_OPERAND (index
, 0), 0) - min_index
)
16682 pos
= (tree_low_cst (index
, 0) - min_index
) * fieldsize
;
16687 if (!native_encode_initializer (val
, array
+ pos
, fieldsize
))
16690 curpos
= pos
+ fieldsize
;
16691 if (index
&& TREE_CODE (index
) == RANGE_EXPR
)
16693 int count
= tree_low_cst (TREE_OPERAND (index
, 1), 0)
16694 - tree_low_cst (TREE_OPERAND (index
, 0), 0);
16698 memcpy (array
+ curpos
, array
+ pos
, fieldsize
);
16699 curpos
+= fieldsize
;
16702 gcc_assert (curpos
<= size
);
16706 else if (TREE_CODE (type
) == RECORD_TYPE
16707 || TREE_CODE (type
) == UNION_TYPE
)
16709 tree field
= NULL_TREE
;
16710 unsigned HOST_WIDE_INT cnt
;
16711 constructor_elt
*ce
;
16713 if (int_size_in_bytes (type
) != size
)
16716 if (TREE_CODE (type
) == RECORD_TYPE
)
16717 field
= TYPE_FIELDS (type
);
16720 VEC_iterate (constructor_elt
, CONSTRUCTOR_ELTS (init
), cnt
, ce
);
16721 cnt
++, field
= field
? TREE_CHAIN (field
) : 0)
16723 tree val
= ce
->value
;
16724 int pos
, fieldsize
;
16726 if (ce
->index
!= 0)
16732 if (field
== NULL_TREE
|| DECL_BIT_FIELD (field
))
16735 if (TREE_CODE (TREE_TYPE (field
)) == ARRAY_TYPE
16736 && TYPE_DOMAIN (TREE_TYPE (field
))
16737 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (field
))))
16739 else if (DECL_SIZE_UNIT (field
) == NULL_TREE
16740 || !host_integerp (DECL_SIZE_UNIT (field
), 0))
16742 fieldsize
= tree_low_cst (DECL_SIZE_UNIT (field
), 0);
16743 pos
= int_byte_position (field
);
16744 gcc_assert (pos
+ fieldsize
<= size
);
16746 && !native_encode_initializer (val
, array
+ pos
, fieldsize
))
16752 case VIEW_CONVERT_EXPR
:
16753 case NON_LVALUE_EXPR
:
16754 return native_encode_initializer (TREE_OPERAND (init
, 0), array
, size
);
16756 return native_encode_expr (init
, array
, size
) == size
;
16760 /* Attach a DW_AT_const_value attribute to DIE. The value of the
16761 attribute is the const value T. */
16764 tree_add_const_value_attribute (dw_die_ref die
, tree t
)
16767 tree type
= TREE_TYPE (t
);
16770 if (!t
|| !TREE_TYPE (t
) || TREE_TYPE (t
) == error_mark_node
)
16774 gcc_assert (!DECL_P (init
));
16776 rtl
= rtl_for_decl_init (init
, type
);
16778 return add_const_value_attribute (die
, rtl
);
16779 /* If the host and target are sane, try harder. */
16780 else if (CHAR_BIT
== 8 && BITS_PER_UNIT
== 8
16781 && initializer_constant_valid_p (init
, type
))
16783 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (init
));
16784 if (size
> 0 && (int) size
== size
)
16786 unsigned char *array
= (unsigned char *)
16787 ggc_alloc_cleared_atomic (size
);
16789 if (native_encode_initializer (init
, array
, size
))
16791 add_AT_vec (die
, DW_AT_const_value
, size
, 1, array
);
16799 /* Attach a DW_AT_const_value attribute to VAR_DIE. The value of the
16800 attribute is the const value of T, where T is an integral constant
16801 variable with static storage duration
16802 (so it can't be a PARM_DECL or a RESULT_DECL). */
16805 tree_add_const_value_attribute_for_decl (dw_die_ref var_die
, tree decl
)
16809 || (TREE_CODE (decl
) != VAR_DECL
16810 && TREE_CODE (decl
) != CONST_DECL
))
16813 if (TREE_READONLY (decl
)
16814 && ! TREE_THIS_VOLATILE (decl
)
16815 && DECL_INITIAL (decl
))
16820 /* Don't add DW_AT_const_value if abstract origin already has one. */
16821 if (get_AT (var_die
, DW_AT_const_value
))
16824 return tree_add_const_value_attribute (var_die
, DECL_INITIAL (decl
));
16827 /* Convert the CFI instructions for the current function into a
16828 location list. This is used for DW_AT_frame_base when we targeting
16829 a dwarf2 consumer that does not support the dwarf3
16830 DW_OP_call_frame_cfa. OFFSET is a constant to be added to all CFA
16833 static dw_loc_list_ref
16834 convert_cfa_to_fb_loc_list (HOST_WIDE_INT offset
)
16837 dw_loc_list_ref list
, *list_tail
;
16839 dw_cfa_location last_cfa
, next_cfa
;
16840 const char *start_label
, *last_label
, *section
;
16841 dw_cfa_location remember
;
16843 fde
= current_fde ();
16844 gcc_assert (fde
!= NULL
);
16846 section
= secname_for_decl (current_function_decl
);
16850 memset (&next_cfa
, 0, sizeof (next_cfa
));
16851 next_cfa
.reg
= INVALID_REGNUM
;
16852 remember
= next_cfa
;
16854 start_label
= fde
->dw_fde_begin
;
16856 /* ??? Bald assumption that the CIE opcode list does not contain
16857 advance opcodes. */
16858 for (cfi
= cie_cfi_head
; cfi
; cfi
= cfi
->dw_cfi_next
)
16859 lookup_cfa_1 (cfi
, &next_cfa
, &remember
);
16861 last_cfa
= next_cfa
;
16862 last_label
= start_label
;
16864 for (cfi
= fde
->dw_fde_cfi
; cfi
; cfi
= cfi
->dw_cfi_next
)
16865 switch (cfi
->dw_cfi_opc
)
16867 case DW_CFA_set_loc
:
16868 case DW_CFA_advance_loc1
:
16869 case DW_CFA_advance_loc2
:
16870 case DW_CFA_advance_loc4
:
16871 if (!cfa_equal_p (&last_cfa
, &next_cfa
))
16873 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
16874 start_label
, last_label
, section
);
16876 list_tail
= &(*list_tail
)->dw_loc_next
;
16877 last_cfa
= next_cfa
;
16878 start_label
= last_label
;
16880 last_label
= cfi
->dw_cfi_oprnd1
.dw_cfi_addr
;
16883 case DW_CFA_advance_loc
:
16884 /* The encoding is complex enough that we should never emit this. */
16885 gcc_unreachable ();
16888 lookup_cfa_1 (cfi
, &next_cfa
, &remember
);
16892 if (!cfa_equal_p (&last_cfa
, &next_cfa
))
16894 *list_tail
= new_loc_list (build_cfa_loc (&last_cfa
, offset
),
16895 start_label
, last_label
, section
);
16896 list_tail
= &(*list_tail
)->dw_loc_next
;
16897 start_label
= last_label
;
16900 *list_tail
= new_loc_list (build_cfa_loc (&next_cfa
, offset
),
16901 start_label
, fde
->dw_fde_end
, section
);
16903 if (list
&& list
->dw_loc_next
)
16909 /* Compute a displacement from the "steady-state frame pointer" to the
16910 frame base (often the same as the CFA), and store it in
16911 frame_pointer_fb_offset. OFFSET is added to the displacement
16912 before the latter is negated. */
16915 compute_frame_pointer_to_fb_displacement (HOST_WIDE_INT offset
)
16919 #ifdef FRAME_POINTER_CFA_OFFSET
16920 reg
= frame_pointer_rtx
;
16921 offset
+= FRAME_POINTER_CFA_OFFSET (current_function_decl
);
16923 reg
= arg_pointer_rtx
;
16924 offset
+= ARG_POINTER_CFA_OFFSET (current_function_decl
);
16927 elim
= eliminate_regs (reg
, VOIDmode
, NULL_RTX
);
16928 if (GET_CODE (elim
) == PLUS
)
16930 offset
+= INTVAL (XEXP (elim
, 1));
16931 elim
= XEXP (elim
, 0);
16934 gcc_assert ((SUPPORTS_STACK_ALIGNMENT
16935 && (elim
== hard_frame_pointer_rtx
16936 || elim
== stack_pointer_rtx
))
16937 || elim
== (frame_pointer_needed
16938 ? hard_frame_pointer_rtx
16939 : stack_pointer_rtx
));
16941 frame_pointer_fb_offset
= -offset
;
16944 /* Generate a DW_AT_name attribute given some string value to be included as
16945 the value of the attribute. */
16948 add_name_attribute (dw_die_ref die
, const char *name_string
)
16950 if (name_string
!= NULL
&& *name_string
!= 0)
16952 if (demangle_name_func
)
16953 name_string
= (*demangle_name_func
) (name_string
);
16955 add_AT_string (die
, DW_AT_name
, name_string
);
16959 /* Generate a DW_AT_comp_dir attribute for DIE. */
16962 add_comp_dir_attribute (dw_die_ref die
)
16964 const char *wd
= get_src_pwd ();
16970 if (DWARF2_DIR_SHOULD_END_WITH_SEPARATOR
)
16974 wdlen
= strlen (wd
);
16975 wd1
= (char *) ggc_alloc_atomic (wdlen
+ 2);
16977 wd1
[wdlen
] = DIR_SEPARATOR
;
16978 wd1
[wdlen
+ 1] = 0;
16982 add_AT_string (die
, DW_AT_comp_dir
, remap_debug_filename (wd
));
16985 /* Return the default for DW_AT_lower_bound, or -1 if there is not any
16989 lower_bound_default (void)
16991 switch (get_AT_unsigned (comp_unit_die
, DW_AT_language
))
16996 case DW_LANG_C_plus_plus
:
16998 case DW_LANG_ObjC_plus_plus
:
17001 case DW_LANG_Fortran77
:
17002 case DW_LANG_Fortran90
:
17003 case DW_LANG_Fortran95
:
17007 case DW_LANG_Python
:
17008 return dwarf_version
>= 4 ? 0 : -1;
17009 case DW_LANG_Ada95
:
17010 case DW_LANG_Ada83
:
17011 case DW_LANG_Cobol74
:
17012 case DW_LANG_Cobol85
:
17013 case DW_LANG_Pascal83
:
17014 case DW_LANG_Modula2
:
17016 return dwarf_version
>= 4 ? 1 : -1;
17022 /* Given a tree node describing an array bound (either lower or upper) output
17023 a representation for that bound. */
17026 add_bound_info (dw_die_ref subrange_die
, enum dwarf_attribute bound_attr
, tree bound
)
17028 switch (TREE_CODE (bound
))
17033 /* All fixed-bounds are represented by INTEGER_CST nodes. */
17036 unsigned int prec
= simple_type_size_in_bits (TREE_TYPE (bound
));
17039 /* Use the default if possible. */
17040 if (bound_attr
== DW_AT_lower_bound
17041 && host_integerp (bound
, 0)
17042 && (dflt
= lower_bound_default ()) != -1
17043 && tree_low_cst (bound
, 0) == dflt
)
17046 /* Otherwise represent the bound as an unsigned value with the
17047 precision of its type. The precision and signedness of the
17048 type will be necessary to re-interpret it unambiguously. */
17049 else if (prec
< HOST_BITS_PER_WIDE_INT
)
17051 unsigned HOST_WIDE_INT mask
17052 = ((unsigned HOST_WIDE_INT
) 1 << prec
) - 1;
17053 add_AT_unsigned (subrange_die
, bound_attr
,
17054 TREE_INT_CST_LOW (bound
) & mask
);
17056 else if (prec
== HOST_BITS_PER_WIDE_INT
17057 || TREE_INT_CST_HIGH (bound
) == 0)
17058 add_AT_unsigned (subrange_die
, bound_attr
,
17059 TREE_INT_CST_LOW (bound
));
17061 add_AT_double (subrange_die
, bound_attr
, TREE_INT_CST_HIGH (bound
),
17062 TREE_INT_CST_LOW (bound
));
17067 case VIEW_CONVERT_EXPR
:
17068 add_bound_info (subrange_die
, bound_attr
, TREE_OPERAND (bound
, 0));
17078 dw_die_ref decl_die
= lookup_decl_die (bound
);
17080 /* ??? Can this happen, or should the variable have been bound
17081 first? Probably it can, since I imagine that we try to create
17082 the types of parameters in the order in which they exist in
17083 the list, and won't have created a forward reference to a
17084 later parameter. */
17085 if (decl_die
!= NULL
)
17087 add_AT_die_ref (subrange_die
, bound_attr
, decl_die
);
17095 /* Otherwise try to create a stack operation procedure to
17096 evaluate the value of the array bound. */
17098 dw_die_ref ctx
, decl_die
;
17099 dw_loc_list_ref list
;
17101 list
= loc_list_from_tree (bound
, 2);
17102 if (list
== NULL
|| single_element_loc_list_p (list
))
17104 /* If DW_AT_*bound is not a reference nor constant, it is
17105 a DWARF expression rather than location description.
17106 For that loc_list_from_tree (bound, 0) is needed.
17107 If that fails to give a single element list,
17108 fall back to outputting this as a reference anyway. */
17109 dw_loc_list_ref list2
= loc_list_from_tree (bound
, 0);
17110 if (list2
&& single_element_loc_list_p (list2
))
17112 add_AT_loc (subrange_die
, bound_attr
, list2
->expr
);
17119 if (current_function_decl
== 0)
17120 ctx
= comp_unit_die
;
17122 ctx
= lookup_decl_die (current_function_decl
);
17124 decl_die
= new_die (DW_TAG_variable
, ctx
, bound
);
17125 add_AT_flag (decl_die
, DW_AT_artificial
, 1);
17126 add_type_attribute (decl_die
, TREE_TYPE (bound
), 1, 0, ctx
);
17127 add_AT_location_description (decl_die
, DW_AT_location
, list
);
17128 add_AT_die_ref (subrange_die
, bound_attr
, decl_die
);
17134 /* Add subscript info to TYPE_DIE, describing an array TYPE, collapsing
17135 possibly nested array subscripts in a flat sequence if COLLAPSE_P is true.
17136 Note that the block of subscript information for an array type also
17137 includes information about the element type of the given array type. */
17140 add_subscript_info (dw_die_ref type_die
, tree type
, bool collapse_p
)
17142 unsigned dimension_number
;
17144 dw_die_ref subrange_die
;
17146 for (dimension_number
= 0;
17147 TREE_CODE (type
) == ARRAY_TYPE
&& (dimension_number
== 0 || collapse_p
);
17148 type
= TREE_TYPE (type
), dimension_number
++)
17150 tree domain
= TYPE_DOMAIN (type
);
17152 if (TYPE_STRING_FLAG (type
) && is_fortran () && dimension_number
> 0)
17155 /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
17156 and (in GNU C only) variable bounds. Handle all three forms
17158 subrange_die
= new_die (DW_TAG_subrange_type
, type_die
, NULL
);
17161 /* We have an array type with specified bounds. */
17162 lower
= TYPE_MIN_VALUE (domain
);
17163 upper
= TYPE_MAX_VALUE (domain
);
17165 /* Define the index type. */
17166 if (TREE_TYPE (domain
))
17168 /* ??? This is probably an Ada unnamed subrange type. Ignore the
17169 TREE_TYPE field. We can't emit debug info for this
17170 because it is an unnamed integral type. */
17171 if (TREE_CODE (domain
) == INTEGER_TYPE
17172 && TYPE_NAME (domain
) == NULL_TREE
17173 && TREE_CODE (TREE_TYPE (domain
)) == INTEGER_TYPE
17174 && TYPE_NAME (TREE_TYPE (domain
)) == NULL_TREE
)
17177 add_type_attribute (subrange_die
, TREE_TYPE (domain
), 0, 0,
17181 /* ??? If upper is NULL, the array has unspecified length,
17182 but it does have a lower bound. This happens with Fortran
17184 Since the debugger is definitely going to need to know N
17185 to produce useful results, go ahead and output the lower
17186 bound solo, and hope the debugger can cope. */
17188 add_bound_info (subrange_die
, DW_AT_lower_bound
, lower
);
17190 add_bound_info (subrange_die
, DW_AT_upper_bound
, upper
);
17193 /* Otherwise we have an array type with an unspecified length. The
17194 DWARF-2 spec does not say how to handle this; let's just leave out the
17200 add_byte_size_attribute (dw_die_ref die
, tree tree_node
)
17204 switch (TREE_CODE (tree_node
))
17209 case ENUMERAL_TYPE
:
17212 case QUAL_UNION_TYPE
:
17213 size
= int_size_in_bytes (tree_node
);
17216 /* For a data member of a struct or union, the DW_AT_byte_size is
17217 generally given as the number of bytes normally allocated for an
17218 object of the *declared* type of the member itself. This is true
17219 even for bit-fields. */
17220 size
= simple_type_size_in_bits (field_type (tree_node
)) / BITS_PER_UNIT
;
17223 gcc_unreachable ();
17226 /* Note that `size' might be -1 when we get to this point. If it is, that
17227 indicates that the byte size of the entity in question is variable. We
17228 have no good way of expressing this fact in Dwarf at the present time,
17229 so just let the -1 pass on through. */
17230 add_AT_unsigned (die
, DW_AT_byte_size
, size
);
17233 /* For a FIELD_DECL node which represents a bit-field, output an attribute
17234 which specifies the distance in bits from the highest order bit of the
17235 "containing object" for the bit-field to the highest order bit of the
17238 For any given bit-field, the "containing object" is a hypothetical object
17239 (of some integral or enum type) within which the given bit-field lives. The
17240 type of this hypothetical "containing object" is always the same as the
17241 declared type of the individual bit-field itself. The determination of the
17242 exact location of the "containing object" for a bit-field is rather
17243 complicated. It's handled by the `field_byte_offset' function (above).
17245 Note that it is the size (in bytes) of the hypothetical "containing object"
17246 which will be given in the DW_AT_byte_size attribute for this bit-field.
17247 (See `byte_size_attribute' above). */
17250 add_bit_offset_attribute (dw_die_ref die
, tree decl
)
17252 HOST_WIDE_INT object_offset_in_bytes
= field_byte_offset (decl
);
17253 tree type
= DECL_BIT_FIELD_TYPE (decl
);
17254 HOST_WIDE_INT bitpos_int
;
17255 HOST_WIDE_INT highest_order_object_bit_offset
;
17256 HOST_WIDE_INT highest_order_field_bit_offset
;
17257 HOST_WIDE_INT
unsigned bit_offset
;
17259 /* Must be a field and a bit field. */
17260 gcc_assert (type
&& TREE_CODE (decl
) == FIELD_DECL
);
17262 /* We can't yet handle bit-fields whose offsets are variable, so if we
17263 encounter such things, just return without generating any attribute
17264 whatsoever. Likewise for variable or too large size. */
17265 if (! host_integerp (bit_position (decl
), 0)
17266 || ! host_integerp (DECL_SIZE (decl
), 1))
17269 bitpos_int
= int_bit_position (decl
);
17271 /* Note that the bit offset is always the distance (in bits) from the
17272 highest-order bit of the "containing object" to the highest-order bit of
17273 the bit-field itself. Since the "high-order end" of any object or field
17274 is different on big-endian and little-endian machines, the computation
17275 below must take account of these differences. */
17276 highest_order_object_bit_offset
= object_offset_in_bytes
* BITS_PER_UNIT
;
17277 highest_order_field_bit_offset
= bitpos_int
;
17279 if (! BYTES_BIG_ENDIAN
)
17281 highest_order_field_bit_offset
+= tree_low_cst (DECL_SIZE (decl
), 0);
17282 highest_order_object_bit_offset
+= simple_type_size_in_bits (type
);
17286 = (! BYTES_BIG_ENDIAN
17287 ? highest_order_object_bit_offset
- highest_order_field_bit_offset
17288 : highest_order_field_bit_offset
- highest_order_object_bit_offset
);
17290 add_AT_unsigned (die
, DW_AT_bit_offset
, bit_offset
);
17293 /* For a FIELD_DECL node which represents a bit field, output an attribute
17294 which specifies the length in bits of the given field. */
17297 add_bit_size_attribute (dw_die_ref die
, tree decl
)
17299 /* Must be a field and a bit field. */
17300 gcc_assert (TREE_CODE (decl
) == FIELD_DECL
17301 && DECL_BIT_FIELD_TYPE (decl
));
17303 if (host_integerp (DECL_SIZE (decl
), 1))
17304 add_AT_unsigned (die
, DW_AT_bit_size
, tree_low_cst (DECL_SIZE (decl
), 1));
17307 /* If the compiled language is ANSI C, then add a 'prototyped'
17308 attribute, if arg types are given for the parameters of a function. */
17311 add_prototyped_attribute (dw_die_ref die
, tree func_type
)
17313 if (get_AT_unsigned (comp_unit_die
, DW_AT_language
) == DW_LANG_C89
17314 && TYPE_ARG_TYPES (func_type
) != NULL
)
17315 add_AT_flag (die
, DW_AT_prototyped
, 1);
17318 /* Add an 'abstract_origin' attribute below a given DIE. The DIE is found
17319 by looking in either the type declaration or object declaration
17322 static inline dw_die_ref
17323 add_abstract_origin_attribute (dw_die_ref die
, tree origin
)
17325 dw_die_ref origin_die
= NULL
;
17327 if (TREE_CODE (origin
) != FUNCTION_DECL
)
17329 /* We may have gotten separated from the block for the inlined
17330 function, if we're in an exception handler or some such; make
17331 sure that the abstract function has been written out.
17333 Doing this for nested functions is wrong, however; functions are
17334 distinct units, and our context might not even be inline. */
17338 fn
= TYPE_STUB_DECL (fn
);
17340 fn
= decl_function_context (fn
);
17342 dwarf2out_abstract_function (fn
);
17345 if (DECL_P (origin
))
17346 origin_die
= lookup_decl_die (origin
);
17347 else if (TYPE_P (origin
))
17348 origin_die
= lookup_type_die (origin
);
17350 /* XXX: Functions that are never lowered don't always have correct block
17351 trees (in the case of java, they simply have no block tree, in some other
17352 languages). For these functions, there is nothing we can really do to
17353 output correct debug info for inlined functions in all cases. Rather
17354 than die, we'll just produce deficient debug info now, in that we will
17355 have variables without a proper abstract origin. In the future, when all
17356 functions are lowered, we should re-add a gcc_assert (origin_die)
17360 add_AT_die_ref (die
, DW_AT_abstract_origin
, origin_die
);
17364 /* We do not currently support the pure_virtual attribute. */
17367 add_pure_or_virtual_attribute (dw_die_ref die
, tree func_decl
)
17369 if (DECL_VINDEX (func_decl
))
17371 add_AT_unsigned (die
, DW_AT_virtuality
, DW_VIRTUALITY_virtual
);
17373 if (host_integerp (DECL_VINDEX (func_decl
), 0))
17374 add_AT_loc (die
, DW_AT_vtable_elem_location
,
17375 new_loc_descr (DW_OP_constu
,
17376 tree_low_cst (DECL_VINDEX (func_decl
), 0),
17379 /* GNU extension: Record what type this method came from originally. */
17380 if (debug_info_level
> DINFO_LEVEL_TERSE
17381 && DECL_CONTEXT (func_decl
))
17382 add_AT_die_ref (die
, DW_AT_containing_type
,
17383 lookup_type_die (DECL_CONTEXT (func_decl
)));
17387 /* Add source coordinate attributes for the given decl. */
17390 add_src_coords_attributes (dw_die_ref die
, tree decl
)
17392 expanded_location s
= expand_location (DECL_SOURCE_LOCATION (decl
));
17394 add_AT_file (die
, DW_AT_decl_file
, lookup_filename (s
.file
));
17395 add_AT_unsigned (die
, DW_AT_decl_line
, s
.line
);
17398 /* Add DW_AT_{,MIPS_}linkage_name attribute for the given decl. */
17401 add_linkage_name (dw_die_ref die
, tree decl
)
17403 if ((TREE_CODE (decl
) == FUNCTION_DECL
|| TREE_CODE (decl
) == VAR_DECL
)
17404 && TREE_PUBLIC (decl
)
17405 && !DECL_ABSTRACT (decl
)
17406 && !(TREE_CODE (decl
) == VAR_DECL
&& DECL_REGISTER (decl
))
17407 && die
->die_tag
!= DW_TAG_member
)
17409 /* Defer until we have an assembler name set. */
17410 if (!DECL_ASSEMBLER_NAME_SET_P (decl
))
17412 limbo_die_node
*asm_name
;
17414 asm_name
= ggc_alloc_cleared_limbo_die_node ();
17415 asm_name
->die
= die
;
17416 asm_name
->created_for
= decl
;
17417 asm_name
->next
= deferred_asm_name
;
17418 deferred_asm_name
= asm_name
;
17420 else if (DECL_ASSEMBLER_NAME (decl
) != DECL_NAME (decl
))
17421 add_AT_string (die
, AT_linkage_name
,
17422 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)));
17426 /* Add a DW_AT_name attribute and source coordinate attribute for the
17427 given decl, but only if it actually has a name. */
17430 add_name_and_src_coords_attributes (dw_die_ref die
, tree decl
)
17434 decl_name
= DECL_NAME (decl
);
17435 if (decl_name
!= NULL
&& IDENTIFIER_POINTER (decl_name
) != NULL
)
17437 const char *name
= dwarf2_name (decl
, 0);
17439 add_name_attribute (die
, name
);
17440 if (! DECL_ARTIFICIAL (decl
))
17441 add_src_coords_attributes (die
, decl
);
17443 add_linkage_name (die
, decl
);
17446 #ifdef VMS_DEBUGGING_INFO
17447 /* Get the function's name, as described by its RTL. This may be different
17448 from the DECL_NAME name used in the source file. */
17449 if (TREE_CODE (decl
) == FUNCTION_DECL
&& TREE_ASM_WRITTEN (decl
))
17451 add_AT_addr (die
, DW_AT_VMS_rtnbeg_pd_address
,
17452 XEXP (DECL_RTL (decl
), 0));
17453 VEC_safe_push (rtx
, gc
, used_rtx_array
, XEXP (DECL_RTL (decl
), 0));
17458 #ifdef VMS_DEBUGGING_INFO
17460 /* Output the debug main pointer die for VMS */
17463 dwarf2out_vms_debug_main_pointer (void)
17465 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
17468 /* Allocate the VMS debug main subprogram die. */
17469 die
= ggc_alloc_cleared_die_node ();
17470 die
->die_tag
= DW_TAG_subprogram
;
17471 add_name_attribute (die
, VMS_DEBUG_MAIN_POINTER
);
17472 ASM_GENERATE_INTERNAL_LABEL (label
, PROLOGUE_END_LABEL
,
17473 current_function_funcdef_no
);
17474 add_AT_lbl_id (die
, DW_AT_entry_pc
, label
);
17476 /* Make it the first child of comp_unit_die. */
17477 die
->die_parent
= comp_unit_die
;
17478 if (comp_unit_die
->die_child
)
17480 die
->die_sib
= comp_unit_die
->die_child
->die_sib
;
17481 comp_unit_die
->die_child
->die_sib
= die
;
17485 die
->die_sib
= die
;
17486 comp_unit_die
->die_child
= die
;
17491 /* Push a new declaration scope. */
17494 push_decl_scope (tree scope
)
17496 VEC_safe_push (tree
, gc
, decl_scope_table
, scope
);
17499 /* Pop a declaration scope. */
17502 pop_decl_scope (void)
17504 VEC_pop (tree
, decl_scope_table
);
17507 /* Return the DIE for the scope that immediately contains this type.
17508 Non-named types get global scope. Named types nested in other
17509 types get their containing scope if it's open, or global scope
17510 otherwise. All other types (i.e. function-local named types) get
17511 the current active scope. */
17514 scope_die_for (tree t
, dw_die_ref context_die
)
17516 dw_die_ref scope_die
= NULL
;
17517 tree containing_scope
;
17520 /* Non-types always go in the current scope. */
17521 gcc_assert (TYPE_P (t
));
17523 containing_scope
= TYPE_CONTEXT (t
);
17525 /* Use the containing namespace if it was passed in (for a declaration). */
17526 if (containing_scope
&& TREE_CODE (containing_scope
) == NAMESPACE_DECL
)
17528 if (context_die
== lookup_decl_die (containing_scope
))
17531 containing_scope
= NULL_TREE
;
17534 /* Ignore function type "scopes" from the C frontend. They mean that
17535 a tagged type is local to a parmlist of a function declarator, but
17536 that isn't useful to DWARF. */
17537 if (containing_scope
&& TREE_CODE (containing_scope
) == FUNCTION_TYPE
)
17538 containing_scope
= NULL_TREE
;
17540 if (containing_scope
== NULL_TREE
)
17541 scope_die
= comp_unit_die
;
17542 else if (TYPE_P (containing_scope
))
17544 /* For types, we can just look up the appropriate DIE. But
17545 first we check to see if we're in the middle of emitting it
17546 so we know where the new DIE should go. */
17547 for (i
= VEC_length (tree
, decl_scope_table
) - 1; i
>= 0; --i
)
17548 if (VEC_index (tree
, decl_scope_table
, i
) == containing_scope
)
17553 gcc_assert (debug_info_level
<= DINFO_LEVEL_TERSE
17554 || TREE_ASM_WRITTEN (containing_scope
));
17556 /* If none of the current dies are suitable, we get file scope. */
17557 scope_die
= comp_unit_die
;
17560 scope_die
= lookup_type_die (containing_scope
);
17563 scope_die
= context_die
;
17568 /* Returns nonzero if CONTEXT_DIE is internal to a function. */
17571 local_scope_p (dw_die_ref context_die
)
17573 for (; context_die
; context_die
= context_die
->die_parent
)
17574 if (context_die
->die_tag
== DW_TAG_inlined_subroutine
17575 || context_die
->die_tag
== DW_TAG_subprogram
)
17581 /* Returns nonzero if CONTEXT_DIE is a class. */
17584 class_scope_p (dw_die_ref context_die
)
17586 return (context_die
17587 && (context_die
->die_tag
== DW_TAG_structure_type
17588 || context_die
->die_tag
== DW_TAG_class_type
17589 || context_die
->die_tag
== DW_TAG_interface_type
17590 || context_die
->die_tag
== DW_TAG_union_type
));
17593 /* Returns nonzero if CONTEXT_DIE is a class or namespace, for deciding
17594 whether or not to treat a DIE in this context as a declaration. */
17597 class_or_namespace_scope_p (dw_die_ref context_die
)
17599 return (class_scope_p (context_die
)
17600 || (context_die
&& context_die
->die_tag
== DW_TAG_namespace
));
17603 /* Many forms of DIEs require a "type description" attribute. This
17604 routine locates the proper "type descriptor" die for the type given
17605 by 'type', and adds a DW_AT_type attribute below the given die. */
17608 add_type_attribute (dw_die_ref object_die
, tree type
, int decl_const
,
17609 int decl_volatile
, dw_die_ref context_die
)
17611 enum tree_code code
= TREE_CODE (type
);
17612 dw_die_ref type_die
= NULL
;
17614 /* ??? If this type is an unnamed subrange type of an integral, floating-point
17615 or fixed-point type, use the inner type. This is because we have no
17616 support for unnamed types in base_type_die. This can happen if this is
17617 an Ada subrange type. Correct solution is emit a subrange type die. */
17618 if ((code
== INTEGER_TYPE
|| code
== REAL_TYPE
|| code
== FIXED_POINT_TYPE
)
17619 && TREE_TYPE (type
) != 0 && TYPE_NAME (type
) == 0)
17620 type
= TREE_TYPE (type
), code
= TREE_CODE (type
);
17622 if (code
== ERROR_MARK
17623 /* Handle a special case. For functions whose return type is void, we
17624 generate *no* type attribute. (Note that no object may have type
17625 `void', so this only applies to function return types). */
17626 || code
== VOID_TYPE
)
17629 type_die
= modified_type_die (type
,
17630 decl_const
|| TYPE_READONLY (type
),
17631 decl_volatile
|| TYPE_VOLATILE (type
),
17634 if (type_die
!= NULL
)
17635 add_AT_die_ref (object_die
, DW_AT_type
, type_die
);
17638 /* Given an object die, add the calling convention attribute for the
17639 function call type. */
17641 add_calling_convention_attribute (dw_die_ref subr_die
, tree decl
)
17643 enum dwarf_calling_convention value
= DW_CC_normal
;
17645 value
= ((enum dwarf_calling_convention
)
17646 targetm
.dwarf_calling_convention (TREE_TYPE (decl
)));
17648 /* DWARF doesn't provide a way to identify a program's source-level
17649 entry point. DW_AT_calling_convention attributes are only meant
17650 to describe functions' calling conventions. However, lacking a
17651 better way to signal the Fortran main program, we use this for the
17652 time being, following existing custom. */
17654 && !strcmp (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)), "MAIN__"))
17655 value
= DW_CC_program
;
17657 /* Only add the attribute if the backend requests it, and
17658 is not DW_CC_normal. */
17659 if (value
&& (value
!= DW_CC_normal
))
17660 add_AT_unsigned (subr_die
, DW_AT_calling_convention
, value
);
17663 /* Given a tree pointer to a struct, class, union, or enum type node, return
17664 a pointer to the (string) tag name for the given type, or zero if the type
17665 was declared without a tag. */
17667 static const char *
17668 type_tag (const_tree type
)
17670 const char *name
= 0;
17672 if (TYPE_NAME (type
) != 0)
17676 /* Find the IDENTIFIER_NODE for the type name. */
17677 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
17678 t
= TYPE_NAME (type
);
17680 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
17681 a TYPE_DECL node, regardless of whether or not a `typedef' was
17683 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
17684 && ! DECL_IGNORED_P (TYPE_NAME (type
)))
17686 /* We want to be extra verbose. Don't call dwarf_name if
17687 DECL_NAME isn't set. The default hook for decl_printable_name
17688 doesn't like that, and in this context it's correct to return
17689 0, instead of "<anonymous>" or the like. */
17690 if (DECL_NAME (TYPE_NAME (type
)))
17691 name
= lang_hooks
.dwarf_name (TYPE_NAME (type
), 2);
17694 /* Now get the name as a string, or invent one. */
17695 if (!name
&& t
!= 0)
17696 name
= IDENTIFIER_POINTER (t
);
17699 return (name
== 0 || *name
== '\0') ? 0 : name
;
17702 /* Return the type associated with a data member, make a special check
17703 for bit field types. */
17706 member_declared_type (const_tree member
)
17708 return (DECL_BIT_FIELD_TYPE (member
)
17709 ? DECL_BIT_FIELD_TYPE (member
) : TREE_TYPE (member
));
17712 /* Get the decl's label, as described by its RTL. This may be different
17713 from the DECL_NAME name used in the source file. */
17716 static const char *
17717 decl_start_label (tree decl
)
17720 const char *fnname
;
17722 x
= DECL_RTL (decl
);
17723 gcc_assert (MEM_P (x
));
17726 gcc_assert (GET_CODE (x
) == SYMBOL_REF
);
17728 fnname
= XSTR (x
, 0);
17733 /* These routines generate the internal representation of the DIE's for
17734 the compilation unit. Debugging information is collected by walking
17735 the declaration trees passed in from dwarf2out_decl(). */
17738 gen_array_type_die (tree type
, dw_die_ref context_die
)
17740 dw_die_ref scope_die
= scope_die_for (type
, context_die
);
17741 dw_die_ref array_die
;
17743 /* GNU compilers represent multidimensional array types as sequences of one
17744 dimensional array types whose element types are themselves array types.
17745 We sometimes squish that down to a single array_type DIE with multiple
17746 subscripts in the Dwarf debugging info. The draft Dwarf specification
17747 say that we are allowed to do this kind of compression in C, because
17748 there is no difference between an array of arrays and a multidimensional
17749 array. We don't do this for Ada to remain as close as possible to the
17750 actual representation, which is especially important against the language
17751 flexibilty wrt arrays of variable size. */
17753 bool collapse_nested_arrays
= !is_ada ();
17756 /* Emit DW_TAG_string_type for Fortran character types (with kind 1 only, as
17757 DW_TAG_string_type doesn't have DW_AT_type attribute). */
17758 if (TYPE_STRING_FLAG (type
)
17759 && TREE_CODE (type
) == ARRAY_TYPE
17761 && TYPE_MODE (TREE_TYPE (type
)) == TYPE_MODE (char_type_node
))
17763 HOST_WIDE_INT size
;
17765 array_die
= new_die (DW_TAG_string_type
, scope_die
, type
);
17766 add_name_attribute (array_die
, type_tag (type
));
17767 equate_type_number_to_die (type
, array_die
);
17768 size
= int_size_in_bytes (type
);
17770 add_AT_unsigned (array_die
, DW_AT_byte_size
, size
);
17771 else if (TYPE_DOMAIN (type
) != NULL_TREE
17772 && TYPE_MAX_VALUE (TYPE_DOMAIN (type
)) != NULL_TREE
17773 && DECL_P (TYPE_MAX_VALUE (TYPE_DOMAIN (type
))))
17775 tree szdecl
= TYPE_MAX_VALUE (TYPE_DOMAIN (type
));
17776 dw_loc_list_ref loc
= loc_list_from_tree (szdecl
, 2);
17778 size
= int_size_in_bytes (TREE_TYPE (szdecl
));
17779 if (loc
&& size
> 0)
17781 add_AT_location_description (array_die
, DW_AT_string_length
, loc
);
17782 if (size
!= DWARF2_ADDR_SIZE
)
17783 add_AT_unsigned (array_die
, DW_AT_byte_size
, size
);
17789 /* ??? The SGI dwarf reader fails for array of array of enum types
17790 (e.g. const enum machine_mode insn_operand_mode[2][10]) unless the inner
17791 array type comes before the outer array type. We thus call gen_type_die
17792 before we new_die and must prevent nested array types collapsing for this
17795 #ifdef MIPS_DEBUGGING_INFO
17796 gen_type_die (TREE_TYPE (type
), context_die
);
17797 collapse_nested_arrays
= false;
17800 array_die
= new_die (DW_TAG_array_type
, scope_die
, type
);
17801 add_name_attribute (array_die
, type_tag (type
));
17802 equate_type_number_to_die (type
, array_die
);
17804 if (TREE_CODE (type
) == VECTOR_TYPE
)
17806 /* The frontend feeds us a representation for the vector as a struct
17807 containing an array. Pull out the array type. */
17808 type
= TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type
)));
17809 add_AT_flag (array_die
, DW_AT_GNU_vector
, 1);
17812 /* For Fortran multidimensional arrays use DW_ORD_col_major ordering. */
17814 && TREE_CODE (type
) == ARRAY_TYPE
17815 && TREE_CODE (TREE_TYPE (type
)) == ARRAY_TYPE
17816 && !TYPE_STRING_FLAG (TREE_TYPE (type
)))
17817 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_col_major
);
17820 /* We default the array ordering. SDB will probably do
17821 the right things even if DW_AT_ordering is not present. It's not even
17822 an issue until we start to get into multidimensional arrays anyway. If
17823 SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
17824 then we'll have to put the DW_AT_ordering attribute back in. (But if
17825 and when we find out that we need to put these in, we will only do so
17826 for multidimensional arrays. */
17827 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_row_major
);
17830 #ifdef MIPS_DEBUGGING_INFO
17831 /* The SGI compilers handle arrays of unknown bound by setting
17832 AT_declaration and not emitting any subrange DIEs. */
17833 if (! TYPE_DOMAIN (type
))
17834 add_AT_flag (array_die
, DW_AT_declaration
, 1);
17837 add_subscript_info (array_die
, type
, collapse_nested_arrays
);
17839 /* Add representation of the type of the elements of this array type and
17840 emit the corresponding DIE if we haven't done it already. */
17841 element_type
= TREE_TYPE (type
);
17842 if (collapse_nested_arrays
)
17843 while (TREE_CODE (element_type
) == ARRAY_TYPE
)
17845 if (TYPE_STRING_FLAG (element_type
) && is_fortran ())
17847 element_type
= TREE_TYPE (element_type
);
17850 #ifndef MIPS_DEBUGGING_INFO
17851 gen_type_die (element_type
, context_die
);
17854 add_type_attribute (array_die
, element_type
, 0, 0, context_die
);
17856 if (get_AT (array_die
, DW_AT_name
))
17857 add_pubtype (type
, array_die
);
17860 static dw_loc_descr_ref
17861 descr_info_loc (tree val
, tree base_decl
)
17863 HOST_WIDE_INT size
;
17864 dw_loc_descr_ref loc
, loc2
;
17865 enum dwarf_location_atom op
;
17867 if (val
== base_decl
)
17868 return new_loc_descr (DW_OP_push_object_address
, 0, 0);
17870 switch (TREE_CODE (val
))
17873 return descr_info_loc (TREE_OPERAND (val
, 0), base_decl
);
17875 return loc_descriptor_from_tree (val
, 0);
17877 if (host_integerp (val
, 0))
17878 return int_loc_descriptor (tree_low_cst (val
, 0));
17881 size
= int_size_in_bytes (TREE_TYPE (val
));
17884 loc
= descr_info_loc (TREE_OPERAND (val
, 0), base_decl
);
17887 if (size
== DWARF2_ADDR_SIZE
)
17888 add_loc_descr (&loc
, new_loc_descr (DW_OP_deref
, 0, 0));
17890 add_loc_descr (&loc
, new_loc_descr (DW_OP_deref_size
, size
, 0));
17892 case POINTER_PLUS_EXPR
:
17894 if (host_integerp (TREE_OPERAND (val
, 1), 1)
17895 && (unsigned HOST_WIDE_INT
) tree_low_cst (TREE_OPERAND (val
, 1), 1)
17898 loc
= descr_info_loc (TREE_OPERAND (val
, 0), base_decl
);
17901 loc_descr_plus_const (&loc
, tree_low_cst (TREE_OPERAND (val
, 1), 0));
17907 loc
= descr_info_loc (TREE_OPERAND (val
, 0), base_decl
);
17910 loc2
= descr_info_loc (TREE_OPERAND (val
, 1), base_decl
);
17913 add_loc_descr (&loc
, loc2
);
17914 add_loc_descr (&loc2
, new_loc_descr (op
, 0, 0));
17936 add_descr_info_field (dw_die_ref die
, enum dwarf_attribute attr
,
17937 tree val
, tree base_decl
)
17939 dw_loc_descr_ref loc
;
17941 if (host_integerp (val
, 0))
17943 add_AT_unsigned (die
, attr
, tree_low_cst (val
, 0));
17947 loc
= descr_info_loc (val
, base_decl
);
17951 add_AT_loc (die
, attr
, loc
);
17954 /* This routine generates DIE for array with hidden descriptor, details
17955 are filled into *info by a langhook. */
17958 gen_descr_array_type_die (tree type
, struct array_descr_info
*info
,
17959 dw_die_ref context_die
)
17961 dw_die_ref scope_die
= scope_die_for (type
, context_die
);
17962 dw_die_ref array_die
;
17965 array_die
= new_die (DW_TAG_array_type
, scope_die
, type
);
17966 add_name_attribute (array_die
, type_tag (type
));
17967 equate_type_number_to_die (type
, array_die
);
17969 /* For Fortran multidimensional arrays use DW_ORD_col_major ordering. */
17971 && info
->ndimensions
>= 2)
17972 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_col_major
);
17974 if (info
->data_location
)
17975 add_descr_info_field (array_die
, DW_AT_data_location
, info
->data_location
,
17977 if (info
->associated
)
17978 add_descr_info_field (array_die
, DW_AT_associated
, info
->associated
,
17980 if (info
->allocated
)
17981 add_descr_info_field (array_die
, DW_AT_allocated
, info
->allocated
,
17984 for (dim
= 0; dim
< info
->ndimensions
; dim
++)
17986 dw_die_ref subrange_die
17987 = new_die (DW_TAG_subrange_type
, array_die
, NULL
);
17989 if (info
->dimen
[dim
].lower_bound
)
17991 /* If it is the default value, omit it. */
17994 if (host_integerp (info
->dimen
[dim
].lower_bound
, 0)
17995 && (dflt
= lower_bound_default ()) != -1
17996 && tree_low_cst (info
->dimen
[dim
].lower_bound
, 0) == dflt
)
17999 add_descr_info_field (subrange_die
, DW_AT_lower_bound
,
18000 info
->dimen
[dim
].lower_bound
,
18003 if (info
->dimen
[dim
].upper_bound
)
18004 add_descr_info_field (subrange_die
, DW_AT_upper_bound
,
18005 info
->dimen
[dim
].upper_bound
,
18007 if (info
->dimen
[dim
].stride
)
18008 add_descr_info_field (subrange_die
, DW_AT_byte_stride
,
18009 info
->dimen
[dim
].stride
,
18013 gen_type_die (info
->element_type
, context_die
);
18014 add_type_attribute (array_die
, info
->element_type
, 0, 0, context_die
);
18016 if (get_AT (array_die
, DW_AT_name
))
18017 add_pubtype (type
, array_die
);
18022 gen_entry_point_die (tree decl
, dw_die_ref context_die
)
18024 tree origin
= decl_ultimate_origin (decl
);
18025 dw_die_ref decl_die
= new_die (DW_TAG_entry_point
, context_die
, decl
);
18027 if (origin
!= NULL
)
18028 add_abstract_origin_attribute (decl_die
, origin
);
18031 add_name_and_src_coords_attributes (decl_die
, decl
);
18032 add_type_attribute (decl_die
, TREE_TYPE (TREE_TYPE (decl
)),
18033 0, 0, context_die
);
18036 if (DECL_ABSTRACT (decl
))
18037 equate_decl_number_to_die (decl
, decl_die
);
18039 add_AT_lbl_id (decl_die
, DW_AT_low_pc
, decl_start_label (decl
));
18043 /* Walk through the list of incomplete types again, trying once more to
18044 emit full debugging info for them. */
18047 retry_incomplete_types (void)
18051 for (i
= VEC_length (tree
, incomplete_types
) - 1; i
>= 0; i
--)
18052 if (should_emit_struct_debug (VEC_index (tree
, incomplete_types
, i
),
18053 DINFO_USAGE_DIR_USE
))
18054 gen_type_die (VEC_index (tree
, incomplete_types
, i
), comp_unit_die
);
18057 /* Determine what tag to use for a record type. */
18059 static enum dwarf_tag
18060 record_type_tag (tree type
)
18062 if (! lang_hooks
.types
.classify_record
)
18063 return DW_TAG_structure_type
;
18065 switch (lang_hooks
.types
.classify_record (type
))
18067 case RECORD_IS_STRUCT
:
18068 return DW_TAG_structure_type
;
18070 case RECORD_IS_CLASS
:
18071 return DW_TAG_class_type
;
18073 case RECORD_IS_INTERFACE
:
18074 if (dwarf_version
>= 3 || !dwarf_strict
)
18075 return DW_TAG_interface_type
;
18076 return DW_TAG_structure_type
;
18079 gcc_unreachable ();
18083 /* Generate a DIE to represent an enumeration type. Note that these DIEs
18084 include all of the information about the enumeration values also. Each
18085 enumerated type name/value is listed as a child of the enumerated type
18089 gen_enumeration_type_die (tree type
, dw_die_ref context_die
)
18091 dw_die_ref type_die
= lookup_type_die (type
);
18093 if (type_die
== NULL
)
18095 type_die
= new_die (DW_TAG_enumeration_type
,
18096 scope_die_for (type
, context_die
), type
);
18097 equate_type_number_to_die (type
, type_die
);
18098 add_name_attribute (type_die
, type_tag (type
));
18099 if ((dwarf_version
>= 4 || !dwarf_strict
)
18100 && ENUM_IS_SCOPED (type
))
18101 add_AT_flag (type_die
, DW_AT_enum_class
, 1);
18103 else if (! TYPE_SIZE (type
))
18106 remove_AT (type_die
, DW_AT_declaration
);
18108 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the
18109 given enum type is incomplete, do not generate the DW_AT_byte_size
18110 attribute or the DW_AT_element_list attribute. */
18111 if (TYPE_SIZE (type
))
18115 TREE_ASM_WRITTEN (type
) = 1;
18116 add_byte_size_attribute (type_die
, type
);
18117 if (TYPE_STUB_DECL (type
) != NULL_TREE
)
18119 add_src_coords_attributes (type_die
, TYPE_STUB_DECL (type
));
18120 add_accessibility_attribute (type_die
, TYPE_STUB_DECL (type
));
18123 /* If the first reference to this type was as the return type of an
18124 inline function, then it may not have a parent. Fix this now. */
18125 if (type_die
->die_parent
== NULL
)
18126 add_child_die (scope_die_for (type
, context_die
), type_die
);
18128 for (link
= TYPE_VALUES (type
);
18129 link
!= NULL
; link
= TREE_CHAIN (link
))
18131 dw_die_ref enum_die
= new_die (DW_TAG_enumerator
, type_die
, link
);
18132 tree value
= TREE_VALUE (link
);
18134 add_name_attribute (enum_die
,
18135 IDENTIFIER_POINTER (TREE_PURPOSE (link
)));
18137 if (TREE_CODE (value
) == CONST_DECL
)
18138 value
= DECL_INITIAL (value
);
18140 if (host_integerp (value
, TYPE_UNSIGNED (TREE_TYPE (value
))))
18141 /* DWARF2 does not provide a way of indicating whether or
18142 not enumeration constants are signed or unsigned. GDB
18143 always assumes the values are signed, so we output all
18144 values as if they were signed. That means that
18145 enumeration constants with very large unsigned values
18146 will appear to have negative values in the debugger. */
18147 add_AT_int (enum_die
, DW_AT_const_value
,
18148 tree_low_cst (value
, tree_int_cst_sgn (value
) > 0));
18152 add_AT_flag (type_die
, DW_AT_declaration
, 1);
18154 if (get_AT (type_die
, DW_AT_name
))
18155 add_pubtype (type
, type_die
);
18160 /* Generate a DIE to represent either a real live formal parameter decl or to
18161 represent just the type of some formal parameter position in some function
18164 Note that this routine is a bit unusual because its argument may be a
18165 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
18166 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
18167 node. If it's the former then this function is being called to output a
18168 DIE to represent a formal parameter object (or some inlining thereof). If
18169 it's the latter, then this function is only being called to output a
18170 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
18171 argument type of some subprogram type.
18172 If EMIT_NAME_P is true, name and source coordinate attributes
18176 gen_formal_parameter_die (tree node
, tree origin
, bool emit_name_p
,
18177 dw_die_ref context_die
)
18179 tree node_or_origin
= node
? node
: origin
;
18180 tree ultimate_origin
;
18181 dw_die_ref parm_die
18182 = new_die (DW_TAG_formal_parameter
, context_die
, node
);
18184 switch (TREE_CODE_CLASS (TREE_CODE (node_or_origin
)))
18186 case tcc_declaration
:
18187 ultimate_origin
= decl_ultimate_origin (node_or_origin
);
18188 if (node
|| ultimate_origin
)
18189 origin
= ultimate_origin
;
18190 if (origin
!= NULL
)
18191 add_abstract_origin_attribute (parm_die
, origin
);
18192 else if (emit_name_p
)
18193 add_name_and_src_coords_attributes (parm_die
, node
);
18195 || (! DECL_ABSTRACT (node_or_origin
)
18196 && variably_modified_type_p (TREE_TYPE (node_or_origin
),
18197 decl_function_context
18198 (node_or_origin
))))
18200 tree type
= TREE_TYPE (node_or_origin
);
18201 if (decl_by_reference_p (node_or_origin
))
18202 add_type_attribute (parm_die
, TREE_TYPE (type
), 0, 0,
18205 add_type_attribute (parm_die
, type
,
18206 TREE_READONLY (node_or_origin
),
18207 TREE_THIS_VOLATILE (node_or_origin
),
18210 if (origin
== NULL
&& DECL_ARTIFICIAL (node
))
18211 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
18213 if (node
&& node
!= origin
)
18214 equate_decl_number_to_die (node
, parm_die
);
18215 if (! DECL_ABSTRACT (node_or_origin
))
18216 add_location_or_const_value_attribute (parm_die
, node_or_origin
,
18222 /* We were called with some kind of a ..._TYPE node. */
18223 add_type_attribute (parm_die
, node_or_origin
, 0, 0, context_die
);
18227 gcc_unreachable ();
18233 /* Generate and return a DW_TAG_GNU_formal_parameter_pack. Also generate
18234 children DW_TAG_formal_parameter DIEs representing the arguments of the
18237 PARM_PACK must be a function parameter pack.
18238 PACK_ARG is the first argument of the parameter pack. Its TREE_CHAIN
18239 must point to the subsequent arguments of the function PACK_ARG belongs to.
18240 SUBR_DIE is the DIE of the function PACK_ARG belongs to.
18241 If NEXT_ARG is non NULL, *NEXT_ARG is set to the function argument
18242 following the last one for which a DIE was generated. */
18245 gen_formal_parameter_pack_die (tree parm_pack
,
18247 dw_die_ref subr_die
,
18251 dw_die_ref parm_pack_die
;
18253 gcc_assert (parm_pack
18254 && lang_hooks
.function_parameter_pack_p (parm_pack
)
18257 parm_pack_die
= new_die (DW_TAG_GNU_formal_parameter_pack
, subr_die
, parm_pack
);
18258 add_src_coords_attributes (parm_pack_die
, parm_pack
);
18260 for (arg
= pack_arg
; arg
; arg
= TREE_CHAIN (arg
))
18262 if (! lang_hooks
.decls
.function_parm_expanded_from_pack_p (arg
,
18265 gen_formal_parameter_die (arg
, NULL
,
18266 false /* Don't emit name attribute. */,
18271 return parm_pack_die
;
18274 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
18275 at the end of an (ANSI prototyped) formal parameters list. */
18278 gen_unspecified_parameters_die (tree decl_or_type
, dw_die_ref context_die
)
18280 new_die (DW_TAG_unspecified_parameters
, context_die
, decl_or_type
);
18283 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
18284 DW_TAG_unspecified_parameters DIE) to represent the types of the formal
18285 parameters as specified in some function type specification (except for
18286 those which appear as part of a function *definition*). */
18289 gen_formal_types_die (tree function_or_method_type
, dw_die_ref context_die
)
18292 tree formal_type
= NULL
;
18293 tree first_parm_type
;
18296 if (TREE_CODE (function_or_method_type
) == FUNCTION_DECL
)
18298 arg
= DECL_ARGUMENTS (function_or_method_type
);
18299 function_or_method_type
= TREE_TYPE (function_or_method_type
);
18304 first_parm_type
= TYPE_ARG_TYPES (function_or_method_type
);
18306 /* Make our first pass over the list of formal parameter types and output a
18307 DW_TAG_formal_parameter DIE for each one. */
18308 for (link
= first_parm_type
; link
; )
18310 dw_die_ref parm_die
;
18312 formal_type
= TREE_VALUE (link
);
18313 if (formal_type
== void_type_node
)
18316 /* Output a (nameless) DIE to represent the formal parameter itself. */
18317 parm_die
= gen_formal_parameter_die (formal_type
, NULL
,
18318 true /* Emit name attribute. */,
18320 if ((TREE_CODE (function_or_method_type
) == METHOD_TYPE
18321 && link
== first_parm_type
)
18322 || (arg
&& DECL_ARTIFICIAL (arg
)))
18323 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
18325 link
= TREE_CHAIN (link
);
18327 arg
= TREE_CHAIN (arg
);
18330 /* If this function type has an ellipsis, add a
18331 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */
18332 if (formal_type
!= void_type_node
)
18333 gen_unspecified_parameters_die (function_or_method_type
, context_die
);
18335 /* Make our second (and final) pass over the list of formal parameter types
18336 and output DIEs to represent those types (as necessary). */
18337 for (link
= TYPE_ARG_TYPES (function_or_method_type
);
18338 link
&& TREE_VALUE (link
);
18339 link
= TREE_CHAIN (link
))
18340 gen_type_die (TREE_VALUE (link
), context_die
);
18343 /* We want to generate the DIE for TYPE so that we can generate the
18344 die for MEMBER, which has been defined; we will need to refer back
18345 to the member declaration nested within TYPE. If we're trying to
18346 generate minimal debug info for TYPE, processing TYPE won't do the
18347 trick; we need to attach the member declaration by hand. */
18350 gen_type_die_for_member (tree type
, tree member
, dw_die_ref context_die
)
18352 gen_type_die (type
, context_die
);
18354 /* If we're trying to avoid duplicate debug info, we may not have
18355 emitted the member decl for this function. Emit it now. */
18356 if (TYPE_STUB_DECL (type
)
18357 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type
))
18358 && ! lookup_decl_die (member
))
18360 dw_die_ref type_die
;
18361 gcc_assert (!decl_ultimate_origin (member
));
18363 push_decl_scope (type
);
18364 type_die
= lookup_type_die (type
);
18365 if (TREE_CODE (member
) == FUNCTION_DECL
)
18366 gen_subprogram_die (member
, type_die
);
18367 else if (TREE_CODE (member
) == FIELD_DECL
)
18369 /* Ignore the nameless fields that are used to skip bits but handle
18370 C++ anonymous unions and structs. */
18371 if (DECL_NAME (member
) != NULL_TREE
18372 || TREE_CODE (TREE_TYPE (member
)) == UNION_TYPE
18373 || TREE_CODE (TREE_TYPE (member
)) == RECORD_TYPE
)
18375 gen_type_die (member_declared_type (member
), type_die
);
18376 gen_field_die (member
, type_die
);
18380 gen_variable_die (member
, NULL_TREE
, type_die
);
18386 /* Generate the DWARF2 info for the "abstract" instance of a function which we
18387 may later generate inlined and/or out-of-line instances of. */
18390 dwarf2out_abstract_function (tree decl
)
18392 dw_die_ref old_die
;
18396 htab_t old_decl_loc_table
;
18398 /* Make sure we have the actual abstract inline, not a clone. */
18399 decl
= DECL_ORIGIN (decl
);
18401 old_die
= lookup_decl_die (decl
);
18402 if (old_die
&& get_AT (old_die
, DW_AT_inline
))
18403 /* We've already generated the abstract instance. */
18406 /* We can be called while recursively when seeing block defining inlined subroutine
18407 DIE. Be sure to not clobber the outer location table nor use it or we would
18408 get locations in abstract instantces. */
18409 old_decl_loc_table
= decl_loc_table
;
18410 decl_loc_table
= NULL
;
18412 /* Be sure we've emitted the in-class declaration DIE (if any) first, so
18413 we don't get confused by DECL_ABSTRACT. */
18414 if (debug_info_level
> DINFO_LEVEL_TERSE
)
18416 context
= decl_class_context (decl
);
18418 gen_type_die_for_member
18419 (context
, decl
, decl_function_context (decl
) ? NULL
: comp_unit_die
);
18422 /* Pretend we've just finished compiling this function. */
18423 save_fn
= current_function_decl
;
18424 current_function_decl
= decl
;
18425 push_cfun (DECL_STRUCT_FUNCTION (decl
));
18427 was_abstract
= DECL_ABSTRACT (decl
);
18428 set_decl_abstract_flags (decl
, 1);
18429 dwarf2out_decl (decl
);
18430 if (! was_abstract
)
18431 set_decl_abstract_flags (decl
, 0);
18433 current_function_decl
= save_fn
;
18434 decl_loc_table
= old_decl_loc_table
;
18438 /* Helper function of premark_used_types() which gets called through
18441 Marks the DIE of a given type in *SLOT as perennial, so it never gets
18442 marked as unused by prune_unused_types. */
18445 premark_used_types_helper (void **slot
, void *data ATTRIBUTE_UNUSED
)
18450 type
= (tree
) *slot
;
18451 die
= lookup_type_die (type
);
18453 die
->die_perennial_p
= 1;
18457 /* Helper function of premark_types_used_by_global_vars which gets called
18458 through htab_traverse.
18460 Marks the DIE of a given type in *SLOT as perennial, so it never gets
18461 marked as unused by prune_unused_types. The DIE of the type is marked
18462 only if the global variable using the type will actually be emitted. */
18465 premark_types_used_by_global_vars_helper (void **slot
,
18466 void *data ATTRIBUTE_UNUSED
)
18468 struct types_used_by_vars_entry
*entry
;
18471 entry
= (struct types_used_by_vars_entry
*) *slot
;
18472 gcc_assert (entry
->type
!= NULL
18473 && entry
->var_decl
!= NULL
);
18474 die
= lookup_type_die (entry
->type
);
18477 /* Ask cgraph if the global variable really is to be emitted.
18478 If yes, then we'll keep the DIE of ENTRY->TYPE. */
18479 struct varpool_node
*node
= varpool_get_node (entry
->var_decl
);
18480 if (node
&& node
->needed
)
18482 die
->die_perennial_p
= 1;
18483 /* Keep the parent DIEs as well. */
18484 while ((die
= die
->die_parent
) && die
->die_perennial_p
== 0)
18485 die
->die_perennial_p
= 1;
18491 /* Mark all members of used_types_hash as perennial. */
18494 premark_used_types (void)
18496 if (cfun
&& cfun
->used_types_hash
)
18497 htab_traverse (cfun
->used_types_hash
, premark_used_types_helper
, NULL
);
18500 /* Mark all members of types_used_by_vars_entry as perennial. */
18503 premark_types_used_by_global_vars (void)
18505 if (types_used_by_vars_hash
)
18506 htab_traverse (types_used_by_vars_hash
,
18507 premark_types_used_by_global_vars_helper
, NULL
);
18510 /* Generate a DIE to represent a declared function (either file-scope or
18514 gen_subprogram_die (tree decl
, dw_die_ref context_die
)
18516 char label_id
[MAX_ARTIFICIAL_LABEL_BYTES
];
18517 tree origin
= decl_ultimate_origin (decl
);
18518 dw_die_ref subr_die
;
18521 dw_die_ref old_die
= lookup_decl_die (decl
);
18522 int declaration
= (current_function_decl
!= decl
18523 || class_or_namespace_scope_p (context_die
));
18525 premark_used_types ();
18527 /* It is possible to have both DECL_ABSTRACT and DECLARATION be true if we
18528 started to generate the abstract instance of an inline, decided to output
18529 its containing class, and proceeded to emit the declaration of the inline
18530 from the member list for the class. If so, DECLARATION takes priority;
18531 we'll get back to the abstract instance when done with the class. */
18533 /* The class-scope declaration DIE must be the primary DIE. */
18534 if (origin
&& declaration
&& class_or_namespace_scope_p (context_die
))
18537 gcc_assert (!old_die
);
18540 /* Now that the C++ front end lazily declares artificial member fns, we
18541 might need to retrofit the declaration into its class. */
18542 if (!declaration
&& !origin
&& !old_die
18543 && DECL_CONTEXT (decl
) && TYPE_P (DECL_CONTEXT (decl
))
18544 && !class_or_namespace_scope_p (context_die
)
18545 && debug_info_level
> DINFO_LEVEL_TERSE
)
18546 old_die
= force_decl_die (decl
);
18548 if (origin
!= NULL
)
18550 gcc_assert (!declaration
|| local_scope_p (context_die
));
18552 /* Fixup die_parent for the abstract instance of a nested
18553 inline function. */
18554 if (old_die
&& old_die
->die_parent
== NULL
)
18555 add_child_die (context_die
, old_die
);
18557 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
18558 add_abstract_origin_attribute (subr_die
, origin
);
18562 expanded_location s
= expand_location (DECL_SOURCE_LOCATION (decl
));
18563 struct dwarf_file_data
* file_index
= lookup_filename (s
.file
);
18565 if (!get_AT_flag (old_die
, DW_AT_declaration
)
18566 /* We can have a normal definition following an inline one in the
18567 case of redefinition of GNU C extern inlines.
18568 It seems reasonable to use AT_specification in this case. */
18569 && !get_AT (old_die
, DW_AT_inline
))
18571 /* Detect and ignore this case, where we are trying to output
18572 something we have already output. */
18576 /* If the definition comes from the same place as the declaration,
18577 maybe use the old DIE. We always want the DIE for this function
18578 that has the *_pc attributes to be under comp_unit_die so the
18579 debugger can find it. We also need to do this for abstract
18580 instances of inlines, since the spec requires the out-of-line copy
18581 to have the same parent. For local class methods, this doesn't
18582 apply; we just use the old DIE. */
18583 if ((old_die
->die_parent
== comp_unit_die
|| context_die
== NULL
)
18584 && (DECL_ARTIFICIAL (decl
)
18585 || (get_AT_file (old_die
, DW_AT_decl_file
) == file_index
18586 && (get_AT_unsigned (old_die
, DW_AT_decl_line
)
18587 == (unsigned) s
.line
))))
18589 subr_die
= old_die
;
18591 /* Clear out the declaration attribute and the formal parameters.
18592 Do not remove all children, because it is possible that this
18593 declaration die was forced using force_decl_die(). In such
18594 cases die that forced declaration die (e.g. TAG_imported_module)
18595 is one of the children that we do not want to remove. */
18596 remove_AT (subr_die
, DW_AT_declaration
);
18597 remove_child_TAG (subr_die
, DW_TAG_formal_parameter
);
18601 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
18602 add_AT_specification (subr_die
, old_die
);
18603 if (get_AT_file (old_die
, DW_AT_decl_file
) != file_index
)
18604 add_AT_file (subr_die
, DW_AT_decl_file
, file_index
);
18605 if (get_AT_unsigned (old_die
, DW_AT_decl_line
) != (unsigned) s
.line
)
18606 add_AT_unsigned (subr_die
, DW_AT_decl_line
, s
.line
);
18611 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
18613 if (TREE_PUBLIC (decl
))
18614 add_AT_flag (subr_die
, DW_AT_external
, 1);
18616 add_name_and_src_coords_attributes (subr_die
, decl
);
18617 if (debug_info_level
> DINFO_LEVEL_TERSE
)
18619 add_prototyped_attribute (subr_die
, TREE_TYPE (decl
));
18620 add_type_attribute (subr_die
, TREE_TYPE (TREE_TYPE (decl
)),
18621 0, 0, context_die
);
18624 add_pure_or_virtual_attribute (subr_die
, decl
);
18625 if (DECL_ARTIFICIAL (decl
))
18626 add_AT_flag (subr_die
, DW_AT_artificial
, 1);
18628 add_accessibility_attribute (subr_die
, decl
);
18633 if (!old_die
|| !get_AT (old_die
, DW_AT_inline
))
18635 add_AT_flag (subr_die
, DW_AT_declaration
, 1);
18637 /* If this is an explicit function declaration then generate
18638 a DW_AT_explicit attribute. */
18639 if (lang_hooks
.decls
.function_decl_explicit_p (decl
)
18640 && (dwarf_version
>= 3 || !dwarf_strict
))
18641 add_AT_flag (subr_die
, DW_AT_explicit
, 1);
18643 /* The first time we see a member function, it is in the context of
18644 the class to which it belongs. We make sure of this by emitting
18645 the class first. The next time is the definition, which is
18646 handled above. The two may come from the same source text.
18648 Note that force_decl_die() forces function declaration die. It is
18649 later reused to represent definition. */
18650 equate_decl_number_to_die (decl
, subr_die
);
18653 else if (DECL_ABSTRACT (decl
))
18655 if (DECL_DECLARED_INLINE_P (decl
))
18657 if (cgraph_function_possibly_inlined_p (decl
))
18658 add_AT_unsigned (subr_die
, DW_AT_inline
, DW_INL_declared_inlined
);
18660 add_AT_unsigned (subr_die
, DW_AT_inline
, DW_INL_declared_not_inlined
);
18664 if (cgraph_function_possibly_inlined_p (decl
))
18665 add_AT_unsigned (subr_die
, DW_AT_inline
, DW_INL_inlined
);
18667 add_AT_unsigned (subr_die
, DW_AT_inline
, DW_INL_not_inlined
);
18670 if (DECL_DECLARED_INLINE_P (decl
)
18671 && lookup_attribute ("artificial", DECL_ATTRIBUTES (decl
)))
18672 add_AT_flag (subr_die
, DW_AT_artificial
, 1);
18674 equate_decl_number_to_die (decl
, subr_die
);
18676 else if (!DECL_EXTERNAL (decl
))
18678 HOST_WIDE_INT cfa_fb_offset
;
18680 if (!old_die
|| !get_AT (old_die
, DW_AT_inline
))
18681 equate_decl_number_to_die (decl
, subr_die
);
18683 if (!flag_reorder_blocks_and_partition
)
18685 ASM_GENERATE_INTERNAL_LABEL (label_id
, FUNC_BEGIN_LABEL
,
18686 current_function_funcdef_no
);
18687 add_AT_lbl_id (subr_die
, DW_AT_low_pc
, label_id
);
18688 ASM_GENERATE_INTERNAL_LABEL (label_id
, FUNC_END_LABEL
,
18689 current_function_funcdef_no
);
18690 add_AT_lbl_id (subr_die
, DW_AT_high_pc
, label_id
);
18692 #if VMS_DEBUGGING_INFO
18693 /* HP OpenVMS Industry Standard 64: DWARF Extensions
18694 Section 2.3 Prologue and Epilogue Attributes:
18695 When a breakpoint is set on entry to a function, it is generally
18696 desirable for execution to be suspended, not on the very first
18697 instruction of the function, but rather at a point after the
18698 function's frame has been set up, after any language defined local
18699 declaration processing has been completed, and before execution of
18700 the first statement of the function begins. Debuggers generally
18701 cannot properly determine where this point is. Similarly for a
18702 breakpoint set on exit from a function. The prologue and epilogue
18703 attributes allow a compiler to communicate the location(s) to use. */
18706 dw_fde_ref fde
= &fde_table
[current_funcdef_fde
];
18708 if (fde
->dw_fde_vms_end_prologue
)
18709 add_AT_vms_delta (subr_die
, DW_AT_HP_prologue
,
18710 fde
->dw_fde_begin
, fde
->dw_fde_vms_end_prologue
);
18712 if (fde
->dw_fde_vms_begin_epilogue
)
18713 add_AT_vms_delta (subr_die
, DW_AT_HP_epilogue
,
18714 fde
->dw_fde_begin
, fde
->dw_fde_vms_begin_epilogue
);
18718 add_pubname (decl
, subr_die
);
18719 add_arange (decl
, subr_die
);
18722 { /* Do nothing for now; maybe need to duplicate die, one for
18723 hot section and one for cold section, then use the hot/cold
18724 section begin/end labels to generate the aranges... */
18726 add_AT_lbl_id (subr_die, DW_AT_low_pc, hot_section_label);
18727 add_AT_lbl_id (subr_die, DW_AT_high_pc, hot_section_end_label);
18728 add_AT_lbl_id (subr_die, DW_AT_lo_user, unlikely_section_label);
18729 add_AT_lbl_id (subr_die, DW_AT_hi_user, cold_section_end_label);
18731 add_pubname (decl, subr_die);
18732 add_arange (decl, subr_die);
18733 add_arange (decl, subr_die);
18737 #ifdef MIPS_DEBUGGING_INFO
18738 /* Add a reference to the FDE for this routine. */
18739 add_AT_fde_ref (subr_die
, DW_AT_MIPS_fde
, current_funcdef_fde
);
18742 cfa_fb_offset
= CFA_FRAME_BASE_OFFSET (decl
);
18744 /* We define the "frame base" as the function's CFA. This is more
18745 convenient for several reasons: (1) It's stable across the prologue
18746 and epilogue, which makes it better than just a frame pointer,
18747 (2) With dwarf3, there exists a one-byte encoding that allows us
18748 to reference the .debug_frame data by proxy, but failing that,
18749 (3) We can at least reuse the code inspection and interpretation
18750 code that determines the CFA position at various points in the
18752 if (dwarf_version
>= 3)
18754 dw_loc_descr_ref op
= new_loc_descr (DW_OP_call_frame_cfa
, 0, 0);
18755 add_AT_loc (subr_die
, DW_AT_frame_base
, op
);
18759 dw_loc_list_ref list
= convert_cfa_to_fb_loc_list (cfa_fb_offset
);
18760 if (list
->dw_loc_next
)
18761 add_AT_loc_list (subr_die
, DW_AT_frame_base
, list
);
18763 add_AT_loc (subr_die
, DW_AT_frame_base
, list
->expr
);
18766 /* Compute a displacement from the "steady-state frame pointer" to
18767 the CFA. The former is what all stack slots and argument slots
18768 will reference in the rtl; the later is what we've told the
18769 debugger about. We'll need to adjust all frame_base references
18770 by this displacement. */
18771 compute_frame_pointer_to_fb_displacement (cfa_fb_offset
);
18773 if (cfun
->static_chain_decl
)
18774 add_AT_location_description (subr_die
, DW_AT_static_link
,
18775 loc_list_from_tree (cfun
->static_chain_decl
, 2));
18778 /* Generate child dies for template paramaters. */
18779 if (debug_info_level
> DINFO_LEVEL_TERSE
)
18780 gen_generic_params_dies (decl
);
18782 /* Now output descriptions of the arguments for this function. This gets
18783 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
18784 for a FUNCTION_DECL doesn't indicate cases where there was a trailing
18785 `...' at the end of the formal parameter list. In order to find out if
18786 there was a trailing ellipsis or not, we must instead look at the type
18787 associated with the FUNCTION_DECL. This will be a node of type
18788 FUNCTION_TYPE. If the chain of type nodes hanging off of this
18789 FUNCTION_TYPE node ends with a void_type_node then there should *not* be
18790 an ellipsis at the end. */
18792 /* In the case where we are describing a mere function declaration, all we
18793 need to do here (and all we *can* do here) is to describe the *types* of
18794 its formal parameters. */
18795 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
18797 else if (declaration
)
18798 gen_formal_types_die (decl
, subr_die
);
18801 /* Generate DIEs to represent all known formal parameters. */
18802 tree parm
= DECL_ARGUMENTS (decl
);
18803 tree generic_decl
= lang_hooks
.decls
.get_generic_function_decl (decl
);
18804 tree generic_decl_parm
= generic_decl
18805 ? DECL_ARGUMENTS (generic_decl
)
18808 /* Now we want to walk the list of parameters of the function and
18809 emit their relevant DIEs.
18811 We consider the case of DECL being an instance of a generic function
18812 as well as it being a normal function.
18814 If DECL is an instance of a generic function we walk the
18815 parameters of the generic function declaration _and_ the parameters of
18816 DECL itself. This is useful because we want to emit specific DIEs for
18817 function parameter packs and those are declared as part of the
18818 generic function declaration. In that particular case,
18819 the parameter pack yields a DW_TAG_GNU_formal_parameter_pack DIE.
18820 That DIE has children DIEs representing the set of arguments
18821 of the pack. Note that the set of pack arguments can be empty.
18822 In that case, the DW_TAG_GNU_formal_parameter_pack DIE will not have any
18825 Otherwise, we just consider the parameters of DECL. */
18826 while (generic_decl_parm
|| parm
)
18828 if (generic_decl_parm
18829 && lang_hooks
.function_parameter_pack_p (generic_decl_parm
))
18830 gen_formal_parameter_pack_die (generic_decl_parm
,
18835 gen_decl_die (parm
, NULL
, subr_die
);
18836 parm
= TREE_CHAIN (parm
);
18839 if (generic_decl_parm
)
18840 generic_decl_parm
= TREE_CHAIN (generic_decl_parm
);
18843 /* Decide whether we need an unspecified_parameters DIE at the end.
18844 There are 2 more cases to do this for: 1) the ansi ... declaration -
18845 this is detectable when the end of the arg list is not a
18846 void_type_node 2) an unprototyped function declaration (not a
18847 definition). This just means that we have no info about the
18848 parameters at all. */
18849 fn_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
18850 if (fn_arg_types
!= NULL
)
18852 /* This is the prototyped case, check for.... */
18853 if (TREE_VALUE (tree_last (fn_arg_types
)) != void_type_node
)
18854 gen_unspecified_parameters_die (decl
, subr_die
);
18856 else if (DECL_INITIAL (decl
) == NULL_TREE
)
18857 gen_unspecified_parameters_die (decl
, subr_die
);
18860 /* Output Dwarf info for all of the stuff within the body of the function
18861 (if it has one - it may be just a declaration). */
18862 outer_scope
= DECL_INITIAL (decl
);
18864 /* OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent
18865 a function. This BLOCK actually represents the outermost binding contour
18866 for the function, i.e. the contour in which the function's formal
18867 parameters and labels get declared. Curiously, it appears that the front
18868 end doesn't actually put the PARM_DECL nodes for the current function onto
18869 the BLOCK_VARS list for this outer scope, but are strung off of the
18870 DECL_ARGUMENTS list for the function instead.
18872 The BLOCK_VARS list for the `outer_scope' does provide us with a list of
18873 the LABEL_DECL nodes for the function however, and we output DWARF info
18874 for those in decls_for_scope. Just within the `outer_scope' there will be
18875 a BLOCK node representing the function's outermost pair of curly braces,
18876 and any blocks used for the base and member initializers of a C++
18877 constructor function. */
18878 if (! declaration
&& TREE_CODE (outer_scope
) != ERROR_MARK
)
18880 /* Emit a DW_TAG_variable DIE for a named return value. */
18881 if (DECL_NAME (DECL_RESULT (decl
)))
18882 gen_decl_die (DECL_RESULT (decl
), NULL
, subr_die
);
18884 current_function_has_inlines
= 0;
18885 decls_for_scope (outer_scope
, subr_die
, 0);
18887 #if 0 && defined (MIPS_DEBUGGING_INFO)
18888 if (current_function_has_inlines
)
18890 add_AT_flag (subr_die
, DW_AT_MIPS_has_inlines
, 1);
18891 if (! comp_unit_has_inlines
)
18893 add_AT_flag (comp_unit_die
, DW_AT_MIPS_has_inlines
, 1);
18894 comp_unit_has_inlines
= 1;
18899 /* Add the calling convention attribute if requested. */
18900 add_calling_convention_attribute (subr_die
, decl
);
18904 /* Returns a hash value for X (which really is a die_struct). */
18907 common_block_die_table_hash (const void *x
)
18909 const_dw_die_ref d
= (const_dw_die_ref
) x
;
18910 return (hashval_t
) d
->decl_id
^ htab_hash_pointer (d
->die_parent
);
18913 /* Return nonzero if decl_id and die_parent of die_struct X is the same
18914 as decl_id and die_parent of die_struct Y. */
18917 common_block_die_table_eq (const void *x
, const void *y
)
18919 const_dw_die_ref d
= (const_dw_die_ref
) x
;
18920 const_dw_die_ref e
= (const_dw_die_ref
) y
;
18921 return d
->decl_id
== e
->decl_id
&& d
->die_parent
== e
->die_parent
;
18924 /* Generate a DIE to represent a declared data object.
18925 Either DECL or ORIGIN must be non-null. */
18928 gen_variable_die (tree decl
, tree origin
, dw_die_ref context_die
)
18932 tree decl_or_origin
= decl
? decl
: origin
;
18933 tree ultimate_origin
;
18934 dw_die_ref var_die
;
18935 dw_die_ref old_die
= decl
? lookup_decl_die (decl
) : NULL
;
18936 dw_die_ref origin_die
;
18937 bool declaration
= (DECL_EXTERNAL (decl_or_origin
)
18938 || class_or_namespace_scope_p (context_die
));
18939 bool specialization_p
= false;
18941 ultimate_origin
= decl_ultimate_origin (decl_or_origin
);
18942 if (decl
|| ultimate_origin
)
18943 origin
= ultimate_origin
;
18944 com_decl
= fortran_common (decl_or_origin
, &off
);
18946 /* Symbol in common gets emitted as a child of the common block, in the form
18947 of a data member. */
18950 dw_die_ref com_die
;
18951 dw_loc_list_ref loc
;
18952 die_node com_die_arg
;
18954 var_die
= lookup_decl_die (decl_or_origin
);
18957 if (get_AT (var_die
, DW_AT_location
) == NULL
)
18959 loc
= loc_list_from_tree (com_decl
, off
? 1 : 2);
18964 /* Optimize the common case. */
18965 if (single_element_loc_list_p (loc
)
18966 && loc
->expr
->dw_loc_opc
== DW_OP_addr
18967 && loc
->expr
->dw_loc_next
== NULL
18968 && GET_CODE (loc
->expr
->dw_loc_oprnd1
.v
.val_addr
)
18970 loc
->expr
->dw_loc_oprnd1
.v
.val_addr
18971 = plus_constant (loc
->expr
->dw_loc_oprnd1
.v
.val_addr
, off
);
18973 loc_list_plus_const (loc
, off
);
18975 add_AT_location_description (var_die
, DW_AT_location
, loc
);
18976 remove_AT (var_die
, DW_AT_declaration
);
18982 if (common_block_die_table
== NULL
)
18983 common_block_die_table
18984 = htab_create_ggc (10, common_block_die_table_hash
,
18985 common_block_die_table_eq
, NULL
);
18987 com_die_arg
.decl_id
= DECL_UID (com_decl
);
18988 com_die_arg
.die_parent
= context_die
;
18989 com_die
= (dw_die_ref
) htab_find (common_block_die_table
, &com_die_arg
);
18990 loc
= loc_list_from_tree (com_decl
, 2);
18991 if (com_die
== NULL
)
18994 = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (com_decl
));
18997 com_die
= new_die (DW_TAG_common_block
, context_die
, decl
);
18998 add_name_and_src_coords_attributes (com_die
, com_decl
);
19001 add_AT_location_description (com_die
, DW_AT_location
, loc
);
19002 /* Avoid sharing the same loc descriptor between
19003 DW_TAG_common_block and DW_TAG_variable. */
19004 loc
= loc_list_from_tree (com_decl
, 2);
19006 else if (DECL_EXTERNAL (decl
))
19007 add_AT_flag (com_die
, DW_AT_declaration
, 1);
19008 add_pubname_string (cnam
, com_die
); /* ??? needed? */
19009 com_die
->decl_id
= DECL_UID (com_decl
);
19010 slot
= htab_find_slot (common_block_die_table
, com_die
, INSERT
);
19011 *slot
= (void *) com_die
;
19013 else if (get_AT (com_die
, DW_AT_location
) == NULL
&& loc
)
19015 add_AT_location_description (com_die
, DW_AT_location
, loc
);
19016 loc
= loc_list_from_tree (com_decl
, 2);
19017 remove_AT (com_die
, DW_AT_declaration
);
19019 var_die
= new_die (DW_TAG_variable
, com_die
, decl
);
19020 add_name_and_src_coords_attributes (var_die
, decl
);
19021 add_type_attribute (var_die
, TREE_TYPE (decl
), TREE_READONLY (decl
),
19022 TREE_THIS_VOLATILE (decl
), context_die
);
19023 add_AT_flag (var_die
, DW_AT_external
, 1);
19028 /* Optimize the common case. */
19029 if (single_element_loc_list_p (loc
)
19030 && loc
->expr
->dw_loc_opc
== DW_OP_addr
19031 && loc
->expr
->dw_loc_next
== NULL
19032 && GET_CODE (loc
->expr
->dw_loc_oprnd1
.v
.val_addr
) == SYMBOL_REF
)
19033 loc
->expr
->dw_loc_oprnd1
.v
.val_addr
19034 = plus_constant (loc
->expr
->dw_loc_oprnd1
.v
.val_addr
, off
);
19036 loc_list_plus_const (loc
, off
);
19038 add_AT_location_description (var_die
, DW_AT_location
, loc
);
19040 else if (DECL_EXTERNAL (decl
))
19041 add_AT_flag (var_die
, DW_AT_declaration
, 1);
19042 equate_decl_number_to_die (decl
, var_die
);
19046 /* If the compiler emitted a definition for the DECL declaration
19047 and if we already emitted a DIE for it, don't emit a second
19048 DIE for it again. Allow re-declarations of DECLs that are
19049 inside functions, though. */
19050 if (old_die
&& declaration
&& !local_scope_p (context_die
))
19053 /* For static data members, the declaration in the class is supposed
19054 to have DW_TAG_member tag; the specification should still be
19055 DW_TAG_variable referencing the DW_TAG_member DIE. */
19056 if (declaration
&& class_scope_p (context_die
))
19057 var_die
= new_die (DW_TAG_member
, context_die
, decl
);
19059 var_die
= new_die (DW_TAG_variable
, context_die
, decl
);
19062 if (origin
!= NULL
)
19063 origin_die
= add_abstract_origin_attribute (var_die
, origin
);
19065 /* Loop unrolling can create multiple blocks that refer to the same
19066 static variable, so we must test for the DW_AT_declaration flag.
19068 ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
19069 copy decls and set the DECL_ABSTRACT flag on them instead of
19072 ??? Duplicated blocks have been rewritten to use .debug_ranges.
19074 ??? The declare_in_namespace support causes us to get two DIEs for one
19075 variable, both of which are declarations. We want to avoid considering
19076 one to be a specification, so we must test that this DIE is not a
19078 else if (old_die
&& TREE_STATIC (decl
) && ! declaration
19079 && get_AT_flag (old_die
, DW_AT_declaration
) == 1)
19081 /* This is a definition of a C++ class level static. */
19082 add_AT_specification (var_die
, old_die
);
19083 specialization_p
= true;
19084 if (DECL_NAME (decl
))
19086 expanded_location s
= expand_location (DECL_SOURCE_LOCATION (decl
));
19087 struct dwarf_file_data
* file_index
= lookup_filename (s
.file
);
19089 if (get_AT_file (old_die
, DW_AT_decl_file
) != file_index
)
19090 add_AT_file (var_die
, DW_AT_decl_file
, file_index
);
19092 if (get_AT_unsigned (old_die
, DW_AT_decl_line
) != (unsigned) s
.line
)
19093 add_AT_unsigned (var_die
, DW_AT_decl_line
, s
.line
);
19095 if (old_die
->die_tag
== DW_TAG_member
)
19096 add_linkage_name (var_die
, decl
);
19100 add_name_and_src_coords_attributes (var_die
, decl
);
19102 if ((origin
== NULL
&& !specialization_p
)
19104 && !DECL_ABSTRACT (decl_or_origin
)
19105 && variably_modified_type_p (TREE_TYPE (decl_or_origin
),
19106 decl_function_context
19107 (decl_or_origin
))))
19109 tree type
= TREE_TYPE (decl_or_origin
);
19111 if (decl_by_reference_p (decl_or_origin
))
19112 add_type_attribute (var_die
, TREE_TYPE (type
), 0, 0, context_die
);
19114 add_type_attribute (var_die
, type
, TREE_READONLY (decl_or_origin
),
19115 TREE_THIS_VOLATILE (decl_or_origin
), context_die
);
19118 if (origin
== NULL
&& !specialization_p
)
19120 if (TREE_PUBLIC (decl
))
19121 add_AT_flag (var_die
, DW_AT_external
, 1);
19123 if (DECL_ARTIFICIAL (decl
))
19124 add_AT_flag (var_die
, DW_AT_artificial
, 1);
19126 add_accessibility_attribute (var_die
, decl
);
19130 add_AT_flag (var_die
, DW_AT_declaration
, 1);
19132 if (decl
&& (DECL_ABSTRACT (decl
) || declaration
))
19133 equate_decl_number_to_die (decl
, var_die
);
19136 && (! DECL_ABSTRACT (decl_or_origin
)
19137 /* Local static vars are shared between all clones/inlines,
19138 so emit DW_AT_location on the abstract DIE if DECL_RTL is
19140 || (TREE_CODE (decl_or_origin
) == VAR_DECL
19141 && TREE_STATIC (decl_or_origin
)
19142 && DECL_RTL_SET_P (decl_or_origin
)))
19143 /* When abstract origin already has DW_AT_location attribute, no need
19144 to add it again. */
19145 && (origin_die
== NULL
|| get_AT (origin_die
, DW_AT_location
) == NULL
))
19147 if (TREE_CODE (decl_or_origin
) == VAR_DECL
&& TREE_STATIC (decl_or_origin
)
19148 && !TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl_or_origin
)))
19149 defer_location (decl_or_origin
, var_die
);
19151 add_location_or_const_value_attribute (var_die
,
19154 add_pubname (decl_or_origin
, var_die
);
19157 tree_add_const_value_attribute_for_decl (var_die
, decl_or_origin
);
19160 /* Generate a DIE to represent a named constant. */
19163 gen_const_die (tree decl
, dw_die_ref context_die
)
19165 dw_die_ref const_die
;
19166 tree type
= TREE_TYPE (decl
);
19168 const_die
= new_die (DW_TAG_constant
, context_die
, decl
);
19169 add_name_and_src_coords_attributes (const_die
, decl
);
19170 add_type_attribute (const_die
, type
, 1, 0, context_die
);
19171 if (TREE_PUBLIC (decl
))
19172 add_AT_flag (const_die
, DW_AT_external
, 1);
19173 if (DECL_ARTIFICIAL (decl
))
19174 add_AT_flag (const_die
, DW_AT_artificial
, 1);
19175 tree_add_const_value_attribute_for_decl (const_die
, decl
);
19178 /* Generate a DIE to represent a label identifier. */
19181 gen_label_die (tree decl
, dw_die_ref context_die
)
19183 tree origin
= decl_ultimate_origin (decl
);
19184 dw_die_ref lbl_die
= new_die (DW_TAG_label
, context_die
, decl
);
19186 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
19188 if (origin
!= NULL
)
19189 add_abstract_origin_attribute (lbl_die
, origin
);
19191 add_name_and_src_coords_attributes (lbl_die
, decl
);
19193 if (DECL_ABSTRACT (decl
))
19194 equate_decl_number_to_die (decl
, lbl_die
);
19197 insn
= DECL_RTL_IF_SET (decl
);
19199 /* Deleted labels are programmer specified labels which have been
19200 eliminated because of various optimizations. We still emit them
19201 here so that it is possible to put breakpoints on them. */
19205 && NOTE_KIND (insn
) == NOTE_INSN_DELETED_LABEL
))))
19207 /* When optimization is enabled (via -O) some parts of the compiler
19208 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
19209 represent source-level labels which were explicitly declared by
19210 the user. This really shouldn't be happening though, so catch
19211 it if it ever does happen. */
19212 gcc_assert (!INSN_DELETED_P (insn
));
19214 ASM_GENERATE_INTERNAL_LABEL (label
, "L", CODE_LABEL_NUMBER (insn
));
19215 add_AT_lbl_id (lbl_die
, DW_AT_low_pc
, label
);
19220 /* A helper function for gen_inlined_subroutine_die. Add source coordinate
19221 attributes to the DIE for a block STMT, to describe where the inlined
19222 function was called from. This is similar to add_src_coords_attributes. */
19225 add_call_src_coords_attributes (tree stmt
, dw_die_ref die
)
19227 expanded_location s
= expand_location (BLOCK_SOURCE_LOCATION (stmt
));
19229 if (dwarf_version
>= 3 || !dwarf_strict
)
19231 add_AT_file (die
, DW_AT_call_file
, lookup_filename (s
.file
));
19232 add_AT_unsigned (die
, DW_AT_call_line
, s
.line
);
19237 /* A helper function for gen_lexical_block_die and gen_inlined_subroutine_die.
19238 Add low_pc and high_pc attributes to the DIE for a block STMT. */
19241 add_high_low_attributes (tree stmt
, dw_die_ref die
)
19243 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
19245 if (BLOCK_FRAGMENT_CHAIN (stmt
)
19246 && (dwarf_version
>= 3 || !dwarf_strict
))
19250 if (inlined_function_outer_scope_p (stmt
))
19252 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_BEGIN_LABEL
,
19253 BLOCK_NUMBER (stmt
));
19254 add_AT_lbl_id (die
, DW_AT_entry_pc
, label
);
19257 add_AT_range_list (die
, DW_AT_ranges
, add_ranges (stmt
));
19259 chain
= BLOCK_FRAGMENT_CHAIN (stmt
);
19262 add_ranges (chain
);
19263 chain
= BLOCK_FRAGMENT_CHAIN (chain
);
19270 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_BEGIN_LABEL
,
19271 BLOCK_NUMBER (stmt
));
19272 add_AT_lbl_id (die
, DW_AT_low_pc
, label
);
19273 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_END_LABEL
,
19274 BLOCK_NUMBER (stmt
));
19275 add_AT_lbl_id (die
, DW_AT_high_pc
, label
);
19279 /* Generate a DIE for a lexical block. */
19282 gen_lexical_block_die (tree stmt
, dw_die_ref context_die
, int depth
)
19284 dw_die_ref stmt_die
= new_die (DW_TAG_lexical_block
, context_die
, stmt
);
19286 if (! BLOCK_ABSTRACT (stmt
) && TREE_ASM_WRITTEN (stmt
))
19287 add_high_low_attributes (stmt
, stmt_die
);
19289 decls_for_scope (stmt
, stmt_die
, depth
);
19292 /* Generate a DIE for an inlined subprogram. */
19295 gen_inlined_subroutine_die (tree stmt
, dw_die_ref context_die
, int depth
)
19299 /* The instance of function that is effectively being inlined shall not
19301 gcc_assert (! BLOCK_ABSTRACT (stmt
));
19303 decl
= block_ultimate_origin (stmt
);
19305 /* Emit info for the abstract instance first, if we haven't yet. We
19306 must emit this even if the block is abstract, otherwise when we
19307 emit the block below (or elsewhere), we may end up trying to emit
19308 a die whose origin die hasn't been emitted, and crashing. */
19309 dwarf2out_abstract_function (decl
);
19311 if (! BLOCK_ABSTRACT (stmt
))
19313 dw_die_ref subr_die
19314 = new_die (DW_TAG_inlined_subroutine
, context_die
, stmt
);
19316 add_abstract_origin_attribute (subr_die
, decl
);
19317 if (TREE_ASM_WRITTEN (stmt
))
19318 add_high_low_attributes (stmt
, subr_die
);
19319 add_call_src_coords_attributes (stmt
, subr_die
);
19321 decls_for_scope (stmt
, subr_die
, depth
);
19322 current_function_has_inlines
= 1;
19326 /* Generate a DIE for a field in a record, or structure. */
19329 gen_field_die (tree decl
, dw_die_ref context_die
)
19331 dw_die_ref decl_die
;
19333 if (TREE_TYPE (decl
) == error_mark_node
)
19336 decl_die
= new_die (DW_TAG_member
, context_die
, decl
);
19337 add_name_and_src_coords_attributes (decl_die
, decl
);
19338 add_type_attribute (decl_die
, member_declared_type (decl
),
19339 TREE_READONLY (decl
), TREE_THIS_VOLATILE (decl
),
19342 if (DECL_BIT_FIELD_TYPE (decl
))
19344 add_byte_size_attribute (decl_die
, decl
);
19345 add_bit_size_attribute (decl_die
, decl
);
19346 add_bit_offset_attribute (decl_die
, decl
);
19349 if (TREE_CODE (DECL_FIELD_CONTEXT (decl
)) != UNION_TYPE
)
19350 add_data_member_location_attribute (decl_die
, decl
);
19352 if (DECL_ARTIFICIAL (decl
))
19353 add_AT_flag (decl_die
, DW_AT_artificial
, 1);
19355 add_accessibility_attribute (decl_die
, decl
);
19357 /* Equate decl number to die, so that we can look up this decl later on. */
19358 equate_decl_number_to_die (decl
, decl_die
);
19362 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
19363 Use modified_type_die instead.
19364 We keep this code here just in case these types of DIEs may be needed to
19365 represent certain things in other languages (e.g. Pascal) someday. */
19368 gen_pointer_type_die (tree type
, dw_die_ref context_die
)
19371 = new_die (DW_TAG_pointer_type
, scope_die_for (type
, context_die
), type
);
19373 equate_type_number_to_die (type
, ptr_die
);
19374 add_type_attribute (ptr_die
, TREE_TYPE (type
), 0, 0, context_die
);
19375 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
, PTR_SIZE
);
19378 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
19379 Use modified_type_die instead.
19380 We keep this code here just in case these types of DIEs may be needed to
19381 represent certain things in other languages (e.g. Pascal) someday. */
19384 gen_reference_type_die (tree type
, dw_die_ref context_die
)
19386 dw_die_ref ref_die
, scope_die
= scope_die_for (type
, context_die
);
19388 if (TYPE_REF_IS_RVALUE (type
) && dwarf_version
>= 4)
19389 ref_die
= new_die (DW_TAG_rvalue_reference_type
, scope_die
, type
);
19391 ref_die
= new_die (DW_TAG_reference_type
, scope_die
, type
);
19393 equate_type_number_to_die (type
, ref_die
);
19394 add_type_attribute (ref_die
, TREE_TYPE (type
), 0, 0, context_die
);
19395 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
, PTR_SIZE
);
19399 /* Generate a DIE for a pointer to a member type. */
19402 gen_ptr_to_mbr_type_die (tree type
, dw_die_ref context_die
)
19405 = new_die (DW_TAG_ptr_to_member_type
,
19406 scope_die_for (type
, context_die
), type
);
19408 equate_type_number_to_die (type
, ptr_die
);
19409 add_AT_die_ref (ptr_die
, DW_AT_containing_type
,
19410 lookup_type_die (TYPE_OFFSET_BASETYPE (type
)));
19411 add_type_attribute (ptr_die
, TREE_TYPE (type
), 0, 0, context_die
);
19414 /* Generate the DIE for the compilation unit. */
19417 gen_compile_unit_die (const char *filename
)
19420 char producer
[250];
19421 const char *language_string
= lang_hooks
.name
;
19424 die
= new_die (DW_TAG_compile_unit
, NULL
, NULL
);
19428 add_name_attribute (die
, filename
);
19429 /* Don't add cwd for <built-in>. */
19430 if (!IS_ABSOLUTE_PATH (filename
) && filename
[0] != '<')
19431 add_comp_dir_attribute (die
);
19434 sprintf (producer
, "%s %s", language_string
, version_string
);
19436 #ifdef MIPS_DEBUGGING_INFO
19437 /* The MIPS/SGI compilers place the 'cc' command line options in the producer
19438 string. The SGI debugger looks for -g, -g1, -g2, or -g3; if they do
19439 not appear in the producer string, the debugger reaches the conclusion
19440 that the object file is stripped and has no debugging information.
19441 To get the MIPS/SGI debugger to believe that there is debugging
19442 information in the object file, we add a -g to the producer string. */
19443 if (debug_info_level
> DINFO_LEVEL_TERSE
)
19444 strcat (producer
, " -g");
19447 add_AT_string (die
, DW_AT_producer
, producer
);
19449 language
= DW_LANG_C89
;
19450 if (strcmp (language_string
, "GNU C++") == 0)
19451 language
= DW_LANG_C_plus_plus
;
19452 else if (strcmp (language_string
, "GNU F77") == 0)
19453 language
= DW_LANG_Fortran77
;
19454 else if (strcmp (language_string
, "GNU Pascal") == 0)
19455 language
= DW_LANG_Pascal83
;
19456 else if (dwarf_version
>= 3 || !dwarf_strict
)
19458 if (strcmp (language_string
, "GNU Ada") == 0)
19459 language
= DW_LANG_Ada95
;
19460 else if (strcmp (language_string
, "GNU Fortran") == 0)
19461 language
= DW_LANG_Fortran95
;
19462 else if (strcmp (language_string
, "GNU Java") == 0)
19463 language
= DW_LANG_Java
;
19464 else if (strcmp (language_string
, "GNU Objective-C") == 0)
19465 language
= DW_LANG_ObjC
;
19466 else if (strcmp (language_string
, "GNU Objective-C++") == 0)
19467 language
= DW_LANG_ObjC_plus_plus
;
19470 add_AT_unsigned (die
, DW_AT_language
, language
);
19474 case DW_LANG_Fortran77
:
19475 case DW_LANG_Fortran90
:
19476 case DW_LANG_Fortran95
:
19477 /* Fortran has case insensitive identifiers and the front-end
19478 lowercases everything. */
19479 add_AT_unsigned (die
, DW_AT_identifier_case
, DW_ID_down_case
);
19482 /* The default DW_ID_case_sensitive doesn't need to be specified. */
19488 /* Generate the DIE for a base class. */
19491 gen_inheritance_die (tree binfo
, tree access
, dw_die_ref context_die
)
19493 dw_die_ref die
= new_die (DW_TAG_inheritance
, context_die
, binfo
);
19495 add_type_attribute (die
, BINFO_TYPE (binfo
), 0, 0, context_die
);
19496 add_data_member_location_attribute (die
, binfo
);
19498 if (BINFO_VIRTUAL_P (binfo
))
19499 add_AT_unsigned (die
, DW_AT_virtuality
, DW_VIRTUALITY_virtual
);
19501 if (access
== access_public_node
)
19502 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_public
);
19503 else if (access
== access_protected_node
)
19504 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_protected
);
19507 /* Generate a DIE for a class member. */
19510 gen_member_die (tree type
, dw_die_ref context_die
)
19513 tree binfo
= TYPE_BINFO (type
);
19516 /* If this is not an incomplete type, output descriptions of each of its
19517 members. Note that as we output the DIEs necessary to represent the
19518 members of this record or union type, we will also be trying to output
19519 DIEs to represent the *types* of those members. However the `type'
19520 function (above) will specifically avoid generating type DIEs for member
19521 types *within* the list of member DIEs for this (containing) type except
19522 for those types (of members) which are explicitly marked as also being
19523 members of this (containing) type themselves. The g++ front- end can
19524 force any given type to be treated as a member of some other (containing)
19525 type by setting the TYPE_CONTEXT of the given (member) type to point to
19526 the TREE node representing the appropriate (containing) type. */
19528 /* First output info about the base classes. */
19531 VEC(tree
,gc
) *accesses
= BINFO_BASE_ACCESSES (binfo
);
19535 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base
); i
++)
19536 gen_inheritance_die (base
,
19537 (accesses
? VEC_index (tree
, accesses
, i
)
19538 : access_public_node
), context_die
);
19541 /* Now output info about the data members and type members. */
19542 for (member
= TYPE_FIELDS (type
); member
; member
= TREE_CHAIN (member
))
19544 /* If we thought we were generating minimal debug info for TYPE
19545 and then changed our minds, some of the member declarations
19546 may have already been defined. Don't define them again, but
19547 do put them in the right order. */
19549 child
= lookup_decl_die (member
);
19551 splice_child_die (context_die
, child
);
19553 gen_decl_die (member
, NULL
, context_die
);
19556 /* Now output info about the function members (if any). */
19557 for (member
= TYPE_METHODS (type
); member
; member
= TREE_CHAIN (member
))
19559 /* Don't include clones in the member list. */
19560 if (DECL_ABSTRACT_ORIGIN (member
))
19563 child
= lookup_decl_die (member
);
19565 splice_child_die (context_die
, child
);
19567 gen_decl_die (member
, NULL
, context_die
);
19571 /* Generate a DIE for a structure or union type. If TYPE_DECL_SUPPRESS_DEBUG
19572 is set, we pretend that the type was never defined, so we only get the
19573 member DIEs needed by later specification DIEs. */
19576 gen_struct_or_union_type_die (tree type
, dw_die_ref context_die
,
19577 enum debug_info_usage usage
)
19579 dw_die_ref type_die
= lookup_type_die (type
);
19580 dw_die_ref scope_die
= 0;
19582 int complete
= (TYPE_SIZE (type
)
19583 && (! TYPE_STUB_DECL (type
)
19584 || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type
))));
19585 int ns_decl
= (context_die
&& context_die
->die_tag
== DW_TAG_namespace
);
19586 complete
= complete
&& should_emit_struct_debug (type
, usage
);
19588 if (type_die
&& ! complete
)
19591 if (TYPE_CONTEXT (type
) != NULL_TREE
19592 && (AGGREGATE_TYPE_P (TYPE_CONTEXT (type
))
19593 || TREE_CODE (TYPE_CONTEXT (type
)) == NAMESPACE_DECL
))
19596 scope_die
= scope_die_for (type
, context_die
);
19598 if (! type_die
|| (nested
&& scope_die
== comp_unit_die
))
19599 /* First occurrence of type or toplevel definition of nested class. */
19601 dw_die_ref old_die
= type_die
;
19603 type_die
= new_die (TREE_CODE (type
) == RECORD_TYPE
19604 ? record_type_tag (type
) : DW_TAG_union_type
,
19606 equate_type_number_to_die (type
, type_die
);
19608 add_AT_specification (type_die
, old_die
);
19610 add_name_attribute (type_die
, type_tag (type
));
19613 remove_AT (type_die
, DW_AT_declaration
);
19615 /* Generate child dies for template paramaters. */
19616 if (debug_info_level
> DINFO_LEVEL_TERSE
19617 && COMPLETE_TYPE_P (type
))
19618 gen_generic_params_dies (type
);
19620 /* If this type has been completed, then give it a byte_size attribute and
19621 then give a list of members. */
19622 if (complete
&& !ns_decl
)
19624 /* Prevent infinite recursion in cases where the type of some member of
19625 this type is expressed in terms of this type itself. */
19626 TREE_ASM_WRITTEN (type
) = 1;
19627 add_byte_size_attribute (type_die
, type
);
19628 if (TYPE_STUB_DECL (type
) != NULL_TREE
)
19630 add_src_coords_attributes (type_die
, TYPE_STUB_DECL (type
));
19631 add_accessibility_attribute (type_die
, TYPE_STUB_DECL (type
));
19634 /* If the first reference to this type was as the return type of an
19635 inline function, then it may not have a parent. Fix this now. */
19636 if (type_die
->die_parent
== NULL
)
19637 add_child_die (scope_die
, type_die
);
19639 push_decl_scope (type
);
19640 gen_member_die (type
, type_die
);
19643 /* GNU extension: Record what type our vtable lives in. */
19644 if (TYPE_VFIELD (type
))
19646 tree vtype
= DECL_FCONTEXT (TYPE_VFIELD (type
));
19648 gen_type_die (vtype
, context_die
);
19649 add_AT_die_ref (type_die
, DW_AT_containing_type
,
19650 lookup_type_die (vtype
));
19655 add_AT_flag (type_die
, DW_AT_declaration
, 1);
19657 /* We don't need to do this for function-local types. */
19658 if (TYPE_STUB_DECL (type
)
19659 && ! decl_function_context (TYPE_STUB_DECL (type
)))
19660 VEC_safe_push (tree
, gc
, incomplete_types
, type
);
19663 if (get_AT (type_die
, DW_AT_name
))
19664 add_pubtype (type
, type_die
);
19667 /* Generate a DIE for a subroutine _type_. */
19670 gen_subroutine_type_die (tree type
, dw_die_ref context_die
)
19672 tree return_type
= TREE_TYPE (type
);
19673 dw_die_ref subr_die
19674 = new_die (DW_TAG_subroutine_type
,
19675 scope_die_for (type
, context_die
), type
);
19677 equate_type_number_to_die (type
, subr_die
);
19678 add_prototyped_attribute (subr_die
, type
);
19679 add_type_attribute (subr_die
, return_type
, 0, 0, context_die
);
19680 gen_formal_types_die (type
, subr_die
);
19682 if (get_AT (subr_die
, DW_AT_name
))
19683 add_pubtype (type
, subr_die
);
19686 /* Generate a DIE for a type definition. */
19689 gen_typedef_die (tree decl
, dw_die_ref context_die
)
19691 dw_die_ref type_die
;
19694 if (TREE_ASM_WRITTEN (decl
))
19697 TREE_ASM_WRITTEN (decl
) = 1;
19698 type_die
= new_die (DW_TAG_typedef
, context_die
, decl
);
19699 origin
= decl_ultimate_origin (decl
);
19700 if (origin
!= NULL
)
19701 add_abstract_origin_attribute (type_die
, origin
);
19706 add_name_and_src_coords_attributes (type_die
, decl
);
19707 if (DECL_ORIGINAL_TYPE (decl
))
19709 type
= DECL_ORIGINAL_TYPE (decl
);
19711 gcc_assert (type
!= TREE_TYPE (decl
));
19712 equate_type_number_to_die (TREE_TYPE (decl
), type_die
);
19716 type
= TREE_TYPE (decl
);
19718 if (is_naming_typedef_decl (TYPE_NAME (type
)))
19720 Here, we are in the case of decl being a typedef naming
19721 an anonymous type, e.g:
19722 typedef struct {...} foo;
19723 In that case TREE_TYPE (decl) is not a typedef variant
19724 type and TYPE_NAME of the anonymous type is set to the
19725 TYPE_DECL of the typedef. This construct is emitted by
19728 TYPE is the anonymous struct named by the typedef
19729 DECL. As we need the DW_AT_type attribute of the
19730 DW_TAG_typedef to point to the DIE of TYPE, let's
19731 generate that DIE right away. add_type_attribute
19732 called below will then pick (via lookup_type_die) that
19733 anonymous struct DIE. */
19734 gen_tagged_type_die (type
, context_die
, DINFO_USAGE_DIR_USE
);
19737 add_type_attribute (type_die
, type
, TREE_READONLY (decl
),
19738 TREE_THIS_VOLATILE (decl
), context_die
);
19740 if (is_naming_typedef_decl (decl
))
19741 /* We want that all subsequent calls to lookup_type_die with
19742 TYPE in argument yield the DW_TAG_typedef we have just
19744 equate_type_number_to_die (type
, type_die
);
19746 add_accessibility_attribute (type_die
, decl
);
19749 if (DECL_ABSTRACT (decl
))
19750 equate_decl_number_to_die (decl
, type_die
);
19752 if (get_AT (type_die
, DW_AT_name
))
19753 add_pubtype (decl
, type_die
);
19756 /* Generate a DIE for a struct, class, enum or union type. */
19759 gen_tagged_type_die (tree type
,
19760 dw_die_ref context_die
,
19761 enum debug_info_usage usage
)
19765 if (type
== NULL_TREE
19766 || !is_tagged_type (type
))
19769 /* If this is a nested type whose containing class hasn't been written
19770 out yet, writing it out will cover this one, too. This does not apply
19771 to instantiations of member class templates; they need to be added to
19772 the containing class as they are generated. FIXME: This hurts the
19773 idea of combining type decls from multiple TUs, since we can't predict
19774 what set of template instantiations we'll get. */
19775 if (TYPE_CONTEXT (type
)
19776 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type
))
19777 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type
)))
19779 gen_type_die_with_usage (TYPE_CONTEXT (type
), context_die
, usage
);
19781 if (TREE_ASM_WRITTEN (type
))
19784 /* If that failed, attach ourselves to the stub. */
19785 push_decl_scope (TYPE_CONTEXT (type
));
19786 context_die
= lookup_type_die (TYPE_CONTEXT (type
));
19789 else if (TYPE_CONTEXT (type
) != NULL_TREE
19790 && (TREE_CODE (TYPE_CONTEXT (type
)) == FUNCTION_DECL
))
19792 /* If this type is local to a function that hasn't been written
19793 out yet, use a NULL context for now; it will be fixed up in
19794 decls_for_scope. */
19795 context_die
= lookup_decl_die (TYPE_CONTEXT (type
));
19800 context_die
= declare_in_namespace (type
, context_die
);
19804 if (TREE_CODE (type
) == ENUMERAL_TYPE
)
19806 /* This might have been written out by the call to
19807 declare_in_namespace. */
19808 if (!TREE_ASM_WRITTEN (type
))
19809 gen_enumeration_type_die (type
, context_die
);
19812 gen_struct_or_union_type_die (type
, context_die
, usage
);
19817 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
19818 it up if it is ever completed. gen_*_type_die will set it for us
19819 when appropriate. */
19822 /* Generate a type description DIE. */
19825 gen_type_die_with_usage (tree type
, dw_die_ref context_die
,
19826 enum debug_info_usage usage
)
19828 struct array_descr_info info
;
19830 if (type
== NULL_TREE
|| type
== error_mark_node
)
19833 /* If TYPE is a typedef type variant, let's generate debug info
19834 for the parent typedef which TYPE is a type of. */
19835 if (typedef_variant_p (type
))
19837 if (TREE_ASM_WRITTEN (type
))
19840 /* Prevent broken recursion; we can't hand off to the same type. */
19841 gcc_assert (DECL_ORIGINAL_TYPE (TYPE_NAME (type
)) != type
);
19843 /* Use the DIE of the containing namespace as the parent DIE of
19844 the type description DIE we want to generate. */
19845 if (DECL_CONTEXT (TYPE_NAME (type
))
19846 && TREE_CODE (DECL_CONTEXT (TYPE_NAME (type
))) == NAMESPACE_DECL
)
19847 context_die
= get_context_die (DECL_CONTEXT (TYPE_NAME (type
)));
19849 TREE_ASM_WRITTEN (type
) = 1;
19851 gen_decl_die (TYPE_NAME (type
), NULL
, context_die
);
19855 /* If type is an anonymous tagged type named by a typedef, let's
19856 generate debug info for the typedef. */
19857 if (is_naming_typedef_decl (TYPE_NAME (type
)))
19859 /* Use the DIE of the containing namespace as the parent DIE of
19860 the type description DIE we want to generate. */
19861 if (DECL_CONTEXT (TYPE_NAME (type
))
19862 && TREE_CODE (DECL_CONTEXT (TYPE_NAME (type
))) == NAMESPACE_DECL
)
19863 context_die
= get_context_die (DECL_CONTEXT (TYPE_NAME (type
)));
19865 gen_decl_die (TYPE_NAME (type
), NULL
, context_die
);
19869 /* If this is an array type with hidden descriptor, handle it first. */
19870 if (!TREE_ASM_WRITTEN (type
)
19871 && lang_hooks
.types
.get_array_descr_info
19872 && lang_hooks
.types
.get_array_descr_info (type
, &info
)
19873 && (dwarf_version
>= 3 || !dwarf_strict
))
19875 gen_descr_array_type_die (type
, &info
, context_die
);
19876 TREE_ASM_WRITTEN (type
) = 1;
19880 /* We are going to output a DIE to represent the unqualified version
19881 of this type (i.e. without any const or volatile qualifiers) so
19882 get the main variant (i.e. the unqualified version) of this type
19883 now. (Vectors are special because the debugging info is in the
19884 cloned type itself). */
19885 if (TREE_CODE (type
) != VECTOR_TYPE
)
19886 type
= type_main_variant (type
);
19888 if (TREE_ASM_WRITTEN (type
))
19891 switch (TREE_CODE (type
))
19897 case REFERENCE_TYPE
:
19898 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This
19899 ensures that the gen_type_die recursion will terminate even if the
19900 type is recursive. Recursive types are possible in Ada. */
19901 /* ??? We could perhaps do this for all types before the switch
19903 TREE_ASM_WRITTEN (type
) = 1;
19905 /* For these types, all that is required is that we output a DIE (or a
19906 set of DIEs) to represent the "basis" type. */
19907 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
19908 DINFO_USAGE_IND_USE
);
19912 /* This code is used for C++ pointer-to-data-member types.
19913 Output a description of the relevant class type. */
19914 gen_type_die_with_usage (TYPE_OFFSET_BASETYPE (type
), context_die
,
19915 DINFO_USAGE_IND_USE
);
19917 /* Output a description of the type of the object pointed to. */
19918 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
19919 DINFO_USAGE_IND_USE
);
19921 /* Now output a DIE to represent this pointer-to-data-member type
19923 gen_ptr_to_mbr_type_die (type
, context_die
);
19926 case FUNCTION_TYPE
:
19927 /* Force out return type (in case it wasn't forced out already). */
19928 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
19929 DINFO_USAGE_DIR_USE
);
19930 gen_subroutine_type_die (type
, context_die
);
19934 /* Force out return type (in case it wasn't forced out already). */
19935 gen_type_die_with_usage (TREE_TYPE (type
), context_die
,
19936 DINFO_USAGE_DIR_USE
);
19937 gen_subroutine_type_die (type
, context_die
);
19941 gen_array_type_die (type
, context_die
);
19945 gen_array_type_die (type
, context_die
);
19948 case ENUMERAL_TYPE
:
19951 case QUAL_UNION_TYPE
:
19952 gen_tagged_type_die (type
, context_die
, usage
);
19958 case FIXED_POINT_TYPE
:
19961 /* No DIEs needed for fundamental types. */
19965 /* Just use DW_TAG_unspecified_type. */
19967 dw_die_ref type_die
= lookup_type_die (type
);
19968 if (type_die
== NULL
)
19970 tree name
= TYPE_NAME (type
);
19971 if (TREE_CODE (name
) == TYPE_DECL
)
19972 name
= DECL_NAME (name
);
19973 type_die
= new_die (DW_TAG_unspecified_type
, comp_unit_die
, type
);
19974 add_name_attribute (type_die
, IDENTIFIER_POINTER (name
));
19975 equate_type_number_to_die (type
, type_die
);
19981 gcc_unreachable ();
19984 TREE_ASM_WRITTEN (type
) = 1;
19988 gen_type_die (tree type
, dw_die_ref context_die
)
19990 gen_type_die_with_usage (type
, context_die
, DINFO_USAGE_DIR_USE
);
19993 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
19994 things which are local to the given block. */
19997 gen_block_die (tree stmt
, dw_die_ref context_die
, int depth
)
19999 int must_output_die
= 0;
20002 /* Ignore blocks that are NULL. */
20003 if (stmt
== NULL_TREE
)
20006 inlined_func
= inlined_function_outer_scope_p (stmt
);
20008 /* If the block is one fragment of a non-contiguous block, do not
20009 process the variables, since they will have been done by the
20010 origin block. Do process subblocks. */
20011 if (BLOCK_FRAGMENT_ORIGIN (stmt
))
20015 for (sub
= BLOCK_SUBBLOCKS (stmt
); sub
; sub
= BLOCK_CHAIN (sub
))
20016 gen_block_die (sub
, context_die
, depth
+ 1);
20021 /* Determine if we need to output any Dwarf DIEs at all to represent this
20024 /* The outer scopes for inlinings *must* always be represented. We
20025 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */
20026 must_output_die
= 1;
20029 /* Determine if this block directly contains any "significant"
20030 local declarations which we will need to output DIEs for. */
20031 if (debug_info_level
> DINFO_LEVEL_TERSE
)
20032 /* We are not in terse mode so *any* local declaration counts
20033 as being a "significant" one. */
20034 must_output_die
= ((BLOCK_VARS (stmt
) != NULL
20035 || BLOCK_NUM_NONLOCALIZED_VARS (stmt
))
20036 && (TREE_USED (stmt
)
20037 || TREE_ASM_WRITTEN (stmt
)
20038 || BLOCK_ABSTRACT (stmt
)));
20039 else if ((TREE_USED (stmt
)
20040 || TREE_ASM_WRITTEN (stmt
)
20041 || BLOCK_ABSTRACT (stmt
))
20042 && !dwarf2out_ignore_block (stmt
))
20043 must_output_die
= 1;
20046 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
20047 DIE for any block which contains no significant local declarations at
20048 all. Rather, in such cases we just call `decls_for_scope' so that any
20049 needed Dwarf info for any sub-blocks will get properly generated. Note
20050 that in terse mode, our definition of what constitutes a "significant"
20051 local declaration gets restricted to include only inlined function
20052 instances and local (nested) function definitions. */
20053 if (must_output_die
)
20057 /* If STMT block is abstract, that means we have been called
20058 indirectly from dwarf2out_abstract_function.
20059 That function rightfully marks the descendent blocks (of
20060 the abstract function it is dealing with) as being abstract,
20061 precisely to prevent us from emitting any
20062 DW_TAG_inlined_subroutine DIE as a descendent
20063 of an abstract function instance. So in that case, we should
20064 not call gen_inlined_subroutine_die.
20066 Later though, when cgraph asks dwarf2out to emit info
20067 for the concrete instance of the function decl into which
20068 the concrete instance of STMT got inlined, the later will lead
20069 to the generation of a DW_TAG_inlined_subroutine DIE. */
20070 if (! BLOCK_ABSTRACT (stmt
))
20071 gen_inlined_subroutine_die (stmt
, context_die
, depth
);
20074 gen_lexical_block_die (stmt
, context_die
, depth
);
20077 decls_for_scope (stmt
, context_die
, depth
);
20080 /* Process variable DECL (or variable with origin ORIGIN) within
20081 block STMT and add it to CONTEXT_DIE. */
20083 process_scope_var (tree stmt
, tree decl
, tree origin
, dw_die_ref context_die
)
20086 tree decl_or_origin
= decl
? decl
: origin
;
20088 if (TREE_CODE (decl_or_origin
) == FUNCTION_DECL
)
20089 die
= lookup_decl_die (decl_or_origin
);
20090 else if (TREE_CODE (decl_or_origin
) == TYPE_DECL
20091 && TYPE_DECL_IS_STUB (decl_or_origin
))
20092 die
= lookup_type_die (TREE_TYPE (decl_or_origin
));
20096 if (die
!= NULL
&& die
->die_parent
== NULL
)
20097 add_child_die (context_die
, die
);
20098 else if (TREE_CODE (decl_or_origin
) == IMPORTED_DECL
)
20099 dwarf2out_imported_module_or_decl_1 (decl_or_origin
, DECL_NAME (decl_or_origin
),
20100 stmt
, context_die
);
20102 gen_decl_die (decl
, origin
, context_die
);
20105 /* Generate all of the decls declared within a given scope and (recursively)
20106 all of its sub-blocks. */
20109 decls_for_scope (tree stmt
, dw_die_ref context_die
, int depth
)
20115 /* Ignore NULL blocks. */
20116 if (stmt
== NULL_TREE
)
20119 /* Output the DIEs to represent all of the data objects and typedefs
20120 declared directly within this block but not within any nested
20121 sub-blocks. Also, nested function and tag DIEs have been
20122 generated with a parent of NULL; fix that up now. */
20123 for (decl
= BLOCK_VARS (stmt
); decl
!= NULL
; decl
= TREE_CHAIN (decl
))
20124 process_scope_var (stmt
, decl
, NULL_TREE
, context_die
);
20125 for (i
= 0; i
< BLOCK_NUM_NONLOCALIZED_VARS (stmt
); i
++)
20126 process_scope_var (stmt
, NULL
, BLOCK_NONLOCALIZED_VAR (stmt
, i
),
20129 /* If we're at -g1, we're not interested in subblocks. */
20130 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
20133 /* Output the DIEs to represent all sub-blocks (and the items declared
20134 therein) of this block. */
20135 for (subblocks
= BLOCK_SUBBLOCKS (stmt
);
20137 subblocks
= BLOCK_CHAIN (subblocks
))
20138 gen_block_die (subblocks
, context_die
, depth
+ 1);
20141 /* Is this a typedef we can avoid emitting? */
20144 is_redundant_typedef (const_tree decl
)
20146 if (TYPE_DECL_IS_STUB (decl
))
20149 if (DECL_ARTIFICIAL (decl
)
20150 && DECL_CONTEXT (decl
)
20151 && is_tagged_type (DECL_CONTEXT (decl
))
20152 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl
))) == TYPE_DECL
20153 && DECL_NAME (decl
) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl
))))
20154 /* Also ignore the artificial member typedef for the class name. */
20160 /* Return TRUE if TYPE is a typedef that names a type for linkage
20161 purposes. This kind of typedefs is produced by the C++ FE for
20164 typedef struct {...} foo;
20166 In that case, there is no typedef variant type produced for foo.
20167 Rather, the TREE_TYPE of the TYPE_DECL of foo is the anonymous
20171 is_naming_typedef_decl (const_tree decl
)
20173 if (decl
== NULL_TREE
20174 || TREE_CODE (decl
) != TYPE_DECL
20175 || !is_tagged_type (TREE_TYPE (decl
))
20176 || DECL_IS_BUILTIN (decl
)
20177 || is_redundant_typedef (decl
)
20178 /* It looks like Ada produces TYPE_DECLs that are very similar
20179 to C++ naming typedefs but that have different
20180 semantics. Let's be specific to c++ for now. */
20184 return (DECL_ORIGINAL_TYPE (decl
) == NULL_TREE
20185 && TYPE_NAME (TREE_TYPE (decl
)) == decl
20186 && (TYPE_STUB_DECL (TREE_TYPE (decl
))
20187 != TYPE_NAME (TREE_TYPE (decl
))));
20190 /* Returns the DIE for a context. */
20192 static inline dw_die_ref
20193 get_context_die (tree context
)
20197 /* Find die that represents this context. */
20198 if (TYPE_P (context
))
20199 return force_type_die (TYPE_MAIN_VARIANT (context
));
20201 return force_decl_die (context
);
20203 return comp_unit_die
;
20206 /* Returns the DIE for decl. A DIE will always be returned. */
20209 force_decl_die (tree decl
)
20211 dw_die_ref decl_die
;
20212 unsigned saved_external_flag
;
20213 tree save_fn
= NULL_TREE
;
20214 decl_die
= lookup_decl_die (decl
);
20217 dw_die_ref context_die
= get_context_die (DECL_CONTEXT (decl
));
20219 decl_die
= lookup_decl_die (decl
);
20223 switch (TREE_CODE (decl
))
20225 case FUNCTION_DECL
:
20226 /* Clear current_function_decl, so that gen_subprogram_die thinks
20227 that this is a declaration. At this point, we just want to force
20228 declaration die. */
20229 save_fn
= current_function_decl
;
20230 current_function_decl
= NULL_TREE
;
20231 gen_subprogram_die (decl
, context_die
);
20232 current_function_decl
= save_fn
;
20236 /* Set external flag to force declaration die. Restore it after
20237 gen_decl_die() call. */
20238 saved_external_flag
= DECL_EXTERNAL (decl
);
20239 DECL_EXTERNAL (decl
) = 1;
20240 gen_decl_die (decl
, NULL
, context_die
);
20241 DECL_EXTERNAL (decl
) = saved_external_flag
;
20244 case NAMESPACE_DECL
:
20245 if (dwarf_version
>= 3 || !dwarf_strict
)
20246 dwarf2out_decl (decl
);
20248 /* DWARF2 has neither DW_TAG_module, nor DW_TAG_namespace. */
20249 decl_die
= comp_unit_die
;
20253 gcc_unreachable ();
20256 /* We should be able to find the DIE now. */
20258 decl_die
= lookup_decl_die (decl
);
20259 gcc_assert (decl_die
);
20265 /* Returns the DIE for TYPE, that must not be a base type. A DIE is
20266 always returned. */
20269 force_type_die (tree type
)
20271 dw_die_ref type_die
;
20273 type_die
= lookup_type_die (type
);
20276 dw_die_ref context_die
= get_context_die (TYPE_CONTEXT (type
));
20278 type_die
= modified_type_die (type
, TYPE_READONLY (type
),
20279 TYPE_VOLATILE (type
), context_die
);
20280 gcc_assert (type_die
);
20285 /* Force out any required namespaces to be able to output DECL,
20286 and return the new context_die for it, if it's changed. */
20289 setup_namespace_context (tree thing
, dw_die_ref context_die
)
20291 tree context
= (DECL_P (thing
)
20292 ? DECL_CONTEXT (thing
) : TYPE_CONTEXT (thing
));
20293 if (context
&& TREE_CODE (context
) == NAMESPACE_DECL
)
20294 /* Force out the namespace. */
20295 context_die
= force_decl_die (context
);
20297 return context_die
;
20300 /* Emit a declaration DIE for THING (which is either a DECL or a tagged
20301 type) within its namespace, if appropriate.
20303 For compatibility with older debuggers, namespace DIEs only contain
20304 declarations; all definitions are emitted at CU scope. */
20307 declare_in_namespace (tree thing
, dw_die_ref context_die
)
20309 dw_die_ref ns_context
;
20311 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
20312 return context_die
;
20314 /* If this decl is from an inlined function, then don't try to emit it in its
20315 namespace, as we will get confused. It would have already been emitted
20316 when the abstract instance of the inline function was emitted anyways. */
20317 if (DECL_P (thing
) && DECL_ABSTRACT_ORIGIN (thing
))
20318 return context_die
;
20320 ns_context
= setup_namespace_context (thing
, context_die
);
20322 if (ns_context
!= context_die
)
20326 if (DECL_P (thing
))
20327 gen_decl_die (thing
, NULL
, ns_context
);
20329 gen_type_die (thing
, ns_context
);
20331 return context_die
;
20334 /* Generate a DIE for a namespace or namespace alias. */
20337 gen_namespace_die (tree decl
, dw_die_ref context_die
)
20339 dw_die_ref namespace_die
;
20341 /* Namespace aliases have a DECL_ABSTRACT_ORIGIN of the namespace
20342 they are an alias of. */
20343 if (DECL_ABSTRACT_ORIGIN (decl
) == NULL
)
20345 /* Output a real namespace or module. */
20346 context_die
= setup_namespace_context (decl
, comp_unit_die
);
20347 namespace_die
= new_die (is_fortran ()
20348 ? DW_TAG_module
: DW_TAG_namespace
,
20349 context_die
, decl
);
20350 /* For Fortran modules defined in different CU don't add src coords. */
20351 if (namespace_die
->die_tag
== DW_TAG_module
&& DECL_EXTERNAL (decl
))
20353 const char *name
= dwarf2_name (decl
, 0);
20355 add_name_attribute (namespace_die
, name
);
20358 add_name_and_src_coords_attributes (namespace_die
, decl
);
20359 if (DECL_EXTERNAL (decl
))
20360 add_AT_flag (namespace_die
, DW_AT_declaration
, 1);
20361 equate_decl_number_to_die (decl
, namespace_die
);
20365 /* Output a namespace alias. */
20367 /* Force out the namespace we are an alias of, if necessary. */
20368 dw_die_ref origin_die
20369 = force_decl_die (DECL_ABSTRACT_ORIGIN (decl
));
20371 if (DECL_CONTEXT (decl
) == NULL_TREE
20372 || TREE_CODE (DECL_CONTEXT (decl
)) == NAMESPACE_DECL
)
20373 context_die
= setup_namespace_context (decl
, comp_unit_die
);
20374 /* Now create the namespace alias DIE. */
20375 namespace_die
= new_die (DW_TAG_imported_declaration
, context_die
, decl
);
20376 add_name_and_src_coords_attributes (namespace_die
, decl
);
20377 add_AT_die_ref (namespace_die
, DW_AT_import
, origin_die
);
20378 equate_decl_number_to_die (decl
, namespace_die
);
20382 /* Generate Dwarf debug information for a decl described by DECL. */
20385 gen_decl_die (tree decl
, tree origin
, dw_die_ref context_die
)
20387 tree decl_or_origin
= decl
? decl
: origin
;
20388 tree class_origin
= NULL
, ultimate_origin
;
20390 if (DECL_P (decl_or_origin
) && DECL_IGNORED_P (decl_or_origin
))
20393 switch (TREE_CODE (decl_or_origin
))
20399 if (!is_fortran ())
20401 /* The individual enumerators of an enum type get output when we output
20402 the Dwarf representation of the relevant enum type itself. */
20406 /* Emit its type. */
20407 gen_type_die (TREE_TYPE (decl
), context_die
);
20409 /* And its containing namespace. */
20410 context_die
= declare_in_namespace (decl
, context_die
);
20412 gen_const_die (decl
, context_die
);
20415 case FUNCTION_DECL
:
20416 /* Don't output any DIEs to represent mere function declarations,
20417 unless they are class members or explicit block externs. */
20418 if (DECL_INITIAL (decl_or_origin
) == NULL_TREE
20419 && DECL_CONTEXT (decl_or_origin
) == NULL_TREE
20420 && (current_function_decl
== NULL_TREE
20421 || DECL_ARTIFICIAL (decl_or_origin
)))
20426 /* This doesn't work because the C frontend sets DECL_ABSTRACT_ORIGIN
20427 on local redeclarations of global functions. That seems broken. */
20428 if (current_function_decl
!= decl
)
20429 /* This is only a declaration. */;
20432 /* If we're emitting a clone, emit info for the abstract instance. */
20433 if (origin
|| DECL_ORIGIN (decl
) != decl
)
20434 dwarf2out_abstract_function (origin
20435 ? DECL_ORIGIN (origin
)
20436 : DECL_ABSTRACT_ORIGIN (decl
));
20438 /* If we're emitting an out-of-line copy of an inline function,
20439 emit info for the abstract instance and set up to refer to it. */
20440 else if (cgraph_function_possibly_inlined_p (decl
)
20441 && ! DECL_ABSTRACT (decl
)
20442 && ! class_or_namespace_scope_p (context_die
)
20443 /* dwarf2out_abstract_function won't emit a die if this is just
20444 a declaration. We must avoid setting DECL_ABSTRACT_ORIGIN in
20445 that case, because that works only if we have a die. */
20446 && DECL_INITIAL (decl
) != NULL_TREE
)
20448 dwarf2out_abstract_function (decl
);
20449 set_decl_origin_self (decl
);
20452 /* Otherwise we're emitting the primary DIE for this decl. */
20453 else if (debug_info_level
> DINFO_LEVEL_TERSE
)
20455 /* Before we describe the FUNCTION_DECL itself, make sure that we
20456 have described its return type. */
20457 gen_type_die (TREE_TYPE (TREE_TYPE (decl
)), context_die
);
20459 /* And its virtual context. */
20460 if (DECL_VINDEX (decl
) != NULL_TREE
)
20461 gen_type_die (DECL_CONTEXT (decl
), context_die
);
20463 /* And its containing type. */
20465 origin
= decl_class_context (decl
);
20466 if (origin
!= NULL_TREE
)
20467 gen_type_die_for_member (origin
, decl
, context_die
);
20469 /* And its containing namespace. */
20470 context_die
= declare_in_namespace (decl
, context_die
);
20473 /* Now output a DIE to represent the function itself. */
20475 gen_subprogram_die (decl
, context_die
);
20479 /* If we are in terse mode, don't generate any DIEs to represent any
20480 actual typedefs. */
20481 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
20484 /* In the special case of a TYPE_DECL node representing the declaration
20485 of some type tag, if the given TYPE_DECL is marked as having been
20486 instantiated from some other (original) TYPE_DECL node (e.g. one which
20487 was generated within the original definition of an inline function) we
20488 used to generate a special (abbreviated) DW_TAG_structure_type,
20489 DW_TAG_union_type, or DW_TAG_enumeration_type DIE here. But nothing
20490 should be actually referencing those DIEs, as variable DIEs with that
20491 type would be emitted already in the abstract origin, so it was always
20492 removed during unused type prunning. Don't add anything in this
20494 if (TYPE_DECL_IS_STUB (decl
) && decl_ultimate_origin (decl
) != NULL_TREE
)
20497 if (is_redundant_typedef (decl
))
20498 gen_type_die (TREE_TYPE (decl
), context_die
);
20500 /* Output a DIE to represent the typedef itself. */
20501 gen_typedef_die (decl
, context_die
);
20505 if (debug_info_level
>= DINFO_LEVEL_NORMAL
)
20506 gen_label_die (decl
, context_die
);
20511 /* If we are in terse mode, don't generate any DIEs to represent any
20512 variable declarations or definitions. */
20513 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
20516 /* Output any DIEs that are needed to specify the type of this data
20518 if (decl_by_reference_p (decl_or_origin
))
20519 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin
)), context_die
);
20521 gen_type_die (TREE_TYPE (decl_or_origin
), context_die
);
20523 /* And its containing type. */
20524 class_origin
= decl_class_context (decl_or_origin
);
20525 if (class_origin
!= NULL_TREE
)
20526 gen_type_die_for_member (class_origin
, decl_or_origin
, context_die
);
20528 /* And its containing namespace. */
20529 context_die
= declare_in_namespace (decl_or_origin
, context_die
);
20531 /* Now output the DIE to represent the data object itself. This gets
20532 complicated because of the possibility that the VAR_DECL really
20533 represents an inlined instance of a formal parameter for an inline
20535 ultimate_origin
= decl_ultimate_origin (decl_or_origin
);
20536 if (ultimate_origin
!= NULL_TREE
20537 && TREE_CODE (ultimate_origin
) == PARM_DECL
)
20538 gen_formal_parameter_die (decl
, origin
,
20539 true /* Emit name attribute. */,
20542 gen_variable_die (decl
, origin
, context_die
);
20546 /* Ignore the nameless fields that are used to skip bits but handle C++
20547 anonymous unions and structs. */
20548 if (DECL_NAME (decl
) != NULL_TREE
20549 || TREE_CODE (TREE_TYPE (decl
)) == UNION_TYPE
20550 || TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
)
20552 gen_type_die (member_declared_type (decl
), context_die
);
20553 gen_field_die (decl
, context_die
);
20558 if (DECL_BY_REFERENCE (decl_or_origin
))
20559 gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin
)), context_die
);
20561 gen_type_die (TREE_TYPE (decl_or_origin
), context_die
);
20562 gen_formal_parameter_die (decl
, origin
,
20563 true /* Emit name attribute. */,
20567 case NAMESPACE_DECL
:
20568 case IMPORTED_DECL
:
20569 if (dwarf_version
>= 3 || !dwarf_strict
)
20570 gen_namespace_die (decl
, context_die
);
20574 /* Probably some frontend-internal decl. Assume we don't care. */
20575 gcc_assert ((int)TREE_CODE (decl
) > NUM_TREE_CODES
);
20580 /* Output debug information for global decl DECL. Called from toplev.c after
20581 compilation proper has finished. */
20584 dwarf2out_global_decl (tree decl
)
20586 /* Output DWARF2 information for file-scope tentative data object
20587 declarations, file-scope (extern) function declarations (which
20588 had no corresponding body) and file-scope tagged type declarations
20589 and definitions which have not yet been forced out. */
20590 if (TREE_CODE (decl
) != FUNCTION_DECL
|| !DECL_INITIAL (decl
))
20591 dwarf2out_decl (decl
);
20594 /* Output debug information for type decl DECL. Called from toplev.c
20595 and from language front ends (to record built-in types). */
20597 dwarf2out_type_decl (tree decl
, int local
)
20600 dwarf2out_decl (decl
);
20603 /* Output debug information for imported module or decl DECL.
20604 NAME is non-NULL name in the lexical block if the decl has been renamed.
20605 LEXICAL_BLOCK is the lexical block (which TREE_CODE is a BLOCK)
20606 that DECL belongs to.
20607 LEXICAL_BLOCK_DIE is the DIE of LEXICAL_BLOCK. */
20609 dwarf2out_imported_module_or_decl_1 (tree decl
,
20611 tree lexical_block
,
20612 dw_die_ref lexical_block_die
)
20614 expanded_location xloc
;
20615 dw_die_ref imported_die
= NULL
;
20616 dw_die_ref at_import_die
;
20618 if (TREE_CODE (decl
) == IMPORTED_DECL
)
20620 xloc
= expand_location (DECL_SOURCE_LOCATION (decl
));
20621 decl
= IMPORTED_DECL_ASSOCIATED_DECL (decl
);
20625 xloc
= expand_location (input_location
);
20627 if (TREE_CODE (decl
) == TYPE_DECL
|| TREE_CODE (decl
) == CONST_DECL
)
20629 at_import_die
= force_type_die (TREE_TYPE (decl
));
20630 /* For namespace N { typedef void T; } using N::T; base_type_die
20631 returns NULL, but DW_TAG_imported_declaration requires
20632 the DW_AT_import tag. Force creation of DW_TAG_typedef. */
20633 if (!at_import_die
)
20635 gcc_assert (TREE_CODE (decl
) == TYPE_DECL
);
20636 gen_typedef_die (decl
, get_context_die (DECL_CONTEXT (decl
)));
20637 at_import_die
= lookup_type_die (TREE_TYPE (decl
));
20638 gcc_assert (at_import_die
);
20643 at_import_die
= lookup_decl_die (decl
);
20644 if (!at_import_die
)
20646 /* If we're trying to avoid duplicate debug info, we may not have
20647 emitted the member decl for this field. Emit it now. */
20648 if (TREE_CODE (decl
) == FIELD_DECL
)
20650 tree type
= DECL_CONTEXT (decl
);
20652 if (TYPE_CONTEXT (type
)
20653 && TYPE_P (TYPE_CONTEXT (type
))
20654 && !should_emit_struct_debug (TYPE_CONTEXT (type
),
20655 DINFO_USAGE_DIR_USE
))
20657 gen_type_die_for_member (type
, decl
,
20658 get_context_die (TYPE_CONTEXT (type
)));
20660 at_import_die
= force_decl_die (decl
);
20664 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
20666 if (dwarf_version
>= 3 || !dwarf_strict
)
20667 imported_die
= new_die (DW_TAG_imported_module
,
20674 imported_die
= new_die (DW_TAG_imported_declaration
,
20678 add_AT_file (imported_die
, DW_AT_decl_file
, lookup_filename (xloc
.file
));
20679 add_AT_unsigned (imported_die
, DW_AT_decl_line
, xloc
.line
);
20681 add_AT_string (imported_die
, DW_AT_name
,
20682 IDENTIFIER_POINTER (name
));
20683 add_AT_die_ref (imported_die
, DW_AT_import
, at_import_die
);
20686 /* Output debug information for imported module or decl DECL.
20687 NAME is non-NULL name in context if the decl has been renamed.
20688 CHILD is true if decl is one of the renamed decls as part of
20689 importing whole module. */
20692 dwarf2out_imported_module_or_decl (tree decl
, tree name
, tree context
,
20695 /* dw_die_ref at_import_die; */
20696 dw_die_ref scope_die
;
20698 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
20703 /* To emit DW_TAG_imported_module or DW_TAG_imported_decl, we need two DIEs.
20704 We need decl DIE for reference and scope die. First, get DIE for the decl
20707 /* Get the scope die for decl context. Use comp_unit_die for global module
20708 or decl. If die is not found for non globals, force new die. */
20710 && TYPE_P (context
)
20711 && !should_emit_struct_debug (context
, DINFO_USAGE_DIR_USE
))
20714 if (!(dwarf_version
>= 3 || !dwarf_strict
))
20717 scope_die
= get_context_die (context
);
20721 gcc_assert (scope_die
->die_child
);
20722 gcc_assert (scope_die
->die_child
->die_tag
== DW_TAG_imported_module
);
20723 gcc_assert (TREE_CODE (decl
) != NAMESPACE_DECL
);
20724 scope_die
= scope_die
->die_child
;
20727 /* OK, now we have DIEs for decl as well as scope. Emit imported die. */
20728 dwarf2out_imported_module_or_decl_1 (decl
, name
, context
, scope_die
);
20732 /* Write the debugging output for DECL. */
20735 dwarf2out_decl (tree decl
)
20737 dw_die_ref context_die
= comp_unit_die
;
20739 switch (TREE_CODE (decl
))
20744 case FUNCTION_DECL
:
20745 /* What we would really like to do here is to filter out all mere
20746 file-scope declarations of file-scope functions which are never
20747 referenced later within this translation unit (and keep all of ones
20748 that *are* referenced later on) but we aren't clairvoyant, so we have
20749 no idea which functions will be referenced in the future (i.e. later
20750 on within the current translation unit). So here we just ignore all
20751 file-scope function declarations which are not also definitions. If
20752 and when the debugger needs to know something about these functions,
20753 it will have to hunt around and find the DWARF information associated
20754 with the definition of the function.
20756 We can't just check DECL_EXTERNAL to find out which FUNCTION_DECL
20757 nodes represent definitions and which ones represent mere
20758 declarations. We have to check DECL_INITIAL instead. That's because
20759 the C front-end supports some weird semantics for "extern inline"
20760 function definitions. These can get inlined within the current
20761 translation unit (and thus, we need to generate Dwarf info for their
20762 abstract instances so that the Dwarf info for the concrete inlined
20763 instances can have something to refer to) but the compiler never
20764 generates any out-of-lines instances of such things (despite the fact
20765 that they *are* definitions).
20767 The important point is that the C front-end marks these "extern
20768 inline" functions as DECL_EXTERNAL, but we need to generate DWARF for
20769 them anyway. Note that the C++ front-end also plays some similar games
20770 for inline function definitions appearing within include files which
20771 also contain `#pragma interface' pragmas. */
20772 if (DECL_INITIAL (decl
) == NULL_TREE
)
20775 /* If we're a nested function, initially use a parent of NULL; if we're
20776 a plain function, this will be fixed up in decls_for_scope. If
20777 we're a method, it will be ignored, since we already have a DIE. */
20778 if (decl_function_context (decl
)
20779 /* But if we're in terse mode, we don't care about scope. */
20780 && debug_info_level
> DINFO_LEVEL_TERSE
)
20781 context_die
= NULL
;
20785 /* Ignore this VAR_DECL if it refers to a file-scope extern data object
20786 declaration and if the declaration was never even referenced from
20787 within this entire compilation unit. We suppress these DIEs in
20788 order to save space in the .debug section (by eliminating entries
20789 which are probably useless). Note that we must not suppress
20790 block-local extern declarations (whether used or not) because that
20791 would screw-up the debugger's name lookup mechanism and cause it to
20792 miss things which really ought to be in scope at a given point. */
20793 if (DECL_EXTERNAL (decl
) && !TREE_USED (decl
))
20796 /* For local statics lookup proper context die. */
20797 if (TREE_STATIC (decl
) && decl_function_context (decl
))
20798 context_die
= lookup_decl_die (DECL_CONTEXT (decl
));
20800 /* If we are in terse mode, don't generate any DIEs to represent any
20801 variable declarations or definitions. */
20802 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
20807 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
20809 if (!is_fortran ())
20811 if (TREE_STATIC (decl
) && decl_function_context (decl
))
20812 context_die
= lookup_decl_die (DECL_CONTEXT (decl
));
20815 case NAMESPACE_DECL
:
20816 case IMPORTED_DECL
:
20817 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
20819 if (lookup_decl_die (decl
) != NULL
)
20824 /* Don't emit stubs for types unless they are needed by other DIEs. */
20825 if (TYPE_DECL_SUPPRESS_DEBUG (decl
))
20828 /* Don't bother trying to generate any DIEs to represent any of the
20829 normal built-in types for the language we are compiling. */
20830 if (DECL_IS_BUILTIN (decl
))
20832 /* OK, we need to generate one for `bool' so GDB knows what type
20833 comparisons have. */
20835 && TREE_CODE (TREE_TYPE (decl
)) == BOOLEAN_TYPE
20836 && ! DECL_IGNORED_P (decl
))
20837 modified_type_die (TREE_TYPE (decl
), 0, 0, NULL
);
20842 /* If we are in terse mode, don't generate any DIEs for types. */
20843 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
20846 /* If we're a function-scope tag, initially use a parent of NULL;
20847 this will be fixed up in decls_for_scope. */
20848 if (decl_function_context (decl
))
20849 context_die
= NULL
;
20857 gen_decl_die (decl
, NULL
, context_die
);
20860 /* Write the debugging output for DECL. */
20863 dwarf2out_function_decl (tree decl
)
20865 dwarf2out_decl (decl
);
20867 htab_empty (decl_loc_table
);
20870 /* Output a marker (i.e. a label) for the beginning of the generated code for
20871 a lexical block. */
20874 dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED
,
20875 unsigned int blocknum
)
20877 switch_to_section (current_function_section ());
20878 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, BLOCK_BEGIN_LABEL
, blocknum
);
20881 /* Output a marker (i.e. a label) for the end of the generated code for a
20885 dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED
, unsigned int blocknum
)
20887 switch_to_section (current_function_section ());
20888 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, BLOCK_END_LABEL
, blocknum
);
20891 /* Returns nonzero if it is appropriate not to emit any debugging
20892 information for BLOCK, because it doesn't contain any instructions.
20894 Don't allow this for blocks with nested functions or local classes
20895 as we would end up with orphans, and in the presence of scheduling
20896 we may end up calling them anyway. */
20899 dwarf2out_ignore_block (const_tree block
)
20904 for (decl
= BLOCK_VARS (block
); decl
; decl
= TREE_CHAIN (decl
))
20905 if (TREE_CODE (decl
) == FUNCTION_DECL
20906 || (TREE_CODE (decl
) == TYPE_DECL
&& TYPE_DECL_IS_STUB (decl
)))
20908 for (i
= 0; i
< BLOCK_NUM_NONLOCALIZED_VARS (block
); i
++)
20910 decl
= BLOCK_NONLOCALIZED_VAR (block
, i
);
20911 if (TREE_CODE (decl
) == FUNCTION_DECL
20912 || (TREE_CODE (decl
) == TYPE_DECL
&& TYPE_DECL_IS_STUB (decl
)))
20919 /* Hash table routines for file_hash. */
20922 file_table_eq (const void *p1_p
, const void *p2_p
)
20924 const struct dwarf_file_data
*const p1
=
20925 (const struct dwarf_file_data
*) p1_p
;
20926 const char *const p2
= (const char *) p2_p
;
20927 return strcmp (p1
->filename
, p2
) == 0;
20931 file_table_hash (const void *p_p
)
20933 const struct dwarf_file_data
*const p
= (const struct dwarf_file_data
*) p_p
;
20934 return htab_hash_string (p
->filename
);
20937 /* Lookup FILE_NAME (in the list of filenames that we know about here in
20938 dwarf2out.c) and return its "index". The index of each (known) filename is
20939 just a unique number which is associated with only that one filename. We
20940 need such numbers for the sake of generating labels (in the .debug_sfnames
20941 section) and references to those files numbers (in the .debug_srcinfo
20942 and.debug_macinfo sections). If the filename given as an argument is not
20943 found in our current list, add it to the list and assign it the next
20944 available unique index number. In order to speed up searches, we remember
20945 the index of the filename was looked up last. This handles the majority of
20948 static struct dwarf_file_data
*
20949 lookup_filename (const char *file_name
)
20952 struct dwarf_file_data
* created
;
20954 /* Check to see if the file name that was searched on the previous
20955 call matches this file name. If so, return the index. */
20956 if (file_table_last_lookup
20957 && (file_name
== file_table_last_lookup
->filename
20958 || strcmp (file_table_last_lookup
->filename
, file_name
) == 0))
20959 return file_table_last_lookup
;
20961 /* Didn't match the previous lookup, search the table. */
20962 slot
= htab_find_slot_with_hash (file_table
, file_name
,
20963 htab_hash_string (file_name
), INSERT
);
20965 return (struct dwarf_file_data
*) *slot
;
20967 created
= ggc_alloc_dwarf_file_data ();
20968 created
->filename
= file_name
;
20969 created
->emitted_number
= 0;
20974 /* If the assembler will construct the file table, then translate the compiler
20975 internal file table number into the assembler file table number, and emit
20976 a .file directive if we haven't already emitted one yet. The file table
20977 numbers are different because we prune debug info for unused variables and
20978 types, which may include filenames. */
20981 maybe_emit_file (struct dwarf_file_data
* fd
)
20983 if (! fd
->emitted_number
)
20985 if (last_emitted_file
)
20986 fd
->emitted_number
= last_emitted_file
->emitted_number
+ 1;
20988 fd
->emitted_number
= 1;
20989 last_emitted_file
= fd
;
20991 if (DWARF2_ASM_LINE_DEBUG_INFO
)
20993 fprintf (asm_out_file
, "\t.file %u ", fd
->emitted_number
);
20994 output_quoted_string (asm_out_file
,
20995 remap_debug_filename (fd
->filename
));
20996 fputc ('\n', asm_out_file
);
21000 return fd
->emitted_number
;
21003 /* Schedule generation of a DW_AT_const_value attribute to DIE.
21004 That generation should happen after function debug info has been
21005 generated. The value of the attribute is the constant value of ARG. */
21008 append_entry_to_tmpl_value_parm_die_table (dw_die_ref die
, tree arg
)
21010 die_arg_entry entry
;
21015 if (!tmpl_value_parm_die_table
)
21016 tmpl_value_parm_die_table
21017 = VEC_alloc (die_arg_entry
, gc
, 32);
21021 VEC_safe_push (die_arg_entry
, gc
,
21022 tmpl_value_parm_die_table
,
21026 /* Add a DW_AT_const_value attribute to DIEs that were scheduled
21027 by append_entry_to_tmpl_value_parm_die_table. This function must
21028 be called after function DIEs have been generated. */
21031 gen_remaining_tmpl_value_param_die_attribute (void)
21033 if (tmpl_value_parm_die_table
)
21039 VEC_iterate (die_arg_entry
, tmpl_value_parm_die_table
, i
, e
);
21041 tree_add_const_value_attribute (e
->die
, e
->arg
);
21046 /* Replace DW_AT_name for the decl with name. */
21049 dwarf2out_set_name (tree decl
, tree name
)
21055 die
= TYPE_SYMTAB_DIE (decl
);
21059 dname
= dwarf2_name (name
, 0);
21063 attr
= get_AT (die
, DW_AT_name
);
21066 struct indirect_string_node
*node
;
21068 node
= find_AT_string (dname
);
21069 /* replace the string. */
21070 attr
->dw_attr_val
.v
.val_str
= node
;
21074 add_name_attribute (die
, dname
);
21077 /* Called by the final INSN scan whenever we see a direct function call.
21078 Make an entry into the direct call table, recording the point of call
21079 and a reference to the target function's debug entry. */
21082 dwarf2out_direct_call (tree targ
)
21085 tree origin
= decl_ultimate_origin (targ
);
21087 /* If this is a clone, use the abstract origin as the target. */
21091 e
.poc_label_num
= poc_label_num
++;
21092 e
.poc_decl
= current_function_decl
;
21093 e
.targ_die
= force_decl_die (targ
);
21094 VEC_safe_push (dcall_entry
, gc
, dcall_table
, &e
);
21096 /* Drop a label at the return point to mark the point of call. */
21097 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, "LPOC", e
.poc_label_num
);
21100 /* Returns a hash value for X (which really is a struct vcall_insn). */
21103 vcall_insn_table_hash (const void *x
)
21105 return (hashval_t
) ((const struct vcall_insn
*) x
)->insn_uid
;
21108 /* Return nonzero if insn_uid of struct vcall_insn *X is the same as
21109 insnd_uid of *Y. */
21112 vcall_insn_table_eq (const void *x
, const void *y
)
21114 return (((const struct vcall_insn
*) x
)->insn_uid
21115 == ((const struct vcall_insn
*) y
)->insn_uid
);
21118 /* Associate VTABLE_SLOT with INSN_UID in the VCALL_INSN_TABLE. */
21121 store_vcall_insn (unsigned int vtable_slot
, int insn_uid
)
21123 struct vcall_insn
*item
= ggc_alloc_vcall_insn ();
21124 struct vcall_insn
**slot
;
21127 item
->insn_uid
= insn_uid
;
21128 item
->vtable_slot
= vtable_slot
;
21129 slot
= (struct vcall_insn
**)
21130 htab_find_slot_with_hash (vcall_insn_table
, &item
,
21131 (hashval_t
) insn_uid
, INSERT
);
21135 /* Return the VTABLE_SLOT associated with INSN_UID. */
21137 static unsigned int
21138 lookup_vcall_insn (unsigned int insn_uid
)
21140 struct vcall_insn item
;
21141 struct vcall_insn
*p
;
21143 item
.insn_uid
= insn_uid
;
21144 item
.vtable_slot
= 0;
21145 p
= (struct vcall_insn
*) htab_find_with_hash (vcall_insn_table
,
21147 (hashval_t
) insn_uid
);
21149 return (unsigned int) -1;
21150 return p
->vtable_slot
;
21154 /* Called when lowering indirect calls to RTL. We make a note of INSN_UID
21155 and the OBJ_TYPE_REF_TOKEN from ADDR. For C++ virtual calls, the token
21156 is the vtable slot index that we will need to put in the virtual call
21160 dwarf2out_virtual_call_token (tree addr
, int insn_uid
)
21162 if (is_cxx() && TREE_CODE (addr
) == OBJ_TYPE_REF
)
21164 tree token
= OBJ_TYPE_REF_TOKEN (addr
);
21165 if (TREE_CODE (token
) == INTEGER_CST
)
21166 store_vcall_insn (TREE_INT_CST_LOW (token
), insn_uid
);
21170 /* Called when scheduling RTL, when a CALL_INSN is split. Copies the
21171 OBJ_TYPE_REF_TOKEN previously associated with OLD_INSN and associates it
21175 dwarf2out_copy_call_info (rtx old_insn
, rtx new_insn
)
21177 unsigned int vtable_slot
= lookup_vcall_insn (INSN_UID (old_insn
));
21179 if (vtable_slot
!= (unsigned int) -1)
21180 store_vcall_insn (vtable_slot
, INSN_UID (new_insn
));
21183 /* Called by the final INSN scan whenever we see a virtual function call.
21184 Make an entry into the virtual call table, recording the point of call
21185 and the slot index of the vtable entry used to call the virtual member
21186 function. The slot index was associated with the INSN_UID during the
21187 lowering to RTL. */
21190 dwarf2out_virtual_call (int insn_uid
)
21192 unsigned int vtable_slot
= lookup_vcall_insn (insn_uid
);
21195 if (vtable_slot
== (unsigned int) -1)
21198 e
.poc_label_num
= poc_label_num
++;
21199 e
.vtable_slot
= vtable_slot
;
21200 VEC_safe_push (vcall_entry
, gc
, vcall_table
, &e
);
21202 /* Drop a label at the return point to mark the point of call. */
21203 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, "LPOC", e
.poc_label_num
);
21206 /* Called by the final INSN scan whenever we see a var location. We
21207 use it to drop labels in the right places, and throw the location in
21208 our lookup table. */
21211 dwarf2out_var_location (rtx loc_note
)
21213 char loclabel
[MAX_ARTIFICIAL_LABEL_BYTES
+ 2];
21214 struct var_loc_node
*newloc
;
21216 static const char *last_label
;
21217 static const char *last_postcall_label
;
21218 static bool last_in_cold_section_p
;
21221 if (!DECL_P (NOTE_VAR_LOCATION_DECL (loc_note
)))
21224 next_real
= next_real_insn (loc_note
);
21225 /* If there are no instructions which would be affected by this note,
21226 don't do anything. */
21227 if (next_real
== NULL_RTX
)
21230 /* If there were any real insns between note we processed last time
21231 and this note (or if it is the first note), clear
21232 last_{,postcall_}label so that they are not reused this time. */
21233 if (last_var_location_insn
== NULL_RTX
21234 || last_var_location_insn
!= next_real
21235 || last_in_cold_section_p
!= in_cold_section_p
)
21238 last_postcall_label
= NULL
;
21241 decl
= NOTE_VAR_LOCATION_DECL (loc_note
);
21242 newloc
= add_var_loc_to_decl (decl
, loc_note
,
21243 NOTE_DURING_CALL_P (loc_note
)
21244 ? last_postcall_label
: last_label
);
21245 if (newloc
== NULL
)
21248 /* If there were no real insns between note we processed last time
21249 and this note, use the label we emitted last time. Otherwise
21250 create a new label and emit it. */
21251 if (last_label
== NULL
)
21253 ASM_GENERATE_INTERNAL_LABEL (loclabel
, "LVL", loclabel_num
);
21254 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, "LVL", loclabel_num
);
21256 last_label
= ggc_strdup (loclabel
);
21259 if (!NOTE_DURING_CALL_P (loc_note
))
21260 newloc
->label
= last_label
;
21263 if (!last_postcall_label
)
21265 sprintf (loclabel
, "%s-1", last_label
);
21266 last_postcall_label
= ggc_strdup (loclabel
);
21268 newloc
->label
= last_postcall_label
;
21271 last_var_location_insn
= next_real
;
21272 last_in_cold_section_p
= in_cold_section_p
;
21275 /* We need to reset the locations at the beginning of each
21276 function. We can't do this in the end_function hook, because the
21277 declarations that use the locations won't have been output when
21278 that hook is called. Also compute have_multiple_function_sections here. */
21281 dwarf2out_begin_function (tree fun
)
21283 if (function_section (fun
) != text_section
)
21284 have_multiple_function_sections
= true;
21286 dwarf2out_note_section_used ();
21289 /* Output a label to mark the beginning of a source code line entry
21290 and record information relating to this source line, in
21291 'line_info_table' for later output of the .debug_line section. */
21294 dwarf2out_source_line (unsigned int line
, const char *filename
,
21295 int discriminator
, bool is_stmt
)
21297 static bool last_is_stmt
= true;
21299 if (debug_info_level
>= DINFO_LEVEL_NORMAL
21302 int file_num
= maybe_emit_file (lookup_filename (filename
));
21304 switch_to_section (current_function_section ());
21306 /* If requested, emit something human-readable. */
21307 if (flag_debug_asm
)
21308 fprintf (asm_out_file
, "\t%s %s:%d\n", ASM_COMMENT_START
,
21311 if (DWARF2_ASM_LINE_DEBUG_INFO
)
21313 /* Emit the .loc directive understood by GNU as. */
21314 fprintf (asm_out_file
, "\t.loc %d %d 0", file_num
, line
);
21315 if (is_stmt
!= last_is_stmt
)
21317 fprintf (asm_out_file
, " is_stmt %d", is_stmt
? 1 : 0);
21318 last_is_stmt
= is_stmt
;
21320 if (SUPPORTS_DISCRIMINATOR
&& discriminator
!= 0)
21321 fprintf (asm_out_file
, " discriminator %d", discriminator
);
21322 fputc ('\n', asm_out_file
);
21324 /* Indicate that line number info exists. */
21325 line_info_table_in_use
++;
21327 else if (function_section (current_function_decl
) != text_section
)
21329 dw_separate_line_info_ref line_info
;
21330 targetm
.asm_out
.internal_label (asm_out_file
,
21331 SEPARATE_LINE_CODE_LABEL
,
21332 separate_line_info_table_in_use
);
21334 /* Expand the line info table if necessary. */
21335 if (separate_line_info_table_in_use
21336 == separate_line_info_table_allocated
)
21338 separate_line_info_table_allocated
+= LINE_INFO_TABLE_INCREMENT
;
21339 separate_line_info_table
21340 = GGC_RESIZEVEC (dw_separate_line_info_entry
,
21341 separate_line_info_table
,
21342 separate_line_info_table_allocated
);
21343 memset (separate_line_info_table
21344 + separate_line_info_table_in_use
,
21346 (LINE_INFO_TABLE_INCREMENT
21347 * sizeof (dw_separate_line_info_entry
)));
21350 /* Add the new entry at the end of the line_info_table. */
21352 = &separate_line_info_table
[separate_line_info_table_in_use
++];
21353 line_info
->dw_file_num
= file_num
;
21354 line_info
->dw_line_num
= line
;
21355 line_info
->function
= current_function_funcdef_no
;
21359 dw_line_info_ref line_info
;
21361 targetm
.asm_out
.internal_label (asm_out_file
, LINE_CODE_LABEL
,
21362 line_info_table_in_use
);
21364 /* Expand the line info table if necessary. */
21365 if (line_info_table_in_use
== line_info_table_allocated
)
21367 line_info_table_allocated
+= LINE_INFO_TABLE_INCREMENT
;
21369 = GGC_RESIZEVEC (dw_line_info_entry
, line_info_table
,
21370 line_info_table_allocated
);
21371 memset (line_info_table
+ line_info_table_in_use
, 0,
21372 LINE_INFO_TABLE_INCREMENT
* sizeof (dw_line_info_entry
));
21375 /* Add the new entry at the end of the line_info_table. */
21376 line_info
= &line_info_table
[line_info_table_in_use
++];
21377 line_info
->dw_file_num
= file_num
;
21378 line_info
->dw_line_num
= line
;
21383 /* Record the beginning of a new source file. */
21386 dwarf2out_start_source_file (unsigned int lineno
, const char *filename
)
21388 if (flag_eliminate_dwarf2_dups
&& dwarf_version
< 4)
21390 /* Record the beginning of the file for break_out_includes. */
21391 dw_die_ref bincl_die
;
21393 bincl_die
= new_die (DW_TAG_GNU_BINCL
, comp_unit_die
, NULL
);
21394 add_AT_string (bincl_die
, DW_AT_name
, remap_debug_filename (filename
));
21397 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
21399 int file_num
= maybe_emit_file (lookup_filename (filename
));
21401 switch_to_section (debug_macinfo_section
);
21402 dw2_asm_output_data (1, DW_MACINFO_start_file
, "Start new file");
21403 dw2_asm_output_data_uleb128 (lineno
, "Included from line number %d",
21406 dw2_asm_output_data_uleb128 (file_num
, "file %s", filename
);
21410 /* Record the end of a source file. */
21413 dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED
)
21415 if (flag_eliminate_dwarf2_dups
&& dwarf_version
< 4)
21416 /* Record the end of the file for break_out_includes. */
21417 new_die (DW_TAG_GNU_EINCL
, comp_unit_die
, NULL
);
21419 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
21421 switch_to_section (debug_macinfo_section
);
21422 dw2_asm_output_data (1, DW_MACINFO_end_file
, "End file");
21426 /* Called from debug_define in toplev.c. The `buffer' parameter contains
21427 the tail part of the directive line, i.e. the part which is past the
21428 initial whitespace, #, whitespace, directive-name, whitespace part. */
21431 dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED
,
21432 const char *buffer ATTRIBUTE_UNUSED
)
21434 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
21436 switch_to_section (debug_macinfo_section
);
21437 dw2_asm_output_data (1, DW_MACINFO_define
, "Define macro");
21438 dw2_asm_output_data_uleb128 (lineno
, "At line number %d", lineno
);
21439 dw2_asm_output_nstring (buffer
, -1, "The macro");
21443 /* Called from debug_undef in toplev.c. The `buffer' parameter contains
21444 the tail part of the directive line, i.e. the part which is past the
21445 initial whitespace, #, whitespace, directive-name, whitespace part. */
21448 dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED
,
21449 const char *buffer ATTRIBUTE_UNUSED
)
21451 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
21453 switch_to_section (debug_macinfo_section
);
21454 dw2_asm_output_data (1, DW_MACINFO_undef
, "Undefine macro");
21455 dw2_asm_output_data_uleb128 (lineno
, "At line number %d", lineno
);
21456 dw2_asm_output_nstring (buffer
, -1, "The macro");
21460 /* Set up for Dwarf output at the start of compilation. */
21463 dwarf2out_init (const char *filename ATTRIBUTE_UNUSED
)
21465 /* Allocate the file_table. */
21466 file_table
= htab_create_ggc (50, file_table_hash
,
21467 file_table_eq
, NULL
);
21469 /* Allocate the decl_die_table. */
21470 decl_die_table
= htab_create_ggc (10, decl_die_table_hash
,
21471 decl_die_table_eq
, NULL
);
21473 /* Allocate the decl_loc_table. */
21474 decl_loc_table
= htab_create_ggc (10, decl_loc_table_hash
,
21475 decl_loc_table_eq
, NULL
);
21477 /* Allocate the initial hunk of the decl_scope_table. */
21478 decl_scope_table
= VEC_alloc (tree
, gc
, 256);
21480 /* Allocate the initial hunk of the abbrev_die_table. */
21481 abbrev_die_table
= ggc_alloc_cleared_vec_dw_die_ref
21482 (ABBREV_DIE_TABLE_INCREMENT
);
21483 abbrev_die_table_allocated
= ABBREV_DIE_TABLE_INCREMENT
;
21484 /* Zero-th entry is allocated, but unused. */
21485 abbrev_die_table_in_use
= 1;
21487 /* Allocate the initial hunk of the line_info_table. */
21488 line_info_table
= ggc_alloc_cleared_vec_dw_line_info_entry
21489 (LINE_INFO_TABLE_INCREMENT
);
21490 line_info_table_allocated
= LINE_INFO_TABLE_INCREMENT
;
21492 /* Zero-th entry is allocated, but unused. */
21493 line_info_table_in_use
= 1;
21495 /* Allocate the pubtypes and pubnames vectors. */
21496 pubname_table
= VEC_alloc (pubname_entry
, gc
, 32);
21497 pubtype_table
= VEC_alloc (pubname_entry
, gc
, 32);
21499 /* Allocate the table that maps insn UIDs to vtable slot indexes. */
21500 vcall_insn_table
= htab_create_ggc (10, vcall_insn_table_hash
,
21501 vcall_insn_table_eq
, NULL
);
21503 /* Generate the initial DIE for the .debug section. Note that the (string)
21504 value given in the DW_AT_name attribute of the DW_TAG_compile_unit DIE
21505 will (typically) be a relative pathname and that this pathname should be
21506 taken as being relative to the directory from which the compiler was
21507 invoked when the given (base) source file was compiled. We will fill
21508 in this value in dwarf2out_finish. */
21509 comp_unit_die
= gen_compile_unit_die (NULL
);
21511 incomplete_types
= VEC_alloc (tree
, gc
, 64);
21513 used_rtx_array
= VEC_alloc (rtx
, gc
, 32);
21515 debug_info_section
= get_section (DEBUG_INFO_SECTION
,
21516 SECTION_DEBUG
, NULL
);
21517 debug_abbrev_section
= get_section (DEBUG_ABBREV_SECTION
,
21518 SECTION_DEBUG
, NULL
);
21519 debug_aranges_section
= get_section (DEBUG_ARANGES_SECTION
,
21520 SECTION_DEBUG
, NULL
);
21521 debug_macinfo_section
= get_section (DEBUG_MACINFO_SECTION
,
21522 SECTION_DEBUG
, NULL
);
21523 debug_line_section
= get_section (DEBUG_LINE_SECTION
,
21524 SECTION_DEBUG
, NULL
);
21525 debug_loc_section
= get_section (DEBUG_LOC_SECTION
,
21526 SECTION_DEBUG
, NULL
);
21527 debug_pubnames_section
= get_section (DEBUG_PUBNAMES_SECTION
,
21528 SECTION_DEBUG
, NULL
);
21529 debug_pubtypes_section
= get_section (DEBUG_PUBTYPES_SECTION
,
21530 SECTION_DEBUG
, NULL
);
21531 debug_dcall_section
= get_section (DEBUG_DCALL_SECTION
,
21532 SECTION_DEBUG
, NULL
);
21533 debug_vcall_section
= get_section (DEBUG_VCALL_SECTION
,
21534 SECTION_DEBUG
, NULL
);
21535 debug_str_section
= get_section (DEBUG_STR_SECTION
,
21536 DEBUG_STR_SECTION_FLAGS
, NULL
);
21537 debug_ranges_section
= get_section (DEBUG_RANGES_SECTION
,
21538 SECTION_DEBUG
, NULL
);
21539 debug_frame_section
= get_section (DEBUG_FRAME_SECTION
,
21540 SECTION_DEBUG
, NULL
);
21542 ASM_GENERATE_INTERNAL_LABEL (text_end_label
, TEXT_END_LABEL
, 0);
21543 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label
,
21544 DEBUG_ABBREV_SECTION_LABEL
, 0);
21545 ASM_GENERATE_INTERNAL_LABEL (text_section_label
, TEXT_SECTION_LABEL
, 0);
21546 ASM_GENERATE_INTERNAL_LABEL (cold_text_section_label
,
21547 COLD_TEXT_SECTION_LABEL
, 0);
21548 ASM_GENERATE_INTERNAL_LABEL (cold_end_label
, COLD_END_LABEL
, 0);
21550 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label
,
21551 DEBUG_INFO_SECTION_LABEL
, 0);
21552 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label
,
21553 DEBUG_LINE_SECTION_LABEL
, 0);
21554 ASM_GENERATE_INTERNAL_LABEL (ranges_section_label
,
21555 DEBUG_RANGES_SECTION_LABEL
, 0);
21556 switch_to_section (debug_abbrev_section
);
21557 ASM_OUTPUT_LABEL (asm_out_file
, abbrev_section_label
);
21558 switch_to_section (debug_info_section
);
21559 ASM_OUTPUT_LABEL (asm_out_file
, debug_info_section_label
);
21560 switch_to_section (debug_line_section
);
21561 ASM_OUTPUT_LABEL (asm_out_file
, debug_line_section_label
);
21563 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
21565 switch_to_section (debug_macinfo_section
);
21566 ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label
,
21567 DEBUG_MACINFO_SECTION_LABEL
, 0);
21568 ASM_OUTPUT_LABEL (asm_out_file
, macinfo_section_label
);
21571 switch_to_section (text_section
);
21572 ASM_OUTPUT_LABEL (asm_out_file
, text_section_label
);
21573 if (flag_reorder_blocks_and_partition
)
21575 cold_text_section
= unlikely_text_section ();
21576 switch_to_section (cold_text_section
);
21577 ASM_OUTPUT_LABEL (asm_out_file
, cold_text_section_label
);
21582 /* Called before cgraph_optimize starts outputtting functions, variables
21583 and toplevel asms into assembly. */
21586 dwarf2out_assembly_start (void)
21588 if (HAVE_GAS_CFI_SECTIONS_DIRECTIVE
&& dwarf2out_do_cfi_asm ())
21590 #ifndef TARGET_UNWIND_INFO
21591 if (USING_SJLJ_EXCEPTIONS
|| (!flag_unwind_tables
&& !flag_exceptions
))
21593 fprintf (asm_out_file
, "\t.cfi_sections\t.debug_frame\n");
21597 /* A helper function for dwarf2out_finish called through
21598 htab_traverse. Emit one queued .debug_str string. */
21601 output_indirect_string (void **h
, void *v ATTRIBUTE_UNUSED
)
21603 struct indirect_string_node
*node
= (struct indirect_string_node
*) *h
;
21605 if (node
->label
&& node
->refcount
)
21607 switch_to_section (debug_str_section
);
21608 ASM_OUTPUT_LABEL (asm_out_file
, node
->label
);
21609 assemble_string (node
->str
, strlen (node
->str
) + 1);
21615 #if ENABLE_ASSERT_CHECKING
21616 /* Verify that all marks are clear. */
21619 verify_marks_clear (dw_die_ref die
)
21623 gcc_assert (! die
->die_mark
);
21624 FOR_EACH_CHILD (die
, c
, verify_marks_clear (c
));
21626 #endif /* ENABLE_ASSERT_CHECKING */
21628 /* Clear the marks for a die and its children.
21629 Be cool if the mark isn't set. */
21632 prune_unmark_dies (dw_die_ref die
)
21638 FOR_EACH_CHILD (die
, c
, prune_unmark_dies (c
));
21641 /* Given DIE that we're marking as used, find any other dies
21642 it references as attributes and mark them as used. */
21645 prune_unused_types_walk_attribs (dw_die_ref die
)
21650 for (ix
= 0; VEC_iterate (dw_attr_node
, die
->die_attr
, ix
, a
); ix
++)
21652 if (a
->dw_attr_val
.val_class
== dw_val_class_die_ref
)
21654 /* A reference to another DIE.
21655 Make sure that it will get emitted.
21656 If it was broken out into a comdat group, don't follow it. */
21657 if (dwarf_version
< 4
21658 || a
->dw_attr
== DW_AT_specification
21659 || a
->dw_attr_val
.v
.val_die_ref
.die
->die_id
.die_type_node
== NULL
)
21660 prune_unused_types_mark (a
->dw_attr_val
.v
.val_die_ref
.die
, 1);
21662 /* Set the string's refcount to 0 so that prune_unused_types_mark
21663 accounts properly for it. */
21664 if (AT_class (a
) == dw_val_class_str
)
21665 a
->dw_attr_val
.v
.val_str
->refcount
= 0;
21670 /* Mark DIE as being used. If DOKIDS is true, then walk down
21671 to DIE's children. */
21674 prune_unused_types_mark (dw_die_ref die
, int dokids
)
21678 if (die
->die_mark
== 0)
21680 /* We haven't done this node yet. Mark it as used. */
21683 /* We also have to mark its parents as used.
21684 (But we don't want to mark our parents' kids due to this.) */
21685 if (die
->die_parent
)
21686 prune_unused_types_mark (die
->die_parent
, 0);
21688 /* Mark any referenced nodes. */
21689 prune_unused_types_walk_attribs (die
);
21691 /* If this node is a specification,
21692 also mark the definition, if it exists. */
21693 if (get_AT_flag (die
, DW_AT_declaration
) && die
->die_definition
)
21694 prune_unused_types_mark (die
->die_definition
, 1);
21697 if (dokids
&& die
->die_mark
!= 2)
21699 /* We need to walk the children, but haven't done so yet.
21700 Remember that we've walked the kids. */
21703 /* If this is an array type, we need to make sure our
21704 kids get marked, even if they're types. If we're
21705 breaking out types into comdat sections, do this
21706 for all type definitions. */
21707 if (die
->die_tag
== DW_TAG_array_type
21708 || (dwarf_version
>= 4
21709 && is_type_die (die
) && ! is_declaration_die (die
)))
21710 FOR_EACH_CHILD (die
, c
, prune_unused_types_mark (c
, 1));
21712 FOR_EACH_CHILD (die
, c
, prune_unused_types_walk (c
));
21716 /* For local classes, look if any static member functions were emitted
21717 and if so, mark them. */
21720 prune_unused_types_walk_local_classes (dw_die_ref die
)
21724 if (die
->die_mark
== 2)
21727 switch (die
->die_tag
)
21729 case DW_TAG_structure_type
:
21730 case DW_TAG_union_type
:
21731 case DW_TAG_class_type
:
21734 case DW_TAG_subprogram
:
21735 if (!get_AT_flag (die
, DW_AT_declaration
)
21736 || die
->die_definition
!= NULL
)
21737 prune_unused_types_mark (die
, 1);
21744 /* Mark children. */
21745 FOR_EACH_CHILD (die
, c
, prune_unused_types_walk_local_classes (c
));
21748 /* Walk the tree DIE and mark types that we actually use. */
21751 prune_unused_types_walk (dw_die_ref die
)
21755 /* Don't do anything if this node is already marked and
21756 children have been marked as well. */
21757 if (die
->die_mark
== 2)
21760 switch (die
->die_tag
)
21762 case DW_TAG_structure_type
:
21763 case DW_TAG_union_type
:
21764 case DW_TAG_class_type
:
21765 if (die
->die_perennial_p
)
21768 for (c
= die
->die_parent
; c
; c
= c
->die_parent
)
21769 if (c
->die_tag
== DW_TAG_subprogram
)
21772 /* Finding used static member functions inside of classes
21773 is needed just for local classes, because for other classes
21774 static member function DIEs with DW_AT_specification
21775 are emitted outside of the DW_TAG_*_type. If we ever change
21776 it, we'd need to call this even for non-local classes. */
21778 prune_unused_types_walk_local_classes (die
);
21780 /* It's a type node --- don't mark it. */
21783 case DW_TAG_const_type
:
21784 case DW_TAG_packed_type
:
21785 case DW_TAG_pointer_type
:
21786 case DW_TAG_reference_type
:
21787 case DW_TAG_rvalue_reference_type
:
21788 case DW_TAG_volatile_type
:
21789 case DW_TAG_typedef
:
21790 case DW_TAG_array_type
:
21791 case DW_TAG_interface_type
:
21792 case DW_TAG_friend
:
21793 case DW_TAG_variant_part
:
21794 case DW_TAG_enumeration_type
:
21795 case DW_TAG_subroutine_type
:
21796 case DW_TAG_string_type
:
21797 case DW_TAG_set_type
:
21798 case DW_TAG_subrange_type
:
21799 case DW_TAG_ptr_to_member_type
:
21800 case DW_TAG_file_type
:
21801 if (die
->die_perennial_p
)
21804 /* It's a type node --- don't mark it. */
21808 /* Mark everything else. */
21812 if (die
->die_mark
== 0)
21816 /* Now, mark any dies referenced from here. */
21817 prune_unused_types_walk_attribs (die
);
21822 /* Mark children. */
21823 FOR_EACH_CHILD (die
, c
, prune_unused_types_walk (c
));
21826 /* Increment the string counts on strings referred to from DIE's
21830 prune_unused_types_update_strings (dw_die_ref die
)
21835 for (ix
= 0; VEC_iterate (dw_attr_node
, die
->die_attr
, ix
, a
); ix
++)
21836 if (AT_class (a
) == dw_val_class_str
)
21838 struct indirect_string_node
*s
= a
->dw_attr_val
.v
.val_str
;
21840 /* Avoid unnecessarily putting strings that are used less than
21841 twice in the hash table. */
21843 == ((DEBUG_STR_SECTION_FLAGS
& SECTION_MERGE
) ? 1 : 2))
21846 slot
= htab_find_slot_with_hash (debug_str_hash
, s
->str
,
21847 htab_hash_string (s
->str
),
21849 gcc_assert (*slot
== NULL
);
21855 /* Remove from the tree DIE any dies that aren't marked. */
21858 prune_unused_types_prune (dw_die_ref die
)
21862 gcc_assert (die
->die_mark
);
21863 prune_unused_types_update_strings (die
);
21865 if (! die
->die_child
)
21868 c
= die
->die_child
;
21870 dw_die_ref prev
= c
;
21871 for (c
= c
->die_sib
; ! c
->die_mark
; c
= c
->die_sib
)
21872 if (c
== die
->die_child
)
21874 /* No marked children between 'prev' and the end of the list. */
21876 /* No marked children at all. */
21877 die
->die_child
= NULL
;
21880 prev
->die_sib
= c
->die_sib
;
21881 die
->die_child
= prev
;
21886 if (c
!= prev
->die_sib
)
21888 prune_unused_types_prune (c
);
21889 } while (c
!= die
->die_child
);
21892 /* A helper function for dwarf2out_finish called through
21893 htab_traverse. Clear .debug_str strings that we haven't already
21894 decided to emit. */
21897 prune_indirect_string (void **h
, void *v ATTRIBUTE_UNUSED
)
21899 struct indirect_string_node
*node
= (struct indirect_string_node
*) *h
;
21901 if (!node
->label
|| !node
->refcount
)
21902 htab_clear_slot (debug_str_hash
, h
);
21907 /* Remove dies representing declarations that we never use. */
21910 prune_unused_types (void)
21913 limbo_die_node
*node
;
21914 comdat_type_node
*ctnode
;
21916 dcall_entry
*dcall
;
21918 #if ENABLE_ASSERT_CHECKING
21919 /* All the marks should already be clear. */
21920 verify_marks_clear (comp_unit_die
);
21921 for (node
= limbo_die_list
; node
; node
= node
->next
)
21922 verify_marks_clear (node
->die
);
21923 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
21924 verify_marks_clear (ctnode
->root_die
);
21925 #endif /* ENABLE_ASSERT_CHECKING */
21927 /* Mark types that are used in global variables. */
21928 premark_types_used_by_global_vars ();
21930 /* Set the mark on nodes that are actually used. */
21931 prune_unused_types_walk (comp_unit_die
);
21932 for (node
= limbo_die_list
; node
; node
= node
->next
)
21933 prune_unused_types_walk (node
->die
);
21934 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
21936 prune_unused_types_walk (ctnode
->root_die
);
21937 prune_unused_types_mark (ctnode
->type_die
, 1);
21940 /* Also set the mark on nodes referenced from the
21941 pubname_table or arange_table. */
21942 for (i
= 0; VEC_iterate (pubname_entry
, pubname_table
, i
, pub
); i
++)
21943 prune_unused_types_mark (pub
->die
, 1);
21944 for (i
= 0; i
< arange_table_in_use
; i
++)
21945 prune_unused_types_mark (arange_table
[i
], 1);
21947 /* Mark nodes referenced from the direct call table. */
21948 for (i
= 0; VEC_iterate (dcall_entry
, dcall_table
, i
, dcall
); i
++)
21949 prune_unused_types_mark (dcall
->targ_die
, 1);
21951 /* Get rid of nodes that aren't marked; and update the string counts. */
21952 if (debug_str_hash
&& debug_str_hash_forced
)
21953 htab_traverse (debug_str_hash
, prune_indirect_string
, NULL
);
21954 else if (debug_str_hash
)
21955 htab_empty (debug_str_hash
);
21956 prune_unused_types_prune (comp_unit_die
);
21957 for (node
= limbo_die_list
; node
; node
= node
->next
)
21958 prune_unused_types_prune (node
->die
);
21959 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
21960 prune_unused_types_prune (ctnode
->root_die
);
21962 /* Leave the marks clear. */
21963 prune_unmark_dies (comp_unit_die
);
21964 for (node
= limbo_die_list
; node
; node
= node
->next
)
21965 prune_unmark_dies (node
->die
);
21966 for (ctnode
= comdat_type_list
; ctnode
; ctnode
= ctnode
->next
)
21967 prune_unmark_dies (ctnode
->root_die
);
21970 /* Set the parameter to true if there are any relative pathnames in
21973 file_table_relative_p (void ** slot
, void *param
)
21975 bool *p
= (bool *) param
;
21976 struct dwarf_file_data
*d
= (struct dwarf_file_data
*) *slot
;
21977 if (!IS_ABSOLUTE_PATH (d
->filename
))
21985 /* Routines to manipulate hash table of comdat type units. */
21988 htab_ct_hash (const void *of
)
21991 const comdat_type_node
*const type_node
= (const comdat_type_node
*) of
;
21993 memcpy (&h
, type_node
->signature
, sizeof (h
));
21998 htab_ct_eq (const void *of1
, const void *of2
)
22000 const comdat_type_node
*const type_node_1
= (const comdat_type_node
*) of1
;
22001 const comdat_type_node
*const type_node_2
= (const comdat_type_node
*) of2
;
22003 return (! memcmp (type_node_1
->signature
, type_node_2
->signature
,
22004 DWARF_TYPE_SIGNATURE_SIZE
));
22007 /* Move a DW_AT_{,MIPS_}linkage_name attribute just added to dw_die_ref
22008 to the location it would have been added, should we know its
22009 DECL_ASSEMBLER_NAME when we added other attributes. This will
22010 probably improve compactness of debug info, removing equivalent
22011 abbrevs, and hide any differences caused by deferring the
22012 computation of the assembler name, triggered by e.g. PCH. */
22015 move_linkage_attr (dw_die_ref die
)
22017 unsigned ix
= VEC_length (dw_attr_node
, die
->die_attr
);
22018 dw_attr_node linkage
= *VEC_index (dw_attr_node
, die
->die_attr
, ix
- 1);
22020 gcc_assert (linkage
.dw_attr
== AT_linkage_name
);
22024 dw_attr_node
*prev
= VEC_index (dw_attr_node
, die
->die_attr
, ix
- 1);
22026 if (prev
->dw_attr
== DW_AT_decl_line
|| prev
->dw_attr
== DW_AT_name
)
22030 if (ix
!= VEC_length (dw_attr_node
, die
->die_attr
) - 1)
22032 VEC_pop (dw_attr_node
, die
->die_attr
);
22033 VEC_quick_insert (dw_attr_node
, die
->die_attr
, ix
, &linkage
);
22037 /* Helper function for resolve_addr, attempt to resolve
22038 one CONST_STRING, return non-zero if not successful. Similarly verify that
22039 SYMBOL_REFs refer to variables emitted in the current CU. */
22042 resolve_one_addr (rtx
*addr
, void *data ATTRIBUTE_UNUSED
)
22046 if (GET_CODE (rtl
) == CONST_STRING
)
22048 size_t len
= strlen (XSTR (rtl
, 0)) + 1;
22049 tree t
= build_string (len
, XSTR (rtl
, 0));
22050 tree tlen
= build_int_cst (NULL_TREE
, len
- 1);
22052 = build_array_type (char_type_node
, build_index_type (tlen
));
22053 rtl
= lookup_constant_def (t
);
22054 if (!rtl
|| !MEM_P (rtl
))
22056 rtl
= XEXP (rtl
, 0);
22057 VEC_safe_push (rtx
, gc
, used_rtx_array
, rtl
);
22062 if (GET_CODE (rtl
) == SYMBOL_REF
22063 && SYMBOL_REF_DECL (rtl
)
22064 && !TREE_ASM_WRITTEN (SYMBOL_REF_DECL (rtl
)))
22067 if (GET_CODE (rtl
) == CONST
22068 && for_each_rtx (&XEXP (rtl
, 0), resolve_one_addr
, NULL
))
22074 /* Helper function for resolve_addr, handle one location
22075 expression, return false if at least one CONST_STRING or SYMBOL_REF in
22076 the location list couldn't be resolved. */
22079 resolve_addr_in_expr (dw_loc_descr_ref loc
)
22081 for (; loc
; loc
= loc
->dw_loc_next
)
22082 if ((loc
->dw_loc_opc
== DW_OP_addr
22083 && resolve_one_addr (&loc
->dw_loc_oprnd1
.v
.val_addr
, NULL
))
22084 || (loc
->dw_loc_opc
== DW_OP_implicit_value
22085 && loc
->dw_loc_oprnd2
.val_class
== dw_val_class_addr
22086 && resolve_one_addr (&loc
->dw_loc_oprnd2
.v
.val_addr
, NULL
)))
22091 /* Resolve DW_OP_addr and DW_AT_const_value CONST_STRING arguments to
22092 an address in .rodata section if the string literal is emitted there,
22093 or remove the containing location list or replace DW_AT_const_value
22094 with DW_AT_location and empty location expression, if it isn't found
22095 in .rodata. Similarly for SYMBOL_REFs, keep only those that refer
22096 to something that has been emitted in the current CU. */
22099 resolve_addr (dw_die_ref die
)
22103 dw_loc_list_ref
*curr
;
22106 for (ix
= 0; VEC_iterate (dw_attr_node
, die
->die_attr
, ix
, a
); ix
++)
22107 switch (AT_class (a
))
22109 case dw_val_class_loc_list
:
22110 curr
= AT_loc_list_ptr (a
);
22113 if (!resolve_addr_in_expr ((*curr
)->expr
))
22115 dw_loc_list_ref next
= (*curr
)->dw_loc_next
;
22116 if (next
&& (*curr
)->ll_symbol
)
22118 gcc_assert (!next
->ll_symbol
);
22119 next
->ll_symbol
= (*curr
)->ll_symbol
;
22124 curr
= &(*curr
)->dw_loc_next
;
22126 if (!AT_loc_list (a
))
22128 remove_AT (die
, a
->dw_attr
);
22132 case dw_val_class_loc
:
22133 if (!resolve_addr_in_expr (AT_loc (a
)))
22135 remove_AT (die
, a
->dw_attr
);
22139 case dw_val_class_addr
:
22140 if (a
->dw_attr
== DW_AT_const_value
22141 && resolve_one_addr (&a
->dw_attr_val
.v
.val_addr
, NULL
))
22143 remove_AT (die
, a
->dw_attr
);
22151 FOR_EACH_CHILD (die
, c
, resolve_addr (c
));
22154 /* Output stuff that dwarf requires at the end of every file,
22155 and generate the DWARF-2 debugging info. */
22158 dwarf2out_finish (const char *filename
)
22160 limbo_die_node
*node
, *next_node
;
22161 comdat_type_node
*ctnode
;
22162 htab_t comdat_type_table
;
22163 dw_die_ref die
= 0;
22166 gen_remaining_tmpl_value_param_die_attribute ();
22168 /* Add the name for the main input file now. We delayed this from
22169 dwarf2out_init to avoid complications with PCH. */
22170 add_name_attribute (comp_unit_die
, remap_debug_filename (filename
));
22171 if (!IS_ABSOLUTE_PATH (filename
))
22172 add_comp_dir_attribute (comp_unit_die
);
22173 else if (get_AT (comp_unit_die
, DW_AT_comp_dir
) == NULL
)
22176 htab_traverse (file_table
, file_table_relative_p
, &p
);
22178 add_comp_dir_attribute (comp_unit_die
);
22181 for (i
= 0; i
< VEC_length (deferred_locations
, deferred_locations_list
); i
++)
22183 add_location_or_const_value_attribute (
22184 VEC_index (deferred_locations
, deferred_locations_list
, i
)->die
,
22185 VEC_index (deferred_locations
, deferred_locations_list
, i
)->variable
,
22189 /* Traverse the limbo die list, and add parent/child links. The only
22190 dies without parents that should be here are concrete instances of
22191 inline functions, and the comp_unit_die. We can ignore the comp_unit_die.
22192 For concrete instances, we can get the parent die from the abstract
22194 for (node
= limbo_die_list
; node
; node
= next_node
)
22196 next_node
= node
->next
;
22199 if (die
->die_parent
== NULL
)
22201 dw_die_ref origin
= get_AT_ref (die
, DW_AT_abstract_origin
);
22204 add_child_die (origin
->die_parent
, die
);
22205 else if (die
== comp_unit_die
)
22207 else if (seen_error ())
22208 /* It's OK to be confused by errors in the input. */
22209 add_child_die (comp_unit_die
, die
);
22212 /* In certain situations, the lexical block containing a
22213 nested function can be optimized away, which results
22214 in the nested function die being orphaned. Likewise
22215 with the return type of that nested function. Force
22216 this to be a child of the containing function.
22218 It may happen that even the containing function got fully
22219 inlined and optimized out. In that case we are lost and
22220 assign the empty child. This should not be big issue as
22221 the function is likely unreachable too. */
22222 tree context
= NULL_TREE
;
22224 gcc_assert (node
->created_for
);
22226 if (DECL_P (node
->created_for
))
22227 context
= DECL_CONTEXT (node
->created_for
);
22228 else if (TYPE_P (node
->created_for
))
22229 context
= TYPE_CONTEXT (node
->created_for
);
22231 gcc_assert (context
22232 && (TREE_CODE (context
) == FUNCTION_DECL
22233 || TREE_CODE (context
) == NAMESPACE_DECL
));
22235 origin
= lookup_decl_die (context
);
22237 add_child_die (origin
, die
);
22239 add_child_die (comp_unit_die
, die
);
22244 limbo_die_list
= NULL
;
22246 resolve_addr (comp_unit_die
);
22248 for (node
= deferred_asm_name
; node
; node
= node
->next
)
22250 tree decl
= node
->created_for
;
22251 if (DECL_ASSEMBLER_NAME (decl
) != DECL_NAME (decl
))
22253 add_AT_string (node
->die
, AT_linkage_name
,
22254 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)));
22255 move_linkage_attr (node
->die
);
22259 deferred_asm_name
= NULL
;
22261 /* Walk through the list of incomplete types again, trying once more to
22262 emit full debugging info for them. */
22263 retry_incomplete_types ();
22265 if (flag_eliminate_unused_debug_types
)
22266 prune_unused_types ();
22268 /* Generate separate CUs for each of the include files we've seen.
22269 They will go into limbo_die_list. */
22270 if (flag_eliminate_dwarf2_dups
&& dwarf_version
< 4)
22271 break_out_includes (comp_unit_die
);
22273 /* Generate separate COMDAT sections for type DIEs. */
22274 if (dwarf_version
>= 4)
22276 break_out_comdat_types (comp_unit_die
);
22278 /* Each new type_unit DIE was added to the limbo die list when created.
22279 Since these have all been added to comdat_type_list, clear the
22281 limbo_die_list
= NULL
;
22283 /* For each new comdat type unit, copy declarations for incomplete
22284 types to make the new unit self-contained (i.e., no direct
22285 references to the main compile unit). */
22286 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
22287 copy_decls_for_unworthy_types (ctnode
->root_die
);
22288 copy_decls_for_unworthy_types (comp_unit_die
);
22290 /* In the process of copying declarations from one unit to another,
22291 we may have left some declarations behind that are no longer
22292 referenced. Prune them. */
22293 prune_unused_types ();
22296 /* Traverse the DIE's and add add sibling attributes to those DIE's
22297 that have children. */
22298 add_sibling_attributes (comp_unit_die
);
22299 for (node
= limbo_die_list
; node
; node
= node
->next
)
22300 add_sibling_attributes (node
->die
);
22301 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
22302 add_sibling_attributes (ctnode
->root_die
);
22304 /* Output a terminator label for the .text section. */
22305 switch_to_section (text_section
);
22306 targetm
.asm_out
.internal_label (asm_out_file
, TEXT_END_LABEL
, 0);
22307 if (flag_reorder_blocks_and_partition
)
22309 switch_to_section (unlikely_text_section ());
22310 targetm
.asm_out
.internal_label (asm_out_file
, COLD_END_LABEL
, 0);
22313 /* We can only use the low/high_pc attributes if all of the code was
22315 if (!have_multiple_function_sections
22316 || !(dwarf_version
>= 3 || !dwarf_strict
))
22318 add_AT_lbl_id (comp_unit_die
, DW_AT_low_pc
, text_section_label
);
22319 add_AT_lbl_id (comp_unit_die
, DW_AT_high_pc
, text_end_label
);
22324 unsigned fde_idx
= 0;
22325 bool range_list_added
= false;
22327 /* We need to give .debug_loc and .debug_ranges an appropriate
22328 "base address". Use zero so that these addresses become
22329 absolute. Historically, we've emitted the unexpected
22330 DW_AT_entry_pc instead of DW_AT_low_pc for this purpose.
22331 Emit both to give time for other tools to adapt. */
22332 add_AT_addr (comp_unit_die
, DW_AT_low_pc
, const0_rtx
);
22333 add_AT_addr (comp_unit_die
, DW_AT_entry_pc
, const0_rtx
);
22335 if (text_section_used
)
22336 add_ranges_by_labels (comp_unit_die
, text_section_label
,
22337 text_end_label
, &range_list_added
);
22338 if (flag_reorder_blocks_and_partition
&& cold_text_section_used
)
22339 add_ranges_by_labels (comp_unit_die
, cold_text_section_label
,
22340 cold_end_label
, &range_list_added
);
22342 for (fde_idx
= 0; fde_idx
< fde_table_in_use
; fde_idx
++)
22344 dw_fde_ref fde
= &fde_table
[fde_idx
];
22346 if (fde
->dw_fde_switched_sections
)
22348 if (!fde
->in_std_section
)
22349 add_ranges_by_labels (comp_unit_die
,
22350 fde
->dw_fde_hot_section_label
,
22351 fde
->dw_fde_hot_section_end_label
,
22352 &range_list_added
);
22353 if (!fde
->cold_in_std_section
)
22354 add_ranges_by_labels (comp_unit_die
,
22355 fde
->dw_fde_unlikely_section_label
,
22356 fde
->dw_fde_unlikely_section_end_label
,
22357 &range_list_added
);
22359 else if (!fde
->in_std_section
)
22360 add_ranges_by_labels (comp_unit_die
, fde
->dw_fde_begin
,
22361 fde
->dw_fde_end
, &range_list_added
);
22364 if (range_list_added
)
22368 /* Output location list section if necessary. */
22369 if (have_location_lists
)
22371 /* Output the location lists info. */
22372 switch_to_section (debug_loc_section
);
22373 ASM_GENERATE_INTERNAL_LABEL (loc_section_label
,
22374 DEBUG_LOC_SECTION_LABEL
, 0);
22375 ASM_OUTPUT_LABEL (asm_out_file
, loc_section_label
);
22376 output_location_lists (die
);
22379 if (debug_info_level
>= DINFO_LEVEL_NORMAL
)
22380 add_AT_lineptr (comp_unit_die
, DW_AT_stmt_list
,
22381 debug_line_section_label
);
22383 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
22384 add_AT_macptr (comp_unit_die
, DW_AT_macro_info
, macinfo_section_label
);
22386 /* Output all of the compilation units. We put the main one last so that
22387 the offsets are available to output_pubnames. */
22388 for (node
= limbo_die_list
; node
; node
= node
->next
)
22389 output_comp_unit (node
->die
, 0);
22391 comdat_type_table
= htab_create (100, htab_ct_hash
, htab_ct_eq
, NULL
);
22392 for (ctnode
= comdat_type_list
; ctnode
!= NULL
; ctnode
= ctnode
->next
)
22394 void **slot
= htab_find_slot (comdat_type_table
, ctnode
, INSERT
);
22396 /* Don't output duplicate types. */
22397 if (*slot
!= HTAB_EMPTY_ENTRY
)
22400 /* Add a pointer to the line table for the main compilation unit
22401 so that the debugger can make sense of DW_AT_decl_file
22403 if (debug_info_level
>= DINFO_LEVEL_NORMAL
)
22404 add_AT_lineptr (ctnode
->root_die
, DW_AT_stmt_list
,
22405 debug_line_section_label
);
22407 output_comdat_type_unit (ctnode
);
22410 htab_delete (comdat_type_table
);
22412 /* Output the main compilation unit if non-empty or if .debug_macinfo
22413 has been emitted. */
22414 output_comp_unit (comp_unit_die
, debug_info_level
>= DINFO_LEVEL_VERBOSE
);
22416 /* Output the abbreviation table. */
22417 switch_to_section (debug_abbrev_section
);
22418 output_abbrev_section ();
22420 /* Output public names table if necessary. */
22421 if (!VEC_empty (pubname_entry
, pubname_table
))
22423 switch_to_section (debug_pubnames_section
);
22424 output_pubnames (pubname_table
);
22427 /* Output public types table if necessary. */
22428 /* ??? Only defined by DWARF3, but emitted by Darwin for DWARF2.
22429 It shouldn't hurt to emit it always, since pure DWARF2 consumers
22430 simply won't look for the section. */
22431 if (!VEC_empty (pubname_entry
, pubtype_table
))
22433 switch_to_section (debug_pubtypes_section
);
22434 output_pubnames (pubtype_table
);
22437 /* Output direct and virtual call tables if necessary. */
22438 if (!VEC_empty (dcall_entry
, dcall_table
))
22440 switch_to_section (debug_dcall_section
);
22441 output_dcall_table ();
22443 if (!VEC_empty (vcall_entry
, vcall_table
))
22445 switch_to_section (debug_vcall_section
);
22446 output_vcall_table ();
22449 /* Output the address range information. We only put functions in the arange
22450 table, so don't write it out if we don't have any. */
22451 if (fde_table_in_use
)
22453 switch_to_section (debug_aranges_section
);
22457 /* Output ranges section if necessary. */
22458 if (ranges_table_in_use
)
22460 switch_to_section (debug_ranges_section
);
22461 ASM_OUTPUT_LABEL (asm_out_file
, ranges_section_label
);
22465 /* Output the source line correspondence table. We must do this
22466 even if there is no line information. Otherwise, on an empty
22467 translation unit, we will generate a present, but empty,
22468 .debug_info section. IRIX 6.5 `nm' will then complain when
22469 examining the file. This is done late so that any filenames
22470 used by the debug_info section are marked as 'used'. */
22471 if (! DWARF2_ASM_LINE_DEBUG_INFO
)
22473 switch_to_section (debug_line_section
);
22474 output_line_info ();
22477 /* Have to end the macro section. */
22478 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
22480 switch_to_section (debug_macinfo_section
);
22481 dw2_asm_output_data (1, 0, "End compilation unit");
22484 /* If we emitted any DW_FORM_strp form attribute, output the string
22486 if (debug_str_hash
)
22487 htab_traverse (debug_str_hash
, output_indirect_string
, NULL
);
22491 /* This should never be used, but its address is needed for comparisons. */
22492 const struct gcc_debug_hooks dwarf2_debug_hooks
=
22496 0, /* assembly_start */
22499 0, /* start_source_file */
22500 0, /* end_source_file */
22501 0, /* begin_block */
22503 0, /* ignore_block */
22504 0, /* source_line */
22505 0, /* begin_prologue */
22506 0, /* end_prologue */
22507 0, /* begin_epilogue */
22508 0, /* end_epilogue */
22509 0, /* begin_function */
22510 0, /* end_function */
22511 0, /* function_decl */
22512 0, /* global_decl */
22514 0, /* imported_module_or_decl */
22515 0, /* deferred_inline_function */
22516 0, /* outlining_inline_function */
22518 0, /* handle_pch */
22519 0, /* var_location */
22520 0, /* switch_text_section */
22521 0, /* direct_call */
22522 0, /* virtual_call_token */
22523 0, /* copy_call_info */
22524 0, /* virtual_call */
22526 0 /* start_end_main_source_file */
22529 #endif /* DWARF2_DEBUGGING_INFO */
22531 #include "gt-dwarf2out.h"