1 /* Output Dwarf2 format symbol table information from GCC.
2 Copyright (C) 1992, 1993, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
3 2003 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"
45 #include "hard-reg-set.h"
47 #include "insn-config.h"
55 #include "dwarf2out.h"
56 #include "dwarf2asm.h"
62 #include "diagnostic.h"
65 #include "langhooks.h"
69 #ifdef DWARF2_DEBUGGING_INFO
70 static void dwarf2out_source_line (unsigned int, const char *);
73 /* DWARF2 Abbreviation Glossary:
74 CFA = Canonical Frame Address
75 a fixed address on the stack which identifies a call frame.
76 We define it to be the value of SP just before the call insn.
77 The CFA register and offset, which may change during the course
78 of the function, are used to calculate its value at runtime.
79 CFI = Call Frame Instruction
80 an instruction for the DWARF2 abstract machine
81 CIE = Common Information Entry
82 information describing information common to one or more FDEs
83 DIE = Debugging Information Entry
84 FDE = Frame Description Entry
85 information describing the stack call frame, in particular,
86 how to restore registers
88 DW_CFA_... = DWARF2 CFA call frame instruction
89 DW_TAG_... = DWARF2 DIE tag */
91 /* Decide whether we want to emit frame unwind information for the current
95 dwarf2out_do_frame (void)
97 return (write_symbols
== DWARF2_DEBUG
98 || write_symbols
== VMS_AND_DWARF2_DEBUG
99 #ifdef DWARF2_FRAME_INFO
102 #ifdef DWARF2_UNWIND_INFO
103 || flag_unwind_tables
104 || (flag_exceptions
&& ! USING_SJLJ_EXCEPTIONS
)
109 /* The size of the target's pointer type. */
111 #define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
114 /* Various versions of targetm.eh_frame_section. Note these must appear
115 outside the DWARF2_DEBUGGING_INFO || DWARF2_UNWIND_INFO macro guards. */
117 /* Version of targetm.eh_frame_section for systems with named sections. */
119 named_section_eh_frame_section (void)
121 #ifdef EH_FRAME_SECTION_NAME
122 #ifdef HAVE_LD_RO_RW_SECTION_MIXING
123 int fde_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0);
124 int per_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
125 int lsda_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
129 || ((fde_encoding
& 0x70) != DW_EH_PE_absptr
130 && (fde_encoding
& 0x70) != DW_EH_PE_aligned
131 && (per_encoding
& 0x70) != DW_EH_PE_absptr
132 && (per_encoding
& 0x70) != DW_EH_PE_aligned
133 && (lsda_encoding
& 0x70) != DW_EH_PE_absptr
134 && (lsda_encoding
& 0x70) != DW_EH_PE_aligned
))
136 named_section_flags (EH_FRAME_SECTION_NAME
, flags
);
138 named_section_flags (EH_FRAME_SECTION_NAME
, SECTION_WRITE
);
143 /* Version of targetm.eh_frame_section for systems using collect2. */
145 collect2_eh_frame_section (void)
147 tree label
= get_file_function_name ('F');
150 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (PTR_SIZE
));
151 (*targetm
.asm_out
.globalize_label
) (asm_out_file
, IDENTIFIER_POINTER (label
));
152 ASM_OUTPUT_LABEL (asm_out_file
, IDENTIFIER_POINTER (label
));
155 /* Default version of targetm.eh_frame_section. */
157 default_eh_frame_section (void)
159 #ifdef EH_FRAME_SECTION_NAME
160 named_section_eh_frame_section ();
162 collect2_eh_frame_section ();
166 /* Array of RTXes referenced by the debugging information, which therefore
167 must be kept around forever. */
168 static GTY(()) varray_type used_rtx_varray
;
170 /* A pointer to the base of a list of incomplete types which might be
171 completed at some later time. incomplete_types_list needs to be a VARRAY
172 because we want to tell the garbage collector about it. */
173 static GTY(()) varray_type incomplete_types
;
175 /* A pointer to the base of a table of references to declaration
176 scopes. This table is a display which tracks the nesting
177 of declaration scopes at the current scope and containing
178 scopes. This table is used to find the proper place to
179 define type declaration DIE's. */
180 static GTY(()) varray_type decl_scope_table
;
182 /* How to start an assembler comment. */
183 #ifndef ASM_COMMENT_START
184 #define ASM_COMMENT_START ";#"
187 typedef struct dw_cfi_struct
*dw_cfi_ref
;
188 typedef struct dw_fde_struct
*dw_fde_ref
;
189 typedef union dw_cfi_oprnd_struct
*dw_cfi_oprnd_ref
;
191 /* Call frames are described using a sequence of Call Frame
192 Information instructions. The register number, offset
193 and address fields are provided as possible operands;
194 their use is selected by the opcode field. */
196 enum dw_cfi_oprnd_type
{
198 dw_cfi_oprnd_reg_num
,
204 typedef union dw_cfi_oprnd_struct
GTY(())
206 unsigned long GTY ((tag ("dw_cfi_oprnd_reg_num"))) dw_cfi_reg_num
;
207 HOST_WIDE_INT
GTY ((tag ("dw_cfi_oprnd_offset"))) dw_cfi_offset
;
208 const char * GTY ((tag ("dw_cfi_oprnd_addr"))) dw_cfi_addr
;
209 struct dw_loc_descr_struct
* GTY ((tag ("dw_cfi_oprnd_loc"))) dw_cfi_loc
;
213 typedef struct dw_cfi_struct
GTY(())
215 dw_cfi_ref dw_cfi_next
;
216 enum dwarf_call_frame_info dw_cfi_opc
;
217 dw_cfi_oprnd
GTY ((desc ("dw_cfi_oprnd1_desc (%1.dw_cfi_opc)")))
219 dw_cfi_oprnd
GTY ((desc ("dw_cfi_oprnd2_desc (%1.dw_cfi_opc)")))
224 /* This is how we define the location of the CFA. We use to handle it
225 as REG + OFFSET all the time, but now it can be more complex.
226 It can now be either REG + CFA_OFFSET or *(REG + BASE_OFFSET) + CFA_OFFSET.
227 Instead of passing around REG and OFFSET, we pass a copy
228 of this structure. */
229 typedef struct cfa_loc
GTY(())
232 HOST_WIDE_INT offset
;
233 HOST_WIDE_INT base_offset
;
234 int indirect
; /* 1 if CFA is accessed via a dereference. */
237 /* All call frame descriptions (FDE's) in the GCC generated DWARF
238 refer to a single Common Information Entry (CIE), defined at
239 the beginning of the .debug_frame section. This use of a single
240 CIE obviates the need to keep track of multiple CIE's
241 in the DWARF generation routines below. */
243 typedef struct dw_fde_struct
GTY(())
245 const char *dw_fde_begin
;
246 const char *dw_fde_current_label
;
247 const char *dw_fde_end
;
248 dw_cfi_ref dw_fde_cfi
;
249 unsigned funcdef_number
;
250 unsigned all_throwers_are_sibcalls
: 1;
251 unsigned nothrow
: 1;
252 unsigned uses_eh_lsda
: 1;
256 /* Maximum size (in bytes) of an artificially generated label. */
257 #define MAX_ARTIFICIAL_LABEL_BYTES 30
259 /* The size of addresses as they appear in the Dwarf 2 data.
260 Some architectures use word addresses to refer to code locations,
261 but Dwarf 2 info always uses byte addresses. On such machines,
262 Dwarf 2 addresses need to be larger than the architecture's
264 #ifndef DWARF2_ADDR_SIZE
265 #define DWARF2_ADDR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
268 /* The size in bytes of a DWARF field indicating an offset or length
269 relative to a debug info section, specified to be 4 bytes in the
270 DWARF-2 specification. The SGI/MIPS ABI defines it to be the same
273 #ifndef DWARF_OFFSET_SIZE
274 #define DWARF_OFFSET_SIZE 4
277 /* According to the (draft) DWARF 3 specification, the initial length
278 should either be 4 or 12 bytes. When it's 12 bytes, the first 4
279 bytes are 0xffffffff, followed by the length stored in the next 8
282 However, the SGI/MIPS ABI uses an initial length which is equal to
283 DWARF_OFFSET_SIZE. It is defined (elsewhere) accordingly. */
285 #ifndef DWARF_INITIAL_LENGTH_SIZE
286 #define DWARF_INITIAL_LENGTH_SIZE (DWARF_OFFSET_SIZE == 4 ? 4 : 12)
289 #define DWARF_VERSION 2
291 /* Round SIZE up to the nearest BOUNDARY. */
292 #define DWARF_ROUND(SIZE,BOUNDARY) \
293 ((((SIZE) + (BOUNDARY) - 1) / (BOUNDARY)) * (BOUNDARY))
295 /* Offsets recorded in opcodes are a multiple of this alignment factor. */
296 #ifndef DWARF_CIE_DATA_ALIGNMENT
297 #ifdef STACK_GROWS_DOWNWARD
298 #define DWARF_CIE_DATA_ALIGNMENT (-((int) UNITS_PER_WORD))
300 #define DWARF_CIE_DATA_ALIGNMENT ((int) UNITS_PER_WORD)
304 /* A pointer to the base of a table that contains frame description
305 information for each routine. */
306 static GTY((length ("fde_table_allocated"))) dw_fde_ref fde_table
;
308 /* Number of elements currently allocated for fde_table. */
309 static GTY(()) unsigned fde_table_allocated
;
311 /* Number of elements in fde_table currently in use. */
312 static GTY(()) unsigned fde_table_in_use
;
314 /* Size (in elements) of increments by which we may expand the
316 #define FDE_TABLE_INCREMENT 256
318 /* A list of call frame insns for the CIE. */
319 static GTY(()) dw_cfi_ref cie_cfi_head
;
321 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
322 /* Some DWARF extensions (e.g., MIPS/SGI) implement a subprogram
323 attribute that accelerates the lookup of the FDE associated
324 with the subprogram. This variable holds the table index of the FDE
325 associated with the current function (body) definition. */
326 static unsigned current_funcdef_fde
;
329 struct indirect_string_node
GTY(())
332 unsigned int refcount
;
337 static GTY ((param_is (struct indirect_string_node
))) htab_t debug_str_hash
;
339 static GTY(()) int dw2_string_counter
;
340 static GTY(()) unsigned long dwarf2out_cfi_label_num
;
342 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
344 /* Forward declarations for functions defined in this file. */
346 static char *stripattributes (const char *);
347 static const char *dwarf_cfi_name (unsigned);
348 static dw_cfi_ref
new_cfi (void);
349 static void add_cfi (dw_cfi_ref
*, dw_cfi_ref
);
350 static void add_fde_cfi (const char *, dw_cfi_ref
);
351 static void lookup_cfa_1 (dw_cfi_ref
, dw_cfa_location
*);
352 static void lookup_cfa (dw_cfa_location
*);
353 static void reg_save (const char *, unsigned, unsigned, HOST_WIDE_INT
);
354 static void initial_return_save (rtx
);
355 static HOST_WIDE_INT
stack_adjust_offset (rtx
);
356 static void output_cfi (dw_cfi_ref
, dw_fde_ref
, int);
357 static void output_call_frame_info (int);
358 static void dwarf2out_stack_adjust (rtx
);
359 static void queue_reg_save (const char *, rtx
, HOST_WIDE_INT
);
360 static void flush_queued_reg_saves (void);
361 static bool clobbers_queued_reg_save (rtx
);
362 static void dwarf2out_frame_debug_expr (rtx
, const char *);
364 /* Support for complex CFA locations. */
365 static void output_cfa_loc (dw_cfi_ref
);
366 static void get_cfa_from_loc_descr (dw_cfa_location
*,
367 struct dw_loc_descr_struct
*);
368 static struct dw_loc_descr_struct
*build_cfa_loc
370 static void def_cfa_1 (const char *, dw_cfa_location
*);
372 /* How to start an assembler comment. */
373 #ifndef ASM_COMMENT_START
374 #define ASM_COMMENT_START ";#"
377 /* Data and reference forms for relocatable data. */
378 #define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
379 #define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
381 #ifndef DEBUG_FRAME_SECTION
382 #define DEBUG_FRAME_SECTION ".debug_frame"
385 #ifndef FUNC_BEGIN_LABEL
386 #define FUNC_BEGIN_LABEL "LFB"
389 #ifndef FUNC_END_LABEL
390 #define FUNC_END_LABEL "LFE"
393 #define FRAME_BEGIN_LABEL "Lframe"
394 #define CIE_AFTER_SIZE_LABEL "LSCIE"
395 #define CIE_END_LABEL "LECIE"
396 #define FDE_LABEL "LSFDE"
397 #define FDE_AFTER_SIZE_LABEL "LASFDE"
398 #define FDE_END_LABEL "LEFDE"
399 #define LINE_NUMBER_BEGIN_LABEL "LSLT"
400 #define LINE_NUMBER_END_LABEL "LELT"
401 #define LN_PROLOG_AS_LABEL "LASLTP"
402 #define LN_PROLOG_END_LABEL "LELTP"
403 #define DIE_LABEL_PREFIX "DW"
405 /* The DWARF 2 CFA column which tracks the return address. Normally this
406 is the column for PC, or the first column after all of the hard
408 #ifndef DWARF_FRAME_RETURN_COLUMN
410 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (PC_REGNUM)
412 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGISTERS
416 /* The mapping from gcc register number to DWARF 2 CFA column number. By
417 default, we just provide columns for all registers. */
418 #ifndef DWARF_FRAME_REGNUM
419 #define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG)
422 /* The offset from the incoming value of %sp to the top of the stack frame
423 for the current function. */
424 #ifndef INCOMING_FRAME_SP_OFFSET
425 #define INCOMING_FRAME_SP_OFFSET 0
428 /* Hook used by __throw. */
431 expand_builtin_dwarf_sp_column (void)
433 return GEN_INT (DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM
));
436 /* Return a pointer to a copy of the section string name S with all
437 attributes stripped off, and an asterisk prepended (for assemble_name). */
440 stripattributes (const char *s
)
442 char *stripped
= xmalloc (strlen (s
) + 2);
447 while (*s
&& *s
!= ',')
454 /* Generate code to initialize the register size table. */
457 expand_builtin_init_dwarf_reg_sizes (tree address
)
460 enum machine_mode mode
= TYPE_MODE (char_type_node
);
461 rtx addr
= expand_expr (address
, NULL_RTX
, VOIDmode
, 0);
462 rtx mem
= gen_rtx_MEM (BLKmode
, addr
);
463 bool wrote_return_column
= false;
465 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
466 if (DWARF_FRAME_REGNUM (i
) < DWARF_FRAME_REGISTERS
)
468 HOST_WIDE_INT offset
= DWARF_FRAME_REGNUM (i
) * GET_MODE_SIZE (mode
);
469 enum machine_mode save_mode
= reg_raw_mode
[i
];
472 if (HARD_REGNO_CALL_PART_CLOBBERED (i
, save_mode
))
473 save_mode
= choose_hard_reg_mode (i
, 1, true);
474 if (DWARF_FRAME_REGNUM (i
) == DWARF_FRAME_RETURN_COLUMN
)
476 if (save_mode
== VOIDmode
)
478 wrote_return_column
= true;
480 size
= GET_MODE_SIZE (save_mode
);
484 emit_move_insn (adjust_address (mem
, mode
, offset
), GEN_INT (size
));
487 #ifdef DWARF_ALT_FRAME_RETURN_COLUMN
488 if (! wrote_return_column
)
490 i
= DWARF_ALT_FRAME_RETURN_COLUMN
;
491 wrote_return_column
= false;
493 i
= DWARF_FRAME_RETURN_COLUMN
;
496 if (! wrote_return_column
)
498 enum machine_mode save_mode
= Pmode
;
499 HOST_WIDE_INT offset
= i
* GET_MODE_SIZE (mode
);
500 HOST_WIDE_INT size
= GET_MODE_SIZE (save_mode
);
501 emit_move_insn (adjust_address (mem
, mode
, offset
), GEN_INT (size
));
505 /* Convert a DWARF call frame info. operation to its string name */
508 dwarf_cfi_name (unsigned int cfi_opc
)
512 case DW_CFA_advance_loc
:
513 return "DW_CFA_advance_loc";
515 return "DW_CFA_offset";
517 return "DW_CFA_restore";
521 return "DW_CFA_set_loc";
522 case DW_CFA_advance_loc1
:
523 return "DW_CFA_advance_loc1";
524 case DW_CFA_advance_loc2
:
525 return "DW_CFA_advance_loc2";
526 case DW_CFA_advance_loc4
:
527 return "DW_CFA_advance_loc4";
528 case DW_CFA_offset_extended
:
529 return "DW_CFA_offset_extended";
530 case DW_CFA_restore_extended
:
531 return "DW_CFA_restore_extended";
532 case DW_CFA_undefined
:
533 return "DW_CFA_undefined";
534 case DW_CFA_same_value
:
535 return "DW_CFA_same_value";
536 case DW_CFA_register
:
537 return "DW_CFA_register";
538 case DW_CFA_remember_state
:
539 return "DW_CFA_remember_state";
540 case DW_CFA_restore_state
:
541 return "DW_CFA_restore_state";
543 return "DW_CFA_def_cfa";
544 case DW_CFA_def_cfa_register
:
545 return "DW_CFA_def_cfa_register";
546 case DW_CFA_def_cfa_offset
:
547 return "DW_CFA_def_cfa_offset";
550 case DW_CFA_def_cfa_expression
:
551 return "DW_CFA_def_cfa_expression";
552 case DW_CFA_expression
:
553 return "DW_CFA_expression";
554 case DW_CFA_offset_extended_sf
:
555 return "DW_CFA_offset_extended_sf";
556 case DW_CFA_def_cfa_sf
:
557 return "DW_CFA_def_cfa_sf";
558 case DW_CFA_def_cfa_offset_sf
:
559 return "DW_CFA_def_cfa_offset_sf";
561 /* SGI/MIPS specific */
562 case DW_CFA_MIPS_advance_loc8
:
563 return "DW_CFA_MIPS_advance_loc8";
566 case DW_CFA_GNU_window_save
:
567 return "DW_CFA_GNU_window_save";
568 case DW_CFA_GNU_args_size
:
569 return "DW_CFA_GNU_args_size";
570 case DW_CFA_GNU_negative_offset_extended
:
571 return "DW_CFA_GNU_negative_offset_extended";
574 return "DW_CFA_<unknown>";
578 /* Return a pointer to a newly allocated Call Frame Instruction. */
580 static inline dw_cfi_ref
583 dw_cfi_ref cfi
= ggc_alloc (sizeof (dw_cfi_node
));
585 cfi
->dw_cfi_next
= NULL
;
586 cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
= 0;
587 cfi
->dw_cfi_oprnd2
.dw_cfi_reg_num
= 0;
592 /* Add a Call Frame Instruction to list of instructions. */
595 add_cfi (dw_cfi_ref
*list_head
, dw_cfi_ref cfi
)
599 /* Find the end of the chain. */
600 for (p
= list_head
; (*p
) != NULL
; p
= &(*p
)->dw_cfi_next
)
606 /* Generate a new label for the CFI info to refer to. */
609 dwarf2out_cfi_label (void)
611 static char label
[20];
613 ASM_GENERATE_INTERNAL_LABEL (label
, "LCFI", dwarf2out_cfi_label_num
++);
614 ASM_OUTPUT_LABEL (asm_out_file
, label
);
618 /* Add CFI to the current fde at the PC value indicated by LABEL if specified,
619 or to the CIE if LABEL is NULL. */
622 add_fde_cfi (const char *label
, dw_cfi_ref cfi
)
626 dw_fde_ref fde
= &fde_table
[fde_table_in_use
- 1];
629 label
= dwarf2out_cfi_label ();
631 if (fde
->dw_fde_current_label
== NULL
632 || strcmp (label
, fde
->dw_fde_current_label
) != 0)
636 fde
->dw_fde_current_label
= label
= xstrdup (label
);
638 /* Set the location counter to the new label. */
640 xcfi
->dw_cfi_opc
= DW_CFA_advance_loc4
;
641 xcfi
->dw_cfi_oprnd1
.dw_cfi_addr
= label
;
642 add_cfi (&fde
->dw_fde_cfi
, xcfi
);
645 add_cfi (&fde
->dw_fde_cfi
, cfi
);
649 add_cfi (&cie_cfi_head
, cfi
);
652 /* Subroutine of lookup_cfa. */
655 lookup_cfa_1 (dw_cfi_ref cfi
, dw_cfa_location
*loc
)
657 switch (cfi
->dw_cfi_opc
)
659 case DW_CFA_def_cfa_offset
:
660 loc
->offset
= cfi
->dw_cfi_oprnd1
.dw_cfi_offset
;
662 case DW_CFA_def_cfa_register
:
663 loc
->reg
= cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
;
666 loc
->reg
= cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
;
667 loc
->offset
= cfi
->dw_cfi_oprnd2
.dw_cfi_offset
;
669 case DW_CFA_def_cfa_expression
:
670 get_cfa_from_loc_descr (loc
, cfi
->dw_cfi_oprnd1
.dw_cfi_loc
);
677 /* Find the previous value for the CFA. */
680 lookup_cfa (dw_cfa_location
*loc
)
684 loc
->reg
= (unsigned long) -1;
687 loc
->base_offset
= 0;
689 for (cfi
= cie_cfi_head
; cfi
; cfi
= cfi
->dw_cfi_next
)
690 lookup_cfa_1 (cfi
, loc
);
692 if (fde_table_in_use
)
694 dw_fde_ref fde
= &fde_table
[fde_table_in_use
- 1];
695 for (cfi
= fde
->dw_fde_cfi
; cfi
; cfi
= cfi
->dw_cfi_next
)
696 lookup_cfa_1 (cfi
, loc
);
700 /* The current rule for calculating the DWARF2 canonical frame address. */
701 static dw_cfa_location cfa
;
703 /* The register used for saving registers to the stack, and its offset
705 static dw_cfa_location cfa_store
;
707 /* The running total of the size of arguments pushed onto the stack. */
708 static HOST_WIDE_INT args_size
;
710 /* The last args_size we actually output. */
711 static HOST_WIDE_INT old_args_size
;
713 /* Entry point to update the canonical frame address (CFA).
714 LABEL is passed to add_fde_cfi. The value of CFA is now to be
715 calculated from REG+OFFSET. */
718 dwarf2out_def_cfa (const char *label
, unsigned int reg
, HOST_WIDE_INT offset
)
725 def_cfa_1 (label
, &loc
);
728 /* This routine does the actual work. The CFA is now calculated from
729 the dw_cfa_location structure. */
732 def_cfa_1 (const char *label
, dw_cfa_location
*loc_p
)
735 dw_cfa_location old_cfa
, loc
;
740 if (cfa_store
.reg
== loc
.reg
&& loc
.indirect
== 0)
741 cfa_store
.offset
= loc
.offset
;
743 loc
.reg
= DWARF_FRAME_REGNUM (loc
.reg
);
744 lookup_cfa (&old_cfa
);
746 /* If nothing changed, no need to issue any call frame instructions. */
747 if (loc
.reg
== old_cfa
.reg
&& loc
.offset
== old_cfa
.offset
748 && loc
.indirect
== old_cfa
.indirect
749 && (loc
.indirect
== 0 || loc
.base_offset
== old_cfa
.base_offset
))
754 if (loc
.reg
== old_cfa
.reg
&& !loc
.indirect
)
756 /* Construct a "DW_CFA_def_cfa_offset <offset>" instruction,
757 indicating the CFA register did not change but the offset
759 cfi
->dw_cfi_opc
= DW_CFA_def_cfa_offset
;
760 cfi
->dw_cfi_oprnd1
.dw_cfi_offset
= loc
.offset
;
763 #ifndef MIPS_DEBUGGING_INFO /* SGI dbx thinks this means no offset. */
764 else if (loc
.offset
== old_cfa
.offset
&& old_cfa
.reg
!= (unsigned long) -1
767 /* Construct a "DW_CFA_def_cfa_register <register>" instruction,
768 indicating the CFA register has changed to <register> but the
769 offset has not changed. */
770 cfi
->dw_cfi_opc
= DW_CFA_def_cfa_register
;
771 cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
= loc
.reg
;
775 else if (loc
.indirect
== 0)
777 /* Construct a "DW_CFA_def_cfa <register> <offset>" instruction,
778 indicating the CFA register has changed to <register> with
779 the specified offset. */
780 cfi
->dw_cfi_opc
= DW_CFA_def_cfa
;
781 cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
= loc
.reg
;
782 cfi
->dw_cfi_oprnd2
.dw_cfi_offset
= loc
.offset
;
786 /* Construct a DW_CFA_def_cfa_expression instruction to
787 calculate the CFA using a full location expression since no
788 register-offset pair is available. */
789 struct dw_loc_descr_struct
*loc_list
;
791 cfi
->dw_cfi_opc
= DW_CFA_def_cfa_expression
;
792 loc_list
= build_cfa_loc (&loc
);
793 cfi
->dw_cfi_oprnd1
.dw_cfi_loc
= loc_list
;
796 add_fde_cfi (label
, cfi
);
799 /* Add the CFI for saving a register. REG is the CFA column number.
800 LABEL is passed to add_fde_cfi.
801 If SREG is -1, the register is saved at OFFSET from the CFA;
802 otherwise it is saved in SREG. */
805 reg_save (const char *label
, unsigned int reg
, unsigned int sreg
, HOST_WIDE_INT offset
)
807 dw_cfi_ref cfi
= new_cfi ();
809 cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
= reg
;
811 /* The following comparison is correct. -1 is used to indicate that
812 the value isn't a register number. */
813 if (sreg
== (unsigned int) -1)
816 /* The register number won't fit in 6 bits, so we have to use
818 cfi
->dw_cfi_opc
= DW_CFA_offset_extended
;
820 cfi
->dw_cfi_opc
= DW_CFA_offset
;
822 #ifdef ENABLE_CHECKING
824 /* If we get an offset that is not a multiple of
825 DWARF_CIE_DATA_ALIGNMENT, there is either a bug in the
826 definition of DWARF_CIE_DATA_ALIGNMENT, or a bug in the machine
828 HOST_WIDE_INT check_offset
= offset
/ DWARF_CIE_DATA_ALIGNMENT
;
830 if (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 /* We could emit a DW_CFA_same_value in this case, but don't bother. */
845 cfi
->dw_cfi_opc
= DW_CFA_register
;
846 cfi
->dw_cfi_oprnd2
.dw_cfi_reg_num
= sreg
;
849 add_fde_cfi (label
, cfi
);
852 /* Add the CFI for saving a register window. LABEL is passed to reg_save.
853 This CFI tells the unwinder that it needs to restore the window registers
854 from the previous frame's window save area.
856 ??? Perhaps we should note in the CIE where windows are saved (instead of
857 assuming 0(cfa)) and what registers are in the window. */
860 dwarf2out_window_save (const char *label
)
862 dw_cfi_ref cfi
= new_cfi ();
864 cfi
->dw_cfi_opc
= DW_CFA_GNU_window_save
;
865 add_fde_cfi (label
, cfi
);
868 /* Add a CFI to update the running total of the size of arguments
869 pushed onto the stack. */
872 dwarf2out_args_size (const char *label
, HOST_WIDE_INT size
)
876 if (size
== old_args_size
)
879 old_args_size
= size
;
882 cfi
->dw_cfi_opc
= DW_CFA_GNU_args_size
;
883 cfi
->dw_cfi_oprnd1
.dw_cfi_offset
= size
;
884 add_fde_cfi (label
, cfi
);
887 /* Entry point for saving a register to the stack. REG is the GCC register
888 number. LABEL and OFFSET are passed to reg_save. */
891 dwarf2out_reg_save (const char *label
, unsigned int reg
, HOST_WIDE_INT offset
)
893 reg_save (label
, DWARF_FRAME_REGNUM (reg
), -1, offset
);
896 /* Entry point for saving the return address in the stack.
897 LABEL and OFFSET are passed to reg_save. */
900 dwarf2out_return_save (const char *label
, HOST_WIDE_INT offset
)
902 reg_save (label
, DWARF_FRAME_RETURN_COLUMN
, -1, offset
);
905 /* Entry point for saving the return address in a register.
906 LABEL and SREG are passed to reg_save. */
909 dwarf2out_return_reg (const char *label
, unsigned int sreg
)
911 reg_save (label
, DWARF_FRAME_RETURN_COLUMN
, sreg
, 0);
914 /* Record the initial position of the return address. RTL is
915 INCOMING_RETURN_ADDR_RTX. */
918 initial_return_save (rtx rtl
)
920 unsigned int reg
= (unsigned int) -1;
921 HOST_WIDE_INT offset
= 0;
923 switch (GET_CODE (rtl
))
926 /* RA is in a register. */
927 reg
= DWARF_FRAME_REGNUM (REGNO (rtl
));
931 /* RA is on the stack. */
933 switch (GET_CODE (rtl
))
936 if (REGNO (rtl
) != STACK_POINTER_REGNUM
)
942 if (REGNO (XEXP (rtl
, 0)) != STACK_POINTER_REGNUM
)
944 offset
= INTVAL (XEXP (rtl
, 1));
948 if (REGNO (XEXP (rtl
, 0)) != STACK_POINTER_REGNUM
)
950 offset
= -INTVAL (XEXP (rtl
, 1));
960 /* The return address is at some offset from any value we can
961 actually load. For instance, on the SPARC it is in %i7+8. Just
962 ignore the offset for now; it doesn't matter for unwinding frames. */
963 if (GET_CODE (XEXP (rtl
, 1)) != CONST_INT
)
965 initial_return_save (XEXP (rtl
, 0));
972 reg_save (NULL
, DWARF_FRAME_RETURN_COLUMN
, reg
, offset
- cfa
.offset
);
975 /* Given a SET, calculate the amount of stack adjustment it
979 stack_adjust_offset (rtx pattern
)
981 rtx src
= SET_SRC (pattern
);
982 rtx dest
= SET_DEST (pattern
);
983 HOST_WIDE_INT offset
= 0;
986 if (dest
== stack_pointer_rtx
)
988 /* (set (reg sp) (plus (reg sp) (const_int))) */
989 code
= GET_CODE (src
);
990 if (! (code
== PLUS
|| code
== MINUS
)
991 || XEXP (src
, 0) != stack_pointer_rtx
992 || GET_CODE (XEXP (src
, 1)) != CONST_INT
)
995 offset
= INTVAL (XEXP (src
, 1));
999 else if (GET_CODE (dest
) == MEM
)
1001 /* (set (mem (pre_dec (reg sp))) (foo)) */
1002 src
= XEXP (dest
, 0);
1003 code
= GET_CODE (src
);
1009 if (XEXP (src
, 0) == stack_pointer_rtx
)
1011 rtx val
= XEXP (XEXP (src
, 1), 1);
1012 /* We handle only adjustments by constant amount. */
1013 if (GET_CODE (XEXP (src
, 1)) != PLUS
||
1014 GET_CODE (val
) != CONST_INT
)
1016 offset
= -INTVAL (val
);
1023 if (XEXP (src
, 0) == stack_pointer_rtx
)
1025 offset
= GET_MODE_SIZE (GET_MODE (dest
));
1032 if (XEXP (src
, 0) == stack_pointer_rtx
)
1034 offset
= -GET_MODE_SIZE (GET_MODE (dest
));
1049 /* Check INSN to see if it looks like a push or a stack adjustment, and
1050 make a note of it if it does. EH uses this information to find out how
1051 much extra space it needs to pop off the stack. */
1054 dwarf2out_stack_adjust (rtx insn
)
1056 HOST_WIDE_INT offset
;
1060 if (!flag_asynchronous_unwind_tables
&& GET_CODE (insn
) == CALL_INSN
)
1062 /* Extract the size of the args from the CALL rtx itself. */
1063 insn
= PATTERN (insn
);
1064 if (GET_CODE (insn
) == PARALLEL
)
1065 insn
= XVECEXP (insn
, 0, 0);
1066 if (GET_CODE (insn
) == SET
)
1067 insn
= SET_SRC (insn
);
1068 if (GET_CODE (insn
) != CALL
)
1071 dwarf2out_args_size ("", INTVAL (XEXP (insn
, 1)));
1075 /* If only calls can throw, and we have a frame pointer,
1076 save up adjustments until we see the CALL_INSN. */
1077 else if (!flag_asynchronous_unwind_tables
&& cfa
.reg
!= STACK_POINTER_REGNUM
)
1080 if (GET_CODE (insn
) == BARRIER
)
1082 /* When we see a BARRIER, we know to reset args_size to 0. Usually
1083 the compiler will have already emitted a stack adjustment, but
1084 doesn't bother for calls to noreturn functions. */
1085 #ifdef STACK_GROWS_DOWNWARD
1086 offset
= -args_size
;
1091 else if (GET_CODE (PATTERN (insn
)) == SET
)
1092 offset
= stack_adjust_offset (PATTERN (insn
));
1093 else if (GET_CODE (PATTERN (insn
)) == PARALLEL
1094 || GET_CODE (PATTERN (insn
)) == SEQUENCE
)
1096 /* There may be stack adjustments inside compound insns. Search
1098 for (offset
= 0, i
= XVECLEN (PATTERN (insn
), 0) - 1; i
>= 0; i
--)
1099 if (GET_CODE (XVECEXP (PATTERN (insn
), 0, i
)) == SET
)
1100 offset
+= stack_adjust_offset (XVECEXP (PATTERN (insn
), 0, i
));
1108 if (cfa
.reg
== STACK_POINTER_REGNUM
)
1109 cfa
.offset
+= offset
;
1111 #ifndef STACK_GROWS_DOWNWARD
1115 args_size
+= offset
;
1119 label
= dwarf2out_cfi_label ();
1120 def_cfa_1 (label
, &cfa
);
1121 dwarf2out_args_size (label
, args_size
);
1126 /* We delay emitting a register save until either (a) we reach the end
1127 of the prologue or (b) the register is clobbered. This clusters
1128 register saves so that there are fewer pc advances. */
1130 struct queued_reg_save
GTY(())
1132 struct queued_reg_save
*next
;
1134 HOST_WIDE_INT cfa_offset
;
1137 static GTY(()) struct queued_reg_save
*queued_reg_saves
;
1139 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
1140 static const char *last_reg_save_label
;
1143 queue_reg_save (const char *label
, rtx reg
, HOST_WIDE_INT offset
)
1145 struct queued_reg_save
*q
= ggc_alloc (sizeof (*q
));
1147 q
->next
= queued_reg_saves
;
1149 q
->cfa_offset
= offset
;
1150 queued_reg_saves
= q
;
1152 last_reg_save_label
= label
;
1156 flush_queued_reg_saves (void)
1158 struct queued_reg_save
*q
, *next
;
1160 for (q
= queued_reg_saves
; q
; q
= next
)
1162 dwarf2out_reg_save (last_reg_save_label
, REGNO (q
->reg
), q
->cfa_offset
);
1166 queued_reg_saves
= NULL
;
1167 last_reg_save_label
= NULL
;
1171 clobbers_queued_reg_save (rtx insn
)
1173 struct queued_reg_save
*q
;
1175 for (q
= queued_reg_saves
; q
; q
= q
->next
)
1176 if (modified_in_p (q
->reg
, insn
))
1183 /* A temporary register holding an integral value used in adjusting SP
1184 or setting up the store_reg. The "offset" field holds the integer
1185 value, not an offset. */
1186 static dw_cfa_location cfa_temp
;
1188 /* Record call frame debugging information for an expression EXPR,
1189 which either sets SP or FP (adjusting how we calculate the frame
1190 address) or saves a register to the stack. LABEL indicates the
1193 This function encodes a state machine mapping rtxes to actions on
1194 cfa, cfa_store, and cfa_temp.reg. We describe these rules so
1195 users need not read the source code.
1197 The High-Level Picture
1199 Changes in the register we use to calculate the CFA: Currently we
1200 assume that if you copy the CFA register into another register, we
1201 should take the other one as the new CFA register; this seems to
1202 work pretty well. If it's wrong for some target, it's simple
1203 enough not to set RTX_FRAME_RELATED_P on the insn in question.
1205 Changes in the register we use for saving registers to the stack:
1206 This is usually SP, but not always. Again, we deduce that if you
1207 copy SP into another register (and SP is not the CFA register),
1208 then the new register is the one we will be using for register
1209 saves. This also seems to work.
1211 Register saves: There's not much guesswork about this one; if
1212 RTX_FRAME_RELATED_P is set on an insn which modifies memory, it's a
1213 register save, and the register used to calculate the destination
1214 had better be the one we think we're using for this purpose.
1216 Except: If the register being saved is the CFA register, and the
1217 offset is nonzero, we are saving the CFA, so we assume we have to
1218 use DW_CFA_def_cfa_expression. If the offset is 0, we assume that
1219 the intent is to save the value of SP from the previous frame.
1221 Invariants / Summaries of Rules
1223 cfa current rule for calculating the CFA. It usually
1224 consists of a register and an offset.
1225 cfa_store register used by prologue code to save things to the stack
1226 cfa_store.offset is the offset from the value of
1227 cfa_store.reg to the actual CFA
1228 cfa_temp register holding an integral value. cfa_temp.offset
1229 stores the value, which will be used to adjust the
1230 stack pointer. cfa_temp is also used like cfa_store,
1231 to track stores to the stack via fp or a temp reg.
1233 Rules 1- 4: Setting a register's value to cfa.reg or an expression
1234 with cfa.reg as the first operand changes the cfa.reg and its
1235 cfa.offset. Rule 1 and 4 also set cfa_temp.reg and
1238 Rules 6- 9: Set a non-cfa.reg register value to a constant or an
1239 expression yielding a constant. This sets cfa_temp.reg
1240 and cfa_temp.offset.
1242 Rule 5: Create a new register cfa_store used to save items to the
1245 Rules 10-14: Save a register to the stack. Define offset as the
1246 difference of the original location and cfa_store's
1247 location (or cfa_temp's location if cfa_temp is used).
1251 "{a,b}" indicates a choice of a xor b.
1252 "<reg>:cfa.reg" indicates that <reg> must equal cfa.reg.
1255 (set <reg1> <reg2>:cfa.reg)
1256 effects: cfa.reg = <reg1>
1257 cfa.offset unchanged
1258 cfa_temp.reg = <reg1>
1259 cfa_temp.offset = cfa.offset
1262 (set sp ({minus,plus,losum} {sp,fp}:cfa.reg
1263 {<const_int>,<reg>:cfa_temp.reg}))
1264 effects: cfa.reg = sp if fp used
1265 cfa.offset += {+/- <const_int>, cfa_temp.offset} if cfa.reg==sp
1266 cfa_store.offset += {+/- <const_int>, cfa_temp.offset}
1267 if cfa_store.reg==sp
1270 (set fp ({minus,plus,losum} <reg>:cfa.reg <const_int>))
1271 effects: cfa.reg = fp
1272 cfa_offset += +/- <const_int>
1275 (set <reg1> ({plus,losum} <reg2>:cfa.reg <const_int>))
1276 constraints: <reg1> != fp
1278 effects: cfa.reg = <reg1>
1279 cfa_temp.reg = <reg1>
1280 cfa_temp.offset = cfa.offset
1283 (set <reg1> (plus <reg2>:cfa_temp.reg sp:cfa.reg))
1284 constraints: <reg1> != fp
1286 effects: cfa_store.reg = <reg1>
1287 cfa_store.offset = cfa.offset - cfa_temp.offset
1290 (set <reg> <const_int>)
1291 effects: cfa_temp.reg = <reg>
1292 cfa_temp.offset = <const_int>
1295 (set <reg1>:cfa_temp.reg (ior <reg2>:cfa_temp.reg <const_int>))
1296 effects: cfa_temp.reg = <reg1>
1297 cfa_temp.offset |= <const_int>
1300 (set <reg> (high <exp>))
1304 (set <reg> (lo_sum <exp> <const_int>))
1305 effects: cfa_temp.reg = <reg>
1306 cfa_temp.offset = <const_int>
1309 (set (mem (pre_modify sp:cfa_store (???? <reg1> <const_int>))) <reg2>)
1310 effects: cfa_store.offset -= <const_int>
1311 cfa.offset = cfa_store.offset if cfa.reg == sp
1313 cfa.base_offset = -cfa_store.offset
1316 (set (mem ({pre_inc,pre_dec} sp:cfa_store.reg)) <reg>)
1317 effects: cfa_store.offset += -/+ mode_size(mem)
1318 cfa.offset = cfa_store.offset if cfa.reg == sp
1320 cfa.base_offset = -cfa_store.offset
1323 (set (mem ({minus,plus,losum} <reg1>:{cfa_store,cfa_temp} <const_int>))
1326 effects: cfa.reg = <reg1>
1327 cfa.base_offset = -/+ <const_int> - {cfa_store,cfa_temp}.offset
1330 (set (mem <reg1>:{cfa_store,cfa_temp}) <reg2>)
1331 effects: cfa.reg = <reg1>
1332 cfa.base_offset = -{cfa_store,cfa_temp}.offset
1335 (set (mem (postinc <reg1>:cfa_temp <const_int>)) <reg2>)
1336 effects: cfa.reg = <reg1>
1337 cfa.base_offset = -cfa_temp.offset
1338 cfa_temp.offset -= mode_size(mem) */
1341 dwarf2out_frame_debug_expr (rtx expr
, const char *label
)
1344 HOST_WIDE_INT offset
;
1346 /* If RTX_FRAME_RELATED_P is set on a PARALLEL, process each member of
1347 the PARALLEL independently. The first element is always processed if
1348 it is a SET. This is for backward compatibility. Other elements
1349 are processed only if they are SETs and the RTX_FRAME_RELATED_P
1350 flag is set in them. */
1351 if (GET_CODE (expr
) == PARALLEL
|| GET_CODE (expr
) == SEQUENCE
)
1354 int limit
= XVECLEN (expr
, 0);
1356 for (par_index
= 0; par_index
< limit
; par_index
++)
1357 if (GET_CODE (XVECEXP (expr
, 0, par_index
)) == SET
1358 && (RTX_FRAME_RELATED_P (XVECEXP (expr
, 0, par_index
))
1360 dwarf2out_frame_debug_expr (XVECEXP (expr
, 0, par_index
), label
);
1365 if (GET_CODE (expr
) != SET
)
1368 src
= SET_SRC (expr
);
1369 dest
= SET_DEST (expr
);
1371 switch (GET_CODE (dest
))
1375 /* Update the CFA rule wrt SP or FP. Make sure src is
1376 relative to the current CFA register. */
1377 switch (GET_CODE (src
))
1379 /* Setting FP from SP. */
1381 if (cfa
.reg
== (unsigned) REGNO (src
))
1387 /* We used to require that dest be either SP or FP, but the
1388 ARM copies SP to a temporary register, and from there to
1389 FP. So we just rely on the backends to only set
1390 RTX_FRAME_RELATED_P on appropriate insns. */
1391 cfa
.reg
= REGNO (dest
);
1392 cfa_temp
.reg
= cfa
.reg
;
1393 cfa_temp
.offset
= cfa
.offset
;
1399 if (dest
== stack_pointer_rtx
)
1403 switch (GET_CODE (XEXP (src
, 1)))
1406 offset
= INTVAL (XEXP (src
, 1));
1409 if ((unsigned) REGNO (XEXP (src
, 1)) != cfa_temp
.reg
)
1411 offset
= cfa_temp
.offset
;
1417 if (XEXP (src
, 0) == hard_frame_pointer_rtx
)
1419 /* Restoring SP from FP in the epilogue. */
1420 if (cfa
.reg
!= (unsigned) HARD_FRAME_POINTER_REGNUM
)
1422 cfa
.reg
= STACK_POINTER_REGNUM
;
1424 else if (GET_CODE (src
) == LO_SUM
)
1425 /* Assume we've set the source reg of the LO_SUM from sp. */
1427 else if (XEXP (src
, 0) != stack_pointer_rtx
)
1430 if (GET_CODE (src
) != MINUS
)
1432 if (cfa
.reg
== STACK_POINTER_REGNUM
)
1433 cfa
.offset
+= offset
;
1434 if (cfa_store
.reg
== STACK_POINTER_REGNUM
)
1435 cfa_store
.offset
+= offset
;
1437 else if (dest
== hard_frame_pointer_rtx
)
1440 /* Either setting the FP from an offset of the SP,
1441 or adjusting the FP */
1442 if (! frame_pointer_needed
)
1445 if (GET_CODE (XEXP (src
, 0)) == REG
1446 && (unsigned) REGNO (XEXP (src
, 0)) == cfa
.reg
1447 && GET_CODE (XEXP (src
, 1)) == CONST_INT
)
1449 offset
= INTVAL (XEXP (src
, 1));
1450 if (GET_CODE (src
) != MINUS
)
1452 cfa
.offset
+= offset
;
1453 cfa
.reg
= HARD_FRAME_POINTER_REGNUM
;
1460 if (GET_CODE (src
) == MINUS
)
1464 if (GET_CODE (XEXP (src
, 0)) == REG
1465 && REGNO (XEXP (src
, 0)) == cfa
.reg
1466 && GET_CODE (XEXP (src
, 1)) == CONST_INT
)
1468 /* Setting a temporary CFA register that will be copied
1469 into the FP later on. */
1470 offset
= - INTVAL (XEXP (src
, 1));
1471 cfa
.offset
+= offset
;
1472 cfa
.reg
= REGNO (dest
);
1473 /* Or used to save regs to the stack. */
1474 cfa_temp
.reg
= cfa
.reg
;
1475 cfa_temp
.offset
= cfa
.offset
;
1479 else if (GET_CODE (XEXP (src
, 0)) == REG
1480 && REGNO (XEXP (src
, 0)) == cfa_temp
.reg
1481 && XEXP (src
, 1) == stack_pointer_rtx
)
1483 /* Setting a scratch register that we will use instead
1484 of SP for saving registers to the stack. */
1485 if (cfa
.reg
!= STACK_POINTER_REGNUM
)
1487 cfa_store
.reg
= REGNO (dest
);
1488 cfa_store
.offset
= cfa
.offset
- cfa_temp
.offset
;
1492 else if (GET_CODE (src
) == LO_SUM
1493 && GET_CODE (XEXP (src
, 1)) == CONST_INT
)
1495 cfa_temp
.reg
= REGNO (dest
);
1496 cfa_temp
.offset
= INTVAL (XEXP (src
, 1));
1505 cfa_temp
.reg
= REGNO (dest
);
1506 cfa_temp
.offset
= INTVAL (src
);
1511 if (GET_CODE (XEXP (src
, 0)) != REG
1512 || (unsigned) REGNO (XEXP (src
, 0)) != cfa_temp
.reg
1513 || GET_CODE (XEXP (src
, 1)) != CONST_INT
)
1516 if ((unsigned) REGNO (dest
) != cfa_temp
.reg
)
1517 cfa_temp
.reg
= REGNO (dest
);
1518 cfa_temp
.offset
|= INTVAL (XEXP (src
, 1));
1521 /* Skip over HIGH, assuming it will be followed by a LO_SUM,
1522 which will fill in all of the bits. */
1531 def_cfa_1 (label
, &cfa
);
1535 if (GET_CODE (src
) != REG
)
1538 /* Saving a register to the stack. Make sure dest is relative to the
1540 switch (GET_CODE (XEXP (dest
, 0)))
1545 /* We can't handle variable size modifications. */
1546 if (GET_CODE (XEXP (XEXP (XEXP (dest
, 0), 1), 1)) != CONST_INT
)
1548 offset
= -INTVAL (XEXP (XEXP (XEXP (dest
, 0), 1), 1));
1550 if (REGNO (XEXP (XEXP (dest
, 0), 0)) != STACK_POINTER_REGNUM
1551 || cfa_store
.reg
!= STACK_POINTER_REGNUM
)
1554 cfa_store
.offset
+= offset
;
1555 if (cfa
.reg
== STACK_POINTER_REGNUM
)
1556 cfa
.offset
= cfa_store
.offset
;
1558 offset
= -cfa_store
.offset
;
1564 offset
= GET_MODE_SIZE (GET_MODE (dest
));
1565 if (GET_CODE (XEXP (dest
, 0)) == PRE_INC
)
1568 if (REGNO (XEXP (XEXP (dest
, 0), 0)) != STACK_POINTER_REGNUM
1569 || cfa_store
.reg
!= STACK_POINTER_REGNUM
)
1572 cfa_store
.offset
+= offset
;
1573 if (cfa
.reg
== STACK_POINTER_REGNUM
)
1574 cfa
.offset
= cfa_store
.offset
;
1576 offset
= -cfa_store
.offset
;
1580 /* With an offset. */
1584 if (GET_CODE (XEXP (XEXP (dest
, 0), 1)) != CONST_INT
)
1586 offset
= INTVAL (XEXP (XEXP (dest
, 0), 1));
1587 if (GET_CODE (XEXP (dest
, 0)) == MINUS
)
1590 if (cfa_store
.reg
== (unsigned) REGNO (XEXP (XEXP (dest
, 0), 0)))
1591 offset
-= cfa_store
.offset
;
1592 else if (cfa_temp
.reg
== (unsigned) REGNO (XEXP (XEXP (dest
, 0), 0)))
1593 offset
-= cfa_temp
.offset
;
1599 /* Without an offset. */
1601 if (cfa_store
.reg
== (unsigned) REGNO (XEXP (dest
, 0)))
1602 offset
= -cfa_store
.offset
;
1603 else if (cfa_temp
.reg
== (unsigned) REGNO (XEXP (dest
, 0)))
1604 offset
= -cfa_temp
.offset
;
1611 if (cfa_temp
.reg
!= (unsigned) REGNO (XEXP (XEXP (dest
, 0), 0)))
1613 offset
= -cfa_temp
.offset
;
1614 cfa_temp
.offset
-= GET_MODE_SIZE (GET_MODE (dest
));
1621 if (REGNO (src
) != STACK_POINTER_REGNUM
1622 && REGNO (src
) != HARD_FRAME_POINTER_REGNUM
1623 && (unsigned) REGNO (src
) == cfa
.reg
)
1625 /* We're storing the current CFA reg into the stack. */
1627 if (cfa
.offset
== 0)
1629 /* If the source register is exactly the CFA, assume
1630 we're saving SP like any other register; this happens
1632 def_cfa_1 (label
, &cfa
);
1633 queue_reg_save (label
, stack_pointer_rtx
, offset
);
1638 /* Otherwise, we'll need to look in the stack to
1639 calculate the CFA. */
1640 rtx x
= XEXP (dest
, 0);
1642 if (GET_CODE (x
) != REG
)
1644 if (GET_CODE (x
) != REG
)
1647 cfa
.reg
= REGNO (x
);
1648 cfa
.base_offset
= offset
;
1650 def_cfa_1 (label
, &cfa
);
1655 def_cfa_1 (label
, &cfa
);
1656 queue_reg_save (label
, src
, offset
);
1664 /* Record call frame debugging information for INSN, which either
1665 sets SP or FP (adjusting how we calculate the frame address) or saves a
1666 register to the stack. If INSN is NULL_RTX, initialize our state. */
1669 dwarf2out_frame_debug (rtx insn
)
1674 if (insn
== NULL_RTX
)
1676 /* Flush any queued register saves. */
1677 flush_queued_reg_saves ();
1679 /* Set up state for generating call frame debug info. */
1681 if (cfa
.reg
!= (unsigned long) DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM
))
1684 cfa
.reg
= STACK_POINTER_REGNUM
;
1687 cfa_temp
.offset
= 0;
1691 if (GET_CODE (insn
) != INSN
|| clobbers_queued_reg_save (insn
))
1692 flush_queued_reg_saves ();
1694 if (! RTX_FRAME_RELATED_P (insn
))
1696 if (!ACCUMULATE_OUTGOING_ARGS
)
1697 dwarf2out_stack_adjust (insn
);
1702 label
= dwarf2out_cfi_label ();
1703 src
= find_reg_note (insn
, REG_FRAME_RELATED_EXPR
, NULL_RTX
);
1705 insn
= XEXP (src
, 0);
1707 insn
= PATTERN (insn
);
1709 dwarf2out_frame_debug_expr (insn
, label
);
1714 /* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used. */
1715 static enum dw_cfi_oprnd_type dw_cfi_oprnd1_desc
1716 (enum dwarf_call_frame_info cfi
);
1718 static enum dw_cfi_oprnd_type
1719 dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi
)
1724 case DW_CFA_GNU_window_save
:
1725 return dw_cfi_oprnd_unused
;
1727 case DW_CFA_set_loc
:
1728 case DW_CFA_advance_loc1
:
1729 case DW_CFA_advance_loc2
:
1730 case DW_CFA_advance_loc4
:
1731 case DW_CFA_MIPS_advance_loc8
:
1732 return dw_cfi_oprnd_addr
;
1735 case DW_CFA_offset_extended
:
1736 case DW_CFA_def_cfa
:
1737 case DW_CFA_offset_extended_sf
:
1738 case DW_CFA_def_cfa_sf
:
1739 case DW_CFA_restore_extended
:
1740 case DW_CFA_undefined
:
1741 case DW_CFA_same_value
:
1742 case DW_CFA_def_cfa_register
:
1743 case DW_CFA_register
:
1744 return dw_cfi_oprnd_reg_num
;
1746 case DW_CFA_def_cfa_offset
:
1747 case DW_CFA_GNU_args_size
:
1748 case DW_CFA_def_cfa_offset_sf
:
1749 return dw_cfi_oprnd_offset
;
1751 case DW_CFA_def_cfa_expression
:
1752 case DW_CFA_expression
:
1753 return dw_cfi_oprnd_loc
;
1760 /* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used. */
1761 static enum dw_cfi_oprnd_type dw_cfi_oprnd2_desc
1762 (enum dwarf_call_frame_info cfi
);
1764 static enum dw_cfi_oprnd_type
1765 dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi
)
1769 case DW_CFA_def_cfa
:
1770 case DW_CFA_def_cfa_sf
:
1772 case DW_CFA_offset_extended_sf
:
1773 case DW_CFA_offset_extended
:
1774 return dw_cfi_oprnd_offset
;
1776 case DW_CFA_register
:
1777 return dw_cfi_oprnd_reg_num
;
1780 return dw_cfi_oprnd_unused
;
1784 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
1786 /* Output a Call Frame Information opcode and its operand(s). */
1789 output_cfi (dw_cfi_ref cfi
, dw_fde_ref fde
, int for_eh
)
1791 if (cfi
->dw_cfi_opc
== DW_CFA_advance_loc
)
1792 dw2_asm_output_data (1, (cfi
->dw_cfi_opc
1793 | (cfi
->dw_cfi_oprnd1
.dw_cfi_offset
& 0x3f)),
1794 "DW_CFA_advance_loc " HOST_WIDE_INT_PRINT_HEX
,
1795 cfi
->dw_cfi_oprnd1
.dw_cfi_offset
);
1796 else if (cfi
->dw_cfi_opc
== DW_CFA_offset
)
1798 dw2_asm_output_data (1, (cfi
->dw_cfi_opc
1799 | (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
& 0x3f)),
1800 "DW_CFA_offset, column 0x%lx",
1801 cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
);
1802 dw2_asm_output_data_uleb128 (cfi
->dw_cfi_oprnd2
.dw_cfi_offset
, NULL
);
1804 else if (cfi
->dw_cfi_opc
== DW_CFA_restore
)
1805 dw2_asm_output_data (1, (cfi
->dw_cfi_opc
1806 | (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
& 0x3f)),
1807 "DW_CFA_restore, column 0x%lx",
1808 cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
);
1811 dw2_asm_output_data (1, cfi
->dw_cfi_opc
,
1812 "%s", dwarf_cfi_name (cfi
->dw_cfi_opc
));
1814 switch (cfi
->dw_cfi_opc
)
1816 case DW_CFA_set_loc
:
1818 dw2_asm_output_encoded_addr_rtx (
1819 ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0),
1820 gen_rtx_SYMBOL_REF (Pmode
, cfi
->dw_cfi_oprnd1
.dw_cfi_addr
),
1823 dw2_asm_output_addr (DWARF2_ADDR_SIZE
,
1824 cfi
->dw_cfi_oprnd1
.dw_cfi_addr
, NULL
);
1827 case DW_CFA_advance_loc1
:
1828 dw2_asm_output_delta (1, cfi
->dw_cfi_oprnd1
.dw_cfi_addr
,
1829 fde
->dw_fde_current_label
, NULL
);
1830 fde
->dw_fde_current_label
= cfi
->dw_cfi_oprnd1
.dw_cfi_addr
;
1833 case DW_CFA_advance_loc2
:
1834 dw2_asm_output_delta (2, cfi
->dw_cfi_oprnd1
.dw_cfi_addr
,
1835 fde
->dw_fde_current_label
, NULL
);
1836 fde
->dw_fde_current_label
= cfi
->dw_cfi_oprnd1
.dw_cfi_addr
;
1839 case DW_CFA_advance_loc4
:
1840 dw2_asm_output_delta (4, cfi
->dw_cfi_oprnd1
.dw_cfi_addr
,
1841 fde
->dw_fde_current_label
, NULL
);
1842 fde
->dw_fde_current_label
= cfi
->dw_cfi_oprnd1
.dw_cfi_addr
;
1845 case DW_CFA_MIPS_advance_loc8
:
1846 dw2_asm_output_delta (8, cfi
->dw_cfi_oprnd1
.dw_cfi_addr
,
1847 fde
->dw_fde_current_label
, NULL
);
1848 fde
->dw_fde_current_label
= cfi
->dw_cfi_oprnd1
.dw_cfi_addr
;
1851 case DW_CFA_offset_extended
:
1852 case DW_CFA_def_cfa
:
1853 dw2_asm_output_data_uleb128 (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
,
1855 dw2_asm_output_data_uleb128 (cfi
->dw_cfi_oprnd2
.dw_cfi_offset
, NULL
);
1858 case DW_CFA_offset_extended_sf
:
1859 case DW_CFA_def_cfa_sf
:
1860 dw2_asm_output_data_uleb128 (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
,
1862 dw2_asm_output_data_sleb128 (cfi
->dw_cfi_oprnd2
.dw_cfi_offset
, NULL
);
1865 case DW_CFA_restore_extended
:
1866 case DW_CFA_undefined
:
1867 case DW_CFA_same_value
:
1868 case DW_CFA_def_cfa_register
:
1869 dw2_asm_output_data_uleb128 (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
,
1873 case DW_CFA_register
:
1874 dw2_asm_output_data_uleb128 (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
,
1876 dw2_asm_output_data_uleb128 (cfi
->dw_cfi_oprnd2
.dw_cfi_reg_num
,
1880 case DW_CFA_def_cfa_offset
:
1881 case DW_CFA_GNU_args_size
:
1882 dw2_asm_output_data_uleb128 (cfi
->dw_cfi_oprnd1
.dw_cfi_offset
, NULL
);
1885 case DW_CFA_def_cfa_offset_sf
:
1886 dw2_asm_output_data_sleb128 (cfi
->dw_cfi_oprnd1
.dw_cfi_offset
, NULL
);
1889 case DW_CFA_GNU_window_save
:
1892 case DW_CFA_def_cfa_expression
:
1893 case DW_CFA_expression
:
1894 output_cfa_loc (cfi
);
1897 case DW_CFA_GNU_negative_offset_extended
:
1898 /* Obsoleted by DW_CFA_offset_extended_sf. */
1907 /* Output the call frame information used to used to record information
1908 that relates to calculating the frame pointer, and records the
1909 location of saved registers. */
1912 output_call_frame_info (int for_eh
)
1917 char l1
[20], l2
[20], section_start_label
[20];
1918 bool any_lsda_needed
= false;
1919 char augmentation
[6];
1920 int augmentation_size
;
1921 int fde_encoding
= DW_EH_PE_absptr
;
1922 int per_encoding
= DW_EH_PE_absptr
;
1923 int lsda_encoding
= DW_EH_PE_absptr
;
1925 /* Don't emit a CIE if there won't be any FDEs. */
1926 if (fde_table_in_use
== 0)
1929 /* If we don't have any functions we'll want to unwind out of, don't
1930 emit any EH unwind information. Note that if exceptions aren't
1931 enabled, we won't have collected nothrow information, and if we
1932 asked for asynchronous tables, we always want this info. */
1935 bool any_eh_needed
= !flag_exceptions
|| flag_asynchronous_unwind_tables
;
1937 for (i
= 0; i
< fde_table_in_use
; i
++)
1938 if (fde_table
[i
].uses_eh_lsda
)
1939 any_eh_needed
= any_lsda_needed
= true;
1940 else if (! fde_table
[i
].nothrow
1941 && ! fde_table
[i
].all_throwers_are_sibcalls
)
1942 any_eh_needed
= true;
1944 if (! any_eh_needed
)
1948 /* We're going to be generating comments, so turn on app. */
1953 (*targetm
.asm_out
.eh_frame_section
) ();
1955 named_section_flags (DEBUG_FRAME_SECTION
, SECTION_DEBUG
);
1957 ASM_GENERATE_INTERNAL_LABEL (section_start_label
, FRAME_BEGIN_LABEL
, for_eh
);
1958 ASM_OUTPUT_LABEL (asm_out_file
, section_start_label
);
1960 /* Output the CIE. */
1961 ASM_GENERATE_INTERNAL_LABEL (l1
, CIE_AFTER_SIZE_LABEL
, for_eh
);
1962 ASM_GENERATE_INTERNAL_LABEL (l2
, CIE_END_LABEL
, for_eh
);
1963 dw2_asm_output_delta (for_eh
? 4 : DWARF_OFFSET_SIZE
, l2
, l1
,
1964 "Length of Common Information Entry");
1965 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
1967 /* Now that the CIE pointer is PC-relative for EH,
1968 use 0 to identify the CIE. */
1969 dw2_asm_output_data ((for_eh
? 4 : DWARF_OFFSET_SIZE
),
1970 (for_eh
? 0 : DW_CIE_ID
),
1971 "CIE Identifier Tag");
1973 dw2_asm_output_data (1, DW_CIE_VERSION
, "CIE Version");
1975 augmentation
[0] = 0;
1976 augmentation_size
= 0;
1982 z Indicates that a uleb128 is present to size the
1983 augmentation section.
1984 L Indicates the encoding (and thus presence) of
1985 an LSDA pointer in the FDE augmentation.
1986 R Indicates a non-default pointer encoding for
1988 P Indicates the presence of an encoding + language
1989 personality routine in the CIE augmentation. */
1991 fde_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0);
1992 per_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
1993 lsda_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
1995 p
= augmentation
+ 1;
1996 if (eh_personality_libfunc
)
1999 augmentation_size
+= 1 + size_of_encoded_value (per_encoding
);
2001 if (any_lsda_needed
)
2004 augmentation_size
+= 1;
2006 if (fde_encoding
!= DW_EH_PE_absptr
)
2009 augmentation_size
+= 1;
2011 if (p
> augmentation
+ 1)
2013 augmentation
[0] = 'z';
2017 /* Ug. Some platforms can't do unaligned dynamic relocations at all. */
2018 if (eh_personality_libfunc
&& per_encoding
== DW_EH_PE_aligned
)
2020 int offset
= ( 4 /* Length */
2022 + 1 /* CIE version */
2023 + strlen (augmentation
) + 1 /* Augmentation */
2024 + size_of_uleb128 (1) /* Code alignment */
2025 + size_of_sleb128 (DWARF_CIE_DATA_ALIGNMENT
)
2027 + 1 /* Augmentation size */
2028 + 1 /* Personality encoding */ );
2029 int pad
= -offset
& (PTR_SIZE
- 1);
2031 augmentation_size
+= pad
;
2033 /* Augmentations should be small, so there's scarce need to
2034 iterate for a solution. Die if we exceed one uleb128 byte. */
2035 if (size_of_uleb128 (augmentation_size
) != 1)
2040 dw2_asm_output_nstring (augmentation
, -1, "CIE Augmentation");
2041 dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor");
2042 dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT
,
2043 "CIE Data Alignment Factor");
2044 dw2_asm_output_data (1, DWARF_FRAME_RETURN_COLUMN
, "CIE RA Column");
2046 if (augmentation
[0])
2048 dw2_asm_output_data_uleb128 (augmentation_size
, "Augmentation size");
2049 if (eh_personality_libfunc
)
2051 dw2_asm_output_data (1, per_encoding
, "Personality (%s)",
2052 eh_data_format_name (per_encoding
));
2053 dw2_asm_output_encoded_addr_rtx (per_encoding
,
2054 eh_personality_libfunc
, NULL
);
2057 if (any_lsda_needed
)
2058 dw2_asm_output_data (1, lsda_encoding
, "LSDA Encoding (%s)",
2059 eh_data_format_name (lsda_encoding
));
2061 if (fde_encoding
!= DW_EH_PE_absptr
)
2062 dw2_asm_output_data (1, fde_encoding
, "FDE Encoding (%s)",
2063 eh_data_format_name (fde_encoding
));
2066 for (cfi
= cie_cfi_head
; cfi
!= NULL
; cfi
= cfi
->dw_cfi_next
)
2067 output_cfi (cfi
, NULL
, for_eh
);
2069 /* Pad the CIE out to an address sized boundary. */
2070 ASM_OUTPUT_ALIGN (asm_out_file
,
2071 floor_log2 (for_eh
? PTR_SIZE
: DWARF2_ADDR_SIZE
));
2072 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
2074 /* Loop through all of the FDE's. */
2075 for (i
= 0; i
< fde_table_in_use
; i
++)
2077 fde
= &fde_table
[i
];
2079 /* Don't emit EH unwind info for leaf functions that don't need it. */
2080 if (for_eh
&& !flag_asynchronous_unwind_tables
&& flag_exceptions
2081 && (fde
->nothrow
|| fde
->all_throwers_are_sibcalls
)
2082 && !fde
->uses_eh_lsda
)
2085 (*targetm
.asm_out
.internal_label
) (asm_out_file
, FDE_LABEL
, for_eh
+ i
* 2);
2086 ASM_GENERATE_INTERNAL_LABEL (l1
, FDE_AFTER_SIZE_LABEL
, for_eh
+ i
* 2);
2087 ASM_GENERATE_INTERNAL_LABEL (l2
, FDE_END_LABEL
, for_eh
+ i
* 2);
2088 dw2_asm_output_delta (for_eh
? 4 : DWARF_OFFSET_SIZE
, l2
, l1
,
2090 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
2093 dw2_asm_output_delta (4, l1
, section_start_label
, "FDE CIE offset");
2095 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, section_start_label
,
2100 dw2_asm_output_encoded_addr_rtx (fde_encoding
,
2101 gen_rtx_SYMBOL_REF (Pmode
, fde
->dw_fde_begin
),
2102 "FDE initial location");
2103 dw2_asm_output_delta (size_of_encoded_value (fde_encoding
),
2104 fde
->dw_fde_end
, fde
->dw_fde_begin
,
2105 "FDE address range");
2109 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, fde
->dw_fde_begin
,
2110 "FDE initial location");
2111 dw2_asm_output_delta (DWARF2_ADDR_SIZE
,
2112 fde
->dw_fde_end
, fde
->dw_fde_begin
,
2113 "FDE address range");
2116 if (augmentation
[0])
2118 if (any_lsda_needed
)
2120 int size
= size_of_encoded_value (lsda_encoding
);
2122 if (lsda_encoding
== DW_EH_PE_aligned
)
2124 int offset
= ( 4 /* Length */
2125 + 4 /* CIE offset */
2126 + 2 * size_of_encoded_value (fde_encoding
)
2127 + 1 /* Augmentation size */ );
2128 int pad
= -offset
& (PTR_SIZE
- 1);
2131 if (size_of_uleb128 (size
) != 1)
2135 dw2_asm_output_data_uleb128 (size
, "Augmentation size");
2137 if (fde
->uses_eh_lsda
)
2139 ASM_GENERATE_INTERNAL_LABEL (l1
, "LLSDA",
2140 fde
->funcdef_number
);
2141 dw2_asm_output_encoded_addr_rtx (
2142 lsda_encoding
, gen_rtx_SYMBOL_REF (Pmode
, l1
),
2143 "Language Specific Data Area");
2147 if (lsda_encoding
== DW_EH_PE_aligned
)
2148 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (PTR_SIZE
));
2150 (size_of_encoded_value (lsda_encoding
), 0,
2151 "Language Specific Data Area (none)");
2155 dw2_asm_output_data_uleb128 (0, "Augmentation size");
2158 /* Loop through the Call Frame Instructions associated with
2160 fde
->dw_fde_current_label
= fde
->dw_fde_begin
;
2161 for (cfi
= fde
->dw_fde_cfi
; cfi
!= NULL
; cfi
= cfi
->dw_cfi_next
)
2162 output_cfi (cfi
, fde
, for_eh
);
2164 /* Pad the FDE out to an address sized boundary. */
2165 ASM_OUTPUT_ALIGN (asm_out_file
,
2166 floor_log2 ((for_eh
? PTR_SIZE
: DWARF2_ADDR_SIZE
)));
2167 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
2170 if (for_eh
&& targetm
.terminate_dw2_eh_frame_info
)
2171 dw2_asm_output_data (4, 0, "End of Table");
2172 #ifdef MIPS_DEBUGGING_INFO
2173 /* Work around Irix 6 assembler bug whereby labels at the end of a section
2174 get a value of 0. Putting .align 0 after the label fixes it. */
2175 ASM_OUTPUT_ALIGN (asm_out_file
, 0);
2178 /* Turn off app to make assembly quicker. */
2183 /* Output a marker (i.e. a label) for the beginning of a function, before
2187 dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED
,
2188 const char *file ATTRIBUTE_UNUSED
)
2190 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
2193 current_function_func_begin_label
= 0;
2195 #ifdef IA64_UNWIND_INFO
2196 /* ??? current_function_func_begin_label is also used by except.c
2197 for call-site information. We must emit this label if it might
2199 if ((! flag_exceptions
|| USING_SJLJ_EXCEPTIONS
)
2200 && ! dwarf2out_do_frame ())
2203 if (! dwarf2out_do_frame ())
2207 function_section (current_function_decl
);
2208 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_BEGIN_LABEL
,
2209 current_function_funcdef_no
);
2210 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, FUNC_BEGIN_LABEL
,
2211 current_function_funcdef_no
);
2212 current_function_func_begin_label
= get_identifier (label
);
2214 #ifdef IA64_UNWIND_INFO
2215 /* We can elide the fde allocation if we're not emitting debug info. */
2216 if (! dwarf2out_do_frame ())
2220 /* Expand the fde table if necessary. */
2221 if (fde_table_in_use
== fde_table_allocated
)
2223 fde_table_allocated
+= FDE_TABLE_INCREMENT
;
2224 fde_table
= ggc_realloc (fde_table
,
2225 fde_table_allocated
* sizeof (dw_fde_node
));
2226 memset (fde_table
+ fde_table_in_use
, 0,
2227 FDE_TABLE_INCREMENT
* sizeof (dw_fde_node
));
2230 /* Record the FDE associated with this function. */
2231 current_funcdef_fde
= fde_table_in_use
;
2233 /* Add the new FDE at the end of the fde_table. */
2234 fde
= &fde_table
[fde_table_in_use
++];
2235 fde
->dw_fde_begin
= xstrdup (label
);
2236 fde
->dw_fde_current_label
= NULL
;
2237 fde
->dw_fde_end
= NULL
;
2238 fde
->dw_fde_cfi
= NULL
;
2239 fde
->funcdef_number
= current_function_funcdef_no
;
2240 fde
->nothrow
= current_function_nothrow
;
2241 fde
->uses_eh_lsda
= cfun
->uses_eh_lsda
;
2242 fde
->all_throwers_are_sibcalls
= cfun
->all_throwers_are_sibcalls
;
2244 args_size
= old_args_size
= 0;
2246 /* We only want to output line number information for the genuine dwarf2
2247 prologue case, not the eh frame case. */
2248 #ifdef DWARF2_DEBUGGING_INFO
2250 dwarf2out_source_line (line
, file
);
2254 /* Output a marker (i.e. a label) for the absolute end of the generated code
2255 for a function definition. This gets called *after* the epilogue code has
2259 dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED
,
2260 const char *file ATTRIBUTE_UNUSED
)
2263 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
2265 /* Output a label to mark the endpoint of the code generated for this
2267 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_END_LABEL
,
2268 current_function_funcdef_no
);
2269 ASM_OUTPUT_LABEL (asm_out_file
, label
);
2270 fde
= &fde_table
[fde_table_in_use
- 1];
2271 fde
->dw_fde_end
= xstrdup (label
);
2275 dwarf2out_frame_init (void)
2277 /* Allocate the initial hunk of the fde_table. */
2278 fde_table
= ggc_alloc_cleared (FDE_TABLE_INCREMENT
* sizeof (dw_fde_node
));
2279 fde_table_allocated
= FDE_TABLE_INCREMENT
;
2280 fde_table_in_use
= 0;
2282 /* Generate the CFA instructions common to all FDE's. Do it now for the
2283 sake of lookup_cfa. */
2285 #ifdef DWARF2_UNWIND_INFO
2286 /* On entry, the Canonical Frame Address is at SP. */
2287 dwarf2out_def_cfa (NULL
, STACK_POINTER_REGNUM
, INCOMING_FRAME_SP_OFFSET
);
2288 initial_return_save (INCOMING_RETURN_ADDR_RTX
);
2293 dwarf2out_frame_finish (void)
2295 /* Output call frame information. */
2296 if (write_symbols
== DWARF2_DEBUG
|| write_symbols
== VMS_AND_DWARF2_DEBUG
)
2297 output_call_frame_info (0);
2299 if (! USING_SJLJ_EXCEPTIONS
&& (flag_unwind_tables
|| flag_exceptions
))
2300 output_call_frame_info (1);
2304 /* And now, the subset of the debugging information support code necessary
2305 for emitting location expressions. */
2307 /* We need some way to distinguish DW_OP_addr with a direct symbol
2308 relocation from DW_OP_addr with a dtp-relative symbol relocation. */
2309 #define INTERNAL_DW_OP_tls_addr (0x100 + DW_OP_addr)
2312 typedef struct dw_val_struct
*dw_val_ref
;
2313 typedef struct die_struct
*dw_die_ref
;
2314 typedef struct dw_loc_descr_struct
*dw_loc_descr_ref
;
2315 typedef struct dw_loc_list_struct
*dw_loc_list_ref
;
2317 /* Each DIE may have a series of attribute/value pairs. Values
2318 can take on several forms. The forms that are used in this
2319 implementation are listed below. */
2324 dw_val_class_offset
,
2326 dw_val_class_loc_list
,
2327 dw_val_class_range_list
,
2329 dw_val_class_unsigned_const
,
2330 dw_val_class_long_long
,
2333 dw_val_class_die_ref
,
2334 dw_val_class_fde_ref
,
2335 dw_val_class_lbl_id
,
2336 dw_val_class_lbl_offset
,
2340 /* Describe a double word constant value. */
2341 /* ??? Every instance of long_long in the code really means CONST_DOUBLE. */
2343 typedef struct dw_long_long_struct
GTY(())
2350 /* Describe a floating point constant value. */
2352 typedef struct dw_fp_struct
GTY(())
2354 long * GTY((length ("%h.length"))) array
;
2359 /* The dw_val_node describes an attribute's value, as it is
2360 represented internally. */
2362 typedef struct dw_val_struct
GTY(())
2364 enum dw_val_class val_class
;
2365 union dw_val_struct_union
2367 rtx
GTY ((tag ("dw_val_class_addr"))) val_addr
;
2368 unsigned HOST_WIDE_INT
GTY ((tag ("dw_val_class_offset"))) val_offset
;
2369 dw_loc_list_ref
GTY ((tag ("dw_val_class_loc_list"))) val_loc_list
;
2370 dw_loc_descr_ref
GTY ((tag ("dw_val_class_loc"))) val_loc
;
2371 HOST_WIDE_INT
GTY ((default (""))) val_int
;
2372 unsigned HOST_WIDE_INT
GTY ((tag ("dw_val_class_unsigned_const"))) val_unsigned
;
2373 dw_long_long_const
GTY ((tag ("dw_val_class_long_long"))) val_long_long
;
2374 dw_float_const
GTY ((tag ("dw_val_class_float"))) val_float
;
2375 struct dw_val_die_union
2379 } GTY ((tag ("dw_val_class_die_ref"))) val_die_ref
;
2380 unsigned GTY ((tag ("dw_val_class_fde_ref"))) val_fde_index
;
2381 struct indirect_string_node
* GTY ((tag ("dw_val_class_str"))) val_str
;
2382 char * GTY ((tag ("dw_val_class_lbl_id"))) val_lbl_id
;
2383 unsigned char GTY ((tag ("dw_val_class_flag"))) val_flag
;
2385 GTY ((desc ("%1.val_class"))) v
;
2389 /* Locations in memory are described using a sequence of stack machine
2392 typedef struct dw_loc_descr_struct
GTY(())
2394 dw_loc_descr_ref dw_loc_next
;
2395 enum dwarf_location_atom dw_loc_opc
;
2396 dw_val_node dw_loc_oprnd1
;
2397 dw_val_node dw_loc_oprnd2
;
2402 /* Location lists are ranges + location descriptions for that range,
2403 so you can track variables that are in different places over
2404 their entire life. */
2405 typedef struct dw_loc_list_struct
GTY(())
2407 dw_loc_list_ref dw_loc_next
;
2408 const char *begin
; /* Label for begin address of range */
2409 const char *end
; /* Label for end address of range */
2410 char *ll_symbol
; /* Label for beginning of location list.
2411 Only on head of list */
2412 const char *section
; /* Section this loclist is relative to */
2413 dw_loc_descr_ref expr
;
2416 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
2418 static const char *dwarf_stack_op_name (unsigned);
2419 static dw_loc_descr_ref
new_loc_descr (enum dwarf_location_atom
,
2420 unsigned HOST_WIDE_INT
, unsigned HOST_WIDE_INT
);
2421 static void add_loc_descr (dw_loc_descr_ref
*, dw_loc_descr_ref
);
2422 static unsigned long size_of_loc_descr (dw_loc_descr_ref
);
2423 static unsigned long size_of_locs (dw_loc_descr_ref
);
2424 static void output_loc_operands (dw_loc_descr_ref
);
2425 static void output_loc_sequence (dw_loc_descr_ref
);
2427 /* Convert a DWARF stack opcode into its string name. */
2430 dwarf_stack_op_name (unsigned int op
)
2435 case INTERNAL_DW_OP_tls_addr
:
2436 return "DW_OP_addr";
2438 return "DW_OP_deref";
2440 return "DW_OP_const1u";
2442 return "DW_OP_const1s";
2444 return "DW_OP_const2u";
2446 return "DW_OP_const2s";
2448 return "DW_OP_const4u";
2450 return "DW_OP_const4s";
2452 return "DW_OP_const8u";
2454 return "DW_OP_const8s";
2456 return "DW_OP_constu";
2458 return "DW_OP_consts";
2462 return "DW_OP_drop";
2464 return "DW_OP_over";
2466 return "DW_OP_pick";
2468 return "DW_OP_swap";
2472 return "DW_OP_xderef";
2480 return "DW_OP_minus";
2492 return "DW_OP_plus";
2493 case DW_OP_plus_uconst
:
2494 return "DW_OP_plus_uconst";
2500 return "DW_OP_shra";
2518 return "DW_OP_skip";
2520 return "DW_OP_lit0";
2522 return "DW_OP_lit1";
2524 return "DW_OP_lit2";
2526 return "DW_OP_lit3";
2528 return "DW_OP_lit4";
2530 return "DW_OP_lit5";
2532 return "DW_OP_lit6";
2534 return "DW_OP_lit7";
2536 return "DW_OP_lit8";
2538 return "DW_OP_lit9";
2540 return "DW_OP_lit10";
2542 return "DW_OP_lit11";
2544 return "DW_OP_lit12";
2546 return "DW_OP_lit13";
2548 return "DW_OP_lit14";
2550 return "DW_OP_lit15";
2552 return "DW_OP_lit16";
2554 return "DW_OP_lit17";
2556 return "DW_OP_lit18";
2558 return "DW_OP_lit19";
2560 return "DW_OP_lit20";
2562 return "DW_OP_lit21";
2564 return "DW_OP_lit22";
2566 return "DW_OP_lit23";
2568 return "DW_OP_lit24";
2570 return "DW_OP_lit25";
2572 return "DW_OP_lit26";
2574 return "DW_OP_lit27";
2576 return "DW_OP_lit28";
2578 return "DW_OP_lit29";
2580 return "DW_OP_lit30";
2582 return "DW_OP_lit31";
2584 return "DW_OP_reg0";
2586 return "DW_OP_reg1";
2588 return "DW_OP_reg2";
2590 return "DW_OP_reg3";
2592 return "DW_OP_reg4";
2594 return "DW_OP_reg5";
2596 return "DW_OP_reg6";
2598 return "DW_OP_reg7";
2600 return "DW_OP_reg8";
2602 return "DW_OP_reg9";
2604 return "DW_OP_reg10";
2606 return "DW_OP_reg11";
2608 return "DW_OP_reg12";
2610 return "DW_OP_reg13";
2612 return "DW_OP_reg14";
2614 return "DW_OP_reg15";
2616 return "DW_OP_reg16";
2618 return "DW_OP_reg17";
2620 return "DW_OP_reg18";
2622 return "DW_OP_reg19";
2624 return "DW_OP_reg20";
2626 return "DW_OP_reg21";
2628 return "DW_OP_reg22";
2630 return "DW_OP_reg23";
2632 return "DW_OP_reg24";
2634 return "DW_OP_reg25";
2636 return "DW_OP_reg26";
2638 return "DW_OP_reg27";
2640 return "DW_OP_reg28";
2642 return "DW_OP_reg29";
2644 return "DW_OP_reg30";
2646 return "DW_OP_reg31";
2648 return "DW_OP_breg0";
2650 return "DW_OP_breg1";
2652 return "DW_OP_breg2";
2654 return "DW_OP_breg3";
2656 return "DW_OP_breg4";
2658 return "DW_OP_breg5";
2660 return "DW_OP_breg6";
2662 return "DW_OP_breg7";
2664 return "DW_OP_breg8";
2666 return "DW_OP_breg9";
2668 return "DW_OP_breg10";
2670 return "DW_OP_breg11";
2672 return "DW_OP_breg12";
2674 return "DW_OP_breg13";
2676 return "DW_OP_breg14";
2678 return "DW_OP_breg15";
2680 return "DW_OP_breg16";
2682 return "DW_OP_breg17";
2684 return "DW_OP_breg18";
2686 return "DW_OP_breg19";
2688 return "DW_OP_breg20";
2690 return "DW_OP_breg21";
2692 return "DW_OP_breg22";
2694 return "DW_OP_breg23";
2696 return "DW_OP_breg24";
2698 return "DW_OP_breg25";
2700 return "DW_OP_breg26";
2702 return "DW_OP_breg27";
2704 return "DW_OP_breg28";
2706 return "DW_OP_breg29";
2708 return "DW_OP_breg30";
2710 return "DW_OP_breg31";
2712 return "DW_OP_regx";
2714 return "DW_OP_fbreg";
2716 return "DW_OP_bregx";
2718 return "DW_OP_piece";
2719 case DW_OP_deref_size
:
2720 return "DW_OP_deref_size";
2721 case DW_OP_xderef_size
:
2722 return "DW_OP_xderef_size";
2725 case DW_OP_push_object_address
:
2726 return "DW_OP_push_object_address";
2728 return "DW_OP_call2";
2730 return "DW_OP_call4";
2731 case DW_OP_call_ref
:
2732 return "DW_OP_call_ref";
2733 case DW_OP_GNU_push_tls_address
:
2734 return "DW_OP_GNU_push_tls_address";
2736 return "OP_<unknown>";
2740 /* Return a pointer to a newly allocated location description. Location
2741 descriptions are simple expression terms that can be strung
2742 together to form more complicated location (address) descriptions. */
2744 static inline dw_loc_descr_ref
2745 new_loc_descr (enum dwarf_location_atom op
, unsigned HOST_WIDE_INT oprnd1
,
2746 unsigned HOST_WIDE_INT oprnd2
)
2748 dw_loc_descr_ref descr
= ggc_alloc_cleared (sizeof (dw_loc_descr_node
));
2750 descr
->dw_loc_opc
= op
;
2751 descr
->dw_loc_oprnd1
.val_class
= dw_val_class_unsigned_const
;
2752 descr
->dw_loc_oprnd1
.v
.val_unsigned
= oprnd1
;
2753 descr
->dw_loc_oprnd2
.val_class
= dw_val_class_unsigned_const
;
2754 descr
->dw_loc_oprnd2
.v
.val_unsigned
= oprnd2
;
2760 /* Add a location description term to a location description expression. */
2763 add_loc_descr (dw_loc_descr_ref
*list_head
, dw_loc_descr_ref descr
)
2765 dw_loc_descr_ref
*d
;
2767 /* Find the end of the chain. */
2768 for (d
= list_head
; (*d
) != NULL
; d
= &(*d
)->dw_loc_next
)
2774 /* Return the size of a location descriptor. */
2776 static unsigned long
2777 size_of_loc_descr (dw_loc_descr_ref loc
)
2779 unsigned long size
= 1;
2781 switch (loc
->dw_loc_opc
)
2784 case INTERNAL_DW_OP_tls_addr
:
2785 size
+= DWARF2_ADDR_SIZE
;
2804 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
2807 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
2812 case DW_OP_plus_uconst
:
2813 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
2851 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
2854 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
2857 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
2860 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
2861 size
+= size_of_sleb128 (loc
->dw_loc_oprnd2
.v
.val_int
);
2864 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
2866 case DW_OP_deref_size
:
2867 case DW_OP_xderef_size
:
2876 case DW_OP_call_ref
:
2877 size
+= DWARF2_ADDR_SIZE
;
2886 /* Return the size of a series of location descriptors. */
2888 static unsigned long
2889 size_of_locs (dw_loc_descr_ref loc
)
2893 for (size
= 0; loc
!= NULL
; loc
= loc
->dw_loc_next
)
2895 loc
->dw_loc_addr
= size
;
2896 size
+= size_of_loc_descr (loc
);
2902 /* Output location description stack opcode's operands (if any). */
2905 output_loc_operands (dw_loc_descr_ref loc
)
2907 dw_val_ref val1
= &loc
->dw_loc_oprnd1
;
2908 dw_val_ref val2
= &loc
->dw_loc_oprnd2
;
2910 switch (loc
->dw_loc_opc
)
2912 #ifdef DWARF2_DEBUGGING_INFO
2914 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, val1
->v
.val_addr
, NULL
);
2918 dw2_asm_output_data (2, val1
->v
.val_int
, NULL
);
2922 dw2_asm_output_data (4, val1
->v
.val_int
, NULL
);
2926 if (HOST_BITS_PER_LONG
< 64)
2928 dw2_asm_output_data (8, val1
->v
.val_int
, NULL
);
2935 if (val1
->val_class
== dw_val_class_loc
)
2936 offset
= val1
->v
.val_loc
->dw_loc_addr
- (loc
->dw_loc_addr
+ 3);
2940 dw2_asm_output_data (2, offset
, NULL
);
2953 /* We currently don't make any attempt to make sure these are
2954 aligned properly like we do for the main unwind info, so
2955 don't support emitting things larger than a byte if we're
2956 only doing unwinding. */
2961 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
2964 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2967 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
2970 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
2972 case DW_OP_plus_uconst
:
2973 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
3007 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
3010 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
3013 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
3016 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
3017 dw2_asm_output_data_sleb128 (val2
->v
.val_int
, NULL
);
3020 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
3022 case DW_OP_deref_size
:
3023 case DW_OP_xderef_size
:
3024 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
3027 case INTERNAL_DW_OP_tls_addr
:
3028 #ifdef ASM_OUTPUT_DWARF_DTPREL
3029 ASM_OUTPUT_DWARF_DTPREL (asm_out_file
, DWARF2_ADDR_SIZE
,
3031 fputc ('\n', asm_out_file
);
3038 /* Other codes have no operands. */
3043 /* Output a sequence of location operations. */
3046 output_loc_sequence (dw_loc_descr_ref loc
)
3048 for (; loc
!= NULL
; loc
= loc
->dw_loc_next
)
3050 /* Output the opcode. */
3051 dw2_asm_output_data (1, loc
->dw_loc_opc
,
3052 "%s", dwarf_stack_op_name (loc
->dw_loc_opc
));
3054 /* Output the operand(s) (if any). */
3055 output_loc_operands (loc
);
3059 /* This routine will generate the correct assembly data for a location
3060 description based on a cfi entry with a complex address. */
3063 output_cfa_loc (dw_cfi_ref cfi
)
3065 dw_loc_descr_ref loc
;
3068 /* Output the size of the block. */
3069 loc
= cfi
->dw_cfi_oprnd1
.dw_cfi_loc
;
3070 size
= size_of_locs (loc
);
3071 dw2_asm_output_data_uleb128 (size
, NULL
);
3073 /* Now output the operations themselves. */
3074 output_loc_sequence (loc
);
3077 /* This function builds a dwarf location descriptor sequence from
3078 a dw_cfa_location. */
3080 static struct dw_loc_descr_struct
*
3081 build_cfa_loc (dw_cfa_location
*cfa
)
3083 struct dw_loc_descr_struct
*head
, *tmp
;
3085 if (cfa
->indirect
== 0)
3088 if (cfa
->base_offset
)
3091 head
= new_loc_descr (DW_OP_breg0
+ cfa
->reg
, cfa
->base_offset
, 0);
3093 head
= new_loc_descr (DW_OP_bregx
, cfa
->reg
, cfa
->base_offset
);
3095 else if (cfa
->reg
<= 31)
3096 head
= new_loc_descr (DW_OP_reg0
+ cfa
->reg
, 0, 0);
3098 head
= new_loc_descr (DW_OP_regx
, cfa
->reg
, 0);
3100 head
->dw_loc_oprnd1
.val_class
= dw_val_class_const
;
3101 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
3102 add_loc_descr (&head
, tmp
);
3103 if (cfa
->offset
!= 0)
3105 tmp
= new_loc_descr (DW_OP_plus_uconst
, cfa
->offset
, 0);
3106 add_loc_descr (&head
, tmp
);
3112 /* This function fills in aa dw_cfa_location structure from a dwarf location
3113 descriptor sequence. */
3116 get_cfa_from_loc_descr (dw_cfa_location
*cfa
, struct dw_loc_descr_struct
*loc
)
3118 struct dw_loc_descr_struct
*ptr
;
3120 cfa
->base_offset
= 0;
3124 for (ptr
= loc
; ptr
!= NULL
; ptr
= ptr
->dw_loc_next
)
3126 enum dwarf_location_atom op
= ptr
->dw_loc_opc
;
3162 cfa
->reg
= op
- DW_OP_reg0
;
3165 cfa
->reg
= ptr
->dw_loc_oprnd1
.v
.val_int
;
3199 cfa
->reg
= op
- DW_OP_breg0
;
3200 cfa
->base_offset
= ptr
->dw_loc_oprnd1
.v
.val_int
;
3203 cfa
->reg
= ptr
->dw_loc_oprnd1
.v
.val_int
;
3204 cfa
->base_offset
= ptr
->dw_loc_oprnd2
.v
.val_int
;
3209 case DW_OP_plus_uconst
:
3210 cfa
->offset
= ptr
->dw_loc_oprnd1
.v
.val_unsigned
;
3213 internal_error ("DW_LOC_OP %s not implemented\n",
3214 dwarf_stack_op_name (ptr
->dw_loc_opc
));
3218 #endif /* .debug_frame support */
3220 /* And now, the support for symbolic debugging information. */
3221 #ifdef DWARF2_DEBUGGING_INFO
3223 /* .debug_str support. */
3224 static int output_indirect_string (void **, void *);
3226 static void dwarf2out_init (const char *);
3227 static void dwarf2out_finish (const char *);
3228 static void dwarf2out_define (unsigned int, const char *);
3229 static void dwarf2out_undef (unsigned int, const char *);
3230 static void dwarf2out_start_source_file (unsigned, const char *);
3231 static void dwarf2out_end_source_file (unsigned);
3232 static void dwarf2out_begin_block (unsigned, unsigned);
3233 static void dwarf2out_end_block (unsigned, unsigned);
3234 static bool dwarf2out_ignore_block (tree
);
3235 static void dwarf2out_global_decl (tree
);
3236 static void dwarf2out_abstract_function (tree
);
3238 /* The debug hooks structure. */
3240 const struct gcc_debug_hooks dwarf2_debug_hooks
=
3246 dwarf2out_start_source_file
,
3247 dwarf2out_end_source_file
,
3248 dwarf2out_begin_block
,
3249 dwarf2out_end_block
,
3250 dwarf2out_ignore_block
,
3251 dwarf2out_source_line
,
3252 dwarf2out_begin_prologue
,
3253 debug_nothing_int_charstar
, /* end_prologue */
3254 dwarf2out_end_epilogue
,
3255 debug_nothing_tree
, /* begin_function */
3256 debug_nothing_int
, /* end_function */
3257 dwarf2out_decl
, /* function_decl */
3258 dwarf2out_global_decl
,
3259 debug_nothing_tree
, /* deferred_inline_function */
3260 /* The DWARF 2 backend tries to reduce debugging bloat by not
3261 emitting the abstract description of inline functions until
3262 something tries to reference them. */
3263 dwarf2out_abstract_function
, /* outlining_inline_function */
3264 debug_nothing_rtx
, /* label */
3265 debug_nothing_int
/* handle_pch */
3269 /* NOTE: In the comments in this file, many references are made to
3270 "Debugging Information Entries". This term is abbreviated as `DIE'
3271 throughout the remainder of this file. */
3273 /* An internal representation of the DWARF output is built, and then
3274 walked to generate the DWARF debugging info. The walk of the internal
3275 representation is done after the entire program has been compiled.
3276 The types below are used to describe the internal representation. */
3278 /* Various DIE's use offsets relative to the beginning of the
3279 .debug_info section to refer to each other. */
3281 typedef long int dw_offset
;
3283 /* Define typedefs here to avoid circular dependencies. */
3285 typedef struct dw_attr_struct
*dw_attr_ref
;
3286 typedef struct dw_line_info_struct
*dw_line_info_ref
;
3287 typedef struct dw_separate_line_info_struct
*dw_separate_line_info_ref
;
3288 typedef struct pubname_struct
*pubname_ref
;
3289 typedef struct dw_ranges_struct
*dw_ranges_ref
;
3291 /* Each entry in the line_info_table maintains the file and
3292 line number associated with the label generated for that
3293 entry. The label gives the PC value associated with
3294 the line number entry. */
3296 typedef struct dw_line_info_struct
GTY(())
3298 unsigned long dw_file_num
;
3299 unsigned long dw_line_num
;
3303 /* Line information for functions in separate sections; each one gets its
3305 typedef struct dw_separate_line_info_struct
GTY(())
3307 unsigned long dw_file_num
;
3308 unsigned long dw_line_num
;
3309 unsigned long function
;
3311 dw_separate_line_info_entry
;
3313 /* Each DIE attribute has a field specifying the attribute kind,
3314 a link to the next attribute in the chain, and an attribute value.
3315 Attributes are typically linked below the DIE they modify. */
3317 typedef struct dw_attr_struct
GTY(())
3319 enum dwarf_attribute dw_attr
;
3320 dw_attr_ref dw_attr_next
;
3321 dw_val_node dw_attr_val
;
3325 /* The Debugging Information Entry (DIE) structure */
3327 typedef struct die_struct
GTY(())
3329 enum dwarf_tag die_tag
;
3331 dw_attr_ref die_attr
;
3332 dw_die_ref die_parent
;
3333 dw_die_ref die_child
;
3335 dw_offset die_offset
;
3336 unsigned long die_abbrev
;
3341 /* The pubname structure */
3343 typedef struct pubname_struct
GTY(())
3350 struct dw_ranges_struct
GTY(())
3355 /* The limbo die list structure. */
3356 typedef struct limbo_die_struct
GTY(())
3360 struct limbo_die_struct
*next
;
3364 /* How to start an assembler comment. */
3365 #ifndef ASM_COMMENT_START
3366 #define ASM_COMMENT_START ";#"
3369 /* Define a macro which returns nonzero for a TYPE_DECL which was
3370 implicitly generated for a tagged type.
3372 Note that unlike the gcc front end (which generates a NULL named
3373 TYPE_DECL node for each complete tagged type, each array type, and
3374 each function type node created) the g++ front end generates a
3375 _named_ TYPE_DECL node for each tagged type node created.
3376 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
3377 generate a DW_TAG_typedef DIE for them. */
3379 #define TYPE_DECL_IS_STUB(decl) \
3380 (DECL_NAME (decl) == NULL_TREE \
3381 || (DECL_ARTIFICIAL (decl) \
3382 && is_tagged_type (TREE_TYPE (decl)) \
3383 && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \
3384 /* This is necessary for stub decls that \
3385 appear in nested inline functions. */ \
3386 || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
3387 && (decl_ultimate_origin (decl) \
3388 == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
3390 /* Information concerning the compilation unit's programming
3391 language, and compiler version. */
3393 /* Fixed size portion of the DWARF compilation unit header. */
3394 #define DWARF_COMPILE_UNIT_HEADER_SIZE \
3395 (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 3)
3397 /* Fixed size portion of public names info. */
3398 #define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
3400 /* Fixed size portion of the address range info. */
3401 #define DWARF_ARANGES_HEADER_SIZE \
3402 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
3403 DWARF2_ADDR_SIZE * 2) \
3404 - DWARF_INITIAL_LENGTH_SIZE)
3406 /* Size of padding portion in the address range info. It must be
3407 aligned to twice the pointer size. */
3408 #define DWARF_ARANGES_PAD_SIZE \
3409 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
3410 DWARF2_ADDR_SIZE * 2) \
3411 - (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4))
3413 /* Use assembler line directives if available. */
3414 #ifndef DWARF2_ASM_LINE_DEBUG_INFO
3415 #ifdef HAVE_AS_DWARF2_DEBUG_LINE
3416 #define DWARF2_ASM_LINE_DEBUG_INFO 1
3418 #define DWARF2_ASM_LINE_DEBUG_INFO 0
3422 /* Minimum line offset in a special line info. opcode.
3423 This value was chosen to give a reasonable range of values. */
3424 #define DWARF_LINE_BASE -10
3426 /* First special line opcode - leave room for the standard opcodes. */
3427 #define DWARF_LINE_OPCODE_BASE 10
3429 /* Range of line offsets in a special line info. opcode. */
3430 #define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1)
3432 /* Flag that indicates the initial value of the is_stmt_start flag.
3433 In the present implementation, we do not mark any lines as
3434 the beginning of a source statement, because that information
3435 is not made available by the GCC front-end. */
3436 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
3438 #ifdef DWARF2_DEBUGGING_INFO
3439 /* This location is used by calc_die_sizes() to keep track
3440 the offset of each DIE within the .debug_info section. */
3441 static unsigned long next_die_offset
;
3444 /* Record the root of the DIE's built for the current compilation unit. */
3445 static GTY(()) dw_die_ref comp_unit_die
;
3447 /* A list of DIEs with a NULL parent waiting to be relocated. */
3448 static GTY(()) limbo_die_node
*limbo_die_list
;
3450 /* Filenames referenced by this compilation unit. */
3451 static GTY(()) varray_type file_table
;
3452 static GTY(()) varray_type file_table_emitted
;
3453 static GTY(()) size_t file_table_last_lookup_index
;
3455 /* A pointer to the base of a table of references to DIE's that describe
3456 declarations. The table is indexed by DECL_UID() which is a unique
3457 number identifying each decl. */
3458 static GTY((length ("decl_die_table_allocated"))) dw_die_ref
*decl_die_table
;
3460 /* Number of elements currently allocated for the decl_die_table. */
3461 static GTY(()) unsigned decl_die_table_allocated
;
3463 /* Number of elements in decl_die_table currently in use. */
3464 static GTY(()) unsigned decl_die_table_in_use
;
3466 /* Size (in elements) of increments by which we may expand the
3468 #define DECL_DIE_TABLE_INCREMENT 256
3470 /* A pointer to the base of a list of references to DIE's that
3471 are uniquely identified by their tag, presence/absence of
3472 children DIE's, and list of attribute/value pairs. */
3473 static GTY((length ("abbrev_die_table_allocated")))
3474 dw_die_ref
*abbrev_die_table
;
3476 /* Number of elements currently allocated for abbrev_die_table. */
3477 static GTY(()) unsigned abbrev_die_table_allocated
;
3479 /* Number of elements in type_die_table currently in use. */
3480 static GTY(()) unsigned abbrev_die_table_in_use
;
3482 /* Size (in elements) of increments by which we may expand the
3483 abbrev_die_table. */
3484 #define ABBREV_DIE_TABLE_INCREMENT 256
3486 /* A pointer to the base of a table that contains line information
3487 for each source code line in .text in the compilation unit. */
3488 static GTY((length ("line_info_table_allocated")))
3489 dw_line_info_ref line_info_table
;
3491 /* Number of elements currently allocated for line_info_table. */
3492 static GTY(()) unsigned line_info_table_allocated
;
3494 /* Number of elements in line_info_table currently in use. */
3495 static GTY(()) unsigned line_info_table_in_use
;
3497 /* A pointer to the base of a table that contains line information
3498 for each source code line outside of .text in the compilation unit. */
3499 static GTY ((length ("separate_line_info_table_allocated")))
3500 dw_separate_line_info_ref separate_line_info_table
;
3502 /* Number of elements currently allocated for separate_line_info_table. */
3503 static GTY(()) unsigned separate_line_info_table_allocated
;
3505 /* Number of elements in separate_line_info_table currently in use. */
3506 static GTY(()) unsigned separate_line_info_table_in_use
;
3508 /* Size (in elements) of increments by which we may expand the
3510 #define LINE_INFO_TABLE_INCREMENT 1024
3512 /* A pointer to the base of a table that contains a list of publicly
3513 accessible names. */
3514 static GTY ((length ("pubname_table_allocated"))) pubname_ref pubname_table
;
3516 /* Number of elements currently allocated for pubname_table. */
3517 static GTY(()) unsigned pubname_table_allocated
;
3519 /* Number of elements in pubname_table currently in use. */
3520 static GTY(()) unsigned pubname_table_in_use
;
3522 /* Size (in elements) of increments by which we may expand the
3524 #define PUBNAME_TABLE_INCREMENT 64
3526 /* Array of dies for which we should generate .debug_arange info. */
3527 static GTY((length ("arange_table_allocated"))) dw_die_ref
*arange_table
;
3529 /* Number of elements currently allocated for arange_table. */
3530 static GTY(()) unsigned arange_table_allocated
;
3532 /* Number of elements in arange_table currently in use. */
3533 static GTY(()) unsigned arange_table_in_use
;
3535 /* Size (in elements) of increments by which we may expand the
3537 #define ARANGE_TABLE_INCREMENT 64
3539 /* Array of dies for which we should generate .debug_ranges info. */
3540 static GTY ((length ("ranges_table_allocated"))) dw_ranges_ref ranges_table
;
3542 /* Number of elements currently allocated for ranges_table. */
3543 static GTY(()) unsigned ranges_table_allocated
;
3545 /* Number of elements in ranges_table currently in use. */
3546 static GTY(()) unsigned ranges_table_in_use
;
3548 /* Size (in elements) of increments by which we may expand the
3550 #define RANGES_TABLE_INCREMENT 64
3552 /* Whether we have location lists that need outputting */
3553 static GTY(()) unsigned have_location_lists
;
3555 #ifdef DWARF2_DEBUGGING_INFO
3556 /* Record whether the function being analyzed contains inlined functions. */
3557 static int current_function_has_inlines
;
3559 #if 0 && defined (MIPS_DEBUGGING_INFO)
3560 static int comp_unit_has_inlines
;
3563 /* Number of file tables emitted in maybe_emit_file(). */
3564 static GTY(()) int emitcount
= 0;
3566 /* Number of internal labels generated by gen_internal_sym(). */
3567 static GTY(()) int label_num
;
3569 #ifdef DWARF2_DEBUGGING_INFO
3571 /* Forward declarations for functions defined in this file. */
3573 static int is_pseudo_reg (rtx
);
3574 static tree
type_main_variant (tree
);
3575 static int is_tagged_type (tree
);
3576 static const char *dwarf_tag_name (unsigned);
3577 static const char *dwarf_attr_name (unsigned);
3578 static const char *dwarf_form_name (unsigned);
3580 static const char *dwarf_type_encoding_name (unsigned);
3582 static tree
decl_ultimate_origin (tree
);
3583 static tree
block_ultimate_origin (tree
);
3584 static tree
decl_class_context (tree
);
3585 static void add_dwarf_attr (dw_die_ref
, dw_attr_ref
);
3586 static inline enum dw_val_class
AT_class (dw_attr_ref
);
3587 static void add_AT_flag (dw_die_ref
, enum dwarf_attribute
, unsigned);
3588 static inline unsigned AT_flag (dw_attr_ref
);
3589 static void add_AT_int (dw_die_ref
, enum dwarf_attribute
, HOST_WIDE_INT
);
3590 static inline HOST_WIDE_INT
AT_int (dw_attr_ref
);
3591 static void add_AT_unsigned (dw_die_ref
, enum dwarf_attribute
, unsigned HOST_WIDE_INT
);
3592 static inline unsigned HOST_WIDE_INT
AT_unsigned (dw_attr_ref
);
3593 static void add_AT_long_long (dw_die_ref
, enum dwarf_attribute
, unsigned long,
3595 static void add_AT_float (dw_die_ref
, enum dwarf_attribute
, unsigned, long *);
3596 static hashval_t
debug_str_do_hash (const void *);
3597 static int debug_str_eq (const void *, const void *);
3598 static void add_AT_string (dw_die_ref
, enum dwarf_attribute
, const char *);
3599 static inline const char *AT_string (dw_attr_ref
);
3600 static int AT_string_form (dw_attr_ref
);
3601 static void add_AT_die_ref (dw_die_ref
, enum dwarf_attribute
, dw_die_ref
);
3602 static inline dw_die_ref
AT_ref (dw_attr_ref
);
3603 static inline int AT_ref_external (dw_attr_ref
);
3604 static inline void set_AT_ref_external (dw_attr_ref
, int);
3605 static void add_AT_fde_ref (dw_die_ref
, enum dwarf_attribute
, unsigned);
3606 static void add_AT_loc (dw_die_ref
, enum dwarf_attribute
, dw_loc_descr_ref
);
3607 static inline dw_loc_descr_ref
AT_loc (dw_attr_ref
);
3608 static void add_AT_loc_list (dw_die_ref
, enum dwarf_attribute
,
3610 static inline dw_loc_list_ref
AT_loc_list (dw_attr_ref
);
3611 static void add_AT_addr (dw_die_ref
, enum dwarf_attribute
, rtx
);
3612 static inline rtx
AT_addr (dw_attr_ref
);
3613 static void add_AT_lbl_id (dw_die_ref
, enum dwarf_attribute
, const char *);
3614 static void add_AT_lbl_offset (dw_die_ref
, enum dwarf_attribute
, const char *);
3615 static void add_AT_offset (dw_die_ref
, enum dwarf_attribute
,
3616 unsigned HOST_WIDE_INT
);
3617 static void add_AT_range_list (dw_die_ref
, enum dwarf_attribute
,
3619 static inline const char *AT_lbl (dw_attr_ref
);
3620 static dw_attr_ref
get_AT (dw_die_ref
, enum dwarf_attribute
);
3621 static const char *get_AT_low_pc (dw_die_ref
);
3622 static const char *get_AT_hi_pc (dw_die_ref
);
3623 static const char *get_AT_string (dw_die_ref
, enum dwarf_attribute
);
3624 static int get_AT_flag (dw_die_ref
, enum dwarf_attribute
);
3625 static unsigned get_AT_unsigned (dw_die_ref
, enum dwarf_attribute
);
3626 static inline dw_die_ref
get_AT_ref (dw_die_ref
, enum dwarf_attribute
);
3627 static bool is_c_family (void);
3628 static bool is_cxx (void);
3629 static bool is_java (void);
3630 static bool is_fortran (void);
3631 static bool is_ada (void);
3632 static void remove_AT (dw_die_ref
, enum dwarf_attribute
);
3633 static inline void free_die (dw_die_ref
);
3634 static void remove_children (dw_die_ref
);
3635 static void add_child_die (dw_die_ref
, dw_die_ref
);
3636 static dw_die_ref
new_die (enum dwarf_tag
, dw_die_ref
, tree
);
3637 static dw_die_ref
lookup_type_die (tree
);
3638 static void equate_type_number_to_die (tree
, dw_die_ref
);
3639 static dw_die_ref
lookup_decl_die (tree
);
3640 static void equate_decl_number_to_die (tree
, dw_die_ref
);
3641 static void print_spaces (FILE *);
3642 static void print_die (dw_die_ref
, FILE *);
3643 static void print_dwarf_line_table (FILE *);
3644 static void reverse_die_lists (dw_die_ref
);
3645 static void reverse_all_dies (dw_die_ref
);
3646 static dw_die_ref
push_new_compile_unit (dw_die_ref
, dw_die_ref
);
3647 static dw_die_ref
pop_compile_unit (dw_die_ref
);
3648 static void loc_checksum (dw_loc_descr_ref
, struct md5_ctx
*);
3649 static void attr_checksum (dw_attr_ref
, struct md5_ctx
*, int *);
3650 static void die_checksum (dw_die_ref
, struct md5_ctx
*, int *);
3651 static int same_loc_p (dw_loc_descr_ref
, dw_loc_descr_ref
, int *);
3652 static int same_dw_val_p (dw_val_node
*, dw_val_node
*, int *);
3653 static int same_attr_p (dw_attr_ref
, dw_attr_ref
, int *);
3654 static int same_die_p (dw_die_ref
, dw_die_ref
, int *);
3655 static int same_die_p_wrap (dw_die_ref
, dw_die_ref
);
3656 static void compute_section_prefix (dw_die_ref
);
3657 static int is_type_die (dw_die_ref
);
3658 static int is_comdat_die (dw_die_ref
);
3659 static int is_symbol_die (dw_die_ref
);
3660 static void assign_symbol_names (dw_die_ref
);
3661 static void break_out_includes (dw_die_ref
);
3662 static hashval_t
htab_cu_hash (const void *);
3663 static int htab_cu_eq (const void *, const void *);
3664 static void htab_cu_del (void *);
3665 static int check_duplicate_cu (dw_die_ref
, htab_t
, unsigned *);
3666 static void record_comdat_symbol_number (dw_die_ref
, htab_t
, unsigned);
3667 static void add_sibling_attributes (dw_die_ref
);
3668 static void build_abbrev_table (dw_die_ref
);
3669 static void output_location_lists (dw_die_ref
);
3670 static int constant_size (long unsigned);
3671 static unsigned long size_of_die (dw_die_ref
);
3672 static void calc_die_sizes (dw_die_ref
);
3673 static void mark_dies (dw_die_ref
);
3674 static void unmark_dies (dw_die_ref
);
3675 static void unmark_all_dies (dw_die_ref
);
3676 static unsigned long size_of_pubnames (void);
3677 static unsigned long size_of_aranges (void);
3678 static enum dwarf_form
value_format (dw_attr_ref
);
3679 static void output_value_format (dw_attr_ref
);
3680 static void output_abbrev_section (void);
3681 static void output_die_symbol (dw_die_ref
);
3682 static void output_die (dw_die_ref
);
3683 static void output_compilation_unit_header (void);
3684 static void output_comp_unit (dw_die_ref
, int);
3685 static const char *dwarf2_name (tree
, int);
3686 static void add_pubname (tree
, dw_die_ref
);
3687 static void output_pubnames (void);
3688 static void add_arange (tree
, dw_die_ref
);
3689 static void output_aranges (void);
3690 static unsigned int add_ranges (tree
);
3691 static void output_ranges (void);
3692 static void output_line_info (void);
3693 static void output_file_names (void);
3694 static dw_die_ref
base_type_die (tree
);
3695 static tree
root_type (tree
);
3696 static int is_base_type (tree
);
3697 static bool is_ada_subrange_type (tree
);
3698 static dw_die_ref
subrange_type_die (tree
);
3699 static dw_die_ref
modified_type_die (tree
, int, int, dw_die_ref
);
3700 static int type_is_enum (tree
);
3701 static unsigned int reg_number (rtx
);
3702 static dw_loc_descr_ref
reg_loc_descriptor (rtx
);
3703 static dw_loc_descr_ref
one_reg_loc_descriptor (unsigned int);
3704 static dw_loc_descr_ref
multiple_reg_loc_descriptor (rtx
, rtx
);
3705 static dw_loc_descr_ref
int_loc_descriptor (HOST_WIDE_INT
);
3706 static dw_loc_descr_ref
based_loc_descr (unsigned, HOST_WIDE_INT
);
3707 static int is_based_loc (rtx
);
3708 static dw_loc_descr_ref
mem_loc_descriptor (rtx
, enum machine_mode mode
);
3709 static dw_loc_descr_ref
concat_loc_descriptor (rtx
, rtx
);
3710 static dw_loc_descr_ref
loc_descriptor (rtx
);
3711 static dw_loc_descr_ref
loc_descriptor_from_tree (tree
, int);
3712 static HOST_WIDE_INT
ceiling (HOST_WIDE_INT
, unsigned int);
3713 static tree
field_type (tree
);
3714 static unsigned int simple_type_align_in_bits (tree
);
3715 static unsigned int simple_decl_align_in_bits (tree
);
3716 static unsigned HOST_WIDE_INT
simple_type_size_in_bits (tree
);
3717 static HOST_WIDE_INT
field_byte_offset (tree
);
3718 static void add_AT_location_description (dw_die_ref
, enum dwarf_attribute
,
3720 static void add_data_member_location_attribute (dw_die_ref
, tree
);
3721 static void add_const_value_attribute (dw_die_ref
, rtx
);
3722 static rtx
rtl_for_decl_location (tree
);
3723 static void add_location_or_const_value_attribute (dw_die_ref
, tree
);
3724 static void tree_add_const_value_attribute (dw_die_ref
, tree
);
3725 static void add_name_attribute (dw_die_ref
, const char *);
3726 static void add_comp_dir_attribute (dw_die_ref
);
3727 static void add_bound_info (dw_die_ref
, enum dwarf_attribute
, tree
);
3728 static void add_subscript_info (dw_die_ref
, tree
);
3729 static void add_byte_size_attribute (dw_die_ref
, tree
);
3730 static void add_bit_offset_attribute (dw_die_ref
, tree
);
3731 static void add_bit_size_attribute (dw_die_ref
, tree
);
3732 static void add_prototyped_attribute (dw_die_ref
, tree
);
3733 static void add_abstract_origin_attribute (dw_die_ref
, tree
);
3734 static void add_pure_or_virtual_attribute (dw_die_ref
, tree
);
3735 static void add_src_coords_attributes (dw_die_ref
, tree
);
3736 static void add_name_and_src_coords_attributes (dw_die_ref
, tree
);
3737 static void push_decl_scope (tree
);
3738 static void pop_decl_scope (void);
3739 static dw_die_ref
scope_die_for (tree
, dw_die_ref
);
3740 static inline int local_scope_p (dw_die_ref
);
3741 static inline int class_scope_p (dw_die_ref
);
3742 static void add_type_attribute (dw_die_ref
, tree
, int, int, dw_die_ref
);
3743 static const char *type_tag (tree
);
3744 static tree
member_declared_type (tree
);
3746 static const char *decl_start_label (tree
);
3748 static void gen_array_type_die (tree
, dw_die_ref
);
3749 static void gen_set_type_die (tree
, dw_die_ref
);
3751 static void gen_entry_point_die (tree
, dw_die_ref
);
3753 static void gen_inlined_enumeration_type_die (tree
, dw_die_ref
);
3754 static void gen_inlined_structure_type_die (tree
, dw_die_ref
);
3755 static void gen_inlined_union_type_die (tree
, dw_die_ref
);
3756 static void gen_enumeration_type_die (tree
, dw_die_ref
);
3757 static dw_die_ref
gen_formal_parameter_die (tree
, dw_die_ref
);
3758 static void gen_unspecified_parameters_die (tree
, dw_die_ref
);
3759 static void gen_formal_types_die (tree
, dw_die_ref
);
3760 static void gen_subprogram_die (tree
, dw_die_ref
);
3761 static void gen_variable_die (tree
, dw_die_ref
);
3762 static void gen_label_die (tree
, dw_die_ref
);
3763 static void gen_lexical_block_die (tree
, dw_die_ref
, int);
3764 static void gen_inlined_subroutine_die (tree
, dw_die_ref
, int);
3765 static void gen_field_die (tree
, dw_die_ref
);
3766 static void gen_ptr_to_mbr_type_die (tree
, dw_die_ref
);
3767 static dw_die_ref
gen_compile_unit_die (const char *);
3768 static void gen_string_type_die (tree
, dw_die_ref
);
3769 static void gen_inheritance_die (tree
, tree
, dw_die_ref
);
3770 static void gen_member_die (tree
, dw_die_ref
);
3771 static void gen_struct_or_union_type_die (tree
, dw_die_ref
);
3772 static void gen_subroutine_type_die (tree
, dw_die_ref
);
3773 static void gen_typedef_die (tree
, dw_die_ref
);
3774 static void gen_type_die (tree
, dw_die_ref
);
3775 static void gen_tagged_type_instantiation_die (tree
, dw_die_ref
);
3776 static void gen_block_die (tree
, dw_die_ref
, int);
3777 static void decls_for_scope (tree
, dw_die_ref
, int);
3778 static int is_redundant_typedef (tree
);
3779 static void gen_decl_die (tree
, dw_die_ref
);
3780 static unsigned lookup_filename (const char *);
3781 static void init_file_table (void);
3782 static void retry_incomplete_types (void);
3783 static void gen_type_die_for_member (tree
, tree
, dw_die_ref
);
3784 static void splice_child_die (dw_die_ref
, dw_die_ref
);
3785 static int file_info_cmp (const void *, const void *);
3786 static dw_loc_list_ref
new_loc_list (dw_loc_descr_ref
, const char *,
3787 const char *, const char *, unsigned);
3788 static void add_loc_descr_to_loc_list (dw_loc_list_ref
*, dw_loc_descr_ref
,
3789 const char *, const char *,
3791 static void output_loc_list (dw_loc_list_ref
);
3792 static char *gen_internal_sym (const char *);
3794 static void prune_unmark_dies (dw_die_ref
);
3795 static void prune_unused_types_mark (dw_die_ref
, int);
3796 static void prune_unused_types_walk (dw_die_ref
);
3797 static void prune_unused_types_walk_attribs (dw_die_ref
);
3798 static void prune_unused_types_prune (dw_die_ref
);
3799 static void prune_unused_types (void);
3800 static int maybe_emit_file (int);
3802 /* Section names used to hold DWARF debugging information. */
3803 #ifndef DEBUG_INFO_SECTION
3804 #define DEBUG_INFO_SECTION ".debug_info"
3806 #ifndef DEBUG_ABBREV_SECTION
3807 #define DEBUG_ABBREV_SECTION ".debug_abbrev"
3809 #ifndef DEBUG_ARANGES_SECTION
3810 #define DEBUG_ARANGES_SECTION ".debug_aranges"
3812 #ifndef DEBUG_MACINFO_SECTION
3813 #define DEBUG_MACINFO_SECTION ".debug_macinfo"
3815 #ifndef DEBUG_LINE_SECTION
3816 #define DEBUG_LINE_SECTION ".debug_line"
3818 #ifndef DEBUG_LOC_SECTION
3819 #define DEBUG_LOC_SECTION ".debug_loc"
3821 #ifndef DEBUG_PUBNAMES_SECTION
3822 #define DEBUG_PUBNAMES_SECTION ".debug_pubnames"
3824 #ifndef DEBUG_STR_SECTION
3825 #define DEBUG_STR_SECTION ".debug_str"
3827 #ifndef DEBUG_RANGES_SECTION
3828 #define DEBUG_RANGES_SECTION ".debug_ranges"
3831 /* Standard ELF section names for compiled code and data. */
3832 #ifndef TEXT_SECTION_NAME
3833 #define TEXT_SECTION_NAME ".text"
3836 /* Section flags for .debug_str section. */
3837 #define DEBUG_STR_SECTION_FLAGS \
3838 (HAVE_GAS_SHF_MERGE && flag_merge_constants \
3839 ? SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1 \
3842 /* Labels we insert at beginning sections we can reference instead of
3843 the section names themselves. */
3845 #ifndef TEXT_SECTION_LABEL
3846 #define TEXT_SECTION_LABEL "Ltext"
3848 #ifndef DEBUG_LINE_SECTION_LABEL
3849 #define DEBUG_LINE_SECTION_LABEL "Ldebug_line"
3851 #ifndef DEBUG_INFO_SECTION_LABEL
3852 #define DEBUG_INFO_SECTION_LABEL "Ldebug_info"
3854 #ifndef DEBUG_ABBREV_SECTION_LABEL
3855 #define DEBUG_ABBREV_SECTION_LABEL "Ldebug_abbrev"
3857 #ifndef DEBUG_LOC_SECTION_LABEL
3858 #define DEBUG_LOC_SECTION_LABEL "Ldebug_loc"
3860 #ifndef DEBUG_RANGES_SECTION_LABEL
3861 #define DEBUG_RANGES_SECTION_LABEL "Ldebug_ranges"
3863 #ifndef DEBUG_MACINFO_SECTION_LABEL
3864 #define DEBUG_MACINFO_SECTION_LABEL "Ldebug_macinfo"
3867 /* Definitions of defaults for formats and names of various special
3868 (artificial) labels which may be generated within this file (when the -g
3869 options is used and DWARF_DEBUGGING_INFO is in effect.
3870 If necessary, these may be overridden from within the tm.h file, but
3871 typically, overriding these defaults is unnecessary. */
3873 static char text_end_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3874 static char text_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3875 static char abbrev_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3876 static char debug_info_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3877 static char debug_line_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3878 static char macinfo_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3879 static char loc_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3880 static char ranges_section_label
[2 * MAX_ARTIFICIAL_LABEL_BYTES
];
3882 #ifndef TEXT_END_LABEL
3883 #define TEXT_END_LABEL "Letext"
3885 #ifndef BLOCK_BEGIN_LABEL
3886 #define BLOCK_BEGIN_LABEL "LBB"
3888 #ifndef BLOCK_END_LABEL
3889 #define BLOCK_END_LABEL "LBE"
3891 #ifndef LINE_CODE_LABEL
3892 #define LINE_CODE_LABEL "LM"
3894 #ifndef SEPARATE_LINE_CODE_LABEL
3895 #define SEPARATE_LINE_CODE_LABEL "LSM"
3898 /* We allow a language front-end to designate a function that is to be
3899 called to "demangle" any name before it it put into a DIE. */
3901 static const char *(*demangle_name_func
) (const char *);
3904 dwarf2out_set_demangle_name_func (const char *(*func
) (const char *))
3906 demangle_name_func
= func
;
3909 /* Test if rtl node points to a pseudo register. */
3912 is_pseudo_reg (rtx rtl
)
3914 return ((GET_CODE (rtl
) == REG
&& REGNO (rtl
) >= FIRST_PSEUDO_REGISTER
)
3915 || (GET_CODE (rtl
) == SUBREG
3916 && REGNO (SUBREG_REG (rtl
)) >= FIRST_PSEUDO_REGISTER
));
3919 /* Return a reference to a type, with its const and volatile qualifiers
3923 type_main_variant (tree type
)
3925 type
= TYPE_MAIN_VARIANT (type
);
3927 /* ??? There really should be only one main variant among any group of
3928 variants of a given type (and all of the MAIN_VARIANT values for all
3929 members of the group should point to that one type) but sometimes the C
3930 front-end messes this up for array types, so we work around that bug
3932 if (TREE_CODE (type
) == ARRAY_TYPE
)
3933 while (type
!= TYPE_MAIN_VARIANT (type
))
3934 type
= TYPE_MAIN_VARIANT (type
);
3939 /* Return nonzero if the given type node represents a tagged type. */
3942 is_tagged_type (tree type
)
3944 enum tree_code code
= TREE_CODE (type
);
3946 return (code
== RECORD_TYPE
|| code
== UNION_TYPE
3947 || code
== QUAL_UNION_TYPE
|| code
== ENUMERAL_TYPE
);
3950 /* Convert a DIE tag into its string name. */
3953 dwarf_tag_name (unsigned int tag
)
3957 case DW_TAG_padding
:
3958 return "DW_TAG_padding";
3959 case DW_TAG_array_type
:
3960 return "DW_TAG_array_type";
3961 case DW_TAG_class_type
:
3962 return "DW_TAG_class_type";
3963 case DW_TAG_entry_point
:
3964 return "DW_TAG_entry_point";
3965 case DW_TAG_enumeration_type
:
3966 return "DW_TAG_enumeration_type";
3967 case DW_TAG_formal_parameter
:
3968 return "DW_TAG_formal_parameter";
3969 case DW_TAG_imported_declaration
:
3970 return "DW_TAG_imported_declaration";
3972 return "DW_TAG_label";
3973 case DW_TAG_lexical_block
:
3974 return "DW_TAG_lexical_block";
3976 return "DW_TAG_member";
3977 case DW_TAG_pointer_type
:
3978 return "DW_TAG_pointer_type";
3979 case DW_TAG_reference_type
:
3980 return "DW_TAG_reference_type";
3981 case DW_TAG_compile_unit
:
3982 return "DW_TAG_compile_unit";
3983 case DW_TAG_string_type
:
3984 return "DW_TAG_string_type";
3985 case DW_TAG_structure_type
:
3986 return "DW_TAG_structure_type";
3987 case DW_TAG_subroutine_type
:
3988 return "DW_TAG_subroutine_type";
3989 case DW_TAG_typedef
:
3990 return "DW_TAG_typedef";
3991 case DW_TAG_union_type
:
3992 return "DW_TAG_union_type";
3993 case DW_TAG_unspecified_parameters
:
3994 return "DW_TAG_unspecified_parameters";
3995 case DW_TAG_variant
:
3996 return "DW_TAG_variant";
3997 case DW_TAG_common_block
:
3998 return "DW_TAG_common_block";
3999 case DW_TAG_common_inclusion
:
4000 return "DW_TAG_common_inclusion";
4001 case DW_TAG_inheritance
:
4002 return "DW_TAG_inheritance";
4003 case DW_TAG_inlined_subroutine
:
4004 return "DW_TAG_inlined_subroutine";
4006 return "DW_TAG_module";
4007 case DW_TAG_ptr_to_member_type
:
4008 return "DW_TAG_ptr_to_member_type";
4009 case DW_TAG_set_type
:
4010 return "DW_TAG_set_type";
4011 case DW_TAG_subrange_type
:
4012 return "DW_TAG_subrange_type";
4013 case DW_TAG_with_stmt
:
4014 return "DW_TAG_with_stmt";
4015 case DW_TAG_access_declaration
:
4016 return "DW_TAG_access_declaration";
4017 case DW_TAG_base_type
:
4018 return "DW_TAG_base_type";
4019 case DW_TAG_catch_block
:
4020 return "DW_TAG_catch_block";
4021 case DW_TAG_const_type
:
4022 return "DW_TAG_const_type";
4023 case DW_TAG_constant
:
4024 return "DW_TAG_constant";
4025 case DW_TAG_enumerator
:
4026 return "DW_TAG_enumerator";
4027 case DW_TAG_file_type
:
4028 return "DW_TAG_file_type";
4030 return "DW_TAG_friend";
4031 case DW_TAG_namelist
:
4032 return "DW_TAG_namelist";
4033 case DW_TAG_namelist_item
:
4034 return "DW_TAG_namelist_item";
4035 case DW_TAG_packed_type
:
4036 return "DW_TAG_packed_type";
4037 case DW_TAG_subprogram
:
4038 return "DW_TAG_subprogram";
4039 case DW_TAG_template_type_param
:
4040 return "DW_TAG_template_type_param";
4041 case DW_TAG_template_value_param
:
4042 return "DW_TAG_template_value_param";
4043 case DW_TAG_thrown_type
:
4044 return "DW_TAG_thrown_type";
4045 case DW_TAG_try_block
:
4046 return "DW_TAG_try_block";
4047 case DW_TAG_variant_part
:
4048 return "DW_TAG_variant_part";
4049 case DW_TAG_variable
:
4050 return "DW_TAG_variable";
4051 case DW_TAG_volatile_type
:
4052 return "DW_TAG_volatile_type";
4053 case DW_TAG_MIPS_loop
:
4054 return "DW_TAG_MIPS_loop";
4055 case DW_TAG_format_label
:
4056 return "DW_TAG_format_label";
4057 case DW_TAG_function_template
:
4058 return "DW_TAG_function_template";
4059 case DW_TAG_class_template
:
4060 return "DW_TAG_class_template";
4061 case DW_TAG_GNU_BINCL
:
4062 return "DW_TAG_GNU_BINCL";
4063 case DW_TAG_GNU_EINCL
:
4064 return "DW_TAG_GNU_EINCL";
4066 return "DW_TAG_<unknown>";
4070 /* Convert a DWARF attribute code into its string name. */
4073 dwarf_attr_name (unsigned int attr
)
4078 return "DW_AT_sibling";
4079 case DW_AT_location
:
4080 return "DW_AT_location";
4082 return "DW_AT_name";
4083 case DW_AT_ordering
:
4084 return "DW_AT_ordering";
4085 case DW_AT_subscr_data
:
4086 return "DW_AT_subscr_data";
4087 case DW_AT_byte_size
:
4088 return "DW_AT_byte_size";
4089 case DW_AT_bit_offset
:
4090 return "DW_AT_bit_offset";
4091 case DW_AT_bit_size
:
4092 return "DW_AT_bit_size";
4093 case DW_AT_element_list
:
4094 return "DW_AT_element_list";
4095 case DW_AT_stmt_list
:
4096 return "DW_AT_stmt_list";
4098 return "DW_AT_low_pc";
4100 return "DW_AT_high_pc";
4101 case DW_AT_language
:
4102 return "DW_AT_language";
4104 return "DW_AT_member";
4106 return "DW_AT_discr";
4107 case DW_AT_discr_value
:
4108 return "DW_AT_discr_value";
4109 case DW_AT_visibility
:
4110 return "DW_AT_visibility";
4112 return "DW_AT_import";
4113 case DW_AT_string_length
:
4114 return "DW_AT_string_length";
4115 case DW_AT_common_reference
:
4116 return "DW_AT_common_reference";
4117 case DW_AT_comp_dir
:
4118 return "DW_AT_comp_dir";
4119 case DW_AT_const_value
:
4120 return "DW_AT_const_value";
4121 case DW_AT_containing_type
:
4122 return "DW_AT_containing_type";
4123 case DW_AT_default_value
:
4124 return "DW_AT_default_value";
4126 return "DW_AT_inline";
4127 case DW_AT_is_optional
:
4128 return "DW_AT_is_optional";
4129 case DW_AT_lower_bound
:
4130 return "DW_AT_lower_bound";
4131 case DW_AT_producer
:
4132 return "DW_AT_producer";
4133 case DW_AT_prototyped
:
4134 return "DW_AT_prototyped";
4135 case DW_AT_return_addr
:
4136 return "DW_AT_return_addr";
4137 case DW_AT_start_scope
:
4138 return "DW_AT_start_scope";
4139 case DW_AT_stride_size
:
4140 return "DW_AT_stride_size";
4141 case DW_AT_upper_bound
:
4142 return "DW_AT_upper_bound";
4143 case DW_AT_abstract_origin
:
4144 return "DW_AT_abstract_origin";
4145 case DW_AT_accessibility
:
4146 return "DW_AT_accessibility";
4147 case DW_AT_address_class
:
4148 return "DW_AT_address_class";
4149 case DW_AT_artificial
:
4150 return "DW_AT_artificial";
4151 case DW_AT_base_types
:
4152 return "DW_AT_base_types";
4153 case DW_AT_calling_convention
:
4154 return "DW_AT_calling_convention";
4156 return "DW_AT_count";
4157 case DW_AT_data_member_location
:
4158 return "DW_AT_data_member_location";
4159 case DW_AT_decl_column
:
4160 return "DW_AT_decl_column";
4161 case DW_AT_decl_file
:
4162 return "DW_AT_decl_file";
4163 case DW_AT_decl_line
:
4164 return "DW_AT_decl_line";
4165 case DW_AT_declaration
:
4166 return "DW_AT_declaration";
4167 case DW_AT_discr_list
:
4168 return "DW_AT_discr_list";
4169 case DW_AT_encoding
:
4170 return "DW_AT_encoding";
4171 case DW_AT_external
:
4172 return "DW_AT_external";
4173 case DW_AT_frame_base
:
4174 return "DW_AT_frame_base";
4176 return "DW_AT_friend";
4177 case DW_AT_identifier_case
:
4178 return "DW_AT_identifier_case";
4179 case DW_AT_macro_info
:
4180 return "DW_AT_macro_info";
4181 case DW_AT_namelist_items
:
4182 return "DW_AT_namelist_items";
4183 case DW_AT_priority
:
4184 return "DW_AT_priority";
4186 return "DW_AT_segment";
4187 case DW_AT_specification
:
4188 return "DW_AT_specification";
4189 case DW_AT_static_link
:
4190 return "DW_AT_static_link";
4192 return "DW_AT_type";
4193 case DW_AT_use_location
:
4194 return "DW_AT_use_location";
4195 case DW_AT_variable_parameter
:
4196 return "DW_AT_variable_parameter";
4197 case DW_AT_virtuality
:
4198 return "DW_AT_virtuality";
4199 case DW_AT_vtable_elem_location
:
4200 return "DW_AT_vtable_elem_location";
4202 case DW_AT_allocated
:
4203 return "DW_AT_allocated";
4204 case DW_AT_associated
:
4205 return "DW_AT_associated";
4206 case DW_AT_data_location
:
4207 return "DW_AT_data_location";
4209 return "DW_AT_stride";
4210 case DW_AT_entry_pc
:
4211 return "DW_AT_entry_pc";
4212 case DW_AT_use_UTF8
:
4213 return "DW_AT_use_UTF8";
4214 case DW_AT_extension
:
4215 return "DW_AT_extension";
4217 return "DW_AT_ranges";
4218 case DW_AT_trampoline
:
4219 return "DW_AT_trampoline";
4220 case DW_AT_call_column
:
4221 return "DW_AT_call_column";
4222 case DW_AT_call_file
:
4223 return "DW_AT_call_file";
4224 case DW_AT_call_line
:
4225 return "DW_AT_call_line";
4227 case DW_AT_MIPS_fde
:
4228 return "DW_AT_MIPS_fde";
4229 case DW_AT_MIPS_loop_begin
:
4230 return "DW_AT_MIPS_loop_begin";
4231 case DW_AT_MIPS_tail_loop_begin
:
4232 return "DW_AT_MIPS_tail_loop_begin";
4233 case DW_AT_MIPS_epilog_begin
:
4234 return "DW_AT_MIPS_epilog_begin";
4235 case DW_AT_MIPS_loop_unroll_factor
:
4236 return "DW_AT_MIPS_loop_unroll_factor";
4237 case DW_AT_MIPS_software_pipeline_depth
:
4238 return "DW_AT_MIPS_software_pipeline_depth";
4239 case DW_AT_MIPS_linkage_name
:
4240 return "DW_AT_MIPS_linkage_name";
4241 case DW_AT_MIPS_stride
:
4242 return "DW_AT_MIPS_stride";
4243 case DW_AT_MIPS_abstract_name
:
4244 return "DW_AT_MIPS_abstract_name";
4245 case DW_AT_MIPS_clone_origin
:
4246 return "DW_AT_MIPS_clone_origin";
4247 case DW_AT_MIPS_has_inlines
:
4248 return "DW_AT_MIPS_has_inlines";
4250 case DW_AT_sf_names
:
4251 return "DW_AT_sf_names";
4252 case DW_AT_src_info
:
4253 return "DW_AT_src_info";
4254 case DW_AT_mac_info
:
4255 return "DW_AT_mac_info";
4256 case DW_AT_src_coords
:
4257 return "DW_AT_src_coords";
4258 case DW_AT_body_begin
:
4259 return "DW_AT_body_begin";
4260 case DW_AT_body_end
:
4261 return "DW_AT_body_end";
4262 case DW_AT_GNU_vector
:
4263 return "DW_AT_GNU_vector";
4265 case DW_AT_VMS_rtnbeg_pd_address
:
4266 return "DW_AT_VMS_rtnbeg_pd_address";
4269 return "DW_AT_<unknown>";
4273 /* Convert a DWARF value form code into its string name. */
4276 dwarf_form_name (unsigned int form
)
4281 return "DW_FORM_addr";
4282 case DW_FORM_block2
:
4283 return "DW_FORM_block2";
4284 case DW_FORM_block4
:
4285 return "DW_FORM_block4";
4287 return "DW_FORM_data2";
4289 return "DW_FORM_data4";
4291 return "DW_FORM_data8";
4292 case DW_FORM_string
:
4293 return "DW_FORM_string";
4295 return "DW_FORM_block";
4296 case DW_FORM_block1
:
4297 return "DW_FORM_block1";
4299 return "DW_FORM_data1";
4301 return "DW_FORM_flag";
4303 return "DW_FORM_sdata";
4305 return "DW_FORM_strp";
4307 return "DW_FORM_udata";
4308 case DW_FORM_ref_addr
:
4309 return "DW_FORM_ref_addr";
4311 return "DW_FORM_ref1";
4313 return "DW_FORM_ref2";
4315 return "DW_FORM_ref4";
4317 return "DW_FORM_ref8";
4318 case DW_FORM_ref_udata
:
4319 return "DW_FORM_ref_udata";
4320 case DW_FORM_indirect
:
4321 return "DW_FORM_indirect";
4323 return "DW_FORM_<unknown>";
4327 /* Convert a DWARF type code into its string name. */
4331 dwarf_type_encoding_name (unsigned enc
)
4335 case DW_ATE_address
:
4336 return "DW_ATE_address";
4337 case DW_ATE_boolean
:
4338 return "DW_ATE_boolean";
4339 case DW_ATE_complex_float
:
4340 return "DW_ATE_complex_float";
4342 return "DW_ATE_float";
4344 return "DW_ATE_signed";
4345 case DW_ATE_signed_char
:
4346 return "DW_ATE_signed_char";
4347 case DW_ATE_unsigned
:
4348 return "DW_ATE_unsigned";
4349 case DW_ATE_unsigned_char
:
4350 return "DW_ATE_unsigned_char";
4352 return "DW_ATE_<unknown>";
4357 /* Determine the "ultimate origin" of a decl. The decl may be an inlined
4358 instance of an inlined instance of a decl which is local to an inline
4359 function, so we have to trace all of the way back through the origin chain
4360 to find out what sort of node actually served as the original seed for the
4364 decl_ultimate_origin (tree decl
)
4366 /* output_inline_function sets DECL_ABSTRACT_ORIGIN for all the
4367 nodes in the function to point to themselves; ignore that if
4368 we're trying to output the abstract instance of this function. */
4369 if (DECL_ABSTRACT (decl
) && DECL_ABSTRACT_ORIGIN (decl
) == decl
)
4372 #ifdef ENABLE_CHECKING
4373 if (DECL_FROM_INLINE (DECL_ORIGIN (decl
)))
4374 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
4375 most distant ancestor, this should never happen. */
4379 return DECL_ABSTRACT_ORIGIN (decl
);
4382 /* Determine the "ultimate origin" of a block. The block may be an inlined
4383 instance of an inlined instance of a block which is local to an inline
4384 function, so we have to trace all of the way back through the origin chain
4385 to find out what sort of node actually served as the original seed for the
4389 block_ultimate_origin (tree block
)
4391 tree immediate_origin
= BLOCK_ABSTRACT_ORIGIN (block
);
4393 /* output_inline_function sets BLOCK_ABSTRACT_ORIGIN for all the
4394 nodes in the function to point to themselves; ignore that if
4395 we're trying to output the abstract instance of this function. */
4396 if (BLOCK_ABSTRACT (block
) && immediate_origin
== block
)
4399 if (immediate_origin
== NULL_TREE
)
4404 tree lookahead
= immediate_origin
;
4408 ret_val
= lookahead
;
4409 lookahead
= (TREE_CODE (ret_val
) == BLOCK
4410 ? BLOCK_ABSTRACT_ORIGIN (ret_val
) : NULL
);
4412 while (lookahead
!= NULL
&& lookahead
!= ret_val
);
4418 /* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT
4419 of a virtual function may refer to a base class, so we check the 'this'
4423 decl_class_context (tree decl
)
4425 tree context
= NULL_TREE
;
4427 if (TREE_CODE (decl
) != FUNCTION_DECL
|| ! DECL_VINDEX (decl
))
4428 context
= DECL_CONTEXT (decl
);
4430 context
= TYPE_MAIN_VARIANT
4431 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)))));
4433 if (context
&& !TYPE_P (context
))
4434 context
= NULL_TREE
;
4439 /* Add an attribute/value pair to a DIE. We build the lists up in reverse
4440 addition order, and correct that in reverse_all_dies. */
4443 add_dwarf_attr (dw_die_ref die
, dw_attr_ref attr
)
4445 if (die
!= NULL
&& attr
!= NULL
)
4447 attr
->dw_attr_next
= die
->die_attr
;
4448 die
->die_attr
= attr
;
4452 static inline enum dw_val_class
4453 AT_class (dw_attr_ref a
)
4455 return a
->dw_attr_val
.val_class
;
4458 /* Add a flag value attribute to a DIE. */
4461 add_AT_flag (dw_die_ref die
, enum dwarf_attribute attr_kind
, unsigned int flag
)
4463 dw_attr_ref attr
= ggc_alloc (sizeof (dw_attr_node
));
4465 attr
->dw_attr_next
= NULL
;
4466 attr
->dw_attr
= attr_kind
;
4467 attr
->dw_attr_val
.val_class
= dw_val_class_flag
;
4468 attr
->dw_attr_val
.v
.val_flag
= flag
;
4469 add_dwarf_attr (die
, attr
);
4472 static inline unsigned
4473 AT_flag (dw_attr_ref a
)
4475 if (a
&& AT_class (a
) == dw_val_class_flag
)
4476 return a
->dw_attr_val
.v
.val_flag
;
4481 /* Add a signed integer attribute value to a DIE. */
4484 add_AT_int (dw_die_ref die
, enum dwarf_attribute attr_kind
, HOST_WIDE_INT int_val
)
4486 dw_attr_ref attr
= ggc_alloc (sizeof (dw_attr_node
));
4488 attr
->dw_attr_next
= NULL
;
4489 attr
->dw_attr
= attr_kind
;
4490 attr
->dw_attr_val
.val_class
= dw_val_class_const
;
4491 attr
->dw_attr_val
.v
.val_int
= int_val
;
4492 add_dwarf_attr (die
, attr
);
4495 static inline HOST_WIDE_INT
4496 AT_int (dw_attr_ref a
)
4498 if (a
&& AT_class (a
) == dw_val_class_const
)
4499 return a
->dw_attr_val
.v
.val_int
;
4504 /* Add an unsigned integer attribute value to a DIE. */
4507 add_AT_unsigned (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4508 unsigned HOST_WIDE_INT unsigned_val
)
4510 dw_attr_ref attr
= ggc_alloc (sizeof (dw_attr_node
));
4512 attr
->dw_attr_next
= NULL
;
4513 attr
->dw_attr
= attr_kind
;
4514 attr
->dw_attr_val
.val_class
= dw_val_class_unsigned_const
;
4515 attr
->dw_attr_val
.v
.val_unsigned
= unsigned_val
;
4516 add_dwarf_attr (die
, attr
);
4519 static inline unsigned HOST_WIDE_INT
4520 AT_unsigned (dw_attr_ref a
)
4522 if (a
&& AT_class (a
) == dw_val_class_unsigned_const
)
4523 return a
->dw_attr_val
.v
.val_unsigned
;
4528 /* Add an unsigned double integer attribute value to a DIE. */
4531 add_AT_long_long (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4532 long unsigned int val_hi
, long unsigned int val_low
)
4534 dw_attr_ref attr
= ggc_alloc (sizeof (dw_attr_node
));
4536 attr
->dw_attr_next
= NULL
;
4537 attr
->dw_attr
= attr_kind
;
4538 attr
->dw_attr_val
.val_class
= dw_val_class_long_long
;
4539 attr
->dw_attr_val
.v
.val_long_long
.hi
= val_hi
;
4540 attr
->dw_attr_val
.v
.val_long_long
.low
= val_low
;
4541 add_dwarf_attr (die
, attr
);
4544 /* Add a floating point attribute value to a DIE and return it. */
4547 add_AT_float (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4548 unsigned int length
, long int *array
)
4550 dw_attr_ref attr
= ggc_alloc (sizeof (dw_attr_node
));
4552 attr
->dw_attr_next
= NULL
;
4553 attr
->dw_attr
= attr_kind
;
4554 attr
->dw_attr_val
.val_class
= dw_val_class_float
;
4555 attr
->dw_attr_val
.v
.val_float
.length
= length
;
4556 attr
->dw_attr_val
.v
.val_float
.array
= array
;
4557 add_dwarf_attr (die
, attr
);
4560 /* Hash and equality functions for debug_str_hash. */
4563 debug_str_do_hash (const void *x
)
4565 return htab_hash_string (((const struct indirect_string_node
*)x
)->str
);
4569 debug_str_eq (const void *x1
, const void *x2
)
4571 return strcmp ((((const struct indirect_string_node
*)x1
)->str
),
4572 (const char *)x2
) == 0;
4575 /* Add a string attribute value to a DIE. */
4578 add_AT_string (dw_die_ref die
, enum dwarf_attribute attr_kind
, const char *str
)
4580 dw_attr_ref attr
= ggc_alloc (sizeof (dw_attr_node
));
4581 struct indirect_string_node
*node
;
4584 if (! debug_str_hash
)
4585 debug_str_hash
= htab_create_ggc (10, debug_str_do_hash
,
4586 debug_str_eq
, NULL
);
4588 slot
= htab_find_slot_with_hash (debug_str_hash
, str
,
4589 htab_hash_string (str
), INSERT
);
4591 *slot
= ggc_alloc_cleared (sizeof (struct indirect_string_node
));
4592 node
= (struct indirect_string_node
*) *slot
;
4593 node
->str
= ggc_strdup (str
);
4596 attr
->dw_attr_next
= NULL
;
4597 attr
->dw_attr
= attr_kind
;
4598 attr
->dw_attr_val
.val_class
= dw_val_class_str
;
4599 attr
->dw_attr_val
.v
.val_str
= node
;
4600 add_dwarf_attr (die
, attr
);
4603 static inline const char *
4604 AT_string (dw_attr_ref a
)
4606 if (a
&& AT_class (a
) == dw_val_class_str
)
4607 return a
->dw_attr_val
.v
.val_str
->str
;
4612 /* Find out whether a string should be output inline in DIE
4613 or out-of-line in .debug_str section. */
4616 AT_string_form (dw_attr_ref a
)
4618 if (a
&& AT_class (a
) == dw_val_class_str
)
4620 struct indirect_string_node
*node
;
4624 node
= a
->dw_attr_val
.v
.val_str
;
4628 len
= strlen (node
->str
) + 1;
4630 /* If the string is shorter or equal to the size of the reference, it is
4631 always better to put it inline. */
4632 if (len
<= DWARF_OFFSET_SIZE
|| node
->refcount
== 0)
4633 return node
->form
= DW_FORM_string
;
4635 /* If we cannot expect the linker to merge strings in .debug_str
4636 section, only put it into .debug_str if it is worth even in this
4638 if ((DEBUG_STR_SECTION_FLAGS
& SECTION_MERGE
) == 0
4639 && (len
- DWARF_OFFSET_SIZE
) * node
->refcount
<= len
)
4640 return node
->form
= DW_FORM_string
;
4642 ASM_GENERATE_INTERNAL_LABEL (label
, "LASF", dw2_string_counter
);
4643 ++dw2_string_counter
;
4644 node
->label
= xstrdup (label
);
4646 return node
->form
= DW_FORM_strp
;
4652 /* Add a DIE reference attribute value to a DIE. */
4655 add_AT_die_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
, dw_die_ref targ_die
)
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_die_ref
;
4662 attr
->dw_attr_val
.v
.val_die_ref
.die
= targ_die
;
4663 attr
->dw_attr_val
.v
.val_die_ref
.external
= 0;
4664 add_dwarf_attr (die
, attr
);
4667 static inline dw_die_ref
4668 AT_ref (dw_attr_ref a
)
4670 if (a
&& AT_class (a
) == dw_val_class_die_ref
)
4671 return a
->dw_attr_val
.v
.val_die_ref
.die
;
4677 AT_ref_external (dw_attr_ref a
)
4679 if (a
&& AT_class (a
) == dw_val_class_die_ref
)
4680 return a
->dw_attr_val
.v
.val_die_ref
.external
;
4686 set_AT_ref_external (dw_attr_ref a
, int i
)
4688 if (a
&& AT_class (a
) == dw_val_class_die_ref
)
4689 a
->dw_attr_val
.v
.val_die_ref
.external
= i
;
4694 /* Add an FDE reference attribute value to a DIE. */
4697 add_AT_fde_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
, unsigned int targ_fde
)
4699 dw_attr_ref attr
= ggc_alloc (sizeof (dw_attr_node
));
4701 attr
->dw_attr_next
= NULL
;
4702 attr
->dw_attr
= attr_kind
;
4703 attr
->dw_attr_val
.val_class
= dw_val_class_fde_ref
;
4704 attr
->dw_attr_val
.v
.val_fde_index
= targ_fde
;
4705 add_dwarf_attr (die
, attr
);
4708 /* Add a location description attribute value to a DIE. */
4711 add_AT_loc (dw_die_ref die
, enum dwarf_attribute attr_kind
, dw_loc_descr_ref loc
)
4713 dw_attr_ref attr
= ggc_alloc (sizeof (dw_attr_node
));
4715 attr
->dw_attr_next
= NULL
;
4716 attr
->dw_attr
= attr_kind
;
4717 attr
->dw_attr_val
.val_class
= dw_val_class_loc
;
4718 attr
->dw_attr_val
.v
.val_loc
= loc
;
4719 add_dwarf_attr (die
, attr
);
4722 static inline dw_loc_descr_ref
4723 AT_loc (dw_attr_ref a
)
4725 if (a
&& AT_class (a
) == dw_val_class_loc
)
4726 return a
->dw_attr_val
.v
.val_loc
;
4732 add_AT_loc_list (dw_die_ref die
, enum dwarf_attribute attr_kind
, dw_loc_list_ref loc_list
)
4734 dw_attr_ref attr
= ggc_alloc (sizeof (dw_attr_node
));
4736 attr
->dw_attr_next
= NULL
;
4737 attr
->dw_attr
= attr_kind
;
4738 attr
->dw_attr_val
.val_class
= dw_val_class_loc_list
;
4739 attr
->dw_attr_val
.v
.val_loc_list
= loc_list
;
4740 add_dwarf_attr (die
, attr
);
4741 have_location_lists
= 1;
4744 static inline dw_loc_list_ref
4745 AT_loc_list (dw_attr_ref a
)
4747 if (a
&& AT_class (a
) == dw_val_class_loc_list
)
4748 return a
->dw_attr_val
.v
.val_loc_list
;
4753 /* Add an address constant attribute value to a DIE. */
4756 add_AT_addr (dw_die_ref die
, enum dwarf_attribute attr_kind
, rtx addr
)
4758 dw_attr_ref attr
= ggc_alloc (sizeof (dw_attr_node
));
4760 attr
->dw_attr_next
= NULL
;
4761 attr
->dw_attr
= attr_kind
;
4762 attr
->dw_attr_val
.val_class
= dw_val_class_addr
;
4763 attr
->dw_attr_val
.v
.val_addr
= addr
;
4764 add_dwarf_attr (die
, attr
);
4768 AT_addr (dw_attr_ref a
)
4770 if (a
&& AT_class (a
) == dw_val_class_addr
)
4771 return a
->dw_attr_val
.v
.val_addr
;
4776 /* Add a label identifier attribute value to a DIE. */
4779 add_AT_lbl_id (dw_die_ref die
, enum dwarf_attribute attr_kind
, const char *lbl_id
)
4781 dw_attr_ref attr
= ggc_alloc (sizeof (dw_attr_node
));
4783 attr
->dw_attr_next
= NULL
;
4784 attr
->dw_attr
= attr_kind
;
4785 attr
->dw_attr_val
.val_class
= dw_val_class_lbl_id
;
4786 attr
->dw_attr_val
.v
.val_lbl_id
= xstrdup (lbl_id
);
4787 add_dwarf_attr (die
, attr
);
4790 /* Add a section offset attribute value to a DIE. */
4793 add_AT_lbl_offset (dw_die_ref die
, enum dwarf_attribute attr_kind
, const char *label
)
4795 dw_attr_ref attr
= ggc_alloc (sizeof (dw_attr_node
));
4797 attr
->dw_attr_next
= NULL
;
4798 attr
->dw_attr
= attr_kind
;
4799 attr
->dw_attr_val
.val_class
= dw_val_class_lbl_offset
;
4800 attr
->dw_attr_val
.v
.val_lbl_id
= xstrdup (label
);
4801 add_dwarf_attr (die
, attr
);
4804 /* Add an offset attribute value to a DIE. */
4807 add_AT_offset (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4808 unsigned HOST_WIDE_INT offset
)
4810 dw_attr_ref attr
= ggc_alloc (sizeof (dw_attr_node
));
4812 attr
->dw_attr_next
= NULL
;
4813 attr
->dw_attr
= attr_kind
;
4814 attr
->dw_attr_val
.val_class
= dw_val_class_offset
;
4815 attr
->dw_attr_val
.v
.val_offset
= offset
;
4816 add_dwarf_attr (die
, attr
);
4819 /* Add an range_list attribute value to a DIE. */
4822 add_AT_range_list (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4823 long unsigned int offset
)
4825 dw_attr_ref attr
= ggc_alloc (sizeof (dw_attr_node
));
4827 attr
->dw_attr_next
= NULL
;
4828 attr
->dw_attr
= attr_kind
;
4829 attr
->dw_attr_val
.val_class
= dw_val_class_range_list
;
4830 attr
->dw_attr_val
.v
.val_offset
= offset
;
4831 add_dwarf_attr (die
, attr
);
4834 static inline const char *
4835 AT_lbl (dw_attr_ref a
)
4837 if (a
&& (AT_class (a
) == dw_val_class_lbl_id
4838 || AT_class (a
) == dw_val_class_lbl_offset
))
4839 return a
->dw_attr_val
.v
.val_lbl_id
;
4844 /* Get the attribute of type attr_kind. */
4846 static inline dw_attr_ref
4847 get_AT (dw_die_ref die
, enum dwarf_attribute attr_kind
)
4850 dw_die_ref spec
= NULL
;
4854 for (a
= die
->die_attr
; a
!= NULL
; a
= a
->dw_attr_next
)
4855 if (a
->dw_attr
== attr_kind
)
4857 else if (a
->dw_attr
== DW_AT_specification
4858 || a
->dw_attr
== DW_AT_abstract_origin
)
4862 return get_AT (spec
, attr_kind
);
4868 /* Return the "low pc" attribute value, typically associated with a subprogram
4869 DIE. Return null if the "low pc" attribute is either not present, or if it
4870 cannot be represented as an assembler label identifier. */
4872 static inline const char *
4873 get_AT_low_pc (dw_die_ref die
)
4875 dw_attr_ref a
= get_AT (die
, DW_AT_low_pc
);
4877 return a
? AT_lbl (a
) : NULL
;
4880 /* Return the "high pc" attribute value, typically associated with a subprogram
4881 DIE. Return null if the "high pc" attribute is either not present, or if it
4882 cannot be represented as an assembler label identifier. */
4884 static inline const char *
4885 get_AT_hi_pc (dw_die_ref die
)
4887 dw_attr_ref a
= get_AT (die
, DW_AT_high_pc
);
4889 return a
? AT_lbl (a
) : NULL
;
4892 /* Return the value of the string attribute designated by ATTR_KIND, or
4893 NULL if it is not present. */
4895 static inline const char *
4896 get_AT_string (dw_die_ref die
, enum dwarf_attribute attr_kind
)
4898 dw_attr_ref a
= get_AT (die
, attr_kind
);
4900 return a
? AT_string (a
) : NULL
;
4903 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
4904 if it is not present. */
4907 get_AT_flag (dw_die_ref die
, enum dwarf_attribute attr_kind
)
4909 dw_attr_ref a
= get_AT (die
, attr_kind
);
4911 return a
? AT_flag (a
) : 0;
4914 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
4915 if it is not present. */
4917 static inline unsigned
4918 get_AT_unsigned (dw_die_ref die
, enum dwarf_attribute attr_kind
)
4920 dw_attr_ref a
= get_AT (die
, attr_kind
);
4922 return a
? AT_unsigned (a
) : 0;
4925 static inline dw_die_ref
4926 get_AT_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
)
4928 dw_attr_ref a
= get_AT (die
, attr_kind
);
4930 return a
? AT_ref (a
) : NULL
;
4933 /* Return TRUE if the language is C or C++. */
4938 unsigned int lang
= get_AT_unsigned (comp_unit_die
, DW_AT_language
);
4940 return (lang
== DW_LANG_C
|| lang
== DW_LANG_C89
4941 || lang
== DW_LANG_C_plus_plus
);
4944 /* Return TRUE if the language is C++. */
4949 return (get_AT_unsigned (comp_unit_die
, DW_AT_language
)
4950 == DW_LANG_C_plus_plus
);
4953 /* Return TRUE if the language is Fortran. */
4958 unsigned int lang
= get_AT_unsigned (comp_unit_die
, DW_AT_language
);
4960 return lang
== DW_LANG_Fortran77
|| lang
== DW_LANG_Fortran90
;
4963 /* Return TRUE if the language is Java. */
4968 unsigned int lang
= get_AT_unsigned (comp_unit_die
, DW_AT_language
);
4970 return lang
== DW_LANG_Java
;
4973 /* Return TRUE if the language is Ada. */
4978 unsigned int lang
= get_AT_unsigned (comp_unit_die
, DW_AT_language
);
4980 return lang
== DW_LANG_Ada95
|| lang
== DW_LANG_Ada83
;
4983 /* Free up the memory used by A. */
4985 static inline void free_AT (dw_attr_ref
);
4987 free_AT (dw_attr_ref a
)
4989 if (AT_class (a
) == dw_val_class_str
)
4990 if (a
->dw_attr_val
.v
.val_str
->refcount
)
4991 a
->dw_attr_val
.v
.val_str
->refcount
--;
4994 /* Remove the specified attribute if present. */
4997 remove_AT (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5000 dw_attr_ref removed
= NULL
;
5004 for (p
= &(die
->die_attr
); *p
; p
= &((*p
)->dw_attr_next
))
5005 if ((*p
)->dw_attr
== attr_kind
)
5008 *p
= (*p
)->dw_attr_next
;
5017 /* Free up the memory used by DIE. */
5020 free_die (dw_die_ref die
)
5022 remove_children (die
);
5025 /* Discard the children of this DIE. */
5028 remove_children (dw_die_ref die
)
5030 dw_die_ref child_die
= die
->die_child
;
5032 die
->die_child
= NULL
;
5034 while (child_die
!= NULL
)
5036 dw_die_ref tmp_die
= child_die
;
5039 child_die
= child_die
->die_sib
;
5041 for (a
= tmp_die
->die_attr
; a
!= NULL
;)
5043 dw_attr_ref tmp_a
= a
;
5045 a
= a
->dw_attr_next
;
5053 /* Add a child DIE below its parent. We build the lists up in reverse
5054 addition order, and correct that in reverse_all_dies. */
5057 add_child_die (dw_die_ref die
, dw_die_ref child_die
)
5059 if (die
!= NULL
&& child_die
!= NULL
)
5061 if (die
== child_die
)
5064 child_die
->die_parent
= die
;
5065 child_die
->die_sib
= die
->die_child
;
5066 die
->die_child
= child_die
;
5070 /* Move CHILD, which must be a child of PARENT or the DIE for which PARENT
5071 is the specification, to the front of PARENT's list of children. */
5074 splice_child_die (dw_die_ref parent
, dw_die_ref child
)
5078 /* We want the declaration DIE from inside the class, not the
5079 specification DIE at toplevel. */
5080 if (child
->die_parent
!= parent
)
5082 dw_die_ref tmp
= get_AT_ref (child
, DW_AT_specification
);
5088 if (child
->die_parent
!= parent
5089 && child
->die_parent
!= get_AT_ref (parent
, DW_AT_specification
))
5092 for (p
= &(child
->die_parent
->die_child
); *p
; p
= &((*p
)->die_sib
))
5095 *p
= child
->die_sib
;
5099 child
->die_parent
= parent
;
5100 child
->die_sib
= parent
->die_child
;
5101 parent
->die_child
= child
;
5104 /* Return a pointer to a newly created DIE node. */
5106 static inline dw_die_ref
5107 new_die (enum dwarf_tag tag_value
, dw_die_ref parent_die
, tree t
)
5109 dw_die_ref die
= ggc_alloc_cleared (sizeof (die_node
));
5111 die
->die_tag
= tag_value
;
5113 if (parent_die
!= NULL
)
5114 add_child_die (parent_die
, die
);
5117 limbo_die_node
*limbo_node
;
5119 limbo_node
= ggc_alloc_cleared (sizeof (limbo_die_node
));
5120 limbo_node
->die
= die
;
5121 limbo_node
->created_for
= t
;
5122 limbo_node
->next
= limbo_die_list
;
5123 limbo_die_list
= limbo_node
;
5129 /* Return the DIE associated with the given type specifier. */
5131 static inline dw_die_ref
5132 lookup_type_die (tree type
)
5134 return TYPE_SYMTAB_DIE (type
);
5137 /* Equate a DIE to a given type specifier. */
5140 equate_type_number_to_die (tree type
, dw_die_ref type_die
)
5142 TYPE_SYMTAB_DIE (type
) = type_die
;
5145 /* Return the DIE associated with a given declaration. */
5147 static inline dw_die_ref
5148 lookup_decl_die (tree decl
)
5150 unsigned decl_id
= DECL_UID (decl
);
5152 return (decl_id
< decl_die_table_in_use
? decl_die_table
[decl_id
] : NULL
);
5155 /* Equate a DIE to a particular declaration. */
5158 equate_decl_number_to_die (tree decl
, dw_die_ref decl_die
)
5160 unsigned int decl_id
= DECL_UID (decl
);
5161 unsigned int num_allocated
;
5163 if (decl_id
>= decl_die_table_allocated
)
5166 = ((decl_id
+ 1 + DECL_DIE_TABLE_INCREMENT
- 1)
5167 / DECL_DIE_TABLE_INCREMENT
)
5168 * DECL_DIE_TABLE_INCREMENT
;
5170 decl_die_table
= ggc_realloc (decl_die_table
,
5171 sizeof (dw_die_ref
) * num_allocated
);
5173 memset (&decl_die_table
[decl_die_table_allocated
], 0,
5174 (num_allocated
- decl_die_table_allocated
) * sizeof (dw_die_ref
));
5175 decl_die_table_allocated
= num_allocated
;
5178 if (decl_id
>= decl_die_table_in_use
)
5179 decl_die_table_in_use
= (decl_id
+ 1);
5181 decl_die_table
[decl_id
] = decl_die
;
5184 /* Keep track of the number of spaces used to indent the
5185 output of the debugging routines that print the structure of
5186 the DIE internal representation. */
5187 static int print_indent
;
5189 /* Indent the line the number of spaces given by print_indent. */
5192 print_spaces (FILE *outfile
)
5194 fprintf (outfile
, "%*s", print_indent
, "");
5197 /* Print the information associated with a given DIE, and its children.
5198 This routine is a debugging aid only. */
5201 print_die (dw_die_ref die
, FILE *outfile
)
5206 print_spaces (outfile
);
5207 fprintf (outfile
, "DIE %4lu: %s\n",
5208 die
->die_offset
, dwarf_tag_name (die
->die_tag
));
5209 print_spaces (outfile
);
5210 fprintf (outfile
, " abbrev id: %lu", die
->die_abbrev
);
5211 fprintf (outfile
, " offset: %lu\n", die
->die_offset
);
5213 for (a
= die
->die_attr
; a
!= NULL
; a
= a
->dw_attr_next
)
5215 print_spaces (outfile
);
5216 fprintf (outfile
, " %s: ", dwarf_attr_name (a
->dw_attr
));
5218 switch (AT_class (a
))
5220 case dw_val_class_addr
:
5221 fprintf (outfile
, "address");
5223 case dw_val_class_offset
:
5224 fprintf (outfile
, "offset");
5226 case dw_val_class_loc
:
5227 fprintf (outfile
, "location descriptor");
5229 case dw_val_class_loc_list
:
5230 fprintf (outfile
, "location list -> label:%s",
5231 AT_loc_list (a
)->ll_symbol
);
5233 case dw_val_class_range_list
:
5234 fprintf (outfile
, "range list");
5236 case dw_val_class_const
:
5237 fprintf (outfile
, HOST_WIDE_INT_PRINT_DEC
, AT_int (a
));
5239 case dw_val_class_unsigned_const
:
5240 fprintf (outfile
, HOST_WIDE_INT_PRINT_UNSIGNED
, AT_unsigned (a
));
5242 case dw_val_class_long_long
:
5243 fprintf (outfile
, "constant (%lu,%lu)",
5244 a
->dw_attr_val
.v
.val_long_long
.hi
,
5245 a
->dw_attr_val
.v
.val_long_long
.low
);
5247 case dw_val_class_float
:
5248 fprintf (outfile
, "floating-point constant");
5250 case dw_val_class_flag
:
5251 fprintf (outfile
, "%u", AT_flag (a
));
5253 case dw_val_class_die_ref
:
5254 if (AT_ref (a
) != NULL
)
5256 if (AT_ref (a
)->die_symbol
)
5257 fprintf (outfile
, "die -> label: %s", AT_ref (a
)->die_symbol
);
5259 fprintf (outfile
, "die -> %lu", AT_ref (a
)->die_offset
);
5262 fprintf (outfile
, "die -> <null>");
5264 case dw_val_class_lbl_id
:
5265 case dw_val_class_lbl_offset
:
5266 fprintf (outfile
, "label: %s", AT_lbl (a
));
5268 case dw_val_class_str
:
5269 if (AT_string (a
) != NULL
)
5270 fprintf (outfile
, "\"%s\"", AT_string (a
));
5272 fprintf (outfile
, "<null>");
5278 fprintf (outfile
, "\n");
5281 if (die
->die_child
!= NULL
)
5284 for (c
= die
->die_child
; c
!= NULL
; c
= c
->die_sib
)
5285 print_die (c
, outfile
);
5289 if (print_indent
== 0)
5290 fprintf (outfile
, "\n");
5293 /* Print the contents of the source code line number correspondence table.
5294 This routine is a debugging aid only. */
5297 print_dwarf_line_table (FILE *outfile
)
5300 dw_line_info_ref line_info
;
5302 fprintf (outfile
, "\n\nDWARF source line information\n");
5303 for (i
= 1; i
< line_info_table_in_use
; i
++)
5305 line_info
= &line_info_table
[i
];
5306 fprintf (outfile
, "%5d: ", i
);
5307 fprintf (outfile
, "%-20s",
5308 VARRAY_CHAR_PTR (file_table
, line_info
->dw_file_num
));
5309 fprintf (outfile
, "%6ld", line_info
->dw_line_num
);
5310 fprintf (outfile
, "\n");
5313 fprintf (outfile
, "\n\n");
5316 /* Print the information collected for a given DIE. */
5319 debug_dwarf_die (dw_die_ref die
)
5321 print_die (die
, stderr
);
5324 /* Print all DWARF information collected for the compilation unit.
5325 This routine is a debugging aid only. */
5331 print_die (comp_unit_die
, stderr
);
5332 if (! DWARF2_ASM_LINE_DEBUG_INFO
)
5333 print_dwarf_line_table (stderr
);
5336 /* We build up the lists of children and attributes by pushing new ones
5337 onto the beginning of the list. Reverse the lists for DIE so that
5338 they are in order of addition. */
5341 reverse_die_lists (dw_die_ref die
)
5343 dw_die_ref c
, cp
, cn
;
5344 dw_attr_ref a
, ap
, an
;
5346 for (a
= die
->die_attr
, ap
= 0; a
; a
= an
)
5348 an
= a
->dw_attr_next
;
5349 a
->dw_attr_next
= ap
;
5355 for (c
= die
->die_child
, cp
= 0; c
; c
= cn
)
5362 die
->die_child
= cp
;
5365 /* reverse_die_lists only reverses the single die you pass it. Since we used to
5366 reverse all dies in add_sibling_attributes, which runs through all the dies,
5367 it would reverse all the dies. Now, however, since we don't call
5368 reverse_die_lists in add_sibling_attributes, we need a routine to
5369 recursively reverse all the dies. This is that routine. */
5372 reverse_all_dies (dw_die_ref die
)
5376 reverse_die_lists (die
);
5378 for (c
= die
->die_child
; c
; c
= c
->die_sib
)
5379 reverse_all_dies (c
);
5382 /* Start a new compilation unit DIE for an include file. OLD_UNIT is the CU
5383 for the enclosing include file, if any. BINCL_DIE is the DW_TAG_GNU_BINCL
5384 DIE that marks the start of the DIEs for this include file. */
5387 push_new_compile_unit (dw_die_ref old_unit
, dw_die_ref bincl_die
)
5389 const char *filename
= get_AT_string (bincl_die
, DW_AT_name
);
5390 dw_die_ref new_unit
= gen_compile_unit_die (filename
);
5392 new_unit
->die_sib
= old_unit
;
5396 /* Close an include-file CU and reopen the enclosing one. */
5399 pop_compile_unit (dw_die_ref old_unit
)
5401 dw_die_ref new_unit
= old_unit
->die_sib
;
5403 old_unit
->die_sib
= NULL
;
5407 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
5408 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO), ctx)
5410 /* Calculate the checksum of a location expression. */
5413 loc_checksum (dw_loc_descr_ref loc
, struct md5_ctx
*ctx
)
5415 CHECKSUM (loc
->dw_loc_opc
);
5416 CHECKSUM (loc
->dw_loc_oprnd1
);
5417 CHECKSUM (loc
->dw_loc_oprnd2
);
5420 /* Calculate the checksum of an attribute. */
5423 attr_checksum (dw_attr_ref at
, struct md5_ctx
*ctx
, int *mark
)
5425 dw_loc_descr_ref loc
;
5428 CHECKSUM (at
->dw_attr
);
5430 /* We don't care about differences in file numbering. */
5431 if (at
->dw_attr
== DW_AT_decl_file
5432 /* Or that this was compiled with a different compiler snapshot; if
5433 the output is the same, that's what matters. */
5434 || at
->dw_attr
== DW_AT_producer
)
5437 switch (AT_class (at
))
5439 case dw_val_class_const
:
5440 CHECKSUM (at
->dw_attr_val
.v
.val_int
);
5442 case dw_val_class_unsigned_const
:
5443 CHECKSUM (at
->dw_attr_val
.v
.val_unsigned
);
5445 case dw_val_class_long_long
:
5446 CHECKSUM (at
->dw_attr_val
.v
.val_long_long
);
5448 case dw_val_class_float
:
5449 CHECKSUM (at
->dw_attr_val
.v
.val_float
);
5451 case dw_val_class_flag
:
5452 CHECKSUM (at
->dw_attr_val
.v
.val_flag
);
5454 case dw_val_class_str
:
5455 CHECKSUM_STRING (AT_string (at
));
5458 case dw_val_class_addr
:
5460 switch (GET_CODE (r
))
5463 CHECKSUM_STRING (XSTR (r
, 0));
5471 case dw_val_class_offset
:
5472 CHECKSUM (at
->dw_attr_val
.v
.val_offset
);
5475 case dw_val_class_loc
:
5476 for (loc
= AT_loc (at
); loc
; loc
= loc
->dw_loc_next
)
5477 loc_checksum (loc
, ctx
);
5480 case dw_val_class_die_ref
:
5481 die_checksum (AT_ref (at
), ctx
, mark
);
5484 case dw_val_class_fde_ref
:
5485 case dw_val_class_lbl_id
:
5486 case dw_val_class_lbl_offset
:
5494 /* Calculate the checksum of a DIE. */
5497 die_checksum (dw_die_ref die
, struct md5_ctx
*ctx
, int *mark
)
5502 /* To avoid infinite recursion. */
5505 CHECKSUM (die
->die_mark
);
5508 die
->die_mark
= ++(*mark
);
5510 CHECKSUM (die
->die_tag
);
5512 for (a
= die
->die_attr
; a
; a
= a
->dw_attr_next
)
5513 attr_checksum (a
, ctx
, mark
);
5515 for (c
= die
->die_child
; c
; c
= c
->die_sib
)
5516 die_checksum (c
, ctx
, mark
);
5520 #undef CHECKSUM_STRING
5522 /* Do the location expressions look same? */
5524 same_loc_p (dw_loc_descr_ref loc1
, dw_loc_descr_ref loc2
, int *mark
)
5526 return loc1
->dw_loc_opc
== loc2
->dw_loc_opc
5527 && same_dw_val_p (&loc1
->dw_loc_oprnd1
, &loc2
->dw_loc_oprnd1
, mark
)
5528 && same_dw_val_p (&loc1
->dw_loc_oprnd2
, &loc2
->dw_loc_oprnd2
, mark
);
5531 /* Do the values look the same? */
5533 same_dw_val_p (dw_val_node
*v1
, dw_val_node
*v2
, int *mark
)
5535 dw_loc_descr_ref loc1
, loc2
;
5539 if (v1
->val_class
!= v2
->val_class
)
5542 switch (v1
->val_class
)
5544 case dw_val_class_const
:
5545 return v1
->v
.val_int
== v2
->v
.val_int
;
5546 case dw_val_class_unsigned_const
:
5547 return v1
->v
.val_unsigned
== v2
->v
.val_unsigned
;
5548 case dw_val_class_long_long
:
5549 return v1
->v
.val_long_long
.hi
== v2
->v
.val_long_long
.hi
5550 && v1
->v
.val_long_long
.low
== v2
->v
.val_long_long
.low
;
5551 case dw_val_class_float
:
5552 if (v1
->v
.val_float
.length
!= v2
->v
.val_float
.length
)
5554 for (i
= 0; i
< v1
->v
.val_float
.length
; i
++)
5555 if (v1
->v
.val_float
.array
[i
] != v2
->v
.val_float
.array
[i
])
5558 case dw_val_class_flag
:
5559 return v1
->v
.val_flag
== v2
->v
.val_flag
;
5560 case dw_val_class_str
:
5561 return !strcmp(v1
->v
.val_str
->str
, v2
->v
.val_str
->str
);
5563 case dw_val_class_addr
:
5564 r1
= v1
->v
.val_addr
;
5565 r2
= v2
->v
.val_addr
;
5566 if (GET_CODE (r1
) != GET_CODE (r2
))
5568 switch (GET_CODE (r1
))
5571 return !strcmp (XSTR (r1
, 0), XSTR (r2
, 0));
5577 case dw_val_class_offset
:
5578 return v1
->v
.val_offset
== v2
->v
.val_offset
;
5580 case dw_val_class_loc
:
5581 for (loc1
= v1
->v
.val_loc
, loc2
= v2
->v
.val_loc
;
5583 loc1
= loc1
->dw_loc_next
, loc2
= loc2
->dw_loc_next
)
5584 if (!same_loc_p (loc1
, loc2
, mark
))
5586 return !loc1
&& !loc2
;
5588 case dw_val_class_die_ref
:
5589 return same_die_p (v1
->v
.val_die_ref
.die
, v2
->v
.val_die_ref
.die
, mark
);
5591 case dw_val_class_fde_ref
:
5592 case dw_val_class_lbl_id
:
5593 case dw_val_class_lbl_offset
:
5601 /* Do the attributes look the same? */
5604 same_attr_p (dw_attr_ref at1
, dw_attr_ref at2
, int *mark
)
5606 if (at1
->dw_attr
!= at2
->dw_attr
)
5609 /* We don't care about differences in file numbering. */
5610 if (at1
->dw_attr
== DW_AT_decl_file
5611 /* Or that this was compiled with a different compiler snapshot; if
5612 the output is the same, that's what matters. */
5613 || at1
->dw_attr
== DW_AT_producer
)
5616 return same_dw_val_p (&at1
->dw_attr_val
, &at2
->dw_attr_val
, mark
);
5619 /* Do the dies look the same? */
5622 same_die_p (dw_die_ref die1
, dw_die_ref die2
, int *mark
)
5627 /* To avoid infinite recursion. */
5629 return die1
->die_mark
== die2
->die_mark
;
5630 die1
->die_mark
= die2
->die_mark
= ++(*mark
);
5632 if (die1
->die_tag
!= die2
->die_tag
)
5635 for (a1
= die1
->die_attr
, a2
= die2
->die_attr
;
5637 a1
= a1
->dw_attr_next
, a2
= a2
->dw_attr_next
)
5638 if (!same_attr_p (a1
, a2
, mark
))
5643 for (c1
= die1
->die_child
, c2
= die2
->die_child
;
5645 c1
= c1
->die_sib
, c2
= c2
->die_sib
)
5646 if (!same_die_p (c1
, c2
, mark
))
5654 /* Do the dies look the same? Wrapper around same_die_p. */
5657 same_die_p_wrap (dw_die_ref die1
, dw_die_ref die2
)
5660 int ret
= same_die_p (die1
, die2
, &mark
);
5662 unmark_all_dies (die1
);
5663 unmark_all_dies (die2
);
5668 /* The prefix to attach to symbols on DIEs in the current comdat debug
5670 static char *comdat_symbol_id
;
5672 /* The index of the current symbol within the current comdat CU. */
5673 static unsigned int comdat_symbol_number
;
5675 /* Calculate the MD5 checksum of the compilation unit DIE UNIT_DIE and its
5676 children, and set comdat_symbol_id accordingly. */
5679 compute_section_prefix (dw_die_ref unit_die
)
5681 const char *die_name
= get_AT_string (unit_die
, DW_AT_name
);
5682 const char *base
= die_name
? lbasename (die_name
) : "anonymous";
5683 char *name
= alloca (strlen (base
) + 64);
5686 unsigned char checksum
[16];
5689 /* Compute the checksum of the DIE, then append part of it as hex digits to
5690 the name filename of the unit. */
5692 md5_init_ctx (&ctx
);
5694 die_checksum (unit_die
, &ctx
, &mark
);
5695 unmark_all_dies (unit_die
);
5696 md5_finish_ctx (&ctx
, checksum
);
5698 sprintf (name
, "%s.", base
);
5699 clean_symbol_name (name
);
5701 p
= name
+ strlen (name
);
5702 for (i
= 0; i
< 4; i
++)
5704 sprintf (p
, "%.2x", checksum
[i
]);
5708 comdat_symbol_id
= unit_die
->die_symbol
= xstrdup (name
);
5709 comdat_symbol_number
= 0;
5712 /* Returns nonzero if DIE represents a type, in the sense of TYPE_P. */
5715 is_type_die (dw_die_ref die
)
5717 switch (die
->die_tag
)
5719 case DW_TAG_array_type
:
5720 case DW_TAG_class_type
:
5721 case DW_TAG_enumeration_type
:
5722 case DW_TAG_pointer_type
:
5723 case DW_TAG_reference_type
:
5724 case DW_TAG_string_type
:
5725 case DW_TAG_structure_type
:
5726 case DW_TAG_subroutine_type
:
5727 case DW_TAG_union_type
:
5728 case DW_TAG_ptr_to_member_type
:
5729 case DW_TAG_set_type
:
5730 case DW_TAG_subrange_type
:
5731 case DW_TAG_base_type
:
5732 case DW_TAG_const_type
:
5733 case DW_TAG_file_type
:
5734 case DW_TAG_packed_type
:
5735 case DW_TAG_volatile_type
:
5736 case DW_TAG_typedef
:
5743 /* Returns 1 iff C is the sort of DIE that should go into a COMDAT CU.
5744 Basically, we want to choose the bits that are likely to be shared between
5745 compilations (types) and leave out the bits that are specific to individual
5746 compilations (functions). */
5749 is_comdat_die (dw_die_ref c
)
5751 /* I think we want to leave base types and __vtbl_ptr_type in the main CU, as
5752 we do for stabs. The advantage is a greater likelihood of sharing between
5753 objects that don't include headers in the same order (and therefore would
5754 put the base types in a different comdat). jason 8/28/00 */
5756 if (c
->die_tag
== DW_TAG_base_type
)
5759 if (c
->die_tag
== DW_TAG_pointer_type
5760 || c
->die_tag
== DW_TAG_reference_type
5761 || c
->die_tag
== DW_TAG_const_type
5762 || c
->die_tag
== DW_TAG_volatile_type
)
5764 dw_die_ref t
= get_AT_ref (c
, DW_AT_type
);
5766 return t
? is_comdat_die (t
) : 0;
5769 return is_type_die (c
);
5772 /* Returns 1 iff C is the sort of DIE that might be referred to from another
5773 compilation unit. */
5776 is_symbol_die (dw_die_ref c
)
5778 return (is_type_die (c
)
5779 || (get_AT (c
, DW_AT_declaration
)
5780 && !get_AT (c
, DW_AT_specification
)));
5784 gen_internal_sym (const char *prefix
)
5788 ASM_GENERATE_INTERNAL_LABEL (buf
, prefix
, label_num
++);
5789 return xstrdup (buf
);
5792 /* Assign symbols to all worthy DIEs under DIE. */
5795 assign_symbol_names (dw_die_ref die
)
5799 if (is_symbol_die (die
))
5801 if (comdat_symbol_id
)
5803 char *p
= alloca (strlen (comdat_symbol_id
) + 64);
5805 sprintf (p
, "%s.%s.%x", DIE_LABEL_PREFIX
,
5806 comdat_symbol_id
, comdat_symbol_number
++);
5807 die
->die_symbol
= xstrdup (p
);
5810 die
->die_symbol
= gen_internal_sym ("LDIE");
5813 for (c
= die
->die_child
; c
!= NULL
; c
= c
->die_sib
)
5814 assign_symbol_names (c
);
5817 struct cu_hash_table_entry
5820 unsigned min_comdat_num
, max_comdat_num
;
5821 struct cu_hash_table_entry
*next
;
5824 /* Routines to manipulate hash table of CUs. */
5826 htab_cu_hash (const void *of
)
5828 const struct cu_hash_table_entry
*entry
= of
;
5830 return htab_hash_string (entry
->cu
->die_symbol
);
5834 htab_cu_eq (const void *of1
, const void *of2
)
5836 const struct cu_hash_table_entry
*entry1
= of1
;
5837 const struct die_struct
*entry2
= of2
;
5839 return !strcmp (entry1
->cu
->die_symbol
, entry2
->die_symbol
);
5843 htab_cu_del (void *what
)
5845 struct cu_hash_table_entry
*next
, *entry
= what
;
5855 /* Check whether we have already seen this CU and set up SYM_NUM
5858 check_duplicate_cu (dw_die_ref cu
, htab_t htable
, unsigned int *sym_num
)
5860 struct cu_hash_table_entry dummy
;
5861 struct cu_hash_table_entry
**slot
, *entry
, *last
= &dummy
;
5863 dummy
.max_comdat_num
= 0;
5865 slot
= (struct cu_hash_table_entry
**)
5866 htab_find_slot_with_hash (htable
, cu
, htab_hash_string (cu
->die_symbol
),
5870 for (; entry
; last
= entry
, entry
= entry
->next
)
5872 if (same_die_p_wrap (cu
, entry
->cu
))
5878 *sym_num
= entry
->min_comdat_num
;
5882 entry
= xcalloc (1, sizeof (struct cu_hash_table_entry
));
5884 entry
->min_comdat_num
= *sym_num
= last
->max_comdat_num
;
5885 entry
->next
= *slot
;
5891 /* Record SYM_NUM to record of CU in HTABLE. */
5893 record_comdat_symbol_number (dw_die_ref cu
, htab_t htable
, unsigned int sym_num
)
5895 struct cu_hash_table_entry
**slot
, *entry
;
5897 slot
= (struct cu_hash_table_entry
**)
5898 htab_find_slot_with_hash (htable
, cu
, htab_hash_string (cu
->die_symbol
),
5902 entry
->max_comdat_num
= sym_num
;
5905 /* Traverse the DIE (which is always comp_unit_die), and set up
5906 additional compilation units for each of the include files we see
5907 bracketed by BINCL/EINCL. */
5910 break_out_includes (dw_die_ref die
)
5913 dw_die_ref unit
= NULL
;
5914 limbo_die_node
*node
, **pnode
;
5915 htab_t cu_hash_table
;
5917 for (ptr
= &(die
->die_child
); *ptr
;)
5919 dw_die_ref c
= *ptr
;
5921 if (c
->die_tag
== DW_TAG_GNU_BINCL
|| c
->die_tag
== DW_TAG_GNU_EINCL
5922 || (unit
&& is_comdat_die (c
)))
5924 /* This DIE is for a secondary CU; remove it from the main one. */
5927 if (c
->die_tag
== DW_TAG_GNU_BINCL
)
5929 unit
= push_new_compile_unit (unit
, c
);
5932 else if (c
->die_tag
== DW_TAG_GNU_EINCL
)
5934 unit
= pop_compile_unit (unit
);
5938 add_child_die (unit
, c
);
5942 /* Leave this DIE in the main CU. */
5943 ptr
= &(c
->die_sib
);
5949 /* We can only use this in debugging, since the frontend doesn't check
5950 to make sure that we leave every include file we enter. */
5955 assign_symbol_names (die
);
5956 cu_hash_table
= htab_create (10, htab_cu_hash
, htab_cu_eq
, htab_cu_del
);
5957 for (node
= limbo_die_list
, pnode
= &limbo_die_list
;
5963 compute_section_prefix (node
->die
);
5964 is_dupl
= check_duplicate_cu (node
->die
, cu_hash_table
,
5965 &comdat_symbol_number
);
5966 assign_symbol_names (node
->die
);
5968 *pnode
= node
->next
;
5971 pnode
= &node
->next
;
5972 record_comdat_symbol_number (node
->die
, cu_hash_table
,
5973 comdat_symbol_number
);
5976 htab_delete (cu_hash_table
);
5979 /* Traverse the DIE and add a sibling attribute if it may have the
5980 effect of speeding up access to siblings. To save some space,
5981 avoid generating sibling attributes for DIE's without children. */
5984 add_sibling_attributes (dw_die_ref die
)
5988 if (die
->die_tag
!= DW_TAG_compile_unit
5989 && die
->die_sib
&& die
->die_child
!= NULL
)
5990 /* Add the sibling link to the front of the attribute list. */
5991 add_AT_die_ref (die
, DW_AT_sibling
, die
->die_sib
);
5993 for (c
= die
->die_child
; c
!= NULL
; c
= c
->die_sib
)
5994 add_sibling_attributes (c
);
5997 /* Output all location lists for the DIE and its children. */
6000 output_location_lists (dw_die_ref die
)
6005 for (d_attr
= die
->die_attr
; d_attr
; d_attr
= d_attr
->dw_attr_next
)
6006 if (AT_class (d_attr
) == dw_val_class_loc_list
)
6007 output_loc_list (AT_loc_list (d_attr
));
6009 for (c
= die
->die_child
; c
!= NULL
; c
= c
->die_sib
)
6010 output_location_lists (c
);
6014 /* The format of each DIE (and its attribute value pairs) is encoded in an
6015 abbreviation table. This routine builds the abbreviation table and assigns
6016 a unique abbreviation id for each abbreviation entry. The children of each
6017 die are visited recursively. */
6020 build_abbrev_table (dw_die_ref die
)
6022 unsigned long abbrev_id
;
6023 unsigned int n_alloc
;
6025 dw_attr_ref d_attr
, a_attr
;
6027 /* Scan the DIE references, and mark as external any that refer to
6028 DIEs from other CUs (i.e. those which are not marked). */
6029 for (d_attr
= die
->die_attr
; d_attr
; d_attr
= d_attr
->dw_attr_next
)
6030 if (AT_class (d_attr
) == dw_val_class_die_ref
6031 && AT_ref (d_attr
)->die_mark
== 0)
6033 if (AT_ref (d_attr
)->die_symbol
== 0)
6036 set_AT_ref_external (d_attr
, 1);
6039 for (abbrev_id
= 1; abbrev_id
< abbrev_die_table_in_use
; ++abbrev_id
)
6041 dw_die_ref abbrev
= abbrev_die_table
[abbrev_id
];
6043 if (abbrev
->die_tag
== die
->die_tag
)
6045 if ((abbrev
->die_child
!= NULL
) == (die
->die_child
!= NULL
))
6047 a_attr
= abbrev
->die_attr
;
6048 d_attr
= die
->die_attr
;
6050 while (a_attr
!= NULL
&& d_attr
!= NULL
)
6052 if ((a_attr
->dw_attr
!= d_attr
->dw_attr
)
6053 || (value_format (a_attr
) != value_format (d_attr
)))
6056 a_attr
= a_attr
->dw_attr_next
;
6057 d_attr
= d_attr
->dw_attr_next
;
6060 if (a_attr
== NULL
&& d_attr
== NULL
)
6066 if (abbrev_id
>= abbrev_die_table_in_use
)
6068 if (abbrev_die_table_in_use
>= abbrev_die_table_allocated
)
6070 n_alloc
= abbrev_die_table_allocated
+ ABBREV_DIE_TABLE_INCREMENT
;
6071 abbrev_die_table
= ggc_realloc (abbrev_die_table
,
6072 sizeof (dw_die_ref
) * n_alloc
);
6074 memset (&abbrev_die_table
[abbrev_die_table_allocated
], 0,
6075 (n_alloc
- abbrev_die_table_allocated
) * sizeof (dw_die_ref
));
6076 abbrev_die_table_allocated
= n_alloc
;
6079 ++abbrev_die_table_in_use
;
6080 abbrev_die_table
[abbrev_id
] = die
;
6083 die
->die_abbrev
= abbrev_id
;
6084 for (c
= die
->die_child
; c
!= NULL
; c
= c
->die_sib
)
6085 build_abbrev_table (c
);
6088 /* Return the power-of-two number of bytes necessary to represent VALUE. */
6091 constant_size (long unsigned int value
)
6098 log
= floor_log2 (value
);
6101 log
= 1 << (floor_log2 (log
) + 1);
6106 /* Return the size of a DIE as it is represented in the
6107 .debug_info section. */
6109 static unsigned long
6110 size_of_die (dw_die_ref die
)
6112 unsigned long size
= 0;
6115 size
+= size_of_uleb128 (die
->die_abbrev
);
6116 for (a
= die
->die_attr
; a
!= NULL
; a
= a
->dw_attr_next
)
6118 switch (AT_class (a
))
6120 case dw_val_class_addr
:
6121 size
+= DWARF2_ADDR_SIZE
;
6123 case dw_val_class_offset
:
6124 size
+= DWARF_OFFSET_SIZE
;
6126 case dw_val_class_loc
:
6128 unsigned long lsize
= size_of_locs (AT_loc (a
));
6131 size
+= constant_size (lsize
);
6135 case dw_val_class_loc_list
:
6136 size
+= DWARF_OFFSET_SIZE
;
6138 case dw_val_class_range_list
:
6139 size
+= DWARF_OFFSET_SIZE
;
6141 case dw_val_class_const
:
6142 size
+= size_of_sleb128 (AT_int (a
));
6144 case dw_val_class_unsigned_const
:
6145 size
+= constant_size (AT_unsigned (a
));
6147 case dw_val_class_long_long
:
6148 size
+= 1 + 2*HOST_BITS_PER_LONG
/HOST_BITS_PER_CHAR
; /* block */
6150 case dw_val_class_float
:
6151 size
+= 1 + a
->dw_attr_val
.v
.val_float
.length
* 4; /* block */
6153 case dw_val_class_flag
:
6156 case dw_val_class_die_ref
:
6157 if (AT_ref_external (a
))
6158 size
+= DWARF2_ADDR_SIZE
;
6160 size
+= DWARF_OFFSET_SIZE
;
6162 case dw_val_class_fde_ref
:
6163 size
+= DWARF_OFFSET_SIZE
;
6165 case dw_val_class_lbl_id
:
6166 size
+= DWARF2_ADDR_SIZE
;
6168 case dw_val_class_lbl_offset
:
6169 size
+= DWARF_OFFSET_SIZE
;
6171 case dw_val_class_str
:
6172 if (AT_string_form (a
) == DW_FORM_strp
)
6173 size
+= DWARF_OFFSET_SIZE
;
6175 size
+= strlen (a
->dw_attr_val
.v
.val_str
->str
) + 1;
6185 /* Size the debugging information associated with a given DIE. Visits the
6186 DIE's children recursively. Updates the global variable next_die_offset, on
6187 each time through. Uses the current value of next_die_offset to update the
6188 die_offset field in each DIE. */
6191 calc_die_sizes (dw_die_ref die
)
6195 die
->die_offset
= next_die_offset
;
6196 next_die_offset
+= size_of_die (die
);
6198 for (c
= die
->die_child
; c
!= NULL
; c
= c
->die_sib
)
6201 if (die
->die_child
!= NULL
)
6202 /* Count the null byte used to terminate sibling lists. */
6203 next_die_offset
+= 1;
6206 /* Set the marks for a die and its children. We do this so
6207 that we know whether or not a reference needs to use FORM_ref_addr; only
6208 DIEs in the same CU will be marked. We used to clear out the offset
6209 and use that as the flag, but ran into ordering problems. */
6212 mark_dies (dw_die_ref die
)
6220 for (c
= die
->die_child
; c
; c
= c
->die_sib
)
6224 /* Clear the marks for a die and its children. */
6227 unmark_dies (dw_die_ref die
)
6235 for (c
= die
->die_child
; c
; c
= c
->die_sib
)
6239 /* Clear the marks for a die, its children and referred dies. */
6242 unmark_all_dies (dw_die_ref die
)
6251 for (c
= die
->die_child
; c
; c
= c
->die_sib
)
6252 unmark_all_dies (c
);
6254 for (a
= die
->die_attr
; a
; a
= a
->dw_attr_next
)
6255 if (AT_class (a
) == dw_val_class_die_ref
)
6256 unmark_all_dies (AT_ref (a
));
6259 /* Return the size of the .debug_pubnames table generated for the
6260 compilation unit. */
6262 static unsigned long
6263 size_of_pubnames (void)
6268 size
= DWARF_PUBNAMES_HEADER_SIZE
;
6269 for (i
= 0; i
< pubname_table_in_use
; i
++)
6271 pubname_ref p
= &pubname_table
[i
];
6272 size
+= DWARF_OFFSET_SIZE
+ strlen (p
->name
) + 1;
6275 size
+= DWARF_OFFSET_SIZE
;
6279 /* Return the size of the information in the .debug_aranges section. */
6281 static unsigned long
6282 size_of_aranges (void)
6286 size
= DWARF_ARANGES_HEADER_SIZE
;
6288 /* Count the address/length pair for this compilation unit. */
6289 size
+= 2 * DWARF2_ADDR_SIZE
;
6290 size
+= 2 * DWARF2_ADDR_SIZE
* arange_table_in_use
;
6292 /* Count the two zero words used to terminated the address range table. */
6293 size
+= 2 * DWARF2_ADDR_SIZE
;
6297 /* Select the encoding of an attribute value. */
6299 static enum dwarf_form
6300 value_format (dw_attr_ref a
)
6302 switch (a
->dw_attr_val
.val_class
)
6304 case dw_val_class_addr
:
6305 return DW_FORM_addr
;
6306 case dw_val_class_range_list
:
6307 case dw_val_class_offset
:
6308 if (DWARF_OFFSET_SIZE
== 4)
6309 return DW_FORM_data4
;
6310 if (DWARF_OFFSET_SIZE
== 8)
6311 return DW_FORM_data8
;
6313 case dw_val_class_loc_list
:
6314 /* FIXME: Could be DW_FORM_data8, with a > 32 bit size
6315 .debug_loc section */
6316 return DW_FORM_data4
;
6317 case dw_val_class_loc
:
6318 switch (constant_size (size_of_locs (AT_loc (a
))))
6321 return DW_FORM_block1
;
6323 return DW_FORM_block2
;
6327 case dw_val_class_const
:
6328 return DW_FORM_sdata
;
6329 case dw_val_class_unsigned_const
:
6330 switch (constant_size (AT_unsigned (a
)))
6333 return DW_FORM_data1
;
6335 return DW_FORM_data2
;
6337 return DW_FORM_data4
;
6339 return DW_FORM_data8
;
6343 case dw_val_class_long_long
:
6344 return DW_FORM_block1
;
6345 case dw_val_class_float
:
6346 return DW_FORM_block1
;
6347 case dw_val_class_flag
:
6348 return DW_FORM_flag
;
6349 case dw_val_class_die_ref
:
6350 if (AT_ref_external (a
))
6351 return DW_FORM_ref_addr
;
6354 case dw_val_class_fde_ref
:
6355 return DW_FORM_data
;
6356 case dw_val_class_lbl_id
:
6357 return DW_FORM_addr
;
6358 case dw_val_class_lbl_offset
:
6359 return DW_FORM_data
;
6360 case dw_val_class_str
:
6361 return AT_string_form (a
);
6368 /* Output the encoding of an attribute value. */
6371 output_value_format (dw_attr_ref a
)
6373 enum dwarf_form form
= value_format (a
);
6375 dw2_asm_output_data_uleb128 (form
, "(%s)", dwarf_form_name (form
));
6378 /* Output the .debug_abbrev section which defines the DIE abbreviation
6382 output_abbrev_section (void)
6384 unsigned long abbrev_id
;
6388 for (abbrev_id
= 1; abbrev_id
< abbrev_die_table_in_use
; ++abbrev_id
)
6390 dw_die_ref abbrev
= abbrev_die_table
[abbrev_id
];
6392 dw2_asm_output_data_uleb128 (abbrev_id
, "(abbrev code)");
6393 dw2_asm_output_data_uleb128 (abbrev
->die_tag
, "(TAG: %s)",
6394 dwarf_tag_name (abbrev
->die_tag
));
6396 if (abbrev
->die_child
!= NULL
)
6397 dw2_asm_output_data (1, DW_children_yes
, "DW_children_yes");
6399 dw2_asm_output_data (1, DW_children_no
, "DW_children_no");
6401 for (a_attr
= abbrev
->die_attr
; a_attr
!= NULL
;
6402 a_attr
= a_attr
->dw_attr_next
)
6404 dw2_asm_output_data_uleb128 (a_attr
->dw_attr
, "(%s)",
6405 dwarf_attr_name (a_attr
->dw_attr
));
6406 output_value_format (a_attr
);
6409 dw2_asm_output_data (1, 0, NULL
);
6410 dw2_asm_output_data (1, 0, NULL
);
6413 /* Terminate the table. */
6414 dw2_asm_output_data (1, 0, NULL
);
6417 /* Output a symbol we can use to refer to this DIE from another CU. */
6420 output_die_symbol (dw_die_ref die
)
6422 char *sym
= die
->die_symbol
;
6427 if (strncmp (sym
, DIE_LABEL_PREFIX
, sizeof (DIE_LABEL_PREFIX
) - 1) == 0)
6428 /* We make these global, not weak; if the target doesn't support
6429 .linkonce, it doesn't support combining the sections, so debugging
6431 (*targetm
.asm_out
.globalize_label
) (asm_out_file
, sym
);
6433 ASM_OUTPUT_LABEL (asm_out_file
, sym
);
6436 /* Return a new location list, given the begin and end range, and the
6437 expression. gensym tells us whether to generate a new internal symbol for
6438 this location list node, which is done for the head of the list only. */
6440 static inline dw_loc_list_ref
6441 new_loc_list (dw_loc_descr_ref expr
, const char *begin
, const char *end
,
6442 const char *section
, unsigned int gensym
)
6444 dw_loc_list_ref retlist
= ggc_alloc_cleared (sizeof (dw_loc_list_node
));
6446 retlist
->begin
= begin
;
6448 retlist
->expr
= expr
;
6449 retlist
->section
= section
;
6451 retlist
->ll_symbol
= gen_internal_sym ("LLST");
6456 /* Add a location description expression to a location list. */
6459 add_loc_descr_to_loc_list (dw_loc_list_ref
*list_head
, dw_loc_descr_ref descr
,
6460 const char *begin
, const char *end
,
6461 const char *section
)
6465 /* Find the end of the chain. */
6466 for (d
= list_head
; (*d
) != NULL
; d
= &(*d
)->dw_loc_next
)
6469 /* Add a new location list node to the list. */
6470 *d
= new_loc_list (descr
, begin
, end
, section
, 0);
6473 /* Output the location list given to us. */
6476 output_loc_list (dw_loc_list_ref list_head
)
6478 dw_loc_list_ref curr
= list_head
;
6480 ASM_OUTPUT_LABEL (asm_out_file
, list_head
->ll_symbol
);
6482 /* ??? This shouldn't be needed now that we've forced the
6483 compilation unit base address to zero when there is code
6484 in more than one section. */
6485 if (strcmp (curr
->section
, ".text") == 0)
6487 /* dw2_asm_output_data will mask off any extra bits in the ~0. */
6488 dw2_asm_output_data (DWARF2_ADDR_SIZE
, ~(unsigned HOST_WIDE_INT
) 0,
6489 "Location list base address specifier fake entry");
6490 dw2_asm_output_offset (DWARF2_ADDR_SIZE
, curr
->section
,
6491 "Location list base address specifier base");
6494 for (curr
= list_head
; curr
!= NULL
; curr
= curr
->dw_loc_next
)
6498 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, curr
->begin
, curr
->section
,
6499 "Location list begin address (%s)",
6500 list_head
->ll_symbol
);
6501 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, curr
->end
, curr
->section
,
6502 "Location list end address (%s)",
6503 list_head
->ll_symbol
);
6504 size
= size_of_locs (curr
->expr
);
6506 /* Output the block length for this list of location operations. */
6509 dw2_asm_output_data (2, size
, "%s", "Location expression size");
6511 output_loc_sequence (curr
->expr
);
6514 dw2_asm_output_data (DWARF_OFFSET_SIZE
, 0,
6515 "Location list terminator begin (%s)",
6516 list_head
->ll_symbol
);
6517 dw2_asm_output_data (DWARF_OFFSET_SIZE
, 0,
6518 "Location list terminator end (%s)",
6519 list_head
->ll_symbol
);
6522 /* Output the DIE and its attributes. Called recursively to generate
6523 the definitions of each child DIE. */
6526 output_die (dw_die_ref die
)
6532 /* If someone in another CU might refer to us, set up a symbol for
6533 them to point to. */
6534 if (die
->die_symbol
)
6535 output_die_symbol (die
);
6537 dw2_asm_output_data_uleb128 (die
->die_abbrev
, "(DIE (0x%lx) %s)",
6538 die
->die_offset
, dwarf_tag_name (die
->die_tag
));
6540 for (a
= die
->die_attr
; a
!= NULL
; a
= a
->dw_attr_next
)
6542 const char *name
= dwarf_attr_name (a
->dw_attr
);
6544 switch (AT_class (a
))
6546 case dw_val_class_addr
:
6547 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, AT_addr (a
), "%s", name
);
6550 case dw_val_class_offset
:
6551 dw2_asm_output_data (DWARF_OFFSET_SIZE
, a
->dw_attr_val
.v
.val_offset
,
6555 case dw_val_class_range_list
:
6557 char *p
= strchr (ranges_section_label
, '\0');
6559 sprintf (p
, "+" HOST_WIDE_INT_PRINT_HEX
,
6560 a
->dw_attr_val
.v
.val_offset
);
6561 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, ranges_section_label
,
6567 case dw_val_class_loc
:
6568 size
= size_of_locs (AT_loc (a
));
6570 /* Output the block length for this list of location operations. */
6571 dw2_asm_output_data (constant_size (size
), size
, "%s", name
);
6573 output_loc_sequence (AT_loc (a
));
6576 case dw_val_class_const
:
6577 /* ??? It would be slightly more efficient to use a scheme like is
6578 used for unsigned constants below, but gdb 4.x does not sign
6579 extend. Gdb 5.x does sign extend. */
6580 dw2_asm_output_data_sleb128 (AT_int (a
), "%s", name
);
6583 case dw_val_class_unsigned_const
:
6584 dw2_asm_output_data (constant_size (AT_unsigned (a
)),
6585 AT_unsigned (a
), "%s", name
);
6588 case dw_val_class_long_long
:
6590 unsigned HOST_WIDE_INT first
, second
;
6592 dw2_asm_output_data (1,
6593 2 * HOST_BITS_PER_LONG
/ HOST_BITS_PER_CHAR
,
6596 if (WORDS_BIG_ENDIAN
)
6598 first
= a
->dw_attr_val
.v
.val_long_long
.hi
;
6599 second
= a
->dw_attr_val
.v
.val_long_long
.low
;
6603 first
= a
->dw_attr_val
.v
.val_long_long
.low
;
6604 second
= a
->dw_attr_val
.v
.val_long_long
.hi
;
6607 dw2_asm_output_data (HOST_BITS_PER_LONG
/ HOST_BITS_PER_CHAR
,
6608 first
, "long long constant");
6609 dw2_asm_output_data (HOST_BITS_PER_LONG
/ HOST_BITS_PER_CHAR
,
6614 case dw_val_class_float
:
6618 dw2_asm_output_data (1, a
->dw_attr_val
.v
.val_float
.length
* 4,
6621 for (i
= 0; i
< a
->dw_attr_val
.v
.val_float
.length
; i
++)
6622 dw2_asm_output_data (4, a
->dw_attr_val
.v
.val_float
.array
[i
],
6623 "fp constant word %u", i
);
6627 case dw_val_class_flag
:
6628 dw2_asm_output_data (1, AT_flag (a
), "%s", name
);
6631 case dw_val_class_loc_list
:
6633 char *sym
= AT_loc_list (a
)->ll_symbol
;
6637 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, sym
,
6638 loc_section_label
, "%s", name
);
6642 case dw_val_class_die_ref
:
6643 if (AT_ref_external (a
))
6645 char *sym
= AT_ref (a
)->die_symbol
;
6649 dw2_asm_output_offset (DWARF2_ADDR_SIZE
, sym
, "%s", name
);
6651 else if (AT_ref (a
)->die_offset
== 0)
6654 dw2_asm_output_data (DWARF_OFFSET_SIZE
, AT_ref (a
)->die_offset
,
6658 case dw_val_class_fde_ref
:
6662 ASM_GENERATE_INTERNAL_LABEL (l1
, FDE_LABEL
,
6663 a
->dw_attr_val
.v
.val_fde_index
* 2);
6664 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, l1
, "%s", name
);
6668 case dw_val_class_lbl_id
:
6669 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, AT_lbl (a
), "%s", name
);
6672 case dw_val_class_lbl_offset
:
6673 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, AT_lbl (a
), "%s", name
);
6676 case dw_val_class_str
:
6677 if (AT_string_form (a
) == DW_FORM_strp
)
6678 dw2_asm_output_offset (DWARF_OFFSET_SIZE
,
6679 a
->dw_attr_val
.v
.val_str
->label
,
6680 "%s: \"%s\"", name
, AT_string (a
));
6682 dw2_asm_output_nstring (AT_string (a
), -1, "%s", name
);
6690 for (c
= die
->die_child
; c
!= NULL
; c
= c
->die_sib
)
6693 /* Add null byte to terminate sibling list. */
6694 if (die
->die_child
!= NULL
)
6695 dw2_asm_output_data (1, 0, "end of children of DIE 0x%lx",
6699 /* Output the compilation unit that appears at the beginning of the
6700 .debug_info section, and precedes the DIE descriptions. */
6703 output_compilation_unit_header (void)
6705 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
6706 dw2_asm_output_data (4, 0xffffffff,
6707 "Initial length escape value indicating 64-bit DWARF extension");
6708 dw2_asm_output_data (DWARF_OFFSET_SIZE
,
6709 next_die_offset
- DWARF_INITIAL_LENGTH_SIZE
,
6710 "Length of Compilation Unit Info");
6711 dw2_asm_output_data (2, DWARF_VERSION
, "DWARF version number");
6712 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, abbrev_section_label
,
6713 "Offset Into Abbrev. Section");
6714 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Pointer Size (in bytes)");
6717 /* Output the compilation unit DIE and its children. */
6720 output_comp_unit (dw_die_ref die
, int output_if_empty
)
6722 const char *secname
;
6725 /* Unless we are outputting main CU, we may throw away empty ones. */
6726 if (!output_if_empty
&& die
->die_child
== NULL
)
6729 /* Even if there are no children of this DIE, we must output the information
6730 about the compilation unit. Otherwise, on an empty translation unit, we
6731 will generate a present, but empty, .debug_info section. IRIX 6.5 `nm'
6732 will then complain when examining the file. First mark all the DIEs in
6733 this CU so we know which get local refs. */
6736 build_abbrev_table (die
);
6738 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
6739 next_die_offset
= DWARF_COMPILE_UNIT_HEADER_SIZE
;
6740 calc_die_sizes (die
);
6742 oldsym
= die
->die_symbol
;
6745 tmp
= alloca (strlen (oldsym
) + 24);
6747 sprintf (tmp
, ".gnu.linkonce.wi.%s", oldsym
);
6749 die
->die_symbol
= NULL
;
6752 secname
= (const char *) DEBUG_INFO_SECTION
;
6754 /* Output debugging information. */
6755 named_section_flags (secname
, SECTION_DEBUG
);
6756 output_compilation_unit_header ();
6759 /* Leave the marks on the main CU, so we can check them in
6764 die
->die_symbol
= oldsym
;
6768 /* The DWARF2 pubname for a nested thingy looks like "A::f". The
6769 output of lang_hooks.decl_printable_name for C++ looks like
6770 "A::f(int)". Let's drop the argument list, and maybe the scope. */
6773 dwarf2_name (tree decl
, int scope
)
6775 return (*lang_hooks
.decl_printable_name
) (decl
, scope
? 1 : 0);
6778 /* Add a new entry to .debug_pubnames if appropriate. */
6781 add_pubname (tree decl
, dw_die_ref die
)
6785 if (! TREE_PUBLIC (decl
))
6788 if (pubname_table_in_use
== pubname_table_allocated
)
6790 pubname_table_allocated
+= PUBNAME_TABLE_INCREMENT
;
6792 = ggc_realloc (pubname_table
,
6793 (pubname_table_allocated
* sizeof (pubname_entry
)));
6794 memset (pubname_table
+ pubname_table_in_use
, 0,
6795 PUBNAME_TABLE_INCREMENT
* sizeof (pubname_entry
));
6798 p
= &pubname_table
[pubname_table_in_use
++];
6800 p
->name
= xstrdup (dwarf2_name (decl
, 1));
6803 /* Output the public names table used to speed up access to externally
6804 visible names. For now, only generate entries for externally
6805 visible procedures. */
6808 output_pubnames (void)
6811 unsigned long pubnames_length
= size_of_pubnames ();
6813 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
6814 dw2_asm_output_data (4, 0xffffffff,
6815 "Initial length escape value indicating 64-bit DWARF extension");
6816 dw2_asm_output_data (DWARF_OFFSET_SIZE
, pubnames_length
,
6817 "Length of Public Names Info");
6818 dw2_asm_output_data (2, DWARF_VERSION
, "DWARF Version");
6819 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_info_section_label
,
6820 "Offset of Compilation Unit Info");
6821 dw2_asm_output_data (DWARF_OFFSET_SIZE
, next_die_offset
,
6822 "Compilation Unit Length");
6824 for (i
= 0; i
< pubname_table_in_use
; i
++)
6826 pubname_ref pub
= &pubname_table
[i
];
6828 /* We shouldn't see pubnames for DIEs outside of the main CU. */
6829 if (pub
->die
->die_mark
== 0)
6832 dw2_asm_output_data (DWARF_OFFSET_SIZE
, pub
->die
->die_offset
,
6835 dw2_asm_output_nstring (pub
->name
, -1, "external name");
6838 dw2_asm_output_data (DWARF_OFFSET_SIZE
, 0, NULL
);
6841 /* Add a new entry to .debug_aranges if appropriate. */
6844 add_arange (tree decl
, dw_die_ref die
)
6846 if (! DECL_SECTION_NAME (decl
))
6849 if (arange_table_in_use
== arange_table_allocated
)
6851 arange_table_allocated
+= ARANGE_TABLE_INCREMENT
;
6852 arange_table
= ggc_realloc (arange_table
,
6853 (arange_table_allocated
6854 * sizeof (dw_die_ref
)));
6855 memset (arange_table
+ arange_table_in_use
, 0,
6856 ARANGE_TABLE_INCREMENT
* sizeof (dw_die_ref
));
6859 arange_table
[arange_table_in_use
++] = die
;
6862 /* Output the information that goes into the .debug_aranges table.
6863 Namely, define the beginning and ending address range of the
6864 text section generated for this compilation unit. */
6867 output_aranges (void)
6870 unsigned long aranges_length
= size_of_aranges ();
6872 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
6873 dw2_asm_output_data (4, 0xffffffff,
6874 "Initial length escape value indicating 64-bit DWARF extension");
6875 dw2_asm_output_data (DWARF_OFFSET_SIZE
, aranges_length
,
6876 "Length of Address Ranges Info");
6877 dw2_asm_output_data (2, DWARF_VERSION
, "DWARF Version");
6878 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_info_section_label
,
6879 "Offset of Compilation Unit Info");
6880 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Size of Address");
6881 dw2_asm_output_data (1, 0, "Size of Segment Descriptor");
6883 /* We need to align to twice the pointer size here. */
6884 if (DWARF_ARANGES_PAD_SIZE
)
6886 /* Pad using a 2 byte words so that padding is correct for any
6888 dw2_asm_output_data (2, 0, "Pad to %d byte boundary",
6889 2 * DWARF2_ADDR_SIZE
);
6890 for (i
= 2; i
< (unsigned) DWARF_ARANGES_PAD_SIZE
; i
+= 2)
6891 dw2_asm_output_data (2, 0, NULL
);
6894 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, text_section_label
, "Address");
6895 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, text_end_label
,
6896 text_section_label
, "Length");
6898 for (i
= 0; i
< arange_table_in_use
; i
++)
6900 dw_die_ref die
= arange_table
[i
];
6902 /* We shouldn't see aranges for DIEs outside of the main CU. */
6903 if (die
->die_mark
== 0)
6906 if (die
->die_tag
== DW_TAG_subprogram
)
6908 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, get_AT_low_pc (die
),
6910 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, get_AT_hi_pc (die
),
6911 get_AT_low_pc (die
), "Length");
6915 /* A static variable; extract the symbol from DW_AT_location.
6916 Note that this code isn't currently hit, as we only emit
6917 aranges for functions (jason 9/23/99). */
6918 dw_attr_ref a
= get_AT (die
, DW_AT_location
);
6919 dw_loc_descr_ref loc
;
6921 if (! a
|| AT_class (a
) != dw_val_class_loc
)
6925 if (loc
->dw_loc_opc
!= DW_OP_addr
)
6928 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
,
6929 loc
->dw_loc_oprnd1
.v
.val_addr
, "Address");
6930 dw2_asm_output_data (DWARF2_ADDR_SIZE
,
6931 get_AT_unsigned (die
, DW_AT_byte_size
),
6936 /* Output the terminator words. */
6937 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
6938 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
6941 /* Add a new entry to .debug_ranges. Return the offset at which it
6945 add_ranges (tree block
)
6947 unsigned int in_use
= ranges_table_in_use
;
6949 if (in_use
== ranges_table_allocated
)
6951 ranges_table_allocated
+= RANGES_TABLE_INCREMENT
;
6953 = ggc_realloc (ranges_table
, (ranges_table_allocated
6954 * sizeof (struct dw_ranges_struct
)));
6955 memset (ranges_table
+ ranges_table_in_use
, 0,
6956 RANGES_TABLE_INCREMENT
* sizeof (struct dw_ranges_struct
));
6959 ranges_table
[in_use
].block_num
= (block
? BLOCK_NUMBER (block
) : 0);
6960 ranges_table_in_use
= in_use
+ 1;
6962 return in_use
* 2 * DWARF2_ADDR_SIZE
;
6966 output_ranges (void)
6969 static const char *const start_fmt
= "Offset 0x%x";
6970 const char *fmt
= start_fmt
;
6972 for (i
= 0; i
< ranges_table_in_use
; i
++)
6974 int block_num
= ranges_table
[i
].block_num
;
6978 char blabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
6979 char elabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
6981 ASM_GENERATE_INTERNAL_LABEL (blabel
, BLOCK_BEGIN_LABEL
, block_num
);
6982 ASM_GENERATE_INTERNAL_LABEL (elabel
, BLOCK_END_LABEL
, block_num
);
6984 /* If all code is in the text section, then the compilation
6985 unit base address defaults to DW_AT_low_pc, which is the
6986 base of the text section. */
6987 if (separate_line_info_table_in_use
== 0)
6989 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, blabel
,
6991 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
6992 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, elabel
,
6993 text_section_label
, NULL
);
6996 /* Otherwise, we add a DW_AT_entry_pc attribute to force the
6997 compilation unit base address to zero, which allows us to
6998 use absolute addresses, and not worry about whether the
6999 target supports cross-section arithmetic. */
7002 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
7003 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
7004 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, elabel
, NULL
);
7011 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
7012 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
7018 /* Data structure containing information about input files. */
7021 char *path
; /* Complete file name. */
7022 char *fname
; /* File name part. */
7023 int length
; /* Length of entire string. */
7024 int file_idx
; /* Index in input file table. */
7025 int dir_idx
; /* Index in directory table. */
7028 /* Data structure containing information about directories with source
7032 char *path
; /* Path including directory name. */
7033 int length
; /* Path length. */
7034 int prefix
; /* Index of directory entry which is a prefix. */
7035 int count
; /* Number of files in this directory. */
7036 int dir_idx
; /* Index of directory used as base. */
7037 int used
; /* Used in the end? */
7040 /* Callback function for file_info comparison. We sort by looking at
7041 the directories in the path. */
7044 file_info_cmp (const void *p1
, const void *p2
)
7046 const struct file_info
*s1
= p1
;
7047 const struct file_info
*s2
= p2
;
7051 /* Take care of file names without directories. We need to make sure that
7052 we return consistent values to qsort since some will get confused if
7053 we return the same value when identical operands are passed in opposite
7054 orders. So if neither has a directory, return 0 and otherwise return
7055 1 or -1 depending on which one has the directory. */
7056 if ((s1
->path
== s1
->fname
|| s2
->path
== s2
->fname
))
7057 return (s2
->path
== s2
->fname
) - (s1
->path
== s1
->fname
);
7059 cp1
= (unsigned char *) s1
->path
;
7060 cp2
= (unsigned char *) s2
->path
;
7066 /* Reached the end of the first path? If so, handle like above. */
7067 if ((cp1
== (unsigned char *) s1
->fname
)
7068 || (cp2
== (unsigned char *) s2
->fname
))
7069 return ((cp2
== (unsigned char *) s2
->fname
)
7070 - (cp1
== (unsigned char *) s1
->fname
));
7072 /* Character of current path component the same? */
7073 else if (*cp1
!= *cp2
)
7078 /* Output the directory table and the file name table. We try to minimize
7079 the total amount of memory needed. A heuristic is used to avoid large
7080 slowdowns with many input files. */
7083 output_file_names (void)
7085 struct file_info
*files
;
7086 struct dir_info
*dirs
;
7095 /* Handle the case where file_table is empty. */
7096 if (VARRAY_ACTIVE_SIZE (file_table
) <= 1)
7098 dw2_asm_output_data (1, 0, "End directory table");
7099 dw2_asm_output_data (1, 0, "End file name table");
7103 /* Allocate the various arrays we need. */
7104 files
= alloca (VARRAY_ACTIVE_SIZE (file_table
) * sizeof (struct file_info
));
7105 dirs
= alloca (VARRAY_ACTIVE_SIZE (file_table
) * sizeof (struct dir_info
));
7107 /* Sort the file names. */
7108 for (i
= 1; i
< VARRAY_ACTIVE_SIZE (file_table
); i
++)
7112 /* Skip all leading "./". */
7113 f
= VARRAY_CHAR_PTR (file_table
, i
);
7114 while (f
[0] == '.' && f
[1] == '/')
7117 /* Create a new array entry. */
7119 files
[i
].length
= strlen (f
);
7120 files
[i
].file_idx
= i
;
7122 /* Search for the file name part. */
7123 f
= strrchr (f
, '/');
7124 files
[i
].fname
= f
== NULL
? files
[i
].path
: f
+ 1;
7127 qsort (files
+ 1, VARRAY_ACTIVE_SIZE (file_table
) - 1,
7128 sizeof (files
[0]), file_info_cmp
);
7130 /* Find all the different directories used. */
7131 dirs
[0].path
= files
[1].path
;
7132 dirs
[0].length
= files
[1].fname
- files
[1].path
;
7133 dirs
[0].prefix
= -1;
7135 dirs
[0].dir_idx
= 0;
7137 files
[1].dir_idx
= 0;
7140 for (i
= 2; i
< VARRAY_ACTIVE_SIZE (file_table
); i
++)
7141 if (files
[i
].fname
- files
[i
].path
== dirs
[ndirs
- 1].length
7142 && memcmp (dirs
[ndirs
- 1].path
, files
[i
].path
,
7143 dirs
[ndirs
- 1].length
) == 0)
7145 /* Same directory as last entry. */
7146 files
[i
].dir_idx
= ndirs
- 1;
7147 ++dirs
[ndirs
- 1].count
;
7153 /* This is a new directory. */
7154 dirs
[ndirs
].path
= files
[i
].path
;
7155 dirs
[ndirs
].length
= files
[i
].fname
- files
[i
].path
;
7156 dirs
[ndirs
].count
= 1;
7157 dirs
[ndirs
].dir_idx
= ndirs
;
7158 dirs
[ndirs
].used
= 0;
7159 files
[i
].dir_idx
= ndirs
;
7161 /* Search for a prefix. */
7162 dirs
[ndirs
].prefix
= -1;
7163 for (j
= 0; j
< ndirs
; j
++)
7164 if (dirs
[j
].length
< dirs
[ndirs
].length
7165 && dirs
[j
].length
> 1
7166 && (dirs
[ndirs
].prefix
== -1
7167 || dirs
[j
].length
> dirs
[dirs
[ndirs
].prefix
].length
)
7168 && memcmp (dirs
[j
].path
, dirs
[ndirs
].path
, dirs
[j
].length
) == 0)
7169 dirs
[ndirs
].prefix
= j
;
7174 /* Now to the actual work. We have to find a subset of the directories which
7175 allow expressing the file name using references to the directory table
7176 with the least amount of characters. We do not do an exhaustive search
7177 where we would have to check out every combination of every single
7178 possible prefix. Instead we use a heuristic which provides nearly optimal
7179 results in most cases and never is much off. */
7180 saved
= alloca (ndirs
* sizeof (int));
7181 savehere
= alloca (ndirs
* sizeof (int));
7183 memset (saved
, '\0', ndirs
* sizeof (saved
[0]));
7184 for (i
= 0; i
< ndirs
; i
++)
7189 /* We can always save some space for the current directory. But this
7190 does not mean it will be enough to justify adding the directory. */
7191 savehere
[i
] = dirs
[i
].length
;
7192 total
= (savehere
[i
] - saved
[i
]) * dirs
[i
].count
;
7194 for (j
= i
+ 1; j
< ndirs
; j
++)
7197 if (saved
[j
] < dirs
[i
].length
)
7199 /* Determine whether the dirs[i] path is a prefix of the
7204 while (k
!= -1 && k
!= (int) i
)
7209 /* Yes it is. We can possibly safe some memory but
7210 writing the filenames in dirs[j] relative to
7212 savehere
[j
] = dirs
[i
].length
;
7213 total
+= (savehere
[j
] - saved
[j
]) * dirs
[j
].count
;
7218 /* Check whether we can safe enough to justify adding the dirs[i]
7220 if (total
> dirs
[i
].length
+ 1)
7222 /* It's worthwhile adding. */
7223 for (j
= i
; j
< ndirs
; j
++)
7224 if (savehere
[j
] > 0)
7226 /* Remember how much we saved for this directory so far. */
7227 saved
[j
] = savehere
[j
];
7229 /* Remember the prefix directory. */
7230 dirs
[j
].dir_idx
= i
;
7235 /* We have to emit them in the order they appear in the file_table array
7236 since the index is used in the debug info generation. To do this
7237 efficiently we generate a back-mapping of the indices first. */
7238 backmap
= alloca (VARRAY_ACTIVE_SIZE (file_table
) * sizeof (int));
7239 for (i
= 1; i
< VARRAY_ACTIVE_SIZE (file_table
); i
++)
7241 backmap
[files
[i
].file_idx
] = i
;
7243 /* Mark this directory as used. */
7244 dirs
[dirs
[files
[i
].dir_idx
].dir_idx
].used
= 1;
7247 /* That was it. We are ready to emit the information. First emit the
7248 directory name table. We have to make sure the first actually emitted
7249 directory name has index one; zero is reserved for the current working
7250 directory. Make sure we do not confuse these indices with the one for the
7251 constructed table (even though most of the time they are identical). */
7253 idx_offset
= dirs
[0].length
> 0 ? 1 : 0;
7254 for (i
= 1 - idx_offset
; i
< ndirs
; i
++)
7255 if (dirs
[i
].used
!= 0)
7257 dirs
[i
].used
= idx
++;
7258 dw2_asm_output_nstring (dirs
[i
].path
, dirs
[i
].length
- 1,
7259 "Directory Entry: 0x%x", dirs
[i
].used
);
7262 dw2_asm_output_data (1, 0, "End directory table");
7264 /* Correct the index for the current working directory entry if it
7266 if (idx_offset
== 0)
7269 /* Now write all the file names. */
7270 for (i
= 1; i
< VARRAY_ACTIVE_SIZE (file_table
); i
++)
7272 int file_idx
= backmap
[i
];
7273 int dir_idx
= dirs
[files
[file_idx
].dir_idx
].dir_idx
;
7275 dw2_asm_output_nstring (files
[file_idx
].path
+ dirs
[dir_idx
].length
, -1,
7276 "File Entry: 0x%lx", (unsigned long) i
);
7278 /* Include directory index. */
7279 dw2_asm_output_data_uleb128 (dirs
[dir_idx
].used
, NULL
);
7281 /* Modification time. */
7282 dw2_asm_output_data_uleb128 (0, NULL
);
7284 /* File length in bytes. */
7285 dw2_asm_output_data_uleb128 (0, NULL
);
7288 dw2_asm_output_data (1, 0, "End file name table");
7292 /* Output the source line number correspondence information. This
7293 information goes into the .debug_line section. */
7296 output_line_info (void)
7298 char l1
[20], l2
[20], p1
[20], p2
[20];
7299 char line_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
7300 char prev_line_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
7303 unsigned long lt_index
;
7304 unsigned long current_line
;
7307 unsigned long current_file
;
7308 unsigned long function
;
7310 ASM_GENERATE_INTERNAL_LABEL (l1
, LINE_NUMBER_BEGIN_LABEL
, 0);
7311 ASM_GENERATE_INTERNAL_LABEL (l2
, LINE_NUMBER_END_LABEL
, 0);
7312 ASM_GENERATE_INTERNAL_LABEL (p1
, LN_PROLOG_AS_LABEL
, 0);
7313 ASM_GENERATE_INTERNAL_LABEL (p2
, LN_PROLOG_END_LABEL
, 0);
7315 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
7316 dw2_asm_output_data (4, 0xffffffff,
7317 "Initial length escape value indicating 64-bit DWARF extension");
7318 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, l2
, l1
,
7319 "Length of Source Line Info");
7320 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
7322 dw2_asm_output_data (2, DWARF_VERSION
, "DWARF Version");
7323 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, p2
, p1
, "Prolog Length");
7324 ASM_OUTPUT_LABEL (asm_out_file
, p1
);
7326 /* Define the architecture-dependent minimum instruction length (in
7327 bytes). In this implementation of DWARF, this field is used for
7328 information purposes only. Since GCC generates assembly language,
7329 we have no a priori knowledge of how many instruction bytes are
7330 generated for each source line, and therefore can use only the
7331 DW_LNE_set_address and DW_LNS_fixed_advance_pc line information
7332 commands. Accordingly, we fix this as `1', which is "correct
7333 enough" for all architectures, and don't let the target override. */
7334 dw2_asm_output_data (1, 1,
7335 "Minimum Instruction Length");
7337 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START
,
7338 "Default is_stmt_start flag");
7339 dw2_asm_output_data (1, DWARF_LINE_BASE
,
7340 "Line Base Value (Special Opcodes)");
7341 dw2_asm_output_data (1, DWARF_LINE_RANGE
,
7342 "Line Range Value (Special Opcodes)");
7343 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE
,
7344 "Special Opcode Base");
7346 for (opc
= 1; opc
< DWARF_LINE_OPCODE_BASE
; opc
++)
7350 case DW_LNS_advance_pc
:
7351 case DW_LNS_advance_line
:
7352 case DW_LNS_set_file
:
7353 case DW_LNS_set_column
:
7354 case DW_LNS_fixed_advance_pc
:
7362 dw2_asm_output_data (1, n_op_args
, "opcode: 0x%x has %d args",
7366 /* Write out the information about the files we use. */
7367 output_file_names ();
7368 ASM_OUTPUT_LABEL (asm_out_file
, p2
);
7370 /* We used to set the address register to the first location in the text
7371 section here, but that didn't accomplish anything since we already
7372 have a line note for the opening brace of the first function. */
7374 /* Generate the line number to PC correspondence table, encoded as
7375 a series of state machine operations. */
7378 strcpy (prev_line_label
, text_section_label
);
7379 for (lt_index
= 1; lt_index
< line_info_table_in_use
; ++lt_index
)
7381 dw_line_info_ref line_info
= &line_info_table
[lt_index
];
7384 /* Disable this optimization for now; GDB wants to see two line notes
7385 at the beginning of a function so it can find the end of the
7388 /* Don't emit anything for redundant notes. Just updating the
7389 address doesn't accomplish anything, because we already assume
7390 that anything after the last address is this line. */
7391 if (line_info
->dw_line_num
== current_line
7392 && line_info
->dw_file_num
== current_file
)
7396 /* Emit debug info for the address of the current line.
7398 Unfortunately, we have little choice here currently, and must always
7399 use the most general form. GCC does not know the address delta
7400 itself, so we can't use DW_LNS_advance_pc. Many ports do have length
7401 attributes which will give an upper bound on the address range. We
7402 could perhaps use length attributes to determine when it is safe to
7403 use DW_LNS_fixed_advance_pc. */
7405 ASM_GENERATE_INTERNAL_LABEL (line_label
, LINE_CODE_LABEL
, lt_index
);
7408 /* This can handle deltas up to 0xffff. This takes 3 bytes. */
7409 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc
,
7410 "DW_LNS_fixed_advance_pc");
7411 dw2_asm_output_delta (2, line_label
, prev_line_label
, NULL
);
7415 /* This can handle any delta. This takes
7416 4+DWARF2_ADDR_SIZE bytes. */
7417 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
7418 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE
, NULL
);
7419 dw2_asm_output_data (1, DW_LNE_set_address
, NULL
);
7420 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, line_label
, NULL
);
7423 strcpy (prev_line_label
, line_label
);
7425 /* Emit debug info for the source file of the current line, if
7426 different from the previous line. */
7427 if (line_info
->dw_file_num
!= current_file
)
7429 current_file
= line_info
->dw_file_num
;
7430 dw2_asm_output_data (1, DW_LNS_set_file
, "DW_LNS_set_file");
7431 dw2_asm_output_data_uleb128 (current_file
, "(\"%s\")",
7432 VARRAY_CHAR_PTR (file_table
,
7436 /* Emit debug info for the current line number, choosing the encoding
7437 that uses the least amount of space. */
7438 if (line_info
->dw_line_num
!= current_line
)
7440 line_offset
= line_info
->dw_line_num
- current_line
;
7441 line_delta
= line_offset
- DWARF_LINE_BASE
;
7442 current_line
= line_info
->dw_line_num
;
7443 if (line_delta
>= 0 && line_delta
< (DWARF_LINE_RANGE
- 1))
7444 /* This can handle deltas from -10 to 234, using the current
7445 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE. This
7447 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE
+ line_delta
,
7448 "line %lu", current_line
);
7451 /* This can handle any delta. This takes at least 4 bytes,
7452 depending on the value being encoded. */
7453 dw2_asm_output_data (1, DW_LNS_advance_line
,
7454 "advance to line %lu", current_line
);
7455 dw2_asm_output_data_sleb128 (line_offset
, NULL
);
7456 dw2_asm_output_data (1, DW_LNS_copy
, "DW_LNS_copy");
7460 /* We still need to start a new row, so output a copy insn. */
7461 dw2_asm_output_data (1, DW_LNS_copy
, "DW_LNS_copy");
7464 /* Emit debug info for the address of the end of the function. */
7467 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc
,
7468 "DW_LNS_fixed_advance_pc");
7469 dw2_asm_output_delta (2, text_end_label
, prev_line_label
, NULL
);
7473 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
7474 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE
, NULL
);
7475 dw2_asm_output_data (1, DW_LNE_set_address
, NULL
);
7476 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, text_end_label
, NULL
);
7479 dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
7480 dw2_asm_output_data_uleb128 (1, NULL
);
7481 dw2_asm_output_data (1, DW_LNE_end_sequence
, NULL
);
7486 for (lt_index
= 0; lt_index
< separate_line_info_table_in_use
;)
7488 dw_separate_line_info_ref line_info
7489 = &separate_line_info_table
[lt_index
];
7492 /* Don't emit anything for redundant notes. */
7493 if (line_info
->dw_line_num
== current_line
7494 && line_info
->dw_file_num
== current_file
7495 && line_info
->function
== function
)
7499 /* Emit debug info for the address of the current line. If this is
7500 a new function, or the first line of a function, then we need
7501 to handle it differently. */
7502 ASM_GENERATE_INTERNAL_LABEL (line_label
, SEPARATE_LINE_CODE_LABEL
,
7504 if (function
!= line_info
->function
)
7506 function
= line_info
->function
;
7508 /* Set the address register to the first line in the function. */
7509 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
7510 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE
, NULL
);
7511 dw2_asm_output_data (1, DW_LNE_set_address
, NULL
);
7512 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, line_label
, NULL
);
7516 /* ??? See the DW_LNS_advance_pc comment above. */
7519 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc
,
7520 "DW_LNS_fixed_advance_pc");
7521 dw2_asm_output_delta (2, line_label
, prev_line_label
, NULL
);
7525 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
7526 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE
, NULL
);
7527 dw2_asm_output_data (1, DW_LNE_set_address
, NULL
);
7528 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, line_label
, NULL
);
7532 strcpy (prev_line_label
, line_label
);
7534 /* Emit debug info for the source file of the current line, if
7535 different from the previous line. */
7536 if (line_info
->dw_file_num
!= current_file
)
7538 current_file
= line_info
->dw_file_num
;
7539 dw2_asm_output_data (1, DW_LNS_set_file
, "DW_LNS_set_file");
7540 dw2_asm_output_data_uleb128 (current_file
, "(\"%s\")",
7541 VARRAY_CHAR_PTR (file_table
,
7545 /* Emit debug info for the current line number, choosing the encoding
7546 that uses the least amount of space. */
7547 if (line_info
->dw_line_num
!= current_line
)
7549 line_offset
= line_info
->dw_line_num
- current_line
;
7550 line_delta
= line_offset
- DWARF_LINE_BASE
;
7551 current_line
= line_info
->dw_line_num
;
7552 if (line_delta
>= 0 && line_delta
< (DWARF_LINE_RANGE
- 1))
7553 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE
+ line_delta
,
7554 "line %lu", current_line
);
7557 dw2_asm_output_data (1, DW_LNS_advance_line
,
7558 "advance to line %lu", current_line
);
7559 dw2_asm_output_data_sleb128 (line_offset
, NULL
);
7560 dw2_asm_output_data (1, DW_LNS_copy
, "DW_LNS_copy");
7564 dw2_asm_output_data (1, DW_LNS_copy
, "DW_LNS_copy");
7572 /* If we're done with a function, end its sequence. */
7573 if (lt_index
== separate_line_info_table_in_use
7574 || separate_line_info_table
[lt_index
].function
!= function
)
7579 /* Emit debug info for the address of the end of the function. */
7580 ASM_GENERATE_INTERNAL_LABEL (line_label
, FUNC_END_LABEL
, function
);
7583 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc
,
7584 "DW_LNS_fixed_advance_pc");
7585 dw2_asm_output_delta (2, line_label
, prev_line_label
, NULL
);
7589 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
7590 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE
, NULL
);
7591 dw2_asm_output_data (1, DW_LNE_set_address
, NULL
);
7592 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, line_label
, NULL
);
7595 /* Output the marker for the end of this sequence. */
7596 dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
7597 dw2_asm_output_data_uleb128 (1, NULL
);
7598 dw2_asm_output_data (1, DW_LNE_end_sequence
, NULL
);
7602 /* Output the marker for the end of the line number info. */
7603 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
7606 /* Given a pointer to a tree node for some base type, return a pointer to
7607 a DIE that describes the given type.
7609 This routine must only be called for GCC type nodes that correspond to
7610 Dwarf base (fundamental) types. */
7613 base_type_die (tree type
)
7615 dw_die_ref base_type_result
;
7616 const char *type_name
;
7617 enum dwarf_type encoding
;
7618 tree name
= TYPE_NAME (type
);
7620 if (TREE_CODE (type
) == ERROR_MARK
|| TREE_CODE (type
) == VOID_TYPE
)
7625 if (TREE_CODE (name
) == TYPE_DECL
)
7626 name
= DECL_NAME (name
);
7628 type_name
= IDENTIFIER_POINTER (name
);
7631 type_name
= "__unknown__";
7633 switch (TREE_CODE (type
))
7636 /* Carefully distinguish the C character types, without messing
7637 up if the language is not C. Note that we check only for the names
7638 that contain spaces; other names might occur by coincidence in other
7640 if (! (TYPE_PRECISION (type
) == CHAR_TYPE_SIZE
7641 && (type
== char_type_node
7642 || ! strcmp (type_name
, "signed char")
7643 || ! strcmp (type_name
, "unsigned char"))))
7645 if (TREE_UNSIGNED (type
))
7646 encoding
= DW_ATE_unsigned
;
7648 encoding
= DW_ATE_signed
;
7651 /* else fall through. */
7654 /* GNU Pascal/Ada CHAR type. Not used in C. */
7655 if (TREE_UNSIGNED (type
))
7656 encoding
= DW_ATE_unsigned_char
;
7658 encoding
= DW_ATE_signed_char
;
7662 encoding
= DW_ATE_float
;
7665 /* Dwarf2 doesn't know anything about complex ints, so use
7666 a user defined type for it. */
7668 if (TREE_CODE (TREE_TYPE (type
)) == REAL_TYPE
)
7669 encoding
= DW_ATE_complex_float
;
7671 encoding
= DW_ATE_lo_user
;
7675 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */
7676 encoding
= DW_ATE_boolean
;
7680 /* No other TREE_CODEs are Dwarf fundamental types. */
7684 base_type_result
= new_die (DW_TAG_base_type
, comp_unit_die
, type
);
7685 if (demangle_name_func
)
7686 type_name
= (*demangle_name_func
) (type_name
);
7688 add_AT_string (base_type_result
, DW_AT_name
, type_name
);
7689 add_AT_unsigned (base_type_result
, DW_AT_byte_size
,
7690 int_size_in_bytes (type
));
7691 add_AT_unsigned (base_type_result
, DW_AT_encoding
, encoding
);
7693 return base_type_result
;
7696 /* Given a pointer to an arbitrary ..._TYPE tree node, return a pointer to
7697 the Dwarf "root" type for the given input type. The Dwarf "root" type of
7698 a given type is generally the same as the given type, except that if the
7699 given type is a pointer or reference type, then the root type of the given
7700 type is the root type of the "basis" type for the pointer or reference
7701 type. (This definition of the "root" type is recursive.) Also, the root
7702 type of a `const' qualified type or a `volatile' qualified type is the
7703 root type of the given type without the qualifiers. */
7706 root_type (tree type
)
7708 if (TREE_CODE (type
) == ERROR_MARK
)
7709 return error_mark_node
;
7711 switch (TREE_CODE (type
))
7714 return error_mark_node
;
7717 case REFERENCE_TYPE
:
7718 return type_main_variant (root_type (TREE_TYPE (type
)));
7721 return type_main_variant (type
);
7725 /* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the
7726 given input type is a Dwarf "fundamental" type. Otherwise return null. */
7729 is_base_type (tree type
)
7731 switch (TREE_CODE (type
))
7746 case QUAL_UNION_TYPE
:
7751 case REFERENCE_TYPE
:
7765 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
7766 node, return the size in bits for the type if it is a constant, or else
7767 return the alignment for the type if the type's size is not constant, or
7768 else return BITS_PER_WORD if the type actually turns out to be an
7771 static inline unsigned HOST_WIDE_INT
7772 simple_type_size_in_bits (tree type
)
7774 if (TREE_CODE (type
) == ERROR_MARK
)
7775 return BITS_PER_WORD
;
7776 else if (TYPE_SIZE (type
) == NULL_TREE
)
7778 else if (host_integerp (TYPE_SIZE (type
), 1))
7779 return tree_low_cst (TYPE_SIZE (type
), 1);
7781 return TYPE_ALIGN (type
);
7784 /* Return true if the debug information for the given type should be
7785 emitted as a subrange type. */
7788 is_ada_subrange_type (tree type
)
7790 /* We do this for INTEGER_TYPEs that have names, parent types, and when
7791 we are compiling Ada code. */
7792 return (TREE_CODE (type
) == INTEGER_TYPE
7793 && TYPE_NAME (type
) != 0 && TREE_TYPE (type
) != 0
7794 && TREE_CODE (TREE_TYPE (type
)) == INTEGER_TYPE
7795 && TREE_UNSIGNED (TREE_TYPE (type
)) && is_ada ());
7798 /* Given a pointer to a tree node for a subrange type, return a pointer
7799 to a DIE that describes the given type. */
7802 subrange_type_die (tree type
)
7804 dw_die_ref subtype_die
;
7805 dw_die_ref subrange_die
;
7806 tree name
= TYPE_NAME (type
);
7808 subtype_die
= base_type_die (TREE_TYPE (type
));
7810 if (TREE_CODE (name
) == TYPE_DECL
)
7811 name
= DECL_NAME (name
);
7813 subrange_die
= new_die (DW_TAG_subrange_type
, comp_unit_die
, type
);
7814 add_name_attribute (subrange_die
, IDENTIFIER_POINTER (name
));
7815 if (TYPE_MIN_VALUE (type
) != NULL
)
7816 add_bound_info (subrange_die
, DW_AT_lower_bound
,
7817 TYPE_MIN_VALUE (type
));
7818 if (TYPE_MAX_VALUE (type
) != NULL
)
7819 add_bound_info (subrange_die
, DW_AT_upper_bound
,
7820 TYPE_MAX_VALUE (type
));
7821 add_AT_die_ref (subrange_die
, DW_AT_type
, subtype_die
);
7823 return subrange_die
;
7826 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
7827 entry that chains various modifiers in front of the given type. */
7830 modified_type_die (tree type
, int is_const_type
, int is_volatile_type
,
7831 dw_die_ref context_die
)
7833 enum tree_code code
= TREE_CODE (type
);
7834 dw_die_ref mod_type_die
= NULL
;
7835 dw_die_ref sub_die
= NULL
;
7836 tree item_type
= NULL
;
7838 if (code
!= ERROR_MARK
)
7840 tree qualified_type
;
7842 /* See if we already have the appropriately qualified variant of
7845 = get_qualified_type (type
,
7846 ((is_const_type
? TYPE_QUAL_CONST
: 0)
7848 ? TYPE_QUAL_VOLATILE
: 0)));
7850 /* If we do, then we can just use its DIE, if it exists. */
7853 mod_type_die
= lookup_type_die (qualified_type
);
7855 return mod_type_die
;
7858 /* Handle C typedef types. */
7859 if (qualified_type
&& TYPE_NAME (qualified_type
)
7860 && TREE_CODE (TYPE_NAME (qualified_type
)) == TYPE_DECL
7861 && DECL_ORIGINAL_TYPE (TYPE_NAME (qualified_type
)))
7863 tree type_name
= TYPE_NAME (qualified_type
);
7864 tree dtype
= TREE_TYPE (type_name
);
7866 if (qualified_type
== dtype
)
7868 /* For a named type, use the typedef. */
7869 gen_type_die (qualified_type
, context_die
);
7870 mod_type_die
= lookup_type_die (qualified_type
);
7872 else if (is_const_type
< TYPE_READONLY (dtype
)
7873 || is_volatile_type
< TYPE_VOLATILE (dtype
))
7874 /* cv-unqualified version of named type. Just use the unnamed
7875 type to which it refers. */
7877 = modified_type_die (DECL_ORIGINAL_TYPE (type_name
),
7878 is_const_type
, is_volatile_type
,
7881 /* Else cv-qualified version of named type; fall through. */
7887 else if (is_const_type
)
7889 mod_type_die
= new_die (DW_TAG_const_type
, comp_unit_die
, type
);
7890 sub_die
= modified_type_die (type
, 0, is_volatile_type
, context_die
);
7892 else if (is_volatile_type
)
7894 mod_type_die
= new_die (DW_TAG_volatile_type
, comp_unit_die
, type
);
7895 sub_die
= modified_type_die (type
, 0, 0, context_die
);
7897 else if (code
== POINTER_TYPE
)
7899 mod_type_die
= new_die (DW_TAG_pointer_type
, comp_unit_die
, type
);
7900 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
,
7901 simple_type_size_in_bits (type
) / BITS_PER_UNIT
);
7903 add_AT_unsigned (mod_type_die
, DW_AT_address_class
, 0);
7905 item_type
= TREE_TYPE (type
);
7907 else if (code
== REFERENCE_TYPE
)
7909 mod_type_die
= new_die (DW_TAG_reference_type
, comp_unit_die
, type
);
7910 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
,
7911 simple_type_size_in_bits (type
) / BITS_PER_UNIT
);
7913 add_AT_unsigned (mod_type_die
, DW_AT_address_class
, 0);
7915 item_type
= TREE_TYPE (type
);
7917 else if (is_ada_subrange_type (type
))
7918 mod_type_die
= subrange_type_die (type
);
7919 else if (is_base_type (type
))
7920 mod_type_die
= base_type_die (type
);
7923 gen_type_die (type
, context_die
);
7925 /* We have to get the type_main_variant here (and pass that to the
7926 `lookup_type_die' routine) because the ..._TYPE node we have
7927 might simply be a *copy* of some original type node (where the
7928 copy was created to help us keep track of typedef names) and
7929 that copy might have a different TYPE_UID from the original
7931 if (TREE_CODE (type
) != VECTOR_TYPE
)
7932 mod_type_die
= lookup_type_die (type_main_variant (type
));
7934 /* Vectors have the debugging information in the type,
7935 not the main variant. */
7936 mod_type_die
= lookup_type_die (type
);
7937 if (mod_type_die
== NULL
)
7941 /* We want to equate the qualified type to the die below. */
7942 type
= qualified_type
;
7946 equate_type_number_to_die (type
, mod_type_die
);
7948 /* We must do this after the equate_type_number_to_die call, in case
7949 this is a recursive type. This ensures that the modified_type_die
7950 recursion will terminate even if the type is recursive. Recursive
7951 types are possible in Ada. */
7952 sub_die
= modified_type_die (item_type
,
7953 TYPE_READONLY (item_type
),
7954 TYPE_VOLATILE (item_type
),
7957 if (sub_die
!= NULL
)
7958 add_AT_die_ref (mod_type_die
, DW_AT_type
, sub_die
);
7960 return mod_type_die
;
7963 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
7964 an enumerated type. */
7967 type_is_enum (tree type
)
7969 return TREE_CODE (type
) == ENUMERAL_TYPE
;
7972 /* Return the register number described by a given RTL node. */
7975 reg_number (rtx rtl
)
7977 unsigned regno
= REGNO (rtl
);
7979 if (regno
>= FIRST_PSEUDO_REGISTER
)
7982 return DBX_REGISTER_NUMBER (regno
);
7985 /* Return a location descriptor that designates a machine register or
7986 zero if there is none. */
7988 static dw_loc_descr_ref
7989 reg_loc_descriptor (rtx rtl
)
7994 if (REGNO (rtl
) >= FIRST_PSEUDO_REGISTER
)
7997 reg
= reg_number (rtl
);
7998 regs
= (*targetm
.dwarf_register_span
) (rtl
);
8000 if (HARD_REGNO_NREGS (reg
, GET_MODE (rtl
)) > 1
8002 return multiple_reg_loc_descriptor (rtl
, regs
);
8004 return one_reg_loc_descriptor (reg
);
8007 /* Return a location descriptor that designates a machine register for
8008 a given hard register number. */
8010 static dw_loc_descr_ref
8011 one_reg_loc_descriptor (unsigned int regno
)
8014 return new_loc_descr (DW_OP_reg0
+ regno
, 0, 0);
8016 return new_loc_descr (DW_OP_regx
, regno
, 0);
8019 /* Given an RTL of a register, return a location descriptor that
8020 designates a value that spans more than one register. */
8022 static dw_loc_descr_ref
8023 multiple_reg_loc_descriptor (rtx rtl
, rtx regs
)
8027 dw_loc_descr_ref loc_result
= NULL
;
8029 reg
= reg_number (rtl
);
8030 nregs
= HARD_REGNO_NREGS (reg
, GET_MODE (rtl
));
8032 /* Simple, contiguous registers. */
8033 if (regs
== NULL_RTX
)
8035 size
= GET_MODE_SIZE (GET_MODE (rtl
)) / nregs
;
8042 t
= one_reg_loc_descriptor (reg
);
8043 add_loc_descr (&loc_result
, t
);
8044 add_loc_descr (&loc_result
, new_loc_descr (DW_OP_piece
, size
, 0));
8050 /* Now onto stupid register sets in non contiguous locations. */
8052 if (GET_CODE (regs
) != PARALLEL
)
8055 size
= GET_MODE_SIZE (GET_MODE (XVECEXP (regs
, 0, 0)));
8058 for (i
= 0; i
< XVECLEN (regs
, 0); ++i
)
8062 t
= one_reg_loc_descriptor (REGNO (XVECEXP (regs
, 0, i
)));
8063 add_loc_descr (&loc_result
, t
);
8064 size
= GET_MODE_SIZE (GET_MODE (XVECEXP (regs
, 0, 0)));
8065 add_loc_descr (&loc_result
, new_loc_descr (DW_OP_piece
, size
, 0));
8070 /* Return a location descriptor that designates a constant. */
8072 static dw_loc_descr_ref
8073 int_loc_descriptor (HOST_WIDE_INT i
)
8075 enum dwarf_location_atom op
;
8077 /* Pick the smallest representation of a constant, rather than just
8078 defaulting to the LEB encoding. */
8082 op
= DW_OP_lit0
+ i
;
8085 else if (i
<= 0xffff)
8087 else if (HOST_BITS_PER_WIDE_INT
== 32
8097 else if (i
>= -0x8000)
8099 else if (HOST_BITS_PER_WIDE_INT
== 32
8100 || i
>= -0x80000000)
8106 return new_loc_descr (op
, i
, 0);
8109 /* Return a location descriptor that designates a base+offset location. */
8111 static dw_loc_descr_ref
8112 based_loc_descr (unsigned int reg
, HOST_WIDE_INT offset
)
8114 dw_loc_descr_ref loc_result
;
8115 /* For the "frame base", we use the frame pointer or stack pointer
8116 registers, since the RTL for local variables is relative to one of
8118 unsigned fp_reg
= DBX_REGISTER_NUMBER (frame_pointer_needed
8119 ? HARD_FRAME_POINTER_REGNUM
8120 : STACK_POINTER_REGNUM
);
8123 loc_result
= new_loc_descr (DW_OP_fbreg
, offset
, 0);
8125 loc_result
= new_loc_descr (DW_OP_breg0
+ reg
, offset
, 0);
8127 loc_result
= new_loc_descr (DW_OP_bregx
, reg
, offset
);
8132 /* Return true if this RTL expression describes a base+offset calculation. */
8135 is_based_loc (rtx rtl
)
8137 return (GET_CODE (rtl
) == PLUS
8138 && ((GET_CODE (XEXP (rtl
, 0)) == REG
8139 && REGNO (XEXP (rtl
, 0)) < FIRST_PSEUDO_REGISTER
8140 && GET_CODE (XEXP (rtl
, 1)) == CONST_INT
)));
8143 /* The following routine converts the RTL for a variable or parameter
8144 (resident in memory) into an equivalent Dwarf representation of a
8145 mechanism for getting the address of that same variable onto the top of a
8146 hypothetical "address evaluation" stack.
8148 When creating memory location descriptors, we are effectively transforming
8149 the RTL for a memory-resident object into its Dwarf postfix expression
8150 equivalent. This routine recursively descends an RTL tree, turning
8151 it into Dwarf postfix code as it goes.
8153 MODE is the mode of the memory reference, needed to handle some
8154 autoincrement addressing modes.
8156 Return 0 if we can't represent the location. */
8158 static dw_loc_descr_ref
8159 mem_loc_descriptor (rtx rtl
, enum machine_mode mode
)
8161 dw_loc_descr_ref mem_loc_result
= NULL
;
8163 /* Note that for a dynamically sized array, the location we will generate a
8164 description of here will be the lowest numbered location which is
8165 actually within the array. That's *not* necessarily the same as the
8166 zeroth element of the array. */
8168 rtl
= (*targetm
.delegitimize_address
) (rtl
);
8170 switch (GET_CODE (rtl
))
8175 /* POST_INC and POST_DEC can be handled just like a SUBREG. So we
8176 just fall into the SUBREG code. */
8178 /* ... fall through ... */
8181 /* The case of a subreg may arise when we have a local (register)
8182 variable or a formal (register) parameter which doesn't quite fill
8183 up an entire register. For now, just assume that it is
8184 legitimate to make the Dwarf info refer to the whole register which
8185 contains the given subreg. */
8186 rtl
= SUBREG_REG (rtl
);
8188 /* ... fall through ... */
8191 /* Whenever a register number forms a part of the description of the
8192 method for calculating the (dynamic) address of a memory resident
8193 object, DWARF rules require the register number be referred to as
8194 a "base register". This distinction is not based in any way upon
8195 what category of register the hardware believes the given register
8196 belongs to. This is strictly DWARF terminology we're dealing with
8197 here. Note that in cases where the location of a memory-resident
8198 data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
8199 OP_CONST (0)) the actual DWARF location descriptor that we generate
8200 may just be OP_BASEREG (basereg). This may look deceptively like
8201 the object in question was allocated to a register (rather than in
8202 memory) so DWARF consumers need to be aware of the subtle
8203 distinction between OP_REG and OP_BASEREG. */
8204 if (REGNO (rtl
) < FIRST_PSEUDO_REGISTER
)
8205 mem_loc_result
= based_loc_descr (reg_number (rtl
), 0);
8209 mem_loc_result
= mem_loc_descriptor (XEXP (rtl
, 0), GET_MODE (rtl
));
8210 if (mem_loc_result
!= 0)
8211 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_deref
, 0, 0));
8215 rtl
= XEXP (rtl
, 1);
8217 /* ... fall through ... */
8220 /* Some ports can transform a symbol ref into a label ref, because
8221 the symbol ref is too far away and has to be dumped into a constant
8225 /* Alternatively, the symbol in the constant pool might be referenced
8226 by a different symbol. */
8227 if (GET_CODE (rtl
) == SYMBOL_REF
&& CONSTANT_POOL_ADDRESS_P (rtl
))
8230 rtx tmp
= get_pool_constant_mark (rtl
, &marked
);
8232 if (GET_CODE (tmp
) == SYMBOL_REF
)
8235 if (CONSTANT_POOL_ADDRESS_P (tmp
))
8236 get_pool_constant_mark (tmp
, &marked
);
8241 /* If all references to this pool constant were optimized away,
8242 it was not output and thus we can't represent it.
8243 FIXME: might try to use DW_OP_const_value here, though
8244 DW_OP_piece complicates it. */
8249 mem_loc_result
= new_loc_descr (DW_OP_addr
, 0, 0);
8250 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_addr
;
8251 mem_loc_result
->dw_loc_oprnd1
.v
.val_addr
= rtl
;
8252 VARRAY_PUSH_RTX (used_rtx_varray
, rtl
);
8256 /* Extract the PLUS expression nested inside and fall into
8258 rtl
= XEXP (rtl
, 1);
8263 /* Turn these into a PLUS expression and fall into the PLUS code
8265 rtl
= gen_rtx_PLUS (word_mode
, XEXP (rtl
, 0),
8266 GEN_INT (GET_CODE (rtl
) == PRE_INC
8267 ? GET_MODE_UNIT_SIZE (mode
)
8268 : -GET_MODE_UNIT_SIZE (mode
)));
8270 /* ... fall through ... */
8274 if (is_based_loc (rtl
))
8275 mem_loc_result
= based_loc_descr (reg_number (XEXP (rtl
, 0)),
8276 INTVAL (XEXP (rtl
, 1)));
8279 mem_loc_result
= mem_loc_descriptor (XEXP (rtl
, 0), mode
);
8280 if (mem_loc_result
== 0)
8283 if (GET_CODE (XEXP (rtl
, 1)) == CONST_INT
8284 && INTVAL (XEXP (rtl
, 1)) >= 0)
8285 add_loc_descr (&mem_loc_result
,
8286 new_loc_descr (DW_OP_plus_uconst
,
8287 INTVAL (XEXP (rtl
, 1)), 0));
8290 add_loc_descr (&mem_loc_result
,
8291 mem_loc_descriptor (XEXP (rtl
, 1), mode
));
8292 add_loc_descr (&mem_loc_result
,
8293 new_loc_descr (DW_OP_plus
, 0, 0));
8300 /* If a pseudo-reg is optimized away, it is possible for it to
8301 be replaced with a MEM containing a multiply. */
8302 dw_loc_descr_ref op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
);
8303 dw_loc_descr_ref op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
);
8305 if (op0
== 0 || op1
== 0)
8308 mem_loc_result
= op0
;
8309 add_loc_descr (&mem_loc_result
, op1
);
8310 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_mul
, 0, 0));
8315 mem_loc_result
= int_loc_descriptor (INTVAL (rtl
));
8319 /* If this is a MEM, return its address. Otherwise, we can't
8321 if (GET_CODE (XEXP (rtl
, 0)) == MEM
)
8322 return mem_loc_descriptor (XEXP (XEXP (rtl
, 0), 0), mode
);
8330 return mem_loc_result
;
8333 /* Return a descriptor that describes the concatenation of two locations.
8334 This is typically a complex variable. */
8336 static dw_loc_descr_ref
8337 concat_loc_descriptor (rtx x0
, rtx x1
)
8339 dw_loc_descr_ref cc_loc_result
= NULL
;
8340 dw_loc_descr_ref x0_ref
= loc_descriptor (x0
);
8341 dw_loc_descr_ref x1_ref
= loc_descriptor (x1
);
8343 if (x0_ref
== 0 || x1_ref
== 0)
8346 cc_loc_result
= x0_ref
;
8347 add_loc_descr (&cc_loc_result
,
8348 new_loc_descr (DW_OP_piece
,
8349 GET_MODE_SIZE (GET_MODE (x0
)), 0));
8351 add_loc_descr (&cc_loc_result
, x1_ref
);
8352 add_loc_descr (&cc_loc_result
,
8353 new_loc_descr (DW_OP_piece
,
8354 GET_MODE_SIZE (GET_MODE (x1
)), 0));
8356 return cc_loc_result
;
8359 /* Output a proper Dwarf location descriptor for a variable or parameter
8360 which is either allocated in a register or in a memory location. For a
8361 register, we just generate an OP_REG and the register number. For a
8362 memory location we provide a Dwarf postfix expression describing how to
8363 generate the (dynamic) address of the object onto the address stack.
8365 If we don't know how to describe it, return 0. */
8367 static dw_loc_descr_ref
8368 loc_descriptor (rtx rtl
)
8370 dw_loc_descr_ref loc_result
= NULL
;
8372 switch (GET_CODE (rtl
))
8375 /* The case of a subreg may arise when we have a local (register)
8376 variable or a formal (register) parameter which doesn't quite fill
8377 up an entire register. For now, just assume that it is
8378 legitimate to make the Dwarf info refer to the whole register which
8379 contains the given subreg. */
8380 rtl
= SUBREG_REG (rtl
);
8382 /* ... fall through ... */
8385 loc_result
= reg_loc_descriptor (rtl
);
8389 loc_result
= mem_loc_descriptor (XEXP (rtl
, 0), GET_MODE (rtl
));
8393 loc_result
= concat_loc_descriptor (XEXP (rtl
, 0), XEXP (rtl
, 1));
8403 /* Similar, but generate the descriptor from trees instead of rtl. This comes
8404 up particularly with variable length arrays. If ADDRESSP is nonzero, we are
8405 looking for an address. Otherwise, we return a value. If we can't make a
8406 descriptor, return 0. */
8408 static dw_loc_descr_ref
8409 loc_descriptor_from_tree (tree loc
, int addressp
)
8411 dw_loc_descr_ref ret
, ret1
;
8413 int unsignedp
= TREE_UNSIGNED (TREE_TYPE (loc
));
8414 enum dwarf_location_atom op
;
8416 /* ??? Most of the time we do not take proper care for sign/zero
8417 extending the values properly. Hopefully this won't be a real
8420 switch (TREE_CODE (loc
))
8425 case WITH_RECORD_EXPR
:
8426 case PLACEHOLDER_EXPR
:
8427 /* This case involves extracting fields from an object to determine the
8428 position of other fields. We don't try to encode this here. The
8429 only user of this is Ada, which encodes the needed information using
8430 the names of types. */
8437 /* We can support this only if we can look through conversions and
8438 find an INDIRECT_EXPR. */
8439 for (loc
= TREE_OPERAND (loc
, 0);
8440 TREE_CODE (loc
) == CONVERT_EXPR
|| TREE_CODE (loc
) == NOP_EXPR
8441 || TREE_CODE (loc
) == NON_LVALUE_EXPR
8442 || TREE_CODE (loc
) == VIEW_CONVERT_EXPR
8443 || TREE_CODE (loc
) == SAVE_EXPR
;
8444 loc
= TREE_OPERAND (loc
, 0))
8447 return (TREE_CODE (loc
) == INDIRECT_REF
8448 ? loc_descriptor_from_tree (TREE_OPERAND (loc
, 0), addressp
)
8452 if (DECL_THREAD_LOCAL (loc
))
8456 #ifndef ASM_OUTPUT_DWARF_DTPREL
8457 /* If this is not defined, we have no way to emit the data. */
8461 /* The way DW_OP_GNU_push_tls_address is specified, we can only
8462 look up addresses of objects in the current module. */
8463 if (DECL_EXTERNAL (loc
))
8466 rtl
= rtl_for_decl_location (loc
);
8467 if (rtl
== NULL_RTX
)
8470 if (GET_CODE (rtl
) != MEM
)
8472 rtl
= XEXP (rtl
, 0);
8473 if (! CONSTANT_P (rtl
))
8476 ret
= new_loc_descr (INTERNAL_DW_OP_tls_addr
, 0, 0);
8477 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_addr
;
8478 ret
->dw_loc_oprnd1
.v
.val_addr
= rtl
;
8480 ret1
= new_loc_descr (DW_OP_GNU_push_tls_address
, 0, 0);
8481 add_loc_descr (&ret
, ret1
);
8490 rtx rtl
= rtl_for_decl_location (loc
);
8492 if (rtl
== NULL_RTX
)
8494 else if (CONSTANT_P (rtl
))
8496 ret
= new_loc_descr (DW_OP_addr
, 0, 0);
8497 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_addr
;
8498 ret
->dw_loc_oprnd1
.v
.val_addr
= rtl
;
8503 enum machine_mode mode
= GET_MODE (rtl
);
8505 if (GET_CODE (rtl
) == MEM
)
8508 rtl
= XEXP (rtl
, 0);
8511 ret
= mem_loc_descriptor (rtl
, mode
);
8517 ret
= loc_descriptor_from_tree (TREE_OPERAND (loc
, 0), 0);
8522 return loc_descriptor_from_tree (TREE_OPERAND (loc
, 1), addressp
);
8526 case NON_LVALUE_EXPR
:
8527 case VIEW_CONVERT_EXPR
:
8530 return loc_descriptor_from_tree (TREE_OPERAND (loc
, 0), addressp
);
8535 case ARRAY_RANGE_REF
:
8538 HOST_WIDE_INT bitsize
, bitpos
, bytepos
;
8539 enum machine_mode mode
;
8542 obj
= get_inner_reference (loc
, &bitsize
, &bitpos
, &offset
, &mode
,
8543 &unsignedp
, &volatilep
);
8548 ret
= loc_descriptor_from_tree (obj
, 1);
8550 || bitpos
% BITS_PER_UNIT
!= 0 || bitsize
% BITS_PER_UNIT
!= 0)
8553 if (offset
!= NULL_TREE
)
8555 /* Variable offset. */
8556 add_loc_descr (&ret
, loc_descriptor_from_tree (offset
, 0));
8557 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus
, 0, 0));
8563 bytepos
= bitpos
/ BITS_PER_UNIT
;
8565 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus_uconst
, bytepos
, 0));
8566 else if (bytepos
< 0)
8568 add_loc_descr (&ret
, int_loc_descriptor (bytepos
));
8569 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus
, 0, 0));
8575 if (host_integerp (loc
, 0))
8576 ret
= int_loc_descriptor (tree_low_cst (loc
, 0));
8583 /* Get an RTL for this, if something has been emitted. */
8584 rtx rtl
= lookup_constant_def (loc
);
8585 enum machine_mode mode
;
8587 if (GET_CODE (rtl
) != MEM
)
8589 mode
= GET_MODE (rtl
);
8590 rtl
= XEXP (rtl
, 0);
8592 rtl
= (*targetm
.delegitimize_address
) (rtl
);
8595 ret
= mem_loc_descriptor (rtl
, mode
);
8599 case TRUTH_AND_EXPR
:
8600 case TRUTH_ANDIF_EXPR
:
8605 case TRUTH_XOR_EXPR
:
8611 case TRUTH_ORIF_EXPR
:
8616 case FLOOR_DIV_EXPR
:
8618 case ROUND_DIV_EXPR
:
8619 case TRUNC_DIV_EXPR
:
8627 case FLOOR_MOD_EXPR
:
8629 case ROUND_MOD_EXPR
:
8630 case TRUNC_MOD_EXPR
:
8643 op
= (unsignedp
? DW_OP_shr
: DW_OP_shra
);
8647 if (TREE_CODE (TREE_OPERAND (loc
, 1)) == INTEGER_CST
8648 && host_integerp (TREE_OPERAND (loc
, 1), 0))
8650 ret
= loc_descriptor_from_tree (TREE_OPERAND (loc
, 0), 0);
8654 add_loc_descr (&ret
,
8655 new_loc_descr (DW_OP_plus_uconst
,
8656 tree_low_cst (TREE_OPERAND (loc
, 1),
8666 if (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc
, 0))))
8673 if (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc
, 0))))
8680 if (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc
, 0))))
8687 if (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc
, 0))))
8702 ret
= loc_descriptor_from_tree (TREE_OPERAND (loc
, 0), 0);
8703 ret1
= loc_descriptor_from_tree (TREE_OPERAND (loc
, 1), 0);
8704 if (ret
== 0 || ret1
== 0)
8707 add_loc_descr (&ret
, ret1
);
8708 add_loc_descr (&ret
, new_loc_descr (op
, 0, 0));
8711 case TRUTH_NOT_EXPR
:
8725 ret
= loc_descriptor_from_tree (TREE_OPERAND (loc
, 0), 0);
8729 add_loc_descr (&ret
, new_loc_descr (op
, 0, 0));
8733 loc
= build (COND_EXPR
, TREE_TYPE (loc
),
8734 build (LT_EXPR
, integer_type_node
,
8735 TREE_OPERAND (loc
, 0), TREE_OPERAND (loc
, 1)),
8736 TREE_OPERAND (loc
, 1), TREE_OPERAND (loc
, 0));
8738 /* ... fall through ... */
8742 dw_loc_descr_ref lhs
8743 = loc_descriptor_from_tree (TREE_OPERAND (loc
, 1), 0);
8744 dw_loc_descr_ref rhs
8745 = loc_descriptor_from_tree (TREE_OPERAND (loc
, 2), 0);
8746 dw_loc_descr_ref bra_node
, jump_node
, tmp
;
8748 ret
= loc_descriptor_from_tree (TREE_OPERAND (loc
, 0), 0);
8749 if (ret
== 0 || lhs
== 0 || rhs
== 0)
8752 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
8753 add_loc_descr (&ret
, bra_node
);
8755 add_loc_descr (&ret
, rhs
);
8756 jump_node
= new_loc_descr (DW_OP_skip
, 0, 0);
8757 add_loc_descr (&ret
, jump_node
);
8759 add_loc_descr (&ret
, lhs
);
8760 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
8761 bra_node
->dw_loc_oprnd1
.v
.val_loc
= lhs
;
8763 /* ??? Need a node to point the skip at. Use a nop. */
8764 tmp
= new_loc_descr (DW_OP_nop
, 0, 0);
8765 add_loc_descr (&ret
, tmp
);
8766 jump_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
8767 jump_node
->dw_loc_oprnd1
.v
.val_loc
= tmp
;
8772 /* Leave front-end specific codes as simply unknown. This comes
8773 up, for instance, with the C STMT_EXPR. */
8774 if ((unsigned int) TREE_CODE (loc
)
8775 >= (unsigned int) LAST_AND_UNUSED_TREE_CODE
)
8778 /* Otherwise this is a generic code; we should just lists all of
8779 these explicitly. Aborting means we forgot one. */
8783 /* Show if we can't fill the request for an address. */
8784 if (addressp
&& indirect_p
== 0)
8787 /* If we've got an address and don't want one, dereference. */
8788 if (!addressp
&& indirect_p
> 0)
8790 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (loc
));
8792 if (size
> DWARF2_ADDR_SIZE
|| size
== -1)
8794 else if (size
== DWARF2_ADDR_SIZE
)
8797 op
= DW_OP_deref_size
;
8799 add_loc_descr (&ret
, new_loc_descr (op
, size
, 0));
8805 /* Given a value, round it up to the lowest multiple of `boundary'
8806 which is not less than the value itself. */
8808 static inline HOST_WIDE_INT
8809 ceiling (HOST_WIDE_INT value
, unsigned int boundary
)
8811 return (((value
+ boundary
- 1) / boundary
) * boundary
);
8814 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
8815 pointer to the declared type for the relevant field variable, or return
8816 `integer_type_node' if the given node turns out to be an
8820 field_type (tree decl
)
8824 if (TREE_CODE (decl
) == ERROR_MARK
)
8825 return integer_type_node
;
8827 type
= DECL_BIT_FIELD_TYPE (decl
);
8828 if (type
== NULL_TREE
)
8829 type
= TREE_TYPE (decl
);
8834 /* Given a pointer to a tree node, return the alignment in bits for
8835 it, or else return BITS_PER_WORD if the node actually turns out to
8836 be an ERROR_MARK node. */
8838 static inline unsigned
8839 simple_type_align_in_bits (tree type
)
8841 return (TREE_CODE (type
) != ERROR_MARK
) ? TYPE_ALIGN (type
) : BITS_PER_WORD
;
8844 static inline unsigned
8845 simple_decl_align_in_bits (tree decl
)
8847 return (TREE_CODE (decl
) != ERROR_MARK
) ? DECL_ALIGN (decl
) : BITS_PER_WORD
;
8850 /* Given a pointer to a FIELD_DECL, compute and return the byte offset of the
8851 lowest addressed byte of the "containing object" for the given FIELD_DECL,
8852 or return 0 if we are unable to determine what that offset is, either
8853 because the argument turns out to be a pointer to an ERROR_MARK node, or
8854 because the offset is actually variable. (We can't handle the latter case
8857 static HOST_WIDE_INT
8858 field_byte_offset (tree decl
)
8860 unsigned int type_align_in_bits
;
8861 unsigned int decl_align_in_bits
;
8862 unsigned HOST_WIDE_INT type_size_in_bits
;
8863 HOST_WIDE_INT object_offset_in_bits
;
8865 tree field_size_tree
;
8866 HOST_WIDE_INT bitpos_int
;
8867 HOST_WIDE_INT deepest_bitpos
;
8868 unsigned HOST_WIDE_INT field_size_in_bits
;
8870 if (TREE_CODE (decl
) == ERROR_MARK
)
8872 else if (TREE_CODE (decl
) != FIELD_DECL
)
8875 type
= field_type (decl
);
8876 field_size_tree
= DECL_SIZE (decl
);
8878 /* The size could be unspecified if there was an error, or for
8879 a flexible array member. */
8880 if (! field_size_tree
)
8881 field_size_tree
= bitsize_zero_node
;
8883 /* We cannot yet cope with fields whose positions are variable, so
8884 for now, when we see such things, we simply return 0. Someday, we may
8885 be able to handle such cases, but it will be damn difficult. */
8886 if (! host_integerp (bit_position (decl
), 0))
8889 bitpos_int
= int_bit_position (decl
);
8891 /* If we don't know the size of the field, pretend it's a full word. */
8892 if (host_integerp (field_size_tree
, 1))
8893 field_size_in_bits
= tree_low_cst (field_size_tree
, 1);
8895 field_size_in_bits
= BITS_PER_WORD
;
8897 type_size_in_bits
= simple_type_size_in_bits (type
);
8898 type_align_in_bits
= simple_type_align_in_bits (type
);
8899 decl_align_in_bits
= simple_decl_align_in_bits (decl
);
8901 /* The GCC front-end doesn't make any attempt to keep track of the starting
8902 bit offset (relative to the start of the containing structure type) of the
8903 hypothetical "containing object" for a bit-field. Thus, when computing
8904 the byte offset value for the start of the "containing object" of a
8905 bit-field, we must deduce this information on our own. This can be rather
8906 tricky to do in some cases. For example, handling the following structure
8907 type definition when compiling for an i386/i486 target (which only aligns
8908 long long's to 32-bit boundaries) can be very tricky:
8910 struct S { int field1; long long field2:31; };
8912 Fortunately, there is a simple rule-of-thumb which can be used in such
8913 cases. When compiling for an i386/i486, GCC will allocate 8 bytes for the
8914 structure shown above. It decides to do this based upon one simple rule
8915 for bit-field allocation. GCC allocates each "containing object" for each
8916 bit-field at the first (i.e. lowest addressed) legitimate alignment
8917 boundary (based upon the required minimum alignment for the declared type
8918 of the field) which it can possibly use, subject to the condition that
8919 there is still enough available space remaining in the containing object
8920 (when allocated at the selected point) to fully accommodate all of the
8921 bits of the bit-field itself.
8923 This simple rule makes it obvious why GCC allocates 8 bytes for each
8924 object of the structure type shown above. When looking for a place to
8925 allocate the "containing object" for `field2', the compiler simply tries
8926 to allocate a 64-bit "containing object" at each successive 32-bit
8927 boundary (starting at zero) until it finds a place to allocate that 64-
8928 bit field such that at least 31 contiguous (and previously unallocated)
8929 bits remain within that selected 64 bit field. (As it turns out, for the
8930 example above, the compiler finds it is OK to allocate the "containing
8931 object" 64-bit field at bit-offset zero within the structure type.)
8933 Here we attempt to work backwards from the limited set of facts we're
8934 given, and we try to deduce from those facts, where GCC must have believed
8935 that the containing object started (within the structure type). The value
8936 we deduce is then used (by the callers of this routine) to generate
8937 DW_AT_location and DW_AT_bit_offset attributes for fields (both bit-fields
8938 and, in the case of DW_AT_location, regular fields as well). */
8940 /* Figure out the bit-distance from the start of the structure to the
8941 "deepest" bit of the bit-field. */
8942 deepest_bitpos
= bitpos_int
+ field_size_in_bits
;
8944 /* This is the tricky part. Use some fancy footwork to deduce where the
8945 lowest addressed bit of the containing object must be. */
8946 object_offset_in_bits
= deepest_bitpos
- type_size_in_bits
;
8948 /* Round up to type_align by default. This works best for bitfields. */
8949 object_offset_in_bits
+= type_align_in_bits
- 1;
8950 object_offset_in_bits
/= type_align_in_bits
;
8951 object_offset_in_bits
*= type_align_in_bits
;
8953 if (object_offset_in_bits
> bitpos_int
)
8955 /* Sigh, the decl must be packed. */
8956 object_offset_in_bits
= deepest_bitpos
- type_size_in_bits
;
8958 /* Round up to decl_align instead. */
8959 object_offset_in_bits
+= decl_align_in_bits
- 1;
8960 object_offset_in_bits
/= decl_align_in_bits
;
8961 object_offset_in_bits
*= decl_align_in_bits
;
8964 return object_offset_in_bits
/ BITS_PER_UNIT
;
8967 /* The following routines define various Dwarf attributes and any data
8968 associated with them. */
8970 /* Add a location description attribute value to a DIE.
8972 This emits location attributes suitable for whole variables and
8973 whole parameters. Note that the location attributes for struct fields are
8974 generated by the routine `data_member_location_attribute' below. */
8977 add_AT_location_description (dw_die_ref die
, enum dwarf_attribute attr_kind
,
8978 dw_loc_descr_ref descr
)
8981 add_AT_loc (die
, attr_kind
, descr
);
8984 /* Attach the specialized form of location attribute used for data members of
8985 struct and union types. In the special case of a FIELD_DECL node which
8986 represents a bit-field, the "offset" part of this special location
8987 descriptor must indicate the distance in bytes from the lowest-addressed
8988 byte of the containing struct or union type to the lowest-addressed byte of
8989 the "containing object" for the bit-field. (See the `field_byte_offset'
8992 For any given bit-field, the "containing object" is a hypothetical object
8993 (of some integral or enum type) within which the given bit-field lives. The
8994 type of this hypothetical "containing object" is always the same as the
8995 declared type of the individual bit-field itself (for GCC anyway... the
8996 DWARF spec doesn't actually mandate this). Note that it is the size (in
8997 bytes) of the hypothetical "containing object" which will be given in the
8998 DW_AT_byte_size attribute for this bit-field. (See the
8999 `byte_size_attribute' function below.) It is also used when calculating the
9000 value of the DW_AT_bit_offset attribute. (See the `bit_offset_attribute'
9004 add_data_member_location_attribute (dw_die_ref die
, tree decl
)
9006 HOST_WIDE_INT offset
;
9007 dw_loc_descr_ref loc_descr
= 0;
9009 if (TREE_CODE (decl
) == TREE_VEC
)
9011 /* We're working on the TAG_inheritance for a base class. */
9012 if (TREE_VIA_VIRTUAL (decl
) && is_cxx ())
9014 /* For C++ virtual bases we can't just use BINFO_OFFSET, as they
9015 aren't at a fixed offset from all (sub)objects of the same
9016 type. We need to extract the appropriate offset from our
9017 vtable. The following dwarf expression means
9019 BaseAddr = ObAddr + *((*ObAddr) - Offset)
9021 This is specific to the V3 ABI, of course. */
9023 dw_loc_descr_ref tmp
;
9025 /* Make a copy of the object address. */
9026 tmp
= new_loc_descr (DW_OP_dup
, 0, 0);
9027 add_loc_descr (&loc_descr
, tmp
);
9029 /* Extract the vtable address. */
9030 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
9031 add_loc_descr (&loc_descr
, tmp
);
9033 /* Calculate the address of the offset. */
9034 offset
= tree_low_cst (BINFO_VPTR_FIELD (decl
), 0);
9038 tmp
= int_loc_descriptor (-offset
);
9039 add_loc_descr (&loc_descr
, tmp
);
9040 tmp
= new_loc_descr (DW_OP_minus
, 0, 0);
9041 add_loc_descr (&loc_descr
, tmp
);
9043 /* Extract the offset. */
9044 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
9045 add_loc_descr (&loc_descr
, tmp
);
9047 /* Add it to the object address. */
9048 tmp
= new_loc_descr (DW_OP_plus
, 0, 0);
9049 add_loc_descr (&loc_descr
, tmp
);
9052 offset
= tree_low_cst (BINFO_OFFSET (decl
), 0);
9055 offset
= field_byte_offset (decl
);
9059 enum dwarf_location_atom op
;
9061 /* The DWARF2 standard says that we should assume that the structure
9062 address is already on the stack, so we can specify a structure field
9063 address by using DW_OP_plus_uconst. */
9065 #ifdef MIPS_DEBUGGING_INFO
9066 /* ??? The SGI dwarf reader does not handle the DW_OP_plus_uconst
9067 operator correctly. It works only if we leave the offset on the
9071 op
= DW_OP_plus_uconst
;
9074 loc_descr
= new_loc_descr (op
, offset
, 0);
9077 add_AT_loc (die
, DW_AT_data_member_location
, loc_descr
);
9080 /* Attach a DW_AT_const_value attribute for a variable or a parameter which
9081 does not have a "location" either in memory or in a register. These
9082 things can arise in GNU C when a constant is passed as an actual parameter
9083 to an inlined function. They can also arise in C++ where declared
9084 constants do not necessarily get memory "homes". */
9087 add_const_value_attribute (dw_die_ref die
, rtx rtl
)
9089 switch (GET_CODE (rtl
))
9092 /* Note that a CONST_INT rtx could represent either an integer
9093 or a floating-point constant. A CONST_INT is used whenever
9094 the constant will fit into a single word. In all such
9095 cases, the original mode of the constant value is wiped
9096 out, and the CONST_INT rtx is assigned VOIDmode. */
9098 HOST_WIDE_INT val
= INTVAL (rtl
);
9101 add_AT_int (die
, DW_AT_const_value
, val
);
9103 add_AT_unsigned (die
, DW_AT_const_value
, (unsigned HOST_WIDE_INT
) val
);
9108 /* Note that a CONST_DOUBLE rtx could represent either an integer or a
9109 floating-point constant. A CONST_DOUBLE is used whenever the
9110 constant requires more than one word in order to be adequately
9111 represented. We output CONST_DOUBLEs as blocks. */
9113 enum machine_mode mode
= GET_MODE (rtl
);
9115 if (GET_MODE_CLASS (mode
) == MODE_FLOAT
)
9117 unsigned length
= GET_MODE_SIZE (mode
) / 4;
9118 long *array
= ggc_alloc (sizeof (long) * length
);
9121 REAL_VALUE_FROM_CONST_DOUBLE (rv
, rtl
);
9122 real_to_target (array
, &rv
, mode
);
9124 add_AT_float (die
, DW_AT_const_value
, length
, array
);
9128 /* ??? We really should be using HOST_WIDE_INT throughout. */
9129 if (HOST_BITS_PER_LONG
!= HOST_BITS_PER_WIDE_INT
)
9132 add_AT_long_long (die
, DW_AT_const_value
,
9133 CONST_DOUBLE_HIGH (rtl
), CONST_DOUBLE_LOW (rtl
));
9139 add_AT_string (die
, DW_AT_const_value
, XSTR (rtl
, 0));
9145 add_AT_addr (die
, DW_AT_const_value
, rtl
);
9146 VARRAY_PUSH_RTX (used_rtx_varray
, rtl
);
9150 /* In cases where an inlined instance of an inline function is passed
9151 the address of an `auto' variable (which is local to the caller) we
9152 can get a situation where the DECL_RTL of the artificial local
9153 variable (for the inlining) which acts as a stand-in for the
9154 corresponding formal parameter (of the inline function) will look
9155 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not
9156 exactly a compile-time constant expression, but it isn't the address
9157 of the (artificial) local variable either. Rather, it represents the
9158 *value* which the artificial local variable always has during its
9159 lifetime. We currently have no way to represent such quasi-constant
9160 values in Dwarf, so for now we just punt and generate nothing. */
9164 /* No other kinds of rtx should be possible here. */
9171 rtl_for_decl_location (tree decl
)
9175 /* Here we have to decide where we are going to say the parameter "lives"
9176 (as far as the debugger is concerned). We only have a couple of
9177 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
9179 DECL_RTL normally indicates where the parameter lives during most of the
9180 activation of the function. If optimization is enabled however, this
9181 could be either NULL or else a pseudo-reg. Both of those cases indicate
9182 that the parameter doesn't really live anywhere (as far as the code
9183 generation parts of GCC are concerned) during most of the function's
9184 activation. That will happen (for example) if the parameter is never
9185 referenced within the function.
9187 We could just generate a location descriptor here for all non-NULL
9188 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
9189 a little nicer than that if we also consider DECL_INCOMING_RTL in cases
9190 where DECL_RTL is NULL or is a pseudo-reg.
9192 Note however that we can only get away with using DECL_INCOMING_RTL as
9193 a backup substitute for DECL_RTL in certain limited cases. In cases
9194 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
9195 we can be sure that the parameter was passed using the same type as it is
9196 declared to have within the function, and that its DECL_INCOMING_RTL
9197 points us to a place where a value of that type is passed.
9199 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
9200 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
9201 because in these cases DECL_INCOMING_RTL points us to a value of some
9202 type which is *different* from the type of the parameter itself. Thus,
9203 if we tried to use DECL_INCOMING_RTL to generate a location attribute in
9204 such cases, the debugger would end up (for example) trying to fetch a
9205 `float' from a place which actually contains the first part of a
9206 `double'. That would lead to really incorrect and confusing
9207 output at debug-time.
9209 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
9210 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There
9211 are a couple of exceptions however. On little-endian machines we can
9212 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
9213 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
9214 an integral type that is smaller than TREE_TYPE (decl). These cases arise
9215 when (on a little-endian machine) a non-prototyped function has a
9216 parameter declared to be of type `short' or `char'. In such cases,
9217 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
9218 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
9219 passed `int' value. If the debugger then uses that address to fetch
9220 a `short' or a `char' (on a little-endian machine) the result will be
9221 the correct data, so we allow for such exceptional cases below.
9223 Note that our goal here is to describe the place where the given formal
9224 parameter lives during most of the function's activation (i.e. between the
9225 end of the prologue and the start of the epilogue). We'll do that as best
9226 as we can. Note however that if the given formal parameter is modified
9227 sometime during the execution of the function, then a stack backtrace (at
9228 debug-time) will show the function as having been called with the *new*
9229 value rather than the value which was originally passed in. This happens
9230 rarely enough that it is not a major problem, but it *is* a problem, and
9233 A future version of dwarf2out.c may generate two additional attributes for
9234 any given DW_TAG_formal_parameter DIE which will describe the "passed
9235 type" and the "passed location" for the given formal parameter in addition
9236 to the attributes we now generate to indicate the "declared type" and the
9237 "active location" for each parameter. This additional set of attributes
9238 could be used by debuggers for stack backtraces. Separately, note that
9239 sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also.
9240 This happens (for example) for inlined-instances of inline function formal
9241 parameters which are never referenced. This really shouldn't be
9242 happening. All PARM_DECL nodes should get valid non-NULL
9243 DECL_INCOMING_RTL values, but integrate.c doesn't currently generate these
9244 values for inlined instances of inline function parameters, so when we see
9245 such cases, we are just out-of-luck for the time being (until integrate.c
9248 /* Use DECL_RTL as the "location" unless we find something better. */
9249 rtl
= DECL_RTL_IF_SET (decl
);
9251 /* When generating abstract instances, ignore everything except
9252 constants, symbols living in memory, and symbols living in
9254 if (! reload_completed
)
9257 && (CONSTANT_P (rtl
)
9258 || (GET_CODE (rtl
) == MEM
9259 && CONSTANT_P (XEXP (rtl
, 0)))
9260 || (GET_CODE (rtl
) == REG
9261 && TREE_CODE (decl
) == VAR_DECL
9262 && TREE_STATIC (decl
))))
9264 rtl
= (*targetm
.delegitimize_address
) (rtl
);
9269 else if (TREE_CODE (decl
) == PARM_DECL
)
9271 if (rtl
== NULL_RTX
|| is_pseudo_reg (rtl
))
9273 tree declared_type
= type_main_variant (TREE_TYPE (decl
));
9274 tree passed_type
= type_main_variant (DECL_ARG_TYPE (decl
));
9276 /* This decl represents a formal parameter which was optimized out.
9277 Note that DECL_INCOMING_RTL may be NULL in here, but we handle
9278 all cases where (rtl == NULL_RTX) just below. */
9279 if (declared_type
== passed_type
)
9280 rtl
= DECL_INCOMING_RTL (decl
);
9281 else if (! BYTES_BIG_ENDIAN
9282 && TREE_CODE (declared_type
) == INTEGER_TYPE
9283 && (GET_MODE_SIZE (TYPE_MODE (declared_type
))
9284 <= GET_MODE_SIZE (TYPE_MODE (passed_type
))))
9285 rtl
= DECL_INCOMING_RTL (decl
);
9288 /* If the parm was passed in registers, but lives on the stack, then
9289 make a big endian correction if the mode of the type of the
9290 parameter is not the same as the mode of the rtl. */
9291 /* ??? This is the same series of checks that are made in dbxout.c before
9292 we reach the big endian correction code there. It isn't clear if all
9293 of these checks are necessary here, but keeping them all is the safe
9295 else if (GET_CODE (rtl
) == MEM
9296 && XEXP (rtl
, 0) != const0_rtx
9297 && ! CONSTANT_P (XEXP (rtl
, 0))
9298 /* Not passed in memory. */
9299 && GET_CODE (DECL_INCOMING_RTL (decl
)) != MEM
9300 /* Not passed by invisible reference. */
9301 && (GET_CODE (XEXP (rtl
, 0)) != REG
9302 || REGNO (XEXP (rtl
, 0)) == HARD_FRAME_POINTER_REGNUM
9303 || REGNO (XEXP (rtl
, 0)) == STACK_POINTER_REGNUM
9304 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
9305 || REGNO (XEXP (rtl
, 0)) == ARG_POINTER_REGNUM
9308 /* Big endian correction check. */
9310 && TYPE_MODE (TREE_TYPE (decl
)) != GET_MODE (rtl
)
9311 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl
)))
9314 int offset
= (UNITS_PER_WORD
9315 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl
))));
9317 rtl
= gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl
)),
9318 plus_constant (XEXP (rtl
, 0), offset
));
9322 if (rtl
!= NULL_RTX
)
9324 rtl
= eliminate_regs (rtl
, 0, NULL_RTX
);
9325 #ifdef LEAF_REG_REMAP
9326 if (current_function_uses_only_leaf_regs
)
9327 leaf_renumber_regs_insn (rtl
);
9331 /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant,
9332 and will have been substituted directly into all expressions that use it.
9333 C does not have such a concept, but C++ and other languages do. */
9334 else if (TREE_CODE (decl
) == VAR_DECL
&& DECL_INITIAL (decl
))
9336 /* If a variable is initialized with a string constant without embedded
9337 zeros, build CONST_STRING. */
9338 if (TREE_CODE (DECL_INITIAL (decl
)) == STRING_CST
9339 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
9341 tree arrtype
= TREE_TYPE (decl
);
9342 tree enttype
= TREE_TYPE (arrtype
);
9343 tree domain
= TYPE_DOMAIN (arrtype
);
9344 tree init
= DECL_INITIAL (decl
);
9345 enum machine_mode mode
= TYPE_MODE (enttype
);
9347 if (GET_MODE_CLASS (mode
) == MODE_INT
&& GET_MODE_SIZE (mode
) == 1
9349 && integer_zerop (TYPE_MIN_VALUE (domain
))
9350 && compare_tree_int (TYPE_MAX_VALUE (domain
),
9351 TREE_STRING_LENGTH (init
) - 1) == 0
9352 && ((size_t) TREE_STRING_LENGTH (init
)
9353 == strlen (TREE_STRING_POINTER (init
)) + 1))
9354 rtl
= gen_rtx_CONST_STRING (VOIDmode
, TREE_STRING_POINTER (init
));
9356 /* If the initializer is something that we know will expand into an
9357 immediate RTL constant, expand it now. Expanding anything else
9358 tends to produce unresolved symbols; see debug/5770 and c++/6381. */
9359 else if (TREE_CODE (DECL_INITIAL (decl
)) == INTEGER_CST
9360 || TREE_CODE (DECL_INITIAL (decl
)) == REAL_CST
)
9362 rtl
= expand_expr (DECL_INITIAL (decl
), NULL_RTX
, VOIDmode
,
9363 EXPAND_INITIALIZER
);
9364 /* If expand_expr returns a MEM, it wasn't immediate. */
9365 if (rtl
&& GET_CODE (rtl
) == MEM
)
9371 rtl
= (*targetm
.delegitimize_address
) (rtl
);
9373 /* If we don't look past the constant pool, we risk emitting a
9374 reference to a constant pool entry that isn't referenced from
9375 code, and thus is not emitted. */
9377 rtl
= avoid_constant_pool_reference (rtl
);
9382 /* Generate *either* a DW_AT_location attribute or else a DW_AT_const_value
9383 data attribute for a variable or a parameter. We generate the
9384 DW_AT_const_value attribute only in those cases where the given variable
9385 or parameter does not have a true "location" either in memory or in a
9386 register. This can happen (for example) when a constant is passed as an
9387 actual argument in a call to an inline function. (It's possible that
9388 these things can crop up in other ways also.) Note that one type of
9389 constant value which can be passed into an inlined function is a constant
9390 pointer. This can happen for example if an actual argument in an inlined
9391 function call evaluates to a compile-time constant address. */
9394 add_location_or_const_value_attribute (dw_die_ref die
, tree decl
)
9397 dw_loc_descr_ref descr
;
9399 if (TREE_CODE (decl
) == ERROR_MARK
)
9401 else if (TREE_CODE (decl
) != VAR_DECL
&& TREE_CODE (decl
) != PARM_DECL
)
9404 rtl
= rtl_for_decl_location (decl
);
9405 if (rtl
== NULL_RTX
)
9408 switch (GET_CODE (rtl
))
9411 /* The address of a variable that was optimized away;
9412 don't emit anything. */
9422 /* DECL_RTL could be (plus (reg ...) (const_int ...)) */
9423 add_const_value_attribute (die
, rtl
);
9427 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_THREAD_LOCAL (decl
))
9429 /* Need loc_descriptor_from_tree since that's where we know
9430 how to handle TLS variables. Want the object's address
9431 since the top-level DW_AT_location assumes such. See
9432 the confusion in loc_descriptor for reference. */
9433 descr
= loc_descriptor_from_tree (decl
, 1);
9440 descr
= loc_descriptor (rtl
);
9442 add_AT_location_description (die
, DW_AT_location
, descr
);
9450 /* If we don't have a copy of this variable in memory for some reason (such
9451 as a C++ member constant that doesn't have an out-of-line definition),
9452 we should tell the debugger about the constant value. */
9455 tree_add_const_value_attribute (dw_die_ref var_die
, tree decl
)
9457 tree init
= DECL_INITIAL (decl
);
9458 tree type
= TREE_TYPE (decl
);
9460 if (TREE_READONLY (decl
) && ! TREE_THIS_VOLATILE (decl
) && init
9461 && initializer_constant_valid_p (init
, type
) == null_pointer_node
)
9466 switch (TREE_CODE (type
))
9469 if (host_integerp (init
, 0))
9470 add_AT_unsigned (var_die
, DW_AT_const_value
,
9471 tree_low_cst (init
, 0));
9473 add_AT_long_long (var_die
, DW_AT_const_value
,
9474 TREE_INT_CST_HIGH (init
),
9475 TREE_INT_CST_LOW (init
));
9482 /* Generate a DW_AT_name attribute given some string value to be included as
9483 the value of the attribute. */
9486 add_name_attribute (dw_die_ref die
, const char *name_string
)
9488 if (name_string
!= NULL
&& *name_string
!= 0)
9490 if (demangle_name_func
)
9491 name_string
= (*demangle_name_func
) (name_string
);
9493 add_AT_string (die
, DW_AT_name
, name_string
);
9497 /* Generate a DW_AT_comp_dir attribute for DIE. */
9500 add_comp_dir_attribute (dw_die_ref die
)
9502 const char *wd
= get_src_pwd ();
9504 add_AT_string (die
, DW_AT_comp_dir
, wd
);
9507 /* Given a tree node describing an array bound (either lower or upper) output
9508 a representation for that bound. */
9511 add_bound_info (dw_die_ref subrange_die
, enum dwarf_attribute bound_attr
, tree bound
)
9513 switch (TREE_CODE (bound
))
9518 /* All fixed-bounds are represented by INTEGER_CST nodes. */
9520 if (! host_integerp (bound
, 0)
9521 || (bound_attr
== DW_AT_lower_bound
9522 && (((is_c_family () || is_java ()) && integer_zerop (bound
))
9523 || (is_fortran () && integer_onep (bound
)))))
9524 /* use the default */
9527 add_AT_unsigned (subrange_die
, bound_attr
, tree_low_cst (bound
, 0));
9532 case NON_LVALUE_EXPR
:
9533 case VIEW_CONVERT_EXPR
:
9534 add_bound_info (subrange_die
, bound_attr
, TREE_OPERAND (bound
, 0));
9538 /* If optimization is turned on, the SAVE_EXPRs that describe how to
9539 access the upper bound values may be bogus. If they refer to a
9540 register, they may only describe how to get at these values at the
9541 points in the generated code right after they have just been
9542 computed. Worse yet, in the typical case, the upper bound values
9543 will not even *be* computed in the optimized code (though the
9544 number of elements will), so these SAVE_EXPRs are entirely
9545 bogus. In order to compensate for this fact, we check here to see
9546 if optimization is enabled, and if so, we don't add an attribute
9547 for the (unknown and unknowable) upper bound. This should not
9548 cause too much trouble for existing (stupid?) debuggers because
9549 they have to deal with empty upper bounds location descriptions
9550 anyway in order to be able to deal with incomplete array types.
9551 Of course an intelligent debugger (GDB?) should be able to
9552 comprehend that a missing upper bound specification in an array
9553 type used for a storage class `auto' local array variable
9554 indicates that the upper bound is both unknown (at compile- time)
9555 and unknowable (at run-time) due to optimization.
9557 We assume that a MEM rtx is safe because gcc wouldn't put the
9558 value there unless it was going to be used repeatedly in the
9559 function, i.e. for cleanups. */
9560 if (SAVE_EXPR_RTL (bound
)
9561 && (! optimize
|| GET_CODE (SAVE_EXPR_RTL (bound
)) == MEM
))
9563 dw_die_ref ctx
= lookup_decl_die (current_function_decl
);
9564 dw_die_ref decl_die
= new_die (DW_TAG_variable
, ctx
, bound
);
9565 rtx loc
= SAVE_EXPR_RTL (bound
);
9567 /* If the RTL for the SAVE_EXPR is memory, handle the case where
9568 it references an outer function's frame. */
9569 if (GET_CODE (loc
) == MEM
)
9571 rtx new_addr
= fix_lexical_addr (XEXP (loc
, 0), bound
);
9573 if (XEXP (loc
, 0) != new_addr
)
9574 loc
= gen_rtx_MEM (GET_MODE (loc
), new_addr
);
9577 add_AT_flag (decl_die
, DW_AT_artificial
, 1);
9578 add_type_attribute (decl_die
, TREE_TYPE (bound
), 1, 0, ctx
);
9579 add_AT_location_description (decl_die
, DW_AT_location
,
9580 loc_descriptor (loc
));
9581 add_AT_die_ref (subrange_die
, bound_attr
, decl_die
);
9584 /* Else leave out the attribute. */
9590 dw_die_ref decl_die
= lookup_decl_die (bound
);
9592 /* ??? Can this happen, or should the variable have been bound
9593 first? Probably it can, since I imagine that we try to create
9594 the types of parameters in the order in which they exist in
9595 the list, and won't have created a forward reference to a
9597 if (decl_die
!= NULL
)
9598 add_AT_die_ref (subrange_die
, bound_attr
, decl_die
);
9604 /* Otherwise try to create a stack operation procedure to
9605 evaluate the value of the array bound. */
9607 dw_die_ref ctx
, decl_die
;
9608 dw_loc_descr_ref loc
;
9610 loc
= loc_descriptor_from_tree (bound
, 0);
9614 if (current_function_decl
== 0)
9615 ctx
= comp_unit_die
;
9617 ctx
= lookup_decl_die (current_function_decl
);
9619 /* If we weren't able to find a context, it's most likely the case
9620 that we are processing the return type of the function. So
9621 make a SAVE_EXPR to point to it and have the limbo DIE code
9622 find the proper die. The save_expr function doesn't always
9623 make a SAVE_EXPR, so do it ourselves. */
9625 bound
= build (SAVE_EXPR
, TREE_TYPE (bound
), bound
,
9626 current_function_decl
, NULL_TREE
);
9628 decl_die
= new_die (DW_TAG_variable
, ctx
, bound
);
9629 add_AT_flag (decl_die
, DW_AT_artificial
, 1);
9630 add_type_attribute (decl_die
, TREE_TYPE (bound
), 1, 0, ctx
);
9631 add_AT_loc (decl_die
, DW_AT_location
, loc
);
9633 add_AT_die_ref (subrange_die
, bound_attr
, decl_die
);
9639 /* Note that the block of subscript information for an array type also
9640 includes information about the element type of type given array type. */
9643 add_subscript_info (dw_die_ref type_die
, tree type
)
9645 #ifndef MIPS_DEBUGGING_INFO
9646 unsigned dimension_number
;
9649 dw_die_ref subrange_die
;
9651 /* The GNU compilers represent multidimensional array types as sequences of
9652 one dimensional array types whose element types are themselves array
9653 types. Here we squish that down, so that each multidimensional array
9654 type gets only one array_type DIE in the Dwarf debugging info. The draft
9655 Dwarf specification say that we are allowed to do this kind of
9656 compression in C (because there is no difference between an array or
9657 arrays and a multidimensional array in C) but for other source languages
9658 (e.g. Ada) we probably shouldn't do this. */
9660 /* ??? The SGI dwarf reader fails for multidimensional arrays with a
9661 const enum type. E.g. const enum machine_mode insn_operand_mode[2][10].
9662 We work around this by disabling this feature. See also
9663 gen_array_type_die. */
9664 #ifndef MIPS_DEBUGGING_INFO
9665 for (dimension_number
= 0;
9666 TREE_CODE (type
) == ARRAY_TYPE
;
9667 type
= TREE_TYPE (type
), dimension_number
++)
9670 tree domain
= TYPE_DOMAIN (type
);
9672 /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
9673 and (in GNU C only) variable bounds. Handle all three forms
9675 subrange_die
= new_die (DW_TAG_subrange_type
, type_die
, NULL
);
9678 /* We have an array type with specified bounds. */
9679 lower
= TYPE_MIN_VALUE (domain
);
9680 upper
= TYPE_MAX_VALUE (domain
);
9682 /* Define the index type. */
9683 if (TREE_TYPE (domain
))
9685 /* ??? This is probably an Ada unnamed subrange type. Ignore the
9686 TREE_TYPE field. We can't emit debug info for this
9687 because it is an unnamed integral type. */
9688 if (TREE_CODE (domain
) == INTEGER_TYPE
9689 && TYPE_NAME (domain
) == NULL_TREE
9690 && TREE_CODE (TREE_TYPE (domain
)) == INTEGER_TYPE
9691 && TYPE_NAME (TREE_TYPE (domain
)) == NULL_TREE
)
9694 add_type_attribute (subrange_die
, TREE_TYPE (domain
), 0, 0,
9698 /* ??? If upper is NULL, the array has unspecified length,
9699 but it does have a lower bound. This happens with Fortran
9701 Since the debugger is definitely going to need to know N
9702 to produce useful results, go ahead and output the lower
9703 bound solo, and hope the debugger can cope. */
9705 add_bound_info (subrange_die
, DW_AT_lower_bound
, lower
);
9707 add_bound_info (subrange_die
, DW_AT_upper_bound
, upper
);
9710 /* Otherwise we have an array type with an unspecified length. The
9711 DWARF-2 spec does not say how to handle this; let's just leave out the
9717 add_byte_size_attribute (dw_die_ref die
, tree tree_node
)
9721 switch (TREE_CODE (tree_node
))
9729 case QUAL_UNION_TYPE
:
9730 size
= int_size_in_bytes (tree_node
);
9733 /* For a data member of a struct or union, the DW_AT_byte_size is
9734 generally given as the number of bytes normally allocated for an
9735 object of the *declared* type of the member itself. This is true
9736 even for bit-fields. */
9737 size
= simple_type_size_in_bits (field_type (tree_node
)) / BITS_PER_UNIT
;
9743 /* Note that `size' might be -1 when we get to this point. If it is, that
9744 indicates that the byte size of the entity in question is variable. We
9745 have no good way of expressing this fact in Dwarf at the present time,
9746 so just let the -1 pass on through. */
9747 add_AT_unsigned (die
, DW_AT_byte_size
, size
);
9750 /* For a FIELD_DECL node which represents a bit-field, output an attribute
9751 which specifies the distance in bits from the highest order bit of the
9752 "containing object" for the bit-field to the highest order bit of the
9755 For any given bit-field, the "containing object" is a hypothetical object
9756 (of some integral or enum type) within which the given bit-field lives. The
9757 type of this hypothetical "containing object" is always the same as the
9758 declared type of the individual bit-field itself. The determination of the
9759 exact location of the "containing object" for a bit-field is rather
9760 complicated. It's handled by the `field_byte_offset' function (above).
9762 Note that it is the size (in bytes) of the hypothetical "containing object"
9763 which will be given in the DW_AT_byte_size attribute for this bit-field.
9764 (See `byte_size_attribute' above). */
9767 add_bit_offset_attribute (dw_die_ref die
, tree decl
)
9769 HOST_WIDE_INT object_offset_in_bytes
= field_byte_offset (decl
);
9770 tree type
= DECL_BIT_FIELD_TYPE (decl
);
9771 HOST_WIDE_INT bitpos_int
;
9772 HOST_WIDE_INT highest_order_object_bit_offset
;
9773 HOST_WIDE_INT highest_order_field_bit_offset
;
9774 HOST_WIDE_INT
unsigned bit_offset
;
9776 /* Must be a field and a bit field. */
9778 || TREE_CODE (decl
) != FIELD_DECL
)
9781 /* We can't yet handle bit-fields whose offsets are variable, so if we
9782 encounter such things, just return without generating any attribute
9783 whatsoever. Likewise for variable or too large size. */
9784 if (! host_integerp (bit_position (decl
), 0)
9785 || ! host_integerp (DECL_SIZE (decl
), 1))
9788 bitpos_int
= int_bit_position (decl
);
9790 /* Note that the bit offset is always the distance (in bits) from the
9791 highest-order bit of the "containing object" to the highest-order bit of
9792 the bit-field itself. Since the "high-order end" of any object or field
9793 is different on big-endian and little-endian machines, the computation
9794 below must take account of these differences. */
9795 highest_order_object_bit_offset
= object_offset_in_bytes
* BITS_PER_UNIT
;
9796 highest_order_field_bit_offset
= bitpos_int
;
9798 if (! BYTES_BIG_ENDIAN
)
9800 highest_order_field_bit_offset
+= tree_low_cst (DECL_SIZE (decl
), 0);
9801 highest_order_object_bit_offset
+= simple_type_size_in_bits (type
);
9805 = (! BYTES_BIG_ENDIAN
9806 ? highest_order_object_bit_offset
- highest_order_field_bit_offset
9807 : highest_order_field_bit_offset
- highest_order_object_bit_offset
);
9809 add_AT_unsigned (die
, DW_AT_bit_offset
, bit_offset
);
9812 /* For a FIELD_DECL node which represents a bit field, output an attribute
9813 which specifies the length in bits of the given field. */
9816 add_bit_size_attribute (dw_die_ref die
, tree decl
)
9818 /* Must be a field and a bit field. */
9819 if (TREE_CODE (decl
) != FIELD_DECL
9820 || ! DECL_BIT_FIELD_TYPE (decl
))
9823 if (host_integerp (DECL_SIZE (decl
), 1))
9824 add_AT_unsigned (die
, DW_AT_bit_size
, tree_low_cst (DECL_SIZE (decl
), 1));
9827 /* If the compiled language is ANSI C, then add a 'prototyped'
9828 attribute, if arg types are given for the parameters of a function. */
9831 add_prototyped_attribute (dw_die_ref die
, tree func_type
)
9833 if (get_AT_unsigned (comp_unit_die
, DW_AT_language
) == DW_LANG_C89
9834 && TYPE_ARG_TYPES (func_type
) != NULL
)
9835 add_AT_flag (die
, DW_AT_prototyped
, 1);
9838 /* Add an 'abstract_origin' attribute below a given DIE. The DIE is found
9839 by looking in either the type declaration or object declaration
9843 add_abstract_origin_attribute (dw_die_ref die
, tree origin
)
9845 dw_die_ref origin_die
= NULL
;
9847 if (TREE_CODE (origin
) != FUNCTION_DECL
)
9849 /* We may have gotten separated from the block for the inlined
9850 function, if we're in an exception handler or some such; make
9851 sure that the abstract function has been written out.
9853 Doing this for nested functions is wrong, however; functions are
9854 distinct units, and our context might not even be inline. */
9858 fn
= TYPE_STUB_DECL (fn
);
9860 fn
= decl_function_context (fn
);
9862 dwarf2out_abstract_function (fn
);
9865 if (DECL_P (origin
))
9866 origin_die
= lookup_decl_die (origin
);
9867 else if (TYPE_P (origin
))
9868 origin_die
= lookup_type_die (origin
);
9870 if (origin_die
== NULL
)
9873 add_AT_die_ref (die
, DW_AT_abstract_origin
, origin_die
);
9876 /* We do not currently support the pure_virtual attribute. */
9879 add_pure_or_virtual_attribute (dw_die_ref die
, tree func_decl
)
9881 if (DECL_VINDEX (func_decl
))
9883 add_AT_unsigned (die
, DW_AT_virtuality
, DW_VIRTUALITY_virtual
);
9885 if (host_integerp (DECL_VINDEX (func_decl
), 0))
9886 add_AT_loc (die
, DW_AT_vtable_elem_location
,
9887 new_loc_descr (DW_OP_constu
,
9888 tree_low_cst (DECL_VINDEX (func_decl
), 0),
9891 /* GNU extension: Record what type this method came from originally. */
9892 if (debug_info_level
> DINFO_LEVEL_TERSE
)
9893 add_AT_die_ref (die
, DW_AT_containing_type
,
9894 lookup_type_die (DECL_CONTEXT (func_decl
)));
9898 /* Add source coordinate attributes for the given decl. */
9901 add_src_coords_attributes (dw_die_ref die
, tree decl
)
9903 unsigned file_index
= lookup_filename (DECL_SOURCE_FILE (decl
));
9905 add_AT_unsigned (die
, DW_AT_decl_file
, file_index
);
9906 add_AT_unsigned (die
, DW_AT_decl_line
, DECL_SOURCE_LINE (decl
));
9909 /* Add a DW_AT_name attribute and source coordinate attribute for the
9910 given decl, but only if it actually has a name. */
9913 add_name_and_src_coords_attributes (dw_die_ref die
, tree decl
)
9917 decl_name
= DECL_NAME (decl
);
9918 if (decl_name
!= NULL
&& IDENTIFIER_POINTER (decl_name
) != NULL
)
9920 add_name_attribute (die
, dwarf2_name (decl
, 0));
9921 if (! DECL_ARTIFICIAL (decl
))
9922 add_src_coords_attributes (die
, decl
);
9924 if ((TREE_CODE (decl
) == FUNCTION_DECL
|| TREE_CODE (decl
) == VAR_DECL
)
9925 && TREE_PUBLIC (decl
)
9926 && DECL_ASSEMBLER_NAME (decl
) != DECL_NAME (decl
)
9927 && !DECL_ABSTRACT (decl
))
9928 add_AT_string (die
, DW_AT_MIPS_linkage_name
,
9929 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)));
9932 #ifdef VMS_DEBUGGING_INFO
9933 /* Get the function's name, as described by its RTL. This may be different
9934 from the DECL_NAME name used in the source file. */
9935 if (TREE_CODE (decl
) == FUNCTION_DECL
&& TREE_ASM_WRITTEN (decl
))
9937 add_AT_addr (die
, DW_AT_VMS_rtnbeg_pd_address
,
9938 XEXP (DECL_RTL (decl
), 0));
9939 VARRAY_PUSH_RTX (used_rtx_varray
, XEXP (DECL_RTL (decl
), 0));
9944 /* Push a new declaration scope. */
9947 push_decl_scope (tree scope
)
9949 VARRAY_PUSH_TREE (decl_scope_table
, scope
);
9952 /* Pop a declaration scope. */
9955 pop_decl_scope (void)
9957 if (VARRAY_ACTIVE_SIZE (decl_scope_table
) <= 0)
9960 VARRAY_POP (decl_scope_table
);
9963 /* Return the DIE for the scope that immediately contains this type.
9964 Non-named types get global scope. Named types nested in other
9965 types get their containing scope if it's open, or global scope
9966 otherwise. All other types (i.e. function-local named types) get
9967 the current active scope. */
9970 scope_die_for (tree t
, dw_die_ref context_die
)
9972 dw_die_ref scope_die
= NULL
;
9973 tree containing_scope
;
9976 /* Non-types always go in the current scope. */
9980 containing_scope
= TYPE_CONTEXT (t
);
9982 /* Ignore namespaces for the moment. */
9983 if (containing_scope
&& TREE_CODE (containing_scope
) == NAMESPACE_DECL
)
9984 containing_scope
= NULL_TREE
;
9986 /* Ignore function type "scopes" from the C frontend. They mean that
9987 a tagged type is local to a parmlist of a function declarator, but
9988 that isn't useful to DWARF. */
9989 if (containing_scope
&& TREE_CODE (containing_scope
) == FUNCTION_TYPE
)
9990 containing_scope
= NULL_TREE
;
9992 if (containing_scope
== NULL_TREE
)
9993 scope_die
= comp_unit_die
;
9994 else if (TYPE_P (containing_scope
))
9996 /* For types, we can just look up the appropriate DIE. But
9997 first we check to see if we're in the middle of emitting it
9998 so we know where the new DIE should go. */
9999 for (i
= VARRAY_ACTIVE_SIZE (decl_scope_table
) - 1; i
>= 0; --i
)
10000 if (VARRAY_TREE (decl_scope_table
, i
) == containing_scope
)
10005 if (debug_info_level
> DINFO_LEVEL_TERSE
10006 && !TREE_ASM_WRITTEN (containing_scope
))
10009 /* If none of the current dies are suitable, we get file scope. */
10010 scope_die
= comp_unit_die
;
10013 scope_die
= lookup_type_die (containing_scope
);
10016 scope_die
= context_die
;
10021 /* Returns nonzero if CONTEXT_DIE is internal to a function. */
10024 local_scope_p (dw_die_ref context_die
)
10026 for (; context_die
; context_die
= context_die
->die_parent
)
10027 if (context_die
->die_tag
== DW_TAG_inlined_subroutine
10028 || context_die
->die_tag
== DW_TAG_subprogram
)
10034 /* Returns nonzero if CONTEXT_DIE is a class. */
10037 class_scope_p (dw_die_ref context_die
)
10039 return (context_die
10040 && (context_die
->die_tag
== DW_TAG_structure_type
10041 || context_die
->die_tag
== DW_TAG_union_type
));
10044 /* Many forms of DIEs require a "type description" attribute. This
10045 routine locates the proper "type descriptor" die for the type given
10046 by 'type', and adds a DW_AT_type attribute below the given die. */
10049 add_type_attribute (dw_die_ref object_die
, tree type
, int decl_const
,
10050 int decl_volatile
, dw_die_ref context_die
)
10052 enum tree_code code
= TREE_CODE (type
);
10053 dw_die_ref type_die
= NULL
;
10055 /* ??? If this type is an unnamed subrange type of an integral or
10056 floating-point type, use the inner type. This is because we have no
10057 support for unnamed types in base_type_die. This can happen if this is
10058 an Ada subrange type. Correct solution is emit a subrange type die. */
10059 if ((code
== INTEGER_TYPE
|| code
== REAL_TYPE
)
10060 && TREE_TYPE (type
) != 0 && TYPE_NAME (type
) == 0)
10061 type
= TREE_TYPE (type
), code
= TREE_CODE (type
);
10063 if (code
== ERROR_MARK
10064 /* Handle a special case. For functions whose return type is void, we
10065 generate *no* type attribute. (Note that no object may have type
10066 `void', so this only applies to function return types). */
10067 || code
== VOID_TYPE
)
10070 type_die
= modified_type_die (type
,
10071 decl_const
|| TYPE_READONLY (type
),
10072 decl_volatile
|| TYPE_VOLATILE (type
),
10075 if (type_die
!= NULL
)
10076 add_AT_die_ref (object_die
, DW_AT_type
, type_die
);
10079 /* Given a tree pointer to a struct, class, union, or enum type node, return
10080 a pointer to the (string) tag name for the given type, or zero if the type
10081 was declared without a tag. */
10083 static const char *
10084 type_tag (tree type
)
10086 const char *name
= 0;
10088 if (TYPE_NAME (type
) != 0)
10092 /* Find the IDENTIFIER_NODE for the type name. */
10093 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
10094 t
= TYPE_NAME (type
);
10096 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
10097 a TYPE_DECL node, regardless of whether or not a `typedef' was
10099 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
10100 && ! DECL_IGNORED_P (TYPE_NAME (type
)))
10101 t
= DECL_NAME (TYPE_NAME (type
));
10103 /* Now get the name as a string, or invent one. */
10105 name
= IDENTIFIER_POINTER (t
);
10108 return (name
== 0 || *name
== '\0') ? 0 : name
;
10111 /* Return the type associated with a data member, make a special check
10112 for bit field types. */
10115 member_declared_type (tree member
)
10117 return (DECL_BIT_FIELD_TYPE (member
)
10118 ? DECL_BIT_FIELD_TYPE (member
) : TREE_TYPE (member
));
10121 /* Get the decl's label, as described by its RTL. This may be different
10122 from the DECL_NAME name used in the source file. */
10125 static const char *
10126 decl_start_label (tree decl
)
10129 const char *fnname
;
10131 x
= DECL_RTL (decl
);
10132 if (GET_CODE (x
) != MEM
)
10136 if (GET_CODE (x
) != SYMBOL_REF
)
10139 fnname
= XSTR (x
, 0);
10144 /* These routines generate the internal representation of the DIE's for
10145 the compilation unit. Debugging information is collected by walking
10146 the declaration trees passed in from dwarf2out_decl(). */
10149 gen_array_type_die (tree type
, dw_die_ref context_die
)
10151 dw_die_ref scope_die
= scope_die_for (type
, context_die
);
10152 dw_die_ref array_die
;
10155 /* ??? The SGI dwarf reader fails for array of array of enum types unless
10156 the inner array type comes before the outer array type. Thus we must
10157 call gen_type_die before we call new_die. See below also. */
10158 #ifdef MIPS_DEBUGGING_INFO
10159 gen_type_die (TREE_TYPE (type
), context_die
);
10162 array_die
= new_die (DW_TAG_array_type
, scope_die
, type
);
10163 add_name_attribute (array_die
, type_tag (type
));
10164 equate_type_number_to_die (type
, array_die
);
10166 if (TREE_CODE (type
) == VECTOR_TYPE
)
10168 /* The frontend feeds us a representation for the vector as a struct
10169 containing an array. Pull out the array type. */
10170 type
= TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type
)));
10171 add_AT_flag (array_die
, DW_AT_GNU_vector
, 1);
10175 /* We default the array ordering. SDB will probably do
10176 the right things even if DW_AT_ordering is not present. It's not even
10177 an issue until we start to get into multidimensional arrays anyway. If
10178 SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
10179 then we'll have to put the DW_AT_ordering attribute back in. (But if
10180 and when we find out that we need to put these in, we will only do so
10181 for multidimensional arrays. */
10182 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_row_major
);
10185 #ifdef MIPS_DEBUGGING_INFO
10186 /* The SGI compilers handle arrays of unknown bound by setting
10187 AT_declaration and not emitting any subrange DIEs. */
10188 if (! TYPE_DOMAIN (type
))
10189 add_AT_unsigned (array_die
, DW_AT_declaration
, 1);
10192 add_subscript_info (array_die
, type
);
10194 /* Add representation of the type of the elements of this array type. */
10195 element_type
= TREE_TYPE (type
);
10197 /* ??? The SGI dwarf reader fails for multidimensional arrays with a
10198 const enum type. E.g. const enum machine_mode insn_operand_mode[2][10].
10199 We work around this by disabling this feature. See also
10200 add_subscript_info. */
10201 #ifndef MIPS_DEBUGGING_INFO
10202 while (TREE_CODE (element_type
) == ARRAY_TYPE
)
10203 element_type
= TREE_TYPE (element_type
);
10205 gen_type_die (element_type
, context_die
);
10208 add_type_attribute (array_die
, element_type
, 0, 0, context_die
);
10212 gen_set_type_die (tree type
, dw_die_ref context_die
)
10214 dw_die_ref type_die
10215 = new_die (DW_TAG_set_type
, scope_die_for (type
, context_die
), type
);
10217 equate_type_number_to_die (type
, type_die
);
10218 add_type_attribute (type_die
, TREE_TYPE (type
), 0, 0, context_die
);
10223 gen_entry_point_die (tree decl
, dw_die_ref context_die
)
10225 tree origin
= decl_ultimate_origin (decl
);
10226 dw_die_ref decl_die
= new_die (DW_TAG_entry_point
, context_die
, decl
);
10228 if (origin
!= NULL
)
10229 add_abstract_origin_attribute (decl_die
, origin
);
10232 add_name_and_src_coords_attributes (decl_die
, decl
);
10233 add_type_attribute (decl_die
, TREE_TYPE (TREE_TYPE (decl
)),
10234 0, 0, context_die
);
10237 if (DECL_ABSTRACT (decl
))
10238 equate_decl_number_to_die (decl
, decl_die
);
10240 add_AT_lbl_id (decl_die
, DW_AT_low_pc
, decl_start_label (decl
));
10244 /* Walk through the list of incomplete types again, trying once more to
10245 emit full debugging info for them. */
10248 retry_incomplete_types (void)
10252 for (i
= VARRAY_ACTIVE_SIZE (incomplete_types
) - 1; i
>= 0; i
--)
10253 gen_type_die (VARRAY_TREE (incomplete_types
, i
), comp_unit_die
);
10256 /* Generate a DIE to represent an inlined instance of an enumeration type. */
10259 gen_inlined_enumeration_type_die (tree type
, dw_die_ref context_die
)
10261 dw_die_ref type_die
= new_die (DW_TAG_enumeration_type
, context_die
, type
);
10263 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
10264 be incomplete and such types are not marked. */
10265 add_abstract_origin_attribute (type_die
, type
);
10268 /* Generate a DIE to represent an inlined instance of a structure type. */
10271 gen_inlined_structure_type_die (tree type
, dw_die_ref context_die
)
10273 dw_die_ref type_die
= new_die (DW_TAG_structure_type
, context_die
, type
);
10275 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
10276 be incomplete and such types are not marked. */
10277 add_abstract_origin_attribute (type_die
, type
);
10280 /* Generate a DIE to represent an inlined instance of a union type. */
10283 gen_inlined_union_type_die (tree type
, dw_die_ref context_die
)
10285 dw_die_ref type_die
= new_die (DW_TAG_union_type
, context_die
, type
);
10287 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
10288 be incomplete and such types are not marked. */
10289 add_abstract_origin_attribute (type_die
, type
);
10292 /* Generate a DIE to represent an enumeration type. Note that these DIEs
10293 include all of the information about the enumeration values also. Each
10294 enumerated type name/value is listed as a child of the enumerated type
10298 gen_enumeration_type_die (tree type
, dw_die_ref context_die
)
10300 dw_die_ref type_die
= lookup_type_die (type
);
10302 if (type_die
== NULL
)
10304 type_die
= new_die (DW_TAG_enumeration_type
,
10305 scope_die_for (type
, context_die
), type
);
10306 equate_type_number_to_die (type
, type_die
);
10307 add_name_attribute (type_die
, type_tag (type
));
10309 else if (! TYPE_SIZE (type
))
10312 remove_AT (type_die
, DW_AT_declaration
);
10314 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the
10315 given enum type is incomplete, do not generate the DW_AT_byte_size
10316 attribute or the DW_AT_element_list attribute. */
10317 if (TYPE_SIZE (type
))
10321 TREE_ASM_WRITTEN (type
) = 1;
10322 add_byte_size_attribute (type_die
, type
);
10323 if (TYPE_STUB_DECL (type
) != NULL_TREE
)
10324 add_src_coords_attributes (type_die
, TYPE_STUB_DECL (type
));
10326 /* If the first reference to this type was as the return type of an
10327 inline function, then it may not have a parent. Fix this now. */
10328 if (type_die
->die_parent
== NULL
)
10329 add_child_die (scope_die_for (type
, context_die
), type_die
);
10331 for (link
= TYPE_FIELDS (type
);
10332 link
!= NULL
; link
= TREE_CHAIN (link
))
10334 dw_die_ref enum_die
= new_die (DW_TAG_enumerator
, type_die
, link
);
10336 add_name_attribute (enum_die
,
10337 IDENTIFIER_POINTER (TREE_PURPOSE (link
)));
10339 if (host_integerp (TREE_VALUE (link
),
10340 TREE_UNSIGNED (TREE_TYPE (TREE_VALUE (link
)))))
10342 if (tree_int_cst_sgn (TREE_VALUE (link
)) < 0)
10343 add_AT_int (enum_die
, DW_AT_const_value
,
10344 tree_low_cst (TREE_VALUE (link
), 0));
10346 add_AT_unsigned (enum_die
, DW_AT_const_value
,
10347 tree_low_cst (TREE_VALUE (link
), 1));
10352 add_AT_flag (type_die
, DW_AT_declaration
, 1);
10355 /* Generate a DIE to represent either a real live formal parameter decl or to
10356 represent just the type of some formal parameter position in some function
10359 Note that this routine is a bit unusual because its argument may be a
10360 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
10361 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
10362 node. If it's the former then this function is being called to output a
10363 DIE to represent a formal parameter object (or some inlining thereof). If
10364 it's the latter, then this function is only being called to output a
10365 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
10366 argument type of some subprogram type. */
10369 gen_formal_parameter_die (tree node
, dw_die_ref context_die
)
10371 dw_die_ref parm_die
10372 = new_die (DW_TAG_formal_parameter
, context_die
, node
);
10375 switch (TREE_CODE_CLASS (TREE_CODE (node
)))
10378 origin
= decl_ultimate_origin (node
);
10379 if (origin
!= NULL
)
10380 add_abstract_origin_attribute (parm_die
, origin
);
10383 add_name_and_src_coords_attributes (parm_die
, node
);
10384 add_type_attribute (parm_die
, TREE_TYPE (node
),
10385 TREE_READONLY (node
),
10386 TREE_THIS_VOLATILE (node
),
10388 if (DECL_ARTIFICIAL (node
))
10389 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
10392 equate_decl_number_to_die (node
, parm_die
);
10393 if (! DECL_ABSTRACT (node
))
10394 add_location_or_const_value_attribute (parm_die
, node
);
10399 /* We were called with some kind of a ..._TYPE node. */
10400 add_type_attribute (parm_die
, node
, 0, 0, context_die
);
10410 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
10411 at the end of an (ANSI prototyped) formal parameters list. */
10414 gen_unspecified_parameters_die (tree decl_or_type
, dw_die_ref context_die
)
10416 new_die (DW_TAG_unspecified_parameters
, context_die
, decl_or_type
);
10419 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
10420 DW_TAG_unspecified_parameters DIE) to represent the types of the formal
10421 parameters as specified in some function type specification (except for
10422 those which appear as part of a function *definition*). */
10425 gen_formal_types_die (tree function_or_method_type
, dw_die_ref context_die
)
10428 tree formal_type
= NULL
;
10429 tree first_parm_type
;
10432 if (TREE_CODE (function_or_method_type
) == FUNCTION_DECL
)
10434 arg
= DECL_ARGUMENTS (function_or_method_type
);
10435 function_or_method_type
= TREE_TYPE (function_or_method_type
);
10440 first_parm_type
= TYPE_ARG_TYPES (function_or_method_type
);
10442 /* Make our first pass over the list of formal parameter types and output a
10443 DW_TAG_formal_parameter DIE for each one. */
10444 for (link
= first_parm_type
; link
; )
10446 dw_die_ref parm_die
;
10448 formal_type
= TREE_VALUE (link
);
10449 if (formal_type
== void_type_node
)
10452 /* Output a (nameless) DIE to represent the formal parameter itself. */
10453 parm_die
= gen_formal_parameter_die (formal_type
, context_die
);
10454 if ((TREE_CODE (function_or_method_type
) == METHOD_TYPE
10455 && link
== first_parm_type
)
10456 || (arg
&& DECL_ARTIFICIAL (arg
)))
10457 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
10459 link
= TREE_CHAIN (link
);
10461 arg
= TREE_CHAIN (arg
);
10464 /* If this function type has an ellipsis, add a
10465 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */
10466 if (formal_type
!= void_type_node
)
10467 gen_unspecified_parameters_die (function_or_method_type
, context_die
);
10469 /* Make our second (and final) pass over the list of formal parameter types
10470 and output DIEs to represent those types (as necessary). */
10471 for (link
= TYPE_ARG_TYPES (function_or_method_type
);
10472 link
&& TREE_VALUE (link
);
10473 link
= TREE_CHAIN (link
))
10474 gen_type_die (TREE_VALUE (link
), context_die
);
10477 /* We want to generate the DIE for TYPE so that we can generate the
10478 die for MEMBER, which has been defined; we will need to refer back
10479 to the member declaration nested within TYPE. If we're trying to
10480 generate minimal debug info for TYPE, processing TYPE won't do the
10481 trick; we need to attach the member declaration by hand. */
10484 gen_type_die_for_member (tree type
, tree member
, dw_die_ref context_die
)
10486 gen_type_die (type
, context_die
);
10488 /* If we're trying to avoid duplicate debug info, we may not have
10489 emitted the member decl for this function. Emit it now. */
10490 if (TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type
))
10491 && ! lookup_decl_die (member
))
10493 if (decl_ultimate_origin (member
))
10496 push_decl_scope (type
);
10497 if (TREE_CODE (member
) == FUNCTION_DECL
)
10498 gen_subprogram_die (member
, lookup_type_die (type
));
10500 gen_variable_die (member
, lookup_type_die (type
));
10506 /* Generate the DWARF2 info for the "abstract" instance of a function which we
10507 may later generate inlined and/or out-of-line instances of. */
10510 dwarf2out_abstract_function (tree decl
)
10512 dw_die_ref old_die
;
10515 int was_abstract
= DECL_ABSTRACT (decl
);
10517 /* Make sure we have the actual abstract inline, not a clone. */
10518 decl
= DECL_ORIGIN (decl
);
10520 old_die
= lookup_decl_die (decl
);
10521 if (old_die
&& get_AT (old_die
, DW_AT_inline
))
10522 /* We've already generated the abstract instance. */
10525 /* Be sure we've emitted the in-class declaration DIE (if any) first, so
10526 we don't get confused by DECL_ABSTRACT. */
10527 if (debug_info_level
> DINFO_LEVEL_TERSE
)
10529 context
= decl_class_context (decl
);
10531 gen_type_die_for_member
10532 (context
, decl
, decl_function_context (decl
) ? NULL
: comp_unit_die
);
10535 /* Pretend we've just finished compiling this function. */
10536 save_fn
= current_function_decl
;
10537 current_function_decl
= decl
;
10539 set_decl_abstract_flags (decl
, 1);
10540 dwarf2out_decl (decl
);
10541 if (! was_abstract
)
10542 set_decl_abstract_flags (decl
, 0);
10544 current_function_decl
= save_fn
;
10547 /* Generate a DIE to represent a declared function (either file-scope or
10551 gen_subprogram_die (tree decl
, dw_die_ref context_die
)
10553 char label_id
[MAX_ARTIFICIAL_LABEL_BYTES
];
10554 tree origin
= decl_ultimate_origin (decl
);
10555 dw_die_ref subr_die
;
10559 dw_die_ref old_die
= lookup_decl_die (decl
);
10560 int declaration
= (current_function_decl
!= decl
10561 || class_scope_p (context_die
));
10563 /* It is possible to have both DECL_ABSTRACT and DECLARATION be true if we
10564 started to generate the abstract instance of an inline, decided to output
10565 its containing class, and proceeded to emit the declaration of the inline
10566 from the member list for the class. If so, DECLARATION takes priority;
10567 we'll get back to the abstract instance when done with the class. */
10569 /* The class-scope declaration DIE must be the primary DIE. */
10570 if (origin
&& declaration
&& class_scope_p (context_die
))
10577 if (origin
!= NULL
)
10579 if (declaration
&& ! local_scope_p (context_die
))
10582 /* Fixup die_parent for the abstract instance of a nested
10583 inline function. */
10584 if (old_die
&& old_die
->die_parent
== NULL
)
10585 add_child_die (context_die
, old_die
);
10587 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
10588 add_abstract_origin_attribute (subr_die
, origin
);
10592 unsigned file_index
= lookup_filename (DECL_SOURCE_FILE (decl
));
10594 if (!get_AT_flag (old_die
, DW_AT_declaration
)
10595 /* We can have a normal definition following an inline one in the
10596 case of redefinition of GNU C extern inlines.
10597 It seems reasonable to use AT_specification in this case. */
10598 && !get_AT (old_die
, DW_AT_inline
))
10600 /* ??? This can happen if there is a bug in the program, for
10601 instance, if it has duplicate function definitions. Ideally,
10602 we should detect this case and ignore it. For now, if we have
10603 already reported an error, any error at all, then assume that
10604 we got here because of an input error, not a dwarf2 bug. */
10610 /* If the definition comes from the same place as the declaration,
10611 maybe use the old DIE. We always want the DIE for this function
10612 that has the *_pc attributes to be under comp_unit_die so the
10613 debugger can find it. We also need to do this for abstract
10614 instances of inlines, since the spec requires the out-of-line copy
10615 to have the same parent. For local class methods, this doesn't
10616 apply; we just use the old DIE. */
10617 if ((old_die
->die_parent
== comp_unit_die
|| context_die
== NULL
)
10618 && (DECL_ARTIFICIAL (decl
)
10619 || (get_AT_unsigned (old_die
, DW_AT_decl_file
) == file_index
10620 && (get_AT_unsigned (old_die
, DW_AT_decl_line
)
10621 == (unsigned) DECL_SOURCE_LINE (decl
)))))
10623 subr_die
= old_die
;
10625 /* Clear out the declaration attribute and the parm types. */
10626 remove_AT (subr_die
, DW_AT_declaration
);
10627 remove_children (subr_die
);
10631 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
10632 add_AT_die_ref (subr_die
, DW_AT_specification
, old_die
);
10633 if (get_AT_unsigned (old_die
, DW_AT_decl_file
) != file_index
)
10634 add_AT_unsigned (subr_die
, DW_AT_decl_file
, file_index
);
10635 if (get_AT_unsigned (old_die
, DW_AT_decl_line
)
10636 != (unsigned) DECL_SOURCE_LINE (decl
))
10638 (subr_die
, DW_AT_decl_line
, DECL_SOURCE_LINE (decl
));
10643 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
10645 if (TREE_PUBLIC (decl
))
10646 add_AT_flag (subr_die
, DW_AT_external
, 1);
10648 add_name_and_src_coords_attributes (subr_die
, decl
);
10649 if (debug_info_level
> DINFO_LEVEL_TERSE
)
10651 add_prototyped_attribute (subr_die
, TREE_TYPE (decl
));
10652 add_type_attribute (subr_die
, TREE_TYPE (TREE_TYPE (decl
)),
10653 0, 0, context_die
);
10656 add_pure_or_virtual_attribute (subr_die
, decl
);
10657 if (DECL_ARTIFICIAL (decl
))
10658 add_AT_flag (subr_die
, DW_AT_artificial
, 1);
10660 if (TREE_PROTECTED (decl
))
10661 add_AT_unsigned (subr_die
, DW_AT_accessibility
, DW_ACCESS_protected
);
10662 else if (TREE_PRIVATE (decl
))
10663 add_AT_unsigned (subr_die
, DW_AT_accessibility
, DW_ACCESS_private
);
10668 if (!old_die
|| !get_AT (old_die
, DW_AT_inline
))
10670 add_AT_flag (subr_die
, DW_AT_declaration
, 1);
10672 /* The first time we see a member function, it is in the context of
10673 the class to which it belongs. We make sure of this by emitting
10674 the class first. The next time is the definition, which is
10675 handled above. The two may come from the same source text. */
10676 if (DECL_CONTEXT (decl
) || DECL_ABSTRACT (decl
))
10677 equate_decl_number_to_die (decl
, subr_die
);
10680 else if (DECL_ABSTRACT (decl
))
10682 if (DECL_DECLARED_INLINE_P (decl
))
10684 if (cgraph_function_possibly_inlined_p (decl
))
10685 add_AT_unsigned (subr_die
, DW_AT_inline
, DW_INL_declared_inlined
);
10687 add_AT_unsigned (subr_die
, DW_AT_inline
, DW_INL_declared_not_inlined
);
10691 if (cgraph_function_possibly_inlined_p (decl
))
10692 add_AT_unsigned (subr_die
, DW_AT_inline
, DW_INL_inlined
);
10694 add_AT_unsigned (subr_die
, DW_AT_inline
, DW_INL_not_inlined
);
10697 equate_decl_number_to_die (decl
, subr_die
);
10699 else if (!DECL_EXTERNAL (decl
))
10701 if (!old_die
|| !get_AT (old_die
, DW_AT_inline
))
10702 equate_decl_number_to_die (decl
, subr_die
);
10704 ASM_GENERATE_INTERNAL_LABEL (label_id
, FUNC_BEGIN_LABEL
,
10705 current_function_funcdef_no
);
10706 add_AT_lbl_id (subr_die
, DW_AT_low_pc
, label_id
);
10707 ASM_GENERATE_INTERNAL_LABEL (label_id
, FUNC_END_LABEL
,
10708 current_function_funcdef_no
);
10709 add_AT_lbl_id (subr_die
, DW_AT_high_pc
, label_id
);
10711 add_pubname (decl
, subr_die
);
10712 add_arange (decl
, subr_die
);
10714 #ifdef MIPS_DEBUGGING_INFO
10715 /* Add a reference to the FDE for this routine. */
10716 add_AT_fde_ref (subr_die
, DW_AT_MIPS_fde
, current_funcdef_fde
);
10719 /* Define the "frame base" location for this routine. We use the
10720 frame pointer or stack pointer registers, since the RTL for local
10721 variables is relative to one of them. */
10723 = frame_pointer_needed
? hard_frame_pointer_rtx
: stack_pointer_rtx
;
10724 add_AT_loc (subr_die
, DW_AT_frame_base
, reg_loc_descriptor (fp_reg
));
10727 /* ??? This fails for nested inline functions, because context_display
10728 is not part of the state saved/restored for inline functions. */
10729 if (current_function_needs_context
)
10730 add_AT_location_description (subr_die
, DW_AT_static_link
,
10731 loc_descriptor (lookup_static_chain (decl
)));
10735 /* Now output descriptions of the arguments for this function. This gets
10736 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
10737 for a FUNCTION_DECL doesn't indicate cases where there was a trailing
10738 `...' at the end of the formal parameter list. In order to find out if
10739 there was a trailing ellipsis or not, we must instead look at the type
10740 associated with the FUNCTION_DECL. This will be a node of type
10741 FUNCTION_TYPE. If the chain of type nodes hanging off of this
10742 FUNCTION_TYPE node ends with a void_type_node then there should *not* be
10743 an ellipsis at the end. */
10745 /* In the case where we are describing a mere function declaration, all we
10746 need to do here (and all we *can* do here) is to describe the *types* of
10747 its formal parameters. */
10748 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
10750 else if (declaration
)
10751 gen_formal_types_die (decl
, subr_die
);
10754 /* Generate DIEs to represent all known formal parameters. */
10755 tree arg_decls
= DECL_ARGUMENTS (decl
);
10758 /* When generating DIEs, generate the unspecified_parameters DIE
10759 instead if we come across the arg "__builtin_va_alist" */
10760 for (parm
= arg_decls
; parm
; parm
= TREE_CHAIN (parm
))
10761 if (TREE_CODE (parm
) == PARM_DECL
)
10763 if (DECL_NAME (parm
)
10764 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (parm
)),
10765 "__builtin_va_alist"))
10766 gen_unspecified_parameters_die (parm
, subr_die
);
10768 gen_decl_die (parm
, subr_die
);
10771 /* Decide whether we need an unspecified_parameters DIE at the end.
10772 There are 2 more cases to do this for: 1) the ansi ... declaration -
10773 this is detectable when the end of the arg list is not a
10774 void_type_node 2) an unprototyped function declaration (not a
10775 definition). This just means that we have no info about the
10776 parameters at all. */
10777 fn_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
10778 if (fn_arg_types
!= NULL
)
10780 /* This is the prototyped case, check for.... */
10781 if (TREE_VALUE (tree_last (fn_arg_types
)) != void_type_node
)
10782 gen_unspecified_parameters_die (decl
, subr_die
);
10784 else if (DECL_INITIAL (decl
) == NULL_TREE
)
10785 gen_unspecified_parameters_die (decl
, subr_die
);
10788 /* Output Dwarf info for all of the stuff within the body of the function
10789 (if it has one - it may be just a declaration). */
10790 outer_scope
= DECL_INITIAL (decl
);
10792 /* OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent
10793 a function. This BLOCK actually represents the outermost binding contour
10794 for the function, i.e. the contour in which the function's formal
10795 parameters and labels get declared. Curiously, it appears that the front
10796 end doesn't actually put the PARM_DECL nodes for the current function onto
10797 the BLOCK_VARS list for this outer scope, but are strung off of the
10798 DECL_ARGUMENTS list for the function instead.
10800 The BLOCK_VARS list for the `outer_scope' does provide us with a list of
10801 the LABEL_DECL nodes for the function however, and we output DWARF info
10802 for those in decls_for_scope. Just within the `outer_scope' there will be
10803 a BLOCK node representing the function's outermost pair of curly braces,
10804 and any blocks used for the base and member initializers of a C++
10805 constructor function. */
10806 if (! declaration
&& TREE_CODE (outer_scope
) != ERROR_MARK
)
10808 current_function_has_inlines
= 0;
10809 decls_for_scope (outer_scope
, subr_die
, 0);
10811 #if 0 && defined (MIPS_DEBUGGING_INFO)
10812 if (current_function_has_inlines
)
10814 add_AT_flag (subr_die
, DW_AT_MIPS_has_inlines
, 1);
10815 if (! comp_unit_has_inlines
)
10817 add_AT_flag (comp_unit_die
, DW_AT_MIPS_has_inlines
, 1);
10818 comp_unit_has_inlines
= 1;
10825 /* Generate a DIE to represent a declared data object. */
10828 gen_variable_die (tree decl
, dw_die_ref context_die
)
10830 tree origin
= decl_ultimate_origin (decl
);
10831 dw_die_ref var_die
= new_die (DW_TAG_variable
, context_die
, decl
);
10833 dw_die_ref old_die
= lookup_decl_die (decl
);
10834 int declaration
= (DECL_EXTERNAL (decl
)
10835 || class_scope_p (context_die
));
10837 if (origin
!= NULL
)
10838 add_abstract_origin_attribute (var_die
, origin
);
10840 /* Loop unrolling can create multiple blocks that refer to the same
10841 static variable, so we must test for the DW_AT_declaration flag.
10843 ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
10844 copy decls and set the DECL_ABSTRACT flag on them instead of
10847 ??? Duplicated blocks have been rewritten to use .debug_ranges. */
10848 else if (old_die
&& TREE_STATIC (decl
)
10849 && get_AT_flag (old_die
, DW_AT_declaration
) == 1)
10851 /* This is a definition of a C++ class level static. */
10852 add_AT_die_ref (var_die
, DW_AT_specification
, old_die
);
10853 if (DECL_NAME (decl
))
10855 unsigned file_index
= lookup_filename (DECL_SOURCE_FILE (decl
));
10857 if (get_AT_unsigned (old_die
, DW_AT_decl_file
) != file_index
)
10858 add_AT_unsigned (var_die
, DW_AT_decl_file
, file_index
);
10860 if (get_AT_unsigned (old_die
, DW_AT_decl_line
)
10861 != (unsigned) DECL_SOURCE_LINE (decl
))
10863 add_AT_unsigned (var_die
, DW_AT_decl_line
,
10864 DECL_SOURCE_LINE (decl
));
10869 add_name_and_src_coords_attributes (var_die
, decl
);
10870 add_type_attribute (var_die
, TREE_TYPE (decl
), TREE_READONLY (decl
),
10871 TREE_THIS_VOLATILE (decl
), context_die
);
10873 if (TREE_PUBLIC (decl
))
10874 add_AT_flag (var_die
, DW_AT_external
, 1);
10876 if (DECL_ARTIFICIAL (decl
))
10877 add_AT_flag (var_die
, DW_AT_artificial
, 1);
10879 if (TREE_PROTECTED (decl
))
10880 add_AT_unsigned (var_die
, DW_AT_accessibility
, DW_ACCESS_protected
);
10881 else if (TREE_PRIVATE (decl
))
10882 add_AT_unsigned (var_die
, DW_AT_accessibility
, DW_ACCESS_private
);
10886 add_AT_flag (var_die
, DW_AT_declaration
, 1);
10888 if (class_scope_p (context_die
) || DECL_ABSTRACT (decl
))
10889 equate_decl_number_to_die (decl
, var_die
);
10891 if (! declaration
&& ! DECL_ABSTRACT (decl
))
10893 add_location_or_const_value_attribute (var_die
, decl
);
10894 add_pubname (decl
, var_die
);
10897 tree_add_const_value_attribute (var_die
, decl
);
10900 /* Generate a DIE to represent a label identifier. */
10903 gen_label_die (tree decl
, dw_die_ref context_die
)
10905 tree origin
= decl_ultimate_origin (decl
);
10906 dw_die_ref lbl_die
= new_die (DW_TAG_label
, context_die
, decl
);
10908 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
10910 if (origin
!= NULL
)
10911 add_abstract_origin_attribute (lbl_die
, origin
);
10913 add_name_and_src_coords_attributes (lbl_die
, decl
);
10915 if (DECL_ABSTRACT (decl
))
10916 equate_decl_number_to_die (decl
, lbl_die
);
10919 insn
= DECL_RTL (decl
);
10921 /* Deleted labels are programmer specified labels which have been
10922 eliminated because of various optimizations. We still emit them
10923 here so that it is possible to put breakpoints on them. */
10924 if (GET_CODE (insn
) == CODE_LABEL
10925 || ((GET_CODE (insn
) == NOTE
10926 && NOTE_LINE_NUMBER (insn
) == NOTE_INSN_DELETED_LABEL
)))
10928 /* When optimization is enabled (via -O) some parts of the compiler
10929 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
10930 represent source-level labels which were explicitly declared by
10931 the user. This really shouldn't be happening though, so catch
10932 it if it ever does happen. */
10933 if (INSN_DELETED_P (insn
))
10936 ASM_GENERATE_INTERNAL_LABEL (label
, "L", CODE_LABEL_NUMBER (insn
));
10937 add_AT_lbl_id (lbl_die
, DW_AT_low_pc
, label
);
10942 /* Generate a DIE for a lexical block. */
10945 gen_lexical_block_die (tree stmt
, dw_die_ref context_die
, int depth
)
10947 dw_die_ref stmt_die
= new_die (DW_TAG_lexical_block
, context_die
, stmt
);
10948 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
10950 if (! BLOCK_ABSTRACT (stmt
))
10952 if (BLOCK_FRAGMENT_CHAIN (stmt
))
10956 add_AT_range_list (stmt_die
, DW_AT_ranges
, add_ranges (stmt
));
10958 chain
= BLOCK_FRAGMENT_CHAIN (stmt
);
10961 add_ranges (chain
);
10962 chain
= BLOCK_FRAGMENT_CHAIN (chain
);
10969 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_BEGIN_LABEL
,
10970 BLOCK_NUMBER (stmt
));
10971 add_AT_lbl_id (stmt_die
, DW_AT_low_pc
, label
);
10972 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_END_LABEL
,
10973 BLOCK_NUMBER (stmt
));
10974 add_AT_lbl_id (stmt_die
, DW_AT_high_pc
, label
);
10978 decls_for_scope (stmt
, stmt_die
, depth
);
10981 /* Generate a DIE for an inlined subprogram. */
10984 gen_inlined_subroutine_die (tree stmt
, dw_die_ref context_die
, int depth
)
10986 tree decl
= block_ultimate_origin (stmt
);
10988 /* Emit info for the abstract instance first, if we haven't yet. We
10989 must emit this even if the block is abstract, otherwise when we
10990 emit the block below (or elsewhere), we may end up trying to emit
10991 a die whose origin die hasn't been emitted, and crashing. */
10992 dwarf2out_abstract_function (decl
);
10994 if (! BLOCK_ABSTRACT (stmt
))
10996 dw_die_ref subr_die
10997 = new_die (DW_TAG_inlined_subroutine
, context_die
, stmt
);
10998 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
11000 add_abstract_origin_attribute (subr_die
, decl
);
11001 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_BEGIN_LABEL
,
11002 BLOCK_NUMBER (stmt
));
11003 add_AT_lbl_id (subr_die
, DW_AT_low_pc
, label
);
11004 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_END_LABEL
,
11005 BLOCK_NUMBER (stmt
));
11006 add_AT_lbl_id (subr_die
, DW_AT_high_pc
, label
);
11007 decls_for_scope (stmt
, subr_die
, depth
);
11008 current_function_has_inlines
= 1;
11011 /* We may get here if we're the outer block of function A that was
11012 inlined into function B that was inlined into function C. When
11013 generating debugging info for C, dwarf2out_abstract_function(B)
11014 would mark all inlined blocks as abstract, including this one.
11015 So, we wouldn't (and shouldn't) expect labels to be generated
11016 for this one. Instead, just emit debugging info for
11017 declarations within the block. This is particularly important
11018 in the case of initializers of arguments passed from B to us:
11019 if they're statement expressions containing declarations, we
11020 wouldn't generate dies for their abstract variables, and then,
11021 when generating dies for the real variables, we'd die (pun
11023 gen_lexical_block_die (stmt
, context_die
, depth
);
11026 /* Generate a DIE for a field in a record, or structure. */
11029 gen_field_die (tree decl
, dw_die_ref context_die
)
11031 dw_die_ref decl_die
;
11033 if (TREE_TYPE (decl
) == error_mark_node
)
11036 decl_die
= new_die (DW_TAG_member
, context_die
, decl
);
11037 add_name_and_src_coords_attributes (decl_die
, decl
);
11038 add_type_attribute (decl_die
, member_declared_type (decl
),
11039 TREE_READONLY (decl
), TREE_THIS_VOLATILE (decl
),
11042 if (DECL_BIT_FIELD_TYPE (decl
))
11044 add_byte_size_attribute (decl_die
, decl
);
11045 add_bit_size_attribute (decl_die
, decl
);
11046 add_bit_offset_attribute (decl_die
, decl
);
11049 if (TREE_CODE (DECL_FIELD_CONTEXT (decl
)) != UNION_TYPE
)
11050 add_data_member_location_attribute (decl_die
, decl
);
11052 if (DECL_ARTIFICIAL (decl
))
11053 add_AT_flag (decl_die
, DW_AT_artificial
, 1);
11055 if (TREE_PROTECTED (decl
))
11056 add_AT_unsigned (decl_die
, DW_AT_accessibility
, DW_ACCESS_protected
);
11057 else if (TREE_PRIVATE (decl
))
11058 add_AT_unsigned (decl_die
, DW_AT_accessibility
, DW_ACCESS_private
);
11062 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
11063 Use modified_type_die instead.
11064 We keep this code here just in case these types of DIEs may be needed to
11065 represent certain things in other languages (e.g. Pascal) someday. */
11068 gen_pointer_type_die (tree type
, dw_die_ref context_die
)
11071 = new_die (DW_TAG_pointer_type
, scope_die_for (type
, context_die
), type
);
11073 equate_type_number_to_die (type
, ptr_die
);
11074 add_type_attribute (ptr_die
, TREE_TYPE (type
), 0, 0, context_die
);
11075 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
, PTR_SIZE
);
11078 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
11079 Use modified_type_die instead.
11080 We keep this code here just in case these types of DIEs may be needed to
11081 represent certain things in other languages (e.g. Pascal) someday. */
11084 gen_reference_type_die (tree type
, dw_die_ref context_die
)
11087 = new_die (DW_TAG_reference_type
, scope_die_for (type
, context_die
), type
);
11089 equate_type_number_to_die (type
, ref_die
);
11090 add_type_attribute (ref_die
, TREE_TYPE (type
), 0, 0, context_die
);
11091 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
, PTR_SIZE
);
11095 /* Generate a DIE for a pointer to a member type. */
11098 gen_ptr_to_mbr_type_die (tree type
, dw_die_ref context_die
)
11101 = new_die (DW_TAG_ptr_to_member_type
,
11102 scope_die_for (type
, context_die
), type
);
11104 equate_type_number_to_die (type
, ptr_die
);
11105 add_AT_die_ref (ptr_die
, DW_AT_containing_type
,
11106 lookup_type_die (TYPE_OFFSET_BASETYPE (type
)));
11107 add_type_attribute (ptr_die
, TREE_TYPE (type
), 0, 0, context_die
);
11110 /* Generate the DIE for the compilation unit. */
11113 gen_compile_unit_die (const char *filename
)
11116 char producer
[250];
11117 const char *language_string
= lang_hooks
.name
;
11120 die
= new_die (DW_TAG_compile_unit
, NULL
, NULL
);
11124 add_name_attribute (die
, filename
);
11125 /* Don't add cwd for <built-in>. */
11126 if (filename
[0] != DIR_SEPARATOR
&& filename
[0] != '<')
11127 add_comp_dir_attribute (die
);
11130 sprintf (producer
, "%s %s", language_string
, version_string
);
11132 #ifdef MIPS_DEBUGGING_INFO
11133 /* The MIPS/SGI compilers place the 'cc' command line options in the producer
11134 string. The SGI debugger looks for -g, -g1, -g2, or -g3; if they do
11135 not appear in the producer string, the debugger reaches the conclusion
11136 that the object file is stripped and has no debugging information.
11137 To get the MIPS/SGI debugger to believe that there is debugging
11138 information in the object file, we add a -g to the producer string. */
11139 if (debug_info_level
> DINFO_LEVEL_TERSE
)
11140 strcat (producer
, " -g");
11143 add_AT_string (die
, DW_AT_producer
, producer
);
11145 if (strcmp (language_string
, "GNU C++") == 0)
11146 language
= DW_LANG_C_plus_plus
;
11147 else if (strcmp (language_string
, "GNU Ada") == 0)
11148 language
= DW_LANG_Ada95
;
11149 else if (strcmp (language_string
, "GNU F77") == 0)
11150 language
= DW_LANG_Fortran77
;
11151 else if (strcmp (language_string
, "GNU Pascal") == 0)
11152 language
= DW_LANG_Pascal83
;
11153 else if (strcmp (language_string
, "GNU Java") == 0)
11154 language
= DW_LANG_Java
;
11156 language
= DW_LANG_C89
;
11158 add_AT_unsigned (die
, DW_AT_language
, language
);
11162 /* Generate a DIE for a string type. */
11165 gen_string_type_die (tree type
, dw_die_ref context_die
)
11167 dw_die_ref type_die
11168 = new_die (DW_TAG_string_type
, scope_die_for (type
, context_die
), type
);
11170 equate_type_number_to_die (type
, type_die
);
11172 /* ??? Fudge the string length attribute for now.
11173 TODO: add string length info. */
11175 string_length_attribute (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)));
11176 bound_representation (upper_bound
, 0, 'u');
11180 /* Generate the DIE for a base class. */
11183 gen_inheritance_die (tree binfo
, tree access
, dw_die_ref context_die
)
11185 dw_die_ref die
= new_die (DW_TAG_inheritance
, context_die
, binfo
);
11187 add_type_attribute (die
, BINFO_TYPE (binfo
), 0, 0, context_die
);
11188 add_data_member_location_attribute (die
, binfo
);
11190 if (TREE_VIA_VIRTUAL (binfo
))
11191 add_AT_unsigned (die
, DW_AT_virtuality
, DW_VIRTUALITY_virtual
);
11193 if (access
== access_public_node
)
11194 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_public
);
11195 else if (access
== access_protected_node
)
11196 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_protected
);
11199 /* Generate a DIE for a class member. */
11202 gen_member_die (tree type
, dw_die_ref context_die
)
11205 tree binfo
= TYPE_BINFO (type
);
11208 /* If this is not an incomplete type, output descriptions of each of its
11209 members. Note that as we output the DIEs necessary to represent the
11210 members of this record or union type, we will also be trying to output
11211 DIEs to represent the *types* of those members. However the `type'
11212 function (above) will specifically avoid generating type DIEs for member
11213 types *within* the list of member DIEs for this (containing) type except
11214 for those types (of members) which are explicitly marked as also being
11215 members of this (containing) type themselves. The g++ front- end can
11216 force any given type to be treated as a member of some other (containing)
11217 type by setting the TYPE_CONTEXT of the given (member) type to point to
11218 the TREE node representing the appropriate (containing) type. */
11220 /* First output info about the base classes. */
11221 if (binfo
&& BINFO_BASETYPES (binfo
))
11223 tree bases
= BINFO_BASETYPES (binfo
);
11224 tree accesses
= BINFO_BASEACCESSES (binfo
);
11225 int n_bases
= TREE_VEC_LENGTH (bases
);
11228 for (i
= 0; i
< n_bases
; i
++)
11229 gen_inheritance_die (TREE_VEC_ELT (bases
, i
),
11230 (accesses
? TREE_VEC_ELT (accesses
, i
)
11231 : access_public_node
), context_die
);
11234 /* Now output info about the data members and type members. */
11235 for (member
= TYPE_FIELDS (type
); member
; member
= TREE_CHAIN (member
))
11237 /* If we thought we were generating minimal debug info for TYPE
11238 and then changed our minds, some of the member declarations
11239 may have already been defined. Don't define them again, but
11240 do put them in the right order. */
11242 child
= lookup_decl_die (member
);
11244 splice_child_die (context_die
, child
);
11246 gen_decl_die (member
, context_die
);
11249 /* Now output info about the function members (if any). */
11250 for (member
= TYPE_METHODS (type
); member
; member
= TREE_CHAIN (member
))
11252 /* Don't include clones in the member list. */
11253 if (DECL_ABSTRACT_ORIGIN (member
))
11256 child
= lookup_decl_die (member
);
11258 splice_child_die (context_die
, child
);
11260 gen_decl_die (member
, context_die
);
11264 /* Generate a DIE for a structure or union type. If TYPE_DECL_SUPPRESS_DEBUG
11265 is set, we pretend that the type was never defined, so we only get the
11266 member DIEs needed by later specification DIEs. */
11269 gen_struct_or_union_type_die (tree type
, dw_die_ref context_die
)
11271 dw_die_ref type_die
= lookup_type_die (type
);
11272 dw_die_ref scope_die
= 0;
11274 int complete
= (TYPE_SIZE (type
)
11275 && (! TYPE_STUB_DECL (type
)
11276 || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type
))));
11278 if (type_die
&& ! complete
)
11281 if (TYPE_CONTEXT (type
) != NULL_TREE
11282 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type
)))
11285 scope_die
= scope_die_for (type
, context_die
);
11287 if (! type_die
|| (nested
&& scope_die
== comp_unit_die
))
11288 /* First occurrence of type or toplevel definition of nested class. */
11290 dw_die_ref old_die
= type_die
;
11292 type_die
= new_die (TREE_CODE (type
) == RECORD_TYPE
11293 ? DW_TAG_structure_type
: DW_TAG_union_type
,
11295 equate_type_number_to_die (type
, type_die
);
11297 add_AT_die_ref (type_die
, DW_AT_specification
, old_die
);
11299 add_name_attribute (type_die
, type_tag (type
));
11302 remove_AT (type_die
, DW_AT_declaration
);
11304 /* If this type has been completed, then give it a byte_size attribute and
11305 then give a list of members. */
11308 /* Prevent infinite recursion in cases where the type of some member of
11309 this type is expressed in terms of this type itself. */
11310 TREE_ASM_WRITTEN (type
) = 1;
11311 add_byte_size_attribute (type_die
, type
);
11312 if (TYPE_STUB_DECL (type
) != NULL_TREE
)
11313 add_src_coords_attributes (type_die
, TYPE_STUB_DECL (type
));
11315 /* If the first reference to this type was as the return type of an
11316 inline function, then it may not have a parent. Fix this now. */
11317 if (type_die
->die_parent
== NULL
)
11318 add_child_die (scope_die
, type_die
);
11320 push_decl_scope (type
);
11321 gen_member_die (type
, type_die
);
11324 /* GNU extension: Record what type our vtable lives in. */
11325 if (TYPE_VFIELD (type
))
11327 tree vtype
= DECL_FCONTEXT (TYPE_VFIELD (type
));
11329 gen_type_die (vtype
, context_die
);
11330 add_AT_die_ref (type_die
, DW_AT_containing_type
,
11331 lookup_type_die (vtype
));
11336 add_AT_flag (type_die
, DW_AT_declaration
, 1);
11338 /* We don't need to do this for function-local types. */
11339 if (TYPE_STUB_DECL (type
)
11340 && ! decl_function_context (TYPE_STUB_DECL (type
)))
11341 VARRAY_PUSH_TREE (incomplete_types
, type
);
11345 /* Generate a DIE for a subroutine _type_. */
11348 gen_subroutine_type_die (tree type
, dw_die_ref context_die
)
11350 tree return_type
= TREE_TYPE (type
);
11351 dw_die_ref subr_die
11352 = new_die (DW_TAG_subroutine_type
,
11353 scope_die_for (type
, context_die
), type
);
11355 equate_type_number_to_die (type
, subr_die
);
11356 add_prototyped_attribute (subr_die
, type
);
11357 add_type_attribute (subr_die
, return_type
, 0, 0, context_die
);
11358 gen_formal_types_die (type
, subr_die
);
11361 /* Generate a DIE for a type definition. */
11364 gen_typedef_die (tree decl
, dw_die_ref context_die
)
11366 dw_die_ref type_die
;
11369 if (TREE_ASM_WRITTEN (decl
))
11372 TREE_ASM_WRITTEN (decl
) = 1;
11373 type_die
= new_die (DW_TAG_typedef
, context_die
, decl
);
11374 origin
= decl_ultimate_origin (decl
);
11375 if (origin
!= NULL
)
11376 add_abstract_origin_attribute (type_die
, origin
);
11381 add_name_and_src_coords_attributes (type_die
, decl
);
11382 if (DECL_ORIGINAL_TYPE (decl
))
11384 type
= DECL_ORIGINAL_TYPE (decl
);
11386 if (type
== TREE_TYPE (decl
))
11389 equate_type_number_to_die (TREE_TYPE (decl
), type_die
);
11392 type
= TREE_TYPE (decl
);
11394 add_type_attribute (type_die
, type
, TREE_READONLY (decl
),
11395 TREE_THIS_VOLATILE (decl
), context_die
);
11398 if (DECL_ABSTRACT (decl
))
11399 equate_decl_number_to_die (decl
, type_die
);
11402 /* Generate a type description DIE. */
11405 gen_type_die (tree type
, dw_die_ref context_die
)
11409 if (type
== NULL_TREE
|| type
== error_mark_node
)
11412 if (TYPE_NAME (type
) && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
11413 && DECL_ORIGINAL_TYPE (TYPE_NAME (type
)))
11415 if (TREE_ASM_WRITTEN (type
))
11418 /* Prevent broken recursion; we can't hand off to the same type. */
11419 if (DECL_ORIGINAL_TYPE (TYPE_NAME (type
)) == type
)
11422 TREE_ASM_WRITTEN (type
) = 1;
11423 gen_decl_die (TYPE_NAME (type
), context_die
);
11427 /* We are going to output a DIE to represent the unqualified version
11428 of this type (i.e. without any const or volatile qualifiers) so
11429 get the main variant (i.e. the unqualified version) of this type
11430 now. (Vectors are special because the debugging info is in the
11431 cloned type itself). */
11432 if (TREE_CODE (type
) != VECTOR_TYPE
)
11433 type
= type_main_variant (type
);
11435 if (TREE_ASM_WRITTEN (type
))
11438 switch (TREE_CODE (type
))
11444 case REFERENCE_TYPE
:
11445 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This
11446 ensures that the gen_type_die recursion will terminate even if the
11447 type is recursive. Recursive types are possible in Ada. */
11448 /* ??? We could perhaps do this for all types before the switch
11450 TREE_ASM_WRITTEN (type
) = 1;
11452 /* For these types, all that is required is that we output a DIE (or a
11453 set of DIEs) to represent the "basis" type. */
11454 gen_type_die (TREE_TYPE (type
), context_die
);
11458 /* This code is used for C++ pointer-to-data-member types.
11459 Output a description of the relevant class type. */
11460 gen_type_die (TYPE_OFFSET_BASETYPE (type
), context_die
);
11462 /* Output a description of the type of the object pointed to. */
11463 gen_type_die (TREE_TYPE (type
), context_die
);
11465 /* Now output a DIE to represent this pointer-to-data-member type
11467 gen_ptr_to_mbr_type_die (type
, context_die
);
11471 gen_type_die (TYPE_DOMAIN (type
), context_die
);
11472 gen_set_type_die (type
, context_die
);
11476 gen_type_die (TREE_TYPE (type
), context_die
);
11477 abort (); /* No way to represent these in Dwarf yet! */
11480 case FUNCTION_TYPE
:
11481 /* Force out return type (in case it wasn't forced out already). */
11482 gen_type_die (TREE_TYPE (type
), context_die
);
11483 gen_subroutine_type_die (type
, context_die
);
11487 /* Force out return type (in case it wasn't forced out already). */
11488 gen_type_die (TREE_TYPE (type
), context_die
);
11489 gen_subroutine_type_die (type
, context_die
);
11493 if (TYPE_STRING_FLAG (type
) && TREE_CODE (TREE_TYPE (type
)) == CHAR_TYPE
)
11495 gen_type_die (TREE_TYPE (type
), context_die
);
11496 gen_string_type_die (type
, context_die
);
11499 gen_array_type_die (type
, context_die
);
11503 gen_array_type_die (type
, context_die
);
11506 case ENUMERAL_TYPE
:
11509 case QUAL_UNION_TYPE
:
11510 /* If this is a nested type whose containing class hasn't been written
11511 out yet, writing it out will cover this one, too. This does not apply
11512 to instantiations of member class templates; they need to be added to
11513 the containing class as they are generated. FIXME: This hurts the
11514 idea of combining type decls from multiple TUs, since we can't predict
11515 what set of template instantiations we'll get. */
11516 if (TYPE_CONTEXT (type
)
11517 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type
))
11518 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type
)))
11520 gen_type_die (TYPE_CONTEXT (type
), context_die
);
11522 if (TREE_ASM_WRITTEN (type
))
11525 /* If that failed, attach ourselves to the stub. */
11526 push_decl_scope (TYPE_CONTEXT (type
));
11527 context_die
= lookup_type_die (TYPE_CONTEXT (type
));
11533 if (TREE_CODE (type
) == ENUMERAL_TYPE
)
11534 gen_enumeration_type_die (type
, context_die
);
11536 gen_struct_or_union_type_die (type
, context_die
);
11541 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
11542 it up if it is ever completed. gen_*_type_die will set it for us
11543 when appropriate. */
11552 /* No DIEs needed for fundamental types. */
11556 /* No Dwarf representation currently defined. */
11563 TREE_ASM_WRITTEN (type
) = 1;
11566 /* Generate a DIE for a tagged type instantiation. */
11569 gen_tagged_type_instantiation_die (tree type
, dw_die_ref context_die
)
11571 if (type
== NULL_TREE
|| type
== error_mark_node
)
11574 /* We are going to output a DIE to represent the unqualified version of
11575 this type (i.e. without any const or volatile qualifiers) so make sure
11576 that we have the main variant (i.e. the unqualified version) of this
11578 if (type
!= type_main_variant (type
))
11581 /* Do not check TREE_ASM_WRITTEN (type) as it may not be set if this is
11582 an instance of an unresolved type. */
11584 switch (TREE_CODE (type
))
11589 case ENUMERAL_TYPE
:
11590 gen_inlined_enumeration_type_die (type
, context_die
);
11594 gen_inlined_structure_type_die (type
, context_die
);
11598 case QUAL_UNION_TYPE
:
11599 gen_inlined_union_type_die (type
, context_die
);
11607 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
11608 things which are local to the given block. */
11611 gen_block_die (tree stmt
, dw_die_ref context_die
, int depth
)
11613 int must_output_die
= 0;
11616 enum tree_code origin_code
;
11618 /* Ignore blocks never really used to make RTL. */
11619 if (stmt
== NULL_TREE
|| !TREE_USED (stmt
)
11620 || (!TREE_ASM_WRITTEN (stmt
) && !BLOCK_ABSTRACT (stmt
)))
11623 /* If the block is one fragment of a non-contiguous block, do not
11624 process the variables, since they will have been done by the
11625 origin block. Do process subblocks. */
11626 if (BLOCK_FRAGMENT_ORIGIN (stmt
))
11630 for (sub
= BLOCK_SUBBLOCKS (stmt
); sub
; sub
= BLOCK_CHAIN (sub
))
11631 gen_block_die (sub
, context_die
, depth
+ 1);
11636 /* Determine the "ultimate origin" of this block. This block may be an
11637 inlined instance of an inlined instance of inline function, so we have
11638 to trace all of the way back through the origin chain to find out what
11639 sort of node actually served as the original seed for the creation of
11640 the current block. */
11641 origin
= block_ultimate_origin (stmt
);
11642 origin_code
= (origin
!= NULL
) ? TREE_CODE (origin
) : ERROR_MARK
;
11644 /* Determine if we need to output any Dwarf DIEs at all to represent this
11646 if (origin_code
== FUNCTION_DECL
)
11647 /* The outer scopes for inlinings *must* always be represented. We
11648 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */
11649 must_output_die
= 1;
11652 /* In the case where the current block represents an inlining of the
11653 "body block" of an inline function, we must *NOT* output any DIE for
11654 this block because we have already output a DIE to represent the whole
11655 inlined function scope and the "body block" of any function doesn't
11656 really represent a different scope according to ANSI C rules. So we
11657 check here to make sure that this block does not represent a "body
11658 block inlining" before trying to set the MUST_OUTPUT_DIE flag. */
11659 if (! is_body_block (origin
? origin
: stmt
))
11661 /* Determine if this block directly contains any "significant"
11662 local declarations which we will need to output DIEs for. */
11663 if (debug_info_level
> DINFO_LEVEL_TERSE
)
11664 /* We are not in terse mode so *any* local declaration counts
11665 as being a "significant" one. */
11666 must_output_die
= (BLOCK_VARS (stmt
) != NULL
);
11668 /* We are in terse mode, so only local (nested) function
11669 definitions count as "significant" local declarations. */
11670 for (decl
= BLOCK_VARS (stmt
);
11671 decl
!= NULL
; decl
= TREE_CHAIN (decl
))
11672 if (TREE_CODE (decl
) == FUNCTION_DECL
11673 && DECL_INITIAL (decl
))
11675 must_output_die
= 1;
11681 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
11682 DIE for any block which contains no significant local declarations at
11683 all. Rather, in such cases we just call `decls_for_scope' so that any
11684 needed Dwarf info for any sub-blocks will get properly generated. Note
11685 that in terse mode, our definition of what constitutes a "significant"
11686 local declaration gets restricted to include only inlined function
11687 instances and local (nested) function definitions. */
11688 if (must_output_die
)
11690 if (origin_code
== FUNCTION_DECL
)
11691 gen_inlined_subroutine_die (stmt
, context_die
, depth
);
11693 gen_lexical_block_die (stmt
, context_die
, depth
);
11696 decls_for_scope (stmt
, context_die
, depth
);
11699 /* Generate all of the decls declared within a given scope and (recursively)
11700 all of its sub-blocks. */
11703 decls_for_scope (tree stmt
, dw_die_ref context_die
, int depth
)
11708 /* Ignore blocks never really used to make RTL. */
11709 if (stmt
== NULL_TREE
|| ! TREE_USED (stmt
))
11712 /* Output the DIEs to represent all of the data objects and typedefs
11713 declared directly within this block but not within any nested
11714 sub-blocks. Also, nested function and tag DIEs have been
11715 generated with a parent of NULL; fix that up now. */
11716 for (decl
= BLOCK_VARS (stmt
); decl
!= NULL
; decl
= TREE_CHAIN (decl
))
11720 if (TREE_CODE (decl
) == FUNCTION_DECL
)
11721 die
= lookup_decl_die (decl
);
11722 else if (TREE_CODE (decl
) == TYPE_DECL
&& TYPE_DECL_IS_STUB (decl
))
11723 die
= lookup_type_die (TREE_TYPE (decl
));
11727 if (die
!= NULL
&& die
->die_parent
== NULL
)
11728 add_child_die (context_die
, die
);
11730 gen_decl_die (decl
, context_die
);
11733 /* If we're at -g1, we're not interested in subblocks. */
11734 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
11737 /* Output the DIEs to represent all sub-blocks (and the items declared
11738 therein) of this block. */
11739 for (subblocks
= BLOCK_SUBBLOCKS (stmt
);
11741 subblocks
= BLOCK_CHAIN (subblocks
))
11742 gen_block_die (subblocks
, context_die
, depth
+ 1);
11745 /* Is this a typedef we can avoid emitting? */
11748 is_redundant_typedef (tree decl
)
11750 if (TYPE_DECL_IS_STUB (decl
))
11753 if (DECL_ARTIFICIAL (decl
)
11754 && DECL_CONTEXT (decl
)
11755 && is_tagged_type (DECL_CONTEXT (decl
))
11756 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl
))) == TYPE_DECL
11757 && DECL_NAME (decl
) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl
))))
11758 /* Also ignore the artificial member typedef for the class name. */
11764 /* Generate Dwarf debug information for a decl described by DECL. */
11767 gen_decl_die (tree decl
, dw_die_ref context_die
)
11771 if (DECL_P (decl
) && DECL_IGNORED_P (decl
))
11774 switch (TREE_CODE (decl
))
11780 /* The individual enumerators of an enum type get output when we output
11781 the Dwarf representation of the relevant enum type itself. */
11784 case FUNCTION_DECL
:
11785 /* Don't output any DIEs to represent mere function declarations,
11786 unless they are class members or explicit block externs. */
11787 if (DECL_INITIAL (decl
) == NULL_TREE
&& DECL_CONTEXT (decl
) == NULL_TREE
11788 && (current_function_decl
== NULL_TREE
|| DECL_ARTIFICIAL (decl
)))
11791 /* If we're emitting a clone, emit info for the abstract instance. */
11792 if (DECL_ORIGIN (decl
) != decl
)
11793 dwarf2out_abstract_function (DECL_ABSTRACT_ORIGIN (decl
));
11795 /* If we're emitting an out-of-line copy of an inline function,
11796 emit info for the abstract instance and set up to refer to it. */
11797 else if (cgraph_function_possibly_inlined_p (decl
)
11798 && ! DECL_ABSTRACT (decl
)
11799 && ! class_scope_p (context_die
)
11800 /* dwarf2out_abstract_function won't emit a die if this is just
11801 a declaration. We must avoid setting DECL_ABSTRACT_ORIGIN in
11802 that case, because that works only if we have a die. */
11803 && DECL_INITIAL (decl
) != NULL_TREE
)
11805 dwarf2out_abstract_function (decl
);
11806 set_decl_origin_self (decl
);
11809 /* Otherwise we're emitting the primary DIE for this decl. */
11810 else if (debug_info_level
> DINFO_LEVEL_TERSE
)
11812 /* Before we describe the FUNCTION_DECL itself, make sure that we
11813 have described its return type. */
11814 gen_type_die (TREE_TYPE (TREE_TYPE (decl
)), context_die
);
11816 /* And its virtual context. */
11817 if (DECL_VINDEX (decl
) != NULL_TREE
)
11818 gen_type_die (DECL_CONTEXT (decl
), context_die
);
11820 /* And its containing type. */
11821 origin
= decl_class_context (decl
);
11822 if (origin
!= NULL_TREE
)
11823 gen_type_die_for_member (origin
, decl
, context_die
);
11826 /* Now output a DIE to represent the function itself. */
11827 gen_subprogram_die (decl
, context_die
);
11831 /* If we are in terse mode, don't generate any DIEs to represent any
11832 actual typedefs. */
11833 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
11836 /* In the special case of a TYPE_DECL node representing the declaration
11837 of some type tag, if the given TYPE_DECL is marked as having been
11838 instantiated from some other (original) TYPE_DECL node (e.g. one which
11839 was generated within the original definition of an inline function) we
11840 have to generate a special (abbreviated) DW_TAG_structure_type,
11841 DW_TAG_union_type, or DW_TAG_enumeration_type DIE here. */
11842 if (TYPE_DECL_IS_STUB (decl
) && decl_ultimate_origin (decl
) != NULL_TREE
)
11844 gen_tagged_type_instantiation_die (TREE_TYPE (decl
), context_die
);
11848 if (is_redundant_typedef (decl
))
11849 gen_type_die (TREE_TYPE (decl
), context_die
);
11851 /* Output a DIE to represent the typedef itself. */
11852 gen_typedef_die (decl
, context_die
);
11856 if (debug_info_level
>= DINFO_LEVEL_NORMAL
)
11857 gen_label_die (decl
, context_die
);
11861 /* If we are in terse mode, don't generate any DIEs to represent any
11862 variable declarations or definitions. */
11863 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
11866 /* Output any DIEs that are needed to specify the type of this data
11868 gen_type_die (TREE_TYPE (decl
), context_die
);
11870 /* And its containing type. */
11871 origin
= decl_class_context (decl
);
11872 if (origin
!= NULL_TREE
)
11873 gen_type_die_for_member (origin
, decl
, context_die
);
11875 /* Now output the DIE to represent the data object itself. This gets
11876 complicated because of the possibility that the VAR_DECL really
11877 represents an inlined instance of a formal parameter for an inline
11879 origin
= decl_ultimate_origin (decl
);
11880 if (origin
!= NULL_TREE
&& TREE_CODE (origin
) == PARM_DECL
)
11881 gen_formal_parameter_die (decl
, context_die
);
11883 gen_variable_die (decl
, context_die
);
11887 /* Ignore the nameless fields that are used to skip bits but handle C++
11888 anonymous unions. */
11889 if (DECL_NAME (decl
) != NULL_TREE
11890 || TREE_CODE (TREE_TYPE (decl
)) == UNION_TYPE
)
11892 gen_type_die (member_declared_type (decl
), context_die
);
11893 gen_field_die (decl
, context_die
);
11898 gen_type_die (TREE_TYPE (decl
), context_die
);
11899 gen_formal_parameter_die (decl
, context_die
);
11902 case NAMESPACE_DECL
:
11903 /* Ignore for now. */
11907 if ((int)TREE_CODE (decl
) > NUM_TREE_CODES
)
11908 /* Probably some frontend-internal decl. Assume we don't care. */
11914 /* Add Ada "use" clause information for SGI Workshop debugger. */
11917 dwarf2out_add_library_unit_info (const char *filename
, const char *context_list
)
11919 unsigned int file_index
;
11921 if (filename
!= NULL
)
11923 dw_die_ref unit_die
= new_die (DW_TAG_module
, comp_unit_die
, NULL
);
11924 tree context_list_decl
11925 = build_decl (LABEL_DECL
, get_identifier (context_list
),
11928 TREE_PUBLIC (context_list_decl
) = TRUE
;
11929 add_name_attribute (unit_die
, context_list
);
11930 file_index
= lookup_filename (filename
);
11931 add_AT_unsigned (unit_die
, DW_AT_decl_file
, file_index
);
11932 add_pubname (context_list_decl
, unit_die
);
11936 /* Output debug information for global decl DECL. Called from toplev.c after
11937 compilation proper has finished. */
11940 dwarf2out_global_decl (tree decl
)
11942 /* Output DWARF2 information for file-scope tentative data object
11943 declarations, file-scope (extern) function declarations (which had no
11944 corresponding body) and file-scope tagged type declarations and
11945 definitions which have not yet been forced out. */
11946 if (TREE_CODE (decl
) != FUNCTION_DECL
|| !DECL_INITIAL (decl
))
11947 dwarf2out_decl (decl
);
11950 /* Write the debugging output for DECL. */
11953 dwarf2out_decl (tree decl
)
11955 dw_die_ref context_die
= comp_unit_die
;
11957 switch (TREE_CODE (decl
))
11962 case FUNCTION_DECL
:
11963 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration of a
11964 builtin function. Explicit programmer-supplied declarations of
11965 these same functions should NOT be ignored however. */
11966 if (DECL_EXTERNAL (decl
) && DECL_BUILT_IN (decl
))
11969 /* What we would really like to do here is to filter out all mere
11970 file-scope declarations of file-scope functions which are never
11971 referenced later within this translation unit (and keep all of ones
11972 that *are* referenced later on) but we aren't clairvoyant, so we have
11973 no idea which functions will be referenced in the future (i.e. later
11974 on within the current translation unit). So here we just ignore all
11975 file-scope function declarations which are not also definitions. If
11976 and when the debugger needs to know something about these functions,
11977 it will have to hunt around and find the DWARF information associated
11978 with the definition of the function.
11980 We can't just check DECL_EXTERNAL to find out which FUNCTION_DECL
11981 nodes represent definitions and which ones represent mere
11982 declarations. We have to check DECL_INITIAL instead. That's because
11983 the C front-end supports some weird semantics for "extern inline"
11984 function definitions. These can get inlined within the current
11985 translation unit (an thus, we need to generate Dwarf info for their
11986 abstract instances so that the Dwarf info for the concrete inlined
11987 instances can have something to refer to) but the compiler never
11988 generates any out-of-lines instances of such things (despite the fact
11989 that they *are* definitions).
11991 The important point is that the C front-end marks these "extern
11992 inline" functions as DECL_EXTERNAL, but we need to generate DWARF for
11993 them anyway. Note that the C++ front-end also plays some similar games
11994 for inline function definitions appearing within include files which
11995 also contain `#pragma interface' pragmas. */
11996 if (DECL_INITIAL (decl
) == NULL_TREE
)
11999 /* If we're a nested function, initially use a parent of NULL; if we're
12000 a plain function, this will be fixed up in decls_for_scope. If
12001 we're a method, it will be ignored, since we already have a DIE. */
12002 if (decl_function_context (decl
)
12003 /* But if we're in terse mode, we don't care about scope. */
12004 && debug_info_level
> DINFO_LEVEL_TERSE
)
12005 context_die
= NULL
;
12009 /* Ignore this VAR_DECL if it refers to a file-scope extern data object
12010 declaration and if the declaration was never even referenced from
12011 within this entire compilation unit. We suppress these DIEs in
12012 order to save space in the .debug section (by eliminating entries
12013 which are probably useless). Note that we must not suppress
12014 block-local extern declarations (whether used or not) because that
12015 would screw-up the debugger's name lookup mechanism and cause it to
12016 miss things which really ought to be in scope at a given point. */
12017 if (DECL_EXTERNAL (decl
) && !TREE_USED (decl
))
12020 /* If we are in terse mode, don't generate any DIEs to represent any
12021 variable declarations or definitions. */
12022 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
12027 /* Don't emit stubs for types unless they are needed by other DIEs. */
12028 if (TYPE_DECL_SUPPRESS_DEBUG (decl
))
12031 /* Don't bother trying to generate any DIEs to represent any of the
12032 normal built-in types for the language we are compiling. */
12033 if (DECL_SOURCE_LINE (decl
) == 0)
12035 /* OK, we need to generate one for `bool' so GDB knows what type
12036 comparisons have. */
12037 if ((get_AT_unsigned (comp_unit_die
, DW_AT_language
)
12038 == DW_LANG_C_plus_plus
)
12039 && TREE_CODE (TREE_TYPE (decl
)) == BOOLEAN_TYPE
12040 && ! DECL_IGNORED_P (decl
))
12041 modified_type_die (TREE_TYPE (decl
), 0, 0, NULL
);
12046 /* If we are in terse mode, don't generate any DIEs for types. */
12047 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
12050 /* If we're a function-scope tag, initially use a parent of NULL;
12051 this will be fixed up in decls_for_scope. */
12052 if (decl_function_context (decl
))
12053 context_die
= NULL
;
12061 gen_decl_die (decl
, context_die
);
12064 /* Output a marker (i.e. a label) for the beginning of the generated code for
12065 a lexical block. */
12068 dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED
,
12069 unsigned int blocknum
)
12071 function_section (current_function_decl
);
12072 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, BLOCK_BEGIN_LABEL
, blocknum
);
12075 /* Output a marker (i.e. a label) for the end of the generated code for a
12079 dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED
, unsigned int blocknum
)
12081 function_section (current_function_decl
);
12082 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, BLOCK_END_LABEL
, blocknum
);
12085 /* Returns nonzero if it is appropriate not to emit any debugging
12086 information for BLOCK, because it doesn't contain any instructions.
12088 Don't allow this for blocks with nested functions or local classes
12089 as we would end up with orphans, and in the presence of scheduling
12090 we may end up calling them anyway. */
12093 dwarf2out_ignore_block (tree block
)
12097 for (decl
= BLOCK_VARS (block
); decl
; decl
= TREE_CHAIN (decl
))
12098 if (TREE_CODE (decl
) == FUNCTION_DECL
12099 || (TREE_CODE (decl
) == TYPE_DECL
&& TYPE_DECL_IS_STUB (decl
)))
12105 /* Lookup FILE_NAME (in the list of filenames that we know about here in
12106 dwarf2out.c) and return its "index". The index of each (known) filename is
12107 just a unique number which is associated with only that one filename. We
12108 need such numbers for the sake of generating labels (in the .debug_sfnames
12109 section) and references to those files numbers (in the .debug_srcinfo
12110 and.debug_macinfo sections). If the filename given as an argument is not
12111 found in our current list, add it to the list and assign it the next
12112 available unique index number. In order to speed up searches, we remember
12113 the index of the filename was looked up last. This handles the majority of
12117 lookup_filename (const char *file_name
)
12120 char *save_file_name
;
12122 /* Check to see if the file name that was searched on the previous
12123 call matches this file name. If so, return the index. */
12124 if (file_table_last_lookup_index
!= 0)
12127 = VARRAY_CHAR_PTR (file_table
, file_table_last_lookup_index
);
12128 if (strcmp (file_name
, last
) == 0)
12129 return file_table_last_lookup_index
;
12132 /* Didn't match the previous lookup, search the table */
12133 n
= VARRAY_ACTIVE_SIZE (file_table
);
12134 for (i
= 1; i
< n
; i
++)
12135 if (strcmp (file_name
, VARRAY_CHAR_PTR (file_table
, i
)) == 0)
12137 file_table_last_lookup_index
= i
;
12141 /* Add the new entry to the end of the filename table. */
12142 file_table_last_lookup_index
= n
;
12143 save_file_name
= (char *) ggc_strdup (file_name
);
12144 VARRAY_PUSH_CHAR_PTR (file_table
, save_file_name
);
12145 VARRAY_PUSH_UINT (file_table_emitted
, 0);
12151 maybe_emit_file (int fileno
)
12153 if (DWARF2_ASM_LINE_DEBUG_INFO
&& fileno
> 0)
12155 if (!VARRAY_UINT (file_table_emitted
, fileno
))
12157 VARRAY_UINT (file_table_emitted
, fileno
) = ++emitcount
;
12158 fprintf (asm_out_file
, "\t.file %u ",
12159 VARRAY_UINT (file_table_emitted
, fileno
));
12160 output_quoted_string (asm_out_file
,
12161 VARRAY_CHAR_PTR (file_table
, fileno
));
12162 fputc ('\n', asm_out_file
);
12164 return VARRAY_UINT (file_table_emitted
, fileno
);
12171 init_file_table (void)
12173 /* Allocate the initial hunk of the file_table. */
12174 VARRAY_CHAR_PTR_INIT (file_table
, 64, "file_table");
12175 VARRAY_UINT_INIT (file_table_emitted
, 64, "file_table_emitted");
12177 /* Skip the first entry - file numbers begin at 1. */
12178 VARRAY_PUSH_CHAR_PTR (file_table
, NULL
);
12179 VARRAY_PUSH_UINT (file_table_emitted
, 0);
12180 file_table_last_lookup_index
= 0;
12183 /* Output a label to mark the beginning of a source code line entry
12184 and record information relating to this source line, in
12185 'line_info_table' for later output of the .debug_line section. */
12188 dwarf2out_source_line (unsigned int line
, const char *filename
)
12190 if (debug_info_level
>= DINFO_LEVEL_NORMAL
12193 function_section (current_function_decl
);
12195 /* If requested, emit something human-readable. */
12196 if (flag_debug_asm
)
12197 fprintf (asm_out_file
, "\t%s %s:%d\n", ASM_COMMENT_START
,
12200 if (DWARF2_ASM_LINE_DEBUG_INFO
)
12202 unsigned file_num
= lookup_filename (filename
);
12204 file_num
= maybe_emit_file (file_num
);
12206 /* Emit the .loc directive understood by GNU as. */
12207 fprintf (asm_out_file
, "\t.loc %d %d 0\n", file_num
, line
);
12209 /* Indicate that line number info exists. */
12210 line_info_table_in_use
++;
12212 /* Indicate that multiple line number tables exist. */
12213 if (DECL_SECTION_NAME (current_function_decl
))
12214 separate_line_info_table_in_use
++;
12216 else if (DECL_SECTION_NAME (current_function_decl
))
12218 dw_separate_line_info_ref line_info
;
12219 (*targetm
.asm_out
.internal_label
) (asm_out_file
, SEPARATE_LINE_CODE_LABEL
,
12220 separate_line_info_table_in_use
);
12222 /* expand the line info table if necessary */
12223 if (separate_line_info_table_in_use
12224 == separate_line_info_table_allocated
)
12226 separate_line_info_table_allocated
+= LINE_INFO_TABLE_INCREMENT
;
12227 separate_line_info_table
12228 = ggc_realloc (separate_line_info_table
,
12229 separate_line_info_table_allocated
12230 * sizeof (dw_separate_line_info_entry
));
12231 memset (separate_line_info_table
12232 + separate_line_info_table_in_use
,
12234 (LINE_INFO_TABLE_INCREMENT
12235 * sizeof (dw_separate_line_info_entry
)));
12238 /* Add the new entry at the end of the line_info_table. */
12240 = &separate_line_info_table
[separate_line_info_table_in_use
++];
12241 line_info
->dw_file_num
= lookup_filename (filename
);
12242 line_info
->dw_line_num
= line
;
12243 line_info
->function
= current_function_funcdef_no
;
12247 dw_line_info_ref line_info
;
12249 (*targetm
.asm_out
.internal_label
) (asm_out_file
, LINE_CODE_LABEL
,
12250 line_info_table_in_use
);
12252 /* Expand the line info table if necessary. */
12253 if (line_info_table_in_use
== line_info_table_allocated
)
12255 line_info_table_allocated
+= LINE_INFO_TABLE_INCREMENT
;
12257 = ggc_realloc (line_info_table
,
12258 (line_info_table_allocated
12259 * sizeof (dw_line_info_entry
)));
12260 memset (line_info_table
+ line_info_table_in_use
, 0,
12261 LINE_INFO_TABLE_INCREMENT
* sizeof (dw_line_info_entry
));
12264 /* Add the new entry at the end of the line_info_table. */
12265 line_info
= &line_info_table
[line_info_table_in_use
++];
12266 line_info
->dw_file_num
= lookup_filename (filename
);
12267 line_info
->dw_line_num
= line
;
12272 /* Record the beginning of a new source file. */
12275 dwarf2out_start_source_file (unsigned int lineno
, const char *filename
)
12277 if (flag_eliminate_dwarf2_dups
)
12279 /* Record the beginning of the file for break_out_includes. */
12280 dw_die_ref bincl_die
;
12282 bincl_die
= new_die (DW_TAG_GNU_BINCL
, comp_unit_die
, NULL
);
12283 add_AT_string (bincl_die
, DW_AT_name
, filename
);
12286 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
12288 named_section_flags (DEBUG_MACINFO_SECTION
, SECTION_DEBUG
);
12289 dw2_asm_output_data (1, DW_MACINFO_start_file
, "Start new file");
12290 dw2_asm_output_data_uleb128 (lineno
, "Included from line number %d",
12292 maybe_emit_file (lookup_filename (filename
));
12293 dw2_asm_output_data_uleb128 (lookup_filename (filename
),
12294 "Filename we just started");
12298 /* Record the end of a source file. */
12301 dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED
)
12303 if (flag_eliminate_dwarf2_dups
)
12304 /* Record the end of the file for break_out_includes. */
12305 new_die (DW_TAG_GNU_EINCL
, comp_unit_die
, NULL
);
12307 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
12309 named_section_flags (DEBUG_MACINFO_SECTION
, SECTION_DEBUG
);
12310 dw2_asm_output_data (1, DW_MACINFO_end_file
, "End file");
12314 /* Called from debug_define in toplev.c. The `buffer' parameter contains
12315 the tail part of the directive line, i.e. the part which is past the
12316 initial whitespace, #, whitespace, directive-name, whitespace part. */
12319 dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED
,
12320 const char *buffer ATTRIBUTE_UNUSED
)
12322 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
12324 named_section_flags (DEBUG_MACINFO_SECTION
, SECTION_DEBUG
);
12325 dw2_asm_output_data (1, DW_MACINFO_define
, "Define macro");
12326 dw2_asm_output_data_uleb128 (lineno
, "At line number %d", lineno
);
12327 dw2_asm_output_nstring (buffer
, -1, "The macro");
12331 /* Called from debug_undef in toplev.c. The `buffer' parameter contains
12332 the tail part of the directive line, i.e. the part which is past the
12333 initial whitespace, #, whitespace, directive-name, whitespace part. */
12336 dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED
,
12337 const char *buffer ATTRIBUTE_UNUSED
)
12339 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
12341 named_section_flags (DEBUG_MACINFO_SECTION
, SECTION_DEBUG
);
12342 dw2_asm_output_data (1, DW_MACINFO_undef
, "Undefine macro");
12343 dw2_asm_output_data_uleb128 (lineno
, "At line number %d", lineno
);
12344 dw2_asm_output_nstring (buffer
, -1, "The macro");
12348 /* Set up for Dwarf output at the start of compilation. */
12351 dwarf2out_init (const char *filename ATTRIBUTE_UNUSED
)
12353 init_file_table ();
12355 /* Allocate the initial hunk of the decl_die_table. */
12356 decl_die_table
= ggc_alloc_cleared (DECL_DIE_TABLE_INCREMENT
12357 * sizeof (dw_die_ref
));
12358 decl_die_table_allocated
= DECL_DIE_TABLE_INCREMENT
;
12359 decl_die_table_in_use
= 0;
12361 /* Allocate the initial hunk of the decl_scope_table. */
12362 VARRAY_TREE_INIT (decl_scope_table
, 256, "decl_scope_table");
12364 /* Allocate the initial hunk of the abbrev_die_table. */
12365 abbrev_die_table
= ggc_alloc_cleared (ABBREV_DIE_TABLE_INCREMENT
12366 * sizeof (dw_die_ref
));
12367 abbrev_die_table_allocated
= ABBREV_DIE_TABLE_INCREMENT
;
12368 /* Zero-th entry is allocated, but unused */
12369 abbrev_die_table_in_use
= 1;
12371 /* Allocate the initial hunk of the line_info_table. */
12372 line_info_table
= ggc_alloc_cleared (LINE_INFO_TABLE_INCREMENT
12373 * sizeof (dw_line_info_entry
));
12374 line_info_table_allocated
= LINE_INFO_TABLE_INCREMENT
;
12376 /* Zero-th entry is allocated, but unused */
12377 line_info_table_in_use
= 1;
12379 /* Generate the initial DIE for the .debug section. Note that the (string)
12380 value given in the DW_AT_name attribute of the DW_TAG_compile_unit DIE
12381 will (typically) be a relative pathname and that this pathname should be
12382 taken as being relative to the directory from which the compiler was
12383 invoked when the given (base) source file was compiled. We will fill
12384 in this value in dwarf2out_finish. */
12385 comp_unit_die
= gen_compile_unit_die (NULL
);
12387 VARRAY_TREE_INIT (incomplete_types
, 64, "incomplete_types");
12389 VARRAY_RTX_INIT (used_rtx_varray
, 32, "used_rtx_varray");
12391 ASM_GENERATE_INTERNAL_LABEL (text_end_label
, TEXT_END_LABEL
, 0);
12392 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label
,
12393 DEBUG_ABBREV_SECTION_LABEL
, 0);
12394 if (DWARF2_GENERATE_TEXT_SECTION_LABEL
)
12395 ASM_GENERATE_INTERNAL_LABEL (text_section_label
, TEXT_SECTION_LABEL
, 0);
12397 strcpy (text_section_label
, stripattributes (TEXT_SECTION_NAME
));
12399 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label
,
12400 DEBUG_INFO_SECTION_LABEL
, 0);
12401 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label
,
12402 DEBUG_LINE_SECTION_LABEL
, 0);
12403 ASM_GENERATE_INTERNAL_LABEL (ranges_section_label
,
12404 DEBUG_RANGES_SECTION_LABEL
, 0);
12405 named_section_flags (DEBUG_ABBREV_SECTION
, SECTION_DEBUG
);
12406 ASM_OUTPUT_LABEL (asm_out_file
, abbrev_section_label
);
12407 named_section_flags (DEBUG_INFO_SECTION
, SECTION_DEBUG
);
12408 ASM_OUTPUT_LABEL (asm_out_file
, debug_info_section_label
);
12409 named_section_flags (DEBUG_LINE_SECTION
, SECTION_DEBUG
);
12410 ASM_OUTPUT_LABEL (asm_out_file
, debug_line_section_label
);
12412 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
12414 named_section_flags (DEBUG_MACINFO_SECTION
, SECTION_DEBUG
);
12415 ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label
,
12416 DEBUG_MACINFO_SECTION_LABEL
, 0);
12417 ASM_OUTPUT_LABEL (asm_out_file
, macinfo_section_label
);
12420 if (DWARF2_GENERATE_TEXT_SECTION_LABEL
)
12423 ASM_OUTPUT_LABEL (asm_out_file
, text_section_label
);
12427 /* A helper function for dwarf2out_finish called through
12428 ht_forall. Emit one queued .debug_str string. */
12431 output_indirect_string (void **h
, void *v ATTRIBUTE_UNUSED
)
12433 struct indirect_string_node
*node
= (struct indirect_string_node
*) *h
;
12435 if (node
->form
== DW_FORM_strp
)
12437 named_section_flags (DEBUG_STR_SECTION
, DEBUG_STR_SECTION_FLAGS
);
12438 ASM_OUTPUT_LABEL (asm_out_file
, node
->label
);
12439 assemble_string (node
->str
, strlen (node
->str
) + 1);
12447 /* Clear the marks for a die and its children.
12448 Be cool if the mark isn't set. */
12451 prune_unmark_dies (dw_die_ref die
)
12455 for (c
= die
->die_child
; c
; c
= c
->die_sib
)
12456 prune_unmark_dies (c
);
12460 /* Given DIE that we're marking as used, find any other dies
12461 it references as attributes and mark them as used. */
12464 prune_unused_types_walk_attribs (dw_die_ref die
)
12468 for (a
= die
->die_attr
; a
!= NULL
; a
= a
->dw_attr_next
)
12470 if (a
->dw_attr_val
.val_class
== dw_val_class_die_ref
)
12472 /* A reference to another DIE.
12473 Make sure that it will get emitted. */
12474 prune_unused_types_mark (a
->dw_attr_val
.v
.val_die_ref
.die
, 1);
12476 else if (a
->dw_attr
== DW_AT_decl_file
)
12478 /* A reference to a file. Make sure the file name is emitted. */
12479 a
->dw_attr_val
.v
.val_unsigned
=
12480 maybe_emit_file (a
->dw_attr_val
.v
.val_unsigned
);
12486 /* Mark DIE as being used. If DOKIDS is true, then walk down
12487 to DIE's children. */
12490 prune_unused_types_mark (dw_die_ref die
, int dokids
)
12494 if (die
->die_mark
== 0)
12496 /* We haven't done this node yet. Mark it as used. */
12499 /* We also have to mark its parents as used.
12500 (But we don't want to mark our parents' kids due to this.) */
12501 if (die
->die_parent
)
12502 prune_unused_types_mark (die
->die_parent
, 0);
12504 /* Mark any referenced nodes. */
12505 prune_unused_types_walk_attribs (die
);
12508 if (dokids
&& die
->die_mark
!= 2)
12510 /* We need to walk the children, but haven't done so yet.
12511 Remember that we've walked the kids. */
12515 for (c
= die
->die_child
; c
; c
= c
->die_sib
)
12517 /* If this is an array type, we need to make sure our
12518 kids get marked, even if they're types. */
12519 if (die
->die_tag
== DW_TAG_array_type
)
12520 prune_unused_types_mark (c
, 1);
12522 prune_unused_types_walk (c
);
12528 /* Walk the tree DIE and mark types that we actually use. */
12531 prune_unused_types_walk (dw_die_ref die
)
12535 /* Don't do anything if this node is already marked. */
12539 switch (die
->die_tag
) {
12540 case DW_TAG_const_type
:
12541 case DW_TAG_packed_type
:
12542 case DW_TAG_pointer_type
:
12543 case DW_TAG_reference_type
:
12544 case DW_TAG_volatile_type
:
12545 case DW_TAG_typedef
:
12546 case DW_TAG_array_type
:
12547 case DW_TAG_structure_type
:
12548 case DW_TAG_union_type
:
12549 case DW_TAG_class_type
:
12550 case DW_TAG_friend
:
12551 case DW_TAG_variant_part
:
12552 case DW_TAG_enumeration_type
:
12553 case DW_TAG_subroutine_type
:
12554 case DW_TAG_string_type
:
12555 case DW_TAG_set_type
:
12556 case DW_TAG_subrange_type
:
12557 case DW_TAG_ptr_to_member_type
:
12558 case DW_TAG_file_type
:
12559 /* It's a type node --- don't mark it. */
12563 /* Mark everything else. */
12569 /* Now, mark any dies referenced from here. */
12570 prune_unused_types_walk_attribs (die
);
12572 /* Mark children. */
12573 for (c
= die
->die_child
; c
; c
= c
->die_sib
)
12574 prune_unused_types_walk (c
);
12578 /* Remove from the tree DIE any dies that aren't marked. */
12581 prune_unused_types_prune (dw_die_ref die
)
12583 dw_die_ref c
, p
, n
;
12584 if (!die
->die_mark
)
12588 for (c
= die
->die_child
; c
; c
= n
)
12593 prune_unused_types_prune (c
);
12601 die
->die_child
= n
;
12608 /* Remove dies representing declarations that we never use. */
12611 prune_unused_types (void)
12614 limbo_die_node
*node
;
12616 /* Clear all the marks. */
12617 prune_unmark_dies (comp_unit_die
);
12618 for (node
= limbo_die_list
; node
; node
= node
->next
)
12619 prune_unmark_dies (node
->die
);
12621 /* Set the mark on nodes that are actually used. */
12622 prune_unused_types_walk (comp_unit_die
);
12623 for (node
= limbo_die_list
; node
; node
= node
->next
)
12624 prune_unused_types_walk (node
->die
);
12626 /* Also set the mark on nodes referenced from the
12627 pubname_table or arange_table. */
12628 for (i
= 0; i
< pubname_table_in_use
; i
++)
12629 prune_unused_types_mark (pubname_table
[i
].die
, 1);
12630 for (i
= 0; i
< arange_table_in_use
; i
++)
12631 prune_unused_types_mark (arange_table
[i
], 1);
12633 /* Get rid of nodes that aren't marked. */
12634 prune_unused_types_prune (comp_unit_die
);
12635 for (node
= limbo_die_list
; node
; node
= node
->next
)
12636 prune_unused_types_prune (node
->die
);
12638 /* Leave the marks clear. */
12639 prune_unmark_dies (comp_unit_die
);
12640 for (node
= limbo_die_list
; node
; node
= node
->next
)
12641 prune_unmark_dies (node
->die
);
12644 /* Output stuff that dwarf requires at the end of every file,
12645 and generate the DWARF-2 debugging info. */
12648 dwarf2out_finish (const char *filename
)
12650 limbo_die_node
*node
, *next_node
;
12651 dw_die_ref die
= 0;
12653 /* Add the name for the main input file now. We delayed this from
12654 dwarf2out_init to avoid complications with PCH. */
12655 add_name_attribute (comp_unit_die
, filename
);
12656 if (filename
[0] != DIR_SEPARATOR
)
12657 add_comp_dir_attribute (comp_unit_die
);
12658 else if (get_AT (comp_unit_die
, DW_AT_comp_dir
) == NULL
)
12661 for (i
= 1; i
< VARRAY_ACTIVE_SIZE (file_table
); i
++)
12662 if (VARRAY_CHAR_PTR (file_table
, i
)[0] != DIR_SEPARATOR
12663 /* Don't add cwd for <built-in>. */
12664 && VARRAY_CHAR_PTR (file_table
, i
)[0] != '<')
12666 add_comp_dir_attribute (comp_unit_die
);
12671 /* Traverse the limbo die list, and add parent/child links. The only
12672 dies without parents that should be here are concrete instances of
12673 inline functions, and the comp_unit_die. We can ignore the comp_unit_die.
12674 For concrete instances, we can get the parent die from the abstract
12676 for (node
= limbo_die_list
; node
; node
= next_node
)
12678 next_node
= node
->next
;
12681 if (die
->die_parent
== NULL
)
12683 dw_die_ref origin
= get_AT_ref (die
, DW_AT_abstract_origin
);
12687 add_child_die (origin
->die_parent
, die
);
12688 else if (die
== comp_unit_die
)
12690 /* If this was an expression for a bound involved in a function
12691 return type, it may be a SAVE_EXPR for which we weren't able
12692 to find a DIE previously. So try now. */
12693 else if (node
->created_for
12694 && TREE_CODE (node
->created_for
) == SAVE_EXPR
12695 && 0 != (origin
= (lookup_decl_die
12697 (node
->created_for
)))))
12698 add_child_die (origin
, die
);
12699 else if (errorcount
> 0 || sorrycount
> 0)
12700 /* It's OK to be confused by errors in the input. */
12701 add_child_die (comp_unit_die
, die
);
12702 else if (node
->created_for
12703 && ((DECL_P (node
->created_for
)
12704 && (context
= DECL_CONTEXT (node
->created_for
)))
12705 || (TYPE_P (node
->created_for
)
12706 && (context
= TYPE_CONTEXT (node
->created_for
))))
12707 && TREE_CODE (context
) == FUNCTION_DECL
)
12709 /* In certain situations, the lexical block containing a
12710 nested function can be optimized away, which results
12711 in the nested function die being orphaned. Likewise
12712 with the return type of that nested function. Force
12713 this to be a child of the containing function. */
12714 origin
= lookup_decl_die (context
);
12717 add_child_die (origin
, die
);
12724 limbo_die_list
= NULL
;
12726 /* Walk through the list of incomplete types again, trying once more to
12727 emit full debugging info for them. */
12728 retry_incomplete_types ();
12730 /* We need to reverse all the dies before break_out_includes, or
12731 we'll see the end of an include file before the beginning. */
12732 reverse_all_dies (comp_unit_die
);
12734 if (flag_eliminate_unused_debug_types
)
12735 prune_unused_types ();
12737 /* Generate separate CUs for each of the include files we've seen.
12738 They will go into limbo_die_list. */
12739 if (flag_eliminate_dwarf2_dups
)
12740 break_out_includes (comp_unit_die
);
12742 /* Traverse the DIE's and add add sibling attributes to those DIE's
12743 that have children. */
12744 add_sibling_attributes (comp_unit_die
);
12745 for (node
= limbo_die_list
; node
; node
= node
->next
)
12746 add_sibling_attributes (node
->die
);
12748 /* Output a terminator label for the .text section. */
12750 (*targetm
.asm_out
.internal_label
) (asm_out_file
, TEXT_END_LABEL
, 0);
12752 /* Output the source line correspondence table. We must do this
12753 even if there is no line information. Otherwise, on an empty
12754 translation unit, we will generate a present, but empty,
12755 .debug_info section. IRIX 6.5 `nm' will then complain when
12756 examining the file. */
12757 if (! DWARF2_ASM_LINE_DEBUG_INFO
)
12759 named_section_flags (DEBUG_LINE_SECTION
, SECTION_DEBUG
);
12760 output_line_info ();
12763 /* Output location list section if necessary. */
12764 if (have_location_lists
)
12766 /* Output the location lists info. */
12767 named_section_flags (DEBUG_LOC_SECTION
, SECTION_DEBUG
);
12768 ASM_GENERATE_INTERNAL_LABEL (loc_section_label
,
12769 DEBUG_LOC_SECTION_LABEL
, 0);
12770 ASM_OUTPUT_LABEL (asm_out_file
, loc_section_label
);
12771 output_location_lists (die
);
12772 have_location_lists
= 0;
12775 /* We can only use the low/high_pc attributes if all of the code was
12777 if (separate_line_info_table_in_use
== 0)
12779 add_AT_lbl_id (comp_unit_die
, DW_AT_low_pc
, text_section_label
);
12780 add_AT_lbl_id (comp_unit_die
, DW_AT_high_pc
, text_end_label
);
12783 /* If it wasn't, we need to give .debug_loc and .debug_ranges an appropriate
12784 "base address". Use zero so that these addresses become absolute. */
12785 else if (have_location_lists
|| ranges_table_in_use
)
12786 add_AT_addr (comp_unit_die
, DW_AT_entry_pc
, const0_rtx
);
12788 if (debug_info_level
>= DINFO_LEVEL_NORMAL
)
12789 add_AT_lbl_offset (comp_unit_die
, DW_AT_stmt_list
,
12790 debug_line_section_label
);
12792 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
12793 add_AT_lbl_offset (comp_unit_die
, DW_AT_macro_info
, macinfo_section_label
);
12795 /* Output all of the compilation units. We put the main one last so that
12796 the offsets are available to output_pubnames. */
12797 for (node
= limbo_die_list
; node
; node
= node
->next
)
12798 output_comp_unit (node
->die
, 0);
12800 output_comp_unit (comp_unit_die
, 0);
12802 /* Output the abbreviation table. */
12803 named_section_flags (DEBUG_ABBREV_SECTION
, SECTION_DEBUG
);
12804 output_abbrev_section ();
12806 /* Output public names table if necessary. */
12807 if (pubname_table_in_use
)
12809 named_section_flags (DEBUG_PUBNAMES_SECTION
, SECTION_DEBUG
);
12810 output_pubnames ();
12813 /* Output the address range information. We only put functions in the arange
12814 table, so don't write it out if we don't have any. */
12815 if (fde_table_in_use
)
12817 named_section_flags (DEBUG_ARANGES_SECTION
, SECTION_DEBUG
);
12821 /* Output ranges section if necessary. */
12822 if (ranges_table_in_use
)
12824 named_section_flags (DEBUG_RANGES_SECTION
, SECTION_DEBUG
);
12825 ASM_OUTPUT_LABEL (asm_out_file
, ranges_section_label
);
12829 /* Have to end the primary source file. */
12830 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
12832 named_section_flags (DEBUG_MACINFO_SECTION
, SECTION_DEBUG
);
12833 dw2_asm_output_data (1, DW_MACINFO_end_file
, "End file");
12834 dw2_asm_output_data (1, 0, "End compilation unit");
12837 /* If we emitted any DW_FORM_strp form attribute, output the string
12839 if (debug_str_hash
)
12840 htab_traverse (debug_str_hash
, output_indirect_string
, NULL
);
12844 /* This should never be used, but its address is needed for comparisons. */
12845 const struct gcc_debug_hooks dwarf2_debug_hooks
;
12847 #endif /* DWARF2_DEBUGGING_INFO */
12849 #include "gt-dwarf2out.h"