1 /* Output Dwarf2 format symbol table information from the GNU C compiler.
2 Copyright (C) 1992, 1993, 1995, 1996, 1997, 1998, 1999, 2000 Free Software
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 GNU CC.
10 GNU CC is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2, or (at your option)
15 GNU CC is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with GNU CC; see the file COPYING. If not, write to
22 the Free Software Foundation, 59 Temple Place - Suite 330,
23 Boston, MA 02111-1307, USA. */
25 /* The first part of this file deals with the DWARF 2 frame unwind
26 information, which is also used by the GCC efficient exception handling
27 mechanism. The second part, controlled only by an #ifdef
28 DWARF2_DEBUGGING_INFO, deals with the other DWARF 2 debugging
37 #include "hard-reg-set.h"
39 #include "insn-config.h"
45 #include "dwarf2out.h"
47 #include "dyn-string.h"
49 /* We cannot use <assert.h> in GCC source, since that would include
50 GCC's assert.h, which may not be compatible with the host compiler. */
55 # define assert(e) do { if (! (e)) abort (); } while (0)
58 /* Decide whether we want to emit frame unwind information for the current
64 return (write_symbols == DWARF2_DEBUG
65 #ifdef DWARF2_FRAME_INFO
68 #ifdef DWARF2_UNWIND_INFO
69 || (flag_exceptions && ! exceptions_via_longjmp)
74 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
76 /* How to start an assembler comment. */
77 #ifndef ASM_COMMENT_START
78 #define ASM_COMMENT_START ";#"
81 typedef struct dw_cfi_struct *dw_cfi_ref;
82 typedef struct dw_fde_struct *dw_fde_ref;
83 typedef union dw_cfi_oprnd_struct *dw_cfi_oprnd_ref;
85 /* Call frames are described using a sequence of Call Frame
86 Information instructions. The register number, offset
87 and address fields are provided as possible operands;
88 their use is selected by the opcode field. */
90 typedef union dw_cfi_oprnd_struct
92 unsigned long dw_cfi_reg_num;
93 long int dw_cfi_offset;
98 typedef struct dw_cfi_struct
100 dw_cfi_ref dw_cfi_next;
101 enum dwarf_call_frame_info dw_cfi_opc;
102 dw_cfi_oprnd dw_cfi_oprnd1;
103 dw_cfi_oprnd dw_cfi_oprnd2;
107 /* All call frame descriptions (FDE's) in the GCC generated DWARF
108 refer to a single Common Information Entry (CIE), defined at
109 the beginning of the .debug_frame section. This used of a single
110 CIE obviates the need to keep track of multiple CIE's
111 in the DWARF generation routines below. */
113 typedef struct dw_fde_struct
116 char *dw_fde_current_label;
118 dw_cfi_ref dw_fde_cfi;
122 /* Maximum size (in bytes) of an artificially generated label. */
123 #define MAX_ARTIFICIAL_LABEL_BYTES 30
125 /* Make sure we know the sizes of the various types dwarf can describe. These
126 are only defaults. If the sizes are different for your target, you should
127 override these values by defining the appropriate symbols in your tm.h
130 #ifndef CHAR_TYPE_SIZE
131 #define CHAR_TYPE_SIZE BITS_PER_UNIT
134 #define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
137 /* The size in bytes of a DWARF field indicating an offset or length
138 relative to a debug info section, specified to be 4 bytes in the DWARF-2
139 specification. The SGI/MIPS ABI defines it to be the same as PTR_SIZE. */
141 #ifndef DWARF_OFFSET_SIZE
142 #define DWARF_OFFSET_SIZE 4
145 #define DWARF_VERSION 2
147 /* Round SIZE up to the nearest BOUNDARY. */
148 #define DWARF_ROUND(SIZE,BOUNDARY) \
149 (((SIZE) + (BOUNDARY) - 1) & ~((BOUNDARY) - 1))
151 /* Offsets recorded in opcodes are a multiple of this alignment factor. */
152 #ifdef STACK_GROWS_DOWNWARD
153 #define DWARF_CIE_DATA_ALIGNMENT (-UNITS_PER_WORD)
155 #define DWARF_CIE_DATA_ALIGNMENT UNITS_PER_WORD
158 /* A pointer to the base of a table that contains frame description
159 information for each routine. */
160 static dw_fde_ref fde_table;
162 /* Number of elements currently allocated for fde_table. */
163 static unsigned fde_table_allocated;
165 /* Number of elements in fde_table currently in use. */
166 static unsigned fde_table_in_use;
168 /* Size (in elements) of increments by which we may expand the
170 #define FDE_TABLE_INCREMENT 256
172 /* A list of call frame insns for the CIE. */
173 static dw_cfi_ref cie_cfi_head;
175 /* The number of the current function definition for which debugging
176 information is being generated. These numbers range from 1 up to the
177 maximum number of function definitions contained within the current
178 compilation unit. These numbers are used to create unique label id's
179 unique to each function definition. */
180 static unsigned current_funcdef_number = 0;
182 /* Some DWARF extensions (e.g., MIPS/SGI) implement a subprogram
183 attribute that accelerates the lookup of the FDE associated
184 with the subprogram. This variable holds the table index of the FDE
185 associated with the current function (body) definition. */
186 static unsigned current_funcdef_fde;
188 /* Forward declarations for functions defined in this file. */
190 static char *stripattributes PROTO((char *));
191 static char *dwarf_cfi_name PROTO((unsigned));
192 static dw_cfi_ref new_cfi PROTO((void));
193 static void add_cfi PROTO((dw_cfi_ref *, dw_cfi_ref));
194 static unsigned long size_of_uleb128 PROTO((unsigned long));
195 static unsigned long size_of_sleb128 PROTO((long));
196 static void output_uleb128 PROTO((unsigned long));
197 static void output_sleb128 PROTO((long));
198 static void add_fde_cfi PROTO((char *, dw_cfi_ref));
199 static void lookup_cfa_1 PROTO((dw_cfi_ref, unsigned long *,
201 static void lookup_cfa PROTO((unsigned long *, long *));
202 static void reg_save PROTO((char *, unsigned, unsigned,
204 static void initial_return_save PROTO((rtx));
205 static void output_cfi PROTO((dw_cfi_ref, dw_fde_ref));
206 static void output_call_frame_info PROTO((int));
207 static unsigned reg_number PROTO((rtx));
208 static void dwarf2out_stack_adjust PROTO((rtx));
210 /* Definitions of defaults for assembler-dependent names of various
211 pseudo-ops and section names.
212 Theses may be overridden in the tm.h file (if necessary) for a particular
215 #ifdef OBJECT_FORMAT_ELF
216 #ifndef UNALIGNED_SHORT_ASM_OP
217 #define UNALIGNED_SHORT_ASM_OP ".2byte"
219 #ifndef UNALIGNED_INT_ASM_OP
220 #define UNALIGNED_INT_ASM_OP ".4byte"
222 #ifndef UNALIGNED_DOUBLE_INT_ASM_OP
223 #define UNALIGNED_DOUBLE_INT_ASM_OP ".8byte"
225 #endif /* OBJECT_FORMAT_ELF */
228 #define ASM_BYTE_OP ".byte"
231 /* Data and reference forms for relocatable data. */
232 #define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
233 #define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
235 /* Pseudo-op for defining a new section. */
236 #ifndef SECTION_ASM_OP
237 #define SECTION_ASM_OP ".section"
240 /* The default format used by the ASM_OUTPUT_SECTION macro (see below) to
241 print the SECTION_ASM_OP and the section name. The default here works for
242 almost all svr4 assemblers, except for the sparc, where the section name
243 must be enclosed in double quotes. (See sparcv4.h). */
244 #ifndef SECTION_FORMAT
245 #ifdef PUSHSECTION_FORMAT
246 #define SECTION_FORMAT PUSHSECTION_FORMAT
248 #define SECTION_FORMAT "\t%s\t%s\n"
252 #ifndef FRAME_SECTION
253 #define FRAME_SECTION ".debug_frame"
256 #ifndef FUNC_BEGIN_LABEL
257 #define FUNC_BEGIN_LABEL "LFB"
259 #ifndef FUNC_END_LABEL
260 #define FUNC_END_LABEL "LFE"
262 #define CIE_AFTER_SIZE_LABEL "LSCIE"
263 #define CIE_END_LABEL "LECIE"
264 #define CIE_LENGTH_LABEL "LLCIE"
265 #define FDE_AFTER_SIZE_LABEL "LSFDE"
266 #define FDE_END_LABEL "LEFDE"
267 #define FDE_LENGTH_LABEL "LLFDE"
269 /* Definitions of defaults for various types of primitive assembly language
270 output operations. These may be overridden from within the tm.h file,
271 but typically, that is unnecessary. */
273 #ifndef ASM_OUTPUT_SECTION
274 #define ASM_OUTPUT_SECTION(FILE, SECTION) \
275 fprintf ((FILE), SECTION_FORMAT, SECTION_ASM_OP, SECTION)
278 #ifndef ASM_OUTPUT_DWARF_DATA1
279 #define ASM_OUTPUT_DWARF_DATA1(FILE,VALUE) \
280 fprintf ((FILE), "\t%s\t0x%x", ASM_BYTE_OP, (unsigned) (VALUE))
283 #ifndef ASM_OUTPUT_DWARF_DELTA1
284 #define ASM_OUTPUT_DWARF_DELTA1(FILE,LABEL1,LABEL2) \
285 do { fprintf ((FILE), "\t%s\t", ASM_BYTE_OP); \
286 assemble_name (FILE, LABEL1); \
287 fprintf (FILE, "-"); \
288 assemble_name (FILE, LABEL2); \
292 #ifdef UNALIGNED_INT_ASM_OP
294 #ifndef UNALIGNED_OFFSET_ASM_OP
295 #define UNALIGNED_OFFSET_ASM_OP \
296 (DWARF_OFFSET_SIZE == 8 ? UNALIGNED_DOUBLE_INT_ASM_OP : UNALIGNED_INT_ASM_OP)
299 #ifndef UNALIGNED_WORD_ASM_OP
300 #define UNALIGNED_WORD_ASM_OP \
301 (PTR_SIZE == 8 ? UNALIGNED_DOUBLE_INT_ASM_OP : UNALIGNED_INT_ASM_OP)
304 #ifndef ASM_OUTPUT_DWARF_DELTA2
305 #define ASM_OUTPUT_DWARF_DELTA2(FILE,LABEL1,LABEL2) \
306 do { fprintf ((FILE), "\t%s\t", UNALIGNED_SHORT_ASM_OP); \
307 assemble_name (FILE, LABEL1); \
308 fprintf (FILE, "-"); \
309 assemble_name (FILE, LABEL2); \
313 #ifndef ASM_OUTPUT_DWARF_DELTA4
314 #define ASM_OUTPUT_DWARF_DELTA4(FILE,LABEL1,LABEL2) \
315 do { fprintf ((FILE), "\t%s\t", UNALIGNED_INT_ASM_OP); \
316 assemble_name (FILE, LABEL1); \
317 fprintf (FILE, "-"); \
318 assemble_name (FILE, LABEL2); \
322 #ifndef ASM_OUTPUT_DWARF_DELTA
323 #define ASM_OUTPUT_DWARF_DELTA(FILE,LABEL1,LABEL2) \
324 do { fprintf ((FILE), "\t%s\t", UNALIGNED_OFFSET_ASM_OP); \
325 assemble_name (FILE, LABEL1); \
326 fprintf (FILE, "-"); \
327 assemble_name (FILE, LABEL2); \
331 #ifndef ASM_OUTPUT_DWARF_ADDR_DELTA
332 #define ASM_OUTPUT_DWARF_ADDR_DELTA(FILE,LABEL1,LABEL2) \
333 do { fprintf ((FILE), "\t%s\t", UNALIGNED_WORD_ASM_OP); \
334 assemble_name (FILE, LABEL1); \
335 fprintf (FILE, "-"); \
336 assemble_name (FILE, LABEL2); \
340 #ifndef ASM_OUTPUT_DWARF_ADDR
341 #define ASM_OUTPUT_DWARF_ADDR(FILE,LABEL) \
342 do { fprintf ((FILE), "\t%s\t", UNALIGNED_WORD_ASM_OP); \
343 assemble_name (FILE, LABEL); \
347 /* ??? This macro takes an RTX in dwarfout.c and a string in dwarf2out.c.
348 We resolve the conflict by creating a new macro ASM_OUTPUT_DWARF2_ADDR_CONST
349 for ports that want to support both DWARF1 and DWARF2. This needs a better
350 solution. See also the comments in sparc/sp64-elf.h. */
351 #ifdef ASM_OUTPUT_DWARF2_ADDR_CONST
352 #undef ASM_OUTPUT_DWARF_ADDR_CONST
353 #define ASM_OUTPUT_DWARF_ADDR_CONST(FILE,ADDR) \
354 ASM_OUTPUT_DWARF2_ADDR_CONST (FILE, ADDR)
357 #ifndef ASM_OUTPUT_DWARF_ADDR_CONST
358 #define ASM_OUTPUT_DWARF_ADDR_CONST(FILE,ADDR) \
359 fprintf ((FILE), "\t%s\t%s", UNALIGNED_WORD_ASM_OP, (ADDR))
362 #ifndef ASM_OUTPUT_DWARF_OFFSET4
363 #define ASM_OUTPUT_DWARF_OFFSET4(FILE,LABEL) \
364 do { fprintf ((FILE), "\t%s\t", UNALIGNED_INT_ASM_OP); \
365 assemble_name (FILE, LABEL); \
369 #ifndef ASM_OUTPUT_DWARF_OFFSET
370 #define ASM_OUTPUT_DWARF_OFFSET(FILE,LABEL) \
371 do { fprintf ((FILE), "\t%s\t", UNALIGNED_OFFSET_ASM_OP); \
372 assemble_name (FILE, LABEL); \
376 #ifndef ASM_OUTPUT_DWARF_DATA2
377 #define ASM_OUTPUT_DWARF_DATA2(FILE,VALUE) \
378 fprintf ((FILE), "\t%s\t0x%x", UNALIGNED_SHORT_ASM_OP, (unsigned) (VALUE))
381 #ifndef ASM_OUTPUT_DWARF_DATA4
382 #define ASM_OUTPUT_DWARF_DATA4(FILE,VALUE) \
383 fprintf ((FILE), "\t%s\t0x%x", UNALIGNED_INT_ASM_OP, (unsigned) (VALUE))
386 #ifndef ASM_OUTPUT_DWARF_DATA
387 #define ASM_OUTPUT_DWARF_DATA(FILE,VALUE) \
388 fprintf ((FILE), "\t%s\t0x%lx", UNALIGNED_OFFSET_ASM_OP, \
389 (unsigned long) (VALUE))
392 #ifndef ASM_OUTPUT_DWARF_ADDR_DATA
393 #define ASM_OUTPUT_DWARF_ADDR_DATA(FILE,VALUE) \
394 fprintf ((FILE), "\t%s\t0x%lx", UNALIGNED_WORD_ASM_OP, \
395 (unsigned long) (VALUE))
398 #ifndef ASM_OUTPUT_DWARF_DATA8
399 #define ASM_OUTPUT_DWARF_DATA8(FILE,HIGH_VALUE,LOW_VALUE) \
401 if (WORDS_BIG_ENDIAN) \
403 fprintf ((FILE), "\t%s\t0x%lx\n", UNALIGNED_INT_ASM_OP, (HIGH_VALUE));\
404 fprintf ((FILE), "\t%s\t0x%lx", UNALIGNED_INT_ASM_OP, (LOW_VALUE));\
408 fprintf ((FILE), "\t%s\t0x%lx\n", UNALIGNED_INT_ASM_OP, (LOW_VALUE)); \
409 fprintf ((FILE), "\t%s\t0x%lx", UNALIGNED_INT_ASM_OP, (HIGH_VALUE)); \
414 #else /* UNALIGNED_INT_ASM_OP */
416 /* We don't have unaligned support, let's hope the normal output works for
419 #define ASM_OUTPUT_DWARF_ADDR(FILE,LABEL) \
420 assemble_integer (gen_rtx_SYMBOL_REF (Pmode, LABEL), PTR_SIZE, 1)
422 #define ASM_OUTPUT_DWARF_OFFSET4(FILE,LABEL) \
423 assemble_integer (gen_rtx_SYMBOL_REF (SImode, LABEL), 4, 1)
425 #define ASM_OUTPUT_DWARF_OFFSET(FILE,LABEL) \
426 assemble_integer (gen_rtx_SYMBOL_REF (SImode, LABEL), 4, 1)
428 #define ASM_OUTPUT_DWARF_DELTA2(FILE,LABEL1,LABEL2) \
429 assemble_integer (gen_rtx_MINUS (HImode, \
430 gen_rtx_SYMBOL_REF (Pmode, LABEL1), \
431 gen_rtx_SYMBOL_REF (Pmode, LABEL2)), \
434 #define ASM_OUTPUT_DWARF_DELTA4(FILE,LABEL1,LABEL2) \
435 assemble_integer (gen_rtx_MINUS (SImode, \
436 gen_rtx_SYMBOL_REF (Pmode, LABEL1), \
437 gen_rtx_SYMBOL_REF (Pmode, LABEL2)), \
440 #define ASM_OUTPUT_DWARF_ADDR_DELTA(FILE,LABEL1,LABEL2) \
441 assemble_integer (gen_rtx_MINUS (Pmode, \
442 gen_rtx_SYMBOL_REF (Pmode, LABEL1), \
443 gen_rtx_SYMBOL_REF (Pmode, LABEL2)), \
446 #define ASM_OUTPUT_DWARF_DELTA(FILE,LABEL1,LABEL2) \
447 ASM_OUTPUT_DWARF_DELTA4 (FILE,LABEL1,LABEL2)
449 #define ASM_OUTPUT_DWARF_DATA4(FILE,VALUE) \
450 assemble_integer (GEN_INT (VALUE), 4, 1)
452 #endif /* UNALIGNED_INT_ASM_OP */
455 #ifndef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
456 #define ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL(FILE, SY, HI, LO) \
458 fprintf (FILE, "\t%s\t", SET_ASM_OP); \
459 assemble_name (FILE, SY); \
461 assemble_name (FILE, HI); \
463 assemble_name (FILE, LO); \
466 #endif /* SET_ASM_OP */
468 /* This is similar to the default ASM_OUTPUT_ASCII, except that no trailing
469 newline is produced. When flag_debug_asm is asserted, we add commentary
470 at the end of the line, so we must avoid output of a newline here. */
471 #ifndef ASM_OUTPUT_DWARF_STRING
472 #define ASM_OUTPUT_DWARF_STRING(FILE,P) \
474 register int slen = strlen(P); \
475 register char *p = (P); \
477 fprintf (FILE, "\t.ascii \""); \
478 for (i = 0; i < slen; i++) \
480 register int c = p[i]; \
481 if (c == '\"' || c == '\\') \
483 if (c >= ' ' && c < 0177) \
487 fprintf (FILE, "\\%o", c); \
490 fprintf (FILE, "\\0\""); \
495 /* The DWARF 2 CFA column which tracks the return address. Normally this
496 is the column for PC, or the first column after all of the hard
498 #ifndef DWARF_FRAME_RETURN_COLUMN
500 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (PC_REGNUM)
502 #define DWARF_FRAME_RETURN_COLUMN FIRST_PSEUDO_REGISTER
506 /* The mapping from gcc register number to DWARF 2 CFA column number. By
507 default, we just provide columns for all registers. */
508 #ifndef DWARF_FRAME_REGNUM
509 #define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG)
512 /* Hook used by __throw. */
515 expand_builtin_dwarf_fp_regnum ()
517 return GEN_INT (DWARF_FRAME_REGNUM (HARD_FRAME_POINTER_REGNUM));
520 /* The offset from the incoming value of %sp to the top of the stack frame
521 for the current function. */
522 #ifndef INCOMING_FRAME_SP_OFFSET
523 #define INCOMING_FRAME_SP_OFFSET 0
526 /* Return a pointer to a copy of the section string name S with all
527 attributes stripped off, and an asterisk prepended (for assemble_name). */
533 char *stripped = xmalloc (strlen (s) + 2);
538 while (*s && *s != ',')
545 /* Return the register number described by a given RTL node. */
551 register unsigned regno = REGNO (rtl);
553 if (regno >= FIRST_PSEUDO_REGISTER)
555 warning ("internal regno botch: regno = %d\n", regno);
559 regno = DBX_REGISTER_NUMBER (regno);
563 struct reg_size_range
570 /* Given a register number in REG_TREE, return an rtx for its size in bytes.
571 We do this in kind of a roundabout way, by building up a list of
572 register size ranges and seeing where our register falls in one of those
573 ranges. We need to do it this way because REG_TREE is not a constant,
574 and the target macros were not designed to make this task easy. */
577 expand_builtin_dwarf_reg_size (reg_tree, target)
581 enum machine_mode mode;
583 struct reg_size_range ranges[5];
590 for (; i < FIRST_PSEUDO_REGISTER; ++i)
592 /* The return address is out of order on the MIPS, and we don't use
593 copy_reg for it anyway, so we don't care here how large it is. */
594 if (DWARF_FRAME_REGNUM (i) == DWARF_FRAME_RETURN_COLUMN)
597 mode = reg_raw_mode[i];
599 /* CCmode is arbitrarily given a size of 4 bytes. It is more useful
600 to use the same size as word_mode, since that reduces the number
601 of ranges we need. It should not matter, since the result should
602 never be used for a condition code register anyways. */
603 if (GET_MODE_CLASS (mode) == MODE_CC)
606 size = GET_MODE_SIZE (mode);
608 /* If this register is not valid in the specified mode and
609 we have a previous size, use that for the size of this
610 register to avoid making junk tiny ranges. */
611 if (! HARD_REGNO_MODE_OK (i, mode) && last_size != -1)
614 if (size != last_size)
616 ranges[n_ranges].beg = i;
617 ranges[n_ranges].size = last_size = size;
622 ranges[n_ranges-1].end = i;
625 /* The usual case: fp regs surrounded by general regs. */
626 if (n_ranges == 3 && ranges[0].size == ranges[2].size)
628 if ((DWARF_FRAME_REGNUM (ranges[1].end)
629 - DWARF_FRAME_REGNUM (ranges[1].beg))
630 != ranges[1].end - ranges[1].beg)
632 t = fold (build (GE_EXPR, integer_type_node, reg_tree,
633 build_int_2 (DWARF_FRAME_REGNUM (ranges[1].beg), 0)));
634 t2 = fold (build (LE_EXPR, integer_type_node, reg_tree,
635 build_int_2 (DWARF_FRAME_REGNUM (ranges[1].end), 0)));
636 t = fold (build (TRUTH_ANDIF_EXPR, integer_type_node, t, t2));
637 t = fold (build (COND_EXPR, integer_type_node, t,
638 build_int_2 (ranges[1].size, 0),
639 build_int_2 (ranges[0].size, 0)));
643 /* Initialize last_end to be larger than any possible
644 DWARF_FRAME_REGNUM. */
645 int last_end = 0x7fffffff;
647 t = build_int_2 (ranges[n_ranges].size, 0);
650 int beg = DWARF_FRAME_REGNUM (ranges[n_ranges].beg);
651 int end = DWARF_FRAME_REGNUM (ranges[n_ranges].end);
657 if (end - beg != ranges[n_ranges].end - ranges[n_ranges].beg)
659 t2 = fold (build (LE_EXPR, integer_type_node, reg_tree,
660 build_int_2 (end, 0)));
661 t = fold (build (COND_EXPR, integer_type_node, t2,
662 build_int_2 (ranges[n_ranges].size, 0), t));
664 while (--n_ranges >= 0);
666 return expand_expr (t, target, Pmode, 0);
669 /* Convert a DWARF call frame info. operation to its string name */
672 dwarf_cfi_name (cfi_opc)
673 register unsigned cfi_opc;
677 case DW_CFA_advance_loc:
678 return "DW_CFA_advance_loc";
680 return "DW_CFA_offset";
682 return "DW_CFA_restore";
686 return "DW_CFA_set_loc";
687 case DW_CFA_advance_loc1:
688 return "DW_CFA_advance_loc1";
689 case DW_CFA_advance_loc2:
690 return "DW_CFA_advance_loc2";
691 case DW_CFA_advance_loc4:
692 return "DW_CFA_advance_loc4";
693 case DW_CFA_offset_extended:
694 return "DW_CFA_offset_extended";
695 case DW_CFA_restore_extended:
696 return "DW_CFA_restore_extended";
697 case DW_CFA_undefined:
698 return "DW_CFA_undefined";
699 case DW_CFA_same_value:
700 return "DW_CFA_same_value";
701 case DW_CFA_register:
702 return "DW_CFA_register";
703 case DW_CFA_remember_state:
704 return "DW_CFA_remember_state";
705 case DW_CFA_restore_state:
706 return "DW_CFA_restore_state";
708 return "DW_CFA_def_cfa";
709 case DW_CFA_def_cfa_register:
710 return "DW_CFA_def_cfa_register";
711 case DW_CFA_def_cfa_offset:
712 return "DW_CFA_def_cfa_offset";
714 /* SGI/MIPS specific */
715 case DW_CFA_MIPS_advance_loc8:
716 return "DW_CFA_MIPS_advance_loc8";
719 case DW_CFA_GNU_window_save:
720 return "DW_CFA_GNU_window_save";
721 case DW_CFA_GNU_args_size:
722 return "DW_CFA_GNU_args_size";
723 case DW_CFA_GNU_negative_offset_extended:
724 return "DW_CFA_GNU_negative_offset_extended";
727 return "DW_CFA_<unknown>";
731 /* Return a pointer to a newly allocated Call Frame Instruction. */
733 static inline dw_cfi_ref
736 register dw_cfi_ref cfi = (dw_cfi_ref) xmalloc (sizeof (dw_cfi_node));
738 cfi->dw_cfi_next = NULL;
739 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = 0;
740 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = 0;
745 /* Add a Call Frame Instruction to list of instructions. */
748 add_cfi (list_head, cfi)
749 register dw_cfi_ref *list_head;
750 register dw_cfi_ref cfi;
752 register dw_cfi_ref *p;
754 /* Find the end of the chain. */
755 for (p = list_head; (*p) != NULL; p = &(*p)->dw_cfi_next)
761 /* Generate a new label for the CFI info to refer to. */
764 dwarf2out_cfi_label ()
766 static char label[20];
767 static unsigned long label_num = 0;
769 ASM_GENERATE_INTERNAL_LABEL (label, "LCFI", label_num++);
770 ASM_OUTPUT_LABEL (asm_out_file, label);
775 /* Add CFI to the current fde at the PC value indicated by LABEL if specified,
776 or to the CIE if LABEL is NULL. */
779 add_fde_cfi (label, cfi)
780 register char *label;
781 register dw_cfi_ref cfi;
785 register dw_fde_ref fde = &fde_table[fde_table_in_use - 1];
788 label = dwarf2out_cfi_label ();
790 if (fde->dw_fde_current_label == NULL
791 || strcmp (label, fde->dw_fde_current_label) != 0)
793 register dw_cfi_ref xcfi;
795 fde->dw_fde_current_label = label = xstrdup (label);
797 /* Set the location counter to the new label. */
799 xcfi->dw_cfi_opc = DW_CFA_advance_loc4;
800 xcfi->dw_cfi_oprnd1.dw_cfi_addr = label;
801 add_cfi (&fde->dw_fde_cfi, xcfi);
804 add_cfi (&fde->dw_fde_cfi, cfi);
808 add_cfi (&cie_cfi_head, cfi);
811 /* Subroutine of lookup_cfa. */
814 lookup_cfa_1 (cfi, regp, offsetp)
815 register dw_cfi_ref cfi;
816 register unsigned long *regp;
817 register long *offsetp;
819 switch (cfi->dw_cfi_opc)
821 case DW_CFA_def_cfa_offset:
822 *offsetp = cfi->dw_cfi_oprnd1.dw_cfi_offset;
824 case DW_CFA_def_cfa_register:
825 *regp = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
828 *regp = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
829 *offsetp = cfi->dw_cfi_oprnd2.dw_cfi_offset;
836 /* Find the previous value for the CFA. */
839 lookup_cfa (regp, offsetp)
840 register unsigned long *regp;
841 register long *offsetp;
843 register dw_cfi_ref cfi;
845 *regp = (unsigned long) -1;
848 for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
849 lookup_cfa_1 (cfi, regp, offsetp);
851 if (fde_table_in_use)
853 register dw_fde_ref fde = &fde_table[fde_table_in_use - 1];
854 for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
855 lookup_cfa_1 (cfi, regp, offsetp);
859 /* The current rule for calculating the DWARF2 canonical frame address. */
860 static unsigned long cfa_reg;
861 static long cfa_offset;
863 /* The register used for saving registers to the stack, and its offset
865 static unsigned cfa_store_reg;
866 static long cfa_store_offset;
868 /* The running total of the size of arguments pushed onto the stack. */
869 static long args_size;
871 /* The last args_size we actually output. */
872 static long old_args_size;
874 /* Entry point to update the canonical frame address (CFA).
875 LABEL is passed to add_fde_cfi. The value of CFA is now to be
876 calculated from REG+OFFSET. */
879 dwarf2out_def_cfa (label, reg, offset)
880 register char *label;
881 register unsigned reg;
882 register long offset;
884 register dw_cfi_ref cfi;
885 unsigned long old_reg;
890 if (cfa_store_reg == reg)
891 cfa_store_offset = offset;
893 reg = DWARF_FRAME_REGNUM (reg);
894 lookup_cfa (&old_reg, &old_offset);
896 if (reg == old_reg && offset == old_offset)
903 cfi->dw_cfi_opc = DW_CFA_def_cfa_offset;
904 cfi->dw_cfi_oprnd1.dw_cfi_offset = offset;
907 #ifndef MIPS_DEBUGGING_INFO /* SGI dbx thinks this means no offset. */
908 else if (offset == old_offset && old_reg != (unsigned long) -1)
910 cfi->dw_cfi_opc = DW_CFA_def_cfa_register;
911 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
917 cfi->dw_cfi_opc = DW_CFA_def_cfa;
918 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
919 cfi->dw_cfi_oprnd2.dw_cfi_offset = offset;
922 add_fde_cfi (label, cfi);
925 /* Add the CFI for saving a register. REG is the CFA column number.
926 LABEL is passed to add_fde_cfi.
927 If SREG is -1, the register is saved at OFFSET from the CFA;
928 otherwise it is saved in SREG. */
931 reg_save (label, reg, sreg, offset)
932 register char * label;
933 register unsigned reg;
934 register unsigned sreg;
935 register long offset;
937 register dw_cfi_ref cfi = new_cfi ();
939 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
941 /* The following comparison is correct. -1 is used to indicate that
942 the value isn't a register number. */
943 if (sreg == (unsigned int) -1)
946 /* The register number won't fit in 6 bits, so we have to use
948 cfi->dw_cfi_opc = DW_CFA_offset_extended;
950 cfi->dw_cfi_opc = DW_CFA_offset;
952 offset /= DWARF_CIE_DATA_ALIGNMENT;
955 cfi->dw_cfi_opc = DW_CFA_GNU_negative_offset_extended;
958 cfi->dw_cfi_oprnd2.dw_cfi_offset = offset;
962 cfi->dw_cfi_opc = DW_CFA_register;
963 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = sreg;
966 add_fde_cfi (label, cfi);
969 /* Add the CFI for saving a register window. LABEL is passed to reg_save.
970 This CFI tells the unwinder that it needs to restore the window registers
971 from the previous frame's window save area.
973 ??? Perhaps we should note in the CIE where windows are saved (instead of
974 assuming 0(cfa)) and what registers are in the window. */
977 dwarf2out_window_save (label)
978 register char * label;
980 register dw_cfi_ref cfi = new_cfi ();
981 cfi->dw_cfi_opc = DW_CFA_GNU_window_save;
982 add_fde_cfi (label, cfi);
985 /* Add a CFI to update the running total of the size of arguments
986 pushed onto the stack. */
989 dwarf2out_args_size (label, size)
993 register dw_cfi_ref cfi;
995 if (size == old_args_size)
997 old_args_size = size;
1000 cfi->dw_cfi_opc = DW_CFA_GNU_args_size;
1001 cfi->dw_cfi_oprnd1.dw_cfi_offset = size;
1002 add_fde_cfi (label, cfi);
1005 /* Entry point for saving a register to the stack. REG is the GCC register
1006 number. LABEL and OFFSET are passed to reg_save. */
1009 dwarf2out_reg_save (label, reg, offset)
1010 register char * label;
1011 register unsigned reg;
1012 register long offset;
1014 reg_save (label, DWARF_FRAME_REGNUM (reg), -1, offset);
1017 /* Entry point for saving the return address in the stack.
1018 LABEL and OFFSET are passed to reg_save. */
1021 dwarf2out_return_save (label, offset)
1022 register char * label;
1023 register long offset;
1025 reg_save (label, DWARF_FRAME_RETURN_COLUMN, -1, offset);
1028 /* Entry point for saving the return address in a register.
1029 LABEL and SREG are passed to reg_save. */
1032 dwarf2out_return_reg (label, sreg)
1033 register char * label;
1034 register unsigned sreg;
1036 reg_save (label, DWARF_FRAME_RETURN_COLUMN, sreg, 0);
1039 /* Record the initial position of the return address. RTL is
1040 INCOMING_RETURN_ADDR_RTX. */
1043 initial_return_save (rtl)
1046 unsigned int reg = (unsigned int) -1;
1049 switch (GET_CODE (rtl))
1052 /* RA is in a register. */
1053 reg = reg_number (rtl);
1056 /* RA is on the stack. */
1057 rtl = XEXP (rtl, 0);
1058 switch (GET_CODE (rtl))
1061 if (REGNO (rtl) != STACK_POINTER_REGNUM)
1066 if (REGNO (XEXP (rtl, 0)) != STACK_POINTER_REGNUM)
1068 offset = INTVAL (XEXP (rtl, 1));
1071 if (REGNO (XEXP (rtl, 0)) != STACK_POINTER_REGNUM)
1073 offset = -INTVAL (XEXP (rtl, 1));
1080 /* The return address is at some offset from any value we can
1081 actually load. For instance, on the SPARC it is in %i7+8. Just
1082 ignore the offset for now; it doesn't matter for unwinding frames. */
1083 if (GET_CODE (XEXP (rtl, 1)) != CONST_INT)
1085 initial_return_save (XEXP (rtl, 0));
1091 reg_save (NULL, DWARF_FRAME_RETURN_COLUMN, reg, offset - cfa_offset);
1094 /* Check INSN to see if it looks like a push or a stack adjustment, and
1095 make a note of it if it does. EH uses this information to find out how
1096 much extra space it needs to pop off the stack. */
1099 dwarf2out_stack_adjust (insn)
1105 if (! asynchronous_exceptions && GET_CODE (insn) == CALL_INSN)
1107 /* Extract the size of the args from the CALL rtx itself. */
1109 insn = PATTERN (insn);
1110 if (GET_CODE (insn) == PARALLEL)
1111 insn = XVECEXP (insn, 0, 0);
1112 if (GET_CODE (insn) == SET)
1113 insn = SET_SRC (insn);
1114 assert (GET_CODE (insn) == CALL);
1115 dwarf2out_args_size ("", INTVAL (XEXP (insn, 1)));
1119 /* If only calls can throw, and we have a frame pointer,
1120 save up adjustments until we see the CALL_INSN. */
1121 else if (! asynchronous_exceptions
1122 && cfa_reg != STACK_POINTER_REGNUM)
1125 if (GET_CODE (insn) == BARRIER)
1127 /* When we see a BARRIER, we know to reset args_size to 0. Usually
1128 the compiler will have already emitted a stack adjustment, but
1129 doesn't bother for calls to noreturn functions. */
1130 #ifdef STACK_GROWS_DOWNWARD
1131 offset = -args_size;
1136 else if (GET_CODE (PATTERN (insn)) == SET)
1141 insn = PATTERN (insn);
1142 src = SET_SRC (insn);
1143 dest = SET_DEST (insn);
1145 if (dest == stack_pointer_rtx)
1147 /* (set (reg sp) (plus (reg sp) (const_int))) */
1148 code = GET_CODE (src);
1149 if (! (code == PLUS || code == MINUS)
1150 || XEXP (src, 0) != stack_pointer_rtx
1151 || GET_CODE (XEXP (src, 1)) != CONST_INT)
1154 offset = INTVAL (XEXP (src, 1));
1156 else if (GET_CODE (dest) == MEM)
1158 /* (set (mem (pre_dec (reg sp))) (foo)) */
1159 src = XEXP (dest, 0);
1160 code = GET_CODE (src);
1162 if (! (code == PRE_DEC || code == PRE_INC)
1163 || XEXP (src, 0) != stack_pointer_rtx)
1166 offset = GET_MODE_SIZE (GET_MODE (dest));
1171 if (code == PLUS || code == PRE_INC)
1180 if (cfa_reg == STACK_POINTER_REGNUM)
1181 cfa_offset += offset;
1183 #ifndef STACK_GROWS_DOWNWARD
1186 args_size += offset;
1190 label = dwarf2out_cfi_label ();
1191 dwarf2out_def_cfa (label, cfa_reg, cfa_offset);
1192 dwarf2out_args_size (label, args_size);
1195 /* A temporary register used in adjusting SP or setting up the store_reg. */
1196 static unsigned cfa_temp_reg;
1198 /* A temporary value used in adjusting SP or setting up the store_reg. */
1199 static long cfa_temp_value;
1201 /* Record call frame debugging information for an expression, which either
1202 sets SP or FP (adjusting how we calculate the frame address) or saves a
1203 register to the stack. */
1206 dwarf2out_frame_debug_expr (expr, label)
1213 /* If RTX_FRAME_RELATED_P is set on a PARALLEL, process each member of
1214 the PARALLEL independantly. The first element is always processed if
1215 it is a SET. This is for backward compatability. Other elements
1216 are processed only if they are SETs and the RTX_FRAME_RELATED_P
1217 flag is set in them. */
1219 if (GET_CODE (expr) == PARALLEL)
1222 int limit = XVECLEN (expr, 0);
1224 for (par_index = 0; par_index < limit; par_index++)
1226 rtx x = XVECEXP (expr, 0, par_index);
1228 if (GET_CODE (x) == SET &&
1229 (RTX_FRAME_RELATED_P (x) || par_index == 0))
1230 dwarf2out_frame_debug_expr (x, label);
1235 if (GET_CODE (expr) != SET)
1238 src = SET_SRC (expr);
1239 dest = SET_DEST (expr);
1241 switch (GET_CODE (dest))
1244 /* Update the CFA rule wrt SP or FP. Make sure src is
1245 relative to the current CFA register. */
1246 switch (GET_CODE (src))
1248 /* Setting FP from SP. */
1250 if (cfa_reg != (unsigned) REGNO (src))
1252 if (REGNO (dest) != STACK_POINTER_REGNUM
1253 && !(frame_pointer_needed
1254 && REGNO (dest) == HARD_FRAME_POINTER_REGNUM))
1256 cfa_reg = REGNO (dest);
1261 if (dest == stack_pointer_rtx)
1264 switch (GET_CODE (XEXP (src, 1)))
1267 offset = INTVAL (XEXP (src, 1));
1270 if ((unsigned) REGNO (XEXP (src, 1)) != cfa_temp_reg)
1272 offset = cfa_temp_value;
1278 if (XEXP (src, 0) == hard_frame_pointer_rtx)
1280 /* Restoring SP from FP in the epilogue. */
1281 if (cfa_reg != (unsigned) HARD_FRAME_POINTER_REGNUM)
1283 cfa_reg = STACK_POINTER_REGNUM;
1285 else if (XEXP (src, 0) != stack_pointer_rtx)
1288 if (GET_CODE (src) == PLUS)
1290 if (cfa_reg == STACK_POINTER_REGNUM)
1291 cfa_offset += offset;
1292 if (cfa_store_reg == STACK_POINTER_REGNUM)
1293 cfa_store_offset += offset;
1295 else if (dest == hard_frame_pointer_rtx)
1297 /* Either setting the FP from an offset of the SP,
1298 or adjusting the FP */
1299 if (! frame_pointer_needed
1300 || REGNO (dest) != HARD_FRAME_POINTER_REGNUM)
1303 if (XEXP (src, 0) == stack_pointer_rtx
1304 && GET_CODE (XEXP (src, 1)) == CONST_INT)
1306 if (cfa_reg != STACK_POINTER_REGNUM)
1308 offset = INTVAL (XEXP (src, 1));
1309 if (GET_CODE (src) == PLUS)
1311 cfa_offset += offset;
1312 cfa_reg = HARD_FRAME_POINTER_REGNUM;
1314 else if (XEXP (src, 0) == hard_frame_pointer_rtx
1315 && GET_CODE (XEXP (src, 1)) == CONST_INT)
1317 if (cfa_reg != (unsigned) HARD_FRAME_POINTER_REGNUM)
1319 offset = INTVAL (XEXP (src, 1));
1320 if (GET_CODE (src) == PLUS)
1322 cfa_offset += offset;
1330 if (GET_CODE (src) != PLUS
1331 || XEXP (src, 1) != stack_pointer_rtx)
1333 if (GET_CODE (XEXP (src, 0)) != REG
1334 || (unsigned) REGNO (XEXP (src, 0)) != cfa_temp_reg)
1336 if (cfa_reg != STACK_POINTER_REGNUM)
1338 cfa_store_reg = REGNO (dest);
1339 cfa_store_offset = cfa_offset - cfa_temp_value;
1344 cfa_temp_reg = REGNO (dest);
1345 cfa_temp_value = INTVAL (src);
1349 if (GET_CODE (XEXP (src, 0)) != REG
1350 || (unsigned) REGNO (XEXP (src, 0)) != cfa_temp_reg
1351 || (unsigned) REGNO (dest) != cfa_temp_reg
1352 || GET_CODE (XEXP (src, 1)) != CONST_INT)
1354 cfa_temp_value |= INTVAL (XEXP (src, 1));
1360 dwarf2out_def_cfa (label, cfa_reg, cfa_offset);
1364 /* Saving a register to the stack. Make sure dest is relative to the
1366 if (GET_CODE (src) != REG)
1368 switch (GET_CODE (XEXP (dest, 0)))
1373 offset = GET_MODE_SIZE (GET_MODE (dest));
1374 if (GET_CODE (XEXP (dest, 0)) == PRE_INC)
1377 if (REGNO (XEXP (XEXP (dest, 0), 0)) != STACK_POINTER_REGNUM
1378 || cfa_store_reg != STACK_POINTER_REGNUM)
1380 cfa_store_offset += offset;
1381 if (cfa_reg == STACK_POINTER_REGNUM)
1382 cfa_offset = cfa_store_offset;
1384 offset = -cfa_store_offset;
1387 /* With an offset. */
1390 offset = INTVAL (XEXP (XEXP (dest, 0), 1));
1391 if (GET_CODE (XEXP (dest, 0)) == MINUS)
1394 if (cfa_store_reg != (unsigned) REGNO (XEXP (XEXP (dest, 0), 0)))
1396 offset -= cfa_store_offset;
1399 /* Without an offset. */
1401 if (cfa_store_reg != (unsigned) REGNO (XEXP (dest, 0)))
1403 offset = -cfa_store_offset;
1409 dwarf2out_def_cfa (label, cfa_reg, cfa_offset);
1410 dwarf2out_reg_save (label, REGNO (src), offset);
1419 /* Record call frame debugging information for INSN, which either
1420 sets SP or FP (adjusting how we calculate the frame address) or saves a
1421 register to the stack. If INSN is NULL_RTX, initialize our state. */
1424 dwarf2out_frame_debug (insn)
1430 if (insn == NULL_RTX)
1432 /* Set up state for generating call frame debug info. */
1433 lookup_cfa (&cfa_reg, &cfa_offset);
1434 if (cfa_reg != DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM))
1436 cfa_reg = STACK_POINTER_REGNUM;
1437 cfa_store_reg = cfa_reg;
1438 cfa_store_offset = cfa_offset;
1444 if (! RTX_FRAME_RELATED_P (insn))
1446 dwarf2out_stack_adjust (insn);
1450 label = dwarf2out_cfi_label ();
1452 src = find_reg_note (insn, REG_FRAME_RELATED_EXPR, NULL_RTX);
1454 insn = XEXP (src, 0);
1456 insn = PATTERN (insn);
1458 dwarf2out_frame_debug_expr (insn, label);
1461 /* Return the size of an unsigned LEB128 quantity. */
1463 static inline unsigned long
1464 size_of_uleb128 (value)
1465 register unsigned long value;
1467 register unsigned long size = 0;
1468 register unsigned byte;
1472 byte = (value & 0x7f);
1481 /* Return the size of a signed LEB128 quantity. */
1483 static inline unsigned long
1484 size_of_sleb128 (value)
1485 register long value;
1487 register unsigned long size = 0;
1488 register unsigned byte;
1492 byte = (value & 0x7f);
1496 while (!(((value == 0) && ((byte & 0x40) == 0))
1497 || ((value == -1) && ((byte & 0x40) != 0))));
1502 /* Output an unsigned LEB128 quantity. */
1505 output_uleb128 (value)
1506 register unsigned long value;
1508 unsigned long save_value = value;
1510 fprintf (asm_out_file, "\t%s\t", ASM_BYTE_OP);
1513 register unsigned byte = (value & 0x7f);
1516 /* More bytes to follow. */
1519 fprintf (asm_out_file, "0x%x", byte);
1521 fprintf (asm_out_file, ",");
1526 fprintf (asm_out_file, "\t%s ULEB128 0x%lx", ASM_COMMENT_START, save_value);
1529 /* Output an signed LEB128 quantity. */
1532 output_sleb128 (value)
1533 register long value;
1536 register unsigned byte;
1537 long save_value = value;
1539 fprintf (asm_out_file, "\t%s\t", ASM_BYTE_OP);
1542 byte = (value & 0x7f);
1543 /* arithmetic shift */
1545 more = !((((value == 0) && ((byte & 0x40) == 0))
1546 || ((value == -1) && ((byte & 0x40) != 0))));
1550 fprintf (asm_out_file, "0x%x", byte);
1552 fprintf (asm_out_file, ",");
1557 fprintf (asm_out_file, "\t%s SLEB128 %ld", ASM_COMMENT_START, save_value);
1560 /* Output a Call Frame Information opcode and its operand(s). */
1563 output_cfi (cfi, fde)
1564 register dw_cfi_ref cfi;
1565 register dw_fde_ref fde;
1567 if (cfi->dw_cfi_opc == DW_CFA_advance_loc)
1569 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
1571 | (cfi->dw_cfi_oprnd1.dw_cfi_offset & 0x3f));
1573 fprintf (asm_out_file, "\t%s DW_CFA_advance_loc 0x%lx",
1574 ASM_COMMENT_START, cfi->dw_cfi_oprnd1.dw_cfi_offset);
1575 fputc ('\n', asm_out_file);
1578 else if (cfi->dw_cfi_opc == DW_CFA_offset)
1580 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
1582 | (cfi->dw_cfi_oprnd1.dw_cfi_reg_num & 0x3f));
1584 fprintf (asm_out_file, "\t%s DW_CFA_offset, column 0x%lx",
1585 ASM_COMMENT_START, cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
1587 fputc ('\n', asm_out_file);
1588 output_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset);
1589 fputc ('\n', asm_out_file);
1591 else if (cfi->dw_cfi_opc == DW_CFA_restore)
1593 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
1595 | (cfi->dw_cfi_oprnd1.dw_cfi_reg_num & 0x3f));
1597 fprintf (asm_out_file, "\t%s DW_CFA_restore, column 0x%lx",
1598 ASM_COMMENT_START, cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
1600 fputc ('\n', asm_out_file);
1604 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, cfi->dw_cfi_opc);
1606 fprintf (asm_out_file, "\t%s %s", ASM_COMMENT_START,
1607 dwarf_cfi_name (cfi->dw_cfi_opc));
1609 fputc ('\n', asm_out_file);
1610 switch (cfi->dw_cfi_opc)
1612 case DW_CFA_set_loc:
1613 ASM_OUTPUT_DWARF_ADDR (asm_out_file, cfi->dw_cfi_oprnd1.dw_cfi_addr);
1614 fputc ('\n', asm_out_file);
1616 case DW_CFA_advance_loc1:
1617 ASM_OUTPUT_DWARF_DELTA1 (asm_out_file,
1618 cfi->dw_cfi_oprnd1.dw_cfi_addr,
1619 fde->dw_fde_current_label);
1620 fputc ('\n', asm_out_file);
1621 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
1623 case DW_CFA_advance_loc2:
1624 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file,
1625 cfi->dw_cfi_oprnd1.dw_cfi_addr,
1626 fde->dw_fde_current_label);
1627 fputc ('\n', asm_out_file);
1628 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
1630 case DW_CFA_advance_loc4:
1631 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file,
1632 cfi->dw_cfi_oprnd1.dw_cfi_addr,
1633 fde->dw_fde_current_label);
1634 fputc ('\n', asm_out_file);
1635 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
1637 #ifdef MIPS_DEBUGGING_INFO
1638 case DW_CFA_MIPS_advance_loc8:
1639 /* TODO: not currently implemented. */
1643 case DW_CFA_offset_extended:
1644 case DW_CFA_GNU_negative_offset_extended:
1645 case DW_CFA_def_cfa:
1646 output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
1647 fputc ('\n', asm_out_file);
1648 output_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset);
1649 fputc ('\n', asm_out_file);
1651 case DW_CFA_restore_extended:
1652 case DW_CFA_undefined:
1653 output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
1654 fputc ('\n', asm_out_file);
1656 case DW_CFA_same_value:
1657 case DW_CFA_def_cfa_register:
1658 output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
1659 fputc ('\n', asm_out_file);
1661 case DW_CFA_register:
1662 output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
1663 fputc ('\n', asm_out_file);
1664 output_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_reg_num);
1665 fputc ('\n', asm_out_file);
1667 case DW_CFA_def_cfa_offset:
1668 output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset);
1669 fputc ('\n', asm_out_file);
1671 case DW_CFA_GNU_window_save:
1673 case DW_CFA_GNU_args_size:
1674 output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset);
1675 fputc ('\n', asm_out_file);
1683 #if !defined (EH_FRAME_SECTION)
1684 #if defined (EH_FRAME_SECTION_ASM_OP)
1685 #define EH_FRAME_SECTION() eh_frame_section();
1687 #if defined (ASM_OUTPUT_SECTION_NAME)
1688 #define EH_FRAME_SECTION() \
1690 named_section (NULL_TREE, ".eh_frame", 0); \
1696 /* If we aren't using crtstuff to run ctors, don't use it for EH. */
1697 #if !defined (HAS_INIT_SECTION) && !defined (INIT_SECTION_ASM_OP)
1698 #undef EH_FRAME_SECTION
1701 /* Output the call frame information used to used to record information
1702 that relates to calculating the frame pointer, and records the
1703 location of saved registers. */
1706 output_call_frame_info (for_eh)
1709 register unsigned long i;
1710 register dw_fde_ref fde;
1711 register dw_cfi_ref cfi;
1712 char l1[20], l2[20];
1713 #ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
1717 /* Do we want to include a pointer to the exception table? */
1718 int eh_ptr = for_eh && exception_table_p ();
1720 fputc ('\n', asm_out_file);
1722 /* We're going to be generating comments, so turn on app. */
1728 #ifdef EH_FRAME_SECTION
1729 EH_FRAME_SECTION ();
1731 tree label = get_file_function_name ('F');
1733 force_data_section ();
1734 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
1735 ASM_GLOBALIZE_LABEL (asm_out_file, IDENTIFIER_POINTER (label));
1736 ASM_OUTPUT_LABEL (asm_out_file, IDENTIFIER_POINTER (label));
1738 assemble_label ("__FRAME_BEGIN__");
1741 ASM_OUTPUT_SECTION (asm_out_file, FRAME_SECTION);
1743 /* Output the CIE. */
1744 ASM_GENERATE_INTERNAL_LABEL (l1, CIE_AFTER_SIZE_LABEL, for_eh);
1745 ASM_GENERATE_INTERNAL_LABEL (l2, CIE_END_LABEL, for_eh);
1746 #ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
1747 ASM_GENERATE_INTERNAL_LABEL (ld, CIE_LENGTH_LABEL, for_eh);
1749 ASM_OUTPUT_DWARF_OFFSET4 (asm_out_file, ld);
1751 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, ld);
1754 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, l2, l1);
1756 ASM_OUTPUT_DWARF_DELTA (asm_out_file, l2, l1);
1759 fprintf (asm_out_file, "\t%s Length of Common Information Entry",
1762 fputc ('\n', asm_out_file);
1763 ASM_OUTPUT_LABEL (asm_out_file, l1);
1766 /* Now that the CIE pointer is PC-relative for EH,
1767 use 0 to identify the CIE. */
1768 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0);
1770 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, DW_CIE_ID);
1773 fprintf (asm_out_file, "\t%s CIE Identifier Tag", ASM_COMMENT_START);
1775 fputc ('\n', asm_out_file);
1776 if (! for_eh && DWARF_OFFSET_SIZE == 8)
1778 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, DW_CIE_ID);
1779 fputc ('\n', asm_out_file);
1782 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_CIE_VERSION);
1784 fprintf (asm_out_file, "\t%s CIE Version", ASM_COMMENT_START);
1786 fputc ('\n', asm_out_file);
1789 /* The CIE contains a pointer to the exception region info for the
1790 frame. Make the augmentation string three bytes (including the
1791 trailing null) so the pointer is 4-byte aligned. The Solaris ld
1792 can't handle unaligned relocs. */
1795 ASM_OUTPUT_DWARF_STRING (asm_out_file, "eh");
1796 fprintf (asm_out_file, "\t%s CIE Augmentation", ASM_COMMENT_START);
1800 ASM_OUTPUT_ASCII (asm_out_file, "eh", 3);
1802 fputc ('\n', asm_out_file);
1804 ASM_OUTPUT_DWARF_ADDR (asm_out_file, "__EXCEPTION_TABLE__");
1806 fprintf (asm_out_file, "\t%s pointer to exception region info",
1811 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
1813 fprintf (asm_out_file, "\t%s CIE Augmentation (none)",
1817 fputc ('\n', asm_out_file);
1820 fprintf (asm_out_file, " (CIE Code Alignment Factor)");
1822 fputc ('\n', asm_out_file);
1823 output_sleb128 (DWARF_CIE_DATA_ALIGNMENT);
1825 fprintf (asm_out_file, " (CIE Data Alignment Factor)");
1827 fputc ('\n', asm_out_file);
1828 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DWARF_FRAME_RETURN_COLUMN);
1830 fprintf (asm_out_file, "\t%s CIE RA Column", ASM_COMMENT_START);
1832 fputc ('\n', asm_out_file);
1834 for (cfi = cie_cfi_head; cfi != NULL; cfi = cfi->dw_cfi_next)
1835 output_cfi (cfi, NULL);
1837 /* Pad the CIE out to an address sized boundary. */
1838 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
1839 ASM_OUTPUT_LABEL (asm_out_file, l2);
1840 #ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
1841 ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL (asm_out_file, ld, l2, l1);
1843 fprintf (asm_out_file, "\t%s CIE Length Symbol", ASM_COMMENT_START);
1844 fputc ('\n', asm_out_file);
1847 /* Loop through all of the FDE's. */
1848 for (i = 0; i < fde_table_in_use; ++i)
1850 fde = &fde_table[i];
1852 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_AFTER_SIZE_LABEL, for_eh + i*2);
1853 ASM_GENERATE_INTERNAL_LABEL (l2, FDE_END_LABEL, for_eh + i*2);
1854 #ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
1855 ASM_GENERATE_INTERNAL_LABEL (ld, FDE_LENGTH_LABEL, for_eh + i*2);
1857 ASM_OUTPUT_DWARF_OFFSET4 (asm_out_file, ld);
1859 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, ld);
1862 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, l2, l1);
1864 ASM_OUTPUT_DWARF_DELTA (asm_out_file, l2, l1);
1867 fprintf (asm_out_file, "\t%s FDE Length", ASM_COMMENT_START);
1868 fputc ('\n', asm_out_file);
1869 ASM_OUTPUT_LABEL (asm_out_file, l1);
1871 /* ??? This always emits a 4 byte offset when for_eh is true, but it
1872 emits a target dependent sized offset when for_eh is not true.
1873 This inconsistency may confuse gdb. The only case where we need a
1874 non-4 byte offset is for the Irix6 N64 ABI, so we may lose SGI
1875 compatibility if we emit a 4 byte offset. We need a 4 byte offset
1876 though in order to be compatible with the dwarf_fde struct in frame.c.
1877 If the for_eh case is changed, then the struct in frame.c has
1878 to be adjusted appropriately. */
1880 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, l1, "__FRAME_BEGIN__");
1882 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, stripattributes (FRAME_SECTION));
1884 fprintf (asm_out_file, "\t%s FDE CIE offset", ASM_COMMENT_START);
1886 fputc ('\n', asm_out_file);
1887 ASM_OUTPUT_DWARF_ADDR (asm_out_file, fde->dw_fde_begin);
1889 fprintf (asm_out_file, "\t%s FDE initial location", ASM_COMMENT_START);
1891 fputc ('\n', asm_out_file);
1892 ASM_OUTPUT_DWARF_ADDR_DELTA (asm_out_file,
1893 fde->dw_fde_end, fde->dw_fde_begin);
1895 fprintf (asm_out_file, "\t%s FDE address range", ASM_COMMENT_START);
1897 fputc ('\n', asm_out_file);
1899 /* Loop through the Call Frame Instructions associated with
1901 fde->dw_fde_current_label = fde->dw_fde_begin;
1902 for (cfi = fde->dw_fde_cfi; cfi != NULL; cfi = cfi->dw_cfi_next)
1903 output_cfi (cfi, fde);
1905 /* Pad the FDE out to an address sized boundary. */
1906 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
1907 ASM_OUTPUT_LABEL (asm_out_file, l2);
1908 #ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
1909 ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL (asm_out_file, ld, l2, l1);
1911 fprintf (asm_out_file, "\t%s FDE Length Symbol", ASM_COMMENT_START);
1912 fputc ('\n', asm_out_file);
1915 #ifndef EH_FRAME_SECTION
1918 /* Emit terminating zero for table. */
1919 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0);
1920 fputc ('\n', asm_out_file);
1923 #ifdef MIPS_DEBUGGING_INFO
1924 /* Work around Irix 6 assembler bug whereby labels at the end of a section
1925 get a value of 0. Putting .align 0 after the label fixes it. */
1926 ASM_OUTPUT_ALIGN (asm_out_file, 0);
1929 /* Turn off app to make assembly quicker. */
1934 /* Output a marker (i.e. a label) for the beginning of a function, before
1938 dwarf2out_begin_prologue ()
1940 char label[MAX_ARTIFICIAL_LABEL_BYTES];
1941 register dw_fde_ref fde;
1943 ++current_funcdef_number;
1945 function_section (current_function_decl);
1946 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_BEGIN_LABEL,
1947 current_funcdef_number);
1948 ASM_OUTPUT_LABEL (asm_out_file, label);
1950 /* Expand the fde table if necessary. */
1951 if (fde_table_in_use == fde_table_allocated)
1953 fde_table_allocated += FDE_TABLE_INCREMENT;
1955 = (dw_fde_ref) xrealloc (fde_table,
1956 fde_table_allocated * sizeof (dw_fde_node));
1959 /* Record the FDE associated with this function. */
1960 current_funcdef_fde = fde_table_in_use;
1962 /* Add the new FDE at the end of the fde_table. */
1963 fde = &fde_table[fde_table_in_use++];
1964 fde->dw_fde_begin = xstrdup (label);
1965 fde->dw_fde_current_label = NULL;
1966 fde->dw_fde_end = NULL;
1967 fde->dw_fde_cfi = NULL;
1969 args_size = old_args_size = 0;
1972 /* Output a marker (i.e. a label) for the absolute end of the generated code
1973 for a function definition. This gets called *after* the epilogue code has
1977 dwarf2out_end_epilogue ()
1980 char label[MAX_ARTIFICIAL_LABEL_BYTES];
1982 /* Output a label to mark the endpoint of the code generated for this
1984 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL, current_funcdef_number);
1985 ASM_OUTPUT_LABEL (asm_out_file, label);
1986 fde = &fde_table[fde_table_in_use - 1];
1987 fde->dw_fde_end = xstrdup (label);
1991 dwarf2out_frame_init ()
1993 /* Allocate the initial hunk of the fde_table. */
1995 = (dw_fde_ref) xmalloc (FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
1996 bzero ((char *) fde_table, FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
1997 fde_table_allocated = FDE_TABLE_INCREMENT;
1998 fde_table_in_use = 0;
2000 /* Generate the CFA instructions common to all FDE's. Do it now for the
2001 sake of lookup_cfa. */
2003 #ifdef DWARF2_UNWIND_INFO
2004 /* On entry, the Canonical Frame Address is at SP. */
2005 dwarf2out_def_cfa (NULL, STACK_POINTER_REGNUM, INCOMING_FRAME_SP_OFFSET);
2006 initial_return_save (INCOMING_RETURN_ADDR_RTX);
2011 dwarf2out_frame_finish ()
2013 /* Output call frame information. */
2014 #ifdef MIPS_DEBUGGING_INFO
2015 if (write_symbols == DWARF2_DEBUG)
2016 output_call_frame_info (0);
2017 if (flag_exceptions && ! exceptions_via_longjmp)
2018 output_call_frame_info (1);
2020 if (write_symbols == DWARF2_DEBUG
2021 || (flag_exceptions && ! exceptions_via_longjmp))
2022 output_call_frame_info (1);
2026 #endif /* .debug_frame support */
2028 /* And now, the support for symbolic debugging information. */
2029 #ifdef DWARF2_DEBUGGING_INFO
2031 extern char *getpwd PROTO((void));
2033 /* NOTE: In the comments in this file, many references are made to
2034 "Debugging Information Entries". This term is abbreviated as `DIE'
2035 throughout the remainder of this file. */
2037 /* An internal representation of the DWARF output is built, and then
2038 walked to generate the DWARF debugging info. The walk of the internal
2039 representation is done after the entire program has been compiled.
2040 The types below are used to describe the internal representation. */
2042 /* Each DIE may have a series of attribute/value pairs. Values
2043 can take on several forms. The forms that are used in this
2044 implementation are listed below. */
2051 dw_val_class_unsigned_const,
2052 dw_val_class_long_long,
2055 dw_val_class_die_ref,
2056 dw_val_class_fde_ref,
2057 dw_val_class_lbl_id,
2058 dw_val_class_lbl_offset,
2063 /* Various DIE's use offsets relative to the beginning of the
2064 .debug_info section to refer to each other. */
2066 typedef long int dw_offset;
2068 /* Define typedefs here to avoid circular dependencies. */
2070 typedef struct die_struct *dw_die_ref;
2071 typedef struct dw_attr_struct *dw_attr_ref;
2072 typedef struct dw_val_struct *dw_val_ref;
2073 typedef struct dw_line_info_struct *dw_line_info_ref;
2074 typedef struct dw_separate_line_info_struct *dw_separate_line_info_ref;
2075 typedef struct dw_loc_descr_struct *dw_loc_descr_ref;
2076 typedef struct pubname_struct *pubname_ref;
2077 typedef dw_die_ref *arange_ref;
2079 /* Describe a double word constant value. */
2081 typedef struct dw_long_long_struct
2088 /* Describe a floating point constant value. */
2090 typedef struct dw_fp_struct
2097 /* Each entry in the line_info_table maintains the file and
2098 line number associated with the label generated for that
2099 entry. The label gives the PC value associated with
2100 the line number entry. */
2102 typedef struct dw_line_info_struct
2104 unsigned long dw_file_num;
2105 unsigned long dw_line_num;
2109 /* Line information for functions in separate sections; each one gets its
2111 typedef struct dw_separate_line_info_struct
2113 unsigned long dw_file_num;
2114 unsigned long dw_line_num;
2115 unsigned long function;
2117 dw_separate_line_info_entry;
2119 /* The dw_val_node describes an attribute's value, as it is
2120 represented internally. */
2122 typedef struct dw_val_struct
2124 dw_val_class val_class;
2128 dw_loc_descr_ref val_loc;
2130 long unsigned val_unsigned;
2131 dw_long_long_const val_long_long;
2132 dw_float_const val_float;
2133 dw_die_ref val_die_ref;
2134 unsigned val_fde_index;
2137 unsigned char val_flag;
2143 /* Locations in memory are described using a sequence of stack machine
2146 typedef struct dw_loc_descr_struct
2148 dw_loc_descr_ref dw_loc_next;
2149 enum dwarf_location_atom dw_loc_opc;
2150 dw_val_node dw_loc_oprnd1;
2151 dw_val_node dw_loc_oprnd2;
2155 /* Each DIE attribute has a field specifying the attribute kind,
2156 a link to the next attribute in the chain, and an attribute value.
2157 Attributes are typically linked below the DIE they modify. */
2159 typedef struct dw_attr_struct
2161 enum dwarf_attribute dw_attr;
2162 dw_attr_ref dw_attr_next;
2163 dw_val_node dw_attr_val;
2167 /* The Debugging Information Entry (DIE) structure */
2169 typedef struct die_struct
2171 enum dwarf_tag die_tag;
2172 dw_attr_ref die_attr;
2173 dw_attr_ref die_attr_last;
2174 dw_die_ref die_parent;
2175 dw_die_ref die_child;
2176 dw_die_ref die_child_last;
2178 dw_offset die_offset;
2179 unsigned long die_abbrev;
2183 /* The pubname structure */
2185 typedef struct pubname_struct
2192 /* The limbo die list structure. */
2193 typedef struct limbo_die_struct
2196 struct limbo_die_struct *next;
2200 /* How to start an assembler comment. */
2201 #ifndef ASM_COMMENT_START
2202 #define ASM_COMMENT_START ";#"
2205 /* Define a macro which returns non-zero for a TYPE_DECL which was
2206 implicitly generated for a tagged type.
2208 Note that unlike the gcc front end (which generates a NULL named
2209 TYPE_DECL node for each complete tagged type, each array type, and
2210 each function type node created) the g++ front end generates a
2211 _named_ TYPE_DECL node for each tagged type node created.
2212 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
2213 generate a DW_TAG_typedef DIE for them. */
2215 #define TYPE_DECL_IS_STUB(decl) \
2216 (DECL_NAME (decl) == NULL_TREE \
2217 || (DECL_ARTIFICIAL (decl) \
2218 && is_tagged_type (TREE_TYPE (decl)) \
2219 && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \
2220 /* This is necessary for stub decls that \
2221 appear in nested inline functions. */ \
2222 || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
2223 && (decl_ultimate_origin (decl) \
2224 == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
2226 /* Information concerning the compilation unit's programming
2227 language, and compiler version. */
2229 extern int flag_traditional;
2230 extern char *version_string;
2231 extern char *language_string;
2233 /* Fixed size portion of the DWARF compilation unit header. */
2234 #define DWARF_COMPILE_UNIT_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 3)
2236 /* Fixed size portion of debugging line information prolog. */
2237 #define DWARF_LINE_PROLOG_HEADER_SIZE 5
2239 /* Fixed size portion of public names info. */
2240 #define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
2242 /* Fixed size portion of the address range info. */
2243 #define DWARF_ARANGES_HEADER_SIZE \
2244 (DWARF_ROUND (2 * DWARF_OFFSET_SIZE + 4, PTR_SIZE * 2) - DWARF_OFFSET_SIZE)
2246 /* Define the architecture-dependent minimum instruction length (in bytes).
2247 In this implementation of DWARF, this field is used for information
2248 purposes only. Since GCC generates assembly language, we have
2249 no a priori knowledge of how many instruction bytes are generated
2250 for each source line, and therefore can use only the DW_LNE_set_address
2251 and DW_LNS_fixed_advance_pc line information commands. */
2253 #ifndef DWARF_LINE_MIN_INSTR_LENGTH
2254 #define DWARF_LINE_MIN_INSTR_LENGTH 4
2257 /* Minimum line offset in a special line info. opcode.
2258 This value was chosen to give a reasonable range of values. */
2259 #define DWARF_LINE_BASE -10
2261 /* First special line opcde - leave room for the standard opcodes. */
2262 #define DWARF_LINE_OPCODE_BASE 10
2264 /* Range of line offsets in a special line info. opcode. */
2265 #define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1)
2267 /* Flag that indicates the initial value of the is_stmt_start flag.
2268 In the present implementation, we do not mark any lines as
2269 the beginning of a source statement, because that information
2270 is not made available by the GCC front-end. */
2271 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
2273 /* This location is used by calc_die_sizes() to keep track
2274 the offset of each DIE within the .debug_info section. */
2275 static unsigned long next_die_offset;
2277 /* Record the root of the DIE's built for the current compilation unit. */
2278 static dw_die_ref comp_unit_die;
2280 /* A list of DIEs with a NULL parent waiting to be relocated. */
2281 static limbo_die_node *limbo_die_list = 0;
2283 /* Pointer to an array of filenames referenced by this compilation unit. */
2284 static char **file_table;
2286 /* Total number of entries in the table (i.e. array) pointed to by
2287 `file_table'. This is the *total* and includes both used and unused
2289 static unsigned file_table_allocated;
2291 /* Number of entries in the file_table which are actually in use. */
2292 static unsigned file_table_in_use;
2294 /* Size (in elements) of increments by which we may expand the filename
2296 #define FILE_TABLE_INCREMENT 64
2298 /* Local pointer to the name of the main input file. Initialized in
2300 static char *primary_filename;
2302 /* For Dwarf output, we must assign lexical-blocks id numbers in the order in
2303 which their beginnings are encountered. We output Dwarf debugging info
2304 that refers to the beginnings and ends of the ranges of code for each
2305 lexical block. The labels themselves are generated in final.c, which
2306 assigns numbers to the blocks in the same way. */
2307 static unsigned next_block_number = 2;
2309 /* A pointer to the base of a table of references to DIE's that describe
2310 declarations. The table is indexed by DECL_UID() which is a unique
2311 number identifying each decl. */
2312 static dw_die_ref *decl_die_table;
2314 /* Number of elements currently allocated for the decl_die_table. */
2315 static unsigned decl_die_table_allocated;
2317 /* Number of elements in decl_die_table currently in use. */
2318 static unsigned decl_die_table_in_use;
2320 /* Size (in elements) of increments by which we may expand the
2322 #define DECL_DIE_TABLE_INCREMENT 256
2324 /* Structure used for the decl_scope table. scope is the current declaration
2325 scope, and previous is the entry that is the parent of this scope. This
2326 is usually but not always the immediately preceeding entry. */
2328 typedef struct decl_scope_struct
2335 /* A pointer to the base of a table of references to declaration
2336 scopes. This table is a display which tracks the nesting
2337 of declaration scopes at the current scope and containing
2338 scopes. This table is used to find the proper place to
2339 define type declaration DIE's. */
2340 static decl_scope_node *decl_scope_table;
2342 /* Number of elements currently allocated for the decl_scope_table. */
2343 static int decl_scope_table_allocated;
2345 /* Current level of nesting of declaration scopes. */
2346 static int decl_scope_depth;
2348 /* Size (in elements) of increments by which we may expand the
2349 decl_scope_table. */
2350 #define DECL_SCOPE_TABLE_INCREMENT 64
2352 /* A pointer to the base of a list of references to DIE's that
2353 are uniquely identified by their tag, presence/absence of
2354 children DIE's, and list of attribute/value pairs. */
2355 static dw_die_ref *abbrev_die_table;
2357 /* Number of elements currently allocated for abbrev_die_table. */
2358 static unsigned abbrev_die_table_allocated;
2360 /* Number of elements in type_die_table currently in use. */
2361 static unsigned abbrev_die_table_in_use;
2363 /* Size (in elements) of increments by which we may expand the
2364 abbrev_die_table. */
2365 #define ABBREV_DIE_TABLE_INCREMENT 256
2367 /* A pointer to the base of a table that contains line information
2368 for each source code line in .text in the compilation unit. */
2369 static dw_line_info_ref line_info_table;
2371 /* Number of elements currently allocated for line_info_table. */
2372 static unsigned line_info_table_allocated;
2374 /* Number of elements in separate_line_info_table currently in use. */
2375 static unsigned separate_line_info_table_in_use;
2377 /* A pointer to the base of a table that contains line information
2378 for each source code line outside of .text in the compilation unit. */
2379 static dw_separate_line_info_ref separate_line_info_table;
2381 /* Number of elements currently allocated for separate_line_info_table. */
2382 static unsigned separate_line_info_table_allocated;
2384 /* Number of elements in line_info_table currently in use. */
2385 static unsigned line_info_table_in_use;
2387 /* Size (in elements) of increments by which we may expand the
2389 #define LINE_INFO_TABLE_INCREMENT 1024
2391 /* A pointer to the base of a table that contains a list of publicly
2392 accessible names. */
2393 static pubname_ref pubname_table;
2395 /* Number of elements currently allocated for pubname_table. */
2396 static unsigned pubname_table_allocated;
2398 /* Number of elements in pubname_table currently in use. */
2399 static unsigned pubname_table_in_use;
2401 /* Size (in elements) of increments by which we may expand the
2403 #define PUBNAME_TABLE_INCREMENT 64
2405 /* A pointer to the base of a table that contains a list of publicly
2406 accessible names. */
2407 static arange_ref arange_table;
2409 /* Number of elements currently allocated for arange_table. */
2410 static unsigned arange_table_allocated;
2412 /* Number of elements in arange_table currently in use. */
2413 static unsigned arange_table_in_use;
2415 /* Size (in elements) of increments by which we may expand the
2417 #define ARANGE_TABLE_INCREMENT 64
2419 /* A pointer to the base of a list of pending types which we haven't
2420 generated DIEs for yet, but which we will have to come back to
2423 static tree *pending_types_list;
2425 /* Number of elements currently allocated for the pending_types_list. */
2426 static unsigned pending_types_allocated;
2428 /* Number of elements of pending_types_list currently in use. */
2429 static unsigned pending_types;
2431 /* Size (in elements) of increments by which we may expand the pending
2432 types list. Actually, a single hunk of space of this size should
2433 be enough for most typical programs. */
2434 #define PENDING_TYPES_INCREMENT 64
2436 /* A pointer to the base of a list of incomplete types which might be
2437 completed at some later time. */
2439 static tree *incomplete_types_list;
2441 /* Number of elements currently allocated for the incomplete_types_list. */
2442 static unsigned incomplete_types_allocated;
2444 /* Number of elements of incomplete_types_list currently in use. */
2445 static unsigned incomplete_types;
2447 /* Size (in elements) of increments by which we may expand the incomplete
2448 types list. Actually, a single hunk of space of this size should
2449 be enough for most typical programs. */
2450 #define INCOMPLETE_TYPES_INCREMENT 64
2452 /* Record whether the function being analyzed contains inlined functions. */
2453 static int current_function_has_inlines;
2454 #if 0 && defined (MIPS_DEBUGGING_INFO)
2455 static int comp_unit_has_inlines;
2458 /* A pointer to the ..._DECL node which we have most recently been working
2459 on. We keep this around just in case something about it looks screwy and
2460 we want to tell the user what the source coordinates for the actual
2462 static tree dwarf_last_decl;
2464 /* Forward declarations for functions defined in this file. */
2466 static void addr_const_to_string PROTO((dyn_string_t, rtx));
2467 static char *addr_to_string PROTO((rtx));
2468 static int is_pseudo_reg PROTO((rtx));
2469 static tree type_main_variant PROTO((tree));
2470 static int is_tagged_type PROTO((tree));
2471 static char *dwarf_tag_name PROTO((unsigned));
2472 static char *dwarf_attr_name PROTO((unsigned));
2473 static char *dwarf_form_name PROTO((unsigned));
2474 static char *dwarf_stack_op_name PROTO((unsigned));
2476 static char *dwarf_type_encoding_name PROTO((unsigned));
2478 static tree decl_ultimate_origin PROTO((tree));
2479 static tree block_ultimate_origin PROTO((tree));
2480 static tree decl_class_context PROTO((tree));
2481 static void add_dwarf_attr PROTO((dw_die_ref, dw_attr_ref));
2482 static void add_AT_flag PROTO((dw_die_ref,
2483 enum dwarf_attribute,
2485 static void add_AT_int PROTO((dw_die_ref,
2486 enum dwarf_attribute, long));
2487 static void add_AT_unsigned PROTO((dw_die_ref,
2488 enum dwarf_attribute,
2490 static void add_AT_long_long PROTO((dw_die_ref,
2491 enum dwarf_attribute,
2492 unsigned long, unsigned long));
2493 static void add_AT_float PROTO((dw_die_ref,
2494 enum dwarf_attribute,
2496 static void add_AT_string PROTO((dw_die_ref,
2497 enum dwarf_attribute, char *));
2498 static void add_AT_die_ref PROTO((dw_die_ref,
2499 enum dwarf_attribute,
2501 static void add_AT_fde_ref PROTO((dw_die_ref,
2502 enum dwarf_attribute,
2504 static void add_AT_loc PROTO((dw_die_ref,
2505 enum dwarf_attribute,
2507 static void add_AT_addr PROTO((dw_die_ref,
2508 enum dwarf_attribute, char *));
2509 static void add_AT_lbl_id PROTO((dw_die_ref,
2510 enum dwarf_attribute, char *));
2511 static void add_AT_lbl_offset PROTO((dw_die_ref,
2512 enum dwarf_attribute, char *));
2513 static int is_extern_subr_die PROTO((dw_die_ref));
2514 static dw_attr_ref get_AT PROTO((dw_die_ref,
2515 enum dwarf_attribute));
2516 static char *get_AT_low_pc PROTO((dw_die_ref));
2517 static char *get_AT_hi_pc PROTO((dw_die_ref));
2518 static char *get_AT_string PROTO((dw_die_ref,
2519 enum dwarf_attribute));
2520 static int get_AT_flag PROTO((dw_die_ref,
2521 enum dwarf_attribute));
2522 static unsigned get_AT_unsigned PROTO((dw_die_ref,
2523 enum dwarf_attribute));
2524 static int is_c_family PROTO((void));
2525 static int is_fortran PROTO((void));
2526 static void remove_AT PROTO((dw_die_ref,
2527 enum dwarf_attribute));
2528 static void remove_children PROTO((dw_die_ref));
2529 static void add_child_die PROTO((dw_die_ref, dw_die_ref));
2530 static dw_die_ref new_die PROTO((enum dwarf_tag, dw_die_ref));
2531 static dw_die_ref lookup_type_die PROTO((tree));
2532 static void equate_type_number_to_die PROTO((tree, dw_die_ref));
2533 static dw_die_ref lookup_decl_die PROTO((tree));
2534 static void equate_decl_number_to_die PROTO((tree, dw_die_ref));
2535 static dw_loc_descr_ref new_loc_descr PROTO((enum dwarf_location_atom,
2536 unsigned long, unsigned long));
2537 static void add_loc_descr PROTO((dw_loc_descr_ref *,
2539 static void print_spaces PROTO((FILE *));
2540 static void print_die PROTO((dw_die_ref, FILE *));
2541 static void print_dwarf_line_table PROTO((FILE *));
2542 static void add_sibling_attributes PROTO((dw_die_ref));
2543 static void build_abbrev_table PROTO((dw_die_ref));
2544 static unsigned long size_of_string PROTO((char *));
2545 static unsigned long size_of_loc_descr PROTO((dw_loc_descr_ref));
2546 static unsigned long size_of_locs PROTO((dw_loc_descr_ref));
2547 static int constant_size PROTO((long unsigned));
2548 static unsigned long size_of_die PROTO((dw_die_ref));
2549 static void calc_die_sizes PROTO((dw_die_ref));
2550 static unsigned long size_of_line_prolog PROTO((void));
2551 static unsigned long size_of_line_info PROTO((void));
2552 static unsigned long size_of_pubnames PROTO((void));
2553 static unsigned long size_of_aranges PROTO((void));
2554 static enum dwarf_form value_format PROTO((dw_val_ref));
2555 static void output_value_format PROTO((dw_val_ref));
2556 static void output_abbrev_section PROTO((void));
2557 static void output_loc_operands PROTO((dw_loc_descr_ref));
2558 static unsigned long sibling_offset PROTO((dw_die_ref));
2559 static void output_die PROTO((dw_die_ref));
2560 static void output_compilation_unit_header PROTO((void));
2561 static char *dwarf2_name PROTO((tree, int));
2562 static void add_pubname PROTO((tree, dw_die_ref));
2563 static void output_pubnames PROTO((void));
2564 static void add_arange PROTO((tree, dw_die_ref));
2565 static void output_aranges PROTO((void));
2566 static void output_line_info PROTO((void));
2567 static int is_body_block PROTO((tree));
2568 static dw_die_ref base_type_die PROTO((tree));
2569 static tree root_type PROTO((tree));
2570 static int is_base_type PROTO((tree));
2571 static dw_die_ref modified_type_die PROTO((tree, int, int, dw_die_ref));
2572 static int type_is_enum PROTO((tree));
2573 static dw_loc_descr_ref reg_loc_descriptor PROTO((rtx));
2574 static dw_loc_descr_ref based_loc_descr PROTO((unsigned, long));
2575 static int is_based_loc PROTO((rtx));
2576 static dw_loc_descr_ref mem_loc_descriptor PROTO((rtx));
2577 static dw_loc_descr_ref concat_loc_descriptor PROTO((rtx, rtx));
2578 static dw_loc_descr_ref loc_descriptor PROTO((rtx));
2579 static unsigned ceiling PROTO((unsigned, unsigned));
2580 static tree field_type PROTO((tree));
2581 static unsigned simple_type_align_in_bits PROTO((tree));
2582 static unsigned simple_type_size_in_bits PROTO((tree));
2583 static unsigned field_byte_offset PROTO((tree));
2584 static void add_AT_location_description PROTO((dw_die_ref,
2585 enum dwarf_attribute, rtx));
2586 static void add_data_member_location_attribute PROTO((dw_die_ref, tree));
2587 static void add_const_value_attribute PROTO((dw_die_ref, rtx));
2588 static void add_location_or_const_value_attribute PROTO((dw_die_ref, tree));
2589 static void add_name_attribute PROTO((dw_die_ref, char *));
2590 static void add_bound_info PROTO((dw_die_ref,
2591 enum dwarf_attribute, tree));
2592 static void add_subscript_info PROTO((dw_die_ref, tree));
2593 static void add_byte_size_attribute PROTO((dw_die_ref, tree));
2594 static void add_bit_offset_attribute PROTO((dw_die_ref, tree));
2595 static void add_bit_size_attribute PROTO((dw_die_ref, tree));
2596 static void add_prototyped_attribute PROTO((dw_die_ref, tree));
2597 static void add_abstract_origin_attribute PROTO((dw_die_ref, tree));
2598 static void add_pure_or_virtual_attribute PROTO((dw_die_ref, tree));
2599 static void add_src_coords_attributes PROTO((dw_die_ref, tree));
2600 static void add_name_and_src_coords_attributes PROTO((dw_die_ref, tree));
2601 static void push_decl_scope PROTO((tree));
2602 static dw_die_ref scope_die_for PROTO((tree, dw_die_ref));
2603 static void pop_decl_scope PROTO((void));
2604 static void add_type_attribute PROTO((dw_die_ref, tree, int, int,
2606 static char *type_tag PROTO((tree));
2607 static tree member_declared_type PROTO((tree));
2609 static char *decl_start_label PROTO((tree));
2611 static void gen_array_type_die PROTO((tree, dw_die_ref));
2612 static void gen_set_type_die PROTO((tree, dw_die_ref));
2614 static void gen_entry_point_die PROTO((tree, dw_die_ref));
2616 static void pend_type PROTO((tree));
2617 static void output_pending_types_for_scope PROTO((dw_die_ref));
2618 static void gen_inlined_enumeration_type_die PROTO((tree, dw_die_ref));
2619 static void gen_inlined_structure_type_die PROTO((tree, dw_die_ref));
2620 static void gen_inlined_union_type_die PROTO((tree, dw_die_ref));
2621 static void gen_enumeration_type_die PROTO((tree, dw_die_ref));
2622 static dw_die_ref gen_formal_parameter_die PROTO((tree, dw_die_ref));
2623 static void gen_unspecified_parameters_die PROTO((tree, dw_die_ref));
2624 static void gen_formal_types_die PROTO((tree, dw_die_ref));
2625 static void gen_subprogram_die PROTO((tree, dw_die_ref));
2626 static void gen_variable_die PROTO((tree, dw_die_ref));
2627 static void gen_label_die PROTO((tree, dw_die_ref));
2628 static void gen_lexical_block_die PROTO((tree, dw_die_ref, int));
2629 static void gen_inlined_subroutine_die PROTO((tree, dw_die_ref, int));
2630 static void gen_field_die PROTO((tree, dw_die_ref));
2631 static void gen_ptr_to_mbr_type_die PROTO((tree, dw_die_ref));
2632 static void gen_compile_unit_die PROTO((char *));
2633 static void gen_string_type_die PROTO((tree, dw_die_ref));
2634 static void gen_inheritance_die PROTO((tree, dw_die_ref));
2635 static void gen_member_die PROTO((tree, dw_die_ref));
2636 static void gen_struct_or_union_type_die PROTO((tree, dw_die_ref));
2637 static void gen_subroutine_type_die PROTO((tree, dw_die_ref));
2638 static void gen_typedef_die PROTO((tree, dw_die_ref));
2639 static void gen_type_die PROTO((tree, dw_die_ref));
2640 static void gen_tagged_type_instantiation_die PROTO((tree, dw_die_ref));
2641 static void gen_block_die PROTO((tree, dw_die_ref, int));
2642 static void decls_for_scope PROTO((tree, dw_die_ref, int));
2643 static int is_redundant_typedef PROTO((tree));
2644 static void gen_decl_die PROTO((tree, dw_die_ref));
2645 static unsigned lookup_filename PROTO((char *));
2647 /* Section names used to hold DWARF debugging information. */
2648 #ifndef DEBUG_INFO_SECTION
2649 #define DEBUG_INFO_SECTION ".debug_info"
2651 #ifndef ABBREV_SECTION
2652 #define ABBREV_SECTION ".debug_abbrev"
2654 #ifndef ARANGES_SECTION
2655 #define ARANGES_SECTION ".debug_aranges"
2657 #ifndef DW_MACINFO_SECTION
2658 #define DW_MACINFO_SECTION ".debug_macinfo"
2660 #ifndef DEBUG_LINE_SECTION
2661 #define DEBUG_LINE_SECTION ".debug_line"
2664 #define LOC_SECTION ".debug_loc"
2666 #ifndef PUBNAMES_SECTION
2667 #define PUBNAMES_SECTION ".debug_pubnames"
2670 #define STR_SECTION ".debug_str"
2673 /* Standard ELF section names for compiled code and data. */
2674 #ifndef TEXT_SECTION
2675 #define TEXT_SECTION ".text"
2677 #ifndef DATA_SECTION
2678 #define DATA_SECTION ".data"
2681 #define BSS_SECTION ".bss"
2684 /* Labels we insert at beginning sections we can reference instead of
2685 the section names themselves. */
2687 #ifndef TEXT_SECTION_LABEL
2688 #define TEXT_SECTION_LABEL "Ltext"
2690 #ifndef DEBUG_LINE_SECTION_LABEL
2691 #define DEBUG_LINE_SECTION_LABEL "Ldebug_line"
2693 #ifndef DEBUG_INFO_SECTION_LABEL
2694 #define DEBUG_INFO_SECTION_LABEL "Ldebug_info"
2696 #ifndef ABBREV_SECTION_LABEL
2697 #define ABBREV_SECTION_LABEL "Ldebug_abbrev"
2701 /* Definitions of defaults for formats and names of various special
2702 (artificial) labels which may be generated within this file (when the -g
2703 options is used and DWARF_DEBUGGING_INFO is in effect.
2704 If necessary, these may be overridden from within the tm.h file, but
2705 typically, overriding these defaults is unnecessary. */
2707 static char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
2708 static char text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
2709 static char abbrev_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
2710 static char debug_info_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
2711 static char debug_line_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
2713 #ifndef TEXT_END_LABEL
2714 #define TEXT_END_LABEL "Letext"
2716 #ifndef DATA_END_LABEL
2717 #define DATA_END_LABEL "Ledata"
2719 #ifndef BSS_END_LABEL
2720 #define BSS_END_LABEL "Lebss"
2722 #ifndef INSN_LABEL_FMT
2723 #define INSN_LABEL_FMT "LI%u_"
2725 #ifndef BLOCK_BEGIN_LABEL
2726 #define BLOCK_BEGIN_LABEL "LBB"
2728 #ifndef BLOCK_END_LABEL
2729 #define BLOCK_END_LABEL "LBE"
2731 #ifndef BODY_BEGIN_LABEL
2732 #define BODY_BEGIN_LABEL "Lbb"
2734 #ifndef BODY_END_LABEL
2735 #define BODY_END_LABEL "Lbe"
2737 #ifndef LINE_CODE_LABEL
2738 #define LINE_CODE_LABEL "LM"
2740 #ifndef SEPARATE_LINE_CODE_LABEL
2741 #define SEPARATE_LINE_CODE_LABEL "LSM"
2744 /* Convert a reference to the assembler name of a C-level name. This
2745 macro has the same effect as ASM_OUTPUT_LABELREF, but copies to
2746 a string rather than writing to a file. */
2747 #ifndef ASM_NAME_TO_STRING
2748 #define ASM_NAME_TO_STRING(STR, NAME) \
2750 if ((NAME)[0] == '*') \
2751 dyn_string_append (STR, NAME + 1); \
2755 STRIP_NAME_ENCODING (newstr, NAME); \
2756 dyn_string_append (STR, user_label_prefix); \
2757 dyn_string_append (STR, newstr); \
2763 /* Convert an integer constant expression into assembler syntax. Addition
2764 and subtraction are the only arithmetic that may appear in these
2765 expressions. This is an adaptation of output_addr_const in final.c.
2766 Here, the target of the conversion is a string buffer. We can't use
2767 output_addr_const directly, because it writes to a file. */
2770 addr_const_to_string (str, x)
2777 switch (GET_CODE (x))
2781 dyn_string_append (str, ",");
2787 ASM_NAME_TO_STRING (str, XSTR (x, 0));
2791 ASM_GENERATE_INTERNAL_LABEL (buf1, "L", CODE_LABEL_NUMBER (XEXP (x, 0)));
2792 ASM_NAME_TO_STRING (str, buf1);
2796 ASM_GENERATE_INTERNAL_LABEL (buf1, "L", CODE_LABEL_NUMBER (x));
2797 ASM_NAME_TO_STRING (str, buf1);
2801 sprintf (buf1, HOST_WIDE_INT_PRINT_DEC, INTVAL (x));
2802 dyn_string_append (str, buf1);
2806 /* This used to output parentheses around the expression, but that does
2807 not work on the 386 (either ATT or BSD assembler). */
2808 addr_const_to_string (str, XEXP (x, 0));
2812 if (GET_MODE (x) == VOIDmode)
2814 /* We can use %d if the number is one word and positive. */
2815 if (CONST_DOUBLE_HIGH (x))
2816 sprintf (buf1, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
2817 CONST_DOUBLE_HIGH (x), CONST_DOUBLE_LOW (x));
2818 else if (CONST_DOUBLE_LOW (x) < 0)
2819 sprintf (buf1, HOST_WIDE_INT_PRINT_HEX, CONST_DOUBLE_LOW (x));
2821 sprintf (buf1, HOST_WIDE_INT_PRINT_DEC,
2822 CONST_DOUBLE_LOW (x));
2823 dyn_string_append (str, buf1);
2826 /* We can't handle floating point constants; PRINT_OPERAND must
2828 output_operand_lossage ("floating constant misused");
2832 /* Some assemblers need integer constants to appear last (eg masm). */
2833 if (GET_CODE (XEXP (x, 0)) == CONST_INT)
2835 addr_const_to_string (str, XEXP (x, 1));
2836 if (INTVAL (XEXP (x, 0)) >= 0)
2837 dyn_string_append (str, "+");
2839 addr_const_to_string (str, XEXP (x, 0));
2843 addr_const_to_string (str, XEXP (x, 0));
2844 if (INTVAL (XEXP (x, 1)) >= 0)
2845 dyn_string_append (str, "+");
2847 addr_const_to_string (str, XEXP (x, 1));
2852 /* Avoid outputting things like x-x or x+5-x, since some assemblers
2853 can't handle that. */
2854 x = simplify_subtraction (x);
2855 if (GET_CODE (x) != MINUS)
2858 addr_const_to_string (str, XEXP (x, 0));
2859 dyn_string_append (str, "-");
2860 if (GET_CODE (XEXP (x, 1)) == CONST_INT
2861 && INTVAL (XEXP (x, 1)) < 0)
2863 dyn_string_append (str, ASM_OPEN_PAREN);
2864 addr_const_to_string (str, XEXP (x, 1));
2865 dyn_string_append (str, ASM_CLOSE_PAREN);
2868 addr_const_to_string (str, XEXP (x, 1));
2873 addr_const_to_string (str, XEXP (x, 0));
2877 output_operand_lossage ("invalid expression as operand");
2881 /* Convert an address constant to a string, and return a pointer to
2882 a copy of the result, located on the heap. */
2888 dyn_string_t ds = dyn_string_new (256);
2891 addr_const_to_string (ds, x);
2893 /* Return the dynamically allocated string, but free the
2894 dyn_string_t itself. */
2900 /* Test if rtl node points to a pseudo register. */
2906 return (((GET_CODE (rtl) == REG) && (REGNO (rtl) >= FIRST_PSEUDO_REGISTER))
2907 || ((GET_CODE (rtl) == SUBREG)
2908 && (REGNO (XEXP (rtl, 0)) >= FIRST_PSEUDO_REGISTER)));
2911 /* Return a reference to a type, with its const and volatile qualifiers
2915 type_main_variant (type)
2918 type = TYPE_MAIN_VARIANT (type);
2920 /* There really should be only one main variant among any group of variants
2921 of a given type (and all of the MAIN_VARIANT values for all members of
2922 the group should point to that one type) but sometimes the C front-end
2923 messes this up for array types, so we work around that bug here. */
2925 if (TREE_CODE (type) == ARRAY_TYPE)
2926 while (type != TYPE_MAIN_VARIANT (type))
2927 type = TYPE_MAIN_VARIANT (type);
2932 /* Return non-zero if the given type node represents a tagged type. */
2935 is_tagged_type (type)
2938 register enum tree_code code = TREE_CODE (type);
2940 return (code == RECORD_TYPE || code == UNION_TYPE
2941 || code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE);
2944 /* Convert a DIE tag into its string name. */
2947 dwarf_tag_name (tag)
2948 register unsigned tag;
2952 case DW_TAG_padding:
2953 return "DW_TAG_padding";
2954 case DW_TAG_array_type:
2955 return "DW_TAG_array_type";
2956 case DW_TAG_class_type:
2957 return "DW_TAG_class_type";
2958 case DW_TAG_entry_point:
2959 return "DW_TAG_entry_point";
2960 case DW_TAG_enumeration_type:
2961 return "DW_TAG_enumeration_type";
2962 case DW_TAG_formal_parameter:
2963 return "DW_TAG_formal_parameter";
2964 case DW_TAG_imported_declaration:
2965 return "DW_TAG_imported_declaration";
2967 return "DW_TAG_label";
2968 case DW_TAG_lexical_block:
2969 return "DW_TAG_lexical_block";
2971 return "DW_TAG_member";
2972 case DW_TAG_pointer_type:
2973 return "DW_TAG_pointer_type";
2974 case DW_TAG_reference_type:
2975 return "DW_TAG_reference_type";
2976 case DW_TAG_compile_unit:
2977 return "DW_TAG_compile_unit";
2978 case DW_TAG_string_type:
2979 return "DW_TAG_string_type";
2980 case DW_TAG_structure_type:
2981 return "DW_TAG_structure_type";
2982 case DW_TAG_subroutine_type:
2983 return "DW_TAG_subroutine_type";
2984 case DW_TAG_typedef:
2985 return "DW_TAG_typedef";
2986 case DW_TAG_union_type:
2987 return "DW_TAG_union_type";
2988 case DW_TAG_unspecified_parameters:
2989 return "DW_TAG_unspecified_parameters";
2990 case DW_TAG_variant:
2991 return "DW_TAG_variant";
2992 case DW_TAG_common_block:
2993 return "DW_TAG_common_block";
2994 case DW_TAG_common_inclusion:
2995 return "DW_TAG_common_inclusion";
2996 case DW_TAG_inheritance:
2997 return "DW_TAG_inheritance";
2998 case DW_TAG_inlined_subroutine:
2999 return "DW_TAG_inlined_subroutine";
3001 return "DW_TAG_module";
3002 case DW_TAG_ptr_to_member_type:
3003 return "DW_TAG_ptr_to_member_type";
3004 case DW_TAG_set_type:
3005 return "DW_TAG_set_type";
3006 case DW_TAG_subrange_type:
3007 return "DW_TAG_subrange_type";
3008 case DW_TAG_with_stmt:
3009 return "DW_TAG_with_stmt";
3010 case DW_TAG_access_declaration:
3011 return "DW_TAG_access_declaration";
3012 case DW_TAG_base_type:
3013 return "DW_TAG_base_type";
3014 case DW_TAG_catch_block:
3015 return "DW_TAG_catch_block";
3016 case DW_TAG_const_type:
3017 return "DW_TAG_const_type";
3018 case DW_TAG_constant:
3019 return "DW_TAG_constant";
3020 case DW_TAG_enumerator:
3021 return "DW_TAG_enumerator";
3022 case DW_TAG_file_type:
3023 return "DW_TAG_file_type";
3025 return "DW_TAG_friend";
3026 case DW_TAG_namelist:
3027 return "DW_TAG_namelist";
3028 case DW_TAG_namelist_item:
3029 return "DW_TAG_namelist_item";
3030 case DW_TAG_packed_type:
3031 return "DW_TAG_packed_type";
3032 case DW_TAG_subprogram:
3033 return "DW_TAG_subprogram";
3034 case DW_TAG_template_type_param:
3035 return "DW_TAG_template_type_param";
3036 case DW_TAG_template_value_param:
3037 return "DW_TAG_template_value_param";
3038 case DW_TAG_thrown_type:
3039 return "DW_TAG_thrown_type";
3040 case DW_TAG_try_block:
3041 return "DW_TAG_try_block";
3042 case DW_TAG_variant_part:
3043 return "DW_TAG_variant_part";
3044 case DW_TAG_variable:
3045 return "DW_TAG_variable";
3046 case DW_TAG_volatile_type:
3047 return "DW_TAG_volatile_type";
3048 case DW_TAG_MIPS_loop:
3049 return "DW_TAG_MIPS_loop";
3050 case DW_TAG_format_label:
3051 return "DW_TAG_format_label";
3052 case DW_TAG_function_template:
3053 return "DW_TAG_function_template";
3054 case DW_TAG_class_template:
3055 return "DW_TAG_class_template";
3057 return "DW_TAG_<unknown>";
3061 /* Convert a DWARF attribute code into its string name. */
3064 dwarf_attr_name (attr)
3065 register unsigned attr;
3070 return "DW_AT_sibling";
3071 case DW_AT_location:
3072 return "DW_AT_location";
3074 return "DW_AT_name";
3075 case DW_AT_ordering:
3076 return "DW_AT_ordering";
3077 case DW_AT_subscr_data:
3078 return "DW_AT_subscr_data";
3079 case DW_AT_byte_size:
3080 return "DW_AT_byte_size";
3081 case DW_AT_bit_offset:
3082 return "DW_AT_bit_offset";
3083 case DW_AT_bit_size:
3084 return "DW_AT_bit_size";
3085 case DW_AT_element_list:
3086 return "DW_AT_element_list";
3087 case DW_AT_stmt_list:
3088 return "DW_AT_stmt_list";
3090 return "DW_AT_low_pc";
3092 return "DW_AT_high_pc";
3093 case DW_AT_language:
3094 return "DW_AT_language";
3096 return "DW_AT_member";
3098 return "DW_AT_discr";
3099 case DW_AT_discr_value:
3100 return "DW_AT_discr_value";
3101 case DW_AT_visibility:
3102 return "DW_AT_visibility";
3104 return "DW_AT_import";
3105 case DW_AT_string_length:
3106 return "DW_AT_string_length";
3107 case DW_AT_common_reference:
3108 return "DW_AT_common_reference";
3109 case DW_AT_comp_dir:
3110 return "DW_AT_comp_dir";
3111 case DW_AT_const_value:
3112 return "DW_AT_const_value";
3113 case DW_AT_containing_type:
3114 return "DW_AT_containing_type";
3115 case DW_AT_default_value:
3116 return "DW_AT_default_value";
3118 return "DW_AT_inline";
3119 case DW_AT_is_optional:
3120 return "DW_AT_is_optional";
3121 case DW_AT_lower_bound:
3122 return "DW_AT_lower_bound";
3123 case DW_AT_producer:
3124 return "DW_AT_producer";
3125 case DW_AT_prototyped:
3126 return "DW_AT_prototyped";
3127 case DW_AT_return_addr:
3128 return "DW_AT_return_addr";
3129 case DW_AT_start_scope:
3130 return "DW_AT_start_scope";
3131 case DW_AT_stride_size:
3132 return "DW_AT_stride_size";
3133 case DW_AT_upper_bound:
3134 return "DW_AT_upper_bound";
3135 case DW_AT_abstract_origin:
3136 return "DW_AT_abstract_origin";
3137 case DW_AT_accessibility:
3138 return "DW_AT_accessibility";
3139 case DW_AT_address_class:
3140 return "DW_AT_address_class";
3141 case DW_AT_artificial:
3142 return "DW_AT_artificial";
3143 case DW_AT_base_types:
3144 return "DW_AT_base_types";
3145 case DW_AT_calling_convention:
3146 return "DW_AT_calling_convention";
3148 return "DW_AT_count";
3149 case DW_AT_data_member_location:
3150 return "DW_AT_data_member_location";
3151 case DW_AT_decl_column:
3152 return "DW_AT_decl_column";
3153 case DW_AT_decl_file:
3154 return "DW_AT_decl_file";
3155 case DW_AT_decl_line:
3156 return "DW_AT_decl_line";
3157 case DW_AT_declaration:
3158 return "DW_AT_declaration";
3159 case DW_AT_discr_list:
3160 return "DW_AT_discr_list";
3161 case DW_AT_encoding:
3162 return "DW_AT_encoding";
3163 case DW_AT_external:
3164 return "DW_AT_external";
3165 case DW_AT_frame_base:
3166 return "DW_AT_frame_base";
3168 return "DW_AT_friend";
3169 case DW_AT_identifier_case:
3170 return "DW_AT_identifier_case";
3171 case DW_AT_macro_info:
3172 return "DW_AT_macro_info";
3173 case DW_AT_namelist_items:
3174 return "DW_AT_namelist_items";
3175 case DW_AT_priority:
3176 return "DW_AT_priority";
3178 return "DW_AT_segment";
3179 case DW_AT_specification:
3180 return "DW_AT_specification";
3181 case DW_AT_static_link:
3182 return "DW_AT_static_link";
3184 return "DW_AT_type";
3185 case DW_AT_use_location:
3186 return "DW_AT_use_location";
3187 case DW_AT_variable_parameter:
3188 return "DW_AT_variable_parameter";
3189 case DW_AT_virtuality:
3190 return "DW_AT_virtuality";
3191 case DW_AT_vtable_elem_location:
3192 return "DW_AT_vtable_elem_location";
3194 case DW_AT_MIPS_fde:
3195 return "DW_AT_MIPS_fde";
3196 case DW_AT_MIPS_loop_begin:
3197 return "DW_AT_MIPS_loop_begin";
3198 case DW_AT_MIPS_tail_loop_begin:
3199 return "DW_AT_MIPS_tail_loop_begin";
3200 case DW_AT_MIPS_epilog_begin:
3201 return "DW_AT_MIPS_epilog_begin";
3202 case DW_AT_MIPS_loop_unroll_factor:
3203 return "DW_AT_MIPS_loop_unroll_factor";
3204 case DW_AT_MIPS_software_pipeline_depth:
3205 return "DW_AT_MIPS_software_pipeline_depth";
3206 case DW_AT_MIPS_linkage_name:
3207 return "DW_AT_MIPS_linkage_name";
3208 case DW_AT_MIPS_stride:
3209 return "DW_AT_MIPS_stride";
3210 case DW_AT_MIPS_abstract_name:
3211 return "DW_AT_MIPS_abstract_name";
3212 case DW_AT_MIPS_clone_origin:
3213 return "DW_AT_MIPS_clone_origin";
3214 case DW_AT_MIPS_has_inlines:
3215 return "DW_AT_MIPS_has_inlines";
3217 case DW_AT_sf_names:
3218 return "DW_AT_sf_names";
3219 case DW_AT_src_info:
3220 return "DW_AT_src_info";
3221 case DW_AT_mac_info:
3222 return "DW_AT_mac_info";
3223 case DW_AT_src_coords:
3224 return "DW_AT_src_coords";
3225 case DW_AT_body_begin:
3226 return "DW_AT_body_begin";
3227 case DW_AT_body_end:
3228 return "DW_AT_body_end";
3230 return "DW_AT_<unknown>";
3234 /* Convert a DWARF value form code into its string name. */
3237 dwarf_form_name (form)
3238 register unsigned form;
3243 return "DW_FORM_addr";
3244 case DW_FORM_block2:
3245 return "DW_FORM_block2";
3246 case DW_FORM_block4:
3247 return "DW_FORM_block4";
3249 return "DW_FORM_data2";
3251 return "DW_FORM_data4";
3253 return "DW_FORM_data8";
3254 case DW_FORM_string:
3255 return "DW_FORM_string";
3257 return "DW_FORM_block";
3258 case DW_FORM_block1:
3259 return "DW_FORM_block1";
3261 return "DW_FORM_data1";
3263 return "DW_FORM_flag";
3265 return "DW_FORM_sdata";
3267 return "DW_FORM_strp";
3269 return "DW_FORM_udata";
3270 case DW_FORM_ref_addr:
3271 return "DW_FORM_ref_addr";
3273 return "DW_FORM_ref1";
3275 return "DW_FORM_ref2";
3277 return "DW_FORM_ref4";
3279 return "DW_FORM_ref8";
3280 case DW_FORM_ref_udata:
3281 return "DW_FORM_ref_udata";
3282 case DW_FORM_indirect:
3283 return "DW_FORM_indirect";
3285 return "DW_FORM_<unknown>";
3289 /* Convert a DWARF stack opcode into its string name. */
3292 dwarf_stack_op_name (op)
3293 register unsigned op;
3298 return "DW_OP_addr";
3300 return "DW_OP_deref";
3302 return "DW_OP_const1u";
3304 return "DW_OP_const1s";
3306 return "DW_OP_const2u";
3308 return "DW_OP_const2s";
3310 return "DW_OP_const4u";
3312 return "DW_OP_const4s";
3314 return "DW_OP_const8u";
3316 return "DW_OP_const8s";
3318 return "DW_OP_constu";
3320 return "DW_OP_consts";
3324 return "DW_OP_drop";
3326 return "DW_OP_over";
3328 return "DW_OP_pick";
3330 return "DW_OP_swap";
3334 return "DW_OP_xderef";
3342 return "DW_OP_minus";
3354 return "DW_OP_plus";
3355 case DW_OP_plus_uconst:
3356 return "DW_OP_plus_uconst";
3362 return "DW_OP_shra";
3380 return "DW_OP_skip";
3382 return "DW_OP_lit0";
3384 return "DW_OP_lit1";
3386 return "DW_OP_lit2";
3388 return "DW_OP_lit3";
3390 return "DW_OP_lit4";
3392 return "DW_OP_lit5";
3394 return "DW_OP_lit6";
3396 return "DW_OP_lit7";
3398 return "DW_OP_lit8";
3400 return "DW_OP_lit9";
3402 return "DW_OP_lit10";
3404 return "DW_OP_lit11";
3406 return "DW_OP_lit12";
3408 return "DW_OP_lit13";
3410 return "DW_OP_lit14";
3412 return "DW_OP_lit15";
3414 return "DW_OP_lit16";
3416 return "DW_OP_lit17";
3418 return "DW_OP_lit18";
3420 return "DW_OP_lit19";
3422 return "DW_OP_lit20";
3424 return "DW_OP_lit21";
3426 return "DW_OP_lit22";
3428 return "DW_OP_lit23";
3430 return "DW_OP_lit24";
3432 return "DW_OP_lit25";
3434 return "DW_OP_lit26";
3436 return "DW_OP_lit27";
3438 return "DW_OP_lit28";
3440 return "DW_OP_lit29";
3442 return "DW_OP_lit30";
3444 return "DW_OP_lit31";
3446 return "DW_OP_reg0";
3448 return "DW_OP_reg1";
3450 return "DW_OP_reg2";
3452 return "DW_OP_reg3";
3454 return "DW_OP_reg4";
3456 return "DW_OP_reg5";
3458 return "DW_OP_reg6";
3460 return "DW_OP_reg7";
3462 return "DW_OP_reg8";
3464 return "DW_OP_reg9";
3466 return "DW_OP_reg10";
3468 return "DW_OP_reg11";
3470 return "DW_OP_reg12";
3472 return "DW_OP_reg13";
3474 return "DW_OP_reg14";
3476 return "DW_OP_reg15";
3478 return "DW_OP_reg16";
3480 return "DW_OP_reg17";
3482 return "DW_OP_reg18";
3484 return "DW_OP_reg19";
3486 return "DW_OP_reg20";
3488 return "DW_OP_reg21";
3490 return "DW_OP_reg22";
3492 return "DW_OP_reg23";
3494 return "DW_OP_reg24";
3496 return "DW_OP_reg25";
3498 return "DW_OP_reg26";
3500 return "DW_OP_reg27";
3502 return "DW_OP_reg28";
3504 return "DW_OP_reg29";
3506 return "DW_OP_reg30";
3508 return "DW_OP_reg31";
3510 return "DW_OP_breg0";
3512 return "DW_OP_breg1";
3514 return "DW_OP_breg2";
3516 return "DW_OP_breg3";
3518 return "DW_OP_breg4";
3520 return "DW_OP_breg5";
3522 return "DW_OP_breg6";
3524 return "DW_OP_breg7";
3526 return "DW_OP_breg8";
3528 return "DW_OP_breg9";
3530 return "DW_OP_breg10";
3532 return "DW_OP_breg11";
3534 return "DW_OP_breg12";
3536 return "DW_OP_breg13";
3538 return "DW_OP_breg14";
3540 return "DW_OP_breg15";
3542 return "DW_OP_breg16";
3544 return "DW_OP_breg17";
3546 return "DW_OP_breg18";
3548 return "DW_OP_breg19";
3550 return "DW_OP_breg20";
3552 return "DW_OP_breg21";
3554 return "DW_OP_breg22";
3556 return "DW_OP_breg23";
3558 return "DW_OP_breg24";
3560 return "DW_OP_breg25";
3562 return "DW_OP_breg26";
3564 return "DW_OP_breg27";
3566 return "DW_OP_breg28";
3568 return "DW_OP_breg29";
3570 return "DW_OP_breg30";
3572 return "DW_OP_breg31";
3574 return "DW_OP_regx";
3576 return "DW_OP_fbreg";
3578 return "DW_OP_bregx";
3580 return "DW_OP_piece";
3581 case DW_OP_deref_size:
3582 return "DW_OP_deref_size";
3583 case DW_OP_xderef_size:
3584 return "DW_OP_xderef_size";
3588 return "OP_<unknown>";
3592 /* Convert a DWARF type code into its string name. */
3596 dwarf_type_encoding_name (enc)
3597 register unsigned enc;
3601 case DW_ATE_address:
3602 return "DW_ATE_address";
3603 case DW_ATE_boolean:
3604 return "DW_ATE_boolean";
3605 case DW_ATE_complex_float:
3606 return "DW_ATE_complex_float";
3608 return "DW_ATE_float";
3610 return "DW_ATE_signed";
3611 case DW_ATE_signed_char:
3612 return "DW_ATE_signed_char";
3613 case DW_ATE_unsigned:
3614 return "DW_ATE_unsigned";
3615 case DW_ATE_unsigned_char:
3616 return "DW_ATE_unsigned_char";
3618 return "DW_ATE_<unknown>";
3623 /* Determine the "ultimate origin" of a decl. The decl may be an inlined
3624 instance of an inlined instance of a decl which is local to an inline
3625 function, so we have to trace all of the way back through the origin chain
3626 to find out what sort of node actually served as the original seed for the
3630 decl_ultimate_origin (decl)
3633 #ifdef ENABLE_CHECKING
3634 if (DECL_FROM_INLINE (DECL_ORIGIN (decl)))
3635 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
3636 most distant ancestor, this should never happen. */
3640 return DECL_ABSTRACT_ORIGIN (decl);
3643 /* Determine the "ultimate origin" of a block. The block may be an inlined
3644 instance of an inlined instance of a block which is local to an inline
3645 function, so we have to trace all of the way back through the origin chain
3646 to find out what sort of node actually served as the original seed for the
3650 block_ultimate_origin (block)
3651 register tree block;
3653 register tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block);
3655 if (immediate_origin == NULL_TREE)
3659 register tree ret_val;
3660 register tree lookahead = immediate_origin;
3664 ret_val = lookahead;
3665 lookahead = (TREE_CODE (ret_val) == BLOCK)
3666 ? BLOCK_ABSTRACT_ORIGIN (ret_val)
3669 while (lookahead != NULL && lookahead != ret_val);
3675 /* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT
3676 of a virtual function may refer to a base class, so we check the 'this'
3680 decl_class_context (decl)
3683 tree context = NULL_TREE;
3685 if (TREE_CODE (decl) != FUNCTION_DECL || ! DECL_VINDEX (decl))
3686 context = DECL_CONTEXT (decl);
3688 context = TYPE_MAIN_VARIANT
3689 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
3691 if (context && TREE_CODE_CLASS (TREE_CODE (context)) != 't')
3692 context = NULL_TREE;
3697 /* Add an attribute/value pair to a DIE */
3700 add_dwarf_attr (die, attr)
3701 register dw_die_ref die;
3702 register dw_attr_ref attr;
3704 if (die != NULL && attr != NULL)
3706 if (die->die_attr == NULL)
3708 die->die_attr = attr;
3709 die->die_attr_last = attr;
3713 die->die_attr_last->dw_attr_next = attr;
3714 die->die_attr_last = attr;
3719 /* Add a flag value attribute to a DIE. */
3722 add_AT_flag (die, attr_kind, flag)
3723 register dw_die_ref die;
3724 register enum dwarf_attribute attr_kind;
3725 register unsigned flag;
3727 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3729 attr->dw_attr_next = NULL;
3730 attr->dw_attr = attr_kind;
3731 attr->dw_attr_val.val_class = dw_val_class_flag;
3732 attr->dw_attr_val.v.val_flag = flag;
3733 add_dwarf_attr (die, attr);
3736 /* Add a signed integer attribute value to a DIE. */
3739 add_AT_int (die, attr_kind, int_val)
3740 register dw_die_ref die;
3741 register enum dwarf_attribute attr_kind;
3742 register long int int_val;
3744 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3746 attr->dw_attr_next = NULL;
3747 attr->dw_attr = attr_kind;
3748 attr->dw_attr_val.val_class = dw_val_class_const;
3749 attr->dw_attr_val.v.val_int = int_val;
3750 add_dwarf_attr (die, attr);
3753 /* Add an unsigned integer attribute value to a DIE. */
3756 add_AT_unsigned (die, attr_kind, unsigned_val)
3757 register dw_die_ref die;
3758 register enum dwarf_attribute attr_kind;
3759 register unsigned long unsigned_val;
3761 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3763 attr->dw_attr_next = NULL;
3764 attr->dw_attr = attr_kind;
3765 attr->dw_attr_val.val_class = dw_val_class_unsigned_const;
3766 attr->dw_attr_val.v.val_unsigned = unsigned_val;
3767 add_dwarf_attr (die, attr);
3770 /* Add an unsigned double integer attribute value to a DIE. */
3773 add_AT_long_long (die, attr_kind, val_hi, val_low)
3774 register dw_die_ref die;
3775 register enum dwarf_attribute attr_kind;
3776 register unsigned long val_hi;
3777 register unsigned long val_low;
3779 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3781 attr->dw_attr_next = NULL;
3782 attr->dw_attr = attr_kind;
3783 attr->dw_attr_val.val_class = dw_val_class_long_long;
3784 attr->dw_attr_val.v.val_long_long.hi = val_hi;
3785 attr->dw_attr_val.v.val_long_long.low = val_low;
3786 add_dwarf_attr (die, attr);
3789 /* Add a floating point attribute value to a DIE and return it. */
3792 add_AT_float (die, attr_kind, length, array)
3793 register dw_die_ref die;
3794 register enum dwarf_attribute attr_kind;
3795 register unsigned length;
3796 register long *array;
3798 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3800 attr->dw_attr_next = NULL;
3801 attr->dw_attr = attr_kind;
3802 attr->dw_attr_val.val_class = dw_val_class_float;
3803 attr->dw_attr_val.v.val_float.length = length;
3804 attr->dw_attr_val.v.val_float.array = array;
3805 add_dwarf_attr (die, attr);
3808 /* Add a string attribute value to a DIE. */
3811 add_AT_string (die, attr_kind, str)
3812 register dw_die_ref die;
3813 register enum dwarf_attribute attr_kind;
3816 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3818 attr->dw_attr_next = NULL;
3819 attr->dw_attr = attr_kind;
3820 attr->dw_attr_val.val_class = dw_val_class_str;
3821 attr->dw_attr_val.v.val_str = xstrdup (str);
3822 add_dwarf_attr (die, attr);
3825 /* Add a DIE reference attribute value to a DIE. */
3828 add_AT_die_ref (die, attr_kind, targ_die)
3829 register dw_die_ref die;
3830 register enum dwarf_attribute attr_kind;
3831 register dw_die_ref targ_die;
3833 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3835 attr->dw_attr_next = NULL;
3836 attr->dw_attr = attr_kind;
3837 attr->dw_attr_val.val_class = dw_val_class_die_ref;
3838 attr->dw_attr_val.v.val_die_ref = targ_die;
3839 add_dwarf_attr (die, attr);
3842 /* Add an FDE reference attribute value to a DIE. */
3845 add_AT_fde_ref (die, attr_kind, targ_fde)
3846 register dw_die_ref die;
3847 register enum dwarf_attribute attr_kind;
3848 register unsigned targ_fde;
3850 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3852 attr->dw_attr_next = NULL;
3853 attr->dw_attr = attr_kind;
3854 attr->dw_attr_val.val_class = dw_val_class_fde_ref;
3855 attr->dw_attr_val.v.val_fde_index = targ_fde;
3856 add_dwarf_attr (die, attr);
3859 /* Add a location description attribute value to a DIE. */
3862 add_AT_loc (die, attr_kind, loc)
3863 register dw_die_ref die;
3864 register enum dwarf_attribute attr_kind;
3865 register dw_loc_descr_ref loc;
3867 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3869 attr->dw_attr_next = NULL;
3870 attr->dw_attr = attr_kind;
3871 attr->dw_attr_val.val_class = dw_val_class_loc;
3872 attr->dw_attr_val.v.val_loc = loc;
3873 add_dwarf_attr (die, attr);
3876 /* Add an address constant attribute value to a DIE. */
3879 add_AT_addr (die, attr_kind, addr)
3880 register dw_die_ref die;
3881 register enum dwarf_attribute attr_kind;
3884 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3886 attr->dw_attr_next = NULL;
3887 attr->dw_attr = attr_kind;
3888 attr->dw_attr_val.val_class = dw_val_class_addr;
3889 attr->dw_attr_val.v.val_addr = addr;
3890 add_dwarf_attr (die, attr);
3893 /* Add a label identifier attribute value to a DIE. */
3896 add_AT_lbl_id (die, attr_kind, lbl_id)
3897 register dw_die_ref die;
3898 register enum dwarf_attribute attr_kind;
3899 register char *lbl_id;
3901 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3903 attr->dw_attr_next = NULL;
3904 attr->dw_attr = attr_kind;
3905 attr->dw_attr_val.val_class = dw_val_class_lbl_id;
3906 attr->dw_attr_val.v.val_lbl_id = xstrdup (lbl_id);
3907 add_dwarf_attr (die, attr);
3910 /* Add a section offset attribute value to a DIE. */
3913 add_AT_lbl_offset (die, attr_kind, label)
3914 register dw_die_ref die;
3915 register enum dwarf_attribute attr_kind;
3916 register char *label;
3918 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3920 attr->dw_attr_next = NULL;
3921 attr->dw_attr = attr_kind;
3922 attr->dw_attr_val.val_class = dw_val_class_lbl_offset;
3923 attr->dw_attr_val.v.val_lbl_id = label;
3924 add_dwarf_attr (die, attr);
3928 /* Test if die refers to an external subroutine. */
3931 is_extern_subr_die (die)
3932 register dw_die_ref die;
3934 register dw_attr_ref a;
3935 register int is_subr = FALSE;
3936 register int is_extern = FALSE;
3938 if (die != NULL && die->die_tag == DW_TAG_subprogram)
3941 for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
3943 if (a->dw_attr == DW_AT_external
3944 && a->dw_attr_val.val_class == dw_val_class_flag
3945 && a->dw_attr_val.v.val_flag != 0)
3953 return is_subr && is_extern;
3956 /* Get the attribute of type attr_kind. */
3958 static inline dw_attr_ref
3959 get_AT (die, attr_kind)
3960 register dw_die_ref die;
3961 register enum dwarf_attribute attr_kind;
3963 register dw_attr_ref a;
3964 register dw_die_ref spec = NULL;
3968 for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
3970 if (a->dw_attr == attr_kind)
3973 if (a->dw_attr == DW_AT_specification
3974 || a->dw_attr == DW_AT_abstract_origin)
3975 spec = a->dw_attr_val.v.val_die_ref;
3979 return get_AT (spec, attr_kind);
3985 /* Return the "low pc" attribute value, typically associated with
3986 a subprogram DIE. Return null if the "low pc" attribute is
3987 either not prsent, or if it cannot be represented as an
3988 assembler label identifier. */
3990 static inline char *
3992 register dw_die_ref die;
3994 register dw_attr_ref a = get_AT (die, DW_AT_low_pc);
3996 if (a && a->dw_attr_val.val_class == dw_val_class_lbl_id)
3997 return a->dw_attr_val.v.val_lbl_id;
4002 /* Return the "high pc" attribute value, typically associated with
4003 a subprogram DIE. Return null if the "high pc" attribute is
4004 either not prsent, or if it cannot be represented as an
4005 assembler label identifier. */
4007 static inline char *
4009 register dw_die_ref die;
4011 register dw_attr_ref a = get_AT (die, DW_AT_high_pc);
4013 if (a && a->dw_attr_val.val_class == dw_val_class_lbl_id)
4014 return a->dw_attr_val.v.val_lbl_id;
4019 /* Return the value of the string attribute designated by ATTR_KIND, or
4020 NULL if it is not present. */
4022 static inline char *
4023 get_AT_string (die, attr_kind)
4024 register dw_die_ref die;
4025 register enum dwarf_attribute attr_kind;
4027 register dw_attr_ref a = get_AT (die, attr_kind);
4029 if (a && a->dw_attr_val.val_class == dw_val_class_str)
4030 return a->dw_attr_val.v.val_str;
4035 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
4036 if it is not present. */
4039 get_AT_flag (die, attr_kind)
4040 register dw_die_ref die;
4041 register enum dwarf_attribute attr_kind;
4043 register dw_attr_ref a = get_AT (die, attr_kind);
4045 if (a && a->dw_attr_val.val_class == dw_val_class_flag)
4046 return a->dw_attr_val.v.val_flag;
4051 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
4052 if it is not present. */
4054 static inline unsigned
4055 get_AT_unsigned (die, attr_kind)
4056 register dw_die_ref die;
4057 register enum dwarf_attribute attr_kind;
4059 register dw_attr_ref a = get_AT (die, attr_kind);
4061 if (a && a->dw_attr_val.val_class == dw_val_class_unsigned_const)
4062 return a->dw_attr_val.v.val_unsigned;
4070 register unsigned lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
4072 return (lang == DW_LANG_C || lang == DW_LANG_C89
4073 || lang == DW_LANG_C_plus_plus);
4079 register unsigned lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
4081 return (lang == DW_LANG_Fortran77 || lang == DW_LANG_Fortran90);
4084 /* Remove the specified attribute if present. */
4087 remove_AT (die, attr_kind)
4088 register dw_die_ref die;
4089 register enum dwarf_attribute attr_kind;
4091 register dw_attr_ref a;
4092 register dw_attr_ref removed = NULL;;
4096 if (die->die_attr->dw_attr == attr_kind)
4098 removed = die->die_attr;
4099 if (die->die_attr_last == die->die_attr)
4100 die->die_attr_last = NULL;
4102 die->die_attr = die->die_attr->dw_attr_next;
4106 for (a = die->die_attr; a->dw_attr_next != NULL;
4107 a = a->dw_attr_next)
4108 if (a->dw_attr_next->dw_attr == attr_kind)
4110 removed = a->dw_attr_next;
4111 if (die->die_attr_last == a->dw_attr_next)
4112 die->die_attr_last = a;
4114 a->dw_attr_next = a->dw_attr_next->dw_attr_next;
4123 /* Discard the children of this DIE. */
4126 remove_children (die)
4127 register dw_die_ref die;
4129 register dw_die_ref child_die = die->die_child;
4131 die->die_child = NULL;
4132 die->die_child_last = NULL;
4134 while (child_die != NULL)
4136 register dw_die_ref tmp_die = child_die;
4137 register dw_attr_ref a;
4139 child_die = child_die->die_sib;
4141 for (a = tmp_die->die_attr; a != NULL; )
4143 register dw_attr_ref tmp_a = a;
4145 a = a->dw_attr_next;
4153 /* Add a child DIE below its parent. */
4156 add_child_die (die, child_die)
4157 register dw_die_ref die;
4158 register dw_die_ref child_die;
4160 if (die != NULL && child_die != NULL)
4162 if (die == child_die)
4164 child_die->die_parent = die;
4165 child_die->die_sib = NULL;
4167 if (die->die_child == NULL)
4169 die->die_child = child_die;
4170 die->die_child_last = child_die;
4174 die->die_child_last->die_sib = child_die;
4175 die->die_child_last = child_die;
4180 /* Return a pointer to a newly created DIE node. */
4182 static inline dw_die_ref
4183 new_die (tag_value, parent_die)
4184 register enum dwarf_tag tag_value;
4185 register dw_die_ref parent_die;
4187 register dw_die_ref die = (dw_die_ref) xmalloc (sizeof (die_node));
4189 die->die_tag = tag_value;
4190 die->die_abbrev = 0;
4191 die->die_offset = 0;
4192 die->die_child = NULL;
4193 die->die_parent = NULL;
4194 die->die_sib = NULL;
4195 die->die_child_last = NULL;
4196 die->die_attr = NULL;
4197 die->die_attr_last = NULL;
4199 if (parent_die != NULL)
4200 add_child_die (parent_die, die);
4203 limbo_die_node *limbo_node;
4205 limbo_node = (limbo_die_node *) xmalloc (sizeof (limbo_die_node));
4206 limbo_node->die = die;
4207 limbo_node->next = limbo_die_list;
4208 limbo_die_list = limbo_node;
4214 /* Return the DIE associated with the given type specifier. */
4216 static inline dw_die_ref
4217 lookup_type_die (type)
4220 return (dw_die_ref) TYPE_SYMTAB_POINTER (type);
4223 /* Equate a DIE to a given type specifier. */
4226 equate_type_number_to_die (type, type_die)
4228 register dw_die_ref type_die;
4230 TYPE_SYMTAB_POINTER (type) = (char *) type_die;
4233 /* Return the DIE associated with a given declaration. */
4235 static inline dw_die_ref
4236 lookup_decl_die (decl)
4239 register unsigned decl_id = DECL_UID (decl);
4241 return (decl_id < decl_die_table_in_use
4242 ? decl_die_table[decl_id] : NULL);
4245 /* Equate a DIE to a particular declaration. */
4248 equate_decl_number_to_die (decl, decl_die)
4250 register dw_die_ref decl_die;
4252 register unsigned decl_id = DECL_UID (decl);
4253 register unsigned num_allocated;
4255 if (decl_id >= decl_die_table_allocated)
4258 = ((decl_id + 1 + DECL_DIE_TABLE_INCREMENT - 1)
4259 / DECL_DIE_TABLE_INCREMENT)
4260 * DECL_DIE_TABLE_INCREMENT;
4263 = (dw_die_ref *) xrealloc (decl_die_table,
4264 sizeof (dw_die_ref) * num_allocated);
4266 bzero ((char *) &decl_die_table[decl_die_table_allocated],
4267 (num_allocated - decl_die_table_allocated) * sizeof (dw_die_ref));
4268 decl_die_table_allocated = num_allocated;
4271 if (decl_id >= decl_die_table_in_use)
4272 decl_die_table_in_use = (decl_id + 1);
4274 decl_die_table[decl_id] = decl_die;
4277 /* Return a pointer to a newly allocated location description. Location
4278 descriptions are simple expression terms that can be strung
4279 together to form more complicated location (address) descriptions. */
4281 static inline dw_loc_descr_ref
4282 new_loc_descr (op, oprnd1, oprnd2)
4283 register enum dwarf_location_atom op;
4284 register unsigned long oprnd1;
4285 register unsigned long oprnd2;
4287 register dw_loc_descr_ref descr
4288 = (dw_loc_descr_ref) xmalloc (sizeof (dw_loc_descr_node));
4290 descr->dw_loc_next = NULL;
4291 descr->dw_loc_opc = op;
4292 descr->dw_loc_oprnd1.val_class = dw_val_class_unsigned_const;
4293 descr->dw_loc_oprnd1.v.val_unsigned = oprnd1;
4294 descr->dw_loc_oprnd2.val_class = dw_val_class_unsigned_const;
4295 descr->dw_loc_oprnd2.v.val_unsigned = oprnd2;
4300 /* Add a location description term to a location description expression. */
4303 add_loc_descr (list_head, descr)
4304 register dw_loc_descr_ref *list_head;
4305 register dw_loc_descr_ref descr;
4307 register dw_loc_descr_ref *d;
4309 /* Find the end of the chain. */
4310 for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
4316 /* Keep track of the number of spaces used to indent the
4317 output of the debugging routines that print the structure of
4318 the DIE internal representation. */
4319 static int print_indent;
4321 /* Indent the line the number of spaces given by print_indent. */
4324 print_spaces (outfile)
4327 fprintf (outfile, "%*s", print_indent, "");
4330 /* Print the information associated with a given DIE, and its children.
4331 This routine is a debugging aid only. */
4334 print_die (die, outfile)
4338 register dw_attr_ref a;
4339 register dw_die_ref c;
4341 print_spaces (outfile);
4342 fprintf (outfile, "DIE %4lu: %s\n",
4343 die->die_offset, dwarf_tag_name (die->die_tag));
4344 print_spaces (outfile);
4345 fprintf (outfile, " abbrev id: %lu", die->die_abbrev);
4346 fprintf (outfile, " offset: %lu\n", die->die_offset);
4348 for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
4350 print_spaces (outfile);
4351 fprintf (outfile, " %s: ", dwarf_attr_name (a->dw_attr));
4353 switch (a->dw_attr_val.val_class)
4355 case dw_val_class_addr:
4356 fprintf (outfile, "address");
4358 case dw_val_class_loc:
4359 fprintf (outfile, "location descriptor");
4361 case dw_val_class_const:
4362 fprintf (outfile, "%ld", a->dw_attr_val.v.val_int);
4364 case dw_val_class_unsigned_const:
4365 fprintf (outfile, "%lu", a->dw_attr_val.v.val_unsigned);
4367 case dw_val_class_long_long:
4368 fprintf (outfile, "constant (%lu,%lu)",
4369 a->dw_attr_val.v.val_long_long.hi,
4370 a->dw_attr_val.v.val_long_long.low);
4372 case dw_val_class_float:
4373 fprintf (outfile, "floating-point constant");
4375 case dw_val_class_flag:
4376 fprintf (outfile, "%u", a->dw_attr_val.v.val_flag);
4378 case dw_val_class_die_ref:
4379 if (a->dw_attr_val.v.val_die_ref != NULL)
4380 fprintf (outfile, "die -> %lu",
4381 a->dw_attr_val.v.val_die_ref->die_offset);
4383 fprintf (outfile, "die -> <null>");
4385 case dw_val_class_lbl_id:
4386 case dw_val_class_lbl_offset:
4387 fprintf (outfile, "label: %s", a->dw_attr_val.v.val_lbl_id);
4389 case dw_val_class_str:
4390 if (a->dw_attr_val.v.val_str != NULL)
4391 fprintf (outfile, "\"%s\"", a->dw_attr_val.v.val_str);
4393 fprintf (outfile, "<null>");
4399 fprintf (outfile, "\n");
4402 if (die->die_child != NULL)
4405 for (c = die->die_child; c != NULL; c = c->die_sib)
4406 print_die (c, outfile);
4412 /* Print the contents of the source code line number correspondence table.
4413 This routine is a debugging aid only. */
4416 print_dwarf_line_table (outfile)
4419 register unsigned i;
4420 register dw_line_info_ref line_info;
4422 fprintf (outfile, "\n\nDWARF source line information\n");
4423 for (i = 1; i < line_info_table_in_use; ++i)
4425 line_info = &line_info_table[i];
4426 fprintf (outfile, "%5d: ", i);
4427 fprintf (outfile, "%-20s", file_table[line_info->dw_file_num]);
4428 fprintf (outfile, "%6ld", line_info->dw_line_num);
4429 fprintf (outfile, "\n");
4432 fprintf (outfile, "\n\n");
4435 /* Print the information collected for a given DIE. */
4438 debug_dwarf_die (die)
4441 print_die (die, stderr);
4444 /* Print all DWARF information collected for the compilation unit.
4445 This routine is a debugging aid only. */
4451 print_die (comp_unit_die, stderr);
4452 print_dwarf_line_table (stderr);
4455 /* Traverse the DIE, and add a sibling attribute if it may have the
4456 effect of speeding up access to siblings. To save some space,
4457 avoid generating sibling attributes for DIE's without children. */
4460 add_sibling_attributes(die)
4461 register dw_die_ref die;
4463 register dw_die_ref c;
4464 register dw_attr_ref attr;
4465 if (die != comp_unit_die && die->die_child != NULL)
4467 attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
4468 attr->dw_attr_next = NULL;
4469 attr->dw_attr = DW_AT_sibling;
4470 attr->dw_attr_val.val_class = dw_val_class_die_ref;
4471 attr->dw_attr_val.v.val_die_ref = die->die_sib;
4473 /* Add the sibling link to the front of the attribute list. */
4474 attr->dw_attr_next = die->die_attr;
4475 if (die->die_attr == NULL)
4476 die->die_attr_last = attr;
4478 die->die_attr = attr;
4481 for (c = die->die_child; c != NULL; c = c->die_sib)
4482 add_sibling_attributes (c);
4485 /* The format of each DIE (and its attribute value pairs)
4486 is encoded in an abbreviation table. This routine builds the
4487 abbreviation table and assigns a unique abbreviation id for
4488 each abbreviation entry. The children of each die are visited
4492 build_abbrev_table (die)
4493 register dw_die_ref die;
4495 register unsigned long abbrev_id;
4496 register unsigned long n_alloc;
4497 register dw_die_ref c;
4498 register dw_attr_ref d_attr, a_attr;
4499 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
4501 register dw_die_ref abbrev = abbrev_die_table[abbrev_id];
4503 if (abbrev->die_tag == die->die_tag)
4505 if ((abbrev->die_child != NULL) == (die->die_child != NULL))
4507 a_attr = abbrev->die_attr;
4508 d_attr = die->die_attr;
4510 while (a_attr != NULL && d_attr != NULL)
4512 if ((a_attr->dw_attr != d_attr->dw_attr)
4513 || (value_format (&a_attr->dw_attr_val)
4514 != value_format (&d_attr->dw_attr_val)))
4517 a_attr = a_attr->dw_attr_next;
4518 d_attr = d_attr->dw_attr_next;
4521 if (a_attr == NULL && d_attr == NULL)
4527 if (abbrev_id >= abbrev_die_table_in_use)
4529 if (abbrev_die_table_in_use >= abbrev_die_table_allocated)
4531 n_alloc = abbrev_die_table_allocated + ABBREV_DIE_TABLE_INCREMENT;
4533 = (dw_die_ref *) xrealloc (abbrev_die_table,
4534 sizeof (dw_die_ref) * n_alloc);
4536 bzero ((char *) &abbrev_die_table[abbrev_die_table_allocated],
4537 (n_alloc - abbrev_die_table_allocated) * sizeof (dw_die_ref));
4538 abbrev_die_table_allocated = n_alloc;
4541 ++abbrev_die_table_in_use;
4542 abbrev_die_table[abbrev_id] = die;
4545 die->die_abbrev = abbrev_id;
4546 for (c = die->die_child; c != NULL; c = c->die_sib)
4547 build_abbrev_table (c);
4550 /* Return the size of a string, including the null byte.
4552 This used to treat backslashes as escapes, and hence they were not included
4553 in the count. However, that conflicts with what ASM_OUTPUT_ASCII does,
4554 which treats a backslash as a backslash, escaping it if necessary, and hence
4555 we must include them in the count. */
4557 static unsigned long
4558 size_of_string (str)
4561 return strlen (str) + 1;
4564 /* Return the size of a location descriptor. */
4566 static unsigned long
4567 size_of_loc_descr (loc)
4568 register dw_loc_descr_ref loc;
4570 register unsigned long size = 1;
4572 switch (loc->dw_loc_opc)
4594 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4597 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
4602 case DW_OP_plus_uconst:
4603 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4641 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
4644 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4647 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
4650 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4651 size += size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int);
4654 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4656 case DW_OP_deref_size:
4657 case DW_OP_xderef_size:
4667 /* Return the size of a series of location descriptors. */
4669 static unsigned long
4671 register dw_loc_descr_ref loc;
4673 register unsigned long size = 0;
4675 for (; loc != NULL; loc = loc->dw_loc_next)
4676 size += size_of_loc_descr (loc);
4681 /* Return the power-of-two number of bytes necessary to represent VALUE. */
4684 constant_size (value)
4685 long unsigned value;
4692 log = floor_log2 (value);
4695 log = 1 << (floor_log2 (log) + 1);
4700 /* Return the size of a DIE, as it is represented in the
4701 .debug_info section. */
4703 static unsigned long
4705 register dw_die_ref die;
4707 register unsigned long size = 0;
4708 register dw_attr_ref a;
4710 size += size_of_uleb128 (die->die_abbrev);
4711 for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
4713 switch (a->dw_attr_val.val_class)
4715 case dw_val_class_addr:
4718 case dw_val_class_loc:
4720 register unsigned long lsize
4721 = size_of_locs (a->dw_attr_val.v.val_loc);
4724 size += constant_size (lsize);
4728 case dw_val_class_const:
4731 case dw_val_class_unsigned_const:
4732 size += constant_size (a->dw_attr_val.v.val_unsigned);
4734 case dw_val_class_long_long:
4735 size += 1 + 8; /* block */
4737 case dw_val_class_float:
4738 size += 1 + a->dw_attr_val.v.val_float.length * 4; /* block */
4740 case dw_val_class_flag:
4743 case dw_val_class_die_ref:
4744 size += DWARF_OFFSET_SIZE;
4746 case dw_val_class_fde_ref:
4747 size += DWARF_OFFSET_SIZE;
4749 case dw_val_class_lbl_id:
4752 case dw_val_class_lbl_offset:
4753 size += DWARF_OFFSET_SIZE;
4755 case dw_val_class_str:
4756 size += size_of_string (a->dw_attr_val.v.val_str);
4766 /* Size the debugging information associated with a given DIE.
4767 Visits the DIE's children recursively. Updates the global
4768 variable next_die_offset, on each time through. Uses the
4769 current value of next_die_offset to update the die_offset
4770 field in each DIE. */
4773 calc_die_sizes (die)
4776 register dw_die_ref c;
4777 die->die_offset = next_die_offset;
4778 next_die_offset += size_of_die (die);
4780 for (c = die->die_child; c != NULL; c = c->die_sib)
4783 if (die->die_child != NULL)
4784 /* Count the null byte used to terminate sibling lists. */
4785 next_die_offset += 1;
4788 /* Return the size of the line information prolog generated for the
4789 compilation unit. */
4791 static unsigned long
4792 size_of_line_prolog ()
4794 register unsigned long size;
4795 register unsigned long ft_index;
4797 size = DWARF_LINE_PROLOG_HEADER_SIZE;
4799 /* Count the size of the table giving number of args for each
4801 size += DWARF_LINE_OPCODE_BASE - 1;
4803 /* Include directory table is empty (at present). Count only the
4804 null byte used to terminate the table. */
4807 for (ft_index = 1; ft_index < file_table_in_use; ++ft_index)
4809 /* File name entry. */
4810 size += size_of_string (file_table[ft_index]);
4812 /* Include directory index. */
4813 size += size_of_uleb128 (0);
4815 /* Modification time. */
4816 size += size_of_uleb128 (0);
4818 /* File length in bytes. */
4819 size += size_of_uleb128 (0);
4822 /* Count the file table terminator. */
4827 /* Return the size of the line information generated for this
4828 compilation unit. */
4830 static unsigned long
4831 size_of_line_info ()
4833 register unsigned long size;
4834 register unsigned long lt_index;
4835 register unsigned long current_line;
4836 register long line_offset;
4837 register long line_delta;
4838 register unsigned long current_file;
4839 register unsigned long function;
4840 unsigned long size_of_set_address;
4842 /* Size of a DW_LNE_set_address instruction. */
4843 size_of_set_address = 1 + size_of_uleb128 (1 + PTR_SIZE) + 1 + PTR_SIZE;
4845 /* Version number. */
4848 /* Prolog length specifier. */
4849 size += DWARF_OFFSET_SIZE;
4852 size += size_of_line_prolog ();
4856 for (lt_index = 1; lt_index < line_info_table_in_use; ++lt_index)
4858 register dw_line_info_ref line_info = &line_info_table[lt_index];
4860 if (line_info->dw_line_num == current_line
4861 && line_info->dw_file_num == current_file)
4864 /* Advance pc instruction. */
4865 /* ??? See the DW_LNS_advance_pc comment in output_line_info. */
4869 size += size_of_set_address;
4871 if (line_info->dw_file_num != current_file)
4873 /* Set file number instruction. */
4875 current_file = line_info->dw_file_num;
4876 size += size_of_uleb128 (current_file);
4879 if (line_info->dw_line_num != current_line)
4881 line_offset = line_info->dw_line_num - current_line;
4882 line_delta = line_offset - DWARF_LINE_BASE;
4883 current_line = line_info->dw_line_num;
4884 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
4885 /* 1-byte special line number instruction. */
4889 /* Advance line instruction. */
4891 size += size_of_sleb128 (line_offset);
4892 /* Generate line entry instruction. */
4898 /* Advance pc instruction. */
4902 size += size_of_set_address;
4904 /* End of line number info. marker. */
4905 size += 1 + size_of_uleb128 (1) + 1;
4910 for (lt_index = 0; lt_index < separate_line_info_table_in_use; )
4912 register dw_separate_line_info_ref line_info
4913 = &separate_line_info_table[lt_index];
4915 if (line_info->dw_line_num == current_line
4916 && line_info->dw_file_num == current_file
4917 && line_info->function == function)
4920 if (function != line_info->function)
4922 function = line_info->function;
4923 /* Set address register instruction. */
4924 size += size_of_set_address;
4928 /* Advance pc instruction. */
4932 size += size_of_set_address;
4935 if (line_info->dw_file_num != current_file)
4937 /* Set file number instruction. */
4939 current_file = line_info->dw_file_num;
4940 size += size_of_uleb128 (current_file);
4943 if (line_info->dw_line_num != current_line)
4945 line_offset = line_info->dw_line_num - current_line;
4946 line_delta = line_offset - DWARF_LINE_BASE;
4947 current_line = line_info->dw_line_num;
4948 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
4949 /* 1-byte special line number instruction. */
4953 /* Advance line instruction. */
4955 size += size_of_sleb128 (line_offset);
4957 /* Generate line entry instruction. */
4965 /* If we're done with a function, end its sequence. */
4966 if (lt_index == separate_line_info_table_in_use
4967 || separate_line_info_table[lt_index].function != function)
4972 /* Advance pc instruction. */
4976 size += size_of_set_address;
4978 /* End of line number info. marker. */
4979 size += 1 + size_of_uleb128 (1) + 1;
4986 /* Return the size of the .debug_pubnames table generated for the
4987 compilation unit. */
4989 static unsigned long
4992 register unsigned long size;
4993 register unsigned i;
4995 size = DWARF_PUBNAMES_HEADER_SIZE;
4996 for (i = 0; i < pubname_table_in_use; ++i)
4998 register pubname_ref p = &pubname_table[i];
4999 size += DWARF_OFFSET_SIZE + size_of_string (p->name);
5002 size += DWARF_OFFSET_SIZE;
5006 /* Return the size of the information in the .debug_aranges section. */
5008 static unsigned long
5011 register unsigned long size;
5013 size = DWARF_ARANGES_HEADER_SIZE;
5015 /* Count the address/length pair for this compilation unit. */
5016 size += 2 * PTR_SIZE;
5017 size += 2 * PTR_SIZE * arange_table_in_use;
5019 /* Count the two zero words used to terminated the address range table. */
5020 size += 2 * PTR_SIZE;
5024 /* Select the encoding of an attribute value. */
5026 static enum dwarf_form
5030 switch (v->val_class)
5032 case dw_val_class_addr:
5033 return DW_FORM_addr;
5034 case dw_val_class_loc:
5035 switch (constant_size (size_of_locs (v->v.val_loc)))
5038 return DW_FORM_block1;
5040 return DW_FORM_block2;
5044 case dw_val_class_const:
5045 return DW_FORM_data4;
5046 case dw_val_class_unsigned_const:
5047 switch (constant_size (v->v.val_unsigned))
5050 return DW_FORM_data1;
5052 return DW_FORM_data2;
5054 return DW_FORM_data4;
5056 return DW_FORM_data8;
5060 case dw_val_class_long_long:
5061 return DW_FORM_block1;
5062 case dw_val_class_float:
5063 return DW_FORM_block1;
5064 case dw_val_class_flag:
5065 return DW_FORM_flag;
5066 case dw_val_class_die_ref:
5068 case dw_val_class_fde_ref:
5069 return DW_FORM_data;
5070 case dw_val_class_lbl_id:
5071 return DW_FORM_addr;
5072 case dw_val_class_lbl_offset:
5073 return DW_FORM_data;
5074 case dw_val_class_str:
5075 return DW_FORM_string;
5081 /* Output the encoding of an attribute value. */
5084 output_value_format (v)
5087 enum dwarf_form form = value_format (v);
5089 output_uleb128 (form);
5091 fprintf (asm_out_file, " (%s)", dwarf_form_name (form));
5093 fputc ('\n', asm_out_file);
5096 /* Output the .debug_abbrev section which defines the DIE abbreviation
5100 output_abbrev_section ()
5102 unsigned long abbrev_id;
5105 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
5107 register dw_die_ref abbrev = abbrev_die_table[abbrev_id];
5109 output_uleb128 (abbrev_id);
5111 fprintf (asm_out_file, " (abbrev code)");
5113 fputc ('\n', asm_out_file);
5114 output_uleb128 (abbrev->die_tag);
5116 fprintf (asm_out_file, " (TAG: %s)",
5117 dwarf_tag_name (abbrev->die_tag));
5119 fputc ('\n', asm_out_file);
5120 fprintf (asm_out_file, "\t%s\t0x%x", ASM_BYTE_OP,
5121 abbrev->die_child != NULL ? DW_children_yes : DW_children_no);
5124 fprintf (asm_out_file, "\t%s %s",
5126 (abbrev->die_child != NULL
5127 ? "DW_children_yes" : "DW_children_no"));
5129 fputc ('\n', asm_out_file);
5131 for (a_attr = abbrev->die_attr; a_attr != NULL;
5132 a_attr = a_attr->dw_attr_next)
5134 output_uleb128 (a_attr->dw_attr);
5136 fprintf (asm_out_file, " (%s)",
5137 dwarf_attr_name (a_attr->dw_attr));
5139 fputc ('\n', asm_out_file);
5140 output_value_format (&a_attr->dw_attr_val);
5143 fprintf (asm_out_file, "\t%s\t0,0\n", ASM_BYTE_OP);
5146 /* We need to properly terminate the abbrev table for this
5147 compilation unit, as per the standard, and not rely on
5148 workarounds in e.g. gdb. */
5149 fprintf (asm_out_file, "\t%s\t0\n", ASM_BYTE_OP);
5152 /* Output location description stack opcode's operands (if any). */
5155 output_loc_operands (loc)
5156 register dw_loc_descr_ref loc;
5158 register dw_val_ref val1 = &loc->dw_loc_oprnd1;
5159 register dw_val_ref val2 = &loc->dw_loc_oprnd2;
5161 switch (loc->dw_loc_opc)
5164 ASM_OUTPUT_DWARF_ADDR_CONST (asm_out_file, val1->v.val_addr);
5165 fputc ('\n', asm_out_file);
5169 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, val1->v.val_flag);
5170 fputc ('\n', asm_out_file);
5174 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, val1->v.val_int);
5175 fputc ('\n', asm_out_file);
5179 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, val1->v.val_int);
5180 fputc ('\n', asm_out_file);
5185 fputc ('\n', asm_out_file);
5188 output_uleb128 (val1->v.val_unsigned);
5189 fputc ('\n', asm_out_file);
5192 output_sleb128 (val1->v.val_int);
5193 fputc ('\n', asm_out_file);
5196 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, val1->v.val_int);
5197 fputc ('\n', asm_out_file);
5199 case DW_OP_plus_uconst:
5200 output_uleb128 (val1->v.val_unsigned);
5201 fputc ('\n', asm_out_file);
5205 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, val1->v.val_int);
5206 fputc ('\n', asm_out_file);
5240 output_sleb128 (val1->v.val_int);
5241 fputc ('\n', asm_out_file);
5244 output_uleb128 (val1->v.val_unsigned);
5245 fputc ('\n', asm_out_file);
5248 output_sleb128 (val1->v.val_int);
5249 fputc ('\n', asm_out_file);
5252 output_uleb128 (val1->v.val_unsigned);
5253 fputc ('\n', asm_out_file);
5254 output_sleb128 (val2->v.val_int);
5255 fputc ('\n', asm_out_file);
5258 output_uleb128 (val1->v.val_unsigned);
5259 fputc ('\n', asm_out_file);
5261 case DW_OP_deref_size:
5262 case DW_OP_xderef_size:
5263 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, val1->v.val_flag);
5264 fputc ('\n', asm_out_file);
5271 /* Compute the offset of a sibling. */
5273 static unsigned long
5274 sibling_offset (die)
5277 unsigned long offset;
5279 if (die->die_child_last == NULL)
5280 offset = die->die_offset + size_of_die (die);
5282 offset = sibling_offset (die->die_child_last) + 1;
5287 /* Output the DIE and its attributes. Called recursively to generate
5288 the definitions of each child DIE. */
5292 register dw_die_ref die;
5294 register dw_attr_ref a;
5295 register dw_die_ref c;
5296 register unsigned long ref_offset;
5297 register unsigned long size;
5298 register dw_loc_descr_ref loc;
5300 output_uleb128 (die->die_abbrev);
5302 fprintf (asm_out_file, " (DIE (0x%lx) %s)",
5303 die->die_offset, dwarf_tag_name (die->die_tag));
5305 fputc ('\n', asm_out_file);
5307 for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
5309 switch (a->dw_attr_val.val_class)
5311 case dw_val_class_addr:
5312 ASM_OUTPUT_DWARF_ADDR_CONST (asm_out_file,
5313 a->dw_attr_val.v.val_addr);
5316 case dw_val_class_loc:
5317 size = size_of_locs (a->dw_attr_val.v.val_loc);
5319 /* Output the block length for this list of location operations. */
5320 switch (constant_size (size))
5323 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, size);
5326 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, size);
5333 fprintf (asm_out_file, "\t%s %s",
5334 ASM_COMMENT_START, dwarf_attr_name (a->dw_attr));
5336 fputc ('\n', asm_out_file);
5337 for (loc = a->dw_attr_val.v.val_loc; loc != NULL;
5338 loc = loc->dw_loc_next)
5340 /* Output the opcode. */
5341 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, loc->dw_loc_opc);
5343 fprintf (asm_out_file, "\t%s %s", ASM_COMMENT_START,
5344 dwarf_stack_op_name (loc->dw_loc_opc));
5346 fputc ('\n', asm_out_file);
5348 /* Output the operand(s) (if any). */
5349 output_loc_operands (loc);
5353 case dw_val_class_const:
5354 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, a->dw_attr_val.v.val_int);
5357 case dw_val_class_unsigned_const:
5358 switch (constant_size (a->dw_attr_val.v.val_unsigned))
5361 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
5362 a->dw_attr_val.v.val_unsigned);
5365 ASM_OUTPUT_DWARF_DATA2 (asm_out_file,
5366 a->dw_attr_val.v.val_unsigned);
5369 ASM_OUTPUT_DWARF_DATA4 (asm_out_file,
5370 a->dw_attr_val.v.val_unsigned);
5373 ASM_OUTPUT_DWARF_DATA8 (asm_out_file,
5374 a->dw_attr_val.v.val_long_long.hi,
5375 a->dw_attr_val.v.val_long_long.low);
5382 case dw_val_class_long_long:
5383 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 8);
5385 fprintf (asm_out_file, "\t%s %s",
5386 ASM_COMMENT_START, dwarf_attr_name (a->dw_attr));
5388 fputc ('\n', asm_out_file);
5389 ASM_OUTPUT_DWARF_DATA8 (asm_out_file,
5390 a->dw_attr_val.v.val_long_long.hi,
5391 a->dw_attr_val.v.val_long_long.low);
5394 fprintf (asm_out_file,
5395 "\t%s long long constant", ASM_COMMENT_START);
5397 fputc ('\n', asm_out_file);
5400 case dw_val_class_float:
5402 register unsigned int i;
5403 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
5404 a->dw_attr_val.v.val_float.length * 4);
5406 fprintf (asm_out_file, "\t%s %s",
5407 ASM_COMMENT_START, dwarf_attr_name (a->dw_attr));
5409 fputc ('\n', asm_out_file);
5410 for (i = 0; i < a->dw_attr_val.v.val_float.length; ++i)
5412 ASM_OUTPUT_DWARF_DATA4 (asm_out_file,
5413 a->dw_attr_val.v.val_float.array[i]);
5415 fprintf (asm_out_file, "\t%s fp constant word %u",
5416 ASM_COMMENT_START, i);
5418 fputc ('\n', asm_out_file);
5423 case dw_val_class_flag:
5424 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, a->dw_attr_val.v.val_flag);
5427 case dw_val_class_die_ref:
5428 if (a->dw_attr_val.v.val_die_ref != NULL)
5429 ref_offset = a->dw_attr_val.v.val_die_ref->die_offset;
5430 else if (a->dw_attr == DW_AT_sibling)
5431 ref_offset = sibling_offset(die);
5435 ASM_OUTPUT_DWARF_DATA (asm_out_file, ref_offset);
5438 case dw_val_class_fde_ref:
5441 ASM_GENERATE_INTERNAL_LABEL
5442 (l1, FDE_AFTER_SIZE_LABEL, a->dw_attr_val.v.val_fde_index * 2);
5443 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, l1);
5444 fprintf (asm_out_file, " - %d", DWARF_OFFSET_SIZE);
5448 case dw_val_class_lbl_id:
5449 ASM_OUTPUT_DWARF_ADDR (asm_out_file, a->dw_attr_val.v.val_lbl_id);
5452 case dw_val_class_lbl_offset:
5453 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, a->dw_attr_val.v.val_lbl_id);
5456 case dw_val_class_str:
5458 ASM_OUTPUT_DWARF_STRING (asm_out_file, a->dw_attr_val.v.val_str);
5460 ASM_OUTPUT_ASCII (asm_out_file,
5461 a->dw_attr_val.v.val_str,
5462 (int) strlen (a->dw_attr_val.v.val_str) + 1);
5469 if (a->dw_attr_val.val_class != dw_val_class_loc
5470 && a->dw_attr_val.val_class != dw_val_class_long_long
5471 && a->dw_attr_val.val_class != dw_val_class_float)
5474 fprintf (asm_out_file, "\t%s %s",
5475 ASM_COMMENT_START, dwarf_attr_name (a->dw_attr));
5477 fputc ('\n', asm_out_file);
5481 for (c = die->die_child; c != NULL; c = c->die_sib)
5484 if (die->die_child != NULL)
5486 /* Add null byte to terminate sibling list. */
5487 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5489 fprintf (asm_out_file, "\t%s end of children of DIE 0x%lx",
5490 ASM_COMMENT_START, die->die_offset);
5492 fputc ('\n', asm_out_file);
5496 /* Output the compilation unit that appears at the beginning of the
5497 .debug_info section, and precedes the DIE descriptions. */
5500 output_compilation_unit_header ()
5502 ASM_OUTPUT_DWARF_DATA (asm_out_file, next_die_offset - DWARF_OFFSET_SIZE);
5504 fprintf (asm_out_file, "\t%s Length of Compilation Unit Info.",
5507 fputc ('\n', asm_out_file);
5508 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, DWARF_VERSION);
5510 fprintf (asm_out_file, "\t%s DWARF version number", ASM_COMMENT_START);
5512 fputc ('\n', asm_out_file);
5513 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, abbrev_section_label);
5515 fprintf (asm_out_file, "\t%s Offset Into Abbrev. Section",
5518 fputc ('\n', asm_out_file);
5519 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, PTR_SIZE);
5521 fprintf (asm_out_file, "\t%s Pointer Size (in bytes)", ASM_COMMENT_START);
5523 fputc ('\n', asm_out_file);
5526 /* The DWARF2 pubname for a nested thingy looks like "A::f". The output
5527 of decl_printable_name for C++ looks like "A::f(int)". Let's drop the
5528 argument list, and maybe the scope. */
5531 dwarf2_name (decl, scope)
5535 return (*decl_printable_name) (decl, scope ? 1 : 0);
5538 /* Add a new entry to .debug_pubnames if appropriate. */
5541 add_pubname (decl, die)
5547 if (! TREE_PUBLIC (decl))
5550 if (pubname_table_in_use == pubname_table_allocated)
5552 pubname_table_allocated += PUBNAME_TABLE_INCREMENT;
5553 pubname_table = (pubname_ref) xrealloc
5554 (pubname_table, pubname_table_allocated * sizeof (pubname_entry));
5557 p = &pubname_table[pubname_table_in_use++];
5560 p->name = xstrdup (dwarf2_name (decl, 1));
5563 /* Output the public names table used to speed up access to externally
5564 visible names. For now, only generate entries for externally
5565 visible procedures. */
5570 register unsigned i;
5571 register unsigned long pubnames_length = size_of_pubnames ();
5573 ASM_OUTPUT_DWARF_DATA (asm_out_file, pubnames_length);
5576 fprintf (asm_out_file, "\t%s Length of Public Names Info.",
5579 fputc ('\n', asm_out_file);
5580 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, DWARF_VERSION);
5583 fprintf (asm_out_file, "\t%s DWARF Version", ASM_COMMENT_START);
5585 fputc ('\n', asm_out_file);
5586 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, debug_info_section_label);
5588 fprintf (asm_out_file, "\t%s Offset of Compilation Unit Info.",
5591 fputc ('\n', asm_out_file);
5592 ASM_OUTPUT_DWARF_DATA (asm_out_file, next_die_offset);
5594 fprintf (asm_out_file, "\t%s Compilation Unit Length", ASM_COMMENT_START);
5596 fputc ('\n', asm_out_file);
5597 for (i = 0; i < pubname_table_in_use; ++i)
5599 register pubname_ref pub = &pubname_table[i];
5601 ASM_OUTPUT_DWARF_DATA (asm_out_file, pub->die->die_offset);
5603 fprintf (asm_out_file, "\t%s DIE offset", ASM_COMMENT_START);
5605 fputc ('\n', asm_out_file);
5609 ASM_OUTPUT_DWARF_STRING (asm_out_file, pub->name);
5610 fprintf (asm_out_file, "%s external name", ASM_COMMENT_START);
5614 ASM_OUTPUT_ASCII (asm_out_file, pub->name,
5615 (int) strlen (pub->name) + 1);
5618 fputc ('\n', asm_out_file);
5621 ASM_OUTPUT_DWARF_DATA (asm_out_file, 0);
5622 fputc ('\n', asm_out_file);
5625 /* Add a new entry to .debug_aranges if appropriate. */
5628 add_arange (decl, die)
5632 if (! DECL_SECTION_NAME (decl))
5635 if (arange_table_in_use == arange_table_allocated)
5637 arange_table_allocated += ARANGE_TABLE_INCREMENT;
5639 = (arange_ref) xrealloc (arange_table,
5640 arange_table_allocated * sizeof (dw_die_ref));
5643 arange_table[arange_table_in_use++] = die;
5646 /* Output the information that goes into the .debug_aranges table.
5647 Namely, define the beginning and ending address range of the
5648 text section generated for this compilation unit. */
5653 register unsigned i;
5654 register unsigned long aranges_length = size_of_aranges ();
5656 ASM_OUTPUT_DWARF_DATA (asm_out_file, aranges_length);
5658 fprintf (asm_out_file, "\t%s Length of Address Ranges Info.",
5661 fputc ('\n', asm_out_file);
5662 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, DWARF_VERSION);
5664 fprintf (asm_out_file, "\t%s DWARF Version", ASM_COMMENT_START);
5666 fputc ('\n', asm_out_file);
5667 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, debug_info_section_label);
5669 fprintf (asm_out_file, "\t%s Offset of Compilation Unit Info.",
5672 fputc ('\n', asm_out_file);
5673 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, PTR_SIZE);
5675 fprintf (asm_out_file, "\t%s Size of Address", ASM_COMMENT_START);
5677 fputc ('\n', asm_out_file);
5678 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5680 fprintf (asm_out_file, "\t%s Size of Segment Descriptor",
5683 fputc ('\n', asm_out_file);
5684 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 4);
5686 fprintf (asm_out_file, ",0,0");
5689 fprintf (asm_out_file, "\t%s Pad to %d byte boundary",
5690 ASM_COMMENT_START, 2 * PTR_SIZE);
5692 fputc ('\n', asm_out_file);
5693 ASM_OUTPUT_DWARF_ADDR (asm_out_file, text_section_label);
5695 fprintf (asm_out_file, "\t%s Address", ASM_COMMENT_START);
5697 fputc ('\n', asm_out_file);
5698 ASM_OUTPUT_DWARF_ADDR_DELTA (asm_out_file, text_end_label,
5699 text_section_label);
5701 fprintf (asm_out_file, "%s Length", ASM_COMMENT_START);
5703 fputc ('\n', asm_out_file);
5704 for (i = 0; i < arange_table_in_use; ++i)
5706 dw_die_ref a = arange_table[i];
5708 if (a->die_tag == DW_TAG_subprogram)
5709 ASM_OUTPUT_DWARF_ADDR (asm_out_file, get_AT_low_pc (a));
5712 char *name = get_AT_string (a, DW_AT_MIPS_linkage_name);
5714 name = get_AT_string (a, DW_AT_name);
5716 ASM_OUTPUT_DWARF_ADDR (asm_out_file, name);
5720 fprintf (asm_out_file, "\t%s Address", ASM_COMMENT_START);
5722 fputc ('\n', asm_out_file);
5723 if (a->die_tag == DW_TAG_subprogram)
5724 ASM_OUTPUT_DWARF_ADDR_DELTA (asm_out_file, get_AT_hi_pc (a),
5727 ASM_OUTPUT_DWARF_ADDR_DATA (asm_out_file,
5728 get_AT_unsigned (a, DW_AT_byte_size));
5731 fprintf (asm_out_file, "%s Length", ASM_COMMENT_START);
5733 fputc ('\n', asm_out_file);
5736 /* Output the terminator words. */
5737 ASM_OUTPUT_DWARF_ADDR_DATA (asm_out_file, 0);
5738 fputc ('\n', asm_out_file);
5739 ASM_OUTPUT_DWARF_ADDR_DATA (asm_out_file, 0);
5740 fputc ('\n', asm_out_file);
5743 /* Output the source line number correspondence information. This
5744 information goes into the .debug_line section.
5746 If the format of this data changes, then the function size_of_line_info
5747 must also be adjusted the same way. */
5752 char line_label[MAX_ARTIFICIAL_LABEL_BYTES];
5753 char prev_line_label[MAX_ARTIFICIAL_LABEL_BYTES];
5754 register unsigned opc;
5755 register unsigned n_op_args;
5756 register unsigned long ft_index;
5757 register unsigned long lt_index;
5758 register unsigned long current_line;
5759 register long line_offset;
5760 register long line_delta;
5761 register unsigned long current_file;
5762 register unsigned long function;
5764 ASM_OUTPUT_DWARF_DATA (asm_out_file, size_of_line_info ());
5766 fprintf (asm_out_file, "\t%s Length of Source Line Info.",
5769 fputc ('\n', asm_out_file);
5770 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, DWARF_VERSION);
5772 fprintf (asm_out_file, "\t%s DWARF Version", ASM_COMMENT_START);
5774 fputc ('\n', asm_out_file);
5775 ASM_OUTPUT_DWARF_DATA (asm_out_file, size_of_line_prolog ());
5777 fprintf (asm_out_file, "\t%s Prolog Length", ASM_COMMENT_START);
5779 fputc ('\n', asm_out_file);
5780 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DWARF_LINE_MIN_INSTR_LENGTH);
5782 fprintf (asm_out_file, "\t%s Minimum Instruction Length",
5785 fputc ('\n', asm_out_file);
5786 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DWARF_LINE_DEFAULT_IS_STMT_START);
5788 fprintf (asm_out_file, "\t%s Default is_stmt_start flag",
5791 fputc ('\n', asm_out_file);
5792 fprintf (asm_out_file, "\t%s\t%d", ASM_BYTE_OP, DWARF_LINE_BASE);
5794 fprintf (asm_out_file, "\t%s Line Base Value (Special Opcodes)",
5797 fputc ('\n', asm_out_file);
5798 fprintf (asm_out_file, "\t%s\t%u", ASM_BYTE_OP, DWARF_LINE_RANGE);
5800 fprintf (asm_out_file, "\t%s Line Range Value (Special Opcodes)",
5803 fputc ('\n', asm_out_file);
5804 fprintf (asm_out_file, "\t%s\t%u", ASM_BYTE_OP, DWARF_LINE_OPCODE_BASE);
5806 fprintf (asm_out_file, "\t%s Special Opcode Base", ASM_COMMENT_START);
5808 fputc ('\n', asm_out_file);
5809 for (opc = 1; opc < DWARF_LINE_OPCODE_BASE; ++opc)
5813 case DW_LNS_advance_pc:
5814 case DW_LNS_advance_line:
5815 case DW_LNS_set_file:
5816 case DW_LNS_set_column:
5817 case DW_LNS_fixed_advance_pc:
5824 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, n_op_args);
5826 fprintf (asm_out_file, "\t%s opcode: 0x%x has %d args",
5827 ASM_COMMENT_START, opc, n_op_args);
5828 fputc ('\n', asm_out_file);
5832 fprintf (asm_out_file, "%s Include Directory Table\n", ASM_COMMENT_START);
5834 /* Include directory table is empty, at present */
5835 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5836 fputc ('\n', asm_out_file);
5838 fprintf (asm_out_file, "%s File Name Table\n", ASM_COMMENT_START);
5840 for (ft_index = 1; ft_index < file_table_in_use; ++ft_index)
5844 ASM_OUTPUT_DWARF_STRING (asm_out_file, file_table[ft_index]);
5845 fprintf (asm_out_file, "%s File Entry: 0x%lx",
5846 ASM_COMMENT_START, ft_index);
5850 ASM_OUTPUT_ASCII (asm_out_file,
5851 file_table[ft_index],
5852 (int) strlen (file_table[ft_index]) + 1);
5855 fputc ('\n', asm_out_file);
5857 /* Include directory index */
5859 fputc ('\n', asm_out_file);
5861 /* Modification time */
5863 fputc ('\n', asm_out_file);
5865 /* File length in bytes */
5867 fputc ('\n', asm_out_file);
5870 /* Terminate the file name table */
5871 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5872 fputc ('\n', asm_out_file);
5874 /* We used to set the address register to the first location in the text
5875 section here, but that didn't accomplish anything since we already
5876 have a line note for the opening brace of the first function. */
5878 /* Generate the line number to PC correspondence table, encoded as
5879 a series of state machine operations. */
5882 strcpy (prev_line_label, text_section_label);
5883 for (lt_index = 1; lt_index < line_info_table_in_use; ++lt_index)
5885 register dw_line_info_ref line_info = &line_info_table[lt_index];
5887 /* Don't emit anything for redundant notes. Just updating the
5888 address doesn't accomplish anything, because we already assume
5889 that anything after the last address is this line. */
5890 if (line_info->dw_line_num == current_line
5891 && line_info->dw_file_num == current_file)
5894 /* Emit debug info for the address of the current line, choosing
5895 the encoding that uses the least amount of space. */
5896 /* ??? Unfortunately, we have little choice here currently, and must
5897 always use the most general form. Gcc does not know the address
5898 delta itself, so we can't use DW_LNS_advance_pc. There are no known
5899 dwarf2 aware assemblers at this time, so we can't use any special
5900 pseudo ops that would allow the assembler to optimally encode this for
5901 us. Many ports do have length attributes which will give an upper
5902 bound on the address range. We could perhaps use length attributes
5903 to determine when it is safe to use DW_LNS_fixed_advance_pc. */
5904 ASM_GENERATE_INTERNAL_LABEL (line_label, LINE_CODE_LABEL, lt_index);
5907 /* This can handle deltas up to 0xffff. This takes 3 bytes. */
5908 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc);
5910 fprintf (asm_out_file, "\t%s DW_LNS_fixed_advance_pc",
5913 fputc ('\n', asm_out_file);
5914 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, line_label, prev_line_label);
5915 fputc ('\n', asm_out_file);
5919 /* This can handle any delta. This takes 4+PTR_SIZE bytes. */
5920 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5922 fprintf (asm_out_file, "\t%s DW_LNE_set_address",
5924 fputc ('\n', asm_out_file);
5925 output_uleb128 (1 + PTR_SIZE);
5926 fputc ('\n', asm_out_file);
5927 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address);
5928 fputc ('\n', asm_out_file);
5929 ASM_OUTPUT_DWARF_ADDR (asm_out_file, line_label);
5930 fputc ('\n', asm_out_file);
5932 strcpy (prev_line_label, line_label);
5934 /* Emit debug info for the source file of the current line, if
5935 different from the previous line. */
5936 if (line_info->dw_file_num != current_file)
5938 current_file = line_info->dw_file_num;
5939 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_set_file);
5941 fprintf (asm_out_file, "\t%s DW_LNS_set_file", ASM_COMMENT_START);
5943 fputc ('\n', asm_out_file);
5944 output_uleb128 (current_file);
5946 fprintf (asm_out_file, " (\"%s\")", file_table[current_file]);
5948 fputc ('\n', asm_out_file);
5951 /* Emit debug info for the current line number, choosing the encoding
5952 that uses the least amount of space. */
5953 if (line_info->dw_line_num != current_line)
5955 line_offset = line_info->dw_line_num - current_line;
5956 line_delta = line_offset - DWARF_LINE_BASE;
5957 current_line = line_info->dw_line_num;
5958 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
5960 /* This can handle deltas from -10 to 234, using the current
5961 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE. This
5963 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
5964 DWARF_LINE_OPCODE_BASE + line_delta);
5966 fprintf (asm_out_file,
5967 "\t%s line %ld", ASM_COMMENT_START, current_line);
5969 fputc ('\n', asm_out_file);
5973 /* This can handle any delta. This takes at least 4 bytes,
5974 depending on the value being encoded. */
5975 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_advance_line);
5977 fprintf (asm_out_file, "\t%s advance to line %ld",
5978 ASM_COMMENT_START, current_line);
5980 fputc ('\n', asm_out_file);
5981 output_sleb128 (line_offset);
5982 fputc ('\n', asm_out_file);
5983 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_copy);
5985 fprintf (asm_out_file, "\t%s DW_LNS_copy", ASM_COMMENT_START);
5986 fputc ('\n', asm_out_file);
5991 /* We still need to start a new row, so output a copy insn. */
5992 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_copy);
5994 fprintf (asm_out_file, "\t%s DW_LNS_copy", ASM_COMMENT_START);
5995 fputc ('\n', asm_out_file);
5999 /* Emit debug info for the address of the end of the function. */
6002 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc);
6004 fprintf (asm_out_file, "\t%s DW_LNS_fixed_advance_pc",
6007 fputc ('\n', asm_out_file);
6008 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, text_end_label, prev_line_label);
6009 fputc ('\n', asm_out_file);
6013 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
6015 fprintf (asm_out_file, "\t%s DW_LNE_set_address", ASM_COMMENT_START);
6016 fputc ('\n', asm_out_file);
6017 output_uleb128 (1 + PTR_SIZE);
6018 fputc ('\n', asm_out_file);
6019 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address);
6020 fputc ('\n', asm_out_file);
6021 ASM_OUTPUT_DWARF_ADDR (asm_out_file, text_end_label);
6022 fputc ('\n', asm_out_file);
6025 /* Output the marker for the end of the line number info. */
6026 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
6028 fprintf (asm_out_file, "\t%s DW_LNE_end_sequence", ASM_COMMENT_START);
6030 fputc ('\n', asm_out_file);
6032 fputc ('\n', asm_out_file);
6033 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_end_sequence);
6034 fputc ('\n', asm_out_file);
6039 for (lt_index = 0; lt_index < separate_line_info_table_in_use; )
6041 register dw_separate_line_info_ref line_info
6042 = &separate_line_info_table[lt_index];
6044 /* Don't emit anything for redundant notes. */
6045 if (line_info->dw_line_num == current_line
6046 && line_info->dw_file_num == current_file
6047 && line_info->function == function)
6050 /* Emit debug info for the address of the current line. If this is
6051 a new function, or the first line of a function, then we need
6052 to handle it differently. */
6053 ASM_GENERATE_INTERNAL_LABEL (line_label, SEPARATE_LINE_CODE_LABEL,
6055 if (function != line_info->function)
6057 function = line_info->function;
6059 /* Set the address register to the first line in the function */
6060 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
6062 fprintf (asm_out_file, "\t%s DW_LNE_set_address",
6065 fputc ('\n', asm_out_file);
6066 output_uleb128 (1 + PTR_SIZE);
6067 fputc ('\n', asm_out_file);
6068 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address);
6069 fputc ('\n', asm_out_file);
6070 ASM_OUTPUT_DWARF_ADDR (asm_out_file, line_label);
6071 fputc ('\n', asm_out_file);
6075 /* ??? See the DW_LNS_advance_pc comment above. */
6078 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc);
6080 fprintf (asm_out_file, "\t%s DW_LNS_fixed_advance_pc",
6083 fputc ('\n', asm_out_file);
6084 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, line_label,
6086 fputc ('\n', asm_out_file);
6090 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
6092 fprintf (asm_out_file, "\t%s DW_LNE_set_address",
6094 fputc ('\n', asm_out_file);
6095 output_uleb128 (1 + PTR_SIZE);
6096 fputc ('\n', asm_out_file);
6097 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address);
6098 fputc ('\n', asm_out_file);
6099 ASM_OUTPUT_DWARF_ADDR (asm_out_file, line_label);
6100 fputc ('\n', asm_out_file);
6103 strcpy (prev_line_label, line_label);
6105 /* Emit debug info for the source file of the current line, if
6106 different from the previous line. */
6107 if (line_info->dw_file_num != current_file)
6109 current_file = line_info->dw_file_num;
6110 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_set_file);
6112 fprintf (asm_out_file, "\t%s DW_LNS_set_file", ASM_COMMENT_START);
6114 fputc ('\n', asm_out_file);
6115 output_uleb128 (current_file);
6117 fprintf (asm_out_file, " (\"%s\")", file_table[current_file]);
6119 fputc ('\n', asm_out_file);
6122 /* Emit debug info for the current line number, choosing the encoding
6123 that uses the least amount of space. */
6124 if (line_info->dw_line_num != current_line)
6126 line_offset = line_info->dw_line_num - current_line;
6127 line_delta = line_offset - DWARF_LINE_BASE;
6128 current_line = line_info->dw_line_num;
6129 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
6131 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
6132 DWARF_LINE_OPCODE_BASE + line_delta);
6134 fprintf (asm_out_file,
6135 "\t%s line %ld", ASM_COMMENT_START, current_line);
6137 fputc ('\n', asm_out_file);
6141 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_advance_line);
6143 fprintf (asm_out_file, "\t%s advance to line %ld",
6144 ASM_COMMENT_START, current_line);
6146 fputc ('\n', asm_out_file);
6147 output_sleb128 (line_offset);
6148 fputc ('\n', asm_out_file);
6149 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_copy);
6151 fprintf (asm_out_file, "\t%s DW_LNS_copy", ASM_COMMENT_START);
6152 fputc ('\n', asm_out_file);
6157 /* We still need to start a new row, so output a copy insn. */
6158 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_copy);
6160 fprintf (asm_out_file, "\t%s DW_LNS_copy", ASM_COMMENT_START);
6161 fputc ('\n', asm_out_file);
6167 /* If we're done with a function, end its sequence. */
6168 if (lt_index == separate_line_info_table_in_use
6169 || separate_line_info_table[lt_index].function != function)
6174 /* Emit debug info for the address of the end of the function. */
6175 ASM_GENERATE_INTERNAL_LABEL (line_label, FUNC_END_LABEL, function);
6178 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc);
6180 fprintf (asm_out_file, "\t%s DW_LNS_fixed_advance_pc",
6183 fputc ('\n', asm_out_file);
6184 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, line_label,
6186 fputc ('\n', asm_out_file);
6190 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
6192 fprintf (asm_out_file, "\t%s DW_LNE_set_address",
6194 fputc ('\n', asm_out_file);
6195 output_uleb128 (1 + PTR_SIZE);
6196 fputc ('\n', asm_out_file);
6197 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address);
6198 fputc ('\n', asm_out_file);
6199 ASM_OUTPUT_DWARF_ADDR (asm_out_file, line_label);
6200 fputc ('\n', asm_out_file);
6203 /* Output the marker for the end of this sequence. */
6204 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
6206 fprintf (asm_out_file, "\t%s DW_LNE_end_sequence",
6209 fputc ('\n', asm_out_file);
6211 fputc ('\n', asm_out_file);
6212 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_end_sequence);
6213 fputc ('\n', asm_out_file);
6218 /* Given a pointer to a BLOCK node return non-zero if (and only if) the node
6219 in question represents the outermost pair of curly braces (i.e. the "body
6220 block") of a function or method.
6222 For any BLOCK node representing a "body block" of a function or method, the
6223 BLOCK_SUPERCONTEXT of the node will point to another BLOCK node which
6224 represents the outermost (function) scope for the function or method (i.e.
6225 the one which includes the formal parameters). The BLOCK_SUPERCONTEXT of
6226 *that* node in turn will point to the relevant FUNCTION_DECL node. */
6229 is_body_block (stmt)
6232 if (TREE_CODE (stmt) == BLOCK)
6234 register tree parent = BLOCK_SUPERCONTEXT (stmt);
6236 if (TREE_CODE (parent) == BLOCK)
6238 register tree grandparent = BLOCK_SUPERCONTEXT (parent);
6240 if (TREE_CODE (grandparent) == FUNCTION_DECL)
6248 /* Given a pointer to a tree node for some base type, return a pointer to
6249 a DIE that describes the given type.
6251 This routine must only be called for GCC type nodes that correspond to
6252 Dwarf base (fundamental) types. */
6255 base_type_die (type)
6258 register dw_die_ref base_type_result;
6259 register char *type_name;
6260 register enum dwarf_type encoding;
6261 register tree name = TYPE_NAME (type);
6263 if (TREE_CODE (type) == ERROR_MARK
6264 || TREE_CODE (type) == VOID_TYPE)
6267 if (TREE_CODE (name) == TYPE_DECL)
6268 name = DECL_NAME (name);
6269 type_name = IDENTIFIER_POINTER (name);
6271 switch (TREE_CODE (type))
6274 /* Carefully distinguish the C character types, without messing
6275 up if the language is not C. Note that we check only for the names
6276 that contain spaces; other names might occur by coincidence in other
6278 if (! (TYPE_PRECISION (type) == CHAR_TYPE_SIZE
6279 && (type == char_type_node
6280 || ! strcmp (type_name, "signed char")
6281 || ! strcmp (type_name, "unsigned char"))))
6283 if (TREE_UNSIGNED (type))
6284 encoding = DW_ATE_unsigned;
6286 encoding = DW_ATE_signed;
6289 /* else fall through */
6292 /* GNU Pascal/Ada CHAR type. Not used in C. */
6293 if (TREE_UNSIGNED (type))
6294 encoding = DW_ATE_unsigned_char;
6296 encoding = DW_ATE_signed_char;
6300 encoding = DW_ATE_float;
6304 encoding = DW_ATE_complex_float;
6308 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */
6309 encoding = DW_ATE_boolean;
6313 abort (); /* No other TREE_CODEs are Dwarf fundamental types. */
6316 base_type_result = new_die (DW_TAG_base_type, comp_unit_die);
6317 add_AT_string (base_type_result, DW_AT_name, type_name);
6318 add_AT_unsigned (base_type_result, DW_AT_byte_size,
6319 int_size_in_bytes (type));
6320 add_AT_unsigned (base_type_result, DW_AT_encoding, encoding);
6322 return base_type_result;
6325 /* Given a pointer to an arbitrary ..._TYPE tree node, return a pointer to
6326 the Dwarf "root" type for the given input type. The Dwarf "root" type of
6327 a given type is generally the same as the given type, except that if the
6328 given type is a pointer or reference type, then the root type of the given
6329 type is the root type of the "basis" type for the pointer or reference
6330 type. (This definition of the "root" type is recursive.) Also, the root
6331 type of a `const' qualified type or a `volatile' qualified type is the
6332 root type of the given type without the qualifiers. */
6338 if (TREE_CODE (type) == ERROR_MARK)
6339 return error_mark_node;
6341 switch (TREE_CODE (type))
6344 return error_mark_node;
6347 case REFERENCE_TYPE:
6348 return type_main_variant (root_type (TREE_TYPE (type)));
6351 return type_main_variant (type);
6355 /* Given a pointer to an arbitrary ..._TYPE tree node, return non-zero if the
6356 given input type is a Dwarf "fundamental" type. Otherwise return null. */
6362 switch (TREE_CODE (type))
6377 case QUAL_UNION_TYPE:
6382 case REFERENCE_TYPE:
6395 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
6396 entry that chains various modifiers in front of the given type. */
6399 modified_type_die (type, is_const_type, is_volatile_type, context_die)
6401 register int is_const_type;
6402 register int is_volatile_type;
6403 register dw_die_ref context_die;
6405 register enum tree_code code = TREE_CODE (type);
6406 register dw_die_ref mod_type_die = NULL;
6407 register dw_die_ref sub_die = NULL;
6408 register tree item_type = NULL;
6410 if (code != ERROR_MARK)
6412 type = build_type_variant (type, is_const_type, is_volatile_type);
6414 mod_type_die = lookup_type_die (type);
6416 return mod_type_die;
6418 /* Handle C typedef types. */
6419 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
6420 && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
6422 tree dtype = TREE_TYPE (TYPE_NAME (type));
6425 /* For a named type, use the typedef. */
6426 gen_type_die (type, context_die);
6427 mod_type_die = lookup_type_die (type);
6430 else if (is_const_type < TYPE_READONLY (dtype)
6431 || is_volatile_type < TYPE_VOLATILE (dtype))
6432 /* cv-unqualified version of named type. Just use the unnamed
6433 type to which it refers. */
6435 = modified_type_die (DECL_ORIGINAL_TYPE (TYPE_NAME (type)),
6436 is_const_type, is_volatile_type,
6438 /* Else cv-qualified version of named type; fall through. */
6443 else if (is_const_type)
6445 mod_type_die = new_die (DW_TAG_const_type, comp_unit_die);
6446 sub_die = modified_type_die (type, 0, is_volatile_type, context_die);
6448 else if (is_volatile_type)
6450 mod_type_die = new_die (DW_TAG_volatile_type, comp_unit_die);
6451 sub_die = modified_type_die (type, 0, 0, context_die);
6453 else if (code == POINTER_TYPE)
6455 mod_type_die = new_die (DW_TAG_pointer_type, comp_unit_die);
6456 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
6458 add_AT_unsigned (mod_type_die, DW_AT_address_class, 0);
6460 item_type = TREE_TYPE (type);
6462 else if (code == REFERENCE_TYPE)
6464 mod_type_die = new_die (DW_TAG_reference_type, comp_unit_die);
6465 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
6467 add_AT_unsigned (mod_type_die, DW_AT_address_class, 0);
6469 item_type = TREE_TYPE (type);
6471 else if (is_base_type (type))
6472 mod_type_die = base_type_die (type);
6475 gen_type_die (type, context_die);
6477 /* We have to get the type_main_variant here (and pass that to the
6478 `lookup_type_die' routine) because the ..._TYPE node we have
6479 might simply be a *copy* of some original type node (where the
6480 copy was created to help us keep track of typedef names) and
6481 that copy might have a different TYPE_UID from the original
6483 mod_type_die = lookup_type_die (type_main_variant (type));
6484 if (mod_type_die == NULL)
6489 equate_type_number_to_die (type, mod_type_die);
6491 /* We must do this after the equate_type_number_to_die call, in case
6492 this is a recursive type. This ensures that the modified_type_die
6493 recursion will terminate even if the type is recursive. Recursive
6494 types are possible in Ada. */
6495 sub_die = modified_type_die (item_type,
6496 TYPE_READONLY (item_type),
6497 TYPE_VOLATILE (item_type),
6500 if (sub_die != NULL)
6501 add_AT_die_ref (mod_type_die, DW_AT_type, sub_die);
6503 return mod_type_die;
6506 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
6507 an enumerated type. */
6513 return TREE_CODE (type) == ENUMERAL_TYPE;
6516 /* Return a location descriptor that designates a machine register. */
6518 static dw_loc_descr_ref
6519 reg_loc_descriptor (rtl)
6522 register dw_loc_descr_ref loc_result = NULL;
6523 register unsigned reg = reg_number (rtl);
6526 loc_result = new_loc_descr (DW_OP_reg0 + reg, 0, 0);
6528 loc_result = new_loc_descr (DW_OP_regx, reg, 0);
6533 /* Return a location descriptor that designates a base+offset location. */
6535 static dw_loc_descr_ref
6536 based_loc_descr (reg, offset)
6540 register dw_loc_descr_ref loc_result;
6541 /* For the "frame base", we use the frame pointer or stack pointer
6542 registers, since the RTL for local variables is relative to one of
6544 register unsigned fp_reg = DBX_REGISTER_NUMBER (frame_pointer_needed
6545 ? HARD_FRAME_POINTER_REGNUM
6546 : STACK_POINTER_REGNUM);
6549 loc_result = new_loc_descr (DW_OP_fbreg, offset, 0);
6551 loc_result = new_loc_descr (DW_OP_breg0 + reg, offset, 0);
6553 loc_result = new_loc_descr (DW_OP_bregx, reg, offset);
6558 /* Return true if this RTL expression describes a base+offset calculation. */
6564 return (GET_CODE (rtl) == PLUS
6565 && ((GET_CODE (XEXP (rtl, 0)) == REG
6566 && GET_CODE (XEXP (rtl, 1)) == CONST_INT)));
6569 /* The following routine converts the RTL for a variable or parameter
6570 (resident in memory) into an equivalent Dwarf representation of a
6571 mechanism for getting the address of that same variable onto the top of a
6572 hypothetical "address evaluation" stack.
6574 When creating memory location descriptors, we are effectively transforming
6575 the RTL for a memory-resident object into its Dwarf postfix expression
6576 equivalent. This routine recursively descends an RTL tree, turning
6577 it into Dwarf postfix code as it goes. */
6579 static dw_loc_descr_ref
6580 mem_loc_descriptor (rtl)
6583 dw_loc_descr_ref mem_loc_result = NULL;
6584 /* Note that for a dynamically sized array, the location we will generate a
6585 description of here will be the lowest numbered location which is
6586 actually within the array. That's *not* necessarily the same as the
6587 zeroth element of the array. */
6589 switch (GET_CODE (rtl))
6592 /* The case of a subreg may arise when we have a local (register)
6593 variable or a formal (register) parameter which doesn't quite fill
6594 up an entire register. For now, just assume that it is
6595 legitimate to make the Dwarf info refer to the whole register which
6596 contains the given subreg. */
6597 rtl = XEXP (rtl, 0);
6599 /* ... fall through ... */
6602 /* Whenever a register number forms a part of the description of the
6603 method for calculating the (dynamic) address of a memory resident
6604 object, DWARF rules require the register number be referred to as
6605 a "base register". This distinction is not based in any way upon
6606 what category of register the hardware believes the given register
6607 belongs to. This is strictly DWARF terminology we're dealing with
6608 here. Note that in cases where the location of a memory-resident
6609 data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
6610 OP_CONST (0)) the actual DWARF location descriptor that we generate
6611 may just be OP_BASEREG (basereg). This may look deceptively like
6612 the object in question was allocated to a register (rather than in
6613 memory) so DWARF consumers need to be aware of the subtle
6614 distinction between OP_REG and OP_BASEREG. */
6615 mem_loc_result = based_loc_descr (reg_number (rtl), 0);
6619 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0));
6620 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_deref, 0, 0));
6625 mem_loc_result = new_loc_descr (DW_OP_addr, 0, 0);
6626 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_addr;
6627 mem_loc_result->dw_loc_oprnd1.v.val_addr = addr_to_string (rtl);
6631 if (is_based_loc (rtl))
6632 mem_loc_result = based_loc_descr (reg_number (XEXP (rtl, 0)),
6633 INTVAL (XEXP (rtl, 1)));
6636 add_loc_descr (&mem_loc_result, mem_loc_descriptor (XEXP (rtl, 0)));
6637 add_loc_descr (&mem_loc_result, mem_loc_descriptor (XEXP (rtl, 1)));
6638 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_plus, 0, 0));
6643 /* If a pseudo-reg is optimized away, it is possible for it to
6644 be replaced with a MEM containing a multiply. */
6645 add_loc_descr (&mem_loc_result, mem_loc_descriptor (XEXP (rtl, 0)));
6646 add_loc_descr (&mem_loc_result, mem_loc_descriptor (XEXP (rtl, 1)));
6647 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_mul, 0, 0));
6651 mem_loc_result = new_loc_descr (DW_OP_constu, INTVAL (rtl), 0);
6658 return mem_loc_result;
6661 /* Return a descriptor that describes the concatenation of two locations.
6662 This is typically a complex variable. */
6664 static dw_loc_descr_ref
6665 concat_loc_descriptor (x0, x1)
6666 register rtx x0, x1;
6668 dw_loc_descr_ref cc_loc_result = NULL;
6670 if (!is_pseudo_reg (x0)
6671 && (GET_CODE (x0) != MEM || !is_pseudo_reg (XEXP (x0, 0))))
6672 add_loc_descr (&cc_loc_result, loc_descriptor (x0));
6673 add_loc_descr (&cc_loc_result,
6674 new_loc_descr (DW_OP_piece, GET_MODE_SIZE (GET_MODE (x0)), 0));
6676 if (!is_pseudo_reg (x1)
6677 && (GET_CODE (x1) != MEM || !is_pseudo_reg (XEXP (x1, 0))))
6678 add_loc_descr (&cc_loc_result, loc_descriptor (x1));
6679 add_loc_descr (&cc_loc_result,
6680 new_loc_descr (DW_OP_piece, GET_MODE_SIZE (GET_MODE (x1)), 0));
6682 return cc_loc_result;
6685 /* Output a proper Dwarf location descriptor for a variable or parameter
6686 which is either allocated in a register or in a memory location. For a
6687 register, we just generate an OP_REG and the register number. For a
6688 memory location we provide a Dwarf postfix expression describing how to
6689 generate the (dynamic) address of the object onto the address stack. */
6691 static dw_loc_descr_ref
6692 loc_descriptor (rtl)
6695 dw_loc_descr_ref loc_result = NULL;
6696 switch (GET_CODE (rtl))
6699 /* The case of a subreg may arise when we have a local (register)
6700 variable or a formal (register) parameter which doesn't quite fill
6701 up an entire register. For now, just assume that it is
6702 legitimate to make the Dwarf info refer to the whole register which
6703 contains the given subreg. */
6704 rtl = XEXP (rtl, 0);
6706 /* ... fall through ... */
6709 loc_result = reg_loc_descriptor (rtl);
6713 loc_result = mem_loc_descriptor (XEXP (rtl, 0));
6717 loc_result = concat_loc_descriptor (XEXP (rtl, 0), XEXP (rtl, 1));
6727 /* Given an unsigned value, round it up to the lowest multiple of `boundary'
6728 which is not less than the value itself. */
6730 static inline unsigned
6731 ceiling (value, boundary)
6732 register unsigned value;
6733 register unsigned boundary;
6735 return (((value + boundary - 1) / boundary) * boundary);
6738 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
6739 pointer to the declared type for the relevant field variable, or return
6740 `integer_type_node' if the given node turns out to be an
6749 if (TREE_CODE (decl) == ERROR_MARK)
6750 return integer_type_node;
6752 type = DECL_BIT_FIELD_TYPE (decl);
6753 if (type == NULL_TREE)
6754 type = TREE_TYPE (decl);
6759 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
6760 node, return the alignment in bits for the type, or else return
6761 BITS_PER_WORD if the node actually turns out to be an
6764 static inline unsigned
6765 simple_type_align_in_bits (type)
6768 return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD;
6771 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
6772 node, return the size in bits for the type if it is a constant, or else
6773 return the alignment for the type if the type's size is not constant, or
6774 else return BITS_PER_WORD if the type actually turns out to be an
6777 static inline unsigned
6778 simple_type_size_in_bits (type)
6781 if (TREE_CODE (type) == ERROR_MARK)
6782 return BITS_PER_WORD;
6785 register tree type_size_tree = TYPE_SIZE (type);
6787 if (TREE_CODE (type_size_tree) != INTEGER_CST)
6788 return TYPE_ALIGN (type);
6790 return (unsigned) TREE_INT_CST_LOW (type_size_tree);
6794 /* Given a pointer to what is assumed to be a FIELD_DECL node, compute and
6795 return the byte offset of the lowest addressed byte of the "containing
6796 object" for the given FIELD_DECL, or return 0 if we are unable to
6797 determine what that offset is, either because the argument turns out to
6798 be a pointer to an ERROR_MARK node, or because the offset is actually
6799 variable. (We can't handle the latter case just yet). */
6802 field_byte_offset (decl)
6805 register unsigned type_align_in_bytes;
6806 register unsigned type_align_in_bits;
6807 register unsigned type_size_in_bits;
6808 register unsigned object_offset_in_align_units;
6809 register unsigned object_offset_in_bits;
6810 register unsigned object_offset_in_bytes;
6812 register tree bitpos_tree;
6813 register tree field_size_tree;
6814 register unsigned bitpos_int;
6815 register unsigned deepest_bitpos;
6816 register unsigned field_size_in_bits;
6818 if (TREE_CODE (decl) == ERROR_MARK)
6821 if (TREE_CODE (decl) != FIELD_DECL)
6824 type = field_type (decl);
6826 bitpos_tree = DECL_FIELD_BITPOS (decl);
6827 field_size_tree = DECL_SIZE (decl);
6829 /* We cannot yet cope with fields whose positions or sizes are variable, so
6830 for now, when we see such things, we simply return 0. Someday, we may
6831 be able to handle such cases, but it will be damn difficult. */
6832 if (TREE_CODE (bitpos_tree) != INTEGER_CST)
6834 bitpos_int = (unsigned) TREE_INT_CST_LOW (bitpos_tree);
6836 if (TREE_CODE (field_size_tree) != INTEGER_CST)
6839 field_size_in_bits = (unsigned) TREE_INT_CST_LOW (field_size_tree);
6840 type_size_in_bits = simple_type_size_in_bits (type);
6841 type_align_in_bits = simple_type_align_in_bits (type);
6842 type_align_in_bytes = type_align_in_bits / BITS_PER_UNIT;
6844 /* Note that the GCC front-end doesn't make any attempt to keep track of
6845 the starting bit offset (relative to the start of the containing
6846 structure type) of the hypothetical "containing object" for a bit-
6847 field. Thus, when computing the byte offset value for the start of the
6848 "containing object" of a bit-field, we must deduce this information on
6849 our own. This can be rather tricky to do in some cases. For example,
6850 handling the following structure type definition when compiling for an
6851 i386/i486 target (which only aligns long long's to 32-bit boundaries)
6854 struct S { int field1; long long field2:31; };
6856 Fortunately, there is a simple rule-of-thumb which can be
6857 used in such cases. When compiling for an i386/i486, GCC will allocate
6858 8 bytes for the structure shown above. It decides to do this based upon
6859 one simple rule for bit-field allocation. Quite simply, GCC allocates
6860 each "containing object" for each bit-field at the first (i.e. lowest
6861 addressed) legitimate alignment boundary (based upon the required
6862 minimum alignment for the declared type of the field) which it can
6863 possibly use, subject to the condition that there is still enough
6864 available space remaining in the containing object (when allocated at
6865 the selected point) to fully accommodate all of the bits of the
6866 bit-field itself. This simple rule makes it obvious why GCC allocates
6867 8 bytes for each object of the structure type shown above. When looking
6868 for a place to allocate the "containing object" for `field2', the
6869 compiler simply tries to allocate a 64-bit "containing object" at each
6870 successive 32-bit boundary (starting at zero) until it finds a place to
6871 allocate that 64- bit field such that at least 31 contiguous (and
6872 previously unallocated) bits remain within that selected 64 bit field.
6873 (As it turns out, for the example above, the compiler finds that it is
6874 OK to allocate the "containing object" 64-bit field at bit-offset zero
6875 within the structure type.) Here we attempt to work backwards from the
6876 limited set of facts we're given, and we try to deduce from those facts,
6877 where GCC must have believed that the containing object started (within
6878 the structure type). The value we deduce is then used (by the callers of
6879 this routine) to generate DW_AT_location and DW_AT_bit_offset attributes
6880 for fields (both bit-fields and, in the case of DW_AT_location, regular
6883 /* Figure out the bit-distance from the start of the structure to the
6884 "deepest" bit of the bit-field. */
6885 deepest_bitpos = bitpos_int + field_size_in_bits;
6887 /* This is the tricky part. Use some fancy footwork to deduce where the
6888 lowest addressed bit of the containing object must be. */
6889 object_offset_in_bits
6890 = ceiling (deepest_bitpos, type_align_in_bits) - type_size_in_bits;
6892 /* Compute the offset of the containing object in "alignment units". */
6893 object_offset_in_align_units = object_offset_in_bits / type_align_in_bits;
6895 /* Compute the offset of the containing object in bytes. */
6896 object_offset_in_bytes = object_offset_in_align_units * type_align_in_bytes;
6898 return object_offset_in_bytes;
6901 /* The following routines define various Dwarf attributes and any data
6902 associated with them. */
6904 /* Add a location description attribute value to a DIE.
6906 This emits location attributes suitable for whole variables and
6907 whole parameters. Note that the location attributes for struct fields are
6908 generated by the routine `data_member_location_attribute' below. */
6911 add_AT_location_description (die, attr_kind, rtl)
6913 enum dwarf_attribute attr_kind;
6916 /* Handle a special case. If we are about to output a location descriptor
6917 for a variable or parameter which has been optimized out of existence,
6918 don't do that. A variable which has been optimized out
6919 of existence will have a DECL_RTL value which denotes a pseudo-reg.
6920 Currently, in some rare cases, variables can have DECL_RTL values which
6921 look like (MEM (REG pseudo-reg#)). These cases are due to bugs
6922 elsewhere in the compiler. We treat such cases as if the variable(s) in
6923 question had been optimized out of existence. */
6925 if (is_pseudo_reg (rtl)
6926 || (GET_CODE (rtl) == MEM
6927 && is_pseudo_reg (XEXP (rtl, 0)))
6928 || (GET_CODE (rtl) == CONCAT
6929 && is_pseudo_reg (XEXP (rtl, 0))
6930 && is_pseudo_reg (XEXP (rtl, 1))))
6933 add_AT_loc (die, attr_kind, loc_descriptor (rtl));
6936 /* Attach the specialized form of location attribute used for data
6937 members of struct and union types. In the special case of a
6938 FIELD_DECL node which represents a bit-field, the "offset" part
6939 of this special location descriptor must indicate the distance
6940 in bytes from the lowest-addressed byte of the containing struct
6941 or union type to the lowest-addressed byte of the "containing
6942 object" for the bit-field. (See the `field_byte_offset' function
6943 above).. For any given bit-field, the "containing object" is a
6944 hypothetical object (of some integral or enum type) within which
6945 the given bit-field lives. The type of this hypothetical
6946 "containing object" is always the same as the declared type of
6947 the individual bit-field itself (for GCC anyway... the DWARF
6948 spec doesn't actually mandate this). Note that it is the size
6949 (in bytes) of the hypothetical "containing object" which will
6950 be given in the DW_AT_byte_size attribute for this bit-field.
6951 (See the `byte_size_attribute' function below.) It is also used
6952 when calculating the value of the DW_AT_bit_offset attribute.
6953 (See the `bit_offset_attribute' function below). */
6956 add_data_member_location_attribute (die, decl)
6957 register dw_die_ref die;
6960 register unsigned long offset;
6961 register dw_loc_descr_ref loc_descr;
6962 register enum dwarf_location_atom op;
6964 if (TREE_CODE (decl) == TREE_VEC)
6965 offset = TREE_INT_CST_LOW (BINFO_OFFSET (decl));
6967 offset = field_byte_offset (decl);
6969 /* The DWARF2 standard says that we should assume that the structure address
6970 is already on the stack, so we can specify a structure field address
6971 by using DW_OP_plus_uconst. */
6973 #ifdef MIPS_DEBUGGING_INFO
6974 /* ??? The SGI dwarf reader does not handle the DW_OP_plus_uconst operator
6975 correctly. It works only if we leave the offset on the stack. */
6978 op = DW_OP_plus_uconst;
6981 loc_descr = new_loc_descr (op, offset, 0);
6982 add_AT_loc (die, DW_AT_data_member_location, loc_descr);
6985 /* Attach an DW_AT_const_value attribute for a variable or a parameter which
6986 does not have a "location" either in memory or in a register. These
6987 things can arise in GNU C when a constant is passed as an actual parameter
6988 to an inlined function. They can also arise in C++ where declared
6989 constants do not necessarily get memory "homes". */
6992 add_const_value_attribute (die, rtl)
6993 register dw_die_ref die;
6996 switch (GET_CODE (rtl))
6999 /* Note that a CONST_INT rtx could represent either an integer or a
7000 floating-point constant. A CONST_INT is used whenever the constant
7001 will fit into a single word. In all such cases, the original mode
7002 of the constant value is wiped out, and the CONST_INT rtx is
7003 assigned VOIDmode. */
7004 add_AT_unsigned (die, DW_AT_const_value, (unsigned) INTVAL (rtl));
7008 /* Note that a CONST_DOUBLE rtx could represent either an integer or a
7009 floating-point constant. A CONST_DOUBLE is used whenever the
7010 constant requires more than one word in order to be adequately
7011 represented. We output CONST_DOUBLEs as blocks. */
7013 register enum machine_mode mode = GET_MODE (rtl);
7015 if (GET_MODE_CLASS (mode) == MODE_FLOAT)
7017 register unsigned length = GET_MODE_SIZE (mode) / sizeof (long);
7021 REAL_VALUE_FROM_CONST_DOUBLE (rv, rtl);
7025 REAL_VALUE_TO_TARGET_SINGLE (rv, array[0]);
7029 REAL_VALUE_TO_TARGET_DOUBLE (rv, array);
7034 REAL_VALUE_TO_TARGET_LONG_DOUBLE (rv, array);
7041 add_AT_float (die, DW_AT_const_value, length, array);
7044 add_AT_long_long (die, DW_AT_const_value,
7045 CONST_DOUBLE_HIGH (rtl), CONST_DOUBLE_LOW (rtl));
7050 add_AT_string (die, DW_AT_const_value, XSTR (rtl, 0));
7056 add_AT_addr (die, DW_AT_const_value, addr_to_string (rtl));
7060 /* In cases where an inlined instance of an inline function is passed
7061 the address of an `auto' variable (which is local to the caller) we
7062 can get a situation where the DECL_RTL of the artificial local
7063 variable (for the inlining) which acts as a stand-in for the
7064 corresponding formal parameter (of the inline function) will look
7065 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not
7066 exactly a compile-time constant expression, but it isn't the address
7067 of the (artificial) local variable either. Rather, it represents the
7068 *value* which the artificial local variable always has during its
7069 lifetime. We currently have no way to represent such quasi-constant
7070 values in Dwarf, so for now we just punt and generate nothing. */
7074 /* No other kinds of rtx should be possible here. */
7080 /* Generate *either* an DW_AT_location attribute or else an DW_AT_const_value
7081 data attribute for a variable or a parameter. We generate the
7082 DW_AT_const_value attribute only in those cases where the given variable
7083 or parameter does not have a true "location" either in memory or in a
7084 register. This can happen (for example) when a constant is passed as an
7085 actual argument in a call to an inline function. (It's possible that
7086 these things can crop up in other ways also.) Note that one type of
7087 constant value which can be passed into an inlined function is a constant
7088 pointer. This can happen for example if an actual argument in an inlined
7089 function call evaluates to a compile-time constant address. */
7092 add_location_or_const_value_attribute (die, decl)
7093 register dw_die_ref die;
7097 register tree declared_type;
7098 register tree passed_type;
7100 if (TREE_CODE (decl) == ERROR_MARK)
7103 if (TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != PARM_DECL)
7106 /* Here we have to decide where we are going to say the parameter "lives"
7107 (as far as the debugger is concerned). We only have a couple of
7108 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
7110 DECL_RTL normally indicates where the parameter lives during most of the
7111 activation of the function. If optimization is enabled however, this
7112 could be either NULL or else a pseudo-reg. Both of those cases indicate
7113 that the parameter doesn't really live anywhere (as far as the code
7114 generation parts of GCC are concerned) during most of the function's
7115 activation. That will happen (for example) if the parameter is never
7116 referenced within the function.
7118 We could just generate a location descriptor here for all non-NULL
7119 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
7120 a little nicer than that if we also consider DECL_INCOMING_RTL in cases
7121 where DECL_RTL is NULL or is a pseudo-reg.
7123 Note however that we can only get away with using DECL_INCOMING_RTL as
7124 a backup substitute for DECL_RTL in certain limited cases. In cases
7125 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
7126 we can be sure that the parameter was passed using the same type as it is
7127 declared to have within the function, and that its DECL_INCOMING_RTL
7128 points us to a place where a value of that type is passed.
7130 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
7131 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
7132 because in these cases DECL_INCOMING_RTL points us to a value of some
7133 type which is *different* from the type of the parameter itself. Thus,
7134 if we tried to use DECL_INCOMING_RTL to generate a location attribute in
7135 such cases, the debugger would end up (for example) trying to fetch a
7136 `float' from a place which actually contains the first part of a
7137 `double'. That would lead to really incorrect and confusing
7138 output at debug-time.
7140 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
7141 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There
7142 are a couple of exceptions however. On little-endian machines we can
7143 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
7144 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
7145 an integral type that is smaller than TREE_TYPE (decl). These cases arise
7146 when (on a little-endian machine) a non-prototyped function has a
7147 parameter declared to be of type `short' or `char'. In such cases,
7148 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
7149 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
7150 passed `int' value. If the debugger then uses that address to fetch
7151 a `short' or a `char' (on a little-endian machine) the result will be
7152 the correct data, so we allow for such exceptional cases below.
7154 Note that our goal here is to describe the place where the given formal
7155 parameter lives during most of the function's activation (i.e. between
7156 the end of the prologue and the start of the epilogue). We'll do that
7157 as best as we can. Note however that if the given formal parameter is
7158 modified sometime during the execution of the function, then a stack
7159 backtrace (at debug-time) will show the function as having been
7160 called with the *new* value rather than the value which was
7161 originally passed in. This happens rarely enough that it is not
7162 a major problem, but it *is* a problem, and I'd like to fix it.
7164 A future version of dwarf2out.c may generate two additional
7165 attributes for any given DW_TAG_formal_parameter DIE which will
7166 describe the "passed type" and the "passed location" for the
7167 given formal parameter in addition to the attributes we now
7168 generate to indicate the "declared type" and the "active
7169 location" for each parameter. This additional set of attributes
7170 could be used by debuggers for stack backtraces. Separately, note
7171 that sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be
7172 NULL also. This happens (for example) for inlined-instances of
7173 inline function formal parameters which are never referenced.
7174 This really shouldn't be happening. All PARM_DECL nodes should
7175 get valid non-NULL DECL_INCOMING_RTL values, but integrate.c
7176 doesn't currently generate these values for inlined instances of
7177 inline function parameters, so when we see such cases, we are
7178 just out-of-luck for the time being (until integrate.c
7181 /* Use DECL_RTL as the "location" unless we find something better. */
7182 rtl = DECL_RTL (decl);
7184 if (TREE_CODE (decl) == PARM_DECL)
7186 if (rtl == NULL_RTX || is_pseudo_reg (rtl))
7188 declared_type = type_main_variant (TREE_TYPE (decl));
7189 passed_type = type_main_variant (DECL_ARG_TYPE (decl));
7191 /* This decl represents a formal parameter which was optimized out.
7192 Note that DECL_INCOMING_RTL may be NULL in here, but we handle
7193 all* cases where (rtl == NULL_RTX) just below. */
7194 if (declared_type == passed_type)
7195 rtl = DECL_INCOMING_RTL (decl);
7196 else if (! BYTES_BIG_ENDIAN
7197 && TREE_CODE (declared_type) == INTEGER_TYPE
7198 && (GET_MODE_SIZE (TYPE_MODE (declared_type))
7199 <= GET_MODE_SIZE (TYPE_MODE (passed_type))))
7200 rtl = DECL_INCOMING_RTL (decl);
7203 /* If the parm was passed in registers, but lives on the stack, then
7204 make a big endian correction if the mode of the type of the
7205 parameter is not the same as the mode of the rtl. */
7206 /* ??? This is the same series of checks that are made in dbxout.c before
7207 we reach the big endian correction code there. It isn't clear if all
7208 of these checks are necessary here, but keeping them all is the safe
7210 else if (GET_CODE (rtl) == MEM
7211 && XEXP (rtl, 0) != const0_rtx
7212 && ! CONSTANT_P (XEXP (rtl, 0))
7213 /* Not passed in memory. */
7214 && GET_CODE (DECL_INCOMING_RTL (decl)) != MEM
7215 /* Not passed by invisible reference. */
7216 && (GET_CODE (XEXP (rtl, 0)) != REG
7217 || REGNO (XEXP (rtl, 0)) == HARD_FRAME_POINTER_REGNUM
7218 || REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM
7219 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
7220 || REGNO (XEXP (rtl, 0)) == ARG_POINTER_REGNUM
7223 /* Big endian correction check. */
7225 && TYPE_MODE (TREE_TYPE (decl)) != GET_MODE (rtl)
7226 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)))
7229 int offset = (UNITS_PER_WORD
7230 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl))));
7231 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
7232 plus_constant (XEXP (rtl, 0), offset));
7236 if (rtl == NULL_RTX)
7239 rtl = eliminate_regs (rtl, 0, NULL_RTX);
7240 #ifdef LEAF_REG_REMAP
7241 if (current_function_uses_only_leaf_regs)
7242 leaf_renumber_regs_insn (rtl);
7245 switch (GET_CODE (rtl))
7248 /* The address of a variable that was optimized away; don't emit
7259 /* DECL_RTL could be (plus (reg ...) (const_int ...)) */
7260 add_const_value_attribute (die, rtl);
7267 add_AT_location_description (die, DW_AT_location, rtl);
7275 /* Generate an DW_AT_name attribute given some string value to be included as
7276 the value of the attribute. */
7279 add_name_attribute (die, name_string)
7280 register dw_die_ref die;
7281 register char *name_string;
7283 if (name_string != NULL && *name_string != 0)
7284 add_AT_string (die, DW_AT_name, name_string);
7287 /* Given a tree node describing an array bound (either lower or upper) output
7288 a representation for that bound. */
7291 add_bound_info (subrange_die, bound_attr, bound)
7292 register dw_die_ref subrange_die;
7293 register enum dwarf_attribute bound_attr;
7294 register tree bound;
7296 register unsigned bound_value = 0;
7298 /* If this is an Ada unconstrained array type, then don't emit any debug
7299 info because the array bounds are unknown. They are parameterized when
7300 the type is instantiated. */
7301 if (contains_placeholder_p (bound))
7304 switch (TREE_CODE (bound))
7309 /* All fixed-bounds are represented by INTEGER_CST nodes. */
7311 bound_value = TREE_INT_CST_LOW (bound);
7312 if (bound_attr == DW_AT_lower_bound
7313 && ((is_c_family () && bound_value == 0)
7314 || (is_fortran () && bound_value == 1)))
7315 /* use the default */;
7317 add_AT_unsigned (subrange_die, bound_attr, bound_value);
7322 case NON_LVALUE_EXPR:
7323 add_bound_info (subrange_die, bound_attr, TREE_OPERAND (bound, 0));
7327 /* If optimization is turned on, the SAVE_EXPRs that describe how to
7328 access the upper bound values may be bogus. If they refer to a
7329 register, they may only describe how to get at these values at the
7330 points in the generated code right after they have just been
7331 computed. Worse yet, in the typical case, the upper bound values
7332 will not even *be* computed in the optimized code (though the
7333 number of elements will), so these SAVE_EXPRs are entirely
7334 bogus. In order to compensate for this fact, we check here to see
7335 if optimization is enabled, and if so, we don't add an attribute
7336 for the (unknown and unknowable) upper bound. This should not
7337 cause too much trouble for existing (stupid?) debuggers because
7338 they have to deal with empty upper bounds location descriptions
7339 anyway in order to be able to deal with incomplete array types.
7340 Of course an intelligent debugger (GDB?) should be able to
7341 comprehend that a missing upper bound specification in a array
7342 type used for a storage class `auto' local array variable
7343 indicates that the upper bound is both unknown (at compile- time)
7344 and unknowable (at run-time) due to optimization.
7346 We assume that a MEM rtx is safe because gcc wouldn't put the
7347 value there unless it was going to be used repeatedly in the
7348 function, i.e. for cleanups. */
7349 if (! optimize || GET_CODE (SAVE_EXPR_RTL (bound)) == MEM)
7351 register dw_die_ref ctx = lookup_decl_die (current_function_decl);
7352 register dw_die_ref decl_die = new_die (DW_TAG_variable, ctx);
7353 register rtx loc = SAVE_EXPR_RTL (bound);
7355 /* If the RTL for the SAVE_EXPR is memory, handle the case where
7356 it references an outer function's frame. */
7358 if (GET_CODE (loc) == MEM)
7360 rtx new_addr = fix_lexical_addr (XEXP (loc, 0), bound);
7362 if (XEXP (loc, 0) != new_addr)
7363 loc = gen_rtx (MEM, GET_MODE (loc), new_addr);
7366 add_AT_flag (decl_die, DW_AT_artificial, 1);
7367 add_type_attribute (decl_die, TREE_TYPE (bound), 1, 0, ctx);
7368 add_AT_location_description (decl_die, DW_AT_location, loc);
7369 add_AT_die_ref (subrange_die, bound_attr, decl_die);
7372 /* Else leave out the attribute. */
7378 /* ??? These types of bounds can be created by the Ada front end,
7379 and it isn't clear how to emit debug info for them. */
7387 /* Note that the block of subscript information for an array type also
7388 includes information about the element type of type given array type. */
7391 add_subscript_info (type_die, type)
7392 register dw_die_ref type_die;
7395 #ifndef MIPS_DEBUGGING_INFO
7396 register unsigned dimension_number;
7398 register tree lower, upper;
7399 register dw_die_ref subrange_die;
7401 /* The GNU compilers represent multidimensional array types as sequences of
7402 one dimensional array types whose element types are themselves array
7403 types. Here we squish that down, so that each multidimensional array
7404 type gets only one array_type DIE in the Dwarf debugging info. The draft
7405 Dwarf specification say that we are allowed to do this kind of
7406 compression in C (because there is no difference between an array or
7407 arrays and a multidimensional array in C) but for other source languages
7408 (e.g. Ada) we probably shouldn't do this. */
7410 /* ??? The SGI dwarf reader fails for multidimensional arrays with a
7411 const enum type. E.g. const enum machine_mode insn_operand_mode[2][10].
7412 We work around this by disabling this feature. See also
7413 gen_array_type_die. */
7414 #ifndef MIPS_DEBUGGING_INFO
7415 for (dimension_number = 0;
7416 TREE_CODE (type) == ARRAY_TYPE;
7417 type = TREE_TYPE (type), dimension_number++)
7420 register tree domain = TYPE_DOMAIN (type);
7422 /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
7423 and (in GNU C only) variable bounds. Handle all three forms
7425 subrange_die = new_die (DW_TAG_subrange_type, type_die);
7428 /* We have an array type with specified bounds. */
7429 lower = TYPE_MIN_VALUE (domain);
7430 upper = TYPE_MAX_VALUE (domain);
7432 /* define the index type. */
7433 if (TREE_TYPE (domain))
7435 /* ??? This is probably an Ada unnamed subrange type. Ignore the
7436 TREE_TYPE field. We can't emit debug info for this
7437 because it is an unnamed integral type. */
7438 if (TREE_CODE (domain) == INTEGER_TYPE
7439 && TYPE_NAME (domain) == NULL_TREE
7440 && TREE_CODE (TREE_TYPE (domain)) == INTEGER_TYPE
7441 && TYPE_NAME (TREE_TYPE (domain)) == NULL_TREE)
7444 add_type_attribute (subrange_die, TREE_TYPE (domain), 0, 0,
7448 /* ??? If upper is NULL, the array has unspecified length,
7449 but it does have a lower bound. This happens with Fortran
7451 Since the debugger is definitely going to need to know N
7452 to produce useful results, go ahead and output the lower
7453 bound solo, and hope the debugger can cope. */
7455 add_bound_info (subrange_die, DW_AT_lower_bound, lower);
7457 add_bound_info (subrange_die, DW_AT_upper_bound, upper);
7460 /* We have an array type with an unspecified length. The DWARF-2
7461 spec does not say how to handle this; let's just leave out the
7466 #ifndef MIPS_DEBUGGING_INFO
7472 add_byte_size_attribute (die, tree_node)
7474 register tree tree_node;
7476 register unsigned size;
7478 switch (TREE_CODE (tree_node))
7486 case QUAL_UNION_TYPE:
7487 size = int_size_in_bytes (tree_node);
7490 /* For a data member of a struct or union, the DW_AT_byte_size is
7491 generally given as the number of bytes normally allocated for an
7492 object of the *declared* type of the member itself. This is true
7493 even for bit-fields. */
7494 size = simple_type_size_in_bits (field_type (tree_node)) / BITS_PER_UNIT;
7500 /* Note that `size' might be -1 when we get to this point. If it is, that
7501 indicates that the byte size of the entity in question is variable. We
7502 have no good way of expressing this fact in Dwarf at the present time,
7503 so just let the -1 pass on through. */
7505 add_AT_unsigned (die, DW_AT_byte_size, size);
7508 /* For a FIELD_DECL node which represents a bit-field, output an attribute
7509 which specifies the distance in bits from the highest order bit of the
7510 "containing object" for the bit-field to the highest order bit of the
7513 For any given bit-field, the "containing object" is a hypothetical
7514 object (of some integral or enum type) within which the given bit-field
7515 lives. The type of this hypothetical "containing object" is always the
7516 same as the declared type of the individual bit-field itself. The
7517 determination of the exact location of the "containing object" for a
7518 bit-field is rather complicated. It's handled by the
7519 `field_byte_offset' function (above).
7521 Note that it is the size (in bytes) of the hypothetical "containing object"
7522 which will be given in the DW_AT_byte_size attribute for this bit-field.
7523 (See `byte_size_attribute' above). */
7526 add_bit_offset_attribute (die, decl)
7527 register dw_die_ref die;
7530 register unsigned object_offset_in_bytes = field_byte_offset (decl);
7531 register tree type = DECL_BIT_FIELD_TYPE (decl);
7532 register tree bitpos_tree = DECL_FIELD_BITPOS (decl);
7533 register unsigned bitpos_int;
7534 register unsigned highest_order_object_bit_offset;
7535 register unsigned highest_order_field_bit_offset;
7536 register unsigned bit_offset;
7538 /* Must be a field and a bit field. */
7540 || TREE_CODE (decl) != FIELD_DECL)
7543 /* We can't yet handle bit-fields whose offsets are variable, so if we
7544 encounter such things, just return without generating any attribute
7546 if (TREE_CODE (bitpos_tree) != INTEGER_CST)
7549 bitpos_int = (unsigned) TREE_INT_CST_LOW (bitpos_tree);
7551 /* Note that the bit offset is always the distance (in bits) from the
7552 highest-order bit of the "containing object" to the highest-order bit of
7553 the bit-field itself. Since the "high-order end" of any object or field
7554 is different on big-endian and little-endian machines, the computation
7555 below must take account of these differences. */
7556 highest_order_object_bit_offset = object_offset_in_bytes * BITS_PER_UNIT;
7557 highest_order_field_bit_offset = bitpos_int;
7559 if (! BYTES_BIG_ENDIAN)
7561 highest_order_field_bit_offset
7562 += (unsigned) TREE_INT_CST_LOW (DECL_SIZE (decl));
7564 highest_order_object_bit_offset += simple_type_size_in_bits (type);
7568 = (! BYTES_BIG_ENDIAN
7569 ? highest_order_object_bit_offset - highest_order_field_bit_offset
7570 : highest_order_field_bit_offset - highest_order_object_bit_offset);
7572 add_AT_unsigned (die, DW_AT_bit_offset, bit_offset);
7575 /* For a FIELD_DECL node which represents a bit field, output an attribute
7576 which specifies the length in bits of the given field. */
7579 add_bit_size_attribute (die, decl)
7580 register dw_die_ref die;
7583 /* Must be a field and a bit field. */
7584 if (TREE_CODE (decl) != FIELD_DECL
7585 || ! DECL_BIT_FIELD_TYPE (decl))
7587 add_AT_unsigned (die, DW_AT_bit_size,
7588 (unsigned) TREE_INT_CST_LOW (DECL_SIZE (decl)));
7591 /* If the compiled language is ANSI C, then add a 'prototyped'
7592 attribute, if arg types are given for the parameters of a function. */
7595 add_prototyped_attribute (die, func_type)
7596 register dw_die_ref die;
7597 register tree func_type;
7599 if (get_AT_unsigned (comp_unit_die, DW_AT_language) == DW_LANG_C89
7600 && TYPE_ARG_TYPES (func_type) != NULL)
7601 add_AT_flag (die, DW_AT_prototyped, 1);
7605 /* Add an 'abstract_origin' attribute below a given DIE. The DIE is found
7606 by looking in either the type declaration or object declaration
7610 add_abstract_origin_attribute (die, origin)
7611 register dw_die_ref die;
7612 register tree origin;
7614 dw_die_ref origin_die = NULL;
7615 if (TREE_CODE_CLASS (TREE_CODE (origin)) == 'd')
7616 origin_die = lookup_decl_die (origin);
7617 else if (TREE_CODE_CLASS (TREE_CODE (origin)) == 't')
7618 origin_die = lookup_type_die (origin);
7620 add_AT_die_ref (die, DW_AT_abstract_origin, origin_die);
7623 /* We do not currently support the pure_virtual attribute. */
7626 add_pure_or_virtual_attribute (die, func_decl)
7627 register dw_die_ref die;
7628 register tree func_decl;
7630 if (DECL_VINDEX (func_decl))
7632 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
7633 add_AT_loc (die, DW_AT_vtable_elem_location,
7634 new_loc_descr (DW_OP_constu,
7635 TREE_INT_CST_LOW (DECL_VINDEX (func_decl)),
7638 /* GNU extension: Record what type this method came from originally. */
7639 if (debug_info_level > DINFO_LEVEL_TERSE)
7640 add_AT_die_ref (die, DW_AT_containing_type,
7641 lookup_type_die (DECL_CONTEXT (func_decl)));
7645 /* Add source coordinate attributes for the given decl. */
7648 add_src_coords_attributes (die, decl)
7649 register dw_die_ref die;
7652 register unsigned file_index = lookup_filename (DECL_SOURCE_FILE (decl));
7654 add_AT_unsigned (die, DW_AT_decl_file, file_index);
7655 add_AT_unsigned (die, DW_AT_decl_line, DECL_SOURCE_LINE (decl));
7658 /* Add an DW_AT_name attribute and source coordinate attribute for the
7659 given decl, but only if it actually has a name. */
7662 add_name_and_src_coords_attributes (die, decl)
7663 register dw_die_ref die;
7666 register tree decl_name;
7668 decl_name = DECL_NAME (decl);
7669 if (decl_name != NULL && IDENTIFIER_POINTER (decl_name) != NULL)
7671 add_name_attribute (die, dwarf2_name (decl, 0));
7672 add_src_coords_attributes (die, decl);
7673 if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
7674 && DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
7675 add_AT_string (die, DW_AT_MIPS_linkage_name,
7676 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
7680 /* Push a new declaration scope. */
7683 push_decl_scope (scope)
7686 tree containing_scope;
7689 /* Make room in the decl_scope_table, if necessary. */
7690 if (decl_scope_table_allocated == decl_scope_depth)
7692 decl_scope_table_allocated += DECL_SCOPE_TABLE_INCREMENT;
7694 = (decl_scope_node *) xrealloc (decl_scope_table,
7695 (decl_scope_table_allocated
7696 * sizeof (decl_scope_node)));
7699 decl_scope_table[decl_scope_depth].scope = scope;
7701 /* Sometimes, while recursively emitting subtypes within a class type,
7702 we end up recuring on a subtype at a higher level then the current
7703 subtype. In such a case, we need to search the decl_scope_table to
7704 find the parent of this subtype. */
7706 if (AGGREGATE_TYPE_P (scope))
7707 containing_scope = TYPE_CONTEXT (scope);
7709 containing_scope = NULL_TREE;
7711 /* The normal case. */
7712 if (decl_scope_depth == 0
7713 || containing_scope == NULL_TREE
7714 /* Ignore namespaces for the moment. */
7715 || TREE_CODE (containing_scope) == NAMESPACE_DECL
7716 || containing_scope == decl_scope_table[decl_scope_depth - 1].scope)
7717 decl_scope_table[decl_scope_depth].previous = decl_scope_depth - 1;
7720 /* We need to search for the containing_scope. */
7721 for (i = 0; i < decl_scope_depth; i++)
7722 if (decl_scope_table[i].scope == containing_scope)
7725 if (i == decl_scope_depth)
7728 decl_scope_table[decl_scope_depth].previous = i;
7734 /* Return the DIE for the scope that immediately contains this declaration. */
7737 scope_die_for (t, context_die)
7739 register dw_die_ref context_die;
7741 register dw_die_ref scope_die = NULL;
7742 register tree containing_scope;
7745 /* Walk back up the declaration tree looking for a place to define
7747 if (TREE_CODE_CLASS (TREE_CODE (t)) == 't')
7748 containing_scope = TYPE_CONTEXT (t);
7749 else if (TREE_CODE (t) == FUNCTION_DECL && DECL_VINDEX (t))
7750 containing_scope = decl_class_context (t);
7752 containing_scope = DECL_CONTEXT (t);
7754 /* Ignore namespaces for the moment. */
7755 if (containing_scope && TREE_CODE (containing_scope) == NAMESPACE_DECL)
7756 containing_scope = NULL_TREE;
7758 /* Ignore function type "scopes" from the C frontend. They mean that
7759 a tagged type is local to a parmlist of a function declarator, but
7760 that isn't useful to DWARF. */
7761 if (containing_scope && TREE_CODE (containing_scope) == FUNCTION_TYPE)
7762 containing_scope = NULL_TREE;
7764 /* Function-local tags and functions get stuck in limbo until they are
7765 fixed up by decls_for_scope. */
7766 if (context_die == NULL && containing_scope != NULL_TREE
7767 && (TREE_CODE (t) == FUNCTION_DECL || is_tagged_type (t)))
7770 if (containing_scope == NULL_TREE)
7771 scope_die = comp_unit_die;
7774 for (i = decl_scope_depth - 1, scope_die = context_die;
7775 i >= 0 && decl_scope_table[i].scope != containing_scope;
7776 (scope_die = scope_die->die_parent,
7777 i = decl_scope_table[i].previous))
7780 /* ??? Integrate_decl_tree does not handle BLOCK_TYPE_TAGS, nor
7781 does it try to handle types defined by TYPE_DECLs. Such types
7782 thus have an incorrect TYPE_CONTEXT, which points to the block
7783 they were originally defined in, instead of the current block
7784 created by function inlining. We try to detect that here and
7787 if (i < 0 && scope_die == comp_unit_die
7788 && TREE_CODE (containing_scope) == BLOCK
7789 && is_tagged_type (t)
7790 && (block_ultimate_origin (decl_scope_table[decl_scope_depth - 1].scope)
7791 == containing_scope))
7793 scope_die = context_die;
7794 /* Since the checks below are no longer applicable. */
7800 if (TREE_CODE_CLASS (TREE_CODE (containing_scope)) != 't')
7802 if (debug_info_level > DINFO_LEVEL_TERSE
7803 && !TREE_ASM_WRITTEN (containing_scope))
7806 /* If none of the current dies are suitable, we get file scope. */
7807 scope_die = comp_unit_die;
7814 /* Pop a declaration scope. */
7818 if (decl_scope_depth <= 0)
7823 /* Many forms of DIEs require a "type description" attribute. This
7824 routine locates the proper "type descriptor" die for the type given
7825 by 'type', and adds an DW_AT_type attribute below the given die. */
7828 add_type_attribute (object_die, type, decl_const, decl_volatile, context_die)
7829 register dw_die_ref object_die;
7831 register int decl_const;
7832 register int decl_volatile;
7833 register dw_die_ref context_die;
7835 register enum tree_code code = TREE_CODE (type);
7836 register dw_die_ref type_die = NULL;
7838 /* ??? If this type is an unnamed subrange type of an integral or
7839 floating-point type, use the inner type. This is because we have no
7840 support for unnamed types in base_type_die. This can happen if this is
7841 an Ada subrange type. Correct solution is emit a subrange type die. */
7842 if ((code == INTEGER_TYPE || code == REAL_TYPE)
7843 && TREE_TYPE (type) != 0 && TYPE_NAME (type) == 0)
7844 type = TREE_TYPE (type), code = TREE_CODE (type);
7846 if (code == ERROR_MARK)
7849 /* Handle a special case. For functions whose return type is void, we
7850 generate *no* type attribute. (Note that no object may have type
7851 `void', so this only applies to function return types). */
7852 if (code == VOID_TYPE)
7855 type_die = modified_type_die (type,
7856 decl_const || TYPE_READONLY (type),
7857 decl_volatile || TYPE_VOLATILE (type),
7859 if (type_die != NULL)
7860 add_AT_die_ref (object_die, DW_AT_type, type_die);
7863 /* Given a tree pointer to a struct, class, union, or enum type node, return
7864 a pointer to the (string) tag name for the given type, or zero if the type
7865 was declared without a tag. */
7871 register char *name = 0;
7873 if (TYPE_NAME (type) != 0)
7875 register tree t = 0;
7877 /* Find the IDENTIFIER_NODE for the type name. */
7878 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
7879 t = TYPE_NAME (type);
7881 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
7882 a TYPE_DECL node, regardless of whether or not a `typedef' was
7884 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
7885 && ! DECL_IGNORED_P (TYPE_NAME (type)))
7886 t = DECL_NAME (TYPE_NAME (type));
7888 /* Now get the name as a string, or invent one. */
7890 name = IDENTIFIER_POINTER (t);
7893 return (name == 0 || *name == '\0') ? 0 : name;
7896 /* Return the type associated with a data member, make a special check
7897 for bit field types. */
7900 member_declared_type (member)
7901 register tree member;
7903 return (DECL_BIT_FIELD_TYPE (member)
7904 ? DECL_BIT_FIELD_TYPE (member)
7905 : TREE_TYPE (member));
7908 /* Get the decl's label, as described by its RTL. This may be different
7909 from the DECL_NAME name used in the source file. */
7913 decl_start_label (decl)
7918 x = DECL_RTL (decl);
7919 if (GET_CODE (x) != MEM)
7923 if (GET_CODE (x) != SYMBOL_REF)
7926 fnname = XSTR (x, 0);
7931 /* These routines generate the internal representation of the DIE's for
7932 the compilation unit. Debugging information is collected by walking
7933 the declaration trees passed in from dwarf2out_decl(). */
7936 gen_array_type_die (type, context_die)
7938 register dw_die_ref context_die;
7940 register dw_die_ref scope_die = scope_die_for (type, context_die);
7941 register dw_die_ref array_die;
7942 register tree element_type;
7944 /* ??? The SGI dwarf reader fails for array of array of enum types unless
7945 the inner array type comes before the outer array type. Thus we must
7946 call gen_type_die before we call new_die. See below also. */
7947 #ifdef MIPS_DEBUGGING_INFO
7948 gen_type_die (TREE_TYPE (type), context_die);
7951 array_die = new_die (DW_TAG_array_type, scope_die);
7954 /* We default the array ordering. SDB will probably do
7955 the right things even if DW_AT_ordering is not present. It's not even
7956 an issue until we start to get into multidimensional arrays anyway. If
7957 SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
7958 then we'll have to put the DW_AT_ordering attribute back in. (But if
7959 and when we find out that we need to put these in, we will only do so
7960 for multidimensional arrays. */
7961 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major);
7964 #ifdef MIPS_DEBUGGING_INFO
7965 /* The SGI compilers handle arrays of unknown bound by setting
7966 AT_declaration and not emitting any subrange DIEs. */
7967 if (! TYPE_DOMAIN (type))
7968 add_AT_unsigned (array_die, DW_AT_declaration, 1);
7971 add_subscript_info (array_die, type);
7973 equate_type_number_to_die (type, array_die);
7975 /* Add representation of the type of the elements of this array type. */
7976 element_type = TREE_TYPE (type);
7978 /* ??? The SGI dwarf reader fails for multidimensional arrays with a
7979 const enum type. E.g. const enum machine_mode insn_operand_mode[2][10].
7980 We work around this by disabling this feature. See also
7981 add_subscript_info. */
7982 #ifndef MIPS_DEBUGGING_INFO
7983 while (TREE_CODE (element_type) == ARRAY_TYPE)
7984 element_type = TREE_TYPE (element_type);
7986 gen_type_die (element_type, context_die);
7989 add_type_attribute (array_die, element_type, 0, 0, context_die);
7993 gen_set_type_die (type, context_die)
7995 register dw_die_ref context_die;
7997 register dw_die_ref type_die
7998 = new_die (DW_TAG_set_type, scope_die_for (type, context_die));
8000 equate_type_number_to_die (type, type_die);
8001 add_type_attribute (type_die, TREE_TYPE (type), 0, 0, context_die);
8006 gen_entry_point_die (decl, context_die)
8008 register dw_die_ref context_die;
8010 register tree origin = decl_ultimate_origin (decl);
8011 register dw_die_ref decl_die = new_die (DW_TAG_entry_point, context_die);
8013 add_abstract_origin_attribute (decl_die, origin);
8016 add_name_and_src_coords_attributes (decl_die, decl);
8017 add_type_attribute (decl_die, TREE_TYPE (TREE_TYPE (decl)),
8021 if (DECL_ABSTRACT (decl))
8022 equate_decl_number_to_die (decl, decl_die);
8024 add_AT_lbl_id (decl_die, DW_AT_low_pc, decl_start_label (decl));
8028 /* Remember a type in the pending_types_list. */
8034 if (pending_types == pending_types_allocated)
8036 pending_types_allocated += PENDING_TYPES_INCREMENT;
8038 = (tree *) xrealloc (pending_types_list,
8039 sizeof (tree) * pending_types_allocated);
8042 pending_types_list[pending_types++] = type;
8045 /* Output any pending types (from the pending_types list) which we can output
8046 now (taking into account the scope that we are working on now).
8048 For each type output, remove the given type from the pending_types_list
8049 *before* we try to output it. */
8052 output_pending_types_for_scope (context_die)
8053 register dw_die_ref context_die;
8057 while (pending_types)
8060 type = pending_types_list[pending_types];
8061 gen_type_die (type, context_die);
8062 if (!TREE_ASM_WRITTEN (type))
8067 /* Remember a type in the incomplete_types_list. */
8070 add_incomplete_type (type)
8073 if (incomplete_types == incomplete_types_allocated)
8075 incomplete_types_allocated += INCOMPLETE_TYPES_INCREMENT;
8076 incomplete_types_list
8077 = (tree *) xrealloc (incomplete_types_list,
8078 sizeof (tree) * incomplete_types_allocated);
8081 incomplete_types_list[incomplete_types++] = type;
8084 /* Walk through the list of incomplete types again, trying once more to
8085 emit full debugging info for them. */
8088 retry_incomplete_types ()
8092 while (incomplete_types)
8095 type = incomplete_types_list[incomplete_types];
8096 gen_type_die (type, comp_unit_die);
8100 /* Generate a DIE to represent an inlined instance of an enumeration type. */
8103 gen_inlined_enumeration_type_die (type, context_die)
8105 register dw_die_ref context_die;
8107 register dw_die_ref type_die = new_die (DW_TAG_enumeration_type,
8108 scope_die_for (type, context_die));
8110 if (!TREE_ASM_WRITTEN (type))
8112 add_abstract_origin_attribute (type_die, type);
8115 /* Generate a DIE to represent an inlined instance of a structure type. */
8118 gen_inlined_structure_type_die (type, context_die)
8120 register dw_die_ref context_die;
8122 register dw_die_ref type_die = new_die (DW_TAG_structure_type,
8123 scope_die_for (type, context_die));
8125 if (!TREE_ASM_WRITTEN (type))
8127 add_abstract_origin_attribute (type_die, type);
8130 /* Generate a DIE to represent an inlined instance of a union type. */
8133 gen_inlined_union_type_die (type, context_die)
8135 register dw_die_ref context_die;
8137 register dw_die_ref type_die = new_die (DW_TAG_union_type,
8138 scope_die_for (type, context_die));
8140 if (!TREE_ASM_WRITTEN (type))
8142 add_abstract_origin_attribute (type_die, type);
8145 /* Generate a DIE to represent an enumeration type. Note that these DIEs
8146 include all of the information about the enumeration values also. Each
8147 enumerated type name/value is listed as a child of the enumerated type
8151 gen_enumeration_type_die (type, context_die)
8153 register dw_die_ref context_die;
8155 register dw_die_ref type_die = lookup_type_die (type);
8157 if (type_die == NULL)
8159 type_die = new_die (DW_TAG_enumeration_type,
8160 scope_die_for (type, context_die));
8161 equate_type_number_to_die (type, type_die);
8162 add_name_attribute (type_die, type_tag (type));
8164 else if (! TYPE_SIZE (type))
8167 remove_AT (type_die, DW_AT_declaration);
8169 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the
8170 given enum type is incomplete, do not generate the DW_AT_byte_size
8171 attribute or the DW_AT_element_list attribute. */
8172 if (TYPE_SIZE (type))
8176 TREE_ASM_WRITTEN (type) = 1;
8177 add_byte_size_attribute (type_die, type);
8178 if (TYPE_STUB_DECL (type) != NULL_TREE)
8179 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
8181 /* If the first reference to this type was as the return type of an
8182 inline function, then it may not have a parent. Fix this now. */
8183 if (type_die->die_parent == NULL)
8184 add_child_die (scope_die_for (type, context_die), type_die);
8186 for (link = TYPE_FIELDS (type);
8187 link != NULL; link = TREE_CHAIN (link))
8189 register dw_die_ref enum_die = new_die (DW_TAG_enumerator, type_die);
8191 add_name_attribute (enum_die,
8192 IDENTIFIER_POINTER (TREE_PURPOSE (link)));
8193 add_AT_unsigned (enum_die, DW_AT_const_value,
8194 (unsigned) TREE_INT_CST_LOW (TREE_VALUE (link)));
8198 add_AT_flag (type_die, DW_AT_declaration, 1);
8202 /* Generate a DIE to represent either a real live formal parameter decl or to
8203 represent just the type of some formal parameter position in some function
8206 Note that this routine is a bit unusual because its argument may be a
8207 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
8208 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
8209 node. If it's the former then this function is being called to output a
8210 DIE to represent a formal parameter object (or some inlining thereof). If
8211 it's the latter, then this function is only being called to output a
8212 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
8213 argument type of some subprogram type. */
8216 gen_formal_parameter_die (node, context_die)
8218 register dw_die_ref context_die;
8220 register dw_die_ref parm_die
8221 = new_die (DW_TAG_formal_parameter, context_die);
8222 register tree origin;
8224 switch (TREE_CODE_CLASS (TREE_CODE (node)))
8227 origin = decl_ultimate_origin (node);
8229 add_abstract_origin_attribute (parm_die, origin);
8232 add_name_and_src_coords_attributes (parm_die, node);
8233 add_type_attribute (parm_die, TREE_TYPE (node),
8234 TREE_READONLY (node),
8235 TREE_THIS_VOLATILE (node),
8237 if (DECL_ARTIFICIAL (node))
8238 add_AT_flag (parm_die, DW_AT_artificial, 1);
8241 equate_decl_number_to_die (node, parm_die);
8242 if (! DECL_ABSTRACT (node))
8243 add_location_or_const_value_attribute (parm_die, node);
8248 /* We were called with some kind of a ..._TYPE node. */
8249 add_type_attribute (parm_die, node, 0, 0, context_die);
8259 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
8260 at the end of an (ANSI prototyped) formal parameters list. */
8263 gen_unspecified_parameters_die (decl_or_type, context_die)
8264 register tree decl_or_type;
8265 register dw_die_ref context_die;
8267 new_die (DW_TAG_unspecified_parameters, context_die);
8270 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
8271 DW_TAG_unspecified_parameters DIE) to represent the types of the formal
8272 parameters as specified in some function type specification (except for
8273 those which appear as part of a function *definition*).
8275 Note we must be careful here to output all of the parameter DIEs before*
8276 we output any DIEs needed to represent the types of the formal parameters.
8277 This keeps svr4 SDB happy because it (incorrectly) thinks that the first
8278 non-parameter DIE it sees ends the formal parameter list. */
8281 gen_formal_types_die (function_or_method_type, context_die)
8282 register tree function_or_method_type;
8283 register dw_die_ref context_die;
8286 register tree formal_type = NULL;
8287 register tree first_parm_type = TYPE_ARG_TYPES (function_or_method_type);
8290 /* In the case where we are generating a formal types list for a C++
8291 non-static member function type, skip over the first thing on the
8292 TYPE_ARG_TYPES list because it only represents the type of the hidden
8293 `this pointer'. The debugger should be able to figure out (without
8294 being explicitly told) that this non-static member function type takes a
8295 `this pointer' and should be able to figure what the type of that hidden
8296 parameter is from the DW_AT_member attribute of the parent
8297 DW_TAG_subroutine_type DIE. */
8298 if (TREE_CODE (function_or_method_type) == METHOD_TYPE)
8299 first_parm_type = TREE_CHAIN (first_parm_type);
8302 /* Make our first pass over the list of formal parameter types and output a
8303 DW_TAG_formal_parameter DIE for each one. */
8304 for (link = first_parm_type; link; link = TREE_CHAIN (link))
8306 register dw_die_ref parm_die;
8308 formal_type = TREE_VALUE (link);
8309 if (formal_type == void_type_node)
8312 /* Output a (nameless) DIE to represent the formal parameter itself. */
8313 parm_die = gen_formal_parameter_die (formal_type, context_die);
8314 if (TREE_CODE (function_or_method_type) == METHOD_TYPE
8315 && link == first_parm_type)
8316 add_AT_flag (parm_die, DW_AT_artificial, 1);
8319 /* If this function type has an ellipsis, add a
8320 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */
8321 if (formal_type != void_type_node)
8322 gen_unspecified_parameters_die (function_or_method_type, context_die);
8324 /* Make our second (and final) pass over the list of formal parameter types
8325 and output DIEs to represent those types (as necessary). */
8326 for (link = TYPE_ARG_TYPES (function_or_method_type);
8328 link = TREE_CHAIN (link))
8330 formal_type = TREE_VALUE (link);
8331 if (formal_type == void_type_node)
8334 gen_type_die (formal_type, context_die);
8338 /* Generate a DIE to represent a declared function (either file-scope or
8342 gen_subprogram_die (decl, context_die)
8344 register dw_die_ref context_die;
8346 char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
8347 register tree origin = decl_ultimate_origin (decl);
8348 register dw_die_ref subr_die;
8349 register rtx fp_reg;
8350 register tree fn_arg_types;
8351 register tree outer_scope;
8352 register dw_die_ref old_die = lookup_decl_die (decl);
8353 register int declaration
8354 = (current_function_decl != decl
8356 && (context_die->die_tag == DW_TAG_structure_type
8357 || context_die->die_tag == DW_TAG_union_type)));
8361 subr_die = new_die (DW_TAG_subprogram, context_die);
8362 add_abstract_origin_attribute (subr_die, origin);
8364 else if (old_die && DECL_ABSTRACT (decl)
8365 && get_AT_unsigned (old_die, DW_AT_inline))
8367 /* This must be a redefinition of an extern inline function.
8368 We can just reuse the old die here. */
8371 /* Clear out the inlined attribute and parm types. */
8372 remove_AT (subr_die, DW_AT_inline);
8373 remove_children (subr_die);
8377 register unsigned file_index
8378 = lookup_filename (DECL_SOURCE_FILE (decl));
8380 if (get_AT_flag (old_die, DW_AT_declaration) != 1)
8382 /* ??? This can happen if there is a bug in the program, for
8383 instance, if it has duplicate function definitions. Ideally,
8384 we should detect this case and ignore it. For now, if we have
8385 already reported an error, any error at all, then assume that
8386 we got here because of a input error, not a dwarf2 bug. */
8387 extern int errorcount;
8393 /* If the definition comes from the same place as the declaration,
8394 maybe use the old DIE. We always want the DIE for this function
8395 that has the *_pc attributes to be under comp_unit_die so the
8396 debugger can find it. For inlines, that is the concrete instance,
8397 so we can use the old DIE here. For non-inline methods, we want a
8398 specification DIE at toplevel, so we need a new DIE. For local
8399 class methods, this does not apply. */
8400 if ((DECL_ABSTRACT (decl) || old_die->die_parent == comp_unit_die
8401 || context_die == NULL)
8402 && get_AT_unsigned (old_die, DW_AT_decl_file) == file_index
8403 && (get_AT_unsigned (old_die, DW_AT_decl_line)
8404 == DECL_SOURCE_LINE (decl)))
8408 /* Clear out the declaration attribute and the parm types. */
8409 remove_AT (subr_die, DW_AT_declaration);
8410 remove_children (subr_die);
8414 subr_die = new_die (DW_TAG_subprogram, context_die);
8415 add_AT_die_ref (subr_die, DW_AT_specification, old_die);
8416 if (get_AT_unsigned (old_die, DW_AT_decl_file) != file_index)
8417 add_AT_unsigned (subr_die, DW_AT_decl_file, file_index);
8418 if (get_AT_unsigned (old_die, DW_AT_decl_line)
8419 != DECL_SOURCE_LINE (decl))
8421 (subr_die, DW_AT_decl_line, DECL_SOURCE_LINE (decl));
8426 register dw_die_ref scope_die;
8428 if (DECL_CONTEXT (decl))
8429 scope_die = scope_die_for (decl, context_die);
8431 /* Don't put block extern declarations under comp_unit_die. */
8432 scope_die = context_die;
8434 subr_die = new_die (DW_TAG_subprogram, scope_die);
8436 if (TREE_PUBLIC (decl))
8437 add_AT_flag (subr_die, DW_AT_external, 1);
8439 add_name_and_src_coords_attributes (subr_die, decl);
8440 if (debug_info_level > DINFO_LEVEL_TERSE)
8442 register tree type = TREE_TYPE (decl);
8444 add_prototyped_attribute (subr_die, type);
8445 add_type_attribute (subr_die, TREE_TYPE (type), 0, 0, context_die);
8448 add_pure_or_virtual_attribute (subr_die, decl);
8449 if (DECL_ARTIFICIAL (decl))
8450 add_AT_flag (subr_die, DW_AT_artificial, 1);
8451 if (TREE_PROTECTED (decl))
8452 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_protected);
8453 else if (TREE_PRIVATE (decl))
8454 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_private);
8459 add_AT_flag (subr_die, DW_AT_declaration, 1);
8461 /* The first time we see a member function, it is in the context of
8462 the class to which it belongs. We make sure of this by emitting
8463 the class first. The next time is the definition, which is
8464 handled above. The two may come from the same source text. */
8465 if (DECL_CONTEXT (decl))
8466 equate_decl_number_to_die (decl, subr_die);
8468 else if (DECL_ABSTRACT (decl))
8470 /* ??? Checking DECL_DEFER_OUTPUT is correct for static inline functions,
8471 but not for extern inline functions. We can't get this completely
8472 correct because information about whether the function was declared
8473 inline is not saved anywhere. */
8474 if (DECL_DEFER_OUTPUT (decl))
8476 if (DECL_INLINE (decl))
8477 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_inlined);
8479 add_AT_unsigned (subr_die, DW_AT_inline,
8480 DW_INL_declared_not_inlined);
8482 else if (DECL_INLINE (decl))
8483 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_inlined);
8487 equate_decl_number_to_die (decl, subr_die);
8489 else if (!DECL_EXTERNAL (decl))
8491 if (origin == NULL_TREE)
8492 equate_decl_number_to_die (decl, subr_die);
8494 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_BEGIN_LABEL,
8495 current_funcdef_number);
8496 add_AT_lbl_id (subr_die, DW_AT_low_pc, label_id);
8497 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
8498 current_funcdef_number);
8499 add_AT_lbl_id (subr_die, DW_AT_high_pc, label_id);
8501 add_pubname (decl, subr_die);
8502 add_arange (decl, subr_die);
8504 #ifdef MIPS_DEBUGGING_INFO
8505 /* Add a reference to the FDE for this routine. */
8506 add_AT_fde_ref (subr_die, DW_AT_MIPS_fde, current_funcdef_fde);
8509 /* Define the "frame base" location for this routine. We use the
8510 frame pointer or stack pointer registers, since the RTL for local
8511 variables is relative to one of them. */
8513 = frame_pointer_needed ? hard_frame_pointer_rtx : stack_pointer_rtx;
8514 add_AT_loc (subr_die, DW_AT_frame_base, reg_loc_descriptor (fp_reg));
8517 /* ??? This fails for nested inline functions, because context_display
8518 is not part of the state saved/restored for inline functions. */
8519 if (current_function_needs_context)
8520 add_AT_location_description (subr_die, DW_AT_static_link,
8521 lookup_static_chain (decl));
8525 /* Now output descriptions of the arguments for this function. This gets
8526 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
8527 for a FUNCTION_DECL doesn't indicate cases where there was a trailing
8528 `...' at the end of the formal parameter list. In order to find out if
8529 there was a trailing ellipsis or not, we must instead look at the type
8530 associated with the FUNCTION_DECL. This will be a node of type
8531 FUNCTION_TYPE. If the chain of type nodes hanging off of this
8532 FUNCTION_TYPE node ends with a void_type_node then there should *not* be
8533 an ellipsis at the end. */
8534 push_decl_scope (decl);
8536 /* In the case where we are describing a mere function declaration, all we
8537 need to do here (and all we *can* do here) is to describe the *types* of
8538 its formal parameters. */
8539 if (debug_info_level <= DINFO_LEVEL_TERSE)
8541 else if (declaration)
8542 gen_formal_types_die (TREE_TYPE (decl), subr_die);
8545 /* Generate DIEs to represent all known formal parameters */
8546 register tree arg_decls = DECL_ARGUMENTS (decl);
8549 /* When generating DIEs, generate the unspecified_parameters DIE
8550 instead if we come across the arg "__builtin_va_alist" */
8551 for (parm = arg_decls; parm; parm = TREE_CHAIN (parm))
8552 if (TREE_CODE (parm) == PARM_DECL)
8554 if (DECL_NAME (parm)
8555 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (parm)),
8556 "__builtin_va_alist"))
8557 gen_unspecified_parameters_die (parm, subr_die);
8559 gen_decl_die (parm, subr_die);
8562 /* Decide whether we need a unspecified_parameters DIE at the end.
8563 There are 2 more cases to do this for: 1) the ansi ... declaration -
8564 this is detectable when the end of the arg list is not a
8565 void_type_node 2) an unprototyped function declaration (not a
8566 definition). This just means that we have no info about the
8567 parameters at all. */
8568 fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
8569 if (fn_arg_types != NULL)
8571 /* this is the prototyped case, check for ... */
8572 if (TREE_VALUE (tree_last (fn_arg_types)) != void_type_node)
8573 gen_unspecified_parameters_die (decl, subr_die);
8575 else if (DECL_INITIAL (decl) == NULL_TREE)
8576 gen_unspecified_parameters_die (decl, subr_die);
8579 /* Output Dwarf info for all of the stuff within the body of the function
8580 (if it has one - it may be just a declaration). */
8581 outer_scope = DECL_INITIAL (decl);
8583 /* Note that here, `outer_scope' is a pointer to the outermost BLOCK
8584 node created to represent a function. This outermost BLOCK actually
8585 represents the outermost binding contour for the function, i.e. the
8586 contour in which the function's formal parameters and labels get
8587 declared. Curiously, it appears that the front end doesn't actually
8588 put the PARM_DECL nodes for the current function onto the BLOCK_VARS
8589 list for this outer scope. (They are strung off of the DECL_ARGUMENTS
8590 list for the function instead.) The BLOCK_VARS list for the
8591 `outer_scope' does provide us with a list of the LABEL_DECL nodes for
8592 the function however, and we output DWARF info for those in
8593 decls_for_scope. Just within the `outer_scope' there will be a BLOCK
8594 node representing the function's outermost pair of curly braces, and
8595 any blocks used for the base and member initializers of a C++
8596 constructor function. */
8597 if (! declaration && TREE_CODE (outer_scope) != ERROR_MARK)
8599 current_function_has_inlines = 0;
8600 decls_for_scope (outer_scope, subr_die, 0);
8602 #if 0 && defined (MIPS_DEBUGGING_INFO)
8603 if (current_function_has_inlines)
8605 add_AT_flag (subr_die, DW_AT_MIPS_has_inlines, 1);
8606 if (! comp_unit_has_inlines)
8608 add_AT_flag (comp_unit_die, DW_AT_MIPS_has_inlines, 1);
8609 comp_unit_has_inlines = 1;
8618 /* Generate a DIE to represent a declared data object. */
8621 gen_variable_die (decl, context_die)
8623 register dw_die_ref context_die;
8625 register tree origin = decl_ultimate_origin (decl);
8626 register dw_die_ref var_die = new_die (DW_TAG_variable, context_die);
8628 dw_die_ref old_die = lookup_decl_die (decl);
8630 = (DECL_EXTERNAL (decl)
8631 || current_function_decl != decl_function_context (decl)
8632 || context_die->die_tag == DW_TAG_structure_type
8633 || context_die->die_tag == DW_TAG_union_type);
8636 add_abstract_origin_attribute (var_die, origin);
8637 /* Loop unrolling can create multiple blocks that refer to the same
8638 static variable, so we must test for the DW_AT_declaration flag. */
8639 /* ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
8640 copy decls and set the DECL_ABSTRACT flag on them instead of
8642 else if (old_die && TREE_STATIC (decl)
8643 && get_AT_flag (old_die, DW_AT_declaration) == 1)
8645 /* ??? This is an instantiation of a C++ class level static. */
8646 add_AT_die_ref (var_die, DW_AT_specification, old_die);
8647 if (DECL_NAME (decl))
8649 register unsigned file_index
8650 = lookup_filename (DECL_SOURCE_FILE (decl));
8652 if (get_AT_unsigned (old_die, DW_AT_decl_file) != file_index)
8653 add_AT_unsigned (var_die, DW_AT_decl_file, file_index);
8655 if (get_AT_unsigned (old_die, DW_AT_decl_line)
8656 != DECL_SOURCE_LINE (decl))
8658 add_AT_unsigned (var_die, DW_AT_decl_line,
8659 DECL_SOURCE_LINE (decl));
8664 add_name_and_src_coords_attributes (var_die, decl);
8665 add_type_attribute (var_die, TREE_TYPE (decl),
8666 TREE_READONLY (decl),
8667 TREE_THIS_VOLATILE (decl), context_die);
8669 if (TREE_PUBLIC (decl))
8670 add_AT_flag (var_die, DW_AT_external, 1);
8672 if (DECL_ARTIFICIAL (decl))
8673 add_AT_flag (var_die, DW_AT_artificial, 1);
8675 if (TREE_PROTECTED (decl))
8676 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_protected);
8678 else if (TREE_PRIVATE (decl))
8679 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_private);
8683 add_AT_flag (var_die, DW_AT_declaration, 1);
8685 if ((declaration && decl_class_context (decl)) || DECL_ABSTRACT (decl))
8686 equate_decl_number_to_die (decl, var_die);
8688 if (! declaration && ! DECL_ABSTRACT (decl))
8690 equate_decl_number_to_die (decl, var_die);
8691 add_location_or_const_value_attribute (var_die, decl);
8692 add_pubname (decl, var_die);
8696 /* Generate a DIE to represent a label identifier. */
8699 gen_label_die (decl, context_die)
8701 register dw_die_ref context_die;
8703 register tree origin = decl_ultimate_origin (decl);
8704 register dw_die_ref lbl_die = new_die (DW_TAG_label, context_die);
8706 char label[MAX_ARTIFICIAL_LABEL_BYTES];
8707 char label2[MAX_ARTIFICIAL_LABEL_BYTES];
8710 add_abstract_origin_attribute (lbl_die, origin);
8712 add_name_and_src_coords_attributes (lbl_die, decl);
8714 if (DECL_ABSTRACT (decl))
8715 equate_decl_number_to_die (decl, lbl_die);
8718 insn = DECL_RTL (decl);
8720 /* Deleted labels are programmer specified labels which have been
8721 eliminated because of various optimisations. We still emit them
8722 here so that it is possible to put breakpoints on them. */
8723 if (GET_CODE (insn) == CODE_LABEL
8724 || ((GET_CODE (insn) == NOTE
8725 && NOTE_LINE_NUMBER (insn) == NOTE_INSN_DELETED_LABEL)))
8727 /* When optimization is enabled (via -O) some parts of the compiler
8728 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
8729 represent source-level labels which were explicitly declared by
8730 the user. This really shouldn't be happening though, so catch
8731 it if it ever does happen. */
8732 if (INSN_DELETED_P (insn))
8735 sprintf (label2, INSN_LABEL_FMT, current_funcdef_number);
8736 ASM_GENERATE_INTERNAL_LABEL (label, label2,
8737 (unsigned) INSN_UID (insn));
8738 add_AT_lbl_id (lbl_die, DW_AT_low_pc, label);
8743 /* Generate a DIE for a lexical block. */
8746 gen_lexical_block_die (stmt, context_die, depth)
8748 register dw_die_ref context_die;
8751 register dw_die_ref stmt_die = new_die (DW_TAG_lexical_block, context_die);
8752 char label[MAX_ARTIFICIAL_LABEL_BYTES];
8754 if (! BLOCK_ABSTRACT (stmt))
8756 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
8758 add_AT_lbl_id (stmt_die, DW_AT_low_pc, label);
8759 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL, next_block_number);
8760 add_AT_lbl_id (stmt_die, DW_AT_high_pc, label);
8763 push_decl_scope (stmt);
8764 decls_for_scope (stmt, stmt_die, depth);
8768 /* Generate a DIE for an inlined subprogram. */
8771 gen_inlined_subroutine_die (stmt, context_die, depth)
8773 register dw_die_ref context_die;
8776 if (! BLOCK_ABSTRACT (stmt))
8778 register dw_die_ref subr_die
8779 = new_die (DW_TAG_inlined_subroutine, context_die);
8780 register tree decl = block_ultimate_origin (stmt);
8781 char label[MAX_ARTIFICIAL_LABEL_BYTES];
8783 add_abstract_origin_attribute (subr_die, decl);
8784 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
8786 add_AT_lbl_id (subr_die, DW_AT_low_pc, label);
8787 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL, next_block_number);
8788 add_AT_lbl_id (subr_die, DW_AT_high_pc, label);
8789 push_decl_scope (decl);
8790 decls_for_scope (stmt, subr_die, depth);
8792 current_function_has_inlines = 1;
8796 /* Generate a DIE for a field in a record, or structure. */
8799 gen_field_die (decl, context_die)
8801 register dw_die_ref context_die;
8803 register dw_die_ref decl_die = new_die (DW_TAG_member, context_die);
8805 add_name_and_src_coords_attributes (decl_die, decl);
8806 add_type_attribute (decl_die, member_declared_type (decl),
8807 TREE_READONLY (decl), TREE_THIS_VOLATILE (decl),
8810 /* If this is a bit field... */
8811 if (DECL_BIT_FIELD_TYPE (decl))
8813 add_byte_size_attribute (decl_die, decl);
8814 add_bit_size_attribute (decl_die, decl);
8815 add_bit_offset_attribute (decl_die, decl);
8818 if (TREE_CODE (DECL_FIELD_CONTEXT (decl)) != UNION_TYPE)
8819 add_data_member_location_attribute (decl_die, decl);
8821 if (DECL_ARTIFICIAL (decl))
8822 add_AT_flag (decl_die, DW_AT_artificial, 1);
8824 if (TREE_PROTECTED (decl))
8825 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_protected);
8827 else if (TREE_PRIVATE (decl))
8828 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_private);
8832 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
8833 Use modified_type_die instead.
8834 We keep this code here just in case these types of DIEs may be needed to
8835 represent certain things in other languages (e.g. Pascal) someday. */
8837 gen_pointer_type_die (type, context_die)
8839 register dw_die_ref context_die;
8841 register dw_die_ref ptr_die
8842 = new_die (DW_TAG_pointer_type, scope_die_for (type, context_die));
8844 equate_type_number_to_die (type, ptr_die);
8845 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
8846 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
8849 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
8850 Use modified_type_die instead.
8851 We keep this code here just in case these types of DIEs may be needed to
8852 represent certain things in other languages (e.g. Pascal) someday. */
8854 gen_reference_type_die (type, context_die)
8856 register dw_die_ref context_die;
8858 register dw_die_ref ref_die
8859 = new_die (DW_TAG_reference_type, scope_die_for (type, context_die));
8861 equate_type_number_to_die (type, ref_die);
8862 add_type_attribute (ref_die, TREE_TYPE (type), 0, 0, context_die);
8863 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
8867 /* Generate a DIE for a pointer to a member type. */
8869 gen_ptr_to_mbr_type_die (type, context_die)
8871 register dw_die_ref context_die;
8873 register dw_die_ref ptr_die
8874 = new_die (DW_TAG_ptr_to_member_type, scope_die_for (type, context_die));
8876 equate_type_number_to_die (type, ptr_die);
8877 add_AT_die_ref (ptr_die, DW_AT_containing_type,
8878 lookup_type_die (TYPE_OFFSET_BASETYPE (type)));
8879 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
8882 /* Generate the DIE for the compilation unit. */
8885 gen_compile_unit_die (main_input_filename)
8886 register char *main_input_filename;
8889 char *wd = getpwd ();
8891 comp_unit_die = new_die (DW_TAG_compile_unit, NULL);
8892 add_name_attribute (comp_unit_die, main_input_filename);
8895 add_AT_string (comp_unit_die, DW_AT_comp_dir, wd);
8897 sprintf (producer, "%s %s", language_string, version_string);
8899 #ifdef MIPS_DEBUGGING_INFO
8900 /* The MIPS/SGI compilers place the 'cc' command line options in the producer
8901 string. The SGI debugger looks for -g, -g1, -g2, or -g3; if they do
8902 not appear in the producer string, the debugger reaches the conclusion
8903 that the object file is stripped and has no debugging information.
8904 To get the MIPS/SGI debugger to believe that there is debugging
8905 information in the object file, we add a -g to the producer string. */
8906 if (debug_info_level > DINFO_LEVEL_TERSE)
8907 strcat (producer, " -g");
8910 add_AT_string (comp_unit_die, DW_AT_producer, producer);
8912 if (strcmp (language_string, "GNU C++") == 0)
8913 add_AT_unsigned (comp_unit_die, DW_AT_language, DW_LANG_C_plus_plus);
8915 else if (strcmp (language_string, "GNU Ada") == 0)
8916 add_AT_unsigned (comp_unit_die, DW_AT_language, DW_LANG_Ada83);
8918 else if (strcmp (language_string, "GNU F77") == 0)
8919 add_AT_unsigned (comp_unit_die, DW_AT_language, DW_LANG_Fortran77);
8921 else if (strcmp (language_string, "GNU Pascal") == 0)
8922 add_AT_unsigned (comp_unit_die, DW_AT_language, DW_LANG_Pascal83);
8924 else if (flag_traditional)
8925 add_AT_unsigned (comp_unit_die, DW_AT_language, DW_LANG_C);
8928 add_AT_unsigned (comp_unit_die, DW_AT_language, DW_LANG_C89);
8930 #if 0 /* unimplemented */
8931 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
8932 add_AT_unsigned (comp_unit_die, DW_AT_macro_info, 0);
8936 /* Generate a DIE for a string type. */
8939 gen_string_type_die (type, context_die)
8941 register dw_die_ref context_die;
8943 register dw_die_ref type_die
8944 = new_die (DW_TAG_string_type, scope_die_for (type, context_die));
8946 equate_type_number_to_die (type, type_die);
8948 /* Fudge the string length attribute for now. */
8950 /* TODO: add string length info.
8951 string_length_attribute (TYPE_MAX_VALUE (TYPE_DOMAIN (type)));
8952 bound_representation (upper_bound, 0, 'u'); */
8955 /* Generate the DIE for a base class. */
8958 gen_inheritance_die (binfo, context_die)
8959 register tree binfo;
8960 register dw_die_ref context_die;
8962 dw_die_ref die = new_die (DW_TAG_inheritance, context_die);
8964 add_type_attribute (die, BINFO_TYPE (binfo), 0, 0, context_die);
8965 add_data_member_location_attribute (die, binfo);
8967 if (TREE_VIA_VIRTUAL (binfo))
8968 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
8969 if (TREE_VIA_PUBLIC (binfo))
8970 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public);
8971 else if (TREE_VIA_PROTECTED (binfo))
8972 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected);
8975 /* Generate a DIE for a class member. */
8978 gen_member_die (type, context_die)
8980 register dw_die_ref context_die;
8982 register tree member;
8984 /* If this is not an incomplete type, output descriptions of each of its
8985 members. Note that as we output the DIEs necessary to represent the
8986 members of this record or union type, we will also be trying to output
8987 DIEs to represent the *types* of those members. However the `type'
8988 function (above) will specifically avoid generating type DIEs for member
8989 types *within* the list of member DIEs for this (containing) type execpt
8990 for those types (of members) which are explicitly marked as also being
8991 members of this (containing) type themselves. The g++ front- end can
8992 force any given type to be treated as a member of some other
8993 (containing) type by setting the TYPE_CONTEXT of the given (member) type
8994 to point to the TREE node representing the appropriate (containing)
8997 /* First output info about the base classes. */
8998 if (TYPE_BINFO (type) && TYPE_BINFO_BASETYPES (type))
9000 register tree bases = TYPE_BINFO_BASETYPES (type);
9001 register int n_bases = TREE_VEC_LENGTH (bases);
9004 for (i = 0; i < n_bases; i++)
9005 gen_inheritance_die (TREE_VEC_ELT (bases, i), context_die);
9008 /* Now output info about the data members and type members. */
9009 for (member = TYPE_FIELDS (type); member; member = TREE_CHAIN (member))
9010 gen_decl_die (member, context_die);
9012 /* Now output info about the function members (if any). */
9013 for (member = TYPE_METHODS (type); member; member = TREE_CHAIN (member))
9014 gen_decl_die (member, context_die);
9017 /* Generate a DIE for a structure or union type. */
9020 gen_struct_or_union_type_die (type, context_die)
9022 register dw_die_ref context_die;
9024 register dw_die_ref type_die = lookup_type_die (type);
9025 register dw_die_ref scope_die = 0;
9026 register int nested = 0;
9028 if (type_die && ! TYPE_SIZE (type))
9031 if (TYPE_CONTEXT (type) != NULL_TREE
9032 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type)))
9035 scope_die = scope_die_for (type, context_die);
9037 if (! type_die || (nested && scope_die == comp_unit_die))
9038 /* First occurrence of type or toplevel definition of nested class. */
9040 register dw_die_ref old_die = type_die;
9042 type_die = new_die (TREE_CODE (type) == RECORD_TYPE
9043 ? DW_TAG_structure_type : DW_TAG_union_type,
9045 equate_type_number_to_die (type, type_die);
9046 add_name_attribute (type_die, type_tag (type));
9048 add_AT_die_ref (type_die, DW_AT_specification, old_die);
9051 remove_AT (type_die, DW_AT_declaration);
9053 /* If we're not in the right context to be defining this type, defer to
9054 avoid tricky recursion. */
9055 if (TYPE_SIZE (type) && decl_scope_depth > 0 && scope_die == comp_unit_die)
9057 add_AT_flag (type_die, DW_AT_declaration, 1);
9060 /* If this type has been completed, then give it a byte_size attribute and
9061 then give a list of members. */
9062 else if (TYPE_SIZE (type))
9064 /* Prevent infinite recursion in cases where the type of some member of
9065 this type is expressed in terms of this type itself. */
9066 TREE_ASM_WRITTEN (type) = 1;
9067 add_byte_size_attribute (type_die, type);
9068 if (TYPE_STUB_DECL (type) != NULL_TREE)
9069 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
9071 /* If the first reference to this type was as the return type of an
9072 inline function, then it may not have a parent. Fix this now. */
9073 if (type_die->die_parent == NULL)
9074 add_child_die (scope_die, type_die);
9076 push_decl_scope (type);
9077 gen_member_die (type, type_die);
9080 /* GNU extension: Record what type our vtable lives in. */
9081 if (TYPE_VFIELD (type))
9083 tree vtype = DECL_FCONTEXT (TYPE_VFIELD (type));
9085 gen_type_die (vtype, context_die);
9086 add_AT_die_ref (type_die, DW_AT_containing_type,
9087 lookup_type_die (vtype));
9092 add_AT_flag (type_die, DW_AT_declaration, 1);
9094 /* We can't do this for function-local types, and we don't need to. */
9095 if (TREE_PERMANENT (type))
9096 add_incomplete_type (type);
9100 /* Generate a DIE for a subroutine _type_. */
9103 gen_subroutine_type_die (type, context_die)
9105 register dw_die_ref context_die;
9107 register tree return_type = TREE_TYPE (type);
9108 register dw_die_ref subr_die
9109 = new_die (DW_TAG_subroutine_type, scope_die_for (type, context_die));
9111 equate_type_number_to_die (type, subr_die);
9112 add_prototyped_attribute (subr_die, type);
9113 add_type_attribute (subr_die, return_type, 0, 0, context_die);
9114 gen_formal_types_die (type, subr_die);
9117 /* Generate a DIE for a type definition */
9120 gen_typedef_die (decl, context_die)
9122 register dw_die_ref context_die;
9124 register dw_die_ref type_die;
9125 register tree origin;
9127 if (TREE_ASM_WRITTEN (decl))
9129 TREE_ASM_WRITTEN (decl) = 1;
9131 type_die = new_die (DW_TAG_typedef, scope_die_for (decl, context_die));
9132 origin = decl_ultimate_origin (decl);
9134 add_abstract_origin_attribute (type_die, origin);
9138 add_name_and_src_coords_attributes (type_die, decl);
9139 if (DECL_ORIGINAL_TYPE (decl))
9141 type = DECL_ORIGINAL_TYPE (decl);
9142 equate_type_number_to_die (TREE_TYPE (decl), type_die);
9145 type = TREE_TYPE (decl);
9146 add_type_attribute (type_die, type, TREE_READONLY (decl),
9147 TREE_THIS_VOLATILE (decl), context_die);
9150 if (DECL_ABSTRACT (decl))
9151 equate_decl_number_to_die (decl, type_die);
9154 /* Generate a type description DIE. */
9157 gen_type_die (type, context_die)
9159 register dw_die_ref context_die;
9161 if (type == NULL_TREE || type == error_mark_node)
9164 /* We are going to output a DIE to represent the unqualified version of
9165 this type (i.e. without any const or volatile qualifiers) so get the
9166 main variant (i.e. the unqualified version) of this type now. */
9167 type = type_main_variant (type);
9169 if (TREE_ASM_WRITTEN (type))
9172 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
9173 && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
9175 TREE_ASM_WRITTEN (type) = 1;
9176 gen_decl_die (TYPE_NAME (type), context_die);
9180 switch (TREE_CODE (type))
9186 case REFERENCE_TYPE:
9187 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This
9188 ensures that the gen_type_die recursion will terminate even if the
9189 type is recursive. Recursive types are possible in Ada. */
9190 /* ??? We could perhaps do this for all types before the switch
9192 TREE_ASM_WRITTEN (type) = 1;
9194 /* For these types, all that is required is that we output a DIE (or a
9195 set of DIEs) to represent the "basis" type. */
9196 gen_type_die (TREE_TYPE (type), context_die);
9200 /* This code is used for C++ pointer-to-data-member types.
9201 Output a description of the relevant class type. */
9202 gen_type_die (TYPE_OFFSET_BASETYPE (type), context_die);
9204 /* Output a description of the type of the object pointed to. */
9205 gen_type_die (TREE_TYPE (type), context_die);
9207 /* Now output a DIE to represent this pointer-to-data-member type
9209 gen_ptr_to_mbr_type_die (type, context_die);
9213 gen_type_die (TYPE_DOMAIN (type), context_die);
9214 gen_set_type_die (type, context_die);
9218 gen_type_die (TREE_TYPE (type), context_die);
9219 abort (); /* No way to represent these in Dwarf yet! */
9223 /* Force out return type (in case it wasn't forced out already). */
9224 gen_type_die (TREE_TYPE (type), context_die);
9225 gen_subroutine_type_die (type, context_die);
9229 /* Force out return type (in case it wasn't forced out already). */
9230 gen_type_die (TREE_TYPE (type), context_die);
9231 gen_subroutine_type_die (type, context_die);
9235 if (TYPE_STRING_FLAG (type) && TREE_CODE (TREE_TYPE (type)) == CHAR_TYPE)
9237 gen_type_die (TREE_TYPE (type), context_die);
9238 gen_string_type_die (type, context_die);
9241 gen_array_type_die (type, context_die);
9247 case QUAL_UNION_TYPE:
9248 /* If this is a nested type whose containing class hasn't been
9249 written out yet, writing it out will cover this one, too. */
9250 if (TYPE_CONTEXT (type)
9251 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
9252 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
9254 gen_type_die (TYPE_CONTEXT (type), context_die);
9256 if (TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
9259 /* If that failed, attach ourselves to the stub. */
9260 push_decl_scope (TYPE_CONTEXT (type));
9261 context_die = lookup_type_die (TYPE_CONTEXT (type));
9264 if (TREE_CODE (type) == ENUMERAL_TYPE)
9265 gen_enumeration_type_die (type, context_die);
9267 gen_struct_or_union_type_die (type, context_die);
9269 if (TYPE_CONTEXT (type)
9270 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
9271 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
9274 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
9275 it up if it is ever completed. gen_*_type_die will set it for us
9276 when appropriate. */
9285 /* No DIEs needed for fundamental types. */
9289 /* No Dwarf representation currently defined. */
9296 TREE_ASM_WRITTEN (type) = 1;
9299 /* Generate a DIE for a tagged type instantiation. */
9302 gen_tagged_type_instantiation_die (type, context_die)
9304 register dw_die_ref context_die;
9306 if (type == NULL_TREE || type == error_mark_node)
9309 /* We are going to output a DIE to represent the unqualified version of
9310 this type (i.e. without any const or volatile qualifiers) so make sure
9311 that we have the main variant (i.e. the unqualified version) of this
9313 if (type != type_main_variant (type)
9314 || !TREE_ASM_WRITTEN (type))
9317 switch (TREE_CODE (type))
9323 gen_inlined_enumeration_type_die (type, context_die);
9327 gen_inlined_structure_type_die (type, context_die);
9331 case QUAL_UNION_TYPE:
9332 gen_inlined_union_type_die (type, context_die);
9340 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
9341 things which are local to the given block. */
9344 gen_block_die (stmt, context_die, depth)
9346 register dw_die_ref context_die;
9349 register int must_output_die = 0;
9350 register tree origin;
9352 register enum tree_code origin_code;
9354 /* Ignore blocks never really used to make RTL. */
9356 if (stmt == NULL_TREE || !TREE_USED (stmt))
9359 /* Determine the "ultimate origin" of this block. This block may be an
9360 inlined instance of an inlined instance of inline function, so we have
9361 to trace all of the way back through the origin chain to find out what
9362 sort of node actually served as the original seed for the creation of
9363 the current block. */
9364 origin = block_ultimate_origin (stmt);
9365 origin_code = (origin != NULL) ? TREE_CODE (origin) : ERROR_MARK;
9367 /* Determine if we need to output any Dwarf DIEs at all to represent this
9369 if (origin_code == FUNCTION_DECL)
9370 /* The outer scopes for inlinings *must* always be represented. We
9371 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */
9372 must_output_die = 1;
9375 /* In the case where the current block represents an inlining of the
9376 "body block" of an inline function, we must *NOT* output any DIE for
9377 this block because we have already output a DIE to represent the
9378 whole inlined function scope and the "body block" of any function
9379 doesn't really represent a different scope according to ANSI C
9380 rules. So we check here to make sure that this block does not
9381 represent a "body block inlining" before trying to set the
9382 `must_output_die' flag. */
9383 if (! is_body_block (origin ? origin : stmt))
9385 /* Determine if this block directly contains any "significant"
9386 local declarations which we will need to output DIEs for. */
9387 if (debug_info_level > DINFO_LEVEL_TERSE)
9388 /* We are not in terse mode so *any* local declaration counts
9389 as being a "significant" one. */
9390 must_output_die = (BLOCK_VARS (stmt) != NULL);
9392 /* We are in terse mode, so only local (nested) function
9393 definitions count as "significant" local declarations. */
9394 for (decl = BLOCK_VARS (stmt);
9395 decl != NULL; decl = TREE_CHAIN (decl))
9396 if (TREE_CODE (decl) == FUNCTION_DECL
9397 && DECL_INITIAL (decl))
9399 must_output_die = 1;
9405 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
9406 DIE for any block which contains no significant local declarations at
9407 all. Rather, in such cases we just call `decls_for_scope' so that any
9408 needed Dwarf info for any sub-blocks will get properly generated. Note
9409 that in terse mode, our definition of what constitutes a "significant"
9410 local declaration gets restricted to include only inlined function
9411 instances and local (nested) function definitions. */
9412 if (must_output_die)
9414 if (origin_code == FUNCTION_DECL)
9415 gen_inlined_subroutine_die (stmt, context_die, depth);
9417 gen_lexical_block_die (stmt, context_die, depth);
9420 decls_for_scope (stmt, context_die, depth);
9423 /* Generate all of the decls declared within a given scope and (recursively)
9424 all of its sub-blocks. */
9427 decls_for_scope (stmt, context_die, depth)
9429 register dw_die_ref context_die;
9433 register tree subblocks;
9435 /* Ignore blocks never really used to make RTL. */
9436 if (stmt == NULL_TREE || ! TREE_USED (stmt))
9439 if (!BLOCK_ABSTRACT (stmt) && depth > 0)
9440 next_block_number++;
9442 /* Output the DIEs to represent all of the data objects and typedefs
9443 declared directly within this block but not within any nested
9444 sub-blocks. Also, nested function and tag DIEs have been
9445 generated with a parent of NULL; fix that up now. */
9446 for (decl = BLOCK_VARS (stmt);
9447 decl != NULL; decl = TREE_CHAIN (decl))
9449 register dw_die_ref die;
9451 if (TREE_CODE (decl) == FUNCTION_DECL)
9452 die = lookup_decl_die (decl);
9453 else if (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl))
9454 die = lookup_type_die (TREE_TYPE (decl));
9458 if (die != NULL && die->die_parent == NULL)
9459 add_child_die (context_die, die);
9461 gen_decl_die (decl, context_die);
9464 /* Output the DIEs to represent all sub-blocks (and the items declared
9465 therein) of this block. */
9466 for (subblocks = BLOCK_SUBBLOCKS (stmt);
9468 subblocks = BLOCK_CHAIN (subblocks))
9469 gen_block_die (subblocks, context_die, depth + 1);
9472 /* Is this a typedef we can avoid emitting? */
9475 is_redundant_typedef (decl)
9478 if (TYPE_DECL_IS_STUB (decl))
9481 if (DECL_ARTIFICIAL (decl)
9482 && DECL_CONTEXT (decl)
9483 && is_tagged_type (DECL_CONTEXT (decl))
9484 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl))) == TYPE_DECL
9485 && DECL_NAME (decl) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))))
9486 /* Also ignore the artificial member typedef for the class name. */
9492 /* Generate Dwarf debug information for a decl described by DECL. */
9495 gen_decl_die (decl, context_die)
9497 register dw_die_ref context_die;
9499 register tree origin;
9501 /* Make a note of the decl node we are going to be working on. We may need
9502 to give the user the source coordinates of where it appeared in case we
9503 notice (later on) that something about it looks screwy. */
9504 dwarf_last_decl = decl;
9506 if (TREE_CODE (decl) == ERROR_MARK)
9509 /* If this ..._DECL node is marked to be ignored, then ignore it. But don't
9510 ignore a function definition, since that would screw up our count of
9511 blocks, and that in turn will completely screw up the labels we will
9512 reference in subsequent DW_AT_low_pc and DW_AT_high_pc attributes (for
9513 subsequent blocks). */
9514 if (DECL_IGNORED_P (decl) && TREE_CODE (decl) != FUNCTION_DECL)
9517 switch (TREE_CODE (decl))
9520 /* The individual enumerators of an enum type get output when we output
9521 the Dwarf representation of the relevant enum type itself. */
9525 /* Don't output any DIEs to represent mere function declarations,
9526 unless they are class members or explicit block externs. */
9527 if (DECL_INITIAL (decl) == NULL_TREE && DECL_CONTEXT (decl) == NULL_TREE
9528 && (current_function_decl == NULL_TREE || ! DECL_ARTIFICIAL (decl)))
9531 if (debug_info_level > DINFO_LEVEL_TERSE)
9533 /* Before we describe the FUNCTION_DECL itself, make sure that we
9534 have described its return type. */
9535 gen_type_die (TREE_TYPE (TREE_TYPE (decl)), context_die);
9537 /* And its containing type. */
9538 origin = decl_class_context (decl);
9539 if (origin != NULL_TREE)
9540 gen_type_die (origin, context_die);
9542 /* And its virtual context. */
9543 if (DECL_VINDEX (decl) != NULL_TREE)
9544 gen_type_die (DECL_CONTEXT (decl), context_die);
9547 /* Now output a DIE to represent the function itself. */
9548 gen_subprogram_die (decl, context_die);
9552 /* If we are in terse mode, don't generate any DIEs to represent any
9554 if (debug_info_level <= DINFO_LEVEL_TERSE)
9557 /* In the special case of a TYPE_DECL node representing the
9558 declaration of some type tag, if the given TYPE_DECL is marked as
9559 having been instantiated from some other (original) TYPE_DECL node
9560 (e.g. one which was generated within the original definition of an
9561 inline function) we have to generate a special (abbreviated)
9562 DW_TAG_structure_type, DW_TAG_union_type, or DW_TAG_enumeration_type
9564 if (TYPE_DECL_IS_STUB (decl) && DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
9566 gen_tagged_type_instantiation_die (TREE_TYPE (decl), context_die);
9570 if (is_redundant_typedef (decl))
9571 gen_type_die (TREE_TYPE (decl), context_die);
9573 /* Output a DIE to represent the typedef itself. */
9574 gen_typedef_die (decl, context_die);
9578 if (debug_info_level >= DINFO_LEVEL_NORMAL)
9579 gen_label_die (decl, context_die);
9583 /* If we are in terse mode, don't generate any DIEs to represent any
9584 variable declarations or definitions. */
9585 if (debug_info_level <= DINFO_LEVEL_TERSE)
9588 /* Output any DIEs that are needed to specify the type of this data
9590 gen_type_die (TREE_TYPE (decl), context_die);
9592 /* And its containing type. */
9593 origin = decl_class_context (decl);
9594 if (origin != NULL_TREE)
9595 gen_type_die (origin, context_die);
9597 /* Now output the DIE to represent the data object itself. This gets
9598 complicated because of the possibility that the VAR_DECL really
9599 represents an inlined instance of a formal parameter for an inline
9601 origin = decl_ultimate_origin (decl);
9602 if (origin != NULL_TREE && TREE_CODE (origin) == PARM_DECL)
9603 gen_formal_parameter_die (decl, context_die);
9605 gen_variable_die (decl, context_die);
9609 /* Ignore the nameless fields that are used to skip bits, but
9610 handle C++ anonymous unions. */
9611 if (DECL_NAME (decl) != NULL_TREE
9612 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE)
9614 gen_type_die (member_declared_type (decl), context_die);
9615 gen_field_die (decl, context_die);
9620 gen_type_die (TREE_TYPE (decl), context_die);
9621 gen_formal_parameter_die (decl, context_die);
9629 /* Write the debugging output for DECL. */
9632 dwarf2out_decl (decl)
9635 register dw_die_ref context_die = comp_unit_die;
9637 if (TREE_CODE (decl) == ERROR_MARK)
9640 /* If this ..._DECL node is marked to be ignored, then ignore it. We gotta
9641 hope that the node in question doesn't represent a function definition.
9642 If it does, then totally ignoring it is bound to screw up our count of
9643 blocks, and that in turn will completely screw up the labels we will
9644 reference in subsequent DW_AT_low_pc and DW_AT_high_pc attributes (for
9645 subsequent blocks). (It's too bad that BLOCK nodes don't carry their
9646 own sequence numbers with them!) */
9647 if (DECL_IGNORED_P (decl))
9649 if (TREE_CODE (decl) == FUNCTION_DECL
9650 && DECL_INITIAL (decl) != NULL)
9656 switch (TREE_CODE (decl))
9659 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration of a
9660 builtin function. Explicit programmer-supplied declarations of
9661 these same functions should NOT be ignored however. */
9662 if (DECL_EXTERNAL (decl) && DECL_FUNCTION_CODE (decl))
9665 /* What we would really like to do here is to filter out all mere
9666 file-scope declarations of file-scope functions which are never
9667 referenced later within this translation unit (and keep all of ones
9668 that *are* referenced later on) but we aren't clairvoyant, so we have
9669 no idea which functions will be referenced in the future (i.e. later
9670 on within the current translation unit). So here we just ignore all
9671 file-scope function declarations which are not also definitions. If
9672 and when the debugger needs to know something about these functions,
9673 it wil have to hunt around and find the DWARF information associated
9674 with the definition of the function. Note that we can't just check
9675 `DECL_EXTERNAL' to find out which FUNCTION_DECL nodes represent
9676 definitions and which ones represent mere declarations. We have to
9677 check `DECL_INITIAL' instead. That's because the C front-end
9678 supports some weird semantics for "extern inline" function
9679 definitions. These can get inlined within the current translation
9680 unit (an thus, we need to generate DWARF info for their abstract
9681 instances so that the DWARF info for the concrete inlined instances
9682 can have something to refer to) but the compiler never generates any
9683 out-of-lines instances of such things (despite the fact that they
9684 *are* definitions). The important point is that the C front-end
9685 marks these "extern inline" functions as DECL_EXTERNAL, but we need
9686 to generate DWARF for them anyway. Note that the C++ front-end also
9687 plays some similar games for inline function definitions appearing
9688 within include files which also contain
9689 `#pragma interface' pragmas. */
9690 if (DECL_INITIAL (decl) == NULL_TREE)
9693 /* If we're a nested function, initially use a parent of NULL; if we're
9694 a plain function, this will be fixed up in decls_for_scope. If
9695 we're a method, it will be ignored, since we already have a DIE. */
9696 if (decl_function_context (decl))
9702 /* Ignore this VAR_DECL if it refers to a file-scope extern data object
9703 declaration and if the declaration was never even referenced from
9704 within this entire compilation unit. We suppress these DIEs in
9705 order to save space in the .debug section (by eliminating entries
9706 which are probably useless). Note that we must not suppress
9707 block-local extern declarations (whether used or not) because that
9708 would screw-up the debugger's name lookup mechanism and cause it to
9709 miss things which really ought to be in scope at a given point. */
9710 if (DECL_EXTERNAL (decl) && !TREE_USED (decl))
9713 /* If we are in terse mode, don't generate any DIEs to represent any
9714 variable declarations or definitions. */
9715 if (debug_info_level <= DINFO_LEVEL_TERSE)
9720 /* Don't bother trying to generate any DIEs to represent any of the
9721 normal built-in types for the language we are compiling. */
9722 if (DECL_SOURCE_LINE (decl) == 0)
9724 /* OK, we need to generate one for `bool' so GDB knows what type
9725 comparisons have. */
9726 if ((get_AT_unsigned (comp_unit_die, DW_AT_language)
9727 == DW_LANG_C_plus_plus)
9728 && TREE_CODE (TREE_TYPE (decl)) == BOOLEAN_TYPE)
9729 modified_type_die (TREE_TYPE (decl), 0, 0, NULL);
9734 /* If we are in terse mode, don't generate any DIEs for types. */
9735 if (debug_info_level <= DINFO_LEVEL_TERSE)
9738 /* If we're a function-scope tag, initially use a parent of NULL;
9739 this will be fixed up in decls_for_scope. */
9740 if (decl_function_context (decl))
9749 gen_decl_die (decl, context_die);
9750 output_pending_types_for_scope (comp_unit_die);
9753 /* Output a marker (i.e. a label) for the beginning of the generated code for
9757 dwarf2out_begin_block (blocknum)
9758 register unsigned blocknum;
9760 function_section (current_function_decl);
9761 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, BLOCK_BEGIN_LABEL, blocknum);
9764 /* Output a marker (i.e. a label) for the end of the generated code for a
9768 dwarf2out_end_block (blocknum)
9769 register unsigned blocknum;
9771 function_section (current_function_decl);
9772 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, BLOCK_END_LABEL, blocknum);
9775 /* Output a marker (i.e. a label) at a point in the assembly code which
9776 corresponds to a given source level label. */
9779 dwarf2out_label (insn)
9782 char label[MAX_ARTIFICIAL_LABEL_BYTES];
9784 if (debug_info_level >= DINFO_LEVEL_NORMAL)
9786 function_section (current_function_decl);
9787 sprintf (label, INSN_LABEL_FMT, current_funcdef_number);
9788 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, label,
9789 (unsigned) INSN_UID (insn));
9793 /* Lookup a filename (in the list of filenames that we know about here in
9794 dwarf2out.c) and return its "index". The index of each (known) filename is
9795 just a unique number which is associated with only that one filename.
9796 We need such numbers for the sake of generating labels
9797 (in the .debug_sfnames section) and references to those
9798 files numbers (in the .debug_srcinfo and.debug_macinfo sections).
9799 If the filename given as an argument is not found in our current list,
9800 add it to the list and assign it the next available unique index number.
9801 In order to speed up searches, we remember the index of the filename
9802 was looked up last. This handles the majority of all searches. */
9805 lookup_filename (file_name)
9808 static unsigned last_file_lookup_index = 0;
9809 register unsigned i;
9811 /* Check to see if the file name that was searched on the previous call
9812 matches this file name. If so, return the index. */
9813 if (last_file_lookup_index != 0)
9814 if (strcmp (file_name, file_table[last_file_lookup_index]) == 0)
9815 return last_file_lookup_index;
9817 /* Didn't match the previous lookup, search the table */
9818 for (i = 1; i < file_table_in_use; ++i)
9819 if (strcmp (file_name, file_table[i]) == 0)
9821 last_file_lookup_index = i;
9825 /* Prepare to add a new table entry by making sure there is enough space in
9826 the table to do so. If not, expand the current table. */
9827 if (file_table_in_use == file_table_allocated)
9829 file_table_allocated += FILE_TABLE_INCREMENT;
9831 = (char **) xrealloc (file_table,
9832 file_table_allocated * sizeof (char *));
9835 /* Add the new entry to the end of the filename table. */
9836 file_table[file_table_in_use] = xstrdup (file_name);
9837 last_file_lookup_index = file_table_in_use++;
9839 return last_file_lookup_index;
9842 /* Output a label to mark the beginning of a source code line entry
9843 and record information relating to this source line, in
9844 'line_info_table' for later output of the .debug_line section. */
9847 dwarf2out_line (filename, line)
9848 register char *filename;
9849 register unsigned line;
9851 if (debug_info_level >= DINFO_LEVEL_NORMAL)
9853 function_section (current_function_decl);
9855 if (DECL_SECTION_NAME (current_function_decl))
9857 register dw_separate_line_info_ref line_info;
9858 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, SEPARATE_LINE_CODE_LABEL,
9859 separate_line_info_table_in_use);
9860 fputc ('\n', asm_out_file);
9862 /* expand the line info table if necessary */
9863 if (separate_line_info_table_in_use
9864 == separate_line_info_table_allocated)
9866 separate_line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
9867 separate_line_info_table
9868 = (dw_separate_line_info_ref)
9869 xrealloc (separate_line_info_table,
9870 separate_line_info_table_allocated
9871 * sizeof (dw_separate_line_info_entry));
9874 /* Add the new entry at the end of the line_info_table. */
9876 = &separate_line_info_table[separate_line_info_table_in_use++];
9877 line_info->dw_file_num = lookup_filename (filename);
9878 line_info->dw_line_num = line;
9879 line_info->function = current_funcdef_number;
9883 register dw_line_info_ref line_info;
9885 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, LINE_CODE_LABEL,
9886 line_info_table_in_use);
9887 fputc ('\n', asm_out_file);
9889 /* Expand the line info table if necessary. */
9890 if (line_info_table_in_use == line_info_table_allocated)
9892 line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
9894 = (dw_line_info_ref)
9895 xrealloc (line_info_table,
9896 (line_info_table_allocated
9897 * sizeof (dw_line_info_entry)));
9900 /* Add the new entry at the end of the line_info_table. */
9901 line_info = &line_info_table[line_info_table_in_use++];
9902 line_info->dw_file_num = lookup_filename (filename);
9903 line_info->dw_line_num = line;
9908 /* Record the beginning of a new source file, for later output
9909 of the .debug_macinfo section. At present, unimplemented. */
9912 dwarf2out_start_source_file (filename)
9913 register char *filename ATTRIBUTE_UNUSED;
9917 /* Record the end of a source file, for later output
9918 of the .debug_macinfo section. At present, unimplemented. */
9921 dwarf2out_end_source_file ()
9925 /* Called from check_newline in c-parse.y. The `buffer' parameter contains
9926 the tail part of the directive line, i.e. the part which is past the
9927 initial whitespace, #, whitespace, directive-name, whitespace part. */
9930 dwarf2out_define (lineno, buffer)
9931 register unsigned lineno;
9932 register char *buffer;
9934 static int initialized = 0;
9937 dwarf2out_start_source_file (primary_filename);
9942 /* Called from check_newline in c-parse.y. The `buffer' parameter contains
9943 the tail part of the directive line, i.e. the part which is past the
9944 initial whitespace, #, whitespace, directive-name, whitespace part. */
9947 dwarf2out_undef (lineno, buffer)
9948 register unsigned lineno ATTRIBUTE_UNUSED;
9949 register char *buffer ATTRIBUTE_UNUSED;
9953 /* Set up for Dwarf output at the start of compilation. */
9956 dwarf2out_init (asm_out_file, main_input_filename)
9957 register FILE *asm_out_file;
9958 register char *main_input_filename;
9960 /* Remember the name of the primary input file. */
9961 primary_filename = main_input_filename;
9963 /* Allocate the initial hunk of the file_table. */
9964 file_table = (char **) xmalloc (FILE_TABLE_INCREMENT * sizeof (char *));
9965 bzero ((char *) file_table, FILE_TABLE_INCREMENT * sizeof (char *));
9966 file_table_allocated = FILE_TABLE_INCREMENT;
9968 /* Skip the first entry - file numbers begin at 1. */
9969 file_table_in_use = 1;
9971 /* Allocate the initial hunk of the decl_die_table. */
9973 = (dw_die_ref *) xmalloc (DECL_DIE_TABLE_INCREMENT * sizeof (dw_die_ref));
9974 bzero ((char *) decl_die_table,
9975 DECL_DIE_TABLE_INCREMENT * sizeof (dw_die_ref));
9976 decl_die_table_allocated = DECL_DIE_TABLE_INCREMENT;
9977 decl_die_table_in_use = 0;
9979 /* Allocate the initial hunk of the decl_scope_table. */
9981 = (decl_scope_node *) xmalloc (DECL_SCOPE_TABLE_INCREMENT
9982 * sizeof (decl_scope_node));
9983 bzero ((char *) decl_scope_table,
9984 DECL_SCOPE_TABLE_INCREMENT * sizeof (decl_scope_node));
9985 decl_scope_table_allocated = DECL_SCOPE_TABLE_INCREMENT;
9986 decl_scope_depth = 0;
9988 /* Allocate the initial hunk of the abbrev_die_table. */
9990 = (dw_die_ref *) xmalloc (ABBREV_DIE_TABLE_INCREMENT
9991 * sizeof (dw_die_ref));
9992 bzero ((char *) abbrev_die_table,
9993 ABBREV_DIE_TABLE_INCREMENT * sizeof (dw_die_ref));
9994 abbrev_die_table_allocated = ABBREV_DIE_TABLE_INCREMENT;
9995 /* Zero-th entry is allocated, but unused */
9996 abbrev_die_table_in_use = 1;
9998 /* Allocate the initial hunk of the line_info_table. */
10000 = (dw_line_info_ref) xmalloc (LINE_INFO_TABLE_INCREMENT
10001 * sizeof (dw_line_info_entry));
10002 bzero ((char *) line_info_table,
10003 LINE_INFO_TABLE_INCREMENT * sizeof (dw_line_info_entry));
10004 line_info_table_allocated = LINE_INFO_TABLE_INCREMENT;
10005 /* Zero-th entry is allocated, but unused */
10006 line_info_table_in_use = 1;
10008 /* Generate the initial DIE for the .debug section. Note that the (string)
10009 value given in the DW_AT_name attribute of the DW_TAG_compile_unit DIE
10010 will (typically) be a relative pathname and that this pathname should be
10011 taken as being relative to the directory from which the compiler was
10012 invoked when the given (base) source file was compiled. */
10013 gen_compile_unit_die (main_input_filename);
10015 ASM_GENERATE_INTERNAL_LABEL (text_end_label, TEXT_END_LABEL, 0);
10016 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label, ABBREV_SECTION_LABEL, 0);
10017 ASM_GENERATE_INTERNAL_LABEL (text_section_label, TEXT_SECTION_LABEL, 0);
10018 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label,
10019 DEBUG_INFO_SECTION_LABEL, 0);
10020 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label,
10021 DEBUG_LINE_SECTION_LABEL, 0);
10023 ASM_OUTPUT_SECTION (asm_out_file, ABBREV_SECTION);
10024 ASM_OUTPUT_LABEL (asm_out_file, abbrev_section_label);
10025 ASM_OUTPUT_SECTION (asm_out_file, TEXT_SECTION);
10026 ASM_OUTPUT_LABEL (asm_out_file, text_section_label);
10027 ASM_OUTPUT_SECTION (asm_out_file, DEBUG_INFO_SECTION);
10028 ASM_OUTPUT_LABEL (asm_out_file, debug_info_section_label);
10029 ASM_OUTPUT_SECTION (asm_out_file, DEBUG_LINE_SECTION);
10030 ASM_OUTPUT_LABEL (asm_out_file, debug_line_section_label);
10033 /* Output stuff that dwarf requires at the end of every file,
10034 and generate the DWARF-2 debugging info. */
10037 dwarf2out_finish ()
10039 limbo_die_node *node, *next_node;
10043 /* Traverse the limbo die list, and add parent/child links. The only
10044 dies without parents that should be here are concrete instances of
10045 inline functions, and the comp_unit_die. We can ignore the comp_unit_die.
10046 For concrete instances, we can get the parent die from the abstract
10048 for (node = limbo_die_list; node; node = next_node)
10050 next_node = node->next;
10053 if (die->die_parent == NULL)
10055 a = get_AT (die, DW_AT_abstract_origin);
10057 add_child_die (a->dw_attr_val.v.val_die_ref->die_parent, die);
10058 else if (die == comp_unit_die)
10066 /* Walk through the list of incomplete types again, trying once more to
10067 emit full debugging info for them. */
10068 retry_incomplete_types ();
10070 /* Traverse the DIE tree and add sibling attributes to those DIE's
10071 that have children. */
10072 add_sibling_attributes (comp_unit_die);
10074 /* Output a terminator label for the .text section. */
10075 fputc ('\n', asm_out_file);
10076 ASM_OUTPUT_SECTION (asm_out_file, TEXT_SECTION);
10077 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, TEXT_END_LABEL, 0);
10080 /* Output a terminator label for the .data section. */
10081 fputc ('\n', asm_out_file);
10082 ASM_OUTPUT_SECTION (asm_out_file, DATA_SECTION);
10083 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, DATA_END_LABEL, 0);
10085 /* Output a terminator label for the .bss section. */
10086 fputc ('\n', asm_out_file);
10087 ASM_OUTPUT_SECTION (asm_out_file, BSS_SECTION);
10088 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, BSS_END_LABEL, 0);
10091 /* Output the source line correspondence table. */
10092 if (line_info_table_in_use > 1 || separate_line_info_table_in_use)
10094 fputc ('\n', asm_out_file);
10095 ASM_OUTPUT_SECTION (asm_out_file, DEBUG_LINE_SECTION);
10096 output_line_info ();
10098 /* We can only use the low/high_pc attributes if all of the code
10100 if (separate_line_info_table_in_use == 0)
10102 add_AT_lbl_id (comp_unit_die, DW_AT_low_pc, text_section_label);
10103 add_AT_lbl_id (comp_unit_die, DW_AT_high_pc, text_end_label);
10106 add_AT_lbl_offset (comp_unit_die, DW_AT_stmt_list,
10107 debug_line_section_label);
10110 /* Output the abbreviation table. */
10111 fputc ('\n', asm_out_file);
10112 ASM_OUTPUT_SECTION (asm_out_file, ABBREV_SECTION);
10113 build_abbrev_table (comp_unit_die);
10114 output_abbrev_section ();
10116 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
10117 next_die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE;
10118 calc_die_sizes (comp_unit_die);
10120 /* Output debugging information. */
10121 fputc ('\n', asm_out_file);
10122 ASM_OUTPUT_SECTION (asm_out_file, DEBUG_INFO_SECTION);
10123 output_compilation_unit_header ();
10124 output_die (comp_unit_die);
10126 if (pubname_table_in_use)
10128 /* Output public names table. */
10129 fputc ('\n', asm_out_file);
10130 ASM_OUTPUT_SECTION (asm_out_file, PUBNAMES_SECTION);
10131 output_pubnames ();
10134 if (fde_table_in_use)
10136 /* Output the address range information. */
10137 fputc ('\n', asm_out_file);
10138 ASM_OUTPUT_SECTION (asm_out_file, ARANGES_SECTION);
10142 #endif /* DWARF2_DEBUGGING_INFO */