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 /* TODO: Implement .debug_str handling, and share entries somehow.
25 Eliminate duplicates by putting common info in a separate section
26 to be collected by the linker and referring to it with
28 Emit .debug_line header even when there are no functions, since
29 the file numbers are used by .debug_info. Alternately, leave
30 out locations for types and decls.
31 Avoid talking about ctors and op= for PODs.
32 Factor out common prologue sequences into multiple CIEs. */
34 /* The first part of this file deals with the DWARF 2 frame unwind
35 information, which is also used by the GCC efficient exception handling
36 mechanism. The second part, controlled only by an #ifdef
37 DWARF2_DEBUGGING_INFO, deals with the other DWARF 2 debugging
46 #include "hard-reg-set.h"
48 #include "insn-config.h"
54 #include "dwarf2out.h"
56 #include "dyn-string.h"
59 /* We cannot use <assert.h> in GCC source, since that would include
60 GCC's assert.h, which may not be compatible with the host compiler. */
65 # define assert(e) do { if (! (e)) abort (); } while (0)
68 /* Decide whether we want to emit frame unwind information for the current
74 return (write_symbols == DWARF2_DEBUG
75 #ifdef DWARF2_FRAME_INFO
78 #ifdef DWARF2_UNWIND_INFO
80 || (flag_exceptions && ! exceptions_via_longjmp)
85 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
87 /* How to start an assembler comment. */
88 #ifndef ASM_COMMENT_START
89 #define ASM_COMMENT_START ";#"
92 typedef struct dw_cfi_struct *dw_cfi_ref;
93 typedef struct dw_fde_struct *dw_fde_ref;
94 typedef union dw_cfi_oprnd_struct *dw_cfi_oprnd_ref;
96 /* Call frames are described using a sequence of Call Frame
97 Information instructions. The register number, offset
98 and address fields are provided as possible operands;
99 their use is selected by the opcode field. */
101 typedef union dw_cfi_oprnd_struct
103 unsigned long dw_cfi_reg_num;
104 long int dw_cfi_offset;
109 typedef struct dw_cfi_struct
111 dw_cfi_ref dw_cfi_next;
112 enum dwarf_call_frame_info dw_cfi_opc;
113 dw_cfi_oprnd dw_cfi_oprnd1;
114 dw_cfi_oprnd dw_cfi_oprnd2;
118 /* All call frame descriptions (FDE's) in the GCC generated DWARF
119 refer to a single Common Information Entry (CIE), defined at
120 the beginning of the .debug_frame section. This used of a single
121 CIE obviates the need to keep track of multiple CIE's
122 in the DWARF generation routines below. */
124 typedef struct dw_fde_struct
127 char *dw_fde_current_label;
129 dw_cfi_ref dw_fde_cfi;
133 /* Maximum size (in bytes) of an artificially generated label. */
134 #define MAX_ARTIFICIAL_LABEL_BYTES 30
136 /* Make sure we know the sizes of the various types dwarf can describe. These
137 are only defaults. If the sizes are different for your target, you should
138 override these values by defining the appropriate symbols in your tm.h
141 #ifndef CHAR_TYPE_SIZE
142 #define CHAR_TYPE_SIZE BITS_PER_UNIT
145 #define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
148 /* The size in bytes of a DWARF field indicating an offset or length
149 relative to a debug info section, specified to be 4 bytes in the DWARF-2
150 specification. The SGI/MIPS ABI defines it to be the same as PTR_SIZE. */
152 #ifndef DWARF_OFFSET_SIZE
153 #define DWARF_OFFSET_SIZE 4
156 #define DWARF_VERSION 2
158 /* Round SIZE up to the nearest BOUNDARY. */
159 #define DWARF_ROUND(SIZE,BOUNDARY) \
160 (((SIZE) + (BOUNDARY) - 1) & ~((BOUNDARY) - 1))
162 /* Offsets recorded in opcodes are a multiple of this alignment factor. */
163 #ifdef STACK_GROWS_DOWNWARD
164 #define DWARF_CIE_DATA_ALIGNMENT (-UNITS_PER_WORD)
166 #define DWARF_CIE_DATA_ALIGNMENT UNITS_PER_WORD
169 /* A pointer to the base of a table that contains frame description
170 information for each routine. */
171 static dw_fde_ref fde_table;
173 /* Number of elements currently allocated for fde_table. */
174 static unsigned fde_table_allocated;
176 /* Number of elements in fde_table currently in use. */
177 static unsigned fde_table_in_use;
179 /* Size (in elements) of increments by which we may expand the
181 #define FDE_TABLE_INCREMENT 256
183 /* A list of call frame insns for the CIE. */
184 static dw_cfi_ref cie_cfi_head;
186 /* The number of the current function definition for which debugging
187 information is being generated. These numbers range from 1 up to the
188 maximum number of function definitions contained within the current
189 compilation unit. These numbers are used to create unique label id's
190 unique to each function definition. */
191 static unsigned current_funcdef_number = 0;
193 /* Some DWARF extensions (e.g., MIPS/SGI) implement a subprogram
194 attribute that accelerates the lookup of the FDE associated
195 with the subprogram. This variable holds the table index of the FDE
196 associated with the current function (body) definition. */
197 static unsigned current_funcdef_fde;
199 /* Forward declarations for functions defined in this file. */
201 static char *stripattributes PROTO((const char *));
202 static const char *dwarf_cfi_name PROTO((unsigned));
203 static dw_cfi_ref new_cfi PROTO((void));
204 static void add_cfi PROTO((dw_cfi_ref *, dw_cfi_ref));
205 static unsigned long size_of_uleb128 PROTO((unsigned long));
206 static unsigned long size_of_sleb128 PROTO((long));
207 static void output_uleb128 PROTO((unsigned long));
208 static void output_sleb128 PROTO((long));
209 static void add_fde_cfi PROTO((char *, dw_cfi_ref));
210 static void lookup_cfa_1 PROTO((dw_cfi_ref, unsigned long *,
212 static void lookup_cfa PROTO((unsigned long *, long *));
213 static void reg_save PROTO((char *, unsigned, unsigned,
215 static void initial_return_save PROTO((rtx));
216 static void output_cfi PROTO((dw_cfi_ref, dw_fde_ref));
217 static void output_call_frame_info PROTO((int));
218 static unsigned reg_number PROTO((rtx));
219 static void dwarf2out_stack_adjust PROTO((rtx));
220 static void dwarf2out_frame_debug_expr PROTO((rtx, char *));
222 /* Definitions of defaults for assembler-dependent names of various
223 pseudo-ops and section names.
224 Theses may be overridden in the tm.h file (if necessary) for a particular
227 #ifdef OBJECT_FORMAT_ELF
228 #ifndef UNALIGNED_SHORT_ASM_OP
229 #define UNALIGNED_SHORT_ASM_OP ".2byte"
231 #ifndef UNALIGNED_INT_ASM_OP
232 #define UNALIGNED_INT_ASM_OP ".4byte"
234 #ifndef UNALIGNED_DOUBLE_INT_ASM_OP
235 #define UNALIGNED_DOUBLE_INT_ASM_OP ".8byte"
237 #endif /* OBJECT_FORMAT_ELF */
240 #define ASM_BYTE_OP ".byte"
243 /* Data and reference forms for relocatable data. */
244 #define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
245 #define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
247 /* Pseudo-op for defining a new section. */
248 #ifndef SECTION_ASM_OP
249 #define SECTION_ASM_OP ".section"
252 /* The default format used by the ASM_OUTPUT_SECTION macro (see below) to
253 print the SECTION_ASM_OP and the section name. The default here works for
254 almost all svr4 assemblers, except for the sparc, where the section name
255 must be enclosed in double quotes. (See sparcv4.h). */
256 #ifndef SECTION_FORMAT
257 #ifdef PUSHSECTION_FORMAT
258 #define SECTION_FORMAT PUSHSECTION_FORMAT
260 #define SECTION_FORMAT "\t%s\t%s\n"
264 #ifndef FRAME_SECTION
265 #define FRAME_SECTION ".debug_frame"
268 #ifndef FUNC_BEGIN_LABEL
269 #define FUNC_BEGIN_LABEL "LFB"
271 #ifndef FUNC_END_LABEL
272 #define FUNC_END_LABEL "LFE"
274 #define CIE_AFTER_SIZE_LABEL "LSCIE"
275 #define CIE_END_LABEL "LECIE"
276 #define CIE_LENGTH_LABEL "LLCIE"
277 #define FDE_AFTER_SIZE_LABEL "LSFDE"
278 #define FDE_END_LABEL "LEFDE"
279 #define FDE_LENGTH_LABEL "LLFDE"
281 /* Definitions of defaults for various types of primitive assembly language
282 output operations. These may be overridden from within the tm.h file,
283 but typically, that is unnecessary. */
285 #ifndef ASM_OUTPUT_SECTION
286 #define ASM_OUTPUT_SECTION(FILE, SECTION) \
287 fprintf ((FILE), SECTION_FORMAT, SECTION_ASM_OP, SECTION)
290 #ifndef ASM_OUTPUT_DWARF_DATA1
291 #define ASM_OUTPUT_DWARF_DATA1(FILE,VALUE) \
292 fprintf ((FILE), "\t%s\t0x%x", ASM_BYTE_OP, (unsigned) (VALUE))
295 #ifndef ASM_OUTPUT_DWARF_DELTA1
296 #define ASM_OUTPUT_DWARF_DELTA1(FILE,LABEL1,LABEL2) \
297 do { fprintf ((FILE), "\t%s\t", ASM_BYTE_OP); \
298 assemble_name (FILE, LABEL1); \
299 fprintf (FILE, "-"); \
300 assemble_name (FILE, LABEL2); \
304 #ifdef UNALIGNED_INT_ASM_OP
306 #ifndef UNALIGNED_OFFSET_ASM_OP
307 #define UNALIGNED_OFFSET_ASM_OP \
308 (DWARF_OFFSET_SIZE == 8 ? UNALIGNED_DOUBLE_INT_ASM_OP : UNALIGNED_INT_ASM_OP)
311 #ifndef UNALIGNED_WORD_ASM_OP
312 #define UNALIGNED_WORD_ASM_OP \
313 (PTR_SIZE == 8 ? UNALIGNED_DOUBLE_INT_ASM_OP : UNALIGNED_INT_ASM_OP)
316 #ifndef ASM_OUTPUT_DWARF_DELTA2
317 #define ASM_OUTPUT_DWARF_DELTA2(FILE,LABEL1,LABEL2) \
318 do { fprintf ((FILE), "\t%s\t", UNALIGNED_SHORT_ASM_OP); \
319 assemble_name (FILE, LABEL1); \
320 fprintf (FILE, "-"); \
321 assemble_name (FILE, LABEL2); \
325 #ifndef ASM_OUTPUT_DWARF_DELTA4
326 #define ASM_OUTPUT_DWARF_DELTA4(FILE,LABEL1,LABEL2) \
327 do { fprintf ((FILE), "\t%s\t", UNALIGNED_INT_ASM_OP); \
328 assemble_name (FILE, LABEL1); \
329 fprintf (FILE, "-"); \
330 assemble_name (FILE, LABEL2); \
334 #ifndef ASM_OUTPUT_DWARF_DELTA
335 #define ASM_OUTPUT_DWARF_DELTA(FILE,LABEL1,LABEL2) \
336 do { fprintf ((FILE), "\t%s\t", UNALIGNED_OFFSET_ASM_OP); \
337 assemble_name (FILE, LABEL1); \
338 fprintf (FILE, "-"); \
339 assemble_name (FILE, LABEL2); \
343 #ifndef ASM_OUTPUT_DWARF_ADDR_DELTA
344 #define ASM_OUTPUT_DWARF_ADDR_DELTA(FILE,LABEL1,LABEL2) \
345 do { fprintf ((FILE), "\t%s\t", UNALIGNED_WORD_ASM_OP); \
346 assemble_name (FILE, LABEL1); \
347 fprintf (FILE, "-"); \
348 assemble_name (FILE, LABEL2); \
352 #ifndef ASM_OUTPUT_DWARF_ADDR
353 #define ASM_OUTPUT_DWARF_ADDR(FILE,LABEL) \
354 do { fprintf ((FILE), "\t%s\t", UNALIGNED_WORD_ASM_OP); \
355 assemble_name (FILE, LABEL); \
359 /* ??? This macro takes an RTX in dwarfout.c and a string in dwarf2out.c.
360 We resolve the conflict by creating a new macro ASM_OUTPUT_DWARF2_ADDR_CONST
361 for ports that want to support both DWARF1 and DWARF2. This needs a better
362 solution. See also the comments in sparc/sp64-elf.h. */
363 #ifdef ASM_OUTPUT_DWARF2_ADDR_CONST
364 #undef ASM_OUTPUT_DWARF_ADDR_CONST
365 #define ASM_OUTPUT_DWARF_ADDR_CONST(FILE,ADDR) \
366 ASM_OUTPUT_DWARF2_ADDR_CONST (FILE, ADDR)
369 #ifndef ASM_OUTPUT_DWARF_ADDR_CONST
370 #define ASM_OUTPUT_DWARF_ADDR_CONST(FILE,ADDR) \
371 fprintf ((FILE), "\t%s\t%s", UNALIGNED_WORD_ASM_OP, (ADDR))
374 #ifndef ASM_OUTPUT_DWARF_OFFSET4
375 #define ASM_OUTPUT_DWARF_OFFSET4(FILE,LABEL) \
376 do { fprintf ((FILE), "\t%s\t", UNALIGNED_INT_ASM_OP); \
377 assemble_name (FILE, LABEL); \
381 #ifndef ASM_OUTPUT_DWARF_OFFSET
382 #define ASM_OUTPUT_DWARF_OFFSET(FILE,LABEL) \
383 do { fprintf ((FILE), "\t%s\t", UNALIGNED_OFFSET_ASM_OP); \
384 assemble_name (FILE, LABEL); \
388 #ifndef ASM_OUTPUT_DWARF_DATA2
389 #define ASM_OUTPUT_DWARF_DATA2(FILE,VALUE) \
390 fprintf ((FILE), "\t%s\t0x%x", UNALIGNED_SHORT_ASM_OP, (unsigned) (VALUE))
393 #ifndef ASM_OUTPUT_DWARF_DATA4
394 #define ASM_OUTPUT_DWARF_DATA4(FILE,VALUE) \
395 fprintf ((FILE), "\t%s\t0x%x", UNALIGNED_INT_ASM_OP, (unsigned) (VALUE))
398 #ifndef ASM_OUTPUT_DWARF_DATA
399 #define ASM_OUTPUT_DWARF_DATA(FILE,VALUE) \
400 fprintf ((FILE), "\t%s\t0x%lx", UNALIGNED_OFFSET_ASM_OP, \
401 (unsigned long) (VALUE))
404 #ifndef ASM_OUTPUT_DWARF_ADDR_DATA
405 #define ASM_OUTPUT_DWARF_ADDR_DATA(FILE,VALUE) \
406 fprintf ((FILE), "\t%s\t0x%lx", UNALIGNED_WORD_ASM_OP, \
407 (unsigned long) (VALUE))
410 #ifndef ASM_OUTPUT_DWARF_DATA8
411 #define ASM_OUTPUT_DWARF_DATA8(FILE,HIGH_VALUE,LOW_VALUE) \
413 if (WORDS_BIG_ENDIAN) \
415 fprintf ((FILE), "\t%s\t0x%lx\n", UNALIGNED_INT_ASM_OP, (HIGH_VALUE));\
416 fprintf ((FILE), "\t%s\t0x%lx", UNALIGNED_INT_ASM_OP, (LOW_VALUE));\
420 fprintf ((FILE), "\t%s\t0x%lx\n", UNALIGNED_INT_ASM_OP, (LOW_VALUE)); \
421 fprintf ((FILE), "\t%s\t0x%lx", UNALIGNED_INT_ASM_OP, (HIGH_VALUE)); \
426 #else /* UNALIGNED_INT_ASM_OP */
428 /* We don't have unaligned support, let's hope the normal output works for
431 #define ASM_OUTPUT_DWARF_ADDR(FILE,LABEL) \
432 assemble_integer (gen_rtx_SYMBOL_REF (Pmode, LABEL), PTR_SIZE, 1)
434 #define ASM_OUTPUT_DWARF_OFFSET4(FILE,LABEL) \
435 assemble_integer (gen_rtx_SYMBOL_REF (SImode, LABEL), 4, 1)
437 #define ASM_OUTPUT_DWARF_OFFSET(FILE,LABEL) \
438 assemble_integer (gen_rtx_SYMBOL_REF (SImode, LABEL), 4, 1)
440 #define ASM_OUTPUT_DWARF_DELTA2(FILE,LABEL1,LABEL2) \
441 assemble_integer (gen_rtx_MINUS (HImode, \
442 gen_rtx_SYMBOL_REF (Pmode, LABEL1), \
443 gen_rtx_SYMBOL_REF (Pmode, LABEL2)), \
446 #define ASM_OUTPUT_DWARF_DELTA4(FILE,LABEL1,LABEL2) \
447 assemble_integer (gen_rtx_MINUS (SImode, \
448 gen_rtx_SYMBOL_REF (Pmode, LABEL1), \
449 gen_rtx_SYMBOL_REF (Pmode, LABEL2)), \
452 #define ASM_OUTPUT_DWARF_ADDR_DELTA(FILE,LABEL1,LABEL2) \
453 assemble_integer (gen_rtx_MINUS (Pmode, \
454 gen_rtx_SYMBOL_REF (Pmode, LABEL1), \
455 gen_rtx_SYMBOL_REF (Pmode, LABEL2)), \
458 #define ASM_OUTPUT_DWARF_DELTA(FILE,LABEL1,LABEL2) \
459 ASM_OUTPUT_DWARF_DELTA4 (FILE,LABEL1,LABEL2)
461 #define ASM_OUTPUT_DWARF_DATA4(FILE,VALUE) \
462 assemble_integer (GEN_INT (VALUE), 4, 1)
464 #endif /* UNALIGNED_INT_ASM_OP */
467 #ifndef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
468 #define ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL(FILE, SY, HI, LO) \
470 fprintf (FILE, "\t%s\t", SET_ASM_OP); \
471 assemble_name (FILE, SY); \
473 assemble_name (FILE, HI); \
475 assemble_name (FILE, LO); \
478 #endif /* SET_ASM_OP */
480 /* This is similar to the default ASM_OUTPUT_ASCII, except that no trailing
481 newline is produced. When flag_debug_asm is asserted, we add commentary
482 at the end of the line, so we must avoid output of a newline here. */
483 #ifndef ASM_OUTPUT_DWARF_STRING
484 #define ASM_OUTPUT_DWARF_STRING(FILE,P) \
486 register int slen = strlen(P); \
487 register const char *p = (P); \
489 fprintf (FILE, "\t.ascii \""); \
490 for (i = 0; i < slen; i++) \
492 register int c = p[i]; \
493 if (c == '\"' || c == '\\') \
499 fprintf (FILE, "\\%o", c); \
502 fprintf (FILE, "\\0\""); \
507 /* The DWARF 2 CFA column which tracks the return address. Normally this
508 is the column for PC, or the first column after all of the hard
510 #ifndef DWARF_FRAME_RETURN_COLUMN
512 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (PC_REGNUM)
514 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGISTERS
518 /* The mapping from gcc register number to DWARF 2 CFA column number. By
519 default, we just provide columns for all registers. */
520 #ifndef DWARF_FRAME_REGNUM
521 #define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG)
524 /* Hook used by __throw. */
527 expand_builtin_dwarf_fp_regnum ()
529 return GEN_INT (DWARF_FRAME_REGNUM (HARD_FRAME_POINTER_REGNUM));
532 /* The offset from the incoming value of %sp to the top of the stack frame
533 for the current function. */
534 #ifndef INCOMING_FRAME_SP_OFFSET
535 #define INCOMING_FRAME_SP_OFFSET 0
538 /* Return a pointer to a copy of the section string name S with all
539 attributes stripped off, and an asterisk prepended (for assemble_name). */
545 char *stripped = xmalloc (strlen (s) + 2);
550 while (*s && *s != ',')
557 /* Return the register number described by a given RTL node. */
563 register unsigned regno = REGNO (rtl);
565 if (regno >= DWARF_FRAME_REGISTERS)
567 warning ("internal regno botch: regno = %d\n", regno);
571 regno = DBX_REGISTER_NUMBER (regno);
575 /* Generate code to initialize the register size table. */
578 expand_builtin_init_dwarf_reg_sizes (address)
582 enum machine_mode mode = TYPE_MODE (char_type_node);
583 rtx addr = expand_expr (address, NULL_RTX, VOIDmode, 0);
584 rtx mem = gen_rtx_MEM (mode, addr);
586 for (i = 0; i < DWARF_FRAME_REGISTERS; ++i)
588 int offset = i * GET_MODE_SIZE (mode);
589 int size = GET_MODE_SIZE (reg_raw_mode[i]);
591 emit_move_insn (change_address (mem, mode,
592 plus_constant (addr, offset)),
597 /* Convert a DWARF call frame info. operation to its string name */
600 dwarf_cfi_name (cfi_opc)
601 register unsigned cfi_opc;
605 case DW_CFA_advance_loc:
606 return "DW_CFA_advance_loc";
608 return "DW_CFA_offset";
610 return "DW_CFA_restore";
614 return "DW_CFA_set_loc";
615 case DW_CFA_advance_loc1:
616 return "DW_CFA_advance_loc1";
617 case DW_CFA_advance_loc2:
618 return "DW_CFA_advance_loc2";
619 case DW_CFA_advance_loc4:
620 return "DW_CFA_advance_loc4";
621 case DW_CFA_offset_extended:
622 return "DW_CFA_offset_extended";
623 case DW_CFA_restore_extended:
624 return "DW_CFA_restore_extended";
625 case DW_CFA_undefined:
626 return "DW_CFA_undefined";
627 case DW_CFA_same_value:
628 return "DW_CFA_same_value";
629 case DW_CFA_register:
630 return "DW_CFA_register";
631 case DW_CFA_remember_state:
632 return "DW_CFA_remember_state";
633 case DW_CFA_restore_state:
634 return "DW_CFA_restore_state";
636 return "DW_CFA_def_cfa";
637 case DW_CFA_def_cfa_register:
638 return "DW_CFA_def_cfa_register";
639 case DW_CFA_def_cfa_offset:
640 return "DW_CFA_def_cfa_offset";
642 /* SGI/MIPS specific */
643 case DW_CFA_MIPS_advance_loc8:
644 return "DW_CFA_MIPS_advance_loc8";
647 case DW_CFA_GNU_window_save:
648 return "DW_CFA_GNU_window_save";
649 case DW_CFA_GNU_args_size:
650 return "DW_CFA_GNU_args_size";
653 return "DW_CFA_<unknown>";
657 /* Return a pointer to a newly allocated Call Frame Instruction. */
659 static inline dw_cfi_ref
662 register dw_cfi_ref cfi = (dw_cfi_ref) xmalloc (sizeof (dw_cfi_node));
664 cfi->dw_cfi_next = NULL;
665 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = 0;
666 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = 0;
671 /* Add a Call Frame Instruction to list of instructions. */
674 add_cfi (list_head, cfi)
675 register dw_cfi_ref *list_head;
676 register dw_cfi_ref cfi;
678 register dw_cfi_ref *p;
680 /* Find the end of the chain. */
681 for (p = list_head; (*p) != NULL; p = &(*p)->dw_cfi_next)
687 /* Generate a new label for the CFI info to refer to. */
690 dwarf2out_cfi_label ()
692 static char label[20];
693 static unsigned long label_num = 0;
695 ASM_GENERATE_INTERNAL_LABEL (label, "LCFI", label_num++);
696 ASM_OUTPUT_LABEL (asm_out_file, label);
701 /* Add CFI to the current fde at the PC value indicated by LABEL if specified,
702 or to the CIE if LABEL is NULL. */
705 add_fde_cfi (label, cfi)
706 register char *label;
707 register dw_cfi_ref cfi;
711 register dw_fde_ref fde = &fde_table[fde_table_in_use - 1];
714 label = dwarf2out_cfi_label ();
716 if (fde->dw_fde_current_label == NULL
717 || strcmp (label, fde->dw_fde_current_label) != 0)
719 register dw_cfi_ref xcfi;
721 fde->dw_fde_current_label = label = xstrdup (label);
723 /* Set the location counter to the new label. */
725 xcfi->dw_cfi_opc = DW_CFA_advance_loc4;
726 xcfi->dw_cfi_oprnd1.dw_cfi_addr = label;
727 add_cfi (&fde->dw_fde_cfi, xcfi);
730 add_cfi (&fde->dw_fde_cfi, cfi);
734 add_cfi (&cie_cfi_head, cfi);
737 /* Subroutine of lookup_cfa. */
740 lookup_cfa_1 (cfi, regp, offsetp)
741 register dw_cfi_ref cfi;
742 register unsigned long *regp;
743 register long *offsetp;
745 switch (cfi->dw_cfi_opc)
747 case DW_CFA_def_cfa_offset:
748 *offsetp = cfi->dw_cfi_oprnd1.dw_cfi_offset;
750 case DW_CFA_def_cfa_register:
751 *regp = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
754 *regp = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
755 *offsetp = cfi->dw_cfi_oprnd2.dw_cfi_offset;
762 /* Find the previous value for the CFA. */
765 lookup_cfa (regp, offsetp)
766 register unsigned long *regp;
767 register long *offsetp;
769 register dw_cfi_ref cfi;
771 *regp = (unsigned long) -1;
774 for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
775 lookup_cfa_1 (cfi, regp, offsetp);
777 if (fde_table_in_use)
779 register dw_fde_ref fde = &fde_table[fde_table_in_use - 1];
780 for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
781 lookup_cfa_1 (cfi, regp, offsetp);
785 /* The current rule for calculating the DWARF2 canonical frame address. */
786 static unsigned long cfa_reg;
787 static long cfa_offset;
789 /* The register used for saving registers to the stack, and its offset
791 static unsigned cfa_store_reg;
792 static long cfa_store_offset;
794 /* The running total of the size of arguments pushed onto the stack. */
795 static long args_size;
797 /* The last args_size we actually output. */
798 static long old_args_size;
800 /* Entry point to update the canonical frame address (CFA).
801 LABEL is passed to add_fde_cfi. The value of CFA is now to be
802 calculated from REG+OFFSET. */
805 dwarf2out_def_cfa (label, reg, offset)
806 register char *label;
807 register unsigned reg;
808 register long offset;
810 register dw_cfi_ref cfi;
811 unsigned long old_reg;
816 if (cfa_store_reg == reg)
817 cfa_store_offset = offset;
819 reg = DWARF_FRAME_REGNUM (reg);
820 lookup_cfa (&old_reg, &old_offset);
822 if (reg == old_reg && offset == old_offset)
829 cfi->dw_cfi_opc = DW_CFA_def_cfa_offset;
830 cfi->dw_cfi_oprnd1.dw_cfi_offset = offset;
833 #ifndef MIPS_DEBUGGING_INFO /* SGI dbx thinks this means no offset. */
834 else if (offset == old_offset && old_reg != (unsigned long) -1)
836 cfi->dw_cfi_opc = DW_CFA_def_cfa_register;
837 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
843 cfi->dw_cfi_opc = DW_CFA_def_cfa;
844 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
845 cfi->dw_cfi_oprnd2.dw_cfi_offset = offset;
848 add_fde_cfi (label, cfi);
851 /* Add the CFI for saving a register. REG is the CFA column number.
852 LABEL is passed to add_fde_cfi.
853 If SREG is -1, the register is saved at OFFSET from the CFA;
854 otherwise it is saved in SREG. */
857 reg_save (label, reg, sreg, offset)
858 register char * label;
859 register unsigned reg;
860 register unsigned sreg;
861 register long offset;
863 register dw_cfi_ref cfi = new_cfi ();
865 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
867 /* The following comparison is correct. -1 is used to indicate that
868 the value isn't a register number. */
869 if (sreg == (unsigned int) -1)
872 /* The register number won't fit in 6 bits, so we have to use
874 cfi->dw_cfi_opc = DW_CFA_offset_extended;
876 cfi->dw_cfi_opc = DW_CFA_offset;
878 offset /= DWARF_CIE_DATA_ALIGNMENT;
881 cfi->dw_cfi_oprnd2.dw_cfi_offset = offset;
885 cfi->dw_cfi_opc = DW_CFA_register;
886 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = sreg;
889 add_fde_cfi (label, cfi);
892 /* Add the CFI for saving a register window. LABEL is passed to reg_save.
893 This CFI tells the unwinder that it needs to restore the window registers
894 from the previous frame's window save area.
896 ??? Perhaps we should note in the CIE where windows are saved (instead of
897 assuming 0(cfa)) and what registers are in the window. */
900 dwarf2out_window_save (label)
901 register char * label;
903 register dw_cfi_ref cfi = new_cfi ();
904 cfi->dw_cfi_opc = DW_CFA_GNU_window_save;
905 add_fde_cfi (label, cfi);
908 /* Add a CFI to update the running total of the size of arguments
909 pushed onto the stack. */
912 dwarf2out_args_size (label, size)
916 register dw_cfi_ref cfi;
918 if (size == old_args_size)
920 old_args_size = size;
923 cfi->dw_cfi_opc = DW_CFA_GNU_args_size;
924 cfi->dw_cfi_oprnd1.dw_cfi_offset = size;
925 add_fde_cfi (label, cfi);
928 /* Entry point for saving a register to the stack. REG is the GCC register
929 number. LABEL and OFFSET are passed to reg_save. */
932 dwarf2out_reg_save (label, reg, offset)
933 register char * label;
934 register unsigned reg;
935 register long offset;
937 reg_save (label, DWARF_FRAME_REGNUM (reg), -1, offset);
940 /* Entry point for saving the return address in the stack.
941 LABEL and OFFSET are passed to reg_save. */
944 dwarf2out_return_save (label, offset)
945 register char * label;
946 register long offset;
948 reg_save (label, DWARF_FRAME_RETURN_COLUMN, -1, offset);
951 /* Entry point for saving the return address in a register.
952 LABEL and SREG are passed to reg_save. */
955 dwarf2out_return_reg (label, sreg)
956 register char * label;
957 register unsigned sreg;
959 reg_save (label, DWARF_FRAME_RETURN_COLUMN, sreg, 0);
962 /* Record the initial position of the return address. RTL is
963 INCOMING_RETURN_ADDR_RTX. */
966 initial_return_save (rtl)
969 unsigned int reg = (unsigned int) -1;
972 switch (GET_CODE (rtl))
975 /* RA is in a register. */
976 reg = reg_number (rtl);
979 /* RA is on the stack. */
981 switch (GET_CODE (rtl))
984 if (REGNO (rtl) != STACK_POINTER_REGNUM)
989 if (REGNO (XEXP (rtl, 0)) != STACK_POINTER_REGNUM)
991 offset = INTVAL (XEXP (rtl, 1));
994 if (REGNO (XEXP (rtl, 0)) != STACK_POINTER_REGNUM)
996 offset = -INTVAL (XEXP (rtl, 1));
1003 /* The return address is at some offset from any value we can
1004 actually load. For instance, on the SPARC it is in %i7+8. Just
1005 ignore the offset for now; it doesn't matter for unwinding frames. */
1006 if (GET_CODE (XEXP (rtl, 1)) != CONST_INT)
1008 initial_return_save (XEXP (rtl, 0));
1014 reg_save (NULL, DWARF_FRAME_RETURN_COLUMN, reg, offset - cfa_offset);
1017 /* Check INSN to see if it looks like a push or a stack adjustment, and
1018 make a note of it if it does. EH uses this information to find out how
1019 much extra space it needs to pop off the stack. */
1022 dwarf2out_stack_adjust (insn)
1028 if (! asynchronous_exceptions && GET_CODE (insn) == CALL_INSN)
1030 /* Extract the size of the args from the CALL rtx itself. */
1032 insn = PATTERN (insn);
1033 if (GET_CODE (insn) == PARALLEL)
1034 insn = XVECEXP (insn, 0, 0);
1035 if (GET_CODE (insn) == SET)
1036 insn = SET_SRC (insn);
1037 assert (GET_CODE (insn) == CALL);
1038 dwarf2out_args_size ("", INTVAL (XEXP (insn, 1)));
1042 /* If only calls can throw, and we have a frame pointer,
1043 save up adjustments until we see the CALL_INSN. */
1044 else if (! asynchronous_exceptions
1045 && cfa_reg != STACK_POINTER_REGNUM)
1048 if (GET_CODE (insn) == BARRIER)
1050 /* When we see a BARRIER, we know to reset args_size to 0. Usually
1051 the compiler will have already emitted a stack adjustment, but
1052 doesn't bother for calls to noreturn functions. */
1053 #ifdef STACK_GROWS_DOWNWARD
1054 offset = -args_size;
1059 else if (GET_CODE (PATTERN (insn)) == SET)
1064 insn = PATTERN (insn);
1065 src = SET_SRC (insn);
1066 dest = SET_DEST (insn);
1068 if (dest == stack_pointer_rtx)
1070 /* (set (reg sp) (plus (reg sp) (const_int))) */
1071 code = GET_CODE (src);
1072 if (! (code == PLUS || code == MINUS)
1073 || XEXP (src, 0) != stack_pointer_rtx
1074 || GET_CODE (XEXP (src, 1)) != CONST_INT)
1077 offset = INTVAL (XEXP (src, 1));
1079 else if (GET_CODE (dest) == MEM)
1081 /* (set (mem (pre_dec (reg sp))) (foo)) */
1082 src = XEXP (dest, 0);
1083 code = GET_CODE (src);
1085 if (! (code == PRE_DEC || code == PRE_INC)
1086 || XEXP (src, 0) != stack_pointer_rtx)
1089 offset = GET_MODE_SIZE (GET_MODE (dest));
1094 if (code == PLUS || code == PRE_INC)
1103 if (cfa_reg == STACK_POINTER_REGNUM)
1104 cfa_offset += offset;
1106 #ifndef STACK_GROWS_DOWNWARD
1109 args_size += offset;
1113 label = dwarf2out_cfi_label ();
1114 dwarf2out_def_cfa (label, cfa_reg, cfa_offset);
1115 dwarf2out_args_size (label, args_size);
1118 /* A temporary register used in adjusting SP or setting up the store_reg. */
1119 static unsigned cfa_temp_reg;
1121 /* A temporary value used in adjusting SP or setting up the store_reg. */
1122 static long cfa_temp_value;
1124 /* Record call frame debugging information for an expression, which either
1125 sets SP or FP (adjusting how we calculate the frame address) or saves a
1126 register to the stack. */
1129 dwarf2out_frame_debug_expr (expr, label)
1136 /* If RTX_FRAME_RELATED_P is set on a PARALLEL, process each member of
1137 the PARALLEL independantly. The first element is always processed if
1138 it is a SET. This is for backward compatability. Other elements
1139 are processed only if they are SETs and the RTX_FRAME_RELATED_P
1140 flag is set in them. */
1142 if (GET_CODE (expr) == PARALLEL)
1145 int limit = XVECLEN (expr, 0);
1147 for (par_index = 0; par_index < limit; par_index++)
1149 rtx x = XVECEXP (expr, 0, par_index);
1151 if (GET_CODE (x) == SET &&
1152 (RTX_FRAME_RELATED_P (x) || par_index == 0))
1153 dwarf2out_frame_debug_expr (x, label);
1158 if (GET_CODE (expr) != SET)
1161 src = SET_SRC (expr);
1162 dest = SET_DEST (expr);
1164 switch (GET_CODE (dest))
1167 /* Update the CFA rule wrt SP or FP. Make sure src is
1168 relative to the current CFA register. */
1169 switch (GET_CODE (src))
1171 /* Setting FP from SP. */
1173 if (cfa_reg != (unsigned) REGNO (src))
1175 if (REGNO (dest) != STACK_POINTER_REGNUM
1176 && !(frame_pointer_needed
1177 && REGNO (dest) == HARD_FRAME_POINTER_REGNUM))
1179 cfa_reg = REGNO (dest);
1184 if (dest == stack_pointer_rtx)
1187 switch (GET_CODE (XEXP (src, 1)))
1190 offset = INTVAL (XEXP (src, 1));
1193 if ((unsigned) REGNO (XEXP (src, 1)) != cfa_temp_reg)
1195 offset = cfa_temp_value;
1201 if (XEXP (src, 0) == hard_frame_pointer_rtx)
1203 /* Restoring SP from FP in the epilogue. */
1204 if (cfa_reg != (unsigned) HARD_FRAME_POINTER_REGNUM)
1206 cfa_reg = STACK_POINTER_REGNUM;
1208 else if (XEXP (src, 0) != stack_pointer_rtx)
1211 if (GET_CODE (src) == PLUS)
1213 if (cfa_reg == STACK_POINTER_REGNUM)
1214 cfa_offset += offset;
1215 if (cfa_store_reg == STACK_POINTER_REGNUM)
1216 cfa_store_offset += offset;
1218 else if (dest == hard_frame_pointer_rtx)
1220 /* Either setting the FP from an offset of the SP,
1221 or adjusting the FP */
1222 if (! frame_pointer_needed
1223 || REGNO (dest) != HARD_FRAME_POINTER_REGNUM)
1226 if (XEXP (src, 0) == stack_pointer_rtx
1227 && GET_CODE (XEXP (src, 1)) == CONST_INT)
1229 if (cfa_reg != STACK_POINTER_REGNUM)
1231 offset = INTVAL (XEXP (src, 1));
1232 if (GET_CODE (src) == PLUS)
1234 cfa_offset += offset;
1235 cfa_reg = HARD_FRAME_POINTER_REGNUM;
1237 else if (XEXP (src, 0) == hard_frame_pointer_rtx
1238 && GET_CODE (XEXP (src, 1)) == CONST_INT)
1240 if (cfa_reg != (unsigned) HARD_FRAME_POINTER_REGNUM)
1242 offset = INTVAL (XEXP (src, 1));
1243 if (GET_CODE (src) == PLUS)
1245 cfa_offset += offset;
1253 if (GET_CODE (src) != PLUS
1254 || XEXP (src, 1) != stack_pointer_rtx)
1256 if (GET_CODE (XEXP (src, 0)) != REG
1257 || (unsigned) REGNO (XEXP (src, 0)) != cfa_temp_reg)
1259 if (cfa_reg != STACK_POINTER_REGNUM)
1261 cfa_store_reg = REGNO (dest);
1262 cfa_store_offset = cfa_offset - cfa_temp_value;
1267 cfa_temp_reg = REGNO (dest);
1268 cfa_temp_value = INTVAL (src);
1272 if (GET_CODE (XEXP (src, 0)) != REG
1273 || (unsigned) REGNO (XEXP (src, 0)) != cfa_temp_reg
1274 || (unsigned) REGNO (dest) != cfa_temp_reg
1275 || GET_CODE (XEXP (src, 1)) != CONST_INT)
1277 cfa_temp_value |= INTVAL (XEXP (src, 1));
1283 dwarf2out_def_cfa (label, cfa_reg, cfa_offset);
1287 /* Saving a register to the stack. Make sure dest is relative to the
1289 if (GET_CODE (src) != REG)
1291 switch (GET_CODE (XEXP (dest, 0)))
1296 offset = GET_MODE_SIZE (GET_MODE (dest));
1297 if (GET_CODE (XEXP (dest, 0)) == PRE_INC)
1300 if (REGNO (XEXP (XEXP (dest, 0), 0)) != STACK_POINTER_REGNUM
1301 || cfa_store_reg != STACK_POINTER_REGNUM)
1303 cfa_store_offset += offset;
1304 if (cfa_reg == STACK_POINTER_REGNUM)
1305 cfa_offset = cfa_store_offset;
1307 offset = -cfa_store_offset;
1310 /* With an offset. */
1313 offset = INTVAL (XEXP (XEXP (dest, 0), 1));
1314 if (GET_CODE (XEXP (dest, 0)) == MINUS)
1317 if (cfa_store_reg != (unsigned) REGNO (XEXP (XEXP (dest, 0), 0)))
1319 offset -= cfa_store_offset;
1322 /* Without an offset. */
1324 if (cfa_store_reg != (unsigned) REGNO (XEXP (dest, 0)))
1326 offset = -cfa_store_offset;
1332 dwarf2out_def_cfa (label, cfa_reg, cfa_offset);
1333 dwarf2out_reg_save (label, REGNO (src), offset);
1342 /* Record call frame debugging information for INSN, which either
1343 sets SP or FP (adjusting how we calculate the frame address) or saves a
1344 register to the stack. If INSN is NULL_RTX, initialize our state. */
1347 dwarf2out_frame_debug (insn)
1353 if (insn == NULL_RTX)
1355 /* Set up state for generating call frame debug info. */
1356 lookup_cfa (&cfa_reg, &cfa_offset);
1357 if (cfa_reg != DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM))
1359 cfa_reg = STACK_POINTER_REGNUM;
1360 cfa_store_reg = cfa_reg;
1361 cfa_store_offset = cfa_offset;
1367 if (! RTX_FRAME_RELATED_P (insn))
1369 dwarf2out_stack_adjust (insn);
1373 label = dwarf2out_cfi_label ();
1375 src = find_reg_note (insn, REG_FRAME_RELATED_EXPR, NULL_RTX);
1377 insn = XEXP (src, 0);
1379 insn = PATTERN (insn);
1381 dwarf2out_frame_debug_expr (insn, label);
1384 /* Return the size of an unsigned LEB128 quantity. */
1386 static inline unsigned long
1387 size_of_uleb128 (value)
1388 register unsigned long value;
1390 register unsigned long size = 0;
1391 register unsigned byte;
1395 byte = (value & 0x7f);
1404 /* Return the size of a signed LEB128 quantity. */
1406 static inline unsigned long
1407 size_of_sleb128 (value)
1408 register long value;
1410 register unsigned long size = 0;
1411 register unsigned byte;
1415 byte = (value & 0x7f);
1419 while (!(((value == 0) && ((byte & 0x40) == 0))
1420 || ((value == -1) && ((byte & 0x40) != 0))));
1425 /* Output an unsigned LEB128 quantity. */
1428 output_uleb128 (value)
1429 register unsigned long value;
1431 unsigned long save_value = value;
1433 fprintf (asm_out_file, "\t%s\t", ASM_BYTE_OP);
1436 register unsigned byte = (value & 0x7f);
1439 /* More bytes to follow. */
1442 fprintf (asm_out_file, "0x%x", byte);
1444 fprintf (asm_out_file, ",");
1449 fprintf (asm_out_file, "\t%s ULEB128 0x%lx", ASM_COMMENT_START, save_value);
1452 /* Output an signed LEB128 quantity. */
1455 output_sleb128 (value)
1456 register long value;
1459 register unsigned byte;
1460 long save_value = value;
1462 fprintf (asm_out_file, "\t%s\t", ASM_BYTE_OP);
1465 byte = (value & 0x7f);
1466 /* arithmetic shift */
1468 more = !((((value == 0) && ((byte & 0x40) == 0))
1469 || ((value == -1) && ((byte & 0x40) != 0))));
1473 fprintf (asm_out_file, "0x%x", byte);
1475 fprintf (asm_out_file, ",");
1480 fprintf (asm_out_file, "\t%s SLEB128 %ld", ASM_COMMENT_START, save_value);
1483 /* Output a Call Frame Information opcode and its operand(s). */
1486 output_cfi (cfi, fde)
1487 register dw_cfi_ref cfi;
1488 register dw_fde_ref fde;
1490 if (cfi->dw_cfi_opc == DW_CFA_advance_loc)
1492 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
1494 | (cfi->dw_cfi_oprnd1.dw_cfi_offset & 0x3f));
1496 fprintf (asm_out_file, "\t%s DW_CFA_advance_loc 0x%lx",
1497 ASM_COMMENT_START, cfi->dw_cfi_oprnd1.dw_cfi_offset);
1498 fputc ('\n', asm_out_file);
1501 else if (cfi->dw_cfi_opc == DW_CFA_offset)
1503 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
1505 | (cfi->dw_cfi_oprnd1.dw_cfi_reg_num & 0x3f));
1507 fprintf (asm_out_file, "\t%s DW_CFA_offset, column 0x%lx",
1508 ASM_COMMENT_START, cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
1510 fputc ('\n', asm_out_file);
1511 output_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset);
1512 fputc ('\n', asm_out_file);
1514 else if (cfi->dw_cfi_opc == DW_CFA_restore)
1516 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
1518 | (cfi->dw_cfi_oprnd1.dw_cfi_reg_num & 0x3f));
1520 fprintf (asm_out_file, "\t%s DW_CFA_restore, column 0x%lx",
1521 ASM_COMMENT_START, cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
1523 fputc ('\n', asm_out_file);
1527 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, cfi->dw_cfi_opc);
1529 fprintf (asm_out_file, "\t%s %s", ASM_COMMENT_START,
1530 dwarf_cfi_name (cfi->dw_cfi_opc));
1532 fputc ('\n', asm_out_file);
1533 switch (cfi->dw_cfi_opc)
1535 case DW_CFA_set_loc:
1536 ASM_OUTPUT_DWARF_ADDR (asm_out_file, cfi->dw_cfi_oprnd1.dw_cfi_addr);
1537 fputc ('\n', asm_out_file);
1539 case DW_CFA_advance_loc1:
1540 ASM_OUTPUT_DWARF_DELTA1 (asm_out_file,
1541 cfi->dw_cfi_oprnd1.dw_cfi_addr,
1542 fde->dw_fde_current_label);
1543 fputc ('\n', asm_out_file);
1544 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
1546 case DW_CFA_advance_loc2:
1547 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file,
1548 cfi->dw_cfi_oprnd1.dw_cfi_addr,
1549 fde->dw_fde_current_label);
1550 fputc ('\n', asm_out_file);
1551 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
1553 case DW_CFA_advance_loc4:
1554 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file,
1555 cfi->dw_cfi_oprnd1.dw_cfi_addr,
1556 fde->dw_fde_current_label);
1557 fputc ('\n', asm_out_file);
1558 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
1560 #ifdef MIPS_DEBUGGING_INFO
1561 case DW_CFA_MIPS_advance_loc8:
1562 /* TODO: not currently implemented. */
1566 case DW_CFA_offset_extended:
1567 case DW_CFA_def_cfa:
1568 output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
1569 fputc ('\n', asm_out_file);
1570 output_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset);
1571 fputc ('\n', asm_out_file);
1573 case DW_CFA_restore_extended:
1574 case DW_CFA_undefined:
1575 output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
1576 fputc ('\n', asm_out_file);
1578 case DW_CFA_same_value:
1579 case DW_CFA_def_cfa_register:
1580 output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
1581 fputc ('\n', asm_out_file);
1583 case DW_CFA_register:
1584 output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
1585 fputc ('\n', asm_out_file);
1586 output_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_reg_num);
1587 fputc ('\n', asm_out_file);
1589 case DW_CFA_def_cfa_offset:
1590 output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset);
1591 fputc ('\n', asm_out_file);
1593 case DW_CFA_GNU_window_save:
1595 case DW_CFA_GNU_args_size:
1596 output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset);
1597 fputc ('\n', asm_out_file);
1605 /* Output the call frame information used to used to record information
1606 that relates to calculating the frame pointer, and records the
1607 location of saved registers. */
1610 output_call_frame_info (for_eh)
1613 register unsigned long i;
1614 register dw_fde_ref fde;
1615 register dw_cfi_ref cfi;
1616 char l1[20], l2[20];
1617 #ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
1621 /* Do we want to include a pointer to the exception table? */
1622 int eh_ptr = for_eh && exception_table_p ();
1624 fputc ('\n', asm_out_file);
1626 /* We're going to be generating comments, so turn on app. */
1632 #ifdef EH_FRAME_SECTION
1633 EH_FRAME_SECTION ();
1635 tree label = get_file_function_name ('F');
1637 force_data_section ();
1638 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
1639 ASM_GLOBALIZE_LABEL (asm_out_file, IDENTIFIER_POINTER (label));
1640 ASM_OUTPUT_LABEL (asm_out_file, IDENTIFIER_POINTER (label));
1642 assemble_label ("__FRAME_BEGIN__");
1645 ASM_OUTPUT_SECTION (asm_out_file, FRAME_SECTION);
1647 /* Output the CIE. */
1648 ASM_GENERATE_INTERNAL_LABEL (l1, CIE_AFTER_SIZE_LABEL, for_eh);
1649 ASM_GENERATE_INTERNAL_LABEL (l2, CIE_END_LABEL, for_eh);
1650 #ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
1651 ASM_GENERATE_INTERNAL_LABEL (ld, CIE_LENGTH_LABEL, for_eh);
1653 ASM_OUTPUT_DWARF_OFFSET4 (asm_out_file, ld);
1655 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, ld);
1658 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, l2, l1);
1660 ASM_OUTPUT_DWARF_DELTA (asm_out_file, l2, l1);
1663 fprintf (asm_out_file, "\t%s Length of Common Information Entry",
1666 fputc ('\n', asm_out_file);
1667 ASM_OUTPUT_LABEL (asm_out_file, l1);
1670 /* Now that the CIE pointer is PC-relative for EH,
1671 use 0 to identify the CIE. */
1672 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0);
1674 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, DW_CIE_ID);
1677 fprintf (asm_out_file, "\t%s CIE Identifier Tag", ASM_COMMENT_START);
1679 fputc ('\n', asm_out_file);
1680 if (! for_eh && DWARF_OFFSET_SIZE == 8)
1682 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, DW_CIE_ID);
1683 fputc ('\n', asm_out_file);
1686 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_CIE_VERSION);
1688 fprintf (asm_out_file, "\t%s CIE Version", ASM_COMMENT_START);
1690 fputc ('\n', asm_out_file);
1693 /* The CIE contains a pointer to the exception region info for the
1694 frame. Make the augmentation string three bytes (including the
1695 trailing null) so the pointer is 4-byte aligned. The Solaris ld
1696 can't handle unaligned relocs. */
1699 ASM_OUTPUT_DWARF_STRING (asm_out_file, "eh");
1700 fprintf (asm_out_file, "\t%s CIE Augmentation", ASM_COMMENT_START);
1704 ASM_OUTPUT_ASCII (asm_out_file, "eh", 3);
1706 fputc ('\n', asm_out_file);
1708 ASM_OUTPUT_DWARF_ADDR (asm_out_file, "__EXCEPTION_TABLE__");
1710 fprintf (asm_out_file, "\t%s pointer to exception region info",
1715 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
1717 fprintf (asm_out_file, "\t%s CIE Augmentation (none)",
1721 fputc ('\n', asm_out_file);
1724 fprintf (asm_out_file, " (CIE Code Alignment Factor)");
1726 fputc ('\n', asm_out_file);
1727 output_sleb128 (DWARF_CIE_DATA_ALIGNMENT);
1729 fprintf (asm_out_file, " (CIE Data Alignment Factor)");
1731 fputc ('\n', asm_out_file);
1732 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DWARF_FRAME_RETURN_COLUMN);
1734 fprintf (asm_out_file, "\t%s CIE RA Column", ASM_COMMENT_START);
1736 fputc ('\n', asm_out_file);
1738 for (cfi = cie_cfi_head; cfi != NULL; cfi = cfi->dw_cfi_next)
1739 output_cfi (cfi, NULL);
1741 /* Pad the CIE out to an address sized boundary. */
1742 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
1743 ASM_OUTPUT_LABEL (asm_out_file, l2);
1744 #ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
1745 ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL (asm_out_file, ld, l2, l1);
1747 fprintf (asm_out_file, "\t%s CIE Length Symbol", ASM_COMMENT_START);
1748 fputc ('\n', asm_out_file);
1751 /* Loop through all of the FDE's. */
1752 for (i = 0; i < fde_table_in_use; ++i)
1754 fde = &fde_table[i];
1756 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_AFTER_SIZE_LABEL, for_eh + i*2);
1757 ASM_GENERATE_INTERNAL_LABEL (l2, FDE_END_LABEL, for_eh + i*2);
1758 #ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
1759 ASM_GENERATE_INTERNAL_LABEL (ld, FDE_LENGTH_LABEL, for_eh + i*2);
1761 ASM_OUTPUT_DWARF_OFFSET4 (asm_out_file, ld);
1763 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, ld);
1766 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, l2, l1);
1768 ASM_OUTPUT_DWARF_DELTA (asm_out_file, l2, l1);
1771 fprintf (asm_out_file, "\t%s FDE Length", ASM_COMMENT_START);
1772 fputc ('\n', asm_out_file);
1773 ASM_OUTPUT_LABEL (asm_out_file, l1);
1775 /* ??? This always emits a 4 byte offset when for_eh is true, but it
1776 emits a target dependent sized offset when for_eh is not true.
1777 This inconsistency may confuse gdb. The only case where we need a
1778 non-4 byte offset is for the Irix6 N64 ABI, so we may lose SGI
1779 compatibility if we emit a 4 byte offset. We need a 4 byte offset
1780 though in order to be compatible with the dwarf_fde struct in frame.c.
1781 If the for_eh case is changed, then the struct in frame.c has
1782 to be adjusted appropriately. */
1784 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, l1, "__FRAME_BEGIN__");
1786 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, stripattributes (FRAME_SECTION));
1788 fprintf (asm_out_file, "\t%s FDE CIE offset", ASM_COMMENT_START);
1790 fputc ('\n', asm_out_file);
1791 ASM_OUTPUT_DWARF_ADDR (asm_out_file, fde->dw_fde_begin);
1793 fprintf (asm_out_file, "\t%s FDE initial location", ASM_COMMENT_START);
1795 fputc ('\n', asm_out_file);
1796 ASM_OUTPUT_DWARF_ADDR_DELTA (asm_out_file,
1797 fde->dw_fde_end, fde->dw_fde_begin);
1799 fprintf (asm_out_file, "\t%s FDE address range", ASM_COMMENT_START);
1801 fputc ('\n', asm_out_file);
1803 /* Loop through the Call Frame Instructions associated with
1805 fde->dw_fde_current_label = fde->dw_fde_begin;
1806 for (cfi = fde->dw_fde_cfi; cfi != NULL; cfi = cfi->dw_cfi_next)
1807 output_cfi (cfi, fde);
1809 /* Pad the FDE out to an address sized boundary. */
1810 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
1811 ASM_OUTPUT_LABEL (asm_out_file, l2);
1812 #ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
1813 ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL (asm_out_file, ld, l2, l1);
1815 fprintf (asm_out_file, "\t%s FDE Length Symbol", ASM_COMMENT_START);
1816 fputc ('\n', asm_out_file);
1819 #ifndef EH_FRAME_SECTION
1822 /* Emit terminating zero for table. */
1823 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0);
1824 fputc ('\n', asm_out_file);
1827 #ifdef MIPS_DEBUGGING_INFO
1828 /* Work around Irix 6 assembler bug whereby labels at the end of a section
1829 get a value of 0. Putting .align 0 after the label fixes it. */
1830 ASM_OUTPUT_ALIGN (asm_out_file, 0);
1833 /* Turn off app to make assembly quicker. */
1838 /* Output a marker (i.e. a label) for the beginning of a function, before
1842 dwarf2out_begin_prologue ()
1844 char label[MAX_ARTIFICIAL_LABEL_BYTES];
1845 register dw_fde_ref fde;
1847 ++current_funcdef_number;
1849 function_section (current_function_decl);
1850 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_BEGIN_LABEL,
1851 current_funcdef_number);
1852 ASM_OUTPUT_LABEL (asm_out_file, label);
1854 /* Expand the fde table if necessary. */
1855 if (fde_table_in_use == fde_table_allocated)
1857 fde_table_allocated += FDE_TABLE_INCREMENT;
1859 = (dw_fde_ref) xrealloc (fde_table,
1860 fde_table_allocated * sizeof (dw_fde_node));
1863 /* Record the FDE associated with this function. */
1864 current_funcdef_fde = fde_table_in_use;
1866 /* Add the new FDE at the end of the fde_table. */
1867 fde = &fde_table[fde_table_in_use++];
1868 fde->dw_fde_begin = xstrdup (label);
1869 fde->dw_fde_current_label = NULL;
1870 fde->dw_fde_end = NULL;
1871 fde->dw_fde_cfi = NULL;
1873 args_size = old_args_size = 0;
1876 /* Output a marker (i.e. a label) for the absolute end of the generated code
1877 for a function definition. This gets called *after* the epilogue code has
1881 dwarf2out_end_epilogue ()
1884 char label[MAX_ARTIFICIAL_LABEL_BYTES];
1886 /* Output a label to mark the endpoint of the code generated for this
1888 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL, current_funcdef_number);
1889 ASM_OUTPUT_LABEL (asm_out_file, label);
1890 fde = &fde_table[fde_table_in_use - 1];
1891 fde->dw_fde_end = xstrdup (label);
1895 dwarf2out_frame_init ()
1897 /* Allocate the initial hunk of the fde_table. */
1898 fde_table = (dw_fde_ref) xcalloc (FDE_TABLE_INCREMENT, sizeof (dw_fde_node));
1899 fde_table_allocated = FDE_TABLE_INCREMENT;
1900 fde_table_in_use = 0;
1902 /* Generate the CFA instructions common to all FDE's. Do it now for the
1903 sake of lookup_cfa. */
1905 #ifdef DWARF2_UNWIND_INFO
1906 /* On entry, the Canonical Frame Address is at SP. */
1907 dwarf2out_def_cfa (NULL, STACK_POINTER_REGNUM, INCOMING_FRAME_SP_OFFSET);
1908 initial_return_save (INCOMING_RETURN_ADDR_RTX);
1913 dwarf2out_frame_finish ()
1915 /* Output call frame information. */
1916 #ifdef MIPS_DEBUGGING_INFO
1917 if (write_symbols == DWARF2_DEBUG)
1918 output_call_frame_info (0);
1919 if (flag_unwind_tables || (flag_exceptions && ! exceptions_via_longjmp))
1920 output_call_frame_info (1);
1922 if (write_symbols == DWARF2_DEBUG
1923 || flag_unwind_tables || (flag_exceptions && ! exceptions_via_longjmp))
1924 output_call_frame_info (1);
1928 #endif /* .debug_frame support */
1930 /* And now, the support for symbolic debugging information. */
1931 #ifdef DWARF2_DEBUGGING_INFO
1933 /* NOTE: In the comments in this file, many references are made to
1934 "Debugging Information Entries". This term is abbreviated as `DIE'
1935 throughout the remainder of this file. */
1937 /* An internal representation of the DWARF output is built, and then
1938 walked to generate the DWARF debugging info. The walk of the internal
1939 representation is done after the entire program has been compiled.
1940 The types below are used to describe the internal representation. */
1942 /* Each DIE may have a series of attribute/value pairs. Values
1943 can take on several forms. The forms that are used in this
1944 implementation are listed below. */
1951 dw_val_class_unsigned_const,
1952 dw_val_class_long_long,
1955 dw_val_class_die_ref,
1956 dw_val_class_fde_ref,
1957 dw_val_class_lbl_id,
1958 dw_val_class_lbl_offset,
1963 /* Various DIE's use offsets relative to the beginning of the
1964 .debug_info section to refer to each other. */
1966 typedef long int dw_offset;
1968 /* Define typedefs here to avoid circular dependencies. */
1970 typedef struct die_struct *dw_die_ref;
1971 typedef struct dw_attr_struct *dw_attr_ref;
1972 typedef struct dw_val_struct *dw_val_ref;
1973 typedef struct dw_line_info_struct *dw_line_info_ref;
1974 typedef struct dw_separate_line_info_struct *dw_separate_line_info_ref;
1975 typedef struct dw_loc_descr_struct *dw_loc_descr_ref;
1976 typedef struct pubname_struct *pubname_ref;
1977 typedef dw_die_ref *arange_ref;
1979 /* Describe a double word constant value. */
1981 typedef struct dw_long_long_struct
1988 /* Describe a floating point constant value. */
1990 typedef struct dw_fp_struct
1997 /* Each entry in the line_info_table maintains the file and
1998 line number associated with the label generated for that
1999 entry. The label gives the PC value associated with
2000 the line number entry. */
2002 typedef struct dw_line_info_struct
2004 unsigned long dw_file_num;
2005 unsigned long dw_line_num;
2009 /* Line information for functions in separate sections; each one gets its
2011 typedef struct dw_separate_line_info_struct
2013 unsigned long dw_file_num;
2014 unsigned long dw_line_num;
2015 unsigned long function;
2017 dw_separate_line_info_entry;
2019 /* The dw_val_node describes an attribute's value, as it is
2020 represented internally. */
2022 typedef struct dw_val_struct
2024 dw_val_class val_class;
2028 dw_loc_descr_ref val_loc;
2030 long unsigned val_unsigned;
2031 dw_long_long_const val_long_long;
2032 dw_float_const val_float;
2033 dw_die_ref val_die_ref;
2034 unsigned val_fde_index;
2037 unsigned char val_flag;
2043 /* Locations in memory are described using a sequence of stack machine
2046 typedef struct dw_loc_descr_struct
2048 dw_loc_descr_ref dw_loc_next;
2049 enum dwarf_location_atom dw_loc_opc;
2050 dw_val_node dw_loc_oprnd1;
2051 dw_val_node dw_loc_oprnd2;
2055 /* Each DIE attribute has a field specifying the attribute kind,
2056 a link to the next attribute in the chain, and an attribute value.
2057 Attributes are typically linked below the DIE they modify. */
2059 typedef struct dw_attr_struct
2061 enum dwarf_attribute dw_attr;
2062 dw_attr_ref dw_attr_next;
2063 dw_val_node dw_attr_val;
2067 /* The Debugging Information Entry (DIE) structure */
2069 typedef struct die_struct
2071 enum dwarf_tag die_tag;
2072 dw_attr_ref die_attr;
2073 dw_die_ref die_parent;
2074 dw_die_ref die_child;
2076 dw_offset die_offset;
2077 unsigned long die_abbrev;
2081 /* The pubname structure */
2083 typedef struct pubname_struct
2090 /* The limbo die list structure. */
2091 typedef struct limbo_die_struct
2094 struct limbo_die_struct *next;
2098 /* How to start an assembler comment. */
2099 #ifndef ASM_COMMENT_START
2100 #define ASM_COMMENT_START ";#"
2103 /* Define a macro which returns non-zero for a TYPE_DECL which was
2104 implicitly generated for a tagged type.
2106 Note that unlike the gcc front end (which generates a NULL named
2107 TYPE_DECL node for each complete tagged type, each array type, and
2108 each function type node created) the g++ front end generates a
2109 _named_ TYPE_DECL node for each tagged type node created.
2110 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
2111 generate a DW_TAG_typedef DIE for them. */
2113 #define TYPE_DECL_IS_STUB(decl) \
2114 (DECL_NAME (decl) == NULL_TREE \
2115 || (DECL_ARTIFICIAL (decl) \
2116 && is_tagged_type (TREE_TYPE (decl)) \
2117 && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \
2118 /* This is necessary for stub decls that \
2119 appear in nested inline functions. */ \
2120 || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
2121 && (decl_ultimate_origin (decl) \
2122 == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
2124 /* Information concerning the compilation unit's programming
2125 language, and compiler version. */
2127 extern int flag_traditional;
2128 extern char *version_string;
2130 /* Fixed size portion of the DWARF compilation unit header. */
2131 #define DWARF_COMPILE_UNIT_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 3)
2133 /* Fixed size portion of debugging line information prolog. */
2134 #define DWARF_LINE_PROLOG_HEADER_SIZE 5
2136 /* Fixed size portion of public names info. */
2137 #define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
2139 /* Fixed size portion of the address range info. */
2140 #define DWARF_ARANGES_HEADER_SIZE \
2141 (DWARF_ROUND (2 * DWARF_OFFSET_SIZE + 4, PTR_SIZE * 2) - DWARF_OFFSET_SIZE)
2143 /* The default is to have gcc emit the line number tables. */
2144 #ifndef DWARF2_ASM_LINE_DEBUG_INFO
2145 #define DWARF2_ASM_LINE_DEBUG_INFO 0
2148 /* Define the architecture-dependent minimum instruction length (in bytes).
2149 In this implementation of DWARF, this field is used for information
2150 purposes only. Since GCC generates assembly language, we have
2151 no a priori knowledge of how many instruction bytes are generated
2152 for each source line, and therefore can use only the DW_LNE_set_address
2153 and DW_LNS_fixed_advance_pc line information commands. */
2155 #ifndef DWARF_LINE_MIN_INSTR_LENGTH
2156 #define DWARF_LINE_MIN_INSTR_LENGTH 4
2159 /* Minimum line offset in a special line info. opcode.
2160 This value was chosen to give a reasonable range of values. */
2161 #define DWARF_LINE_BASE -10
2163 /* First special line opcde - leave room for the standard opcodes. */
2164 #define DWARF_LINE_OPCODE_BASE 10
2166 /* Range of line offsets in a special line info. opcode. */
2167 #define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1)
2169 /* Flag that indicates the initial value of the is_stmt_start flag.
2170 In the present implementation, we do not mark any lines as
2171 the beginning of a source statement, because that information
2172 is not made available by the GCC front-end. */
2173 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
2175 /* This location is used by calc_die_sizes() to keep track
2176 the offset of each DIE within the .debug_info section. */
2177 static unsigned long next_die_offset;
2179 /* Record the root of the DIE's built for the current compilation unit. */
2180 static dw_die_ref comp_unit_die;
2182 /* A list of DIEs with a NULL parent waiting to be relocated. */
2183 static limbo_die_node *limbo_die_list = 0;
2185 /* Pointer to an array of filenames referenced by this compilation unit. */
2186 static char **file_table;
2188 /* Total number of entries in the table (i.e. array) pointed to by
2189 `file_table'. This is the *total* and includes both used and unused
2191 static unsigned file_table_allocated;
2193 /* Number of entries in the file_table which are actually in use. */
2194 static unsigned file_table_in_use;
2196 /* Size (in elements) of increments by which we may expand the filename
2198 #define FILE_TABLE_INCREMENT 64
2200 /* Local pointer to the name of the main input file. Initialized in
2202 static char *primary_filename;
2204 /* For Dwarf output, we must assign lexical-blocks id numbers in the order in
2205 which their beginnings are encountered. We output Dwarf debugging info
2206 that refers to the beginnings and ends of the ranges of code for each
2207 lexical block. The labels themselves are generated in final.c, which
2208 assigns numbers to the blocks in the same way. */
2209 static unsigned next_block_number = 2;
2211 /* A pointer to the base of a table of references to DIE's that describe
2212 declarations. The table is indexed by DECL_UID() which is a unique
2213 number identifying each decl. */
2214 static dw_die_ref *decl_die_table;
2216 /* Number of elements currently allocated for the decl_die_table. */
2217 static unsigned decl_die_table_allocated;
2219 /* Number of elements in decl_die_table currently in use. */
2220 static unsigned decl_die_table_in_use;
2222 /* Size (in elements) of increments by which we may expand the
2224 #define DECL_DIE_TABLE_INCREMENT 256
2226 /* A pointer to the base of a table of references to declaration
2227 scopes. This table is a display which tracks the nesting
2228 of declaration scopes at the current scope and containing
2229 scopes. This table is used to find the proper place to
2230 define type declaration DIE's. */
2231 static tree *decl_scope_table;
2233 /* Number of elements currently allocated for the decl_scope_table. */
2234 static int decl_scope_table_allocated;
2236 /* Current level of nesting of declaration scopes. */
2237 static int decl_scope_depth;
2239 /* Size (in elements) of increments by which we may expand the
2240 decl_scope_table. */
2241 #define DECL_SCOPE_TABLE_INCREMENT 64
2243 /* A pointer to the base of a list of references to DIE's that
2244 are uniquely identified by their tag, presence/absence of
2245 children DIE's, and list of attribute/value pairs. */
2246 static dw_die_ref *abbrev_die_table;
2248 /* Number of elements currently allocated for abbrev_die_table. */
2249 static unsigned abbrev_die_table_allocated;
2251 /* Number of elements in type_die_table currently in use. */
2252 static unsigned abbrev_die_table_in_use;
2254 /* Size (in elements) of increments by which we may expand the
2255 abbrev_die_table. */
2256 #define ABBREV_DIE_TABLE_INCREMENT 256
2258 /* A pointer to the base of a table that contains line information
2259 for each source code line in .text in the compilation unit. */
2260 static dw_line_info_ref line_info_table;
2262 /* Number of elements currently allocated for line_info_table. */
2263 static unsigned line_info_table_allocated;
2265 /* Number of elements in separate_line_info_table currently in use. */
2266 static unsigned separate_line_info_table_in_use;
2268 /* A pointer to the base of a table that contains line information
2269 for each source code line outside of .text in the compilation unit. */
2270 static dw_separate_line_info_ref separate_line_info_table;
2272 /* Number of elements currently allocated for separate_line_info_table. */
2273 static unsigned separate_line_info_table_allocated;
2275 /* Number of elements in line_info_table currently in use. */
2276 static unsigned line_info_table_in_use;
2278 /* Size (in elements) of increments by which we may expand the
2280 #define LINE_INFO_TABLE_INCREMENT 1024
2282 /* A pointer to the base of a table that contains a list of publicly
2283 accessible names. */
2284 static pubname_ref pubname_table;
2286 /* Number of elements currently allocated for pubname_table. */
2287 static unsigned pubname_table_allocated;
2289 /* Number of elements in pubname_table currently in use. */
2290 static unsigned pubname_table_in_use;
2292 /* Size (in elements) of increments by which we may expand the
2294 #define PUBNAME_TABLE_INCREMENT 64
2296 /* A pointer to the base of a table that contains a list of publicly
2297 accessible names. */
2298 static arange_ref arange_table;
2300 /* Number of elements currently allocated for arange_table. */
2301 static unsigned arange_table_allocated;
2303 /* Number of elements in arange_table currently in use. */
2304 static unsigned arange_table_in_use;
2306 /* Size (in elements) of increments by which we may expand the
2308 #define ARANGE_TABLE_INCREMENT 64
2310 /* A pointer to the base of a list of incomplete types which might be
2311 completed at some later time. */
2313 static tree *incomplete_types_list;
2315 /* Number of elements currently allocated for the incomplete_types_list. */
2316 static unsigned incomplete_types_allocated;
2318 /* Number of elements of incomplete_types_list currently in use. */
2319 static unsigned incomplete_types;
2321 /* Size (in elements) of increments by which we may expand the incomplete
2322 types list. Actually, a single hunk of space of this size should
2323 be enough for most typical programs. */
2324 #define INCOMPLETE_TYPES_INCREMENT 64
2326 /* Record whether the function being analyzed contains inlined functions. */
2327 static int current_function_has_inlines;
2328 #if 0 && defined (MIPS_DEBUGGING_INFO)
2329 static int comp_unit_has_inlines;
2332 /* Forward declarations for functions defined in this file. */
2334 static void addr_const_to_string PROTO((dyn_string_t, rtx));
2335 static char *addr_to_string PROTO((rtx));
2336 static int is_pseudo_reg PROTO((rtx));
2337 static tree type_main_variant PROTO((tree));
2338 static int is_tagged_type PROTO((tree));
2339 static const char *dwarf_tag_name PROTO((unsigned));
2340 static const char *dwarf_attr_name PROTO((unsigned));
2341 static const char *dwarf_form_name PROTO((unsigned));
2342 static const char *dwarf_stack_op_name PROTO((unsigned));
2344 static const char *dwarf_type_encoding_name PROTO((unsigned));
2346 static tree decl_ultimate_origin PROTO((tree));
2347 static tree block_ultimate_origin PROTO((tree));
2348 static tree decl_class_context PROTO((tree));
2349 static void add_dwarf_attr PROTO((dw_die_ref, dw_attr_ref));
2350 static void add_AT_flag PROTO((dw_die_ref,
2351 enum dwarf_attribute,
2353 static void add_AT_int PROTO((dw_die_ref,
2354 enum dwarf_attribute, long));
2355 static void add_AT_unsigned PROTO((dw_die_ref,
2356 enum dwarf_attribute,
2358 static void add_AT_long_long PROTO((dw_die_ref,
2359 enum dwarf_attribute,
2360 unsigned long, unsigned long));
2361 static void add_AT_float PROTO((dw_die_ref,
2362 enum dwarf_attribute,
2364 static void add_AT_string PROTO((dw_die_ref,
2365 enum dwarf_attribute,
2367 static void add_AT_die_ref PROTO((dw_die_ref,
2368 enum dwarf_attribute,
2370 static void add_AT_fde_ref PROTO((dw_die_ref,
2371 enum dwarf_attribute,
2373 static void add_AT_loc PROTO((dw_die_ref,
2374 enum dwarf_attribute,
2376 static void add_AT_addr PROTO((dw_die_ref,
2377 enum dwarf_attribute, char *));
2378 static void add_AT_lbl_id PROTO((dw_die_ref,
2379 enum dwarf_attribute, char *));
2380 static void add_AT_lbl_offset PROTO((dw_die_ref,
2381 enum dwarf_attribute, char *));
2382 static dw_attr_ref get_AT PROTO((dw_die_ref,
2383 enum dwarf_attribute));
2384 static const char *get_AT_low_pc PROTO((dw_die_ref));
2385 static const char *get_AT_hi_pc PROTO((dw_die_ref));
2386 static const char *get_AT_string PROTO((dw_die_ref,
2387 enum dwarf_attribute));
2388 static int get_AT_flag PROTO((dw_die_ref,
2389 enum dwarf_attribute));
2390 static unsigned get_AT_unsigned PROTO((dw_die_ref,
2391 enum dwarf_attribute));
2392 static int is_c_family PROTO((void));
2393 static int is_fortran PROTO((void));
2394 static void remove_AT PROTO((dw_die_ref,
2395 enum dwarf_attribute));
2396 static void remove_children PROTO((dw_die_ref));
2397 static void add_child_die PROTO((dw_die_ref, dw_die_ref));
2398 static dw_die_ref new_die PROTO((enum dwarf_tag, dw_die_ref));
2399 static dw_die_ref lookup_type_die PROTO((tree));
2400 static void equate_type_number_to_die PROTO((tree, dw_die_ref));
2401 static dw_die_ref lookup_decl_die PROTO((tree));
2402 static void equate_decl_number_to_die PROTO((tree, dw_die_ref));
2403 static dw_loc_descr_ref new_loc_descr PROTO((enum dwarf_location_atom,
2404 unsigned long, unsigned long));
2405 static void add_loc_descr PROTO((dw_loc_descr_ref *,
2407 static void print_spaces PROTO((FILE *));
2408 static void print_die PROTO((dw_die_ref, FILE *));
2409 static void print_dwarf_line_table PROTO((FILE *));
2410 static void add_sibling_attributes PROTO((dw_die_ref));
2411 static void build_abbrev_table PROTO((dw_die_ref));
2412 static unsigned long size_of_string PROTO((const char *));
2413 static unsigned long size_of_loc_descr PROTO((dw_loc_descr_ref));
2414 static unsigned long size_of_locs PROTO((dw_loc_descr_ref));
2415 static int constant_size PROTO((long unsigned));
2416 static unsigned long size_of_die PROTO((dw_die_ref));
2417 static void calc_die_sizes PROTO((dw_die_ref));
2418 static unsigned long size_of_line_prolog PROTO((void));
2419 static unsigned long size_of_pubnames PROTO((void));
2420 static unsigned long size_of_aranges PROTO((void));
2421 static enum dwarf_form value_format PROTO((dw_attr_ref));
2422 static void output_value_format PROTO((dw_attr_ref));
2423 static void output_abbrev_section PROTO((void));
2424 static void output_loc_operands PROTO((dw_loc_descr_ref));
2425 static void output_die PROTO((dw_die_ref));
2426 static void output_compilation_unit_header PROTO((void));
2427 static const char *dwarf2_name PROTO((tree, int));
2428 static void add_pubname PROTO((tree, dw_die_ref));
2429 static void output_pubnames PROTO((void));
2430 static void add_arange PROTO((tree, dw_die_ref));
2431 static void output_aranges PROTO((void));
2432 static void output_line_info PROTO((void));
2433 static int is_body_block PROTO((tree));
2434 static dw_die_ref base_type_die PROTO((tree));
2435 static tree root_type PROTO((tree));
2436 static int is_base_type PROTO((tree));
2437 static dw_die_ref modified_type_die PROTO((tree, int, int, dw_die_ref));
2438 static int type_is_enum PROTO((tree));
2439 static dw_loc_descr_ref reg_loc_descriptor PROTO((rtx));
2440 static dw_loc_descr_ref based_loc_descr PROTO((unsigned, long));
2441 static int is_based_loc PROTO((rtx));
2442 static dw_loc_descr_ref mem_loc_descriptor PROTO((rtx, enum machine_mode mode));
2443 static dw_loc_descr_ref concat_loc_descriptor PROTO((rtx, rtx));
2444 static dw_loc_descr_ref loc_descriptor PROTO((rtx));
2445 static unsigned ceiling PROTO((unsigned, unsigned));
2446 static tree field_type PROTO((tree));
2447 static unsigned simple_type_align_in_bits PROTO((tree));
2448 static unsigned simple_type_size_in_bits PROTO((tree));
2449 static unsigned field_byte_offset PROTO((tree));
2450 static void add_AT_location_description PROTO((dw_die_ref,
2451 enum dwarf_attribute, rtx));
2452 static void add_data_member_location_attribute PROTO((dw_die_ref, tree));
2453 static void add_const_value_attribute PROTO((dw_die_ref, rtx));
2454 static void add_location_or_const_value_attribute PROTO((dw_die_ref, tree));
2455 static void add_name_attribute PROTO((dw_die_ref, const char *));
2456 static void add_bound_info PROTO((dw_die_ref,
2457 enum dwarf_attribute, tree));
2458 static void add_subscript_info PROTO((dw_die_ref, tree));
2459 static void add_byte_size_attribute PROTO((dw_die_ref, tree));
2460 static void add_bit_offset_attribute PROTO((dw_die_ref, tree));
2461 static void add_bit_size_attribute PROTO((dw_die_ref, tree));
2462 static void add_prototyped_attribute PROTO((dw_die_ref, tree));
2463 static void add_abstract_origin_attribute PROTO((dw_die_ref, tree));
2464 static void add_pure_or_virtual_attribute PROTO((dw_die_ref, tree));
2465 static void add_src_coords_attributes PROTO((dw_die_ref, tree));
2466 static void add_name_and_src_coords_attributes PROTO((dw_die_ref, tree));
2467 static void push_decl_scope PROTO((tree));
2468 static dw_die_ref scope_die_for PROTO((tree, dw_die_ref));
2469 static void pop_decl_scope PROTO((void));
2470 static void add_type_attribute PROTO((dw_die_ref, tree, int, int,
2472 static char *type_tag PROTO((tree));
2473 static tree member_declared_type PROTO((tree));
2475 static char *decl_start_label PROTO((tree));
2477 static void gen_array_type_die PROTO((tree, dw_die_ref));
2478 static void gen_set_type_die PROTO((tree, dw_die_ref));
2480 static void gen_entry_point_die PROTO((tree, dw_die_ref));
2482 static void gen_inlined_enumeration_type_die PROTO((tree, dw_die_ref));
2483 static void gen_inlined_structure_type_die PROTO((tree, dw_die_ref));
2484 static void gen_inlined_union_type_die PROTO((tree, dw_die_ref));
2485 static void gen_enumeration_type_die PROTO((tree, dw_die_ref));
2486 static dw_die_ref gen_formal_parameter_die PROTO((tree, dw_die_ref));
2487 static void gen_unspecified_parameters_die PROTO((tree, dw_die_ref));
2488 static void gen_formal_types_die PROTO((tree, dw_die_ref));
2489 static void gen_subprogram_die PROTO((tree, dw_die_ref));
2490 static void gen_variable_die PROTO((tree, dw_die_ref));
2491 static void gen_label_die PROTO((tree, dw_die_ref));
2492 static void gen_lexical_block_die PROTO((tree, dw_die_ref, int));
2493 static void gen_inlined_subroutine_die PROTO((tree, dw_die_ref, int));
2494 static void gen_field_die PROTO((tree, dw_die_ref));
2495 static void gen_ptr_to_mbr_type_die PROTO((tree, dw_die_ref));
2496 static dw_die_ref gen_compile_unit_die PROTO((const char *));
2497 static void gen_string_type_die PROTO((tree, dw_die_ref));
2498 static void gen_inheritance_die PROTO((tree, dw_die_ref));
2499 static void gen_member_die PROTO((tree, dw_die_ref));
2500 static void gen_struct_or_union_type_die PROTO((tree, dw_die_ref));
2501 static void gen_subroutine_type_die PROTO((tree, dw_die_ref));
2502 static void gen_typedef_die PROTO((tree, dw_die_ref));
2503 static void gen_type_die PROTO((tree, dw_die_ref));
2504 static void gen_tagged_type_instantiation_die PROTO((tree, dw_die_ref));
2505 static void gen_block_die PROTO((tree, dw_die_ref, int));
2506 static void decls_for_scope PROTO((tree, dw_die_ref, int));
2507 static int is_redundant_typedef PROTO((tree));
2508 static void gen_decl_die PROTO((tree, dw_die_ref));
2509 static unsigned lookup_filename PROTO((const char *));
2510 static void add_incomplete_type PROTO((tree));
2511 static void retry_incomplete_types PROTO((void));
2512 static void gen_type_die_for_member PROTO((tree, tree, dw_die_ref));
2513 static void gen_abstract_function PROTO((tree));
2515 /* Section names used to hold DWARF debugging information. */
2516 #ifndef DEBUG_INFO_SECTION
2517 #define DEBUG_INFO_SECTION ".debug_info"
2519 #ifndef ABBREV_SECTION
2520 #define ABBREV_SECTION ".debug_abbrev"
2522 #ifndef ARANGES_SECTION
2523 #define ARANGES_SECTION ".debug_aranges"
2525 #ifndef DW_MACINFO_SECTION
2526 #define DW_MACINFO_SECTION ".debug_macinfo"
2528 #ifndef DEBUG_LINE_SECTION
2529 #define DEBUG_LINE_SECTION ".debug_line"
2532 #define LOC_SECTION ".debug_loc"
2534 #ifndef PUBNAMES_SECTION
2535 #define PUBNAMES_SECTION ".debug_pubnames"
2538 #define STR_SECTION ".debug_str"
2541 /* Standard ELF section names for compiled code and data. */
2542 #ifndef TEXT_SECTION
2543 #define TEXT_SECTION ".text"
2545 #ifndef DATA_SECTION
2546 #define DATA_SECTION ".data"
2549 #define BSS_SECTION ".bss"
2552 /* Labels we insert at beginning sections we can reference instead of
2553 the section names themselves. */
2555 #ifndef TEXT_SECTION_LABEL
2556 #define TEXT_SECTION_LABEL "Ltext"
2558 #ifndef DEBUG_LINE_SECTION_LABEL
2559 #define DEBUG_LINE_SECTION_LABEL "Ldebug_line"
2561 #ifndef DEBUG_INFO_SECTION_LABEL
2562 #define DEBUG_INFO_SECTION_LABEL "Ldebug_info"
2564 #ifndef ABBREV_SECTION_LABEL
2565 #define ABBREV_SECTION_LABEL "Ldebug_abbrev"
2569 /* Definitions of defaults for formats and names of various special
2570 (artificial) labels which may be generated within this file (when the -g
2571 options is used and DWARF_DEBUGGING_INFO is in effect.
2572 If necessary, these may be overridden from within the tm.h file, but
2573 typically, overriding these defaults is unnecessary. */
2575 static char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
2576 static char text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
2577 static char abbrev_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
2578 static char debug_info_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
2579 static char debug_line_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
2581 #ifndef TEXT_END_LABEL
2582 #define TEXT_END_LABEL "Letext"
2584 #ifndef DATA_END_LABEL
2585 #define DATA_END_LABEL "Ledata"
2587 #ifndef BSS_END_LABEL
2588 #define BSS_END_LABEL "Lebss"
2590 #ifndef INSN_LABEL_FMT
2591 #define INSN_LABEL_FMT "LI%u_"
2593 #ifndef BLOCK_BEGIN_LABEL
2594 #define BLOCK_BEGIN_LABEL "LBB"
2596 #ifndef BLOCK_END_LABEL
2597 #define BLOCK_END_LABEL "LBE"
2599 #ifndef BODY_BEGIN_LABEL
2600 #define BODY_BEGIN_LABEL "Lbb"
2602 #ifndef BODY_END_LABEL
2603 #define BODY_END_LABEL "Lbe"
2605 #ifndef LINE_CODE_LABEL
2606 #define LINE_CODE_LABEL "LM"
2608 #ifndef SEPARATE_LINE_CODE_LABEL
2609 #define SEPARATE_LINE_CODE_LABEL "LSM"
2612 /* Convert a reference to the assembler name of a C-level name. This
2613 macro has the same effect as ASM_OUTPUT_LABELREF, but copies to
2614 a string rather than writing to a file. */
2615 #ifndef ASM_NAME_TO_STRING
2616 #define ASM_NAME_TO_STRING(STR, NAME) \
2618 if ((NAME)[0] == '*') \
2619 dyn_string_append (STR, NAME + 1); \
2622 const char *newstr; \
2623 STRIP_NAME_ENCODING (newstr, NAME); \
2624 dyn_string_append (STR, user_label_prefix); \
2625 dyn_string_append (STR, newstr); \
2631 /* We allow a language front-end to designate a function that is to be
2632 called to "demangle" any name before it it put into a DIE. */
2634 static const char *(*demangle_name_func) PROTO((const char *));
2637 dwarf2out_set_demangle_name_func (func)
2638 const char *(*func) PROTO((const char *));
2640 demangle_name_func = func;
2643 /* Convert an integer constant expression into assembler syntax. Addition
2644 and subtraction are the only arithmetic that may appear in these
2645 expressions. This is an adaptation of output_addr_const in final.c.
2646 Here, the target of the conversion is a string buffer. We can't use
2647 output_addr_const directly, because it writes to a file. */
2650 addr_const_to_string (str, x)
2657 switch (GET_CODE (x))
2661 dyn_string_append (str, ",");
2667 ASM_NAME_TO_STRING (str, XSTR (x, 0));
2671 ASM_GENERATE_INTERNAL_LABEL (buf1, "L", CODE_LABEL_NUMBER (XEXP (x, 0)));
2672 ASM_NAME_TO_STRING (str, buf1);
2676 ASM_GENERATE_INTERNAL_LABEL (buf1, "L", CODE_LABEL_NUMBER (x));
2677 ASM_NAME_TO_STRING (str, buf1);
2681 sprintf (buf1, HOST_WIDE_INT_PRINT_DEC, INTVAL (x));
2682 dyn_string_append (str, buf1);
2686 /* This used to output parentheses around the expression, but that does
2687 not work on the 386 (either ATT or BSD assembler). */
2688 addr_const_to_string (str, XEXP (x, 0));
2692 if (GET_MODE (x) == VOIDmode)
2694 /* We can use %d if the number is one word and positive. */
2695 if (CONST_DOUBLE_HIGH (x))
2696 sprintf (buf1, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
2697 CONST_DOUBLE_HIGH (x), CONST_DOUBLE_LOW (x));
2698 else if (CONST_DOUBLE_LOW (x) < 0)
2699 sprintf (buf1, HOST_WIDE_INT_PRINT_HEX, CONST_DOUBLE_LOW (x));
2701 sprintf (buf1, HOST_WIDE_INT_PRINT_DEC,
2702 CONST_DOUBLE_LOW (x));
2703 dyn_string_append (str, buf1);
2706 /* We can't handle floating point constants; PRINT_OPERAND must
2708 output_operand_lossage ("floating constant misused");
2712 /* Some assemblers need integer constants to appear last (eg masm). */
2713 if (GET_CODE (XEXP (x, 0)) == CONST_INT)
2715 addr_const_to_string (str, XEXP (x, 1));
2716 if (INTVAL (XEXP (x, 0)) >= 0)
2717 dyn_string_append (str, "+");
2719 addr_const_to_string (str, XEXP (x, 0));
2723 addr_const_to_string (str, XEXP (x, 0));
2724 if (INTVAL (XEXP (x, 1)) >= 0)
2725 dyn_string_append (str, "+");
2727 addr_const_to_string (str, XEXP (x, 1));
2732 /* Avoid outputting things like x-x or x+5-x, since some assemblers
2733 can't handle that. */
2734 x = simplify_subtraction (x);
2735 if (GET_CODE (x) != MINUS)
2738 addr_const_to_string (str, XEXP (x, 0));
2739 dyn_string_append (str, "-");
2740 if (GET_CODE (XEXP (x, 1)) == CONST_INT
2741 && INTVAL (XEXP (x, 1)) < 0)
2743 dyn_string_append (str, ASM_OPEN_PAREN);
2744 addr_const_to_string (str, XEXP (x, 1));
2745 dyn_string_append (str, ASM_CLOSE_PAREN);
2748 addr_const_to_string (str, XEXP (x, 1));
2753 addr_const_to_string (str, XEXP (x, 0));
2757 output_operand_lossage ("invalid expression as operand");
2761 /* Convert an address constant to a string, and return a pointer to
2762 a copy of the result, located on the heap. */
2768 dyn_string_t ds = dyn_string_new (256);
2771 addr_const_to_string (ds, x);
2773 /* Return the dynamically allocated string, but free the
2774 dyn_string_t itself. */
2780 /* Test if rtl node points to a pseudo register. */
2786 return (((GET_CODE (rtl) == REG) && (REGNO (rtl) >= FIRST_PSEUDO_REGISTER))
2787 || ((GET_CODE (rtl) == SUBREG)
2788 && (REGNO (XEXP (rtl, 0)) >= FIRST_PSEUDO_REGISTER)));
2791 /* Return a reference to a type, with its const and volatile qualifiers
2795 type_main_variant (type)
2798 type = TYPE_MAIN_VARIANT (type);
2800 /* There really should be only one main variant among any group of variants
2801 of a given type (and all of the MAIN_VARIANT values for all members of
2802 the group should point to that one type) but sometimes the C front-end
2803 messes this up for array types, so we work around that bug here. */
2805 if (TREE_CODE (type) == ARRAY_TYPE)
2806 while (type != TYPE_MAIN_VARIANT (type))
2807 type = TYPE_MAIN_VARIANT (type);
2812 /* Return non-zero if the given type node represents a tagged type. */
2815 is_tagged_type (type)
2818 register enum tree_code code = TREE_CODE (type);
2820 return (code == RECORD_TYPE || code == UNION_TYPE
2821 || code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE);
2824 /* Convert a DIE tag into its string name. */
2827 dwarf_tag_name (tag)
2828 register unsigned tag;
2832 case DW_TAG_padding:
2833 return "DW_TAG_padding";
2834 case DW_TAG_array_type:
2835 return "DW_TAG_array_type";
2836 case DW_TAG_class_type:
2837 return "DW_TAG_class_type";
2838 case DW_TAG_entry_point:
2839 return "DW_TAG_entry_point";
2840 case DW_TAG_enumeration_type:
2841 return "DW_TAG_enumeration_type";
2842 case DW_TAG_formal_parameter:
2843 return "DW_TAG_formal_parameter";
2844 case DW_TAG_imported_declaration:
2845 return "DW_TAG_imported_declaration";
2847 return "DW_TAG_label";
2848 case DW_TAG_lexical_block:
2849 return "DW_TAG_lexical_block";
2851 return "DW_TAG_member";
2852 case DW_TAG_pointer_type:
2853 return "DW_TAG_pointer_type";
2854 case DW_TAG_reference_type:
2855 return "DW_TAG_reference_type";
2856 case DW_TAG_compile_unit:
2857 return "DW_TAG_compile_unit";
2858 case DW_TAG_string_type:
2859 return "DW_TAG_string_type";
2860 case DW_TAG_structure_type:
2861 return "DW_TAG_structure_type";
2862 case DW_TAG_subroutine_type:
2863 return "DW_TAG_subroutine_type";
2864 case DW_TAG_typedef:
2865 return "DW_TAG_typedef";
2866 case DW_TAG_union_type:
2867 return "DW_TAG_union_type";
2868 case DW_TAG_unspecified_parameters:
2869 return "DW_TAG_unspecified_parameters";
2870 case DW_TAG_variant:
2871 return "DW_TAG_variant";
2872 case DW_TAG_common_block:
2873 return "DW_TAG_common_block";
2874 case DW_TAG_common_inclusion:
2875 return "DW_TAG_common_inclusion";
2876 case DW_TAG_inheritance:
2877 return "DW_TAG_inheritance";
2878 case DW_TAG_inlined_subroutine:
2879 return "DW_TAG_inlined_subroutine";
2881 return "DW_TAG_module";
2882 case DW_TAG_ptr_to_member_type:
2883 return "DW_TAG_ptr_to_member_type";
2884 case DW_TAG_set_type:
2885 return "DW_TAG_set_type";
2886 case DW_TAG_subrange_type:
2887 return "DW_TAG_subrange_type";
2888 case DW_TAG_with_stmt:
2889 return "DW_TAG_with_stmt";
2890 case DW_TAG_access_declaration:
2891 return "DW_TAG_access_declaration";
2892 case DW_TAG_base_type:
2893 return "DW_TAG_base_type";
2894 case DW_TAG_catch_block:
2895 return "DW_TAG_catch_block";
2896 case DW_TAG_const_type:
2897 return "DW_TAG_const_type";
2898 case DW_TAG_constant:
2899 return "DW_TAG_constant";
2900 case DW_TAG_enumerator:
2901 return "DW_TAG_enumerator";
2902 case DW_TAG_file_type:
2903 return "DW_TAG_file_type";
2905 return "DW_TAG_friend";
2906 case DW_TAG_namelist:
2907 return "DW_TAG_namelist";
2908 case DW_TAG_namelist_item:
2909 return "DW_TAG_namelist_item";
2910 case DW_TAG_packed_type:
2911 return "DW_TAG_packed_type";
2912 case DW_TAG_subprogram:
2913 return "DW_TAG_subprogram";
2914 case DW_TAG_template_type_param:
2915 return "DW_TAG_template_type_param";
2916 case DW_TAG_template_value_param:
2917 return "DW_TAG_template_value_param";
2918 case DW_TAG_thrown_type:
2919 return "DW_TAG_thrown_type";
2920 case DW_TAG_try_block:
2921 return "DW_TAG_try_block";
2922 case DW_TAG_variant_part:
2923 return "DW_TAG_variant_part";
2924 case DW_TAG_variable:
2925 return "DW_TAG_variable";
2926 case DW_TAG_volatile_type:
2927 return "DW_TAG_volatile_type";
2928 case DW_TAG_MIPS_loop:
2929 return "DW_TAG_MIPS_loop";
2930 case DW_TAG_format_label:
2931 return "DW_TAG_format_label";
2932 case DW_TAG_function_template:
2933 return "DW_TAG_function_template";
2934 case DW_TAG_class_template:
2935 return "DW_TAG_class_template";
2937 return "DW_TAG_<unknown>";
2941 /* Convert a DWARF attribute code into its string name. */
2944 dwarf_attr_name (attr)
2945 register unsigned attr;
2950 return "DW_AT_sibling";
2951 case DW_AT_location:
2952 return "DW_AT_location";
2954 return "DW_AT_name";
2955 case DW_AT_ordering:
2956 return "DW_AT_ordering";
2957 case DW_AT_subscr_data:
2958 return "DW_AT_subscr_data";
2959 case DW_AT_byte_size:
2960 return "DW_AT_byte_size";
2961 case DW_AT_bit_offset:
2962 return "DW_AT_bit_offset";
2963 case DW_AT_bit_size:
2964 return "DW_AT_bit_size";
2965 case DW_AT_element_list:
2966 return "DW_AT_element_list";
2967 case DW_AT_stmt_list:
2968 return "DW_AT_stmt_list";
2970 return "DW_AT_low_pc";
2972 return "DW_AT_high_pc";
2973 case DW_AT_language:
2974 return "DW_AT_language";
2976 return "DW_AT_member";
2978 return "DW_AT_discr";
2979 case DW_AT_discr_value:
2980 return "DW_AT_discr_value";
2981 case DW_AT_visibility:
2982 return "DW_AT_visibility";
2984 return "DW_AT_import";
2985 case DW_AT_string_length:
2986 return "DW_AT_string_length";
2987 case DW_AT_common_reference:
2988 return "DW_AT_common_reference";
2989 case DW_AT_comp_dir:
2990 return "DW_AT_comp_dir";
2991 case DW_AT_const_value:
2992 return "DW_AT_const_value";
2993 case DW_AT_containing_type:
2994 return "DW_AT_containing_type";
2995 case DW_AT_default_value:
2996 return "DW_AT_default_value";
2998 return "DW_AT_inline";
2999 case DW_AT_is_optional:
3000 return "DW_AT_is_optional";
3001 case DW_AT_lower_bound:
3002 return "DW_AT_lower_bound";
3003 case DW_AT_producer:
3004 return "DW_AT_producer";
3005 case DW_AT_prototyped:
3006 return "DW_AT_prototyped";
3007 case DW_AT_return_addr:
3008 return "DW_AT_return_addr";
3009 case DW_AT_start_scope:
3010 return "DW_AT_start_scope";
3011 case DW_AT_stride_size:
3012 return "DW_AT_stride_size";
3013 case DW_AT_upper_bound:
3014 return "DW_AT_upper_bound";
3015 case DW_AT_abstract_origin:
3016 return "DW_AT_abstract_origin";
3017 case DW_AT_accessibility:
3018 return "DW_AT_accessibility";
3019 case DW_AT_address_class:
3020 return "DW_AT_address_class";
3021 case DW_AT_artificial:
3022 return "DW_AT_artificial";
3023 case DW_AT_base_types:
3024 return "DW_AT_base_types";
3025 case DW_AT_calling_convention:
3026 return "DW_AT_calling_convention";
3028 return "DW_AT_count";
3029 case DW_AT_data_member_location:
3030 return "DW_AT_data_member_location";
3031 case DW_AT_decl_column:
3032 return "DW_AT_decl_column";
3033 case DW_AT_decl_file:
3034 return "DW_AT_decl_file";
3035 case DW_AT_decl_line:
3036 return "DW_AT_decl_line";
3037 case DW_AT_declaration:
3038 return "DW_AT_declaration";
3039 case DW_AT_discr_list:
3040 return "DW_AT_discr_list";
3041 case DW_AT_encoding:
3042 return "DW_AT_encoding";
3043 case DW_AT_external:
3044 return "DW_AT_external";
3045 case DW_AT_frame_base:
3046 return "DW_AT_frame_base";
3048 return "DW_AT_friend";
3049 case DW_AT_identifier_case:
3050 return "DW_AT_identifier_case";
3051 case DW_AT_macro_info:
3052 return "DW_AT_macro_info";
3053 case DW_AT_namelist_items:
3054 return "DW_AT_namelist_items";
3055 case DW_AT_priority:
3056 return "DW_AT_priority";
3058 return "DW_AT_segment";
3059 case DW_AT_specification:
3060 return "DW_AT_specification";
3061 case DW_AT_static_link:
3062 return "DW_AT_static_link";
3064 return "DW_AT_type";
3065 case DW_AT_use_location:
3066 return "DW_AT_use_location";
3067 case DW_AT_variable_parameter:
3068 return "DW_AT_variable_parameter";
3069 case DW_AT_virtuality:
3070 return "DW_AT_virtuality";
3071 case DW_AT_vtable_elem_location:
3072 return "DW_AT_vtable_elem_location";
3074 case DW_AT_MIPS_fde:
3075 return "DW_AT_MIPS_fde";
3076 case DW_AT_MIPS_loop_begin:
3077 return "DW_AT_MIPS_loop_begin";
3078 case DW_AT_MIPS_tail_loop_begin:
3079 return "DW_AT_MIPS_tail_loop_begin";
3080 case DW_AT_MIPS_epilog_begin:
3081 return "DW_AT_MIPS_epilog_begin";
3082 case DW_AT_MIPS_loop_unroll_factor:
3083 return "DW_AT_MIPS_loop_unroll_factor";
3084 case DW_AT_MIPS_software_pipeline_depth:
3085 return "DW_AT_MIPS_software_pipeline_depth";
3086 case DW_AT_MIPS_linkage_name:
3087 return "DW_AT_MIPS_linkage_name";
3088 case DW_AT_MIPS_stride:
3089 return "DW_AT_MIPS_stride";
3090 case DW_AT_MIPS_abstract_name:
3091 return "DW_AT_MIPS_abstract_name";
3092 case DW_AT_MIPS_clone_origin:
3093 return "DW_AT_MIPS_clone_origin";
3094 case DW_AT_MIPS_has_inlines:
3095 return "DW_AT_MIPS_has_inlines";
3097 case DW_AT_sf_names:
3098 return "DW_AT_sf_names";
3099 case DW_AT_src_info:
3100 return "DW_AT_src_info";
3101 case DW_AT_mac_info:
3102 return "DW_AT_mac_info";
3103 case DW_AT_src_coords:
3104 return "DW_AT_src_coords";
3105 case DW_AT_body_begin:
3106 return "DW_AT_body_begin";
3107 case DW_AT_body_end:
3108 return "DW_AT_body_end";
3110 return "DW_AT_<unknown>";
3114 /* Convert a DWARF value form code into its string name. */
3117 dwarf_form_name (form)
3118 register unsigned form;
3123 return "DW_FORM_addr";
3124 case DW_FORM_block2:
3125 return "DW_FORM_block2";
3126 case DW_FORM_block4:
3127 return "DW_FORM_block4";
3129 return "DW_FORM_data2";
3131 return "DW_FORM_data4";
3133 return "DW_FORM_data8";
3134 case DW_FORM_string:
3135 return "DW_FORM_string";
3137 return "DW_FORM_block";
3138 case DW_FORM_block1:
3139 return "DW_FORM_block1";
3141 return "DW_FORM_data1";
3143 return "DW_FORM_flag";
3145 return "DW_FORM_sdata";
3147 return "DW_FORM_strp";
3149 return "DW_FORM_udata";
3150 case DW_FORM_ref_addr:
3151 return "DW_FORM_ref_addr";
3153 return "DW_FORM_ref1";
3155 return "DW_FORM_ref2";
3157 return "DW_FORM_ref4";
3159 return "DW_FORM_ref8";
3160 case DW_FORM_ref_udata:
3161 return "DW_FORM_ref_udata";
3162 case DW_FORM_indirect:
3163 return "DW_FORM_indirect";
3165 return "DW_FORM_<unknown>";
3169 /* Convert a DWARF stack opcode into its string name. */
3172 dwarf_stack_op_name (op)
3173 register unsigned op;
3178 return "DW_OP_addr";
3180 return "DW_OP_deref";
3182 return "DW_OP_const1u";
3184 return "DW_OP_const1s";
3186 return "DW_OP_const2u";
3188 return "DW_OP_const2s";
3190 return "DW_OP_const4u";
3192 return "DW_OP_const4s";
3194 return "DW_OP_const8u";
3196 return "DW_OP_const8s";
3198 return "DW_OP_constu";
3200 return "DW_OP_consts";
3204 return "DW_OP_drop";
3206 return "DW_OP_over";
3208 return "DW_OP_pick";
3210 return "DW_OP_swap";
3214 return "DW_OP_xderef";
3222 return "DW_OP_minus";
3234 return "DW_OP_plus";
3235 case DW_OP_plus_uconst:
3236 return "DW_OP_plus_uconst";
3242 return "DW_OP_shra";
3260 return "DW_OP_skip";
3262 return "DW_OP_lit0";
3264 return "DW_OP_lit1";
3266 return "DW_OP_lit2";
3268 return "DW_OP_lit3";
3270 return "DW_OP_lit4";
3272 return "DW_OP_lit5";
3274 return "DW_OP_lit6";
3276 return "DW_OP_lit7";
3278 return "DW_OP_lit8";
3280 return "DW_OP_lit9";
3282 return "DW_OP_lit10";
3284 return "DW_OP_lit11";
3286 return "DW_OP_lit12";
3288 return "DW_OP_lit13";
3290 return "DW_OP_lit14";
3292 return "DW_OP_lit15";
3294 return "DW_OP_lit16";
3296 return "DW_OP_lit17";
3298 return "DW_OP_lit18";
3300 return "DW_OP_lit19";
3302 return "DW_OP_lit20";
3304 return "DW_OP_lit21";
3306 return "DW_OP_lit22";
3308 return "DW_OP_lit23";
3310 return "DW_OP_lit24";
3312 return "DW_OP_lit25";
3314 return "DW_OP_lit26";
3316 return "DW_OP_lit27";
3318 return "DW_OP_lit28";
3320 return "DW_OP_lit29";
3322 return "DW_OP_lit30";
3324 return "DW_OP_lit31";
3326 return "DW_OP_reg0";
3328 return "DW_OP_reg1";
3330 return "DW_OP_reg2";
3332 return "DW_OP_reg3";
3334 return "DW_OP_reg4";
3336 return "DW_OP_reg5";
3338 return "DW_OP_reg6";
3340 return "DW_OP_reg7";
3342 return "DW_OP_reg8";
3344 return "DW_OP_reg9";
3346 return "DW_OP_reg10";
3348 return "DW_OP_reg11";
3350 return "DW_OP_reg12";
3352 return "DW_OP_reg13";
3354 return "DW_OP_reg14";
3356 return "DW_OP_reg15";
3358 return "DW_OP_reg16";
3360 return "DW_OP_reg17";
3362 return "DW_OP_reg18";
3364 return "DW_OP_reg19";
3366 return "DW_OP_reg20";
3368 return "DW_OP_reg21";
3370 return "DW_OP_reg22";
3372 return "DW_OP_reg23";
3374 return "DW_OP_reg24";
3376 return "DW_OP_reg25";
3378 return "DW_OP_reg26";
3380 return "DW_OP_reg27";
3382 return "DW_OP_reg28";
3384 return "DW_OP_reg29";
3386 return "DW_OP_reg30";
3388 return "DW_OP_reg31";
3390 return "DW_OP_breg0";
3392 return "DW_OP_breg1";
3394 return "DW_OP_breg2";
3396 return "DW_OP_breg3";
3398 return "DW_OP_breg4";
3400 return "DW_OP_breg5";
3402 return "DW_OP_breg6";
3404 return "DW_OP_breg7";
3406 return "DW_OP_breg8";
3408 return "DW_OP_breg9";
3410 return "DW_OP_breg10";
3412 return "DW_OP_breg11";
3414 return "DW_OP_breg12";
3416 return "DW_OP_breg13";
3418 return "DW_OP_breg14";
3420 return "DW_OP_breg15";
3422 return "DW_OP_breg16";
3424 return "DW_OP_breg17";
3426 return "DW_OP_breg18";
3428 return "DW_OP_breg19";
3430 return "DW_OP_breg20";
3432 return "DW_OP_breg21";
3434 return "DW_OP_breg22";
3436 return "DW_OP_breg23";
3438 return "DW_OP_breg24";
3440 return "DW_OP_breg25";
3442 return "DW_OP_breg26";
3444 return "DW_OP_breg27";
3446 return "DW_OP_breg28";
3448 return "DW_OP_breg29";
3450 return "DW_OP_breg30";
3452 return "DW_OP_breg31";
3454 return "DW_OP_regx";
3456 return "DW_OP_fbreg";
3458 return "DW_OP_bregx";
3460 return "DW_OP_piece";
3461 case DW_OP_deref_size:
3462 return "DW_OP_deref_size";
3463 case DW_OP_xderef_size:
3464 return "DW_OP_xderef_size";
3468 return "OP_<unknown>";
3472 /* Convert a DWARF type code into its string name. */
3476 dwarf_type_encoding_name (enc)
3477 register unsigned enc;
3481 case DW_ATE_address:
3482 return "DW_ATE_address";
3483 case DW_ATE_boolean:
3484 return "DW_ATE_boolean";
3485 case DW_ATE_complex_float:
3486 return "DW_ATE_complex_float";
3488 return "DW_ATE_float";
3490 return "DW_ATE_signed";
3491 case DW_ATE_signed_char:
3492 return "DW_ATE_signed_char";
3493 case DW_ATE_unsigned:
3494 return "DW_ATE_unsigned";
3495 case DW_ATE_unsigned_char:
3496 return "DW_ATE_unsigned_char";
3498 return "DW_ATE_<unknown>";
3503 /* Determine the "ultimate origin" of a decl. The decl may be an inlined
3504 instance of an inlined instance of a decl which is local to an inline
3505 function, so we have to trace all of the way back through the origin chain
3506 to find out what sort of node actually served as the original seed for the
3510 decl_ultimate_origin (decl)
3513 /* output_inline_function sets DECL_ABSTRACT_ORIGIN for all the
3514 nodes in the function to point to themselves; ignore that if
3515 we're trying to output the abstract instance of this function. */
3516 if (DECL_ABSTRACT (decl) && DECL_ABSTRACT_ORIGIN (decl) == decl)
3519 #ifdef ENABLE_CHECKING
3520 if (DECL_FROM_INLINE (DECL_ORIGIN (decl)))
3521 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
3522 most distant ancestor, this should never happen. */
3526 return DECL_ABSTRACT_ORIGIN (decl);
3529 /* Determine the "ultimate origin" of a block. The block may be an inlined
3530 instance of an inlined instance of a block which is local to an inline
3531 function, so we have to trace all of the way back through the origin chain
3532 to find out what sort of node actually served as the original seed for the
3536 block_ultimate_origin (block)
3537 register tree block;
3539 register tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block);
3541 /* output_inline_function sets BLOCK_ABSTRACT_ORIGIN for all the
3542 nodes in the function to point to themselves; ignore that if
3543 we're trying to output the abstract instance of this function. */
3544 if (BLOCK_ABSTRACT (block) && immediate_origin == block)
3547 if (immediate_origin == NULL_TREE)
3551 register tree ret_val;
3552 register tree lookahead = immediate_origin;
3556 ret_val = lookahead;
3557 lookahead = (TREE_CODE (ret_val) == BLOCK)
3558 ? BLOCK_ABSTRACT_ORIGIN (ret_val)
3561 while (lookahead != NULL && lookahead != ret_val);
3567 /* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT
3568 of a virtual function may refer to a base class, so we check the 'this'
3572 decl_class_context (decl)
3575 tree context = NULL_TREE;
3577 if (TREE_CODE (decl) != FUNCTION_DECL || ! DECL_VINDEX (decl))
3578 context = DECL_CONTEXT (decl);
3580 context = TYPE_MAIN_VARIANT
3581 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
3583 if (context && TREE_CODE_CLASS (TREE_CODE (context)) != 't')
3584 context = NULL_TREE;
3589 /* Add an attribute/value pair to a DIE. We build the lists up in reverse
3590 addition order, and correct that in add_sibling_attributes. */
3593 add_dwarf_attr (die, attr)
3594 register dw_die_ref die;
3595 register dw_attr_ref attr;
3597 if (die != NULL && attr != NULL)
3599 attr->dw_attr_next = die->die_attr;
3600 die->die_attr = attr;
3604 static inline dw_val_class
3608 return a->dw_attr_val.val_class;
3611 /* Add a flag value attribute to a DIE. */
3614 add_AT_flag (die, attr_kind, flag)
3615 register dw_die_ref die;
3616 register enum dwarf_attribute attr_kind;
3617 register unsigned flag;
3619 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3621 attr->dw_attr_next = NULL;
3622 attr->dw_attr = attr_kind;
3623 attr->dw_attr_val.val_class = dw_val_class_flag;
3624 attr->dw_attr_val.v.val_flag = flag;
3625 add_dwarf_attr (die, attr);
3628 static inline unsigned
3630 register dw_attr_ref a;
3632 if (a && AT_class (a) == dw_val_class_flag)
3633 return a->dw_attr_val.v.val_flag;
3638 /* Add a signed integer attribute value to a DIE. */
3641 add_AT_int (die, attr_kind, int_val)
3642 register dw_die_ref die;
3643 register enum dwarf_attribute attr_kind;
3644 register long int int_val;
3646 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3648 attr->dw_attr_next = NULL;
3649 attr->dw_attr = attr_kind;
3650 attr->dw_attr_val.val_class = dw_val_class_const;
3651 attr->dw_attr_val.v.val_int = int_val;
3652 add_dwarf_attr (die, attr);
3655 static inline long int
3657 register dw_attr_ref a;
3659 if (a && AT_class (a) == dw_val_class_const)
3660 return a->dw_attr_val.v.val_int;
3665 /* Add an unsigned integer attribute value to a DIE. */
3668 add_AT_unsigned (die, attr_kind, unsigned_val)
3669 register dw_die_ref die;
3670 register enum dwarf_attribute attr_kind;
3671 register unsigned long unsigned_val;
3673 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3675 attr->dw_attr_next = NULL;
3676 attr->dw_attr = attr_kind;
3677 attr->dw_attr_val.val_class = dw_val_class_unsigned_const;
3678 attr->dw_attr_val.v.val_unsigned = unsigned_val;
3679 add_dwarf_attr (die, attr);
3682 static inline unsigned long
3684 register dw_attr_ref a;
3686 if (a && AT_class (a) == dw_val_class_unsigned_const)
3687 return a->dw_attr_val.v.val_unsigned;
3692 /* Add an unsigned double integer attribute value to a DIE. */
3695 add_AT_long_long (die, attr_kind, val_hi, val_low)
3696 register dw_die_ref die;
3697 register enum dwarf_attribute attr_kind;
3698 register unsigned long val_hi;
3699 register unsigned long val_low;
3701 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3703 attr->dw_attr_next = NULL;
3704 attr->dw_attr = attr_kind;
3705 attr->dw_attr_val.val_class = dw_val_class_long_long;
3706 attr->dw_attr_val.v.val_long_long.hi = val_hi;
3707 attr->dw_attr_val.v.val_long_long.low = val_low;
3708 add_dwarf_attr (die, attr);
3711 /* Add a floating point attribute value to a DIE and return it. */
3714 add_AT_float (die, attr_kind, length, array)
3715 register dw_die_ref die;
3716 register enum dwarf_attribute attr_kind;
3717 register unsigned length;
3718 register long *array;
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_float;
3725 attr->dw_attr_val.v.val_float.length = length;
3726 attr->dw_attr_val.v.val_float.array = array;
3727 add_dwarf_attr (die, attr);
3730 /* Add a string attribute value to a DIE. */
3733 add_AT_string (die, attr_kind, str)
3734 register dw_die_ref die;
3735 register enum dwarf_attribute attr_kind;
3736 register const char *str;
3738 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3740 attr->dw_attr_next = NULL;
3741 attr->dw_attr = attr_kind;
3742 attr->dw_attr_val.val_class = dw_val_class_str;
3743 attr->dw_attr_val.v.val_str = xstrdup (str);
3744 add_dwarf_attr (die, attr);
3747 static inline const char *
3749 register dw_attr_ref a;
3751 if (a && AT_class (a) == dw_val_class_str)
3752 return a->dw_attr_val.v.val_str;
3757 /* Add a DIE reference attribute value to a DIE. */
3760 add_AT_die_ref (die, attr_kind, targ_die)
3761 register dw_die_ref die;
3762 register enum dwarf_attribute attr_kind;
3763 register dw_die_ref targ_die;
3765 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3767 attr->dw_attr_next = NULL;
3768 attr->dw_attr = attr_kind;
3769 attr->dw_attr_val.val_class = dw_val_class_die_ref;
3770 attr->dw_attr_val.v.val_die_ref = targ_die;
3771 add_dwarf_attr (die, attr);
3774 static inline dw_die_ref
3776 register dw_attr_ref a;
3778 if (a && AT_class (a) == dw_val_class_die_ref)
3779 return a->dw_attr_val.v.val_die_ref;
3784 /* Add an FDE reference attribute value to a DIE. */
3787 add_AT_fde_ref (die, attr_kind, targ_fde)
3788 register dw_die_ref die;
3789 register enum dwarf_attribute attr_kind;
3790 register unsigned targ_fde;
3792 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3794 attr->dw_attr_next = NULL;
3795 attr->dw_attr = attr_kind;
3796 attr->dw_attr_val.val_class = dw_val_class_fde_ref;
3797 attr->dw_attr_val.v.val_fde_index = targ_fde;
3798 add_dwarf_attr (die, attr);
3801 /* Add a location description attribute value to a DIE. */
3804 add_AT_loc (die, attr_kind, loc)
3805 register dw_die_ref die;
3806 register enum dwarf_attribute attr_kind;
3807 register dw_loc_descr_ref loc;
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_loc;
3814 attr->dw_attr_val.v.val_loc = loc;
3815 add_dwarf_attr (die, attr);
3818 static inline dw_loc_descr_ref
3820 register dw_attr_ref a;
3822 if (a && AT_class (a) == dw_val_class_loc)
3823 return a->dw_attr_val.v.val_loc;
3828 /* Add an address constant attribute value to a DIE. */
3831 add_AT_addr (die, attr_kind, addr)
3832 register dw_die_ref die;
3833 register enum dwarf_attribute attr_kind;
3836 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3838 attr->dw_attr_next = NULL;
3839 attr->dw_attr = attr_kind;
3840 attr->dw_attr_val.val_class = dw_val_class_addr;
3841 attr->dw_attr_val.v.val_addr = addr;
3842 add_dwarf_attr (die, attr);
3845 static inline const char *
3847 register dw_attr_ref a;
3849 if (a && AT_class (a) == dw_val_class_addr)
3850 return a->dw_attr_val.v.val_addr;
3855 /* Add a label identifier attribute value to a DIE. */
3858 add_AT_lbl_id (die, attr_kind, lbl_id)
3859 register dw_die_ref die;
3860 register enum dwarf_attribute attr_kind;
3861 register char *lbl_id;
3863 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3865 attr->dw_attr_next = NULL;
3866 attr->dw_attr = attr_kind;
3867 attr->dw_attr_val.val_class = dw_val_class_lbl_id;
3868 attr->dw_attr_val.v.val_lbl_id = xstrdup (lbl_id);
3869 add_dwarf_attr (die, attr);
3872 /* Add a section offset attribute value to a DIE. */
3875 add_AT_lbl_offset (die, attr_kind, label)
3876 register dw_die_ref die;
3877 register enum dwarf_attribute attr_kind;
3878 register char *label;
3880 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3882 attr->dw_attr_next = NULL;
3883 attr->dw_attr = attr_kind;
3884 attr->dw_attr_val.val_class = dw_val_class_lbl_offset;
3885 attr->dw_attr_val.v.val_lbl_id = xstrdup (label);
3886 add_dwarf_attr (die, attr);
3890 static inline const char *
3892 register dw_attr_ref a;
3894 if (a && (AT_class (a) == dw_val_class_lbl_id
3895 || AT_class (a) == dw_val_class_lbl_offset))
3896 return a->dw_attr_val.v.val_lbl_id;
3901 /* Get the attribute of type attr_kind. */
3903 static inline dw_attr_ref
3904 get_AT (die, attr_kind)
3905 register dw_die_ref die;
3906 register enum dwarf_attribute attr_kind;
3908 register dw_attr_ref a;
3909 register dw_die_ref spec = NULL;
3913 for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
3915 if (a->dw_attr == attr_kind)
3918 if (a->dw_attr == DW_AT_specification
3919 || a->dw_attr == DW_AT_abstract_origin)
3924 return get_AT (spec, attr_kind);
3930 /* Return the "low pc" attribute value, typically associated with
3931 a subprogram DIE. Return null if the "low pc" attribute is
3932 either not prsent, or if it cannot be represented as an
3933 assembler label identifier. */
3935 static inline const char *
3937 register dw_die_ref die;
3939 register dw_attr_ref a = get_AT (die, DW_AT_low_pc);
3943 /* Return the "high pc" attribute value, typically associated with
3944 a subprogram DIE. Return null if the "high pc" attribute is
3945 either not prsent, or if it cannot be represented as an
3946 assembler label identifier. */
3948 static inline const char *
3950 register dw_die_ref die;
3952 register dw_attr_ref a = get_AT (die, DW_AT_high_pc);
3956 /* Return the value of the string attribute designated by ATTR_KIND, or
3957 NULL if it is not present. */
3959 static inline const char *
3960 get_AT_string (die, attr_kind)
3961 register dw_die_ref die;
3962 register enum dwarf_attribute attr_kind;
3964 register dw_attr_ref a = get_AT (die, attr_kind);
3965 return AT_string (a);
3968 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
3969 if it is not present. */
3972 get_AT_flag (die, attr_kind)
3973 register dw_die_ref die;
3974 register enum dwarf_attribute attr_kind;
3976 register dw_attr_ref a = get_AT (die, attr_kind);
3980 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
3981 if it is not present. */
3983 static inline unsigned
3984 get_AT_unsigned (die, attr_kind)
3985 register dw_die_ref die;
3986 register enum dwarf_attribute attr_kind;
3988 register dw_attr_ref a = get_AT (die, attr_kind);
3989 return AT_unsigned (a);
3992 static inline dw_die_ref
3993 get_AT_ref (die, attr_kind)
3995 register enum dwarf_attribute attr_kind;
3997 register dw_attr_ref a = get_AT (die, attr_kind);
4004 register unsigned lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
4006 return (lang == DW_LANG_C || lang == DW_LANG_C89
4007 || lang == DW_LANG_C_plus_plus);
4013 register unsigned lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
4015 return (lang == DW_LANG_Fortran77 || lang == DW_LANG_Fortran90);
4018 /* Free up the memory used by A. */
4024 switch (AT_class (a))
4026 case dw_val_class_addr:
4027 case dw_val_class_str:
4028 case dw_val_class_lbl_id:
4029 case dw_val_class_lbl_offset:
4030 free (a->dw_attr_val.v.val_str);
4040 /* Remove the specified attribute if present. */
4043 remove_AT (die, attr_kind)
4044 register dw_die_ref die;
4045 register enum dwarf_attribute attr_kind;
4047 register dw_attr_ref *p;
4048 register dw_attr_ref removed = NULL;
4052 for (p = &(die->die_attr); *p; p = &((*p)->dw_attr_next))
4053 if ((*p)->dw_attr == attr_kind)
4056 *p = (*p)->dw_attr_next;
4065 /* Free up the memory used by DIE. */
4071 remove_children (die);
4075 /* Discard the children of this DIE. */
4078 remove_children (die)
4079 register dw_die_ref die;
4081 register dw_die_ref child_die = die->die_child;
4083 die->die_child = NULL;
4085 while (child_die != NULL)
4087 register dw_die_ref tmp_die = child_die;
4088 register dw_attr_ref a;
4090 child_die = child_die->die_sib;
4092 for (a = tmp_die->die_attr; a != NULL; )
4094 register dw_attr_ref tmp_a = a;
4096 a = a->dw_attr_next;
4104 /* Add a child DIE below its parent. We build the lists up in reverse
4105 addition order, and correct that in add_sibling_attributes. */
4108 add_child_die (die, child_die)
4109 register dw_die_ref die;
4110 register dw_die_ref child_die;
4112 if (die != NULL && child_die != NULL)
4114 if (die == child_die)
4116 child_die->die_parent = die;
4117 child_die->die_sib = die->die_child;
4118 die->die_child = child_die;
4122 /* Move CHILD, which must be a child of PARENT or the DIE for which PARENT
4123 is the specification, to the front of PARENT's list of children. */
4126 splice_child_die (parent, child)
4127 dw_die_ref parent, child;
4131 /* We want the declaration DIE from inside the class, not the
4132 specification DIE at toplevel. */
4133 if (child->die_parent != parent)
4135 dw_die_ref tmp = get_AT_ref (child, DW_AT_specification);
4140 if (child->die_parent != parent
4141 && child->die_parent != get_AT_ref (parent, DW_AT_specification))
4144 for (p = &(parent->die_child); *p; p = &((*p)->die_sib))
4147 *p = child->die_sib;
4151 child->die_sib = parent->die_child;
4152 parent->die_child = child;
4155 /* Return a pointer to a newly created DIE node. */
4157 static inline dw_die_ref
4158 new_die (tag_value, parent_die)
4159 register enum dwarf_tag tag_value;
4160 register dw_die_ref parent_die;
4162 register dw_die_ref die = (dw_die_ref) xmalloc (sizeof (die_node));
4164 die->die_tag = tag_value;
4165 die->die_abbrev = 0;
4166 die->die_offset = 0;
4167 die->die_child = NULL;
4168 die->die_parent = NULL;
4169 die->die_sib = NULL;
4170 die->die_attr = NULL;
4172 if (parent_die != NULL)
4173 add_child_die (parent_die, die);
4176 limbo_die_node *limbo_node;
4178 limbo_node = (limbo_die_node *) xmalloc (sizeof (limbo_die_node));
4179 limbo_node->die = die;
4180 limbo_node->next = limbo_die_list;
4181 limbo_die_list = limbo_node;
4187 /* Return the DIE associated with the given type specifier. */
4189 static inline dw_die_ref
4190 lookup_type_die (type)
4193 return (dw_die_ref) TYPE_SYMTAB_POINTER (type);
4196 /* Equate a DIE to a given type specifier. */
4199 equate_type_number_to_die (type, type_die)
4201 register dw_die_ref type_die;
4203 TYPE_SYMTAB_POINTER (type) = (char *) type_die;
4206 /* Return the DIE associated with a given declaration. */
4208 static inline dw_die_ref
4209 lookup_decl_die (decl)
4212 register unsigned decl_id = DECL_UID (decl);
4214 return (decl_id < decl_die_table_in_use
4215 ? decl_die_table[decl_id] : NULL);
4218 /* Equate a DIE to a particular declaration. */
4221 equate_decl_number_to_die (decl, decl_die)
4223 register dw_die_ref decl_die;
4225 register unsigned decl_id = DECL_UID (decl);
4226 register unsigned num_allocated;
4228 if (decl_id >= decl_die_table_allocated)
4231 = ((decl_id + 1 + DECL_DIE_TABLE_INCREMENT - 1)
4232 / DECL_DIE_TABLE_INCREMENT)
4233 * DECL_DIE_TABLE_INCREMENT;
4236 = (dw_die_ref *) xrealloc (decl_die_table,
4237 sizeof (dw_die_ref) * num_allocated);
4239 bzero ((char *) &decl_die_table[decl_die_table_allocated],
4240 (num_allocated - decl_die_table_allocated) * sizeof (dw_die_ref));
4241 decl_die_table_allocated = num_allocated;
4244 if (decl_id >= decl_die_table_in_use)
4245 decl_die_table_in_use = (decl_id + 1);
4247 decl_die_table[decl_id] = decl_die;
4250 /* Return a pointer to a newly allocated location description. Location
4251 descriptions are simple expression terms that can be strung
4252 together to form more complicated location (address) descriptions. */
4254 static inline dw_loc_descr_ref
4255 new_loc_descr (op, oprnd1, oprnd2)
4256 register enum dwarf_location_atom op;
4257 register unsigned long oprnd1;
4258 register unsigned long oprnd2;
4260 register dw_loc_descr_ref descr
4261 = (dw_loc_descr_ref) xmalloc (sizeof (dw_loc_descr_node));
4263 descr->dw_loc_next = NULL;
4264 descr->dw_loc_opc = op;
4265 descr->dw_loc_oprnd1.val_class = dw_val_class_unsigned_const;
4266 descr->dw_loc_oprnd1.v.val_unsigned = oprnd1;
4267 descr->dw_loc_oprnd2.val_class = dw_val_class_unsigned_const;
4268 descr->dw_loc_oprnd2.v.val_unsigned = oprnd2;
4273 /* Add a location description term to a location description expression. */
4276 add_loc_descr (list_head, descr)
4277 register dw_loc_descr_ref *list_head;
4278 register dw_loc_descr_ref descr;
4280 register dw_loc_descr_ref *d;
4282 /* Find the end of the chain. */
4283 for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
4289 /* Keep track of the number of spaces used to indent the
4290 output of the debugging routines that print the structure of
4291 the DIE internal representation. */
4292 static int print_indent;
4294 /* Indent the line the number of spaces given by print_indent. */
4297 print_spaces (outfile)
4300 fprintf (outfile, "%*s", print_indent, "");
4303 /* Print the information associated with a given DIE, and its children.
4304 This routine is a debugging aid only. */
4307 print_die (die, outfile)
4311 register dw_attr_ref a;
4312 register dw_die_ref c;
4314 print_spaces (outfile);
4315 fprintf (outfile, "DIE %4lu: %s\n",
4316 die->die_offset, dwarf_tag_name (die->die_tag));
4317 print_spaces (outfile);
4318 fprintf (outfile, " abbrev id: %lu", die->die_abbrev);
4319 fprintf (outfile, " offset: %lu\n", die->die_offset);
4321 for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
4323 print_spaces (outfile);
4324 fprintf (outfile, " %s: ", dwarf_attr_name (a->dw_attr));
4326 switch (AT_class (a))
4328 case dw_val_class_addr:
4329 fprintf (outfile, "address");
4331 case dw_val_class_loc:
4332 fprintf (outfile, "location descriptor");
4334 case dw_val_class_const:
4335 fprintf (outfile, "%ld", AT_int (a));
4337 case dw_val_class_unsigned_const:
4338 fprintf (outfile, "%lu", AT_unsigned (a));
4340 case dw_val_class_long_long:
4341 fprintf (outfile, "constant (%lu,%lu)",
4342 a->dw_attr_val.v.val_long_long.hi,
4343 a->dw_attr_val.v.val_long_long.low);
4345 case dw_val_class_float:
4346 fprintf (outfile, "floating-point constant");
4348 case dw_val_class_flag:
4349 fprintf (outfile, "%u", AT_flag (a));
4351 case dw_val_class_die_ref:
4352 if (AT_ref (a) != NULL)
4353 fprintf (outfile, "die -> %lu", AT_ref (a)->die_offset);
4355 fprintf (outfile, "die -> <null>");
4357 case dw_val_class_lbl_id:
4358 case dw_val_class_lbl_offset:
4359 fprintf (outfile, "label: %s", AT_lbl (a));
4361 case dw_val_class_str:
4362 if (AT_string (a) != NULL)
4363 fprintf (outfile, "\"%s\"", AT_string (a));
4365 fprintf (outfile, "<null>");
4371 fprintf (outfile, "\n");
4374 if (die->die_child != NULL)
4377 for (c = die->die_child; c != NULL; c = c->die_sib)
4378 print_die (c, outfile);
4384 /* Print the contents of the source code line number correspondence table.
4385 This routine is a debugging aid only. */
4388 print_dwarf_line_table (outfile)
4391 register unsigned i;
4392 register dw_line_info_ref line_info;
4394 fprintf (outfile, "\n\nDWARF source line information\n");
4395 for (i = 1; i < line_info_table_in_use; ++i)
4397 line_info = &line_info_table[i];
4398 fprintf (outfile, "%5d: ", i);
4399 fprintf (outfile, "%-20s", file_table[line_info->dw_file_num]);
4400 fprintf (outfile, "%6ld", line_info->dw_line_num);
4401 fprintf (outfile, "\n");
4404 fprintf (outfile, "\n\n");
4407 /* Print the information collected for a given DIE. */
4410 debug_dwarf_die (die)
4413 print_die (die, stderr);
4416 /* Print all DWARF information collected for the compilation unit.
4417 This routine is a debugging aid only. */
4423 print_die (comp_unit_die, stderr);
4424 if (! DWARF2_ASM_LINE_DEBUG_INFO)
4425 print_dwarf_line_table (stderr);
4428 /* We build up the lists of children and attributes by pushing new ones
4429 onto the beginning of the list. Reverse the lists for DIE so that
4430 they are in order of addition. */
4433 reverse_die_lists (die)
4434 register dw_die_ref die;
4436 register dw_die_ref c, cp, cn;
4437 register dw_attr_ref a, ap, an;
4439 for (a = die->die_attr, ap = 0; a; a = an)
4441 an = a->dw_attr_next;
4442 a->dw_attr_next = ap;
4447 for (c = die->die_child, cp = 0; c; c = cn)
4453 die->die_child = cp;
4456 /* Traverse the DIE, reverse its lists of attributes and children, and
4457 add a sibling attribute if it may have the effect of speeding up
4458 access to siblings. To save some space, avoid generating sibling
4459 attributes for DIE's without children. */
4462 add_sibling_attributes (die)
4463 register dw_die_ref die;
4465 register dw_die_ref c;
4467 reverse_die_lists (die);
4469 if (die != comp_unit_die && die->die_sib && die->die_child != NULL)
4470 /* Add the sibling link to the front of the attribute list. */
4471 add_AT_die_ref (die, DW_AT_sibling, die->die_sib);
4473 for (c = die->die_child; c != NULL; c = c->die_sib)
4474 add_sibling_attributes (c);
4477 /* The format of each DIE (and its attribute value pairs)
4478 is encoded in an abbreviation table. This routine builds the
4479 abbreviation table and assigns a unique abbreviation id for
4480 each abbreviation entry. The children of each die are visited
4484 build_abbrev_table (die)
4485 register dw_die_ref die;
4487 register unsigned long abbrev_id;
4488 register unsigned long n_alloc;
4489 register dw_die_ref c;
4490 register dw_attr_ref d_attr, a_attr;
4491 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
4493 register dw_die_ref abbrev = abbrev_die_table[abbrev_id];
4495 if (abbrev->die_tag == die->die_tag)
4497 if ((abbrev->die_child != NULL) == (die->die_child != NULL))
4499 a_attr = abbrev->die_attr;
4500 d_attr = die->die_attr;
4502 while (a_attr != NULL && d_attr != NULL)
4504 if ((a_attr->dw_attr != d_attr->dw_attr)
4505 || (value_format (a_attr) != value_format (d_attr)))
4508 a_attr = a_attr->dw_attr_next;
4509 d_attr = d_attr->dw_attr_next;
4512 if (a_attr == NULL && d_attr == NULL)
4518 if (abbrev_id >= abbrev_die_table_in_use)
4520 if (abbrev_die_table_in_use >= abbrev_die_table_allocated)
4522 n_alloc = abbrev_die_table_allocated + ABBREV_DIE_TABLE_INCREMENT;
4524 = (dw_die_ref *) xrealloc (abbrev_die_table,
4525 sizeof (dw_die_ref) * n_alloc);
4527 bzero ((char *) &abbrev_die_table[abbrev_die_table_allocated],
4528 (n_alloc - abbrev_die_table_allocated) * sizeof (dw_die_ref));
4529 abbrev_die_table_allocated = n_alloc;
4532 ++abbrev_die_table_in_use;
4533 abbrev_die_table[abbrev_id] = die;
4536 die->die_abbrev = abbrev_id;
4537 for (c = die->die_child; c != NULL; c = c->die_sib)
4538 build_abbrev_table (c);
4541 /* Return the size of a string, including the null byte.
4543 This used to treat backslashes as escapes, and hence they were not included
4544 in the count. However, that conflicts with what ASM_OUTPUT_ASCII does,
4545 which treats a backslash as a backslash, escaping it if necessary, and hence
4546 we must include them in the count. */
4548 static unsigned long
4549 size_of_string (str)
4550 register const char *str;
4552 return strlen (str) + 1;
4555 /* Return the size of a location descriptor. */
4557 static unsigned long
4558 size_of_loc_descr (loc)
4559 register dw_loc_descr_ref loc;
4561 register unsigned long size = 1;
4563 switch (loc->dw_loc_opc)
4585 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4588 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
4593 case DW_OP_plus_uconst:
4594 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4632 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
4635 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4638 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
4641 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4642 size += size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int);
4645 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4647 case DW_OP_deref_size:
4648 case DW_OP_xderef_size:
4658 /* Return the size of a series of location descriptors. */
4660 static unsigned long
4662 register dw_loc_descr_ref loc;
4664 register unsigned long size = 0;
4666 for (; loc != NULL; loc = loc->dw_loc_next)
4667 size += size_of_loc_descr (loc);
4672 /* Return the power-of-two number of bytes necessary to represent VALUE. */
4675 constant_size (value)
4676 long unsigned value;
4683 log = floor_log2 (value);
4686 log = 1 << (floor_log2 (log) + 1);
4691 /* Return the size of a DIE, as it is represented in the
4692 .debug_info section. */
4694 static unsigned long
4696 register dw_die_ref die;
4698 register unsigned long size = 0;
4699 register dw_attr_ref a;
4701 size += size_of_uleb128 (die->die_abbrev);
4702 for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
4704 switch (AT_class (a))
4706 case dw_val_class_addr:
4709 case dw_val_class_loc:
4711 register unsigned long lsize = size_of_locs (AT_loc (a));
4714 size += constant_size (lsize);
4718 case dw_val_class_const:
4721 case dw_val_class_unsigned_const:
4722 size += constant_size (AT_unsigned (a));
4724 case dw_val_class_long_long:
4725 size += 1 + 8; /* block */
4727 case dw_val_class_float:
4728 size += 1 + a->dw_attr_val.v.val_float.length * 4; /* block */
4730 case dw_val_class_flag:
4733 case dw_val_class_die_ref:
4734 size += DWARF_OFFSET_SIZE;
4736 case dw_val_class_fde_ref:
4737 size += DWARF_OFFSET_SIZE;
4739 case dw_val_class_lbl_id:
4742 case dw_val_class_lbl_offset:
4743 size += DWARF_OFFSET_SIZE;
4745 case dw_val_class_str:
4746 size += size_of_string (AT_string (a));
4756 /* Size the debugging information associated with a given DIE.
4757 Visits the DIE's children recursively. Updates the global
4758 variable next_die_offset, on each time through. Uses the
4759 current value of next_die_offset to update the die_offset
4760 field in each DIE. */
4763 calc_die_sizes (die)
4766 register dw_die_ref c;
4767 die->die_offset = next_die_offset;
4768 next_die_offset += size_of_die (die);
4770 for (c = die->die_child; c != NULL; c = c->die_sib)
4773 if (die->die_child != NULL)
4774 /* Count the null byte used to terminate sibling lists. */
4775 next_die_offset += 1;
4778 /* Return the size of the line information prolog generated for the
4779 compilation unit. */
4781 static unsigned long
4782 size_of_line_prolog ()
4784 register unsigned long size;
4785 register unsigned long ft_index;
4787 size = DWARF_LINE_PROLOG_HEADER_SIZE;
4789 /* Count the size of the table giving number of args for each
4791 size += DWARF_LINE_OPCODE_BASE - 1;
4793 /* Include directory table is empty (at present). Count only the
4794 null byte used to terminate the table. */
4797 for (ft_index = 1; ft_index < file_table_in_use; ++ft_index)
4799 /* File name entry. */
4800 size += size_of_string (file_table[ft_index]);
4802 /* Include directory index. */
4803 size += size_of_uleb128 (0);
4805 /* Modification time. */
4806 size += size_of_uleb128 (0);
4808 /* File length in bytes. */
4809 size += size_of_uleb128 (0);
4812 /* Count the file table terminator. */
4817 /* Return the size of the .debug_pubnames table generated for the
4818 compilation unit. */
4820 static unsigned long
4823 register unsigned long size;
4824 register unsigned i;
4826 size = DWARF_PUBNAMES_HEADER_SIZE;
4827 for (i = 0; i < pubname_table_in_use; ++i)
4829 register pubname_ref p = &pubname_table[i];
4830 size += DWARF_OFFSET_SIZE + size_of_string (p->name);
4833 size += DWARF_OFFSET_SIZE;
4837 /* Return the size of the information in the .debug_aranges section. */
4839 static unsigned long
4842 register unsigned long size;
4844 size = DWARF_ARANGES_HEADER_SIZE;
4846 /* Count the address/length pair for this compilation unit. */
4847 size += 2 * PTR_SIZE;
4848 size += 2 * PTR_SIZE * arange_table_in_use;
4850 /* Count the two zero words used to terminated the address range table. */
4851 size += 2 * PTR_SIZE;
4855 /* Select the encoding of an attribute value. */
4857 static enum dwarf_form
4861 switch (a->dw_attr_val.val_class)
4863 case dw_val_class_addr:
4864 return DW_FORM_addr;
4865 case dw_val_class_loc:
4866 switch (constant_size (size_of_locs (AT_loc (a))))
4869 return DW_FORM_block1;
4871 return DW_FORM_block2;
4875 case dw_val_class_const:
4876 return DW_FORM_data4;
4877 case dw_val_class_unsigned_const:
4878 switch (constant_size (AT_unsigned (a)))
4881 return DW_FORM_data1;
4883 return DW_FORM_data2;
4885 return DW_FORM_data4;
4887 return DW_FORM_data8;
4891 case dw_val_class_long_long:
4892 return DW_FORM_block1;
4893 case dw_val_class_float:
4894 return DW_FORM_block1;
4895 case dw_val_class_flag:
4896 return DW_FORM_flag;
4897 case dw_val_class_die_ref:
4899 case dw_val_class_fde_ref:
4900 return DW_FORM_data;
4901 case dw_val_class_lbl_id:
4902 return DW_FORM_addr;
4903 case dw_val_class_lbl_offset:
4904 return DW_FORM_data;
4905 case dw_val_class_str:
4906 return DW_FORM_string;
4912 /* Output the encoding of an attribute value. */
4915 output_value_format (a)
4918 enum dwarf_form form = value_format (a);
4920 output_uleb128 (form);
4922 fprintf (asm_out_file, " (%s)", dwarf_form_name (form));
4924 fputc ('\n', asm_out_file);
4927 /* Output the .debug_abbrev section which defines the DIE abbreviation
4931 output_abbrev_section ()
4933 unsigned long abbrev_id;
4936 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
4938 register dw_die_ref abbrev = abbrev_die_table[abbrev_id];
4940 output_uleb128 (abbrev_id);
4942 fprintf (asm_out_file, " (abbrev code)");
4944 fputc ('\n', asm_out_file);
4945 output_uleb128 (abbrev->die_tag);
4947 fprintf (asm_out_file, " (TAG: %s)",
4948 dwarf_tag_name (abbrev->die_tag));
4950 fputc ('\n', asm_out_file);
4951 fprintf (asm_out_file, "\t%s\t0x%x", ASM_BYTE_OP,
4952 abbrev->die_child != NULL ? DW_children_yes : DW_children_no);
4955 fprintf (asm_out_file, "\t%s %s",
4957 (abbrev->die_child != NULL
4958 ? "DW_children_yes" : "DW_children_no"));
4960 fputc ('\n', asm_out_file);
4962 for (a_attr = abbrev->die_attr; a_attr != NULL;
4963 a_attr = a_attr->dw_attr_next)
4965 output_uleb128 (a_attr->dw_attr);
4967 fprintf (asm_out_file, " (%s)",
4968 dwarf_attr_name (a_attr->dw_attr));
4970 fputc ('\n', asm_out_file);
4971 output_value_format (a_attr);
4974 fprintf (asm_out_file, "\t%s\t0,0\n", ASM_BYTE_OP);
4977 /* Terminate the table. */
4978 fprintf (asm_out_file, "\t%s\t0\n", ASM_BYTE_OP);
4981 /* Output location description stack opcode's operands (if any). */
4984 output_loc_operands (loc)
4985 register dw_loc_descr_ref loc;
4987 register dw_val_ref val1 = &loc->dw_loc_oprnd1;
4988 register dw_val_ref val2 = &loc->dw_loc_oprnd2;
4990 switch (loc->dw_loc_opc)
4993 ASM_OUTPUT_DWARF_ADDR_CONST (asm_out_file, val1->v.val_addr);
4994 fputc ('\n', asm_out_file);
4998 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, val1->v.val_flag);
4999 fputc ('\n', asm_out_file);
5003 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, val1->v.val_int);
5004 fputc ('\n', asm_out_file);
5008 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, val1->v.val_int);
5009 fputc ('\n', asm_out_file);
5014 fputc ('\n', asm_out_file);
5017 output_uleb128 (val1->v.val_unsigned);
5018 fputc ('\n', asm_out_file);
5021 output_sleb128 (val1->v.val_int);
5022 fputc ('\n', asm_out_file);
5025 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, val1->v.val_int);
5026 fputc ('\n', asm_out_file);
5028 case DW_OP_plus_uconst:
5029 output_uleb128 (val1->v.val_unsigned);
5030 fputc ('\n', asm_out_file);
5034 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, val1->v.val_int);
5035 fputc ('\n', asm_out_file);
5069 output_sleb128 (val1->v.val_int);
5070 fputc ('\n', asm_out_file);
5073 output_uleb128 (val1->v.val_unsigned);
5074 fputc ('\n', asm_out_file);
5077 output_sleb128 (val1->v.val_int);
5078 fputc ('\n', asm_out_file);
5081 output_uleb128 (val1->v.val_unsigned);
5082 fputc ('\n', asm_out_file);
5083 output_sleb128 (val2->v.val_int);
5084 fputc ('\n', asm_out_file);
5087 output_uleb128 (val1->v.val_unsigned);
5088 fputc ('\n', asm_out_file);
5090 case DW_OP_deref_size:
5091 case DW_OP_xderef_size:
5092 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, val1->v.val_flag);
5093 fputc ('\n', asm_out_file);
5100 /* Output the DIE and its attributes. Called recursively to generate
5101 the definitions of each child DIE. */
5105 register dw_die_ref die;
5107 register dw_attr_ref a;
5108 register dw_die_ref c;
5109 register unsigned long size;
5110 register dw_loc_descr_ref loc;
5112 output_uleb128 (die->die_abbrev);
5114 fprintf (asm_out_file, " (DIE (0x%lx) %s)",
5115 die->die_offset, dwarf_tag_name (die->die_tag));
5117 fputc ('\n', asm_out_file);
5119 for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
5121 switch (AT_class (a))
5123 case dw_val_class_addr:
5124 ASM_OUTPUT_DWARF_ADDR_CONST (asm_out_file, AT_addr (a));
5127 case dw_val_class_loc:
5128 size = size_of_locs (AT_loc (a));
5130 /* Output the block length for this list of location operations. */
5131 switch (constant_size (size))
5134 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, size);
5137 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, size);
5144 fprintf (asm_out_file, "\t%s %s",
5145 ASM_COMMENT_START, dwarf_attr_name (a->dw_attr));
5147 fputc ('\n', asm_out_file);
5148 for (loc = AT_loc (a); loc != NULL; loc = loc->dw_loc_next)
5150 /* Output the opcode. */
5151 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, loc->dw_loc_opc);
5153 fprintf (asm_out_file, "\t%s %s", ASM_COMMENT_START,
5154 dwarf_stack_op_name (loc->dw_loc_opc));
5156 fputc ('\n', asm_out_file);
5158 /* Output the operand(s) (if any). */
5159 output_loc_operands (loc);
5163 case dw_val_class_const:
5164 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, AT_int (a));
5167 case dw_val_class_unsigned_const:
5168 switch (constant_size (AT_unsigned (a)))
5171 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, AT_unsigned (a));
5174 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, AT_unsigned (a));
5177 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, AT_unsigned (a));
5180 ASM_OUTPUT_DWARF_DATA8 (asm_out_file,
5181 a->dw_attr_val.v.val_long_long.hi,
5182 a->dw_attr_val.v.val_long_long.low);
5189 case dw_val_class_long_long:
5190 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 8);
5192 fprintf (asm_out_file, "\t%s %s",
5193 ASM_COMMENT_START, dwarf_attr_name (a->dw_attr));
5195 fputc ('\n', asm_out_file);
5196 ASM_OUTPUT_DWARF_DATA8 (asm_out_file,
5197 a->dw_attr_val.v.val_long_long.hi,
5198 a->dw_attr_val.v.val_long_long.low);
5201 fprintf (asm_out_file,
5202 "\t%s long long constant", ASM_COMMENT_START);
5204 fputc ('\n', asm_out_file);
5207 case dw_val_class_float:
5209 register unsigned int i;
5210 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
5211 a->dw_attr_val.v.val_float.length * 4);
5213 fprintf (asm_out_file, "\t%s %s",
5214 ASM_COMMENT_START, dwarf_attr_name (a->dw_attr));
5216 fputc ('\n', asm_out_file);
5217 for (i = 0; i < a->dw_attr_val.v.val_float.length; ++i)
5219 ASM_OUTPUT_DWARF_DATA4 (asm_out_file,
5220 a->dw_attr_val.v.val_float.array[i]);
5222 fprintf (asm_out_file, "\t%s fp constant word %u",
5223 ASM_COMMENT_START, i);
5225 fputc ('\n', asm_out_file);
5230 case dw_val_class_flag:
5231 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, AT_flag (a));
5234 case dw_val_class_die_ref:
5235 ASM_OUTPUT_DWARF_DATA (asm_out_file, AT_ref (a)->die_offset);
5238 case dw_val_class_fde_ref:
5241 ASM_GENERATE_INTERNAL_LABEL
5242 (l1, FDE_AFTER_SIZE_LABEL, a->dw_attr_val.v.val_fde_index * 2);
5243 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, l1);
5244 fprintf (asm_out_file, " - %d", DWARF_OFFSET_SIZE);
5248 case dw_val_class_lbl_id:
5249 ASM_OUTPUT_DWARF_ADDR (asm_out_file, AT_lbl (a));
5252 case dw_val_class_lbl_offset:
5253 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, AT_lbl (a));
5256 case dw_val_class_str:
5258 ASM_OUTPUT_DWARF_STRING (asm_out_file, AT_string (a));
5260 ASM_OUTPUT_ASCII (asm_out_file, AT_string (a),
5261 (int) strlen (AT_string (a)) + 1);
5268 if (AT_class (a) != dw_val_class_loc
5269 && AT_class (a) != dw_val_class_long_long
5270 && AT_class (a) != dw_val_class_float)
5273 fprintf (asm_out_file, "\t%s %s",
5274 ASM_COMMENT_START, dwarf_attr_name (a->dw_attr));
5276 fputc ('\n', asm_out_file);
5280 for (c = die->die_child; c != NULL; c = c->die_sib)
5283 if (die->die_child != NULL)
5285 /* Add null byte to terminate sibling list. */
5286 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5288 fprintf (asm_out_file, "\t%s end of children of DIE 0x%lx",
5289 ASM_COMMENT_START, die->die_offset);
5291 fputc ('\n', asm_out_file);
5295 /* Output the compilation unit that appears at the beginning of the
5296 .debug_info section, and precedes the DIE descriptions. */
5299 output_compilation_unit_header ()
5301 ASM_OUTPUT_DWARF_DATA (asm_out_file, next_die_offset - DWARF_OFFSET_SIZE);
5303 fprintf (asm_out_file, "\t%s Length of Compilation Unit Info.",
5306 fputc ('\n', asm_out_file);
5307 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, DWARF_VERSION);
5309 fprintf (asm_out_file, "\t%s DWARF version number", ASM_COMMENT_START);
5311 fputc ('\n', asm_out_file);
5312 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, abbrev_section_label);
5314 fprintf (asm_out_file, "\t%s Offset Into Abbrev. Section",
5317 fputc ('\n', asm_out_file);
5318 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, PTR_SIZE);
5320 fprintf (asm_out_file, "\t%s Pointer Size (in bytes)", ASM_COMMENT_START);
5322 fputc ('\n', asm_out_file);
5325 /* The DWARF2 pubname for a nested thingy looks like "A::f". The output
5326 of decl_printable_name for C++ looks like "A::f(int)". Let's drop the
5327 argument list, and maybe the scope. */
5330 dwarf2_name (decl, scope)
5334 return (*decl_printable_name) (decl, scope ? 1 : 0);
5337 /* Add a new entry to .debug_pubnames if appropriate. */
5340 add_pubname (decl, die)
5346 if (! TREE_PUBLIC (decl))
5349 if (pubname_table_in_use == pubname_table_allocated)
5351 pubname_table_allocated += PUBNAME_TABLE_INCREMENT;
5352 pubname_table = (pubname_ref) xrealloc
5353 (pubname_table, pubname_table_allocated * sizeof (pubname_entry));
5356 p = &pubname_table[pubname_table_in_use++];
5359 p->name = xstrdup (dwarf2_name (decl, 1));
5362 /* Output the public names table used to speed up access to externally
5363 visible names. For now, only generate entries for externally
5364 visible procedures. */
5369 register unsigned i;
5370 register unsigned long pubnames_length = size_of_pubnames ();
5372 ASM_OUTPUT_DWARF_DATA (asm_out_file, pubnames_length);
5375 fprintf (asm_out_file, "\t%s Length of Public Names Info.",
5378 fputc ('\n', asm_out_file);
5379 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, DWARF_VERSION);
5382 fprintf (asm_out_file, "\t%s DWARF Version", ASM_COMMENT_START);
5384 fputc ('\n', asm_out_file);
5385 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, debug_info_section_label);
5387 fprintf (asm_out_file, "\t%s Offset of Compilation Unit Info.",
5390 fputc ('\n', asm_out_file);
5391 ASM_OUTPUT_DWARF_DATA (asm_out_file, next_die_offset);
5393 fprintf (asm_out_file, "\t%s Compilation Unit Length", ASM_COMMENT_START);
5395 fputc ('\n', asm_out_file);
5396 for (i = 0; i < pubname_table_in_use; ++i)
5398 register pubname_ref pub = &pubname_table[i];
5400 ASM_OUTPUT_DWARF_DATA (asm_out_file, pub->die->die_offset);
5402 fprintf (asm_out_file, "\t%s DIE offset", ASM_COMMENT_START);
5404 fputc ('\n', asm_out_file);
5408 ASM_OUTPUT_DWARF_STRING (asm_out_file, pub->name);
5409 fprintf (asm_out_file, "%s external name", ASM_COMMENT_START);
5413 ASM_OUTPUT_ASCII (asm_out_file, pub->name,
5414 (int) strlen (pub->name) + 1);
5417 fputc ('\n', asm_out_file);
5420 ASM_OUTPUT_DWARF_DATA (asm_out_file, 0);
5421 fputc ('\n', asm_out_file);
5424 /* Add a new entry to .debug_aranges if appropriate. */
5427 add_arange (decl, die)
5431 if (! DECL_SECTION_NAME (decl))
5434 if (arange_table_in_use == arange_table_allocated)
5436 arange_table_allocated += ARANGE_TABLE_INCREMENT;
5438 = (arange_ref) xrealloc (arange_table,
5439 arange_table_allocated * sizeof (dw_die_ref));
5442 arange_table[arange_table_in_use++] = die;
5445 /* Output the information that goes into the .debug_aranges table.
5446 Namely, define the beginning and ending address range of the
5447 text section generated for this compilation unit. */
5452 register unsigned i;
5453 register unsigned long aranges_length = size_of_aranges ();
5455 ASM_OUTPUT_DWARF_DATA (asm_out_file, aranges_length);
5457 fprintf (asm_out_file, "\t%s Length of Address Ranges Info.",
5460 fputc ('\n', asm_out_file);
5461 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, DWARF_VERSION);
5463 fprintf (asm_out_file, "\t%s DWARF Version", ASM_COMMENT_START);
5465 fputc ('\n', asm_out_file);
5466 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, debug_info_section_label);
5468 fprintf (asm_out_file, "\t%s Offset of Compilation Unit Info.",
5471 fputc ('\n', asm_out_file);
5472 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, PTR_SIZE);
5474 fprintf (asm_out_file, "\t%s Size of Address", ASM_COMMENT_START);
5476 fputc ('\n', asm_out_file);
5477 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5479 fprintf (asm_out_file, "\t%s Size of Segment Descriptor",
5482 fputc ('\n', asm_out_file);
5483 /* We need to align to twice the pointer size here.
5484 If DWARF_OFFSET_SIZE == 4, then we have emitted 12 bytes, and need 4
5485 bytes of padding to align for either 4 or 8 byte pointers. */
5486 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0);
5487 /* If DWARF_OFFSET_SIZE == 8, then we have emitted 20 bytes, and need 12
5488 bytes of padding to align for 8 byte pointers. We have already emitted
5489 4 bytes of padding, so emit 8 more here. */
5490 if (DWARF_OFFSET_SIZE == 8)
5491 fprintf (asm_out_file, ",0,0");
5494 fprintf (asm_out_file, "\t%s Pad to %d byte boundary",
5495 ASM_COMMENT_START, 2 * PTR_SIZE);
5497 fputc ('\n', asm_out_file);
5498 ASM_OUTPUT_DWARF_ADDR (asm_out_file, text_section_label);
5500 fprintf (asm_out_file, "\t%s Address", ASM_COMMENT_START);
5502 fputc ('\n', asm_out_file);
5503 ASM_OUTPUT_DWARF_ADDR_DELTA (asm_out_file, text_end_label,
5504 text_section_label);
5506 fprintf (asm_out_file, "%s Length", ASM_COMMENT_START);
5508 fputc ('\n', asm_out_file);
5509 for (i = 0; i < arange_table_in_use; ++i)
5511 dw_die_ref die = arange_table[i];
5513 if (die->die_tag == DW_TAG_subprogram)
5514 ASM_OUTPUT_DWARF_ADDR (asm_out_file, get_AT_low_pc (die));
5517 /* A static variable; extract the symbol from DW_AT_location.
5518 Note that this code isn't currently hit, as we only emit
5519 aranges for functions (jason 9/23/99). */
5521 dw_attr_ref a = get_AT (die, DW_AT_location);
5522 dw_loc_descr_ref loc;
5523 if (! a || AT_class (a) != dw_val_class_loc)
5527 if (loc->dw_loc_opc != DW_OP_addr)
5530 ASM_OUTPUT_DWARF_ADDR (asm_out_file, loc->dw_loc_oprnd1.v.val_addr);
5534 fprintf (asm_out_file, "\t%s Address", ASM_COMMENT_START);
5536 fputc ('\n', asm_out_file);
5537 if (die->die_tag == DW_TAG_subprogram)
5538 ASM_OUTPUT_DWARF_ADDR_DELTA (asm_out_file, get_AT_hi_pc (die),
5539 get_AT_low_pc (die));
5541 ASM_OUTPUT_DWARF_ADDR_DATA (asm_out_file,
5542 get_AT_unsigned (die, DW_AT_byte_size));
5545 fprintf (asm_out_file, "%s Length", ASM_COMMENT_START);
5547 fputc ('\n', asm_out_file);
5550 /* Output the terminator words. */
5551 ASM_OUTPUT_DWARF_ADDR_DATA (asm_out_file, 0);
5552 fputc ('\n', asm_out_file);
5553 ASM_OUTPUT_DWARF_ADDR_DATA (asm_out_file, 0);
5554 fputc ('\n', asm_out_file);
5557 /* Output the source line number correspondence information. This
5558 information goes into the .debug_line section. */
5563 char line_label[MAX_ARTIFICIAL_LABEL_BYTES];
5564 char prev_line_label[MAX_ARTIFICIAL_LABEL_BYTES];
5565 register unsigned opc;
5566 register unsigned n_op_args;
5567 register unsigned long ft_index;
5568 register unsigned long lt_index;
5569 register unsigned long current_line;
5570 register long line_offset;
5571 register long line_delta;
5572 register unsigned long current_file;
5573 register unsigned long function;
5575 ASM_OUTPUT_DWARF_DELTA (asm_out_file, ".LTEND", ".LTSTART");
5577 fprintf (asm_out_file, "\t%s Length of Source Line Info.",
5580 fputc ('\n', asm_out_file);
5581 ASM_OUTPUT_LABEL (asm_out_file, ".LTSTART");
5582 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, DWARF_VERSION);
5584 fprintf (asm_out_file, "\t%s DWARF Version", ASM_COMMENT_START);
5586 fputc ('\n', asm_out_file);
5587 ASM_OUTPUT_DWARF_DATA (asm_out_file, size_of_line_prolog ());
5589 fprintf (asm_out_file, "\t%s Prolog Length", ASM_COMMENT_START);
5591 fputc ('\n', asm_out_file);
5592 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DWARF_LINE_MIN_INSTR_LENGTH);
5594 fprintf (asm_out_file, "\t%s Minimum Instruction Length",
5597 fputc ('\n', asm_out_file);
5598 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DWARF_LINE_DEFAULT_IS_STMT_START);
5600 fprintf (asm_out_file, "\t%s Default is_stmt_start flag",
5603 fputc ('\n', asm_out_file);
5604 fprintf (asm_out_file, "\t%s\t%d", ASM_BYTE_OP, DWARF_LINE_BASE);
5606 fprintf (asm_out_file, "\t%s Line Base Value (Special Opcodes)",
5609 fputc ('\n', asm_out_file);
5610 fprintf (asm_out_file, "\t%s\t%u", ASM_BYTE_OP, DWARF_LINE_RANGE);
5612 fprintf (asm_out_file, "\t%s Line Range Value (Special Opcodes)",
5615 fputc ('\n', asm_out_file);
5616 fprintf (asm_out_file, "\t%s\t%u", ASM_BYTE_OP, DWARF_LINE_OPCODE_BASE);
5618 fprintf (asm_out_file, "\t%s Special Opcode Base", ASM_COMMENT_START);
5620 fputc ('\n', asm_out_file);
5621 for (opc = 1; opc < DWARF_LINE_OPCODE_BASE; ++opc)
5625 case DW_LNS_advance_pc:
5626 case DW_LNS_advance_line:
5627 case DW_LNS_set_file:
5628 case DW_LNS_set_column:
5629 case DW_LNS_fixed_advance_pc:
5636 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, n_op_args);
5638 fprintf (asm_out_file, "\t%s opcode: 0x%x has %d args",
5639 ASM_COMMENT_START, opc, n_op_args);
5640 fputc ('\n', asm_out_file);
5644 fprintf (asm_out_file, "%s Include Directory Table\n", ASM_COMMENT_START);
5646 /* Include directory table is empty, at present */
5647 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5648 fputc ('\n', asm_out_file);
5650 fprintf (asm_out_file, "%s File Name Table\n", ASM_COMMENT_START);
5652 for (ft_index = 1; ft_index < file_table_in_use; ++ft_index)
5656 ASM_OUTPUT_DWARF_STRING (asm_out_file, file_table[ft_index]);
5657 fprintf (asm_out_file, "%s File Entry: 0x%lx",
5658 ASM_COMMENT_START, ft_index);
5662 ASM_OUTPUT_ASCII (asm_out_file,
5663 file_table[ft_index],
5664 (int) strlen (file_table[ft_index]) + 1);
5667 fputc ('\n', asm_out_file);
5669 /* Include directory index */
5671 fputc ('\n', asm_out_file);
5673 /* Modification time */
5675 fputc ('\n', asm_out_file);
5677 /* File length in bytes */
5679 fputc ('\n', asm_out_file);
5682 /* Terminate the file name table */
5683 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5684 fputc ('\n', asm_out_file);
5686 /* We used to set the address register to the first location in the text
5687 section here, but that didn't accomplish anything since we already
5688 have a line note for the opening brace of the first function. */
5690 /* Generate the line number to PC correspondence table, encoded as
5691 a series of state machine operations. */
5694 strcpy (prev_line_label, text_section_label);
5695 for (lt_index = 1; lt_index < line_info_table_in_use; ++lt_index)
5697 register dw_line_info_ref line_info = &line_info_table[lt_index];
5700 /* Disable this optimization for now; GDB wants to see two line notes
5701 at the beginning of a function so it can find the end of the
5704 /* Don't emit anything for redundant notes. Just updating the
5705 address doesn't accomplish anything, because we already assume
5706 that anything after the last address is this line. */
5707 if (line_info->dw_line_num == current_line
5708 && line_info->dw_file_num == current_file)
5712 /* Emit debug info for the address of the current line, choosing
5713 the encoding that uses the least amount of space. */
5714 /* ??? Unfortunately, we have little choice here currently, and must
5715 always use the most general form. Gcc does not know the address
5716 delta itself, so we can't use DW_LNS_advance_pc. There are no known
5717 dwarf2 aware assemblers at this time, so we can't use any special
5718 pseudo ops that would allow the assembler to optimally encode this for
5719 us. Many ports do have length attributes which will give an upper
5720 bound on the address range. We could perhaps use length attributes
5721 to determine when it is safe to use DW_LNS_fixed_advance_pc. */
5722 ASM_GENERATE_INTERNAL_LABEL (line_label, LINE_CODE_LABEL, lt_index);
5725 /* This can handle deltas up to 0xffff. This takes 3 bytes. */
5726 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc);
5728 fprintf (asm_out_file, "\t%s DW_LNS_fixed_advance_pc",
5731 fputc ('\n', asm_out_file);
5732 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, line_label, prev_line_label);
5733 fputc ('\n', asm_out_file);
5737 /* This can handle any delta. This takes 4+PTR_SIZE bytes. */
5738 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5740 fprintf (asm_out_file, "\t%s DW_LNE_set_address",
5742 fputc ('\n', asm_out_file);
5743 output_uleb128 (1 + PTR_SIZE);
5744 fputc ('\n', asm_out_file);
5745 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address);
5746 fputc ('\n', asm_out_file);
5747 ASM_OUTPUT_DWARF_ADDR (asm_out_file, line_label);
5748 fputc ('\n', asm_out_file);
5750 strcpy (prev_line_label, line_label);
5752 /* Emit debug info for the source file of the current line, if
5753 different from the previous line. */
5754 if (line_info->dw_file_num != current_file)
5756 current_file = line_info->dw_file_num;
5757 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_set_file);
5759 fprintf (asm_out_file, "\t%s DW_LNS_set_file", ASM_COMMENT_START);
5761 fputc ('\n', asm_out_file);
5762 output_uleb128 (current_file);
5764 fprintf (asm_out_file, " (\"%s\")", file_table[current_file]);
5766 fputc ('\n', asm_out_file);
5769 /* Emit debug info for the current line number, choosing the encoding
5770 that uses the least amount of space. */
5771 if (line_info->dw_line_num != current_line)
5773 line_offset = line_info->dw_line_num - current_line;
5774 line_delta = line_offset - DWARF_LINE_BASE;
5775 current_line = line_info->dw_line_num;
5776 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
5778 /* This can handle deltas from -10 to 234, using the current
5779 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE. This
5781 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
5782 DWARF_LINE_OPCODE_BASE + line_delta);
5784 fprintf (asm_out_file,
5785 "\t%s line %ld", ASM_COMMENT_START, current_line);
5787 fputc ('\n', asm_out_file);
5791 /* This can handle any delta. This takes at least 4 bytes,
5792 depending on the value being encoded. */
5793 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_advance_line);
5795 fprintf (asm_out_file, "\t%s advance to line %ld",
5796 ASM_COMMENT_START, current_line);
5798 fputc ('\n', asm_out_file);
5799 output_sleb128 (line_offset);
5800 fputc ('\n', asm_out_file);
5801 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_copy);
5803 fprintf (asm_out_file, "\t%s DW_LNS_copy", ASM_COMMENT_START);
5804 fputc ('\n', asm_out_file);
5809 /* We still need to start a new row, so output a copy insn. */
5810 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_copy);
5812 fprintf (asm_out_file, "\t%s DW_LNS_copy", ASM_COMMENT_START);
5813 fputc ('\n', asm_out_file);
5817 /* Emit debug info for the address of the end of the function. */
5820 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc);
5822 fprintf (asm_out_file, "\t%s DW_LNS_fixed_advance_pc",
5825 fputc ('\n', asm_out_file);
5826 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, text_end_label, prev_line_label);
5827 fputc ('\n', asm_out_file);
5831 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5833 fprintf (asm_out_file, "\t%s DW_LNE_set_address", ASM_COMMENT_START);
5834 fputc ('\n', asm_out_file);
5835 output_uleb128 (1 + PTR_SIZE);
5836 fputc ('\n', asm_out_file);
5837 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address);
5838 fputc ('\n', asm_out_file);
5839 ASM_OUTPUT_DWARF_ADDR (asm_out_file, text_end_label);
5840 fputc ('\n', asm_out_file);
5843 /* Output the marker for the end of the line number info. */
5844 ASM_OUTPUT_LABEL (asm_out_file, ".LTEND");
5845 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5847 fprintf (asm_out_file, "\t%s DW_LNE_end_sequence", ASM_COMMENT_START);
5849 fputc ('\n', asm_out_file);
5851 fputc ('\n', asm_out_file);
5852 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_end_sequence);
5853 fputc ('\n', asm_out_file);
5858 for (lt_index = 0; lt_index < separate_line_info_table_in_use; )
5860 register dw_separate_line_info_ref line_info
5861 = &separate_line_info_table[lt_index];
5864 /* Don't emit anything for redundant notes. */
5865 if (line_info->dw_line_num == current_line
5866 && line_info->dw_file_num == current_file
5867 && line_info->function == function)
5871 /* Emit debug info for the address of the current line. If this is
5872 a new function, or the first line of a function, then we need
5873 to handle it differently. */
5874 ASM_GENERATE_INTERNAL_LABEL (line_label, SEPARATE_LINE_CODE_LABEL,
5876 if (function != line_info->function)
5878 function = line_info->function;
5880 /* Set the address register to the first line in the function */
5881 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5883 fprintf (asm_out_file, "\t%s DW_LNE_set_address",
5886 fputc ('\n', asm_out_file);
5887 output_uleb128 (1 + PTR_SIZE);
5888 fputc ('\n', asm_out_file);
5889 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address);
5890 fputc ('\n', asm_out_file);
5891 ASM_OUTPUT_DWARF_ADDR (asm_out_file, line_label);
5892 fputc ('\n', asm_out_file);
5896 /* ??? See the DW_LNS_advance_pc comment above. */
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,
5907 fputc ('\n', asm_out_file);
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);
5924 strcpy (prev_line_label, line_label);
5926 /* Emit debug info for the source file of the current line, if
5927 different from the previous line. */
5928 if (line_info->dw_file_num != current_file)
5930 current_file = line_info->dw_file_num;
5931 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_set_file);
5933 fprintf (asm_out_file, "\t%s DW_LNS_set_file", ASM_COMMENT_START);
5935 fputc ('\n', asm_out_file);
5936 output_uleb128 (current_file);
5938 fprintf (asm_out_file, " (\"%s\")", file_table[current_file]);
5940 fputc ('\n', asm_out_file);
5943 /* Emit debug info for the current line number, choosing the encoding
5944 that uses the least amount of space. */
5945 if (line_info->dw_line_num != current_line)
5947 line_offset = line_info->dw_line_num - current_line;
5948 line_delta = line_offset - DWARF_LINE_BASE;
5949 current_line = line_info->dw_line_num;
5950 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
5952 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
5953 DWARF_LINE_OPCODE_BASE + line_delta);
5955 fprintf (asm_out_file,
5956 "\t%s line %ld", ASM_COMMENT_START, current_line);
5958 fputc ('\n', asm_out_file);
5962 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_advance_line);
5964 fprintf (asm_out_file, "\t%s advance to line %ld",
5965 ASM_COMMENT_START, current_line);
5967 fputc ('\n', asm_out_file);
5968 output_sleb128 (line_offset);
5969 fputc ('\n', asm_out_file);
5970 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_copy);
5972 fprintf (asm_out_file, "\t%s DW_LNS_copy", ASM_COMMENT_START);
5973 fputc ('\n', asm_out_file);
5978 /* We still need to start a new row, so output a copy insn. */
5979 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_copy);
5981 fprintf (asm_out_file, "\t%s DW_LNS_copy", ASM_COMMENT_START);
5982 fputc ('\n', asm_out_file);
5990 /* If we're done with a function, end its sequence. */
5991 if (lt_index == separate_line_info_table_in_use
5992 || separate_line_info_table[lt_index].function != function)
5997 /* Emit debug info for the address of the end of the function. */
5998 ASM_GENERATE_INTERNAL_LABEL (line_label, FUNC_END_LABEL, function);
6001 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc);
6003 fprintf (asm_out_file, "\t%s DW_LNS_fixed_advance_pc",
6006 fputc ('\n', asm_out_file);
6007 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, line_label,
6009 fputc ('\n', asm_out_file);
6013 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
6015 fprintf (asm_out_file, "\t%s DW_LNE_set_address",
6017 fputc ('\n', asm_out_file);
6018 output_uleb128 (1 + PTR_SIZE);
6019 fputc ('\n', asm_out_file);
6020 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address);
6021 fputc ('\n', asm_out_file);
6022 ASM_OUTPUT_DWARF_ADDR (asm_out_file, line_label);
6023 fputc ('\n', asm_out_file);
6026 /* Output the marker for the end of this sequence. */
6027 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
6029 fprintf (asm_out_file, "\t%s DW_LNE_end_sequence",
6032 fputc ('\n', asm_out_file);
6034 fputc ('\n', asm_out_file);
6035 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_end_sequence);
6036 fputc ('\n', asm_out_file);
6041 /* Given a pointer to a BLOCK node return non-zero if (and only if) the node
6042 in question represents the outermost pair of curly braces (i.e. the "body
6043 block") of a function or method.
6045 For any BLOCK node representing a "body block" of a function or method, the
6046 BLOCK_SUPERCONTEXT of the node will point to another BLOCK node which
6047 represents the outermost (function) scope for the function or method (i.e.
6048 the one which includes the formal parameters). The BLOCK_SUPERCONTEXT of
6049 *that* node in turn will point to the relevant FUNCTION_DECL node. */
6052 is_body_block (stmt)
6055 if (TREE_CODE (stmt) == BLOCK)
6057 register tree parent = BLOCK_SUPERCONTEXT (stmt);
6059 if (TREE_CODE (parent) == BLOCK)
6061 register tree grandparent = BLOCK_SUPERCONTEXT (parent);
6063 if (TREE_CODE (grandparent) == FUNCTION_DECL)
6071 /* Given a pointer to a tree node for some base type, return a pointer to
6072 a DIE that describes the given type.
6074 This routine must only be called for GCC type nodes that correspond to
6075 Dwarf base (fundamental) types. */
6078 base_type_die (type)
6081 register dw_die_ref base_type_result;
6082 register const char *type_name;
6083 register enum dwarf_type encoding;
6084 register tree name = TYPE_NAME (type);
6086 if (TREE_CODE (type) == ERROR_MARK
6087 || TREE_CODE (type) == VOID_TYPE)
6092 if (TREE_CODE (name) == TYPE_DECL)
6093 name = DECL_NAME (name);
6095 type_name = IDENTIFIER_POINTER (name);
6098 type_name = "__unknown__";
6100 switch (TREE_CODE (type))
6103 /* Carefully distinguish the C character types, without messing
6104 up if the language is not C. Note that we check only for the names
6105 that contain spaces; other names might occur by coincidence in other
6107 if (! (TYPE_PRECISION (type) == CHAR_TYPE_SIZE
6108 && (type == char_type_node
6109 || ! strcmp (type_name, "signed char")
6110 || ! strcmp (type_name, "unsigned char"))))
6112 if (TREE_UNSIGNED (type))
6113 encoding = DW_ATE_unsigned;
6115 encoding = DW_ATE_signed;
6118 /* else fall through */
6121 /* GNU Pascal/Ada CHAR type. Not used in C. */
6122 if (TREE_UNSIGNED (type))
6123 encoding = DW_ATE_unsigned_char;
6125 encoding = DW_ATE_signed_char;
6129 encoding = DW_ATE_float;
6132 /* Dwarf2 doesn't know anything about complex ints, so use
6133 a user defined type for it. */
6135 if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
6136 encoding = DW_ATE_complex_float;
6138 encoding = DW_ATE_lo_user;
6142 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */
6143 encoding = DW_ATE_boolean;
6147 abort (); /* No other TREE_CODEs are Dwarf fundamental types. */
6150 base_type_result = new_die (DW_TAG_base_type, comp_unit_die);
6151 if (demangle_name_func)
6152 type_name = (*demangle_name_func) (type_name);
6154 add_AT_string (base_type_result, DW_AT_name, type_name);
6155 add_AT_unsigned (base_type_result, DW_AT_byte_size,
6156 int_size_in_bytes (type));
6157 add_AT_unsigned (base_type_result, DW_AT_encoding, encoding);
6159 return base_type_result;
6162 /* Given a pointer to an arbitrary ..._TYPE tree node, return a pointer to
6163 the Dwarf "root" type for the given input type. The Dwarf "root" type of
6164 a given type is generally the same as the given type, except that if the
6165 given type is a pointer or reference type, then the root type of the given
6166 type is the root type of the "basis" type for the pointer or reference
6167 type. (This definition of the "root" type is recursive.) Also, the root
6168 type of a `const' qualified type or a `volatile' qualified type is the
6169 root type of the given type without the qualifiers. */
6175 if (TREE_CODE (type) == ERROR_MARK)
6176 return error_mark_node;
6178 switch (TREE_CODE (type))
6181 return error_mark_node;
6184 case REFERENCE_TYPE:
6185 return type_main_variant (root_type (TREE_TYPE (type)));
6188 return type_main_variant (type);
6192 /* Given a pointer to an arbitrary ..._TYPE tree node, return non-zero if the
6193 given input type is a Dwarf "fundamental" type. Otherwise return null. */
6199 switch (TREE_CODE (type))
6214 case QUAL_UNION_TYPE:
6219 case REFERENCE_TYPE:
6232 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
6233 entry that chains various modifiers in front of the given type. */
6236 modified_type_die (type, is_const_type, is_volatile_type, context_die)
6238 register int is_const_type;
6239 register int is_volatile_type;
6240 register dw_die_ref context_die;
6242 register enum tree_code code = TREE_CODE (type);
6243 register dw_die_ref mod_type_die = NULL;
6244 register dw_die_ref sub_die = NULL;
6245 register tree item_type = NULL;
6247 if (code != ERROR_MARK)
6249 type = build_type_variant (type, is_const_type, is_volatile_type);
6251 mod_type_die = lookup_type_die (type);
6253 return mod_type_die;
6255 /* Handle C typedef types. */
6256 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
6257 && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
6259 tree dtype = TREE_TYPE (TYPE_NAME (type));
6262 /* For a named type, use the typedef. */
6263 gen_type_die (type, context_die);
6264 mod_type_die = lookup_type_die (type);
6267 else if (is_const_type < TYPE_READONLY (dtype)
6268 || is_volatile_type < TYPE_VOLATILE (dtype))
6269 /* cv-unqualified version of named type. Just use the unnamed
6270 type to which it refers. */
6272 = modified_type_die (DECL_ORIGINAL_TYPE (TYPE_NAME (type)),
6273 is_const_type, is_volatile_type,
6275 /* Else cv-qualified version of named type; fall through. */
6280 else if (is_const_type)
6282 mod_type_die = new_die (DW_TAG_const_type, comp_unit_die);
6283 sub_die = modified_type_die (type, 0, is_volatile_type, context_die);
6285 else if (is_volatile_type)
6287 mod_type_die = new_die (DW_TAG_volatile_type, comp_unit_die);
6288 sub_die = modified_type_die (type, 0, 0, context_die);
6290 else if (code == POINTER_TYPE)
6292 mod_type_die = new_die (DW_TAG_pointer_type, comp_unit_die);
6293 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
6295 add_AT_unsigned (mod_type_die, DW_AT_address_class, 0);
6297 item_type = TREE_TYPE (type);
6299 else if (code == REFERENCE_TYPE)
6301 mod_type_die = new_die (DW_TAG_reference_type, comp_unit_die);
6302 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
6304 add_AT_unsigned (mod_type_die, DW_AT_address_class, 0);
6306 item_type = TREE_TYPE (type);
6308 else if (is_base_type (type))
6309 mod_type_die = base_type_die (type);
6312 gen_type_die (type, context_die);
6314 /* We have to get the type_main_variant here (and pass that to the
6315 `lookup_type_die' routine) because the ..._TYPE node we have
6316 might simply be a *copy* of some original type node (where the
6317 copy was created to help us keep track of typedef names) and
6318 that copy might have a different TYPE_UID from the original
6320 mod_type_die = lookup_type_die (type_main_variant (type));
6321 if (mod_type_die == NULL)
6326 equate_type_number_to_die (type, mod_type_die);
6328 /* We must do this after the equate_type_number_to_die call, in case
6329 this is a recursive type. This ensures that the modified_type_die
6330 recursion will terminate even if the type is recursive. Recursive
6331 types are possible in Ada. */
6332 sub_die = modified_type_die (item_type,
6333 TYPE_READONLY (item_type),
6334 TYPE_VOLATILE (item_type),
6337 if (sub_die != NULL)
6338 add_AT_die_ref (mod_type_die, DW_AT_type, sub_die);
6340 return mod_type_die;
6343 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
6344 an enumerated type. */
6350 return TREE_CODE (type) == ENUMERAL_TYPE;
6353 /* Return a location descriptor that designates a machine register. */
6355 static dw_loc_descr_ref
6356 reg_loc_descriptor (rtl)
6359 register dw_loc_descr_ref loc_result = NULL;
6360 register unsigned reg = reg_number (rtl);
6363 loc_result = new_loc_descr (DW_OP_reg0 + reg, 0, 0);
6365 loc_result = new_loc_descr (DW_OP_regx, reg, 0);
6370 /* Return a location descriptor that designates a base+offset location. */
6372 static dw_loc_descr_ref
6373 based_loc_descr (reg, offset)
6377 register dw_loc_descr_ref loc_result;
6378 /* For the "frame base", we use the frame pointer or stack pointer
6379 registers, since the RTL for local variables is relative to one of
6381 register unsigned fp_reg = DBX_REGISTER_NUMBER (frame_pointer_needed
6382 ? HARD_FRAME_POINTER_REGNUM
6383 : STACK_POINTER_REGNUM);
6386 loc_result = new_loc_descr (DW_OP_fbreg, offset, 0);
6388 loc_result = new_loc_descr (DW_OP_breg0 + reg, offset, 0);
6390 loc_result = new_loc_descr (DW_OP_bregx, reg, offset);
6395 /* Return true if this RTL expression describes a base+offset calculation. */
6401 return (GET_CODE (rtl) == PLUS
6402 && ((GET_CODE (XEXP (rtl, 0)) == REG
6403 && GET_CODE (XEXP (rtl, 1)) == CONST_INT)));
6406 /* The following routine converts the RTL for a variable or parameter
6407 (resident in memory) into an equivalent Dwarf representation of a
6408 mechanism for getting the address of that same variable onto the top of a
6409 hypothetical "address evaluation" stack.
6411 When creating memory location descriptors, we are effectively transforming
6412 the RTL for a memory-resident object into its Dwarf postfix expression
6413 equivalent. This routine recursively descends an RTL tree, turning
6414 it into Dwarf postfix code as it goes.
6416 MODE is the mode of the memory reference, needed to handle some
6417 autoincrement addressing modes. */
6419 static dw_loc_descr_ref
6420 mem_loc_descriptor (rtl, mode)
6422 enum machine_mode mode;
6424 dw_loc_descr_ref mem_loc_result = NULL;
6425 /* Note that for a dynamically sized array, the location we will generate a
6426 description of here will be the lowest numbered location which is
6427 actually within the array. That's *not* necessarily the same as the
6428 zeroth element of the array. */
6430 switch (GET_CODE (rtl))
6434 /* POST_INC and POST_DEC can be handled just like a SUBREG. So we
6435 just fall into the SUBREG code. */
6437 /* ... fall through ... */
6440 /* The case of a subreg may arise when we have a local (register)
6441 variable or a formal (register) parameter which doesn't quite fill
6442 up an entire register. For now, just assume that it is
6443 legitimate to make the Dwarf info refer to the whole register which
6444 contains the given subreg. */
6445 rtl = XEXP (rtl, 0);
6447 /* ... fall through ... */
6450 /* Whenever a register number forms a part of the description of the
6451 method for calculating the (dynamic) address of a memory resident
6452 object, DWARF rules require the register number be referred to as
6453 a "base register". This distinction is not based in any way upon
6454 what category of register the hardware believes the given register
6455 belongs to. This is strictly DWARF terminology we're dealing with
6456 here. Note that in cases where the location of a memory-resident
6457 data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
6458 OP_CONST (0)) the actual DWARF location descriptor that we generate
6459 may just be OP_BASEREG (basereg). This may look deceptively like
6460 the object in question was allocated to a register (rather than in
6461 memory) so DWARF consumers need to be aware of the subtle
6462 distinction between OP_REG and OP_BASEREG. */
6463 mem_loc_result = based_loc_descr (reg_number (rtl), 0);
6467 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), mode);
6468 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_deref, 0, 0));
6472 /* Some ports can transform a symbol ref into a label ref, because
6473 the symbol ref is too far away and has to be dumped into a constant
6477 mem_loc_result = new_loc_descr (DW_OP_addr, 0, 0);
6478 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_addr;
6479 mem_loc_result->dw_loc_oprnd1.v.val_addr = addr_to_string (rtl);
6484 /* Turn these into a PLUS expression and fall into the PLUS code
6486 rtl = gen_rtx_PLUS (word_mode, XEXP (rtl, 0),
6487 GEN_INT (GET_CODE (rtl) == PRE_INC
6488 ? GET_MODE_UNIT_SIZE (mode)
6489 : - GET_MODE_UNIT_SIZE (mode)));
6491 /* ... fall through ... */
6494 if (is_based_loc (rtl))
6495 mem_loc_result = based_loc_descr (reg_number (XEXP (rtl, 0)),
6496 INTVAL (XEXP (rtl, 1)));
6499 add_loc_descr (&mem_loc_result, mem_loc_descriptor (XEXP (rtl, 0),
6501 add_loc_descr (&mem_loc_result, mem_loc_descriptor (XEXP (rtl, 1),
6503 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_plus, 0, 0));
6508 /* If a pseudo-reg is optimized away, it is possible for it to
6509 be replaced with a MEM containing a multiply. */
6510 add_loc_descr (&mem_loc_result, mem_loc_descriptor (XEXP (rtl, 0), mode));
6511 add_loc_descr (&mem_loc_result, mem_loc_descriptor (XEXP (rtl, 1), mode));
6512 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_mul, 0, 0));
6516 mem_loc_result = new_loc_descr (DW_OP_constu, INTVAL (rtl), 0);
6523 return mem_loc_result;
6526 /* Return a descriptor that describes the concatenation of two locations.
6527 This is typically a complex variable. */
6529 static dw_loc_descr_ref
6530 concat_loc_descriptor (x0, x1)
6531 register rtx x0, x1;
6533 dw_loc_descr_ref cc_loc_result = NULL;
6535 if (!is_pseudo_reg (x0)
6536 && (GET_CODE (x0) != MEM || !is_pseudo_reg (XEXP (x0, 0))))
6537 add_loc_descr (&cc_loc_result, loc_descriptor (x0));
6538 add_loc_descr (&cc_loc_result,
6539 new_loc_descr (DW_OP_piece, GET_MODE_SIZE (GET_MODE (x0)), 0));
6541 if (!is_pseudo_reg (x1)
6542 && (GET_CODE (x1) != MEM || !is_pseudo_reg (XEXP (x1, 0))))
6543 add_loc_descr (&cc_loc_result, loc_descriptor (x1));
6544 add_loc_descr (&cc_loc_result,
6545 new_loc_descr (DW_OP_piece, GET_MODE_SIZE (GET_MODE (x1)), 0));
6547 return cc_loc_result;
6550 /* Output a proper Dwarf location descriptor for a variable or parameter
6551 which is either allocated in a register or in a memory location. For a
6552 register, we just generate an OP_REG and the register number. For a
6553 memory location we provide a Dwarf postfix expression describing how to
6554 generate the (dynamic) address of the object onto the address stack. */
6556 static dw_loc_descr_ref
6557 loc_descriptor (rtl)
6560 dw_loc_descr_ref loc_result = NULL;
6561 switch (GET_CODE (rtl))
6564 /* The case of a subreg may arise when we have a local (register)
6565 variable or a formal (register) parameter which doesn't quite fill
6566 up an entire register. For now, just assume that it is
6567 legitimate to make the Dwarf info refer to the whole register which
6568 contains the given subreg. */
6569 rtl = XEXP (rtl, 0);
6571 /* ... fall through ... */
6574 loc_result = reg_loc_descriptor (rtl);
6578 loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl));
6582 loc_result = concat_loc_descriptor (XEXP (rtl, 0), XEXP (rtl, 1));
6592 /* Given an unsigned value, round it up to the lowest multiple of `boundary'
6593 which is not less than the value itself. */
6595 static inline unsigned
6596 ceiling (value, boundary)
6597 register unsigned value;
6598 register unsigned boundary;
6600 return (((value + boundary - 1) / boundary) * boundary);
6603 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
6604 pointer to the declared type for the relevant field variable, or return
6605 `integer_type_node' if the given node turns out to be an
6614 if (TREE_CODE (decl) == ERROR_MARK)
6615 return integer_type_node;
6617 type = DECL_BIT_FIELD_TYPE (decl);
6618 if (type == NULL_TREE)
6619 type = TREE_TYPE (decl);
6624 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
6625 node, return the alignment in bits for the type, or else return
6626 BITS_PER_WORD if the node actually turns out to be an
6629 static inline unsigned
6630 simple_type_align_in_bits (type)
6633 return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD;
6636 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
6637 node, return the size in bits for the type if it is a constant, or else
6638 return the alignment for the type if the type's size is not constant, or
6639 else return BITS_PER_WORD if the type actually turns out to be an
6642 static inline unsigned
6643 simple_type_size_in_bits (type)
6646 if (TREE_CODE (type) == ERROR_MARK)
6647 return BITS_PER_WORD;
6650 register tree type_size_tree = TYPE_SIZE (type);
6652 if (TREE_CODE (type_size_tree) != INTEGER_CST)
6653 return TYPE_ALIGN (type);
6655 return (unsigned) TREE_INT_CST_LOW (type_size_tree);
6659 /* Given a pointer to what is assumed to be a FIELD_DECL node, compute and
6660 return the byte offset of the lowest addressed byte of the "containing
6661 object" for the given FIELD_DECL, or return 0 if we are unable to
6662 determine what that offset is, either because the argument turns out to
6663 be a pointer to an ERROR_MARK node, or because the offset is actually
6664 variable. (We can't handle the latter case just yet). */
6667 field_byte_offset (decl)
6670 register unsigned type_align_in_bytes;
6671 register unsigned type_align_in_bits;
6672 register unsigned type_size_in_bits;
6673 register unsigned object_offset_in_align_units;
6674 register unsigned object_offset_in_bits;
6675 register unsigned object_offset_in_bytes;
6677 register tree bitpos_tree;
6678 register tree field_size_tree;
6679 register unsigned bitpos_int;
6680 register unsigned deepest_bitpos;
6681 register unsigned field_size_in_bits;
6683 if (TREE_CODE (decl) == ERROR_MARK)
6686 if (TREE_CODE (decl) != FIELD_DECL)
6689 type = field_type (decl);
6691 bitpos_tree = DECL_FIELD_BITPOS (decl);
6692 field_size_tree = DECL_SIZE (decl);
6694 /* If there was an error, the size could be zero. */
6695 if (! field_size_tree)
6702 /* We cannot yet cope with fields whose positions are variable, so
6703 for now, when we see such things, we simply return 0. Someday, we may
6704 be able to handle such cases, but it will be damn difficult. */
6705 if (TREE_CODE (bitpos_tree) != INTEGER_CST)
6708 bitpos_int = (unsigned) TREE_INT_CST_LOW (bitpos_tree);
6710 /* If we don't know the size of the field, pretend it's a full word. */
6711 if (TREE_CODE (field_size_tree) == INTEGER_CST)
6712 field_size_in_bits = (unsigned) TREE_INT_CST_LOW (field_size_tree);
6714 field_size_in_bits = BITS_PER_WORD;
6716 type_size_in_bits = simple_type_size_in_bits (type);
6717 type_align_in_bits = simple_type_align_in_bits (type);
6718 type_align_in_bytes = type_align_in_bits / BITS_PER_UNIT;
6720 /* Note that the GCC front-end doesn't make any attempt to keep track of
6721 the starting bit offset (relative to the start of the containing
6722 structure type) of the hypothetical "containing object" for a bit-
6723 field. Thus, when computing the byte offset value for the start of the
6724 "containing object" of a bit-field, we must deduce this information on
6725 our own. This can be rather tricky to do in some cases. For example,
6726 handling the following structure type definition when compiling for an
6727 i386/i486 target (which only aligns long long's to 32-bit boundaries)
6730 struct S { int field1; long long field2:31; };
6732 Fortunately, there is a simple rule-of-thumb which can be
6733 used in such cases. When compiling for an i386/i486, GCC will allocate
6734 8 bytes for the structure shown above. It decides to do this based upon
6735 one simple rule for bit-field allocation. Quite simply, GCC allocates
6736 each "containing object" for each bit-field at the first (i.e. lowest
6737 addressed) legitimate alignment boundary (based upon the required
6738 minimum alignment for the declared type of the field) which it can
6739 possibly use, subject to the condition that there is still enough
6740 available space remaining in the containing object (when allocated at
6741 the selected point) to fully accommodate all of the bits of the
6742 bit-field itself. This simple rule makes it obvious why GCC allocates
6743 8 bytes for each object of the structure type shown above. When looking
6744 for a place to allocate the "containing object" for `field2', the
6745 compiler simply tries to allocate a 64-bit "containing object" at each
6746 successive 32-bit boundary (starting at zero) until it finds a place to
6747 allocate that 64- bit field such that at least 31 contiguous (and
6748 previously unallocated) bits remain within that selected 64 bit field.
6749 (As it turns out, for the example above, the compiler finds that it is
6750 OK to allocate the "containing object" 64-bit field at bit-offset zero
6751 within the structure type.) Here we attempt to work backwards from the
6752 limited set of facts we're given, and we try to deduce from those facts,
6753 where GCC must have believed that the containing object started (within
6754 the structure type). The value we deduce is then used (by the callers of
6755 this routine) to generate DW_AT_location and DW_AT_bit_offset attributes
6756 for fields (both bit-fields and, in the case of DW_AT_location, regular
6759 /* Figure out the bit-distance from the start of the structure to the
6760 "deepest" bit of the bit-field. */
6761 deepest_bitpos = bitpos_int + field_size_in_bits;
6763 /* This is the tricky part. Use some fancy footwork to deduce where the
6764 lowest addressed bit of the containing object must be. */
6765 object_offset_in_bits
6766 = ceiling (deepest_bitpos, type_align_in_bits) - type_size_in_bits;
6768 /* Compute the offset of the containing object in "alignment units". */
6769 object_offset_in_align_units = object_offset_in_bits / type_align_in_bits;
6771 /* Compute the offset of the containing object in bytes. */
6772 object_offset_in_bytes = object_offset_in_align_units * type_align_in_bytes;
6774 return object_offset_in_bytes;
6777 /* The following routines define various Dwarf attributes and any data
6778 associated with them. */
6780 /* Add a location description attribute value to a DIE.
6782 This emits location attributes suitable for whole variables and
6783 whole parameters. Note that the location attributes for struct fields are
6784 generated by the routine `data_member_location_attribute' below. */
6787 add_AT_location_description (die, attr_kind, rtl)
6789 enum dwarf_attribute attr_kind;
6792 /* Handle a special case. If we are about to output a location descriptor
6793 for a variable or parameter which has been optimized out of existence,
6794 don't do that. A variable which has been optimized out
6795 of existence will have a DECL_RTL value which denotes a pseudo-reg.
6796 Currently, in some rare cases, variables can have DECL_RTL values which
6797 look like (MEM (REG pseudo-reg#)). These cases are due to bugs
6798 elsewhere in the compiler. We treat such cases as if the variable(s) in
6799 question had been optimized out of existence. */
6801 if (is_pseudo_reg (rtl)
6802 || (GET_CODE (rtl) == MEM
6803 && is_pseudo_reg (XEXP (rtl, 0)))
6804 /* This can happen for a PARM_DECL with a DECL_INCOMING_RTL which
6805 references the internal argument pointer (a pseudo) in a function
6806 where all references to the internal argument pointer were
6807 eliminated via the optimizers. */
6808 || (GET_CODE (rtl) == MEM
6809 && GET_CODE (XEXP (rtl, 0)) == PLUS
6810 && is_pseudo_reg (XEXP (XEXP (rtl, 0), 0)))
6811 || (GET_CODE (rtl) == CONCAT
6812 && is_pseudo_reg (XEXP (rtl, 0))
6813 && is_pseudo_reg (XEXP (rtl, 1))))
6816 add_AT_loc (die, attr_kind, loc_descriptor (rtl));
6819 /* Attach the specialized form of location attribute used for data
6820 members of struct and union types. In the special case of a
6821 FIELD_DECL node which represents a bit-field, the "offset" part
6822 of this special location descriptor must indicate the distance
6823 in bytes from the lowest-addressed byte of the containing struct
6824 or union type to the lowest-addressed byte of the "containing
6825 object" for the bit-field. (See the `field_byte_offset' function
6826 above).. For any given bit-field, the "containing object" is a
6827 hypothetical object (of some integral or enum type) within which
6828 the given bit-field lives. The type of this hypothetical
6829 "containing object" is always the same as the declared type of
6830 the individual bit-field itself (for GCC anyway... the DWARF
6831 spec doesn't actually mandate this). Note that it is the size
6832 (in bytes) of the hypothetical "containing object" which will
6833 be given in the DW_AT_byte_size attribute for this bit-field.
6834 (See the `byte_size_attribute' function below.) It is also used
6835 when calculating the value of the DW_AT_bit_offset attribute.
6836 (See the `bit_offset_attribute' function below). */
6839 add_data_member_location_attribute (die, decl)
6840 register dw_die_ref die;
6843 register unsigned long offset;
6844 register dw_loc_descr_ref loc_descr;
6845 register enum dwarf_location_atom op;
6847 if (TREE_CODE (decl) == TREE_VEC)
6848 offset = TREE_INT_CST_LOW (BINFO_OFFSET (decl));
6850 offset = field_byte_offset (decl);
6852 /* The DWARF2 standard says that we should assume that the structure address
6853 is already on the stack, so we can specify a structure field address
6854 by using DW_OP_plus_uconst. */
6856 #ifdef MIPS_DEBUGGING_INFO
6857 /* ??? The SGI dwarf reader does not handle the DW_OP_plus_uconst operator
6858 correctly. It works only if we leave the offset on the stack. */
6861 op = DW_OP_plus_uconst;
6864 loc_descr = new_loc_descr (op, offset, 0);
6865 add_AT_loc (die, DW_AT_data_member_location, loc_descr);
6868 /* Attach an DW_AT_const_value attribute for a variable or a parameter which
6869 does not have a "location" either in memory or in a register. These
6870 things can arise in GNU C when a constant is passed as an actual parameter
6871 to an inlined function. They can also arise in C++ where declared
6872 constants do not necessarily get memory "homes". */
6875 add_const_value_attribute (die, rtl)
6876 register dw_die_ref die;
6879 switch (GET_CODE (rtl))
6882 /* Note that a CONST_INT rtx could represent either an integer or a
6883 floating-point constant. A CONST_INT is used whenever the constant
6884 will fit into a single word. In all such cases, the original mode
6885 of the constant value is wiped out, and the CONST_INT rtx is
6886 assigned VOIDmode. */
6887 add_AT_unsigned (die, DW_AT_const_value, (unsigned) INTVAL (rtl));
6891 /* Note that a CONST_DOUBLE rtx could represent either an integer or a
6892 floating-point constant. A CONST_DOUBLE is used whenever the
6893 constant requires more than one word in order to be adequately
6894 represented. We output CONST_DOUBLEs as blocks. */
6896 register enum machine_mode mode = GET_MODE (rtl);
6898 if (GET_MODE_CLASS (mode) == MODE_FLOAT)
6900 register unsigned length = GET_MODE_SIZE (mode) / sizeof (long);
6904 REAL_VALUE_FROM_CONST_DOUBLE (rv, rtl);
6908 REAL_VALUE_TO_TARGET_SINGLE (rv, array[0]);
6912 REAL_VALUE_TO_TARGET_DOUBLE (rv, array);
6917 REAL_VALUE_TO_TARGET_LONG_DOUBLE (rv, array);
6924 add_AT_float (die, DW_AT_const_value, length, array);
6927 add_AT_long_long (die, DW_AT_const_value,
6928 CONST_DOUBLE_HIGH (rtl), CONST_DOUBLE_LOW (rtl));
6933 add_AT_string (die, DW_AT_const_value, XSTR (rtl, 0));
6939 add_AT_addr (die, DW_AT_const_value, addr_to_string (rtl));
6943 /* In cases where an inlined instance of an inline function is passed
6944 the address of an `auto' variable (which is local to the caller) we
6945 can get a situation where the DECL_RTL of the artificial local
6946 variable (for the inlining) which acts as a stand-in for the
6947 corresponding formal parameter (of the inline function) will look
6948 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not
6949 exactly a compile-time constant expression, but it isn't the address
6950 of the (artificial) local variable either. Rather, it represents the
6951 *value* which the artificial local variable always has during its
6952 lifetime. We currently have no way to represent such quasi-constant
6953 values in Dwarf, so for now we just punt and generate nothing. */
6957 /* No other kinds of rtx should be possible here. */
6963 /* Generate *either* an DW_AT_location attribute or else an DW_AT_const_value
6964 data attribute for a variable or a parameter. We generate the
6965 DW_AT_const_value attribute only in those cases where the given variable
6966 or parameter does not have a true "location" either in memory or in a
6967 register. This can happen (for example) when a constant is passed as an
6968 actual argument in a call to an inline function. (It's possible that
6969 these things can crop up in other ways also.) Note that one type of
6970 constant value which can be passed into an inlined function is a constant
6971 pointer. This can happen for example if an actual argument in an inlined
6972 function call evaluates to a compile-time constant address. */
6975 add_location_or_const_value_attribute (die, decl)
6976 register dw_die_ref die;
6980 register tree declared_type;
6981 register tree passed_type;
6983 if (TREE_CODE (decl) == ERROR_MARK)
6986 if (TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != PARM_DECL)
6989 /* Here we have to decide where we are going to say the parameter "lives"
6990 (as far as the debugger is concerned). We only have a couple of
6991 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
6993 DECL_RTL normally indicates where the parameter lives during most of the
6994 activation of the function. If optimization is enabled however, this
6995 could be either NULL or else a pseudo-reg. Both of those cases indicate
6996 that the parameter doesn't really live anywhere (as far as the code
6997 generation parts of GCC are concerned) during most of the function's
6998 activation. That will happen (for example) if the parameter is never
6999 referenced within the function.
7001 We could just generate a location descriptor here for all non-NULL
7002 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
7003 a little nicer than that if we also consider DECL_INCOMING_RTL in cases
7004 where DECL_RTL is NULL or is a pseudo-reg.
7006 Note however that we can only get away with using DECL_INCOMING_RTL as
7007 a backup substitute for DECL_RTL in certain limited cases. In cases
7008 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
7009 we can be sure that the parameter was passed using the same type as it is
7010 declared to have within the function, and that its DECL_INCOMING_RTL
7011 points us to a place where a value of that type is passed.
7013 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
7014 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
7015 because in these cases DECL_INCOMING_RTL points us to a value of some
7016 type which is *different* from the type of the parameter itself. Thus,
7017 if we tried to use DECL_INCOMING_RTL to generate a location attribute in
7018 such cases, the debugger would end up (for example) trying to fetch a
7019 `float' from a place which actually contains the first part of a
7020 `double'. That would lead to really incorrect and confusing
7021 output at debug-time.
7023 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
7024 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There
7025 are a couple of exceptions however. On little-endian machines we can
7026 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
7027 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
7028 an integral type that is smaller than TREE_TYPE (decl). These cases arise
7029 when (on a little-endian machine) a non-prototyped function has a
7030 parameter declared to be of type `short' or `char'. In such cases,
7031 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
7032 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
7033 passed `int' value. If the debugger then uses that address to fetch
7034 a `short' or a `char' (on a little-endian machine) the result will be
7035 the correct data, so we allow for such exceptional cases below.
7037 Note that our goal here is to describe the place where the given formal
7038 parameter lives during most of the function's activation (i.e. between
7039 the end of the prologue and the start of the epilogue). We'll do that
7040 as best as we can. Note however that if the given formal parameter is
7041 modified sometime during the execution of the function, then a stack
7042 backtrace (at debug-time) will show the function as having been
7043 called with the *new* value rather than the value which was
7044 originally passed in. This happens rarely enough that it is not
7045 a major problem, but it *is* a problem, and I'd like to fix it.
7047 A future version of dwarf2out.c may generate two additional
7048 attributes for any given DW_TAG_formal_parameter DIE which will
7049 describe the "passed type" and the "passed location" for the
7050 given formal parameter in addition to the attributes we now
7051 generate to indicate the "declared type" and the "active
7052 location" for each parameter. This additional set of attributes
7053 could be used by debuggers for stack backtraces. Separately, note
7054 that sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be
7055 NULL also. This happens (for example) for inlined-instances of
7056 inline function formal parameters which are never referenced.
7057 This really shouldn't be happening. All PARM_DECL nodes should
7058 get valid non-NULL DECL_INCOMING_RTL values, but integrate.c
7059 doesn't currently generate these values for inlined instances of
7060 inline function parameters, so when we see such cases, we are
7061 just out-of-luck for the time being (until integrate.c
7064 /* Use DECL_RTL as the "location" unless we find something better. */
7065 rtl = DECL_RTL (decl);
7067 if (TREE_CODE (decl) == PARM_DECL)
7069 if (rtl == NULL_RTX || is_pseudo_reg (rtl))
7071 declared_type = type_main_variant (TREE_TYPE (decl));
7072 passed_type = type_main_variant (DECL_ARG_TYPE (decl));
7074 /* This decl represents a formal parameter which was optimized out.
7075 Note that DECL_INCOMING_RTL may be NULL in here, but we handle
7076 all* cases where (rtl == NULL_RTX) just below. */
7077 if (declared_type == passed_type)
7078 rtl = DECL_INCOMING_RTL (decl);
7079 else if (! BYTES_BIG_ENDIAN
7080 && TREE_CODE (declared_type) == INTEGER_TYPE
7081 && (GET_MODE_SIZE (TYPE_MODE (declared_type))
7082 <= GET_MODE_SIZE (TYPE_MODE (passed_type))))
7083 rtl = DECL_INCOMING_RTL (decl);
7086 /* If the parm was passed in registers, but lives on the stack, then
7087 make a big endian correction if the mode of the type of the
7088 parameter is not the same as the mode of the rtl. */
7089 /* ??? This is the same series of checks that are made in dbxout.c before
7090 we reach the big endian correction code there. It isn't clear if all
7091 of these checks are necessary here, but keeping them all is the safe
7093 else if (GET_CODE (rtl) == MEM
7094 && XEXP (rtl, 0) != const0_rtx
7095 && ! CONSTANT_P (XEXP (rtl, 0))
7096 /* Not passed in memory. */
7097 && GET_CODE (DECL_INCOMING_RTL (decl)) != MEM
7098 /* Not passed by invisible reference. */
7099 && (GET_CODE (XEXP (rtl, 0)) != REG
7100 || REGNO (XEXP (rtl, 0)) == HARD_FRAME_POINTER_REGNUM
7101 || REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM
7102 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
7103 || REGNO (XEXP (rtl, 0)) == ARG_POINTER_REGNUM
7106 /* Big endian correction check. */
7108 && TYPE_MODE (TREE_TYPE (decl)) != GET_MODE (rtl)
7109 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)))
7112 int offset = (UNITS_PER_WORD
7113 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl))));
7114 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
7115 plus_constant (XEXP (rtl, 0), offset));
7119 if (rtl == NULL_RTX)
7122 rtl = eliminate_regs (rtl, 0, NULL_RTX);
7123 #ifdef LEAF_REG_REMAP
7124 if (current_function_uses_only_leaf_regs)
7125 leaf_renumber_regs_insn (rtl);
7128 switch (GET_CODE (rtl))
7131 /* The address of a variable that was optimized away; don't emit
7142 /* DECL_RTL could be (plus (reg ...) (const_int ...)) */
7143 add_const_value_attribute (die, rtl);
7150 add_AT_location_description (die, DW_AT_location, rtl);
7158 /* Generate an DW_AT_name attribute given some string value to be included as
7159 the value of the attribute. */
7162 add_name_attribute (die, name_string)
7163 register dw_die_ref die;
7164 register const char *name_string;
7166 if (name_string != NULL && *name_string != 0)
7168 if (demangle_name_func)
7169 name_string = (*demangle_name_func) (name_string);
7171 add_AT_string (die, DW_AT_name, name_string);
7175 /* Given a tree node describing an array bound (either lower or upper) output
7176 a representation for that bound. */
7179 add_bound_info (subrange_die, bound_attr, bound)
7180 register dw_die_ref subrange_die;
7181 register enum dwarf_attribute bound_attr;
7182 register tree bound;
7184 register unsigned bound_value = 0;
7186 /* If this is an Ada unconstrained array type, then don't emit any debug
7187 info because the array bounds are unknown. They are parameterized when
7188 the type is instantiated. */
7189 if (contains_placeholder_p (bound))
7192 switch (TREE_CODE (bound))
7197 /* All fixed-bounds are represented by INTEGER_CST nodes. */
7199 bound_value = TREE_INT_CST_LOW (bound);
7200 if (bound_attr == DW_AT_lower_bound
7201 && ((is_c_family () && bound_value == 0)
7202 || (is_fortran () && bound_value == 1)))
7203 /* use the default */;
7205 add_AT_unsigned (subrange_die, bound_attr, bound_value);
7210 case NON_LVALUE_EXPR:
7211 add_bound_info (subrange_die, bound_attr, TREE_OPERAND (bound, 0));
7215 /* If optimization is turned on, the SAVE_EXPRs that describe how to
7216 access the upper bound values may be bogus. If they refer to a
7217 register, they may only describe how to get at these values at the
7218 points in the generated code right after they have just been
7219 computed. Worse yet, in the typical case, the upper bound values
7220 will not even *be* computed in the optimized code (though the
7221 number of elements will), so these SAVE_EXPRs are entirely
7222 bogus. In order to compensate for this fact, we check here to see
7223 if optimization is enabled, and if so, we don't add an attribute
7224 for the (unknown and unknowable) upper bound. This should not
7225 cause too much trouble for existing (stupid?) debuggers because
7226 they have to deal with empty upper bounds location descriptions
7227 anyway in order to be able to deal with incomplete array types.
7228 Of course an intelligent debugger (GDB?) should be able to
7229 comprehend that a missing upper bound specification in a array
7230 type used for a storage class `auto' local array variable
7231 indicates that the upper bound is both unknown (at compile- time)
7232 and unknowable (at run-time) due to optimization.
7234 We assume that a MEM rtx is safe because gcc wouldn't put the
7235 value there unless it was going to be used repeatedly in the
7236 function, i.e. for cleanups. */
7237 if (! optimize || GET_CODE (SAVE_EXPR_RTL (bound)) == MEM)
7239 register dw_die_ref ctx = lookup_decl_die (current_function_decl);
7240 register dw_die_ref decl_die = new_die (DW_TAG_variable, ctx);
7241 register rtx loc = SAVE_EXPR_RTL (bound);
7243 /* If the RTL for the SAVE_EXPR is memory, handle the case where
7244 it references an outer function's frame. */
7246 if (GET_CODE (loc) == MEM)
7248 rtx new_addr = fix_lexical_addr (XEXP (loc, 0), bound);
7250 if (XEXP (loc, 0) != new_addr)
7251 loc = gen_rtx_MEM (GET_MODE (loc), new_addr);
7254 add_AT_flag (decl_die, DW_AT_artificial, 1);
7255 add_type_attribute (decl_die, TREE_TYPE (bound), 1, 0, ctx);
7256 add_AT_location_description (decl_die, DW_AT_location, loc);
7257 add_AT_die_ref (subrange_die, bound_attr, decl_die);
7260 /* Else leave out the attribute. */
7266 /* ??? These types of bounds can be created by the Ada front end,
7267 and it isn't clear how to emit debug info for them. */
7275 /* Note that the block of subscript information for an array type also
7276 includes information about the element type of type given array type. */
7279 add_subscript_info (type_die, type)
7280 register dw_die_ref type_die;
7283 #ifndef MIPS_DEBUGGING_INFO
7284 register unsigned dimension_number;
7286 register tree lower, upper;
7287 register dw_die_ref subrange_die;
7289 /* The GNU compilers represent multidimensional array types as sequences of
7290 one dimensional array types whose element types are themselves array
7291 types. Here we squish that down, so that each multidimensional array
7292 type gets only one array_type DIE in the Dwarf debugging info. The draft
7293 Dwarf specification say that we are allowed to do this kind of
7294 compression in C (because there is no difference between an array or
7295 arrays and a multidimensional array in C) but for other source languages
7296 (e.g. Ada) we probably shouldn't do this. */
7298 /* ??? The SGI dwarf reader fails for multidimensional arrays with a
7299 const enum type. E.g. const enum machine_mode insn_operand_mode[2][10].
7300 We work around this by disabling this feature. See also
7301 gen_array_type_die. */
7302 #ifndef MIPS_DEBUGGING_INFO
7303 for (dimension_number = 0;
7304 TREE_CODE (type) == ARRAY_TYPE;
7305 type = TREE_TYPE (type), dimension_number++)
7308 register tree domain = TYPE_DOMAIN (type);
7310 /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
7311 and (in GNU C only) variable bounds. Handle all three forms
7313 subrange_die = new_die (DW_TAG_subrange_type, type_die);
7316 /* We have an array type with specified bounds. */
7317 lower = TYPE_MIN_VALUE (domain);
7318 upper = TYPE_MAX_VALUE (domain);
7320 /* define the index type. */
7321 if (TREE_TYPE (domain))
7323 /* ??? This is probably an Ada unnamed subrange type. Ignore the
7324 TREE_TYPE field. We can't emit debug info for this
7325 because it is an unnamed integral type. */
7326 if (TREE_CODE (domain) == INTEGER_TYPE
7327 && TYPE_NAME (domain) == NULL_TREE
7328 && TREE_CODE (TREE_TYPE (domain)) == INTEGER_TYPE
7329 && TYPE_NAME (TREE_TYPE (domain)) == NULL_TREE)
7332 add_type_attribute (subrange_die, TREE_TYPE (domain), 0, 0,
7336 /* ??? If upper is NULL, the array has unspecified length,
7337 but it does have a lower bound. This happens with Fortran
7339 Since the debugger is definitely going to need to know N
7340 to produce useful results, go ahead and output the lower
7341 bound solo, and hope the debugger can cope. */
7343 add_bound_info (subrange_die, DW_AT_lower_bound, lower);
7345 add_bound_info (subrange_die, DW_AT_upper_bound, upper);
7348 /* We have an array type with an unspecified length. The DWARF-2
7349 spec does not say how to handle this; let's just leave out the
7354 #ifndef MIPS_DEBUGGING_INFO
7360 add_byte_size_attribute (die, tree_node)
7362 register tree tree_node;
7364 register unsigned size;
7366 switch (TREE_CODE (tree_node))
7374 case QUAL_UNION_TYPE:
7375 size = int_size_in_bytes (tree_node);
7378 /* For a data member of a struct or union, the DW_AT_byte_size is
7379 generally given as the number of bytes normally allocated for an
7380 object of the *declared* type of the member itself. This is true
7381 even for bit-fields. */
7382 size = simple_type_size_in_bits (field_type (tree_node)) / BITS_PER_UNIT;
7388 /* Note that `size' might be -1 when we get to this point. If it is, that
7389 indicates that the byte size of the entity in question is variable. We
7390 have no good way of expressing this fact in Dwarf at the present time,
7391 so just let the -1 pass on through. */
7393 add_AT_unsigned (die, DW_AT_byte_size, size);
7396 /* For a FIELD_DECL node which represents a bit-field, output an attribute
7397 which specifies the distance in bits from the highest order bit of the
7398 "containing object" for the bit-field to the highest order bit of the
7401 For any given bit-field, the "containing object" is a hypothetical
7402 object (of some integral or enum type) within which the given bit-field
7403 lives. The type of this hypothetical "containing object" is always the
7404 same as the declared type of the individual bit-field itself. The
7405 determination of the exact location of the "containing object" for a
7406 bit-field is rather complicated. It's handled by the
7407 `field_byte_offset' function (above).
7409 Note that it is the size (in bytes) of the hypothetical "containing object"
7410 which will be given in the DW_AT_byte_size attribute for this bit-field.
7411 (See `byte_size_attribute' above). */
7414 add_bit_offset_attribute (die, decl)
7415 register dw_die_ref die;
7418 register unsigned object_offset_in_bytes = field_byte_offset (decl);
7419 register tree type = DECL_BIT_FIELD_TYPE (decl);
7420 register tree bitpos_tree = DECL_FIELD_BITPOS (decl);
7421 register unsigned bitpos_int;
7422 register unsigned highest_order_object_bit_offset;
7423 register unsigned highest_order_field_bit_offset;
7424 register unsigned bit_offset;
7426 /* Must be a field and a bit field. */
7428 || TREE_CODE (decl) != FIELD_DECL)
7431 /* We can't yet handle bit-fields whose offsets are variable, so if we
7432 encounter such things, just return without generating any attribute
7434 if (TREE_CODE (bitpos_tree) != INTEGER_CST)
7437 bitpos_int = (unsigned) TREE_INT_CST_LOW (bitpos_tree);
7439 /* Note that the bit offset is always the distance (in bits) from the
7440 highest-order bit of the "containing object" to the highest-order bit of
7441 the bit-field itself. Since the "high-order end" of any object or field
7442 is different on big-endian and little-endian machines, the computation
7443 below must take account of these differences. */
7444 highest_order_object_bit_offset = object_offset_in_bytes * BITS_PER_UNIT;
7445 highest_order_field_bit_offset = bitpos_int;
7447 if (! BYTES_BIG_ENDIAN)
7449 highest_order_field_bit_offset
7450 += (unsigned) TREE_INT_CST_LOW (DECL_SIZE (decl));
7452 highest_order_object_bit_offset += simple_type_size_in_bits (type);
7456 = (! BYTES_BIG_ENDIAN
7457 ? highest_order_object_bit_offset - highest_order_field_bit_offset
7458 : highest_order_field_bit_offset - highest_order_object_bit_offset);
7460 add_AT_unsigned (die, DW_AT_bit_offset, bit_offset);
7463 /* For a FIELD_DECL node which represents a bit field, output an attribute
7464 which specifies the length in bits of the given field. */
7467 add_bit_size_attribute (die, decl)
7468 register dw_die_ref die;
7471 /* Must be a field and a bit field. */
7472 if (TREE_CODE (decl) != FIELD_DECL
7473 || ! DECL_BIT_FIELD_TYPE (decl))
7475 add_AT_unsigned (die, DW_AT_bit_size,
7476 (unsigned) TREE_INT_CST_LOW (DECL_SIZE (decl)));
7479 /* If the compiled language is ANSI C, then add a 'prototyped'
7480 attribute, if arg types are given for the parameters of a function. */
7483 add_prototyped_attribute (die, func_type)
7484 register dw_die_ref die;
7485 register tree func_type;
7487 if (get_AT_unsigned (comp_unit_die, DW_AT_language) == DW_LANG_C89
7488 && TYPE_ARG_TYPES (func_type) != NULL)
7489 add_AT_flag (die, DW_AT_prototyped, 1);
7493 /* Add an 'abstract_origin' attribute below a given DIE. The DIE is found
7494 by looking in either the type declaration or object declaration
7498 add_abstract_origin_attribute (die, origin)
7499 register dw_die_ref die;
7500 register tree origin;
7502 dw_die_ref origin_die = NULL;
7504 /* We may have gotten separated from the block for the inlined
7505 function, if we're in an exception handler or some such; make
7506 sure that the abstract function has been written out. */
7507 tree fn = decl_function_context (origin);
7509 gen_abstract_function (fn);
7511 if (TREE_CODE_CLASS (TREE_CODE (origin)) == 'd')
7512 origin_die = lookup_decl_die (origin);
7513 else if (TREE_CODE_CLASS (TREE_CODE (origin)) == 't')
7514 origin_die = lookup_type_die (origin);
7516 if (origin_die == NULL)
7519 add_AT_die_ref (die, DW_AT_abstract_origin, origin_die);
7522 /* We do not currently support the pure_virtual attribute. */
7525 add_pure_or_virtual_attribute (die, func_decl)
7526 register dw_die_ref die;
7527 register tree func_decl;
7529 if (DECL_VINDEX (func_decl))
7531 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
7532 add_AT_loc (die, DW_AT_vtable_elem_location,
7533 new_loc_descr (DW_OP_constu,
7534 TREE_INT_CST_LOW (DECL_VINDEX (func_decl)),
7537 /* GNU extension: Record what type this method came from originally. */
7538 if (debug_info_level > DINFO_LEVEL_TERSE)
7539 add_AT_die_ref (die, DW_AT_containing_type,
7540 lookup_type_die (DECL_CONTEXT (func_decl)));
7544 /* Add source coordinate attributes for the given decl. */
7547 add_src_coords_attributes (die, decl)
7548 register dw_die_ref die;
7551 register unsigned file_index = lookup_filename (DECL_SOURCE_FILE (decl));
7553 add_AT_unsigned (die, DW_AT_decl_file, file_index);
7554 add_AT_unsigned (die, DW_AT_decl_line, DECL_SOURCE_LINE (decl));
7557 /* Add an DW_AT_name attribute and source coordinate attribute for the
7558 given decl, but only if it actually has a name. */
7561 add_name_and_src_coords_attributes (die, decl)
7562 register dw_die_ref die;
7565 register tree decl_name;
7567 decl_name = DECL_NAME (decl);
7568 if (decl_name != NULL && IDENTIFIER_POINTER (decl_name) != NULL)
7570 add_name_attribute (die, dwarf2_name (decl, 0));
7571 if (! DECL_ARTIFICIAL (decl))
7572 add_src_coords_attributes (die, decl);
7574 if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
7575 && DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
7576 add_AT_string (die, DW_AT_MIPS_linkage_name,
7577 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
7581 /* Push a new declaration scope. */
7584 push_decl_scope (scope)
7587 /* Make room in the decl_scope_table, if necessary. */
7588 if (decl_scope_table_allocated == decl_scope_depth)
7590 decl_scope_table_allocated += DECL_SCOPE_TABLE_INCREMENT;
7592 = (tree *) xrealloc (decl_scope_table,
7593 decl_scope_table_allocated * sizeof (tree));
7596 decl_scope_table[decl_scope_depth] = scope;
7600 /* Pop a declaration scope. */
7604 if (decl_scope_depth <= 0)
7609 /* Return the DIE for the scope that immediately contains this type.
7610 Non-named types get global scope. Named types nested in other
7611 types get their containing scope if it's open, or global scope
7612 otherwise. All other types (i.e. function-local named types) get
7613 the current active scope. */
7616 scope_die_for (t, context_die)
7618 register dw_die_ref context_die;
7620 register dw_die_ref scope_die = NULL;
7621 register tree containing_scope;
7624 /* Non-types always go in the current scope. */
7628 containing_scope = TYPE_CONTEXT (t);
7630 /* Ignore namespaces for the moment. */
7631 if (containing_scope && TREE_CODE (containing_scope) == NAMESPACE_DECL)
7632 containing_scope = NULL_TREE;
7634 /* Ignore function type "scopes" from the C frontend. They mean that
7635 a tagged type is local to a parmlist of a function declarator, but
7636 that isn't useful to DWARF. */
7637 if (containing_scope && TREE_CODE (containing_scope) == FUNCTION_TYPE)
7638 containing_scope = NULL_TREE;
7640 if (containing_scope == NULL_TREE)
7641 scope_die = comp_unit_die;
7642 else if (TYPE_P (containing_scope))
7644 /* For types, we can just look up the appropriate DIE. But
7645 first we check to see if we're in the middle of emitting it
7646 so we know where the new DIE should go. */
7648 for (i = decl_scope_depth - 1; i >= 0; --i)
7649 if (decl_scope_table[i] == containing_scope)
7654 if (debug_info_level > DINFO_LEVEL_TERSE
7655 && !TREE_ASM_WRITTEN (containing_scope))
7658 /* If none of the current dies are suitable, we get file scope. */
7659 scope_die = comp_unit_die;
7662 scope_die = lookup_type_die (containing_scope);
7665 scope_die = context_die;
7670 /* Returns nonzero iff CONTEXT_DIE is internal to a function. */
7673 local_scope_p (context_die)
7674 dw_die_ref context_die;
7676 for (; context_die; context_die = context_die->die_parent)
7677 if (context_die->die_tag == DW_TAG_inlined_subroutine
7678 || context_die->die_tag == DW_TAG_subprogram)
7683 /* Returns nonzero iff CONTEXT_DIE is a class. */
7686 class_scope_p (context_die)
7687 dw_die_ref context_die;
7690 && (context_die->die_tag == DW_TAG_structure_type
7691 || context_die->die_tag == DW_TAG_union_type));
7694 /* Many forms of DIEs require a "type description" attribute. This
7695 routine locates the proper "type descriptor" die for the type given
7696 by 'type', and adds an DW_AT_type attribute below the given die. */
7699 add_type_attribute (object_die, type, decl_const, decl_volatile, context_die)
7700 register dw_die_ref object_die;
7702 register int decl_const;
7703 register int decl_volatile;
7704 register dw_die_ref context_die;
7706 register enum tree_code code = TREE_CODE (type);
7707 register dw_die_ref type_die = NULL;
7709 /* ??? If this type is an unnamed subrange type of an integral or
7710 floating-point type, use the inner type. This is because we have no
7711 support for unnamed types in base_type_die. This can happen if this is
7712 an Ada subrange type. Correct solution is emit a subrange type die. */
7713 if ((code == INTEGER_TYPE || code == REAL_TYPE)
7714 && TREE_TYPE (type) != 0 && TYPE_NAME (type) == 0)
7715 type = TREE_TYPE (type), code = TREE_CODE (type);
7717 if (code == ERROR_MARK)
7720 /* Handle a special case. For functions whose return type is void, we
7721 generate *no* type attribute. (Note that no object may have type
7722 `void', so this only applies to function return types). */
7723 if (code == VOID_TYPE)
7726 type_die = modified_type_die (type,
7727 decl_const || TYPE_READONLY (type),
7728 decl_volatile || TYPE_VOLATILE (type),
7730 if (type_die != NULL)
7731 add_AT_die_ref (object_die, DW_AT_type, type_die);
7734 /* Given a tree pointer to a struct, class, union, or enum type node, return
7735 a pointer to the (string) tag name for the given type, or zero if the type
7736 was declared without a tag. */
7742 register char *name = 0;
7744 if (TYPE_NAME (type) != 0)
7746 register tree t = 0;
7748 /* Find the IDENTIFIER_NODE for the type name. */
7749 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
7750 t = TYPE_NAME (type);
7752 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
7753 a TYPE_DECL node, regardless of whether or not a `typedef' was
7755 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
7756 && ! DECL_IGNORED_P (TYPE_NAME (type)))
7757 t = DECL_NAME (TYPE_NAME (type));
7759 /* Now get the name as a string, or invent one. */
7761 name = IDENTIFIER_POINTER (t);
7764 return (name == 0 || *name == '\0') ? 0 : name;
7767 /* Return the type associated with a data member, make a special check
7768 for bit field types. */
7771 member_declared_type (member)
7772 register tree member;
7774 return (DECL_BIT_FIELD_TYPE (member)
7775 ? DECL_BIT_FIELD_TYPE (member)
7776 : TREE_TYPE (member));
7779 /* Get the decl's label, as described by its RTL. This may be different
7780 from the DECL_NAME name used in the source file. */
7784 decl_start_label (decl)
7789 x = DECL_RTL (decl);
7790 if (GET_CODE (x) != MEM)
7794 if (GET_CODE (x) != SYMBOL_REF)
7797 fnname = XSTR (x, 0);
7802 /* These routines generate the internal representation of the DIE's for
7803 the compilation unit. Debugging information is collected by walking
7804 the declaration trees passed in from dwarf2out_decl(). */
7807 gen_array_type_die (type, context_die)
7809 register dw_die_ref context_die;
7811 register dw_die_ref scope_die = scope_die_for (type, context_die);
7812 register dw_die_ref array_die;
7813 register tree element_type;
7815 /* ??? The SGI dwarf reader fails for array of array of enum types unless
7816 the inner array type comes before the outer array type. Thus we must
7817 call gen_type_die before we call new_die. See below also. */
7818 #ifdef MIPS_DEBUGGING_INFO
7819 gen_type_die (TREE_TYPE (type), context_die);
7822 array_die = new_die (DW_TAG_array_type, scope_die);
7825 /* We default the array ordering. SDB will probably do
7826 the right things even if DW_AT_ordering is not present. It's not even
7827 an issue until we start to get into multidimensional arrays anyway. If
7828 SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
7829 then we'll have to put the DW_AT_ordering attribute back in. (But if
7830 and when we find out that we need to put these in, we will only do so
7831 for multidimensional arrays. */
7832 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major);
7835 #ifdef MIPS_DEBUGGING_INFO
7836 /* The SGI compilers handle arrays of unknown bound by setting
7837 AT_declaration and not emitting any subrange DIEs. */
7838 if (! TYPE_DOMAIN (type))
7839 add_AT_unsigned (array_die, DW_AT_declaration, 1);
7842 add_subscript_info (array_die, type);
7844 add_name_attribute (array_die, type_tag (type));
7845 equate_type_number_to_die (type, array_die);
7847 /* Add representation of the type of the elements of this array type. */
7848 element_type = TREE_TYPE (type);
7850 /* ??? The SGI dwarf reader fails for multidimensional arrays with a
7851 const enum type. E.g. const enum machine_mode insn_operand_mode[2][10].
7852 We work around this by disabling this feature. See also
7853 add_subscript_info. */
7854 #ifndef MIPS_DEBUGGING_INFO
7855 while (TREE_CODE (element_type) == ARRAY_TYPE)
7856 element_type = TREE_TYPE (element_type);
7858 gen_type_die (element_type, context_die);
7861 add_type_attribute (array_die, element_type, 0, 0, context_die);
7865 gen_set_type_die (type, context_die)
7867 register dw_die_ref context_die;
7869 register dw_die_ref type_die
7870 = new_die (DW_TAG_set_type, scope_die_for (type, context_die));
7872 equate_type_number_to_die (type, type_die);
7873 add_type_attribute (type_die, TREE_TYPE (type), 0, 0, context_die);
7878 gen_entry_point_die (decl, context_die)
7880 register dw_die_ref context_die;
7882 register tree origin = decl_ultimate_origin (decl);
7883 register dw_die_ref decl_die = new_die (DW_TAG_entry_point, context_die);
7885 add_abstract_origin_attribute (decl_die, origin);
7888 add_name_and_src_coords_attributes (decl_die, decl);
7889 add_type_attribute (decl_die, TREE_TYPE (TREE_TYPE (decl)),
7893 if (DECL_ABSTRACT (decl))
7894 equate_decl_number_to_die (decl, decl_die);
7896 add_AT_lbl_id (decl_die, DW_AT_low_pc, decl_start_label (decl));
7900 /* Remember a type in the incomplete_types_list. */
7903 add_incomplete_type (type)
7906 if (incomplete_types == incomplete_types_allocated)
7908 incomplete_types_allocated += INCOMPLETE_TYPES_INCREMENT;
7909 incomplete_types_list
7910 = (tree *) xrealloc (incomplete_types_list,
7911 sizeof (tree) * incomplete_types_allocated);
7914 incomplete_types_list[incomplete_types++] = type;
7917 /* Walk through the list of incomplete types again, trying once more to
7918 emit full debugging info for them. */
7921 retry_incomplete_types ()
7925 while (incomplete_types)
7928 type = incomplete_types_list[incomplete_types];
7929 gen_type_die (type, comp_unit_die);
7933 /* Generate a DIE to represent an inlined instance of an enumeration type. */
7936 gen_inlined_enumeration_type_die (type, context_die)
7938 register dw_die_ref context_die;
7940 register dw_die_ref type_die = new_die (DW_TAG_enumeration_type,
7942 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
7943 be incomplete and such types are not marked. */
7944 add_abstract_origin_attribute (type_die, type);
7947 /* Generate a DIE to represent an inlined instance of a structure type. */
7950 gen_inlined_structure_type_die (type, context_die)
7952 register dw_die_ref context_die;
7954 register dw_die_ref type_die = new_die (DW_TAG_structure_type, context_die);
7956 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
7957 be incomplete and such types are not marked. */
7958 add_abstract_origin_attribute (type_die, type);
7961 /* Generate a DIE to represent an inlined instance of a union type. */
7964 gen_inlined_union_type_die (type, context_die)
7966 register dw_die_ref context_die;
7968 register dw_die_ref type_die = new_die (DW_TAG_union_type, context_die);
7970 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
7971 be incomplete and such types are not marked. */
7972 add_abstract_origin_attribute (type_die, type);
7975 /* Generate a DIE to represent an enumeration type. Note that these DIEs
7976 include all of the information about the enumeration values also. Each
7977 enumerated type name/value is listed as a child of the enumerated type
7981 gen_enumeration_type_die (type, context_die)
7983 register dw_die_ref context_die;
7985 register dw_die_ref type_die = lookup_type_die (type);
7987 if (type_die == NULL)
7989 type_die = new_die (DW_TAG_enumeration_type,
7990 scope_die_for (type, context_die));
7991 equate_type_number_to_die (type, type_die);
7992 add_name_attribute (type_die, type_tag (type));
7994 else if (! TYPE_SIZE (type))
7997 remove_AT (type_die, DW_AT_declaration);
7999 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the
8000 given enum type is incomplete, do not generate the DW_AT_byte_size
8001 attribute or the DW_AT_element_list attribute. */
8002 if (TYPE_SIZE (type))
8006 TREE_ASM_WRITTEN (type) = 1;
8007 add_byte_size_attribute (type_die, type);
8008 if (TYPE_STUB_DECL (type) != NULL_TREE)
8009 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
8011 /* If the first reference to this type was as the return type of an
8012 inline function, then it may not have a parent. Fix this now. */
8013 if (type_die->die_parent == NULL)
8014 add_child_die (scope_die_for (type, context_die), type_die);
8016 for (link = TYPE_FIELDS (type);
8017 link != NULL; link = TREE_CHAIN (link))
8019 register dw_die_ref enum_die = new_die (DW_TAG_enumerator, type_die);
8021 add_name_attribute (enum_die,
8022 IDENTIFIER_POINTER (TREE_PURPOSE (link)));
8023 add_AT_unsigned (enum_die, DW_AT_const_value,
8024 (unsigned) TREE_INT_CST_LOW (TREE_VALUE (link)));
8028 add_AT_flag (type_die, DW_AT_declaration, 1);
8032 /* Generate a DIE to represent either a real live formal parameter decl or to
8033 represent just the type of some formal parameter position in some function
8036 Note that this routine is a bit unusual because its argument may be a
8037 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
8038 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
8039 node. If it's the former then this function is being called to output a
8040 DIE to represent a formal parameter object (or some inlining thereof). If
8041 it's the latter, then this function is only being called to output a
8042 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
8043 argument type of some subprogram type. */
8046 gen_formal_parameter_die (node, context_die)
8048 register dw_die_ref context_die;
8050 register dw_die_ref parm_die
8051 = new_die (DW_TAG_formal_parameter, context_die);
8052 register tree origin;
8054 switch (TREE_CODE_CLASS (TREE_CODE (node)))
8057 origin = decl_ultimate_origin (node);
8059 add_abstract_origin_attribute (parm_die, origin);
8062 add_name_and_src_coords_attributes (parm_die, node);
8063 add_type_attribute (parm_die, TREE_TYPE (node),
8064 TREE_READONLY (node),
8065 TREE_THIS_VOLATILE (node),
8067 if (DECL_ARTIFICIAL (node))
8068 add_AT_flag (parm_die, DW_AT_artificial, 1);
8071 equate_decl_number_to_die (node, parm_die);
8072 if (! DECL_ABSTRACT (node))
8073 add_location_or_const_value_attribute (parm_die, node);
8078 /* We were called with some kind of a ..._TYPE node. */
8079 add_type_attribute (parm_die, node, 0, 0, context_die);
8089 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
8090 at the end of an (ANSI prototyped) formal parameters list. */
8093 gen_unspecified_parameters_die (decl_or_type, context_die)
8094 register tree decl_or_type ATTRIBUTE_UNUSED;
8095 register dw_die_ref context_die;
8097 new_die (DW_TAG_unspecified_parameters, context_die);
8100 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
8101 DW_TAG_unspecified_parameters DIE) to represent the types of the formal
8102 parameters as specified in some function type specification (except for
8103 those which appear as part of a function *definition*).
8105 Note we must be careful here to output all of the parameter DIEs before*
8106 we output any DIEs needed to represent the types of the formal parameters.
8107 This keeps svr4 SDB happy because it (incorrectly) thinks that the first
8108 non-parameter DIE it sees ends the formal parameter list. */
8111 gen_formal_types_die (function_or_method_type, context_die)
8112 register tree function_or_method_type;
8113 register dw_die_ref context_die;
8116 register tree formal_type = NULL;
8117 register tree first_parm_type = TYPE_ARG_TYPES (function_or_method_type);
8120 /* In the case where we are generating a formal types list for a C++
8121 non-static member function type, skip over the first thing on the
8122 TYPE_ARG_TYPES list because it only represents the type of the hidden
8123 `this pointer'. The debugger should be able to figure out (without
8124 being explicitly told) that this non-static member function type takes a
8125 `this pointer' and should be able to figure what the type of that hidden
8126 parameter is from the DW_AT_member attribute of the parent
8127 DW_TAG_subroutine_type DIE. */
8128 if (TREE_CODE (function_or_method_type) == METHOD_TYPE)
8129 first_parm_type = TREE_CHAIN (first_parm_type);
8132 /* Make our first pass over the list of formal parameter types and output a
8133 DW_TAG_formal_parameter DIE for each one. */
8134 for (link = first_parm_type; link; link = TREE_CHAIN (link))
8136 register dw_die_ref parm_die;
8138 formal_type = TREE_VALUE (link);
8139 if (formal_type == void_type_node)
8142 /* Output a (nameless) DIE to represent the formal parameter itself. */
8143 parm_die = gen_formal_parameter_die (formal_type, context_die);
8144 if (TREE_CODE (function_or_method_type) == METHOD_TYPE
8145 && link == first_parm_type)
8146 add_AT_flag (parm_die, DW_AT_artificial, 1);
8149 /* If this function type has an ellipsis, add a
8150 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */
8151 if (formal_type != void_type_node)
8152 gen_unspecified_parameters_die (function_or_method_type, context_die);
8154 /* Make our second (and final) pass over the list of formal parameter types
8155 and output DIEs to represent those types (as necessary). */
8156 for (link = TYPE_ARG_TYPES (function_or_method_type);
8158 link = TREE_CHAIN (link))
8160 formal_type = TREE_VALUE (link);
8161 if (formal_type == void_type_node)
8164 gen_type_die (formal_type, context_die);
8168 /* We want to generate the DIE for TYPE so that we can generate the
8169 die for MEMBER, which has been defined; we will need to refer back
8170 to the member declaration nested within TYPE. If we're trying to
8171 generate minimal debug info for TYPE, processing TYPE won't do the
8172 trick; we need to attach the member declaration by hand. */
8175 gen_type_die_for_member (type, member, context_die)
8177 dw_die_ref context_die;
8179 gen_type_die (type, context_die);
8181 /* If we're trying to avoid duplicate debug info, we may not have
8182 emitted the member decl for this function. Emit it now. */
8183 if (TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))
8184 && ! lookup_decl_die (member))
8186 if (decl_ultimate_origin (member))
8189 push_decl_scope (type);
8190 if (TREE_CODE (member) == FUNCTION_DECL)
8191 gen_subprogram_die (member, lookup_type_die (type));
8193 gen_variable_die (member, lookup_type_die (type));
8198 /* Generate the DWARF2 info for the "abstract" instance
8199 of a function which we may later generate inlined and/or
8200 out-of-line instances of. */
8203 gen_abstract_function (decl)
8206 register dw_die_ref old_die = lookup_decl_die (decl);
8209 if (old_die && get_AT_unsigned (old_die, DW_AT_inline))
8210 /* We've already generated the abstract instance. */
8213 save_fn = current_function_decl;
8214 current_function_decl = decl;
8216 set_decl_abstract_flags (decl, 1);
8217 dwarf2out_decl (decl);
8218 set_decl_abstract_flags (decl, 0);
8220 current_function_decl = save_fn;
8223 /* Generate a DIE to represent a declared function (either file-scope or
8227 gen_subprogram_die (decl, context_die)
8229 register dw_die_ref context_die;
8231 char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
8232 register tree origin = decl_ultimate_origin (decl);
8233 register dw_die_ref subr_die;
8234 register rtx fp_reg;
8235 register tree fn_arg_types;
8236 register tree outer_scope;
8237 register dw_die_ref old_die = lookup_decl_die (decl);
8238 register int declaration = (current_function_decl != decl
8239 || class_scope_p (context_die));
8241 /* Note that it is possible to have both DECL_ABSTRACT and `declaration'
8242 be true, if we started to generate the abstract instance of an inline,
8243 decided to output its containing class, and proceeded to emit the
8244 declaration of the inline from the member list for the class. In that
8245 case, `declaration' takes priority; we'll get back to the abstract
8246 instance when we're done with the class. */
8250 if (declaration && ! local_scope_p (context_die))
8253 subr_die = new_die (DW_TAG_subprogram, context_die);
8254 add_abstract_origin_attribute (subr_die, origin);
8256 else if (old_die && DECL_ABSTRACT (decl)
8257 && get_AT_unsigned (old_die, DW_AT_inline))
8259 /* This must be a redefinition of an extern inline function.
8260 We can just reuse the old die here. */
8263 /* Clear out the inlined attribute and parm types. */
8264 remove_AT (subr_die, DW_AT_inline);
8265 remove_children (subr_die);
8269 register unsigned file_index
8270 = lookup_filename (DECL_SOURCE_FILE (decl));
8272 if (get_AT_flag (old_die, DW_AT_declaration) != 1)
8274 /* ??? This can happen if there is a bug in the program, for
8275 instance, if it has duplicate function definitions. Ideally,
8276 we should detect this case and ignore it. For now, if we have
8277 already reported an error, any error at all, then assume that
8278 we got here because of a input error, not a dwarf2 bug. */
8284 /* If the definition comes from the same place as the declaration,
8285 maybe use the old DIE. We always want the DIE for this function
8286 that has the *_pc attributes to be under comp_unit_die so the
8287 debugger can find it. For inlines, that is the concrete instance,
8288 so we can use the old DIE here. For non-inline methods, we want a
8289 specification DIE at toplevel, so we need a new DIE. For local
8290 class methods, this doesn't apply; we just use the old DIE. */
8291 if ((DECL_ABSTRACT (decl) || old_die->die_parent == comp_unit_die
8292 || context_die == NULL)
8293 && (DECL_ARTIFICIAL (decl)
8294 || (get_AT_unsigned (old_die, DW_AT_decl_file) == file_index
8295 && (get_AT_unsigned (old_die, DW_AT_decl_line)
8296 == (unsigned)DECL_SOURCE_LINE (decl)))))
8300 /* Clear out the declaration attribute and the parm types. */
8301 remove_AT (subr_die, DW_AT_declaration);
8302 remove_children (subr_die);
8306 subr_die = new_die (DW_TAG_subprogram, context_die);
8307 add_AT_die_ref (subr_die, DW_AT_specification, old_die);
8308 if (get_AT_unsigned (old_die, DW_AT_decl_file) != file_index)
8309 add_AT_unsigned (subr_die, DW_AT_decl_file, file_index);
8310 if (get_AT_unsigned (old_die, DW_AT_decl_line)
8311 != (unsigned)DECL_SOURCE_LINE (decl))
8313 (subr_die, DW_AT_decl_line, DECL_SOURCE_LINE (decl));
8318 subr_die = new_die (DW_TAG_subprogram, context_die);
8320 if (TREE_PUBLIC (decl))
8321 add_AT_flag (subr_die, DW_AT_external, 1);
8323 add_name_and_src_coords_attributes (subr_die, decl);
8324 if (debug_info_level > DINFO_LEVEL_TERSE)
8326 register tree type = TREE_TYPE (decl);
8328 add_prototyped_attribute (subr_die, type);
8329 add_type_attribute (subr_die, TREE_TYPE (type), 0, 0, context_die);
8332 add_pure_or_virtual_attribute (subr_die, decl);
8333 if (DECL_ARTIFICIAL (decl))
8334 add_AT_flag (subr_die, DW_AT_artificial, 1);
8335 if (TREE_PROTECTED (decl))
8336 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_protected);
8337 else if (TREE_PRIVATE (decl))
8338 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_private);
8344 add_AT_flag (subr_die, DW_AT_declaration, 1);
8346 /* The first time we see a member function, it is in the context of
8347 the class to which it belongs. We make sure of this by emitting
8348 the class first. The next time is the definition, which is
8349 handled above. The two may come from the same source text. */
8350 if (DECL_CONTEXT (decl) || DECL_ABSTRACT (decl))
8351 equate_decl_number_to_die (decl, subr_die);
8353 else if (DECL_ABSTRACT (decl))
8355 if (DECL_INLINE (decl) && !flag_no_inline)
8357 /* ??? Checking DECL_DEFER_OUTPUT is correct for static
8358 inline functions, but not for extern inline functions.
8359 We can't get this completely correct because information
8360 about whether the function was declared inline is not
8362 if (DECL_DEFER_OUTPUT (decl))
8363 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_inlined);
8365 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_inlined);
8368 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_not_inlined);
8370 equate_decl_number_to_die (decl, subr_die);
8372 else if (!DECL_EXTERNAL (decl))
8374 if (origin == NULL_TREE)
8375 equate_decl_number_to_die (decl, subr_die);
8377 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_BEGIN_LABEL,
8378 current_funcdef_number);
8379 add_AT_lbl_id (subr_die, DW_AT_low_pc, label_id);
8380 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
8381 current_funcdef_number);
8382 add_AT_lbl_id (subr_die, DW_AT_high_pc, label_id);
8384 add_pubname (decl, subr_die);
8385 add_arange (decl, subr_die);
8387 #ifdef MIPS_DEBUGGING_INFO
8388 /* Add a reference to the FDE for this routine. */
8389 add_AT_fde_ref (subr_die, DW_AT_MIPS_fde, current_funcdef_fde);
8392 /* Define the "frame base" location for this routine. We use the
8393 frame pointer or stack pointer registers, since the RTL for local
8394 variables is relative to one of them. */
8396 = frame_pointer_needed ? hard_frame_pointer_rtx : stack_pointer_rtx;
8397 add_AT_loc (subr_die, DW_AT_frame_base, reg_loc_descriptor (fp_reg));
8400 /* ??? This fails for nested inline functions, because context_display
8401 is not part of the state saved/restored for inline functions. */
8402 if (current_function_needs_context)
8403 add_AT_location_description (subr_die, DW_AT_static_link,
8404 lookup_static_chain (decl));
8408 /* Now output descriptions of the arguments for this function. This gets
8409 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
8410 for a FUNCTION_DECL doesn't indicate cases where there was a trailing
8411 `...' at the end of the formal parameter list. In order to find out if
8412 there was a trailing ellipsis or not, we must instead look at the type
8413 associated with the FUNCTION_DECL. This will be a node of type
8414 FUNCTION_TYPE. If the chain of type nodes hanging off of this
8415 FUNCTION_TYPE node ends with a void_type_node then there should *not* be
8416 an ellipsis at the end. */
8418 /* In the case where we are describing a mere function declaration, all we
8419 need to do here (and all we *can* do here) is to describe the *types* of
8420 its formal parameters. */
8421 if (debug_info_level <= DINFO_LEVEL_TERSE)
8423 else if (declaration)
8424 gen_formal_types_die (TREE_TYPE (decl), subr_die);
8427 /* Generate DIEs to represent all known formal parameters */
8428 register tree arg_decls = DECL_ARGUMENTS (decl);
8431 /* When generating DIEs, generate the unspecified_parameters DIE
8432 instead if we come across the arg "__builtin_va_alist" */
8433 for (parm = arg_decls; parm; parm = TREE_CHAIN (parm))
8434 if (TREE_CODE (parm) == PARM_DECL)
8436 if (DECL_NAME (parm)
8437 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (parm)),
8438 "__builtin_va_alist"))
8439 gen_unspecified_parameters_die (parm, subr_die);
8441 gen_decl_die (parm, subr_die);
8444 /* Decide whether we need a unspecified_parameters DIE at the end.
8445 There are 2 more cases to do this for: 1) the ansi ... declaration -
8446 this is detectable when the end of the arg list is not a
8447 void_type_node 2) an unprototyped function declaration (not a
8448 definition). This just means that we have no info about the
8449 parameters at all. */
8450 fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
8451 if (fn_arg_types != NULL)
8453 /* this is the prototyped case, check for ... */
8454 if (TREE_VALUE (tree_last (fn_arg_types)) != void_type_node)
8455 gen_unspecified_parameters_die (decl, subr_die);
8457 else if (DECL_INITIAL (decl) == NULL_TREE)
8458 gen_unspecified_parameters_die (decl, subr_die);
8461 /* Output Dwarf info for all of the stuff within the body of the function
8462 (if it has one - it may be just a declaration). */
8463 outer_scope = DECL_INITIAL (decl);
8465 /* Note that here, `outer_scope' is a pointer to the outermost BLOCK
8466 node created to represent a function. This outermost BLOCK actually
8467 represents the outermost binding contour for the function, i.e. the
8468 contour in which the function's formal parameters and labels get
8469 declared. Curiously, it appears that the front end doesn't actually
8470 put the PARM_DECL nodes for the current function onto the BLOCK_VARS
8471 list for this outer scope. (They are strung off of the DECL_ARGUMENTS
8472 list for the function instead.) The BLOCK_VARS list for the
8473 `outer_scope' does provide us with a list of the LABEL_DECL nodes for
8474 the function however, and we output DWARF info for those in
8475 decls_for_scope. Just within the `outer_scope' there will be a BLOCK
8476 node representing the function's outermost pair of curly braces, and
8477 any blocks used for the base and member initializers of a C++
8478 constructor function. */
8479 if (! declaration && TREE_CODE (outer_scope) != ERROR_MARK)
8481 current_function_has_inlines = 0;
8482 decls_for_scope (outer_scope, subr_die, 0);
8484 #if 0 && defined (MIPS_DEBUGGING_INFO)
8485 if (current_function_has_inlines)
8487 add_AT_flag (subr_die, DW_AT_MIPS_has_inlines, 1);
8488 if (! comp_unit_has_inlines)
8490 add_AT_flag (comp_unit_die, DW_AT_MIPS_has_inlines, 1);
8491 comp_unit_has_inlines = 1;
8498 /* Generate a DIE to represent a declared data object. */
8501 gen_variable_die (decl, context_die)
8503 register dw_die_ref context_die;
8505 register tree origin = decl_ultimate_origin (decl);
8506 register dw_die_ref var_die = new_die (DW_TAG_variable, context_die);
8508 dw_die_ref old_die = lookup_decl_die (decl);
8509 int declaration = (DECL_EXTERNAL (decl)
8510 || class_scope_p (context_die));
8513 add_abstract_origin_attribute (var_die, origin);
8514 /* Loop unrolling can create multiple blocks that refer to the same
8515 static variable, so we must test for the DW_AT_declaration flag. */
8516 /* ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
8517 copy decls and set the DECL_ABSTRACT flag on them instead of
8519 else if (old_die && TREE_STATIC (decl)
8520 && get_AT_flag (old_die, DW_AT_declaration) == 1)
8522 /* This is a definition of a C++ class level static. */
8523 add_AT_die_ref (var_die, DW_AT_specification, old_die);
8524 if (DECL_NAME (decl))
8526 register unsigned file_index
8527 = lookup_filename (DECL_SOURCE_FILE (decl));
8529 if (get_AT_unsigned (old_die, DW_AT_decl_file) != file_index)
8530 add_AT_unsigned (var_die, DW_AT_decl_file, file_index);
8532 if (get_AT_unsigned (old_die, DW_AT_decl_line)
8533 != (unsigned)DECL_SOURCE_LINE (decl))
8535 add_AT_unsigned (var_die, DW_AT_decl_line,
8536 DECL_SOURCE_LINE (decl));
8541 add_name_and_src_coords_attributes (var_die, decl);
8542 add_type_attribute (var_die, TREE_TYPE (decl),
8543 TREE_READONLY (decl),
8544 TREE_THIS_VOLATILE (decl), context_die);
8546 if (TREE_PUBLIC (decl))
8547 add_AT_flag (var_die, DW_AT_external, 1);
8549 if (DECL_ARTIFICIAL (decl))
8550 add_AT_flag (var_die, DW_AT_artificial, 1);
8552 if (TREE_PROTECTED (decl))
8553 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_protected);
8555 else if (TREE_PRIVATE (decl))
8556 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_private);
8560 add_AT_flag (var_die, DW_AT_declaration, 1);
8562 if (class_scope_p (context_die) || DECL_ABSTRACT (decl))
8563 equate_decl_number_to_die (decl, var_die);
8565 if (! declaration && ! DECL_ABSTRACT (decl))
8567 add_location_or_const_value_attribute (var_die, decl);
8568 add_pubname (decl, var_die);
8572 /* Generate a DIE to represent a label identifier. */
8575 gen_label_die (decl, context_die)
8577 register dw_die_ref context_die;
8579 register tree origin = decl_ultimate_origin (decl);
8580 register dw_die_ref lbl_die = new_die (DW_TAG_label, context_die);
8582 char label[MAX_ARTIFICIAL_LABEL_BYTES];
8583 char label2[MAX_ARTIFICIAL_LABEL_BYTES];
8586 add_abstract_origin_attribute (lbl_die, origin);
8588 add_name_and_src_coords_attributes (lbl_die, decl);
8590 if (DECL_ABSTRACT (decl))
8591 equate_decl_number_to_die (decl, lbl_die);
8594 insn = DECL_RTL (decl);
8596 /* Deleted labels are programmer specified labels which have been
8597 eliminated because of various optimisations. We still emit them
8598 here so that it is possible to put breakpoints on them. */
8599 if (GET_CODE (insn) == CODE_LABEL
8600 || ((GET_CODE (insn) == NOTE
8601 && NOTE_LINE_NUMBER (insn) == NOTE_INSN_DELETED_LABEL)))
8603 /* When optimization is enabled (via -O) some parts of the compiler
8604 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
8605 represent source-level labels which were explicitly declared by
8606 the user. This really shouldn't be happening though, so catch
8607 it if it ever does happen. */
8608 if (INSN_DELETED_P (insn))
8611 sprintf (label2, INSN_LABEL_FMT, current_funcdef_number);
8612 ASM_GENERATE_INTERNAL_LABEL (label, label2,
8613 (unsigned) INSN_UID (insn));
8614 add_AT_lbl_id (lbl_die, DW_AT_low_pc, label);
8619 /* Generate a DIE for a lexical block. */
8622 gen_lexical_block_die (stmt, context_die, depth)
8624 register dw_die_ref context_die;
8627 register dw_die_ref stmt_die = new_die (DW_TAG_lexical_block, context_die);
8628 char label[MAX_ARTIFICIAL_LABEL_BYTES];
8630 if (! BLOCK_ABSTRACT (stmt))
8632 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
8634 add_AT_lbl_id (stmt_die, DW_AT_low_pc, label);
8635 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL, next_block_number);
8636 add_AT_lbl_id (stmt_die, DW_AT_high_pc, label);
8639 decls_for_scope (stmt, stmt_die, depth);
8642 /* Generate a DIE for an inlined subprogram. */
8645 gen_inlined_subroutine_die (stmt, context_die, depth)
8647 register dw_die_ref context_die;
8650 if (! BLOCK_ABSTRACT (stmt))
8652 register dw_die_ref subr_die
8653 = new_die (DW_TAG_inlined_subroutine, context_die);
8654 register tree decl = block_ultimate_origin (stmt);
8655 char label[MAX_ARTIFICIAL_LABEL_BYTES];
8657 /* Emit info for the abstract instance first, if we haven't yet. */
8658 gen_abstract_function (decl);
8660 add_abstract_origin_attribute (subr_die, decl);
8661 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
8663 add_AT_lbl_id (subr_die, DW_AT_low_pc, label);
8664 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL, next_block_number);
8665 add_AT_lbl_id (subr_die, DW_AT_high_pc, label);
8666 decls_for_scope (stmt, subr_die, depth);
8667 current_function_has_inlines = 1;
8671 /* Generate a DIE for a field in a record, or structure. */
8674 gen_field_die (decl, context_die)
8676 register dw_die_ref context_die;
8678 register dw_die_ref decl_die = new_die (DW_TAG_member, context_die);
8680 add_name_and_src_coords_attributes (decl_die, decl);
8681 add_type_attribute (decl_die, member_declared_type (decl),
8682 TREE_READONLY (decl), TREE_THIS_VOLATILE (decl),
8685 /* If this is a bit field... */
8686 if (DECL_BIT_FIELD_TYPE (decl))
8688 add_byte_size_attribute (decl_die, decl);
8689 add_bit_size_attribute (decl_die, decl);
8690 add_bit_offset_attribute (decl_die, decl);
8693 if (TREE_CODE (DECL_FIELD_CONTEXT (decl)) != UNION_TYPE)
8694 add_data_member_location_attribute (decl_die, decl);
8696 if (DECL_ARTIFICIAL (decl))
8697 add_AT_flag (decl_die, DW_AT_artificial, 1);
8699 if (TREE_PROTECTED (decl))
8700 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_protected);
8702 else if (TREE_PRIVATE (decl))
8703 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_private);
8707 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
8708 Use modified_type_die instead.
8709 We keep this code here just in case these types of DIEs may be needed to
8710 represent certain things in other languages (e.g. Pascal) someday. */
8712 gen_pointer_type_die (type, context_die)
8714 register dw_die_ref context_die;
8716 register dw_die_ref ptr_die
8717 = new_die (DW_TAG_pointer_type, scope_die_for (type, context_die));
8719 equate_type_number_to_die (type, ptr_die);
8720 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
8721 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
8724 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
8725 Use modified_type_die instead.
8726 We keep this code here just in case these types of DIEs may be needed to
8727 represent certain things in other languages (e.g. Pascal) someday. */
8729 gen_reference_type_die (type, context_die)
8731 register dw_die_ref context_die;
8733 register dw_die_ref ref_die
8734 = new_die (DW_TAG_reference_type, scope_die_for (type, context_die));
8736 equate_type_number_to_die (type, ref_die);
8737 add_type_attribute (ref_die, TREE_TYPE (type), 0, 0, context_die);
8738 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
8742 /* Generate a DIE for a pointer to a member type. */
8744 gen_ptr_to_mbr_type_die (type, context_die)
8746 register dw_die_ref context_die;
8748 register dw_die_ref ptr_die
8749 = new_die (DW_TAG_ptr_to_member_type, scope_die_for (type, context_die));
8751 equate_type_number_to_die (type, ptr_die);
8752 add_AT_die_ref (ptr_die, DW_AT_containing_type,
8753 lookup_type_die (TYPE_OFFSET_BASETYPE (type)));
8754 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
8757 /* Generate the DIE for the compilation unit. */
8760 gen_compile_unit_die (filename)
8761 register const char *filename;
8763 register dw_die_ref die;
8765 char *wd = getpwd ();
8768 die = new_die (DW_TAG_compile_unit, NULL);
8769 add_name_attribute (die, filename);
8771 if (wd != NULL && filename[0] != DIR_SEPARATOR)
8772 add_AT_string (die, DW_AT_comp_dir, wd);
8774 sprintf (producer, "%s %s", language_string, version_string);
8776 #ifdef MIPS_DEBUGGING_INFO
8777 /* The MIPS/SGI compilers place the 'cc' command line options in the producer
8778 string. The SGI debugger looks for -g, -g1, -g2, or -g3; if they do
8779 not appear in the producer string, the debugger reaches the conclusion
8780 that the object file is stripped and has no debugging information.
8781 To get the MIPS/SGI debugger to believe that there is debugging
8782 information in the object file, we add a -g to the producer string. */
8783 if (debug_info_level > DINFO_LEVEL_TERSE)
8784 strcat (producer, " -g");
8787 add_AT_string (die, DW_AT_producer, producer);
8789 if (strcmp (language_string, "GNU C++") == 0)
8790 language = DW_LANG_C_plus_plus;
8791 else if (strcmp (language_string, "GNU Ada") == 0)
8792 language = DW_LANG_Ada83;
8793 else if (strcmp (language_string, "GNU F77") == 0)
8794 language = DW_LANG_Fortran77;
8795 else if (strcmp (language_string, "GNU Pascal") == 0)
8796 language = DW_LANG_Pascal83;
8797 else if (flag_traditional)
8798 language = DW_LANG_C;
8800 language = DW_LANG_C89;
8802 add_AT_unsigned (die, DW_AT_language, language);
8807 /* Generate a DIE for a string type. */
8810 gen_string_type_die (type, context_die)
8812 register dw_die_ref context_die;
8814 register dw_die_ref type_die
8815 = new_die (DW_TAG_string_type, scope_die_for (type, context_die));
8817 equate_type_number_to_die (type, type_die);
8819 /* Fudge the string length attribute for now. */
8821 /* TODO: add string length info.
8822 string_length_attribute (TYPE_MAX_VALUE (TYPE_DOMAIN (type)));
8823 bound_representation (upper_bound, 0, 'u'); */
8826 /* Generate the DIE for a base class. */
8829 gen_inheritance_die (binfo, context_die)
8830 register tree binfo;
8831 register dw_die_ref context_die;
8833 dw_die_ref die = new_die (DW_TAG_inheritance, context_die);
8835 add_type_attribute (die, BINFO_TYPE (binfo), 0, 0, context_die);
8836 add_data_member_location_attribute (die, binfo);
8838 if (TREE_VIA_VIRTUAL (binfo))
8839 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
8840 if (TREE_VIA_PUBLIC (binfo))
8841 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public);
8842 else if (TREE_VIA_PROTECTED (binfo))
8843 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected);
8846 /* Generate a DIE for a class member. */
8849 gen_member_die (type, context_die)
8851 register dw_die_ref context_die;
8853 register tree member;
8856 /* If this is not an incomplete type, output descriptions of each of its
8857 members. Note that as we output the DIEs necessary to represent the
8858 members of this record or union type, we will also be trying to output
8859 DIEs to represent the *types* of those members. However the `type'
8860 function (above) will specifically avoid generating type DIEs for member
8861 types *within* the list of member DIEs for this (containing) type execpt
8862 for those types (of members) which are explicitly marked as also being
8863 members of this (containing) type themselves. The g++ front- end can
8864 force any given type to be treated as a member of some other
8865 (containing) type by setting the TYPE_CONTEXT of the given (member) type
8866 to point to the TREE node representing the appropriate (containing)
8869 /* First output info about the base classes. */
8870 if (TYPE_BINFO (type) && TYPE_BINFO_BASETYPES (type))
8872 register tree bases = TYPE_BINFO_BASETYPES (type);
8873 register int n_bases = TREE_VEC_LENGTH (bases);
8876 for (i = 0; i < n_bases; i++)
8877 gen_inheritance_die (TREE_VEC_ELT (bases, i), context_die);
8880 /* Now output info about the data members and type members. */
8881 for (member = TYPE_FIELDS (type); member; member = TREE_CHAIN (member))
8883 /* If we thought we were generating minimal debug info for TYPE
8884 and then changed our minds, some of the member declarations
8885 may have already been defined. Don't define them again, but
8886 do put them in the right order. */
8888 child = lookup_decl_die (member);
8890 splice_child_die (context_die, child);
8892 gen_decl_die (member, context_die);
8895 /* Now output info about the function members (if any). */
8896 for (member = TYPE_METHODS (type); member; member = TREE_CHAIN (member))
8898 child = lookup_decl_die (member);
8900 splice_child_die (context_die, child);
8902 gen_decl_die (member, context_die);
8906 /* Generate a DIE for a structure or union type. If TYPE_DECL_SUPPRESS_DEBUG
8907 is set, we pretend that the type was never defined, so we only get the
8908 member DIEs needed by later specification DIEs. */
8911 gen_struct_or_union_type_die (type, context_die)
8913 register dw_die_ref context_die;
8915 register dw_die_ref type_die = lookup_type_die (type);
8916 register dw_die_ref scope_die = 0;
8917 register int nested = 0;
8918 int complete = (TYPE_SIZE (type)
8919 && ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type)));
8921 if (type_die && ! complete)
8924 if (TYPE_CONTEXT (type) != NULL_TREE
8925 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type)))
8928 scope_die = scope_die_for (type, context_die);
8930 if (! type_die || (nested && scope_die == comp_unit_die))
8931 /* First occurrence of type or toplevel definition of nested class. */
8933 register dw_die_ref old_die = type_die;
8935 type_die = new_die (TREE_CODE (type) == RECORD_TYPE
8936 ? DW_TAG_structure_type : DW_TAG_union_type,
8938 equate_type_number_to_die (type, type_die);
8939 add_name_attribute (type_die, type_tag (type));
8941 add_AT_die_ref (type_die, DW_AT_specification, old_die);
8944 remove_AT (type_die, DW_AT_declaration);
8946 /* If this type has been completed, then give it a byte_size attribute and
8947 then give a list of members. */
8950 /* Prevent infinite recursion in cases where the type of some member of
8951 this type is expressed in terms of this type itself. */
8952 TREE_ASM_WRITTEN (type) = 1;
8953 add_byte_size_attribute (type_die, type);
8954 if (TYPE_STUB_DECL (type) != NULL_TREE)
8955 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
8957 /* If the first reference to this type was as the return type of an
8958 inline function, then it may not have a parent. Fix this now. */
8959 if (type_die->die_parent == NULL)
8960 add_child_die (scope_die, type_die);
8962 push_decl_scope (type);
8963 gen_member_die (type, type_die);
8966 /* GNU extension: Record what type our vtable lives in. */
8967 if (TYPE_VFIELD (type))
8969 tree vtype = DECL_FCONTEXT (TYPE_VFIELD (type));
8971 gen_type_die (vtype, context_die);
8972 add_AT_die_ref (type_die, DW_AT_containing_type,
8973 lookup_type_die (vtype));
8978 add_AT_flag (type_die, DW_AT_declaration, 1);
8980 /* We don't need to do this for function-local types. */
8982 add_incomplete_type (type);
8986 /* Generate a DIE for a subroutine _type_. */
8989 gen_subroutine_type_die (type, context_die)
8991 register dw_die_ref context_die;
8993 register tree return_type = TREE_TYPE (type);
8994 register dw_die_ref subr_die
8995 = new_die (DW_TAG_subroutine_type, scope_die_for (type, context_die));
8997 equate_type_number_to_die (type, subr_die);
8998 add_prototyped_attribute (subr_die, type);
8999 add_type_attribute (subr_die, return_type, 0, 0, context_die);
9000 gen_formal_types_die (type, subr_die);
9003 /* Generate a DIE for a type definition */
9006 gen_typedef_die (decl, context_die)
9008 register dw_die_ref context_die;
9010 register dw_die_ref type_die;
9011 register tree origin;
9013 if (TREE_ASM_WRITTEN (decl))
9015 TREE_ASM_WRITTEN (decl) = 1;
9017 type_die = new_die (DW_TAG_typedef, context_die);
9018 origin = decl_ultimate_origin (decl);
9020 add_abstract_origin_attribute (type_die, origin);
9024 add_name_and_src_coords_attributes (type_die, decl);
9025 if (DECL_ORIGINAL_TYPE (decl))
9027 type = DECL_ORIGINAL_TYPE (decl);
9028 equate_type_number_to_die (TREE_TYPE (decl), type_die);
9031 type = TREE_TYPE (decl);
9032 add_type_attribute (type_die, type, TREE_READONLY (decl),
9033 TREE_THIS_VOLATILE (decl), context_die);
9036 if (DECL_ABSTRACT (decl))
9037 equate_decl_number_to_die (decl, type_die);
9040 /* Generate a type description DIE. */
9043 gen_type_die (type, context_die)
9045 register dw_die_ref context_die;
9049 if (type == NULL_TREE || type == error_mark_node)
9052 /* We are going to output a DIE to represent the unqualified version of
9053 this type (i.e. without any const or volatile qualifiers) so get the
9054 main variant (i.e. the unqualified version) of this type now. */
9055 type = type_main_variant (type);
9057 if (TREE_ASM_WRITTEN (type))
9060 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
9061 && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
9063 TREE_ASM_WRITTEN (type) = 1;
9064 gen_decl_die (TYPE_NAME (type), context_die);
9068 switch (TREE_CODE (type))
9074 case REFERENCE_TYPE:
9075 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This
9076 ensures that the gen_type_die recursion will terminate even if the
9077 type is recursive. Recursive types are possible in Ada. */
9078 /* ??? We could perhaps do this for all types before the switch
9080 TREE_ASM_WRITTEN (type) = 1;
9082 /* For these types, all that is required is that we output a DIE (or a
9083 set of DIEs) to represent the "basis" type. */
9084 gen_type_die (TREE_TYPE (type), context_die);
9088 /* This code is used for C++ pointer-to-data-member types.
9089 Output a description of the relevant class type. */
9090 gen_type_die (TYPE_OFFSET_BASETYPE (type), context_die);
9092 /* Output a description of the type of the object pointed to. */
9093 gen_type_die (TREE_TYPE (type), context_die);
9095 /* Now output a DIE to represent this pointer-to-data-member type
9097 gen_ptr_to_mbr_type_die (type, context_die);
9101 gen_type_die (TYPE_DOMAIN (type), context_die);
9102 gen_set_type_die (type, context_die);
9106 gen_type_die (TREE_TYPE (type), context_die);
9107 abort (); /* No way to represent these in Dwarf yet! */
9111 /* Force out return type (in case it wasn't forced out already). */
9112 gen_type_die (TREE_TYPE (type), context_die);
9113 gen_subroutine_type_die (type, context_die);
9117 /* Force out return type (in case it wasn't forced out already). */
9118 gen_type_die (TREE_TYPE (type), context_die);
9119 gen_subroutine_type_die (type, context_die);
9123 if (TYPE_STRING_FLAG (type) && TREE_CODE (TREE_TYPE (type)) == CHAR_TYPE)
9125 gen_type_die (TREE_TYPE (type), context_die);
9126 gen_string_type_die (type, context_die);
9129 gen_array_type_die (type, context_die);
9135 case QUAL_UNION_TYPE:
9136 /* If this is a nested type whose containing class hasn't been
9137 written out yet, writing it out will cover this one, too.
9138 This does not apply to instantiations of member class templates;
9139 they need to be added to the containing class as they are
9140 generated. FIXME: This hurts the idea of combining type decls
9141 from multiple TUs, since we can't predict what set of template
9142 instantiations we'll get. */
9143 if (TYPE_CONTEXT (type)
9144 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
9145 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
9147 gen_type_die (TYPE_CONTEXT (type), context_die);
9149 if (TREE_ASM_WRITTEN (type))
9152 /* If that failed, attach ourselves to the stub. */
9153 push_decl_scope (TYPE_CONTEXT (type));
9154 context_die = lookup_type_die (TYPE_CONTEXT (type));
9160 if (TREE_CODE (type) == ENUMERAL_TYPE)
9161 gen_enumeration_type_die (type, context_die);
9163 gen_struct_or_union_type_die (type, context_die);
9168 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
9169 it up if it is ever completed. gen_*_type_die will set it for us
9170 when appropriate. */
9179 /* No DIEs needed for fundamental types. */
9183 /* No Dwarf representation currently defined. */
9190 TREE_ASM_WRITTEN (type) = 1;
9193 /* Generate a DIE for a tagged type instantiation. */
9196 gen_tagged_type_instantiation_die (type, context_die)
9198 register dw_die_ref context_die;
9200 if (type == NULL_TREE || type == error_mark_node)
9203 /* We are going to output a DIE to represent the unqualified version of
9204 this type (i.e. without any const or volatile qualifiers) so make sure
9205 that we have the main variant (i.e. the unqualified version) of this
9207 if (type != type_main_variant (type))
9210 /* Do not check TREE_ASM_WRITTEN (type) as it may not be set if this is
9211 an instance of an unresolved type. */
9213 switch (TREE_CODE (type))
9219 gen_inlined_enumeration_type_die (type, context_die);
9223 gen_inlined_structure_type_die (type, context_die);
9227 case QUAL_UNION_TYPE:
9228 gen_inlined_union_type_die (type, context_die);
9236 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
9237 things which are local to the given block. */
9240 gen_block_die (stmt, context_die, depth)
9242 register dw_die_ref context_die;
9245 register int must_output_die = 0;
9246 register tree origin;
9248 register enum tree_code origin_code;
9250 /* Ignore blocks never really used to make RTL. */
9252 if (stmt == NULL_TREE || !TREE_USED (stmt))
9255 /* Determine the "ultimate origin" of this block. This block may be an
9256 inlined instance of an inlined instance of inline function, so we have
9257 to trace all of the way back through the origin chain to find out what
9258 sort of node actually served as the original seed for the creation of
9259 the current block. */
9260 origin = block_ultimate_origin (stmt);
9261 origin_code = (origin != NULL) ? TREE_CODE (origin) : ERROR_MARK;
9263 /* Determine if we need to output any Dwarf DIEs at all to represent this
9265 if (origin_code == FUNCTION_DECL)
9266 /* The outer scopes for inlinings *must* always be represented. We
9267 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */
9268 must_output_die = 1;
9271 /* In the case where the current block represents an inlining of the
9272 "body block" of an inline function, we must *NOT* output any DIE for
9273 this block because we have already output a DIE to represent the
9274 whole inlined function scope and the "body block" of any function
9275 doesn't really represent a different scope according to ANSI C
9276 rules. So we check here to make sure that this block does not
9277 represent a "body block inlining" before trying to set the
9278 `must_output_die' flag. */
9279 if (! is_body_block (origin ? origin : stmt))
9281 /* Determine if this block directly contains any "significant"
9282 local declarations which we will need to output DIEs for. */
9283 if (debug_info_level > DINFO_LEVEL_TERSE)
9284 /* We are not in terse mode so *any* local declaration counts
9285 as being a "significant" one. */
9286 must_output_die = (BLOCK_VARS (stmt) != NULL);
9288 /* We are in terse mode, so only local (nested) function
9289 definitions count as "significant" local declarations. */
9290 for (decl = BLOCK_VARS (stmt);
9291 decl != NULL; decl = TREE_CHAIN (decl))
9292 if (TREE_CODE (decl) == FUNCTION_DECL
9293 && DECL_INITIAL (decl))
9295 must_output_die = 1;
9301 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
9302 DIE for any block which contains no significant local declarations at
9303 all. Rather, in such cases we just call `decls_for_scope' so that any
9304 needed Dwarf info for any sub-blocks will get properly generated. Note
9305 that in terse mode, our definition of what constitutes a "significant"
9306 local declaration gets restricted to include only inlined function
9307 instances and local (nested) function definitions. */
9308 if (must_output_die)
9310 if (origin_code == FUNCTION_DECL)
9311 gen_inlined_subroutine_die (stmt, context_die, depth);
9313 gen_lexical_block_die (stmt, context_die, depth);
9316 decls_for_scope (stmt, context_die, depth);
9319 /* Generate all of the decls declared within a given scope and (recursively)
9320 all of its sub-blocks. */
9323 decls_for_scope (stmt, context_die, depth)
9325 register dw_die_ref context_die;
9329 register tree subblocks;
9331 /* Ignore blocks never really used to make RTL. */
9332 if (stmt == NULL_TREE || ! TREE_USED (stmt))
9335 if (!BLOCK_ABSTRACT (stmt) && depth > 0)
9336 next_block_number++;
9338 /* Output the DIEs to represent all of the data objects and typedefs
9339 declared directly within this block but not within any nested
9340 sub-blocks. Also, nested function and tag DIEs have been
9341 generated with a parent of NULL; fix that up now. */
9342 for (decl = BLOCK_VARS (stmt);
9343 decl != NULL; decl = TREE_CHAIN (decl))
9345 register dw_die_ref die;
9347 if (TREE_CODE (decl) == FUNCTION_DECL)
9348 die = lookup_decl_die (decl);
9349 else if (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl))
9350 die = lookup_type_die (TREE_TYPE (decl));
9354 if (die != NULL && die->die_parent == NULL)
9355 add_child_die (context_die, die);
9357 gen_decl_die (decl, context_die);
9360 /* Output the DIEs to represent all sub-blocks (and the items declared
9361 therein) of this block. */
9362 for (subblocks = BLOCK_SUBBLOCKS (stmt);
9364 subblocks = BLOCK_CHAIN (subblocks))
9365 gen_block_die (subblocks, context_die, depth + 1);
9368 /* Is this a typedef we can avoid emitting? */
9371 is_redundant_typedef (decl)
9374 if (TYPE_DECL_IS_STUB (decl))
9377 if (DECL_ARTIFICIAL (decl)
9378 && DECL_CONTEXT (decl)
9379 && is_tagged_type (DECL_CONTEXT (decl))
9380 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl))) == TYPE_DECL
9381 && DECL_NAME (decl) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))))
9382 /* Also ignore the artificial member typedef for the class name. */
9388 /* Generate Dwarf debug information for a decl described by DECL. */
9391 gen_decl_die (decl, context_die)
9393 register dw_die_ref context_die;
9395 register tree origin;
9397 if (TREE_CODE (decl) == ERROR_MARK)
9400 /* If this ..._DECL node is marked to be ignored, then ignore it. But don't
9401 ignore a function definition, since that would screw up our count of
9402 blocks, and that in turn will completely screw up the labels we will
9403 reference in subsequent DW_AT_low_pc and DW_AT_high_pc attributes (for
9404 subsequent blocks). */
9405 if (DECL_IGNORED_P (decl) && TREE_CODE (decl) != FUNCTION_DECL)
9408 switch (TREE_CODE (decl))
9411 /* The individual enumerators of an enum type get output when we output
9412 the Dwarf representation of the relevant enum type itself. */
9416 /* Don't output any DIEs to represent mere function declarations,
9417 unless they are class members or explicit block externs. */
9418 if (DECL_INITIAL (decl) == NULL_TREE && DECL_CONTEXT (decl) == NULL_TREE
9419 && (current_function_decl == NULL_TREE || DECL_ARTIFICIAL (decl)))
9422 /* Emit info for the abstract instance first, if we haven't yet. */
9423 origin = decl_ultimate_origin (decl);
9425 gen_abstract_function (origin);
9427 if (debug_info_level > DINFO_LEVEL_TERSE)
9429 /* Before we describe the FUNCTION_DECL itself, make sure that we
9430 have described its return type. */
9431 gen_type_die (TREE_TYPE (TREE_TYPE (decl)), context_die);
9433 /* And its virtual context. */
9434 if (DECL_VINDEX (decl) != NULL_TREE)
9435 gen_type_die (DECL_CONTEXT (decl), context_die);
9437 /* And its containing type. */
9438 origin = decl_class_context (decl);
9439 if (origin != NULL_TREE)
9440 gen_type_die_for_member (origin, decl, context_die);
9443 /* Now output a DIE to represent the function itself. */
9444 gen_subprogram_die (decl, context_die);
9448 /* If we are in terse mode, don't generate any DIEs to represent any
9450 if (debug_info_level <= DINFO_LEVEL_TERSE)
9453 /* In the special case of a TYPE_DECL node representing the
9454 declaration of some type tag, if the given TYPE_DECL is marked as
9455 having been instantiated from some other (original) TYPE_DECL node
9456 (e.g. one which was generated within the original definition of an
9457 inline function) we have to generate a special (abbreviated)
9458 DW_TAG_structure_type, DW_TAG_union_type, or DW_TAG_enumeration_type
9460 if (TYPE_DECL_IS_STUB (decl) && decl_ultimate_origin (decl) != NULL_TREE)
9462 gen_tagged_type_instantiation_die (TREE_TYPE (decl), context_die);
9466 if (is_redundant_typedef (decl))
9467 gen_type_die (TREE_TYPE (decl), context_die);
9469 /* Output a DIE to represent the typedef itself. */
9470 gen_typedef_die (decl, context_die);
9474 if (debug_info_level >= DINFO_LEVEL_NORMAL)
9475 gen_label_die (decl, context_die);
9479 /* If we are in terse mode, don't generate any DIEs to represent any
9480 variable declarations or definitions. */
9481 if (debug_info_level <= DINFO_LEVEL_TERSE)
9484 /* Output any DIEs that are needed to specify the type of this data
9486 gen_type_die (TREE_TYPE (decl), context_die);
9488 /* And its containing type. */
9489 origin = decl_class_context (decl);
9490 if (origin != NULL_TREE)
9491 gen_type_die_for_member (origin, decl, context_die);
9493 /* Now output the DIE to represent the data object itself. This gets
9494 complicated because of the possibility that the VAR_DECL really
9495 represents an inlined instance of a formal parameter for an inline
9497 origin = decl_ultimate_origin (decl);
9498 if (origin != NULL_TREE && TREE_CODE (origin) == PARM_DECL)
9499 gen_formal_parameter_die (decl, context_die);
9501 gen_variable_die (decl, context_die);
9505 /* Ignore the nameless fields that are used to skip bits, but
9506 handle C++ anonymous unions. */
9507 if (DECL_NAME (decl) != NULL_TREE
9508 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE)
9510 gen_type_die (member_declared_type (decl), context_die);
9511 gen_field_die (decl, context_die);
9516 gen_type_die (TREE_TYPE (decl), context_die);
9517 gen_formal_parameter_die (decl, context_die);
9520 case NAMESPACE_DECL:
9521 /* Ignore for now. */
9529 /* Add Ada "use" clause information for SGI Workshop debugger. */
9532 dwarf2out_add_library_unit_info (filename, context_list)
9536 unsigned int file_index;
9538 if (filename != NULL)
9540 dw_die_ref unit_die = new_die (DW_TAG_module, comp_unit_die);
9541 tree context_list_decl
9542 = build_decl (LABEL_DECL, get_identifier (context_list),
9545 TREE_PUBLIC (context_list_decl) = TRUE;
9546 add_name_attribute (unit_die, context_list);
9547 file_index = lookup_filename (filename);
9548 add_AT_unsigned (unit_die, DW_AT_decl_file, file_index);
9549 add_pubname (context_list_decl, unit_die);
9553 /* Write the debugging output for DECL. */
9556 dwarf2out_decl (decl)
9559 register dw_die_ref context_die = comp_unit_die;
9561 if (TREE_CODE (decl) == ERROR_MARK)
9564 /* If this ..._DECL node is marked to be ignored, then ignore it. We gotta
9565 hope that the node in question doesn't represent a function definition.
9566 If it does, then totally ignoring it is bound to screw up our count of
9567 blocks, and that in turn will completely screw up the labels we will
9568 reference in subsequent DW_AT_low_pc and DW_AT_high_pc attributes (for
9569 subsequent blocks). (It's too bad that BLOCK nodes don't carry their
9570 own sequence numbers with them!) */
9571 if (DECL_IGNORED_P (decl))
9573 if (TREE_CODE (decl) == FUNCTION_DECL
9574 && DECL_INITIAL (decl) != NULL)
9580 switch (TREE_CODE (decl))
9583 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration of a
9584 builtin function. Explicit programmer-supplied declarations of
9585 these same functions should NOT be ignored however. */
9586 if (DECL_EXTERNAL (decl) && DECL_BUILT_IN (decl))
9589 /* What we would really like to do here is to filter out all mere
9590 file-scope declarations of file-scope functions which are never
9591 referenced later within this translation unit (and keep all of ones
9592 that *are* referenced later on) but we aren't clairvoyant, so we have
9593 no idea which functions will be referenced in the future (i.e. later
9594 on within the current translation unit). So here we just ignore all
9595 file-scope function declarations which are not also definitions. If
9596 and when the debugger needs to know something about these functions,
9597 it will have to hunt around and find the DWARF information associated
9598 with the definition of the function. Note that we can't just check
9599 `DECL_EXTERNAL' to find out which FUNCTION_DECL nodes represent
9600 definitions and which ones represent mere declarations. We have to
9601 check `DECL_INITIAL' instead. That's because the C front-end
9602 supports some weird semantics for "extern inline" function
9603 definitions. These can get inlined within the current translation
9604 unit (an thus, we need to generate DWARF info for their abstract
9605 instances so that the DWARF info for the concrete inlined instances
9606 can have something to refer to) but the compiler never generates any
9607 out-of-lines instances of such things (despite the fact that they
9608 *are* definitions). The important point is that the C front-end
9609 marks these "extern inline" functions as DECL_EXTERNAL, but we need
9610 to generate DWARF for them anyway. Note that the C++ front-end also
9611 plays some similar games for inline function definitions appearing
9612 within include files which also contain
9613 `#pragma interface' pragmas. */
9614 if (DECL_INITIAL (decl) == NULL_TREE)
9617 /* If we're a nested function, initially use a parent of NULL; if we're
9618 a plain function, this will be fixed up in decls_for_scope. If
9619 we're a method, it will be ignored, since we already have a DIE. */
9620 if (decl_function_context (decl))
9626 /* Ignore this VAR_DECL if it refers to a file-scope extern data object
9627 declaration and if the declaration was never even referenced from
9628 within this entire compilation unit. We suppress these DIEs in
9629 order to save space in the .debug section (by eliminating entries
9630 which are probably useless). Note that we must not suppress
9631 block-local extern declarations (whether used or not) because that
9632 would screw-up the debugger's name lookup mechanism and cause it to
9633 miss things which really ought to be in scope at a given point. */
9634 if (DECL_EXTERNAL (decl) && !TREE_USED (decl))
9637 /* If we are in terse mode, don't generate any DIEs to represent any
9638 variable declarations or definitions. */
9639 if (debug_info_level <= DINFO_LEVEL_TERSE)
9644 /* Don't bother trying to generate any DIEs to represent any of the
9645 normal built-in types for the language we are compiling. */
9646 if (DECL_SOURCE_LINE (decl) == 0)
9648 /* OK, we need to generate one for `bool' so GDB knows what type
9649 comparisons have. */
9650 if ((get_AT_unsigned (comp_unit_die, DW_AT_language)
9651 == DW_LANG_C_plus_plus)
9652 && TREE_CODE (TREE_TYPE (decl)) == BOOLEAN_TYPE)
9653 modified_type_die (TREE_TYPE (decl), 0, 0, NULL);
9658 /* If we are in terse mode, don't generate any DIEs for types. */
9659 if (debug_info_level <= DINFO_LEVEL_TERSE)
9662 /* If we're a function-scope tag, initially use a parent of NULL;
9663 this will be fixed up in decls_for_scope. */
9664 if (decl_function_context (decl))
9673 gen_decl_die (decl, context_die);
9676 /* Output a marker (i.e. a label) for the beginning of the generated code for
9680 dwarf2out_begin_block (blocknum)
9681 register unsigned blocknum;
9683 function_section (current_function_decl);
9684 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, BLOCK_BEGIN_LABEL, blocknum);
9687 /* Output a marker (i.e. a label) for the end of the generated code for a
9691 dwarf2out_end_block (blocknum)
9692 register unsigned blocknum;
9694 function_section (current_function_decl);
9695 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, BLOCK_END_LABEL, blocknum);
9698 /* Output a marker (i.e. a label) at a point in the assembly code which
9699 corresponds to a given source level label. */
9702 dwarf2out_label (insn)
9705 char label[MAX_ARTIFICIAL_LABEL_BYTES];
9707 if (debug_info_level >= DINFO_LEVEL_NORMAL)
9709 function_section (current_function_decl);
9710 sprintf (label, INSN_LABEL_FMT, current_funcdef_number);
9711 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, label,
9712 (unsigned) INSN_UID (insn));
9716 /* Lookup a filename (in the list of filenames that we know about here in
9717 dwarf2out.c) and return its "index". The index of each (known) filename is
9718 just a unique number which is associated with only that one filename.
9719 We need such numbers for the sake of generating labels
9720 (in the .debug_sfnames section) and references to those
9721 files numbers (in the .debug_srcinfo and.debug_macinfo sections).
9722 If the filename given as an argument is not found in our current list,
9723 add it to the list and assign it the next available unique index number.
9724 In order to speed up searches, we remember the index of the filename
9725 was looked up last. This handles the majority of all searches. */
9728 lookup_filename (file_name)
9729 const char *file_name;
9731 static unsigned last_file_lookup_index = 0;
9732 register unsigned i;
9734 /* Check to see if the file name that was searched on the previous call
9735 matches this file name. If so, return the index. */
9736 if (last_file_lookup_index != 0)
9737 if (strcmp (file_name, file_table[last_file_lookup_index]) == 0)
9738 return last_file_lookup_index;
9740 /* Didn't match the previous lookup, search the table */
9741 for (i = 1; i < file_table_in_use; ++i)
9742 if (strcmp (file_name, file_table[i]) == 0)
9744 last_file_lookup_index = i;
9748 /* Prepare to add a new table entry by making sure there is enough space in
9749 the table to do so. If not, expand the current table. */
9750 if (file_table_in_use == file_table_allocated)
9752 file_table_allocated += FILE_TABLE_INCREMENT;
9754 = (char **) xrealloc (file_table,
9755 file_table_allocated * sizeof (char *));
9758 /* Add the new entry to the end of the filename table. */
9759 file_table[file_table_in_use] = xstrdup (file_name);
9760 last_file_lookup_index = file_table_in_use++;
9762 return last_file_lookup_index;
9765 /* Output a label to mark the beginning of a source code line entry
9766 and record information relating to this source line, in
9767 'line_info_table' for later output of the .debug_line section. */
9770 dwarf2out_line (filename, line)
9771 register const char *filename;
9772 register unsigned line;
9774 if (debug_info_level >= DINFO_LEVEL_NORMAL)
9776 function_section (current_function_decl);
9778 if (DWARF2_ASM_LINE_DEBUG_INFO)
9780 static const char *lastfile;
9782 /* Emit the .file and .loc directives understood by GNU as. */
9783 if (lastfile == 0 || strcmp (filename, lastfile))
9786 ggc_add_string_root ((char **) &lastfile, 1);
9788 fprintf (asm_out_file, "\t.file 0 \"%s\"\n", filename);
9789 lastfile = filename;
9792 fprintf (asm_out_file, "\t.loc 0 %d 0\n", line);
9794 /* Indicate that line number info exists. */
9795 ++line_info_table_in_use;
9797 /* Indicate that multiple line number tables exist. */
9798 if (DECL_SECTION_NAME (current_function_decl))
9799 ++separate_line_info_table_in_use;
9801 else if (DECL_SECTION_NAME (current_function_decl))
9803 register dw_separate_line_info_ref line_info;
9804 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, SEPARATE_LINE_CODE_LABEL,
9805 separate_line_info_table_in_use);
9807 fprintf (asm_out_file, "\t%s line %d", ASM_COMMENT_START, line);
9808 fputc ('\n', asm_out_file);
9810 /* expand the line info table if necessary */
9811 if (separate_line_info_table_in_use
9812 == separate_line_info_table_allocated)
9814 separate_line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
9815 separate_line_info_table
9816 = (dw_separate_line_info_ref)
9817 xrealloc (separate_line_info_table,
9818 separate_line_info_table_allocated
9819 * sizeof (dw_separate_line_info_entry));
9822 /* Add the new entry at the end of the line_info_table. */
9824 = &separate_line_info_table[separate_line_info_table_in_use++];
9825 line_info->dw_file_num = lookup_filename (filename);
9826 line_info->dw_line_num = line;
9827 line_info->function = current_funcdef_number;
9831 register dw_line_info_ref line_info;
9833 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, LINE_CODE_LABEL,
9834 line_info_table_in_use);
9836 fprintf (asm_out_file, "\t%s line %d", ASM_COMMENT_START, line);
9837 fputc ('\n', asm_out_file);
9839 /* Expand the line info table if necessary. */
9840 if (line_info_table_in_use == line_info_table_allocated)
9842 line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
9844 = (dw_line_info_ref)
9845 xrealloc (line_info_table,
9846 (line_info_table_allocated
9847 * sizeof (dw_line_info_entry)));
9850 /* Add the new entry at the end of the line_info_table. */
9851 line_info = &line_info_table[line_info_table_in_use++];
9852 line_info->dw_file_num = lookup_filename (filename);
9853 line_info->dw_line_num = line;
9858 /* Record the beginning of a new source file, for later output
9859 of the .debug_macinfo section. At present, unimplemented. */
9862 dwarf2out_start_source_file (filename)
9863 register const char *filename ATTRIBUTE_UNUSED;
9867 /* Record the end of a source file, for later output
9868 of the .debug_macinfo section. At present, unimplemented. */
9871 dwarf2out_end_source_file ()
9875 /* Called from check_newline in c-parse.y. The `buffer' parameter contains
9876 the tail part of the directive line, i.e. the part which is past the
9877 initial whitespace, #, whitespace, directive-name, whitespace part. */
9880 dwarf2out_define (lineno, buffer)
9881 register unsigned lineno ATTRIBUTE_UNUSED;
9882 register const char *buffer ATTRIBUTE_UNUSED;
9884 static int initialized = 0;
9887 dwarf2out_start_source_file (primary_filename);
9892 /* Called from check_newline in c-parse.y. The `buffer' parameter contains
9893 the tail part of the directive line, i.e. the part which is past the
9894 initial whitespace, #, whitespace, directive-name, whitespace part. */
9897 dwarf2out_undef (lineno, buffer)
9898 register unsigned lineno ATTRIBUTE_UNUSED;
9899 register const char *buffer ATTRIBUTE_UNUSED;
9903 /* Set up for Dwarf output at the start of compilation. */
9906 dwarf2out_init (asm_out_file, main_input_filename)
9907 register FILE *asm_out_file;
9908 register char *main_input_filename;
9910 /* Remember the name of the primary input file. */
9911 primary_filename = main_input_filename;
9913 /* Allocate the initial hunk of the file_table. */
9914 file_table = (char **) xcalloc (FILE_TABLE_INCREMENT, sizeof (char *));
9915 file_table_allocated = FILE_TABLE_INCREMENT;
9917 /* Skip the first entry - file numbers begin at 1. */
9918 file_table_in_use = 1;
9920 /* Allocate the initial hunk of the decl_die_table. */
9922 = (dw_die_ref *) xcalloc (DECL_DIE_TABLE_INCREMENT, sizeof (dw_die_ref));
9923 decl_die_table_allocated = DECL_DIE_TABLE_INCREMENT;
9924 decl_die_table_in_use = 0;
9926 /* Allocate the initial hunk of the decl_scope_table. */
9928 = (tree *) xcalloc (DECL_SCOPE_TABLE_INCREMENT, sizeof (tree));
9929 decl_scope_table_allocated = DECL_SCOPE_TABLE_INCREMENT;
9930 decl_scope_depth = 0;
9932 /* Allocate the initial hunk of the abbrev_die_table. */
9934 = (dw_die_ref *) xcalloc (ABBREV_DIE_TABLE_INCREMENT,
9935 sizeof (dw_die_ref));
9936 abbrev_die_table_allocated = ABBREV_DIE_TABLE_INCREMENT;
9937 /* Zero-th entry is allocated, but unused */
9938 abbrev_die_table_in_use = 1;
9940 /* Allocate the initial hunk of the line_info_table. */
9942 = (dw_line_info_ref) xcalloc (LINE_INFO_TABLE_INCREMENT,
9943 sizeof (dw_line_info_entry));
9944 line_info_table_allocated = LINE_INFO_TABLE_INCREMENT;
9945 /* Zero-th entry is allocated, but unused */
9946 line_info_table_in_use = 1;
9948 /* Generate the initial DIE for the .debug section. Note that the (string)
9949 value given in the DW_AT_name attribute of the DW_TAG_compile_unit DIE
9950 will (typically) be a relative pathname and that this pathname should be
9951 taken as being relative to the directory from which the compiler was
9952 invoked when the given (base) source file was compiled. */
9953 comp_unit_die = gen_compile_unit_die (main_input_filename);
9955 ASM_GENERATE_INTERNAL_LABEL (text_end_label, TEXT_END_LABEL, 0);
9956 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label, ABBREV_SECTION_LABEL, 0);
9957 if (DWARF2_GENERATE_TEXT_SECTION_LABEL)
9958 ASM_GENERATE_INTERNAL_LABEL (text_section_label, TEXT_SECTION_LABEL, 0);
9960 strcpy (text_section_label, stripattributes (TEXT_SECTION));
9961 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label,
9962 DEBUG_INFO_SECTION_LABEL, 0);
9963 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label,
9964 DEBUG_LINE_SECTION_LABEL, 0);
9966 ASM_OUTPUT_SECTION (asm_out_file, ABBREV_SECTION);
9967 ASM_OUTPUT_LABEL (asm_out_file, abbrev_section_label);
9968 if (DWARF2_GENERATE_TEXT_SECTION_LABEL)
9970 ASM_OUTPUT_SECTION (asm_out_file, TEXT_SECTION);
9971 ASM_OUTPUT_LABEL (asm_out_file, text_section_label);
9973 ASM_OUTPUT_SECTION (asm_out_file, DEBUG_INFO_SECTION);
9974 ASM_OUTPUT_LABEL (asm_out_file, debug_info_section_label);
9975 ASM_OUTPUT_SECTION (asm_out_file, DEBUG_LINE_SECTION);
9976 ASM_OUTPUT_LABEL (asm_out_file, debug_line_section_label);
9979 /* Output stuff that dwarf requires at the end of every file,
9980 and generate the DWARF-2 debugging info. */
9985 limbo_die_node *node, *next_node;
9988 /* Traverse the limbo die list, and add parent/child links. The only
9989 dies without parents that should be here are concrete instances of
9990 inline functions, and the comp_unit_die. We can ignore the comp_unit_die.
9991 For concrete instances, we can get the parent die from the abstract
9993 for (node = limbo_die_list; node; node = next_node)
9995 next_node = node->next;
9998 if (die->die_parent == NULL)
10000 dw_die_ref origin = get_AT_ref (die, DW_AT_abstract_origin);
10002 add_child_die (origin->die_parent, die);
10003 else if (die == comp_unit_die)
10010 limbo_die_list = NULL;
10012 /* Walk through the list of incomplete types again, trying once more to
10013 emit full debugging info for them. */
10014 retry_incomplete_types ();
10016 /* Traverse the DIE's, reverse their lists of attributes and children,
10017 and add add sibling attributes to those DIE's that have children. */
10018 add_sibling_attributes (comp_unit_die);
10020 /* Output a terminator label for the .text section. */
10021 fputc ('\n', asm_out_file);
10022 ASM_OUTPUT_SECTION (asm_out_file, TEXT_SECTION);
10023 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, TEXT_END_LABEL, 0);
10026 /* Output a terminator label for the .data section. */
10027 fputc ('\n', asm_out_file);
10028 ASM_OUTPUT_SECTION (asm_out_file, DATA_SECTION);
10029 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, DATA_END_LABEL, 0);
10031 /* Output a terminator label for the .bss section. */
10032 fputc ('\n', asm_out_file);
10033 ASM_OUTPUT_SECTION (asm_out_file, BSS_SECTION);
10034 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, BSS_END_LABEL, 0);
10037 /* Output the source line correspondence table. */
10038 if (line_info_table_in_use > 1 || separate_line_info_table_in_use)
10040 if (! DWARF2_ASM_LINE_DEBUG_INFO)
10042 fputc ('\n', asm_out_file);
10043 ASM_OUTPUT_SECTION (asm_out_file, DEBUG_LINE_SECTION);
10044 output_line_info ();
10047 /* We can only use the low/high_pc attributes if all of the code
10049 if (separate_line_info_table_in_use == 0)
10051 add_AT_lbl_id (comp_unit_die, DW_AT_low_pc, text_section_label);
10052 add_AT_lbl_id (comp_unit_die, DW_AT_high_pc, text_end_label);
10055 add_AT_lbl_offset (comp_unit_die, DW_AT_stmt_list,
10056 debug_line_section_label);
10059 #if 0 /* unimplemented */
10060 if (debug_info_level >= DINFO_LEVEL_VERBOSE && primary)
10061 add_AT_unsigned (die, DW_AT_macro_info, 0);
10064 /* Output the abbreviation table. */
10065 fputc ('\n', asm_out_file);
10066 ASM_OUTPUT_SECTION (asm_out_file, ABBREV_SECTION);
10067 build_abbrev_table (comp_unit_die);
10068 output_abbrev_section ();
10070 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
10071 next_die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE;
10072 calc_die_sizes (comp_unit_die);
10074 /* Output debugging information. */
10075 fputc ('\n', asm_out_file);
10076 ASM_OUTPUT_SECTION (asm_out_file, DEBUG_INFO_SECTION);
10077 output_compilation_unit_header ();
10078 output_die (comp_unit_die);
10080 if (pubname_table_in_use)
10082 /* Output public names table. */
10083 fputc ('\n', asm_out_file);
10084 ASM_OUTPUT_SECTION (asm_out_file, PUBNAMES_SECTION);
10085 output_pubnames ();
10088 /* We only put functions in the arange table, so don't write it out if
10089 we don't have any. */
10090 if (fde_table_in_use)
10092 /* Output the address range information. */
10093 fputc ('\n', asm_out_file);
10094 ASM_OUTPUT_SECTION (asm_out_file, ARANGES_SECTION);
10098 #endif /* DWARF2_DEBUGGING_INFO */