1 /* Output Dwarf2 format symbol table information from GCC.
2 Copyright (C) 1992, 1993, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
3 2003, 2004, 2005, 2006 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, 51 Franklin Street, Fifth Floor, Boston, MA
25 /* TODO: Emit .debug_line header even when there are no functions, since
26 the file numbers are used by .debug_info. Alternately, leave
27 out locations for types and decls.
28 Avoid talking about ctors and op= for PODs.
29 Factor out common prologue sequences into multiple CIEs. */
31 /* The first part of this file deals with the DWARF 2 frame unwind
32 information, which is also used by the GCC efficient exception handling
33 mechanism. The second part, controlled only by an #ifdef
34 DWARF2_DEBUGGING_INFO, deals with the other DWARF 2 debugging
39 #include "coretypes.h"
46 #include "hard-reg-set.h"
48 #include "insn-config.h"
56 #include "dwarf2out.h"
57 #include "dwarf2asm.h"
63 #include "diagnostic.h"
66 #include "langhooks.h"
71 #ifdef DWARF2_DEBUGGING_INFO
72 static void dwarf2out_source_line (unsigned int, const char *);
75 /* DWARF2 Abbreviation Glossary:
76 CFA = Canonical Frame Address
77 a fixed address on the stack which identifies a call frame.
78 We define it to be the value of SP just before the call insn.
79 The CFA register and offset, which may change during the course
80 of the function, are used to calculate its value at runtime.
81 CFI = Call Frame Instruction
82 an instruction for the DWARF2 abstract machine
83 CIE = Common Information Entry
84 information describing information common to one or more FDEs
85 DIE = Debugging Information Entry
86 FDE = Frame Description Entry
87 information describing the stack call frame, in particular,
88 how to restore registers
90 DW_CFA_... = DWARF2 CFA call frame instruction
91 DW_TAG_... = DWARF2 DIE tag */
93 #ifndef DWARF2_FRAME_INFO
94 # ifdef DWARF2_DEBUGGING_INFO
95 # define DWARF2_FRAME_INFO \
96 (write_symbols == DWARF2_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
98 # define DWARF2_FRAME_INFO 0
102 /* Decide whether we want to emit frame unwind information for the current
106 dwarf2out_do_frame (void)
108 /* We want to emit correct CFA location expressions or lists, so we
109 have to return true if we're going to output debug info, even if
110 we're not going to output frame or unwind info. */
111 return (write_symbols == DWARF2_DEBUG
112 || write_symbols == VMS_AND_DWARF2_DEBUG
114 #ifdef DWARF2_UNWIND_INFO
115 || (DWARF2_UNWIND_INFO
116 && (flag_unwind_tables
117 || (flag_exceptions && ! USING_SJLJ_EXCEPTIONS)))
122 /* The size of the target's pointer type. */
124 #define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
127 /* Various versions of targetm.eh_frame_section. Note these must appear
128 outside the DWARF2_DEBUGGING_INFO || DWARF2_UNWIND_INFO macro guards. */
130 /* Version of targetm.eh_frame_section for systems with named sections. */
132 named_section_eh_frame_section (void)
134 #ifdef EH_FRAME_SECTION_NAME
137 if (EH_TABLES_CAN_BE_READ_ONLY)
143 fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0);
144 per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
145 lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
147 || ((fde_encoding & 0x70) != DW_EH_PE_absptr
148 && (fde_encoding & 0x70) != DW_EH_PE_aligned
149 && (per_encoding & 0x70) != DW_EH_PE_absptr
150 && (per_encoding & 0x70) != DW_EH_PE_aligned
151 && (lsda_encoding & 0x70) != DW_EH_PE_absptr
152 && (lsda_encoding & 0x70) != DW_EH_PE_aligned))
156 flags = SECTION_WRITE;
157 named_section_flags (EH_FRAME_SECTION_NAME, flags);
161 /* Version of targetm.eh_frame_section for systems using collect2. */
163 collect2_eh_frame_section (void)
165 tree label = get_file_function_name ('F');
168 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
169 targetm.asm_out.globalize_label (asm_out_file, IDENTIFIER_POINTER (label));
170 ASM_OUTPUT_LABEL (asm_out_file, IDENTIFIER_POINTER (label));
173 /* Default version of targetm.eh_frame_section. */
175 default_eh_frame_section (void)
177 #ifdef EH_FRAME_SECTION_NAME
178 named_section_eh_frame_section ();
180 collect2_eh_frame_section ();
185 DEF_VEC_ALLOC_P(rtx,gc);
187 /* Array of RTXes referenced by the debugging information, which therefore
188 must be kept around forever. */
189 static GTY(()) VEC(rtx,gc) *used_rtx_array;
191 /* A pointer to the base of a list of incomplete types which might be
192 completed at some later time. incomplete_types_list needs to be a
193 VEC(tree,gc) because we want to tell the garbage collector about
195 static GTY(()) VEC(tree,gc) *incomplete_types;
197 /* A pointer to the base of a table of references to declaration
198 scopes. This table is a display which tracks the nesting
199 of declaration scopes at the current scope and containing
200 scopes. This table is used to find the proper place to
201 define type declaration DIE's. */
202 static GTY(()) VEC(tree,gc) *decl_scope_table;
204 /* How to start an assembler comment. */
205 #ifndef ASM_COMMENT_START
206 #define ASM_COMMENT_START ";#"
209 typedef struct dw_cfi_struct *dw_cfi_ref;
210 typedef struct dw_fde_struct *dw_fde_ref;
211 typedef union dw_cfi_oprnd_struct *dw_cfi_oprnd_ref;
213 /* Call frames are described using a sequence of Call Frame
214 Information instructions. The register number, offset
215 and address fields are provided as possible operands;
216 their use is selected by the opcode field. */
218 enum dw_cfi_oprnd_type {
220 dw_cfi_oprnd_reg_num,
226 typedef union dw_cfi_oprnd_struct GTY(())
228 unsigned int GTY ((tag ("dw_cfi_oprnd_reg_num"))) dw_cfi_reg_num;
229 HOST_WIDE_INT GTY ((tag ("dw_cfi_oprnd_offset"))) dw_cfi_offset;
230 const char * GTY ((tag ("dw_cfi_oprnd_addr"))) dw_cfi_addr;
231 struct dw_loc_descr_struct * GTY ((tag ("dw_cfi_oprnd_loc"))) dw_cfi_loc;
235 typedef struct dw_cfi_struct GTY(())
237 dw_cfi_ref dw_cfi_next;
238 enum dwarf_call_frame_info dw_cfi_opc;
239 dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd1_desc (%1.dw_cfi_opc)")))
241 dw_cfi_oprnd GTY ((desc ("dw_cfi_oprnd2_desc (%1.dw_cfi_opc)")))
246 /* This is how we define the location of the CFA. We use to handle it
247 as REG + OFFSET all the time, but now it can be more complex.
248 It can now be either REG + CFA_OFFSET or *(REG + BASE_OFFSET) + CFA_OFFSET.
249 Instead of passing around REG and OFFSET, we pass a copy
250 of this structure. */
251 typedef struct cfa_loc GTY(())
253 HOST_WIDE_INT offset;
254 HOST_WIDE_INT base_offset;
256 int indirect; /* 1 if CFA is accessed via a dereference. */
259 /* All call frame descriptions (FDE's) in the GCC generated DWARF
260 refer to a single Common Information Entry (CIE), defined at
261 the beginning of the .debug_frame section. This use of a single
262 CIE obviates the need to keep track of multiple CIE's
263 in the DWARF generation routines below. */
265 typedef struct dw_fde_struct GTY(())
268 const char *dw_fde_begin;
269 const char *dw_fde_current_label;
270 const char *dw_fde_end;
271 const char *dw_fde_hot_section_label;
272 const char *dw_fde_hot_section_end_label;
273 const char *dw_fde_unlikely_section_label;
274 const char *dw_fde_unlikely_section_end_label;
275 bool dw_fde_switched_sections;
276 dw_cfi_ref dw_fde_cfi;
277 unsigned funcdef_number;
278 unsigned all_throwers_are_sibcalls : 1;
279 unsigned nothrow : 1;
280 unsigned uses_eh_lsda : 1;
284 /* Maximum size (in bytes) of an artificially generated label. */
285 #define MAX_ARTIFICIAL_LABEL_BYTES 30
287 /* The size of addresses as they appear in the Dwarf 2 data.
288 Some architectures use word addresses to refer to code locations,
289 but Dwarf 2 info always uses byte addresses. On such machines,
290 Dwarf 2 addresses need to be larger than the architecture's
292 #ifndef DWARF2_ADDR_SIZE
293 #define DWARF2_ADDR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
296 /* The size in bytes of a DWARF field indicating an offset or length
297 relative to a debug info section, specified to be 4 bytes in the
298 DWARF-2 specification. The SGI/MIPS ABI defines it to be the same
301 #ifndef DWARF_OFFSET_SIZE
302 #define DWARF_OFFSET_SIZE 4
305 /* According to the (draft) DWARF 3 specification, the initial length
306 should either be 4 or 12 bytes. When it's 12 bytes, the first 4
307 bytes are 0xffffffff, followed by the length stored in the next 8
310 However, the SGI/MIPS ABI uses an initial length which is equal to
311 DWARF_OFFSET_SIZE. It is defined (elsewhere) accordingly. */
313 #ifndef DWARF_INITIAL_LENGTH_SIZE
314 #define DWARF_INITIAL_LENGTH_SIZE (DWARF_OFFSET_SIZE == 4 ? 4 : 12)
317 #define DWARF_VERSION 2
319 /* Round SIZE up to the nearest BOUNDARY. */
320 #define DWARF_ROUND(SIZE,BOUNDARY) \
321 ((((SIZE) + (BOUNDARY) - 1) / (BOUNDARY)) * (BOUNDARY))
323 /* Offsets recorded in opcodes are a multiple of this alignment factor. */
324 #ifndef DWARF_CIE_DATA_ALIGNMENT
325 #ifdef STACK_GROWS_DOWNWARD
326 #define DWARF_CIE_DATA_ALIGNMENT (-((int) UNITS_PER_WORD))
328 #define DWARF_CIE_DATA_ALIGNMENT ((int) UNITS_PER_WORD)
332 /* A pointer to the base of a table that contains frame description
333 information for each routine. */
334 static GTY((length ("fde_table_allocated"))) dw_fde_ref fde_table;
336 /* Number of elements currently allocated for fde_table. */
337 static GTY(()) unsigned fde_table_allocated;
339 /* Number of elements in fde_table currently in use. */
340 static GTY(()) unsigned fde_table_in_use;
342 /* Size (in elements) of increments by which we may expand the
344 #define FDE_TABLE_INCREMENT 256
346 /* A list of call frame insns for the CIE. */
347 static GTY(()) dw_cfi_ref cie_cfi_head;
349 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
350 /* Some DWARF extensions (e.g., MIPS/SGI) implement a subprogram
351 attribute that accelerates the lookup of the FDE associated
352 with the subprogram. This variable holds the table index of the FDE
353 associated with the current function (body) definition. */
354 static unsigned current_funcdef_fde;
357 struct indirect_string_node GTY(())
360 unsigned int refcount;
365 static GTY ((param_is (struct indirect_string_node))) htab_t debug_str_hash;
367 static GTY(()) int dw2_string_counter;
368 static GTY(()) unsigned long dwarf2out_cfi_label_num;
370 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
372 /* Forward declarations for functions defined in this file. */
374 static char *stripattributes (const char *);
375 static const char *dwarf_cfi_name (unsigned);
376 static dw_cfi_ref new_cfi (void);
377 static void add_cfi (dw_cfi_ref *, dw_cfi_ref);
378 static void add_fde_cfi (const char *, dw_cfi_ref);
379 static void lookup_cfa_1 (dw_cfi_ref, dw_cfa_location *);
380 static void lookup_cfa (dw_cfa_location *);
381 static void reg_save (const char *, unsigned, unsigned, HOST_WIDE_INT);
382 static void initial_return_save (rtx);
383 static HOST_WIDE_INT stack_adjust_offset (rtx);
384 static void output_cfi (dw_cfi_ref, dw_fde_ref, int);
385 static void output_call_frame_info (int);
386 static void dwarf2out_stack_adjust (rtx, bool);
387 static void flush_queued_reg_saves (void);
388 static bool clobbers_queued_reg_save (rtx);
389 static void dwarf2out_frame_debug_expr (rtx, const char *);
391 /* Support for complex CFA locations. */
392 static void output_cfa_loc (dw_cfi_ref);
393 static void get_cfa_from_loc_descr (dw_cfa_location *,
394 struct dw_loc_descr_struct *);
395 static struct dw_loc_descr_struct *build_cfa_loc
397 static void def_cfa_1 (const char *, dw_cfa_location *);
399 /* How to start an assembler comment. */
400 #ifndef ASM_COMMENT_START
401 #define ASM_COMMENT_START ";#"
404 /* Data and reference forms for relocatable data. */
405 #define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
406 #define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
408 #ifndef DEBUG_FRAME_SECTION
409 #define DEBUG_FRAME_SECTION ".debug_frame"
412 #ifndef FUNC_BEGIN_LABEL
413 #define FUNC_BEGIN_LABEL "LFB"
416 #ifndef FUNC_END_LABEL
417 #define FUNC_END_LABEL "LFE"
420 #ifndef FRAME_BEGIN_LABEL
421 #define FRAME_BEGIN_LABEL "Lframe"
423 #define CIE_AFTER_SIZE_LABEL "LSCIE"
424 #define CIE_END_LABEL "LECIE"
425 #define FDE_LABEL "LSFDE"
426 #define FDE_AFTER_SIZE_LABEL "LASFDE"
427 #define FDE_END_LABEL "LEFDE"
428 #define LINE_NUMBER_BEGIN_LABEL "LSLT"
429 #define LINE_NUMBER_END_LABEL "LELT"
430 #define LN_PROLOG_AS_LABEL "LASLTP"
431 #define LN_PROLOG_END_LABEL "LELTP"
432 #define DIE_LABEL_PREFIX "DW"
434 /* The DWARF 2 CFA column which tracks the return address. Normally this
435 is the column for PC, or the first column after all of the hard
437 #ifndef DWARF_FRAME_RETURN_COLUMN
439 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (PC_REGNUM)
441 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGISTERS
445 /* The mapping from gcc register number to DWARF 2 CFA column number. By
446 default, we just provide columns for all registers. */
447 #ifndef DWARF_FRAME_REGNUM
448 #define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG)
451 /* Hook used by __throw. */
454 expand_builtin_dwarf_sp_column (void)
456 return GEN_INT (DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM));
459 /* Return a pointer to a copy of the section string name S with all
460 attributes stripped off, and an asterisk prepended (for assemble_name). */
463 stripattributes (const char *s)
465 char *stripped = xmalloc (strlen (s) + 2);
470 while (*s && *s != ',')
477 /* Generate code to initialize the register size table. */
480 expand_builtin_init_dwarf_reg_sizes (tree address)
483 enum machine_mode mode = TYPE_MODE (char_type_node);
484 rtx addr = expand_expr (address, NULL_RTX, VOIDmode, 0);
485 rtx mem = gen_rtx_MEM (BLKmode, addr);
486 bool wrote_return_column = false;
488 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
489 if (DWARF_FRAME_REGNUM (i) < DWARF_FRAME_REGISTERS)
491 HOST_WIDE_INT offset = DWARF_FRAME_REGNUM (i) * GET_MODE_SIZE (mode);
492 enum machine_mode save_mode = reg_raw_mode[i];
495 if (HARD_REGNO_CALL_PART_CLOBBERED (i, save_mode))
496 save_mode = choose_hard_reg_mode (i, 1, true);
497 if (DWARF_FRAME_REGNUM (i) == DWARF_FRAME_RETURN_COLUMN)
499 if (save_mode == VOIDmode)
501 wrote_return_column = true;
503 size = GET_MODE_SIZE (save_mode);
507 emit_move_insn (adjust_address (mem, mode, offset),
508 gen_int_mode (size, mode));
511 #ifdef DWARF_ALT_FRAME_RETURN_COLUMN
512 gcc_assert (wrote_return_column);
513 i = DWARF_ALT_FRAME_RETURN_COLUMN;
514 wrote_return_column = false;
516 i = DWARF_FRAME_RETURN_COLUMN;
519 if (! wrote_return_column)
521 enum machine_mode save_mode = Pmode;
522 HOST_WIDE_INT offset = i * GET_MODE_SIZE (mode);
523 HOST_WIDE_INT size = GET_MODE_SIZE (save_mode);
524 emit_move_insn (adjust_address (mem, mode, offset), GEN_INT (size));
528 /* Convert a DWARF call frame info. operation to its string name */
531 dwarf_cfi_name (unsigned int cfi_opc)
535 case DW_CFA_advance_loc:
536 return "DW_CFA_advance_loc";
538 return "DW_CFA_offset";
540 return "DW_CFA_restore";
544 return "DW_CFA_set_loc";
545 case DW_CFA_advance_loc1:
546 return "DW_CFA_advance_loc1";
547 case DW_CFA_advance_loc2:
548 return "DW_CFA_advance_loc2";
549 case DW_CFA_advance_loc4:
550 return "DW_CFA_advance_loc4";
551 case DW_CFA_offset_extended:
552 return "DW_CFA_offset_extended";
553 case DW_CFA_restore_extended:
554 return "DW_CFA_restore_extended";
555 case DW_CFA_undefined:
556 return "DW_CFA_undefined";
557 case DW_CFA_same_value:
558 return "DW_CFA_same_value";
559 case DW_CFA_register:
560 return "DW_CFA_register";
561 case DW_CFA_remember_state:
562 return "DW_CFA_remember_state";
563 case DW_CFA_restore_state:
564 return "DW_CFA_restore_state";
566 return "DW_CFA_def_cfa";
567 case DW_CFA_def_cfa_register:
568 return "DW_CFA_def_cfa_register";
569 case DW_CFA_def_cfa_offset:
570 return "DW_CFA_def_cfa_offset";
573 case DW_CFA_def_cfa_expression:
574 return "DW_CFA_def_cfa_expression";
575 case DW_CFA_expression:
576 return "DW_CFA_expression";
577 case DW_CFA_offset_extended_sf:
578 return "DW_CFA_offset_extended_sf";
579 case DW_CFA_def_cfa_sf:
580 return "DW_CFA_def_cfa_sf";
581 case DW_CFA_def_cfa_offset_sf:
582 return "DW_CFA_def_cfa_offset_sf";
584 /* SGI/MIPS specific */
585 case DW_CFA_MIPS_advance_loc8:
586 return "DW_CFA_MIPS_advance_loc8";
589 case DW_CFA_GNU_window_save:
590 return "DW_CFA_GNU_window_save";
591 case DW_CFA_GNU_args_size:
592 return "DW_CFA_GNU_args_size";
593 case DW_CFA_GNU_negative_offset_extended:
594 return "DW_CFA_GNU_negative_offset_extended";
597 return "DW_CFA_<unknown>";
601 /* Return a pointer to a newly allocated Call Frame Instruction. */
603 static inline dw_cfi_ref
606 dw_cfi_ref cfi = ggc_alloc (sizeof (dw_cfi_node));
608 cfi->dw_cfi_next = NULL;
609 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = 0;
610 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = 0;
615 /* Add a Call Frame Instruction to list of instructions. */
618 add_cfi (dw_cfi_ref *list_head, dw_cfi_ref cfi)
622 /* Find the end of the chain. */
623 for (p = list_head; (*p) != NULL; p = &(*p)->dw_cfi_next)
629 /* Generate a new label for the CFI info to refer to. */
632 dwarf2out_cfi_label (void)
634 static char label[20];
636 ASM_GENERATE_INTERNAL_LABEL (label, "LCFI", dwarf2out_cfi_label_num++);
637 ASM_OUTPUT_LABEL (asm_out_file, label);
641 /* Add CFI to the current fde at the PC value indicated by LABEL if specified,
642 or to the CIE if LABEL is NULL. */
645 add_fde_cfi (const char *label, dw_cfi_ref cfi)
649 dw_fde_ref fde = &fde_table[fde_table_in_use - 1];
652 label = dwarf2out_cfi_label ();
654 if (fde->dw_fde_current_label == NULL
655 || strcmp (label, fde->dw_fde_current_label) != 0)
659 fde->dw_fde_current_label = label = xstrdup (label);
661 /* Set the location counter to the new label. */
663 xcfi->dw_cfi_opc = DW_CFA_advance_loc4;
664 xcfi->dw_cfi_oprnd1.dw_cfi_addr = label;
665 add_cfi (&fde->dw_fde_cfi, xcfi);
668 add_cfi (&fde->dw_fde_cfi, cfi);
672 add_cfi (&cie_cfi_head, cfi);
675 /* Subroutine of lookup_cfa. */
678 lookup_cfa_1 (dw_cfi_ref cfi, dw_cfa_location *loc)
680 switch (cfi->dw_cfi_opc)
682 case DW_CFA_def_cfa_offset:
683 loc->offset = cfi->dw_cfi_oprnd1.dw_cfi_offset;
685 case DW_CFA_def_cfa_offset_sf:
687 = cfi->dw_cfi_oprnd1.dw_cfi_offset * DWARF_CIE_DATA_ALIGNMENT;
689 case DW_CFA_def_cfa_register:
690 loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
693 loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
694 loc->offset = cfi->dw_cfi_oprnd2.dw_cfi_offset;
696 case DW_CFA_def_cfa_sf:
697 loc->reg = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
699 = cfi->dw_cfi_oprnd2.dw_cfi_offset * DWARF_CIE_DATA_ALIGNMENT;
701 case DW_CFA_def_cfa_expression:
702 get_cfa_from_loc_descr (loc, cfi->dw_cfi_oprnd1.dw_cfi_loc);
709 /* Find the previous value for the CFA. */
712 lookup_cfa (dw_cfa_location *loc)
716 loc->reg = INVALID_REGNUM;
719 loc->base_offset = 0;
721 for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
722 lookup_cfa_1 (cfi, loc);
724 if (fde_table_in_use)
726 dw_fde_ref fde = &fde_table[fde_table_in_use - 1];
727 for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
728 lookup_cfa_1 (cfi, loc);
732 /* The current rule for calculating the DWARF2 canonical frame address. */
733 static dw_cfa_location cfa;
735 /* The register used for saving registers to the stack, and its offset
737 static dw_cfa_location cfa_store;
739 /* The running total of the size of arguments pushed onto the stack. */
740 static HOST_WIDE_INT args_size;
742 /* The last args_size we actually output. */
743 static HOST_WIDE_INT old_args_size;
745 /* Entry point to update the canonical frame address (CFA).
746 LABEL is passed to add_fde_cfi. The value of CFA is now to be
747 calculated from REG+OFFSET. */
750 dwarf2out_def_cfa (const char *label, unsigned int reg, HOST_WIDE_INT offset)
757 def_cfa_1 (label, &loc);
760 /* Determine if two dw_cfa_location structures define the same data. */
763 cfa_equal_p (const dw_cfa_location *loc1, const dw_cfa_location *loc2)
765 return (loc1->reg == loc2->reg
766 && loc1->offset == loc2->offset
767 && loc1->indirect == loc2->indirect
768 && (loc1->indirect == 0
769 || loc1->base_offset == loc2->base_offset));
772 /* This routine does the actual work. The CFA is now calculated from
773 the dw_cfa_location structure. */
776 def_cfa_1 (const char *label, dw_cfa_location *loc_p)
779 dw_cfa_location old_cfa, loc;
784 if (cfa_store.reg == loc.reg && loc.indirect == 0)
785 cfa_store.offset = loc.offset;
787 loc.reg = DWARF_FRAME_REGNUM (loc.reg);
788 lookup_cfa (&old_cfa);
790 /* If nothing changed, no need to issue any call frame instructions. */
791 if (cfa_equal_p (&loc, &old_cfa))
796 if (loc.reg == old_cfa.reg && !loc.indirect)
798 /* Construct a "DW_CFA_def_cfa_offset <offset>" instruction, indicating
799 the CFA register did not change but the offset did. */
802 HOST_WIDE_INT f_offset = loc.offset / DWARF_CIE_DATA_ALIGNMENT;
803 gcc_assert (f_offset * DWARF_CIE_DATA_ALIGNMENT == loc.offset);
805 cfi->dw_cfi_opc = DW_CFA_def_cfa_offset_sf;
806 cfi->dw_cfi_oprnd1.dw_cfi_offset = f_offset;
810 cfi->dw_cfi_opc = DW_CFA_def_cfa_offset;
811 cfi->dw_cfi_oprnd1.dw_cfi_offset = loc.offset;
815 #ifndef MIPS_DEBUGGING_INFO /* SGI dbx thinks this means no offset. */
816 else if (loc.offset == old_cfa.offset
817 && old_cfa.reg != INVALID_REGNUM
820 /* Construct a "DW_CFA_def_cfa_register <register>" instruction,
821 indicating the CFA register has changed to <register> but the
822 offset has not changed. */
823 cfi->dw_cfi_opc = DW_CFA_def_cfa_register;
824 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg;
828 else if (loc.indirect == 0)
830 /* Construct a "DW_CFA_def_cfa <register> <offset>" instruction,
831 indicating the CFA register has changed to <register> with
832 the specified offset. */
835 HOST_WIDE_INT f_offset = loc.offset / DWARF_CIE_DATA_ALIGNMENT;
836 gcc_assert (f_offset * DWARF_CIE_DATA_ALIGNMENT == loc.offset);
838 cfi->dw_cfi_opc = DW_CFA_def_cfa_sf;
839 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg;
840 cfi->dw_cfi_oprnd2.dw_cfi_offset = f_offset;
844 cfi->dw_cfi_opc = DW_CFA_def_cfa;
845 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = loc.reg;
846 cfi->dw_cfi_oprnd2.dw_cfi_offset = loc.offset;
851 /* Construct a DW_CFA_def_cfa_expression instruction to
852 calculate the CFA using a full location expression since no
853 register-offset pair is available. */
854 struct dw_loc_descr_struct *loc_list;
856 cfi->dw_cfi_opc = DW_CFA_def_cfa_expression;
857 loc_list = build_cfa_loc (&loc);
858 cfi->dw_cfi_oprnd1.dw_cfi_loc = loc_list;
861 add_fde_cfi (label, cfi);
864 /* Add the CFI for saving a register. REG is the CFA column number.
865 LABEL is passed to add_fde_cfi.
866 If SREG is -1, the register is saved at OFFSET from the CFA;
867 otherwise it is saved in SREG. */
870 reg_save (const char *label, unsigned int reg, unsigned int sreg, HOST_WIDE_INT offset)
872 dw_cfi_ref cfi = new_cfi ();
874 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
876 if (sreg == INVALID_REGNUM)
879 /* The register number won't fit in 6 bits, so we have to use
881 cfi->dw_cfi_opc = DW_CFA_offset_extended;
883 cfi->dw_cfi_opc = DW_CFA_offset;
885 #ifdef ENABLE_CHECKING
887 /* If we get an offset that is not a multiple of
888 DWARF_CIE_DATA_ALIGNMENT, there is either a bug in the
889 definition of DWARF_CIE_DATA_ALIGNMENT, or a bug in the machine
891 HOST_WIDE_INT check_offset = offset / DWARF_CIE_DATA_ALIGNMENT;
893 gcc_assert (check_offset * DWARF_CIE_DATA_ALIGNMENT == offset);
896 offset /= DWARF_CIE_DATA_ALIGNMENT;
898 cfi->dw_cfi_opc = DW_CFA_offset_extended_sf;
900 cfi->dw_cfi_oprnd2.dw_cfi_offset = offset;
902 else if (sreg == reg)
903 cfi->dw_cfi_opc = DW_CFA_same_value;
906 cfi->dw_cfi_opc = DW_CFA_register;
907 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = sreg;
910 add_fde_cfi (label, cfi);
913 /* Add the CFI for saving a register window. LABEL is passed to reg_save.
914 This CFI tells the unwinder that it needs to restore the window registers
915 from the previous frame's window save area.
917 ??? Perhaps we should note in the CIE where windows are saved (instead of
918 assuming 0(cfa)) and what registers are in the window. */
921 dwarf2out_window_save (const char *label)
923 dw_cfi_ref cfi = new_cfi ();
925 cfi->dw_cfi_opc = DW_CFA_GNU_window_save;
926 add_fde_cfi (label, cfi);
929 /* Add a CFI to update the running total of the size of arguments
930 pushed onto the stack. */
933 dwarf2out_args_size (const char *label, HOST_WIDE_INT size)
937 if (size == old_args_size)
940 old_args_size = size;
943 cfi->dw_cfi_opc = DW_CFA_GNU_args_size;
944 cfi->dw_cfi_oprnd1.dw_cfi_offset = size;
945 add_fde_cfi (label, cfi);
948 /* Entry point for saving a register to the stack. REG is the GCC register
949 number. LABEL and OFFSET are passed to reg_save. */
952 dwarf2out_reg_save (const char *label, unsigned int reg, HOST_WIDE_INT offset)
954 reg_save (label, DWARF_FRAME_REGNUM (reg), INVALID_REGNUM, offset);
957 /* Entry point for saving the return address in the stack.
958 LABEL and OFFSET are passed to reg_save. */
961 dwarf2out_return_save (const char *label, HOST_WIDE_INT offset)
963 reg_save (label, DWARF_FRAME_RETURN_COLUMN, INVALID_REGNUM, offset);
966 /* Entry point for saving the return address in a register.
967 LABEL and SREG are passed to reg_save. */
970 dwarf2out_return_reg (const char *label, unsigned int sreg)
972 reg_save (label, DWARF_FRAME_RETURN_COLUMN, DWARF_FRAME_REGNUM (sreg), 0);
975 /* Record the initial position of the return address. RTL is
976 INCOMING_RETURN_ADDR_RTX. */
979 initial_return_save (rtx rtl)
981 unsigned int reg = INVALID_REGNUM;
982 HOST_WIDE_INT offset = 0;
984 switch (GET_CODE (rtl))
987 /* RA is in a register. */
988 reg = DWARF_FRAME_REGNUM (REGNO (rtl));
992 /* RA is on the stack. */
994 switch (GET_CODE (rtl))
997 gcc_assert (REGNO (rtl) == STACK_POINTER_REGNUM);
1002 gcc_assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM);
1003 offset = INTVAL (XEXP (rtl, 1));
1007 gcc_assert (REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM);
1008 offset = -INTVAL (XEXP (rtl, 1));
1018 /* The return address is at some offset from any value we can
1019 actually load. For instance, on the SPARC it is in %i7+8. Just
1020 ignore the offset for now; it doesn't matter for unwinding frames. */
1021 gcc_assert (GET_CODE (XEXP (rtl, 1)) == CONST_INT);
1022 initial_return_save (XEXP (rtl, 0));
1029 if (reg != DWARF_FRAME_RETURN_COLUMN)
1030 reg_save (NULL, DWARF_FRAME_RETURN_COLUMN, reg, offset - cfa.offset);
1033 /* Given a SET, calculate the amount of stack adjustment it
1036 static HOST_WIDE_INT
1037 stack_adjust_offset (rtx pattern)
1039 rtx src = SET_SRC (pattern);
1040 rtx dest = SET_DEST (pattern);
1041 HOST_WIDE_INT offset = 0;
1044 if (dest == stack_pointer_rtx)
1046 /* (set (reg sp) (plus (reg sp) (const_int))) */
1047 code = GET_CODE (src);
1048 if (! (code == PLUS || code == MINUS)
1049 || XEXP (src, 0) != stack_pointer_rtx
1050 || GET_CODE (XEXP (src, 1)) != CONST_INT)
1053 offset = INTVAL (XEXP (src, 1));
1057 else if (MEM_P (dest))
1059 /* (set (mem (pre_dec (reg sp))) (foo)) */
1060 src = XEXP (dest, 0);
1061 code = GET_CODE (src);
1067 if (XEXP (src, 0) == stack_pointer_rtx)
1069 rtx val = XEXP (XEXP (src, 1), 1);
1070 /* We handle only adjustments by constant amount. */
1071 gcc_assert (GET_CODE (XEXP (src, 1)) == PLUS
1072 && GET_CODE (val) == CONST_INT);
1073 offset = -INTVAL (val);
1080 if (XEXP (src, 0) == stack_pointer_rtx)
1082 offset = GET_MODE_SIZE (GET_MODE (dest));
1089 if (XEXP (src, 0) == stack_pointer_rtx)
1091 offset = -GET_MODE_SIZE (GET_MODE (dest));
1106 /* Check INSN to see if it looks like a push or a stack adjustment, and
1107 make a note of it if it does. EH uses this information to find out how
1108 much extra space it needs to pop off the stack. */
1111 dwarf2out_stack_adjust (rtx insn, bool after_p)
1113 HOST_WIDE_INT offset;
1117 /* Don't handle epilogues at all. Certainly it would be wrong to do so
1118 with this function. Proper support would require all frame-related
1119 insns to be marked, and to be able to handle saving state around
1120 epilogues textually in the middle of the function. */
1121 if (prologue_epilogue_contains (insn) || sibcall_epilogue_contains (insn))
1124 /* If only calls can throw, and we have a frame pointer,
1125 save up adjustments until we see the CALL_INSN. */
1126 if (!flag_asynchronous_unwind_tables && cfa.reg != STACK_POINTER_REGNUM)
1128 if (CALL_P (insn) && !after_p)
1130 /* Extract the size of the args from the CALL rtx itself. */
1131 insn = PATTERN (insn);
1132 if (GET_CODE (insn) == PARALLEL)
1133 insn = XVECEXP (insn, 0, 0);
1134 if (GET_CODE (insn) == SET)
1135 insn = SET_SRC (insn);
1136 gcc_assert (GET_CODE (insn) == CALL);
1137 dwarf2out_args_size ("", INTVAL (XEXP (insn, 1)));
1142 if (CALL_P (insn) && !after_p)
1144 if (!flag_asynchronous_unwind_tables)
1145 dwarf2out_args_size ("", args_size);
1148 else if (BARRIER_P (insn))
1150 /* When we see a BARRIER, we know to reset args_size to 0. Usually
1151 the compiler will have already emitted a stack adjustment, but
1152 doesn't bother for calls to noreturn functions. */
1153 #ifdef STACK_GROWS_DOWNWARD
1154 offset = -args_size;
1159 else if (GET_CODE (PATTERN (insn)) == SET)
1160 offset = stack_adjust_offset (PATTERN (insn));
1161 else if (GET_CODE (PATTERN (insn)) == PARALLEL
1162 || GET_CODE (PATTERN (insn)) == SEQUENCE)
1164 /* There may be stack adjustments inside compound insns. Search
1166 for (offset = 0, i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
1167 if (GET_CODE (XVECEXP (PATTERN (insn), 0, i)) == SET)
1168 offset += stack_adjust_offset (XVECEXP (PATTERN (insn), 0, i));
1176 if (cfa.reg == STACK_POINTER_REGNUM)
1177 cfa.offset += offset;
1179 #ifndef STACK_GROWS_DOWNWARD
1183 args_size += offset;
1187 label = dwarf2out_cfi_label ();
1188 def_cfa_1 (label, &cfa);
1189 if (flag_asynchronous_unwind_tables)
1190 dwarf2out_args_size (label, args_size);
1195 /* We delay emitting a register save until either (a) we reach the end
1196 of the prologue or (b) the register is clobbered. This clusters
1197 register saves so that there are fewer pc advances. */
1199 struct queued_reg_save GTY(())
1201 struct queued_reg_save *next;
1203 HOST_WIDE_INT cfa_offset;
1207 static GTY(()) struct queued_reg_save *queued_reg_saves;
1209 /* The caller's ORIG_REG is saved in SAVED_IN_REG. */
1210 struct reg_saved_in_data GTY(()) {
1215 /* A list of registers saved in other registers.
1216 The list intentionally has a small maximum capacity of 4; if your
1217 port needs more than that, you might consider implementing a
1218 more efficient data structure. */
1219 static GTY(()) struct reg_saved_in_data regs_saved_in_regs[4];
1220 static GTY(()) size_t num_regs_saved_in_regs;
1222 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
1223 static const char *last_reg_save_label;
1225 /* Add an entry to QUEUED_REG_SAVES saying that REG is now saved at
1226 SREG, or if SREG is NULL then it is saved at OFFSET to the CFA. */
1229 queue_reg_save (const char *label, rtx reg, rtx sreg, HOST_WIDE_INT offset)
1231 struct queued_reg_save *q;
1233 /* Duplicates waste space, but it's also necessary to remove them
1234 for correctness, since the queue gets output in reverse
1236 for (q = queued_reg_saves; q != NULL; q = q->next)
1237 if (REGNO (q->reg) == REGNO (reg))
1242 q = ggc_alloc (sizeof (*q));
1243 q->next = queued_reg_saves;
1244 queued_reg_saves = q;
1248 q->cfa_offset = offset;
1249 q->saved_reg = sreg;
1251 last_reg_save_label = label;
1254 /* Output all the entries in QUEUED_REG_SAVES. */
1257 flush_queued_reg_saves (void)
1259 struct queued_reg_save *q;
1261 for (q = queued_reg_saves; q; q = q->next)
1264 unsigned int reg, sreg;
1266 for (i = 0; i < num_regs_saved_in_regs; i++)
1267 if (REGNO (regs_saved_in_regs[i].orig_reg) == REGNO (q->reg))
1269 if (q->saved_reg && i == num_regs_saved_in_regs)
1271 gcc_assert (i != ARRAY_SIZE (regs_saved_in_regs));
1272 num_regs_saved_in_regs++;
1274 if (i != num_regs_saved_in_regs)
1276 regs_saved_in_regs[i].orig_reg = q->reg;
1277 regs_saved_in_regs[i].saved_in_reg = q->saved_reg;
1280 reg = DWARF_FRAME_REGNUM (REGNO (q->reg));
1282 sreg = DWARF_FRAME_REGNUM (REGNO (q->saved_reg));
1284 sreg = INVALID_REGNUM;
1285 reg_save (last_reg_save_label, reg, sreg, q->cfa_offset);
1288 queued_reg_saves = NULL;
1289 last_reg_save_label = NULL;
1292 /* Does INSN clobber any register which QUEUED_REG_SAVES lists a saved
1293 location for? Or, does it clobber a register which we've previously
1294 said that some other register is saved in, and for which we now
1295 have a new location for? */
1298 clobbers_queued_reg_save (rtx insn)
1300 struct queued_reg_save *q;
1302 for (q = queued_reg_saves; q; q = q->next)
1305 if (modified_in_p (q->reg, insn))
1307 for (i = 0; i < num_regs_saved_in_regs; i++)
1308 if (REGNO (q->reg) == REGNO (regs_saved_in_regs[i].orig_reg)
1309 && modified_in_p (regs_saved_in_regs[i].saved_in_reg, insn))
1316 /* Entry point for saving the first register into the second. */
1319 dwarf2out_reg_save_reg (const char *label, rtx reg, rtx sreg)
1322 unsigned int regno, sregno;
1324 for (i = 0; i < num_regs_saved_in_regs; i++)
1325 if (REGNO (regs_saved_in_regs[i].orig_reg) == REGNO (reg))
1327 if (i == num_regs_saved_in_regs)
1329 gcc_assert (i != ARRAY_SIZE (regs_saved_in_regs));
1330 num_regs_saved_in_regs++;
1332 regs_saved_in_regs[i].orig_reg = reg;
1333 regs_saved_in_regs[i].saved_in_reg = sreg;
1335 regno = DWARF_FRAME_REGNUM (REGNO (reg));
1336 sregno = DWARF_FRAME_REGNUM (REGNO (sreg));
1337 reg_save (label, regno, sregno, 0);
1340 /* What register, if any, is currently saved in REG? */
1343 reg_saved_in (rtx reg)
1345 unsigned int regn = REGNO (reg);
1347 struct queued_reg_save *q;
1349 for (q = queued_reg_saves; q; q = q->next)
1350 if (q->saved_reg && regn == REGNO (q->saved_reg))
1353 for (i = 0; i < num_regs_saved_in_regs; i++)
1354 if (regs_saved_in_regs[i].saved_in_reg
1355 && regn == REGNO (regs_saved_in_regs[i].saved_in_reg))
1356 return regs_saved_in_regs[i].orig_reg;
1362 /* A temporary register holding an integral value used in adjusting SP
1363 or setting up the store_reg. The "offset" field holds the integer
1364 value, not an offset. */
1365 static dw_cfa_location cfa_temp;
1367 /* Record call frame debugging information for an expression EXPR,
1368 which either sets SP or FP (adjusting how we calculate the frame
1369 address) or saves a register to the stack or another register.
1370 LABEL indicates the address of EXPR.
1372 This function encodes a state machine mapping rtxes to actions on
1373 cfa, cfa_store, and cfa_temp.reg. We describe these rules so
1374 users need not read the source code.
1376 The High-Level Picture
1378 Changes in the register we use to calculate the CFA: Currently we
1379 assume that if you copy the CFA register into another register, we
1380 should take the other one as the new CFA register; this seems to
1381 work pretty well. If it's wrong for some target, it's simple
1382 enough not to set RTX_FRAME_RELATED_P on the insn in question.
1384 Changes in the register we use for saving registers to the stack:
1385 This is usually SP, but not always. Again, we deduce that if you
1386 copy SP into another register (and SP is not the CFA register),
1387 then the new register is the one we will be using for register
1388 saves. This also seems to work.
1390 Register saves: There's not much guesswork about this one; if
1391 RTX_FRAME_RELATED_P is set on an insn which modifies memory, it's a
1392 register save, and the register used to calculate the destination
1393 had better be the one we think we're using for this purpose.
1394 It's also assumed that a copy from a call-saved register to another
1395 register is saving that register if RTX_FRAME_RELATED_P is set on
1396 that instruction. If the copy is from a call-saved register to
1397 the *same* register, that means that the register is now the same
1398 value as in the caller.
1400 Except: If the register being saved is the CFA register, and the
1401 offset is nonzero, we are saving the CFA, so we assume we have to
1402 use DW_CFA_def_cfa_expression. If the offset is 0, we assume that
1403 the intent is to save the value of SP from the previous frame.
1405 In addition, if a register has previously been saved to a different
1408 Invariants / Summaries of Rules
1410 cfa current rule for calculating the CFA. It usually
1411 consists of a register and an offset.
1412 cfa_store register used by prologue code to save things to the stack
1413 cfa_store.offset is the offset from the value of
1414 cfa_store.reg to the actual CFA
1415 cfa_temp register holding an integral value. cfa_temp.offset
1416 stores the value, which will be used to adjust the
1417 stack pointer. cfa_temp is also used like cfa_store,
1418 to track stores to the stack via fp or a temp reg.
1420 Rules 1- 4: Setting a register's value to cfa.reg or an expression
1421 with cfa.reg as the first operand changes the cfa.reg and its
1422 cfa.offset. Rule 1 and 4 also set cfa_temp.reg and
1425 Rules 6- 9: Set a non-cfa.reg register value to a constant or an
1426 expression yielding a constant. This sets cfa_temp.reg
1427 and cfa_temp.offset.
1429 Rule 5: Create a new register cfa_store used to save items to the
1432 Rules 10-14: Save a register to the stack. Define offset as the
1433 difference of the original location and cfa_store's
1434 location (or cfa_temp's location if cfa_temp is used).
1438 "{a,b}" indicates a choice of a xor b.
1439 "<reg>:cfa.reg" indicates that <reg> must equal cfa.reg.
1442 (set <reg1> <reg2>:cfa.reg)
1443 effects: cfa.reg = <reg1>
1444 cfa.offset unchanged
1445 cfa_temp.reg = <reg1>
1446 cfa_temp.offset = cfa.offset
1449 (set sp ({minus,plus,losum} {sp,fp}:cfa.reg
1450 {<const_int>,<reg>:cfa_temp.reg}))
1451 effects: cfa.reg = sp if fp used
1452 cfa.offset += {+/- <const_int>, cfa_temp.offset} if cfa.reg==sp
1453 cfa_store.offset += {+/- <const_int>, cfa_temp.offset}
1454 if cfa_store.reg==sp
1457 (set fp ({minus,plus,losum} <reg>:cfa.reg <const_int>))
1458 effects: cfa.reg = fp
1459 cfa_offset += +/- <const_int>
1462 (set <reg1> ({plus,losum} <reg2>:cfa.reg <const_int>))
1463 constraints: <reg1> != fp
1465 effects: cfa.reg = <reg1>
1466 cfa_temp.reg = <reg1>
1467 cfa_temp.offset = cfa.offset
1470 (set <reg1> (plus <reg2>:cfa_temp.reg sp:cfa.reg))
1471 constraints: <reg1> != fp
1473 effects: cfa_store.reg = <reg1>
1474 cfa_store.offset = cfa.offset - cfa_temp.offset
1477 (set <reg> <const_int>)
1478 effects: cfa_temp.reg = <reg>
1479 cfa_temp.offset = <const_int>
1482 (set <reg1>:cfa_temp.reg (ior <reg2>:cfa_temp.reg <const_int>))
1483 effects: cfa_temp.reg = <reg1>
1484 cfa_temp.offset |= <const_int>
1487 (set <reg> (high <exp>))
1491 (set <reg> (lo_sum <exp> <const_int>))
1492 effects: cfa_temp.reg = <reg>
1493 cfa_temp.offset = <const_int>
1496 (set (mem (pre_modify sp:cfa_store (???? <reg1> <const_int>))) <reg2>)
1497 effects: cfa_store.offset -= <const_int>
1498 cfa.offset = cfa_store.offset if cfa.reg == sp
1500 cfa.base_offset = -cfa_store.offset
1503 (set (mem ({pre_inc,pre_dec} sp:cfa_store.reg)) <reg>)
1504 effects: cfa_store.offset += -/+ mode_size(mem)
1505 cfa.offset = cfa_store.offset if cfa.reg == sp
1507 cfa.base_offset = -cfa_store.offset
1510 (set (mem ({minus,plus,losum} <reg1>:{cfa_store,cfa_temp} <const_int>))
1513 effects: cfa.reg = <reg1>
1514 cfa.base_offset = -/+ <const_int> - {cfa_store,cfa_temp}.offset
1517 (set (mem <reg1>:{cfa_store,cfa_temp}) <reg2>)
1518 effects: cfa.reg = <reg1>
1519 cfa.base_offset = -{cfa_store,cfa_temp}.offset
1522 (set (mem (postinc <reg1>:cfa_temp <const_int>)) <reg2>)
1523 effects: cfa.reg = <reg1>
1524 cfa.base_offset = -cfa_temp.offset
1525 cfa_temp.offset -= mode_size(mem)
1528 Â (set <reg> {unspec, unspec_volatile})
1529 Â effects: target-dependent */
1532 dwarf2out_frame_debug_expr (rtx expr, const char *label)
1535 HOST_WIDE_INT offset;
1537 /* If RTX_FRAME_RELATED_P is set on a PARALLEL, process each member of
1538 the PARALLEL independently. The first element is always processed if
1539 it is a SET. This is for backward compatibility. Other elements
1540 are processed only if they are SETs and the RTX_FRAME_RELATED_P
1541 flag is set in them. */
1542 if (GET_CODE (expr) == PARALLEL || GET_CODE (expr) == SEQUENCE)
1545 int limit = XVECLEN (expr, 0);
1547 for (par_index = 0; par_index < limit; par_index++)
1548 if (GET_CODE (XVECEXP (expr, 0, par_index)) == SET
1549 && (RTX_FRAME_RELATED_P (XVECEXP (expr, 0, par_index))
1551 dwarf2out_frame_debug_expr (XVECEXP (expr, 0, par_index), label);
1556 gcc_assert (GET_CODE (expr) == SET);
1558 src = SET_SRC (expr);
1559 dest = SET_DEST (expr);
1563 rtx rsi = reg_saved_in (src);
1568 switch (GET_CODE (dest))
1571 switch (GET_CODE (src))
1573 /* Setting FP from SP. */
1575 if (cfa.reg == (unsigned) REGNO (src))
1578 /* Update the CFA rule wrt SP or FP. Make sure src is
1579 relative to the current CFA register.
1581 We used to require that dest be either SP or FP, but the
1582 ARM copies SP to a temporary register, and from there to
1583 FP. So we just rely on the backends to only set
1584 RTX_FRAME_RELATED_P on appropriate insns. */
1585 cfa.reg = REGNO (dest);
1586 cfa_temp.reg = cfa.reg;
1587 cfa_temp.offset = cfa.offset;
1591 /* Saving a register in a register. */
1592 gcc_assert (!fixed_regs [REGNO (dest)]
1593 /* For the SPARC and its register window. */
1594 || (DWARF_FRAME_REGNUM (REGNO (src))
1595 == DWARF_FRAME_RETURN_COLUMN));
1596 queue_reg_save (label, src, dest, 0);
1603 if (dest == stack_pointer_rtx)
1607 switch (GET_CODE (XEXP (src, 1)))
1610 offset = INTVAL (XEXP (src, 1));
1613 gcc_assert ((unsigned) REGNO (XEXP (src, 1))
1615 offset = cfa_temp.offset;
1621 if (XEXP (src, 0) == hard_frame_pointer_rtx)
1623 /* Restoring SP from FP in the epilogue. */
1624 gcc_assert (cfa.reg == (unsigned) HARD_FRAME_POINTER_REGNUM);
1625 cfa.reg = STACK_POINTER_REGNUM;
1627 else if (GET_CODE (src) == LO_SUM)
1628 /* Assume we've set the source reg of the LO_SUM from sp. */
1631 gcc_assert (XEXP (src, 0) == stack_pointer_rtx);
1633 if (GET_CODE (src) != MINUS)
1635 if (cfa.reg == STACK_POINTER_REGNUM)
1636 cfa.offset += offset;
1637 if (cfa_store.reg == STACK_POINTER_REGNUM)
1638 cfa_store.offset += offset;
1640 else if (dest == hard_frame_pointer_rtx)
1643 /* Either setting the FP from an offset of the SP,
1644 or adjusting the FP */
1645 gcc_assert (frame_pointer_needed);
1647 gcc_assert (REG_P (XEXP (src, 0))
1648 && (unsigned) REGNO (XEXP (src, 0)) == cfa.reg
1649 && GET_CODE (XEXP (src, 1)) == CONST_INT);
1650 offset = INTVAL (XEXP (src, 1));
1651 if (GET_CODE (src) != MINUS)
1653 cfa.offset += offset;
1654 cfa.reg = HARD_FRAME_POINTER_REGNUM;
1658 gcc_assert (GET_CODE (src) != MINUS);
1661 if (REG_P (XEXP (src, 0))
1662 && REGNO (XEXP (src, 0)) == cfa.reg
1663 && GET_CODE (XEXP (src, 1)) == CONST_INT)
1665 /* Setting a temporary CFA register that will be copied
1666 into the FP later on. */
1667 offset = - INTVAL (XEXP (src, 1));
1668 cfa.offset += offset;
1669 cfa.reg = REGNO (dest);
1670 /* Or used to save regs to the stack. */
1671 cfa_temp.reg = cfa.reg;
1672 cfa_temp.offset = cfa.offset;
1676 else if (REG_P (XEXP (src, 0))
1677 && REGNO (XEXP (src, 0)) == cfa_temp.reg
1678 && XEXP (src, 1) == stack_pointer_rtx)
1680 /* Setting a scratch register that we will use instead
1681 of SP for saving registers to the stack. */
1682 gcc_assert (cfa.reg == STACK_POINTER_REGNUM);
1683 cfa_store.reg = REGNO (dest);
1684 cfa_store.offset = cfa.offset - cfa_temp.offset;
1688 else if (GET_CODE (src) == LO_SUM
1689 && GET_CODE (XEXP (src, 1)) == CONST_INT)
1691 cfa_temp.reg = REGNO (dest);
1692 cfa_temp.offset = INTVAL (XEXP (src, 1));
1701 cfa_temp.reg = REGNO (dest);
1702 cfa_temp.offset = INTVAL (src);
1707 gcc_assert (REG_P (XEXP (src, 0))
1708 && (unsigned) REGNO (XEXP (src, 0)) == cfa_temp.reg
1709 && GET_CODE (XEXP (src, 1)) == CONST_INT);
1711 if ((unsigned) REGNO (dest) != cfa_temp.reg)
1712 cfa_temp.reg = REGNO (dest);
1713 cfa_temp.offset |= INTVAL (XEXP (src, 1));
1716 /* Skip over HIGH, assuming it will be followed by a LO_SUM,
1717 which will fill in all of the bits. */
1724 case UNSPEC_VOLATILE:
1725 gcc_assert (targetm.dwarf_handle_frame_unspec);
1726 targetm.dwarf_handle_frame_unspec (label, expr, XINT (src, 1));
1733 def_cfa_1 (label, &cfa);
1737 gcc_assert (REG_P (src));
1739 /* Saving a register to the stack. Make sure dest is relative to the
1741 switch (GET_CODE (XEXP (dest, 0)))
1746 /* We can't handle variable size modifications. */
1747 gcc_assert (GET_CODE (XEXP (XEXP (XEXP (dest, 0), 1), 1))
1749 offset = -INTVAL (XEXP (XEXP (XEXP (dest, 0), 1), 1));
1751 gcc_assert (REGNO (XEXP (XEXP (dest, 0), 0)) == STACK_POINTER_REGNUM
1752 && cfa_store.reg == STACK_POINTER_REGNUM);
1754 cfa_store.offset += offset;
1755 if (cfa.reg == STACK_POINTER_REGNUM)
1756 cfa.offset = cfa_store.offset;
1758 offset = -cfa_store.offset;
1764 offset = GET_MODE_SIZE (GET_MODE (dest));
1765 if (GET_CODE (XEXP (dest, 0)) == PRE_INC)
1768 gcc_assert (REGNO (XEXP (XEXP (dest, 0), 0)) == STACK_POINTER_REGNUM
1769 && cfa_store.reg == STACK_POINTER_REGNUM);
1771 cfa_store.offset += offset;
1772 if (cfa.reg == STACK_POINTER_REGNUM)
1773 cfa.offset = cfa_store.offset;
1775 offset = -cfa_store.offset;
1779 /* With an offset. */
1786 gcc_assert (GET_CODE (XEXP (XEXP (dest, 0), 1)) == CONST_INT);
1787 offset = INTVAL (XEXP (XEXP (dest, 0), 1));
1788 if (GET_CODE (XEXP (dest, 0)) == MINUS)
1791 regno = REGNO (XEXP (XEXP (dest, 0), 0));
1793 if (cfa_store.reg == (unsigned) regno)
1794 offset -= cfa_store.offset;
1797 gcc_assert (cfa_temp.reg == (unsigned) regno);
1798 offset -= cfa_temp.offset;
1804 /* Without an offset. */
1807 int regno = REGNO (XEXP (dest, 0));
1809 if (cfa_store.reg == (unsigned) regno)
1810 offset = -cfa_store.offset;
1813 gcc_assert (cfa_temp.reg == (unsigned) regno);
1814 offset = -cfa_temp.offset;
1821 gcc_assert (cfa_temp.reg
1822 == (unsigned) REGNO (XEXP (XEXP (dest, 0), 0)));
1823 offset = -cfa_temp.offset;
1824 cfa_temp.offset -= GET_MODE_SIZE (GET_MODE (dest));
1831 if (REGNO (src) != STACK_POINTER_REGNUM
1832 && REGNO (src) != HARD_FRAME_POINTER_REGNUM
1833 && (unsigned) REGNO (src) == cfa.reg)
1835 /* We're storing the current CFA reg into the stack. */
1837 if (cfa.offset == 0)
1839 /* If the source register is exactly the CFA, assume
1840 we're saving SP like any other register; this happens
1842 def_cfa_1 (label, &cfa);
1843 queue_reg_save (label, stack_pointer_rtx, NULL_RTX, offset);
1848 /* Otherwise, we'll need to look in the stack to
1849 calculate the CFA. */
1850 rtx x = XEXP (dest, 0);
1854 gcc_assert (REG_P (x));
1856 cfa.reg = REGNO (x);
1857 cfa.base_offset = offset;
1859 def_cfa_1 (label, &cfa);
1864 def_cfa_1 (label, &cfa);
1865 queue_reg_save (label, src, NULL_RTX, offset);
1873 /* Record call frame debugging information for INSN, which either
1874 sets SP or FP (adjusting how we calculate the frame address) or saves a
1875 register to the stack. If INSN is NULL_RTX, initialize our state.
1877 If AFTER_P is false, we're being called before the insn is emitted,
1878 otherwise after. Call instructions get invoked twice. */
1881 dwarf2out_frame_debug (rtx insn, bool after_p)
1886 if (insn == NULL_RTX)
1890 /* Flush any queued register saves. */
1891 flush_queued_reg_saves ();
1893 /* Set up state for generating call frame debug info. */
1896 == (unsigned long)DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM));
1898 cfa.reg = STACK_POINTER_REGNUM;
1901 cfa_temp.offset = 0;
1903 for (i = 0; i < num_regs_saved_in_regs; i++)
1905 regs_saved_in_regs[i].orig_reg = NULL_RTX;
1906 regs_saved_in_regs[i].saved_in_reg = NULL_RTX;
1908 num_regs_saved_in_regs = 0;
1912 if (!NONJUMP_INSN_P (insn) || clobbers_queued_reg_save (insn))
1913 flush_queued_reg_saves ();
1915 if (! RTX_FRAME_RELATED_P (insn))
1917 if (!ACCUMULATE_OUTGOING_ARGS)
1918 dwarf2out_stack_adjust (insn, after_p);
1922 label = dwarf2out_cfi_label ();
1923 src = find_reg_note (insn, REG_FRAME_RELATED_EXPR, NULL_RTX);
1925 insn = XEXP (src, 0);
1927 insn = PATTERN (insn);
1929 dwarf2out_frame_debug_expr (insn, label);
1934 /* Describe for the GTY machinery what parts of dw_cfi_oprnd1 are used. */
1935 static enum dw_cfi_oprnd_type dw_cfi_oprnd1_desc
1936 (enum dwarf_call_frame_info cfi);
1938 static enum dw_cfi_oprnd_type
1939 dw_cfi_oprnd1_desc (enum dwarf_call_frame_info cfi)
1944 case DW_CFA_GNU_window_save:
1945 return dw_cfi_oprnd_unused;
1947 case DW_CFA_set_loc:
1948 case DW_CFA_advance_loc1:
1949 case DW_CFA_advance_loc2:
1950 case DW_CFA_advance_loc4:
1951 case DW_CFA_MIPS_advance_loc8:
1952 return dw_cfi_oprnd_addr;
1955 case DW_CFA_offset_extended:
1956 case DW_CFA_def_cfa:
1957 case DW_CFA_offset_extended_sf:
1958 case DW_CFA_def_cfa_sf:
1959 case DW_CFA_restore_extended:
1960 case DW_CFA_undefined:
1961 case DW_CFA_same_value:
1962 case DW_CFA_def_cfa_register:
1963 case DW_CFA_register:
1964 return dw_cfi_oprnd_reg_num;
1966 case DW_CFA_def_cfa_offset:
1967 case DW_CFA_GNU_args_size:
1968 case DW_CFA_def_cfa_offset_sf:
1969 return dw_cfi_oprnd_offset;
1971 case DW_CFA_def_cfa_expression:
1972 case DW_CFA_expression:
1973 return dw_cfi_oprnd_loc;
1980 /* Describe for the GTY machinery what parts of dw_cfi_oprnd2 are used. */
1981 static enum dw_cfi_oprnd_type dw_cfi_oprnd2_desc
1982 (enum dwarf_call_frame_info cfi);
1984 static enum dw_cfi_oprnd_type
1985 dw_cfi_oprnd2_desc (enum dwarf_call_frame_info cfi)
1989 case DW_CFA_def_cfa:
1990 case DW_CFA_def_cfa_sf:
1992 case DW_CFA_offset_extended_sf:
1993 case DW_CFA_offset_extended:
1994 return dw_cfi_oprnd_offset;
1996 case DW_CFA_register:
1997 return dw_cfi_oprnd_reg_num;
2000 return dw_cfi_oprnd_unused;
2004 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
2006 /* Map register numbers held in the call frame info that gcc has
2007 collected using DWARF_FRAME_REGNUM to those that should be output in
2008 .debug_frame and .eh_frame. */
2009 #ifndef DWARF2_FRAME_REG_OUT
2010 #define DWARF2_FRAME_REG_OUT(REGNO, FOR_EH) (REGNO)
2013 /* Output a Call Frame Information opcode and its operand(s). */
2016 output_cfi (dw_cfi_ref cfi, dw_fde_ref fde, int for_eh)
2019 if (cfi->dw_cfi_opc == DW_CFA_advance_loc)
2020 dw2_asm_output_data (1, (cfi->dw_cfi_opc
2021 | (cfi->dw_cfi_oprnd1.dw_cfi_offset & 0x3f)),
2022 "DW_CFA_advance_loc " HOST_WIDE_INT_PRINT_HEX,
2023 cfi->dw_cfi_oprnd1.dw_cfi_offset);
2024 else if (cfi->dw_cfi_opc == DW_CFA_offset)
2026 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2027 dw2_asm_output_data (1, (cfi->dw_cfi_opc | (r & 0x3f)),
2028 "DW_CFA_offset, column 0x%lx", r);
2029 dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL);
2031 else if (cfi->dw_cfi_opc == DW_CFA_restore)
2033 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2034 dw2_asm_output_data (1, (cfi->dw_cfi_opc | (r & 0x3f)),
2035 "DW_CFA_restore, column 0x%lx", r);
2039 dw2_asm_output_data (1, cfi->dw_cfi_opc,
2040 "%s", dwarf_cfi_name (cfi->dw_cfi_opc));
2042 switch (cfi->dw_cfi_opc)
2044 case DW_CFA_set_loc:
2046 dw2_asm_output_encoded_addr_rtx (
2047 ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0),
2048 gen_rtx_SYMBOL_REF (Pmode, cfi->dw_cfi_oprnd1.dw_cfi_addr),
2051 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
2052 cfi->dw_cfi_oprnd1.dw_cfi_addr, NULL);
2055 case DW_CFA_advance_loc1:
2056 dw2_asm_output_delta (1, cfi->dw_cfi_oprnd1.dw_cfi_addr,
2057 fde->dw_fde_current_label, NULL);
2058 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
2061 case DW_CFA_advance_loc2:
2062 dw2_asm_output_delta (2, cfi->dw_cfi_oprnd1.dw_cfi_addr,
2063 fde->dw_fde_current_label, NULL);
2064 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
2067 case DW_CFA_advance_loc4:
2068 dw2_asm_output_delta (4, cfi->dw_cfi_oprnd1.dw_cfi_addr,
2069 fde->dw_fde_current_label, NULL);
2070 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
2073 case DW_CFA_MIPS_advance_loc8:
2074 dw2_asm_output_delta (8, cfi->dw_cfi_oprnd1.dw_cfi_addr,
2075 fde->dw_fde_current_label, NULL);
2076 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
2079 case DW_CFA_offset_extended:
2080 case DW_CFA_def_cfa:
2081 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2082 dw2_asm_output_data_uleb128 (r, NULL);
2083 dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL);
2086 case DW_CFA_offset_extended_sf:
2087 case DW_CFA_def_cfa_sf:
2088 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2089 dw2_asm_output_data_uleb128 (r, NULL);
2090 dw2_asm_output_data_sleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset, NULL);
2093 case DW_CFA_restore_extended:
2094 case DW_CFA_undefined:
2095 case DW_CFA_same_value:
2096 case DW_CFA_def_cfa_register:
2097 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2098 dw2_asm_output_data_uleb128 (r, NULL);
2101 case DW_CFA_register:
2102 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd1.dw_cfi_reg_num, for_eh);
2103 dw2_asm_output_data_uleb128 (r, NULL);
2104 r = DWARF2_FRAME_REG_OUT (cfi->dw_cfi_oprnd2.dw_cfi_reg_num, for_eh);
2105 dw2_asm_output_data_uleb128 (r, NULL);
2108 case DW_CFA_def_cfa_offset:
2109 case DW_CFA_GNU_args_size:
2110 dw2_asm_output_data_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset, NULL);
2113 case DW_CFA_def_cfa_offset_sf:
2114 dw2_asm_output_data_sleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset, NULL);
2117 case DW_CFA_GNU_window_save:
2120 case DW_CFA_def_cfa_expression:
2121 case DW_CFA_expression:
2122 output_cfa_loc (cfi);
2125 case DW_CFA_GNU_negative_offset_extended:
2126 /* Obsoleted by DW_CFA_offset_extended_sf. */
2135 /* Output the call frame information used to record information
2136 that relates to calculating the frame pointer, and records the
2137 location of saved registers. */
2140 output_call_frame_info (int for_eh)
2145 char l1[20], l2[20], section_start_label[20];
2146 bool any_lsda_needed = false;
2147 char augmentation[6];
2148 int augmentation_size;
2149 int fde_encoding = DW_EH_PE_absptr;
2150 int per_encoding = DW_EH_PE_absptr;
2151 int lsda_encoding = DW_EH_PE_absptr;
2154 /* Don't emit a CIE if there won't be any FDEs. */
2155 if (fde_table_in_use == 0)
2158 /* If we make FDEs linkonce, we may have to emit an empty label for
2159 an FDE that wouldn't otherwise be emitted. We want to avoid
2160 having an FDE kept around when the function it refers to is
2161 discarded. Example where this matters: a primary function
2162 template in C++ requires EH information, but an explicit
2163 specialization doesn't. */
2164 if (TARGET_USES_WEAK_UNWIND_INFO
2165 && ! flag_asynchronous_unwind_tables
2167 for (i = 0; i < fde_table_in_use; i++)
2168 if ((fde_table[i].nothrow || fde_table[i].all_throwers_are_sibcalls)
2169 && !fde_table[i].uses_eh_lsda
2170 && ! DECL_WEAK (fde_table[i].decl))
2171 targetm.asm_out.unwind_label (asm_out_file, fde_table[i].decl,
2172 for_eh, /* empty */ 1);
2174 /* If we don't have any functions we'll want to unwind out of, don't
2175 emit any EH unwind information. Note that if exceptions aren't
2176 enabled, we won't have collected nothrow information, and if we
2177 asked for asynchronous tables, we always want this info. */
2180 bool any_eh_needed = !flag_exceptions || flag_asynchronous_unwind_tables;
2182 for (i = 0; i < fde_table_in_use; i++)
2183 if (fde_table[i].uses_eh_lsda)
2184 any_eh_needed = any_lsda_needed = true;
2185 else if (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde_table[i].decl))
2186 any_eh_needed = true;
2187 else if (! fde_table[i].nothrow
2188 && ! fde_table[i].all_throwers_are_sibcalls)
2189 any_eh_needed = true;
2191 if (! any_eh_needed)
2195 /* We're going to be generating comments, so turn on app. */
2200 targetm.asm_out.eh_frame_section ();
2202 named_section_flags (DEBUG_FRAME_SECTION, SECTION_DEBUG);
2204 ASM_GENERATE_INTERNAL_LABEL (section_start_label, FRAME_BEGIN_LABEL, for_eh);
2205 ASM_OUTPUT_LABEL (asm_out_file, section_start_label);
2207 /* Output the CIE. */
2208 ASM_GENERATE_INTERNAL_LABEL (l1, CIE_AFTER_SIZE_LABEL, for_eh);
2209 ASM_GENERATE_INTERNAL_LABEL (l2, CIE_END_LABEL, for_eh);
2210 dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
2211 "Length of Common Information Entry");
2212 ASM_OUTPUT_LABEL (asm_out_file, l1);
2214 /* Now that the CIE pointer is PC-relative for EH,
2215 use 0 to identify the CIE. */
2216 dw2_asm_output_data ((for_eh ? 4 : DWARF_OFFSET_SIZE),
2217 (for_eh ? 0 : DW_CIE_ID),
2218 "CIE Identifier Tag");
2220 dw2_asm_output_data (1, DW_CIE_VERSION, "CIE Version");
2222 augmentation[0] = 0;
2223 augmentation_size = 0;
2229 z Indicates that a uleb128 is present to size the
2230 augmentation section.
2231 L Indicates the encoding (and thus presence) of
2232 an LSDA pointer in the FDE augmentation.
2233 R Indicates a non-default pointer encoding for
2235 P Indicates the presence of an encoding + language
2236 personality routine in the CIE augmentation. */
2238 fde_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/1, /*global=*/0);
2239 per_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/2, /*global=*/1);
2240 lsda_encoding = ASM_PREFERRED_EH_DATA_FORMAT (/*code=*/0, /*global=*/0);
2242 p = augmentation + 1;
2243 if (eh_personality_libfunc)
2246 augmentation_size += 1 + size_of_encoded_value (per_encoding);
2248 if (any_lsda_needed)
2251 augmentation_size += 1;
2253 if (fde_encoding != DW_EH_PE_absptr)
2256 augmentation_size += 1;
2258 if (p > augmentation + 1)
2260 augmentation[0] = 'z';
2264 /* Ug. Some platforms can't do unaligned dynamic relocations at all. */
2265 if (eh_personality_libfunc && per_encoding == DW_EH_PE_aligned)
2267 int offset = ( 4 /* Length */
2269 + 1 /* CIE version */
2270 + strlen (augmentation) + 1 /* Augmentation */
2271 + size_of_uleb128 (1) /* Code alignment */
2272 + size_of_sleb128 (DWARF_CIE_DATA_ALIGNMENT)
2274 + 1 /* Augmentation size */
2275 + 1 /* Personality encoding */ );
2276 int pad = -offset & (PTR_SIZE - 1);
2278 augmentation_size += pad;
2280 /* Augmentations should be small, so there's scarce need to
2281 iterate for a solution. Die if we exceed one uleb128 byte. */
2282 gcc_assert (size_of_uleb128 (augmentation_size) == 1);
2286 dw2_asm_output_nstring (augmentation, -1, "CIE Augmentation");
2287 dw2_asm_output_data_uleb128 (1, "CIE Code Alignment Factor");
2288 dw2_asm_output_data_sleb128 (DWARF_CIE_DATA_ALIGNMENT,
2289 "CIE Data Alignment Factor");
2291 return_reg = DWARF2_FRAME_REG_OUT (DWARF_FRAME_RETURN_COLUMN, for_eh);
2292 if (DW_CIE_VERSION == 1)
2293 dw2_asm_output_data (1, return_reg, "CIE RA Column");
2295 dw2_asm_output_data_uleb128 (return_reg, "CIE RA Column");
2297 if (augmentation[0])
2299 dw2_asm_output_data_uleb128 (augmentation_size, "Augmentation size");
2300 if (eh_personality_libfunc)
2302 dw2_asm_output_data (1, per_encoding, "Personality (%s)",
2303 eh_data_format_name (per_encoding));
2304 dw2_asm_output_encoded_addr_rtx (per_encoding,
2305 eh_personality_libfunc,
2309 if (any_lsda_needed)
2310 dw2_asm_output_data (1, lsda_encoding, "LSDA Encoding (%s)",
2311 eh_data_format_name (lsda_encoding));
2313 if (fde_encoding != DW_EH_PE_absptr)
2314 dw2_asm_output_data (1, fde_encoding, "FDE Encoding (%s)",
2315 eh_data_format_name (fde_encoding));
2318 for (cfi = cie_cfi_head; cfi != NULL; cfi = cfi->dw_cfi_next)
2319 output_cfi (cfi, NULL, for_eh);
2321 /* Pad the CIE out to an address sized boundary. */
2322 ASM_OUTPUT_ALIGN (asm_out_file,
2323 floor_log2 (for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE));
2324 ASM_OUTPUT_LABEL (asm_out_file, l2);
2326 /* Loop through all of the FDE's. */
2327 for (i = 0; i < fde_table_in_use; i++)
2329 fde = &fde_table[i];
2331 /* Don't emit EH unwind info for leaf functions that don't need it. */
2332 if (for_eh && !flag_asynchronous_unwind_tables && flag_exceptions
2333 && (fde->nothrow || fde->all_throwers_are_sibcalls)
2334 && ! (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde_table[i].decl))
2335 && !fde->uses_eh_lsda)
2338 targetm.asm_out.unwind_label (asm_out_file, fde->decl, for_eh, /* empty */ 0);
2339 targetm.asm_out.internal_label (asm_out_file, FDE_LABEL, for_eh + i * 2);
2340 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_AFTER_SIZE_LABEL, for_eh + i * 2);
2341 ASM_GENERATE_INTERNAL_LABEL (l2, FDE_END_LABEL, for_eh + i * 2);
2342 dw2_asm_output_delta (for_eh ? 4 : DWARF_OFFSET_SIZE, l2, l1,
2344 ASM_OUTPUT_LABEL (asm_out_file, l1);
2347 dw2_asm_output_delta (4, l1, section_start_label, "FDE CIE offset");
2349 dw2_asm_output_offset (DWARF_OFFSET_SIZE, section_start_label,
2354 rtx sym_ref = gen_rtx_SYMBOL_REF (Pmode, fde->dw_fde_begin);
2355 SYMBOL_REF_FLAGS (sym_ref) |= SYMBOL_FLAG_LOCAL;
2356 dw2_asm_output_encoded_addr_rtx (fde_encoding,
2359 "FDE initial location");
2360 if (fde->dw_fde_switched_sections)
2362 rtx sym_ref2 = gen_rtx_SYMBOL_REF (Pmode,
2363 fde->dw_fde_unlikely_section_label);
2364 rtx sym_ref3= gen_rtx_SYMBOL_REF (Pmode,
2365 fde->dw_fde_hot_section_label);
2366 SYMBOL_REF_FLAGS (sym_ref2) |= SYMBOL_FLAG_LOCAL;
2367 SYMBOL_REF_FLAGS (sym_ref3) |= SYMBOL_FLAG_LOCAL;
2368 dw2_asm_output_encoded_addr_rtx (fde_encoding, sym_ref3, false,
2369 "FDE initial location");
2370 dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
2371 fde->dw_fde_hot_section_end_label,
2372 fde->dw_fde_hot_section_label,
2373 "FDE address range");
2374 dw2_asm_output_encoded_addr_rtx (fde_encoding, sym_ref2, false,
2375 "FDE initial location");
2376 dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
2377 fde->dw_fde_unlikely_section_end_label,
2378 fde->dw_fde_unlikely_section_label,
2379 "FDE address range");
2382 dw2_asm_output_delta (size_of_encoded_value (fde_encoding),
2383 fde->dw_fde_end, fde->dw_fde_begin,
2384 "FDE address range");
2388 dw2_asm_output_addr (DWARF2_ADDR_SIZE, fde->dw_fde_begin,
2389 "FDE initial location");
2390 if (fde->dw_fde_switched_sections)
2392 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
2393 fde->dw_fde_hot_section_label,
2394 "FDE initial location");
2395 dw2_asm_output_delta (DWARF2_ADDR_SIZE,
2396 fde->dw_fde_hot_section_end_label,
2397 fde->dw_fde_hot_section_label,
2398 "FDE address range");
2399 dw2_asm_output_addr (DWARF2_ADDR_SIZE,
2400 fde->dw_fde_unlikely_section_label,
2401 "FDE initial location");
2402 dw2_asm_output_delta (DWARF2_ADDR_SIZE,
2403 fde->dw_fde_unlikely_section_end_label,
2404 fde->dw_fde_unlikely_section_label,
2405 "FDE address range");
2408 dw2_asm_output_delta (DWARF2_ADDR_SIZE,
2409 fde->dw_fde_end, fde->dw_fde_begin,
2410 "FDE address range");
2413 if (augmentation[0])
2415 if (any_lsda_needed)
2417 int size = size_of_encoded_value (lsda_encoding);
2419 if (lsda_encoding == DW_EH_PE_aligned)
2421 int offset = ( 4 /* Length */
2422 + 4 /* CIE offset */
2423 + 2 * size_of_encoded_value (fde_encoding)
2424 + 1 /* Augmentation size */ );
2425 int pad = -offset & (PTR_SIZE - 1);
2428 gcc_assert (size_of_uleb128 (size) == 1);
2431 dw2_asm_output_data_uleb128 (size, "Augmentation size");
2433 if (fde->uses_eh_lsda)
2435 ASM_GENERATE_INTERNAL_LABEL (l1, "LLSDA",
2436 fde->funcdef_number);
2437 dw2_asm_output_encoded_addr_rtx (
2438 lsda_encoding, gen_rtx_SYMBOL_REF (Pmode, l1),
2439 false, "Language Specific Data Area");
2443 if (lsda_encoding == DW_EH_PE_aligned)
2444 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
2446 (size_of_encoded_value (lsda_encoding), 0,
2447 "Language Specific Data Area (none)");
2451 dw2_asm_output_data_uleb128 (0, "Augmentation size");
2454 /* Loop through the Call Frame Instructions associated with
2456 fde->dw_fde_current_label = fde->dw_fde_begin;
2457 for (cfi = fde->dw_fde_cfi; cfi != NULL; cfi = cfi->dw_cfi_next)
2458 output_cfi (cfi, fde, for_eh);
2460 /* Pad the FDE out to an address sized boundary. */
2461 ASM_OUTPUT_ALIGN (asm_out_file,
2462 floor_log2 ((for_eh ? PTR_SIZE : DWARF2_ADDR_SIZE)));
2463 ASM_OUTPUT_LABEL (asm_out_file, l2);
2466 if (for_eh && targetm.terminate_dw2_eh_frame_info)
2467 dw2_asm_output_data (4, 0, "End of Table");
2468 #ifdef MIPS_DEBUGGING_INFO
2469 /* Work around Irix 6 assembler bug whereby labels at the end of a section
2470 get a value of 0. Putting .align 0 after the label fixes it. */
2471 ASM_OUTPUT_ALIGN (asm_out_file, 0);
2474 /* Turn off app to make assembly quicker. */
2479 /* Output a marker (i.e. a label) for the beginning of a function, before
2483 dwarf2out_begin_prologue (unsigned int line ATTRIBUTE_UNUSED,
2484 const char *file ATTRIBUTE_UNUSED)
2486 char label[MAX_ARTIFICIAL_LABEL_BYTES];
2490 current_function_func_begin_label = NULL;
2492 #ifdef TARGET_UNWIND_INFO
2493 /* ??? current_function_func_begin_label is also used by except.c
2494 for call-site information. We must emit this label if it might
2496 if ((! flag_exceptions || USING_SJLJ_EXCEPTIONS)
2497 && ! dwarf2out_do_frame ())
2500 if (! dwarf2out_do_frame ())
2504 function_section (current_function_decl);
2505 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_BEGIN_LABEL,
2506 current_function_funcdef_no);
2507 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, FUNC_BEGIN_LABEL,
2508 current_function_funcdef_no);
2509 dup_label = xstrdup (label);
2510 current_function_func_begin_label = dup_label;
2512 #ifdef TARGET_UNWIND_INFO
2513 /* We can elide the fde allocation if we're not emitting debug info. */
2514 if (! dwarf2out_do_frame ())
2518 /* Expand the fde table if necessary. */
2519 if (fde_table_in_use == fde_table_allocated)
2521 fde_table_allocated += FDE_TABLE_INCREMENT;
2522 fde_table = ggc_realloc (fde_table,
2523 fde_table_allocated * sizeof (dw_fde_node));
2524 memset (fde_table + fde_table_in_use, 0,
2525 FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
2528 /* Record the FDE associated with this function. */
2529 current_funcdef_fde = fde_table_in_use;
2531 /* Add the new FDE at the end of the fde_table. */
2532 fde = &fde_table[fde_table_in_use++];
2533 fde->decl = current_function_decl;
2534 fde->dw_fde_begin = dup_label;
2535 fde->dw_fde_current_label = NULL;
2536 fde->dw_fde_hot_section_label = NULL;
2537 fde->dw_fde_hot_section_end_label = NULL;
2538 fde->dw_fde_unlikely_section_label = NULL;
2539 fde->dw_fde_unlikely_section_end_label = NULL;
2540 fde->dw_fde_switched_sections = false;
2541 fde->dw_fde_end = NULL;
2542 fde->dw_fde_cfi = NULL;
2543 fde->funcdef_number = current_function_funcdef_no;
2544 fde->nothrow = TREE_NOTHROW (current_function_decl);
2545 fde->uses_eh_lsda = cfun->uses_eh_lsda;
2546 fde->all_throwers_are_sibcalls = cfun->all_throwers_are_sibcalls;
2548 args_size = old_args_size = 0;
2550 /* We only want to output line number information for the genuine dwarf2
2551 prologue case, not the eh frame case. */
2552 #ifdef DWARF2_DEBUGGING_INFO
2554 dwarf2out_source_line (line, file);
2558 /* Output a marker (i.e. a label) for the absolute end of the generated code
2559 for a function definition. This gets called *after* the epilogue code has
2563 dwarf2out_end_epilogue (unsigned int line ATTRIBUTE_UNUSED,
2564 const char *file ATTRIBUTE_UNUSED)
2567 char label[MAX_ARTIFICIAL_LABEL_BYTES];
2569 /* Output a label to mark the endpoint of the code generated for this
2571 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL,
2572 current_function_funcdef_no);
2573 ASM_OUTPUT_LABEL (asm_out_file, label);
2574 fde = &fde_table[fde_table_in_use - 1];
2575 fde->dw_fde_end = xstrdup (label);
2579 dwarf2out_frame_init (void)
2581 /* Allocate the initial hunk of the fde_table. */
2582 fde_table = ggc_alloc_cleared (FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
2583 fde_table_allocated = FDE_TABLE_INCREMENT;
2584 fde_table_in_use = 0;
2586 /* Generate the CFA instructions common to all FDE's. Do it now for the
2587 sake of lookup_cfa. */
2589 /* On entry, the Canonical Frame Address is at SP. */
2590 dwarf2out_def_cfa (NULL, STACK_POINTER_REGNUM, INCOMING_FRAME_SP_OFFSET);
2592 #ifdef DWARF2_UNWIND_INFO
2593 if (DWARF2_UNWIND_INFO)
2594 initial_return_save (INCOMING_RETURN_ADDR_RTX);
2599 dwarf2out_frame_finish (void)
2601 /* Output call frame information. */
2602 if (DWARF2_FRAME_INFO)
2603 output_call_frame_info (0);
2605 #ifndef TARGET_UNWIND_INFO
2606 /* Output another copy for the unwinder. */
2607 if (! USING_SJLJ_EXCEPTIONS && (flag_unwind_tables || flag_exceptions))
2608 output_call_frame_info (1);
2613 /* And now, the subset of the debugging information support code necessary
2614 for emitting location expressions. */
2616 /* We need some way to distinguish DW_OP_addr with a direct symbol
2617 relocation from DW_OP_addr with a dtp-relative symbol relocation. */
2618 #define INTERNAL_DW_OP_tls_addr (0x100 + DW_OP_addr)
2621 typedef struct dw_val_struct *dw_val_ref;
2622 typedef struct die_struct *dw_die_ref;
2623 typedef struct dw_loc_descr_struct *dw_loc_descr_ref;
2624 typedef struct dw_loc_list_struct *dw_loc_list_ref;
2626 /* Each DIE may have a series of attribute/value pairs. Values
2627 can take on several forms. The forms that are used in this
2628 implementation are listed below. */
2633 dw_val_class_offset,
2635 dw_val_class_loc_list,
2636 dw_val_class_range_list,
2638 dw_val_class_unsigned_const,
2639 dw_val_class_long_long,
2642 dw_val_class_die_ref,
2643 dw_val_class_fde_ref,
2644 dw_val_class_lbl_id,
2645 dw_val_class_lbl_offset,
2649 /* Describe a double word constant value. */
2650 /* ??? Every instance of long_long in the code really means CONST_DOUBLE. */
2652 typedef struct dw_long_long_struct GTY(())
2659 /* Describe a floating point constant value, or a vector constant value. */
2661 typedef struct dw_vec_struct GTY(())
2663 unsigned char * GTY((length ("%h.length"))) array;
2669 /* The dw_val_node describes an attribute's value, as it is
2670 represented internally. */
2672 typedef struct dw_val_struct GTY(())
2674 enum dw_val_class val_class;
2675 union dw_val_struct_union
2677 rtx GTY ((tag ("dw_val_class_addr"))) val_addr;
2678 unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_offset"))) val_offset;
2679 dw_loc_list_ref GTY ((tag ("dw_val_class_loc_list"))) val_loc_list;
2680 dw_loc_descr_ref GTY ((tag ("dw_val_class_loc"))) val_loc;
2681 HOST_WIDE_INT GTY ((default)) val_int;
2682 unsigned HOST_WIDE_INT GTY ((tag ("dw_val_class_unsigned_const"))) val_unsigned;
2683 dw_long_long_const GTY ((tag ("dw_val_class_long_long"))) val_long_long;
2684 dw_vec_const GTY ((tag ("dw_val_class_vec"))) val_vec;
2685 struct dw_val_die_union
2689 } GTY ((tag ("dw_val_class_die_ref"))) val_die_ref;
2690 unsigned GTY ((tag ("dw_val_class_fde_ref"))) val_fde_index;
2691 struct indirect_string_node * GTY ((tag ("dw_val_class_str"))) val_str;
2692 char * GTY ((tag ("dw_val_class_lbl_id"))) val_lbl_id;
2693 unsigned char GTY ((tag ("dw_val_class_flag"))) val_flag;
2695 GTY ((desc ("%1.val_class"))) v;
2699 /* Locations in memory are described using a sequence of stack machine
2702 typedef struct dw_loc_descr_struct GTY(())
2704 dw_loc_descr_ref dw_loc_next;
2705 enum dwarf_location_atom dw_loc_opc;
2706 dw_val_node dw_loc_oprnd1;
2707 dw_val_node dw_loc_oprnd2;
2712 /* Location lists are ranges + location descriptions for that range,
2713 so you can track variables that are in different places over
2714 their entire life. */
2715 typedef struct dw_loc_list_struct GTY(())
2717 dw_loc_list_ref dw_loc_next;
2718 const char *begin; /* Label for begin address of range */
2719 const char *end; /* Label for end address of range */
2720 char *ll_symbol; /* Label for beginning of location list.
2721 Only on head of list */
2722 const char *section; /* Section this loclist is relative to */
2723 dw_loc_descr_ref expr;
2726 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
2728 static const char *dwarf_stack_op_name (unsigned);
2729 static dw_loc_descr_ref new_loc_descr (enum dwarf_location_atom,
2730 unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT);
2731 static void add_loc_descr (dw_loc_descr_ref *, dw_loc_descr_ref);
2732 static unsigned long size_of_loc_descr (dw_loc_descr_ref);
2733 static unsigned long size_of_locs (dw_loc_descr_ref);
2734 static void output_loc_operands (dw_loc_descr_ref);
2735 static void output_loc_sequence (dw_loc_descr_ref);
2737 /* Convert a DWARF stack opcode into its string name. */
2740 dwarf_stack_op_name (unsigned int op)
2745 case INTERNAL_DW_OP_tls_addr:
2746 return "DW_OP_addr";
2748 return "DW_OP_deref";
2750 return "DW_OP_const1u";
2752 return "DW_OP_const1s";
2754 return "DW_OP_const2u";
2756 return "DW_OP_const2s";
2758 return "DW_OP_const4u";
2760 return "DW_OP_const4s";
2762 return "DW_OP_const8u";
2764 return "DW_OP_const8s";
2766 return "DW_OP_constu";
2768 return "DW_OP_consts";
2772 return "DW_OP_drop";
2774 return "DW_OP_over";
2776 return "DW_OP_pick";
2778 return "DW_OP_swap";
2782 return "DW_OP_xderef";
2790 return "DW_OP_minus";
2802 return "DW_OP_plus";
2803 case DW_OP_plus_uconst:
2804 return "DW_OP_plus_uconst";
2810 return "DW_OP_shra";
2828 return "DW_OP_skip";
2830 return "DW_OP_lit0";
2832 return "DW_OP_lit1";
2834 return "DW_OP_lit2";
2836 return "DW_OP_lit3";
2838 return "DW_OP_lit4";
2840 return "DW_OP_lit5";
2842 return "DW_OP_lit6";
2844 return "DW_OP_lit7";
2846 return "DW_OP_lit8";
2848 return "DW_OP_lit9";
2850 return "DW_OP_lit10";
2852 return "DW_OP_lit11";
2854 return "DW_OP_lit12";
2856 return "DW_OP_lit13";
2858 return "DW_OP_lit14";
2860 return "DW_OP_lit15";
2862 return "DW_OP_lit16";
2864 return "DW_OP_lit17";
2866 return "DW_OP_lit18";
2868 return "DW_OP_lit19";
2870 return "DW_OP_lit20";
2872 return "DW_OP_lit21";
2874 return "DW_OP_lit22";
2876 return "DW_OP_lit23";
2878 return "DW_OP_lit24";
2880 return "DW_OP_lit25";
2882 return "DW_OP_lit26";
2884 return "DW_OP_lit27";
2886 return "DW_OP_lit28";
2888 return "DW_OP_lit29";
2890 return "DW_OP_lit30";
2892 return "DW_OP_lit31";
2894 return "DW_OP_reg0";
2896 return "DW_OP_reg1";
2898 return "DW_OP_reg2";
2900 return "DW_OP_reg3";
2902 return "DW_OP_reg4";
2904 return "DW_OP_reg5";
2906 return "DW_OP_reg6";
2908 return "DW_OP_reg7";
2910 return "DW_OP_reg8";
2912 return "DW_OP_reg9";
2914 return "DW_OP_reg10";
2916 return "DW_OP_reg11";
2918 return "DW_OP_reg12";
2920 return "DW_OP_reg13";
2922 return "DW_OP_reg14";
2924 return "DW_OP_reg15";
2926 return "DW_OP_reg16";
2928 return "DW_OP_reg17";
2930 return "DW_OP_reg18";
2932 return "DW_OP_reg19";
2934 return "DW_OP_reg20";
2936 return "DW_OP_reg21";
2938 return "DW_OP_reg22";
2940 return "DW_OP_reg23";
2942 return "DW_OP_reg24";
2944 return "DW_OP_reg25";
2946 return "DW_OP_reg26";
2948 return "DW_OP_reg27";
2950 return "DW_OP_reg28";
2952 return "DW_OP_reg29";
2954 return "DW_OP_reg30";
2956 return "DW_OP_reg31";
2958 return "DW_OP_breg0";
2960 return "DW_OP_breg1";
2962 return "DW_OP_breg2";
2964 return "DW_OP_breg3";
2966 return "DW_OP_breg4";
2968 return "DW_OP_breg5";
2970 return "DW_OP_breg6";
2972 return "DW_OP_breg7";
2974 return "DW_OP_breg8";
2976 return "DW_OP_breg9";
2978 return "DW_OP_breg10";
2980 return "DW_OP_breg11";
2982 return "DW_OP_breg12";
2984 return "DW_OP_breg13";
2986 return "DW_OP_breg14";
2988 return "DW_OP_breg15";
2990 return "DW_OP_breg16";
2992 return "DW_OP_breg17";
2994 return "DW_OP_breg18";
2996 return "DW_OP_breg19";
2998 return "DW_OP_breg20";
3000 return "DW_OP_breg21";
3002 return "DW_OP_breg22";
3004 return "DW_OP_breg23";
3006 return "DW_OP_breg24";
3008 return "DW_OP_breg25";
3010 return "DW_OP_breg26";
3012 return "DW_OP_breg27";
3014 return "DW_OP_breg28";
3016 return "DW_OP_breg29";
3018 return "DW_OP_breg30";
3020 return "DW_OP_breg31";
3022 return "DW_OP_regx";
3024 return "DW_OP_fbreg";
3026 return "DW_OP_bregx";
3028 return "DW_OP_piece";
3029 case DW_OP_deref_size:
3030 return "DW_OP_deref_size";
3031 case DW_OP_xderef_size:
3032 return "DW_OP_xderef_size";
3035 case DW_OP_push_object_address:
3036 return "DW_OP_push_object_address";
3038 return "DW_OP_call2";
3040 return "DW_OP_call4";
3041 case DW_OP_call_ref:
3042 return "DW_OP_call_ref";
3043 case DW_OP_GNU_push_tls_address:
3044 return "DW_OP_GNU_push_tls_address";
3046 return "OP_<unknown>";
3050 /* Return a pointer to a newly allocated location description. Location
3051 descriptions are simple expression terms that can be strung
3052 together to form more complicated location (address) descriptions. */
3054 static inline dw_loc_descr_ref
3055 new_loc_descr (enum dwarf_location_atom op, unsigned HOST_WIDE_INT oprnd1,
3056 unsigned HOST_WIDE_INT oprnd2)
3058 dw_loc_descr_ref descr = ggc_alloc_cleared (sizeof (dw_loc_descr_node));
3060 descr->dw_loc_opc = op;
3061 descr->dw_loc_oprnd1.val_class = dw_val_class_unsigned_const;
3062 descr->dw_loc_oprnd1.v.val_unsigned = oprnd1;
3063 descr->dw_loc_oprnd2.val_class = dw_val_class_unsigned_const;
3064 descr->dw_loc_oprnd2.v.val_unsigned = oprnd2;
3069 /* Add a location description term to a location description expression. */
3072 add_loc_descr (dw_loc_descr_ref *list_head, dw_loc_descr_ref descr)
3074 dw_loc_descr_ref *d;
3076 /* Find the end of the chain. */
3077 for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
3083 /* Return the size of a location descriptor. */
3085 static unsigned long
3086 size_of_loc_descr (dw_loc_descr_ref loc)
3088 unsigned long size = 1;
3090 switch (loc->dw_loc_opc)
3093 case INTERNAL_DW_OP_tls_addr:
3094 size += DWARF2_ADDR_SIZE;
3113 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3116 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
3121 case DW_OP_plus_uconst:
3122 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3160 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
3163 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3166 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
3169 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3170 size += size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int);
3173 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
3175 case DW_OP_deref_size:
3176 case DW_OP_xderef_size:
3185 case DW_OP_call_ref:
3186 size += DWARF2_ADDR_SIZE;
3195 /* Return the size of a series of location descriptors. */
3197 static unsigned long
3198 size_of_locs (dw_loc_descr_ref loc)
3202 for (size = 0; loc != NULL; loc = loc->dw_loc_next)
3204 loc->dw_loc_addr = size;
3205 size += size_of_loc_descr (loc);
3211 /* Output location description stack opcode's operands (if any). */
3214 output_loc_operands (dw_loc_descr_ref loc)
3216 dw_val_ref val1 = &loc->dw_loc_oprnd1;
3217 dw_val_ref val2 = &loc->dw_loc_oprnd2;
3219 switch (loc->dw_loc_opc)
3221 #ifdef DWARF2_DEBUGGING_INFO
3223 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, val1->v.val_addr, NULL);
3227 dw2_asm_output_data (2, val1->v.val_int, NULL);
3231 dw2_asm_output_data (4, val1->v.val_int, NULL);
3235 gcc_assert (HOST_BITS_PER_LONG >= 64);
3236 dw2_asm_output_data (8, val1->v.val_int, NULL);
3243 gcc_assert (val1->val_class == dw_val_class_loc);
3244 offset = val1->v.val_loc->dw_loc_addr - (loc->dw_loc_addr + 3);
3246 dw2_asm_output_data (2, offset, NULL);
3259 /* We currently don't make any attempt to make sure these are
3260 aligned properly like we do for the main unwind info, so
3261 don't support emitting things larger than a byte if we're
3262 only doing unwinding. */
3267 dw2_asm_output_data (1, val1->v.val_int, NULL);
3270 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
3273 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
3276 dw2_asm_output_data (1, val1->v.val_int, NULL);
3278 case DW_OP_plus_uconst:
3279 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
3313 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
3316 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
3319 dw2_asm_output_data_sleb128 (val1->v.val_int, NULL);
3322 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
3323 dw2_asm_output_data_sleb128 (val2->v.val_int, NULL);
3326 dw2_asm_output_data_uleb128 (val1->v.val_unsigned, NULL);
3328 case DW_OP_deref_size:
3329 case DW_OP_xderef_size:
3330 dw2_asm_output_data (1, val1->v.val_int, NULL);
3333 case INTERNAL_DW_OP_tls_addr:
3334 if (targetm.asm_out.output_dwarf_dtprel)
3336 targetm.asm_out.output_dwarf_dtprel (asm_out_file,
3339 fputc ('\n', asm_out_file);
3346 /* Other codes have no operands. */
3351 /* Output a sequence of location operations. */
3354 output_loc_sequence (dw_loc_descr_ref loc)
3356 for (; loc != NULL; loc = loc->dw_loc_next)
3358 /* Output the opcode. */
3359 dw2_asm_output_data (1, loc->dw_loc_opc,
3360 "%s", dwarf_stack_op_name (loc->dw_loc_opc));
3362 /* Output the operand(s) (if any). */
3363 output_loc_operands (loc);
3367 /* This routine will generate the correct assembly data for a location
3368 description based on a cfi entry with a complex address. */
3371 output_cfa_loc (dw_cfi_ref cfi)
3373 dw_loc_descr_ref loc;
3376 /* Output the size of the block. */
3377 loc = cfi->dw_cfi_oprnd1.dw_cfi_loc;
3378 size = size_of_locs (loc);
3379 dw2_asm_output_data_uleb128 (size, NULL);
3381 /* Now output the operations themselves. */
3382 output_loc_sequence (loc);
3385 /* This function builds a dwarf location descriptor sequence from
3386 a dw_cfa_location. */
3388 static struct dw_loc_descr_struct *
3389 build_cfa_loc (dw_cfa_location *cfa)
3391 struct dw_loc_descr_struct *head, *tmp;
3395 if (cfa->base_offset)
3398 head = new_loc_descr (DW_OP_breg0 + cfa->reg, cfa->base_offset, 0);
3400 head = new_loc_descr (DW_OP_bregx, cfa->reg, cfa->base_offset);
3402 else if (cfa->reg <= 31)
3403 head = new_loc_descr (DW_OP_reg0 + cfa->reg, 0, 0);
3405 head = new_loc_descr (DW_OP_regx, cfa->reg, 0);
3407 head->dw_loc_oprnd1.val_class = dw_val_class_const;
3408 tmp = new_loc_descr (DW_OP_deref, 0, 0);
3409 add_loc_descr (&head, tmp);
3410 if (cfa->offset != 0)
3412 tmp = new_loc_descr (DW_OP_plus_uconst, cfa->offset, 0);
3413 add_loc_descr (&head, tmp);
3418 if (cfa->offset == 0)
3420 head = new_loc_descr (DW_OP_reg0 + cfa->reg, 0, 0);
3422 head = new_loc_descr (DW_OP_regx, cfa->reg, 0);
3423 else if (cfa->reg <= 31)
3424 head = new_loc_descr (DW_OP_breg0 + cfa->reg, cfa->offset, 0);
3426 head = new_loc_descr (DW_OP_bregx, cfa->reg, cfa->offset);
3432 /* This function fills in aa dw_cfa_location structure from a dwarf location
3433 descriptor sequence. */
3436 get_cfa_from_loc_descr (dw_cfa_location *cfa, struct dw_loc_descr_struct *loc)
3438 struct dw_loc_descr_struct *ptr;
3440 cfa->base_offset = 0;
3444 for (ptr = loc; ptr != NULL; ptr = ptr->dw_loc_next)
3446 enum dwarf_location_atom op = ptr->dw_loc_opc;
3482 cfa->reg = op - DW_OP_reg0;
3485 cfa->reg = ptr->dw_loc_oprnd1.v.val_int;
3519 cfa->reg = op - DW_OP_breg0;
3520 cfa->base_offset = ptr->dw_loc_oprnd1.v.val_int;
3523 cfa->reg = ptr->dw_loc_oprnd1.v.val_int;
3524 cfa->base_offset = ptr->dw_loc_oprnd2.v.val_int;
3529 case DW_OP_plus_uconst:
3530 cfa->offset = ptr->dw_loc_oprnd1.v.val_unsigned;
3533 internal_error ("DW_LOC_OP %s not implemented",
3534 dwarf_stack_op_name (ptr->dw_loc_opc));
3538 #endif /* .debug_frame support */
3540 /* And now, the support for symbolic debugging information. */
3541 #ifdef DWARF2_DEBUGGING_INFO
3543 /* .debug_str support. */
3544 static int output_indirect_string (void **, void *);
3546 static void dwarf2out_init (const char *);
3547 static void dwarf2out_finish (const char *);
3548 static void dwarf2out_define (unsigned int, const char *);
3549 static void dwarf2out_undef (unsigned int, const char *);
3550 static void dwarf2out_start_source_file (unsigned, const char *);
3551 static void dwarf2out_end_source_file (unsigned);
3552 static void dwarf2out_begin_block (unsigned, unsigned);
3553 static void dwarf2out_end_block (unsigned, unsigned);
3554 static bool dwarf2out_ignore_block (tree);
3555 static void dwarf2out_global_decl (tree);
3556 static void dwarf2out_type_decl (tree, int);
3557 static void dwarf2out_imported_module_or_decl (tree, tree);
3558 static void dwarf2out_abstract_function (tree);
3559 static void dwarf2out_var_location (rtx);
3560 static void dwarf2out_begin_function (tree);
3562 /* The debug hooks structure. */
3564 const struct gcc_debug_hooks dwarf2_debug_hooks =
3570 dwarf2out_start_source_file,
3571 dwarf2out_end_source_file,
3572 dwarf2out_begin_block,
3573 dwarf2out_end_block,
3574 dwarf2out_ignore_block,
3575 dwarf2out_source_line,
3576 dwarf2out_begin_prologue,
3577 debug_nothing_int_charstar, /* end_prologue */
3578 dwarf2out_end_epilogue,
3579 dwarf2out_begin_function,
3580 debug_nothing_int, /* end_function */
3581 dwarf2out_decl, /* function_decl */
3582 dwarf2out_global_decl,
3583 dwarf2out_type_decl, /* type_decl */
3584 dwarf2out_imported_module_or_decl,
3585 debug_nothing_tree, /* deferred_inline_function */
3586 /* The DWARF 2 backend tries to reduce debugging bloat by not
3587 emitting the abstract description of inline functions until
3588 something tries to reference them. */
3589 dwarf2out_abstract_function, /* outlining_inline_function */
3590 debug_nothing_rtx, /* label */
3591 debug_nothing_int, /* handle_pch */
3592 dwarf2out_var_location,
3593 dwarf2out_switch_text_section,
3594 1 /* start_end_main_source_file */
3598 /* NOTE: In the comments in this file, many references are made to
3599 "Debugging Information Entries". This term is abbreviated as `DIE'
3600 throughout the remainder of this file. */
3602 /* An internal representation of the DWARF output is built, and then
3603 walked to generate the DWARF debugging info. The walk of the internal
3604 representation is done after the entire program has been compiled.
3605 The types below are used to describe the internal representation. */
3607 /* Various DIE's use offsets relative to the beginning of the
3608 .debug_info section to refer to each other. */
3610 typedef long int dw_offset;
3612 /* Define typedefs here to avoid circular dependencies. */
3614 typedef struct dw_attr_struct *dw_attr_ref;
3615 typedef struct dw_line_info_struct *dw_line_info_ref;
3616 typedef struct dw_separate_line_info_struct *dw_separate_line_info_ref;
3617 typedef struct pubname_struct *pubname_ref;
3618 typedef struct dw_ranges_struct *dw_ranges_ref;
3620 /* Each entry in the line_info_table maintains the file and
3621 line number associated with the label generated for that
3622 entry. The label gives the PC value associated with
3623 the line number entry. */
3625 typedef struct dw_line_info_struct GTY(())
3627 unsigned long dw_file_num;
3628 unsigned long dw_line_num;
3632 /* Line information for functions in separate sections; each one gets its
3634 typedef struct dw_separate_line_info_struct GTY(())
3636 unsigned long dw_file_num;
3637 unsigned long dw_line_num;
3638 unsigned long function;
3640 dw_separate_line_info_entry;
3642 /* Each DIE attribute has a field specifying the attribute kind,
3643 a link to the next attribute in the chain, and an attribute value.
3644 Attributes are typically linked below the DIE they modify. */
3646 typedef struct dw_attr_struct GTY(())
3648 enum dwarf_attribute dw_attr;
3649 dw_attr_ref dw_attr_next;
3650 dw_val_node dw_attr_val;
3654 /* The Debugging Information Entry (DIE) structure */
3656 typedef struct die_struct GTY(())
3658 enum dwarf_tag die_tag;
3660 dw_attr_ref die_attr;
3661 dw_die_ref die_parent;
3662 dw_die_ref die_child;
3664 dw_die_ref die_definition; /* ref from a specification to its definition */
3665 dw_offset die_offset;
3666 unsigned long die_abbrev;
3668 unsigned int decl_id;
3672 /* The pubname structure */
3674 typedef struct pubname_struct GTY(())
3681 struct dw_ranges_struct GTY(())
3686 /* The limbo die list structure. */
3687 typedef struct limbo_die_struct GTY(())
3691 struct limbo_die_struct *next;
3695 /* How to start an assembler comment. */
3696 #ifndef ASM_COMMENT_START
3697 #define ASM_COMMENT_START ";#"
3700 /* Define a macro which returns nonzero for a TYPE_DECL which was
3701 implicitly generated for a tagged type.
3703 Note that unlike the gcc front end (which generates a NULL named
3704 TYPE_DECL node for each complete tagged type, each array type, and
3705 each function type node created) the g++ front end generates a
3706 _named_ TYPE_DECL node for each tagged type node created.
3707 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
3708 generate a DW_TAG_typedef DIE for them. */
3710 #define TYPE_DECL_IS_STUB(decl) \
3711 (DECL_NAME (decl) == NULL_TREE \
3712 || (DECL_ARTIFICIAL (decl) \
3713 && is_tagged_type (TREE_TYPE (decl)) \
3714 && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \
3715 /* This is necessary for stub decls that \
3716 appear in nested inline functions. */ \
3717 || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
3718 && (decl_ultimate_origin (decl) \
3719 == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
3721 /* Information concerning the compilation unit's programming
3722 language, and compiler version. */
3724 /* Fixed size portion of the DWARF compilation unit header. */
3725 #define DWARF_COMPILE_UNIT_HEADER_SIZE \
3726 (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 3)
3728 /* Fixed size portion of public names info. */
3729 #define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
3731 /* Fixed size portion of the address range info. */
3732 #define DWARF_ARANGES_HEADER_SIZE \
3733 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
3734 DWARF2_ADDR_SIZE * 2) \
3735 - DWARF_INITIAL_LENGTH_SIZE)
3737 /* Size of padding portion in the address range info. It must be
3738 aligned to twice the pointer size. */
3739 #define DWARF_ARANGES_PAD_SIZE \
3740 (DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
3741 DWARF2_ADDR_SIZE * 2) \
3742 - (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4))
3744 /* Use assembler line directives if available. */
3745 #ifndef DWARF2_ASM_LINE_DEBUG_INFO
3746 #ifdef HAVE_AS_DWARF2_DEBUG_LINE
3747 #define DWARF2_ASM_LINE_DEBUG_INFO 1
3749 #define DWARF2_ASM_LINE_DEBUG_INFO 0
3753 /* Minimum line offset in a special line info. opcode.
3754 This value was chosen to give a reasonable range of values. */
3755 #define DWARF_LINE_BASE -10
3757 /* First special line opcode - leave room for the standard opcodes. */
3758 #define DWARF_LINE_OPCODE_BASE 10
3760 /* Range of line offsets in a special line info. opcode. */
3761 #define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1)
3763 /* Flag that indicates the initial value of the is_stmt_start flag.
3764 In the present implementation, we do not mark any lines as
3765 the beginning of a source statement, because that information
3766 is not made available by the GCC front-end. */
3767 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
3769 #ifdef DWARF2_DEBUGGING_INFO
3770 /* This location is used by calc_die_sizes() to keep track
3771 the offset of each DIE within the .debug_info section. */
3772 static unsigned long next_die_offset;
3775 /* Record the root of the DIE's built for the current compilation unit. */
3776 static GTY(()) dw_die_ref comp_unit_die;
3778 /* A list of DIEs with a NULL parent waiting to be relocated. */
3779 static GTY(()) limbo_die_node *limbo_die_list;
3781 /* Filenames referenced by this compilation unit. */
3782 static GTY(()) varray_type file_table;
3783 static GTY(()) varray_type file_table_emitted;
3784 static GTY(()) size_t file_table_last_lookup_index;
3786 /* A hash table of references to DIE's that describe declarations.
3787 The key is a DECL_UID() which is a unique number identifying each decl. */
3788 static GTY ((param_is (struct die_struct))) htab_t decl_die_table;
3790 /* Node of the variable location list. */
3791 struct var_loc_node GTY ((chain_next ("%h.next")))
3793 rtx GTY (()) var_loc_note;
3794 const char * GTY (()) label;
3795 const char * GTY (()) section_label;
3796 struct var_loc_node * GTY (()) next;
3799 /* Variable location list. */
3800 struct var_loc_list_def GTY (())
3802 struct var_loc_node * GTY (()) first;
3804 /* Do not mark the last element of the chained list because
3805 it is marked through the chain. */
3806 struct var_loc_node * GTY ((skip ("%h"))) last;
3808 /* DECL_UID of the variable decl. */
3809 unsigned int decl_id;
3811 typedef struct var_loc_list_def var_loc_list;
3814 /* Table of decl location linked lists. */
3815 static GTY ((param_is (var_loc_list))) htab_t decl_loc_table;
3817 /* A pointer to the base of a list of references to DIE's that
3818 are uniquely identified by their tag, presence/absence of
3819 children DIE's, and list of attribute/value pairs. */
3820 static GTY((length ("abbrev_die_table_allocated")))
3821 dw_die_ref *abbrev_die_table;
3823 /* Number of elements currently allocated for abbrev_die_table. */
3824 static GTY(()) unsigned abbrev_die_table_allocated;
3826 /* Number of elements in type_die_table currently in use. */
3827 static GTY(()) unsigned abbrev_die_table_in_use;
3829 /* Size (in elements) of increments by which we may expand the
3830 abbrev_die_table. */
3831 #define ABBREV_DIE_TABLE_INCREMENT 256
3833 /* A pointer to the base of a table that contains line information
3834 for each source code line in .text in the compilation unit. */
3835 static GTY((length ("line_info_table_allocated")))
3836 dw_line_info_ref line_info_table;
3838 /* Number of elements currently allocated for line_info_table. */
3839 static GTY(()) unsigned line_info_table_allocated;
3841 /* Number of elements in line_info_table currently in use. */
3842 static GTY(()) unsigned line_info_table_in_use;
3844 /* True if the compilation unit contains more than one .text section. */
3845 static GTY(()) bool have_switched_text_section = false;
3847 /* A pointer to the base of a table that contains line information
3848 for each source code line outside of .text in the compilation unit. */
3849 static GTY ((length ("separate_line_info_table_allocated")))
3850 dw_separate_line_info_ref separate_line_info_table;
3852 /* Number of elements currently allocated for separate_line_info_table. */
3853 static GTY(()) unsigned separate_line_info_table_allocated;
3855 /* Number of elements in separate_line_info_table currently in use. */
3856 static GTY(()) unsigned separate_line_info_table_in_use;
3858 /* Size (in elements) of increments by which we may expand the
3860 #define LINE_INFO_TABLE_INCREMENT 1024
3862 /* A pointer to the base of a table that contains a list of publicly
3863 accessible names. */
3864 static GTY ((length ("pubname_table_allocated"))) pubname_ref pubname_table;
3866 /* Number of elements currently allocated for pubname_table. */
3867 static GTY(()) unsigned pubname_table_allocated;
3869 /* Number of elements in pubname_table currently in use. */
3870 static GTY(()) unsigned pubname_table_in_use;
3872 /* Size (in elements) of increments by which we may expand the
3874 #define PUBNAME_TABLE_INCREMENT 64
3876 /* Array of dies for which we should generate .debug_arange info. */
3877 static GTY((length ("arange_table_allocated"))) dw_die_ref *arange_table;
3879 /* Number of elements currently allocated for arange_table. */
3880 static GTY(()) unsigned arange_table_allocated;
3882 /* Number of elements in arange_table currently in use. */
3883 static GTY(()) unsigned arange_table_in_use;
3885 /* Size (in elements) of increments by which we may expand the
3887 #define ARANGE_TABLE_INCREMENT 64
3889 /* Array of dies for which we should generate .debug_ranges info. */
3890 static GTY ((length ("ranges_table_allocated"))) dw_ranges_ref ranges_table;
3892 /* Number of elements currently allocated for ranges_table. */
3893 static GTY(()) unsigned ranges_table_allocated;
3895 /* Number of elements in ranges_table currently in use. */
3896 static GTY(()) unsigned ranges_table_in_use;
3898 /* Size (in elements) of increments by which we may expand the
3900 #define RANGES_TABLE_INCREMENT 64
3902 /* Whether we have location lists that need outputting */
3903 static GTY(()) unsigned have_location_lists;
3905 /* Unique label counter. */
3906 static GTY(()) unsigned int loclabel_num;
3908 #ifdef DWARF2_DEBUGGING_INFO
3909 /* Record whether the function being analyzed contains inlined functions. */
3910 static int current_function_has_inlines;
3912 #if 0 && defined (MIPS_DEBUGGING_INFO)
3913 static int comp_unit_has_inlines;
3916 /* Number of file tables emitted in maybe_emit_file(). */
3917 static GTY(()) int emitcount = 0;
3919 /* Number of internal labels generated by gen_internal_sym(). */
3920 static GTY(()) int label_num;
3922 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
3924 dwarf2out_switch_text_section (void)
3930 fde = &fde_table[fde_table_in_use - 1];
3931 fde->dw_fde_switched_sections = true;
3932 fde->dw_fde_hot_section_label = cfun->hot_section_label;
3933 fde->dw_fde_hot_section_end_label = cfun->hot_section_end_label;
3934 fde->dw_fde_unlikely_section_label = cfun->cold_section_label;
3935 fde->dw_fde_unlikely_section_end_label = cfun->cold_section_end_label;
3936 have_switched_text_section = true;
3941 #ifdef DWARF2_DEBUGGING_INFO
3943 /* Offset from the "steady-state frame pointer" to the CFA,
3944 within the current function. */
3945 static HOST_WIDE_INT frame_pointer_cfa_offset;
3947 /* Forward declarations for functions defined in this file. */
3949 static int is_pseudo_reg (rtx);
3950 static tree type_main_variant (tree);
3951 static int is_tagged_type (tree);
3952 static const char *dwarf_tag_name (unsigned);
3953 static const char *dwarf_attr_name (unsigned);
3954 static const char *dwarf_form_name (unsigned);
3955 static tree decl_ultimate_origin (tree);
3956 static tree block_ultimate_origin (tree);
3957 static tree decl_class_context (tree);
3958 static void add_dwarf_attr (dw_die_ref, dw_attr_ref);
3959 static inline enum dw_val_class AT_class (dw_attr_ref);
3960 static void add_AT_flag (dw_die_ref, enum dwarf_attribute, unsigned);
3961 static inline unsigned AT_flag (dw_attr_ref);
3962 static void add_AT_int (dw_die_ref, enum dwarf_attribute, HOST_WIDE_INT);
3963 static inline HOST_WIDE_INT AT_int (dw_attr_ref);
3964 static void add_AT_unsigned (dw_die_ref, enum dwarf_attribute, unsigned HOST_WIDE_INT);
3965 static inline unsigned HOST_WIDE_INT AT_unsigned (dw_attr_ref);
3966 static void add_AT_long_long (dw_die_ref, enum dwarf_attribute, unsigned long,
3968 static inline void add_AT_vec (dw_die_ref, enum dwarf_attribute, unsigned int,
3969 unsigned int, unsigned char *);
3970 static hashval_t debug_str_do_hash (const void *);
3971 static int debug_str_eq (const void *, const void *);
3972 static void add_AT_string (dw_die_ref, enum dwarf_attribute, const char *);
3973 static inline const char *AT_string (dw_attr_ref);
3974 static int AT_string_form (dw_attr_ref);
3975 static void add_AT_die_ref (dw_die_ref, enum dwarf_attribute, dw_die_ref);
3976 static void add_AT_specification (dw_die_ref, dw_die_ref);
3977 static inline dw_die_ref AT_ref (dw_attr_ref);
3978 static inline int AT_ref_external (dw_attr_ref);
3979 static inline void set_AT_ref_external (dw_attr_ref, int);
3980 static void add_AT_fde_ref (dw_die_ref, enum dwarf_attribute, unsigned);
3981 static void add_AT_loc (dw_die_ref, enum dwarf_attribute, dw_loc_descr_ref);
3982 static inline dw_loc_descr_ref AT_loc (dw_attr_ref);
3983 static void add_AT_loc_list (dw_die_ref, enum dwarf_attribute,
3985 static inline dw_loc_list_ref AT_loc_list (dw_attr_ref);
3986 static void add_AT_addr (dw_die_ref, enum dwarf_attribute, rtx);
3987 static inline rtx AT_addr (dw_attr_ref);
3988 static void add_AT_lbl_id (dw_die_ref, enum dwarf_attribute, const char *);
3989 static void add_AT_lbl_offset (dw_die_ref, enum dwarf_attribute, const char *);
3990 static void add_AT_offset (dw_die_ref, enum dwarf_attribute,
3991 unsigned HOST_WIDE_INT);
3992 static void add_AT_range_list (dw_die_ref, enum dwarf_attribute,
3994 static inline const char *AT_lbl (dw_attr_ref);
3995 static dw_attr_ref get_AT (dw_die_ref, enum dwarf_attribute);
3996 static const char *get_AT_low_pc (dw_die_ref);
3997 static const char *get_AT_hi_pc (dw_die_ref);
3998 static const char *get_AT_string (dw_die_ref, enum dwarf_attribute);
3999 static int get_AT_flag (dw_die_ref, enum dwarf_attribute);
4000 static unsigned get_AT_unsigned (dw_die_ref, enum dwarf_attribute);
4001 static inline dw_die_ref get_AT_ref (dw_die_ref, enum dwarf_attribute);
4002 static bool is_c_family (void);
4003 static bool is_cxx (void);
4004 static bool is_java (void);
4005 static bool is_fortran (void);
4006 static bool is_ada (void);
4007 static void remove_AT (dw_die_ref, enum dwarf_attribute);
4008 static void remove_child_TAG (dw_die_ref, enum dwarf_tag);
4009 static inline void free_die (dw_die_ref);
4010 static void remove_children (dw_die_ref);
4011 static void add_child_die (dw_die_ref, dw_die_ref);
4012 static dw_die_ref new_die (enum dwarf_tag, dw_die_ref, tree);
4013 static dw_die_ref lookup_type_die (tree);
4014 static void equate_type_number_to_die (tree, dw_die_ref);
4015 static hashval_t decl_die_table_hash (const void *);
4016 static int decl_die_table_eq (const void *, const void *);
4017 static dw_die_ref lookup_decl_die (tree);
4018 static hashval_t decl_loc_table_hash (const void *);
4019 static int decl_loc_table_eq (const void *, const void *);
4020 static var_loc_list *lookup_decl_loc (tree);
4021 static void equate_decl_number_to_die (tree, dw_die_ref);
4022 static void add_var_loc_to_decl (tree, struct var_loc_node *);
4023 static void print_spaces (FILE *);
4024 static void print_die (dw_die_ref, FILE *);
4025 static void print_dwarf_line_table (FILE *);
4026 static void reverse_die_lists (dw_die_ref);
4027 static void reverse_all_dies (dw_die_ref);
4028 static dw_die_ref push_new_compile_unit (dw_die_ref, dw_die_ref);
4029 static dw_die_ref pop_compile_unit (dw_die_ref);
4030 static void loc_checksum (dw_loc_descr_ref, struct md5_ctx *);
4031 static void attr_checksum (dw_attr_ref, struct md5_ctx *, int *);
4032 static void die_checksum (dw_die_ref, struct md5_ctx *, int *);
4033 static int same_loc_p (dw_loc_descr_ref, dw_loc_descr_ref, int *);
4034 static int same_dw_val_p (dw_val_node *, dw_val_node *, int *);
4035 static int same_attr_p (dw_attr_ref, dw_attr_ref, int *);
4036 static int same_die_p (dw_die_ref, dw_die_ref, int *);
4037 static int same_die_p_wrap (dw_die_ref, dw_die_ref);
4038 static void compute_section_prefix (dw_die_ref);
4039 static int is_type_die (dw_die_ref);
4040 static int is_comdat_die (dw_die_ref);
4041 static int is_symbol_die (dw_die_ref);
4042 static void assign_symbol_names (dw_die_ref);
4043 static void break_out_includes (dw_die_ref);
4044 static hashval_t htab_cu_hash (const void *);
4045 static int htab_cu_eq (const void *, const void *);
4046 static void htab_cu_del (void *);
4047 static int check_duplicate_cu (dw_die_ref, htab_t, unsigned *);
4048 static void record_comdat_symbol_number (dw_die_ref, htab_t, unsigned);
4049 static void add_sibling_attributes (dw_die_ref);
4050 static void build_abbrev_table (dw_die_ref);
4051 static void output_location_lists (dw_die_ref);
4052 static int constant_size (long unsigned);
4053 static unsigned long size_of_die (dw_die_ref);
4054 static void calc_die_sizes (dw_die_ref);
4055 static void mark_dies (dw_die_ref);
4056 static void unmark_dies (dw_die_ref);
4057 static void unmark_all_dies (dw_die_ref);
4058 static unsigned long size_of_pubnames (void);
4059 static unsigned long size_of_aranges (void);
4060 static enum dwarf_form value_format (dw_attr_ref);
4061 static void output_value_format (dw_attr_ref);
4062 static void output_abbrev_section (void);
4063 static void output_die_symbol (dw_die_ref);
4064 static void output_die (dw_die_ref);
4065 static void output_compilation_unit_header (void);
4066 static void output_comp_unit (dw_die_ref, int);
4067 static const char *dwarf2_name (tree, int);
4068 static void add_pubname (tree, dw_die_ref);
4069 static void output_pubnames (void);
4070 static void add_arange (tree, dw_die_ref);
4071 static void output_aranges (void);
4072 static unsigned int add_ranges (tree);
4073 static void output_ranges (void);
4074 static void output_line_info (void);
4075 static void output_file_names (void);
4076 static dw_die_ref base_type_die (tree);
4077 static tree root_type (tree);
4078 static int is_base_type (tree);
4079 static bool is_subrange_type (tree);
4080 static dw_die_ref subrange_type_die (tree, dw_die_ref);
4081 static dw_die_ref modified_type_die (tree, int, int, dw_die_ref);
4082 static int type_is_enum (tree);
4083 static unsigned int dbx_reg_number (rtx);
4084 static void add_loc_descr_op_piece (dw_loc_descr_ref *, int);
4085 static dw_loc_descr_ref reg_loc_descriptor (rtx);
4086 static dw_loc_descr_ref one_reg_loc_descriptor (unsigned int);
4087 static dw_loc_descr_ref multiple_reg_loc_descriptor (rtx, rtx);
4088 static dw_loc_descr_ref int_loc_descriptor (HOST_WIDE_INT);
4089 static dw_loc_descr_ref based_loc_descr (rtx, HOST_WIDE_INT);
4090 static int is_based_loc (rtx);
4091 static dw_loc_descr_ref mem_loc_descriptor (rtx, enum machine_mode mode);
4092 static dw_loc_descr_ref concat_loc_descriptor (rtx, rtx);
4093 static dw_loc_descr_ref loc_descriptor (rtx);
4094 static dw_loc_descr_ref loc_descriptor_from_tree_1 (tree, int);
4095 static dw_loc_descr_ref loc_descriptor_from_tree (tree);
4096 static HOST_WIDE_INT ceiling (HOST_WIDE_INT, unsigned int);
4097 static tree field_type (tree);
4098 static unsigned int simple_type_align_in_bits (tree);
4099 static unsigned int simple_decl_align_in_bits (tree);
4100 static unsigned HOST_WIDE_INT simple_type_size_in_bits (tree);
4101 static HOST_WIDE_INT field_byte_offset (tree);
4102 static void add_AT_location_description (dw_die_ref, enum dwarf_attribute,
4104 static void add_data_member_location_attribute (dw_die_ref, tree);
4105 static void add_const_value_attribute (dw_die_ref, rtx);
4106 static void insert_int (HOST_WIDE_INT, unsigned, unsigned char *);
4107 static HOST_WIDE_INT extract_int (const unsigned char *, unsigned);
4108 static void insert_float (rtx, unsigned char *);
4109 static rtx rtl_for_decl_location (tree);
4110 static void add_location_or_const_value_attribute (dw_die_ref, tree,
4111 enum dwarf_attribute);
4112 static void tree_add_const_value_attribute (dw_die_ref, tree);
4113 static void add_name_attribute (dw_die_ref, const char *);
4114 static void add_comp_dir_attribute (dw_die_ref);
4115 static void add_bound_info (dw_die_ref, enum dwarf_attribute, tree);
4116 static void add_subscript_info (dw_die_ref, tree);
4117 static void add_byte_size_attribute (dw_die_ref, tree);
4118 static void add_bit_offset_attribute (dw_die_ref, tree);
4119 static void add_bit_size_attribute (dw_die_ref, tree);
4120 static void add_prototyped_attribute (dw_die_ref, tree);
4121 static void add_abstract_origin_attribute (dw_die_ref, tree);
4122 static void add_pure_or_virtual_attribute (dw_die_ref, tree);
4123 static void add_src_coords_attributes (dw_die_ref, tree);
4124 static void add_name_and_src_coords_attributes (dw_die_ref, tree);
4125 static void push_decl_scope (tree);
4126 static void pop_decl_scope (void);
4127 static dw_die_ref scope_die_for (tree, dw_die_ref);
4128 static inline int local_scope_p (dw_die_ref);
4129 static inline int class_or_namespace_scope_p (dw_die_ref);
4130 static void add_type_attribute (dw_die_ref, tree, int, int, dw_die_ref);
4131 static void add_calling_convention_attribute (dw_die_ref, tree);
4132 static const char *type_tag (tree);
4133 static tree member_declared_type (tree);
4135 static const char *decl_start_label (tree);
4137 static void gen_array_type_die (tree, dw_die_ref);
4139 static void gen_entry_point_die (tree, dw_die_ref);
4141 static void gen_inlined_enumeration_type_die (tree, dw_die_ref);
4142 static void gen_inlined_structure_type_die (tree, dw_die_ref);
4143 static void gen_inlined_union_type_die (tree, dw_die_ref);
4144 static dw_die_ref gen_enumeration_type_die (tree, dw_die_ref);
4145 static dw_die_ref gen_formal_parameter_die (tree, dw_die_ref);
4146 static void gen_unspecified_parameters_die (tree, dw_die_ref);
4147 static void gen_formal_types_die (tree, dw_die_ref);
4148 static void gen_subprogram_die (tree, dw_die_ref);
4149 static void gen_variable_die (tree, dw_die_ref);
4150 static void gen_label_die (tree, dw_die_ref);
4151 static void gen_lexical_block_die (tree, dw_die_ref, int);
4152 static void gen_inlined_subroutine_die (tree, dw_die_ref, int);
4153 static void gen_field_die (tree, dw_die_ref);
4154 static void gen_ptr_to_mbr_type_die (tree, dw_die_ref);
4155 static dw_die_ref gen_compile_unit_die (const char *);
4156 static void gen_string_type_die (tree, dw_die_ref);
4157 static void gen_inheritance_die (tree, tree, dw_die_ref);
4158 static void gen_member_die (tree, dw_die_ref);
4159 static void gen_struct_or_union_type_die (tree, dw_die_ref);
4160 static void gen_subroutine_type_die (tree, dw_die_ref);
4161 static void gen_typedef_die (tree, dw_die_ref);
4162 static void gen_type_die (tree, dw_die_ref);
4163 static void gen_tagged_type_instantiation_die (tree, dw_die_ref);
4164 static void gen_block_die (tree, dw_die_ref, int);
4165 static void decls_for_scope (tree, dw_die_ref, int);
4166 static int is_redundant_typedef (tree);
4167 static void gen_namespace_die (tree);
4168 static void gen_decl_die (tree, dw_die_ref);
4169 static dw_die_ref force_decl_die (tree);
4170 static dw_die_ref force_type_die (tree);
4171 static dw_die_ref setup_namespace_context (tree, dw_die_ref);
4172 static void declare_in_namespace (tree, dw_die_ref);
4173 static unsigned lookup_filename (const char *);
4174 static void init_file_table (void);
4175 static void retry_incomplete_types (void);
4176 static void gen_type_die_for_member (tree, tree, dw_die_ref);
4177 static void splice_child_die (dw_die_ref, dw_die_ref);
4178 static int file_info_cmp (const void *, const void *);
4179 static dw_loc_list_ref new_loc_list (dw_loc_descr_ref, const char *,
4180 const char *, const char *, unsigned);
4181 static void add_loc_descr_to_loc_list (dw_loc_list_ref *, dw_loc_descr_ref,
4182 const char *, const char *,
4184 static void output_loc_list (dw_loc_list_ref);
4185 static char *gen_internal_sym (const char *);
4187 static void prune_unmark_dies (dw_die_ref);
4188 static void prune_unused_types_mark (dw_die_ref, int);
4189 static void prune_unused_types_walk (dw_die_ref);
4190 static void prune_unused_types_walk_attribs (dw_die_ref);
4191 static void prune_unused_types_prune (dw_die_ref);
4192 static void prune_unused_types (void);
4193 static int maybe_emit_file (int);
4195 /* Section names used to hold DWARF debugging information. */
4196 #ifndef DEBUG_INFO_SECTION
4197 #define DEBUG_INFO_SECTION ".debug_info"
4199 #ifndef DEBUG_ABBREV_SECTION
4200 #define DEBUG_ABBREV_SECTION ".debug_abbrev"
4202 #ifndef DEBUG_ARANGES_SECTION
4203 #define DEBUG_ARANGES_SECTION ".debug_aranges"
4205 #ifndef DEBUG_MACINFO_SECTION
4206 #define DEBUG_MACINFO_SECTION ".debug_macinfo"
4208 #ifndef DEBUG_LINE_SECTION
4209 #define DEBUG_LINE_SECTION ".debug_line"
4211 #ifndef DEBUG_LOC_SECTION
4212 #define DEBUG_LOC_SECTION ".debug_loc"
4214 #ifndef DEBUG_PUBNAMES_SECTION
4215 #define DEBUG_PUBNAMES_SECTION ".debug_pubnames"
4217 #ifndef DEBUG_STR_SECTION
4218 #define DEBUG_STR_SECTION ".debug_str"
4220 #ifndef DEBUG_RANGES_SECTION
4221 #define DEBUG_RANGES_SECTION ".debug_ranges"
4224 /* Standard ELF section names for compiled code and data. */
4225 #ifndef TEXT_SECTION_NAME
4226 #define TEXT_SECTION_NAME ".text"
4229 /* Section flags for .debug_str section. */
4230 #define DEBUG_STR_SECTION_FLAGS \
4231 (HAVE_GAS_SHF_MERGE && flag_merge_constants \
4232 ? SECTION_DEBUG | SECTION_MERGE | SECTION_STRINGS | 1 \
4235 /* Labels we insert at beginning sections we can reference instead of
4236 the section names themselves. */
4238 #ifndef TEXT_SECTION_LABEL
4239 #define TEXT_SECTION_LABEL "Ltext"
4241 #ifndef COLD_TEXT_SECTION_LABEL
4242 #define COLD_TEXT_SECTION_LABEL "Ltext_cold"
4244 #ifndef DEBUG_LINE_SECTION_LABEL
4245 #define DEBUG_LINE_SECTION_LABEL "Ldebug_line"
4247 #ifndef DEBUG_INFO_SECTION_LABEL
4248 #define DEBUG_INFO_SECTION_LABEL "Ldebug_info"
4250 #ifndef DEBUG_ABBREV_SECTION_LABEL
4251 #define DEBUG_ABBREV_SECTION_LABEL "Ldebug_abbrev"
4253 #ifndef DEBUG_LOC_SECTION_LABEL
4254 #define DEBUG_LOC_SECTION_LABEL "Ldebug_loc"
4256 #ifndef DEBUG_RANGES_SECTION_LABEL
4257 #define DEBUG_RANGES_SECTION_LABEL "Ldebug_ranges"
4259 #ifndef DEBUG_MACINFO_SECTION_LABEL
4260 #define DEBUG_MACINFO_SECTION_LABEL "Ldebug_macinfo"
4263 /* Definitions of defaults for formats and names of various special
4264 (artificial) labels which may be generated within this file (when the -g
4265 options is used and DWARF2_DEBUGGING_INFO is in effect.
4266 If necessary, these may be overridden from within the tm.h file, but
4267 typically, overriding these defaults is unnecessary. */
4269 static char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
4270 static char text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4271 static char cold_text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4272 static char cold_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
4273 static char abbrev_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4274 static char debug_info_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4275 static char debug_line_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4276 static char macinfo_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4277 static char loc_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
4278 static char ranges_section_label[2 * MAX_ARTIFICIAL_LABEL_BYTES];
4280 #ifndef TEXT_END_LABEL
4281 #define TEXT_END_LABEL "Letext"
4283 #ifndef COLD_END_LABEL
4284 #define COLD_END_LABEL "Letext_cold"
4286 #ifndef BLOCK_BEGIN_LABEL
4287 #define BLOCK_BEGIN_LABEL "LBB"
4289 #ifndef BLOCK_END_LABEL
4290 #define BLOCK_END_LABEL "LBE"
4292 #ifndef LINE_CODE_LABEL
4293 #define LINE_CODE_LABEL "LM"
4295 #ifndef SEPARATE_LINE_CODE_LABEL
4296 #define SEPARATE_LINE_CODE_LABEL "LSM"
4299 /* We allow a language front-end to designate a function that is to be
4300 called to "demangle" any name before it is put into a DIE. */
4302 static const char *(*demangle_name_func) (const char *);
4305 dwarf2out_set_demangle_name_func (const char *(*func) (const char *))
4307 demangle_name_func = func;
4310 /* Test if rtl node points to a pseudo register. */
4313 is_pseudo_reg (rtx rtl)
4315 return ((REG_P (rtl) && REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
4316 || (GET_CODE (rtl) == SUBREG
4317 && REGNO (SUBREG_REG (rtl)) >= FIRST_PSEUDO_REGISTER));
4320 /* Return a reference to a type, with its const and volatile qualifiers
4324 type_main_variant (tree type)
4326 type = TYPE_MAIN_VARIANT (type);
4328 /* ??? There really should be only one main variant among any group of
4329 variants of a given type (and all of the MAIN_VARIANT values for all
4330 members of the group should point to that one type) but sometimes the C
4331 front-end messes this up for array types, so we work around that bug
4333 if (TREE_CODE (type) == ARRAY_TYPE)
4334 while (type != TYPE_MAIN_VARIANT (type))
4335 type = TYPE_MAIN_VARIANT (type);
4340 /* Return nonzero if the given type node represents a tagged type. */
4343 is_tagged_type (tree type)
4345 enum tree_code code = TREE_CODE (type);
4347 return (code == RECORD_TYPE || code == UNION_TYPE
4348 || code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE);
4351 /* Convert a DIE tag into its string name. */
4354 dwarf_tag_name (unsigned int tag)
4358 case DW_TAG_padding:
4359 return "DW_TAG_padding";
4360 case DW_TAG_array_type:
4361 return "DW_TAG_array_type";
4362 case DW_TAG_class_type:
4363 return "DW_TAG_class_type";
4364 case DW_TAG_entry_point:
4365 return "DW_TAG_entry_point";
4366 case DW_TAG_enumeration_type:
4367 return "DW_TAG_enumeration_type";
4368 case DW_TAG_formal_parameter:
4369 return "DW_TAG_formal_parameter";
4370 case DW_TAG_imported_declaration:
4371 return "DW_TAG_imported_declaration";
4373 return "DW_TAG_label";
4374 case DW_TAG_lexical_block:
4375 return "DW_TAG_lexical_block";
4377 return "DW_TAG_member";
4378 case DW_TAG_pointer_type:
4379 return "DW_TAG_pointer_type";
4380 case DW_TAG_reference_type:
4381 return "DW_TAG_reference_type";
4382 case DW_TAG_compile_unit:
4383 return "DW_TAG_compile_unit";
4384 case DW_TAG_string_type:
4385 return "DW_TAG_string_type";
4386 case DW_TAG_structure_type:
4387 return "DW_TAG_structure_type";
4388 case DW_TAG_subroutine_type:
4389 return "DW_TAG_subroutine_type";
4390 case DW_TAG_typedef:
4391 return "DW_TAG_typedef";
4392 case DW_TAG_union_type:
4393 return "DW_TAG_union_type";
4394 case DW_TAG_unspecified_parameters:
4395 return "DW_TAG_unspecified_parameters";
4396 case DW_TAG_variant:
4397 return "DW_TAG_variant";
4398 case DW_TAG_common_block:
4399 return "DW_TAG_common_block";
4400 case DW_TAG_common_inclusion:
4401 return "DW_TAG_common_inclusion";
4402 case DW_TAG_inheritance:
4403 return "DW_TAG_inheritance";
4404 case DW_TAG_inlined_subroutine:
4405 return "DW_TAG_inlined_subroutine";
4407 return "DW_TAG_module";
4408 case DW_TAG_ptr_to_member_type:
4409 return "DW_TAG_ptr_to_member_type";
4410 case DW_TAG_set_type:
4411 return "DW_TAG_set_type";
4412 case DW_TAG_subrange_type:
4413 return "DW_TAG_subrange_type";
4414 case DW_TAG_with_stmt:
4415 return "DW_TAG_with_stmt";
4416 case DW_TAG_access_declaration:
4417 return "DW_TAG_access_declaration";
4418 case DW_TAG_base_type:
4419 return "DW_TAG_base_type";
4420 case DW_TAG_catch_block:
4421 return "DW_TAG_catch_block";
4422 case DW_TAG_const_type:
4423 return "DW_TAG_const_type";
4424 case DW_TAG_constant:
4425 return "DW_TAG_constant";
4426 case DW_TAG_enumerator:
4427 return "DW_TAG_enumerator";
4428 case DW_TAG_file_type:
4429 return "DW_TAG_file_type";
4431 return "DW_TAG_friend";
4432 case DW_TAG_namelist:
4433 return "DW_TAG_namelist";
4434 case DW_TAG_namelist_item:
4435 return "DW_TAG_namelist_item";
4436 case DW_TAG_namespace:
4437 return "DW_TAG_namespace";
4438 case DW_TAG_packed_type:
4439 return "DW_TAG_packed_type";
4440 case DW_TAG_subprogram:
4441 return "DW_TAG_subprogram";
4442 case DW_TAG_template_type_param:
4443 return "DW_TAG_template_type_param";
4444 case DW_TAG_template_value_param:
4445 return "DW_TAG_template_value_param";
4446 case DW_TAG_thrown_type:
4447 return "DW_TAG_thrown_type";
4448 case DW_TAG_try_block:
4449 return "DW_TAG_try_block";
4450 case DW_TAG_variant_part:
4451 return "DW_TAG_variant_part";
4452 case DW_TAG_variable:
4453 return "DW_TAG_variable";
4454 case DW_TAG_volatile_type:
4455 return "DW_TAG_volatile_type";
4456 case DW_TAG_imported_module:
4457 return "DW_TAG_imported_module";
4458 case DW_TAG_MIPS_loop:
4459 return "DW_TAG_MIPS_loop";
4460 case DW_TAG_format_label:
4461 return "DW_TAG_format_label";
4462 case DW_TAG_function_template:
4463 return "DW_TAG_function_template";
4464 case DW_TAG_class_template:
4465 return "DW_TAG_class_template";
4466 case DW_TAG_GNU_BINCL:
4467 return "DW_TAG_GNU_BINCL";
4468 case DW_TAG_GNU_EINCL:
4469 return "DW_TAG_GNU_EINCL";
4471 return "DW_TAG_<unknown>";
4475 /* Convert a DWARF attribute code into its string name. */
4478 dwarf_attr_name (unsigned int attr)
4483 return "DW_AT_sibling";
4484 case DW_AT_location:
4485 return "DW_AT_location";
4487 return "DW_AT_name";
4488 case DW_AT_ordering:
4489 return "DW_AT_ordering";
4490 case DW_AT_subscr_data:
4491 return "DW_AT_subscr_data";
4492 case DW_AT_byte_size:
4493 return "DW_AT_byte_size";
4494 case DW_AT_bit_offset:
4495 return "DW_AT_bit_offset";
4496 case DW_AT_bit_size:
4497 return "DW_AT_bit_size";
4498 case DW_AT_element_list:
4499 return "DW_AT_element_list";
4500 case DW_AT_stmt_list:
4501 return "DW_AT_stmt_list";
4503 return "DW_AT_low_pc";
4505 return "DW_AT_high_pc";
4506 case DW_AT_language:
4507 return "DW_AT_language";
4509 return "DW_AT_member";
4511 return "DW_AT_discr";
4512 case DW_AT_discr_value:
4513 return "DW_AT_discr_value";
4514 case DW_AT_visibility:
4515 return "DW_AT_visibility";
4517 return "DW_AT_import";
4518 case DW_AT_string_length:
4519 return "DW_AT_string_length";
4520 case DW_AT_common_reference:
4521 return "DW_AT_common_reference";
4522 case DW_AT_comp_dir:
4523 return "DW_AT_comp_dir";
4524 case DW_AT_const_value:
4525 return "DW_AT_const_value";
4526 case DW_AT_containing_type:
4527 return "DW_AT_containing_type";
4528 case DW_AT_default_value:
4529 return "DW_AT_default_value";
4531 return "DW_AT_inline";
4532 case DW_AT_is_optional:
4533 return "DW_AT_is_optional";
4534 case DW_AT_lower_bound:
4535 return "DW_AT_lower_bound";
4536 case DW_AT_producer:
4537 return "DW_AT_producer";
4538 case DW_AT_prototyped:
4539 return "DW_AT_prototyped";
4540 case DW_AT_return_addr:
4541 return "DW_AT_return_addr";
4542 case DW_AT_start_scope:
4543 return "DW_AT_start_scope";
4544 case DW_AT_stride_size:
4545 return "DW_AT_stride_size";
4546 case DW_AT_upper_bound:
4547 return "DW_AT_upper_bound";
4548 case DW_AT_abstract_origin:
4549 return "DW_AT_abstract_origin";
4550 case DW_AT_accessibility:
4551 return "DW_AT_accessibility";
4552 case DW_AT_address_class:
4553 return "DW_AT_address_class";
4554 case DW_AT_artificial:
4555 return "DW_AT_artificial";
4556 case DW_AT_base_types:
4557 return "DW_AT_base_types";
4558 case DW_AT_calling_convention:
4559 return "DW_AT_calling_convention";
4561 return "DW_AT_count";
4562 case DW_AT_data_member_location:
4563 return "DW_AT_data_member_location";
4564 case DW_AT_decl_column:
4565 return "DW_AT_decl_column";
4566 case DW_AT_decl_file:
4567 return "DW_AT_decl_file";
4568 case DW_AT_decl_line:
4569 return "DW_AT_decl_line";
4570 case DW_AT_declaration:
4571 return "DW_AT_declaration";
4572 case DW_AT_discr_list:
4573 return "DW_AT_discr_list";
4574 case DW_AT_encoding:
4575 return "DW_AT_encoding";
4576 case DW_AT_external:
4577 return "DW_AT_external";
4578 case DW_AT_frame_base:
4579 return "DW_AT_frame_base";
4581 return "DW_AT_friend";
4582 case DW_AT_identifier_case:
4583 return "DW_AT_identifier_case";
4584 case DW_AT_macro_info:
4585 return "DW_AT_macro_info";
4586 case DW_AT_namelist_items:
4587 return "DW_AT_namelist_items";
4588 case DW_AT_priority:
4589 return "DW_AT_priority";
4591 return "DW_AT_segment";
4592 case DW_AT_specification:
4593 return "DW_AT_specification";
4594 case DW_AT_static_link:
4595 return "DW_AT_static_link";
4597 return "DW_AT_type";
4598 case DW_AT_use_location:
4599 return "DW_AT_use_location";
4600 case DW_AT_variable_parameter:
4601 return "DW_AT_variable_parameter";
4602 case DW_AT_virtuality:
4603 return "DW_AT_virtuality";
4604 case DW_AT_vtable_elem_location:
4605 return "DW_AT_vtable_elem_location";
4607 case DW_AT_allocated:
4608 return "DW_AT_allocated";
4609 case DW_AT_associated:
4610 return "DW_AT_associated";
4611 case DW_AT_data_location:
4612 return "DW_AT_data_location";
4614 return "DW_AT_stride";
4615 case DW_AT_entry_pc:
4616 return "DW_AT_entry_pc";
4617 case DW_AT_use_UTF8:
4618 return "DW_AT_use_UTF8";
4619 case DW_AT_extension:
4620 return "DW_AT_extension";
4622 return "DW_AT_ranges";
4623 case DW_AT_trampoline:
4624 return "DW_AT_trampoline";
4625 case DW_AT_call_column:
4626 return "DW_AT_call_column";
4627 case DW_AT_call_file:
4628 return "DW_AT_call_file";
4629 case DW_AT_call_line:
4630 return "DW_AT_call_line";
4632 case DW_AT_MIPS_fde:
4633 return "DW_AT_MIPS_fde";
4634 case DW_AT_MIPS_loop_begin:
4635 return "DW_AT_MIPS_loop_begin";
4636 case DW_AT_MIPS_tail_loop_begin:
4637 return "DW_AT_MIPS_tail_loop_begin";
4638 case DW_AT_MIPS_epilog_begin:
4639 return "DW_AT_MIPS_epilog_begin";
4640 case DW_AT_MIPS_loop_unroll_factor:
4641 return "DW_AT_MIPS_loop_unroll_factor";
4642 case DW_AT_MIPS_software_pipeline_depth:
4643 return "DW_AT_MIPS_software_pipeline_depth";
4644 case DW_AT_MIPS_linkage_name:
4645 return "DW_AT_MIPS_linkage_name";
4646 case DW_AT_MIPS_stride:
4647 return "DW_AT_MIPS_stride";
4648 case DW_AT_MIPS_abstract_name:
4649 return "DW_AT_MIPS_abstract_name";
4650 case DW_AT_MIPS_clone_origin:
4651 return "DW_AT_MIPS_clone_origin";
4652 case DW_AT_MIPS_has_inlines:
4653 return "DW_AT_MIPS_has_inlines";
4655 case DW_AT_sf_names:
4656 return "DW_AT_sf_names";
4657 case DW_AT_src_info:
4658 return "DW_AT_src_info";
4659 case DW_AT_mac_info:
4660 return "DW_AT_mac_info";
4661 case DW_AT_src_coords:
4662 return "DW_AT_src_coords";
4663 case DW_AT_body_begin:
4664 return "DW_AT_body_begin";
4665 case DW_AT_body_end:
4666 return "DW_AT_body_end";
4667 case DW_AT_GNU_vector:
4668 return "DW_AT_GNU_vector";
4670 case DW_AT_VMS_rtnbeg_pd_address:
4671 return "DW_AT_VMS_rtnbeg_pd_address";
4674 return "DW_AT_<unknown>";
4678 /* Convert a DWARF value form code into its string name. */
4681 dwarf_form_name (unsigned int form)
4686 return "DW_FORM_addr";
4687 case DW_FORM_block2:
4688 return "DW_FORM_block2";
4689 case DW_FORM_block4:
4690 return "DW_FORM_block4";
4692 return "DW_FORM_data2";
4694 return "DW_FORM_data4";
4696 return "DW_FORM_data8";
4697 case DW_FORM_string:
4698 return "DW_FORM_string";
4700 return "DW_FORM_block";
4701 case DW_FORM_block1:
4702 return "DW_FORM_block1";
4704 return "DW_FORM_data1";
4706 return "DW_FORM_flag";
4708 return "DW_FORM_sdata";
4710 return "DW_FORM_strp";
4712 return "DW_FORM_udata";
4713 case DW_FORM_ref_addr:
4714 return "DW_FORM_ref_addr";
4716 return "DW_FORM_ref1";
4718 return "DW_FORM_ref2";
4720 return "DW_FORM_ref4";
4722 return "DW_FORM_ref8";
4723 case DW_FORM_ref_udata:
4724 return "DW_FORM_ref_udata";
4725 case DW_FORM_indirect:
4726 return "DW_FORM_indirect";
4728 return "DW_FORM_<unknown>";
4732 /* Determine the "ultimate origin" of a decl. The decl may be an inlined
4733 instance of an inlined instance of a decl which is local to an inline
4734 function, so we have to trace all of the way back through the origin chain
4735 to find out what sort of node actually served as the original seed for the
4739 decl_ultimate_origin (tree decl)
4741 if (!CODE_CONTAINS_STRUCT (TREE_CODE (decl), TS_DECL_COMMON))
4744 /* output_inline_function sets DECL_ABSTRACT_ORIGIN for all the
4745 nodes in the function to point to themselves; ignore that if
4746 we're trying to output the abstract instance of this function. */
4747 if (DECL_ABSTRACT (decl) && DECL_ABSTRACT_ORIGIN (decl) == decl)
4750 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
4751 most distant ancestor, this should never happen. */
4752 gcc_assert (!DECL_FROM_INLINE (DECL_ORIGIN (decl)));
4754 return DECL_ABSTRACT_ORIGIN (decl);
4757 /* Determine the "ultimate origin" of a block. The block may be an inlined
4758 instance of an inlined instance of a block which is local to an inline
4759 function, so we have to trace all of the way back through the origin chain
4760 to find out what sort of node actually served as the original seed for the
4764 block_ultimate_origin (tree block)
4766 tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block);
4768 /* output_inline_function sets BLOCK_ABSTRACT_ORIGIN for all the
4769 nodes in the function to point to themselves; ignore that if
4770 we're trying to output the abstract instance of this function. */
4771 if (BLOCK_ABSTRACT (block) && immediate_origin == block)
4774 if (immediate_origin == NULL_TREE)
4779 tree lookahead = immediate_origin;
4783 ret_val = lookahead;
4784 lookahead = (TREE_CODE (ret_val) == BLOCK
4785 ? BLOCK_ABSTRACT_ORIGIN (ret_val) : NULL);
4787 while (lookahead != NULL && lookahead != ret_val);
4789 /* The block's abstract origin chain may not be the *ultimate* origin of
4790 the block. It could lead to a DECL that has an abstract origin set.
4791 If so, we want that DECL's abstract origin (which is what DECL_ORIGIN
4792 will give us if it has one). Note that DECL's abstract origins are
4793 supposed to be the most distant ancestor (or so decl_ultimate_origin
4794 claims), so we don't need to loop following the DECL origins. */
4795 if (DECL_P (ret_val))
4796 return DECL_ORIGIN (ret_val);
4802 /* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT
4803 of a virtual function may refer to a base class, so we check the 'this'
4807 decl_class_context (tree decl)
4809 tree context = NULL_TREE;
4811 if (TREE_CODE (decl) != FUNCTION_DECL || ! DECL_VINDEX (decl))
4812 context = DECL_CONTEXT (decl);
4814 context = TYPE_MAIN_VARIANT
4815 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
4817 if (context && !TYPE_P (context))
4818 context = NULL_TREE;
4823 /* Add an attribute/value pair to a DIE. We build the lists up in reverse
4824 addition order, and correct that in reverse_all_dies. */
4827 add_dwarf_attr (dw_die_ref die, dw_attr_ref attr)
4829 if (die != NULL && attr != NULL)
4831 attr->dw_attr_next = die->die_attr;
4832 die->die_attr = attr;
4836 static inline enum dw_val_class
4837 AT_class (dw_attr_ref a)
4839 return a->dw_attr_val.val_class;
4842 /* Add a flag value attribute to a DIE. */
4845 add_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int flag)
4847 dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
4849 attr->dw_attr_next = NULL;
4850 attr->dw_attr = attr_kind;
4851 attr->dw_attr_val.val_class = dw_val_class_flag;
4852 attr->dw_attr_val.v.val_flag = flag;
4853 add_dwarf_attr (die, attr);
4856 static inline unsigned
4857 AT_flag (dw_attr_ref a)
4859 gcc_assert (a && AT_class (a) == dw_val_class_flag);
4860 return a->dw_attr_val.v.val_flag;
4863 /* Add a signed integer attribute value to a DIE. */
4866 add_AT_int (dw_die_ref die, enum dwarf_attribute attr_kind, HOST_WIDE_INT int_val)
4868 dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
4870 attr->dw_attr_next = NULL;
4871 attr->dw_attr = attr_kind;
4872 attr->dw_attr_val.val_class = dw_val_class_const;
4873 attr->dw_attr_val.v.val_int = int_val;
4874 add_dwarf_attr (die, attr);
4877 static inline HOST_WIDE_INT
4878 AT_int (dw_attr_ref a)
4880 gcc_assert (a && AT_class (a) == dw_val_class_const);
4881 return a->dw_attr_val.v.val_int;
4884 /* Add an unsigned integer attribute value to a DIE. */
4887 add_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind,
4888 unsigned HOST_WIDE_INT unsigned_val)
4890 dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
4892 attr->dw_attr_next = NULL;
4893 attr->dw_attr = attr_kind;
4894 attr->dw_attr_val.val_class = dw_val_class_unsigned_const;
4895 attr->dw_attr_val.v.val_unsigned = unsigned_val;
4896 add_dwarf_attr (die, attr);
4899 static inline unsigned HOST_WIDE_INT
4900 AT_unsigned (dw_attr_ref a)
4902 gcc_assert (a && AT_class (a) == dw_val_class_unsigned_const);
4903 return a->dw_attr_val.v.val_unsigned;
4906 /* Add an unsigned double integer attribute value to a DIE. */
4909 add_AT_long_long (dw_die_ref die, enum dwarf_attribute attr_kind,
4910 long unsigned int val_hi, long unsigned int val_low)
4912 dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
4914 attr->dw_attr_next = NULL;
4915 attr->dw_attr = attr_kind;
4916 attr->dw_attr_val.val_class = dw_val_class_long_long;
4917 attr->dw_attr_val.v.val_long_long.hi = val_hi;
4918 attr->dw_attr_val.v.val_long_long.low = val_low;
4919 add_dwarf_attr (die, attr);
4922 /* Add a floating point attribute value to a DIE and return it. */
4925 add_AT_vec (dw_die_ref die, enum dwarf_attribute attr_kind,
4926 unsigned int length, unsigned int elt_size, unsigned char *array)
4928 dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
4930 attr->dw_attr_next = NULL;
4931 attr->dw_attr = attr_kind;
4932 attr->dw_attr_val.val_class = dw_val_class_vec;
4933 attr->dw_attr_val.v.val_vec.length = length;
4934 attr->dw_attr_val.v.val_vec.elt_size = elt_size;
4935 attr->dw_attr_val.v.val_vec.array = array;
4936 add_dwarf_attr (die, attr);
4939 /* Hash and equality functions for debug_str_hash. */
4942 debug_str_do_hash (const void *x)
4944 return htab_hash_string (((const struct indirect_string_node *)x)->str);
4948 debug_str_eq (const void *x1, const void *x2)
4950 return strcmp ((((const struct indirect_string_node *)x1)->str),
4951 (const char *)x2) == 0;
4954 /* Add a string attribute value to a DIE. */
4957 add_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind, const char *str)
4959 dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
4960 struct indirect_string_node *node;
4963 if (! debug_str_hash)
4964 debug_str_hash = htab_create_ggc (10, debug_str_do_hash,
4965 debug_str_eq, NULL);
4967 slot = htab_find_slot_with_hash (debug_str_hash, str,
4968 htab_hash_string (str), INSERT);
4970 *slot = ggc_alloc_cleared (sizeof (struct indirect_string_node));
4971 node = (struct indirect_string_node *) *slot;
4972 node->str = ggc_strdup (str);
4975 attr->dw_attr_next = NULL;
4976 attr->dw_attr = attr_kind;
4977 attr->dw_attr_val.val_class = dw_val_class_str;
4978 attr->dw_attr_val.v.val_str = node;
4979 add_dwarf_attr (die, attr);
4982 static inline const char *
4983 AT_string (dw_attr_ref a)
4985 gcc_assert (a && AT_class (a) == dw_val_class_str);
4986 return a->dw_attr_val.v.val_str->str;
4989 /* Find out whether a string should be output inline in DIE
4990 or out-of-line in .debug_str section. */
4993 AT_string_form (dw_attr_ref a)
4995 struct indirect_string_node *node;
4999 gcc_assert (a && AT_class (a) == dw_val_class_str);
5001 node = a->dw_attr_val.v.val_str;
5005 len = strlen (node->str) + 1;
5007 /* If the string is shorter or equal to the size of the reference, it is
5008 always better to put it inline. */
5009 if (len <= DWARF_OFFSET_SIZE || node->refcount == 0)
5010 return node->form = DW_FORM_string;
5012 /* If we cannot expect the linker to merge strings in .debug_str
5013 section, only put it into .debug_str if it is worth even in this
5015 if ((DEBUG_STR_SECTION_FLAGS & SECTION_MERGE) == 0
5016 && (len - DWARF_OFFSET_SIZE) * node->refcount <= len)
5017 return node->form = DW_FORM_string;
5019 ASM_GENERATE_INTERNAL_LABEL (label, "LASF", dw2_string_counter);
5020 ++dw2_string_counter;
5021 node->label = xstrdup (label);
5023 return node->form = DW_FORM_strp;
5026 /* Add a DIE reference attribute value to a DIE. */
5029 add_AT_die_ref (dw_die_ref die, enum dwarf_attribute attr_kind, dw_die_ref targ_die)
5031 dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
5033 attr->dw_attr_next = NULL;
5034 attr->dw_attr = attr_kind;
5035 attr->dw_attr_val.val_class = dw_val_class_die_ref;
5036 attr->dw_attr_val.v.val_die_ref.die = targ_die;
5037 attr->dw_attr_val.v.val_die_ref.external = 0;
5038 add_dwarf_attr (die, attr);
5041 /* Add an AT_specification attribute to a DIE, and also make the back
5042 pointer from the specification to the definition. */
5045 add_AT_specification (dw_die_ref die, dw_die_ref targ_die)
5047 add_AT_die_ref (die, DW_AT_specification, targ_die);
5048 gcc_assert (!targ_die->die_definition);
5049 targ_die->die_definition = die;
5052 static inline dw_die_ref
5053 AT_ref (dw_attr_ref a)
5055 gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
5056 return a->dw_attr_val.v.val_die_ref.die;
5060 AT_ref_external (dw_attr_ref a)
5062 if (a && AT_class (a) == dw_val_class_die_ref)
5063 return a->dw_attr_val.v.val_die_ref.external;
5069 set_AT_ref_external (dw_attr_ref a, int i)
5071 gcc_assert (a && AT_class (a) == dw_val_class_die_ref);
5072 a->dw_attr_val.v.val_die_ref.external = i;
5075 /* Add an FDE reference attribute value to a DIE. */
5078 add_AT_fde_ref (dw_die_ref die, enum dwarf_attribute attr_kind, unsigned int targ_fde)
5080 dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
5082 attr->dw_attr_next = NULL;
5083 attr->dw_attr = attr_kind;
5084 attr->dw_attr_val.val_class = dw_val_class_fde_ref;
5085 attr->dw_attr_val.v.val_fde_index = targ_fde;
5086 add_dwarf_attr (die, attr);
5089 /* Add a location description attribute value to a DIE. */
5092 add_AT_loc (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_descr_ref loc)
5094 dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
5096 attr->dw_attr_next = NULL;
5097 attr->dw_attr = attr_kind;
5098 attr->dw_attr_val.val_class = dw_val_class_loc;
5099 attr->dw_attr_val.v.val_loc = loc;
5100 add_dwarf_attr (die, attr);
5103 static inline dw_loc_descr_ref
5104 AT_loc (dw_attr_ref a)
5106 gcc_assert (a && AT_class (a) == dw_val_class_loc);
5107 return a->dw_attr_val.v.val_loc;
5111 add_AT_loc_list (dw_die_ref die, enum dwarf_attribute attr_kind, dw_loc_list_ref loc_list)
5113 dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
5115 attr->dw_attr_next = NULL;
5116 attr->dw_attr = attr_kind;
5117 attr->dw_attr_val.val_class = dw_val_class_loc_list;
5118 attr->dw_attr_val.v.val_loc_list = loc_list;
5119 add_dwarf_attr (die, attr);
5120 have_location_lists = 1;
5123 static inline dw_loc_list_ref
5124 AT_loc_list (dw_attr_ref a)
5126 gcc_assert (a && AT_class (a) == dw_val_class_loc_list);
5127 return a->dw_attr_val.v.val_loc_list;
5130 /* Add an address constant attribute value to a DIE. */
5133 add_AT_addr (dw_die_ref die, enum dwarf_attribute attr_kind, rtx addr)
5135 dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
5137 attr->dw_attr_next = NULL;
5138 attr->dw_attr = attr_kind;
5139 attr->dw_attr_val.val_class = dw_val_class_addr;
5140 attr->dw_attr_val.v.val_addr = addr;
5141 add_dwarf_attr (die, attr);
5145 AT_addr (dw_attr_ref a)
5147 gcc_assert (a && AT_class (a) == dw_val_class_addr);
5148 return a->dw_attr_val.v.val_addr;
5151 /* Add a label identifier attribute value to a DIE. */
5154 add_AT_lbl_id (dw_die_ref die, enum dwarf_attribute attr_kind, const char *lbl_id)
5156 dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
5158 attr->dw_attr_next = NULL;
5159 attr->dw_attr = attr_kind;
5160 attr->dw_attr_val.val_class = dw_val_class_lbl_id;
5161 attr->dw_attr_val.v.val_lbl_id = xstrdup (lbl_id);
5162 add_dwarf_attr (die, attr);
5165 /* Add a section offset attribute value to a DIE. */
5168 add_AT_lbl_offset (dw_die_ref die, enum dwarf_attribute attr_kind, const char *label)
5170 dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
5172 attr->dw_attr_next = NULL;
5173 attr->dw_attr = attr_kind;
5174 attr->dw_attr_val.val_class = dw_val_class_lbl_offset;
5175 attr->dw_attr_val.v.val_lbl_id = xstrdup (label);
5176 add_dwarf_attr (die, attr);
5179 /* Add an offset attribute value to a DIE. */
5182 add_AT_offset (dw_die_ref die, enum dwarf_attribute attr_kind,
5183 unsigned HOST_WIDE_INT offset)
5185 dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
5187 attr->dw_attr_next = NULL;
5188 attr->dw_attr = attr_kind;
5189 attr->dw_attr_val.val_class = dw_val_class_offset;
5190 attr->dw_attr_val.v.val_offset = offset;
5191 add_dwarf_attr (die, attr);
5194 /* Add an range_list attribute value to a DIE. */
5197 add_AT_range_list (dw_die_ref die, enum dwarf_attribute attr_kind,
5198 long unsigned int offset)
5200 dw_attr_ref attr = ggc_alloc (sizeof (dw_attr_node));
5202 attr->dw_attr_next = NULL;
5203 attr->dw_attr = attr_kind;
5204 attr->dw_attr_val.val_class = dw_val_class_range_list;
5205 attr->dw_attr_val.v.val_offset = offset;
5206 add_dwarf_attr (die, attr);
5209 static inline const char *
5210 AT_lbl (dw_attr_ref a)
5212 gcc_assert (a && (AT_class (a) == dw_val_class_lbl_id
5213 || AT_class (a) == dw_val_class_lbl_offset));
5214 return a->dw_attr_val.v.val_lbl_id;
5217 /* Get the attribute of type attr_kind. */
5220 get_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
5223 dw_die_ref spec = NULL;
5227 for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
5228 if (a->dw_attr == attr_kind)
5230 else if (a->dw_attr == DW_AT_specification
5231 || a->dw_attr == DW_AT_abstract_origin)
5235 return get_AT (spec, attr_kind);
5241 /* Return the "low pc" attribute value, typically associated with a subprogram
5242 DIE. Return null if the "low pc" attribute is either not present, or if it
5243 cannot be represented as an assembler label identifier. */
5245 static inline const char *
5246 get_AT_low_pc (dw_die_ref die)
5248 dw_attr_ref a = get_AT (die, DW_AT_low_pc);
5250 return a ? AT_lbl (a) : NULL;
5253 /* Return the "high pc" attribute value, typically associated with a subprogram
5254 DIE. Return null if the "high pc" attribute is either not present, or if it
5255 cannot be represented as an assembler label identifier. */
5257 static inline const char *
5258 get_AT_hi_pc (dw_die_ref die)
5260 dw_attr_ref a = get_AT (die, DW_AT_high_pc);
5262 return a ? AT_lbl (a) : NULL;
5265 /* Return the value of the string attribute designated by ATTR_KIND, or
5266 NULL if it is not present. */
5268 static inline const char *
5269 get_AT_string (dw_die_ref die, enum dwarf_attribute attr_kind)
5271 dw_attr_ref a = get_AT (die, attr_kind);
5273 return a ? AT_string (a) : NULL;
5276 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
5277 if it is not present. */
5280 get_AT_flag (dw_die_ref die, enum dwarf_attribute attr_kind)
5282 dw_attr_ref a = get_AT (die, attr_kind);
5284 return a ? AT_flag (a) : 0;
5287 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
5288 if it is not present. */
5290 static inline unsigned
5291 get_AT_unsigned (dw_die_ref die, enum dwarf_attribute attr_kind)
5293 dw_attr_ref a = get_AT (die, attr_kind);
5295 return a ? AT_unsigned (a) : 0;
5298 static inline dw_die_ref
5299 get_AT_ref (dw_die_ref die, enum dwarf_attribute attr_kind)
5301 dw_attr_ref a = get_AT (die, attr_kind);
5303 return a ? AT_ref (a) : NULL;
5306 /* Return TRUE if the language is C or C++. */
5311 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5313 return (lang == DW_LANG_C || lang == DW_LANG_C89
5314 || lang == DW_LANG_C_plus_plus);
5317 /* Return TRUE if the language is C++. */
5322 return (get_AT_unsigned (comp_unit_die, DW_AT_language)
5323 == DW_LANG_C_plus_plus);
5326 /* Return TRUE if the language is Fortran. */
5331 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5333 return (lang == DW_LANG_Fortran77
5334 || lang == DW_LANG_Fortran90
5335 || lang == DW_LANG_Fortran95);
5338 /* Return TRUE if the language is Java. */
5343 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5345 return lang == DW_LANG_Java;
5348 /* Return TRUE if the language is Ada. */
5353 unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
5355 return lang == DW_LANG_Ada95 || lang == DW_LANG_Ada83;
5358 /* Free up the memory used by A. */
5360 static inline void free_AT (dw_attr_ref);
5362 free_AT (dw_attr_ref a)
5364 if (AT_class (a) == dw_val_class_str)
5365 if (a->dw_attr_val.v.val_str->refcount)
5366 a->dw_attr_val.v.val_str->refcount--;
5369 /* Remove the specified attribute if present. */
5372 remove_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
5375 dw_attr_ref removed = NULL;
5379 for (p = &(die->die_attr); *p; p = &((*p)->dw_attr_next))
5380 if ((*p)->dw_attr == attr_kind)
5383 *p = (*p)->dw_attr_next;
5392 /* Remove child die whose die_tag is specified tag. */
5395 remove_child_TAG (dw_die_ref die, enum dwarf_tag tag)
5397 dw_die_ref current, prev, next;
5398 current = die->die_child;
5400 while (current != NULL)
5402 if (current->die_tag == tag)
5404 next = current->die_sib;
5406 die->die_child = next;
5408 prev->die_sib = next;
5415 current = current->die_sib;
5420 /* Free up the memory used by DIE. */
5423 free_die (dw_die_ref die)
5425 remove_children (die);
5428 /* Discard the children of this DIE. */
5431 remove_children (dw_die_ref die)
5433 dw_die_ref child_die = die->die_child;
5435 die->die_child = NULL;
5437 while (child_die != NULL)
5439 dw_die_ref tmp_die = child_die;
5442 child_die = child_die->die_sib;
5444 for (a = tmp_die->die_attr; a != NULL;)
5446 dw_attr_ref tmp_a = a;
5448 a = a->dw_attr_next;
5456 /* Add a child DIE below its parent. We build the lists up in reverse
5457 addition order, and correct that in reverse_all_dies. */
5460 add_child_die (dw_die_ref die, dw_die_ref child_die)
5462 if (die != NULL && child_die != NULL)
5464 gcc_assert (die != child_die);
5466 child_die->die_parent = die;
5467 child_die->die_sib = die->die_child;
5468 die->die_child = child_die;
5472 /* Move CHILD, which must be a child of PARENT or the DIE for which PARENT
5473 is the specification, to the front of PARENT's list of children. */
5476 splice_child_die (dw_die_ref parent, dw_die_ref child)
5480 /* We want the declaration DIE from inside the class, not the
5481 specification DIE at toplevel. */
5482 if (child->die_parent != parent)
5484 dw_die_ref tmp = get_AT_ref (child, DW_AT_specification);
5490 gcc_assert (child->die_parent == parent
5491 || (child->die_parent
5492 == get_AT_ref (parent, DW_AT_specification)));
5494 for (p = &(child->die_parent->die_child); *p; p = &((*p)->die_sib))
5497 *p = child->die_sib;
5501 child->die_parent = parent;
5502 child->die_sib = parent->die_child;
5503 parent->die_child = child;
5506 /* Return a pointer to a newly created DIE node. */
5508 static inline dw_die_ref
5509 new_die (enum dwarf_tag tag_value, dw_die_ref parent_die, tree t)
5511 dw_die_ref die = ggc_alloc_cleared (sizeof (die_node));
5513 die->die_tag = tag_value;
5515 if (parent_die != NULL)
5516 add_child_die (parent_die, die);
5519 limbo_die_node *limbo_node;
5521 limbo_node = ggc_alloc_cleared (sizeof (limbo_die_node));
5522 limbo_node->die = die;
5523 limbo_node->created_for = t;
5524 limbo_node->next = limbo_die_list;
5525 limbo_die_list = limbo_node;
5531 /* Return the DIE associated with the given type specifier. */
5533 static inline dw_die_ref
5534 lookup_type_die (tree type)
5536 return TYPE_SYMTAB_DIE (type);
5539 /* Equate a DIE to a given type specifier. */
5542 equate_type_number_to_die (tree type, dw_die_ref type_die)
5544 TYPE_SYMTAB_DIE (type) = type_die;
5547 /* Returns a hash value for X (which really is a die_struct). */
5550 decl_die_table_hash (const void *x)
5552 return (hashval_t) ((const dw_die_ref) x)->decl_id;
5555 /* Return nonzero if decl_id of die_struct X is the same as UID of decl *Y. */
5558 decl_die_table_eq (const void *x, const void *y)
5560 return (((const dw_die_ref) x)->decl_id == DECL_UID ((const tree) y));
5563 /* Return the DIE associated with a given declaration. */
5565 static inline dw_die_ref
5566 lookup_decl_die (tree decl)
5568 return htab_find_with_hash (decl_die_table, decl, DECL_UID (decl));
5571 /* Returns a hash value for X (which really is a var_loc_list). */
5574 decl_loc_table_hash (const void *x)
5576 return (hashval_t) ((const var_loc_list *) x)->decl_id;
5579 /* Return nonzero if decl_id of var_loc_list X is the same as
5583 decl_loc_table_eq (const void *x, const void *y)
5585 return (((const var_loc_list *) x)->decl_id == DECL_UID ((const tree) y));
5588 /* Return the var_loc list associated with a given declaration. */
5590 static inline var_loc_list *
5591 lookup_decl_loc (tree decl)
5593 return htab_find_with_hash (decl_loc_table, decl, DECL_UID (decl));
5596 /* Equate a DIE to a particular declaration. */
5599 equate_decl_number_to_die (tree decl, dw_die_ref decl_die)
5601 unsigned int decl_id = DECL_UID (decl);
5604 slot = htab_find_slot_with_hash (decl_die_table, decl, decl_id, INSERT);
5606 decl_die->decl_id = decl_id;
5609 /* Add a variable location node to the linked list for DECL. */
5612 add_var_loc_to_decl (tree decl, struct var_loc_node *loc)
5614 unsigned int decl_id = DECL_UID (decl);
5618 slot = htab_find_slot_with_hash (decl_loc_table, decl, decl_id, INSERT);
5621 temp = ggc_alloc_cleared (sizeof (var_loc_list));
5622 temp->decl_id = decl_id;
5630 /* If the current location is the same as the end of the list,
5631 we have nothing to do. */
5632 if (!rtx_equal_p (NOTE_VAR_LOCATION_LOC (temp->last->var_loc_note),
5633 NOTE_VAR_LOCATION_LOC (loc->var_loc_note)))
5635 /* Add LOC to the end of list and update LAST. */
5636 temp->last->next = loc;
5640 /* Do not add empty location to the beginning of the list. */
5641 else if (NOTE_VAR_LOCATION_LOC (loc->var_loc_note) != NULL_RTX)
5648 /* Keep track of the number of spaces used to indent the
5649 output of the debugging routines that print the structure of
5650 the DIE internal representation. */
5651 static int print_indent;
5653 /* Indent the line the number of spaces given by print_indent. */
5656 print_spaces (FILE *outfile)
5658 fprintf (outfile, "%*s", print_indent, "");
5661 /* Print the information associated with a given DIE, and its children.
5662 This routine is a debugging aid only. */
5665 print_die (dw_die_ref die, FILE *outfile)
5670 print_spaces (outfile);
5671 fprintf (outfile, "DIE %4lu: %s\n",
5672 die->die_offset, dwarf_tag_name (die->die_tag));
5673 print_spaces (outfile);
5674 fprintf (outfile, " abbrev id: %lu", die->die_abbrev);
5675 fprintf (outfile, " offset: %lu\n", die->die_offset);
5677 for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
5679 print_spaces (outfile);
5680 fprintf (outfile, " %s: ", dwarf_attr_name (a->dw_attr));
5682 switch (AT_class (a))
5684 case dw_val_class_addr:
5685 fprintf (outfile, "address");
5687 case dw_val_class_offset:
5688 fprintf (outfile, "offset");
5690 case dw_val_class_loc:
5691 fprintf (outfile, "location descriptor");
5693 case dw_val_class_loc_list:
5694 fprintf (outfile, "location list -> label:%s",
5695 AT_loc_list (a)->ll_symbol);
5697 case dw_val_class_range_list:
5698 fprintf (outfile, "range list");
5700 case dw_val_class_const:
5701 fprintf (outfile, HOST_WIDE_INT_PRINT_DEC, AT_int (a));
5703 case dw_val_class_unsigned_const:
5704 fprintf (outfile, HOST_WIDE_INT_PRINT_UNSIGNED, AT_unsigned (a));
5706 case dw_val_class_long_long:
5707 fprintf (outfile, "constant (%lu,%lu)",
5708 a->dw_attr_val.v.val_long_long.hi,
5709 a->dw_attr_val.v.val_long_long.low);
5711 case dw_val_class_vec:
5712 fprintf (outfile, "floating-point or vector constant");
5714 case dw_val_class_flag:
5715 fprintf (outfile, "%u", AT_flag (a));
5717 case dw_val_class_die_ref:
5718 if (AT_ref (a) != NULL)
5720 if (AT_ref (a)->die_symbol)
5721 fprintf (outfile, "die -> label: %s", AT_ref (a)->die_symbol);
5723 fprintf (outfile, "die -> %lu", AT_ref (a)->die_offset);
5726 fprintf (outfile, "die -> <null>");
5728 case dw_val_class_lbl_id:
5729 case dw_val_class_lbl_offset:
5730 fprintf (outfile, "label: %s", AT_lbl (a));
5732 case dw_val_class_str:
5733 if (AT_string (a) != NULL)
5734 fprintf (outfile, "\"%s\"", AT_string (a));
5736 fprintf (outfile, "<null>");
5742 fprintf (outfile, "\n");
5745 if (die->die_child != NULL)
5748 for (c = die->die_child; c != NULL; c = c->die_sib)
5749 print_die (c, outfile);
5753 if (print_indent == 0)
5754 fprintf (outfile, "\n");
5757 /* Print the contents of the source code line number correspondence table.
5758 This routine is a debugging aid only. */
5761 print_dwarf_line_table (FILE *outfile)
5764 dw_line_info_ref line_info;
5766 fprintf (outfile, "\n\nDWARF source line information\n");
5767 for (i = 1; i < line_info_table_in_use; i++)
5769 line_info = &line_info_table[i];
5770 fprintf (outfile, "%5d: ", i);
5771 fprintf (outfile, "%-20s",
5772 VARRAY_CHAR_PTR (file_table, line_info->dw_file_num));
5773 fprintf (outfile, "%6ld", line_info->dw_line_num);
5774 fprintf (outfile, "\n");
5777 fprintf (outfile, "\n\n");
5780 /* Print the information collected for a given DIE. */
5783 debug_dwarf_die (dw_die_ref die)
5785 print_die (die, stderr);
5788 /* Print all DWARF information collected for the compilation unit.
5789 This routine is a debugging aid only. */
5795 print_die (comp_unit_die, stderr);
5796 if (! DWARF2_ASM_LINE_DEBUG_INFO)
5797 print_dwarf_line_table (stderr);
5800 /* We build up the lists of children and attributes by pushing new ones
5801 onto the beginning of the list. Reverse the lists for DIE so that
5802 they are in order of addition. */
5805 reverse_die_lists (dw_die_ref die)
5807 dw_die_ref c, cp, cn;
5808 dw_attr_ref a, ap, an;
5810 for (a = die->die_attr, ap = 0; a; a = an)
5812 an = a->dw_attr_next;
5813 a->dw_attr_next = ap;
5819 for (c = die->die_child, cp = 0; c; c = cn)
5826 die->die_child = cp;
5829 /* reverse_die_lists only reverses the single die you pass it. Since we used to
5830 reverse all dies in add_sibling_attributes, which runs through all the dies,
5831 it would reverse all the dies. Now, however, since we don't call
5832 reverse_die_lists in add_sibling_attributes, we need a routine to
5833 recursively reverse all the dies. This is that routine. */
5836 reverse_all_dies (dw_die_ref die)
5840 reverse_die_lists (die);
5842 for (c = die->die_child; c; c = c->die_sib)
5843 reverse_all_dies (c);
5846 /* Start a new compilation unit DIE for an include file. OLD_UNIT is the CU
5847 for the enclosing include file, if any. BINCL_DIE is the DW_TAG_GNU_BINCL
5848 DIE that marks the start of the DIEs for this include file. */
5851 push_new_compile_unit (dw_die_ref old_unit, dw_die_ref bincl_die)
5853 const char *filename = get_AT_string (bincl_die, DW_AT_name);
5854 dw_die_ref new_unit = gen_compile_unit_die (filename);
5856 new_unit->die_sib = old_unit;
5860 /* Close an include-file CU and reopen the enclosing one. */
5863 pop_compile_unit (dw_die_ref old_unit)
5865 dw_die_ref new_unit = old_unit->die_sib;
5867 old_unit->die_sib = NULL;
5871 #define CHECKSUM(FOO) md5_process_bytes (&(FOO), sizeof (FOO), ctx)
5872 #define CHECKSUM_STRING(FOO) md5_process_bytes ((FOO), strlen (FOO), ctx)
5874 /* Calculate the checksum of a location expression. */
5877 loc_checksum (dw_loc_descr_ref loc, struct md5_ctx *ctx)
5879 CHECKSUM (loc->dw_loc_opc);
5880 CHECKSUM (loc->dw_loc_oprnd1);
5881 CHECKSUM (loc->dw_loc_oprnd2);
5884 /* Calculate the checksum of an attribute. */
5887 attr_checksum (dw_attr_ref at, struct md5_ctx *ctx, int *mark)
5889 dw_loc_descr_ref loc;
5892 CHECKSUM (at->dw_attr);
5894 /* We don't care about differences in file numbering. */
5895 if (at->dw_attr == DW_AT_decl_file
5896 /* Or that this was compiled with a different compiler snapshot; if
5897 the output is the same, that's what matters. */
5898 || at->dw_attr == DW_AT_producer)
5901 switch (AT_class (at))
5903 case dw_val_class_const:
5904 CHECKSUM (at->dw_attr_val.v.val_int);
5906 case dw_val_class_unsigned_const:
5907 CHECKSUM (at->dw_attr_val.v.val_unsigned);
5909 case dw_val_class_long_long:
5910 CHECKSUM (at->dw_attr_val.v.val_long_long);
5912 case dw_val_class_vec:
5913 CHECKSUM (at->dw_attr_val.v.val_vec);
5915 case dw_val_class_flag:
5916 CHECKSUM (at->dw_attr_val.v.val_flag);
5918 case dw_val_class_str:
5919 CHECKSUM_STRING (AT_string (at));
5922 case dw_val_class_addr:
5924 gcc_assert (GET_CODE (r) == SYMBOL_REF);
5925 CHECKSUM_STRING (XSTR (r, 0));
5928 case dw_val_class_offset:
5929 CHECKSUM (at->dw_attr_val.v.val_offset);
5932 case dw_val_class_loc:
5933 for (loc = AT_loc (at); loc; loc = loc->dw_loc_next)
5934 loc_checksum (loc, ctx);
5937 case dw_val_class_die_ref:
5938 die_checksum (AT_ref (at), ctx, mark);
5941 case dw_val_class_fde_ref:
5942 case dw_val_class_lbl_id:
5943 case dw_val_class_lbl_offset:
5951 /* Calculate the checksum of a DIE. */
5954 die_checksum (dw_die_ref die, struct md5_ctx *ctx, int *mark)
5959 /* To avoid infinite recursion. */
5962 CHECKSUM (die->die_mark);
5965 die->die_mark = ++(*mark);
5967 CHECKSUM (die->die_tag);
5969 for (a = die->die_attr; a; a = a->dw_attr_next)
5970 attr_checksum (a, ctx, mark);
5972 for (c = die->die_child; c; c = c->die_sib)
5973 die_checksum (c, ctx, mark);
5977 #undef CHECKSUM_STRING
5979 /* Do the location expressions look same? */
5981 same_loc_p (dw_loc_descr_ref loc1, dw_loc_descr_ref loc2, int *mark)
5983 return loc1->dw_loc_opc == loc2->dw_loc_opc
5984 && same_dw_val_p (&loc1->dw_loc_oprnd1, &loc2->dw_loc_oprnd1, mark)
5985 && same_dw_val_p (&loc1->dw_loc_oprnd2, &loc2->dw_loc_oprnd2, mark);
5988 /* Do the values look the same? */
5990 same_dw_val_p (dw_val_node *v1, dw_val_node *v2, int *mark)
5992 dw_loc_descr_ref loc1, loc2;
5995 if (v1->val_class != v2->val_class)
5998 switch (v1->val_class)
6000 case dw_val_class_const:
6001 return v1->v.val_int == v2->v.val_int;
6002 case dw_val_class_unsigned_const:
6003 return v1->v.val_unsigned == v2->v.val_unsigned;
6004 case dw_val_class_long_long:
6005 return v1->v.val_long_long.hi == v2->v.val_long_long.hi
6006 && v1->v.val_long_long.low == v2->v.val_long_long.low;
6007 case dw_val_class_vec:
6008 if (v1->v.val_vec.length != v2->v.val_vec.length
6009 || v1->v.val_vec.elt_size != v2->v.val_vec.elt_size)
6011 if (memcmp (v1->v.val_vec.array, v2->v.val_vec.array,
6012 v1->v.val_vec.length * v1->v.val_vec.elt_size))
6015 case dw_val_class_flag:
6016 return v1->v.val_flag == v2->v.val_flag;
6017 case dw_val_class_str:
6018 return !strcmp(v1->v.val_str->str, v2->v.val_str->str);
6020 case dw_val_class_addr:
6021 r1 = v1->v.val_addr;
6022 r2 = v2->v.val_addr;
6023 if (GET_CODE (r1) != GET_CODE (r2))
6025 gcc_assert (GET_CODE (r1) == SYMBOL_REF);
6026 return !strcmp (XSTR (r1, 0), XSTR (r2, 0));
6028 case dw_val_class_offset:
6029 return v1->v.val_offset == v2->v.val_offset;
6031 case dw_val_class_loc:
6032 for (loc1 = v1->v.val_loc, loc2 = v2->v.val_loc;
6034 loc1 = loc1->dw_loc_next, loc2 = loc2->dw_loc_next)
6035 if (!same_loc_p (loc1, loc2, mark))
6037 return !loc1 && !loc2;
6039 case dw_val_class_die_ref:
6040 return same_die_p (v1->v.val_die_ref.die, v2->v.val_die_ref.die, mark);
6042 case dw_val_class_fde_ref:
6043 case dw_val_class_lbl_id:
6044 case dw_val_class_lbl_offset:
6052 /* Do the attributes look the same? */
6055 same_attr_p (dw_attr_ref at1, dw_attr_ref at2, int *mark)
6057 if (at1->dw_attr != at2->dw_attr)
6060 /* We don't care about differences in file numbering. */
6061 if (at1->dw_attr == DW_AT_decl_file
6062 /* Or that this was compiled with a different compiler snapshot; if
6063 the output is the same, that's what matters. */
6064 || at1->dw_attr == DW_AT_producer)
6067 return same_dw_val_p (&at1->dw_attr_val, &at2->dw_attr_val, mark);
6070 /* Do the dies look the same? */
6073 same_die_p (dw_die_ref die1, dw_die_ref die2, int *mark)
6078 /* To avoid infinite recursion. */
6080 return die1->die_mark == die2->die_mark;
6081 die1->die_mark = die2->die_mark = ++(*mark);
6083 if (die1->die_tag != die2->die_tag)
6086 for (a1 = die1->die_attr, a2 = die2->die_attr;
6088 a1 = a1->dw_attr_next, a2 = a2->dw_attr_next)
6089 if (!same_attr_p (a1, a2, mark))
6094 for (c1 = die1->die_child, c2 = die2->die_child;
6096 c1 = c1->die_sib, c2 = c2->die_sib)
6097 if (!same_die_p (c1, c2, mark))
6105 /* Do the dies look the same? Wrapper around same_die_p. */
6108 same_die_p_wrap (dw_die_ref die1, dw_die_ref die2)
6111 int ret = same_die_p (die1, die2, &mark);
6113 unmark_all_dies (die1);
6114 unmark_all_dies (die2);
6119 /* The prefix to attach to symbols on DIEs in the current comdat debug
6121 static char *comdat_symbol_id;
6123 /* The index of the current symbol within the current comdat CU. */
6124 static unsigned int comdat_symbol_number;
6126 /* Calculate the MD5 checksum of the compilation unit DIE UNIT_DIE and its
6127 children, and set comdat_symbol_id accordingly. */
6130 compute_section_prefix (dw_die_ref unit_die)
6132 const char *die_name = get_AT_string (unit_die, DW_AT_name);
6133 const char *base = die_name ? lbasename (die_name) : "anonymous";
6134 char *name = alloca (strlen (base) + 64);
6137 unsigned char checksum[16];
6140 /* Compute the checksum of the DIE, then append part of it as hex digits to
6141 the name filename of the unit. */
6143 md5_init_ctx (&ctx);
6145 die_checksum (unit_die, &ctx, &mark);
6146 unmark_all_dies (unit_die);
6147 md5_finish_ctx (&ctx, checksum);
6149 sprintf (name, "%s.", base);
6150 clean_symbol_name (name);
6152 p = name + strlen (name);
6153 for (i = 0; i < 4; i++)
6155 sprintf (p, "%.2x", checksum[i]);
6159 comdat_symbol_id = unit_die->die_symbol = xstrdup (name);
6160 comdat_symbol_number = 0;
6163 /* Returns nonzero if DIE represents a type, in the sense of TYPE_P. */
6166 is_type_die (dw_die_ref die)
6168 switch (die->die_tag)
6170 case DW_TAG_array_type:
6171 case DW_TAG_class_type:
6172 case DW_TAG_enumeration_type:
6173 case DW_TAG_pointer_type:
6174 case DW_TAG_reference_type:
6175 case DW_TAG_string_type:
6176 case DW_TAG_structure_type:
6177 case DW_TAG_subroutine_type:
6178 case DW_TAG_union_type:
6179 case DW_TAG_ptr_to_member_type:
6180 case DW_TAG_set_type:
6181 case DW_TAG_subrange_type:
6182 case DW_TAG_base_type:
6183 case DW_TAG_const_type:
6184 case DW_TAG_file_type:
6185 case DW_TAG_packed_type:
6186 case DW_TAG_volatile_type:
6187 case DW_TAG_typedef:
6194 /* Returns 1 iff C is the sort of DIE that should go into a COMDAT CU.
6195 Basically, we want to choose the bits that are likely to be shared between
6196 compilations (types) and leave out the bits that are specific to individual
6197 compilations (functions). */
6200 is_comdat_die (dw_die_ref c)
6202 /* I think we want to leave base types and __vtbl_ptr_type in the main CU, as
6203 we do for stabs. The advantage is a greater likelihood of sharing between
6204 objects that don't include headers in the same order (and therefore would
6205 put the base types in a different comdat). jason 8/28/00 */
6207 if (c->die_tag == DW_TAG_base_type)
6210 if (c->die_tag == DW_TAG_pointer_type
6211 || c->die_tag == DW_TAG_reference_type
6212 || c->die_tag == DW_TAG_const_type
6213 || c->die_tag == DW_TAG_volatile_type)
6215 dw_die_ref t = get_AT_ref (c, DW_AT_type);
6217 return t ? is_comdat_die (t) : 0;
6220 return is_type_die (c);
6223 /* Returns 1 iff C is the sort of DIE that might be referred to from another
6224 compilation unit. */
6227 is_symbol_die (dw_die_ref c)
6229 return (is_type_die (c)
6230 || (get_AT (c, DW_AT_declaration)
6231 && !get_AT (c, DW_AT_specification))
6232 || c->die_tag == DW_TAG_namespace);
6236 gen_internal_sym (const char *prefix)
6240 ASM_GENERATE_INTERNAL_LABEL (buf, prefix, label_num++);
6241 return xstrdup (buf);
6244 /* Assign symbols to all worthy DIEs under DIE. */
6247 assign_symbol_names (dw_die_ref die)
6251 if (is_symbol_die (die))
6253 if (comdat_symbol_id)
6255 char *p = alloca (strlen (comdat_symbol_id) + 64);
6257 sprintf (p, "%s.%s.%x", DIE_LABEL_PREFIX,
6258 comdat_symbol_id, comdat_symbol_number++);
6259 die->die_symbol = xstrdup (p);
6262 die->die_symbol = gen_internal_sym ("LDIE");
6265 for (c = die->die_child; c != NULL; c = c->die_sib)
6266 assign_symbol_names (c);
6269 struct cu_hash_table_entry
6272 unsigned min_comdat_num, max_comdat_num;
6273 struct cu_hash_table_entry *next;
6276 /* Routines to manipulate hash table of CUs. */
6278 htab_cu_hash (const void *of)
6280 const struct cu_hash_table_entry *entry = of;
6282 return htab_hash_string (entry->cu->die_symbol);
6286 htab_cu_eq (const void *of1, const void *of2)
6288 const struct cu_hash_table_entry *entry1 = of1;
6289 const struct die_struct *entry2 = of2;
6291 return !strcmp (entry1->cu->die_symbol, entry2->die_symbol);
6295 htab_cu_del (void *what)
6297 struct cu_hash_table_entry *next, *entry = what;
6307 /* Check whether we have already seen this CU and set up SYM_NUM
6310 check_duplicate_cu (dw_die_ref cu, htab_t htable, unsigned int *sym_num)
6312 struct cu_hash_table_entry dummy;
6313 struct cu_hash_table_entry **slot, *entry, *last = &dummy;
6315 dummy.max_comdat_num = 0;
6317 slot = (struct cu_hash_table_entry **)
6318 htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_symbol),
6322 for (; entry; last = entry, entry = entry->next)
6324 if (same_die_p_wrap (cu, entry->cu))
6330 *sym_num = entry->min_comdat_num;
6334 entry = xcalloc (1, sizeof (struct cu_hash_table_entry));
6336 entry->min_comdat_num = *sym_num = last->max_comdat_num;
6337 entry->next = *slot;
6343 /* Record SYM_NUM to record of CU in HTABLE. */
6345 record_comdat_symbol_number (dw_die_ref cu, htab_t htable, unsigned int sym_num)
6347 struct cu_hash_table_entry **slot, *entry;
6349 slot = (struct cu_hash_table_entry **)
6350 htab_find_slot_with_hash (htable, cu, htab_hash_string (cu->die_symbol),
6354 entry->max_comdat_num = sym_num;
6357 /* Traverse the DIE (which is always comp_unit_die), and set up
6358 additional compilation units for each of the include files we see
6359 bracketed by BINCL/EINCL. */
6362 break_out_includes (dw_die_ref die)
6365 dw_die_ref unit = NULL;
6366 limbo_die_node *node, **pnode;
6367 htab_t cu_hash_table;
6369 for (ptr = &(die->die_child); *ptr;)
6371 dw_die_ref c = *ptr;
6373 if (c->die_tag == DW_TAG_GNU_BINCL || c->die_tag == DW_TAG_GNU_EINCL
6374 || (unit && is_comdat_die (c)))
6376 /* This DIE is for a secondary CU; remove it from the main one. */
6379 if (c->die_tag == DW_TAG_GNU_BINCL)
6381 unit = push_new_compile_unit (unit, c);
6384 else if (c->die_tag == DW_TAG_GNU_EINCL)
6386 unit = pop_compile_unit (unit);
6390 add_child_die (unit, c);
6394 /* Leave this DIE in the main CU. */
6395 ptr = &(c->die_sib);
6401 /* We can only use this in debugging, since the frontend doesn't check
6402 to make sure that we leave every include file we enter. */
6406 assign_symbol_names (die);
6407 cu_hash_table = htab_create (10, htab_cu_hash, htab_cu_eq, htab_cu_del);
6408 for (node = limbo_die_list, pnode = &limbo_die_list;
6414 compute_section_prefix (node->die);
6415 is_dupl = check_duplicate_cu (node->die, cu_hash_table,
6416 &comdat_symbol_number);
6417 assign_symbol_names (node->die);
6419 *pnode = node->next;
6422 pnode = &node->next;
6423 record_comdat_symbol_number (node->die, cu_hash_table,
6424 comdat_symbol_number);
6427 htab_delete (cu_hash_table);
6430 /* Traverse the DIE and add a sibling attribute if it may have the
6431 effect of speeding up access to siblings. To save some space,
6432 avoid generating sibling attributes for DIE's without children. */
6435 add_sibling_attributes (dw_die_ref die)
6439 if (die->die_tag != DW_TAG_compile_unit
6440 && die->die_sib && die->die_child != NULL)
6441 /* Add the sibling link to the front of the attribute list. */
6442 add_AT_die_ref (die, DW_AT_sibling, die->die_sib);
6444 for (c = die->die_child; c != NULL; c = c->die_sib)
6445 add_sibling_attributes (c);
6448 /* Output all location lists for the DIE and its children. */
6451 output_location_lists (dw_die_ref die)
6456 for (d_attr = die->die_attr; d_attr; d_attr = d_attr->dw_attr_next)
6457 if (AT_class (d_attr) == dw_val_class_loc_list)
6458 output_loc_list (AT_loc_list (d_attr));
6460 for (c = die->die_child; c != NULL; c = c->die_sib)
6461 output_location_lists (c);
6465 /* The format of each DIE (and its attribute value pairs) is encoded in an
6466 abbreviation table. This routine builds the abbreviation table and assigns
6467 a unique abbreviation id for each abbreviation entry. The children of each
6468 die are visited recursively. */
6471 build_abbrev_table (dw_die_ref die)
6473 unsigned long abbrev_id;
6474 unsigned int n_alloc;
6476 dw_attr_ref d_attr, a_attr;
6478 /* Scan the DIE references, and mark as external any that refer to
6479 DIEs from other CUs (i.e. those which are not marked). */
6480 for (d_attr = die->die_attr; d_attr; d_attr = d_attr->dw_attr_next)
6481 if (AT_class (d_attr) == dw_val_class_die_ref
6482 && AT_ref (d_attr)->die_mark == 0)
6484 gcc_assert (AT_ref (d_attr)->die_symbol);
6486 set_AT_ref_external (d_attr, 1);
6489 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
6491 dw_die_ref abbrev = abbrev_die_table[abbrev_id];
6493 if (abbrev->die_tag == die->die_tag)
6495 if ((abbrev->die_child != NULL) == (die->die_child != NULL))
6497 a_attr = abbrev->die_attr;
6498 d_attr = die->die_attr;
6500 while (a_attr != NULL && d_attr != NULL)
6502 if ((a_attr->dw_attr != d_attr->dw_attr)
6503 || (value_format (a_attr) != value_format (d_attr)))
6506 a_attr = a_attr->dw_attr_next;
6507 d_attr = d_attr->dw_attr_next;
6510 if (a_attr == NULL && d_attr == NULL)
6516 if (abbrev_id >= abbrev_die_table_in_use)
6518 if (abbrev_die_table_in_use >= abbrev_die_table_allocated)
6520 n_alloc = abbrev_die_table_allocated + ABBREV_DIE_TABLE_INCREMENT;
6521 abbrev_die_table = ggc_realloc (abbrev_die_table,
6522 sizeof (dw_die_ref) * n_alloc);
6524 memset (&abbrev_die_table[abbrev_die_table_allocated], 0,
6525 (n_alloc - abbrev_die_table_allocated) * sizeof (dw_die_ref));
6526 abbrev_die_table_allocated = n_alloc;
6529 ++abbrev_die_table_in_use;
6530 abbrev_die_table[abbrev_id] = die;
6533 die->die_abbrev = abbrev_id;
6534 for (c = die->die_child; c != NULL; c = c->die_sib)
6535 build_abbrev_table (c);
6538 /* Return the power-of-two number of bytes necessary to represent VALUE. */
6541 constant_size (long unsigned int value)
6548 log = floor_log2 (value);
6551 log = 1 << (floor_log2 (log) + 1);
6556 /* Return the size of a DIE as it is represented in the
6557 .debug_info section. */
6559 static unsigned long
6560 size_of_die (dw_die_ref die)
6562 unsigned long size = 0;
6565 size += size_of_uleb128 (die->die_abbrev);
6566 for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
6568 switch (AT_class (a))
6570 case dw_val_class_addr:
6571 size += DWARF2_ADDR_SIZE;
6573 case dw_val_class_offset:
6574 size += DWARF_OFFSET_SIZE;
6576 case dw_val_class_loc:
6578 unsigned long lsize = size_of_locs (AT_loc (a));
6581 size += constant_size (lsize);
6585 case dw_val_class_loc_list:
6586 size += DWARF_OFFSET_SIZE;
6588 case dw_val_class_range_list:
6589 size += DWARF_OFFSET_SIZE;
6591 case dw_val_class_const:
6592 size += size_of_sleb128 (AT_int (a));
6594 case dw_val_class_unsigned_const:
6595 size += constant_size (AT_unsigned (a));
6597 case dw_val_class_long_long:
6598 size += 1 + 2*HOST_BITS_PER_LONG/HOST_BITS_PER_CHAR; /* block */
6600 case dw_val_class_vec:
6601 size += 1 + (a->dw_attr_val.v.val_vec.length
6602 * a->dw_attr_val.v.val_vec.elt_size); /* block */
6604 case dw_val_class_flag:
6607 case dw_val_class_die_ref:
6608 if (AT_ref_external (a))
6609 size += DWARF2_ADDR_SIZE;
6611 size += DWARF_OFFSET_SIZE;
6613 case dw_val_class_fde_ref:
6614 size += DWARF_OFFSET_SIZE;
6616 case dw_val_class_lbl_id:
6617 size += DWARF2_ADDR_SIZE;
6619 case dw_val_class_lbl_offset:
6620 size += DWARF_OFFSET_SIZE;
6622 case dw_val_class_str:
6623 if (AT_string_form (a) == DW_FORM_strp)
6624 size += DWARF_OFFSET_SIZE;
6626 size += strlen (a->dw_attr_val.v.val_str->str) + 1;
6636 /* Size the debugging information associated with a given DIE. Visits the
6637 DIE's children recursively. Updates the global variable next_die_offset, on
6638 each time through. Uses the current value of next_die_offset to update the
6639 die_offset field in each DIE. */
6642 calc_die_sizes (dw_die_ref die)
6646 die->die_offset = next_die_offset;
6647 next_die_offset += size_of_die (die);
6649 for (c = die->die_child; c != NULL; c = c->die_sib)
6652 if (die->die_child != NULL)
6653 /* Count the null byte used to terminate sibling lists. */
6654 next_die_offset += 1;
6657 /* Set the marks for a die and its children. We do this so
6658 that we know whether or not a reference needs to use FORM_ref_addr; only
6659 DIEs in the same CU will be marked. We used to clear out the offset
6660 and use that as the flag, but ran into ordering problems. */
6663 mark_dies (dw_die_ref die)
6667 gcc_assert (!die->die_mark);
6670 for (c = die->die_child; c; c = c->die_sib)
6674 /* Clear the marks for a die and its children. */
6677 unmark_dies (dw_die_ref die)
6681 gcc_assert (die->die_mark);
6684 for (c = die->die_child; c; c = c->die_sib)
6688 /* Clear the marks for a die, its children and referred dies. */
6691 unmark_all_dies (dw_die_ref die)
6700 for (c = die->die_child; c; c = c->die_sib)
6701 unmark_all_dies (c);
6703 for (a = die->die_attr; a; a = a->dw_attr_next)
6704 if (AT_class (a) == dw_val_class_die_ref)
6705 unmark_all_dies (AT_ref (a));
6708 /* Return the size of the .debug_pubnames table generated for the
6709 compilation unit. */
6711 static unsigned long
6712 size_of_pubnames (void)
6717 size = DWARF_PUBNAMES_HEADER_SIZE;
6718 for (i = 0; i < pubname_table_in_use; i++)
6720 pubname_ref p = &pubname_table[i];
6721 size += DWARF_OFFSET_SIZE + strlen (p->name) + 1;
6724 size += DWARF_OFFSET_SIZE;
6728 /* Return the size of the information in the .debug_aranges section. */
6730 static unsigned long
6731 size_of_aranges (void)
6735 size = DWARF_ARANGES_HEADER_SIZE;
6737 /* Count the address/length pair for this compilation unit. */
6738 size += 2 * DWARF2_ADDR_SIZE;
6739 size += 2 * DWARF2_ADDR_SIZE * arange_table_in_use;
6741 /* Count the two zero words used to terminated the address range table. */
6742 size += 2 * DWARF2_ADDR_SIZE;
6746 /* Select the encoding of an attribute value. */
6748 static enum dwarf_form
6749 value_format (dw_attr_ref a)
6751 switch (a->dw_attr_val.val_class)
6753 case dw_val_class_addr:
6754 return DW_FORM_addr;
6755 case dw_val_class_range_list:
6756 case dw_val_class_offset:
6757 switch (DWARF_OFFSET_SIZE)
6760 return DW_FORM_data4;
6762 return DW_FORM_data8;
6766 case dw_val_class_loc_list:
6767 /* FIXME: Could be DW_FORM_data8, with a > 32 bit size
6768 .debug_loc section */
6769 return DW_FORM_data4;
6770 case dw_val_class_loc:
6771 switch (constant_size (size_of_locs (AT_loc (a))))
6774 return DW_FORM_block1;
6776 return DW_FORM_block2;
6780 case dw_val_class_const:
6781 return DW_FORM_sdata;
6782 case dw_val_class_unsigned_const:
6783 switch (constant_size (AT_unsigned (a)))
6786 return DW_FORM_data1;
6788 return DW_FORM_data2;
6790 return DW_FORM_data4;
6792 return DW_FORM_data8;
6796 case dw_val_class_long_long:
6797 return DW_FORM_block1;
6798 case dw_val_class_vec:
6799 return DW_FORM_block1;
6800 case dw_val_class_flag:
6801 return DW_FORM_flag;
6802 case dw_val_class_die_ref:
6803 if (AT_ref_external (a))
6804 return DW_FORM_ref_addr;
6807 case dw_val_class_fde_ref:
6808 return DW_FORM_data;
6809 case dw_val_class_lbl_id:
6810 return DW_FORM_addr;
6811 case dw_val_class_lbl_offset:
6812 return DW_FORM_data;
6813 case dw_val_class_str:
6814 return AT_string_form (a);
6821 /* Output the encoding of an attribute value. */
6824 output_value_format (dw_attr_ref a)
6826 enum dwarf_form form = value_format (a);
6828 dw2_asm_output_data_uleb128 (form, "(%s)", dwarf_form_name (form));
6831 /* Output the .debug_abbrev section which defines the DIE abbreviation
6835 output_abbrev_section (void)
6837 unsigned long abbrev_id;
6841 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
6843 dw_die_ref abbrev = abbrev_die_table[abbrev_id];
6845 dw2_asm_output_data_uleb128 (abbrev_id, "(abbrev code)");
6846 dw2_asm_output_data_uleb128 (abbrev->die_tag, "(TAG: %s)",
6847 dwarf_tag_name (abbrev->die_tag));
6849 if (abbrev->die_child != NULL)
6850 dw2_asm_output_data (1, DW_children_yes, "DW_children_yes");
6852 dw2_asm_output_data (1, DW_children_no, "DW_children_no");
6854 for (a_attr = abbrev->die_attr; a_attr != NULL;
6855 a_attr = a_attr->dw_attr_next)
6857 dw2_asm_output_data_uleb128 (a_attr->dw_attr, "(%s)",
6858 dwarf_attr_name (a_attr->dw_attr));
6859 output_value_format (a_attr);
6862 dw2_asm_output_data (1, 0, NULL);
6863 dw2_asm_output_data (1, 0, NULL);
6866 /* Terminate the table. */
6867 dw2_asm_output_data (1, 0, NULL);
6870 /* Output a symbol we can use to refer to this DIE from another CU. */
6873 output_die_symbol (dw_die_ref die)
6875 char *sym = die->die_symbol;
6880 if (strncmp (sym, DIE_LABEL_PREFIX, sizeof (DIE_LABEL_PREFIX) - 1) == 0)
6881 /* We make these global, not weak; if the target doesn't support
6882 .linkonce, it doesn't support combining the sections, so debugging
6884 targetm.asm_out.globalize_label (asm_out_file, sym);
6886 ASM_OUTPUT_LABEL (asm_out_file, sym);
6889 /* Return a new location list, given the begin and end range, and the
6890 expression. gensym tells us whether to generate a new internal symbol for
6891 this location list node, which is done for the head of the list only. */
6893 static inline dw_loc_list_ref
6894 new_loc_list (dw_loc_descr_ref expr, const char *begin, const char *end,
6895 const char *section, unsigned int gensym)
6897 dw_loc_list_ref retlist = ggc_alloc_cleared (sizeof (dw_loc_list_node));
6899 retlist->begin = begin;
6901 retlist->expr = expr;
6902 retlist->section = section;
6904 retlist->ll_symbol = gen_internal_sym ("LLST");
6909 /* Add a location description expression to a location list. */
6912 add_loc_descr_to_loc_list (dw_loc_list_ref *list_head, dw_loc_descr_ref descr,
6913 const char *begin, const char *end,
6914 const char *section)
6918 /* Find the end of the chain. */
6919 for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
6922 /* Add a new location list node to the list. */
6923 *d = new_loc_list (descr, begin, end, section, 0);
6926 /* Output the location list given to us. */
6929 output_loc_list (dw_loc_list_ref list_head)
6931 dw_loc_list_ref curr = list_head;
6933 ASM_OUTPUT_LABEL (asm_out_file, list_head->ll_symbol);
6935 /* Walk the location list, and output each range + expression. */
6936 for (curr = list_head; curr != NULL; curr = curr->dw_loc_next)
6939 if (!separate_line_info_table_in_use && !have_switched_text_section)
6941 dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->begin, curr->section,
6942 "Location list begin address (%s)",
6943 list_head->ll_symbol);
6944 dw2_asm_output_delta (DWARF2_ADDR_SIZE, curr->end, curr->section,
6945 "Location list end address (%s)",
6946 list_head->ll_symbol);
6950 dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->begin,
6951 "Location list begin address (%s)",
6952 list_head->ll_symbol);
6953 dw2_asm_output_addr (DWARF2_ADDR_SIZE, curr->end,
6954 "Location list end address (%s)",
6955 list_head->ll_symbol);
6957 size = size_of_locs (curr->expr);
6959 /* Output the block length for this list of location operations. */
6960 gcc_assert (size <= 0xffff);
6961 dw2_asm_output_data (2, size, "%s", "Location expression size");
6963 output_loc_sequence (curr->expr);
6966 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0,
6967 "Location list terminator begin (%s)",
6968 list_head->ll_symbol);
6969 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0,
6970 "Location list terminator end (%s)",
6971 list_head->ll_symbol);
6974 /* Output the DIE and its attributes. Called recursively to generate
6975 the definitions of each child DIE. */
6978 output_die (dw_die_ref die)
6984 /* If someone in another CU might refer to us, set up a symbol for
6985 them to point to. */
6986 if (die->die_symbol)
6987 output_die_symbol (die);
6989 dw2_asm_output_data_uleb128 (die->die_abbrev, "(DIE (0x%lx) %s)",
6990 die->die_offset, dwarf_tag_name (die->die_tag));
6992 for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
6994 const char *name = dwarf_attr_name (a->dw_attr);
6996 switch (AT_class (a))
6998 case dw_val_class_addr:
6999 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE, AT_addr (a), "%s", name);
7002 case dw_val_class_offset:
7003 dw2_asm_output_data (DWARF_OFFSET_SIZE, a->dw_attr_val.v.val_offset,
7007 case dw_val_class_range_list:
7009 char *p = strchr (ranges_section_label, '\0');
7011 sprintf (p, "+" HOST_WIDE_INT_PRINT_HEX,
7012 a->dw_attr_val.v.val_offset);
7013 dw2_asm_output_offset (DWARF_OFFSET_SIZE, ranges_section_label,
7019 case dw_val_class_loc:
7020 size = size_of_locs (AT_loc (a));
7022 /* Output the block length for this list of location operations. */
7023 dw2_asm_output_data (constant_size (size), size, "%s", name);
7025 output_loc_sequence (AT_loc (a));
7028 case dw_val_class_const:
7029 /* ??? It would be slightly more efficient to use a scheme like is
7030 used for unsigned constants below, but gdb 4.x does not sign
7031 extend. Gdb 5.x does sign extend. */
7032 dw2_asm_output_data_sleb128 (AT_int (a), "%s", name);
7035 case dw_val_class_unsigned_const:
7036 dw2_asm_output_data (constant_size (AT_unsigned (a)),
7037 AT_unsigned (a), "%s", name);
7040 case dw_val_class_long_long:
7042 unsigned HOST_WIDE_INT first, second;
7044 dw2_asm_output_data (1,
7045 2 * HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
7048 if (WORDS_BIG_ENDIAN)
7050 first = a->dw_attr_val.v.val_long_long.hi;
7051 second = a->dw_attr_val.v.val_long_long.low;
7055 first = a->dw_attr_val.v.val_long_long.low;
7056 second = a->dw_attr_val.v.val_long_long.hi;
7059 dw2_asm_output_data (HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
7060 first, "long long constant");
7061 dw2_asm_output_data (HOST_BITS_PER_LONG / HOST_BITS_PER_CHAR,
7066 case dw_val_class_vec:
7068 unsigned int elt_size = a->dw_attr_val.v.val_vec.elt_size;
7069 unsigned int len = a->dw_attr_val.v.val_vec.length;
7073 dw2_asm_output_data (1, len * elt_size, "%s", name);
7074 if (elt_size > sizeof (HOST_WIDE_INT))
7079 for (i = 0, p = a->dw_attr_val.v.val_vec.array;
7082 dw2_asm_output_data (elt_size, extract_int (p, elt_size),
7083 "fp or vector constant word %u", i);
7087 case dw_val_class_flag:
7088 dw2_asm_output_data (1, AT_flag (a), "%s", name);
7091 case dw_val_class_loc_list:
7093 char *sym = AT_loc_list (a)->ll_symbol;
7096 dw2_asm_output_offset (DWARF_OFFSET_SIZE, sym, "%s", name);
7100 case dw_val_class_die_ref:
7101 if (AT_ref_external (a))
7103 char *sym = AT_ref (a)->die_symbol;
7106 dw2_asm_output_offset (DWARF2_ADDR_SIZE, sym, "%s", name);
7110 gcc_assert (AT_ref (a)->die_offset);
7111 dw2_asm_output_data (DWARF_OFFSET_SIZE, AT_ref (a)->die_offset,
7116 case dw_val_class_fde_ref:
7120 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_LABEL,
7121 a->dw_attr_val.v.val_fde_index * 2);
7122 dw2_asm_output_offset (DWARF_OFFSET_SIZE, l1, "%s", name);
7126 case dw_val_class_lbl_id:
7127 dw2_asm_output_addr (DWARF2_ADDR_SIZE, AT_lbl (a), "%s", name);
7130 case dw_val_class_lbl_offset:
7131 dw2_asm_output_offset (DWARF_OFFSET_SIZE, AT_lbl (a), "%s", name);
7134 case dw_val_class_str:
7135 if (AT_string_form (a) == DW_FORM_strp)
7136 dw2_asm_output_offset (DWARF_OFFSET_SIZE,
7137 a->dw_attr_val.v.val_str->label,
7138 "%s: \"%s\"", name, AT_string (a));
7140 dw2_asm_output_nstring (AT_string (a), -1, "%s", name);
7148 for (c = die->die_child; c != NULL; c = c->die_sib)
7151 /* Add null byte to terminate sibling list. */
7152 if (die->die_child != NULL)
7153 dw2_asm_output_data (1, 0, "end of children of DIE 0x%lx",
7157 /* Output the compilation unit that appears at the beginning of the
7158 .debug_info section, and precedes the DIE descriptions. */
7161 output_compilation_unit_header (void)
7163 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
7164 dw2_asm_output_data (4, 0xffffffff,
7165 "Initial length escape value indicating 64-bit DWARF extension");
7166 dw2_asm_output_data (DWARF_OFFSET_SIZE,
7167 next_die_offset - DWARF_INITIAL_LENGTH_SIZE,
7168 "Length of Compilation Unit Info");
7169 dw2_asm_output_data (2, DWARF_VERSION, "DWARF version number");
7170 dw2_asm_output_offset (DWARF_OFFSET_SIZE, abbrev_section_label,
7171 "Offset Into Abbrev. Section");
7172 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Pointer Size (in bytes)");
7175 /* Output the compilation unit DIE and its children. */
7178 output_comp_unit (dw_die_ref die, int output_if_empty)
7180 const char *secname;
7183 /* Unless we are outputting main CU, we may throw away empty ones. */
7184 if (!output_if_empty && die->die_child == NULL)
7187 /* Even if there are no children of this DIE, we must output the information
7188 about the compilation unit. Otherwise, on an empty translation unit, we
7189 will generate a present, but empty, .debug_info section. IRIX 6.5 `nm'
7190 will then complain when examining the file. First mark all the DIEs in
7191 this CU so we know which get local refs. */
7194 build_abbrev_table (die);
7196 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
7197 next_die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE;
7198 calc_die_sizes (die);
7200 oldsym = die->die_symbol;
7203 tmp = alloca (strlen (oldsym) + 24);
7205 sprintf (tmp, ".gnu.linkonce.wi.%s", oldsym);
7207 die->die_symbol = NULL;
7210 secname = (const char *) DEBUG_INFO_SECTION;
7212 /* Output debugging information. */
7213 named_section_flags (secname, SECTION_DEBUG);
7214 output_compilation_unit_header ();
7217 /* Leave the marks on the main CU, so we can check them in
7222 die->die_symbol = oldsym;
7226 /* The DWARF2 pubname for a nested thingy looks like "A::f". The
7227 output of lang_hooks.decl_printable_name for C++ looks like
7228 "A::f(int)". Let's drop the argument list, and maybe the scope. */
7231 dwarf2_name (tree decl, int scope)
7233 return lang_hooks.decl_printable_name (decl, scope ? 1 : 0);
7236 /* Add a new entry to .debug_pubnames if appropriate. */
7239 add_pubname (tree decl, dw_die_ref die)
7243 if (! TREE_PUBLIC (decl))
7246 if (pubname_table_in_use == pubname_table_allocated)
7248 pubname_table_allocated += PUBNAME_TABLE_INCREMENT;
7250 = ggc_realloc (pubname_table,
7251 (pubname_table_allocated * sizeof (pubname_entry)));
7252 memset (pubname_table + pubname_table_in_use, 0,
7253 PUBNAME_TABLE_INCREMENT * sizeof (pubname_entry));
7256 p = &pubname_table[pubname_table_in_use++];
7258 p->name = xstrdup (dwarf2_name (decl, 1));
7261 /* Output the public names table used to speed up access to externally
7262 visible names. For now, only generate entries for externally
7263 visible procedures. */
7266 output_pubnames (void)
7269 unsigned long pubnames_length = size_of_pubnames ();
7271 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
7272 dw2_asm_output_data (4, 0xffffffff,
7273 "Initial length escape value indicating 64-bit DWARF extension");
7274 dw2_asm_output_data (DWARF_OFFSET_SIZE, pubnames_length,
7275 "Length of Public Names Info");
7276 dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
7277 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
7278 "Offset of Compilation Unit Info");
7279 dw2_asm_output_data (DWARF_OFFSET_SIZE, next_die_offset,
7280 "Compilation Unit Length");
7282 for (i = 0; i < pubname_table_in_use; i++)
7284 pubname_ref pub = &pubname_table[i];
7286 /* We shouldn't see pubnames for DIEs outside of the main CU. */
7287 gcc_assert (pub->die->die_mark);
7289 dw2_asm_output_data (DWARF_OFFSET_SIZE, pub->die->die_offset,
7292 dw2_asm_output_nstring (pub->name, -1, "external name");
7295 dw2_asm_output_data (DWARF_OFFSET_SIZE, 0, NULL);
7298 /* Add a new entry to .debug_aranges if appropriate. */
7301 add_arange (tree decl, dw_die_ref die)
7303 if (! DECL_SECTION_NAME (decl))
7306 if (arange_table_in_use == arange_table_allocated)
7308 arange_table_allocated += ARANGE_TABLE_INCREMENT;
7309 arange_table = ggc_realloc (arange_table,
7310 (arange_table_allocated
7311 * sizeof (dw_die_ref)));
7312 memset (arange_table + arange_table_in_use, 0,
7313 ARANGE_TABLE_INCREMENT * sizeof (dw_die_ref));
7316 arange_table[arange_table_in_use++] = die;
7319 /* Output the information that goes into the .debug_aranges table.
7320 Namely, define the beginning and ending address range of the
7321 text section generated for this compilation unit. */
7324 output_aranges (void)
7327 unsigned long aranges_length = size_of_aranges ();
7329 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
7330 dw2_asm_output_data (4, 0xffffffff,
7331 "Initial length escape value indicating 64-bit DWARF extension");
7332 dw2_asm_output_data (DWARF_OFFSET_SIZE, aranges_length,
7333 "Length of Address Ranges Info");
7334 dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
7335 dw2_asm_output_offset (DWARF_OFFSET_SIZE, debug_info_section_label,
7336 "Offset of Compilation Unit Info");
7337 dw2_asm_output_data (1, DWARF2_ADDR_SIZE, "Size of Address");
7338 dw2_asm_output_data (1, 0, "Size of Segment Descriptor");
7340 /* We need to align to twice the pointer size here. */
7341 if (DWARF_ARANGES_PAD_SIZE)
7343 /* Pad using a 2 byte words so that padding is correct for any
7345 dw2_asm_output_data (2, 0, "Pad to %d byte boundary",
7346 2 * DWARF2_ADDR_SIZE);
7347 for (i = 2; i < (unsigned) DWARF_ARANGES_PAD_SIZE; i += 2)
7348 dw2_asm_output_data (2, 0, NULL);
7351 dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_section_label, "Address");
7352 dw2_asm_output_delta (DWARF2_ADDR_SIZE, text_end_label,
7353 text_section_label, "Length");
7354 if (flag_reorder_blocks_and_partition)
7356 dw2_asm_output_addr (DWARF2_ADDR_SIZE, cold_text_section_label,
7358 dw2_asm_output_delta (DWARF2_ADDR_SIZE, cold_end_label,
7359 cold_text_section_label, "Length");
7362 for (i = 0; i < arange_table_in_use; i++)
7364 dw_die_ref die = arange_table[i];
7366 /* We shouldn't see aranges for DIEs outside of the main CU. */
7367 gcc_assert (die->die_mark);
7369 if (die->die_tag == DW_TAG_subprogram)
7371 dw2_asm_output_addr (DWARF2_ADDR_SIZE, get_AT_low_pc (die),
7373 dw2_asm_output_delta (DWARF2_ADDR_SIZE, get_AT_hi_pc (die),
7374 get_AT_low_pc (die), "Length");
7378 /* A static variable; extract the symbol from DW_AT_location.
7379 Note that this code isn't currently hit, as we only emit
7380 aranges for functions (jason 9/23/99). */
7381 dw_attr_ref a = get_AT (die, DW_AT_location);
7382 dw_loc_descr_ref loc;
7384 gcc_assert (a && AT_class (a) == dw_val_class_loc);
7387 gcc_assert (loc->dw_loc_opc == DW_OP_addr);
7389 dw2_asm_output_addr_rtx (DWARF2_ADDR_SIZE,
7390 loc->dw_loc_oprnd1.v.val_addr, "Address");
7391 dw2_asm_output_data (DWARF2_ADDR_SIZE,
7392 get_AT_unsigned (die, DW_AT_byte_size),
7397 /* Output the terminator words. */
7398 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
7399 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
7402 /* Add a new entry to .debug_ranges. Return the offset at which it
7406 add_ranges (tree block)
7408 unsigned int in_use = ranges_table_in_use;
7410 if (in_use == ranges_table_allocated)
7412 ranges_table_allocated += RANGES_TABLE_INCREMENT;
7414 = ggc_realloc (ranges_table, (ranges_table_allocated
7415 * sizeof (struct dw_ranges_struct)));
7416 memset (ranges_table + ranges_table_in_use, 0,
7417 RANGES_TABLE_INCREMENT * sizeof (struct dw_ranges_struct));
7420 ranges_table[in_use].block_num = (block ? BLOCK_NUMBER (block) : 0);
7421 ranges_table_in_use = in_use + 1;
7423 return in_use * 2 * DWARF2_ADDR_SIZE;
7427 output_ranges (void)
7430 static const char *const start_fmt = "Offset 0x%x";
7431 const char *fmt = start_fmt;
7433 for (i = 0; i < ranges_table_in_use; i++)
7435 int block_num = ranges_table[i].block_num;
7439 char blabel[MAX_ARTIFICIAL_LABEL_BYTES];
7440 char elabel[MAX_ARTIFICIAL_LABEL_BYTES];
7442 ASM_GENERATE_INTERNAL_LABEL (blabel, BLOCK_BEGIN_LABEL, block_num);
7443 ASM_GENERATE_INTERNAL_LABEL (elabel, BLOCK_END_LABEL, block_num);
7445 /* If all code is in the text section, then the compilation
7446 unit base address defaults to DW_AT_low_pc, which is the
7447 base of the text section. */
7448 if (!separate_line_info_table_in_use && !have_switched_text_section)
7450 dw2_asm_output_delta (DWARF2_ADDR_SIZE, blabel,
7452 fmt, i * 2 * DWARF2_ADDR_SIZE);
7453 dw2_asm_output_delta (DWARF2_ADDR_SIZE, elabel,
7454 text_section_label, NULL);
7457 /* Otherwise, we add a DW_AT_entry_pc attribute to force the
7458 compilation unit base address to zero, which allows us to
7459 use absolute addresses, and not worry about whether the
7460 target supports cross-section arithmetic. */
7463 dw2_asm_output_addr (DWARF2_ADDR_SIZE, blabel,
7464 fmt, i * 2 * DWARF2_ADDR_SIZE);
7465 dw2_asm_output_addr (DWARF2_ADDR_SIZE, elabel, NULL);
7472 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
7473 dw2_asm_output_data (DWARF2_ADDR_SIZE, 0, NULL);
7479 /* Data structure containing information about input files. */
7482 char *path; /* Complete file name. */
7483 char *fname; /* File name part. */
7484 int length; /* Length of entire string. */
7485 int file_idx; /* Index in input file table. */
7486 int dir_idx; /* Index in directory table. */
7489 /* Data structure containing information about directories with source
7493 char *path; /* Path including directory name. */
7494 int length; /* Path length. */
7495 int prefix; /* Index of directory entry which is a prefix. */
7496 int count; /* Number of files in this directory. */
7497 int dir_idx; /* Index of directory used as base. */
7498 int used; /* Used in the end? */
7501 /* Callback function for file_info comparison. We sort by looking at
7502 the directories in the path. */
7505 file_info_cmp (const void *p1, const void *p2)
7507 const struct file_info *s1 = p1;
7508 const struct file_info *s2 = p2;
7512 /* Take care of file names without directories. We need to make sure that
7513 we return consistent values to qsort since some will get confused if
7514 we return the same value when identical operands are passed in opposite
7515 orders. So if neither has a directory, return 0 and otherwise return
7516 1 or -1 depending on which one has the directory. */
7517 if ((s1->path == s1->fname || s2->path == s2->fname))
7518 return (s2->path == s2->fname) - (s1->path == s1->fname);
7520 cp1 = (unsigned char *) s1->path;
7521 cp2 = (unsigned char *) s2->path;
7527 /* Reached the end of the first path? If so, handle like above. */
7528 if ((cp1 == (unsigned char *) s1->fname)
7529 || (cp2 == (unsigned char *) s2->fname))
7530 return ((cp2 == (unsigned char *) s2->fname)
7531 - (cp1 == (unsigned char *) s1->fname));
7533 /* Character of current path component the same? */
7534 else if (*cp1 != *cp2)
7539 /* Output the directory table and the file name table. We try to minimize
7540 the total amount of memory needed. A heuristic is used to avoid large
7541 slowdowns with many input files. */
7544 output_file_names (void)
7546 struct file_info *files;
7547 struct dir_info *dirs;
7556 /* Handle the case where file_table is empty. */
7557 if (VARRAY_ACTIVE_SIZE (file_table) <= 1)
7559 dw2_asm_output_data (1, 0, "End directory table");
7560 dw2_asm_output_data (1, 0, "End file name table");
7564 /* Allocate the various arrays we need. */
7565 files = alloca (VARRAY_ACTIVE_SIZE (file_table) * sizeof (struct file_info));
7566 dirs = alloca (VARRAY_ACTIVE_SIZE (file_table) * sizeof (struct dir_info));
7568 /* Sort the file names. */
7569 for (i = 1; i < VARRAY_ACTIVE_SIZE (file_table); i++)
7573 /* Skip all leading "./". */
7574 f = VARRAY_CHAR_PTR (file_table, i);
7575 while (f[0] == '.' && f[1] == '/')
7578 /* Create a new array entry. */
7580 files[i].length = strlen (f);
7581 files[i].file_idx = i;
7583 /* Search for the file name part. */
7584 f = strrchr (f, '/');
7585 files[i].fname = f == NULL ? files[i].path : f + 1;
7588 qsort (files + 1, VARRAY_ACTIVE_SIZE (file_table) - 1,
7589 sizeof (files[0]), file_info_cmp);
7591 /* Find all the different directories used. */
7592 dirs[0].path = files[1].path;
7593 dirs[0].length = files[1].fname - files[1].path;
7594 dirs[0].prefix = -1;
7596 dirs[0].dir_idx = 0;
7598 files[1].dir_idx = 0;
7601 for (i = 2; i < VARRAY_ACTIVE_SIZE (file_table); i++)
7602 if (files[i].fname - files[i].path == dirs[ndirs - 1].length
7603 && memcmp (dirs[ndirs - 1].path, files[i].path,
7604 dirs[ndirs - 1].length) == 0)
7606 /* Same directory as last entry. */
7607 files[i].dir_idx = ndirs - 1;
7608 ++dirs[ndirs - 1].count;
7614 /* This is a new directory. */
7615 dirs[ndirs].path = files[i].path;
7616 dirs[ndirs].length = files[i].fname - files[i].path;
7617 dirs[ndirs].count = 1;
7618 dirs[ndirs].dir_idx = ndirs;
7619 dirs[ndirs].used = 0;
7620 files[i].dir_idx = ndirs;
7622 /* Search for a prefix. */
7623 dirs[ndirs].prefix = -1;
7624 for (j = 0; j < ndirs; j++)
7625 if (dirs[j].length < dirs[ndirs].length
7626 && dirs[j].length > 1
7627 && (dirs[ndirs].prefix == -1
7628 || dirs[j].length > dirs[dirs[ndirs].prefix].length)
7629 && memcmp (dirs[j].path, dirs[ndirs].path, dirs[j].length) == 0)
7630 dirs[ndirs].prefix = j;
7635 /* Now to the actual work. We have to find a subset of the directories which
7636 allow expressing the file name using references to the directory table
7637 with the least amount of characters. We do not do an exhaustive search
7638 where we would have to check out every combination of every single
7639 possible prefix. Instead we use a heuristic which provides nearly optimal
7640 results in most cases and never is much off. */
7641 saved = alloca (ndirs * sizeof (int));
7642 savehere = alloca (ndirs * sizeof (int));
7644 memset (saved, '\0', ndirs * sizeof (saved[0]));
7645 for (i = 0; i < ndirs; i++)
7650 /* We can always save some space for the current directory. But this
7651 does not mean it will be enough to justify adding the directory. */
7652 savehere[i] = dirs[i].length;
7653 total = (savehere[i] - saved[i]) * dirs[i].count;
7655 for (j = i + 1; j < ndirs; j++)
7658 if (saved[j] < dirs[i].length)
7660 /* Determine whether the dirs[i] path is a prefix of the
7665 while (k != -1 && k != (int) i)
7670 /* Yes it is. We can possibly safe some memory but
7671 writing the filenames in dirs[j] relative to
7673 savehere[j] = dirs[i].length;
7674 total += (savehere[j] - saved[j]) * dirs[j].count;
7679 /* Check whether we can safe enough to justify adding the dirs[i]
7681 if (total > dirs[i].length + 1)
7683 /* It's worthwhile adding. */
7684 for (j = i; j < ndirs; j++)
7685 if (savehere[j] > 0)
7687 /* Remember how much we saved for this directory so far. */
7688 saved[j] = savehere[j];
7690 /* Remember the prefix directory. */
7691 dirs[j].dir_idx = i;
7696 /* We have to emit them in the order they appear in the file_table array
7697 since the index is used in the debug info generation. To do this
7698 efficiently we generate a back-mapping of the indices first. */
7699 backmap = alloca (VARRAY_ACTIVE_SIZE (file_table) * sizeof (int));
7700 for (i = 1; i < VARRAY_ACTIVE_SIZE (file_table); i++)
7702 backmap[files[i].file_idx] = i;
7704 /* Mark this directory as used. */
7705 dirs[dirs[files[i].dir_idx].dir_idx].used = 1;
7708 /* That was it. We are ready to emit the information. First emit the
7709 directory name table. We have to make sure the first actually emitted
7710 directory name has index one; zero is reserved for the current working
7711 directory. Make sure we do not confuse these indices with the one for the
7712 constructed table (even though most of the time they are identical). */
7714 idx_offset = dirs[0].length > 0 ? 1 : 0;
7715 for (i = 1 - idx_offset; i < ndirs; i++)
7716 if (dirs[i].used != 0)
7718 dirs[i].used = idx++;
7719 dw2_asm_output_nstring (dirs[i].path, dirs[i].length - 1,
7720 "Directory Entry: 0x%x", dirs[i].used);
7723 dw2_asm_output_data (1, 0, "End directory table");
7725 /* Correct the index for the current working directory entry if it
7727 if (idx_offset == 0)
7730 /* Now write all the file names. */
7731 for (i = 1; i < VARRAY_ACTIVE_SIZE (file_table); i++)
7733 int file_idx = backmap[i];
7734 int dir_idx = dirs[files[file_idx].dir_idx].dir_idx;
7736 dw2_asm_output_nstring (files[file_idx].path + dirs[dir_idx].length, -1,
7737 "File Entry: 0x%lx", (unsigned long) i);
7739 /* Include directory index. */
7740 dw2_asm_output_data_uleb128 (dirs[dir_idx].used, NULL);
7742 /* Modification time. */
7743 dw2_asm_output_data_uleb128 (0, NULL);
7745 /* File length in bytes. */
7746 dw2_asm_output_data_uleb128 (0, NULL);
7749 dw2_asm_output_data (1, 0, "End file name table");
7753 /* Output the source line number correspondence information. This
7754 information goes into the .debug_line section. */
7757 output_line_info (void)
7759 char l1[20], l2[20], p1[20], p2[20];
7760 char line_label[MAX_ARTIFICIAL_LABEL_BYTES];
7761 char prev_line_label[MAX_ARTIFICIAL_LABEL_BYTES];
7764 unsigned long lt_index;
7765 unsigned long current_line;
7768 unsigned long current_file;
7769 unsigned long function;
7771 ASM_GENERATE_INTERNAL_LABEL (l1, LINE_NUMBER_BEGIN_LABEL, 0);
7772 ASM_GENERATE_INTERNAL_LABEL (l2, LINE_NUMBER_END_LABEL, 0);
7773 ASM_GENERATE_INTERNAL_LABEL (p1, LN_PROLOG_AS_LABEL, 0);
7774 ASM_GENERATE_INTERNAL_LABEL (p2, LN_PROLOG_END_LABEL, 0);
7776 if (DWARF_INITIAL_LENGTH_SIZE - DWARF_OFFSET_SIZE == 4)
7777 dw2_asm_output_data (4, 0xffffffff,
7778 "Initial length escape value indicating 64-bit DWARF extension");
7779 dw2_asm_output_delta (DWARF_OFFSET_SIZE, l2, l1,
7780 "Length of Source Line Info");
7781 ASM_OUTPUT_LABEL (asm_out_file, l1);
7783 dw2_asm_output_data (2, DWARF_VERSION, "DWARF Version");
7784 dw2_asm_output_delta (DWARF_OFFSET_SIZE, p2, p1, "Prolog Length");
7785 ASM_OUTPUT_LABEL (asm_out_file, p1);
7787 /* Define the architecture-dependent minimum instruction length (in
7788 bytes). In this implementation of DWARF, this field is used for
7789 information purposes only. Since GCC generates assembly language,
7790 we have no a priori knowledge of how many instruction bytes are
7791 generated for each source line, and therefore can use only the
7792 DW_LNE_set_address and DW_LNS_fixed_advance_pc line information
7793 commands. Accordingly, we fix this as `1', which is "correct
7794 enough" for all architectures, and don't let the target override. */
7795 dw2_asm_output_data (1, 1,
7796 "Minimum Instruction Length");
7798 dw2_asm_output_data (1, DWARF_LINE_DEFAULT_IS_STMT_START,
7799 "Default is_stmt_start flag");
7800 dw2_asm_output_data (1, DWARF_LINE_BASE,
7801 "Line Base Value (Special Opcodes)");
7802 dw2_asm_output_data (1, DWARF_LINE_RANGE,
7803 "Line Range Value (Special Opcodes)");
7804 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE,
7805 "Special Opcode Base");
7807 for (opc = 1; opc < DWARF_LINE_OPCODE_BASE; opc++)
7811 case DW_LNS_advance_pc:
7812 case DW_LNS_advance_line:
7813 case DW_LNS_set_file:
7814 case DW_LNS_set_column:
7815 case DW_LNS_fixed_advance_pc:
7823 dw2_asm_output_data (1, n_op_args, "opcode: 0x%x has %d args",
7827 /* Write out the information about the files we use. */
7828 output_file_names ();
7829 ASM_OUTPUT_LABEL (asm_out_file, p2);
7831 /* We used to set the address register to the first location in the text
7832 section here, but that didn't accomplish anything since we already
7833 have a line note for the opening brace of the first function. */
7835 /* Generate the line number to PC correspondence table, encoded as
7836 a series of state machine operations. */
7841 && (last_text_section == in_unlikely_executed_text
7842 || (last_text_section == in_named
7843 && last_text_section_name == cfun->unlikely_text_section_name)))
7844 strcpy (prev_line_label, cfun->cold_section_label);
7846 strcpy (prev_line_label, text_section_label);
7847 for (lt_index = 1; lt_index < line_info_table_in_use; ++lt_index)
7849 dw_line_info_ref line_info = &line_info_table[lt_index];
7852 /* Disable this optimization for now; GDB wants to see two line notes
7853 at the beginning of a function so it can find the end of the
7856 /* Don't emit anything for redundant notes. Just updating the
7857 address doesn't accomplish anything, because we already assume
7858 that anything after the last address is this line. */
7859 if (line_info->dw_line_num == current_line
7860 && line_info->dw_file_num == current_file)
7864 /* Emit debug info for the address of the current line.
7866 Unfortunately, we have little choice here currently, and must always
7867 use the most general form. GCC does not know the address delta
7868 itself, so we can't use DW_LNS_advance_pc. Many ports do have length
7869 attributes which will give an upper bound on the address range. We
7870 could perhaps use length attributes to determine when it is safe to
7871 use DW_LNS_fixed_advance_pc. */
7873 ASM_GENERATE_INTERNAL_LABEL (line_label, LINE_CODE_LABEL, lt_index);
7876 /* This can handle deltas up to 0xffff. This takes 3 bytes. */
7877 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
7878 "DW_LNS_fixed_advance_pc");
7879 dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
7883 /* This can handle any delta. This takes
7884 4+DWARF2_ADDR_SIZE bytes. */
7885 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
7886 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
7887 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
7888 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
7891 strcpy (prev_line_label, line_label);
7893 /* Emit debug info for the source file of the current line, if
7894 different from the previous line. */
7895 if (line_info->dw_file_num != current_file)
7897 current_file = line_info->dw_file_num;
7898 dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file");
7899 dw2_asm_output_data_uleb128 (current_file, "(\"%s\")",
7900 VARRAY_CHAR_PTR (file_table,
7904 /* Emit debug info for the current line number, choosing the encoding
7905 that uses the least amount of space. */
7906 if (line_info->dw_line_num != current_line)
7908 line_offset = line_info->dw_line_num - current_line;
7909 line_delta = line_offset - DWARF_LINE_BASE;
7910 current_line = line_info->dw_line_num;
7911 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
7912 /* This can handle deltas from -10 to 234, using the current
7913 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE. This
7915 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
7916 "line %lu", current_line);
7919 /* This can handle any delta. This takes at least 4 bytes,
7920 depending on the value being encoded. */
7921 dw2_asm_output_data (1, DW_LNS_advance_line,
7922 "advance to line %lu", current_line);
7923 dw2_asm_output_data_sleb128 (line_offset, NULL);
7924 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
7928 /* We still need to start a new row, so output a copy insn. */
7929 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
7932 /* Emit debug info for the address of the end of the function. */
7935 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
7936 "DW_LNS_fixed_advance_pc");
7937 dw2_asm_output_delta (2, text_end_label, prev_line_label, NULL);
7941 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
7942 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
7943 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
7944 dw2_asm_output_addr (DWARF2_ADDR_SIZE, text_end_label, NULL);
7947 dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
7948 dw2_asm_output_data_uleb128 (1, NULL);
7949 dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
7954 for (lt_index = 0; lt_index < separate_line_info_table_in_use;)
7956 dw_separate_line_info_ref line_info
7957 = &separate_line_info_table[lt_index];
7960 /* Don't emit anything for redundant notes. */
7961 if (line_info->dw_line_num == current_line
7962 && line_info->dw_file_num == current_file
7963 && line_info->function == function)
7967 /* Emit debug info for the address of the current line. If this is
7968 a new function, or the first line of a function, then we need
7969 to handle it differently. */
7970 ASM_GENERATE_INTERNAL_LABEL (line_label, SEPARATE_LINE_CODE_LABEL,
7972 if (function != line_info->function)
7974 function = line_info->function;
7976 /* Set the address register to the first line in the function. */
7977 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
7978 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
7979 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
7980 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
7984 /* ??? See the DW_LNS_advance_pc comment above. */
7987 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
7988 "DW_LNS_fixed_advance_pc");
7989 dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
7993 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
7994 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
7995 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
7996 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
8000 strcpy (prev_line_label, line_label);
8002 /* Emit debug info for the source file of the current line, if
8003 different from the previous line. */
8004 if (line_info->dw_file_num != current_file)
8006 current_file = line_info->dw_file_num;
8007 dw2_asm_output_data (1, DW_LNS_set_file, "DW_LNS_set_file");
8008 dw2_asm_output_data_uleb128 (current_file, "(\"%s\")",
8009 VARRAY_CHAR_PTR (file_table,
8013 /* Emit debug info for the current line number, choosing the encoding
8014 that uses the least amount of space. */
8015 if (line_info->dw_line_num != current_line)
8017 line_offset = line_info->dw_line_num - current_line;
8018 line_delta = line_offset - DWARF_LINE_BASE;
8019 current_line = line_info->dw_line_num;
8020 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
8021 dw2_asm_output_data (1, DWARF_LINE_OPCODE_BASE + line_delta,
8022 "line %lu", current_line);
8025 dw2_asm_output_data (1, DW_LNS_advance_line,
8026 "advance to line %lu", current_line);
8027 dw2_asm_output_data_sleb128 (line_offset, NULL);
8028 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
8032 dw2_asm_output_data (1, DW_LNS_copy, "DW_LNS_copy");
8040 /* If we're done with a function, end its sequence. */
8041 if (lt_index == separate_line_info_table_in_use
8042 || separate_line_info_table[lt_index].function != function)
8047 /* Emit debug info for the address of the end of the function. */
8048 ASM_GENERATE_INTERNAL_LABEL (line_label, FUNC_END_LABEL, function);
8051 dw2_asm_output_data (1, DW_LNS_fixed_advance_pc,
8052 "DW_LNS_fixed_advance_pc");
8053 dw2_asm_output_delta (2, line_label, prev_line_label, NULL);
8057 dw2_asm_output_data (1, 0, "DW_LNE_set_address");
8058 dw2_asm_output_data_uleb128 (1 + DWARF2_ADDR_SIZE, NULL);
8059 dw2_asm_output_data (1, DW_LNE_set_address, NULL);
8060 dw2_asm_output_addr (DWARF2_ADDR_SIZE, line_label, NULL);
8063 /* Output the marker for the end of this sequence. */
8064 dw2_asm_output_data (1, 0, "DW_LNE_end_sequence");
8065 dw2_asm_output_data_uleb128 (1, NULL);
8066 dw2_asm_output_data (1, DW_LNE_end_sequence, NULL);
8070 /* Output the marker for the end of the line number info. */
8071 ASM_OUTPUT_LABEL (asm_out_file, l2);
8074 /* Given a pointer to a tree node for some base type, return a pointer to
8075 a DIE that describes the given type.
8077 This routine must only be called for GCC type nodes that correspond to
8078 Dwarf base (fundamental) types. */
8081 base_type_die (tree type)
8083 dw_die_ref base_type_result;
8084 const char *type_name;
8085 enum dwarf_type encoding;
8086 tree name = TYPE_NAME (type);
8088 if (TREE_CODE (type) == ERROR_MARK || TREE_CODE (type) == VOID_TYPE)
8093 if (TREE_CODE (name) == TYPE_DECL)
8094 name = DECL_NAME (name);
8096 type_name = IDENTIFIER_POINTER (name);
8099 type_name = "__unknown__";
8101 switch (TREE_CODE (type))
8104 /* Carefully distinguish the C character types, without messing
8105 up if the language is not C. Note that we check only for the names
8106 that contain spaces; other names might occur by coincidence in other
8108 if (! (TYPE_PRECISION (type) == CHAR_TYPE_SIZE
8109 && (TYPE_MAIN_VARIANT (type) == char_type_node
8110 || ! strcmp (type_name, "signed char")
8111 || ! strcmp (type_name, "unsigned char"))))
8113 if (TYPE_UNSIGNED (type))
8114 encoding = DW_ATE_unsigned;
8116 encoding = DW_ATE_signed;
8119 /* else fall through. */
8122 /* GNU Pascal/Ada CHAR type. Not used in C. */
8123 if (TYPE_UNSIGNED (type))
8124 encoding = DW_ATE_unsigned_char;
8126 encoding = DW_ATE_signed_char;
8130 encoding = DW_ATE_float;
8133 /* Dwarf2 doesn't know anything about complex ints, so use
8134 a user defined type for it. */
8136 if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
8137 encoding = DW_ATE_complex_float;
8139 encoding = DW_ATE_lo_user;
8143 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */
8144 encoding = DW_ATE_boolean;
8148 /* No other TREE_CODEs are Dwarf fundamental types. */
8152 base_type_result = new_die (DW_TAG_base_type, comp_unit_die, type);
8153 if (demangle_name_func)
8154 type_name = (*demangle_name_func) (type_name);
8156 add_AT_string (base_type_result, DW_AT_name, type_name);
8157 add_AT_unsigned (base_type_result, DW_AT_byte_size,
8158 int_size_in_bytes (type));
8159 add_AT_unsigned (base_type_result, DW_AT_encoding, encoding);
8161 return base_type_result;
8164 /* Given a pointer to an arbitrary ..._TYPE tree node, return a pointer to
8165 the Dwarf "root" type for the given input type. The Dwarf "root" type of
8166 a given type is generally the same as the given type, except that if the
8167 given type is a pointer or reference type, then the root type of the given
8168 type is the root type of the "basis" type for the pointer or reference
8169 type. (This definition of the "root" type is recursive.) Also, the root
8170 type of a `const' qualified type or a `volatile' qualified type is the
8171 root type of the given type without the qualifiers. */
8174 root_type (tree type)
8176 if (TREE_CODE (type) == ERROR_MARK)
8177 return error_mark_node;
8179 switch (TREE_CODE (type))
8182 return error_mark_node;
8185 case REFERENCE_TYPE:
8186 return type_main_variant (root_type (TREE_TYPE (type)));
8189 return type_main_variant (type);
8193 /* Given a pointer to an arbitrary ..._TYPE tree node, return nonzero if the
8194 given input type is a Dwarf "fundamental" type. Otherwise return null. */
8197 is_base_type (tree type)
8199 switch (TREE_CODE (type))
8213 case QUAL_UNION_TYPE:
8218 case REFERENCE_TYPE:
8231 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
8232 node, return the size in bits for the type if it is a constant, or else
8233 return the alignment for the type if the type's size is not constant, or
8234 else return BITS_PER_WORD if the type actually turns out to be an
8237 static inline unsigned HOST_WIDE_INT
8238 simple_type_size_in_bits (tree type)
8240 if (TREE_CODE (type) == ERROR_MARK)
8241 return BITS_PER_WORD;
8242 else if (TYPE_SIZE (type) == NULL_TREE)
8244 else if (host_integerp (TYPE_SIZE (type), 1))
8245 return tree_low_cst (TYPE_SIZE (type), 1);
8247 return TYPE_ALIGN (type);
8250 /* Return true if the debug information for the given type should be
8251 emitted as a subrange type. */
8254 is_subrange_type (tree type)
8256 tree subtype = TREE_TYPE (type);
8258 /* Subrange types are identified by the fact that they are integer
8259 types, and that they have a subtype which is either an integer type
8260 or an enumeral type. */
8262 if (TREE_CODE (type) != INTEGER_TYPE
8263 || subtype == NULL_TREE)
8266 if (TREE_CODE (subtype) != INTEGER_TYPE
8267 && TREE_CODE (subtype) != ENUMERAL_TYPE)
8270 if (TREE_CODE (type) == TREE_CODE (subtype)
8271 && int_size_in_bytes (type) == int_size_in_bytes (subtype)
8272 && TYPE_MIN_VALUE (type) != NULL
8273 && TYPE_MIN_VALUE (subtype) != NULL
8274 && tree_int_cst_equal (TYPE_MIN_VALUE (type), TYPE_MIN_VALUE (subtype))
8275 && TYPE_MAX_VALUE (type) != NULL
8276 && TYPE_MAX_VALUE (subtype) != NULL
8277 && tree_int_cst_equal (TYPE_MAX_VALUE (type), TYPE_MAX_VALUE (subtype)))
8279 /* The type and its subtype have the same representation. If in
8280 addition the two types also have the same name, then the given
8281 type is not a subrange type, but rather a plain base type. */
8282 /* FIXME: brobecker/2004-03-22:
8283 Sizetype INTEGER_CSTs nodes are canonicalized. It should
8284 therefore be sufficient to check the TYPE_SIZE node pointers
8285 rather than checking the actual size. Unfortunately, we have
8286 found some cases, such as in the Ada "integer" type, where
8287 this is not the case. Until this problem is solved, we need to
8288 keep checking the actual size. */
8289 tree type_name = TYPE_NAME (type);
8290 tree subtype_name = TYPE_NAME (subtype);
8292 if (type_name != NULL && TREE_CODE (type_name) == TYPE_DECL)
8293 type_name = DECL_NAME (type_name);
8295 if (subtype_name != NULL && TREE_CODE (subtype_name) == TYPE_DECL)
8296 subtype_name = DECL_NAME (subtype_name);
8298 if (type_name == subtype_name)
8305 /* Given a pointer to a tree node for a subrange type, return a pointer
8306 to a DIE that describes the given type. */
8309 subrange_type_die (tree type, dw_die_ref context_die)
8311 dw_die_ref subtype_die;
8312 dw_die_ref subrange_die;
8313 tree name = TYPE_NAME (type);
8314 const HOST_WIDE_INT size_in_bytes = int_size_in_bytes (type);
8315 tree subtype = TREE_TYPE (type);
8317 if (context_die == NULL)
8318 context_die = comp_unit_die;
8320 if (TREE_CODE (subtype) == ENUMERAL_TYPE)
8321 subtype_die = gen_enumeration_type_die (subtype, context_die);
8323 subtype_die = base_type_die (subtype);
8325 subrange_die = new_die (DW_TAG_subrange_type, context_die, type);
8329 if (TREE_CODE (name) == TYPE_DECL)
8330 name = DECL_NAME (name);
8331 add_name_attribute (subrange_die, IDENTIFIER_POINTER (name));
8334 if (int_size_in_bytes (subtype) != size_in_bytes)
8336 /* The size of the subrange type and its base type do not match,
8337 so we need to generate a size attribute for the subrange type. */
8338 add_AT_unsigned (subrange_die, DW_AT_byte_size, size_in_bytes);
8341 if (TYPE_MIN_VALUE (type) != NULL)
8342 add_bound_info (subrange_die, DW_AT_lower_bound,
8343 TYPE_MIN_VALUE (type));
8344 if (TYPE_MAX_VALUE (type) != NULL)
8345 add_bound_info (subrange_die, DW_AT_upper_bound,
8346 TYPE_MAX_VALUE (type));
8347 add_AT_die_ref (subrange_die, DW_AT_type, subtype_die);
8349 return subrange_die;
8352 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
8353 entry that chains various modifiers in front of the given type. */
8356 modified_type_die (tree type, int is_const_type, int is_volatile_type,
8357 dw_die_ref context_die)
8359 enum tree_code code = TREE_CODE (type);
8360 dw_die_ref mod_type_die = NULL;
8361 dw_die_ref sub_die = NULL;
8362 tree item_type = NULL;
8364 if (code != ERROR_MARK)
8366 tree qualified_type;
8368 /* See if we already have the appropriately qualified variant of
8371 = get_qualified_type (type,
8372 ((is_const_type ? TYPE_QUAL_CONST : 0)
8374 ? TYPE_QUAL_VOLATILE : 0)));
8376 /* If we do, then we can just use its DIE, if it exists. */
8379 mod_type_die = lookup_type_die (qualified_type);
8381 return mod_type_die;
8384 /* Handle C typedef types. */
8385 if (qualified_type && TYPE_NAME (qualified_type)
8386 && TREE_CODE (TYPE_NAME (qualified_type)) == TYPE_DECL
8387 && DECL_ORIGINAL_TYPE (TYPE_NAME (qualified_type)))
8389 tree type_name = TYPE_NAME (qualified_type);
8390 tree dtype = TREE_TYPE (type_name);
8392 if (qualified_type == dtype)
8394 /* For a named type, use the typedef. */
8395 gen_type_die (qualified_type, context_die);
8396 mod_type_die = lookup_type_die (qualified_type);
8398 else if (is_const_type < TYPE_READONLY (dtype)
8399 || is_volatile_type < TYPE_VOLATILE (dtype))
8400 /* cv-unqualified version of named type. Just use the unnamed
8401 type to which it refers. */
8403 = modified_type_die (DECL_ORIGINAL_TYPE (type_name),
8404 is_const_type, is_volatile_type,
8407 /* Else cv-qualified version of named type; fall through. */
8413 else if (is_const_type)
8415 mod_type_die = new_die (DW_TAG_const_type, comp_unit_die, type);
8416 sub_die = modified_type_die (type, 0, is_volatile_type, context_die);
8418 else if (is_volatile_type)
8420 mod_type_die = new_die (DW_TAG_volatile_type, comp_unit_die, type);
8421 sub_die = modified_type_die (type, 0, 0, context_die);
8423 else if (code == POINTER_TYPE)
8425 mod_type_die = new_die (DW_TAG_pointer_type, comp_unit_die, type);
8426 add_AT_unsigned (mod_type_die, DW_AT_byte_size,
8427 simple_type_size_in_bits (type) / BITS_PER_UNIT);
8429 add_AT_unsigned (mod_type_die, DW_AT_address_class, 0);
8431 item_type = TREE_TYPE (type);
8433 else if (code == REFERENCE_TYPE)
8435 mod_type_die = new_die (DW_TAG_reference_type, comp_unit_die, type);
8436 add_AT_unsigned (mod_type_die, DW_AT_byte_size,
8437 simple_type_size_in_bits (type) / BITS_PER_UNIT);
8439 add_AT_unsigned (mod_type_die, DW_AT_address_class, 0);
8441 item_type = TREE_TYPE (type);
8443 else if (is_subrange_type (type))
8444 mod_type_die = subrange_type_die (type, context_die);
8445 else if (is_base_type (type))
8446 mod_type_die = base_type_die (type);
8449 gen_type_die (type, context_die);
8451 /* We have to get the type_main_variant here (and pass that to the
8452 `lookup_type_die' routine) because the ..._TYPE node we have
8453 might simply be a *copy* of some original type node (where the
8454 copy was created to help us keep track of typedef names) and
8455 that copy might have a different TYPE_UID from the original
8457 if (TREE_CODE (type) != VECTOR_TYPE)
8458 mod_type_die = lookup_type_die (type_main_variant (type));
8460 /* Vectors have the debugging information in the type,
8461 not the main variant. */
8462 mod_type_die = lookup_type_die (type);
8463 gcc_assert (mod_type_die);
8466 /* We want to equate the qualified type to the die below. */
8467 type = qualified_type;
8471 equate_type_number_to_die (type, mod_type_die);
8473 /* We must do this after the equate_type_number_to_die call, in case
8474 this is a recursive type. This ensures that the modified_type_die
8475 recursion will terminate even if the type is recursive. Recursive
8476 types are possible in Ada. */
8477 sub_die = modified_type_die (item_type,
8478 TYPE_READONLY (item_type),
8479 TYPE_VOLATILE (item_type),
8482 if (sub_die != NULL)
8483 add_AT_die_ref (mod_type_die, DW_AT_type, sub_die);
8485 return mod_type_die;
8488 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
8489 an enumerated type. */
8492 type_is_enum (tree type)
8494 return TREE_CODE (type) == ENUMERAL_TYPE;
8497 /* Return the DBX register number described by a given RTL node. */
8500 dbx_reg_number (rtx rtl)
8502 unsigned regno = REGNO (rtl);
8504 gcc_assert (regno < FIRST_PSEUDO_REGISTER);
8506 #ifdef LEAF_REG_REMAP
8507 regno = LEAF_REG_REMAP (regno);
8510 return DBX_REGISTER_NUMBER (regno);
8513 /* Optionally add a DW_OP_piece term to a location description expression.
8514 DW_OP_piece is only added if the location description expression already
8515 doesn't end with DW_OP_piece. */
8518 add_loc_descr_op_piece (dw_loc_descr_ref *list_head, int size)
8520 dw_loc_descr_ref loc;
8522 if (*list_head != NULL)
8524 /* Find the end of the chain. */
8525 for (loc = *list_head; loc->dw_loc_next != NULL; loc = loc->dw_loc_next)
8528 if (loc->dw_loc_opc != DW_OP_piece)
8529 loc->dw_loc_next = new_loc_descr (DW_OP_piece, size, 0);
8533 /* Return a location descriptor that designates a machine register or
8534 zero if there is none. */
8536 static dw_loc_descr_ref
8537 reg_loc_descriptor (rtx rtl)
8541 if (REGNO (rtl) >= FIRST_PSEUDO_REGISTER)
8544 regs = targetm.dwarf_register_span (rtl);
8546 if (hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)] > 1 || regs)
8547 return multiple_reg_loc_descriptor (rtl, regs);
8549 return one_reg_loc_descriptor (dbx_reg_number (rtl));
8552 /* Return a location descriptor that designates a machine register for
8553 a given hard register number. */
8555 static dw_loc_descr_ref
8556 one_reg_loc_descriptor (unsigned int regno)
8559 return new_loc_descr (DW_OP_reg0 + regno, 0, 0);
8561 return new_loc_descr (DW_OP_regx, regno, 0);
8564 /* Given an RTL of a register, return a location descriptor that
8565 designates a value that spans more than one register. */
8567 static dw_loc_descr_ref
8568 multiple_reg_loc_descriptor (rtx rtl, rtx regs)
8572 dw_loc_descr_ref loc_result = NULL;
8575 #ifdef LEAF_REG_REMAP
8576 reg = LEAF_REG_REMAP (reg);
8578 gcc_assert ((unsigned) DBX_REGISTER_NUMBER (reg) == dbx_reg_number (rtl));
8579 nregs = hard_regno_nregs[REGNO (rtl)][GET_MODE (rtl)];
8581 /* Simple, contiguous registers. */
8582 if (regs == NULL_RTX)
8584 size = GET_MODE_SIZE (GET_MODE (rtl)) / nregs;
8591 t = one_reg_loc_descriptor (DBX_REGISTER_NUMBER (reg));
8592 add_loc_descr (&loc_result, t);
8593 add_loc_descr_op_piece (&loc_result, size);
8599 /* Now onto stupid register sets in non contiguous locations. */
8601 gcc_assert (GET_CODE (regs) == PARALLEL);
8603 size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
8606 for (i = 0; i < XVECLEN (regs, 0); ++i)
8610 t = one_reg_loc_descriptor (REGNO (XVECEXP (regs, 0, i)));
8611 add_loc_descr (&loc_result, t);
8612 size = GET_MODE_SIZE (GET_MODE (XVECEXP (regs, 0, 0)));
8613 add_loc_descr_op_piece (&loc_result, size);
8618 /* Return a location descriptor that designates a constant. */
8620 static dw_loc_descr_ref
8621 int_loc_descriptor (HOST_WIDE_INT i)
8623 enum dwarf_location_atom op;
8625 /* Pick the smallest representation of a constant, rather than just
8626 defaulting to the LEB encoding. */
8630 op = DW_OP_lit0 + i;
8633 else if (i <= 0xffff)
8635 else if (HOST_BITS_PER_WIDE_INT == 32
8645 else if (i >= -0x8000)
8647 else if (HOST_BITS_PER_WIDE_INT == 32
8648 || i >= -0x80000000)
8654 return new_loc_descr (op, i, 0);
8657 /* Return a location descriptor that designates a base+offset location. */
8659 static dw_loc_descr_ref
8660 based_loc_descr (rtx reg, HOST_WIDE_INT offset)
8664 /* We only use "frame base" when we're sure we're talking about the
8665 post-prologue local stack frame. We do this by *not* running
8666 register elimination until this point, and recognizing the special
8667 argument pointer and soft frame pointer rtx's. */
8668 if (reg == arg_pointer_rtx || reg == frame_pointer_rtx)
8670 rtx elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
8674 if (GET_CODE (elim) == PLUS)
8676 offset += INTVAL (XEXP (elim, 1));
8677 elim = XEXP (elim, 0);
8679 gcc_assert (elim == (frame_pointer_needed ? hard_frame_pointer_rtx
8680 : stack_pointer_rtx));
8681 offset += frame_pointer_cfa_offset;
8683 return new_loc_descr (DW_OP_fbreg, offset, 0);
8687 regno = dbx_reg_number (reg);
8689 return new_loc_descr (DW_OP_breg0 + regno, offset, 0);
8691 return new_loc_descr (DW_OP_bregx, regno, offset);
8694 /* Return true if this RTL expression describes a base+offset calculation. */
8697 is_based_loc (rtx rtl)
8699 return (GET_CODE (rtl) == PLUS
8700 && ((REG_P (XEXP (rtl, 0))
8701 && REGNO (XEXP (rtl, 0)) < FIRST_PSEUDO_REGISTER
8702 && GET_CODE (XEXP (rtl, 1)) == CONST_INT)));
8705 /* The following routine converts the RTL for a variable or parameter
8706 (resident in memory) into an equivalent Dwarf representation of a
8707 mechanism for getting the address of that same variable onto the top of a
8708 hypothetical "address evaluation" stack.
8710 When creating memory location descriptors, we are effectively transforming
8711 the RTL for a memory-resident object into its Dwarf postfix expression
8712 equivalent. This routine recursively descends an RTL tree, turning
8713 it into Dwarf postfix code as it goes.
8715 MODE is the mode of the memory reference, needed to handle some
8716 autoincrement addressing modes.
8718 CAN_USE_FBREG is a flag whether we can use DW_AT_frame_base in the
8719 location list for RTL.
8721 Return 0 if we can't represent the location. */
8723 static dw_loc_descr_ref
8724 mem_loc_descriptor (rtx rtl, enum machine_mode mode)
8726 dw_loc_descr_ref mem_loc_result = NULL;
8727 enum dwarf_location_atom op;
8729 /* Note that for a dynamically sized array, the location we will generate a
8730 description of here will be the lowest numbered location which is
8731 actually within the array. That's *not* necessarily the same as the
8732 zeroth element of the array. */
8734 rtl = targetm.delegitimize_address (rtl);
8736 switch (GET_CODE (rtl))
8741 /* POST_INC and POST_DEC can be handled just like a SUBREG. So we
8742 just fall into the SUBREG code. */
8744 /* ... fall through ... */
8747 /* The case of a subreg may arise when we have a local (register)
8748 variable or a formal (register) parameter which doesn't quite fill
8749 up an entire register. For now, just assume that it is
8750 legitimate to make the Dwarf info refer to the whole register which
8751 contains the given subreg. */
8752 rtl = XEXP (rtl, 0);
8754 /* ... fall through ... */
8757 /* Whenever a register number forms a part of the description of the
8758 method for calculating the (dynamic) address of a memory resident
8759 object, DWARF rules require the register number be referred to as
8760 a "base register". This distinction is not based in any way upon
8761 what category of register the hardware believes the given register
8762 belongs to. This is strictly DWARF terminology we're dealing with
8763 here. Note that in cases where the location of a memory-resident
8764 data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
8765 OP_CONST (0)) the actual DWARF location descriptor that we generate
8766 may just be OP_BASEREG (basereg). This may look deceptively like
8767 the object in question was allocated to a register (rather than in
8768 memory) so DWARF consumers need to be aware of the subtle
8769 distinction between OP_REG and OP_BASEREG. */
8770 if (REGNO (rtl) < FIRST_PSEUDO_REGISTER)
8771 mem_loc_result = based_loc_descr (rtl, 0);
8775 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl));
8776 if (mem_loc_result != 0)
8777 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_deref, 0, 0));
8781 rtl = XEXP (rtl, 1);
8783 /* ... fall through ... */
8786 /* Some ports can transform a symbol ref into a label ref, because
8787 the symbol ref is too far away and has to be dumped into a constant
8791 /* Alternatively, the symbol in the constant pool might be referenced
8792 by a different symbol. */
8793 if (GET_CODE (rtl) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P (rtl))
8796 rtx tmp = get_pool_constant_mark (rtl, &marked);
8798 if (GET_CODE (tmp) == SYMBOL_REF)
8801 if (CONSTANT_POOL_ADDRESS_P (tmp))
8802 get_pool_constant_mark (tmp, &marked);
8807 /* If all references to this pool constant were optimized away,
8808 it was not output and thus we can't represent it.
8809 FIXME: might try to use DW_OP_const_value here, though
8810 DW_OP_piece complicates it. */
8815 mem_loc_result = new_loc_descr (DW_OP_addr, 0, 0);
8816 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_addr;
8817 mem_loc_result->dw_loc_oprnd1.v.val_addr = rtl;
8818 VEC_safe_push (rtx, gc, used_rtx_array, rtl);
8822 /* Extract the PLUS expression nested inside and fall into
8824 rtl = XEXP (rtl, 1);
8829 /* Turn these into a PLUS expression and fall into the PLUS code
8831 rtl = gen_rtx_PLUS (word_mode, XEXP (rtl, 0),
8832 GEN_INT (GET_CODE (rtl) == PRE_INC
8833 ? GET_MODE_UNIT_SIZE (mode)
8834 : -GET_MODE_UNIT_SIZE (mode)));
8836 /* ... fall through ... */
8840 if (is_based_loc (rtl))
8841 mem_loc_result = based_loc_descr (XEXP (rtl, 0),
8842 INTVAL (XEXP (rtl, 1)));
8845 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), mode);
8846 if (mem_loc_result == 0)
8849 if (GET_CODE (XEXP (rtl, 1)) == CONST_INT
8850 && INTVAL (XEXP (rtl, 1)) >= 0)
8851 add_loc_descr (&mem_loc_result,
8852 new_loc_descr (DW_OP_plus_uconst,
8853 INTVAL (XEXP (rtl, 1)), 0));
8856 add_loc_descr (&mem_loc_result,
8857 mem_loc_descriptor (XEXP (rtl, 1), mode));
8858 add_loc_descr (&mem_loc_result,
8859 new_loc_descr (DW_OP_plus, 0, 0));
8864 /* If a pseudo-reg is optimized away, it is possible for it to
8865 be replaced with a MEM containing a multiply or shift. */
8884 dw_loc_descr_ref op0 = mem_loc_descriptor (XEXP (rtl, 0), mode);
8885 dw_loc_descr_ref op1 = mem_loc_descriptor (XEXP (rtl, 1), mode);
8887 if (op0 == 0 || op1 == 0)
8890 mem_loc_result = op0;
8891 add_loc_descr (&mem_loc_result, op1);
8892 add_loc_descr (&mem_loc_result, new_loc_descr (op, 0, 0));
8897 mem_loc_result = int_loc_descriptor (INTVAL (rtl));
8904 return mem_loc_result;
8907 /* Return a descriptor that describes the concatenation of two locations.
8908 This is typically a complex variable. */
8910 static dw_loc_descr_ref
8911 concat_loc_descriptor (rtx x0, rtx x1)
8913 dw_loc_descr_ref cc_loc_result = NULL;
8914 dw_loc_descr_ref x0_ref = loc_descriptor (x0);
8915 dw_loc_descr_ref x1_ref = loc_descriptor (x1);
8917 if (x0_ref == 0 || x1_ref == 0)
8920 cc_loc_result = x0_ref;
8921 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x0)));
8923 add_loc_descr (&cc_loc_result, x1_ref);
8924 add_loc_descr_op_piece (&cc_loc_result, GET_MODE_SIZE (GET_MODE (x1)));
8926 return cc_loc_result;
8929 /* Output a proper Dwarf location descriptor for a variable or parameter
8930 which is either allocated in a register or in a memory location. For a
8931 register, we just generate an OP_REG and the register number. For a
8932 memory location we provide a Dwarf postfix expression describing how to
8933 generate the (dynamic) address of the object onto the address stack.
8935 If we don't know how to describe it, return 0. */
8937 static dw_loc_descr_ref
8938 loc_descriptor (rtx rtl)
8940 dw_loc_descr_ref loc_result = NULL;
8942 switch (GET_CODE (rtl))
8945 /* The case of a subreg may arise when we have a local (register)
8946 variable or a formal (register) parameter which doesn't quite fill
8947 up an entire register. For now, just assume that it is
8948 legitimate to make the Dwarf info refer to the whole register which
8949 contains the given subreg. */
8950 rtl = SUBREG_REG (rtl);
8952 /* ... fall through ... */
8955 loc_result = reg_loc_descriptor (rtl);
8959 loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl));
8963 loc_result = concat_loc_descriptor (XEXP (rtl, 0), XEXP (rtl, 1));
8968 if (GET_CODE (XEXP (rtl, 1)) != PARALLEL)
8970 loc_result = loc_descriptor (XEXP (XEXP (rtl, 1), 0));
8974 rtl = XEXP (rtl, 1);
8979 rtvec par_elems = XVEC (rtl, 0);
8980 int num_elem = GET_NUM_ELEM (par_elems);
8981 enum machine_mode mode;
8984 /* Create the first one, so we have something to add to. */
8985 loc_result = loc_descriptor (XEXP (RTVEC_ELT (par_elems, 0), 0));
8986 mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, 0), 0));
8987 add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
8988 for (i = 1; i < num_elem; i++)
8990 dw_loc_descr_ref temp;
8992 temp = loc_descriptor (XEXP (RTVEC_ELT (par_elems, i), 0));
8993 add_loc_descr (&loc_result, temp);
8994 mode = GET_MODE (XEXP (RTVEC_ELT (par_elems, i), 0));
8995 add_loc_descr_op_piece (&loc_result, GET_MODE_SIZE (mode));
9007 /* Similar, but generate the descriptor from trees instead of rtl. This comes
9008 up particularly with variable length arrays. WANT_ADDRESS is 2 if this is
9009 a top-level invocation of loc_descriptor_from_tree; is 1 if this is not a
9010 top-level invocation, and we require the address of LOC; is 0 if we require
9011 the value of LOC. */
9013 static dw_loc_descr_ref
9014 loc_descriptor_from_tree_1 (tree loc, int want_address)
9016 dw_loc_descr_ref ret, ret1;
9017 int have_address = 0;
9018 int unsignedp = TYPE_UNSIGNED (TREE_TYPE (loc));
9019 enum dwarf_location_atom op;
9021 /* ??? Most of the time we do not take proper care for sign/zero
9022 extending the values properly. Hopefully this won't be a real
9025 switch (TREE_CODE (loc))
9030 case PLACEHOLDER_EXPR:
9031 /* This case involves extracting fields from an object to determine the
9032 position of other fields. We don't try to encode this here. The
9033 only user of this is Ada, which encodes the needed information using
9034 the names of types. */
9040 case PREINCREMENT_EXPR:
9041 case PREDECREMENT_EXPR:
9042 case POSTINCREMENT_EXPR:
9043 case POSTDECREMENT_EXPR:
9044 /* There are no opcodes for these operations. */
9048 /* If we already want an address, there's nothing we can do. */
9052 /* Otherwise, process the argument and look for the address. */
9053 return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 1);
9056 if (DECL_THREAD_LOCAL_P (loc))
9060 /* If this is not defined, we have no way to emit the data. */
9061 if (!targetm.asm_out.output_dwarf_dtprel)
9064 /* The way DW_OP_GNU_push_tls_address is specified, we can only
9065 look up addresses of objects in the current module. */
9066 if (DECL_EXTERNAL (loc))
9069 rtl = rtl_for_decl_location (loc);
9070 if (rtl == NULL_RTX)
9075 rtl = XEXP (rtl, 0);
9076 if (! CONSTANT_P (rtl))
9079 ret = new_loc_descr (INTERNAL_DW_OP_tls_addr, 0, 0);
9080 ret->dw_loc_oprnd1.val_class = dw_val_class_addr;
9081 ret->dw_loc_oprnd1.v.val_addr = rtl;
9083 ret1 = new_loc_descr (DW_OP_GNU_push_tls_address, 0, 0);
9084 add_loc_descr (&ret, ret1);
9092 if (DECL_HAS_VALUE_EXPR_P (loc))
9093 return loc_descriptor_from_tree_1 (DECL_VALUE_EXPR (loc),
9099 rtx rtl = rtl_for_decl_location (loc);
9101 if (rtl == NULL_RTX)
9103 else if (GET_CODE (rtl) == CONST_INT)
9105 HOST_WIDE_INT val = INTVAL (rtl);
9106 if (TYPE_UNSIGNED (TREE_TYPE (loc)))
9107 val &= GET_MODE_MASK (DECL_MODE (loc));
9108 ret = int_loc_descriptor (val);
9110 else if (GET_CODE (rtl) == CONST_STRING)
9112 else if (CONSTANT_P (rtl))
9114 ret = new_loc_descr (DW_OP_addr, 0, 0);
9115 ret->dw_loc_oprnd1.val_class = dw_val_class_addr;
9116 ret->dw_loc_oprnd1.v.val_addr = rtl;
9120 enum machine_mode mode;
9122 /* Certain constructs can only be represented at top-level. */
9123 if (want_address == 2)
9124 return loc_descriptor (rtl);
9126 mode = GET_MODE (rtl);
9129 rtl = XEXP (rtl, 0);
9132 ret = mem_loc_descriptor (rtl, mode);
9138 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9143 return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), want_address);
9147 case NON_LVALUE_EXPR:
9148 case VIEW_CONVERT_EXPR:
9151 return loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), want_address);
9156 case ARRAY_RANGE_REF:
9159 HOST_WIDE_INT bitsize, bitpos, bytepos;
9160 enum machine_mode mode;
9163 obj = get_inner_reference (loc, &bitsize, &bitpos, &offset, &mode,
9164 &unsignedp, &volatilep, false);
9169 ret = loc_descriptor_from_tree_1 (obj, 1);
9171 || bitpos % BITS_PER_UNIT != 0 || bitsize % BITS_PER_UNIT != 0)
9174 if (offset != NULL_TREE)
9176 /* Variable offset. */
9177 add_loc_descr (&ret, loc_descriptor_from_tree_1 (offset, 0));
9178 add_loc_descr (&ret, new_loc_descr (DW_OP_plus, 0, 0));
9181 bytepos = bitpos / BITS_PER_UNIT;
9183 add_loc_descr (&ret, new_loc_descr (DW_OP_plus_uconst, bytepos, 0));
9184 else if (bytepos < 0)
9186 add_loc_descr (&ret, int_loc_descriptor (bytepos));
9187 add_loc_descr (&ret, new_loc_descr (DW_OP_plus, 0, 0));
9195 if (host_integerp (loc, 0))
9196 ret = int_loc_descriptor (tree_low_cst (loc, 0));
9203 /* Get an RTL for this, if something has been emitted. */
9204 rtx rtl = lookup_constant_def (loc);
9205 enum machine_mode mode;
9207 if (!rtl || !MEM_P (rtl))
9209 mode = GET_MODE (rtl);
9210 rtl = XEXP (rtl, 0);
9211 ret = mem_loc_descriptor (rtl, mode);
9216 case TRUTH_AND_EXPR:
9217 case TRUTH_ANDIF_EXPR:
9222 case TRUTH_XOR_EXPR:
9228 case TRUTH_ORIF_EXPR:
9233 case FLOOR_DIV_EXPR:
9235 case ROUND_DIV_EXPR:
9236 case TRUNC_DIV_EXPR:
9244 case FLOOR_MOD_EXPR:
9246 case ROUND_MOD_EXPR:
9247 case TRUNC_MOD_EXPR:
9260 op = (unsignedp ? DW_OP_shr : DW_OP_shra);
9264 if (TREE_CODE (TREE_OPERAND (loc, 1)) == INTEGER_CST
9265 && host_integerp (TREE_OPERAND (loc, 1), 0))
9267 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9271 add_loc_descr (&ret,
9272 new_loc_descr (DW_OP_plus_uconst,
9273 tree_low_cst (TREE_OPERAND (loc, 1),
9283 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
9290 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
9297 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
9304 if (TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (loc, 0))))
9319 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9320 ret1 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), 0);
9321 if (ret == 0 || ret1 == 0)
9324 add_loc_descr (&ret, ret1);
9325 add_loc_descr (&ret, new_loc_descr (op, 0, 0));
9328 case TRUTH_NOT_EXPR:
9342 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9346 add_loc_descr (&ret, new_loc_descr (op, 0, 0));
9352 const enum tree_code code =
9353 TREE_CODE (loc) == MIN_EXPR ? GT_EXPR : LT_EXPR;
9355 loc = build3 (COND_EXPR, TREE_TYPE (loc),
9356 build2 (code, integer_type_node,
9357 TREE_OPERAND (loc, 0), TREE_OPERAND (loc, 1)),
9358 TREE_OPERAND (loc, 1), TREE_OPERAND (loc, 0));
9361 /* ... fall through ... */
9365 dw_loc_descr_ref lhs
9366 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 1), 0);
9367 dw_loc_descr_ref rhs
9368 = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 2), 0);
9369 dw_loc_descr_ref bra_node, jump_node, tmp;
9371 ret = loc_descriptor_from_tree_1 (TREE_OPERAND (loc, 0), 0);
9372 if (ret == 0 || lhs == 0 || rhs == 0)
9375 bra_node = new_loc_descr (DW_OP_bra, 0, 0);
9376 add_loc_descr (&ret, bra_node);
9378 add_loc_descr (&ret, rhs);
9379 jump_node = new_loc_descr (DW_OP_skip, 0, 0);
9380 add_loc_descr (&ret, jump_node);
9382 add_loc_descr (&ret, lhs);
9383 bra_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
9384 bra_node->dw_loc_oprnd1.v.val_loc = lhs;
9386 /* ??? Need a node to point the skip at. Use a nop. */
9387 tmp = new_loc_descr (DW_OP_nop, 0, 0);
9388 add_loc_descr (&ret, tmp);
9389 jump_node->dw_loc_oprnd1.val_class = dw_val_class_loc;
9390 jump_node->dw_loc_oprnd1.v.val_loc = tmp;
9394 case FIX_TRUNC_EXPR:
9396 case FIX_FLOOR_EXPR:
9397 case FIX_ROUND_EXPR:
9401 /* Leave front-end specific codes as simply unknown. This comes
9402 up, for instance, with the C STMT_EXPR. */
9403 if ((unsigned int) TREE_CODE (loc)
9404 >= (unsigned int) LAST_AND_UNUSED_TREE_CODE)
9407 #ifdef ENABLE_CHECKING
9408 /* Otherwise this is a generic code; we should just lists all of
9409 these explicitly. We forgot one. */
9412 /* In a release build, we want to degrade gracefully: better to
9413 generate incomplete debugging information than to crash. */
9418 /* Show if we can't fill the request for an address. */
9419 if (want_address && !have_address)
9422 /* If we've got an address and don't want one, dereference. */
9423 if (!want_address && have_address && ret)
9425 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (loc));
9427 if (size > DWARF2_ADDR_SIZE || size == -1)
9429 else if (size == DWARF2_ADDR_SIZE)
9432 op = DW_OP_deref_size;
9434 add_loc_descr (&ret, new_loc_descr (op, size, 0));
9440 static inline dw_loc_descr_ref
9441 loc_descriptor_from_tree (tree loc)
9443 return loc_descriptor_from_tree_1 (loc, 2);
9446 /* Given a value, round it up to the lowest multiple of `boundary'
9447 which is not less than the value itself. */
9449 static inline HOST_WIDE_INT
9450 ceiling (HOST_WIDE_INT value, unsigned int boundary)
9452 return (((value + boundary - 1) / boundary) * boundary);
9455 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
9456 pointer to the declared type for the relevant field variable, or return
9457 `integer_type_node' if the given node turns out to be an
9461 field_type (tree decl)
9465 if (TREE_CODE (decl) == ERROR_MARK)
9466 return integer_type_node;
9468 type = DECL_BIT_FIELD_TYPE (decl);
9469 if (type == NULL_TREE)
9470 type = TREE_TYPE (decl);
9475 /* Given a pointer to a tree node, return the alignment in bits for
9476 it, or else return BITS_PER_WORD if the node actually turns out to
9477 be an ERROR_MARK node. */
9479 static inline unsigned
9480 simple_type_align_in_bits (tree type)
9482 return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD;
9485 static inline unsigned
9486 simple_decl_align_in_bits (tree decl)
9488 return (TREE_CODE (decl) != ERROR_MARK) ? DECL_ALIGN (decl) : BITS_PER_WORD;
9491 /* Given a pointer to a FIELD_DECL, compute and return the byte offset of the
9492 lowest addressed byte of the "containing object" for the given FIELD_DECL,
9493 or return 0 if we are unable to determine what that offset is, either
9494 because the argument turns out to be a pointer to an ERROR_MARK node, or
9495 because the offset is actually variable. (We can't handle the latter case
9498 static HOST_WIDE_INT
9499 field_byte_offset (tree decl)
9501 unsigned int type_align_in_bits;
9502 unsigned int decl_align_in_bits;
9503 unsigned HOST_WIDE_INT type_size_in_bits;
9504 HOST_WIDE_INT object_offset_in_bits;
9506 tree field_size_tree;
9507 HOST_WIDE_INT bitpos_int;
9508 HOST_WIDE_INT deepest_bitpos;
9509 unsigned HOST_WIDE_INT field_size_in_bits;
9511 if (TREE_CODE (decl) == ERROR_MARK)
9514 gcc_assert (TREE_CODE (decl) == FIELD_DECL);
9516 type = field_type (decl);
9517 field_size_tree = DECL_SIZE (decl);
9519 /* The size could be unspecified if there was an error, or for
9520 a flexible array member. */
9521 if (! field_size_tree)
9522 field_size_tree = bitsize_zero_node;
9524 /* We cannot yet cope with fields whose positions are variable, so
9525 for now, when we see such things, we simply return 0. Someday, we may
9526 be able to handle such cases, but it will be damn difficult. */
9527 if (! host_integerp (bit_position (decl), 0))
9530 bitpos_int = int_bit_position (decl);
9532 /* If we don't know the size of the field, pretend it's a full word. */
9533 if (host_integerp (field_size_tree, 1))
9534 field_size_in_bits = tree_low_cst (field_size_tree, 1);
9536 field_size_in_bits = BITS_PER_WORD;
9538 type_size_in_bits = simple_type_size_in_bits (type);
9539 type_align_in_bits = simple_type_align_in_bits (type);
9540 decl_align_in_bits = simple_decl_align_in_bits (decl);
9542 /* The GCC front-end doesn't make any attempt to keep track of the starting
9543 bit offset (relative to the start of the containing structure type) of the
9544 hypothetical "containing object" for a bit-field. Thus, when computing
9545 the byte offset value for the start of the "containing object" of a
9546 bit-field, we must deduce this information on our own. This can be rather
9547 tricky to do in some cases. For example, handling the following structure
9548 type definition when compiling for an i386/i486 target (which only aligns
9549 long long's to 32-bit boundaries) can be very tricky:
9551 struct S { int field1; long long field2:31; };
9553 Fortunately, there is a simple rule-of-thumb which can be used in such
9554 cases. When compiling for an i386/i486, GCC will allocate 8 bytes for the
9555 structure shown above. It decides to do this based upon one simple rule
9556 for bit-field allocation. GCC allocates each "containing object" for each
9557 bit-field at the first (i.e. lowest addressed) legitimate alignment
9558 boundary (based upon the required minimum alignment for the declared type
9559 of the field) which it can possibly use, subject to the condition that
9560 there is still enough available space remaining in the containing object
9561 (when allocated at the selected point) to fully accommodate all of the
9562 bits of the bit-field itself.
9564 This simple rule makes it obvious why GCC allocates 8 bytes for each
9565 object of the structure type shown above. When looking for a place to
9566 allocate the "containing object" for `field2', the compiler simply tries
9567 to allocate a 64-bit "containing object" at each successive 32-bit
9568 boundary (starting at zero) until it finds a place to allocate that 64-
9569 bit field such that at least 31 contiguous (and previously unallocated)
9570 bits remain within that selected 64 bit field. (As it turns out, for the
9571 example above, the compiler finds it is OK to allocate the "containing
9572 object" 64-bit field at bit-offset zero within the structure type.)
9574 Here we attempt to work backwards from the limited set of facts we're
9575 given, and we try to deduce from those facts, where GCC must have believed
9576 that the containing object started (within the structure type). The value
9577 we deduce is then used (by the callers of this routine) to generate
9578 DW_AT_location and DW_AT_bit_offset attributes for fields (both bit-fields
9579 and, in the case of DW_AT_location, regular fields as well). */
9581 /* Figure out the bit-distance from the start of the structure to the
9582 "deepest" bit of the bit-field. */
9583 deepest_bitpos = bitpos_int + field_size_in_bits;
9585 /* This is the tricky part. Use some fancy footwork to deduce where the
9586 lowest addressed bit of the containing object must be. */
9587 object_offset_in_bits = deepest_bitpos - type_size_in_bits;
9589 /* Round up to type_align by default. This works best for bitfields. */
9590 object_offset_in_bits += type_align_in_bits - 1;
9591 object_offset_in_bits /= type_align_in_bits;
9592 object_offset_in_bits *= type_align_in_bits;
9594 if (object_offset_in_bits > bitpos_int)
9596 /* Sigh, the decl must be packed. */
9597 object_offset_in_bits = deepest_bitpos - type_size_in_bits;
9599 /* Round up to decl_align instead. */
9600 object_offset_in_bits += decl_align_in_bits - 1;
9601 object_offset_in_bits /= decl_align_in_bits;
9602 object_offset_in_bits *= decl_align_in_bits;
9605 return object_offset_in_bits / BITS_PER_UNIT;
9608 /* The following routines define various Dwarf attributes and any data
9609 associated with them. */
9611 /* Add a location description attribute value to a DIE.
9613 This emits location attributes suitable for whole variables and
9614 whole parameters. Note that the location attributes for struct fields are
9615 generated by the routine `data_member_location_attribute' below. */
9618 add_AT_location_description (dw_die_ref die, enum dwarf_attribute attr_kind,
9619 dw_loc_descr_ref descr)
9622 add_AT_loc (die, attr_kind, descr);
9625 /* Attach the specialized form of location attribute used for data members of
9626 struct and union types. In the special case of a FIELD_DECL node which
9627 represents a bit-field, the "offset" part of this special location
9628 descriptor must indicate the distance in bytes from the lowest-addressed
9629 byte of the containing struct or union type to the lowest-addressed byte of
9630 the "containing object" for the bit-field. (See the `field_byte_offset'
9633 For any given bit-field, the "containing object" is a hypothetical object
9634 (of some integral or enum type) within which the given bit-field lives. The
9635 type of this hypothetical "containing object" is always the same as the
9636 declared type of the individual bit-field itself (for GCC anyway... the
9637 DWARF spec doesn't actually mandate this). Note that it is the size (in
9638 bytes) of the hypothetical "containing object" which will be given in the
9639 DW_AT_byte_size attribute for this bit-field. (See the
9640 `byte_size_attribute' function below.) It is also used when calculating the
9641 value of the DW_AT_bit_offset attribute. (See the `bit_offset_attribute'
9645 add_data_member_location_attribute (dw_die_ref die, tree decl)
9647 HOST_WIDE_INT offset;
9648 dw_loc_descr_ref loc_descr = 0;
9650 if (TREE_CODE (decl) == TREE_BINFO)
9652 /* We're working on the TAG_inheritance for a base class. */
9653 if (BINFO_VIRTUAL_P (decl) && is_cxx ())
9655 /* For C++ virtual bases we can't just use BINFO_OFFSET, as they
9656 aren't at a fixed offset from all (sub)objects of the same
9657 type. We need to extract the appropriate offset from our
9658 vtable. The following dwarf expression means
9660 BaseAddr = ObAddr + *((*ObAddr) - Offset)
9662 This is specific to the V3 ABI, of course. */
9664 dw_loc_descr_ref tmp;
9666 /* Make a copy of the object address. */
9667 tmp = new_loc_descr (DW_OP_dup, 0, 0);
9668 add_loc_descr (&loc_descr, tmp);
9670 /* Extract the vtable address. */
9671 tmp = new_loc_descr (DW_OP_deref, 0, 0);
9672 add_loc_descr (&loc_descr, tmp);
9674 /* Calculate the address of the offset. */
9675 offset = tree_low_cst (BINFO_VPTR_FIELD (decl), 0);
9676 gcc_assert (offset < 0);
9678 tmp = int_loc_descriptor (-offset);
9679 add_loc_descr (&loc_descr, tmp);
9680 tmp = new_loc_descr (DW_OP_minus, 0, 0);
9681 add_loc_descr (&loc_descr, tmp);
9683 /* Extract the offset. */
9684 tmp = new_loc_descr (DW_OP_deref, 0, 0);
9685 add_loc_descr (&loc_descr, tmp);
9687 /* Add it to the object address. */
9688 tmp = new_loc_descr (DW_OP_plus, 0, 0);
9689 add_loc_descr (&loc_descr, tmp);
9692 offset = tree_low_cst (BINFO_OFFSET (decl), 0);
9695 offset = field_byte_offset (decl);
9699 enum dwarf_location_atom op;
9701 /* The DWARF2 standard says that we should assume that the structure
9702 address is already on the stack, so we can specify a structure field
9703 address by using DW_OP_plus_uconst. */
9705 #ifdef MIPS_DEBUGGING_INFO
9706 /* ??? The SGI dwarf reader does not handle the DW_OP_plus_uconst
9707 operator correctly. It works only if we leave the offset on the
9711 op = DW_OP_plus_uconst;
9714 loc_descr = new_loc_descr (op, offset, 0);
9717 add_AT_loc (die, DW_AT_data_member_location, loc_descr);
9720 /* Writes integer values to dw_vec_const array. */
9723 insert_int (HOST_WIDE_INT val, unsigned int size, unsigned char *dest)
9727 *dest++ = val & 0xff;
9733 /* Reads integers from dw_vec_const array. Inverse of insert_int. */
9735 static HOST_WIDE_INT
9736 extract_int (const unsigned char *src, unsigned int size)
9738 HOST_WIDE_INT val = 0;
9744 val |= *--src & 0xff;
9750 /* Writes floating point values to dw_vec_const array. */
9753 insert_float (rtx rtl, unsigned char *array)
9759 REAL_VALUE_FROM_CONST_DOUBLE (rv, rtl);
9760 real_to_target (val, &rv, GET_MODE (rtl));
9762 /* real_to_target puts 32-bit pieces in each long. Pack them. */
9763 for (i = 0; i < GET_MODE_SIZE (GET_MODE (rtl)) / 4; i++)
9765 insert_int (val[i], 4, array);
9770 /* Attach a DW_AT_const_value attribute for a variable or a parameter which
9771 does not have a "location" either in memory or in a register. These
9772 things can arise in GNU C when a constant is passed as an actual parameter
9773 to an inlined function. They can also arise in C++ where declared
9774 constants do not necessarily get memory "homes". */
9777 add_const_value_attribute (dw_die_ref die, rtx rtl)
9779 switch (GET_CODE (rtl))
9783 HOST_WIDE_INT val = INTVAL (rtl);
9786 add_AT_int (die, DW_AT_const_value, val);
9788 add_AT_unsigned (die, DW_AT_const_value, (unsigned HOST_WIDE_INT) val);
9793 /* Note that a CONST_DOUBLE rtx could represent either an integer or a
9794 floating-point constant. A CONST_DOUBLE is used whenever the
9795 constant requires more than one word in order to be adequately
9796 represented. We output CONST_DOUBLEs as blocks. */
9798 enum machine_mode mode = GET_MODE (rtl);
9800 if (GET_MODE_CLASS (mode) == MODE_FLOAT)
9802 unsigned int length = GET_MODE_SIZE (mode);
9803 unsigned char *array = ggc_alloc (length);
9805 insert_float (rtl, array);
9806 add_AT_vec (die, DW_AT_const_value, length / 4, 4, array);
9810 /* ??? We really should be using HOST_WIDE_INT throughout. */
9811 gcc_assert (HOST_BITS_PER_LONG == HOST_BITS_PER_WIDE_INT);
9813 add_AT_long_long (die, DW_AT_const_value,
9814 CONST_DOUBLE_HIGH (rtl), CONST_DOUBLE_LOW (rtl));
9821 enum machine_mode mode = GET_MODE (rtl);
9822 unsigned int elt_size = GET_MODE_UNIT_SIZE (mode);
9823 unsigned int length = CONST_VECTOR_NUNITS (rtl);
9824 unsigned char *array = ggc_alloc (length * elt_size);
9828 switch (GET_MODE_CLASS (mode))
9830 case MODE_VECTOR_INT:
9831 for (i = 0, p = array; i < length; i++, p += elt_size)
9833 rtx elt = CONST_VECTOR_ELT (rtl, i);
9834 HOST_WIDE_INT lo, hi;
9836 switch (GET_CODE (elt))
9844 lo = CONST_DOUBLE_LOW (elt);
9845 hi = CONST_DOUBLE_HIGH (elt);
9852 if (elt_size <= sizeof (HOST_WIDE_INT))
9853 insert_int (lo, elt_size, p);
9856 unsigned char *p0 = p;
9857 unsigned char *p1 = p + sizeof (HOST_WIDE_INT);
9859 gcc_assert (elt_size == 2 * sizeof (HOST_WIDE_INT));
9860 if (WORDS_BIG_ENDIAN)
9865 insert_int (lo, sizeof (HOST_WIDE_INT), p0);
9866 insert_int (hi, sizeof (HOST_WIDE_INT), p1);
9871 case MODE_VECTOR_FLOAT:
9872 for (i = 0, p = array; i < length; i++, p += elt_size)
9874 rtx elt = CONST_VECTOR_ELT (rtl, i);
9875 insert_float (elt, p);
9883 add_AT_vec (die, DW_AT_const_value, length, elt_size, array);
9888 add_AT_string (die, DW_AT_const_value, XSTR (rtl, 0));
9894 add_AT_addr (die, DW_AT_const_value, rtl);
9895 VEC_safe_push (rtx, gc, used_rtx_array, rtl);
9899 /* In cases where an inlined instance of an inline function is passed
9900 the address of an `auto' variable (which is local to the caller) we
9901 can get a situation where the DECL_RTL of the artificial local
9902 variable (for the inlining) which acts as a stand-in for the
9903 corresponding formal parameter (of the inline function) will look
9904 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not
9905 exactly a compile-time constant expression, but it isn't the address
9906 of the (artificial) local variable either. Rather, it represents the
9907 *value* which the artificial local variable always has during its
9908 lifetime. We currently have no way to represent such quasi-constant
9909 values in Dwarf, so for now we just punt and generate nothing. */
9913 /* No other kinds of rtx should be possible here. */
9919 /* Generate an RTL constant from a decl initializer INIT with decl type TYPE,
9920 for use in a later add_const_value_attribute call. */
9923 rtl_for_decl_init (tree init, tree type)
9927 /* If a variable is initialized with a string constant without embedded
9928 zeros, build CONST_STRING. */
9929 if (TREE_CODE (init) == STRING_CST && TREE_CODE (type) == ARRAY_TYPE)
9931 tree enttype = TREE_TYPE (type);
9932 tree domain = TYPE_DOMAIN (type);
9933 enum machine_mode mode = TYPE_MODE (enttype);
9935 if (GET_MODE_CLASS (mode) == MODE_INT && GET_MODE_SIZE (mode) == 1
9937 && integer_zerop (TYPE_MIN_VALUE (domain))
9938 && compare_tree_int (TYPE_MAX_VALUE (domain),
9939 TREE_STRING_LENGTH (init) - 1) == 0
9940 && ((size_t) TREE_STRING_LENGTH (init)
9941 == strlen (TREE_STRING_POINTER (init)) + 1))
9942 rtl = gen_rtx_CONST_STRING (VOIDmode,
9943 ggc_strdup (TREE_STRING_POINTER (init)));
9945 /* If the initializer is something that we know will expand into an
9946 immediate RTL constant, expand it now. Expanding anything else
9947 tends to produce unresolved symbols; see debug/5770 and c++/6381. */
9948 /* Aggregate, vector, and complex types may contain constructors that may
9949 result in code being generated when expand_expr is called, so we can't
9950 handle them here. Integer and float are useful and safe types to handle
9952 else if ((INTEGRAL_TYPE_P (type) || SCALAR_FLOAT_TYPE_P (type))
9953 && initializer_constant_valid_p (init, type) == null_pointer_node)
9955 rtl = expand_expr (init, NULL_RTX, VOIDmode, EXPAND_INITIALIZER);
9957 /* If expand_expr returns a MEM, it wasn't immediate. */
9958 gcc_assert (!rtl || !MEM_P (rtl));
9964 /* Generate RTL for the variable DECL to represent its location. */
9967 rtl_for_decl_location (tree decl)
9971 /* Here we have to decide where we are going to say the parameter "lives"
9972 (as far as the debugger is concerned). We only have a couple of
9973 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
9975 DECL_RTL normally indicates where the parameter lives during most of the
9976 activation of the function. If optimization is enabled however, this
9977 could be either NULL or else a pseudo-reg. Both of those cases indicate
9978 that the parameter doesn't really live anywhere (as far as the code
9979 generation parts of GCC are concerned) during most of the function's
9980 activation. That will happen (for example) if the parameter is never
9981 referenced within the function.
9983 We could just generate a location descriptor here for all non-NULL
9984 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
9985 a little nicer than that if we also consider DECL_INCOMING_RTL in cases
9986 where DECL_RTL is NULL or is a pseudo-reg.
9988 Note however that we can only get away with using DECL_INCOMING_RTL as
9989 a backup substitute for DECL_RTL in certain limited cases. In cases
9990 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
9991 we can be sure that the parameter was passed using the same type as it is
9992 declared to have within the function, and that its DECL_INCOMING_RTL
9993 points us to a place where a value of that type is passed.
9995 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
9996 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
9997 because in these cases DECL_INCOMING_RTL points us to a value of some
9998 type which is *different* from the type of the parameter itself. Thus,
9999 if we tried to use DECL_INCOMING_RTL to generate a location attribute in
10000 such cases, the debugger would end up (for example) trying to fetch a
10001 `float' from a place which actually contains the first part of a
10002 `double'. That would lead to really incorrect and confusing
10003 output at debug-time.
10005 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
10006 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There
10007 are a couple of exceptions however. On little-endian machines we can
10008 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
10009 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
10010 an integral type that is smaller than TREE_TYPE (decl). These cases arise
10011 when (on a little-endian machine) a non-prototyped function has a
10012 parameter declared to be of type `short' or `char'. In such cases,
10013 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
10014 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
10015 passed `int' value. If the debugger then uses that address to fetch
10016 a `short' or a `char' (on a little-endian machine) the result will be
10017 the correct data, so we allow for such exceptional cases below.
10019 Note that our goal here is to describe the place where the given formal
10020 parameter lives during most of the function's activation (i.e. between the
10021 end of the prologue and the start of the epilogue). We'll do that as best
10022 as we can. Note however that if the given formal parameter is modified
10023 sometime during the execution of the function, then a stack backtrace (at
10024 debug-time) will show the function as having been called with the *new*
10025 value rather than the value which was originally passed in. This happens
10026 rarely enough that it is not a major problem, but it *is* a problem, and
10027 I'd like to fix it.
10029 A future version of dwarf2out.c may generate two additional attributes for
10030 any given DW_TAG_formal_parameter DIE which will describe the "passed
10031 type" and the "passed location" for the given formal parameter in addition
10032 to the attributes we now generate to indicate the "declared type" and the
10033 "active location" for each parameter. This additional set of attributes
10034 could be used by debuggers for stack backtraces. Separately, note that
10035 sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be NULL also.
10036 This happens (for example) for inlined-instances of inline function formal
10037 parameters which are never referenced. This really shouldn't be
10038 happening. All PARM_DECL nodes should get valid non-NULL
10039 DECL_INCOMING_RTL values. FIXME. */
10041 /* Use DECL_RTL as the "location" unless we find something better. */
10042 rtl = DECL_RTL_IF_SET (decl);
10044 /* When generating abstract instances, ignore everything except
10045 constants, symbols living in memory, and symbols living in
10046 fixed registers. */
10047 if (! reload_completed)
10050 && (CONSTANT_P (rtl)
10052 && CONSTANT_P (XEXP (rtl, 0)))
10054 && TREE_CODE (decl) == VAR_DECL
10055 && TREE_STATIC (decl))))
10057 rtl = targetm.delegitimize_address (rtl);
10062 else if (TREE_CODE (decl) == PARM_DECL)
10064 if (rtl == NULL_RTX || is_pseudo_reg (rtl))
10066 tree declared_type = TREE_TYPE (decl);
10067 tree passed_type = DECL_ARG_TYPE (decl);
10068 enum machine_mode dmode = TYPE_MODE (declared_type);
10069 enum machine_mode pmode = TYPE_MODE (passed_type);
10071 /* This decl represents a formal parameter which was optimized out.
10072 Note that DECL_INCOMING_RTL may be NULL in here, but we handle
10073 all cases where (rtl == NULL_RTX) just below. */
10074 if (dmode == pmode)
10075 rtl = DECL_INCOMING_RTL (decl);
10076 else if (SCALAR_INT_MODE_P (dmode)
10077 && GET_MODE_SIZE (dmode) <= GET_MODE_SIZE (pmode)
10078 && DECL_INCOMING_RTL (decl))
10080 rtx inc = DECL_INCOMING_RTL (decl);
10083 else if (MEM_P (inc))
10085 if (BYTES_BIG_ENDIAN)
10086 rtl = adjust_address_nv (inc, dmode,
10087 GET_MODE_SIZE (pmode)
10088 - GET_MODE_SIZE (dmode));
10095 /* If the parm was passed in registers, but lives on the stack, then
10096 make a big endian correction if the mode of the type of the
10097 parameter is not the same as the mode of the rtl. */
10098 /* ??? This is the same series of checks that are made in dbxout.c before
10099 we reach the big endian correction code there. It isn't clear if all
10100 of these checks are necessary here, but keeping them all is the safe
10102 else if (MEM_P (rtl)
10103 && XEXP (rtl, 0) != const0_rtx
10104 && ! CONSTANT_P (XEXP (rtl, 0))
10105 /* Not passed in memory. */
10106 && !MEM_P (DECL_INCOMING_RTL (decl))
10107 /* Not passed by invisible reference. */
10108 && (!REG_P (XEXP (rtl, 0))
10109 || REGNO (XEXP (rtl, 0)) == HARD_FRAME_POINTER_REGNUM
10110 || REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM
10111 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
10112 || REGNO (XEXP (rtl, 0)) == ARG_POINTER_REGNUM
10115 /* Big endian correction check. */
10116 && BYTES_BIG_ENDIAN
10117 && TYPE_MODE (TREE_TYPE (decl)) != GET_MODE (rtl)
10118 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)))
10121 int offset = (UNITS_PER_WORD
10122 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl))));
10124 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
10125 plus_constant (XEXP (rtl, 0), offset));
10128 else if (TREE_CODE (decl) == VAR_DECL
10131 && GET_MODE (rtl) != TYPE_MODE (TREE_TYPE (decl))
10132 && BYTES_BIG_ENDIAN)
10134 int rsize = GET_MODE_SIZE (GET_MODE (rtl));
10135 int dsize = GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)));
10137 /* If a variable is declared "register" yet is smaller than
10138 a register, then if we store the variable to memory, it
10139 looks like we're storing a register-sized value, when in
10140 fact we are not. We need to adjust the offset of the
10141 storage location to reflect the actual value's bytes,
10142 else gdb will not be able to display it. */
10144 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
10145 plus_constant (XEXP (rtl, 0), rsize-dsize));
10148 /* A variable with no DECL_RTL but a DECL_INITIAL is a compile-time constant,
10149 and will have been substituted directly into all expressions that use it.
10150 C does not have such a concept, but C++ and other languages do. */
10151 if (!rtl && TREE_CODE (decl) == VAR_DECL && DECL_INITIAL (decl))
10152 rtl = rtl_for_decl_init (DECL_INITIAL (decl), TREE_TYPE (decl));
10155 rtl = targetm.delegitimize_address (rtl);
10157 /* If we don't look past the constant pool, we risk emitting a
10158 reference to a constant pool entry that isn't referenced from
10159 code, and thus is not emitted. */
10161 rtl = avoid_constant_pool_reference (rtl);
10166 /* We need to figure out what section we should use as the base for the
10167 address ranges where a given location is valid.
10168 1. If this particular DECL has a section associated with it, use that.
10169 2. If this function has a section associated with it, use that.
10170 3. Otherwise, use the text section.
10171 XXX: If you split a variable across multiple sections, we won't notice. */
10173 static const char *
10174 secname_for_decl (tree decl)
10176 const char *secname;
10178 if (VAR_OR_FUNCTION_DECL_P (decl) && DECL_SECTION_NAME (decl))
10180 tree sectree = DECL_SECTION_NAME (decl);
10181 secname = TREE_STRING_POINTER (sectree);
10183 else if (current_function_decl && DECL_SECTION_NAME (current_function_decl))
10185 tree sectree = DECL_SECTION_NAME (current_function_decl);
10186 secname = TREE_STRING_POINTER (sectree);
10189 && (last_text_section == in_unlikely_executed_text
10190 || (last_text_section == in_named
10191 && last_text_section_name
10192 == cfun->unlikely_text_section_name)))
10193 secname = cfun->cold_section_label;
10195 secname = text_section_label;
10200 /* Generate *either* a DW_AT_location attribute or else a DW_AT_const_value
10201 data attribute for a variable or a parameter. We generate the
10202 DW_AT_const_value attribute only in those cases where the given variable
10203 or parameter does not have a true "location" either in memory or in a
10204 register. This can happen (for example) when a constant is passed as an
10205 actual argument in a call to an inline function. (It's possible that
10206 these things can crop up in other ways also.) Note that one type of
10207 constant value which can be passed into an inlined function is a constant
10208 pointer. This can happen for example if an actual argument in an inlined
10209 function call evaluates to a compile-time constant address. */
10212 add_location_or_const_value_attribute (dw_die_ref die, tree decl,
10213 enum dwarf_attribute attr)
10216 dw_loc_descr_ref descr;
10217 var_loc_list *loc_list;
10218 struct var_loc_node *node;
10219 if (TREE_CODE (decl) == ERROR_MARK)
10222 gcc_assert (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL
10223 || TREE_CODE (decl) == RESULT_DECL);
10225 /* See if we possibly have multiple locations for this variable. */
10226 loc_list = lookup_decl_loc (decl);
10228 /* If it truly has multiple locations, the first and last node will
10230 if (loc_list && loc_list->first != loc_list->last)
10232 const char *endname, *secname;
10233 dw_loc_list_ref list;
10236 /* Now that we know what section we are using for a base,
10237 actually construct the list of locations.
10238 The first location information is what is passed to the
10239 function that creates the location list, and the remaining
10240 locations just get added on to that list.
10241 Note that we only know the start address for a location
10242 (IE location changes), so to build the range, we use
10243 the range [current location start, next location start].
10244 This means we have to special case the last node, and generate
10245 a range of [last location start, end of function label]. */
10247 node = loc_list->first;
10248 varloc = NOTE_VAR_LOCATION (node->var_loc_note);
10249 secname = secname_for_decl (decl);
10251 list = new_loc_list (loc_descriptor (varloc),
10252 node->label, node->next->label, secname, 1);
10255 for (; node->next; node = node->next)
10256 if (NOTE_VAR_LOCATION_LOC (node->var_loc_note) != NULL_RTX)
10258 /* The variable has a location between NODE->LABEL and
10259 NODE->NEXT->LABEL. */
10260 varloc = NOTE_VAR_LOCATION (node->var_loc_note);
10261 add_loc_descr_to_loc_list (&list, loc_descriptor (varloc),
10262 node->label, node->next->label, secname);
10265 /* If the variable has a location at the last label
10266 it keeps its location until the end of function. */
10267 if (NOTE_VAR_LOCATION_LOC (node->var_loc_note) != NULL_RTX)
10269 char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
10271 varloc = NOTE_VAR_LOCATION (node->var_loc_note);
10272 if (!current_function_decl)
10273 endname = text_end_label;
10276 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
10277 current_function_funcdef_no);
10278 endname = ggc_strdup (label_id);
10280 add_loc_descr_to_loc_list (&list, loc_descriptor (varloc),
10281 node->label, endname, secname);
10284 /* Finally, add the location list to the DIE, and we are done. */
10285 add_AT_loc_list (die, attr, list);
10289 /* Try to get some constant RTL for this decl, and use that as the value of
10292 rtl = rtl_for_decl_location (decl);
10293 if (rtl && (CONSTANT_P (rtl) || GET_CODE (rtl) == CONST_STRING))
10295 add_const_value_attribute (die, rtl);
10299 /* If we have tried to generate the location otherwise, and it
10300 didn't work out (we wouldn't be here if we did), and we have a one entry
10301 location list, try generating a location from that. */
10302 if (loc_list && loc_list->first)
10304 node = loc_list->first;
10305 descr = loc_descriptor (NOTE_VAR_LOCATION (node->var_loc_note));
10308 add_AT_location_description (die, attr, descr);
10313 /* We couldn't get any rtl, so try directly generating the location
10314 description from the tree. */
10315 descr = loc_descriptor_from_tree (decl);
10318 add_AT_location_description (die, attr, descr);
10323 /* If we don't have a copy of this variable in memory for some reason (such
10324 as a C++ member constant that doesn't have an out-of-line definition),
10325 we should tell the debugger about the constant value. */
10328 tree_add_const_value_attribute (dw_die_ref var_die, tree decl)
10330 tree init = DECL_INITIAL (decl);
10331 tree type = TREE_TYPE (decl);
10334 if (TREE_READONLY (decl) && ! TREE_THIS_VOLATILE (decl) && init)
10339 rtl = rtl_for_decl_init (init, type);
10341 add_const_value_attribute (var_die, rtl);
10344 /* Convert the CFI instructions for the current function into a location
10345 list. This is used for DW_AT_frame_base when we targeting a dwarf2
10346 consumer that does not support the dwarf3 DW_OP_call_frame_cfa. */
10348 static dw_loc_list_ref
10349 convert_cfa_to_loc_list (void)
10352 dw_loc_list_ref list, *list_tail;
10354 dw_cfa_location last_cfa, next_cfa;
10355 const char *start_label, *last_label, *section;
10357 fde = &fde_table[fde_table_in_use - 1];
10359 section = secname_for_decl (current_function_decl);
10363 next_cfa.reg = INVALID_REGNUM;
10364 next_cfa.offset = 0;
10365 next_cfa.indirect = 0;
10366 next_cfa.base_offset = 0;
10368 start_label = fde->dw_fde_begin;
10370 /* ??? Bald assumption that the CIE opcode list does not contain
10371 advance opcodes. */
10372 for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
10373 lookup_cfa_1 (cfi, &next_cfa);
10375 last_cfa = next_cfa;
10376 last_label = start_label;
10378 for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
10379 switch (cfi->dw_cfi_opc)
10381 case DW_CFA_advance_loc1:
10382 case DW_CFA_advance_loc2:
10383 case DW_CFA_advance_loc4:
10384 if (!cfa_equal_p (&last_cfa, &next_cfa))
10386 *list_tail = new_loc_list (build_cfa_loc (&last_cfa), start_label,
10387 last_label, section, list == NULL);
10389 list_tail = &(*list_tail)->dw_loc_next;
10390 last_cfa = next_cfa;
10391 start_label = last_label;
10393 last_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
10396 case DW_CFA_advance_loc:
10397 /* The encoding is complex enough that we should never emit this. */
10398 case DW_CFA_remember_state:
10399 case DW_CFA_restore_state:
10400 /* We don't handle these two in this function. It would be possible
10401 if it were to be required. */
10402 gcc_unreachable ();
10405 lookup_cfa_1 (cfi, &next_cfa);
10409 if (!cfa_equal_p (&last_cfa, &next_cfa))
10411 *list_tail = new_loc_list (build_cfa_loc (&last_cfa), start_label,
10412 last_label, section, list == NULL);
10413 list_tail = &(*list_tail)->dw_loc_next;
10414 start_label = last_label;
10416 *list_tail = new_loc_list (build_cfa_loc (&next_cfa), start_label,
10417 fde->dw_fde_end, section, list == NULL);
10422 /* Compute a displacement from the "steady-state frame pointer" to
10423 the CFA, and store it in frame_pointer_cfa_offset. */
10426 compute_frame_pointer_to_cfa_displacement (void)
10428 HOST_WIDE_INT offset;
10431 #ifdef FRAME_POINTER_CFA_OFFSET
10432 reg = frame_pointer_rtx;
10433 offset = FRAME_POINTER_CFA_OFFSET (current_function_decl);
10435 reg = arg_pointer_rtx;
10436 offset = ARG_POINTER_CFA_OFFSET (current_function_decl);
10439 elim = eliminate_regs (reg, VOIDmode, NULL_RTX);
10440 if (GET_CODE (elim) == PLUS)
10442 offset += INTVAL (XEXP (elim, 1));
10443 elim = XEXP (elim, 0);
10445 gcc_assert (elim == (frame_pointer_needed ? hard_frame_pointer_rtx
10446 : stack_pointer_rtx));
10448 frame_pointer_cfa_offset = -offset;
10451 /* Generate a DW_AT_name attribute given some string value to be included as
10452 the value of the attribute. */
10455 add_name_attribute (dw_die_ref die, const char *name_string)
10457 if (name_string != NULL && *name_string != 0)
10459 if (demangle_name_func)
10460 name_string = (*demangle_name_func) (name_string);
10462 add_AT_string (die, DW_AT_name, name_string);
10466 /* Generate a DW_AT_comp_dir attribute for DIE. */
10469 add_comp_dir_attribute (dw_die_ref die)
10471 const char *wd = get_src_pwd ();
10473 add_AT_string (die, DW_AT_comp_dir, wd);
10476 /* Given a tree node describing an array bound (either lower or upper) output
10477 a representation for that bound. */
10480 add_bound_info (dw_die_ref subrange_die, enum dwarf_attribute bound_attr, tree bound)
10482 switch (TREE_CODE (bound))
10487 /* All fixed-bounds are represented by INTEGER_CST nodes. */
10489 if (! host_integerp (bound, 0)
10490 || (bound_attr == DW_AT_lower_bound
10491 && (((is_c_family () || is_java ()) && integer_zerop (bound))
10492 || (is_fortran () && integer_onep (bound)))))
10493 /* Use the default. */
10496 add_AT_unsigned (subrange_die, bound_attr, tree_low_cst (bound, 0));
10501 case NON_LVALUE_EXPR:
10502 case VIEW_CONVERT_EXPR:
10503 add_bound_info (subrange_die, bound_attr, TREE_OPERAND (bound, 0));
10513 dw_die_ref decl_die = lookup_decl_die (bound);
10515 /* ??? Can this happen, or should the variable have been bound
10516 first? Probably it can, since I imagine that we try to create
10517 the types of parameters in the order in which they exist in
10518 the list, and won't have created a forward reference to a
10519 later parameter. */
10520 if (decl_die != NULL)
10521 add_AT_die_ref (subrange_die, bound_attr, decl_die);
10527 /* Otherwise try to create a stack operation procedure to
10528 evaluate the value of the array bound. */
10530 dw_die_ref ctx, decl_die;
10531 dw_loc_descr_ref loc;
10533 loc = loc_descriptor_from_tree (bound);
10537 if (current_function_decl == 0)
10538 ctx = comp_unit_die;
10540 ctx = lookup_decl_die (current_function_decl);
10542 decl_die = new_die (DW_TAG_variable, ctx, bound);
10543 add_AT_flag (decl_die, DW_AT_artificial, 1);
10544 add_type_attribute (decl_die, TREE_TYPE (bound), 1, 0, ctx);
10545 add_AT_loc (decl_die, DW_AT_location, loc);
10547 add_AT_die_ref (subrange_die, bound_attr, decl_die);
10553 /* Note that the block of subscript information for an array type also
10554 includes information about the element type of type given array type. */
10557 add_subscript_info (dw_die_ref type_die, tree type)
10559 #ifndef MIPS_DEBUGGING_INFO
10560 unsigned dimension_number;
10563 dw_die_ref subrange_die;
10565 /* The GNU compilers represent multidimensional array types as sequences of
10566 one dimensional array types whose element types are themselves array
10567 types. Here we squish that down, so that each multidimensional array
10568 type gets only one array_type DIE in the Dwarf debugging info. The draft
10569 Dwarf specification say that we are allowed to do this kind of
10570 compression in C (because there is no difference between an array or
10571 arrays and a multidimensional array in C) but for other source languages
10572 (e.g. Ada) we probably shouldn't do this. */
10574 /* ??? The SGI dwarf reader fails for multidimensional arrays with a
10575 const enum type. E.g. const enum machine_mode insn_operand_mode[2][10].
10576 We work around this by disabling this feature. See also
10577 gen_array_type_die. */
10578 #ifndef MIPS_DEBUGGING_INFO
10579 for (dimension_number = 0;
10580 TREE_CODE (type) == ARRAY_TYPE;
10581 type = TREE_TYPE (type), dimension_number++)
10584 tree domain = TYPE_DOMAIN (type);
10586 /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
10587 and (in GNU C only) variable bounds. Handle all three forms
10589 subrange_die = new_die (DW_TAG_subrange_type, type_die, NULL);
10592 /* We have an array type with specified bounds. */
10593 lower = TYPE_MIN_VALUE (domain);
10594 upper = TYPE_MAX_VALUE (domain);
10596 /* Define the index type. */
10597 if (TREE_TYPE (domain))
10599 /* ??? This is probably an Ada unnamed subrange type. Ignore the
10600 TREE_TYPE field. We can't emit debug info for this
10601 because it is an unnamed integral type. */
10602 if (TREE_CODE (domain) == INTEGER_TYPE
10603 && TYPE_NAME (domain) == NULL_TREE
10604 && TREE_CODE (TREE_TYPE (domain)) == INTEGER_TYPE
10605 && TYPE_NAME (TREE_TYPE (domain)) == NULL_TREE)
10608 add_type_attribute (subrange_die, TREE_TYPE (domain), 0, 0,
10612 /* ??? If upper is NULL, the array has unspecified length,
10613 but it does have a lower bound. This happens with Fortran
10615 Since the debugger is definitely going to need to know N
10616 to produce useful results, go ahead and output the lower
10617 bound solo, and hope the debugger can cope. */
10619 add_bound_info (subrange_die, DW_AT_lower_bound, lower);
10621 add_bound_info (subrange_die, DW_AT_upper_bound, upper);
10624 /* Otherwise we have an array type with an unspecified length. The
10625 DWARF-2 spec does not say how to handle this; let's just leave out the
10631 add_byte_size_attribute (dw_die_ref die, tree tree_node)
10635 switch (TREE_CODE (tree_node))
10640 case ENUMERAL_TYPE:
10643 case QUAL_UNION_TYPE:
10644 size = int_size_in_bytes (tree_node);
10647 /* For a data member of a struct or union, the DW_AT_byte_size is
10648 generally given as the number of bytes normally allocated for an
10649 object of the *declared* type of the member itself. This is true
10650 even for bit-fields. */
10651 size = simple_type_size_in_bits (field_type (tree_node)) / BITS_PER_UNIT;
10654 gcc_unreachable ();
10657 /* Note that `size' might be -1 when we get to this point. If it is, that
10658 indicates that the byte size of the entity in question is variable. We
10659 have no good way of expressing this fact in Dwarf at the present time,
10660 so just let the -1 pass on through. */
10661 add_AT_unsigned (die, DW_AT_byte_size, size);
10664 /* For a FIELD_DECL node which represents a bit-field, output an attribute
10665 which specifies the distance in bits from the highest order bit of the
10666 "containing object" for the bit-field to the highest order bit of the
10669 For any given bit-field, the "containing object" is a hypothetical object
10670 (of some integral or enum type) within which the given bit-field lives. The
10671 type of this hypothetical "containing object" is always the same as the
10672 declared type of the individual bit-field itself. The determination of the
10673 exact location of the "containing object" for a bit-field is rather
10674 complicated. It's handled by the `field_byte_offset' function (above).
10676 Note that it is the size (in bytes) of the hypothetical "containing object"
10677 which will be given in the DW_AT_byte_size attribute for this bit-field.
10678 (See `byte_size_attribute' above). */
10681 add_bit_offset_attribute (dw_die_ref die, tree decl)
10683 HOST_WIDE_INT object_offset_in_bytes = field_byte_offset (decl);
10684 tree type = DECL_BIT_FIELD_TYPE (decl);
10685 HOST_WIDE_INT bitpos_int;
10686 HOST_WIDE_INT highest_order_object_bit_offset;
10687 HOST_WIDE_INT highest_order_field_bit_offset;
10688 HOST_WIDE_INT unsigned bit_offset;
10690 /* Must be a field and a bit field. */
10691 gcc_assert (type && TREE_CODE (decl) == FIELD_DECL);
10693 /* We can't yet handle bit-fields whose offsets are variable, so if we
10694 encounter such things, just return without generating any attribute
10695 whatsoever. Likewise for variable or too large size. */
10696 if (! host_integerp (bit_position (decl), 0)
10697 || ! host_integerp (DECL_SIZE (decl), 1))
10700 bitpos_int = int_bit_position (decl);
10702 /* Note that the bit offset is always the distance (in bits) from the
10703 highest-order bit of the "containing object" to the highest-order bit of
10704 the bit-field itself. Since the "high-order end" of any object or field
10705 is different on big-endian and little-endian machines, the computation
10706 below must take account of these differences. */
10707 highest_order_object_bit_offset = object_offset_in_bytes * BITS_PER_UNIT;
10708 highest_order_field_bit_offset = bitpos_int;
10710 if (! BYTES_BIG_ENDIAN)
10712 highest_order_field_bit_offset += tree_low_cst (DECL_SIZE (decl), 0);
10713 highest_order_object_bit_offset += simple_type_size_in_bits (type);
10717 = (! BYTES_BIG_ENDIAN
10718 ? highest_order_object_bit_offset - highest_order_field_bit_offset
10719 : highest_order_field_bit_offset - highest_order_object_bit_offset);
10721 add_AT_unsigned (die, DW_AT_bit_offset, bit_offset);
10724 /* For a FIELD_DECL node which represents a bit field, output an attribute
10725 which specifies the length in bits of the given field. */
10728 add_bit_size_attribute (dw_die_ref die, tree decl)
10730 /* Must be a field and a bit field. */
10731 gcc_assert (TREE_CODE (decl) == FIELD_DECL
10732 && DECL_BIT_FIELD_TYPE (decl));
10734 if (host_integerp (DECL_SIZE (decl), 1))
10735 add_AT_unsigned (die, DW_AT_bit_size, tree_low_cst (DECL_SIZE (decl), 1));
10738 /* If the compiled language is ANSI C, then add a 'prototyped'
10739 attribute, if arg types are given for the parameters of a function. */
10742 add_prototyped_attribute (dw_die_ref die, tree func_type)
10744 if (get_AT_unsigned (comp_unit_die, DW_AT_language) == DW_LANG_C89
10745 && TYPE_ARG_TYPES (func_type) != NULL)
10746 add_AT_flag (die, DW_AT_prototyped, 1);
10749 /* Add an 'abstract_origin' attribute below a given DIE. The DIE is found
10750 by looking in either the type declaration or object declaration
10754 add_abstract_origin_attribute (dw_die_ref die, tree origin)
10756 dw_die_ref origin_die = NULL;
10758 if (TREE_CODE (origin) != FUNCTION_DECL)
10760 /* We may have gotten separated from the block for the inlined
10761 function, if we're in an exception handler or some such; make
10762 sure that the abstract function has been written out.
10764 Doing this for nested functions is wrong, however; functions are
10765 distinct units, and our context might not even be inline. */
10769 fn = TYPE_STUB_DECL (fn);
10771 fn = decl_function_context (fn);
10773 dwarf2out_abstract_function (fn);
10776 if (DECL_P (origin))
10777 origin_die = lookup_decl_die (origin);
10778 else if (TYPE_P (origin))
10779 origin_die = lookup_type_die (origin);
10781 /* XXX: Functions that are never lowered don't always have correct block
10782 trees (in the case of java, they simply have no block tree, in some other
10783 languages). For these functions, there is nothing we can really do to
10784 output correct debug info for inlined functions in all cases. Rather
10785 than die, we'll just produce deficient debug info now, in that we will
10786 have variables without a proper abstract origin. In the future, when all
10787 functions are lowered, we should re-add a gcc_assert (origin_die)
10791 add_AT_die_ref (die, DW_AT_abstract_origin, origin_die);
10794 /* We do not currently support the pure_virtual attribute. */
10797 add_pure_or_virtual_attribute (dw_die_ref die, tree func_decl)
10799 if (DECL_VINDEX (func_decl))
10801 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
10803 if (host_integerp (DECL_VINDEX (func_decl), 0))
10804 add_AT_loc (die, DW_AT_vtable_elem_location,
10805 new_loc_descr (DW_OP_constu,
10806 tree_low_cst (DECL_VINDEX (func_decl), 0),
10809 /* GNU extension: Record what type this method came from originally. */
10810 if (debug_info_level > DINFO_LEVEL_TERSE)
10811 add_AT_die_ref (die, DW_AT_containing_type,
10812 lookup_type_die (DECL_CONTEXT (func_decl)));
10816 /* Add source coordinate attributes for the given decl. */
10819 add_src_coords_attributes (dw_die_ref die, tree decl)
10821 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
10822 unsigned file_index = lookup_filename (s.file);
10824 add_AT_unsigned (die, DW_AT_decl_file, file_index);
10825 add_AT_unsigned (die, DW_AT_decl_line, s.line);
10828 /* Add a DW_AT_name attribute and source coordinate attribute for the
10829 given decl, but only if it actually has a name. */
10832 add_name_and_src_coords_attributes (dw_die_ref die, tree decl)
10836 decl_name = DECL_NAME (decl);
10837 if (decl_name != NULL && IDENTIFIER_POINTER (decl_name) != NULL)
10839 add_name_attribute (die, dwarf2_name (decl, 0));
10840 if (! DECL_ARTIFICIAL (decl))
10841 add_src_coords_attributes (die, decl);
10843 if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
10844 && TREE_PUBLIC (decl)
10845 && DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl)
10846 && !DECL_ABSTRACT (decl)
10847 && !(TREE_CODE (decl) == VAR_DECL && DECL_REGISTER (decl)))
10848 add_AT_string (die, DW_AT_MIPS_linkage_name,
10849 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
10852 #ifdef VMS_DEBUGGING_INFO
10853 /* Get the function's name, as described by its RTL. This may be different
10854 from the DECL_NAME name used in the source file. */
10855 if (TREE_CODE (decl) == FUNCTION_DECL && TREE_ASM_WRITTEN (decl))
10857 add_AT_addr (die, DW_AT_VMS_rtnbeg_pd_address,
10858 XEXP (DECL_RTL (decl), 0));
10859 VEC_safe_push (tree, gc, used_rtx_array, XEXP (DECL_RTL (decl), 0));
10864 /* Push a new declaration scope. */
10867 push_decl_scope (tree scope)
10869 VEC_safe_push (tree, gc, decl_scope_table, scope);
10872 /* Pop a declaration scope. */
10875 pop_decl_scope (void)
10877 VEC_pop (tree, decl_scope_table);
10880 /* Return the DIE for the scope that immediately contains this type.
10881 Non-named types get global scope. Named types nested in other
10882 types get their containing scope if it's open, or global scope
10883 otherwise. All other types (i.e. function-local named types) get
10884 the current active scope. */
10887 scope_die_for (tree t, dw_die_ref context_die)
10889 dw_die_ref scope_die = NULL;
10890 tree containing_scope;
10893 /* Non-types always go in the current scope. */
10894 gcc_assert (TYPE_P (t));
10896 containing_scope = TYPE_CONTEXT (t);
10898 /* Use the containing namespace if it was passed in (for a declaration). */
10899 if (containing_scope && TREE_CODE (containing_scope) == NAMESPACE_DECL)
10901 if (context_die == lookup_decl_die (containing_scope))
10904 containing_scope = NULL_TREE;
10907 /* Ignore function type "scopes" from the C frontend. They mean that
10908 a tagged type is local to a parmlist of a function declarator, but
10909 that isn't useful to DWARF. */
10910 if (containing_scope && TREE_CODE (containing_scope) == FUNCTION_TYPE)
10911 containing_scope = NULL_TREE;
10913 if (containing_scope == NULL_TREE)
10914 scope_die = comp_unit_die;
10915 else if (TYPE_P (containing_scope))
10917 /* For types, we can just look up the appropriate DIE. But
10918 first we check to see if we're in the middle of emitting it
10919 so we know where the new DIE should go. */
10920 for (i = VEC_length (tree, decl_scope_table) - 1; i >= 0; --i)
10921 if (VEC_index (tree, decl_scope_table, i) == containing_scope)
10926 gcc_assert (debug_info_level <= DINFO_LEVEL_TERSE
10927 || TREE_ASM_WRITTEN (containing_scope));
10929 /* If none of the current dies are suitable, we get file scope. */
10930 scope_die = comp_unit_die;
10933 scope_die = lookup_type_die (containing_scope);
10936 scope_die = context_die;
10941 /* Returns nonzero if CONTEXT_DIE is internal to a function. */
10944 local_scope_p (dw_die_ref context_die)
10946 for (; context_die; context_die = context_die->die_parent)
10947 if (context_die->die_tag == DW_TAG_inlined_subroutine
10948 || context_die->die_tag == DW_TAG_subprogram)
10954 /* Returns nonzero if CONTEXT_DIE is a class or namespace, for deciding
10955 whether or not to treat a DIE in this context as a declaration. */
10958 class_or_namespace_scope_p (dw_die_ref context_die)
10960 return (context_die
10961 && (context_die->die_tag == DW_TAG_structure_type
10962 || context_die->die_tag == DW_TAG_union_type
10963 || context_die->die_tag == DW_TAG_namespace));
10966 /* Many forms of DIEs require a "type description" attribute. This
10967 routine locates the proper "type descriptor" die for the type given
10968 by 'type', and adds a DW_AT_type attribute below the given die. */
10971 add_type_attribute (dw_die_ref object_die, tree type, int decl_const,
10972 int decl_volatile, dw_die_ref context_die)
10974 enum tree_code code = TREE_CODE (type);
10975 dw_die_ref type_die = NULL;
10977 /* ??? If this type is an unnamed subrange type of an integral or
10978 floating-point type, use the inner type. This is because we have no
10979 support for unnamed types in base_type_die. This can happen if this is
10980 an Ada subrange type. Correct solution is emit a subrange type die. */
10981 if ((code == INTEGER_TYPE || code == REAL_TYPE)
10982 && TREE_TYPE (type) != 0 && TYPE_NAME (type) == 0)
10983 type = TREE_TYPE (type), code = TREE_CODE (type);
10985 if (code == ERROR_MARK
10986 /* Handle a special case. For functions whose return type is void, we
10987 generate *no* type attribute. (Note that no object may have type
10988 `void', so this only applies to function return types). */
10989 || code == VOID_TYPE)
10992 type_die = modified_type_die (type,
10993 decl_const || TYPE_READONLY (type),
10994 decl_volatile || TYPE_VOLATILE (type),
10997 if (type_die != NULL)
10998 add_AT_die_ref (object_die, DW_AT_type, type_die);
11001 /* Given an object die, add the calling convention attribute for the
11002 function call type. */
11004 add_calling_convention_attribute (dw_die_ref subr_die, tree type)
11006 enum dwarf_calling_convention value = DW_CC_normal;
11008 value = targetm.dwarf_calling_convention (type);
11010 /* Only add the attribute if the backend requests it, and
11011 is not DW_CC_normal. */
11012 if (value && (value != DW_CC_normal))
11013 add_AT_unsigned (subr_die, DW_AT_calling_convention, value);
11016 /* Given a tree pointer to a struct, class, union, or enum type node, return
11017 a pointer to the (string) tag name for the given type, or zero if the type
11018 was declared without a tag. */
11020 static const char *
11021 type_tag (tree type)
11023 const char *name = 0;
11025 if (TYPE_NAME (type) != 0)
11029 /* Find the IDENTIFIER_NODE for the type name. */
11030 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
11031 t = TYPE_NAME (type);
11033 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
11034 a TYPE_DECL node, regardless of whether or not a `typedef' was
11036 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
11037 && ! DECL_IGNORED_P (TYPE_NAME (type)))
11038 t = DECL_NAME (TYPE_NAME (type));
11040 /* Now get the name as a string, or invent one. */
11042 name = IDENTIFIER_POINTER (t);
11045 return (name == 0 || *name == '\0') ? 0 : name;
11048 /* Return the type associated with a data member, make a special check
11049 for bit field types. */
11052 member_declared_type (tree member)
11054 return (DECL_BIT_FIELD_TYPE (member)
11055 ? DECL_BIT_FIELD_TYPE (member) : TREE_TYPE (member));
11058 /* Get the decl's label, as described by its RTL. This may be different
11059 from the DECL_NAME name used in the source file. */
11062 static const char *
11063 decl_start_label (tree decl)
11066 const char *fnname;
11068 x = DECL_RTL (decl);
11069 gcc_assert (MEM_P (x));
11072 gcc_assert (GET_CODE (x) == SYMBOL_REF);
11074 fnname = XSTR (x, 0);
11079 /* These routines generate the internal representation of the DIE's for
11080 the compilation unit. Debugging information is collected by walking
11081 the declaration trees passed in from dwarf2out_decl(). */
11084 gen_array_type_die (tree type, dw_die_ref context_die)
11086 dw_die_ref scope_die = scope_die_for (type, context_die);
11087 dw_die_ref array_die;
11090 /* ??? The SGI dwarf reader fails for array of array of enum types unless
11091 the inner array type comes before the outer array type. Thus we must
11092 call gen_type_die before we call new_die. See below also. */
11093 #ifdef MIPS_DEBUGGING_INFO
11094 gen_type_die (TREE_TYPE (type), context_die);
11097 array_die = new_die (DW_TAG_array_type, scope_die, type);
11098 add_name_attribute (array_die, type_tag (type));
11099 equate_type_number_to_die (type, array_die);
11101 if (TREE_CODE (type) == VECTOR_TYPE)
11103 /* The frontend feeds us a representation for the vector as a struct
11104 containing an array. Pull out the array type. */
11105 type = TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type)));
11106 add_AT_flag (array_die, DW_AT_GNU_vector, 1);
11110 /* We default the array ordering. SDB will probably do
11111 the right things even if DW_AT_ordering is not present. It's not even
11112 an issue until we start to get into multidimensional arrays anyway. If
11113 SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
11114 then we'll have to put the DW_AT_ordering attribute back in. (But if
11115 and when we find out that we need to put these in, we will only do so
11116 for multidimensional arrays. */
11117 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major);
11120 #ifdef MIPS_DEBUGGING_INFO
11121 /* The SGI compilers handle arrays of unknown bound by setting
11122 AT_declaration and not emitting any subrange DIEs. */
11123 if (! TYPE_DOMAIN (type))
11124 add_AT_flag (array_die, DW_AT_declaration, 1);
11127 add_subscript_info (array_die, type);
11129 /* Add representation of the type of the elements of this array type. */
11130 element_type = TREE_TYPE (type);
11132 /* ??? The SGI dwarf reader fails for multidimensional arrays with a
11133 const enum type. E.g. const enum machine_mode insn_operand_mode[2][10].
11134 We work around this by disabling this feature. See also
11135 add_subscript_info. */
11136 #ifndef MIPS_DEBUGGING_INFO
11137 while (TREE_CODE (element_type) == ARRAY_TYPE)
11138 element_type = TREE_TYPE (element_type);
11140 gen_type_die (element_type, context_die);
11143 add_type_attribute (array_die, element_type, 0, 0, context_die);
11148 gen_entry_point_die (tree decl, dw_die_ref context_die)
11150 tree origin = decl_ultimate_origin (decl);
11151 dw_die_ref decl_die = new_die (DW_TAG_entry_point, context_die, decl);
11153 if (origin != NULL)
11154 add_abstract_origin_attribute (decl_die, origin);
11157 add_name_and_src_coords_attributes (decl_die, decl);
11158 add_type_attribute (decl_die, TREE_TYPE (TREE_TYPE (decl)),
11159 0, 0, context_die);
11162 if (DECL_ABSTRACT (decl))
11163 equate_decl_number_to_die (decl, decl_die);
11165 add_AT_lbl_id (decl_die, DW_AT_low_pc, decl_start_label (decl));
11169 /* Walk through the list of incomplete types again, trying once more to
11170 emit full debugging info for them. */
11173 retry_incomplete_types (void)
11177 for (i = VEC_length (tree, incomplete_types) - 1; i >= 0; i--)
11178 gen_type_die (VEC_index (tree, incomplete_types, i), comp_unit_die);
11181 /* Generate a DIE to represent an inlined instance of an enumeration type. */
11184 gen_inlined_enumeration_type_die (tree type, dw_die_ref context_die)
11186 dw_die_ref type_die = new_die (DW_TAG_enumeration_type, context_die, type);
11188 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
11189 be incomplete and such types are not marked. */
11190 add_abstract_origin_attribute (type_die, type);
11193 /* Generate a DIE to represent an inlined instance of a structure type. */
11196 gen_inlined_structure_type_die (tree type, dw_die_ref context_die)
11198 dw_die_ref type_die = new_die (DW_TAG_structure_type, context_die, type);
11200 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
11201 be incomplete and such types are not marked. */
11202 add_abstract_origin_attribute (type_die, type);
11205 /* Generate a DIE to represent an inlined instance of a union type. */
11208 gen_inlined_union_type_die (tree type, dw_die_ref context_die)
11210 dw_die_ref type_die = new_die (DW_TAG_union_type, context_die, type);
11212 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
11213 be incomplete and such types are not marked. */
11214 add_abstract_origin_attribute (type_die, type);
11217 /* Generate a DIE to represent an enumeration type. Note that these DIEs
11218 include all of the information about the enumeration values also. Each
11219 enumerated type name/value is listed as a child of the enumerated type
11223 gen_enumeration_type_die (tree type, dw_die_ref context_die)
11225 dw_die_ref type_die = lookup_type_die (type);
11227 if (type_die == NULL)
11229 type_die = new_die (DW_TAG_enumeration_type,
11230 scope_die_for (type, context_die), type);
11231 equate_type_number_to_die (type, type_die);
11232 add_name_attribute (type_die, type_tag (type));
11234 else if (! TYPE_SIZE (type))
11237 remove_AT (type_die, DW_AT_declaration);
11239 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the
11240 given enum type is incomplete, do not generate the DW_AT_byte_size
11241 attribute or the DW_AT_element_list attribute. */
11242 if (TYPE_SIZE (type))
11246 TREE_ASM_WRITTEN (type) = 1;
11247 add_byte_size_attribute (type_die, type);
11248 if (TYPE_STUB_DECL (type) != NULL_TREE)
11249 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
11251 /* If the first reference to this type was as the return type of an
11252 inline function, then it may not have a parent. Fix this now. */
11253 if (type_die->die_parent == NULL)
11254 add_child_die (scope_die_for (type, context_die), type_die);
11256 for (link = TYPE_VALUES (type);
11257 link != NULL; link = TREE_CHAIN (link))
11259 dw_die_ref enum_die = new_die (DW_TAG_enumerator, type_die, link);
11260 tree value = TREE_VALUE (link);
11262 add_name_attribute (enum_die,
11263 IDENTIFIER_POINTER (TREE_PURPOSE (link)));
11265 if (host_integerp (value, TYPE_UNSIGNED (TREE_TYPE (value))))
11266 /* DWARF2 does not provide a way of indicating whether or
11267 not enumeration constants are signed or unsigned. GDB
11268 always assumes the values are signed, so we output all
11269 values as if they were signed. That means that
11270 enumeration constants with very large unsigned values
11271 will appear to have negative values in the debugger. */
11272 add_AT_int (enum_die, DW_AT_const_value,
11273 tree_low_cst (value, tree_int_cst_sgn (value) > 0));
11277 add_AT_flag (type_die, DW_AT_declaration, 1);
11282 /* Generate a DIE to represent either a real live formal parameter decl or to
11283 represent just the type of some formal parameter position in some function
11286 Note that this routine is a bit unusual because its argument may be a
11287 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
11288 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
11289 node. If it's the former then this function is being called to output a
11290 DIE to represent a formal parameter object (or some inlining thereof). If
11291 it's the latter, then this function is only being called to output a
11292 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
11293 argument type of some subprogram type. */
11296 gen_formal_parameter_die (tree node, dw_die_ref context_die)
11298 dw_die_ref parm_die
11299 = new_die (DW_TAG_formal_parameter, context_die, node);
11302 switch (TREE_CODE_CLASS (TREE_CODE (node)))
11304 case tcc_declaration:
11305 origin = decl_ultimate_origin (node);
11306 if (origin != NULL)
11307 add_abstract_origin_attribute (parm_die, origin);
11310 add_name_and_src_coords_attributes (parm_die, node);
11311 add_type_attribute (parm_die, TREE_TYPE (node),
11312 TREE_READONLY (node),
11313 TREE_THIS_VOLATILE (node),
11315 if (DECL_ARTIFICIAL (node))
11316 add_AT_flag (parm_die, DW_AT_artificial, 1);
11319 equate_decl_number_to_die (node, parm_die);
11320 if (! DECL_ABSTRACT (node))
11321 add_location_or_const_value_attribute (parm_die, node, DW_AT_location);
11326 /* We were called with some kind of a ..._TYPE node. */
11327 add_type_attribute (parm_die, node, 0, 0, context_die);
11331 gcc_unreachable ();
11337 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
11338 at the end of an (ANSI prototyped) formal parameters list. */
11341 gen_unspecified_parameters_die (tree decl_or_type, dw_die_ref context_die)
11343 new_die (DW_TAG_unspecified_parameters, context_die, decl_or_type);
11346 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
11347 DW_TAG_unspecified_parameters DIE) to represent the types of the formal
11348 parameters as specified in some function type specification (except for
11349 those which appear as part of a function *definition*). */
11352 gen_formal_types_die (tree function_or_method_type, dw_die_ref context_die)
11355 tree formal_type = NULL;
11356 tree first_parm_type;
11359 if (TREE_CODE (function_or_method_type) == FUNCTION_DECL)
11361 arg = DECL_ARGUMENTS (function_or_method_type);
11362 function_or_method_type = TREE_TYPE (function_or_method_type);
11367 first_parm_type = TYPE_ARG_TYPES (function_or_method_type);
11369 /* Make our first pass over the list of formal parameter types and output a
11370 DW_TAG_formal_parameter DIE for each one. */
11371 for (link = first_parm_type; link; )
11373 dw_die_ref parm_die;
11375 formal_type = TREE_VALUE (link);
11376 if (formal_type == void_type_node)
11379 /* Output a (nameless) DIE to represent the formal parameter itself. */
11380 parm_die = gen_formal_parameter_die (formal_type, context_die);
11381 if ((TREE_CODE (function_or_method_type) == METHOD_TYPE
11382 && link == first_parm_type)
11383 || (arg && DECL_ARTIFICIAL (arg)))
11384 add_AT_flag (parm_die, DW_AT_artificial, 1);
11386 link = TREE_CHAIN (link);
11388 arg = TREE_CHAIN (arg);
11391 /* If this function type has an ellipsis, add a
11392 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */
11393 if (formal_type != void_type_node)
11394 gen_unspecified_parameters_die (function_or_method_type, context_die);
11396 /* Make our second (and final) pass over the list of formal parameter types
11397 and output DIEs to represent those types (as necessary). */
11398 for (link = TYPE_ARG_TYPES (function_or_method_type);
11399 link && TREE_VALUE (link);
11400 link = TREE_CHAIN (link))
11401 gen_type_die (TREE_VALUE (link), context_die);
11404 /* We want to generate the DIE for TYPE so that we can generate the
11405 die for MEMBER, which has been defined; we will need to refer back
11406 to the member declaration nested within TYPE. If we're trying to
11407 generate minimal debug info for TYPE, processing TYPE won't do the
11408 trick; we need to attach the member declaration by hand. */
11411 gen_type_die_for_member (tree type, tree member, dw_die_ref context_die)
11413 gen_type_die (type, context_die);
11415 /* If we're trying to avoid duplicate debug info, we may not have
11416 emitted the member decl for this function. Emit it now. */
11417 if (TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))
11418 && ! lookup_decl_die (member))
11420 dw_die_ref type_die;
11421 gcc_assert (!decl_ultimate_origin (member));
11423 push_decl_scope (type);
11424 type_die = lookup_type_die (type);
11425 if (TREE_CODE (member) == FUNCTION_DECL)
11426 gen_subprogram_die (member, type_die);
11427 else if (TREE_CODE (member) == FIELD_DECL)
11429 /* Ignore the nameless fields that are used to skip bits but handle
11430 C++ anonymous unions and structs. */
11431 if (DECL_NAME (member) != NULL_TREE
11432 || TREE_CODE (TREE_TYPE (member)) == UNION_TYPE
11433 || TREE_CODE (TREE_TYPE (member)) == RECORD_TYPE)
11435 gen_type_die (member_declared_type (member), type_die);
11436 gen_field_die (member, type_die);
11440 gen_variable_die (member, type_die);
11446 /* Generate the DWARF2 info for the "abstract" instance of a function which we
11447 may later generate inlined and/or out-of-line instances of. */
11450 dwarf2out_abstract_function (tree decl)
11452 dw_die_ref old_die;
11455 int was_abstract = DECL_ABSTRACT (decl);
11457 /* Make sure we have the actual abstract inline, not a clone. */
11458 decl = DECL_ORIGIN (decl);
11460 old_die = lookup_decl_die (decl);
11461 if (old_die && get_AT (old_die, DW_AT_inline))
11462 /* We've already generated the abstract instance. */
11465 /* Be sure we've emitted the in-class declaration DIE (if any) first, so
11466 we don't get confused by DECL_ABSTRACT. */
11467 if (debug_info_level > DINFO_LEVEL_TERSE)
11469 context = decl_class_context (decl);
11471 gen_type_die_for_member
11472 (context, decl, decl_function_context (decl) ? NULL : comp_unit_die);
11475 /* Pretend we've just finished compiling this function. */
11476 save_fn = current_function_decl;
11477 current_function_decl = decl;
11479 set_decl_abstract_flags (decl, 1);
11480 dwarf2out_decl (decl);
11481 if (! was_abstract)
11482 set_decl_abstract_flags (decl, 0);
11484 current_function_decl = save_fn;
11487 /* Generate a DIE to represent a declared function (either file-scope or
11491 gen_subprogram_die (tree decl, dw_die_ref context_die)
11493 char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
11494 tree origin = decl_ultimate_origin (decl);
11495 dw_die_ref subr_die;
11498 dw_die_ref old_die = lookup_decl_die (decl);
11499 int declaration = (current_function_decl != decl
11500 || class_or_namespace_scope_p (context_die));
11502 /* It is possible to have both DECL_ABSTRACT and DECLARATION be true if we
11503 started to generate the abstract instance of an inline, decided to output
11504 its containing class, and proceeded to emit the declaration of the inline
11505 from the member list for the class. If so, DECLARATION takes priority;
11506 we'll get back to the abstract instance when done with the class. */
11508 /* The class-scope declaration DIE must be the primary DIE. */
11509 if (origin && declaration && class_or_namespace_scope_p (context_die))
11512 gcc_assert (!old_die);
11515 /* Now that the C++ front end lazily declares artificial member fns, we
11516 might need to retrofit the declaration into its class. */
11517 if (!declaration && !origin && !old_die
11518 && DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl))
11519 && !class_or_namespace_scope_p (context_die)
11520 && debug_info_level > DINFO_LEVEL_TERSE)
11521 old_die = force_decl_die (decl);
11523 if (origin != NULL)
11525 gcc_assert (!declaration || local_scope_p (context_die));
11527 /* Fixup die_parent for the abstract instance of a nested
11528 inline function. */
11529 if (old_die && old_die->die_parent == NULL)
11530 add_child_die (context_die, old_die);
11532 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
11533 add_abstract_origin_attribute (subr_die, origin);
11537 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
11538 unsigned file_index = lookup_filename (s.file);
11540 if (!get_AT_flag (old_die, DW_AT_declaration)
11541 /* We can have a normal definition following an inline one in the
11542 case of redefinition of GNU C extern inlines.
11543 It seems reasonable to use AT_specification in this case. */
11544 && !get_AT (old_die, DW_AT_inline))
11546 /* Detect and ignore this case, where we are trying to output
11547 something we have already output. */
11551 /* If the definition comes from the same place as the declaration,
11552 maybe use the old DIE. We always want the DIE for this function
11553 that has the *_pc attributes to be under comp_unit_die so the
11554 debugger can find it. We also need to do this for abstract
11555 instances of inlines, since the spec requires the out-of-line copy
11556 to have the same parent. For local class methods, this doesn't
11557 apply; we just use the old DIE. */
11558 if ((old_die->die_parent == comp_unit_die || context_die == NULL)
11559 && (DECL_ARTIFICIAL (decl)
11560 || (get_AT_unsigned (old_die, DW_AT_decl_file) == file_index
11561 && (get_AT_unsigned (old_die, DW_AT_decl_line)
11562 == (unsigned) s.line))))
11564 subr_die = old_die;
11566 /* Clear out the declaration attribute and the formal parameters.
11567 Do not remove all children, because it is possible that this
11568 declaration die was forced using force_decl_die(). In such
11569 cases die that forced declaration die (e.g. TAG_imported_module)
11570 is one of the children that we do not want to remove. */
11571 remove_AT (subr_die, DW_AT_declaration);
11572 remove_child_TAG (subr_die, DW_TAG_formal_parameter);
11576 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
11577 add_AT_specification (subr_die, old_die);
11578 if (get_AT_unsigned (old_die, DW_AT_decl_file) != file_index)
11579 add_AT_unsigned (subr_die, DW_AT_decl_file, file_index);
11580 if (get_AT_unsigned (old_die, DW_AT_decl_line)
11581 != (unsigned) s.line)
11583 (subr_die, DW_AT_decl_line, s.line);
11588 subr_die = new_die (DW_TAG_subprogram, context_die, decl);
11590 if (TREE_PUBLIC (decl))
11591 add_AT_flag (subr_die, DW_AT_external, 1);
11593 add_name_and_src_coords_attributes (subr_die, decl);
11594 if (debug_info_level > DINFO_LEVEL_TERSE)
11596 add_prototyped_attribute (subr_die, TREE_TYPE (decl));
11597 add_type_attribute (subr_die, TREE_TYPE (TREE_TYPE (decl)),
11598 0, 0, context_die);
11601 add_pure_or_virtual_attribute (subr_die, decl);
11602 if (DECL_ARTIFICIAL (decl))
11603 add_AT_flag (subr_die, DW_AT_artificial, 1);
11605 if (TREE_PROTECTED (decl))
11606 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_protected);
11607 else if (TREE_PRIVATE (decl))
11608 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_private);
11613 if (!old_die || !get_AT (old_die, DW_AT_inline))
11615 add_AT_flag (subr_die, DW_AT_declaration, 1);
11617 /* The first time we see a member function, it is in the context of
11618 the class to which it belongs. We make sure of this by emitting
11619 the class first. The next time is the definition, which is
11620 handled above. The two may come from the same source text.
11622 Note that force_decl_die() forces function declaration die. It is
11623 later reused to represent definition. */
11624 equate_decl_number_to_die (decl, subr_die);
11627 else if (DECL_ABSTRACT (decl))
11629 if (DECL_DECLARED_INLINE_P (decl))
11631 if (cgraph_function_possibly_inlined_p (decl))
11632 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_inlined);
11634 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_not_inlined);
11638 if (cgraph_function_possibly_inlined_p (decl))
11639 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_inlined);
11641 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_not_inlined);
11644 equate_decl_number_to_die (decl, subr_die);
11646 else if (!DECL_EXTERNAL (decl))
11648 if (!old_die || !get_AT (old_die, DW_AT_inline))
11649 equate_decl_number_to_die (decl, subr_die);
11651 if (!flag_reorder_blocks_and_partition)
11653 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_BEGIN_LABEL,
11654 current_function_funcdef_no);
11655 add_AT_lbl_id (subr_die, DW_AT_low_pc, label_id);
11656 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
11657 current_function_funcdef_no);
11658 add_AT_lbl_id (subr_die, DW_AT_high_pc, label_id);
11660 add_pubname (decl, subr_die);
11661 add_arange (decl, subr_die);
11664 { /* Do nothing for now; maybe need to duplicate die, one for
11665 hot section and ond for cold section, then use the hot/cold
11666 section begin/end labels to generate the aranges... */
11668 add_AT_lbl_id (subr_die, DW_AT_low_pc, hot_section_label);
11669 add_AT_lbl_id (subr_die, DW_AT_high_pc, hot_section_end_label);
11670 add_AT_lbl_id (subr_die, DW_AT_lo_user, unlikely_section_label);
11671 add_AT_lbl_id (subr_die, DW_AT_hi_user, cold_section_end_label);
11673 add_pubname (decl, subr_die);
11674 add_arange (decl, subr_die);
11675 add_arange (decl, subr_die);
11679 #ifdef MIPS_DEBUGGING_INFO
11680 /* Add a reference to the FDE for this routine. */
11681 add_AT_fde_ref (subr_die, DW_AT_MIPS_fde, current_funcdef_fde);
11684 /* We define the "frame base" as the function's CFA. This is more
11685 convenient for several reasons: (1) It's stable across the prologue
11686 and epilogue, which makes it better than just a frame pointer,
11687 (2) With dwarf3, there exists a one-byte encoding that allows us
11688 to reference the .debug_frame data by proxy, but failing that,
11689 (3) We can at least reuse the code inspection and interpretation
11690 code that determines the CFA position at various points in the
11692 /* ??? Use some command-line or configury switch to enable the use
11693 of dwarf3 DW_OP_call_frame_cfa. At present there are no dwarf
11694 consumers that understand it; fall back to "pure" dwarf2 and
11695 convert the CFA data into a location list. */
11697 dw_loc_list_ref list = convert_cfa_to_loc_list ();
11698 if (list->dw_loc_next)
11699 add_AT_loc_list (subr_die, DW_AT_frame_base, list);
11701 add_AT_loc (subr_die, DW_AT_frame_base, list->expr);
11704 /* Compute a displacement from the "steady-state frame pointer" to
11705 the CFA. The former is what all stack slots and argument slots
11706 will reference in the rtl; the later is what we've told the
11707 debugger about. We'll need to adjust all frame_base references
11708 by this displacement. */
11709 compute_frame_pointer_to_cfa_displacement ();
11711 if (cfun->static_chain_decl)
11712 add_AT_location_description (subr_die, DW_AT_static_link,
11713 loc_descriptor_from_tree (cfun->static_chain_decl));
11716 /* Now output descriptions of the arguments for this function. This gets
11717 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
11718 for a FUNCTION_DECL doesn't indicate cases where there was a trailing
11719 `...' at the end of the formal parameter list. In order to find out if
11720 there was a trailing ellipsis or not, we must instead look at the type
11721 associated with the FUNCTION_DECL. This will be a node of type
11722 FUNCTION_TYPE. If the chain of type nodes hanging off of this
11723 FUNCTION_TYPE node ends with a void_type_node then there should *not* be
11724 an ellipsis at the end. */
11726 /* In the case where we are describing a mere function declaration, all we
11727 need to do here (and all we *can* do here) is to describe the *types* of
11728 its formal parameters. */
11729 if (debug_info_level <= DINFO_LEVEL_TERSE)
11731 else if (declaration)
11732 gen_formal_types_die (decl, subr_die);
11735 /* Generate DIEs to represent all known formal parameters. */
11736 tree arg_decls = DECL_ARGUMENTS (decl);
11739 /* When generating DIEs, generate the unspecified_parameters DIE
11740 instead if we come across the arg "__builtin_va_alist" */
11741 for (parm = arg_decls; parm; parm = TREE_CHAIN (parm))
11742 if (TREE_CODE (parm) == PARM_DECL)
11744 if (DECL_NAME (parm)
11745 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (parm)),
11746 "__builtin_va_alist"))
11747 gen_unspecified_parameters_die (parm, subr_die);
11749 gen_decl_die (parm, subr_die);
11752 /* Decide whether we need an unspecified_parameters DIE at the end.
11753 There are 2 more cases to do this for: 1) the ansi ... declaration -
11754 this is detectable when the end of the arg list is not a
11755 void_type_node 2) an unprototyped function declaration (not a
11756 definition). This just means that we have no info about the
11757 parameters at all. */
11758 fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
11759 if (fn_arg_types != NULL)
11761 /* This is the prototyped case, check for.... */
11762 if (TREE_VALUE (tree_last (fn_arg_types)) != void_type_node)
11763 gen_unspecified_parameters_die (decl, subr_die);
11765 else if (DECL_INITIAL (decl) == NULL_TREE)
11766 gen_unspecified_parameters_die (decl, subr_die);
11769 /* Output Dwarf info for all of the stuff within the body of the function
11770 (if it has one - it may be just a declaration). */
11771 outer_scope = DECL_INITIAL (decl);
11773 /* OUTER_SCOPE is a pointer to the outermost BLOCK node created to represent
11774 a function. This BLOCK actually represents the outermost binding contour
11775 for the function, i.e. the contour in which the function's formal
11776 parameters and labels get declared. Curiously, it appears that the front
11777 end doesn't actually put the PARM_DECL nodes for the current function onto
11778 the BLOCK_VARS list for this outer scope, but are strung off of the
11779 DECL_ARGUMENTS list for the function instead.
11781 The BLOCK_VARS list for the `outer_scope' does provide us with a list of
11782 the LABEL_DECL nodes for the function however, and we output DWARF info
11783 for those in decls_for_scope. Just within the `outer_scope' there will be
11784 a BLOCK node representing the function's outermost pair of curly braces,
11785 and any blocks used for the base and member initializers of a C++
11786 constructor function. */
11787 if (! declaration && TREE_CODE (outer_scope) != ERROR_MARK)
11789 /* Emit a DW_TAG_variable DIE for a named return value. */
11790 if (DECL_NAME (DECL_RESULT (decl)))
11791 gen_decl_die (DECL_RESULT (decl), subr_die);
11793 current_function_has_inlines = 0;
11794 decls_for_scope (outer_scope, subr_die, 0);
11796 #if 0 && defined (MIPS_DEBUGGING_INFO)
11797 if (current_function_has_inlines)
11799 add_AT_flag (subr_die, DW_AT_MIPS_has_inlines, 1);
11800 if (! comp_unit_has_inlines)
11802 add_AT_flag (comp_unit_die, DW_AT_MIPS_has_inlines, 1);
11803 comp_unit_has_inlines = 1;
11808 /* Add the calling convention attribute if requested. */
11809 add_calling_convention_attribute (subr_die, TREE_TYPE (decl));
11813 /* Generate a DIE to represent a declared data object. */
11816 gen_variable_die (tree decl, dw_die_ref context_die)
11818 tree origin = decl_ultimate_origin (decl);
11819 dw_die_ref var_die = new_die (DW_TAG_variable, context_die, decl);
11821 dw_die_ref old_die = lookup_decl_die (decl);
11822 int declaration = (DECL_EXTERNAL (decl)
11823 /* If DECL is COMDAT and has not actually been
11824 emitted, we cannot take its address; there
11825 might end up being no definition anywhere in
11826 the program. For example, consider the C++
11830 struct S { static const int i = 7; };
11835 int f() { return S<int>::i; }
11837 Here, S<int>::i is not DECL_EXTERNAL, but no
11838 definition is required, so the compiler will
11839 not emit a definition. */
11840 || (TREE_CODE (decl) == VAR_DECL
11841 && DECL_COMDAT (decl) && !TREE_ASM_WRITTEN (decl))
11842 || class_or_namespace_scope_p (context_die));
11844 if (origin != NULL)
11845 add_abstract_origin_attribute (var_die, origin);
11847 /* Loop unrolling can create multiple blocks that refer to the same
11848 static variable, so we must test for the DW_AT_declaration flag.
11850 ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
11851 copy decls and set the DECL_ABSTRACT flag on them instead of
11854 ??? Duplicated blocks have been rewritten to use .debug_ranges.
11856 ??? The declare_in_namespace support causes us to get two DIEs for one
11857 variable, both of which are declarations. We want to avoid considering
11858 one to be a specification, so we must test that this DIE is not a
11860 else if (old_die && TREE_STATIC (decl) && ! declaration
11861 && get_AT_flag (old_die, DW_AT_declaration) == 1)
11863 /* This is a definition of a C++ class level static. */
11864 add_AT_specification (var_die, old_die);
11865 if (DECL_NAME (decl))
11867 expanded_location s = expand_location (DECL_SOURCE_LOCATION (decl));
11868 unsigned file_index = lookup_filename (s.file);
11870 if (get_AT_unsigned (old_die, DW_AT_decl_file) != file_index)
11871 add_AT_unsigned (var_die, DW_AT_decl_file, file_index);
11873 if (get_AT_unsigned (old_die, DW_AT_decl_line)
11874 != (unsigned) s.line)
11876 add_AT_unsigned (var_die, DW_AT_decl_line, s.line);
11881 add_name_and_src_coords_attributes (var_die, decl);
11882 add_type_attribute (var_die, TREE_TYPE (decl), TREE_READONLY (decl),
11883 TREE_THIS_VOLATILE (decl), context_die);
11885 if (TREE_PUBLIC (decl))
11886 add_AT_flag (var_die, DW_AT_external, 1);
11888 if (DECL_ARTIFICIAL (decl))
11889 add_AT_flag (var_die, DW_AT_artificial, 1);
11891 if (TREE_PROTECTED (decl))
11892 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_protected);
11893 else if (TREE_PRIVATE (decl))
11894 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_private);
11898 add_AT_flag (var_die, DW_AT_declaration, 1);
11900 if (DECL_ABSTRACT (decl) || declaration)
11901 equate_decl_number_to_die (decl, var_die);
11903 if (! declaration && ! DECL_ABSTRACT (decl))
11905 add_location_or_const_value_attribute (var_die, decl, DW_AT_location);
11906 add_pubname (decl, var_die);
11909 tree_add_const_value_attribute (var_die, decl);
11912 /* Generate a DIE to represent a label identifier. */
11915 gen_label_die (tree decl, dw_die_ref context_die)
11917 tree origin = decl_ultimate_origin (decl);
11918 dw_die_ref lbl_die = new_die (DW_TAG_label, context_die, decl);
11920 char label[MAX_ARTIFICIAL_LABEL_BYTES];
11922 if (origin != NULL)
11923 add_abstract_origin_attribute (lbl_die, origin);
11925 add_name_and_src_coords_attributes (lbl_die, decl);
11927 if (DECL_ABSTRACT (decl))
11928 equate_decl_number_to_die (decl, lbl_die);
11931 insn = DECL_RTL_IF_SET (decl);
11933 /* Deleted labels are programmer specified labels which have been
11934 eliminated because of various optimizations. We still emit them
11935 here so that it is possible to put breakpoints on them. */
11939 && NOTE_LINE_NUMBER (insn) == NOTE_INSN_DELETED_LABEL))))
11941 /* When optimization is enabled (via -O) some parts of the compiler
11942 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
11943 represent source-level labels which were explicitly declared by
11944 the user. This really shouldn't be happening though, so catch
11945 it if it ever does happen. */
11946 gcc_assert (!INSN_DELETED_P (insn));
11948 ASM_GENERATE_INTERNAL_LABEL (label, "L", CODE_LABEL_NUMBER (insn));
11949 add_AT_lbl_id (lbl_die, DW_AT_low_pc, label);
11954 /* A helper function for gen_inlined_subroutine_die. Add source coordinate
11955 attributes to the DIE for a block STMT, to describe where the inlined
11956 function was called from. This is similar to add_src_coords_attributes. */
11959 add_call_src_coords_attributes (tree stmt, dw_die_ref die)
11961 expanded_location s = expand_location (BLOCK_SOURCE_LOCATION (stmt));
11962 unsigned file_index = lookup_filename (s.file);
11964 add_AT_unsigned (die, DW_AT_call_file, file_index);
11965 add_AT_unsigned (die, DW_AT_call_line, s.line);
11968 /* A helper function for gen_lexical_block_die and gen_inlined_subroutine_die.
11969 Add low_pc and high_pc attributes to the DIE for a block STMT. */
11972 add_high_low_attributes (tree stmt, dw_die_ref die)
11974 char label[MAX_ARTIFICIAL_LABEL_BYTES];
11976 if (BLOCK_FRAGMENT_CHAIN (stmt))
11980 add_AT_range_list (die, DW_AT_ranges, add_ranges (stmt));
11982 chain = BLOCK_FRAGMENT_CHAIN (stmt);
11985 add_ranges (chain);
11986 chain = BLOCK_FRAGMENT_CHAIN (chain);
11993 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
11994 BLOCK_NUMBER (stmt));
11995 add_AT_lbl_id (die, DW_AT_low_pc, label);
11996 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL,
11997 BLOCK_NUMBER (stmt));
11998 add_AT_lbl_id (die, DW_AT_high_pc, label);
12002 /* Generate a DIE for a lexical block. */
12005 gen_lexical_block_die (tree stmt, dw_die_ref context_die, int depth)
12007 dw_die_ref stmt_die = new_die (DW_TAG_lexical_block, context_die, stmt);
12009 if (! BLOCK_ABSTRACT (stmt))
12010 add_high_low_attributes (stmt, stmt_die);
12012 decls_for_scope (stmt, stmt_die, depth);
12015 /* Generate a DIE for an inlined subprogram. */
12018 gen_inlined_subroutine_die (tree stmt, dw_die_ref context_die, int depth)
12020 tree decl = block_ultimate_origin (stmt);
12022 /* Emit info for the abstract instance first, if we haven't yet. We
12023 must emit this even if the block is abstract, otherwise when we
12024 emit the block below (or elsewhere), we may end up trying to emit
12025 a die whose origin die hasn't been emitted, and crashing. */
12026 dwarf2out_abstract_function (decl);
12028 if (! BLOCK_ABSTRACT (stmt))
12030 dw_die_ref subr_die
12031 = new_die (DW_TAG_inlined_subroutine, context_die, stmt);
12033 add_abstract_origin_attribute (subr_die, decl);
12034 add_high_low_attributes (stmt, subr_die);
12035 add_call_src_coords_attributes (stmt, subr_die);
12037 decls_for_scope (stmt, subr_die, depth);
12038 current_function_has_inlines = 1;
12041 /* We may get here if we're the outer block of function A that was
12042 inlined into function B that was inlined into function C. When
12043 generating debugging info for C, dwarf2out_abstract_function(B)
12044 would mark all inlined blocks as abstract, including this one.
12045 So, we wouldn't (and shouldn't) expect labels to be generated
12046 for this one. Instead, just emit debugging info for
12047 declarations within the block. This is particularly important
12048 in the case of initializers of arguments passed from B to us:
12049 if they're statement expressions containing declarations, we
12050 wouldn't generate dies for their abstract variables, and then,
12051 when generating dies for the real variables, we'd die (pun
12053 gen_lexical_block_die (stmt, context_die, depth);
12056 /* Generate a DIE for a field in a record, or structure. */
12059 gen_field_die (tree decl, dw_die_ref context_die)
12061 dw_die_ref decl_die;
12063 if (TREE_TYPE (decl) == error_mark_node)
12066 decl_die = new_die (DW_TAG_member, context_die, decl);
12067 add_name_and_src_coords_attributes (decl_die, decl);
12068 add_type_attribute (decl_die, member_declared_type (decl),
12069 TREE_READONLY (decl), TREE_THIS_VOLATILE (decl),
12072 if (DECL_BIT_FIELD_TYPE (decl))
12074 add_byte_size_attribute (decl_die, decl);
12075 add_bit_size_attribute (decl_die, decl);
12076 add_bit_offset_attribute (decl_die, decl);
12079 if (TREE_CODE (DECL_FIELD_CONTEXT (decl)) != UNION_TYPE)
12080 add_data_member_location_attribute (decl_die, decl);
12082 if (DECL_ARTIFICIAL (decl))
12083 add_AT_flag (decl_die, DW_AT_artificial, 1);
12085 if (TREE_PROTECTED (decl))
12086 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_protected);
12087 else if (TREE_PRIVATE (decl))
12088 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_private);
12090 /* Equate decl number to die, so that we can look up this decl later on. */
12091 equate_decl_number_to_die (decl, decl_die);
12095 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
12096 Use modified_type_die instead.
12097 We keep this code here just in case these types of DIEs may be needed to
12098 represent certain things in other languages (e.g. Pascal) someday. */
12101 gen_pointer_type_die (tree type, dw_die_ref context_die)
12104 = new_die (DW_TAG_pointer_type, scope_die_for (type, context_die), type);
12106 equate_type_number_to_die (type, ptr_die);
12107 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
12108 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
12111 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
12112 Use modified_type_die instead.
12113 We keep this code here just in case these types of DIEs may be needed to
12114 represent certain things in other languages (e.g. Pascal) someday. */
12117 gen_reference_type_die (tree type, dw_die_ref context_die)
12120 = new_die (DW_TAG_reference_type, scope_die_for (type, context_die), type);
12122 equate_type_number_to_die (type, ref_die);
12123 add_type_attribute (ref_die, TREE_TYPE (type), 0, 0, context_die);
12124 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
12128 /* Generate a DIE for a pointer to a member type. */
12131 gen_ptr_to_mbr_type_die (tree type, dw_die_ref context_die)
12134 = new_die (DW_TAG_ptr_to_member_type,
12135 scope_die_for (type, context_die), type);
12137 equate_type_number_to_die (type, ptr_die);
12138 add_AT_die_ref (ptr_die, DW_AT_containing_type,
12139 lookup_type_die (TYPE_OFFSET_BASETYPE (type)));
12140 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
12143 /* Generate the DIE for the compilation unit. */
12146 gen_compile_unit_die (const char *filename)
12149 char producer[250];
12150 const char *language_string = lang_hooks.name;
12153 die = new_die (DW_TAG_compile_unit, NULL, NULL);
12157 add_name_attribute (die, filename);
12158 /* Don't add cwd for <built-in>. */
12159 if (filename[0] != DIR_SEPARATOR && filename[0] != '<')
12160 add_comp_dir_attribute (die);
12163 sprintf (producer, "%s %s", language_string, version_string);
12165 #ifdef MIPS_DEBUGGING_INFO
12166 /* The MIPS/SGI compilers place the 'cc' command line options in the producer
12167 string. The SGI debugger looks for -g, -g1, -g2, or -g3; if they do
12168 not appear in the producer string, the debugger reaches the conclusion
12169 that the object file is stripped and has no debugging information.
12170 To get the MIPS/SGI debugger to believe that there is debugging
12171 information in the object file, we add a -g to the producer string. */
12172 if (debug_info_level > DINFO_LEVEL_TERSE)
12173 strcat (producer, " -g");
12176 add_AT_string (die, DW_AT_producer, producer);
12178 if (strcmp (language_string, "GNU C++") == 0)
12179 language = DW_LANG_C_plus_plus;
12180 else if (strcmp (language_string, "GNU Ada") == 0)
12181 language = DW_LANG_Ada95;
12182 else if (strcmp (language_string, "GNU F77") == 0)
12183 language = DW_LANG_Fortran77;
12184 else if (strcmp (language_string, "GNU F95") == 0)
12185 language = DW_LANG_Fortran95;
12186 else if (strcmp (language_string, "GNU Pascal") == 0)
12187 language = DW_LANG_Pascal83;
12188 else if (strcmp (language_string, "GNU Java") == 0)
12189 language = DW_LANG_Java;
12191 language = DW_LANG_C89;
12193 add_AT_unsigned (die, DW_AT_language, language);
12197 /* Generate a DIE for a string type. */
12200 gen_string_type_die (tree type, dw_die_ref context_die)
12202 dw_die_ref type_die
12203 = new_die (DW_TAG_string_type, scope_die_for (type, context_die), type);
12205 equate_type_number_to_die (type, type_die);
12207 /* ??? Fudge the string length attribute for now.
12208 TODO: add string length info. */
12210 string_length_attribute (TYPE_MAX_VALUE (TYPE_DOMAIN (type)));
12211 bound_representation (upper_bound, 0, 'u');
12215 /* Generate the DIE for a base class. */
12218 gen_inheritance_die (tree binfo, tree access, dw_die_ref context_die)
12220 dw_die_ref die = new_die (DW_TAG_inheritance, context_die, binfo);
12222 add_type_attribute (die, BINFO_TYPE (binfo), 0, 0, context_die);
12223 add_data_member_location_attribute (die, binfo);
12225 if (BINFO_VIRTUAL_P (binfo))
12226 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
12228 if (access == access_public_node)
12229 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public);
12230 else if (access == access_protected_node)
12231 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected);
12234 /* Generate a DIE for a class member. */
12237 gen_member_die (tree type, dw_die_ref context_die)
12240 tree binfo = TYPE_BINFO (type);
12243 /* If this is not an incomplete type, output descriptions of each of its
12244 members. Note that as we output the DIEs necessary to represent the
12245 members of this record or union type, we will also be trying to output
12246 DIEs to represent the *types* of those members. However the `type'
12247 function (above) will specifically avoid generating type DIEs for member
12248 types *within* the list of member DIEs for this (containing) type except
12249 for those types (of members) which are explicitly marked as also being
12250 members of this (containing) type themselves. The g++ front- end can
12251 force any given type to be treated as a member of some other (containing)
12252 type by setting the TYPE_CONTEXT of the given (member) type to point to
12253 the TREE node representing the appropriate (containing) type. */
12255 /* First output info about the base classes. */
12258 VEC(tree,gc) *accesses = BINFO_BASE_ACCESSES (binfo);
12262 for (i = 0; BINFO_BASE_ITERATE (binfo, i, base); i++)
12263 gen_inheritance_die (base,
12264 (accesses ? VEC_index (tree, accesses, i)
12265 : access_public_node), context_die);
12268 /* Now output info about the data members and type members. */
12269 for (member = TYPE_FIELDS (type); member; member = TREE_CHAIN (member))
12271 /* If we thought we were generating minimal debug info for TYPE
12272 and then changed our minds, some of the member declarations
12273 may have already been defined. Don't define them again, but
12274 do put them in the right order. */
12276 child = lookup_decl_die (member);
12278 splice_child_die (context_die, child);
12280 gen_decl_die (member, context_die);
12283 /* Now output info about the function members (if any). */
12284 for (member = TYPE_METHODS (type); member; member = TREE_CHAIN (member))
12286 /* Don't include clones in the member list. */
12287 if (DECL_ABSTRACT_ORIGIN (member))
12290 child = lookup_decl_die (member);
12292 splice_child_die (context_die, child);
12294 gen_decl_die (member, context_die);
12298 /* Generate a DIE for a structure or union type. If TYPE_DECL_SUPPRESS_DEBUG
12299 is set, we pretend that the type was never defined, so we only get the
12300 member DIEs needed by later specification DIEs. */
12303 gen_struct_or_union_type_die (tree type, dw_die_ref context_die)
12305 dw_die_ref type_die = lookup_type_die (type);
12306 dw_die_ref scope_die = 0;
12308 int complete = (TYPE_SIZE (type)
12309 && (! TYPE_STUB_DECL (type)
12310 || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))));
12311 int ns_decl = (context_die && context_die->die_tag == DW_TAG_namespace);
12313 if (type_die && ! complete)
12316 if (TYPE_CONTEXT (type) != NULL_TREE
12317 && (AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
12318 || TREE_CODE (TYPE_CONTEXT (type)) == NAMESPACE_DECL))
12321 scope_die = scope_die_for (type, context_die);
12323 if (! type_die || (nested && scope_die == comp_unit_die))
12324 /* First occurrence of type or toplevel definition of nested class. */
12326 dw_die_ref old_die = type_die;
12328 type_die = new_die (TREE_CODE (type) == RECORD_TYPE
12329 ? DW_TAG_structure_type : DW_TAG_union_type,
12331 equate_type_number_to_die (type, type_die);
12333 add_AT_specification (type_die, old_die);
12335 add_name_attribute (type_die, type_tag (type));
12338 remove_AT (type_die, DW_AT_declaration);
12340 /* If this type has been completed, then give it a byte_size attribute and
12341 then give a list of members. */
12342 if (complete && !ns_decl)
12344 /* Prevent infinite recursion in cases where the type of some member of
12345 this type is expressed in terms of this type itself. */
12346 TREE_ASM_WRITTEN (type) = 1;
12347 add_byte_size_attribute (type_die, type);
12348 if (TYPE_STUB_DECL (type) != NULL_TREE)
12349 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
12351 /* If the first reference to this type was as the return type of an
12352 inline function, then it may not have a parent. Fix this now. */
12353 if (type_die->die_parent == NULL)
12354 add_child_die (scope_die, type_die);
12356 push_decl_scope (type);
12357 gen_member_die (type, type_die);
12360 /* GNU extension: Record what type our vtable lives in. */
12361 if (TYPE_VFIELD (type))
12363 tree vtype = DECL_FCONTEXT (TYPE_VFIELD (type));
12365 gen_type_die (vtype, context_die);
12366 add_AT_die_ref (type_die, DW_AT_containing_type,
12367 lookup_type_die (vtype));
12372 add_AT_flag (type_die, DW_AT_declaration, 1);
12374 /* We don't need to do this for function-local types. */
12375 if (TYPE_STUB_DECL (type)
12376 && ! decl_function_context (TYPE_STUB_DECL (type)))
12377 VEC_safe_push (tree, gc, incomplete_types, type);
12381 /* Generate a DIE for a subroutine _type_. */
12384 gen_subroutine_type_die (tree type, dw_die_ref context_die)
12386 tree return_type = TREE_TYPE (type);
12387 dw_die_ref subr_die
12388 = new_die (DW_TAG_subroutine_type,
12389 scope_die_for (type, context_die), type);
12391 equate_type_number_to_die (type, subr_die);
12392 add_prototyped_attribute (subr_die, type);
12393 add_type_attribute (subr_die, return_type, 0, 0, context_die);
12394 gen_formal_types_die (type, subr_die);
12397 /* Generate a DIE for a type definition. */
12400 gen_typedef_die (tree decl, dw_die_ref context_die)
12402 dw_die_ref type_die;
12405 if (TREE_ASM_WRITTEN (decl))
12408 TREE_ASM_WRITTEN (decl) = 1;
12409 type_die = new_die (DW_TAG_typedef, context_die, decl);
12410 origin = decl_ultimate_origin (decl);
12411 if (origin != NULL)
12412 add_abstract_origin_attribute (type_die, origin);
12417 add_name_and_src_coords_attributes (type_die, decl);
12418 if (DECL_ORIGINAL_TYPE (decl))
12420 type = DECL_ORIGINAL_TYPE (decl);
12422 gcc_assert (type != TREE_TYPE (decl));
12423 equate_type_number_to_die (TREE_TYPE (decl), type_die);
12426 type = TREE_TYPE (decl);
12428 add_type_attribute (type_die, type, TREE_READONLY (decl),
12429 TREE_THIS_VOLATILE (decl), context_die);
12432 if (DECL_ABSTRACT (decl))
12433 equate_decl_number_to_die (decl, type_die);
12436 /* Generate a type description DIE. */
12439 gen_type_die (tree type, dw_die_ref context_die)
12443 if (type == NULL_TREE || type == error_mark_node)
12446 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
12447 && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
12449 if (TREE_ASM_WRITTEN (type))
12452 /* Prevent broken recursion; we can't hand off to the same type. */
12453 gcc_assert (DECL_ORIGINAL_TYPE (TYPE_NAME (type)) != type);
12455 TREE_ASM_WRITTEN (type) = 1;
12456 gen_decl_die (TYPE_NAME (type), context_die);
12460 /* We are going to output a DIE to represent the unqualified version
12461 of this type (i.e. without any const or volatile qualifiers) so
12462 get the main variant (i.e. the unqualified version) of this type
12463 now. (Vectors are special because the debugging info is in the
12464 cloned type itself). */
12465 if (TREE_CODE (type) != VECTOR_TYPE)
12466 type = type_main_variant (type);
12468 if (TREE_ASM_WRITTEN (type))
12471 switch (TREE_CODE (type))
12477 case REFERENCE_TYPE:
12478 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This
12479 ensures that the gen_type_die recursion will terminate even if the
12480 type is recursive. Recursive types are possible in Ada. */
12481 /* ??? We could perhaps do this for all types before the switch
12483 TREE_ASM_WRITTEN (type) = 1;
12485 /* For these types, all that is required is that we output a DIE (or a
12486 set of DIEs) to represent the "basis" type. */
12487 gen_type_die (TREE_TYPE (type), context_die);
12491 /* This code is used for C++ pointer-to-data-member types.
12492 Output a description of the relevant class type. */
12493 gen_type_die (TYPE_OFFSET_BASETYPE (type), context_die);
12495 /* Output a description of the type of the object pointed to. */
12496 gen_type_die (TREE_TYPE (type), context_die);
12498 /* Now output a DIE to represent this pointer-to-data-member type
12500 gen_ptr_to_mbr_type_die (type, context_die);
12503 case FUNCTION_TYPE:
12504 /* Force out return type (in case it wasn't forced out already). */
12505 gen_type_die (TREE_TYPE (type), context_die);
12506 gen_subroutine_type_die (type, context_die);
12510 /* Force out return type (in case it wasn't forced out already). */
12511 gen_type_die (TREE_TYPE (type), context_die);
12512 gen_subroutine_type_die (type, context_die);
12516 if (TYPE_STRING_FLAG (type) && TREE_CODE (TREE_TYPE (type)) == CHAR_TYPE)
12518 gen_type_die (TREE_TYPE (type), context_die);
12519 gen_string_type_die (type, context_die);
12522 gen_array_type_die (type, context_die);
12526 gen_array_type_die (type, context_die);
12529 case ENUMERAL_TYPE:
12532 case QUAL_UNION_TYPE:
12533 /* If this is a nested type whose containing class hasn't been written
12534 out yet, writing it out will cover this one, too. This does not apply
12535 to instantiations of member class templates; they need to be added to
12536 the containing class as they are generated. FIXME: This hurts the
12537 idea of combining type decls from multiple TUs, since we can't predict
12538 what set of template instantiations we'll get. */
12539 if (TYPE_CONTEXT (type)
12540 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
12541 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
12543 gen_type_die (TYPE_CONTEXT (type), context_die);
12545 if (TREE_ASM_WRITTEN (type))
12548 /* If that failed, attach ourselves to the stub. */
12549 push_decl_scope (TYPE_CONTEXT (type));
12550 context_die = lookup_type_die (TYPE_CONTEXT (type));
12555 declare_in_namespace (type, context_die);
12559 if (TREE_CODE (type) == ENUMERAL_TYPE)
12560 gen_enumeration_type_die (type, context_die);
12562 gen_struct_or_union_type_die (type, context_die);
12567 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
12568 it up if it is ever completed. gen_*_type_die will set it for us
12569 when appropriate. */
12578 /* No DIEs needed for fundamental types. */
12582 /* No Dwarf representation currently defined. */
12586 gcc_unreachable ();
12589 TREE_ASM_WRITTEN (type) = 1;
12592 /* Generate a DIE for a tagged type instantiation. */
12595 gen_tagged_type_instantiation_die (tree type, dw_die_ref context_die)
12597 if (type == NULL_TREE || type == error_mark_node)
12600 /* We are going to output a DIE to represent the unqualified version of
12601 this type (i.e. without any const or volatile qualifiers) so make sure
12602 that we have the main variant (i.e. the unqualified version) of this
12604 gcc_assert (type == type_main_variant (type));
12606 /* Do not check TREE_ASM_WRITTEN (type) as it may not be set if this is
12607 an instance of an unresolved type. */
12609 switch (TREE_CODE (type))
12614 case ENUMERAL_TYPE:
12615 gen_inlined_enumeration_type_die (type, context_die);
12619 gen_inlined_structure_type_die (type, context_die);
12623 case QUAL_UNION_TYPE:
12624 gen_inlined_union_type_die (type, context_die);
12628 gcc_unreachable ();
12632 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
12633 things which are local to the given block. */
12636 gen_block_die (tree stmt, dw_die_ref context_die, int depth)
12638 int must_output_die = 0;
12641 enum tree_code origin_code;
12643 /* Ignore blocks that are NULL. */
12644 if (stmt == NULL_TREE)
12647 /* If the block is one fragment of a non-contiguous block, do not
12648 process the variables, since they will have been done by the
12649 origin block. Do process subblocks. */
12650 if (BLOCK_FRAGMENT_ORIGIN (stmt))
12654 for (sub = BLOCK_SUBBLOCKS (stmt); sub; sub = BLOCK_CHAIN (sub))
12655 gen_block_die (sub, context_die, depth + 1);
12660 /* Determine the "ultimate origin" of this block. This block may be an
12661 inlined instance of an inlined instance of inline function, so we have
12662 to trace all of the way back through the origin chain to find out what
12663 sort of node actually served as the original seed for the creation of
12664 the current block. */
12665 origin = block_ultimate_origin (stmt);
12666 origin_code = (origin != NULL) ? TREE_CODE (origin) : ERROR_MARK;
12668 /* Determine if we need to output any Dwarf DIEs at all to represent this
12670 if (origin_code == FUNCTION_DECL)
12671 /* The outer scopes for inlinings *must* always be represented. We
12672 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */
12673 must_output_die = 1;
12676 /* In the case where the current block represents an inlining of the
12677 "body block" of an inline function, we must *NOT* output any DIE for
12678 this block because we have already output a DIE to represent the whole
12679 inlined function scope and the "body block" of any function doesn't
12680 really represent a different scope according to ANSI C rules. So we
12681 check here to make sure that this block does not represent a "body
12682 block inlining" before trying to set the MUST_OUTPUT_DIE flag. */
12683 if (! is_body_block (origin ? origin : stmt))
12685 /* Determine if this block directly contains any "significant"
12686 local declarations which we will need to output DIEs for. */
12687 if (debug_info_level > DINFO_LEVEL_TERSE)
12688 /* We are not in terse mode so *any* local declaration counts
12689 as being a "significant" one. */
12690 must_output_die = (BLOCK_VARS (stmt) != NULL
12691 && (TREE_USED (stmt)
12692 || TREE_ASM_WRITTEN (stmt)
12693 || BLOCK_ABSTRACT (stmt)));
12695 /* We are in terse mode, so only local (nested) function
12696 definitions count as "significant" local declarations. */
12697 for (decl = BLOCK_VARS (stmt);
12698 decl != NULL; decl = TREE_CHAIN (decl))
12699 if (TREE_CODE (decl) == FUNCTION_DECL
12700 && DECL_INITIAL (decl))
12702 must_output_die = 1;
12708 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
12709 DIE for any block which contains no significant local declarations at
12710 all. Rather, in such cases we just call `decls_for_scope' so that any
12711 needed Dwarf info for any sub-blocks will get properly generated. Note
12712 that in terse mode, our definition of what constitutes a "significant"
12713 local declaration gets restricted to include only inlined function
12714 instances and local (nested) function definitions. */
12715 if (must_output_die)
12717 if (origin_code == FUNCTION_DECL)
12718 gen_inlined_subroutine_die (stmt, context_die, depth);
12720 gen_lexical_block_die (stmt, context_die, depth);
12723 decls_for_scope (stmt, context_die, depth);
12726 /* Generate all of the decls declared within a given scope and (recursively)
12727 all of its sub-blocks. */
12730 decls_for_scope (tree stmt, dw_die_ref context_die, int depth)
12735 /* Ignore NULL blocks. */
12736 if (stmt == NULL_TREE)
12739 if (TREE_USED (stmt))
12741 /* Output the DIEs to represent all of the data objects and typedefs
12742 declared directly within this block but not within any nested
12743 sub-blocks. Also, nested function and tag DIEs have been
12744 generated with a parent of NULL; fix that up now. */
12745 for (decl = BLOCK_VARS (stmt); decl != NULL; decl = TREE_CHAIN (decl))
12749 if (TREE_CODE (decl) == FUNCTION_DECL)
12750 die = lookup_decl_die (decl);
12751 else if (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl))
12752 die = lookup_type_die (TREE_TYPE (decl));
12756 if (die != NULL && die->die_parent == NULL)
12757 add_child_die (context_die, die);
12758 /* Do not produce debug information for static variables since
12759 these might be optimized out. We are called for these later
12760 in cgraph_varpool_analyze_pending_decls. */
12761 if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl))
12764 gen_decl_die (decl, context_die);
12768 /* If we're at -g1, we're not interested in subblocks. */
12769 if (debug_info_level <= DINFO_LEVEL_TERSE)
12772 /* Output the DIEs to represent all sub-blocks (and the items declared
12773 therein) of this block. */
12774 for (subblocks = BLOCK_SUBBLOCKS (stmt);
12776 subblocks = BLOCK_CHAIN (subblocks))
12777 gen_block_die (subblocks, context_die, depth + 1);
12780 /* Is this a typedef we can avoid emitting? */
12783 is_redundant_typedef (tree decl)
12785 if (TYPE_DECL_IS_STUB (decl))
12788 if (DECL_ARTIFICIAL (decl)
12789 && DECL_CONTEXT (decl)
12790 && is_tagged_type (DECL_CONTEXT (decl))
12791 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl))) == TYPE_DECL
12792 && DECL_NAME (decl) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))))
12793 /* Also ignore the artificial member typedef for the class name. */
12799 /* Returns the DIE for decl. A DIE will always be returned. */
12802 force_decl_die (tree decl)
12804 dw_die_ref decl_die;
12805 unsigned saved_external_flag;
12806 tree save_fn = NULL_TREE;
12807 decl_die = lookup_decl_die (decl);
12810 dw_die_ref context_die;
12811 tree decl_context = DECL_CONTEXT (decl);
12814 /* Find die that represents this context. */
12815 if (TYPE_P (decl_context))
12816 context_die = force_type_die (decl_context);
12818 context_die = force_decl_die (decl_context);
12821 context_die = comp_unit_die;
12823 decl_die = lookup_decl_die (decl);
12827 switch (TREE_CODE (decl))
12829 case FUNCTION_DECL:
12830 /* Clear current_function_decl, so that gen_subprogram_die thinks
12831 that this is a declaration. At this point, we just want to force
12832 declaration die. */
12833 save_fn = current_function_decl;
12834 current_function_decl = NULL_TREE;
12835 gen_subprogram_die (decl, context_die);
12836 current_function_decl = save_fn;
12840 /* Set external flag to force declaration die. Restore it after
12841 gen_decl_die() call. */
12842 saved_external_flag = DECL_EXTERNAL (decl);
12843 DECL_EXTERNAL (decl) = 1;
12844 gen_decl_die (decl, context_die);
12845 DECL_EXTERNAL (decl) = saved_external_flag;
12848 case NAMESPACE_DECL:
12849 dwarf2out_decl (decl);
12853 gcc_unreachable ();
12856 /* We should be able to find the DIE now. */
12858 decl_die = lookup_decl_die (decl);
12859 gcc_assert (decl_die);
12865 /* Returns the DIE for TYPE. A DIE is always returned. */
12868 force_type_die (tree type)
12870 dw_die_ref type_die;
12872 type_die = lookup_type_die (type);
12875 dw_die_ref context_die;
12876 if (TYPE_CONTEXT (type))
12878 if (TYPE_P (TYPE_CONTEXT (type)))
12879 context_die = force_type_die (TYPE_CONTEXT (type));
12881 context_die = force_decl_die (TYPE_CONTEXT (type));
12884 context_die = comp_unit_die;
12886 type_die = lookup_type_die (type);
12889 gen_type_die (type, context_die);
12890 type_die = lookup_type_die (type);
12891 gcc_assert (type_die);
12896 /* Force out any required namespaces to be able to output DECL,
12897 and return the new context_die for it, if it's changed. */
12900 setup_namespace_context (tree thing, dw_die_ref context_die)
12902 tree context = (DECL_P (thing)
12903 ? DECL_CONTEXT (thing) : TYPE_CONTEXT (thing));
12904 if (context && TREE_CODE (context) == NAMESPACE_DECL)
12905 /* Force out the namespace. */
12906 context_die = force_decl_die (context);
12908 return context_die;
12911 /* Emit a declaration DIE for THING (which is either a DECL or a tagged
12912 type) within its namespace, if appropriate.
12914 For compatibility with older debuggers, namespace DIEs only contain
12915 declarations; all definitions are emitted at CU scope. */
12918 declare_in_namespace (tree thing, dw_die_ref context_die)
12920 dw_die_ref ns_context;
12922 if (debug_info_level <= DINFO_LEVEL_TERSE)
12925 /* If this decl is from an inlined function, then don't try to emit it in its
12926 namespace, as we will get confused. It would have already been emitted
12927 when the abstract instance of the inline function was emitted anyways. */
12928 if (DECL_P (thing) && DECL_ABSTRACT_ORIGIN (thing))
12931 ns_context = setup_namespace_context (thing, context_die);
12933 if (ns_context != context_die)
12935 if (DECL_P (thing))
12936 gen_decl_die (thing, ns_context);
12938 gen_type_die (thing, ns_context);
12942 /* Generate a DIE for a namespace or namespace alias. */
12945 gen_namespace_die (tree decl)
12947 dw_die_ref context_die = setup_namespace_context (decl, comp_unit_die);
12949 /* Namespace aliases have a DECL_ABSTRACT_ORIGIN of the namespace
12950 they are an alias of. */
12951 if (DECL_ABSTRACT_ORIGIN (decl) == NULL)
12953 /* Output a real namespace. */
12954 dw_die_ref namespace_die
12955 = new_die (DW_TAG_namespace, context_die, decl);
12956 add_name_and_src_coords_attributes (namespace_die, decl);
12957 equate_decl_number_to_die (decl, namespace_die);
12961 /* Output a namespace alias. */
12963 /* Force out the namespace we are an alias of, if necessary. */
12964 dw_die_ref origin_die
12965 = force_decl_die (DECL_ABSTRACT_ORIGIN (decl));
12967 /* Now create the namespace alias DIE. */
12968 dw_die_ref namespace_die
12969 = new_die (DW_TAG_imported_declaration, context_die, decl);
12970 add_name_and_src_coords_attributes (namespace_die, decl);
12971 add_AT_die_ref (namespace_die, DW_AT_import, origin_die);
12972 equate_decl_number_to_die (decl, namespace_die);
12976 /* Generate Dwarf debug information for a decl described by DECL. */
12979 gen_decl_die (tree decl, dw_die_ref context_die)
12983 if (DECL_P (decl) && DECL_IGNORED_P (decl))
12986 switch (TREE_CODE (decl))
12992 /* The individual enumerators of an enum type get output when we output
12993 the Dwarf representation of the relevant enum type itself. */
12996 case FUNCTION_DECL:
12997 /* Don't output any DIEs to represent mere function declarations,
12998 unless they are class members or explicit block externs. */
12999 if (DECL_INITIAL (decl) == NULL_TREE && DECL_CONTEXT (decl) == NULL_TREE
13000 && (current_function_decl == NULL_TREE || DECL_ARTIFICIAL (decl)))
13005 /* This doesn't work because the C frontend sets DECL_ABSTRACT_ORIGIN
13006 on local redeclarations of global functions. That seems broken. */
13007 if (current_function_decl != decl)
13008 /* This is only a declaration. */;
13011 /* If we're emitting a clone, emit info for the abstract instance. */
13012 if (DECL_ORIGIN (decl) != decl)
13013 dwarf2out_abstract_function (DECL_ABSTRACT_ORIGIN (decl));
13015 /* If we're emitting an out-of-line copy of an inline function,
13016 emit info for the abstract instance and set up to refer to it. */
13017 else if (cgraph_function_possibly_inlined_p (decl)
13018 && ! DECL_ABSTRACT (decl)
13019 && ! class_or_namespace_scope_p (context_die)
13020 /* dwarf2out_abstract_function won't emit a die if this is just
13021 a declaration. We must avoid setting DECL_ABSTRACT_ORIGIN in
13022 that case, because that works only if we have a die. */
13023 && DECL_INITIAL (decl) != NULL_TREE)
13025 dwarf2out_abstract_function (decl);
13026 set_decl_origin_self (decl);
13029 /* Otherwise we're emitting the primary DIE for this decl. */
13030 else if (debug_info_level > DINFO_LEVEL_TERSE)
13032 /* Before we describe the FUNCTION_DECL itself, make sure that we
13033 have described its return type. */
13034 gen_type_die (TREE_TYPE (TREE_TYPE (decl)), context_die);
13036 /* And its virtual context. */
13037 if (DECL_VINDEX (decl) != NULL_TREE)
13038 gen_type_die (DECL_CONTEXT (decl), context_die);
13040 /* And its containing type. */
13041 origin = decl_class_context (decl);
13042 if (origin != NULL_TREE)
13043 gen_type_die_for_member (origin, decl, context_die);
13045 /* And its containing namespace. */
13046 declare_in_namespace (decl, context_die);
13049 /* Now output a DIE to represent the function itself. */
13050 gen_subprogram_die (decl, context_die);
13054 /* If we are in terse mode, don't generate any DIEs to represent any
13055 actual typedefs. */
13056 if (debug_info_level <= DINFO_LEVEL_TERSE)
13059 /* In the special case of a TYPE_DECL node representing the declaration
13060 of some type tag, if the given TYPE_DECL is marked as having been
13061 instantiated from some other (original) TYPE_DECL node (e.g. one which
13062 was generated within the original definition of an inline function) we
13063 have to generate a special (abbreviated) DW_TAG_structure_type,
13064 DW_TAG_union_type, or DW_TAG_enumeration_type DIE here. */
13065 if (TYPE_DECL_IS_STUB (decl) && decl_ultimate_origin (decl) != NULL_TREE)
13067 gen_tagged_type_instantiation_die (TREE_TYPE (decl), context_die);
13071 if (is_redundant_typedef (decl))
13072 gen_type_die (TREE_TYPE (decl), context_die);
13074 /* Output a DIE to represent the typedef itself. */
13075 gen_typedef_die (decl, context_die);
13079 if (debug_info_level >= DINFO_LEVEL_NORMAL)
13080 gen_label_die (decl, context_die);
13085 /* If we are in terse mode, don't generate any DIEs to represent any
13086 variable declarations or definitions. */
13087 if (debug_info_level <= DINFO_LEVEL_TERSE)
13090 /* Output any DIEs that are needed to specify the type of this data
13092 gen_type_die (TREE_TYPE (decl), context_die);
13094 /* And its containing type. */
13095 origin = decl_class_context (decl);
13096 if (origin != NULL_TREE)
13097 gen_type_die_for_member (origin, decl, context_die);
13099 /* And its containing namespace. */
13100 declare_in_namespace (decl, context_die);
13102 /* Now output the DIE to represent the data object itself. This gets
13103 complicated because of the possibility that the VAR_DECL really
13104 represents an inlined instance of a formal parameter for an inline
13106 origin = decl_ultimate_origin (decl);
13107 if (origin != NULL_TREE && TREE_CODE (origin) == PARM_DECL)
13108 gen_formal_parameter_die (decl, context_die);
13110 gen_variable_die (decl, context_die);
13114 /* Ignore the nameless fields that are used to skip bits but handle C++
13115 anonymous unions and structs. */
13116 if (DECL_NAME (decl) != NULL_TREE
13117 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
13118 || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE)
13120 gen_type_die (member_declared_type (decl), context_die);
13121 gen_field_die (decl, context_die);
13126 gen_type_die (TREE_TYPE (decl), context_die);
13127 gen_formal_parameter_die (decl, context_die);
13130 case NAMESPACE_DECL:
13131 gen_namespace_die (decl);
13135 /* Probably some frontend-internal decl. Assume we don't care. */
13136 gcc_assert ((int)TREE_CODE (decl) > NUM_TREE_CODES);
13141 /* Add Ada "use" clause information for SGI Workshop debugger. */
13144 dwarf2out_add_library_unit_info (const char *filename, const char *context_list)
13146 unsigned int file_index;
13148 if (filename != NULL)
13150 dw_die_ref unit_die = new_die (DW_TAG_module, comp_unit_die, NULL);
13151 tree context_list_decl
13152 = build_decl (LABEL_DECL, get_identifier (context_list),
13155 TREE_PUBLIC (context_list_decl) = TRUE;
13156 add_name_attribute (unit_die, context_list);
13157 file_index = lookup_filename (filename);
13158 add_AT_unsigned (unit_die, DW_AT_decl_file, file_index);
13159 add_pubname (context_list_decl, unit_die);
13163 /* Output debug information for global decl DECL. Called from toplev.c after
13164 compilation proper has finished. */
13167 dwarf2out_global_decl (tree decl)
13169 /* Output DWARF2 information for file-scope tentative data object
13170 declarations, file-scope (extern) function declarations (which had no
13171 corresponding body) and file-scope tagged type declarations and
13172 definitions which have not yet been forced out. */
13173 if (TREE_CODE (decl) != FUNCTION_DECL || !DECL_INITIAL (decl))
13174 dwarf2out_decl (decl);
13177 /* Output debug information for type decl DECL. Called from toplev.c
13178 and from language front ends (to record built-in types). */
13180 dwarf2out_type_decl (tree decl, int local)
13183 dwarf2out_decl (decl);
13186 /* Output debug information for imported module or decl. */
13189 dwarf2out_imported_module_or_decl (tree decl, tree context)
13191 dw_die_ref imported_die, at_import_die;
13192 dw_die_ref scope_die;
13193 unsigned file_index;
13194 expanded_location xloc;
13196 if (debug_info_level <= DINFO_LEVEL_TERSE)
13201 /* To emit DW_TAG_imported_module or DW_TAG_imported_decl, we need two DIEs.
13202 We need decl DIE for reference and scope die. First, get DIE for the decl
13205 /* Get the scope die for decl context. Use comp_unit_die for global module
13206 or decl. If die is not found for non globals, force new die. */
13208 scope_die = comp_unit_die;
13209 else if (TYPE_P (context))
13210 scope_die = force_type_die (context);
13212 scope_die = force_decl_die (context);
13214 /* For TYPE_DECL or CONST_DECL, lookup TREE_TYPE. */
13215 if (TREE_CODE (decl) == TYPE_DECL || TREE_CODE (decl) == CONST_DECL)
13216 at_import_die = force_type_die (TREE_TYPE (decl));
13219 at_import_die = lookup_decl_die (decl);
13220 if (!at_import_die)
13222 /* If we're trying to avoid duplicate debug info, we may not have
13223 emitted the member decl for this field. Emit it now. */
13224 if (TREE_CODE (decl) == FIELD_DECL)
13226 tree type = DECL_CONTEXT (decl);
13227 dw_die_ref type_context_die;
13229 if (TYPE_CONTEXT (type))
13230 if (TYPE_P (TYPE_CONTEXT (type)))
13231 type_context_die = force_type_die (TYPE_CONTEXT (type));
13233 type_context_die = force_decl_die (TYPE_CONTEXT (type));
13235 type_context_die = comp_unit_die;
13236 gen_type_die_for_member (type, decl, type_context_die);
13238 at_import_die = force_decl_die (decl);
13242 /* OK, now we have DIEs for decl as well as scope. Emit imported die. */
13243 if (TREE_CODE (decl) == NAMESPACE_DECL)
13244 imported_die = new_die (DW_TAG_imported_module, scope_die, context);
13246 imported_die = new_die (DW_TAG_imported_declaration, scope_die, context);
13248 xloc = expand_location (input_location);
13249 file_index = lookup_filename (xloc.file);
13250 add_AT_unsigned (imported_die, DW_AT_decl_file, file_index);
13251 add_AT_unsigned (imported_die, DW_AT_decl_line, xloc.line);
13252 add_AT_die_ref (imported_die, DW_AT_import, at_import_die);
13255 /* Write the debugging output for DECL. */
13258 dwarf2out_decl (tree decl)
13260 dw_die_ref context_die = comp_unit_die;
13262 switch (TREE_CODE (decl))
13267 case FUNCTION_DECL:
13268 /* What we would really like to do here is to filter out all mere
13269 file-scope declarations of file-scope functions which are never
13270 referenced later within this translation unit (and keep all of ones
13271 that *are* referenced later on) but we aren't clairvoyant, so we have
13272 no idea which functions will be referenced in the future (i.e. later
13273 on within the current translation unit). So here we just ignore all
13274 file-scope function declarations which are not also definitions. If
13275 and when the debugger needs to know something about these functions,
13276 it will have to hunt around and find the DWARF information associated
13277 with the definition of the function.
13279 We can't just check DECL_EXTERNAL to find out which FUNCTION_DECL
13280 nodes represent definitions and which ones represent mere
13281 declarations. We have to check DECL_INITIAL instead. That's because
13282 the C front-end supports some weird semantics for "extern inline"
13283 function definitions. These can get inlined within the current
13284 translation unit (and thus, we need to generate Dwarf info for their
13285 abstract instances so that the Dwarf info for the concrete inlined
13286 instances can have something to refer to) but the compiler never
13287 generates any out-of-lines instances of such things (despite the fact
13288 that they *are* definitions).
13290 The important point is that the C front-end marks these "extern
13291 inline" functions as DECL_EXTERNAL, but we need to generate DWARF for
13292 them anyway. Note that the C++ front-end also plays some similar games
13293 for inline function definitions appearing within include files which
13294 also contain `#pragma interface' pragmas. */
13295 if (DECL_INITIAL (decl) == NULL_TREE)
13298 /* If we're a nested function, initially use a parent of NULL; if we're
13299 a plain function, this will be fixed up in decls_for_scope. If
13300 we're a method, it will be ignored, since we already have a DIE. */
13301 if (decl_function_context (decl)
13302 /* But if we're in terse mode, we don't care about scope. */
13303 && debug_info_level > DINFO_LEVEL_TERSE)
13304 context_die = NULL;
13308 /* Ignore this VAR_DECL if it refers to a file-scope extern data object
13309 declaration and if the declaration was never even referenced from
13310 within this entire compilation unit. We suppress these DIEs in
13311 order to save space in the .debug section (by eliminating entries
13312 which are probably useless). Note that we must not suppress
13313 block-local extern declarations (whether used or not) because that
13314 would screw-up the debugger's name lookup mechanism and cause it to
13315 miss things which really ought to be in scope at a given point. */
13316 if (DECL_EXTERNAL (decl) && !TREE_USED (decl))
13319 /* For local statics lookup proper context die. */
13320 if (TREE_STATIC (decl) && decl_function_context (decl))
13321 context_die = lookup_decl_die (DECL_CONTEXT (decl));
13323 /* If we are in terse mode, don't generate any DIEs to represent any
13324 variable declarations or definitions. */
13325 if (debug_info_level <= DINFO_LEVEL_TERSE)
13329 case NAMESPACE_DECL:
13330 if (debug_info_level <= DINFO_LEVEL_TERSE)
13332 if (lookup_decl_die (decl) != NULL)
13337 /* Don't emit stubs for types unless they are needed by other DIEs. */
13338 if (TYPE_DECL_SUPPRESS_DEBUG (decl))
13341 /* Don't bother trying to generate any DIEs to represent any of the
13342 normal built-in types for the language we are compiling. */
13343 if (DECL_IS_BUILTIN (decl))
13345 /* OK, we need to generate one for `bool' so GDB knows what type
13346 comparisons have. */
13347 if ((get_AT_unsigned (comp_unit_die, DW_AT_language)
13348 == DW_LANG_C_plus_plus)
13349 && TREE_CODE (TREE_TYPE (decl)) == BOOLEAN_TYPE
13350 && ! DECL_IGNORED_P (decl))
13351 modified_type_die (TREE_TYPE (decl), 0, 0, NULL);
13356 /* If we are in terse mode, don't generate any DIEs for types. */
13357 if (debug_info_level <= DINFO_LEVEL_TERSE)
13360 /* If we're a function-scope tag, initially use a parent of NULL;
13361 this will be fixed up in decls_for_scope. */
13362 if (decl_function_context (decl))
13363 context_die = NULL;
13371 gen_decl_die (decl, context_die);
13374 /* Output a marker (i.e. a label) for the beginning of the generated code for
13375 a lexical block. */
13378 dwarf2out_begin_block (unsigned int line ATTRIBUTE_UNUSED,
13379 unsigned int blocknum)
13381 current_function_section (current_function_decl);
13382 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_BEGIN_LABEL, blocknum);
13385 /* Output a marker (i.e. a label) for the end of the generated code for a
13389 dwarf2out_end_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int blocknum)
13391 current_function_section (current_function_decl);
13392 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, BLOCK_END_LABEL, blocknum);
13395 /* Returns nonzero if it is appropriate not to emit any debugging
13396 information for BLOCK, because it doesn't contain any instructions.
13398 Don't allow this for blocks with nested functions or local classes
13399 as we would end up with orphans, and in the presence of scheduling
13400 we may end up calling them anyway. */
13403 dwarf2out_ignore_block (tree block)
13407 for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl))
13408 if (TREE_CODE (decl) == FUNCTION_DECL
13409 || (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)))
13415 /* Lookup FILE_NAME (in the list of filenames that we know about here in
13416 dwarf2out.c) and return its "index". The index of each (known) filename is
13417 just a unique number which is associated with only that one filename. We
13418 need such numbers for the sake of generating labels (in the .debug_sfnames
13419 section) and references to those files numbers (in the .debug_srcinfo
13420 and.debug_macinfo sections). If the filename given as an argument is not
13421 found in our current list, add it to the list and assign it the next
13422 available unique index number. In order to speed up searches, we remember
13423 the index of the filename was looked up last. This handles the majority of
13427 lookup_filename (const char *file_name)
13430 char *save_file_name;
13432 /* Check to see if the file name that was searched on the previous
13433 call matches this file name. If so, return the index. */
13434 if (file_table_last_lookup_index != 0)
13437 = VARRAY_CHAR_PTR (file_table, file_table_last_lookup_index);
13438 if (strcmp (file_name, last) == 0)
13439 return file_table_last_lookup_index;
13442 /* Didn't match the previous lookup, search the table. */
13443 n = VARRAY_ACTIVE_SIZE (file_table);
13444 for (i = 1; i < n; i++)
13445 if (strcmp (file_name, VARRAY_CHAR_PTR (file_table, i)) == 0)
13447 file_table_last_lookup_index = i;
13451 /* Add the new entry to the end of the filename table. */
13452 file_table_last_lookup_index = n;
13453 save_file_name = (char *) ggc_strdup (file_name);
13454 VARRAY_PUSH_CHAR_PTR (file_table, save_file_name);
13455 VARRAY_PUSH_UINT (file_table_emitted, 0);
13457 /* If the assembler is emitting the file table, and we aren't eliminating
13458 unused debug types, then we must emit .file here. If we are eliminating
13459 unused debug types, then this will be done by the maybe_emit_file call in
13460 prune_unused_types_walk_attribs. */
13462 if (DWARF2_ASM_LINE_DEBUG_INFO && ! flag_eliminate_unused_debug_types)
13463 return maybe_emit_file (i);
13468 /* If the assembler will construct the file table, then translate the compiler
13469 internal file table number into the assembler file table number, and emit
13470 a .file directive if we haven't already emitted one yet. The file table
13471 numbers are different because we prune debug info for unused variables and
13472 types, which may include filenames. */
13475 maybe_emit_file (int fileno)
13477 if (DWARF2_ASM_LINE_DEBUG_INFO && fileno > 0)
13479 if (!VARRAY_UINT (file_table_emitted, fileno))
13481 VARRAY_UINT (file_table_emitted, fileno) = ++emitcount;
13482 fprintf (asm_out_file, "\t.file %u ",
13483 VARRAY_UINT (file_table_emitted, fileno));
13484 output_quoted_string (asm_out_file,
13485 VARRAY_CHAR_PTR (file_table, fileno));
13486 fputc ('\n', asm_out_file);
13488 return VARRAY_UINT (file_table_emitted, fileno);
13494 /* Initialize the compiler internal file table. */
13497 init_file_table (void)
13499 /* Allocate the initial hunk of the file_table. */
13500 VARRAY_CHAR_PTR_INIT (file_table, 64, "file_table");
13501 VARRAY_UINT_INIT (file_table_emitted, 64, "file_table_emitted");
13503 /* Skip the first entry - file numbers begin at 1. */
13504 VARRAY_PUSH_CHAR_PTR (file_table, NULL);
13505 VARRAY_PUSH_UINT (file_table_emitted, 0);
13506 file_table_last_lookup_index = 0;
13509 /* Called by the final INSN scan whenever we see a var location. We
13510 use it to drop labels in the right places, and throw the location in
13511 our lookup table. */
13514 dwarf2out_var_location (rtx loc_note)
13516 char loclabel[MAX_ARTIFICIAL_LABEL_BYTES];
13517 struct var_loc_node *newloc;
13519 static rtx last_insn;
13520 static const char *last_label;
13523 if (!DECL_P (NOTE_VAR_LOCATION_DECL (loc_note)))
13525 prev_insn = PREV_INSN (loc_note);
13527 newloc = ggc_alloc_cleared (sizeof (struct var_loc_node));
13528 /* If the insn we processed last time is the previous insn
13529 and it is also a var location note, use the label we emitted
13531 if (last_insn != NULL_RTX
13532 && last_insn == prev_insn
13533 && NOTE_P (prev_insn)
13534 && NOTE_LINE_NUMBER (prev_insn) == NOTE_INSN_VAR_LOCATION)
13536 newloc->label = last_label;
13540 ASM_GENERATE_INTERNAL_LABEL (loclabel, "LVL", loclabel_num);
13541 ASM_OUTPUT_DEBUG_LABEL (asm_out_file, "LVL", loclabel_num);
13543 newloc->label = ggc_strdup (loclabel);
13545 newloc->var_loc_note = loc_note;
13546 newloc->next = NULL;
13549 && (last_text_section == in_unlikely_executed_text
13550 || (last_text_section == in_named
13551 && last_text_section_name == cfun->unlikely_text_section_name)))
13552 newloc->section_label = cfun->cold_section_label;
13554 newloc->section_label = text_section_label;
13556 last_insn = loc_note;
13557 last_label = newloc->label;
13558 decl = NOTE_VAR_LOCATION_DECL (loc_note);
13559 if (DECL_DEBUG_EXPR_IS_FROM (decl) && DECL_DEBUG_EXPR (decl)
13560 && DECL_P (DECL_DEBUG_EXPR (decl)))
13561 decl = DECL_DEBUG_EXPR (decl);
13562 add_var_loc_to_decl (decl, newloc);
13565 /* We need to reset the locations at the beginning of each
13566 function. We can't do this in the end_function hook, because the
13567 declarations that use the locations won't have been outputted when
13568 that hook is called. */
13571 dwarf2out_begin_function (tree unused ATTRIBUTE_UNUSED)
13573 htab_empty (decl_loc_table);
13576 /* Output a label to mark the beginning of a source code line entry
13577 and record information relating to this source line, in
13578 'line_info_table' for later output of the .debug_line section. */
13581 dwarf2out_source_line (unsigned int line, const char *filename)
13583 if (debug_info_level >= DINFO_LEVEL_NORMAL
13586 current_function_section (current_function_decl);
13588 /* If requested, emit something human-readable. */
13589 if (flag_debug_asm)
13590 fprintf (asm_out_file, "\t%s %s:%d\n", ASM_COMMENT_START,
13593 if (DWARF2_ASM_LINE_DEBUG_INFO)
13595 unsigned file_num = lookup_filename (filename);
13597 file_num = maybe_emit_file (file_num);
13599 /* Emit the .loc directive understood by GNU as. */
13600 fprintf (asm_out_file, "\t.loc %d %d 0\n", file_num, line);
13602 /* Indicate that line number info exists. */
13603 line_info_table_in_use++;
13605 /* Indicate that multiple line number tables exist. */
13606 if (DECL_SECTION_NAME (current_function_decl))
13607 separate_line_info_table_in_use++;
13609 else if (DECL_SECTION_NAME (current_function_decl))
13611 dw_separate_line_info_ref line_info;
13612 targetm.asm_out.internal_label (asm_out_file, SEPARATE_LINE_CODE_LABEL,
13613 separate_line_info_table_in_use);
13615 /* Expand the line info table if necessary. */
13616 if (separate_line_info_table_in_use
13617 == separate_line_info_table_allocated)
13619 separate_line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
13620 separate_line_info_table
13621 = ggc_realloc (separate_line_info_table,
13622 separate_line_info_table_allocated
13623 * sizeof (dw_separate_line_info_entry));
13624 memset (separate_line_info_table
13625 + separate_line_info_table_in_use,
13627 (LINE_INFO_TABLE_INCREMENT
13628 * sizeof (dw_separate_line_info_entry)));
13631 /* Add the new entry at the end of the line_info_table. */
13633 = &separate_line_info_table[separate_line_info_table_in_use++];
13634 line_info->dw_file_num = lookup_filename (filename);
13635 line_info->dw_line_num = line;
13636 line_info->function = current_function_funcdef_no;
13640 dw_line_info_ref line_info;
13642 targetm.asm_out.internal_label (asm_out_file, LINE_CODE_LABEL,
13643 line_info_table_in_use);
13645 /* Expand the line info table if necessary. */
13646 if (line_info_table_in_use == line_info_table_allocated)
13648 line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
13650 = ggc_realloc (line_info_table,
13651 (line_info_table_allocated
13652 * sizeof (dw_line_info_entry)));
13653 memset (line_info_table + line_info_table_in_use, 0,
13654 LINE_INFO_TABLE_INCREMENT * sizeof (dw_line_info_entry));
13657 /* Add the new entry at the end of the line_info_table. */
13658 line_info = &line_info_table[line_info_table_in_use++];
13659 line_info->dw_file_num = lookup_filename (filename);
13660 line_info->dw_line_num = line;
13665 /* Record the beginning of a new source file. */
13668 dwarf2out_start_source_file (unsigned int lineno, const char *filename)
13670 if (flag_eliminate_dwarf2_dups)
13672 /* Record the beginning of the file for break_out_includes. */
13673 dw_die_ref bincl_die;
13675 bincl_die = new_die (DW_TAG_GNU_BINCL, comp_unit_die, NULL);
13676 add_AT_string (bincl_die, DW_AT_name, filename);
13679 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13683 named_section_flags (DEBUG_MACINFO_SECTION, SECTION_DEBUG);
13684 dw2_asm_output_data (1, DW_MACINFO_start_file, "Start new file");
13685 dw2_asm_output_data_uleb128 (lineno, "Included from line number %d",
13688 fileno = maybe_emit_file (lookup_filename (filename));
13689 dw2_asm_output_data_uleb128 (fileno, "Filename we just started");
13693 /* Record the end of a source file. */
13696 dwarf2out_end_source_file (unsigned int lineno ATTRIBUTE_UNUSED)
13698 if (flag_eliminate_dwarf2_dups)
13699 /* Record the end of the file for break_out_includes. */
13700 new_die (DW_TAG_GNU_EINCL, comp_unit_die, NULL);
13702 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13704 named_section_flags (DEBUG_MACINFO_SECTION, SECTION_DEBUG);
13705 dw2_asm_output_data (1, DW_MACINFO_end_file, "End file");
13709 /* Called from debug_define in toplev.c. The `buffer' parameter contains
13710 the tail part of the directive line, i.e. the part which is past the
13711 initial whitespace, #, whitespace, directive-name, whitespace part. */
13714 dwarf2out_define (unsigned int lineno ATTRIBUTE_UNUSED,
13715 const char *buffer ATTRIBUTE_UNUSED)
13717 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13719 named_section_flags (DEBUG_MACINFO_SECTION, SECTION_DEBUG);
13720 dw2_asm_output_data (1, DW_MACINFO_define, "Define macro");
13721 dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno);
13722 dw2_asm_output_nstring (buffer, -1, "The macro");
13726 /* Called from debug_undef in toplev.c. The `buffer' parameter contains
13727 the tail part of the directive line, i.e. the part which is past the
13728 initial whitespace, #, whitespace, directive-name, whitespace part. */
13731 dwarf2out_undef (unsigned int lineno ATTRIBUTE_UNUSED,
13732 const char *buffer ATTRIBUTE_UNUSED)
13734 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13736 named_section_flags (DEBUG_MACINFO_SECTION, SECTION_DEBUG);
13737 dw2_asm_output_data (1, DW_MACINFO_undef, "Undefine macro");
13738 dw2_asm_output_data_uleb128 (lineno, "At line number %d", lineno);
13739 dw2_asm_output_nstring (buffer, -1, "The macro");
13743 /* Set up for Dwarf output at the start of compilation. */
13746 dwarf2out_init (const char *filename ATTRIBUTE_UNUSED)
13748 init_file_table ();
13750 /* Allocate the decl_die_table. */
13751 decl_die_table = htab_create_ggc (10, decl_die_table_hash,
13752 decl_die_table_eq, NULL);
13754 /* Allocate the decl_loc_table. */
13755 decl_loc_table = htab_create_ggc (10, decl_loc_table_hash,
13756 decl_loc_table_eq, NULL);
13758 /* Allocate the initial hunk of the decl_scope_table. */
13759 decl_scope_table = VEC_alloc (tree, gc, 256);
13761 /* Allocate the initial hunk of the abbrev_die_table. */
13762 abbrev_die_table = ggc_alloc_cleared (ABBREV_DIE_TABLE_INCREMENT
13763 * sizeof (dw_die_ref));
13764 abbrev_die_table_allocated = ABBREV_DIE_TABLE_INCREMENT;
13765 /* Zero-th entry is allocated, but unused. */
13766 abbrev_die_table_in_use = 1;
13768 /* Allocate the initial hunk of the line_info_table. */
13769 line_info_table = ggc_alloc_cleared (LINE_INFO_TABLE_INCREMENT
13770 * sizeof (dw_line_info_entry));
13771 line_info_table_allocated = LINE_INFO_TABLE_INCREMENT;
13773 /* Zero-th entry is allocated, but unused. */
13774 line_info_table_in_use = 1;
13776 /* Generate the initial DIE for the .debug section. Note that the (string)
13777 value given in the DW_AT_name attribute of the DW_TAG_compile_unit DIE
13778 will (typically) be a relative pathname and that this pathname should be
13779 taken as being relative to the directory from which the compiler was
13780 invoked when the given (base) source file was compiled. We will fill
13781 in this value in dwarf2out_finish. */
13782 comp_unit_die = gen_compile_unit_die (NULL);
13784 incomplete_types = VEC_alloc (tree, gc, 64);
13786 used_rtx_array = VEC_alloc (rtx, gc, 32);
13788 ASM_GENERATE_INTERNAL_LABEL (text_end_label, TEXT_END_LABEL, 0);
13789 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label,
13790 DEBUG_ABBREV_SECTION_LABEL, 0);
13791 ASM_GENERATE_INTERNAL_LABEL (text_section_label, TEXT_SECTION_LABEL, 0);
13792 ASM_GENERATE_INTERNAL_LABEL (cold_text_section_label,
13793 COLD_TEXT_SECTION_LABEL, 0);
13794 ASM_GENERATE_INTERNAL_LABEL (cold_end_label, COLD_END_LABEL, 0);
13796 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label,
13797 DEBUG_INFO_SECTION_LABEL, 0);
13798 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label,
13799 DEBUG_LINE_SECTION_LABEL, 0);
13800 ASM_GENERATE_INTERNAL_LABEL (ranges_section_label,
13801 DEBUG_RANGES_SECTION_LABEL, 0);
13802 named_section_flags (DEBUG_ABBREV_SECTION, SECTION_DEBUG);
13803 ASM_OUTPUT_LABEL (asm_out_file, abbrev_section_label);
13804 named_section_flags (DEBUG_INFO_SECTION, SECTION_DEBUG);
13805 ASM_OUTPUT_LABEL (asm_out_file, debug_info_section_label);
13806 named_section_flags (DEBUG_LINE_SECTION, SECTION_DEBUG);
13807 ASM_OUTPUT_LABEL (asm_out_file, debug_line_section_label);
13809 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
13811 named_section_flags (DEBUG_MACINFO_SECTION, SECTION_DEBUG);
13812 ASM_GENERATE_INTERNAL_LABEL (macinfo_section_label,
13813 DEBUG_MACINFO_SECTION_LABEL, 0);
13814 ASM_OUTPUT_LABEL (asm_out_file, macinfo_section_label);
13818 ASM_OUTPUT_LABEL (asm_out_file, text_section_label);
13819 if (flag_reorder_blocks_and_partition)
13821 unlikely_text_section ();
13822 ASM_OUTPUT_LABEL (asm_out_file, cold_text_section_label);
13826 /* A helper function for dwarf2out_finish called through
13827 ht_forall. Emit one queued .debug_str string. */
13830 output_indirect_string (void **h, void *v ATTRIBUTE_UNUSED)
13832 struct indirect_string_node *node = (struct indirect_string_node *) *h;
13834 if (node->form == DW_FORM_strp)
13836 named_section_flags (DEBUG_STR_SECTION, DEBUG_STR_SECTION_FLAGS);
13837 ASM_OUTPUT_LABEL (asm_out_file, node->label);
13838 assemble_string (node->str, strlen (node->str) + 1);
13846 /* Clear the marks for a die and its children.
13847 Be cool if the mark isn't set. */
13850 prune_unmark_dies (dw_die_ref die)
13854 for (c = die->die_child; c; c = c->die_sib)
13855 prune_unmark_dies (c);
13859 /* Given DIE that we're marking as used, find any other dies
13860 it references as attributes and mark them as used. */
13863 prune_unused_types_walk_attribs (dw_die_ref die)
13867 for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
13869 if (a->dw_attr_val.val_class == dw_val_class_die_ref)
13871 /* A reference to another DIE.
13872 Make sure that it will get emitted. */
13873 prune_unused_types_mark (a->dw_attr_val.v.val_die_ref.die, 1);
13875 else if (a->dw_attr == DW_AT_decl_file || a->dw_attr == DW_AT_call_file)
13877 /* A reference to a file. Make sure the file name is emitted. */
13878 a->dw_attr_val.v.val_unsigned =
13879 maybe_emit_file (a->dw_attr_val.v.val_unsigned);
13885 /* Mark DIE as being used. If DOKIDS is true, then walk down
13886 to DIE's children. */
13889 prune_unused_types_mark (dw_die_ref die, int dokids)
13893 if (die->die_mark == 0)
13895 /* We haven't done this node yet. Mark it as used. */
13898 /* We also have to mark its parents as used.
13899 (But we don't want to mark our parents' kids due to this.) */
13900 if (die->die_parent)
13901 prune_unused_types_mark (die->die_parent, 0);
13903 /* Mark any referenced nodes. */
13904 prune_unused_types_walk_attribs (die);
13906 /* If this node is a specification,
13907 also mark the definition, if it exists. */
13908 if (get_AT_flag (die, DW_AT_declaration) && die->die_definition)
13909 prune_unused_types_mark (die->die_definition, 1);
13912 if (dokids && die->die_mark != 2)
13914 /* We need to walk the children, but haven't done so yet.
13915 Remember that we've walked the kids. */
13919 for (c = die->die_child; c; c = c->die_sib)
13921 /* If this is an array type, we need to make sure our
13922 kids get marked, even if they're types. */
13923 if (die->die_tag == DW_TAG_array_type)
13924 prune_unused_types_mark (c, 1);
13926 prune_unused_types_walk (c);
13932 /* Walk the tree DIE and mark types that we actually use. */
13935 prune_unused_types_walk (dw_die_ref die)
13939 /* Don't do anything if this node is already marked. */
13943 switch (die->die_tag) {
13944 case DW_TAG_const_type:
13945 case DW_TAG_packed_type:
13946 case DW_TAG_pointer_type:
13947 case DW_TAG_reference_type:
13948 case DW_TAG_volatile_type:
13949 case DW_TAG_typedef:
13950 case DW_TAG_array_type:
13951 case DW_TAG_structure_type:
13952 case DW_TAG_union_type:
13953 case DW_TAG_class_type:
13954 case DW_TAG_friend:
13955 case DW_TAG_variant_part:
13956 case DW_TAG_enumeration_type:
13957 case DW_TAG_subroutine_type:
13958 case DW_TAG_string_type:
13959 case DW_TAG_set_type:
13960 case DW_TAG_subrange_type:
13961 case DW_TAG_ptr_to_member_type:
13962 case DW_TAG_file_type:
13963 /* It's a type node --- don't mark it. */
13967 /* Mark everything else. */
13973 /* Now, mark any dies referenced from here. */
13974 prune_unused_types_walk_attribs (die);
13976 /* Mark children. */
13977 for (c = die->die_child; c; c = c->die_sib)
13978 prune_unused_types_walk (c);
13982 /* Remove from the tree DIE any dies that aren't marked. */
13985 prune_unused_types_prune (dw_die_ref die)
13987 dw_die_ref c, p, n;
13989 gcc_assert (die->die_mark);
13992 for (c = die->die_child; c; c = n)
13997 prune_unused_types_prune (c);
14005 die->die_child = n;
14012 /* Remove dies representing declarations that we never use. */
14015 prune_unused_types (void)
14018 limbo_die_node *node;
14020 /* Clear all the marks. */
14021 prune_unmark_dies (comp_unit_die);
14022 for (node = limbo_die_list; node; node = node->next)
14023 prune_unmark_dies (node->die);
14025 /* Set the mark on nodes that are actually used. */
14026 prune_unused_types_walk (comp_unit_die);
14027 for (node = limbo_die_list; node; node = node->next)
14028 prune_unused_types_walk (node->die);
14030 /* Also set the mark on nodes referenced from the
14031 pubname_table or arange_table. */
14032 for (i = 0; i < pubname_table_in_use; i++)
14033 prune_unused_types_mark (pubname_table[i].die, 1);
14034 for (i = 0; i < arange_table_in_use; i++)
14035 prune_unused_types_mark (arange_table[i], 1);
14037 /* Get rid of nodes that aren't marked. */
14038 prune_unused_types_prune (comp_unit_die);
14039 for (node = limbo_die_list; node; node = node->next)
14040 prune_unused_types_prune (node->die);
14042 /* Leave the marks clear. */
14043 prune_unmark_dies (comp_unit_die);
14044 for (node = limbo_die_list; node; node = node->next)
14045 prune_unmark_dies (node->die);
14048 /* Output stuff that dwarf requires at the end of every file,
14049 and generate the DWARF-2 debugging info. */
14052 dwarf2out_finish (const char *filename)
14054 limbo_die_node *node, *next_node;
14055 dw_die_ref die = 0;
14057 /* Add the name for the main input file now. We delayed this from
14058 dwarf2out_init to avoid complications with PCH. */
14059 add_name_attribute (comp_unit_die, filename);
14060 if (filename[0] != DIR_SEPARATOR)
14061 add_comp_dir_attribute (comp_unit_die);
14062 else if (get_AT (comp_unit_die, DW_AT_comp_dir) == NULL)
14065 for (i = 1; i < VARRAY_ACTIVE_SIZE (file_table); i++)
14066 if (VARRAY_CHAR_PTR (file_table, i)[0] != DIR_SEPARATOR
14067 /* Don't add cwd for <built-in>. */
14068 && VARRAY_CHAR_PTR (file_table, i)[0] != '<')
14070 add_comp_dir_attribute (comp_unit_die);
14075 /* Traverse the limbo die list, and add parent/child links. The only
14076 dies without parents that should be here are concrete instances of
14077 inline functions, and the comp_unit_die. We can ignore the comp_unit_die.
14078 For concrete instances, we can get the parent die from the abstract
14080 for (node = limbo_die_list; node; node = next_node)
14082 next_node = node->next;
14085 if (die->die_parent == NULL)
14087 dw_die_ref origin = get_AT_ref (die, DW_AT_abstract_origin);
14090 add_child_die (origin->die_parent, die);
14091 else if (die == comp_unit_die)
14093 else if (errorcount > 0 || sorrycount > 0)
14094 /* It's OK to be confused by errors in the input. */
14095 add_child_die (comp_unit_die, die);
14098 /* In certain situations, the lexical block containing a
14099 nested function can be optimized away, which results
14100 in the nested function die being orphaned. Likewise
14101 with the return type of that nested function. Force
14102 this to be a child of the containing function.
14104 It may happen that even the containing function got fully
14105 inlined and optimized out. In that case we are lost and
14106 assign the empty child. This should not be big issue as
14107 the function is likely unreachable too. */
14108 tree context = NULL_TREE;
14110 gcc_assert (node->created_for);
14112 if (DECL_P (node->created_for))
14113 context = DECL_CONTEXT (node->created_for);
14114 else if (TYPE_P (node->created_for))
14115 context = TYPE_CONTEXT (node->created_for);
14117 gcc_assert (context && TREE_CODE (context) == FUNCTION_DECL);
14119 origin = lookup_decl_die (context);
14121 add_child_die (origin, die);
14123 add_child_die (comp_unit_die, die);
14128 limbo_die_list = NULL;
14130 /* Walk through the list of incomplete types again, trying once more to
14131 emit full debugging info for them. */
14132 retry_incomplete_types ();
14134 /* We need to reverse all the dies before break_out_includes, or
14135 we'll see the end of an include file before the beginning. */
14136 reverse_all_dies (comp_unit_die);
14138 if (flag_eliminate_unused_debug_types)
14139 prune_unused_types ();
14141 /* Generate separate CUs for each of the include files we've seen.
14142 They will go into limbo_die_list. */
14143 if (flag_eliminate_dwarf2_dups)
14144 break_out_includes (comp_unit_die);
14146 /* Traverse the DIE's and add add sibling attributes to those DIE's
14147 that have children. */
14148 add_sibling_attributes (comp_unit_die);
14149 for (node = limbo_die_list; node; node = node->next)
14150 add_sibling_attributes (node->die);
14152 /* Output a terminator label for the .text section. */
14154 targetm.asm_out.internal_label (asm_out_file, TEXT_END_LABEL, 0);
14155 if (flag_reorder_blocks_and_partition)
14157 unlikely_text_section ();
14158 targetm.asm_out.internal_label (asm_out_file, COLD_END_LABEL, 0);
14161 /* Output the source line correspondence table. We must do this
14162 even if there is no line information. Otherwise, on an empty
14163 translation unit, we will generate a present, but empty,
14164 .debug_info section. IRIX 6.5 `nm' will then complain when
14165 examining the file. */
14166 if (! DWARF2_ASM_LINE_DEBUG_INFO)
14168 named_section_flags (DEBUG_LINE_SECTION, SECTION_DEBUG);
14169 output_line_info ();
14172 /* Output location list section if necessary. */
14173 if (have_location_lists)
14175 /* Output the location lists info. */
14176 named_section_flags (DEBUG_LOC_SECTION, SECTION_DEBUG);
14177 ASM_GENERATE_INTERNAL_LABEL (loc_section_label,
14178 DEBUG_LOC_SECTION_LABEL, 0);
14179 ASM_OUTPUT_LABEL (asm_out_file, loc_section_label);
14180 output_location_lists (die);
14181 have_location_lists = 0;
14184 /* We can only use the low/high_pc attributes if all of the code was
14186 if (!separate_line_info_table_in_use && !have_switched_text_section)
14188 add_AT_lbl_id (comp_unit_die, DW_AT_low_pc, text_section_label);
14189 add_AT_lbl_id (comp_unit_die, DW_AT_high_pc, text_end_label);
14192 /* If it wasn't, we need to give .debug_loc and .debug_ranges an appropriate
14193 "base address". Use zero so that these addresses become absolute. */
14194 else if (have_location_lists || ranges_table_in_use)
14195 add_AT_addr (comp_unit_die, DW_AT_entry_pc, const0_rtx);
14197 if (debug_info_level >= DINFO_LEVEL_NORMAL)
14198 add_AT_lbl_offset (comp_unit_die, DW_AT_stmt_list,
14199 debug_line_section_label);
14201 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
14202 add_AT_lbl_offset (comp_unit_die, DW_AT_macro_info, macinfo_section_label);
14204 /* Output all of the compilation units. We put the main one last so that
14205 the offsets are available to output_pubnames. */
14206 for (node = limbo_die_list; node; node = node->next)
14207 output_comp_unit (node->die, 0);
14209 output_comp_unit (comp_unit_die, 0);
14211 /* Output the abbreviation table. */
14212 named_section_flags (DEBUG_ABBREV_SECTION, SECTION_DEBUG);
14213 output_abbrev_section ();
14215 /* Output public names table if necessary. */
14216 if (pubname_table_in_use)
14218 named_section_flags (DEBUG_PUBNAMES_SECTION, SECTION_DEBUG);
14219 output_pubnames ();
14222 /* Output the address range information. We only put functions in the arange
14223 table, so don't write it out if we don't have any. */
14224 if (fde_table_in_use)
14226 named_section_flags (DEBUG_ARANGES_SECTION, SECTION_DEBUG);
14230 /* Output ranges section if necessary. */
14231 if (ranges_table_in_use)
14233 named_section_flags (DEBUG_RANGES_SECTION, SECTION_DEBUG);
14234 ASM_OUTPUT_LABEL (asm_out_file, ranges_section_label);
14238 /* Have to end the macro section. */
14239 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
14241 named_section_flags (DEBUG_MACINFO_SECTION, SECTION_DEBUG);
14242 dw2_asm_output_data (1, 0, "End compilation unit");
14245 /* If we emitted any DW_FORM_strp form attribute, output the string
14247 if (debug_str_hash)
14248 htab_traverse (debug_str_hash, output_indirect_string, NULL);
14252 /* This should never be used, but its address is needed for comparisons. */
14253 const struct gcc_debug_hooks dwarf2_debug_hooks;
14255 #endif /* DWARF2_DEBUGGING_INFO */
14257 #include "gt-dwarf2out.h"