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((char *));
190 static 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));
209 /* Definitions of defaults for assembler-dependent names of various
210 pseudo-ops and section names.
211 Theses may be overridden in the tm.h file (if necessary) for a particular
214 #ifdef OBJECT_FORMAT_ELF
215 #ifndef UNALIGNED_SHORT_ASM_OP
216 #define UNALIGNED_SHORT_ASM_OP ".2byte"
218 #ifndef UNALIGNED_INT_ASM_OP
219 #define UNALIGNED_INT_ASM_OP ".4byte"
221 #ifndef UNALIGNED_DOUBLE_INT_ASM_OP
222 #define UNALIGNED_DOUBLE_INT_ASM_OP ".8byte"
224 #endif /* OBJECT_FORMAT_ELF */
227 #define ASM_BYTE_OP ".byte"
230 /* Data and reference forms for relocatable data. */
231 #define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
232 #define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
234 /* Pseudo-op for defining a new section. */
235 #ifndef SECTION_ASM_OP
236 #define SECTION_ASM_OP ".section"
239 /* The default format used by the ASM_OUTPUT_SECTION macro (see below) to
240 print the SECTION_ASM_OP and the section name. The default here works for
241 almost all svr4 assemblers, except for the sparc, where the section name
242 must be enclosed in double quotes. (See sparcv4.h). */
243 #ifndef SECTION_FORMAT
244 #ifdef PUSHSECTION_FORMAT
245 #define SECTION_FORMAT PUSHSECTION_FORMAT
247 #define SECTION_FORMAT "\t%s\t%s\n"
251 #ifndef FRAME_SECTION
252 #define FRAME_SECTION ".debug_frame"
255 #ifndef FUNC_BEGIN_LABEL
256 #define FUNC_BEGIN_LABEL "LFB"
258 #ifndef FUNC_END_LABEL
259 #define FUNC_END_LABEL "LFE"
261 #define CIE_AFTER_SIZE_LABEL "LSCIE"
262 #define CIE_END_LABEL "LECIE"
263 #define CIE_LENGTH_LABEL "LLCIE"
264 #define FDE_AFTER_SIZE_LABEL "LSFDE"
265 #define FDE_END_LABEL "LEFDE"
266 #define FDE_LENGTH_LABEL "LLFDE"
268 /* Definitions of defaults for various types of primitive assembly language
269 output operations. These may be overridden from within the tm.h file,
270 but typically, that is unnecessary. */
272 #ifndef ASM_OUTPUT_SECTION
273 #define ASM_OUTPUT_SECTION(FILE, SECTION) \
274 fprintf ((FILE), SECTION_FORMAT, SECTION_ASM_OP, SECTION)
277 #ifndef ASM_OUTPUT_DWARF_DATA1
278 #define ASM_OUTPUT_DWARF_DATA1(FILE,VALUE) \
279 fprintf ((FILE), "\t%s\t0x%x", ASM_BYTE_OP, (unsigned) (VALUE))
282 #ifndef ASM_OUTPUT_DWARF_DELTA1
283 #define ASM_OUTPUT_DWARF_DELTA1(FILE,LABEL1,LABEL2) \
284 do { fprintf ((FILE), "\t%s\t", ASM_BYTE_OP); \
285 assemble_name (FILE, LABEL1); \
286 fprintf (FILE, "-"); \
287 assemble_name (FILE, LABEL2); \
291 #ifdef UNALIGNED_INT_ASM_OP
293 #ifndef UNALIGNED_OFFSET_ASM_OP
294 #define UNALIGNED_OFFSET_ASM_OP \
295 (DWARF_OFFSET_SIZE == 8 ? UNALIGNED_DOUBLE_INT_ASM_OP : UNALIGNED_INT_ASM_OP)
298 #ifndef UNALIGNED_WORD_ASM_OP
299 #define UNALIGNED_WORD_ASM_OP \
300 (PTR_SIZE == 8 ? UNALIGNED_DOUBLE_INT_ASM_OP : UNALIGNED_INT_ASM_OP)
303 #ifndef ASM_OUTPUT_DWARF_DELTA2
304 #define ASM_OUTPUT_DWARF_DELTA2(FILE,LABEL1,LABEL2) \
305 do { fprintf ((FILE), "\t%s\t", UNALIGNED_SHORT_ASM_OP); \
306 assemble_name (FILE, LABEL1); \
307 fprintf (FILE, "-"); \
308 assemble_name (FILE, LABEL2); \
312 #ifndef ASM_OUTPUT_DWARF_DELTA4
313 #define ASM_OUTPUT_DWARF_DELTA4(FILE,LABEL1,LABEL2) \
314 do { fprintf ((FILE), "\t%s\t", UNALIGNED_INT_ASM_OP); \
315 assemble_name (FILE, LABEL1); \
316 fprintf (FILE, "-"); \
317 assemble_name (FILE, LABEL2); \
321 #ifndef ASM_OUTPUT_DWARF_DELTA
322 #define ASM_OUTPUT_DWARF_DELTA(FILE,LABEL1,LABEL2) \
323 do { fprintf ((FILE), "\t%s\t", UNALIGNED_OFFSET_ASM_OP); \
324 assemble_name (FILE, LABEL1); \
325 fprintf (FILE, "-"); \
326 assemble_name (FILE, LABEL2); \
330 #ifndef ASM_OUTPUT_DWARF_ADDR_DELTA
331 #define ASM_OUTPUT_DWARF_ADDR_DELTA(FILE,LABEL1,LABEL2) \
332 do { fprintf ((FILE), "\t%s\t", UNALIGNED_WORD_ASM_OP); \
333 assemble_name (FILE, LABEL1); \
334 fprintf (FILE, "-"); \
335 assemble_name (FILE, LABEL2); \
339 #ifndef ASM_OUTPUT_DWARF_ADDR
340 #define ASM_OUTPUT_DWARF_ADDR(FILE,LABEL) \
341 do { fprintf ((FILE), "\t%s\t", UNALIGNED_WORD_ASM_OP); \
342 assemble_name (FILE, LABEL); \
346 /* ??? This macro takes an RTX in dwarfout.c and a string in dwarf2out.c.
347 We resolve the conflict by creating a new macro ASM_OUTPUT_DWARF2_ADDR_CONST
348 for ports that want to support both DWARF1 and DWARF2. This needs a better
349 solution. See also the comments in sparc/sp64-elf.h. */
350 #ifdef ASM_OUTPUT_DWARF2_ADDR_CONST
351 #undef ASM_OUTPUT_DWARF_ADDR_CONST
352 #define ASM_OUTPUT_DWARF_ADDR_CONST(FILE,ADDR) \
353 ASM_OUTPUT_DWARF2_ADDR_CONST (FILE, ADDR)
356 #ifndef ASM_OUTPUT_DWARF_ADDR_CONST
357 #define ASM_OUTPUT_DWARF_ADDR_CONST(FILE,ADDR) \
358 fprintf ((FILE), "\t%s\t%s", UNALIGNED_WORD_ASM_OP, (ADDR))
361 #ifndef ASM_OUTPUT_DWARF_OFFSET4
362 #define ASM_OUTPUT_DWARF_OFFSET4(FILE,LABEL) \
363 do { fprintf ((FILE), "\t%s\t", UNALIGNED_INT_ASM_OP); \
364 assemble_name (FILE, LABEL); \
368 #ifndef ASM_OUTPUT_DWARF_OFFSET
369 #define ASM_OUTPUT_DWARF_OFFSET(FILE,LABEL) \
370 do { fprintf ((FILE), "\t%s\t", UNALIGNED_OFFSET_ASM_OP); \
371 assemble_name (FILE, LABEL); \
375 #ifndef ASM_OUTPUT_DWARF_DATA2
376 #define ASM_OUTPUT_DWARF_DATA2(FILE,VALUE) \
377 fprintf ((FILE), "\t%s\t0x%x", UNALIGNED_SHORT_ASM_OP, (unsigned) (VALUE))
380 #ifndef ASM_OUTPUT_DWARF_DATA4
381 #define ASM_OUTPUT_DWARF_DATA4(FILE,VALUE) \
382 fprintf ((FILE), "\t%s\t0x%x", UNALIGNED_INT_ASM_OP, (unsigned) (VALUE))
385 #ifndef ASM_OUTPUT_DWARF_DATA
386 #define ASM_OUTPUT_DWARF_DATA(FILE,VALUE) \
387 fprintf ((FILE), "\t%s\t0x%lx", UNALIGNED_OFFSET_ASM_OP, \
388 (unsigned long) (VALUE))
391 #ifndef ASM_OUTPUT_DWARF_ADDR_DATA
392 #define ASM_OUTPUT_DWARF_ADDR_DATA(FILE,VALUE) \
393 fprintf ((FILE), "\t%s\t0x%lx", UNALIGNED_WORD_ASM_OP, \
394 (unsigned long) (VALUE))
397 #ifndef ASM_OUTPUT_DWARF_DATA8
398 #define ASM_OUTPUT_DWARF_DATA8(FILE,HIGH_VALUE,LOW_VALUE) \
400 if (WORDS_BIG_ENDIAN) \
402 fprintf ((FILE), "\t%s\t0x%lx\n", UNALIGNED_INT_ASM_OP, (HIGH_VALUE));\
403 fprintf ((FILE), "\t%s\t0x%lx", UNALIGNED_INT_ASM_OP, (LOW_VALUE));\
407 fprintf ((FILE), "\t%s\t0x%lx\n", UNALIGNED_INT_ASM_OP, (LOW_VALUE)); \
408 fprintf ((FILE), "\t%s\t0x%lx", UNALIGNED_INT_ASM_OP, (HIGH_VALUE)); \
413 #else /* UNALIGNED_INT_ASM_OP */
415 /* We don't have unaligned support, let's hope the normal output works for
418 #define ASM_OUTPUT_DWARF_ADDR(FILE,LABEL) \
419 assemble_integer (gen_rtx_SYMBOL_REF (Pmode, LABEL), PTR_SIZE, 1)
421 #define ASM_OUTPUT_DWARF_OFFSET4(FILE,LABEL) \
422 assemble_integer (gen_rtx_SYMBOL_REF (SImode, LABEL), 4, 1)
424 #define ASM_OUTPUT_DWARF_OFFSET(FILE,LABEL) \
425 assemble_integer (gen_rtx_SYMBOL_REF (SImode, LABEL), 4, 1)
427 #define ASM_OUTPUT_DWARF_DELTA2(FILE,LABEL1,LABEL2) \
428 assemble_integer (gen_rtx_MINUS (HImode, \
429 gen_rtx_SYMBOL_REF (Pmode, LABEL1), \
430 gen_rtx_SYMBOL_REF (Pmode, LABEL2)), \
433 #define ASM_OUTPUT_DWARF_DELTA4(FILE,LABEL1,LABEL2) \
434 assemble_integer (gen_rtx_MINUS (SImode, \
435 gen_rtx_SYMBOL_REF (Pmode, LABEL1), \
436 gen_rtx_SYMBOL_REF (Pmode, LABEL2)), \
439 #define ASM_OUTPUT_DWARF_ADDR_DELTA(FILE,LABEL1,LABEL2) \
440 assemble_integer (gen_rtx_MINUS (Pmode, \
441 gen_rtx_SYMBOL_REF (Pmode, LABEL1), \
442 gen_rtx_SYMBOL_REF (Pmode, LABEL2)), \
445 #define ASM_OUTPUT_DWARF_DELTA(FILE,LABEL1,LABEL2) \
446 ASM_OUTPUT_DWARF_DELTA4 (FILE,LABEL1,LABEL2)
448 #define ASM_OUTPUT_DWARF_DATA4(FILE,VALUE) \
449 assemble_integer (GEN_INT (VALUE), 4, 1)
451 #endif /* UNALIGNED_INT_ASM_OP */
454 #ifndef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
455 #define ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL(FILE, SY, HI, LO) \
457 fprintf (FILE, "\t%s\t", SET_ASM_OP); \
458 assemble_name (FILE, SY); \
460 assemble_name (FILE, HI); \
462 assemble_name (FILE, LO); \
465 #endif /* SET_ASM_OP */
467 /* This is similar to the default ASM_OUTPUT_ASCII, except that no trailing
468 newline is produced. When flag_debug_asm is asserted, we add commentary
469 at the end of the line, so we must avoid output of a newline here. */
470 #ifndef ASM_OUTPUT_DWARF_STRING
471 #define ASM_OUTPUT_DWARF_STRING(FILE,P) \
473 register int slen = strlen(P); \
474 register char *p = (P); \
476 fprintf (FILE, "\t.ascii \""); \
477 for (i = 0; i < slen; i++) \
479 register int c = p[i]; \
480 if (c == '\"' || c == '\\') \
482 if (c >= ' ' && c < 0177) \
486 fprintf (FILE, "\\%o", c); \
489 fprintf (FILE, "\\0\""); \
494 /* The DWARF 2 CFA column which tracks the return address. Normally this
495 is the column for PC, or the first column after all of the hard
497 #ifndef DWARF_FRAME_RETURN_COLUMN
499 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (PC_REGNUM)
501 #define DWARF_FRAME_RETURN_COLUMN FIRST_PSEUDO_REGISTER
505 /* The mapping from gcc register number to DWARF 2 CFA column number. By
506 default, we just provide columns for all registers. */
507 #ifndef DWARF_FRAME_REGNUM
508 #define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG)
511 /* Hook used by __throw. */
514 expand_builtin_dwarf_fp_regnum ()
516 return GEN_INT (DWARF_FRAME_REGNUM (HARD_FRAME_POINTER_REGNUM));
519 /* The offset from the incoming value of %sp to the top of the stack frame
520 for the current function. */
521 #ifndef INCOMING_FRAME_SP_OFFSET
522 #define INCOMING_FRAME_SP_OFFSET 0
525 /* Return a pointer to a copy of the section string name S with all
526 attributes stripped off, and an asterisk prepended (for assemble_name). */
532 char *stripped = xmalloc (strlen (s) + 2);
537 while (*s && *s != ',')
544 /* Return the register number described by a given RTL node. */
550 register unsigned regno = REGNO (rtl);
552 if (regno >= FIRST_PSEUDO_REGISTER)
554 warning ("internal regno botch: regno = %d\n", regno);
558 regno = DBX_REGISTER_NUMBER (regno);
562 struct reg_size_range
569 /* Given a register number in REG_TREE, return an rtx for its size in bytes.
570 We do this in kind of a roundabout way, by building up a list of
571 register size ranges and seeing where our register falls in one of those
572 ranges. We need to do it this way because REG_TREE is not a constant,
573 and the target macros were not designed to make this task easy. */
576 expand_builtin_dwarf_reg_size (reg_tree, target)
580 enum machine_mode mode;
582 struct reg_size_range ranges[5];
589 for (; i < FIRST_PSEUDO_REGISTER; ++i)
591 /* The return address is out of order on the MIPS, and we don't use
592 copy_reg for it anyway, so we don't care here how large it is. */
593 if (DWARF_FRAME_REGNUM (i) == DWARF_FRAME_RETURN_COLUMN)
596 mode = reg_raw_mode[i];
598 /* CCmode is arbitrarily given a size of 4 bytes. It is more useful
599 to use the same size as word_mode, since that reduces the number
600 of ranges we need. It should not matter, since the result should
601 never be used for a condition code register anyways. */
602 if (GET_MODE_CLASS (mode) == MODE_CC)
605 size = GET_MODE_SIZE (mode);
607 /* If this register is not valid in the specified mode and
608 we have a previous size, use that for the size of this
609 register to avoid making junk tiny ranges. */
610 if (! HARD_REGNO_MODE_OK (i, mode) && last_size != -1)
613 if (size != last_size)
615 ranges[n_ranges].beg = i;
616 ranges[n_ranges].size = last_size = size;
621 ranges[n_ranges-1].end = i;
624 /* The usual case: fp regs surrounded by general regs. */
625 if (n_ranges == 3 && ranges[0].size == ranges[2].size)
627 if ((DWARF_FRAME_REGNUM (ranges[1].end)
628 - DWARF_FRAME_REGNUM (ranges[1].beg))
629 != ranges[1].end - ranges[1].beg)
631 t = fold (build (GE_EXPR, integer_type_node, reg_tree,
632 build_int_2 (DWARF_FRAME_REGNUM (ranges[1].beg), 0)));
633 t2 = fold (build (LE_EXPR, integer_type_node, reg_tree,
634 build_int_2 (DWARF_FRAME_REGNUM (ranges[1].end), 0)));
635 t = fold (build (TRUTH_ANDIF_EXPR, integer_type_node, t, t2));
636 t = fold (build (COND_EXPR, integer_type_node, t,
637 build_int_2 (ranges[1].size, 0),
638 build_int_2 (ranges[0].size, 0)));
642 /* Initialize last_end to be larger than any possible
643 DWARF_FRAME_REGNUM. */
644 int last_end = 0x7fffffff;
646 t = build_int_2 (ranges[n_ranges].size, 0);
649 int beg = DWARF_FRAME_REGNUM (ranges[n_ranges].beg);
650 int end = DWARF_FRAME_REGNUM (ranges[n_ranges].end);
656 if (end - beg != ranges[n_ranges].end - ranges[n_ranges].beg)
658 t2 = fold (build (LE_EXPR, integer_type_node, reg_tree,
659 build_int_2 (end, 0)));
660 t = fold (build (COND_EXPR, integer_type_node, t2,
661 build_int_2 (ranges[n_ranges].size, 0), t));
663 while (--n_ranges >= 0);
665 return expand_expr (t, target, Pmode, 0);
668 /* Convert a DWARF call frame info. operation to its string name */
671 dwarf_cfi_name (cfi_opc)
672 register unsigned cfi_opc;
676 case DW_CFA_advance_loc:
677 return "DW_CFA_advance_loc";
679 return "DW_CFA_offset";
681 return "DW_CFA_restore";
685 return "DW_CFA_set_loc";
686 case DW_CFA_advance_loc1:
687 return "DW_CFA_advance_loc1";
688 case DW_CFA_advance_loc2:
689 return "DW_CFA_advance_loc2";
690 case DW_CFA_advance_loc4:
691 return "DW_CFA_advance_loc4";
692 case DW_CFA_offset_extended:
693 return "DW_CFA_offset_extended";
694 case DW_CFA_restore_extended:
695 return "DW_CFA_restore_extended";
696 case DW_CFA_undefined:
697 return "DW_CFA_undefined";
698 case DW_CFA_same_value:
699 return "DW_CFA_same_value";
700 case DW_CFA_register:
701 return "DW_CFA_register";
702 case DW_CFA_remember_state:
703 return "DW_CFA_remember_state";
704 case DW_CFA_restore_state:
705 return "DW_CFA_restore_state";
707 return "DW_CFA_def_cfa";
708 case DW_CFA_def_cfa_register:
709 return "DW_CFA_def_cfa_register";
710 case DW_CFA_def_cfa_offset:
711 return "DW_CFA_def_cfa_offset";
713 /* SGI/MIPS specific */
714 case DW_CFA_MIPS_advance_loc8:
715 return "DW_CFA_MIPS_advance_loc8";
718 case DW_CFA_GNU_window_save:
719 return "DW_CFA_GNU_window_save";
720 case DW_CFA_GNU_args_size:
721 return "DW_CFA_GNU_args_size";
724 return "DW_CFA_<unknown>";
728 /* Return a pointer to a newly allocated Call Frame Instruction. */
730 static inline dw_cfi_ref
733 register dw_cfi_ref cfi = (dw_cfi_ref) xmalloc (sizeof (dw_cfi_node));
735 cfi->dw_cfi_next = NULL;
736 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = 0;
737 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = 0;
742 /* Add a Call Frame Instruction to list of instructions. */
745 add_cfi (list_head, cfi)
746 register dw_cfi_ref *list_head;
747 register dw_cfi_ref cfi;
749 register dw_cfi_ref *p;
751 /* Find the end of the chain. */
752 for (p = list_head; (*p) != NULL; p = &(*p)->dw_cfi_next)
758 /* Generate a new label for the CFI info to refer to. */
761 dwarf2out_cfi_label ()
763 static char label[20];
764 static unsigned long label_num = 0;
766 ASM_GENERATE_INTERNAL_LABEL (label, "LCFI", label_num++);
767 ASM_OUTPUT_LABEL (asm_out_file, label);
772 /* Add CFI to the current fde at the PC value indicated by LABEL if specified,
773 or to the CIE if LABEL is NULL. */
776 add_fde_cfi (label, cfi)
777 register char *label;
778 register dw_cfi_ref cfi;
782 register dw_fde_ref fde = &fde_table[fde_table_in_use - 1];
785 label = dwarf2out_cfi_label ();
787 if (fde->dw_fde_current_label == NULL
788 || strcmp (label, fde->dw_fde_current_label) != 0)
790 register dw_cfi_ref xcfi;
792 fde->dw_fde_current_label = label = xstrdup (label);
794 /* Set the location counter to the new label. */
796 xcfi->dw_cfi_opc = DW_CFA_advance_loc4;
797 xcfi->dw_cfi_oprnd1.dw_cfi_addr = label;
798 add_cfi (&fde->dw_fde_cfi, xcfi);
801 add_cfi (&fde->dw_fde_cfi, cfi);
805 add_cfi (&cie_cfi_head, cfi);
808 /* Subroutine of lookup_cfa. */
811 lookup_cfa_1 (cfi, regp, offsetp)
812 register dw_cfi_ref cfi;
813 register unsigned long *regp;
814 register long *offsetp;
816 switch (cfi->dw_cfi_opc)
818 case DW_CFA_def_cfa_offset:
819 *offsetp = cfi->dw_cfi_oprnd1.dw_cfi_offset;
821 case DW_CFA_def_cfa_register:
822 *regp = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
825 *regp = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
826 *offsetp = cfi->dw_cfi_oprnd2.dw_cfi_offset;
833 /* Find the previous value for the CFA. */
836 lookup_cfa (regp, offsetp)
837 register unsigned long *regp;
838 register long *offsetp;
840 register dw_cfi_ref cfi;
842 *regp = (unsigned long) -1;
845 for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
846 lookup_cfa_1 (cfi, regp, offsetp);
848 if (fde_table_in_use)
850 register dw_fde_ref fde = &fde_table[fde_table_in_use - 1];
851 for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
852 lookup_cfa_1 (cfi, regp, offsetp);
856 /* The current rule for calculating the DWARF2 canonical frame address. */
857 static unsigned long cfa_reg;
858 static long cfa_offset;
860 /* The register used for saving registers to the stack, and its offset
862 static unsigned cfa_store_reg;
863 static long cfa_store_offset;
865 /* The running total of the size of arguments pushed onto the stack. */
866 static long args_size;
868 /* The last args_size we actually output. */
869 static long old_args_size;
871 /* Entry point to update the canonical frame address (CFA).
872 LABEL is passed to add_fde_cfi. The value of CFA is now to be
873 calculated from REG+OFFSET. */
876 dwarf2out_def_cfa (label, reg, offset)
877 register char *label;
878 register unsigned reg;
879 register long offset;
881 register dw_cfi_ref cfi;
882 unsigned long old_reg;
887 if (cfa_store_reg == reg)
888 cfa_store_offset = offset;
890 reg = DWARF_FRAME_REGNUM (reg);
891 lookup_cfa (&old_reg, &old_offset);
893 if (reg == old_reg && offset == old_offset)
900 cfi->dw_cfi_opc = DW_CFA_def_cfa_offset;
901 cfi->dw_cfi_oprnd1.dw_cfi_offset = offset;
904 #ifndef MIPS_DEBUGGING_INFO /* SGI dbx thinks this means no offset. */
905 else if (offset == old_offset && old_reg != (unsigned long) -1)
907 cfi->dw_cfi_opc = DW_CFA_def_cfa_register;
908 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
914 cfi->dw_cfi_opc = DW_CFA_def_cfa;
915 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
916 cfi->dw_cfi_oprnd2.dw_cfi_offset = offset;
919 add_fde_cfi (label, cfi);
922 /* Add the CFI for saving a register. REG is the CFA column number.
923 LABEL is passed to add_fde_cfi.
924 If SREG is -1, the register is saved at OFFSET from the CFA;
925 otherwise it is saved in SREG. */
928 reg_save (label, reg, sreg, offset)
929 register char * label;
930 register unsigned reg;
931 register unsigned sreg;
932 register long offset;
934 register dw_cfi_ref cfi = new_cfi ();
936 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
938 /* The following comparison is correct. -1 is used to indicate that
939 the value isn't a register number. */
940 if (sreg == (unsigned int) -1)
943 /* The register number won't fit in 6 bits, so we have to use
945 cfi->dw_cfi_opc = DW_CFA_offset_extended;
947 cfi->dw_cfi_opc = DW_CFA_offset;
949 offset /= DWARF_CIE_DATA_ALIGNMENT;
952 cfi->dw_cfi_oprnd2.dw_cfi_offset = offset;
956 cfi->dw_cfi_opc = DW_CFA_register;
957 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = sreg;
960 add_fde_cfi (label, cfi);
963 /* Add the CFI for saving a register window. LABEL is passed to reg_save.
964 This CFI tells the unwinder that it needs to restore the window registers
965 from the previous frame's window save area.
967 ??? Perhaps we should note in the CIE where windows are saved (instead of
968 assuming 0(cfa)) and what registers are in the window. */
971 dwarf2out_window_save (label)
972 register char * label;
974 register dw_cfi_ref cfi = new_cfi ();
975 cfi->dw_cfi_opc = DW_CFA_GNU_window_save;
976 add_fde_cfi (label, cfi);
979 /* Add a CFI to update the running total of the size of arguments
980 pushed onto the stack. */
983 dwarf2out_args_size (label, size)
987 register dw_cfi_ref cfi;
989 if (size == old_args_size)
991 old_args_size = size;
994 cfi->dw_cfi_opc = DW_CFA_GNU_args_size;
995 cfi->dw_cfi_oprnd1.dw_cfi_offset = size;
996 add_fde_cfi (label, cfi);
999 /* Entry point for saving a register to the stack. REG is the GCC register
1000 number. LABEL and OFFSET are passed to reg_save. */
1003 dwarf2out_reg_save (label, reg, offset)
1004 register char * label;
1005 register unsigned reg;
1006 register long offset;
1008 reg_save (label, DWARF_FRAME_REGNUM (reg), -1, offset);
1011 /* Entry point for saving the return address in the stack.
1012 LABEL and OFFSET are passed to reg_save. */
1015 dwarf2out_return_save (label, offset)
1016 register char * label;
1017 register long offset;
1019 reg_save (label, DWARF_FRAME_RETURN_COLUMN, -1, offset);
1022 /* Entry point for saving the return address in a register.
1023 LABEL and SREG are passed to reg_save. */
1026 dwarf2out_return_reg (label, sreg)
1027 register char * label;
1028 register unsigned sreg;
1030 reg_save (label, DWARF_FRAME_RETURN_COLUMN, sreg, 0);
1033 /* Record the initial position of the return address. RTL is
1034 INCOMING_RETURN_ADDR_RTX. */
1037 initial_return_save (rtl)
1040 unsigned int reg = (unsigned int) -1;
1043 switch (GET_CODE (rtl))
1046 /* RA is in a register. */
1047 reg = reg_number (rtl);
1050 /* RA is on the stack. */
1051 rtl = XEXP (rtl, 0);
1052 switch (GET_CODE (rtl))
1055 if (REGNO (rtl) != STACK_POINTER_REGNUM)
1060 if (REGNO (XEXP (rtl, 0)) != STACK_POINTER_REGNUM)
1062 offset = INTVAL (XEXP (rtl, 1));
1065 if (REGNO (XEXP (rtl, 0)) != STACK_POINTER_REGNUM)
1067 offset = -INTVAL (XEXP (rtl, 1));
1074 /* The return address is at some offset from any value we can
1075 actually load. For instance, on the SPARC it is in %i7+8. Just
1076 ignore the offset for now; it doesn't matter for unwinding frames. */
1077 if (GET_CODE (XEXP (rtl, 1)) != CONST_INT)
1079 initial_return_save (XEXP (rtl, 0));
1085 reg_save (NULL, DWARF_FRAME_RETURN_COLUMN, reg, offset - cfa_offset);
1088 /* Check INSN to see if it looks like a push or a stack adjustment, and
1089 make a note of it if it does. EH uses this information to find out how
1090 much extra space it needs to pop off the stack. */
1093 dwarf2out_stack_adjust (insn)
1099 if (! asynchronous_exceptions && GET_CODE (insn) == CALL_INSN)
1101 /* Extract the size of the args from the CALL rtx itself. */
1103 insn = PATTERN (insn);
1104 if (GET_CODE (insn) == PARALLEL)
1105 insn = XVECEXP (insn, 0, 0);
1106 if (GET_CODE (insn) == SET)
1107 insn = SET_SRC (insn);
1108 assert (GET_CODE (insn) == CALL);
1109 dwarf2out_args_size ("", INTVAL (XEXP (insn, 1)));
1113 /* If only calls can throw, and we have a frame pointer,
1114 save up adjustments until we see the CALL_INSN. */
1115 else if (! asynchronous_exceptions
1116 && cfa_reg != STACK_POINTER_REGNUM)
1119 if (GET_CODE (insn) == BARRIER)
1121 /* When we see a BARRIER, we know to reset args_size to 0. Usually
1122 the compiler will have already emitted a stack adjustment, but
1123 doesn't bother for calls to noreturn functions. */
1124 #ifdef STACK_GROWS_DOWNWARD
1125 offset = -args_size;
1130 else if (GET_CODE (PATTERN (insn)) == SET)
1135 insn = PATTERN (insn);
1136 src = SET_SRC (insn);
1137 dest = SET_DEST (insn);
1139 if (dest == stack_pointer_rtx)
1141 /* (set (reg sp) (plus (reg sp) (const_int))) */
1142 code = GET_CODE (src);
1143 if (! (code == PLUS || code == MINUS)
1144 || XEXP (src, 0) != stack_pointer_rtx
1145 || GET_CODE (XEXP (src, 1)) != CONST_INT)
1148 offset = INTVAL (XEXP (src, 1));
1150 else if (GET_CODE (dest) == MEM)
1152 /* (set (mem (pre_dec (reg sp))) (foo)) */
1153 src = XEXP (dest, 0);
1154 code = GET_CODE (src);
1156 if (! (code == PRE_DEC || code == PRE_INC)
1157 || XEXP (src, 0) != stack_pointer_rtx)
1160 offset = GET_MODE_SIZE (GET_MODE (dest));
1165 if (code == PLUS || code == PRE_INC)
1174 if (cfa_reg == STACK_POINTER_REGNUM)
1175 cfa_offset += offset;
1177 #ifndef STACK_GROWS_DOWNWARD
1180 args_size += offset;
1184 label = dwarf2out_cfi_label ();
1185 dwarf2out_def_cfa (label, cfa_reg, cfa_offset);
1186 dwarf2out_args_size (label, args_size);
1189 /* A temporary register used in adjusting SP or setting up the store_reg. */
1190 static unsigned cfa_temp_reg;
1192 /* A temporary value used in adjusting SP or setting up the store_reg. */
1193 static long cfa_temp_value;
1195 /* Record call frame debugging information for an expression, which either
1196 sets SP or FP (adjusting how we calculate the frame address) or saves a
1197 register to the stack. */
1200 dwarf2out_frame_debug_expr (expr, label)
1207 /* If RTX_FRAME_RELATED_P is set on a PARALLEL, process each member of
1208 the PARALLEL independantly. The first element is always processed if
1209 it is a SET. This is for backward compatability. Other elements
1210 are processed only if they are SETs and the RTX_FRAME_RELATED_P
1211 flag is set in them. */
1213 if (GET_CODE (expr) == PARALLEL)
1216 int limit = XVECLEN (expr, 0);
1218 for (par_index = 0; par_index < limit; par_index++)
1220 rtx x = XVECEXP (expr, 0, par_index);
1222 if (GET_CODE (x) == SET &&
1223 (RTX_FRAME_RELATED_P (x) || par_index == 0))
1224 dwarf2out_frame_debug_expr (x, label);
1229 if (GET_CODE (expr) != SET)
1232 src = SET_SRC (expr);
1233 dest = SET_DEST (expr);
1235 switch (GET_CODE (dest))
1238 /* Update the CFA rule wrt SP or FP. Make sure src is
1239 relative to the current CFA register. */
1240 switch (GET_CODE (src))
1242 /* Setting FP from SP. */
1244 if (cfa_reg != (unsigned) REGNO (src))
1246 if (REGNO (dest) != STACK_POINTER_REGNUM
1247 && !(frame_pointer_needed
1248 && REGNO (dest) == HARD_FRAME_POINTER_REGNUM))
1250 cfa_reg = REGNO (dest);
1255 if (dest == stack_pointer_rtx)
1258 switch (GET_CODE (XEXP (src, 1)))
1261 offset = INTVAL (XEXP (src, 1));
1264 if ((unsigned) REGNO (XEXP (src, 1)) != cfa_temp_reg)
1266 offset = cfa_temp_value;
1272 if (XEXP (src, 0) == hard_frame_pointer_rtx)
1274 /* Restoring SP from FP in the epilogue. */
1275 if (cfa_reg != (unsigned) HARD_FRAME_POINTER_REGNUM)
1277 cfa_reg = STACK_POINTER_REGNUM;
1279 else if (XEXP (src, 0) != stack_pointer_rtx)
1282 if (GET_CODE (src) == PLUS)
1284 if (cfa_reg == STACK_POINTER_REGNUM)
1285 cfa_offset += offset;
1286 if (cfa_store_reg == STACK_POINTER_REGNUM)
1287 cfa_store_offset += offset;
1289 else if (dest == hard_frame_pointer_rtx)
1291 /* Either setting the FP from an offset of the SP,
1292 or adjusting the FP */
1293 if (! frame_pointer_needed
1294 || REGNO (dest) != HARD_FRAME_POINTER_REGNUM)
1297 if (XEXP (src, 0) == stack_pointer_rtx
1298 && GET_CODE (XEXP (src, 1)) == CONST_INT)
1300 if (cfa_reg != STACK_POINTER_REGNUM)
1302 offset = INTVAL (XEXP (src, 1));
1303 if (GET_CODE (src) == PLUS)
1305 cfa_offset += offset;
1306 cfa_reg = HARD_FRAME_POINTER_REGNUM;
1308 else if (XEXP (src, 0) == hard_frame_pointer_rtx
1309 && GET_CODE (XEXP (src, 1)) == CONST_INT)
1311 if (cfa_reg != (unsigned) HARD_FRAME_POINTER_REGNUM)
1313 offset = INTVAL (XEXP (src, 1));
1314 if (GET_CODE (src) == PLUS)
1316 cfa_offset += offset;
1324 if (GET_CODE (src) != PLUS
1325 || XEXP (src, 1) != stack_pointer_rtx)
1327 if (GET_CODE (XEXP (src, 0)) != REG
1328 || (unsigned) REGNO (XEXP (src, 0)) != cfa_temp_reg)
1330 if (cfa_reg != STACK_POINTER_REGNUM)
1332 cfa_store_reg = REGNO (dest);
1333 cfa_store_offset = cfa_offset - cfa_temp_value;
1338 cfa_temp_reg = REGNO (dest);
1339 cfa_temp_value = INTVAL (src);
1343 if (GET_CODE (XEXP (src, 0)) != REG
1344 || (unsigned) REGNO (XEXP (src, 0)) != cfa_temp_reg
1345 || (unsigned) REGNO (dest) != cfa_temp_reg
1346 || GET_CODE (XEXP (src, 1)) != CONST_INT)
1348 cfa_temp_value |= INTVAL (XEXP (src, 1));
1354 dwarf2out_def_cfa (label, cfa_reg, cfa_offset);
1358 /* Saving a register to the stack. Make sure dest is relative to the
1360 if (GET_CODE (src) != REG)
1362 switch (GET_CODE (XEXP (dest, 0)))
1367 offset = GET_MODE_SIZE (GET_MODE (dest));
1368 if (GET_CODE (XEXP (dest, 0)) == PRE_INC)
1371 if (REGNO (XEXP (XEXP (dest, 0), 0)) != STACK_POINTER_REGNUM
1372 || cfa_store_reg != STACK_POINTER_REGNUM)
1374 cfa_store_offset += offset;
1375 if (cfa_reg == STACK_POINTER_REGNUM)
1376 cfa_offset = cfa_store_offset;
1378 offset = -cfa_store_offset;
1381 /* With an offset. */
1384 offset = INTVAL (XEXP (XEXP (dest, 0), 1));
1385 if (GET_CODE (XEXP (dest, 0)) == MINUS)
1388 if (cfa_store_reg != (unsigned) REGNO (XEXP (XEXP (dest, 0), 0)))
1390 offset -= cfa_store_offset;
1393 /* Without an offset. */
1395 if (cfa_store_reg != (unsigned) REGNO (XEXP (dest, 0)))
1397 offset = -cfa_store_offset;
1403 dwarf2out_def_cfa (label, cfa_reg, cfa_offset);
1404 dwarf2out_reg_save (label, REGNO (src), offset);
1413 /* Record call frame debugging information for INSN, which either
1414 sets SP or FP (adjusting how we calculate the frame address) or saves a
1415 register to the stack. If INSN is NULL_RTX, initialize our state. */
1418 dwarf2out_frame_debug (insn)
1424 if (insn == NULL_RTX)
1426 /* Set up state for generating call frame debug info. */
1427 lookup_cfa (&cfa_reg, &cfa_offset);
1428 if (cfa_reg != DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM))
1430 cfa_reg = STACK_POINTER_REGNUM;
1431 cfa_store_reg = cfa_reg;
1432 cfa_store_offset = cfa_offset;
1438 if (! RTX_FRAME_RELATED_P (insn))
1440 dwarf2out_stack_adjust (insn);
1444 label = dwarf2out_cfi_label ();
1446 src = find_reg_note (insn, REG_FRAME_RELATED_EXPR, NULL_RTX);
1448 insn = XEXP (src, 0);
1450 insn = PATTERN (insn);
1452 dwarf2out_frame_debug_expr (insn, label);
1455 /* Return the size of an unsigned LEB128 quantity. */
1457 static inline unsigned long
1458 size_of_uleb128 (value)
1459 register unsigned long value;
1461 register unsigned long size = 0;
1462 register unsigned byte;
1466 byte = (value & 0x7f);
1475 /* Return the size of a signed LEB128 quantity. */
1477 static inline unsigned long
1478 size_of_sleb128 (value)
1479 register long value;
1481 register unsigned long size = 0;
1482 register unsigned byte;
1486 byte = (value & 0x7f);
1490 while (!(((value == 0) && ((byte & 0x40) == 0))
1491 || ((value == -1) && ((byte & 0x40) != 0))));
1496 /* Output an unsigned LEB128 quantity. */
1499 output_uleb128 (value)
1500 register unsigned long value;
1502 unsigned long save_value = value;
1504 fprintf (asm_out_file, "\t%s\t", ASM_BYTE_OP);
1507 register unsigned byte = (value & 0x7f);
1510 /* More bytes to follow. */
1513 fprintf (asm_out_file, "0x%x", byte);
1515 fprintf (asm_out_file, ",");
1520 fprintf (asm_out_file, "\t%s ULEB128 0x%lx", ASM_COMMENT_START, save_value);
1523 /* Output an signed LEB128 quantity. */
1526 output_sleb128 (value)
1527 register long value;
1530 register unsigned byte;
1531 long save_value = value;
1533 fprintf (asm_out_file, "\t%s\t", ASM_BYTE_OP);
1536 byte = (value & 0x7f);
1537 /* arithmetic shift */
1539 more = !((((value == 0) && ((byte & 0x40) == 0))
1540 || ((value == -1) && ((byte & 0x40) != 0))));
1544 fprintf (asm_out_file, "0x%x", byte);
1546 fprintf (asm_out_file, ",");
1551 fprintf (asm_out_file, "\t%s SLEB128 %ld", ASM_COMMENT_START, save_value);
1554 /* Output a Call Frame Information opcode and its operand(s). */
1557 output_cfi (cfi, fde)
1558 register dw_cfi_ref cfi;
1559 register dw_fde_ref fde;
1561 if (cfi->dw_cfi_opc == DW_CFA_advance_loc)
1563 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
1565 | (cfi->dw_cfi_oprnd1.dw_cfi_offset & 0x3f));
1567 fprintf (asm_out_file, "\t%s DW_CFA_advance_loc 0x%lx",
1568 ASM_COMMENT_START, cfi->dw_cfi_oprnd1.dw_cfi_offset);
1569 fputc ('\n', asm_out_file);
1572 else if (cfi->dw_cfi_opc == DW_CFA_offset)
1574 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
1576 | (cfi->dw_cfi_oprnd1.dw_cfi_reg_num & 0x3f));
1578 fprintf (asm_out_file, "\t%s DW_CFA_offset, column 0x%lx",
1579 ASM_COMMENT_START, cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
1581 fputc ('\n', asm_out_file);
1582 output_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset);
1583 fputc ('\n', asm_out_file);
1585 else if (cfi->dw_cfi_opc == DW_CFA_restore)
1587 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
1589 | (cfi->dw_cfi_oprnd1.dw_cfi_reg_num & 0x3f));
1591 fprintf (asm_out_file, "\t%s DW_CFA_restore, column 0x%lx",
1592 ASM_COMMENT_START, cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
1594 fputc ('\n', asm_out_file);
1598 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, cfi->dw_cfi_opc);
1600 fprintf (asm_out_file, "\t%s %s", ASM_COMMENT_START,
1601 dwarf_cfi_name (cfi->dw_cfi_opc));
1603 fputc ('\n', asm_out_file);
1604 switch (cfi->dw_cfi_opc)
1606 case DW_CFA_set_loc:
1607 ASM_OUTPUT_DWARF_ADDR (asm_out_file, cfi->dw_cfi_oprnd1.dw_cfi_addr);
1608 fputc ('\n', asm_out_file);
1610 case DW_CFA_advance_loc1:
1611 ASM_OUTPUT_DWARF_DELTA1 (asm_out_file,
1612 cfi->dw_cfi_oprnd1.dw_cfi_addr,
1613 fde->dw_fde_current_label);
1614 fputc ('\n', asm_out_file);
1615 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
1617 case DW_CFA_advance_loc2:
1618 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file,
1619 cfi->dw_cfi_oprnd1.dw_cfi_addr,
1620 fde->dw_fde_current_label);
1621 fputc ('\n', asm_out_file);
1622 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
1624 case DW_CFA_advance_loc4:
1625 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file,
1626 cfi->dw_cfi_oprnd1.dw_cfi_addr,
1627 fde->dw_fde_current_label);
1628 fputc ('\n', asm_out_file);
1629 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
1631 #ifdef MIPS_DEBUGGING_INFO
1632 case DW_CFA_MIPS_advance_loc8:
1633 /* TODO: not currently implemented. */
1637 case DW_CFA_offset_extended:
1638 case DW_CFA_def_cfa:
1639 output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
1640 fputc ('\n', asm_out_file);
1641 output_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset);
1642 fputc ('\n', asm_out_file);
1644 case DW_CFA_restore_extended:
1645 case DW_CFA_undefined:
1646 output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
1647 fputc ('\n', asm_out_file);
1649 case DW_CFA_same_value:
1650 case DW_CFA_def_cfa_register:
1651 output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
1652 fputc ('\n', asm_out_file);
1654 case DW_CFA_register:
1655 output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
1656 fputc ('\n', asm_out_file);
1657 output_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_reg_num);
1658 fputc ('\n', asm_out_file);
1660 case DW_CFA_def_cfa_offset:
1661 output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset);
1662 fputc ('\n', asm_out_file);
1664 case DW_CFA_GNU_window_save:
1666 case DW_CFA_GNU_args_size:
1667 output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset);
1668 fputc ('\n', asm_out_file);
1676 #if !defined (EH_FRAME_SECTION)
1677 #if defined (EH_FRAME_SECTION_ASM_OP)
1678 #define EH_FRAME_SECTION() eh_frame_section();
1680 #if defined (ASM_OUTPUT_SECTION_NAME)
1681 #define EH_FRAME_SECTION() \
1683 named_section (NULL_TREE, ".eh_frame", 0); \
1689 /* If we aren't using crtstuff to run ctors, don't use it for EH. */
1690 #if !defined (HAS_INIT_SECTION) && !defined (INIT_SECTION_ASM_OP)
1691 #undef EH_FRAME_SECTION
1694 /* Output the call frame information used to used to record information
1695 that relates to calculating the frame pointer, and records the
1696 location of saved registers. */
1699 output_call_frame_info (for_eh)
1702 register unsigned long i;
1703 register dw_fde_ref fde;
1704 register dw_cfi_ref cfi;
1705 char l1[20], l2[20];
1706 #ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
1710 /* Do we want to include a pointer to the exception table? */
1711 int eh_ptr = for_eh && exception_table_p ();
1713 fputc ('\n', asm_out_file);
1715 /* We're going to be generating comments, so turn on app. */
1721 #ifdef EH_FRAME_SECTION
1722 EH_FRAME_SECTION ();
1724 tree label = get_file_function_name ('F');
1726 force_data_section ();
1727 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
1728 ASM_GLOBALIZE_LABEL (asm_out_file, IDENTIFIER_POINTER (label));
1729 ASM_OUTPUT_LABEL (asm_out_file, IDENTIFIER_POINTER (label));
1731 assemble_label ("__FRAME_BEGIN__");
1734 ASM_OUTPUT_SECTION (asm_out_file, FRAME_SECTION);
1736 /* Output the CIE. */
1737 ASM_GENERATE_INTERNAL_LABEL (l1, CIE_AFTER_SIZE_LABEL, for_eh);
1738 ASM_GENERATE_INTERNAL_LABEL (l2, CIE_END_LABEL, for_eh);
1739 #ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
1740 ASM_GENERATE_INTERNAL_LABEL (ld, CIE_LENGTH_LABEL, for_eh);
1742 ASM_OUTPUT_DWARF_OFFSET4 (asm_out_file, ld);
1744 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, ld);
1747 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, l2, l1);
1749 ASM_OUTPUT_DWARF_DELTA (asm_out_file, l2, l1);
1752 fprintf (asm_out_file, "\t%s Length of Common Information Entry",
1755 fputc ('\n', asm_out_file);
1756 ASM_OUTPUT_LABEL (asm_out_file, l1);
1759 /* Now that the CIE pointer is PC-relative for EH,
1760 use 0 to identify the CIE. */
1761 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0);
1763 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, DW_CIE_ID);
1766 fprintf (asm_out_file, "\t%s CIE Identifier Tag", ASM_COMMENT_START);
1768 fputc ('\n', asm_out_file);
1769 if (! for_eh && DWARF_OFFSET_SIZE == 8)
1771 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, DW_CIE_ID);
1772 fputc ('\n', asm_out_file);
1775 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_CIE_VERSION);
1777 fprintf (asm_out_file, "\t%s CIE Version", ASM_COMMENT_START);
1779 fputc ('\n', asm_out_file);
1782 /* The CIE contains a pointer to the exception region info for the
1783 frame. Make the augmentation string three bytes (including the
1784 trailing null) so the pointer is 4-byte aligned. The Solaris ld
1785 can't handle unaligned relocs. */
1788 ASM_OUTPUT_DWARF_STRING (asm_out_file, "eh");
1789 fprintf (asm_out_file, "\t%s CIE Augmentation", ASM_COMMENT_START);
1793 ASM_OUTPUT_ASCII (asm_out_file, "eh", 3);
1795 fputc ('\n', asm_out_file);
1797 ASM_OUTPUT_DWARF_ADDR (asm_out_file, "__EXCEPTION_TABLE__");
1799 fprintf (asm_out_file, "\t%s pointer to exception region info",
1804 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
1806 fprintf (asm_out_file, "\t%s CIE Augmentation (none)",
1810 fputc ('\n', asm_out_file);
1813 fprintf (asm_out_file, " (CIE Code Alignment Factor)");
1815 fputc ('\n', asm_out_file);
1816 output_sleb128 (DWARF_CIE_DATA_ALIGNMENT);
1818 fprintf (asm_out_file, " (CIE Data Alignment Factor)");
1820 fputc ('\n', asm_out_file);
1821 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DWARF_FRAME_RETURN_COLUMN);
1823 fprintf (asm_out_file, "\t%s CIE RA Column", ASM_COMMENT_START);
1825 fputc ('\n', asm_out_file);
1827 for (cfi = cie_cfi_head; cfi != NULL; cfi = cfi->dw_cfi_next)
1828 output_cfi (cfi, NULL);
1830 /* Pad the CIE out to an address sized boundary. */
1831 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
1832 ASM_OUTPUT_LABEL (asm_out_file, l2);
1833 #ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
1834 ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL (asm_out_file, ld, l2, l1);
1836 fprintf (asm_out_file, "\t%s CIE Length Symbol", ASM_COMMENT_START);
1837 fputc ('\n', asm_out_file);
1840 /* Loop through all of the FDE's. */
1841 for (i = 0; i < fde_table_in_use; ++i)
1843 fde = &fde_table[i];
1845 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_AFTER_SIZE_LABEL, for_eh + i*2);
1846 ASM_GENERATE_INTERNAL_LABEL (l2, FDE_END_LABEL, for_eh + i*2);
1847 #ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
1848 ASM_GENERATE_INTERNAL_LABEL (ld, FDE_LENGTH_LABEL, for_eh + i*2);
1850 ASM_OUTPUT_DWARF_OFFSET4 (asm_out_file, ld);
1852 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, ld);
1855 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, l2, l1);
1857 ASM_OUTPUT_DWARF_DELTA (asm_out_file, l2, l1);
1860 fprintf (asm_out_file, "\t%s FDE Length", ASM_COMMENT_START);
1861 fputc ('\n', asm_out_file);
1862 ASM_OUTPUT_LABEL (asm_out_file, l1);
1864 /* ??? This always emits a 4 byte offset when for_eh is true, but it
1865 emits a target dependent sized offset when for_eh is not true.
1866 This inconsistency may confuse gdb. The only case where we need a
1867 non-4 byte offset is for the Irix6 N64 ABI, so we may lose SGI
1868 compatibility if we emit a 4 byte offset. We need a 4 byte offset
1869 though in order to be compatible with the dwarf_fde struct in frame.c.
1870 If the for_eh case is changed, then the struct in frame.c has
1871 to be adjusted appropriately. */
1873 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, l1, "__FRAME_BEGIN__");
1875 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, stripattributes (FRAME_SECTION));
1877 fprintf (asm_out_file, "\t%s FDE CIE offset", ASM_COMMENT_START);
1879 fputc ('\n', asm_out_file);
1880 ASM_OUTPUT_DWARF_ADDR (asm_out_file, fde->dw_fde_begin);
1882 fprintf (asm_out_file, "\t%s FDE initial location", ASM_COMMENT_START);
1884 fputc ('\n', asm_out_file);
1885 ASM_OUTPUT_DWARF_ADDR_DELTA (asm_out_file,
1886 fde->dw_fde_end, fde->dw_fde_begin);
1888 fprintf (asm_out_file, "\t%s FDE address range", ASM_COMMENT_START);
1890 fputc ('\n', asm_out_file);
1892 /* Loop through the Call Frame Instructions associated with
1894 fde->dw_fde_current_label = fde->dw_fde_begin;
1895 for (cfi = fde->dw_fde_cfi; cfi != NULL; cfi = cfi->dw_cfi_next)
1896 output_cfi (cfi, fde);
1898 /* Pad the FDE out to an address sized boundary. */
1899 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
1900 ASM_OUTPUT_LABEL (asm_out_file, l2);
1901 #ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
1902 ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL (asm_out_file, ld, l2, l1);
1904 fprintf (asm_out_file, "\t%s FDE Length Symbol", ASM_COMMENT_START);
1905 fputc ('\n', asm_out_file);
1908 #ifndef EH_FRAME_SECTION
1911 /* Emit terminating zero for table. */
1912 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0);
1913 fputc ('\n', asm_out_file);
1916 #ifdef MIPS_DEBUGGING_INFO
1917 /* Work around Irix 6 assembler bug whereby labels at the end of a section
1918 get a value of 0. Putting .align 0 after the label fixes it. */
1919 ASM_OUTPUT_ALIGN (asm_out_file, 0);
1922 /* Turn off app to make assembly quicker. */
1927 /* Output a marker (i.e. a label) for the beginning of a function, before
1931 dwarf2out_begin_prologue ()
1933 char label[MAX_ARTIFICIAL_LABEL_BYTES];
1934 register dw_fde_ref fde;
1936 ++current_funcdef_number;
1938 function_section (current_function_decl);
1939 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_BEGIN_LABEL,
1940 current_funcdef_number);
1941 ASM_OUTPUT_LABEL (asm_out_file, label);
1943 /* Expand the fde table if necessary. */
1944 if (fde_table_in_use == fde_table_allocated)
1946 fde_table_allocated += FDE_TABLE_INCREMENT;
1948 = (dw_fde_ref) xrealloc (fde_table,
1949 fde_table_allocated * sizeof (dw_fde_node));
1952 /* Record the FDE associated with this function. */
1953 current_funcdef_fde = fde_table_in_use;
1955 /* Add the new FDE at the end of the fde_table. */
1956 fde = &fde_table[fde_table_in_use++];
1957 fde->dw_fde_begin = xstrdup (label);
1958 fde->dw_fde_current_label = NULL;
1959 fde->dw_fde_end = NULL;
1960 fde->dw_fde_cfi = NULL;
1962 args_size = old_args_size = 0;
1965 /* Output a marker (i.e. a label) for the absolute end of the generated code
1966 for a function definition. This gets called *after* the epilogue code has
1970 dwarf2out_end_epilogue ()
1973 char label[MAX_ARTIFICIAL_LABEL_BYTES];
1975 /* Output a label to mark the endpoint of the code generated for this
1977 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL, current_funcdef_number);
1978 ASM_OUTPUT_LABEL (asm_out_file, label);
1979 fde = &fde_table[fde_table_in_use - 1];
1980 fde->dw_fde_end = xstrdup (label);
1984 dwarf2out_frame_init ()
1986 /* Allocate the initial hunk of the fde_table. */
1988 = (dw_fde_ref) xmalloc (FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
1989 bzero ((char *) fde_table, FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
1990 fde_table_allocated = FDE_TABLE_INCREMENT;
1991 fde_table_in_use = 0;
1993 /* Generate the CFA instructions common to all FDE's. Do it now for the
1994 sake of lookup_cfa. */
1996 #ifdef DWARF2_UNWIND_INFO
1997 /* On entry, the Canonical Frame Address is at SP. */
1998 dwarf2out_def_cfa (NULL, STACK_POINTER_REGNUM, INCOMING_FRAME_SP_OFFSET);
1999 initial_return_save (INCOMING_RETURN_ADDR_RTX);
2004 dwarf2out_frame_finish ()
2006 /* Output call frame information. */
2007 #ifdef MIPS_DEBUGGING_INFO
2008 if (write_symbols == DWARF2_DEBUG)
2009 output_call_frame_info (0);
2010 if (flag_exceptions && ! exceptions_via_longjmp)
2011 output_call_frame_info (1);
2013 if (write_symbols == DWARF2_DEBUG
2014 || (flag_exceptions && ! exceptions_via_longjmp))
2015 output_call_frame_info (1);
2019 #endif /* .debug_frame support */
2021 /* And now, the support for symbolic debugging information. */
2022 #ifdef DWARF2_DEBUGGING_INFO
2024 extern char *getpwd PROTO((void));
2026 /* NOTE: In the comments in this file, many references are made to
2027 "Debugging Information Entries". This term is abbreviated as `DIE'
2028 throughout the remainder of this file. */
2030 /* An internal representation of the DWARF output is built, and then
2031 walked to generate the DWARF debugging info. The walk of the internal
2032 representation is done after the entire program has been compiled.
2033 The types below are used to describe the internal representation. */
2035 /* Each DIE may have a series of attribute/value pairs. Values
2036 can take on several forms. The forms that are used in this
2037 implementation are listed below. */
2044 dw_val_class_unsigned_const,
2045 dw_val_class_long_long,
2048 dw_val_class_die_ref,
2049 dw_val_class_fde_ref,
2050 dw_val_class_lbl_id,
2051 dw_val_class_lbl_offset,
2056 /* Various DIE's use offsets relative to the beginning of the
2057 .debug_info section to refer to each other. */
2059 typedef long int dw_offset;
2061 /* Define typedefs here to avoid circular dependencies. */
2063 typedef struct die_struct *dw_die_ref;
2064 typedef struct dw_attr_struct *dw_attr_ref;
2065 typedef struct dw_val_struct *dw_val_ref;
2066 typedef struct dw_line_info_struct *dw_line_info_ref;
2067 typedef struct dw_separate_line_info_struct *dw_separate_line_info_ref;
2068 typedef struct dw_loc_descr_struct *dw_loc_descr_ref;
2069 typedef struct pubname_struct *pubname_ref;
2070 typedef dw_die_ref *arange_ref;
2072 /* Describe a double word constant value. */
2074 typedef struct dw_long_long_struct
2081 /* Describe a floating point constant value. */
2083 typedef struct dw_fp_struct
2090 /* Each entry in the line_info_table maintains the file and
2091 line number associated with the label generated for that
2092 entry. The label gives the PC value associated with
2093 the line number entry. */
2095 typedef struct dw_line_info_struct
2097 unsigned long dw_file_num;
2098 unsigned long dw_line_num;
2102 /* Line information for functions in separate sections; each one gets its
2104 typedef struct dw_separate_line_info_struct
2106 unsigned long dw_file_num;
2107 unsigned long dw_line_num;
2108 unsigned long function;
2110 dw_separate_line_info_entry;
2112 /* The dw_val_node describes an attribute's value, as it is
2113 represented internally. */
2115 typedef struct dw_val_struct
2117 dw_val_class val_class;
2121 dw_loc_descr_ref val_loc;
2123 long unsigned val_unsigned;
2124 dw_long_long_const val_long_long;
2125 dw_float_const val_float;
2126 dw_die_ref val_die_ref;
2127 unsigned val_fde_index;
2130 unsigned char val_flag;
2136 /* Locations in memory are described using a sequence of stack machine
2139 typedef struct dw_loc_descr_struct
2141 dw_loc_descr_ref dw_loc_next;
2142 enum dwarf_location_atom dw_loc_opc;
2143 dw_val_node dw_loc_oprnd1;
2144 dw_val_node dw_loc_oprnd2;
2148 /* Each DIE attribute has a field specifying the attribute kind,
2149 a link to the next attribute in the chain, and an attribute value.
2150 Attributes are typically linked below the DIE they modify. */
2152 typedef struct dw_attr_struct
2154 enum dwarf_attribute dw_attr;
2155 dw_attr_ref dw_attr_next;
2156 dw_val_node dw_attr_val;
2160 /* The Debugging Information Entry (DIE) structure */
2162 typedef struct die_struct
2164 enum dwarf_tag die_tag;
2165 dw_attr_ref die_attr;
2166 dw_attr_ref die_attr_last;
2167 dw_die_ref die_parent;
2168 dw_die_ref die_child;
2169 dw_die_ref die_child_last;
2171 dw_offset die_offset;
2172 unsigned long die_abbrev;
2176 /* The pubname structure */
2178 typedef struct pubname_struct
2185 /* The limbo die list structure. */
2186 typedef struct limbo_die_struct
2189 struct limbo_die_struct *next;
2193 /* How to start an assembler comment. */
2194 #ifndef ASM_COMMENT_START
2195 #define ASM_COMMENT_START ";#"
2198 /* Define a macro which returns non-zero for a TYPE_DECL which was
2199 implicitly generated for a tagged type.
2201 Note that unlike the gcc front end (which generates a NULL named
2202 TYPE_DECL node for each complete tagged type, each array type, and
2203 each function type node created) the g++ front end generates a
2204 _named_ TYPE_DECL node for each tagged type node created.
2205 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
2206 generate a DW_TAG_typedef DIE for them. */
2208 #define TYPE_DECL_IS_STUB(decl) \
2209 (DECL_NAME (decl) == NULL_TREE \
2210 || (DECL_ARTIFICIAL (decl) \
2211 && is_tagged_type (TREE_TYPE (decl)) \
2212 && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \
2213 /* This is necessary for stub decls that \
2214 appear in nested inline functions. */ \
2215 || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
2216 && (decl_ultimate_origin (decl) \
2217 == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
2219 /* Information concerning the compilation unit's programming
2220 language, and compiler version. */
2222 extern int flag_traditional;
2223 extern char *version_string;
2224 extern char *language_string;
2226 /* Fixed size portion of the DWARF compilation unit header. */
2227 #define DWARF_COMPILE_UNIT_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 3)
2229 /* Fixed size portion of debugging line information prolog. */
2230 #define DWARF_LINE_PROLOG_HEADER_SIZE 5
2232 /* Fixed size portion of public names info. */
2233 #define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
2235 /* Fixed size portion of the address range info. */
2236 #define DWARF_ARANGES_HEADER_SIZE \
2237 (DWARF_ROUND (2 * DWARF_OFFSET_SIZE + 4, PTR_SIZE * 2) - DWARF_OFFSET_SIZE)
2239 /* Define the architecture-dependent minimum instruction length (in bytes).
2240 In this implementation of DWARF, this field is used for information
2241 purposes only. Since GCC generates assembly language, we have
2242 no a priori knowledge of how many instruction bytes are generated
2243 for each source line, and therefore can use only the DW_LNE_set_address
2244 and DW_LNS_fixed_advance_pc line information commands. */
2246 #ifndef DWARF_LINE_MIN_INSTR_LENGTH
2247 #define DWARF_LINE_MIN_INSTR_LENGTH 4
2250 /* Minimum line offset in a special line info. opcode.
2251 This value was chosen to give a reasonable range of values. */
2252 #define DWARF_LINE_BASE -10
2254 /* First special line opcde - leave room for the standard opcodes. */
2255 #define DWARF_LINE_OPCODE_BASE 10
2257 /* Range of line offsets in a special line info. opcode. */
2258 #define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1)
2260 /* Flag that indicates the initial value of the is_stmt_start flag.
2261 In the present implementation, we do not mark any lines as
2262 the beginning of a source statement, because that information
2263 is not made available by the GCC front-end. */
2264 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
2266 /* This location is used by calc_die_sizes() to keep track
2267 the offset of each DIE within the .debug_info section. */
2268 static unsigned long next_die_offset;
2270 /* Record the root of the DIE's built for the current compilation unit. */
2271 static dw_die_ref comp_unit_die;
2273 /* A list of DIEs with a NULL parent waiting to be relocated. */
2274 static limbo_die_node *limbo_die_list = 0;
2276 /* Pointer to an array of filenames referenced by this compilation unit. */
2277 static char **file_table;
2279 /* Total number of entries in the table (i.e. array) pointed to by
2280 `file_table'. This is the *total* and includes both used and unused
2282 static unsigned file_table_allocated;
2284 /* Number of entries in the file_table which are actually in use. */
2285 static unsigned file_table_in_use;
2287 /* Size (in elements) of increments by which we may expand the filename
2289 #define FILE_TABLE_INCREMENT 64
2291 /* Local pointer to the name of the main input file. Initialized in
2293 static char *primary_filename;
2295 /* For Dwarf output, we must assign lexical-blocks id numbers in the order in
2296 which their beginnings are encountered. We output Dwarf debugging info
2297 that refers to the beginnings and ends of the ranges of code for each
2298 lexical block. The labels themselves are generated in final.c, which
2299 assigns numbers to the blocks in the same way. */
2300 static unsigned next_block_number = 2;
2302 /* A pointer to the base of a table of references to DIE's that describe
2303 declarations. The table is indexed by DECL_UID() which is a unique
2304 number identifying each decl. */
2305 static dw_die_ref *decl_die_table;
2307 /* Number of elements currently allocated for the decl_die_table. */
2308 static unsigned decl_die_table_allocated;
2310 /* Number of elements in decl_die_table currently in use. */
2311 static unsigned decl_die_table_in_use;
2313 /* Size (in elements) of increments by which we may expand the
2315 #define DECL_DIE_TABLE_INCREMENT 256
2317 /* Structure used for the decl_scope table. scope is the current declaration
2318 scope, and previous is the entry that is the parent of this scope. This
2319 is usually but not always the immediately preceeding entry. */
2321 typedef struct decl_scope_struct
2328 /* A pointer to the base of a table of references to declaration
2329 scopes. This table is a display which tracks the nesting
2330 of declaration scopes at the current scope and containing
2331 scopes. This table is used to find the proper place to
2332 define type declaration DIE's. */
2333 static decl_scope_node *decl_scope_table;
2335 /* Number of elements currently allocated for the decl_scope_table. */
2336 static int decl_scope_table_allocated;
2338 /* Current level of nesting of declaration scopes. */
2339 static int decl_scope_depth;
2341 /* Size (in elements) of increments by which we may expand the
2342 decl_scope_table. */
2343 #define DECL_SCOPE_TABLE_INCREMENT 64
2345 /* A pointer to the base of a list of references to DIE's that
2346 are uniquely identified by their tag, presence/absence of
2347 children DIE's, and list of attribute/value pairs. */
2348 static dw_die_ref *abbrev_die_table;
2350 /* Number of elements currently allocated for abbrev_die_table. */
2351 static unsigned abbrev_die_table_allocated;
2353 /* Number of elements in type_die_table currently in use. */
2354 static unsigned abbrev_die_table_in_use;
2356 /* Size (in elements) of increments by which we may expand the
2357 abbrev_die_table. */
2358 #define ABBREV_DIE_TABLE_INCREMENT 256
2360 /* A pointer to the base of a table that contains line information
2361 for each source code line in .text in the compilation unit. */
2362 static dw_line_info_ref line_info_table;
2364 /* Number of elements currently allocated for line_info_table. */
2365 static unsigned line_info_table_allocated;
2367 /* Number of elements in separate_line_info_table currently in use. */
2368 static unsigned separate_line_info_table_in_use;
2370 /* A pointer to the base of a table that contains line information
2371 for each source code line outside of .text in the compilation unit. */
2372 static dw_separate_line_info_ref separate_line_info_table;
2374 /* Number of elements currently allocated for separate_line_info_table. */
2375 static unsigned separate_line_info_table_allocated;
2377 /* Number of elements in line_info_table currently in use. */
2378 static unsigned line_info_table_in_use;
2380 /* Size (in elements) of increments by which we may expand the
2382 #define LINE_INFO_TABLE_INCREMENT 1024
2384 /* A pointer to the base of a table that contains a list of publicly
2385 accessible names. */
2386 static pubname_ref pubname_table;
2388 /* Number of elements currently allocated for pubname_table. */
2389 static unsigned pubname_table_allocated;
2391 /* Number of elements in pubname_table currently in use. */
2392 static unsigned pubname_table_in_use;
2394 /* Size (in elements) of increments by which we may expand the
2396 #define PUBNAME_TABLE_INCREMENT 64
2398 /* A pointer to the base of a table that contains a list of publicly
2399 accessible names. */
2400 static arange_ref arange_table;
2402 /* Number of elements currently allocated for arange_table. */
2403 static unsigned arange_table_allocated;
2405 /* Number of elements in arange_table currently in use. */
2406 static unsigned arange_table_in_use;
2408 /* Size (in elements) of increments by which we may expand the
2410 #define ARANGE_TABLE_INCREMENT 64
2412 /* A pointer to the base of a list of pending types which we haven't
2413 generated DIEs for yet, but which we will have to come back to
2416 static tree *pending_types_list;
2418 /* Number of elements currently allocated for the pending_types_list. */
2419 static unsigned pending_types_allocated;
2421 /* Number of elements of pending_types_list currently in use. */
2422 static unsigned pending_types;
2424 /* Size (in elements) of increments by which we may expand the pending
2425 types list. Actually, a single hunk of space of this size should
2426 be enough for most typical programs. */
2427 #define PENDING_TYPES_INCREMENT 64
2429 /* A pointer to the base of a list of incomplete types which might be
2430 completed at some later time. */
2432 static tree *incomplete_types_list;
2434 /* Number of elements currently allocated for the incomplete_types_list. */
2435 static unsigned incomplete_types_allocated;
2437 /* Number of elements of incomplete_types_list currently in use. */
2438 static unsigned incomplete_types;
2440 /* Size (in elements) of increments by which we may expand the incomplete
2441 types list. Actually, a single hunk of space of this size should
2442 be enough for most typical programs. */
2443 #define INCOMPLETE_TYPES_INCREMENT 64
2445 /* Record whether the function being analyzed contains inlined functions. */
2446 static int current_function_has_inlines;
2447 #if 0 && defined (MIPS_DEBUGGING_INFO)
2448 static int comp_unit_has_inlines;
2451 /* A pointer to the ..._DECL node which we have most recently been working
2452 on. We keep this around just in case something about it looks screwy and
2453 we want to tell the user what the source coordinates for the actual
2455 static tree dwarf_last_decl;
2457 /* Forward declarations for functions defined in this file. */
2459 static void addr_const_to_string PROTO((dyn_string_t, rtx));
2460 static char *addr_to_string PROTO((rtx));
2461 static int is_pseudo_reg PROTO((rtx));
2462 static tree type_main_variant PROTO((tree));
2463 static int is_tagged_type PROTO((tree));
2464 static char *dwarf_tag_name PROTO((unsigned));
2465 static char *dwarf_attr_name PROTO((unsigned));
2466 static char *dwarf_form_name PROTO((unsigned));
2467 static char *dwarf_stack_op_name PROTO((unsigned));
2469 static char *dwarf_type_encoding_name PROTO((unsigned));
2471 static tree decl_ultimate_origin PROTO((tree));
2472 static tree block_ultimate_origin PROTO((tree));
2473 static tree decl_class_context PROTO((tree));
2474 static void add_dwarf_attr PROTO((dw_die_ref, dw_attr_ref));
2475 static void add_AT_flag PROTO((dw_die_ref,
2476 enum dwarf_attribute,
2478 static void add_AT_int PROTO((dw_die_ref,
2479 enum dwarf_attribute, long));
2480 static void add_AT_unsigned PROTO((dw_die_ref,
2481 enum dwarf_attribute,
2483 static void add_AT_long_long PROTO((dw_die_ref,
2484 enum dwarf_attribute,
2485 unsigned long, unsigned long));
2486 static void add_AT_float PROTO((dw_die_ref,
2487 enum dwarf_attribute,
2489 static void add_AT_string PROTO((dw_die_ref,
2490 enum dwarf_attribute, char *));
2491 static void add_AT_die_ref PROTO((dw_die_ref,
2492 enum dwarf_attribute,
2494 static void add_AT_fde_ref PROTO((dw_die_ref,
2495 enum dwarf_attribute,
2497 static void add_AT_loc PROTO((dw_die_ref,
2498 enum dwarf_attribute,
2500 static void add_AT_addr PROTO((dw_die_ref,
2501 enum dwarf_attribute, char *));
2502 static void add_AT_lbl_id PROTO((dw_die_ref,
2503 enum dwarf_attribute, char *));
2504 static void add_AT_lbl_offset PROTO((dw_die_ref,
2505 enum dwarf_attribute, char *));
2506 static int is_extern_subr_die PROTO((dw_die_ref));
2507 static dw_attr_ref get_AT PROTO((dw_die_ref,
2508 enum dwarf_attribute));
2509 static char *get_AT_low_pc PROTO((dw_die_ref));
2510 static char *get_AT_hi_pc PROTO((dw_die_ref));
2511 static char *get_AT_string PROTO((dw_die_ref,
2512 enum dwarf_attribute));
2513 static int get_AT_flag PROTO((dw_die_ref,
2514 enum dwarf_attribute));
2515 static unsigned get_AT_unsigned PROTO((dw_die_ref,
2516 enum dwarf_attribute));
2517 static int is_c_family PROTO((void));
2518 static int is_fortran PROTO((void));
2519 static void remove_AT PROTO((dw_die_ref,
2520 enum dwarf_attribute));
2521 static void remove_children PROTO((dw_die_ref));
2522 static void add_child_die PROTO((dw_die_ref, dw_die_ref));
2523 static dw_die_ref new_die PROTO((enum dwarf_tag, dw_die_ref));
2524 static dw_die_ref lookup_type_die PROTO((tree));
2525 static void equate_type_number_to_die PROTO((tree, dw_die_ref));
2526 static dw_die_ref lookup_decl_die PROTO((tree));
2527 static void equate_decl_number_to_die PROTO((tree, dw_die_ref));
2528 static dw_loc_descr_ref new_loc_descr PROTO((enum dwarf_location_atom,
2529 unsigned long, unsigned long));
2530 static void add_loc_descr PROTO((dw_loc_descr_ref *,
2532 static void print_spaces PROTO((FILE *));
2533 static void print_die PROTO((dw_die_ref, FILE *));
2534 static void print_dwarf_line_table PROTO((FILE *));
2535 static void add_sibling_attributes PROTO((dw_die_ref));
2536 static void build_abbrev_table PROTO((dw_die_ref));
2537 static unsigned long size_of_string PROTO((char *));
2538 static unsigned long size_of_loc_descr PROTO((dw_loc_descr_ref));
2539 static unsigned long size_of_locs PROTO((dw_loc_descr_ref));
2540 static int constant_size PROTO((long unsigned));
2541 static unsigned long size_of_die PROTO((dw_die_ref));
2542 static void calc_die_sizes PROTO((dw_die_ref));
2543 static unsigned long size_of_line_prolog PROTO((void));
2544 static unsigned long size_of_line_info PROTO((void));
2545 static unsigned long size_of_pubnames PROTO((void));
2546 static unsigned long size_of_aranges PROTO((void));
2547 static enum dwarf_form value_format PROTO((dw_val_ref));
2548 static void output_value_format PROTO((dw_val_ref));
2549 static void output_abbrev_section PROTO((void));
2550 static void output_loc_operands PROTO((dw_loc_descr_ref));
2551 static unsigned long sibling_offset PROTO((dw_die_ref));
2552 static void output_die PROTO((dw_die_ref));
2553 static void output_compilation_unit_header PROTO((void));
2554 static char *dwarf2_name PROTO((tree, int));
2555 static void add_pubname PROTO((tree, dw_die_ref));
2556 static void output_pubnames PROTO((void));
2557 static void add_arange PROTO((tree, dw_die_ref));
2558 static void output_aranges PROTO((void));
2559 static void output_line_info PROTO((void));
2560 static int is_body_block PROTO((tree));
2561 static dw_die_ref base_type_die PROTO((tree));
2562 static tree root_type PROTO((tree));
2563 static int is_base_type PROTO((tree));
2564 static dw_die_ref modified_type_die PROTO((tree, int, int, dw_die_ref));
2565 static int type_is_enum PROTO((tree));
2566 static dw_loc_descr_ref reg_loc_descriptor PROTO((rtx));
2567 static dw_loc_descr_ref based_loc_descr PROTO((unsigned, long));
2568 static int is_based_loc PROTO((rtx));
2569 static dw_loc_descr_ref mem_loc_descriptor PROTO((rtx));
2570 static dw_loc_descr_ref concat_loc_descriptor PROTO((rtx, rtx));
2571 static dw_loc_descr_ref loc_descriptor PROTO((rtx));
2572 static unsigned ceiling PROTO((unsigned, unsigned));
2573 static tree field_type PROTO((tree));
2574 static unsigned simple_type_align_in_bits PROTO((tree));
2575 static unsigned simple_type_size_in_bits PROTO((tree));
2576 static unsigned field_byte_offset PROTO((tree));
2577 static void add_AT_location_description PROTO((dw_die_ref,
2578 enum dwarf_attribute, rtx));
2579 static void add_data_member_location_attribute PROTO((dw_die_ref, tree));
2580 static void add_const_value_attribute PROTO((dw_die_ref, rtx));
2581 static void add_location_or_const_value_attribute PROTO((dw_die_ref, tree));
2582 static void add_name_attribute PROTO((dw_die_ref, char *));
2583 static void add_bound_info PROTO((dw_die_ref,
2584 enum dwarf_attribute, tree));
2585 static void add_subscript_info PROTO((dw_die_ref, tree));
2586 static void add_byte_size_attribute PROTO((dw_die_ref, tree));
2587 static void add_bit_offset_attribute PROTO((dw_die_ref, tree));
2588 static void add_bit_size_attribute PROTO((dw_die_ref, tree));
2589 static void add_prototyped_attribute PROTO((dw_die_ref, tree));
2590 static void add_abstract_origin_attribute PROTO((dw_die_ref, tree));
2591 static void add_pure_or_virtual_attribute PROTO((dw_die_ref, tree));
2592 static void add_src_coords_attributes PROTO((dw_die_ref, tree));
2593 static void add_name_and_src_coords_attributes PROTO((dw_die_ref, tree));
2594 static void push_decl_scope PROTO((tree));
2595 static dw_die_ref scope_die_for PROTO((tree, dw_die_ref));
2596 static void pop_decl_scope PROTO((void));
2597 static void add_type_attribute PROTO((dw_die_ref, tree, int, int,
2599 static char *type_tag PROTO((tree));
2600 static tree member_declared_type PROTO((tree));
2602 static char *decl_start_label PROTO((tree));
2604 static void gen_array_type_die PROTO((tree, dw_die_ref));
2605 static void gen_set_type_die PROTO((tree, dw_die_ref));
2607 static void gen_entry_point_die PROTO((tree, dw_die_ref));
2609 static void pend_type PROTO((tree));
2610 static void output_pending_types_for_scope PROTO((dw_die_ref));
2611 static void gen_inlined_enumeration_type_die PROTO((tree, dw_die_ref));
2612 static void gen_inlined_structure_type_die PROTO((tree, dw_die_ref));
2613 static void gen_inlined_union_type_die PROTO((tree, dw_die_ref));
2614 static void gen_enumeration_type_die PROTO((tree, dw_die_ref));
2615 static dw_die_ref gen_formal_parameter_die PROTO((tree, dw_die_ref));
2616 static void gen_unspecified_parameters_die PROTO((tree, dw_die_ref));
2617 static void gen_formal_types_die PROTO((tree, dw_die_ref));
2618 static void gen_subprogram_die PROTO((tree, dw_die_ref));
2619 static void gen_variable_die PROTO((tree, dw_die_ref));
2620 static void gen_label_die PROTO((tree, dw_die_ref));
2621 static void gen_lexical_block_die PROTO((tree, dw_die_ref, int));
2622 static void gen_inlined_subroutine_die PROTO((tree, dw_die_ref, int));
2623 static void gen_field_die PROTO((tree, dw_die_ref));
2624 static void gen_ptr_to_mbr_type_die PROTO((tree, dw_die_ref));
2625 static void gen_compile_unit_die PROTO((char *));
2626 static void gen_string_type_die PROTO((tree, dw_die_ref));
2627 static void gen_inheritance_die PROTO((tree, dw_die_ref));
2628 static void gen_member_die PROTO((tree, dw_die_ref));
2629 static void gen_struct_or_union_type_die PROTO((tree, dw_die_ref));
2630 static void gen_subroutine_type_die PROTO((tree, dw_die_ref));
2631 static void gen_typedef_die PROTO((tree, dw_die_ref));
2632 static void gen_type_die PROTO((tree, dw_die_ref));
2633 static void gen_tagged_type_instantiation_die PROTO((tree, dw_die_ref));
2634 static void gen_block_die PROTO((tree, dw_die_ref, int));
2635 static void decls_for_scope PROTO((tree, dw_die_ref, int));
2636 static int is_redundant_typedef PROTO((tree));
2637 static void gen_decl_die PROTO((tree, dw_die_ref));
2638 static unsigned lookup_filename PROTO((char *));
2640 /* Section names used to hold DWARF debugging information. */
2641 #ifndef DEBUG_INFO_SECTION
2642 #define DEBUG_INFO_SECTION ".debug_info"
2644 #ifndef ABBREV_SECTION
2645 #define ABBREV_SECTION ".debug_abbrev"
2647 #ifndef ARANGES_SECTION
2648 #define ARANGES_SECTION ".debug_aranges"
2650 #ifndef DW_MACINFO_SECTION
2651 #define DW_MACINFO_SECTION ".debug_macinfo"
2653 #ifndef DEBUG_LINE_SECTION
2654 #define DEBUG_LINE_SECTION ".debug_line"
2657 #define LOC_SECTION ".debug_loc"
2659 #ifndef PUBNAMES_SECTION
2660 #define PUBNAMES_SECTION ".debug_pubnames"
2663 #define STR_SECTION ".debug_str"
2666 /* Standard ELF section names for compiled code and data. */
2667 #ifndef TEXT_SECTION
2668 #define TEXT_SECTION ".text"
2670 #ifndef DATA_SECTION
2671 #define DATA_SECTION ".data"
2674 #define BSS_SECTION ".bss"
2677 /* Labels we insert at beginning sections we can reference instead of
2678 the section names themselves. */
2680 #ifndef TEXT_SECTION_LABEL
2681 #define TEXT_SECTION_LABEL "Ltext"
2683 #ifndef DEBUG_LINE_SECTION_LABEL
2684 #define DEBUG_LINE_SECTION_LABEL "Ldebug_line"
2686 #ifndef DEBUG_INFO_SECTION_LABEL
2687 #define DEBUG_INFO_SECTION_LABEL "Ldebug_info"
2689 #ifndef ABBREV_SECTION_LABEL
2690 #define ABBREV_SECTION_LABEL "Ldebug_abbrev"
2694 /* Definitions of defaults for formats and names of various special
2695 (artificial) labels which may be generated within this file (when the -g
2696 options is used and DWARF_DEBUGGING_INFO is in effect.
2697 If necessary, these may be overridden from within the tm.h file, but
2698 typically, overriding these defaults is unnecessary. */
2700 static char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
2701 static char text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
2702 static char abbrev_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
2703 static char debug_info_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
2704 static char debug_line_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
2706 #ifndef TEXT_END_LABEL
2707 #define TEXT_END_LABEL "Letext"
2709 #ifndef DATA_END_LABEL
2710 #define DATA_END_LABEL "Ledata"
2712 #ifndef BSS_END_LABEL
2713 #define BSS_END_LABEL "Lebss"
2715 #ifndef INSN_LABEL_FMT
2716 #define INSN_LABEL_FMT "LI%u_"
2718 #ifndef BLOCK_BEGIN_LABEL
2719 #define BLOCK_BEGIN_LABEL "LBB"
2721 #ifndef BLOCK_END_LABEL
2722 #define BLOCK_END_LABEL "LBE"
2724 #ifndef BODY_BEGIN_LABEL
2725 #define BODY_BEGIN_LABEL "Lbb"
2727 #ifndef BODY_END_LABEL
2728 #define BODY_END_LABEL "Lbe"
2730 #ifndef LINE_CODE_LABEL
2731 #define LINE_CODE_LABEL "LM"
2733 #ifndef SEPARATE_LINE_CODE_LABEL
2734 #define SEPARATE_LINE_CODE_LABEL "LSM"
2737 /* Convert a reference to the assembler name of a C-level name. This
2738 macro has the same effect as ASM_OUTPUT_LABELREF, but copies to
2739 a string rather than writing to a file. */
2740 #ifndef ASM_NAME_TO_STRING
2741 #define ASM_NAME_TO_STRING(STR, NAME) \
2743 if ((NAME)[0] == '*') \
2744 dyn_string_append (STR, NAME + 1); \
2747 const char *newstr; \
2748 STRIP_NAME_ENCODING (newstr, NAME); \
2749 dyn_string_append (STR, user_label_prefix); \
2750 dyn_string_append (STR, newstr); \
2756 /* Convert an integer constant expression into assembler syntax. Addition
2757 and subtraction are the only arithmetic that may appear in these
2758 expressions. This is an adaptation of output_addr_const in final.c.
2759 Here, the target of the conversion is a string buffer. We can't use
2760 output_addr_const directly, because it writes to a file. */
2763 addr_const_to_string (str, x)
2770 switch (GET_CODE (x))
2774 dyn_string_append (str, ",");
2780 ASM_NAME_TO_STRING (str, XSTR (x, 0));
2784 ASM_GENERATE_INTERNAL_LABEL (buf1, "L", CODE_LABEL_NUMBER (XEXP (x, 0)));
2785 ASM_NAME_TO_STRING (str, buf1);
2789 ASM_GENERATE_INTERNAL_LABEL (buf1, "L", CODE_LABEL_NUMBER (x));
2790 ASM_NAME_TO_STRING (str, buf1);
2794 sprintf (buf1, HOST_WIDE_INT_PRINT_DEC, INTVAL (x));
2795 dyn_string_append (str, buf1);
2799 /* This used to output parentheses around the expression, but that does
2800 not work on the 386 (either ATT or BSD assembler). */
2801 addr_const_to_string (str, XEXP (x, 0));
2805 if (GET_MODE (x) == VOIDmode)
2807 /* We can use %d if the number is one word and positive. */
2808 if (CONST_DOUBLE_HIGH (x))
2809 sprintf (buf1, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
2810 CONST_DOUBLE_HIGH (x), CONST_DOUBLE_LOW (x));
2811 else if (CONST_DOUBLE_LOW (x) < 0)
2812 sprintf (buf1, HOST_WIDE_INT_PRINT_HEX, CONST_DOUBLE_LOW (x));
2814 sprintf (buf1, HOST_WIDE_INT_PRINT_DEC,
2815 CONST_DOUBLE_LOW (x));
2816 dyn_string_append (str, buf1);
2819 /* We can't handle floating point constants; PRINT_OPERAND must
2821 output_operand_lossage ("floating constant misused");
2825 /* Some assemblers need integer constants to appear last (eg masm). */
2826 if (GET_CODE (XEXP (x, 0)) == CONST_INT)
2828 addr_const_to_string (str, XEXP (x, 1));
2829 if (INTVAL (XEXP (x, 0)) >= 0)
2830 dyn_string_append (str, "+");
2832 addr_const_to_string (str, XEXP (x, 0));
2836 addr_const_to_string (str, XEXP (x, 0));
2837 if (INTVAL (XEXP (x, 1)) >= 0)
2838 dyn_string_append (str, "+");
2840 addr_const_to_string (str, XEXP (x, 1));
2845 /* Avoid outputting things like x-x or x+5-x, since some assemblers
2846 can't handle that. */
2847 x = simplify_subtraction (x);
2848 if (GET_CODE (x) != MINUS)
2851 addr_const_to_string (str, XEXP (x, 0));
2852 dyn_string_append (str, "-");
2853 if (GET_CODE (XEXP (x, 1)) == CONST_INT
2854 && INTVAL (XEXP (x, 1)) < 0)
2856 dyn_string_append (str, ASM_OPEN_PAREN);
2857 addr_const_to_string (str, XEXP (x, 1));
2858 dyn_string_append (str, ASM_CLOSE_PAREN);
2861 addr_const_to_string (str, XEXP (x, 1));
2866 addr_const_to_string (str, XEXP (x, 0));
2870 output_operand_lossage ("invalid expression as operand");
2874 /* Convert an address constant to a string, and return a pointer to
2875 a copy of the result, located on the heap. */
2881 dyn_string_t ds = dyn_string_new (256);
2884 addr_const_to_string (ds, x);
2886 /* Return the dynamically allocated string, but free the
2887 dyn_string_t itself. */
2893 /* Test if rtl node points to a pseudo register. */
2899 return (((GET_CODE (rtl) == REG) && (REGNO (rtl) >= FIRST_PSEUDO_REGISTER))
2900 || ((GET_CODE (rtl) == SUBREG)
2901 && (REGNO (XEXP (rtl, 0)) >= FIRST_PSEUDO_REGISTER)));
2904 /* Return a reference to a type, with its const and volatile qualifiers
2908 type_main_variant (type)
2911 type = TYPE_MAIN_VARIANT (type);
2913 /* There really should be only one main variant among any group of variants
2914 of a given type (and all of the MAIN_VARIANT values for all members of
2915 the group should point to that one type) but sometimes the C front-end
2916 messes this up for array types, so we work around that bug here. */
2918 if (TREE_CODE (type) == ARRAY_TYPE)
2919 while (type != TYPE_MAIN_VARIANT (type))
2920 type = TYPE_MAIN_VARIANT (type);
2925 /* Return non-zero if the given type node represents a tagged type. */
2928 is_tagged_type (type)
2931 register enum tree_code code = TREE_CODE (type);
2933 return (code == RECORD_TYPE || code == UNION_TYPE
2934 || code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE);
2937 /* Convert a DIE tag into its string name. */
2940 dwarf_tag_name (tag)
2941 register unsigned tag;
2945 case DW_TAG_padding:
2946 return "DW_TAG_padding";
2947 case DW_TAG_array_type:
2948 return "DW_TAG_array_type";
2949 case DW_TAG_class_type:
2950 return "DW_TAG_class_type";
2951 case DW_TAG_entry_point:
2952 return "DW_TAG_entry_point";
2953 case DW_TAG_enumeration_type:
2954 return "DW_TAG_enumeration_type";
2955 case DW_TAG_formal_parameter:
2956 return "DW_TAG_formal_parameter";
2957 case DW_TAG_imported_declaration:
2958 return "DW_TAG_imported_declaration";
2960 return "DW_TAG_label";
2961 case DW_TAG_lexical_block:
2962 return "DW_TAG_lexical_block";
2964 return "DW_TAG_member";
2965 case DW_TAG_pointer_type:
2966 return "DW_TAG_pointer_type";
2967 case DW_TAG_reference_type:
2968 return "DW_TAG_reference_type";
2969 case DW_TAG_compile_unit:
2970 return "DW_TAG_compile_unit";
2971 case DW_TAG_string_type:
2972 return "DW_TAG_string_type";
2973 case DW_TAG_structure_type:
2974 return "DW_TAG_structure_type";
2975 case DW_TAG_subroutine_type:
2976 return "DW_TAG_subroutine_type";
2977 case DW_TAG_typedef:
2978 return "DW_TAG_typedef";
2979 case DW_TAG_union_type:
2980 return "DW_TAG_union_type";
2981 case DW_TAG_unspecified_parameters:
2982 return "DW_TAG_unspecified_parameters";
2983 case DW_TAG_variant:
2984 return "DW_TAG_variant";
2985 case DW_TAG_common_block:
2986 return "DW_TAG_common_block";
2987 case DW_TAG_common_inclusion:
2988 return "DW_TAG_common_inclusion";
2989 case DW_TAG_inheritance:
2990 return "DW_TAG_inheritance";
2991 case DW_TAG_inlined_subroutine:
2992 return "DW_TAG_inlined_subroutine";
2994 return "DW_TAG_module";
2995 case DW_TAG_ptr_to_member_type:
2996 return "DW_TAG_ptr_to_member_type";
2997 case DW_TAG_set_type:
2998 return "DW_TAG_set_type";
2999 case DW_TAG_subrange_type:
3000 return "DW_TAG_subrange_type";
3001 case DW_TAG_with_stmt:
3002 return "DW_TAG_with_stmt";
3003 case DW_TAG_access_declaration:
3004 return "DW_TAG_access_declaration";
3005 case DW_TAG_base_type:
3006 return "DW_TAG_base_type";
3007 case DW_TAG_catch_block:
3008 return "DW_TAG_catch_block";
3009 case DW_TAG_const_type:
3010 return "DW_TAG_const_type";
3011 case DW_TAG_constant:
3012 return "DW_TAG_constant";
3013 case DW_TAG_enumerator:
3014 return "DW_TAG_enumerator";
3015 case DW_TAG_file_type:
3016 return "DW_TAG_file_type";
3018 return "DW_TAG_friend";
3019 case DW_TAG_namelist:
3020 return "DW_TAG_namelist";
3021 case DW_TAG_namelist_item:
3022 return "DW_TAG_namelist_item";
3023 case DW_TAG_packed_type:
3024 return "DW_TAG_packed_type";
3025 case DW_TAG_subprogram:
3026 return "DW_TAG_subprogram";
3027 case DW_TAG_template_type_param:
3028 return "DW_TAG_template_type_param";
3029 case DW_TAG_template_value_param:
3030 return "DW_TAG_template_value_param";
3031 case DW_TAG_thrown_type:
3032 return "DW_TAG_thrown_type";
3033 case DW_TAG_try_block:
3034 return "DW_TAG_try_block";
3035 case DW_TAG_variant_part:
3036 return "DW_TAG_variant_part";
3037 case DW_TAG_variable:
3038 return "DW_TAG_variable";
3039 case DW_TAG_volatile_type:
3040 return "DW_TAG_volatile_type";
3041 case DW_TAG_MIPS_loop:
3042 return "DW_TAG_MIPS_loop";
3043 case DW_TAG_format_label:
3044 return "DW_TAG_format_label";
3045 case DW_TAG_function_template:
3046 return "DW_TAG_function_template";
3047 case DW_TAG_class_template:
3048 return "DW_TAG_class_template";
3050 return "DW_TAG_<unknown>";
3054 /* Convert a DWARF attribute code into its string name. */
3057 dwarf_attr_name (attr)
3058 register unsigned attr;
3063 return "DW_AT_sibling";
3064 case DW_AT_location:
3065 return "DW_AT_location";
3067 return "DW_AT_name";
3068 case DW_AT_ordering:
3069 return "DW_AT_ordering";
3070 case DW_AT_subscr_data:
3071 return "DW_AT_subscr_data";
3072 case DW_AT_byte_size:
3073 return "DW_AT_byte_size";
3074 case DW_AT_bit_offset:
3075 return "DW_AT_bit_offset";
3076 case DW_AT_bit_size:
3077 return "DW_AT_bit_size";
3078 case DW_AT_element_list:
3079 return "DW_AT_element_list";
3080 case DW_AT_stmt_list:
3081 return "DW_AT_stmt_list";
3083 return "DW_AT_low_pc";
3085 return "DW_AT_high_pc";
3086 case DW_AT_language:
3087 return "DW_AT_language";
3089 return "DW_AT_member";
3091 return "DW_AT_discr";
3092 case DW_AT_discr_value:
3093 return "DW_AT_discr_value";
3094 case DW_AT_visibility:
3095 return "DW_AT_visibility";
3097 return "DW_AT_import";
3098 case DW_AT_string_length:
3099 return "DW_AT_string_length";
3100 case DW_AT_common_reference:
3101 return "DW_AT_common_reference";
3102 case DW_AT_comp_dir:
3103 return "DW_AT_comp_dir";
3104 case DW_AT_const_value:
3105 return "DW_AT_const_value";
3106 case DW_AT_containing_type:
3107 return "DW_AT_containing_type";
3108 case DW_AT_default_value:
3109 return "DW_AT_default_value";
3111 return "DW_AT_inline";
3112 case DW_AT_is_optional:
3113 return "DW_AT_is_optional";
3114 case DW_AT_lower_bound:
3115 return "DW_AT_lower_bound";
3116 case DW_AT_producer:
3117 return "DW_AT_producer";
3118 case DW_AT_prototyped:
3119 return "DW_AT_prototyped";
3120 case DW_AT_return_addr:
3121 return "DW_AT_return_addr";
3122 case DW_AT_start_scope:
3123 return "DW_AT_start_scope";
3124 case DW_AT_stride_size:
3125 return "DW_AT_stride_size";
3126 case DW_AT_upper_bound:
3127 return "DW_AT_upper_bound";
3128 case DW_AT_abstract_origin:
3129 return "DW_AT_abstract_origin";
3130 case DW_AT_accessibility:
3131 return "DW_AT_accessibility";
3132 case DW_AT_address_class:
3133 return "DW_AT_address_class";
3134 case DW_AT_artificial:
3135 return "DW_AT_artificial";
3136 case DW_AT_base_types:
3137 return "DW_AT_base_types";
3138 case DW_AT_calling_convention:
3139 return "DW_AT_calling_convention";
3141 return "DW_AT_count";
3142 case DW_AT_data_member_location:
3143 return "DW_AT_data_member_location";
3144 case DW_AT_decl_column:
3145 return "DW_AT_decl_column";
3146 case DW_AT_decl_file:
3147 return "DW_AT_decl_file";
3148 case DW_AT_decl_line:
3149 return "DW_AT_decl_line";
3150 case DW_AT_declaration:
3151 return "DW_AT_declaration";
3152 case DW_AT_discr_list:
3153 return "DW_AT_discr_list";
3154 case DW_AT_encoding:
3155 return "DW_AT_encoding";
3156 case DW_AT_external:
3157 return "DW_AT_external";
3158 case DW_AT_frame_base:
3159 return "DW_AT_frame_base";
3161 return "DW_AT_friend";
3162 case DW_AT_identifier_case:
3163 return "DW_AT_identifier_case";
3164 case DW_AT_macro_info:
3165 return "DW_AT_macro_info";
3166 case DW_AT_namelist_items:
3167 return "DW_AT_namelist_items";
3168 case DW_AT_priority:
3169 return "DW_AT_priority";
3171 return "DW_AT_segment";
3172 case DW_AT_specification:
3173 return "DW_AT_specification";
3174 case DW_AT_static_link:
3175 return "DW_AT_static_link";
3177 return "DW_AT_type";
3178 case DW_AT_use_location:
3179 return "DW_AT_use_location";
3180 case DW_AT_variable_parameter:
3181 return "DW_AT_variable_parameter";
3182 case DW_AT_virtuality:
3183 return "DW_AT_virtuality";
3184 case DW_AT_vtable_elem_location:
3185 return "DW_AT_vtable_elem_location";
3187 case DW_AT_MIPS_fde:
3188 return "DW_AT_MIPS_fde";
3189 case DW_AT_MIPS_loop_begin:
3190 return "DW_AT_MIPS_loop_begin";
3191 case DW_AT_MIPS_tail_loop_begin:
3192 return "DW_AT_MIPS_tail_loop_begin";
3193 case DW_AT_MIPS_epilog_begin:
3194 return "DW_AT_MIPS_epilog_begin";
3195 case DW_AT_MIPS_loop_unroll_factor:
3196 return "DW_AT_MIPS_loop_unroll_factor";
3197 case DW_AT_MIPS_software_pipeline_depth:
3198 return "DW_AT_MIPS_software_pipeline_depth";
3199 case DW_AT_MIPS_linkage_name:
3200 return "DW_AT_MIPS_linkage_name";
3201 case DW_AT_MIPS_stride:
3202 return "DW_AT_MIPS_stride";
3203 case DW_AT_MIPS_abstract_name:
3204 return "DW_AT_MIPS_abstract_name";
3205 case DW_AT_MIPS_clone_origin:
3206 return "DW_AT_MIPS_clone_origin";
3207 case DW_AT_MIPS_has_inlines:
3208 return "DW_AT_MIPS_has_inlines";
3210 case DW_AT_sf_names:
3211 return "DW_AT_sf_names";
3212 case DW_AT_src_info:
3213 return "DW_AT_src_info";
3214 case DW_AT_mac_info:
3215 return "DW_AT_mac_info";
3216 case DW_AT_src_coords:
3217 return "DW_AT_src_coords";
3218 case DW_AT_body_begin:
3219 return "DW_AT_body_begin";
3220 case DW_AT_body_end:
3221 return "DW_AT_body_end";
3223 return "DW_AT_<unknown>";
3227 /* Convert a DWARF value form code into its string name. */
3230 dwarf_form_name (form)
3231 register unsigned form;
3236 return "DW_FORM_addr";
3237 case DW_FORM_block2:
3238 return "DW_FORM_block2";
3239 case DW_FORM_block4:
3240 return "DW_FORM_block4";
3242 return "DW_FORM_data2";
3244 return "DW_FORM_data4";
3246 return "DW_FORM_data8";
3247 case DW_FORM_string:
3248 return "DW_FORM_string";
3250 return "DW_FORM_block";
3251 case DW_FORM_block1:
3252 return "DW_FORM_block1";
3254 return "DW_FORM_data1";
3256 return "DW_FORM_flag";
3258 return "DW_FORM_sdata";
3260 return "DW_FORM_strp";
3262 return "DW_FORM_udata";
3263 case DW_FORM_ref_addr:
3264 return "DW_FORM_ref_addr";
3266 return "DW_FORM_ref1";
3268 return "DW_FORM_ref2";
3270 return "DW_FORM_ref4";
3272 return "DW_FORM_ref8";
3273 case DW_FORM_ref_udata:
3274 return "DW_FORM_ref_udata";
3275 case DW_FORM_indirect:
3276 return "DW_FORM_indirect";
3278 return "DW_FORM_<unknown>";
3282 /* Convert a DWARF stack opcode into its string name. */
3285 dwarf_stack_op_name (op)
3286 register unsigned op;
3291 return "DW_OP_addr";
3293 return "DW_OP_deref";
3295 return "DW_OP_const1u";
3297 return "DW_OP_const1s";
3299 return "DW_OP_const2u";
3301 return "DW_OP_const2s";
3303 return "DW_OP_const4u";
3305 return "DW_OP_const4s";
3307 return "DW_OP_const8u";
3309 return "DW_OP_const8s";
3311 return "DW_OP_constu";
3313 return "DW_OP_consts";
3317 return "DW_OP_drop";
3319 return "DW_OP_over";
3321 return "DW_OP_pick";
3323 return "DW_OP_swap";
3327 return "DW_OP_xderef";
3335 return "DW_OP_minus";
3347 return "DW_OP_plus";
3348 case DW_OP_plus_uconst:
3349 return "DW_OP_plus_uconst";
3355 return "DW_OP_shra";
3373 return "DW_OP_skip";
3375 return "DW_OP_lit0";
3377 return "DW_OP_lit1";
3379 return "DW_OP_lit2";
3381 return "DW_OP_lit3";
3383 return "DW_OP_lit4";
3385 return "DW_OP_lit5";
3387 return "DW_OP_lit6";
3389 return "DW_OP_lit7";
3391 return "DW_OP_lit8";
3393 return "DW_OP_lit9";
3395 return "DW_OP_lit10";
3397 return "DW_OP_lit11";
3399 return "DW_OP_lit12";
3401 return "DW_OP_lit13";
3403 return "DW_OP_lit14";
3405 return "DW_OP_lit15";
3407 return "DW_OP_lit16";
3409 return "DW_OP_lit17";
3411 return "DW_OP_lit18";
3413 return "DW_OP_lit19";
3415 return "DW_OP_lit20";
3417 return "DW_OP_lit21";
3419 return "DW_OP_lit22";
3421 return "DW_OP_lit23";
3423 return "DW_OP_lit24";
3425 return "DW_OP_lit25";
3427 return "DW_OP_lit26";
3429 return "DW_OP_lit27";
3431 return "DW_OP_lit28";
3433 return "DW_OP_lit29";
3435 return "DW_OP_lit30";
3437 return "DW_OP_lit31";
3439 return "DW_OP_reg0";
3441 return "DW_OP_reg1";
3443 return "DW_OP_reg2";
3445 return "DW_OP_reg3";
3447 return "DW_OP_reg4";
3449 return "DW_OP_reg5";
3451 return "DW_OP_reg6";
3453 return "DW_OP_reg7";
3455 return "DW_OP_reg8";
3457 return "DW_OP_reg9";
3459 return "DW_OP_reg10";
3461 return "DW_OP_reg11";
3463 return "DW_OP_reg12";
3465 return "DW_OP_reg13";
3467 return "DW_OP_reg14";
3469 return "DW_OP_reg15";
3471 return "DW_OP_reg16";
3473 return "DW_OP_reg17";
3475 return "DW_OP_reg18";
3477 return "DW_OP_reg19";
3479 return "DW_OP_reg20";
3481 return "DW_OP_reg21";
3483 return "DW_OP_reg22";
3485 return "DW_OP_reg23";
3487 return "DW_OP_reg24";
3489 return "DW_OP_reg25";
3491 return "DW_OP_reg26";
3493 return "DW_OP_reg27";
3495 return "DW_OP_reg28";
3497 return "DW_OP_reg29";
3499 return "DW_OP_reg30";
3501 return "DW_OP_reg31";
3503 return "DW_OP_breg0";
3505 return "DW_OP_breg1";
3507 return "DW_OP_breg2";
3509 return "DW_OP_breg3";
3511 return "DW_OP_breg4";
3513 return "DW_OP_breg5";
3515 return "DW_OP_breg6";
3517 return "DW_OP_breg7";
3519 return "DW_OP_breg8";
3521 return "DW_OP_breg9";
3523 return "DW_OP_breg10";
3525 return "DW_OP_breg11";
3527 return "DW_OP_breg12";
3529 return "DW_OP_breg13";
3531 return "DW_OP_breg14";
3533 return "DW_OP_breg15";
3535 return "DW_OP_breg16";
3537 return "DW_OP_breg17";
3539 return "DW_OP_breg18";
3541 return "DW_OP_breg19";
3543 return "DW_OP_breg20";
3545 return "DW_OP_breg21";
3547 return "DW_OP_breg22";
3549 return "DW_OP_breg23";
3551 return "DW_OP_breg24";
3553 return "DW_OP_breg25";
3555 return "DW_OP_breg26";
3557 return "DW_OP_breg27";
3559 return "DW_OP_breg28";
3561 return "DW_OP_breg29";
3563 return "DW_OP_breg30";
3565 return "DW_OP_breg31";
3567 return "DW_OP_regx";
3569 return "DW_OP_fbreg";
3571 return "DW_OP_bregx";
3573 return "DW_OP_piece";
3574 case DW_OP_deref_size:
3575 return "DW_OP_deref_size";
3576 case DW_OP_xderef_size:
3577 return "DW_OP_xderef_size";
3581 return "OP_<unknown>";
3585 /* Convert a DWARF type code into its string name. */
3589 dwarf_type_encoding_name (enc)
3590 register unsigned enc;
3594 case DW_ATE_address:
3595 return "DW_ATE_address";
3596 case DW_ATE_boolean:
3597 return "DW_ATE_boolean";
3598 case DW_ATE_complex_float:
3599 return "DW_ATE_complex_float";
3601 return "DW_ATE_float";
3603 return "DW_ATE_signed";
3604 case DW_ATE_signed_char:
3605 return "DW_ATE_signed_char";
3606 case DW_ATE_unsigned:
3607 return "DW_ATE_unsigned";
3608 case DW_ATE_unsigned_char:
3609 return "DW_ATE_unsigned_char";
3611 return "DW_ATE_<unknown>";
3616 /* Determine the "ultimate origin" of a decl. The decl may be an inlined
3617 instance of an inlined instance of a decl which is local to an inline
3618 function, so we have to trace all of the way back through the origin chain
3619 to find out what sort of node actually served as the original seed for the
3623 decl_ultimate_origin (decl)
3626 #ifdef ENABLE_CHECKING
3627 if (DECL_FROM_INLINE (DECL_ORIGIN (decl)))
3628 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
3629 most distant ancestor, this should never happen. */
3633 return DECL_ABSTRACT_ORIGIN (decl);
3636 /* Determine the "ultimate origin" of a block. The block may be an inlined
3637 instance of an inlined instance of a block which is local to an inline
3638 function, so we have to trace all of the way back through the origin chain
3639 to find out what sort of node actually served as the original seed for the
3643 block_ultimate_origin (block)
3644 register tree block;
3646 register tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block);
3648 if (immediate_origin == NULL_TREE)
3652 register tree ret_val;
3653 register tree lookahead = immediate_origin;
3657 ret_val = lookahead;
3658 lookahead = (TREE_CODE (ret_val) == BLOCK)
3659 ? BLOCK_ABSTRACT_ORIGIN (ret_val)
3662 while (lookahead != NULL && lookahead != ret_val);
3668 /* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT
3669 of a virtual function may refer to a base class, so we check the 'this'
3673 decl_class_context (decl)
3676 tree context = NULL_TREE;
3678 if (TREE_CODE (decl) != FUNCTION_DECL || ! DECL_VINDEX (decl))
3679 context = DECL_CONTEXT (decl);
3681 context = TYPE_MAIN_VARIANT
3682 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
3684 if (context && TREE_CODE_CLASS (TREE_CODE (context)) != 't')
3685 context = NULL_TREE;
3690 /* Add an attribute/value pair to a DIE */
3693 add_dwarf_attr (die, attr)
3694 register dw_die_ref die;
3695 register dw_attr_ref attr;
3697 if (die != NULL && attr != NULL)
3699 if (die->die_attr == NULL)
3701 die->die_attr = attr;
3702 die->die_attr_last = attr;
3706 die->die_attr_last->dw_attr_next = attr;
3707 die->die_attr_last = attr;
3712 /* Add a flag value attribute to a DIE. */
3715 add_AT_flag (die, attr_kind, flag)
3716 register dw_die_ref die;
3717 register enum dwarf_attribute attr_kind;
3718 register unsigned flag;
3720 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3722 attr->dw_attr_next = NULL;
3723 attr->dw_attr = attr_kind;
3724 attr->dw_attr_val.val_class = dw_val_class_flag;
3725 attr->dw_attr_val.v.val_flag = flag;
3726 add_dwarf_attr (die, attr);
3729 /* Add a signed integer attribute value to a DIE. */
3732 add_AT_int (die, attr_kind, int_val)
3733 register dw_die_ref die;
3734 register enum dwarf_attribute attr_kind;
3735 register long int int_val;
3737 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3739 attr->dw_attr_next = NULL;
3740 attr->dw_attr = attr_kind;
3741 attr->dw_attr_val.val_class = dw_val_class_const;
3742 attr->dw_attr_val.v.val_int = int_val;
3743 add_dwarf_attr (die, attr);
3746 /* Add an unsigned integer attribute value to a DIE. */
3749 add_AT_unsigned (die, attr_kind, unsigned_val)
3750 register dw_die_ref die;
3751 register enum dwarf_attribute attr_kind;
3752 register unsigned long unsigned_val;
3754 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3756 attr->dw_attr_next = NULL;
3757 attr->dw_attr = attr_kind;
3758 attr->dw_attr_val.val_class = dw_val_class_unsigned_const;
3759 attr->dw_attr_val.v.val_unsigned = unsigned_val;
3760 add_dwarf_attr (die, attr);
3763 /* Add an unsigned double integer attribute value to a DIE. */
3766 add_AT_long_long (die, attr_kind, val_hi, val_low)
3767 register dw_die_ref die;
3768 register enum dwarf_attribute attr_kind;
3769 register unsigned long val_hi;
3770 register unsigned long val_low;
3772 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3774 attr->dw_attr_next = NULL;
3775 attr->dw_attr = attr_kind;
3776 attr->dw_attr_val.val_class = dw_val_class_long_long;
3777 attr->dw_attr_val.v.val_long_long.hi = val_hi;
3778 attr->dw_attr_val.v.val_long_long.low = val_low;
3779 add_dwarf_attr (die, attr);
3782 /* Add a floating point attribute value to a DIE and return it. */
3785 add_AT_float (die, attr_kind, length, array)
3786 register dw_die_ref die;
3787 register enum dwarf_attribute attr_kind;
3788 register unsigned length;
3789 register long *array;
3791 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3793 attr->dw_attr_next = NULL;
3794 attr->dw_attr = attr_kind;
3795 attr->dw_attr_val.val_class = dw_val_class_float;
3796 attr->dw_attr_val.v.val_float.length = length;
3797 attr->dw_attr_val.v.val_float.array = array;
3798 add_dwarf_attr (die, attr);
3801 /* Add a string attribute value to a DIE. */
3804 add_AT_string (die, attr_kind, str)
3805 register dw_die_ref die;
3806 register enum dwarf_attribute attr_kind;
3809 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3811 attr->dw_attr_next = NULL;
3812 attr->dw_attr = attr_kind;
3813 attr->dw_attr_val.val_class = dw_val_class_str;
3814 attr->dw_attr_val.v.val_str = xstrdup (str);
3815 add_dwarf_attr (die, attr);
3818 /* Add a DIE reference attribute value to a DIE. */
3821 add_AT_die_ref (die, attr_kind, targ_die)
3822 register dw_die_ref die;
3823 register enum dwarf_attribute attr_kind;
3824 register dw_die_ref targ_die;
3826 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3828 attr->dw_attr_next = NULL;
3829 attr->dw_attr = attr_kind;
3830 attr->dw_attr_val.val_class = dw_val_class_die_ref;
3831 attr->dw_attr_val.v.val_die_ref = targ_die;
3832 add_dwarf_attr (die, attr);
3835 /* Add an FDE reference attribute value to a DIE. */
3838 add_AT_fde_ref (die, attr_kind, targ_fde)
3839 register dw_die_ref die;
3840 register enum dwarf_attribute attr_kind;
3841 register unsigned targ_fde;
3843 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3845 attr->dw_attr_next = NULL;
3846 attr->dw_attr = attr_kind;
3847 attr->dw_attr_val.val_class = dw_val_class_fde_ref;
3848 attr->dw_attr_val.v.val_fde_index = targ_fde;
3849 add_dwarf_attr (die, attr);
3852 /* Add a location description attribute value to a DIE. */
3855 add_AT_loc (die, attr_kind, loc)
3856 register dw_die_ref die;
3857 register enum dwarf_attribute attr_kind;
3858 register dw_loc_descr_ref loc;
3860 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3862 attr->dw_attr_next = NULL;
3863 attr->dw_attr = attr_kind;
3864 attr->dw_attr_val.val_class = dw_val_class_loc;
3865 attr->dw_attr_val.v.val_loc = loc;
3866 add_dwarf_attr (die, attr);
3869 /* Add an address constant attribute value to a DIE. */
3872 add_AT_addr (die, attr_kind, addr)
3873 register dw_die_ref die;
3874 register enum dwarf_attribute attr_kind;
3877 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3879 attr->dw_attr_next = NULL;
3880 attr->dw_attr = attr_kind;
3881 attr->dw_attr_val.val_class = dw_val_class_addr;
3882 attr->dw_attr_val.v.val_addr = addr;
3883 add_dwarf_attr (die, attr);
3886 /* Add a label identifier attribute value to a DIE. */
3889 add_AT_lbl_id (die, attr_kind, lbl_id)
3890 register dw_die_ref die;
3891 register enum dwarf_attribute attr_kind;
3892 register char *lbl_id;
3894 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3896 attr->dw_attr_next = NULL;
3897 attr->dw_attr = attr_kind;
3898 attr->dw_attr_val.val_class = dw_val_class_lbl_id;
3899 attr->dw_attr_val.v.val_lbl_id = xstrdup (lbl_id);
3900 add_dwarf_attr (die, attr);
3903 /* Add a section offset attribute value to a DIE. */
3906 add_AT_lbl_offset (die, attr_kind, label)
3907 register dw_die_ref die;
3908 register enum dwarf_attribute attr_kind;
3909 register char *label;
3911 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3913 attr->dw_attr_next = NULL;
3914 attr->dw_attr = attr_kind;
3915 attr->dw_attr_val.val_class = dw_val_class_lbl_offset;
3916 attr->dw_attr_val.v.val_lbl_id = label;
3917 add_dwarf_attr (die, attr);
3921 /* Test if die refers to an external subroutine. */
3924 is_extern_subr_die (die)
3925 register dw_die_ref die;
3927 register dw_attr_ref a;
3928 register int is_subr = FALSE;
3929 register int is_extern = FALSE;
3931 if (die != NULL && die->die_tag == DW_TAG_subprogram)
3934 for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
3936 if (a->dw_attr == DW_AT_external
3937 && a->dw_attr_val.val_class == dw_val_class_flag
3938 && a->dw_attr_val.v.val_flag != 0)
3946 return is_subr && is_extern;
3949 /* Get the attribute of type attr_kind. */
3951 static inline dw_attr_ref
3952 get_AT (die, attr_kind)
3953 register dw_die_ref die;
3954 register enum dwarf_attribute attr_kind;
3956 register dw_attr_ref a;
3957 register dw_die_ref spec = NULL;
3961 for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
3963 if (a->dw_attr == attr_kind)
3966 if (a->dw_attr == DW_AT_specification
3967 || a->dw_attr == DW_AT_abstract_origin)
3968 spec = a->dw_attr_val.v.val_die_ref;
3972 return get_AT (spec, attr_kind);
3978 /* Return the "low pc" attribute value, typically associated with
3979 a subprogram DIE. Return null if the "low pc" attribute is
3980 either not prsent, or if it cannot be represented as an
3981 assembler label identifier. */
3983 static inline char *
3985 register dw_die_ref die;
3987 register dw_attr_ref a = get_AT (die, DW_AT_low_pc);
3989 if (a && a->dw_attr_val.val_class == dw_val_class_lbl_id)
3990 return a->dw_attr_val.v.val_lbl_id;
3995 /* Return the "high pc" attribute value, typically associated with
3996 a subprogram DIE. Return null if the "high pc" attribute is
3997 either not prsent, or if it cannot be represented as an
3998 assembler label identifier. */
4000 static inline char *
4002 register dw_die_ref die;
4004 register dw_attr_ref a = get_AT (die, DW_AT_high_pc);
4006 if (a && a->dw_attr_val.val_class == dw_val_class_lbl_id)
4007 return a->dw_attr_val.v.val_lbl_id;
4012 /* Return the value of the string attribute designated by ATTR_KIND, or
4013 NULL if it is not present. */
4015 static inline char *
4016 get_AT_string (die, attr_kind)
4017 register dw_die_ref die;
4018 register enum dwarf_attribute attr_kind;
4020 register dw_attr_ref a = get_AT (die, attr_kind);
4022 if (a && a->dw_attr_val.val_class == dw_val_class_str)
4023 return a->dw_attr_val.v.val_str;
4028 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
4029 if it is not present. */
4032 get_AT_flag (die, attr_kind)
4033 register dw_die_ref die;
4034 register enum dwarf_attribute attr_kind;
4036 register dw_attr_ref a = get_AT (die, attr_kind);
4038 if (a && a->dw_attr_val.val_class == dw_val_class_flag)
4039 return a->dw_attr_val.v.val_flag;
4044 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
4045 if it is not present. */
4047 static inline unsigned
4048 get_AT_unsigned (die, attr_kind)
4049 register dw_die_ref die;
4050 register enum dwarf_attribute attr_kind;
4052 register dw_attr_ref a = get_AT (die, attr_kind);
4054 if (a && a->dw_attr_val.val_class == dw_val_class_unsigned_const)
4055 return a->dw_attr_val.v.val_unsigned;
4063 register unsigned lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
4065 return (lang == DW_LANG_C || lang == DW_LANG_C89
4066 || lang == DW_LANG_C_plus_plus);
4072 register unsigned lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
4074 return (lang == DW_LANG_Fortran77 || lang == DW_LANG_Fortran90);
4077 /* Remove the specified attribute if present. */
4080 remove_AT (die, attr_kind)
4081 register dw_die_ref die;
4082 register enum dwarf_attribute attr_kind;
4084 register dw_attr_ref a;
4085 register dw_attr_ref removed = NULL;;
4089 if (die->die_attr->dw_attr == attr_kind)
4091 removed = die->die_attr;
4092 if (die->die_attr_last == die->die_attr)
4093 die->die_attr_last = NULL;
4095 die->die_attr = die->die_attr->dw_attr_next;
4099 for (a = die->die_attr; a->dw_attr_next != NULL;
4100 a = a->dw_attr_next)
4101 if (a->dw_attr_next->dw_attr == attr_kind)
4103 removed = a->dw_attr_next;
4104 if (die->die_attr_last == a->dw_attr_next)
4105 die->die_attr_last = a;
4107 a->dw_attr_next = a->dw_attr_next->dw_attr_next;
4116 /* Discard the children of this DIE. */
4119 remove_children (die)
4120 register dw_die_ref die;
4122 register dw_die_ref child_die = die->die_child;
4124 die->die_child = NULL;
4125 die->die_child_last = NULL;
4127 while (child_die != NULL)
4129 register dw_die_ref tmp_die = child_die;
4130 register dw_attr_ref a;
4132 child_die = child_die->die_sib;
4134 for (a = tmp_die->die_attr; a != NULL; )
4136 register dw_attr_ref tmp_a = a;
4138 a = a->dw_attr_next;
4146 /* Add a child DIE below its parent. */
4149 add_child_die (die, child_die)
4150 register dw_die_ref die;
4151 register dw_die_ref child_die;
4153 if (die != NULL && child_die != NULL)
4155 if (die == child_die)
4157 child_die->die_parent = die;
4158 child_die->die_sib = NULL;
4160 if (die->die_child == NULL)
4162 die->die_child = child_die;
4163 die->die_child_last = child_die;
4167 die->die_child_last->die_sib = child_die;
4168 die->die_child_last = child_die;
4173 /* Return a pointer to a newly created DIE node. */
4175 static inline dw_die_ref
4176 new_die (tag_value, parent_die)
4177 register enum dwarf_tag tag_value;
4178 register dw_die_ref parent_die;
4180 register dw_die_ref die = (dw_die_ref) xmalloc (sizeof (die_node));
4182 die->die_tag = tag_value;
4183 die->die_abbrev = 0;
4184 die->die_offset = 0;
4185 die->die_child = NULL;
4186 die->die_parent = NULL;
4187 die->die_sib = NULL;
4188 die->die_child_last = NULL;
4189 die->die_attr = NULL;
4190 die->die_attr_last = NULL;
4192 if (parent_die != NULL)
4193 add_child_die (parent_die, die);
4196 limbo_die_node *limbo_node;
4198 limbo_node = (limbo_die_node *) xmalloc (sizeof (limbo_die_node));
4199 limbo_node->die = die;
4200 limbo_node->next = limbo_die_list;
4201 limbo_die_list = limbo_node;
4207 /* Return the DIE associated with the given type specifier. */
4209 static inline dw_die_ref
4210 lookup_type_die (type)
4213 return (dw_die_ref) TYPE_SYMTAB_POINTER (type);
4216 /* Equate a DIE to a given type specifier. */
4219 equate_type_number_to_die (type, type_die)
4221 register dw_die_ref type_die;
4223 TYPE_SYMTAB_POINTER (type) = (char *) type_die;
4226 /* Return the DIE associated with a given declaration. */
4228 static inline dw_die_ref
4229 lookup_decl_die (decl)
4232 register unsigned decl_id = DECL_UID (decl);
4234 return (decl_id < decl_die_table_in_use
4235 ? decl_die_table[decl_id] : NULL);
4238 /* Equate a DIE to a particular declaration. */
4241 equate_decl_number_to_die (decl, decl_die)
4243 register dw_die_ref decl_die;
4245 register unsigned decl_id = DECL_UID (decl);
4246 register unsigned num_allocated;
4248 if (decl_id >= decl_die_table_allocated)
4251 = ((decl_id + 1 + DECL_DIE_TABLE_INCREMENT - 1)
4252 / DECL_DIE_TABLE_INCREMENT)
4253 * DECL_DIE_TABLE_INCREMENT;
4256 = (dw_die_ref *) xrealloc (decl_die_table,
4257 sizeof (dw_die_ref) * num_allocated);
4259 bzero ((char *) &decl_die_table[decl_die_table_allocated],
4260 (num_allocated - decl_die_table_allocated) * sizeof (dw_die_ref));
4261 decl_die_table_allocated = num_allocated;
4264 if (decl_id >= decl_die_table_in_use)
4265 decl_die_table_in_use = (decl_id + 1);
4267 decl_die_table[decl_id] = decl_die;
4270 /* Return a pointer to a newly allocated location description. Location
4271 descriptions are simple expression terms that can be strung
4272 together to form more complicated location (address) descriptions. */
4274 static inline dw_loc_descr_ref
4275 new_loc_descr (op, oprnd1, oprnd2)
4276 register enum dwarf_location_atom op;
4277 register unsigned long oprnd1;
4278 register unsigned long oprnd2;
4280 register dw_loc_descr_ref descr
4281 = (dw_loc_descr_ref) xmalloc (sizeof (dw_loc_descr_node));
4283 descr->dw_loc_next = NULL;
4284 descr->dw_loc_opc = op;
4285 descr->dw_loc_oprnd1.val_class = dw_val_class_unsigned_const;
4286 descr->dw_loc_oprnd1.v.val_unsigned = oprnd1;
4287 descr->dw_loc_oprnd2.val_class = dw_val_class_unsigned_const;
4288 descr->dw_loc_oprnd2.v.val_unsigned = oprnd2;
4293 /* Add a location description term to a location description expression. */
4296 add_loc_descr (list_head, descr)
4297 register dw_loc_descr_ref *list_head;
4298 register dw_loc_descr_ref descr;
4300 register dw_loc_descr_ref *d;
4302 /* Find the end of the chain. */
4303 for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
4309 /* Keep track of the number of spaces used to indent the
4310 output of the debugging routines that print the structure of
4311 the DIE internal representation. */
4312 static int print_indent;
4314 /* Indent the line the number of spaces given by print_indent. */
4317 print_spaces (outfile)
4320 fprintf (outfile, "%*s", print_indent, "");
4323 /* Print the information associated with a given DIE, and its children.
4324 This routine is a debugging aid only. */
4327 print_die (die, outfile)
4331 register dw_attr_ref a;
4332 register dw_die_ref c;
4334 print_spaces (outfile);
4335 fprintf (outfile, "DIE %4lu: %s\n",
4336 die->die_offset, dwarf_tag_name (die->die_tag));
4337 print_spaces (outfile);
4338 fprintf (outfile, " abbrev id: %lu", die->die_abbrev);
4339 fprintf (outfile, " offset: %lu\n", die->die_offset);
4341 for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
4343 print_spaces (outfile);
4344 fprintf (outfile, " %s: ", dwarf_attr_name (a->dw_attr));
4346 switch (a->dw_attr_val.val_class)
4348 case dw_val_class_addr:
4349 fprintf (outfile, "address");
4351 case dw_val_class_loc:
4352 fprintf (outfile, "location descriptor");
4354 case dw_val_class_const:
4355 fprintf (outfile, "%ld", a->dw_attr_val.v.val_int);
4357 case dw_val_class_unsigned_const:
4358 fprintf (outfile, "%lu", a->dw_attr_val.v.val_unsigned);
4360 case dw_val_class_long_long:
4361 fprintf (outfile, "constant (%lu,%lu)",
4362 a->dw_attr_val.v.val_long_long.hi,
4363 a->dw_attr_val.v.val_long_long.low);
4365 case dw_val_class_float:
4366 fprintf (outfile, "floating-point constant");
4368 case dw_val_class_flag:
4369 fprintf (outfile, "%u", a->dw_attr_val.v.val_flag);
4371 case dw_val_class_die_ref:
4372 if (a->dw_attr_val.v.val_die_ref != NULL)
4373 fprintf (outfile, "die -> %lu",
4374 a->dw_attr_val.v.val_die_ref->die_offset);
4376 fprintf (outfile, "die -> <null>");
4378 case dw_val_class_lbl_id:
4379 case dw_val_class_lbl_offset:
4380 fprintf (outfile, "label: %s", a->dw_attr_val.v.val_lbl_id);
4382 case dw_val_class_str:
4383 if (a->dw_attr_val.v.val_str != NULL)
4384 fprintf (outfile, "\"%s\"", a->dw_attr_val.v.val_str);
4386 fprintf (outfile, "<null>");
4392 fprintf (outfile, "\n");
4395 if (die->die_child != NULL)
4398 for (c = die->die_child; c != NULL; c = c->die_sib)
4399 print_die (c, outfile);
4405 /* Print the contents of the source code line number correspondence table.
4406 This routine is a debugging aid only. */
4409 print_dwarf_line_table (outfile)
4412 register unsigned i;
4413 register dw_line_info_ref line_info;
4415 fprintf (outfile, "\n\nDWARF source line information\n");
4416 for (i = 1; i < line_info_table_in_use; ++i)
4418 line_info = &line_info_table[i];
4419 fprintf (outfile, "%5d: ", i);
4420 fprintf (outfile, "%-20s", file_table[line_info->dw_file_num]);
4421 fprintf (outfile, "%6ld", line_info->dw_line_num);
4422 fprintf (outfile, "\n");
4425 fprintf (outfile, "\n\n");
4428 /* Print the information collected for a given DIE. */
4431 debug_dwarf_die (die)
4434 print_die (die, stderr);
4437 /* Print all DWARF information collected for the compilation unit.
4438 This routine is a debugging aid only. */
4444 print_die (comp_unit_die, stderr);
4445 print_dwarf_line_table (stderr);
4448 /* Traverse the DIE, and add a sibling attribute if it may have the
4449 effect of speeding up access to siblings. To save some space,
4450 avoid generating sibling attributes for DIE's without children. */
4453 add_sibling_attributes(die)
4454 register dw_die_ref die;
4456 register dw_die_ref c;
4457 register dw_attr_ref attr;
4458 if (die != comp_unit_die && die->die_child != NULL)
4460 attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
4461 attr->dw_attr_next = NULL;
4462 attr->dw_attr = DW_AT_sibling;
4463 attr->dw_attr_val.val_class = dw_val_class_die_ref;
4464 attr->dw_attr_val.v.val_die_ref = die->die_sib;
4466 /* Add the sibling link to the front of the attribute list. */
4467 attr->dw_attr_next = die->die_attr;
4468 if (die->die_attr == NULL)
4469 die->die_attr_last = attr;
4471 die->die_attr = attr;
4474 for (c = die->die_child; c != NULL; c = c->die_sib)
4475 add_sibling_attributes (c);
4478 /* The format of each DIE (and its attribute value pairs)
4479 is encoded in an abbreviation table. This routine builds the
4480 abbreviation table and assigns a unique abbreviation id for
4481 each abbreviation entry. The children of each die are visited
4485 build_abbrev_table (die)
4486 register dw_die_ref die;
4488 register unsigned long abbrev_id;
4489 register unsigned long n_alloc;
4490 register dw_die_ref c;
4491 register dw_attr_ref d_attr, a_attr;
4492 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
4494 register dw_die_ref abbrev = abbrev_die_table[abbrev_id];
4496 if (abbrev->die_tag == die->die_tag)
4498 if ((abbrev->die_child != NULL) == (die->die_child != NULL))
4500 a_attr = abbrev->die_attr;
4501 d_attr = die->die_attr;
4503 while (a_attr != NULL && d_attr != NULL)
4505 if ((a_attr->dw_attr != d_attr->dw_attr)
4506 || (value_format (&a_attr->dw_attr_val)
4507 != value_format (&d_attr->dw_attr_val)))
4510 a_attr = a_attr->dw_attr_next;
4511 d_attr = d_attr->dw_attr_next;
4514 if (a_attr == NULL && d_attr == NULL)
4520 if (abbrev_id >= abbrev_die_table_in_use)
4522 if (abbrev_die_table_in_use >= abbrev_die_table_allocated)
4524 n_alloc = abbrev_die_table_allocated + ABBREV_DIE_TABLE_INCREMENT;
4526 = (dw_die_ref *) xrealloc (abbrev_die_table,
4527 sizeof (dw_die_ref) * n_alloc);
4529 bzero ((char *) &abbrev_die_table[abbrev_die_table_allocated],
4530 (n_alloc - abbrev_die_table_allocated) * sizeof (dw_die_ref));
4531 abbrev_die_table_allocated = n_alloc;
4534 ++abbrev_die_table_in_use;
4535 abbrev_die_table[abbrev_id] = die;
4538 die->die_abbrev = abbrev_id;
4539 for (c = die->die_child; c != NULL; c = c->die_sib)
4540 build_abbrev_table (c);
4543 /* Return the size of a string, including the null byte.
4545 This used to treat backslashes as escapes, and hence they were not included
4546 in the count. However, that conflicts with what ASM_OUTPUT_ASCII does,
4547 which treats a backslash as a backslash, escaping it if necessary, and hence
4548 we must include them in the count. */
4550 static unsigned long
4551 size_of_string (str)
4554 return strlen (str) + 1;
4557 /* Return the size of a location descriptor. */
4559 static unsigned long
4560 size_of_loc_descr (loc)
4561 register dw_loc_descr_ref loc;
4563 register unsigned long size = 1;
4565 switch (loc->dw_loc_opc)
4587 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4590 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
4595 case DW_OP_plus_uconst:
4596 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4634 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
4637 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4640 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
4643 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4644 size += size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int);
4647 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4649 case DW_OP_deref_size:
4650 case DW_OP_xderef_size:
4660 /* Return the size of a series of location descriptors. */
4662 static unsigned long
4664 register dw_loc_descr_ref loc;
4666 register unsigned long size = 0;
4668 for (; loc != NULL; loc = loc->dw_loc_next)
4669 size += size_of_loc_descr (loc);
4674 /* Return the power-of-two number of bytes necessary to represent VALUE. */
4677 constant_size (value)
4678 long unsigned value;
4685 log = floor_log2 (value);
4688 log = 1 << (floor_log2 (log) + 1);
4693 /* Return the size of a DIE, as it is represented in the
4694 .debug_info section. */
4696 static unsigned long
4698 register dw_die_ref die;
4700 register unsigned long size = 0;
4701 register dw_attr_ref a;
4703 size += size_of_uleb128 (die->die_abbrev);
4704 for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
4706 switch (a->dw_attr_val.val_class)
4708 case dw_val_class_addr:
4711 case dw_val_class_loc:
4713 register unsigned long lsize
4714 = size_of_locs (a->dw_attr_val.v.val_loc);
4717 size += constant_size (lsize);
4721 case dw_val_class_const:
4724 case dw_val_class_unsigned_const:
4725 size += constant_size (a->dw_attr_val.v.val_unsigned);
4727 case dw_val_class_long_long:
4728 size += 1 + 8; /* block */
4730 case dw_val_class_float:
4731 size += 1 + a->dw_attr_val.v.val_float.length * 4; /* block */
4733 case dw_val_class_flag:
4736 case dw_val_class_die_ref:
4737 size += DWARF_OFFSET_SIZE;
4739 case dw_val_class_fde_ref:
4740 size += DWARF_OFFSET_SIZE;
4742 case dw_val_class_lbl_id:
4745 case dw_val_class_lbl_offset:
4746 size += DWARF_OFFSET_SIZE;
4748 case dw_val_class_str:
4749 size += size_of_string (a->dw_attr_val.v.val_str);
4759 /* Size the debugging information associated with a given DIE.
4760 Visits the DIE's children recursively. Updates the global
4761 variable next_die_offset, on each time through. Uses the
4762 current value of next_die_offset to update the die_offset
4763 field in each DIE. */
4766 calc_die_sizes (die)
4769 register dw_die_ref c;
4770 die->die_offset = next_die_offset;
4771 next_die_offset += size_of_die (die);
4773 for (c = die->die_child; c != NULL; c = c->die_sib)
4776 if (die->die_child != NULL)
4777 /* Count the null byte used to terminate sibling lists. */
4778 next_die_offset += 1;
4781 /* Return the size of the line information prolog generated for the
4782 compilation unit. */
4784 static unsigned long
4785 size_of_line_prolog ()
4787 register unsigned long size;
4788 register unsigned long ft_index;
4790 size = DWARF_LINE_PROLOG_HEADER_SIZE;
4792 /* Count the size of the table giving number of args for each
4794 size += DWARF_LINE_OPCODE_BASE - 1;
4796 /* Include directory table is empty (at present). Count only the
4797 null byte used to terminate the table. */
4800 for (ft_index = 1; ft_index < file_table_in_use; ++ft_index)
4802 /* File name entry. */
4803 size += size_of_string (file_table[ft_index]);
4805 /* Include directory index. */
4806 size += size_of_uleb128 (0);
4808 /* Modification time. */
4809 size += size_of_uleb128 (0);
4811 /* File length in bytes. */
4812 size += size_of_uleb128 (0);
4815 /* Count the file table terminator. */
4820 /* Return the size of the line information generated for this
4821 compilation unit. */
4823 static unsigned long
4824 size_of_line_info ()
4826 register unsigned long size;
4827 register unsigned long lt_index;
4828 register unsigned long current_line;
4829 register long line_offset;
4830 register long line_delta;
4831 register unsigned long current_file;
4832 register unsigned long function;
4833 unsigned long size_of_set_address;
4835 /* Size of a DW_LNE_set_address instruction. */
4836 size_of_set_address = 1 + size_of_uleb128 (1 + PTR_SIZE) + 1 + PTR_SIZE;
4838 /* Version number. */
4841 /* Prolog length specifier. */
4842 size += DWARF_OFFSET_SIZE;
4845 size += size_of_line_prolog ();
4849 for (lt_index = 1; lt_index < line_info_table_in_use; ++lt_index)
4851 register dw_line_info_ref line_info = &line_info_table[lt_index];
4853 if (line_info->dw_line_num == current_line
4854 && line_info->dw_file_num == current_file)
4857 /* Advance pc instruction. */
4858 /* ??? See the DW_LNS_advance_pc comment in output_line_info. */
4862 size += size_of_set_address;
4864 if (line_info->dw_file_num != current_file)
4866 /* Set file number instruction. */
4868 current_file = line_info->dw_file_num;
4869 size += size_of_uleb128 (current_file);
4872 if (line_info->dw_line_num != current_line)
4874 line_offset = line_info->dw_line_num - current_line;
4875 line_delta = line_offset - DWARF_LINE_BASE;
4876 current_line = line_info->dw_line_num;
4877 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
4878 /* 1-byte special line number instruction. */
4882 /* Advance line instruction. */
4884 size += size_of_sleb128 (line_offset);
4885 /* Generate line entry instruction. */
4891 /* Advance pc instruction. */
4895 size += size_of_set_address;
4897 /* End of line number info. marker. */
4898 size += 1 + size_of_uleb128 (1) + 1;
4903 for (lt_index = 0; lt_index < separate_line_info_table_in_use; )
4905 register dw_separate_line_info_ref line_info
4906 = &separate_line_info_table[lt_index];
4908 if (line_info->dw_line_num == current_line
4909 && line_info->dw_file_num == current_file
4910 && line_info->function == function)
4913 if (function != line_info->function)
4915 function = line_info->function;
4916 /* Set address register instruction. */
4917 size += size_of_set_address;
4921 /* Advance pc instruction. */
4925 size += size_of_set_address;
4928 if (line_info->dw_file_num != current_file)
4930 /* Set file number instruction. */
4932 current_file = line_info->dw_file_num;
4933 size += size_of_uleb128 (current_file);
4936 if (line_info->dw_line_num != current_line)
4938 line_offset = line_info->dw_line_num - current_line;
4939 line_delta = line_offset - DWARF_LINE_BASE;
4940 current_line = line_info->dw_line_num;
4941 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
4942 /* 1-byte special line number instruction. */
4946 /* Advance line instruction. */
4948 size += size_of_sleb128 (line_offset);
4950 /* Generate line entry instruction. */
4958 /* If we're done with a function, end its sequence. */
4959 if (lt_index == separate_line_info_table_in_use
4960 || separate_line_info_table[lt_index].function != function)
4965 /* Advance pc instruction. */
4969 size += size_of_set_address;
4971 /* End of line number info. marker. */
4972 size += 1 + size_of_uleb128 (1) + 1;
4979 /* Return the size of the .debug_pubnames table generated for the
4980 compilation unit. */
4982 static unsigned long
4985 register unsigned long size;
4986 register unsigned i;
4988 size = DWARF_PUBNAMES_HEADER_SIZE;
4989 for (i = 0; i < pubname_table_in_use; ++i)
4991 register pubname_ref p = &pubname_table[i];
4992 size += DWARF_OFFSET_SIZE + size_of_string (p->name);
4995 size += DWARF_OFFSET_SIZE;
4999 /* Return the size of the information in the .debug_aranges section. */
5001 static unsigned long
5004 register unsigned long size;
5006 size = DWARF_ARANGES_HEADER_SIZE;
5008 /* Count the address/length pair for this compilation unit. */
5009 size += 2 * PTR_SIZE;
5010 size += 2 * PTR_SIZE * arange_table_in_use;
5012 /* Count the two zero words used to terminated the address range table. */
5013 size += 2 * PTR_SIZE;
5017 /* Select the encoding of an attribute value. */
5019 static enum dwarf_form
5023 switch (v->val_class)
5025 case dw_val_class_addr:
5026 return DW_FORM_addr;
5027 case dw_val_class_loc:
5028 switch (constant_size (size_of_locs (v->v.val_loc)))
5031 return DW_FORM_block1;
5033 return DW_FORM_block2;
5037 case dw_val_class_const:
5038 return DW_FORM_data4;
5039 case dw_val_class_unsigned_const:
5040 switch (constant_size (v->v.val_unsigned))
5043 return DW_FORM_data1;
5045 return DW_FORM_data2;
5047 return DW_FORM_data4;
5049 return DW_FORM_data8;
5053 case dw_val_class_long_long:
5054 return DW_FORM_block1;
5055 case dw_val_class_float:
5056 return DW_FORM_block1;
5057 case dw_val_class_flag:
5058 return DW_FORM_flag;
5059 case dw_val_class_die_ref:
5061 case dw_val_class_fde_ref:
5062 return DW_FORM_data;
5063 case dw_val_class_lbl_id:
5064 return DW_FORM_addr;
5065 case dw_val_class_lbl_offset:
5066 return DW_FORM_data;
5067 case dw_val_class_str:
5068 return DW_FORM_string;
5074 /* Output the encoding of an attribute value. */
5077 output_value_format (v)
5080 enum dwarf_form form = value_format (v);
5082 output_uleb128 (form);
5084 fprintf (asm_out_file, " (%s)", dwarf_form_name (form));
5086 fputc ('\n', asm_out_file);
5089 /* Output the .debug_abbrev section which defines the DIE abbreviation
5093 output_abbrev_section ()
5095 unsigned long abbrev_id;
5098 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
5100 register dw_die_ref abbrev = abbrev_die_table[abbrev_id];
5102 output_uleb128 (abbrev_id);
5104 fprintf (asm_out_file, " (abbrev code)");
5106 fputc ('\n', asm_out_file);
5107 output_uleb128 (abbrev->die_tag);
5109 fprintf (asm_out_file, " (TAG: %s)",
5110 dwarf_tag_name (abbrev->die_tag));
5112 fputc ('\n', asm_out_file);
5113 fprintf (asm_out_file, "\t%s\t0x%x", ASM_BYTE_OP,
5114 abbrev->die_child != NULL ? DW_children_yes : DW_children_no);
5117 fprintf (asm_out_file, "\t%s %s",
5119 (abbrev->die_child != NULL
5120 ? "DW_children_yes" : "DW_children_no"));
5122 fputc ('\n', asm_out_file);
5124 for (a_attr = abbrev->die_attr; a_attr != NULL;
5125 a_attr = a_attr->dw_attr_next)
5127 output_uleb128 (a_attr->dw_attr);
5129 fprintf (asm_out_file, " (%s)",
5130 dwarf_attr_name (a_attr->dw_attr));
5132 fputc ('\n', asm_out_file);
5133 output_value_format (&a_attr->dw_attr_val);
5136 fprintf (asm_out_file, "\t%s\t0,0\n", ASM_BYTE_OP);
5139 /* Terminate the table. */
5140 fprintf (asm_out_file, "\t%s\t0\n", ASM_BYTE_OP);
5143 /* Output location description stack opcode's operands (if any). */
5146 output_loc_operands (loc)
5147 register dw_loc_descr_ref loc;
5149 register dw_val_ref val1 = &loc->dw_loc_oprnd1;
5150 register dw_val_ref val2 = &loc->dw_loc_oprnd2;
5152 switch (loc->dw_loc_opc)
5155 ASM_OUTPUT_DWARF_ADDR_CONST (asm_out_file, val1->v.val_addr);
5156 fputc ('\n', asm_out_file);
5160 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, val1->v.val_flag);
5161 fputc ('\n', asm_out_file);
5165 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, val1->v.val_int);
5166 fputc ('\n', asm_out_file);
5170 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, val1->v.val_int);
5171 fputc ('\n', asm_out_file);
5176 fputc ('\n', asm_out_file);
5179 output_uleb128 (val1->v.val_unsigned);
5180 fputc ('\n', asm_out_file);
5183 output_sleb128 (val1->v.val_int);
5184 fputc ('\n', asm_out_file);
5187 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, val1->v.val_int);
5188 fputc ('\n', asm_out_file);
5190 case DW_OP_plus_uconst:
5191 output_uleb128 (val1->v.val_unsigned);
5192 fputc ('\n', asm_out_file);
5196 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, val1->v.val_int);
5197 fputc ('\n', asm_out_file);
5231 output_sleb128 (val1->v.val_int);
5232 fputc ('\n', asm_out_file);
5235 output_uleb128 (val1->v.val_unsigned);
5236 fputc ('\n', asm_out_file);
5239 output_sleb128 (val1->v.val_int);
5240 fputc ('\n', asm_out_file);
5243 output_uleb128 (val1->v.val_unsigned);
5244 fputc ('\n', asm_out_file);
5245 output_sleb128 (val2->v.val_int);
5246 fputc ('\n', asm_out_file);
5249 output_uleb128 (val1->v.val_unsigned);
5250 fputc ('\n', asm_out_file);
5252 case DW_OP_deref_size:
5253 case DW_OP_xderef_size:
5254 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, val1->v.val_flag);
5255 fputc ('\n', asm_out_file);
5262 /* Compute the offset of a sibling. */
5264 static unsigned long
5265 sibling_offset (die)
5268 unsigned long offset;
5270 if (die->die_child_last == NULL)
5271 offset = die->die_offset + size_of_die (die);
5273 offset = sibling_offset (die->die_child_last) + 1;
5278 /* Output the DIE and its attributes. Called recursively to generate
5279 the definitions of each child DIE. */
5283 register dw_die_ref die;
5285 register dw_attr_ref a;
5286 register dw_die_ref c;
5287 register unsigned long ref_offset;
5288 register unsigned long size;
5289 register dw_loc_descr_ref loc;
5291 output_uleb128 (die->die_abbrev);
5293 fprintf (asm_out_file, " (DIE (0x%lx) %s)",
5294 die->die_offset, dwarf_tag_name (die->die_tag));
5296 fputc ('\n', asm_out_file);
5298 for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
5300 switch (a->dw_attr_val.val_class)
5302 case dw_val_class_addr:
5303 ASM_OUTPUT_DWARF_ADDR_CONST (asm_out_file,
5304 a->dw_attr_val.v.val_addr);
5307 case dw_val_class_loc:
5308 size = size_of_locs (a->dw_attr_val.v.val_loc);
5310 /* Output the block length for this list of location operations. */
5311 switch (constant_size (size))
5314 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, size);
5317 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, size);
5324 fprintf (asm_out_file, "\t%s %s",
5325 ASM_COMMENT_START, dwarf_attr_name (a->dw_attr));
5327 fputc ('\n', asm_out_file);
5328 for (loc = a->dw_attr_val.v.val_loc; loc != NULL;
5329 loc = loc->dw_loc_next)
5331 /* Output the opcode. */
5332 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, loc->dw_loc_opc);
5334 fprintf (asm_out_file, "\t%s %s", ASM_COMMENT_START,
5335 dwarf_stack_op_name (loc->dw_loc_opc));
5337 fputc ('\n', asm_out_file);
5339 /* Output the operand(s) (if any). */
5340 output_loc_operands (loc);
5344 case dw_val_class_const:
5345 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, a->dw_attr_val.v.val_int);
5348 case dw_val_class_unsigned_const:
5349 switch (constant_size (a->dw_attr_val.v.val_unsigned))
5352 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
5353 a->dw_attr_val.v.val_unsigned);
5356 ASM_OUTPUT_DWARF_DATA2 (asm_out_file,
5357 a->dw_attr_val.v.val_unsigned);
5360 ASM_OUTPUT_DWARF_DATA4 (asm_out_file,
5361 a->dw_attr_val.v.val_unsigned);
5364 ASM_OUTPUT_DWARF_DATA8 (asm_out_file,
5365 a->dw_attr_val.v.val_long_long.hi,
5366 a->dw_attr_val.v.val_long_long.low);
5373 case dw_val_class_long_long:
5374 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 8);
5376 fprintf (asm_out_file, "\t%s %s",
5377 ASM_COMMENT_START, dwarf_attr_name (a->dw_attr));
5379 fputc ('\n', asm_out_file);
5380 ASM_OUTPUT_DWARF_DATA8 (asm_out_file,
5381 a->dw_attr_val.v.val_long_long.hi,
5382 a->dw_attr_val.v.val_long_long.low);
5385 fprintf (asm_out_file,
5386 "\t%s long long constant", ASM_COMMENT_START);
5388 fputc ('\n', asm_out_file);
5391 case dw_val_class_float:
5393 register unsigned int i;
5394 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
5395 a->dw_attr_val.v.val_float.length * 4);
5397 fprintf (asm_out_file, "\t%s %s",
5398 ASM_COMMENT_START, dwarf_attr_name (a->dw_attr));
5400 fputc ('\n', asm_out_file);
5401 for (i = 0; i < a->dw_attr_val.v.val_float.length; ++i)
5403 ASM_OUTPUT_DWARF_DATA4 (asm_out_file,
5404 a->dw_attr_val.v.val_float.array[i]);
5406 fprintf (asm_out_file, "\t%s fp constant word %u",
5407 ASM_COMMENT_START, i);
5409 fputc ('\n', asm_out_file);
5414 case dw_val_class_flag:
5415 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, a->dw_attr_val.v.val_flag);
5418 case dw_val_class_die_ref:
5419 if (a->dw_attr_val.v.val_die_ref != NULL)
5420 ref_offset = a->dw_attr_val.v.val_die_ref->die_offset;
5421 else if (a->dw_attr == DW_AT_sibling)
5422 ref_offset = sibling_offset(die);
5426 ASM_OUTPUT_DWARF_DATA (asm_out_file, ref_offset);
5429 case dw_val_class_fde_ref:
5432 ASM_GENERATE_INTERNAL_LABEL
5433 (l1, FDE_AFTER_SIZE_LABEL, a->dw_attr_val.v.val_fde_index * 2);
5434 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, l1);
5435 fprintf (asm_out_file, " - %d", DWARF_OFFSET_SIZE);
5439 case dw_val_class_lbl_id:
5440 ASM_OUTPUT_DWARF_ADDR (asm_out_file, a->dw_attr_val.v.val_lbl_id);
5443 case dw_val_class_lbl_offset:
5444 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, a->dw_attr_val.v.val_lbl_id);
5447 case dw_val_class_str:
5449 ASM_OUTPUT_DWARF_STRING (asm_out_file, a->dw_attr_val.v.val_str);
5451 ASM_OUTPUT_ASCII (asm_out_file,
5452 a->dw_attr_val.v.val_str,
5453 (int) strlen (a->dw_attr_val.v.val_str) + 1);
5460 if (a->dw_attr_val.val_class != dw_val_class_loc
5461 && a->dw_attr_val.val_class != dw_val_class_long_long
5462 && a->dw_attr_val.val_class != dw_val_class_float)
5465 fprintf (asm_out_file, "\t%s %s",
5466 ASM_COMMENT_START, dwarf_attr_name (a->dw_attr));
5468 fputc ('\n', asm_out_file);
5472 for (c = die->die_child; c != NULL; c = c->die_sib)
5475 if (die->die_child != NULL)
5477 /* Add null byte to terminate sibling list. */
5478 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5480 fprintf (asm_out_file, "\t%s end of children of DIE 0x%lx",
5481 ASM_COMMENT_START, die->die_offset);
5483 fputc ('\n', asm_out_file);
5487 /* Output the compilation unit that appears at the beginning of the
5488 .debug_info section, and precedes the DIE descriptions. */
5491 output_compilation_unit_header ()
5493 ASM_OUTPUT_DWARF_DATA (asm_out_file, next_die_offset - DWARF_OFFSET_SIZE);
5495 fprintf (asm_out_file, "\t%s Length of Compilation Unit Info.",
5498 fputc ('\n', asm_out_file);
5499 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, DWARF_VERSION);
5501 fprintf (asm_out_file, "\t%s DWARF version number", ASM_COMMENT_START);
5503 fputc ('\n', asm_out_file);
5504 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, abbrev_section_label);
5506 fprintf (asm_out_file, "\t%s Offset Into Abbrev. Section",
5509 fputc ('\n', asm_out_file);
5510 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, PTR_SIZE);
5512 fprintf (asm_out_file, "\t%s Pointer Size (in bytes)", ASM_COMMENT_START);
5514 fputc ('\n', asm_out_file);
5517 /* The DWARF2 pubname for a nested thingy looks like "A::f". The output
5518 of decl_printable_name for C++ looks like "A::f(int)". Let's drop the
5519 argument list, and maybe the scope. */
5522 dwarf2_name (decl, scope)
5526 return (*decl_printable_name) (decl, scope ? 1 : 0);
5529 /* Add a new entry to .debug_pubnames if appropriate. */
5532 add_pubname (decl, die)
5538 if (! TREE_PUBLIC (decl))
5541 if (pubname_table_in_use == pubname_table_allocated)
5543 pubname_table_allocated += PUBNAME_TABLE_INCREMENT;
5544 pubname_table = (pubname_ref) xrealloc
5545 (pubname_table, pubname_table_allocated * sizeof (pubname_entry));
5548 p = &pubname_table[pubname_table_in_use++];
5551 p->name = xstrdup (dwarf2_name (decl, 1));
5554 /* Output the public names table used to speed up access to externally
5555 visible names. For now, only generate entries for externally
5556 visible procedures. */
5561 register unsigned i;
5562 register unsigned long pubnames_length = size_of_pubnames ();
5564 ASM_OUTPUT_DWARF_DATA (asm_out_file, pubnames_length);
5567 fprintf (asm_out_file, "\t%s Length of Public Names Info.",
5570 fputc ('\n', asm_out_file);
5571 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, DWARF_VERSION);
5574 fprintf (asm_out_file, "\t%s DWARF Version", ASM_COMMENT_START);
5576 fputc ('\n', asm_out_file);
5577 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, debug_info_section_label);
5579 fprintf (asm_out_file, "\t%s Offset of Compilation Unit Info.",
5582 fputc ('\n', asm_out_file);
5583 ASM_OUTPUT_DWARF_DATA (asm_out_file, next_die_offset);
5585 fprintf (asm_out_file, "\t%s Compilation Unit Length", ASM_COMMENT_START);
5587 fputc ('\n', asm_out_file);
5588 for (i = 0; i < pubname_table_in_use; ++i)
5590 register pubname_ref pub = &pubname_table[i];
5592 ASM_OUTPUT_DWARF_DATA (asm_out_file, pub->die->die_offset);
5594 fprintf (asm_out_file, "\t%s DIE offset", ASM_COMMENT_START);
5596 fputc ('\n', asm_out_file);
5600 ASM_OUTPUT_DWARF_STRING (asm_out_file, pub->name);
5601 fprintf (asm_out_file, "%s external name", ASM_COMMENT_START);
5605 ASM_OUTPUT_ASCII (asm_out_file, pub->name,
5606 (int) strlen (pub->name) + 1);
5609 fputc ('\n', asm_out_file);
5612 ASM_OUTPUT_DWARF_DATA (asm_out_file, 0);
5613 fputc ('\n', asm_out_file);
5616 /* Add a new entry to .debug_aranges if appropriate. */
5619 add_arange (decl, die)
5623 if (! DECL_SECTION_NAME (decl))
5626 if (arange_table_in_use == arange_table_allocated)
5628 arange_table_allocated += ARANGE_TABLE_INCREMENT;
5630 = (arange_ref) xrealloc (arange_table,
5631 arange_table_allocated * sizeof (dw_die_ref));
5634 arange_table[arange_table_in_use++] = die;
5637 /* Output the information that goes into the .debug_aranges table.
5638 Namely, define the beginning and ending address range of the
5639 text section generated for this compilation unit. */
5644 register unsigned i;
5645 register unsigned long aranges_length = size_of_aranges ();
5647 ASM_OUTPUT_DWARF_DATA (asm_out_file, aranges_length);
5649 fprintf (asm_out_file, "\t%s Length of Address Ranges Info.",
5652 fputc ('\n', asm_out_file);
5653 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, DWARF_VERSION);
5655 fprintf (asm_out_file, "\t%s DWARF Version", ASM_COMMENT_START);
5657 fputc ('\n', asm_out_file);
5658 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, debug_info_section_label);
5660 fprintf (asm_out_file, "\t%s Offset of Compilation Unit Info.",
5663 fputc ('\n', asm_out_file);
5664 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, PTR_SIZE);
5666 fprintf (asm_out_file, "\t%s Size of Address", ASM_COMMENT_START);
5668 fputc ('\n', asm_out_file);
5669 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5671 fprintf (asm_out_file, "\t%s Size of Segment Descriptor",
5674 fputc ('\n', asm_out_file);
5675 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 4);
5677 fprintf (asm_out_file, ",0,0");
5680 fprintf (asm_out_file, "\t%s Pad to %d byte boundary",
5681 ASM_COMMENT_START, 2 * PTR_SIZE);
5683 fputc ('\n', asm_out_file);
5684 ASM_OUTPUT_DWARF_ADDR (asm_out_file, text_section_label);
5686 fprintf (asm_out_file, "\t%s Address", ASM_COMMENT_START);
5688 fputc ('\n', asm_out_file);
5689 ASM_OUTPUT_DWARF_ADDR_DELTA (asm_out_file, text_end_label,
5690 text_section_label);
5692 fprintf (asm_out_file, "%s Length", ASM_COMMENT_START);
5694 fputc ('\n', asm_out_file);
5695 for (i = 0; i < arange_table_in_use; ++i)
5697 dw_die_ref a = arange_table[i];
5699 if (a->die_tag == DW_TAG_subprogram)
5700 ASM_OUTPUT_DWARF_ADDR (asm_out_file, get_AT_low_pc (a));
5703 char *name = get_AT_string (a, DW_AT_MIPS_linkage_name);
5705 name = get_AT_string (a, DW_AT_name);
5707 ASM_OUTPUT_DWARF_ADDR (asm_out_file, name);
5711 fprintf (asm_out_file, "\t%s Address", ASM_COMMENT_START);
5713 fputc ('\n', asm_out_file);
5714 if (a->die_tag == DW_TAG_subprogram)
5715 ASM_OUTPUT_DWARF_ADDR_DELTA (asm_out_file, get_AT_hi_pc (a),
5718 ASM_OUTPUT_DWARF_ADDR_DATA (asm_out_file,
5719 get_AT_unsigned (a, DW_AT_byte_size));
5722 fprintf (asm_out_file, "%s Length", ASM_COMMENT_START);
5724 fputc ('\n', asm_out_file);
5727 /* Output the terminator words. */
5728 ASM_OUTPUT_DWARF_ADDR_DATA (asm_out_file, 0);
5729 fputc ('\n', asm_out_file);
5730 ASM_OUTPUT_DWARF_ADDR_DATA (asm_out_file, 0);
5731 fputc ('\n', asm_out_file);
5734 /* Output the source line number correspondence information. This
5735 information goes into the .debug_line section.
5737 If the format of this data changes, then the function size_of_line_info
5738 must also be adjusted the same way. */
5743 char line_label[MAX_ARTIFICIAL_LABEL_BYTES];
5744 char prev_line_label[MAX_ARTIFICIAL_LABEL_BYTES];
5745 register unsigned opc;
5746 register unsigned n_op_args;
5747 register unsigned long ft_index;
5748 register unsigned long lt_index;
5749 register unsigned long current_line;
5750 register long line_offset;
5751 register long line_delta;
5752 register unsigned long current_file;
5753 register unsigned long function;
5755 ASM_OUTPUT_DWARF_DATA (asm_out_file, size_of_line_info ());
5757 fprintf (asm_out_file, "\t%s Length of Source Line Info.",
5760 fputc ('\n', asm_out_file);
5761 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, DWARF_VERSION);
5763 fprintf (asm_out_file, "\t%s DWARF Version", ASM_COMMENT_START);
5765 fputc ('\n', asm_out_file);
5766 ASM_OUTPUT_DWARF_DATA (asm_out_file, size_of_line_prolog ());
5768 fprintf (asm_out_file, "\t%s Prolog Length", ASM_COMMENT_START);
5770 fputc ('\n', asm_out_file);
5771 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DWARF_LINE_MIN_INSTR_LENGTH);
5773 fprintf (asm_out_file, "\t%s Minimum Instruction Length",
5776 fputc ('\n', asm_out_file);
5777 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DWARF_LINE_DEFAULT_IS_STMT_START);
5779 fprintf (asm_out_file, "\t%s Default is_stmt_start flag",
5782 fputc ('\n', asm_out_file);
5783 fprintf (asm_out_file, "\t%s\t%d", ASM_BYTE_OP, DWARF_LINE_BASE);
5785 fprintf (asm_out_file, "\t%s Line Base Value (Special Opcodes)",
5788 fputc ('\n', asm_out_file);
5789 fprintf (asm_out_file, "\t%s\t%u", ASM_BYTE_OP, DWARF_LINE_RANGE);
5791 fprintf (asm_out_file, "\t%s Line Range Value (Special Opcodes)",
5794 fputc ('\n', asm_out_file);
5795 fprintf (asm_out_file, "\t%s\t%u", ASM_BYTE_OP, DWARF_LINE_OPCODE_BASE);
5797 fprintf (asm_out_file, "\t%s Special Opcode Base", ASM_COMMENT_START);
5799 fputc ('\n', asm_out_file);
5800 for (opc = 1; opc < DWARF_LINE_OPCODE_BASE; ++opc)
5804 case DW_LNS_advance_pc:
5805 case DW_LNS_advance_line:
5806 case DW_LNS_set_file:
5807 case DW_LNS_set_column:
5808 case DW_LNS_fixed_advance_pc:
5815 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, n_op_args);
5817 fprintf (asm_out_file, "\t%s opcode: 0x%x has %d args",
5818 ASM_COMMENT_START, opc, n_op_args);
5819 fputc ('\n', asm_out_file);
5823 fprintf (asm_out_file, "%s Include Directory Table\n", ASM_COMMENT_START);
5825 /* Include directory table is empty, at present */
5826 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5827 fputc ('\n', asm_out_file);
5829 fprintf (asm_out_file, "%s File Name Table\n", ASM_COMMENT_START);
5831 for (ft_index = 1; ft_index < file_table_in_use; ++ft_index)
5835 ASM_OUTPUT_DWARF_STRING (asm_out_file, file_table[ft_index]);
5836 fprintf (asm_out_file, "%s File Entry: 0x%lx",
5837 ASM_COMMENT_START, ft_index);
5841 ASM_OUTPUT_ASCII (asm_out_file,
5842 file_table[ft_index],
5843 (int) strlen (file_table[ft_index]) + 1);
5846 fputc ('\n', asm_out_file);
5848 /* Include directory index */
5850 fputc ('\n', asm_out_file);
5852 /* Modification time */
5854 fputc ('\n', asm_out_file);
5856 /* File length in bytes */
5858 fputc ('\n', asm_out_file);
5861 /* Terminate the file name table */
5862 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5863 fputc ('\n', asm_out_file);
5865 /* We used to set the address register to the first location in the text
5866 section here, but that didn't accomplish anything since we already
5867 have a line note for the opening brace of the first function. */
5869 /* Generate the line number to PC correspondence table, encoded as
5870 a series of state machine operations. */
5873 strcpy (prev_line_label, text_section_label);
5874 for (lt_index = 1; lt_index < line_info_table_in_use; ++lt_index)
5876 register dw_line_info_ref line_info = &line_info_table[lt_index];
5878 /* Don't emit anything for redundant notes. Just updating the
5879 address doesn't accomplish anything, because we already assume
5880 that anything after the last address is this line. */
5881 if (line_info->dw_line_num == current_line
5882 && line_info->dw_file_num == current_file)
5885 /* Emit debug info for the address of the current line, choosing
5886 the encoding that uses the least amount of space. */
5887 /* ??? Unfortunately, we have little choice here currently, and must
5888 always use the most general form. Gcc does not know the address
5889 delta itself, so we can't use DW_LNS_advance_pc. There are no known
5890 dwarf2 aware assemblers at this time, so we can't use any special
5891 pseudo ops that would allow the assembler to optimally encode this for
5892 us. Many ports do have length attributes which will give an upper
5893 bound on the address range. We could perhaps use length attributes
5894 to determine when it is safe to use DW_LNS_fixed_advance_pc. */
5895 ASM_GENERATE_INTERNAL_LABEL (line_label, LINE_CODE_LABEL, lt_index);
5898 /* This can handle deltas up to 0xffff. This takes 3 bytes. */
5899 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc);
5901 fprintf (asm_out_file, "\t%s DW_LNS_fixed_advance_pc",
5904 fputc ('\n', asm_out_file);
5905 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, line_label, prev_line_label);
5906 fputc ('\n', asm_out_file);
5910 /* This can handle any delta. This takes 4+PTR_SIZE bytes. */
5911 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5913 fprintf (asm_out_file, "\t%s DW_LNE_set_address",
5915 fputc ('\n', asm_out_file);
5916 output_uleb128 (1 + PTR_SIZE);
5917 fputc ('\n', asm_out_file);
5918 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address);
5919 fputc ('\n', asm_out_file);
5920 ASM_OUTPUT_DWARF_ADDR (asm_out_file, line_label);
5921 fputc ('\n', asm_out_file);
5923 strcpy (prev_line_label, line_label);
5925 /* Emit debug info for the source file of the current line, if
5926 different from the previous line. */
5927 if (line_info->dw_file_num != current_file)
5929 current_file = line_info->dw_file_num;
5930 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_set_file);
5932 fprintf (asm_out_file, "\t%s DW_LNS_set_file", ASM_COMMENT_START);
5934 fputc ('\n', asm_out_file);
5935 output_uleb128 (current_file);
5937 fprintf (asm_out_file, " (\"%s\")", file_table[current_file]);
5939 fputc ('\n', asm_out_file);
5942 /* Emit debug info for the current line number, choosing the encoding
5943 that uses the least amount of space. */
5944 if (line_info->dw_line_num != current_line)
5946 line_offset = line_info->dw_line_num - current_line;
5947 line_delta = line_offset - DWARF_LINE_BASE;
5948 current_line = line_info->dw_line_num;
5949 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
5951 /* This can handle deltas from -10 to 234, using the current
5952 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE. This
5954 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
5955 DWARF_LINE_OPCODE_BASE + line_delta);
5957 fprintf (asm_out_file,
5958 "\t%s line %ld", ASM_COMMENT_START, current_line);
5960 fputc ('\n', asm_out_file);
5964 /* This can handle any delta. This takes at least 4 bytes,
5965 depending on the value being encoded. */
5966 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_advance_line);
5968 fprintf (asm_out_file, "\t%s advance to line %ld",
5969 ASM_COMMENT_START, current_line);
5971 fputc ('\n', asm_out_file);
5972 output_sleb128 (line_offset);
5973 fputc ('\n', asm_out_file);
5974 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_copy);
5976 fprintf (asm_out_file, "\t%s DW_LNS_copy", ASM_COMMENT_START);
5977 fputc ('\n', asm_out_file);
5982 /* We still need to start a new row, so output a copy insn. */
5983 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_copy);
5985 fprintf (asm_out_file, "\t%s DW_LNS_copy", ASM_COMMENT_START);
5986 fputc ('\n', asm_out_file);
5990 /* Emit debug info for the address of the end of the function. */
5993 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc);
5995 fprintf (asm_out_file, "\t%s DW_LNS_fixed_advance_pc",
5998 fputc ('\n', asm_out_file);
5999 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, text_end_label, prev_line_label);
6000 fputc ('\n', asm_out_file);
6004 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
6006 fprintf (asm_out_file, "\t%s DW_LNE_set_address", ASM_COMMENT_START);
6007 fputc ('\n', asm_out_file);
6008 output_uleb128 (1 + PTR_SIZE);
6009 fputc ('\n', asm_out_file);
6010 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address);
6011 fputc ('\n', asm_out_file);
6012 ASM_OUTPUT_DWARF_ADDR (asm_out_file, text_end_label);
6013 fputc ('\n', asm_out_file);
6016 /* Output the marker for the end of the line number info. */
6017 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
6019 fprintf (asm_out_file, "\t%s DW_LNE_end_sequence", ASM_COMMENT_START);
6021 fputc ('\n', asm_out_file);
6023 fputc ('\n', asm_out_file);
6024 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_end_sequence);
6025 fputc ('\n', asm_out_file);
6030 for (lt_index = 0; lt_index < separate_line_info_table_in_use; )
6032 register dw_separate_line_info_ref line_info
6033 = &separate_line_info_table[lt_index];
6035 /* Don't emit anything for redundant notes. */
6036 if (line_info->dw_line_num == current_line
6037 && line_info->dw_file_num == current_file
6038 && line_info->function == function)
6041 /* Emit debug info for the address of the current line. If this is
6042 a new function, or the first line of a function, then we need
6043 to handle it differently. */
6044 ASM_GENERATE_INTERNAL_LABEL (line_label, SEPARATE_LINE_CODE_LABEL,
6046 if (function != line_info->function)
6048 function = line_info->function;
6050 /* Set the address register to the first line in the function */
6051 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
6053 fprintf (asm_out_file, "\t%s DW_LNE_set_address",
6056 fputc ('\n', asm_out_file);
6057 output_uleb128 (1 + PTR_SIZE);
6058 fputc ('\n', asm_out_file);
6059 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address);
6060 fputc ('\n', asm_out_file);
6061 ASM_OUTPUT_DWARF_ADDR (asm_out_file, line_label);
6062 fputc ('\n', asm_out_file);
6066 /* ??? See the DW_LNS_advance_pc comment above. */
6069 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc);
6071 fprintf (asm_out_file, "\t%s DW_LNS_fixed_advance_pc",
6074 fputc ('\n', asm_out_file);
6075 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, line_label,
6077 fputc ('\n', asm_out_file);
6081 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
6083 fprintf (asm_out_file, "\t%s DW_LNE_set_address",
6085 fputc ('\n', asm_out_file);
6086 output_uleb128 (1 + PTR_SIZE);
6087 fputc ('\n', asm_out_file);
6088 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address);
6089 fputc ('\n', asm_out_file);
6090 ASM_OUTPUT_DWARF_ADDR (asm_out_file, line_label);
6091 fputc ('\n', asm_out_file);
6094 strcpy (prev_line_label, line_label);
6096 /* Emit debug info for the source file of the current line, if
6097 different from the previous line. */
6098 if (line_info->dw_file_num != current_file)
6100 current_file = line_info->dw_file_num;
6101 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_set_file);
6103 fprintf (asm_out_file, "\t%s DW_LNS_set_file", ASM_COMMENT_START);
6105 fputc ('\n', asm_out_file);
6106 output_uleb128 (current_file);
6108 fprintf (asm_out_file, " (\"%s\")", file_table[current_file]);
6110 fputc ('\n', asm_out_file);
6113 /* Emit debug info for the current line number, choosing the encoding
6114 that uses the least amount of space. */
6115 if (line_info->dw_line_num != current_line)
6117 line_offset = line_info->dw_line_num - current_line;
6118 line_delta = line_offset - DWARF_LINE_BASE;
6119 current_line = line_info->dw_line_num;
6120 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
6122 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
6123 DWARF_LINE_OPCODE_BASE + line_delta);
6125 fprintf (asm_out_file,
6126 "\t%s line %ld", ASM_COMMENT_START, current_line);
6128 fputc ('\n', asm_out_file);
6132 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_advance_line);
6134 fprintf (asm_out_file, "\t%s advance to line %ld",
6135 ASM_COMMENT_START, current_line);
6137 fputc ('\n', asm_out_file);
6138 output_sleb128 (line_offset);
6139 fputc ('\n', asm_out_file);
6140 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_copy);
6142 fprintf (asm_out_file, "\t%s DW_LNS_copy", ASM_COMMENT_START);
6143 fputc ('\n', asm_out_file);
6148 /* We still need to start a new row, so output a copy insn. */
6149 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_copy);
6151 fprintf (asm_out_file, "\t%s DW_LNS_copy", ASM_COMMENT_START);
6152 fputc ('\n', asm_out_file);
6158 /* If we're done with a function, end its sequence. */
6159 if (lt_index == separate_line_info_table_in_use
6160 || separate_line_info_table[lt_index].function != function)
6165 /* Emit debug info for the address of the end of the function. */
6166 ASM_GENERATE_INTERNAL_LABEL (line_label, FUNC_END_LABEL, function);
6169 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc);
6171 fprintf (asm_out_file, "\t%s DW_LNS_fixed_advance_pc",
6174 fputc ('\n', asm_out_file);
6175 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, line_label,
6177 fputc ('\n', asm_out_file);
6181 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
6183 fprintf (asm_out_file, "\t%s DW_LNE_set_address",
6185 fputc ('\n', asm_out_file);
6186 output_uleb128 (1 + PTR_SIZE);
6187 fputc ('\n', asm_out_file);
6188 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address);
6189 fputc ('\n', asm_out_file);
6190 ASM_OUTPUT_DWARF_ADDR (asm_out_file, line_label);
6191 fputc ('\n', asm_out_file);
6194 /* Output the marker for the end of this sequence. */
6195 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
6197 fprintf (asm_out_file, "\t%s DW_LNE_end_sequence",
6200 fputc ('\n', asm_out_file);
6202 fputc ('\n', asm_out_file);
6203 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_end_sequence);
6204 fputc ('\n', asm_out_file);
6209 /* Given a pointer to a BLOCK node return non-zero if (and only if) the node
6210 in question represents the outermost pair of curly braces (i.e. the "body
6211 block") of a function or method.
6213 For any BLOCK node representing a "body block" of a function or method, the
6214 BLOCK_SUPERCONTEXT of the node will point to another BLOCK node which
6215 represents the outermost (function) scope for the function or method (i.e.
6216 the one which includes the formal parameters). The BLOCK_SUPERCONTEXT of
6217 *that* node in turn will point to the relevant FUNCTION_DECL node. */
6220 is_body_block (stmt)
6223 if (TREE_CODE (stmt) == BLOCK)
6225 register tree parent = BLOCK_SUPERCONTEXT (stmt);
6227 if (TREE_CODE (parent) == BLOCK)
6229 register tree grandparent = BLOCK_SUPERCONTEXT (parent);
6231 if (TREE_CODE (grandparent) == FUNCTION_DECL)
6239 /* Given a pointer to a tree node for some base type, return a pointer to
6240 a DIE that describes the given type.
6242 This routine must only be called for GCC type nodes that correspond to
6243 Dwarf base (fundamental) types. */
6246 base_type_die (type)
6249 register dw_die_ref base_type_result;
6250 register char *type_name;
6251 register enum dwarf_type encoding;
6252 register tree name = TYPE_NAME (type);
6254 if (TREE_CODE (type) == ERROR_MARK
6255 || TREE_CODE (type) == VOID_TYPE)
6258 if (TREE_CODE (name) == TYPE_DECL)
6259 name = DECL_NAME (name);
6260 type_name = IDENTIFIER_POINTER (name);
6262 switch (TREE_CODE (type))
6265 /* Carefully distinguish the C character types, without messing
6266 up if the language is not C. Note that we check only for the names
6267 that contain spaces; other names might occur by coincidence in other
6269 if (! (TYPE_PRECISION (type) == CHAR_TYPE_SIZE
6270 && (type == char_type_node
6271 || ! strcmp (type_name, "signed char")
6272 || ! strcmp (type_name, "unsigned char"))))
6274 if (TREE_UNSIGNED (type))
6275 encoding = DW_ATE_unsigned;
6277 encoding = DW_ATE_signed;
6280 /* else fall through */
6283 /* GNU Pascal/Ada CHAR type. Not used in C. */
6284 if (TREE_UNSIGNED (type))
6285 encoding = DW_ATE_unsigned_char;
6287 encoding = DW_ATE_signed_char;
6291 encoding = DW_ATE_float;
6295 encoding = DW_ATE_complex_float;
6299 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */
6300 encoding = DW_ATE_boolean;
6304 abort (); /* No other TREE_CODEs are Dwarf fundamental types. */
6307 base_type_result = new_die (DW_TAG_base_type, comp_unit_die);
6308 add_AT_string (base_type_result, DW_AT_name, type_name);
6309 add_AT_unsigned (base_type_result, DW_AT_byte_size,
6310 int_size_in_bytes (type));
6311 add_AT_unsigned (base_type_result, DW_AT_encoding, encoding);
6313 return base_type_result;
6316 /* Given a pointer to an arbitrary ..._TYPE tree node, return a pointer to
6317 the Dwarf "root" type for the given input type. The Dwarf "root" type of
6318 a given type is generally the same as the given type, except that if the
6319 given type is a pointer or reference type, then the root type of the given
6320 type is the root type of the "basis" type for the pointer or reference
6321 type. (This definition of the "root" type is recursive.) Also, the root
6322 type of a `const' qualified type or a `volatile' qualified type is the
6323 root type of the given type without the qualifiers. */
6329 if (TREE_CODE (type) == ERROR_MARK)
6330 return error_mark_node;
6332 switch (TREE_CODE (type))
6335 return error_mark_node;
6338 case REFERENCE_TYPE:
6339 return type_main_variant (root_type (TREE_TYPE (type)));
6342 return type_main_variant (type);
6346 /* Given a pointer to an arbitrary ..._TYPE tree node, return non-zero if the
6347 given input type is a Dwarf "fundamental" type. Otherwise return null. */
6353 switch (TREE_CODE (type))
6368 case QUAL_UNION_TYPE:
6373 case REFERENCE_TYPE:
6386 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
6387 entry that chains various modifiers in front of the given type. */
6390 modified_type_die (type, is_const_type, is_volatile_type, context_die)
6392 register int is_const_type;
6393 register int is_volatile_type;
6394 register dw_die_ref context_die;
6396 register enum tree_code code = TREE_CODE (type);
6397 register dw_die_ref mod_type_die = NULL;
6398 register dw_die_ref sub_die = NULL;
6399 register tree item_type = NULL;
6401 if (code != ERROR_MARK)
6403 type = build_type_variant (type, is_const_type, is_volatile_type);
6405 mod_type_die = lookup_type_die (type);
6407 return mod_type_die;
6409 /* Handle C typedef types. */
6410 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
6411 && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
6413 tree dtype = TREE_TYPE (TYPE_NAME (type));
6416 /* For a named type, use the typedef. */
6417 gen_type_die (type, context_die);
6418 mod_type_die = lookup_type_die (type);
6421 else if (is_const_type < TYPE_READONLY (dtype)
6422 || is_volatile_type < TYPE_VOLATILE (dtype))
6423 /* cv-unqualified version of named type. Just use the unnamed
6424 type to which it refers. */
6426 = modified_type_die (DECL_ORIGINAL_TYPE (TYPE_NAME (type)),
6427 is_const_type, is_volatile_type,
6429 /* Else cv-qualified version of named type; fall through. */
6434 else if (is_const_type)
6436 mod_type_die = new_die (DW_TAG_const_type, comp_unit_die);
6437 sub_die = modified_type_die (type, 0, is_volatile_type, context_die);
6439 else if (is_volatile_type)
6441 mod_type_die = new_die (DW_TAG_volatile_type, comp_unit_die);
6442 sub_die = modified_type_die (type, 0, 0, context_die);
6444 else if (code == POINTER_TYPE)
6446 mod_type_die = new_die (DW_TAG_pointer_type, comp_unit_die);
6447 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
6449 add_AT_unsigned (mod_type_die, DW_AT_address_class, 0);
6451 item_type = TREE_TYPE (type);
6453 else if (code == REFERENCE_TYPE)
6455 mod_type_die = new_die (DW_TAG_reference_type, comp_unit_die);
6456 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
6458 add_AT_unsigned (mod_type_die, DW_AT_address_class, 0);
6460 item_type = TREE_TYPE (type);
6462 else if (is_base_type (type))
6463 mod_type_die = base_type_die (type);
6466 gen_type_die (type, context_die);
6468 /* We have to get the type_main_variant here (and pass that to the
6469 `lookup_type_die' routine) because the ..._TYPE node we have
6470 might simply be a *copy* of some original type node (where the
6471 copy was created to help us keep track of typedef names) and
6472 that copy might have a different TYPE_UID from the original
6474 mod_type_die = lookup_type_die (type_main_variant (type));
6475 if (mod_type_die == NULL)
6480 equate_type_number_to_die (type, mod_type_die);
6482 /* We must do this after the equate_type_number_to_die call, in case
6483 this is a recursive type. This ensures that the modified_type_die
6484 recursion will terminate even if the type is recursive. Recursive
6485 types are possible in Ada. */
6486 sub_die = modified_type_die (item_type,
6487 TYPE_READONLY (item_type),
6488 TYPE_VOLATILE (item_type),
6491 if (sub_die != NULL)
6492 add_AT_die_ref (mod_type_die, DW_AT_type, sub_die);
6494 return mod_type_die;
6497 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
6498 an enumerated type. */
6504 return TREE_CODE (type) == ENUMERAL_TYPE;
6507 /* Return a location descriptor that designates a machine register. */
6509 static dw_loc_descr_ref
6510 reg_loc_descriptor (rtl)
6513 register dw_loc_descr_ref loc_result = NULL;
6514 register unsigned reg = reg_number (rtl);
6517 loc_result = new_loc_descr (DW_OP_reg0 + reg, 0, 0);
6519 loc_result = new_loc_descr (DW_OP_regx, reg, 0);
6524 /* Return a location descriptor that designates a base+offset location. */
6526 static dw_loc_descr_ref
6527 based_loc_descr (reg, offset)
6531 register dw_loc_descr_ref loc_result;
6532 /* For the "frame base", we use the frame pointer or stack pointer
6533 registers, since the RTL for local variables is relative to one of
6535 register unsigned fp_reg = DBX_REGISTER_NUMBER (frame_pointer_needed
6536 ? HARD_FRAME_POINTER_REGNUM
6537 : STACK_POINTER_REGNUM);
6540 loc_result = new_loc_descr (DW_OP_fbreg, offset, 0);
6542 loc_result = new_loc_descr (DW_OP_breg0 + reg, offset, 0);
6544 loc_result = new_loc_descr (DW_OP_bregx, reg, offset);
6549 /* Return true if this RTL expression describes a base+offset calculation. */
6555 return (GET_CODE (rtl) == PLUS
6556 && ((GET_CODE (XEXP (rtl, 0)) == REG
6557 && GET_CODE (XEXP (rtl, 1)) == CONST_INT)));
6560 /* The following routine converts the RTL for a variable or parameter
6561 (resident in memory) into an equivalent Dwarf representation of a
6562 mechanism for getting the address of that same variable onto the top of a
6563 hypothetical "address evaluation" stack.
6565 When creating memory location descriptors, we are effectively transforming
6566 the RTL for a memory-resident object into its Dwarf postfix expression
6567 equivalent. This routine recursively descends an RTL tree, turning
6568 it into Dwarf postfix code as it goes. */
6570 static dw_loc_descr_ref
6571 mem_loc_descriptor (rtl)
6574 dw_loc_descr_ref mem_loc_result = NULL;
6575 /* Note that for a dynamically sized array, the location we will generate a
6576 description of here will be the lowest numbered location which is
6577 actually within the array. That's *not* necessarily the same as the
6578 zeroth element of the array. */
6580 switch (GET_CODE (rtl))
6583 /* The case of a subreg may arise when we have a local (register)
6584 variable or a formal (register) parameter which doesn't quite fill
6585 up an entire register. For now, just assume that it is
6586 legitimate to make the Dwarf info refer to the whole register which
6587 contains the given subreg. */
6588 rtl = XEXP (rtl, 0);
6590 /* ... fall through ... */
6593 /* Whenever a register number forms a part of the description of the
6594 method for calculating the (dynamic) address of a memory resident
6595 object, DWARF rules require the register number be referred to as
6596 a "base register". This distinction is not based in any way upon
6597 what category of register the hardware believes the given register
6598 belongs to. This is strictly DWARF terminology we're dealing with
6599 here. Note that in cases where the location of a memory-resident
6600 data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
6601 OP_CONST (0)) the actual DWARF location descriptor that we generate
6602 may just be OP_BASEREG (basereg). This may look deceptively like
6603 the object in question was allocated to a register (rather than in
6604 memory) so DWARF consumers need to be aware of the subtle
6605 distinction between OP_REG and OP_BASEREG. */
6606 mem_loc_result = based_loc_descr (reg_number (rtl), 0);
6610 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0));
6611 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_deref, 0, 0));
6616 mem_loc_result = new_loc_descr (DW_OP_addr, 0, 0);
6617 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_addr;
6618 mem_loc_result->dw_loc_oprnd1.v.val_addr = addr_to_string (rtl);
6622 if (is_based_loc (rtl))
6623 mem_loc_result = based_loc_descr (reg_number (XEXP (rtl, 0)),
6624 INTVAL (XEXP (rtl, 1)));
6627 add_loc_descr (&mem_loc_result, mem_loc_descriptor (XEXP (rtl, 0)));
6628 add_loc_descr (&mem_loc_result, mem_loc_descriptor (XEXP (rtl, 1)));
6629 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_plus, 0, 0));
6634 /* If a pseudo-reg is optimized away, it is possible for it to
6635 be replaced with a MEM containing a multiply. */
6636 add_loc_descr (&mem_loc_result, mem_loc_descriptor (XEXP (rtl, 0)));
6637 add_loc_descr (&mem_loc_result, mem_loc_descriptor (XEXP (rtl, 1)));
6638 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_mul, 0, 0));
6642 mem_loc_result = new_loc_descr (DW_OP_constu, INTVAL (rtl), 0);
6649 return mem_loc_result;
6652 /* Return a descriptor that describes the concatenation of two locations.
6653 This is typically a complex variable. */
6655 static dw_loc_descr_ref
6656 concat_loc_descriptor (x0, x1)
6657 register rtx x0, x1;
6659 dw_loc_descr_ref cc_loc_result = NULL;
6661 if (!is_pseudo_reg (x0)
6662 && (GET_CODE (x0) != MEM || !is_pseudo_reg (XEXP (x0, 0))))
6663 add_loc_descr (&cc_loc_result, loc_descriptor (x0));
6664 add_loc_descr (&cc_loc_result,
6665 new_loc_descr (DW_OP_piece, GET_MODE_SIZE (GET_MODE (x0)), 0));
6667 if (!is_pseudo_reg (x1)
6668 && (GET_CODE (x1) != MEM || !is_pseudo_reg (XEXP (x1, 0))))
6669 add_loc_descr (&cc_loc_result, loc_descriptor (x1));
6670 add_loc_descr (&cc_loc_result,
6671 new_loc_descr (DW_OP_piece, GET_MODE_SIZE (GET_MODE (x1)), 0));
6673 return cc_loc_result;
6676 /* Output a proper Dwarf location descriptor for a variable or parameter
6677 which is either allocated in a register or in a memory location. For a
6678 register, we just generate an OP_REG and the register number. For a
6679 memory location we provide a Dwarf postfix expression describing how to
6680 generate the (dynamic) address of the object onto the address stack. */
6682 static dw_loc_descr_ref
6683 loc_descriptor (rtl)
6686 dw_loc_descr_ref loc_result = NULL;
6687 switch (GET_CODE (rtl))
6690 /* The case of a subreg may arise when we have a local (register)
6691 variable or a formal (register) parameter which doesn't quite fill
6692 up an entire register. For now, just assume that it is
6693 legitimate to make the Dwarf info refer to the whole register which
6694 contains the given subreg. */
6695 rtl = XEXP (rtl, 0);
6697 /* ... fall through ... */
6700 loc_result = reg_loc_descriptor (rtl);
6704 loc_result = mem_loc_descriptor (XEXP (rtl, 0));
6708 loc_result = concat_loc_descriptor (XEXP (rtl, 0), XEXP (rtl, 1));
6718 /* Given an unsigned value, round it up to the lowest multiple of `boundary'
6719 which is not less than the value itself. */
6721 static inline unsigned
6722 ceiling (value, boundary)
6723 register unsigned value;
6724 register unsigned boundary;
6726 return (((value + boundary - 1) / boundary) * boundary);
6729 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
6730 pointer to the declared type for the relevant field variable, or return
6731 `integer_type_node' if the given node turns out to be an
6740 if (TREE_CODE (decl) == ERROR_MARK)
6741 return integer_type_node;
6743 type = DECL_BIT_FIELD_TYPE (decl);
6744 if (type == NULL_TREE)
6745 type = TREE_TYPE (decl);
6750 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
6751 node, return the alignment in bits for the type, or else return
6752 BITS_PER_WORD if the node actually turns out to be an
6755 static inline unsigned
6756 simple_type_align_in_bits (type)
6759 return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD;
6762 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
6763 node, return the size in bits for the type if it is a constant, or else
6764 return the alignment for the type if the type's size is not constant, or
6765 else return BITS_PER_WORD if the type actually turns out to be an
6768 static inline unsigned
6769 simple_type_size_in_bits (type)
6772 if (TREE_CODE (type) == ERROR_MARK)
6773 return BITS_PER_WORD;
6776 register tree type_size_tree = TYPE_SIZE (type);
6778 if (TREE_CODE (type_size_tree) != INTEGER_CST)
6779 return TYPE_ALIGN (type);
6781 return (unsigned) TREE_INT_CST_LOW (type_size_tree);
6785 /* Given a pointer to what is assumed to be a FIELD_DECL node, compute and
6786 return the byte offset of the lowest addressed byte of the "containing
6787 object" for the given FIELD_DECL, or return 0 if we are unable to
6788 determine what that offset is, either because the argument turns out to
6789 be a pointer to an ERROR_MARK node, or because the offset is actually
6790 variable. (We can't handle the latter case just yet). */
6793 field_byte_offset (decl)
6796 register unsigned type_align_in_bytes;
6797 register unsigned type_align_in_bits;
6798 register unsigned type_size_in_bits;
6799 register unsigned object_offset_in_align_units;
6800 register unsigned object_offset_in_bits;
6801 register unsigned object_offset_in_bytes;
6803 register tree bitpos_tree;
6804 register tree field_size_tree;
6805 register unsigned bitpos_int;
6806 register unsigned deepest_bitpos;
6807 register unsigned field_size_in_bits;
6809 if (TREE_CODE (decl) == ERROR_MARK)
6812 if (TREE_CODE (decl) != FIELD_DECL)
6815 type = field_type (decl);
6817 bitpos_tree = DECL_FIELD_BITPOS (decl);
6818 field_size_tree = DECL_SIZE (decl);
6820 /* We cannot yet cope with fields whose positions or sizes are variable, so
6821 for now, when we see such things, we simply return 0. Someday, we may
6822 be able to handle such cases, but it will be damn difficult. */
6823 if (TREE_CODE (bitpos_tree) != INTEGER_CST)
6825 bitpos_int = (unsigned) TREE_INT_CST_LOW (bitpos_tree);
6827 if (TREE_CODE (field_size_tree) != INTEGER_CST)
6830 field_size_in_bits = (unsigned) TREE_INT_CST_LOW (field_size_tree);
6831 type_size_in_bits = simple_type_size_in_bits (type);
6832 type_align_in_bits = simple_type_align_in_bits (type);
6833 type_align_in_bytes = type_align_in_bits / BITS_PER_UNIT;
6835 /* Note that the GCC front-end doesn't make any attempt to keep track of
6836 the starting bit offset (relative to the start of the containing
6837 structure type) of the hypothetical "containing object" for a bit-
6838 field. Thus, when computing the byte offset value for the start of the
6839 "containing object" of a bit-field, we must deduce this information on
6840 our own. This can be rather tricky to do in some cases. For example,
6841 handling the following structure type definition when compiling for an
6842 i386/i486 target (which only aligns long long's to 32-bit boundaries)
6845 struct S { int field1; long long field2:31; };
6847 Fortunately, there is a simple rule-of-thumb which can be
6848 used in such cases. When compiling for an i386/i486, GCC will allocate
6849 8 bytes for the structure shown above. It decides to do this based upon
6850 one simple rule for bit-field allocation. Quite simply, GCC allocates
6851 each "containing object" for each bit-field at the first (i.e. lowest
6852 addressed) legitimate alignment boundary (based upon the required
6853 minimum alignment for the declared type of the field) which it can
6854 possibly use, subject to the condition that there is still enough
6855 available space remaining in the containing object (when allocated at
6856 the selected point) to fully accommodate all of the bits of the
6857 bit-field itself. This simple rule makes it obvious why GCC allocates
6858 8 bytes for each object of the structure type shown above. When looking
6859 for a place to allocate the "containing object" for `field2', the
6860 compiler simply tries to allocate a 64-bit "containing object" at each
6861 successive 32-bit boundary (starting at zero) until it finds a place to
6862 allocate that 64- bit field such that at least 31 contiguous (and
6863 previously unallocated) bits remain within that selected 64 bit field.
6864 (As it turns out, for the example above, the compiler finds that it is
6865 OK to allocate the "containing object" 64-bit field at bit-offset zero
6866 within the structure type.) Here we attempt to work backwards from the
6867 limited set of facts we're given, and we try to deduce from those facts,
6868 where GCC must have believed that the containing object started (within
6869 the structure type). The value we deduce is then used (by the callers of
6870 this routine) to generate DW_AT_location and DW_AT_bit_offset attributes
6871 for fields (both bit-fields and, in the case of DW_AT_location, regular
6874 /* Figure out the bit-distance from the start of the structure to the
6875 "deepest" bit of the bit-field. */
6876 deepest_bitpos = bitpos_int + field_size_in_bits;
6878 /* This is the tricky part. Use some fancy footwork to deduce where the
6879 lowest addressed bit of the containing object must be. */
6880 object_offset_in_bits
6881 = ceiling (deepest_bitpos, type_align_in_bits) - type_size_in_bits;
6883 /* Compute the offset of the containing object in "alignment units". */
6884 object_offset_in_align_units = object_offset_in_bits / type_align_in_bits;
6886 /* Compute the offset of the containing object in bytes. */
6887 object_offset_in_bytes = object_offset_in_align_units * type_align_in_bytes;
6889 return object_offset_in_bytes;
6892 /* The following routines define various Dwarf attributes and any data
6893 associated with them. */
6895 /* Add a location description attribute value to a DIE.
6897 This emits location attributes suitable for whole variables and
6898 whole parameters. Note that the location attributes for struct fields are
6899 generated by the routine `data_member_location_attribute' below. */
6902 add_AT_location_description (die, attr_kind, rtl)
6904 enum dwarf_attribute attr_kind;
6907 /* Handle a special case. If we are about to output a location descriptor
6908 for a variable or parameter which has been optimized out of existence,
6909 don't do that. A variable which has been optimized out
6910 of existence will have a DECL_RTL value which denotes a pseudo-reg.
6911 Currently, in some rare cases, variables can have DECL_RTL values which
6912 look like (MEM (REG pseudo-reg#)). These cases are due to bugs
6913 elsewhere in the compiler. We treat such cases as if the variable(s) in
6914 question had been optimized out of existence. */
6916 if (is_pseudo_reg (rtl)
6917 || (GET_CODE (rtl) == MEM
6918 && is_pseudo_reg (XEXP (rtl, 0)))
6919 || (GET_CODE (rtl) == CONCAT
6920 && is_pseudo_reg (XEXP (rtl, 0))
6921 && is_pseudo_reg (XEXP (rtl, 1))))
6924 add_AT_loc (die, attr_kind, loc_descriptor (rtl));
6927 /* Attach the specialized form of location attribute used for data
6928 members of struct and union types. In the special case of a
6929 FIELD_DECL node which represents a bit-field, the "offset" part
6930 of this special location descriptor must indicate the distance
6931 in bytes from the lowest-addressed byte of the containing struct
6932 or union type to the lowest-addressed byte of the "containing
6933 object" for the bit-field. (See the `field_byte_offset' function
6934 above).. For any given bit-field, the "containing object" is a
6935 hypothetical object (of some integral or enum type) within which
6936 the given bit-field lives. The type of this hypothetical
6937 "containing object" is always the same as the declared type of
6938 the individual bit-field itself (for GCC anyway... the DWARF
6939 spec doesn't actually mandate this). Note that it is the size
6940 (in bytes) of the hypothetical "containing object" which will
6941 be given in the DW_AT_byte_size attribute for this bit-field.
6942 (See the `byte_size_attribute' function below.) It is also used
6943 when calculating the value of the DW_AT_bit_offset attribute.
6944 (See the `bit_offset_attribute' function below). */
6947 add_data_member_location_attribute (die, decl)
6948 register dw_die_ref die;
6951 register unsigned long offset;
6952 register dw_loc_descr_ref loc_descr;
6953 register enum dwarf_location_atom op;
6955 if (TREE_CODE (decl) == TREE_VEC)
6956 offset = TREE_INT_CST_LOW (BINFO_OFFSET (decl));
6958 offset = field_byte_offset (decl);
6960 /* The DWARF2 standard says that we should assume that the structure address
6961 is already on the stack, so we can specify a structure field address
6962 by using DW_OP_plus_uconst. */
6964 #ifdef MIPS_DEBUGGING_INFO
6965 /* ??? The SGI dwarf reader does not handle the DW_OP_plus_uconst operator
6966 correctly. It works only if we leave the offset on the stack. */
6969 op = DW_OP_plus_uconst;
6972 loc_descr = new_loc_descr (op, offset, 0);
6973 add_AT_loc (die, DW_AT_data_member_location, loc_descr);
6976 /* Attach an DW_AT_const_value attribute for a variable or a parameter which
6977 does not have a "location" either in memory or in a register. These
6978 things can arise in GNU C when a constant is passed as an actual parameter
6979 to an inlined function. They can also arise in C++ where declared
6980 constants do not necessarily get memory "homes". */
6983 add_const_value_attribute (die, rtl)
6984 register dw_die_ref die;
6987 switch (GET_CODE (rtl))
6990 /* Note that a CONST_INT rtx could represent either an integer or a
6991 floating-point constant. A CONST_INT is used whenever the constant
6992 will fit into a single word. In all such cases, the original mode
6993 of the constant value is wiped out, and the CONST_INT rtx is
6994 assigned VOIDmode. */
6995 add_AT_unsigned (die, DW_AT_const_value, (unsigned) INTVAL (rtl));
6999 /* Note that a CONST_DOUBLE rtx could represent either an integer or a
7000 floating-point constant. A CONST_DOUBLE is used whenever the
7001 constant requires more than one word in order to be adequately
7002 represented. We output CONST_DOUBLEs as blocks. */
7004 register enum machine_mode mode = GET_MODE (rtl);
7006 if (GET_MODE_CLASS (mode) == MODE_FLOAT)
7008 register unsigned length = GET_MODE_SIZE (mode) / sizeof (long);
7012 REAL_VALUE_FROM_CONST_DOUBLE (rv, rtl);
7016 REAL_VALUE_TO_TARGET_SINGLE (rv, array[0]);
7020 REAL_VALUE_TO_TARGET_DOUBLE (rv, array);
7025 REAL_VALUE_TO_TARGET_LONG_DOUBLE (rv, array);
7032 add_AT_float (die, DW_AT_const_value, length, array);
7035 add_AT_long_long (die, DW_AT_const_value,
7036 CONST_DOUBLE_HIGH (rtl), CONST_DOUBLE_LOW (rtl));
7041 add_AT_string (die, DW_AT_const_value, XSTR (rtl, 0));
7047 add_AT_addr (die, DW_AT_const_value, addr_to_string (rtl));
7051 /* In cases where an inlined instance of an inline function is passed
7052 the address of an `auto' variable (which is local to the caller) we
7053 can get a situation where the DECL_RTL of the artificial local
7054 variable (for the inlining) which acts as a stand-in for the
7055 corresponding formal parameter (of the inline function) will look
7056 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not
7057 exactly a compile-time constant expression, but it isn't the address
7058 of the (artificial) local variable either. Rather, it represents the
7059 *value* which the artificial local variable always has during its
7060 lifetime. We currently have no way to represent such quasi-constant
7061 values in Dwarf, so for now we just punt and generate nothing. */
7065 /* No other kinds of rtx should be possible here. */
7071 /* Generate *either* an DW_AT_location attribute or else an DW_AT_const_value
7072 data attribute for a variable or a parameter. We generate the
7073 DW_AT_const_value attribute only in those cases where the given variable
7074 or parameter does not have a true "location" either in memory or in a
7075 register. This can happen (for example) when a constant is passed as an
7076 actual argument in a call to an inline function. (It's possible that
7077 these things can crop up in other ways also.) Note that one type of
7078 constant value which can be passed into an inlined function is a constant
7079 pointer. This can happen for example if an actual argument in an inlined
7080 function call evaluates to a compile-time constant address. */
7083 add_location_or_const_value_attribute (die, decl)
7084 register dw_die_ref die;
7088 register tree declared_type;
7089 register tree passed_type;
7091 if (TREE_CODE (decl) == ERROR_MARK)
7094 if (TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != PARM_DECL)
7097 /* Here we have to decide where we are going to say the parameter "lives"
7098 (as far as the debugger is concerned). We only have a couple of
7099 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
7101 DECL_RTL normally indicates where the parameter lives during most of the
7102 activation of the function. If optimization is enabled however, this
7103 could be either NULL or else a pseudo-reg. Both of those cases indicate
7104 that the parameter doesn't really live anywhere (as far as the code
7105 generation parts of GCC are concerned) during most of the function's
7106 activation. That will happen (for example) if the parameter is never
7107 referenced within the function.
7109 We could just generate a location descriptor here for all non-NULL
7110 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
7111 a little nicer than that if we also consider DECL_INCOMING_RTL in cases
7112 where DECL_RTL is NULL or is a pseudo-reg.
7114 Note however that we can only get away with using DECL_INCOMING_RTL as
7115 a backup substitute for DECL_RTL in certain limited cases. In cases
7116 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
7117 we can be sure that the parameter was passed using the same type as it is
7118 declared to have within the function, and that its DECL_INCOMING_RTL
7119 points us to a place where a value of that type is passed.
7121 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
7122 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
7123 because in these cases DECL_INCOMING_RTL points us to a value of some
7124 type which is *different* from the type of the parameter itself. Thus,
7125 if we tried to use DECL_INCOMING_RTL to generate a location attribute in
7126 such cases, the debugger would end up (for example) trying to fetch a
7127 `float' from a place which actually contains the first part of a
7128 `double'. That would lead to really incorrect and confusing
7129 output at debug-time.
7131 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
7132 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There
7133 are a couple of exceptions however. On little-endian machines we can
7134 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
7135 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
7136 an integral type that is smaller than TREE_TYPE (decl). These cases arise
7137 when (on a little-endian machine) a non-prototyped function has a
7138 parameter declared to be of type `short' or `char'. In such cases,
7139 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
7140 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
7141 passed `int' value. If the debugger then uses that address to fetch
7142 a `short' or a `char' (on a little-endian machine) the result will be
7143 the correct data, so we allow for such exceptional cases below.
7145 Note that our goal here is to describe the place where the given formal
7146 parameter lives during most of the function's activation (i.e. between
7147 the end of the prologue and the start of the epilogue). We'll do that
7148 as best as we can. Note however that if the given formal parameter is
7149 modified sometime during the execution of the function, then a stack
7150 backtrace (at debug-time) will show the function as having been
7151 called with the *new* value rather than the value which was
7152 originally passed in. This happens rarely enough that it is not
7153 a major problem, but it *is* a problem, and I'd like to fix it.
7155 A future version of dwarf2out.c may generate two additional
7156 attributes for any given DW_TAG_formal_parameter DIE which will
7157 describe the "passed type" and the "passed location" for the
7158 given formal parameter in addition to the attributes we now
7159 generate to indicate the "declared type" and the "active
7160 location" for each parameter. This additional set of attributes
7161 could be used by debuggers for stack backtraces. Separately, note
7162 that sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be
7163 NULL also. This happens (for example) for inlined-instances of
7164 inline function formal parameters which are never referenced.
7165 This really shouldn't be happening. All PARM_DECL nodes should
7166 get valid non-NULL DECL_INCOMING_RTL values, but integrate.c
7167 doesn't currently generate these values for inlined instances of
7168 inline function parameters, so when we see such cases, we are
7169 just out-of-luck for the time being (until integrate.c
7172 /* Use DECL_RTL as the "location" unless we find something better. */
7173 rtl = DECL_RTL (decl);
7175 if (TREE_CODE (decl) == PARM_DECL)
7177 if (rtl == NULL_RTX || is_pseudo_reg (rtl))
7179 declared_type = type_main_variant (TREE_TYPE (decl));
7180 passed_type = type_main_variant (DECL_ARG_TYPE (decl));
7182 /* This decl represents a formal parameter which was optimized out.
7183 Note that DECL_INCOMING_RTL may be NULL in here, but we handle
7184 all* cases where (rtl == NULL_RTX) just below. */
7185 if (declared_type == passed_type)
7186 rtl = DECL_INCOMING_RTL (decl);
7187 else if (! BYTES_BIG_ENDIAN
7188 && TREE_CODE (declared_type) == INTEGER_TYPE
7189 && (GET_MODE_SIZE (TYPE_MODE (declared_type))
7190 <= GET_MODE_SIZE (TYPE_MODE (passed_type))))
7191 rtl = DECL_INCOMING_RTL (decl);
7194 /* If the parm was passed in registers, but lives on the stack, then
7195 make a big endian correction if the mode of the type of the
7196 parameter is not the same as the mode of the rtl. */
7197 /* ??? This is the same series of checks that are made in dbxout.c before
7198 we reach the big endian correction code there. It isn't clear if all
7199 of these checks are necessary here, but keeping them all is the safe
7201 else if (GET_CODE (rtl) == MEM
7202 && XEXP (rtl, 0) != const0_rtx
7203 && ! CONSTANT_P (XEXP (rtl, 0))
7204 /* Not passed in memory. */
7205 && GET_CODE (DECL_INCOMING_RTL (decl)) != MEM
7206 /* Not passed by invisible reference. */
7207 && (GET_CODE (XEXP (rtl, 0)) != REG
7208 || REGNO (XEXP (rtl, 0)) == HARD_FRAME_POINTER_REGNUM
7209 || REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM
7210 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
7211 || REGNO (XEXP (rtl, 0)) == ARG_POINTER_REGNUM
7214 /* Big endian correction check. */
7216 && TYPE_MODE (TREE_TYPE (decl)) != GET_MODE (rtl)
7217 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)))
7220 int offset = (UNITS_PER_WORD
7221 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl))));
7222 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
7223 plus_constant (XEXP (rtl, 0), offset));
7227 if (rtl == NULL_RTX)
7230 rtl = eliminate_regs (rtl, 0, NULL_RTX);
7231 #ifdef LEAF_REG_REMAP
7232 if (current_function_uses_only_leaf_regs)
7233 leaf_renumber_regs_insn (rtl);
7236 switch (GET_CODE (rtl))
7239 /* The address of a variable that was optimized away; don't emit
7250 /* DECL_RTL could be (plus (reg ...) (const_int ...)) */
7251 add_const_value_attribute (die, rtl);
7258 add_AT_location_description (die, DW_AT_location, rtl);
7266 /* Generate an DW_AT_name attribute given some string value to be included as
7267 the value of the attribute. */
7270 add_name_attribute (die, name_string)
7271 register dw_die_ref die;
7272 register char *name_string;
7274 if (name_string != NULL && *name_string != 0)
7275 add_AT_string (die, DW_AT_name, name_string);
7278 /* Given a tree node describing an array bound (either lower or upper) output
7279 a representation for that bound. */
7282 add_bound_info (subrange_die, bound_attr, bound)
7283 register dw_die_ref subrange_die;
7284 register enum dwarf_attribute bound_attr;
7285 register tree bound;
7287 register unsigned bound_value = 0;
7289 /* If this is an Ada unconstrained array type, then don't emit any debug
7290 info because the array bounds are unknown. They are parameterized when
7291 the type is instantiated. */
7292 if (contains_placeholder_p (bound))
7295 switch (TREE_CODE (bound))
7300 /* All fixed-bounds are represented by INTEGER_CST nodes. */
7302 bound_value = TREE_INT_CST_LOW (bound);
7303 if (bound_attr == DW_AT_lower_bound
7304 && ((is_c_family () && bound_value == 0)
7305 || (is_fortran () && bound_value == 1)))
7306 /* use the default */;
7308 add_AT_unsigned (subrange_die, bound_attr, bound_value);
7313 case NON_LVALUE_EXPR:
7314 add_bound_info (subrange_die, bound_attr, TREE_OPERAND (bound, 0));
7318 /* If optimization is turned on, the SAVE_EXPRs that describe how to
7319 access the upper bound values may be bogus. If they refer to a
7320 register, they may only describe how to get at these values at the
7321 points in the generated code right after they have just been
7322 computed. Worse yet, in the typical case, the upper bound values
7323 will not even *be* computed in the optimized code (though the
7324 number of elements will), so these SAVE_EXPRs are entirely
7325 bogus. In order to compensate for this fact, we check here to see
7326 if optimization is enabled, and if so, we don't add an attribute
7327 for the (unknown and unknowable) upper bound. This should not
7328 cause too much trouble for existing (stupid?) debuggers because
7329 they have to deal with empty upper bounds location descriptions
7330 anyway in order to be able to deal with incomplete array types.
7331 Of course an intelligent debugger (GDB?) should be able to
7332 comprehend that a missing upper bound specification in a array
7333 type used for a storage class `auto' local array variable
7334 indicates that the upper bound is both unknown (at compile- time)
7335 and unknowable (at run-time) due to optimization.
7337 We assume that a MEM rtx is safe because gcc wouldn't put the
7338 value there unless it was going to be used repeatedly in the
7339 function, i.e. for cleanups. */
7340 if (! optimize || GET_CODE (SAVE_EXPR_RTL (bound)) == MEM)
7342 register dw_die_ref ctx = lookup_decl_die (current_function_decl);
7343 register dw_die_ref decl_die = new_die (DW_TAG_variable, ctx);
7344 register rtx loc = SAVE_EXPR_RTL (bound);
7346 /* If the RTL for the SAVE_EXPR is memory, handle the case where
7347 it references an outer function's frame. */
7349 if (GET_CODE (loc) == MEM)
7351 rtx new_addr = fix_lexical_addr (XEXP (loc, 0), bound);
7353 if (XEXP (loc, 0) != new_addr)
7354 loc = gen_rtx (MEM, GET_MODE (loc), new_addr);
7357 add_AT_flag (decl_die, DW_AT_artificial, 1);
7358 add_type_attribute (decl_die, TREE_TYPE (bound), 1, 0, ctx);
7359 add_AT_location_description (decl_die, DW_AT_location, loc);
7360 add_AT_die_ref (subrange_die, bound_attr, decl_die);
7363 /* Else leave out the attribute. */
7369 /* ??? These types of bounds can be created by the Ada front end,
7370 and it isn't clear how to emit debug info for them. */
7378 /* Note that the block of subscript information for an array type also
7379 includes information about the element type of type given array type. */
7382 add_subscript_info (type_die, type)
7383 register dw_die_ref type_die;
7386 #ifndef MIPS_DEBUGGING_INFO
7387 register unsigned dimension_number;
7389 register tree lower, upper;
7390 register dw_die_ref subrange_die;
7392 /* The GNU compilers represent multidimensional array types as sequences of
7393 one dimensional array types whose element types are themselves array
7394 types. Here we squish that down, so that each multidimensional array
7395 type gets only one array_type DIE in the Dwarf debugging info. The draft
7396 Dwarf specification say that we are allowed to do this kind of
7397 compression in C (because there is no difference between an array or
7398 arrays and a multidimensional array in C) but for other source languages
7399 (e.g. Ada) we probably shouldn't do this. */
7401 /* ??? The SGI dwarf reader fails for multidimensional arrays with a
7402 const enum type. E.g. const enum machine_mode insn_operand_mode[2][10].
7403 We work around this by disabling this feature. See also
7404 gen_array_type_die. */
7405 #ifndef MIPS_DEBUGGING_INFO
7406 for (dimension_number = 0;
7407 TREE_CODE (type) == ARRAY_TYPE;
7408 type = TREE_TYPE (type), dimension_number++)
7411 register tree domain = TYPE_DOMAIN (type);
7413 /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
7414 and (in GNU C only) variable bounds. Handle all three forms
7416 subrange_die = new_die (DW_TAG_subrange_type, type_die);
7419 /* We have an array type with specified bounds. */
7420 lower = TYPE_MIN_VALUE (domain);
7421 upper = TYPE_MAX_VALUE (domain);
7423 /* define the index type. */
7424 if (TREE_TYPE (domain))
7426 /* ??? This is probably an Ada unnamed subrange type. Ignore the
7427 TREE_TYPE field. We can't emit debug info for this
7428 because it is an unnamed integral type. */
7429 if (TREE_CODE (domain) == INTEGER_TYPE
7430 && TYPE_NAME (domain) == NULL_TREE
7431 && TREE_CODE (TREE_TYPE (domain)) == INTEGER_TYPE
7432 && TYPE_NAME (TREE_TYPE (domain)) == NULL_TREE)
7435 add_type_attribute (subrange_die, TREE_TYPE (domain), 0, 0,
7439 /* ??? If upper is NULL, the array has unspecified length,
7440 but it does have a lower bound. This happens with Fortran
7442 Since the debugger is definitely going to need to know N
7443 to produce useful results, go ahead and output the lower
7444 bound solo, and hope the debugger can cope. */
7446 add_bound_info (subrange_die, DW_AT_lower_bound, lower);
7448 add_bound_info (subrange_die, DW_AT_upper_bound, upper);
7451 /* We have an array type with an unspecified length. The DWARF-2
7452 spec does not say how to handle this; let's just leave out the
7457 #ifndef MIPS_DEBUGGING_INFO
7463 add_byte_size_attribute (die, tree_node)
7465 register tree tree_node;
7467 register unsigned size;
7469 switch (TREE_CODE (tree_node))
7477 case QUAL_UNION_TYPE:
7478 size = int_size_in_bytes (tree_node);
7481 /* For a data member of a struct or union, the DW_AT_byte_size is
7482 generally given as the number of bytes normally allocated for an
7483 object of the *declared* type of the member itself. This is true
7484 even for bit-fields. */
7485 size = simple_type_size_in_bits (field_type (tree_node)) / BITS_PER_UNIT;
7491 /* Note that `size' might be -1 when we get to this point. If it is, that
7492 indicates that the byte size of the entity in question is variable. We
7493 have no good way of expressing this fact in Dwarf at the present time,
7494 so just let the -1 pass on through. */
7496 add_AT_unsigned (die, DW_AT_byte_size, size);
7499 /* For a FIELD_DECL node which represents a bit-field, output an attribute
7500 which specifies the distance in bits from the highest order bit of the
7501 "containing object" for the bit-field to the highest order bit of the
7504 For any given bit-field, the "containing object" is a hypothetical
7505 object (of some integral or enum type) within which the given bit-field
7506 lives. The type of this hypothetical "containing object" is always the
7507 same as the declared type of the individual bit-field itself. The
7508 determination of the exact location of the "containing object" for a
7509 bit-field is rather complicated. It's handled by the
7510 `field_byte_offset' function (above).
7512 Note that it is the size (in bytes) of the hypothetical "containing object"
7513 which will be given in the DW_AT_byte_size attribute for this bit-field.
7514 (See `byte_size_attribute' above). */
7517 add_bit_offset_attribute (die, decl)
7518 register dw_die_ref die;
7521 register unsigned object_offset_in_bytes = field_byte_offset (decl);
7522 register tree type = DECL_BIT_FIELD_TYPE (decl);
7523 register tree bitpos_tree = DECL_FIELD_BITPOS (decl);
7524 register unsigned bitpos_int;
7525 register unsigned highest_order_object_bit_offset;
7526 register unsigned highest_order_field_bit_offset;
7527 register unsigned bit_offset;
7529 /* Must be a field and a bit field. */
7531 || TREE_CODE (decl) != FIELD_DECL)
7534 /* We can't yet handle bit-fields whose offsets are variable, so if we
7535 encounter such things, just return without generating any attribute
7537 if (TREE_CODE (bitpos_tree) != INTEGER_CST)
7540 bitpos_int = (unsigned) TREE_INT_CST_LOW (bitpos_tree);
7542 /* Note that the bit offset is always the distance (in bits) from the
7543 highest-order bit of the "containing object" to the highest-order bit of
7544 the bit-field itself. Since the "high-order end" of any object or field
7545 is different on big-endian and little-endian machines, the computation
7546 below must take account of these differences. */
7547 highest_order_object_bit_offset = object_offset_in_bytes * BITS_PER_UNIT;
7548 highest_order_field_bit_offset = bitpos_int;
7550 if (! BYTES_BIG_ENDIAN)
7552 highest_order_field_bit_offset
7553 += (unsigned) TREE_INT_CST_LOW (DECL_SIZE (decl));
7555 highest_order_object_bit_offset += simple_type_size_in_bits (type);
7559 = (! BYTES_BIG_ENDIAN
7560 ? highest_order_object_bit_offset - highest_order_field_bit_offset
7561 : highest_order_field_bit_offset - highest_order_object_bit_offset);
7563 add_AT_unsigned (die, DW_AT_bit_offset, bit_offset);
7566 /* For a FIELD_DECL node which represents a bit field, output an attribute
7567 which specifies the length in bits of the given field. */
7570 add_bit_size_attribute (die, decl)
7571 register dw_die_ref die;
7574 /* Must be a field and a bit field. */
7575 if (TREE_CODE (decl) != FIELD_DECL
7576 || ! DECL_BIT_FIELD_TYPE (decl))
7578 add_AT_unsigned (die, DW_AT_bit_size,
7579 (unsigned) TREE_INT_CST_LOW (DECL_SIZE (decl)));
7582 /* If the compiled language is ANSI C, then add a 'prototyped'
7583 attribute, if arg types are given for the parameters of a function. */
7586 add_prototyped_attribute (die, func_type)
7587 register dw_die_ref die;
7588 register tree func_type;
7590 if (get_AT_unsigned (comp_unit_die, DW_AT_language) == DW_LANG_C89
7591 && TYPE_ARG_TYPES (func_type) != NULL)
7592 add_AT_flag (die, DW_AT_prototyped, 1);
7596 /* Add an 'abstract_origin' attribute below a given DIE. The DIE is found
7597 by looking in either the type declaration or object declaration
7601 add_abstract_origin_attribute (die, origin)
7602 register dw_die_ref die;
7603 register tree origin;
7605 dw_die_ref origin_die = NULL;
7606 if (TREE_CODE_CLASS (TREE_CODE (origin)) == 'd')
7607 origin_die = lookup_decl_die (origin);
7608 else if (TREE_CODE_CLASS (TREE_CODE (origin)) == 't')
7609 origin_die = lookup_type_die (origin);
7611 add_AT_die_ref (die, DW_AT_abstract_origin, origin_die);
7614 /* We do not currently support the pure_virtual attribute. */
7617 add_pure_or_virtual_attribute (die, func_decl)
7618 register dw_die_ref die;
7619 register tree func_decl;
7621 if (DECL_VINDEX (func_decl))
7623 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
7624 add_AT_loc (die, DW_AT_vtable_elem_location,
7625 new_loc_descr (DW_OP_constu,
7626 TREE_INT_CST_LOW (DECL_VINDEX (func_decl)),
7629 /* GNU extension: Record what type this method came from originally. */
7630 if (debug_info_level > DINFO_LEVEL_TERSE)
7631 add_AT_die_ref (die, DW_AT_containing_type,
7632 lookup_type_die (DECL_CONTEXT (func_decl)));
7636 /* Add source coordinate attributes for the given decl. */
7639 add_src_coords_attributes (die, decl)
7640 register dw_die_ref die;
7643 register unsigned file_index = lookup_filename (DECL_SOURCE_FILE (decl));
7645 add_AT_unsigned (die, DW_AT_decl_file, file_index);
7646 add_AT_unsigned (die, DW_AT_decl_line, DECL_SOURCE_LINE (decl));
7649 /* Add an DW_AT_name attribute and source coordinate attribute for the
7650 given decl, but only if it actually has a name. */
7653 add_name_and_src_coords_attributes (die, decl)
7654 register dw_die_ref die;
7657 register tree decl_name;
7659 decl_name = DECL_NAME (decl);
7660 if (decl_name != NULL && IDENTIFIER_POINTER (decl_name) != NULL)
7662 add_name_attribute (die, dwarf2_name (decl, 0));
7663 add_src_coords_attributes (die, decl);
7664 if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
7665 && DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
7666 add_AT_string (die, DW_AT_MIPS_linkage_name,
7667 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
7671 /* Push a new declaration scope. */
7674 push_decl_scope (scope)
7677 tree containing_scope;
7680 /* Make room in the decl_scope_table, if necessary. */
7681 if (decl_scope_table_allocated == decl_scope_depth)
7683 decl_scope_table_allocated += DECL_SCOPE_TABLE_INCREMENT;
7685 = (decl_scope_node *) xrealloc (decl_scope_table,
7686 (decl_scope_table_allocated
7687 * sizeof (decl_scope_node)));
7690 decl_scope_table[decl_scope_depth].scope = scope;
7692 /* Sometimes, while recursively emitting subtypes within a class type,
7693 we end up recuring on a subtype at a higher level then the current
7694 subtype. In such a case, we need to search the decl_scope_table to
7695 find the parent of this subtype. */
7697 if (AGGREGATE_TYPE_P (scope))
7698 containing_scope = TYPE_CONTEXT (scope);
7700 containing_scope = NULL_TREE;
7702 /* The normal case. */
7703 if (decl_scope_depth == 0
7704 || containing_scope == NULL_TREE
7705 /* Ignore namespaces for the moment. */
7706 || TREE_CODE (containing_scope) == NAMESPACE_DECL
7707 || containing_scope == decl_scope_table[decl_scope_depth - 1].scope)
7708 decl_scope_table[decl_scope_depth].previous = decl_scope_depth - 1;
7711 /* We need to search for the containing_scope. */
7712 for (i = 0; i < decl_scope_depth; i++)
7713 if (decl_scope_table[i].scope == containing_scope)
7716 if (i == decl_scope_depth)
7719 decl_scope_table[decl_scope_depth].previous = i;
7725 /* Return the DIE for the scope that immediately contains this declaration. */
7728 scope_die_for (t, context_die)
7730 register dw_die_ref context_die;
7732 register dw_die_ref scope_die = NULL;
7733 register tree containing_scope;
7736 /* Walk back up the declaration tree looking for a place to define
7738 if (TREE_CODE_CLASS (TREE_CODE (t)) == 't')
7739 containing_scope = TYPE_CONTEXT (t);
7740 else if (TREE_CODE (t) == FUNCTION_DECL && DECL_VINDEX (t))
7741 containing_scope = decl_class_context (t);
7743 containing_scope = DECL_CONTEXT (t);
7745 /* Ignore namespaces for the moment. */
7746 if (containing_scope && TREE_CODE (containing_scope) == NAMESPACE_DECL)
7747 containing_scope = NULL_TREE;
7749 /* Ignore function type "scopes" from the C frontend. They mean that
7750 a tagged type is local to a parmlist of a function declarator, but
7751 that isn't useful to DWARF. */
7752 if (containing_scope && TREE_CODE (containing_scope) == FUNCTION_TYPE)
7753 containing_scope = NULL_TREE;
7755 /* Function-local tags and functions get stuck in limbo until they are
7756 fixed up by decls_for_scope. */
7757 if (context_die == NULL && containing_scope != NULL_TREE
7758 && (TREE_CODE (t) == FUNCTION_DECL || is_tagged_type (t)))
7761 if (containing_scope == NULL_TREE)
7762 scope_die = comp_unit_die;
7765 for (i = decl_scope_depth - 1, scope_die = context_die;
7766 i >= 0 && decl_scope_table[i].scope != containing_scope;
7767 (scope_die = scope_die->die_parent,
7768 i = decl_scope_table[i].previous))
7771 /* ??? Integrate_decl_tree does not handle BLOCK_TYPE_TAGS, nor
7772 does it try to handle types defined by TYPE_DECLs. Such types
7773 thus have an incorrect TYPE_CONTEXT, which points to the block
7774 they were originally defined in, instead of the current block
7775 created by function inlining. We try to detect that here and
7778 if (i < 0 && scope_die == comp_unit_die
7779 && TREE_CODE (containing_scope) == BLOCK
7780 && is_tagged_type (t)
7781 && (block_ultimate_origin (decl_scope_table[decl_scope_depth - 1].scope)
7782 == containing_scope))
7784 scope_die = context_die;
7785 /* Since the checks below are no longer applicable. */
7791 if (TREE_CODE_CLASS (TREE_CODE (containing_scope)) != 't')
7793 if (debug_info_level > DINFO_LEVEL_TERSE
7794 && !TREE_ASM_WRITTEN (containing_scope))
7797 /* If none of the current dies are suitable, we get file scope. */
7798 scope_die = comp_unit_die;
7805 /* Pop a declaration scope. */
7809 if (decl_scope_depth <= 0)
7814 /* Many forms of DIEs require a "type description" attribute. This
7815 routine locates the proper "type descriptor" die for the type given
7816 by 'type', and adds an DW_AT_type attribute below the given die. */
7819 add_type_attribute (object_die, type, decl_const, decl_volatile, context_die)
7820 register dw_die_ref object_die;
7822 register int decl_const;
7823 register int decl_volatile;
7824 register dw_die_ref context_die;
7826 register enum tree_code code = TREE_CODE (type);
7827 register dw_die_ref type_die = NULL;
7829 /* ??? If this type is an unnamed subrange type of an integral or
7830 floating-point type, use the inner type. This is because we have no
7831 support for unnamed types in base_type_die. This can happen if this is
7832 an Ada subrange type. Correct solution is emit a subrange type die. */
7833 if ((code == INTEGER_TYPE || code == REAL_TYPE)
7834 && TREE_TYPE (type) != 0 && TYPE_NAME (type) == 0)
7835 type = TREE_TYPE (type), code = TREE_CODE (type);
7837 if (code == ERROR_MARK)
7840 /* Handle a special case. For functions whose return type is void, we
7841 generate *no* type attribute. (Note that no object may have type
7842 `void', so this only applies to function return types). */
7843 if (code == VOID_TYPE)
7846 type_die = modified_type_die (type,
7847 decl_const || TYPE_READONLY (type),
7848 decl_volatile || TYPE_VOLATILE (type),
7850 if (type_die != NULL)
7851 add_AT_die_ref (object_die, DW_AT_type, type_die);
7854 /* Given a tree pointer to a struct, class, union, or enum type node, return
7855 a pointer to the (string) tag name for the given type, or zero if the type
7856 was declared without a tag. */
7862 register char *name = 0;
7864 if (TYPE_NAME (type) != 0)
7866 register tree t = 0;
7868 /* Find the IDENTIFIER_NODE for the type name. */
7869 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
7870 t = TYPE_NAME (type);
7872 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
7873 a TYPE_DECL node, regardless of whether or not a `typedef' was
7875 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
7876 && ! DECL_IGNORED_P (TYPE_NAME (type)))
7877 t = DECL_NAME (TYPE_NAME (type));
7879 /* Now get the name as a string, or invent one. */
7881 name = IDENTIFIER_POINTER (t);
7884 return (name == 0 || *name == '\0') ? 0 : name;
7887 /* Return the type associated with a data member, make a special check
7888 for bit field types. */
7891 member_declared_type (member)
7892 register tree member;
7894 return (DECL_BIT_FIELD_TYPE (member)
7895 ? DECL_BIT_FIELD_TYPE (member)
7896 : TREE_TYPE (member));
7899 /* Get the decl's label, as described by its RTL. This may be different
7900 from the DECL_NAME name used in the source file. */
7904 decl_start_label (decl)
7909 x = DECL_RTL (decl);
7910 if (GET_CODE (x) != MEM)
7914 if (GET_CODE (x) != SYMBOL_REF)
7917 fnname = XSTR (x, 0);
7922 /* These routines generate the internal representation of the DIE's for
7923 the compilation unit. Debugging information is collected by walking
7924 the declaration trees passed in from dwarf2out_decl(). */
7927 gen_array_type_die (type, context_die)
7929 register dw_die_ref context_die;
7931 register dw_die_ref scope_die = scope_die_for (type, context_die);
7932 register dw_die_ref array_die;
7933 register tree element_type;
7935 /* ??? The SGI dwarf reader fails for array of array of enum types unless
7936 the inner array type comes before the outer array type. Thus we must
7937 call gen_type_die before we call new_die. See below also. */
7938 #ifdef MIPS_DEBUGGING_INFO
7939 gen_type_die (TREE_TYPE (type), context_die);
7942 array_die = new_die (DW_TAG_array_type, scope_die);
7945 /* We default the array ordering. SDB will probably do
7946 the right things even if DW_AT_ordering is not present. It's not even
7947 an issue until we start to get into multidimensional arrays anyway. If
7948 SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
7949 then we'll have to put the DW_AT_ordering attribute back in. (But if
7950 and when we find out that we need to put these in, we will only do so
7951 for multidimensional arrays. */
7952 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major);
7955 #ifdef MIPS_DEBUGGING_INFO
7956 /* The SGI compilers handle arrays of unknown bound by setting
7957 AT_declaration and not emitting any subrange DIEs. */
7958 if (! TYPE_DOMAIN (type))
7959 add_AT_unsigned (array_die, DW_AT_declaration, 1);
7962 add_subscript_info (array_die, type);
7964 equate_type_number_to_die (type, array_die);
7966 /* Add representation of the type of the elements of this array type. */
7967 element_type = TREE_TYPE (type);
7969 /* ??? The SGI dwarf reader fails for multidimensional arrays with a
7970 const enum type. E.g. const enum machine_mode insn_operand_mode[2][10].
7971 We work around this by disabling this feature. See also
7972 add_subscript_info. */
7973 #ifndef MIPS_DEBUGGING_INFO
7974 while (TREE_CODE (element_type) == ARRAY_TYPE)
7975 element_type = TREE_TYPE (element_type);
7977 gen_type_die (element_type, context_die);
7980 add_type_attribute (array_die, element_type, 0, 0, context_die);
7984 gen_set_type_die (type, context_die)
7986 register dw_die_ref context_die;
7988 register dw_die_ref type_die
7989 = new_die (DW_TAG_set_type, scope_die_for (type, context_die));
7991 equate_type_number_to_die (type, type_die);
7992 add_type_attribute (type_die, TREE_TYPE (type), 0, 0, context_die);
7997 gen_entry_point_die (decl, context_die)
7999 register dw_die_ref context_die;
8001 register tree origin = decl_ultimate_origin (decl);
8002 register dw_die_ref decl_die = new_die (DW_TAG_entry_point, context_die);
8004 add_abstract_origin_attribute (decl_die, origin);
8007 add_name_and_src_coords_attributes (decl_die, decl);
8008 add_type_attribute (decl_die, TREE_TYPE (TREE_TYPE (decl)),
8012 if (DECL_ABSTRACT (decl))
8013 equate_decl_number_to_die (decl, decl_die);
8015 add_AT_lbl_id (decl_die, DW_AT_low_pc, decl_start_label (decl));
8019 /* Remember a type in the pending_types_list. */
8025 if (pending_types == pending_types_allocated)
8027 pending_types_allocated += PENDING_TYPES_INCREMENT;
8029 = (tree *) xrealloc (pending_types_list,
8030 sizeof (tree) * pending_types_allocated);
8033 pending_types_list[pending_types++] = type;
8036 /* Output any pending types (from the pending_types list) which we can output
8037 now (taking into account the scope that we are working on now).
8039 For each type output, remove the given type from the pending_types_list
8040 *before* we try to output it. */
8043 output_pending_types_for_scope (context_die)
8044 register dw_die_ref context_die;
8048 while (pending_types)
8051 type = pending_types_list[pending_types];
8052 gen_type_die (type, context_die);
8053 if (!TREE_ASM_WRITTEN (type))
8058 /* Remember a type in the incomplete_types_list. */
8061 add_incomplete_type (type)
8064 if (incomplete_types == incomplete_types_allocated)
8066 incomplete_types_allocated += INCOMPLETE_TYPES_INCREMENT;
8067 incomplete_types_list
8068 = (tree *) xrealloc (incomplete_types_list,
8069 sizeof (tree) * incomplete_types_allocated);
8072 incomplete_types_list[incomplete_types++] = type;
8075 /* Walk through the list of incomplete types again, trying once more to
8076 emit full debugging info for them. */
8079 retry_incomplete_types ()
8083 while (incomplete_types)
8086 type = incomplete_types_list[incomplete_types];
8087 gen_type_die (type, comp_unit_die);
8091 /* Generate a DIE to represent an inlined instance of an enumeration type. */
8094 gen_inlined_enumeration_type_die (type, context_die)
8096 register dw_die_ref context_die;
8098 register dw_die_ref type_die = new_die (DW_TAG_enumeration_type,
8099 scope_die_for (type, context_die));
8101 if (!TREE_ASM_WRITTEN (type))
8103 add_abstract_origin_attribute (type_die, type);
8106 /* Generate a DIE to represent an inlined instance of a structure type. */
8109 gen_inlined_structure_type_die (type, context_die)
8111 register dw_die_ref context_die;
8113 register dw_die_ref type_die = new_die (DW_TAG_structure_type,
8114 scope_die_for (type, context_die));
8116 if (!TREE_ASM_WRITTEN (type))
8118 add_abstract_origin_attribute (type_die, type);
8121 /* Generate a DIE to represent an inlined instance of a union type. */
8124 gen_inlined_union_type_die (type, context_die)
8126 register dw_die_ref context_die;
8128 register dw_die_ref type_die = new_die (DW_TAG_union_type,
8129 scope_die_for (type, context_die));
8131 if (!TREE_ASM_WRITTEN (type))
8133 add_abstract_origin_attribute (type_die, type);
8136 /* Generate a DIE to represent an enumeration type. Note that these DIEs
8137 include all of the information about the enumeration values also. Each
8138 enumerated type name/value is listed as a child of the enumerated type
8142 gen_enumeration_type_die (type, context_die)
8144 register dw_die_ref context_die;
8146 register dw_die_ref type_die = lookup_type_die (type);
8148 if (type_die == NULL)
8150 type_die = new_die (DW_TAG_enumeration_type,
8151 scope_die_for (type, context_die));
8152 equate_type_number_to_die (type, type_die);
8153 add_name_attribute (type_die, type_tag (type));
8155 else if (! TYPE_SIZE (type))
8158 remove_AT (type_die, DW_AT_declaration);
8160 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the
8161 given enum type is incomplete, do not generate the DW_AT_byte_size
8162 attribute or the DW_AT_element_list attribute. */
8163 if (TYPE_SIZE (type))
8167 TREE_ASM_WRITTEN (type) = 1;
8168 add_byte_size_attribute (type_die, type);
8169 if (TYPE_STUB_DECL (type) != NULL_TREE)
8170 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
8172 /* If the first reference to this type was as the return type of an
8173 inline function, then it may not have a parent. Fix this now. */
8174 if (type_die->die_parent == NULL)
8175 add_child_die (scope_die_for (type, context_die), type_die);
8177 for (link = TYPE_FIELDS (type);
8178 link != NULL; link = TREE_CHAIN (link))
8180 register dw_die_ref enum_die = new_die (DW_TAG_enumerator, type_die);
8182 add_name_attribute (enum_die,
8183 IDENTIFIER_POINTER (TREE_PURPOSE (link)));
8184 add_AT_unsigned (enum_die, DW_AT_const_value,
8185 (unsigned) TREE_INT_CST_LOW (TREE_VALUE (link)));
8189 add_AT_flag (type_die, DW_AT_declaration, 1);
8193 /* Generate a DIE to represent either a real live formal parameter decl or to
8194 represent just the type of some formal parameter position in some function
8197 Note that this routine is a bit unusual because its argument may be a
8198 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
8199 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
8200 node. If it's the former then this function is being called to output a
8201 DIE to represent a formal parameter object (or some inlining thereof). If
8202 it's the latter, then this function is only being called to output a
8203 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
8204 argument type of some subprogram type. */
8207 gen_formal_parameter_die (node, context_die)
8209 register dw_die_ref context_die;
8211 register dw_die_ref parm_die
8212 = new_die (DW_TAG_formal_parameter, context_die);
8213 register tree origin;
8215 switch (TREE_CODE_CLASS (TREE_CODE (node)))
8218 origin = decl_ultimate_origin (node);
8220 add_abstract_origin_attribute (parm_die, origin);
8223 add_name_and_src_coords_attributes (parm_die, node);
8224 add_type_attribute (parm_die, TREE_TYPE (node),
8225 TREE_READONLY (node),
8226 TREE_THIS_VOLATILE (node),
8228 if (DECL_ARTIFICIAL (node))
8229 add_AT_flag (parm_die, DW_AT_artificial, 1);
8232 equate_decl_number_to_die (node, parm_die);
8233 if (! DECL_ABSTRACT (node))
8234 add_location_or_const_value_attribute (parm_die, node);
8239 /* We were called with some kind of a ..._TYPE node. */
8240 add_type_attribute (parm_die, node, 0, 0, context_die);
8250 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
8251 at the end of an (ANSI prototyped) formal parameters list. */
8254 gen_unspecified_parameters_die (decl_or_type, context_die)
8255 register tree decl_or_type ATTRIBUTE_UNUSED;
8256 register dw_die_ref context_die;
8258 new_die (DW_TAG_unspecified_parameters, context_die);
8261 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
8262 DW_TAG_unspecified_parameters DIE) to represent the types of the formal
8263 parameters as specified in some function type specification (except for
8264 those which appear as part of a function *definition*).
8266 Note we must be careful here to output all of the parameter DIEs before*
8267 we output any DIEs needed to represent the types of the formal parameters.
8268 This keeps svr4 SDB happy because it (incorrectly) thinks that the first
8269 non-parameter DIE it sees ends the formal parameter list. */
8272 gen_formal_types_die (function_or_method_type, context_die)
8273 register tree function_or_method_type;
8274 register dw_die_ref context_die;
8277 register tree formal_type = NULL;
8278 register tree first_parm_type = TYPE_ARG_TYPES (function_or_method_type);
8281 /* In the case where we are generating a formal types list for a C++
8282 non-static member function type, skip over the first thing on the
8283 TYPE_ARG_TYPES list because it only represents the type of the hidden
8284 `this pointer'. The debugger should be able to figure out (without
8285 being explicitly told) that this non-static member function type takes a
8286 `this pointer' and should be able to figure what the type of that hidden
8287 parameter is from the DW_AT_member attribute of the parent
8288 DW_TAG_subroutine_type DIE. */
8289 if (TREE_CODE (function_or_method_type) == METHOD_TYPE)
8290 first_parm_type = TREE_CHAIN (first_parm_type);
8293 /* Make our first pass over the list of formal parameter types and output a
8294 DW_TAG_formal_parameter DIE for each one. */
8295 for (link = first_parm_type; link; link = TREE_CHAIN (link))
8297 register dw_die_ref parm_die;
8299 formal_type = TREE_VALUE (link);
8300 if (formal_type == void_type_node)
8303 /* Output a (nameless) DIE to represent the formal parameter itself. */
8304 parm_die = gen_formal_parameter_die (formal_type, context_die);
8305 if (TREE_CODE (function_or_method_type) == METHOD_TYPE
8306 && link == first_parm_type)
8307 add_AT_flag (parm_die, DW_AT_artificial, 1);
8310 /* If this function type has an ellipsis, add a
8311 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */
8312 if (formal_type != void_type_node)
8313 gen_unspecified_parameters_die (function_or_method_type, context_die);
8315 /* Make our second (and final) pass over the list of formal parameter types
8316 and output DIEs to represent those types (as necessary). */
8317 for (link = TYPE_ARG_TYPES (function_or_method_type);
8319 link = TREE_CHAIN (link))
8321 formal_type = TREE_VALUE (link);
8322 if (formal_type == void_type_node)
8325 gen_type_die (formal_type, context_die);
8329 /* Generate a DIE to represent a declared function (either file-scope or
8333 gen_subprogram_die (decl, context_die)
8335 register dw_die_ref context_die;
8337 char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
8338 register tree origin = decl_ultimate_origin (decl);
8339 register dw_die_ref subr_die;
8340 register rtx fp_reg;
8341 register tree fn_arg_types;
8342 register tree outer_scope;
8343 register dw_die_ref old_die = lookup_decl_die (decl);
8344 register int declaration
8345 = (current_function_decl != decl
8347 && (context_die->die_tag == DW_TAG_structure_type
8348 || context_die->die_tag == DW_TAG_union_type)));
8352 subr_die = new_die (DW_TAG_subprogram, context_die);
8353 add_abstract_origin_attribute (subr_die, origin);
8355 else if (old_die && DECL_ABSTRACT (decl)
8356 && get_AT_unsigned (old_die, DW_AT_inline))
8358 /* This must be a redefinition of an extern inline function.
8359 We can just reuse the old die here. */
8362 /* Clear out the inlined attribute and parm types. */
8363 remove_AT (subr_die, DW_AT_inline);
8364 remove_children (subr_die);
8368 register unsigned file_index
8369 = lookup_filename (DECL_SOURCE_FILE (decl));
8371 if (get_AT_flag (old_die, DW_AT_declaration) != 1)
8373 /* ??? This can happen if there is a bug in the program, for
8374 instance, if it has duplicate function definitions. Ideally,
8375 we should detect this case and ignore it. For now, if we have
8376 already reported an error, any error at all, then assume that
8377 we got here because of a input error, not a dwarf2 bug. */
8383 /* If the definition comes from the same place as the declaration,
8384 maybe use the old DIE. We always want the DIE for this function
8385 that has the *_pc attributes to be under comp_unit_die so the
8386 debugger can find it. For inlines, that is the concrete instance,
8387 so we can use the old DIE here. For non-inline methods, we want a
8388 specification DIE at toplevel, so we need a new DIE. For local
8389 class methods, this does not apply. */
8390 if ((DECL_ABSTRACT (decl) || old_die->die_parent == comp_unit_die
8391 || context_die == NULL)
8392 && get_AT_unsigned (old_die, DW_AT_decl_file) == file_index
8393 && (get_AT_unsigned (old_die, DW_AT_decl_line)
8394 == (unsigned)DECL_SOURCE_LINE (decl)))
8398 /* Clear out the declaration attribute and the parm types. */
8399 remove_AT (subr_die, DW_AT_declaration);
8400 remove_children (subr_die);
8404 subr_die = new_die (DW_TAG_subprogram, context_die);
8405 add_AT_die_ref (subr_die, DW_AT_specification, old_die);
8406 if (get_AT_unsigned (old_die, DW_AT_decl_file) != file_index)
8407 add_AT_unsigned (subr_die, DW_AT_decl_file, file_index);
8408 if (get_AT_unsigned (old_die, DW_AT_decl_line)
8409 != (unsigned)DECL_SOURCE_LINE (decl))
8411 (subr_die, DW_AT_decl_line, DECL_SOURCE_LINE (decl));
8416 register dw_die_ref scope_die;
8418 if (DECL_CONTEXT (decl))
8419 scope_die = scope_die_for (decl, context_die);
8421 /* Don't put block extern declarations under comp_unit_die. */
8422 scope_die = context_die;
8424 subr_die = new_die (DW_TAG_subprogram, scope_die);
8426 if (TREE_PUBLIC (decl))
8427 add_AT_flag (subr_die, DW_AT_external, 1);
8429 add_name_and_src_coords_attributes (subr_die, decl);
8430 if (debug_info_level > DINFO_LEVEL_TERSE)
8432 register tree type = TREE_TYPE (decl);
8434 add_prototyped_attribute (subr_die, type);
8435 add_type_attribute (subr_die, TREE_TYPE (type), 0, 0, context_die);
8438 add_pure_or_virtual_attribute (subr_die, decl);
8439 if (DECL_ARTIFICIAL (decl))
8440 add_AT_flag (subr_die, DW_AT_artificial, 1);
8441 if (TREE_PROTECTED (decl))
8442 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_protected);
8443 else if (TREE_PRIVATE (decl))
8444 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_private);
8449 add_AT_flag (subr_die, DW_AT_declaration, 1);
8451 /* The first time we see a member function, it is in the context of
8452 the class to which it belongs. We make sure of this by emitting
8453 the class first. The next time is the definition, which is
8454 handled above. The two may come from the same source text. */
8455 if (DECL_CONTEXT (decl))
8456 equate_decl_number_to_die (decl, subr_die);
8458 else if (DECL_ABSTRACT (decl))
8460 /* ??? Checking DECL_DEFER_OUTPUT is correct for static inline functions,
8461 but not for extern inline functions. We can't get this completely
8462 correct because information about whether the function was declared
8463 inline is not saved anywhere. */
8464 if (DECL_DEFER_OUTPUT (decl))
8466 if (DECL_INLINE (decl))
8467 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_inlined);
8469 add_AT_unsigned (subr_die, DW_AT_inline,
8470 DW_INL_declared_not_inlined);
8472 else if (DECL_INLINE (decl))
8473 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_inlined);
8477 equate_decl_number_to_die (decl, subr_die);
8479 else if (!DECL_EXTERNAL (decl))
8481 if (origin == NULL_TREE)
8482 equate_decl_number_to_die (decl, subr_die);
8484 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_BEGIN_LABEL,
8485 current_funcdef_number);
8486 add_AT_lbl_id (subr_die, DW_AT_low_pc, label_id);
8487 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
8488 current_funcdef_number);
8489 add_AT_lbl_id (subr_die, DW_AT_high_pc, label_id);
8491 add_pubname (decl, subr_die);
8492 add_arange (decl, subr_die);
8494 #ifdef MIPS_DEBUGGING_INFO
8495 /* Add a reference to the FDE for this routine. */
8496 add_AT_fde_ref (subr_die, DW_AT_MIPS_fde, current_funcdef_fde);
8499 /* Define the "frame base" location for this routine. We use the
8500 frame pointer or stack pointer registers, since the RTL for local
8501 variables is relative to one of them. */
8503 = frame_pointer_needed ? hard_frame_pointer_rtx : stack_pointer_rtx;
8504 add_AT_loc (subr_die, DW_AT_frame_base, reg_loc_descriptor (fp_reg));
8507 /* ??? This fails for nested inline functions, because context_display
8508 is not part of the state saved/restored for inline functions. */
8509 if (current_function_needs_context)
8510 add_AT_location_description (subr_die, DW_AT_static_link,
8511 lookup_static_chain (decl));
8515 /* Now output descriptions of the arguments for this function. This gets
8516 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
8517 for a FUNCTION_DECL doesn't indicate cases where there was a trailing
8518 `...' at the end of the formal parameter list. In order to find out if
8519 there was a trailing ellipsis or not, we must instead look at the type
8520 associated with the FUNCTION_DECL. This will be a node of type
8521 FUNCTION_TYPE. If the chain of type nodes hanging off of this
8522 FUNCTION_TYPE node ends with a void_type_node then there should *not* be
8523 an ellipsis at the end. */
8524 push_decl_scope (decl);
8526 /* In the case where we are describing a mere function declaration, all we
8527 need to do here (and all we *can* do here) is to describe the *types* of
8528 its formal parameters. */
8529 if (debug_info_level <= DINFO_LEVEL_TERSE)
8531 else if (declaration)
8532 gen_formal_types_die (TREE_TYPE (decl), subr_die);
8535 /* Generate DIEs to represent all known formal parameters */
8536 register tree arg_decls = DECL_ARGUMENTS (decl);
8539 /* When generating DIEs, generate the unspecified_parameters DIE
8540 instead if we come across the arg "__builtin_va_alist" */
8541 for (parm = arg_decls; parm; parm = TREE_CHAIN (parm))
8542 if (TREE_CODE (parm) == PARM_DECL)
8544 if (DECL_NAME (parm)
8545 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (parm)),
8546 "__builtin_va_alist"))
8547 gen_unspecified_parameters_die (parm, subr_die);
8549 gen_decl_die (parm, subr_die);
8552 /* Decide whether we need a unspecified_parameters DIE at the end.
8553 There are 2 more cases to do this for: 1) the ansi ... declaration -
8554 this is detectable when the end of the arg list is not a
8555 void_type_node 2) an unprototyped function declaration (not a
8556 definition). This just means that we have no info about the
8557 parameters at all. */
8558 fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
8559 if (fn_arg_types != NULL)
8561 /* this is the prototyped case, check for ... */
8562 if (TREE_VALUE (tree_last (fn_arg_types)) != void_type_node)
8563 gen_unspecified_parameters_die (decl, subr_die);
8565 else if (DECL_INITIAL (decl) == NULL_TREE)
8566 gen_unspecified_parameters_die (decl, subr_die);
8569 /* Output Dwarf info for all of the stuff within the body of the function
8570 (if it has one - it may be just a declaration). */
8571 outer_scope = DECL_INITIAL (decl);
8573 /* Note that here, `outer_scope' is a pointer to the outermost BLOCK
8574 node created to represent a function. This outermost BLOCK actually
8575 represents the outermost binding contour for the function, i.e. the
8576 contour in which the function's formal parameters and labels get
8577 declared. Curiously, it appears that the front end doesn't actually
8578 put the PARM_DECL nodes for the current function onto the BLOCK_VARS
8579 list for this outer scope. (They are strung off of the DECL_ARGUMENTS
8580 list for the function instead.) The BLOCK_VARS list for the
8581 `outer_scope' does provide us with a list of the LABEL_DECL nodes for
8582 the function however, and we output DWARF info for those in
8583 decls_for_scope. Just within the `outer_scope' there will be a BLOCK
8584 node representing the function's outermost pair of curly braces, and
8585 any blocks used for the base and member initializers of a C++
8586 constructor function. */
8587 if (! declaration && TREE_CODE (outer_scope) != ERROR_MARK)
8589 current_function_has_inlines = 0;
8590 decls_for_scope (outer_scope, subr_die, 0);
8592 #if 0 && defined (MIPS_DEBUGGING_INFO)
8593 if (current_function_has_inlines)
8595 add_AT_flag (subr_die, DW_AT_MIPS_has_inlines, 1);
8596 if (! comp_unit_has_inlines)
8598 add_AT_flag (comp_unit_die, DW_AT_MIPS_has_inlines, 1);
8599 comp_unit_has_inlines = 1;
8608 /* Generate a DIE to represent a declared data object. */
8611 gen_variable_die (decl, context_die)
8613 register dw_die_ref context_die;
8615 register tree origin = decl_ultimate_origin (decl);
8616 register dw_die_ref var_die = new_die (DW_TAG_variable, context_die);
8618 dw_die_ref old_die = lookup_decl_die (decl);
8620 = (DECL_EXTERNAL (decl)
8621 || current_function_decl != decl_function_context (decl)
8622 || context_die->die_tag == DW_TAG_structure_type
8623 || context_die->die_tag == DW_TAG_union_type);
8626 add_abstract_origin_attribute (var_die, origin);
8627 /* Loop unrolling can create multiple blocks that refer to the same
8628 static variable, so we must test for the DW_AT_declaration flag. */
8629 /* ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
8630 copy decls and set the DECL_ABSTRACT flag on them instead of
8632 else if (old_die && TREE_STATIC (decl)
8633 && get_AT_flag (old_die, DW_AT_declaration) == 1)
8635 /* ??? This is an instantiation of a C++ class level static. */
8636 add_AT_die_ref (var_die, DW_AT_specification, old_die);
8637 if (DECL_NAME (decl))
8639 register unsigned file_index
8640 = lookup_filename (DECL_SOURCE_FILE (decl));
8642 if (get_AT_unsigned (old_die, DW_AT_decl_file) != file_index)
8643 add_AT_unsigned (var_die, DW_AT_decl_file, file_index);
8645 if (get_AT_unsigned (old_die, DW_AT_decl_line)
8646 != (unsigned)DECL_SOURCE_LINE (decl))
8648 add_AT_unsigned (var_die, DW_AT_decl_line,
8649 DECL_SOURCE_LINE (decl));
8654 add_name_and_src_coords_attributes (var_die, decl);
8655 add_type_attribute (var_die, TREE_TYPE (decl),
8656 TREE_READONLY (decl),
8657 TREE_THIS_VOLATILE (decl), context_die);
8659 if (TREE_PUBLIC (decl))
8660 add_AT_flag (var_die, DW_AT_external, 1);
8662 if (DECL_ARTIFICIAL (decl))
8663 add_AT_flag (var_die, DW_AT_artificial, 1);
8665 if (TREE_PROTECTED (decl))
8666 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_protected);
8668 else if (TREE_PRIVATE (decl))
8669 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_private);
8673 add_AT_flag (var_die, DW_AT_declaration, 1);
8675 if ((declaration && decl_class_context (decl)) || DECL_ABSTRACT (decl))
8676 equate_decl_number_to_die (decl, var_die);
8678 if (! declaration && ! DECL_ABSTRACT (decl))
8680 equate_decl_number_to_die (decl, var_die);
8681 add_location_or_const_value_attribute (var_die, decl);
8682 add_pubname (decl, var_die);
8686 /* Generate a DIE to represent a label identifier. */
8689 gen_label_die (decl, context_die)
8691 register dw_die_ref context_die;
8693 register tree origin = decl_ultimate_origin (decl);
8694 register dw_die_ref lbl_die = new_die (DW_TAG_label, context_die);
8696 char label[MAX_ARTIFICIAL_LABEL_BYTES];
8697 char label2[MAX_ARTIFICIAL_LABEL_BYTES];
8700 add_abstract_origin_attribute (lbl_die, origin);
8702 add_name_and_src_coords_attributes (lbl_die, decl);
8704 if (DECL_ABSTRACT (decl))
8705 equate_decl_number_to_die (decl, lbl_die);
8708 insn = DECL_RTL (decl);
8710 /* Deleted labels are programmer specified labels which have been
8711 eliminated because of various optimisations. We still emit them
8712 here so that it is possible to put breakpoints on them. */
8713 if (GET_CODE (insn) == CODE_LABEL
8714 || ((GET_CODE (insn) == NOTE
8715 && NOTE_LINE_NUMBER (insn) == NOTE_INSN_DELETED_LABEL)))
8717 /* When optimization is enabled (via -O) some parts of the compiler
8718 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
8719 represent source-level labels which were explicitly declared by
8720 the user. This really shouldn't be happening though, so catch
8721 it if it ever does happen. */
8722 if (INSN_DELETED_P (insn))
8725 sprintf (label2, INSN_LABEL_FMT, current_funcdef_number);
8726 ASM_GENERATE_INTERNAL_LABEL (label, label2,
8727 (unsigned) INSN_UID (insn));
8728 add_AT_lbl_id (lbl_die, DW_AT_low_pc, label);
8733 /* Generate a DIE for a lexical block. */
8736 gen_lexical_block_die (stmt, context_die, depth)
8738 register dw_die_ref context_die;
8741 register dw_die_ref stmt_die = new_die (DW_TAG_lexical_block, context_die);
8742 char label[MAX_ARTIFICIAL_LABEL_BYTES];
8744 if (! BLOCK_ABSTRACT (stmt))
8746 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
8748 add_AT_lbl_id (stmt_die, DW_AT_low_pc, label);
8749 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL, next_block_number);
8750 add_AT_lbl_id (stmt_die, DW_AT_high_pc, label);
8753 push_decl_scope (stmt);
8754 decls_for_scope (stmt, stmt_die, depth);
8758 /* Generate a DIE for an inlined subprogram. */
8761 gen_inlined_subroutine_die (stmt, context_die, depth)
8763 register dw_die_ref context_die;
8766 if (! BLOCK_ABSTRACT (stmt))
8768 register dw_die_ref subr_die
8769 = new_die (DW_TAG_inlined_subroutine, context_die);
8770 register tree decl = block_ultimate_origin (stmt);
8771 char label[MAX_ARTIFICIAL_LABEL_BYTES];
8773 add_abstract_origin_attribute (subr_die, decl);
8774 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
8776 add_AT_lbl_id (subr_die, DW_AT_low_pc, label);
8777 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL, next_block_number);
8778 add_AT_lbl_id (subr_die, DW_AT_high_pc, label);
8779 push_decl_scope (decl);
8780 decls_for_scope (stmt, subr_die, depth);
8782 current_function_has_inlines = 1;
8786 /* Generate a DIE for a field in a record, or structure. */
8789 gen_field_die (decl, context_die)
8791 register dw_die_ref context_die;
8793 register dw_die_ref decl_die = new_die (DW_TAG_member, context_die);
8795 add_name_and_src_coords_attributes (decl_die, decl);
8796 add_type_attribute (decl_die, member_declared_type (decl),
8797 TREE_READONLY (decl), TREE_THIS_VOLATILE (decl),
8800 /* If this is a bit field... */
8801 if (DECL_BIT_FIELD_TYPE (decl))
8803 add_byte_size_attribute (decl_die, decl);
8804 add_bit_size_attribute (decl_die, decl);
8805 add_bit_offset_attribute (decl_die, decl);
8808 if (TREE_CODE (DECL_FIELD_CONTEXT (decl)) != UNION_TYPE)
8809 add_data_member_location_attribute (decl_die, decl);
8811 if (DECL_ARTIFICIAL (decl))
8812 add_AT_flag (decl_die, DW_AT_artificial, 1);
8814 if (TREE_PROTECTED (decl))
8815 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_protected);
8817 else if (TREE_PRIVATE (decl))
8818 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_private);
8822 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
8823 Use modified_type_die instead.
8824 We keep this code here just in case these types of DIEs may be needed to
8825 represent certain things in other languages (e.g. Pascal) someday. */
8827 gen_pointer_type_die (type, context_die)
8829 register dw_die_ref context_die;
8831 register dw_die_ref ptr_die
8832 = new_die (DW_TAG_pointer_type, scope_die_for (type, context_die));
8834 equate_type_number_to_die (type, ptr_die);
8835 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
8836 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
8839 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
8840 Use modified_type_die instead.
8841 We keep this code here just in case these types of DIEs may be needed to
8842 represent certain things in other languages (e.g. Pascal) someday. */
8844 gen_reference_type_die (type, context_die)
8846 register dw_die_ref context_die;
8848 register dw_die_ref ref_die
8849 = new_die (DW_TAG_reference_type, scope_die_for (type, context_die));
8851 equate_type_number_to_die (type, ref_die);
8852 add_type_attribute (ref_die, TREE_TYPE (type), 0, 0, context_die);
8853 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
8857 /* Generate a DIE for a pointer to a member type. */
8859 gen_ptr_to_mbr_type_die (type, context_die)
8861 register dw_die_ref context_die;
8863 register dw_die_ref ptr_die
8864 = new_die (DW_TAG_ptr_to_member_type, scope_die_for (type, context_die));
8866 equate_type_number_to_die (type, ptr_die);
8867 add_AT_die_ref (ptr_die, DW_AT_containing_type,
8868 lookup_type_die (TYPE_OFFSET_BASETYPE (type)));
8869 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
8872 /* Generate the DIE for the compilation unit. */
8875 gen_compile_unit_die (main_input_filename)
8876 register char *main_input_filename;
8879 char *wd = getpwd ();
8881 comp_unit_die = new_die (DW_TAG_compile_unit, NULL);
8882 add_name_attribute (comp_unit_die, main_input_filename);
8885 add_AT_string (comp_unit_die, DW_AT_comp_dir, wd);
8887 sprintf (producer, "%s %s", language_string, version_string);
8889 #ifdef MIPS_DEBUGGING_INFO
8890 /* The MIPS/SGI compilers place the 'cc' command line options in the producer
8891 string. The SGI debugger looks for -g, -g1, -g2, or -g3; if they do
8892 not appear in the producer string, the debugger reaches the conclusion
8893 that the object file is stripped and has no debugging information.
8894 To get the MIPS/SGI debugger to believe that there is debugging
8895 information in the object file, we add a -g to the producer string. */
8896 if (debug_info_level > DINFO_LEVEL_TERSE)
8897 strcat (producer, " -g");
8900 add_AT_string (comp_unit_die, DW_AT_producer, producer);
8902 if (strcmp (language_string, "GNU C++") == 0)
8903 add_AT_unsigned (comp_unit_die, DW_AT_language, DW_LANG_C_plus_plus);
8905 else if (strcmp (language_string, "GNU Ada") == 0)
8906 add_AT_unsigned (comp_unit_die, DW_AT_language, DW_LANG_Ada83);
8908 else if (strcmp (language_string, "GNU F77") == 0)
8909 add_AT_unsigned (comp_unit_die, DW_AT_language, DW_LANG_Fortran77);
8911 else if (strcmp (language_string, "GNU Pascal") == 0)
8912 add_AT_unsigned (comp_unit_die, DW_AT_language, DW_LANG_Pascal83);
8914 else if (flag_traditional)
8915 add_AT_unsigned (comp_unit_die, DW_AT_language, DW_LANG_C);
8918 add_AT_unsigned (comp_unit_die, DW_AT_language, DW_LANG_C89);
8920 #if 0 /* unimplemented */
8921 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
8922 add_AT_unsigned (comp_unit_die, DW_AT_macro_info, 0);
8926 /* Generate a DIE for a string type. */
8929 gen_string_type_die (type, context_die)
8931 register dw_die_ref context_die;
8933 register dw_die_ref type_die
8934 = new_die (DW_TAG_string_type, scope_die_for (type, context_die));
8936 equate_type_number_to_die (type, type_die);
8938 /* Fudge the string length attribute for now. */
8940 /* TODO: add string length info.
8941 string_length_attribute (TYPE_MAX_VALUE (TYPE_DOMAIN (type)));
8942 bound_representation (upper_bound, 0, 'u'); */
8945 /* Generate the DIE for a base class. */
8948 gen_inheritance_die (binfo, context_die)
8949 register tree binfo;
8950 register dw_die_ref context_die;
8952 dw_die_ref die = new_die (DW_TAG_inheritance, context_die);
8954 add_type_attribute (die, BINFO_TYPE (binfo), 0, 0, context_die);
8955 add_data_member_location_attribute (die, binfo);
8957 if (TREE_VIA_VIRTUAL (binfo))
8958 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
8959 if (TREE_VIA_PUBLIC (binfo))
8960 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public);
8961 else if (TREE_VIA_PROTECTED (binfo))
8962 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected);
8965 /* Generate a DIE for a class member. */
8968 gen_member_die (type, context_die)
8970 register dw_die_ref context_die;
8972 register tree member;
8974 /* If this is not an incomplete type, output descriptions of each of its
8975 members. Note that as we output the DIEs necessary to represent the
8976 members of this record or union type, we will also be trying to output
8977 DIEs to represent the *types* of those members. However the `type'
8978 function (above) will specifically avoid generating type DIEs for member
8979 types *within* the list of member DIEs for this (containing) type execpt
8980 for those types (of members) which are explicitly marked as also being
8981 members of this (containing) type themselves. The g++ front- end can
8982 force any given type to be treated as a member of some other
8983 (containing) type by setting the TYPE_CONTEXT of the given (member) type
8984 to point to the TREE node representing the appropriate (containing)
8987 /* First output info about the base classes. */
8988 if (TYPE_BINFO (type) && TYPE_BINFO_BASETYPES (type))
8990 register tree bases = TYPE_BINFO_BASETYPES (type);
8991 register int n_bases = TREE_VEC_LENGTH (bases);
8994 for (i = 0; i < n_bases; i++)
8995 gen_inheritance_die (TREE_VEC_ELT (bases, i), context_die);
8998 /* Now output info about the data members and type members. */
8999 for (member = TYPE_FIELDS (type); member; member = TREE_CHAIN (member))
9000 gen_decl_die (member, context_die);
9002 /* Now output info about the function members (if any). */
9003 for (member = TYPE_METHODS (type); member; member = TREE_CHAIN (member))
9004 gen_decl_die (member, context_die);
9007 /* Generate a DIE for a structure or union type. */
9010 gen_struct_or_union_type_die (type, context_die)
9012 register dw_die_ref context_die;
9014 register dw_die_ref type_die = lookup_type_die (type);
9015 register dw_die_ref scope_die = 0;
9016 register int nested = 0;
9018 if (type_die && ! TYPE_SIZE (type))
9021 if (TYPE_CONTEXT (type) != NULL_TREE
9022 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type)))
9025 scope_die = scope_die_for (type, context_die);
9027 if (! type_die || (nested && scope_die == comp_unit_die))
9028 /* First occurrence of type or toplevel definition of nested class. */
9030 register dw_die_ref old_die = type_die;
9032 type_die = new_die (TREE_CODE (type) == RECORD_TYPE
9033 ? DW_TAG_structure_type : DW_TAG_union_type,
9035 equate_type_number_to_die (type, type_die);
9036 add_name_attribute (type_die, type_tag (type));
9038 add_AT_die_ref (type_die, DW_AT_specification, old_die);
9041 remove_AT (type_die, DW_AT_declaration);
9043 /* If we're not in the right context to be defining this type, defer to
9044 avoid tricky recursion. */
9045 if (TYPE_SIZE (type) && decl_scope_depth > 0 && scope_die == comp_unit_die)
9047 add_AT_flag (type_die, DW_AT_declaration, 1);
9050 /* If this type has been completed, then give it a byte_size attribute and
9051 then give a list of members. */
9052 else if (TYPE_SIZE (type))
9054 /* Prevent infinite recursion in cases where the type of some member of
9055 this type is expressed in terms of this type itself. */
9056 TREE_ASM_WRITTEN (type) = 1;
9057 add_byte_size_attribute (type_die, type);
9058 if (TYPE_STUB_DECL (type) != NULL_TREE)
9059 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
9061 /* If the first reference to this type was as the return type of an
9062 inline function, then it may not have a parent. Fix this now. */
9063 if (type_die->die_parent == NULL)
9064 add_child_die (scope_die, type_die);
9066 push_decl_scope (type);
9067 gen_member_die (type, type_die);
9070 /* GNU extension: Record what type our vtable lives in. */
9071 if (TYPE_VFIELD (type))
9073 tree vtype = DECL_FCONTEXT (TYPE_VFIELD (type));
9075 gen_type_die (vtype, context_die);
9076 add_AT_die_ref (type_die, DW_AT_containing_type,
9077 lookup_type_die (vtype));
9082 add_AT_flag (type_die, DW_AT_declaration, 1);
9084 /* We can't do this for function-local types, and we don't need to. */
9085 if (TREE_PERMANENT (type))
9086 add_incomplete_type (type);
9090 /* Generate a DIE for a subroutine _type_. */
9093 gen_subroutine_type_die (type, context_die)
9095 register dw_die_ref context_die;
9097 register tree return_type = TREE_TYPE (type);
9098 register dw_die_ref subr_die
9099 = new_die (DW_TAG_subroutine_type, scope_die_for (type, context_die));
9101 equate_type_number_to_die (type, subr_die);
9102 add_prototyped_attribute (subr_die, type);
9103 add_type_attribute (subr_die, return_type, 0, 0, context_die);
9104 gen_formal_types_die (type, subr_die);
9107 /* Generate a DIE for a type definition */
9110 gen_typedef_die (decl, context_die)
9112 register dw_die_ref context_die;
9114 register dw_die_ref type_die;
9115 register tree origin;
9117 if (TREE_ASM_WRITTEN (decl))
9119 TREE_ASM_WRITTEN (decl) = 1;
9121 type_die = new_die (DW_TAG_typedef, scope_die_for (decl, context_die));
9122 origin = decl_ultimate_origin (decl);
9124 add_abstract_origin_attribute (type_die, origin);
9128 add_name_and_src_coords_attributes (type_die, decl);
9129 if (DECL_ORIGINAL_TYPE (decl))
9131 type = DECL_ORIGINAL_TYPE (decl);
9132 equate_type_number_to_die (TREE_TYPE (decl), type_die);
9135 type = TREE_TYPE (decl);
9136 add_type_attribute (type_die, type, TREE_READONLY (decl),
9137 TREE_THIS_VOLATILE (decl), context_die);
9140 if (DECL_ABSTRACT (decl))
9141 equate_decl_number_to_die (decl, type_die);
9144 /* Generate a type description DIE. */
9147 gen_type_die (type, context_die)
9149 register dw_die_ref context_die;
9151 if (type == NULL_TREE || type == error_mark_node)
9154 /* We are going to output a DIE to represent the unqualified version of
9155 this type (i.e. without any const or volatile qualifiers) so get the
9156 main variant (i.e. the unqualified version) of this type now. */
9157 type = type_main_variant (type);
9159 if (TREE_ASM_WRITTEN (type))
9162 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
9163 && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
9165 TREE_ASM_WRITTEN (type) = 1;
9166 gen_decl_die (TYPE_NAME (type), context_die);
9170 switch (TREE_CODE (type))
9176 case REFERENCE_TYPE:
9177 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This
9178 ensures that the gen_type_die recursion will terminate even if the
9179 type is recursive. Recursive types are possible in Ada. */
9180 /* ??? We could perhaps do this for all types before the switch
9182 TREE_ASM_WRITTEN (type) = 1;
9184 /* For these types, all that is required is that we output a DIE (or a
9185 set of DIEs) to represent the "basis" type. */
9186 gen_type_die (TREE_TYPE (type), context_die);
9190 /* This code is used for C++ pointer-to-data-member types.
9191 Output a description of the relevant class type. */
9192 gen_type_die (TYPE_OFFSET_BASETYPE (type), context_die);
9194 /* Output a description of the type of the object pointed to. */
9195 gen_type_die (TREE_TYPE (type), context_die);
9197 /* Now output a DIE to represent this pointer-to-data-member type
9199 gen_ptr_to_mbr_type_die (type, context_die);
9203 gen_type_die (TYPE_DOMAIN (type), context_die);
9204 gen_set_type_die (type, context_die);
9208 gen_type_die (TREE_TYPE (type), context_die);
9209 abort (); /* No way to represent these in Dwarf yet! */
9213 /* Force out return type (in case it wasn't forced out already). */
9214 gen_type_die (TREE_TYPE (type), context_die);
9215 gen_subroutine_type_die (type, context_die);
9219 /* Force out return type (in case it wasn't forced out already). */
9220 gen_type_die (TREE_TYPE (type), context_die);
9221 gen_subroutine_type_die (type, context_die);
9225 if (TYPE_STRING_FLAG (type) && TREE_CODE (TREE_TYPE (type)) == CHAR_TYPE)
9227 gen_type_die (TREE_TYPE (type), context_die);
9228 gen_string_type_die (type, context_die);
9231 gen_array_type_die (type, context_die);
9237 case QUAL_UNION_TYPE:
9238 /* If this is a nested type whose containing class hasn't been
9239 written out yet, writing it out will cover this one, too. */
9240 if (TYPE_CONTEXT (type)
9241 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
9242 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
9244 gen_type_die (TYPE_CONTEXT (type), context_die);
9246 if (TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
9249 /* If that failed, attach ourselves to the stub. */
9250 push_decl_scope (TYPE_CONTEXT (type));
9251 context_die = lookup_type_die (TYPE_CONTEXT (type));
9254 if (TREE_CODE (type) == ENUMERAL_TYPE)
9255 gen_enumeration_type_die (type, context_die);
9257 gen_struct_or_union_type_die (type, context_die);
9259 if (TYPE_CONTEXT (type)
9260 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
9261 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
9264 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
9265 it up if it is ever completed. gen_*_type_die will set it for us
9266 when appropriate. */
9275 /* No DIEs needed for fundamental types. */
9279 /* No Dwarf representation currently defined. */
9286 TREE_ASM_WRITTEN (type) = 1;
9289 /* Generate a DIE for a tagged type instantiation. */
9292 gen_tagged_type_instantiation_die (type, context_die)
9294 register dw_die_ref context_die;
9296 if (type == NULL_TREE || type == error_mark_node)
9299 /* We are going to output a DIE to represent the unqualified version of
9300 this type (i.e. without any const or volatile qualifiers) so make sure
9301 that we have the main variant (i.e. the unqualified version) of this
9303 if (type != type_main_variant (type)
9304 || !TREE_ASM_WRITTEN (type))
9307 switch (TREE_CODE (type))
9313 gen_inlined_enumeration_type_die (type, context_die);
9317 gen_inlined_structure_type_die (type, context_die);
9321 case QUAL_UNION_TYPE:
9322 gen_inlined_union_type_die (type, context_die);
9330 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
9331 things which are local to the given block. */
9334 gen_block_die (stmt, context_die, depth)
9336 register dw_die_ref context_die;
9339 register int must_output_die = 0;
9340 register tree origin;
9342 register enum tree_code origin_code;
9344 /* Ignore blocks never really used to make RTL. */
9346 if (stmt == NULL_TREE || !TREE_USED (stmt))
9349 /* Determine the "ultimate origin" of this block. This block may be an
9350 inlined instance of an inlined instance of inline function, so we have
9351 to trace all of the way back through the origin chain to find out what
9352 sort of node actually served as the original seed for the creation of
9353 the current block. */
9354 origin = block_ultimate_origin (stmt);
9355 origin_code = (origin != NULL) ? TREE_CODE (origin) : ERROR_MARK;
9357 /* Determine if we need to output any Dwarf DIEs at all to represent this
9359 if (origin_code == FUNCTION_DECL)
9360 /* The outer scopes for inlinings *must* always be represented. We
9361 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */
9362 must_output_die = 1;
9365 /* In the case where the current block represents an inlining of the
9366 "body block" of an inline function, we must *NOT* output any DIE for
9367 this block because we have already output a DIE to represent the
9368 whole inlined function scope and the "body block" of any function
9369 doesn't really represent a different scope according to ANSI C
9370 rules. So we check here to make sure that this block does not
9371 represent a "body block inlining" before trying to set the
9372 `must_output_die' flag. */
9373 if (! is_body_block (origin ? origin : stmt))
9375 /* Determine if this block directly contains any "significant"
9376 local declarations which we will need to output DIEs for. */
9377 if (debug_info_level > DINFO_LEVEL_TERSE)
9378 /* We are not in terse mode so *any* local declaration counts
9379 as being a "significant" one. */
9380 must_output_die = (BLOCK_VARS (stmt) != NULL);
9382 /* We are in terse mode, so only local (nested) function
9383 definitions count as "significant" local declarations. */
9384 for (decl = BLOCK_VARS (stmt);
9385 decl != NULL; decl = TREE_CHAIN (decl))
9386 if (TREE_CODE (decl) == FUNCTION_DECL
9387 && DECL_INITIAL (decl))
9389 must_output_die = 1;
9395 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
9396 DIE for any block which contains no significant local declarations at
9397 all. Rather, in such cases we just call `decls_for_scope' so that any
9398 needed Dwarf info for any sub-blocks will get properly generated. Note
9399 that in terse mode, our definition of what constitutes a "significant"
9400 local declaration gets restricted to include only inlined function
9401 instances and local (nested) function definitions. */
9402 if (must_output_die)
9404 if (origin_code == FUNCTION_DECL)
9405 gen_inlined_subroutine_die (stmt, context_die, depth);
9407 gen_lexical_block_die (stmt, context_die, depth);
9410 decls_for_scope (stmt, context_die, depth);
9413 /* Generate all of the decls declared within a given scope and (recursively)
9414 all of its sub-blocks. */
9417 decls_for_scope (stmt, context_die, depth)
9419 register dw_die_ref context_die;
9423 register tree subblocks;
9425 /* Ignore blocks never really used to make RTL. */
9426 if (stmt == NULL_TREE || ! TREE_USED (stmt))
9429 if (!BLOCK_ABSTRACT (stmt) && depth > 0)
9430 next_block_number++;
9432 /* Output the DIEs to represent all of the data objects and typedefs
9433 declared directly within this block but not within any nested
9434 sub-blocks. Also, nested function and tag DIEs have been
9435 generated with a parent of NULL; fix that up now. */
9436 for (decl = BLOCK_VARS (stmt);
9437 decl != NULL; decl = TREE_CHAIN (decl))
9439 register dw_die_ref die;
9441 if (TREE_CODE (decl) == FUNCTION_DECL)
9442 die = lookup_decl_die (decl);
9443 else if (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl))
9444 die = lookup_type_die (TREE_TYPE (decl));
9448 if (die != NULL && die->die_parent == NULL)
9449 add_child_die (context_die, die);
9451 gen_decl_die (decl, context_die);
9454 /* Output the DIEs to represent all sub-blocks (and the items declared
9455 therein) of this block. */
9456 for (subblocks = BLOCK_SUBBLOCKS (stmt);
9458 subblocks = BLOCK_CHAIN (subblocks))
9459 gen_block_die (subblocks, context_die, depth + 1);
9462 /* Is this a typedef we can avoid emitting? */
9465 is_redundant_typedef (decl)
9468 if (TYPE_DECL_IS_STUB (decl))
9471 if (DECL_ARTIFICIAL (decl)
9472 && DECL_CONTEXT (decl)
9473 && is_tagged_type (DECL_CONTEXT (decl))
9474 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl))) == TYPE_DECL
9475 && DECL_NAME (decl) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))))
9476 /* Also ignore the artificial member typedef for the class name. */
9482 /* Generate Dwarf debug information for a decl described by DECL. */
9485 gen_decl_die (decl, context_die)
9487 register dw_die_ref context_die;
9489 register tree origin;
9491 /* Make a note of the decl node we are going to be working on. We may need
9492 to give the user the source coordinates of where it appeared in case we
9493 notice (later on) that something about it looks screwy. */
9494 dwarf_last_decl = decl;
9496 if (TREE_CODE (decl) == ERROR_MARK)
9499 /* If this ..._DECL node is marked to be ignored, then ignore it. But don't
9500 ignore a function definition, since that would screw up our count of
9501 blocks, and that in turn will completely screw up the labels we will
9502 reference in subsequent DW_AT_low_pc and DW_AT_high_pc attributes (for
9503 subsequent blocks). */
9504 if (DECL_IGNORED_P (decl) && TREE_CODE (decl) != FUNCTION_DECL)
9507 switch (TREE_CODE (decl))
9510 /* The individual enumerators of an enum type get output when we output
9511 the Dwarf representation of the relevant enum type itself. */
9515 /* Don't output any DIEs to represent mere function declarations,
9516 unless they are class members or explicit block externs. */
9517 if (DECL_INITIAL (decl) == NULL_TREE && DECL_CONTEXT (decl) == NULL_TREE
9518 && (current_function_decl == NULL_TREE || ! DECL_ARTIFICIAL (decl)))
9521 if (debug_info_level > DINFO_LEVEL_TERSE)
9523 /* Before we describe the FUNCTION_DECL itself, make sure that we
9524 have described its return type. */
9525 gen_type_die (TREE_TYPE (TREE_TYPE (decl)), context_die);
9527 /* And its containing type. */
9528 origin = decl_class_context (decl);
9529 if (origin != NULL_TREE)
9530 gen_type_die (origin, context_die);
9532 /* And its virtual context. */
9533 if (DECL_VINDEX (decl) != NULL_TREE)
9534 gen_type_die (DECL_CONTEXT (decl), context_die);
9537 /* Now output a DIE to represent the function itself. */
9538 gen_subprogram_die (decl, context_die);
9542 /* If we are in terse mode, don't generate any DIEs to represent any
9544 if (debug_info_level <= DINFO_LEVEL_TERSE)
9547 /* In the special case of a TYPE_DECL node representing the
9548 declaration of some type tag, if the given TYPE_DECL is marked as
9549 having been instantiated from some other (original) TYPE_DECL node
9550 (e.g. one which was generated within the original definition of an
9551 inline function) we have to generate a special (abbreviated)
9552 DW_TAG_structure_type, DW_TAG_union_type, or DW_TAG_enumeration_type
9554 if (TYPE_DECL_IS_STUB (decl) && DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
9556 gen_tagged_type_instantiation_die (TREE_TYPE (decl), context_die);
9560 if (is_redundant_typedef (decl))
9561 gen_type_die (TREE_TYPE (decl), context_die);
9563 /* Output a DIE to represent the typedef itself. */
9564 gen_typedef_die (decl, context_die);
9568 if (debug_info_level >= DINFO_LEVEL_NORMAL)
9569 gen_label_die (decl, context_die);
9573 /* If we are in terse mode, don't generate any DIEs to represent any
9574 variable declarations or definitions. */
9575 if (debug_info_level <= DINFO_LEVEL_TERSE)
9578 /* Output any DIEs that are needed to specify the type of this data
9580 gen_type_die (TREE_TYPE (decl), context_die);
9582 /* And its containing type. */
9583 origin = decl_class_context (decl);
9584 if (origin != NULL_TREE)
9585 gen_type_die (origin, context_die);
9587 /* Now output the DIE to represent the data object itself. This gets
9588 complicated because of the possibility that the VAR_DECL really
9589 represents an inlined instance of a formal parameter for an inline
9591 origin = decl_ultimate_origin (decl);
9592 if (origin != NULL_TREE && TREE_CODE (origin) == PARM_DECL)
9593 gen_formal_parameter_die (decl, context_die);
9595 gen_variable_die (decl, context_die);
9599 /* Ignore the nameless fields that are used to skip bits, but
9600 handle C++ anonymous unions. */
9601 if (DECL_NAME (decl) != NULL_TREE
9602 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE)
9604 gen_type_die (member_declared_type (decl), context_die);
9605 gen_field_die (decl, context_die);
9610 gen_type_die (TREE_TYPE (decl), context_die);
9611 gen_formal_parameter_die (decl, context_die);
9619 /* Write the debugging output for DECL. */
9622 dwarf2out_decl (decl)
9625 register dw_die_ref context_die = comp_unit_die;
9627 if (TREE_CODE (decl) == ERROR_MARK)
9630 /* If this ..._DECL node is marked to be ignored, then ignore it. We gotta
9631 hope that the node in question doesn't represent a function definition.
9632 If it does, then totally ignoring it is bound to screw up our count of
9633 blocks, and that in turn will completely screw up the labels we will
9634 reference in subsequent DW_AT_low_pc and DW_AT_high_pc attributes (for
9635 subsequent blocks). (It's too bad that BLOCK nodes don't carry their
9636 own sequence numbers with them!) */
9637 if (DECL_IGNORED_P (decl))
9639 if (TREE_CODE (decl) == FUNCTION_DECL
9640 && DECL_INITIAL (decl) != NULL)
9646 switch (TREE_CODE (decl))
9649 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration of a
9650 builtin function. Explicit programmer-supplied declarations of
9651 these same functions should NOT be ignored however. */
9652 if (DECL_EXTERNAL (decl) && DECL_FUNCTION_CODE (decl))
9655 /* What we would really like to do here is to filter out all mere
9656 file-scope declarations of file-scope functions which are never
9657 referenced later within this translation unit (and keep all of ones
9658 that *are* referenced later on) but we aren't clairvoyant, so we have
9659 no idea which functions will be referenced in the future (i.e. later
9660 on within the current translation unit). So here we just ignore all
9661 file-scope function declarations which are not also definitions. If
9662 and when the debugger needs to know something about these functions,
9663 it wil have to hunt around and find the DWARF information associated
9664 with the definition of the function. Note that we can't just check
9665 `DECL_EXTERNAL' to find out which FUNCTION_DECL nodes represent
9666 definitions and which ones represent mere declarations. We have to
9667 check `DECL_INITIAL' instead. That's because the C front-end
9668 supports some weird semantics for "extern inline" function
9669 definitions. These can get inlined within the current translation
9670 unit (an thus, we need to generate DWARF info for their abstract
9671 instances so that the DWARF info for the concrete inlined instances
9672 can have something to refer to) but the compiler never generates any
9673 out-of-lines instances of such things (despite the fact that they
9674 *are* definitions). The important point is that the C front-end
9675 marks these "extern inline" functions as DECL_EXTERNAL, but we need
9676 to generate DWARF for them anyway. Note that the C++ front-end also
9677 plays some similar games for inline function definitions appearing
9678 within include files which also contain
9679 `#pragma interface' pragmas. */
9680 if (DECL_INITIAL (decl) == NULL_TREE)
9683 /* If we're a nested function, initially use a parent of NULL; if we're
9684 a plain function, this will be fixed up in decls_for_scope. If
9685 we're a method, it will be ignored, since we already have a DIE. */
9686 if (decl_function_context (decl))
9692 /* Ignore this VAR_DECL if it refers to a file-scope extern data object
9693 declaration and if the declaration was never even referenced from
9694 within this entire compilation unit. We suppress these DIEs in
9695 order to save space in the .debug section (by eliminating entries
9696 which are probably useless). Note that we must not suppress
9697 block-local extern declarations (whether used or not) because that
9698 would screw-up the debugger's name lookup mechanism and cause it to
9699 miss things which really ought to be in scope at a given point. */
9700 if (DECL_EXTERNAL (decl) && !TREE_USED (decl))
9703 /* If we are in terse mode, don't generate any DIEs to represent any
9704 variable declarations or definitions. */
9705 if (debug_info_level <= DINFO_LEVEL_TERSE)
9710 /* Don't bother trying to generate any DIEs to represent any of the
9711 normal built-in types for the language we are compiling. */
9712 if (DECL_SOURCE_LINE (decl) == 0)
9714 /* OK, we need to generate one for `bool' so GDB knows what type
9715 comparisons have. */
9716 if ((get_AT_unsigned (comp_unit_die, DW_AT_language)
9717 == DW_LANG_C_plus_plus)
9718 && TREE_CODE (TREE_TYPE (decl)) == BOOLEAN_TYPE)
9719 modified_type_die (TREE_TYPE (decl), 0, 0, NULL);
9724 /* If we are in terse mode, don't generate any DIEs for types. */
9725 if (debug_info_level <= DINFO_LEVEL_TERSE)
9728 /* If we're a function-scope tag, initially use a parent of NULL;
9729 this will be fixed up in decls_for_scope. */
9730 if (decl_function_context (decl))
9739 gen_decl_die (decl, context_die);
9740 output_pending_types_for_scope (comp_unit_die);
9743 /* Output a marker (i.e. a label) for the beginning of the generated code for
9747 dwarf2out_begin_block (blocknum)
9748 register unsigned blocknum;
9750 function_section (current_function_decl);
9751 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, BLOCK_BEGIN_LABEL, blocknum);
9754 /* Output a marker (i.e. a label) for the end of the generated code for a
9758 dwarf2out_end_block (blocknum)
9759 register unsigned blocknum;
9761 function_section (current_function_decl);
9762 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, BLOCK_END_LABEL, blocknum);
9765 /* Output a marker (i.e. a label) at a point in the assembly code which
9766 corresponds to a given source level label. */
9769 dwarf2out_label (insn)
9772 char label[MAX_ARTIFICIAL_LABEL_BYTES];
9774 if (debug_info_level >= DINFO_LEVEL_NORMAL)
9776 function_section (current_function_decl);
9777 sprintf (label, INSN_LABEL_FMT, current_funcdef_number);
9778 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, label,
9779 (unsigned) INSN_UID (insn));
9783 /* Lookup a filename (in the list of filenames that we know about here in
9784 dwarf2out.c) and return its "index". The index of each (known) filename is
9785 just a unique number which is associated with only that one filename.
9786 We need such numbers for the sake of generating labels
9787 (in the .debug_sfnames section) and references to those
9788 files numbers (in the .debug_srcinfo and.debug_macinfo sections).
9789 If the filename given as an argument is not found in our current list,
9790 add it to the list and assign it the next available unique index number.
9791 In order to speed up searches, we remember the index of the filename
9792 was looked up last. This handles the majority of all searches. */
9795 lookup_filename (file_name)
9798 static unsigned last_file_lookup_index = 0;
9799 register unsigned i;
9801 /* Check to see if the file name that was searched on the previous call
9802 matches this file name. If so, return the index. */
9803 if (last_file_lookup_index != 0)
9804 if (strcmp (file_name, file_table[last_file_lookup_index]) == 0)
9805 return last_file_lookup_index;
9807 /* Didn't match the previous lookup, search the table */
9808 for (i = 1; i < file_table_in_use; ++i)
9809 if (strcmp (file_name, file_table[i]) == 0)
9811 last_file_lookup_index = i;
9815 /* Prepare to add a new table entry by making sure there is enough space in
9816 the table to do so. If not, expand the current table. */
9817 if (file_table_in_use == file_table_allocated)
9819 file_table_allocated += FILE_TABLE_INCREMENT;
9821 = (char **) xrealloc (file_table,
9822 file_table_allocated * sizeof (char *));
9825 /* Add the new entry to the end of the filename table. */
9826 file_table[file_table_in_use] = xstrdup (file_name);
9827 last_file_lookup_index = file_table_in_use++;
9829 return last_file_lookup_index;
9832 /* Output a label to mark the beginning of a source code line entry
9833 and record information relating to this source line, in
9834 'line_info_table' for later output of the .debug_line section. */
9837 dwarf2out_line (filename, line)
9838 register char *filename;
9839 register unsigned line;
9841 if (debug_info_level >= DINFO_LEVEL_NORMAL)
9843 function_section (current_function_decl);
9845 if (DECL_SECTION_NAME (current_function_decl))
9847 register dw_separate_line_info_ref line_info;
9848 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, SEPARATE_LINE_CODE_LABEL,
9849 separate_line_info_table_in_use);
9851 fprintf (asm_out_file, "\t%s line %d", ASM_COMMENT_START, line);
9852 fputc ('\n', asm_out_file);
9854 /* expand the line info table if necessary */
9855 if (separate_line_info_table_in_use
9856 == separate_line_info_table_allocated)
9858 separate_line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
9859 separate_line_info_table
9860 = (dw_separate_line_info_ref)
9861 xrealloc (separate_line_info_table,
9862 separate_line_info_table_allocated
9863 * sizeof (dw_separate_line_info_entry));
9866 /* Add the new entry at the end of the line_info_table. */
9868 = &separate_line_info_table[separate_line_info_table_in_use++];
9869 line_info->dw_file_num = lookup_filename (filename);
9870 line_info->dw_line_num = line;
9871 line_info->function = current_funcdef_number;
9875 register dw_line_info_ref line_info;
9877 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, LINE_CODE_LABEL,
9878 line_info_table_in_use);
9880 fprintf (asm_out_file, "\t%s line %d", ASM_COMMENT_START, line);
9881 fputc ('\n', asm_out_file);
9883 /* Expand the line info table if necessary. */
9884 if (line_info_table_in_use == line_info_table_allocated)
9886 line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
9888 = (dw_line_info_ref)
9889 xrealloc (line_info_table,
9890 (line_info_table_allocated
9891 * sizeof (dw_line_info_entry)));
9894 /* Add the new entry at the end of the line_info_table. */
9895 line_info = &line_info_table[line_info_table_in_use++];
9896 line_info->dw_file_num = lookup_filename (filename);
9897 line_info->dw_line_num = line;
9902 /* Record the beginning of a new source file, for later output
9903 of the .debug_macinfo section. At present, unimplemented. */
9906 dwarf2out_start_source_file (filename)
9907 register char *filename ATTRIBUTE_UNUSED;
9911 /* Record the end of a source file, for later output
9912 of the .debug_macinfo section. At present, unimplemented. */
9915 dwarf2out_end_source_file ()
9919 /* Called from check_newline in c-parse.y. The `buffer' parameter contains
9920 the tail part of the directive line, i.e. the part which is past the
9921 initial whitespace, #, whitespace, directive-name, whitespace part. */
9924 dwarf2out_define (lineno, buffer)
9925 register unsigned lineno ATTRIBUTE_UNUSED;
9926 register char *buffer ATTRIBUTE_UNUSED;
9928 static int initialized = 0;
9931 dwarf2out_start_source_file (primary_filename);
9936 /* Called from check_newline in c-parse.y. The `buffer' parameter contains
9937 the tail part of the directive line, i.e. the part which is past the
9938 initial whitespace, #, whitespace, directive-name, whitespace part. */
9941 dwarf2out_undef (lineno, buffer)
9942 register unsigned lineno ATTRIBUTE_UNUSED;
9943 register char *buffer ATTRIBUTE_UNUSED;
9947 /* Set up for Dwarf output at the start of compilation. */
9950 dwarf2out_init (asm_out_file, main_input_filename)
9951 register FILE *asm_out_file;
9952 register char *main_input_filename;
9954 /* Remember the name of the primary input file. */
9955 primary_filename = main_input_filename;
9957 /* Allocate the initial hunk of the file_table. */
9958 file_table = (char **) xmalloc (FILE_TABLE_INCREMENT * sizeof (char *));
9959 bzero ((char *) file_table, FILE_TABLE_INCREMENT * sizeof (char *));
9960 file_table_allocated = FILE_TABLE_INCREMENT;
9962 /* Skip the first entry - file numbers begin at 1. */
9963 file_table_in_use = 1;
9965 /* Allocate the initial hunk of the decl_die_table. */
9967 = (dw_die_ref *) xmalloc (DECL_DIE_TABLE_INCREMENT * sizeof (dw_die_ref));
9968 bzero ((char *) decl_die_table,
9969 DECL_DIE_TABLE_INCREMENT * sizeof (dw_die_ref));
9970 decl_die_table_allocated = DECL_DIE_TABLE_INCREMENT;
9971 decl_die_table_in_use = 0;
9973 /* Allocate the initial hunk of the decl_scope_table. */
9975 = (decl_scope_node *) xmalloc (DECL_SCOPE_TABLE_INCREMENT
9976 * sizeof (decl_scope_node));
9977 bzero ((char *) decl_scope_table,
9978 DECL_SCOPE_TABLE_INCREMENT * sizeof (decl_scope_node));
9979 decl_scope_table_allocated = DECL_SCOPE_TABLE_INCREMENT;
9980 decl_scope_depth = 0;
9982 /* Allocate the initial hunk of the abbrev_die_table. */
9984 = (dw_die_ref *) xmalloc (ABBREV_DIE_TABLE_INCREMENT
9985 * sizeof (dw_die_ref));
9986 bzero ((char *) abbrev_die_table,
9987 ABBREV_DIE_TABLE_INCREMENT * sizeof (dw_die_ref));
9988 abbrev_die_table_allocated = ABBREV_DIE_TABLE_INCREMENT;
9989 /* Zero-th entry is allocated, but unused */
9990 abbrev_die_table_in_use = 1;
9992 /* Allocate the initial hunk of the line_info_table. */
9994 = (dw_line_info_ref) xmalloc (LINE_INFO_TABLE_INCREMENT
9995 * sizeof (dw_line_info_entry));
9996 bzero ((char *) line_info_table,
9997 LINE_INFO_TABLE_INCREMENT * sizeof (dw_line_info_entry));
9998 line_info_table_allocated = LINE_INFO_TABLE_INCREMENT;
9999 /* Zero-th entry is allocated, but unused */
10000 line_info_table_in_use = 1;
10002 /* Generate the initial DIE for the .debug section. Note that the (string)
10003 value given in the DW_AT_name attribute of the DW_TAG_compile_unit DIE
10004 will (typically) be a relative pathname and that this pathname should be
10005 taken as being relative to the directory from which the compiler was
10006 invoked when the given (base) source file was compiled. */
10007 gen_compile_unit_die (main_input_filename);
10009 ASM_GENERATE_INTERNAL_LABEL (text_end_label, TEXT_END_LABEL, 0);
10010 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label, ABBREV_SECTION_LABEL, 0);
10011 if (DWARF2_GENERATE_TEXT_SECTION_LABEL)
10012 ASM_GENERATE_INTERNAL_LABEL (text_section_label, TEXT_SECTION_LABEL, 0);
10014 strcpy (text_section_label, stripattributes (TEXT_SECTION));
10015 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label,
10016 DEBUG_INFO_SECTION_LABEL, 0);
10017 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label,
10018 DEBUG_LINE_SECTION_LABEL, 0);
10020 ASM_OUTPUT_SECTION (asm_out_file, ABBREV_SECTION);
10021 ASM_OUTPUT_LABEL (asm_out_file, abbrev_section_label);
10022 ASM_OUTPUT_SECTION (asm_out_file, TEXT_SECTION);
10023 if (DWARF2_GENERATE_TEXT_SECTION_LABEL)
10024 ASM_OUTPUT_LABEL (asm_out_file, text_section_label);
10025 ASM_OUTPUT_SECTION (asm_out_file, DEBUG_INFO_SECTION);
10026 ASM_OUTPUT_LABEL (asm_out_file, debug_info_section_label);
10027 ASM_OUTPUT_SECTION (asm_out_file, DEBUG_LINE_SECTION);
10028 ASM_OUTPUT_LABEL (asm_out_file, debug_line_section_label);
10031 /* Output stuff that dwarf requires at the end of every file,
10032 and generate the DWARF-2 debugging info. */
10035 dwarf2out_finish ()
10037 limbo_die_node *node, *next_node;
10041 /* Traverse the limbo die list, and add parent/child links. The only
10042 dies without parents that should be here are concrete instances of
10043 inline functions, and the comp_unit_die. We can ignore the comp_unit_die.
10044 For concrete instances, we can get the parent die from the abstract
10046 for (node = limbo_die_list; node; node = next_node)
10048 next_node = node->next;
10051 if (die->die_parent == NULL)
10053 a = get_AT (die, DW_AT_abstract_origin);
10055 add_child_die (a->dw_attr_val.v.val_die_ref->die_parent, die);
10056 else if (die == comp_unit_die)
10064 /* Walk through the list of incomplete types again, trying once more to
10065 emit full debugging info for them. */
10066 retry_incomplete_types ();
10068 /* Traverse the DIE tree and add sibling attributes to those DIE's
10069 that have children. */
10070 add_sibling_attributes (comp_unit_die);
10072 /* Output a terminator label for the .text section. */
10073 fputc ('\n', asm_out_file);
10074 ASM_OUTPUT_SECTION (asm_out_file, TEXT_SECTION);
10075 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, TEXT_END_LABEL, 0);
10078 /* Output a terminator label for the .data section. */
10079 fputc ('\n', asm_out_file);
10080 ASM_OUTPUT_SECTION (asm_out_file, DATA_SECTION);
10081 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, DATA_END_LABEL, 0);
10083 /* Output a terminator label for the .bss section. */
10084 fputc ('\n', asm_out_file);
10085 ASM_OUTPUT_SECTION (asm_out_file, BSS_SECTION);
10086 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, BSS_END_LABEL, 0);
10089 /* Output the source line correspondence table. */
10090 if (line_info_table_in_use > 1 || separate_line_info_table_in_use)
10092 fputc ('\n', asm_out_file);
10093 ASM_OUTPUT_SECTION (asm_out_file, DEBUG_LINE_SECTION);
10094 output_line_info ();
10096 /* We can only use the low/high_pc attributes if all of the code
10098 if (separate_line_info_table_in_use == 0)
10100 add_AT_lbl_id (comp_unit_die, DW_AT_low_pc, text_section_label);
10101 add_AT_lbl_id (comp_unit_die, DW_AT_high_pc, text_end_label);
10104 add_AT_lbl_offset (comp_unit_die, DW_AT_stmt_list,
10105 debug_line_section_label);
10108 /* Output the abbreviation table. */
10109 fputc ('\n', asm_out_file);
10110 ASM_OUTPUT_SECTION (asm_out_file, ABBREV_SECTION);
10111 build_abbrev_table (comp_unit_die);
10112 output_abbrev_section ();
10114 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
10115 next_die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE;
10116 calc_die_sizes (comp_unit_die);
10118 /* Output debugging information. */
10119 fputc ('\n', asm_out_file);
10120 ASM_OUTPUT_SECTION (asm_out_file, DEBUG_INFO_SECTION);
10121 output_compilation_unit_header ();
10122 output_die (comp_unit_die);
10124 if (pubname_table_in_use)
10126 /* Output public names table. */
10127 fputc ('\n', asm_out_file);
10128 ASM_OUTPUT_SECTION (asm_out_file, PUBNAMES_SECTION);
10129 output_pubnames ();
10132 if (fde_table_in_use)
10134 /* Output the address range information. */
10135 fputc ('\n', asm_out_file);
10136 ASM_OUTPUT_SECTION (asm_out_file, ARANGES_SECTION);
10140 #endif /* DWARF2_DEBUGGING_INFO */