1 /* Output Dwarf2 format symbol table information from GCC.
2 Copyright (C) 1992, 1993, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
3 2003, 2004 Free Software Foundation, Inc.
4 Contributed by Gary Funck (gary@intrepid.com).
5 Derived from DWARF 1 implementation of Ron Guilmette (rfg@monkeys.com).
6 Extensively modified by Jason Merrill (jason@cygnus.com).
8 This file is part of GCC.
10 GCC is free software; you can redistribute it and/or modify it under
11 the terms of the GNU General Public License as published by the Free
12 Software Foundation; either version 2, or (at your option) any later
15 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
16 WARRANTY; without even the implied warranty of MERCHANTABILITY or
17 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING. If not, write to the Free
22 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
25 /* TODO: Emit .debug_line header even when there are no functions, since
26 the file numbers are used by .debug_info. Alternately, leave
27 out locations for types and decls.
28 Avoid talking about ctors and op= for PODs.
29 Factor out common prologue sequences into multiple CIEs. */
31 /* The first part of this file deals with the DWARF 2 frame unwind
32 information, which is also used by the GCC efficient exception handling
33 mechanism. The second part, controlled only by an #ifdef
34 DWARF2_DEBUGGING_INFO, deals with the other DWARF 2 debugging
39 #include "coretypes.h"
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"
70 #ifdef DWARF2_DEBUGGING_INFO
71 static void dwarf2out_source_line (unsigned int, const char *);
74 /* DWARF2 Abbreviation Glossary:
75 CFA = Canonical Frame Address
76 a fixed address on the stack which identifies a call frame.
77 We define it to be the value of SP just before the call insn.
78 The CFA register and offset, which may change during the course
79 of the function, are used to calculate its value at runtime.
80 CFI = Call Frame Instruction
81 an instruction for the DWARF2 abstract machine
82 CIE = Common Information Entry
83 information describing information common to one or more FDEs
84 DIE = Debugging Information Entry
85 FDE = Frame Description Entry
86 information describing the stack call frame, in particular,
87 how to restore registers
89 DW_CFA_... = DWARF2 CFA call frame instruction
90 DW_TAG_... = DWARF2 DIE tag */
92 /* Decide whether we want to emit frame unwind information for the current
96 dwarf2out_do_frame (void)
98 return (write_symbols
== DWARF2_DEBUG
99 || write_symbols
== VMS_AND_DWARF2_DEBUG
100 #ifdef DWARF2_FRAME_INFO
103 #ifdef DWARF2_UNWIND_INFO
104 || flag_unwind_tables
105 || (flag_exceptions
&& ! USING_SJLJ_EXCEPTIONS
)
110 /* The size of the target's pointer type. */
112 #define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
115 /* Various versions of targetm.eh_frame_section. Note these must appear
116 outside the DWARF2_DEBUGGING_INFO || DWARF2_UNWIND_INFO macro guards. */
118 /* Version of targetm.eh_frame_section for systems with named sections. */
120 named_section_eh_frame_section (void)
122 #ifdef EH_FRAME_SECTION_NAME
123 #ifdef HAVE_LD_RO_RW_SECTION_MIXING
124 int fde_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0);
125 int per_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
126 int lsda_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
130 || ((fde_encoding
& 0x70) != DW_EH_PE_absptr
131 && (fde_encoding
& 0x70) != DW_EH_PE_aligned
132 && (per_encoding
& 0x70) != DW_EH_PE_absptr
133 && (per_encoding
& 0x70) != DW_EH_PE_aligned
134 && (lsda_encoding
& 0x70) != DW_EH_PE_absptr
135 && (lsda_encoding
& 0x70) != DW_EH_PE_aligned
))
137 named_section_flags (EH_FRAME_SECTION_NAME
, flags
);
139 named_section_flags (EH_FRAME_SECTION_NAME
, SECTION_WRITE
);
144 /* Version of targetm.eh_frame_section for systems using collect2. */
146 collect2_eh_frame_section (void)
148 tree label
= get_file_function_name ('F');
151 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (PTR_SIZE
));
152 (*targetm
.asm_out
.globalize_label
) (asm_out_file
, IDENTIFIER_POINTER (label
));
153 ASM_OUTPUT_LABEL (asm_out_file
, IDENTIFIER_POINTER (label
));
156 /* Default version of targetm.eh_frame_section. */
158 default_eh_frame_section (void)
160 #ifdef EH_FRAME_SECTION_NAME
161 named_section_eh_frame_section ();
163 collect2_eh_frame_section ();
167 /* Array of RTXes referenced by the debugging information, which therefore
168 must be kept around forever. */
169 static GTY(()) varray_type used_rtx_varray
;
171 /* A pointer to the base of a list of incomplete types which might be
172 completed at some later time. incomplete_types_list needs to be a VARRAY
173 because we want to tell the garbage collector about it. */
174 static GTY(()) varray_type incomplete_types
;
176 /* A pointer to the base of a table of references to declaration
177 scopes. This table is a display which tracks the nesting
178 of declaration scopes at the current scope and containing
179 scopes. This table is used to find the proper place to
180 define type declaration DIE's. */
181 static GTY(()) varray_type decl_scope_table
;
183 /* How to start an assembler comment. */
184 #ifndef ASM_COMMENT_START
185 #define ASM_COMMENT_START ";#"
188 typedef struct dw_cfi_struct
*dw_cfi_ref
;
189 typedef struct dw_fde_struct
*dw_fde_ref
;
190 typedef union dw_cfi_oprnd_struct
*dw_cfi_oprnd_ref
;
192 /* Call frames are described using a sequence of Call Frame
193 Information instructions. The register number, offset
194 and address fields are provided as possible operands;
195 their use is selected by the opcode field. */
197 enum dw_cfi_oprnd_type
{
199 dw_cfi_oprnd_reg_num
,
205 typedef union dw_cfi_oprnd_struct
GTY(())
207 unsigned long GTY ((tag ("dw_cfi_oprnd_reg_num"))) dw_cfi_reg_num
;
208 HOST_WIDE_INT
GTY ((tag ("dw_cfi_oprnd_offset"))) dw_cfi_offset
;
209 const char * GTY ((tag ("dw_cfi_oprnd_addr"))) dw_cfi_addr
;
210 struct dw_loc_descr_struct
* GTY ((tag ("dw_cfi_oprnd_loc"))) dw_cfi_loc
;
214 typedef struct dw_cfi_struct
GTY(())
216 dw_cfi_ref dw_cfi_next
;
217 enum dwarf_call_frame_info dw_cfi_opc
;
218 dw_cfi_oprnd
GTY ((desc ("dw_cfi_oprnd1_desc (%1.dw_cfi_opc)")))
220 dw_cfi_oprnd
GTY ((desc ("dw_cfi_oprnd2_desc (%1.dw_cfi_opc)")))
225 /* This is how we define the location of the CFA. We use to handle it
226 as REG + OFFSET all the time, but now it can be more complex.
227 It can now be either REG + CFA_OFFSET or *(REG + BASE_OFFSET) + CFA_OFFSET.
228 Instead of passing around REG and OFFSET, we pass a copy
229 of this structure. */
230 typedef struct cfa_loc
GTY(())
233 HOST_WIDE_INT offset
;
234 HOST_WIDE_INT base_offset
;
235 int indirect
; /* 1 if CFA is accessed via a dereference. */
238 /* All call frame descriptions (FDE's) in the GCC generated DWARF
239 refer to a single Common Information Entry (CIE), defined at
240 the beginning of the .debug_frame section. This use of a single
241 CIE obviates the need to keep track of multiple CIE's
242 in the DWARF generation routines below. */
244 typedef struct dw_fde_struct
GTY(())
246 const char *dw_fde_begin
;
247 const char *dw_fde_current_label
;
248 const char *dw_fde_end
;
249 dw_cfi_ref dw_fde_cfi
;
250 unsigned funcdef_number
;
251 unsigned all_throwers_are_sibcalls
: 1;
252 unsigned nothrow
: 1;
253 unsigned uses_eh_lsda
: 1;
257 /* Maximum size (in bytes) of an artificially generated label. */
258 #define MAX_ARTIFICIAL_LABEL_BYTES 30
260 /* The size of addresses as they appear in the Dwarf 2 data.
261 Some architectures use word addresses to refer to code locations,
262 but Dwarf 2 info always uses byte addresses. On such machines,
263 Dwarf 2 addresses need to be larger than the architecture's
265 #ifndef DWARF2_ADDR_SIZE
266 #define DWARF2_ADDR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
269 /* The size in bytes of a DWARF field indicating an offset or length
270 relative to a debug info section, specified to be 4 bytes in the
271 DWARF-2 specification. The SGI/MIPS ABI defines it to be the same
274 #ifndef DWARF_OFFSET_SIZE
275 #define DWARF_OFFSET_SIZE 4
278 /* According to the (draft) DWARF 3 specification, the initial length
279 should either be 4 or 12 bytes. When it's 12 bytes, the first 4
280 bytes are 0xffffffff, followed by the length stored in the next 8
283 However, the SGI/MIPS ABI uses an initial length which is equal to
284 DWARF_OFFSET_SIZE. It is defined (elsewhere) accordingly. */
286 #ifndef DWARF_INITIAL_LENGTH_SIZE
287 #define DWARF_INITIAL_LENGTH_SIZE (DWARF_OFFSET_SIZE == 4 ? 4 : 12)
290 #define DWARF_VERSION 2
292 /* Round SIZE up to the nearest BOUNDARY. */
293 #define DWARF_ROUND(SIZE,BOUNDARY) \
294 ((((SIZE) + (BOUNDARY) - 1) / (BOUNDARY)) * (BOUNDARY))
296 /* Offsets recorded in opcodes are a multiple of this alignment factor. */
297 #ifndef DWARF_CIE_DATA_ALIGNMENT
298 #ifdef STACK_GROWS_DOWNWARD
299 #define DWARF_CIE_DATA_ALIGNMENT (-((int) UNITS_PER_WORD))
301 #define DWARF_CIE_DATA_ALIGNMENT ((int) UNITS_PER_WORD)
305 /* A pointer to the base of a table that contains frame description
306 information for each routine. */
307 static GTY((length ("fde_table_allocated"))) dw_fde_ref fde_table
;
309 /* Number of elements currently allocated for fde_table. */
310 static GTY(()) unsigned fde_table_allocated
;
312 /* Number of elements in fde_table currently in use. */
313 static GTY(()) unsigned fde_table_in_use
;
315 /* Size (in elements) of increments by which we may expand the
317 #define FDE_TABLE_INCREMENT 256
319 /* A list of call frame insns for the CIE. */
320 static GTY(()) dw_cfi_ref cie_cfi_head
;
322 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
323 /* Some DWARF extensions (e.g., MIPS/SGI) implement a subprogram
324 attribute that accelerates the lookup of the FDE associated
325 with the subprogram. This variable holds the table index of the FDE
326 associated with the current function (body) definition. */
327 static unsigned current_funcdef_fde
;
330 struct indirect_string_node
GTY(())
333 unsigned int refcount
;
338 static GTY ((param_is (struct indirect_string_node
))) htab_t debug_str_hash
;
340 static GTY(()) int dw2_string_counter
;
341 static GTY(()) unsigned long dwarf2out_cfi_label_num
;
343 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
345 /* Forward declarations for functions defined in this file. */
347 static char *stripattributes (const char *);
348 static const char *dwarf_cfi_name (unsigned);
349 static dw_cfi_ref
new_cfi (void);
350 static void add_cfi (dw_cfi_ref
*, dw_cfi_ref
);
351 static void add_fde_cfi (const char *, dw_cfi_ref
);
352 static void lookup_cfa_1 (dw_cfi_ref
, dw_cfa_location
*);
353 static void lookup_cfa (dw_cfa_location
*);
354 static void reg_save (const char *, unsigned, unsigned, HOST_WIDE_INT
);
355 static void initial_return_save (rtx
);
356 static HOST_WIDE_INT
stack_adjust_offset (rtx
);
357 static void output_cfi (dw_cfi_ref
, dw_fde_ref
, int);
358 static void output_call_frame_info (int);
359 static void dwarf2out_stack_adjust (rtx
);
360 static void queue_reg_save (const char *, rtx
, HOST_WIDE_INT
);
361 static void flush_queued_reg_saves (void);
362 static bool clobbers_queued_reg_save (rtx
);
363 static void dwarf2out_frame_debug_expr (rtx
, const char *);
365 /* Support for complex CFA locations. */
366 static void output_cfa_loc (dw_cfi_ref
);
367 static void get_cfa_from_loc_descr (dw_cfa_location
*,
368 struct dw_loc_descr_struct
*);
369 static struct dw_loc_descr_struct
*build_cfa_loc
371 static void def_cfa_1 (const char *, dw_cfa_location
*);
373 /* How to start an assembler comment. */
374 #ifndef ASM_COMMENT_START
375 #define ASM_COMMENT_START ";#"
378 /* Data and reference forms for relocatable data. */
379 #define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
380 #define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
382 #ifndef DEBUG_FRAME_SECTION
383 #define DEBUG_FRAME_SECTION ".debug_frame"
386 #ifndef FUNC_BEGIN_LABEL
387 #define FUNC_BEGIN_LABEL "LFB"
390 #ifndef FUNC_END_LABEL
391 #define FUNC_END_LABEL "LFE"
394 #define FRAME_BEGIN_LABEL "Lframe"
395 #define CIE_AFTER_SIZE_LABEL "LSCIE"
396 #define CIE_END_LABEL "LECIE"
397 #define FDE_LABEL "LSFDE"
398 #define FDE_AFTER_SIZE_LABEL "LASFDE"
399 #define FDE_END_LABEL "LEFDE"
400 #define LINE_NUMBER_BEGIN_LABEL "LSLT"
401 #define LINE_NUMBER_END_LABEL "LELT"
402 #define LN_PROLOG_AS_LABEL "LASLTP"
403 #define LN_PROLOG_END_LABEL "LELTP"
404 #define DIE_LABEL_PREFIX "DW"
406 /* The DWARF 2 CFA column which tracks the return address. Normally this
407 is the column for PC, or the first column after all of the hard
409 #ifndef DWARF_FRAME_RETURN_COLUMN
411 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (PC_REGNUM)
413 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGISTERS
417 /* The mapping from gcc register number to DWARF 2 CFA column number. By
418 default, we just provide columns for all registers. */
419 #ifndef DWARF_FRAME_REGNUM
420 #define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG)
423 /* The offset from the incoming value of %sp to the top of the stack frame
424 for the current function. */
425 #ifndef INCOMING_FRAME_SP_OFFSET
426 #define INCOMING_FRAME_SP_OFFSET 0
429 /* Hook used by __throw. */
432 expand_builtin_dwarf_sp_column (void)
434 return GEN_INT (DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM
));
437 /* Return a pointer to a copy of the section string name S with all
438 attributes stripped off, and an asterisk prepended (for assemble_name). */
441 stripattributes (const char *s
)
443 char *stripped
= xmalloc (strlen (s
) + 2);
448 while (*s
&& *s
!= ',')
455 /* Generate code to initialize the register size table. */
458 expand_builtin_init_dwarf_reg_sizes (tree address
)
461 enum machine_mode mode
= TYPE_MODE (char_type_node
);
462 rtx addr
= expand_expr (address
, NULL_RTX
, VOIDmode
, 0);
463 rtx mem
= gen_rtx_MEM (BLKmode
, addr
);
464 bool wrote_return_column
= false;
466 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
467 if (DWARF_FRAME_REGNUM (i
) < DWARF_FRAME_REGISTERS
)
469 HOST_WIDE_INT offset
= DWARF_FRAME_REGNUM (i
) * GET_MODE_SIZE (mode
);
470 enum machine_mode save_mode
= reg_raw_mode
[i
];
473 if (HARD_REGNO_CALL_PART_CLOBBERED (i
, save_mode
))
474 save_mode
= choose_hard_reg_mode (i
, 1, true);
475 if (DWARF_FRAME_REGNUM (i
) == DWARF_FRAME_RETURN_COLUMN
)
477 if (save_mode
== VOIDmode
)
479 wrote_return_column
= true;
481 size
= GET_MODE_SIZE (save_mode
);
485 emit_move_insn (adjust_address (mem
, mode
, offset
), GEN_INT (size
));
488 #ifdef DWARF_ALT_FRAME_RETURN_COLUMN
489 if (! wrote_return_column
)
491 i
= DWARF_ALT_FRAME_RETURN_COLUMN
;
492 wrote_return_column
= false;
494 i
= DWARF_FRAME_RETURN_COLUMN
;
497 if (! wrote_return_column
)
499 enum machine_mode save_mode
= Pmode
;
500 HOST_WIDE_INT offset
= i
* GET_MODE_SIZE (mode
);
501 HOST_WIDE_INT size
= GET_MODE_SIZE (save_mode
);
502 emit_move_insn (adjust_address (mem
, mode
, offset
), GEN_INT (size
));
506 /* Convert a DWARF call frame info. operation to its string name */
509 dwarf_cfi_name (unsigned int cfi_opc
)
513 case DW_CFA_advance_loc
:
514 return "DW_CFA_advance_loc";
516 return "DW_CFA_offset";
518 return "DW_CFA_restore";
522 return "DW_CFA_set_loc";
523 case DW_CFA_advance_loc1
:
524 return "DW_CFA_advance_loc1";
525 case DW_CFA_advance_loc2
:
526 return "DW_CFA_advance_loc2";
527 case DW_CFA_advance_loc4
:
528 return "DW_CFA_advance_loc4";
529 case DW_CFA_offset_extended
:
530 return "DW_CFA_offset_extended";
531 case DW_CFA_restore_extended
:
532 return "DW_CFA_restore_extended";
533 case DW_CFA_undefined
:
534 return "DW_CFA_undefined";
535 case DW_CFA_same_value
:
536 return "DW_CFA_same_value";
537 case DW_CFA_register
:
538 return "DW_CFA_register";
539 case DW_CFA_remember_state
:
540 return "DW_CFA_remember_state";
541 case DW_CFA_restore_state
:
542 return "DW_CFA_restore_state";
544 return "DW_CFA_def_cfa";
545 case DW_CFA_def_cfa_register
:
546 return "DW_CFA_def_cfa_register";
547 case DW_CFA_def_cfa_offset
:
548 return "DW_CFA_def_cfa_offset";
551 case DW_CFA_def_cfa_expression
:
552 return "DW_CFA_def_cfa_expression";
553 case DW_CFA_expression
:
554 return "DW_CFA_expression";
555 case DW_CFA_offset_extended_sf
:
556 return "DW_CFA_offset_extended_sf";
557 case DW_CFA_def_cfa_sf
:
558 return "DW_CFA_def_cfa_sf";
559 case DW_CFA_def_cfa_offset_sf
:
560 return "DW_CFA_def_cfa_offset_sf";
562 /* SGI/MIPS specific */
563 case DW_CFA_MIPS_advance_loc8
:
564 return "DW_CFA_MIPS_advance_loc8";
567 case DW_CFA_GNU_window_save
:
568 return "DW_CFA_GNU_window_save";
569 case DW_CFA_GNU_args_size
:
570 return "DW_CFA_GNU_args_size";
571 case DW_CFA_GNU_negative_offset_extended
:
572 return "DW_CFA_GNU_negative_offset_extended";
575 return "DW_CFA_<unknown>";
579 /* Return a pointer to a newly allocated Call Frame Instruction. */
581 static inline dw_cfi_ref
584 dw_cfi_ref cfi
= ggc_alloc (sizeof (dw_cfi_node
));
586 cfi
->dw_cfi_next
= NULL
;
587 cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
= 0;
588 cfi
->dw_cfi_oprnd2
.dw_cfi_reg_num
= 0;
593 /* Add a Call Frame Instruction to list of instructions. */
596 add_cfi (dw_cfi_ref
*list_head
, dw_cfi_ref cfi
)
600 /* Find the end of the chain. */
601 for (p
= list_head
; (*p
) != NULL
; p
= &(*p
)->dw_cfi_next
)
607 /* Generate a new label for the CFI info to refer to. */
610 dwarf2out_cfi_label (void)
612 static char label
[20];
614 ASM_GENERATE_INTERNAL_LABEL (label
, "LCFI", dwarf2out_cfi_label_num
++);
615 ASM_OUTPUT_LABEL (asm_out_file
, label
);
619 /* Add CFI to the current fde at the PC value indicated by LABEL if specified,
620 or to the CIE if LABEL is NULL. */
623 add_fde_cfi (const char *label
, dw_cfi_ref cfi
)
627 dw_fde_ref fde
= &fde_table
[fde_table_in_use
- 1];
630 label
= dwarf2out_cfi_label ();
632 if (fde
->dw_fde_current_label
== NULL
633 || strcmp (label
, fde
->dw_fde_current_label
) != 0)
637 fde
->dw_fde_current_label
= label
= xstrdup (label
);
639 /* Set the location counter to the new label. */
641 xcfi
->dw_cfi_opc
= DW_CFA_advance_loc4
;
642 xcfi
->dw_cfi_oprnd1
.dw_cfi_addr
= label
;
643 add_cfi (&fde
->dw_fde_cfi
, xcfi
);
646 add_cfi (&fde
->dw_fde_cfi
, cfi
);
650 add_cfi (&cie_cfi_head
, cfi
);
653 /* Subroutine of lookup_cfa. */
656 lookup_cfa_1 (dw_cfi_ref cfi
, dw_cfa_location
*loc
)
658 switch (cfi
->dw_cfi_opc
)
660 case DW_CFA_def_cfa_offset
:
661 loc
->offset
= cfi
->dw_cfi_oprnd1
.dw_cfi_offset
;
663 case DW_CFA_def_cfa_register
:
664 loc
->reg
= cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
;
667 loc
->reg
= cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
;
668 loc
->offset
= cfi
->dw_cfi_oprnd2
.dw_cfi_offset
;
670 case DW_CFA_def_cfa_expression
:
671 get_cfa_from_loc_descr (loc
, cfi
->dw_cfi_oprnd1
.dw_cfi_loc
);
678 /* Find the previous value for the CFA. */
681 lookup_cfa (dw_cfa_location
*loc
)
685 loc
->reg
= (unsigned long) -1;
688 loc
->base_offset
= 0;
690 for (cfi
= cie_cfi_head
; cfi
; cfi
= cfi
->dw_cfi_next
)
691 lookup_cfa_1 (cfi
, loc
);
693 if (fde_table_in_use
)
695 dw_fde_ref fde
= &fde_table
[fde_table_in_use
- 1];
696 for (cfi
= fde
->dw_fde_cfi
; cfi
; cfi
= cfi
->dw_cfi_next
)
697 lookup_cfa_1 (cfi
, loc
);
701 /* The current rule for calculating the DWARF2 canonical frame address. */
702 static dw_cfa_location cfa
;
704 /* The register used for saving registers to the stack, and its offset
706 static dw_cfa_location cfa_store
;
708 /* The running total of the size of arguments pushed onto the stack. */
709 static HOST_WIDE_INT args_size
;
711 /* The last args_size we actually output. */
712 static HOST_WIDE_INT old_args_size
;
714 /* Entry point to update the canonical frame address (CFA).
715 LABEL is passed to add_fde_cfi. The value of CFA is now to be
716 calculated from REG+OFFSET. */
719 dwarf2out_def_cfa (const char *label
, unsigned int reg
, HOST_WIDE_INT offset
)
726 def_cfa_1 (label
, &loc
);
729 /* This routine does the actual work. The CFA is now calculated from
730 the dw_cfa_location structure. */
733 def_cfa_1 (const char *label
, dw_cfa_location
*loc_p
)
736 dw_cfa_location old_cfa
, loc
;
741 if (cfa_store
.reg
== loc
.reg
&& loc
.indirect
== 0)
742 cfa_store
.offset
= loc
.offset
;
744 loc
.reg
= DWARF_FRAME_REGNUM (loc
.reg
);
745 lookup_cfa (&old_cfa
);
747 /* If nothing changed, no need to issue any call frame instructions. */
748 if (loc
.reg
== old_cfa
.reg
&& loc
.offset
== old_cfa
.offset
749 && loc
.indirect
== old_cfa
.indirect
750 && (loc
.indirect
== 0 || loc
.base_offset
== old_cfa
.base_offset
))
755 if (loc
.reg
== old_cfa
.reg
&& !loc
.indirect
)
757 /* Construct a "DW_CFA_def_cfa_offset <offset>" instruction,
758 indicating the CFA register did not change but the offset
760 cfi
->dw_cfi_opc
= DW_CFA_def_cfa_offset
;
761 cfi
->dw_cfi_oprnd1
.dw_cfi_offset
= loc
.offset
;
764 #ifndef MIPS_DEBUGGING_INFO /* SGI dbx thinks this means no offset. */
765 else if (loc
.offset
== old_cfa
.offset
&& old_cfa
.reg
!= (unsigned long) -1
768 /* Construct a "DW_CFA_def_cfa_register <register>" instruction,
769 indicating the CFA register has changed to <register> but the
770 offset has not changed. */
771 cfi
->dw_cfi_opc
= DW_CFA_def_cfa_register
;
772 cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
= loc
.reg
;
776 else if (loc
.indirect
== 0)
778 /* Construct a "DW_CFA_def_cfa <register> <offset>" instruction,
779 indicating the CFA register has changed to <register> with
780 the specified offset. */
781 cfi
->dw_cfi_opc
= DW_CFA_def_cfa
;
782 cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
= loc
.reg
;
783 cfi
->dw_cfi_oprnd2
.dw_cfi_offset
= loc
.offset
;
787 /* Construct a DW_CFA_def_cfa_expression instruction to
788 calculate the CFA using a full location expression since no
789 register-offset pair is available. */
790 struct dw_loc_descr_struct
*loc_list
;
792 cfi
->dw_cfi_opc
= DW_CFA_def_cfa_expression
;
793 loc_list
= build_cfa_loc (&loc
);
794 cfi
->dw_cfi_oprnd1
.dw_cfi_loc
= loc_list
;
797 add_fde_cfi (label
, cfi
);
800 /* Add the CFI for saving a register. REG is the CFA column number.
801 LABEL is passed to add_fde_cfi.
802 If SREG is -1, the register is saved at OFFSET from the CFA;
803 otherwise it is saved in SREG. */
806 reg_save (const char *label
, unsigned int reg
, unsigned int sreg
, HOST_WIDE_INT offset
)
808 dw_cfi_ref cfi
= new_cfi ();
810 cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
= reg
;
812 /* The following comparison is correct. -1 is used to indicate that
813 the value isn't a register number. */
814 if (sreg
== (unsigned int) -1)
817 /* The register number won't fit in 6 bits, so we have to use
819 cfi
->dw_cfi_opc
= DW_CFA_offset_extended
;
821 cfi
->dw_cfi_opc
= DW_CFA_offset
;
823 #ifdef ENABLE_CHECKING
825 /* If we get an offset that is not a multiple of
826 DWARF_CIE_DATA_ALIGNMENT, there is either a bug in the
827 definition of DWARF_CIE_DATA_ALIGNMENT, or a bug in the machine
829 HOST_WIDE_INT check_offset
= offset
/ DWARF_CIE_DATA_ALIGNMENT
;
831 if (check_offset
* DWARF_CIE_DATA_ALIGNMENT
!= offset
)
835 offset
/= DWARF_CIE_DATA_ALIGNMENT
;
837 cfi
->dw_cfi_opc
= DW_CFA_offset_extended_sf
;
839 cfi
->dw_cfi_oprnd2
.dw_cfi_offset
= offset
;
841 else if (sreg
== reg
)
842 /* We could emit a DW_CFA_same_value in this case, but don't bother. */
846 cfi
->dw_cfi_opc
= DW_CFA_register
;
847 cfi
->dw_cfi_oprnd2
.dw_cfi_reg_num
= sreg
;
850 add_fde_cfi (label
, cfi
);
853 /* Add the CFI for saving a register window. LABEL is passed to reg_save.
854 This CFI tells the unwinder that it needs to restore the window registers
855 from the previous frame's window save area.
857 ??? Perhaps we should note in the CIE where windows are saved (instead of
858 assuming 0(cfa)) and what registers are in the window. */
861 dwarf2out_window_save (const char *label
)
863 dw_cfi_ref cfi
= new_cfi ();
865 cfi
->dw_cfi_opc
= DW_CFA_GNU_window_save
;
866 add_fde_cfi (label
, cfi
);
869 /* Add a CFI to update the running total of the size of arguments
870 pushed onto the stack. */
873 dwarf2out_args_size (const char *label
, HOST_WIDE_INT size
)
877 if (size
== old_args_size
)
880 old_args_size
= size
;
883 cfi
->dw_cfi_opc
= DW_CFA_GNU_args_size
;
884 cfi
->dw_cfi_oprnd1
.dw_cfi_offset
= size
;
885 add_fde_cfi (label
, cfi
);
888 /* Entry point for saving a register to the stack. REG is the GCC register
889 number. LABEL and OFFSET are passed to reg_save. */
892 dwarf2out_reg_save (const char *label
, unsigned int reg
, HOST_WIDE_INT offset
)
894 reg_save (label
, DWARF_FRAME_REGNUM (reg
), -1, offset
);
897 /* Entry point for saving the return address in the stack.
898 LABEL and OFFSET are passed to reg_save. */
901 dwarf2out_return_save (const char *label
, HOST_WIDE_INT offset
)
903 reg_save (label
, DWARF_FRAME_RETURN_COLUMN
, -1, offset
);
906 /* Entry point for saving the return address in a register.
907 LABEL and SREG are passed to reg_save. */
910 dwarf2out_return_reg (const char *label
, unsigned int sreg
)
912 reg_save (label
, DWARF_FRAME_RETURN_COLUMN
, sreg
, 0);
915 /* Record the initial position of the return address. RTL is
916 INCOMING_RETURN_ADDR_RTX. */
919 initial_return_save (rtx rtl
)
921 unsigned int reg
= (unsigned int) -1;
922 HOST_WIDE_INT offset
= 0;
924 switch (GET_CODE (rtl
))
927 /* RA is in a register. */
928 reg
= DWARF_FRAME_REGNUM (REGNO (rtl
));
932 /* RA is on the stack. */
934 switch (GET_CODE (rtl
))
937 if (REGNO (rtl
) != STACK_POINTER_REGNUM
)
943 if (REGNO (XEXP (rtl
, 0)) != STACK_POINTER_REGNUM
)
945 offset
= INTVAL (XEXP (rtl
, 1));
949 if (REGNO (XEXP (rtl
, 0)) != STACK_POINTER_REGNUM
)
951 offset
= -INTVAL (XEXP (rtl
, 1));
961 /* The return address is at some offset from any value we can
962 actually load. For instance, on the SPARC it is in %i7+8. Just
963 ignore the offset for now; it doesn't matter for unwinding frames. */
964 if (GET_CODE (XEXP (rtl
, 1)) != CONST_INT
)
966 initial_return_save (XEXP (rtl
, 0));
973 reg_save (NULL
, DWARF_FRAME_RETURN_COLUMN
, reg
, offset
- cfa
.offset
);
976 /* Given a SET, calculate the amount of stack adjustment it
980 stack_adjust_offset (rtx pattern
)
982 rtx src
= SET_SRC (pattern
);
983 rtx dest
= SET_DEST (pattern
);
984 HOST_WIDE_INT offset
= 0;
987 if (dest
== stack_pointer_rtx
)
989 /* (set (reg sp) (plus (reg sp) (const_int))) */
990 code
= GET_CODE (src
);
991 if (! (code
== PLUS
|| code
== MINUS
)
992 || XEXP (src
, 0) != stack_pointer_rtx
993 || GET_CODE (XEXP (src
, 1)) != CONST_INT
)
996 offset
= INTVAL (XEXP (src
, 1));
1000 else if (GET_CODE (dest
) == MEM
)
1002 /* (set (mem (pre_dec (reg sp))) (foo)) */
1003 src
= XEXP (dest
, 0);
1004 code
= GET_CODE (src
);
1010 if (XEXP (src
, 0) == stack_pointer_rtx
)
1012 rtx val
= XEXP (XEXP (src
, 1), 1);
1013 /* We handle only adjustments by constant amount. */
1014 if (GET_CODE (XEXP (src
, 1)) != PLUS
||
1015 GET_CODE (val
) != CONST_INT
)
1017 offset
= -INTVAL (val
);
1024 if (XEXP (src
, 0) == stack_pointer_rtx
)
1026 offset
= GET_MODE_SIZE (GET_MODE (dest
));
1033 if (XEXP (src
, 0) == stack_pointer_rtx
)
1035 offset
= -GET_MODE_SIZE (GET_MODE (dest
));
1050 /* Check INSN to see if it looks like a push or a stack adjustment, and
1051 make a note of it if it does. EH uses this information to find out how
1052 much extra space it needs to pop off the stack. */
1055 dwarf2out_stack_adjust (rtx insn
)
1057 HOST_WIDE_INT offset
;
1061 /* Don't handle epilogues at all. Certainly it would be wrong to do so
1062 with this function. Proper support would require all frame-related
1063 insns to be marked, and to be able to handle saving state around
1064 epilogues textually in the middle of the function. */
1065 if (prologue_epilogue_contains (insn
) || sibcall_epilogue_contains (insn
))
1068 if (!flag_asynchronous_unwind_tables
&& GET_CODE (insn
) == CALL_INSN
)
1070 /* Extract the size of the args from the CALL rtx itself. */
1071 insn
= PATTERN (insn
);
1072 if (GET_CODE (insn
) == PARALLEL
)
1073 insn
= XVECEXP (insn
, 0, 0);
1074 if (GET_CODE (insn
) == SET
)
1075 insn
= SET_SRC (insn
);
1076 if (GET_CODE (insn
) != CALL
)
1079 dwarf2out_args_size ("", INTVAL (XEXP (insn
, 1)));
1083 /* If only calls can throw, and we have a frame pointer,
1084 save up adjustments until we see the CALL_INSN. */
1085 else if (!flag_asynchronous_unwind_tables
&& cfa
.reg
!= STACK_POINTER_REGNUM
)
1088 if (GET_CODE (insn
) == BARRIER
)
1090 /* When we see a BARRIER, we know to reset args_size to 0. Usually
1091 the compiler will have already emitted a stack adjustment, but
1092 doesn't bother for calls to noreturn functions. */
1093 #ifdef STACK_GROWS_DOWNWARD
1094 offset
= -args_size
;
1099 else if (GET_CODE (PATTERN (insn
)) == SET
)
1100 offset
= stack_adjust_offset (PATTERN (insn
));
1101 else if (GET_CODE (PATTERN (insn
)) == PARALLEL
1102 || GET_CODE (PATTERN (insn
)) == SEQUENCE
)
1104 /* There may be stack adjustments inside compound insns. Search
1106 for (offset
= 0, i
= XVECLEN (PATTERN (insn
), 0) - 1; i
>= 0; i
--)
1107 if (GET_CODE (XVECEXP (PATTERN (insn
), 0, i
)) == SET
)
1108 offset
+= stack_adjust_offset (XVECEXP (PATTERN (insn
), 0, i
));
1116 if (cfa
.reg
== STACK_POINTER_REGNUM
)
1117 cfa
.offset
+= offset
;
1119 #ifndef STACK_GROWS_DOWNWARD
1123 args_size
+= offset
;
1127 label
= dwarf2out_cfi_label ();
1128 def_cfa_1 (label
, &cfa
);
1129 dwarf2out_args_size (label
, args_size
);
1134 /* We delay emitting a register save until either (a) we reach the end
1135 of the prologue or (b) the register is clobbered. This clusters
1136 register saves so that there are fewer pc advances. */
1138 struct queued_reg_save
GTY(())
1140 struct queued_reg_save
*next
;
1142 HOST_WIDE_INT cfa_offset
;
1145 static GTY(()) struct queued_reg_save
*queued_reg_saves
;
1147 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
1148 static const char *last_reg_save_label
;
1151 queue_reg_save (const char *label
, rtx reg
, HOST_WIDE_INT offset
)
1153 struct queued_reg_save
*q
= ggc_alloc (sizeof (*q
));
1155 q
->next
= queued_reg_saves
;
1157 q
->cfa_offset
= offset
;
1158 queued_reg_saves
= q
;
1160 last_reg_save_label
= label
;
1164 flush_queued_reg_saves (void)
1166 struct queued_reg_save
*q
, *next
;
1168 for (q
= queued_reg_saves
; q
; q
= next
)
1170 dwarf2out_reg_save (last_reg_save_label
, REGNO (q
->reg
), q
->cfa_offset
);
1174 queued_reg_saves
= NULL
;
1175 last_reg_save_label
= NULL
;
1179 clobbers_queued_reg_save (rtx insn
)
1181 struct queued_reg_save
*q
;
1183 for (q
= queued_reg_saves
; q
; q
= q
->next
)
1184 if (modified_in_p (q
->reg
, insn
))
1191 /* A temporary register holding an integral value used in adjusting SP
1192 or setting up the store_reg. The "offset" field holds the integer
1193 value, not an offset. */
1194 static dw_cfa_location cfa_temp
;
1196 /* Record call frame debugging information for an expression EXPR,
1197 which either sets SP or FP (adjusting how we calculate the frame
1198 address) or saves a register to the stack. LABEL indicates the
1201 This function encodes a state machine mapping rtxes to actions on
1202 cfa, cfa_store, and cfa_temp.reg. We describe these rules so
1203 users need not read the source code.
1205 The High-Level Picture
1207 Changes in the register we use to calculate the CFA: Currently we
1208 assume that if you copy the CFA register into another register, we
1209 should take the other one as the new CFA register; this seems to
1210 work pretty well. If it's wrong for some target, it's simple
1211 enough not to set RTX_FRAME_RELATED_P on the insn in question.
1213 Changes in the register we use for saving registers to the stack:
1214 This is usually SP, but not always. Again, we deduce that if you
1215 copy SP into another register (and SP is not the CFA register),
1216 then the new register is the one we will be using for register
1217 saves. This also seems to work.
1219 Register saves: There's not much guesswork about this one; if
1220 RTX_FRAME_RELATED_P is set on an insn which modifies memory, it's a
1221 register save, and the register used to calculate the destination
1222 had better be the one we think we're using for this purpose.
1224 Except: If the register being saved is the CFA register, and the
1225 offset is nonzero, we are saving the CFA, so we assume we have to
1226 use DW_CFA_def_cfa_expression. If the offset is 0, we assume that
1227 the intent is to save the value of SP from the previous frame.
1229 Invariants / Summaries of Rules
1231 cfa current rule for calculating the CFA. It usually
1232 consists of a register and an offset.
1233 cfa_store register used by prologue code to save things to the stack
1234 cfa_store.offset is the offset from the value of
1235 cfa_store.reg to the actual CFA
1236 cfa_temp register holding an integral value. cfa_temp.offset
1237 stores the value, which will be used to adjust the
1238 stack pointer. cfa_temp is also used like cfa_store,
1239 to track stores to the stack via fp or a temp reg.
1241 Rules 1- 4: Setting a register's value to cfa.reg or an expression
1242 with cfa.reg as the first operand changes the cfa.reg and its
1243 cfa.offset. Rule 1 and 4 also set cfa_temp.reg and
1246 Rules 6- 9: Set a non-cfa.reg register value to a constant or an
1247 expression yielding a constant. This sets cfa_temp.reg
1248 and cfa_temp.offset.
1250 Rule 5: Create a new register cfa_store used to save items to the
1253 Rules 10-14: Save a register to the stack. Define offset as the
1254 difference of the original location and cfa_store's
1255 location (or cfa_temp's location if cfa_temp is used).
1259 "{a,b}" indicates a choice of a xor b.
1260 "<reg>:cfa.reg" indicates that <reg> must equal cfa.reg.
1263 (set <reg1> <reg2>:cfa.reg)
1264 effects: cfa.reg = <reg1>
1265 cfa.offset unchanged
1266 cfa_temp.reg = <reg1>
1267 cfa_temp.offset = cfa.offset
1270 (set sp ({minus,plus,losum} {sp,fp}:cfa.reg
1271 {<const_int>,<reg>:cfa_temp.reg}))
1272 effects: cfa.reg = sp if fp used
1273 cfa.offset += {+/- <const_int>, cfa_temp.offset} if cfa.reg==sp
1274 cfa_store.offset += {+/- <const_int>, cfa_temp.offset}
1275 if cfa_store.reg==sp
1278 (set fp ({minus,plus,losum} <reg>:cfa.reg <const_int>))
1279 effects: cfa.reg = fp
1280 cfa_offset += +/- <const_int>
1283 (set <reg1> ({plus,losum} <reg2>:cfa.reg <const_int>))
1284 constraints: <reg1> != fp
1286 effects: cfa.reg = <reg1>
1287 cfa_temp.reg = <reg1>
1288 cfa_temp.offset = cfa.offset
1291 (set <reg1> (plus <reg2>:cfa_temp.reg sp:cfa.reg))
1292 constraints: <reg1> != fp
1294 effects: cfa_store.reg = <reg1>
1295 cfa_store.offset = cfa.offset - cfa_temp.offset
1298 (set <reg> <const_int>)
1299 effects: cfa_temp.reg = <reg>
1300 cfa_temp.offset = <const_int>
1303 (set <reg1>:cfa_temp.reg (ior <reg2>:cfa_temp.reg <const_int>))
1304 effects: cfa_temp.reg = <reg1>
1305 cfa_temp.offset |= <const_int>
1308 (set <reg> (high <exp>))
1312 (set <reg> (lo_sum <exp> <const_int>))
1313 effects: cfa_temp.reg = <reg>
1314 cfa_temp.offset = <const_int>
1317 (set (mem (pre_modify sp:cfa_store (???? <reg1> <const_int>))) <reg2>)
1318 effects: cfa_store.offset -= <const_int>
1319 cfa.offset = cfa_store.offset if cfa.reg == sp
1321 cfa.base_offset = -cfa_store.offset
1324 (set (mem ({pre_inc,pre_dec} sp:cfa_store.reg)) <reg>)
1325 effects: cfa_store.offset += -/+ mode_size(mem)
1326 cfa.offset = cfa_store.offset if cfa.reg == sp
1328 cfa.base_offset = -cfa_store.offset
1331 (set (mem ({minus,plus,losum} <reg1>:{cfa_store,cfa_temp} <const_int>))
1334 effects: cfa.reg = <reg1>
1335 cfa.base_offset = -/+ <const_int> - {cfa_store,cfa_temp}.offset
1338 (set (mem <reg1>:{cfa_store,cfa_temp}) <reg2>)
1339 effects: cfa.reg = <reg1>
1340 cfa.base_offset = -{cfa_store,cfa_temp}.offset
1343 (set (mem (postinc <reg1>:cfa_temp <const_int>)) <reg2>)
1344 effects: cfa.reg = <reg1>
1345 cfa.base_offset = -cfa_temp.offset
1346 cfa_temp.offset -= mode_size(mem) */
1349 dwarf2out_frame_debug_expr (rtx expr
, const char *label
)
1352 HOST_WIDE_INT offset
;
1354 /* If RTX_FRAME_RELATED_P is set on a PARALLEL, process each member of
1355 the PARALLEL independently. The first element is always processed if
1356 it is a SET. This is for backward compatibility. Other elements
1357 are processed only if they are SETs and the RTX_FRAME_RELATED_P
1358 flag is set in them. */
1359 if (GET_CODE (expr
) == PARALLEL
|| GET_CODE (expr
) == SEQUENCE
)
1362 int limit
= XVECLEN (expr
, 0);
1364 for (par_index
= 0; par_index
< limit
; par_index
++)
1365 if (GET_CODE (XVECEXP (expr
, 0, par_index
)) == SET
1366 && (RTX_FRAME_RELATED_P (XVECEXP (expr
, 0, par_index
))
1368 dwarf2out_frame_debug_expr (XVECEXP (expr
, 0, par_index
), label
);
1373 if (GET_CODE (expr
) != SET
)
1376 src
= SET_SRC (expr
);
1377 dest
= SET_DEST (expr
);
1379 switch (GET_CODE (dest
))
1383 /* Update the CFA rule wrt SP or FP. Make sure src is
1384 relative to the current CFA register. */
1385 switch (GET_CODE (src
))
1387 /* Setting FP from SP. */
1389 if (cfa
.reg
== (unsigned) REGNO (src
))
1395 /* We used to require that dest be either SP or FP, but the
1396 ARM copies SP to a temporary register, and from there to
1397 FP. So we just rely on the backends to only set
1398 RTX_FRAME_RELATED_P on appropriate insns. */
1399 cfa
.reg
= REGNO (dest
);
1400 cfa_temp
.reg
= cfa
.reg
;
1401 cfa_temp
.offset
= cfa
.offset
;
1407 if (dest
== stack_pointer_rtx
)
1411 switch (GET_CODE (XEXP (src
, 1)))
1414 offset
= INTVAL (XEXP (src
, 1));
1417 if ((unsigned) REGNO (XEXP (src
, 1)) != cfa_temp
.reg
)
1419 offset
= cfa_temp
.offset
;
1425 if (XEXP (src
, 0) == hard_frame_pointer_rtx
)
1427 /* Restoring SP from FP in the epilogue. */
1428 if (cfa
.reg
!= (unsigned) HARD_FRAME_POINTER_REGNUM
)
1430 cfa
.reg
= STACK_POINTER_REGNUM
;
1432 else if (GET_CODE (src
) == LO_SUM
)
1433 /* Assume we've set the source reg of the LO_SUM from sp. */
1435 else if (XEXP (src
, 0) != stack_pointer_rtx
)
1438 if (GET_CODE (src
) != MINUS
)
1440 if (cfa
.reg
== STACK_POINTER_REGNUM
)
1441 cfa
.offset
+= offset
;
1442 if (cfa_store
.reg
== STACK_POINTER_REGNUM
)
1443 cfa_store
.offset
+= offset
;
1445 else if (dest
== hard_frame_pointer_rtx
)
1448 /* Either setting the FP from an offset of the SP,
1449 or adjusting the FP */
1450 if (! frame_pointer_needed
)
1453 if (GET_CODE (XEXP (src
, 0)) == REG
1454 && (unsigned) REGNO (XEXP (src
, 0)) == cfa
.reg
1455 && GET_CODE (XEXP (src
, 1)) == CONST_INT
)
1457 offset
= INTVAL (XEXP (src
, 1));
1458 if (GET_CODE (src
) != MINUS
)
1460 cfa
.offset
+= offset
;
1461 cfa
.reg
= HARD_FRAME_POINTER_REGNUM
;
1468 if (GET_CODE (src
) == MINUS
)
1472 if (GET_CODE (XEXP (src
, 0)) == REG
1473 && REGNO (XEXP (src
, 0)) == cfa
.reg
1474 && GET_CODE (XEXP (src
, 1)) == CONST_INT
)
1476 /* Setting a temporary CFA register that will be copied
1477 into the FP later on. */
1478 offset
= - INTVAL (XEXP (src
, 1));
1479 cfa
.offset
+= offset
;
1480 cfa
.reg
= REGNO (dest
);
1481 /* Or used to save regs to the stack. */
1482 cfa_temp
.reg
= cfa
.reg
;
1483 cfa_temp
.offset
= cfa
.offset
;
1487 else if (GET_CODE (XEXP (src
, 0)) == REG
1488 && REGNO (XEXP (src
, 0)) == cfa_temp
.reg
1489 && XEXP (src
, 1) == stack_pointer_rtx
)
1491 /* Setting a scratch register that we will use instead
1492 of SP for saving registers to the stack. */
1493 if (cfa
.reg
!= STACK_POINTER_REGNUM
)
1495 cfa_store
.reg
= REGNO (dest
);
1496 cfa_store
.offset
= cfa
.offset
- cfa_temp
.offset
;
1500 else if (GET_CODE (src
) == LO_SUM
1501 && GET_CODE (XEXP (src
, 1)) == CONST_INT
)
1503 cfa_temp
.reg
= REGNO (dest
);
1504 cfa_temp
.offset
= INTVAL (XEXP (src
, 1));
1513 cfa_temp
.reg
= REGNO (dest
);
1514 cfa_temp
.offset
= INTVAL (src
);
1519 if (GET_CODE (XEXP (src
, 0)) != REG
1520 || (unsigned) REGNO (XEXP (src
, 0)) != cfa_temp
.reg
1521 || GET_CODE (XEXP (src
, 1)) != CONST_INT
)
1524 if ((unsigned) REGNO (dest
) != cfa_temp
.reg
)
1525 cfa_temp
.reg
= REGNO (dest
);
1526 cfa_temp
.offset
|= INTVAL (XEXP (src
, 1));
1529 /* Skip over HIGH, assuming it will be followed by a LO_SUM,
1530 which will fill in all of the bits. */
1539 def_cfa_1 (label
, &cfa
);
1543 if (GET_CODE (src
) != REG
)
1546 /* Saving a register to the stack. Make sure dest is relative to the
1548 switch (GET_CODE (XEXP (dest
, 0)))
1553 /* We can't handle variable size modifications. */
1554 if (GET_CODE (XEXP (XEXP (XEXP (dest
, 0), 1), 1)) != CONST_INT
)
1556 offset
= -INTVAL (XEXP (XEXP (XEXP (dest
, 0), 1), 1));
1558 if (REGNO (XEXP (XEXP (dest
, 0), 0)) != STACK_POINTER_REGNUM
1559 || cfa_store
.reg
!= STACK_POINTER_REGNUM
)
1562 cfa_store
.offset
+= offset
;
1563 if (cfa
.reg
== STACK_POINTER_REGNUM
)
1564 cfa
.offset
= cfa_store
.offset
;
1566 offset
= -cfa_store
.offset
;
1572 offset
= GET_MODE_SIZE (GET_MODE (dest
));
1573 if (GET_CODE (XEXP (dest
, 0)) == PRE_INC
)
1576 if (REGNO (XEXP (XEXP (dest
, 0), 0)) != STACK_POINTER_REGNUM
1577 || cfa_store
.reg
!= STACK_POINTER_REGNUM
)
1580 cfa_store
.offset
+= offset
;
1581 if (cfa
.reg
== STACK_POINTER_REGNUM
)
1582 cfa
.offset
= cfa_store
.offset
;
1584 offset
= -cfa_store
.offset
;
1588 /* With an offset. */
1592 if (GET_CODE (XEXP (XEXP (dest
, 0), 1)) != CONST_INT
)
1594 offset
= INTVAL (XEXP (XEXP (dest
, 0), 1));
1595 if (GET_CODE (XEXP (dest
, 0)) == MINUS
)
1598 if (cfa_store
.reg
== (unsigned) REGNO (XEXP (XEXP (dest
, 0), 0)))
1599 offset
-= cfa_store
.offset
;
1600 else if (cfa_temp
.reg
== (unsigned) REGNO (XEXP (XEXP (dest
, 0), 0)))
1601 offset
-= cfa_temp
.offset
;
1607 /* Without an offset. */
1609 if (cfa_store
.reg
== (unsigned) REGNO (XEXP (dest
, 0)))
1610 offset
= -cfa_store
.offset
;
1611 else if (cfa_temp
.reg
== (unsigned) REGNO (XEXP (dest
, 0)))
1612 offset
= -cfa_temp
.offset
;
1619 if (cfa_temp
.reg
!= (unsigned) REGNO (XEXP (XEXP (dest
, 0), 0)))
1621 offset
= -cfa_temp
.offset
;
1622 cfa_temp
.offset
-= GET_MODE_SIZE (GET_MODE (dest
));
1629 if (REGNO (src
) != STACK_POINTER_REGNUM
1630 && REGNO (src
) != HARD_FRAME_POINTER_REGNUM
1631 && (unsigned) REGNO (src
) == cfa
.reg
)
1633 /* We're storing the current CFA reg into the stack. */
1635 if (cfa
.offset
== 0)
1637 /* If the source register is exactly the CFA, assume
1638 we're saving SP like any other register; this happens
1640 def_cfa_1 (label
, &cfa
);
1641 queue_reg_save (label
, stack_pointer_rtx
, offset
);
1646 /* Otherwise, we'll need to look in the stack to
1647 calculate the CFA. */
1648 rtx x
= XEXP (dest
, 0);
1650 if (GET_CODE (x
) != REG
)
1652 if (GET_CODE (x
) != REG
)
1655 cfa
.reg
= REGNO (x
);
1656 cfa
.base_offset
= offset
;
1658 def_cfa_1 (label
, &cfa
);
1663 def_cfa_1 (label
, &cfa
);
1664 queue_reg_save (label
, src
, offset
);
1672 /* Record call frame debugging information for INSN, which either
1673 sets SP or FP (adjusting how we calculate the frame address) or saves a
1674 register to the stack. If INSN is NULL_RTX, initialize our state. */
1677 dwarf2out_frame_debug (rtx insn
)
1682 if (insn
== NULL_RTX
)
1684 /* Flush any queued register saves. */
1685 flush_queued_reg_saves ();
1687 /* Set up state for generating call frame debug info. */
1689 if (cfa
.reg
!= (unsigned long) DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM
))
1692 cfa
.reg
= STACK_POINTER_REGNUM
;
1695 cfa_temp
.offset
= 0;
1699 if (GET_CODE (insn
) != INSN
|| clobbers_queued_reg_save (insn
))
1700 flush_queued_reg_saves ();
1702 if (! RTX_FRAME_RELATED_P (insn
))
1704 if (!ACCUMULATE_OUTGOING_ARGS
)
1705 dwarf2out_stack_adjust (insn
);
1710 label
= dwarf2out_cfi_label ();
1711 src
= find_reg_note (insn
, REG_FRAME_RELATED_EXPR
, NULL_RTX
);
1713 insn
= XEXP (src
, 0);
1715 insn
= PATTERN (insn
);
1717 dwarf2out_frame_debug_expr (insn
, label
);
1722 /* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used. */
1723 static enum dw_cfi_oprnd_type dw_cfi_oprnd1_desc
1724 (enum dwarf_call_frame_info cfi
);
1726 static enum dw_cfi_oprnd_type
1727 dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi
)
1732 case DW_CFA_GNU_window_save
:
1733 return dw_cfi_oprnd_unused
;
1735 case DW_CFA_set_loc
:
1736 case DW_CFA_advance_loc1
:
1737 case DW_CFA_advance_loc2
:
1738 case DW_CFA_advance_loc4
:
1739 case DW_CFA_MIPS_advance_loc8
:
1740 return dw_cfi_oprnd_addr
;
1743 case DW_CFA_offset_extended
:
1744 case DW_CFA_def_cfa
:
1745 case DW_CFA_offset_extended_sf
:
1746 case DW_CFA_def_cfa_sf
:
1747 case DW_CFA_restore_extended
:
1748 case DW_CFA_undefined
:
1749 case DW_CFA_same_value
:
1750 case DW_CFA_def_cfa_register
:
1751 case DW_CFA_register
:
1752 return dw_cfi_oprnd_reg_num
;
1754 case DW_CFA_def_cfa_offset
:
1755 case DW_CFA_GNU_args_size
:
1756 case DW_CFA_def_cfa_offset_sf
:
1757 return dw_cfi_oprnd_offset
;
1759 case DW_CFA_def_cfa_expression
:
1760 case DW_CFA_expression
:
1761 return dw_cfi_oprnd_loc
;
1768 /* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used. */
1769 static enum dw_cfi_oprnd_type dw_cfi_oprnd2_desc
1770 (enum dwarf_call_frame_info cfi
);
1772 static enum dw_cfi_oprnd_type
1773 dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi
)
1777 case DW_CFA_def_cfa
:
1778 case DW_CFA_def_cfa_sf
:
1780 case DW_CFA_offset_extended_sf
:
1781 case DW_CFA_offset_extended
:
1782 return dw_cfi_oprnd_offset
;
1784 case DW_CFA_register
:
1785 return dw_cfi_oprnd_reg_num
;
1788 return dw_cfi_oprnd_unused
;
1792 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
1794 /* Map register numbers held in the call frame info that gcc has
1795 collected using DWARF_FRAME_REGNUM to those that should be output in
1796 .debug_frame and .eh_frame. */
1797 #ifndef DWARF2_FRAME_REG_OUT
1798 #define DWARF2_FRAME_REG_OUT(REGNO, FOR_EH) (REGNO)
1801 /* Output a Call Frame Information opcode and its operand(s). */
1804 output_cfi (dw_cfi_ref cfi
, dw_fde_ref fde
, int for_eh
)
1807 if (cfi
->dw_cfi_opc
== DW_CFA_advance_loc
)
1808 dw2_asm_output_data (1, (cfi
->dw_cfi_opc
1809 | (cfi
->dw_cfi_oprnd1
.dw_cfi_offset
& 0x3f)),
1810 "DW_CFA_advance_loc " HOST_WIDE_INT_PRINT_HEX
,
1811 cfi
->dw_cfi_oprnd1
.dw_cfi_offset
);
1812 else if (cfi
->dw_cfi_opc
== DW_CFA_offset
)
1814 r
= DWARF2_FRAME_REG_OUT (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
, for_eh
);
1815 dw2_asm_output_data (1, (cfi
->dw_cfi_opc
| (r
& 0x3f)),
1816 "DW_CFA_offset, column 0x%lx", r
);
1817 dw2_asm_output_data_uleb128 (cfi
->dw_cfi_oprnd2
.dw_cfi_offset
, NULL
);
1819 else if (cfi
->dw_cfi_opc
== DW_CFA_restore
)
1821 r
= DWARF2_FRAME_REG_OUT (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
, for_eh
);
1822 dw2_asm_output_data (1, (cfi
->dw_cfi_opc
| (r
& 0x3f)),
1823 "DW_CFA_restore, column 0x%lx", r
);
1827 dw2_asm_output_data (1, cfi
->dw_cfi_opc
,
1828 "%s", dwarf_cfi_name (cfi
->dw_cfi_opc
));
1830 switch (cfi
->dw_cfi_opc
)
1832 case DW_CFA_set_loc
:
1834 dw2_asm_output_encoded_addr_rtx (
1835 ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0),
1836 gen_rtx_SYMBOL_REF (Pmode
, cfi
->dw_cfi_oprnd1
.dw_cfi_addr
),
1839 dw2_asm_output_addr (DWARF2_ADDR_SIZE
,
1840 cfi
->dw_cfi_oprnd1
.dw_cfi_addr
, NULL
);
1843 case DW_CFA_advance_loc1
:
1844 dw2_asm_output_delta (1, cfi
->dw_cfi_oprnd1
.dw_cfi_addr
,
1845 fde
->dw_fde_current_label
, NULL
);
1846 fde
->dw_fde_current_label
= cfi
->dw_cfi_oprnd1
.dw_cfi_addr
;
1849 case DW_CFA_advance_loc2
:
1850 dw2_asm_output_delta (2, cfi
->dw_cfi_oprnd1
.dw_cfi_addr
,
1851 fde
->dw_fde_current_label
, NULL
);
1852 fde
->dw_fde_current_label
= cfi
->dw_cfi_oprnd1
.dw_cfi_addr
;
1855 case DW_CFA_advance_loc4
:
1856 dw2_asm_output_delta (4, cfi
->dw_cfi_oprnd1
.dw_cfi_addr
,
1857 fde
->dw_fde_current_label
, NULL
);
1858 fde
->dw_fde_current_label
= cfi
->dw_cfi_oprnd1
.dw_cfi_addr
;
1861 case DW_CFA_MIPS_advance_loc8
:
1862 dw2_asm_output_delta (8, cfi
->dw_cfi_oprnd1
.dw_cfi_addr
,
1863 fde
->dw_fde_current_label
, NULL
);
1864 fde
->dw_fde_current_label
= cfi
->dw_cfi_oprnd1
.dw_cfi_addr
;
1867 case DW_CFA_offset_extended
:
1868 case DW_CFA_def_cfa
:
1869 r
= DWARF2_FRAME_REG_OUT (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
, for_eh
);
1870 dw2_asm_output_data_uleb128 (r
, NULL
);
1871 dw2_asm_output_data_uleb128 (cfi
->dw_cfi_oprnd2
.dw_cfi_offset
, NULL
);
1874 case DW_CFA_offset_extended_sf
:
1875 case DW_CFA_def_cfa_sf
:
1876 r
= DWARF2_FRAME_REG_OUT (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
, for_eh
);
1877 dw2_asm_output_data_uleb128 (r
, NULL
);
1878 dw2_asm_output_data_sleb128 (cfi
->dw_cfi_oprnd2
.dw_cfi_offset
, NULL
);
1881 case DW_CFA_restore_extended
:
1882 case DW_CFA_undefined
:
1883 case DW_CFA_same_value
:
1884 case DW_CFA_def_cfa_register
:
1885 r
= DWARF2_FRAME_REG_OUT (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
, for_eh
);
1886 dw2_asm_output_data_uleb128 (r
, NULL
);
1889 case DW_CFA_register
:
1890 r
= DWARF2_FRAME_REG_OUT (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
, for_eh
);
1891 dw2_asm_output_data_uleb128 (r
, NULL
);
1892 r
= DWARF2_FRAME_REG_OUT (cfi
->dw_cfi_oprnd2
.dw_cfi_reg_num
, for_eh
);
1893 dw2_asm_output_data_uleb128 (r
, NULL
);
1896 case DW_CFA_def_cfa_offset
:
1897 case DW_CFA_GNU_args_size
:
1898 dw2_asm_output_data_uleb128 (cfi
->dw_cfi_oprnd1
.dw_cfi_offset
, NULL
);
1901 case DW_CFA_def_cfa_offset_sf
:
1902 dw2_asm_output_data_sleb128 (cfi
->dw_cfi_oprnd1
.dw_cfi_offset
, NULL
);
1905 case DW_CFA_GNU_window_save
:
1908 case DW_CFA_def_cfa_expression
:
1909 case DW_CFA_expression
:
1910 output_cfa_loc (cfi
);
1913 case DW_CFA_GNU_negative_offset_extended
:
1914 /* Obsoleted by DW_CFA_offset_extended_sf. */
1923 /* Output the call frame information used to record information
1924 that relates to calculating the frame pointer, and records the
1925 location of saved registers. */
1928 output_call_frame_info (int for_eh
)
1933 char l1
[20], l2
[20], section_start_label
[20];
1934 bool any_lsda_needed
= false;
1935 char augmentation
[6];
1936 int augmentation_size
;
1937 int fde_encoding
= DW_EH_PE_absptr
;
1938 int per_encoding
= DW_EH_PE_absptr
;
1939 int lsda_encoding
= DW_EH_PE_absptr
;
1941 /* Don't emit a CIE if there won't be any FDEs. */
1942 if (fde_table_in_use
== 0)
1945 /* If we don't have any functions we'll want to unwind out of, don't
1946 emit any EH unwind information. Note that if exceptions aren't
1947 enabled, we won't have collected nothrow information, and if we
1948 asked for asynchronous tables, we always want this info. */
1951 bool any_eh_needed
= !flag_exceptions
|| flag_asynchronous_unwind_tables
;
1953 for (i
= 0; i
< fde_table_in_use
; i
++)
1954 if (fde_table
[i
].uses_eh_lsda
)
1955 any_eh_needed
= any_lsda_needed
= true;
1956 else if (! fde_table
[i
].nothrow
1957 && ! fde_table
[i
].all_throwers_are_sibcalls
)
1958 any_eh_needed
= true;
1960 if (! any_eh_needed
)
1964 /* We're going to be generating comments, so turn on app. */
1969 (*targetm
.asm_out
.eh_frame_section
) ();
1971 named_section_flags (DEBUG_FRAME_SECTION
, SECTION_DEBUG
);
1973 ASM_GENERATE_INTERNAL_LABEL (section_start_label
, FRAME_BEGIN_LABEL
, for_eh
);
1974 ASM_OUTPUT_LABEL (asm_out_file
, section_start_label
);
1976 /* Output the CIE. */
1977 ASM_GENERATE_INTERNAL_LABEL (l1
, CIE_AFTER_SIZE_LABEL
, for_eh
);
1978 ASM_GENERATE_INTERNAL_LABEL (l2
, CIE_END_LABEL
, for_eh
);
1979 dw2_asm_output_delta (for_eh
? 4 : DWARF_OFFSET_SIZE
, l2
, l1
,
1980 "Length of Common Information Entry");
1981 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
1983 /* Now that the CIE pointer is PC-relative for EH,
1984 use 0 to identify the CIE. */
1985 dw2_asm_output_data ((for_eh
? 4 : DWARF_OFFSET_SIZE
),
1986 (for_eh
? 0 : DW_CIE_ID
),
1987 "CIE Identifier Tag");
1989 dw2_asm_output_data (1, DW_CIE_VERSION
, "CIE Version");
1991 augmentation
[0] = 0;
1992 augmentation_size
= 0;
1998 z Indicates that a uleb128 is present to size the
1999 augmentation section.
2000 L Indicates the encoding (and thus presence) of
2001 an LSDA pointer in the FDE augmentation.
2002 R Indicates a non-default pointer encoding for
2004 P Indicates the presence of an encoding + language
2005 personality routine in the CIE augmentation. */
2007 fde_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0);
2008 per_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
2009 lsda_encoding
= ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
2011 p
= augmentation
+ 1;
2012 if (eh_personality_libfunc
)
2015 augmentation_size
+= 1 + size_of_encoded_value (per_encoding
);
2017 if (any_lsda_needed
)
2020 augmentation_size
+= 1;
2022 if (fde_encoding
!= DW_EH_PE_absptr
)
2025 augmentation_size
+= 1;
2027 if (p
> augmentation
+ 1)
2029 augmentation
[0] = 'z';
2033 /* Ug. Some platforms can't do unaligned dynamic relocations at all. */
2034 if (eh_personality_libfunc
&& per_encoding
== DW_EH_PE_aligned
)
2036 int offset
= ( 4 /* Length */
2038 + 1 /* CIE version */
2039 + strlen (augmentation
) + 1 /* Augmentation */
2040 + size_of_uleb128 (1) /* Code alignment */
2041 + size_of_sleb128 (DWARF_CIE_DATA_ALIGNMENT
)
2043 + 1 /* Augmentation size */
2044 + 1 /* Personality encoding */ );
2045 int pad
= -offset
& (PTR_SIZE
- 1);
2047 augmentation_size
+= pad
;
2049 /* Augmentations should be small, so there's scarce need to
2050 iterate for a solution. Die if we exceed one uleb128 byte. */
2051 if (size_of_uleb128 (augmentation_size
) != 1)
2056 dw2_asm_output_nstring (augmentation
, -1, "CIE Augmentation");
2057 dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor");
2058 dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT
,
2059 "CIE Data Alignment Factor");
2060 dw2_asm_output_data (1, DWARF_FRAME_RETURN_COLUMN
, "CIE RA Column");
2062 if (augmentation
[0])
2064 dw2_asm_output_data_uleb128 (augmentation_size
, "Augmentation size");
2065 if (eh_personality_libfunc
)
2067 dw2_asm_output_data (1, per_encoding
, "Personality (%s)",
2068 eh_data_format_name (per_encoding
));
2069 dw2_asm_output_encoded_addr_rtx (per_encoding
,
2070 eh_personality_libfunc
, NULL
);
2073 if (any_lsda_needed
)
2074 dw2_asm_output_data (1, lsda_encoding
, "LSDA Encoding (%s)",
2075 eh_data_format_name (lsda_encoding
));
2077 if (fde_encoding
!= DW_EH_PE_absptr
)
2078 dw2_asm_output_data (1, fde_encoding
, "FDE Encoding (%s)",
2079 eh_data_format_name (fde_encoding
));
2082 for (cfi
= cie_cfi_head
; cfi
!= NULL
; cfi
= cfi
->dw_cfi_next
)
2083 output_cfi (cfi
, NULL
, for_eh
);
2085 /* Pad the CIE out to an address sized boundary. */
2086 ASM_OUTPUT_ALIGN (asm_out_file
,
2087 floor_log2 (for_eh
? PTR_SIZE
: DWARF2_ADDR_SIZE
));
2088 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
2090 /* Loop through all of the FDE's. */
2091 for (i
= 0; i
< fde_table_in_use
; i
++)
2093 fde
= &fde_table
[i
];
2095 /* Don't emit EH unwind info for leaf functions that don't need it. */
2096 if (for_eh
&& !flag_asynchronous_unwind_tables
&& flag_exceptions
2097 && (fde
->nothrow
|| fde
->all_throwers_are_sibcalls
)
2098 && !fde
->uses_eh_lsda
)
2101 (*targetm
.asm_out
.internal_label
) (asm_out_file
, FDE_LABEL
, for_eh
+ i
* 2);
2102 ASM_GENERATE_INTERNAL_LABEL (l1
, FDE_AFTER_SIZE_LABEL
, for_eh
+ i
* 2);
2103 ASM_GENERATE_INTERNAL_LABEL (l2
, FDE_END_LABEL
, for_eh
+ i
* 2);
2104 dw2_asm_output_delta (for_eh
? 4 : DWARF_OFFSET_SIZE
, l2
, l1
,
2106 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
2109 dw2_asm_output_delta (4, l1
, section_start_label
, "FDE CIE offset");
2111 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, section_start_label
,
2116 dw2_asm_output_encoded_addr_rtx (fde_encoding
,
2117 gen_rtx_SYMBOL_REF (Pmode
, fde
->dw_fde_begin
),
2118 "FDE initial location");
2119 dw2_asm_output_delta (size_of_encoded_value (fde_encoding
),
2120 fde
->dw_fde_end
, fde
->dw_fde_begin
,
2121 "FDE address range");
2125 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, fde
->dw_fde_begin
,
2126 "FDE initial location");
2127 dw2_asm_output_delta (DWARF2_ADDR_SIZE
,
2128 fde
->dw_fde_end
, fde
->dw_fde_begin
,
2129 "FDE address range");
2132 if (augmentation
[0])
2134 if (any_lsda_needed
)
2136 int size
= size_of_encoded_value (lsda_encoding
);
2138 if (lsda_encoding
== DW_EH_PE_aligned
)
2140 int offset
= ( 4 /* Length */
2141 + 4 /* CIE offset */
2142 + 2 * size_of_encoded_value (fde_encoding
)
2143 + 1 /* Augmentation size */ );
2144 int pad
= -offset
& (PTR_SIZE
- 1);
2147 if (size_of_uleb128 (size
) != 1)
2151 dw2_asm_output_data_uleb128 (size
, "Augmentation size");
2153 if (fde
->uses_eh_lsda
)
2155 ASM_GENERATE_INTERNAL_LABEL (l1
, "LLSDA",
2156 fde
->funcdef_number
);
2157 dw2_asm_output_encoded_addr_rtx (
2158 lsda_encoding
, gen_rtx_SYMBOL_REF (Pmode
, l1
),
2159 "Language Specific Data Area");
2163 if (lsda_encoding
== DW_EH_PE_aligned
)
2164 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (PTR_SIZE
));
2166 (size_of_encoded_value (lsda_encoding
), 0,
2167 "Language Specific Data Area (none)");
2171 dw2_asm_output_data_uleb128 (0, "Augmentation size");
2174 /* Loop through the Call Frame Instructions associated with
2176 fde
->dw_fde_current_label
= fde
->dw_fde_begin
;
2177 for (cfi
= fde
->dw_fde_cfi
; cfi
!= NULL
; cfi
= cfi
->dw_cfi_next
)
2178 output_cfi (cfi
, fde
, for_eh
);
2180 /* Pad the FDE out to an address sized boundary. */
2181 ASM_OUTPUT_ALIGN (asm_out_file
,
2182 floor_log2 ((for_eh
? PTR_SIZE
: DWARF2_ADDR_SIZE
)));
2183 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
2186 if (for_eh
&& targetm
.terminate_dw2_eh_frame_info
)
2187 dw2_asm_output_data (4, 0, "End of Table");
2188 #ifdef MIPS_DEBUGGING_INFO
2189 /* Work around Irix 6 assembler bug whereby labels at the end of a section
2190 get a value of 0. Putting .align 0 after the label fixes it. */
2191 ASM_OUTPUT_ALIGN (asm_out_file
, 0);
2194 /* Turn off app to make assembly quicker. */
2199 /* Output a marker (i.e. a label) for the beginning of a function, before
2203 dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED
,
2204 const char *file ATTRIBUTE_UNUSED
)
2206 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
2209 current_function_func_begin_label
= 0;
2211 #ifdef IA64_UNWIND_INFO
2212 /* ??? current_function_func_begin_label is also used by except.c
2213 for call-site information. We must emit this label if it might
2215 if ((! flag_exceptions
|| USING_SJLJ_EXCEPTIONS
)
2216 && ! dwarf2out_do_frame ())
2219 if (! dwarf2out_do_frame ())
2223 function_section (current_function_decl
);
2224 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_BEGIN_LABEL
,
2225 current_function_funcdef_no
);
2226 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, FUNC_BEGIN_LABEL
,
2227 current_function_funcdef_no
);
2228 current_function_func_begin_label
= get_identifier (label
);
2230 #ifdef IA64_UNWIND_INFO
2231 /* We can elide the fde allocation if we're not emitting debug info. */
2232 if (! dwarf2out_do_frame ())
2236 /* Expand the fde table if necessary. */
2237 if (fde_table_in_use
== fde_table_allocated
)
2239 fde_table_allocated
+= FDE_TABLE_INCREMENT
;
2240 fde_table
= ggc_realloc (fde_table
,
2241 fde_table_allocated
* sizeof (dw_fde_node
));
2242 memset (fde_table
+ fde_table_in_use
, 0,
2243 FDE_TABLE_INCREMENT
* sizeof (dw_fde_node
));
2246 /* Record the FDE associated with this function. */
2247 current_funcdef_fde
= fde_table_in_use
;
2249 /* Add the new FDE at the end of the fde_table. */
2250 fde
= &fde_table
[fde_table_in_use
++];
2251 fde
->dw_fde_begin
= xstrdup (label
);
2252 fde
->dw_fde_current_label
= NULL
;
2253 fde
->dw_fde_end
= NULL
;
2254 fde
->dw_fde_cfi
= NULL
;
2255 fde
->funcdef_number
= current_function_funcdef_no
;
2256 fde
->nothrow
= current_function_nothrow
;
2257 fde
->uses_eh_lsda
= cfun
->uses_eh_lsda
;
2258 fde
->all_throwers_are_sibcalls
= cfun
->all_throwers_are_sibcalls
;
2260 args_size
= old_args_size
= 0;
2262 /* We only want to output line number information for the genuine dwarf2
2263 prologue case, not the eh frame case. */
2264 #ifdef DWARF2_DEBUGGING_INFO
2266 dwarf2out_source_line (line
, file
);
2270 /* Output a marker (i.e. a label) for the absolute end of the generated code
2271 for a function definition. This gets called *after* the epilogue code has
2275 dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED
,
2276 const char *file ATTRIBUTE_UNUSED
)
2279 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
2281 /* Output a label to mark the endpoint of the code generated for this
2283 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_END_LABEL
,
2284 current_function_funcdef_no
);
2285 ASM_OUTPUT_LABEL (asm_out_file
, label
);
2286 fde
= &fde_table
[fde_table_in_use
- 1];
2287 fde
->dw_fde_end
= xstrdup (label
);
2291 dwarf2out_frame_init (void)
2293 /* Allocate the initial hunk of the fde_table. */
2294 fde_table
= ggc_alloc_cleared (FDE_TABLE_INCREMENT
* sizeof (dw_fde_node
));
2295 fde_table_allocated
= FDE_TABLE_INCREMENT
;
2296 fde_table_in_use
= 0;
2298 /* Generate the CFA instructions common to all FDE's. Do it now for the
2299 sake of lookup_cfa. */
2301 #ifdef DWARF2_UNWIND_INFO
2302 /* On entry, the Canonical Frame Address is at SP. */
2303 dwarf2out_def_cfa (NULL
, STACK_POINTER_REGNUM
, INCOMING_FRAME_SP_OFFSET
);
2304 initial_return_save (INCOMING_RETURN_ADDR_RTX
);
2309 dwarf2out_frame_finish (void)
2311 /* Output call frame information. */
2312 if (write_symbols
== DWARF2_DEBUG
|| write_symbols
== VMS_AND_DWARF2_DEBUG
)
2313 output_call_frame_info (0);
2315 if (! USING_SJLJ_EXCEPTIONS
&& (flag_unwind_tables
|| flag_exceptions
))
2316 output_call_frame_info (1);
2320 /* And now, the subset of the debugging information support code necessary
2321 for emitting location expressions. */
2323 /* We need some way to distinguish DW_OP_addr with a direct symbol
2324 relocation from DW_OP_addr with a dtp-relative symbol relocation. */
2325 #define INTERNAL_DW_OP_tls_addr (0x100 + DW_OP_addr)
2328 typedef struct dw_val_struct
*dw_val_ref
;
2329 typedef struct die_struct
*dw_die_ref
;
2330 typedef struct dw_loc_descr_struct
*dw_loc_descr_ref
;
2331 typedef struct dw_loc_list_struct
*dw_loc_list_ref
;
2333 /* Each DIE may have a series of attribute/value pairs. Values
2334 can take on several forms. The forms that are used in this
2335 implementation are listed below. */
2340 dw_val_class_offset
,
2342 dw_val_class_loc_list
,
2343 dw_val_class_range_list
,
2345 dw_val_class_unsigned_const
,
2346 dw_val_class_long_long
,
2349 dw_val_class_die_ref
,
2350 dw_val_class_fde_ref
,
2351 dw_val_class_lbl_id
,
2352 dw_val_class_lbl_offset
,
2356 /* Describe a double word constant value. */
2357 /* ??? Every instance of long_long in the code really means CONST_DOUBLE. */
2359 typedef struct dw_long_long_struct
GTY(())
2366 /* Describe a floating point constant value, or a vector constant value. */
2368 typedef struct dw_vec_struct
GTY(())
2370 unsigned char * GTY((length ("%h.length"))) array
;
2376 /* The dw_val_node describes an attribute's value, as it is
2377 represented internally. */
2379 typedef struct dw_val_struct
GTY(())
2381 enum dw_val_class val_class
;
2382 union dw_val_struct_union
2384 rtx
GTY ((tag ("dw_val_class_addr"))) val_addr
;
2385 unsigned HOST_WIDE_INT
GTY ((tag ("dw_val_class_offset"))) val_offset
;
2386 dw_loc_list_ref
GTY ((tag ("dw_val_class_loc_list"))) val_loc_list
;
2387 dw_loc_descr_ref
GTY ((tag ("dw_val_class_loc"))) val_loc
;
2388 HOST_WIDE_INT
GTY ((default (""))) val_int
;
2389 unsigned HOST_WIDE_INT
GTY ((tag ("dw_val_class_unsigned_const"))) val_unsigned
;
2390 dw_long_long_const
GTY ((tag ("dw_val_class_long_long"))) val_long_long
;
2391 dw_vec_const
GTY ((tag ("dw_val_class_vec"))) val_vec
;
2392 struct dw_val_die_union
2396 } GTY ((tag ("dw_val_class_die_ref"))) val_die_ref
;
2397 unsigned GTY ((tag ("dw_val_class_fde_ref"))) val_fde_index
;
2398 struct indirect_string_node
* GTY ((tag ("dw_val_class_str"))) val_str
;
2399 char * GTY ((tag ("dw_val_class_lbl_id"))) val_lbl_id
;
2400 unsigned char GTY ((tag ("dw_val_class_flag"))) val_flag
;
2402 GTY ((desc ("%1.val_class"))) v
;
2406 /* Locations in memory are described using a sequence of stack machine
2409 typedef struct dw_loc_descr_struct
GTY(())
2411 dw_loc_descr_ref dw_loc_next
;
2412 enum dwarf_location_atom dw_loc_opc
;
2413 dw_val_node dw_loc_oprnd1
;
2414 dw_val_node dw_loc_oprnd2
;
2419 /* Location lists are ranges + location descriptions for that range,
2420 so you can track variables that are in different places over
2421 their entire life. */
2422 typedef struct dw_loc_list_struct
GTY(())
2424 dw_loc_list_ref dw_loc_next
;
2425 const char *begin
; /* Label for begin address of range */
2426 const char *end
; /* Label for end address of range */
2427 char *ll_symbol
; /* Label for beginning of location list.
2428 Only on head of list */
2429 const char *section
; /* Section this loclist is relative to */
2430 dw_loc_descr_ref expr
;
2433 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
2435 static const char *dwarf_stack_op_name (unsigned);
2436 static dw_loc_descr_ref
new_loc_descr (enum dwarf_location_atom
,
2437 unsigned HOST_WIDE_INT
, unsigned HOST_WIDE_INT
);
2438 static void add_loc_descr (dw_loc_descr_ref
*, dw_loc_descr_ref
);
2439 static unsigned long size_of_loc_descr (dw_loc_descr_ref
);
2440 static unsigned long size_of_locs (dw_loc_descr_ref
);
2441 static void output_loc_operands (dw_loc_descr_ref
);
2442 static void output_loc_sequence (dw_loc_descr_ref
);
2444 /* Convert a DWARF stack opcode into its string name. */
2447 dwarf_stack_op_name (unsigned int op
)
2452 case INTERNAL_DW_OP_tls_addr
:
2453 return "DW_OP_addr";
2455 return "DW_OP_deref";
2457 return "DW_OP_const1u";
2459 return "DW_OP_const1s";
2461 return "DW_OP_const2u";
2463 return "DW_OP_const2s";
2465 return "DW_OP_const4u";
2467 return "DW_OP_const4s";
2469 return "DW_OP_const8u";
2471 return "DW_OP_const8s";
2473 return "DW_OP_constu";
2475 return "DW_OP_consts";
2479 return "DW_OP_drop";
2481 return "DW_OP_over";
2483 return "DW_OP_pick";
2485 return "DW_OP_swap";
2489 return "DW_OP_xderef";
2497 return "DW_OP_minus";
2509 return "DW_OP_plus";
2510 case DW_OP_plus_uconst
:
2511 return "DW_OP_plus_uconst";
2517 return "DW_OP_shra";
2535 return "DW_OP_skip";
2537 return "DW_OP_lit0";
2539 return "DW_OP_lit1";
2541 return "DW_OP_lit2";
2543 return "DW_OP_lit3";
2545 return "DW_OP_lit4";
2547 return "DW_OP_lit5";
2549 return "DW_OP_lit6";
2551 return "DW_OP_lit7";
2553 return "DW_OP_lit8";
2555 return "DW_OP_lit9";
2557 return "DW_OP_lit10";
2559 return "DW_OP_lit11";
2561 return "DW_OP_lit12";
2563 return "DW_OP_lit13";
2565 return "DW_OP_lit14";
2567 return "DW_OP_lit15";
2569 return "DW_OP_lit16";
2571 return "DW_OP_lit17";
2573 return "DW_OP_lit18";
2575 return "DW_OP_lit19";
2577 return "DW_OP_lit20";
2579 return "DW_OP_lit21";
2581 return "DW_OP_lit22";
2583 return "DW_OP_lit23";
2585 return "DW_OP_lit24";
2587 return "DW_OP_lit25";
2589 return "DW_OP_lit26";
2591 return "DW_OP_lit27";
2593 return "DW_OP_lit28";
2595 return "DW_OP_lit29";
2597 return "DW_OP_lit30";
2599 return "DW_OP_lit31";
2601 return "DW_OP_reg0";
2603 return "DW_OP_reg1";
2605 return "DW_OP_reg2";
2607 return "DW_OP_reg3";
2609 return "DW_OP_reg4";
2611 return "DW_OP_reg5";
2613 return "DW_OP_reg6";
2615 return "DW_OP_reg7";
2617 return "DW_OP_reg8";
2619 return "DW_OP_reg9";
2621 return "DW_OP_reg10";
2623 return "DW_OP_reg11";
2625 return "DW_OP_reg12";
2627 return "DW_OP_reg13";
2629 return "DW_OP_reg14";
2631 return "DW_OP_reg15";
2633 return "DW_OP_reg16";
2635 return "DW_OP_reg17";
2637 return "DW_OP_reg18";
2639 return "DW_OP_reg19";
2641 return "DW_OP_reg20";
2643 return "DW_OP_reg21";
2645 return "DW_OP_reg22";
2647 return "DW_OP_reg23";
2649 return "DW_OP_reg24";
2651 return "DW_OP_reg25";
2653 return "DW_OP_reg26";
2655 return "DW_OP_reg27";
2657 return "DW_OP_reg28";
2659 return "DW_OP_reg29";
2661 return "DW_OP_reg30";
2663 return "DW_OP_reg31";
2665 return "DW_OP_breg0";
2667 return "DW_OP_breg1";
2669 return "DW_OP_breg2";
2671 return "DW_OP_breg3";
2673 return "DW_OP_breg4";
2675 return "DW_OP_breg5";
2677 return "DW_OP_breg6";
2679 return "DW_OP_breg7";
2681 return "DW_OP_breg8";
2683 return "DW_OP_breg9";
2685 return "DW_OP_breg10";
2687 return "DW_OP_breg11";
2689 return "DW_OP_breg12";
2691 return "DW_OP_breg13";
2693 return "DW_OP_breg14";
2695 return "DW_OP_breg15";
2697 return "DW_OP_breg16";
2699 return "DW_OP_breg17";
2701 return "DW_OP_breg18";
2703 return "DW_OP_breg19";
2705 return "DW_OP_breg20";
2707 return "DW_OP_breg21";
2709 return "DW_OP_breg22";
2711 return "DW_OP_breg23";
2713 return "DW_OP_breg24";
2715 return "DW_OP_breg25";
2717 return "DW_OP_breg26";
2719 return "DW_OP_breg27";
2721 return "DW_OP_breg28";
2723 return "DW_OP_breg29";
2725 return "DW_OP_breg30";
2727 return "DW_OP_breg31";
2729 return "DW_OP_regx";
2731 return "DW_OP_fbreg";
2733 return "DW_OP_bregx";
2735 return "DW_OP_piece";
2736 case DW_OP_deref_size
:
2737 return "DW_OP_deref_size";
2738 case DW_OP_xderef_size
:
2739 return "DW_OP_xderef_size";
2742 case DW_OP_push_object_address
:
2743 return "DW_OP_push_object_address";
2745 return "DW_OP_call2";
2747 return "DW_OP_call4";
2748 case DW_OP_call_ref
:
2749 return "DW_OP_call_ref";
2750 case DW_OP_GNU_push_tls_address
:
2751 return "DW_OP_GNU_push_tls_address";
2753 return "OP_<unknown>";
2757 /* Return a pointer to a newly allocated location description. Location
2758 descriptions are simple expression terms that can be strung
2759 together to form more complicated location (address) descriptions. */
2761 static inline dw_loc_descr_ref
2762 new_loc_descr (enum dwarf_location_atom op
, unsigned HOST_WIDE_INT oprnd1
,
2763 unsigned HOST_WIDE_INT oprnd2
)
2765 dw_loc_descr_ref descr
= ggc_alloc_cleared (sizeof (dw_loc_descr_node
));
2767 descr
->dw_loc_opc
= op
;
2768 descr
->dw_loc_oprnd1
.val_class
= dw_val_class_unsigned_const
;
2769 descr
->dw_loc_oprnd1
.v
.val_unsigned
= oprnd1
;
2770 descr
->dw_loc_oprnd2
.val_class
= dw_val_class_unsigned_const
;
2771 descr
->dw_loc_oprnd2
.v
.val_unsigned
= oprnd2
;
2777 /* Add a location description term to a location description expression. */
2780 add_loc_descr (dw_loc_descr_ref
*list_head
, dw_loc_descr_ref descr
)
2782 dw_loc_descr_ref
*d
;
2784 /* Find the end of the chain. */
2785 for (d
= list_head
; (*d
) != NULL
; d
= &(*d
)->dw_loc_next
)
2791 /* Return the size of a location descriptor. */
2793 static unsigned long
2794 size_of_loc_descr (dw_loc_descr_ref loc
)
2796 unsigned long size
= 1;
2798 switch (loc
->dw_loc_opc
)
2801 case INTERNAL_DW_OP_tls_addr
:
2802 size
+= DWARF2_ADDR_SIZE
;
2821 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
2824 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
2829 case DW_OP_plus_uconst
:
2830 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
2868 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
2871 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
2874 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
2877 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
2878 size
+= size_of_sleb128 (loc
->dw_loc_oprnd2
.v
.val_int
);
2881 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
2883 case DW_OP_deref_size
:
2884 case DW_OP_xderef_size
:
2893 case DW_OP_call_ref
:
2894 size
+= DWARF2_ADDR_SIZE
;
2903 /* Return the size of a series of location descriptors. */
2905 static unsigned long
2906 size_of_locs (dw_loc_descr_ref loc
)
2910 for (size
= 0; loc
!= NULL
; loc
= loc
->dw_loc_next
)
2912 loc
->dw_loc_addr
= size
;
2913 size
+= size_of_loc_descr (loc
);
2919 /* Output location description stack opcode's operands (if any). */
2922 output_loc_operands (dw_loc_descr_ref loc
)
2924 dw_val_ref val1
= &loc
->dw_loc_oprnd1
;
2925 dw_val_ref val2
= &loc
->dw_loc_oprnd2
;
2927 switch (loc
->dw_loc_opc
)
2929 #ifdef DWARF2_DEBUGGING_INFO
2931 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, val1
->v
.val_addr
, NULL
);
2935 dw2_asm_output_data (2, val1
->v
.val_int
, NULL
);
2939 dw2_asm_output_data (4, val1
->v
.val_int
, NULL
);
2943 if (HOST_BITS_PER_LONG
< 64)
2945 dw2_asm_output_data (8, val1
->v
.val_int
, NULL
);
2952 if (val1
->val_class
== dw_val_class_loc
)
2953 offset
= val1
->v
.val_loc
->dw_loc_addr
- (loc
->dw_loc_addr
+ 3);
2957 dw2_asm_output_data (2, offset
, NULL
);
2970 /* We currently don't make any attempt to make sure these are
2971 aligned properly like we do for the main unwind info, so
2972 don't support emitting things larger than a byte if we're
2973 only doing unwinding. */
2978 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
2981 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
2984 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
2987 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
2989 case DW_OP_plus_uconst
:
2990 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
3024 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
3027 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
3030 dw2_asm_output_data_sleb128 (val1
->v
.val_int
, NULL
);
3033 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
3034 dw2_asm_output_data_sleb128 (val2
->v
.val_int
, NULL
);
3037 dw2_asm_output_data_uleb128 (val1
->v
.val_unsigned
, NULL
);
3039 case DW_OP_deref_size
:
3040 case DW_OP_xderef_size
:
3041 dw2_asm_output_data (1, val1
->v
.val_int
, NULL
);
3044 case INTERNAL_DW_OP_tls_addr
:
3045 #ifdef ASM_OUTPUT_DWARF_DTPREL
3046 ASM_OUTPUT_DWARF_DTPREL (asm_out_file
, DWARF2_ADDR_SIZE
,
3048 fputc ('\n', asm_out_file
);
3055 /* Other codes have no operands. */
3060 /* Output a sequence of location operations. */
3063 output_loc_sequence (dw_loc_descr_ref loc
)
3065 for (; loc
!= NULL
; loc
= loc
->dw_loc_next
)
3067 /* Output the opcode. */
3068 dw2_asm_output_data (1, loc
->dw_loc_opc
,
3069 "%s", dwarf_stack_op_name (loc
->dw_loc_opc
));
3071 /* Output the operand(s) (if any). */
3072 output_loc_operands (loc
);
3076 /* This routine will generate the correct assembly data for a location
3077 description based on a cfi entry with a complex address. */
3080 output_cfa_loc (dw_cfi_ref cfi
)
3082 dw_loc_descr_ref loc
;
3085 /* Output the size of the block. */
3086 loc
= cfi
->dw_cfi_oprnd1
.dw_cfi_loc
;
3087 size
= size_of_locs (loc
);
3088 dw2_asm_output_data_uleb128 (size
, NULL
);
3090 /* Now output the operations themselves. */
3091 output_loc_sequence (loc
);
3094 /* This function builds a dwarf location descriptor sequence from
3095 a dw_cfa_location. */
3097 static struct dw_loc_descr_struct
*
3098 build_cfa_loc (dw_cfa_location
*cfa
)
3100 struct dw_loc_descr_struct
*head
, *tmp
;
3102 if (cfa
->indirect
== 0)
3105 if (cfa
->base_offset
)
3108 head
= new_loc_descr (DW_OP_breg0
+ cfa
->reg
, cfa
->base_offset
, 0);
3110 head
= new_loc_descr (DW_OP_bregx
, cfa
->reg
, cfa
->base_offset
);
3112 else if (cfa
->reg
<= 31)
3113 head
= new_loc_descr (DW_OP_reg0
+ cfa
->reg
, 0, 0);
3115 head
= new_loc_descr (DW_OP_regx
, cfa
->reg
, 0);
3117 head
->dw_loc_oprnd1
.val_class
= dw_val_class_const
;
3118 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
3119 add_loc_descr (&head
, tmp
);
3120 if (cfa
->offset
!= 0)
3122 tmp
= new_loc_descr (DW_OP_plus_uconst
, cfa
->offset
, 0);
3123 add_loc_descr (&head
, tmp
);
3129 /* This function fills in aa dw_cfa_location structure from a dwarf location
3130 descriptor sequence. */
3133 get_cfa_from_loc_descr (dw_cfa_location
*cfa
, struct dw_loc_descr_struct
*loc
)
3135 struct dw_loc_descr_struct
*ptr
;
3137 cfa
->base_offset
= 0;
3141 for (ptr
= loc
; ptr
!= NULL
; ptr
= ptr
->dw_loc_next
)
3143 enum dwarf_location_atom op
= ptr
->dw_loc_opc
;
3179 cfa
->reg
= op
- DW_OP_reg0
;
3182 cfa
->reg
= ptr
->dw_loc_oprnd1
.v
.val_int
;
3216 cfa
->reg
= op
- DW_OP_breg0
;
3217 cfa
->base_offset
= ptr
->dw_loc_oprnd1
.v
.val_int
;
3220 cfa
->reg
= ptr
->dw_loc_oprnd1
.v
.val_int
;
3221 cfa
->base_offset
= ptr
->dw_loc_oprnd2
.v
.val_int
;
3226 case DW_OP_plus_uconst
:
3227 cfa
->offset
= ptr
->dw_loc_oprnd1
.v
.val_unsigned
;
3230 internal_error ("DW_LOC_OP %s not implemented\n",
3231 dwarf_stack_op_name (ptr
->dw_loc_opc
));
3235 #endif /* .debug_frame support */
3237 /* And now, the support for symbolic debugging information. */
3238 #ifdef DWARF2_DEBUGGING_INFO
3240 /* .debug_str support. */
3241 static int output_indirect_string (void **, void *);
3243 static void dwarf2out_init (const char *);
3244 static void dwarf2out_finish (const char *);
3245 static void dwarf2out_define (unsigned int, const char *);
3246 static void dwarf2out_undef (unsigned int, const char *);
3247 static void dwarf2out_start_source_file (unsigned, const char *);
3248 static void dwarf2out_end_source_file (unsigned);
3249 static void dwarf2out_begin_block (unsigned, unsigned);
3250 static void dwarf2out_end_block (unsigned, unsigned);
3251 static bool dwarf2out_ignore_block (tree
);
3252 static void dwarf2out_global_decl (tree
);
3253 static void dwarf2out_type_decl (tree
, int);
3254 static void dwarf2out_imported_module_or_decl (tree
, tree
);
3255 static void dwarf2out_abstract_function (tree
);
3256 static void dwarf2out_var_location (rtx
);
3257 static void dwarf2out_begin_function (tree
);
3259 /* The debug hooks structure. */
3261 const struct gcc_debug_hooks dwarf2_debug_hooks
=
3267 dwarf2out_start_source_file
,
3268 dwarf2out_end_source_file
,
3269 dwarf2out_begin_block
,
3270 dwarf2out_end_block
,
3271 dwarf2out_ignore_block
,
3272 dwarf2out_source_line
,
3273 dwarf2out_begin_prologue
,
3274 debug_nothing_int_charstar
, /* end_prologue */
3275 dwarf2out_end_epilogue
,
3276 dwarf2out_begin_function
,
3277 debug_nothing_int
, /* end_function */
3278 dwarf2out_decl
, /* function_decl */
3279 dwarf2out_global_decl
,
3280 dwarf2out_type_decl
, /* type_decl */
3281 dwarf2out_imported_module_or_decl
,
3282 debug_nothing_tree
, /* deferred_inline_function */
3283 /* The DWARF 2 backend tries to reduce debugging bloat by not
3284 emitting the abstract description of inline functions until
3285 something tries to reference them. */
3286 dwarf2out_abstract_function
, /* outlining_inline_function */
3287 debug_nothing_rtx
, /* label */
3288 debug_nothing_int
, /* handle_pch */
3289 dwarf2out_var_location
3293 /* NOTE: In the comments in this file, many references are made to
3294 "Debugging Information Entries". This term is abbreviated as `DIE'
3295 throughout the remainder of this file. */
3297 /* An internal representation of the DWARF output is built, and then
3298 walked to generate the DWARF debugging info. The walk of the internal
3299 representation is done after the entire program has been compiled.
3300 The types below are used to describe the internal representation. */
3302 /* Various DIE's use offsets relative to the beginning of the
3303 .debug_info section to refer to each other. */
3305 typedef long int dw_offset
;
3307 /* Define typedefs here to avoid circular dependencies. */
3309 typedef struct dw_attr_struct
*dw_attr_ref
;
3310 typedef struct dw_line_info_struct
*dw_line_info_ref
;
3311 typedef struct dw_separate_line_info_struct
*dw_separate_line_info_ref
;
3312 typedef struct pubname_struct
*pubname_ref
;
3313 typedef struct dw_ranges_struct
*dw_ranges_ref
;
3315 /* Each entry in the line_info_table maintains the file and
3316 line number associated with the label generated for that
3317 entry. The label gives the PC value associated with
3318 the line number entry. */
3320 typedef struct dw_line_info_struct
GTY(())
3322 unsigned long dw_file_num
;
3323 unsigned long dw_line_num
;
3327 /* Line information for functions in separate sections; each one gets its
3329 typedef struct dw_separate_line_info_struct
GTY(())
3331 unsigned long dw_file_num
;
3332 unsigned long dw_line_num
;
3333 unsigned long function
;
3335 dw_separate_line_info_entry
;
3337 /* Each DIE attribute has a field specifying the attribute kind,
3338 a link to the next attribute in the chain, and an attribute value.
3339 Attributes are typically linked below the DIE they modify. */
3341 typedef struct dw_attr_struct
GTY(())
3343 enum dwarf_attribute dw_attr
;
3344 dw_attr_ref dw_attr_next
;
3345 dw_val_node dw_attr_val
;
3349 /* The Debugging Information Entry (DIE) structure */
3351 typedef struct die_struct
GTY(())
3353 enum dwarf_tag die_tag
;
3355 dw_attr_ref die_attr
;
3356 dw_die_ref die_parent
;
3357 dw_die_ref die_child
;
3359 dw_die_ref die_definition
; /* ref from a specification to its definition */
3360 dw_offset die_offset
;
3361 unsigned long die_abbrev
;
3363 unsigned int decl_id
;
3367 /* The pubname structure */
3369 typedef struct pubname_struct
GTY(())
3376 struct dw_ranges_struct
GTY(())
3381 /* The limbo die list structure. */
3382 typedef struct limbo_die_struct
GTY(())
3386 struct limbo_die_struct
*next
;
3390 /* How to start an assembler comment. */
3391 #ifndef ASM_COMMENT_START
3392 #define ASM_COMMENT_START ";#"
3395 /* Define a macro which returns nonzero for a TYPE_DECL which was
3396 implicitly generated for a tagged type.
3398 Note that unlike the gcc front end (which generates a NULL named
3399 TYPE_DECL node for each complete tagged type, each array type, and
3400 each function type node created) the g++ front end generates a
3401 _named_ TYPE_DECL node for each tagged type node created.
3402 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
3403 generate a DW_TAG_typedef DIE for them. */
3405 #define TYPE_DECL_IS_STUB(decl) \
3406 (DECL_NAME (decl) == NULL_TREE \
3407 || (DECL_ARTIFICIAL (decl) \
3408 && is_tagged_type (TREE_TYPE (decl)) \
3409 && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \
3410 /* This is necessary for stub decls that \
3411 appear in nested inline functions. */ \
3412 || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
3413 && (decl_ultimate_origin (decl) \
3414 == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
3416 /* Information concerning the compilation unit's programming
3417 language, and compiler version. */
3419 /* Fixed size portion of the DWARF compilation unit header. */
3420 #define DWARF_COMPILE_UNIT_HEADER_SIZE \
3421 (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 3)
3423 /* Fixed size portion of public names info. */
3424 #define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
3426 /* Fixed size portion of the address range info. */
3427 #define DWARF_ARANGES_HEADER_SIZE \
3428 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
3429 DWARF2_ADDR_SIZE * 2) \
3430 - DWARF_INITIAL_LENGTH_SIZE)
3432 /* Size of padding portion in the address range info. It must be
3433 aligned to twice the pointer size. */
3434 #define DWARF_ARANGES_PAD_SIZE \
3435 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
3436 DWARF2_ADDR_SIZE * 2) \
3437 - (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4))
3439 /* Use assembler line directives if available. */
3440 #ifndef DWARF2_ASM_LINE_DEBUG_INFO
3441 #ifdef HAVE_AS_DWARF2_DEBUG_LINE
3442 #define DWARF2_ASM_LINE_DEBUG_INFO 1
3444 #define DWARF2_ASM_LINE_DEBUG_INFO 0
3448 /* Minimum line offset in a special line info. opcode.
3449 This value was chosen to give a reasonable range of values. */
3450 #define DWARF_LINE_BASE -10
3452 /* First special line opcode - leave room for the standard opcodes. */
3453 #define DWARF_LINE_OPCODE_BASE 10
3455 /* Range of line offsets in a special line info. opcode. */
3456 #define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1)
3458 /* Flag that indicates the initial value of the is_stmt_start flag.
3459 In the present implementation, we do not mark any lines as
3460 the beginning of a source statement, because that information
3461 is not made available by the GCC front-end. */
3462 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
3464 #ifdef DWARF2_DEBUGGING_INFO
3465 /* This location is used by calc_die_sizes() to keep track
3466 the offset of each DIE within the .debug_info section. */
3467 static unsigned long next_die_offset
;
3470 /* Record the root of the DIE's built for the current compilation unit. */
3471 static GTY(()) dw_die_ref comp_unit_die
;
3473 /* A list of DIEs with a NULL parent waiting to be relocated. */
3474 static GTY(()) limbo_die_node
*limbo_die_list
;
3476 /* Filenames referenced by this compilation unit. */
3477 static GTY(()) varray_type file_table
;
3478 static GTY(()) varray_type file_table_emitted
;
3479 static GTY(()) size_t file_table_last_lookup_index
;
3481 /* A hash table of references to DIE's that describe declarations.
3482 The key is a DECL_UID() which is a unique number identifying each decl. */
3483 static GTY ((param_is (struct die_struct
))) htab_t decl_die_table
;
3485 /* Node of the variable location list. */
3486 struct var_loc_node
GTY ((chain_next ("%h.next")))
3488 rtx
GTY (()) var_loc_note
;
3489 const char * GTY (()) label
;
3490 struct var_loc_node
* GTY (()) next
;
3493 /* Variable location list. */
3494 struct var_loc_list_def
GTY (())
3496 struct var_loc_node
* GTY (()) first
;
3498 /* Do not mark the last element of the chained list because
3499 it is marked through the chain. */
3500 struct var_loc_node
* GTY ((skip ("%h"))) last
;
3502 /* DECL_UID of the variable decl. */
3503 unsigned int decl_id
;
3505 typedef struct var_loc_list_def var_loc_list
;
3508 /* Table of decl location linked lists. */
3509 static GTY ((param_is (var_loc_list
))) htab_t decl_loc_table
;
3511 /* A pointer to the base of a list of references to DIE's that
3512 are uniquely identified by their tag, presence/absence of
3513 children DIE's, and list of attribute/value pairs. */
3514 static GTY((length ("abbrev_die_table_allocated")))
3515 dw_die_ref
*abbrev_die_table
;
3517 /* Number of elements currently allocated for abbrev_die_table. */
3518 static GTY(()) unsigned abbrev_die_table_allocated
;
3520 /* Number of elements in type_die_table currently in use. */
3521 static GTY(()) unsigned abbrev_die_table_in_use
;
3523 /* Size (in elements) of increments by which we may expand the
3524 abbrev_die_table. */
3525 #define ABBREV_DIE_TABLE_INCREMENT 256
3527 /* A pointer to the base of a table that contains line information
3528 for each source code line in .text in the compilation unit. */
3529 static GTY((length ("line_info_table_allocated")))
3530 dw_line_info_ref line_info_table
;
3532 /* Number of elements currently allocated for line_info_table. */
3533 static GTY(()) unsigned line_info_table_allocated
;
3535 /* Number of elements in line_info_table currently in use. */
3536 static GTY(()) unsigned line_info_table_in_use
;
3538 /* A pointer to the base of a table that contains line information
3539 for each source code line outside of .text in the compilation unit. */
3540 static GTY ((length ("separate_line_info_table_allocated")))
3541 dw_separate_line_info_ref separate_line_info_table
;
3543 /* Number of elements currently allocated for separate_line_info_table. */
3544 static GTY(()) unsigned separate_line_info_table_allocated
;
3546 /* Number of elements in separate_line_info_table currently in use. */
3547 static GTY(()) unsigned separate_line_info_table_in_use
;
3549 /* Size (in elements) of increments by which we may expand the
3551 #define LINE_INFO_TABLE_INCREMENT 1024
3553 /* A pointer to the base of a table that contains a list of publicly
3554 accessible names. */
3555 static GTY ((length ("pubname_table_allocated"))) pubname_ref pubname_table
;
3557 /* Number of elements currently allocated for pubname_table. */
3558 static GTY(()) unsigned pubname_table_allocated
;
3560 /* Number of elements in pubname_table currently in use. */
3561 static GTY(()) unsigned pubname_table_in_use
;
3563 /* Size (in elements) of increments by which we may expand the
3565 #define PUBNAME_TABLE_INCREMENT 64
3567 /* Array of dies for which we should generate .debug_arange info. */
3568 static GTY((length ("arange_table_allocated"))) dw_die_ref
*arange_table
;
3570 /* Number of elements currently allocated for arange_table. */
3571 static GTY(()) unsigned arange_table_allocated
;
3573 /* Number of elements in arange_table currently in use. */
3574 static GTY(()) unsigned arange_table_in_use
;
3576 /* Size (in elements) of increments by which we may expand the
3578 #define ARANGE_TABLE_INCREMENT 64
3580 /* Array of dies for which we should generate .debug_ranges info. */
3581 static GTY ((length ("ranges_table_allocated"))) dw_ranges_ref ranges_table
;
3583 /* Number of elements currently allocated for ranges_table. */
3584 static GTY(()) unsigned ranges_table_allocated
;
3586 /* Number of elements in ranges_table currently in use. */
3587 static GTY(()) unsigned ranges_table_in_use
;
3589 /* Size (in elements) of increments by which we may expand the
3591 #define RANGES_TABLE_INCREMENT 64
3593 /* Whether we have location lists that need outputting */
3594 static GTY(()) unsigned have_location_lists
;
3596 /* Unique label counter. */
3597 static GTY(()) unsigned int loclabel_num
;
3599 #ifdef DWARF2_DEBUGGING_INFO
3600 /* Record whether the function being analyzed contains inlined functions. */
3601 static int current_function_has_inlines
;
3603 #if 0 && defined (MIPS_DEBUGGING_INFO)
3604 static int comp_unit_has_inlines
;
3607 /* Number of file tables emitted in maybe_emit_file(). */
3608 static GTY(()) int emitcount
= 0;
3610 /* Number of internal labels generated by gen_internal_sym(). */
3611 static GTY(()) int label_num
;
3613 #ifdef DWARF2_DEBUGGING_INFO
3615 /* Forward declarations for functions defined in this file. */
3617 static int is_pseudo_reg (rtx
);
3618 static tree
type_main_variant (tree
);
3619 static int is_tagged_type (tree
);
3620 static const char *dwarf_tag_name (unsigned);
3621 static const char *dwarf_attr_name (unsigned);
3622 static const char *dwarf_form_name (unsigned);
3624 static const char *dwarf_type_encoding_name (unsigned);
3626 static tree
decl_ultimate_origin (tree
);
3627 static tree
block_ultimate_origin (tree
);
3628 static tree
decl_class_context (tree
);
3629 static void add_dwarf_attr (dw_die_ref
, dw_attr_ref
);
3630 static inline enum dw_val_class
AT_class (dw_attr_ref
);
3631 static void add_AT_flag (dw_die_ref
, enum dwarf_attribute
, unsigned);
3632 static inline unsigned AT_flag (dw_attr_ref
);
3633 static void add_AT_int (dw_die_ref
, enum dwarf_attribute
, HOST_WIDE_INT
);
3634 static inline HOST_WIDE_INT
AT_int (dw_attr_ref
);
3635 static void add_AT_unsigned (dw_die_ref
, enum dwarf_attribute
, unsigned HOST_WIDE_INT
);
3636 static inline unsigned HOST_WIDE_INT
AT_unsigned (dw_attr_ref
);
3637 static void add_AT_long_long (dw_die_ref
, enum dwarf_attribute
, unsigned long,
3639 static inline void add_AT_vec (dw_die_ref
, enum dwarf_attribute
, unsigned int,
3640 unsigned int, unsigned char *);
3641 static hashval_t
debug_str_do_hash (const void *);
3642 static int debug_str_eq (const void *, const void *);
3643 static void add_AT_string (dw_die_ref
, enum dwarf_attribute
, const char *);
3644 static inline const char *AT_string (dw_attr_ref
);
3645 static int AT_string_form (dw_attr_ref
);
3646 static void add_AT_die_ref (dw_die_ref
, enum dwarf_attribute
, dw_die_ref
);
3647 static void add_AT_specification (dw_die_ref
, dw_die_ref
);
3648 static inline dw_die_ref
AT_ref (dw_attr_ref
);
3649 static inline int AT_ref_external (dw_attr_ref
);
3650 static inline void set_AT_ref_external (dw_attr_ref
, int);
3651 static void add_AT_fde_ref (dw_die_ref
, enum dwarf_attribute
, unsigned);
3652 static void add_AT_loc (dw_die_ref
, enum dwarf_attribute
, dw_loc_descr_ref
);
3653 static inline dw_loc_descr_ref
AT_loc (dw_attr_ref
);
3654 static void add_AT_loc_list (dw_die_ref
, enum dwarf_attribute
,
3656 static inline dw_loc_list_ref
AT_loc_list (dw_attr_ref
);
3657 static void add_AT_addr (dw_die_ref
, enum dwarf_attribute
, rtx
);
3658 static inline rtx
AT_addr (dw_attr_ref
);
3659 static void add_AT_lbl_id (dw_die_ref
, enum dwarf_attribute
, const char *);
3660 static void add_AT_lbl_offset (dw_die_ref
, enum dwarf_attribute
, const char *);
3661 static void add_AT_offset (dw_die_ref
, enum dwarf_attribute
,
3662 unsigned HOST_WIDE_INT
);
3663 static void add_AT_range_list (dw_die_ref
, enum dwarf_attribute
,
3665 static inline const char *AT_lbl (dw_attr_ref
);
3666 static dw_attr_ref
get_AT (dw_die_ref
, enum dwarf_attribute
);
3667 static const char *get_AT_low_pc (dw_die_ref
);
3668 static const char *get_AT_hi_pc (dw_die_ref
);
3669 static const char *get_AT_string (dw_die_ref
, enum dwarf_attribute
);
3670 static int get_AT_flag (dw_die_ref
, enum dwarf_attribute
);
3671 static unsigned get_AT_unsigned (dw_die_ref
, enum dwarf_attribute
);
3672 static inline dw_die_ref
get_AT_ref (dw_die_ref
, enum dwarf_attribute
);
3673 static bool is_c_family (void);
3674 static bool is_cxx (void);
3675 static bool is_java (void);
3676 static bool is_fortran (void);
3677 static bool is_ada (void);
3678 static void remove_AT (dw_die_ref
, enum dwarf_attribute
);
3679 static void remove_child_TAG (dw_die_ref
, enum dwarf_tag
);
3680 static inline void free_die (dw_die_ref
);
3681 static void remove_children (dw_die_ref
);
3682 static void add_child_die (dw_die_ref
, dw_die_ref
);
3683 static dw_die_ref
new_die (enum dwarf_tag
, dw_die_ref
, tree
);
3684 static dw_die_ref
lookup_type_die (tree
);
3685 static void equate_type_number_to_die (tree
, dw_die_ref
);
3686 static hashval_t
decl_die_table_hash (const void *);
3687 static int decl_die_table_eq (const void *, const void *);
3688 static dw_die_ref
lookup_decl_die (tree
);
3689 static hashval_t
decl_loc_table_hash (const void *);
3690 static int decl_loc_table_eq (const void *, const void *);
3691 static var_loc_list
*lookup_decl_loc (tree
);
3692 static void equate_decl_number_to_die (tree
, dw_die_ref
);
3693 static void add_var_loc_to_decl (tree
, struct var_loc_node
*);
3694 static void print_spaces (FILE *);
3695 static void print_die (dw_die_ref
, FILE *);
3696 static void print_dwarf_line_table (FILE *);
3697 static void reverse_die_lists (dw_die_ref
);
3698 static void reverse_all_dies (dw_die_ref
);
3699 static dw_die_ref
push_new_compile_unit (dw_die_ref
, dw_die_ref
);
3700 static dw_die_ref
pop_compile_unit (dw_die_ref
);
3701 static void loc_checksum (dw_loc_descr_ref
, struct md5_ctx
*);
3702 static void attr_checksum (dw_attr_ref
, struct md5_ctx
*, int *);
3703 static void die_checksum (dw_die_ref
, struct md5_ctx
*, int *);
3704 static int same_loc_p (dw_loc_descr_ref
, dw_loc_descr_ref
, int *);
3705 static int same_dw_val_p (dw_val_node
*, dw_val_node
*, int *);
3706 static int same_attr_p (dw_attr_ref
, dw_attr_ref
, int *);
3707 static int same_die_p (dw_die_ref
, dw_die_ref
, int *);
3708 static int same_die_p_wrap (dw_die_ref
, dw_die_ref
);
3709 static void compute_section_prefix (dw_die_ref
);
3710 static int is_type_die (dw_die_ref
);
3711 static int is_comdat_die (dw_die_ref
);
3712 static int is_symbol_die (dw_die_ref
);
3713 static void assign_symbol_names (dw_die_ref
);
3714 static void break_out_includes (dw_die_ref
);
3715 static hashval_t
htab_cu_hash (const void *);
3716 static int htab_cu_eq (const void *, const void *);
3717 static void htab_cu_del (void *);
3718 static int check_duplicate_cu (dw_die_ref
, htab_t
, unsigned *);
3719 static void record_comdat_symbol_number (dw_die_ref
, htab_t
, unsigned);
3720 static void add_sibling_attributes (dw_die_ref
);
3721 static void build_abbrev_table (dw_die_ref
);
3722 static void output_location_lists (dw_die_ref
);
3723 static int constant_size (long unsigned);
3724 static unsigned long size_of_die (dw_die_ref
);
3725 static void calc_die_sizes (dw_die_ref
);
3726 static void mark_dies (dw_die_ref
);
3727 static void unmark_dies (dw_die_ref
);
3728 static void unmark_all_dies (dw_die_ref
);
3729 static unsigned long size_of_pubnames (void);
3730 static unsigned long size_of_aranges (void);
3731 static enum dwarf_form
value_format (dw_attr_ref
);
3732 static void output_value_format (dw_attr_ref
);
3733 static void output_abbrev_section (void);
3734 static void output_die_symbol (dw_die_ref
);
3735 static void output_die (dw_die_ref
);
3736 static void output_compilation_unit_header (void);
3737 static void output_comp_unit (dw_die_ref
, int);
3738 static const char *dwarf2_name (tree
, int);
3739 static void add_pubname (tree
, dw_die_ref
);
3740 static void output_pubnames (void);
3741 static void add_arange (tree
, dw_die_ref
);
3742 static void output_aranges (void);
3743 static unsigned int add_ranges (tree
);
3744 static void output_ranges (void);
3745 static void output_line_info (void);
3746 static void output_file_names (void);
3747 static dw_die_ref
base_type_die (tree
);
3748 static tree
root_type (tree
);
3749 static int is_base_type (tree
);
3750 static bool is_subrange_type (tree
);
3751 static dw_die_ref
subrange_type_die (tree
, dw_die_ref
);
3752 static dw_die_ref
modified_type_die (tree
, int, int, dw_die_ref
);
3753 static int type_is_enum (tree
);
3754 static unsigned int reg_number (rtx
);
3755 static dw_loc_descr_ref
reg_loc_descriptor (rtx
);
3756 static dw_loc_descr_ref
one_reg_loc_descriptor (unsigned int);
3757 static dw_loc_descr_ref
multiple_reg_loc_descriptor (rtx
, rtx
);
3758 static dw_loc_descr_ref
int_loc_descriptor (HOST_WIDE_INT
);
3759 static dw_loc_descr_ref
based_loc_descr (unsigned, HOST_WIDE_INT
, bool);
3760 static int is_based_loc (rtx
);
3761 static dw_loc_descr_ref
mem_loc_descriptor (rtx
, enum machine_mode mode
, bool);
3762 static dw_loc_descr_ref
concat_loc_descriptor (rtx
, rtx
);
3763 static dw_loc_descr_ref
loc_descriptor (rtx
, bool);
3764 static dw_loc_descr_ref
loc_descriptor_from_tree (tree
, int);
3765 static HOST_WIDE_INT
ceiling (HOST_WIDE_INT
, unsigned int);
3766 static tree
field_type (tree
);
3767 static unsigned int simple_type_align_in_bits (tree
);
3768 static unsigned int simple_decl_align_in_bits (tree
);
3769 static unsigned HOST_WIDE_INT
simple_type_size_in_bits (tree
);
3770 static HOST_WIDE_INT
field_byte_offset (tree
);
3771 static void add_AT_location_description (dw_die_ref
, enum dwarf_attribute
,
3773 static void add_data_member_location_attribute (dw_die_ref
, tree
);
3774 static void add_const_value_attribute (dw_die_ref
, rtx
);
3775 static void insert_int (HOST_WIDE_INT
, unsigned, unsigned char *);
3776 static HOST_WIDE_INT
extract_int (const unsigned char *, unsigned);
3777 static void insert_float (rtx
, unsigned char *);
3778 static rtx
rtl_for_decl_location (tree
);
3779 static void add_location_or_const_value_attribute (dw_die_ref
, tree
,
3780 enum dwarf_attribute
);
3781 static void tree_add_const_value_attribute (dw_die_ref
, tree
);
3782 static void add_name_attribute (dw_die_ref
, const char *);
3783 static void add_comp_dir_attribute (dw_die_ref
);
3784 static void add_bound_info (dw_die_ref
, enum dwarf_attribute
, tree
);
3785 static void add_subscript_info (dw_die_ref
, tree
);
3786 static void add_byte_size_attribute (dw_die_ref
, tree
);
3787 static void add_bit_offset_attribute (dw_die_ref
, tree
);
3788 static void add_bit_size_attribute (dw_die_ref
, tree
);
3789 static void add_prototyped_attribute (dw_die_ref
, tree
);
3790 static void add_abstract_origin_attribute (dw_die_ref
, tree
);
3791 static void add_pure_or_virtual_attribute (dw_die_ref
, tree
);
3792 static void add_src_coords_attributes (dw_die_ref
, tree
);
3793 static void add_name_and_src_coords_attributes (dw_die_ref
, tree
);
3794 static void push_decl_scope (tree
);
3795 static void pop_decl_scope (void);
3796 static dw_die_ref
scope_die_for (tree
, dw_die_ref
);
3797 static inline int local_scope_p (dw_die_ref
);
3798 static inline int class_or_namespace_scope_p (dw_die_ref
);
3799 static void add_type_attribute (dw_die_ref
, tree
, int, int, dw_die_ref
);
3800 static const char *type_tag (tree
);
3801 static tree
member_declared_type (tree
);
3803 static const char *decl_start_label (tree
);
3805 static void gen_array_type_die (tree
, dw_die_ref
);
3806 static void gen_set_type_die (tree
, dw_die_ref
);
3808 static void gen_entry_point_die (tree
, dw_die_ref
);
3810 static void gen_inlined_enumeration_type_die (tree
, dw_die_ref
);
3811 static void gen_inlined_structure_type_die (tree
, dw_die_ref
);
3812 static void gen_inlined_union_type_die (tree
, dw_die_ref
);
3813 static dw_die_ref
gen_enumeration_type_die (tree
, dw_die_ref
);
3814 static dw_die_ref
gen_formal_parameter_die (tree
, dw_die_ref
);
3815 static void gen_unspecified_parameters_die (tree
, dw_die_ref
);
3816 static void gen_formal_types_die (tree
, dw_die_ref
);
3817 static void gen_subprogram_die (tree
, dw_die_ref
);
3818 static void gen_variable_die (tree
, dw_die_ref
);
3819 static void gen_label_die (tree
, dw_die_ref
);
3820 static void gen_lexical_block_die (tree
, dw_die_ref
, int);
3821 static void gen_inlined_subroutine_die (tree
, dw_die_ref
, int);
3822 static void gen_field_die (tree
, dw_die_ref
);
3823 static void gen_ptr_to_mbr_type_die (tree
, dw_die_ref
);
3824 static dw_die_ref
gen_compile_unit_die (const char *);
3825 static void gen_string_type_die (tree
, dw_die_ref
);
3826 static void gen_inheritance_die (tree
, tree
, dw_die_ref
);
3827 static void gen_member_die (tree
, dw_die_ref
);
3828 static void gen_struct_or_union_type_die (tree
, dw_die_ref
);
3829 static void gen_subroutine_type_die (tree
, dw_die_ref
);
3830 static void gen_typedef_die (tree
, dw_die_ref
);
3831 static void gen_type_die (tree
, dw_die_ref
);
3832 static void gen_tagged_type_instantiation_die (tree
, dw_die_ref
);
3833 static void gen_block_die (tree
, dw_die_ref
, int);
3834 static void decls_for_scope (tree
, dw_die_ref
, int);
3835 static int is_redundant_typedef (tree
);
3836 static void gen_namespace_die (tree
);
3837 static void gen_decl_die (tree
, dw_die_ref
);
3838 static dw_die_ref
force_decl_die (tree
);
3839 static dw_die_ref
force_type_die (tree
);
3840 static dw_die_ref
setup_namespace_context (tree
, dw_die_ref
);
3841 static void declare_in_namespace (tree
, dw_die_ref
);
3842 static unsigned lookup_filename (const char *);
3843 static void init_file_table (void);
3844 static void retry_incomplete_types (void);
3845 static void gen_type_die_for_member (tree
, tree
, dw_die_ref
);
3846 static void splice_child_die (dw_die_ref
, dw_die_ref
);
3847 static int file_info_cmp (const void *, const void *);
3848 static dw_loc_list_ref
new_loc_list (dw_loc_descr_ref
, const char *,
3849 const char *, const char *, unsigned);
3850 static void add_loc_descr_to_loc_list (dw_loc_list_ref
*, dw_loc_descr_ref
,
3851 const char *, const char *,
3853 static void output_loc_list (dw_loc_list_ref
);
3854 static char *gen_internal_sym (const char *);
3856 static void prune_unmark_dies (dw_die_ref
);
3857 static void prune_unused_types_mark (dw_die_ref
, int);
3858 static void prune_unused_types_walk (dw_die_ref
);
3859 static void prune_unused_types_walk_attribs (dw_die_ref
);
3860 static void prune_unused_types_prune (dw_die_ref
);
3861 static void prune_unused_types (void);
3862 static int maybe_emit_file (int);
3864 /* Section names used to hold DWARF debugging information. */
3865 #ifndef DEBUG_INFO_SECTION
3866 #define DEBUG_INFO_SECTION ".debug_info"
3868 #ifndef DEBUG_ABBREV_SECTION
3869 #define DEBUG_ABBREV_SECTION ".debug_abbrev"
3871 #ifndef DEBUG_ARANGES_SECTION
3872 #define DEBUG_ARANGES_SECTION ".debug_aranges"
3874 #ifndef DEBUG_MACINFO_SECTION
3875 #define DEBUG_MACINFO_SECTION ".debug_macinfo"
3877 #ifndef DEBUG_LINE_SECTION
3878 #define DEBUG_LINE_SECTION ".debug_line"
3880 #ifndef DEBUG_LOC_SECTION
3881 #define DEBUG_LOC_SECTION ".debug_loc"
3883 #ifndef DEBUG_PUBNAMES_SECTION
3884 #define DEBUG_PUBNAMES_SECTION ".debug_pubnames"
3886 #ifndef DEBUG_STR_SECTION
3887 #define DEBUG_STR_SECTION ".debug_str"
3889 #ifndef DEBUG_RANGES_SECTION
3890 #define DEBUG_RANGES_SECTION ".debug_ranges"
3893 /* Standard ELF section names for compiled code and data. */
3894 #ifndef TEXT_SECTION_NAME
3895 #define TEXT_SECTION_NAME ".text"
3898 /* Section flags for .debug_str section. */
3899 #define DEBUG_STR_SECTION_FLAGS \
3900 (HAVE_GAS_SHF_MERGE && flag_merge_constants \
3901 ? SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1 \
3904 /* Labels we insert at beginning sections we can reference instead of
3905 the section names themselves. */
3907 #ifndef TEXT_SECTION_LABEL
3908 #define TEXT_SECTION_LABEL "Ltext"
3910 #ifndef DEBUG_LINE_SECTION_LABEL
3911 #define DEBUG_LINE_SECTION_LABEL "Ldebug_line"
3913 #ifndef DEBUG_INFO_SECTION_LABEL
3914 #define DEBUG_INFO_SECTION_LABEL "Ldebug_info"
3916 #ifndef DEBUG_ABBREV_SECTION_LABEL
3917 #define DEBUG_ABBREV_SECTION_LABEL "Ldebug_abbrev"
3919 #ifndef DEBUG_LOC_SECTION_LABEL
3920 #define DEBUG_LOC_SECTION_LABEL "Ldebug_loc"
3922 #ifndef DEBUG_RANGES_SECTION_LABEL
3923 #define DEBUG_RANGES_SECTION_LABEL "Ldebug_ranges"
3925 #ifndef DEBUG_MACINFO_SECTION_LABEL
3926 #define DEBUG_MACINFO_SECTION_LABEL "Ldebug_macinfo"
3929 /* Definitions of defaults for formats and names of various special
3930 (artificial) labels which may be generated within this file (when the -g
3931 options is used and DWARF2_DEBUGGING_INFO is in effect.
3932 If necessary, these may be overridden from within the tm.h file, but
3933 typically, overriding these defaults is unnecessary. */
3935 static char text_end_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3936 static char text_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3937 static char abbrev_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3938 static char debug_info_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3939 static char debug_line_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3940 static char macinfo_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3941 static char loc_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
3942 static char ranges_section_label
[2 * MAX_ARTIFICIAL_LABEL_BYTES
];
3944 #ifndef TEXT_END_LABEL
3945 #define TEXT_END_LABEL "Letext"
3947 #ifndef BLOCK_BEGIN_LABEL
3948 #define BLOCK_BEGIN_LABEL "LBB"
3950 #ifndef BLOCK_END_LABEL
3951 #define BLOCK_END_LABEL "LBE"
3953 #ifndef LINE_CODE_LABEL
3954 #define LINE_CODE_LABEL "LM"
3956 #ifndef SEPARATE_LINE_CODE_LABEL
3957 #define SEPARATE_LINE_CODE_LABEL "LSM"
3960 /* We allow a language front-end to designate a function that is to be
3961 called to "demangle" any name before it it put into a DIE. */
3963 static const char *(*demangle_name_func
) (const char *);
3966 dwarf2out_set_demangle_name_func (const char *(*func
) (const char *))
3968 demangle_name_func
= func
;
3971 /* Test if rtl node points to a pseudo register. */
3974 is_pseudo_reg (rtx rtl
)
3976 return ((GET_CODE (rtl
) == REG
&& REGNO (rtl
) >= FIRST_PSEUDO_REGISTER
)
3977 || (GET_CODE (rtl
) == SUBREG
3978 && REGNO (SUBREG_REG (rtl
)) >= FIRST_PSEUDO_REGISTER
));
3981 /* Return a reference to a type, with its const and volatile qualifiers
3985 type_main_variant (tree type
)
3987 type
= TYPE_MAIN_VARIANT (type
);
3989 /* ??? There really should be only one main variant among any group of
3990 variants of a given type (and all of the MAIN_VARIANT values for all
3991 members of the group should point to that one type) but sometimes the C
3992 front-end messes this up for array types, so we work around that bug
3994 if (TREE_CODE (type
) == ARRAY_TYPE
)
3995 while (type
!= TYPE_MAIN_VARIANT (type
))
3996 type
= TYPE_MAIN_VARIANT (type
);
4001 /* Return nonzero if the given type node represents a tagged type. */
4004 is_tagged_type (tree type
)
4006 enum tree_code code
= TREE_CODE (type
);
4008 return (code
== RECORD_TYPE
|| code
== UNION_TYPE
4009 || code
== QUAL_UNION_TYPE
|| code
== ENUMERAL_TYPE
);
4012 /* Convert a DIE tag into its string name. */
4015 dwarf_tag_name (unsigned int tag
)
4019 case DW_TAG_padding
:
4020 return "DW_TAG_padding";
4021 case DW_TAG_array_type
:
4022 return "DW_TAG_array_type";
4023 case DW_TAG_class_type
:
4024 return "DW_TAG_class_type";
4025 case DW_TAG_entry_point
:
4026 return "DW_TAG_entry_point";
4027 case DW_TAG_enumeration_type
:
4028 return "DW_TAG_enumeration_type";
4029 case DW_TAG_formal_parameter
:
4030 return "DW_TAG_formal_parameter";
4031 case DW_TAG_imported_declaration
:
4032 return "DW_TAG_imported_declaration";
4034 return "DW_TAG_label";
4035 case DW_TAG_lexical_block
:
4036 return "DW_TAG_lexical_block";
4038 return "DW_TAG_member";
4039 case DW_TAG_pointer_type
:
4040 return "DW_TAG_pointer_type";
4041 case DW_TAG_reference_type
:
4042 return "DW_TAG_reference_type";
4043 case DW_TAG_compile_unit
:
4044 return "DW_TAG_compile_unit";
4045 case DW_TAG_string_type
:
4046 return "DW_TAG_string_type";
4047 case DW_TAG_structure_type
:
4048 return "DW_TAG_structure_type";
4049 case DW_TAG_subroutine_type
:
4050 return "DW_TAG_subroutine_type";
4051 case DW_TAG_typedef
:
4052 return "DW_TAG_typedef";
4053 case DW_TAG_union_type
:
4054 return "DW_TAG_union_type";
4055 case DW_TAG_unspecified_parameters
:
4056 return "DW_TAG_unspecified_parameters";
4057 case DW_TAG_variant
:
4058 return "DW_TAG_variant";
4059 case DW_TAG_common_block
:
4060 return "DW_TAG_common_block";
4061 case DW_TAG_common_inclusion
:
4062 return "DW_TAG_common_inclusion";
4063 case DW_TAG_inheritance
:
4064 return "DW_TAG_inheritance";
4065 case DW_TAG_inlined_subroutine
:
4066 return "DW_TAG_inlined_subroutine";
4068 return "DW_TAG_module";
4069 case DW_TAG_ptr_to_member_type
:
4070 return "DW_TAG_ptr_to_member_type";
4071 case DW_TAG_set_type
:
4072 return "DW_TAG_set_type";
4073 case DW_TAG_subrange_type
:
4074 return "DW_TAG_subrange_type";
4075 case DW_TAG_with_stmt
:
4076 return "DW_TAG_with_stmt";
4077 case DW_TAG_access_declaration
:
4078 return "DW_TAG_access_declaration";
4079 case DW_TAG_base_type
:
4080 return "DW_TAG_base_type";
4081 case DW_TAG_catch_block
:
4082 return "DW_TAG_catch_block";
4083 case DW_TAG_const_type
:
4084 return "DW_TAG_const_type";
4085 case DW_TAG_constant
:
4086 return "DW_TAG_constant";
4087 case DW_TAG_enumerator
:
4088 return "DW_TAG_enumerator";
4089 case DW_TAG_file_type
:
4090 return "DW_TAG_file_type";
4092 return "DW_TAG_friend";
4093 case DW_TAG_namelist
:
4094 return "DW_TAG_namelist";
4095 case DW_TAG_namelist_item
:
4096 return "DW_TAG_namelist_item";
4097 case DW_TAG_namespace
:
4098 return "DW_TAG_namespace";
4099 case DW_TAG_packed_type
:
4100 return "DW_TAG_packed_type";
4101 case DW_TAG_subprogram
:
4102 return "DW_TAG_subprogram";
4103 case DW_TAG_template_type_param
:
4104 return "DW_TAG_template_type_param";
4105 case DW_TAG_template_value_param
:
4106 return "DW_TAG_template_value_param";
4107 case DW_TAG_thrown_type
:
4108 return "DW_TAG_thrown_type";
4109 case DW_TAG_try_block
:
4110 return "DW_TAG_try_block";
4111 case DW_TAG_variant_part
:
4112 return "DW_TAG_variant_part";
4113 case DW_TAG_variable
:
4114 return "DW_TAG_variable";
4115 case DW_TAG_volatile_type
:
4116 return "DW_TAG_volatile_type";
4117 case DW_TAG_imported_module
:
4118 return "DW_TAG_imported_module";
4119 case DW_TAG_MIPS_loop
:
4120 return "DW_TAG_MIPS_loop";
4121 case DW_TAG_format_label
:
4122 return "DW_TAG_format_label";
4123 case DW_TAG_function_template
:
4124 return "DW_TAG_function_template";
4125 case DW_TAG_class_template
:
4126 return "DW_TAG_class_template";
4127 case DW_TAG_GNU_BINCL
:
4128 return "DW_TAG_GNU_BINCL";
4129 case DW_TAG_GNU_EINCL
:
4130 return "DW_TAG_GNU_EINCL";
4132 return "DW_TAG_<unknown>";
4136 /* Convert a DWARF attribute code into its string name. */
4139 dwarf_attr_name (unsigned int attr
)
4144 return "DW_AT_sibling";
4145 case DW_AT_location
:
4146 return "DW_AT_location";
4148 return "DW_AT_name";
4149 case DW_AT_ordering
:
4150 return "DW_AT_ordering";
4151 case DW_AT_subscr_data
:
4152 return "DW_AT_subscr_data";
4153 case DW_AT_byte_size
:
4154 return "DW_AT_byte_size";
4155 case DW_AT_bit_offset
:
4156 return "DW_AT_bit_offset";
4157 case DW_AT_bit_size
:
4158 return "DW_AT_bit_size";
4159 case DW_AT_element_list
:
4160 return "DW_AT_element_list";
4161 case DW_AT_stmt_list
:
4162 return "DW_AT_stmt_list";
4164 return "DW_AT_low_pc";
4166 return "DW_AT_high_pc";
4167 case DW_AT_language
:
4168 return "DW_AT_language";
4170 return "DW_AT_member";
4172 return "DW_AT_discr";
4173 case DW_AT_discr_value
:
4174 return "DW_AT_discr_value";
4175 case DW_AT_visibility
:
4176 return "DW_AT_visibility";
4178 return "DW_AT_import";
4179 case DW_AT_string_length
:
4180 return "DW_AT_string_length";
4181 case DW_AT_common_reference
:
4182 return "DW_AT_common_reference";
4183 case DW_AT_comp_dir
:
4184 return "DW_AT_comp_dir";
4185 case DW_AT_const_value
:
4186 return "DW_AT_const_value";
4187 case DW_AT_containing_type
:
4188 return "DW_AT_containing_type";
4189 case DW_AT_default_value
:
4190 return "DW_AT_default_value";
4192 return "DW_AT_inline";
4193 case DW_AT_is_optional
:
4194 return "DW_AT_is_optional";
4195 case DW_AT_lower_bound
:
4196 return "DW_AT_lower_bound";
4197 case DW_AT_producer
:
4198 return "DW_AT_producer";
4199 case DW_AT_prototyped
:
4200 return "DW_AT_prototyped";
4201 case DW_AT_return_addr
:
4202 return "DW_AT_return_addr";
4203 case DW_AT_start_scope
:
4204 return "DW_AT_start_scope";
4205 case DW_AT_stride_size
:
4206 return "DW_AT_stride_size";
4207 case DW_AT_upper_bound
:
4208 return "DW_AT_upper_bound";
4209 case DW_AT_abstract_origin
:
4210 return "DW_AT_abstract_origin";
4211 case DW_AT_accessibility
:
4212 return "DW_AT_accessibility";
4213 case DW_AT_address_class
:
4214 return "DW_AT_address_class";
4215 case DW_AT_artificial
:
4216 return "DW_AT_artificial";
4217 case DW_AT_base_types
:
4218 return "DW_AT_base_types";
4219 case DW_AT_calling_convention
:
4220 return "DW_AT_calling_convention";
4222 return "DW_AT_count";
4223 case DW_AT_data_member_location
:
4224 return "DW_AT_data_member_location";
4225 case DW_AT_decl_column
:
4226 return "DW_AT_decl_column";
4227 case DW_AT_decl_file
:
4228 return "DW_AT_decl_file";
4229 case DW_AT_decl_line
:
4230 return "DW_AT_decl_line";
4231 case DW_AT_declaration
:
4232 return "DW_AT_declaration";
4233 case DW_AT_discr_list
:
4234 return "DW_AT_discr_list";
4235 case DW_AT_encoding
:
4236 return "DW_AT_encoding";
4237 case DW_AT_external
:
4238 return "DW_AT_external";
4239 case DW_AT_frame_base
:
4240 return "DW_AT_frame_base";
4242 return "DW_AT_friend";
4243 case DW_AT_identifier_case
:
4244 return "DW_AT_identifier_case";
4245 case DW_AT_macro_info
:
4246 return "DW_AT_macro_info";
4247 case DW_AT_namelist_items
:
4248 return "DW_AT_namelist_items";
4249 case DW_AT_priority
:
4250 return "DW_AT_priority";
4252 return "DW_AT_segment";
4253 case DW_AT_specification
:
4254 return "DW_AT_specification";
4255 case DW_AT_static_link
:
4256 return "DW_AT_static_link";
4258 return "DW_AT_type";
4259 case DW_AT_use_location
:
4260 return "DW_AT_use_location";
4261 case DW_AT_variable_parameter
:
4262 return "DW_AT_variable_parameter";
4263 case DW_AT_virtuality
:
4264 return "DW_AT_virtuality";
4265 case DW_AT_vtable_elem_location
:
4266 return "DW_AT_vtable_elem_location";
4268 case DW_AT_allocated
:
4269 return "DW_AT_allocated";
4270 case DW_AT_associated
:
4271 return "DW_AT_associated";
4272 case DW_AT_data_location
:
4273 return "DW_AT_data_location";
4275 return "DW_AT_stride";
4276 case DW_AT_entry_pc
:
4277 return "DW_AT_entry_pc";
4278 case DW_AT_use_UTF8
:
4279 return "DW_AT_use_UTF8";
4280 case DW_AT_extension
:
4281 return "DW_AT_extension";
4283 return "DW_AT_ranges";
4284 case DW_AT_trampoline
:
4285 return "DW_AT_trampoline";
4286 case DW_AT_call_column
:
4287 return "DW_AT_call_column";
4288 case DW_AT_call_file
:
4289 return "DW_AT_call_file";
4290 case DW_AT_call_line
:
4291 return "DW_AT_call_line";
4293 case DW_AT_MIPS_fde
:
4294 return "DW_AT_MIPS_fde";
4295 case DW_AT_MIPS_loop_begin
:
4296 return "DW_AT_MIPS_loop_begin";
4297 case DW_AT_MIPS_tail_loop_begin
:
4298 return "DW_AT_MIPS_tail_loop_begin";
4299 case DW_AT_MIPS_epilog_begin
:
4300 return "DW_AT_MIPS_epilog_begin";
4301 case DW_AT_MIPS_loop_unroll_factor
:
4302 return "DW_AT_MIPS_loop_unroll_factor";
4303 case DW_AT_MIPS_software_pipeline_depth
:
4304 return "DW_AT_MIPS_software_pipeline_depth";
4305 case DW_AT_MIPS_linkage_name
:
4306 return "DW_AT_MIPS_linkage_name";
4307 case DW_AT_MIPS_stride
:
4308 return "DW_AT_MIPS_stride";
4309 case DW_AT_MIPS_abstract_name
:
4310 return "DW_AT_MIPS_abstract_name";
4311 case DW_AT_MIPS_clone_origin
:
4312 return "DW_AT_MIPS_clone_origin";
4313 case DW_AT_MIPS_has_inlines
:
4314 return "DW_AT_MIPS_has_inlines";
4316 case DW_AT_sf_names
:
4317 return "DW_AT_sf_names";
4318 case DW_AT_src_info
:
4319 return "DW_AT_src_info";
4320 case DW_AT_mac_info
:
4321 return "DW_AT_mac_info";
4322 case DW_AT_src_coords
:
4323 return "DW_AT_src_coords";
4324 case DW_AT_body_begin
:
4325 return "DW_AT_body_begin";
4326 case DW_AT_body_end
:
4327 return "DW_AT_body_end";
4328 case DW_AT_GNU_vector
:
4329 return "DW_AT_GNU_vector";
4331 case DW_AT_VMS_rtnbeg_pd_address
:
4332 return "DW_AT_VMS_rtnbeg_pd_address";
4335 return "DW_AT_<unknown>";
4339 /* Convert a DWARF value form code into its string name. */
4342 dwarf_form_name (unsigned int form
)
4347 return "DW_FORM_addr";
4348 case DW_FORM_block2
:
4349 return "DW_FORM_block2";
4350 case DW_FORM_block4
:
4351 return "DW_FORM_block4";
4353 return "DW_FORM_data2";
4355 return "DW_FORM_data4";
4357 return "DW_FORM_data8";
4358 case DW_FORM_string
:
4359 return "DW_FORM_string";
4361 return "DW_FORM_block";
4362 case DW_FORM_block1
:
4363 return "DW_FORM_block1";
4365 return "DW_FORM_data1";
4367 return "DW_FORM_flag";
4369 return "DW_FORM_sdata";
4371 return "DW_FORM_strp";
4373 return "DW_FORM_udata";
4374 case DW_FORM_ref_addr
:
4375 return "DW_FORM_ref_addr";
4377 return "DW_FORM_ref1";
4379 return "DW_FORM_ref2";
4381 return "DW_FORM_ref4";
4383 return "DW_FORM_ref8";
4384 case DW_FORM_ref_udata
:
4385 return "DW_FORM_ref_udata";
4386 case DW_FORM_indirect
:
4387 return "DW_FORM_indirect";
4389 return "DW_FORM_<unknown>";
4393 /* Convert a DWARF type code into its string name. */
4397 dwarf_type_encoding_name (unsigned enc
)
4401 case DW_ATE_address
:
4402 return "DW_ATE_address";
4403 case DW_ATE_boolean
:
4404 return "DW_ATE_boolean";
4405 case DW_ATE_complex_float
:
4406 return "DW_ATE_complex_float";
4408 return "DW_ATE_float";
4410 return "DW_ATE_signed";
4411 case DW_ATE_signed_char
:
4412 return "DW_ATE_signed_char";
4413 case DW_ATE_unsigned
:
4414 return "DW_ATE_unsigned";
4415 case DW_ATE_unsigned_char
:
4416 return "DW_ATE_unsigned_char";
4418 return "DW_ATE_<unknown>";
4423 /* Determine the "ultimate origin" of a decl. The decl may be an inlined
4424 instance of an inlined instance of a decl which is local to an inline
4425 function, so we have to trace all of the way back through the origin chain
4426 to find out what sort of node actually served as the original seed for the
4430 decl_ultimate_origin (tree decl
)
4432 /* output_inline_function sets DECL_ABSTRACT_ORIGIN for all the
4433 nodes in the function to point to themselves; ignore that if
4434 we're trying to output the abstract instance of this function. */
4435 if (DECL_ABSTRACT (decl
) && DECL_ABSTRACT_ORIGIN (decl
) == decl
)
4438 #ifdef ENABLE_CHECKING
4439 if (DECL_FROM_INLINE (DECL_ORIGIN (decl
)))
4440 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
4441 most distant ancestor, this should never happen. */
4445 return DECL_ABSTRACT_ORIGIN (decl
);
4448 /* Determine the "ultimate origin" of a block. The block may be an inlined
4449 instance of an inlined instance of a block which is local to an inline
4450 function, so we have to trace all of the way back through the origin chain
4451 to find out what sort of node actually served as the original seed for the
4455 block_ultimate_origin (tree block
)
4457 tree immediate_origin
= BLOCK_ABSTRACT_ORIGIN (block
);
4459 /* output_inline_function sets BLOCK_ABSTRACT_ORIGIN for all the
4460 nodes in the function to point to themselves; ignore that if
4461 we're trying to output the abstract instance of this function. */
4462 if (BLOCK_ABSTRACT (block
) && immediate_origin
== block
)
4465 if (immediate_origin
== NULL_TREE
)
4470 tree lookahead
= immediate_origin
;
4474 ret_val
= lookahead
;
4475 lookahead
= (TREE_CODE (ret_val
) == BLOCK
4476 ? BLOCK_ABSTRACT_ORIGIN (ret_val
) : NULL
);
4478 while (lookahead
!= NULL
&& lookahead
!= ret_val
);
4484 /* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT
4485 of a virtual function may refer to a base class, so we check the 'this'
4489 decl_class_context (tree decl
)
4491 tree context
= NULL_TREE
;
4493 if (TREE_CODE (decl
) != FUNCTION_DECL
|| ! DECL_VINDEX (decl
))
4494 context
= DECL_CONTEXT (decl
);
4496 context
= TYPE_MAIN_VARIANT
4497 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)))));
4499 if (context
&& !TYPE_P (context
))
4500 context
= NULL_TREE
;
4505 /* Add an attribute/value pair to a DIE. We build the lists up in reverse
4506 addition order, and correct that in reverse_all_dies. */
4509 add_dwarf_attr (dw_die_ref die
, dw_attr_ref attr
)
4511 if (die
!= NULL
&& attr
!= NULL
)
4513 attr
->dw_attr_next
= die
->die_attr
;
4514 die
->die_attr
= attr
;
4518 static inline enum dw_val_class
4519 AT_class (dw_attr_ref a
)
4521 return a
->dw_attr_val
.val_class
;
4524 /* Add a flag value attribute to a DIE. */
4527 add_AT_flag (dw_die_ref die
, enum dwarf_attribute attr_kind
, unsigned int flag
)
4529 dw_attr_ref attr
= ggc_alloc (sizeof (dw_attr_node
));
4531 attr
->dw_attr_next
= NULL
;
4532 attr
->dw_attr
= attr_kind
;
4533 attr
->dw_attr_val
.val_class
= dw_val_class_flag
;
4534 attr
->dw_attr_val
.v
.val_flag
= flag
;
4535 add_dwarf_attr (die
, attr
);
4538 static inline unsigned
4539 AT_flag (dw_attr_ref a
)
4541 if (a
&& AT_class (a
) == dw_val_class_flag
)
4542 return a
->dw_attr_val
.v
.val_flag
;
4547 /* Add a signed integer attribute value to a DIE. */
4550 add_AT_int (dw_die_ref die
, enum dwarf_attribute attr_kind
, HOST_WIDE_INT int_val
)
4552 dw_attr_ref attr
= ggc_alloc (sizeof (dw_attr_node
));
4554 attr
->dw_attr_next
= NULL
;
4555 attr
->dw_attr
= attr_kind
;
4556 attr
->dw_attr_val
.val_class
= dw_val_class_const
;
4557 attr
->dw_attr_val
.v
.val_int
= int_val
;
4558 add_dwarf_attr (die
, attr
);
4561 static inline HOST_WIDE_INT
4562 AT_int (dw_attr_ref a
)
4564 if (a
&& AT_class (a
) == dw_val_class_const
)
4565 return a
->dw_attr_val
.v
.val_int
;
4570 /* Add an unsigned integer attribute value to a DIE. */
4573 add_AT_unsigned (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4574 unsigned HOST_WIDE_INT unsigned_val
)
4576 dw_attr_ref attr
= ggc_alloc (sizeof (dw_attr_node
));
4578 attr
->dw_attr_next
= NULL
;
4579 attr
->dw_attr
= attr_kind
;
4580 attr
->dw_attr_val
.val_class
= dw_val_class_unsigned_const
;
4581 attr
->dw_attr_val
.v
.val_unsigned
= unsigned_val
;
4582 add_dwarf_attr (die
, attr
);
4585 static inline unsigned HOST_WIDE_INT
4586 AT_unsigned (dw_attr_ref a
)
4588 if (a
&& AT_class (a
) == dw_val_class_unsigned_const
)
4589 return a
->dw_attr_val
.v
.val_unsigned
;
4594 /* Add an unsigned double integer attribute value to a DIE. */
4597 add_AT_long_long (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4598 long unsigned int val_hi
, long unsigned int val_low
)
4600 dw_attr_ref attr
= ggc_alloc (sizeof (dw_attr_node
));
4602 attr
->dw_attr_next
= NULL
;
4603 attr
->dw_attr
= attr_kind
;
4604 attr
->dw_attr_val
.val_class
= dw_val_class_long_long
;
4605 attr
->dw_attr_val
.v
.val_long_long
.hi
= val_hi
;
4606 attr
->dw_attr_val
.v
.val_long_long
.low
= val_low
;
4607 add_dwarf_attr (die
, attr
);
4610 /* Add a floating point attribute value to a DIE and return it. */
4613 add_AT_vec (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4614 unsigned int length
, unsigned int elt_size
, unsigned char *array
)
4616 dw_attr_ref attr
= ggc_alloc (sizeof (dw_attr_node
));
4618 attr
->dw_attr_next
= NULL
;
4619 attr
->dw_attr
= attr_kind
;
4620 attr
->dw_attr_val
.val_class
= dw_val_class_vec
;
4621 attr
->dw_attr_val
.v
.val_vec
.length
= length
;
4622 attr
->dw_attr_val
.v
.val_vec
.elt_size
= elt_size
;
4623 attr
->dw_attr_val
.v
.val_vec
.array
= array
;
4624 add_dwarf_attr (die
, attr
);
4627 /* Hash and equality functions for debug_str_hash. */
4630 debug_str_do_hash (const void *x
)
4632 return htab_hash_string (((const struct indirect_string_node
*)x
)->str
);
4636 debug_str_eq (const void *x1
, const void *x2
)
4638 return strcmp ((((const struct indirect_string_node
*)x1
)->str
),
4639 (const char *)x2
) == 0;
4642 /* Add a string attribute value to a DIE. */
4645 add_AT_string (dw_die_ref die
, enum dwarf_attribute attr_kind
, const char *str
)
4647 dw_attr_ref attr
= ggc_alloc (sizeof (dw_attr_node
));
4648 struct indirect_string_node
*node
;
4651 if (! debug_str_hash
)
4652 debug_str_hash
= htab_create_ggc (10, debug_str_do_hash
,
4653 debug_str_eq
, NULL
);
4655 slot
= htab_find_slot_with_hash (debug_str_hash
, str
,
4656 htab_hash_string (str
), INSERT
);
4658 *slot
= ggc_alloc_cleared (sizeof (struct indirect_string_node
));
4659 node
= (struct indirect_string_node
*) *slot
;
4660 node
->str
= ggc_strdup (str
);
4663 attr
->dw_attr_next
= NULL
;
4664 attr
->dw_attr
= attr_kind
;
4665 attr
->dw_attr_val
.val_class
= dw_val_class_str
;
4666 attr
->dw_attr_val
.v
.val_str
= node
;
4667 add_dwarf_attr (die
, attr
);
4670 static inline const char *
4671 AT_string (dw_attr_ref a
)
4673 if (a
&& AT_class (a
) == dw_val_class_str
)
4674 return a
->dw_attr_val
.v
.val_str
->str
;
4679 /* Find out whether a string should be output inline in DIE
4680 or out-of-line in .debug_str section. */
4683 AT_string_form (dw_attr_ref a
)
4685 if (a
&& AT_class (a
) == dw_val_class_str
)
4687 struct indirect_string_node
*node
;
4691 node
= a
->dw_attr_val
.v
.val_str
;
4695 len
= strlen (node
->str
) + 1;
4697 /* If the string is shorter or equal to the size of the reference, it is
4698 always better to put it inline. */
4699 if (len
<= DWARF_OFFSET_SIZE
|| node
->refcount
== 0)
4700 return node
->form
= DW_FORM_string
;
4702 /* If we cannot expect the linker to merge strings in .debug_str
4703 section, only put it into .debug_str if it is worth even in this
4705 if ((DEBUG_STR_SECTION_FLAGS
& SECTION_MERGE
) == 0
4706 && (len
- DWARF_OFFSET_SIZE
) * node
->refcount
<= len
)
4707 return node
->form
= DW_FORM_string
;
4709 ASM_GENERATE_INTERNAL_LABEL (label
, "LASF", dw2_string_counter
);
4710 ++dw2_string_counter
;
4711 node
->label
= xstrdup (label
);
4713 return node
->form
= DW_FORM_strp
;
4719 /* Add a DIE reference attribute value to a DIE. */
4722 add_AT_die_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
, dw_die_ref targ_die
)
4724 dw_attr_ref attr
= ggc_alloc (sizeof (dw_attr_node
));
4726 attr
->dw_attr_next
= NULL
;
4727 attr
->dw_attr
= attr_kind
;
4728 attr
->dw_attr_val
.val_class
= dw_val_class_die_ref
;
4729 attr
->dw_attr_val
.v
.val_die_ref
.die
= targ_die
;
4730 attr
->dw_attr_val
.v
.val_die_ref
.external
= 0;
4731 add_dwarf_attr (die
, attr
);
4734 /* Add an AT_specification attribute to a DIE, and also make the back
4735 pointer from the specification to the definition. */
4738 add_AT_specification (dw_die_ref die
, dw_die_ref targ_die
)
4740 add_AT_die_ref (die
, DW_AT_specification
, targ_die
);
4741 if (targ_die
->die_definition
)
4743 targ_die
->die_definition
= die
;
4746 static inline dw_die_ref
4747 AT_ref (dw_attr_ref a
)
4749 if (a
&& AT_class (a
) == dw_val_class_die_ref
)
4750 return a
->dw_attr_val
.v
.val_die_ref
.die
;
4756 AT_ref_external (dw_attr_ref a
)
4758 if (a
&& AT_class (a
) == dw_val_class_die_ref
)
4759 return a
->dw_attr_val
.v
.val_die_ref
.external
;
4765 set_AT_ref_external (dw_attr_ref a
, int i
)
4767 if (a
&& AT_class (a
) == dw_val_class_die_ref
)
4768 a
->dw_attr_val
.v
.val_die_ref
.external
= i
;
4773 /* Add an FDE reference attribute value to a DIE. */
4776 add_AT_fde_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
, unsigned int targ_fde
)
4778 dw_attr_ref attr
= ggc_alloc (sizeof (dw_attr_node
));
4780 attr
->dw_attr_next
= NULL
;
4781 attr
->dw_attr
= attr_kind
;
4782 attr
->dw_attr_val
.val_class
= dw_val_class_fde_ref
;
4783 attr
->dw_attr_val
.v
.val_fde_index
= targ_fde
;
4784 add_dwarf_attr (die
, attr
);
4787 /* Add a location description attribute value to a DIE. */
4790 add_AT_loc (dw_die_ref die
, enum dwarf_attribute attr_kind
, dw_loc_descr_ref loc
)
4792 dw_attr_ref attr
= ggc_alloc (sizeof (dw_attr_node
));
4794 attr
->dw_attr_next
= NULL
;
4795 attr
->dw_attr
= attr_kind
;
4796 attr
->dw_attr_val
.val_class
= dw_val_class_loc
;
4797 attr
->dw_attr_val
.v
.val_loc
= loc
;
4798 add_dwarf_attr (die
, attr
);
4801 static inline dw_loc_descr_ref
4802 AT_loc (dw_attr_ref a
)
4804 if (a
&& AT_class (a
) == dw_val_class_loc
)
4805 return a
->dw_attr_val
.v
.val_loc
;
4811 add_AT_loc_list (dw_die_ref die
, enum dwarf_attribute attr_kind
, dw_loc_list_ref loc_list
)
4813 dw_attr_ref attr
= ggc_alloc (sizeof (dw_attr_node
));
4815 attr
->dw_attr_next
= NULL
;
4816 attr
->dw_attr
= attr_kind
;
4817 attr
->dw_attr_val
.val_class
= dw_val_class_loc_list
;
4818 attr
->dw_attr_val
.v
.val_loc_list
= loc_list
;
4819 add_dwarf_attr (die
, attr
);
4820 have_location_lists
= 1;
4823 static inline dw_loc_list_ref
4824 AT_loc_list (dw_attr_ref a
)
4826 if (a
&& AT_class (a
) == dw_val_class_loc_list
)
4827 return a
->dw_attr_val
.v
.val_loc_list
;
4832 /* Add an address constant attribute value to a DIE. */
4835 add_AT_addr (dw_die_ref die
, enum dwarf_attribute attr_kind
, rtx addr
)
4837 dw_attr_ref attr
= ggc_alloc (sizeof (dw_attr_node
));
4839 attr
->dw_attr_next
= NULL
;
4840 attr
->dw_attr
= attr_kind
;
4841 attr
->dw_attr_val
.val_class
= dw_val_class_addr
;
4842 attr
->dw_attr_val
.v
.val_addr
= addr
;
4843 add_dwarf_attr (die
, attr
);
4847 AT_addr (dw_attr_ref a
)
4849 if (a
&& AT_class (a
) == dw_val_class_addr
)
4850 return a
->dw_attr_val
.v
.val_addr
;
4855 /* Add a label identifier attribute value to a DIE. */
4858 add_AT_lbl_id (dw_die_ref die
, enum dwarf_attribute attr_kind
, const char *lbl_id
)
4860 dw_attr_ref attr
= ggc_alloc (sizeof (dw_attr_node
));
4862 attr
->dw_attr_next
= NULL
;
4863 attr
->dw_attr
= attr_kind
;
4864 attr
->dw_attr_val
.val_class
= dw_val_class_lbl_id
;
4865 attr
->dw_attr_val
.v
.val_lbl_id
= xstrdup (lbl_id
);
4866 add_dwarf_attr (die
, attr
);
4869 /* Add a section offset attribute value to a DIE. */
4872 add_AT_lbl_offset (dw_die_ref die
, enum dwarf_attribute attr_kind
, const char *label
)
4874 dw_attr_ref attr
= ggc_alloc (sizeof (dw_attr_node
));
4876 attr
->dw_attr_next
= NULL
;
4877 attr
->dw_attr
= attr_kind
;
4878 attr
->dw_attr_val
.val_class
= dw_val_class_lbl_offset
;
4879 attr
->dw_attr_val
.v
.val_lbl_id
= xstrdup (label
);
4880 add_dwarf_attr (die
, attr
);
4883 /* Add an offset attribute value to a DIE. */
4886 add_AT_offset (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4887 unsigned HOST_WIDE_INT offset
)
4889 dw_attr_ref attr
= ggc_alloc (sizeof (dw_attr_node
));
4891 attr
->dw_attr_next
= NULL
;
4892 attr
->dw_attr
= attr_kind
;
4893 attr
->dw_attr_val
.val_class
= dw_val_class_offset
;
4894 attr
->dw_attr_val
.v
.val_offset
= offset
;
4895 add_dwarf_attr (die
, attr
);
4898 /* Add an range_list attribute value to a DIE. */
4901 add_AT_range_list (dw_die_ref die
, enum dwarf_attribute attr_kind
,
4902 long unsigned int offset
)
4904 dw_attr_ref attr
= ggc_alloc (sizeof (dw_attr_node
));
4906 attr
->dw_attr_next
= NULL
;
4907 attr
->dw_attr
= attr_kind
;
4908 attr
->dw_attr_val
.val_class
= dw_val_class_range_list
;
4909 attr
->dw_attr_val
.v
.val_offset
= offset
;
4910 add_dwarf_attr (die
, attr
);
4913 static inline const char *
4914 AT_lbl (dw_attr_ref a
)
4916 if (a
&& (AT_class (a
) == dw_val_class_lbl_id
4917 || AT_class (a
) == dw_val_class_lbl_offset
))
4918 return a
->dw_attr_val
.v
.val_lbl_id
;
4923 /* Get the attribute of type attr_kind. */
4926 get_AT (dw_die_ref die
, enum dwarf_attribute attr_kind
)
4929 dw_die_ref spec
= NULL
;
4933 for (a
= die
->die_attr
; a
!= NULL
; a
= a
->dw_attr_next
)
4934 if (a
->dw_attr
== attr_kind
)
4936 else if (a
->dw_attr
== DW_AT_specification
4937 || a
->dw_attr
== DW_AT_abstract_origin
)
4941 return get_AT (spec
, attr_kind
);
4947 /* Return the "low pc" attribute value, typically associated with a subprogram
4948 DIE. Return null if the "low pc" attribute is either not present, or if it
4949 cannot be represented as an assembler label identifier. */
4951 static inline const char *
4952 get_AT_low_pc (dw_die_ref die
)
4954 dw_attr_ref a
= get_AT (die
, DW_AT_low_pc
);
4956 return a
? AT_lbl (a
) : NULL
;
4959 /* Return the "high pc" attribute value, typically associated with a subprogram
4960 DIE. Return null if the "high pc" attribute is either not present, or if it
4961 cannot be represented as an assembler label identifier. */
4963 static inline const char *
4964 get_AT_hi_pc (dw_die_ref die
)
4966 dw_attr_ref a
= get_AT (die
, DW_AT_high_pc
);
4968 return a
? AT_lbl (a
) : NULL
;
4971 /* Return the value of the string attribute designated by ATTR_KIND, or
4972 NULL if it is not present. */
4974 static inline const char *
4975 get_AT_string (dw_die_ref die
, enum dwarf_attribute attr_kind
)
4977 dw_attr_ref a
= get_AT (die
, attr_kind
);
4979 return a
? AT_string (a
) : NULL
;
4982 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
4983 if it is not present. */
4986 get_AT_flag (dw_die_ref die
, enum dwarf_attribute attr_kind
)
4988 dw_attr_ref a
= get_AT (die
, attr_kind
);
4990 return a
? AT_flag (a
) : 0;
4993 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
4994 if it is not present. */
4996 static inline unsigned
4997 get_AT_unsigned (dw_die_ref die
, enum dwarf_attribute attr_kind
)
4999 dw_attr_ref a
= get_AT (die
, attr_kind
);
5001 return a
? AT_unsigned (a
) : 0;
5004 static inline dw_die_ref
5005 get_AT_ref (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5007 dw_attr_ref a
= get_AT (die
, attr_kind
);
5009 return a
? AT_ref (a
) : NULL
;
5012 /* Return TRUE if the language is C or C++. */
5017 unsigned int lang
= get_AT_unsigned (comp_unit_die
, DW_AT_language
);
5019 return (lang
== DW_LANG_C
|| lang
== DW_LANG_C89
5020 || lang
== DW_LANG_C_plus_plus
);
5023 /* Return TRUE if the language is C++. */
5028 return (get_AT_unsigned (comp_unit_die
, DW_AT_language
)
5029 == DW_LANG_C_plus_plus
);
5032 /* Return TRUE if the language is Fortran. */
5037 unsigned int lang
= get_AT_unsigned (comp_unit_die
, DW_AT_language
);
5039 return lang
== DW_LANG_Fortran77
|| lang
== DW_LANG_Fortran90
;
5042 /* Return TRUE if the language is Java. */
5047 unsigned int lang
= get_AT_unsigned (comp_unit_die
, DW_AT_language
);
5049 return lang
== DW_LANG_Java
;
5052 /* Return TRUE if the language is Ada. */
5057 unsigned int lang
= get_AT_unsigned (comp_unit_die
, DW_AT_language
);
5059 return lang
== DW_LANG_Ada95
|| lang
== DW_LANG_Ada83
;
5062 /* Free up the memory used by A. */
5064 static inline void free_AT (dw_attr_ref
);
5066 free_AT (dw_attr_ref a
)
5068 if (AT_class (a
) == dw_val_class_str
)
5069 if (a
->dw_attr_val
.v
.val_str
->refcount
)
5070 a
->dw_attr_val
.v
.val_str
->refcount
--;
5073 /* Remove the specified attribute if present. */
5076 remove_AT (dw_die_ref die
, enum dwarf_attribute attr_kind
)
5079 dw_attr_ref removed
= NULL
;
5083 for (p
= &(die
->die_attr
); *p
; p
= &((*p
)->dw_attr_next
))
5084 if ((*p
)->dw_attr
== attr_kind
)
5087 *p
= (*p
)->dw_attr_next
;
5096 /* Remove child die whose die_tag is specified tag. */
5099 remove_child_TAG (dw_die_ref die
, enum dwarf_tag tag
)
5101 dw_die_ref current
, prev
, next
;
5102 current
= die
->die_child
;
5104 while (current
!= NULL
)
5106 if (current
->die_tag
== tag
)
5108 next
= current
->die_sib
;
5110 die
->die_child
= next
;
5112 prev
->die_sib
= next
;
5119 current
= current
->die_sib
;
5124 /* Free up the memory used by DIE. */
5127 free_die (dw_die_ref die
)
5129 remove_children (die
);
5132 /* Discard the children of this DIE. */
5135 remove_children (dw_die_ref die
)
5137 dw_die_ref child_die
= die
->die_child
;
5139 die
->die_child
= NULL
;
5141 while (child_die
!= NULL
)
5143 dw_die_ref tmp_die
= child_die
;
5146 child_die
= child_die
->die_sib
;
5148 for (a
= tmp_die
->die_attr
; a
!= NULL
;)
5150 dw_attr_ref tmp_a
= a
;
5152 a
= a
->dw_attr_next
;
5160 /* Add a child DIE below its parent. We build the lists up in reverse
5161 addition order, and correct that in reverse_all_dies. */
5164 add_child_die (dw_die_ref die
, dw_die_ref child_die
)
5166 if (die
!= NULL
&& child_die
!= NULL
)
5168 if (die
== child_die
)
5171 child_die
->die_parent
= die
;
5172 child_die
->die_sib
= die
->die_child
;
5173 die
->die_child
= child_die
;
5177 /* Move CHILD, which must be a child of PARENT or the DIE for which PARENT
5178 is the specification, to the front of PARENT's list of children. */
5181 splice_child_die (dw_die_ref parent
, dw_die_ref child
)
5185 /* We want the declaration DIE from inside the class, not the
5186 specification DIE at toplevel. */
5187 if (child
->die_parent
!= parent
)
5189 dw_die_ref tmp
= get_AT_ref (child
, DW_AT_specification
);
5195 if (child
->die_parent
!= parent
5196 && child
->die_parent
!= get_AT_ref (parent
, DW_AT_specification
))
5199 for (p
= &(child
->die_parent
->die_child
); *p
; p
= &((*p
)->die_sib
))
5202 *p
= child
->die_sib
;
5206 child
->die_parent
= parent
;
5207 child
->die_sib
= parent
->die_child
;
5208 parent
->die_child
= child
;
5211 /* Return a pointer to a newly created DIE node. */
5213 static inline dw_die_ref
5214 new_die (enum dwarf_tag tag_value
, dw_die_ref parent_die
, tree t
)
5216 dw_die_ref die
= ggc_alloc_cleared (sizeof (die_node
));
5218 die
->die_tag
= tag_value
;
5220 if (parent_die
!= NULL
)
5221 add_child_die (parent_die
, die
);
5224 limbo_die_node
*limbo_node
;
5226 limbo_node
= ggc_alloc_cleared (sizeof (limbo_die_node
));
5227 limbo_node
->die
= die
;
5228 limbo_node
->created_for
= t
;
5229 limbo_node
->next
= limbo_die_list
;
5230 limbo_die_list
= limbo_node
;
5236 /* Return the DIE associated with the given type specifier. */
5238 static inline dw_die_ref
5239 lookup_type_die (tree type
)
5241 return TYPE_SYMTAB_DIE (type
);
5244 /* Equate a DIE to a given type specifier. */
5247 equate_type_number_to_die (tree type
, dw_die_ref type_die
)
5249 TYPE_SYMTAB_DIE (type
) = type_die
;
5252 /* Returns a hash value for X (which really is a die_struct). */
5255 decl_die_table_hash (const void *x
)
5257 return (hashval_t
) ((const dw_die_ref
) x
)->decl_id
;
5260 /* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y. */
5263 decl_die_table_eq (const void *x
, const void *y
)
5265 return (((const dw_die_ref
) x
)->decl_id
== DECL_UID ((const tree
) y
));
5268 /* Return the DIE associated with a given declaration. */
5270 static inline dw_die_ref
5271 lookup_decl_die (tree decl
)
5273 return htab_find_with_hash (decl_die_table
, decl
, DECL_UID (decl
));
5276 /* Returns a hash value for X (which really is a var_loc_list). */
5279 decl_loc_table_hash (const void *x
)
5281 return (hashval_t
) ((const var_loc_list
*) x
)->decl_id
;
5284 /* Return nonzero if decl_id of var_loc_list X is the same as
5288 decl_loc_table_eq (const void *x
, const void *y
)
5290 return (((const var_loc_list
*) x
)->decl_id
== DECL_UID ((const tree
) y
));
5293 /* Return the var_loc list associated with a given declaration. */
5295 static inline var_loc_list
*
5296 lookup_decl_loc (tree decl
)
5298 return htab_find_with_hash (decl_loc_table
, decl
, DECL_UID (decl
));
5301 /* Equate a DIE to a particular declaration. */
5304 equate_decl_number_to_die (tree decl
, dw_die_ref decl_die
)
5306 unsigned int decl_id
= DECL_UID (decl
);
5309 slot
= htab_find_slot_with_hash (decl_die_table
, decl
, decl_id
, INSERT
);
5311 decl_die
->decl_id
= decl_id
;
5314 /* Add a variable location node to the linked list for DECL. */
5317 add_var_loc_to_decl (tree decl
, struct var_loc_node
*loc
)
5319 unsigned int decl_id
= DECL_UID (decl
);
5323 slot
= htab_find_slot_with_hash (decl_loc_table
, decl
, decl_id
, INSERT
);
5326 temp
= ggc_alloc_cleared (sizeof (var_loc_list
));
5327 temp
->decl_id
= decl_id
;
5335 /* If the current location is the same as the end of the list,
5336 we have nothing to do. */
5337 if (!rtx_equal_p (NOTE_VAR_LOCATION_LOC (temp
->last
->var_loc_note
),
5338 NOTE_VAR_LOCATION_LOC (loc
->var_loc_note
)))
5340 /* Add LOC to the end of list and update LAST. */
5341 temp
->last
->next
= loc
;
5345 /* Do not add empty location to the beginning of the list. */
5346 else if (NOTE_VAR_LOCATION_LOC (loc
->var_loc_note
) != NULL_RTX
)
5353 /* Keep track of the number of spaces used to indent the
5354 output of the debugging routines that print the structure of
5355 the DIE internal representation. */
5356 static int print_indent
;
5358 /* Indent the line the number of spaces given by print_indent. */
5361 print_spaces (FILE *outfile
)
5363 fprintf (outfile
, "%*s", print_indent
, "");
5366 /* Print the information associated with a given DIE, and its children.
5367 This routine is a debugging aid only. */
5370 print_die (dw_die_ref die
, FILE *outfile
)
5375 print_spaces (outfile
);
5376 fprintf (outfile
, "DIE %4lu: %s\n",
5377 die
->die_offset
, dwarf_tag_name (die
->die_tag
));
5378 print_spaces (outfile
);
5379 fprintf (outfile
, " abbrev id: %lu", die
->die_abbrev
);
5380 fprintf (outfile
, " offset: %lu\n", die
->die_offset
);
5382 for (a
= die
->die_attr
; a
!= NULL
; a
= a
->dw_attr_next
)
5384 print_spaces (outfile
);
5385 fprintf (outfile
, " %s: ", dwarf_attr_name (a
->dw_attr
));
5387 switch (AT_class (a
))
5389 case dw_val_class_addr
:
5390 fprintf (outfile
, "address");
5392 case dw_val_class_offset
:
5393 fprintf (outfile
, "offset");
5395 case dw_val_class_loc
:
5396 fprintf (outfile
, "location descriptor");
5398 case dw_val_class_loc_list
:
5399 fprintf (outfile
, "location list -> label:%s",
5400 AT_loc_list (a
)->ll_symbol
);
5402 case dw_val_class_range_list
:
5403 fprintf (outfile
, "range list");
5405 case dw_val_class_const
:
5406 fprintf (outfile
, HOST_WIDE_INT_PRINT_DEC
, AT_int (a
));
5408 case dw_val_class_unsigned_const
:
5409 fprintf (outfile
, HOST_WIDE_INT_PRINT_UNSIGNED
, AT_unsigned (a
));
5411 case dw_val_class_long_long
:
5412 fprintf (outfile
, "constant (%lu,%lu)",
5413 a
->dw_attr_val
.v
.val_long_long
.hi
,
5414 a
->dw_attr_val
.v
.val_long_long
.low
);
5416 case dw_val_class_vec
:
5417 fprintf (outfile
, "floating-point or vector constant");
5419 case dw_val_class_flag
:
5420 fprintf (outfile
, "%u", AT_flag (a
));
5422 case dw_val_class_die_ref
:
5423 if (AT_ref (a
) != NULL
)
5425 if (AT_ref (a
)->die_symbol
)
5426 fprintf (outfile
, "die -> label: %s", AT_ref (a
)->die_symbol
);
5428 fprintf (outfile
, "die -> %lu", AT_ref (a
)->die_offset
);
5431 fprintf (outfile
, "die -> <null>");
5433 case dw_val_class_lbl_id
:
5434 case dw_val_class_lbl_offset
:
5435 fprintf (outfile
, "label: %s", AT_lbl (a
));
5437 case dw_val_class_str
:
5438 if (AT_string (a
) != NULL
)
5439 fprintf (outfile
, "\"%s\"", AT_string (a
));
5441 fprintf (outfile
, "<null>");
5447 fprintf (outfile
, "\n");
5450 if (die
->die_child
!= NULL
)
5453 for (c
= die
->die_child
; c
!= NULL
; c
= c
->die_sib
)
5454 print_die (c
, outfile
);
5458 if (print_indent
== 0)
5459 fprintf (outfile
, "\n");
5462 /* Print the contents of the source code line number correspondence table.
5463 This routine is a debugging aid only. */
5466 print_dwarf_line_table (FILE *outfile
)
5469 dw_line_info_ref line_info
;
5471 fprintf (outfile
, "\n\nDWARF source line information\n");
5472 for (i
= 1; i
< line_info_table_in_use
; i
++)
5474 line_info
= &line_info_table
[i
];
5475 fprintf (outfile
, "%5d: ", i
);
5476 fprintf (outfile
, "%-20s",
5477 VARRAY_CHAR_PTR (file_table
, line_info
->dw_file_num
));
5478 fprintf (outfile
, "%6ld", line_info
->dw_line_num
);
5479 fprintf (outfile
, "\n");
5482 fprintf (outfile
, "\n\n");
5485 /* Print the information collected for a given DIE. */
5488 debug_dwarf_die (dw_die_ref die
)
5490 print_die (die
, stderr
);
5493 /* Print all DWARF information collected for the compilation unit.
5494 This routine is a debugging aid only. */
5500 print_die (comp_unit_die
, stderr
);
5501 if (! DWARF2_ASM_LINE_DEBUG_INFO
)
5502 print_dwarf_line_table (stderr
);
5505 /* We build up the lists of children and attributes by pushing new ones
5506 onto the beginning of the list. Reverse the lists for DIE so that
5507 they are in order of addition. */
5510 reverse_die_lists (dw_die_ref die
)
5512 dw_die_ref c
, cp
, cn
;
5513 dw_attr_ref a
, ap
, an
;
5515 for (a
= die
->die_attr
, ap
= 0; a
; a
= an
)
5517 an
= a
->dw_attr_next
;
5518 a
->dw_attr_next
= ap
;
5524 for (c
= die
->die_child
, cp
= 0; c
; c
= cn
)
5531 die
->die_child
= cp
;
5534 /* reverse_die_lists only reverses the single die you pass it. Since we used to
5535 reverse all dies in add_sibling_attributes, which runs through all the dies,
5536 it would reverse all the dies. Now, however, since we don't call
5537 reverse_die_lists in add_sibling_attributes, we need a routine to
5538 recursively reverse all the dies. This is that routine. */
5541 reverse_all_dies (dw_die_ref die
)
5545 reverse_die_lists (die
);
5547 for (c
= die
->die_child
; c
; c
= c
->die_sib
)
5548 reverse_all_dies (c
);
5551 /* Start a new compilation unit DIE for an include file. OLD_UNIT is the CU
5552 for the enclosing include file, if any. BINCL_DIE is the DW_TAG_GNU_BINCL
5553 DIE that marks the start of the DIEs for this include file. */
5556 push_new_compile_unit (dw_die_ref old_unit
, dw_die_ref bincl_die
)
5558 const char *filename
= get_AT_string (bincl_die
, DW_AT_name
);
5559 dw_die_ref new_unit
= gen_compile_unit_die (filename
);
5561 new_unit
->die_sib
= old_unit
;
5565 /* Close an include-file CU and reopen the enclosing one. */
5568 pop_compile_unit (dw_die_ref old_unit
)
5570 dw_die_ref new_unit
= old_unit
->die_sib
;
5572 old_unit
->die_sib
= NULL
;
5576 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
5577 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO), ctx)
5579 /* Calculate the checksum of a location expression. */
5582 loc_checksum (dw_loc_descr_ref loc
, struct md5_ctx
*ctx
)
5584 CHECKSUM (loc
->dw_loc_opc
);
5585 CHECKSUM (loc
->dw_loc_oprnd1
);
5586 CHECKSUM (loc
->dw_loc_oprnd2
);
5589 /* Calculate the checksum of an attribute. */
5592 attr_checksum (dw_attr_ref at
, struct md5_ctx
*ctx
, int *mark
)
5594 dw_loc_descr_ref loc
;
5597 CHECKSUM (at
->dw_attr
);
5599 /* We don't care about differences in file numbering. */
5600 if (at
->dw_attr
== DW_AT_decl_file
5601 /* Or that this was compiled with a different compiler snapshot; if
5602 the output is the same, that's what matters. */
5603 || at
->dw_attr
== DW_AT_producer
)
5606 switch (AT_class (at
))
5608 case dw_val_class_const
:
5609 CHECKSUM (at
->dw_attr_val
.v
.val_int
);
5611 case dw_val_class_unsigned_const
:
5612 CHECKSUM (at
->dw_attr_val
.v
.val_unsigned
);
5614 case dw_val_class_long_long
:
5615 CHECKSUM (at
->dw_attr_val
.v
.val_long_long
);
5617 case dw_val_class_vec
:
5618 CHECKSUM (at
->dw_attr_val
.v
.val_vec
);
5620 case dw_val_class_flag
:
5621 CHECKSUM (at
->dw_attr_val
.v
.val_flag
);
5623 case dw_val_class_str
:
5624 CHECKSUM_STRING (AT_string (at
));
5627 case dw_val_class_addr
:
5629 switch (GET_CODE (r
))
5632 CHECKSUM_STRING (XSTR (r
, 0));
5640 case dw_val_class_offset
:
5641 CHECKSUM (at
->dw_attr_val
.v
.val_offset
);
5644 case dw_val_class_loc
:
5645 for (loc
= AT_loc (at
); loc
; loc
= loc
->dw_loc_next
)
5646 loc_checksum (loc
, ctx
);
5649 case dw_val_class_die_ref
:
5650 die_checksum (AT_ref (at
), ctx
, mark
);
5653 case dw_val_class_fde_ref
:
5654 case dw_val_class_lbl_id
:
5655 case dw_val_class_lbl_offset
:
5663 /* Calculate the checksum of a DIE. */
5666 die_checksum (dw_die_ref die
, struct md5_ctx
*ctx
, int *mark
)
5671 /* To avoid infinite recursion. */
5674 CHECKSUM (die
->die_mark
);
5677 die
->die_mark
= ++(*mark
);
5679 CHECKSUM (die
->die_tag
);
5681 for (a
= die
->die_attr
; a
; a
= a
->dw_attr_next
)
5682 attr_checksum (a
, ctx
, mark
);
5684 for (c
= die
->die_child
; c
; c
= c
->die_sib
)
5685 die_checksum (c
, ctx
, mark
);
5689 #undef CHECKSUM_STRING
5691 /* Do the location expressions look same? */
5693 same_loc_p (dw_loc_descr_ref loc1
, dw_loc_descr_ref loc2
, int *mark
)
5695 return loc1
->dw_loc_opc
== loc2
->dw_loc_opc
5696 && same_dw_val_p (&loc1
->dw_loc_oprnd1
, &loc2
->dw_loc_oprnd1
, mark
)
5697 && same_dw_val_p (&loc1
->dw_loc_oprnd2
, &loc2
->dw_loc_oprnd2
, mark
);
5700 /* Do the values look the same? */
5702 same_dw_val_p (dw_val_node
*v1
, dw_val_node
*v2
, int *mark
)
5704 dw_loc_descr_ref loc1
, loc2
;
5707 if (v1
->val_class
!= v2
->val_class
)
5710 switch (v1
->val_class
)
5712 case dw_val_class_const
:
5713 return v1
->v
.val_int
== v2
->v
.val_int
;
5714 case dw_val_class_unsigned_const
:
5715 return v1
->v
.val_unsigned
== v2
->v
.val_unsigned
;
5716 case dw_val_class_long_long
:
5717 return v1
->v
.val_long_long
.hi
== v2
->v
.val_long_long
.hi
5718 && v1
->v
.val_long_long
.low
== v2
->v
.val_long_long
.low
;
5719 case dw_val_class_vec
:
5720 if (v1
->v
.val_vec
.length
!= v2
->v
.val_vec
.length
5721 || v1
->v
.val_vec
.elt_size
!= v2
->v
.val_vec
.elt_size
)
5723 if (memcmp (v1
->v
.val_vec
.array
, v2
->v
.val_vec
.array
,
5724 v1
->v
.val_vec
.length
* v1
->v
.val_vec
.elt_size
))
5727 case dw_val_class_flag
:
5728 return v1
->v
.val_flag
== v2
->v
.val_flag
;
5729 case dw_val_class_str
:
5730 return !strcmp(v1
->v
.val_str
->str
, v2
->v
.val_str
->str
);
5732 case dw_val_class_addr
:
5733 r1
= v1
->v
.val_addr
;
5734 r2
= v2
->v
.val_addr
;
5735 if (GET_CODE (r1
) != GET_CODE (r2
))
5737 switch (GET_CODE (r1
))
5740 return !strcmp (XSTR (r1
, 0), XSTR (r2
, 0));
5746 case dw_val_class_offset
:
5747 return v1
->v
.val_offset
== v2
->v
.val_offset
;
5749 case dw_val_class_loc
:
5750 for (loc1
= v1
->v
.val_loc
, loc2
= v2
->v
.val_loc
;
5752 loc1
= loc1
->dw_loc_next
, loc2
= loc2
->dw_loc_next
)
5753 if (!same_loc_p (loc1
, loc2
, mark
))
5755 return !loc1
&& !loc2
;
5757 case dw_val_class_die_ref
:
5758 return same_die_p (v1
->v
.val_die_ref
.die
, v2
->v
.val_die_ref
.die
, mark
);
5760 case dw_val_class_fde_ref
:
5761 case dw_val_class_lbl_id
:
5762 case dw_val_class_lbl_offset
:
5770 /* Do the attributes look the same? */
5773 same_attr_p (dw_attr_ref at1
, dw_attr_ref at2
, int *mark
)
5775 if (at1
->dw_attr
!= at2
->dw_attr
)
5778 /* We don't care about differences in file numbering. */
5779 if (at1
->dw_attr
== DW_AT_decl_file
5780 /* Or that this was compiled with a different compiler snapshot; if
5781 the output is the same, that's what matters. */
5782 || at1
->dw_attr
== DW_AT_producer
)
5785 return same_dw_val_p (&at1
->dw_attr_val
, &at2
->dw_attr_val
, mark
);
5788 /* Do the dies look the same? */
5791 same_die_p (dw_die_ref die1
, dw_die_ref die2
, int *mark
)
5796 /* To avoid infinite recursion. */
5798 return die1
->die_mark
== die2
->die_mark
;
5799 die1
->die_mark
= die2
->die_mark
= ++(*mark
);
5801 if (die1
->die_tag
!= die2
->die_tag
)
5804 for (a1
= die1
->die_attr
, a2
= die2
->die_attr
;
5806 a1
= a1
->dw_attr_next
, a2
= a2
->dw_attr_next
)
5807 if (!same_attr_p (a1
, a2
, mark
))
5812 for (c1
= die1
->die_child
, c2
= die2
->die_child
;
5814 c1
= c1
->die_sib
, c2
= c2
->die_sib
)
5815 if (!same_die_p (c1
, c2
, mark
))
5823 /* Do the dies look the same? Wrapper around same_die_p. */
5826 same_die_p_wrap (dw_die_ref die1
, dw_die_ref die2
)
5829 int ret
= same_die_p (die1
, die2
, &mark
);
5831 unmark_all_dies (die1
);
5832 unmark_all_dies (die2
);
5837 /* The prefix to attach to symbols on DIEs in the current comdat debug
5839 static char *comdat_symbol_id
;
5841 /* The index of the current symbol within the current comdat CU. */
5842 static unsigned int comdat_symbol_number
;
5844 /* Calculate the MD5 checksum of the compilation unit DIE UNIT_DIE and its
5845 children, and set comdat_symbol_id accordingly. */
5848 compute_section_prefix (dw_die_ref unit_die
)
5850 const char *die_name
= get_AT_string (unit_die
, DW_AT_name
);
5851 const char *base
= die_name
? lbasename (die_name
) : "anonymous";
5852 char *name
= alloca (strlen (base
) + 64);
5855 unsigned char checksum
[16];
5858 /* Compute the checksum of the DIE, then append part of it as hex digits to
5859 the name filename of the unit. */
5861 md5_init_ctx (&ctx
);
5863 die_checksum (unit_die
, &ctx
, &mark
);
5864 unmark_all_dies (unit_die
);
5865 md5_finish_ctx (&ctx
, checksum
);
5867 sprintf (name
, "%s.", base
);
5868 clean_symbol_name (name
);
5870 p
= name
+ strlen (name
);
5871 for (i
= 0; i
< 4; i
++)
5873 sprintf (p
, "%.2x", checksum
[i
]);
5877 comdat_symbol_id
= unit_die
->die_symbol
= xstrdup (name
);
5878 comdat_symbol_number
= 0;
5881 /* Returns nonzero if DIE represents a type, in the sense of TYPE_P. */
5884 is_type_die (dw_die_ref die
)
5886 switch (die
->die_tag
)
5888 case DW_TAG_array_type
:
5889 case DW_TAG_class_type
:
5890 case DW_TAG_enumeration_type
:
5891 case DW_TAG_pointer_type
:
5892 case DW_TAG_reference_type
:
5893 case DW_TAG_string_type
:
5894 case DW_TAG_structure_type
:
5895 case DW_TAG_subroutine_type
:
5896 case DW_TAG_union_type
:
5897 case DW_TAG_ptr_to_member_type
:
5898 case DW_TAG_set_type
:
5899 case DW_TAG_subrange_type
:
5900 case DW_TAG_base_type
:
5901 case DW_TAG_const_type
:
5902 case DW_TAG_file_type
:
5903 case DW_TAG_packed_type
:
5904 case DW_TAG_volatile_type
:
5905 case DW_TAG_typedef
:
5912 /* Returns 1 iff C is the sort of DIE that should go into a COMDAT CU.
5913 Basically, we want to choose the bits that are likely to be shared between
5914 compilations (types) and leave out the bits that are specific to individual
5915 compilations (functions). */
5918 is_comdat_die (dw_die_ref c
)
5920 /* I think we want to leave base types and __vtbl_ptr_type in the main CU, as
5921 we do for stabs. The advantage is a greater likelihood of sharing between
5922 objects that don't include headers in the same order (and therefore would
5923 put the base types in a different comdat). jason 8/28/00 */
5925 if (c
->die_tag
== DW_TAG_base_type
)
5928 if (c
->die_tag
== DW_TAG_pointer_type
5929 || c
->die_tag
== DW_TAG_reference_type
5930 || c
->die_tag
== DW_TAG_const_type
5931 || c
->die_tag
== DW_TAG_volatile_type
)
5933 dw_die_ref t
= get_AT_ref (c
, DW_AT_type
);
5935 return t
? is_comdat_die (t
) : 0;
5938 return is_type_die (c
);
5941 /* Returns 1 iff C is the sort of DIE that might be referred to from another
5942 compilation unit. */
5945 is_symbol_die (dw_die_ref c
)
5947 return (is_type_die (c
)
5948 || (get_AT (c
, DW_AT_declaration
)
5949 && !get_AT (c
, DW_AT_specification
)));
5953 gen_internal_sym (const char *prefix
)
5957 ASM_GENERATE_INTERNAL_LABEL (buf
, prefix
, label_num
++);
5958 return xstrdup (buf
);
5961 /* Assign symbols to all worthy DIEs under DIE. */
5964 assign_symbol_names (dw_die_ref die
)
5968 if (is_symbol_die (die
))
5970 if (comdat_symbol_id
)
5972 char *p
= alloca (strlen (comdat_symbol_id
) + 64);
5974 sprintf (p
, "%s.%s.%x", DIE_LABEL_PREFIX
,
5975 comdat_symbol_id
, comdat_symbol_number
++);
5976 die
->die_symbol
= xstrdup (p
);
5979 die
->die_symbol
= gen_internal_sym ("LDIE");
5982 for (c
= die
->die_child
; c
!= NULL
; c
= c
->die_sib
)
5983 assign_symbol_names (c
);
5986 struct cu_hash_table_entry
5989 unsigned min_comdat_num
, max_comdat_num
;
5990 struct cu_hash_table_entry
*next
;
5993 /* Routines to manipulate hash table of CUs. */
5995 htab_cu_hash (const void *of
)
5997 const struct cu_hash_table_entry
*entry
= of
;
5999 return htab_hash_string (entry
->cu
->die_symbol
);
6003 htab_cu_eq (const void *of1
, const void *of2
)
6005 const struct cu_hash_table_entry
*entry1
= of1
;
6006 const struct die_struct
*entry2
= of2
;
6008 return !strcmp (entry1
->cu
->die_symbol
, entry2
->die_symbol
);
6012 htab_cu_del (void *what
)
6014 struct cu_hash_table_entry
*next
, *entry
= what
;
6024 /* Check whether we have already seen this CU and set up SYM_NUM
6027 check_duplicate_cu (dw_die_ref cu
, htab_t htable
, unsigned int *sym_num
)
6029 struct cu_hash_table_entry dummy
;
6030 struct cu_hash_table_entry
**slot
, *entry
, *last
= &dummy
;
6032 dummy
.max_comdat_num
= 0;
6034 slot
= (struct cu_hash_table_entry
**)
6035 htab_find_slot_with_hash (htable
, cu
, htab_hash_string (cu
->die_symbol
),
6039 for (; entry
; last
= entry
, entry
= entry
->next
)
6041 if (same_die_p_wrap (cu
, entry
->cu
))
6047 *sym_num
= entry
->min_comdat_num
;
6051 entry
= xcalloc (1, sizeof (struct cu_hash_table_entry
));
6053 entry
->min_comdat_num
= *sym_num
= last
->max_comdat_num
;
6054 entry
->next
= *slot
;
6060 /* Record SYM_NUM to record of CU in HTABLE. */
6062 record_comdat_symbol_number (dw_die_ref cu
, htab_t htable
, unsigned int sym_num
)
6064 struct cu_hash_table_entry
**slot
, *entry
;
6066 slot
= (struct cu_hash_table_entry
**)
6067 htab_find_slot_with_hash (htable
, cu
, htab_hash_string (cu
->die_symbol
),
6071 entry
->max_comdat_num
= sym_num
;
6074 /* Traverse the DIE (which is always comp_unit_die), and set up
6075 additional compilation units for each of the include files we see
6076 bracketed by BINCL/EINCL. */
6079 break_out_includes (dw_die_ref die
)
6082 dw_die_ref unit
= NULL
;
6083 limbo_die_node
*node
, **pnode
;
6084 htab_t cu_hash_table
;
6086 for (ptr
= &(die
->die_child
); *ptr
;)
6088 dw_die_ref c
= *ptr
;
6090 if (c
->die_tag
== DW_TAG_GNU_BINCL
|| c
->die_tag
== DW_TAG_GNU_EINCL
6091 || (unit
&& is_comdat_die (c
)))
6093 /* This DIE is for a secondary CU; remove it from the main one. */
6096 if (c
->die_tag
== DW_TAG_GNU_BINCL
)
6098 unit
= push_new_compile_unit (unit
, c
);
6101 else if (c
->die_tag
== DW_TAG_GNU_EINCL
)
6103 unit
= pop_compile_unit (unit
);
6107 add_child_die (unit
, c
);
6111 /* Leave this DIE in the main CU. */
6112 ptr
= &(c
->die_sib
);
6118 /* We can only use this in debugging, since the frontend doesn't check
6119 to make sure that we leave every include file we enter. */
6124 assign_symbol_names (die
);
6125 cu_hash_table
= htab_create (10, htab_cu_hash
, htab_cu_eq
, htab_cu_del
);
6126 for (node
= limbo_die_list
, pnode
= &limbo_die_list
;
6132 compute_section_prefix (node
->die
);
6133 is_dupl
= check_duplicate_cu (node
->die
, cu_hash_table
,
6134 &comdat_symbol_number
);
6135 assign_symbol_names (node
->die
);
6137 *pnode
= node
->next
;
6140 pnode
= &node
->next
;
6141 record_comdat_symbol_number (node
->die
, cu_hash_table
,
6142 comdat_symbol_number
);
6145 htab_delete (cu_hash_table
);
6148 /* Traverse the DIE and add a sibling attribute if it may have the
6149 effect of speeding up access to siblings. To save some space,
6150 avoid generating sibling attributes for DIE's without children. */
6153 add_sibling_attributes (dw_die_ref die
)
6157 if (die
->die_tag
!= DW_TAG_compile_unit
6158 && die
->die_sib
&& die
->die_child
!= NULL
)
6159 /* Add the sibling link to the front of the attribute list. */
6160 add_AT_die_ref (die
, DW_AT_sibling
, die
->die_sib
);
6162 for (c
= die
->die_child
; c
!= NULL
; c
= c
->die_sib
)
6163 add_sibling_attributes (c
);
6166 /* Output all location lists for the DIE and its children. */
6169 output_location_lists (dw_die_ref die
)
6174 for (d_attr
= die
->die_attr
; d_attr
; d_attr
= d_attr
->dw_attr_next
)
6175 if (AT_class (d_attr
) == dw_val_class_loc_list
)
6176 output_loc_list (AT_loc_list (d_attr
));
6178 for (c
= die
->die_child
; c
!= NULL
; c
= c
->die_sib
)
6179 output_location_lists (c
);
6183 /* The format of each DIE (and its attribute value pairs) is encoded in an
6184 abbreviation table. This routine builds the abbreviation table and assigns
6185 a unique abbreviation id for each abbreviation entry. The children of each
6186 die are visited recursively. */
6189 build_abbrev_table (dw_die_ref die
)
6191 unsigned long abbrev_id
;
6192 unsigned int n_alloc
;
6194 dw_attr_ref d_attr
, a_attr
;
6196 /* Scan the DIE references, and mark as external any that refer to
6197 DIEs from other CUs (i.e. those which are not marked). */
6198 for (d_attr
= die
->die_attr
; d_attr
; d_attr
= d_attr
->dw_attr_next
)
6199 if (AT_class (d_attr
) == dw_val_class_die_ref
6200 && AT_ref (d_attr
)->die_mark
== 0)
6202 if (AT_ref (d_attr
)->die_symbol
== 0)
6205 set_AT_ref_external (d_attr
, 1);
6208 for (abbrev_id
= 1; abbrev_id
< abbrev_die_table_in_use
; ++abbrev_id
)
6210 dw_die_ref abbrev
= abbrev_die_table
[abbrev_id
];
6212 if (abbrev
->die_tag
== die
->die_tag
)
6214 if ((abbrev
->die_child
!= NULL
) == (die
->die_child
!= NULL
))
6216 a_attr
= abbrev
->die_attr
;
6217 d_attr
= die
->die_attr
;
6219 while (a_attr
!= NULL
&& d_attr
!= NULL
)
6221 if ((a_attr
->dw_attr
!= d_attr
->dw_attr
)
6222 || (value_format (a_attr
) != value_format (d_attr
)))
6225 a_attr
= a_attr
->dw_attr_next
;
6226 d_attr
= d_attr
->dw_attr_next
;
6229 if (a_attr
== NULL
&& d_attr
== NULL
)
6235 if (abbrev_id
>= abbrev_die_table_in_use
)
6237 if (abbrev_die_table_in_use
>= abbrev_die_table_allocated
)
6239 n_alloc
= abbrev_die_table_allocated
+ ABBREV_DIE_TABLE_INCREMENT
;
6240 abbrev_die_table
= ggc_realloc (abbrev_die_table
,
6241 sizeof (dw_die_ref
) * n_alloc
);
6243 memset (&abbrev_die_table
[abbrev_die_table_allocated
], 0,
6244 (n_alloc
- abbrev_die_table_allocated
) * sizeof (dw_die_ref
));
6245 abbrev_die_table_allocated
= n_alloc
;
6248 ++abbrev_die_table_in_use
;
6249 abbrev_die_table
[abbrev_id
] = die
;
6252 die
->die_abbrev
= abbrev_id
;
6253 for (c
= die
->die_child
; c
!= NULL
; c
= c
->die_sib
)
6254 build_abbrev_table (c
);
6257 /* Return the power-of-two number of bytes necessary to represent VALUE. */
6260 constant_size (long unsigned int value
)
6267 log
= floor_log2 (value
);
6270 log
= 1 << (floor_log2 (log
) + 1);
6275 /* Return the size of a DIE as it is represented in the
6276 .debug_info section. */
6278 static unsigned long
6279 size_of_die (dw_die_ref die
)
6281 unsigned long size
= 0;
6284 size
+= size_of_uleb128 (die
->die_abbrev
);
6285 for (a
= die
->die_attr
; a
!= NULL
; a
= a
->dw_attr_next
)
6287 switch (AT_class (a
))
6289 case dw_val_class_addr
:
6290 size
+= DWARF2_ADDR_SIZE
;
6292 case dw_val_class_offset
:
6293 size
+= DWARF_OFFSET_SIZE
;
6295 case dw_val_class_loc
:
6297 unsigned long lsize
= size_of_locs (AT_loc (a
));
6300 size
+= constant_size (lsize
);
6304 case dw_val_class_loc_list
:
6305 size
+= DWARF_OFFSET_SIZE
;
6307 case dw_val_class_range_list
:
6308 size
+= DWARF_OFFSET_SIZE
;
6310 case dw_val_class_const
:
6311 size
+= size_of_sleb128 (AT_int (a
));
6313 case dw_val_class_unsigned_const
:
6314 size
+= constant_size (AT_unsigned (a
));
6316 case dw_val_class_long_long
:
6317 size
+= 1 + 2*HOST_BITS_PER_LONG
/HOST_BITS_PER_CHAR
; /* block */
6319 case dw_val_class_vec
:
6320 size
+= 1 + (a
->dw_attr_val
.v
.val_vec
.length
6321 * a
->dw_attr_val
.v
.val_vec
.elt_size
); /* block */
6323 case dw_val_class_flag
:
6326 case dw_val_class_die_ref
:
6327 if (AT_ref_external (a
))
6328 size
+= DWARF2_ADDR_SIZE
;
6330 size
+= DWARF_OFFSET_SIZE
;
6332 case dw_val_class_fde_ref
:
6333 size
+= DWARF_OFFSET_SIZE
;
6335 case dw_val_class_lbl_id
:
6336 size
+= DWARF2_ADDR_SIZE
;
6338 case dw_val_class_lbl_offset
:
6339 size
+= DWARF_OFFSET_SIZE
;
6341 case dw_val_class_str
:
6342 if (AT_string_form (a
) == DW_FORM_strp
)
6343 size
+= DWARF_OFFSET_SIZE
;
6345 size
+= strlen (a
->dw_attr_val
.v
.val_str
->str
) + 1;
6355 /* Size the debugging information associated with a given DIE. Visits the
6356 DIE's children recursively. Updates the global variable next_die_offset, on
6357 each time through. Uses the current value of next_die_offset to update the
6358 die_offset field in each DIE. */
6361 calc_die_sizes (dw_die_ref die
)
6365 die
->die_offset
= next_die_offset
;
6366 next_die_offset
+= size_of_die (die
);
6368 for (c
= die
->die_child
; c
!= NULL
; c
= c
->die_sib
)
6371 if (die
->die_child
!= NULL
)
6372 /* Count the null byte used to terminate sibling lists. */
6373 next_die_offset
+= 1;
6376 /* Set the marks for a die and its children. We do this so
6377 that we know whether or not a reference needs to use FORM_ref_addr; only
6378 DIEs in the same CU will be marked. We used to clear out the offset
6379 and use that as the flag, but ran into ordering problems. */
6382 mark_dies (dw_die_ref die
)
6390 for (c
= die
->die_child
; c
; c
= c
->die_sib
)
6394 /* Clear the marks for a die and its children. */
6397 unmark_dies (dw_die_ref die
)
6405 for (c
= die
->die_child
; c
; c
= c
->die_sib
)
6409 /* Clear the marks for a die, its children and referred dies. */
6412 unmark_all_dies (dw_die_ref die
)
6421 for (c
= die
->die_child
; c
; c
= c
->die_sib
)
6422 unmark_all_dies (c
);
6424 for (a
= die
->die_attr
; a
; a
= a
->dw_attr_next
)
6425 if (AT_class (a
) == dw_val_class_die_ref
)
6426 unmark_all_dies (AT_ref (a
));
6429 /* Return the size of the .debug_pubnames table generated for the
6430 compilation unit. */
6432 static unsigned long
6433 size_of_pubnames (void)
6438 size
= DWARF_PUBNAMES_HEADER_SIZE
;
6439 for (i
= 0; i
< pubname_table_in_use
; i
++)
6441 pubname_ref p
= &pubname_table
[i
];
6442 size
+= DWARF_OFFSET_SIZE
+ strlen (p
->name
) + 1;
6445 size
+= DWARF_OFFSET_SIZE
;
6449 /* Return the size of the information in the .debug_aranges section. */
6451 static unsigned long
6452 size_of_aranges (void)
6456 size
= DWARF_ARANGES_HEADER_SIZE
;
6458 /* Count the address/length pair for this compilation unit. */
6459 size
+= 2 * DWARF2_ADDR_SIZE
;
6460 size
+= 2 * DWARF2_ADDR_SIZE
* arange_table_in_use
;
6462 /* Count the two zero words used to terminated the address range table. */
6463 size
+= 2 * DWARF2_ADDR_SIZE
;
6467 /* Select the encoding of an attribute value. */
6469 static enum dwarf_form
6470 value_format (dw_attr_ref a
)
6472 switch (a
->dw_attr_val
.val_class
)
6474 case dw_val_class_addr
:
6475 return DW_FORM_addr
;
6476 case dw_val_class_range_list
:
6477 case dw_val_class_offset
:
6478 if (DWARF_OFFSET_SIZE
== 4)
6479 return DW_FORM_data4
;
6480 if (DWARF_OFFSET_SIZE
== 8)
6481 return DW_FORM_data8
;
6483 case dw_val_class_loc_list
:
6484 /* FIXME: Could be DW_FORM_data8, with a > 32 bit size
6485 .debug_loc section */
6486 return DW_FORM_data4
;
6487 case dw_val_class_loc
:
6488 switch (constant_size (size_of_locs (AT_loc (a
))))
6491 return DW_FORM_block1
;
6493 return DW_FORM_block2
;
6497 case dw_val_class_const
:
6498 return DW_FORM_sdata
;
6499 case dw_val_class_unsigned_const
:
6500 switch (constant_size (AT_unsigned (a
)))
6503 return DW_FORM_data1
;
6505 return DW_FORM_data2
;
6507 return DW_FORM_data4
;
6509 return DW_FORM_data8
;
6513 case dw_val_class_long_long
:
6514 return DW_FORM_block1
;
6515 case dw_val_class_vec
:
6516 return DW_FORM_block1
;
6517 case dw_val_class_flag
:
6518 return DW_FORM_flag
;
6519 case dw_val_class_die_ref
:
6520 if (AT_ref_external (a
))
6521 return DW_FORM_ref_addr
;
6524 case dw_val_class_fde_ref
:
6525 return DW_FORM_data
;
6526 case dw_val_class_lbl_id
:
6527 return DW_FORM_addr
;
6528 case dw_val_class_lbl_offset
:
6529 return DW_FORM_data
;
6530 case dw_val_class_str
:
6531 return AT_string_form (a
);
6538 /* Output the encoding of an attribute value. */
6541 output_value_format (dw_attr_ref a
)
6543 enum dwarf_form form
= value_format (a
);
6545 dw2_asm_output_data_uleb128 (form
, "(%s)", dwarf_form_name (form
));
6548 /* Output the .debug_abbrev section which defines the DIE abbreviation
6552 output_abbrev_section (void)
6554 unsigned long abbrev_id
;
6558 for (abbrev_id
= 1; abbrev_id
< abbrev_die_table_in_use
; ++abbrev_id
)
6560 dw_die_ref abbrev
= abbrev_die_table
[abbrev_id
];
6562 dw2_asm_output_data_uleb128 (abbrev_id
, "(abbrev code)");
6563 dw2_asm_output_data_uleb128 (abbrev
->die_tag
, "(TAG: %s)",
6564 dwarf_tag_name (abbrev
->die_tag
));
6566 if (abbrev
->die_child
!= NULL
)
6567 dw2_asm_output_data (1, DW_children_yes
, "DW_children_yes");
6569 dw2_asm_output_data (1, DW_children_no
, "DW_children_no");
6571 for (a_attr
= abbrev
->die_attr
; a_attr
!= NULL
;
6572 a_attr
= a_attr
->dw_attr_next
)
6574 dw2_asm_output_data_uleb128 (a_attr
->dw_attr
, "(%s)",
6575 dwarf_attr_name (a_attr
->dw_attr
));
6576 output_value_format (a_attr
);
6579 dw2_asm_output_data (1, 0, NULL
);
6580 dw2_asm_output_data (1, 0, NULL
);
6583 /* Terminate the table. */
6584 dw2_asm_output_data (1, 0, NULL
);
6587 /* Output a symbol we can use to refer to this DIE from another CU. */
6590 output_die_symbol (dw_die_ref die
)
6592 char *sym
= die
->die_symbol
;
6597 if (strncmp (sym
, DIE_LABEL_PREFIX
, sizeof (DIE_LABEL_PREFIX
) - 1) == 0)
6598 /* We make these global, not weak; if the target doesn't support
6599 .linkonce, it doesn't support combining the sections, so debugging
6601 (*targetm
.asm_out
.globalize_label
) (asm_out_file
, sym
);
6603 ASM_OUTPUT_LABEL (asm_out_file
, sym
);
6606 /* Return a new location list, given the begin and end range, and the
6607 expression. gensym tells us whether to generate a new internal symbol for
6608 this location list node, which is done for the head of the list only. */
6610 static inline dw_loc_list_ref
6611 new_loc_list (dw_loc_descr_ref expr
, const char *begin
, const char *end
,
6612 const char *section
, unsigned int gensym
)
6614 dw_loc_list_ref retlist
= ggc_alloc_cleared (sizeof (dw_loc_list_node
));
6616 retlist
->begin
= begin
;
6618 retlist
->expr
= expr
;
6619 retlist
->section
= section
;
6621 retlist
->ll_symbol
= gen_internal_sym ("LLST");
6626 /* Add a location description expression to a location list. */
6629 add_loc_descr_to_loc_list (dw_loc_list_ref
*list_head
, dw_loc_descr_ref descr
,
6630 const char *begin
, const char *end
,
6631 const char *section
)
6635 /* Find the end of the chain. */
6636 for (d
= list_head
; (*d
) != NULL
; d
= &(*d
)->dw_loc_next
)
6639 /* Add a new location list node to the list. */
6640 *d
= new_loc_list (descr
, begin
, end
, section
, 0);
6643 /* Output the location list given to us. */
6646 output_loc_list (dw_loc_list_ref list_head
)
6648 dw_loc_list_ref curr
= list_head
;
6650 ASM_OUTPUT_LABEL (asm_out_file
, list_head
->ll_symbol
);
6652 /* Walk the location list, and output each range + expression. */
6653 for (curr
= list_head
; curr
!= NULL
; curr
= curr
->dw_loc_next
)
6656 if (separate_line_info_table_in_use
== 0)
6658 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, curr
->begin
, curr
->section
,
6659 "Location list begin address (%s)",
6660 list_head
->ll_symbol
);
6661 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, curr
->end
, curr
->section
,
6662 "Location list end address (%s)",
6663 list_head
->ll_symbol
);
6667 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->begin
,
6668 "Location list begin address (%s)",
6669 list_head
->ll_symbol
);
6670 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, curr
->end
,
6671 "Location list end address (%s)",
6672 list_head
->ll_symbol
);
6674 size
= size_of_locs (curr
->expr
);
6676 /* Output the block length for this list of location operations. */
6679 dw2_asm_output_data (2, size
, "%s", "Location expression size");
6681 output_loc_sequence (curr
->expr
);
6684 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0,
6685 "Location list terminator begin (%s)",
6686 list_head
->ll_symbol
);
6687 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0,
6688 "Location list terminator end (%s)",
6689 list_head
->ll_symbol
);
6692 /* Output the DIE and its attributes. Called recursively to generate
6693 the definitions of each child DIE. */
6696 output_die (dw_die_ref die
)
6702 /* If someone in another CU might refer to us, set up a symbol for
6703 them to point to. */
6704 if (die
->die_symbol
)
6705 output_die_symbol (die
);
6707 dw2_asm_output_data_uleb128 (die
->die_abbrev
, "(DIE (0x%lx) %s)",
6708 die
->die_offset
, dwarf_tag_name (die
->die_tag
));
6710 for (a
= die
->die_attr
; a
!= NULL
; a
= a
->dw_attr_next
)
6712 const char *name
= dwarf_attr_name (a
->dw_attr
);
6714 switch (AT_class (a
))
6716 case dw_val_class_addr
:
6717 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
, AT_addr (a
), "%s", name
);
6720 case dw_val_class_offset
:
6721 dw2_asm_output_data (DWARF_OFFSET_SIZE
, a
->dw_attr_val
.v
.val_offset
,
6725 case dw_val_class_range_list
:
6727 char *p
= strchr (ranges_section_label
, '\0');
6729 sprintf (p
, "+" HOST_WIDE_INT_PRINT_HEX
,
6730 a
->dw_attr_val
.v
.val_offset
);
6731 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, ranges_section_label
,
6737 case dw_val_class_loc
:
6738 size
= size_of_locs (AT_loc (a
));
6740 /* Output the block length for this list of location operations. */
6741 dw2_asm_output_data (constant_size (size
), size
, "%s", name
);
6743 output_loc_sequence (AT_loc (a
));
6746 case dw_val_class_const
:
6747 /* ??? It would be slightly more efficient to use a scheme like is
6748 used for unsigned constants below, but gdb 4.x does not sign
6749 extend. Gdb 5.x does sign extend. */
6750 dw2_asm_output_data_sleb128 (AT_int (a
), "%s", name
);
6753 case dw_val_class_unsigned_const
:
6754 dw2_asm_output_data (constant_size (AT_unsigned (a
)),
6755 AT_unsigned (a
), "%s", name
);
6758 case dw_val_class_long_long
:
6760 unsigned HOST_WIDE_INT first
, second
;
6762 dw2_asm_output_data (1,
6763 2 * HOST_BITS_PER_LONG
/ HOST_BITS_PER_CHAR
,
6766 if (WORDS_BIG_ENDIAN
)
6768 first
= a
->dw_attr_val
.v
.val_long_long
.hi
;
6769 second
= a
->dw_attr_val
.v
.val_long_long
.low
;
6773 first
= a
->dw_attr_val
.v
.val_long_long
.low
;
6774 second
= a
->dw_attr_val
.v
.val_long_long
.hi
;
6777 dw2_asm_output_data (HOST_BITS_PER_LONG
/ HOST_BITS_PER_CHAR
,
6778 first
, "long long constant");
6779 dw2_asm_output_data (HOST_BITS_PER_LONG
/ HOST_BITS_PER_CHAR
,
6784 case dw_val_class_vec
:
6786 unsigned int elt_size
= a
->dw_attr_val
.v
.val_vec
.elt_size
;
6787 unsigned int len
= a
->dw_attr_val
.v
.val_vec
.length
;
6791 dw2_asm_output_data (1, len
* elt_size
, "%s", name
);
6792 if (elt_size
> sizeof (HOST_WIDE_INT
))
6797 for (i
= 0, p
= a
->dw_attr_val
.v
.val_vec
.array
;
6800 dw2_asm_output_data (elt_size
, extract_int (p
, elt_size
),
6801 "fp or vector constant word %u", i
);
6805 case dw_val_class_flag
:
6806 dw2_asm_output_data (1, AT_flag (a
), "%s", name
);
6809 case dw_val_class_loc_list
:
6811 char *sym
= AT_loc_list (a
)->ll_symbol
;
6815 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, sym
, "%s", name
);
6819 case dw_val_class_die_ref
:
6820 if (AT_ref_external (a
))
6822 char *sym
= AT_ref (a
)->die_symbol
;
6826 dw2_asm_output_offset (DWARF2_ADDR_SIZE
, sym
, "%s", name
);
6828 else if (AT_ref (a
)->die_offset
== 0)
6831 dw2_asm_output_data (DWARF_OFFSET_SIZE
, AT_ref (a
)->die_offset
,
6835 case dw_val_class_fde_ref
:
6839 ASM_GENERATE_INTERNAL_LABEL (l1
, FDE_LABEL
,
6840 a
->dw_attr_val
.v
.val_fde_index
* 2);
6841 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, l1
, "%s", name
);
6845 case dw_val_class_lbl_id
:
6846 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, AT_lbl (a
), "%s", name
);
6849 case dw_val_class_lbl_offset
:
6850 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, AT_lbl (a
), "%s", name
);
6853 case dw_val_class_str
:
6854 if (AT_string_form (a
) == DW_FORM_strp
)
6855 dw2_asm_output_offset (DWARF_OFFSET_SIZE
,
6856 a
->dw_attr_val
.v
.val_str
->label
,
6857 "%s: \"%s\"", name
, AT_string (a
));
6859 dw2_asm_output_nstring (AT_string (a
), -1, "%s", name
);
6867 for (c
= die
->die_child
; c
!= NULL
; c
= c
->die_sib
)
6870 /* Add null byte to terminate sibling list. */
6871 if (die
->die_child
!= NULL
)
6872 dw2_asm_output_data (1, 0, "end of children of DIE 0x%lx",
6876 /* Output the compilation unit that appears at the beginning of the
6877 .debug_info section, and precedes the DIE descriptions. */
6880 output_compilation_unit_header (void)
6882 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
6883 dw2_asm_output_data (4, 0xffffffff,
6884 "Initial length escape value indicating 64-bit DWARF extension");
6885 dw2_asm_output_data (DWARF_OFFSET_SIZE
,
6886 next_die_offset
- DWARF_INITIAL_LENGTH_SIZE
,
6887 "Length of Compilation Unit Info");
6888 dw2_asm_output_data (2, DWARF_VERSION
, "DWARF version number");
6889 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, abbrev_section_label
,
6890 "Offset Into Abbrev. Section");
6891 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Pointer Size (in bytes)");
6894 /* Output the compilation unit DIE and its children. */
6897 output_comp_unit (dw_die_ref die
, int output_if_empty
)
6899 const char *secname
;
6902 /* Unless we are outputting main CU, we may throw away empty ones. */
6903 if (!output_if_empty
&& die
->die_child
== NULL
)
6906 /* Even if there are no children of this DIE, we must output the information
6907 about the compilation unit. Otherwise, on an empty translation unit, we
6908 will generate a present, but empty, .debug_info section. IRIX 6.5 `nm'
6909 will then complain when examining the file. First mark all the DIEs in
6910 this CU so we know which get local refs. */
6913 build_abbrev_table (die
);
6915 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
6916 next_die_offset
= DWARF_COMPILE_UNIT_HEADER_SIZE
;
6917 calc_die_sizes (die
);
6919 oldsym
= die
->die_symbol
;
6922 tmp
= alloca (strlen (oldsym
) + 24);
6924 sprintf (tmp
, ".gnu.linkonce.wi.%s", oldsym
);
6926 die
->die_symbol
= NULL
;
6929 secname
= (const char *) DEBUG_INFO_SECTION
;
6931 /* Output debugging information. */
6932 named_section_flags (secname
, SECTION_DEBUG
);
6933 output_compilation_unit_header ();
6936 /* Leave the marks on the main CU, so we can check them in
6941 die
->die_symbol
= oldsym
;
6945 /* The DWARF2 pubname for a nested thingy looks like "A::f". The
6946 output of lang_hooks.decl_printable_name for C++ looks like
6947 "A::f(int)". Let's drop the argument list, and maybe the scope. */
6950 dwarf2_name (tree decl
, int scope
)
6952 return (*lang_hooks
.decl_printable_name
) (decl
, scope
? 1 : 0);
6955 /* Add a new entry to .debug_pubnames if appropriate. */
6958 add_pubname (tree decl
, dw_die_ref die
)
6962 if (! TREE_PUBLIC (decl
))
6965 if (pubname_table_in_use
== pubname_table_allocated
)
6967 pubname_table_allocated
+= PUBNAME_TABLE_INCREMENT
;
6969 = ggc_realloc (pubname_table
,
6970 (pubname_table_allocated
* sizeof (pubname_entry
)));
6971 memset (pubname_table
+ pubname_table_in_use
, 0,
6972 PUBNAME_TABLE_INCREMENT
* sizeof (pubname_entry
));
6975 p
= &pubname_table
[pubname_table_in_use
++];
6977 p
->name
= xstrdup (dwarf2_name (decl
, 1));
6980 /* Output the public names table used to speed up access to externally
6981 visible names. For now, only generate entries for externally
6982 visible procedures. */
6985 output_pubnames (void)
6988 unsigned long pubnames_length
= size_of_pubnames ();
6990 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
6991 dw2_asm_output_data (4, 0xffffffff,
6992 "Initial length escape value indicating 64-bit DWARF extension");
6993 dw2_asm_output_data (DWARF_OFFSET_SIZE
, pubnames_length
,
6994 "Length of Public Names Info");
6995 dw2_asm_output_data (2, DWARF_VERSION
, "DWARF Version");
6996 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_info_section_label
,
6997 "Offset of Compilation Unit Info");
6998 dw2_asm_output_data (DWARF_OFFSET_SIZE
, next_die_offset
,
6999 "Compilation Unit Length");
7001 for (i
= 0; i
< pubname_table_in_use
; i
++)
7003 pubname_ref pub
= &pubname_table
[i
];
7005 /* We shouldn't see pubnames for DIEs outside of the main CU. */
7006 if (pub
->die
->die_mark
== 0)
7009 dw2_asm_output_data (DWARF_OFFSET_SIZE
, pub
->die
->die_offset
,
7012 dw2_asm_output_nstring (pub
->name
, -1, "external name");
7015 dw2_asm_output_data (DWARF_OFFSET_SIZE
, 0, NULL
);
7018 /* Add a new entry to .debug_aranges if appropriate. */
7021 add_arange (tree decl
, dw_die_ref die
)
7023 if (! DECL_SECTION_NAME (decl
))
7026 if (arange_table_in_use
== arange_table_allocated
)
7028 arange_table_allocated
+= ARANGE_TABLE_INCREMENT
;
7029 arange_table
= ggc_realloc (arange_table
,
7030 (arange_table_allocated
7031 * sizeof (dw_die_ref
)));
7032 memset (arange_table
+ arange_table_in_use
, 0,
7033 ARANGE_TABLE_INCREMENT
* sizeof (dw_die_ref
));
7036 arange_table
[arange_table_in_use
++] = die
;
7039 /* Output the information that goes into the .debug_aranges table.
7040 Namely, define the beginning and ending address range of the
7041 text section generated for this compilation unit. */
7044 output_aranges (void)
7047 unsigned long aranges_length
= size_of_aranges ();
7049 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
7050 dw2_asm_output_data (4, 0xffffffff,
7051 "Initial length escape value indicating 64-bit DWARF extension");
7052 dw2_asm_output_data (DWARF_OFFSET_SIZE
, aranges_length
,
7053 "Length of Address Ranges Info");
7054 dw2_asm_output_data (2, DWARF_VERSION
, "DWARF Version");
7055 dw2_asm_output_offset (DWARF_OFFSET_SIZE
, debug_info_section_label
,
7056 "Offset of Compilation Unit Info");
7057 dw2_asm_output_data (1, DWARF2_ADDR_SIZE
, "Size of Address");
7058 dw2_asm_output_data (1, 0, "Size of Segment Descriptor");
7060 /* We need to align to twice the pointer size here. */
7061 if (DWARF_ARANGES_PAD_SIZE
)
7063 /* Pad using a 2 byte words so that padding is correct for any
7065 dw2_asm_output_data (2, 0, "Pad to %d byte boundary",
7066 2 * DWARF2_ADDR_SIZE
);
7067 for (i
= 2; i
< (unsigned) DWARF_ARANGES_PAD_SIZE
; i
+= 2)
7068 dw2_asm_output_data (2, 0, NULL
);
7071 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, text_section_label
, "Address");
7072 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, text_end_label
,
7073 text_section_label
, "Length");
7075 for (i
= 0; i
< arange_table_in_use
; i
++)
7077 dw_die_ref die
= arange_table
[i
];
7079 /* We shouldn't see aranges for DIEs outside of the main CU. */
7080 if (die
->die_mark
== 0)
7083 if (die
->die_tag
== DW_TAG_subprogram
)
7085 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, get_AT_low_pc (die
),
7087 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, get_AT_hi_pc (die
),
7088 get_AT_low_pc (die
), "Length");
7092 /* A static variable; extract the symbol from DW_AT_location.
7093 Note that this code isn't currently hit, as we only emit
7094 aranges for functions (jason 9/23/99). */
7095 dw_attr_ref a
= get_AT (die
, DW_AT_location
);
7096 dw_loc_descr_ref loc
;
7098 if (! a
|| AT_class (a
) != dw_val_class_loc
)
7102 if (loc
->dw_loc_opc
!= DW_OP_addr
)
7105 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE
,
7106 loc
->dw_loc_oprnd1
.v
.val_addr
, "Address");
7107 dw2_asm_output_data (DWARF2_ADDR_SIZE
,
7108 get_AT_unsigned (die
, DW_AT_byte_size
),
7113 /* Output the terminator words. */
7114 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
7115 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
7118 /* Add a new entry to .debug_ranges. Return the offset at which it
7122 add_ranges (tree block
)
7124 unsigned int in_use
= ranges_table_in_use
;
7126 if (in_use
== ranges_table_allocated
)
7128 ranges_table_allocated
+= RANGES_TABLE_INCREMENT
;
7130 = ggc_realloc (ranges_table
, (ranges_table_allocated
7131 * sizeof (struct dw_ranges_struct
)));
7132 memset (ranges_table
+ ranges_table_in_use
, 0,
7133 RANGES_TABLE_INCREMENT
* sizeof (struct dw_ranges_struct
));
7136 ranges_table
[in_use
].block_num
= (block
? BLOCK_NUMBER (block
) : 0);
7137 ranges_table_in_use
= in_use
+ 1;
7139 return in_use
* 2 * DWARF2_ADDR_SIZE
;
7143 output_ranges (void)
7146 static const char *const start_fmt
= "Offset 0x%x";
7147 const char *fmt
= start_fmt
;
7149 for (i
= 0; i
< ranges_table_in_use
; i
++)
7151 int block_num
= ranges_table
[i
].block_num
;
7155 char blabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
7156 char elabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
7158 ASM_GENERATE_INTERNAL_LABEL (blabel
, BLOCK_BEGIN_LABEL
, block_num
);
7159 ASM_GENERATE_INTERNAL_LABEL (elabel
, BLOCK_END_LABEL
, block_num
);
7161 /* If all code is in the text section, then the compilation
7162 unit base address defaults to DW_AT_low_pc, which is the
7163 base of the text section. */
7164 if (separate_line_info_table_in_use
== 0)
7166 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, blabel
,
7168 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
7169 dw2_asm_output_delta (DWARF2_ADDR_SIZE
, elabel
,
7170 text_section_label
, NULL
);
7173 /* Otherwise, we add a DW_AT_entry_pc attribute to force the
7174 compilation unit base address to zero, which allows us to
7175 use absolute addresses, and not worry about whether the
7176 target supports cross-section arithmetic. */
7179 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, blabel
,
7180 fmt
, i
* 2 * DWARF2_ADDR_SIZE
);
7181 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, elabel
, NULL
);
7188 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
7189 dw2_asm_output_data (DWARF2_ADDR_SIZE
, 0, NULL
);
7195 /* Data structure containing information about input files. */
7198 char *path
; /* Complete file name. */
7199 char *fname
; /* File name part. */
7200 int length
; /* Length of entire string. */
7201 int file_idx
; /* Index in input file table. */
7202 int dir_idx
; /* Index in directory table. */
7205 /* Data structure containing information about directories with source
7209 char *path
; /* Path including directory name. */
7210 int length
; /* Path length. */
7211 int prefix
; /* Index of directory entry which is a prefix. */
7212 int count
; /* Number of files in this directory. */
7213 int dir_idx
; /* Index of directory used as base. */
7214 int used
; /* Used in the end? */
7217 /* Callback function for file_info comparison. We sort by looking at
7218 the directories in the path. */
7221 file_info_cmp (const void *p1
, const void *p2
)
7223 const struct file_info
*s1
= p1
;
7224 const struct file_info
*s2
= p2
;
7228 /* Take care of file names without directories. We need to make sure that
7229 we return consistent values to qsort since some will get confused if
7230 we return the same value when identical operands are passed in opposite
7231 orders. So if neither has a directory, return 0 and otherwise return
7232 1 or -1 depending on which one has the directory. */
7233 if ((s1
->path
== s1
->fname
|| s2
->path
== s2
->fname
))
7234 return (s2
->path
== s2
->fname
) - (s1
->path
== s1
->fname
);
7236 cp1
= (unsigned char *) s1
->path
;
7237 cp2
= (unsigned char *) s2
->path
;
7243 /* Reached the end of the first path? If so, handle like above. */
7244 if ((cp1
== (unsigned char *) s1
->fname
)
7245 || (cp2
== (unsigned char *) s2
->fname
))
7246 return ((cp2
== (unsigned char *) s2
->fname
)
7247 - (cp1
== (unsigned char *) s1
->fname
));
7249 /* Character of current path component the same? */
7250 else if (*cp1
!= *cp2
)
7255 /* Output the directory table and the file name table. We try to minimize
7256 the total amount of memory needed. A heuristic is used to avoid large
7257 slowdowns with many input files. */
7260 output_file_names (void)
7262 struct file_info
*files
;
7263 struct dir_info
*dirs
;
7272 /* Handle the case where file_table is empty. */
7273 if (VARRAY_ACTIVE_SIZE (file_table
) <= 1)
7275 dw2_asm_output_data (1, 0, "End directory table");
7276 dw2_asm_output_data (1, 0, "End file name table");
7280 /* Allocate the various arrays we need. */
7281 files
= alloca (VARRAY_ACTIVE_SIZE (file_table
) * sizeof (struct file_info
));
7282 dirs
= alloca (VARRAY_ACTIVE_SIZE (file_table
) * sizeof (struct dir_info
));
7284 /* Sort the file names. */
7285 for (i
= 1; i
< VARRAY_ACTIVE_SIZE (file_table
); i
++)
7289 /* Skip all leading "./". */
7290 f
= VARRAY_CHAR_PTR (file_table
, i
);
7291 while (f
[0] == '.' && f
[1] == '/')
7294 /* Create a new array entry. */
7296 files
[i
].length
= strlen (f
);
7297 files
[i
].file_idx
= i
;
7299 /* Search for the file name part. */
7300 f
= strrchr (f
, '/');
7301 files
[i
].fname
= f
== NULL
? files
[i
].path
: f
+ 1;
7304 qsort (files
+ 1, VARRAY_ACTIVE_SIZE (file_table
) - 1,
7305 sizeof (files
[0]), file_info_cmp
);
7307 /* Find all the different directories used. */
7308 dirs
[0].path
= files
[1].path
;
7309 dirs
[0].length
= files
[1].fname
- files
[1].path
;
7310 dirs
[0].prefix
= -1;
7312 dirs
[0].dir_idx
= 0;
7314 files
[1].dir_idx
= 0;
7317 for (i
= 2; i
< VARRAY_ACTIVE_SIZE (file_table
); i
++)
7318 if (files
[i
].fname
- files
[i
].path
== dirs
[ndirs
- 1].length
7319 && memcmp (dirs
[ndirs
- 1].path
, files
[i
].path
,
7320 dirs
[ndirs
- 1].length
) == 0)
7322 /* Same directory as last entry. */
7323 files
[i
].dir_idx
= ndirs
- 1;
7324 ++dirs
[ndirs
- 1].count
;
7330 /* This is a new directory. */
7331 dirs
[ndirs
].path
= files
[i
].path
;
7332 dirs
[ndirs
].length
= files
[i
].fname
- files
[i
].path
;
7333 dirs
[ndirs
].count
= 1;
7334 dirs
[ndirs
].dir_idx
= ndirs
;
7335 dirs
[ndirs
].used
= 0;
7336 files
[i
].dir_idx
= ndirs
;
7338 /* Search for a prefix. */
7339 dirs
[ndirs
].prefix
= -1;
7340 for (j
= 0; j
< ndirs
; j
++)
7341 if (dirs
[j
].length
< dirs
[ndirs
].length
7342 && dirs
[j
].length
> 1
7343 && (dirs
[ndirs
].prefix
== -1
7344 || dirs
[j
].length
> dirs
[dirs
[ndirs
].prefix
].length
)
7345 && memcmp (dirs
[j
].path
, dirs
[ndirs
].path
, dirs
[j
].length
) == 0)
7346 dirs
[ndirs
].prefix
= j
;
7351 /* Now to the actual work. We have to find a subset of the directories which
7352 allow expressing the file name using references to the directory table
7353 with the least amount of characters. We do not do an exhaustive search
7354 where we would have to check out every combination of every single
7355 possible prefix. Instead we use a heuristic which provides nearly optimal
7356 results in most cases and never is much off. */
7357 saved
= alloca (ndirs
* sizeof (int));
7358 savehere
= alloca (ndirs
* sizeof (int));
7360 memset (saved
, '\0', ndirs
* sizeof (saved
[0]));
7361 for (i
= 0; i
< ndirs
; i
++)
7366 /* We can always save some space for the current directory. But this
7367 does not mean it will be enough to justify adding the directory. */
7368 savehere
[i
] = dirs
[i
].length
;
7369 total
= (savehere
[i
] - saved
[i
]) * dirs
[i
].count
;
7371 for (j
= i
+ 1; j
< ndirs
; j
++)
7374 if (saved
[j
] < dirs
[i
].length
)
7376 /* Determine whether the dirs[i] path is a prefix of the
7381 while (k
!= -1 && k
!= (int) i
)
7386 /* Yes it is. We can possibly safe some memory but
7387 writing the filenames in dirs[j] relative to
7389 savehere
[j
] = dirs
[i
].length
;
7390 total
+= (savehere
[j
] - saved
[j
]) * dirs
[j
].count
;
7395 /* Check whether we can safe enough to justify adding the dirs[i]
7397 if (total
> dirs
[i
].length
+ 1)
7399 /* It's worthwhile adding. */
7400 for (j
= i
; j
< ndirs
; j
++)
7401 if (savehere
[j
] > 0)
7403 /* Remember how much we saved for this directory so far. */
7404 saved
[j
] = savehere
[j
];
7406 /* Remember the prefix directory. */
7407 dirs
[j
].dir_idx
= i
;
7412 /* We have to emit them in the order they appear in the file_table array
7413 since the index is used in the debug info generation. To do this
7414 efficiently we generate a back-mapping of the indices first. */
7415 backmap
= alloca (VARRAY_ACTIVE_SIZE (file_table
) * sizeof (int));
7416 for (i
= 1; i
< VARRAY_ACTIVE_SIZE (file_table
); i
++)
7418 backmap
[files
[i
].file_idx
] = i
;
7420 /* Mark this directory as used. */
7421 dirs
[dirs
[files
[i
].dir_idx
].dir_idx
].used
= 1;
7424 /* That was it. We are ready to emit the information. First emit the
7425 directory name table. We have to make sure the first actually emitted
7426 directory name has index one; zero is reserved for the current working
7427 directory. Make sure we do not confuse these indices with the one for the
7428 constructed table (even though most of the time they are identical). */
7430 idx_offset
= dirs
[0].length
> 0 ? 1 : 0;
7431 for (i
= 1 - idx_offset
; i
< ndirs
; i
++)
7432 if (dirs
[i
].used
!= 0)
7434 dirs
[i
].used
= idx
++;
7435 dw2_asm_output_nstring (dirs
[i
].path
, dirs
[i
].length
- 1,
7436 "Directory Entry: 0x%x", dirs
[i
].used
);
7439 dw2_asm_output_data (1, 0, "End directory table");
7441 /* Correct the index for the current working directory entry if it
7443 if (idx_offset
== 0)
7446 /* Now write all the file names. */
7447 for (i
= 1; i
< VARRAY_ACTIVE_SIZE (file_table
); i
++)
7449 int file_idx
= backmap
[i
];
7450 int dir_idx
= dirs
[files
[file_idx
].dir_idx
].dir_idx
;
7452 dw2_asm_output_nstring (files
[file_idx
].path
+ dirs
[dir_idx
].length
, -1,
7453 "File Entry: 0x%lx", (unsigned long) i
);
7455 /* Include directory index. */
7456 dw2_asm_output_data_uleb128 (dirs
[dir_idx
].used
, NULL
);
7458 /* Modification time. */
7459 dw2_asm_output_data_uleb128 (0, NULL
);
7461 /* File length in bytes. */
7462 dw2_asm_output_data_uleb128 (0, NULL
);
7465 dw2_asm_output_data (1, 0, "End file name table");
7469 /* Output the source line number correspondence information. This
7470 information goes into the .debug_line section. */
7473 output_line_info (void)
7475 char l1
[20], l2
[20], p1
[20], p2
[20];
7476 char line_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
7477 char prev_line_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
7480 unsigned long lt_index
;
7481 unsigned long current_line
;
7484 unsigned long current_file
;
7485 unsigned long function
;
7487 ASM_GENERATE_INTERNAL_LABEL (l1
, LINE_NUMBER_BEGIN_LABEL
, 0);
7488 ASM_GENERATE_INTERNAL_LABEL (l2
, LINE_NUMBER_END_LABEL
, 0);
7489 ASM_GENERATE_INTERNAL_LABEL (p1
, LN_PROLOG_AS_LABEL
, 0);
7490 ASM_GENERATE_INTERNAL_LABEL (p2
, LN_PROLOG_END_LABEL
, 0);
7492 if (DWARF_INITIAL_LENGTH_SIZE
- DWARF_OFFSET_SIZE
== 4)
7493 dw2_asm_output_data (4, 0xffffffff,
7494 "Initial length escape value indicating 64-bit DWARF extension");
7495 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, l2
, l1
,
7496 "Length of Source Line Info");
7497 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
7499 dw2_asm_output_data (2, DWARF_VERSION
, "DWARF Version");
7500 dw2_asm_output_delta (DWARF_OFFSET_SIZE
, p2
, p1
, "Prolog Length");
7501 ASM_OUTPUT_LABEL (asm_out_file
, p1
);
7503 /* Define the architecture-dependent minimum instruction length (in
7504 bytes). In this implementation of DWARF, this field is used for
7505 information purposes only. Since GCC generates assembly language,
7506 we have no a priori knowledge of how many instruction bytes are
7507 generated for each source line, and therefore can use only the
7508 DW_LNE_set_address and DW_LNS_fixed_advance_pc line information
7509 commands. Accordingly, we fix this as `1', which is "correct
7510 enough" for all architectures, and don't let the target override. */
7511 dw2_asm_output_data (1, 1,
7512 "Minimum Instruction Length");
7514 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START
,
7515 "Default is_stmt_start flag");
7516 dw2_asm_output_data (1, DWARF_LINE_BASE
,
7517 "Line Base Value (Special Opcodes)");
7518 dw2_asm_output_data (1, DWARF_LINE_RANGE
,
7519 "Line Range Value (Special Opcodes)");
7520 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE
,
7521 "Special Opcode Base");
7523 for (opc
= 1; opc
< DWARF_LINE_OPCODE_BASE
; opc
++)
7527 case DW_LNS_advance_pc
:
7528 case DW_LNS_advance_line
:
7529 case DW_LNS_set_file
:
7530 case DW_LNS_set_column
:
7531 case DW_LNS_fixed_advance_pc
:
7539 dw2_asm_output_data (1, n_op_args
, "opcode: 0x%x has %d args",
7543 /* Write out the information about the files we use. */
7544 output_file_names ();
7545 ASM_OUTPUT_LABEL (asm_out_file
, p2
);
7547 /* We used to set the address register to the first location in the text
7548 section here, but that didn't accomplish anything since we already
7549 have a line note for the opening brace of the first function. */
7551 /* Generate the line number to PC correspondence table, encoded as
7552 a series of state machine operations. */
7555 strcpy (prev_line_label
, text_section_label
);
7556 for (lt_index
= 1; lt_index
< line_info_table_in_use
; ++lt_index
)
7558 dw_line_info_ref line_info
= &line_info_table
[lt_index
];
7561 /* Disable this optimization for now; GDB wants to see two line notes
7562 at the beginning of a function so it can find the end of the
7565 /* Don't emit anything for redundant notes. Just updating the
7566 address doesn't accomplish anything, because we already assume
7567 that anything after the last address is this line. */
7568 if (line_info
->dw_line_num
== current_line
7569 && line_info
->dw_file_num
== current_file
)
7573 /* Emit debug info for the address of the current line.
7575 Unfortunately, we have little choice here currently, and must always
7576 use the most general form. GCC does not know the address delta
7577 itself, so we can't use DW_LNS_advance_pc. Many ports do have length
7578 attributes which will give an upper bound on the address range. We
7579 could perhaps use length attributes to determine when it is safe to
7580 use DW_LNS_fixed_advance_pc. */
7582 ASM_GENERATE_INTERNAL_LABEL (line_label
, LINE_CODE_LABEL
, lt_index
);
7585 /* This can handle deltas up to 0xffff. This takes 3 bytes. */
7586 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc
,
7587 "DW_LNS_fixed_advance_pc");
7588 dw2_asm_output_delta (2, line_label
, prev_line_label
, NULL
);
7592 /* This can handle any delta. This takes
7593 4+DWARF2_ADDR_SIZE bytes. */
7594 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
7595 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE
, NULL
);
7596 dw2_asm_output_data (1, DW_LNE_set_address
, NULL
);
7597 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, line_label
, NULL
);
7600 strcpy (prev_line_label
, line_label
);
7602 /* Emit debug info for the source file of the current line, if
7603 different from the previous line. */
7604 if (line_info
->dw_file_num
!= current_file
)
7606 current_file
= line_info
->dw_file_num
;
7607 dw2_asm_output_data (1, DW_LNS_set_file
, "DW_LNS_set_file");
7608 dw2_asm_output_data_uleb128 (current_file
, "(\"%s\")",
7609 VARRAY_CHAR_PTR (file_table
,
7613 /* Emit debug info for the current line number, choosing the encoding
7614 that uses the least amount of space. */
7615 if (line_info
->dw_line_num
!= current_line
)
7617 line_offset
= line_info
->dw_line_num
- current_line
;
7618 line_delta
= line_offset
- DWARF_LINE_BASE
;
7619 current_line
= line_info
->dw_line_num
;
7620 if (line_delta
>= 0 && line_delta
< (DWARF_LINE_RANGE
- 1))
7621 /* This can handle deltas from -10 to 234, using the current
7622 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE. This
7624 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE
+ line_delta
,
7625 "line %lu", current_line
);
7628 /* This can handle any delta. This takes at least 4 bytes,
7629 depending on the value being encoded. */
7630 dw2_asm_output_data (1, DW_LNS_advance_line
,
7631 "advance to line %lu", current_line
);
7632 dw2_asm_output_data_sleb128 (line_offset
, NULL
);
7633 dw2_asm_output_data (1, DW_LNS_copy
, "DW_LNS_copy");
7637 /* We still need to start a new row, so output a copy insn. */
7638 dw2_asm_output_data (1, DW_LNS_copy
, "DW_LNS_copy");
7641 /* Emit debug info for the address of the end of the function. */
7644 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc
,
7645 "DW_LNS_fixed_advance_pc");
7646 dw2_asm_output_delta (2, text_end_label
, prev_line_label
, NULL
);
7650 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
7651 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE
, NULL
);
7652 dw2_asm_output_data (1, DW_LNE_set_address
, NULL
);
7653 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, text_end_label
, NULL
);
7656 dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
7657 dw2_asm_output_data_uleb128 (1, NULL
);
7658 dw2_asm_output_data (1, DW_LNE_end_sequence
, NULL
);
7663 for (lt_index
= 0; lt_index
< separate_line_info_table_in_use
;)
7665 dw_separate_line_info_ref line_info
7666 = &separate_line_info_table
[lt_index
];
7669 /* Don't emit anything for redundant notes. */
7670 if (line_info
->dw_line_num
== current_line
7671 && line_info
->dw_file_num
== current_file
7672 && line_info
->function
== function
)
7676 /* Emit debug info for the address of the current line. If this is
7677 a new function, or the first line of a function, then we need
7678 to handle it differently. */
7679 ASM_GENERATE_INTERNAL_LABEL (line_label
, SEPARATE_LINE_CODE_LABEL
,
7681 if (function
!= line_info
->function
)
7683 function
= line_info
->function
;
7685 /* Set the address register to the first line in the function. */
7686 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
7687 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE
, NULL
);
7688 dw2_asm_output_data (1, DW_LNE_set_address
, NULL
);
7689 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, line_label
, NULL
);
7693 /* ??? See the DW_LNS_advance_pc comment above. */
7696 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc
,
7697 "DW_LNS_fixed_advance_pc");
7698 dw2_asm_output_delta (2, line_label
, prev_line_label
, NULL
);
7702 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
7703 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE
, NULL
);
7704 dw2_asm_output_data (1, DW_LNE_set_address
, NULL
);
7705 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, line_label
, NULL
);
7709 strcpy (prev_line_label
, line_label
);
7711 /* Emit debug info for the source file of the current line, if
7712 different from the previous line. */
7713 if (line_info
->dw_file_num
!= current_file
)
7715 current_file
= line_info
->dw_file_num
;
7716 dw2_asm_output_data (1, DW_LNS_set_file
, "DW_LNS_set_file");
7717 dw2_asm_output_data_uleb128 (current_file
, "(\"%s\")",
7718 VARRAY_CHAR_PTR (file_table
,
7722 /* Emit debug info for the current line number, choosing the encoding
7723 that uses the least amount of space. */
7724 if (line_info
->dw_line_num
!= current_line
)
7726 line_offset
= line_info
->dw_line_num
- current_line
;
7727 line_delta
= line_offset
- DWARF_LINE_BASE
;
7728 current_line
= line_info
->dw_line_num
;
7729 if (line_delta
>= 0 && line_delta
< (DWARF_LINE_RANGE
- 1))
7730 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE
+ line_delta
,
7731 "line %lu", current_line
);
7734 dw2_asm_output_data (1, DW_LNS_advance_line
,
7735 "advance to line %lu", current_line
);
7736 dw2_asm_output_data_sleb128 (line_offset
, NULL
);
7737 dw2_asm_output_data (1, DW_LNS_copy
, "DW_LNS_copy");
7741 dw2_asm_output_data (1, DW_LNS_copy
, "DW_LNS_copy");
7749 /* If we're done with a function, end its sequence. */
7750 if (lt_index
== separate_line_info_table_in_use
7751 || separate_line_info_table
[lt_index
].function
!= function
)
7756 /* Emit debug info for the address of the end of the function. */
7757 ASM_GENERATE_INTERNAL_LABEL (line_label
, FUNC_END_LABEL
, function
);
7760 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc
,
7761 "DW_LNS_fixed_advance_pc");
7762 dw2_asm_output_delta (2, line_label
, prev_line_label
, NULL
);
7766 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
7767 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE
, NULL
);
7768 dw2_asm_output_data (1, DW_LNE_set_address
, NULL
);
7769 dw2_asm_output_addr (DWARF2_ADDR_SIZE
, line_label
, NULL
);
7772 /* Output the marker for the end of this sequence. */
7773 dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
7774 dw2_asm_output_data_uleb128 (1, NULL
);
7775 dw2_asm_output_data (1, DW_LNE_end_sequence
, NULL
);
7779 /* Output the marker for the end of the line number info. */
7780 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
7783 /* Given a pointer to a tree node for some base type, return a pointer to
7784 a DIE that describes the given type.
7786 This routine must only be called for GCC type nodes that correspond to
7787 Dwarf base (fundamental) types. */
7790 base_type_die (tree type
)
7792 dw_die_ref base_type_result
;
7793 const char *type_name
;
7794 enum dwarf_type encoding
;
7795 tree name
= TYPE_NAME (type
);
7797 if (TREE_CODE (type
) == ERROR_MARK
|| TREE_CODE (type
) == VOID_TYPE
)
7802 if (TREE_CODE (name
) == TYPE_DECL
)
7803 name
= DECL_NAME (name
);
7805 type_name
= IDENTIFIER_POINTER (name
);
7808 type_name
= "__unknown__";
7810 switch (TREE_CODE (type
))
7813 /* Carefully distinguish the C character types, without messing
7814 up if the language is not C. Note that we check only for the names
7815 that contain spaces; other names might occur by coincidence in other
7817 if (! (TYPE_PRECISION (type
) == CHAR_TYPE_SIZE
7818 && (type
== char_type_node
7819 || ! strcmp (type_name
, "signed char")
7820 || ! strcmp (type_name
, "unsigned char"))))
7822 if (TREE_UNSIGNED (type
))
7823 encoding
= DW_ATE_unsigned
;
7825 encoding
= DW_ATE_signed
;
7828 /* else fall through. */
7831 /* GNU Pascal/Ada CHAR type. Not used in C. */
7832 if (TREE_UNSIGNED (type
))
7833 encoding
= DW_ATE_unsigned_char
;
7835 encoding
= DW_ATE_signed_char
;
7839 encoding
= DW_ATE_float
;
7842 /* Dwarf2 doesn't know anything about complex ints, so use
7843 a user defined type for it. */
7845 if (TREE_CODE (TREE_TYPE (type
)) == REAL_TYPE
)
7846 encoding
= DW_ATE_complex_float
;
7848 encoding
= DW_ATE_lo_user
;
7852 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */
7853 encoding
= DW_ATE_boolean
;
7857 /* No other TREE_CODEs are Dwarf fundamental types. */
7861 base_type_result
= new_die (DW_TAG_base_type
, comp_unit_die
, type
);
7862 if (demangle_name_func
)
7863 type_name
= (*demangle_name_func
) (type_name
);
7865 add_AT_string (base_type_result
, DW_AT_name
, type_name
);
7866 add_AT_unsigned (base_type_result
, DW_AT_byte_size
,
7867 int_size_in_bytes (type
));
7868 add_AT_unsigned (base_type_result
, DW_AT_encoding
, encoding
);
7870 return base_type_result
;
7873 /* Given a pointer to an arbitrary ..._TYPE tree node, return a pointer to
7874 the Dwarf "root" type for the given input type. The Dwarf "root" type of
7875 a given type is generally the same as the given type, except that if the
7876 given type is a pointer or reference type, then the root type of the given
7877 type is the root type of the "basis" type for the pointer or reference
7878 type. (This definition of the "root" type is recursive.) Also, the root
7879 type of a `const' qualified type or a `volatile' qualified type is the
7880 root type of the given type without the qualifiers. */
7883 root_type (tree type
)
7885 if (TREE_CODE (type
) == ERROR_MARK
)
7886 return error_mark_node
;
7888 switch (TREE_CODE (type
))
7891 return error_mark_node
;
7894 case REFERENCE_TYPE
:
7895 return type_main_variant (root_type (TREE_TYPE (type
)));
7898 return type_main_variant (type
);
7902 /* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the
7903 given input type is a Dwarf "fundamental" type. Otherwise return null. */
7906 is_base_type (tree type
)
7908 switch (TREE_CODE (type
))
7923 case QUAL_UNION_TYPE
:
7928 case REFERENCE_TYPE
:
7942 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
7943 node, return the size in bits for the type if it is a constant, or else
7944 return the alignment for the type if the type's size is not constant, or
7945 else return BITS_PER_WORD if the type actually turns out to be an
7948 static inline unsigned HOST_WIDE_INT
7949 simple_type_size_in_bits (tree type
)
7951 if (TREE_CODE (type
) == ERROR_MARK
)
7952 return BITS_PER_WORD
;
7953 else if (TYPE_SIZE (type
) == NULL_TREE
)
7955 else if (host_integerp (TYPE_SIZE (type
), 1))
7956 return tree_low_cst (TYPE_SIZE (type
), 1);
7958 return TYPE_ALIGN (type
);
7961 /* Return true if the debug information for the given type should be
7962 emitted as a subrange type. */
7965 is_subrange_type (tree type
)
7967 tree subtype
= TREE_TYPE (type
);
7969 if (TREE_CODE (type
) == INTEGER_TYPE
7970 && subtype
!= NULL_TREE
)
7972 if (TREE_CODE (subtype
) == INTEGER_TYPE
)
7974 if (TREE_CODE (subtype
) == ENUMERAL_TYPE
)
7980 /* Given a pointer to a tree node for a subrange type, return a pointer
7981 to a DIE that describes the given type. */
7984 subrange_type_die (tree type
, dw_die_ref context_die
)
7986 dw_die_ref subtype_die
;
7987 dw_die_ref subrange_die
;
7988 tree name
= TYPE_NAME (type
);
7989 const HOST_WIDE_INT size_in_bytes
= int_size_in_bytes (type
);
7991 if (context_die
== NULL
)
7992 context_die
= comp_unit_die
;
7994 if (TREE_CODE (TREE_TYPE (type
)) == ENUMERAL_TYPE
)
7995 subtype_die
= gen_enumeration_type_die (TREE_TYPE (type
), context_die
);
7997 subtype_die
= base_type_die (TREE_TYPE (type
));
7999 subrange_die
= new_die (DW_TAG_subrange_type
, context_die
, type
);
8003 if (TREE_CODE (name
) == TYPE_DECL
)
8004 name
= DECL_NAME (name
);
8005 add_name_attribute (subrange_die
, IDENTIFIER_POINTER (name
));
8008 if (int_size_in_bytes (TREE_TYPE (type
)) != size_in_bytes
)
8010 /* The size of the subrange type and its base type do not match,
8011 so we need to generate a size attribute for the subrange type. */
8012 add_AT_unsigned (subrange_die
, DW_AT_byte_size
, size_in_bytes
);
8015 if (TYPE_MIN_VALUE (type
) != NULL
)
8016 add_bound_info (subrange_die
, DW_AT_lower_bound
,
8017 TYPE_MIN_VALUE (type
));
8018 if (TYPE_MAX_VALUE (type
) != NULL
)
8019 add_bound_info (subrange_die
, DW_AT_upper_bound
,
8020 TYPE_MAX_VALUE (type
));
8021 add_AT_die_ref (subrange_die
, DW_AT_type
, subtype_die
);
8023 return subrange_die
;
8026 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
8027 entry that chains various modifiers in front of the given type. */
8030 modified_type_die (tree type
, int is_const_type
, int is_volatile_type
,
8031 dw_die_ref context_die
)
8033 enum tree_code code
= TREE_CODE (type
);
8034 dw_die_ref mod_type_die
= NULL
;
8035 dw_die_ref sub_die
= NULL
;
8036 tree item_type
= NULL
;
8038 if (code
!= ERROR_MARK
)
8040 tree qualified_type
;
8042 /* See if we already have the appropriately qualified variant of
8045 = get_qualified_type (type
,
8046 ((is_const_type
? TYPE_QUAL_CONST
: 0)
8048 ? TYPE_QUAL_VOLATILE
: 0)));
8050 /* If we do, then we can just use its DIE, if it exists. */
8053 mod_type_die
= lookup_type_die (qualified_type
);
8055 return mod_type_die
;
8058 /* Handle C typedef types. */
8059 if (qualified_type
&& TYPE_NAME (qualified_type
)
8060 && TREE_CODE (TYPE_NAME (qualified_type
)) == TYPE_DECL
8061 && DECL_ORIGINAL_TYPE (TYPE_NAME (qualified_type
)))
8063 tree type_name
= TYPE_NAME (qualified_type
);
8064 tree dtype
= TREE_TYPE (type_name
);
8066 if (qualified_type
== dtype
)
8068 /* For a named type, use the typedef. */
8069 gen_type_die (qualified_type
, context_die
);
8070 mod_type_die
= lookup_type_die (qualified_type
);
8072 else if (is_const_type
< TYPE_READONLY (dtype
)
8073 || is_volatile_type
< TYPE_VOLATILE (dtype
))
8074 /* cv-unqualified version of named type. Just use the unnamed
8075 type to which it refers. */
8077 = modified_type_die (DECL_ORIGINAL_TYPE (type_name
),
8078 is_const_type
, is_volatile_type
,
8081 /* Else cv-qualified version of named type; fall through. */
8087 else if (is_const_type
)
8089 mod_type_die
= new_die (DW_TAG_const_type
, comp_unit_die
, type
);
8090 sub_die
= modified_type_die (type
, 0, is_volatile_type
, context_die
);
8092 else if (is_volatile_type
)
8094 mod_type_die
= new_die (DW_TAG_volatile_type
, comp_unit_die
, type
);
8095 sub_die
= modified_type_die (type
, 0, 0, context_die
);
8097 else if (code
== POINTER_TYPE
)
8099 mod_type_die
= new_die (DW_TAG_pointer_type
, comp_unit_die
, type
);
8100 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
,
8101 simple_type_size_in_bits (type
) / BITS_PER_UNIT
);
8103 add_AT_unsigned (mod_type_die
, DW_AT_address_class
, 0);
8105 item_type
= TREE_TYPE (type
);
8107 else if (code
== REFERENCE_TYPE
)
8109 mod_type_die
= new_die (DW_TAG_reference_type
, comp_unit_die
, type
);
8110 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
,
8111 simple_type_size_in_bits (type
) / BITS_PER_UNIT
);
8113 add_AT_unsigned (mod_type_die
, DW_AT_address_class
, 0);
8115 item_type
= TREE_TYPE (type
);
8117 else if (is_subrange_type (type
))
8118 mod_type_die
= subrange_type_die (type
, context_die
);
8119 else if (is_base_type (type
))
8120 mod_type_die
= base_type_die (type
);
8123 gen_type_die (type
, context_die
);
8125 /* We have to get the type_main_variant here (and pass that to the
8126 `lookup_type_die' routine) because the ..._TYPE node we have
8127 might simply be a *copy* of some original type node (where the
8128 copy was created to help us keep track of typedef names) and
8129 that copy might have a different TYPE_UID from the original
8131 if (TREE_CODE (type
) != VECTOR_TYPE
)
8132 mod_type_die
= lookup_type_die (type_main_variant (type
));
8134 /* Vectors have the debugging information in the type,
8135 not the main variant. */
8136 mod_type_die
= lookup_type_die (type
);
8137 if (mod_type_die
== NULL
)
8141 /* We want to equate the qualified type to the die below. */
8142 type
= qualified_type
;
8146 equate_type_number_to_die (type
, mod_type_die
);
8148 /* We must do this after the equate_type_number_to_die call, in case
8149 this is a recursive type. This ensures that the modified_type_die
8150 recursion will terminate even if the type is recursive. Recursive
8151 types are possible in Ada. */
8152 sub_die
= modified_type_die (item_type
,
8153 TYPE_READONLY (item_type
),
8154 TYPE_VOLATILE (item_type
),
8157 if (sub_die
!= NULL
)
8158 add_AT_die_ref (mod_type_die
, DW_AT_type
, sub_die
);
8160 return mod_type_die
;
8163 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
8164 an enumerated type. */
8167 type_is_enum (tree type
)
8169 return TREE_CODE (type
) == ENUMERAL_TYPE
;
8172 /* Return the register number described by a given RTL node. */
8175 reg_number (rtx rtl
)
8177 unsigned regno
= REGNO (rtl
);
8179 if (regno
>= FIRST_PSEUDO_REGISTER
)
8182 return DBX_REGISTER_NUMBER (regno
);
8185 /* Return a location descriptor that designates a machine register or
8186 zero if there is none. */
8188 static dw_loc_descr_ref
8189 reg_loc_descriptor (rtx rtl
)
8194 if (REGNO (rtl
) >= FIRST_PSEUDO_REGISTER
)
8197 reg
= reg_number (rtl
);
8198 regs
= (*targetm
.dwarf_register_span
) (rtl
);
8200 if (hard_regno_nregs
[reg
][GET_MODE (rtl
)] > 1
8202 return multiple_reg_loc_descriptor (rtl
, regs
);
8204 return one_reg_loc_descriptor (reg
);
8207 /* Return a location descriptor that designates a machine register for
8208 a given hard register number. */
8210 static dw_loc_descr_ref
8211 one_reg_loc_descriptor (unsigned int regno
)
8214 return new_loc_descr (DW_OP_reg0
+ regno
, 0, 0);
8216 return new_loc_descr (DW_OP_regx
, regno
, 0);
8219 /* Given an RTL of a register, return a location descriptor that
8220 designates a value that spans more than one register. */
8222 static dw_loc_descr_ref
8223 multiple_reg_loc_descriptor (rtx rtl
, rtx regs
)
8227 dw_loc_descr_ref loc_result
= NULL
;
8229 reg
= reg_number (rtl
);
8230 nregs
= hard_regno_nregs
[reg
][GET_MODE (rtl
)];
8232 /* Simple, contiguous registers. */
8233 if (regs
== NULL_RTX
)
8235 size
= GET_MODE_SIZE (GET_MODE (rtl
)) / nregs
;
8242 t
= one_reg_loc_descriptor (reg
);
8243 add_loc_descr (&loc_result
, t
);
8244 add_loc_descr (&loc_result
, new_loc_descr (DW_OP_piece
, size
, 0));
8250 /* Now onto stupid register sets in non contiguous locations. */
8252 if (GET_CODE (regs
) != PARALLEL
)
8255 size
= GET_MODE_SIZE (GET_MODE (XVECEXP (regs
, 0, 0)));
8258 for (i
= 0; i
< XVECLEN (regs
, 0); ++i
)
8262 t
= one_reg_loc_descriptor (REGNO (XVECEXP (regs
, 0, i
)));
8263 add_loc_descr (&loc_result
, t
);
8264 size
= GET_MODE_SIZE (GET_MODE (XVECEXP (regs
, 0, 0)));
8265 add_loc_descr (&loc_result
, new_loc_descr (DW_OP_piece
, size
, 0));
8270 /* Return a location descriptor that designates a constant. */
8272 static dw_loc_descr_ref
8273 int_loc_descriptor (HOST_WIDE_INT i
)
8275 enum dwarf_location_atom op
;
8277 /* Pick the smallest representation of a constant, rather than just
8278 defaulting to the LEB encoding. */
8282 op
= DW_OP_lit0
+ i
;
8285 else if (i
<= 0xffff)
8287 else if (HOST_BITS_PER_WIDE_INT
== 32
8297 else if (i
>= -0x8000)
8299 else if (HOST_BITS_PER_WIDE_INT
== 32
8300 || i
>= -0x80000000)
8306 return new_loc_descr (op
, i
, 0);
8309 /* Return a location descriptor that designates a base+offset location. */
8311 static dw_loc_descr_ref
8312 based_loc_descr (unsigned int reg
, HOST_WIDE_INT offset
, bool can_use_fbreg
)
8314 dw_loc_descr_ref loc_result
;
8315 /* For the "frame base", we use the frame pointer or stack pointer
8316 registers, since the RTL for local variables is relative to one of
8318 unsigned fp_reg
= DBX_REGISTER_NUMBER (frame_pointer_needed
8319 ? HARD_FRAME_POINTER_REGNUM
8320 : STACK_POINTER_REGNUM
);
8322 if (reg
== fp_reg
&& can_use_fbreg
)
8323 loc_result
= new_loc_descr (DW_OP_fbreg
, offset
, 0);
8325 loc_result
= new_loc_descr (DW_OP_breg0
+ reg
, offset
, 0);
8327 loc_result
= new_loc_descr (DW_OP_bregx
, reg
, offset
);
8332 /* Return true if this RTL expression describes a base+offset calculation. */
8335 is_based_loc (rtx rtl
)
8337 return (GET_CODE (rtl
) == PLUS
8338 && ((GET_CODE (XEXP (rtl
, 0)) == REG
8339 && REGNO (XEXP (rtl
, 0)) < FIRST_PSEUDO_REGISTER
8340 && GET_CODE (XEXP (rtl
, 1)) == CONST_INT
)));
8343 /* The following routine converts the RTL for a variable or parameter
8344 (resident in memory) into an equivalent Dwarf representation of a
8345 mechanism for getting the address of that same variable onto the top of a
8346 hypothetical "address evaluation" stack.
8348 When creating memory location descriptors, we are effectively transforming
8349 the RTL for a memory-resident object into its Dwarf postfix expression
8350 equivalent. This routine recursively descends an RTL tree, turning
8351 it into Dwarf postfix code as it goes.
8353 MODE is the mode of the memory reference, needed to handle some
8354 autoincrement addressing modes.
8356 CAN_USE_FBREG is a flag whether we can use DW_AT_frame_base in the location
8357 list for RTL. We can't use it when we are emitting location list for
8358 virtual variable frame_base_decl (i.e. a location list for DW_AT_frame_base)
8359 which describes how frame base changes when !frame_pointer_needed.
8361 Return 0 if we can't represent the location. */
8363 static dw_loc_descr_ref
8364 mem_loc_descriptor (rtx rtl
, enum machine_mode mode
, bool can_use_fbreg
)
8366 dw_loc_descr_ref mem_loc_result
= NULL
;
8368 /* Note that for a dynamically sized array, the location we will generate a
8369 description of here will be the lowest numbered location which is
8370 actually within the array. That's *not* necessarily the same as the
8371 zeroth element of the array. */
8373 rtl
= (*targetm
.delegitimize_address
) (rtl
);
8375 switch (GET_CODE (rtl
))
8380 /* POST_INC and POST_DEC can be handled just like a SUBREG. So we
8381 just fall into the SUBREG code. */
8383 /* ... fall through ... */
8386 /* The case of a subreg may arise when we have a local (register)
8387 variable or a formal (register) parameter which doesn't quite fill
8388 up an entire register. For now, just assume that it is
8389 legitimate to make the Dwarf info refer to the whole register which
8390 contains the given subreg. */
8391 rtl
= SUBREG_REG (rtl
);
8393 /* ... fall through ... */
8396 /* Whenever a register number forms a part of the description of the
8397 method for calculating the (dynamic) address of a memory resident
8398 object, DWARF rules require the register number be referred to as
8399 a "base register". This distinction is not based in any way upon
8400 what category of register the hardware believes the given register
8401 belongs to. This is strictly DWARF terminology we're dealing with
8402 here. Note that in cases where the location of a memory-resident
8403 data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
8404 OP_CONST (0)) the actual DWARF location descriptor that we generate
8405 may just be OP_BASEREG (basereg). This may look deceptively like
8406 the object in question was allocated to a register (rather than in
8407 memory) so DWARF consumers need to be aware of the subtle
8408 distinction between OP_REG and OP_BASEREG. */
8409 if (REGNO (rtl
) < FIRST_PSEUDO_REGISTER
)
8410 mem_loc_result
= based_loc_descr (reg_number (rtl
), 0, can_use_fbreg
);
8414 mem_loc_result
= mem_loc_descriptor (XEXP (rtl
, 0), GET_MODE (rtl
),
8416 if (mem_loc_result
!= 0)
8417 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_deref
, 0, 0));
8421 rtl
= XEXP (rtl
, 1);
8423 /* ... fall through ... */
8426 /* Some ports can transform a symbol ref into a label ref, because
8427 the symbol ref is too far away and has to be dumped into a constant
8431 /* Alternatively, the symbol in the constant pool might be referenced
8432 by a different symbol. */
8433 if (GET_CODE (rtl
) == SYMBOL_REF
&& CONSTANT_POOL_ADDRESS_P (rtl
))
8436 rtx tmp
= get_pool_constant_mark (rtl
, &marked
);
8438 if (GET_CODE (tmp
) == SYMBOL_REF
)
8441 if (CONSTANT_POOL_ADDRESS_P (tmp
))
8442 get_pool_constant_mark (tmp
, &marked
);
8447 /* If all references to this pool constant were optimized away,
8448 it was not output and thus we can't represent it.
8449 FIXME: might try to use DW_OP_const_value here, though
8450 DW_OP_piece complicates it. */
8455 mem_loc_result
= new_loc_descr (DW_OP_addr
, 0, 0);
8456 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_addr
;
8457 mem_loc_result
->dw_loc_oprnd1
.v
.val_addr
= rtl
;
8458 VARRAY_PUSH_RTX (used_rtx_varray
, rtl
);
8462 /* Extract the PLUS expression nested inside and fall into
8464 rtl
= XEXP (rtl
, 1);
8469 /* Turn these into a PLUS expression and fall into the PLUS code
8471 rtl
= gen_rtx_PLUS (word_mode
, XEXP (rtl
, 0),
8472 GEN_INT (GET_CODE (rtl
) == PRE_INC
8473 ? GET_MODE_UNIT_SIZE (mode
)
8474 : -GET_MODE_UNIT_SIZE (mode
)));
8476 /* ... fall through ... */
8480 if (is_based_loc (rtl
))
8481 mem_loc_result
= based_loc_descr (reg_number (XEXP (rtl
, 0)),
8482 INTVAL (XEXP (rtl
, 1)),
8486 mem_loc_result
= mem_loc_descriptor (XEXP (rtl
, 0), mode
,
8488 if (mem_loc_result
== 0)
8491 if (GET_CODE (XEXP (rtl
, 1)) == CONST_INT
8492 && INTVAL (XEXP (rtl
, 1)) >= 0)
8493 add_loc_descr (&mem_loc_result
,
8494 new_loc_descr (DW_OP_plus_uconst
,
8495 INTVAL (XEXP (rtl
, 1)), 0));
8498 add_loc_descr (&mem_loc_result
,
8499 mem_loc_descriptor (XEXP (rtl
, 1), mode
,
8501 add_loc_descr (&mem_loc_result
,
8502 new_loc_descr (DW_OP_plus
, 0, 0));
8509 /* If a pseudo-reg is optimized away, it is possible for it to
8510 be replaced with a MEM containing a multiply. */
8511 dw_loc_descr_ref op0
= mem_loc_descriptor (XEXP (rtl
, 0), mode
,
8513 dw_loc_descr_ref op1
= mem_loc_descriptor (XEXP (rtl
, 1), mode
,
8516 if (op0
== 0 || op1
== 0)
8519 mem_loc_result
= op0
;
8520 add_loc_descr (&mem_loc_result
, op1
);
8521 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_mul
, 0, 0));
8526 mem_loc_result
= int_loc_descriptor (INTVAL (rtl
));
8530 /* If this is a MEM, return its address. Otherwise, we can't
8532 if (GET_CODE (XEXP (rtl
, 0)) == MEM
)
8533 return mem_loc_descriptor (XEXP (XEXP (rtl
, 0), 0), mode
,
8542 return mem_loc_result
;
8545 /* Return a descriptor that describes the concatenation of two locations.
8546 This is typically a complex variable. */
8548 static dw_loc_descr_ref
8549 concat_loc_descriptor (rtx x0
, rtx x1
)
8551 dw_loc_descr_ref cc_loc_result
= NULL
;
8552 dw_loc_descr_ref x0_ref
= loc_descriptor (x0
, true);
8553 dw_loc_descr_ref x1_ref
= loc_descriptor (x1
, true);
8555 if (x0_ref
== 0 || x1_ref
== 0)
8558 cc_loc_result
= x0_ref
;
8559 add_loc_descr (&cc_loc_result
,
8560 new_loc_descr (DW_OP_piece
,
8561 GET_MODE_SIZE (GET_MODE (x0
)), 0));
8563 add_loc_descr (&cc_loc_result
, x1_ref
);
8564 add_loc_descr (&cc_loc_result
,
8565 new_loc_descr (DW_OP_piece
,
8566 GET_MODE_SIZE (GET_MODE (x1
)), 0));
8568 return cc_loc_result
;
8571 /* Output a proper Dwarf location descriptor for a variable or parameter
8572 which is either allocated in a register or in a memory location. For a
8573 register, we just generate an OP_REG and the register number. For a
8574 memory location we provide a Dwarf postfix expression describing how to
8575 generate the (dynamic) address of the object onto the address stack.
8577 If we don't know how to describe it, return 0. */
8579 static dw_loc_descr_ref
8580 loc_descriptor (rtx rtl
, bool can_use_fbreg
)
8582 dw_loc_descr_ref loc_result
= NULL
;
8584 switch (GET_CODE (rtl
))
8587 /* The case of a subreg may arise when we have a local (register)
8588 variable or a formal (register) parameter which doesn't quite fill
8589 up an entire register. For now, just assume that it is
8590 legitimate to make the Dwarf info refer to the whole register which
8591 contains the given subreg. */
8592 rtl
= SUBREG_REG (rtl
);
8594 /* ... fall through ... */
8597 loc_result
= reg_loc_descriptor (rtl
);
8601 loc_result
= mem_loc_descriptor (XEXP (rtl
, 0), GET_MODE (rtl
),
8606 loc_result
= concat_loc_descriptor (XEXP (rtl
, 0), XEXP (rtl
, 1));
8611 if (GET_CODE (XEXP (rtl
, 1)) != PARALLEL
)
8613 loc_result
= loc_descriptor (XEXP (XEXP (rtl
, 1), 0), can_use_fbreg
);
8615 /* Multiple parts. */
8618 rtvec par_elems
= XVEC (XEXP (rtl
, 1), 0);
8619 int num_elem
= GET_NUM_ELEM (par_elems
);
8620 enum machine_mode mode
;
8623 /* Create the first one, so we have something to add to. */
8624 loc_result
= loc_descriptor (XEXP (RTVEC_ELT (par_elems
, 0), 0),
8626 mode
= GET_MODE (XEXP (RTVEC_ELT (par_elems
, 0), 0));
8627 add_loc_descr (&loc_result
,
8628 new_loc_descr (DW_OP_piece
, GET_MODE_SIZE (mode
), 0));
8629 for (i
= 1; i
< num_elem
; i
++)
8631 dw_loc_descr_ref temp
;
8633 temp
= loc_descriptor (XEXP (RTVEC_ELT (par_elems
, i
), 0),
8635 add_loc_descr (&loc_result
, temp
);
8636 mode
= GET_MODE (XEXP (RTVEC_ELT (par_elems
, i
), 0));
8637 add_loc_descr (&loc_result
,
8638 new_loc_descr (DW_OP_piece
,
8639 GET_MODE_SIZE (mode
), 0));
8651 /* Similar, but generate the descriptor from trees instead of rtl. This comes
8652 up particularly with variable length arrays. If ADDRESSP is nonzero, we are
8653 looking for an address. Otherwise, we return a value. If we can't make a
8654 descriptor, return 0. */
8656 static dw_loc_descr_ref
8657 loc_descriptor_from_tree (tree loc
, int addressp
)
8659 dw_loc_descr_ref ret
, ret1
;
8661 int unsignedp
= TREE_UNSIGNED (TREE_TYPE (loc
));
8662 enum dwarf_location_atom op
;
8664 /* ??? Most of the time we do not take proper care for sign/zero
8665 extending the values properly. Hopefully this won't be a real
8668 switch (TREE_CODE (loc
))
8673 case WITH_RECORD_EXPR
:
8674 case PLACEHOLDER_EXPR
:
8675 /* This case involves extracting fields from an object to determine the
8676 position of other fields. We don't try to encode this here. The
8677 only user of this is Ada, which encodes the needed information using
8678 the names of types. */
8685 /* We can support this only if we can look through conversions and
8686 find an INDIRECT_EXPR. */
8687 for (loc
= TREE_OPERAND (loc
, 0);
8688 TREE_CODE (loc
) == CONVERT_EXPR
|| TREE_CODE (loc
) == NOP_EXPR
8689 || TREE_CODE (loc
) == NON_LVALUE_EXPR
8690 || TREE_CODE (loc
) == VIEW_CONVERT_EXPR
8691 || TREE_CODE (loc
) == SAVE_EXPR
;
8692 loc
= TREE_OPERAND (loc
, 0))
8695 return (TREE_CODE (loc
) == INDIRECT_REF
8696 ? loc_descriptor_from_tree (TREE_OPERAND (loc
, 0), addressp
)
8700 if (DECL_THREAD_LOCAL (loc
))
8704 #ifndef ASM_OUTPUT_DWARF_DTPREL
8705 /* If this is not defined, we have no way to emit the data. */
8709 /* The way DW_OP_GNU_push_tls_address is specified, we can only
8710 look up addresses of objects in the current module. */
8711 if (DECL_EXTERNAL (loc
))
8714 rtl
= rtl_for_decl_location (loc
);
8715 if (rtl
== NULL_RTX
)
8718 if (GET_CODE (rtl
) != MEM
)
8720 rtl
= XEXP (rtl
, 0);
8721 if (! CONSTANT_P (rtl
))
8724 ret
= new_loc_descr (INTERNAL_DW_OP_tls_addr
, 0, 0);
8725 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_addr
;
8726 ret
->dw_loc_oprnd1
.v
.val_addr
= rtl
;
8728 ret1
= new_loc_descr (DW_OP_GNU_push_tls_address
, 0, 0);
8729 add_loc_descr (&ret
, ret1
);
8738 rtx rtl
= rtl_for_decl_location (loc
);
8740 if (rtl
== NULL_RTX
)
8742 else if (CONSTANT_P (rtl
))
8744 ret
= new_loc_descr (DW_OP_addr
, 0, 0);
8745 ret
->dw_loc_oprnd1
.val_class
= dw_val_class_addr
;
8746 ret
->dw_loc_oprnd1
.v
.val_addr
= rtl
;
8751 enum machine_mode mode
= GET_MODE (rtl
);
8753 if (GET_CODE (rtl
) == MEM
)
8756 rtl
= XEXP (rtl
, 0);
8759 ret
= mem_loc_descriptor (rtl
, mode
, true);
8765 ret
= loc_descriptor_from_tree (TREE_OPERAND (loc
, 0), 0);
8770 return loc_descriptor_from_tree (TREE_OPERAND (loc
, 1), addressp
);
8774 case NON_LVALUE_EXPR
:
8775 case VIEW_CONVERT_EXPR
:
8778 return loc_descriptor_from_tree (TREE_OPERAND (loc
, 0), addressp
);
8783 case ARRAY_RANGE_REF
:
8786 HOST_WIDE_INT bitsize
, bitpos
, bytepos
;
8787 enum machine_mode mode
;
8790 obj
= get_inner_reference (loc
, &bitsize
, &bitpos
, &offset
, &mode
,
8791 &unsignedp
, &volatilep
);
8796 ret
= loc_descriptor_from_tree (obj
, 1);
8798 || bitpos
% BITS_PER_UNIT
!= 0 || bitsize
% BITS_PER_UNIT
!= 0)
8801 if (offset
!= NULL_TREE
)
8803 /* Variable offset. */
8804 add_loc_descr (&ret
, loc_descriptor_from_tree (offset
, 0));
8805 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus
, 0, 0));
8811 bytepos
= bitpos
/ BITS_PER_UNIT
;
8813 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus_uconst
, bytepos
, 0));
8814 else if (bytepos
< 0)
8816 add_loc_descr (&ret
, int_loc_descriptor (bytepos
));
8817 add_loc_descr (&ret
, new_loc_descr (DW_OP_plus
, 0, 0));
8823 if (host_integerp (loc
, 0))
8824 ret
= int_loc_descriptor (tree_low_cst (loc
, 0));
8831 /* Get an RTL for this, if something has been emitted. */
8832 rtx rtl
= lookup_constant_def (loc
);
8833 enum machine_mode mode
;
8835 if (GET_CODE (rtl
) != MEM
)
8837 mode
= GET_MODE (rtl
);
8838 rtl
= XEXP (rtl
, 0);
8840 rtl
= (*targetm
.delegitimize_address
) (rtl
);
8843 ret
= mem_loc_descriptor (rtl
, mode
, true);
8847 case TRUTH_AND_EXPR
:
8848 case TRUTH_ANDIF_EXPR
:
8853 case TRUTH_XOR_EXPR
:
8859 case TRUTH_ORIF_EXPR
:
8864 case FLOOR_DIV_EXPR
:
8866 case ROUND_DIV_EXPR
:
8867 case TRUNC_DIV_EXPR
:
8875 case FLOOR_MOD_EXPR
:
8877 case ROUND_MOD_EXPR
:
8878 case TRUNC_MOD_EXPR
:
8891 op
= (unsignedp
? DW_OP_shr
: DW_OP_shra
);
8895 if (TREE_CODE (TREE_OPERAND (loc
, 1)) == INTEGER_CST
8896 && host_integerp (TREE_OPERAND (loc
, 1), 0))
8898 ret
= loc_descriptor_from_tree (TREE_OPERAND (loc
, 0), 0);
8902 add_loc_descr (&ret
,
8903 new_loc_descr (DW_OP_plus_uconst
,
8904 tree_low_cst (TREE_OPERAND (loc
, 1),
8914 if (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc
, 0))))
8921 if (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc
, 0))))
8928 if (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc
, 0))))
8935 if (TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc
, 0))))
8950 ret
= loc_descriptor_from_tree (TREE_OPERAND (loc
, 0), 0);
8951 ret1
= loc_descriptor_from_tree (TREE_OPERAND (loc
, 1), 0);
8952 if (ret
== 0 || ret1
== 0)
8955 add_loc_descr (&ret
, ret1
);
8956 add_loc_descr (&ret
, new_loc_descr (op
, 0, 0));
8959 case TRUTH_NOT_EXPR
:
8973 ret
= loc_descriptor_from_tree (TREE_OPERAND (loc
, 0), 0);
8977 add_loc_descr (&ret
, new_loc_descr (op
, 0, 0));
8981 loc
= build (COND_EXPR
, TREE_TYPE (loc
),
8982 build (LT_EXPR
, integer_type_node
,
8983 TREE_OPERAND (loc
, 0), TREE_OPERAND (loc
, 1)),
8984 TREE_OPERAND (loc
, 1), TREE_OPERAND (loc
, 0));
8986 /* ... fall through ... */
8990 dw_loc_descr_ref lhs
8991 = loc_descriptor_from_tree (TREE_OPERAND (loc
, 1), 0);
8992 dw_loc_descr_ref rhs
8993 = loc_descriptor_from_tree (TREE_OPERAND (loc
, 2), 0);
8994 dw_loc_descr_ref bra_node
, jump_node
, tmp
;
8996 ret
= loc_descriptor_from_tree (TREE_OPERAND (loc
, 0), 0);
8997 if (ret
== 0 || lhs
== 0 || rhs
== 0)
9000 bra_node
= new_loc_descr (DW_OP_bra
, 0, 0);
9001 add_loc_descr (&ret
, bra_node
);
9003 add_loc_descr (&ret
, rhs
);
9004 jump_node
= new_loc_descr (DW_OP_skip
, 0, 0);
9005 add_loc_descr (&ret
, jump_node
);
9007 add_loc_descr (&ret
, lhs
);
9008 bra_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
9009 bra_node
->dw_loc_oprnd1
.v
.val_loc
= lhs
;
9011 /* ??? Need a node to point the skip at. Use a nop. */
9012 tmp
= new_loc_descr (DW_OP_nop
, 0, 0);
9013 add_loc_descr (&ret
, tmp
);
9014 jump_node
->dw_loc_oprnd1
.val_class
= dw_val_class_loc
;
9015 jump_node
->dw_loc_oprnd1
.v
.val_loc
= tmp
;
9019 case EXPR_WITH_FILE_LOCATION
:
9020 return loc_descriptor_from_tree (EXPR_WFL_NODE (loc
), addressp
);
9023 /* Leave front-end specific codes as simply unknown. This comes
9024 up, for instance, with the C STMT_EXPR. */
9025 if ((unsigned int) TREE_CODE (loc
)
9026 >= (unsigned int) LAST_AND_UNUSED_TREE_CODE
)
9029 /* Otherwise this is a generic code; we should just lists all of
9030 these explicitly. Aborting means we forgot one. */
9034 /* Show if we can't fill the request for an address. */
9035 if (addressp
&& indirect_p
== 0)
9038 /* If we've got an address and don't want one, dereference. */
9039 if (!addressp
&& indirect_p
> 0)
9041 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (loc
));
9043 if (size
> DWARF2_ADDR_SIZE
|| size
== -1)
9045 else if (size
== DWARF2_ADDR_SIZE
)
9048 op
= DW_OP_deref_size
;
9050 add_loc_descr (&ret
, new_loc_descr (op
, size
, 0));
9056 /* Given a value, round it up to the lowest multiple of `boundary'
9057 which is not less than the value itself. */
9059 static inline HOST_WIDE_INT
9060 ceiling (HOST_WIDE_INT value
, unsigned int boundary
)
9062 return (((value
+ boundary
- 1) / boundary
) * boundary
);
9065 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
9066 pointer to the declared type for the relevant field variable, or return
9067 `integer_type_node' if the given node turns out to be an
9071 field_type (tree decl
)
9075 if (TREE_CODE (decl
) == ERROR_MARK
)
9076 return integer_type_node
;
9078 type
= DECL_BIT_FIELD_TYPE (decl
);
9079 if (type
== NULL_TREE
)
9080 type
= TREE_TYPE (decl
);
9085 /* Given a pointer to a tree node, return the alignment in bits for
9086 it, or else return BITS_PER_WORD if the node actually turns out to
9087 be an ERROR_MARK node. */
9089 static inline unsigned
9090 simple_type_align_in_bits (tree type
)
9092 return (TREE_CODE (type
) != ERROR_MARK
) ? TYPE_ALIGN (type
) : BITS_PER_WORD
;
9095 static inline unsigned
9096 simple_decl_align_in_bits (tree decl
)
9098 return (TREE_CODE (decl
) != ERROR_MARK
) ? DECL_ALIGN (decl
) : BITS_PER_WORD
;
9101 /* Given a pointer to a FIELD_DECL, compute and return the byte offset of the
9102 lowest addressed byte of the "containing object" for the given FIELD_DECL,
9103 or return 0 if we are unable to determine what that offset is, either
9104 because the argument turns out to be a pointer to an ERROR_MARK node, or
9105 because the offset is actually variable. (We can't handle the latter case
9108 static HOST_WIDE_INT
9109 field_byte_offset (tree decl
)
9111 unsigned int type_align_in_bits
;
9112 unsigned int decl_align_in_bits
;
9113 unsigned HOST_WIDE_INT type_size_in_bits
;
9114 HOST_WIDE_INT object_offset_in_bits
;
9116 tree field_size_tree
;
9117 HOST_WIDE_INT bitpos_int
;
9118 HOST_WIDE_INT deepest_bitpos
;
9119 unsigned HOST_WIDE_INT field_size_in_bits
;
9121 if (TREE_CODE (decl
) == ERROR_MARK
)
9123 else if (TREE_CODE (decl
) != FIELD_DECL
)
9126 type
= field_type (decl
);
9127 field_size_tree
= DECL_SIZE (decl
);
9129 /* The size could be unspecified if there was an error, or for
9130 a flexible array member. */
9131 if (! field_size_tree
)
9132 field_size_tree
= bitsize_zero_node
;
9134 /* We cannot yet cope with fields whose positions are variable, so
9135 for now, when we see such things, we simply return 0. Someday, we may
9136 be able to handle such cases, but it will be damn difficult. */
9137 if (! host_integerp (bit_position (decl
), 0))
9140 bitpos_int
= int_bit_position (decl
);
9142 /* If we don't know the size of the field, pretend it's a full word. */
9143 if (host_integerp (field_size_tree
, 1))
9144 field_size_in_bits
= tree_low_cst (field_size_tree
, 1);
9146 field_size_in_bits
= BITS_PER_WORD
;
9148 type_size_in_bits
= simple_type_size_in_bits (type
);
9149 type_align_in_bits
= simple_type_align_in_bits (type
);
9150 decl_align_in_bits
= simple_decl_align_in_bits (decl
);
9152 /* The GCC front-end doesn't make any attempt to keep track of the starting
9153 bit offset (relative to the start of the containing structure type) of the
9154 hypothetical "containing object" for a bit-field. Thus, when computing
9155 the byte offset value for the start of the "containing object" of a
9156 bit-field, we must deduce this information on our own. This can be rather
9157 tricky to do in some cases. For example, handling the following structure
9158 type definition when compiling for an i386/i486 target (which only aligns
9159 long long's to 32-bit boundaries) can be very tricky:
9161 struct S { int field1; long long field2:31; };
9163 Fortunately, there is a simple rule-of-thumb which can be used in such
9164 cases. When compiling for an i386/i486, GCC will allocate 8 bytes for the
9165 structure shown above. It decides to do this based upon one simple rule
9166 for bit-field allocation. GCC allocates each "containing object" for each
9167 bit-field at the first (i.e. lowest addressed) legitimate alignment
9168 boundary (based upon the required minimum alignment for the declared type
9169 of the field) which it can possibly use, subject to the condition that
9170 there is still enough available space remaining in the containing object
9171 (when allocated at the selected point) to fully accommodate all of the
9172 bits of the bit-field itself.
9174 This simple rule makes it obvious why GCC allocates 8 bytes for each
9175 object of the structure type shown above. When looking for a place to
9176 allocate the "containing object" for `field2', the compiler simply tries
9177 to allocate a 64-bit "containing object" at each successive 32-bit
9178 boundary (starting at zero) until it finds a place to allocate that 64-
9179 bit field such that at least 31 contiguous (and previously unallocated)
9180 bits remain within that selected 64 bit field. (As it turns out, for the
9181 example above, the compiler finds it is OK to allocate the "containing
9182 object" 64-bit field at bit-offset zero within the structure type.)
9184 Here we attempt to work backwards from the limited set of facts we're
9185 given, and we try to deduce from those facts, where GCC must have believed
9186 that the containing object started (within the structure type). The value
9187 we deduce is then used (by the callers of this routine) to generate
9188 DW_AT_location and DW_AT_bit_offset attributes for fields (both bit-fields
9189 and, in the case of DW_AT_location, regular fields as well). */
9191 /* Figure out the bit-distance from the start of the structure to the
9192 "deepest" bit of the bit-field. */
9193 deepest_bitpos
= bitpos_int
+ field_size_in_bits
;
9195 /* This is the tricky part. Use some fancy footwork to deduce where the
9196 lowest addressed bit of the containing object must be. */
9197 object_offset_in_bits
= deepest_bitpos
- type_size_in_bits
;
9199 /* Round up to type_align by default. This works best for bitfields. */
9200 object_offset_in_bits
+= type_align_in_bits
- 1;
9201 object_offset_in_bits
/= type_align_in_bits
;
9202 object_offset_in_bits
*= type_align_in_bits
;
9204 if (object_offset_in_bits
> bitpos_int
)
9206 /* Sigh, the decl must be packed. */
9207 object_offset_in_bits
= deepest_bitpos
- type_size_in_bits
;
9209 /* Round up to decl_align instead. */
9210 object_offset_in_bits
+= decl_align_in_bits
- 1;
9211 object_offset_in_bits
/= decl_align_in_bits
;
9212 object_offset_in_bits
*= decl_align_in_bits
;
9215 return object_offset_in_bits
/ BITS_PER_UNIT
;
9218 /* The following routines define various Dwarf attributes and any data
9219 associated with them. */
9221 /* Add a location description attribute value to a DIE.
9223 This emits location attributes suitable for whole variables and
9224 whole parameters. Note that the location attributes for struct fields are
9225 generated by the routine `data_member_location_attribute' below. */
9228 add_AT_location_description (dw_die_ref die
, enum dwarf_attribute attr_kind
,
9229 dw_loc_descr_ref descr
)
9232 add_AT_loc (die
, attr_kind
, descr
);
9235 /* Attach the specialized form of location attribute used for data members of
9236 struct and union types. In the special case of a FIELD_DECL node which
9237 represents a bit-field, the "offset" part of this special location
9238 descriptor must indicate the distance in bytes from the lowest-addressed
9239 byte of the containing struct or union type to the lowest-addressed byte of
9240 the "containing object" for the bit-field. (See the `field_byte_offset'
9243 For any given bit-field, the "containing object" is a hypothetical object
9244 (of some integral or enum type) within which the given bit-field lives. The
9245 type of this hypothetical "containing object" is always the same as the
9246 declared type of the individual bit-field itself (for GCC anyway... the
9247 DWARF spec doesn't actually mandate this). Note that it is the size (in
9248 bytes) of the hypothetical "containing object" which will be given in the
9249 DW_AT_byte_size attribute for this bit-field. (See the
9250 `byte_size_attribute' function below.) It is also used when calculating the
9251 value of the DW_AT_bit_offset attribute. (See the `bit_offset_attribute'
9255 add_data_member_location_attribute (dw_die_ref die
, tree decl
)
9257 HOST_WIDE_INT offset
;
9258 dw_loc_descr_ref loc_descr
= 0;
9260 if (TREE_CODE (decl
) == TREE_VEC
)
9262 /* We're working on the TAG_inheritance for a base class. */
9263 if (TREE_VIA_VIRTUAL (decl
) && is_cxx ())
9265 /* For C++ virtual bases we can't just use BINFO_OFFSET, as they
9266 aren't at a fixed offset from all (sub)objects of the same
9267 type. We need to extract the appropriate offset from our
9268 vtable. The following dwarf expression means
9270 BaseAddr = ObAddr + *((*ObAddr) - Offset)
9272 This is specific to the V3 ABI, of course. */
9274 dw_loc_descr_ref tmp
;
9276 /* Make a copy of the object address. */
9277 tmp
= new_loc_descr (DW_OP_dup
, 0, 0);
9278 add_loc_descr (&loc_descr
, tmp
);
9280 /* Extract the vtable address. */
9281 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
9282 add_loc_descr (&loc_descr
, tmp
);
9284 /* Calculate the address of the offset. */
9285 offset
= tree_low_cst (BINFO_VPTR_FIELD (decl
), 0);
9289 tmp
= int_loc_descriptor (-offset
);
9290 add_loc_descr (&loc_descr
, tmp
);
9291 tmp
= new_loc_descr (DW_OP_minus
, 0, 0);
9292 add_loc_descr (&loc_descr
, tmp
);
9294 /* Extract the offset. */
9295 tmp
= new_loc_descr (DW_OP_deref
, 0, 0);
9296 add_loc_descr (&loc_descr
, tmp
);
9298 /* Add it to the object address. */
9299 tmp
= new_loc_descr (DW_OP_plus
, 0, 0);
9300 add_loc_descr (&loc_descr
, tmp
);
9303 offset
= tree_low_cst (BINFO_OFFSET (decl
), 0);
9306 offset
= field_byte_offset (decl
);
9310 enum dwarf_location_atom op
;
9312 /* The DWARF2 standard says that we should assume that the structure
9313 address is already on the stack, so we can specify a structure field
9314 address by using DW_OP_plus_uconst. */
9316 #ifdef MIPS_DEBUGGING_INFO
9317 /* ??? The SGI dwarf reader does not handle the DW_OP_plus_uconst
9318 operator correctly. It works only if we leave the offset on the
9322 op
= DW_OP_plus_uconst
;
9325 loc_descr
= new_loc_descr (op
, offset
, 0);
9328 add_AT_loc (die
, DW_AT_data_member_location
, loc_descr
);
9331 /* Writes integer values to dw_vec_const array. */
9334 insert_int (HOST_WIDE_INT val
, unsigned int size
, unsigned char *dest
)
9338 *dest
++ = val
& 0xff;
9344 /* Reads integers from dw_vec_const array. Inverse of insert_int. */
9346 static HOST_WIDE_INT
9347 extract_int (const unsigned char *src
, unsigned int size
)
9349 HOST_WIDE_INT val
= 0;
9355 val
|= *--src
& 0xff;
9361 /* Writes floating point values to dw_vec_const array. */
9364 insert_float (rtx rtl
, unsigned char *array
)
9370 REAL_VALUE_FROM_CONST_DOUBLE (rv
, rtl
);
9371 real_to_target (val
, &rv
, GET_MODE (rtl
));
9373 /* real_to_target puts 32-bit pieces in each long. Pack them. */
9374 for (i
= 0; i
< GET_MODE_SIZE (GET_MODE (rtl
)) / 4; i
++)
9376 insert_int (val
[i
], 4, array
);
9381 /* Attach a DW_AT_const_value attribute for a variable or a parameter which
9382 does not have a "location" either in memory or in a register. These
9383 things can arise in GNU C when a constant is passed as an actual parameter
9384 to an inlined function. They can also arise in C++ where declared
9385 constants do not necessarily get memory "homes". */
9388 add_const_value_attribute (dw_die_ref die
, rtx rtl
)
9390 switch (GET_CODE (rtl
))
9394 HOST_WIDE_INT val
= INTVAL (rtl
);
9397 add_AT_int (die
, DW_AT_const_value
, val
);
9399 add_AT_unsigned (die
, DW_AT_const_value
, (unsigned HOST_WIDE_INT
) val
);
9404 /* Note that a CONST_DOUBLE rtx could represent either an integer or a
9405 floating-point constant. A CONST_DOUBLE is used whenever the
9406 constant requires more than one word in order to be adequately
9407 represented. We output CONST_DOUBLEs as blocks. */
9409 enum machine_mode mode
= GET_MODE (rtl
);
9411 if (GET_MODE_CLASS (mode
) == MODE_FLOAT
)
9413 unsigned int length
= GET_MODE_SIZE (mode
);
9414 unsigned char *array
= ggc_alloc (length
);
9416 insert_float (rtl
, array
);
9417 add_AT_vec (die
, DW_AT_const_value
, length
/ 4, 4, array
);
9421 /* ??? We really should be using HOST_WIDE_INT throughout. */
9422 if (HOST_BITS_PER_LONG
!= HOST_BITS_PER_WIDE_INT
)
9425 add_AT_long_long (die
, DW_AT_const_value
,
9426 CONST_DOUBLE_HIGH (rtl
), CONST_DOUBLE_LOW (rtl
));
9433 enum machine_mode mode
= GET_MODE (rtl
);
9434 unsigned int elt_size
= GET_MODE_UNIT_SIZE (mode
);
9435 unsigned int length
= CONST_VECTOR_NUNITS (rtl
);
9436 unsigned char *array
= ggc_alloc (length
* elt_size
);
9440 if (GET_MODE_CLASS (mode
) == MODE_VECTOR_INT
)
9442 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
9444 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
9445 HOST_WIDE_INT lo
, hi
;
9446 if (GET_CODE (elt
) == CONST_INT
)
9451 else if (GET_CODE (elt
) == CONST_DOUBLE
)
9453 lo
= CONST_DOUBLE_LOW (elt
);
9454 hi
= CONST_DOUBLE_HIGH (elt
);
9459 if (elt_size
<= sizeof (HOST_WIDE_INT
))
9460 insert_int (lo
, elt_size
, p
);
9461 else if (elt_size
== 2 * sizeof (HOST_WIDE_INT
))
9463 unsigned char *p0
= p
;
9464 unsigned char *p1
= p
+ sizeof (HOST_WIDE_INT
);
9466 if (WORDS_BIG_ENDIAN
)
9471 insert_int (lo
, sizeof (HOST_WIDE_INT
), p0
);
9472 insert_int (hi
, sizeof (HOST_WIDE_INT
), p1
);
9478 else if (GET_MODE_CLASS (mode
) == MODE_VECTOR_FLOAT
)
9480 for (i
= 0, p
= array
; i
< length
; i
++, p
+= elt_size
)
9482 rtx elt
= CONST_VECTOR_ELT (rtl
, i
);
9483 insert_float (elt
, p
);
9489 add_AT_vec (die
, DW_AT_const_value
, length
, elt_size
, array
);
9494 add_AT_string (die
, DW_AT_const_value
, XSTR (rtl
, 0));
9500 add_AT_addr (die
, DW_AT_const_value
, rtl
);
9501 VARRAY_PUSH_RTX (used_rtx_varray
, rtl
);
9505 /* In cases where an inlined instance of an inline function is passed
9506 the address of an `auto' variable (which is local to the caller) we
9507 can get a situation where the DECL_RTL of the artificial local
9508 variable (for the inlining) which acts as a stand-in for the
9509 corresponding formal parameter (of the inline function) will look
9510 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not
9511 exactly a compile-time constant expression, but it isn't the address
9512 of the (artificial) local variable either. Rather, it represents the
9513 *value* which the artificial local variable always has during its
9514 lifetime. We currently have no way to represent such quasi-constant
9515 values in Dwarf, so for now we just punt and generate nothing. */
9519 /* No other kinds of rtx should be possible here. */
9526 rtl_for_decl_location (tree decl
)
9530 /* Here we have to decide where we are going to say the parameter "lives"
9531 (as far as the debugger is concerned). We only have a couple of
9532 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
9534 DECL_RTL normally indicates where the parameter lives during most of the
9535 activation of the function. If optimization is enabled however, this
9536 could be either NULL or else a pseudo-reg. Both of those cases indicate
9537 that the parameter doesn't really live anywhere (as far as the code
9538 generation parts of GCC are concerned) during most of the function's
9539 activation. That will happen (for example) if the parameter is never
9540 referenced within the function.
9542 We could just generate a location descriptor here for all non-NULL
9543 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
9544 a little nicer than that if we also consider DECL_INCOMING_RTL in cases
9545 where DECL_RTL is NULL or is a pseudo-reg.
9547 Note however that we can only get away with using DECL_INCOMING_RTL as
9548 a backup substitute for DECL_RTL in certain limited cases. In cases
9549 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
9550 we can be sure that the parameter was passed using the same type as it is
9551 declared to have within the function, and that its DECL_INCOMING_RTL
9552 points us to a place where a value of that type is passed.
9554 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
9555 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
9556 because in these cases DECL_INCOMING_RTL points us to a value of some
9557 type which is *different* from the type of the parameter itself. Thus,
9558 if we tried to use DECL_INCOMING_RTL to generate a location attribute in
9559 such cases, the debugger would end up (for example) trying to fetch a
9560 `float' from a place which actually contains the first part of a
9561 `double'. That would lead to really incorrect and confusing
9562 output at debug-time.
9564 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
9565 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There
9566 are a couple of exceptions however. On little-endian machines we can
9567 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
9568 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
9569 an integral type that is smaller than TREE_TYPE (decl). These cases arise
9570 when (on a little-endian machine) a non-prototyped function has a
9571 parameter declared to be of type `short' or `char'. In such cases,
9572 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
9573 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
9574 passed `int' value. If the debugger then uses that address to fetch
9575 a `short' or a `char' (on a little-endian machine) the result will be
9576 the correct data, so we allow for such exceptional cases below.
9578 Note that our goal here is to describe the place where the given formal
9579 parameter lives during most of the function's activation (i.e. between the
9580 end of the prologue and the start of the epilogue). We'll do that as best
9581 as we can. Note however that if the given formal parameter is modified
9582 sometime during the execution of the function, then a stack backtrace (at
9583 debug-time) will show the function as having been called with the *new*
9584 value rather than the value which was originally passed in. This happens
9585 rarely enough that it is not a major problem, but it *is* a problem, and
9588 A future version of dwarf2out.c may generate two additional attributes for
9589 any given DW_TAG_formal_parameter DIE which will describe the "passed
9590 type" and the "passed location" for the given formal parameter in addition
9591 to the attributes we now generate to indicate the "declared type" and the
9592 "active location" for each parameter. This additional set of attributes
9593 could be used by debuggers for stack backtraces. Separately, note that
9594 sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also.
9595 This happens (for example) for inlined-instances of inline function formal
9596 parameters which are never referenced. This really shouldn't be
9597 happening. All PARM_DECL nodes should get valid non-NULL
9598 DECL_INCOMING_RTL values, but integrate.c doesn't currently generate these
9599 values for inlined instances of inline function parameters, so when we see
9600 such cases, we are just out-of-luck for the time being (until integrate.c
9603 /* Use DECL_RTL as the "location" unless we find something better. */
9604 rtl
= DECL_RTL_IF_SET (decl
);
9606 /* When generating abstract instances, ignore everything except
9607 constants, symbols living in memory, and symbols living in
9609 if (! reload_completed
)
9612 && (CONSTANT_P (rtl
)
9613 || (GET_CODE (rtl
) == MEM
9614 && CONSTANT_P (XEXP (rtl
, 0)))
9615 || (GET_CODE (rtl
) == REG
9616 && TREE_CODE (decl
) == VAR_DECL
9617 && TREE_STATIC (decl
))))
9619 rtl
= (*targetm
.delegitimize_address
) (rtl
);
9624 else if (TREE_CODE (decl
) == PARM_DECL
)
9626 if (rtl
== NULL_RTX
|| is_pseudo_reg (rtl
))
9628 tree declared_type
= type_main_variant (TREE_TYPE (decl
));
9629 tree passed_type
= type_main_variant (DECL_ARG_TYPE (decl
));
9631 /* This decl represents a formal parameter which was optimized out.
9632 Note that DECL_INCOMING_RTL may be NULL in here, but we handle
9633 all cases where (rtl == NULL_RTX) just below. */
9634 if (declared_type
== passed_type
)
9635 rtl
= DECL_INCOMING_RTL (decl
);
9636 else if (! BYTES_BIG_ENDIAN
9637 && TREE_CODE (declared_type
) == INTEGER_TYPE
9638 && (GET_MODE_SIZE (TYPE_MODE (declared_type
))
9639 <= GET_MODE_SIZE (TYPE_MODE (passed_type
))))
9640 rtl
= DECL_INCOMING_RTL (decl
);
9643 /* If the parm was passed in registers, but lives on the stack, then
9644 make a big endian correction if the mode of the type of the
9645 parameter is not the same as the mode of the rtl. */
9646 /* ??? This is the same series of checks that are made in dbxout.c before
9647 we reach the big endian correction code there. It isn't clear if all
9648 of these checks are necessary here, but keeping them all is the safe
9650 else if (GET_CODE (rtl
) == MEM
9651 && XEXP (rtl
, 0) != const0_rtx
9652 && ! CONSTANT_P (XEXP (rtl
, 0))
9653 /* Not passed in memory. */
9654 && GET_CODE (DECL_INCOMING_RTL (decl
)) != MEM
9655 /* Not passed by invisible reference. */
9656 && (GET_CODE (XEXP (rtl
, 0)) != REG
9657 || REGNO (XEXP (rtl
, 0)) == HARD_FRAME_POINTER_REGNUM
9658 || REGNO (XEXP (rtl
, 0)) == STACK_POINTER_REGNUM
9659 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
9660 || REGNO (XEXP (rtl
, 0)) == ARG_POINTER_REGNUM
9663 /* Big endian correction check. */
9665 && TYPE_MODE (TREE_TYPE (decl
)) != GET_MODE (rtl
)
9666 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl
)))
9669 int offset
= (UNITS_PER_WORD
9670 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl
))));
9672 rtl
= gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl
)),
9673 plus_constant (XEXP (rtl
, 0), offset
));
9677 if (rtl
!= NULL_RTX
)
9679 rtl
= eliminate_regs (rtl
, 0, NULL_RTX
);
9680 #ifdef LEAF_REG_REMAP
9681 if (current_function_uses_only_leaf_regs
)
9682 leaf_renumber_regs_insn (rtl
);
9686 /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant,
9687 and will have been substituted directly into all expressions that use it.
9688 C does not have such a concept, but C++ and other languages do. */
9689 else if (TREE_CODE (decl
) == VAR_DECL
&& DECL_INITIAL (decl
))
9691 /* If a variable is initialized with a string constant without embedded
9692 zeros, build CONST_STRING. */
9693 if (TREE_CODE (DECL_INITIAL (decl
)) == STRING_CST
9694 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
9696 tree arrtype
= TREE_TYPE (decl
);
9697 tree enttype
= TREE_TYPE (arrtype
);
9698 tree domain
= TYPE_DOMAIN (arrtype
);
9699 tree init
= DECL_INITIAL (decl
);
9700 enum machine_mode mode
= TYPE_MODE (enttype
);
9702 if (GET_MODE_CLASS (mode
) == MODE_INT
&& GET_MODE_SIZE (mode
) == 1
9704 && integer_zerop (TYPE_MIN_VALUE (domain
))
9705 && compare_tree_int (TYPE_MAX_VALUE (domain
),
9706 TREE_STRING_LENGTH (init
) - 1) == 0
9707 && ((size_t) TREE_STRING_LENGTH (init
)
9708 == strlen (TREE_STRING_POINTER (init
)) + 1))
9709 rtl
= gen_rtx_CONST_STRING (VOIDmode
, TREE_STRING_POINTER (init
));
9711 /* If the initializer is something that we know will expand into an
9712 immediate RTL constant, expand it now. Expanding anything else
9713 tends to produce unresolved symbols; see debug/5770 and c++/6381. */
9714 else if (TREE_CODE (DECL_INITIAL (decl
)) == INTEGER_CST
9715 || TREE_CODE (DECL_INITIAL (decl
)) == REAL_CST
)
9717 rtl
= expand_expr (DECL_INITIAL (decl
), NULL_RTX
, VOIDmode
,
9718 EXPAND_INITIALIZER
);
9719 /* If expand_expr returns a MEM, it wasn't immediate. */
9720 if (rtl
&& GET_CODE (rtl
) == MEM
)
9726 rtl
= (*targetm
.delegitimize_address
) (rtl
);
9728 /* If we don't look past the constant pool, we risk emitting a
9729 reference to a constant pool entry that isn't referenced from
9730 code, and thus is not emitted. */
9732 rtl
= avoid_constant_pool_reference (rtl
);
9737 /* Generate *either* a DW_AT_location attribute or else a DW_AT_const_value
9738 data attribute for a variable or a parameter. We generate the
9739 DW_AT_const_value attribute only in those cases where the given variable
9740 or parameter does not have a true "location" either in memory or in a
9741 register. This can happen (for example) when a constant is passed as an
9742 actual argument in a call to an inline function. (It's possible that
9743 these things can crop up in other ways also.) Note that one type of
9744 constant value which can be passed into an inlined function is a constant
9745 pointer. This can happen for example if an actual argument in an inlined
9746 function call evaluates to a compile-time constant address. */
9749 add_location_or_const_value_attribute (dw_die_ref die
, tree decl
,
9750 enum dwarf_attribute attr
)
9753 dw_loc_descr_ref descr
;
9754 var_loc_list
*loc_list
;
9756 if (TREE_CODE (decl
) == ERROR_MARK
)
9758 else if (TREE_CODE (decl
) != VAR_DECL
&& TREE_CODE (decl
) != PARM_DECL
)
9761 /* See if we possibly have multiple locations for this variable. */
9762 loc_list
= lookup_decl_loc (decl
);
9764 /* If it truly has multiple locations, the first and last node will
9766 if (loc_list
&& loc_list
->first
!= loc_list
->last
)
9768 const char *secname
;
9769 const char *endname
;
9770 dw_loc_list_ref list
;
9772 struct var_loc_node
*node
;
9774 /* We need to figure out what section we should use as the base
9775 for the address ranges where a given location is valid.
9776 1. If this particular DECL has a section associated with it,
9778 2. If this function has a section associated with it, use
9780 3. Otherwise, use the text section.
9781 XXX: If you split a variable across multiple sections, this
9784 if (DECL_SECTION_NAME (decl
))
9786 tree sectree
= DECL_SECTION_NAME (decl
);
9787 secname
= TREE_STRING_POINTER (sectree
);
9789 else if (current_function_decl
9790 && DECL_SECTION_NAME (current_function_decl
))
9792 tree sectree
= DECL_SECTION_NAME (current_function_decl
);
9793 secname
= TREE_STRING_POINTER (sectree
);
9796 secname
= text_section_label
;
9798 /* Now that we know what section we are using for a base,
9799 actually construct the list of locations.
9800 The first location information is what is passed to the
9801 function that creates the location list, and the remaining
9802 locations just get added on to that list.
9803 Note that we only know the start address for a location
9804 (IE location changes), so to build the range, we use
9805 the range [current location start, next location start].
9806 This means we have to special case the last node, and generate
9807 a range of [last location start, end of function label]. */
9809 node
= loc_list
->first
;
9810 varloc
= NOTE_VAR_LOCATION (node
->var_loc_note
);
9811 list
= new_loc_list (loc_descriptor (varloc
, attr
!= DW_AT_frame_base
),
9812 node
->label
, node
->next
->label
, secname
, 1);
9815 for (; node
->next
; node
= node
->next
)
9816 if (NOTE_VAR_LOCATION_LOC (node
->var_loc_note
) != NULL_RTX
)
9818 /* The variable has a location between NODE->LABEL and
9819 NODE->NEXT->LABEL. */
9820 varloc
= NOTE_VAR_LOCATION (node
->var_loc_note
);
9821 add_loc_descr_to_loc_list (&list
,
9822 loc_descriptor (varloc
,
9823 attr
!= DW_AT_frame_base
),
9824 node
->label
, node
->next
->label
, secname
);
9827 /* If the variable has a location at the last label
9828 it keeps its location until the end of function. */
9829 if (NOTE_VAR_LOCATION_LOC (node
->var_loc_note
) != NULL_RTX
)
9831 char label_id
[MAX_ARTIFICIAL_LABEL_BYTES
];
9833 varloc
= NOTE_VAR_LOCATION (node
->var_loc_note
);
9834 if (!current_function_decl
)
9835 endname
= text_end_label
;
9838 ASM_GENERATE_INTERNAL_LABEL (label_id
, FUNC_END_LABEL
,
9839 current_function_funcdef_no
);
9840 endname
= ggc_strdup (label_id
);
9842 add_loc_descr_to_loc_list (&list
,
9843 loc_descriptor (varloc
,
9844 attr
!= DW_AT_frame_base
),
9845 node
->label
, endname
, secname
);
9848 /* Finally, add the location list to the DIE, and we are done. */
9849 add_AT_loc_list (die
, attr
, list
);
9853 rtl
= rtl_for_decl_location (decl
);
9854 if (rtl
== NULL_RTX
)
9857 switch (GET_CODE (rtl
))
9860 /* The address of a variable that was optimized away;
9861 don't emit anything. */
9872 /* DECL_RTL could be (plus (reg ...) (const_int ...)) */
9873 add_const_value_attribute (die
, rtl
);
9877 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_THREAD_LOCAL (decl
))
9879 /* Need loc_descriptor_from_tree since that's where we know
9880 how to handle TLS variables. Want the object's address
9881 since the top-level DW_AT_location assumes such. See
9882 the confusion in loc_descriptor for reference. */
9883 descr
= loc_descriptor_from_tree (decl
, 1);
9890 descr
= loc_descriptor (rtl
, true);
9892 add_AT_location_description (die
, attr
, descr
);
9897 rtvec par_elems
= XVEC (rtl
, 0);
9898 int num_elem
= GET_NUM_ELEM (par_elems
);
9899 enum machine_mode mode
;
9902 /* Create the first one, so we have something to add to. */
9903 descr
= loc_descriptor (XEXP (RTVEC_ELT (par_elems
, 0), 0), true);
9904 mode
= GET_MODE (XEXP (RTVEC_ELT (par_elems
, 0), 0));
9905 add_loc_descr (&descr
,
9906 new_loc_descr (DW_OP_piece
, GET_MODE_SIZE (mode
), 0));
9907 for (i
= 1; i
< num_elem
; i
++)
9909 dw_loc_descr_ref temp
;
9911 temp
= loc_descriptor (XEXP (RTVEC_ELT (par_elems
, i
), 0), true);
9912 add_loc_descr (&descr
, temp
);
9913 mode
= GET_MODE (XEXP (RTVEC_ELT (par_elems
, i
), 0));
9914 add_loc_descr (&descr
,
9915 new_loc_descr (DW_OP_piece
,
9916 GET_MODE_SIZE (mode
), 0));
9919 add_AT_location_description (die
, DW_AT_location
, descr
);
9927 /* If we don't have a copy of this variable in memory for some reason (such
9928 as a C++ member constant that doesn't have an out-of-line definition),
9929 we should tell the debugger about the constant value. */
9932 tree_add_const_value_attribute (dw_die_ref var_die
, tree decl
)
9934 tree init
= DECL_INITIAL (decl
);
9935 tree type
= TREE_TYPE (decl
);
9937 if (TREE_READONLY (decl
) && ! TREE_THIS_VOLATILE (decl
) && init
9938 && initializer_constant_valid_p (init
, type
) == null_pointer_node
)
9943 switch (TREE_CODE (type
))
9946 if (host_integerp (init
, 0))
9947 add_AT_unsigned (var_die
, DW_AT_const_value
,
9948 tree_low_cst (init
, 0));
9950 add_AT_long_long (var_die
, DW_AT_const_value
,
9951 TREE_INT_CST_HIGH (init
),
9952 TREE_INT_CST_LOW (init
));
9959 /* Generate a DW_AT_name attribute given some string value to be included as
9960 the value of the attribute. */
9963 add_name_attribute (dw_die_ref die
, const char *name_string
)
9965 if (name_string
!= NULL
&& *name_string
!= 0)
9967 if (demangle_name_func
)
9968 name_string
= (*demangle_name_func
) (name_string
);
9970 add_AT_string (die
, DW_AT_name
, name_string
);
9974 /* Generate a DW_AT_comp_dir attribute for DIE. */
9977 add_comp_dir_attribute (dw_die_ref die
)
9979 const char *wd
= get_src_pwd ();
9981 add_AT_string (die
, DW_AT_comp_dir
, wd
);
9984 /* Given a tree node describing an array bound (either lower or upper) output
9985 a representation for that bound. */
9988 add_bound_info (dw_die_ref subrange_die
, enum dwarf_attribute bound_attr
, tree bound
)
9990 switch (TREE_CODE (bound
))
9995 /* All fixed-bounds are represented by INTEGER_CST nodes. */
9997 if (! host_integerp (bound
, 0)
9998 || (bound_attr
== DW_AT_lower_bound
9999 && (((is_c_family () || is_java ()) && integer_zerop (bound
))
10000 || (is_fortran () && integer_onep (bound
)))))
10001 /* Use the default. */
10004 add_AT_unsigned (subrange_die
, bound_attr
, tree_low_cst (bound
, 0));
10009 case NON_LVALUE_EXPR
:
10010 case VIEW_CONVERT_EXPR
:
10011 add_bound_info (subrange_die
, bound_attr
, TREE_OPERAND (bound
, 0));
10015 /* If optimization is turned on, the SAVE_EXPRs that describe how to
10016 access the upper bound values may be bogus. If they refer to a
10017 register, they may only describe how to get at these values at the
10018 points in the generated code right after they have just been
10019 computed. Worse yet, in the typical case, the upper bound values
10020 will not even *be* computed in the optimized code (though the
10021 number of elements will), so these SAVE_EXPRs are entirely
10022 bogus. In order to compensate for this fact, we check here to see
10023 if optimization is enabled, and if so, we don't add an attribute
10024 for the (unknown and unknowable) upper bound. This should not
10025 cause too much trouble for existing (stupid?) debuggers because
10026 they have to deal with empty upper bounds location descriptions
10027 anyway in order to be able to deal with incomplete array types.
10028 Of course an intelligent debugger (GDB?) should be able to
10029 comprehend that a missing upper bound specification in an array
10030 type used for a storage class `auto' local array variable
10031 indicates that the upper bound is both unknown (at compile- time)
10032 and unknowable (at run-time) due to optimization.
10034 We assume that a MEM rtx is safe because gcc wouldn't put the
10035 value there unless it was going to be used repeatedly in the
10036 function, i.e. for cleanups. */
10037 if (SAVE_EXPR_RTL (bound
)
10038 && (! optimize
|| GET_CODE (SAVE_EXPR_RTL (bound
)) == MEM
))
10040 dw_die_ref ctx
= lookup_decl_die (current_function_decl
);
10041 dw_die_ref decl_die
= new_die (DW_TAG_variable
, ctx
, bound
);
10042 rtx loc
= SAVE_EXPR_RTL (bound
);
10044 /* If the RTL for the SAVE_EXPR is memory, handle the case where
10045 it references an outer function's frame. */
10046 if (GET_CODE (loc
) == MEM
)
10048 rtx new_addr
= fix_lexical_addr (XEXP (loc
, 0), bound
);
10050 if (XEXP (loc
, 0) != new_addr
)
10051 loc
= gen_rtx_MEM (GET_MODE (loc
), new_addr
);
10054 add_AT_flag (decl_die
, DW_AT_artificial
, 1);
10055 add_type_attribute (decl_die
, TREE_TYPE (bound
), 1, 0, ctx
);
10056 add_AT_location_description (decl_die
, DW_AT_location
,
10057 loc_descriptor (loc
, true));
10058 add_AT_die_ref (subrange_die
, bound_attr
, decl_die
);
10061 /* Else leave out the attribute. */
10067 dw_die_ref decl_die
= lookup_decl_die (bound
);
10069 /* ??? Can this happen, or should the variable have been bound
10070 first? Probably it can, since I imagine that we try to create
10071 the types of parameters in the order in which they exist in
10072 the list, and won't have created a forward reference to a
10073 later parameter. */
10074 if (decl_die
!= NULL
)
10075 add_AT_die_ref (subrange_die
, bound_attr
, decl_die
);
10081 /* Otherwise try to create a stack operation procedure to
10082 evaluate the value of the array bound. */
10084 dw_die_ref ctx
, decl_die
;
10085 dw_loc_descr_ref loc
;
10087 loc
= loc_descriptor_from_tree (bound
, 0);
10091 if (current_function_decl
== 0)
10092 ctx
= comp_unit_die
;
10094 ctx
= lookup_decl_die (current_function_decl
);
10096 /* If we weren't able to find a context, it's most likely the case
10097 that we are processing the return type of the function. So
10098 make a SAVE_EXPR to point to it and have the limbo DIE code
10099 find the proper die. The save_expr function doesn't always
10100 make a SAVE_EXPR, so do it ourselves. */
10102 bound
= build (SAVE_EXPR
, TREE_TYPE (bound
), bound
,
10103 current_function_decl
, NULL_TREE
);
10105 decl_die
= new_die (DW_TAG_variable
, ctx
, bound
);
10106 add_AT_flag (decl_die
, DW_AT_artificial
, 1);
10107 add_type_attribute (decl_die
, TREE_TYPE (bound
), 1, 0, ctx
);
10108 add_AT_loc (decl_die
, DW_AT_location
, loc
);
10110 add_AT_die_ref (subrange_die
, bound_attr
, decl_die
);
10116 /* Note that the block of subscript information for an array type also
10117 includes information about the element type of type given array type. */
10120 add_subscript_info (dw_die_ref type_die
, tree type
)
10122 #ifndef MIPS_DEBUGGING_INFO
10123 unsigned dimension_number
;
10126 dw_die_ref subrange_die
;
10128 /* The GNU compilers represent multidimensional array types as sequences of
10129 one dimensional array types whose element types are themselves array
10130 types. Here we squish that down, so that each multidimensional array
10131 type gets only one array_type DIE in the Dwarf debugging info. The draft
10132 Dwarf specification say that we are allowed to do this kind of
10133 compression in C (because there is no difference between an array or
10134 arrays and a multidimensional array in C) but for other source languages
10135 (e.g. Ada) we probably shouldn't do this. */
10137 /* ??? The SGI dwarf reader fails for multidimensional arrays with a
10138 const enum type. E.g. const enum machine_mode insn_operand_mode[2][10].
10139 We work around this by disabling this feature. See also
10140 gen_array_type_die. */
10141 #ifndef MIPS_DEBUGGING_INFO
10142 for (dimension_number
= 0;
10143 TREE_CODE (type
) == ARRAY_TYPE
;
10144 type
= TREE_TYPE (type
), dimension_number
++)
10147 tree domain
= TYPE_DOMAIN (type
);
10149 /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
10150 and (in GNU C only) variable bounds. Handle all three forms
10152 subrange_die
= new_die (DW_TAG_subrange_type
, type_die
, NULL
);
10155 /* We have an array type with specified bounds. */
10156 lower
= TYPE_MIN_VALUE (domain
);
10157 upper
= TYPE_MAX_VALUE (domain
);
10159 /* Define the index type. */
10160 if (TREE_TYPE (domain
))
10162 /* ??? This is probably an Ada unnamed subrange type. Ignore the
10163 TREE_TYPE field. We can't emit debug info for this
10164 because it is an unnamed integral type. */
10165 if (TREE_CODE (domain
) == INTEGER_TYPE
10166 && TYPE_NAME (domain
) == NULL_TREE
10167 && TREE_CODE (TREE_TYPE (domain
)) == INTEGER_TYPE
10168 && TYPE_NAME (TREE_TYPE (domain
)) == NULL_TREE
)
10171 add_type_attribute (subrange_die
, TREE_TYPE (domain
), 0, 0,
10175 /* ??? If upper is NULL, the array has unspecified length,
10176 but it does have a lower bound. This happens with Fortran
10178 Since the debugger is definitely going to need to know N
10179 to produce useful results, go ahead and output the lower
10180 bound solo, and hope the debugger can cope. */
10182 add_bound_info (subrange_die
, DW_AT_lower_bound
, lower
);
10184 add_bound_info (subrange_die
, DW_AT_upper_bound
, upper
);
10187 /* Otherwise we have an array type with an unspecified length. The
10188 DWARF-2 spec does not say how to handle this; let's just leave out the
10194 add_byte_size_attribute (dw_die_ref die
, tree tree_node
)
10198 switch (TREE_CODE (tree_node
))
10203 case ENUMERAL_TYPE
:
10206 case QUAL_UNION_TYPE
:
10207 size
= int_size_in_bytes (tree_node
);
10210 /* For a data member of a struct or union, the DW_AT_byte_size is
10211 generally given as the number of bytes normally allocated for an
10212 object of the *declared* type of the member itself. This is true
10213 even for bit-fields. */
10214 size
= simple_type_size_in_bits (field_type (tree_node
)) / BITS_PER_UNIT
;
10220 /* Note that `size' might be -1 when we get to this point. If it is, that
10221 indicates that the byte size of the entity in question is variable. We
10222 have no good way of expressing this fact in Dwarf at the present time,
10223 so just let the -1 pass on through. */
10224 add_AT_unsigned (die
, DW_AT_byte_size
, size
);
10227 /* For a FIELD_DECL node which represents a bit-field, output an attribute
10228 which specifies the distance in bits from the highest order bit of the
10229 "containing object" for the bit-field to the highest order bit of the
10232 For any given bit-field, the "containing object" is a hypothetical object
10233 (of some integral or enum type) within which the given bit-field lives. The
10234 type of this hypothetical "containing object" is always the same as the
10235 declared type of the individual bit-field itself. The determination of the
10236 exact location of the "containing object" for a bit-field is rather
10237 complicated. It's handled by the `field_byte_offset' function (above).
10239 Note that it is the size (in bytes) of the hypothetical "containing object"
10240 which will be given in the DW_AT_byte_size attribute for this bit-field.
10241 (See `byte_size_attribute' above). */
10244 add_bit_offset_attribute (dw_die_ref die
, tree decl
)
10246 HOST_WIDE_INT object_offset_in_bytes
= field_byte_offset (decl
);
10247 tree type
= DECL_BIT_FIELD_TYPE (decl
);
10248 HOST_WIDE_INT bitpos_int
;
10249 HOST_WIDE_INT highest_order_object_bit_offset
;
10250 HOST_WIDE_INT highest_order_field_bit_offset
;
10251 HOST_WIDE_INT
unsigned bit_offset
;
10253 /* Must be a field and a bit field. */
10255 || TREE_CODE (decl
) != FIELD_DECL
)
10258 /* We can't yet handle bit-fields whose offsets are variable, so if we
10259 encounter such things, just return without generating any attribute
10260 whatsoever. Likewise for variable or too large size. */
10261 if (! host_integerp (bit_position (decl
), 0)
10262 || ! host_integerp (DECL_SIZE (decl
), 1))
10265 bitpos_int
= int_bit_position (decl
);
10267 /* Note that the bit offset is always the distance (in bits) from the
10268 highest-order bit of the "containing object" to the highest-order bit of
10269 the bit-field itself. Since the "high-order end" of any object or field
10270 is different on big-endian and little-endian machines, the computation
10271 below must take account of these differences. */
10272 highest_order_object_bit_offset
= object_offset_in_bytes
* BITS_PER_UNIT
;
10273 highest_order_field_bit_offset
= bitpos_int
;
10275 if (! BYTES_BIG_ENDIAN
)
10277 highest_order_field_bit_offset
+= tree_low_cst (DECL_SIZE (decl
), 0);
10278 highest_order_object_bit_offset
+= simple_type_size_in_bits (type
);
10282 = (! BYTES_BIG_ENDIAN
10283 ? highest_order_object_bit_offset
- highest_order_field_bit_offset
10284 : highest_order_field_bit_offset
- highest_order_object_bit_offset
);
10286 add_AT_unsigned (die
, DW_AT_bit_offset
, bit_offset
);
10289 /* For a FIELD_DECL node which represents a bit field, output an attribute
10290 which specifies the length in bits of the given field. */
10293 add_bit_size_attribute (dw_die_ref die
, tree decl
)
10295 /* Must be a field and a bit field. */
10296 if (TREE_CODE (decl
) != FIELD_DECL
10297 || ! DECL_BIT_FIELD_TYPE (decl
))
10300 if (host_integerp (DECL_SIZE (decl
), 1))
10301 add_AT_unsigned (die
, DW_AT_bit_size
, tree_low_cst (DECL_SIZE (decl
), 1));
10304 /* If the compiled language is ANSI C, then add a 'prototyped'
10305 attribute, if arg types are given for the parameters of a function. */
10308 add_prototyped_attribute (dw_die_ref die
, tree func_type
)
10310 if (get_AT_unsigned (comp_unit_die
, DW_AT_language
) == DW_LANG_C89
10311 && TYPE_ARG_TYPES (func_type
) != NULL
)
10312 add_AT_flag (die
, DW_AT_prototyped
, 1);
10315 /* Add an 'abstract_origin' attribute below a given DIE. The DIE is found
10316 by looking in either the type declaration or object declaration
10320 add_abstract_origin_attribute (dw_die_ref die
, tree origin
)
10322 dw_die_ref origin_die
= NULL
;
10324 if (TREE_CODE (origin
) != FUNCTION_DECL
)
10326 /* We may have gotten separated from the block for the inlined
10327 function, if we're in an exception handler or some such; make
10328 sure that the abstract function has been written out.
10330 Doing this for nested functions is wrong, however; functions are
10331 distinct units, and our context might not even be inline. */
10335 fn
= TYPE_STUB_DECL (fn
);
10337 fn
= decl_function_context (fn
);
10339 dwarf2out_abstract_function (fn
);
10342 if (DECL_P (origin
))
10343 origin_die
= lookup_decl_die (origin
);
10344 else if (TYPE_P (origin
))
10345 origin_die
= lookup_type_die (origin
);
10347 if (origin_die
== NULL
)
10350 add_AT_die_ref (die
, DW_AT_abstract_origin
, origin_die
);
10353 /* We do not currently support the pure_virtual attribute. */
10356 add_pure_or_virtual_attribute (dw_die_ref die
, tree func_decl
)
10358 if (DECL_VINDEX (func_decl
))
10360 add_AT_unsigned (die
, DW_AT_virtuality
, DW_VIRTUALITY_virtual
);
10362 if (host_integerp (DECL_VINDEX (func_decl
), 0))
10363 add_AT_loc (die
, DW_AT_vtable_elem_location
,
10364 new_loc_descr (DW_OP_constu
,
10365 tree_low_cst (DECL_VINDEX (func_decl
), 0),
10368 /* GNU extension: Record what type this method came from originally. */
10369 if (debug_info_level
> DINFO_LEVEL_TERSE
)
10370 add_AT_die_ref (die
, DW_AT_containing_type
,
10371 lookup_type_die (DECL_CONTEXT (func_decl
)));
10375 /* Add source coordinate attributes for the given decl. */
10378 add_src_coords_attributes (dw_die_ref die
, tree decl
)
10380 unsigned file_index
= lookup_filename (DECL_SOURCE_FILE (decl
));
10382 add_AT_unsigned (die
, DW_AT_decl_file
, file_index
);
10383 add_AT_unsigned (die
, DW_AT_decl_line
, DECL_SOURCE_LINE (decl
));
10386 /* Add a DW_AT_name attribute and source coordinate attribute for the
10387 given decl, but only if it actually has a name. */
10390 add_name_and_src_coords_attributes (dw_die_ref die
, tree decl
)
10394 decl_name
= DECL_NAME (decl
);
10395 if (decl_name
!= NULL
&& IDENTIFIER_POINTER (decl_name
) != NULL
)
10397 add_name_attribute (die
, dwarf2_name (decl
, 0));
10398 if (! DECL_ARTIFICIAL (decl
))
10399 add_src_coords_attributes (die
, decl
);
10401 if ((TREE_CODE (decl
) == FUNCTION_DECL
|| TREE_CODE (decl
) == VAR_DECL
)
10402 && TREE_PUBLIC (decl
)
10403 && DECL_ASSEMBLER_NAME (decl
) != DECL_NAME (decl
)
10404 && !DECL_ABSTRACT (decl
))
10405 add_AT_string (die
, DW_AT_MIPS_linkage_name
,
10406 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)));
10409 #ifdef VMS_DEBUGGING_INFO
10410 /* Get the function's name, as described by its RTL. This may be different
10411 from the DECL_NAME name used in the source file. */
10412 if (TREE_CODE (decl
) == FUNCTION_DECL
&& TREE_ASM_WRITTEN (decl
))
10414 add_AT_addr (die
, DW_AT_VMS_rtnbeg_pd_address
,
10415 XEXP (DECL_RTL (decl
), 0));
10416 VARRAY_PUSH_RTX (used_rtx_varray
, XEXP (DECL_RTL (decl
), 0));
10421 /* Push a new declaration scope. */
10424 push_decl_scope (tree scope
)
10426 VARRAY_PUSH_TREE (decl_scope_table
, scope
);
10429 /* Pop a declaration scope. */
10432 pop_decl_scope (void)
10434 if (VARRAY_ACTIVE_SIZE (decl_scope_table
) <= 0)
10437 VARRAY_POP (decl_scope_table
);
10440 /* Return the DIE for the scope that immediately contains this type.
10441 Non-named types get global scope. Named types nested in other
10442 types get their containing scope if it's open, or global scope
10443 otherwise. All other types (i.e. function-local named types) get
10444 the current active scope. */
10447 scope_die_for (tree t
, dw_die_ref context_die
)
10449 dw_die_ref scope_die
= NULL
;
10450 tree containing_scope
;
10453 /* Non-types always go in the current scope. */
10457 containing_scope
= TYPE_CONTEXT (t
);
10459 /* Use the containing namespace if it was passed in (for a declaration). */
10460 if (containing_scope
&& TREE_CODE (containing_scope
) == NAMESPACE_DECL
)
10462 if (context_die
== lookup_decl_die (containing_scope
))
10465 containing_scope
= NULL_TREE
;
10468 /* Ignore function type "scopes" from the C frontend. They mean that
10469 a tagged type is local to a parmlist of a function declarator, but
10470 that isn't useful to DWARF. */
10471 if (containing_scope
&& TREE_CODE (containing_scope
) == FUNCTION_TYPE
)
10472 containing_scope
= NULL_TREE
;
10474 if (containing_scope
== NULL_TREE
)
10475 scope_die
= comp_unit_die
;
10476 else if (TYPE_P (containing_scope
))
10478 /* For types, we can just look up the appropriate DIE. But
10479 first we check to see if we're in the middle of emitting it
10480 so we know where the new DIE should go. */
10481 for (i
= VARRAY_ACTIVE_SIZE (decl_scope_table
) - 1; i
>= 0; --i
)
10482 if (VARRAY_TREE (decl_scope_table
, i
) == containing_scope
)
10487 if (debug_info_level
> DINFO_LEVEL_TERSE
10488 && !TREE_ASM_WRITTEN (containing_scope
))
10491 /* If none of the current dies are suitable, we get file scope. */
10492 scope_die
= comp_unit_die
;
10495 scope_die
= lookup_type_die (containing_scope
);
10498 scope_die
= context_die
;
10503 /* Returns nonzero if CONTEXT_DIE is internal to a function. */
10506 local_scope_p (dw_die_ref context_die
)
10508 for (; context_die
; context_die
= context_die
->die_parent
)
10509 if (context_die
->die_tag
== DW_TAG_inlined_subroutine
10510 || context_die
->die_tag
== DW_TAG_subprogram
)
10516 /* Returns nonzero if CONTEXT_DIE is a class or namespace, for deciding
10517 whether or not to treat a DIE in this context as a declaration. */
10520 class_or_namespace_scope_p (dw_die_ref context_die
)
10522 return (context_die
10523 && (context_die
->die_tag
== DW_TAG_structure_type
10524 || context_die
->die_tag
== DW_TAG_union_type
10525 || context_die
->die_tag
== DW_TAG_namespace
));
10528 /* Many forms of DIEs require a "type description" attribute. This
10529 routine locates the proper "type descriptor" die for the type given
10530 by 'type', and adds a DW_AT_type attribute below the given die. */
10533 add_type_attribute (dw_die_ref object_die
, tree type
, int decl_const
,
10534 int decl_volatile
, dw_die_ref context_die
)
10536 enum tree_code code
= TREE_CODE (type
);
10537 dw_die_ref type_die
= NULL
;
10539 /* ??? If this type is an unnamed subrange type of an integral or
10540 floating-point type, use the inner type. This is because we have no
10541 support for unnamed types in base_type_die. This can happen if this is
10542 an Ada subrange type. Correct solution is emit a subrange type die. */
10543 if ((code
== INTEGER_TYPE
|| code
== REAL_TYPE
)
10544 && TREE_TYPE (type
) != 0 && TYPE_NAME (type
) == 0)
10545 type
= TREE_TYPE (type
), code
= TREE_CODE (type
);
10547 if (code
== ERROR_MARK
10548 /* Handle a special case. For functions whose return type is void, we
10549 generate *no* type attribute. (Note that no object may have type
10550 `void', so this only applies to function return types). */
10551 || code
== VOID_TYPE
)
10554 type_die
= modified_type_die (type
,
10555 decl_const
|| TYPE_READONLY (type
),
10556 decl_volatile
|| TYPE_VOLATILE (type
),
10559 if (type_die
!= NULL
)
10560 add_AT_die_ref (object_die
, DW_AT_type
, type_die
);
10563 /* Given a tree pointer to a struct, class, union, or enum type node, return
10564 a pointer to the (string) tag name for the given type, or zero if the type
10565 was declared without a tag. */
10567 static const char *
10568 type_tag (tree type
)
10570 const char *name
= 0;
10572 if (TYPE_NAME (type
) != 0)
10576 /* Find the IDENTIFIER_NODE for the type name. */
10577 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
10578 t
= TYPE_NAME (type
);
10580 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
10581 a TYPE_DECL node, regardless of whether or not a `typedef' was
10583 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
10584 && ! DECL_IGNORED_P (TYPE_NAME (type
)))
10585 t
= DECL_NAME (TYPE_NAME (type
));
10587 /* Now get the name as a string, or invent one. */
10589 name
= IDENTIFIER_POINTER (t
);
10592 return (name
== 0 || *name
== '\0') ? 0 : name
;
10595 /* Return the type associated with a data member, make a special check
10596 for bit field types. */
10599 member_declared_type (tree member
)
10601 return (DECL_BIT_FIELD_TYPE (member
)
10602 ? DECL_BIT_FIELD_TYPE (member
) : TREE_TYPE (member
));
10605 /* Get the decl's label, as described by its RTL. This may be different
10606 from the DECL_NAME name used in the source file. */
10609 static const char *
10610 decl_start_label (tree decl
)
10613 const char *fnname
;
10615 x
= DECL_RTL (decl
);
10616 if (GET_CODE (x
) != MEM
)
10620 if (GET_CODE (x
) != SYMBOL_REF
)
10623 fnname
= XSTR (x
, 0);
10628 /* These routines generate the internal representation of the DIE's for
10629 the compilation unit. Debugging information is collected by walking
10630 the declaration trees passed in from dwarf2out_decl(). */
10633 gen_array_type_die (tree type
, dw_die_ref context_die
)
10635 dw_die_ref scope_die
= scope_die_for (type
, context_die
);
10636 dw_die_ref array_die
;
10639 /* ??? The SGI dwarf reader fails for array of array of enum types unless
10640 the inner array type comes before the outer array type. Thus we must
10641 call gen_type_die before we call new_die. See below also. */
10642 #ifdef MIPS_DEBUGGING_INFO
10643 gen_type_die (TREE_TYPE (type
), context_die
);
10646 array_die
= new_die (DW_TAG_array_type
, scope_die
, type
);
10647 add_name_attribute (array_die
, type_tag (type
));
10648 equate_type_number_to_die (type
, array_die
);
10650 if (TREE_CODE (type
) == VECTOR_TYPE
)
10652 /* The frontend feeds us a representation for the vector as a struct
10653 containing an array. Pull out the array type. */
10654 type
= TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type
)));
10655 add_AT_flag (array_die
, DW_AT_GNU_vector
, 1);
10659 /* We default the array ordering. SDB will probably do
10660 the right things even if DW_AT_ordering is not present. It's not even
10661 an issue until we start to get into multidimensional arrays anyway. If
10662 SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
10663 then we'll have to put the DW_AT_ordering attribute back in. (But if
10664 and when we find out that we need to put these in, we will only do so
10665 for multidimensional arrays. */
10666 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_row_major
);
10669 #ifdef MIPS_DEBUGGING_INFO
10670 /* The SGI compilers handle arrays of unknown bound by setting
10671 AT_declaration and not emitting any subrange DIEs. */
10672 if (! TYPE_DOMAIN (type
))
10673 add_AT_flag (array_die
, DW_AT_declaration
, 1);
10676 add_subscript_info (array_die
, type
);
10678 /* Add representation of the type of the elements of this array type. */
10679 element_type
= TREE_TYPE (type
);
10681 /* ??? The SGI dwarf reader fails for multidimensional arrays with a
10682 const enum type. E.g. const enum machine_mode insn_operand_mode[2][10].
10683 We work around this by disabling this feature. See also
10684 add_subscript_info. */
10685 #ifndef MIPS_DEBUGGING_INFO
10686 while (TREE_CODE (element_type
) == ARRAY_TYPE
)
10687 element_type
= TREE_TYPE (element_type
);
10689 gen_type_die (element_type
, context_die
);
10692 add_type_attribute (array_die
, element_type
, 0, 0, context_die
);
10696 gen_set_type_die (tree type
, dw_die_ref context_die
)
10698 dw_die_ref type_die
10699 = new_die (DW_TAG_set_type
, scope_die_for (type
, context_die
), type
);
10701 equate_type_number_to_die (type
, type_die
);
10702 add_type_attribute (type_die
, TREE_TYPE (type
), 0, 0, context_die
);
10707 gen_entry_point_die (tree decl
, dw_die_ref context_die
)
10709 tree origin
= decl_ultimate_origin (decl
);
10710 dw_die_ref decl_die
= new_die (DW_TAG_entry_point
, context_die
, decl
);
10712 if (origin
!= NULL
)
10713 add_abstract_origin_attribute (decl_die
, origin
);
10716 add_name_and_src_coords_attributes (decl_die
, decl
);
10717 add_type_attribute (decl_die
, TREE_TYPE (TREE_TYPE (decl
)),
10718 0, 0, context_die
);
10721 if (DECL_ABSTRACT (decl
))
10722 equate_decl_number_to_die (decl
, decl_die
);
10724 add_AT_lbl_id (decl_die
, DW_AT_low_pc
, decl_start_label (decl
));
10728 /* Walk through the list of incomplete types again, trying once more to
10729 emit full debugging info for them. */
10732 retry_incomplete_types (void)
10736 for (i
= VARRAY_ACTIVE_SIZE (incomplete_types
) - 1; i
>= 0; i
--)
10737 gen_type_die (VARRAY_TREE (incomplete_types
, i
), comp_unit_die
);
10740 /* Generate a DIE to represent an inlined instance of an enumeration type. */
10743 gen_inlined_enumeration_type_die (tree type
, dw_die_ref context_die
)
10745 dw_die_ref type_die
= new_die (DW_TAG_enumeration_type
, context_die
, type
);
10747 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
10748 be incomplete and such types are not marked. */
10749 add_abstract_origin_attribute (type_die
, type
);
10752 /* Generate a DIE to represent an inlined instance of a structure type. */
10755 gen_inlined_structure_type_die (tree type
, dw_die_ref context_die
)
10757 dw_die_ref type_die
= new_die (DW_TAG_structure_type
, context_die
, type
);
10759 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
10760 be incomplete and such types are not marked. */
10761 add_abstract_origin_attribute (type_die
, type
);
10764 /* Generate a DIE to represent an inlined instance of a union type. */
10767 gen_inlined_union_type_die (tree type
, dw_die_ref context_die
)
10769 dw_die_ref type_die
= new_die (DW_TAG_union_type
, context_die
, type
);
10771 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
10772 be incomplete and such types are not marked. */
10773 add_abstract_origin_attribute (type_die
, type
);
10776 /* Generate a DIE to represent an enumeration type. Note that these DIEs
10777 include all of the information about the enumeration values also. Each
10778 enumerated type name/value is listed as a child of the enumerated type
10782 gen_enumeration_type_die (tree type
, dw_die_ref context_die
)
10784 dw_die_ref type_die
= lookup_type_die (type
);
10786 if (type_die
== NULL
)
10788 type_die
= new_die (DW_TAG_enumeration_type
,
10789 scope_die_for (type
, context_die
), type
);
10790 equate_type_number_to_die (type
, type_die
);
10791 add_name_attribute (type_die
, type_tag (type
));
10793 else if (! TYPE_SIZE (type
))
10796 remove_AT (type_die
, DW_AT_declaration
);
10798 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the
10799 given enum type is incomplete, do not generate the DW_AT_byte_size
10800 attribute or the DW_AT_element_list attribute. */
10801 if (TYPE_SIZE (type
))
10805 TREE_ASM_WRITTEN (type
) = 1;
10806 add_byte_size_attribute (type_die
, type
);
10807 if (TYPE_STUB_DECL (type
) != NULL_TREE
)
10808 add_src_coords_attributes (type_die
, TYPE_STUB_DECL (type
));
10810 /* If the first reference to this type was as the return type of an
10811 inline function, then it may not have a parent. Fix this now. */
10812 if (type_die
->die_parent
== NULL
)
10813 add_child_die (scope_die_for (type
, context_die
), type_die
);
10815 for (link
= TYPE_FIELDS (type
);
10816 link
!= NULL
; link
= TREE_CHAIN (link
))
10818 dw_die_ref enum_die
= new_die (DW_TAG_enumerator
, type_die
, link
);
10819 tree value
= TREE_VALUE (link
);
10821 add_name_attribute (enum_die
,
10822 IDENTIFIER_POINTER (TREE_PURPOSE (link
)));
10824 if (host_integerp (value
, TREE_UNSIGNED (TREE_TYPE (value
))))
10825 /* DWARF2 does not provide a way of indicating whether or
10826 not enumeration constants are signed or unsigned. GDB
10827 always assumes the values are signed, so we output all
10828 values as if they were signed. That means that
10829 enumeration constants with very large unsigned values
10830 will appear to have negative values in the debugger. */
10831 add_AT_int (enum_die
, DW_AT_const_value
,
10832 tree_low_cst (value
, tree_int_cst_sgn (value
) > 0));
10836 add_AT_flag (type_die
, DW_AT_declaration
, 1);
10841 /* Generate a DIE to represent either a real live formal parameter decl or to
10842 represent just the type of some formal parameter position in some function
10845 Note that this routine is a bit unusual because its argument may be a
10846 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
10847 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
10848 node. If it's the former then this function is being called to output a
10849 DIE to represent a formal parameter object (or some inlining thereof). If
10850 it's the latter, then this function is only being called to output a
10851 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
10852 argument type of some subprogram type. */
10855 gen_formal_parameter_die (tree node
, dw_die_ref context_die
)
10857 dw_die_ref parm_die
10858 = new_die (DW_TAG_formal_parameter
, context_die
, node
);
10861 switch (TREE_CODE_CLASS (TREE_CODE (node
)))
10864 origin
= decl_ultimate_origin (node
);
10865 if (origin
!= NULL
)
10866 add_abstract_origin_attribute (parm_die
, origin
);
10869 add_name_and_src_coords_attributes (parm_die
, node
);
10870 add_type_attribute (parm_die
, TREE_TYPE (node
),
10871 TREE_READONLY (node
),
10872 TREE_THIS_VOLATILE (node
),
10874 if (DECL_ARTIFICIAL (node
))
10875 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
10878 equate_decl_number_to_die (node
, parm_die
);
10879 if (! DECL_ABSTRACT (node
))
10880 add_location_or_const_value_attribute (parm_die
, node
, DW_AT_location
);
10885 /* We were called with some kind of a ..._TYPE node. */
10886 add_type_attribute (parm_die
, node
, 0, 0, context_die
);
10896 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
10897 at the end of an (ANSI prototyped) formal parameters list. */
10900 gen_unspecified_parameters_die (tree decl_or_type
, dw_die_ref context_die
)
10902 new_die (DW_TAG_unspecified_parameters
, context_die
, decl_or_type
);
10905 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
10906 DW_TAG_unspecified_parameters DIE) to represent the types of the formal
10907 parameters as specified in some function type specification (except for
10908 those which appear as part of a function *definition*). */
10911 gen_formal_types_die (tree function_or_method_type
, dw_die_ref context_die
)
10914 tree formal_type
= NULL
;
10915 tree first_parm_type
;
10918 if (TREE_CODE (function_or_method_type
) == FUNCTION_DECL
)
10920 arg
= DECL_ARGUMENTS (function_or_method_type
);
10921 function_or_method_type
= TREE_TYPE (function_or_method_type
);
10926 first_parm_type
= TYPE_ARG_TYPES (function_or_method_type
);
10928 /* Make our first pass over the list of formal parameter types and output a
10929 DW_TAG_formal_parameter DIE for each one. */
10930 for (link
= first_parm_type
; link
; )
10932 dw_die_ref parm_die
;
10934 formal_type
= TREE_VALUE (link
);
10935 if (formal_type
== void_type_node
)
10938 /* Output a (nameless) DIE to represent the formal parameter itself. */
10939 parm_die
= gen_formal_parameter_die (formal_type
, context_die
);
10940 if ((TREE_CODE (function_or_method_type
) == METHOD_TYPE
10941 && link
== first_parm_type
)
10942 || (arg
&& DECL_ARTIFICIAL (arg
)))
10943 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
10945 link
= TREE_CHAIN (link
);
10947 arg
= TREE_CHAIN (arg
);
10950 /* If this function type has an ellipsis, add a
10951 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */
10952 if (formal_type
!= void_type_node
)
10953 gen_unspecified_parameters_die (function_or_method_type
, context_die
);
10955 /* Make our second (and final) pass over the list of formal parameter types
10956 and output DIEs to represent those types (as necessary). */
10957 for (link
= TYPE_ARG_TYPES (function_or_method_type
);
10958 link
&& TREE_VALUE (link
);
10959 link
= TREE_CHAIN (link
))
10960 gen_type_die (TREE_VALUE (link
), context_die
);
10963 /* We want to generate the DIE for TYPE so that we can generate the
10964 die for MEMBER, which has been defined; we will need to refer back
10965 to the member declaration nested within TYPE. If we're trying to
10966 generate minimal debug info for TYPE, processing TYPE won't do the
10967 trick; we need to attach the member declaration by hand. */
10970 gen_type_die_for_member (tree type
, tree member
, dw_die_ref context_die
)
10972 gen_type_die (type
, context_die
);
10974 /* If we're trying to avoid duplicate debug info, we may not have
10975 emitted the member decl for this function. Emit it now. */
10976 if (TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type
))
10977 && ! lookup_decl_die (member
))
10979 if (decl_ultimate_origin (member
))
10982 push_decl_scope (type
);
10983 if (TREE_CODE (member
) == FUNCTION_DECL
)
10984 gen_subprogram_die (member
, lookup_type_die (type
));
10986 gen_variable_die (member
, lookup_type_die (type
));
10992 /* Generate the DWARF2 info for the "abstract" instance of a function which we
10993 may later generate inlined and/or out-of-line instances of. */
10996 dwarf2out_abstract_function (tree decl
)
10998 dw_die_ref old_die
;
11001 int was_abstract
= DECL_ABSTRACT (decl
);
11003 /* Make sure we have the actual abstract inline, not a clone. */
11004 decl
= DECL_ORIGIN (decl
);
11006 old_die
= lookup_decl_die (decl
);
11007 if (old_die
&& get_AT (old_die
, DW_AT_inline
))
11008 /* We've already generated the abstract instance. */
11011 /* Be sure we've emitted the in-class declaration DIE (if any) first, so
11012 we don't get confused by DECL_ABSTRACT. */
11013 if (debug_info_level
> DINFO_LEVEL_TERSE
)
11015 context
= decl_class_context (decl
);
11017 gen_type_die_for_member
11018 (context
, decl
, decl_function_context (decl
) ? NULL
: comp_unit_die
);
11021 /* Pretend we've just finished compiling this function. */
11022 save_fn
= current_function_decl
;
11023 current_function_decl
= decl
;
11025 set_decl_abstract_flags (decl
, 1);
11026 dwarf2out_decl (decl
);
11027 if (! was_abstract
)
11028 set_decl_abstract_flags (decl
, 0);
11030 current_function_decl
= save_fn
;
11033 /* Generate a DIE to represent a declared function (either file-scope or
11037 gen_subprogram_die (tree decl
, dw_die_ref context_die
)
11039 char label_id
[MAX_ARTIFICIAL_LABEL_BYTES
];
11040 tree origin
= decl_ultimate_origin (decl
);
11041 dw_die_ref subr_die
;
11045 dw_die_ref old_die
= lookup_decl_die (decl
);
11046 int declaration
= (current_function_decl
!= decl
11047 || class_or_namespace_scope_p (context_die
));
11049 /* It is possible to have both DECL_ABSTRACT and DECLARATION be true if we
11050 started to generate the abstract instance of an inline, decided to output
11051 its containing class, and proceeded to emit the declaration of the inline
11052 from the member list for the class. If so, DECLARATION takes priority;
11053 we'll get back to the abstract instance when done with the class. */
11055 /* The class-scope declaration DIE must be the primary DIE. */
11056 if (origin
&& declaration
&& class_or_namespace_scope_p (context_die
))
11063 if (origin
!= NULL
)
11065 if (declaration
&& ! local_scope_p (context_die
))
11068 /* Fixup die_parent for the abstract instance of a nested
11069 inline function. */
11070 if (old_die
&& old_die
->die_parent
== NULL
)
11071 add_child_die (context_die
, old_die
);
11073 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
11074 add_abstract_origin_attribute (subr_die
, origin
);
11078 unsigned file_index
= lookup_filename (DECL_SOURCE_FILE (decl
));
11080 if (!get_AT_flag (old_die
, DW_AT_declaration
)
11081 /* We can have a normal definition following an inline one in the
11082 case of redefinition of GNU C extern inlines.
11083 It seems reasonable to use AT_specification in this case. */
11084 && !get_AT (old_die
, DW_AT_inline
))
11086 /* ??? This can happen if there is a bug in the program, for
11087 instance, if it has duplicate function definitions. Ideally,
11088 we should detect this case and ignore it. For now, if we have
11089 already reported an error, any error at all, then assume that
11090 we got here because of an input error, not a dwarf2 bug. */
11096 /* If the definition comes from the same place as the declaration,
11097 maybe use the old DIE. We always want the DIE for this function
11098 that has the *_pc attributes to be under comp_unit_die so the
11099 debugger can find it. We also need to do this for abstract
11100 instances of inlines, since the spec requires the out-of-line copy
11101 to have the same parent. For local class methods, this doesn't
11102 apply; we just use the old DIE. */
11103 if ((old_die
->die_parent
== comp_unit_die
|| context_die
== NULL
)
11104 && (DECL_ARTIFICIAL (decl
)
11105 || (get_AT_unsigned (old_die
, DW_AT_decl_file
) == file_index
11106 && (get_AT_unsigned (old_die
, DW_AT_decl_line
)
11107 == (unsigned) DECL_SOURCE_LINE (decl
)))))
11109 subr_die
= old_die
;
11111 /* Clear out the declaration attribute and the formal parameters.
11112 Do not remove all children, because it is possible that this
11113 declaration die was forced using force_decl_die(). In such
11114 cases die that forced declaration die (e.g. TAG_imported_module)
11115 is one of the children that we do not want to remove. */
11116 remove_AT (subr_die
, DW_AT_declaration
);
11117 remove_child_TAG (subr_die
, DW_TAG_formal_parameter
);
11121 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
11122 add_AT_specification (subr_die
, old_die
);
11123 if (get_AT_unsigned (old_die
, DW_AT_decl_file
) != file_index
)
11124 add_AT_unsigned (subr_die
, DW_AT_decl_file
, file_index
);
11125 if (get_AT_unsigned (old_die
, DW_AT_decl_line
)
11126 != (unsigned) DECL_SOURCE_LINE (decl
))
11128 (subr_die
, DW_AT_decl_line
, DECL_SOURCE_LINE (decl
));
11133 subr_die
= new_die (DW_TAG_subprogram
, context_die
, decl
);
11135 if (TREE_PUBLIC (decl
))
11136 add_AT_flag (subr_die
, DW_AT_external
, 1);
11138 add_name_and_src_coords_attributes (subr_die
, decl
);
11139 if (debug_info_level
> DINFO_LEVEL_TERSE
)
11141 add_prototyped_attribute (subr_die
, TREE_TYPE (decl
));
11142 add_type_attribute (subr_die
, TREE_TYPE (TREE_TYPE (decl
)),
11143 0, 0, context_die
);
11146 add_pure_or_virtual_attribute (subr_die
, decl
);
11147 if (DECL_ARTIFICIAL (decl
))
11148 add_AT_flag (subr_die
, DW_AT_artificial
, 1);
11150 if (TREE_PROTECTED (decl
))
11151 add_AT_unsigned (subr_die
, DW_AT_accessibility
, DW_ACCESS_protected
);
11152 else if (TREE_PRIVATE (decl
))
11153 add_AT_unsigned (subr_die
, DW_AT_accessibility
, DW_ACCESS_private
);
11158 if (!old_die
|| !get_AT (old_die
, DW_AT_inline
))
11160 add_AT_flag (subr_die
, DW_AT_declaration
, 1);
11162 /* The first time we see a member function, it is in the context of
11163 the class to which it belongs. We make sure of this by emitting
11164 the class first. The next time is the definition, which is
11165 handled above. The two may come from the same source text.
11167 Note that force_decl_die() forces function declaration die. It is
11168 later reused to represent definition. */
11169 equate_decl_number_to_die (decl
, subr_die
);
11172 else if (DECL_ABSTRACT (decl
))
11174 if (DECL_DECLARED_INLINE_P (decl
))
11176 if (cgraph_function_possibly_inlined_p (decl
))
11177 add_AT_unsigned (subr_die
, DW_AT_inline
, DW_INL_declared_inlined
);
11179 add_AT_unsigned (subr_die
, DW_AT_inline
, DW_INL_declared_not_inlined
);
11183 if (cgraph_function_possibly_inlined_p (decl
))
11184 add_AT_unsigned (subr_die
, DW_AT_inline
, DW_INL_inlined
);
11186 add_AT_unsigned (subr_die
, DW_AT_inline
, DW_INL_not_inlined
);
11189 equate_decl_number_to_die (decl
, subr_die
);
11191 else if (!DECL_EXTERNAL (decl
))
11193 if (!old_die
|| !get_AT (old_die
, DW_AT_inline
))
11194 equate_decl_number_to_die (decl
, subr_die
);
11196 ASM_GENERATE_INTERNAL_LABEL (label_id
, FUNC_BEGIN_LABEL
,
11197 current_function_funcdef_no
);
11198 add_AT_lbl_id (subr_die
, DW_AT_low_pc
, label_id
);
11199 ASM_GENERATE_INTERNAL_LABEL (label_id
, FUNC_END_LABEL
,
11200 current_function_funcdef_no
);
11201 add_AT_lbl_id (subr_die
, DW_AT_high_pc
, label_id
);
11203 add_pubname (decl
, subr_die
);
11204 add_arange (decl
, subr_die
);
11206 #ifdef MIPS_DEBUGGING_INFO
11207 /* Add a reference to the FDE for this routine. */
11208 add_AT_fde_ref (subr_die
, DW_AT_MIPS_fde
, current_funcdef_fde
);
11211 /* Define the "frame base" location for this routine. We use the
11212 frame pointer or stack pointer registers, since the RTL for local
11213 variables is relative to one of them. */
11214 if (frame_base_decl
&& lookup_decl_loc (frame_base_decl
) != NULL
)
11216 add_location_or_const_value_attribute (subr_die
, frame_base_decl
,
11222 = frame_pointer_needed
? hard_frame_pointer_rtx
: stack_pointer_rtx
;
11223 add_AT_loc (subr_die
, DW_AT_frame_base
, reg_loc_descriptor (fp_reg
));
11227 /* ??? This fails for nested inline functions, because context_display
11228 is not part of the state saved/restored for inline functions. */
11229 if (current_function_needs_context
)
11230 add_AT_location_description (subr_die
, DW_AT_static_link
,
11231 loc_descriptor (lookup_static_chain (decl
)));
11235 /* Now output descriptions of the arguments for this function. This gets
11236 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
11237 for a FUNCTION_DECL doesn't indicate cases where there was a trailing
11238 `...' at the end of the formal parameter list. In order to find out if
11239 there was a trailing ellipsis or not, we must instead look at the type
11240 associated with the FUNCTION_DECL. This will be a node of type
11241 FUNCTION_TYPE. If the chain of type nodes hanging off of this
11242 FUNCTION_TYPE node ends with a void_type_node then there should *not* be
11243 an ellipsis at the end. */
11245 /* In the case where we are describing a mere function declaration, all we
11246 need to do here (and all we *can* do here) is to describe the *types* of
11247 its formal parameters. */
11248 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
11250 else if (declaration
)
11251 gen_formal_types_die (decl
, subr_die
);
11254 /* Generate DIEs to represent all known formal parameters. */
11255 tree arg_decls
= DECL_ARGUMENTS (decl
);
11258 /* When generating DIEs, generate the unspecified_parameters DIE
11259 instead if we come across the arg "__builtin_va_alist" */
11260 for (parm
= arg_decls
; parm
; parm
= TREE_CHAIN (parm
))
11261 if (TREE_CODE (parm
) == PARM_DECL
)
11263 if (DECL_NAME (parm
)
11264 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (parm
)),
11265 "__builtin_va_alist"))
11266 gen_unspecified_parameters_die (parm
, subr_die
);
11268 gen_decl_die (parm
, subr_die
);
11271 /* Decide whether we need an unspecified_parameters DIE at the end.
11272 There are 2 more cases to do this for: 1) the ansi ... declaration -
11273 this is detectable when the end of the arg list is not a
11274 void_type_node 2) an unprototyped function declaration (not a
11275 definition). This just means that we have no info about the
11276 parameters at all. */
11277 fn_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
11278 if (fn_arg_types
!= NULL
)
11280 /* This is the prototyped case, check for.... */
11281 if (TREE_VALUE (tree_last (fn_arg_types
)) != void_type_node
)
11282 gen_unspecified_parameters_die (decl
, subr_die
);
11284 else if (DECL_INITIAL (decl
) == NULL_TREE
)
11285 gen_unspecified_parameters_die (decl
, subr_die
);
11288 /* Output Dwarf info for all of the stuff within the body of the function
11289 (if it has one - it may be just a declaration). */
11290 outer_scope
= DECL_INITIAL (decl
);
11292 /* OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent
11293 a function. This BLOCK actually represents the outermost binding contour
11294 for the function, i.e. the contour in which the function's formal
11295 parameters and labels get declared. Curiously, it appears that the front
11296 end doesn't actually put the PARM_DECL nodes for the current function onto
11297 the BLOCK_VARS list for this outer scope, but are strung off of the
11298 DECL_ARGUMENTS list for the function instead.
11300 The BLOCK_VARS list for the `outer_scope' does provide us with a list of
11301 the LABEL_DECL nodes for the function however, and we output DWARF info
11302 for those in decls_for_scope. Just within the `outer_scope' there will be
11303 a BLOCK node representing the function's outermost pair of curly braces,
11304 and any blocks used for the base and member initializers of a C++
11305 constructor function. */
11306 if (! declaration
&& TREE_CODE (outer_scope
) != ERROR_MARK
)
11308 current_function_has_inlines
= 0;
11309 decls_for_scope (outer_scope
, subr_die
, 0);
11311 #if 0 && defined (MIPS_DEBUGGING_INFO)
11312 if (current_function_has_inlines
)
11314 add_AT_flag (subr_die
, DW_AT_MIPS_has_inlines
, 1);
11315 if (! comp_unit_has_inlines
)
11317 add_AT_flag (comp_unit_die
, DW_AT_MIPS_has_inlines
, 1);
11318 comp_unit_has_inlines
= 1;
11325 /* Generate a DIE to represent a declared data object. */
11328 gen_variable_die (tree decl
, dw_die_ref context_die
)
11330 tree origin
= decl_ultimate_origin (decl
);
11331 dw_die_ref var_die
= new_die (DW_TAG_variable
, context_die
, decl
);
11333 dw_die_ref old_die
= lookup_decl_die (decl
);
11334 int declaration
= (DECL_EXTERNAL (decl
)
11335 || class_or_namespace_scope_p (context_die
));
11337 if (origin
!= NULL
)
11338 add_abstract_origin_attribute (var_die
, origin
);
11340 /* Loop unrolling can create multiple blocks that refer to the same
11341 static variable, so we must test for the DW_AT_declaration flag.
11343 ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
11344 copy decls and set the DECL_ABSTRACT flag on them instead of
11347 ??? Duplicated blocks have been rewritten to use .debug_ranges. */
11348 else if (old_die
&& TREE_STATIC (decl
)
11349 && get_AT_flag (old_die
, DW_AT_declaration
) == 1)
11351 /* This is a definition of a C++ class level static. */
11352 add_AT_specification (var_die
, old_die
);
11353 if (DECL_NAME (decl
))
11355 unsigned file_index
= lookup_filename (DECL_SOURCE_FILE (decl
));
11357 if (get_AT_unsigned (old_die
, DW_AT_decl_file
) != file_index
)
11358 add_AT_unsigned (var_die
, DW_AT_decl_file
, file_index
);
11360 if (get_AT_unsigned (old_die
, DW_AT_decl_line
)
11361 != (unsigned) DECL_SOURCE_LINE (decl
))
11363 add_AT_unsigned (var_die
, DW_AT_decl_line
,
11364 DECL_SOURCE_LINE (decl
));
11369 add_name_and_src_coords_attributes (var_die
, decl
);
11370 add_type_attribute (var_die
, TREE_TYPE (decl
), TREE_READONLY (decl
),
11371 TREE_THIS_VOLATILE (decl
), context_die
);
11373 if (TREE_PUBLIC (decl
))
11374 add_AT_flag (var_die
, DW_AT_external
, 1);
11376 if (DECL_ARTIFICIAL (decl
))
11377 add_AT_flag (var_die
, DW_AT_artificial
, 1);
11379 if (TREE_PROTECTED (decl
))
11380 add_AT_unsigned (var_die
, DW_AT_accessibility
, DW_ACCESS_protected
);
11381 else if (TREE_PRIVATE (decl
))
11382 add_AT_unsigned (var_die
, DW_AT_accessibility
, DW_ACCESS_private
);
11386 add_AT_flag (var_die
, DW_AT_declaration
, 1);
11388 if (DECL_ABSTRACT (decl
) || declaration
)
11389 equate_decl_number_to_die (decl
, var_die
);
11391 if (! declaration
&& ! DECL_ABSTRACT (decl
))
11393 add_location_or_const_value_attribute (var_die
, decl
, DW_AT_location
);
11394 add_pubname (decl
, var_die
);
11397 tree_add_const_value_attribute (var_die
, decl
);
11400 /* Generate a DIE to represent a label identifier. */
11403 gen_label_die (tree decl
, dw_die_ref context_die
)
11405 tree origin
= decl_ultimate_origin (decl
);
11406 dw_die_ref lbl_die
= new_die (DW_TAG_label
, context_die
, decl
);
11408 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
11410 if (origin
!= NULL
)
11411 add_abstract_origin_attribute (lbl_die
, origin
);
11413 add_name_and_src_coords_attributes (lbl_die
, decl
);
11415 if (DECL_ABSTRACT (decl
))
11416 equate_decl_number_to_die (decl
, lbl_die
);
11419 insn
= DECL_RTL_IF_SET (decl
);
11421 /* Deleted labels are programmer specified labels which have been
11422 eliminated because of various optimizations. We still emit them
11423 here so that it is possible to put breakpoints on them. */
11425 && (GET_CODE (insn
) == CODE_LABEL
11426 || ((GET_CODE (insn
) == NOTE
11427 && NOTE_LINE_NUMBER (insn
) == NOTE_INSN_DELETED_LABEL
))))
11429 /* When optimization is enabled (via -O) some parts of the compiler
11430 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
11431 represent source-level labels which were explicitly declared by
11432 the user. This really shouldn't be happening though, so catch
11433 it if it ever does happen. */
11434 if (INSN_DELETED_P (insn
))
11437 ASM_GENERATE_INTERNAL_LABEL (label
, "L", CODE_LABEL_NUMBER (insn
));
11438 add_AT_lbl_id (lbl_die
, DW_AT_low_pc
, label
);
11443 /* Generate a DIE for a lexical block. */
11446 gen_lexical_block_die (tree stmt
, dw_die_ref context_die
, int depth
)
11448 dw_die_ref stmt_die
= new_die (DW_TAG_lexical_block
, context_die
, stmt
);
11449 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
11451 if (! BLOCK_ABSTRACT (stmt
))
11453 if (BLOCK_FRAGMENT_CHAIN (stmt
))
11457 add_AT_range_list (stmt_die
, DW_AT_ranges
, add_ranges (stmt
));
11459 chain
= BLOCK_FRAGMENT_CHAIN (stmt
);
11462 add_ranges (chain
);
11463 chain
= BLOCK_FRAGMENT_CHAIN (chain
);
11470 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_BEGIN_LABEL
,
11471 BLOCK_NUMBER (stmt
));
11472 add_AT_lbl_id (stmt_die
, DW_AT_low_pc
, label
);
11473 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_END_LABEL
,
11474 BLOCK_NUMBER (stmt
));
11475 add_AT_lbl_id (stmt_die
, DW_AT_high_pc
, label
);
11479 decls_for_scope (stmt
, stmt_die
, depth
);
11482 /* Generate a DIE for an inlined subprogram. */
11485 gen_inlined_subroutine_die (tree stmt
, dw_die_ref context_die
, int depth
)
11487 tree decl
= block_ultimate_origin (stmt
);
11489 /* Emit info for the abstract instance first, if we haven't yet. We
11490 must emit this even if the block is abstract, otherwise when we
11491 emit the block below (or elsewhere), we may end up trying to emit
11492 a die whose origin die hasn't been emitted, and crashing. */
11493 dwarf2out_abstract_function (decl
);
11495 if (! BLOCK_ABSTRACT (stmt
))
11497 dw_die_ref subr_die
11498 = new_die (DW_TAG_inlined_subroutine
, context_die
, stmt
);
11499 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
11501 add_abstract_origin_attribute (subr_die
, decl
);
11502 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_BEGIN_LABEL
,
11503 BLOCK_NUMBER (stmt
));
11504 add_AT_lbl_id (subr_die
, DW_AT_low_pc
, label
);
11505 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_END_LABEL
,
11506 BLOCK_NUMBER (stmt
));
11507 add_AT_lbl_id (subr_die
, DW_AT_high_pc
, label
);
11508 decls_for_scope (stmt
, subr_die
, depth
);
11509 current_function_has_inlines
= 1;
11512 /* We may get here if we're the outer block of function A that was
11513 inlined into function B that was inlined into function C. When
11514 generating debugging info for C, dwarf2out_abstract_function(B)
11515 would mark all inlined blocks as abstract, including this one.
11516 So, we wouldn't (and shouldn't) expect labels to be generated
11517 for this one. Instead, just emit debugging info for
11518 declarations within the block. This is particularly important
11519 in the case of initializers of arguments passed from B to us:
11520 if they're statement expressions containing declarations, we
11521 wouldn't generate dies for their abstract variables, and then,
11522 when generating dies for the real variables, we'd die (pun
11524 gen_lexical_block_die (stmt
, context_die
, depth
);
11527 /* Generate a DIE for a field in a record, or structure. */
11530 gen_field_die (tree decl
, dw_die_ref context_die
)
11532 dw_die_ref decl_die
;
11534 if (TREE_TYPE (decl
) == error_mark_node
)
11537 decl_die
= new_die (DW_TAG_member
, context_die
, decl
);
11538 add_name_and_src_coords_attributes (decl_die
, decl
);
11539 add_type_attribute (decl_die
, member_declared_type (decl
),
11540 TREE_READONLY (decl
), TREE_THIS_VOLATILE (decl
),
11543 if (DECL_BIT_FIELD_TYPE (decl
))
11545 add_byte_size_attribute (decl_die
, decl
);
11546 add_bit_size_attribute (decl_die
, decl
);
11547 add_bit_offset_attribute (decl_die
, decl
);
11550 if (TREE_CODE (DECL_FIELD_CONTEXT (decl
)) != UNION_TYPE
)
11551 add_data_member_location_attribute (decl_die
, decl
);
11553 if (DECL_ARTIFICIAL (decl
))
11554 add_AT_flag (decl_die
, DW_AT_artificial
, 1);
11556 if (TREE_PROTECTED (decl
))
11557 add_AT_unsigned (decl_die
, DW_AT_accessibility
, DW_ACCESS_protected
);
11558 else if (TREE_PRIVATE (decl
))
11559 add_AT_unsigned (decl_die
, DW_AT_accessibility
, DW_ACCESS_private
);
11563 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
11564 Use modified_type_die instead.
11565 We keep this code here just in case these types of DIEs may be needed to
11566 represent certain things in other languages (e.g. Pascal) someday. */
11569 gen_pointer_type_die (tree type
, dw_die_ref context_die
)
11572 = new_die (DW_TAG_pointer_type
, scope_die_for (type
, context_die
), type
);
11574 equate_type_number_to_die (type
, ptr_die
);
11575 add_type_attribute (ptr_die
, TREE_TYPE (type
), 0, 0, context_die
);
11576 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
, PTR_SIZE
);
11579 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
11580 Use modified_type_die instead.
11581 We keep this code here just in case these types of DIEs may be needed to
11582 represent certain things in other languages (e.g. Pascal) someday. */
11585 gen_reference_type_die (tree type
, dw_die_ref context_die
)
11588 = new_die (DW_TAG_reference_type
, scope_die_for (type
, context_die
), type
);
11590 equate_type_number_to_die (type
, ref_die
);
11591 add_type_attribute (ref_die
, TREE_TYPE (type
), 0, 0, context_die
);
11592 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
, PTR_SIZE
);
11596 /* Generate a DIE for a pointer to a member type. */
11599 gen_ptr_to_mbr_type_die (tree type
, dw_die_ref context_die
)
11602 = new_die (DW_TAG_ptr_to_member_type
,
11603 scope_die_for (type
, context_die
), type
);
11605 equate_type_number_to_die (type
, ptr_die
);
11606 add_AT_die_ref (ptr_die
, DW_AT_containing_type
,
11607 lookup_type_die (TYPE_OFFSET_BASETYPE (type
)));
11608 add_type_attribute (ptr_die
, TREE_TYPE (type
), 0, 0, context_die
);
11611 /* Generate the DIE for the compilation unit. */
11614 gen_compile_unit_die (const char *filename
)
11617 char producer
[250];
11618 const char *language_string
= lang_hooks
.name
;
11621 die
= new_die (DW_TAG_compile_unit
, NULL
, NULL
);
11625 add_name_attribute (die
, filename
);
11626 /* Don't add cwd for <built-in>. */
11627 if (filename
[0] != DIR_SEPARATOR
&& filename
[0] != '<')
11628 add_comp_dir_attribute (die
);
11631 sprintf (producer
, "%s %s", language_string
, version_string
);
11633 #ifdef MIPS_DEBUGGING_INFO
11634 /* The MIPS/SGI compilers place the 'cc' command line options in the producer
11635 string. The SGI debugger looks for -g, -g1, -g2, or -g3; if they do
11636 not appear in the producer string, the debugger reaches the conclusion
11637 that the object file is stripped and has no debugging information.
11638 To get the MIPS/SGI debugger to believe that there is debugging
11639 information in the object file, we add a -g to the producer string. */
11640 if (debug_info_level
> DINFO_LEVEL_TERSE
)
11641 strcat (producer
, " -g");
11644 add_AT_string (die
, DW_AT_producer
, producer
);
11646 if (strcmp (language_string
, "GNU C++") == 0)
11647 language
= DW_LANG_C_plus_plus
;
11648 else if (strcmp (language_string
, "GNU Ada") == 0)
11649 language
= DW_LANG_Ada95
;
11650 else if (strcmp (language_string
, "GNU F77") == 0)
11651 language
= DW_LANG_Fortran77
;
11652 else if (strcmp (language_string
, "GNU Pascal") == 0)
11653 language
= DW_LANG_Pascal83
;
11654 else if (strcmp (language_string
, "GNU Java") == 0)
11655 language
= DW_LANG_Java
;
11657 language
= DW_LANG_C89
;
11659 add_AT_unsigned (die
, DW_AT_language
, language
);
11663 /* Generate a DIE for a string type. */
11666 gen_string_type_die (tree type
, dw_die_ref context_die
)
11668 dw_die_ref type_die
11669 = new_die (DW_TAG_string_type
, scope_die_for (type
, context_die
), type
);
11671 equate_type_number_to_die (type
, type_die
);
11673 /* ??? Fudge the string length attribute for now.
11674 TODO: add string length info. */
11676 string_length_attribute (TYPE_MAX_VALUE (TYPE_DOMAIN (type
)));
11677 bound_representation (upper_bound
, 0, 'u');
11681 /* Generate the DIE for a base class. */
11684 gen_inheritance_die (tree binfo
, tree access
, dw_die_ref context_die
)
11686 dw_die_ref die
= new_die (DW_TAG_inheritance
, context_die
, binfo
);
11688 add_type_attribute (die
, BINFO_TYPE (binfo
), 0, 0, context_die
);
11689 add_data_member_location_attribute (die
, binfo
);
11691 if (TREE_VIA_VIRTUAL (binfo
))
11692 add_AT_unsigned (die
, DW_AT_virtuality
, DW_VIRTUALITY_virtual
);
11694 if (access
== access_public_node
)
11695 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_public
);
11696 else if (access
== access_protected_node
)
11697 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_protected
);
11700 /* Generate a DIE for a class member. */
11703 gen_member_die (tree type
, dw_die_ref context_die
)
11706 tree binfo
= TYPE_BINFO (type
);
11709 /* If this is not an incomplete type, output descriptions of each of its
11710 members. Note that as we output the DIEs necessary to represent the
11711 members of this record or union type, we will also be trying to output
11712 DIEs to represent the *types* of those members. However the `type'
11713 function (above) will specifically avoid generating type DIEs for member
11714 types *within* the list of member DIEs for this (containing) type except
11715 for those types (of members) which are explicitly marked as also being
11716 members of this (containing) type themselves. The g++ front- end can
11717 force any given type to be treated as a member of some other (containing)
11718 type by setting the TYPE_CONTEXT of the given (member) type to point to
11719 the TREE node representing the appropriate (containing) type. */
11721 /* First output info about the base classes. */
11722 if (binfo
&& BINFO_BASETYPES (binfo
))
11724 tree bases
= BINFO_BASETYPES (binfo
);
11725 tree accesses
= BINFO_BASEACCESSES (binfo
);
11726 int n_bases
= TREE_VEC_LENGTH (bases
);
11729 for (i
= 0; i
< n_bases
; i
++)
11730 gen_inheritance_die (TREE_VEC_ELT (bases
, i
),
11731 (accesses
? TREE_VEC_ELT (accesses
, i
)
11732 : access_public_node
), context_die
);
11735 /* Now output info about the data members and type members. */
11736 for (member
= TYPE_FIELDS (type
); member
; member
= TREE_CHAIN (member
))
11738 /* If we thought we were generating minimal debug info for TYPE
11739 and then changed our minds, some of the member declarations
11740 may have already been defined. Don't define them again, but
11741 do put them in the right order. */
11743 child
= lookup_decl_die (member
);
11745 splice_child_die (context_die
, child
);
11747 gen_decl_die (member
, context_die
);
11750 /* Now output info about the function members (if any). */
11751 for (member
= TYPE_METHODS (type
); member
; member
= TREE_CHAIN (member
))
11753 /* Don't include clones in the member list. */
11754 if (DECL_ABSTRACT_ORIGIN (member
))
11757 child
= lookup_decl_die (member
);
11759 splice_child_die (context_die
, child
);
11761 gen_decl_die (member
, context_die
);
11765 /* Generate a DIE for a structure or union type. If TYPE_DECL_SUPPRESS_DEBUG
11766 is set, we pretend that the type was never defined, so we only get the
11767 member DIEs needed by later specification DIEs. */
11770 gen_struct_or_union_type_die (tree type
, dw_die_ref context_die
)
11772 dw_die_ref type_die
= lookup_type_die (type
);
11773 dw_die_ref scope_die
= 0;
11775 int complete
= (TYPE_SIZE (type
)
11776 && (! TYPE_STUB_DECL (type
)
11777 || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type
))));
11778 int ns_decl
= (context_die
&& context_die
->die_tag
== DW_TAG_namespace
);
11780 if (type_die
&& ! complete
)
11783 if (TYPE_CONTEXT (type
) != NULL_TREE
11784 && (AGGREGATE_TYPE_P (TYPE_CONTEXT (type
))
11785 || TREE_CODE (TYPE_CONTEXT (type
)) == NAMESPACE_DECL
))
11788 scope_die
= scope_die_for (type
, context_die
);
11790 if (! type_die
|| (nested
&& scope_die
== comp_unit_die
))
11791 /* First occurrence of type or toplevel definition of nested class. */
11793 dw_die_ref old_die
= type_die
;
11795 type_die
= new_die (TREE_CODE (type
) == RECORD_TYPE
11796 ? DW_TAG_structure_type
: DW_TAG_union_type
,
11798 equate_type_number_to_die (type
, type_die
);
11800 add_AT_specification (type_die
, old_die
);
11802 add_name_attribute (type_die
, type_tag (type
));
11805 remove_AT (type_die
, DW_AT_declaration
);
11807 /* If this type has been completed, then give it a byte_size attribute and
11808 then give a list of members. */
11809 if (complete
&& !ns_decl
)
11811 /* Prevent infinite recursion in cases where the type of some member of
11812 this type is expressed in terms of this type itself. */
11813 TREE_ASM_WRITTEN (type
) = 1;
11814 add_byte_size_attribute (type_die
, type
);
11815 if (TYPE_STUB_DECL (type
) != NULL_TREE
)
11816 add_src_coords_attributes (type_die
, TYPE_STUB_DECL (type
));
11818 /* If the first reference to this type was as the return type of an
11819 inline function, then it may not have a parent. Fix this now. */
11820 if (type_die
->die_parent
== NULL
)
11821 add_child_die (scope_die
, type_die
);
11823 push_decl_scope (type
);
11824 gen_member_die (type
, type_die
);
11827 /* GNU extension: Record what type our vtable lives in. */
11828 if (TYPE_VFIELD (type
))
11830 tree vtype
= DECL_FCONTEXT (TYPE_VFIELD (type
));
11832 gen_type_die (vtype
, context_die
);
11833 add_AT_die_ref (type_die
, DW_AT_containing_type
,
11834 lookup_type_die (vtype
));
11839 add_AT_flag (type_die
, DW_AT_declaration
, 1);
11841 /* We don't need to do this for function-local types. */
11842 if (TYPE_STUB_DECL (type
)
11843 && ! decl_function_context (TYPE_STUB_DECL (type
)))
11844 VARRAY_PUSH_TREE (incomplete_types
, type
);
11848 /* Generate a DIE for a subroutine _type_. */
11851 gen_subroutine_type_die (tree type
, dw_die_ref context_die
)
11853 tree return_type
= TREE_TYPE (type
);
11854 dw_die_ref subr_die
11855 = new_die (DW_TAG_subroutine_type
,
11856 scope_die_for (type
, context_die
), type
);
11858 equate_type_number_to_die (type
, subr_die
);
11859 add_prototyped_attribute (subr_die
, type
);
11860 add_type_attribute (subr_die
, return_type
, 0, 0, context_die
);
11861 gen_formal_types_die (type
, subr_die
);
11864 /* Generate a DIE for a type definition. */
11867 gen_typedef_die (tree decl
, dw_die_ref context_die
)
11869 dw_die_ref type_die
;
11872 if (TREE_ASM_WRITTEN (decl
))
11875 TREE_ASM_WRITTEN (decl
) = 1;
11876 type_die
= new_die (DW_TAG_typedef
, context_die
, decl
);
11877 origin
= decl_ultimate_origin (decl
);
11878 if (origin
!= NULL
)
11879 add_abstract_origin_attribute (type_die
, origin
);
11884 add_name_and_src_coords_attributes (type_die
, decl
);
11885 if (DECL_ORIGINAL_TYPE (decl
))
11887 type
= DECL_ORIGINAL_TYPE (decl
);
11889 if (type
== TREE_TYPE (decl
))
11892 equate_type_number_to_die (TREE_TYPE (decl
), type_die
);
11895 type
= TREE_TYPE (decl
);
11897 add_type_attribute (type_die
, type
, TREE_READONLY (decl
),
11898 TREE_THIS_VOLATILE (decl
), context_die
);
11901 if (DECL_ABSTRACT (decl
))
11902 equate_decl_number_to_die (decl
, type_die
);
11905 /* Generate a type description DIE. */
11908 gen_type_die (tree type
, dw_die_ref context_die
)
11912 if (type
== NULL_TREE
|| type
== error_mark_node
)
11915 if (TYPE_NAME (type
) && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
11916 && DECL_ORIGINAL_TYPE (TYPE_NAME (type
)))
11918 if (TREE_ASM_WRITTEN (type
))
11921 /* Prevent broken recursion; we can't hand off to the same type. */
11922 if (DECL_ORIGINAL_TYPE (TYPE_NAME (type
)) == type
)
11925 TREE_ASM_WRITTEN (type
) = 1;
11926 gen_decl_die (TYPE_NAME (type
), context_die
);
11930 /* We are going to output a DIE to represent the unqualified version
11931 of this type (i.e. without any const or volatile qualifiers) so
11932 get the main variant (i.e. the unqualified version) of this type
11933 now. (Vectors are special because the debugging info is in the
11934 cloned type itself). */
11935 if (TREE_CODE (type
) != VECTOR_TYPE
)
11936 type
= type_main_variant (type
);
11938 if (TREE_ASM_WRITTEN (type
))
11941 switch (TREE_CODE (type
))
11947 case REFERENCE_TYPE
:
11948 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This
11949 ensures that the gen_type_die recursion will terminate even if the
11950 type is recursive. Recursive types are possible in Ada. */
11951 /* ??? We could perhaps do this for all types before the switch
11953 TREE_ASM_WRITTEN (type
) = 1;
11955 /* For these types, all that is required is that we output a DIE (or a
11956 set of DIEs) to represent the "basis" type. */
11957 gen_type_die (TREE_TYPE (type
), context_die
);
11961 /* This code is used for C++ pointer-to-data-member types.
11962 Output a description of the relevant class type. */
11963 gen_type_die (TYPE_OFFSET_BASETYPE (type
), context_die
);
11965 /* Output a description of the type of the object pointed to. */
11966 gen_type_die (TREE_TYPE (type
), context_die
);
11968 /* Now output a DIE to represent this pointer-to-data-member type
11970 gen_ptr_to_mbr_type_die (type
, context_die
);
11974 gen_type_die (TYPE_DOMAIN (type
), context_die
);
11975 gen_set_type_die (type
, context_die
);
11979 gen_type_die (TREE_TYPE (type
), context_die
);
11980 abort (); /* No way to represent these in Dwarf yet! */
11983 case FUNCTION_TYPE
:
11984 /* Force out return type (in case it wasn't forced out already). */
11985 gen_type_die (TREE_TYPE (type
), context_die
);
11986 gen_subroutine_type_die (type
, context_die
);
11990 /* Force out return type (in case it wasn't forced out already). */
11991 gen_type_die (TREE_TYPE (type
), context_die
);
11992 gen_subroutine_type_die (type
, context_die
);
11996 if (TYPE_STRING_FLAG (type
) && TREE_CODE (TREE_TYPE (type
)) == CHAR_TYPE
)
11998 gen_type_die (TREE_TYPE (type
), context_die
);
11999 gen_string_type_die (type
, context_die
);
12002 gen_array_type_die (type
, context_die
);
12006 gen_array_type_die (type
, context_die
);
12009 case ENUMERAL_TYPE
:
12012 case QUAL_UNION_TYPE
:
12013 /* If this is a nested type whose containing class hasn't been written
12014 out yet, writing it out will cover this one, too. This does not apply
12015 to instantiations of member class templates; they need to be added to
12016 the containing class as they are generated. FIXME: This hurts the
12017 idea of combining type decls from multiple TUs, since we can't predict
12018 what set of template instantiations we'll get. */
12019 if (TYPE_CONTEXT (type
)
12020 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type
))
12021 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type
)))
12023 gen_type_die (TYPE_CONTEXT (type
), context_die
);
12025 if (TREE_ASM_WRITTEN (type
))
12028 /* If that failed, attach ourselves to the stub. */
12029 push_decl_scope (TYPE_CONTEXT (type
));
12030 context_die
= lookup_type_die (TYPE_CONTEXT (type
));
12035 declare_in_namespace (type
, context_die
);
12039 if (TREE_CODE (type
) == ENUMERAL_TYPE
)
12040 gen_enumeration_type_die (type
, context_die
);
12042 gen_struct_or_union_type_die (type
, context_die
);
12047 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
12048 it up if it is ever completed. gen_*_type_die will set it for us
12049 when appropriate. */
12058 /* No DIEs needed for fundamental types. */
12062 /* No Dwarf representation currently defined. */
12069 TREE_ASM_WRITTEN (type
) = 1;
12072 /* Generate a DIE for a tagged type instantiation. */
12075 gen_tagged_type_instantiation_die (tree type
, dw_die_ref context_die
)
12077 if (type
== NULL_TREE
|| type
== error_mark_node
)
12080 /* We are going to output a DIE to represent the unqualified version of
12081 this type (i.e. without any const or volatile qualifiers) so make sure
12082 that we have the main variant (i.e. the unqualified version) of this
12084 if (type
!= type_main_variant (type
))
12087 /* Do not check TREE_ASM_WRITTEN (type) as it may not be set if this is
12088 an instance of an unresolved type. */
12090 switch (TREE_CODE (type
))
12095 case ENUMERAL_TYPE
:
12096 gen_inlined_enumeration_type_die (type
, context_die
);
12100 gen_inlined_structure_type_die (type
, context_die
);
12104 case QUAL_UNION_TYPE
:
12105 gen_inlined_union_type_die (type
, context_die
);
12113 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
12114 things which are local to the given block. */
12117 gen_block_die (tree stmt
, dw_die_ref context_die
, int depth
)
12119 int must_output_die
= 0;
12122 enum tree_code origin_code
;
12124 /* Ignore blocks never really used to make RTL. */
12125 if (stmt
== NULL_TREE
|| !TREE_USED (stmt
)
12126 || (!TREE_ASM_WRITTEN (stmt
) && !BLOCK_ABSTRACT (stmt
)))
12129 /* If the block is one fragment of a non-contiguous block, do not
12130 process the variables, since they will have been done by the
12131 origin block. Do process subblocks. */
12132 if (BLOCK_FRAGMENT_ORIGIN (stmt
))
12136 for (sub
= BLOCK_SUBBLOCKS (stmt
); sub
; sub
= BLOCK_CHAIN (sub
))
12137 gen_block_die (sub
, context_die
, depth
+ 1);
12142 /* Determine the "ultimate origin" of this block. This block may be an
12143 inlined instance of an inlined instance of inline function, so we have
12144 to trace all of the way back through the origin chain to find out what
12145 sort of node actually served as the original seed for the creation of
12146 the current block. */
12147 origin
= block_ultimate_origin (stmt
);
12148 origin_code
= (origin
!= NULL
) ? TREE_CODE (origin
) : ERROR_MARK
;
12150 /* Determine if we need to output any Dwarf DIEs at all to represent this
12152 if (origin_code
== FUNCTION_DECL
)
12153 /* The outer scopes for inlinings *must* always be represented. We
12154 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */
12155 must_output_die
= 1;
12158 /* In the case where the current block represents an inlining of the
12159 "body block" of an inline function, we must *NOT* output any DIE for
12160 this block because we have already output a DIE to represent the whole
12161 inlined function scope and the "body block" of any function doesn't
12162 really represent a different scope according to ANSI C rules. So we
12163 check here to make sure that this block does not represent a "body
12164 block inlining" before trying to set the MUST_OUTPUT_DIE flag. */
12165 if (! is_body_block (origin
? origin
: stmt
))
12167 /* Determine if this block directly contains any "significant"
12168 local declarations which we will need to output DIEs for. */
12169 if (debug_info_level
> DINFO_LEVEL_TERSE
)
12170 /* We are not in terse mode so *any* local declaration counts
12171 as being a "significant" one. */
12172 must_output_die
= (BLOCK_VARS (stmt
) != NULL
);
12174 /* We are in terse mode, so only local (nested) function
12175 definitions count as "significant" local declarations. */
12176 for (decl
= BLOCK_VARS (stmt
);
12177 decl
!= NULL
; decl
= TREE_CHAIN (decl
))
12178 if (TREE_CODE (decl
) == FUNCTION_DECL
12179 && DECL_INITIAL (decl
))
12181 must_output_die
= 1;
12187 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
12188 DIE for any block which contains no significant local declarations at
12189 all. Rather, in such cases we just call `decls_for_scope' so that any
12190 needed Dwarf info for any sub-blocks will get properly generated. Note
12191 that in terse mode, our definition of what constitutes a "significant"
12192 local declaration gets restricted to include only inlined function
12193 instances and local (nested) function definitions. */
12194 if (must_output_die
)
12196 if (origin_code
== FUNCTION_DECL
)
12197 gen_inlined_subroutine_die (stmt
, context_die
, depth
);
12199 gen_lexical_block_die (stmt
, context_die
, depth
);
12202 decls_for_scope (stmt
, context_die
, depth
);
12205 /* Generate all of the decls declared within a given scope and (recursively)
12206 all of its sub-blocks. */
12209 decls_for_scope (tree stmt
, dw_die_ref context_die
, int depth
)
12214 /* Ignore blocks never really used to make RTL. */
12215 if (stmt
== NULL_TREE
|| ! TREE_USED (stmt
))
12218 /* Output the DIEs to represent all of the data objects and typedefs
12219 declared directly within this block but not within any nested
12220 sub-blocks. Also, nested function and tag DIEs have been
12221 generated with a parent of NULL; fix that up now. */
12222 for (decl
= BLOCK_VARS (stmt
); decl
!= NULL
; decl
= TREE_CHAIN (decl
))
12226 if (TREE_CODE (decl
) == FUNCTION_DECL
)
12227 die
= lookup_decl_die (decl
);
12228 else if (TREE_CODE (decl
) == TYPE_DECL
&& TYPE_DECL_IS_STUB (decl
))
12229 die
= lookup_type_die (TREE_TYPE (decl
));
12233 if (die
!= NULL
&& die
->die_parent
== NULL
)
12234 add_child_die (context_die
, die
);
12236 gen_decl_die (decl
, context_die
);
12239 /* If we're at -g1, we're not interested in subblocks. */
12240 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
12243 /* Output the DIEs to represent all sub-blocks (and the items declared
12244 therein) of this block. */
12245 for (subblocks
= BLOCK_SUBBLOCKS (stmt
);
12247 subblocks
= BLOCK_CHAIN (subblocks
))
12248 gen_block_die (subblocks
, context_die
, depth
+ 1);
12251 /* Is this a typedef we can avoid emitting? */
12254 is_redundant_typedef (tree decl
)
12256 if (TYPE_DECL_IS_STUB (decl
))
12259 if (DECL_ARTIFICIAL (decl
)
12260 && DECL_CONTEXT (decl
)
12261 && is_tagged_type (DECL_CONTEXT (decl
))
12262 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl
))) == TYPE_DECL
12263 && DECL_NAME (decl
) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl
))))
12264 /* Also ignore the artificial member typedef for the class name. */
12270 /* Returns the DIE for decl or aborts. */
12273 force_decl_die (tree decl
)
12275 dw_die_ref decl_die
;
12276 unsigned saved_external_flag
;
12277 tree save_fn
= NULL_TREE
;
12278 decl_die
= lookup_decl_die (decl
);
12281 dw_die_ref context_die
;
12282 tree decl_context
= DECL_CONTEXT (decl
);
12285 /* Find die that represents this context. */
12286 if (TYPE_P (decl_context
))
12287 context_die
= force_type_die (decl_context
);
12289 context_die
= force_decl_die (decl_context
);
12292 context_die
= comp_unit_die
;
12294 switch (TREE_CODE (decl
))
12296 case FUNCTION_DECL
:
12297 /* Clear current_function_decl, so that gen_subprogram_die thinks
12298 that this is a declaration. At this point, we just want to force
12299 declaration die. */
12300 save_fn
= current_function_decl
;
12301 current_function_decl
= NULL_TREE
;
12302 gen_subprogram_die (decl
, context_die
);
12303 current_function_decl
= save_fn
;
12307 /* Set external flag to force declaration die. Restore it after
12308 gen_decl_die() call. */
12309 saved_external_flag
= DECL_EXTERNAL (decl
);
12310 DECL_EXTERNAL (decl
) = 1;
12311 gen_decl_die (decl
, context_die
);
12312 DECL_EXTERNAL (decl
) = saved_external_flag
;
12315 case NAMESPACE_DECL
:
12316 dwarf2out_decl (decl
);
12323 /* See if we can find the die for this deci now.
12324 If not then abort. */
12326 decl_die
= lookup_decl_die (decl
);
12334 /* Returns the DIE for decl or aborts. */
12337 force_type_die (tree type
)
12339 dw_die_ref type_die
;
12341 type_die
= lookup_type_die (type
);
12344 dw_die_ref context_die
;
12345 if (TYPE_CONTEXT (type
))
12346 if (TYPE_P (TYPE_CONTEXT (type
)))
12347 context_die
= force_type_die (TYPE_CONTEXT (type
));
12349 context_die
= force_decl_die (TYPE_CONTEXT (type
));
12351 context_die
= comp_unit_die
;
12353 gen_type_die (type
, context_die
);
12354 type_die
= lookup_type_die (type
);
12361 /* Force out any required namespaces to be able to output DECL,
12362 and return the new context_die for it, if it's changed. */
12365 setup_namespace_context (tree thing
, dw_die_ref context_die
)
12367 tree context
= DECL_P (thing
) ? DECL_CONTEXT (thing
) : TYPE_CONTEXT (thing
);
12368 if (context
&& TREE_CODE (context
) == NAMESPACE_DECL
)
12369 /* Force out the namespace. */
12370 context_die
= force_decl_die (context
);
12372 return context_die
;
12375 /* Emit a declaration DIE for THING (which is either a DECL or a tagged
12376 type) within its namespace, if appropriate.
12378 For compatibility with older debuggers, namespace DIEs only contain
12379 declarations; all definitions are emitted at CU scope. */
12382 declare_in_namespace (tree thing
, dw_die_ref context_die
)
12384 dw_die_ref ns_context
;
12386 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
12389 ns_context
= setup_namespace_context (thing
, context_die
);
12391 if (ns_context
!= context_die
)
12393 if (DECL_P (thing
))
12394 gen_decl_die (thing
, ns_context
);
12396 gen_type_die (thing
, ns_context
);
12400 /* Generate a DIE for a namespace or namespace alias. */
12403 gen_namespace_die (tree decl
)
12405 dw_die_ref context_die
= setup_namespace_context (decl
, comp_unit_die
);
12407 /* Namespace aliases have a DECL_ABSTRACT_ORIGIN of the namespace
12408 they are an alias of. */
12409 if (DECL_ABSTRACT_ORIGIN (decl
) == NULL
)
12411 /* Output a real namespace. */
12412 dw_die_ref namespace_die
12413 = new_die (DW_TAG_namespace
, context_die
, decl
);
12414 add_name_and_src_coords_attributes (namespace_die
, decl
);
12415 equate_decl_number_to_die (decl
, namespace_die
);
12419 /* Output a namespace alias. */
12421 /* Force out the namespace we are an alias of, if necessary. */
12422 dw_die_ref origin_die
12423 = force_decl_die (DECL_ABSTRACT_ORIGIN (decl
));
12425 /* Now create the namespace alias DIE. */
12426 dw_die_ref namespace_die
12427 = new_die (DW_TAG_imported_declaration
, context_die
, decl
);
12428 add_name_and_src_coords_attributes (namespace_die
, decl
);
12429 add_AT_die_ref (namespace_die
, DW_AT_import
, origin_die
);
12430 equate_decl_number_to_die (decl
, namespace_die
);
12434 /* Generate Dwarf debug information for a decl described by DECL. */
12437 gen_decl_die (tree decl
, dw_die_ref context_die
)
12441 if (DECL_P (decl
) && DECL_IGNORED_P (decl
))
12444 switch (TREE_CODE (decl
))
12450 /* The individual enumerators of an enum type get output when we output
12451 the Dwarf representation of the relevant enum type itself. */
12454 case FUNCTION_DECL
:
12455 /* Don't output any DIEs to represent mere function declarations,
12456 unless they are class members or explicit block externs. */
12457 if (DECL_INITIAL (decl
) == NULL_TREE
&& DECL_CONTEXT (decl
) == NULL_TREE
12458 && (current_function_decl
== NULL_TREE
|| DECL_ARTIFICIAL (decl
)))
12461 /* If we're emitting a clone, emit info for the abstract instance. */
12462 if (DECL_ORIGIN (decl
) != decl
)
12463 dwarf2out_abstract_function (DECL_ABSTRACT_ORIGIN (decl
));
12465 /* If we're emitting an out-of-line copy of an inline function,
12466 emit info for the abstract instance and set up to refer to it. */
12467 else if (cgraph_function_possibly_inlined_p (decl
)
12468 && ! DECL_ABSTRACT (decl
)
12469 && ! class_or_namespace_scope_p (context_die
)
12470 /* dwarf2out_abstract_function won't emit a die if this is just
12471 a declaration. We must avoid setting DECL_ABSTRACT_ORIGIN in
12472 that case, because that works only if we have a die. */
12473 && DECL_INITIAL (decl
) != NULL_TREE
)
12475 dwarf2out_abstract_function (decl
);
12476 set_decl_origin_self (decl
);
12479 /* Otherwise we're emitting the primary DIE for this decl. */
12480 else if (debug_info_level
> DINFO_LEVEL_TERSE
)
12482 /* Before we describe the FUNCTION_DECL itself, make sure that we
12483 have described its return type. */
12484 gen_type_die (TREE_TYPE (TREE_TYPE (decl
)), context_die
);
12486 /* And its virtual context. */
12487 if (DECL_VINDEX (decl
) != NULL_TREE
)
12488 gen_type_die (DECL_CONTEXT (decl
), context_die
);
12490 /* And its containing type. */
12491 origin
= decl_class_context (decl
);
12492 if (origin
!= NULL_TREE
)
12493 gen_type_die_for_member (origin
, decl
, context_die
);
12495 /* And its containing namespace. */
12496 declare_in_namespace (decl
, context_die
);
12499 /* Now output a DIE to represent the function itself. */
12500 gen_subprogram_die (decl
, context_die
);
12504 /* If we are in terse mode, don't generate any DIEs to represent any
12505 actual typedefs. */
12506 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
12509 /* In the special case of a TYPE_DECL node representing the declaration
12510 of some type tag, if the given TYPE_DECL is marked as having been
12511 instantiated from some other (original) TYPE_DECL node (e.g. one which
12512 was generated within the original definition of an inline function) we
12513 have to generate a special (abbreviated) DW_TAG_structure_type,
12514 DW_TAG_union_type, or DW_TAG_enumeration_type DIE here. */
12515 if (TYPE_DECL_IS_STUB (decl
) && decl_ultimate_origin (decl
) != NULL_TREE
)
12517 gen_tagged_type_instantiation_die (TREE_TYPE (decl
), context_die
);
12521 if (is_redundant_typedef (decl
))
12522 gen_type_die (TREE_TYPE (decl
), context_die
);
12524 /* Output a DIE to represent the typedef itself. */
12525 gen_typedef_die (decl
, context_die
);
12529 if (debug_info_level
>= DINFO_LEVEL_NORMAL
)
12530 gen_label_die (decl
, context_die
);
12534 /* If we are in terse mode, don't generate any DIEs to represent any
12535 variable declarations or definitions. */
12536 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
12539 /* Output any DIEs that are needed to specify the type of this data
12541 gen_type_die (TREE_TYPE (decl
), context_die
);
12543 /* And its containing type. */
12544 origin
= decl_class_context (decl
);
12545 if (origin
!= NULL_TREE
)
12546 gen_type_die_for_member (origin
, decl
, context_die
);
12548 /* And its containing namespace. */
12549 declare_in_namespace (decl
, context_die
);
12551 /* Now output the DIE to represent the data object itself. This gets
12552 complicated because of the possibility that the VAR_DECL really
12553 represents an inlined instance of a formal parameter for an inline
12555 origin
= decl_ultimate_origin (decl
);
12556 if (origin
!= NULL_TREE
&& TREE_CODE (origin
) == PARM_DECL
)
12557 gen_formal_parameter_die (decl
, context_die
);
12559 gen_variable_die (decl
, context_die
);
12563 /* Ignore the nameless fields that are used to skip bits but handle C++
12564 anonymous unions and structs. */
12565 if (DECL_NAME (decl
) != NULL_TREE
12566 || TREE_CODE (TREE_TYPE (decl
)) == UNION_TYPE
12567 || TREE_CODE (TREE_TYPE (decl
)) == RECORD_TYPE
)
12569 gen_type_die (member_declared_type (decl
), context_die
);
12570 gen_field_die (decl
, context_die
);
12575 gen_type_die (TREE_TYPE (decl
), context_die
);
12576 gen_formal_parameter_die (decl
, context_die
);
12579 case NAMESPACE_DECL
:
12580 gen_namespace_die (decl
);
12584 if ((int)TREE_CODE (decl
) > NUM_TREE_CODES
)
12585 /* Probably some frontend-internal decl. Assume we don't care. */
12591 /* Add Ada "use" clause information for SGI Workshop debugger. */
12594 dwarf2out_add_library_unit_info (const char *filename
, const char *context_list
)
12596 unsigned int file_index
;
12598 if (filename
!= NULL
)
12600 dw_die_ref unit_die
= new_die (DW_TAG_module
, comp_unit_die
, NULL
);
12601 tree context_list_decl
12602 = build_decl (LABEL_DECL
, get_identifier (context_list
),
12605 TREE_PUBLIC (context_list_decl
) = TRUE
;
12606 add_name_attribute (unit_die
, context_list
);
12607 file_index
= lookup_filename (filename
);
12608 add_AT_unsigned (unit_die
, DW_AT_decl_file
, file_index
);
12609 add_pubname (context_list_decl
, unit_die
);
12613 /* Output debug information for global decl DECL. Called from toplev.c after
12614 compilation proper has finished. */
12617 dwarf2out_global_decl (tree decl
)
12619 /* Output DWARF2 information for file-scope tentative data object
12620 declarations, file-scope (extern) function declarations (which had no
12621 corresponding body) and file-scope tagged type declarations and
12622 definitions which have not yet been forced out. */
12623 if (TREE_CODE (decl
) != FUNCTION_DECL
|| !DECL_INITIAL (decl
))
12624 dwarf2out_decl (decl
);
12627 /* Output debug information for type decl DECL. Called from toplev.c
12628 and from language front ends (to record built-in types). */
12630 dwarf2out_type_decl (tree decl
, int local
)
12633 dwarf2out_decl (decl
);
12636 /* Output debug information for imported module or decl. */
12639 dwarf2out_imported_module_or_decl (tree decl
, tree context
)
12641 dw_die_ref imported_die
, at_import_die
;
12642 dw_die_ref scope_die
;
12643 unsigned file_index
;
12645 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
12651 /* To emit DW_TAG_imported_module or DW_TAG_imported_decl, we need two DIEs.
12652 We need decl DIE for reference and scope die. First, get DIE for the decl
12655 /* Get the scope die for decl context. Use comp_unit_die for global module
12656 or decl. If die is not found for non globals, force new die. */
12658 scope_die
= comp_unit_die
;
12659 else if (TYPE_P (context
))
12660 scope_die
= force_type_die (context
);
12662 scope_die
= force_decl_die (context
);
12664 /* For TYPE_DECL, lookup TREE_TYPE. */
12665 if (TREE_CODE (decl
) == TYPE_DECL
)
12666 at_import_die
= force_type_die (TREE_TYPE (decl
));
12668 at_import_die
= force_decl_die (decl
);
12670 /* OK, now we have DIEs for decl as well as scope. Emit imported die. */
12671 if (TREE_CODE (decl
) == NAMESPACE_DECL
)
12672 imported_die
= new_die (DW_TAG_imported_module
, scope_die
, context
);
12674 imported_die
= new_die (DW_TAG_imported_declaration
, scope_die
, context
);
12676 file_index
= lookup_filename (input_filename
);
12677 add_AT_unsigned (imported_die
, DW_AT_decl_file
, file_index
);
12678 add_AT_unsigned (imported_die
, DW_AT_decl_line
, input_line
);
12679 add_AT_die_ref (imported_die
, DW_AT_import
, at_import_die
);
12682 /* Write the debugging output for DECL. */
12685 dwarf2out_decl (tree decl
)
12687 dw_die_ref context_die
= comp_unit_die
;
12689 switch (TREE_CODE (decl
))
12694 case FUNCTION_DECL
:
12695 /* What we would really like to do here is to filter out all mere
12696 file-scope declarations of file-scope functions which are never
12697 referenced later within this translation unit (and keep all of ones
12698 that *are* referenced later on) but we aren't clairvoyant, so we have
12699 no idea which functions will be referenced in the future (i.e. later
12700 on within the current translation unit). So here we just ignore all
12701 file-scope function declarations which are not also definitions. If
12702 and when the debugger needs to know something about these functions,
12703 it will have to hunt around and find the DWARF information associated
12704 with the definition of the function.
12706 We can't just check DECL_EXTERNAL to find out which FUNCTION_DECL
12707 nodes represent definitions and which ones represent mere
12708 declarations. We have to check DECL_INITIAL instead. That's because
12709 the C front-end supports some weird semantics for "extern inline"
12710 function definitions. These can get inlined within the current
12711 translation unit (an thus, we need to generate Dwarf info for their
12712 abstract instances so that the Dwarf info for the concrete inlined
12713 instances can have something to refer to) but the compiler never
12714 generates any out-of-lines instances of such things (despite the fact
12715 that they *are* definitions).
12717 The important point is that the C front-end marks these "extern
12718 inline" functions as DECL_EXTERNAL, but we need to generate DWARF for
12719 them anyway. Note that the C++ front-end also plays some similar games
12720 for inline function definitions appearing within include files which
12721 also contain `#pragma interface' pragmas. */
12722 if (DECL_INITIAL (decl
) == NULL_TREE
)
12725 /* If we're a nested function, initially use a parent of NULL; if we're
12726 a plain function, this will be fixed up in decls_for_scope. If
12727 we're a method, it will be ignored, since we already have a DIE. */
12728 if (decl_function_context (decl
)
12729 /* But if we're in terse mode, we don't care about scope. */
12730 && debug_info_level
> DINFO_LEVEL_TERSE
)
12731 context_die
= NULL
;
12735 /* Ignore this VAR_DECL if it refers to a file-scope extern data object
12736 declaration and if the declaration was never even referenced from
12737 within this entire compilation unit. We suppress these DIEs in
12738 order to save space in the .debug section (by eliminating entries
12739 which are probably useless). Note that we must not suppress
12740 block-local extern declarations (whether used or not) because that
12741 would screw-up the debugger's name lookup mechanism and cause it to
12742 miss things which really ought to be in scope at a given point. */
12743 if (DECL_EXTERNAL (decl
) && !TREE_USED (decl
))
12746 /* If we are in terse mode, don't generate any DIEs to represent any
12747 variable declarations or definitions. */
12748 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
12752 case NAMESPACE_DECL
:
12753 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
12755 if (lookup_decl_die (decl
) != NULL
)
12760 /* Don't emit stubs for types unless they are needed by other DIEs. */
12761 if (TYPE_DECL_SUPPRESS_DEBUG (decl
))
12764 /* Don't bother trying to generate any DIEs to represent any of the
12765 normal built-in types for the language we are compiling. */
12766 if (DECL_SOURCE_LINE (decl
) == 0)
12768 /* OK, we need to generate one for `bool' so GDB knows what type
12769 comparisons have. */
12770 if ((get_AT_unsigned (comp_unit_die
, DW_AT_language
)
12771 == DW_LANG_C_plus_plus
)
12772 && TREE_CODE (TREE_TYPE (decl
)) == BOOLEAN_TYPE
12773 && ! DECL_IGNORED_P (decl
))
12774 modified_type_die (TREE_TYPE (decl
), 0, 0, NULL
);
12779 /* If we are in terse mode, don't generate any DIEs for types. */
12780 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
12783 /* If we're a function-scope tag, initially use a parent of NULL;
12784 this will be fixed up in decls_for_scope. */
12785 if (decl_function_context (decl
))
12786 context_die
= NULL
;
12794 gen_decl_die (decl
, context_die
);
12797 /* Output a marker (i.e. a label) for the beginning of the generated code for
12798 a lexical block. */
12801 dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED
,
12802 unsigned int blocknum
)
12804 function_section (current_function_decl
);
12805 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, BLOCK_BEGIN_LABEL
, blocknum
);
12808 /* Output a marker (i.e. a label) for the end of the generated code for a
12812 dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED
, unsigned int blocknum
)
12814 function_section (current_function_decl
);
12815 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, BLOCK_END_LABEL
, blocknum
);
12818 /* Returns nonzero if it is appropriate not to emit any debugging
12819 information for BLOCK, because it doesn't contain any instructions.
12821 Don't allow this for blocks with nested functions or local classes
12822 as we would end up with orphans, and in the presence of scheduling
12823 we may end up calling them anyway. */
12826 dwarf2out_ignore_block (tree block
)
12830 for (decl
= BLOCK_VARS (block
); decl
; decl
= TREE_CHAIN (decl
))
12831 if (TREE_CODE (decl
) == FUNCTION_DECL
12832 || (TREE_CODE (decl
) == TYPE_DECL
&& TYPE_DECL_IS_STUB (decl
)))
12838 /* Lookup FILE_NAME (in the list of filenames that we know about here in
12839 dwarf2out.c) and return its "index". The index of each (known) filename is
12840 just a unique number which is associated with only that one filename. We
12841 need such numbers for the sake of generating labels (in the .debug_sfnames
12842 section) and references to those files numbers (in the .debug_srcinfo
12843 and.debug_macinfo sections). If the filename given as an argument is not
12844 found in our current list, add it to the list and assign it the next
12845 available unique index number. In order to speed up searches, we remember
12846 the index of the filename was looked up last. This handles the majority of
12850 lookup_filename (const char *file_name
)
12853 char *save_file_name
;
12855 /* Check to see if the file name that was searched on the previous
12856 call matches this file name. If so, return the index. */
12857 if (file_table_last_lookup_index
!= 0)
12860 = VARRAY_CHAR_PTR (file_table
, file_table_last_lookup_index
);
12861 if (strcmp (file_name
, last
) == 0)
12862 return file_table_last_lookup_index
;
12865 /* Didn't match the previous lookup, search the table */
12866 n
= VARRAY_ACTIVE_SIZE (file_table
);
12867 for (i
= 1; i
< n
; i
++)
12868 if (strcmp (file_name
, VARRAY_CHAR_PTR (file_table
, i
)) == 0)
12870 file_table_last_lookup_index
= i
;
12874 /* Add the new entry to the end of the filename table. */
12875 file_table_last_lookup_index
= n
;
12876 save_file_name
= (char *) ggc_strdup (file_name
);
12877 VARRAY_PUSH_CHAR_PTR (file_table
, save_file_name
);
12878 VARRAY_PUSH_UINT (file_table_emitted
, 0);
12884 maybe_emit_file (int fileno
)
12886 if (DWARF2_ASM_LINE_DEBUG_INFO
&& fileno
> 0)
12888 if (!VARRAY_UINT (file_table_emitted
, fileno
))
12890 VARRAY_UINT (file_table_emitted
, fileno
) = ++emitcount
;
12891 fprintf (asm_out_file
, "\t.file %u ",
12892 VARRAY_UINT (file_table_emitted
, fileno
));
12893 output_quoted_string (asm_out_file
,
12894 VARRAY_CHAR_PTR (file_table
, fileno
));
12895 fputc ('\n', asm_out_file
);
12897 return VARRAY_UINT (file_table_emitted
, fileno
);
12904 init_file_table (void)
12906 /* Allocate the initial hunk of the file_table. */
12907 VARRAY_CHAR_PTR_INIT (file_table
, 64, "file_table");
12908 VARRAY_UINT_INIT (file_table_emitted
, 64, "file_table_emitted");
12910 /* Skip the first entry - file numbers begin at 1. */
12911 VARRAY_PUSH_CHAR_PTR (file_table
, NULL
);
12912 VARRAY_PUSH_UINT (file_table_emitted
, 0);
12913 file_table_last_lookup_index
= 0;
12916 /* Called by the final INSN scan whenever we see a var location. We
12917 use it to drop labels in the right places, and throw the location in
12918 our lookup table. */
12921 dwarf2out_var_location (rtx loc_note
)
12923 char loclabel
[MAX_ARTIFICIAL_LABEL_BYTES
];
12924 struct var_loc_node
*newloc
;
12926 static rtx last_insn
;
12927 static const char *last_label
;
12929 if (!DECL_P (NOTE_VAR_LOCATION_DECL (loc_note
)))
12931 prev_insn
= PREV_INSN (loc_note
);
12933 newloc
= ggc_alloc_cleared (sizeof (struct var_loc_node
));
12934 /* If the insn we processed last time is the previous insn
12935 and it is also a var location note, use the label we emitted
12937 if (last_insn
!= NULL_RTX
12938 && last_insn
== prev_insn
12939 && GET_CODE (prev_insn
) == NOTE
12940 && NOTE_LINE_NUMBER (prev_insn
) == NOTE_INSN_VAR_LOCATION
)
12942 newloc
->label
= last_label
;
12946 ASM_GENERATE_INTERNAL_LABEL (loclabel
, "LVL", loclabel_num
);
12947 ASM_OUTPUT_DEBUG_LABEL (asm_out_file
, "LVL", loclabel_num
);
12949 newloc
->label
= ggc_strdup (loclabel
);
12951 newloc
->var_loc_note
= loc_note
;
12952 newloc
->next
= NULL
;
12954 last_insn
= loc_note
;
12955 last_label
= newloc
->label
;
12957 add_var_loc_to_decl (NOTE_VAR_LOCATION_DECL (loc_note
), newloc
);
12960 /* We need to reset the locations at the beginning of each
12961 function. We can't do this in the end_function hook, because the
12962 declarations that use the locations won't have been outputted when
12963 that hook is called. */
12966 dwarf2out_begin_function (tree unused ATTRIBUTE_UNUSED
)
12968 htab_empty (decl_loc_table
);
12971 /* Output a label to mark the beginning of a source code line entry
12972 and record information relating to this source line, in
12973 'line_info_table' for later output of the .debug_line section. */
12976 dwarf2out_source_line (unsigned int line
, const char *filename
)
12978 if (debug_info_level
>= DINFO_LEVEL_NORMAL
12981 function_section (current_function_decl
);
12983 /* If requested, emit something human-readable. */
12984 if (flag_debug_asm
)
12985 fprintf (asm_out_file
, "\t%s %s:%d\n", ASM_COMMENT_START
,
12988 if (DWARF2_ASM_LINE_DEBUG_INFO
)
12990 unsigned file_num
= lookup_filename (filename
);
12992 file_num
= maybe_emit_file (file_num
);
12994 /* Emit the .loc directive understood by GNU as. */
12995 fprintf (asm_out_file
, "\t.loc %d %d 0\n", file_num
, line
);
12997 /* Indicate that line number info exists. */
12998 line_info_table_in_use
++;
13000 /* Indicate that multiple line number tables exist. */
13001 if (DECL_SECTION_NAME (current_function_decl
))
13002 separate_line_info_table_in_use
++;
13004 else if (DECL_SECTION_NAME (current_function_decl
))
13006 dw_separate_line_info_ref line_info
;
13007 (*targetm
.asm_out
.internal_label
) (asm_out_file
, SEPARATE_LINE_CODE_LABEL
,
13008 separate_line_info_table_in_use
);
13010 /* Expand the line info table if necessary. */
13011 if (separate_line_info_table_in_use
13012 == separate_line_info_table_allocated
)
13014 separate_line_info_table_allocated
+= LINE_INFO_TABLE_INCREMENT
;
13015 separate_line_info_table
13016 = ggc_realloc (separate_line_info_table
,
13017 separate_line_info_table_allocated
13018 * sizeof (dw_separate_line_info_entry
));
13019 memset (separate_line_info_table
13020 + separate_line_info_table_in_use
,
13022 (LINE_INFO_TABLE_INCREMENT
13023 * sizeof (dw_separate_line_info_entry
)));
13026 /* Add the new entry at the end of the line_info_table. */
13028 = &separate_line_info_table
[separate_line_info_table_in_use
++];
13029 line_info
->dw_file_num
= lookup_filename (filename
);
13030 line_info
->dw_line_num
= line
;
13031 line_info
->function
= current_function_funcdef_no
;
13035 dw_line_info_ref line_info
;
13037 (*targetm
.asm_out
.internal_label
) (asm_out_file
, LINE_CODE_LABEL
,
13038 line_info_table_in_use
);
13040 /* Expand the line info table if necessary. */
13041 if (line_info_table_in_use
== line_info_table_allocated
)
13043 line_info_table_allocated
+= LINE_INFO_TABLE_INCREMENT
;
13045 = ggc_realloc (line_info_table
,
13046 (line_info_table_allocated
13047 * sizeof (dw_line_info_entry
)));
13048 memset (line_info_table
+ line_info_table_in_use
, 0,
13049 LINE_INFO_TABLE_INCREMENT
* sizeof (dw_line_info_entry
));
13052 /* Add the new entry at the end of the line_info_table. */
13053 line_info
= &line_info_table
[line_info_table_in_use
++];
13054 line_info
->dw_file_num
= lookup_filename (filename
);
13055 line_info
->dw_line_num
= line
;
13060 /* Record the beginning of a new source file. */
13063 dwarf2out_start_source_file (unsigned int lineno
, const char *filename
)
13065 if (flag_eliminate_dwarf2_dups
)
13067 /* Record the beginning of the file for break_out_includes. */
13068 dw_die_ref bincl_die
;
13070 bincl_die
= new_die (DW_TAG_GNU_BINCL
, comp_unit_die
, NULL
);
13071 add_AT_string (bincl_die
, DW_AT_name
, filename
);
13074 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
13076 named_section_flags (DEBUG_MACINFO_SECTION
, SECTION_DEBUG
);
13077 dw2_asm_output_data (1, DW_MACINFO_start_file
, "Start new file");
13078 dw2_asm_output_data_uleb128 (lineno
, "Included from line number %d",
13080 maybe_emit_file (lookup_filename (filename
));
13081 dw2_asm_output_data_uleb128 (lookup_filename (filename
),
13082 "Filename we just started");
13086 /* Record the end of a source file. */
13089 dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED
)
13091 if (flag_eliminate_dwarf2_dups
)
13092 /* Record the end of the file for break_out_includes. */
13093 new_die (DW_TAG_GNU_EINCL
, comp_unit_die
, NULL
);
13095 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
13097 named_section_flags (DEBUG_MACINFO_SECTION
, SECTION_DEBUG
);
13098 dw2_asm_output_data (1, DW_MACINFO_end_file
, "End file");
13102 /* Called from debug_define in toplev.c. The `buffer' parameter contains
13103 the tail part of the directive line, i.e. the part which is past the
13104 initial whitespace, #, whitespace, directive-name, whitespace part. */
13107 dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED
,
13108 const char *buffer ATTRIBUTE_UNUSED
)
13110 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
13112 named_section_flags (DEBUG_MACINFO_SECTION
, SECTION_DEBUG
);
13113 dw2_asm_output_data (1, DW_MACINFO_define
, "Define macro");
13114 dw2_asm_output_data_uleb128 (lineno
, "At line number %d", lineno
);
13115 dw2_asm_output_nstring (buffer
, -1, "The macro");
13119 /* Called from debug_undef in toplev.c. The `buffer' parameter contains
13120 the tail part of the directive line, i.e. the part which is past the
13121 initial whitespace, #, whitespace, directive-name, whitespace part. */
13124 dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED
,
13125 const char *buffer ATTRIBUTE_UNUSED
)
13127 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
13129 named_section_flags (DEBUG_MACINFO_SECTION
, SECTION_DEBUG
);
13130 dw2_asm_output_data (1, DW_MACINFO_undef
, "Undefine macro");
13131 dw2_asm_output_data_uleb128 (lineno
, "At line number %d", lineno
);
13132 dw2_asm_output_nstring (buffer
, -1, "The macro");
13136 /* Set up for Dwarf output at the start of compilation. */
13139 dwarf2out_init (const char *filename ATTRIBUTE_UNUSED
)
13141 init_file_table ();
13143 /* Allocate the decl_die_table. */
13144 decl_die_table
= htab_create_ggc (10, decl_die_table_hash
,
13145 decl_die_table_eq
, NULL
);
13147 /* Allocate the decl_loc_table. */
13148 decl_loc_table
= htab_create_ggc (10, decl_loc_table_hash
,
13149 decl_loc_table_eq
, NULL
);
13151 /* Allocate the initial hunk of the decl_scope_table. */
13152 VARRAY_TREE_INIT (decl_scope_table
, 256, "decl_scope_table");
13154 /* Allocate the initial hunk of the abbrev_die_table. */
13155 abbrev_die_table
= ggc_alloc_cleared (ABBREV_DIE_TABLE_INCREMENT
13156 * sizeof (dw_die_ref
));
13157 abbrev_die_table_allocated
= ABBREV_DIE_TABLE_INCREMENT
;
13158 /* Zero-th entry is allocated, but unused */
13159 abbrev_die_table_in_use
= 1;
13161 /* Allocate the initial hunk of the line_info_table. */
13162 line_info_table
= ggc_alloc_cleared (LINE_INFO_TABLE_INCREMENT
13163 * sizeof (dw_line_info_entry
));
13164 line_info_table_allocated
= LINE_INFO_TABLE_INCREMENT
;
13166 /* Zero-th entry is allocated, but unused */
13167 line_info_table_in_use
= 1;
13169 /* Generate the initial DIE for the .debug section. Note that the (string)
13170 value given in the DW_AT_name attribute of the DW_TAG_compile_unit DIE
13171 will (typically) be a relative pathname and that this pathname should be
13172 taken as being relative to the directory from which the compiler was
13173 invoked when the given (base) source file was compiled. We will fill
13174 in this value in dwarf2out_finish. */
13175 comp_unit_die
= gen_compile_unit_die (NULL
);
13177 VARRAY_TREE_INIT (incomplete_types
, 64, "incomplete_types");
13179 VARRAY_RTX_INIT (used_rtx_varray
, 32, "used_rtx_varray");
13181 ASM_GENERATE_INTERNAL_LABEL (text_end_label
, TEXT_END_LABEL
, 0);
13182 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label
,
13183 DEBUG_ABBREV_SECTION_LABEL
, 0);
13184 if (DWARF2_GENERATE_TEXT_SECTION_LABEL
)
13185 ASM_GENERATE_INTERNAL_LABEL (text_section_label
, TEXT_SECTION_LABEL
, 0);
13187 strcpy (text_section_label
, stripattributes (TEXT_SECTION_NAME
));
13189 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label
,
13190 DEBUG_INFO_SECTION_LABEL
, 0);
13191 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label
,
13192 DEBUG_LINE_SECTION_LABEL
, 0);
13193 ASM_GENERATE_INTERNAL_LABEL (ranges_section_label
,
13194 DEBUG_RANGES_SECTION_LABEL
, 0);
13195 named_section_flags (DEBUG_ABBREV_SECTION
, SECTION_DEBUG
);
13196 ASM_OUTPUT_LABEL (asm_out_file
, abbrev_section_label
);
13197 named_section_flags (DEBUG_INFO_SECTION
, SECTION_DEBUG
);
13198 ASM_OUTPUT_LABEL (asm_out_file
, debug_info_section_label
);
13199 named_section_flags (DEBUG_LINE_SECTION
, SECTION_DEBUG
);
13200 ASM_OUTPUT_LABEL (asm_out_file
, debug_line_section_label
);
13202 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
13204 named_section_flags (DEBUG_MACINFO_SECTION
, SECTION_DEBUG
);
13205 ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label
,
13206 DEBUG_MACINFO_SECTION_LABEL
, 0);
13207 ASM_OUTPUT_LABEL (asm_out_file
, macinfo_section_label
);
13210 if (DWARF2_GENERATE_TEXT_SECTION_LABEL
)
13213 ASM_OUTPUT_LABEL (asm_out_file
, text_section_label
);
13217 /* A helper function for dwarf2out_finish called through
13218 ht_forall. Emit one queued .debug_str string. */
13221 output_indirect_string (void **h
, void *v ATTRIBUTE_UNUSED
)
13223 struct indirect_string_node
*node
= (struct indirect_string_node
*) *h
;
13225 if (node
->form
== DW_FORM_strp
)
13227 named_section_flags (DEBUG_STR_SECTION
, DEBUG_STR_SECTION_FLAGS
);
13228 ASM_OUTPUT_LABEL (asm_out_file
, node
->label
);
13229 assemble_string (node
->str
, strlen (node
->str
) + 1);
13237 /* Clear the marks for a die and its children.
13238 Be cool if the mark isn't set. */
13241 prune_unmark_dies (dw_die_ref die
)
13245 for (c
= die
->die_child
; c
; c
= c
->die_sib
)
13246 prune_unmark_dies (c
);
13250 /* Given DIE that we're marking as used, find any other dies
13251 it references as attributes and mark them as used. */
13254 prune_unused_types_walk_attribs (dw_die_ref die
)
13258 for (a
= die
->die_attr
; a
!= NULL
; a
= a
->dw_attr_next
)
13260 if (a
->dw_attr_val
.val_class
== dw_val_class_die_ref
)
13262 /* A reference to another DIE.
13263 Make sure that it will get emitted. */
13264 prune_unused_types_mark (a
->dw_attr_val
.v
.val_die_ref
.die
, 1);
13266 else if (a
->dw_attr
== DW_AT_decl_file
)
13268 /* A reference to a file. Make sure the file name is emitted. */
13269 a
->dw_attr_val
.v
.val_unsigned
=
13270 maybe_emit_file (a
->dw_attr_val
.v
.val_unsigned
);
13276 /* Mark DIE as being used. If DOKIDS is true, then walk down
13277 to DIE's children. */
13280 prune_unused_types_mark (dw_die_ref die
, int dokids
)
13284 if (die
->die_mark
== 0)
13286 /* We haven't done this node yet. Mark it as used. */
13289 /* We also have to mark its parents as used.
13290 (But we don't want to mark our parents' kids due to this.) */
13291 if (die
->die_parent
)
13292 prune_unused_types_mark (die
->die_parent
, 0);
13294 /* Mark any referenced nodes. */
13295 prune_unused_types_walk_attribs (die
);
13297 /* If this node is a specification,
13298 also mark the definition, if it exists. */
13299 if (get_AT_flag (die
, DW_AT_declaration
) && die
->die_definition
)
13300 prune_unused_types_mark (die
->die_definition
, 1);
13303 if (dokids
&& die
->die_mark
!= 2)
13305 /* We need to walk the children, but haven't done so yet.
13306 Remember that we've walked the kids. */
13310 for (c
= die
->die_child
; c
; c
= c
->die_sib
)
13312 /* If this is an array type, we need to make sure our
13313 kids get marked, even if they're types. */
13314 if (die
->die_tag
== DW_TAG_array_type
)
13315 prune_unused_types_mark (c
, 1);
13317 prune_unused_types_walk (c
);
13323 /* Walk the tree DIE and mark types that we actually use. */
13326 prune_unused_types_walk (dw_die_ref die
)
13330 /* Don't do anything if this node is already marked. */
13334 switch (die
->die_tag
) {
13335 case DW_TAG_const_type
:
13336 case DW_TAG_packed_type
:
13337 case DW_TAG_pointer_type
:
13338 case DW_TAG_reference_type
:
13339 case DW_TAG_volatile_type
:
13340 case DW_TAG_typedef
:
13341 case DW_TAG_array_type
:
13342 case DW_TAG_structure_type
:
13343 case DW_TAG_union_type
:
13344 case DW_TAG_class_type
:
13345 case DW_TAG_friend
:
13346 case DW_TAG_variant_part
:
13347 case DW_TAG_enumeration_type
:
13348 case DW_TAG_subroutine_type
:
13349 case DW_TAG_string_type
:
13350 case DW_TAG_set_type
:
13351 case DW_TAG_subrange_type
:
13352 case DW_TAG_ptr_to_member_type
:
13353 case DW_TAG_file_type
:
13354 /* It's a type node --- don't mark it. */
13358 /* Mark everything else. */
13364 /* Now, mark any dies referenced from here. */
13365 prune_unused_types_walk_attribs (die
);
13367 /* Mark children. */
13368 for (c
= die
->die_child
; c
; c
= c
->die_sib
)
13369 prune_unused_types_walk (c
);
13373 /* Remove from the tree DIE any dies that aren't marked. */
13376 prune_unused_types_prune (dw_die_ref die
)
13378 dw_die_ref c
, p
, n
;
13379 if (!die
->die_mark
)
13383 for (c
= die
->die_child
; c
; c
= n
)
13388 prune_unused_types_prune (c
);
13396 die
->die_child
= n
;
13403 /* Remove dies representing declarations that we never use. */
13406 prune_unused_types (void)
13409 limbo_die_node
*node
;
13411 /* Clear all the marks. */
13412 prune_unmark_dies (comp_unit_die
);
13413 for (node
= limbo_die_list
; node
; node
= node
->next
)
13414 prune_unmark_dies (node
->die
);
13416 /* Set the mark on nodes that are actually used. */
13417 prune_unused_types_walk (comp_unit_die
);
13418 for (node
= limbo_die_list
; node
; node
= node
->next
)
13419 prune_unused_types_walk (node
->die
);
13421 /* Also set the mark on nodes referenced from the
13422 pubname_table or arange_table. */
13423 for (i
= 0; i
< pubname_table_in_use
; i
++)
13424 prune_unused_types_mark (pubname_table
[i
].die
, 1);
13425 for (i
= 0; i
< arange_table_in_use
; i
++)
13426 prune_unused_types_mark (arange_table
[i
], 1);
13428 /* Get rid of nodes that aren't marked. */
13429 prune_unused_types_prune (comp_unit_die
);
13430 for (node
= limbo_die_list
; node
; node
= node
->next
)
13431 prune_unused_types_prune (node
->die
);
13433 /* Leave the marks clear. */
13434 prune_unmark_dies (comp_unit_die
);
13435 for (node
= limbo_die_list
; node
; node
= node
->next
)
13436 prune_unmark_dies (node
->die
);
13439 /* Output stuff that dwarf requires at the end of every file,
13440 and generate the DWARF-2 debugging info. */
13443 dwarf2out_finish (const char *filename
)
13445 limbo_die_node
*node
, *next_node
;
13446 dw_die_ref die
= 0;
13448 /* Add the name for the main input file now. We delayed this from
13449 dwarf2out_init to avoid complications with PCH. */
13450 add_name_attribute (comp_unit_die
, filename
);
13451 if (filename
[0] != DIR_SEPARATOR
)
13452 add_comp_dir_attribute (comp_unit_die
);
13453 else if (get_AT (comp_unit_die
, DW_AT_comp_dir
) == NULL
)
13456 for (i
= 1; i
< VARRAY_ACTIVE_SIZE (file_table
); i
++)
13457 if (VARRAY_CHAR_PTR (file_table
, i
)[0] != DIR_SEPARATOR
13458 /* Don't add cwd for <built-in>. */
13459 && VARRAY_CHAR_PTR (file_table
, i
)[0] != '<')
13461 add_comp_dir_attribute (comp_unit_die
);
13466 /* Traverse the limbo die list, and add parent/child links. The only
13467 dies without parents that should be here are concrete instances of
13468 inline functions, and the comp_unit_die. We can ignore the comp_unit_die.
13469 For concrete instances, we can get the parent die from the abstract
13471 for (node
= limbo_die_list
; node
; node
= next_node
)
13473 next_node
= node
->next
;
13476 if (die
->die_parent
== NULL
)
13478 dw_die_ref origin
= get_AT_ref (die
, DW_AT_abstract_origin
);
13482 add_child_die (origin
->die_parent
, die
);
13483 else if (die
== comp_unit_die
)
13485 /* If this was an expression for a bound involved in a function
13486 return type, it may be a SAVE_EXPR for which we weren't able
13487 to find a DIE previously. So try now. */
13488 else if (node
->created_for
13489 && TREE_CODE (node
->created_for
) == SAVE_EXPR
13490 && 0 != (origin
= (lookup_decl_die
13492 (node
->created_for
)))))
13493 add_child_die (origin
, die
);
13494 else if (errorcount
> 0 || sorrycount
> 0)
13495 /* It's OK to be confused by errors in the input. */
13496 add_child_die (comp_unit_die
, die
);
13497 else if (node
->created_for
13498 && ((DECL_P (node
->created_for
)
13499 && (context
= DECL_CONTEXT (node
->created_for
)))
13500 || (TYPE_P (node
->created_for
)
13501 && (context
= TYPE_CONTEXT (node
->created_for
))))
13502 && TREE_CODE (context
) == FUNCTION_DECL
)
13504 /* In certain situations, the lexical block containing a
13505 nested function can be optimized away, which results
13506 in the nested function die being orphaned. Likewise
13507 with the return type of that nested function. Force
13508 this to be a child of the containing function. */
13509 origin
= lookup_decl_die (context
);
13512 add_child_die (origin
, die
);
13519 limbo_die_list
= NULL
;
13521 /* Walk through the list of incomplete types again, trying once more to
13522 emit full debugging info for them. */
13523 retry_incomplete_types ();
13525 /* We need to reverse all the dies before break_out_includes, or
13526 we'll see the end of an include file before the beginning. */
13527 reverse_all_dies (comp_unit_die
);
13529 if (flag_eliminate_unused_debug_types
)
13530 prune_unused_types ();
13532 /* Generate separate CUs for each of the include files we've seen.
13533 They will go into limbo_die_list. */
13534 if (flag_eliminate_dwarf2_dups
)
13535 break_out_includes (comp_unit_die
);
13537 /* Traverse the DIE's and add add sibling attributes to those DIE's
13538 that have children. */
13539 add_sibling_attributes (comp_unit_die
);
13540 for (node
= limbo_die_list
; node
; node
= node
->next
)
13541 add_sibling_attributes (node
->die
);
13543 /* Output a terminator label for the .text section. */
13545 (*targetm
.asm_out
.internal_label
) (asm_out_file
, TEXT_END_LABEL
, 0);
13547 /* Output the source line correspondence table. We must do this
13548 even if there is no line information. Otherwise, on an empty
13549 translation unit, we will generate a present, but empty,
13550 .debug_info section. IRIX 6.5 `nm' will then complain when
13551 examining the file. */
13552 if (! DWARF2_ASM_LINE_DEBUG_INFO
)
13554 named_section_flags (DEBUG_LINE_SECTION
, SECTION_DEBUG
);
13555 output_line_info ();
13558 /* Output location list section if necessary. */
13559 if (have_location_lists
)
13561 /* Output the location lists info. */
13562 named_section_flags (DEBUG_LOC_SECTION
, SECTION_DEBUG
);
13563 ASM_GENERATE_INTERNAL_LABEL (loc_section_label
,
13564 DEBUG_LOC_SECTION_LABEL
, 0);
13565 ASM_OUTPUT_LABEL (asm_out_file
, loc_section_label
);
13566 output_location_lists (die
);
13567 have_location_lists
= 0;
13570 /* We can only use the low/high_pc attributes if all of the code was
13572 if (separate_line_info_table_in_use
== 0)
13574 add_AT_lbl_id (comp_unit_die
, DW_AT_low_pc
, text_section_label
);
13575 add_AT_lbl_id (comp_unit_die
, DW_AT_high_pc
, text_end_label
);
13578 /* If it wasn't, we need to give .debug_loc and .debug_ranges an appropriate
13579 "base address". Use zero so that these addresses become absolute. */
13580 else if (have_location_lists
|| ranges_table_in_use
)
13581 add_AT_addr (comp_unit_die
, DW_AT_entry_pc
, const0_rtx
);
13583 if (debug_info_level
>= DINFO_LEVEL_NORMAL
)
13584 add_AT_lbl_offset (comp_unit_die
, DW_AT_stmt_list
,
13585 debug_line_section_label
);
13587 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
13588 add_AT_lbl_offset (comp_unit_die
, DW_AT_macro_info
, macinfo_section_label
);
13590 /* Output all of the compilation units. We put the main one last so that
13591 the offsets are available to output_pubnames. */
13592 for (node
= limbo_die_list
; node
; node
= node
->next
)
13593 output_comp_unit (node
->die
, 0);
13595 output_comp_unit (comp_unit_die
, 0);
13597 /* Output the abbreviation table. */
13598 named_section_flags (DEBUG_ABBREV_SECTION
, SECTION_DEBUG
);
13599 output_abbrev_section ();
13601 /* Output public names table if necessary. */
13602 if (pubname_table_in_use
)
13604 named_section_flags (DEBUG_PUBNAMES_SECTION
, SECTION_DEBUG
);
13605 output_pubnames ();
13608 /* Output the address range information. We only put functions in the arange
13609 table, so don't write it out if we don't have any. */
13610 if (fde_table_in_use
)
13612 named_section_flags (DEBUG_ARANGES_SECTION
, SECTION_DEBUG
);
13616 /* Output ranges section if necessary. */
13617 if (ranges_table_in_use
)
13619 named_section_flags (DEBUG_RANGES_SECTION
, SECTION_DEBUG
);
13620 ASM_OUTPUT_LABEL (asm_out_file
, ranges_section_label
);
13624 /* Have to end the primary source file. */
13625 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
13627 named_section_flags (DEBUG_MACINFO_SECTION
, SECTION_DEBUG
);
13628 dw2_asm_output_data (1, DW_MACINFO_end_file
, "End file");
13629 dw2_asm_output_data (1, 0, "End compilation unit");
13632 /* If we emitted any DW_FORM_strp form attribute, output the string
13634 if (debug_str_hash
)
13635 htab_traverse (debug_str_hash
, output_indirect_string
, NULL
);
13639 /* This should never be used, but its address is needed for comparisons. */
13640 const struct gcc_debug_hooks dwarf2_debug_hooks
;
13642 #endif /* DWARF2_DEBUGGING_INFO */
13644 #include "gt-dwarf2out.h"