1 /* Output Dwarf2 format symbol table information from the GNU C compiler.
2 Copyright (C) 1992, 93, 95-98, 1999 Free Software Foundation, Inc.
3 Contributed by Gary Funck (gary@intrepid.com).
4 Derived from DWARF 1 implementation of Ron Guilmette (rfg@monkeys.com).
5 Extensively modified by Jason Merrill (jason@cygnus.com).
7 This file is part of GNU CC.
9 GNU CC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2, or (at your option)
14 GNU CC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GNU CC; see the file COPYING. If not, write to
21 the Free Software Foundation, 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
24 /* The first part of this file deals with the DWARF 2 frame unwind
25 information, which is also used by the GCC efficient exception handling
26 mechanism. The second part, controlled only by an #ifdef
27 DWARF2_DEBUGGING_INFO, deals with the other DWARF 2 debugging
36 #include "hard-reg-set.h"
38 #include "insn-config.h"
44 #include "dwarf2out.h"
46 #include "dyn-string.h"
48 /* We cannot use <assert.h> in GCC source, since that would include
49 GCC's assert.h, which may not be compatible with the host compiler. */
54 # define assert(e) do { if (! (e)) abort (); } while (0)
57 /* Decide whether we want to emit frame unwind information for the current
63 return (write_symbols == DWARF2_DEBUG
64 #ifdef DWARF2_FRAME_INFO
67 #ifdef DWARF2_UNWIND_INFO
68 || (flag_exceptions && ! exceptions_via_longjmp)
73 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
75 /* How to start an assembler comment. */
76 #ifndef ASM_COMMENT_START
77 #define ASM_COMMENT_START ";#"
80 typedef struct dw_cfi_struct *dw_cfi_ref;
81 typedef struct dw_fde_struct *dw_fde_ref;
82 typedef union dw_cfi_oprnd_struct *dw_cfi_oprnd_ref;
84 /* Call frames are described using a sequence of Call Frame
85 Information instructions. The register number, offset
86 and address fields are provided as possible operands;
87 their use is selected by the opcode field. */
89 typedef union dw_cfi_oprnd_struct
91 unsigned long dw_cfi_reg_num;
92 long int dw_cfi_offset;
97 typedef struct dw_cfi_struct
99 dw_cfi_ref dw_cfi_next;
100 enum dwarf_call_frame_info dw_cfi_opc;
101 dw_cfi_oprnd dw_cfi_oprnd1;
102 dw_cfi_oprnd dw_cfi_oprnd2;
106 /* All call frame descriptions (FDE's) in the GCC generated DWARF
107 refer to a single Common Information Entry (CIE), defined at
108 the beginning of the .debug_frame section. This used of a single
109 CIE obviates the need to keep track of multiple CIE's
110 in the DWARF generation routines below. */
112 typedef struct dw_fde_struct
115 char *dw_fde_current_label;
117 dw_cfi_ref dw_fde_cfi;
121 /* Maximum size (in bytes) of an artificially generated label. */
122 #define MAX_ARTIFICIAL_LABEL_BYTES 30
124 /* Make sure we know the sizes of the various types dwarf can describe. These
125 are only defaults. If the sizes are different for your target, you should
126 override these values by defining the appropriate symbols in your tm.h
129 #ifndef CHAR_TYPE_SIZE
130 #define CHAR_TYPE_SIZE BITS_PER_UNIT
133 #define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
136 /* The size in bytes of a DWARF field indicating an offset or length
137 relative to a debug info section, specified to be 4 bytes in the DWARF-2
138 specification. The SGI/MIPS ABI defines it to be the same as PTR_SIZE. */
140 #ifndef DWARF_OFFSET_SIZE
141 #define DWARF_OFFSET_SIZE 4
144 #define DWARF_VERSION 2
146 /* Round SIZE up to the nearest BOUNDARY. */
147 #define DWARF_ROUND(SIZE,BOUNDARY) \
148 (((SIZE) + (BOUNDARY) - 1) & ~((BOUNDARY) - 1))
150 /* Offsets recorded in opcodes are a multiple of this alignment factor. */
151 #ifdef STACK_GROWS_DOWNWARD
152 #define DWARF_CIE_DATA_ALIGNMENT (-UNITS_PER_WORD)
154 #define DWARF_CIE_DATA_ALIGNMENT UNITS_PER_WORD
157 /* A pointer to the base of a table that contains frame description
158 information for each routine. */
159 static dw_fde_ref fde_table;
161 /* Number of elements currently allocated for fde_table. */
162 static unsigned fde_table_allocated;
164 /* Number of elements in fde_table currently in use. */
165 static unsigned fde_table_in_use;
167 /* Size (in elements) of increments by which we may expand the
169 #define FDE_TABLE_INCREMENT 256
171 /* A list of call frame insns for the CIE. */
172 static dw_cfi_ref cie_cfi_head;
174 /* The number of the current function definition for which debugging
175 information is being generated. These numbers range from 1 up to the
176 maximum number of function definitions contained within the current
177 compilation unit. These numbers are used to create unique label id's
178 unique to each function definition. */
179 static unsigned current_funcdef_number = 0;
181 /* Some DWARF extensions (e.g., MIPS/SGI) implement a subprogram
182 attribute that accelerates the lookup of the FDE associated
183 with the subprogram. This variable holds the table index of the FDE
184 associated with the current function (body) definition. */
185 static unsigned current_funcdef_fde;
187 /* Forward declarations for functions defined in this file. */
189 static char *stripattributes PROTO((const char *));
190 static const char *dwarf_cfi_name PROTO((unsigned));
191 static dw_cfi_ref new_cfi PROTO((void));
192 static void add_cfi PROTO((dw_cfi_ref *, dw_cfi_ref));
193 static unsigned long size_of_uleb128 PROTO((unsigned long));
194 static unsigned long size_of_sleb128 PROTO((long));
195 static void output_uleb128 PROTO((unsigned long));
196 static void output_sleb128 PROTO((long));
197 static void add_fde_cfi PROTO((char *, dw_cfi_ref));
198 static void lookup_cfa_1 PROTO((dw_cfi_ref, unsigned long *,
200 static void lookup_cfa PROTO((unsigned long *, long *));
201 static void reg_save PROTO((char *, unsigned, unsigned,
203 static void initial_return_save PROTO((rtx));
204 static void output_cfi PROTO((dw_cfi_ref, dw_fde_ref));
205 static void output_call_frame_info PROTO((int));
206 static unsigned reg_number PROTO((rtx));
207 static void dwarf2out_stack_adjust PROTO((rtx));
208 static void dwarf2out_frame_debug_expr PROTO((rtx, char *));
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 const 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";
725 return "DW_CFA_<unknown>";
729 /* Return a pointer to a newly allocated Call Frame Instruction. */
731 static inline dw_cfi_ref
734 register dw_cfi_ref cfi = (dw_cfi_ref) xmalloc (sizeof (dw_cfi_node));
736 cfi->dw_cfi_next = NULL;
737 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = 0;
738 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = 0;
743 /* Add a Call Frame Instruction to list of instructions. */
746 add_cfi (list_head, cfi)
747 register dw_cfi_ref *list_head;
748 register dw_cfi_ref cfi;
750 register dw_cfi_ref *p;
752 /* Find the end of the chain. */
753 for (p = list_head; (*p) != NULL; p = &(*p)->dw_cfi_next)
759 /* Generate a new label for the CFI info to refer to. */
762 dwarf2out_cfi_label ()
764 static char label[20];
765 static unsigned long label_num = 0;
767 ASM_GENERATE_INTERNAL_LABEL (label, "LCFI", label_num++);
768 ASM_OUTPUT_LABEL (asm_out_file, label);
773 /* Add CFI to the current fde at the PC value indicated by LABEL if specified,
774 or to the CIE if LABEL is NULL. */
777 add_fde_cfi (label, cfi)
778 register char *label;
779 register dw_cfi_ref cfi;
783 register dw_fde_ref fde = &fde_table[fde_table_in_use - 1];
786 label = dwarf2out_cfi_label ();
788 if (fde->dw_fde_current_label == NULL
789 || strcmp (label, fde->dw_fde_current_label) != 0)
791 register dw_cfi_ref xcfi;
793 fde->dw_fde_current_label = label = xstrdup (label);
795 /* Set the location counter to the new label. */
797 xcfi->dw_cfi_opc = DW_CFA_advance_loc4;
798 xcfi->dw_cfi_oprnd1.dw_cfi_addr = label;
799 add_cfi (&fde->dw_fde_cfi, xcfi);
802 add_cfi (&fde->dw_fde_cfi, cfi);
806 add_cfi (&cie_cfi_head, cfi);
809 /* Subroutine of lookup_cfa. */
812 lookup_cfa_1 (cfi, regp, offsetp)
813 register dw_cfi_ref cfi;
814 register unsigned long *regp;
815 register long *offsetp;
817 switch (cfi->dw_cfi_opc)
819 case DW_CFA_def_cfa_offset:
820 *offsetp = cfi->dw_cfi_oprnd1.dw_cfi_offset;
822 case DW_CFA_def_cfa_register:
823 *regp = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
826 *regp = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
827 *offsetp = cfi->dw_cfi_oprnd2.dw_cfi_offset;
834 /* Find the previous value for the CFA. */
837 lookup_cfa (regp, offsetp)
838 register unsigned long *regp;
839 register long *offsetp;
841 register dw_cfi_ref cfi;
843 *regp = (unsigned long) -1;
846 for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
847 lookup_cfa_1 (cfi, regp, offsetp);
849 if (fde_table_in_use)
851 register dw_fde_ref fde = &fde_table[fde_table_in_use - 1];
852 for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
853 lookup_cfa_1 (cfi, regp, offsetp);
857 /* The current rule for calculating the DWARF2 canonical frame address. */
858 static unsigned long cfa_reg;
859 static long cfa_offset;
861 /* The register used for saving registers to the stack, and its offset
863 static unsigned cfa_store_reg;
864 static long cfa_store_offset;
866 /* The running total of the size of arguments pushed onto the stack. */
867 static long args_size;
869 /* The last args_size we actually output. */
870 static long old_args_size;
872 /* Entry point to update the canonical frame address (CFA).
873 LABEL is passed to add_fde_cfi. The value of CFA is now to be
874 calculated from REG+OFFSET. */
877 dwarf2out_def_cfa (label, reg, offset)
878 register char *label;
879 register unsigned reg;
880 register long offset;
882 register dw_cfi_ref cfi;
883 unsigned long old_reg;
888 if (cfa_store_reg == reg)
889 cfa_store_offset = offset;
891 reg = DWARF_FRAME_REGNUM (reg);
892 lookup_cfa (&old_reg, &old_offset);
894 if (reg == old_reg && offset == old_offset)
901 cfi->dw_cfi_opc = DW_CFA_def_cfa_offset;
902 cfi->dw_cfi_oprnd1.dw_cfi_offset = offset;
905 #ifndef MIPS_DEBUGGING_INFO /* SGI dbx thinks this means no offset. */
906 else if (offset == old_offset && old_reg != (unsigned long) -1)
908 cfi->dw_cfi_opc = DW_CFA_def_cfa_register;
909 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
915 cfi->dw_cfi_opc = DW_CFA_def_cfa;
916 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
917 cfi->dw_cfi_oprnd2.dw_cfi_offset = offset;
920 add_fde_cfi (label, cfi);
923 /* Add the CFI for saving a register. REG is the CFA column number.
924 LABEL is passed to add_fde_cfi.
925 If SREG is -1, the register is saved at OFFSET from the CFA;
926 otherwise it is saved in SREG. */
929 reg_save (label, reg, sreg, offset)
930 register char * label;
931 register unsigned reg;
932 register unsigned sreg;
933 register long offset;
935 register dw_cfi_ref cfi = new_cfi ();
937 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
939 /* The following comparison is correct. -1 is used to indicate that
940 the value isn't a register number. */
941 if (sreg == (unsigned int) -1)
944 /* The register number won't fit in 6 bits, so we have to use
946 cfi->dw_cfi_opc = DW_CFA_offset_extended;
948 cfi->dw_cfi_opc = DW_CFA_offset;
950 offset /= DWARF_CIE_DATA_ALIGNMENT;
953 cfi->dw_cfi_oprnd2.dw_cfi_offset = offset;
957 cfi->dw_cfi_opc = DW_CFA_register;
958 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = sreg;
961 add_fde_cfi (label, cfi);
964 /* Add the CFI for saving a register window. LABEL is passed to reg_save.
965 This CFI tells the unwinder that it needs to restore the window registers
966 from the previous frame's window save area.
968 ??? Perhaps we should note in the CIE where windows are saved (instead of
969 assuming 0(cfa)) and what registers are in the window. */
972 dwarf2out_window_save (label)
973 register char * label;
975 register dw_cfi_ref cfi = new_cfi ();
976 cfi->dw_cfi_opc = DW_CFA_GNU_window_save;
977 add_fde_cfi (label, cfi);
980 /* Add a CFI to update the running total of the size of arguments
981 pushed onto the stack. */
984 dwarf2out_args_size (label, size)
988 register dw_cfi_ref cfi;
990 if (size == old_args_size)
992 old_args_size = size;
995 cfi->dw_cfi_opc = DW_CFA_GNU_args_size;
996 cfi->dw_cfi_oprnd1.dw_cfi_offset = size;
997 add_fde_cfi (label, cfi);
1000 /* Entry point for saving a register to the stack. REG is the GCC register
1001 number. LABEL and OFFSET are passed to reg_save. */
1004 dwarf2out_reg_save (label, reg, offset)
1005 register char * label;
1006 register unsigned reg;
1007 register long offset;
1009 reg_save (label, DWARF_FRAME_REGNUM (reg), -1, offset);
1012 /* Entry point for saving the return address in the stack.
1013 LABEL and OFFSET are passed to reg_save. */
1016 dwarf2out_return_save (label, offset)
1017 register char * label;
1018 register long offset;
1020 reg_save (label, DWARF_FRAME_RETURN_COLUMN, -1, offset);
1023 /* Entry point for saving the return address in a register.
1024 LABEL and SREG are passed to reg_save. */
1027 dwarf2out_return_reg (label, sreg)
1028 register char * label;
1029 register unsigned sreg;
1031 reg_save (label, DWARF_FRAME_RETURN_COLUMN, sreg, 0);
1034 /* Record the initial position of the return address. RTL is
1035 INCOMING_RETURN_ADDR_RTX. */
1038 initial_return_save (rtl)
1041 unsigned int reg = (unsigned int) -1;
1044 switch (GET_CODE (rtl))
1047 /* RA is in a register. */
1048 reg = reg_number (rtl);
1051 /* RA is on the stack. */
1052 rtl = XEXP (rtl, 0);
1053 switch (GET_CODE (rtl))
1056 if (REGNO (rtl) != STACK_POINTER_REGNUM)
1061 if (REGNO (XEXP (rtl, 0)) != STACK_POINTER_REGNUM)
1063 offset = INTVAL (XEXP (rtl, 1));
1066 if (REGNO (XEXP (rtl, 0)) != STACK_POINTER_REGNUM)
1068 offset = -INTVAL (XEXP (rtl, 1));
1075 /* The return address is at some offset from any value we can
1076 actually load. For instance, on the SPARC it is in %i7+8. Just
1077 ignore the offset for now; it doesn't matter for unwinding frames. */
1078 if (GET_CODE (XEXP (rtl, 1)) != CONST_INT)
1080 initial_return_save (XEXP (rtl, 0));
1086 reg_save (NULL, DWARF_FRAME_RETURN_COLUMN, reg, offset - cfa_offset);
1089 /* Check INSN to see if it looks like a push or a stack adjustment, and
1090 make a note of it if it does. EH uses this information to find out how
1091 much extra space it needs to pop off the stack. */
1094 dwarf2out_stack_adjust (insn)
1100 if (! asynchronous_exceptions && GET_CODE (insn) == CALL_INSN)
1102 /* Extract the size of the args from the CALL rtx itself. */
1104 insn = PATTERN (insn);
1105 if (GET_CODE (insn) == PARALLEL)
1106 insn = XVECEXP (insn, 0, 0);
1107 if (GET_CODE (insn) == SET)
1108 insn = SET_SRC (insn);
1109 assert (GET_CODE (insn) == CALL);
1110 dwarf2out_args_size ("", INTVAL (XEXP (insn, 1)));
1114 /* If only calls can throw, and we have a frame pointer,
1115 save up adjustments until we see the CALL_INSN. */
1116 else if (! asynchronous_exceptions
1117 && cfa_reg != STACK_POINTER_REGNUM)
1120 if (GET_CODE (insn) == BARRIER)
1122 /* When we see a BARRIER, we know to reset args_size to 0. Usually
1123 the compiler will have already emitted a stack adjustment, but
1124 doesn't bother for calls to noreturn functions. */
1125 #ifdef STACK_GROWS_DOWNWARD
1126 offset = -args_size;
1131 else if (GET_CODE (PATTERN (insn)) == SET)
1136 insn = PATTERN (insn);
1137 src = SET_SRC (insn);
1138 dest = SET_DEST (insn);
1140 if (dest == stack_pointer_rtx)
1142 /* (set (reg sp) (plus (reg sp) (const_int))) */
1143 code = GET_CODE (src);
1144 if (! (code == PLUS || code == MINUS)
1145 || XEXP (src, 0) != stack_pointer_rtx
1146 || GET_CODE (XEXP (src, 1)) != CONST_INT)
1149 offset = INTVAL (XEXP (src, 1));
1151 else if (GET_CODE (dest) == MEM)
1153 /* (set (mem (pre_dec (reg sp))) (foo)) */
1154 src = XEXP (dest, 0);
1155 code = GET_CODE (src);
1157 if (! (code == PRE_DEC || code == PRE_INC)
1158 || XEXP (src, 0) != stack_pointer_rtx)
1161 offset = GET_MODE_SIZE (GET_MODE (dest));
1166 if (code == PLUS || code == PRE_INC)
1175 if (cfa_reg == STACK_POINTER_REGNUM)
1176 cfa_offset += offset;
1178 #ifndef STACK_GROWS_DOWNWARD
1181 args_size += offset;
1185 label = dwarf2out_cfi_label ();
1186 dwarf2out_def_cfa (label, cfa_reg, cfa_offset);
1187 dwarf2out_args_size (label, args_size);
1190 /* A temporary register used in adjusting SP or setting up the store_reg. */
1191 static unsigned cfa_temp_reg;
1193 /* A temporary value used in adjusting SP or setting up the store_reg. */
1194 static long cfa_temp_value;
1196 /* Record call frame debugging information for an expression, which either
1197 sets SP or FP (adjusting how we calculate the frame address) or saves a
1198 register to the stack. */
1201 dwarf2out_frame_debug_expr (expr, label)
1208 /* If RTX_FRAME_RELATED_P is set on a PARALLEL, process each member of
1209 the PARALLEL independantly. The first element is always processed if
1210 it is a SET. This is for backward compatability. Other elements
1211 are processed only if they are SETs and the RTX_FRAME_RELATED_P
1212 flag is set in them. */
1214 if (GET_CODE (expr) == PARALLEL)
1217 int limit = XVECLEN (expr, 0);
1219 for (par_index = 0; par_index < limit; par_index++)
1221 rtx x = XVECEXP (expr, 0, par_index);
1223 if (GET_CODE (x) == SET &&
1224 (RTX_FRAME_RELATED_P (x) || par_index == 0))
1225 dwarf2out_frame_debug_expr (x, label);
1230 if (GET_CODE (expr) != SET)
1233 src = SET_SRC (expr);
1234 dest = SET_DEST (expr);
1236 switch (GET_CODE (dest))
1239 /* Update the CFA rule wrt SP or FP. Make sure src is
1240 relative to the current CFA register. */
1241 switch (GET_CODE (src))
1243 /* Setting FP from SP. */
1245 if (cfa_reg != (unsigned) REGNO (src))
1247 if (REGNO (dest) != STACK_POINTER_REGNUM
1248 && !(frame_pointer_needed
1249 && REGNO (dest) == HARD_FRAME_POINTER_REGNUM))
1251 cfa_reg = REGNO (dest);
1256 if (dest == stack_pointer_rtx)
1259 switch (GET_CODE (XEXP (src, 1)))
1262 offset = INTVAL (XEXP (src, 1));
1265 if ((unsigned) REGNO (XEXP (src, 1)) != cfa_temp_reg)
1267 offset = cfa_temp_value;
1273 if (XEXP (src, 0) == hard_frame_pointer_rtx)
1275 /* Restoring SP from FP in the epilogue. */
1276 if (cfa_reg != (unsigned) HARD_FRAME_POINTER_REGNUM)
1278 cfa_reg = STACK_POINTER_REGNUM;
1280 else if (XEXP (src, 0) != stack_pointer_rtx)
1283 if (GET_CODE (src) == PLUS)
1285 if (cfa_reg == STACK_POINTER_REGNUM)
1286 cfa_offset += offset;
1287 if (cfa_store_reg == STACK_POINTER_REGNUM)
1288 cfa_store_offset += offset;
1290 else if (dest == hard_frame_pointer_rtx)
1292 /* Either setting the FP from an offset of the SP,
1293 or adjusting the FP */
1294 if (! frame_pointer_needed
1295 || REGNO (dest) != HARD_FRAME_POINTER_REGNUM)
1298 if (XEXP (src, 0) == stack_pointer_rtx
1299 && GET_CODE (XEXP (src, 1)) == CONST_INT)
1301 if (cfa_reg != STACK_POINTER_REGNUM)
1303 offset = INTVAL (XEXP (src, 1));
1304 if (GET_CODE (src) == PLUS)
1306 cfa_offset += offset;
1307 cfa_reg = HARD_FRAME_POINTER_REGNUM;
1309 else if (XEXP (src, 0) == hard_frame_pointer_rtx
1310 && GET_CODE (XEXP (src, 1)) == CONST_INT)
1312 if (cfa_reg != (unsigned) HARD_FRAME_POINTER_REGNUM)
1314 offset = INTVAL (XEXP (src, 1));
1315 if (GET_CODE (src) == PLUS)
1317 cfa_offset += offset;
1325 if (GET_CODE (src) != PLUS
1326 || XEXP (src, 1) != stack_pointer_rtx)
1328 if (GET_CODE (XEXP (src, 0)) != REG
1329 || (unsigned) REGNO (XEXP (src, 0)) != cfa_temp_reg)
1331 if (cfa_reg != STACK_POINTER_REGNUM)
1333 cfa_store_reg = REGNO (dest);
1334 cfa_store_offset = cfa_offset - cfa_temp_value;
1339 cfa_temp_reg = REGNO (dest);
1340 cfa_temp_value = INTVAL (src);
1344 if (GET_CODE (XEXP (src, 0)) != REG
1345 || (unsigned) REGNO (XEXP (src, 0)) != cfa_temp_reg
1346 || (unsigned) REGNO (dest) != cfa_temp_reg
1347 || GET_CODE (XEXP (src, 1)) != CONST_INT)
1349 cfa_temp_value |= INTVAL (XEXP (src, 1));
1355 dwarf2out_def_cfa (label, cfa_reg, cfa_offset);
1359 /* Saving a register to the stack. Make sure dest is relative to the
1361 if (GET_CODE (src) != REG)
1363 switch (GET_CODE (XEXP (dest, 0)))
1368 offset = GET_MODE_SIZE (GET_MODE (dest));
1369 if (GET_CODE (XEXP (dest, 0)) == PRE_INC)
1372 if (REGNO (XEXP (XEXP (dest, 0), 0)) != STACK_POINTER_REGNUM
1373 || cfa_store_reg != STACK_POINTER_REGNUM)
1375 cfa_store_offset += offset;
1376 if (cfa_reg == STACK_POINTER_REGNUM)
1377 cfa_offset = cfa_store_offset;
1379 offset = -cfa_store_offset;
1382 /* With an offset. */
1385 offset = INTVAL (XEXP (XEXP (dest, 0), 1));
1386 if (GET_CODE (XEXP (dest, 0)) == MINUS)
1389 if (cfa_store_reg != (unsigned) REGNO (XEXP (XEXP (dest, 0), 0)))
1391 offset -= cfa_store_offset;
1394 /* Without an offset. */
1396 if (cfa_store_reg != (unsigned) REGNO (XEXP (dest, 0)))
1398 offset = -cfa_store_offset;
1404 dwarf2out_def_cfa (label, cfa_reg, cfa_offset);
1405 dwarf2out_reg_save (label, REGNO (src), offset);
1414 /* Record call frame debugging information for INSN, which either
1415 sets SP or FP (adjusting how we calculate the frame address) or saves a
1416 register to the stack. If INSN is NULL_RTX, initialize our state. */
1419 dwarf2out_frame_debug (insn)
1425 if (insn == NULL_RTX)
1427 /* Set up state for generating call frame debug info. */
1428 lookup_cfa (&cfa_reg, &cfa_offset);
1429 if (cfa_reg != DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM))
1431 cfa_reg = STACK_POINTER_REGNUM;
1432 cfa_store_reg = cfa_reg;
1433 cfa_store_offset = cfa_offset;
1439 if (! RTX_FRAME_RELATED_P (insn))
1441 dwarf2out_stack_adjust (insn);
1445 label = dwarf2out_cfi_label ();
1447 src = find_reg_note (insn, REG_FRAME_RELATED_EXPR, NULL_RTX);
1449 insn = XEXP (src, 0);
1451 insn = PATTERN (insn);
1453 dwarf2out_frame_debug_expr (insn, label);
1456 /* Return the size of an unsigned LEB128 quantity. */
1458 static inline unsigned long
1459 size_of_uleb128 (value)
1460 register unsigned long value;
1462 register unsigned long size = 0;
1463 register unsigned byte;
1467 byte = (value & 0x7f);
1476 /* Return the size of a signed LEB128 quantity. */
1478 static inline unsigned long
1479 size_of_sleb128 (value)
1480 register long value;
1482 register unsigned long size = 0;
1483 register unsigned byte;
1487 byte = (value & 0x7f);
1491 while (!(((value == 0) && ((byte & 0x40) == 0))
1492 || ((value == -1) && ((byte & 0x40) != 0))));
1497 /* Output an unsigned LEB128 quantity. */
1500 output_uleb128 (value)
1501 register unsigned long value;
1503 unsigned long save_value = value;
1505 fprintf (asm_out_file, "\t%s\t", ASM_BYTE_OP);
1508 register unsigned byte = (value & 0x7f);
1511 /* More bytes to follow. */
1514 fprintf (asm_out_file, "0x%x", byte);
1516 fprintf (asm_out_file, ",");
1521 fprintf (asm_out_file, "\t%s ULEB128 0x%lx", ASM_COMMENT_START, save_value);
1524 /* Output an signed LEB128 quantity. */
1527 output_sleb128 (value)
1528 register long value;
1531 register unsigned byte;
1532 long save_value = value;
1534 fprintf (asm_out_file, "\t%s\t", ASM_BYTE_OP);
1537 byte = (value & 0x7f);
1538 /* arithmetic shift */
1540 more = !((((value == 0) && ((byte & 0x40) == 0))
1541 || ((value == -1) && ((byte & 0x40) != 0))));
1545 fprintf (asm_out_file, "0x%x", byte);
1547 fprintf (asm_out_file, ",");
1552 fprintf (asm_out_file, "\t%s SLEB128 %ld", ASM_COMMENT_START, save_value);
1555 /* Output a Call Frame Information opcode and its operand(s). */
1558 output_cfi (cfi, fde)
1559 register dw_cfi_ref cfi;
1560 register dw_fde_ref fde;
1562 if (cfi->dw_cfi_opc == DW_CFA_advance_loc)
1564 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
1566 | (cfi->dw_cfi_oprnd1.dw_cfi_offset & 0x3f));
1568 fprintf (asm_out_file, "\t%s DW_CFA_advance_loc 0x%lx",
1569 ASM_COMMENT_START, cfi->dw_cfi_oprnd1.dw_cfi_offset);
1570 fputc ('\n', asm_out_file);
1573 else if (cfi->dw_cfi_opc == DW_CFA_offset)
1575 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
1577 | (cfi->dw_cfi_oprnd1.dw_cfi_reg_num & 0x3f));
1579 fprintf (asm_out_file, "\t%s DW_CFA_offset, column 0x%lx",
1580 ASM_COMMENT_START, cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
1582 fputc ('\n', asm_out_file);
1583 output_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset);
1584 fputc ('\n', asm_out_file);
1586 else if (cfi->dw_cfi_opc == DW_CFA_restore)
1588 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
1590 | (cfi->dw_cfi_oprnd1.dw_cfi_reg_num & 0x3f));
1592 fprintf (asm_out_file, "\t%s DW_CFA_restore, column 0x%lx",
1593 ASM_COMMENT_START, cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
1595 fputc ('\n', asm_out_file);
1599 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, cfi->dw_cfi_opc);
1601 fprintf (asm_out_file, "\t%s %s", ASM_COMMENT_START,
1602 dwarf_cfi_name (cfi->dw_cfi_opc));
1604 fputc ('\n', asm_out_file);
1605 switch (cfi->dw_cfi_opc)
1607 case DW_CFA_set_loc:
1608 ASM_OUTPUT_DWARF_ADDR (asm_out_file, cfi->dw_cfi_oprnd1.dw_cfi_addr);
1609 fputc ('\n', asm_out_file);
1611 case DW_CFA_advance_loc1:
1612 ASM_OUTPUT_DWARF_DELTA1 (asm_out_file,
1613 cfi->dw_cfi_oprnd1.dw_cfi_addr,
1614 fde->dw_fde_current_label);
1615 fputc ('\n', asm_out_file);
1616 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
1618 case DW_CFA_advance_loc2:
1619 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file,
1620 cfi->dw_cfi_oprnd1.dw_cfi_addr,
1621 fde->dw_fde_current_label);
1622 fputc ('\n', asm_out_file);
1623 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
1625 case DW_CFA_advance_loc4:
1626 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file,
1627 cfi->dw_cfi_oprnd1.dw_cfi_addr,
1628 fde->dw_fde_current_label);
1629 fputc ('\n', asm_out_file);
1630 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
1632 #ifdef MIPS_DEBUGGING_INFO
1633 case DW_CFA_MIPS_advance_loc8:
1634 /* TODO: not currently implemented. */
1638 case DW_CFA_offset_extended:
1639 case DW_CFA_def_cfa:
1640 output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
1641 fputc ('\n', asm_out_file);
1642 output_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset);
1643 fputc ('\n', asm_out_file);
1645 case DW_CFA_restore_extended:
1646 case DW_CFA_undefined:
1647 output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
1648 fputc ('\n', asm_out_file);
1650 case DW_CFA_same_value:
1651 case DW_CFA_def_cfa_register:
1652 output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
1653 fputc ('\n', asm_out_file);
1655 case DW_CFA_register:
1656 output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
1657 fputc ('\n', asm_out_file);
1658 output_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_reg_num);
1659 fputc ('\n', asm_out_file);
1661 case DW_CFA_def_cfa_offset:
1662 output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset);
1663 fputc ('\n', asm_out_file);
1665 case DW_CFA_GNU_window_save:
1667 case DW_CFA_GNU_args_size:
1668 output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset);
1669 fputc ('\n', asm_out_file);
1677 #if !defined (EH_FRAME_SECTION)
1678 #if defined (EH_FRAME_SECTION_ASM_OP)
1679 #define EH_FRAME_SECTION() eh_frame_section();
1681 #if defined (ASM_OUTPUT_SECTION_NAME)
1682 #define EH_FRAME_SECTION() \
1684 named_section (NULL_TREE, ".eh_frame", 0); \
1690 /* If we aren't using crtstuff to run ctors, don't use it for EH. */
1691 #if !defined (HAS_INIT_SECTION) && !defined (INIT_SECTION_ASM_OP)
1692 #undef EH_FRAME_SECTION
1695 /* Output the call frame information used to used to record information
1696 that relates to calculating the frame pointer, and records the
1697 location of saved registers. */
1700 output_call_frame_info (for_eh)
1703 register unsigned long i;
1704 register dw_fde_ref fde;
1705 register dw_cfi_ref cfi;
1706 char l1[20], l2[20];
1707 #ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
1711 /* Do we want to include a pointer to the exception table? */
1712 int eh_ptr = for_eh && exception_table_p ();
1714 fputc ('\n', asm_out_file);
1716 /* We're going to be generating comments, so turn on app. */
1722 #ifdef EH_FRAME_SECTION
1723 EH_FRAME_SECTION ();
1725 tree label = get_file_function_name ('F');
1727 force_data_section ();
1728 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
1729 ASM_GLOBALIZE_LABEL (asm_out_file, IDENTIFIER_POINTER (label));
1730 ASM_OUTPUT_LABEL (asm_out_file, IDENTIFIER_POINTER (label));
1732 assemble_label ("__FRAME_BEGIN__");
1735 ASM_OUTPUT_SECTION (asm_out_file, FRAME_SECTION);
1737 /* Output the CIE. */
1738 ASM_GENERATE_INTERNAL_LABEL (l1, CIE_AFTER_SIZE_LABEL, for_eh);
1739 ASM_GENERATE_INTERNAL_LABEL (l2, CIE_END_LABEL, for_eh);
1740 #ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
1741 ASM_GENERATE_INTERNAL_LABEL (ld, CIE_LENGTH_LABEL, for_eh);
1743 ASM_OUTPUT_DWARF_OFFSET4 (asm_out_file, ld);
1745 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, ld);
1748 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, l2, l1);
1750 ASM_OUTPUT_DWARF_DELTA (asm_out_file, l2, l1);
1753 fprintf (asm_out_file, "\t%s Length of Common Information Entry",
1756 fputc ('\n', asm_out_file);
1757 ASM_OUTPUT_LABEL (asm_out_file, l1);
1760 /* Now that the CIE pointer is PC-relative for EH,
1761 use 0 to identify the CIE. */
1762 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0);
1764 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, DW_CIE_ID);
1767 fprintf (asm_out_file, "\t%s CIE Identifier Tag", ASM_COMMENT_START);
1769 fputc ('\n', asm_out_file);
1770 if (! for_eh && DWARF_OFFSET_SIZE == 8)
1772 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, DW_CIE_ID);
1773 fputc ('\n', asm_out_file);
1776 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_CIE_VERSION);
1778 fprintf (asm_out_file, "\t%s CIE Version", ASM_COMMENT_START);
1780 fputc ('\n', asm_out_file);
1783 /* The CIE contains a pointer to the exception region info for the
1784 frame. Make the augmentation string three bytes (including the
1785 trailing null) so the pointer is 4-byte aligned. The Solaris ld
1786 can't handle unaligned relocs. */
1789 ASM_OUTPUT_DWARF_STRING (asm_out_file, "eh");
1790 fprintf (asm_out_file, "\t%s CIE Augmentation", ASM_COMMENT_START);
1794 ASM_OUTPUT_ASCII (asm_out_file, "eh", 3);
1796 fputc ('\n', asm_out_file);
1798 ASM_OUTPUT_DWARF_ADDR (asm_out_file, "__EXCEPTION_TABLE__");
1800 fprintf (asm_out_file, "\t%s pointer to exception region info",
1805 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
1807 fprintf (asm_out_file, "\t%s CIE Augmentation (none)",
1811 fputc ('\n', asm_out_file);
1814 fprintf (asm_out_file, " (CIE Code Alignment Factor)");
1816 fputc ('\n', asm_out_file);
1817 output_sleb128 (DWARF_CIE_DATA_ALIGNMENT);
1819 fprintf (asm_out_file, " (CIE Data Alignment Factor)");
1821 fputc ('\n', asm_out_file);
1822 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DWARF_FRAME_RETURN_COLUMN);
1824 fprintf (asm_out_file, "\t%s CIE RA Column", ASM_COMMENT_START);
1826 fputc ('\n', asm_out_file);
1828 for (cfi = cie_cfi_head; cfi != NULL; cfi = cfi->dw_cfi_next)
1829 output_cfi (cfi, NULL);
1831 /* Pad the CIE out to an address sized boundary. */
1832 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
1833 ASM_OUTPUT_LABEL (asm_out_file, l2);
1834 #ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
1835 ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL (asm_out_file, ld, l2, l1);
1837 fprintf (asm_out_file, "\t%s CIE Length Symbol", ASM_COMMENT_START);
1838 fputc ('\n', asm_out_file);
1841 /* Loop through all of the FDE's. */
1842 for (i = 0; i < fde_table_in_use; ++i)
1844 fde = &fde_table[i];
1846 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_AFTER_SIZE_LABEL, for_eh + i*2);
1847 ASM_GENERATE_INTERNAL_LABEL (l2, FDE_END_LABEL, for_eh + i*2);
1848 #ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
1849 ASM_GENERATE_INTERNAL_LABEL (ld, FDE_LENGTH_LABEL, for_eh + i*2);
1851 ASM_OUTPUT_DWARF_OFFSET4 (asm_out_file, ld);
1853 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, ld);
1856 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, l2, l1);
1858 ASM_OUTPUT_DWARF_DELTA (asm_out_file, l2, l1);
1861 fprintf (asm_out_file, "\t%s FDE Length", ASM_COMMENT_START);
1862 fputc ('\n', asm_out_file);
1863 ASM_OUTPUT_LABEL (asm_out_file, l1);
1865 /* ??? This always emits a 4 byte offset when for_eh is true, but it
1866 emits a target dependent sized offset when for_eh is not true.
1867 This inconsistency may confuse gdb. The only case where we need a
1868 non-4 byte offset is for the Irix6 N64 ABI, so we may lose SGI
1869 compatibility if we emit a 4 byte offset. We need a 4 byte offset
1870 though in order to be compatible with the dwarf_fde struct in frame.c.
1871 If the for_eh case is changed, then the struct in frame.c has
1872 to be adjusted appropriately. */
1874 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, l1, "__FRAME_BEGIN__");
1876 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, stripattributes (FRAME_SECTION));
1878 fprintf (asm_out_file, "\t%s FDE CIE offset", ASM_COMMENT_START);
1880 fputc ('\n', asm_out_file);
1881 ASM_OUTPUT_DWARF_ADDR (asm_out_file, fde->dw_fde_begin);
1883 fprintf (asm_out_file, "\t%s FDE initial location", ASM_COMMENT_START);
1885 fputc ('\n', asm_out_file);
1886 ASM_OUTPUT_DWARF_ADDR_DELTA (asm_out_file,
1887 fde->dw_fde_end, fde->dw_fde_begin);
1889 fprintf (asm_out_file, "\t%s FDE address range", ASM_COMMENT_START);
1891 fputc ('\n', asm_out_file);
1893 /* Loop through the Call Frame Instructions associated with
1895 fde->dw_fde_current_label = fde->dw_fde_begin;
1896 for (cfi = fde->dw_fde_cfi; cfi != NULL; cfi = cfi->dw_cfi_next)
1897 output_cfi (cfi, fde);
1899 /* Pad the FDE out to an address sized boundary. */
1900 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
1901 ASM_OUTPUT_LABEL (asm_out_file, l2);
1902 #ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
1903 ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL (asm_out_file, ld, l2, l1);
1905 fprintf (asm_out_file, "\t%s FDE Length Symbol", ASM_COMMENT_START);
1906 fputc ('\n', asm_out_file);
1909 #ifndef EH_FRAME_SECTION
1912 /* Emit terminating zero for table. */
1913 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0);
1914 fputc ('\n', asm_out_file);
1917 #ifdef MIPS_DEBUGGING_INFO
1918 /* Work around Irix 6 assembler bug whereby labels at the end of a section
1919 get a value of 0. Putting .align 0 after the label fixes it. */
1920 ASM_OUTPUT_ALIGN (asm_out_file, 0);
1923 /* Turn off app to make assembly quicker. */
1928 /* Output a marker (i.e. a label) for the beginning of a function, before
1932 dwarf2out_begin_prologue ()
1934 char label[MAX_ARTIFICIAL_LABEL_BYTES];
1935 register dw_fde_ref fde;
1937 ++current_funcdef_number;
1939 function_section (current_function_decl);
1940 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_BEGIN_LABEL,
1941 current_funcdef_number);
1942 ASM_OUTPUT_LABEL (asm_out_file, label);
1944 /* Expand the fde table if necessary. */
1945 if (fde_table_in_use == fde_table_allocated)
1947 fde_table_allocated += FDE_TABLE_INCREMENT;
1949 = (dw_fde_ref) xrealloc (fde_table,
1950 fde_table_allocated * sizeof (dw_fde_node));
1953 /* Record the FDE associated with this function. */
1954 current_funcdef_fde = fde_table_in_use;
1956 /* Add the new FDE at the end of the fde_table. */
1957 fde = &fde_table[fde_table_in_use++];
1958 fde->dw_fde_begin = xstrdup (label);
1959 fde->dw_fde_current_label = NULL;
1960 fde->dw_fde_end = NULL;
1961 fde->dw_fde_cfi = NULL;
1963 args_size = old_args_size = 0;
1966 /* Output a marker (i.e. a label) for the absolute end of the generated code
1967 for a function definition. This gets called *after* the epilogue code has
1971 dwarf2out_end_epilogue ()
1974 char label[MAX_ARTIFICIAL_LABEL_BYTES];
1976 /* Output a label to mark the endpoint of the code generated for this
1978 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL, current_funcdef_number);
1979 ASM_OUTPUT_LABEL (asm_out_file, label);
1980 fde = &fde_table[fde_table_in_use - 1];
1981 fde->dw_fde_end = xstrdup (label);
1985 dwarf2out_frame_init ()
1987 /* Allocate the initial hunk of the fde_table. */
1989 = (dw_fde_ref) xmalloc (FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
1990 bzero ((char *) fde_table, FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
1991 fde_table_allocated = FDE_TABLE_INCREMENT;
1992 fde_table_in_use = 0;
1994 /* Generate the CFA instructions common to all FDE's. Do it now for the
1995 sake of lookup_cfa. */
1997 #ifdef DWARF2_UNWIND_INFO
1998 /* On entry, the Canonical Frame Address is at SP. */
1999 dwarf2out_def_cfa (NULL, STACK_POINTER_REGNUM, INCOMING_FRAME_SP_OFFSET);
2000 initial_return_save (INCOMING_RETURN_ADDR_RTX);
2005 dwarf2out_frame_finish ()
2007 /* Output call frame information. */
2008 #ifdef MIPS_DEBUGGING_INFO
2009 if (write_symbols == DWARF2_DEBUG)
2010 output_call_frame_info (0);
2011 if (flag_exceptions && ! exceptions_via_longjmp)
2012 output_call_frame_info (1);
2014 if (write_symbols == DWARF2_DEBUG
2015 || (flag_exceptions && ! exceptions_via_longjmp))
2016 output_call_frame_info (1);
2020 #endif /* .debug_frame support */
2022 /* And now, the support for symbolic debugging information. */
2023 #ifdef DWARF2_DEBUGGING_INFO
2025 extern char *getpwd PROTO((void));
2027 /* NOTE: In the comments in this file, many references are made to
2028 "Debugging Information Entries". This term is abbreviated as `DIE'
2029 throughout the remainder of this file. */
2031 /* An internal representation of the DWARF output is built, and then
2032 walked to generate the DWARF debugging info. The walk of the internal
2033 representation is done after the entire program has been compiled.
2034 The types below are used to describe the internal representation. */
2036 /* Each DIE may have a series of attribute/value pairs. Values
2037 can take on several forms. The forms that are used in this
2038 implementation are listed below. */
2045 dw_val_class_unsigned_const,
2046 dw_val_class_long_long,
2049 dw_val_class_die_ref,
2050 dw_val_class_fde_ref,
2051 dw_val_class_lbl_id,
2052 dw_val_class_lbl_offset,
2057 /* Various DIE's use offsets relative to the beginning of the
2058 .debug_info section to refer to each other. */
2060 typedef long int dw_offset;
2062 /* Define typedefs here to avoid circular dependencies. */
2064 typedef struct die_struct *dw_die_ref;
2065 typedef struct dw_attr_struct *dw_attr_ref;
2066 typedef struct dw_val_struct *dw_val_ref;
2067 typedef struct dw_line_info_struct *dw_line_info_ref;
2068 typedef struct dw_separate_line_info_struct *dw_separate_line_info_ref;
2069 typedef struct dw_loc_descr_struct *dw_loc_descr_ref;
2070 typedef struct pubname_struct *pubname_ref;
2071 typedef dw_die_ref *arange_ref;
2073 /* Describe a double word constant value. */
2075 typedef struct dw_long_long_struct
2082 /* Describe a floating point constant value. */
2084 typedef struct dw_fp_struct
2091 /* Each entry in the line_info_table maintains the file and
2092 line number associated with the label generated for that
2093 entry. The label gives the PC value associated with
2094 the line number entry. */
2096 typedef struct dw_line_info_struct
2098 unsigned long dw_file_num;
2099 unsigned long dw_line_num;
2103 /* Line information for functions in separate sections; each one gets its
2105 typedef struct dw_separate_line_info_struct
2107 unsigned long dw_file_num;
2108 unsigned long dw_line_num;
2109 unsigned long function;
2111 dw_separate_line_info_entry;
2113 /* The dw_val_node describes an attribute's value, as it is
2114 represented internally. */
2116 typedef struct dw_val_struct
2118 dw_val_class val_class;
2122 dw_loc_descr_ref val_loc;
2124 long unsigned val_unsigned;
2125 dw_long_long_const val_long_long;
2126 dw_float_const val_float;
2127 dw_die_ref val_die_ref;
2128 unsigned val_fde_index;
2131 unsigned char val_flag;
2137 /* Locations in memory are described using a sequence of stack machine
2140 typedef struct dw_loc_descr_struct
2142 dw_loc_descr_ref dw_loc_next;
2143 enum dwarf_location_atom dw_loc_opc;
2144 dw_val_node dw_loc_oprnd1;
2145 dw_val_node dw_loc_oprnd2;
2149 /* Each DIE attribute has a field specifying the attribute kind,
2150 a link to the next attribute in the chain, and an attribute value.
2151 Attributes are typically linked below the DIE they modify. */
2153 typedef struct dw_attr_struct
2155 enum dwarf_attribute dw_attr;
2156 dw_attr_ref dw_attr_next;
2157 dw_val_node dw_attr_val;
2161 /* The Debugging Information Entry (DIE) structure */
2163 typedef struct die_struct
2165 enum dwarf_tag die_tag;
2166 dw_attr_ref die_attr;
2167 dw_attr_ref die_attr_last;
2168 dw_die_ref die_parent;
2169 dw_die_ref die_child;
2170 dw_die_ref die_child_last;
2172 dw_offset die_offset;
2173 unsigned long die_abbrev;
2177 /* The pubname structure */
2179 typedef struct pubname_struct
2186 /* The limbo die list structure. */
2187 typedef struct limbo_die_struct
2190 struct limbo_die_struct *next;
2194 /* How to start an assembler comment. */
2195 #ifndef ASM_COMMENT_START
2196 #define ASM_COMMENT_START ";#"
2199 /* Define a macro which returns non-zero for a TYPE_DECL which was
2200 implicitly generated for a tagged type.
2202 Note that unlike the gcc front end (which generates a NULL named
2203 TYPE_DECL node for each complete tagged type, each array type, and
2204 each function type node created) the g++ front end generates a
2205 _named_ TYPE_DECL node for each tagged type node created.
2206 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
2207 generate a DW_TAG_typedef DIE for them. */
2209 #define TYPE_DECL_IS_STUB(decl) \
2210 (DECL_NAME (decl) == NULL_TREE \
2211 || (DECL_ARTIFICIAL (decl) \
2212 && is_tagged_type (TREE_TYPE (decl)) \
2213 && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \
2214 /* This is necessary for stub decls that \
2215 appear in nested inline functions. */ \
2216 || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
2217 && (decl_ultimate_origin (decl) \
2218 == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
2220 /* Information concerning the compilation unit's programming
2221 language, and compiler version. */
2223 extern int flag_traditional;
2224 extern char *version_string;
2225 extern char *language_string;
2227 /* Fixed size portion of the DWARF compilation unit header. */
2228 #define DWARF_COMPILE_UNIT_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 3)
2230 /* Fixed size portion of debugging line information prolog. */
2231 #define DWARF_LINE_PROLOG_HEADER_SIZE 5
2233 /* Fixed size portion of public names info. */
2234 #define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
2236 /* Fixed size portion of the address range info. */
2237 #define DWARF_ARANGES_HEADER_SIZE \
2238 (DWARF_ROUND (2 * DWARF_OFFSET_SIZE + 4, PTR_SIZE * 2) - DWARF_OFFSET_SIZE)
2240 /* The default is to have gcc emit the line number tables. */
2241 #ifndef DWARF2_ASM_LINE_DEBUG_INFO
2242 #define DWARF2_ASM_LINE_DEBUG_INFO 0
2245 /* Define the architecture-dependent minimum instruction length (in bytes).
2246 In this implementation of DWARF, this field is used for information
2247 purposes only. Since GCC generates assembly language, we have
2248 no a priori knowledge of how many instruction bytes are generated
2249 for each source line, and therefore can use only the DW_LNE_set_address
2250 and DW_LNS_fixed_advance_pc line information commands. */
2252 #ifndef DWARF_LINE_MIN_INSTR_LENGTH
2253 #define DWARF_LINE_MIN_INSTR_LENGTH 4
2256 /* Minimum line offset in a special line info. opcode.
2257 This value was chosen to give a reasonable range of values. */
2258 #define DWARF_LINE_BASE -10
2260 /* First special line opcde - leave room for the standard opcodes. */
2261 #define DWARF_LINE_OPCODE_BASE 10
2263 /* Range of line offsets in a special line info. opcode. */
2264 #define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1)
2266 /* Flag that indicates the initial value of the is_stmt_start flag.
2267 In the present implementation, we do not mark any lines as
2268 the beginning of a source statement, because that information
2269 is not made available by the GCC front-end. */
2270 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
2272 /* This location is used by calc_die_sizes() to keep track
2273 the offset of each DIE within the .debug_info section. */
2274 static unsigned long next_die_offset;
2276 /* Record the root of the DIE's built for the current compilation unit. */
2277 static dw_die_ref comp_unit_die;
2279 /* A list of DIEs with a NULL parent waiting to be relocated. */
2280 static limbo_die_node *limbo_die_list = 0;
2282 /* Pointer to an array of filenames referenced by this compilation unit. */
2283 static char **file_table;
2285 /* Total number of entries in the table (i.e. array) pointed to by
2286 `file_table'. This is the *total* and includes both used and unused
2288 static unsigned file_table_allocated;
2290 /* Number of entries in the file_table which are actually in use. */
2291 static unsigned file_table_in_use;
2293 /* Size (in elements) of increments by which we may expand the filename
2295 #define FILE_TABLE_INCREMENT 64
2297 /* Local pointer to the name of the main input file. Initialized in
2299 static char *primary_filename;
2301 /* For Dwarf output, we must assign lexical-blocks id numbers in the order in
2302 which their beginnings are encountered. We output Dwarf debugging info
2303 that refers to the beginnings and ends of the ranges of code for each
2304 lexical block. The labels themselves are generated in final.c, which
2305 assigns numbers to the blocks in the same way. */
2306 static unsigned next_block_number = 2;
2308 /* A pointer to the base of a table of references to DIE's that describe
2309 declarations. The table is indexed by DECL_UID() which is a unique
2310 number identifying each decl. */
2311 static dw_die_ref *decl_die_table;
2313 /* Number of elements currently allocated for the decl_die_table. */
2314 static unsigned decl_die_table_allocated;
2316 /* Number of elements in decl_die_table currently in use. */
2317 static unsigned decl_die_table_in_use;
2319 /* Size (in elements) of increments by which we may expand the
2321 #define DECL_DIE_TABLE_INCREMENT 256
2323 /* Structure used for the decl_scope table. scope is the current declaration
2324 scope, and previous is the entry that is the parent of this scope. This
2325 is usually but not always the immediately preceeding entry. */
2327 typedef struct decl_scope_struct
2334 /* A pointer to the base of a table of references to declaration
2335 scopes. This table is a display which tracks the nesting
2336 of declaration scopes at the current scope and containing
2337 scopes. This table is used to find the proper place to
2338 define type declaration DIE's. */
2339 static decl_scope_node *decl_scope_table;
2341 /* Number of elements currently allocated for the decl_scope_table. */
2342 static int decl_scope_table_allocated;
2344 /* Current level of nesting of declaration scopes. */
2345 static int decl_scope_depth;
2347 /* Size (in elements) of increments by which we may expand the
2348 decl_scope_table. */
2349 #define DECL_SCOPE_TABLE_INCREMENT 64
2351 /* A pointer to the base of a list of references to DIE's that
2352 are uniquely identified by their tag, presence/absence of
2353 children DIE's, and list of attribute/value pairs. */
2354 static dw_die_ref *abbrev_die_table;
2356 /* Number of elements currently allocated for abbrev_die_table. */
2357 static unsigned abbrev_die_table_allocated;
2359 /* Number of elements in type_die_table currently in use. */
2360 static unsigned abbrev_die_table_in_use;
2362 /* Size (in elements) of increments by which we may expand the
2363 abbrev_die_table. */
2364 #define ABBREV_DIE_TABLE_INCREMENT 256
2366 /* A pointer to the base of a table that contains line information
2367 for each source code line in .text in the compilation unit. */
2368 static dw_line_info_ref line_info_table;
2370 /* Number of elements currently allocated for line_info_table. */
2371 static unsigned line_info_table_allocated;
2373 /* Number of elements in separate_line_info_table currently in use. */
2374 static unsigned separate_line_info_table_in_use;
2376 /* A pointer to the base of a table that contains line information
2377 for each source code line outside of .text in the compilation unit. */
2378 static dw_separate_line_info_ref separate_line_info_table;
2380 /* Number of elements currently allocated for separate_line_info_table. */
2381 static unsigned separate_line_info_table_allocated;
2383 /* Number of elements in line_info_table currently in use. */
2384 static unsigned line_info_table_in_use;
2386 /* Size (in elements) of increments by which we may expand the
2388 #define LINE_INFO_TABLE_INCREMENT 1024
2390 /* A pointer to the base of a table that contains a list of publicly
2391 accessible names. */
2392 static pubname_ref pubname_table;
2394 /* Number of elements currently allocated for pubname_table. */
2395 static unsigned pubname_table_allocated;
2397 /* Number of elements in pubname_table currently in use. */
2398 static unsigned pubname_table_in_use;
2400 /* Size (in elements) of increments by which we may expand the
2402 #define PUBNAME_TABLE_INCREMENT 64
2404 /* A pointer to the base of a table that contains a list of publicly
2405 accessible names. */
2406 static arange_ref arange_table;
2408 /* Number of elements currently allocated for arange_table. */
2409 static unsigned arange_table_allocated;
2411 /* Number of elements in arange_table currently in use. */
2412 static unsigned arange_table_in_use;
2414 /* Size (in elements) of increments by which we may expand the
2416 #define ARANGE_TABLE_INCREMENT 64
2418 /* A pointer to the base of a list of pending types which we haven't
2419 generated DIEs for yet, but which we will have to come back to
2422 static tree *pending_types_list;
2424 /* Number of elements currently allocated for the pending_types_list. */
2425 static unsigned pending_types_allocated;
2427 /* Number of elements of pending_types_list currently in use. */
2428 static unsigned pending_types;
2430 /* Size (in elements) of increments by which we may expand the pending
2431 types list. Actually, a single hunk of space of this size should
2432 be enough for most typical programs. */
2433 #define PENDING_TYPES_INCREMENT 64
2435 /* A pointer to the base of a list of incomplete types which might be
2436 completed at some later time. */
2438 static tree *incomplete_types_list;
2440 /* Number of elements currently allocated for the incomplete_types_list. */
2441 static unsigned incomplete_types_allocated;
2443 /* Number of elements of incomplete_types_list currently in use. */
2444 static unsigned incomplete_types;
2446 /* Size (in elements) of increments by which we may expand the incomplete
2447 types list. Actually, a single hunk of space of this size should
2448 be enough for most typical programs. */
2449 #define INCOMPLETE_TYPES_INCREMENT 64
2451 /* Record whether the function being analyzed contains inlined functions. */
2452 static int current_function_has_inlines;
2453 #if 0 && defined (MIPS_DEBUGGING_INFO)
2454 static int comp_unit_has_inlines;
2457 /* A pointer to the ..._DECL node which we have most recently been working
2458 on. We keep this around just in case something about it looks screwy and
2459 we want to tell the user what the source coordinates for the actual
2461 static tree dwarf_last_decl;
2463 /* Forward declarations for functions defined in this file. */
2465 static void addr_const_to_string PROTO((dyn_string_t, rtx));
2466 static char *addr_to_string PROTO((rtx));
2467 static int is_pseudo_reg PROTO((rtx));
2468 static tree type_main_variant PROTO((tree));
2469 static int is_tagged_type PROTO((tree));
2470 static const char *dwarf_tag_name PROTO((unsigned));
2471 static const char *dwarf_attr_name PROTO((unsigned));
2472 static const char *dwarf_form_name PROTO((unsigned));
2473 static const char *dwarf_stack_op_name PROTO((unsigned));
2475 static const char *dwarf_type_encoding_name PROTO((unsigned));
2477 static tree decl_ultimate_origin PROTO((tree));
2478 static tree block_ultimate_origin PROTO((tree));
2479 static tree decl_class_context PROTO((tree));
2480 static void add_dwarf_attr PROTO((dw_die_ref, dw_attr_ref));
2481 static void add_AT_flag PROTO((dw_die_ref,
2482 enum dwarf_attribute,
2484 static void add_AT_int PROTO((dw_die_ref,
2485 enum dwarf_attribute, long));
2486 static void add_AT_unsigned PROTO((dw_die_ref,
2487 enum dwarf_attribute,
2489 static void add_AT_long_long PROTO((dw_die_ref,
2490 enum dwarf_attribute,
2491 unsigned long, unsigned long));
2492 static void add_AT_float PROTO((dw_die_ref,
2493 enum dwarf_attribute,
2495 static void add_AT_string PROTO((dw_die_ref,
2496 enum dwarf_attribute,
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 const 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, enum machine_mode mode));
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, const 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((const char *));
2646 static void add_incomplete_type PROTO((tree));
2647 static void retry_incomplete_types PROTO((void));
2649 /* Section names used to hold DWARF debugging information. */
2650 #ifndef DEBUG_INFO_SECTION
2651 #define DEBUG_INFO_SECTION ".debug_info"
2653 #ifndef ABBREV_SECTION
2654 #define ABBREV_SECTION ".debug_abbrev"
2656 #ifndef ARANGES_SECTION
2657 #define ARANGES_SECTION ".debug_aranges"
2659 #ifndef DW_MACINFO_SECTION
2660 #define DW_MACINFO_SECTION ".debug_macinfo"
2662 #ifndef DEBUG_LINE_SECTION
2663 #define DEBUG_LINE_SECTION ".debug_line"
2666 #define LOC_SECTION ".debug_loc"
2668 #ifndef PUBNAMES_SECTION
2669 #define PUBNAMES_SECTION ".debug_pubnames"
2672 #define STR_SECTION ".debug_str"
2675 /* Standard ELF section names for compiled code and data. */
2676 #ifndef TEXT_SECTION
2677 #define TEXT_SECTION ".text"
2679 #ifndef DATA_SECTION
2680 #define DATA_SECTION ".data"
2683 #define BSS_SECTION ".bss"
2686 /* Labels we insert at beginning sections we can reference instead of
2687 the section names themselves. */
2689 #ifndef TEXT_SECTION_LABEL
2690 #define TEXT_SECTION_LABEL "Ltext"
2692 #ifndef DEBUG_LINE_SECTION_LABEL
2693 #define DEBUG_LINE_SECTION_LABEL "Ldebug_line"
2695 #ifndef DEBUG_INFO_SECTION_LABEL
2696 #define DEBUG_INFO_SECTION_LABEL "Ldebug_info"
2698 #ifndef ABBREV_SECTION_LABEL
2699 #define ABBREV_SECTION_LABEL "Ldebug_abbrev"
2703 /* Definitions of defaults for formats and names of various special
2704 (artificial) labels which may be generated within this file (when the -g
2705 options is used and DWARF_DEBUGGING_INFO is in effect.
2706 If necessary, these may be overridden from within the tm.h file, but
2707 typically, overriding these defaults is unnecessary. */
2709 static char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
2710 static char text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
2711 static char abbrev_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
2712 static char debug_info_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
2713 static char debug_line_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
2715 #ifndef TEXT_END_LABEL
2716 #define TEXT_END_LABEL "Letext"
2718 #ifndef DATA_END_LABEL
2719 #define DATA_END_LABEL "Ledata"
2721 #ifndef BSS_END_LABEL
2722 #define BSS_END_LABEL "Lebss"
2724 #ifndef INSN_LABEL_FMT
2725 #define INSN_LABEL_FMT "LI%u_"
2727 #ifndef BLOCK_BEGIN_LABEL
2728 #define BLOCK_BEGIN_LABEL "LBB"
2730 #ifndef BLOCK_END_LABEL
2731 #define BLOCK_END_LABEL "LBE"
2733 #ifndef BODY_BEGIN_LABEL
2734 #define BODY_BEGIN_LABEL "Lbb"
2736 #ifndef BODY_END_LABEL
2737 #define BODY_END_LABEL "Lbe"
2739 #ifndef LINE_CODE_LABEL
2740 #define LINE_CODE_LABEL "LM"
2742 #ifndef SEPARATE_LINE_CODE_LABEL
2743 #define SEPARATE_LINE_CODE_LABEL "LSM"
2746 /* Convert a reference to the assembler name of a C-level name. This
2747 macro has the same effect as ASM_OUTPUT_LABELREF, but copies to
2748 a string rather than writing to a file. */
2749 #ifndef ASM_NAME_TO_STRING
2750 #define ASM_NAME_TO_STRING(STR, NAME) \
2752 if ((NAME)[0] == '*') \
2753 dyn_string_append (STR, NAME + 1); \
2756 const char *newstr; \
2757 STRIP_NAME_ENCODING (newstr, NAME); \
2758 dyn_string_append (STR, user_label_prefix); \
2759 dyn_string_append (STR, newstr); \
2765 /* Convert an integer constant expression into assembler syntax. Addition
2766 and subtraction are the only arithmetic that may appear in these
2767 expressions. This is an adaptation of output_addr_const in final.c.
2768 Here, the target of the conversion is a string buffer. We can't use
2769 output_addr_const directly, because it writes to a file. */
2772 addr_const_to_string (str, x)
2779 switch (GET_CODE (x))
2783 dyn_string_append (str, ",");
2789 ASM_NAME_TO_STRING (str, XSTR (x, 0));
2793 ASM_GENERATE_INTERNAL_LABEL (buf1, "L", CODE_LABEL_NUMBER (XEXP (x, 0)));
2794 ASM_NAME_TO_STRING (str, buf1);
2798 ASM_GENERATE_INTERNAL_LABEL (buf1, "L", CODE_LABEL_NUMBER (x));
2799 ASM_NAME_TO_STRING (str, buf1);
2803 sprintf (buf1, HOST_WIDE_INT_PRINT_DEC, INTVAL (x));
2804 dyn_string_append (str, buf1);
2808 /* This used to output parentheses around the expression, but that does
2809 not work on the 386 (either ATT or BSD assembler). */
2810 addr_const_to_string (str, XEXP (x, 0));
2814 if (GET_MODE (x) == VOIDmode)
2816 /* We can use %d if the number is one word and positive. */
2817 if (CONST_DOUBLE_HIGH (x))
2818 sprintf (buf1, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
2819 CONST_DOUBLE_HIGH (x), CONST_DOUBLE_LOW (x));
2820 else if (CONST_DOUBLE_LOW (x) < 0)
2821 sprintf (buf1, HOST_WIDE_INT_PRINT_HEX, CONST_DOUBLE_LOW (x));
2823 sprintf (buf1, HOST_WIDE_INT_PRINT_DEC,
2824 CONST_DOUBLE_LOW (x));
2825 dyn_string_append (str, buf1);
2828 /* We can't handle floating point constants; PRINT_OPERAND must
2830 output_operand_lossage ("floating constant misused");
2834 /* Some assemblers need integer constants to appear last (eg masm). */
2835 if (GET_CODE (XEXP (x, 0)) == CONST_INT)
2837 addr_const_to_string (str, XEXP (x, 1));
2838 if (INTVAL (XEXP (x, 0)) >= 0)
2839 dyn_string_append (str, "+");
2841 addr_const_to_string (str, XEXP (x, 0));
2845 addr_const_to_string (str, XEXP (x, 0));
2846 if (INTVAL (XEXP (x, 1)) >= 0)
2847 dyn_string_append (str, "+");
2849 addr_const_to_string (str, XEXP (x, 1));
2854 /* Avoid outputting things like x-x or x+5-x, since some assemblers
2855 can't handle that. */
2856 x = simplify_subtraction (x);
2857 if (GET_CODE (x) != MINUS)
2860 addr_const_to_string (str, XEXP (x, 0));
2861 dyn_string_append (str, "-");
2862 if (GET_CODE (XEXP (x, 1)) == CONST_INT
2863 && INTVAL (XEXP (x, 1)) < 0)
2865 dyn_string_append (str, ASM_OPEN_PAREN);
2866 addr_const_to_string (str, XEXP (x, 1));
2867 dyn_string_append (str, ASM_CLOSE_PAREN);
2870 addr_const_to_string (str, XEXP (x, 1));
2875 addr_const_to_string (str, XEXP (x, 0));
2879 output_operand_lossage ("invalid expression as operand");
2883 /* Convert an address constant to a string, and return a pointer to
2884 a copy of the result, located on the heap. */
2890 dyn_string_t ds = dyn_string_new (256);
2893 addr_const_to_string (ds, x);
2895 /* Return the dynamically allocated string, but free the
2896 dyn_string_t itself. */
2902 /* Test if rtl node points to a pseudo register. */
2908 return (((GET_CODE (rtl) == REG) && (REGNO (rtl) >= FIRST_PSEUDO_REGISTER))
2909 || ((GET_CODE (rtl) == SUBREG)
2910 && (REGNO (XEXP (rtl, 0)) >= FIRST_PSEUDO_REGISTER)));
2913 /* Return a reference to a type, with its const and volatile qualifiers
2917 type_main_variant (type)
2920 type = TYPE_MAIN_VARIANT (type);
2922 /* There really should be only one main variant among any group of variants
2923 of a given type (and all of the MAIN_VARIANT values for all members of
2924 the group should point to that one type) but sometimes the C front-end
2925 messes this up for array types, so we work around that bug here. */
2927 if (TREE_CODE (type) == ARRAY_TYPE)
2928 while (type != TYPE_MAIN_VARIANT (type))
2929 type = TYPE_MAIN_VARIANT (type);
2934 /* Return non-zero if the given type node represents a tagged type. */
2937 is_tagged_type (type)
2940 register enum tree_code code = TREE_CODE (type);
2942 return (code == RECORD_TYPE || code == UNION_TYPE
2943 || code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE);
2946 /* Convert a DIE tag into its string name. */
2949 dwarf_tag_name (tag)
2950 register unsigned tag;
2954 case DW_TAG_padding:
2955 return "DW_TAG_padding";
2956 case DW_TAG_array_type:
2957 return "DW_TAG_array_type";
2958 case DW_TAG_class_type:
2959 return "DW_TAG_class_type";
2960 case DW_TAG_entry_point:
2961 return "DW_TAG_entry_point";
2962 case DW_TAG_enumeration_type:
2963 return "DW_TAG_enumeration_type";
2964 case DW_TAG_formal_parameter:
2965 return "DW_TAG_formal_parameter";
2966 case DW_TAG_imported_declaration:
2967 return "DW_TAG_imported_declaration";
2969 return "DW_TAG_label";
2970 case DW_TAG_lexical_block:
2971 return "DW_TAG_lexical_block";
2973 return "DW_TAG_member";
2974 case DW_TAG_pointer_type:
2975 return "DW_TAG_pointer_type";
2976 case DW_TAG_reference_type:
2977 return "DW_TAG_reference_type";
2978 case DW_TAG_compile_unit:
2979 return "DW_TAG_compile_unit";
2980 case DW_TAG_string_type:
2981 return "DW_TAG_string_type";
2982 case DW_TAG_structure_type:
2983 return "DW_TAG_structure_type";
2984 case DW_TAG_subroutine_type:
2985 return "DW_TAG_subroutine_type";
2986 case DW_TAG_typedef:
2987 return "DW_TAG_typedef";
2988 case DW_TAG_union_type:
2989 return "DW_TAG_union_type";
2990 case DW_TAG_unspecified_parameters:
2991 return "DW_TAG_unspecified_parameters";
2992 case DW_TAG_variant:
2993 return "DW_TAG_variant";
2994 case DW_TAG_common_block:
2995 return "DW_TAG_common_block";
2996 case DW_TAG_common_inclusion:
2997 return "DW_TAG_common_inclusion";
2998 case DW_TAG_inheritance:
2999 return "DW_TAG_inheritance";
3000 case DW_TAG_inlined_subroutine:
3001 return "DW_TAG_inlined_subroutine";
3003 return "DW_TAG_module";
3004 case DW_TAG_ptr_to_member_type:
3005 return "DW_TAG_ptr_to_member_type";
3006 case DW_TAG_set_type:
3007 return "DW_TAG_set_type";
3008 case DW_TAG_subrange_type:
3009 return "DW_TAG_subrange_type";
3010 case DW_TAG_with_stmt:
3011 return "DW_TAG_with_stmt";
3012 case DW_TAG_access_declaration:
3013 return "DW_TAG_access_declaration";
3014 case DW_TAG_base_type:
3015 return "DW_TAG_base_type";
3016 case DW_TAG_catch_block:
3017 return "DW_TAG_catch_block";
3018 case DW_TAG_const_type:
3019 return "DW_TAG_const_type";
3020 case DW_TAG_constant:
3021 return "DW_TAG_constant";
3022 case DW_TAG_enumerator:
3023 return "DW_TAG_enumerator";
3024 case DW_TAG_file_type:
3025 return "DW_TAG_file_type";
3027 return "DW_TAG_friend";
3028 case DW_TAG_namelist:
3029 return "DW_TAG_namelist";
3030 case DW_TAG_namelist_item:
3031 return "DW_TAG_namelist_item";
3032 case DW_TAG_packed_type:
3033 return "DW_TAG_packed_type";
3034 case DW_TAG_subprogram:
3035 return "DW_TAG_subprogram";
3036 case DW_TAG_template_type_param:
3037 return "DW_TAG_template_type_param";
3038 case DW_TAG_template_value_param:
3039 return "DW_TAG_template_value_param";
3040 case DW_TAG_thrown_type:
3041 return "DW_TAG_thrown_type";
3042 case DW_TAG_try_block:
3043 return "DW_TAG_try_block";
3044 case DW_TAG_variant_part:
3045 return "DW_TAG_variant_part";
3046 case DW_TAG_variable:
3047 return "DW_TAG_variable";
3048 case DW_TAG_volatile_type:
3049 return "DW_TAG_volatile_type";
3050 case DW_TAG_MIPS_loop:
3051 return "DW_TAG_MIPS_loop";
3052 case DW_TAG_format_label:
3053 return "DW_TAG_format_label";
3054 case DW_TAG_function_template:
3055 return "DW_TAG_function_template";
3056 case DW_TAG_class_template:
3057 return "DW_TAG_class_template";
3059 return "DW_TAG_<unknown>";
3063 /* Convert a DWARF attribute code into its string name. */
3066 dwarf_attr_name (attr)
3067 register unsigned attr;
3072 return "DW_AT_sibling";
3073 case DW_AT_location:
3074 return "DW_AT_location";
3076 return "DW_AT_name";
3077 case DW_AT_ordering:
3078 return "DW_AT_ordering";
3079 case DW_AT_subscr_data:
3080 return "DW_AT_subscr_data";
3081 case DW_AT_byte_size:
3082 return "DW_AT_byte_size";
3083 case DW_AT_bit_offset:
3084 return "DW_AT_bit_offset";
3085 case DW_AT_bit_size:
3086 return "DW_AT_bit_size";
3087 case DW_AT_element_list:
3088 return "DW_AT_element_list";
3089 case DW_AT_stmt_list:
3090 return "DW_AT_stmt_list";
3092 return "DW_AT_low_pc";
3094 return "DW_AT_high_pc";
3095 case DW_AT_language:
3096 return "DW_AT_language";
3098 return "DW_AT_member";
3100 return "DW_AT_discr";
3101 case DW_AT_discr_value:
3102 return "DW_AT_discr_value";
3103 case DW_AT_visibility:
3104 return "DW_AT_visibility";
3106 return "DW_AT_import";
3107 case DW_AT_string_length:
3108 return "DW_AT_string_length";
3109 case DW_AT_common_reference:
3110 return "DW_AT_common_reference";
3111 case DW_AT_comp_dir:
3112 return "DW_AT_comp_dir";
3113 case DW_AT_const_value:
3114 return "DW_AT_const_value";
3115 case DW_AT_containing_type:
3116 return "DW_AT_containing_type";
3117 case DW_AT_default_value:
3118 return "DW_AT_default_value";
3120 return "DW_AT_inline";
3121 case DW_AT_is_optional:
3122 return "DW_AT_is_optional";
3123 case DW_AT_lower_bound:
3124 return "DW_AT_lower_bound";
3125 case DW_AT_producer:
3126 return "DW_AT_producer";
3127 case DW_AT_prototyped:
3128 return "DW_AT_prototyped";
3129 case DW_AT_return_addr:
3130 return "DW_AT_return_addr";
3131 case DW_AT_start_scope:
3132 return "DW_AT_start_scope";
3133 case DW_AT_stride_size:
3134 return "DW_AT_stride_size";
3135 case DW_AT_upper_bound:
3136 return "DW_AT_upper_bound";
3137 case DW_AT_abstract_origin:
3138 return "DW_AT_abstract_origin";
3139 case DW_AT_accessibility:
3140 return "DW_AT_accessibility";
3141 case DW_AT_address_class:
3142 return "DW_AT_address_class";
3143 case DW_AT_artificial:
3144 return "DW_AT_artificial";
3145 case DW_AT_base_types:
3146 return "DW_AT_base_types";
3147 case DW_AT_calling_convention:
3148 return "DW_AT_calling_convention";
3150 return "DW_AT_count";
3151 case DW_AT_data_member_location:
3152 return "DW_AT_data_member_location";
3153 case DW_AT_decl_column:
3154 return "DW_AT_decl_column";
3155 case DW_AT_decl_file:
3156 return "DW_AT_decl_file";
3157 case DW_AT_decl_line:
3158 return "DW_AT_decl_line";
3159 case DW_AT_declaration:
3160 return "DW_AT_declaration";
3161 case DW_AT_discr_list:
3162 return "DW_AT_discr_list";
3163 case DW_AT_encoding:
3164 return "DW_AT_encoding";
3165 case DW_AT_external:
3166 return "DW_AT_external";
3167 case DW_AT_frame_base:
3168 return "DW_AT_frame_base";
3170 return "DW_AT_friend";
3171 case DW_AT_identifier_case:
3172 return "DW_AT_identifier_case";
3173 case DW_AT_macro_info:
3174 return "DW_AT_macro_info";
3175 case DW_AT_namelist_items:
3176 return "DW_AT_namelist_items";
3177 case DW_AT_priority:
3178 return "DW_AT_priority";
3180 return "DW_AT_segment";
3181 case DW_AT_specification:
3182 return "DW_AT_specification";
3183 case DW_AT_static_link:
3184 return "DW_AT_static_link";
3186 return "DW_AT_type";
3187 case DW_AT_use_location:
3188 return "DW_AT_use_location";
3189 case DW_AT_variable_parameter:
3190 return "DW_AT_variable_parameter";
3191 case DW_AT_virtuality:
3192 return "DW_AT_virtuality";
3193 case DW_AT_vtable_elem_location:
3194 return "DW_AT_vtable_elem_location";
3196 case DW_AT_MIPS_fde:
3197 return "DW_AT_MIPS_fde";
3198 case DW_AT_MIPS_loop_begin:
3199 return "DW_AT_MIPS_loop_begin";
3200 case DW_AT_MIPS_tail_loop_begin:
3201 return "DW_AT_MIPS_tail_loop_begin";
3202 case DW_AT_MIPS_epilog_begin:
3203 return "DW_AT_MIPS_epilog_begin";
3204 case DW_AT_MIPS_loop_unroll_factor:
3205 return "DW_AT_MIPS_loop_unroll_factor";
3206 case DW_AT_MIPS_software_pipeline_depth:
3207 return "DW_AT_MIPS_software_pipeline_depth";
3208 case DW_AT_MIPS_linkage_name:
3209 return "DW_AT_MIPS_linkage_name";
3210 case DW_AT_MIPS_stride:
3211 return "DW_AT_MIPS_stride";
3212 case DW_AT_MIPS_abstract_name:
3213 return "DW_AT_MIPS_abstract_name";
3214 case DW_AT_MIPS_clone_origin:
3215 return "DW_AT_MIPS_clone_origin";
3216 case DW_AT_MIPS_has_inlines:
3217 return "DW_AT_MIPS_has_inlines";
3219 case DW_AT_sf_names:
3220 return "DW_AT_sf_names";
3221 case DW_AT_src_info:
3222 return "DW_AT_src_info";
3223 case DW_AT_mac_info:
3224 return "DW_AT_mac_info";
3225 case DW_AT_src_coords:
3226 return "DW_AT_src_coords";
3227 case DW_AT_body_begin:
3228 return "DW_AT_body_begin";
3229 case DW_AT_body_end:
3230 return "DW_AT_body_end";
3232 return "DW_AT_<unknown>";
3236 /* Convert a DWARF value form code into its string name. */
3239 dwarf_form_name (form)
3240 register unsigned form;
3245 return "DW_FORM_addr";
3246 case DW_FORM_block2:
3247 return "DW_FORM_block2";
3248 case DW_FORM_block4:
3249 return "DW_FORM_block4";
3251 return "DW_FORM_data2";
3253 return "DW_FORM_data4";
3255 return "DW_FORM_data8";
3256 case DW_FORM_string:
3257 return "DW_FORM_string";
3259 return "DW_FORM_block";
3260 case DW_FORM_block1:
3261 return "DW_FORM_block1";
3263 return "DW_FORM_data1";
3265 return "DW_FORM_flag";
3267 return "DW_FORM_sdata";
3269 return "DW_FORM_strp";
3271 return "DW_FORM_udata";
3272 case DW_FORM_ref_addr:
3273 return "DW_FORM_ref_addr";
3275 return "DW_FORM_ref1";
3277 return "DW_FORM_ref2";
3279 return "DW_FORM_ref4";
3281 return "DW_FORM_ref8";
3282 case DW_FORM_ref_udata:
3283 return "DW_FORM_ref_udata";
3284 case DW_FORM_indirect:
3285 return "DW_FORM_indirect";
3287 return "DW_FORM_<unknown>";
3291 /* Convert a DWARF stack opcode into its string name. */
3294 dwarf_stack_op_name (op)
3295 register unsigned op;
3300 return "DW_OP_addr";
3302 return "DW_OP_deref";
3304 return "DW_OP_const1u";
3306 return "DW_OP_const1s";
3308 return "DW_OP_const2u";
3310 return "DW_OP_const2s";
3312 return "DW_OP_const4u";
3314 return "DW_OP_const4s";
3316 return "DW_OP_const8u";
3318 return "DW_OP_const8s";
3320 return "DW_OP_constu";
3322 return "DW_OP_consts";
3326 return "DW_OP_drop";
3328 return "DW_OP_over";
3330 return "DW_OP_pick";
3332 return "DW_OP_swap";
3336 return "DW_OP_xderef";
3344 return "DW_OP_minus";
3356 return "DW_OP_plus";
3357 case DW_OP_plus_uconst:
3358 return "DW_OP_plus_uconst";
3364 return "DW_OP_shra";
3382 return "DW_OP_skip";
3384 return "DW_OP_lit0";
3386 return "DW_OP_lit1";
3388 return "DW_OP_lit2";
3390 return "DW_OP_lit3";
3392 return "DW_OP_lit4";
3394 return "DW_OP_lit5";
3396 return "DW_OP_lit6";
3398 return "DW_OP_lit7";
3400 return "DW_OP_lit8";
3402 return "DW_OP_lit9";
3404 return "DW_OP_lit10";
3406 return "DW_OP_lit11";
3408 return "DW_OP_lit12";
3410 return "DW_OP_lit13";
3412 return "DW_OP_lit14";
3414 return "DW_OP_lit15";
3416 return "DW_OP_lit16";
3418 return "DW_OP_lit17";
3420 return "DW_OP_lit18";
3422 return "DW_OP_lit19";
3424 return "DW_OP_lit20";
3426 return "DW_OP_lit21";
3428 return "DW_OP_lit22";
3430 return "DW_OP_lit23";
3432 return "DW_OP_lit24";
3434 return "DW_OP_lit25";
3436 return "DW_OP_lit26";
3438 return "DW_OP_lit27";
3440 return "DW_OP_lit28";
3442 return "DW_OP_lit29";
3444 return "DW_OP_lit30";
3446 return "DW_OP_lit31";
3448 return "DW_OP_reg0";
3450 return "DW_OP_reg1";
3452 return "DW_OP_reg2";
3454 return "DW_OP_reg3";
3456 return "DW_OP_reg4";
3458 return "DW_OP_reg5";
3460 return "DW_OP_reg6";
3462 return "DW_OP_reg7";
3464 return "DW_OP_reg8";
3466 return "DW_OP_reg9";
3468 return "DW_OP_reg10";
3470 return "DW_OP_reg11";
3472 return "DW_OP_reg12";
3474 return "DW_OP_reg13";
3476 return "DW_OP_reg14";
3478 return "DW_OP_reg15";
3480 return "DW_OP_reg16";
3482 return "DW_OP_reg17";
3484 return "DW_OP_reg18";
3486 return "DW_OP_reg19";
3488 return "DW_OP_reg20";
3490 return "DW_OP_reg21";
3492 return "DW_OP_reg22";
3494 return "DW_OP_reg23";
3496 return "DW_OP_reg24";
3498 return "DW_OP_reg25";
3500 return "DW_OP_reg26";
3502 return "DW_OP_reg27";
3504 return "DW_OP_reg28";
3506 return "DW_OP_reg29";
3508 return "DW_OP_reg30";
3510 return "DW_OP_reg31";
3512 return "DW_OP_breg0";
3514 return "DW_OP_breg1";
3516 return "DW_OP_breg2";
3518 return "DW_OP_breg3";
3520 return "DW_OP_breg4";
3522 return "DW_OP_breg5";
3524 return "DW_OP_breg6";
3526 return "DW_OP_breg7";
3528 return "DW_OP_breg8";
3530 return "DW_OP_breg9";
3532 return "DW_OP_breg10";
3534 return "DW_OP_breg11";
3536 return "DW_OP_breg12";
3538 return "DW_OP_breg13";
3540 return "DW_OP_breg14";
3542 return "DW_OP_breg15";
3544 return "DW_OP_breg16";
3546 return "DW_OP_breg17";
3548 return "DW_OP_breg18";
3550 return "DW_OP_breg19";
3552 return "DW_OP_breg20";
3554 return "DW_OP_breg21";
3556 return "DW_OP_breg22";
3558 return "DW_OP_breg23";
3560 return "DW_OP_breg24";
3562 return "DW_OP_breg25";
3564 return "DW_OP_breg26";
3566 return "DW_OP_breg27";
3568 return "DW_OP_breg28";
3570 return "DW_OP_breg29";
3572 return "DW_OP_breg30";
3574 return "DW_OP_breg31";
3576 return "DW_OP_regx";
3578 return "DW_OP_fbreg";
3580 return "DW_OP_bregx";
3582 return "DW_OP_piece";
3583 case DW_OP_deref_size:
3584 return "DW_OP_deref_size";
3585 case DW_OP_xderef_size:
3586 return "DW_OP_xderef_size";
3590 return "OP_<unknown>";
3594 /* Convert a DWARF type code into its string name. */
3598 dwarf_type_encoding_name (enc)
3599 register unsigned enc;
3603 case DW_ATE_address:
3604 return "DW_ATE_address";
3605 case DW_ATE_boolean:
3606 return "DW_ATE_boolean";
3607 case DW_ATE_complex_float:
3608 return "DW_ATE_complex_float";
3610 return "DW_ATE_float";
3612 return "DW_ATE_signed";
3613 case DW_ATE_signed_char:
3614 return "DW_ATE_signed_char";
3615 case DW_ATE_unsigned:
3616 return "DW_ATE_unsigned";
3617 case DW_ATE_unsigned_char:
3618 return "DW_ATE_unsigned_char";
3620 return "DW_ATE_<unknown>";
3625 /* Determine the "ultimate origin" of a decl. The decl may be an inlined
3626 instance of an inlined instance of a decl which is local to an inline
3627 function, so we have to trace all of the way back through the origin chain
3628 to find out what sort of node actually served as the original seed for the
3632 decl_ultimate_origin (decl)
3635 #ifdef ENABLE_CHECKING
3636 if (DECL_FROM_INLINE (DECL_ORIGIN (decl)))
3637 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
3638 most distant ancestor, this should never happen. */
3642 return DECL_ABSTRACT_ORIGIN (decl);
3645 /* Determine the "ultimate origin" of a block. The block may be an inlined
3646 instance of an inlined instance of a block which is local to an inline
3647 function, so we have to trace all of the way back through the origin chain
3648 to find out what sort of node actually served as the original seed for the
3652 block_ultimate_origin (block)
3653 register tree block;
3655 register tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block);
3657 if (immediate_origin == NULL_TREE)
3661 register tree ret_val;
3662 register tree lookahead = immediate_origin;
3666 ret_val = lookahead;
3667 lookahead = (TREE_CODE (ret_val) == BLOCK)
3668 ? BLOCK_ABSTRACT_ORIGIN (ret_val)
3671 while (lookahead != NULL && lookahead != ret_val);
3677 /* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT
3678 of a virtual function may refer to a base class, so we check the 'this'
3682 decl_class_context (decl)
3685 tree context = NULL_TREE;
3687 if (TREE_CODE (decl) != FUNCTION_DECL || ! DECL_VINDEX (decl))
3688 context = DECL_CONTEXT (decl);
3690 context = TYPE_MAIN_VARIANT
3691 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
3693 if (context && TREE_CODE_CLASS (TREE_CODE (context)) != 't')
3694 context = NULL_TREE;
3699 /* Add an attribute/value pair to a DIE */
3702 add_dwarf_attr (die, attr)
3703 register dw_die_ref die;
3704 register dw_attr_ref attr;
3706 if (die != NULL && attr != NULL)
3708 if (die->die_attr == NULL)
3710 die->die_attr = attr;
3711 die->die_attr_last = attr;
3715 die->die_attr_last->dw_attr_next = attr;
3716 die->die_attr_last = attr;
3721 /* Add a flag value attribute to a DIE. */
3724 add_AT_flag (die, attr_kind, flag)
3725 register dw_die_ref die;
3726 register enum dwarf_attribute attr_kind;
3727 register unsigned flag;
3729 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3731 attr->dw_attr_next = NULL;
3732 attr->dw_attr = attr_kind;
3733 attr->dw_attr_val.val_class = dw_val_class_flag;
3734 attr->dw_attr_val.v.val_flag = flag;
3735 add_dwarf_attr (die, attr);
3738 /* Add a signed integer attribute value to a DIE. */
3741 add_AT_int (die, attr_kind, int_val)
3742 register dw_die_ref die;
3743 register enum dwarf_attribute attr_kind;
3744 register long int int_val;
3746 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3748 attr->dw_attr_next = NULL;
3749 attr->dw_attr = attr_kind;
3750 attr->dw_attr_val.val_class = dw_val_class_const;
3751 attr->dw_attr_val.v.val_int = int_val;
3752 add_dwarf_attr (die, attr);
3755 /* Add an unsigned integer attribute value to a DIE. */
3758 add_AT_unsigned (die, attr_kind, unsigned_val)
3759 register dw_die_ref die;
3760 register enum dwarf_attribute attr_kind;
3761 register unsigned long unsigned_val;
3763 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3765 attr->dw_attr_next = NULL;
3766 attr->dw_attr = attr_kind;
3767 attr->dw_attr_val.val_class = dw_val_class_unsigned_const;
3768 attr->dw_attr_val.v.val_unsigned = unsigned_val;
3769 add_dwarf_attr (die, attr);
3772 /* Add an unsigned double integer attribute value to a DIE. */
3775 add_AT_long_long (die, attr_kind, val_hi, val_low)
3776 register dw_die_ref die;
3777 register enum dwarf_attribute attr_kind;
3778 register unsigned long val_hi;
3779 register unsigned long val_low;
3781 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3783 attr->dw_attr_next = NULL;
3784 attr->dw_attr = attr_kind;
3785 attr->dw_attr_val.val_class = dw_val_class_long_long;
3786 attr->dw_attr_val.v.val_long_long.hi = val_hi;
3787 attr->dw_attr_val.v.val_long_long.low = val_low;
3788 add_dwarf_attr (die, attr);
3791 /* Add a floating point attribute value to a DIE and return it. */
3794 add_AT_float (die, attr_kind, length, array)
3795 register dw_die_ref die;
3796 register enum dwarf_attribute attr_kind;
3797 register unsigned length;
3798 register long *array;
3800 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3802 attr->dw_attr_next = NULL;
3803 attr->dw_attr = attr_kind;
3804 attr->dw_attr_val.val_class = dw_val_class_float;
3805 attr->dw_attr_val.v.val_float.length = length;
3806 attr->dw_attr_val.v.val_float.array = array;
3807 add_dwarf_attr (die, attr);
3810 /* Add a string attribute value to a DIE. */
3813 add_AT_string (die, attr_kind, str)
3814 register dw_die_ref die;
3815 register enum dwarf_attribute attr_kind;
3816 register const char *str;
3818 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3820 attr->dw_attr_next = NULL;
3821 attr->dw_attr = attr_kind;
3822 attr->dw_attr_val.val_class = dw_val_class_str;
3823 attr->dw_attr_val.v.val_str = xstrdup (str);
3824 add_dwarf_attr (die, attr);
3827 /* Add a DIE reference attribute value to a DIE. */
3830 add_AT_die_ref (die, attr_kind, targ_die)
3831 register dw_die_ref die;
3832 register enum dwarf_attribute attr_kind;
3833 register dw_die_ref targ_die;
3835 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3837 attr->dw_attr_next = NULL;
3838 attr->dw_attr = attr_kind;
3839 attr->dw_attr_val.val_class = dw_val_class_die_ref;
3840 attr->dw_attr_val.v.val_die_ref = targ_die;
3841 add_dwarf_attr (die, attr);
3844 /* Add an FDE reference attribute value to a DIE. */
3847 add_AT_fde_ref (die, attr_kind, targ_fde)
3848 register dw_die_ref die;
3849 register enum dwarf_attribute attr_kind;
3850 register unsigned targ_fde;
3852 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3854 attr->dw_attr_next = NULL;
3855 attr->dw_attr = attr_kind;
3856 attr->dw_attr_val.val_class = dw_val_class_fde_ref;
3857 attr->dw_attr_val.v.val_fde_index = targ_fde;
3858 add_dwarf_attr (die, attr);
3861 /* Add a location description attribute value to a DIE. */
3864 add_AT_loc (die, attr_kind, loc)
3865 register dw_die_ref die;
3866 register enum dwarf_attribute attr_kind;
3867 register dw_loc_descr_ref loc;
3869 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3871 attr->dw_attr_next = NULL;
3872 attr->dw_attr = attr_kind;
3873 attr->dw_attr_val.val_class = dw_val_class_loc;
3874 attr->dw_attr_val.v.val_loc = loc;
3875 add_dwarf_attr (die, attr);
3878 /* Add an address constant attribute value to a DIE. */
3881 add_AT_addr (die, attr_kind, addr)
3882 register dw_die_ref die;
3883 register enum dwarf_attribute attr_kind;
3886 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3888 attr->dw_attr_next = NULL;
3889 attr->dw_attr = attr_kind;
3890 attr->dw_attr_val.val_class = dw_val_class_addr;
3891 attr->dw_attr_val.v.val_addr = addr;
3892 add_dwarf_attr (die, attr);
3895 /* Add a label identifier attribute value to a DIE. */
3898 add_AT_lbl_id (die, attr_kind, lbl_id)
3899 register dw_die_ref die;
3900 register enum dwarf_attribute attr_kind;
3901 register char *lbl_id;
3903 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3905 attr->dw_attr_next = NULL;
3906 attr->dw_attr = attr_kind;
3907 attr->dw_attr_val.val_class = dw_val_class_lbl_id;
3908 attr->dw_attr_val.v.val_lbl_id = xstrdup (lbl_id);
3909 add_dwarf_attr (die, attr);
3912 /* Add a section offset attribute value to a DIE. */
3915 add_AT_lbl_offset (die, attr_kind, label)
3916 register dw_die_ref die;
3917 register enum dwarf_attribute attr_kind;
3918 register char *label;
3920 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3922 attr->dw_attr_next = NULL;
3923 attr->dw_attr = attr_kind;
3924 attr->dw_attr_val.val_class = dw_val_class_lbl_offset;
3925 attr->dw_attr_val.v.val_lbl_id = label;
3926 add_dwarf_attr (die, attr);
3930 /* Test if die refers to an external subroutine. */
3933 is_extern_subr_die (die)
3934 register dw_die_ref die;
3936 register dw_attr_ref a;
3937 register int is_subr = FALSE;
3938 register int is_extern = FALSE;
3940 if (die != NULL && die->die_tag == DW_TAG_subprogram)
3943 for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
3945 if (a->dw_attr == DW_AT_external
3946 && a->dw_attr_val.val_class == dw_val_class_flag
3947 && a->dw_attr_val.v.val_flag != 0)
3955 return is_subr && is_extern;
3958 /* Get the attribute of type attr_kind. */
3960 static inline dw_attr_ref
3961 get_AT (die, attr_kind)
3962 register dw_die_ref die;
3963 register enum dwarf_attribute attr_kind;
3965 register dw_attr_ref a;
3966 register dw_die_ref spec = NULL;
3970 for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
3972 if (a->dw_attr == attr_kind)
3975 if (a->dw_attr == DW_AT_specification
3976 || a->dw_attr == DW_AT_abstract_origin)
3977 spec = a->dw_attr_val.v.val_die_ref;
3981 return get_AT (spec, attr_kind);
3987 /* Return the "low pc" attribute value, typically associated with
3988 a subprogram DIE. Return null if the "low pc" attribute is
3989 either not prsent, or if it cannot be represented as an
3990 assembler label identifier. */
3992 static inline char *
3994 register dw_die_ref die;
3996 register dw_attr_ref a = get_AT (die, DW_AT_low_pc);
3998 if (a && a->dw_attr_val.val_class == dw_val_class_lbl_id)
3999 return a->dw_attr_val.v.val_lbl_id;
4004 /* Return the "high pc" attribute value, typically associated with
4005 a subprogram DIE. Return null if the "high pc" attribute is
4006 either not prsent, or if it cannot be represented as an
4007 assembler label identifier. */
4009 static inline char *
4011 register dw_die_ref die;
4013 register dw_attr_ref a = get_AT (die, DW_AT_high_pc);
4015 if (a && a->dw_attr_val.val_class == dw_val_class_lbl_id)
4016 return a->dw_attr_val.v.val_lbl_id;
4021 /* Return the value of the string attribute designated by ATTR_KIND, or
4022 NULL if it is not present. */
4024 static inline char *
4025 get_AT_string (die, attr_kind)
4026 register dw_die_ref die;
4027 register enum dwarf_attribute attr_kind;
4029 register dw_attr_ref a = get_AT (die, attr_kind);
4031 if (a && a->dw_attr_val.val_class == dw_val_class_str)
4032 return a->dw_attr_val.v.val_str;
4037 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
4038 if it is not present. */
4041 get_AT_flag (die, attr_kind)
4042 register dw_die_ref die;
4043 register enum dwarf_attribute attr_kind;
4045 register dw_attr_ref a = get_AT (die, attr_kind);
4047 if (a && a->dw_attr_val.val_class == dw_val_class_flag)
4048 return a->dw_attr_val.v.val_flag;
4053 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
4054 if it is not present. */
4056 static inline unsigned
4057 get_AT_unsigned (die, attr_kind)
4058 register dw_die_ref die;
4059 register enum dwarf_attribute attr_kind;
4061 register dw_attr_ref a = get_AT (die, attr_kind);
4063 if (a && a->dw_attr_val.val_class == dw_val_class_unsigned_const)
4064 return a->dw_attr_val.v.val_unsigned;
4072 register unsigned lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
4074 return (lang == DW_LANG_C || lang == DW_LANG_C89
4075 || lang == DW_LANG_C_plus_plus);
4081 register unsigned lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
4083 return (lang == DW_LANG_Fortran77 || lang == DW_LANG_Fortran90);
4086 /* Remove the specified attribute if present. */
4089 remove_AT (die, attr_kind)
4090 register dw_die_ref die;
4091 register enum dwarf_attribute attr_kind;
4093 register dw_attr_ref a;
4094 register dw_attr_ref removed = NULL;;
4098 if (die->die_attr->dw_attr == attr_kind)
4100 removed = die->die_attr;
4101 if (die->die_attr_last == die->die_attr)
4102 die->die_attr_last = NULL;
4104 die->die_attr = die->die_attr->dw_attr_next;
4108 for (a = die->die_attr; a->dw_attr_next != NULL;
4109 a = a->dw_attr_next)
4110 if (a->dw_attr_next->dw_attr == attr_kind)
4112 removed = a->dw_attr_next;
4113 if (die->die_attr_last == a->dw_attr_next)
4114 die->die_attr_last = a;
4116 a->dw_attr_next = a->dw_attr_next->dw_attr_next;
4125 /* Discard the children of this DIE. */
4128 remove_children (die)
4129 register dw_die_ref die;
4131 register dw_die_ref child_die = die->die_child;
4133 die->die_child = NULL;
4134 die->die_child_last = NULL;
4136 while (child_die != NULL)
4138 register dw_die_ref tmp_die = child_die;
4139 register dw_attr_ref a;
4141 child_die = child_die->die_sib;
4143 for (a = tmp_die->die_attr; a != NULL; )
4145 register dw_attr_ref tmp_a = a;
4147 a = a->dw_attr_next;
4155 /* Add a child DIE below its parent. */
4158 add_child_die (die, child_die)
4159 register dw_die_ref die;
4160 register dw_die_ref child_die;
4162 if (die != NULL && child_die != NULL)
4164 if (die == child_die)
4166 child_die->die_parent = die;
4167 child_die->die_sib = NULL;
4169 if (die->die_child == NULL)
4171 die->die_child = child_die;
4172 die->die_child_last = child_die;
4176 die->die_child_last->die_sib = child_die;
4177 die->die_child_last = child_die;
4182 /* Return a pointer to a newly created DIE node. */
4184 static inline dw_die_ref
4185 new_die (tag_value, parent_die)
4186 register enum dwarf_tag tag_value;
4187 register dw_die_ref parent_die;
4189 register dw_die_ref die = (dw_die_ref) xmalloc (sizeof (die_node));
4191 die->die_tag = tag_value;
4192 die->die_abbrev = 0;
4193 die->die_offset = 0;
4194 die->die_child = NULL;
4195 die->die_parent = NULL;
4196 die->die_sib = NULL;
4197 die->die_child_last = NULL;
4198 die->die_attr = NULL;
4199 die->die_attr_last = NULL;
4201 if (parent_die != NULL)
4202 add_child_die (parent_die, die);
4205 limbo_die_node *limbo_node;
4207 limbo_node = (limbo_die_node *) xmalloc (sizeof (limbo_die_node));
4208 limbo_node->die = die;
4209 limbo_node->next = limbo_die_list;
4210 limbo_die_list = limbo_node;
4216 /* Return the DIE associated with the given type specifier. */
4218 static inline dw_die_ref
4219 lookup_type_die (type)
4222 return (dw_die_ref) TYPE_SYMTAB_POINTER (type);
4225 /* Equate a DIE to a given type specifier. */
4228 equate_type_number_to_die (type, type_die)
4230 register dw_die_ref type_die;
4232 TYPE_SYMTAB_POINTER (type) = (char *) type_die;
4235 /* Return the DIE associated with a given declaration. */
4237 static inline dw_die_ref
4238 lookup_decl_die (decl)
4241 register unsigned decl_id = DECL_UID (decl);
4243 return (decl_id < decl_die_table_in_use
4244 ? decl_die_table[decl_id] : NULL);
4247 /* Equate a DIE to a particular declaration. */
4250 equate_decl_number_to_die (decl, decl_die)
4252 register dw_die_ref decl_die;
4254 register unsigned decl_id = DECL_UID (decl);
4255 register unsigned num_allocated;
4257 if (decl_id >= decl_die_table_allocated)
4260 = ((decl_id + 1 + DECL_DIE_TABLE_INCREMENT - 1)
4261 / DECL_DIE_TABLE_INCREMENT)
4262 * DECL_DIE_TABLE_INCREMENT;
4265 = (dw_die_ref *) xrealloc (decl_die_table,
4266 sizeof (dw_die_ref) * num_allocated);
4268 bzero ((char *) &decl_die_table[decl_die_table_allocated],
4269 (num_allocated - decl_die_table_allocated) * sizeof (dw_die_ref));
4270 decl_die_table_allocated = num_allocated;
4273 if (decl_id >= decl_die_table_in_use)
4274 decl_die_table_in_use = (decl_id + 1);
4276 decl_die_table[decl_id] = decl_die;
4279 /* Return a pointer to a newly allocated location description. Location
4280 descriptions are simple expression terms that can be strung
4281 together to form more complicated location (address) descriptions. */
4283 static inline dw_loc_descr_ref
4284 new_loc_descr (op, oprnd1, oprnd2)
4285 register enum dwarf_location_atom op;
4286 register unsigned long oprnd1;
4287 register unsigned long oprnd2;
4289 register dw_loc_descr_ref descr
4290 = (dw_loc_descr_ref) xmalloc (sizeof (dw_loc_descr_node));
4292 descr->dw_loc_next = NULL;
4293 descr->dw_loc_opc = op;
4294 descr->dw_loc_oprnd1.val_class = dw_val_class_unsigned_const;
4295 descr->dw_loc_oprnd1.v.val_unsigned = oprnd1;
4296 descr->dw_loc_oprnd2.val_class = dw_val_class_unsigned_const;
4297 descr->dw_loc_oprnd2.v.val_unsigned = oprnd2;
4302 /* Add a location description term to a location description expression. */
4305 add_loc_descr (list_head, descr)
4306 register dw_loc_descr_ref *list_head;
4307 register dw_loc_descr_ref descr;
4309 register dw_loc_descr_ref *d;
4311 /* Find the end of the chain. */
4312 for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
4318 /* Keep track of the number of spaces used to indent the
4319 output of the debugging routines that print the structure of
4320 the DIE internal representation. */
4321 static int print_indent;
4323 /* Indent the line the number of spaces given by print_indent. */
4326 print_spaces (outfile)
4329 fprintf (outfile, "%*s", print_indent, "");
4332 /* Print the information associated with a given DIE, and its children.
4333 This routine is a debugging aid only. */
4336 print_die (die, outfile)
4340 register dw_attr_ref a;
4341 register dw_die_ref c;
4343 print_spaces (outfile);
4344 fprintf (outfile, "DIE %4lu: %s\n",
4345 die->die_offset, dwarf_tag_name (die->die_tag));
4346 print_spaces (outfile);
4347 fprintf (outfile, " abbrev id: %lu", die->die_abbrev);
4348 fprintf (outfile, " offset: %lu\n", die->die_offset);
4350 for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
4352 print_spaces (outfile);
4353 fprintf (outfile, " %s: ", dwarf_attr_name (a->dw_attr));
4355 switch (a->dw_attr_val.val_class)
4357 case dw_val_class_addr:
4358 fprintf (outfile, "address");
4360 case dw_val_class_loc:
4361 fprintf (outfile, "location descriptor");
4363 case dw_val_class_const:
4364 fprintf (outfile, "%ld", a->dw_attr_val.v.val_int);
4366 case dw_val_class_unsigned_const:
4367 fprintf (outfile, "%lu", a->dw_attr_val.v.val_unsigned);
4369 case dw_val_class_long_long:
4370 fprintf (outfile, "constant (%lu,%lu)",
4371 a->dw_attr_val.v.val_long_long.hi,
4372 a->dw_attr_val.v.val_long_long.low);
4374 case dw_val_class_float:
4375 fprintf (outfile, "floating-point constant");
4377 case dw_val_class_flag:
4378 fprintf (outfile, "%u", a->dw_attr_val.v.val_flag);
4380 case dw_val_class_die_ref:
4381 if (a->dw_attr_val.v.val_die_ref != NULL)
4382 fprintf (outfile, "die -> %lu",
4383 a->dw_attr_val.v.val_die_ref->die_offset);
4385 fprintf (outfile, "die -> <null>");
4387 case dw_val_class_lbl_id:
4388 case dw_val_class_lbl_offset:
4389 fprintf (outfile, "label: %s", a->dw_attr_val.v.val_lbl_id);
4391 case dw_val_class_str:
4392 if (a->dw_attr_val.v.val_str != NULL)
4393 fprintf (outfile, "\"%s\"", a->dw_attr_val.v.val_str);
4395 fprintf (outfile, "<null>");
4401 fprintf (outfile, "\n");
4404 if (die->die_child != NULL)
4407 for (c = die->die_child; c != NULL; c = c->die_sib)
4408 print_die (c, outfile);
4414 /* Print the contents of the source code line number correspondence table.
4415 This routine is a debugging aid only. */
4418 print_dwarf_line_table (outfile)
4421 register unsigned i;
4422 register dw_line_info_ref line_info;
4424 fprintf (outfile, "\n\nDWARF source line information\n");
4425 for (i = 1; i < line_info_table_in_use; ++i)
4427 line_info = &line_info_table[i];
4428 fprintf (outfile, "%5d: ", i);
4429 fprintf (outfile, "%-20s", file_table[line_info->dw_file_num]);
4430 fprintf (outfile, "%6ld", line_info->dw_line_num);
4431 fprintf (outfile, "\n");
4434 fprintf (outfile, "\n\n");
4437 /* Print the information collected for a given DIE. */
4440 debug_dwarf_die (die)
4443 print_die (die, stderr);
4446 /* Print all DWARF information collected for the compilation unit.
4447 This routine is a debugging aid only. */
4453 print_die (comp_unit_die, stderr);
4454 if (! DWARF2_ASM_LINE_DEBUG_INFO)
4455 print_dwarf_line_table (stderr);
4458 /* Traverse the DIE, and add a sibling attribute if it may have the
4459 effect of speeding up access to siblings. To save some space,
4460 avoid generating sibling attributes for DIE's without children. */
4463 add_sibling_attributes(die)
4464 register dw_die_ref die;
4466 register dw_die_ref c;
4467 register dw_attr_ref attr;
4468 if (die != comp_unit_die && die->die_child != NULL)
4470 attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
4471 attr->dw_attr_next = NULL;
4472 attr->dw_attr = DW_AT_sibling;
4473 attr->dw_attr_val.val_class = dw_val_class_die_ref;
4474 attr->dw_attr_val.v.val_die_ref = die->die_sib;
4476 /* Add the sibling link to the front of the attribute list. */
4477 attr->dw_attr_next = die->die_attr;
4478 if (die->die_attr == NULL)
4479 die->die_attr_last = attr;
4481 die->die_attr = attr;
4484 for (c = die->die_child; c != NULL; c = c->die_sib)
4485 add_sibling_attributes (c);
4488 /* The format of each DIE (and its attribute value pairs)
4489 is encoded in an abbreviation table. This routine builds the
4490 abbreviation table and assigns a unique abbreviation id for
4491 each abbreviation entry. The children of each die are visited
4495 build_abbrev_table (die)
4496 register dw_die_ref die;
4498 register unsigned long abbrev_id;
4499 register unsigned long n_alloc;
4500 register dw_die_ref c;
4501 register dw_attr_ref d_attr, a_attr;
4502 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
4504 register dw_die_ref abbrev = abbrev_die_table[abbrev_id];
4506 if (abbrev->die_tag == die->die_tag)
4508 if ((abbrev->die_child != NULL) == (die->die_child != NULL))
4510 a_attr = abbrev->die_attr;
4511 d_attr = die->die_attr;
4513 while (a_attr != NULL && d_attr != NULL)
4515 if ((a_attr->dw_attr != d_attr->dw_attr)
4516 || (value_format (&a_attr->dw_attr_val)
4517 != value_format (&d_attr->dw_attr_val)))
4520 a_attr = a_attr->dw_attr_next;
4521 d_attr = d_attr->dw_attr_next;
4524 if (a_attr == NULL && d_attr == NULL)
4530 if (abbrev_id >= abbrev_die_table_in_use)
4532 if (abbrev_die_table_in_use >= abbrev_die_table_allocated)
4534 n_alloc = abbrev_die_table_allocated + ABBREV_DIE_TABLE_INCREMENT;
4536 = (dw_die_ref *) xrealloc (abbrev_die_table,
4537 sizeof (dw_die_ref) * n_alloc);
4539 bzero ((char *) &abbrev_die_table[abbrev_die_table_allocated],
4540 (n_alloc - abbrev_die_table_allocated) * sizeof (dw_die_ref));
4541 abbrev_die_table_allocated = n_alloc;
4544 ++abbrev_die_table_in_use;
4545 abbrev_die_table[abbrev_id] = die;
4548 die->die_abbrev = abbrev_id;
4549 for (c = die->die_child; c != NULL; c = c->die_sib)
4550 build_abbrev_table (c);
4553 /* Return the size of a string, including the null byte.
4555 This used to treat backslashes as escapes, and hence they were not included
4556 in the count. However, that conflicts with what ASM_OUTPUT_ASCII does,
4557 which treats a backslash as a backslash, escaping it if necessary, and hence
4558 we must include them in the count. */
4560 static unsigned long
4561 size_of_string (str)
4564 return strlen (str) + 1;
4567 /* Return the size of a location descriptor. */
4569 static unsigned long
4570 size_of_loc_descr (loc)
4571 register dw_loc_descr_ref loc;
4573 register unsigned long size = 1;
4575 switch (loc->dw_loc_opc)
4597 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4600 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
4605 case DW_OP_plus_uconst:
4606 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4644 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
4647 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4650 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
4653 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4654 size += size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int);
4657 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4659 case DW_OP_deref_size:
4660 case DW_OP_xderef_size:
4670 /* Return the size of a series of location descriptors. */
4672 static unsigned long
4674 register dw_loc_descr_ref loc;
4676 register unsigned long size = 0;
4678 for (; loc != NULL; loc = loc->dw_loc_next)
4679 size += size_of_loc_descr (loc);
4684 /* Return the power-of-two number of bytes necessary to represent VALUE. */
4687 constant_size (value)
4688 long unsigned value;
4695 log = floor_log2 (value);
4698 log = 1 << (floor_log2 (log) + 1);
4703 /* Return the size of a DIE, as it is represented in the
4704 .debug_info section. */
4706 static unsigned long
4708 register dw_die_ref die;
4710 register unsigned long size = 0;
4711 register dw_attr_ref a;
4713 size += size_of_uleb128 (die->die_abbrev);
4714 for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
4716 switch (a->dw_attr_val.val_class)
4718 case dw_val_class_addr:
4721 case dw_val_class_loc:
4723 register unsigned long lsize
4724 = size_of_locs (a->dw_attr_val.v.val_loc);
4727 size += constant_size (lsize);
4731 case dw_val_class_const:
4734 case dw_val_class_unsigned_const:
4735 size += constant_size (a->dw_attr_val.v.val_unsigned);
4737 case dw_val_class_long_long:
4738 size += 1 + 8; /* block */
4740 case dw_val_class_float:
4741 size += 1 + a->dw_attr_val.v.val_float.length * 4; /* block */
4743 case dw_val_class_flag:
4746 case dw_val_class_die_ref:
4747 size += DWARF_OFFSET_SIZE;
4749 case dw_val_class_fde_ref:
4750 size += DWARF_OFFSET_SIZE;
4752 case dw_val_class_lbl_id:
4755 case dw_val_class_lbl_offset:
4756 size += DWARF_OFFSET_SIZE;
4758 case dw_val_class_str:
4759 size += size_of_string (a->dw_attr_val.v.val_str);
4769 /* Size the debugging information associated with a given DIE.
4770 Visits the DIE's children recursively. Updates the global
4771 variable next_die_offset, on each time through. Uses the
4772 current value of next_die_offset to update the die_offset
4773 field in each DIE. */
4776 calc_die_sizes (die)
4779 register dw_die_ref c;
4780 die->die_offset = next_die_offset;
4781 next_die_offset += size_of_die (die);
4783 for (c = die->die_child; c != NULL; c = c->die_sib)
4786 if (die->die_child != NULL)
4787 /* Count the null byte used to terminate sibling lists. */
4788 next_die_offset += 1;
4791 /* Return the size of the line information prolog generated for the
4792 compilation unit. */
4794 static unsigned long
4795 size_of_line_prolog ()
4797 register unsigned long size;
4798 register unsigned long ft_index;
4800 size = DWARF_LINE_PROLOG_HEADER_SIZE;
4802 /* Count the size of the table giving number of args for each
4804 size += DWARF_LINE_OPCODE_BASE - 1;
4806 /* Include directory table is empty (at present). Count only the
4807 null byte used to terminate the table. */
4810 for (ft_index = 1; ft_index < file_table_in_use; ++ft_index)
4812 /* File name entry. */
4813 size += size_of_string (file_table[ft_index]);
4815 /* Include directory index. */
4816 size += size_of_uleb128 (0);
4818 /* Modification time. */
4819 size += size_of_uleb128 (0);
4821 /* File length in bytes. */
4822 size += size_of_uleb128 (0);
4825 /* Count the file table terminator. */
4830 /* Return the size of the line information generated for this
4831 compilation unit. */
4833 static unsigned long
4834 size_of_line_info ()
4836 register unsigned long size;
4837 register unsigned long lt_index;
4838 register unsigned long current_line;
4839 register long line_offset;
4840 register long line_delta;
4841 register unsigned long current_file;
4842 register unsigned long function;
4843 unsigned long size_of_set_address;
4845 /* Size of a DW_LNE_set_address instruction. */
4846 size_of_set_address = 1 + size_of_uleb128 (1 + PTR_SIZE) + 1 + PTR_SIZE;
4848 /* Version number. */
4851 /* Prolog length specifier. */
4852 size += DWARF_OFFSET_SIZE;
4855 size += size_of_line_prolog ();
4859 for (lt_index = 1; lt_index < line_info_table_in_use; ++lt_index)
4861 register dw_line_info_ref line_info = &line_info_table[lt_index];
4863 if (line_info->dw_line_num == current_line
4864 && line_info->dw_file_num == current_file)
4867 /* Advance pc instruction. */
4868 /* ??? See the DW_LNS_advance_pc comment in output_line_info. */
4872 size += size_of_set_address;
4874 if (line_info->dw_file_num != current_file)
4876 /* Set file number instruction. */
4878 current_file = line_info->dw_file_num;
4879 size += size_of_uleb128 (current_file);
4882 if (line_info->dw_line_num != current_line)
4884 line_offset = line_info->dw_line_num - current_line;
4885 line_delta = line_offset - DWARF_LINE_BASE;
4886 current_line = line_info->dw_line_num;
4887 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
4888 /* 1-byte special line number instruction. */
4892 /* Advance line instruction. */
4894 size += size_of_sleb128 (line_offset);
4895 /* Generate line entry instruction. */
4901 /* Advance pc instruction. */
4905 size += size_of_set_address;
4907 /* End of line number info. marker. */
4908 size += 1 + size_of_uleb128 (1) + 1;
4913 for (lt_index = 0; lt_index < separate_line_info_table_in_use; )
4915 register dw_separate_line_info_ref line_info
4916 = &separate_line_info_table[lt_index];
4918 if (line_info->dw_line_num == current_line
4919 && line_info->dw_file_num == current_file
4920 && line_info->function == function)
4923 if (function != line_info->function)
4925 function = line_info->function;
4926 /* Set address register instruction. */
4927 size += size_of_set_address;
4931 /* Advance pc instruction. */
4935 size += size_of_set_address;
4938 if (line_info->dw_file_num != current_file)
4940 /* Set file number instruction. */
4942 current_file = line_info->dw_file_num;
4943 size += size_of_uleb128 (current_file);
4946 if (line_info->dw_line_num != current_line)
4948 line_offset = line_info->dw_line_num - current_line;
4949 line_delta = line_offset - DWARF_LINE_BASE;
4950 current_line = line_info->dw_line_num;
4951 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
4952 /* 1-byte special line number instruction. */
4956 /* Advance line instruction. */
4958 size += size_of_sleb128 (line_offset);
4960 /* Generate line entry instruction. */
4968 /* If we're done with a function, end its sequence. */
4969 if (lt_index == separate_line_info_table_in_use
4970 || separate_line_info_table[lt_index].function != function)
4975 /* Advance pc instruction. */
4979 size += size_of_set_address;
4981 /* End of line number info. marker. */
4982 size += 1 + size_of_uleb128 (1) + 1;
4989 /* Return the size of the .debug_pubnames table generated for the
4990 compilation unit. */
4992 static unsigned long
4995 register unsigned long size;
4996 register unsigned i;
4998 size = DWARF_PUBNAMES_HEADER_SIZE;
4999 for (i = 0; i < pubname_table_in_use; ++i)
5001 register pubname_ref p = &pubname_table[i];
5002 size += DWARF_OFFSET_SIZE + size_of_string (p->name);
5005 size += DWARF_OFFSET_SIZE;
5009 /* Return the size of the information in the .debug_aranges section. */
5011 static unsigned long
5014 register unsigned long size;
5016 size = DWARF_ARANGES_HEADER_SIZE;
5018 /* Count the address/length pair for this compilation unit. */
5019 size += 2 * PTR_SIZE;
5020 size += 2 * PTR_SIZE * arange_table_in_use;
5022 /* Count the two zero words used to terminated the address range table. */
5023 size += 2 * PTR_SIZE;
5027 /* Select the encoding of an attribute value. */
5029 static enum dwarf_form
5033 switch (v->val_class)
5035 case dw_val_class_addr:
5036 return DW_FORM_addr;
5037 case dw_val_class_loc:
5038 switch (constant_size (size_of_locs (v->v.val_loc)))
5041 return DW_FORM_block1;
5043 return DW_FORM_block2;
5047 case dw_val_class_const:
5048 return DW_FORM_data4;
5049 case dw_val_class_unsigned_const:
5050 switch (constant_size (v->v.val_unsigned))
5053 return DW_FORM_data1;
5055 return DW_FORM_data2;
5057 return DW_FORM_data4;
5059 return DW_FORM_data8;
5063 case dw_val_class_long_long:
5064 return DW_FORM_block1;
5065 case dw_val_class_float:
5066 return DW_FORM_block1;
5067 case dw_val_class_flag:
5068 return DW_FORM_flag;
5069 case dw_val_class_die_ref:
5071 case dw_val_class_fde_ref:
5072 return DW_FORM_data;
5073 case dw_val_class_lbl_id:
5074 return DW_FORM_addr;
5075 case dw_val_class_lbl_offset:
5076 return DW_FORM_data;
5077 case dw_val_class_str:
5078 return DW_FORM_string;
5084 /* Output the encoding of an attribute value. */
5087 output_value_format (v)
5090 enum dwarf_form form = value_format (v);
5092 output_uleb128 (form);
5094 fprintf (asm_out_file, " (%s)", dwarf_form_name (form));
5096 fputc ('\n', asm_out_file);
5099 /* Output the .debug_abbrev section which defines the DIE abbreviation
5103 output_abbrev_section ()
5105 unsigned long abbrev_id;
5108 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
5110 register dw_die_ref abbrev = abbrev_die_table[abbrev_id];
5112 output_uleb128 (abbrev_id);
5114 fprintf (asm_out_file, " (abbrev code)");
5116 fputc ('\n', asm_out_file);
5117 output_uleb128 (abbrev->die_tag);
5119 fprintf (asm_out_file, " (TAG: %s)",
5120 dwarf_tag_name (abbrev->die_tag));
5122 fputc ('\n', asm_out_file);
5123 fprintf (asm_out_file, "\t%s\t0x%x", ASM_BYTE_OP,
5124 abbrev->die_child != NULL ? DW_children_yes : DW_children_no);
5127 fprintf (asm_out_file, "\t%s %s",
5129 (abbrev->die_child != NULL
5130 ? "DW_children_yes" : "DW_children_no"));
5132 fputc ('\n', asm_out_file);
5134 for (a_attr = abbrev->die_attr; a_attr != NULL;
5135 a_attr = a_attr->dw_attr_next)
5137 output_uleb128 (a_attr->dw_attr);
5139 fprintf (asm_out_file, " (%s)",
5140 dwarf_attr_name (a_attr->dw_attr));
5142 fputc ('\n', asm_out_file);
5143 output_value_format (&a_attr->dw_attr_val);
5146 fprintf (asm_out_file, "\t%s\t0,0\n", ASM_BYTE_OP);
5149 /* Terminate the table. */
5150 fprintf (asm_out_file, "\t%s\t0\n", ASM_BYTE_OP);
5153 /* Output location description stack opcode's operands (if any). */
5156 output_loc_operands (loc)
5157 register dw_loc_descr_ref loc;
5159 register dw_val_ref val1 = &loc->dw_loc_oprnd1;
5160 register dw_val_ref val2 = &loc->dw_loc_oprnd2;
5162 switch (loc->dw_loc_opc)
5165 ASM_OUTPUT_DWARF_ADDR_CONST (asm_out_file, val1->v.val_addr);
5166 fputc ('\n', asm_out_file);
5170 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, val1->v.val_flag);
5171 fputc ('\n', asm_out_file);
5175 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, val1->v.val_int);
5176 fputc ('\n', asm_out_file);
5180 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, val1->v.val_int);
5181 fputc ('\n', asm_out_file);
5186 fputc ('\n', asm_out_file);
5189 output_uleb128 (val1->v.val_unsigned);
5190 fputc ('\n', asm_out_file);
5193 output_sleb128 (val1->v.val_int);
5194 fputc ('\n', asm_out_file);
5197 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, val1->v.val_int);
5198 fputc ('\n', asm_out_file);
5200 case DW_OP_plus_uconst:
5201 output_uleb128 (val1->v.val_unsigned);
5202 fputc ('\n', asm_out_file);
5206 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, val1->v.val_int);
5207 fputc ('\n', asm_out_file);
5241 output_sleb128 (val1->v.val_int);
5242 fputc ('\n', asm_out_file);
5245 output_uleb128 (val1->v.val_unsigned);
5246 fputc ('\n', asm_out_file);
5249 output_sleb128 (val1->v.val_int);
5250 fputc ('\n', asm_out_file);
5253 output_uleb128 (val1->v.val_unsigned);
5254 fputc ('\n', asm_out_file);
5255 output_sleb128 (val2->v.val_int);
5256 fputc ('\n', asm_out_file);
5259 output_uleb128 (val1->v.val_unsigned);
5260 fputc ('\n', asm_out_file);
5262 case DW_OP_deref_size:
5263 case DW_OP_xderef_size:
5264 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, val1->v.val_flag);
5265 fputc ('\n', asm_out_file);
5272 /* Compute the offset of a sibling. */
5274 static unsigned long
5275 sibling_offset (die)
5278 unsigned long offset;
5280 if (die->die_child_last == NULL)
5281 offset = die->die_offset + size_of_die (die);
5283 offset = sibling_offset (die->die_child_last) + 1;
5288 /* Output the DIE and its attributes. Called recursively to generate
5289 the definitions of each child DIE. */
5293 register dw_die_ref die;
5295 register dw_attr_ref a;
5296 register dw_die_ref c;
5297 register unsigned long ref_offset;
5298 register unsigned long size;
5299 register dw_loc_descr_ref loc;
5301 output_uleb128 (die->die_abbrev);
5303 fprintf (asm_out_file, " (DIE (0x%lx) %s)",
5304 die->die_offset, dwarf_tag_name (die->die_tag));
5306 fputc ('\n', asm_out_file);
5308 for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
5310 switch (a->dw_attr_val.val_class)
5312 case dw_val_class_addr:
5313 ASM_OUTPUT_DWARF_ADDR_CONST (asm_out_file,
5314 a->dw_attr_val.v.val_addr);
5317 case dw_val_class_loc:
5318 size = size_of_locs (a->dw_attr_val.v.val_loc);
5320 /* Output the block length for this list of location operations. */
5321 switch (constant_size (size))
5324 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, size);
5327 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, size);
5334 fprintf (asm_out_file, "\t%s %s",
5335 ASM_COMMENT_START, dwarf_attr_name (a->dw_attr));
5337 fputc ('\n', asm_out_file);
5338 for (loc = a->dw_attr_val.v.val_loc; loc != NULL;
5339 loc = loc->dw_loc_next)
5341 /* Output the opcode. */
5342 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, loc->dw_loc_opc);
5344 fprintf (asm_out_file, "\t%s %s", ASM_COMMENT_START,
5345 dwarf_stack_op_name (loc->dw_loc_opc));
5347 fputc ('\n', asm_out_file);
5349 /* Output the operand(s) (if any). */
5350 output_loc_operands (loc);
5354 case dw_val_class_const:
5355 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, a->dw_attr_val.v.val_int);
5358 case dw_val_class_unsigned_const:
5359 switch (constant_size (a->dw_attr_val.v.val_unsigned))
5362 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
5363 a->dw_attr_val.v.val_unsigned);
5366 ASM_OUTPUT_DWARF_DATA2 (asm_out_file,
5367 a->dw_attr_val.v.val_unsigned);
5370 ASM_OUTPUT_DWARF_DATA4 (asm_out_file,
5371 a->dw_attr_val.v.val_unsigned);
5374 ASM_OUTPUT_DWARF_DATA8 (asm_out_file,
5375 a->dw_attr_val.v.val_long_long.hi,
5376 a->dw_attr_val.v.val_long_long.low);
5383 case dw_val_class_long_long:
5384 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 8);
5386 fprintf (asm_out_file, "\t%s %s",
5387 ASM_COMMENT_START, dwarf_attr_name (a->dw_attr));
5389 fputc ('\n', asm_out_file);
5390 ASM_OUTPUT_DWARF_DATA8 (asm_out_file,
5391 a->dw_attr_val.v.val_long_long.hi,
5392 a->dw_attr_val.v.val_long_long.low);
5395 fprintf (asm_out_file,
5396 "\t%s long long constant", ASM_COMMENT_START);
5398 fputc ('\n', asm_out_file);
5401 case dw_val_class_float:
5403 register unsigned int i;
5404 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
5405 a->dw_attr_val.v.val_float.length * 4);
5407 fprintf (asm_out_file, "\t%s %s",
5408 ASM_COMMENT_START, dwarf_attr_name (a->dw_attr));
5410 fputc ('\n', asm_out_file);
5411 for (i = 0; i < a->dw_attr_val.v.val_float.length; ++i)
5413 ASM_OUTPUT_DWARF_DATA4 (asm_out_file,
5414 a->dw_attr_val.v.val_float.array[i]);
5416 fprintf (asm_out_file, "\t%s fp constant word %u",
5417 ASM_COMMENT_START, i);
5419 fputc ('\n', asm_out_file);
5424 case dw_val_class_flag:
5425 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, a->dw_attr_val.v.val_flag);
5428 case dw_val_class_die_ref:
5429 if (a->dw_attr_val.v.val_die_ref != NULL)
5430 ref_offset = a->dw_attr_val.v.val_die_ref->die_offset;
5431 else if (a->dw_attr == DW_AT_sibling)
5432 ref_offset = sibling_offset(die);
5436 ASM_OUTPUT_DWARF_DATA (asm_out_file, ref_offset);
5439 case dw_val_class_fde_ref:
5442 ASM_GENERATE_INTERNAL_LABEL
5443 (l1, FDE_AFTER_SIZE_LABEL, a->dw_attr_val.v.val_fde_index * 2);
5444 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, l1);
5445 fprintf (asm_out_file, " - %d", DWARF_OFFSET_SIZE);
5449 case dw_val_class_lbl_id:
5450 ASM_OUTPUT_DWARF_ADDR (asm_out_file, a->dw_attr_val.v.val_lbl_id);
5453 case dw_val_class_lbl_offset:
5454 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, a->dw_attr_val.v.val_lbl_id);
5457 case dw_val_class_str:
5459 ASM_OUTPUT_DWARF_STRING (asm_out_file, a->dw_attr_val.v.val_str);
5461 ASM_OUTPUT_ASCII (asm_out_file,
5462 a->dw_attr_val.v.val_str,
5463 (int) strlen (a->dw_attr_val.v.val_str) + 1);
5470 if (a->dw_attr_val.val_class != dw_val_class_loc
5471 && a->dw_attr_val.val_class != dw_val_class_long_long
5472 && a->dw_attr_val.val_class != dw_val_class_float)
5475 fprintf (asm_out_file, "\t%s %s",
5476 ASM_COMMENT_START, dwarf_attr_name (a->dw_attr));
5478 fputc ('\n', asm_out_file);
5482 for (c = die->die_child; c != NULL; c = c->die_sib)
5485 if (die->die_child != NULL)
5487 /* Add null byte to terminate sibling list. */
5488 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5490 fprintf (asm_out_file, "\t%s end of children of DIE 0x%lx",
5491 ASM_COMMENT_START, die->die_offset);
5493 fputc ('\n', asm_out_file);
5497 /* Output the compilation unit that appears at the beginning of the
5498 .debug_info section, and precedes the DIE descriptions. */
5501 output_compilation_unit_header ()
5503 ASM_OUTPUT_DWARF_DATA (asm_out_file, next_die_offset - DWARF_OFFSET_SIZE);
5505 fprintf (asm_out_file, "\t%s Length of Compilation Unit Info.",
5508 fputc ('\n', asm_out_file);
5509 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, DWARF_VERSION);
5511 fprintf (asm_out_file, "\t%s DWARF version number", ASM_COMMENT_START);
5513 fputc ('\n', asm_out_file);
5514 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, abbrev_section_label);
5516 fprintf (asm_out_file, "\t%s Offset Into Abbrev. Section",
5519 fputc ('\n', asm_out_file);
5520 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, PTR_SIZE);
5522 fprintf (asm_out_file, "\t%s Pointer Size (in bytes)", ASM_COMMENT_START);
5524 fputc ('\n', asm_out_file);
5527 /* The DWARF2 pubname for a nested thingy looks like "A::f". The output
5528 of decl_printable_name for C++ looks like "A::f(int)". Let's drop the
5529 argument list, and maybe the scope. */
5532 dwarf2_name (decl, scope)
5536 return (*decl_printable_name) (decl, scope ? 1 : 0);
5539 /* Add a new entry to .debug_pubnames if appropriate. */
5542 add_pubname (decl, die)
5548 if (! TREE_PUBLIC (decl))
5551 if (pubname_table_in_use == pubname_table_allocated)
5553 pubname_table_allocated += PUBNAME_TABLE_INCREMENT;
5554 pubname_table = (pubname_ref) xrealloc
5555 (pubname_table, pubname_table_allocated * sizeof (pubname_entry));
5558 p = &pubname_table[pubname_table_in_use++];
5561 p->name = xstrdup (dwarf2_name (decl, 1));
5564 /* Output the public names table used to speed up access to externally
5565 visible names. For now, only generate entries for externally
5566 visible procedures. */
5571 register unsigned i;
5572 register unsigned long pubnames_length = size_of_pubnames ();
5574 ASM_OUTPUT_DWARF_DATA (asm_out_file, pubnames_length);
5577 fprintf (asm_out_file, "\t%s Length of Public Names Info.",
5580 fputc ('\n', asm_out_file);
5581 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, DWARF_VERSION);
5584 fprintf (asm_out_file, "\t%s DWARF Version", ASM_COMMENT_START);
5586 fputc ('\n', asm_out_file);
5587 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, debug_info_section_label);
5589 fprintf (asm_out_file, "\t%s Offset of Compilation Unit Info.",
5592 fputc ('\n', asm_out_file);
5593 ASM_OUTPUT_DWARF_DATA (asm_out_file, next_die_offset);
5595 fprintf (asm_out_file, "\t%s Compilation Unit Length", ASM_COMMENT_START);
5597 fputc ('\n', asm_out_file);
5598 for (i = 0; i < pubname_table_in_use; ++i)
5600 register pubname_ref pub = &pubname_table[i];
5602 ASM_OUTPUT_DWARF_DATA (asm_out_file, pub->die->die_offset);
5604 fprintf (asm_out_file, "\t%s DIE offset", ASM_COMMENT_START);
5606 fputc ('\n', asm_out_file);
5610 ASM_OUTPUT_DWARF_STRING (asm_out_file, pub->name);
5611 fprintf (asm_out_file, "%s external name", ASM_COMMENT_START);
5615 ASM_OUTPUT_ASCII (asm_out_file, pub->name,
5616 (int) strlen (pub->name) + 1);
5619 fputc ('\n', asm_out_file);
5622 ASM_OUTPUT_DWARF_DATA (asm_out_file, 0);
5623 fputc ('\n', asm_out_file);
5626 /* Add a new entry to .debug_aranges if appropriate. */
5629 add_arange (decl, die)
5633 if (! DECL_SECTION_NAME (decl))
5636 if (arange_table_in_use == arange_table_allocated)
5638 arange_table_allocated += ARANGE_TABLE_INCREMENT;
5640 = (arange_ref) xrealloc (arange_table,
5641 arange_table_allocated * sizeof (dw_die_ref));
5644 arange_table[arange_table_in_use++] = die;
5647 /* Output the information that goes into the .debug_aranges table.
5648 Namely, define the beginning and ending address range of the
5649 text section generated for this compilation unit. */
5654 register unsigned i;
5655 register unsigned long aranges_length = size_of_aranges ();
5657 ASM_OUTPUT_DWARF_DATA (asm_out_file, aranges_length);
5659 fprintf (asm_out_file, "\t%s Length of Address Ranges Info.",
5662 fputc ('\n', asm_out_file);
5663 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, DWARF_VERSION);
5665 fprintf (asm_out_file, "\t%s DWARF Version", ASM_COMMENT_START);
5667 fputc ('\n', asm_out_file);
5668 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, debug_info_section_label);
5670 fprintf (asm_out_file, "\t%s Offset of Compilation Unit Info.",
5673 fputc ('\n', asm_out_file);
5674 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, PTR_SIZE);
5676 fprintf (asm_out_file, "\t%s Size of Address", ASM_COMMENT_START);
5678 fputc ('\n', asm_out_file);
5679 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5681 fprintf (asm_out_file, "\t%s Size of Segment Descriptor",
5684 fputc ('\n', asm_out_file);
5685 /* We need to align to twice the pointer size here.
5686 If DWARF_OFFSET_SIZE == 4, then we have emitted 12 bytes, and need 4
5687 bytes of padding to align for either 4 or 8 byte pointers. */
5688 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0);
5689 /* If DWARF_OFFSET_SIZE == 8, then we have emitted 20 bytes, and need 12
5690 bytes of padding to align for 8 byte pointers. We have already emitted
5691 4 bytes of padding, so emit 8 more here. */
5692 if (DWARF_OFFSET_SIZE == 8)
5693 fprintf (asm_out_file, ",0,0");
5696 fprintf (asm_out_file, "\t%s Pad to %d byte boundary",
5697 ASM_COMMENT_START, 2 * PTR_SIZE);
5699 fputc ('\n', asm_out_file);
5700 ASM_OUTPUT_DWARF_ADDR (asm_out_file, text_section_label);
5702 fprintf (asm_out_file, "\t%s Address", ASM_COMMENT_START);
5704 fputc ('\n', asm_out_file);
5705 ASM_OUTPUT_DWARF_ADDR_DELTA (asm_out_file, text_end_label,
5706 text_section_label);
5708 fprintf (asm_out_file, "%s Length", ASM_COMMENT_START);
5710 fputc ('\n', asm_out_file);
5711 for (i = 0; i < arange_table_in_use; ++i)
5713 dw_die_ref a = arange_table[i];
5715 if (a->die_tag == DW_TAG_subprogram)
5716 ASM_OUTPUT_DWARF_ADDR (asm_out_file, get_AT_low_pc (a));
5719 char *name = get_AT_string (a, DW_AT_MIPS_linkage_name);
5721 name = get_AT_string (a, DW_AT_name);
5723 ASM_OUTPUT_DWARF_ADDR (asm_out_file, name);
5727 fprintf (asm_out_file, "\t%s Address", ASM_COMMENT_START);
5729 fputc ('\n', asm_out_file);
5730 if (a->die_tag == DW_TAG_subprogram)
5731 ASM_OUTPUT_DWARF_ADDR_DELTA (asm_out_file, get_AT_hi_pc (a),
5734 ASM_OUTPUT_DWARF_ADDR_DATA (asm_out_file,
5735 get_AT_unsigned (a, DW_AT_byte_size));
5738 fprintf (asm_out_file, "%s Length", ASM_COMMENT_START);
5740 fputc ('\n', asm_out_file);
5743 /* Output the terminator words. */
5744 ASM_OUTPUT_DWARF_ADDR_DATA (asm_out_file, 0);
5745 fputc ('\n', asm_out_file);
5746 ASM_OUTPUT_DWARF_ADDR_DATA (asm_out_file, 0);
5747 fputc ('\n', asm_out_file);
5750 /* Output the source line number correspondence information. This
5751 information goes into the .debug_line section.
5753 If the format of this data changes, then the function size_of_line_info
5754 must also be adjusted the same way. */
5759 char line_label[MAX_ARTIFICIAL_LABEL_BYTES];
5760 char prev_line_label[MAX_ARTIFICIAL_LABEL_BYTES];
5761 register unsigned opc;
5762 register unsigned n_op_args;
5763 register unsigned long ft_index;
5764 register unsigned long lt_index;
5765 register unsigned long current_line;
5766 register long line_offset;
5767 register long line_delta;
5768 register unsigned long current_file;
5769 register unsigned long function;
5771 ASM_OUTPUT_DWARF_DATA (asm_out_file, size_of_line_info ());
5773 fprintf (asm_out_file, "\t%s Length of Source Line Info.",
5776 fputc ('\n', asm_out_file);
5777 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, DWARF_VERSION);
5779 fprintf (asm_out_file, "\t%s DWARF Version", ASM_COMMENT_START);
5781 fputc ('\n', asm_out_file);
5782 ASM_OUTPUT_DWARF_DATA (asm_out_file, size_of_line_prolog ());
5784 fprintf (asm_out_file, "\t%s Prolog Length", ASM_COMMENT_START);
5786 fputc ('\n', asm_out_file);
5787 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DWARF_LINE_MIN_INSTR_LENGTH);
5789 fprintf (asm_out_file, "\t%s Minimum Instruction Length",
5792 fputc ('\n', asm_out_file);
5793 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DWARF_LINE_DEFAULT_IS_STMT_START);
5795 fprintf (asm_out_file, "\t%s Default is_stmt_start flag",
5798 fputc ('\n', asm_out_file);
5799 fprintf (asm_out_file, "\t%s\t%d", ASM_BYTE_OP, DWARF_LINE_BASE);
5801 fprintf (asm_out_file, "\t%s Line Base Value (Special Opcodes)",
5804 fputc ('\n', asm_out_file);
5805 fprintf (asm_out_file, "\t%s\t%u", ASM_BYTE_OP, DWARF_LINE_RANGE);
5807 fprintf (asm_out_file, "\t%s Line Range Value (Special Opcodes)",
5810 fputc ('\n', asm_out_file);
5811 fprintf (asm_out_file, "\t%s\t%u", ASM_BYTE_OP, DWARF_LINE_OPCODE_BASE);
5813 fprintf (asm_out_file, "\t%s Special Opcode Base", ASM_COMMENT_START);
5815 fputc ('\n', asm_out_file);
5816 for (opc = 1; opc < DWARF_LINE_OPCODE_BASE; ++opc)
5820 case DW_LNS_advance_pc:
5821 case DW_LNS_advance_line:
5822 case DW_LNS_set_file:
5823 case DW_LNS_set_column:
5824 case DW_LNS_fixed_advance_pc:
5831 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, n_op_args);
5833 fprintf (asm_out_file, "\t%s opcode: 0x%x has %d args",
5834 ASM_COMMENT_START, opc, n_op_args);
5835 fputc ('\n', asm_out_file);
5839 fprintf (asm_out_file, "%s Include Directory Table\n", ASM_COMMENT_START);
5841 /* Include directory table is empty, at present */
5842 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5843 fputc ('\n', asm_out_file);
5845 fprintf (asm_out_file, "%s File Name Table\n", ASM_COMMENT_START);
5847 for (ft_index = 1; ft_index < file_table_in_use; ++ft_index)
5851 ASM_OUTPUT_DWARF_STRING (asm_out_file, file_table[ft_index]);
5852 fprintf (asm_out_file, "%s File Entry: 0x%lx",
5853 ASM_COMMENT_START, ft_index);
5857 ASM_OUTPUT_ASCII (asm_out_file,
5858 file_table[ft_index],
5859 (int) strlen (file_table[ft_index]) + 1);
5862 fputc ('\n', asm_out_file);
5864 /* Include directory index */
5866 fputc ('\n', asm_out_file);
5868 /* Modification time */
5870 fputc ('\n', asm_out_file);
5872 /* File length in bytes */
5874 fputc ('\n', asm_out_file);
5877 /* Terminate the file name table */
5878 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5879 fputc ('\n', asm_out_file);
5881 /* We used to set the address register to the first location in the text
5882 section here, but that didn't accomplish anything since we already
5883 have a line note for the opening brace of the first function. */
5885 /* Generate the line number to PC correspondence table, encoded as
5886 a series of state machine operations. */
5889 strcpy (prev_line_label, text_section_label);
5890 for (lt_index = 1; lt_index < line_info_table_in_use; ++lt_index)
5892 register dw_line_info_ref line_info = &line_info_table[lt_index];
5894 /* Don't emit anything for redundant notes. Just updating the
5895 address doesn't accomplish anything, because we already assume
5896 that anything after the last address is this line. */
5897 if (line_info->dw_line_num == current_line
5898 && line_info->dw_file_num == current_file)
5901 /* Emit debug info for the address of the current line, choosing
5902 the encoding that uses the least amount of space. */
5903 /* ??? Unfortunately, we have little choice here currently, and must
5904 always use the most general form. Gcc does not know the address
5905 delta itself, so we can't use DW_LNS_advance_pc. There are no known
5906 dwarf2 aware assemblers at this time, so we can't use any special
5907 pseudo ops that would allow the assembler to optimally encode this for
5908 us. Many ports do have length attributes which will give an upper
5909 bound on the address range. We could perhaps use length attributes
5910 to determine when it is safe to use DW_LNS_fixed_advance_pc. */
5911 ASM_GENERATE_INTERNAL_LABEL (line_label, LINE_CODE_LABEL, lt_index);
5914 /* This can handle deltas up to 0xffff. This takes 3 bytes. */
5915 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc);
5917 fprintf (asm_out_file, "\t%s DW_LNS_fixed_advance_pc",
5920 fputc ('\n', asm_out_file);
5921 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, line_label, prev_line_label);
5922 fputc ('\n', asm_out_file);
5926 /* This can handle any delta. This takes 4+PTR_SIZE bytes. */
5927 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5929 fprintf (asm_out_file, "\t%s DW_LNE_set_address",
5931 fputc ('\n', asm_out_file);
5932 output_uleb128 (1 + PTR_SIZE);
5933 fputc ('\n', asm_out_file);
5934 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address);
5935 fputc ('\n', asm_out_file);
5936 ASM_OUTPUT_DWARF_ADDR (asm_out_file, line_label);
5937 fputc ('\n', asm_out_file);
5939 strcpy (prev_line_label, line_label);
5941 /* Emit debug info for the source file of the current line, if
5942 different from the previous line. */
5943 if (line_info->dw_file_num != current_file)
5945 current_file = line_info->dw_file_num;
5946 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_set_file);
5948 fprintf (asm_out_file, "\t%s DW_LNS_set_file", ASM_COMMENT_START);
5950 fputc ('\n', asm_out_file);
5951 output_uleb128 (current_file);
5953 fprintf (asm_out_file, " (\"%s\")", file_table[current_file]);
5955 fputc ('\n', asm_out_file);
5958 /* Emit debug info for the current line number, choosing the encoding
5959 that uses the least amount of space. */
5960 if (line_info->dw_line_num != current_line)
5962 line_offset = line_info->dw_line_num - current_line;
5963 line_delta = line_offset - DWARF_LINE_BASE;
5964 current_line = line_info->dw_line_num;
5965 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
5967 /* This can handle deltas from -10 to 234, using the current
5968 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE. This
5970 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
5971 DWARF_LINE_OPCODE_BASE + line_delta);
5973 fprintf (asm_out_file,
5974 "\t%s line %ld", ASM_COMMENT_START, current_line);
5976 fputc ('\n', asm_out_file);
5980 /* This can handle any delta. This takes at least 4 bytes,
5981 depending on the value being encoded. */
5982 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_advance_line);
5984 fprintf (asm_out_file, "\t%s advance to line %ld",
5985 ASM_COMMENT_START, current_line);
5987 fputc ('\n', asm_out_file);
5988 output_sleb128 (line_offset);
5989 fputc ('\n', asm_out_file);
5990 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_copy);
5992 fprintf (asm_out_file, "\t%s DW_LNS_copy", ASM_COMMENT_START);
5993 fputc ('\n', asm_out_file);
5998 /* We still need to start a new row, so output a copy insn. */
5999 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_copy);
6001 fprintf (asm_out_file, "\t%s DW_LNS_copy", ASM_COMMENT_START);
6002 fputc ('\n', asm_out_file);
6006 /* Emit debug info for the address of the end of the function. */
6009 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc);
6011 fprintf (asm_out_file, "\t%s DW_LNS_fixed_advance_pc",
6014 fputc ('\n', asm_out_file);
6015 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, text_end_label, prev_line_label);
6016 fputc ('\n', asm_out_file);
6020 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
6022 fprintf (asm_out_file, "\t%s DW_LNE_set_address", ASM_COMMENT_START);
6023 fputc ('\n', asm_out_file);
6024 output_uleb128 (1 + PTR_SIZE);
6025 fputc ('\n', asm_out_file);
6026 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address);
6027 fputc ('\n', asm_out_file);
6028 ASM_OUTPUT_DWARF_ADDR (asm_out_file, text_end_label);
6029 fputc ('\n', asm_out_file);
6032 /* Output the marker for the end of the line number info. */
6033 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
6035 fprintf (asm_out_file, "\t%s DW_LNE_end_sequence", ASM_COMMENT_START);
6037 fputc ('\n', asm_out_file);
6039 fputc ('\n', asm_out_file);
6040 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_end_sequence);
6041 fputc ('\n', asm_out_file);
6046 for (lt_index = 0; lt_index < separate_line_info_table_in_use; )
6048 register dw_separate_line_info_ref line_info
6049 = &separate_line_info_table[lt_index];
6051 /* Don't emit anything for redundant notes. */
6052 if (line_info->dw_line_num == current_line
6053 && line_info->dw_file_num == current_file
6054 && line_info->function == function)
6057 /* Emit debug info for the address of the current line. If this is
6058 a new function, or the first line of a function, then we need
6059 to handle it differently. */
6060 ASM_GENERATE_INTERNAL_LABEL (line_label, SEPARATE_LINE_CODE_LABEL,
6062 if (function != line_info->function)
6064 function = line_info->function;
6066 /* Set the address register to the first line in the function */
6067 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
6069 fprintf (asm_out_file, "\t%s DW_LNE_set_address",
6072 fputc ('\n', asm_out_file);
6073 output_uleb128 (1 + PTR_SIZE);
6074 fputc ('\n', asm_out_file);
6075 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address);
6076 fputc ('\n', asm_out_file);
6077 ASM_OUTPUT_DWARF_ADDR (asm_out_file, line_label);
6078 fputc ('\n', asm_out_file);
6082 /* ??? See the DW_LNS_advance_pc comment above. */
6085 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc);
6087 fprintf (asm_out_file, "\t%s DW_LNS_fixed_advance_pc",
6090 fputc ('\n', asm_out_file);
6091 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, line_label,
6093 fputc ('\n', asm_out_file);
6097 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
6099 fprintf (asm_out_file, "\t%s DW_LNE_set_address",
6101 fputc ('\n', asm_out_file);
6102 output_uleb128 (1 + PTR_SIZE);
6103 fputc ('\n', asm_out_file);
6104 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address);
6105 fputc ('\n', asm_out_file);
6106 ASM_OUTPUT_DWARF_ADDR (asm_out_file, line_label);
6107 fputc ('\n', asm_out_file);
6110 strcpy (prev_line_label, line_label);
6112 /* Emit debug info for the source file of the current line, if
6113 different from the previous line. */
6114 if (line_info->dw_file_num != current_file)
6116 current_file = line_info->dw_file_num;
6117 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_set_file);
6119 fprintf (asm_out_file, "\t%s DW_LNS_set_file", ASM_COMMENT_START);
6121 fputc ('\n', asm_out_file);
6122 output_uleb128 (current_file);
6124 fprintf (asm_out_file, " (\"%s\")", file_table[current_file]);
6126 fputc ('\n', asm_out_file);
6129 /* Emit debug info for the current line number, choosing the encoding
6130 that uses the least amount of space. */
6131 if (line_info->dw_line_num != current_line)
6133 line_offset = line_info->dw_line_num - current_line;
6134 line_delta = line_offset - DWARF_LINE_BASE;
6135 current_line = line_info->dw_line_num;
6136 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
6138 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
6139 DWARF_LINE_OPCODE_BASE + line_delta);
6141 fprintf (asm_out_file,
6142 "\t%s line %ld", ASM_COMMENT_START, current_line);
6144 fputc ('\n', asm_out_file);
6148 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_advance_line);
6150 fprintf (asm_out_file, "\t%s advance to line %ld",
6151 ASM_COMMENT_START, current_line);
6153 fputc ('\n', asm_out_file);
6154 output_sleb128 (line_offset);
6155 fputc ('\n', asm_out_file);
6156 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_copy);
6158 fprintf (asm_out_file, "\t%s DW_LNS_copy", ASM_COMMENT_START);
6159 fputc ('\n', asm_out_file);
6164 /* We still need to start a new row, so output a copy insn. */
6165 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_copy);
6167 fprintf (asm_out_file, "\t%s DW_LNS_copy", ASM_COMMENT_START);
6168 fputc ('\n', asm_out_file);
6174 /* If we're done with a function, end its sequence. */
6175 if (lt_index == separate_line_info_table_in_use
6176 || separate_line_info_table[lt_index].function != function)
6181 /* Emit debug info for the address of the end of the function. */
6182 ASM_GENERATE_INTERNAL_LABEL (line_label, FUNC_END_LABEL, function);
6185 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc);
6187 fprintf (asm_out_file, "\t%s DW_LNS_fixed_advance_pc",
6190 fputc ('\n', asm_out_file);
6191 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, line_label,
6193 fputc ('\n', asm_out_file);
6197 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
6199 fprintf (asm_out_file, "\t%s DW_LNE_set_address",
6201 fputc ('\n', asm_out_file);
6202 output_uleb128 (1 + PTR_SIZE);
6203 fputc ('\n', asm_out_file);
6204 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address);
6205 fputc ('\n', asm_out_file);
6206 ASM_OUTPUT_DWARF_ADDR (asm_out_file, line_label);
6207 fputc ('\n', asm_out_file);
6210 /* Output the marker for the end of this sequence. */
6211 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
6213 fprintf (asm_out_file, "\t%s DW_LNE_end_sequence",
6216 fputc ('\n', asm_out_file);
6218 fputc ('\n', asm_out_file);
6219 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_end_sequence);
6220 fputc ('\n', asm_out_file);
6225 /* Given a pointer to a BLOCK node return non-zero if (and only if) the node
6226 in question represents the outermost pair of curly braces (i.e. the "body
6227 block") of a function or method.
6229 For any BLOCK node representing a "body block" of a function or method, the
6230 BLOCK_SUPERCONTEXT of the node will point to another BLOCK node which
6231 represents the outermost (function) scope for the function or method (i.e.
6232 the one which includes the formal parameters). The BLOCK_SUPERCONTEXT of
6233 *that* node in turn will point to the relevant FUNCTION_DECL node. */
6236 is_body_block (stmt)
6239 if (TREE_CODE (stmt) == BLOCK)
6241 register tree parent = BLOCK_SUPERCONTEXT (stmt);
6243 if (TREE_CODE (parent) == BLOCK)
6245 register tree grandparent = BLOCK_SUPERCONTEXT (parent);
6247 if (TREE_CODE (grandparent) == FUNCTION_DECL)
6255 /* Given a pointer to a tree node for some base type, return a pointer to
6256 a DIE that describes the given type.
6258 This routine must only be called for GCC type nodes that correspond to
6259 Dwarf base (fundamental) types. */
6262 base_type_die (type)
6265 register dw_die_ref base_type_result;
6266 register char *type_name;
6267 register enum dwarf_type encoding;
6268 register tree name = TYPE_NAME (type);
6270 if (TREE_CODE (type) == ERROR_MARK
6271 || TREE_CODE (type) == VOID_TYPE)
6274 if (TREE_CODE (name) == TYPE_DECL)
6275 name = DECL_NAME (name);
6276 type_name = IDENTIFIER_POINTER (name);
6278 switch (TREE_CODE (type))
6281 /* Carefully distinguish the C character types, without messing
6282 up if the language is not C. Note that we check only for the names
6283 that contain spaces; other names might occur by coincidence in other
6285 if (! (TYPE_PRECISION (type) == CHAR_TYPE_SIZE
6286 && (type == char_type_node
6287 || ! strcmp (type_name, "signed char")
6288 || ! strcmp (type_name, "unsigned char"))))
6290 if (TREE_UNSIGNED (type))
6291 encoding = DW_ATE_unsigned;
6293 encoding = DW_ATE_signed;
6296 /* else fall through */
6299 /* GNU Pascal/Ada CHAR type. Not used in C. */
6300 if (TREE_UNSIGNED (type))
6301 encoding = DW_ATE_unsigned_char;
6303 encoding = DW_ATE_signed_char;
6307 encoding = DW_ATE_float;
6311 encoding = DW_ATE_complex_float;
6315 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */
6316 encoding = DW_ATE_boolean;
6320 abort (); /* No other TREE_CODEs are Dwarf fundamental types. */
6323 base_type_result = new_die (DW_TAG_base_type, comp_unit_die);
6324 add_AT_string (base_type_result, DW_AT_name, type_name);
6325 add_AT_unsigned (base_type_result, DW_AT_byte_size,
6326 int_size_in_bytes (type));
6327 add_AT_unsigned (base_type_result, DW_AT_encoding, encoding);
6329 return base_type_result;
6332 /* Given a pointer to an arbitrary ..._TYPE tree node, return a pointer to
6333 the Dwarf "root" type for the given input type. The Dwarf "root" type of
6334 a given type is generally the same as the given type, except that if the
6335 given type is a pointer or reference type, then the root type of the given
6336 type is the root type of the "basis" type for the pointer or reference
6337 type. (This definition of the "root" type is recursive.) Also, the root
6338 type of a `const' qualified type or a `volatile' qualified type is the
6339 root type of the given type without the qualifiers. */
6345 if (TREE_CODE (type) == ERROR_MARK)
6346 return error_mark_node;
6348 switch (TREE_CODE (type))
6351 return error_mark_node;
6354 case REFERENCE_TYPE:
6355 return type_main_variant (root_type (TREE_TYPE (type)));
6358 return type_main_variant (type);
6362 /* Given a pointer to an arbitrary ..._TYPE tree node, return non-zero if the
6363 given input type is a Dwarf "fundamental" type. Otherwise return null. */
6369 switch (TREE_CODE (type))
6384 case QUAL_UNION_TYPE:
6389 case REFERENCE_TYPE:
6402 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
6403 entry that chains various modifiers in front of the given type. */
6406 modified_type_die (type, is_const_type, is_volatile_type, context_die)
6408 register int is_const_type;
6409 register int is_volatile_type;
6410 register dw_die_ref context_die;
6412 register enum tree_code code = TREE_CODE (type);
6413 register dw_die_ref mod_type_die = NULL;
6414 register dw_die_ref sub_die = NULL;
6415 register tree item_type = NULL;
6417 if (code != ERROR_MARK)
6419 type = build_type_variant (type, is_const_type, is_volatile_type);
6421 mod_type_die = lookup_type_die (type);
6423 return mod_type_die;
6425 /* Handle C typedef types. */
6426 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
6427 && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
6429 tree dtype = TREE_TYPE (TYPE_NAME (type));
6432 /* For a named type, use the typedef. */
6433 gen_type_die (type, context_die);
6434 mod_type_die = lookup_type_die (type);
6437 else if (is_const_type < TYPE_READONLY (dtype)
6438 || is_volatile_type < TYPE_VOLATILE (dtype))
6439 /* cv-unqualified version of named type. Just use the unnamed
6440 type to which it refers. */
6442 = modified_type_die (DECL_ORIGINAL_TYPE (TYPE_NAME (type)),
6443 is_const_type, is_volatile_type,
6445 /* Else cv-qualified version of named type; fall through. */
6450 else if (is_const_type)
6452 mod_type_die = new_die (DW_TAG_const_type, comp_unit_die);
6453 sub_die = modified_type_die (type, 0, is_volatile_type, context_die);
6455 else if (is_volatile_type)
6457 mod_type_die = new_die (DW_TAG_volatile_type, comp_unit_die);
6458 sub_die = modified_type_die (type, 0, 0, context_die);
6460 else if (code == POINTER_TYPE)
6462 mod_type_die = new_die (DW_TAG_pointer_type, comp_unit_die);
6463 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
6465 add_AT_unsigned (mod_type_die, DW_AT_address_class, 0);
6467 item_type = TREE_TYPE (type);
6469 else if (code == REFERENCE_TYPE)
6471 mod_type_die = new_die (DW_TAG_reference_type, comp_unit_die);
6472 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
6474 add_AT_unsigned (mod_type_die, DW_AT_address_class, 0);
6476 item_type = TREE_TYPE (type);
6478 else if (is_base_type (type))
6479 mod_type_die = base_type_die (type);
6482 gen_type_die (type, context_die);
6484 /* We have to get the type_main_variant here (and pass that to the
6485 `lookup_type_die' routine) because the ..._TYPE node we have
6486 might simply be a *copy* of some original type node (where the
6487 copy was created to help us keep track of typedef names) and
6488 that copy might have a different TYPE_UID from the original
6490 mod_type_die = lookup_type_die (type_main_variant (type));
6491 if (mod_type_die == NULL)
6496 equate_type_number_to_die (type, mod_type_die);
6498 /* We must do this after the equate_type_number_to_die call, in case
6499 this is a recursive type. This ensures that the modified_type_die
6500 recursion will terminate even if the type is recursive. Recursive
6501 types are possible in Ada. */
6502 sub_die = modified_type_die (item_type,
6503 TYPE_READONLY (item_type),
6504 TYPE_VOLATILE (item_type),
6507 if (sub_die != NULL)
6508 add_AT_die_ref (mod_type_die, DW_AT_type, sub_die);
6510 return mod_type_die;
6513 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
6514 an enumerated type. */
6520 return TREE_CODE (type) == ENUMERAL_TYPE;
6523 /* Return a location descriptor that designates a machine register. */
6525 static dw_loc_descr_ref
6526 reg_loc_descriptor (rtl)
6529 register dw_loc_descr_ref loc_result = NULL;
6530 register unsigned reg = reg_number (rtl);
6533 loc_result = new_loc_descr (DW_OP_reg0 + reg, 0, 0);
6535 loc_result = new_loc_descr (DW_OP_regx, reg, 0);
6540 /* Return a location descriptor that designates a base+offset location. */
6542 static dw_loc_descr_ref
6543 based_loc_descr (reg, offset)
6547 register dw_loc_descr_ref loc_result;
6548 /* For the "frame base", we use the frame pointer or stack pointer
6549 registers, since the RTL for local variables is relative to one of
6551 register unsigned fp_reg = DBX_REGISTER_NUMBER (frame_pointer_needed
6552 ? HARD_FRAME_POINTER_REGNUM
6553 : STACK_POINTER_REGNUM);
6556 loc_result = new_loc_descr (DW_OP_fbreg, offset, 0);
6558 loc_result = new_loc_descr (DW_OP_breg0 + reg, offset, 0);
6560 loc_result = new_loc_descr (DW_OP_bregx, reg, offset);
6565 /* Return true if this RTL expression describes a base+offset calculation. */
6571 return (GET_CODE (rtl) == PLUS
6572 && ((GET_CODE (XEXP (rtl, 0)) == REG
6573 && GET_CODE (XEXP (rtl, 1)) == CONST_INT)));
6576 /* The following routine converts the RTL for a variable or parameter
6577 (resident in memory) into an equivalent Dwarf representation of a
6578 mechanism for getting the address of that same variable onto the top of a
6579 hypothetical "address evaluation" stack.
6581 When creating memory location descriptors, we are effectively transforming
6582 the RTL for a memory-resident object into its Dwarf postfix expression
6583 equivalent. This routine recursively descends an RTL tree, turning
6584 it into Dwarf postfix code as it goes.
6586 MODE is the mode of the memory reference, needed to handle some
6587 autoincrement addressing modes. */
6589 static dw_loc_descr_ref
6590 mem_loc_descriptor (rtl, mode)
6592 enum machine_mode mode;
6594 dw_loc_descr_ref mem_loc_result = NULL;
6595 /* Note that for a dynamically sized array, the location we will generate a
6596 description of here will be the lowest numbered location which is
6597 actually within the array. That's *not* necessarily the same as the
6598 zeroth element of the array. */
6600 switch (GET_CODE (rtl))
6604 /* POST_INC and POST_DEC can be handled just like a SUBREG. So we
6605 just fall into the SUBREG code. */
6607 /* ... fall through ... */
6610 /* The case of a subreg may arise when we have a local (register)
6611 variable or a formal (register) parameter which doesn't quite fill
6612 up an entire register. For now, just assume that it is
6613 legitimate to make the Dwarf info refer to the whole register which
6614 contains the given subreg. */
6615 rtl = XEXP (rtl, 0);
6617 /* ... fall through ... */
6620 /* Whenever a register number forms a part of the description of the
6621 method for calculating the (dynamic) address of a memory resident
6622 object, DWARF rules require the register number be referred to as
6623 a "base register". This distinction is not based in any way upon
6624 what category of register the hardware believes the given register
6625 belongs to. This is strictly DWARF terminology we're dealing with
6626 here. Note that in cases where the location of a memory-resident
6627 data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
6628 OP_CONST (0)) the actual DWARF location descriptor that we generate
6629 may just be OP_BASEREG (basereg). This may look deceptively like
6630 the object in question was allocated to a register (rather than in
6631 memory) so DWARF consumers need to be aware of the subtle
6632 distinction between OP_REG and OP_BASEREG. */
6633 mem_loc_result = based_loc_descr (reg_number (rtl), 0);
6637 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), mode);
6638 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_deref, 0, 0));
6642 /* Some ports can transform a symbol ref into a label ref, because
6643 the symbol ref is too far away and has to be dumped into a constant
6647 mem_loc_result = new_loc_descr (DW_OP_addr, 0, 0);
6648 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_addr;
6649 mem_loc_result->dw_loc_oprnd1.v.val_addr = addr_to_string (rtl);
6654 /* Turn these into a PLUS expression and fall into the PLUS code
6656 rtl = gen_rtx_PLUS (word_mode, XEXP (rtl, 0),
6657 GEN_INT (GET_CODE (rtl) == PRE_INC
6658 ? GET_MODE_UNIT_SIZE (mode)
6659 : - GET_MODE_UNIT_SIZE (mode)));
6661 /* ... fall through ... */
6664 if (is_based_loc (rtl))
6665 mem_loc_result = based_loc_descr (reg_number (XEXP (rtl, 0)),
6666 INTVAL (XEXP (rtl, 1)));
6669 add_loc_descr (&mem_loc_result, mem_loc_descriptor (XEXP (rtl, 0),
6671 add_loc_descr (&mem_loc_result, mem_loc_descriptor (XEXP (rtl, 1),
6673 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_plus, 0, 0));
6678 /* If a pseudo-reg is optimized away, it is possible for it to
6679 be replaced with a MEM containing a multiply. */
6680 add_loc_descr (&mem_loc_result, mem_loc_descriptor (XEXP (rtl, 0), mode));
6681 add_loc_descr (&mem_loc_result, mem_loc_descriptor (XEXP (rtl, 1), mode));
6682 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_mul, 0, 0));
6686 mem_loc_result = new_loc_descr (DW_OP_constu, INTVAL (rtl), 0);
6693 return mem_loc_result;
6696 /* Return a descriptor that describes the concatenation of two locations.
6697 This is typically a complex variable. */
6699 static dw_loc_descr_ref
6700 concat_loc_descriptor (x0, x1)
6701 register rtx x0, x1;
6703 dw_loc_descr_ref cc_loc_result = NULL;
6705 if (!is_pseudo_reg (x0)
6706 && (GET_CODE (x0) != MEM || !is_pseudo_reg (XEXP (x0, 0))))
6707 add_loc_descr (&cc_loc_result, loc_descriptor (x0));
6708 add_loc_descr (&cc_loc_result,
6709 new_loc_descr (DW_OP_piece, GET_MODE_SIZE (GET_MODE (x0)), 0));
6711 if (!is_pseudo_reg (x1)
6712 && (GET_CODE (x1) != MEM || !is_pseudo_reg (XEXP (x1, 0))))
6713 add_loc_descr (&cc_loc_result, loc_descriptor (x1));
6714 add_loc_descr (&cc_loc_result,
6715 new_loc_descr (DW_OP_piece, GET_MODE_SIZE (GET_MODE (x1)), 0));
6717 return cc_loc_result;
6720 /* Output a proper Dwarf location descriptor for a variable or parameter
6721 which is either allocated in a register or in a memory location. For a
6722 register, we just generate an OP_REG and the register number. For a
6723 memory location we provide a Dwarf postfix expression describing how to
6724 generate the (dynamic) address of the object onto the address stack. */
6726 static dw_loc_descr_ref
6727 loc_descriptor (rtl)
6730 dw_loc_descr_ref loc_result = NULL;
6731 switch (GET_CODE (rtl))
6734 /* The case of a subreg may arise when we have a local (register)
6735 variable or a formal (register) parameter which doesn't quite fill
6736 up an entire register. For now, just assume that it is
6737 legitimate to make the Dwarf info refer to the whole register which
6738 contains the given subreg. */
6739 rtl = XEXP (rtl, 0);
6741 /* ... fall through ... */
6744 loc_result = reg_loc_descriptor (rtl);
6748 loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl));
6752 loc_result = concat_loc_descriptor (XEXP (rtl, 0), XEXP (rtl, 1));
6762 /* Given an unsigned value, round it up to the lowest multiple of `boundary'
6763 which is not less than the value itself. */
6765 static inline unsigned
6766 ceiling (value, boundary)
6767 register unsigned value;
6768 register unsigned boundary;
6770 return (((value + boundary - 1) / boundary) * boundary);
6773 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
6774 pointer to the declared type for the relevant field variable, or return
6775 `integer_type_node' if the given node turns out to be an
6784 if (TREE_CODE (decl) == ERROR_MARK)
6785 return integer_type_node;
6787 type = DECL_BIT_FIELD_TYPE (decl);
6788 if (type == NULL_TREE)
6789 type = TREE_TYPE (decl);
6794 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
6795 node, return the alignment in bits for the type, or else return
6796 BITS_PER_WORD if the node actually turns out to be an
6799 static inline unsigned
6800 simple_type_align_in_bits (type)
6803 return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD;
6806 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
6807 node, return the size in bits for the type if it is a constant, or else
6808 return the alignment for the type if the type's size is not constant, or
6809 else return BITS_PER_WORD if the type actually turns out to be an
6812 static inline unsigned
6813 simple_type_size_in_bits (type)
6816 if (TREE_CODE (type) == ERROR_MARK)
6817 return BITS_PER_WORD;
6820 register tree type_size_tree = TYPE_SIZE (type);
6822 if (TREE_CODE (type_size_tree) != INTEGER_CST)
6823 return TYPE_ALIGN (type);
6825 return (unsigned) TREE_INT_CST_LOW (type_size_tree);
6829 /* Given a pointer to what is assumed to be a FIELD_DECL node, compute and
6830 return the byte offset of the lowest addressed byte of the "containing
6831 object" for the given FIELD_DECL, or return 0 if we are unable to
6832 determine what that offset is, either because the argument turns out to
6833 be a pointer to an ERROR_MARK node, or because the offset is actually
6834 variable. (We can't handle the latter case just yet). */
6837 field_byte_offset (decl)
6840 register unsigned type_align_in_bytes;
6841 register unsigned type_align_in_bits;
6842 register unsigned type_size_in_bits;
6843 register unsigned object_offset_in_align_units;
6844 register unsigned object_offset_in_bits;
6845 register unsigned object_offset_in_bytes;
6847 register tree bitpos_tree;
6848 register tree field_size_tree;
6849 register unsigned bitpos_int;
6850 register unsigned deepest_bitpos;
6851 register unsigned field_size_in_bits;
6853 if (TREE_CODE (decl) == ERROR_MARK)
6856 if (TREE_CODE (decl) != FIELD_DECL)
6859 type = field_type (decl);
6861 bitpos_tree = DECL_FIELD_BITPOS (decl);
6862 field_size_tree = DECL_SIZE (decl);
6864 /* We cannot yet cope with fields whose positions or sizes are variable, so
6865 for now, when we see such things, we simply return 0. Someday, we may
6866 be able to handle such cases, but it will be damn difficult. */
6867 if (TREE_CODE (bitpos_tree) != INTEGER_CST)
6869 bitpos_int = (unsigned) TREE_INT_CST_LOW (bitpos_tree);
6871 if (TREE_CODE (field_size_tree) != INTEGER_CST)
6874 field_size_in_bits = (unsigned) TREE_INT_CST_LOW (field_size_tree);
6875 type_size_in_bits = simple_type_size_in_bits (type);
6876 type_align_in_bits = simple_type_align_in_bits (type);
6877 type_align_in_bytes = type_align_in_bits / BITS_PER_UNIT;
6879 /* Note that the GCC front-end doesn't make any attempt to keep track of
6880 the starting bit offset (relative to the start of the containing
6881 structure type) of the hypothetical "containing object" for a bit-
6882 field. Thus, when computing the byte offset value for the start of the
6883 "containing object" of a bit-field, we must deduce this information on
6884 our own. This can be rather tricky to do in some cases. For example,
6885 handling the following structure type definition when compiling for an
6886 i386/i486 target (which only aligns long long's to 32-bit boundaries)
6889 struct S { int field1; long long field2:31; };
6891 Fortunately, there is a simple rule-of-thumb which can be
6892 used in such cases. When compiling for an i386/i486, GCC will allocate
6893 8 bytes for the structure shown above. It decides to do this based upon
6894 one simple rule for bit-field allocation. Quite simply, GCC allocates
6895 each "containing object" for each bit-field at the first (i.e. lowest
6896 addressed) legitimate alignment boundary (based upon the required
6897 minimum alignment for the declared type of the field) which it can
6898 possibly use, subject to the condition that there is still enough
6899 available space remaining in the containing object (when allocated at
6900 the selected point) to fully accommodate all of the bits of the
6901 bit-field itself. This simple rule makes it obvious why GCC allocates
6902 8 bytes for each object of the structure type shown above. When looking
6903 for a place to allocate the "containing object" for `field2', the
6904 compiler simply tries to allocate a 64-bit "containing object" at each
6905 successive 32-bit boundary (starting at zero) until it finds a place to
6906 allocate that 64- bit field such that at least 31 contiguous (and
6907 previously unallocated) bits remain within that selected 64 bit field.
6908 (As it turns out, for the example above, the compiler finds that it is
6909 OK to allocate the "containing object" 64-bit field at bit-offset zero
6910 within the structure type.) Here we attempt to work backwards from the
6911 limited set of facts we're given, and we try to deduce from those facts,
6912 where GCC must have believed that the containing object started (within
6913 the structure type). The value we deduce is then used (by the callers of
6914 this routine) to generate DW_AT_location and DW_AT_bit_offset attributes
6915 for fields (both bit-fields and, in the case of DW_AT_location, regular
6918 /* Figure out the bit-distance from the start of the structure to the
6919 "deepest" bit of the bit-field. */
6920 deepest_bitpos = bitpos_int + field_size_in_bits;
6922 /* This is the tricky part. Use some fancy footwork to deduce where the
6923 lowest addressed bit of the containing object must be. */
6924 object_offset_in_bits
6925 = ceiling (deepest_bitpos, type_align_in_bits) - type_size_in_bits;
6927 /* Compute the offset of the containing object in "alignment units". */
6928 object_offset_in_align_units = object_offset_in_bits / type_align_in_bits;
6930 /* Compute the offset of the containing object in bytes. */
6931 object_offset_in_bytes = object_offset_in_align_units * type_align_in_bytes;
6933 return object_offset_in_bytes;
6936 /* The following routines define various Dwarf attributes and any data
6937 associated with them. */
6939 /* Add a location description attribute value to a DIE.
6941 This emits location attributes suitable for whole variables and
6942 whole parameters. Note that the location attributes for struct fields are
6943 generated by the routine `data_member_location_attribute' below. */
6946 add_AT_location_description (die, attr_kind, rtl)
6948 enum dwarf_attribute attr_kind;
6951 /* Handle a special case. If we are about to output a location descriptor
6952 for a variable or parameter which has been optimized out of existence,
6953 don't do that. A variable which has been optimized out
6954 of existence will have a DECL_RTL value which denotes a pseudo-reg.
6955 Currently, in some rare cases, variables can have DECL_RTL values which
6956 look like (MEM (REG pseudo-reg#)). These cases are due to bugs
6957 elsewhere in the compiler. We treat such cases as if the variable(s) in
6958 question had been optimized out of existence. */
6960 if (is_pseudo_reg (rtl)
6961 || (GET_CODE (rtl) == MEM
6962 && is_pseudo_reg (XEXP (rtl, 0)))
6963 || (GET_CODE (rtl) == CONCAT
6964 && is_pseudo_reg (XEXP (rtl, 0))
6965 && is_pseudo_reg (XEXP (rtl, 1))))
6968 add_AT_loc (die, attr_kind, loc_descriptor (rtl));
6971 /* Attach the specialized form of location attribute used for data
6972 members of struct and union types. In the special case of a
6973 FIELD_DECL node which represents a bit-field, the "offset" part
6974 of this special location descriptor must indicate the distance
6975 in bytes from the lowest-addressed byte of the containing struct
6976 or union type to the lowest-addressed byte of the "containing
6977 object" for the bit-field. (See the `field_byte_offset' function
6978 above).. For any given bit-field, the "containing object" is a
6979 hypothetical object (of some integral or enum type) within which
6980 the given bit-field lives. The type of this hypothetical
6981 "containing object" is always the same as the declared type of
6982 the individual bit-field itself (for GCC anyway... the DWARF
6983 spec doesn't actually mandate this). Note that it is the size
6984 (in bytes) of the hypothetical "containing object" which will
6985 be given in the DW_AT_byte_size attribute for this bit-field.
6986 (See the `byte_size_attribute' function below.) It is also used
6987 when calculating the value of the DW_AT_bit_offset attribute.
6988 (See the `bit_offset_attribute' function below). */
6991 add_data_member_location_attribute (die, decl)
6992 register dw_die_ref die;
6995 register unsigned long offset;
6996 register dw_loc_descr_ref loc_descr;
6997 register enum dwarf_location_atom op;
6999 if (TREE_CODE (decl) == TREE_VEC)
7000 offset = TREE_INT_CST_LOW (BINFO_OFFSET (decl));
7002 offset = field_byte_offset (decl);
7004 /* The DWARF2 standard says that we should assume that the structure address
7005 is already on the stack, so we can specify a structure field address
7006 by using DW_OP_plus_uconst. */
7008 #ifdef MIPS_DEBUGGING_INFO
7009 /* ??? The SGI dwarf reader does not handle the DW_OP_plus_uconst operator
7010 correctly. It works only if we leave the offset on the stack. */
7013 op = DW_OP_plus_uconst;
7016 loc_descr = new_loc_descr (op, offset, 0);
7017 add_AT_loc (die, DW_AT_data_member_location, loc_descr);
7020 /* Attach an DW_AT_const_value attribute for a variable or a parameter which
7021 does not have a "location" either in memory or in a register. These
7022 things can arise in GNU C when a constant is passed as an actual parameter
7023 to an inlined function. They can also arise in C++ where declared
7024 constants do not necessarily get memory "homes". */
7027 add_const_value_attribute (die, rtl)
7028 register dw_die_ref die;
7031 switch (GET_CODE (rtl))
7034 /* Note that a CONST_INT rtx could represent either an integer or a
7035 floating-point constant. A CONST_INT is used whenever the constant
7036 will fit into a single word. In all such cases, the original mode
7037 of the constant value is wiped out, and the CONST_INT rtx is
7038 assigned VOIDmode. */
7039 add_AT_unsigned (die, DW_AT_const_value, (unsigned) INTVAL (rtl));
7043 /* Note that a CONST_DOUBLE rtx could represent either an integer or a
7044 floating-point constant. A CONST_DOUBLE is used whenever the
7045 constant requires more than one word in order to be adequately
7046 represented. We output CONST_DOUBLEs as blocks. */
7048 register enum machine_mode mode = GET_MODE (rtl);
7050 if (GET_MODE_CLASS (mode) == MODE_FLOAT)
7052 register unsigned length = GET_MODE_SIZE (mode) / sizeof (long);
7056 REAL_VALUE_FROM_CONST_DOUBLE (rv, rtl);
7060 REAL_VALUE_TO_TARGET_SINGLE (rv, array[0]);
7064 REAL_VALUE_TO_TARGET_DOUBLE (rv, array);
7069 REAL_VALUE_TO_TARGET_LONG_DOUBLE (rv, array);
7076 add_AT_float (die, DW_AT_const_value, length, array);
7079 add_AT_long_long (die, DW_AT_const_value,
7080 CONST_DOUBLE_HIGH (rtl), CONST_DOUBLE_LOW (rtl));
7085 add_AT_string (die, DW_AT_const_value, XSTR (rtl, 0));
7091 add_AT_addr (die, DW_AT_const_value, addr_to_string (rtl));
7095 /* In cases where an inlined instance of an inline function is passed
7096 the address of an `auto' variable (which is local to the caller) we
7097 can get a situation where the DECL_RTL of the artificial local
7098 variable (for the inlining) which acts as a stand-in for the
7099 corresponding formal parameter (of the inline function) will look
7100 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not
7101 exactly a compile-time constant expression, but it isn't the address
7102 of the (artificial) local variable either. Rather, it represents the
7103 *value* which the artificial local variable always has during its
7104 lifetime. We currently have no way to represent such quasi-constant
7105 values in Dwarf, so for now we just punt and generate nothing. */
7109 /* No other kinds of rtx should be possible here. */
7115 /* Generate *either* an DW_AT_location attribute or else an DW_AT_const_value
7116 data attribute for a variable or a parameter. We generate the
7117 DW_AT_const_value attribute only in those cases where the given variable
7118 or parameter does not have a true "location" either in memory or in a
7119 register. This can happen (for example) when a constant is passed as an
7120 actual argument in a call to an inline function. (It's possible that
7121 these things can crop up in other ways also.) Note that one type of
7122 constant value which can be passed into an inlined function is a constant
7123 pointer. This can happen for example if an actual argument in an inlined
7124 function call evaluates to a compile-time constant address. */
7127 add_location_or_const_value_attribute (die, decl)
7128 register dw_die_ref die;
7132 register tree declared_type;
7133 register tree passed_type;
7135 if (TREE_CODE (decl) == ERROR_MARK)
7138 if (TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != PARM_DECL)
7141 /* Here we have to decide where we are going to say the parameter "lives"
7142 (as far as the debugger is concerned). We only have a couple of
7143 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
7145 DECL_RTL normally indicates where the parameter lives during most of the
7146 activation of the function. If optimization is enabled however, this
7147 could be either NULL or else a pseudo-reg. Both of those cases indicate
7148 that the parameter doesn't really live anywhere (as far as the code
7149 generation parts of GCC are concerned) during most of the function's
7150 activation. That will happen (for example) if the parameter is never
7151 referenced within the function.
7153 We could just generate a location descriptor here for all non-NULL
7154 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
7155 a little nicer than that if we also consider DECL_INCOMING_RTL in cases
7156 where DECL_RTL is NULL or is a pseudo-reg.
7158 Note however that we can only get away with using DECL_INCOMING_RTL as
7159 a backup substitute for DECL_RTL in certain limited cases. In cases
7160 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
7161 we can be sure that the parameter was passed using the same type as it is
7162 declared to have within the function, and that its DECL_INCOMING_RTL
7163 points us to a place where a value of that type is passed.
7165 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
7166 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
7167 because in these cases DECL_INCOMING_RTL points us to a value of some
7168 type which is *different* from the type of the parameter itself. Thus,
7169 if we tried to use DECL_INCOMING_RTL to generate a location attribute in
7170 such cases, the debugger would end up (for example) trying to fetch a
7171 `float' from a place which actually contains the first part of a
7172 `double'. That would lead to really incorrect and confusing
7173 output at debug-time.
7175 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
7176 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There
7177 are a couple of exceptions however. On little-endian machines we can
7178 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
7179 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
7180 an integral type that is smaller than TREE_TYPE (decl). These cases arise
7181 when (on a little-endian machine) a non-prototyped function has a
7182 parameter declared to be of type `short' or `char'. In such cases,
7183 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
7184 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
7185 passed `int' value. If the debugger then uses that address to fetch
7186 a `short' or a `char' (on a little-endian machine) the result will be
7187 the correct data, so we allow for such exceptional cases below.
7189 Note that our goal here is to describe the place where the given formal
7190 parameter lives during most of the function's activation (i.e. between
7191 the end of the prologue and the start of the epilogue). We'll do that
7192 as best as we can. Note however that if the given formal parameter is
7193 modified sometime during the execution of the function, then a stack
7194 backtrace (at debug-time) will show the function as having been
7195 called with the *new* value rather than the value which was
7196 originally passed in. This happens rarely enough that it is not
7197 a major problem, but it *is* a problem, and I'd like to fix it.
7199 A future version of dwarf2out.c may generate two additional
7200 attributes for any given DW_TAG_formal_parameter DIE which will
7201 describe the "passed type" and the "passed location" for the
7202 given formal parameter in addition to the attributes we now
7203 generate to indicate the "declared type" and the "active
7204 location" for each parameter. This additional set of attributes
7205 could be used by debuggers for stack backtraces. Separately, note
7206 that sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be
7207 NULL also. This happens (for example) for inlined-instances of
7208 inline function formal parameters which are never referenced.
7209 This really shouldn't be happening. All PARM_DECL nodes should
7210 get valid non-NULL DECL_INCOMING_RTL values, but integrate.c
7211 doesn't currently generate these values for inlined instances of
7212 inline function parameters, so when we see such cases, we are
7213 just out-of-luck for the time being (until integrate.c
7216 /* Use DECL_RTL as the "location" unless we find something better. */
7217 rtl = DECL_RTL (decl);
7219 if (TREE_CODE (decl) == PARM_DECL)
7221 if (rtl == NULL_RTX || is_pseudo_reg (rtl))
7223 declared_type = type_main_variant (TREE_TYPE (decl));
7224 passed_type = type_main_variant (DECL_ARG_TYPE (decl));
7226 /* This decl represents a formal parameter which was optimized out.
7227 Note that DECL_INCOMING_RTL may be NULL in here, but we handle
7228 all* cases where (rtl == NULL_RTX) just below. */
7229 if (declared_type == passed_type)
7230 rtl = DECL_INCOMING_RTL (decl);
7231 else if (! BYTES_BIG_ENDIAN
7232 && TREE_CODE (declared_type) == INTEGER_TYPE
7233 && (GET_MODE_SIZE (TYPE_MODE (declared_type))
7234 <= GET_MODE_SIZE (TYPE_MODE (passed_type))))
7235 rtl = DECL_INCOMING_RTL (decl);
7238 /* If the parm was passed in registers, but lives on the stack, then
7239 make a big endian correction if the mode of the type of the
7240 parameter is not the same as the mode of the rtl. */
7241 /* ??? This is the same series of checks that are made in dbxout.c before
7242 we reach the big endian correction code there. It isn't clear if all
7243 of these checks are necessary here, but keeping them all is the safe
7245 else if (GET_CODE (rtl) == MEM
7246 && XEXP (rtl, 0) != const0_rtx
7247 && ! CONSTANT_P (XEXP (rtl, 0))
7248 /* Not passed in memory. */
7249 && GET_CODE (DECL_INCOMING_RTL (decl)) != MEM
7250 /* Not passed by invisible reference. */
7251 && (GET_CODE (XEXP (rtl, 0)) != REG
7252 || REGNO (XEXP (rtl, 0)) == HARD_FRAME_POINTER_REGNUM
7253 || REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM
7254 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
7255 || REGNO (XEXP (rtl, 0)) == ARG_POINTER_REGNUM
7258 /* Big endian correction check. */
7260 && TYPE_MODE (TREE_TYPE (decl)) != GET_MODE (rtl)
7261 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)))
7264 int offset = (UNITS_PER_WORD
7265 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl))));
7266 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
7267 plus_constant (XEXP (rtl, 0), offset));
7271 if (rtl == NULL_RTX)
7274 rtl = eliminate_regs (rtl, 0, NULL_RTX);
7275 #ifdef LEAF_REG_REMAP
7276 if (current_function_uses_only_leaf_regs)
7277 leaf_renumber_regs_insn (rtl);
7280 switch (GET_CODE (rtl))
7283 /* The address of a variable that was optimized away; don't emit
7294 /* DECL_RTL could be (plus (reg ...) (const_int ...)) */
7295 add_const_value_attribute (die, rtl);
7302 add_AT_location_description (die, DW_AT_location, rtl);
7310 /* Generate an DW_AT_name attribute given some string value to be included as
7311 the value of the attribute. */
7314 add_name_attribute (die, name_string)
7315 register dw_die_ref die;
7316 register const char *name_string;
7318 if (name_string != NULL && *name_string != 0)
7319 add_AT_string (die, DW_AT_name, name_string);
7322 /* Given a tree node describing an array bound (either lower or upper) output
7323 a representation for that bound. */
7326 add_bound_info (subrange_die, bound_attr, bound)
7327 register dw_die_ref subrange_die;
7328 register enum dwarf_attribute bound_attr;
7329 register tree bound;
7331 register unsigned bound_value = 0;
7333 /* If this is an Ada unconstrained array type, then don't emit any debug
7334 info because the array bounds are unknown. They are parameterized when
7335 the type is instantiated. */
7336 if (contains_placeholder_p (bound))
7339 switch (TREE_CODE (bound))
7344 /* All fixed-bounds are represented by INTEGER_CST nodes. */
7346 bound_value = TREE_INT_CST_LOW (bound);
7347 if (bound_attr == DW_AT_lower_bound
7348 && ((is_c_family () && bound_value == 0)
7349 || (is_fortran () && bound_value == 1)))
7350 /* use the default */;
7352 add_AT_unsigned (subrange_die, bound_attr, bound_value);
7357 case NON_LVALUE_EXPR:
7358 add_bound_info (subrange_die, bound_attr, TREE_OPERAND (bound, 0));
7362 /* If optimization is turned on, the SAVE_EXPRs that describe how to
7363 access the upper bound values may be bogus. If they refer to a
7364 register, they may only describe how to get at these values at the
7365 points in the generated code right after they have just been
7366 computed. Worse yet, in the typical case, the upper bound values
7367 will not even *be* computed in the optimized code (though the
7368 number of elements will), so these SAVE_EXPRs are entirely
7369 bogus. In order to compensate for this fact, we check here to see
7370 if optimization is enabled, and if so, we don't add an attribute
7371 for the (unknown and unknowable) upper bound. This should not
7372 cause too much trouble for existing (stupid?) debuggers because
7373 they have to deal with empty upper bounds location descriptions
7374 anyway in order to be able to deal with incomplete array types.
7375 Of course an intelligent debugger (GDB?) should be able to
7376 comprehend that a missing upper bound specification in a array
7377 type used for a storage class `auto' local array variable
7378 indicates that the upper bound is both unknown (at compile- time)
7379 and unknowable (at run-time) due to optimization.
7381 We assume that a MEM rtx is safe because gcc wouldn't put the
7382 value there unless it was going to be used repeatedly in the
7383 function, i.e. for cleanups. */
7384 if (! optimize || GET_CODE (SAVE_EXPR_RTL (bound)) == MEM)
7386 register dw_die_ref ctx = lookup_decl_die (current_function_decl);
7387 register dw_die_ref decl_die = new_die (DW_TAG_variable, ctx);
7388 register rtx loc = SAVE_EXPR_RTL (bound);
7390 /* If the RTL for the SAVE_EXPR is memory, handle the case where
7391 it references an outer function's frame. */
7393 if (GET_CODE (loc) == MEM)
7395 rtx new_addr = fix_lexical_addr (XEXP (loc, 0), bound);
7397 if (XEXP (loc, 0) != new_addr)
7398 loc = gen_rtx (MEM, GET_MODE (loc), new_addr);
7401 add_AT_flag (decl_die, DW_AT_artificial, 1);
7402 add_type_attribute (decl_die, TREE_TYPE (bound), 1, 0, ctx);
7403 add_AT_location_description (decl_die, DW_AT_location, loc);
7404 add_AT_die_ref (subrange_die, bound_attr, decl_die);
7407 /* Else leave out the attribute. */
7413 /* ??? These types of bounds can be created by the Ada front end,
7414 and it isn't clear how to emit debug info for them. */
7422 /* Note that the block of subscript information for an array type also
7423 includes information about the element type of type given array type. */
7426 add_subscript_info (type_die, type)
7427 register dw_die_ref type_die;
7430 #ifndef MIPS_DEBUGGING_INFO
7431 register unsigned dimension_number;
7433 register tree lower, upper;
7434 register dw_die_ref subrange_die;
7436 /* The GNU compilers represent multidimensional array types as sequences of
7437 one dimensional array types whose element types are themselves array
7438 types. Here we squish that down, so that each multidimensional array
7439 type gets only one array_type DIE in the Dwarf debugging info. The draft
7440 Dwarf specification say that we are allowed to do this kind of
7441 compression in C (because there is no difference between an array or
7442 arrays and a multidimensional array in C) but for other source languages
7443 (e.g. Ada) we probably shouldn't do this. */
7445 /* ??? The SGI dwarf reader fails for multidimensional arrays with a
7446 const enum type. E.g. const enum machine_mode insn_operand_mode[2][10].
7447 We work around this by disabling this feature. See also
7448 gen_array_type_die. */
7449 #ifndef MIPS_DEBUGGING_INFO
7450 for (dimension_number = 0;
7451 TREE_CODE (type) == ARRAY_TYPE;
7452 type = TREE_TYPE (type), dimension_number++)
7455 register tree domain = TYPE_DOMAIN (type);
7457 /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
7458 and (in GNU C only) variable bounds. Handle all three forms
7460 subrange_die = new_die (DW_TAG_subrange_type, type_die);
7463 /* We have an array type with specified bounds. */
7464 lower = TYPE_MIN_VALUE (domain);
7465 upper = TYPE_MAX_VALUE (domain);
7467 /* define the index type. */
7468 if (TREE_TYPE (domain))
7470 /* ??? This is probably an Ada unnamed subrange type. Ignore the
7471 TREE_TYPE field. We can't emit debug info for this
7472 because it is an unnamed integral type. */
7473 if (TREE_CODE (domain) == INTEGER_TYPE
7474 && TYPE_NAME (domain) == NULL_TREE
7475 && TREE_CODE (TREE_TYPE (domain)) == INTEGER_TYPE
7476 && TYPE_NAME (TREE_TYPE (domain)) == NULL_TREE)
7479 add_type_attribute (subrange_die, TREE_TYPE (domain), 0, 0,
7483 /* ??? If upper is NULL, the array has unspecified length,
7484 but it does have a lower bound. This happens with Fortran
7486 Since the debugger is definitely going to need to know N
7487 to produce useful results, go ahead and output the lower
7488 bound solo, and hope the debugger can cope. */
7490 add_bound_info (subrange_die, DW_AT_lower_bound, lower);
7492 add_bound_info (subrange_die, DW_AT_upper_bound, upper);
7495 /* We have an array type with an unspecified length. The DWARF-2
7496 spec does not say how to handle this; let's just leave out the
7501 #ifndef MIPS_DEBUGGING_INFO
7507 add_byte_size_attribute (die, tree_node)
7509 register tree tree_node;
7511 register unsigned size;
7513 switch (TREE_CODE (tree_node))
7521 case QUAL_UNION_TYPE:
7522 size = int_size_in_bytes (tree_node);
7525 /* For a data member of a struct or union, the DW_AT_byte_size is
7526 generally given as the number of bytes normally allocated for an
7527 object of the *declared* type of the member itself. This is true
7528 even for bit-fields. */
7529 size = simple_type_size_in_bits (field_type (tree_node)) / BITS_PER_UNIT;
7535 /* Note that `size' might be -1 when we get to this point. If it is, that
7536 indicates that the byte size of the entity in question is variable. We
7537 have no good way of expressing this fact in Dwarf at the present time,
7538 so just let the -1 pass on through. */
7540 add_AT_unsigned (die, DW_AT_byte_size, size);
7543 /* For a FIELD_DECL node which represents a bit-field, output an attribute
7544 which specifies the distance in bits from the highest order bit of the
7545 "containing object" for the bit-field to the highest order bit of the
7548 For any given bit-field, the "containing object" is a hypothetical
7549 object (of some integral or enum type) within which the given bit-field
7550 lives. The type of this hypothetical "containing object" is always the
7551 same as the declared type of the individual bit-field itself. The
7552 determination of the exact location of the "containing object" for a
7553 bit-field is rather complicated. It's handled by the
7554 `field_byte_offset' function (above).
7556 Note that it is the size (in bytes) of the hypothetical "containing object"
7557 which will be given in the DW_AT_byte_size attribute for this bit-field.
7558 (See `byte_size_attribute' above). */
7561 add_bit_offset_attribute (die, decl)
7562 register dw_die_ref die;
7565 register unsigned object_offset_in_bytes = field_byte_offset (decl);
7566 register tree type = DECL_BIT_FIELD_TYPE (decl);
7567 register tree bitpos_tree = DECL_FIELD_BITPOS (decl);
7568 register unsigned bitpos_int;
7569 register unsigned highest_order_object_bit_offset;
7570 register unsigned highest_order_field_bit_offset;
7571 register unsigned bit_offset;
7573 /* Must be a field and a bit field. */
7575 || TREE_CODE (decl) != FIELD_DECL)
7578 /* We can't yet handle bit-fields whose offsets are variable, so if we
7579 encounter such things, just return without generating any attribute
7581 if (TREE_CODE (bitpos_tree) != INTEGER_CST)
7584 bitpos_int = (unsigned) TREE_INT_CST_LOW (bitpos_tree);
7586 /* Note that the bit offset is always the distance (in bits) from the
7587 highest-order bit of the "containing object" to the highest-order bit of
7588 the bit-field itself. Since the "high-order end" of any object or field
7589 is different on big-endian and little-endian machines, the computation
7590 below must take account of these differences. */
7591 highest_order_object_bit_offset = object_offset_in_bytes * BITS_PER_UNIT;
7592 highest_order_field_bit_offset = bitpos_int;
7594 if (! BYTES_BIG_ENDIAN)
7596 highest_order_field_bit_offset
7597 += (unsigned) TREE_INT_CST_LOW (DECL_SIZE (decl));
7599 highest_order_object_bit_offset += simple_type_size_in_bits (type);
7603 = (! BYTES_BIG_ENDIAN
7604 ? highest_order_object_bit_offset - highest_order_field_bit_offset
7605 : highest_order_field_bit_offset - highest_order_object_bit_offset);
7607 add_AT_unsigned (die, DW_AT_bit_offset, bit_offset);
7610 /* For a FIELD_DECL node which represents a bit field, output an attribute
7611 which specifies the length in bits of the given field. */
7614 add_bit_size_attribute (die, decl)
7615 register dw_die_ref die;
7618 /* Must be a field and a bit field. */
7619 if (TREE_CODE (decl) != FIELD_DECL
7620 || ! DECL_BIT_FIELD_TYPE (decl))
7622 add_AT_unsigned (die, DW_AT_bit_size,
7623 (unsigned) TREE_INT_CST_LOW (DECL_SIZE (decl)));
7626 /* If the compiled language is ANSI C, then add a 'prototyped'
7627 attribute, if arg types are given for the parameters of a function. */
7630 add_prototyped_attribute (die, func_type)
7631 register dw_die_ref die;
7632 register tree func_type;
7634 if (get_AT_unsigned (comp_unit_die, DW_AT_language) == DW_LANG_C89
7635 && TYPE_ARG_TYPES (func_type) != NULL)
7636 add_AT_flag (die, DW_AT_prototyped, 1);
7640 /* Add an 'abstract_origin' attribute below a given DIE. The DIE is found
7641 by looking in either the type declaration or object declaration
7645 add_abstract_origin_attribute (die, origin)
7646 register dw_die_ref die;
7647 register tree origin;
7649 dw_die_ref origin_die = NULL;
7650 if (TREE_CODE_CLASS (TREE_CODE (origin)) == 'd')
7651 origin_die = lookup_decl_die (origin);
7652 else if (TREE_CODE_CLASS (TREE_CODE (origin)) == 't')
7653 origin_die = lookup_type_die (origin);
7655 add_AT_die_ref (die, DW_AT_abstract_origin, origin_die);
7658 /* We do not currently support the pure_virtual attribute. */
7661 add_pure_or_virtual_attribute (die, func_decl)
7662 register dw_die_ref die;
7663 register tree func_decl;
7665 if (DECL_VINDEX (func_decl))
7667 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
7668 add_AT_loc (die, DW_AT_vtable_elem_location,
7669 new_loc_descr (DW_OP_constu,
7670 TREE_INT_CST_LOW (DECL_VINDEX (func_decl)),
7673 /* GNU extension: Record what type this method came from originally. */
7674 if (debug_info_level > DINFO_LEVEL_TERSE)
7675 add_AT_die_ref (die, DW_AT_containing_type,
7676 lookup_type_die (DECL_CONTEXT (func_decl)));
7680 /* Add source coordinate attributes for the given decl. */
7683 add_src_coords_attributes (die, decl)
7684 register dw_die_ref die;
7687 register unsigned file_index = lookup_filename (DECL_SOURCE_FILE (decl));
7689 add_AT_unsigned (die, DW_AT_decl_file, file_index);
7690 add_AT_unsigned (die, DW_AT_decl_line, DECL_SOURCE_LINE (decl));
7693 /* Add an DW_AT_name attribute and source coordinate attribute for the
7694 given decl, but only if it actually has a name. */
7697 add_name_and_src_coords_attributes (die, decl)
7698 register dw_die_ref die;
7701 register tree decl_name;
7703 decl_name = DECL_NAME (decl);
7704 if (decl_name != NULL && IDENTIFIER_POINTER (decl_name) != NULL)
7706 add_name_attribute (die, dwarf2_name (decl, 0));
7707 add_src_coords_attributes (die, decl);
7708 if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
7709 && DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
7710 add_AT_string (die, DW_AT_MIPS_linkage_name,
7711 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
7715 /* Push a new declaration scope. */
7718 push_decl_scope (scope)
7721 tree containing_scope;
7724 /* Make room in the decl_scope_table, if necessary. */
7725 if (decl_scope_table_allocated == decl_scope_depth)
7727 decl_scope_table_allocated += DECL_SCOPE_TABLE_INCREMENT;
7729 = (decl_scope_node *) xrealloc (decl_scope_table,
7730 (decl_scope_table_allocated
7731 * sizeof (decl_scope_node)));
7734 decl_scope_table[decl_scope_depth].scope = scope;
7736 /* Sometimes, while recursively emitting subtypes within a class type,
7737 we end up recuring on a subtype at a higher level then the current
7738 subtype. In such a case, we need to search the decl_scope_table to
7739 find the parent of this subtype. */
7741 if (AGGREGATE_TYPE_P (scope))
7742 containing_scope = TYPE_CONTEXT (scope);
7744 containing_scope = NULL_TREE;
7746 /* The normal case. */
7747 if (decl_scope_depth == 0
7748 || containing_scope == NULL_TREE
7749 /* Ignore namespaces for the moment. */
7750 || TREE_CODE (containing_scope) == NAMESPACE_DECL
7751 || containing_scope == decl_scope_table[decl_scope_depth - 1].scope)
7752 decl_scope_table[decl_scope_depth].previous = decl_scope_depth - 1;
7755 /* We need to search for the containing_scope. */
7756 for (i = 0; i < decl_scope_depth; i++)
7757 if (decl_scope_table[i].scope == containing_scope)
7760 if (i == decl_scope_depth)
7763 decl_scope_table[decl_scope_depth].previous = i;
7769 /* Return the DIE for the scope that immediately contains this declaration. */
7772 scope_die_for (t, context_die)
7774 register dw_die_ref context_die;
7776 register dw_die_ref scope_die = NULL;
7777 register tree containing_scope;
7780 /* Walk back up the declaration tree looking for a place to define
7782 if (TREE_CODE_CLASS (TREE_CODE (t)) == 't')
7783 containing_scope = TYPE_CONTEXT (t);
7784 else if (TREE_CODE (t) == FUNCTION_DECL && DECL_VINDEX (t))
7785 containing_scope = decl_class_context (t);
7787 containing_scope = DECL_CONTEXT (t);
7789 /* Ignore namespaces for the moment. */
7790 if (containing_scope && TREE_CODE (containing_scope) == NAMESPACE_DECL)
7791 containing_scope = NULL_TREE;
7793 /* Ignore function type "scopes" from the C frontend. They mean that
7794 a tagged type is local to a parmlist of a function declarator, but
7795 that isn't useful to DWARF. */
7796 if (containing_scope && TREE_CODE (containing_scope) == FUNCTION_TYPE)
7797 containing_scope = NULL_TREE;
7799 /* Function-local tags and functions get stuck in limbo until they are
7800 fixed up by decls_for_scope. */
7801 if (context_die == NULL && containing_scope != NULL_TREE
7802 && (TREE_CODE (t) == FUNCTION_DECL || is_tagged_type (t)))
7805 if (containing_scope == NULL_TREE)
7806 scope_die = comp_unit_die;
7809 for (i = decl_scope_depth - 1, scope_die = context_die;
7810 i >= 0 && decl_scope_table[i].scope != containing_scope;
7811 (scope_die = scope_die->die_parent,
7812 i = decl_scope_table[i].previous))
7815 /* ??? Integrate_decl_tree does not handle BLOCK_TYPE_TAGS, nor
7816 does it try to handle types defined by TYPE_DECLs. Such types
7817 thus have an incorrect TYPE_CONTEXT, which points to the block
7818 they were originally defined in, instead of the current block
7819 created by function inlining. We try to detect that here and
7822 if (i < 0 && scope_die == comp_unit_die
7823 && TREE_CODE (containing_scope) == BLOCK
7824 && is_tagged_type (t)
7825 && (block_ultimate_origin (decl_scope_table[decl_scope_depth - 1].scope)
7826 == containing_scope))
7828 scope_die = context_die;
7829 /* Since the checks below are no longer applicable. */
7835 if (TREE_CODE_CLASS (TREE_CODE (containing_scope)) != 't')
7837 if (debug_info_level > DINFO_LEVEL_TERSE
7838 && !TREE_ASM_WRITTEN (containing_scope))
7841 /* If none of the current dies are suitable, we get file scope. */
7842 scope_die = comp_unit_die;
7849 /* Pop a declaration scope. */
7853 if (decl_scope_depth <= 0)
7858 /* Many forms of DIEs require a "type description" attribute. This
7859 routine locates the proper "type descriptor" die for the type given
7860 by 'type', and adds an DW_AT_type attribute below the given die. */
7863 add_type_attribute (object_die, type, decl_const, decl_volatile, context_die)
7864 register dw_die_ref object_die;
7866 register int decl_const;
7867 register int decl_volatile;
7868 register dw_die_ref context_die;
7870 register enum tree_code code = TREE_CODE (type);
7871 register dw_die_ref type_die = NULL;
7873 /* ??? If this type is an unnamed subrange type of an integral or
7874 floating-point type, use the inner type. This is because we have no
7875 support for unnamed types in base_type_die. This can happen if this is
7876 an Ada subrange type. Correct solution is emit a subrange type die. */
7877 if ((code == INTEGER_TYPE || code == REAL_TYPE)
7878 && TREE_TYPE (type) != 0 && TYPE_NAME (type) == 0)
7879 type = TREE_TYPE (type), code = TREE_CODE (type);
7881 if (code == ERROR_MARK)
7884 /* Handle a special case. For functions whose return type is void, we
7885 generate *no* type attribute. (Note that no object may have type
7886 `void', so this only applies to function return types). */
7887 if (code == VOID_TYPE)
7890 type_die = modified_type_die (type,
7891 decl_const || TYPE_READONLY (type),
7892 decl_volatile || TYPE_VOLATILE (type),
7894 if (type_die != NULL)
7895 add_AT_die_ref (object_die, DW_AT_type, type_die);
7898 /* Given a tree pointer to a struct, class, union, or enum type node, return
7899 a pointer to the (string) tag name for the given type, or zero if the type
7900 was declared without a tag. */
7906 register char *name = 0;
7908 if (TYPE_NAME (type) != 0)
7910 register tree t = 0;
7912 /* Find the IDENTIFIER_NODE for the type name. */
7913 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
7914 t = TYPE_NAME (type);
7916 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
7917 a TYPE_DECL node, regardless of whether or not a `typedef' was
7919 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
7920 && ! DECL_IGNORED_P (TYPE_NAME (type)))
7921 t = DECL_NAME (TYPE_NAME (type));
7923 /* Now get the name as a string, or invent one. */
7925 name = IDENTIFIER_POINTER (t);
7928 return (name == 0 || *name == '\0') ? 0 : name;
7931 /* Return the type associated with a data member, make a special check
7932 for bit field types. */
7935 member_declared_type (member)
7936 register tree member;
7938 return (DECL_BIT_FIELD_TYPE (member)
7939 ? DECL_BIT_FIELD_TYPE (member)
7940 : TREE_TYPE (member));
7943 /* Get the decl's label, as described by its RTL. This may be different
7944 from the DECL_NAME name used in the source file. */
7948 decl_start_label (decl)
7953 x = DECL_RTL (decl);
7954 if (GET_CODE (x) != MEM)
7958 if (GET_CODE (x) != SYMBOL_REF)
7961 fnname = XSTR (x, 0);
7966 /* These routines generate the internal representation of the DIE's for
7967 the compilation unit. Debugging information is collected by walking
7968 the declaration trees passed in from dwarf2out_decl(). */
7971 gen_array_type_die (type, context_die)
7973 register dw_die_ref context_die;
7975 register dw_die_ref scope_die = scope_die_for (type, context_die);
7976 register dw_die_ref array_die;
7977 register tree element_type;
7979 /* ??? The SGI dwarf reader fails for array of array of enum types unless
7980 the inner array type comes before the outer array type. Thus we must
7981 call gen_type_die before we call new_die. See below also. */
7982 #ifdef MIPS_DEBUGGING_INFO
7983 gen_type_die (TREE_TYPE (type), context_die);
7986 array_die = new_die (DW_TAG_array_type, scope_die);
7989 /* We default the array ordering. SDB will probably do
7990 the right things even if DW_AT_ordering is not present. It's not even
7991 an issue until we start to get into multidimensional arrays anyway. If
7992 SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
7993 then we'll have to put the DW_AT_ordering attribute back in. (But if
7994 and when we find out that we need to put these in, we will only do so
7995 for multidimensional arrays. */
7996 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major);
7999 #ifdef MIPS_DEBUGGING_INFO
8000 /* The SGI compilers handle arrays of unknown bound by setting
8001 AT_declaration and not emitting any subrange DIEs. */
8002 if (! TYPE_DOMAIN (type))
8003 add_AT_unsigned (array_die, DW_AT_declaration, 1);
8006 add_subscript_info (array_die, type);
8008 equate_type_number_to_die (type, array_die);
8010 /* Add representation of the type of the elements of this array type. */
8011 element_type = TREE_TYPE (type);
8013 /* ??? The SGI dwarf reader fails for multidimensional arrays with a
8014 const enum type. E.g. const enum machine_mode insn_operand_mode[2][10].
8015 We work around this by disabling this feature. See also
8016 add_subscript_info. */
8017 #ifndef MIPS_DEBUGGING_INFO
8018 while (TREE_CODE (element_type) == ARRAY_TYPE)
8019 element_type = TREE_TYPE (element_type);
8021 gen_type_die (element_type, context_die);
8024 add_type_attribute (array_die, element_type, 0, 0, context_die);
8028 gen_set_type_die (type, context_die)
8030 register dw_die_ref context_die;
8032 register dw_die_ref type_die
8033 = new_die (DW_TAG_set_type, scope_die_for (type, context_die));
8035 equate_type_number_to_die (type, type_die);
8036 add_type_attribute (type_die, TREE_TYPE (type), 0, 0, context_die);
8041 gen_entry_point_die (decl, context_die)
8043 register dw_die_ref context_die;
8045 register tree origin = decl_ultimate_origin (decl);
8046 register dw_die_ref decl_die = new_die (DW_TAG_entry_point, context_die);
8048 add_abstract_origin_attribute (decl_die, origin);
8051 add_name_and_src_coords_attributes (decl_die, decl);
8052 add_type_attribute (decl_die, TREE_TYPE (TREE_TYPE (decl)),
8056 if (DECL_ABSTRACT (decl))
8057 equate_decl_number_to_die (decl, decl_die);
8059 add_AT_lbl_id (decl_die, DW_AT_low_pc, decl_start_label (decl));
8063 /* Remember a type in the pending_types_list. */
8069 if (pending_types == pending_types_allocated)
8071 pending_types_allocated += PENDING_TYPES_INCREMENT;
8073 = (tree *) xrealloc (pending_types_list,
8074 sizeof (tree) * pending_types_allocated);
8077 pending_types_list[pending_types++] = type;
8080 /* Output any pending types (from the pending_types list) which we can output
8081 now (taking into account the scope that we are working on now).
8083 For each type output, remove the given type from the pending_types_list
8084 *before* we try to output it. */
8087 output_pending_types_for_scope (context_die)
8088 register dw_die_ref context_die;
8092 while (pending_types)
8095 type = pending_types_list[pending_types];
8096 gen_type_die (type, context_die);
8097 if (!TREE_ASM_WRITTEN (type))
8102 /* Remember a type in the incomplete_types_list. */
8105 add_incomplete_type (type)
8108 if (incomplete_types == incomplete_types_allocated)
8110 incomplete_types_allocated += INCOMPLETE_TYPES_INCREMENT;
8111 incomplete_types_list
8112 = (tree *) xrealloc (incomplete_types_list,
8113 sizeof (tree) * incomplete_types_allocated);
8116 incomplete_types_list[incomplete_types++] = type;
8119 /* Walk through the list of incomplete types again, trying once more to
8120 emit full debugging info for them. */
8123 retry_incomplete_types ()
8127 while (incomplete_types)
8130 type = incomplete_types_list[incomplete_types];
8131 gen_type_die (type, comp_unit_die);
8135 /* Generate a DIE to represent an inlined instance of an enumeration type. */
8138 gen_inlined_enumeration_type_die (type, context_die)
8140 register dw_die_ref context_die;
8142 register dw_die_ref type_die = new_die (DW_TAG_enumeration_type,
8143 scope_die_for (type, context_die));
8145 if (!TREE_ASM_WRITTEN (type))
8147 add_abstract_origin_attribute (type_die, type);
8150 /* Generate a DIE to represent an inlined instance of a structure type. */
8153 gen_inlined_structure_type_die (type, context_die)
8155 register dw_die_ref context_die;
8157 register dw_die_ref type_die = new_die (DW_TAG_structure_type,
8158 scope_die_for (type, context_die));
8160 if (!TREE_ASM_WRITTEN (type))
8162 add_abstract_origin_attribute (type_die, type);
8165 /* Generate a DIE to represent an inlined instance of a union type. */
8168 gen_inlined_union_type_die (type, context_die)
8170 register dw_die_ref context_die;
8172 register dw_die_ref type_die = new_die (DW_TAG_union_type,
8173 scope_die_for (type, context_die));
8175 if (!TREE_ASM_WRITTEN (type))
8177 add_abstract_origin_attribute (type_die, type);
8180 /* Generate a DIE to represent an enumeration type. Note that these DIEs
8181 include all of the information about the enumeration values also. Each
8182 enumerated type name/value is listed as a child of the enumerated type
8186 gen_enumeration_type_die (type, context_die)
8188 register dw_die_ref context_die;
8190 register dw_die_ref type_die = lookup_type_die (type);
8192 if (type_die == NULL)
8194 type_die = new_die (DW_TAG_enumeration_type,
8195 scope_die_for (type, context_die));
8196 equate_type_number_to_die (type, type_die);
8197 add_name_attribute (type_die, type_tag (type));
8199 else if (! TYPE_SIZE (type))
8202 remove_AT (type_die, DW_AT_declaration);
8204 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the
8205 given enum type is incomplete, do not generate the DW_AT_byte_size
8206 attribute or the DW_AT_element_list attribute. */
8207 if (TYPE_SIZE (type))
8211 TREE_ASM_WRITTEN (type) = 1;
8212 add_byte_size_attribute (type_die, type);
8213 if (TYPE_STUB_DECL (type) != NULL_TREE)
8214 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
8216 /* If the first reference to this type was as the return type of an
8217 inline function, then it may not have a parent. Fix this now. */
8218 if (type_die->die_parent == NULL)
8219 add_child_die (scope_die_for (type, context_die), type_die);
8221 for (link = TYPE_FIELDS (type);
8222 link != NULL; link = TREE_CHAIN (link))
8224 register dw_die_ref enum_die = new_die (DW_TAG_enumerator, type_die);
8226 add_name_attribute (enum_die,
8227 IDENTIFIER_POINTER (TREE_PURPOSE (link)));
8228 add_AT_unsigned (enum_die, DW_AT_const_value,
8229 (unsigned) TREE_INT_CST_LOW (TREE_VALUE (link)));
8233 add_AT_flag (type_die, DW_AT_declaration, 1);
8237 /* Generate a DIE to represent either a real live formal parameter decl or to
8238 represent just the type of some formal parameter position in some function
8241 Note that this routine is a bit unusual because its argument may be a
8242 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
8243 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
8244 node. If it's the former then this function is being called to output a
8245 DIE to represent a formal parameter object (or some inlining thereof). If
8246 it's the latter, then this function is only being called to output a
8247 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
8248 argument type of some subprogram type. */
8251 gen_formal_parameter_die (node, context_die)
8253 register dw_die_ref context_die;
8255 register dw_die_ref parm_die
8256 = new_die (DW_TAG_formal_parameter, context_die);
8257 register tree origin;
8259 switch (TREE_CODE_CLASS (TREE_CODE (node)))
8262 origin = decl_ultimate_origin (node);
8264 add_abstract_origin_attribute (parm_die, origin);
8267 add_name_and_src_coords_attributes (parm_die, node);
8268 add_type_attribute (parm_die, TREE_TYPE (node),
8269 TREE_READONLY (node),
8270 TREE_THIS_VOLATILE (node),
8272 if (DECL_ARTIFICIAL (node))
8273 add_AT_flag (parm_die, DW_AT_artificial, 1);
8276 equate_decl_number_to_die (node, parm_die);
8277 if (! DECL_ABSTRACT (node))
8278 add_location_or_const_value_attribute (parm_die, node);
8283 /* We were called with some kind of a ..._TYPE node. */
8284 add_type_attribute (parm_die, node, 0, 0, context_die);
8294 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
8295 at the end of an (ANSI prototyped) formal parameters list. */
8298 gen_unspecified_parameters_die (decl_or_type, context_die)
8299 register tree decl_or_type ATTRIBUTE_UNUSED;
8300 register dw_die_ref context_die;
8302 new_die (DW_TAG_unspecified_parameters, context_die);
8305 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
8306 DW_TAG_unspecified_parameters DIE) to represent the types of the formal
8307 parameters as specified in some function type specification (except for
8308 those which appear as part of a function *definition*).
8310 Note we must be careful here to output all of the parameter DIEs before*
8311 we output any DIEs needed to represent the types of the formal parameters.
8312 This keeps svr4 SDB happy because it (incorrectly) thinks that the first
8313 non-parameter DIE it sees ends the formal parameter list. */
8316 gen_formal_types_die (function_or_method_type, context_die)
8317 register tree function_or_method_type;
8318 register dw_die_ref context_die;
8321 register tree formal_type = NULL;
8322 register tree first_parm_type = TYPE_ARG_TYPES (function_or_method_type);
8325 /* In the case where we are generating a formal types list for a C++
8326 non-static member function type, skip over the first thing on the
8327 TYPE_ARG_TYPES list because it only represents the type of the hidden
8328 `this pointer'. The debugger should be able to figure out (without
8329 being explicitly told) that this non-static member function type takes a
8330 `this pointer' and should be able to figure what the type of that hidden
8331 parameter is from the DW_AT_member attribute of the parent
8332 DW_TAG_subroutine_type DIE. */
8333 if (TREE_CODE (function_or_method_type) == METHOD_TYPE)
8334 first_parm_type = TREE_CHAIN (first_parm_type);
8337 /* Make our first pass over the list of formal parameter types and output a
8338 DW_TAG_formal_parameter DIE for each one. */
8339 for (link = first_parm_type; link; link = TREE_CHAIN (link))
8341 register dw_die_ref parm_die;
8343 formal_type = TREE_VALUE (link);
8344 if (formal_type == void_type_node)
8347 /* Output a (nameless) DIE to represent the formal parameter itself. */
8348 parm_die = gen_formal_parameter_die (formal_type, context_die);
8349 if (TREE_CODE (function_or_method_type) == METHOD_TYPE
8350 && link == first_parm_type)
8351 add_AT_flag (parm_die, DW_AT_artificial, 1);
8354 /* If this function type has an ellipsis, add a
8355 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */
8356 if (formal_type != void_type_node)
8357 gen_unspecified_parameters_die (function_or_method_type, context_die);
8359 /* Make our second (and final) pass over the list of formal parameter types
8360 and output DIEs to represent those types (as necessary). */
8361 for (link = TYPE_ARG_TYPES (function_or_method_type);
8363 link = TREE_CHAIN (link))
8365 formal_type = TREE_VALUE (link);
8366 if (formal_type == void_type_node)
8369 gen_type_die (formal_type, context_die);
8373 /* Generate a DIE to represent a declared function (either file-scope or
8377 gen_subprogram_die (decl, context_die)
8379 register dw_die_ref context_die;
8381 char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
8382 register tree origin = decl_ultimate_origin (decl);
8383 register dw_die_ref subr_die;
8384 register rtx fp_reg;
8385 register tree fn_arg_types;
8386 register tree outer_scope;
8387 register dw_die_ref old_die = lookup_decl_die (decl);
8388 register int declaration
8389 = (current_function_decl != decl
8391 && (context_die->die_tag == DW_TAG_structure_type
8392 || context_die->die_tag == DW_TAG_union_type)));
8396 subr_die = new_die (DW_TAG_subprogram, context_die);
8397 add_abstract_origin_attribute (subr_die, origin);
8399 else if (old_die && DECL_ABSTRACT (decl)
8400 && get_AT_unsigned (old_die, DW_AT_inline))
8402 /* This must be a redefinition of an extern inline function.
8403 We can just reuse the old die here. */
8406 /* Clear out the inlined attribute and parm types. */
8407 remove_AT (subr_die, DW_AT_inline);
8408 remove_children (subr_die);
8412 register unsigned file_index
8413 = lookup_filename (DECL_SOURCE_FILE (decl));
8415 if (get_AT_flag (old_die, DW_AT_declaration) != 1)
8417 /* ??? This can happen if there is a bug in the program, for
8418 instance, if it has duplicate function definitions. Ideally,
8419 we should detect this case and ignore it. For now, if we have
8420 already reported an error, any error at all, then assume that
8421 we got here because of a input error, not a dwarf2 bug. */
8427 /* If the definition comes from the same place as the declaration,
8428 maybe use the old DIE. We always want the DIE for this function
8429 that has the *_pc attributes to be under comp_unit_die so the
8430 debugger can find it. For inlines, that is the concrete instance,
8431 so we can use the old DIE here. For non-inline methods, we want a
8432 specification DIE at toplevel, so we need a new DIE. For local
8433 class methods, this does not apply. */
8434 if ((DECL_ABSTRACT (decl) || old_die->die_parent == comp_unit_die
8435 || context_die == NULL)
8436 && get_AT_unsigned (old_die, DW_AT_decl_file) == file_index
8437 && (get_AT_unsigned (old_die, DW_AT_decl_line)
8438 == (unsigned)DECL_SOURCE_LINE (decl)))
8442 /* Clear out the declaration attribute and the parm types. */
8443 remove_AT (subr_die, DW_AT_declaration);
8444 remove_children (subr_die);
8448 subr_die = new_die (DW_TAG_subprogram, context_die);
8449 add_AT_die_ref (subr_die, DW_AT_specification, old_die);
8450 if (get_AT_unsigned (old_die, DW_AT_decl_file) != file_index)
8451 add_AT_unsigned (subr_die, DW_AT_decl_file, file_index);
8452 if (get_AT_unsigned (old_die, DW_AT_decl_line)
8453 != (unsigned)DECL_SOURCE_LINE (decl))
8455 (subr_die, DW_AT_decl_line, DECL_SOURCE_LINE (decl));
8460 register dw_die_ref scope_die;
8462 if (DECL_CONTEXT (decl))
8463 scope_die = scope_die_for (decl, context_die);
8465 /* Don't put block extern declarations under comp_unit_die. */
8466 scope_die = context_die;
8468 subr_die = new_die (DW_TAG_subprogram, scope_die);
8470 if (TREE_PUBLIC (decl))
8471 add_AT_flag (subr_die, DW_AT_external, 1);
8473 add_name_and_src_coords_attributes (subr_die, decl);
8474 if (debug_info_level > DINFO_LEVEL_TERSE)
8476 register tree type = TREE_TYPE (decl);
8478 add_prototyped_attribute (subr_die, type);
8479 add_type_attribute (subr_die, TREE_TYPE (type), 0, 0, context_die);
8482 add_pure_or_virtual_attribute (subr_die, decl);
8483 if (DECL_ARTIFICIAL (decl))
8484 add_AT_flag (subr_die, DW_AT_artificial, 1);
8485 if (TREE_PROTECTED (decl))
8486 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_protected);
8487 else if (TREE_PRIVATE (decl))
8488 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_private);
8493 add_AT_flag (subr_die, DW_AT_declaration, 1);
8495 /* The first time we see a member function, it is in the context of
8496 the class to which it belongs. We make sure of this by emitting
8497 the class first. The next time is the definition, which is
8498 handled above. The two may come from the same source text. */
8499 if (DECL_CONTEXT (decl))
8500 equate_decl_number_to_die (decl, subr_die);
8502 else if (DECL_ABSTRACT (decl))
8504 /* ??? Checking DECL_DEFER_OUTPUT is correct for static inline functions,
8505 but not for extern inline functions. We can't get this completely
8506 correct because information about whether the function was declared
8507 inline is not saved anywhere. */
8508 if (DECL_DEFER_OUTPUT (decl))
8510 if (DECL_INLINE (decl))
8511 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_inlined);
8513 add_AT_unsigned (subr_die, DW_AT_inline,
8514 DW_INL_declared_not_inlined);
8516 else if (DECL_INLINE (decl))
8517 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_inlined);
8521 equate_decl_number_to_die (decl, subr_die);
8523 else if (!DECL_EXTERNAL (decl))
8525 if (origin == NULL_TREE)
8526 equate_decl_number_to_die (decl, subr_die);
8528 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_BEGIN_LABEL,
8529 current_funcdef_number);
8530 add_AT_lbl_id (subr_die, DW_AT_low_pc, label_id);
8531 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
8532 current_funcdef_number);
8533 add_AT_lbl_id (subr_die, DW_AT_high_pc, label_id);
8535 add_pubname (decl, subr_die);
8536 add_arange (decl, subr_die);
8538 #ifdef MIPS_DEBUGGING_INFO
8539 /* Add a reference to the FDE for this routine. */
8540 add_AT_fde_ref (subr_die, DW_AT_MIPS_fde, current_funcdef_fde);
8543 /* Define the "frame base" location for this routine. We use the
8544 frame pointer or stack pointer registers, since the RTL for local
8545 variables is relative to one of them. */
8547 = frame_pointer_needed ? hard_frame_pointer_rtx : stack_pointer_rtx;
8548 add_AT_loc (subr_die, DW_AT_frame_base, reg_loc_descriptor (fp_reg));
8551 /* ??? This fails for nested inline functions, because context_display
8552 is not part of the state saved/restored for inline functions. */
8553 if (current_function_needs_context)
8554 add_AT_location_description (subr_die, DW_AT_static_link,
8555 lookup_static_chain (decl));
8559 /* Now output descriptions of the arguments for this function. This gets
8560 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
8561 for a FUNCTION_DECL doesn't indicate cases where there was a trailing
8562 `...' at the end of the formal parameter list. In order to find out if
8563 there was a trailing ellipsis or not, we must instead look at the type
8564 associated with the FUNCTION_DECL. This will be a node of type
8565 FUNCTION_TYPE. If the chain of type nodes hanging off of this
8566 FUNCTION_TYPE node ends with a void_type_node then there should *not* be
8567 an ellipsis at the end. */
8568 push_decl_scope (decl);
8570 /* In the case where we are describing a mere function declaration, all we
8571 need to do here (and all we *can* do here) is to describe the *types* of
8572 its formal parameters. */
8573 if (debug_info_level <= DINFO_LEVEL_TERSE)
8575 else if (declaration)
8576 gen_formal_types_die (TREE_TYPE (decl), subr_die);
8579 /* Generate DIEs to represent all known formal parameters */
8580 register tree arg_decls = DECL_ARGUMENTS (decl);
8583 /* When generating DIEs, generate the unspecified_parameters DIE
8584 instead if we come across the arg "__builtin_va_alist" */
8585 for (parm = arg_decls; parm; parm = TREE_CHAIN (parm))
8586 if (TREE_CODE (parm) == PARM_DECL)
8588 if (DECL_NAME (parm)
8589 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (parm)),
8590 "__builtin_va_alist"))
8591 gen_unspecified_parameters_die (parm, subr_die);
8593 gen_decl_die (parm, subr_die);
8596 /* Decide whether we need a unspecified_parameters DIE at the end.
8597 There are 2 more cases to do this for: 1) the ansi ... declaration -
8598 this is detectable when the end of the arg list is not a
8599 void_type_node 2) an unprototyped function declaration (not a
8600 definition). This just means that we have no info about the
8601 parameters at all. */
8602 fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
8603 if (fn_arg_types != NULL)
8605 /* this is the prototyped case, check for ... */
8606 if (TREE_VALUE (tree_last (fn_arg_types)) != void_type_node)
8607 gen_unspecified_parameters_die (decl, subr_die);
8609 else if (DECL_INITIAL (decl) == NULL_TREE)
8610 gen_unspecified_parameters_die (decl, subr_die);
8613 /* Output Dwarf info for all of the stuff within the body of the function
8614 (if it has one - it may be just a declaration). */
8615 outer_scope = DECL_INITIAL (decl);
8617 /* Note that here, `outer_scope' is a pointer to the outermost BLOCK
8618 node created to represent a function. This outermost BLOCK actually
8619 represents the outermost binding contour for the function, i.e. the
8620 contour in which the function's formal parameters and labels get
8621 declared. Curiously, it appears that the front end doesn't actually
8622 put the PARM_DECL nodes for the current function onto the BLOCK_VARS
8623 list for this outer scope. (They are strung off of the DECL_ARGUMENTS
8624 list for the function instead.) The BLOCK_VARS list for the
8625 `outer_scope' does provide us with a list of the LABEL_DECL nodes for
8626 the function however, and we output DWARF info for those in
8627 decls_for_scope. Just within the `outer_scope' there will be a BLOCK
8628 node representing the function's outermost pair of curly braces, and
8629 any blocks used for the base and member initializers of a C++
8630 constructor function. */
8631 if (! declaration && TREE_CODE (outer_scope) != ERROR_MARK)
8633 current_function_has_inlines = 0;
8634 decls_for_scope (outer_scope, subr_die, 0);
8636 #if 0 && defined (MIPS_DEBUGGING_INFO)
8637 if (current_function_has_inlines)
8639 add_AT_flag (subr_die, DW_AT_MIPS_has_inlines, 1);
8640 if (! comp_unit_has_inlines)
8642 add_AT_flag (comp_unit_die, DW_AT_MIPS_has_inlines, 1);
8643 comp_unit_has_inlines = 1;
8652 /* Generate a DIE to represent a declared data object. */
8655 gen_variable_die (decl, context_die)
8657 register dw_die_ref context_die;
8659 register tree origin = decl_ultimate_origin (decl);
8660 register dw_die_ref var_die = new_die (DW_TAG_variable, context_die);
8662 dw_die_ref old_die = lookup_decl_die (decl);
8664 = (DECL_EXTERNAL (decl)
8665 || current_function_decl != decl_function_context (decl)
8666 || context_die->die_tag == DW_TAG_structure_type
8667 || context_die->die_tag == DW_TAG_union_type);
8670 add_abstract_origin_attribute (var_die, origin);
8671 /* Loop unrolling can create multiple blocks that refer to the same
8672 static variable, so we must test for the DW_AT_declaration flag. */
8673 /* ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
8674 copy decls and set the DECL_ABSTRACT flag on them instead of
8676 else if (old_die && TREE_STATIC (decl)
8677 && get_AT_flag (old_die, DW_AT_declaration) == 1)
8679 /* ??? This is an instantiation of a C++ class level static. */
8680 add_AT_die_ref (var_die, DW_AT_specification, old_die);
8681 if (DECL_NAME (decl))
8683 register unsigned file_index
8684 = lookup_filename (DECL_SOURCE_FILE (decl));
8686 if (get_AT_unsigned (old_die, DW_AT_decl_file) != file_index)
8687 add_AT_unsigned (var_die, DW_AT_decl_file, file_index);
8689 if (get_AT_unsigned (old_die, DW_AT_decl_line)
8690 != (unsigned)DECL_SOURCE_LINE (decl))
8692 add_AT_unsigned (var_die, DW_AT_decl_line,
8693 DECL_SOURCE_LINE (decl));
8698 add_name_and_src_coords_attributes (var_die, decl);
8699 add_type_attribute (var_die, TREE_TYPE (decl),
8700 TREE_READONLY (decl),
8701 TREE_THIS_VOLATILE (decl), context_die);
8703 if (TREE_PUBLIC (decl))
8704 add_AT_flag (var_die, DW_AT_external, 1);
8706 if (DECL_ARTIFICIAL (decl))
8707 add_AT_flag (var_die, DW_AT_artificial, 1);
8709 if (TREE_PROTECTED (decl))
8710 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_protected);
8712 else if (TREE_PRIVATE (decl))
8713 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_private);
8717 add_AT_flag (var_die, DW_AT_declaration, 1);
8719 if ((declaration && decl_class_context (decl)) || DECL_ABSTRACT (decl))
8720 equate_decl_number_to_die (decl, var_die);
8722 if (! declaration && ! DECL_ABSTRACT (decl))
8724 equate_decl_number_to_die (decl, var_die);
8725 add_location_or_const_value_attribute (var_die, decl);
8726 add_pubname (decl, var_die);
8730 /* Generate a DIE to represent a label identifier. */
8733 gen_label_die (decl, context_die)
8735 register dw_die_ref context_die;
8737 register tree origin = decl_ultimate_origin (decl);
8738 register dw_die_ref lbl_die = new_die (DW_TAG_label, context_die);
8740 char label[MAX_ARTIFICIAL_LABEL_BYTES];
8741 char label2[MAX_ARTIFICIAL_LABEL_BYTES];
8744 add_abstract_origin_attribute (lbl_die, origin);
8746 add_name_and_src_coords_attributes (lbl_die, decl);
8748 if (DECL_ABSTRACT (decl))
8749 equate_decl_number_to_die (decl, lbl_die);
8752 insn = DECL_RTL (decl);
8754 /* Deleted labels are programmer specified labels which have been
8755 eliminated because of various optimisations. We still emit them
8756 here so that it is possible to put breakpoints on them. */
8757 if (GET_CODE (insn) == CODE_LABEL
8758 || ((GET_CODE (insn) == NOTE
8759 && NOTE_LINE_NUMBER (insn) == NOTE_INSN_DELETED_LABEL)))
8761 /* When optimization is enabled (via -O) some parts of the compiler
8762 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
8763 represent source-level labels which were explicitly declared by
8764 the user. This really shouldn't be happening though, so catch
8765 it if it ever does happen. */
8766 if (INSN_DELETED_P (insn))
8769 sprintf (label2, INSN_LABEL_FMT, current_funcdef_number);
8770 ASM_GENERATE_INTERNAL_LABEL (label, label2,
8771 (unsigned) INSN_UID (insn));
8772 add_AT_lbl_id (lbl_die, DW_AT_low_pc, label);
8777 /* Generate a DIE for a lexical block. */
8780 gen_lexical_block_die (stmt, context_die, depth)
8782 register dw_die_ref context_die;
8785 register dw_die_ref stmt_die = new_die (DW_TAG_lexical_block, context_die);
8786 char label[MAX_ARTIFICIAL_LABEL_BYTES];
8788 if (! BLOCK_ABSTRACT (stmt))
8790 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
8792 add_AT_lbl_id (stmt_die, DW_AT_low_pc, label);
8793 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL, next_block_number);
8794 add_AT_lbl_id (stmt_die, DW_AT_high_pc, label);
8797 push_decl_scope (stmt);
8798 decls_for_scope (stmt, stmt_die, depth);
8802 /* Generate a DIE for an inlined subprogram. */
8805 gen_inlined_subroutine_die (stmt, context_die, depth)
8807 register dw_die_ref context_die;
8810 if (! BLOCK_ABSTRACT (stmt))
8812 register dw_die_ref subr_die
8813 = new_die (DW_TAG_inlined_subroutine, context_die);
8814 register tree decl = block_ultimate_origin (stmt);
8815 char label[MAX_ARTIFICIAL_LABEL_BYTES];
8817 add_abstract_origin_attribute (subr_die, decl);
8818 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
8820 add_AT_lbl_id (subr_die, DW_AT_low_pc, label);
8821 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL, next_block_number);
8822 add_AT_lbl_id (subr_die, DW_AT_high_pc, label);
8823 push_decl_scope (decl);
8824 decls_for_scope (stmt, subr_die, depth);
8826 current_function_has_inlines = 1;
8830 /* Generate a DIE for a field in a record, or structure. */
8833 gen_field_die (decl, context_die)
8835 register dw_die_ref context_die;
8837 register dw_die_ref decl_die = new_die (DW_TAG_member, context_die);
8839 add_name_and_src_coords_attributes (decl_die, decl);
8840 add_type_attribute (decl_die, member_declared_type (decl),
8841 TREE_READONLY (decl), TREE_THIS_VOLATILE (decl),
8844 /* If this is a bit field... */
8845 if (DECL_BIT_FIELD_TYPE (decl))
8847 add_byte_size_attribute (decl_die, decl);
8848 add_bit_size_attribute (decl_die, decl);
8849 add_bit_offset_attribute (decl_die, decl);
8852 if (TREE_CODE (DECL_FIELD_CONTEXT (decl)) != UNION_TYPE)
8853 add_data_member_location_attribute (decl_die, decl);
8855 if (DECL_ARTIFICIAL (decl))
8856 add_AT_flag (decl_die, DW_AT_artificial, 1);
8858 if (TREE_PROTECTED (decl))
8859 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_protected);
8861 else if (TREE_PRIVATE (decl))
8862 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_private);
8866 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
8867 Use modified_type_die instead.
8868 We keep this code here just in case these types of DIEs may be needed to
8869 represent certain things in other languages (e.g. Pascal) someday. */
8871 gen_pointer_type_die (type, context_die)
8873 register dw_die_ref context_die;
8875 register dw_die_ref ptr_die
8876 = new_die (DW_TAG_pointer_type, scope_die_for (type, context_die));
8878 equate_type_number_to_die (type, ptr_die);
8879 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
8880 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
8883 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
8884 Use modified_type_die instead.
8885 We keep this code here just in case these types of DIEs may be needed to
8886 represent certain things in other languages (e.g. Pascal) someday. */
8888 gen_reference_type_die (type, context_die)
8890 register dw_die_ref context_die;
8892 register dw_die_ref ref_die
8893 = new_die (DW_TAG_reference_type, scope_die_for (type, context_die));
8895 equate_type_number_to_die (type, ref_die);
8896 add_type_attribute (ref_die, TREE_TYPE (type), 0, 0, context_die);
8897 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
8901 /* Generate a DIE for a pointer to a member type. */
8903 gen_ptr_to_mbr_type_die (type, context_die)
8905 register dw_die_ref context_die;
8907 register dw_die_ref ptr_die
8908 = new_die (DW_TAG_ptr_to_member_type, scope_die_for (type, context_die));
8910 equate_type_number_to_die (type, ptr_die);
8911 add_AT_die_ref (ptr_die, DW_AT_containing_type,
8912 lookup_type_die (TYPE_OFFSET_BASETYPE (type)));
8913 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
8916 /* Generate the DIE for the compilation unit. */
8919 gen_compile_unit_die (main_input_filename)
8920 register char *main_input_filename;
8923 char *wd = getpwd ();
8925 comp_unit_die = new_die (DW_TAG_compile_unit, NULL);
8926 add_name_attribute (comp_unit_die, main_input_filename);
8929 add_AT_string (comp_unit_die, DW_AT_comp_dir, wd);
8931 sprintf (producer, "%s %s", language_string, version_string);
8933 #ifdef MIPS_DEBUGGING_INFO
8934 /* The MIPS/SGI compilers place the 'cc' command line options in the producer
8935 string. The SGI debugger looks for -g, -g1, -g2, or -g3; if they do
8936 not appear in the producer string, the debugger reaches the conclusion
8937 that the object file is stripped and has no debugging information.
8938 To get the MIPS/SGI debugger to believe that there is debugging
8939 information in the object file, we add a -g to the producer string. */
8940 if (debug_info_level > DINFO_LEVEL_TERSE)
8941 strcat (producer, " -g");
8944 add_AT_string (comp_unit_die, DW_AT_producer, producer);
8946 if (strcmp (language_string, "GNU C++") == 0)
8947 add_AT_unsigned (comp_unit_die, DW_AT_language, DW_LANG_C_plus_plus);
8949 else if (strcmp (language_string, "GNU Ada") == 0)
8950 add_AT_unsigned (comp_unit_die, DW_AT_language, DW_LANG_Ada83);
8952 else if (strcmp (language_string, "GNU F77") == 0)
8953 add_AT_unsigned (comp_unit_die, DW_AT_language, DW_LANG_Fortran77);
8955 else if (strcmp (language_string, "GNU Pascal") == 0)
8956 add_AT_unsigned (comp_unit_die, DW_AT_language, DW_LANG_Pascal83);
8958 else if (flag_traditional)
8959 add_AT_unsigned (comp_unit_die, DW_AT_language, DW_LANG_C);
8962 add_AT_unsigned (comp_unit_die, DW_AT_language, DW_LANG_C89);
8964 #if 0 /* unimplemented */
8965 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
8966 add_AT_unsigned (comp_unit_die, DW_AT_macro_info, 0);
8970 /* Generate a DIE for a string type. */
8973 gen_string_type_die (type, context_die)
8975 register dw_die_ref context_die;
8977 register dw_die_ref type_die
8978 = new_die (DW_TAG_string_type, scope_die_for (type, context_die));
8980 equate_type_number_to_die (type, type_die);
8982 /* Fudge the string length attribute for now. */
8984 /* TODO: add string length info.
8985 string_length_attribute (TYPE_MAX_VALUE (TYPE_DOMAIN (type)));
8986 bound_representation (upper_bound, 0, 'u'); */
8989 /* Generate the DIE for a base class. */
8992 gen_inheritance_die (binfo, context_die)
8993 register tree binfo;
8994 register dw_die_ref context_die;
8996 dw_die_ref die = new_die (DW_TAG_inheritance, context_die);
8998 add_type_attribute (die, BINFO_TYPE (binfo), 0, 0, context_die);
8999 add_data_member_location_attribute (die, binfo);
9001 if (TREE_VIA_VIRTUAL (binfo))
9002 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
9003 if (TREE_VIA_PUBLIC (binfo))
9004 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public);
9005 else if (TREE_VIA_PROTECTED (binfo))
9006 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected);
9009 /* Generate a DIE for a class member. */
9012 gen_member_die (type, context_die)
9014 register dw_die_ref context_die;
9016 register tree member;
9018 /* If this is not an incomplete type, output descriptions of each of its
9019 members. Note that as we output the DIEs necessary to represent the
9020 members of this record or union type, we will also be trying to output
9021 DIEs to represent the *types* of those members. However the `type'
9022 function (above) will specifically avoid generating type DIEs for member
9023 types *within* the list of member DIEs for this (containing) type execpt
9024 for those types (of members) which are explicitly marked as also being
9025 members of this (containing) type themselves. The g++ front- end can
9026 force any given type to be treated as a member of some other
9027 (containing) type by setting the TYPE_CONTEXT of the given (member) type
9028 to point to the TREE node representing the appropriate (containing)
9031 /* First output info about the base classes. */
9032 if (TYPE_BINFO (type) && TYPE_BINFO_BASETYPES (type))
9034 register tree bases = TYPE_BINFO_BASETYPES (type);
9035 register int n_bases = TREE_VEC_LENGTH (bases);
9038 for (i = 0; i < n_bases; i++)
9039 gen_inheritance_die (TREE_VEC_ELT (bases, i), context_die);
9042 /* Now output info about the data members and type members. */
9043 for (member = TYPE_FIELDS (type); member; member = TREE_CHAIN (member))
9044 gen_decl_die (member, context_die);
9046 /* Now output info about the function members (if any). */
9047 for (member = TYPE_METHODS (type); member; member = TREE_CHAIN (member))
9048 gen_decl_die (member, context_die);
9051 /* Generate a DIE for a structure or union type. */
9054 gen_struct_or_union_type_die (type, context_die)
9056 register dw_die_ref context_die;
9058 register dw_die_ref type_die = lookup_type_die (type);
9059 register dw_die_ref scope_die = 0;
9060 register int nested = 0;
9062 if (type_die && ! TYPE_SIZE (type))
9065 if (TYPE_CONTEXT (type) != NULL_TREE
9066 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type)))
9069 scope_die = scope_die_for (type, context_die);
9071 if (! type_die || (nested && scope_die == comp_unit_die))
9072 /* First occurrence of type or toplevel definition of nested class. */
9074 register dw_die_ref old_die = type_die;
9076 type_die = new_die (TREE_CODE (type) == RECORD_TYPE
9077 ? DW_TAG_structure_type : DW_TAG_union_type,
9079 equate_type_number_to_die (type, type_die);
9080 add_name_attribute (type_die, type_tag (type));
9082 add_AT_die_ref (type_die, DW_AT_specification, old_die);
9085 remove_AT (type_die, DW_AT_declaration);
9087 /* If we're not in the right context to be defining this type, defer to
9088 avoid tricky recursion. */
9089 if (TYPE_SIZE (type) && decl_scope_depth > 0 && scope_die == comp_unit_die)
9091 add_AT_flag (type_die, DW_AT_declaration, 1);
9094 /* If this type has been completed, then give it a byte_size attribute and
9095 then give a list of members. */
9096 else if (TYPE_SIZE (type))
9098 /* Prevent infinite recursion in cases where the type of some member of
9099 this type is expressed in terms of this type itself. */
9100 TREE_ASM_WRITTEN (type) = 1;
9101 add_byte_size_attribute (type_die, type);
9102 if (TYPE_STUB_DECL (type) != NULL_TREE)
9103 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
9105 /* If the first reference to this type was as the return type of an
9106 inline function, then it may not have a parent. Fix this now. */
9107 if (type_die->die_parent == NULL)
9108 add_child_die (scope_die, type_die);
9110 push_decl_scope (type);
9111 gen_member_die (type, type_die);
9114 /* GNU extension: Record what type our vtable lives in. */
9115 if (TYPE_VFIELD (type))
9117 tree vtype = DECL_FCONTEXT (TYPE_VFIELD (type));
9119 gen_type_die (vtype, context_die);
9120 add_AT_die_ref (type_die, DW_AT_containing_type,
9121 lookup_type_die (vtype));
9126 add_AT_flag (type_die, DW_AT_declaration, 1);
9128 /* We can't do this for function-local types, and we don't need to. */
9129 if (TREE_PERMANENT (type))
9130 add_incomplete_type (type);
9134 /* Generate a DIE for a subroutine _type_. */
9137 gen_subroutine_type_die (type, context_die)
9139 register dw_die_ref context_die;
9141 register tree return_type = TREE_TYPE (type);
9142 register dw_die_ref subr_die
9143 = new_die (DW_TAG_subroutine_type, scope_die_for (type, context_die));
9145 equate_type_number_to_die (type, subr_die);
9146 add_prototyped_attribute (subr_die, type);
9147 add_type_attribute (subr_die, return_type, 0, 0, context_die);
9148 gen_formal_types_die (type, subr_die);
9151 /* Generate a DIE for a type definition */
9154 gen_typedef_die (decl, context_die)
9156 register dw_die_ref context_die;
9158 register dw_die_ref type_die;
9159 register tree origin;
9161 if (TREE_ASM_WRITTEN (decl))
9163 TREE_ASM_WRITTEN (decl) = 1;
9165 type_die = new_die (DW_TAG_typedef, scope_die_for (decl, context_die));
9166 origin = decl_ultimate_origin (decl);
9168 add_abstract_origin_attribute (type_die, origin);
9172 add_name_and_src_coords_attributes (type_die, decl);
9173 if (DECL_ORIGINAL_TYPE (decl))
9175 type = DECL_ORIGINAL_TYPE (decl);
9176 equate_type_number_to_die (TREE_TYPE (decl), type_die);
9179 type = TREE_TYPE (decl);
9180 add_type_attribute (type_die, type, TREE_READONLY (decl),
9181 TREE_THIS_VOLATILE (decl), context_die);
9184 if (DECL_ABSTRACT (decl))
9185 equate_decl_number_to_die (decl, type_die);
9188 /* Generate a type description DIE. */
9191 gen_type_die (type, context_die)
9193 register dw_die_ref context_die;
9195 if (type == NULL_TREE || type == error_mark_node)
9198 /* We are going to output a DIE to represent the unqualified version of
9199 this type (i.e. without any const or volatile qualifiers) so get the
9200 main variant (i.e. the unqualified version) of this type now. */
9201 type = type_main_variant (type);
9203 if (TREE_ASM_WRITTEN (type))
9206 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
9207 && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
9209 TREE_ASM_WRITTEN (type) = 1;
9210 gen_decl_die (TYPE_NAME (type), context_die);
9214 switch (TREE_CODE (type))
9220 case REFERENCE_TYPE:
9221 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This
9222 ensures that the gen_type_die recursion will terminate even if the
9223 type is recursive. Recursive types are possible in Ada. */
9224 /* ??? We could perhaps do this for all types before the switch
9226 TREE_ASM_WRITTEN (type) = 1;
9228 /* For these types, all that is required is that we output a DIE (or a
9229 set of DIEs) to represent the "basis" type. */
9230 gen_type_die (TREE_TYPE (type), context_die);
9234 /* This code is used for C++ pointer-to-data-member types.
9235 Output a description of the relevant class type. */
9236 gen_type_die (TYPE_OFFSET_BASETYPE (type), context_die);
9238 /* Output a description of the type of the object pointed to. */
9239 gen_type_die (TREE_TYPE (type), context_die);
9241 /* Now output a DIE to represent this pointer-to-data-member type
9243 gen_ptr_to_mbr_type_die (type, context_die);
9247 gen_type_die (TYPE_DOMAIN (type), context_die);
9248 gen_set_type_die (type, context_die);
9252 gen_type_die (TREE_TYPE (type), context_die);
9253 abort (); /* No way to represent these in Dwarf yet! */
9257 /* Force out return type (in case it wasn't forced out already). */
9258 gen_type_die (TREE_TYPE (type), context_die);
9259 gen_subroutine_type_die (type, context_die);
9263 /* Force out return type (in case it wasn't forced out already). */
9264 gen_type_die (TREE_TYPE (type), context_die);
9265 gen_subroutine_type_die (type, context_die);
9269 if (TYPE_STRING_FLAG (type) && TREE_CODE (TREE_TYPE (type)) == CHAR_TYPE)
9271 gen_type_die (TREE_TYPE (type), context_die);
9272 gen_string_type_die (type, context_die);
9275 gen_array_type_die (type, context_die);
9281 case QUAL_UNION_TYPE:
9282 /* If this is a nested type whose containing class hasn't been
9283 written out yet, writing it out will cover this one, too. */
9284 if (TYPE_CONTEXT (type)
9285 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
9286 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
9288 gen_type_die (TYPE_CONTEXT (type), context_die);
9290 if (TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
9293 /* If that failed, attach ourselves to the stub. */
9294 push_decl_scope (TYPE_CONTEXT (type));
9295 context_die = lookup_type_die (TYPE_CONTEXT (type));
9298 if (TREE_CODE (type) == ENUMERAL_TYPE)
9299 gen_enumeration_type_die (type, context_die);
9301 gen_struct_or_union_type_die (type, context_die);
9303 if (TYPE_CONTEXT (type)
9304 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
9305 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
9308 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
9309 it up if it is ever completed. gen_*_type_die will set it for us
9310 when appropriate. */
9319 /* No DIEs needed for fundamental types. */
9323 /* No Dwarf representation currently defined. */
9330 TREE_ASM_WRITTEN (type) = 1;
9333 /* Generate a DIE for a tagged type instantiation. */
9336 gen_tagged_type_instantiation_die (type, context_die)
9338 register dw_die_ref context_die;
9340 if (type == NULL_TREE || type == error_mark_node)
9343 /* We are going to output a DIE to represent the unqualified version of
9344 this type (i.e. without any const or volatile qualifiers) so make sure
9345 that we have the main variant (i.e. the unqualified version) of this
9347 if (type != type_main_variant (type)
9348 || !TREE_ASM_WRITTEN (type))
9351 switch (TREE_CODE (type))
9357 gen_inlined_enumeration_type_die (type, context_die);
9361 gen_inlined_structure_type_die (type, context_die);
9365 case QUAL_UNION_TYPE:
9366 gen_inlined_union_type_die (type, context_die);
9374 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
9375 things which are local to the given block. */
9378 gen_block_die (stmt, context_die, depth)
9380 register dw_die_ref context_die;
9383 register int must_output_die = 0;
9384 register tree origin;
9386 register enum tree_code origin_code;
9388 /* Ignore blocks never really used to make RTL. */
9390 if (stmt == NULL_TREE || !TREE_USED (stmt))
9393 /* Determine the "ultimate origin" of this block. This block may be an
9394 inlined instance of an inlined instance of inline function, so we have
9395 to trace all of the way back through the origin chain to find out what
9396 sort of node actually served as the original seed for the creation of
9397 the current block. */
9398 origin = block_ultimate_origin (stmt);
9399 origin_code = (origin != NULL) ? TREE_CODE (origin) : ERROR_MARK;
9401 /* Determine if we need to output any Dwarf DIEs at all to represent this
9403 if (origin_code == FUNCTION_DECL)
9404 /* The outer scopes for inlinings *must* always be represented. We
9405 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */
9406 must_output_die = 1;
9409 /* In the case where the current block represents an inlining of the
9410 "body block" of an inline function, we must *NOT* output any DIE for
9411 this block because we have already output a DIE to represent the
9412 whole inlined function scope and the "body block" of any function
9413 doesn't really represent a different scope according to ANSI C
9414 rules. So we check here to make sure that this block does not
9415 represent a "body block inlining" before trying to set the
9416 `must_output_die' flag. */
9417 if (! is_body_block (origin ? origin : stmt))
9419 /* Determine if this block directly contains any "significant"
9420 local declarations which we will need to output DIEs for. */
9421 if (debug_info_level > DINFO_LEVEL_TERSE)
9422 /* We are not in terse mode so *any* local declaration counts
9423 as being a "significant" one. */
9424 must_output_die = (BLOCK_VARS (stmt) != NULL);
9426 /* We are in terse mode, so only local (nested) function
9427 definitions count as "significant" local declarations. */
9428 for (decl = BLOCK_VARS (stmt);
9429 decl != NULL; decl = TREE_CHAIN (decl))
9430 if (TREE_CODE (decl) == FUNCTION_DECL
9431 && DECL_INITIAL (decl))
9433 must_output_die = 1;
9439 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
9440 DIE for any block which contains no significant local declarations at
9441 all. Rather, in such cases we just call `decls_for_scope' so that any
9442 needed Dwarf info for any sub-blocks will get properly generated. Note
9443 that in terse mode, our definition of what constitutes a "significant"
9444 local declaration gets restricted to include only inlined function
9445 instances and local (nested) function definitions. */
9446 if (must_output_die)
9448 if (origin_code == FUNCTION_DECL)
9449 gen_inlined_subroutine_die (stmt, context_die, depth);
9451 gen_lexical_block_die (stmt, context_die, depth);
9454 decls_for_scope (stmt, context_die, depth);
9457 /* Generate all of the decls declared within a given scope and (recursively)
9458 all of its sub-blocks. */
9461 decls_for_scope (stmt, context_die, depth)
9463 register dw_die_ref context_die;
9467 register tree subblocks;
9469 /* Ignore blocks never really used to make RTL. */
9470 if (stmt == NULL_TREE || ! TREE_USED (stmt))
9473 if (!BLOCK_ABSTRACT (stmt) && depth > 0)
9474 next_block_number++;
9476 /* Output the DIEs to represent all of the data objects and typedefs
9477 declared directly within this block but not within any nested
9478 sub-blocks. Also, nested function and tag DIEs have been
9479 generated with a parent of NULL; fix that up now. */
9480 for (decl = BLOCK_VARS (stmt);
9481 decl != NULL; decl = TREE_CHAIN (decl))
9483 register dw_die_ref die;
9485 if (TREE_CODE (decl) == FUNCTION_DECL)
9486 die = lookup_decl_die (decl);
9487 else if (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl))
9488 die = lookup_type_die (TREE_TYPE (decl));
9492 if (die != NULL && die->die_parent == NULL)
9493 add_child_die (context_die, die);
9495 gen_decl_die (decl, context_die);
9498 /* Output the DIEs to represent all sub-blocks (and the items declared
9499 therein) of this block. */
9500 for (subblocks = BLOCK_SUBBLOCKS (stmt);
9502 subblocks = BLOCK_CHAIN (subblocks))
9503 gen_block_die (subblocks, context_die, depth + 1);
9506 /* Is this a typedef we can avoid emitting? */
9509 is_redundant_typedef (decl)
9512 if (TYPE_DECL_IS_STUB (decl))
9515 if (DECL_ARTIFICIAL (decl)
9516 && DECL_CONTEXT (decl)
9517 && is_tagged_type (DECL_CONTEXT (decl))
9518 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl))) == TYPE_DECL
9519 && DECL_NAME (decl) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))))
9520 /* Also ignore the artificial member typedef for the class name. */
9526 /* Generate Dwarf debug information for a decl described by DECL. */
9529 gen_decl_die (decl, context_die)
9531 register dw_die_ref context_die;
9533 register tree origin;
9535 /* Make a note of the decl node we are going to be working on. We may need
9536 to give the user the source coordinates of where it appeared in case we
9537 notice (later on) that something about it looks screwy. */
9538 dwarf_last_decl = decl;
9540 if (TREE_CODE (decl) == ERROR_MARK)
9543 /* If this ..._DECL node is marked to be ignored, then ignore it. But don't
9544 ignore a function definition, since that would screw up our count of
9545 blocks, and that in turn will completely screw up the labels we will
9546 reference in subsequent DW_AT_low_pc and DW_AT_high_pc attributes (for
9547 subsequent blocks). */
9548 if (DECL_IGNORED_P (decl) && TREE_CODE (decl) != FUNCTION_DECL)
9551 switch (TREE_CODE (decl))
9554 /* The individual enumerators of an enum type get output when we output
9555 the Dwarf representation of the relevant enum type itself. */
9559 /* Don't output any DIEs to represent mere function declarations,
9560 unless they are class members or explicit block externs. */
9561 if (DECL_INITIAL (decl) == NULL_TREE && DECL_CONTEXT (decl) == NULL_TREE
9562 && (current_function_decl == NULL_TREE || ! DECL_ARTIFICIAL (decl)))
9565 if (debug_info_level > DINFO_LEVEL_TERSE)
9567 /* Before we describe the FUNCTION_DECL itself, make sure that we
9568 have described its return type. */
9569 gen_type_die (TREE_TYPE (TREE_TYPE (decl)), context_die);
9571 /* And its containing type. */
9572 origin = decl_class_context (decl);
9573 if (origin != NULL_TREE)
9574 gen_type_die (origin, context_die);
9576 /* And its virtual context. */
9577 if (DECL_VINDEX (decl) != NULL_TREE)
9578 gen_type_die (DECL_CONTEXT (decl), context_die);
9581 /* Now output a DIE to represent the function itself. */
9582 gen_subprogram_die (decl, context_die);
9586 /* If we are in terse mode, don't generate any DIEs to represent any
9588 if (debug_info_level <= DINFO_LEVEL_TERSE)
9591 /* In the special case of a TYPE_DECL node representing the
9592 declaration of some type tag, if the given TYPE_DECL is marked as
9593 having been instantiated from some other (original) TYPE_DECL node
9594 (e.g. one which was generated within the original definition of an
9595 inline function) we have to generate a special (abbreviated)
9596 DW_TAG_structure_type, DW_TAG_union_type, or DW_TAG_enumeration_type
9598 if (TYPE_DECL_IS_STUB (decl) && DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
9600 gen_tagged_type_instantiation_die (TREE_TYPE (decl), context_die);
9604 if (is_redundant_typedef (decl))
9605 gen_type_die (TREE_TYPE (decl), context_die);
9607 /* Output a DIE to represent the typedef itself. */
9608 gen_typedef_die (decl, context_die);
9612 if (debug_info_level >= DINFO_LEVEL_NORMAL)
9613 gen_label_die (decl, context_die);
9617 /* If we are in terse mode, don't generate any DIEs to represent any
9618 variable declarations or definitions. */
9619 if (debug_info_level <= DINFO_LEVEL_TERSE)
9622 /* Output any DIEs that are needed to specify the type of this data
9624 gen_type_die (TREE_TYPE (decl), context_die);
9626 /* And its containing type. */
9627 origin = decl_class_context (decl);
9628 if (origin != NULL_TREE)
9629 gen_type_die (origin, context_die);
9631 /* Now output the DIE to represent the data object itself. This gets
9632 complicated because of the possibility that the VAR_DECL really
9633 represents an inlined instance of a formal parameter for an inline
9635 origin = decl_ultimate_origin (decl);
9636 if (origin != NULL_TREE && TREE_CODE (origin) == PARM_DECL)
9637 gen_formal_parameter_die (decl, context_die);
9639 gen_variable_die (decl, context_die);
9643 /* Ignore the nameless fields that are used to skip bits, but
9644 handle C++ anonymous unions. */
9645 if (DECL_NAME (decl) != NULL_TREE
9646 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE)
9648 gen_type_die (member_declared_type (decl), context_die);
9649 gen_field_die (decl, context_die);
9654 gen_type_die (TREE_TYPE (decl), context_die);
9655 gen_formal_parameter_die (decl, context_die);
9663 /* Write the debugging output for DECL. */
9666 dwarf2out_decl (decl)
9669 register dw_die_ref context_die = comp_unit_die;
9671 if (TREE_CODE (decl) == ERROR_MARK)
9674 /* If this ..._DECL node is marked to be ignored, then ignore it. We gotta
9675 hope that the node in question doesn't represent a function definition.
9676 If it does, then totally ignoring it is bound to screw up our count of
9677 blocks, and that in turn will completely screw up the labels we will
9678 reference in subsequent DW_AT_low_pc and DW_AT_high_pc attributes (for
9679 subsequent blocks). (It's too bad that BLOCK nodes don't carry their
9680 own sequence numbers with them!) */
9681 if (DECL_IGNORED_P (decl))
9683 if (TREE_CODE (decl) == FUNCTION_DECL
9684 && DECL_INITIAL (decl) != NULL)
9690 switch (TREE_CODE (decl))
9693 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration of a
9694 builtin function. Explicit programmer-supplied declarations of
9695 these same functions should NOT be ignored however. */
9696 if (DECL_EXTERNAL (decl) && DECL_FUNCTION_CODE (decl))
9699 /* What we would really like to do here is to filter out all mere
9700 file-scope declarations of file-scope functions which are never
9701 referenced later within this translation unit (and keep all of ones
9702 that *are* referenced later on) but we aren't clairvoyant, so we have
9703 no idea which functions will be referenced in the future (i.e. later
9704 on within the current translation unit). So here we just ignore all
9705 file-scope function declarations which are not also definitions. If
9706 and when the debugger needs to know something about these functions,
9707 it wil have to hunt around and find the DWARF information associated
9708 with the definition of the function. Note that we can't just check
9709 `DECL_EXTERNAL' to find out which FUNCTION_DECL nodes represent
9710 definitions and which ones represent mere declarations. We have to
9711 check `DECL_INITIAL' instead. That's because the C front-end
9712 supports some weird semantics for "extern inline" function
9713 definitions. These can get inlined within the current translation
9714 unit (an thus, we need to generate DWARF info for their abstract
9715 instances so that the DWARF info for the concrete inlined instances
9716 can have something to refer to) but the compiler never generates any
9717 out-of-lines instances of such things (despite the fact that they
9718 *are* definitions). The important point is that the C front-end
9719 marks these "extern inline" functions as DECL_EXTERNAL, but we need
9720 to generate DWARF for them anyway. Note that the C++ front-end also
9721 plays some similar games for inline function definitions appearing
9722 within include files which also contain
9723 `#pragma interface' pragmas. */
9724 if (DECL_INITIAL (decl) == NULL_TREE)
9727 /* If we're a nested function, initially use a parent of NULL; if we're
9728 a plain function, this will be fixed up in decls_for_scope. If
9729 we're a method, it will be ignored, since we already have a DIE. */
9730 if (decl_function_context (decl))
9736 /* Ignore this VAR_DECL if it refers to a file-scope extern data object
9737 declaration and if the declaration was never even referenced from
9738 within this entire compilation unit. We suppress these DIEs in
9739 order to save space in the .debug section (by eliminating entries
9740 which are probably useless). Note that we must not suppress
9741 block-local extern declarations (whether used or not) because that
9742 would screw-up the debugger's name lookup mechanism and cause it to
9743 miss things which really ought to be in scope at a given point. */
9744 if (DECL_EXTERNAL (decl) && !TREE_USED (decl))
9747 /* If we are in terse mode, don't generate any DIEs to represent any
9748 variable declarations or definitions. */
9749 if (debug_info_level <= DINFO_LEVEL_TERSE)
9754 /* Don't bother trying to generate any DIEs to represent any of the
9755 normal built-in types for the language we are compiling. */
9756 if (DECL_SOURCE_LINE (decl) == 0)
9758 /* OK, we need to generate one for `bool' so GDB knows what type
9759 comparisons have. */
9760 if ((get_AT_unsigned (comp_unit_die, DW_AT_language)
9761 == DW_LANG_C_plus_plus)
9762 && TREE_CODE (TREE_TYPE (decl)) == BOOLEAN_TYPE)
9763 modified_type_die (TREE_TYPE (decl), 0, 0, NULL);
9768 /* If we are in terse mode, don't generate any DIEs for types. */
9769 if (debug_info_level <= DINFO_LEVEL_TERSE)
9772 /* If we're a function-scope tag, initially use a parent of NULL;
9773 this will be fixed up in decls_for_scope. */
9774 if (decl_function_context (decl))
9783 gen_decl_die (decl, context_die);
9784 output_pending_types_for_scope (comp_unit_die);
9787 /* Output a marker (i.e. a label) for the beginning of the generated code for
9791 dwarf2out_begin_block (blocknum)
9792 register unsigned blocknum;
9794 function_section (current_function_decl);
9795 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, BLOCK_BEGIN_LABEL, blocknum);
9798 /* Output a marker (i.e. a label) for the end of the generated code for a
9802 dwarf2out_end_block (blocknum)
9803 register unsigned blocknum;
9805 function_section (current_function_decl);
9806 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, BLOCK_END_LABEL, blocknum);
9809 /* Output a marker (i.e. a label) at a point in the assembly code which
9810 corresponds to a given source level label. */
9813 dwarf2out_label (insn)
9816 char label[MAX_ARTIFICIAL_LABEL_BYTES];
9818 if (debug_info_level >= DINFO_LEVEL_NORMAL)
9820 function_section (current_function_decl);
9821 sprintf (label, INSN_LABEL_FMT, current_funcdef_number);
9822 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, label,
9823 (unsigned) INSN_UID (insn));
9827 /* Lookup a filename (in the list of filenames that we know about here in
9828 dwarf2out.c) and return its "index". The index of each (known) filename is
9829 just a unique number which is associated with only that one filename.
9830 We need such numbers for the sake of generating labels
9831 (in the .debug_sfnames section) and references to those
9832 files numbers (in the .debug_srcinfo and.debug_macinfo sections).
9833 If the filename given as an argument is not found in our current list,
9834 add it to the list and assign it the next available unique index number.
9835 In order to speed up searches, we remember the index of the filename
9836 was looked up last. This handles the majority of all searches. */
9839 lookup_filename (file_name)
9840 const char *file_name;
9842 static unsigned last_file_lookup_index = 0;
9843 register unsigned i;
9845 /* Check to see if the file name that was searched on the previous call
9846 matches this file name. If so, return the index. */
9847 if (last_file_lookup_index != 0)
9848 if (strcmp (file_name, file_table[last_file_lookup_index]) == 0)
9849 return last_file_lookup_index;
9851 /* Didn't match the previous lookup, search the table */
9852 for (i = 1; i < file_table_in_use; ++i)
9853 if (strcmp (file_name, file_table[i]) == 0)
9855 last_file_lookup_index = i;
9859 /* Prepare to add a new table entry by making sure there is enough space in
9860 the table to do so. If not, expand the current table. */
9861 if (file_table_in_use == file_table_allocated)
9863 file_table_allocated += FILE_TABLE_INCREMENT;
9865 = (char **) xrealloc (file_table,
9866 file_table_allocated * sizeof (char *));
9869 /* Add the new entry to the end of the filename table. */
9870 file_table[file_table_in_use] = xstrdup (file_name);
9871 last_file_lookup_index = file_table_in_use++;
9873 return last_file_lookup_index;
9876 /* Output a label to mark the beginning of a source code line entry
9877 and record information relating to this source line, in
9878 'line_info_table' for later output of the .debug_line section. */
9881 dwarf2out_line (filename, line)
9882 register const char *filename;
9883 register unsigned line;
9885 if (debug_info_level >= DINFO_LEVEL_NORMAL)
9887 function_section (current_function_decl);
9889 if (DWARF2_ASM_LINE_DEBUG_INFO)
9891 static char *lastfile;
9893 /* Emit the .file and .loc directives understood by GNU as. */
9894 if (lastfile == 0 || strcmp (filename, lastfile))
9896 fprintf (asm_out_file, "\t.file 0 \"%s\"\n", filename);
9897 lastfile = filename;
9900 fprintf (asm_out_file, "\t.loc 0 %d 0\n", line);
9902 /* Indicate that line number info exists. */
9903 ++line_info_table_in_use;
9905 /* Indicate that multiple line number tables exist. */
9906 if (DECL_SECTION_NAME (current_function_decl))
9907 ++separate_line_info_table_in_use;
9909 else if (DECL_SECTION_NAME (current_function_decl))
9911 register dw_separate_line_info_ref line_info;
9912 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, SEPARATE_LINE_CODE_LABEL,
9913 separate_line_info_table_in_use);
9915 fprintf (asm_out_file, "\t%s line %d", ASM_COMMENT_START, line);
9916 fputc ('\n', asm_out_file);
9918 /* expand the line info table if necessary */
9919 if (separate_line_info_table_in_use
9920 == separate_line_info_table_allocated)
9922 separate_line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
9923 separate_line_info_table
9924 = (dw_separate_line_info_ref)
9925 xrealloc (separate_line_info_table,
9926 separate_line_info_table_allocated
9927 * sizeof (dw_separate_line_info_entry));
9930 /* Add the new entry at the end of the line_info_table. */
9932 = &separate_line_info_table[separate_line_info_table_in_use++];
9933 line_info->dw_file_num = lookup_filename (filename);
9934 line_info->dw_line_num = line;
9935 line_info->function = current_funcdef_number;
9939 register dw_line_info_ref line_info;
9941 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, LINE_CODE_LABEL,
9942 line_info_table_in_use);
9944 fprintf (asm_out_file, "\t%s line %d", ASM_COMMENT_START, line);
9945 fputc ('\n', asm_out_file);
9947 /* Expand the line info table if necessary. */
9948 if (line_info_table_in_use == line_info_table_allocated)
9950 line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
9952 = (dw_line_info_ref)
9953 xrealloc (line_info_table,
9954 (line_info_table_allocated
9955 * sizeof (dw_line_info_entry)));
9958 /* Add the new entry at the end of the line_info_table. */
9959 line_info = &line_info_table[line_info_table_in_use++];
9960 line_info->dw_file_num = lookup_filename (filename);
9961 line_info->dw_line_num = line;
9966 /* Record the beginning of a new source file, for later output
9967 of the .debug_macinfo section. At present, unimplemented. */
9970 dwarf2out_start_source_file (filename)
9971 register const char *filename ATTRIBUTE_UNUSED;
9975 /* Record the end of a source file, for later output
9976 of the .debug_macinfo section. At present, unimplemented. */
9979 dwarf2out_end_source_file ()
9983 /* Called from check_newline in c-parse.y. The `buffer' parameter contains
9984 the tail part of the directive line, i.e. the part which is past the
9985 initial whitespace, #, whitespace, directive-name, whitespace part. */
9988 dwarf2out_define (lineno, buffer)
9989 register unsigned lineno ATTRIBUTE_UNUSED;
9990 register const char *buffer ATTRIBUTE_UNUSED;
9992 static int initialized = 0;
9995 dwarf2out_start_source_file (primary_filename);
10000 /* Called from check_newline in c-parse.y. The `buffer' parameter contains
10001 the tail part of the directive line, i.e. the part which is past the
10002 initial whitespace, #, whitespace, directive-name, whitespace part. */
10005 dwarf2out_undef (lineno, buffer)
10006 register unsigned lineno ATTRIBUTE_UNUSED;
10007 register const char *buffer ATTRIBUTE_UNUSED;
10011 /* Set up for Dwarf output at the start of compilation. */
10014 dwarf2out_init (asm_out_file, main_input_filename)
10015 register FILE *asm_out_file;
10016 register char *main_input_filename;
10018 /* Remember the name of the primary input file. */
10019 primary_filename = main_input_filename;
10021 /* Allocate the initial hunk of the file_table. */
10022 file_table = (char **) xmalloc (FILE_TABLE_INCREMENT * sizeof (char *));
10023 bzero ((char *) file_table, FILE_TABLE_INCREMENT * sizeof (char *));
10024 file_table_allocated = FILE_TABLE_INCREMENT;
10026 /* Skip the first entry - file numbers begin at 1. */
10027 file_table_in_use = 1;
10029 /* Allocate the initial hunk of the decl_die_table. */
10031 = (dw_die_ref *) xmalloc (DECL_DIE_TABLE_INCREMENT * sizeof (dw_die_ref));
10032 bzero ((char *) decl_die_table,
10033 DECL_DIE_TABLE_INCREMENT * sizeof (dw_die_ref));
10034 decl_die_table_allocated = DECL_DIE_TABLE_INCREMENT;
10035 decl_die_table_in_use = 0;
10037 /* Allocate the initial hunk of the decl_scope_table. */
10039 = (decl_scope_node *) xmalloc (DECL_SCOPE_TABLE_INCREMENT
10040 * sizeof (decl_scope_node));
10041 bzero ((char *) decl_scope_table,
10042 DECL_SCOPE_TABLE_INCREMENT * sizeof (decl_scope_node));
10043 decl_scope_table_allocated = DECL_SCOPE_TABLE_INCREMENT;
10044 decl_scope_depth = 0;
10046 /* Allocate the initial hunk of the abbrev_die_table. */
10048 = (dw_die_ref *) xmalloc (ABBREV_DIE_TABLE_INCREMENT
10049 * sizeof (dw_die_ref));
10050 bzero ((char *) abbrev_die_table,
10051 ABBREV_DIE_TABLE_INCREMENT * sizeof (dw_die_ref));
10052 abbrev_die_table_allocated = ABBREV_DIE_TABLE_INCREMENT;
10053 /* Zero-th entry is allocated, but unused */
10054 abbrev_die_table_in_use = 1;
10056 /* Allocate the initial hunk of the line_info_table. */
10058 = (dw_line_info_ref) xmalloc (LINE_INFO_TABLE_INCREMENT
10059 * sizeof (dw_line_info_entry));
10060 bzero ((char *) line_info_table,
10061 LINE_INFO_TABLE_INCREMENT * sizeof (dw_line_info_entry));
10062 line_info_table_allocated = LINE_INFO_TABLE_INCREMENT;
10063 /* Zero-th entry is allocated, but unused */
10064 line_info_table_in_use = 1;
10066 /* Generate the initial DIE for the .debug section. Note that the (string)
10067 value given in the DW_AT_name attribute of the DW_TAG_compile_unit DIE
10068 will (typically) be a relative pathname and that this pathname should be
10069 taken as being relative to the directory from which the compiler was
10070 invoked when the given (base) source file was compiled. */
10071 gen_compile_unit_die (main_input_filename);
10073 ASM_GENERATE_INTERNAL_LABEL (text_end_label, TEXT_END_LABEL, 0);
10074 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label, ABBREV_SECTION_LABEL, 0);
10075 if (DWARF2_GENERATE_TEXT_SECTION_LABEL)
10076 ASM_GENERATE_INTERNAL_LABEL (text_section_label, TEXT_SECTION_LABEL, 0);
10078 strcpy (text_section_label, stripattributes (TEXT_SECTION));
10079 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label,
10080 DEBUG_INFO_SECTION_LABEL, 0);
10081 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label,
10082 DEBUG_LINE_SECTION_LABEL, 0);
10084 ASM_OUTPUT_SECTION (asm_out_file, ABBREV_SECTION);
10085 ASM_OUTPUT_LABEL (asm_out_file, abbrev_section_label);
10086 ASM_OUTPUT_SECTION (asm_out_file, TEXT_SECTION);
10087 if (DWARF2_GENERATE_TEXT_SECTION_LABEL)
10088 ASM_OUTPUT_LABEL (asm_out_file, text_section_label);
10089 ASM_OUTPUT_SECTION (asm_out_file, DEBUG_INFO_SECTION);
10090 ASM_OUTPUT_LABEL (asm_out_file, debug_info_section_label);
10091 ASM_OUTPUT_SECTION (asm_out_file, DEBUG_LINE_SECTION);
10092 ASM_OUTPUT_LABEL (asm_out_file, debug_line_section_label);
10095 /* Output stuff that dwarf requires at the end of every file,
10096 and generate the DWARF-2 debugging info. */
10099 dwarf2out_finish ()
10101 limbo_die_node *node, *next_node;
10105 /* Traverse the limbo die list, and add parent/child links. The only
10106 dies without parents that should be here are concrete instances of
10107 inline functions, and the comp_unit_die. We can ignore the comp_unit_die.
10108 For concrete instances, we can get the parent die from the abstract
10110 for (node = limbo_die_list; node; node = next_node)
10112 next_node = node->next;
10115 if (die->die_parent == NULL)
10117 a = get_AT (die, DW_AT_abstract_origin);
10119 add_child_die (a->dw_attr_val.v.val_die_ref->die_parent, die);
10120 else if (die == comp_unit_die)
10128 /* Walk through the list of incomplete types again, trying once more to
10129 emit full debugging info for them. */
10130 retry_incomplete_types ();
10132 /* Traverse the DIE tree and add sibling attributes to those DIE's
10133 that have children. */
10134 add_sibling_attributes (comp_unit_die);
10136 /* Output a terminator label for the .text section. */
10137 fputc ('\n', asm_out_file);
10138 ASM_OUTPUT_SECTION (asm_out_file, TEXT_SECTION);
10139 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, TEXT_END_LABEL, 0);
10142 /* Output a terminator label for the .data section. */
10143 fputc ('\n', asm_out_file);
10144 ASM_OUTPUT_SECTION (asm_out_file, DATA_SECTION);
10145 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, DATA_END_LABEL, 0);
10147 /* Output a terminator label for the .bss section. */
10148 fputc ('\n', asm_out_file);
10149 ASM_OUTPUT_SECTION (asm_out_file, BSS_SECTION);
10150 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, BSS_END_LABEL, 0);
10153 /* Output the source line correspondence table. */
10154 if (line_info_table_in_use > 1 || separate_line_info_table_in_use)
10156 if (! DWARF2_ASM_LINE_DEBUG_INFO)
10158 fputc ('\n', asm_out_file);
10159 ASM_OUTPUT_SECTION (asm_out_file, DEBUG_LINE_SECTION);
10160 output_line_info ();
10163 /* We can only use the low/high_pc attributes if all of the code
10165 if (separate_line_info_table_in_use == 0)
10167 add_AT_lbl_id (comp_unit_die, DW_AT_low_pc, text_section_label);
10168 add_AT_lbl_id (comp_unit_die, DW_AT_high_pc, text_end_label);
10171 add_AT_lbl_offset (comp_unit_die, DW_AT_stmt_list,
10172 debug_line_section_label);
10175 /* Output the abbreviation table. */
10176 fputc ('\n', asm_out_file);
10177 ASM_OUTPUT_SECTION (asm_out_file, ABBREV_SECTION);
10178 build_abbrev_table (comp_unit_die);
10179 output_abbrev_section ();
10181 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
10182 next_die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE;
10183 calc_die_sizes (comp_unit_die);
10185 /* Output debugging information. */
10186 fputc ('\n', asm_out_file);
10187 ASM_OUTPUT_SECTION (asm_out_file, DEBUG_INFO_SECTION);
10188 output_compilation_unit_header ();
10189 output_die (comp_unit_die);
10191 if (pubname_table_in_use)
10193 /* Output public names table. */
10194 fputc ('\n', asm_out_file);
10195 ASM_OUTPUT_SECTION (asm_out_file, PUBNAMES_SECTION);
10196 output_pubnames ();
10199 if (fde_table_in_use)
10201 /* Output the address range information. */
10202 fputc ('\n', asm_out_file);
10203 ASM_OUTPUT_SECTION (asm_out_file, ARANGES_SECTION);
10207 #endif /* DWARF2_DEBUGGING_INFO */