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 Free Software Foundation, Inc.
4 Contributed by Gary Funck (gary@intrepid.com).
5 Derived from DWARF 1 implementation of Ron Guilmette (rfg@monkeys.com).
6 Extensively modified by Jason Merrill (jason@cygnus.com).
8 This file is part of GCC.
10 GCC is free software; you can redistribute it and/or modify it under
11 the terms of the GNU General Public License as published by the Free
12 Software Foundation; either version 2, or (at your option) any later
15 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
16 WARRANTY; without even the implied warranty of MERCHANTABILITY or
17 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING. If not, write to the Free
22 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
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
39 #include "coretypes.h"
46 #include "hard-reg-set.h"
48 #include "insn-config.h"
56 #include "dwarf2out.h"
57 #include "dwarf2asm.h"
63 #include "diagnostic.h"
66 #include "langhooks.h"
71 #ifdef DWARF2_DEBUGGING_INFO
72 static void dwarf2out_source_line (unsigned int, const char *);
75 /* DWARF2 Abbreviation Glossary:
76 CFA = Canonical Frame Address
77 a fixed address on the stack which identifies a call frame.
78 We define it to be the value of SP just before the call insn.
79 The CFA register and offset, which may change during the course
80 of the function, are used to calculate its value at runtime.
81 CFI = Call Frame Instruction
82 an instruction for the DWARF2 abstract machine
83 CIE = Common Information Entry
84 information describing information common to one or more FDEs
85 DIE = Debugging Information Entry
86 FDE = Frame Description Entry
87 information describing the stack call frame, in particular,
88 how to restore registers
90 DW_CFA_... = DWARF2 CFA call frame instruction
91 DW_TAG_... = DWARF2 DIE tag */
93 /* Decide whether we want to emit frame unwind information for the current
97 dwarf2out_do_frame (void)
99 return (write_symbols
== DWARF2_DEBUG
100 || write_symbols
== VMS_AND_DWARF2_DEBUG
101 #ifdef DWARF2_FRAME_INFO
104 #ifdef DWARF2_UNWIND_INFO
105 || flag_unwind_tables
106 || (flag_exceptions
&& ! USING_SJLJ_EXCEPTIONS
)
111 /* The size of the target's pointer type. */
113 #define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
116 /* Various versions of targetm.eh_frame_section. Note these must appear
117 outside the DWARF2_DEBUGGING_INFO || DWARF2_UNWIND_INFO macro guards. */
119 /* Version of targetm.eh_frame_section for systems with named sections. */
121 named_section_eh_frame_section (void)
123 #ifdef EH_FRAME_SECTION_NAME
124 #ifdef HAVE_LD_RO_RW_SECTION_MIXING
125 int fde_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0);
126 int per_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
127 int lsda_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
131 || ((fde_encoding
& 0x70) != DW_EH_PE_absptr
132 && (fde_encoding
& 0x70) != DW_EH_PE_aligned
133 && (per_encoding
& 0x70) != DW_EH_PE_absptr
134 && (per_encoding
& 0x70) != DW_EH_PE_aligned
135 && (lsda_encoding
& 0x70) != DW_EH_PE_absptr
136 && (lsda_encoding
& 0x70) != DW_EH_PE_aligned
))
138 named_section_flags (EH_FRAME_SECTION_NAME
, flags
);
140 named_section_flags (EH_FRAME_SECTION_NAME
, SECTION_WRITE
);
145 /* Version of targetm.eh_frame_section for systems using collect2. */
147 collect2_eh_frame_section (void)
149 tree label
= get_file_function_name ('F');
152 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (PTR_SIZE
));
153 targetm
.asm_out
.globalize_label (asm_out_file
, IDENTIFIER_POINTER (label
));
154 ASM_OUTPUT_LABEL (asm_out_file
, IDENTIFIER_POINTER (label
));
157 /* Default version of targetm.eh_frame_section. */
159 default_eh_frame_section (void)
161 #ifdef EH_FRAME_SECTION_NAME
162 named_section_eh_frame_section ();
164 collect2_eh_frame_section ();
168 /* Array of RTXes referenced by the debugging information, which therefore
169 must be kept around forever. */
170 static GTY(()) varray_type used_rtx_varray
;
172 /* A pointer to the base of a list of incomplete types which might be
173 completed at some later time. incomplete_types_list needs to be a VARRAY
174 because we want to tell the garbage collector about it. */
175 static GTY(()) varray_type incomplete_types
;
177 /* A pointer to the base of a table of references to declaration
178 scopes. This table is a display which tracks the nesting
179 of declaration scopes at the current scope and containing
180 scopes. This table is used to find the proper place to
181 define type declaration DIE's. */
182 static GTY(()) varray_type decl_scope_table
;
184 /* How to start an assembler comment. */
185 #ifndef ASM_COMMENT_START
186 #define ASM_COMMENT_START ";#"
189 typedef struct dw_cfi_struct
*dw_cfi_ref
;
190 typedef struct dw_fde_struct
*dw_fde_ref
;
191 typedef union dw_cfi_oprnd_struct
*dw_cfi_oprnd_ref
;
193 /* Call frames are described using a sequence of Call Frame
194 Information instructions. The register number, offset
195 and address fields are provided as possible operands;
196 their use is selected by the opcode field. */
198 enum dw_cfi_oprnd_type
{
200 dw_cfi_oprnd_reg_num
,
206 typedef union dw_cfi_oprnd_struct
GTY(())
208 unsigned long GTY ((tag ("dw_cfi_oprnd_reg_num"))) dw_cfi_reg_num
;
209 HOST_WIDE_INT
GTY ((tag ("dw_cfi_oprnd_offset"))) dw_cfi_offset
;
210 const char * GTY ((tag ("dw_cfi_oprnd_addr"))) dw_cfi_addr
;
211 struct dw_loc_descr_struct
* GTY ((tag ("dw_cfi_oprnd_loc"))) dw_cfi_loc
;
215 typedef struct dw_cfi_struct
GTY(())
217 dw_cfi_ref dw_cfi_next
;
218 enum dwarf_call_frame_info dw_cfi_opc
;
219 dw_cfi_oprnd
GTY ((desc ("dw_cfi_oprnd1_desc (%1.dw_cfi_opc)")))
221 dw_cfi_oprnd
GTY ((desc ("dw_cfi_oprnd2_desc (%1.dw_cfi_opc)")))
226 /* This is how we define the location of the CFA. We use to handle it
227 as REG + OFFSET all the time, but now it can be more complex.
228 It can now be either REG + CFA_OFFSET or *(REG + BASE_OFFSET) + CFA_OFFSET.
229 Instead of passing around REG and OFFSET, we pass a copy
230 of this structure. */
231 typedef struct cfa_loc
GTY(())
234 HOST_WIDE_INT offset
;
235 HOST_WIDE_INT base_offset
;
236 int indirect
; /* 1 if CFA is accessed via a dereference. */
239 /* All call frame descriptions (FDE's) in the GCC generated DWARF
240 refer to a single Common Information Entry (CIE), defined at
241 the beginning of the .debug_frame section. This use of a single
242 CIE obviates the need to keep track of multiple CIE's
243 in the DWARF generation routines below. */
245 typedef struct dw_fde_struct
GTY(())
248 const char *dw_fde_begin
;
249 const char *dw_fde_current_label
;
250 const char *dw_fde_end
;
251 dw_cfi_ref dw_fde_cfi
;
252 unsigned funcdef_number
;
253 unsigned all_throwers_are_sibcalls
: 1;
254 unsigned nothrow
: 1;
255 unsigned uses_eh_lsda
: 1;
259 /* Maximum size (in bytes) of an artificially generated label. */
260 #define MAX_ARTIFICIAL_LABEL_BYTES 30
262 /* The size of addresses as they appear in the Dwarf 2 data.
263 Some architectures use word addresses to refer to code locations,
264 but Dwarf 2 info always uses byte addresses. On such machines,
265 Dwarf 2 addresses need to be larger than the architecture's
267 #ifndef DWARF2_ADDR_SIZE
268 #define DWARF2_ADDR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
271 /* The size in bytes of a DWARF field indicating an offset or length
272 relative to a debug info section, specified to be 4 bytes in the
273 DWARF-2 specification. The SGI/MIPS ABI defines it to be the same
276 #ifndef DWARF_OFFSET_SIZE
277 #define DWARF_OFFSET_SIZE 4
280 /* According to the (draft) DWARF 3 specification, the initial length
281 should either be 4 or 12 bytes. When it's 12 bytes, the first 4
282 bytes are 0xffffffff, followed by the length stored in the next 8
285 However, the SGI/MIPS ABI uses an initial length which is equal to
286 DWARF_OFFSET_SIZE. It is defined (elsewhere) accordingly. */
288 #ifndef DWARF_INITIAL_LENGTH_SIZE
289 #define DWARF_INITIAL_LENGTH_SIZE (DWARF_OFFSET_SIZE == 4 ? 4 : 12)
292 #define DWARF_VERSION 2
294 /* Round SIZE up to the nearest BOUNDARY. */
295 #define DWARF_ROUND(SIZE,BOUNDARY) \
296 ((((SIZE) + (BOUNDARY) - 1) / (BOUNDARY)) * (BOUNDARY))
298 /* Offsets recorded in opcodes are a multiple of this alignment factor. */
299 #ifndef DWARF_CIE_DATA_ALIGNMENT
300 #ifdef STACK_GROWS_DOWNWARD
301 #define DWARF_CIE_DATA_ALIGNMENT (-((int) UNITS_PER_WORD))
303 #define DWARF_CIE_DATA_ALIGNMENT ((int) UNITS_PER_WORD)
307 /* A pointer to the base of a table that contains frame description
308 information for each routine. */
309 static GTY((length ("fde_table_allocated"))) dw_fde_ref fde_table
;
311 /* Number of elements currently allocated for fde_table. */
312 static GTY(()) unsigned fde_table_allocated
;
314 /* Number of elements in fde_table currently in use. */
315 static GTY(()) unsigned fde_table_in_use
;
317 /* Size (in elements) of increments by which we may expand the
319 #define FDE_TABLE_INCREMENT 256
321 /* A list of call frame insns for the CIE. */
322 static GTY(()) dw_cfi_ref cie_cfi_head
;
324 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
325 /* Some DWARF extensions (e.g., MIPS/SGI) implement a subprogram
326 attribute that accelerates the lookup of the FDE associated
327 with the subprogram. This variable holds the table index of the FDE
328 associated with the current function (body) definition. */
329 static unsigned current_funcdef_fde
;
332 struct indirect_string_node
GTY(())
335 unsigned int refcount
;
340 static GTY ((param_is (struct indirect_string_node
))) htab_t debug_str_hash
;
342 static GTY(()) int dw2_string_counter
;
343 static GTY(()) unsigned long dwarf2out_cfi_label_num
;
345 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
347 /* Forward declarations for functions defined in this file. */
349 static char *stripattributes (const char *);
350 static const char *dwarf_cfi_name (unsigned);
351 static dw_cfi_ref
new_cfi (void);
352 static void add_cfi (dw_cfi_ref
*, dw_cfi_ref
);
353 static void add_fde_cfi (const char *, dw_cfi_ref
);
354 static void lookup_cfa_1 (dw_cfi_ref
, dw_cfa_location
*);
355 static void lookup_cfa (dw_cfa_location
*);
356 static void reg_save (const char *, unsigned, unsigned, HOST_WIDE_INT
);
357 static void initial_return_save (rtx
);
358 static HOST_WIDE_INT
stack_adjust_offset (rtx
);
359 static void output_cfi (dw_cfi_ref
, dw_fde_ref
, int);
360 static void output_call_frame_info (int);
361 static void dwarf2out_stack_adjust (rtx
);
362 static void flush_queued_reg_saves (void);
363 static bool clobbers_queued_reg_save (rtx
);
364 static void dwarf2out_frame_debug_expr (rtx
, const char *);
366 /* Support for complex CFA locations. */
367 static void output_cfa_loc (dw_cfi_ref
);
368 static void get_cfa_from_loc_descr (dw_cfa_location
*,
369 struct dw_loc_descr_struct
*);
370 static struct dw_loc_descr_struct
*build_cfa_loc
372 static void def_cfa_1 (const char *, dw_cfa_location
*);
374 /* How to start an assembler comment. */
375 #ifndef ASM_COMMENT_START
376 #define ASM_COMMENT_START ";#"
379 /* Data and reference forms for relocatable data. */
380 #define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
381 #define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
383 #ifndef DEBUG_FRAME_SECTION
384 #define DEBUG_FRAME_SECTION ".debug_frame"
387 #ifndef FUNC_BEGIN_LABEL
388 #define FUNC_BEGIN_LABEL "LFB"
391 #ifndef FUNC_END_LABEL
392 #define FUNC_END_LABEL "LFE"
395 #ifndef FRAME_BEGIN_LABEL
396 #define FRAME_BEGIN_LABEL "Lframe"
398 #define CIE_AFTER_SIZE_LABEL "LSCIE"
399 #define CIE_END_LABEL "LECIE"
400 #define FDE_LABEL "LSFDE"
401 #define FDE_AFTER_SIZE_LABEL "LASFDE"
402 #define FDE_END_LABEL "LEFDE"
403 #define LINE_NUMBER_BEGIN_LABEL "LSLT"
404 #define LINE_NUMBER_END_LABEL "LELT"
405 #define LN_PROLOG_AS_LABEL "LASLTP"
406 #define LN_PROLOG_END_LABEL "LELTP"
407 #define DIE_LABEL_PREFIX "DW"
409 /* The DWARF 2 CFA column which tracks the return address. Normally this
410 is the column for PC, or the first column after all of the hard
412 #ifndef DWARF_FRAME_RETURN_COLUMN
414 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (PC_REGNUM)
416 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGISTERS
420 /* The mapping from gcc register number to DWARF 2 CFA column number. By
421 default, we just provide columns for all registers. */
422 #ifndef DWARF_FRAME_REGNUM
423 #define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG)
426 /* The offset from the incoming value of %sp to the top of the stack frame
427 for the current function. */
428 #ifndef INCOMING_FRAME_SP_OFFSET
429 #define INCOMING_FRAME_SP_OFFSET 0
432 /* Hook used by __throw. */
435 expand_builtin_dwarf_sp_column (void)
437 return GEN_INT (DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM
));
440 /* Return a pointer to a copy of the section string name S with all
441 attributes stripped off, and an asterisk prepended (for assemble_name). */
444 stripattributes (const char *s
)
446 char *stripped
= xmalloc (strlen (s
) + 2);
451 while (*s
&& *s
!= ',')
458 /* Generate code to initialize the register size table. */
461 expand_builtin_init_dwarf_reg_sizes (tree address
)
464 enum machine_mode mode
= TYPE_MODE (char_type_node
);
465 rtx addr
= expand_expr (address
, NULL_RTX
, VOIDmode
, 0);
466 rtx mem
= gen_rtx_MEM (BLKmode
, addr
);
467 bool wrote_return_column
= false;
469 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
470 if (DWARF_FRAME_REGNUM (i
) < DWARF_FRAME_REGISTERS
)
472 HOST_WIDE_INT offset
= DWARF_FRAME_REGNUM (i
) * GET_MODE_SIZE (mode
);
473 enum machine_mode save_mode
= reg_raw_mode
[i
];
476 if (HARD_REGNO_CALL_PART_CLOBBERED (i
, save_mode
))
477 save_mode
= choose_hard_reg_mode (i
, 1, true);
478 if (DWARF_FRAME_REGNUM (i
) == DWARF_FRAME_RETURN_COLUMN
)
480 if (save_mode
== VOIDmode
)
482 wrote_return_column
= true;
484 size
= GET_MODE_SIZE (save_mode
);
488 emit_move_insn (adjust_address (mem
, mode
, offset
), GEN_INT (size
));
491 #ifdef DWARF_ALT_FRAME_RETURN_COLUMN
492 gcc_assert (wrote_return_column
);
493 i
= DWARF_ALT_FRAME_RETURN_COLUMN
;
494 wrote_return_column
= false;
496 i
= DWARF_FRAME_RETURN_COLUMN
;
499 if (! wrote_return_column
)
501 enum machine_mode save_mode
= Pmode
;
502 HOST_WIDE_INT offset
= i
* GET_MODE_SIZE (mode
);
503 HOST_WIDE_INT size
= GET_MODE_SIZE (save_mode
);
504 emit_move_insn (adjust_address (mem
, mode
, offset
), GEN_INT (size
));
508 /* Convert a DWARF call frame info. operation to its string name */
511 dwarf_cfi_name (unsigned int cfi_opc
)
515 case DW_CFA_advance_loc
:
516 return "DW_CFA_advance_loc";
518 return "DW_CFA_offset";
520 return "DW_CFA_restore";
524 return "DW_CFA_set_loc";
525 case DW_CFA_advance_loc1
:
526 return "DW_CFA_advance_loc1";
527 case DW_CFA_advance_loc2
:
528 return "DW_CFA_advance_loc2";
529 case DW_CFA_advance_loc4
:
530 return "DW_CFA_advance_loc4";
531 case DW_CFA_offset_extended
:
532 return "DW_CFA_offset_extended";
533 case DW_CFA_restore_extended
:
534 return "DW_CFA_restore_extended";
535 case DW_CFA_undefined
:
536 return "DW_CFA_undefined";
537 case DW_CFA_same_value
:
538 return "DW_CFA_same_value";
539 case DW_CFA_register
:
540 return "DW_CFA_register";
541 case DW_CFA_remember_state
:
542 return "DW_CFA_remember_state";
543 case DW_CFA_restore_state
:
544 return "DW_CFA_restore_state";
546 return "DW_CFA_def_cfa";
547 case DW_CFA_def_cfa_register
:
548 return "DW_CFA_def_cfa_register";
549 case DW_CFA_def_cfa_offset
:
550 return "DW_CFA_def_cfa_offset";
553 case DW_CFA_def_cfa_expression
:
554 return "DW_CFA_def_cfa_expression";
555 case DW_CFA_expression
:
556 return "DW_CFA_expression";
557 case DW_CFA_offset_extended_sf
:
558 return "DW_CFA_offset_extended_sf";
559 case DW_CFA_def_cfa_sf
:
560 return "DW_CFA_def_cfa_sf";
561 case DW_CFA_def_cfa_offset_sf
:
562 return "DW_CFA_def_cfa_offset_sf";
564 /* SGI/MIPS specific */
565 case DW_CFA_MIPS_advance_loc8
:
566 return "DW_CFA_MIPS_advance_loc8";
569 case DW_CFA_GNU_window_save
:
570 return "DW_CFA_GNU_window_save";
571 case DW_CFA_GNU_args_size
:
572 return "DW_CFA_GNU_args_size";
573 case DW_CFA_GNU_negative_offset_extended
:
574 return "DW_CFA_GNU_negative_offset_extended";
577 return "DW_CFA_<unknown>";
581 /* Return a pointer to a newly allocated Call Frame Instruction. */
583 static inline dw_cfi_ref
586 dw_cfi_ref cfi
= ggc_alloc (sizeof (dw_cfi_node
));
588 cfi
->dw_cfi_next
= NULL
;
589 cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
= 0;
590 cfi
->dw_cfi_oprnd2
.dw_cfi_reg_num
= 0;
595 /* Add a Call Frame Instruction to list of instructions. */
598 add_cfi (dw_cfi_ref
*list_head
, dw_cfi_ref cfi
)
602 /* Find the end of the chain. */
603 for (p
= list_head
; (*p
) != NULL
; p
= &(*p
)->dw_cfi_next
)
609 /* Generate a new label for the CFI info to refer to. */
612 dwarf2out_cfi_label (void)
614 static char label
[20];
616 ASM_GENERATE_INTERNAL_LABEL (label
, "LCFI", dwarf2out_cfi_label_num
++);
617 ASM_OUTPUT_LABEL (asm_out_file
, label
);
621 /* Add CFI to the current fde at the PC value indicated by LABEL if specified,
622 or to the CIE if LABEL is NULL. */
625 add_fde_cfi (const char *label
, dw_cfi_ref cfi
)
629 dw_fde_ref fde
= &fde_table
[fde_table_in_use
- 1];
632 label
= dwarf2out_cfi_label ();
634 if (fde
->dw_fde_current_label
== NULL
635 || strcmp (label
, fde
->dw_fde_current_label
) != 0)
639 fde
->dw_fde_current_label
= label
= xstrdup (label
);
641 /* Set the location counter to the new label. */
643 xcfi
->dw_cfi_opc
= DW_CFA_advance_loc4
;
644 xcfi
->dw_cfi_oprnd1
.dw_cfi_addr
= label
;
645 add_cfi (&fde
->dw_fde_cfi
, xcfi
);
648 add_cfi (&fde
->dw_fde_cfi
, cfi
);
652 add_cfi (&cie_cfi_head
, cfi
);
655 /* Subroutine of lookup_cfa. */
658 lookup_cfa_1 (dw_cfi_ref cfi
, dw_cfa_location
*loc
)
660 switch (cfi
->dw_cfi_opc
)
662 case DW_CFA_def_cfa_offset
:
663 loc
->offset
= cfi
->dw_cfi_oprnd1
.dw_cfi_offset
;
665 case DW_CFA_def_cfa_register
:
666 loc
->reg
= cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
;
669 loc
->reg
= cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
;
670 loc
->offset
= cfi
->dw_cfi_oprnd2
.dw_cfi_offset
;
672 case DW_CFA_def_cfa_expression
:
673 get_cfa_from_loc_descr (loc
, cfi
->dw_cfi_oprnd1
.dw_cfi_loc
);
680 /* Find the previous value for the CFA. */
683 lookup_cfa (dw_cfa_location
*loc
)
687 loc
->reg
= (unsigned long) -1;
690 loc
->base_offset
= 0;
692 for (cfi
= cie_cfi_head
; cfi
; cfi
= cfi
->dw_cfi_next
)
693 lookup_cfa_1 (cfi
, loc
);
695 if (fde_table_in_use
)
697 dw_fde_ref fde
= &fde_table
[fde_table_in_use
- 1];
698 for (cfi
= fde
->dw_fde_cfi
; cfi
; cfi
= cfi
->dw_cfi_next
)
699 lookup_cfa_1 (cfi
, loc
);
703 /* The current rule for calculating the DWARF2 canonical frame address. */
704 static dw_cfa_location cfa
;
706 /* The register used for saving registers to the stack, and its offset
708 static dw_cfa_location cfa_store
;
710 /* The running total of the size of arguments pushed onto the stack. */
711 static HOST_WIDE_INT args_size
;
713 /* The last args_size we actually output. */
714 static HOST_WIDE_INT old_args_size
;
716 /* Entry point to update the canonical frame address (CFA).
717 LABEL is passed to add_fde_cfi. The value of CFA is now to be
718 calculated from REG+OFFSET. */
721 dwarf2out_def_cfa (const char *label
, unsigned int reg
, HOST_WIDE_INT offset
)
728 def_cfa_1 (label
, &loc
);
731 /* This routine does the actual work. The CFA is now calculated from
732 the dw_cfa_location structure. */
735 def_cfa_1 (const char *label
, dw_cfa_location
*loc_p
)
738 dw_cfa_location old_cfa
, loc
;
743 if (cfa_store
.reg
== loc
.reg
&& loc
.indirect
== 0)
744 cfa_store
.offset
= loc
.offset
;
746 loc
.reg
= DWARF_FRAME_REGNUM (loc
.reg
);
747 lookup_cfa (&old_cfa
);
749 /* If nothing changed, no need to issue any call frame instructions. */
750 if (loc
.reg
== old_cfa
.reg
&& loc
.offset
== old_cfa
.offset
751 && loc
.indirect
== old_cfa
.indirect
752 && (loc
.indirect
== 0 || loc
.base_offset
== old_cfa
.base_offset
))
757 if (loc
.reg
== old_cfa
.reg
&& !loc
.indirect
)
759 /* Construct a "DW_CFA_def_cfa_offset <offset>" instruction,
760 indicating the CFA register did not change but the offset
762 cfi
->dw_cfi_opc
= DW_CFA_def_cfa_offset
;
763 cfi
->dw_cfi_oprnd1
.dw_cfi_offset
= loc
.offset
;
766 #ifndef MIPS_DEBUGGING_INFO /* SGI dbx thinks this means no offset. */
767 else if (loc
.offset
== old_cfa
.offset
&& old_cfa
.reg
!= (unsigned long) -1
770 /* Construct a "DW_CFA_def_cfa_register <register>" instruction,
771 indicating the CFA register has changed to <register> but the
772 offset has not changed. */
773 cfi
->dw_cfi_opc
= DW_CFA_def_cfa_register
;
774 cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
= loc
.reg
;
778 else if (loc
.indirect
== 0)
780 /* Construct a "DW_CFA_def_cfa <register> <offset>" instruction,
781 indicating the CFA register has changed to <register> with
782 the specified offset. */
783 cfi
->dw_cfi_opc
= DW_CFA_def_cfa
;
784 cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
= loc
.reg
;
785 cfi
->dw_cfi_oprnd2
.dw_cfi_offset
= loc
.offset
;
789 /* Construct a DW_CFA_def_cfa_expression instruction to
790 calculate the CFA using a full location expression since no
791 register-offset pair is available. */
792 struct dw_loc_descr_struct
*loc_list
;
794 cfi
->dw_cfi_opc
= DW_CFA_def_cfa_expression
;
795 loc_list
= build_cfa_loc (&loc
);
796 cfi
->dw_cfi_oprnd1
.dw_cfi_loc
= loc_list
;
799 add_fde_cfi (label
, cfi
);
802 /* Add the CFI for saving a register. REG is the CFA column number.
803 LABEL is passed to add_fde_cfi.
804 If SREG is -1, the register is saved at OFFSET from the CFA;
805 otherwise it is saved in SREG. */
808 reg_save (const char *label
, unsigned int reg
, unsigned int sreg
, HOST_WIDE_INT offset
)
810 dw_cfi_ref cfi
= new_cfi ();
812 cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
= reg
;
814 if (sreg
== INVALID_REGNUM
)
817 /* The register number won't fit in 6 bits, so we have to use
819 cfi
->dw_cfi_opc
= DW_CFA_offset_extended
;
821 cfi
->dw_cfi_opc
= DW_CFA_offset
;
823 #ifdef ENABLE_CHECKING
825 /* If we get an offset that is not a multiple of
826 DWARF_CIE_DATA_ALIGNMENT, there is either a bug in the
827 definition of DWARF_CIE_DATA_ALIGNMENT, or a bug in the machine
829 HOST_WIDE_INT check_offset
= offset
/ DWARF_CIE_DATA_ALIGNMENT
;
831 gcc_assert (check_offset
* DWARF_CIE_DATA_ALIGNMENT
== offset
);
834 offset
/= DWARF_CIE_DATA_ALIGNMENT
;
836 cfi
->dw_cfi_opc
= DW_CFA_offset_extended_sf
;
838 cfi
->dw_cfi_oprnd2
.dw_cfi_offset
= offset
;
840 else if (sreg
== reg
)
841 cfi
->dw_cfi_opc
= DW_CFA_same_value
;
844 cfi
->dw_cfi_opc
= DW_CFA_register
;
845 cfi
->dw_cfi_oprnd2
.dw_cfi_reg_num
= sreg
;
848 add_fde_cfi (label
, cfi
);
851 /* Add the CFI for saving a register window. LABEL is passed to reg_save.
852 This CFI tells the unwinder that it needs to restore the window registers
853 from the previous frame's window save area.
855 ??? Perhaps we should note in the CIE where windows are saved (instead of
856 assuming 0(cfa)) and what registers are in the window. */
859 dwarf2out_window_save (const char *label
)
861 dw_cfi_ref cfi
= new_cfi ();
863 cfi
->dw_cfi_opc
= DW_CFA_GNU_window_save
;
864 add_fde_cfi (label
, cfi
);
867 /* Add a CFI to update the running total of the size of arguments
868 pushed onto the stack. */
871 dwarf2out_args_size (const char *label
, HOST_WIDE_INT size
)
875 if (size
== old_args_size
)
878 old_args_size
= size
;
881 cfi
->dw_cfi_opc
= DW_CFA_GNU_args_size
;
882 cfi
->dw_cfi_oprnd1
.dw_cfi_offset
= size
;
883 add_fde_cfi (label
, cfi
);
886 /* Entry point for saving a register to the stack. REG is the GCC register
887 number. LABEL and OFFSET are passed to reg_save. */
890 dwarf2out_reg_save (const char *label
, unsigned int reg
, HOST_WIDE_INT offset
)
892 reg_save (label
, DWARF_FRAME_REGNUM (reg
), INVALID_REGNUM
, offset
);
895 /* Entry point for saving the return address in the stack.
896 LABEL and OFFSET are passed to reg_save. */
899 dwarf2out_return_save (const char *label
, HOST_WIDE_INT offset
)
901 reg_save (label
, DWARF_FRAME_RETURN_COLUMN
, INVALID_REGNUM
, offset
);
904 /* Entry point for saving the return address in a register.
905 LABEL and SREG are passed to reg_save. */
908 dwarf2out_return_reg (const char *label
, unsigned int sreg
)
910 reg_save (label
, DWARF_FRAME_RETURN_COLUMN
, DWARF_FRAME_REGNUM (sreg
), 0);
913 /* Record the initial position of the return address. RTL is
914 INCOMING_RETURN_ADDR_RTX. */
917 initial_return_save (rtx rtl
)
919 unsigned int reg
= INVALID_REGNUM
;
920 HOST_WIDE_INT offset
= 0;
922 switch (GET_CODE (rtl
))
925 /* RA is in a register. */
926 reg
= DWARF_FRAME_REGNUM (REGNO (rtl
));
930 /* RA is on the stack. */
932 switch (GET_CODE (rtl
))
935 gcc_assert (REGNO (rtl
) == STACK_POINTER_REGNUM
);
940 gcc_assert (REGNO (XEXP (rtl
, 0)) == STACK_POINTER_REGNUM
);
941 offset
= INTVAL (XEXP (rtl
, 1));
945 gcc_assert (REGNO (XEXP (rtl
, 0)) == STACK_POINTER_REGNUM
);
946 offset
= -INTVAL (XEXP (rtl
, 1));
956 /* The return address is at some offset from any value we can
957 actually load. For instance, on the SPARC it is in %i7+8. Just
958 ignore the offset for now; it doesn't matter for unwinding frames. */
959 gcc_assert (GET_CODE (XEXP (rtl
, 1)) == CONST_INT
);
960 initial_return_save (XEXP (rtl
, 0));
967 if (reg
!= DWARF_FRAME_RETURN_COLUMN
)
968 reg_save (NULL
, DWARF_FRAME_RETURN_COLUMN
, reg
, offset
- cfa
.offset
);
971 /* Given a SET, calculate the amount of stack adjustment it
975 stack_adjust_offset (rtx pattern
)
977 rtx src
= SET_SRC (pattern
);
978 rtx dest
= SET_DEST (pattern
);
979 HOST_WIDE_INT offset
= 0;
982 if (dest
== stack_pointer_rtx
)
984 /* (set (reg sp) (plus (reg sp) (const_int))) */
985 code
= GET_CODE (src
);
986 if (! (code
== PLUS
|| code
== MINUS
)
987 || XEXP (src
, 0) != stack_pointer_rtx
988 || GET_CODE (XEXP (src
, 1)) != CONST_INT
)
991 offset
= INTVAL (XEXP (src
, 1));
995 else if (MEM_P (dest
))
997 /* (set (mem (pre_dec (reg sp))) (foo)) */
998 src
= XEXP (dest
, 0);
999 code
= GET_CODE (src
);
1005 if (XEXP (src
, 0) == stack_pointer_rtx
)
1007 rtx val
= XEXP (XEXP (src
, 1), 1);
1008 /* We handle only adjustments by constant amount. */
1009 gcc_assert (GET_CODE (XEXP (src
, 1)) == PLUS
1010 && GET_CODE (val
) == CONST_INT
);
1011 offset
= -INTVAL (val
);
1018 if (XEXP (src
, 0) == stack_pointer_rtx
)
1020 offset
= GET_MODE_SIZE (GET_MODE (dest
));
1027 if (XEXP (src
, 0) == stack_pointer_rtx
)
1029 offset
= -GET_MODE_SIZE (GET_MODE (dest
));
1044 /* Check INSN to see if it looks like a push or a stack adjustment, and
1045 make a note of it if it does. EH uses this information to find out how
1046 much extra space it needs to pop off the stack. */
1049 dwarf2out_stack_adjust (rtx insn
)
1051 HOST_WIDE_INT offset
;
1055 /* Don't handle epilogues at all. Certainly it would be wrong to do so
1056 with this function. Proper support would require all frame-related
1057 insns to be marked, and to be able to handle saving state around
1058 epilogues textually in the middle of the function. */
1059 if (prologue_epilogue_contains (insn
) || sibcall_epilogue_contains (insn
))
1062 if (!flag_asynchronous_unwind_tables
&& CALL_P (insn
))
1064 /* Extract the size of the args from the CALL rtx itself. */
1065 insn
= PATTERN (insn
);
1066 if (GET_CODE (insn
) == PARALLEL
)
1067 insn
= XVECEXP (insn
, 0, 0);
1068 if (GET_CODE (insn
) == SET
)
1069 insn
= SET_SRC (insn
);
1070 gcc_assert (GET_CODE (insn
) == CALL
);
1072 dwarf2out_args_size ("", INTVAL (XEXP (insn
, 1)));
1076 /* If only calls can throw, and we have a frame pointer,
1077 save up adjustments until we see the CALL_INSN. */
1078 else if (!flag_asynchronous_unwind_tables
&& cfa
.reg
!= STACK_POINTER_REGNUM
)
1081 if (BARRIER_P (insn
))
1083 /* When we see a BARRIER, we know to reset args_size to 0. Usually
1084 the compiler will have already emitted a stack adjustment, but
1085 doesn't bother for calls to noreturn functions. */
1086 #ifdef STACK_GROWS_DOWNWARD
1087 offset
= -args_size
;
1092 else if (GET_CODE (PATTERN (insn
)) == SET
)
1093 offset
= stack_adjust_offset (PATTERN (insn
));
1094 else if (GET_CODE (PATTERN (insn
)) == PARALLEL
1095 || GET_CODE (PATTERN (insn
)) == SEQUENCE
)
1097 /* There may be stack adjustments inside compound insns. Search
1099 for (offset
= 0, i
= XVECLEN (PATTERN (insn
), 0) - 1; i
>= 0; i
--)
1100 if (GET_CODE (XVECEXP (PATTERN (insn
), 0, i
)) == SET
)
1101 offset
+= stack_adjust_offset (XVECEXP (PATTERN (insn
), 0, i
));
1109 if (cfa
.reg
== STACK_POINTER_REGNUM
)
1110 cfa
.offset
+= offset
;
1112 #ifndef STACK_GROWS_DOWNWARD
1116 args_size
+= offset
;
1120 label
= dwarf2out_cfi_label ();
1121 def_cfa_1 (label
, &cfa
);
1122 dwarf2out_args_size (label
, args_size
);
1127 /* We delay emitting a register save until either (a) we reach the end
1128 of the prologue or (b) the register is clobbered. This clusters
1129 register saves so that there are fewer pc advances. */
1131 struct queued_reg_save
GTY(())
1133 struct queued_reg_save
*next
;
1135 HOST_WIDE_INT cfa_offset
;
1139 static GTY(()) struct queued_reg_save
*queued_reg_saves
;
1141 /* The caller's ORIG_REG is saved in SAVED_IN_REG. */
1142 struct reg_saved_in_data
GTY(()) {
1147 /* A list of registers saved in other registers.
1148 The list intentionally has a small maximum capacity of 4; if your
1149 port needs more than that, you might consider implementing a
1150 more efficient data structure. */
1151 static GTY(()) struct reg_saved_in_data regs_saved_in_regs
[4];
1152 static GTY(()) size_t num_regs_saved_in_regs
;
1154 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
1155 static const char *last_reg_save_label
;
1157 /* Add an entry to QUEUED_REG_SAVES saying that REG is now saved at
1158 SREG, or if SREG is NULL then it is saved at OFFSET to the CFA. */
1161 queue_reg_save (const char *label
, rtx reg
, rtx sreg
, HOST_WIDE_INT offset
)
1163 struct queued_reg_save
*q
;
1165 /* Duplicates waste space, but it's also necessary to remove them
1166 for correctness, since the queue gets output in reverse
1168 for (q
= queued_reg_saves
; q
!= NULL
; q
= q
->next
)
1169 if (REGNO (q
->reg
) == REGNO (reg
))
1174 q
= ggc_alloc (sizeof (*q
));
1175 q
->next
= queued_reg_saves
;
1176 queued_reg_saves
= q
;
1180 q
->cfa_offset
= offset
;
1181 q
->saved_reg
= sreg
;
1183 last_reg_save_label
= label
;
1186 /* Output all the entries in QUEUED_REG_SAVES. */
1189 flush_queued_reg_saves (void)
1191 struct queued_reg_save
*q
;
1193 for (q
= queued_reg_saves
; q
; q
= q
->next
)
1196 unsigned int reg
, sreg
;
1198 for (i
= 0; i
< num_regs_saved_in_regs
; i
++)
1199 if (REGNO (regs_saved_in_regs
[i
].orig_reg
) == REGNO (q
->reg
))
1201 if (q
->saved_reg
&& i
== num_regs_saved_in_regs
)
1203 gcc_assert (i
!= ARRAY_SIZE (regs_saved_in_regs
));
1204 num_regs_saved_in_regs
++;
1206 if (i
!= num_regs_saved_in_regs
)
1208 regs_saved_in_regs
[i
].orig_reg
= q
->reg
;
1209 regs_saved_in_regs
[i
].saved_in_reg
= q
->saved_reg
;
1212 reg
= DWARF_FRAME_REGNUM (REGNO (q
->reg
));
1214 sreg
= DWARF_FRAME_REGNUM (REGNO (q
->saved_reg
));
1216 sreg
= INVALID_REGNUM
;
1217 reg_save (last_reg_save_label
, reg
, sreg
, q
->cfa_offset
);
1220 queued_reg_saves
= NULL
;
1221 last_reg_save_label
= NULL
;
1224 /* Does INSN clobber any register which QUEUED_REG_SAVES lists a saved
1225 location for? Or, does it clobber a register which we've previously
1226 said that some other register is saved in, and for which we now
1227 have a new location for? */
1230 clobbers_queued_reg_save (rtx insn
)
1232 struct queued_reg_save
*q
;
1234 for (q
= queued_reg_saves
; q
; q
= q
->next
)
1237 if (modified_in_p (q
->reg
, insn
))
1239 for (i
= 0; i
< num_regs_saved_in_regs
; i
++)
1240 if (REGNO (q
->reg
) == REGNO (regs_saved_in_regs
[i
].orig_reg
)
1241 && modified_in_p (regs_saved_in_regs
[i
].saved_in_reg
, insn
))
1248 /* What register, if any, is currently saved in REG? */
1251 reg_saved_in (rtx reg
)
1253 unsigned int regn
= REGNO (reg
);
1255 struct queued_reg_save
*q
;
1257 for (q
= queued_reg_saves
; q
; q
= q
->next
)
1258 if (q
->saved_reg
&& regn
== REGNO (q
->saved_reg
))
1261 for (i
= 0; i
< num_regs_saved_in_regs
; i
++)
1262 if (regs_saved_in_regs
[i
].saved_in_reg
1263 && regn
== REGNO (regs_saved_in_regs
[i
].saved_in_reg
))
1264 return regs_saved_in_regs
[i
].orig_reg
;
1270 /* A temporary register holding an integral value used in adjusting SP
1271 or setting up the store_reg. The "offset" field holds the integer
1272 value, not an offset. */
1273 static dw_cfa_location cfa_temp
;
1275 /* Record call frame debugging information for an expression EXPR,
1276 which either sets SP or FP (adjusting how we calculate the frame
1277 address) or saves a register to the stack or another register.
1278 LABEL indicates the address of EXPR.
1280 This function encodes a state machine mapping rtxes to actions on
1281 cfa, cfa_store, and cfa_temp.reg. We describe these rules so
1282 users need not read the source code.
1284 The High-Level Picture
1286 Changes in the register we use to calculate the CFA: Currently we
1287 assume that if you copy the CFA register into another register, we
1288 should take the other one as the new CFA register; this seems to
1289 work pretty well. If it's wrong for some target, it's simple
1290 enough not to set RTX_FRAME_RELATED_P on the insn in question.
1292 Changes in the register we use for saving registers to the stack:
1293 This is usually SP, but not always. Again, we deduce that if you
1294 copy SP into another register (and SP is not the CFA register),
1295 then the new register is the one we will be using for register
1296 saves. This also seems to work.
1298 Register saves: There's not much guesswork about this one; if
1299 RTX_FRAME_RELATED_P is set on an insn which modifies memory, it's a
1300 register save, and the register used to calculate the destination
1301 had better be the one we think we're using for this purpose.
1302 It's also assumed that a copy from a call-saved register to another
1303 register is saving that register if RTX_FRAME_RELATED_P is set on
1304 that instruction. If the copy is from a call-saved register to
1305 the *same* register, that means that the register is now the same
1306 value as in the caller.
1308 Except: If the register being saved is the CFA register, and the
1309 offset is nonzero, we are saving the CFA, so we assume we have to
1310 use DW_CFA_def_cfa_expression. If the offset is 0, we assume that
1311 the intent is to save the value of SP from the previous frame.
1313 In addition, if a register has previously been saved to a different
1316 Invariants / Summaries of Rules
1318 cfa current rule for calculating the CFA. It usually
1319 consists of a register and an offset.
1320 cfa_store register used by prologue code to save things to the stack
1321 cfa_store.offset is the offset from the value of
1322 cfa_store.reg to the actual CFA
1323 cfa_temp register holding an integral value. cfa_temp.offset
1324 stores the value, which will be used to adjust the
1325 stack pointer. cfa_temp is also used like cfa_store,
1326 to track stores to the stack via fp or a temp reg.
1328 Rules 1- 4: Setting a register's value to cfa.reg or an expression
1329 with cfa.reg as the first operand changes the cfa.reg and its
1330 cfa.offset. Rule 1 and 4 also set cfa_temp.reg and
1333 Rules 6- 9: Set a non-cfa.reg register value to a constant or an
1334 expression yielding a constant. This sets cfa_temp.reg
1335 and cfa_temp.offset.
1337 Rule 5: Create a new register cfa_store used to save items to the
1340 Rules 10-14: Save a register to the stack. Define offset as the
1341 difference of the original location and cfa_store's
1342 location (or cfa_temp's location if cfa_temp is used).
1346 "{a,b}" indicates a choice of a xor b.
1347 "<reg>:cfa.reg" indicates that <reg> must equal cfa.reg.
1350 (set <reg1> <reg2>:cfa.reg)
1351 effects: cfa.reg = <reg1>
1352 cfa.offset unchanged
1353 cfa_temp.reg = <reg1>
1354 cfa_temp.offset = cfa.offset
1357 (set sp ({minus,plus,losum} {sp,fp}:cfa.reg
1358 {<const_int>,<reg>:cfa_temp.reg}))
1359 effects: cfa.reg = sp if fp used
1360 cfa.offset += {+/- <const_int>, cfa_temp.offset} if cfa.reg==sp
1361 cfa_store.offset += {+/- <const_int>, cfa_temp.offset}
1362 if cfa_store.reg==sp
1365 (set fp ({minus,plus,losum} <reg>:cfa.reg <const_int>))
1366 effects: cfa.reg = fp
1367 cfa_offset += +/- <const_int>
1370 (set <reg1> ({plus,losum} <reg2>:cfa.reg <const_int>))
1371 constraints: <reg1> != fp
1373 effects: cfa.reg = <reg1>
1374 cfa_temp.reg = <reg1>
1375 cfa_temp.offset = cfa.offset
1378 (set <reg1> (plus <reg2>:cfa_temp.reg sp:cfa.reg))
1379 constraints: <reg1> != fp
1381 effects: cfa_store.reg = <reg1>
1382 cfa_store.offset = cfa.offset - cfa_temp.offset
1385 (set <reg> <const_int>)
1386 effects: cfa_temp.reg = <reg>
1387 cfa_temp.offset = <const_int>
1390 (set <reg1>:cfa_temp.reg (ior <reg2>:cfa_temp.reg <const_int>))
1391 effects: cfa_temp.reg = <reg1>
1392 cfa_temp.offset |= <const_int>
1395 (set <reg> (high <exp>))
1399 (set <reg> (lo_sum <exp> <const_int>))
1400 effects: cfa_temp.reg = <reg>
1401 cfa_temp.offset = <const_int>
1404 (set (mem (pre_modify sp:cfa_store (???? <reg1> <const_int>))) <reg2>)
1405 effects: cfa_store.offset -= <const_int>
1406 cfa.offset = cfa_store.offset if cfa.reg == sp
1408 cfa.base_offset = -cfa_store.offset
1411 (set (mem ({pre_inc,pre_dec} sp:cfa_store.reg)) <reg>)
1412 effects: cfa_store.offset += -/+ mode_size(mem)
1413 cfa.offset = cfa_store.offset if cfa.reg == sp
1415 cfa.base_offset = -cfa_store.offset
1418 (set (mem ({minus,plus,losum} <reg1>:{cfa_store,cfa_temp} <const_int>))
1421 effects: cfa.reg = <reg1>
1422 cfa.base_offset = -/+ <const_int> - {cfa_store,cfa_temp}.offset
1425 (set (mem <reg1>:{cfa_store,cfa_temp}) <reg2>)
1426 effects: cfa.reg = <reg1>
1427 cfa.base_offset = -{cfa_store,cfa_temp}.offset
1430 (set (mem (postinc <reg1>:cfa_temp <const_int>)) <reg2>)
1431 effects: cfa.reg = <reg1>
1432 cfa.base_offset = -cfa_temp.offset
1433 cfa_temp.offset -= mode_size(mem) */
1436 dwarf2out_frame_debug_expr (rtx expr
, const char *label
)
1439 HOST_WIDE_INT offset
;
1441 /* If RTX_FRAME_RELATED_P is set on a PARALLEL, process each member of
1442 the PARALLEL independently. The first element is always processed if
1443 it is a SET. This is for backward compatibility. Other elements
1444 are processed only if they are SETs and the RTX_FRAME_RELATED_P
1445 flag is set in them. */
1446 if (GET_CODE (expr
) == PARALLEL
|| GET_CODE (expr
) == SEQUENCE
)
1449 int limit
= XVECLEN (expr
, 0);
1451 for (par_index
= 0; par_index
< limit
; par_index
++)
1452 if (GET_CODE (XVECEXP (expr
, 0, par_index
)) == SET
1453 && (RTX_FRAME_RELATED_P (XVECEXP (expr
, 0, par_index
))
1455 dwarf2out_frame_debug_expr (XVECEXP (expr
, 0, par_index
), label
);
1460 gcc_assert (GET_CODE (expr
) == SET
);
1462 src
= SET_SRC (expr
);
1463 dest
= SET_DEST (expr
);
1465 if (GET_CODE (src
) == REG
)
1467 rtx rsi
= reg_saved_in (src
);
1472 switch (GET_CODE (dest
))
1475 switch (GET_CODE (src
))
1477 /* Setting FP from SP. */
1479 if (cfa
.reg
== (unsigned) REGNO (src
))
1482 /* Update the CFA rule wrt SP or FP. Make sure src is
1483 relative to the current CFA register.
1485 We used to require that dest be either SP or FP, but the
1486 ARM copies SP to a temporary register, and from there to
1487 FP. So we just rely on the backends to only set
1488 RTX_FRAME_RELATED_P on appropriate insns. */
1489 cfa
.reg
= REGNO (dest
);
1490 cfa_temp
.reg
= cfa
.reg
;
1491 cfa_temp
.offset
= cfa
.offset
;
1495 /* Saving a register in a register. */
1496 gcc_assert (call_used_regs
[REGNO (dest
)]
1497 && !fixed_regs
[REGNO (dest
)]);
1498 queue_reg_save (label
, src
, dest
, 0);
1505 if (dest
== stack_pointer_rtx
)
1509 switch (GET_CODE (XEXP (src
, 1)))
1512 offset
= INTVAL (XEXP (src
, 1));
1515 gcc_assert ((unsigned) REGNO (XEXP (src
, 1))
1517 offset
= cfa_temp
.offset
;
1523 if (XEXP (src
, 0) == hard_frame_pointer_rtx
)
1525 /* Restoring SP from FP in the epilogue. */
1526 gcc_assert (cfa
.reg
== (unsigned) HARD_FRAME_POINTER_REGNUM
);
1527 cfa
.reg
= STACK_POINTER_REGNUM
;
1529 else if (GET_CODE (src
) == LO_SUM
)
1530 /* Assume we've set the source reg of the LO_SUM from sp. */
1533 gcc_assert (XEXP (src
, 0) == stack_pointer_rtx
);
1535 if (GET_CODE (src
) != MINUS
)
1537 if (cfa
.reg
== STACK_POINTER_REGNUM
)
1538 cfa
.offset
+= offset
;
1539 if (cfa_store
.reg
== STACK_POINTER_REGNUM
)
1540 cfa_store
.offset
+= offset
;
1542 else if (dest
== hard_frame_pointer_rtx
)
1545 /* Either setting the FP from an offset of the SP,
1546 or adjusting the FP */
1547 gcc_assert (frame_pointer_needed
);
1549 gcc_assert (REG_P (XEXP (src
, 0))
1550 && (unsigned) REGNO (XEXP (src
, 0)) == cfa
.reg
1551 && GET_CODE (XEXP (src
, 1)) == CONST_INT
);
1552 offset
= INTVAL (XEXP (src
, 1));
1553 if (GET_CODE (src
) != MINUS
)
1555 cfa
.offset
+= offset
;
1556 cfa
.reg
= HARD_FRAME_POINTER_REGNUM
;
1560 gcc_assert (GET_CODE (src
) != MINUS
);
1563 if (REG_P (XEXP (src
, 0))
1564 && REGNO (XEXP (src
, 0)) == cfa
.reg
1565 && GET_CODE (XEXP (src
, 1)) == CONST_INT
)
1567 /* Setting a temporary CFA register that will be copied
1568 into the FP later on. */
1569 offset
= - INTVAL (XEXP (src
, 1));
1570 cfa
.offset
+= offset
;
1571 cfa
.reg
= REGNO (dest
);
1572 /* Or used to save regs to the stack. */
1573 cfa_temp
.reg
= cfa
.reg
;
1574 cfa_temp
.offset
= cfa
.offset
;
1578 else if (REG_P (XEXP (src
, 0))
1579 && REGNO (XEXP (src
, 0)) == cfa_temp
.reg
1580 && XEXP (src
, 1) == stack_pointer_rtx
)
1582 /* Setting a scratch register that we will use instead
1583 of SP for saving registers to the stack. */
1584 gcc_assert (cfa
.reg
== STACK_POINTER_REGNUM
);
1585 cfa_store
.reg
= REGNO (dest
);
1586 cfa_store
.offset
= cfa
.offset
- cfa_temp
.offset
;
1590 else if (GET_CODE (src
) == LO_SUM
1591 && GET_CODE (XEXP (src
, 1)) == CONST_INT
)
1593 cfa_temp
.reg
= REGNO (dest
);
1594 cfa_temp
.offset
= INTVAL (XEXP (src
, 1));
1603 cfa_temp
.reg
= REGNO (dest
);
1604 cfa_temp
.offset
= INTVAL (src
);
1609 gcc_assert (REG_P (XEXP (src
, 0))
1610 && (unsigned) REGNO (XEXP (src
, 0)) == cfa_temp
.reg
1611 && GET_CODE (XEXP (src
, 1)) == CONST_INT
);
1613 if ((unsigned) REGNO (dest
) != cfa_temp
.reg
)
1614 cfa_temp
.reg
= REGNO (dest
);
1615 cfa_temp
.offset
|= INTVAL (XEXP (src
, 1));
1618 /* Skip over HIGH, assuming it will be followed by a LO_SUM,
1619 which will fill in all of the bits. */
1628 def_cfa_1 (label
, &cfa
);
1632 gcc_assert (REG_P (src
));
1634 /* Saving a register to the stack. Make sure dest is relative to the
1636 switch (GET_CODE (XEXP (dest
, 0)))
1641 /* We can't handle variable size modifications. */
1642 gcc_assert (GET_CODE (XEXP (XEXP (XEXP (dest
, 0), 1), 1))
1644 offset
= -INTVAL (XEXP (XEXP (XEXP (dest
, 0), 1), 1));
1646 gcc_assert (REGNO (XEXP (XEXP (dest
, 0), 0)) == STACK_POINTER_REGNUM
1647 && cfa_store
.reg
== STACK_POINTER_REGNUM
);
1649 cfa_store
.offset
+= offset
;
1650 if (cfa
.reg
== STACK_POINTER_REGNUM
)
1651 cfa
.offset
= cfa_store
.offset
;
1653 offset
= -cfa_store
.offset
;
1659 offset
= GET_MODE_SIZE (GET_MODE (dest
));
1660 if (GET_CODE (XEXP (dest
, 0)) == PRE_INC
)
1663 gcc_assert (REGNO (XEXP (XEXP (dest
, 0), 0)) == STACK_POINTER_REGNUM
1664 && cfa_store
.reg
== STACK_POINTER_REGNUM
);
1666 cfa_store
.offset
+= offset
;
1667 if (cfa
.reg
== STACK_POINTER_REGNUM
)
1668 cfa
.offset
= cfa_store
.offset
;
1670 offset
= -cfa_store
.offset
;
1674 /* With an offset. */
1681 gcc_assert (GET_CODE (XEXP (XEXP (dest
, 0), 1)) == CONST_INT
);
1682 offset
= INTVAL (XEXP (XEXP (dest
, 0), 1));
1683 if (GET_CODE (XEXP (dest
, 0)) == MINUS
)
1686 regno
= REGNO (XEXP (XEXP (dest
, 0), 0));
1688 if (cfa_store
.reg
== (unsigned) regno
)
1689 offset
-= cfa_store
.offset
;
1692 gcc_assert (cfa_temp
.reg
== (unsigned) regno
);
1693 offset
-= cfa_temp
.offset
;
1699 /* Without an offset. */
1702 int regno
= REGNO (XEXP (dest
, 0));
1704 if (cfa_store
.reg
== (unsigned) regno
)
1705 offset
= -cfa_store
.offset
;
1708 gcc_assert (cfa_temp
.reg
== (unsigned) regno
);
1709 offset
= -cfa_temp
.offset
;
1716 gcc_assert (cfa_temp
.reg
1717 == (unsigned) REGNO (XEXP (XEXP (dest
, 0), 0)));
1718 offset
= -cfa_temp
.offset
;
1719 cfa_temp
.offset
-= GET_MODE_SIZE (GET_MODE (dest
));
1726 if (REGNO (src
) != STACK_POINTER_REGNUM
1727 && REGNO (src
) != HARD_FRAME_POINTER_REGNUM
1728 && (unsigned) REGNO (src
) == cfa
.reg
)
1730 /* We're storing the current CFA reg into the stack. */
1732 if (cfa
.offset
== 0)
1734 /* If the source register is exactly the CFA, assume
1735 we're saving SP like any other register; this happens
1737 def_cfa_1 (label
, &cfa
);
1738 queue_reg_save (label
, stack_pointer_rtx
, NULL_RTX
, offset
);
1743 /* Otherwise, we'll need to look in the stack to
1744 calculate the CFA. */
1745 rtx x
= XEXP (dest
, 0);
1749 gcc_assert (REG_P (x
));
1751 cfa
.reg
= REGNO (x
);
1752 cfa
.base_offset
= offset
;
1754 def_cfa_1 (label
, &cfa
);
1759 def_cfa_1 (label
, &cfa
);
1760 queue_reg_save (label
, src
, NULL_RTX
, offset
);
1768 /* Record call frame debugging information for INSN, which either
1769 sets SP or FP (adjusting how we calculate the frame address) or saves a
1770 register to the stack. If INSN is NULL_RTX, initialize our state. */
1773 dwarf2out_frame_debug (rtx insn
)
1778 if (insn
== NULL_RTX
)
1782 /* Flush any queued register saves. */
1783 flush_queued_reg_saves ();
1785 /* Set up state for generating call frame debug info. */
1788 == (unsigned long)DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM
));
1790 cfa
.reg
= STACK_POINTER_REGNUM
;
1793 cfa_temp
.offset
= 0;
1795 for (i
= 0; i
< num_regs_saved_in_regs
; i
++)
1797 regs_saved_in_regs
[i
].orig_reg
= NULL_RTX
;
1798 regs_saved_in_regs
[i
].saved_in_reg
= NULL_RTX
;
1800 num_regs_saved_in_regs
= 0;
1804 if (!NONJUMP_INSN_P (insn
) || clobbers_queued_reg_save (insn
))
1805 flush_queued_reg_saves ();
1807 if (! RTX_FRAME_RELATED_P (insn
))
1809 if (!ACCUMULATE_OUTGOING_ARGS
)
1810 dwarf2out_stack_adjust (insn
);
1815 label
= dwarf2out_cfi_label ();
1816 src
= find_reg_note (insn
, REG_FRAME_RELATED_EXPR
, NULL_RTX
);
1818 insn
= XEXP (src
, 0);
1820 insn
= PATTERN (insn
);
1822 dwarf2out_frame_debug_expr (insn
, label
);
1827 /* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used. */
1828 static enum dw_cfi_oprnd_type dw_cfi_oprnd1_desc
1829 (enum dwarf_call_frame_info cfi
);
1831 static enum dw_cfi_oprnd_type
1832 dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi
)
1837 case DW_CFA_GNU_window_save
:
1838 return dw_cfi_oprnd_unused
;
1840 case DW_CFA_set_loc
:
1841 case DW_CFA_advance_loc1
:
1842 case DW_CFA_advance_loc2
:
1843 case DW_CFA_advance_loc4
:
1844 case DW_CFA_MIPS_advance_loc8
:
1845 return dw_cfi_oprnd_addr
;
1848 case DW_CFA_offset_extended
:
1849 case DW_CFA_def_cfa
:
1850 case DW_CFA_offset_extended_sf
:
1851 case DW_CFA_def_cfa_sf
:
1852 case DW_CFA_restore_extended
:
1853 case DW_CFA_undefined
:
1854 case DW_CFA_same_value
:
1855 case DW_CFA_def_cfa_register
:
1856 case DW_CFA_register
:
1857 return dw_cfi_oprnd_reg_num
;
1859 case DW_CFA_def_cfa_offset
:
1860 case DW_CFA_GNU_args_size
:
1861 case DW_CFA_def_cfa_offset_sf
:
1862 return dw_cfi_oprnd_offset
;
1864 case DW_CFA_def_cfa_expression
:
1865 case DW_CFA_expression
:
1866 return dw_cfi_oprnd_loc
;
1873 /* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used. */
1874 static enum dw_cfi_oprnd_type dw_cfi_oprnd2_desc
1875 (enum dwarf_call_frame_info cfi
);
1877 static enum dw_cfi_oprnd_type
1878 dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi
)
1882 case DW_CFA_def_cfa
:
1883 case DW_CFA_def_cfa_sf
:
1885 case DW_CFA_offset_extended_sf
:
1886 case DW_CFA_offset_extended
:
1887 return dw_cfi_oprnd_offset
;
1889 case DW_CFA_register
:
1890 return dw_cfi_oprnd_reg_num
;
1893 return dw_cfi_oprnd_unused
;
1897 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
1899 /* Map register numbers held in the call frame info that gcc has
1900 collected using DWARF_FRAME_REGNUM to those that should be output in
1901 .debug_frame and .eh_frame. */
1902 #ifndef DWARF2_FRAME_REG_OUT
1903 #define DWARF2_FRAME_REG_OUT(REGNO, FOR_EH) (REGNO)
1906 /* Output a Call Frame Information opcode and its operand(s). */
1909 output_cfi (dw_cfi_ref cfi
, dw_fde_ref fde
, int for_eh
)
1912 if (cfi
->dw_cfi_opc
== DW_CFA_advance_loc
)
1913 dw2_asm_output_data (1, (cfi
->dw_cfi_opc
1914 | (cfi
->dw_cfi_oprnd1
.dw_cfi_offset
& 0x3f)),
1915 "DW_CFA_advance_loc " HOST_WIDE_INT_PRINT_HEX
,
1916 cfi
->dw_cfi_oprnd1
.dw_cfi_offset
);
1917 else if (cfi
->dw_cfi_opc
== DW_CFA_offset
)
1919 r
= DWARF2_FRAME_REG_OUT (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
, for_eh
);
1920 dw2_asm_output_data (1, (cfi
->dw_cfi_opc
| (r
& 0x3f)),
1921 "DW_CFA_offset, column 0x%lx", r
);
1922 dw2_asm_output_data_uleb128 (cfi
->dw_cfi_oprnd2
.dw_cfi_offset
, NULL
);
1924 else if (cfi
->dw_cfi_opc
== DW_CFA_restore
)
1926 r
= DWARF2_FRAME_REG_OUT (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
, for_eh
);
1927 dw2_asm_output_data (1, (cfi
->dw_cfi_opc
| (r
& 0x3f)),
1928 "DW_CFA_restore, column 0x%lx", r
);
1932 dw2_asm_output_data (1, cfi
->dw_cfi_opc
,
1933 "%s", dwarf_cfi_name (cfi
->dw_cfi_opc
));
1935 switch (cfi
->dw_cfi_opc
)
1937 case DW_CFA_set_loc
:
1939 dw2_asm_output_encoded_addr_rtx (
1940 ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0),
1941 gen_rtx_SYMBOL_REF (Pmode
, cfi
->dw_cfi_oprnd1
.dw_cfi_addr
),
1944 dw2_asm_output_addr (DWARF2_ADDR_SIZE
,
1945 cfi
->dw_cfi_oprnd1
.dw_cfi_addr
, NULL
);
1948 case DW_CFA_advance_loc1
:
1949 dw2_asm_output_delta (1, cfi
->dw_cfi_oprnd1
.dw_cfi_addr
,
1950 fde
->dw_fde_current_label
, NULL
);
1951 fde
->dw_fde_current_label
= cfi
->dw_cfi_oprnd1
.dw_cfi_addr
;
1954 case DW_CFA_advance_loc2
:
1955 dw2_asm_output_delta (2, cfi
->dw_cfi_oprnd1
.dw_cfi_addr
,
1956 fde
->dw_fde_current_label
, NULL
);
1957 fde
->dw_fde_current_label
= cfi
->dw_cfi_oprnd1
.dw_cfi_addr
;
1960 case DW_CFA_advance_loc4
:
1961 dw2_asm_output_delta (4, cfi
->dw_cfi_oprnd1
.dw_cfi_addr
,
1962 fde
->dw_fde_current_label
, NULL
);
1963 fde
->dw_fde_current_label
= cfi
->dw_cfi_oprnd1
.dw_cfi_addr
;
1966 case DW_CFA_MIPS_advance_loc8
:
1967 dw2_asm_output_delta (8, cfi
->dw_cfi_oprnd1
.dw_cfi_addr
,
1968 fde
->dw_fde_current_label
, NULL
);
1969 fde
->dw_fde_current_label
= cfi
->dw_cfi_oprnd1
.dw_cfi_addr
;
1972 case DW_CFA_offset_extended
:
1973 case DW_CFA_def_cfa
:
1974 r
= DWARF2_FRAME_REG_OUT (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
, for_eh
);
1975 dw2_asm_output_data_uleb128 (r
, NULL
);
1976 dw2_asm_output_data_uleb128 (cfi
->dw_cfi_oprnd2
.dw_cfi_offset
, NULL
);
1979 case DW_CFA_offset_extended_sf
:
1980 case DW_CFA_def_cfa_sf
:
1981 r
= DWARF2_FRAME_REG_OUT (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
, for_eh
);
1982 dw2_asm_output_data_uleb128 (r
, NULL
);
1983 dw2_asm_output_data_sleb128 (cfi
->dw_cfi_oprnd2
.dw_cfi_offset
, NULL
);
1986 case DW_CFA_restore_extended
:
1987 case DW_CFA_undefined
:
1988 case DW_CFA_same_value
:
1989 case DW_CFA_def_cfa_register
:
1990 r
= DWARF2_FRAME_REG_OUT (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
, for_eh
);
1991 dw2_asm_output_data_uleb128 (r
, NULL
);
1994 case DW_CFA_register
:
1995 r
= DWARF2_FRAME_REG_OUT (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
, for_eh
);
1996 dw2_asm_output_data_uleb128 (r
, NULL
);
1997 r
= DWARF2_FRAME_REG_OUT (cfi
->dw_cfi_oprnd2
.dw_cfi_reg_num
, for_eh
);
1998 dw2_asm_output_data_uleb128 (r
, NULL
);
2001 case DW_CFA_def_cfa_offset
:
2002 case DW_CFA_GNU_args_size
:
2003 dw2_asm_output_data_uleb128 (cfi
->dw_cfi_oprnd1
.dw_cfi_offset
, NULL
);
2006 case DW_CFA_def_cfa_offset_sf
:
2007 dw2_asm_output_data_sleb128 (cfi
->dw_cfi_oprnd1
.dw_cfi_offset
, NULL
);
2010 case DW_CFA_GNU_window_save
:
2013 case DW_CFA_def_cfa_expression
:
2014 case DW_CFA_expression
:
2015 output_cfa_loc (cfi
);
2018 case DW_CFA_GNU_negative_offset_extended
:
2019 /* Obsoleted by DW_CFA_offset_extended_sf. */
2028 /* Output the call frame information used to record information
2029 that relates to calculating the frame pointer, and records the
2030 location of saved registers. */
2033 output_call_frame_info (int for_eh
)
2038 char l1
[20], l2
[20], section_start_label
[20];
2039 bool any_lsda_needed
= false;
2040 char augmentation
[6];
2041 int augmentation_size
;
2042 int fde_encoding
= DW_EH_PE_absptr
;
2043 int per_encoding
= DW_EH_PE_absptr
;
2044 int lsda_encoding
= DW_EH_PE_absptr
;
2046 /* Don't emit a CIE if there won't be any FDEs. */
2047 if (fde_table_in_use
== 0)
2050 /* If we make FDEs linkonce, we may have to emit an empty label for
2051 an FDE that wouldn't otherwise be emitted. We want to avoid
2052 having an FDE kept around when the function it refers to is
2053 discarded. (Example where this matters: a primary function
2054 template in C++ requires EH information, but an explicit
2055 specialization doesn't. */
2056 if (TARGET_USES_WEAK_UNWIND_INFO
2057 && ! flag_asynchronous_unwind_tables
2059 for (i
= 0; i
< fde_table_in_use
; i
++)
2060 if ((fde_table
[i
].nothrow
|| fde_table
[i
].all_throwers_are_sibcalls
)
2061 && !fde_table
[i
].uses_eh_lsda
2062 && ! DECL_ONE_ONLY (fde_table
[i
].decl
))
2063 targetm
.asm_out
.unwind_label (asm_out_file
, fde_table
[i
].decl
,
2064 for_eh
, /* empty */ 1);
2066 /* If we don't have any functions we'll want to unwind out of, don't
2067 emit any EH unwind information. Note that if exceptions aren't
2068 enabled, we won't have collected nothrow information, and if we
2069 asked for asynchronous tables, we always want this info. */
2072 bool any_eh_needed
= !flag_exceptions
|| flag_asynchronous_unwind_tables
;
2074 for (i
= 0; i
< fde_table_in_use
; i
++)
2075 if (fde_table
[i
].uses_eh_lsda
)
2076 any_eh_needed
= any_lsda_needed
= true;
2077 else if (TARGET_USES_WEAK_UNWIND_INFO
2078 && DECL_ONE_ONLY (fde_table
[i
].decl
))
2079 any_eh_needed
= true;
2080 else if (! fde_table
[i
].nothrow
2081 && ! fde_table
[i
].all_throwers_are_sibcalls
)
2082 any_eh_needed
= true;
2084 if (! any_eh_needed
)
2088 /* We're going to be generating comments, so turn on app. */
2093 targetm
.asm_out
.eh_frame_section ();
2095 named_section_flags (DEBUG_FRAME_SECTION
, SECTION_DEBUG
);
2097 ASM_GENERATE_INTERNAL_LABEL (section_start_label
, FRAME_BEGIN_LABEL
, for_eh
);
2098 ASM_OUTPUT_LABEL (asm_out_file
, section_start_label
);
2100 /* Output the CIE. */
2101 ASM_GENERATE_INTERNAL_LABEL (l1
, CIE_AFTER_SIZE_LABEL
, for_eh
);
2102 ASM_GENERATE_INTERNAL_LABEL (l2
, CIE_END_LABEL
, for_eh
);
2103 dw2_asm_output_delta (for_eh
? 4 : DWARF_OFFSET_SIZE
, l2
, l1
,
2104 "Length of Common Information Entry");
2105 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
2107 /* Now that the CIE pointer is PC-relative for EH,
2108 use 0 to identify the CIE. */
2109 dw2_asm_output_data ((for_eh
? 4 : DWARF_OFFSET_SIZE
),
2110 (for_eh
? 0 : DW_CIE_ID
),
2111 "CIE Identifier Tag");
2113 dw2_asm_output_data (1, DW_CIE_VERSION
, "CIE Version");
2115 augmentation
[0] = 0;
2116 augmentation_size
= 0;
2122 z Indicates that a uleb128 is present to size the
2123 augmentation section.
2124 L Indicates the encoding (and thus presence) of
2125 an LSDA pointer in the FDE augmentation.
2126 R Indicates a non-default pointer encoding for
2128 P Indicates the presence of an encoding + language
2129 personality routine in the CIE augmentation. */
2131 fde_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0);
2132 per_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
2133 lsda_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
2135 p
= augmentation
+ 1;
2136 if (eh_personality_libfunc
)
2139 augmentation_size
+= 1 + size_of_encoded_value (per_encoding
);
2141 if (any_lsda_needed
)
2144 augmentation_size
+= 1;
2146 if (fde_encoding
!= DW_EH_PE_absptr
)
2149 augmentation_size
+= 1;
2151 if (p
> augmentation
+ 1)
2153 augmentation
[0] = 'z';
2157 /* Ug. Some platforms can't do unaligned dynamic relocations at all. */
2158 if (eh_personality_libfunc
&& per_encoding
== DW_EH_PE_aligned
)
2160 int offset
= ( 4 /* Length */
2162 + 1 /* CIE version */
2163 + strlen (augmentation
) + 1 /* Augmentation */
2164 + size_of_uleb128 (1) /* Code alignment */
2165 + size_of_sleb128 (DWARF_CIE_DATA_ALIGNMENT
)
2167 + 1 /* Augmentation size */
2168 + 1 /* Personality encoding */ );
2169 int pad
= -offset
& (PTR_SIZE
- 1);
2171 augmentation_size
+= pad
;
2173 /* Augmentations should be small, so there's scarce need to
2174 iterate for a solution. Die if we exceed one uleb128 byte. */
2175 gcc_assert (size_of_uleb128 (augmentation_size
) == 1);
2179 dw2_asm_output_nstring (augmentation
, -1, "CIE Augmentation");
2180 dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor");
2181 dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT
,
2182 "CIE Data Alignment Factor");
2184 if (DW_CIE_VERSION
== 1)
2185 dw2_asm_output_data (1, DWARF_FRAME_RETURN_COLUMN
, "CIE RA Column");
2187 dw2_asm_output_data_uleb128 (DWARF_FRAME_RETURN_COLUMN
, "CIE RA Column");
2189 if (augmentation
[0])
2191 dw2_asm_output_data_uleb128 (augmentation_size
, "Augmentation size");
2192 if (eh_personality_libfunc
)
2194 dw2_asm_output_data (1, per_encoding
, "Personality (%s)",
2195 eh_data_format_name (per_encoding
));
2196 dw2_asm_output_encoded_addr_rtx (per_encoding
,
2197 eh_personality_libfunc
, NULL
);
2200 if (any_lsda_needed
)
2201 dw2_asm_output_data (1, lsda_encoding
, "LSDA Encoding (%s)",
2202 eh_data_format_name (lsda_encoding
));
2204 if (fde_encoding
!= DW_EH_PE_absptr
)
2205 dw2_asm_output_data (1, fde_encoding
, "FDE Encoding (%s)",
2206 eh_data_format_name (fde_encoding
));
2209 for (cfi
= cie_cfi_head
; cfi
!= NULL
; cfi
= cfi
->dw_cfi_next
)
2210 output_cfi (cfi
, NULL
, for_eh
);
2212 /* Pad the CIE out to an address sized boundary. */
2213 ASM_OUTPUT_ALIGN (asm_out_file
,
2214 floor_log2 (for_eh
? PTR_SIZE
: DWARF2_ADDR_SIZE
));
2215 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
2217 /* Loop through all of the FDE's. */
2218 for (i
= 0; i
< fde_table_in_use
; i
++)
2220 fde
= &fde_table
[i
];
2222 /* Don't emit EH unwind info for leaf functions that don't need it. */
2223 if (for_eh
&& !flag_asynchronous_unwind_tables
&& flag_exceptions
2224 && (fde
->nothrow
|| fde
->all_throwers_are_sibcalls
)
2225 && (! TARGET_USES_WEAK_UNWIND_INFO
|| ! DECL_ONE_ONLY (fde
->decl
))
2226 && !fde
->uses_eh_lsda
)
2229 targetm
.asm_out
.unwind_label (asm_out_file
, fde
->decl
, for_eh
, /* empty */ 0);
2230 targetm
.asm_out
.internal_label (asm_out_file
, FDE_LABEL
, for_eh
+ i
* 2);
2231 ASM_GENERATE_INTERNAL_LABEL (l1
, FDE_AFTER_SIZE_LABEL
, for_eh
+ i
* 2);
2232 ASM_GENERATE_INTERNAL_LABEL (l2
, FDE_END_LABEL
, for_eh
+ i
* 2);
2233 dw2_asm_output_delta (for_eh
? 4 : DWARF_OFFSET_SIZE
, l2
, l1
,
2235 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
2238 dw2_asm_output_delta (4, l1
, section_start_label
, "FDE CIE offset");
2240 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, section_start_label
,
2245 rtx sym_ref
= gen_rtx_SYMBOL_REF (Pmode
, fde
->dw_fde_begin
);
2246 SYMBOL_REF_FLAGS (sym_ref
) |= SYMBOL_FLAG_LOCAL
;
2247 dw2_asm_output_encoded_addr_rtx (fde_encoding
,
2249 "FDE initial location");
2250 dw2_asm_output_delta (size_of_encoded_value (fde_encoding
),
2251 fde
->dw_fde_end
, fde
->dw_fde_begin
,
2252 "FDE address range");
2256 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, fde
->dw_fde_begin
,
2257 "FDE initial location");
2258 dw2_asm_output_delta (DWARF2_ADDR_SIZE
,
2259 fde
->dw_fde_end
, fde
->dw_fde_begin
,
2260 "FDE address range");
2263 if (augmentation
[0])
2265 if (any_lsda_needed
)
2267 int size
= size_of_encoded_value (lsda_encoding
);
2269 if (lsda_encoding
== DW_EH_PE_aligned
)
2271 int offset
= ( 4 /* Length */
2272 + 4 /* CIE offset */
2273 + 2 * size_of_encoded_value (fde_encoding
)
2274 + 1 /* Augmentation size */ );
2275 int pad
= -offset
& (PTR_SIZE
- 1);
2278 gcc_assert (size_of_uleb128 (size
) == 1);
2281 dw2_asm_output_data_uleb128 (size
, "Augmentation size");
2283 if (fde
->uses_eh_lsda
)
2285 ASM_GENERATE_INTERNAL_LABEL (l1
, "LLSDA",
2286 fde
->funcdef_number
);
2287 dw2_asm_output_encoded_addr_rtx (
2288 lsda_encoding
, gen_rtx_SYMBOL_REF (Pmode
, l1
),
2289 "Language Specific Data Area");
2293 if (lsda_encoding
== DW_EH_PE_aligned
)
2294 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (PTR_SIZE
));
2296 (size_of_encoded_value (lsda_encoding
), 0,
2297 "Language Specific Data Area (none)");
2301 dw2_asm_output_data_uleb128 (0, "Augmentation size");
2304 /* Loop through the Call Frame Instructions associated with
2306 fde
->dw_fde_current_label
= fde
->dw_fde_begin
;
2307 for (cfi
= fde
->dw_fde_cfi
; cfi
!= NULL
; cfi
= cfi
->dw_cfi_next
)
2308 output_cfi (cfi
, fde
, for_eh
);
2310 /* Pad the FDE out to an address sized boundary. */
2311 ASM_OUTPUT_ALIGN (asm_out_file
,
2312 floor_log2 ((for_eh
? PTR_SIZE
: DWARF2_ADDR_SIZE
)));
2313 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
2316 if (for_eh
&& targetm
.terminate_dw2_eh_frame_info
)
2317 dw2_asm_output_data (4, 0, "End of Table");
2318 #ifdef MIPS_DEBUGGING_INFO
2319 /* Work around Irix 6 assembler bug whereby labels at the end of a section
2320 get a value of 0. Putting .align 0 after the label fixes it. */
2321 ASM_OUTPUT_ALIGN (asm_out_file
, 0);
2324 /* Turn off app to make assembly quicker. */
2329 /* Output a marker (i.e. a label) for the beginning of a function, before
2333 dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED
,
2334 const char *file ATTRIBUTE_UNUSED
)
2336 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
2339 current_function_func_begin_label
= 0;
2341 #ifdef TARGET_UNWIND_INFO
2342 /* ??? current_function_func_begin_label is also used by except.c
2343 for call-site information. We must emit this label if it might
2345 if ((! flag_exceptions
|| USING_SJLJ_EXCEPTIONS
)
2346 && ! dwarf2out_do_frame ())
2349 if (! dwarf2out_do_frame ())
2353 function_section (current_function_decl
);
2354 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_BEGIN_LABEL
,
2355 current_function_funcdef_no
);
2356 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, FUNC_BEGIN_LABEL
,
2357 current_function_funcdef_no
);
2358 current_function_func_begin_label
= get_identifier (label
);
2360 #ifdef TARGET_UNWIND_INFO
2361 /* We can elide the fde allocation if we're not emitting debug info. */
2362 if (! dwarf2out_do_frame ())
2366 /* Expand the fde table if necessary. */
2367 if (fde_table_in_use
== fde_table_allocated
)
2369 fde_table_allocated
+= FDE_TABLE_INCREMENT
;
2370 fde_table
= ggc_realloc (fde_table
,
2371 fde_table_allocated
* sizeof (dw_fde_node
));
2372 memset (fde_table
+ fde_table_in_use
, 0,
2373 FDE_TABLE_INCREMENT
* sizeof (dw_fde_node
));
2376 /* Record the FDE associated with this function. */
2377 current_funcdef_fde
= fde_table_in_use
;
2379 /* Add the new FDE at the end of the fde_table. */
2380 fde
= &fde_table
[fde_table_in_use
++];
2381 fde
->decl
= current_function_decl
;
2382 fde
->dw_fde_begin
= xstrdup (label
);
2383 fde
->dw_fde_current_label
= NULL
;
2384 fde
->dw_fde_end
= NULL
;
2385 fde
->dw_fde_cfi
= NULL
;
2386 fde
->funcdef_number
= current_function_funcdef_no
;
2387 fde
->nothrow
= TREE_NOTHROW (current_function_decl
);
2388 fde
->uses_eh_lsda
= cfun
->uses_eh_lsda
;
2389 fde
->all_throwers_are_sibcalls
= cfun
->all_throwers_are_sibcalls
;
2391 args_size
= old_args_size
= 0;
2393 /* We only want to output line number information for the genuine dwarf2
2394 prologue case, not the eh frame case. */
2395 #ifdef DWARF2_DEBUGGING_INFO
2397 dwarf2out_source_line (line
, file
);
2401 /* Output a marker (i.e. a label) for the absolute end of the generated code
2402 for a function definition. This gets called *after* the epilogue code has
2406 dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED
,
2407 const char *file ATTRIBUTE_UNUSED
)
2410 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
2412 /* Output a label to mark the endpoint of the code generated for this
2414 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_END_LABEL
,
2415 current_function_funcdef_no
);
2416 ASM_OUTPUT_LABEL (asm_out_file
, label
);
2417 fde
= &fde_table
[fde_table_in_use
- 1];
2418 fde
->dw_fde_end
= xstrdup (label
);
2422 dwarf2out_frame_init (void)
2424 /* Allocate the initial hunk of the fde_table. */
2425 fde_table
= ggc_alloc_cleared (FDE_TABLE_INCREMENT
* sizeof (dw_fde_node
));
2426 fde_table_allocated
= FDE_TABLE_INCREMENT
;
2427 fde_table_in_use
= 0;
2429 /* Generate the CFA instructions common to all FDE's. Do it now for the
2430 sake of lookup_cfa. */
2432 #ifdef DWARF2_UNWIND_INFO
2433 /* On entry, the Canonical Frame Address is at SP. */
2434 dwarf2out_def_cfa (NULL
, STACK_POINTER_REGNUM
, INCOMING_FRAME_SP_OFFSET
);
2435 initial_return_save (INCOMING_RETURN_ADDR_RTX
);
2440 dwarf2out_frame_finish (void)
2442 /* Output call frame information. */
2443 if (write_symbols
== DWARF2_DEBUG
|| write_symbols
== VMS_AND_DWARF2_DEBUG
)
2444 output_call_frame_info (0);
2446 #ifndef TARGET_UNWIND_INFO
2447 /* Output another copy for the unwinder. */
2448 if (! USING_SJLJ_EXCEPTIONS
&& (flag_unwind_tables
|| flag_exceptions
))
2449 output_call_frame_info (1);
2454 /* And now, the subset of the debugging information support code necessary
2455 for emitting location expressions. */
2457 /* We need some way to distinguish DW_OP_addr with a direct symbol
2458 relocation from DW_OP_addr with a dtp-relative symbol relocation. */
2459 #define INTERNAL_DW_OP_tls_addr (0x100 + DW_OP_addr)
2462 typedef struct dw_val_struct
*dw_val_ref
;
2463 typedef struct die_struct
*dw_die_ref
;
2464 typedef struct dw_loc_descr_struct
*dw_loc_descr_ref
;
2465 typedef struct dw_loc_list_struct
*dw_loc_list_ref
;
2467 /* Each DIE may have a series of attribute/value pairs. Values
2468 can take on several forms. The forms that are used in this
2469 implementation are listed below. */
2474 dw_val_class_offset
,
2476 dw_val_class_loc_list
,
2477 dw_val_class_range_list
,
2479 dw_val_class_unsigned_const
,
2480 dw_val_class_long_long
,
2483 dw_val_class_die_ref
,
2484 dw_val_class_fde_ref
,
2485 dw_val_class_lbl_id
,
2486 dw_val_class_lbl_offset
,
2490 /* Describe a double word constant value. */
2491 /* ??? Every instance of long_long in the code really means CONST_DOUBLE. */
2493 typedef struct dw_long_long_struct
GTY(())
2500 /* Describe a floating point constant value, or a vector constant value. */
2502 typedef struct dw_vec_struct
GTY(())
2504 unsigned char * GTY((length ("%h.length"))) array
;
2510 /* The dw_val_node describes an attribute's value, as it is
2511 represented internally. */
2513 typedef struct dw_val_struct
GTY(())
2515 enum dw_val_class val_class
;
2516 union dw_val_struct_union
2518 rtx
GTY ((tag ("dw_val_class_addr"))) val_addr
;
2519 unsigned HOST_WIDE_INT
GTY ((tag ("dw_val_class_offset"))) val_offset
;
2520 dw_loc_list_ref
GTY ((tag ("dw_val_class_loc_list"))) val_loc_list
;
2521 dw_loc_descr_ref
GTY ((tag ("dw_val_class_loc"))) val_loc
;
2522 HOST_WIDE_INT
GTY ((default)) val_int
;
2523 unsigned HOST_WIDE_INT
GTY ((tag ("dw_val_class_unsigned_const"))) val_unsigned
;
2524 dw_long_long_const
GTY ((tag ("dw_val_class_long_long"))) val_long_long
;
2525 dw_vec_const
GTY ((tag ("dw_val_class_vec"))) val_vec
;
2526 struct dw_val_die_union
2530 } GTY ((tag ("dw_val_class_die_ref"))) val_die_ref
;
2531 unsigned GTY ((tag ("dw_val_class_fde_ref"))) val_fde_index
;
2532 struct indirect_string_node
* GTY ((tag ("dw_val_class_str"))) val_str
;
2533 char * GTY ((tag ("dw_val_class_lbl_id"))) val_lbl_id
;
2534 unsigned char GTY ((tag ("dw_val_class_flag"))) val_flag
;
2536 GTY ((desc ("%1.val_class"))) v
;
2540 /* Locations in memory are described using a sequence of stack machine
2543 typedef struct dw_loc_descr_struct
GTY(())
2545 dw_loc_descr_ref dw_loc_next
;
2546 enum dwarf_location_atom dw_loc_opc
;
2547 dw_val_node dw_loc_oprnd1
;
2548 dw_val_node dw_loc_oprnd2
;
2553 /* Location lists are ranges + location descriptions for that range,
2554 so you can track variables that are in different places over
2555 their entire life. */
2556 typedef struct dw_loc_list_struct
GTY(())
2558 dw_loc_list_ref dw_loc_next
;
2559 const char *begin
; /* Label for begin address of range */
2560 const char *end
; /* Label for end address of range */
2561 char *ll_symbol
; /* Label for beginning of location list.
2562 Only on head of list */
2563 const char *section
; /* Section this loclist is relative to */
2564 dw_loc_descr_ref expr
;
2567 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
2569 static const char *dwarf_stack_op_name (unsigned);
2570 static dw_loc_descr_ref
new_loc_descr (enum dwarf_location_atom
,
2571 unsigned HOST_WIDE_INT
, unsigned HOST_WIDE_INT
);
2572 static void add_loc_descr (dw_loc_descr_ref
*, dw_loc_descr_ref
);
2573 static unsigned long size_of_loc_descr (dw_loc_descr_ref
);
2574 static unsigned long size_of_locs (dw_loc_descr_ref
);
2575 static void output_loc_operands (dw_loc_descr_ref
);
2576 static void output_loc_sequence (dw_loc_descr_ref
);
2578 /* Convert a DWARF stack opcode into its string name. */
2581 dwarf_stack_op_name (unsigned int op
)
2586 case INTERNAL_DW_OP_tls_addr
:
2587 return "DW_OP_addr";
2589 return "DW_OP_deref";
2591 return "DW_OP_const1u";
2593 return "DW_OP_const1s";
2595 return "DW_OP_const2u";
2597 return "DW_OP_const2s";
2599 return "DW_OP_const4u";
2601 return "DW_OP_const4s";
2603 return "DW_OP_const8u";
2605 return "DW_OP_const8s";
2607 return "DW_OP_constu";
2609 return "DW_OP_consts";
2613 return "DW_OP_drop";
2615 return "DW_OP_over";
2617 return "DW_OP_pick";
2619 return "DW_OP_swap";
2623 return "DW_OP_xderef";
2631 return "DW_OP_minus";
2643 return "DW_OP_plus";
2644 case DW_OP_plus_uconst
:
2645 return "DW_OP_plus_uconst";
2651 return "DW_OP_shra";
2669 return "DW_OP_skip";
2671 return "DW_OP_lit0";
2673 return "DW_OP_lit1";
2675 return "DW_OP_lit2";
2677 return "DW_OP_lit3";
2679 return "DW_OP_lit4";
2681 return "DW_OP_lit5";
2683 return "DW_OP_lit6";
2685 return "DW_OP_lit7";
2687 return "DW_OP_lit8";
2689 return "DW_OP_lit9";
2691 return "DW_OP_lit10";
2693 return "DW_OP_lit11";
2695 return "DW_OP_lit12";
2697 return "DW_OP_lit13";
2699 return "DW_OP_lit14";
2701 return "DW_OP_lit15";
2703 return "DW_OP_lit16";
2705 return "DW_OP_lit17";
2707 return "DW_OP_lit18";
2709 return "DW_OP_lit19";
2711 return "DW_OP_lit20";
2713 return "DW_OP_lit21";
2715 return "DW_OP_lit22";
2717 return "DW_OP_lit23";
2719 return "DW_OP_lit24";
2721 return "DW_OP_lit25";
2723 return "DW_OP_lit26";
2725 return "DW_OP_lit27";
2727 return "DW_OP_lit28";
2729 return "DW_OP_lit29";
2731 return "DW_OP_lit30";
2733 return "DW_OP_lit31";
2735 return "DW_OP_reg0";
2737 return "DW_OP_reg1";
2739 return "DW_OP_reg2";
2741 return "DW_OP_reg3";
2743 return "DW_OP_reg4";
2745 return "DW_OP_reg5";
2747 return "DW_OP_reg6";
2749 return "DW_OP_reg7";
2751 return "DW_OP_reg8";
2753 return "DW_OP_reg9";
2755 return "DW_OP_reg10";
2757 return "DW_OP_reg11";
2759 return "DW_OP_reg12";
2761 return "DW_OP_reg13";
2763 return "DW_OP_reg14";
2765 return "DW_OP_reg15";
2767 return "DW_OP_reg16";
2769 return "DW_OP_reg17";
2771 return "DW_OP_reg18";
2773 return "DW_OP_reg19";
2775 return "DW_OP_reg20";
2777 return "DW_OP_reg21";
2779 return "DW_OP_reg22";
2781 return "DW_OP_reg23";
2783 return "DW_OP_reg24";
2785 return "DW_OP_reg25";
2787 return "DW_OP_reg26";
2789 return "DW_OP_reg27";
2791 return "DW_OP_reg28";
2793 return "DW_OP_reg29";
2795 return "DW_OP_reg30";
2797 return "DW_OP_reg31";
2799 return "DW_OP_breg0";
2801 return "DW_OP_breg1";
2803 return "DW_OP_breg2";
2805 return "DW_OP_breg3";
2807 return "DW_OP_breg4";
2809 return "DW_OP_breg5";
2811 return "DW_OP_breg6";
2813 return "DW_OP_breg7";
2815 return "DW_OP_breg8";
2817 return "DW_OP_breg9";
2819 return "DW_OP_breg10";
2821 return "DW_OP_breg11";
2823 return "DW_OP_breg12";
2825 return "DW_OP_breg13";
2827 return "DW_OP_breg14";
2829 return "DW_OP_breg15";
2831 return "DW_OP_breg16";
2833 return "DW_OP_breg17";
2835 return "DW_OP_breg18";
2837 return "DW_OP_breg19";
2839 return "DW_OP_breg20";
2841 return "DW_OP_breg21";
2843 return "DW_OP_breg22";
2845 return "DW_OP_breg23";
2847 return "DW_OP_breg24";
2849 return "DW_OP_breg25";
2851 return "DW_OP_breg26";
2853 return "DW_OP_breg27";
2855 return "DW_OP_breg28";
2857 return "DW_OP_breg29";
2859 return "DW_OP_breg30";
2861 return "DW_OP_breg31";
2863 return "DW_OP_regx";
2865 return "DW_OP_fbreg";
2867 return "DW_OP_bregx";
2869 return "DW_OP_piece";
2870 case DW_OP_deref_size
:
2871 return "DW_OP_deref_size";
2872 case DW_OP_xderef_size
:
2873 return "DW_OP_xderef_size";
2876 case DW_OP_push_object_address
:
2877 return "DW_OP_push_object_address";
2879 return "DW_OP_call2";
2881 return "DW_OP_call4";
2882 case DW_OP_call_ref
:
2883 return "DW_OP_call_ref";
2884 case DW_OP_GNU_push_tls_address
:
2885 return "DW_OP_GNU_push_tls_address";
2887 return "OP_<unknown>";
2891 /* Return a pointer to a newly allocated location description. Location
2892 descriptions are simple expression terms that can be strung
2893 together to form more complicated location (address) descriptions. */
2895 static inline dw_loc_descr_ref
2896 new_loc_descr (enum dwarf_location_atom op
, unsigned HOST_WIDE_INT oprnd1
,
2897 unsigned HOST_WIDE_INT oprnd2
)
2899 dw_loc_descr_ref descr
= ggc_alloc_cleared (sizeof (dw_loc_descr_node
));
2901 descr
->dw_loc_opc
= op
;
2902 descr
->dw_loc_oprnd1
.val_class
= dw_val_class_unsigned_const
;
2903 descr
->dw_loc_oprnd1
.v
.val_unsigned
= oprnd1
;
2904 descr
->dw_loc_oprnd2
.val_class
= dw_val_class_unsigned_const
;
2905 descr
->dw_loc_oprnd2
.v
.val_unsigned
= oprnd2
;
2911 /* Add a location description term to a location description expression. */
2914 add_loc_descr (dw_loc_descr_ref
*list_head
, dw_loc_descr_ref descr
)
2916 dw_loc_descr_ref
*d
;
2918 /* Find the end of the chain. */
2919 for (d
= list_head
; (*d
) != NULL
; d
= &(*d
)->dw_loc_next
)
2925 /* Return the size of a location descriptor. */
2927 static unsigned long
2928 size_of_loc_descr (dw_loc_descr_ref loc
)
2930 unsigned long size
= 1;
2932 switch (loc
->dw_loc_opc
)
2935 case INTERNAL_DW_OP_tls_addr
:
2936 size
+= DWARF2_ADDR_SIZE
;
2955 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
2958 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
2963 case DW_OP_plus_uconst
:
2964 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
3002 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
3005 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
3008 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
3011 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
3012 size
+= size_of_sleb128 (loc
->dw_loc_oprnd2
.v
.val_int
);
3015 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
3017 case DW_OP_deref_size
:
3018 case DW_OP_xderef_size
:
3027 case DW_OP_call_ref
:
3028 size
+= DWARF2_ADDR_SIZE
;
3037 /* Return the size of a series of location descriptors. */
3039 static unsigned long
3040 size_of_locs (dw_loc_descr_ref loc
)
3044 for (size
= 0; loc
!= NULL
; loc
= loc
->dw_loc_next
)
3046 loc
->dw_loc_addr
= size
;
3047 size
+= size_of_loc_descr (loc
);
3053 /* Output location description stack opcode's operands (if any). */
3056 output_loc_operands (dw_loc_descr_ref loc
)
3058 dw_val_ref val1
= &loc
->dw_loc_oprnd1
;
3059 dw_val_ref val2
= &loc
->dw_loc_oprnd2
;
3061 switch (loc
->dw_loc_opc
)
3063 #ifdef DWARF2_DEBUGGING_INFO
3065 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, val1
->v
.val_addr
, NULL
);
3069 dw2_asm_output_data (2, val1
->v
.val_int
, NULL
);
3073 dw2_asm_output_data (4, val1
->v
.val_int
, NULL
);
3077 gcc_assert (HOST_BITS_PER_LONG
>= 64);
3078 dw2_asm_output_data (8, val1
->v
.val_int
, NULL
);
3085 gcc_assert (val1
->val_class
== dw_val_class_loc
);
3086 offset
= val1
->v
.val_loc
->dw_loc_addr
- (loc
->dw_loc_addr
+ 3);
3088 dw2_asm_output_data (2, offset
, NULL
);
3101 /* We currently don't make any attempt to make sure these are
3102 aligned properly like we do for the main unwind info, so
3103 don't support emitting things larger than a byte if we're
3104 only doing unwinding. */
3109 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
3112 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
3115 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
3118 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
3120 case DW_OP_plus_uconst
:
3121 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
3155 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
3158 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
3161 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
3164 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
3165 dw2_asm_output_data_sleb128 (val2
->v
.val_int
, NULL
);
3168 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
3170 case DW_OP_deref_size
:
3171 case DW_OP_xderef_size
:
3172 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
3175 case INTERNAL_DW_OP_tls_addr
:
3176 #ifdef ASM_OUTPUT_DWARF_DTPREL
3177 ASM_OUTPUT_DWARF_DTPREL (asm_out_file
, DWARF2_ADDR_SIZE
,
3179 fputc ('\n', asm_out_file
);
3186 /* Other codes have no operands. */
3191 /* Output a sequence of location operations. */
3194 output_loc_sequence (dw_loc_descr_ref loc
)
3196 for (; loc
!= NULL
; loc
= loc
->dw_loc_next
)
3198 /* Output the opcode. */
3199 dw2_asm_output_data (1, loc
->dw_loc_opc
,
3200 "%s", dwarf_stack_op_name (loc
->dw_loc_opc
));
3202 /* Output the operand(s) (if any). */
3203 output_loc_operands (loc
);
3207 /* This routine will generate the correct assembly data for a location
3208 description based on a cfi entry with a complex address. */
3211 output_cfa_loc (dw_cfi_ref cfi
)
3213 dw_loc_descr_ref loc
;
3216 /* Output the size of the block. */
3217 loc
= cfi
->dw_cfi_oprnd1
.dw_cfi_loc
;
3218 size
= size_of_locs (loc
);
3219 dw2_asm_output_data_uleb128 (size
, NULL
);
3221 /* Now output the operations themselves. */
3222 output_loc_sequence (loc
);
3225 /* This function builds a dwarf location descriptor sequence from
3226 a dw_cfa_location. */
3228 static struct dw_loc_descr_struct
*
3229 build_cfa_loc (dw_cfa_location
*cfa
)
3231 struct dw_loc_descr_struct
*head
, *tmp
;
3233 gcc_assert (cfa
->indirect
);
3235 if (cfa
->base_offset
)
3238 head
= new_loc_descr (DW_OP_breg0
+ cfa
->reg
, cfa
->base_offset
, 0);
3240 head
= new_loc_descr (DW_OP_bregx
, cfa
->reg
, cfa
->base_offset
);
3242 else if (cfa
->reg
<= 31)
3243 head
= new_loc_descr (DW_OP_reg0
+ cfa
->reg
, 0, 0);
3245 head
= new_loc_descr (DW_OP_regx
, cfa
->reg
, 0);
3247 head
->dw_loc_oprnd1
.val_class
= dw_val_class_const
;
3248 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
3249 add_loc_descr (&head
, tmp
);
3250 if (cfa
->offset
!= 0)
3252 tmp
= new_loc_descr (DW_OP_plus_uconst
, cfa
->offset
, 0);
3253 add_loc_descr (&head
, tmp
);
3259 /* This function fills in aa dw_cfa_location structure from a dwarf location
3260 descriptor sequence. */
3263 get_cfa_from_loc_descr (dw_cfa_location
*cfa
, struct dw_loc_descr_struct
*loc
)
3265 struct dw_loc_descr_struct
*ptr
;
3267 cfa
->base_offset
= 0;
3271 for (ptr
= loc
; ptr
!= NULL
; ptr
= ptr
->dw_loc_next
)
3273 enum dwarf_location_atom op
= ptr
->dw_loc_opc
;
3309 cfa
->reg
= op
- DW_OP_reg0
;
3312 cfa
->reg
= ptr
->dw_loc_oprnd1
.v
.val_int
;
3346 cfa
->reg
= op
- DW_OP_breg0
;
3347 cfa
->base_offset
= ptr
->dw_loc_oprnd1
.v
.val_int
;
3350 cfa
->reg
= ptr
->dw_loc_oprnd1
.v
.val_int
;
3351 cfa
->base_offset
= ptr
->dw_loc_oprnd2
.v
.val_int
;
3356 case DW_OP_plus_uconst
:
3357 cfa
->offset
= ptr
->dw_loc_oprnd1
.v
.val_unsigned
;
3360 internal_error ("DW_LOC_OP %s not implemented\n",
3361 dwarf_stack_op_name (ptr
->dw_loc_opc
));
3365 #endif /* .debug_frame support */
3367 /* And now, the support for symbolic debugging information. */
3368 #ifdef DWARF2_DEBUGGING_INFO
3370 /* .debug_str support. */
3371 static int output_indirect_string (void **, void *);
3373 static void dwarf2out_init (const char *);
3374 static void dwarf2out_finish (const char *);
3375 static void dwarf2out_define (unsigned int, const char *);
3376 static void dwarf2out_undef (unsigned int, const char *);
3377 static void dwarf2out_start_source_file (unsigned, const char *);
3378 static void dwarf2out_end_source_file (unsigned);
3379 static void dwarf2out_begin_block (unsigned, unsigned);
3380 static void dwarf2out_end_block (unsigned, unsigned);
3381 static bool dwarf2out_ignore_block (tree
);
3382 static void dwarf2out_global_decl (tree
);
3383 static void dwarf2out_type_decl (tree
, int);
3384 static void dwarf2out_imported_module_or_decl (tree
, tree
);
3385 static void dwarf2out_abstract_function (tree
);
3386 static void dwarf2out_var_location (rtx
);
3387 static void dwarf2out_begin_function (tree
);
3389 /* The debug hooks structure. */
3391 const struct gcc_debug_hooks dwarf2_debug_hooks
=
3397 dwarf2out_start_source_file
,
3398 dwarf2out_end_source_file
,
3399 dwarf2out_begin_block
,
3400 dwarf2out_end_block
,
3401 dwarf2out_ignore_block
,
3402 dwarf2out_source_line
,
3403 dwarf2out_begin_prologue
,
3404 debug_nothing_int_charstar
, /* end_prologue */
3405 dwarf2out_end_epilogue
,
3406 dwarf2out_begin_function
,
3407 debug_nothing_int
, /* end_function */
3408 dwarf2out_decl
, /* function_decl */
3409 dwarf2out_global_decl
,
3410 dwarf2out_type_decl
, /* type_decl */
3411 dwarf2out_imported_module_or_decl
,
3412 debug_nothing_tree
, /* deferred_inline_function */
3413 /* The DWARF 2 backend tries to reduce debugging bloat by not
3414 emitting the abstract description of inline functions until
3415 something tries to reference them. */
3416 dwarf2out_abstract_function
, /* outlining_inline_function */
3417 debug_nothing_rtx
, /* label */
3418 debug_nothing_int
, /* handle_pch */
3419 dwarf2out_var_location
3423 /* NOTE: In the comments in this file, many references are made to
3424 "Debugging Information Entries". This term is abbreviated as `DIE'
3425 throughout the remainder of this file. */
3427 /* An internal representation of the DWARF output is built, and then
3428 walked to generate the DWARF debugging info. The walk of the internal
3429 representation is done after the entire program has been compiled.
3430 The types below are used to describe the internal representation. */
3432 /* Various DIE's use offsets relative to the beginning of the
3433 .debug_info section to refer to each other. */
3435 typedef long int dw_offset
;
3437 /* Define typedefs here to avoid circular dependencies. */
3439 typedef struct dw_attr_struct
*dw_attr_ref
;
3440 typedef struct dw_line_info_struct
*dw_line_info_ref
;
3441 typedef struct dw_separate_line_info_struct
*dw_separate_line_info_ref
;
3442 typedef struct pubname_struct
*pubname_ref
;
3443 typedef struct dw_ranges_struct
*dw_ranges_ref
;
3445 /* Each entry in the line_info_table maintains the file and
3446 line number associated with the label generated for that
3447 entry. The label gives the PC value associated with
3448 the line number entry. */
3450 typedef struct dw_line_info_struct
GTY(())
3452 unsigned long dw_file_num
;
3453 unsigned long dw_line_num
;
3457 /* Line information for functions in separate sections; each one gets its
3459 typedef struct dw_separate_line_info_struct
GTY(())
3461 unsigned long dw_file_num
;
3462 unsigned long dw_line_num
;
3463 unsigned long function
;
3465 dw_separate_line_info_entry
;
3467 /* Each DIE attribute has a field specifying the attribute kind,
3468 a link to the next attribute in the chain, and an attribute value.
3469 Attributes are typically linked below the DIE they modify. */
3471 typedef struct dw_attr_struct
GTY(())
3473 enum dwarf_attribute dw_attr
;
3474 dw_attr_ref dw_attr_next
;
3475 dw_val_node dw_attr_val
;
3479 /* The Debugging Information Entry (DIE) structure */
3481 typedef struct die_struct
GTY(())
3483 enum dwarf_tag die_tag
;
3485 dw_attr_ref die_attr
;
3486 dw_die_ref die_parent
;
3487 dw_die_ref die_child
;
3489 dw_die_ref die_definition
; /* ref from a specification to its definition */
3490 dw_offset die_offset
;
3491 unsigned long die_abbrev
;
3493 unsigned int decl_id
;
3497 /* The pubname structure */
3499 typedef struct pubname_struct
GTY(())
3506 struct dw_ranges_struct
GTY(())
3511 /* The limbo die list structure. */
3512 typedef struct limbo_die_struct
GTY(())
3516 struct limbo_die_struct
*next
;
3520 /* How to start an assembler comment. */
3521 #ifndef ASM_COMMENT_START
3522 #define ASM_COMMENT_START ";#"
3525 /* Define a macro which returns nonzero for a TYPE_DECL which was
3526 implicitly generated for a tagged type.
3528 Note that unlike the gcc front end (which generates a NULL named
3529 TYPE_DECL node for each complete tagged type, each array type, and
3530 each function type node created) the g++ front end generates a
3531 _named_ TYPE_DECL node for each tagged type node created.
3532 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
3533 generate a DW_TAG_typedef DIE for them. */
3535 #define TYPE_DECL_IS_STUB(decl) \
3536 (DECL_NAME (decl) == NULL_TREE \
3537 || (DECL_ARTIFICIAL (decl) \
3538 && is_tagged_type (TREE_TYPE (decl)) \
3539 && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \
3540 /* This is necessary for stub decls that \
3541 appear in nested inline functions. */ \
3542 || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
3543 && (decl_ultimate_origin (decl) \
3544 == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
3546 /* Information concerning the compilation unit's programming
3547 language, and compiler version. */
3549 /* Fixed size portion of the DWARF compilation unit header. */
3550 #define DWARF_COMPILE_UNIT_HEADER_SIZE \
3551 (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 3)
3553 /* Fixed size portion of public names info. */
3554 #define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
3556 /* Fixed size portion of the address range info. */
3557 #define DWARF_ARANGES_HEADER_SIZE \
3558 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
3559 DWARF2_ADDR_SIZE * 2) \
3560 - DWARF_INITIAL_LENGTH_SIZE)
3562 /* Size of padding portion in the address range info. It must be
3563 aligned to twice the pointer size. */
3564 #define DWARF_ARANGES_PAD_SIZE \
3565 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
3566 DWARF2_ADDR_SIZE * 2) \
3567 - (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4))
3569 /* Use assembler line directives if available. */
3570 #ifndef DWARF2_ASM_LINE_DEBUG_INFO
3571 #ifdef HAVE_AS_DWARF2_DEBUG_LINE
3572 #define DWARF2_ASM_LINE_DEBUG_INFO 1
3574 #define DWARF2_ASM_LINE_DEBUG_INFO 0
3578 /* Minimum line offset in a special line info. opcode.
3579 This value was chosen to give a reasonable range of values. */
3580 #define DWARF_LINE_BASE -10
3582 /* First special line opcode - leave room for the standard opcodes. */
3583 #define DWARF_LINE_OPCODE_BASE 10
3585 /* Range of line offsets in a special line info. opcode. */
3586 #define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1)
3588 /* Flag that indicates the initial value of the is_stmt_start flag.
3589 In the present implementation, we do not mark any lines as
3590 the beginning of a source statement, because that information
3591 is not made available by the GCC front-end. */
3592 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
3594 #ifdef DWARF2_DEBUGGING_INFO
3595 /* This location is used by calc_die_sizes() to keep track
3596 the offset of each DIE within the .debug_info section. */
3597 static unsigned long next_die_offset
;
3600 /* Record the root of the DIE's built for the current compilation unit. */
3601 static GTY(()) dw_die_ref comp_unit_die
;
3603 /* A list of DIEs with a NULL parent waiting to be relocated. */
3604 static GTY(()) limbo_die_node
*limbo_die_list
;
3606 /* Filenames referenced by this compilation unit. */
3607 static GTY(()) varray_type file_table
;
3608 static GTY(()) varray_type file_table_emitted
;
3609 static GTY(()) size_t file_table_last_lookup_index
;
3611 /* A hash table of references to DIE's that describe declarations.
3612 The key is a DECL_UID() which is a unique number identifying each decl. */
3613 static GTY ((param_is (struct die_struct
))) htab_t decl_die_table
;
3615 /* Node of the variable location list. */
3616 struct var_loc_node
GTY ((chain_next ("%h.next")))
3618 rtx
GTY (()) var_loc_note
;
3619 const char * GTY (()) label
;
3620 struct var_loc_node
* GTY (()) next
;
3623 /* Variable location list. */
3624 struct var_loc_list_def
GTY (())
3626 struct var_loc_node
* GTY (()) first
;
3628 /* Do not mark the last element of the chained list because
3629 it is marked through the chain. */
3630 struct var_loc_node
* GTY ((skip ("%h"))) last
;
3632 /* DECL_UID of the variable decl. */
3633 unsigned int decl_id
;
3635 typedef struct var_loc_list_def var_loc_list
;
3638 /* Table of decl location linked lists. */
3639 static GTY ((param_is (var_loc_list
))) htab_t decl_loc_table
;
3641 /* A pointer to the base of a list of references to DIE's that
3642 are uniquely identified by their tag, presence/absence of
3643 children DIE's, and list of attribute/value pairs. */
3644 static GTY((length ("abbrev_die_table_allocated")))
3645 dw_die_ref
*abbrev_die_table
;
3647 /* Number of elements currently allocated for abbrev_die_table. */
3648 static GTY(()) unsigned abbrev_die_table_allocated
;
3650 /* Number of elements in type_die_table currently in use. */
3651 static GTY(()) unsigned abbrev_die_table_in_use
;
3653 /* Size (in elements) of increments by which we may expand the
3654 abbrev_die_table. */
3655 #define ABBREV_DIE_TABLE_INCREMENT 256
3657 /* A pointer to the base of a table that contains line information
3658 for each source code line in .text in the compilation unit. */
3659 static GTY((length ("line_info_table_allocated")))
3660 dw_line_info_ref line_info_table
;
3662 /* Number of elements currently allocated for line_info_table. */
3663 static GTY(()) unsigned line_info_table_allocated
;
3665 /* Number of elements in line_info_table currently in use. */
3666 static GTY(()) unsigned line_info_table_in_use
;
3668 /* A pointer to the base of a table that contains line information
3669 for each source code line outside of .text in the compilation unit. */
3670 static GTY ((length ("separate_line_info_table_allocated")))
3671 dw_separate_line_info_ref separate_line_info_table
;
3673 /* Number of elements currently allocated for separate_line_info_table. */
3674 static GTY(()) unsigned separate_line_info_table_allocated
;
3676 /* Number of elements in separate_line_info_table currently in use. */
3677 static GTY(()) unsigned separate_line_info_table_in_use
;
3679 /* Size (in elements) of increments by which we may expand the
3681 #define LINE_INFO_TABLE_INCREMENT 1024
3683 /* A pointer to the base of a table that contains a list of publicly
3684 accessible names. */
3685 static GTY ((length ("pubname_table_allocated"))) pubname_ref pubname_table
;
3687 /* Number of elements currently allocated for pubname_table. */
3688 static GTY(()) unsigned pubname_table_allocated
;
3690 /* Number of elements in pubname_table currently in use. */
3691 static GTY(()) unsigned pubname_table_in_use
;
3693 /* Size (in elements) of increments by which we may expand the
3695 #define PUBNAME_TABLE_INCREMENT 64
3697 /* Array of dies for which we should generate .debug_arange info. */
3698 static GTY((length ("arange_table_allocated"))) dw_die_ref
*arange_table
;
3700 /* Number of elements currently allocated for arange_table. */
3701 static GTY(()) unsigned arange_table_allocated
;
3703 /* Number of elements in arange_table currently in use. */
3704 static GTY(()) unsigned arange_table_in_use
;
3706 /* Size (in elements) of increments by which we may expand the
3708 #define ARANGE_TABLE_INCREMENT 64
3710 /* Array of dies for which we should generate .debug_ranges info. */
3711 static GTY ((length ("ranges_table_allocated"))) dw_ranges_ref ranges_table
;
3713 /* Number of elements currently allocated for ranges_table. */
3714 static GTY(()) unsigned ranges_table_allocated
;
3716 /* Number of elements in ranges_table currently in use. */
3717 static GTY(()) unsigned ranges_table_in_use
;
3719 /* Size (in elements) of increments by which we may expand the
3721 #define RANGES_TABLE_INCREMENT 64
3723 /* Whether we have location lists that need outputting */
3724 static GTY(()) unsigned have_location_lists
;
3726 /* Unique label counter. */
3727 static GTY(()) unsigned int loclabel_num
;
3729 #ifdef DWARF2_DEBUGGING_INFO
3730 /* Record whether the function being analyzed contains inlined functions. */
3731 static int current_function_has_inlines
;
3733 #if 0 && defined (MIPS_DEBUGGING_INFO)
3734 static int comp_unit_has_inlines
;
3737 /* Number of file tables emitted in maybe_emit_file(). */
3738 static GTY(()) int emitcount
= 0;
3740 /* Number of internal labels generated by gen_internal_sym(). */
3741 static GTY(()) int label_num
;
3743 #ifdef DWARF2_DEBUGGING_INFO
3745 /* Forward declarations for functions defined in this file. */
3747 static int is_pseudo_reg (rtx
);
3748 static tree
type_main_variant (tree
);
3749 static int is_tagged_type (tree
);
3750 static const char *dwarf_tag_name (unsigned);
3751 static const char *dwarf_attr_name (unsigned);
3752 static const char *dwarf_form_name (unsigned);
3754 static const char *dwarf_type_encoding_name (unsigned);
3756 static tree
decl_ultimate_origin (tree
);
3757 static tree
block_ultimate_origin (tree
);
3758 static tree
decl_class_context (tree
);
3759 static void add_dwarf_attr (dw_die_ref
, dw_attr_ref
);
3760 static inline enum dw_val_class
AT_class (dw_attr_ref
);
3761 static void add_AT_flag (dw_die_ref
, enum dwarf_attribute
, unsigned);
3762 static inline unsigned AT_flag (dw_attr_ref
);
3763 static void add_AT_int (dw_die_ref
, enum dwarf_attribute
, HOST_WIDE_INT
);
3764 static inline HOST_WIDE_INT
AT_int (dw_attr_ref
);
3765 static void add_AT_unsigned (dw_die_ref
, enum dwarf_attribute
, unsigned HOST_WIDE_INT
);
3766 static inline unsigned HOST_WIDE_INT
AT_unsigned (dw_attr_ref
);
3767 static void add_AT_long_long (dw_die_ref
, enum dwarf_attribute
, unsigned long,
3769 static inline void add_AT_vec (dw_die_ref
, enum dwarf_attribute
, unsigned int,
3770 unsigned int, unsigned char *);
3771 static hashval_t
debug_str_do_hash (const void *);
3772 static int debug_str_eq (const void *, const void *);
3773 static void add_AT_string (dw_die_ref
, enum dwarf_attribute
, const char *);
3774 static inline const char *AT_string (dw_attr_ref
);
3775 static int AT_string_form (dw_attr_ref
);
3776 static void add_AT_die_ref (dw_die_ref
, enum dwarf_attribute
, dw_die_ref
);
3777 static void add_AT_specification (dw_die_ref
, dw_die_ref
);
3778 static inline dw_die_ref
AT_ref (dw_attr_ref
);
3779 static inline int AT_ref_external (dw_attr_ref
);
3780 static inline void set_AT_ref_external (dw_attr_ref
, int);
3781 static void add_AT_fde_ref (dw_die_ref
, enum dwarf_attribute
, unsigned);
3782 static void add_AT_loc (dw_die_ref
, enum dwarf_attribute
, dw_loc_descr_ref
);
3783 static inline dw_loc_descr_ref
AT_loc (dw_attr_ref
);
3784 static void add_AT_loc_list (dw_die_ref
, enum dwarf_attribute
,
3786 static inline dw_loc_list_ref
AT_loc_list (dw_attr_ref
);
3787 static void add_AT_addr (dw_die_ref
, enum dwarf_attribute
, rtx
);
3788 static inline rtx
AT_addr (dw_attr_ref
);
3789 static void add_AT_lbl_id (dw_die_ref
, enum dwarf_attribute
, const char *);
3790 static void add_AT_lbl_offset (dw_die_ref
, enum dwarf_attribute
, const char *);
3791 static void add_AT_offset (dw_die_ref
, enum dwarf_attribute
,
3792 unsigned HOST_WIDE_INT
);
3793 static void add_AT_range_list (dw_die_ref
, enum dwarf_attribute
,
3795 static inline const char *AT_lbl (dw_attr_ref
);
3796 static dw_attr_ref
get_AT (dw_die_ref
, enum dwarf_attribute
);
3797 static const char *get_AT_low_pc (dw_die_ref
);
3798 static const char *get_AT_hi_pc (dw_die_ref
);
3799 static const char *get_AT_string (dw_die_ref
, enum dwarf_attribute
);
3800 static int get_AT_flag (dw_die_ref
, enum dwarf_attribute
);
3801 static unsigned get_AT_unsigned (dw_die_ref
, enum dwarf_attribute
);
3802 static inline dw_die_ref
get_AT_ref (dw_die_ref
, enum dwarf_attribute
);
3803 static bool is_c_family (void);
3804 static bool is_cxx (void);
3805 static bool is_java (void);
3806 static bool is_fortran (void);
3807 static bool is_ada (void);
3808 static void remove_AT (dw_die_ref
, enum dwarf_attribute
);
3809 static void remove_child_TAG (dw_die_ref
, enum dwarf_tag
);
3810 static inline void free_die (dw_die_ref
);
3811 static void remove_children (dw_die_ref
);
3812 static void add_child_die (dw_die_ref
, dw_die_ref
);
3813 static dw_die_ref
new_die (enum dwarf_tag
, dw_die_ref
, tree
);
3814 static dw_die_ref
lookup_type_die (tree
);
3815 static void equate_type_number_to_die (tree
, dw_die_ref
);
3816 static hashval_t
decl_die_table_hash (const void *);
3817 static int decl_die_table_eq (const void *, const void *);
3818 static dw_die_ref
lookup_decl_die (tree
);
3819 static hashval_t
decl_loc_table_hash (const void *);
3820 static int decl_loc_table_eq (const void *, const void *);
3821 static var_loc_list
*lookup_decl_loc (tree
);
3822 static void equate_decl_number_to_die (tree
, dw_die_ref
);
3823 static void add_var_loc_to_decl (tree
, struct var_loc_node
*);
3824 static void print_spaces (FILE *);
3825 static void print_die (dw_die_ref
, FILE *);
3826 static void print_dwarf_line_table (FILE *);
3827 static void reverse_die_lists (dw_die_ref
);
3828 static void reverse_all_dies (dw_die_ref
);
3829 static dw_die_ref
push_new_compile_unit (dw_die_ref
, dw_die_ref
);
3830 static dw_die_ref
pop_compile_unit (dw_die_ref
);
3831 static void loc_checksum (dw_loc_descr_ref
, struct md5_ctx
*);
3832 static void attr_checksum (dw_attr_ref
, struct md5_ctx
*, int *);
3833 static void die_checksum (dw_die_ref
, struct md5_ctx
*, int *);
3834 static int same_loc_p (dw_loc_descr_ref
, dw_loc_descr_ref
, int *);
3835 static int same_dw_val_p (dw_val_node
*, dw_val_node
*, int *);
3836 static int same_attr_p (dw_attr_ref
, dw_attr_ref
, int *);
3837 static int same_die_p (dw_die_ref
, dw_die_ref
, int *);
3838 static int same_die_p_wrap (dw_die_ref
, dw_die_ref
);
3839 static void compute_section_prefix (dw_die_ref
);
3840 static int is_type_die (dw_die_ref
);
3841 static int is_comdat_die (dw_die_ref
);
3842 static int is_symbol_die (dw_die_ref
);
3843 static void assign_symbol_names (dw_die_ref
);
3844 static void break_out_includes (dw_die_ref
);
3845 static hashval_t
htab_cu_hash (const void *);
3846 static int htab_cu_eq (const void *, const void *);
3847 static void htab_cu_del (void *);
3848 static int check_duplicate_cu (dw_die_ref
, htab_t
, unsigned *);
3849 static void record_comdat_symbol_number (dw_die_ref
, htab_t
, unsigned);
3850 static void add_sibling_attributes (dw_die_ref
);
3851 static void build_abbrev_table (dw_die_ref
);
3852 static void output_location_lists (dw_die_ref
);
3853 static int constant_size (long unsigned);
3854 static unsigned long size_of_die (dw_die_ref
);
3855 static void calc_die_sizes (dw_die_ref
);
3856 static void mark_dies (dw_die_ref
);
3857 static void unmark_dies (dw_die_ref
);
3858 static void unmark_all_dies (dw_die_ref
);
3859 static unsigned long size_of_pubnames (void);
3860 static unsigned long size_of_aranges (void);
3861 static enum dwarf_form
value_format (dw_attr_ref
);
3862 static void output_value_format (dw_attr_ref
);
3863 static void output_abbrev_section (void);
3864 static void output_die_symbol (dw_die_ref
);
3865 static void output_die (dw_die_ref
);
3866 static void output_compilation_unit_header (void);
3867 static void output_comp_unit (dw_die_ref
, int);
3868 static const char *dwarf2_name (tree
, int);
3869 static void add_pubname (tree
, dw_die_ref
);
3870 static void output_pubnames (void);
3871 static void add_arange (tree
, dw_die_ref
);
3872 static void output_aranges (void);
3873 static unsigned int add_ranges (tree
);
3874 static void output_ranges (void);
3875 static void output_line_info (void);
3876 static void output_file_names (void);
3877 static dw_die_ref
base_type_die (tree
);
3878 static tree
root_type (tree
);
3879 static int is_base_type (tree
);
3880 static bool is_subrange_type (tree
);
3881 static dw_die_ref
subrange_type_die (tree
, dw_die_ref
);
3882 static dw_die_ref
modified_type_die (tree
, int, int, dw_die_ref
);
3883 static int type_is_enum (tree
);
3884 static unsigned int dbx_reg_number (rtx
);
3885 static dw_loc_descr_ref
reg_loc_descriptor (rtx
);
3886 static dw_loc_descr_ref
one_reg_loc_descriptor (unsigned int);
3887 static dw_loc_descr_ref
multiple_reg_loc_descriptor (rtx
, rtx
);
3888 static dw_loc_descr_ref
int_loc_descriptor (HOST_WIDE_INT
);
3889 static dw_loc_descr_ref
based_loc_descr (unsigned, HOST_WIDE_INT
, bool);
3890 static int is_based_loc (rtx
);
3891 static dw_loc_descr_ref
mem_loc_descriptor (rtx
, enum machine_mode mode
, bool);
3892 static dw_loc_descr_ref
concat_loc_descriptor (rtx
, rtx
);
3893 static dw_loc_descr_ref
loc_descriptor (rtx
, bool);
3894 static dw_loc_descr_ref
loc_descriptor_from_tree_1 (tree
, int);
3895 static dw_loc_descr_ref
loc_descriptor_from_tree (tree
);
3896 static HOST_WIDE_INT
ceiling (HOST_WIDE_INT
, unsigned int);
3897 static tree
field_type (tree
);
3898 static unsigned int simple_type_align_in_bits (tree
);
3899 static unsigned int simple_decl_align_in_bits (tree
);
3900 static unsigned HOST_WIDE_INT
simple_type_size_in_bits (tree
);
3901 static HOST_WIDE_INT
field_byte_offset (tree
);
3902 static void add_AT_location_description (dw_die_ref
, enum dwarf_attribute
,
3904 static void add_data_member_location_attribute (dw_die_ref
, tree
);
3905 static void add_const_value_attribute (dw_die_ref
, rtx
);
3906 static void insert_int (HOST_WIDE_INT
, unsigned, unsigned char *);
3907 static HOST_WIDE_INT
extract_int (const unsigned char *, unsigned);
3908 static void insert_float (rtx
, unsigned char *);
3909 static rtx
rtl_for_decl_location (tree
);
3910 static void add_location_or_const_value_attribute (dw_die_ref
, tree
,
3911 enum dwarf_attribute
);
3912 static void tree_add_const_value_attribute (dw_die_ref
, tree
);
3913 static void add_name_attribute (dw_die_ref
, const char *);
3914 static void add_comp_dir_attribute (dw_die_ref
);
3915 static void add_bound_info (dw_die_ref
, enum dwarf_attribute
, tree
);
3916 static void add_subscript_info (dw_die_ref
, tree
);
3917 static void add_byte_size_attribute (dw_die_ref
, tree
);
3918 static void add_bit_offset_attribute (dw_die_ref
, tree
);
3919 static void add_bit_size_attribute (dw_die_ref
, tree
);
3920 static void add_prototyped_attribute (dw_die_ref
, tree
);
3921 static void add_abstract_origin_attribute (dw_die_ref
, tree
);
3922 static void add_pure_or_virtual_attribute (dw_die_ref
, tree
);
3923 static void add_src_coords_attributes (dw_die_ref
, tree
);
3924 static void add_name_and_src_coords_attributes (dw_die_ref
, tree
);
3925 static void push_decl_scope (tree
);
3926 static void pop_decl_scope (void);
3927 static dw_die_ref
scope_die_for (tree
, dw_die_ref
);
3928 static inline int local_scope_p (dw_die_ref
);
3929 static inline int class_or_namespace_scope_p (dw_die_ref
);
3930 static void add_type_attribute (dw_die_ref
, tree
, int, int, dw_die_ref
);
3931 static const char *type_tag (tree
);
3932 static tree
member_declared_type (tree
);
3934 static const char *decl_start_label (tree
);
3936 static void gen_array_type_die (tree
, dw_die_ref
);
3937 static void gen_set_type_die (tree
, dw_die_ref
);
3939 static void gen_entry_point_die (tree
, dw_die_ref
);
3941 static void gen_inlined_enumeration_type_die (tree
, dw_die_ref
);
3942 static void gen_inlined_structure_type_die (tree
, dw_die_ref
);
3943 static void gen_inlined_union_type_die (tree
, dw_die_ref
);
3944 static dw_die_ref
gen_enumeration_type_die (tree
, dw_die_ref
);
3945 static dw_die_ref
gen_formal_parameter_die (tree
, dw_die_ref
);
3946 static void gen_unspecified_parameters_die (tree
, dw_die_ref
);
3947 static void gen_formal_types_die (tree
, dw_die_ref
);
3948 static void gen_subprogram_die (tree
, dw_die_ref
);
3949 static void gen_variable_die (tree
, dw_die_ref
);
3950 static void gen_label_die (tree
, dw_die_ref
);
3951 static void gen_lexical_block_die (tree
, dw_die_ref
, int);
3952 static void gen_inlined_subroutine_die (tree
, dw_die_ref
, int);
3953 static void gen_field_die (tree
, dw_die_ref
);
3954 static void gen_ptr_to_mbr_type_die (tree
, dw_die_ref
);
3955 static dw_die_ref
gen_compile_unit_die (const char *);
3956 static void gen_string_type_die (tree
, dw_die_ref
);
3957 static void gen_inheritance_die (tree
, tree
, dw_die_ref
);
3958 static void gen_member_die (tree
, dw_die_ref
);
3959 static void gen_struct_or_union_type_die (tree
, dw_die_ref
);
3960 static void gen_subroutine_type_die (tree
, dw_die_ref
);
3961 static void gen_typedef_die (tree
, dw_die_ref
);
3962 static void gen_type_die (tree
, dw_die_ref
);
3963 static void gen_tagged_type_instantiation_die (tree
, dw_die_ref
);
3964 static void gen_block_die (tree
, dw_die_ref
, int);
3965 static void decls_for_scope (tree
, dw_die_ref
, int);
3966 static int is_redundant_typedef (tree
);
3967 static void gen_namespace_die (tree
);
3968 static void gen_decl_die (tree
, dw_die_ref
);
3969 static dw_die_ref
force_decl_die (tree
);
3970 static dw_die_ref
force_type_die (tree
);
3971 static dw_die_ref
setup_namespace_context (tree
, dw_die_ref
);
3972 static void declare_in_namespace (tree
, dw_die_ref
);
3973 static unsigned lookup_filename (const char *);
3974 static void init_file_table (void);
3975 static void retry_incomplete_types (void);
3976 static void gen_type_die_for_member (tree
, tree
, dw_die_ref
);
3977 static void splice_child_die (dw_die_ref
, dw_die_ref
);
3978 static int file_info_cmp (const void *, const void *);
3979 static dw_loc_list_ref
new_loc_list (dw_loc_descr_ref
, const char *,
3980 const char *, const char *, unsigned);
3981 static void add_loc_descr_to_loc_list (dw_loc_list_ref
*, dw_loc_descr_ref
,
3982 const char *, const char *,
3984 static void output_loc_list (dw_loc_list_ref
);
3985 static char *gen_internal_sym (const char *);
3987 static void prune_unmark_dies (dw_die_ref
);
3988 static void prune_unused_types_mark (dw_die_ref
, int);
3989 static void prune_unused_types_walk (dw_die_ref
);
3990 static void prune_unused_types_walk_attribs (dw_die_ref
);
3991 static void prune_unused_types_prune (dw_die_ref
);
3992 static void prune_unused_types (void);
3993 static int maybe_emit_file (int);
3995 /* Section names used to hold DWARF debugging information. */
3996 #ifndef DEBUG_INFO_SECTION
3997 #define DEBUG_INFO_SECTION ".debug_info"
3999 #ifndef DEBUG_ABBREV_SECTION
4000 #define DEBUG_ABBREV_SECTION ".debug_abbrev"
4002 #ifndef DEBUG_ARANGES_SECTION
4003 #define DEBUG_ARANGES_SECTION ".debug_aranges"
4005 #ifndef DEBUG_MACINFO_SECTION
4006 #define DEBUG_MACINFO_SECTION ".debug_macinfo"
4008 #ifndef DEBUG_LINE_SECTION
4009 #define DEBUG_LINE_SECTION ".debug_line"
4011 #ifndef DEBUG_LOC_SECTION
4012 #define DEBUG_LOC_SECTION ".debug_loc"
4014 #ifndef DEBUG_PUBNAMES_SECTION
4015 #define DEBUG_PUBNAMES_SECTION ".debug_pubnames"
4017 #ifndef DEBUG_STR_SECTION
4018 #define DEBUG_STR_SECTION ".debug_str"
4020 #ifndef DEBUG_RANGES_SECTION
4021 #define DEBUG_RANGES_SECTION ".debug_ranges"
4024 /* Standard ELF section names for compiled code and data. */
4025 #ifndef TEXT_SECTION_NAME
4026 #define TEXT_SECTION_NAME ".text"
4029 /* Section flags for .debug_str section. */
4030 #define DEBUG_STR_SECTION_FLAGS \
4031 (HAVE_GAS_SHF_MERGE && flag_merge_constants \
4032 ? SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1 \
4035 /* Labels we insert at beginning sections we can reference instead of
4036 the section names themselves. */
4038 #ifndef TEXT_SECTION_LABEL
4039 #define TEXT_SECTION_LABEL "Ltext"
4041 #ifndef DEBUG_LINE_SECTION_LABEL
4042 #define DEBUG_LINE_SECTION_LABEL "Ldebug_line"
4044 #ifndef DEBUG_INFO_SECTION_LABEL
4045 #define DEBUG_INFO_SECTION_LABEL "Ldebug_info"
4047 #ifndef DEBUG_ABBREV_SECTION_LABEL
4048 #define DEBUG_ABBREV_SECTION_LABEL "Ldebug_abbrev"
4050 #ifndef DEBUG_LOC_SECTION_LABEL
4051 #define DEBUG_LOC_SECTION_LABEL "Ldebug_loc"
4053 #ifndef DEBUG_RANGES_SECTION_LABEL
4054 #define DEBUG_RANGES_SECTION_LABEL "Ldebug_ranges"
4056 #ifndef DEBUG_MACINFO_SECTION_LABEL
4057 #define DEBUG_MACINFO_SECTION_LABEL "Ldebug_macinfo"
4060 /* Definitions of defaults for formats and names of various special
4061 (artificial) labels which may be generated within this file (when the -g
4062 options is used and DWARF2_DEBUGGING_INFO is in effect.
4063 If necessary, these may be overridden from within the tm.h file, but
4064 typically, overriding these defaults is unnecessary. */
4066 static char text_end_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4067 static char text_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4068 static char abbrev_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4069 static char debug_info_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4070 static char debug_line_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4071 static char macinfo_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4072 static char loc_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
4073 static char ranges_section_label
[2 * MAX_ARTIFICIAL_LABEL_BYTES
];
4075 #ifndef TEXT_END_LABEL
4076 #define TEXT_END_LABEL "Letext"
4078 #ifndef BLOCK_BEGIN_LABEL
4079 #define BLOCK_BEGIN_LABEL "LBB"
4081 #ifndef BLOCK_END_LABEL
4082 #define BLOCK_END_LABEL "LBE"
4084 #ifndef LINE_CODE_LABEL
4085 #define LINE_CODE_LABEL "LM"
4087 #ifndef SEPARATE_LINE_CODE_LABEL
4088 #define SEPARATE_LINE_CODE_LABEL "LSM"
4091 /* We allow a language front-end to designate a function that is to be
4092 called to "demangle" any name before it it put into a DIE. */
4094 static const char *(*demangle_name_func
) (const char *);
4097 dwarf2out_set_demangle_name_func (const char *(*func
) (const char *))
4099 demangle_name_func
= func
;
4102 /* Test if rtl node points to a pseudo register. */
4105 is_pseudo_reg (rtx rtl
)
4107 return ((REG_P (rtl
) && REGNO (rtl
) >= FIRST_PSEUDO_REGISTER
)
4108 || (GET_CODE (rtl
) == SUBREG
4109 && REGNO (SUBREG_REG (rtl
)) >= FIRST_PSEUDO_REGISTER
));
4112 /* Return a reference to a type, with its const and volatile qualifiers
4116 type_main_variant (tree type
)
4118 type
= TYPE_MAIN_VARIANT (type
);
4120 /* ??? There really should be only one main variant among any group of
4121 variants of a given type (and all of the MAIN_VARIANT values for all
4122 members of the group should point to that one type) but sometimes the C
4123 front-end messes this up for array types, so we work around that bug
4125 if (TREE_CODE (type
) == ARRAY_TYPE
)
4126 while (type
!= TYPE_MAIN_VARIANT (type
))
4127 type
= TYPE_MAIN_VARIANT (type
);
4132 /* Return nonzero if the given type node represents a tagged type. */
4135 is_tagged_type (tree type
)
4137 enum tree_code code
= TREE_CODE (type
);
4139 return (code
== RECORD_TYPE
|| code
== UNION_TYPE
4140 || code
== QUAL_UNION_TYPE
|| code
== ENUMERAL_TYPE
);
4143 /* Convert a DIE tag into its string name. */
4146 dwarf_tag_name (unsigned int tag
)
4150 case DW_TAG_padding
:
4151 return "DW_TAG_padding";
4152 case DW_TAG_array_type
:
4153 return "DW_TAG_array_type";
4154 case DW_TAG_class_type
:
4155 return "DW_TAG_class_type";
4156 case DW_TAG_entry_point
:
4157 return "DW_TAG_entry_point";
4158 case DW_TAG_enumeration_type
:
4159 return "DW_TAG_enumeration_type";
4160 case DW_TAG_formal_parameter
:
4161 return "DW_TAG_formal_parameter";
4162 case DW_TAG_imported_declaration
:
4163 return "DW_TAG_imported_declaration";
4165 return "DW_TAG_label";
4166 case DW_TAG_lexical_block
:
4167 return "DW_TAG_lexical_block";
4169 return "DW_TAG_member";
4170 case DW_TAG_pointer_type
:
4171 return "DW_TAG_pointer_type";
4172 case DW_TAG_reference_type
:
4173 return "DW_TAG_reference_type";
4174 case DW_TAG_compile_unit
:
4175 return "DW_TAG_compile_unit";
4176 case DW_TAG_string_type
:
4177 return "DW_TAG_string_type";
4178 case DW_TAG_structure_type
:
4179 return "DW_TAG_structure_type";
4180 case DW_TAG_subroutine_type
:
4181 return "DW_TAG_subroutine_type";
4182 case DW_TAG_typedef
:
4183 return "DW_TAG_typedef";
4184 case DW_TAG_union_type
:
4185 return "DW_TAG_union_type";
4186 case DW_TAG_unspecified_parameters
:
4187 return "DW_TAG_unspecified_parameters";
4188 case DW_TAG_variant
:
4189 return "DW_TAG_variant";
4190 case DW_TAG_common_block
:
4191 return "DW_TAG_common_block";
4192 case DW_TAG_common_inclusion
:
4193 return "DW_TAG_common_inclusion";
4194 case DW_TAG_inheritance
:
4195 return "DW_TAG_inheritance";
4196 case DW_TAG_inlined_subroutine
:
4197 return "DW_TAG_inlined_subroutine";
4199 return "DW_TAG_module";
4200 case DW_TAG_ptr_to_member_type
:
4201 return "DW_TAG_ptr_to_member_type";
4202 case DW_TAG_set_type
:
4203 return "DW_TAG_set_type";
4204 case DW_TAG_subrange_type
:
4205 return "DW_TAG_subrange_type";
4206 case DW_TAG_with_stmt
:
4207 return "DW_TAG_with_stmt";
4208 case DW_TAG_access_declaration
:
4209 return "DW_TAG_access_declaration";
4210 case DW_TAG_base_type
:
4211 return "DW_TAG_base_type";
4212 case DW_TAG_catch_block
:
4213 return "DW_TAG_catch_block";
4214 case DW_TAG_const_type
:
4215 return "DW_TAG_const_type";
4216 case DW_TAG_constant
:
4217 return "DW_TAG_constant";
4218 case DW_TAG_enumerator
:
4219 return "DW_TAG_enumerator";
4220 case DW_TAG_file_type
:
4221 return "DW_TAG_file_type";
4223 return "DW_TAG_friend";
4224 case DW_TAG_namelist
:
4225 return "DW_TAG_namelist";
4226 case DW_TAG_namelist_item
:
4227 return "DW_TAG_namelist_item";
4228 case DW_TAG_namespace
:
4229 return "DW_TAG_namespace";
4230 case DW_TAG_packed_type
:
4231 return "DW_TAG_packed_type";
4232 case DW_TAG_subprogram
:
4233 return "DW_TAG_subprogram";
4234 case DW_TAG_template_type_param
:
4235 return "DW_TAG_template_type_param";
4236 case DW_TAG_template_value_param
:
4237 return "DW_TAG_template_value_param";
4238 case DW_TAG_thrown_type
:
4239 return "DW_TAG_thrown_type";
4240 case DW_TAG_try_block
:
4241 return "DW_TAG_try_block";
4242 case DW_TAG_variant_part
:
4243 return "DW_TAG_variant_part";
4244 case DW_TAG_variable
:
4245 return "DW_TAG_variable";
4246 case DW_TAG_volatile_type
:
4247 return "DW_TAG_volatile_type";
4248 case DW_TAG_imported_module
:
4249 return "DW_TAG_imported_module";
4250 case DW_TAG_MIPS_loop
:
4251 return "DW_TAG_MIPS_loop";
4252 case DW_TAG_format_label
:
4253 return "DW_TAG_format_label";
4254 case DW_TAG_function_template
:
4255 return "DW_TAG_function_template";
4256 case DW_TAG_class_template
:
4257 return "DW_TAG_class_template";
4258 case DW_TAG_GNU_BINCL
:
4259 return "DW_TAG_GNU_BINCL";
4260 case DW_TAG_GNU_EINCL
:
4261 return "DW_TAG_GNU_EINCL";
4263 return "DW_TAG_<unknown>";
4267 /* Convert a DWARF attribute code into its string name. */
4270 dwarf_attr_name (unsigned int attr
)
4275 return "DW_AT_sibling";
4276 case DW_AT_location
:
4277 return "DW_AT_location";
4279 return "DW_AT_name";
4280 case DW_AT_ordering
:
4281 return "DW_AT_ordering";
4282 case DW_AT_subscr_data
:
4283 return "DW_AT_subscr_data";
4284 case DW_AT_byte_size
:
4285 return "DW_AT_byte_size";
4286 case DW_AT_bit_offset
:
4287 return "DW_AT_bit_offset";
4288 case DW_AT_bit_size
:
4289 return "DW_AT_bit_size";
4290 case DW_AT_element_list
:
4291 return "DW_AT_element_list";
4292 case DW_AT_stmt_list
:
4293 return "DW_AT_stmt_list";
4295 return "DW_AT_low_pc";
4297 return "DW_AT_high_pc";
4298 case DW_AT_language
:
4299 return "DW_AT_language";
4301 return "DW_AT_member";
4303 return "DW_AT_discr";
4304 case DW_AT_discr_value
:
4305 return "DW_AT_discr_value";
4306 case DW_AT_visibility
:
4307 return "DW_AT_visibility";
4309 return "DW_AT_import";
4310 case DW_AT_string_length
:
4311 return "DW_AT_string_length";
4312 case DW_AT_common_reference
:
4313 return "DW_AT_common_reference";
4314 case DW_AT_comp_dir
:
4315 return "DW_AT_comp_dir";
4316 case DW_AT_const_value
:
4317 return "DW_AT_const_value";
4318 case DW_AT_containing_type
:
4319 return "DW_AT_containing_type";
4320 case DW_AT_default_value
:
4321 return "DW_AT_default_value";
4323 return "DW_AT_inline";
4324 case DW_AT_is_optional
:
4325 return "DW_AT_is_optional";
4326 case DW_AT_lower_bound
:
4327 return "DW_AT_lower_bound";
4328 case DW_AT_producer
:
4329 return "DW_AT_producer";
4330 case DW_AT_prototyped
:
4331 return "DW_AT_prototyped";
4332 case DW_AT_return_addr
:
4333 return "DW_AT_return_addr";
4334 case DW_AT_start_scope
:
4335 return "DW_AT_start_scope";
4336 case DW_AT_stride_size
:
4337 return "DW_AT_stride_size";
4338 case DW_AT_upper_bound
:
4339 return "DW_AT_upper_bound";
4340 case DW_AT_abstract_origin
:
4341 return "DW_AT_abstract_origin";
4342 case DW_AT_accessibility
:
4343 return "DW_AT_accessibility";
4344 case DW_AT_address_class
:
4345 return "DW_AT_address_class";
4346 case DW_AT_artificial
:
4347 return "DW_AT_artificial";
4348 case DW_AT_base_types
:
4349 return "DW_AT_base_types";
4350 case DW_AT_calling_convention
:
4351 return "DW_AT_calling_convention";
4353 return "DW_AT_count";
4354 case DW_AT_data_member_location
:
4355 return "DW_AT_data_member_location";
4356 case DW_AT_decl_column
:
4357 return "DW_AT_decl_column";
4358 case DW_AT_decl_file
:
4359 return "DW_AT_decl_file";
4360 case DW_AT_decl_line
:
4361 return "DW_AT_decl_line";
4362 case DW_AT_declaration
:
4363 return "DW_AT_declaration";
4364 case DW_AT_discr_list
:
4365 return "DW_AT_discr_list";
4366 case DW_AT_encoding
:
4367 return "DW_AT_encoding";
4368 case DW_AT_external
:
4369 return "DW_AT_external";
4370 case DW_AT_frame_base
:
4371 return "DW_AT_frame_base";
4373 return "DW_AT_friend";
4374 case DW_AT_identifier_case
:
4375 return "DW_AT_identifier_case";
4376 case DW_AT_macro_info
:
4377 return "DW_AT_macro_info";
4378 case DW_AT_namelist_items
:
4379 return "DW_AT_namelist_items";
4380 case DW_AT_priority
:
4381 return "DW_AT_priority";
4383 return "DW_AT_segment";
4384 case DW_AT_specification
:
4385 return "DW_AT_specification";
4386 case DW_AT_static_link
:
4387 return "DW_AT_static_link";
4389 return "DW_AT_type";
4390 case DW_AT_use_location
:
4391 return "DW_AT_use_location";
4392 case DW_AT_variable_parameter
:
4393 return "DW_AT_variable_parameter";
4394 case DW_AT_virtuality
:
4395 return "DW_AT_virtuality";
4396 case DW_AT_vtable_elem_location
:
4397 return "DW_AT_vtable_elem_location";
4399 case DW_AT_allocated
:
4400 return "DW_AT_allocated";
4401 case DW_AT_associated
:
4402 return "DW_AT_associated";
4403 case DW_AT_data_location
:
4404 return "DW_AT_data_location";
4406 return "DW_AT_stride";
4407 case DW_AT_entry_pc
:
4408 return "DW_AT_entry_pc";
4409 case DW_AT_use_UTF8
:
4410 return "DW_AT_use_UTF8";
4411 case DW_AT_extension
:
4412 return "DW_AT_extension";
4414 return "DW_AT_ranges";
4415 case DW_AT_trampoline
:
4416 return "DW_AT_trampoline";
4417 case DW_AT_call_column
:
4418 return "DW_AT_call_column";
4419 case DW_AT_call_file
:
4420 return "DW_AT_call_file";
4421 case DW_AT_call_line
:
4422 return "DW_AT_call_line";
4424 case DW_AT_MIPS_fde
:
4425 return "DW_AT_MIPS_fde";
4426 case DW_AT_MIPS_loop_begin
:
4427 return "DW_AT_MIPS_loop_begin";
4428 case DW_AT_MIPS_tail_loop_begin
:
4429 return "DW_AT_MIPS_tail_loop_begin";
4430 case DW_AT_MIPS_epilog_begin
:
4431 return "DW_AT_MIPS_epilog_begin";
4432 case DW_AT_MIPS_loop_unroll_factor
:
4433 return "DW_AT_MIPS_loop_unroll_factor";
4434 case DW_AT_MIPS_software_pipeline_depth
:
4435 return "DW_AT_MIPS_software_pipeline_depth";
4436 case DW_AT_MIPS_linkage_name
:
4437 return "DW_AT_MIPS_linkage_name";
4438 case DW_AT_MIPS_stride
:
4439 return "DW_AT_MIPS_stride";
4440 case DW_AT_MIPS_abstract_name
:
4441 return "DW_AT_MIPS_abstract_name";
4442 case DW_AT_MIPS_clone_origin
:
4443 return "DW_AT_MIPS_clone_origin";
4444 case DW_AT_MIPS_has_inlines
:
4445 return "DW_AT_MIPS_has_inlines";
4447 case DW_AT_sf_names
:
4448 return "DW_AT_sf_names";
4449 case DW_AT_src_info
:
4450 return "DW_AT_src_info";
4451 case DW_AT_mac_info
:
4452 return "DW_AT_mac_info";
4453 case DW_AT_src_coords
:
4454 return "DW_AT_src_coords";
4455 case DW_AT_body_begin
:
4456 return "DW_AT_body_begin";
4457 case DW_AT_body_end
:
4458 return "DW_AT_body_end";
4459 case DW_AT_GNU_vector
:
4460 return "DW_AT_GNU_vector";
4462 case DW_AT_VMS_rtnbeg_pd_address
:
4463 return "DW_AT_VMS_rtnbeg_pd_address";
4466 return "DW_AT_<unknown>";
4470 /* Convert a DWARF value form code into its string name. */
4473 dwarf_form_name (unsigned int form
)
4478 return "DW_FORM_addr";
4479 case DW_FORM_block2
:
4480 return "DW_FORM_block2";
4481 case DW_FORM_block4
:
4482 return "DW_FORM_block4";
4484 return "DW_FORM_data2";
4486 return "DW_FORM_data4";
4488 return "DW_FORM_data8";
4489 case DW_FORM_string
:
4490 return "DW_FORM_string";
4492 return "DW_FORM_block";
4493 case DW_FORM_block1
:
4494 return "DW_FORM_block1";
4496 return "DW_FORM_data1";
4498 return "DW_FORM_flag";
4500 return "DW_FORM_sdata";
4502 return "DW_FORM_strp";
4504 return "DW_FORM_udata";
4505 case DW_FORM_ref_addr
:
4506 return "DW_FORM_ref_addr";
4508 return "DW_FORM_ref1";
4510 return "DW_FORM_ref2";
4512 return "DW_FORM_ref4";
4514 return "DW_FORM_ref8";
4515 case DW_FORM_ref_udata
:
4516 return "DW_FORM_ref_udata";
4517 case DW_FORM_indirect
:
4518 return "DW_FORM_indirect";
4520 return "DW_FORM_<unknown>";
4524 /* Convert a DWARF type code into its string name. */
4528 dwarf_type_encoding_name (unsigned enc
)
4532 case DW_ATE_address
:
4533 return "DW_ATE_address";
4534 case DW_ATE_boolean
:
4535 return "DW_ATE_boolean";
4536 case DW_ATE_complex_float
:
4537 return "DW_ATE_complex_float";
4539 return "DW_ATE_float";
4541 return "DW_ATE_signed";
4542 case DW_ATE_signed_char
:
4543 return "DW_ATE_signed_char";
4544 case DW_ATE_unsigned
:
4545 return "DW_ATE_unsigned";
4546 case DW_ATE_unsigned_char
:
4547 return "DW_ATE_unsigned_char";
4549 return "DW_ATE_<unknown>";
4554 /* Determine the "ultimate origin" of a decl. The decl may be an inlined
4555 instance of an inlined instance of a decl which is local to an inline
4556 function, so we have to trace all of the way back through the origin chain
4557 to find out what sort of node actually served as the original seed for the
4561 decl_ultimate_origin (tree decl
)
4563 /* output_inline_function sets DECL_ABSTRACT_ORIGIN for all the
4564 nodes in the function to point to themselves; ignore that if
4565 we're trying to output the abstract instance of this function. */
4566 if (DECL_ABSTRACT (decl
) && DECL_ABSTRACT_ORIGIN (decl
) == decl
)
4569 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
4570 most distant ancestor, this should never happen. */
4571 gcc_assert (!DECL_FROM_INLINE (DECL_ORIGIN (decl
)));
4573 return DECL_ABSTRACT_ORIGIN (decl
);
4576 /* Determine the "ultimate origin" of a block. The block may be an inlined
4577 instance of an inlined instance of a block which is local to an inline
4578 function, so we have to trace all of the way back through the origin chain
4579 to find out what sort of node actually served as the original seed for the
4583 block_ultimate_origin (tree block
)
4585 tree immediate_origin
= BLOCK_ABSTRACT_ORIGIN (block
);
4587 /* output_inline_function sets BLOCK_ABSTRACT_ORIGIN for all the
4588 nodes in the function to point to themselves; ignore that if
4589 we're trying to output the abstract instance of this function. */
4590 if (BLOCK_ABSTRACT (block
) && immediate_origin
== block
)
4593 if (immediate_origin
== NULL_TREE
)
4598 tree lookahead
= immediate_origin
;
4602 ret_val
= lookahead
;
4603 lookahead
= (TREE_CODE (ret_val
) == BLOCK
4604 ? BLOCK_ABSTRACT_ORIGIN (ret_val
) : NULL
);
4606 while (lookahead
!= NULL
&& lookahead
!= ret_val
);
4612 /* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT
4613 of a virtual function may refer to a base class, so we check the 'this'
4617 decl_class_context (tree decl
)
4619 tree context
= NULL_TREE
;
4621 if (TREE_CODE (decl
) != FUNCTION_DECL
|| ! DECL_VINDEX (decl
))
4622 context
= DECL_CONTEXT (decl
);
4624 context
= TYPE_MAIN_VARIANT
4625 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)))));
4627 if (context
&& !TYPE_P (context
))
4628 context
= NULL_TREE
;
4633 /* Add an attribute/value pair to a DIE. We build the lists up in reverse
4634 addition order, and correct that in reverse_all_dies. */
4637 add_dwarf_attr (dw_die_ref die
, dw_attr_ref attr
)
4639 if (die
!= NULL
&& attr
!= NULL
)
4641 attr
->dw_attr_next
= die
->die_attr
;
4642 die
->die_attr
= attr
;
4646 static inline enum dw_val_class
4647 AT_class (dw_attr_ref a
)
4649 return a
->dw_attr_val
.val_class
;
4652 /* Add a flag value attribute to a DIE. */
4655 add_AT_flag (dw_die_ref die
, enum dwarf_attribute attr_kind
, unsigned int flag
)
4657 dw_attr_ref attr
= ggc_alloc (sizeof (dw_attr_node
));
4659 attr
->dw_attr_next
= NULL
;
4660 attr
->dw_attr
= attr_kind
;
4661 attr
->dw_attr_val
.val_class
= dw_val_class_flag
;
4662 attr
->dw_attr_val
.v
.val_flag
= flag
;
4663 add_dwarf_attr (die
, attr
);
4666 static inline unsigned
4667 AT_flag (dw_attr_ref a
)
4669 gcc_assert (a
&& AT_class (a
) == dw_val_class_flag
);
4670 return a
->dw_attr_val
.v
.val_flag
;
4673 /* Add a signed integer attribute value to a DIE. */
4676 add_AT_int (dw_die_ref die
, enum dwarf_attribute attr_kind
, HOST_WIDE_INT int_val
)
4678 dw_attr_ref attr
= ggc_alloc (sizeof (dw_attr_node
));
4680 attr
->dw_attr_next
= NULL
;
4681 attr
->dw_attr
= attr_kind
;
4682 attr
->dw_attr_val
.val_class
= dw_val_class_const
;
4683 attr
->dw_attr_val
.v
.val_int
= int_val
;
4684 add_dwarf_attr (die
, attr
);
4687 static inline HOST_WIDE_INT
4688 AT_int (dw_attr_ref a
)
4690 gcc_assert (a
&& AT_class (a
) == dw_val_class_const
);
4691 return a
->dw_attr_val
.v
.val_int
;
4694 /* Add an unsigned integer attribute value to a DIE. */
4697 add_AT_unsigned (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4698 unsigned HOST_WIDE_INT unsigned_val
)
4700 dw_attr_ref attr
= ggc_alloc (sizeof (dw_attr_node
));
4702 attr
->dw_attr_next
= NULL
;
4703 attr
->dw_attr
= attr_kind
;
4704 attr
->dw_attr_val
.val_class
= dw_val_class_unsigned_const
;
4705 attr
->dw_attr_val
.v
.val_unsigned
= unsigned_val
;
4706 add_dwarf_attr (die
, attr
);
4709 static inline unsigned HOST_WIDE_INT
4710 AT_unsigned (dw_attr_ref a
)
4712 gcc_assert (a
&& AT_class (a
) == dw_val_class_unsigned_const
);
4713 return a
->dw_attr_val
.v
.val_unsigned
;
4716 /* Add an unsigned double integer attribute value to a DIE. */
4719 add_AT_long_long (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4720 long unsigned int val_hi
, long unsigned int val_low
)
4722 dw_attr_ref attr
= ggc_alloc (sizeof (dw_attr_node
));
4724 attr
->dw_attr_next
= NULL
;
4725 attr
->dw_attr
= attr_kind
;
4726 attr
->dw_attr_val
.val_class
= dw_val_class_long_long
;
4727 attr
->dw_attr_val
.v
.val_long_long
.hi
= val_hi
;
4728 attr
->dw_attr_val
.v
.val_long_long
.low
= val_low
;
4729 add_dwarf_attr (die
, attr
);
4732 /* Add a floating point attribute value to a DIE and return it. */
4735 add_AT_vec (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4736 unsigned int length
, unsigned int elt_size
, unsigned char *array
)
4738 dw_attr_ref attr
= ggc_alloc (sizeof (dw_attr_node
));
4740 attr
->dw_attr_next
= NULL
;
4741 attr
->dw_attr
= attr_kind
;
4742 attr
->dw_attr_val
.val_class
= dw_val_class_vec
;
4743 attr
->dw_attr_val
.v
.val_vec
.length
= length
;
4744 attr
->dw_attr_val
.v
.val_vec
.elt_size
= elt_size
;
4745 attr
->dw_attr_val
.v
.val_vec
.array
= array
;
4746 add_dwarf_attr (die
, attr
);
4749 /* Hash and equality functions for debug_str_hash. */
4752 debug_str_do_hash (const void *x
)
4754 return htab_hash_string (((const struct indirect_string_node
*)x
)->str
);
4758 debug_str_eq (const void *x1
, const void *x2
)
4760 return strcmp ((((const struct indirect_string_node
*)x1
)->str
),
4761 (const char *)x2
) == 0;
4764 /* Add a string attribute value to a DIE. */
4767 add_AT_string (dw_die_ref die
, enum dwarf_attribute attr_kind
, const char *str
)
4769 dw_attr_ref attr
= ggc_alloc (sizeof (dw_attr_node
));
4770 struct indirect_string_node
*node
;
4773 if (! debug_str_hash
)
4774 debug_str_hash
= htab_create_ggc (10, debug_str_do_hash
,
4775 debug_str_eq
, NULL
);
4777 slot
= htab_find_slot_with_hash (debug_str_hash
, str
,
4778 htab_hash_string (str
), INSERT
);
4780 *slot
= ggc_alloc_cleared (sizeof (struct indirect_string_node
));
4781 node
= (struct indirect_string_node
*) *slot
;
4782 node
->str
= ggc_strdup (str
);
4785 attr
->dw_attr_next
= NULL
;
4786 attr
->dw_attr
= attr_kind
;
4787 attr
->dw_attr_val
.val_class
= dw_val_class_str
;
4788 attr
->dw_attr_val
.v
.val_str
= node
;
4789 add_dwarf_attr (die
, attr
);
4792 static inline const char *
4793 AT_string (dw_attr_ref a
)
4795 gcc_assert (a
&& AT_class (a
) == dw_val_class_str
);
4796 return a
->dw_attr_val
.v
.val_str
->str
;
4799 /* Find out whether a string should be output inline in DIE
4800 or out-of-line in .debug_str section. */
4803 AT_string_form (dw_attr_ref a
)
4805 struct indirect_string_node
*node
;
4809 gcc_assert (a
&& AT_class (a
) == dw_val_class_str
);
4811 node
= a
->dw_attr_val
.v
.val_str
;
4815 len
= strlen (node
->str
) + 1;
4817 /* If the string is shorter or equal to the size of the reference, it is
4818 always better to put it inline. */
4819 if (len
<= DWARF_OFFSET_SIZE
|| node
->refcount
== 0)
4820 return node
->form
= DW_FORM_string
;
4822 /* If we cannot expect the linker to merge strings in .debug_str
4823 section, only put it into .debug_str if it is worth even in this
4825 if ((DEBUG_STR_SECTION_FLAGS
& SECTION_MERGE
) == 0
4826 && (len
- DWARF_OFFSET_SIZE
) * node
->refcount
<= len
)
4827 return node
->form
= DW_FORM_string
;
4829 ASM_GENERATE_INTERNAL_LABEL (label
, "LASF", dw2_string_counter
);
4830 ++dw2_string_counter
;
4831 node
->label
= xstrdup (label
);
4833 return node
->form
= DW_FORM_strp
;
4836 /* Add a DIE reference attribute value to a DIE. */
4839 add_AT_die_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
, dw_die_ref targ_die
)
4841 dw_attr_ref attr
= ggc_alloc (sizeof (dw_attr_node
));
4843 attr
->dw_attr_next
= NULL
;
4844 attr
->dw_attr
= attr_kind
;
4845 attr
->dw_attr_val
.val_class
= dw_val_class_die_ref
;
4846 attr
->dw_attr_val
.v
.val_die_ref
.die
= targ_die
;
4847 attr
->dw_attr_val
.v
.val_die_ref
.external
= 0;
4848 add_dwarf_attr (die
, attr
);
4851 /* Add an AT_specification attribute to a DIE, and also make the back
4852 pointer from the specification to the definition. */
4855 add_AT_specification (dw_die_ref die
, dw_die_ref targ_die
)
4857 add_AT_die_ref (die
, DW_AT_specification
, targ_die
);
4858 gcc_assert (!targ_die
->die_definition
);
4859 targ_die
->die_definition
= die
;
4862 static inline dw_die_ref
4863 AT_ref (dw_attr_ref a
)
4865 gcc_assert (a
&& AT_class (a
) == dw_val_class_die_ref
);
4866 return a
->dw_attr_val
.v
.val_die_ref
.die
;
4870 AT_ref_external (dw_attr_ref a
)
4872 if (a
&& AT_class (a
) == dw_val_class_die_ref
)
4873 return a
->dw_attr_val
.v
.val_die_ref
.external
;
4879 set_AT_ref_external (dw_attr_ref a
, int i
)
4881 gcc_assert (a
&& AT_class (a
) == dw_val_class_die_ref
);
4882 a
->dw_attr_val
.v
.val_die_ref
.external
= i
;
4885 /* Add an FDE reference attribute value to a DIE. */
4888 add_AT_fde_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
, unsigned int targ_fde
)
4890 dw_attr_ref attr
= ggc_alloc (sizeof (dw_attr_node
));
4892 attr
->dw_attr_next
= NULL
;
4893 attr
->dw_attr
= attr_kind
;
4894 attr
->dw_attr_val
.val_class
= dw_val_class_fde_ref
;
4895 attr
->dw_attr_val
.v
.val_fde_index
= targ_fde
;
4896 add_dwarf_attr (die
, attr
);
4899 /* Add a location description attribute value to a DIE. */
4902 add_AT_loc (dw_die_ref die
, enum dwarf_attribute attr_kind
, dw_loc_descr_ref loc
)
4904 dw_attr_ref attr
= ggc_alloc (sizeof (dw_attr_node
));
4906 attr
->dw_attr_next
= NULL
;
4907 attr
->dw_attr
= attr_kind
;
4908 attr
->dw_attr_val
.val_class
= dw_val_class_loc
;
4909 attr
->dw_attr_val
.v
.val_loc
= loc
;
4910 add_dwarf_attr (die
, attr
);
4913 static inline dw_loc_descr_ref
4914 AT_loc (dw_attr_ref a
)
4916 gcc_assert (a
&& AT_class (a
) == dw_val_class_loc
);
4917 return a
->dw_attr_val
.v
.val_loc
;
4921 add_AT_loc_list (dw_die_ref die
, enum dwarf_attribute attr_kind
, dw_loc_list_ref loc_list
)
4923 dw_attr_ref attr
= ggc_alloc (sizeof (dw_attr_node
));
4925 attr
->dw_attr_next
= NULL
;
4926 attr
->dw_attr
= attr_kind
;
4927 attr
->dw_attr_val
.val_class
= dw_val_class_loc_list
;
4928 attr
->dw_attr_val
.v
.val_loc_list
= loc_list
;
4929 add_dwarf_attr (die
, attr
);
4930 have_location_lists
= 1;
4933 static inline dw_loc_list_ref
4934 AT_loc_list (dw_attr_ref a
)
4936 gcc_assert (a
&& AT_class (a
) == dw_val_class_loc_list
);
4937 return a
->dw_attr_val
.v
.val_loc_list
;
4940 /* Add an address constant attribute value to a DIE. */
4943 add_AT_addr (dw_die_ref die
, enum dwarf_attribute attr_kind
, rtx addr
)
4945 dw_attr_ref attr
= ggc_alloc (sizeof (dw_attr_node
));
4947 attr
->dw_attr_next
= NULL
;
4948 attr
->dw_attr
= attr_kind
;
4949 attr
->dw_attr_val
.val_class
= dw_val_class_addr
;
4950 attr
->dw_attr_val
.v
.val_addr
= addr
;
4951 add_dwarf_attr (die
, attr
);
4955 AT_addr (dw_attr_ref a
)
4957 gcc_assert (a
&& AT_class (a
) == dw_val_class_addr
);
4958 return a
->dw_attr_val
.v
.val_addr
;
4961 /* Add a label identifier attribute value to a DIE. */
4964 add_AT_lbl_id (dw_die_ref die
, enum dwarf_attribute attr_kind
, const char *lbl_id
)
4966 dw_attr_ref attr
= ggc_alloc (sizeof (dw_attr_node
));
4968 attr
->dw_attr_next
= NULL
;
4969 attr
->dw_attr
= attr_kind
;
4970 attr
->dw_attr_val
.val_class
= dw_val_class_lbl_id
;
4971 attr
->dw_attr_val
.v
.val_lbl_id
= xstrdup (lbl_id
);
4972 add_dwarf_attr (die
, attr
);
4975 /* Add a section offset attribute value to a DIE. */
4978 add_AT_lbl_offset (dw_die_ref die
, enum dwarf_attribute attr_kind
, const char *label
)
4980 dw_attr_ref attr
= ggc_alloc (sizeof (dw_attr_node
));
4982 attr
->dw_attr_next
= NULL
;
4983 attr
->dw_attr
= attr_kind
;
4984 attr
->dw_attr_val
.val_class
= dw_val_class_lbl_offset
;
4985 attr
->dw_attr_val
.v
.val_lbl_id
= xstrdup (label
);
4986 add_dwarf_attr (die
, attr
);
4989 /* Add an offset attribute value to a DIE. */
4992 add_AT_offset (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4993 unsigned HOST_WIDE_INT offset
)
4995 dw_attr_ref attr
= ggc_alloc (sizeof (dw_attr_node
));
4997 attr
->dw_attr_next
= NULL
;
4998 attr
->dw_attr
= attr_kind
;
4999 attr
->dw_attr_val
.val_class
= dw_val_class_offset
;
5000 attr
->dw_attr_val
.v
.val_offset
= offset
;
5001 add_dwarf_attr (die
, attr
);
5004 /* Add an range_list attribute value to a DIE. */
5007 add_AT_range_list (dw_die_ref die
, enum dwarf_attribute attr_kind
,
5008 long unsigned int offset
)
5010 dw_attr_ref attr
= ggc_alloc (sizeof (dw_attr_node
));
5012 attr
->dw_attr_next
= NULL
;
5013 attr
->dw_attr
= attr_kind
;
5014 attr
->dw_attr_val
.val_class
= dw_val_class_range_list
;
5015 attr
->dw_attr_val
.v
.val_offset
= offset
;
5016 add_dwarf_attr (die
, attr
);
5019 static inline const char *
5020 AT_lbl (dw_attr_ref a
)
5022 gcc_assert (a
&& (AT_class (a
) == dw_val_class_lbl_id
5023 || AT_class (a
) == dw_val_class_lbl_offset
));
5024 return a
->dw_attr_val
.v
.val_lbl_id
;
5027 /* Get the attribute of type attr_kind. */
5030 get_AT (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5033 dw_die_ref spec
= NULL
;
5037 for (a
= die
->die_attr
; a
!= NULL
; a
= a
->dw_attr_next
)
5038 if (a
->dw_attr
== attr_kind
)
5040 else if (a
->dw_attr
== DW_AT_specification
5041 || a
->dw_attr
== DW_AT_abstract_origin
)
5045 return get_AT (spec
, attr_kind
);
5051 /* Return the "low pc" attribute value, typically associated with a subprogram
5052 DIE. Return null if the "low pc" attribute is either not present, or if it
5053 cannot be represented as an assembler label identifier. */
5055 static inline const char *
5056 get_AT_low_pc (dw_die_ref die
)
5058 dw_attr_ref a
= get_AT (die
, DW_AT_low_pc
);
5060 return a
? AT_lbl (a
) : NULL
;
5063 /* Return the "high pc" attribute value, typically associated with a subprogram
5064 DIE. Return null if the "high pc" attribute is either not present, or if it
5065 cannot be represented as an assembler label identifier. */
5067 static inline const char *
5068 get_AT_hi_pc (dw_die_ref die
)
5070 dw_attr_ref a
= get_AT (die
, DW_AT_high_pc
);
5072 return a
? AT_lbl (a
) : NULL
;
5075 /* Return the value of the string attribute designated by ATTR_KIND, or
5076 NULL if it is not present. */
5078 static inline const char *
5079 get_AT_string (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5081 dw_attr_ref a
= get_AT (die
, attr_kind
);
5083 return a
? AT_string (a
) : NULL
;
5086 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
5087 if it is not present. */
5090 get_AT_flag (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5092 dw_attr_ref a
= get_AT (die
, attr_kind
);
5094 return a
? AT_flag (a
) : 0;
5097 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
5098 if it is not present. */
5100 static inline unsigned
5101 get_AT_unsigned (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5103 dw_attr_ref a
= get_AT (die
, attr_kind
);
5105 return a
? AT_unsigned (a
) : 0;
5108 static inline dw_die_ref
5109 get_AT_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5111 dw_attr_ref a
= get_AT (die
, attr_kind
);
5113 return a
? AT_ref (a
) : NULL
;
5116 /* Return TRUE if the language is C or C++. */
5121 unsigned int lang
= get_AT_unsigned (comp_unit_die
, DW_AT_language
);
5123 return (lang
== DW_LANG_C
|| lang
== DW_LANG_C89
5124 || lang
== DW_LANG_C_plus_plus
);
5127 /* Return TRUE if the language is C++. */
5132 return (get_AT_unsigned (comp_unit_die
, DW_AT_language
)
5133 == DW_LANG_C_plus_plus
);
5136 /* Return TRUE if the language is Fortran. */
5141 unsigned int lang
= get_AT_unsigned (comp_unit_die
, DW_AT_language
);
5143 return (lang
== DW_LANG_Fortran77
5144 || lang
== DW_LANG_Fortran90
5145 || lang
== DW_LANG_Fortran95
);
5148 /* Return TRUE if the language is Java. */
5153 unsigned int lang
= get_AT_unsigned (comp_unit_die
, DW_AT_language
);
5155 return lang
== DW_LANG_Java
;
5158 /* Return TRUE if the language is Ada. */
5163 unsigned int lang
= get_AT_unsigned (comp_unit_die
, DW_AT_language
);
5165 return lang
== DW_LANG_Ada95
|| lang
== DW_LANG_Ada83
;
5168 /* Free up the memory used by A. */
5170 static inline void free_AT (dw_attr_ref
);
5172 free_AT (dw_attr_ref a
)
5174 if (AT_class (a
) == dw_val_class_str
)
5175 if (a
->dw_attr_val
.v
.val_str
->refcount
)
5176 a
->dw_attr_val
.v
.val_str
->refcount
--;
5179 /* Remove the specified attribute if present. */
5182 remove_AT (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5185 dw_attr_ref removed
= NULL
;
5189 for (p
= &(die
->die_attr
); *p
; p
= &((*p
)->dw_attr_next
))
5190 if ((*p
)->dw_attr
== attr_kind
)
5193 *p
= (*p
)->dw_attr_next
;
5202 /* Remove child die whose die_tag is specified tag. */
5205 remove_child_TAG (dw_die_ref die
, enum dwarf_tag tag
)
5207 dw_die_ref current
, prev
, next
;
5208 current
= die
->die_child
;
5210 while (current
!= NULL
)
5212 if (current
->die_tag
== tag
)
5214 next
= current
->die_sib
;
5216 die
->die_child
= next
;
5218 prev
->die_sib
= next
;
5225 current
= current
->die_sib
;
5230 /* Free up the memory used by DIE. */
5233 free_die (dw_die_ref die
)
5235 remove_children (die
);
5238 /* Discard the children of this DIE. */
5241 remove_children (dw_die_ref die
)
5243 dw_die_ref child_die
= die
->die_child
;
5245 die
->die_child
= NULL
;
5247 while (child_die
!= NULL
)
5249 dw_die_ref tmp_die
= child_die
;
5252 child_die
= child_die
->die_sib
;
5254 for (a
= tmp_die
->die_attr
; a
!= NULL
;)
5256 dw_attr_ref tmp_a
= a
;
5258 a
= a
->dw_attr_next
;
5266 /* Add a child DIE below its parent. We build the lists up in reverse
5267 addition order, and correct that in reverse_all_dies. */
5270 add_child_die (dw_die_ref die
, dw_die_ref child_die
)
5272 if (die
!= NULL
&& child_die
!= NULL
)
5274 gcc_assert (die
!= child_die
);
5276 child_die
->die_parent
= die
;
5277 child_die
->die_sib
= die
->die_child
;
5278 die
->die_child
= child_die
;
5282 /* Move CHILD, which must be a child of PARENT or the DIE for which PARENT
5283 is the specification, to the front of PARENT's list of children. */
5286 splice_child_die (dw_die_ref parent
, dw_die_ref child
)
5290 /* We want the declaration DIE from inside the class, not the
5291 specification DIE at toplevel. */
5292 if (child
->die_parent
!= parent
)
5294 dw_die_ref tmp
= get_AT_ref (child
, DW_AT_specification
);
5300 gcc_assert (child
->die_parent
== parent
5301 || (child
->die_parent
5302 == get_AT_ref (parent
, DW_AT_specification
)));
5304 for (p
= &(child
->die_parent
->die_child
); *p
; p
= &((*p
)->die_sib
))
5307 *p
= child
->die_sib
;
5311 child
->die_parent
= parent
;
5312 child
->die_sib
= parent
->die_child
;
5313 parent
->die_child
= child
;
5316 /* Return a pointer to a newly created DIE node. */
5318 static inline dw_die_ref
5319 new_die (enum dwarf_tag tag_value
, dw_die_ref parent_die
, tree t
)
5321 dw_die_ref die
= ggc_alloc_cleared (sizeof (die_node
));
5323 die
->die_tag
= tag_value
;
5325 if (parent_die
!= NULL
)
5326 add_child_die (parent_die
, die
);
5329 limbo_die_node
*limbo_node
;
5331 limbo_node
= ggc_alloc_cleared (sizeof (limbo_die_node
));
5332 limbo_node
->die
= die
;
5333 limbo_node
->created_for
= t
;
5334 limbo_node
->next
= limbo_die_list
;
5335 limbo_die_list
= limbo_node
;
5341 /* Return the DIE associated with the given type specifier. */
5343 static inline dw_die_ref
5344 lookup_type_die (tree type
)
5346 return TYPE_SYMTAB_DIE (type
);
5349 /* Equate a DIE to a given type specifier. */
5352 equate_type_number_to_die (tree type
, dw_die_ref type_die
)
5354 TYPE_SYMTAB_DIE (type
) = type_die
;
5357 /* Returns a hash value for X (which really is a die_struct). */
5360 decl_die_table_hash (const void *x
)
5362 return (hashval_t
) ((const dw_die_ref
) x
)->decl_id
;
5365 /* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y. */
5368 decl_die_table_eq (const void *x
, const void *y
)
5370 return (((const dw_die_ref
) x
)->decl_id
== DECL_UID ((const tree
) y
));
5373 /* Return the DIE associated with a given declaration. */
5375 static inline dw_die_ref
5376 lookup_decl_die (tree decl
)
5378 return htab_find_with_hash (decl_die_table
, decl
, DECL_UID (decl
));
5381 /* Returns a hash value for X (which really is a var_loc_list). */
5384 decl_loc_table_hash (const void *x
)
5386 return (hashval_t
) ((const var_loc_list
*) x
)->decl_id
;
5389 /* Return nonzero if decl_id of var_loc_list X is the same as
5393 decl_loc_table_eq (const void *x
, const void *y
)
5395 return (((const var_loc_list
*) x
)->decl_id
== DECL_UID ((const tree
) y
));
5398 /* Return the var_loc list associated with a given declaration. */
5400 static inline var_loc_list
*
5401 lookup_decl_loc (tree decl
)
5403 return htab_find_with_hash (decl_loc_table
, decl
, DECL_UID (decl
));
5406 /* Equate a DIE to a particular declaration. */
5409 equate_decl_number_to_die (tree decl
, dw_die_ref decl_die
)
5411 unsigned int decl_id
= DECL_UID (decl
);
5414 slot
= htab_find_slot_with_hash (decl_die_table
, decl
, decl_id
, INSERT
);
5416 decl_die
->decl_id
= decl_id
;
5419 /* Add a variable location node to the linked list for DECL. */
5422 add_var_loc_to_decl (tree decl
, struct var_loc_node
*loc
)
5424 unsigned int decl_id
= DECL_UID (decl
);
5428 slot
= htab_find_slot_with_hash (decl_loc_table
, decl
, decl_id
, INSERT
);
5431 temp
= ggc_alloc_cleared (sizeof (var_loc_list
));
5432 temp
->decl_id
= decl_id
;
5440 /* If the current location is the same as the end of the list,
5441 we have nothing to do. */
5442 if (!rtx_equal_p (NOTE_VAR_LOCATION_LOC (temp
->last
->var_loc_note
),
5443 NOTE_VAR_LOCATION_LOC (loc
->var_loc_note
)))
5445 /* Add LOC to the end of list and update LAST. */
5446 temp
->last
->next
= loc
;
5450 /* Do not add empty location to the beginning of the list. */
5451 else if (NOTE_VAR_LOCATION_LOC (loc
->var_loc_note
) != NULL_RTX
)
5458 /* Keep track of the number of spaces used to indent the
5459 output of the debugging routines that print the structure of
5460 the DIE internal representation. */
5461 static int print_indent
;
5463 /* Indent the line the number of spaces given by print_indent. */
5466 print_spaces (FILE *outfile
)
5468 fprintf (outfile
, "%*s", print_indent
, "");
5471 /* Print the information associated with a given DIE, and its children.
5472 This routine is a debugging aid only. */
5475 print_die (dw_die_ref die
, FILE *outfile
)
5480 print_spaces (outfile
);
5481 fprintf (outfile
, "DIE %4lu: %s\n",
5482 die
->die_offset
, dwarf_tag_name (die
->die_tag
));
5483 print_spaces (outfile
);
5484 fprintf (outfile
, " abbrev id: %lu", die
->die_abbrev
);
5485 fprintf (outfile
, " offset: %lu\n", die
->die_offset
);
5487 for (a
= die
->die_attr
; a
!= NULL
; a
= a
->dw_attr_next
)
5489 print_spaces (outfile
);
5490 fprintf (outfile
, " %s: ", dwarf_attr_name (a
->dw_attr
));
5492 switch (AT_class (a
))
5494 case dw_val_class_addr
:
5495 fprintf (outfile
, "address");
5497 case dw_val_class_offset
:
5498 fprintf (outfile
, "offset");
5500 case dw_val_class_loc
:
5501 fprintf (outfile
, "location descriptor");
5503 case dw_val_class_loc_list
:
5504 fprintf (outfile
, "location list -> label:%s",
5505 AT_loc_list (a
)->ll_symbol
);
5507 case dw_val_class_range_list
:
5508 fprintf (outfile
, "range list");
5510 case dw_val_class_const
:
5511 fprintf (outfile
, HOST_WIDE_INT_PRINT_DEC
, AT_int (a
));
5513 case dw_val_class_unsigned_const
:
5514 fprintf (outfile
, HOST_WIDE_INT_PRINT_UNSIGNED
, AT_unsigned (a
));
5516 case dw_val_class_long_long
:
5517 fprintf (outfile
, "constant (%lu,%lu)",
5518 a
->dw_attr_val
.v
.val_long_long
.hi
,
5519 a
->dw_attr_val
.v
.val_long_long
.low
);
5521 case dw_val_class_vec
:
5522 fprintf (outfile
, "floating-point or vector constant");
5524 case dw_val_class_flag
:
5525 fprintf (outfile
, "%u", AT_flag (a
));
5527 case dw_val_class_die_ref
:
5528 if (AT_ref (a
) != NULL
)
5530 if (AT_ref (a
)->die_symbol
)
5531 fprintf (outfile
, "die -> label: %s", AT_ref (a
)->die_symbol
);
5533 fprintf (outfile
, "die -> %lu", AT_ref (a
)->die_offset
);
5536 fprintf (outfile
, "die -> <null>");
5538 case dw_val_class_lbl_id
:
5539 case dw_val_class_lbl_offset
:
5540 fprintf (outfile
, "label: %s", AT_lbl (a
));
5542 case dw_val_class_str
:
5543 if (AT_string (a
) != NULL
)
5544 fprintf (outfile
, "\"%s\"", AT_string (a
));
5546 fprintf (outfile
, "<null>");
5552 fprintf (outfile
, "\n");
5555 if (die
->die_child
!= NULL
)
5558 for (c
= die
->die_child
; c
!= NULL
; c
= c
->die_sib
)
5559 print_die (c
, outfile
);
5563 if (print_indent
== 0)
5564 fprintf (outfile
, "\n");
5567 /* Print the contents of the source code line number correspondence table.
5568 This routine is a debugging aid only. */
5571 print_dwarf_line_table (FILE *outfile
)
5574 dw_line_info_ref line_info
;
5576 fprintf (outfile
, "\n\nDWARF source line information\n");
5577 for (i
= 1; i
< line_info_table_in_use
; i
++)
5579 line_info
= &line_info_table
[i
];
5580 fprintf (outfile
, "%5d: ", i
);
5581 fprintf (outfile
, "%-20s",
5582 VARRAY_CHAR_PTR (file_table
, line_info
->dw_file_num
));
5583 fprintf (outfile
, "%6ld", line_info
->dw_line_num
);
5584 fprintf (outfile
, "\n");
5587 fprintf (outfile
, "\n\n");
5590 /* Print the information collected for a given DIE. */
5593 debug_dwarf_die (dw_die_ref die
)
5595 print_die (die
, stderr
);
5598 /* Print all DWARF information collected for the compilation unit.
5599 This routine is a debugging aid only. */
5605 print_die (comp_unit_die
, stderr
);
5606 if (! DWARF2_ASM_LINE_DEBUG_INFO
)
5607 print_dwarf_line_table (stderr
);
5610 /* We build up the lists of children and attributes by pushing new ones
5611 onto the beginning of the list. Reverse the lists for DIE so that
5612 they are in order of addition. */
5615 reverse_die_lists (dw_die_ref die
)
5617 dw_die_ref c
, cp
, cn
;
5618 dw_attr_ref a
, ap
, an
;
5620 for (a
= die
->die_attr
, ap
= 0; a
; a
= an
)
5622 an
= a
->dw_attr_next
;
5623 a
->dw_attr_next
= ap
;
5629 for (c
= die
->die_child
, cp
= 0; c
; c
= cn
)
5636 die
->die_child
= cp
;
5639 /* reverse_die_lists only reverses the single die you pass it. Since we used to
5640 reverse all dies in add_sibling_attributes, which runs through all the dies,
5641 it would reverse all the dies. Now, however, since we don't call
5642 reverse_die_lists in add_sibling_attributes, we need a routine to
5643 recursively reverse all the dies. This is that routine. */
5646 reverse_all_dies (dw_die_ref die
)
5650 reverse_die_lists (die
);
5652 for (c
= die
->die_child
; c
; c
= c
->die_sib
)
5653 reverse_all_dies (c
);
5656 /* Start a new compilation unit DIE for an include file. OLD_UNIT is the CU
5657 for the enclosing include file, if any. BINCL_DIE is the DW_TAG_GNU_BINCL
5658 DIE that marks the start of the DIEs for this include file. */
5661 push_new_compile_unit (dw_die_ref old_unit
, dw_die_ref bincl_die
)
5663 const char *filename
= get_AT_string (bincl_die
, DW_AT_name
);
5664 dw_die_ref new_unit
= gen_compile_unit_die (filename
);
5666 new_unit
->die_sib
= old_unit
;
5670 /* Close an include-file CU and reopen the enclosing one. */
5673 pop_compile_unit (dw_die_ref old_unit
)
5675 dw_die_ref new_unit
= old_unit
->die_sib
;
5677 old_unit
->die_sib
= NULL
;
5681 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
5682 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO), ctx)
5684 /* Calculate the checksum of a location expression. */
5687 loc_checksum (dw_loc_descr_ref loc
, struct md5_ctx
*ctx
)
5689 CHECKSUM (loc
->dw_loc_opc
);
5690 CHECKSUM (loc
->dw_loc_oprnd1
);
5691 CHECKSUM (loc
->dw_loc_oprnd2
);
5694 /* Calculate the checksum of an attribute. */
5697 attr_checksum (dw_attr_ref at
, struct md5_ctx
*ctx
, int *mark
)
5699 dw_loc_descr_ref loc
;
5702 CHECKSUM (at
->dw_attr
);
5704 /* We don't care about differences in file numbering. */
5705 if (at
->dw_attr
== DW_AT_decl_file
5706 /* Or that this was compiled with a different compiler snapshot; if
5707 the output is the same, that's what matters. */
5708 || at
->dw_attr
== DW_AT_producer
)
5711 switch (AT_class (at
))
5713 case dw_val_class_const
:
5714 CHECKSUM (at
->dw_attr_val
.v
.val_int
);
5716 case dw_val_class_unsigned_const
:
5717 CHECKSUM (at
->dw_attr_val
.v
.val_unsigned
);
5719 case dw_val_class_long_long
:
5720 CHECKSUM (at
->dw_attr_val
.v
.val_long_long
);
5722 case dw_val_class_vec
:
5723 CHECKSUM (at
->dw_attr_val
.v
.val_vec
);
5725 case dw_val_class_flag
:
5726 CHECKSUM (at
->dw_attr_val
.v
.val_flag
);
5728 case dw_val_class_str
:
5729 CHECKSUM_STRING (AT_string (at
));
5732 case dw_val_class_addr
:
5734 gcc_assert (GET_CODE (r
) == SYMBOL_REF
);
5735 CHECKSUM_STRING (XSTR (r
, 0));
5738 case dw_val_class_offset
:
5739 CHECKSUM (at
->dw_attr_val
.v
.val_offset
);
5742 case dw_val_class_loc
:
5743 for (loc
= AT_loc (at
); loc
; loc
= loc
->dw_loc_next
)
5744 loc_checksum (loc
, ctx
);
5747 case dw_val_class_die_ref
:
5748 die_checksum (AT_ref (at
), ctx
, mark
);
5751 case dw_val_class_fde_ref
:
5752 case dw_val_class_lbl_id
:
5753 case dw_val_class_lbl_offset
:
5761 /* Calculate the checksum of a DIE. */
5764 die_checksum (dw_die_ref die
, struct md5_ctx
*ctx
, int *mark
)
5769 /* To avoid infinite recursion. */
5772 CHECKSUM (die
->die_mark
);
5775 die
->die_mark
= ++(*mark
);
5777 CHECKSUM (die
->die_tag
);
5779 for (a
= die
->die_attr
; a
; a
= a
->dw_attr_next
)
5780 attr_checksum (a
, ctx
, mark
);
5782 for (c
= die
->die_child
; c
; c
= c
->die_sib
)
5783 die_checksum (c
, ctx
, mark
);
5787 #undef CHECKSUM_STRING
5789 /* Do the location expressions look same? */
5791 same_loc_p (dw_loc_descr_ref loc1
, dw_loc_descr_ref loc2
, int *mark
)
5793 return loc1
->dw_loc_opc
== loc2
->dw_loc_opc
5794 && same_dw_val_p (&loc1
->dw_loc_oprnd1
, &loc2
->dw_loc_oprnd1
, mark
)
5795 && same_dw_val_p (&loc1
->dw_loc_oprnd2
, &loc2
->dw_loc_oprnd2
, mark
);
5798 /* Do the values look the same? */
5800 same_dw_val_p (dw_val_node
*v1
, dw_val_node
*v2
, int *mark
)
5802 dw_loc_descr_ref loc1
, loc2
;
5805 if (v1
->val_class
!= v2
->val_class
)
5808 switch (v1
->val_class
)
5810 case dw_val_class_const
:
5811 return v1
->v
.val_int
== v2
->v
.val_int
;
5812 case dw_val_class_unsigned_const
:
5813 return v1
->v
.val_unsigned
== v2
->v
.val_unsigned
;
5814 case dw_val_class_long_long
:
5815 return v1
->v
.val_long_long
.hi
== v2
->v
.val_long_long
.hi
5816 && v1
->v
.val_long_long
.low
== v2
->v
.val_long_long
.low
;
5817 case dw_val_class_vec
:
5818 if (v1
->v
.val_vec
.length
!= v2
->v
.val_vec
.length
5819 || v1
->v
.val_vec
.elt_size
!= v2
->v
.val_vec
.elt_size
)
5821 if (memcmp (v1
->v
.val_vec
.array
, v2
->v
.val_vec
.array
,
5822 v1
->v
.val_vec
.length
* v1
->v
.val_vec
.elt_size
))
5825 case dw_val_class_flag
:
5826 return v1
->v
.val_flag
== v2
->v
.val_flag
;
5827 case dw_val_class_str
:
5828 return !strcmp(v1
->v
.val_str
->str
, v2
->v
.val_str
->str
);
5830 case dw_val_class_addr
:
5831 r1
= v1
->v
.val_addr
;
5832 r2
= v2
->v
.val_addr
;
5833 if (GET_CODE (r1
) != GET_CODE (r2
))
5835 gcc_assert (GET_CODE (r1
) == SYMBOL_REF
);
5836 return !strcmp (XSTR (r1
, 0), XSTR (r2
, 0));
5838 case dw_val_class_offset
:
5839 return v1
->v
.val_offset
== v2
->v
.val_offset
;
5841 case dw_val_class_loc
:
5842 for (loc1
= v1
->v
.val_loc
, loc2
= v2
->v
.val_loc
;
5844 loc1
= loc1
->dw_loc_next
, loc2
= loc2
->dw_loc_next
)
5845 if (!same_loc_p (loc1
, loc2
, mark
))
5847 return !loc1
&& !loc2
;
5849 case dw_val_class_die_ref
:
5850 return same_die_p (v1
->v
.val_die_ref
.die
, v2
->v
.val_die_ref
.die
, mark
);
5852 case dw_val_class_fde_ref
:
5853 case dw_val_class_lbl_id
:
5854 case dw_val_class_lbl_offset
:
5862 /* Do the attributes look the same? */
5865 same_attr_p (dw_attr_ref at1
, dw_attr_ref at2
, int *mark
)
5867 if (at1
->dw_attr
!= at2
->dw_attr
)
5870 /* We don't care about differences in file numbering. */
5871 if (at1
->dw_attr
== DW_AT_decl_file
5872 /* Or that this was compiled with a different compiler snapshot; if
5873 the output is the same, that's what matters. */
5874 || at1
->dw_attr
== DW_AT_producer
)
5877 return same_dw_val_p (&at1
->dw_attr_val
, &at2
->dw_attr_val
, mark
);
5880 /* Do the dies look the same? */
5883 same_die_p (dw_die_ref die1
, dw_die_ref die2
, int *mark
)
5888 /* To avoid infinite recursion. */
5890 return die1
->die_mark
== die2
->die_mark
;
5891 die1
->die_mark
= die2
->die_mark
= ++(*mark
);
5893 if (die1
->die_tag
!= die2
->die_tag
)
5896 for (a1
= die1
->die_attr
, a2
= die2
->die_attr
;
5898 a1
= a1
->dw_attr_next
, a2
= a2
->dw_attr_next
)
5899 if (!same_attr_p (a1
, a2
, mark
))
5904 for (c1
= die1
->die_child
, c2
= die2
->die_child
;
5906 c1
= c1
->die_sib
, c2
= c2
->die_sib
)
5907 if (!same_die_p (c1
, c2
, mark
))
5915 /* Do the dies look the same? Wrapper around same_die_p. */
5918 same_die_p_wrap (dw_die_ref die1
, dw_die_ref die2
)
5921 int ret
= same_die_p (die1
, die2
, &mark
);
5923 unmark_all_dies (die1
);
5924 unmark_all_dies (die2
);
5929 /* The prefix to attach to symbols on DIEs in the current comdat debug
5931 static char *comdat_symbol_id
;
5933 /* The index of the current symbol within the current comdat CU. */
5934 static unsigned int comdat_symbol_number
;
5936 /* Calculate the MD5 checksum of the compilation unit DIE UNIT_DIE and its
5937 children, and set comdat_symbol_id accordingly. */
5940 compute_section_prefix (dw_die_ref unit_die
)
5942 const char *die_name
= get_AT_string (unit_die
, DW_AT_name
);
5943 const char *base
= die_name
? lbasename (die_name
) : "anonymous";
5944 char *name
= alloca (strlen (base
) + 64);
5947 unsigned char checksum
[16];
5950 /* Compute the checksum of the DIE, then append part of it as hex digits to
5951 the name filename of the unit. */
5953 md5_init_ctx (&ctx
);
5955 die_checksum (unit_die
, &ctx
, &mark
);
5956 unmark_all_dies (unit_die
);
5957 md5_finish_ctx (&ctx
, checksum
);
5959 sprintf (name
, "%s.", base
);
5960 clean_symbol_name (name
);
5962 p
= name
+ strlen (name
);
5963 for (i
= 0; i
< 4; i
++)
5965 sprintf (p
, "%.2x", checksum
[i
]);
5969 comdat_symbol_id
= unit_die
->die_symbol
= xstrdup (name
);
5970 comdat_symbol_number
= 0;
5973 /* Returns nonzero if DIE represents a type, in the sense of TYPE_P. */
5976 is_type_die (dw_die_ref die
)
5978 switch (die
->die_tag
)
5980 case DW_TAG_array_type
:
5981 case DW_TAG_class_type
:
5982 case DW_TAG_enumeration_type
:
5983 case DW_TAG_pointer_type
:
5984 case DW_TAG_reference_type
:
5985 case DW_TAG_string_type
:
5986 case DW_TAG_structure_type
:
5987 case DW_TAG_subroutine_type
:
5988 case DW_TAG_union_type
:
5989 case DW_TAG_ptr_to_member_type
:
5990 case DW_TAG_set_type
:
5991 case DW_TAG_subrange_type
:
5992 case DW_TAG_base_type
:
5993 case DW_TAG_const_type
:
5994 case DW_TAG_file_type
:
5995 case DW_TAG_packed_type
:
5996 case DW_TAG_volatile_type
:
5997 case DW_TAG_typedef
:
6004 /* Returns 1 iff C is the sort of DIE that should go into a COMDAT CU.
6005 Basically, we want to choose the bits that are likely to be shared between
6006 compilations (types) and leave out the bits that are specific to individual
6007 compilations (functions). */
6010 is_comdat_die (dw_die_ref c
)
6012 /* I think we want to leave base types and __vtbl_ptr_type in the main CU, as
6013 we do for stabs. The advantage is a greater likelihood of sharing between
6014 objects that don't include headers in the same order (and therefore would
6015 put the base types in a different comdat). jason 8/28/00 */
6017 if (c
->die_tag
== DW_TAG_base_type
)
6020 if (c
->die_tag
== DW_TAG_pointer_type
6021 || c
->die_tag
== DW_TAG_reference_type
6022 || c
->die_tag
== DW_TAG_const_type
6023 || c
->die_tag
== DW_TAG_volatile_type
)
6025 dw_die_ref t
= get_AT_ref (c
, DW_AT_type
);
6027 return t
? is_comdat_die (t
) : 0;
6030 return is_type_die (c
);
6033 /* Returns 1 iff C is the sort of DIE that might be referred to from another
6034 compilation unit. */
6037 is_symbol_die (dw_die_ref c
)
6039 return (is_type_die (c
)
6040 || (get_AT (c
, DW_AT_declaration
)
6041 && !get_AT (c
, DW_AT_specification
)));
6045 gen_internal_sym (const char *prefix
)
6049 ASM_GENERATE_INTERNAL_LABEL (buf
, prefix
, label_num
++);
6050 return xstrdup (buf
);
6053 /* Assign symbols to all worthy DIEs under DIE. */
6056 assign_symbol_names (dw_die_ref die
)
6060 if (is_symbol_die (die
))
6062 if (comdat_symbol_id
)
6064 char *p
= alloca (strlen (comdat_symbol_id
) + 64);
6066 sprintf (p
, "%s.%s.%x", DIE_LABEL_PREFIX
,
6067 comdat_symbol_id
, comdat_symbol_number
++);
6068 die
->die_symbol
= xstrdup (p
);
6071 die
->die_symbol
= gen_internal_sym ("LDIE");
6074 for (c
= die
->die_child
; c
!= NULL
; c
= c
->die_sib
)
6075 assign_symbol_names (c
);
6078 struct cu_hash_table_entry
6081 unsigned min_comdat_num
, max_comdat_num
;
6082 struct cu_hash_table_entry
*next
;
6085 /* Routines to manipulate hash table of CUs. */
6087 htab_cu_hash (const void *of
)
6089 const struct cu_hash_table_entry
*entry
= of
;
6091 return htab_hash_string (entry
->cu
->die_symbol
);
6095 htab_cu_eq (const void *of1
, const void *of2
)
6097 const struct cu_hash_table_entry
*entry1
= of1
;
6098 const struct die_struct
*entry2
= of2
;
6100 return !strcmp (entry1
->cu
->die_symbol
, entry2
->die_symbol
);
6104 htab_cu_del (void *what
)
6106 struct cu_hash_table_entry
*next
, *entry
= what
;
6116 /* Check whether we have already seen this CU and set up SYM_NUM
6119 check_duplicate_cu (dw_die_ref cu
, htab_t htable
, unsigned int *sym_num
)
6121 struct cu_hash_table_entry dummy
;
6122 struct cu_hash_table_entry
**slot
, *entry
, *last
= &dummy
;
6124 dummy
.max_comdat_num
= 0;
6126 slot
= (struct cu_hash_table_entry
**)
6127 htab_find_slot_with_hash (htable
, cu
, htab_hash_string (cu
->die_symbol
),
6131 for (; entry
; last
= entry
, entry
= entry
->next
)
6133 if (same_die_p_wrap (cu
, entry
->cu
))
6139 *sym_num
= entry
->min_comdat_num
;
6143 entry
= xcalloc (1, sizeof (struct cu_hash_table_entry
));
6145 entry
->min_comdat_num
= *sym_num
= last
->max_comdat_num
;
6146 entry
->next
= *slot
;
6152 /* Record SYM_NUM to record of CU in HTABLE. */
6154 record_comdat_symbol_number (dw_die_ref cu
, htab_t htable
, unsigned int sym_num
)
6156 struct cu_hash_table_entry
**slot
, *entry
;
6158 slot
= (struct cu_hash_table_entry
**)
6159 htab_find_slot_with_hash (htable
, cu
, htab_hash_string (cu
->die_symbol
),
6163 entry
->max_comdat_num
= sym_num
;
6166 /* Traverse the DIE (which is always comp_unit_die), and set up
6167 additional compilation units for each of the include files we see
6168 bracketed by BINCL/EINCL. */
6171 break_out_includes (dw_die_ref die
)
6174 dw_die_ref unit
= NULL
;
6175 limbo_die_node
*node
, **pnode
;
6176 htab_t cu_hash_table
;
6178 for (ptr
= &(die
->die_child
); *ptr
;)
6180 dw_die_ref c
= *ptr
;
6182 if (c
->die_tag
== DW_TAG_GNU_BINCL
|| c
->die_tag
== DW_TAG_GNU_EINCL
6183 || (unit
&& is_comdat_die (c
)))
6185 /* This DIE is for a secondary CU; remove it from the main one. */
6188 if (c
->die_tag
== DW_TAG_GNU_BINCL
)
6190 unit
= push_new_compile_unit (unit
, c
);
6193 else if (c
->die_tag
== DW_TAG_GNU_EINCL
)
6195 unit
= pop_compile_unit (unit
);
6199 add_child_die (unit
, c
);
6203 /* Leave this DIE in the main CU. */
6204 ptr
= &(c
->die_sib
);
6210 /* We can only use this in debugging, since the frontend doesn't check
6211 to make sure that we leave every include file we enter. */
6215 assign_symbol_names (die
);
6216 cu_hash_table
= htab_create (10, htab_cu_hash
, htab_cu_eq
, htab_cu_del
);
6217 for (node
= limbo_die_list
, pnode
= &limbo_die_list
;
6223 compute_section_prefix (node
->die
);
6224 is_dupl
= check_duplicate_cu (node
->die
, cu_hash_table
,
6225 &comdat_symbol_number
);
6226 assign_symbol_names (node
->die
);
6228 *pnode
= node
->next
;
6231 pnode
= &node
->next
;
6232 record_comdat_symbol_number (node
->die
, cu_hash_table
,
6233 comdat_symbol_number
);
6236 htab_delete (cu_hash_table
);
6239 /* Traverse the DIE and add a sibling attribute if it may have the
6240 effect of speeding up access to siblings. To save some space,
6241 avoid generating sibling attributes for DIE's without children. */
6244 add_sibling_attributes (dw_die_ref die
)
6248 if (die
->die_tag
!= DW_TAG_compile_unit
6249 && die
->die_sib
&& die
->die_child
!= NULL
)
6250 /* Add the sibling link to the front of the attribute list. */
6251 add_AT_die_ref (die
, DW_AT_sibling
, die
->die_sib
);
6253 for (c
= die
->die_child
; c
!= NULL
; c
= c
->die_sib
)
6254 add_sibling_attributes (c
);
6257 /* Output all location lists for the DIE and its children. */
6260 output_location_lists (dw_die_ref die
)
6265 for (d_attr
= die
->die_attr
; d_attr
; d_attr
= d_attr
->dw_attr_next
)
6266 if (AT_class (d_attr
) == dw_val_class_loc_list
)
6267 output_loc_list (AT_loc_list (d_attr
));
6269 for (c
= die
->die_child
; c
!= NULL
; c
= c
->die_sib
)
6270 output_location_lists (c
);
6274 /* The format of each DIE (and its attribute value pairs) is encoded in an
6275 abbreviation table. This routine builds the abbreviation table and assigns
6276 a unique abbreviation id for each abbreviation entry. The children of each
6277 die are visited recursively. */
6280 build_abbrev_table (dw_die_ref die
)
6282 unsigned long abbrev_id
;
6283 unsigned int n_alloc
;
6285 dw_attr_ref d_attr
, a_attr
;
6287 /* Scan the DIE references, and mark as external any that refer to
6288 DIEs from other CUs (i.e. those which are not marked). */
6289 for (d_attr
= die
->die_attr
; d_attr
; d_attr
= d_attr
->dw_attr_next
)
6290 if (AT_class (d_attr
) == dw_val_class_die_ref
6291 && AT_ref (d_attr
)->die_mark
== 0)
6293 gcc_assert (AT_ref (d_attr
)->die_symbol
);
6295 set_AT_ref_external (d_attr
, 1);
6298 for (abbrev_id
= 1; abbrev_id
< abbrev_die_table_in_use
; ++abbrev_id
)
6300 dw_die_ref abbrev
= abbrev_die_table
[abbrev_id
];
6302 if (abbrev
->die_tag
== die
->die_tag
)
6304 if ((abbrev
->die_child
!= NULL
) == (die
->die_child
!= NULL
))
6306 a_attr
= abbrev
->die_attr
;
6307 d_attr
= die
->die_attr
;
6309 while (a_attr
!= NULL
&& d_attr
!= NULL
)
6311 if ((a_attr
->dw_attr
!= d_attr
->dw_attr
)
6312 || (value_format (a_attr
) != value_format (d_attr
)))
6315 a_attr
= a_attr
->dw_attr_next
;
6316 d_attr
= d_attr
->dw_attr_next
;
6319 if (a_attr
== NULL
&& d_attr
== NULL
)
6325 if (abbrev_id
>= abbrev_die_table_in_use
)
6327 if (abbrev_die_table_in_use
>= abbrev_die_table_allocated
)
6329 n_alloc
= abbrev_die_table_allocated
+ ABBREV_DIE_TABLE_INCREMENT
;
6330 abbrev_die_table
= ggc_realloc (abbrev_die_table
,
6331 sizeof (dw_die_ref
) * n_alloc
);
6333 memset (&abbrev_die_table
[abbrev_die_table_allocated
], 0,
6334 (n_alloc
- abbrev_die_table_allocated
) * sizeof (dw_die_ref
));
6335 abbrev_die_table_allocated
= n_alloc
;
6338 ++abbrev_die_table_in_use
;
6339 abbrev_die_table
[abbrev_id
] = die
;
6342 die
->die_abbrev
= abbrev_id
;
6343 for (c
= die
->die_child
; c
!= NULL
; c
= c
->die_sib
)
6344 build_abbrev_table (c
);
6347 /* Return the power-of-two number of bytes necessary to represent VALUE. */
6350 constant_size (long unsigned int value
)
6357 log
= floor_log2 (value
);
6360 log
= 1 << (floor_log2 (log
) + 1);
6365 /* Return the size of a DIE as it is represented in the
6366 .debug_info section. */
6368 static unsigned long
6369 size_of_die (dw_die_ref die
)
6371 unsigned long size
= 0;
6374 size
+= size_of_uleb128 (die
->die_abbrev
);
6375 for (a
= die
->die_attr
; a
!= NULL
; a
= a
->dw_attr_next
)
6377 switch (AT_class (a
))
6379 case dw_val_class_addr
:
6380 size
+= DWARF2_ADDR_SIZE
;
6382 case dw_val_class_offset
:
6383 size
+= DWARF_OFFSET_SIZE
;
6385 case dw_val_class_loc
:
6387 unsigned long lsize
= size_of_locs (AT_loc (a
));
6390 size
+= constant_size (lsize
);
6394 case dw_val_class_loc_list
:
6395 size
+= DWARF_OFFSET_SIZE
;
6397 case dw_val_class_range_list
:
6398 size
+= DWARF_OFFSET_SIZE
;
6400 case dw_val_class_const
:
6401 size
+= size_of_sleb128 (AT_int (a
));
6403 case dw_val_class_unsigned_const
:
6404 size
+= constant_size (AT_unsigned (a
));
6406 case dw_val_class_long_long
:
6407 size
+= 1 + 2*HOST_BITS_PER_LONG
/HOST_BITS_PER_CHAR
; /* block */
6409 case dw_val_class_vec
:
6410 size
+= 1 + (a
->dw_attr_val
.v
.val_vec
.length
6411 * a
->dw_attr_val
.v
.val_vec
.elt_size
); /* block */
6413 case dw_val_class_flag
:
6416 case dw_val_class_die_ref
:
6417 if (AT_ref_external (a
))
6418 size
+= DWARF2_ADDR_SIZE
;
6420 size
+= DWARF_OFFSET_SIZE
;
6422 case dw_val_class_fde_ref
:
6423 size
+= DWARF_OFFSET_SIZE
;
6425 case dw_val_class_lbl_id
:
6426 size
+= DWARF2_ADDR_SIZE
;
6428 case dw_val_class_lbl_offset
:
6429 size
+= DWARF_OFFSET_SIZE
;
6431 case dw_val_class_str
:
6432 if (AT_string_form (a
) == DW_FORM_strp
)
6433 size
+= DWARF_OFFSET_SIZE
;
6435 size
+= strlen (a
->dw_attr_val
.v
.val_str
->str
) + 1;
6445 /* Size the debugging information associated with a given DIE. Visits the
6446 DIE's children recursively. Updates the global variable next_die_offset, on
6447 each time through. Uses the current value of next_die_offset to update the
6448 die_offset field in each DIE. */
6451 calc_die_sizes (dw_die_ref die
)
6455 die
->die_offset
= next_die_offset
;
6456 next_die_offset
+= size_of_die (die
);
6458 for (c
= die
->die_child
; c
!= NULL
; c
= c
->die_sib
)
6461 if (die
->die_child
!= NULL
)
6462 /* Count the null byte used to terminate sibling lists. */
6463 next_die_offset
+= 1;
6466 /* Set the marks for a die and its children. We do this so
6467 that we know whether or not a reference needs to use FORM_ref_addr; only
6468 DIEs in the same CU will be marked. We used to clear out the offset
6469 and use that as the flag, but ran into ordering problems. */
6472 mark_dies (dw_die_ref die
)
6476 gcc_assert (!die
->die_mark
);
6479 for (c
= die
->die_child
; c
; c
= c
->die_sib
)
6483 /* Clear the marks for a die and its children. */
6486 unmark_dies (dw_die_ref die
)
6490 gcc_assert (die
->die_mark
);
6493 for (c
= die
->die_child
; c
; c
= c
->die_sib
)
6497 /* Clear the marks for a die, its children and referred dies. */
6500 unmark_all_dies (dw_die_ref die
)
6509 for (c
= die
->die_child
; c
; c
= c
->die_sib
)
6510 unmark_all_dies (c
);
6512 for (a
= die
->die_attr
; a
; a
= a
->dw_attr_next
)
6513 if (AT_class (a
) == dw_val_class_die_ref
)
6514 unmark_all_dies (AT_ref (a
));
6517 /* Return the size of the .debug_pubnames table generated for the
6518 compilation unit. */
6520 static unsigned long
6521 size_of_pubnames (void)
6526 size
= DWARF_PUBNAMES_HEADER_SIZE
;
6527 for (i
= 0; i
< pubname_table_in_use
; i
++)
6529 pubname_ref p
= &pubname_table
[i
];
6530 size
+= DWARF_OFFSET_SIZE
+ strlen (p
->name
) + 1;
6533 size
+= DWARF_OFFSET_SIZE
;
6537 /* Return the size of the information in the .debug_aranges section. */
6539 static unsigned long
6540 size_of_aranges (void)
6544 size
= DWARF_ARANGES_HEADER_SIZE
;
6546 /* Count the address/length pair for this compilation unit. */
6547 size
+= 2 * DWARF2_ADDR_SIZE
;
6548 size
+= 2 * DWARF2_ADDR_SIZE
* arange_table_in_use
;
6550 /* Count the two zero words used to terminated the address range table. */
6551 size
+= 2 * DWARF2_ADDR_SIZE
;
6555 /* Select the encoding of an attribute value. */
6557 static enum dwarf_form
6558 value_format (dw_attr_ref a
)
6560 switch (a
->dw_attr_val
.val_class
)
6562 case dw_val_class_addr
:
6563 return DW_FORM_addr
;
6564 case dw_val_class_range_list
:
6565 case dw_val_class_offset
:
6566 switch (DWARF_OFFSET_SIZE
)
6569 return DW_FORM_data4
;
6571 return DW_FORM_data8
;
6575 case dw_val_class_loc_list
:
6576 /* FIXME: Could be DW_FORM_data8, with a > 32 bit size
6577 .debug_loc section */
6578 return DW_FORM_data4
;
6579 case dw_val_class_loc
:
6580 switch (constant_size (size_of_locs (AT_loc (a
))))
6583 return DW_FORM_block1
;
6585 return DW_FORM_block2
;
6589 case dw_val_class_const
:
6590 return DW_FORM_sdata
;
6591 case dw_val_class_unsigned_const
:
6592 switch (constant_size (AT_unsigned (a
)))
6595 return DW_FORM_data1
;
6597 return DW_FORM_data2
;
6599 return DW_FORM_data4
;
6601 return DW_FORM_data8
;
6605 case dw_val_class_long_long
:
6606 return DW_FORM_block1
;
6607 case dw_val_class_vec
:
6608 return DW_FORM_block1
;
6609 case dw_val_class_flag
:
6610 return DW_FORM_flag
;
6611 case dw_val_class_die_ref
:
6612 if (AT_ref_external (a
))
6613 return DW_FORM_ref_addr
;
6616 case dw_val_class_fde_ref
:
6617 return DW_FORM_data
;
6618 case dw_val_class_lbl_id
:
6619 return DW_FORM_addr
;
6620 case dw_val_class_lbl_offset
:
6621 return DW_FORM_data
;
6622 case dw_val_class_str
:
6623 return AT_string_form (a
);
6630 /* Output the encoding of an attribute value. */
6633 output_value_format (dw_attr_ref a
)
6635 enum dwarf_form form
= value_format (a
);
6637 dw2_asm_output_data_uleb128 (form
, "(%s)", dwarf_form_name (form
));
6640 /* Output the .debug_abbrev section which defines the DIE abbreviation
6644 output_abbrev_section (void)
6646 unsigned long abbrev_id
;
6650 for (abbrev_id
= 1; abbrev_id
< abbrev_die_table_in_use
; ++abbrev_id
)
6652 dw_die_ref abbrev
= abbrev_die_table
[abbrev_id
];
6654 dw2_asm_output_data_uleb128 (abbrev_id
, "(abbrev code)");
6655 dw2_asm_output_data_uleb128 (abbrev
->die_tag
, "(TAG: %s)",
6656 dwarf_tag_name (abbrev
->die_tag
));
6658 if (abbrev
->die_child
!= NULL
)
6659 dw2_asm_output_data (1, DW_children_yes
, "DW_children_yes");
6661 dw2_asm_output_data (1, DW_children_no
, "DW_children_no");
6663 for (a_attr
= abbrev
->die_attr
; a_attr
!= NULL
;
6664 a_attr
= a_attr
->dw_attr_next
)
6666 dw2_asm_output_data_uleb128 (a_attr
->dw_attr
, "(%s)",
6667 dwarf_attr_name (a_attr
->dw_attr
));
6668 output_value_format (a_attr
);
6671 dw2_asm_output_data (1, 0, NULL
);
6672 dw2_asm_output_data (1, 0, NULL
);
6675 /* Terminate the table. */
6676 dw2_asm_output_data (1, 0, NULL
);
6679 /* Output a symbol we can use to refer to this DIE from another CU. */
6682 output_die_symbol (dw_die_ref die
)
6684 char *sym
= die
->die_symbol
;
6689 if (strncmp (sym
, DIE_LABEL_PREFIX
, sizeof (DIE_LABEL_PREFIX
) - 1) == 0)
6690 /* We make these global, not weak; if the target doesn't support
6691 .linkonce, it doesn't support combining the sections, so debugging
6693 targetm
.asm_out
.globalize_label (asm_out_file
, sym
);
6695 ASM_OUTPUT_LABEL (asm_out_file
, sym
);
6698 /* Return a new location list, given the begin and end range, and the
6699 expression. gensym tells us whether to generate a new internal symbol for
6700 this location list node, which is done for the head of the list only. */
6702 static inline dw_loc_list_ref
6703 new_loc_list (dw_loc_descr_ref expr
, const char *begin
, const char *end
,
6704 const char *section
, unsigned int gensym
)
6706 dw_loc_list_ref retlist
= ggc_alloc_cleared (sizeof (dw_loc_list_node
));
6708 retlist
->begin
= begin
;
6710 retlist
->expr
= expr
;
6711 retlist
->section
= section
;
6713 retlist
->ll_symbol
= gen_internal_sym ("LLST");
6718 /* Add a location description expression to a location list. */
6721 add_loc_descr_to_loc_list (dw_loc_list_ref
*list_head
, dw_loc_descr_ref descr
,
6722 const char *begin
, const char *end
,
6723 const char *section
)
6727 /* Find the end of the chain. */
6728 for (d
= list_head
; (*d
) != NULL
; d
= &(*d
)->dw_loc_next
)
6731 /* Add a new location list node to the list. */
6732 *d
= new_loc_list (descr
, begin
, end
, section
, 0);
6735 /* Output the location list given to us. */
6738 output_loc_list (dw_loc_list_ref list_head
)
6740 dw_loc_list_ref curr
= list_head
;
6742 ASM_OUTPUT_LABEL (asm_out_file
, list_head
->ll_symbol
);
6744 /* Walk the location list, and output each range + expression. */
6745 for (curr
= list_head
; curr
!= NULL
; curr
= curr
->dw_loc_next
)
6748 if (separate_line_info_table_in_use
== 0)
6750 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, curr
->begin
, curr
->section
,
6751 "Location list begin address (%s)",
6752 list_head
->ll_symbol
);
6753 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, curr
->end
, curr
->section
,
6754 "Location list end address (%s)",
6755 list_head
->ll_symbol
);
6759 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->begin
,
6760 "Location list begin address (%s)",
6761 list_head
->ll_symbol
);
6762 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->end
,
6763 "Location list end address (%s)",
6764 list_head
->ll_symbol
);
6766 size
= size_of_locs (curr
->expr
);
6768 /* Output the block length for this list of location operations. */
6769 gcc_assert (size
<= 0xffff);
6770 dw2_asm_output_data (2, size
, "%s", "Location expression size");
6772 output_loc_sequence (curr
->expr
);
6775 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0,
6776 "Location list terminator begin (%s)",
6777 list_head
->ll_symbol
);
6778 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0,
6779 "Location list terminator end (%s)",
6780 list_head
->ll_symbol
);
6783 /* Output the DIE and its attributes. Called recursively to generate
6784 the definitions of each child DIE. */
6787 output_die (dw_die_ref die
)
6793 /* If someone in another CU might refer to us, set up a symbol for
6794 them to point to. */
6795 if (die
->die_symbol
)
6796 output_die_symbol (die
);
6798 dw2_asm_output_data_uleb128 (die
->die_abbrev
, "(DIE (0x%lx) %s)",
6799 die
->die_offset
, dwarf_tag_name (die
->die_tag
));
6801 for (a
= die
->die_attr
; a
!= NULL
; a
= a
->dw_attr_next
)
6803 const char *name
= dwarf_attr_name (a
->dw_attr
);
6805 switch (AT_class (a
))
6807 case dw_val_class_addr
:
6808 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, AT_addr (a
), "%s", name
);
6811 case dw_val_class_offset
:
6812 dw2_asm_output_data (DWARF_OFFSET_SIZE
, a
->dw_attr_val
.v
.val_offset
,
6816 case dw_val_class_range_list
:
6818 char *p
= strchr (ranges_section_label
, '\0');
6820 sprintf (p
, "+" HOST_WIDE_INT_PRINT_HEX
,
6821 a
->dw_attr_val
.v
.val_offset
);
6822 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, ranges_section_label
,
6828 case dw_val_class_loc
:
6829 size
= size_of_locs (AT_loc (a
));
6831 /* Output the block length for this list of location operations. */
6832 dw2_asm_output_data (constant_size (size
), size
, "%s", name
);
6834 output_loc_sequence (AT_loc (a
));
6837 case dw_val_class_const
:
6838 /* ??? It would be slightly more efficient to use a scheme like is
6839 used for unsigned constants below, but gdb 4.x does not sign
6840 extend. Gdb 5.x does sign extend. */
6841 dw2_asm_output_data_sleb128 (AT_int (a
), "%s", name
);
6844 case dw_val_class_unsigned_const
:
6845 dw2_asm_output_data (constant_size (AT_unsigned (a
)),
6846 AT_unsigned (a
), "%s", name
);
6849 case dw_val_class_long_long
:
6851 unsigned HOST_WIDE_INT first
, second
;
6853 dw2_asm_output_data (1,
6854 2 * HOST_BITS_PER_LONG
/ HOST_BITS_PER_CHAR
,
6857 if (WORDS_BIG_ENDIAN
)
6859 first
= a
->dw_attr_val
.v
.val_long_long
.hi
;
6860 second
= a
->dw_attr_val
.v
.val_long_long
.low
;
6864 first
= a
->dw_attr_val
.v
.val_long_long
.low
;
6865 second
= a
->dw_attr_val
.v
.val_long_long
.hi
;
6868 dw2_asm_output_data (HOST_BITS_PER_LONG
/ HOST_BITS_PER_CHAR
,
6869 first
, "long long constant");
6870 dw2_asm_output_data (HOST_BITS_PER_LONG
/ HOST_BITS_PER_CHAR
,
6875 case dw_val_class_vec
:
6877 unsigned int elt_size
= a
->dw_attr_val
.v
.val_vec
.elt_size
;
6878 unsigned int len
= a
->dw_attr_val
.v
.val_vec
.length
;
6882 dw2_asm_output_data (1, len
* elt_size
, "%s", name
);
6883 if (elt_size
> sizeof (HOST_WIDE_INT
))
6888 for (i
= 0, p
= a
->dw_attr_val
.v
.val_vec
.array
;
6891 dw2_asm_output_data (elt_size
, extract_int (p
, elt_size
),
6892 "fp or vector constant word %u", i
);
6896 case dw_val_class_flag
:
6897 dw2_asm_output_data (1, AT_flag (a
), "%s", name
);
6900 case dw_val_class_loc_list
:
6902 char *sym
= AT_loc_list (a
)->ll_symbol
;
6905 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, sym
, "%s", name
);
6909 case dw_val_class_die_ref
:
6910 if (AT_ref_external (a
))
6912 char *sym
= AT_ref (a
)->die_symbol
;
6915 dw2_asm_output_offset (DWARF2_ADDR_SIZE
, sym
, "%s", name
);
6919 gcc_assert (AT_ref (a
)->die_offset
);
6920 dw2_asm_output_data (DWARF_OFFSET_SIZE
, AT_ref (a
)->die_offset
,
6925 case dw_val_class_fde_ref
:
6929 ASM_GENERATE_INTERNAL_LABEL (l1
, FDE_LABEL
,
6930 a
->dw_attr_val
.v
.val_fde_index
* 2);
6931 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, l1
, "%s", name
);
6935 case dw_val_class_lbl_id
:
6936 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, AT_lbl (a
), "%s", name
);
6939 case dw_val_class_lbl_offset
:
6940 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, AT_lbl (a
), "%s", name
);
6943 case dw_val_class_str
:
6944 if (AT_string_form (a
) == DW_FORM_strp
)
6945 dw2_asm_output_offset (DWARF_OFFSET_SIZE
,
6946 a
->dw_attr_val
.v
.val_str
->label
,
6947 "%s: \"%s\"", name
, AT_string (a
));
6949 dw2_asm_output_nstring (AT_string (a
), -1, "%s", name
);
6957 for (c
= die
->die_child
; c
!= NULL
; c
= c
->die_sib
)
6960 /* Add null byte to terminate sibling list. */
6961 if (die
->die_child
!= NULL
)
6962 dw2_asm_output_data (1, 0, "end of children of DIE 0x%lx",
6966 /* Output the compilation unit that appears at the beginning of the
6967 .debug_info section, and precedes the DIE descriptions. */
6970 output_compilation_unit_header (void)
6972 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
6973 dw2_asm_output_data (4, 0xffffffff,
6974 "Initial length escape value indicating 64-bit DWARF extension");
6975 dw2_asm_output_data (DWARF_OFFSET_SIZE
,
6976 next_die_offset
- DWARF_INITIAL_LENGTH_SIZE
,
6977 "Length of Compilation Unit Info");
6978 dw2_asm_output_data (2, DWARF_VERSION
, "DWARF version number");
6979 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, abbrev_section_label
,
6980 "Offset Into Abbrev. Section");
6981 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Pointer Size (in bytes)");
6984 /* Output the compilation unit DIE and its children. */
6987 output_comp_unit (dw_die_ref die
, int output_if_empty
)
6989 const char *secname
;
6992 /* Unless we are outputting main CU, we may throw away empty ones. */
6993 if (!output_if_empty
&& die
->die_child
== NULL
)
6996 /* Even if there are no children of this DIE, we must output the information
6997 about the compilation unit. Otherwise, on an empty translation unit, we
6998 will generate a present, but empty, .debug_info section. IRIX 6.5 `nm'
6999 will then complain when examining the file. First mark all the DIEs in
7000 this CU so we know which get local refs. */
7003 build_abbrev_table (die
);
7005 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
7006 next_die_offset
= DWARF_COMPILE_UNIT_HEADER_SIZE
;
7007 calc_die_sizes (die
);
7009 oldsym
= die
->die_symbol
;
7012 tmp
= alloca (strlen (oldsym
) + 24);
7014 sprintf (tmp
, ".gnu.linkonce.wi.%s", oldsym
);
7016 die
->die_symbol
= NULL
;
7019 secname
= (const char *) DEBUG_INFO_SECTION
;
7021 /* Output debugging information. */
7022 named_section_flags (secname
, SECTION_DEBUG
);
7023 output_compilation_unit_header ();
7026 /* Leave the marks on the main CU, so we can check them in
7031 die
->die_symbol
= oldsym
;
7035 /* The DWARF2 pubname for a nested thingy looks like "A::f". The
7036 output of lang_hooks.decl_printable_name for C++ looks like
7037 "A::f(int)". Let's drop the argument list, and maybe the scope. */
7040 dwarf2_name (tree decl
, int scope
)
7042 return lang_hooks
.decl_printable_name (decl
, scope
? 1 : 0);
7045 /* Add a new entry to .debug_pubnames if appropriate. */
7048 add_pubname (tree decl
, dw_die_ref die
)
7052 if (! TREE_PUBLIC (decl
))
7055 if (pubname_table_in_use
== pubname_table_allocated
)
7057 pubname_table_allocated
+= PUBNAME_TABLE_INCREMENT
;
7059 = ggc_realloc (pubname_table
,
7060 (pubname_table_allocated
* sizeof (pubname_entry
)));
7061 memset (pubname_table
+ pubname_table_in_use
, 0,
7062 PUBNAME_TABLE_INCREMENT
* sizeof (pubname_entry
));
7065 p
= &pubname_table
[pubname_table_in_use
++];
7067 p
->name
= xstrdup (dwarf2_name (decl
, 1));
7070 /* Output the public names table used to speed up access to externally
7071 visible names. For now, only generate entries for externally
7072 visible procedures. */
7075 output_pubnames (void)
7078 unsigned long pubnames_length
= size_of_pubnames ();
7080 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
7081 dw2_asm_output_data (4, 0xffffffff,
7082 "Initial length escape value indicating 64-bit DWARF extension");
7083 dw2_asm_output_data (DWARF_OFFSET_SIZE
, pubnames_length
,
7084 "Length of Public Names Info");
7085 dw2_asm_output_data (2, DWARF_VERSION
, "DWARF Version");
7086 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_info_section_label
,
7087 "Offset of Compilation Unit Info");
7088 dw2_asm_output_data (DWARF_OFFSET_SIZE
, next_die_offset
,
7089 "Compilation Unit Length");
7091 for (i
= 0; i
< pubname_table_in_use
; i
++)
7093 pubname_ref pub
= &pubname_table
[i
];
7095 /* We shouldn't see pubnames for DIEs outside of the main CU. */
7096 gcc_assert (pub
->die
->die_mark
);
7098 dw2_asm_output_data (DWARF_OFFSET_SIZE
, pub
->die
->die_offset
,
7101 dw2_asm_output_nstring (pub
->name
, -1, "external name");
7104 dw2_asm_output_data (DWARF_OFFSET_SIZE
, 0, NULL
);
7107 /* Add a new entry to .debug_aranges if appropriate. */
7110 add_arange (tree decl
, dw_die_ref die
)
7112 if (! DECL_SECTION_NAME (decl
))
7115 if (arange_table_in_use
== arange_table_allocated
)
7117 arange_table_allocated
+= ARANGE_TABLE_INCREMENT
;
7118 arange_table
= ggc_realloc (arange_table
,
7119 (arange_table_allocated
7120 * sizeof (dw_die_ref
)));
7121 memset (arange_table
+ arange_table_in_use
, 0,
7122 ARANGE_TABLE_INCREMENT
* sizeof (dw_die_ref
));
7125 arange_table
[arange_table_in_use
++] = die
;
7128 /* Output the information that goes into the .debug_aranges table.
7129 Namely, define the beginning and ending address range of the
7130 text section generated for this compilation unit. */
7133 output_aranges (void)
7136 unsigned long aranges_length
= size_of_aranges ();
7138 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
7139 dw2_asm_output_data (4, 0xffffffff,
7140 "Initial length escape value indicating 64-bit DWARF extension");
7141 dw2_asm_output_data (DWARF_OFFSET_SIZE
, aranges_length
,
7142 "Length of Address Ranges Info");
7143 dw2_asm_output_data (2, DWARF_VERSION
, "DWARF Version");
7144 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_info_section_label
,
7145 "Offset of Compilation Unit Info");
7146 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Size of Address");
7147 dw2_asm_output_data (1, 0, "Size of Segment Descriptor");
7149 /* We need to align to twice the pointer size here. */
7150 if (DWARF_ARANGES_PAD_SIZE
)
7152 /* Pad using a 2 byte words so that padding is correct for any
7154 dw2_asm_output_data (2, 0, "Pad to %d byte boundary",
7155 2 * DWARF2_ADDR_SIZE
);
7156 for (i
= 2; i
< (unsigned) DWARF_ARANGES_PAD_SIZE
; i
+= 2)
7157 dw2_asm_output_data (2, 0, NULL
);
7160 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, text_section_label
, "Address");
7161 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, text_end_label
,
7162 text_section_label
, "Length");
7164 for (i
= 0; i
< arange_table_in_use
; i
++)
7166 dw_die_ref die
= arange_table
[i
];
7168 /* We shouldn't see aranges for DIEs outside of the main CU. */
7169 gcc_assert (die
->die_mark
);
7171 if (die
->die_tag
== DW_TAG_subprogram
)
7173 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, get_AT_low_pc (die
),
7175 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, get_AT_hi_pc (die
),
7176 get_AT_low_pc (die
), "Length");
7180 /* A static variable; extract the symbol from DW_AT_location.
7181 Note that this code isn't currently hit, as we only emit
7182 aranges for functions (jason 9/23/99). */
7183 dw_attr_ref a
= get_AT (die
, DW_AT_location
);
7184 dw_loc_descr_ref loc
;
7186 gcc_assert (a
&& AT_class (a
) == dw_val_class_loc
);
7189 gcc_assert (loc
->dw_loc_opc
== DW_OP_addr
);
7191 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
,
7192 loc
->dw_loc_oprnd1
.v
.val_addr
, "Address");
7193 dw2_asm_output_data (DWARF2_ADDR_SIZE
,
7194 get_AT_unsigned (die
, DW_AT_byte_size
),
7199 /* Output the terminator words. */
7200 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
7201 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
7204 /* Add a new entry to .debug_ranges. Return the offset at which it
7208 add_ranges (tree block
)
7210 unsigned int in_use
= ranges_table_in_use
;
7212 if (in_use
== ranges_table_allocated
)
7214 ranges_table_allocated
+= RANGES_TABLE_INCREMENT
;
7216 = ggc_realloc (ranges_table
, (ranges_table_allocated
7217 * sizeof (struct dw_ranges_struct
)));
7218 memset (ranges_table
+ ranges_table_in_use
, 0,
7219 RANGES_TABLE_INCREMENT
* sizeof (struct dw_ranges_struct
));
7222 ranges_table
[in_use
].block_num
= (block
? BLOCK_NUMBER (block
) : 0);
7223 ranges_table_in_use
= in_use
+ 1;
7225 return in_use
* 2 * DWARF2_ADDR_SIZE
;
7229 output_ranges (void)
7232 static const char *const start_fmt
= "Offset 0x%x";
7233 const char *fmt
= start_fmt
;
7235 for (i
= 0; i
< ranges_table_in_use
; i
++)
7237 int block_num
= ranges_table
[i
].block_num
;
7241 char blabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
7242 char elabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
7244 ASM_GENERATE_INTERNAL_LABEL (blabel
, BLOCK_BEGIN_LABEL
, block_num
);
7245 ASM_GENERATE_INTERNAL_LABEL (elabel
, BLOCK_END_LABEL
, block_num
);
7247 /* If all code is in the text section, then the compilation
7248 unit base address defaults to DW_AT_low_pc, which is the
7249 base of the text section. */
7250 if (separate_line_info_table_in_use
== 0)
7252 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, blabel
,
7254 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
7255 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, elabel
,
7256 text_section_label
, NULL
);
7259 /* Otherwise, we add a DW_AT_entry_pc attribute to force the
7260 compilation unit base address to zero, which allows us to
7261 use absolute addresses, and not worry about whether the
7262 target supports cross-section arithmetic. */
7265 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
7266 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
7267 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, elabel
, NULL
);
7274 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
7275 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
7281 /* Data structure containing information about input files. */
7284 char *path
; /* Complete file name. */
7285 char *fname
; /* File name part. */
7286 int length
; /* Length of entire string. */
7287 int file_idx
; /* Index in input file table. */
7288 int dir_idx
; /* Index in directory table. */
7291 /* Data structure containing information about directories with source
7295 char *path
; /* Path including directory name. */
7296 int length
; /* Path length. */
7297 int prefix
; /* Index of directory entry which is a prefix. */
7298 int count
; /* Number of files in this directory. */
7299 int dir_idx
; /* Index of directory used as base. */
7300 int used
; /* Used in the end? */
7303 /* Callback function for file_info comparison. We sort by looking at
7304 the directories in the path. */
7307 file_info_cmp (const void *p1
, const void *p2
)
7309 const struct file_info
*s1
= p1
;
7310 const struct file_info
*s2
= p2
;
7314 /* Take care of file names without directories. We need to make sure that
7315 we return consistent values to qsort since some will get confused if
7316 we return the same value when identical operands are passed in opposite
7317 orders. So if neither has a directory, return 0 and otherwise return
7318 1 or -1 depending on which one has the directory. */
7319 if ((s1
->path
== s1
->fname
|| s2
->path
== s2
->fname
))
7320 return (s2
->path
== s2
->fname
) - (s1
->path
== s1
->fname
);
7322 cp1
= (unsigned char *) s1
->path
;
7323 cp2
= (unsigned char *) s2
->path
;
7329 /* Reached the end of the first path? If so, handle like above. */
7330 if ((cp1
== (unsigned char *) s1
->fname
)
7331 || (cp2
== (unsigned char *) s2
->fname
))
7332 return ((cp2
== (unsigned char *) s2
->fname
)
7333 - (cp1
== (unsigned char *) s1
->fname
));
7335 /* Character of current path component the same? */
7336 else if (*cp1
!= *cp2
)
7341 /* Output the directory table and the file name table. We try to minimize
7342 the total amount of memory needed. A heuristic is used to avoid large
7343 slowdowns with many input files. */
7346 output_file_names (void)
7348 struct file_info
*files
;
7349 struct dir_info
*dirs
;
7358 /* Handle the case where file_table is empty. */
7359 if (VARRAY_ACTIVE_SIZE (file_table
) <= 1)
7361 dw2_asm_output_data (1, 0, "End directory table");
7362 dw2_asm_output_data (1, 0, "End file name table");
7366 /* Allocate the various arrays we need. */
7367 files
= alloca (VARRAY_ACTIVE_SIZE (file_table
) * sizeof (struct file_info
));
7368 dirs
= alloca (VARRAY_ACTIVE_SIZE (file_table
) * sizeof (struct dir_info
));
7370 /* Sort the file names. */
7371 for (i
= 1; i
< VARRAY_ACTIVE_SIZE (file_table
); i
++)
7375 /* Skip all leading "./". */
7376 f
= VARRAY_CHAR_PTR (file_table
, i
);
7377 while (f
[0] == '.' && f
[1] == '/')
7380 /* Create a new array entry. */
7382 files
[i
].length
= strlen (f
);
7383 files
[i
].file_idx
= i
;
7385 /* Search for the file name part. */
7386 f
= strrchr (f
, '/');
7387 files
[i
].fname
= f
== NULL
? files
[i
].path
: f
+ 1;
7390 qsort (files
+ 1, VARRAY_ACTIVE_SIZE (file_table
) - 1,
7391 sizeof (files
[0]), file_info_cmp
);
7393 /* Find all the different directories used. */
7394 dirs
[0].path
= files
[1].path
;
7395 dirs
[0].length
= files
[1].fname
- files
[1].path
;
7396 dirs
[0].prefix
= -1;
7398 dirs
[0].dir_idx
= 0;
7400 files
[1].dir_idx
= 0;
7403 for (i
= 2; i
< VARRAY_ACTIVE_SIZE (file_table
); i
++)
7404 if (files
[i
].fname
- files
[i
].path
== dirs
[ndirs
- 1].length
7405 && memcmp (dirs
[ndirs
- 1].path
, files
[i
].path
,
7406 dirs
[ndirs
- 1].length
) == 0)
7408 /* Same directory as last entry. */
7409 files
[i
].dir_idx
= ndirs
- 1;
7410 ++dirs
[ndirs
- 1].count
;
7416 /* This is a new directory. */
7417 dirs
[ndirs
].path
= files
[i
].path
;
7418 dirs
[ndirs
].length
= files
[i
].fname
- files
[i
].path
;
7419 dirs
[ndirs
].count
= 1;
7420 dirs
[ndirs
].dir_idx
= ndirs
;
7421 dirs
[ndirs
].used
= 0;
7422 files
[i
].dir_idx
= ndirs
;
7424 /* Search for a prefix. */
7425 dirs
[ndirs
].prefix
= -1;
7426 for (j
= 0; j
< ndirs
; j
++)
7427 if (dirs
[j
].length
< dirs
[ndirs
].length
7428 && dirs
[j
].length
> 1
7429 && (dirs
[ndirs
].prefix
== -1
7430 || dirs
[j
].length
> dirs
[dirs
[ndirs
].prefix
].length
)
7431 && memcmp (dirs
[j
].path
, dirs
[ndirs
].path
, dirs
[j
].length
) == 0)
7432 dirs
[ndirs
].prefix
= j
;
7437 /* Now to the actual work. We have to find a subset of the directories which
7438 allow expressing the file name using references to the directory table
7439 with the least amount of characters. We do not do an exhaustive search
7440 where we would have to check out every combination of every single
7441 possible prefix. Instead we use a heuristic which provides nearly optimal
7442 results in most cases and never is much off. */
7443 saved
= alloca (ndirs
* sizeof (int));
7444 savehere
= alloca (ndirs
* sizeof (int));
7446 memset (saved
, '\0', ndirs
* sizeof (saved
[0]));
7447 for (i
= 0; i
< ndirs
; i
++)
7452 /* We can always save some space for the current directory. But this
7453 does not mean it will be enough to justify adding the directory. */
7454 savehere
[i
] = dirs
[i
].length
;
7455 total
= (savehere
[i
] - saved
[i
]) * dirs
[i
].count
;
7457 for (j
= i
+ 1; j
< ndirs
; j
++)
7460 if (saved
[j
] < dirs
[i
].length
)
7462 /* Determine whether the dirs[i] path is a prefix of the
7467 while (k
!= -1 && k
!= (int) i
)
7472 /* Yes it is. We can possibly safe some memory but
7473 writing the filenames in dirs[j] relative to
7475 savehere
[j
] = dirs
[i
].length
;
7476 total
+= (savehere
[j
] - saved
[j
]) * dirs
[j
].count
;
7481 /* Check whether we can safe enough to justify adding the dirs[i]
7483 if (total
> dirs
[i
].length
+ 1)
7485 /* It's worthwhile adding. */
7486 for (j
= i
; j
< ndirs
; j
++)
7487 if (savehere
[j
] > 0)
7489 /* Remember how much we saved for this directory so far. */
7490 saved
[j
] = savehere
[j
];
7492 /* Remember the prefix directory. */
7493 dirs
[j
].dir_idx
= i
;
7498 /* We have to emit them in the order they appear in the file_table array
7499 since the index is used in the debug info generation. To do this
7500 efficiently we generate a back-mapping of the indices first. */
7501 backmap
= alloca (VARRAY_ACTIVE_SIZE (file_table
) * sizeof (int));
7502 for (i
= 1; i
< VARRAY_ACTIVE_SIZE (file_table
); i
++)
7504 backmap
[files
[i
].file_idx
] = i
;
7506 /* Mark this directory as used. */
7507 dirs
[dirs
[files
[i
].dir_idx
].dir_idx
].used
= 1;
7510 /* That was it. We are ready to emit the information. First emit the
7511 directory name table. We have to make sure the first actually emitted
7512 directory name has index one; zero is reserved for the current working
7513 directory. Make sure we do not confuse these indices with the one for the
7514 constructed table (even though most of the time they are identical). */
7516 idx_offset
= dirs
[0].length
> 0 ? 1 : 0;
7517 for (i
= 1 - idx_offset
; i
< ndirs
; i
++)
7518 if (dirs
[i
].used
!= 0)
7520 dirs
[i
].used
= idx
++;
7521 dw2_asm_output_nstring (dirs
[i
].path
, dirs
[i
].length
- 1,
7522 "Directory Entry: 0x%x", dirs
[i
].used
);
7525 dw2_asm_output_data (1, 0, "End directory table");
7527 /* Correct the index for the current working directory entry if it
7529 if (idx_offset
== 0)
7532 /* Now write all the file names. */
7533 for (i
= 1; i
< VARRAY_ACTIVE_SIZE (file_table
); i
++)
7535 int file_idx
= backmap
[i
];
7536 int dir_idx
= dirs
[files
[file_idx
].dir_idx
].dir_idx
;
7538 dw2_asm_output_nstring (files
[file_idx
].path
+ dirs
[dir_idx
].length
, -1,
7539 "File Entry: 0x%lx", (unsigned long) i
);
7541 /* Include directory index. */
7542 dw2_asm_output_data_uleb128 (dirs
[dir_idx
].used
, NULL
);
7544 /* Modification time. */
7545 dw2_asm_output_data_uleb128 (0, NULL
);
7547 /* File length in bytes. */
7548 dw2_asm_output_data_uleb128 (0, NULL
);
7551 dw2_asm_output_data (1, 0, "End file name table");
7555 /* Output the source line number correspondence information. This
7556 information goes into the .debug_line section. */
7559 output_line_info (void)
7561 char l1
[20], l2
[20], p1
[20], p2
[20];
7562 char line_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
7563 char prev_line_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
7566 unsigned long lt_index
;
7567 unsigned long current_line
;
7570 unsigned long current_file
;
7571 unsigned long function
;
7573 ASM_GENERATE_INTERNAL_LABEL (l1
, LINE_NUMBER_BEGIN_LABEL
, 0);
7574 ASM_GENERATE_INTERNAL_LABEL (l2
, LINE_NUMBER_END_LABEL
, 0);
7575 ASM_GENERATE_INTERNAL_LABEL (p1
, LN_PROLOG_AS_LABEL
, 0);
7576 ASM_GENERATE_INTERNAL_LABEL (p2
, LN_PROLOG_END_LABEL
, 0);
7578 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
7579 dw2_asm_output_data (4, 0xffffffff,
7580 "Initial length escape value indicating 64-bit DWARF extension");
7581 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, l2
, l1
,
7582 "Length of Source Line Info");
7583 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
7585 dw2_asm_output_data (2, DWARF_VERSION
, "DWARF Version");
7586 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, p2
, p1
, "Prolog Length");
7587 ASM_OUTPUT_LABEL (asm_out_file
, p1
);
7589 /* Define the architecture-dependent minimum instruction length (in
7590 bytes). In this implementation of DWARF, this field is used for
7591 information purposes only. Since GCC generates assembly language,
7592 we have no a priori knowledge of how many instruction bytes are
7593 generated for each source line, and therefore can use only the
7594 DW_LNE_set_address and DW_LNS_fixed_advance_pc line information
7595 commands. Accordingly, we fix this as `1', which is "correct
7596 enough" for all architectures, and don't let the target override. */
7597 dw2_asm_output_data (1, 1,
7598 "Minimum Instruction Length");
7600 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START
,
7601 "Default is_stmt_start flag");
7602 dw2_asm_output_data (1, DWARF_LINE_BASE
,
7603 "Line Base Value (Special Opcodes)");
7604 dw2_asm_output_data (1, DWARF_LINE_RANGE
,
7605 "Line Range Value (Special Opcodes)");
7606 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE
,
7607 "Special Opcode Base");
7609 for (opc
= 1; opc
< DWARF_LINE_OPCODE_BASE
; opc
++)
7613 case DW_LNS_advance_pc
:
7614 case DW_LNS_advance_line
:
7615 case DW_LNS_set_file
:
7616 case DW_LNS_set_column
:
7617 case DW_LNS_fixed_advance_pc
:
7625 dw2_asm_output_data (1, n_op_args
, "opcode: 0x%x has %d args",
7629 /* Write out the information about the files we use. */
7630 output_file_names ();
7631 ASM_OUTPUT_LABEL (asm_out_file
, p2
);
7633 /* We used to set the address register to the first location in the text
7634 section here, but that didn't accomplish anything since we already
7635 have a line note for the opening brace of the first function. */
7637 /* Generate the line number to PC correspondence table, encoded as
7638 a series of state machine operations. */
7641 strcpy (prev_line_label
, text_section_label
);
7642 for (lt_index
= 1; lt_index
< line_info_table_in_use
; ++lt_index
)
7644 dw_line_info_ref line_info
= &line_info_table
[lt_index
];
7647 /* Disable this optimization for now; GDB wants to see two line notes
7648 at the beginning of a function so it can find the end of the
7651 /* Don't emit anything for redundant notes. Just updating the
7652 address doesn't accomplish anything, because we already assume
7653 that anything after the last address is this line. */
7654 if (line_info
->dw_line_num
== current_line
7655 && line_info
->dw_file_num
== current_file
)
7659 /* Emit debug info for the address of the current line.
7661 Unfortunately, we have little choice here currently, and must always
7662 use the most general form. GCC does not know the address delta
7663 itself, so we can't use DW_LNS_advance_pc. Many ports do have length
7664 attributes which will give an upper bound on the address range. We
7665 could perhaps use length attributes to determine when it is safe to
7666 use DW_LNS_fixed_advance_pc. */
7668 ASM_GENERATE_INTERNAL_LABEL (line_label
, LINE_CODE_LABEL
, lt_index
);
7671 /* This can handle deltas up to 0xffff. This takes 3 bytes. */
7672 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc
,
7673 "DW_LNS_fixed_advance_pc");
7674 dw2_asm_output_delta (2, line_label
, prev_line_label
, NULL
);
7678 /* This can handle any delta. This takes
7679 4+DWARF2_ADDR_SIZE bytes. */
7680 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
7681 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE
, NULL
);
7682 dw2_asm_output_data (1, DW_LNE_set_address
, NULL
);
7683 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, line_label
, NULL
);
7686 strcpy (prev_line_label
, line_label
);
7688 /* Emit debug info for the source file of the current line, if
7689 different from the previous line. */
7690 if (line_info
->dw_file_num
!= current_file
)
7692 current_file
= line_info
->dw_file_num
;
7693 dw2_asm_output_data (1, DW_LNS_set_file
, "DW_LNS_set_file");
7694 dw2_asm_output_data_uleb128 (current_file
, "(\"%s\")",
7695 VARRAY_CHAR_PTR (file_table
,
7699 /* Emit debug info for the current line number, choosing the encoding
7700 that uses the least amount of space. */
7701 if (line_info
->dw_line_num
!= current_line
)
7703 line_offset
= line_info
->dw_line_num
- current_line
;
7704 line_delta
= line_offset
- DWARF_LINE_BASE
;
7705 current_line
= line_info
->dw_line_num
;
7706 if (line_delta
>= 0 && line_delta
< (DWARF_LINE_RANGE
- 1))
7707 /* This can handle deltas from -10 to 234, using the current
7708 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE. This
7710 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE
+ line_delta
,
7711 "line %lu", current_line
);
7714 /* This can handle any delta. This takes at least 4 bytes,
7715 depending on the value being encoded. */
7716 dw2_asm_output_data (1, DW_LNS_advance_line
,
7717 "advance to line %lu", current_line
);
7718 dw2_asm_output_data_sleb128 (line_offset
, NULL
);
7719 dw2_asm_output_data (1, DW_LNS_copy
, "DW_LNS_copy");
7723 /* We still need to start a new row, so output a copy insn. */
7724 dw2_asm_output_data (1, DW_LNS_copy
, "DW_LNS_copy");
7727 /* Emit debug info for the address of the end of the function. */
7730 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc
,
7731 "DW_LNS_fixed_advance_pc");
7732 dw2_asm_output_delta (2, text_end_label
, prev_line_label
, NULL
);
7736 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
7737 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE
, NULL
);
7738 dw2_asm_output_data (1, DW_LNE_set_address
, NULL
);
7739 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, text_end_label
, NULL
);
7742 dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
7743 dw2_asm_output_data_uleb128 (1, NULL
);
7744 dw2_asm_output_data (1, DW_LNE_end_sequence
, NULL
);
7749 for (lt_index
= 0; lt_index
< separate_line_info_table_in_use
;)
7751 dw_separate_line_info_ref line_info
7752 = &separate_line_info_table
[lt_index
];
7755 /* Don't emit anything for redundant notes. */
7756 if (line_info
->dw_line_num
== current_line
7757 && line_info
->dw_file_num
== current_file
7758 && line_info
->function
== function
)
7762 /* Emit debug info for the address of the current line. If this is
7763 a new function, or the first line of a function, then we need
7764 to handle it differently. */
7765 ASM_GENERATE_INTERNAL_LABEL (line_label
, SEPARATE_LINE_CODE_LABEL
,
7767 if (function
!= line_info
->function
)
7769 function
= line_info
->function
;
7771 /* Set the address register to the first line in the function. */
7772 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
7773 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE
, NULL
);
7774 dw2_asm_output_data (1, DW_LNE_set_address
, NULL
);
7775 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, line_label
, NULL
);
7779 /* ??? See the DW_LNS_advance_pc comment above. */
7782 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc
,
7783 "DW_LNS_fixed_advance_pc");
7784 dw2_asm_output_delta (2, line_label
, prev_line_label
, NULL
);
7788 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
7789 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE
, NULL
);
7790 dw2_asm_output_data (1, DW_LNE_set_address
, NULL
);
7791 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, line_label
, NULL
);
7795 strcpy (prev_line_label
, line_label
);
7797 /* Emit debug info for the source file of the current line, if
7798 different from the previous line. */
7799 if (line_info
->dw_file_num
!= current_file
)
7801 current_file
= line_info
->dw_file_num
;
7802 dw2_asm_output_data (1, DW_LNS_set_file
, "DW_LNS_set_file");
7803 dw2_asm_output_data_uleb128 (current_file
, "(\"%s\")",
7804 VARRAY_CHAR_PTR (file_table
,
7808 /* Emit debug info for the current line number, choosing the encoding
7809 that uses the least amount of space. */
7810 if (line_info
->dw_line_num
!= current_line
)
7812 line_offset
= line_info
->dw_line_num
- current_line
;
7813 line_delta
= line_offset
- DWARF_LINE_BASE
;
7814 current_line
= line_info
->dw_line_num
;
7815 if (line_delta
>= 0 && line_delta
< (DWARF_LINE_RANGE
- 1))
7816 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE
+ line_delta
,
7817 "line %lu", current_line
);
7820 dw2_asm_output_data (1, DW_LNS_advance_line
,
7821 "advance to line %lu", current_line
);
7822 dw2_asm_output_data_sleb128 (line_offset
, NULL
);
7823 dw2_asm_output_data (1, DW_LNS_copy
, "DW_LNS_copy");
7827 dw2_asm_output_data (1, DW_LNS_copy
, "DW_LNS_copy");
7835 /* If we're done with a function, end its sequence. */
7836 if (lt_index
== separate_line_info_table_in_use
7837 || separate_line_info_table
[lt_index
].function
!= function
)
7842 /* Emit debug info for the address of the end of the function. */
7843 ASM_GENERATE_INTERNAL_LABEL (line_label
, FUNC_END_LABEL
, function
);
7846 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc
,
7847 "DW_LNS_fixed_advance_pc");
7848 dw2_asm_output_delta (2, line_label
, prev_line_label
, NULL
);
7852 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
7853 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE
, NULL
);
7854 dw2_asm_output_data (1, DW_LNE_set_address
, NULL
);
7855 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, line_label
, NULL
);
7858 /* Output the marker for the end of this sequence. */
7859 dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
7860 dw2_asm_output_data_uleb128 (1, NULL
);
7861 dw2_asm_output_data (1, DW_LNE_end_sequence
, NULL
);
7865 /* Output the marker for the end of the line number info. */
7866 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
7869 /* Given a pointer to a tree node for some base type, return a pointer to
7870 a DIE that describes the given type.
7872 This routine must only be called for GCC type nodes that correspond to
7873 Dwarf base (fundamental) types. */
7876 base_type_die (tree type
)
7878 dw_die_ref base_type_result
;
7879 const char *type_name
;
7880 enum dwarf_type encoding
;
7881 tree name
= TYPE_NAME (type
);
7883 if (TREE_CODE (type
) == ERROR_MARK
|| TREE_CODE (type
) == VOID_TYPE
)
7888 if (TREE_CODE (name
) == TYPE_DECL
)
7889 name
= DECL_NAME (name
);
7891 type_name
= IDENTIFIER_POINTER (name
);
7894 type_name
= "__unknown__";
7896 switch (TREE_CODE (type
))
7899 /* Carefully distinguish the C character types, without messing
7900 up if the language is not C. Note that we check only for the names
7901 that contain spaces; other names might occur by coincidence in other
7903 if (! (TYPE_PRECISION (type
) == CHAR_TYPE_SIZE
7904 && (type
== char_type_node
7905 || ! strcmp (type_name
, "signed char")
7906 || ! strcmp (type_name
, "unsigned char"))))
7908 if (TYPE_UNSIGNED (type
))
7909 encoding
= DW_ATE_unsigned
;
7911 encoding
= DW_ATE_signed
;
7914 /* else fall through. */
7917 /* GNU Pascal/Ada CHAR type. Not used in C. */
7918 if (TYPE_UNSIGNED (type
))
7919 encoding
= DW_ATE_unsigned_char
;
7921 encoding
= DW_ATE_signed_char
;
7925 encoding
= DW_ATE_float
;
7928 /* Dwarf2 doesn't know anything about complex ints, so use
7929 a user defined type for it. */
7931 if (TREE_CODE (TREE_TYPE (type
)) == REAL_TYPE
)
7932 encoding
= DW_ATE_complex_float
;
7934 encoding
= DW_ATE_lo_user
;
7938 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */
7939 encoding
= DW_ATE_boolean
;
7943 /* No other TREE_CODEs are Dwarf fundamental types. */
7947 base_type_result
= new_die (DW_TAG_base_type
, comp_unit_die
, type
);
7948 if (demangle_name_func
)
7949 type_name
= (*demangle_name_func
) (type_name
);
7951 add_AT_string (base_type_result
, DW_AT_name
, type_name
);
7952 add_AT_unsigned (base_type_result
, DW_AT_byte_size
,
7953 int_size_in_bytes (type
));
7954 add_AT_unsigned (base_type_result
, DW_AT_encoding
, encoding
);
7956 return base_type_result
;
7959 /* Given a pointer to an arbitrary ..._TYPE tree node, return a pointer to
7960 the Dwarf "root" type for the given input type. The Dwarf "root" type of
7961 a given type is generally the same as the given type, except that if the
7962 given type is a pointer or reference type, then the root type of the given
7963 type is the root type of the "basis" type for the pointer or reference
7964 type. (This definition of the "root" type is recursive.) Also, the root
7965 type of a `const' qualified type or a `volatile' qualified type is the
7966 root type of the given type without the qualifiers. */
7969 root_type (tree type
)
7971 if (TREE_CODE (type
) == ERROR_MARK
)
7972 return error_mark_node
;
7974 switch (TREE_CODE (type
))
7977 return error_mark_node
;
7980 case REFERENCE_TYPE
:
7981 return type_main_variant (root_type (TREE_TYPE (type
)));
7984 return type_main_variant (type
);
7988 /* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the
7989 given input type is a Dwarf "fundamental" type. Otherwise return null. */
7992 is_base_type (tree type
)
7994 switch (TREE_CODE (type
))
8009 case QUAL_UNION_TYPE
:
8014 case REFERENCE_TYPE
:
8028 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
8029 node, return the size in bits for the type if it is a constant, or else
8030 return the alignment for the type if the type's size is not constant, or
8031 else return BITS_PER_WORD if the type actually turns out to be an
8034 static inline unsigned HOST_WIDE_INT
8035 simple_type_size_in_bits (tree type
)
8037 if (TREE_CODE (type
) == ERROR_MARK
)
8038 return BITS_PER_WORD
;
8039 else if (TYPE_SIZE (type
) == NULL_TREE
)
8041 else if (host_integerp (TYPE_SIZE (type
), 1))
8042 return tree_low_cst (TYPE_SIZE (type
), 1);
8044 return TYPE_ALIGN (type
);
8047 /* Return true if the debug information for the given type should be
8048 emitted as a subrange type. */
8051 is_subrange_type (tree type
)
8053 tree subtype
= TREE_TYPE (type
);
8055 /* Subrange types are identified by the fact that they are integer
8056 types, and that they have a subtype which is either an integer type
8057 or an enumeral type. */
8059 if (TREE_CODE (type
) != INTEGER_TYPE
8060 || subtype
== NULL_TREE
)
8063 if (TREE_CODE (subtype
) != INTEGER_TYPE
8064 && TREE_CODE (subtype
) != ENUMERAL_TYPE
)
8067 if (TREE_CODE (type
) == TREE_CODE (subtype
)
8068 && int_size_in_bytes (type
) == int_size_in_bytes (subtype
)
8069 && TYPE_MIN_VALUE (type
) != NULL
8070 && TYPE_MIN_VALUE (subtype
) != NULL
8071 && tree_int_cst_equal (TYPE_MIN_VALUE (type
), TYPE_MIN_VALUE (subtype
))
8072 && TYPE_MAX_VALUE (type
) != NULL
8073 && TYPE_MAX_VALUE (subtype
) != NULL
8074 && tree_int_cst_equal (TYPE_MAX_VALUE (type
), TYPE_MAX_VALUE (subtype
)))
8076 /* The type and its subtype have the same representation. If in
8077 addition the two types also have the same name, then the given
8078 type is not a subrange type, but rather a plain base type. */
8079 /* FIXME: brobecker/2004-03-22:
8080 Sizetype INTEGER_CSTs nodes are canonicalized. It should
8081 therefore be sufficient to check the TYPE_SIZE node pointers
8082 rather than checking the actual size. Unfortunately, we have
8083 found some cases, such as in the Ada "integer" type, where
8084 this is not the case. Until this problem is solved, we need to
8085 keep checking the actual size. */
8086 tree type_name
= TYPE_NAME (type
);
8087 tree subtype_name
= TYPE_NAME (subtype
);
8089 if (type_name
!= NULL
&& TREE_CODE (type_name
) == TYPE_DECL
)
8090 type_name
= DECL_NAME (type_name
);
8092 if (subtype_name
!= NULL
&& TREE_CODE (subtype_name
) == TYPE_DECL
)
8093 subtype_name
= DECL_NAME (subtype_name
);
8095 if (type_name
== subtype_name
)
8102 /* Given a pointer to a tree node for a subrange type, return a pointer
8103 to a DIE that describes the given type. */
8106 subrange_type_die (tree type
, dw_die_ref context_die
)
8108 dw_die_ref subtype_die
;
8109 dw_die_ref subrange_die
;
8110 tree name
= TYPE_NAME (type
);
8111 const HOST_WIDE_INT size_in_bytes
= int_size_in_bytes (type
);
8112 tree subtype
= TREE_TYPE (type
);
8114 if (context_die
== NULL
)
8115 context_die
= comp_unit_die
;
8117 if (TREE_CODE (subtype
) == ENUMERAL_TYPE
)
8118 subtype_die
= gen_enumeration_type_die (subtype
, context_die
);
8120 subtype_die
= base_type_die (subtype
);
8122 subrange_die
= new_die (DW_TAG_subrange_type
, context_die
, type
);
8126 if (TREE_CODE (name
) == TYPE_DECL
)
8127 name
= DECL_NAME (name
);
8128 add_name_attribute (subrange_die
, IDENTIFIER_POINTER (name
));
8131 if (int_size_in_bytes (subtype
) != size_in_bytes
)
8133 /* The size of the subrange type and its base type do not match,
8134 so we need to generate a size attribute for the subrange type. */
8135 add_AT_unsigned (subrange_die
, DW_AT_byte_size
, size_in_bytes
);
8138 if (TYPE_MIN_VALUE (type
) != NULL
)
8139 add_bound_info (subrange_die
, DW_AT_lower_bound
,
8140 TYPE_MIN_VALUE (type
));
8141 if (TYPE_MAX_VALUE (type
) != NULL
)
8142 add_bound_info (subrange_die
, DW_AT_upper_bound
,
8143 TYPE_MAX_VALUE (type
));
8144 add_AT_die_ref (subrange_die
, DW_AT_type
, subtype_die
);
8146 return subrange_die
;
8149 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
8150 entry that chains various modifiers in front of the given type. */
8153 modified_type_die (tree type
, int is_const_type
, int is_volatile_type
,
8154 dw_die_ref context_die
)
8156 enum tree_code code
= TREE_CODE (type
);
8157 dw_die_ref mod_type_die
= NULL
;
8158 dw_die_ref sub_die
= NULL
;
8159 tree item_type
= NULL
;
8161 if (code
!= ERROR_MARK
)
8163 tree qualified_type
;
8165 /* See if we already have the appropriately qualified variant of
8168 = get_qualified_type (type
,
8169 ((is_const_type
? TYPE_QUAL_CONST
: 0)
8171 ? TYPE_QUAL_VOLATILE
: 0)));
8173 /* If we do, then we can just use its DIE, if it exists. */
8176 mod_type_die
= lookup_type_die (qualified_type
);
8178 return mod_type_die
;
8181 /* Handle C typedef types. */
8182 if (qualified_type
&& TYPE_NAME (qualified_type
)
8183 && TREE_CODE (TYPE_NAME (qualified_type
)) == TYPE_DECL
8184 && DECL_ORIGINAL_TYPE (TYPE_NAME (qualified_type
)))
8186 tree type_name
= TYPE_NAME (qualified_type
);
8187 tree dtype
= TREE_TYPE (type_name
);
8189 if (qualified_type
== dtype
)
8191 /* For a named type, use the typedef. */
8192 gen_type_die (qualified_type
, context_die
);
8193 mod_type_die
= lookup_type_die (qualified_type
);
8195 else if (is_const_type
< TYPE_READONLY (dtype
)
8196 || is_volatile_type
< TYPE_VOLATILE (dtype
))
8197 /* cv-unqualified version of named type. Just use the unnamed
8198 type to which it refers. */
8200 = modified_type_die (DECL_ORIGINAL_TYPE (type_name
),
8201 is_const_type
, is_volatile_type
,
8204 /* Else cv-qualified version of named type; fall through. */
8210 else if (is_const_type
)
8212 mod_type_die
= new_die (DW_TAG_const_type
, comp_unit_die
, type
);
8213 sub_die
= modified_type_die (type
, 0, is_volatile_type
, context_die
);
8215 else if (is_volatile_type
)
8217 mod_type_die
= new_die (DW_TAG_volatile_type
, comp_unit_die
, type
);
8218 sub_die
= modified_type_die (type
, 0, 0, context_die
);
8220 else if (code
== POINTER_TYPE
)
8222 mod_type_die
= new_die (DW_TAG_pointer_type
, comp_unit_die
, type
);
8223 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
,
8224 simple_type_size_in_bits (type
) / BITS_PER_UNIT
);
8226 add_AT_unsigned (mod_type_die
, DW_AT_address_class
, 0);
8228 item_type
= TREE_TYPE (type
);
8230 else if (code
== REFERENCE_TYPE
)
8232 mod_type_die
= new_die (DW_TAG_reference_type
, comp_unit_die
, type
);
8233 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
,
8234 simple_type_size_in_bits (type
) / BITS_PER_UNIT
);
8236 add_AT_unsigned (mod_type_die
, DW_AT_address_class
, 0);
8238 item_type
= TREE_TYPE (type
);
8240 else if (is_subrange_type (type
))
8241 mod_type_die
= subrange_type_die (type
, context_die
);
8242 else if (is_base_type (type
))
8243 mod_type_die
= base_type_die (type
);
8246 gen_type_die (type
, context_die
);
8248 /* We have to get the type_main_variant here (and pass that to the
8249 `lookup_type_die' routine) because the ..._TYPE node we have
8250 might simply be a *copy* of some original type node (where the
8251 copy was created to help us keep track of typedef names) and
8252 that copy might have a different TYPE_UID from the original
8254 if (TREE_CODE (type
) != VECTOR_TYPE
)
8255 mod_type_die
= lookup_type_die (type_main_variant (type
));
8257 /* Vectors have the debugging information in the type,
8258 not the main variant. */
8259 mod_type_die
= lookup_type_die (type
);
8260 gcc_assert (mod_type_die
);
8263 /* We want to equate the qualified type to the die below. */
8264 type
= qualified_type
;
8268 equate_type_number_to_die (type
, mod_type_die
);
8270 /* We must do this after the equate_type_number_to_die call, in case
8271 this is a recursive type. This ensures that the modified_type_die
8272 recursion will terminate even if the type is recursive. Recursive
8273 types are possible in Ada. */
8274 sub_die
= modified_type_die (item_type
,
8275 TYPE_READONLY (item_type
),
8276 TYPE_VOLATILE (item_type
),
8279 if (sub_die
!= NULL
)
8280 add_AT_die_ref (mod_type_die
, DW_AT_type
, sub_die
);
8282 return mod_type_die
;
8285 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
8286 an enumerated type. */
8289 type_is_enum (tree type
)
8291 return TREE_CODE (type
) == ENUMERAL_TYPE
;
8294 /* Return the DBX register number described by a given RTL node. */
8297 dbx_reg_number (rtx rtl
)
8299 unsigned regno
= REGNO (rtl
);
8301 gcc_assert (regno
< FIRST_PSEUDO_REGISTER
);
8303 return DBX_REGISTER_NUMBER (regno
);
8306 /* Return a location descriptor that designates a machine register or
8307 zero if there is none. */
8309 static dw_loc_descr_ref
8310 reg_loc_descriptor (rtx rtl
)
8315 if (REGNO (rtl
) >= FIRST_PSEUDO_REGISTER
)
8318 reg
= dbx_reg_number (rtl
);
8319 regs
= targetm
.dwarf_register_span (rtl
);
8321 if (hard_regno_nregs
[REGNO (rtl
)][GET_MODE (rtl
)] > 1
8323 return multiple_reg_loc_descriptor (rtl
, regs
);
8325 return one_reg_loc_descriptor (reg
);
8328 /* Return a location descriptor that designates a machine register for
8329 a given hard register number. */
8331 static dw_loc_descr_ref
8332 one_reg_loc_descriptor (unsigned int regno
)
8335 return new_loc_descr (DW_OP_reg0
+ regno
, 0, 0);
8337 return new_loc_descr (DW_OP_regx
, regno
, 0);
8340 /* Given an RTL of a register, return a location descriptor that
8341 designates a value that spans more than one register. */
8343 static dw_loc_descr_ref
8344 multiple_reg_loc_descriptor (rtx rtl
, rtx regs
)
8348 dw_loc_descr_ref loc_result
= NULL
;
8350 reg
= dbx_reg_number (rtl
);
8351 nregs
= hard_regno_nregs
[REGNO (rtl
)][GET_MODE (rtl
)];
8353 /* Simple, contiguous registers. */
8354 if (regs
== NULL_RTX
)
8356 size
= GET_MODE_SIZE (GET_MODE (rtl
)) / nregs
;
8363 t
= one_reg_loc_descriptor (reg
);
8364 add_loc_descr (&loc_result
, t
);
8365 add_loc_descr (&loc_result
, new_loc_descr (DW_OP_piece
, size
, 0));
8371 /* Now onto stupid register sets in non contiguous locations. */
8373 gcc_assert (GET_CODE (regs
) == PARALLEL
);
8375 size
= GET_MODE_SIZE (GET_MODE (XVECEXP (regs
, 0, 0)));
8378 for (i
= 0; i
< XVECLEN (regs
, 0); ++i
)
8382 t
= one_reg_loc_descriptor (REGNO (XVECEXP (regs
, 0, i
)));
8383 add_loc_descr (&loc_result
, t
);
8384 size
= GET_MODE_SIZE (GET_MODE (XVECEXP (regs
, 0, 0)));
8385 add_loc_descr (&loc_result
, new_loc_descr (DW_OP_piece
, size
, 0));
8390 /* Return a location descriptor that designates a constant. */
8392 static dw_loc_descr_ref
8393 int_loc_descriptor (HOST_WIDE_INT i
)
8395 enum dwarf_location_atom op
;
8397 /* Pick the smallest representation of a constant, rather than just
8398 defaulting to the LEB encoding. */
8402 op
= DW_OP_lit0
+ i
;
8405 else if (i
<= 0xffff)
8407 else if (HOST_BITS_PER_WIDE_INT
== 32
8417 else if (i
>= -0x8000)
8419 else if (HOST_BITS_PER_WIDE_INT
== 32
8420 || i
>= -0x80000000)
8426 return new_loc_descr (op
, i
, 0);
8429 /* Return a location descriptor that designates a base+offset location. */
8431 static dw_loc_descr_ref
8432 based_loc_descr (unsigned int reg
, HOST_WIDE_INT offset
, bool can_use_fbreg
)
8434 dw_loc_descr_ref loc_result
;
8435 /* For the "frame base", we use the frame pointer or stack pointer
8436 registers, since the RTL for local variables is relative to one of
8438 unsigned fp_reg
= DBX_REGISTER_NUMBER (frame_pointer_needed
8439 ? HARD_FRAME_POINTER_REGNUM
8440 : STACK_POINTER_REGNUM
);
8442 if (reg
== fp_reg
&& can_use_fbreg
)
8443 loc_result
= new_loc_descr (DW_OP_fbreg
, offset
, 0);
8445 loc_result
= new_loc_descr (DW_OP_breg0
+ reg
, offset
, 0);
8447 loc_result
= new_loc_descr (DW_OP_bregx
, reg
, offset
);
8452 /* Return true if this RTL expression describes a base+offset calculation. */
8455 is_based_loc (rtx rtl
)
8457 return (GET_CODE (rtl
) == PLUS
8458 && ((REG_P (XEXP (rtl
, 0))
8459 && REGNO (XEXP (rtl
, 0)) < FIRST_PSEUDO_REGISTER
8460 && GET_CODE (XEXP (rtl
, 1)) == CONST_INT
)));
8463 /* The following routine converts the RTL for a variable or parameter
8464 (resident in memory) into an equivalent Dwarf representation of a
8465 mechanism for getting the address of that same variable onto the top of a
8466 hypothetical "address evaluation" stack.
8468 When creating memory location descriptors, we are effectively transforming
8469 the RTL for a memory-resident object into its Dwarf postfix expression
8470 equivalent. This routine recursively descends an RTL tree, turning
8471 it into Dwarf postfix code as it goes.
8473 MODE is the mode of the memory reference, needed to handle some
8474 autoincrement addressing modes.
8476 CAN_USE_FBREG is a flag whether we can use DW_AT_frame_base in the location
8477 list for RTL. We can't use it when we are emitting location list for
8478 virtual variable frame_base_decl (i.e. a location list for DW_AT_frame_base)
8479 which describes how frame base changes when !frame_pointer_needed.
8481 Return 0 if we can't represent the location. */
8483 static dw_loc_descr_ref
8484 mem_loc_descriptor (rtx rtl
, enum machine_mode mode
, bool can_use_fbreg
)
8486 dw_loc_descr_ref mem_loc_result
= NULL
;
8487 enum dwarf_location_atom op
;
8489 /* Note that for a dynamically sized array, the location we will generate a
8490 description of here will be the lowest numbered location which is
8491 actually within the array. That's *not* necessarily the same as the
8492 zeroth element of the array. */
8494 rtl
= targetm
.delegitimize_address (rtl
);
8496 switch (GET_CODE (rtl
))
8501 /* POST_INC and POST_DEC can be handled just like a SUBREG. So we
8502 just fall into the SUBREG code. */
8504 /* ... fall through ... */
8507 /* The case of a subreg may arise when we have a local (register)
8508 variable or a formal (register) parameter which doesn't quite fill
8509 up an entire register. For now, just assume that it is
8510 legitimate to make the Dwarf info refer to the whole register which
8511 contains the given subreg. */
8512 rtl
= SUBREG_REG (rtl
);
8514 /* ... fall through ... */
8517 /* Whenever a register number forms a part of the description of the
8518 method for calculating the (dynamic) address of a memory resident
8519 object, DWARF rules require the register number be referred to as
8520 a "base register". This distinction is not based in any way upon
8521 what category of register the hardware believes the given register
8522 belongs to. This is strictly DWARF terminology we're dealing with
8523 here. Note that in cases where the location of a memory-resident
8524 data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
8525 OP_CONST (0)) the actual DWARF location descriptor that we generate
8526 may just be OP_BASEREG (basereg). This may look deceptively like
8527 the object in question was allocated to a register (rather than in
8528 memory) so DWARF consumers need to be aware of the subtle
8529 distinction between OP_REG and OP_BASEREG. */
8530 if (REGNO (rtl
) < FIRST_PSEUDO_REGISTER
)
8531 mem_loc_result
= based_loc_descr (dbx_reg_number (rtl
), 0,
8536 mem_loc_result
= mem_loc_descriptor (XEXP (rtl
, 0), GET_MODE (rtl
),
8538 if (mem_loc_result
!= 0)
8539 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_deref
, 0, 0));
8543 rtl
= XEXP (rtl
, 1);
8545 /* ... fall through ... */
8548 /* Some ports can transform a symbol ref into a label ref, because
8549 the symbol ref is too far away and has to be dumped into a constant
8553 /* Alternatively, the symbol in the constant pool might be referenced
8554 by a different symbol. */
8555 if (GET_CODE (rtl
) == SYMBOL_REF
&& CONSTANT_POOL_ADDRESS_P (rtl
))
8558 rtx tmp
= get_pool_constant_mark (rtl
, &marked
);
8560 if (GET_CODE (tmp
) == SYMBOL_REF
)
8563 if (CONSTANT_POOL_ADDRESS_P (tmp
))
8564 get_pool_constant_mark (tmp
, &marked
);
8569 /* If all references to this pool constant were optimized away,
8570 it was not output and thus we can't represent it.
8571 FIXME: might try to use DW_OP_const_value here, though
8572 DW_OP_piece complicates it. */
8577 mem_loc_result
= new_loc_descr (DW_OP_addr
, 0, 0);
8578 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_addr
;
8579 mem_loc_result
->dw_loc_oprnd1
.v
.val_addr
= rtl
;
8580 VARRAY_PUSH_RTX (used_rtx_varray
, rtl
);
8584 /* Extract the PLUS expression nested inside and fall into
8586 rtl
= XEXP (rtl
, 1);
8591 /* Turn these into a PLUS expression and fall into the PLUS code
8593 rtl
= gen_rtx_PLUS (word_mode
, XEXP (rtl
, 0),
8594 GEN_INT (GET_CODE (rtl
) == PRE_INC
8595 ? GET_MODE_UNIT_SIZE (mode
)
8596 : -GET_MODE_UNIT_SIZE (mode
)));
8598 /* ... fall through ... */
8602 if (is_based_loc (rtl
))
8603 mem_loc_result
= based_loc_descr (dbx_reg_number (XEXP (rtl
, 0)),
8604 INTVAL (XEXP (rtl
, 1)),
8608 mem_loc_result
= mem_loc_descriptor (XEXP (rtl
, 0), mode
,
8610 if (mem_loc_result
== 0)
8613 if (GET_CODE (XEXP (rtl
, 1)) == CONST_INT
8614 && INTVAL (XEXP (rtl
, 1)) >= 0)
8615 add_loc_descr (&mem_loc_result
,
8616 new_loc_descr (DW_OP_plus_uconst
,
8617 INTVAL (XEXP (rtl
, 1)), 0));
8620 add_loc_descr (&mem_loc_result
,
8621 mem_loc_descriptor (XEXP (rtl
, 1), mode
,
8623 add_loc_descr (&mem_loc_result
,
8624 new_loc_descr (DW_OP_plus
, 0, 0));
8629 /* If a pseudo-reg is optimized away, it is possible for it to
8630 be replaced with a MEM containing a multiply or shift. */
8649 dw_loc_descr_ref op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
,
8651 dw_loc_descr_ref op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
,
8654 if (op0
== 0 || op1
== 0)
8657 mem_loc_result
= op0
;
8658 add_loc_descr (&mem_loc_result
, op1
);
8659 add_loc_descr (&mem_loc_result
, new_loc_descr (op
, 0, 0));
8664 mem_loc_result
= int_loc_descriptor (INTVAL (rtl
));
8671 return mem_loc_result
;
8674 /* Return a descriptor that describes the concatenation of two locations.
8675 This is typically a complex variable. */
8677 static dw_loc_descr_ref
8678 concat_loc_descriptor (rtx x0
, rtx x1
)
8680 dw_loc_descr_ref cc_loc_result
= NULL
;
8681 dw_loc_descr_ref x0_ref
= loc_descriptor (x0
, true);
8682 dw_loc_descr_ref x1_ref
= loc_descriptor (x1
, true);
8684 if (x0_ref
== 0 || x1_ref
== 0)
8687 cc_loc_result
= x0_ref
;
8688 add_loc_descr (&cc_loc_result
,
8689 new_loc_descr (DW_OP_piece
,
8690 GET_MODE_SIZE (GET_MODE (x0
)), 0));
8692 add_loc_descr (&cc_loc_result
, x1_ref
);
8693 add_loc_descr (&cc_loc_result
,
8694 new_loc_descr (DW_OP_piece
,
8695 GET_MODE_SIZE (GET_MODE (x1
)), 0));
8697 return cc_loc_result
;
8700 /* Output a proper Dwarf location descriptor for a variable or parameter
8701 which is either allocated in a register or in a memory location. For a
8702 register, we just generate an OP_REG and the register number. For a
8703 memory location we provide a Dwarf postfix expression describing how to
8704 generate the (dynamic) address of the object onto the address stack.
8706 If we don't know how to describe it, return 0. */
8708 static dw_loc_descr_ref
8709 loc_descriptor (rtx rtl
, bool can_use_fbreg
)
8711 dw_loc_descr_ref loc_result
= NULL
;
8713 switch (GET_CODE (rtl
))
8716 /* The case of a subreg may arise when we have a local (register)
8717 variable or a formal (register) parameter which doesn't quite fill
8718 up an entire register. For now, just assume that it is
8719 legitimate to make the Dwarf info refer to the whole register which
8720 contains the given subreg. */
8721 rtl
= SUBREG_REG (rtl
);
8723 /* ... fall through ... */
8726 loc_result
= reg_loc_descriptor (rtl
);
8730 loc_result
= mem_loc_descriptor (XEXP (rtl
, 0), GET_MODE (rtl
),
8735 loc_result
= concat_loc_descriptor (XEXP (rtl
, 0), XEXP (rtl
, 1));
8740 if (GET_CODE (XEXP (rtl
, 1)) != PARALLEL
)
8742 loc_result
= loc_descriptor (XEXP (XEXP (rtl
, 1), 0), can_use_fbreg
);
8746 rtl
= XEXP (rtl
, 1);
8751 rtvec par_elems
= XVEC (rtl
, 0);
8752 int num_elem
= GET_NUM_ELEM (par_elems
);
8753 enum machine_mode mode
;
8756 /* Create the first one, so we have something to add to. */
8757 loc_result
= loc_descriptor (XEXP (RTVEC_ELT (par_elems
, 0), 0),
8759 mode
= GET_MODE (XEXP (RTVEC_ELT (par_elems
, 0), 0));
8760 add_loc_descr (&loc_result
,
8761 new_loc_descr (DW_OP_piece
, GET_MODE_SIZE (mode
), 0));
8762 for (i
= 1; i
< num_elem
; i
++)
8764 dw_loc_descr_ref temp
;
8766 temp
= loc_descriptor (XEXP (RTVEC_ELT (par_elems
, i
), 0),
8768 add_loc_descr (&loc_result
, temp
);
8769 mode
= GET_MODE (XEXP (RTVEC_ELT (par_elems
, i
), 0));
8770 add_loc_descr (&loc_result
,
8771 new_loc_descr (DW_OP_piece
,
8772 GET_MODE_SIZE (mode
), 0));
8784 /* Similar, but generate the descriptor from trees instead of rtl. This comes
8785 up particularly with variable length arrays. WANT_ADDRESS is 2 if this is
8786 a top-level invocation of loc_descriptor_from_tree; is 1 if this is not a
8787 top-level invocation, and we require the address of LOC; is 0 if we require
8788 the value of LOC. */
8790 static dw_loc_descr_ref
8791 loc_descriptor_from_tree_1 (tree loc
, int want_address
)
8793 dw_loc_descr_ref ret
, ret1
;
8794 int have_address
= 0;
8795 int unsignedp
= TYPE_UNSIGNED (TREE_TYPE (loc
));
8796 enum dwarf_location_atom op
;
8798 /* ??? Most of the time we do not take proper care for sign/zero
8799 extending the values properly. Hopefully this won't be a real
8802 switch (TREE_CODE (loc
))
8807 case PLACEHOLDER_EXPR
:
8808 /* This case involves extracting fields from an object to determine the
8809 position of other fields. We don't try to encode this here. The
8810 only user of this is Ada, which encodes the needed information using
8811 the names of types. */
8817 case PREINCREMENT_EXPR
:
8818 case PREDECREMENT_EXPR
:
8819 case POSTINCREMENT_EXPR
:
8820 case POSTDECREMENT_EXPR
:
8821 /* There are no opcodes for these operations. */
8825 /* If we already want an address, there's nothing we can do. */
8829 /* Otherwise, process the argument and look for the address. */
8830 return loc_descriptor_from_tree_1 (TREE_OPERAND (loc
, 0), 1);
8833 if (DECL_THREAD_LOCAL (loc
))
8837 #ifndef ASM_OUTPUT_DWARF_DTPREL
8838 /* If this is not defined, we have no way to emit the data. */
8842 /* The way DW_OP_GNU_push_tls_address is specified, we can only
8843 look up addresses of objects in the current module. */
8844 if (DECL_EXTERNAL (loc
))
8847 rtl
= rtl_for_decl_location (loc
);
8848 if (rtl
== NULL_RTX
)
8853 rtl
= XEXP (rtl
, 0);
8854 if (! CONSTANT_P (rtl
))
8857 ret
= new_loc_descr (INTERNAL_DW_OP_tls_addr
, 0, 0);
8858 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_addr
;
8859 ret
->dw_loc_oprnd1
.v
.val_addr
= rtl
;
8861 ret1
= new_loc_descr (DW_OP_GNU_push_tls_address
, 0, 0);
8862 add_loc_descr (&ret
, ret1
);
8870 if (DECL_VALUE_EXPR (loc
))
8871 return loc_descriptor_from_tree_1 (DECL_VALUE_EXPR (loc
), want_address
);
8876 rtx rtl
= rtl_for_decl_location (loc
);
8878 if (rtl
== NULL_RTX
)
8880 else if (GET_CODE (rtl
) == CONST_INT
)
8882 HOST_WIDE_INT val
= INTVAL (rtl
);
8883 if (TYPE_UNSIGNED (TREE_TYPE (loc
)))
8884 val
&= GET_MODE_MASK (DECL_MODE (loc
));
8885 ret
= int_loc_descriptor (val
);
8887 else if (GET_CODE (rtl
) == CONST_STRING
)
8889 else if (CONSTANT_P (rtl
))
8891 ret
= new_loc_descr (DW_OP_addr
, 0, 0);
8892 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_addr
;
8893 ret
->dw_loc_oprnd1
.v
.val_addr
= rtl
;
8897 enum machine_mode mode
;
8899 /* Certain constructs can only be represented at top-level. */
8900 if (want_address
== 2)
8901 return loc_descriptor (rtl
, true);
8903 mode
= GET_MODE (rtl
);
8906 rtl
= XEXP (rtl
, 0);
8909 ret
= mem_loc_descriptor (rtl
, mode
, true);
8915 ret
= loc_descriptor_from_tree_1 (TREE_OPERAND (loc
, 0), 0);
8920 return loc_descriptor_from_tree_1 (TREE_OPERAND (loc
, 1), want_address
);
8924 case NON_LVALUE_EXPR
:
8925 case VIEW_CONVERT_EXPR
:
8928 return loc_descriptor_from_tree_1 (TREE_OPERAND (loc
, 0), want_address
);
8933 case ARRAY_RANGE_REF
:
8936 HOST_WIDE_INT bitsize
, bitpos
, bytepos
;
8937 enum machine_mode mode
;
8940 obj
= get_inner_reference (loc
, &bitsize
, &bitpos
, &offset
, &mode
,
8941 &unsignedp
, &volatilep
);
8946 ret
= loc_descriptor_from_tree_1 (obj
, 1);
8948 || bitpos
% BITS_PER_UNIT
!= 0 || bitsize
% BITS_PER_UNIT
!= 0)
8951 if (offset
!= NULL_TREE
)
8953 /* Variable offset. */
8954 add_loc_descr (&ret
, loc_descriptor_from_tree_1 (offset
, 0));
8955 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus
, 0, 0));
8958 bytepos
= bitpos
/ BITS_PER_UNIT
;
8960 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus_uconst
, bytepos
, 0));
8961 else if (bytepos
< 0)
8963 add_loc_descr (&ret
, int_loc_descriptor (bytepos
));
8964 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus
, 0, 0));
8972 if (host_integerp (loc
, 0))
8973 ret
= int_loc_descriptor (tree_low_cst (loc
, 0));
8980 /* Get an RTL for this, if something has been emitted. */
8981 rtx rtl
= lookup_constant_def (loc
);
8982 enum machine_mode mode
;
8984 if (!rtl
|| !MEM_P (rtl
))
8986 mode
= GET_MODE (rtl
);
8987 rtl
= XEXP (rtl
, 0);
8988 ret
= mem_loc_descriptor (rtl
, mode
, true);
8993 case TRUTH_AND_EXPR
:
8994 case TRUTH_ANDIF_EXPR
:
8999 case TRUTH_XOR_EXPR
:
9005 case TRUTH_ORIF_EXPR
:
9010 case FLOOR_DIV_EXPR
:
9012 case ROUND_DIV_EXPR
:
9013 case TRUNC_DIV_EXPR
:
9021 case FLOOR_MOD_EXPR
:
9023 case ROUND_MOD_EXPR
:
9024 case TRUNC_MOD_EXPR
:
9037 op
= (unsignedp
? DW_OP_shr
: DW_OP_shra
);
9041 if (TREE_CODE (TREE_OPERAND (loc
, 1)) == INTEGER_CST
9042 && host_integerp (TREE_OPERAND (loc
, 1), 0))
9044 ret
= loc_descriptor_from_tree_1 (TREE_OPERAND (loc
, 0), 0);
9048 add_loc_descr (&ret
,
9049 new_loc_descr (DW_OP_plus_uconst
,
9050 tree_low_cst (TREE_OPERAND (loc
, 1),
9060 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc
, 0))))
9067 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc
, 0))))
9074 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc
, 0))))
9081 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc
, 0))))
9096 ret
= loc_descriptor_from_tree_1 (TREE_OPERAND (loc
, 0), 0);
9097 ret1
= loc_descriptor_from_tree_1 (TREE_OPERAND (loc
, 1), 0);
9098 if (ret
== 0 || ret1
== 0)
9101 add_loc_descr (&ret
, ret1
);
9102 add_loc_descr (&ret
, new_loc_descr (op
, 0, 0));
9105 case TRUTH_NOT_EXPR
:
9119 ret
= loc_descriptor_from_tree_1 (TREE_OPERAND (loc
, 0), 0);
9123 add_loc_descr (&ret
, new_loc_descr (op
, 0, 0));
9129 const enum tree_code code
=
9130 TREE_CODE (loc
) == MIN_EXPR
? GT_EXPR
: LT_EXPR
;
9132 loc
= build3 (COND_EXPR
, TREE_TYPE (loc
),
9133 build2 (code
, integer_type_node
,
9134 TREE_OPERAND (loc
, 0), TREE_OPERAND (loc
, 1)),
9135 TREE_OPERAND (loc
, 1), TREE_OPERAND (loc
, 0));
9138 /* ... fall through ... */
9142 dw_loc_descr_ref lhs
9143 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc
, 1), 0);
9144 dw_loc_descr_ref rhs
9145 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc
, 2), 0);
9146 dw_loc_descr_ref bra_node
, jump_node
, tmp
;
9148 ret
= loc_descriptor_from_tree_1 (TREE_OPERAND (loc
, 0), 0);
9149 if (ret
== 0 || lhs
== 0 || rhs
== 0)
9152 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
9153 add_loc_descr (&ret
, bra_node
);
9155 add_loc_descr (&ret
, rhs
);
9156 jump_node
= new_loc_descr (DW_OP_skip
, 0, 0);
9157 add_loc_descr (&ret
, jump_node
);
9159 add_loc_descr (&ret
, lhs
);
9160 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
9161 bra_node
->dw_loc_oprnd1
.v
.val_loc
= lhs
;
9163 /* ??? Need a node to point the skip at. Use a nop. */
9164 tmp
= new_loc_descr (DW_OP_nop
, 0, 0);
9165 add_loc_descr (&ret
, tmp
);
9166 jump_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
9167 jump_node
->dw_loc_oprnd1
.v
.val_loc
= tmp
;
9172 /* Leave front-end specific codes as simply unknown. This comes
9173 up, for instance, with the C STMT_EXPR. */
9174 if ((unsigned int) TREE_CODE (loc
)
9175 >= (unsigned int) LAST_AND_UNUSED_TREE_CODE
)
9178 #ifdef ENABLE_CHECKING
9179 /* Otherwise this is a generic code; we should just lists all of
9180 these explicitly. Aborting means we forgot one. */
9183 /* In a release build, we want to degrade gracefully: better to
9184 generate incomplete debugging information than to crash. */
9189 /* Show if we can't fill the request for an address. */
9190 if (want_address
&& !have_address
)
9193 /* If we've got an address and don't want one, dereference. */
9194 if (!want_address
&& have_address
)
9196 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (loc
));
9198 if (size
> DWARF2_ADDR_SIZE
|| size
== -1)
9200 else if (size
== DWARF2_ADDR_SIZE
)
9203 op
= DW_OP_deref_size
;
9205 add_loc_descr (&ret
, new_loc_descr (op
, size
, 0));
9211 static inline dw_loc_descr_ref
9212 loc_descriptor_from_tree (tree loc
)
9214 return loc_descriptor_from_tree_1 (loc
, 2);
9217 /* Given a value, round it up to the lowest multiple of `boundary'
9218 which is not less than the value itself. */
9220 static inline HOST_WIDE_INT
9221 ceiling (HOST_WIDE_INT value
, unsigned int boundary
)
9223 return (((value
+ boundary
- 1) / boundary
) * boundary
);
9226 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
9227 pointer to the declared type for the relevant field variable, or return
9228 `integer_type_node' if the given node turns out to be an
9232 field_type (tree decl
)
9236 if (TREE_CODE (decl
) == ERROR_MARK
)
9237 return integer_type_node
;
9239 type
= DECL_BIT_FIELD_TYPE (decl
);
9240 if (type
== NULL_TREE
)
9241 type
= TREE_TYPE (decl
);
9246 /* Given a pointer to a tree node, return the alignment in bits for
9247 it, or else return BITS_PER_WORD if the node actually turns out to
9248 be an ERROR_MARK node. */
9250 static inline unsigned
9251 simple_type_align_in_bits (tree type
)
9253 return (TREE_CODE (type
) != ERROR_MARK
) ? TYPE_ALIGN (type
) : BITS_PER_WORD
;
9256 static inline unsigned
9257 simple_decl_align_in_bits (tree decl
)
9259 return (TREE_CODE (decl
) != ERROR_MARK
) ? DECL_ALIGN (decl
) : BITS_PER_WORD
;
9262 /* Given a pointer to a FIELD_DECL, compute and return the byte offset of the
9263 lowest addressed byte of the "containing object" for the given FIELD_DECL,
9264 or return 0 if we are unable to determine what that offset is, either
9265 because the argument turns out to be a pointer to an ERROR_MARK node, or
9266 because the offset is actually variable. (We can't handle the latter case
9269 static HOST_WIDE_INT
9270 field_byte_offset (tree decl
)
9272 unsigned int type_align_in_bits
;
9273 unsigned int decl_align_in_bits
;
9274 unsigned HOST_WIDE_INT type_size_in_bits
;
9275 HOST_WIDE_INT object_offset_in_bits
;
9277 tree field_size_tree
;
9278 HOST_WIDE_INT bitpos_int
;
9279 HOST_WIDE_INT deepest_bitpos
;
9280 unsigned HOST_WIDE_INT field_size_in_bits
;
9282 if (TREE_CODE (decl
) == ERROR_MARK
)
9285 gcc_assert (TREE_CODE (decl
) == FIELD_DECL
);
9287 type
= field_type (decl
);
9288 field_size_tree
= DECL_SIZE (decl
);
9290 /* The size could be unspecified if there was an error, or for
9291 a flexible array member. */
9292 if (! field_size_tree
)
9293 field_size_tree
= bitsize_zero_node
;
9295 /* We cannot yet cope with fields whose positions are variable, so
9296 for now, when we see such things, we simply return 0. Someday, we may
9297 be able to handle such cases, but it will be damn difficult. */
9298 if (! host_integerp (bit_position (decl
), 0))
9301 bitpos_int
= int_bit_position (decl
);
9303 /* If we don't know the size of the field, pretend it's a full word. */
9304 if (host_integerp (field_size_tree
, 1))
9305 field_size_in_bits
= tree_low_cst (field_size_tree
, 1);
9307 field_size_in_bits
= BITS_PER_WORD
;
9309 type_size_in_bits
= simple_type_size_in_bits (type
);
9310 type_align_in_bits
= simple_type_align_in_bits (type
);
9311 decl_align_in_bits
= simple_decl_align_in_bits (decl
);
9313 /* The GCC front-end doesn't make any attempt to keep track of the starting
9314 bit offset (relative to the start of the containing structure type) of the
9315 hypothetical "containing object" for a bit-field. Thus, when computing
9316 the byte offset value for the start of the "containing object" of a
9317 bit-field, we must deduce this information on our own. This can be rather
9318 tricky to do in some cases. For example, handling the following structure
9319 type definition when compiling for an i386/i486 target (which only aligns
9320 long long's to 32-bit boundaries) can be very tricky:
9322 struct S { int field1; long long field2:31; };
9324 Fortunately, there is a simple rule-of-thumb which can be used in such
9325 cases. When compiling for an i386/i486, GCC will allocate 8 bytes for the
9326 structure shown above. It decides to do this based upon one simple rule
9327 for bit-field allocation. GCC allocates each "containing object" for each
9328 bit-field at the first (i.e. lowest addressed) legitimate alignment
9329 boundary (based upon the required minimum alignment for the declared type
9330 of the field) which it can possibly use, subject to the condition that
9331 there is still enough available space remaining in the containing object
9332 (when allocated at the selected point) to fully accommodate all of the
9333 bits of the bit-field itself.
9335 This simple rule makes it obvious why GCC allocates 8 bytes for each
9336 object of the structure type shown above. When looking for a place to
9337 allocate the "containing object" for `field2', the compiler simply tries
9338 to allocate a 64-bit "containing object" at each successive 32-bit
9339 boundary (starting at zero) until it finds a place to allocate that 64-
9340 bit field such that at least 31 contiguous (and previously unallocated)
9341 bits remain within that selected 64 bit field. (As it turns out, for the
9342 example above, the compiler finds it is OK to allocate the "containing
9343 object" 64-bit field at bit-offset zero within the structure type.)
9345 Here we attempt to work backwards from the limited set of facts we're
9346 given, and we try to deduce from those facts, where GCC must have believed
9347 that the containing object started (within the structure type). The value
9348 we deduce is then used (by the callers of this routine) to generate
9349 DW_AT_location and DW_AT_bit_offset attributes for fields (both bit-fields
9350 and, in the case of DW_AT_location, regular fields as well). */
9352 /* Figure out the bit-distance from the start of the structure to the
9353 "deepest" bit of the bit-field. */
9354 deepest_bitpos
= bitpos_int
+ field_size_in_bits
;
9356 /* This is the tricky part. Use some fancy footwork to deduce where the
9357 lowest addressed bit of the containing object must be. */
9358 object_offset_in_bits
= deepest_bitpos
- type_size_in_bits
;
9360 /* Round up to type_align by default. This works best for bitfields. */
9361 object_offset_in_bits
+= type_align_in_bits
- 1;
9362 object_offset_in_bits
/= type_align_in_bits
;
9363 object_offset_in_bits
*= type_align_in_bits
;
9365 if (object_offset_in_bits
> bitpos_int
)
9367 /* Sigh, the decl must be packed. */
9368 object_offset_in_bits
= deepest_bitpos
- type_size_in_bits
;
9370 /* Round up to decl_align instead. */
9371 object_offset_in_bits
+= decl_align_in_bits
- 1;
9372 object_offset_in_bits
/= decl_align_in_bits
;
9373 object_offset_in_bits
*= decl_align_in_bits
;
9376 return object_offset_in_bits
/ BITS_PER_UNIT
;
9379 /* The following routines define various Dwarf attributes and any data
9380 associated with them. */
9382 /* Add a location description attribute value to a DIE.
9384 This emits location attributes suitable for whole variables and
9385 whole parameters. Note that the location attributes for struct fields are
9386 generated by the routine `data_member_location_attribute' below. */
9389 add_AT_location_description (dw_die_ref die
, enum dwarf_attribute attr_kind
,
9390 dw_loc_descr_ref descr
)
9393 add_AT_loc (die
, attr_kind
, descr
);
9396 /* Attach the specialized form of location attribute used for data members of
9397 struct and union types. In the special case of a FIELD_DECL node which
9398 represents a bit-field, the "offset" part of this special location
9399 descriptor must indicate the distance in bytes from the lowest-addressed
9400 byte of the containing struct or union type to the lowest-addressed byte of
9401 the "containing object" for the bit-field. (See the `field_byte_offset'
9404 For any given bit-field, the "containing object" is a hypothetical object
9405 (of some integral or enum type) within which the given bit-field lives. The
9406 type of this hypothetical "containing object" is always the same as the
9407 declared type of the individual bit-field itself (for GCC anyway... the
9408 DWARF spec doesn't actually mandate this). Note that it is the size (in
9409 bytes) of the hypothetical "containing object" which will be given in the
9410 DW_AT_byte_size attribute for this bit-field. (See the
9411 `byte_size_attribute' function below.) It is also used when calculating the
9412 value of the DW_AT_bit_offset attribute. (See the `bit_offset_attribute'
9416 add_data_member_location_attribute (dw_die_ref die
, tree decl
)
9418 HOST_WIDE_INT offset
;
9419 dw_loc_descr_ref loc_descr
= 0;
9421 if (TREE_CODE (decl
) == TREE_BINFO
)
9423 /* We're working on the TAG_inheritance for a base class. */
9424 if (BINFO_VIRTUAL_P (decl
) && is_cxx ())
9426 /* For C++ virtual bases we can't just use BINFO_OFFSET, as they
9427 aren't at a fixed offset from all (sub)objects of the same
9428 type. We need to extract the appropriate offset from our
9429 vtable. The following dwarf expression means
9431 BaseAddr = ObAddr + *((*ObAddr) - Offset)
9433 This is specific to the V3 ABI, of course. */
9435 dw_loc_descr_ref tmp
;
9437 /* Make a copy of the object address. */
9438 tmp
= new_loc_descr (DW_OP_dup
, 0, 0);
9439 add_loc_descr (&loc_descr
, tmp
);
9441 /* Extract the vtable address. */
9442 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
9443 add_loc_descr (&loc_descr
, tmp
);
9445 /* Calculate the address of the offset. */
9446 offset
= tree_low_cst (BINFO_VPTR_FIELD (decl
), 0);
9447 gcc_assert (offset
< 0);
9449 tmp
= int_loc_descriptor (-offset
);
9450 add_loc_descr (&loc_descr
, tmp
);
9451 tmp
= new_loc_descr (DW_OP_minus
, 0, 0);
9452 add_loc_descr (&loc_descr
, tmp
);
9454 /* Extract the offset. */
9455 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
9456 add_loc_descr (&loc_descr
, tmp
);
9458 /* Add it to the object address. */
9459 tmp
= new_loc_descr (DW_OP_plus
, 0, 0);
9460 add_loc_descr (&loc_descr
, tmp
);
9463 offset
= tree_low_cst (BINFO_OFFSET (decl
), 0);
9466 offset
= field_byte_offset (decl
);
9470 enum dwarf_location_atom op
;
9472 /* The DWARF2 standard says that we should assume that the structure
9473 address is already on the stack, so we can specify a structure field
9474 address by using DW_OP_plus_uconst. */
9476 #ifdef MIPS_DEBUGGING_INFO
9477 /* ??? The SGI dwarf reader does not handle the DW_OP_plus_uconst
9478 operator correctly. It works only if we leave the offset on the
9482 op
= DW_OP_plus_uconst
;
9485 loc_descr
= new_loc_descr (op
, offset
, 0);
9488 add_AT_loc (die
, DW_AT_data_member_location
, loc_descr
);
9491 /* Writes integer values to dw_vec_const array. */
9494 insert_int (HOST_WIDE_INT val
, unsigned int size
, unsigned char *dest
)
9498 *dest
++ = val
& 0xff;
9504 /* Reads integers from dw_vec_const array. Inverse of insert_int. */
9506 static HOST_WIDE_INT
9507 extract_int (const unsigned char *src
, unsigned int size
)
9509 HOST_WIDE_INT val
= 0;
9515 val
|= *--src
& 0xff;
9521 /* Writes floating point values to dw_vec_const array. */
9524 insert_float (rtx rtl
, unsigned char *array
)
9530 REAL_VALUE_FROM_CONST_DOUBLE (rv
, rtl
);
9531 real_to_target (val
, &rv
, GET_MODE (rtl
));
9533 /* real_to_target puts 32-bit pieces in each long. Pack them. */
9534 for (i
= 0; i
< GET_MODE_SIZE (GET_MODE (rtl
)) / 4; i
++)
9536 insert_int (val
[i
], 4, array
);
9541 /* Attach a DW_AT_const_value attribute for a variable or a parameter which
9542 does not have a "location" either in memory or in a register. These
9543 things can arise in GNU C when a constant is passed as an actual parameter
9544 to an inlined function. They can also arise in C++ where declared
9545 constants do not necessarily get memory "homes". */
9548 add_const_value_attribute (dw_die_ref die
, rtx rtl
)
9550 switch (GET_CODE (rtl
))
9554 HOST_WIDE_INT val
= INTVAL (rtl
);
9557 add_AT_int (die
, DW_AT_const_value
, val
);
9559 add_AT_unsigned (die
, DW_AT_const_value
, (unsigned HOST_WIDE_INT
) val
);
9564 /* Note that a CONST_DOUBLE rtx could represent either an integer or a
9565 floating-point constant. A CONST_DOUBLE is used whenever the
9566 constant requires more than one word in order to be adequately
9567 represented. We output CONST_DOUBLEs as blocks. */
9569 enum machine_mode mode
= GET_MODE (rtl
);
9571 if (GET_MODE_CLASS (mode
) == MODE_FLOAT
)
9573 unsigned int length
= GET_MODE_SIZE (mode
);
9574 unsigned char *array
= ggc_alloc (length
);
9576 insert_float (rtl
, array
);
9577 add_AT_vec (die
, DW_AT_const_value
, length
/ 4, 4, array
);
9581 /* ??? We really should be using HOST_WIDE_INT throughout. */
9582 gcc_assert (HOST_BITS_PER_LONG
== HOST_BITS_PER_WIDE_INT
);
9584 add_AT_long_long (die
, DW_AT_const_value
,
9585 CONST_DOUBLE_HIGH (rtl
), CONST_DOUBLE_LOW (rtl
));
9592 enum machine_mode mode
= GET_MODE (rtl
);
9593 unsigned int elt_size
= GET_MODE_UNIT_SIZE (mode
);
9594 unsigned int length
= CONST_VECTOR_NUNITS (rtl
);
9595 unsigned char *array
= ggc_alloc (length
* elt_size
);
9599 switch (GET_MODE_CLASS (mode
))
9601 case MODE_VECTOR_INT
:
9602 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
9604 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
9605 HOST_WIDE_INT lo
, hi
;
9607 switch (GET_CODE (elt
))
9615 lo
= CONST_DOUBLE_LOW (elt
);
9616 hi
= CONST_DOUBLE_HIGH (elt
);
9623 if (elt_size
<= sizeof (HOST_WIDE_INT
))
9624 insert_int (lo
, elt_size
, p
);
9627 unsigned char *p0
= p
;
9628 unsigned char *p1
= p
+ sizeof (HOST_WIDE_INT
);
9630 gcc_assert (elt_size
== 2 * sizeof (HOST_WIDE_INT
));
9631 if (WORDS_BIG_ENDIAN
)
9636 insert_int (lo
, sizeof (HOST_WIDE_INT
), p0
);
9637 insert_int (hi
, sizeof (HOST_WIDE_INT
), p1
);
9642 case MODE_VECTOR_FLOAT
:
9643 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
9645 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
9646 insert_float (elt
, p
);
9654 add_AT_vec (die
, DW_AT_const_value
, length
, elt_size
, array
);
9659 add_AT_string (die
, DW_AT_const_value
, XSTR (rtl
, 0));
9665 add_AT_addr (die
, DW_AT_const_value
, rtl
);
9666 VARRAY_PUSH_RTX (used_rtx_varray
, rtl
);
9670 /* In cases where an inlined instance of an inline function is passed
9671 the address of an `auto' variable (which is local to the caller) we
9672 can get a situation where the DECL_RTL of the artificial local
9673 variable (for the inlining) which acts as a stand-in for the
9674 corresponding formal parameter (of the inline function) will look
9675 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not
9676 exactly a compile-time constant expression, but it isn't the address
9677 of the (artificial) local variable either. Rather, it represents the
9678 *value* which the artificial local variable always has during its
9679 lifetime. We currently have no way to represent such quasi-constant
9680 values in Dwarf, so for now we just punt and generate nothing. */
9684 /* No other kinds of rtx should be possible here. */
9691 rtl_for_decl_location (tree decl
)
9695 /* Here we have to decide where we are going to say the parameter "lives"
9696 (as far as the debugger is concerned). We only have a couple of
9697 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
9699 DECL_RTL normally indicates where the parameter lives during most of the
9700 activation of the function. If optimization is enabled however, this
9701 could be either NULL or else a pseudo-reg. Both of those cases indicate
9702 that the parameter doesn't really live anywhere (as far as the code
9703 generation parts of GCC are concerned) during most of the function's
9704 activation. That will happen (for example) if the parameter is never
9705 referenced within the function.
9707 We could just generate a location descriptor here for all non-NULL
9708 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
9709 a little nicer than that if we also consider DECL_INCOMING_RTL in cases
9710 where DECL_RTL is NULL or is a pseudo-reg.
9712 Note however that we can only get away with using DECL_INCOMING_RTL as
9713 a backup substitute for DECL_RTL in certain limited cases. In cases
9714 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
9715 we can be sure that the parameter was passed using the same type as it is
9716 declared to have within the function, and that its DECL_INCOMING_RTL
9717 points us to a place where a value of that type is passed.
9719 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
9720 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
9721 because in these cases DECL_INCOMING_RTL points us to a value of some
9722 type which is *different* from the type of the parameter itself. Thus,
9723 if we tried to use DECL_INCOMING_RTL to generate a location attribute in
9724 such cases, the debugger would end up (for example) trying to fetch a
9725 `float' from a place which actually contains the first part of a
9726 `double'. That would lead to really incorrect and confusing
9727 output at debug-time.
9729 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
9730 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There
9731 are a couple of exceptions however. On little-endian machines we can
9732 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
9733 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
9734 an integral type that is smaller than TREE_TYPE (decl). These cases arise
9735 when (on a little-endian machine) a non-prototyped function has a
9736 parameter declared to be of type `short' or `char'. In such cases,
9737 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
9738 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
9739 passed `int' value. If the debugger then uses that address to fetch
9740 a `short' or a `char' (on a little-endian machine) the result will be
9741 the correct data, so we allow for such exceptional cases below.
9743 Note that our goal here is to describe the place where the given formal
9744 parameter lives during most of the function's activation (i.e. between the
9745 end of the prologue and the start of the epilogue). We'll do that as best
9746 as we can. Note however that if the given formal parameter is modified
9747 sometime during the execution of the function, then a stack backtrace (at
9748 debug-time) will show the function as having been called with the *new*
9749 value rather than the value which was originally passed in. This happens
9750 rarely enough that it is not a major problem, but it *is* a problem, and
9753 A future version of dwarf2out.c may generate two additional attributes for
9754 any given DW_TAG_formal_parameter DIE which will describe the "passed
9755 type" and the "passed location" for the given formal parameter in addition
9756 to the attributes we now generate to indicate the "declared type" and the
9757 "active location" for each parameter. This additional set of attributes
9758 could be used by debuggers for stack backtraces. Separately, note that
9759 sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also.
9760 This happens (for example) for inlined-instances of inline function formal
9761 parameters which are never referenced. This really shouldn't be
9762 happening. All PARM_DECL nodes should get valid non-NULL
9763 DECL_INCOMING_RTL values. FIXME. */
9765 /* Use DECL_RTL as the "location" unless we find something better. */
9766 rtl
= DECL_RTL_IF_SET (decl
);
9768 /* When generating abstract instances, ignore everything except
9769 constants, symbols living in memory, and symbols living in
9771 if (! reload_completed
)
9774 && (CONSTANT_P (rtl
)
9776 && CONSTANT_P (XEXP (rtl
, 0)))
9778 && TREE_CODE (decl
) == VAR_DECL
9779 && TREE_STATIC (decl
))))
9781 rtl
= targetm
.delegitimize_address (rtl
);
9786 else if (TREE_CODE (decl
) == PARM_DECL
)
9788 if (rtl
== NULL_RTX
|| is_pseudo_reg (rtl
))
9790 tree declared_type
= type_main_variant (TREE_TYPE (decl
));
9791 tree passed_type
= type_main_variant (DECL_ARG_TYPE (decl
));
9793 /* This decl represents a formal parameter which was optimized out.
9794 Note that DECL_INCOMING_RTL may be NULL in here, but we handle
9795 all cases where (rtl == NULL_RTX) just below. */
9796 if (declared_type
== passed_type
)
9797 rtl
= DECL_INCOMING_RTL (decl
);
9798 else if (! BYTES_BIG_ENDIAN
9799 && TREE_CODE (declared_type
) == INTEGER_TYPE
9800 && (GET_MODE_SIZE (TYPE_MODE (declared_type
))
9801 <= GET_MODE_SIZE (TYPE_MODE (passed_type
))))
9802 rtl
= DECL_INCOMING_RTL (decl
);
9805 /* If the parm was passed in registers, but lives on the stack, then
9806 make a big endian correction if the mode of the type of the
9807 parameter is not the same as the mode of the rtl. */
9808 /* ??? This is the same series of checks that are made in dbxout.c before
9809 we reach the big endian correction code there. It isn't clear if all
9810 of these checks are necessary here, but keeping them all is the safe
9812 else if (MEM_P (rtl
)
9813 && XEXP (rtl
, 0) != const0_rtx
9814 && ! CONSTANT_P (XEXP (rtl
, 0))
9815 /* Not passed in memory. */
9816 && !MEM_P (DECL_INCOMING_RTL (decl
))
9817 /* Not passed by invisible reference. */
9818 && (!REG_P (XEXP (rtl
, 0))
9819 || REGNO (XEXP (rtl
, 0)) == HARD_FRAME_POINTER_REGNUM
9820 || REGNO (XEXP (rtl
, 0)) == STACK_POINTER_REGNUM
9821 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
9822 || REGNO (XEXP (rtl
, 0)) == ARG_POINTER_REGNUM
9825 /* Big endian correction check. */
9827 && TYPE_MODE (TREE_TYPE (decl
)) != GET_MODE (rtl
)
9828 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl
)))
9831 int offset
= (UNITS_PER_WORD
9832 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl
))));
9834 rtl
= gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl
)),
9835 plus_constant (XEXP (rtl
, 0), offset
));
9838 else if (TREE_CODE (decl
) == VAR_DECL
9841 && GET_MODE (rtl
) != TYPE_MODE (TREE_TYPE (decl
))
9842 && BYTES_BIG_ENDIAN
)
9844 int rsize
= GET_MODE_SIZE (GET_MODE (rtl
));
9845 int dsize
= GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl
)));
9847 /* If a variable is declared "register" yet is smaller than
9848 a register, then if we store the variable to memory, it
9849 looks like we're storing a register-sized value, when in
9850 fact we are not. We need to adjust the offset of the
9851 storage location to reflect the actual value's bytes,
9852 else gdb will not be able to display it. */
9854 rtl
= gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl
)),
9855 plus_constant (XEXP (rtl
, 0), rsize
-dsize
));
9858 if (rtl
!= NULL_RTX
)
9860 rtl
= eliminate_regs (rtl
, 0, NULL_RTX
);
9861 #ifdef LEAF_REG_REMAP
9862 if (current_function_uses_only_leaf_regs
)
9863 leaf_renumber_regs_insn (rtl
);
9867 /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant,
9868 and will have been substituted directly into all expressions that use it.
9869 C does not have such a concept, but C++ and other languages do. */
9870 else if (TREE_CODE (decl
) == VAR_DECL
&& DECL_INITIAL (decl
))
9872 /* If a variable is initialized with a string constant without embedded
9873 zeros, build CONST_STRING. */
9874 if (TREE_CODE (DECL_INITIAL (decl
)) == STRING_CST
9875 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
9877 tree arrtype
= TREE_TYPE (decl
);
9878 tree enttype
= TREE_TYPE (arrtype
);
9879 tree domain
= TYPE_DOMAIN (arrtype
);
9880 tree init
= DECL_INITIAL (decl
);
9881 enum machine_mode mode
= TYPE_MODE (enttype
);
9883 if (GET_MODE_CLASS (mode
) == MODE_INT
&& GET_MODE_SIZE (mode
) == 1
9885 && integer_zerop (TYPE_MIN_VALUE (domain
))
9886 && compare_tree_int (TYPE_MAX_VALUE (domain
),
9887 TREE_STRING_LENGTH (init
) - 1) == 0
9888 && ((size_t) TREE_STRING_LENGTH (init
)
9889 == strlen (TREE_STRING_POINTER (init
)) + 1))
9890 rtl
= gen_rtx_CONST_STRING (VOIDmode
, TREE_STRING_POINTER (init
));
9892 /* If the initializer is something that we know will expand into an
9893 immediate RTL constant, expand it now. Expanding anything else
9894 tends to produce unresolved symbols; see debug/5770 and c++/6381. */
9895 else if (TREE_CODE (DECL_INITIAL (decl
)) == INTEGER_CST
9896 || TREE_CODE (DECL_INITIAL (decl
)) == REAL_CST
)
9898 rtl
= expand_expr (DECL_INITIAL (decl
), NULL_RTX
, VOIDmode
,
9899 EXPAND_INITIALIZER
);
9900 /* If expand_expr returns a MEM, it wasn't immediate. */
9901 gcc_assert (!rtl
|| !MEM_P (rtl
));
9906 rtl
= targetm
.delegitimize_address (rtl
);
9908 /* If we don't look past the constant pool, we risk emitting a
9909 reference to a constant pool entry that isn't referenced from
9910 code, and thus is not emitted. */
9912 rtl
= avoid_constant_pool_reference (rtl
);
9917 /* Generate *either* a DW_AT_location attribute or else a DW_AT_const_value
9918 data attribute for a variable or a parameter. We generate the
9919 DW_AT_const_value attribute only in those cases where the given variable
9920 or parameter does not have a true "location" either in memory or in a
9921 register. This can happen (for example) when a constant is passed as an
9922 actual argument in a call to an inline function. (It's possible that
9923 these things can crop up in other ways also.) Note that one type of
9924 constant value which can be passed into an inlined function is a constant
9925 pointer. This can happen for example if an actual argument in an inlined
9926 function call evaluates to a compile-time constant address. */
9929 add_location_or_const_value_attribute (dw_die_ref die
, tree decl
,
9930 enum dwarf_attribute attr
)
9933 dw_loc_descr_ref descr
;
9934 var_loc_list
*loc_list
;
9936 if (TREE_CODE (decl
) == ERROR_MARK
)
9939 gcc_assert (TREE_CODE (decl
) == VAR_DECL
|| TREE_CODE (decl
) == PARM_DECL
9940 || TREE_CODE (decl
) == RESULT_DECL
);
9942 /* See if we possibly have multiple locations for this variable. */
9943 loc_list
= lookup_decl_loc (decl
);
9945 /* If it truly has multiple locations, the first and last node will
9947 if (loc_list
&& loc_list
->first
!= loc_list
->last
)
9949 const char *secname
;
9950 const char *endname
;
9951 dw_loc_list_ref list
;
9953 struct var_loc_node
*node
;
9955 /* We need to figure out what section we should use as the base
9956 for the address ranges where a given location is valid.
9957 1. If this particular DECL has a section associated with it,
9959 2. If this function has a section associated with it, use
9961 3. Otherwise, use the text section.
9962 XXX: If you split a variable across multiple sections, this
9965 if (DECL_SECTION_NAME (decl
))
9967 tree sectree
= DECL_SECTION_NAME (decl
);
9968 secname
= TREE_STRING_POINTER (sectree
);
9970 else if (current_function_decl
9971 && DECL_SECTION_NAME (current_function_decl
))
9973 tree sectree
= DECL_SECTION_NAME (current_function_decl
);
9974 secname
= TREE_STRING_POINTER (sectree
);
9977 secname
= text_section_label
;
9979 /* Now that we know what section we are using for a base,
9980 actually construct the list of locations.
9981 The first location information is what is passed to the
9982 function that creates the location list, and the remaining
9983 locations just get added on to that list.
9984 Note that we only know the start address for a location
9985 (IE location changes), so to build the range, we use
9986 the range [current location start, next location start].
9987 This means we have to special case the last node, and generate
9988 a range of [last location start, end of function label]. */
9990 node
= loc_list
->first
;
9991 varloc
= NOTE_VAR_LOCATION (node
->var_loc_note
);
9992 list
= new_loc_list (loc_descriptor (varloc
, attr
!= DW_AT_frame_base
),
9993 node
->label
, node
->next
->label
, secname
, 1);
9996 for (; node
->next
; node
= node
->next
)
9997 if (NOTE_VAR_LOCATION_LOC (node
->var_loc_note
) != NULL_RTX
)
9999 /* The variable has a location between NODE->LABEL and
10000 NODE->NEXT->LABEL. */
10001 varloc
= NOTE_VAR_LOCATION (node
->var_loc_note
);
10002 add_loc_descr_to_loc_list (&list
,
10003 loc_descriptor (varloc
,
10004 attr
!= DW_AT_frame_base
),
10005 node
->label
, node
->next
->label
, secname
);
10008 /* If the variable has a location at the last label
10009 it keeps its location until the end of function. */
10010 if (NOTE_VAR_LOCATION_LOC (node
->var_loc_note
) != NULL_RTX
)
10012 char label_id
[MAX_ARTIFICIAL_LABEL_BYTES
];
10014 varloc
= NOTE_VAR_LOCATION (node
->var_loc_note
);
10015 if (!current_function_decl
)
10016 endname
= text_end_label
;
10019 ASM_GENERATE_INTERNAL_LABEL (label_id
, FUNC_END_LABEL
,
10020 current_function_funcdef_no
);
10021 endname
= ggc_strdup (label_id
);
10023 add_loc_descr_to_loc_list (&list
,
10024 loc_descriptor (varloc
,
10025 attr
!= DW_AT_frame_base
),
10026 node
->label
, endname
, secname
);
10029 /* Finally, add the location list to the DIE, and we are done. */
10030 add_AT_loc_list (die
, attr
, list
);
10034 rtl
= rtl_for_decl_location (decl
);
10035 if (rtl
&& (CONSTANT_P (rtl
) || GET_CODE (rtl
) == CONST_STRING
))
10037 add_const_value_attribute (die
, rtl
);
10041 descr
= loc_descriptor_from_tree (decl
);
10043 add_AT_location_description (die
, attr
, descr
);
10046 /* If we don't have a copy of this variable in memory for some reason (such
10047 as a C++ member constant that doesn't have an out-of-line definition),
10048 we should tell the debugger about the constant value. */
10051 tree_add_const_value_attribute (dw_die_ref var_die
, tree decl
)
10053 tree init
= DECL_INITIAL (decl
);
10054 tree type
= TREE_TYPE (decl
);
10056 if (TREE_READONLY (decl
) && ! TREE_THIS_VOLATILE (decl
) && init
10057 && initializer_constant_valid_p (init
, type
) == null_pointer_node
)
10062 switch (TREE_CODE (type
))
10065 if (host_integerp (init
, 0))
10066 add_AT_unsigned (var_die
, DW_AT_const_value
,
10067 tree_low_cst (init
, 0));
10069 add_AT_long_long (var_die
, DW_AT_const_value
,
10070 TREE_INT_CST_HIGH (init
),
10071 TREE_INT_CST_LOW (init
));
10078 /* Generate a DW_AT_name attribute given some string value to be included as
10079 the value of the attribute. */
10082 add_name_attribute (dw_die_ref die
, const char *name_string
)
10084 if (name_string
!= NULL
&& *name_string
!= 0)
10086 if (demangle_name_func
)
10087 name_string
= (*demangle_name_func
) (name_string
);
10089 add_AT_string (die
, DW_AT_name
, name_string
);
10093 /* Generate a DW_AT_comp_dir attribute for DIE. */
10096 add_comp_dir_attribute (dw_die_ref die
)
10098 const char *wd
= get_src_pwd ();
10100 add_AT_string (die
, DW_AT_comp_dir
, wd
);
10103 /* Given a tree node describing an array bound (either lower or upper) output
10104 a representation for that bound. */
10107 add_bound_info (dw_die_ref subrange_die
, enum dwarf_attribute bound_attr
, tree bound
)
10109 switch (TREE_CODE (bound
))
10114 /* All fixed-bounds are represented by INTEGER_CST nodes. */
10116 if (! host_integerp (bound
, 0)
10117 || (bound_attr
== DW_AT_lower_bound
10118 && (((is_c_family () || is_java ()) && integer_zerop (bound
))
10119 || (is_fortran () && integer_onep (bound
)))))
10120 /* Use the default. */
10123 add_AT_unsigned (subrange_die
, bound_attr
, tree_low_cst (bound
, 0));
10128 case NON_LVALUE_EXPR
:
10129 case VIEW_CONVERT_EXPR
:
10130 add_bound_info (subrange_die
, bound_attr
, TREE_OPERAND (bound
, 0));
10140 dw_die_ref decl_die
= lookup_decl_die (bound
);
10142 /* ??? Can this happen, or should the variable have been bound
10143 first? Probably it can, since I imagine that we try to create
10144 the types of parameters in the order in which they exist in
10145 the list, and won't have created a forward reference to a
10146 later parameter. */
10147 if (decl_die
!= NULL
)
10148 add_AT_die_ref (subrange_die
, bound_attr
, decl_die
);
10154 /* Otherwise try to create a stack operation procedure to
10155 evaluate the value of the array bound. */
10157 dw_die_ref ctx
, decl_die
;
10158 dw_loc_descr_ref loc
;
10160 loc
= loc_descriptor_from_tree (bound
);
10164 if (current_function_decl
== 0)
10165 ctx
= comp_unit_die
;
10167 ctx
= lookup_decl_die (current_function_decl
);
10169 decl_die
= new_die (DW_TAG_variable
, ctx
, bound
);
10170 add_AT_flag (decl_die
, DW_AT_artificial
, 1);
10171 add_type_attribute (decl_die
, TREE_TYPE (bound
), 1, 0, ctx
);
10172 add_AT_loc (decl_die
, DW_AT_location
, loc
);
10174 add_AT_die_ref (subrange_die
, bound_attr
, decl_die
);
10180 /* Note that the block of subscript information for an array type also
10181 includes information about the element type of type given array type. */
10184 add_subscript_info (dw_die_ref type_die
, tree type
)
10186 #ifndef MIPS_DEBUGGING_INFO
10187 unsigned dimension_number
;
10190 dw_die_ref subrange_die
;
10192 /* The GNU compilers represent multidimensional array types as sequences of
10193 one dimensional array types whose element types are themselves array
10194 types. Here we squish that down, so that each multidimensional array
10195 type gets only one array_type DIE in the Dwarf debugging info. The draft
10196 Dwarf specification say that we are allowed to do this kind of
10197 compression in C (because there is no difference between an array or
10198 arrays and a multidimensional array in C) but for other source languages
10199 (e.g. Ada) we probably shouldn't do this. */
10201 /* ??? The SGI dwarf reader fails for multidimensional arrays with a
10202 const enum type. E.g. const enum machine_mode insn_operand_mode[2][10].
10203 We work around this by disabling this feature. See also
10204 gen_array_type_die. */
10205 #ifndef MIPS_DEBUGGING_INFO
10206 for (dimension_number
= 0;
10207 TREE_CODE (type
) == ARRAY_TYPE
;
10208 type
= TREE_TYPE (type
), dimension_number
++)
10211 tree domain
= TYPE_DOMAIN (type
);
10213 /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
10214 and (in GNU C only) variable bounds. Handle all three forms
10216 subrange_die
= new_die (DW_TAG_subrange_type
, type_die
, NULL
);
10219 /* We have an array type with specified bounds. */
10220 lower
= TYPE_MIN_VALUE (domain
);
10221 upper
= TYPE_MAX_VALUE (domain
);
10223 /* Define the index type. */
10224 if (TREE_TYPE (domain
))
10226 /* ??? This is probably an Ada unnamed subrange type. Ignore the
10227 TREE_TYPE field. We can't emit debug info for this
10228 because it is an unnamed integral type. */
10229 if (TREE_CODE (domain
) == INTEGER_TYPE
10230 && TYPE_NAME (domain
) == NULL_TREE
10231 && TREE_CODE (TREE_TYPE (domain
)) == INTEGER_TYPE
10232 && TYPE_NAME (TREE_TYPE (domain
)) == NULL_TREE
)
10235 add_type_attribute (subrange_die
, TREE_TYPE (domain
), 0, 0,
10239 /* ??? If upper is NULL, the array has unspecified length,
10240 but it does have a lower bound. This happens with Fortran
10242 Since the debugger is definitely going to need to know N
10243 to produce useful results, go ahead and output the lower
10244 bound solo, and hope the debugger can cope. */
10246 add_bound_info (subrange_die
, DW_AT_lower_bound
, lower
);
10248 add_bound_info (subrange_die
, DW_AT_upper_bound
, upper
);
10251 /* Otherwise we have an array type with an unspecified length. The
10252 DWARF-2 spec does not say how to handle this; let's just leave out the
10258 add_byte_size_attribute (dw_die_ref die
, tree tree_node
)
10262 switch (TREE_CODE (tree_node
))
10267 case ENUMERAL_TYPE
:
10270 case QUAL_UNION_TYPE
:
10271 size
= int_size_in_bytes (tree_node
);
10274 /* For a data member of a struct or union, the DW_AT_byte_size is
10275 generally given as the number of bytes normally allocated for an
10276 object of the *declared* type of the member itself. This is true
10277 even for bit-fields. */
10278 size
= simple_type_size_in_bits (field_type (tree_node
)) / BITS_PER_UNIT
;
10281 gcc_unreachable ();
10284 /* Note that `size' might be -1 when we get to this point. If it is, that
10285 indicates that the byte size of the entity in question is variable. We
10286 have no good way of expressing this fact in Dwarf at the present time,
10287 so just let the -1 pass on through. */
10288 add_AT_unsigned (die
, DW_AT_byte_size
, size
);
10291 /* For a FIELD_DECL node which represents a bit-field, output an attribute
10292 which specifies the distance in bits from the highest order bit of the
10293 "containing object" for the bit-field to the highest order bit of the
10296 For any given bit-field, the "containing object" is a hypothetical object
10297 (of some integral or enum type) within which the given bit-field lives. The
10298 type of this hypothetical "containing object" is always the same as the
10299 declared type of the individual bit-field itself. The determination of the
10300 exact location of the "containing object" for a bit-field is rather
10301 complicated. It's handled by the `field_byte_offset' function (above).
10303 Note that it is the size (in bytes) of the hypothetical "containing object"
10304 which will be given in the DW_AT_byte_size attribute for this bit-field.
10305 (See `byte_size_attribute' above). */
10308 add_bit_offset_attribute (dw_die_ref die
, tree decl
)
10310 HOST_WIDE_INT object_offset_in_bytes
= field_byte_offset (decl
);
10311 tree type
= DECL_BIT_FIELD_TYPE (decl
);
10312 HOST_WIDE_INT bitpos_int
;
10313 HOST_WIDE_INT highest_order_object_bit_offset
;
10314 HOST_WIDE_INT highest_order_field_bit_offset
;
10315 HOST_WIDE_INT
unsigned bit_offset
;
10317 /* Must be a field and a bit field. */
10318 gcc_assert (type
&& TREE_CODE (decl
) == FIELD_DECL
);
10320 /* We can't yet handle bit-fields whose offsets are variable, so if we
10321 encounter such things, just return without generating any attribute
10322 whatsoever. Likewise for variable or too large size. */
10323 if (! host_integerp (bit_position (decl
), 0)
10324 || ! host_integerp (DECL_SIZE (decl
), 1))
10327 bitpos_int
= int_bit_position (decl
);
10329 /* Note that the bit offset is always the distance (in bits) from the
10330 highest-order bit of the "containing object" to the highest-order bit of
10331 the bit-field itself. Since the "high-order end" of any object or field
10332 is different on big-endian and little-endian machines, the computation
10333 below must take account of these differences. */
10334 highest_order_object_bit_offset
= object_offset_in_bytes
* BITS_PER_UNIT
;
10335 highest_order_field_bit_offset
= bitpos_int
;
10337 if (! BYTES_BIG_ENDIAN
)
10339 highest_order_field_bit_offset
+= tree_low_cst (DECL_SIZE (decl
), 0);
10340 highest_order_object_bit_offset
+= simple_type_size_in_bits (type
);
10344 = (! BYTES_BIG_ENDIAN
10345 ? highest_order_object_bit_offset
- highest_order_field_bit_offset
10346 : highest_order_field_bit_offset
- highest_order_object_bit_offset
);
10348 add_AT_unsigned (die
, DW_AT_bit_offset
, bit_offset
);
10351 /* For a FIELD_DECL node which represents a bit field, output an attribute
10352 which specifies the length in bits of the given field. */
10355 add_bit_size_attribute (dw_die_ref die
, tree decl
)
10357 /* Must be a field and a bit field. */
10358 gcc_assert (TREE_CODE (decl
) == FIELD_DECL
10359 && DECL_BIT_FIELD_TYPE (decl
));
10361 if (host_integerp (DECL_SIZE (decl
), 1))
10362 add_AT_unsigned (die
, DW_AT_bit_size
, tree_low_cst (DECL_SIZE (decl
), 1));
10365 /* If the compiled language is ANSI C, then add a 'prototyped'
10366 attribute, if arg types are given for the parameters of a function. */
10369 add_prototyped_attribute (dw_die_ref die
, tree func_type
)
10371 if (get_AT_unsigned (comp_unit_die
, DW_AT_language
) == DW_LANG_C89
10372 && TYPE_ARG_TYPES (func_type
) != NULL
)
10373 add_AT_flag (die
, DW_AT_prototyped
, 1);
10376 /* Add an 'abstract_origin' attribute below a given DIE. The DIE is found
10377 by looking in either the type declaration or object declaration
10381 add_abstract_origin_attribute (dw_die_ref die
, tree origin
)
10383 dw_die_ref origin_die
= NULL
;
10385 if (TREE_CODE (origin
) != FUNCTION_DECL
)
10387 /* We may have gotten separated from the block for the inlined
10388 function, if we're in an exception handler or some such; make
10389 sure that the abstract function has been written out.
10391 Doing this for nested functions is wrong, however; functions are
10392 distinct units, and our context might not even be inline. */
10396 fn
= TYPE_STUB_DECL (fn
);
10398 fn
= decl_function_context (fn
);
10400 dwarf2out_abstract_function (fn
);
10403 if (DECL_P (origin
))
10404 origin_die
= lookup_decl_die (origin
);
10405 else if (TYPE_P (origin
))
10406 origin_die
= lookup_type_die (origin
);
10408 gcc_assert (origin_die
);
10410 add_AT_die_ref (die
, DW_AT_abstract_origin
, origin_die
);
10413 /* We do not currently support the pure_virtual attribute. */
10416 add_pure_or_virtual_attribute (dw_die_ref die
, tree func_decl
)
10418 if (DECL_VINDEX (func_decl
))
10420 add_AT_unsigned (die
, DW_AT_virtuality
, DW_VIRTUALITY_virtual
);
10422 if (host_integerp (DECL_VINDEX (func_decl
), 0))
10423 add_AT_loc (die
, DW_AT_vtable_elem_location
,
10424 new_loc_descr (DW_OP_constu
,
10425 tree_low_cst (DECL_VINDEX (func_decl
), 0),
10428 /* GNU extension: Record what type this method came from originally. */
10429 if (debug_info_level
> DINFO_LEVEL_TERSE
)
10430 add_AT_die_ref (die
, DW_AT_containing_type
,
10431 lookup_type_die (DECL_CONTEXT (func_decl
)));
10435 /* Add source coordinate attributes for the given decl. */
10438 add_src_coords_attributes (dw_die_ref die
, tree decl
)
10440 expanded_location s
= expand_location (DECL_SOURCE_LOCATION (decl
));
10441 unsigned file_index
= lookup_filename (s
.file
);
10443 add_AT_unsigned (die
, DW_AT_decl_file
, file_index
);
10444 add_AT_unsigned (die
, DW_AT_decl_line
, s
.line
);
10447 /* Add a DW_AT_name attribute and source coordinate attribute for the
10448 given decl, but only if it actually has a name. */
10451 add_name_and_src_coords_attributes (dw_die_ref die
, tree decl
)
10455 decl_name
= DECL_NAME (decl
);
10456 if (decl_name
!= NULL
&& IDENTIFIER_POINTER (decl_name
) != NULL
)
10458 add_name_attribute (die
, dwarf2_name (decl
, 0));
10459 if (! DECL_ARTIFICIAL (decl
))
10460 add_src_coords_attributes (die
, decl
);
10462 if ((TREE_CODE (decl
) == FUNCTION_DECL
|| TREE_CODE (decl
) == VAR_DECL
)
10463 && TREE_PUBLIC (decl
)
10464 && DECL_ASSEMBLER_NAME (decl
) != DECL_NAME (decl
)
10465 && !DECL_ABSTRACT (decl
))
10466 add_AT_string (die
, DW_AT_MIPS_linkage_name
,
10467 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)));
10470 #ifdef VMS_DEBUGGING_INFO
10471 /* Get the function's name, as described by its RTL. This may be different
10472 from the DECL_NAME name used in the source file. */
10473 if (TREE_CODE (decl
) == FUNCTION_DECL
&& TREE_ASM_WRITTEN (decl
))
10475 add_AT_addr (die
, DW_AT_VMS_rtnbeg_pd_address
,
10476 XEXP (DECL_RTL (decl
), 0));
10477 VARRAY_PUSH_RTX (used_rtx_varray
, XEXP (DECL_RTL (decl
), 0));
10482 /* Push a new declaration scope. */
10485 push_decl_scope (tree scope
)
10487 VARRAY_PUSH_TREE (decl_scope_table
, scope
);
10490 /* Pop a declaration scope. */
10493 pop_decl_scope (void)
10495 gcc_assert (VARRAY_ACTIVE_SIZE (decl_scope_table
) > 0);
10497 VARRAY_POP (decl_scope_table
);
10500 /* Return the DIE for the scope that immediately contains this type.
10501 Non-named types get global scope. Named types nested in other
10502 types get their containing scope if it's open, or global scope
10503 otherwise. All other types (i.e. function-local named types) get
10504 the current active scope. */
10507 scope_die_for (tree t
, dw_die_ref context_die
)
10509 dw_die_ref scope_die
= NULL
;
10510 tree containing_scope
;
10513 /* Non-types always go in the current scope. */
10514 gcc_assert (TYPE_P (t
));
10516 containing_scope
= TYPE_CONTEXT (t
);
10518 /* Use the containing namespace if it was passed in (for a declaration). */
10519 if (containing_scope
&& TREE_CODE (containing_scope
) == NAMESPACE_DECL
)
10521 if (context_die
== lookup_decl_die (containing_scope
))
10524 containing_scope
= NULL_TREE
;
10527 /* Ignore function type "scopes" from the C frontend. They mean that
10528 a tagged type is local to a parmlist of a function declarator, but
10529 that isn't useful to DWARF. */
10530 if (containing_scope
&& TREE_CODE (containing_scope
) == FUNCTION_TYPE
)
10531 containing_scope
= NULL_TREE
;
10533 if (containing_scope
== NULL_TREE
)
10534 scope_die
= comp_unit_die
;
10535 else if (TYPE_P (containing_scope
))
10537 /* For types, we can just look up the appropriate DIE. But
10538 first we check to see if we're in the middle of emitting it
10539 so we know where the new DIE should go. */
10540 for (i
= VARRAY_ACTIVE_SIZE (decl_scope_table
) - 1; i
>= 0; --i
)
10541 if (VARRAY_TREE (decl_scope_table
, i
) == containing_scope
)
10546 gcc_assert (debug_info_level
<= DINFO_LEVEL_TERSE
10547 || TREE_ASM_WRITTEN (containing_scope
));
10549 /* If none of the current dies are suitable, we get file scope. */
10550 scope_die
= comp_unit_die
;
10553 scope_die
= lookup_type_die (containing_scope
);
10556 scope_die
= context_die
;
10561 /* Returns nonzero if CONTEXT_DIE is internal to a function. */
10564 local_scope_p (dw_die_ref context_die
)
10566 for (; context_die
; context_die
= context_die
->die_parent
)
10567 if (context_die
->die_tag
== DW_TAG_inlined_subroutine
10568 || context_die
->die_tag
== DW_TAG_subprogram
)
10574 /* Returns nonzero if CONTEXT_DIE is a class or namespace, for deciding
10575 whether or not to treat a DIE in this context as a declaration. */
10578 class_or_namespace_scope_p (dw_die_ref context_die
)
10580 return (context_die
10581 && (context_die
->die_tag
== DW_TAG_structure_type
10582 || context_die
->die_tag
== DW_TAG_union_type
10583 || context_die
->die_tag
== DW_TAG_namespace
));
10586 /* Many forms of DIEs require a "type description" attribute. This
10587 routine locates the proper "type descriptor" die for the type given
10588 by 'type', and adds a DW_AT_type attribute below the given die. */
10591 add_type_attribute (dw_die_ref object_die
, tree type
, int decl_const
,
10592 int decl_volatile
, dw_die_ref context_die
)
10594 enum tree_code code
= TREE_CODE (type
);
10595 dw_die_ref type_die
= NULL
;
10597 /* ??? If this type is an unnamed subrange type of an integral or
10598 floating-point type, use the inner type. This is because we have no
10599 support for unnamed types in base_type_die. This can happen if this is
10600 an Ada subrange type. Correct solution is emit a subrange type die. */
10601 if ((code
== INTEGER_TYPE
|| code
== REAL_TYPE
)
10602 && TREE_TYPE (type
) != 0 && TYPE_NAME (type
) == 0)
10603 type
= TREE_TYPE (type
), code
= TREE_CODE (type
);
10605 if (code
== ERROR_MARK
10606 /* Handle a special case. For functions whose return type is void, we
10607 generate *no* type attribute. (Note that no object may have type
10608 `void', so this only applies to function return types). */
10609 || code
== VOID_TYPE
)
10612 type_die
= modified_type_die (type
,
10613 decl_const
|| TYPE_READONLY (type
),
10614 decl_volatile
|| TYPE_VOLATILE (type
),
10617 if (type_die
!= NULL
)
10618 add_AT_die_ref (object_die
, DW_AT_type
, type_die
);
10621 /* Given a tree pointer to a struct, class, union, or enum type node, return
10622 a pointer to the (string) tag name for the given type, or zero if the type
10623 was declared without a tag. */
10625 static const char *
10626 type_tag (tree type
)
10628 const char *name
= 0;
10630 if (TYPE_NAME (type
) != 0)
10634 /* Find the IDENTIFIER_NODE for the type name. */
10635 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
10636 t
= TYPE_NAME (type
);
10638 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
10639 a TYPE_DECL node, regardless of whether or not a `typedef' was
10641 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
10642 && ! DECL_IGNORED_P (TYPE_NAME (type
)))
10643 t
= DECL_NAME (TYPE_NAME (type
));
10645 /* Now get the name as a string, or invent one. */
10647 name
= IDENTIFIER_POINTER (t
);
10650 return (name
== 0 || *name
== '\0') ? 0 : name
;
10653 /* Return the type associated with a data member, make a special check
10654 for bit field types. */
10657 member_declared_type (tree member
)
10659 return (DECL_BIT_FIELD_TYPE (member
)
10660 ? DECL_BIT_FIELD_TYPE (member
) : TREE_TYPE (member
));
10663 /* Get the decl's label, as described by its RTL. This may be different
10664 from the DECL_NAME name used in the source file. */
10667 static const char *
10668 decl_start_label (tree decl
)
10671 const char *fnname
;
10673 x
= DECL_RTL (decl
);
10674 gcc_assert (MEM_P (x
));
10677 gcc_assert (GET_CODE (x
) == SYMBOL_REF
);
10679 fnname
= XSTR (x
, 0);
10684 /* These routines generate the internal representation of the DIE's for
10685 the compilation unit. Debugging information is collected by walking
10686 the declaration trees passed in from dwarf2out_decl(). */
10689 gen_array_type_die (tree type
, dw_die_ref context_die
)
10691 dw_die_ref scope_die
= scope_die_for (type
, context_die
);
10692 dw_die_ref array_die
;
10695 /* ??? The SGI dwarf reader fails for array of array of enum types unless
10696 the inner array type comes before the outer array type. Thus we must
10697 call gen_type_die before we call new_die. See below also. */
10698 #ifdef MIPS_DEBUGGING_INFO
10699 gen_type_die (TREE_TYPE (type
), context_die
);
10702 array_die
= new_die (DW_TAG_array_type
, scope_die
, type
);
10703 add_name_attribute (array_die
, type_tag (type
));
10704 equate_type_number_to_die (type
, array_die
);
10706 if (TREE_CODE (type
) == VECTOR_TYPE
)
10708 /* The frontend feeds us a representation for the vector as a struct
10709 containing an array. Pull out the array type. */
10710 type
= TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type
)));
10711 add_AT_flag (array_die
, DW_AT_GNU_vector
, 1);
10715 /* We default the array ordering. SDB will probably do
10716 the right things even if DW_AT_ordering is not present. It's not even
10717 an issue until we start to get into multidimensional arrays anyway. If
10718 SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
10719 then we'll have to put the DW_AT_ordering attribute back in. (But if
10720 and when we find out that we need to put these in, we will only do so
10721 for multidimensional arrays. */
10722 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_row_major
);
10725 #ifdef MIPS_DEBUGGING_INFO
10726 /* The SGI compilers handle arrays of unknown bound by setting
10727 AT_declaration and not emitting any subrange DIEs. */
10728 if (! TYPE_DOMAIN (type
))
10729 add_AT_flag (array_die
, DW_AT_declaration
, 1);
10732 add_subscript_info (array_die
, type
);
10734 /* Add representation of the type of the elements of this array type. */
10735 element_type
= TREE_TYPE (type
);
10737 /* ??? The SGI dwarf reader fails for multidimensional arrays with a
10738 const enum type. E.g. const enum machine_mode insn_operand_mode[2][10].
10739 We work around this by disabling this feature. See also
10740 add_subscript_info. */
10741 #ifndef MIPS_DEBUGGING_INFO
10742 while (TREE_CODE (element_type
) == ARRAY_TYPE
)
10743 element_type
= TREE_TYPE (element_type
);
10745 gen_type_die (element_type
, context_die
);
10748 add_type_attribute (array_die
, element_type
, 0, 0, context_die
);
10752 gen_set_type_die (tree type
, dw_die_ref context_die
)
10754 dw_die_ref type_die
10755 = new_die (DW_TAG_set_type
, scope_die_for (type
, context_die
), type
);
10757 equate_type_number_to_die (type
, type_die
);
10758 add_type_attribute (type_die
, TREE_TYPE (type
), 0, 0, context_die
);
10763 gen_entry_point_die (tree decl
, dw_die_ref context_die
)
10765 tree origin
= decl_ultimate_origin (decl
);
10766 dw_die_ref decl_die
= new_die (DW_TAG_entry_point
, context_die
, decl
);
10768 if (origin
!= NULL
)
10769 add_abstract_origin_attribute (decl_die
, origin
);
10772 add_name_and_src_coords_attributes (decl_die
, decl
);
10773 add_type_attribute (decl_die
, TREE_TYPE (TREE_TYPE (decl
)),
10774 0, 0, context_die
);
10777 if (DECL_ABSTRACT (decl
))
10778 equate_decl_number_to_die (decl
, decl_die
);
10780 add_AT_lbl_id (decl_die
, DW_AT_low_pc
, decl_start_label (decl
));
10784 /* Walk through the list of incomplete types again, trying once more to
10785 emit full debugging info for them. */
10788 retry_incomplete_types (void)
10792 for (i
= VARRAY_ACTIVE_SIZE (incomplete_types
) - 1; i
>= 0; i
--)
10793 gen_type_die (VARRAY_TREE (incomplete_types
, i
), comp_unit_die
);
10796 /* Generate a DIE to represent an inlined instance of an enumeration type. */
10799 gen_inlined_enumeration_type_die (tree type
, dw_die_ref context_die
)
10801 dw_die_ref type_die
= new_die (DW_TAG_enumeration_type
, context_die
, type
);
10803 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
10804 be incomplete and such types are not marked. */
10805 add_abstract_origin_attribute (type_die
, type
);
10808 /* Generate a DIE to represent an inlined instance of a structure type. */
10811 gen_inlined_structure_type_die (tree type
, dw_die_ref context_die
)
10813 dw_die_ref type_die
= new_die (DW_TAG_structure_type
, context_die
, type
);
10815 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
10816 be incomplete and such types are not marked. */
10817 add_abstract_origin_attribute (type_die
, type
);
10820 /* Generate a DIE to represent an inlined instance of a union type. */
10823 gen_inlined_union_type_die (tree type
, dw_die_ref context_die
)
10825 dw_die_ref type_die
= new_die (DW_TAG_union_type
, context_die
, type
);
10827 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
10828 be incomplete and such types are not marked. */
10829 add_abstract_origin_attribute (type_die
, type
);
10832 /* Generate a DIE to represent an enumeration type. Note that these DIEs
10833 include all of the information about the enumeration values also. Each
10834 enumerated type name/value is listed as a child of the enumerated type
10838 gen_enumeration_type_die (tree type
, dw_die_ref context_die
)
10840 dw_die_ref type_die
= lookup_type_die (type
);
10842 if (type_die
== NULL
)
10844 type_die
= new_die (DW_TAG_enumeration_type
,
10845 scope_die_for (type
, context_die
), type
);
10846 equate_type_number_to_die (type
, type_die
);
10847 add_name_attribute (type_die
, type_tag (type
));
10849 else if (! TYPE_SIZE (type
))
10852 remove_AT (type_die
, DW_AT_declaration
);
10854 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the
10855 given enum type is incomplete, do not generate the DW_AT_byte_size
10856 attribute or the DW_AT_element_list attribute. */
10857 if (TYPE_SIZE (type
))
10861 TREE_ASM_WRITTEN (type
) = 1;
10862 add_byte_size_attribute (type_die
, type
);
10863 if (TYPE_STUB_DECL (type
) != NULL_TREE
)
10864 add_src_coords_attributes (type_die
, TYPE_STUB_DECL (type
));
10866 /* If the first reference to this type was as the return type of an
10867 inline function, then it may not have a parent. Fix this now. */
10868 if (type_die
->die_parent
== NULL
)
10869 add_child_die (scope_die_for (type
, context_die
), type_die
);
10871 for (link
= TYPE_VALUES (type
);
10872 link
!= NULL
; link
= TREE_CHAIN (link
))
10874 dw_die_ref enum_die
= new_die (DW_TAG_enumerator
, type_die
, link
);
10875 tree value
= TREE_VALUE (link
);
10877 add_name_attribute (enum_die
,
10878 IDENTIFIER_POINTER (TREE_PURPOSE (link
)));
10880 if (host_integerp (value
, TYPE_UNSIGNED (TREE_TYPE (value
))))
10881 /* DWARF2 does not provide a way of indicating whether or
10882 not enumeration constants are signed or unsigned. GDB
10883 always assumes the values are signed, so we output all
10884 values as if they were signed. That means that
10885 enumeration constants with very large unsigned values
10886 will appear to have negative values in the debugger. */
10887 add_AT_int (enum_die
, DW_AT_const_value
,
10888 tree_low_cst (value
, tree_int_cst_sgn (value
) > 0));
10892 add_AT_flag (type_die
, DW_AT_declaration
, 1);
10897 /* Generate a DIE to represent either a real live formal parameter decl or to
10898 represent just the type of some formal parameter position in some function
10901 Note that this routine is a bit unusual because its argument may be a
10902 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
10903 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
10904 node. If it's the former then this function is being called to output a
10905 DIE to represent a formal parameter object (or some inlining thereof). If
10906 it's the latter, then this function is only being called to output a
10907 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
10908 argument type of some subprogram type. */
10911 gen_formal_parameter_die (tree node
, dw_die_ref context_die
)
10913 dw_die_ref parm_die
10914 = new_die (DW_TAG_formal_parameter
, context_die
, node
);
10917 switch (TREE_CODE_CLASS (TREE_CODE (node
)))
10920 origin
= decl_ultimate_origin (node
);
10921 if (origin
!= NULL
)
10922 add_abstract_origin_attribute (parm_die
, origin
);
10925 add_name_and_src_coords_attributes (parm_die
, node
);
10926 add_type_attribute (parm_die
, TREE_TYPE (node
),
10927 TREE_READONLY (node
),
10928 TREE_THIS_VOLATILE (node
),
10930 if (DECL_ARTIFICIAL (node
))
10931 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
10934 equate_decl_number_to_die (node
, parm_die
);
10935 if (! DECL_ABSTRACT (node
))
10936 add_location_or_const_value_attribute (parm_die
, node
, DW_AT_location
);
10941 /* We were called with some kind of a ..._TYPE node. */
10942 add_type_attribute (parm_die
, node
, 0, 0, context_die
);
10946 gcc_unreachable ();
10952 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
10953 at the end of an (ANSI prototyped) formal parameters list. */
10956 gen_unspecified_parameters_die (tree decl_or_type
, dw_die_ref context_die
)
10958 new_die (DW_TAG_unspecified_parameters
, context_die
, decl_or_type
);
10961 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
10962 DW_TAG_unspecified_parameters DIE) to represent the types of the formal
10963 parameters as specified in some function type specification (except for
10964 those which appear as part of a function *definition*). */
10967 gen_formal_types_die (tree function_or_method_type
, dw_die_ref context_die
)
10970 tree formal_type
= NULL
;
10971 tree first_parm_type
;
10974 if (TREE_CODE (function_or_method_type
) == FUNCTION_DECL
)
10976 arg
= DECL_ARGUMENTS (function_or_method_type
);
10977 function_or_method_type
= TREE_TYPE (function_or_method_type
);
10982 first_parm_type
= TYPE_ARG_TYPES (function_or_method_type
);
10984 /* Make our first pass over the list of formal parameter types and output a
10985 DW_TAG_formal_parameter DIE for each one. */
10986 for (link
= first_parm_type
; link
; )
10988 dw_die_ref parm_die
;
10990 formal_type
= TREE_VALUE (link
);
10991 if (formal_type
== void_type_node
)
10994 /* Output a (nameless) DIE to represent the formal parameter itself. */
10995 parm_die
= gen_formal_parameter_die (formal_type
, context_die
);
10996 if ((TREE_CODE (function_or_method_type
) == METHOD_TYPE
10997 && link
== first_parm_type
)
10998 || (arg
&& DECL_ARTIFICIAL (arg
)))
10999 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
11001 link
= TREE_CHAIN (link
);
11003 arg
= TREE_CHAIN (arg
);
11006 /* If this function type has an ellipsis, add a
11007 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */
11008 if (formal_type
!= void_type_node
)
11009 gen_unspecified_parameters_die (function_or_method_type
, context_die
);
11011 /* Make our second (and final) pass over the list of formal parameter types
11012 and output DIEs to represent those types (as necessary). */
11013 for (link
= TYPE_ARG_TYPES (function_or_method_type
);
11014 link
&& TREE_VALUE (link
);
11015 link
= TREE_CHAIN (link
))
11016 gen_type_die (TREE_VALUE (link
), context_die
);
11019 /* We want to generate the DIE for TYPE so that we can generate the
11020 die for MEMBER, which has been defined; we will need to refer back
11021 to the member declaration nested within TYPE. If we're trying to
11022 generate minimal debug info for TYPE, processing TYPE won't do the
11023 trick; we need to attach the member declaration by hand. */
11026 gen_type_die_for_member (tree type
, tree member
, dw_die_ref context_die
)
11028 gen_type_die (type
, context_die
);
11030 /* If we're trying to avoid duplicate debug info, we may not have
11031 emitted the member decl for this function. Emit it now. */
11032 if (TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type
))
11033 && ! lookup_decl_die (member
))
11035 gcc_assert (!decl_ultimate_origin (member
));
11037 push_decl_scope (type
);
11038 if (TREE_CODE (member
) == FUNCTION_DECL
)
11039 gen_subprogram_die (member
, lookup_type_die (type
));
11041 gen_variable_die (member
, lookup_type_die (type
));
11047 /* Generate the DWARF2 info for the "abstract" instance of a function which we
11048 may later generate inlined and/or out-of-line instances of. */
11051 dwarf2out_abstract_function (tree decl
)
11053 dw_die_ref old_die
;
11056 int was_abstract
= DECL_ABSTRACT (decl
);
11058 /* Make sure we have the actual abstract inline, not a clone. */
11059 decl
= DECL_ORIGIN (decl
);
11061 old_die
= lookup_decl_die (decl
);
11062 if (old_die
&& get_AT (old_die
, DW_AT_inline
))
11063 /* We've already generated the abstract instance. */
11066 /* Be sure we've emitted the in-class declaration DIE (if any) first, so
11067 we don't get confused by DECL_ABSTRACT. */
11068 if (debug_info_level
> DINFO_LEVEL_TERSE
)
11070 context
= decl_class_context (decl
);
11072 gen_type_die_for_member
11073 (context
, decl
, decl_function_context (decl
) ? NULL
: comp_unit_die
);
11076 /* Pretend we've just finished compiling this function. */
11077 save_fn
= current_function_decl
;
11078 current_function_decl
= decl
;
11080 set_decl_abstract_flags (decl
, 1);
11081 dwarf2out_decl (decl
);
11082 if (! was_abstract
)
11083 set_decl_abstract_flags (decl
, 0);
11085 current_function_decl
= save_fn
;
11088 /* Generate a DIE to represent a declared function (either file-scope or
11092 gen_subprogram_die (tree decl
, dw_die_ref context_die
)
11094 char label_id
[MAX_ARTIFICIAL_LABEL_BYTES
];
11095 tree origin
= decl_ultimate_origin (decl
);
11096 dw_die_ref subr_die
;
11100 dw_die_ref old_die
= lookup_decl_die (decl
);
11101 int declaration
= (current_function_decl
!= decl
11102 || class_or_namespace_scope_p (context_die
));
11104 /* It is possible to have both DECL_ABSTRACT and DECLARATION be true if we
11105 started to generate the abstract instance of an inline, decided to output
11106 its containing class, and proceeded to emit the declaration of the inline
11107 from the member list for the class. If so, DECLARATION takes priority;
11108 we'll get back to the abstract instance when done with the class. */
11110 /* The class-scope declaration DIE must be the primary DIE. */
11111 if (origin
&& declaration
&& class_or_namespace_scope_p (context_die
))
11114 gcc_assert (!old_die
);
11117 if (origin
!= NULL
)
11119 gcc_assert (!declaration
|| local_scope_p (context_die
));
11121 /* Fixup die_parent for the abstract instance of a nested
11122 inline function. */
11123 if (old_die
&& old_die
->die_parent
== NULL
)
11124 add_child_die (context_die
, old_die
);
11126 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
11127 add_abstract_origin_attribute (subr_die
, origin
);
11131 expanded_location s
= expand_location (DECL_SOURCE_LOCATION (decl
));
11132 unsigned file_index
= lookup_filename (s
.file
);
11134 if (!get_AT_flag (old_die
, DW_AT_declaration
)
11135 /* We can have a normal definition following an inline one in the
11136 case of redefinition of GNU C extern inlines.
11137 It seems reasonable to use AT_specification in this case. */
11138 && !get_AT (old_die
, DW_AT_inline
))
11140 /* ??? This can happen if there is a bug in the program, for
11141 instance, if it has duplicate function definitions. Ideally,
11142 we should detect this case and ignore it. For now, if we have
11143 already reported an error, any error at all, then assume that
11144 we got here because of an input error, not a dwarf2 bug. */
11145 gcc_assert (errorcount
);
11149 /* If the definition comes from the same place as the declaration,
11150 maybe use the old DIE. We always want the DIE for this function
11151 that has the *_pc attributes to be under comp_unit_die so the
11152 debugger can find it. We also need to do this for abstract
11153 instances of inlines, since the spec requires the out-of-line copy
11154 to have the same parent. For local class methods, this doesn't
11155 apply; we just use the old DIE. */
11156 if ((old_die
->die_parent
== comp_unit_die
|| context_die
== NULL
)
11157 && (DECL_ARTIFICIAL (decl
)
11158 || (get_AT_unsigned (old_die
, DW_AT_decl_file
) == file_index
11159 && (get_AT_unsigned (old_die
, DW_AT_decl_line
)
11160 == (unsigned) s
.line
))))
11162 subr_die
= old_die
;
11164 /* Clear out the declaration attribute and the formal parameters.
11165 Do not remove all children, because it is possible that this
11166 declaration die was forced using force_decl_die(). In such
11167 cases die that forced declaration die (e.g. TAG_imported_module)
11168 is one of the children that we do not want to remove. */
11169 remove_AT (subr_die
, DW_AT_declaration
);
11170 remove_child_TAG (subr_die
, DW_TAG_formal_parameter
);
11174 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
11175 add_AT_specification (subr_die
, old_die
);
11176 if (get_AT_unsigned (old_die
, DW_AT_decl_file
) != file_index
)
11177 add_AT_unsigned (subr_die
, DW_AT_decl_file
, file_index
);
11178 if (get_AT_unsigned (old_die
, DW_AT_decl_line
)
11179 != (unsigned) s
.line
)
11181 (subr_die
, DW_AT_decl_line
, s
.line
);
11186 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
11188 if (TREE_PUBLIC (decl
))
11189 add_AT_flag (subr_die
, DW_AT_external
, 1);
11191 add_name_and_src_coords_attributes (subr_die
, decl
);
11192 if (debug_info_level
> DINFO_LEVEL_TERSE
)
11194 add_prototyped_attribute (subr_die
, TREE_TYPE (decl
));
11195 add_type_attribute (subr_die
, TREE_TYPE (TREE_TYPE (decl
)),
11196 0, 0, context_die
);
11199 add_pure_or_virtual_attribute (subr_die
, decl
);
11200 if (DECL_ARTIFICIAL (decl
))
11201 add_AT_flag (subr_die
, DW_AT_artificial
, 1);
11203 if (TREE_PROTECTED (decl
))
11204 add_AT_unsigned (subr_die
, DW_AT_accessibility
, DW_ACCESS_protected
);
11205 else if (TREE_PRIVATE (decl
))
11206 add_AT_unsigned (subr_die
, DW_AT_accessibility
, DW_ACCESS_private
);
11211 if (!old_die
|| !get_AT (old_die
, DW_AT_inline
))
11213 add_AT_flag (subr_die
, DW_AT_declaration
, 1);
11215 /* The first time we see a member function, it is in the context of
11216 the class to which it belongs. We make sure of this by emitting
11217 the class first. The next time is the definition, which is
11218 handled above. The two may come from the same source text.
11220 Note that force_decl_die() forces function declaration die. It is
11221 later reused to represent definition. */
11222 equate_decl_number_to_die (decl
, subr_die
);
11225 else if (DECL_ABSTRACT (decl
))
11227 if (DECL_DECLARED_INLINE_P (decl
))
11229 if (cgraph_function_possibly_inlined_p (decl
))
11230 add_AT_unsigned (subr_die
, DW_AT_inline
, DW_INL_declared_inlined
);
11232 add_AT_unsigned (subr_die
, DW_AT_inline
, DW_INL_declared_not_inlined
);
11236 if (cgraph_function_possibly_inlined_p (decl
))
11237 add_AT_unsigned (subr_die
, DW_AT_inline
, DW_INL_inlined
);
11239 add_AT_unsigned (subr_die
, DW_AT_inline
, DW_INL_not_inlined
);
11242 equate_decl_number_to_die (decl
, subr_die
);
11244 else if (!DECL_EXTERNAL (decl
))
11246 if (!old_die
|| !get_AT (old_die
, DW_AT_inline
))
11247 equate_decl_number_to_die (decl
, subr_die
);
11249 ASM_GENERATE_INTERNAL_LABEL (label_id
, FUNC_BEGIN_LABEL
,
11250 current_function_funcdef_no
);
11251 add_AT_lbl_id (subr_die
, DW_AT_low_pc
, label_id
);
11252 ASM_GENERATE_INTERNAL_LABEL (label_id
, FUNC_END_LABEL
,
11253 current_function_funcdef_no
);
11254 add_AT_lbl_id (subr_die
, DW_AT_high_pc
, label_id
);
11256 add_pubname (decl
, subr_die
);
11257 add_arange (decl
, subr_die
);
11259 #ifdef MIPS_DEBUGGING_INFO
11260 /* Add a reference to the FDE for this routine. */
11261 add_AT_fde_ref (subr_die
, DW_AT_MIPS_fde
, current_funcdef_fde
);
11264 /* Define the "frame base" location for this routine. We use the
11265 frame pointer or stack pointer registers, since the RTL for local
11266 variables is relative to one of them. */
11267 if (frame_base_decl
&& lookup_decl_loc (frame_base_decl
) != NULL
)
11269 add_location_or_const_value_attribute (subr_die
, frame_base_decl
,
11275 = frame_pointer_needed
? hard_frame_pointer_rtx
: stack_pointer_rtx
;
11276 add_AT_loc (subr_die
, DW_AT_frame_base
, reg_loc_descriptor (fp_reg
));
11279 if (cfun
->static_chain_decl
)
11280 add_AT_location_description (subr_die
, DW_AT_static_link
,
11281 loc_descriptor_from_tree (cfun
->static_chain_decl
));
11284 /* Now output descriptions of the arguments for this function. This gets
11285 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
11286 for a FUNCTION_DECL doesn't indicate cases where there was a trailing
11287 `...' at the end of the formal parameter list. In order to find out if
11288 there was a trailing ellipsis or not, we must instead look at the type
11289 associated with the FUNCTION_DECL. This will be a node of type
11290 FUNCTION_TYPE. If the chain of type nodes hanging off of this
11291 FUNCTION_TYPE node ends with a void_type_node then there should *not* be
11292 an ellipsis at the end. */
11294 /* In the case where we are describing a mere function declaration, all we
11295 need to do here (and all we *can* do here) is to describe the *types* of
11296 its formal parameters. */
11297 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
11299 else if (declaration
)
11300 gen_formal_types_die (decl
, subr_die
);
11303 /* Generate DIEs to represent all known formal parameters. */
11304 tree arg_decls
= DECL_ARGUMENTS (decl
);
11307 /* When generating DIEs, generate the unspecified_parameters DIE
11308 instead if we come across the arg "__builtin_va_alist" */
11309 for (parm
= arg_decls
; parm
; parm
= TREE_CHAIN (parm
))
11310 if (TREE_CODE (parm
) == PARM_DECL
)
11312 if (DECL_NAME (parm
)
11313 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (parm
)),
11314 "__builtin_va_alist"))
11315 gen_unspecified_parameters_die (parm
, subr_die
);
11317 gen_decl_die (parm
, subr_die
);
11320 /* Decide whether we need an unspecified_parameters DIE at the end.
11321 There are 2 more cases to do this for: 1) the ansi ... declaration -
11322 this is detectable when the end of the arg list is not a
11323 void_type_node 2) an unprototyped function declaration (not a
11324 definition). This just means that we have no info about the
11325 parameters at all. */
11326 fn_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
11327 if (fn_arg_types
!= NULL
)
11329 /* This is the prototyped case, check for.... */
11330 if (TREE_VALUE (tree_last (fn_arg_types
)) != void_type_node
)
11331 gen_unspecified_parameters_die (decl
, subr_die
);
11333 else if (DECL_INITIAL (decl
) == NULL_TREE
)
11334 gen_unspecified_parameters_die (decl
, subr_die
);
11337 /* Output Dwarf info for all of the stuff within the body of the function
11338 (if it has one - it may be just a declaration). */
11339 outer_scope
= DECL_INITIAL (decl
);
11341 /* OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent
11342 a function. This BLOCK actually represents the outermost binding contour
11343 for the function, i.e. the contour in which the function's formal
11344 parameters and labels get declared. Curiously, it appears that the front
11345 end doesn't actually put the PARM_DECL nodes for the current function onto
11346 the BLOCK_VARS list for this outer scope, but are strung off of the
11347 DECL_ARGUMENTS list for the function instead.
11349 The BLOCK_VARS list for the `outer_scope' does provide us with a list of
11350 the LABEL_DECL nodes for the function however, and we output DWARF info
11351 for those in decls_for_scope. Just within the `outer_scope' there will be
11352 a BLOCK node representing the function's outermost pair of curly braces,
11353 and any blocks used for the base and member initializers of a C++
11354 constructor function. */
11355 if (! declaration
&& TREE_CODE (outer_scope
) != ERROR_MARK
)
11357 /* Emit a DW_TAG_variable DIE for a named return value. */
11358 if (DECL_NAME (DECL_RESULT (decl
)))
11359 gen_decl_die (DECL_RESULT (decl
), subr_die
);
11361 current_function_has_inlines
= 0;
11362 decls_for_scope (outer_scope
, subr_die
, 0);
11364 #if 0 && defined (MIPS_DEBUGGING_INFO)
11365 if (current_function_has_inlines
)
11367 add_AT_flag (subr_die
, DW_AT_MIPS_has_inlines
, 1);
11368 if (! comp_unit_has_inlines
)
11370 add_AT_flag (comp_unit_die
, DW_AT_MIPS_has_inlines
, 1);
11371 comp_unit_has_inlines
= 1;
11378 /* Generate a DIE to represent a declared data object. */
11381 gen_variable_die (tree decl
, dw_die_ref context_die
)
11383 tree origin
= decl_ultimate_origin (decl
);
11384 dw_die_ref var_die
= new_die (DW_TAG_variable
, context_die
, decl
);
11386 dw_die_ref old_die
= lookup_decl_die (decl
);
11387 int declaration
= (DECL_EXTERNAL (decl
)
11388 || class_or_namespace_scope_p (context_die
));
11390 if (origin
!= NULL
)
11391 add_abstract_origin_attribute (var_die
, origin
);
11393 /* Loop unrolling can create multiple blocks that refer to the same
11394 static variable, so we must test for the DW_AT_declaration flag.
11396 ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
11397 copy decls and set the DECL_ABSTRACT flag on them instead of
11400 ??? Duplicated blocks have been rewritten to use .debug_ranges. */
11401 else if (old_die
&& TREE_STATIC (decl
)
11402 && get_AT_flag (old_die
, DW_AT_declaration
) == 1)
11404 /* This is a definition of a C++ class level static. */
11405 add_AT_specification (var_die
, old_die
);
11406 if (DECL_NAME (decl
))
11408 expanded_location s
= expand_location (DECL_SOURCE_LOCATION (decl
));
11409 unsigned file_index
= lookup_filename (s
.file
);
11411 if (get_AT_unsigned (old_die
, DW_AT_decl_file
) != file_index
)
11412 add_AT_unsigned (var_die
, DW_AT_decl_file
, file_index
);
11414 if (get_AT_unsigned (old_die
, DW_AT_decl_line
)
11415 != (unsigned) s
.line
)
11417 add_AT_unsigned (var_die
, DW_AT_decl_line
, s
.line
);
11422 add_name_and_src_coords_attributes (var_die
, decl
);
11423 add_type_attribute (var_die
, TREE_TYPE (decl
), TREE_READONLY (decl
),
11424 TREE_THIS_VOLATILE (decl
), context_die
);
11426 if (TREE_PUBLIC (decl
))
11427 add_AT_flag (var_die
, DW_AT_external
, 1);
11429 if (DECL_ARTIFICIAL (decl
))
11430 add_AT_flag (var_die
, DW_AT_artificial
, 1);
11432 if (TREE_PROTECTED (decl
))
11433 add_AT_unsigned (var_die
, DW_AT_accessibility
, DW_ACCESS_protected
);
11434 else if (TREE_PRIVATE (decl
))
11435 add_AT_unsigned (var_die
, DW_AT_accessibility
, DW_ACCESS_private
);
11439 add_AT_flag (var_die
, DW_AT_declaration
, 1);
11441 if (DECL_ABSTRACT (decl
) || declaration
)
11442 equate_decl_number_to_die (decl
, var_die
);
11444 if (! declaration
&& ! DECL_ABSTRACT (decl
))
11446 add_location_or_const_value_attribute (var_die
, decl
, DW_AT_location
);
11447 add_pubname (decl
, var_die
);
11450 tree_add_const_value_attribute (var_die
, decl
);
11453 /* Generate a DIE to represent a label identifier. */
11456 gen_label_die (tree decl
, dw_die_ref context_die
)
11458 tree origin
= decl_ultimate_origin (decl
);
11459 dw_die_ref lbl_die
= new_die (DW_TAG_label
, context_die
, decl
);
11461 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
11463 if (origin
!= NULL
)
11464 add_abstract_origin_attribute (lbl_die
, origin
);
11466 add_name_and_src_coords_attributes (lbl_die
, decl
);
11468 if (DECL_ABSTRACT (decl
))
11469 equate_decl_number_to_die (decl
, lbl_die
);
11472 insn
= DECL_RTL_IF_SET (decl
);
11474 /* Deleted labels are programmer specified labels which have been
11475 eliminated because of various optimizations. We still emit them
11476 here so that it is possible to put breakpoints on them. */
11480 && NOTE_LINE_NUMBER (insn
) == NOTE_INSN_DELETED_LABEL
))))
11482 /* When optimization is enabled (via -O) some parts of the compiler
11483 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
11484 represent source-level labels which were explicitly declared by
11485 the user. This really shouldn't be happening though, so catch
11486 it if it ever does happen. */
11487 gcc_assert (!INSN_DELETED_P (insn
));
11489 ASM_GENERATE_INTERNAL_LABEL (label
, "L", CODE_LABEL_NUMBER (insn
));
11490 add_AT_lbl_id (lbl_die
, DW_AT_low_pc
, label
);
11495 /* Generate a DIE for a lexical block. */
11498 gen_lexical_block_die (tree stmt
, dw_die_ref context_die
, int depth
)
11500 dw_die_ref stmt_die
= new_die (DW_TAG_lexical_block
, context_die
, stmt
);
11501 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
11503 if (! BLOCK_ABSTRACT (stmt
))
11505 if (BLOCK_FRAGMENT_CHAIN (stmt
))
11509 add_AT_range_list (stmt_die
, DW_AT_ranges
, add_ranges (stmt
));
11511 chain
= BLOCK_FRAGMENT_CHAIN (stmt
);
11514 add_ranges (chain
);
11515 chain
= BLOCK_FRAGMENT_CHAIN (chain
);
11522 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_BEGIN_LABEL
,
11523 BLOCK_NUMBER (stmt
));
11524 add_AT_lbl_id (stmt_die
, DW_AT_low_pc
, label
);
11525 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_END_LABEL
,
11526 BLOCK_NUMBER (stmt
));
11527 add_AT_lbl_id (stmt_die
, DW_AT_high_pc
, label
);
11531 decls_for_scope (stmt
, stmt_die
, depth
);
11534 /* Generate a DIE for an inlined subprogram. */
11537 gen_inlined_subroutine_die (tree stmt
, dw_die_ref context_die
, int depth
)
11539 tree decl
= block_ultimate_origin (stmt
);
11541 /* Emit info for the abstract instance first, if we haven't yet. We
11542 must emit this even if the block is abstract, otherwise when we
11543 emit the block below (or elsewhere), we may end up trying to emit
11544 a die whose origin die hasn't been emitted, and crashing. */
11545 dwarf2out_abstract_function (decl
);
11547 if (! BLOCK_ABSTRACT (stmt
))
11549 dw_die_ref subr_die
11550 = new_die (DW_TAG_inlined_subroutine
, context_die
, stmt
);
11551 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
11553 add_abstract_origin_attribute (subr_die
, decl
);
11554 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_BEGIN_LABEL
,
11555 BLOCK_NUMBER (stmt
));
11556 add_AT_lbl_id (subr_die
, DW_AT_low_pc
, label
);
11557 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_END_LABEL
,
11558 BLOCK_NUMBER (stmt
));
11559 add_AT_lbl_id (subr_die
, DW_AT_high_pc
, label
);
11560 decls_for_scope (stmt
, subr_die
, depth
);
11561 current_function_has_inlines
= 1;
11564 /* We may get here if we're the outer block of function A that was
11565 inlined into function B that was inlined into function C. When
11566 generating debugging info for C, dwarf2out_abstract_function(B)
11567 would mark all inlined blocks as abstract, including this one.
11568 So, we wouldn't (and shouldn't) expect labels to be generated
11569 for this one. Instead, just emit debugging info for
11570 declarations within the block. This is particularly important
11571 in the case of initializers of arguments passed from B to us:
11572 if they're statement expressions containing declarations, we
11573 wouldn't generate dies for their abstract variables, and then,
11574 when generating dies for the real variables, we'd die (pun
11576 gen_lexical_block_die (stmt
, context_die
, depth
);
11579 /* Generate a DIE for a field in a record, or structure. */
11582 gen_field_die (tree decl
, dw_die_ref context_die
)
11584 dw_die_ref decl_die
;
11586 if (TREE_TYPE (decl
) == error_mark_node
)
11589 decl_die
= new_die (DW_TAG_member
, context_die
, decl
);
11590 add_name_and_src_coords_attributes (decl_die
, decl
);
11591 add_type_attribute (decl_die
, member_declared_type (decl
),
11592 TREE_READONLY (decl
), TREE_THIS_VOLATILE (decl
),
11595 if (DECL_BIT_FIELD_TYPE (decl
))
11597 add_byte_size_attribute (decl_die
, decl
);
11598 add_bit_size_attribute (decl_die
, decl
);
11599 add_bit_offset_attribute (decl_die
, decl
);
11602 if (TREE_CODE (DECL_FIELD_CONTEXT (decl
)) != UNION_TYPE
)
11603 add_data_member_location_attribute (decl_die
, decl
);
11605 if (DECL_ARTIFICIAL (decl
))
11606 add_AT_flag (decl_die
, DW_AT_artificial
, 1);
11608 if (TREE_PROTECTED (decl
))
11609 add_AT_unsigned (decl_die
, DW_AT_accessibility
, DW_ACCESS_protected
);
11610 else if (TREE_PRIVATE (decl
))
11611 add_AT_unsigned (decl_die
, DW_AT_accessibility
, DW_ACCESS_private
);
11613 /* Equate decl number to die, so that we can look up this decl later on. */
11614 equate_decl_number_to_die (decl
, decl_die
);
11618 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
11619 Use modified_type_die instead.
11620 We keep this code here just in case these types of DIEs may be needed to
11621 represent certain things in other languages (e.g. Pascal) someday. */
11624 gen_pointer_type_die (tree type
, dw_die_ref context_die
)
11627 = new_die (DW_TAG_pointer_type
, scope_die_for (type
, context_die
), type
);
11629 equate_type_number_to_die (type
, ptr_die
);
11630 add_type_attribute (ptr_die
, TREE_TYPE (type
), 0, 0, context_die
);
11631 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
, PTR_SIZE
);
11634 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
11635 Use modified_type_die instead.
11636 We keep this code here just in case these types of DIEs may be needed to
11637 represent certain things in other languages (e.g. Pascal) someday. */
11640 gen_reference_type_die (tree type
, dw_die_ref context_die
)
11643 = new_die (DW_TAG_reference_type
, scope_die_for (type
, context_die
), type
);
11645 equate_type_number_to_die (type
, ref_die
);
11646 add_type_attribute (ref_die
, TREE_TYPE (type
), 0, 0, context_die
);
11647 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
, PTR_SIZE
);
11651 /* Generate a DIE for a pointer to a member type. */
11654 gen_ptr_to_mbr_type_die (tree type
, dw_die_ref context_die
)
11657 = new_die (DW_TAG_ptr_to_member_type
,
11658 scope_die_for (type
, context_die
), type
);
11660 equate_type_number_to_die (type
, ptr_die
);
11661 add_AT_die_ref (ptr_die
, DW_AT_containing_type
,
11662 lookup_type_die (TYPE_OFFSET_BASETYPE (type
)));
11663 add_type_attribute (ptr_die
, TREE_TYPE (type
), 0, 0, context_die
);
11666 /* Generate the DIE for the compilation unit. */
11669 gen_compile_unit_die (const char *filename
)
11672 char producer
[250];
11673 const char *language_string
= lang_hooks
.name
;
11676 die
= new_die (DW_TAG_compile_unit
, NULL
, NULL
);
11680 add_name_attribute (die
, filename
);
11681 /* Don't add cwd for <built-in>. */
11682 if (filename
[0] != DIR_SEPARATOR
&& filename
[0] != '<')
11683 add_comp_dir_attribute (die
);
11686 sprintf (producer
, "%s %s", language_string
, version_string
);
11688 #ifdef MIPS_DEBUGGING_INFO
11689 /* The MIPS/SGI compilers place the 'cc' command line options in the producer
11690 string. The SGI debugger looks for -g, -g1, -g2, or -g3; if they do
11691 not appear in the producer string, the debugger reaches the conclusion
11692 that the object file is stripped and has no debugging information.
11693 To get the MIPS/SGI debugger to believe that there is debugging
11694 information in the object file, we add a -g to the producer string. */
11695 if (debug_info_level
> DINFO_LEVEL_TERSE
)
11696 strcat (producer
, " -g");
11699 add_AT_string (die
, DW_AT_producer
, producer
);
11701 if (strcmp (language_string
, "GNU C++") == 0)
11702 language
= DW_LANG_C_plus_plus
;
11703 else if (strcmp (language_string
, "GNU Ada") == 0)
11704 language
= DW_LANG_Ada95
;
11705 else if (strcmp (language_string
, "GNU F77") == 0)
11706 language
= DW_LANG_Fortran77
;
11707 else if (strcmp (language_string
, "GNU F95") == 0)
11708 language
= DW_LANG_Fortran95
;
11709 else if (strcmp (language_string
, "GNU Pascal") == 0)
11710 language
= DW_LANG_Pascal83
;
11711 else if (strcmp (language_string
, "GNU Java") == 0)
11712 language
= DW_LANG_Java
;
11714 language
= DW_LANG_C89
;
11716 add_AT_unsigned (die
, DW_AT_language
, language
);
11720 /* Generate a DIE for a string type. */
11723 gen_string_type_die (tree type
, dw_die_ref context_die
)
11725 dw_die_ref type_die
11726 = new_die (DW_TAG_string_type
, scope_die_for (type
, context_die
), type
);
11728 equate_type_number_to_die (type
, type_die
);
11730 /* ??? Fudge the string length attribute for now.
11731 TODO: add string length info. */
11733 string_length_attribute (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)));
11734 bound_representation (upper_bound
, 0, 'u');
11738 /* Generate the DIE for a base class. */
11741 gen_inheritance_die (tree binfo
, tree access
, dw_die_ref context_die
)
11743 dw_die_ref die
= new_die (DW_TAG_inheritance
, context_die
, binfo
);
11745 add_type_attribute (die
, BINFO_TYPE (binfo
), 0, 0, context_die
);
11746 add_data_member_location_attribute (die
, binfo
);
11748 if (BINFO_VIRTUAL_P (binfo
))
11749 add_AT_unsigned (die
, DW_AT_virtuality
, DW_VIRTUALITY_virtual
);
11751 if (access
== access_public_node
)
11752 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_public
);
11753 else if (access
== access_protected_node
)
11754 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_protected
);
11757 /* Generate a DIE for a class member. */
11760 gen_member_die (tree type
, dw_die_ref context_die
)
11763 tree binfo
= TYPE_BINFO (type
);
11766 /* If this is not an incomplete type, output descriptions of each of its
11767 members. Note that as we output the DIEs necessary to represent the
11768 members of this record or union type, we will also be trying to output
11769 DIEs to represent the *types* of those members. However the `type'
11770 function (above) will specifically avoid generating type DIEs for member
11771 types *within* the list of member DIEs for this (containing) type except
11772 for those types (of members) which are explicitly marked as also being
11773 members of this (containing) type themselves. The g++ front- end can
11774 force any given type to be treated as a member of some other (containing)
11775 type by setting the TYPE_CONTEXT of the given (member) type to point to
11776 the TREE node representing the appropriate (containing) type. */
11778 /* First output info about the base classes. */
11781 VEC (tree
) *accesses
= BINFO_BASE_ACCESSES (binfo
);
11785 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base
); i
++)
11786 gen_inheritance_die (base
,
11787 (accesses
? VEC_index (tree
, accesses
, i
)
11788 : access_public_node
), context_die
);
11791 /* Now output info about the data members and type members. */
11792 for (member
= TYPE_FIELDS (type
); member
; member
= TREE_CHAIN (member
))
11794 /* If we thought we were generating minimal debug info for TYPE
11795 and then changed our minds, some of the member declarations
11796 may have already been defined. Don't define them again, but
11797 do put them in the right order. */
11799 child
= lookup_decl_die (member
);
11801 splice_child_die (context_die
, child
);
11803 gen_decl_die (member
, context_die
);
11806 /* Now output info about the function members (if any). */
11807 for (member
= TYPE_METHODS (type
); member
; member
= TREE_CHAIN (member
))
11809 /* Don't include clones in the member list. */
11810 if (DECL_ABSTRACT_ORIGIN (member
))
11813 child
= lookup_decl_die (member
);
11815 splice_child_die (context_die
, child
);
11817 gen_decl_die (member
, context_die
);
11821 /* Generate a DIE for a structure or union type. If TYPE_DECL_SUPPRESS_DEBUG
11822 is set, we pretend that the type was never defined, so we only get the
11823 member DIEs needed by later specification DIEs. */
11826 gen_struct_or_union_type_die (tree type
, dw_die_ref context_die
)
11828 dw_die_ref type_die
= lookup_type_die (type
);
11829 dw_die_ref scope_die
= 0;
11831 int complete
= (TYPE_SIZE (type
)
11832 && (! TYPE_STUB_DECL (type
)
11833 || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type
))));
11834 int ns_decl
= (context_die
&& context_die
->die_tag
== DW_TAG_namespace
);
11836 if (type_die
&& ! complete
)
11839 if (TYPE_CONTEXT (type
) != NULL_TREE
11840 && (AGGREGATE_TYPE_P (TYPE_CONTEXT (type
))
11841 || TREE_CODE (TYPE_CONTEXT (type
)) == NAMESPACE_DECL
))
11844 scope_die
= scope_die_for (type
, context_die
);
11846 if (! type_die
|| (nested
&& scope_die
== comp_unit_die
))
11847 /* First occurrence of type or toplevel definition of nested class. */
11849 dw_die_ref old_die
= type_die
;
11851 type_die
= new_die (TREE_CODE (type
) == RECORD_TYPE
11852 ? DW_TAG_structure_type
: DW_TAG_union_type
,
11854 equate_type_number_to_die (type
, type_die
);
11856 add_AT_specification (type_die
, old_die
);
11858 add_name_attribute (type_die
, type_tag (type
));
11861 remove_AT (type_die
, DW_AT_declaration
);
11863 /* If this type has been completed, then give it a byte_size attribute and
11864 then give a list of members. */
11865 if (complete
&& !ns_decl
)
11867 /* Prevent infinite recursion in cases where the type of some member of
11868 this type is expressed in terms of this type itself. */
11869 TREE_ASM_WRITTEN (type
) = 1;
11870 add_byte_size_attribute (type_die
, type
);
11871 if (TYPE_STUB_DECL (type
) != NULL_TREE
)
11872 add_src_coords_attributes (type_die
, TYPE_STUB_DECL (type
));
11874 /* If the first reference to this type was as the return type of an
11875 inline function, then it may not have a parent. Fix this now. */
11876 if (type_die
->die_parent
== NULL
)
11877 add_child_die (scope_die
, type_die
);
11879 push_decl_scope (type
);
11880 gen_member_die (type
, type_die
);
11883 /* GNU extension: Record what type our vtable lives in. */
11884 if (TYPE_VFIELD (type
))
11886 tree vtype
= DECL_FCONTEXT (TYPE_VFIELD (type
));
11888 gen_type_die (vtype
, context_die
);
11889 add_AT_die_ref (type_die
, DW_AT_containing_type
,
11890 lookup_type_die (vtype
));
11895 add_AT_flag (type_die
, DW_AT_declaration
, 1);
11897 /* We don't need to do this for function-local types. */
11898 if (TYPE_STUB_DECL (type
)
11899 && ! decl_function_context (TYPE_STUB_DECL (type
)))
11900 VARRAY_PUSH_TREE (incomplete_types
, type
);
11904 /* Generate a DIE for a subroutine _type_. */
11907 gen_subroutine_type_die (tree type
, dw_die_ref context_die
)
11909 tree return_type
= TREE_TYPE (type
);
11910 dw_die_ref subr_die
11911 = new_die (DW_TAG_subroutine_type
,
11912 scope_die_for (type
, context_die
), type
);
11914 equate_type_number_to_die (type
, subr_die
);
11915 add_prototyped_attribute (subr_die
, type
);
11916 add_type_attribute (subr_die
, return_type
, 0, 0, context_die
);
11917 gen_formal_types_die (type
, subr_die
);
11920 /* Generate a DIE for a type definition. */
11923 gen_typedef_die (tree decl
, dw_die_ref context_die
)
11925 dw_die_ref type_die
;
11928 if (TREE_ASM_WRITTEN (decl
))
11931 TREE_ASM_WRITTEN (decl
) = 1;
11932 type_die
= new_die (DW_TAG_typedef
, context_die
, decl
);
11933 origin
= decl_ultimate_origin (decl
);
11934 if (origin
!= NULL
)
11935 add_abstract_origin_attribute (type_die
, origin
);
11940 add_name_and_src_coords_attributes (type_die
, decl
);
11941 if (DECL_ORIGINAL_TYPE (decl
))
11943 type
= DECL_ORIGINAL_TYPE (decl
);
11945 gcc_assert (type
!= TREE_TYPE (decl
));
11946 equate_type_number_to_die (TREE_TYPE (decl
), type_die
);
11949 type
= TREE_TYPE (decl
);
11951 add_type_attribute (type_die
, type
, TREE_READONLY (decl
),
11952 TREE_THIS_VOLATILE (decl
), context_die
);
11955 if (DECL_ABSTRACT (decl
))
11956 equate_decl_number_to_die (decl
, type_die
);
11959 /* Generate a type description DIE. */
11962 gen_type_die (tree type
, dw_die_ref context_die
)
11966 if (type
== NULL_TREE
|| type
== error_mark_node
)
11969 if (TYPE_NAME (type
) && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
11970 && DECL_ORIGINAL_TYPE (TYPE_NAME (type
)))
11972 if (TREE_ASM_WRITTEN (type
))
11975 /* Prevent broken recursion; we can't hand off to the same type. */
11976 gcc_assert (DECL_ORIGINAL_TYPE (TYPE_NAME (type
)) != type
);
11978 TREE_ASM_WRITTEN (type
) = 1;
11979 gen_decl_die (TYPE_NAME (type
), context_die
);
11983 /* We are going to output a DIE to represent the unqualified version
11984 of this type (i.e. without any const or volatile qualifiers) so
11985 get the main variant (i.e. the unqualified version) of this type
11986 now. (Vectors are special because the debugging info is in the
11987 cloned type itself). */
11988 if (TREE_CODE (type
) != VECTOR_TYPE
)
11989 type
= type_main_variant (type
);
11991 if (TREE_ASM_WRITTEN (type
))
11994 switch (TREE_CODE (type
))
12000 case REFERENCE_TYPE
:
12001 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This
12002 ensures that the gen_type_die recursion will terminate even if the
12003 type is recursive. Recursive types are possible in Ada. */
12004 /* ??? We could perhaps do this for all types before the switch
12006 TREE_ASM_WRITTEN (type
) = 1;
12008 /* For these types, all that is required is that we output a DIE (or a
12009 set of DIEs) to represent the "basis" type. */
12010 gen_type_die (TREE_TYPE (type
), context_die
);
12014 /* This code is used for C++ pointer-to-data-member types.
12015 Output a description of the relevant class type. */
12016 gen_type_die (TYPE_OFFSET_BASETYPE (type
), context_die
);
12018 /* Output a description of the type of the object pointed to. */
12019 gen_type_die (TREE_TYPE (type
), context_die
);
12021 /* Now output a DIE to represent this pointer-to-data-member type
12023 gen_ptr_to_mbr_type_die (type
, context_die
);
12027 gen_type_die (TYPE_DOMAIN (type
), context_die
);
12028 gen_set_type_die (type
, context_die
);
12032 gen_type_die (TREE_TYPE (type
), context_die
);
12033 /* No way to represent these in Dwarf yet! */
12034 gcc_unreachable ();
12037 case FUNCTION_TYPE
:
12038 /* Force out return type (in case it wasn't forced out already). */
12039 gen_type_die (TREE_TYPE (type
), context_die
);
12040 gen_subroutine_type_die (type
, context_die
);
12044 /* Force out return type (in case it wasn't forced out already). */
12045 gen_type_die (TREE_TYPE (type
), context_die
);
12046 gen_subroutine_type_die (type
, context_die
);
12050 if (TYPE_STRING_FLAG (type
) && TREE_CODE (TREE_TYPE (type
)) == CHAR_TYPE
)
12052 gen_type_die (TREE_TYPE (type
), context_die
);
12053 gen_string_type_die (type
, context_die
);
12056 gen_array_type_die (type
, context_die
);
12060 gen_array_type_die (type
, context_die
);
12063 case ENUMERAL_TYPE
:
12066 case QUAL_UNION_TYPE
:
12067 /* If this is a nested type whose containing class hasn't been written
12068 out yet, writing it out will cover this one, too. This does not apply
12069 to instantiations of member class templates; they need to be added to
12070 the containing class as they are generated. FIXME: This hurts the
12071 idea of combining type decls from multiple TUs, since we can't predict
12072 what set of template instantiations we'll get. */
12073 if (TYPE_CONTEXT (type
)
12074 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type
))
12075 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type
)))
12077 gen_type_die (TYPE_CONTEXT (type
), context_die
);
12079 if (TREE_ASM_WRITTEN (type
))
12082 /* If that failed, attach ourselves to the stub. */
12083 push_decl_scope (TYPE_CONTEXT (type
));
12084 context_die
= lookup_type_die (TYPE_CONTEXT (type
));
12089 declare_in_namespace (type
, context_die
);
12093 if (TREE_CODE (type
) == ENUMERAL_TYPE
)
12094 gen_enumeration_type_die (type
, context_die
);
12096 gen_struct_or_union_type_die (type
, context_die
);
12101 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
12102 it up if it is ever completed. gen_*_type_die will set it for us
12103 when appropriate. */
12112 /* No DIEs needed for fundamental types. */
12116 /* No Dwarf representation currently defined. */
12120 gcc_unreachable ();
12123 TREE_ASM_WRITTEN (type
) = 1;
12126 /* Generate a DIE for a tagged type instantiation. */
12129 gen_tagged_type_instantiation_die (tree type
, dw_die_ref context_die
)
12131 if (type
== NULL_TREE
|| type
== error_mark_node
)
12134 /* We are going to output a DIE to represent the unqualified version of
12135 this type (i.e. without any const or volatile qualifiers) so make sure
12136 that we have the main variant (i.e. the unqualified version) of this
12138 gcc_assert (type
== type_main_variant (type
));
12140 /* Do not check TREE_ASM_WRITTEN (type) as it may not be set if this is
12141 an instance of an unresolved type. */
12143 switch (TREE_CODE (type
))
12148 case ENUMERAL_TYPE
:
12149 gen_inlined_enumeration_type_die (type
, context_die
);
12153 gen_inlined_structure_type_die (type
, context_die
);
12157 case QUAL_UNION_TYPE
:
12158 gen_inlined_union_type_die (type
, context_die
);
12162 gcc_unreachable ();
12166 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
12167 things which are local to the given block. */
12170 gen_block_die (tree stmt
, dw_die_ref context_die
, int depth
)
12172 int must_output_die
= 0;
12175 enum tree_code origin_code
;
12177 /* Ignore blocks never really used to make RTL. */
12178 if (stmt
== NULL_TREE
|| !TREE_USED (stmt
)
12179 || (!TREE_ASM_WRITTEN (stmt
) && !BLOCK_ABSTRACT (stmt
)))
12182 /* If the block is one fragment of a non-contiguous block, do not
12183 process the variables, since they will have been done by the
12184 origin block. Do process subblocks. */
12185 if (BLOCK_FRAGMENT_ORIGIN (stmt
))
12189 for (sub
= BLOCK_SUBBLOCKS (stmt
); sub
; sub
= BLOCK_CHAIN (sub
))
12190 gen_block_die (sub
, context_die
, depth
+ 1);
12195 /* Determine the "ultimate origin" of this block. This block may be an
12196 inlined instance of an inlined instance of inline function, so we have
12197 to trace all of the way back through the origin chain to find out what
12198 sort of node actually served as the original seed for the creation of
12199 the current block. */
12200 origin
= block_ultimate_origin (stmt
);
12201 origin_code
= (origin
!= NULL
) ? TREE_CODE (origin
) : ERROR_MARK
;
12203 /* Determine if we need to output any Dwarf DIEs at all to represent this
12205 if (origin_code
== FUNCTION_DECL
)
12206 /* The outer scopes for inlinings *must* always be represented. We
12207 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */
12208 must_output_die
= 1;
12211 /* In the case where the current block represents an inlining of the
12212 "body block" of an inline function, we must *NOT* output any DIE for
12213 this block because we have already output a DIE to represent the whole
12214 inlined function scope and the "body block" of any function doesn't
12215 really represent a different scope according to ANSI C rules. So we
12216 check here to make sure that this block does not represent a "body
12217 block inlining" before trying to set the MUST_OUTPUT_DIE flag. */
12218 if (! is_body_block (origin
? origin
: stmt
))
12220 /* Determine if this block directly contains any "significant"
12221 local declarations which we will need to output DIEs for. */
12222 if (debug_info_level
> DINFO_LEVEL_TERSE
)
12223 /* We are not in terse mode so *any* local declaration counts
12224 as being a "significant" one. */
12225 must_output_die
= (BLOCK_VARS (stmt
) != NULL
);
12227 /* We are in terse mode, so only local (nested) function
12228 definitions count as "significant" local declarations. */
12229 for (decl
= BLOCK_VARS (stmt
);
12230 decl
!= NULL
; decl
= TREE_CHAIN (decl
))
12231 if (TREE_CODE (decl
) == FUNCTION_DECL
12232 && DECL_INITIAL (decl
))
12234 must_output_die
= 1;
12240 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
12241 DIE for any block which contains no significant local declarations at
12242 all. Rather, in such cases we just call `decls_for_scope' so that any
12243 needed Dwarf info for any sub-blocks will get properly generated. Note
12244 that in terse mode, our definition of what constitutes a "significant"
12245 local declaration gets restricted to include only inlined function
12246 instances and local (nested) function definitions. */
12247 if (must_output_die
)
12249 if (origin_code
== FUNCTION_DECL
)
12250 gen_inlined_subroutine_die (stmt
, context_die
, depth
);
12252 gen_lexical_block_die (stmt
, context_die
, depth
);
12255 decls_for_scope (stmt
, context_die
, depth
);
12258 /* Generate all of the decls declared within a given scope and (recursively)
12259 all of its sub-blocks. */
12262 decls_for_scope (tree stmt
, dw_die_ref context_die
, int depth
)
12267 /* Ignore blocks never really used to make RTL. */
12268 if (stmt
== NULL_TREE
|| ! TREE_USED (stmt
))
12271 /* Output the DIEs to represent all of the data objects and typedefs
12272 declared directly within this block but not within any nested
12273 sub-blocks. Also, nested function and tag DIEs have been
12274 generated with a parent of NULL; fix that up now. */
12275 for (decl
= BLOCK_VARS (stmt
); decl
!= NULL
; decl
= TREE_CHAIN (decl
))
12279 if (TREE_CODE (decl
) == FUNCTION_DECL
)
12280 die
= lookup_decl_die (decl
);
12281 else if (TREE_CODE (decl
) == TYPE_DECL
&& TYPE_DECL_IS_STUB (decl
))
12282 die
= lookup_type_die (TREE_TYPE (decl
));
12286 if (die
!= NULL
&& die
->die_parent
== NULL
)
12287 add_child_die (context_die
, die
);
12289 gen_decl_die (decl
, context_die
);
12292 /* If we're at -g1, we're not interested in subblocks. */
12293 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
12296 /* Output the DIEs to represent all sub-blocks (and the items declared
12297 therein) of this block. */
12298 for (subblocks
= BLOCK_SUBBLOCKS (stmt
);
12300 subblocks
= BLOCK_CHAIN (subblocks
))
12301 gen_block_die (subblocks
, context_die
, depth
+ 1);
12304 /* Is this a typedef we can avoid emitting? */
12307 is_redundant_typedef (tree decl
)
12309 if (TYPE_DECL_IS_STUB (decl
))
12312 if (DECL_ARTIFICIAL (decl
)
12313 && DECL_CONTEXT (decl
)
12314 && is_tagged_type (DECL_CONTEXT (decl
))
12315 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl
))) == TYPE_DECL
12316 && DECL_NAME (decl
) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl
))))
12317 /* Also ignore the artificial member typedef for the class name. */
12323 /* Returns the DIE for decl or aborts. */
12326 force_decl_die (tree decl
)
12328 dw_die_ref decl_die
;
12329 unsigned saved_external_flag
;
12330 tree save_fn
= NULL_TREE
;
12331 decl_die
= lookup_decl_die (decl
);
12334 dw_die_ref context_die
;
12335 tree decl_context
= DECL_CONTEXT (decl
);
12338 /* Find die that represents this context. */
12339 if (TYPE_P (decl_context
))
12340 context_die
= force_type_die (decl_context
);
12342 context_die
= force_decl_die (decl_context
);
12345 context_die
= comp_unit_die
;
12347 switch (TREE_CODE (decl
))
12349 case FUNCTION_DECL
:
12350 /* Clear current_function_decl, so that gen_subprogram_die thinks
12351 that this is a declaration. At this point, we just want to force
12352 declaration die. */
12353 save_fn
= current_function_decl
;
12354 current_function_decl
= NULL_TREE
;
12355 gen_subprogram_die (decl
, context_die
);
12356 current_function_decl
= save_fn
;
12360 /* Set external flag to force declaration die. Restore it after
12361 gen_decl_die() call. */
12362 saved_external_flag
= DECL_EXTERNAL (decl
);
12363 DECL_EXTERNAL (decl
) = 1;
12364 gen_decl_die (decl
, context_die
);
12365 DECL_EXTERNAL (decl
) = saved_external_flag
;
12368 case NAMESPACE_DECL
:
12369 dwarf2out_decl (decl
);
12373 gcc_unreachable ();
12376 /* See if we can find the die for this deci now.
12377 If not then abort. */
12379 decl_die
= lookup_decl_die (decl
);
12380 gcc_assert (decl_die
);
12386 /* Returns the DIE for decl or aborts. */
12389 force_type_die (tree type
)
12391 dw_die_ref type_die
;
12393 type_die
= lookup_type_die (type
);
12396 dw_die_ref context_die
;
12397 if (TYPE_CONTEXT (type
))
12398 if (TYPE_P (TYPE_CONTEXT (type
)))
12399 context_die
= force_type_die (TYPE_CONTEXT (type
));
12401 context_die
= force_decl_die (TYPE_CONTEXT (type
));
12403 context_die
= comp_unit_die
;
12405 gen_type_die (type
, context_die
);
12406 type_die
= lookup_type_die (type
);
12407 gcc_assert (type_die
);
12412 /* Force out any required namespaces to be able to output DECL,
12413 and return the new context_die for it, if it's changed. */
12416 setup_namespace_context (tree thing
, dw_die_ref context_die
)
12418 tree context
= DECL_P (thing
) ? DECL_CONTEXT (thing
) : TYPE_CONTEXT (thing
);
12419 if (context
&& TREE_CODE (context
) == NAMESPACE_DECL
)
12420 /* Force out the namespace. */
12421 context_die
= force_decl_die (context
);
12423 return context_die
;
12426 /* Emit a declaration DIE for THING (which is either a DECL or a tagged
12427 type) within its namespace, if appropriate.
12429 For compatibility with older debuggers, namespace DIEs only contain
12430 declarations; all definitions are emitted at CU scope. */
12433 declare_in_namespace (tree thing
, dw_die_ref context_die
)
12435 dw_die_ref ns_context
;
12437 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
12440 ns_context
= setup_namespace_context (thing
, context_die
);
12442 if (ns_context
!= context_die
)
12444 if (DECL_P (thing
))
12445 gen_decl_die (thing
, ns_context
);
12447 gen_type_die (thing
, ns_context
);
12451 /* Generate a DIE for a namespace or namespace alias. */
12454 gen_namespace_die (tree decl
)
12456 dw_die_ref context_die
= setup_namespace_context (decl
, comp_unit_die
);
12458 /* Namespace aliases have a DECL_ABSTRACT_ORIGIN of the namespace
12459 they are an alias of. */
12460 if (DECL_ABSTRACT_ORIGIN (decl
) == NULL
)
12462 /* Output a real namespace. */
12463 dw_die_ref namespace_die
12464 = new_die (DW_TAG_namespace
, context_die
, decl
);
12465 add_name_and_src_coords_attributes (namespace_die
, decl
);
12466 equate_decl_number_to_die (decl
, namespace_die
);
12470 /* Output a namespace alias. */
12472 /* Force out the namespace we are an alias of, if necessary. */
12473 dw_die_ref origin_die
12474 = force_decl_die (DECL_ABSTRACT_ORIGIN (decl
));
12476 /* Now create the namespace alias DIE. */
12477 dw_die_ref namespace_die
12478 = new_die (DW_TAG_imported_declaration
, context_die
, decl
);
12479 add_name_and_src_coords_attributes (namespace_die
, decl
);
12480 add_AT_die_ref (namespace_die
, DW_AT_import
, origin_die
);
12481 equate_decl_number_to_die (decl
, namespace_die
);
12485 /* Generate Dwarf debug information for a decl described by DECL. */
12488 gen_decl_die (tree decl
, dw_die_ref context_die
)
12492 if (DECL_P (decl
) && DECL_IGNORED_P (decl
))
12495 switch (TREE_CODE (decl
))
12501 /* The individual enumerators of an enum type get output when we output
12502 the Dwarf representation of the relevant enum type itself. */
12505 case FUNCTION_DECL
:
12506 /* Don't output any DIEs to represent mere function declarations,
12507 unless they are class members or explicit block externs. */
12508 if (DECL_INITIAL (decl
) == NULL_TREE
&& DECL_CONTEXT (decl
) == NULL_TREE
12509 && (current_function_decl
== NULL_TREE
|| DECL_ARTIFICIAL (decl
)))
12514 /* This doesn't work because the C frontend sets DECL_ABSTRACT_ORIGIN
12515 on local redeclarations of global functions. That seems broken. */
12516 if (current_function_decl
!= decl
)
12517 /* This is only a declaration. */;
12520 /* If we're emitting a clone, emit info for the abstract instance. */
12521 if (DECL_ORIGIN (decl
) != decl
)
12522 dwarf2out_abstract_function (DECL_ABSTRACT_ORIGIN (decl
));
12524 /* If we're emitting an out-of-line copy of an inline function,
12525 emit info for the abstract instance and set up to refer to it. */
12526 else if (cgraph_function_possibly_inlined_p (decl
)
12527 && ! DECL_ABSTRACT (decl
)
12528 && ! class_or_namespace_scope_p (context_die
)
12529 /* dwarf2out_abstract_function won't emit a die if this is just
12530 a declaration. We must avoid setting DECL_ABSTRACT_ORIGIN in
12531 that case, because that works only if we have a die. */
12532 && DECL_INITIAL (decl
) != NULL_TREE
)
12534 dwarf2out_abstract_function (decl
);
12535 set_decl_origin_self (decl
);
12538 /* Otherwise we're emitting the primary DIE for this decl. */
12539 else if (debug_info_level
> DINFO_LEVEL_TERSE
)
12541 /* Before we describe the FUNCTION_DECL itself, make sure that we
12542 have described its return type. */
12543 gen_type_die (TREE_TYPE (TREE_TYPE (decl
)), context_die
);
12545 /* And its virtual context. */
12546 if (DECL_VINDEX (decl
) != NULL_TREE
)
12547 gen_type_die (DECL_CONTEXT (decl
), context_die
);
12549 /* And its containing type. */
12550 origin
= decl_class_context (decl
);
12551 if (origin
!= NULL_TREE
)
12552 gen_type_die_for_member (origin
, decl
, context_die
);
12554 /* And its containing namespace. */
12555 declare_in_namespace (decl
, context_die
);
12558 /* Now output a DIE to represent the function itself. */
12559 gen_subprogram_die (decl
, context_die
);
12563 /* If we are in terse mode, don't generate any DIEs to represent any
12564 actual typedefs. */
12565 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
12568 /* In the special case of a TYPE_DECL node representing the declaration
12569 of some type tag, if the given TYPE_DECL is marked as having been
12570 instantiated from some other (original) TYPE_DECL node (e.g. one which
12571 was generated within the original definition of an inline function) we
12572 have to generate a special (abbreviated) DW_TAG_structure_type,
12573 DW_TAG_union_type, or DW_TAG_enumeration_type DIE here. */
12574 if (TYPE_DECL_IS_STUB (decl
) && decl_ultimate_origin (decl
) != NULL_TREE
)
12576 gen_tagged_type_instantiation_die (TREE_TYPE (decl
), context_die
);
12580 if (is_redundant_typedef (decl
))
12581 gen_type_die (TREE_TYPE (decl
), context_die
);
12583 /* Output a DIE to represent the typedef itself. */
12584 gen_typedef_die (decl
, context_die
);
12588 if (debug_info_level
>= DINFO_LEVEL_NORMAL
)
12589 gen_label_die (decl
, context_die
);
12594 /* If we are in terse mode, don't generate any DIEs to represent any
12595 variable declarations or definitions. */
12596 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
12599 /* Output any DIEs that are needed to specify the type of this data
12601 gen_type_die (TREE_TYPE (decl
), context_die
);
12603 /* And its containing type. */
12604 origin
= decl_class_context (decl
);
12605 if (origin
!= NULL_TREE
)
12606 gen_type_die_for_member (origin
, decl
, context_die
);
12608 /* And its containing namespace. */
12609 declare_in_namespace (decl
, context_die
);
12611 /* Now output the DIE to represent the data object itself. This gets
12612 complicated because of the possibility that the VAR_DECL really
12613 represents an inlined instance of a formal parameter for an inline
12615 origin
= decl_ultimate_origin (decl
);
12616 if (origin
!= NULL_TREE
&& TREE_CODE (origin
) == PARM_DECL
)
12617 gen_formal_parameter_die (decl
, context_die
);
12619 gen_variable_die (decl
, context_die
);
12623 /* Ignore the nameless fields that are used to skip bits but handle C++
12624 anonymous unions and structs. */
12625 if (DECL_NAME (decl
) != NULL_TREE
12626 || TREE_CODE (TREE_TYPE (decl
)) == UNION_TYPE
12627 || TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
)
12629 gen_type_die (member_declared_type (decl
), context_die
);
12630 gen_field_die (decl
, context_die
);
12635 gen_type_die (TREE_TYPE (decl
), context_die
);
12636 gen_formal_parameter_die (decl
, context_die
);
12639 case NAMESPACE_DECL
:
12640 gen_namespace_die (decl
);
12644 /* Probably some frontend-internal decl. Assume we don't care. */
12645 gcc_assert ((int)TREE_CODE (decl
) > NUM_TREE_CODES
);
12650 /* Add Ada "use" clause information for SGI Workshop debugger. */
12653 dwarf2out_add_library_unit_info (const char *filename
, const char *context_list
)
12655 unsigned int file_index
;
12657 if (filename
!= NULL
)
12659 dw_die_ref unit_die
= new_die (DW_TAG_module
, comp_unit_die
, NULL
);
12660 tree context_list_decl
12661 = build_decl (LABEL_DECL
, get_identifier (context_list
),
12664 TREE_PUBLIC (context_list_decl
) = TRUE
;
12665 add_name_attribute (unit_die
, context_list
);
12666 file_index
= lookup_filename (filename
);
12667 add_AT_unsigned (unit_die
, DW_AT_decl_file
, file_index
);
12668 add_pubname (context_list_decl
, unit_die
);
12672 /* Output debug information for global decl DECL. Called from toplev.c after
12673 compilation proper has finished. */
12676 dwarf2out_global_decl (tree decl
)
12678 /* Output DWARF2 information for file-scope tentative data object
12679 declarations, file-scope (extern) function declarations (which had no
12680 corresponding body) and file-scope tagged type declarations and
12681 definitions which have not yet been forced out. */
12682 if (TREE_CODE (decl
) != FUNCTION_DECL
|| !DECL_INITIAL (decl
))
12683 dwarf2out_decl (decl
);
12686 /* Output debug information for type decl DECL. Called from toplev.c
12687 and from language front ends (to record built-in types). */
12689 dwarf2out_type_decl (tree decl
, int local
)
12692 dwarf2out_decl (decl
);
12695 /* Output debug information for imported module or decl. */
12698 dwarf2out_imported_module_or_decl (tree decl
, tree context
)
12700 dw_die_ref imported_die
, at_import_die
;
12701 dw_die_ref scope_die
;
12702 unsigned file_index
;
12703 expanded_location xloc
;
12705 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
12710 /* To emit DW_TAG_imported_module or DW_TAG_imported_decl, we need two DIEs.
12711 We need decl DIE for reference and scope die. First, get DIE for the decl
12714 /* Get the scope die for decl context. Use comp_unit_die for global module
12715 or decl. If die is not found for non globals, force new die. */
12717 scope_die
= comp_unit_die
;
12718 else if (TYPE_P (context
))
12719 scope_die
= force_type_die (context
);
12721 scope_die
= force_decl_die (context
);
12723 /* For TYPE_DECL or CONST_DECL, lookup TREE_TYPE. */
12724 if (TREE_CODE (decl
) == TYPE_DECL
|| TREE_CODE (decl
) == CONST_DECL
)
12725 at_import_die
= force_type_die (TREE_TYPE (decl
));
12727 at_import_die
= force_decl_die (decl
);
12729 /* OK, now we have DIEs for decl as well as scope. Emit imported die. */
12730 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
12731 imported_die
= new_die (DW_TAG_imported_module
, scope_die
, context
);
12733 imported_die
= new_die (DW_TAG_imported_declaration
, scope_die
, context
);
12735 xloc
= expand_location (input_location
);
12736 file_index
= lookup_filename (xloc
.file
);
12737 add_AT_unsigned (imported_die
, DW_AT_decl_file
, file_index
);
12738 add_AT_unsigned (imported_die
, DW_AT_decl_line
, xloc
.line
);
12739 add_AT_die_ref (imported_die
, DW_AT_import
, at_import_die
);
12742 /* Write the debugging output for DECL. */
12745 dwarf2out_decl (tree decl
)
12747 dw_die_ref context_die
= comp_unit_die
;
12749 switch (TREE_CODE (decl
))
12754 case FUNCTION_DECL
:
12755 /* What we would really like to do here is to filter out all mere
12756 file-scope declarations of file-scope functions which are never
12757 referenced later within this translation unit (and keep all of ones
12758 that *are* referenced later on) but we aren't clairvoyant, so we have
12759 no idea which functions will be referenced in the future (i.e. later
12760 on within the current translation unit). So here we just ignore all
12761 file-scope function declarations which are not also definitions. If
12762 and when the debugger needs to know something about these functions,
12763 it will have to hunt around and find the DWARF information associated
12764 with the definition of the function.
12766 We can't just check DECL_EXTERNAL to find out which FUNCTION_DECL
12767 nodes represent definitions and which ones represent mere
12768 declarations. We have to check DECL_INITIAL instead. That's because
12769 the C front-end supports some weird semantics for "extern inline"
12770 function definitions. These can get inlined within the current
12771 translation unit (an thus, we need to generate Dwarf info for their
12772 abstract instances so that the Dwarf info for the concrete inlined
12773 instances can have something to refer to) but the compiler never
12774 generates any out-of-lines instances of such things (despite the fact
12775 that they *are* definitions).
12777 The important point is that the C front-end marks these "extern
12778 inline" functions as DECL_EXTERNAL, but we need to generate DWARF for
12779 them anyway. Note that the C++ front-end also plays some similar games
12780 for inline function definitions appearing within include files which
12781 also contain `#pragma interface' pragmas. */
12782 if (DECL_INITIAL (decl
) == NULL_TREE
)
12785 /* If we're a nested function, initially use a parent of NULL; if we're
12786 a plain function, this will be fixed up in decls_for_scope. If
12787 we're a method, it will be ignored, since we already have a DIE. */
12788 if (decl_function_context (decl
)
12789 /* But if we're in terse mode, we don't care about scope. */
12790 && debug_info_level
> DINFO_LEVEL_TERSE
)
12791 context_die
= NULL
;
12795 /* Ignore this VAR_DECL if it refers to a file-scope extern data object
12796 declaration and if the declaration was never even referenced from
12797 within this entire compilation unit. We suppress these DIEs in
12798 order to save space in the .debug section (by eliminating entries
12799 which are probably useless). Note that we must not suppress
12800 block-local extern declarations (whether used or not) because that
12801 would screw-up the debugger's name lookup mechanism and cause it to
12802 miss things which really ought to be in scope at a given point. */
12803 if (DECL_EXTERNAL (decl
) && !TREE_USED (decl
))
12806 /* If we are in terse mode, don't generate any DIEs to represent any
12807 variable declarations or definitions. */
12808 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
12812 case NAMESPACE_DECL
:
12813 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
12815 if (lookup_decl_die (decl
) != NULL
)
12820 /* Don't emit stubs for types unless they are needed by other DIEs. */
12821 if (TYPE_DECL_SUPPRESS_DEBUG (decl
))
12824 /* Don't bother trying to generate any DIEs to represent any of the
12825 normal built-in types for the language we are compiling. */
12826 if (DECL_IS_BUILTIN (decl
))
12828 /* OK, we need to generate one for `bool' so GDB knows what type
12829 comparisons have. */
12830 if ((get_AT_unsigned (comp_unit_die
, DW_AT_language
)
12831 == DW_LANG_C_plus_plus
)
12832 && TREE_CODE (TREE_TYPE (decl
)) == BOOLEAN_TYPE
12833 && ! DECL_IGNORED_P (decl
))
12834 modified_type_die (TREE_TYPE (decl
), 0, 0, NULL
);
12839 /* If we are in terse mode, don't generate any DIEs for types. */
12840 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
12843 /* If we're a function-scope tag, initially use a parent of NULL;
12844 this will be fixed up in decls_for_scope. */
12845 if (decl_function_context (decl
))
12846 context_die
= NULL
;
12854 gen_decl_die (decl
, context_die
);
12857 /* Output a marker (i.e. a label) for the beginning of the generated code for
12858 a lexical block. */
12861 dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED
,
12862 unsigned int blocknum
)
12864 function_section (current_function_decl
);
12865 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, BLOCK_BEGIN_LABEL
, blocknum
);
12868 /* Output a marker (i.e. a label) for the end of the generated code for a
12872 dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED
, unsigned int blocknum
)
12874 function_section (current_function_decl
);
12875 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, BLOCK_END_LABEL
, blocknum
);
12878 /* Returns nonzero if it is appropriate not to emit any debugging
12879 information for BLOCK, because it doesn't contain any instructions.
12881 Don't allow this for blocks with nested functions or local classes
12882 as we would end up with orphans, and in the presence of scheduling
12883 we may end up calling them anyway. */
12886 dwarf2out_ignore_block (tree block
)
12890 for (decl
= BLOCK_VARS (block
); decl
; decl
= TREE_CHAIN (decl
))
12891 if (TREE_CODE (decl
) == FUNCTION_DECL
12892 || (TREE_CODE (decl
) == TYPE_DECL
&& TYPE_DECL_IS_STUB (decl
)))
12898 /* Lookup FILE_NAME (in the list of filenames that we know about here in
12899 dwarf2out.c) and return its "index". The index of each (known) filename is
12900 just a unique number which is associated with only that one filename. We
12901 need such numbers for the sake of generating labels (in the .debug_sfnames
12902 section) and references to those files numbers (in the .debug_srcinfo
12903 and.debug_macinfo sections). If the filename given as an argument is not
12904 found in our current list, add it to the list and assign it the next
12905 available unique index number. In order to speed up searches, we remember
12906 the index of the filename was looked up last. This handles the majority of
12910 lookup_filename (const char *file_name
)
12913 char *save_file_name
;
12915 /* Check to see if the file name that was searched on the previous
12916 call matches this file name. If so, return the index. */
12917 if (file_table_last_lookup_index
!= 0)
12920 = VARRAY_CHAR_PTR (file_table
, file_table_last_lookup_index
);
12921 if (strcmp (file_name
, last
) == 0)
12922 return file_table_last_lookup_index
;
12925 /* Didn't match the previous lookup, search the table */
12926 n
= VARRAY_ACTIVE_SIZE (file_table
);
12927 for (i
= 1; i
< n
; i
++)
12928 if (strcmp (file_name
, VARRAY_CHAR_PTR (file_table
, i
)) == 0)
12930 file_table_last_lookup_index
= i
;
12934 /* Add the new entry to the end of the filename table. */
12935 file_table_last_lookup_index
= n
;
12936 save_file_name
= (char *) ggc_strdup (file_name
);
12937 VARRAY_PUSH_CHAR_PTR (file_table
, save_file_name
);
12938 VARRAY_PUSH_UINT (file_table_emitted
, 0);
12944 maybe_emit_file (int fileno
)
12946 if (DWARF2_ASM_LINE_DEBUG_INFO
&& fileno
> 0)
12948 if (!VARRAY_UINT (file_table_emitted
, fileno
))
12950 VARRAY_UINT (file_table_emitted
, fileno
) = ++emitcount
;
12951 fprintf (asm_out_file
, "\t.file %u ",
12952 VARRAY_UINT (file_table_emitted
, fileno
));
12953 output_quoted_string (asm_out_file
,
12954 VARRAY_CHAR_PTR (file_table
, fileno
));
12955 fputc ('\n', asm_out_file
);
12957 return VARRAY_UINT (file_table_emitted
, fileno
);
12964 init_file_table (void)
12966 /* Allocate the initial hunk of the file_table. */
12967 VARRAY_CHAR_PTR_INIT (file_table
, 64, "file_table");
12968 VARRAY_UINT_INIT (file_table_emitted
, 64, "file_table_emitted");
12970 /* Skip the first entry - file numbers begin at 1. */
12971 VARRAY_PUSH_CHAR_PTR (file_table
, NULL
);
12972 VARRAY_PUSH_UINT (file_table_emitted
, 0);
12973 file_table_last_lookup_index
= 0;
12976 /* Called by the final INSN scan whenever we see a var location. We
12977 use it to drop labels in the right places, and throw the location in
12978 our lookup table. */
12981 dwarf2out_var_location (rtx loc_note
)
12983 char loclabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
12984 struct var_loc_node
*newloc
;
12986 static rtx last_insn
;
12987 static const char *last_label
;
12989 if (!DECL_P (NOTE_VAR_LOCATION_DECL (loc_note
)))
12991 prev_insn
= PREV_INSN (loc_note
);
12993 newloc
= ggc_alloc_cleared (sizeof (struct var_loc_node
));
12994 /* If the insn we processed last time is the previous insn
12995 and it is also a var location note, use the label we emitted
12997 if (last_insn
!= NULL_RTX
12998 && last_insn
== prev_insn
12999 && NOTE_P (prev_insn
)
13000 && NOTE_LINE_NUMBER (prev_insn
) == NOTE_INSN_VAR_LOCATION
)
13002 newloc
->label
= last_label
;
13006 ASM_GENERATE_INTERNAL_LABEL (loclabel
, "LVL", loclabel_num
);
13007 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, "LVL", loclabel_num
);
13009 newloc
->label
= ggc_strdup (loclabel
);
13011 newloc
->var_loc_note
= loc_note
;
13012 newloc
->next
= NULL
;
13014 last_insn
= loc_note
;
13015 last_label
= newloc
->label
;
13017 add_var_loc_to_decl (NOTE_VAR_LOCATION_DECL (loc_note
), newloc
);
13020 /* We need to reset the locations at the beginning of each
13021 function. We can't do this in the end_function hook, because the
13022 declarations that use the locations won't have been outputted when
13023 that hook is called. */
13026 dwarf2out_begin_function (tree unused ATTRIBUTE_UNUSED
)
13028 htab_empty (decl_loc_table
);
13031 /* Output a label to mark the beginning of a source code line entry
13032 and record information relating to this source line, in
13033 'line_info_table' for later output of the .debug_line section. */
13036 dwarf2out_source_line (unsigned int line
, const char *filename
)
13038 if (debug_info_level
>= DINFO_LEVEL_NORMAL
13041 function_section (current_function_decl
);
13043 /* If requested, emit something human-readable. */
13044 if (flag_debug_asm
)
13045 fprintf (asm_out_file
, "\t%s %s:%d\n", ASM_COMMENT_START
,
13048 if (DWARF2_ASM_LINE_DEBUG_INFO
)
13050 unsigned file_num
= lookup_filename (filename
);
13052 file_num
= maybe_emit_file (file_num
);
13054 /* Emit the .loc directive understood by GNU as. */
13055 fprintf (asm_out_file
, "\t.loc %d %d 0\n", file_num
, line
);
13057 /* Indicate that line number info exists. */
13058 line_info_table_in_use
++;
13060 /* Indicate that multiple line number tables exist. */
13061 if (DECL_SECTION_NAME (current_function_decl
))
13062 separate_line_info_table_in_use
++;
13064 else if (DECL_SECTION_NAME (current_function_decl
))
13066 dw_separate_line_info_ref line_info
;
13067 targetm
.asm_out
.internal_label (asm_out_file
, SEPARATE_LINE_CODE_LABEL
,
13068 separate_line_info_table_in_use
);
13070 /* Expand the line info table if necessary. */
13071 if (separate_line_info_table_in_use
13072 == separate_line_info_table_allocated
)
13074 separate_line_info_table_allocated
+= LINE_INFO_TABLE_INCREMENT
;
13075 separate_line_info_table
13076 = ggc_realloc (separate_line_info_table
,
13077 separate_line_info_table_allocated
13078 * sizeof (dw_separate_line_info_entry
));
13079 memset (separate_line_info_table
13080 + separate_line_info_table_in_use
,
13082 (LINE_INFO_TABLE_INCREMENT
13083 * sizeof (dw_separate_line_info_entry
)));
13086 /* Add the new entry at the end of the line_info_table. */
13088 = &separate_line_info_table
[separate_line_info_table_in_use
++];
13089 line_info
->dw_file_num
= lookup_filename (filename
);
13090 line_info
->dw_line_num
= line
;
13091 line_info
->function
= current_function_funcdef_no
;
13095 dw_line_info_ref line_info
;
13097 targetm
.asm_out
.internal_label (asm_out_file
, LINE_CODE_LABEL
,
13098 line_info_table_in_use
);
13100 /* Expand the line info table if necessary. */
13101 if (line_info_table_in_use
== line_info_table_allocated
)
13103 line_info_table_allocated
+= LINE_INFO_TABLE_INCREMENT
;
13105 = ggc_realloc (line_info_table
,
13106 (line_info_table_allocated
13107 * sizeof (dw_line_info_entry
)));
13108 memset (line_info_table
+ line_info_table_in_use
, 0,
13109 LINE_INFO_TABLE_INCREMENT
* sizeof (dw_line_info_entry
));
13112 /* Add the new entry at the end of the line_info_table. */
13113 line_info
= &line_info_table
[line_info_table_in_use
++];
13114 line_info
->dw_file_num
= lookup_filename (filename
);
13115 line_info
->dw_line_num
= line
;
13120 /* Record the beginning of a new source file. */
13123 dwarf2out_start_source_file (unsigned int lineno
, const char *filename
)
13125 if (flag_eliminate_dwarf2_dups
)
13127 /* Record the beginning of the file for break_out_includes. */
13128 dw_die_ref bincl_die
;
13130 bincl_die
= new_die (DW_TAG_GNU_BINCL
, comp_unit_die
, NULL
);
13131 add_AT_string (bincl_die
, DW_AT_name
, filename
);
13134 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
13136 named_section_flags (DEBUG_MACINFO_SECTION
, SECTION_DEBUG
);
13137 dw2_asm_output_data (1, DW_MACINFO_start_file
, "Start new file");
13138 dw2_asm_output_data_uleb128 (lineno
, "Included from line number %d",
13140 maybe_emit_file (lookup_filename (filename
));
13141 dw2_asm_output_data_uleb128 (lookup_filename (filename
),
13142 "Filename we just started");
13146 /* Record the end of a source file. */
13149 dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED
)
13151 if (flag_eliminate_dwarf2_dups
)
13152 /* Record the end of the file for break_out_includes. */
13153 new_die (DW_TAG_GNU_EINCL
, comp_unit_die
, NULL
);
13155 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
13157 named_section_flags (DEBUG_MACINFO_SECTION
, SECTION_DEBUG
);
13158 dw2_asm_output_data (1, DW_MACINFO_end_file
, "End file");
13162 /* Called from debug_define in toplev.c. The `buffer' parameter contains
13163 the tail part of the directive line, i.e. the part which is past the
13164 initial whitespace, #, whitespace, directive-name, whitespace part. */
13167 dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED
,
13168 const char *buffer ATTRIBUTE_UNUSED
)
13170 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
13172 named_section_flags (DEBUG_MACINFO_SECTION
, SECTION_DEBUG
);
13173 dw2_asm_output_data (1, DW_MACINFO_define
, "Define macro");
13174 dw2_asm_output_data_uleb128 (lineno
, "At line number %d", lineno
);
13175 dw2_asm_output_nstring (buffer
, -1, "The macro");
13179 /* Called from debug_undef in toplev.c. The `buffer' parameter contains
13180 the tail part of the directive line, i.e. the part which is past the
13181 initial whitespace, #, whitespace, directive-name, whitespace part. */
13184 dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED
,
13185 const char *buffer ATTRIBUTE_UNUSED
)
13187 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
13189 named_section_flags (DEBUG_MACINFO_SECTION
, SECTION_DEBUG
);
13190 dw2_asm_output_data (1, DW_MACINFO_undef
, "Undefine macro");
13191 dw2_asm_output_data_uleb128 (lineno
, "At line number %d", lineno
);
13192 dw2_asm_output_nstring (buffer
, -1, "The macro");
13196 /* Set up for Dwarf output at the start of compilation. */
13199 dwarf2out_init (const char *filename ATTRIBUTE_UNUSED
)
13201 init_file_table ();
13203 /* Allocate the decl_die_table. */
13204 decl_die_table
= htab_create_ggc (10, decl_die_table_hash
,
13205 decl_die_table_eq
, NULL
);
13207 /* Allocate the decl_loc_table. */
13208 decl_loc_table
= htab_create_ggc (10, decl_loc_table_hash
,
13209 decl_loc_table_eq
, NULL
);
13211 /* Allocate the initial hunk of the decl_scope_table. */
13212 VARRAY_TREE_INIT (decl_scope_table
, 256, "decl_scope_table");
13214 /* Allocate the initial hunk of the abbrev_die_table. */
13215 abbrev_die_table
= ggc_alloc_cleared (ABBREV_DIE_TABLE_INCREMENT
13216 * sizeof (dw_die_ref
));
13217 abbrev_die_table_allocated
= ABBREV_DIE_TABLE_INCREMENT
;
13218 /* Zero-th entry is allocated, but unused */
13219 abbrev_die_table_in_use
= 1;
13221 /* Allocate the initial hunk of the line_info_table. */
13222 line_info_table
= ggc_alloc_cleared (LINE_INFO_TABLE_INCREMENT
13223 * sizeof (dw_line_info_entry
));
13224 line_info_table_allocated
= LINE_INFO_TABLE_INCREMENT
;
13226 /* Zero-th entry is allocated, but unused */
13227 line_info_table_in_use
= 1;
13229 /* Generate the initial DIE for the .debug section. Note that the (string)
13230 value given in the DW_AT_name attribute of the DW_TAG_compile_unit DIE
13231 will (typically) be a relative pathname and that this pathname should be
13232 taken as being relative to the directory from which the compiler was
13233 invoked when the given (base) source file was compiled. We will fill
13234 in this value in dwarf2out_finish. */
13235 comp_unit_die
= gen_compile_unit_die (NULL
);
13237 VARRAY_TREE_INIT (incomplete_types
, 64, "incomplete_types");
13239 VARRAY_RTX_INIT (used_rtx_varray
, 32, "used_rtx_varray");
13241 ASM_GENERATE_INTERNAL_LABEL (text_end_label
, TEXT_END_LABEL
, 0);
13242 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label
,
13243 DEBUG_ABBREV_SECTION_LABEL
, 0);
13244 if (DWARF2_GENERATE_TEXT_SECTION_LABEL
)
13245 ASM_GENERATE_INTERNAL_LABEL (text_section_label
, TEXT_SECTION_LABEL
, 0);
13247 strcpy (text_section_label
, stripattributes (TEXT_SECTION_NAME
));
13249 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label
,
13250 DEBUG_INFO_SECTION_LABEL
, 0);
13251 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label
,
13252 DEBUG_LINE_SECTION_LABEL
, 0);
13253 ASM_GENERATE_INTERNAL_LABEL (ranges_section_label
,
13254 DEBUG_RANGES_SECTION_LABEL
, 0);
13255 named_section_flags (DEBUG_ABBREV_SECTION
, SECTION_DEBUG
);
13256 ASM_OUTPUT_LABEL (asm_out_file
, abbrev_section_label
);
13257 named_section_flags (DEBUG_INFO_SECTION
, SECTION_DEBUG
);
13258 ASM_OUTPUT_LABEL (asm_out_file
, debug_info_section_label
);
13259 named_section_flags (DEBUG_LINE_SECTION
, SECTION_DEBUG
);
13260 ASM_OUTPUT_LABEL (asm_out_file
, debug_line_section_label
);
13262 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
13264 named_section_flags (DEBUG_MACINFO_SECTION
, SECTION_DEBUG
);
13265 ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label
,
13266 DEBUG_MACINFO_SECTION_LABEL
, 0);
13267 ASM_OUTPUT_LABEL (asm_out_file
, macinfo_section_label
);
13270 if (DWARF2_GENERATE_TEXT_SECTION_LABEL
)
13273 ASM_OUTPUT_LABEL (asm_out_file
, text_section_label
);
13277 /* A helper function for dwarf2out_finish called through
13278 ht_forall. Emit one queued .debug_str string. */
13281 output_indirect_string (void **h
, void *v ATTRIBUTE_UNUSED
)
13283 struct indirect_string_node
*node
= (struct indirect_string_node
*) *h
;
13285 if (node
->form
== DW_FORM_strp
)
13287 named_section_flags (DEBUG_STR_SECTION
, DEBUG_STR_SECTION_FLAGS
);
13288 ASM_OUTPUT_LABEL (asm_out_file
, node
->label
);
13289 assemble_string (node
->str
, strlen (node
->str
) + 1);
13297 /* Clear the marks for a die and its children.
13298 Be cool if the mark isn't set. */
13301 prune_unmark_dies (dw_die_ref die
)
13305 for (c
= die
->die_child
; c
; c
= c
->die_sib
)
13306 prune_unmark_dies (c
);
13310 /* Given DIE that we're marking as used, find any other dies
13311 it references as attributes and mark them as used. */
13314 prune_unused_types_walk_attribs (dw_die_ref die
)
13318 for (a
= die
->die_attr
; a
!= NULL
; a
= a
->dw_attr_next
)
13320 if (a
->dw_attr_val
.val_class
== dw_val_class_die_ref
)
13322 /* A reference to another DIE.
13323 Make sure that it will get emitted. */
13324 prune_unused_types_mark (a
->dw_attr_val
.v
.val_die_ref
.die
, 1);
13326 else if (a
->dw_attr
== DW_AT_decl_file
)
13328 /* A reference to a file. Make sure the file name is emitted. */
13329 a
->dw_attr_val
.v
.val_unsigned
=
13330 maybe_emit_file (a
->dw_attr_val
.v
.val_unsigned
);
13336 /* Mark DIE as being used. If DOKIDS is true, then walk down
13337 to DIE's children. */
13340 prune_unused_types_mark (dw_die_ref die
, int dokids
)
13344 if (die
->die_mark
== 0)
13346 /* We haven't done this node yet. Mark it as used. */
13349 /* We also have to mark its parents as used.
13350 (But we don't want to mark our parents' kids due to this.) */
13351 if (die
->die_parent
)
13352 prune_unused_types_mark (die
->die_parent
, 0);
13354 /* Mark any referenced nodes. */
13355 prune_unused_types_walk_attribs (die
);
13357 /* If this node is a specification,
13358 also mark the definition, if it exists. */
13359 if (get_AT_flag (die
, DW_AT_declaration
) && die
->die_definition
)
13360 prune_unused_types_mark (die
->die_definition
, 1);
13363 if (dokids
&& die
->die_mark
!= 2)
13365 /* We need to walk the children, but haven't done so yet.
13366 Remember that we've walked the kids. */
13370 for (c
= die
->die_child
; c
; c
= c
->die_sib
)
13372 /* If this is an array type, we need to make sure our
13373 kids get marked, even if they're types. */
13374 if (die
->die_tag
== DW_TAG_array_type
)
13375 prune_unused_types_mark (c
, 1);
13377 prune_unused_types_walk (c
);
13383 /* Walk the tree DIE and mark types that we actually use. */
13386 prune_unused_types_walk (dw_die_ref die
)
13390 /* Don't do anything if this node is already marked. */
13394 switch (die
->die_tag
) {
13395 case DW_TAG_const_type
:
13396 case DW_TAG_packed_type
:
13397 case DW_TAG_pointer_type
:
13398 case DW_TAG_reference_type
:
13399 case DW_TAG_volatile_type
:
13400 case DW_TAG_typedef
:
13401 case DW_TAG_array_type
:
13402 case DW_TAG_structure_type
:
13403 case DW_TAG_union_type
:
13404 case DW_TAG_class_type
:
13405 case DW_TAG_friend
:
13406 case DW_TAG_variant_part
:
13407 case DW_TAG_enumeration_type
:
13408 case DW_TAG_subroutine_type
:
13409 case DW_TAG_string_type
:
13410 case DW_TAG_set_type
:
13411 case DW_TAG_subrange_type
:
13412 case DW_TAG_ptr_to_member_type
:
13413 case DW_TAG_file_type
:
13414 /* It's a type node --- don't mark it. */
13418 /* Mark everything else. */
13424 /* Now, mark any dies referenced from here. */
13425 prune_unused_types_walk_attribs (die
);
13427 /* Mark children. */
13428 for (c
= die
->die_child
; c
; c
= c
->die_sib
)
13429 prune_unused_types_walk (c
);
13433 /* Remove from the tree DIE any dies that aren't marked. */
13436 prune_unused_types_prune (dw_die_ref die
)
13438 dw_die_ref c
, p
, n
;
13440 gcc_assert (die
->die_mark
);
13443 for (c
= die
->die_child
; c
; c
= n
)
13448 prune_unused_types_prune (c
);
13456 die
->die_child
= n
;
13463 /* Remove dies representing declarations that we never use. */
13466 prune_unused_types (void)
13469 limbo_die_node
*node
;
13471 /* Clear all the marks. */
13472 prune_unmark_dies (comp_unit_die
);
13473 for (node
= limbo_die_list
; node
; node
= node
->next
)
13474 prune_unmark_dies (node
->die
);
13476 /* Set the mark on nodes that are actually used. */
13477 prune_unused_types_walk (comp_unit_die
);
13478 for (node
= limbo_die_list
; node
; node
= node
->next
)
13479 prune_unused_types_walk (node
->die
);
13481 /* Also set the mark on nodes referenced from the
13482 pubname_table or arange_table. */
13483 for (i
= 0; i
< pubname_table_in_use
; i
++)
13484 prune_unused_types_mark (pubname_table
[i
].die
, 1);
13485 for (i
= 0; i
< arange_table_in_use
; i
++)
13486 prune_unused_types_mark (arange_table
[i
], 1);
13488 /* Get rid of nodes that aren't marked. */
13489 prune_unused_types_prune (comp_unit_die
);
13490 for (node
= limbo_die_list
; node
; node
= node
->next
)
13491 prune_unused_types_prune (node
->die
);
13493 /* Leave the marks clear. */
13494 prune_unmark_dies (comp_unit_die
);
13495 for (node
= limbo_die_list
; node
; node
= node
->next
)
13496 prune_unmark_dies (node
->die
);
13499 /* Output stuff that dwarf requires at the end of every file,
13500 and generate the DWARF-2 debugging info. */
13503 dwarf2out_finish (const char *filename
)
13505 limbo_die_node
*node
, *next_node
;
13506 dw_die_ref die
= 0;
13508 /* Add the name for the main input file now. We delayed this from
13509 dwarf2out_init to avoid complications with PCH. */
13510 add_name_attribute (comp_unit_die
, filename
);
13511 if (filename
[0] != DIR_SEPARATOR
)
13512 add_comp_dir_attribute (comp_unit_die
);
13513 else if (get_AT (comp_unit_die
, DW_AT_comp_dir
) == NULL
)
13516 for (i
= 1; i
< VARRAY_ACTIVE_SIZE (file_table
); i
++)
13517 if (VARRAY_CHAR_PTR (file_table
, i
)[0] != DIR_SEPARATOR
13518 /* Don't add cwd for <built-in>. */
13519 && VARRAY_CHAR_PTR (file_table
, i
)[0] != '<')
13521 add_comp_dir_attribute (comp_unit_die
);
13526 /* Traverse the limbo die list, and add parent/child links. The only
13527 dies without parents that should be here are concrete instances of
13528 inline functions, and the comp_unit_die. We can ignore the comp_unit_die.
13529 For concrete instances, we can get the parent die from the abstract
13531 for (node
= limbo_die_list
; node
; node
= next_node
)
13533 next_node
= node
->next
;
13536 if (die
->die_parent
== NULL
)
13538 dw_die_ref origin
= get_AT_ref (die
, DW_AT_abstract_origin
);
13541 add_child_die (origin
->die_parent
, die
);
13542 else if (die
== comp_unit_die
)
13544 else if (errorcount
> 0 || sorrycount
> 0)
13545 /* It's OK to be confused by errors in the input. */
13546 add_child_die (comp_unit_die
, die
);
13549 /* In certain situations, the lexical block containing a
13550 nested function can be optimized away, which results
13551 in the nested function die being orphaned. Likewise
13552 with the return type of that nested function. Force
13553 this to be a child of the containing function. */
13554 tree context
= NULL_TREE
;
13556 gcc_assert (node
->created_for
);
13558 if (DECL_P (node
->created_for
))
13559 context
= DECL_CONTEXT (node
->created_for
);
13560 else if (TYPE_P (node
->created_for
))
13561 context
= TYPE_CONTEXT (node
->created_for
);
13563 gcc_assert (context
&& TREE_CODE (context
) == FUNCTION_DECL
);
13565 origin
= lookup_decl_die (context
);
13566 gcc_assert (origin
);
13567 add_child_die (origin
, die
);
13572 limbo_die_list
= NULL
;
13574 /* Walk through the list of incomplete types again, trying once more to
13575 emit full debugging info for them. */
13576 retry_incomplete_types ();
13578 /* We need to reverse all the dies before break_out_includes, or
13579 we'll see the end of an include file before the beginning. */
13580 reverse_all_dies (comp_unit_die
);
13582 if (flag_eliminate_unused_debug_types
)
13583 prune_unused_types ();
13585 /* Generate separate CUs for each of the include files we've seen.
13586 They will go into limbo_die_list. */
13587 if (flag_eliminate_dwarf2_dups
)
13588 break_out_includes (comp_unit_die
);
13590 /* Traverse the DIE's and add add sibling attributes to those DIE's
13591 that have children. */
13592 add_sibling_attributes (comp_unit_die
);
13593 for (node
= limbo_die_list
; node
; node
= node
->next
)
13594 add_sibling_attributes (node
->die
);
13596 /* Output a terminator label for the .text section. */
13598 targetm
.asm_out
.internal_label (asm_out_file
, TEXT_END_LABEL
, 0);
13600 /* Output the source line correspondence table. We must do this
13601 even if there is no line information. Otherwise, on an empty
13602 translation unit, we will generate a present, but empty,
13603 .debug_info section. IRIX 6.5 `nm' will then complain when
13604 examining the file. */
13605 if (! DWARF2_ASM_LINE_DEBUG_INFO
)
13607 named_section_flags (DEBUG_LINE_SECTION
, SECTION_DEBUG
);
13608 output_line_info ();
13611 /* Output location list section if necessary. */
13612 if (have_location_lists
)
13614 /* Output the location lists info. */
13615 named_section_flags (DEBUG_LOC_SECTION
, SECTION_DEBUG
);
13616 ASM_GENERATE_INTERNAL_LABEL (loc_section_label
,
13617 DEBUG_LOC_SECTION_LABEL
, 0);
13618 ASM_OUTPUT_LABEL (asm_out_file
, loc_section_label
);
13619 output_location_lists (die
);
13620 have_location_lists
= 0;
13623 /* We can only use the low/high_pc attributes if all of the code was
13625 if (separate_line_info_table_in_use
== 0)
13627 add_AT_lbl_id (comp_unit_die
, DW_AT_low_pc
, text_section_label
);
13628 add_AT_lbl_id (comp_unit_die
, DW_AT_high_pc
, text_end_label
);
13631 /* If it wasn't, we need to give .debug_loc and .debug_ranges an appropriate
13632 "base address". Use zero so that these addresses become absolute. */
13633 else if (have_location_lists
|| ranges_table_in_use
)
13634 add_AT_addr (comp_unit_die
, DW_AT_entry_pc
, const0_rtx
);
13636 if (debug_info_level
>= DINFO_LEVEL_NORMAL
)
13637 add_AT_lbl_offset (comp_unit_die
, DW_AT_stmt_list
,
13638 debug_line_section_label
);
13640 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
13641 add_AT_lbl_offset (comp_unit_die
, DW_AT_macro_info
, macinfo_section_label
);
13643 /* Output all of the compilation units. We put the main one last so that
13644 the offsets are available to output_pubnames. */
13645 for (node
= limbo_die_list
; node
; node
= node
->next
)
13646 output_comp_unit (node
->die
, 0);
13648 output_comp_unit (comp_unit_die
, 0);
13650 /* Output the abbreviation table. */
13651 named_section_flags (DEBUG_ABBREV_SECTION
, SECTION_DEBUG
);
13652 output_abbrev_section ();
13654 /* Output public names table if necessary. */
13655 if (pubname_table_in_use
)
13657 named_section_flags (DEBUG_PUBNAMES_SECTION
, SECTION_DEBUG
);
13658 output_pubnames ();
13661 /* Output the address range information. We only put functions in the arange
13662 table, so don't write it out if we don't have any. */
13663 if (fde_table_in_use
)
13665 named_section_flags (DEBUG_ARANGES_SECTION
, SECTION_DEBUG
);
13669 /* Output ranges section if necessary. */
13670 if (ranges_table_in_use
)
13672 named_section_flags (DEBUG_RANGES_SECTION
, SECTION_DEBUG
);
13673 ASM_OUTPUT_LABEL (asm_out_file
, ranges_section_label
);
13677 /* Have to end the primary source file. */
13678 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
13680 named_section_flags (DEBUG_MACINFO_SECTION
, SECTION_DEBUG
);
13681 dw2_asm_output_data (1, DW_MACINFO_end_file
, "End file");
13682 dw2_asm_output_data (1, 0, "End compilation unit");
13685 /* If we emitted any DW_FORM_strp form attribute, output the string
13687 if (debug_str_hash
)
13688 htab_traverse (debug_str_hash
, output_indirect_string
, NULL
);
13692 /* This should never be used, but its address is needed for comparisons. */
13693 const struct gcc_debug_hooks dwarf2_debug_hooks
;
13695 #endif /* DWARF2_DEBUGGING_INFO */
13697 #include "gt-dwarf2out.h"