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)
69 #define DIR_SEPARATOR '/'
72 /* Decide whether we want to emit frame unwind information for the current
78 return (write_symbols == DWARF2_DEBUG
79 #ifdef DWARF2_FRAME_INFO
82 #ifdef DWARF2_UNWIND_INFO
84 || (flag_exceptions && ! exceptions_via_longjmp)
89 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
91 /* How to start an assembler comment. */
92 #ifndef ASM_COMMENT_START
93 #define ASM_COMMENT_START ";#"
96 typedef struct dw_cfi_struct *dw_cfi_ref;
97 typedef struct dw_fde_struct *dw_fde_ref;
98 typedef union dw_cfi_oprnd_struct *dw_cfi_oprnd_ref;
100 /* Call frames are described using a sequence of Call Frame
101 Information instructions. The register number, offset
102 and address fields are provided as possible operands;
103 their use is selected by the opcode field. */
105 typedef union dw_cfi_oprnd_struct
107 unsigned long dw_cfi_reg_num;
108 long int dw_cfi_offset;
113 typedef struct dw_cfi_struct
115 dw_cfi_ref dw_cfi_next;
116 enum dwarf_call_frame_info dw_cfi_opc;
117 dw_cfi_oprnd dw_cfi_oprnd1;
118 dw_cfi_oprnd dw_cfi_oprnd2;
122 /* All call frame descriptions (FDE's) in the GCC generated DWARF
123 refer to a single Common Information Entry (CIE), defined at
124 the beginning of the .debug_frame section. This used of a single
125 CIE obviates the need to keep track of multiple CIE's
126 in the DWARF generation routines below. */
128 typedef struct dw_fde_struct
131 char *dw_fde_current_label;
133 dw_cfi_ref dw_fde_cfi;
137 /* Maximum size (in bytes) of an artificially generated label. */
138 #define MAX_ARTIFICIAL_LABEL_BYTES 30
140 /* Make sure we know the sizes of the various types dwarf can describe. These
141 are only defaults. If the sizes are different for your target, you should
142 override these values by defining the appropriate symbols in your tm.h
145 #ifndef CHAR_TYPE_SIZE
146 #define CHAR_TYPE_SIZE BITS_PER_UNIT
149 #define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
152 /* The size in bytes of a DWARF field indicating an offset or length
153 relative to a debug info section, specified to be 4 bytes in the DWARF-2
154 specification. The SGI/MIPS ABI defines it to be the same as PTR_SIZE. */
156 #ifndef DWARF_OFFSET_SIZE
157 #define DWARF_OFFSET_SIZE 4
160 #define DWARF_VERSION 2
162 /* Round SIZE up to the nearest BOUNDARY. */
163 #define DWARF_ROUND(SIZE,BOUNDARY) \
164 (((SIZE) + (BOUNDARY) - 1) & ~((BOUNDARY) - 1))
166 /* Offsets recorded in opcodes are a multiple of this alignment factor. */
167 #ifdef STACK_GROWS_DOWNWARD
168 #define DWARF_CIE_DATA_ALIGNMENT (-UNITS_PER_WORD)
170 #define DWARF_CIE_DATA_ALIGNMENT UNITS_PER_WORD
173 /* A pointer to the base of a table that contains frame description
174 information for each routine. */
175 static dw_fde_ref fde_table;
177 /* Number of elements currently allocated for fde_table. */
178 static unsigned fde_table_allocated;
180 /* Number of elements in fde_table currently in use. */
181 static unsigned fde_table_in_use;
183 /* Size (in elements) of increments by which we may expand the
185 #define FDE_TABLE_INCREMENT 256
187 /* A list of call frame insns for the CIE. */
188 static dw_cfi_ref cie_cfi_head;
190 /* The number of the current function definition for which debugging
191 information is being generated. These numbers range from 1 up to the
192 maximum number of function definitions contained within the current
193 compilation unit. These numbers are used to create unique label id's
194 unique to each function definition. */
195 static unsigned current_funcdef_number = 0;
197 /* Some DWARF extensions (e.g., MIPS/SGI) implement a subprogram
198 attribute that accelerates the lookup of the FDE associated
199 with the subprogram. This variable holds the table index of the FDE
200 associated with the current function (body) definition. */
201 static unsigned current_funcdef_fde;
203 /* Forward declarations for functions defined in this file. */
205 static char *stripattributes PROTO((const char *));
206 static const char *dwarf_cfi_name PROTO((unsigned));
207 static dw_cfi_ref new_cfi PROTO((void));
208 static void add_cfi PROTO((dw_cfi_ref *, dw_cfi_ref));
209 static unsigned long size_of_uleb128 PROTO((unsigned long));
210 static unsigned long size_of_sleb128 PROTO((long));
211 static void output_uleb128 PROTO((unsigned long));
212 static void output_sleb128 PROTO((long));
213 static void add_fde_cfi PROTO((char *, dw_cfi_ref));
214 static void lookup_cfa_1 PROTO((dw_cfi_ref, unsigned long *,
216 static void lookup_cfa PROTO((unsigned long *, long *));
217 static void reg_save PROTO((char *, unsigned, unsigned,
219 static void initial_return_save PROTO((rtx));
220 static void output_cfi PROTO((dw_cfi_ref, dw_fde_ref));
221 static void output_call_frame_info PROTO((int));
222 static unsigned reg_number PROTO((rtx));
223 static void dwarf2out_stack_adjust PROTO((rtx));
224 static void dwarf2out_frame_debug_expr PROTO((rtx, char *));
226 /* Definitions of defaults for assembler-dependent names of various
227 pseudo-ops and section names.
228 Theses may be overridden in the tm.h file (if necessary) for a particular
231 #ifdef OBJECT_FORMAT_ELF
232 #ifndef UNALIGNED_SHORT_ASM_OP
233 #define UNALIGNED_SHORT_ASM_OP ".2byte"
235 #ifndef UNALIGNED_INT_ASM_OP
236 #define UNALIGNED_INT_ASM_OP ".4byte"
238 #ifndef UNALIGNED_DOUBLE_INT_ASM_OP
239 #define UNALIGNED_DOUBLE_INT_ASM_OP ".8byte"
241 #endif /* OBJECT_FORMAT_ELF */
244 #define ASM_BYTE_OP ".byte"
247 /* Data and reference forms for relocatable data. */
248 #define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
249 #define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
251 /* Pseudo-op for defining a new section. */
252 #ifndef SECTION_ASM_OP
253 #define SECTION_ASM_OP ".section"
256 /* The default format used by the ASM_OUTPUT_SECTION macro (see below) to
257 print the SECTION_ASM_OP and the section name. The default here works for
258 almost all svr4 assemblers, except for the sparc, where the section name
259 must be enclosed in double quotes. (See sparcv4.h). */
260 #ifndef SECTION_FORMAT
261 #ifdef PUSHSECTION_FORMAT
262 #define SECTION_FORMAT PUSHSECTION_FORMAT
264 #define SECTION_FORMAT "\t%s\t%s\n"
268 #ifndef FRAME_SECTION
269 #define FRAME_SECTION ".debug_frame"
272 #ifndef FUNC_BEGIN_LABEL
273 #define FUNC_BEGIN_LABEL "LFB"
275 #ifndef FUNC_END_LABEL
276 #define FUNC_END_LABEL "LFE"
278 #define CIE_AFTER_SIZE_LABEL "LSCIE"
279 #define CIE_END_LABEL "LECIE"
280 #define CIE_LENGTH_LABEL "LLCIE"
281 #define FDE_AFTER_SIZE_LABEL "LSFDE"
282 #define FDE_END_LABEL "LEFDE"
283 #define FDE_LENGTH_LABEL "LLFDE"
285 /* Definitions of defaults for various types of primitive assembly language
286 output operations. These may be overridden from within the tm.h file,
287 but typically, that is unnecessary. */
289 #ifndef ASM_OUTPUT_SECTION
290 #define ASM_OUTPUT_SECTION(FILE, SECTION) \
291 fprintf ((FILE), SECTION_FORMAT, SECTION_ASM_OP, SECTION)
294 #ifndef ASM_OUTPUT_DWARF_DATA1
295 #define ASM_OUTPUT_DWARF_DATA1(FILE,VALUE) \
296 fprintf ((FILE), "\t%s\t0x%x", ASM_BYTE_OP, (unsigned) (VALUE))
299 #ifndef ASM_OUTPUT_DWARF_DELTA1
300 #define ASM_OUTPUT_DWARF_DELTA1(FILE,LABEL1,LABEL2) \
301 do { fprintf ((FILE), "\t%s\t", ASM_BYTE_OP); \
302 assemble_name (FILE, LABEL1); \
303 fprintf (FILE, "-"); \
304 assemble_name (FILE, LABEL2); \
308 #ifdef UNALIGNED_INT_ASM_OP
310 #ifndef UNALIGNED_OFFSET_ASM_OP
311 #define UNALIGNED_OFFSET_ASM_OP \
312 (DWARF_OFFSET_SIZE == 8 ? UNALIGNED_DOUBLE_INT_ASM_OP : UNALIGNED_INT_ASM_OP)
315 #ifndef UNALIGNED_WORD_ASM_OP
316 #define UNALIGNED_WORD_ASM_OP \
317 (PTR_SIZE == 8 ? UNALIGNED_DOUBLE_INT_ASM_OP : UNALIGNED_INT_ASM_OP)
320 #ifndef ASM_OUTPUT_DWARF_DELTA2
321 #define ASM_OUTPUT_DWARF_DELTA2(FILE,LABEL1,LABEL2) \
322 do { fprintf ((FILE), "\t%s\t", UNALIGNED_SHORT_ASM_OP); \
323 assemble_name (FILE, LABEL1); \
324 fprintf (FILE, "-"); \
325 assemble_name (FILE, LABEL2); \
329 #ifndef ASM_OUTPUT_DWARF_DELTA4
330 #define ASM_OUTPUT_DWARF_DELTA4(FILE,LABEL1,LABEL2) \
331 do { fprintf ((FILE), "\t%s\t", UNALIGNED_INT_ASM_OP); \
332 assemble_name (FILE, LABEL1); \
333 fprintf (FILE, "-"); \
334 assemble_name (FILE, LABEL2); \
338 #ifndef ASM_OUTPUT_DWARF_DELTA
339 #define ASM_OUTPUT_DWARF_DELTA(FILE,LABEL1,LABEL2) \
340 do { fprintf ((FILE), "\t%s\t", UNALIGNED_OFFSET_ASM_OP); \
341 assemble_name (FILE, LABEL1); \
342 fprintf (FILE, "-"); \
343 assemble_name (FILE, LABEL2); \
347 #ifndef ASM_OUTPUT_DWARF_ADDR_DELTA
348 #define ASM_OUTPUT_DWARF_ADDR_DELTA(FILE,LABEL1,LABEL2) \
349 do { fprintf ((FILE), "\t%s\t", UNALIGNED_WORD_ASM_OP); \
350 assemble_name (FILE, LABEL1); \
351 fprintf (FILE, "-"); \
352 assemble_name (FILE, LABEL2); \
356 #ifndef ASM_OUTPUT_DWARF_ADDR
357 #define ASM_OUTPUT_DWARF_ADDR(FILE,LABEL) \
358 do { fprintf ((FILE), "\t%s\t", UNALIGNED_WORD_ASM_OP); \
359 assemble_name (FILE, LABEL); \
363 /* ??? This macro takes an RTX in dwarfout.c and a string in dwarf2out.c.
364 We resolve the conflict by creating a new macro ASM_OUTPUT_DWARF2_ADDR_CONST
365 for ports that want to support both DWARF1 and DWARF2. This needs a better
366 solution. See also the comments in sparc/sp64-elf.h. */
367 #ifdef ASM_OUTPUT_DWARF2_ADDR_CONST
368 #undef ASM_OUTPUT_DWARF_ADDR_CONST
369 #define ASM_OUTPUT_DWARF_ADDR_CONST(FILE,ADDR) \
370 ASM_OUTPUT_DWARF2_ADDR_CONST (FILE, ADDR)
373 #ifndef ASM_OUTPUT_DWARF_ADDR_CONST
374 #define ASM_OUTPUT_DWARF_ADDR_CONST(FILE,ADDR) \
375 fprintf ((FILE), "\t%s\t%s", UNALIGNED_WORD_ASM_OP, (ADDR))
378 #ifndef ASM_OUTPUT_DWARF_OFFSET4
379 #define ASM_OUTPUT_DWARF_OFFSET4(FILE,LABEL) \
380 do { fprintf ((FILE), "\t%s\t", UNALIGNED_INT_ASM_OP); \
381 assemble_name (FILE, LABEL); \
385 #ifndef ASM_OUTPUT_DWARF_OFFSET
386 #define ASM_OUTPUT_DWARF_OFFSET(FILE,LABEL) \
387 do { fprintf ((FILE), "\t%s\t", UNALIGNED_OFFSET_ASM_OP); \
388 assemble_name (FILE, LABEL); \
392 #ifndef ASM_OUTPUT_DWARF_DATA2
393 #define ASM_OUTPUT_DWARF_DATA2(FILE,VALUE) \
394 fprintf ((FILE), "\t%s\t0x%x", UNALIGNED_SHORT_ASM_OP, (unsigned) (VALUE))
397 #ifndef ASM_OUTPUT_DWARF_DATA4
398 #define ASM_OUTPUT_DWARF_DATA4(FILE,VALUE) \
399 fprintf ((FILE), "\t%s\t0x%x", UNALIGNED_INT_ASM_OP, (unsigned) (VALUE))
402 #ifndef ASM_OUTPUT_DWARF_DATA
403 #define ASM_OUTPUT_DWARF_DATA(FILE,VALUE) \
404 fprintf ((FILE), "\t%s\t0x%lx", UNALIGNED_OFFSET_ASM_OP, \
405 (unsigned long) (VALUE))
408 #ifndef ASM_OUTPUT_DWARF_ADDR_DATA
409 #define ASM_OUTPUT_DWARF_ADDR_DATA(FILE,VALUE) \
410 fprintf ((FILE), "\t%s\t0x%lx", UNALIGNED_WORD_ASM_OP, \
411 (unsigned long) (VALUE))
414 #ifndef ASM_OUTPUT_DWARF_DATA8
415 #define ASM_OUTPUT_DWARF_DATA8(FILE,HIGH_VALUE,LOW_VALUE) \
417 if (WORDS_BIG_ENDIAN) \
419 fprintf ((FILE), "\t%s\t0x%lx\n", UNALIGNED_INT_ASM_OP, (HIGH_VALUE));\
420 fprintf ((FILE), "\t%s\t0x%lx", UNALIGNED_INT_ASM_OP, (LOW_VALUE));\
424 fprintf ((FILE), "\t%s\t0x%lx\n", UNALIGNED_INT_ASM_OP, (LOW_VALUE)); \
425 fprintf ((FILE), "\t%s\t0x%lx", UNALIGNED_INT_ASM_OP, (HIGH_VALUE)); \
430 #else /* UNALIGNED_INT_ASM_OP */
432 /* We don't have unaligned support, let's hope the normal output works for
435 #define ASM_OUTPUT_DWARF_ADDR(FILE,LABEL) \
436 assemble_integer (gen_rtx_SYMBOL_REF (Pmode, LABEL), PTR_SIZE, 1)
438 #define ASM_OUTPUT_DWARF_OFFSET4(FILE,LABEL) \
439 assemble_integer (gen_rtx_SYMBOL_REF (SImode, LABEL), 4, 1)
441 #define ASM_OUTPUT_DWARF_OFFSET(FILE,LABEL) \
442 assemble_integer (gen_rtx_SYMBOL_REF (SImode, LABEL), 4, 1)
444 #define ASM_OUTPUT_DWARF_DELTA2(FILE,LABEL1,LABEL2) \
445 assemble_integer (gen_rtx_MINUS (HImode, \
446 gen_rtx_SYMBOL_REF (Pmode, LABEL1), \
447 gen_rtx_SYMBOL_REF (Pmode, LABEL2)), \
450 #define ASM_OUTPUT_DWARF_DELTA4(FILE,LABEL1,LABEL2) \
451 assemble_integer (gen_rtx_MINUS (SImode, \
452 gen_rtx_SYMBOL_REF (Pmode, LABEL1), \
453 gen_rtx_SYMBOL_REF (Pmode, LABEL2)), \
456 #define ASM_OUTPUT_DWARF_ADDR_DELTA(FILE,LABEL1,LABEL2) \
457 assemble_integer (gen_rtx_MINUS (Pmode, \
458 gen_rtx_SYMBOL_REF (Pmode, LABEL1), \
459 gen_rtx_SYMBOL_REF (Pmode, LABEL2)), \
462 #define ASM_OUTPUT_DWARF_DELTA(FILE,LABEL1,LABEL2) \
463 ASM_OUTPUT_DWARF_DELTA4 (FILE,LABEL1,LABEL2)
465 #define ASM_OUTPUT_DWARF_DATA4(FILE,VALUE) \
466 assemble_integer (GEN_INT (VALUE), 4, 1)
468 #endif /* UNALIGNED_INT_ASM_OP */
471 #ifndef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
472 #define ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL(FILE, SY, HI, LO) \
474 fprintf (FILE, "\t%s\t", SET_ASM_OP); \
475 assemble_name (FILE, SY); \
477 assemble_name (FILE, HI); \
479 assemble_name (FILE, LO); \
482 #endif /* SET_ASM_OP */
484 /* This is similar to the default ASM_OUTPUT_ASCII, except that no trailing
485 newline is produced. When flag_debug_asm is asserted, we add commentary
486 at the end of the line, so we must avoid output of a newline here. */
487 #ifndef ASM_OUTPUT_DWARF_STRING
488 #define ASM_OUTPUT_DWARF_STRING(FILE,P) \
490 register int slen = strlen(P); \
491 register const char *p = (P); \
493 fprintf (FILE, "\t.ascii \""); \
494 for (i = 0; i < slen; i++) \
496 register int c = p[i]; \
497 if (c == '\"' || c == '\\') \
503 fprintf (FILE, "\\%o", c); \
506 fprintf (FILE, "\\0\""); \
511 /* The DWARF 2 CFA column which tracks the return address. Normally this
512 is the column for PC, or the first column after all of the hard
514 #ifndef DWARF_FRAME_RETURN_COLUMN
516 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (PC_REGNUM)
518 #define DWARF_FRAME_RETURN_COLUMN FIRST_PSEUDO_REGISTER
522 /* The mapping from gcc register number to DWARF 2 CFA column number. By
523 default, we just provide columns for all registers. */
524 #ifndef DWARF_FRAME_REGNUM
525 #define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG)
528 /* Hook used by __throw. */
531 expand_builtin_dwarf_fp_regnum ()
533 return GEN_INT (DWARF_FRAME_REGNUM (HARD_FRAME_POINTER_REGNUM));
536 /* The offset from the incoming value of %sp to the top of the stack frame
537 for the current function. */
538 #ifndef INCOMING_FRAME_SP_OFFSET
539 #define INCOMING_FRAME_SP_OFFSET 0
542 /* Return a pointer to a copy of the section string name S with all
543 attributes stripped off, and an asterisk prepended (for assemble_name). */
549 char *stripped = xmalloc (strlen (s) + 2);
554 while (*s && *s != ',')
561 /* Return the register number described by a given RTL node. */
567 register unsigned regno = REGNO (rtl);
569 if (regno >= FIRST_PSEUDO_REGISTER)
571 warning ("internal regno botch: regno = %d\n", regno);
575 regno = DBX_REGISTER_NUMBER (regno);
579 /* Generate code to initialize the register size table. */
582 expand_builtin_init_dwarf_reg_sizes (address)
586 enum machine_mode mode = TYPE_MODE (char_type_node);
587 rtx addr = expand_expr (address, NULL_RTX, VOIDmode, 0);
588 rtx mem = gen_rtx_MEM (mode, addr);
590 for (i = 0; i < FIRST_PSEUDO_REGISTER; ++i)
592 int offset = i * GET_MODE_SIZE (mode);
593 int size = GET_MODE_SIZE (reg_raw_mode[i]);
595 emit_move_insn (change_address (mem, mode,
596 plus_constant (addr, offset)),
601 /* Convert a DWARF call frame info. operation to its string name */
604 dwarf_cfi_name (cfi_opc)
605 register unsigned cfi_opc;
609 case DW_CFA_advance_loc:
610 return "DW_CFA_advance_loc";
612 return "DW_CFA_offset";
614 return "DW_CFA_restore";
618 return "DW_CFA_set_loc";
619 case DW_CFA_advance_loc1:
620 return "DW_CFA_advance_loc1";
621 case DW_CFA_advance_loc2:
622 return "DW_CFA_advance_loc2";
623 case DW_CFA_advance_loc4:
624 return "DW_CFA_advance_loc4";
625 case DW_CFA_offset_extended:
626 return "DW_CFA_offset_extended";
627 case DW_CFA_restore_extended:
628 return "DW_CFA_restore_extended";
629 case DW_CFA_undefined:
630 return "DW_CFA_undefined";
631 case DW_CFA_same_value:
632 return "DW_CFA_same_value";
633 case DW_CFA_register:
634 return "DW_CFA_register";
635 case DW_CFA_remember_state:
636 return "DW_CFA_remember_state";
637 case DW_CFA_restore_state:
638 return "DW_CFA_restore_state";
640 return "DW_CFA_def_cfa";
641 case DW_CFA_def_cfa_register:
642 return "DW_CFA_def_cfa_register";
643 case DW_CFA_def_cfa_offset:
644 return "DW_CFA_def_cfa_offset";
646 /* SGI/MIPS specific */
647 case DW_CFA_MIPS_advance_loc8:
648 return "DW_CFA_MIPS_advance_loc8";
651 case DW_CFA_GNU_window_save:
652 return "DW_CFA_GNU_window_save";
653 case DW_CFA_GNU_args_size:
654 return "DW_CFA_GNU_args_size";
657 return "DW_CFA_<unknown>";
661 /* Return a pointer to a newly allocated Call Frame Instruction. */
663 static inline dw_cfi_ref
666 register dw_cfi_ref cfi = (dw_cfi_ref) xmalloc (sizeof (dw_cfi_node));
668 cfi->dw_cfi_next = NULL;
669 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = 0;
670 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = 0;
675 /* Add a Call Frame Instruction to list of instructions. */
678 add_cfi (list_head, cfi)
679 register dw_cfi_ref *list_head;
680 register dw_cfi_ref cfi;
682 register dw_cfi_ref *p;
684 /* Find the end of the chain. */
685 for (p = list_head; (*p) != NULL; p = &(*p)->dw_cfi_next)
691 /* Generate a new label for the CFI info to refer to. */
694 dwarf2out_cfi_label ()
696 static char label[20];
697 static unsigned long label_num = 0;
699 ASM_GENERATE_INTERNAL_LABEL (label, "LCFI", label_num++);
700 ASM_OUTPUT_LABEL (asm_out_file, label);
705 /* Add CFI to the current fde at the PC value indicated by LABEL if specified,
706 or to the CIE if LABEL is NULL. */
709 add_fde_cfi (label, cfi)
710 register char *label;
711 register dw_cfi_ref cfi;
715 register dw_fde_ref fde = &fde_table[fde_table_in_use - 1];
718 label = dwarf2out_cfi_label ();
720 if (fde->dw_fde_current_label == NULL
721 || strcmp (label, fde->dw_fde_current_label) != 0)
723 register dw_cfi_ref xcfi;
725 fde->dw_fde_current_label = label = xstrdup (label);
727 /* Set the location counter to the new label. */
729 xcfi->dw_cfi_opc = DW_CFA_advance_loc4;
730 xcfi->dw_cfi_oprnd1.dw_cfi_addr = label;
731 add_cfi (&fde->dw_fde_cfi, xcfi);
734 add_cfi (&fde->dw_fde_cfi, cfi);
738 add_cfi (&cie_cfi_head, cfi);
741 /* Subroutine of lookup_cfa. */
744 lookup_cfa_1 (cfi, regp, offsetp)
745 register dw_cfi_ref cfi;
746 register unsigned long *regp;
747 register long *offsetp;
749 switch (cfi->dw_cfi_opc)
751 case DW_CFA_def_cfa_offset:
752 *offsetp = cfi->dw_cfi_oprnd1.dw_cfi_offset;
754 case DW_CFA_def_cfa_register:
755 *regp = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
758 *regp = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
759 *offsetp = cfi->dw_cfi_oprnd2.dw_cfi_offset;
766 /* Find the previous value for the CFA. */
769 lookup_cfa (regp, offsetp)
770 register unsigned long *regp;
771 register long *offsetp;
773 register dw_cfi_ref cfi;
775 *regp = (unsigned long) -1;
778 for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
779 lookup_cfa_1 (cfi, regp, offsetp);
781 if (fde_table_in_use)
783 register dw_fde_ref fde = &fde_table[fde_table_in_use - 1];
784 for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
785 lookup_cfa_1 (cfi, regp, offsetp);
789 /* The current rule for calculating the DWARF2 canonical frame address. */
790 static unsigned long cfa_reg;
791 static long cfa_offset;
793 /* The register used for saving registers to the stack, and its offset
795 static unsigned cfa_store_reg;
796 static long cfa_store_offset;
798 /* The running total of the size of arguments pushed onto the stack. */
799 static long args_size;
801 /* The last args_size we actually output. */
802 static long old_args_size;
804 /* Entry point to update the canonical frame address (CFA).
805 LABEL is passed to add_fde_cfi. The value of CFA is now to be
806 calculated from REG+OFFSET. */
809 dwarf2out_def_cfa (label, reg, offset)
810 register char *label;
811 register unsigned reg;
812 register long offset;
814 register dw_cfi_ref cfi;
815 unsigned long old_reg;
820 if (cfa_store_reg == reg)
821 cfa_store_offset = offset;
823 reg = DWARF_FRAME_REGNUM (reg);
824 lookup_cfa (&old_reg, &old_offset);
826 if (reg == old_reg && offset == old_offset)
833 cfi->dw_cfi_opc = DW_CFA_def_cfa_offset;
834 cfi->dw_cfi_oprnd1.dw_cfi_offset = offset;
837 #ifndef MIPS_DEBUGGING_INFO /* SGI dbx thinks this means no offset. */
838 else if (offset == old_offset && old_reg != (unsigned long) -1)
840 cfi->dw_cfi_opc = DW_CFA_def_cfa_register;
841 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
847 cfi->dw_cfi_opc = DW_CFA_def_cfa;
848 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
849 cfi->dw_cfi_oprnd2.dw_cfi_offset = offset;
852 add_fde_cfi (label, cfi);
855 /* Add the CFI for saving a register. REG is the CFA column number.
856 LABEL is passed to add_fde_cfi.
857 If SREG is -1, the register is saved at OFFSET from the CFA;
858 otherwise it is saved in SREG. */
861 reg_save (label, reg, sreg, offset)
862 register char * label;
863 register unsigned reg;
864 register unsigned sreg;
865 register long offset;
867 register dw_cfi_ref cfi = new_cfi ();
869 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
871 /* The following comparison is correct. -1 is used to indicate that
872 the value isn't a register number. */
873 if (sreg == (unsigned int) -1)
876 /* The register number won't fit in 6 bits, so we have to use
878 cfi->dw_cfi_opc = DW_CFA_offset_extended;
880 cfi->dw_cfi_opc = DW_CFA_offset;
882 offset /= DWARF_CIE_DATA_ALIGNMENT;
885 cfi->dw_cfi_oprnd2.dw_cfi_offset = offset;
889 cfi->dw_cfi_opc = DW_CFA_register;
890 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = sreg;
893 add_fde_cfi (label, cfi);
896 /* Add the CFI for saving a register window. LABEL is passed to reg_save.
897 This CFI tells the unwinder that it needs to restore the window registers
898 from the previous frame's window save area.
900 ??? Perhaps we should note in the CIE where windows are saved (instead of
901 assuming 0(cfa)) and what registers are in the window. */
904 dwarf2out_window_save (label)
905 register char * label;
907 register dw_cfi_ref cfi = new_cfi ();
908 cfi->dw_cfi_opc = DW_CFA_GNU_window_save;
909 add_fde_cfi (label, cfi);
912 /* Add a CFI to update the running total of the size of arguments
913 pushed onto the stack. */
916 dwarf2out_args_size (label, size)
920 register dw_cfi_ref cfi;
922 if (size == old_args_size)
924 old_args_size = size;
927 cfi->dw_cfi_opc = DW_CFA_GNU_args_size;
928 cfi->dw_cfi_oprnd1.dw_cfi_offset = size;
929 add_fde_cfi (label, cfi);
932 /* Entry point for saving a register to the stack. REG is the GCC register
933 number. LABEL and OFFSET are passed to reg_save. */
936 dwarf2out_reg_save (label, reg, offset)
937 register char * label;
938 register unsigned reg;
939 register long offset;
941 reg_save (label, DWARF_FRAME_REGNUM (reg), -1, offset);
944 /* Entry point for saving the return address in the stack.
945 LABEL and OFFSET are passed to reg_save. */
948 dwarf2out_return_save (label, offset)
949 register char * label;
950 register long offset;
952 reg_save (label, DWARF_FRAME_RETURN_COLUMN, -1, offset);
955 /* Entry point for saving the return address in a register.
956 LABEL and SREG are passed to reg_save. */
959 dwarf2out_return_reg (label, sreg)
960 register char * label;
961 register unsigned sreg;
963 reg_save (label, DWARF_FRAME_RETURN_COLUMN, sreg, 0);
966 /* Record the initial position of the return address. RTL is
967 INCOMING_RETURN_ADDR_RTX. */
970 initial_return_save (rtl)
973 unsigned int reg = (unsigned int) -1;
976 switch (GET_CODE (rtl))
979 /* RA is in a register. */
980 reg = reg_number (rtl);
983 /* RA is on the stack. */
985 switch (GET_CODE (rtl))
988 if (REGNO (rtl) != STACK_POINTER_REGNUM)
993 if (REGNO (XEXP (rtl, 0)) != STACK_POINTER_REGNUM)
995 offset = INTVAL (XEXP (rtl, 1));
998 if (REGNO (XEXP (rtl, 0)) != STACK_POINTER_REGNUM)
1000 offset = -INTVAL (XEXP (rtl, 1));
1007 /* The return address is at some offset from any value we can
1008 actually load. For instance, on the SPARC it is in %i7+8. Just
1009 ignore the offset for now; it doesn't matter for unwinding frames. */
1010 if (GET_CODE (XEXP (rtl, 1)) != CONST_INT)
1012 initial_return_save (XEXP (rtl, 0));
1018 reg_save (NULL, DWARF_FRAME_RETURN_COLUMN, reg, offset - cfa_offset);
1021 /* Check INSN to see if it looks like a push or a stack adjustment, and
1022 make a note of it if it does. EH uses this information to find out how
1023 much extra space it needs to pop off the stack. */
1026 dwarf2out_stack_adjust (insn)
1032 if (! asynchronous_exceptions && GET_CODE (insn) == CALL_INSN)
1034 /* Extract the size of the args from the CALL rtx itself. */
1036 insn = PATTERN (insn);
1037 if (GET_CODE (insn) == PARALLEL)
1038 insn = XVECEXP (insn, 0, 0);
1039 if (GET_CODE (insn) == SET)
1040 insn = SET_SRC (insn);
1041 assert (GET_CODE (insn) == CALL);
1042 dwarf2out_args_size ("", INTVAL (XEXP (insn, 1)));
1046 /* If only calls can throw, and we have a frame pointer,
1047 save up adjustments until we see the CALL_INSN. */
1048 else if (! asynchronous_exceptions
1049 && cfa_reg != STACK_POINTER_REGNUM)
1052 if (GET_CODE (insn) == BARRIER)
1054 /* When we see a BARRIER, we know to reset args_size to 0. Usually
1055 the compiler will have already emitted a stack adjustment, but
1056 doesn't bother for calls to noreturn functions. */
1057 #ifdef STACK_GROWS_DOWNWARD
1058 offset = -args_size;
1063 else if (GET_CODE (PATTERN (insn)) == SET)
1068 insn = PATTERN (insn);
1069 src = SET_SRC (insn);
1070 dest = SET_DEST (insn);
1072 if (dest == stack_pointer_rtx)
1074 /* (set (reg sp) (plus (reg sp) (const_int))) */
1075 code = GET_CODE (src);
1076 if (! (code == PLUS || code == MINUS)
1077 || XEXP (src, 0) != stack_pointer_rtx
1078 || GET_CODE (XEXP (src, 1)) != CONST_INT)
1081 offset = INTVAL (XEXP (src, 1));
1083 else if (GET_CODE (dest) == MEM)
1085 /* (set (mem (pre_dec (reg sp))) (foo)) */
1086 src = XEXP (dest, 0);
1087 code = GET_CODE (src);
1089 if (! (code == PRE_DEC || code == PRE_INC)
1090 || XEXP (src, 0) != stack_pointer_rtx)
1093 offset = GET_MODE_SIZE (GET_MODE (dest));
1098 if (code == PLUS || code == PRE_INC)
1107 if (cfa_reg == STACK_POINTER_REGNUM)
1108 cfa_offset += offset;
1110 #ifndef STACK_GROWS_DOWNWARD
1113 args_size += offset;
1117 label = dwarf2out_cfi_label ();
1118 dwarf2out_def_cfa (label, cfa_reg, cfa_offset);
1119 dwarf2out_args_size (label, args_size);
1122 /* A temporary register used in adjusting SP or setting up the store_reg. */
1123 static unsigned cfa_temp_reg;
1125 /* A temporary value used in adjusting SP or setting up the store_reg. */
1126 static long cfa_temp_value;
1128 /* Record call frame debugging information for an expression, which either
1129 sets SP or FP (adjusting how we calculate the frame address) or saves a
1130 register to the stack. */
1133 dwarf2out_frame_debug_expr (expr, label)
1140 /* If RTX_FRAME_RELATED_P is set on a PARALLEL, process each member of
1141 the PARALLEL independantly. The first element is always processed if
1142 it is a SET. This is for backward compatability. Other elements
1143 are processed only if they are SETs and the RTX_FRAME_RELATED_P
1144 flag is set in them. */
1146 if (GET_CODE (expr) == PARALLEL)
1149 int limit = XVECLEN (expr, 0);
1151 for (par_index = 0; par_index < limit; par_index++)
1153 rtx x = XVECEXP (expr, 0, par_index);
1155 if (GET_CODE (x) == SET &&
1156 (RTX_FRAME_RELATED_P (x) || par_index == 0))
1157 dwarf2out_frame_debug_expr (x, label);
1162 if (GET_CODE (expr) != SET)
1165 src = SET_SRC (expr);
1166 dest = SET_DEST (expr);
1168 switch (GET_CODE (dest))
1171 /* Update the CFA rule wrt SP or FP. Make sure src is
1172 relative to the current CFA register. */
1173 switch (GET_CODE (src))
1175 /* Setting FP from SP. */
1177 if (cfa_reg != (unsigned) REGNO (src))
1179 if (REGNO (dest) != STACK_POINTER_REGNUM
1180 && !(frame_pointer_needed
1181 && REGNO (dest) == HARD_FRAME_POINTER_REGNUM))
1183 cfa_reg = REGNO (dest);
1188 if (dest == stack_pointer_rtx)
1191 switch (GET_CODE (XEXP (src, 1)))
1194 offset = INTVAL (XEXP (src, 1));
1197 if ((unsigned) REGNO (XEXP (src, 1)) != cfa_temp_reg)
1199 offset = cfa_temp_value;
1205 if (XEXP (src, 0) == hard_frame_pointer_rtx)
1207 /* Restoring SP from FP in the epilogue. */
1208 if (cfa_reg != (unsigned) HARD_FRAME_POINTER_REGNUM)
1210 cfa_reg = STACK_POINTER_REGNUM;
1212 else if (XEXP (src, 0) != stack_pointer_rtx)
1215 if (GET_CODE (src) == PLUS)
1217 if (cfa_reg == STACK_POINTER_REGNUM)
1218 cfa_offset += offset;
1219 if (cfa_store_reg == STACK_POINTER_REGNUM)
1220 cfa_store_offset += offset;
1222 else if (dest == hard_frame_pointer_rtx)
1224 /* Either setting the FP from an offset of the SP,
1225 or adjusting the FP */
1226 if (! frame_pointer_needed
1227 || REGNO (dest) != HARD_FRAME_POINTER_REGNUM)
1230 if (XEXP (src, 0) == stack_pointer_rtx
1231 && GET_CODE (XEXP (src, 1)) == CONST_INT)
1233 if (cfa_reg != STACK_POINTER_REGNUM)
1235 offset = INTVAL (XEXP (src, 1));
1236 if (GET_CODE (src) == PLUS)
1238 cfa_offset += offset;
1239 cfa_reg = HARD_FRAME_POINTER_REGNUM;
1241 else if (XEXP (src, 0) == hard_frame_pointer_rtx
1242 && GET_CODE (XEXP (src, 1)) == CONST_INT)
1244 if (cfa_reg != (unsigned) HARD_FRAME_POINTER_REGNUM)
1246 offset = INTVAL (XEXP (src, 1));
1247 if (GET_CODE (src) == PLUS)
1249 cfa_offset += offset;
1257 if (GET_CODE (src) != PLUS
1258 || XEXP (src, 1) != stack_pointer_rtx)
1260 if (GET_CODE (XEXP (src, 0)) != REG
1261 || (unsigned) REGNO (XEXP (src, 0)) != cfa_temp_reg)
1263 if (cfa_reg != STACK_POINTER_REGNUM)
1265 cfa_store_reg = REGNO (dest);
1266 cfa_store_offset = cfa_offset - cfa_temp_value;
1271 cfa_temp_reg = REGNO (dest);
1272 cfa_temp_value = INTVAL (src);
1276 if (GET_CODE (XEXP (src, 0)) != REG
1277 || (unsigned) REGNO (XEXP (src, 0)) != cfa_temp_reg
1278 || (unsigned) REGNO (dest) != cfa_temp_reg
1279 || GET_CODE (XEXP (src, 1)) != CONST_INT)
1281 cfa_temp_value |= INTVAL (XEXP (src, 1));
1287 dwarf2out_def_cfa (label, cfa_reg, cfa_offset);
1291 /* Saving a register to the stack. Make sure dest is relative to the
1293 if (GET_CODE (src) != REG)
1295 switch (GET_CODE (XEXP (dest, 0)))
1300 offset = GET_MODE_SIZE (GET_MODE (dest));
1301 if (GET_CODE (XEXP (dest, 0)) == PRE_INC)
1304 if (REGNO (XEXP (XEXP (dest, 0), 0)) != STACK_POINTER_REGNUM
1305 || cfa_store_reg != STACK_POINTER_REGNUM)
1307 cfa_store_offset += offset;
1308 if (cfa_reg == STACK_POINTER_REGNUM)
1309 cfa_offset = cfa_store_offset;
1311 offset = -cfa_store_offset;
1314 /* With an offset. */
1317 offset = INTVAL (XEXP (XEXP (dest, 0), 1));
1318 if (GET_CODE (XEXP (dest, 0)) == MINUS)
1321 if (cfa_store_reg != (unsigned) REGNO (XEXP (XEXP (dest, 0), 0)))
1323 offset -= cfa_store_offset;
1326 /* Without an offset. */
1328 if (cfa_store_reg != (unsigned) REGNO (XEXP (dest, 0)))
1330 offset = -cfa_store_offset;
1336 dwarf2out_def_cfa (label, cfa_reg, cfa_offset);
1337 dwarf2out_reg_save (label, REGNO (src), offset);
1346 /* Record call frame debugging information for INSN, which either
1347 sets SP or FP (adjusting how we calculate the frame address) or saves a
1348 register to the stack. If INSN is NULL_RTX, initialize our state. */
1351 dwarf2out_frame_debug (insn)
1357 if (insn == NULL_RTX)
1359 /* Set up state for generating call frame debug info. */
1360 lookup_cfa (&cfa_reg, &cfa_offset);
1361 if (cfa_reg != DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM))
1363 cfa_reg = STACK_POINTER_REGNUM;
1364 cfa_store_reg = cfa_reg;
1365 cfa_store_offset = cfa_offset;
1371 if (! RTX_FRAME_RELATED_P (insn))
1373 dwarf2out_stack_adjust (insn);
1377 label = dwarf2out_cfi_label ();
1379 src = find_reg_note (insn, REG_FRAME_RELATED_EXPR, NULL_RTX);
1381 insn = XEXP (src, 0);
1383 insn = PATTERN (insn);
1385 dwarf2out_frame_debug_expr (insn, label);
1388 /* Return the size of an unsigned LEB128 quantity. */
1390 static inline unsigned long
1391 size_of_uleb128 (value)
1392 register unsigned long value;
1394 register unsigned long size = 0;
1395 register unsigned byte;
1399 byte = (value & 0x7f);
1408 /* Return the size of a signed LEB128 quantity. */
1410 static inline unsigned long
1411 size_of_sleb128 (value)
1412 register long value;
1414 register unsigned long size = 0;
1415 register unsigned byte;
1419 byte = (value & 0x7f);
1423 while (!(((value == 0) && ((byte & 0x40) == 0))
1424 || ((value == -1) && ((byte & 0x40) != 0))));
1429 /* Output an unsigned LEB128 quantity. */
1432 output_uleb128 (value)
1433 register unsigned long value;
1435 unsigned long save_value = value;
1437 fprintf (asm_out_file, "\t%s\t", ASM_BYTE_OP);
1440 register unsigned byte = (value & 0x7f);
1443 /* More bytes to follow. */
1446 fprintf (asm_out_file, "0x%x", byte);
1448 fprintf (asm_out_file, ",");
1453 fprintf (asm_out_file, "\t%s ULEB128 0x%lx", ASM_COMMENT_START, save_value);
1456 /* Output an signed LEB128 quantity. */
1459 output_sleb128 (value)
1460 register long value;
1463 register unsigned byte;
1464 long save_value = value;
1466 fprintf (asm_out_file, "\t%s\t", ASM_BYTE_OP);
1469 byte = (value & 0x7f);
1470 /* arithmetic shift */
1472 more = !((((value == 0) && ((byte & 0x40) == 0))
1473 || ((value == -1) && ((byte & 0x40) != 0))));
1477 fprintf (asm_out_file, "0x%x", byte);
1479 fprintf (asm_out_file, ",");
1484 fprintf (asm_out_file, "\t%s SLEB128 %ld", ASM_COMMENT_START, save_value);
1487 /* Output a Call Frame Information opcode and its operand(s). */
1490 output_cfi (cfi, fde)
1491 register dw_cfi_ref cfi;
1492 register dw_fde_ref fde;
1494 if (cfi->dw_cfi_opc == DW_CFA_advance_loc)
1496 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
1498 | (cfi->dw_cfi_oprnd1.dw_cfi_offset & 0x3f));
1500 fprintf (asm_out_file, "\t%s DW_CFA_advance_loc 0x%lx",
1501 ASM_COMMENT_START, cfi->dw_cfi_oprnd1.dw_cfi_offset);
1502 fputc ('\n', asm_out_file);
1505 else if (cfi->dw_cfi_opc == DW_CFA_offset)
1507 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
1509 | (cfi->dw_cfi_oprnd1.dw_cfi_reg_num & 0x3f));
1511 fprintf (asm_out_file, "\t%s DW_CFA_offset, column 0x%lx",
1512 ASM_COMMENT_START, cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
1514 fputc ('\n', asm_out_file);
1515 output_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset);
1516 fputc ('\n', asm_out_file);
1518 else if (cfi->dw_cfi_opc == DW_CFA_restore)
1520 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
1522 | (cfi->dw_cfi_oprnd1.dw_cfi_reg_num & 0x3f));
1524 fprintf (asm_out_file, "\t%s DW_CFA_restore, column 0x%lx",
1525 ASM_COMMENT_START, cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
1527 fputc ('\n', asm_out_file);
1531 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, cfi->dw_cfi_opc);
1533 fprintf (asm_out_file, "\t%s %s", ASM_COMMENT_START,
1534 dwarf_cfi_name (cfi->dw_cfi_opc));
1536 fputc ('\n', asm_out_file);
1537 switch (cfi->dw_cfi_opc)
1539 case DW_CFA_set_loc:
1540 ASM_OUTPUT_DWARF_ADDR (asm_out_file, cfi->dw_cfi_oprnd1.dw_cfi_addr);
1541 fputc ('\n', asm_out_file);
1543 case DW_CFA_advance_loc1:
1544 ASM_OUTPUT_DWARF_DELTA1 (asm_out_file,
1545 cfi->dw_cfi_oprnd1.dw_cfi_addr,
1546 fde->dw_fde_current_label);
1547 fputc ('\n', asm_out_file);
1548 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
1550 case DW_CFA_advance_loc2:
1551 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file,
1552 cfi->dw_cfi_oprnd1.dw_cfi_addr,
1553 fde->dw_fde_current_label);
1554 fputc ('\n', asm_out_file);
1555 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
1557 case DW_CFA_advance_loc4:
1558 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file,
1559 cfi->dw_cfi_oprnd1.dw_cfi_addr,
1560 fde->dw_fde_current_label);
1561 fputc ('\n', asm_out_file);
1562 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
1564 #ifdef MIPS_DEBUGGING_INFO
1565 case DW_CFA_MIPS_advance_loc8:
1566 /* TODO: not currently implemented. */
1570 case DW_CFA_offset_extended:
1571 case DW_CFA_def_cfa:
1572 output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
1573 fputc ('\n', asm_out_file);
1574 output_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset);
1575 fputc ('\n', asm_out_file);
1577 case DW_CFA_restore_extended:
1578 case DW_CFA_undefined:
1579 output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
1580 fputc ('\n', asm_out_file);
1582 case DW_CFA_same_value:
1583 case DW_CFA_def_cfa_register:
1584 output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
1585 fputc ('\n', asm_out_file);
1587 case DW_CFA_register:
1588 output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
1589 fputc ('\n', asm_out_file);
1590 output_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_reg_num);
1591 fputc ('\n', asm_out_file);
1593 case DW_CFA_def_cfa_offset:
1594 output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset);
1595 fputc ('\n', asm_out_file);
1597 case DW_CFA_GNU_window_save:
1599 case DW_CFA_GNU_args_size:
1600 output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset);
1601 fputc ('\n', asm_out_file);
1609 /* Output the call frame information used to used to record information
1610 that relates to calculating the frame pointer, and records the
1611 location of saved registers. */
1614 output_call_frame_info (for_eh)
1617 register unsigned long i;
1618 register dw_fde_ref fde;
1619 register dw_cfi_ref cfi;
1620 char l1[20], l2[20];
1621 #ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
1625 /* Do we want to include a pointer to the exception table? */
1626 int eh_ptr = for_eh && exception_table_p ();
1628 fputc ('\n', asm_out_file);
1630 /* We're going to be generating comments, so turn on app. */
1636 #ifdef EH_FRAME_SECTION
1637 EH_FRAME_SECTION ();
1639 tree label = get_file_function_name ('F');
1641 force_data_section ();
1642 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
1643 ASM_GLOBALIZE_LABEL (asm_out_file, IDENTIFIER_POINTER (label));
1644 ASM_OUTPUT_LABEL (asm_out_file, IDENTIFIER_POINTER (label));
1646 assemble_label ("__FRAME_BEGIN__");
1649 ASM_OUTPUT_SECTION (asm_out_file, FRAME_SECTION);
1651 /* Output the CIE. */
1652 ASM_GENERATE_INTERNAL_LABEL (l1, CIE_AFTER_SIZE_LABEL, for_eh);
1653 ASM_GENERATE_INTERNAL_LABEL (l2, CIE_END_LABEL, for_eh);
1654 #ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
1655 ASM_GENERATE_INTERNAL_LABEL (ld, CIE_LENGTH_LABEL, for_eh);
1657 ASM_OUTPUT_DWARF_OFFSET4 (asm_out_file, ld);
1659 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, ld);
1662 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, l2, l1);
1664 ASM_OUTPUT_DWARF_DELTA (asm_out_file, l2, l1);
1667 fprintf (asm_out_file, "\t%s Length of Common Information Entry",
1670 fputc ('\n', asm_out_file);
1671 ASM_OUTPUT_LABEL (asm_out_file, l1);
1674 /* Now that the CIE pointer is PC-relative for EH,
1675 use 0 to identify the CIE. */
1676 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0);
1678 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, DW_CIE_ID);
1681 fprintf (asm_out_file, "\t%s CIE Identifier Tag", ASM_COMMENT_START);
1683 fputc ('\n', asm_out_file);
1684 if (! for_eh && DWARF_OFFSET_SIZE == 8)
1686 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, DW_CIE_ID);
1687 fputc ('\n', asm_out_file);
1690 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_CIE_VERSION);
1692 fprintf (asm_out_file, "\t%s CIE Version", ASM_COMMENT_START);
1694 fputc ('\n', asm_out_file);
1697 /* The CIE contains a pointer to the exception region info for the
1698 frame. Make the augmentation string three bytes (including the
1699 trailing null) so the pointer is 4-byte aligned. The Solaris ld
1700 can't handle unaligned relocs. */
1703 ASM_OUTPUT_DWARF_STRING (asm_out_file, "eh");
1704 fprintf (asm_out_file, "\t%s CIE Augmentation", ASM_COMMENT_START);
1708 ASM_OUTPUT_ASCII (asm_out_file, "eh", 3);
1710 fputc ('\n', asm_out_file);
1712 ASM_OUTPUT_DWARF_ADDR (asm_out_file, "__EXCEPTION_TABLE__");
1714 fprintf (asm_out_file, "\t%s pointer to exception region info",
1719 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
1721 fprintf (asm_out_file, "\t%s CIE Augmentation (none)",
1725 fputc ('\n', asm_out_file);
1728 fprintf (asm_out_file, " (CIE Code Alignment Factor)");
1730 fputc ('\n', asm_out_file);
1731 output_sleb128 (DWARF_CIE_DATA_ALIGNMENT);
1733 fprintf (asm_out_file, " (CIE Data Alignment Factor)");
1735 fputc ('\n', asm_out_file);
1736 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DWARF_FRAME_RETURN_COLUMN);
1738 fprintf (asm_out_file, "\t%s CIE RA Column", ASM_COMMENT_START);
1740 fputc ('\n', asm_out_file);
1742 for (cfi = cie_cfi_head; cfi != NULL; cfi = cfi->dw_cfi_next)
1743 output_cfi (cfi, NULL);
1745 /* Pad the CIE out to an address sized boundary. */
1746 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
1747 ASM_OUTPUT_LABEL (asm_out_file, l2);
1748 #ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
1749 ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL (asm_out_file, ld, l2, l1);
1751 fprintf (asm_out_file, "\t%s CIE Length Symbol", ASM_COMMENT_START);
1752 fputc ('\n', asm_out_file);
1755 /* Loop through all of the FDE's. */
1756 for (i = 0; i < fde_table_in_use; ++i)
1758 fde = &fde_table[i];
1760 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_AFTER_SIZE_LABEL, for_eh + i*2);
1761 ASM_GENERATE_INTERNAL_LABEL (l2, FDE_END_LABEL, for_eh + i*2);
1762 #ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
1763 ASM_GENERATE_INTERNAL_LABEL (ld, FDE_LENGTH_LABEL, for_eh + i*2);
1765 ASM_OUTPUT_DWARF_OFFSET4 (asm_out_file, ld);
1767 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, ld);
1770 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, l2, l1);
1772 ASM_OUTPUT_DWARF_DELTA (asm_out_file, l2, l1);
1775 fprintf (asm_out_file, "\t%s FDE Length", ASM_COMMENT_START);
1776 fputc ('\n', asm_out_file);
1777 ASM_OUTPUT_LABEL (asm_out_file, l1);
1779 /* ??? This always emits a 4 byte offset when for_eh is true, but it
1780 emits a target dependent sized offset when for_eh is not true.
1781 This inconsistency may confuse gdb. The only case where we need a
1782 non-4 byte offset is for the Irix6 N64 ABI, so we may lose SGI
1783 compatibility if we emit a 4 byte offset. We need a 4 byte offset
1784 though in order to be compatible with the dwarf_fde struct in frame.c.
1785 If the for_eh case is changed, then the struct in frame.c has
1786 to be adjusted appropriately. */
1788 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, l1, "__FRAME_BEGIN__");
1790 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, stripattributes (FRAME_SECTION));
1792 fprintf (asm_out_file, "\t%s FDE CIE offset", ASM_COMMENT_START);
1794 fputc ('\n', asm_out_file);
1795 ASM_OUTPUT_DWARF_ADDR (asm_out_file, fde->dw_fde_begin);
1797 fprintf (asm_out_file, "\t%s FDE initial location", ASM_COMMENT_START);
1799 fputc ('\n', asm_out_file);
1800 ASM_OUTPUT_DWARF_ADDR_DELTA (asm_out_file,
1801 fde->dw_fde_end, fde->dw_fde_begin);
1803 fprintf (asm_out_file, "\t%s FDE address range", ASM_COMMENT_START);
1805 fputc ('\n', asm_out_file);
1807 /* Loop through the Call Frame Instructions associated with
1809 fde->dw_fde_current_label = fde->dw_fde_begin;
1810 for (cfi = fde->dw_fde_cfi; cfi != NULL; cfi = cfi->dw_cfi_next)
1811 output_cfi (cfi, fde);
1813 /* Pad the FDE out to an address sized boundary. */
1814 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
1815 ASM_OUTPUT_LABEL (asm_out_file, l2);
1816 #ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
1817 ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL (asm_out_file, ld, l2, l1);
1819 fprintf (asm_out_file, "\t%s FDE Length Symbol", ASM_COMMENT_START);
1820 fputc ('\n', asm_out_file);
1823 #ifndef EH_FRAME_SECTION
1826 /* Emit terminating zero for table. */
1827 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0);
1828 fputc ('\n', asm_out_file);
1831 #ifdef MIPS_DEBUGGING_INFO
1832 /* Work around Irix 6 assembler bug whereby labels at the end of a section
1833 get a value of 0. Putting .align 0 after the label fixes it. */
1834 ASM_OUTPUT_ALIGN (asm_out_file, 0);
1837 /* Turn off app to make assembly quicker. */
1842 /* Output a marker (i.e. a label) for the beginning of a function, before
1846 dwarf2out_begin_prologue ()
1848 char label[MAX_ARTIFICIAL_LABEL_BYTES];
1849 register dw_fde_ref fde;
1851 ++current_funcdef_number;
1853 function_section (current_function_decl);
1854 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_BEGIN_LABEL,
1855 current_funcdef_number);
1856 ASM_OUTPUT_LABEL (asm_out_file, label);
1858 /* Expand the fde table if necessary. */
1859 if (fde_table_in_use == fde_table_allocated)
1861 fde_table_allocated += FDE_TABLE_INCREMENT;
1863 = (dw_fde_ref) xrealloc (fde_table,
1864 fde_table_allocated * sizeof (dw_fde_node));
1867 /* Record the FDE associated with this function. */
1868 current_funcdef_fde = fde_table_in_use;
1870 /* Add the new FDE at the end of the fde_table. */
1871 fde = &fde_table[fde_table_in_use++];
1872 fde->dw_fde_begin = xstrdup (label);
1873 fde->dw_fde_current_label = NULL;
1874 fde->dw_fde_end = NULL;
1875 fde->dw_fde_cfi = NULL;
1877 args_size = old_args_size = 0;
1880 /* Output a marker (i.e. a label) for the absolute end of the generated code
1881 for a function definition. This gets called *after* the epilogue code has
1885 dwarf2out_end_epilogue ()
1888 char label[MAX_ARTIFICIAL_LABEL_BYTES];
1890 /* Output a label to mark the endpoint of the code generated for this
1892 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL, current_funcdef_number);
1893 ASM_OUTPUT_LABEL (asm_out_file, label);
1894 fde = &fde_table[fde_table_in_use - 1];
1895 fde->dw_fde_end = xstrdup (label);
1899 dwarf2out_frame_init ()
1901 /* Allocate the initial hunk of the fde_table. */
1902 fde_table = (dw_fde_ref) xcalloc (FDE_TABLE_INCREMENT, sizeof (dw_fde_node));
1903 fde_table_allocated = FDE_TABLE_INCREMENT;
1904 fde_table_in_use = 0;
1906 /* Generate the CFA instructions common to all FDE's. Do it now for the
1907 sake of lookup_cfa. */
1909 #ifdef DWARF2_UNWIND_INFO
1910 /* On entry, the Canonical Frame Address is at SP. */
1911 dwarf2out_def_cfa (NULL, STACK_POINTER_REGNUM, INCOMING_FRAME_SP_OFFSET);
1912 initial_return_save (INCOMING_RETURN_ADDR_RTX);
1917 dwarf2out_frame_finish ()
1919 /* Output call frame information. */
1920 #ifdef MIPS_DEBUGGING_INFO
1921 if (write_symbols == DWARF2_DEBUG)
1922 output_call_frame_info (0);
1923 if (flag_unwind_tables || (flag_exceptions && ! exceptions_via_longjmp))
1924 output_call_frame_info (1);
1926 if (write_symbols == DWARF2_DEBUG
1927 || flag_unwind_tables || (flag_exceptions && ! exceptions_via_longjmp))
1928 output_call_frame_info (1);
1932 #endif /* .debug_frame support */
1934 /* And now, the support for symbolic debugging information. */
1935 #ifdef DWARF2_DEBUGGING_INFO
1937 /* NOTE: In the comments in this file, many references are made to
1938 "Debugging Information Entries". This term is abbreviated as `DIE'
1939 throughout the remainder of this file. */
1941 /* An internal representation of the DWARF output is built, and then
1942 walked to generate the DWARF debugging info. The walk of the internal
1943 representation is done after the entire program has been compiled.
1944 The types below are used to describe the internal representation. */
1946 /* Each DIE may have a series of attribute/value pairs. Values
1947 can take on several forms. The forms that are used in this
1948 implementation are listed below. */
1955 dw_val_class_unsigned_const,
1956 dw_val_class_long_long,
1959 dw_val_class_die_ref,
1960 dw_val_class_fde_ref,
1961 dw_val_class_lbl_id,
1962 dw_val_class_lbl_offset,
1967 /* Various DIE's use offsets relative to the beginning of the
1968 .debug_info section to refer to each other. */
1970 typedef long int dw_offset;
1972 /* Define typedefs here to avoid circular dependencies. */
1974 typedef struct die_struct *dw_die_ref;
1975 typedef struct dw_attr_struct *dw_attr_ref;
1976 typedef struct dw_val_struct *dw_val_ref;
1977 typedef struct dw_line_info_struct *dw_line_info_ref;
1978 typedef struct dw_separate_line_info_struct *dw_separate_line_info_ref;
1979 typedef struct dw_loc_descr_struct *dw_loc_descr_ref;
1980 typedef struct pubname_struct *pubname_ref;
1981 typedef dw_die_ref *arange_ref;
1983 /* Describe a double word constant value. */
1985 typedef struct dw_long_long_struct
1992 /* Describe a floating point constant value. */
1994 typedef struct dw_fp_struct
2001 /* Each entry in the line_info_table maintains the file and
2002 line number associated with the label generated for that
2003 entry. The label gives the PC value associated with
2004 the line number entry. */
2006 typedef struct dw_line_info_struct
2008 unsigned long dw_file_num;
2009 unsigned long dw_line_num;
2013 /* Line information for functions in separate sections; each one gets its
2015 typedef struct dw_separate_line_info_struct
2017 unsigned long dw_file_num;
2018 unsigned long dw_line_num;
2019 unsigned long function;
2021 dw_separate_line_info_entry;
2023 /* The dw_val_node describes an attribute's value, as it is
2024 represented internally. */
2026 typedef struct dw_val_struct
2028 dw_val_class val_class;
2032 dw_loc_descr_ref val_loc;
2034 long unsigned val_unsigned;
2035 dw_long_long_const val_long_long;
2036 dw_float_const val_float;
2037 dw_die_ref val_die_ref;
2038 unsigned val_fde_index;
2041 unsigned char val_flag;
2047 /* Locations in memory are described using a sequence of stack machine
2050 typedef struct dw_loc_descr_struct
2052 dw_loc_descr_ref dw_loc_next;
2053 enum dwarf_location_atom dw_loc_opc;
2054 dw_val_node dw_loc_oprnd1;
2055 dw_val_node dw_loc_oprnd2;
2059 /* Each DIE attribute has a field specifying the attribute kind,
2060 a link to the next attribute in the chain, and an attribute value.
2061 Attributes are typically linked below the DIE they modify. */
2063 typedef struct dw_attr_struct
2065 enum dwarf_attribute dw_attr;
2066 dw_attr_ref dw_attr_next;
2067 dw_val_node dw_attr_val;
2071 /* The Debugging Information Entry (DIE) structure */
2073 typedef struct die_struct
2075 enum dwarf_tag die_tag;
2076 dw_attr_ref die_attr;
2077 dw_die_ref die_parent;
2078 dw_die_ref die_child;
2080 dw_offset die_offset;
2081 unsigned long die_abbrev;
2085 /* The pubname structure */
2087 typedef struct pubname_struct
2094 /* The limbo die list structure. */
2095 typedef struct limbo_die_struct
2098 struct limbo_die_struct *next;
2102 /* How to start an assembler comment. */
2103 #ifndef ASM_COMMENT_START
2104 #define ASM_COMMENT_START ";#"
2107 /* Define a macro which returns non-zero for a TYPE_DECL which was
2108 implicitly generated for a tagged type.
2110 Note that unlike the gcc front end (which generates a NULL named
2111 TYPE_DECL node for each complete tagged type, each array type, and
2112 each function type node created) the g++ front end generates a
2113 _named_ TYPE_DECL node for each tagged type node created.
2114 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
2115 generate a DW_TAG_typedef DIE for them. */
2117 #define TYPE_DECL_IS_STUB(decl) \
2118 (DECL_NAME (decl) == NULL_TREE \
2119 || (DECL_ARTIFICIAL (decl) \
2120 && is_tagged_type (TREE_TYPE (decl)) \
2121 && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \
2122 /* This is necessary for stub decls that \
2123 appear in nested inline functions. */ \
2124 || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
2125 && (decl_ultimate_origin (decl) \
2126 == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
2128 /* Information concerning the compilation unit's programming
2129 language, and compiler version. */
2131 extern int flag_traditional;
2132 extern char *version_string;
2134 /* Fixed size portion of the DWARF compilation unit header. */
2135 #define DWARF_COMPILE_UNIT_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 3)
2137 /* Fixed size portion of debugging line information prolog. */
2138 #define DWARF_LINE_PROLOG_HEADER_SIZE 5
2140 /* Fixed size portion of public names info. */
2141 #define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
2143 /* Fixed size portion of the address range info. */
2144 #define DWARF_ARANGES_HEADER_SIZE \
2145 (DWARF_ROUND (2 * DWARF_OFFSET_SIZE + 4, PTR_SIZE * 2) - DWARF_OFFSET_SIZE)
2147 /* The default is to have gcc emit the line number tables. */
2148 #ifndef DWARF2_ASM_LINE_DEBUG_INFO
2149 #define DWARF2_ASM_LINE_DEBUG_INFO 0
2152 /* Define the architecture-dependent minimum instruction length (in bytes).
2153 In this implementation of DWARF, this field is used for information
2154 purposes only. Since GCC generates assembly language, we have
2155 no a priori knowledge of how many instruction bytes are generated
2156 for each source line, and therefore can use only the DW_LNE_set_address
2157 and DW_LNS_fixed_advance_pc line information commands. */
2159 #ifndef DWARF_LINE_MIN_INSTR_LENGTH
2160 #define DWARF_LINE_MIN_INSTR_LENGTH 4
2163 /* Minimum line offset in a special line info. opcode.
2164 This value was chosen to give a reasonable range of values. */
2165 #define DWARF_LINE_BASE -10
2167 /* First special line opcde - leave room for the standard opcodes. */
2168 #define DWARF_LINE_OPCODE_BASE 10
2170 /* Range of line offsets in a special line info. opcode. */
2171 #define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1)
2173 /* Flag that indicates the initial value of the is_stmt_start flag.
2174 In the present implementation, we do not mark any lines as
2175 the beginning of a source statement, because that information
2176 is not made available by the GCC front-end. */
2177 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
2179 /* This location is used by calc_die_sizes() to keep track
2180 the offset of each DIE within the .debug_info section. */
2181 static unsigned long next_die_offset;
2183 /* Record the root of the DIE's built for the current compilation unit. */
2184 static dw_die_ref comp_unit_die;
2186 /* A list of DIEs with a NULL parent waiting to be relocated. */
2187 static limbo_die_node *limbo_die_list = 0;
2189 /* Pointer to an array of filenames referenced by this compilation unit. */
2190 static char **file_table;
2192 /* Total number of entries in the table (i.e. array) pointed to by
2193 `file_table'. This is the *total* and includes both used and unused
2195 static unsigned file_table_allocated;
2197 /* Number of entries in the file_table which are actually in use. */
2198 static unsigned file_table_in_use;
2200 /* Size (in elements) of increments by which we may expand the filename
2202 #define FILE_TABLE_INCREMENT 64
2204 /* Local pointer to the name of the main input file. Initialized in
2206 static char *primary_filename;
2208 /* For Dwarf output, we must assign lexical-blocks id numbers in the order in
2209 which their beginnings are encountered. We output Dwarf debugging info
2210 that refers to the beginnings and ends of the ranges of code for each
2211 lexical block. The labels themselves are generated in final.c, which
2212 assigns numbers to the blocks in the same way. */
2213 static unsigned next_block_number = 2;
2215 /* A pointer to the base of a table of references to DIE's that describe
2216 declarations. The table is indexed by DECL_UID() which is a unique
2217 number identifying each decl. */
2218 static dw_die_ref *decl_die_table;
2220 /* Number of elements currently allocated for the decl_die_table. */
2221 static unsigned decl_die_table_allocated;
2223 /* Number of elements in decl_die_table currently in use. */
2224 static unsigned decl_die_table_in_use;
2226 /* Size (in elements) of increments by which we may expand the
2228 #define DECL_DIE_TABLE_INCREMENT 256
2230 /* A pointer to the base of a table of references to declaration
2231 scopes. This table is a display which tracks the nesting
2232 of declaration scopes at the current scope and containing
2233 scopes. This table is used to find the proper place to
2234 define type declaration DIE's. */
2235 static tree *decl_scope_table;
2237 /* Number of elements currently allocated for the decl_scope_table. */
2238 static int decl_scope_table_allocated;
2240 /* Current level of nesting of declaration scopes. */
2241 static int decl_scope_depth;
2243 /* Size (in elements) of increments by which we may expand the
2244 decl_scope_table. */
2245 #define DECL_SCOPE_TABLE_INCREMENT 64
2247 /* A pointer to the base of a list of references to DIE's that
2248 are uniquely identified by their tag, presence/absence of
2249 children DIE's, and list of attribute/value pairs. */
2250 static dw_die_ref *abbrev_die_table;
2252 /* Number of elements currently allocated for abbrev_die_table. */
2253 static unsigned abbrev_die_table_allocated;
2255 /* Number of elements in type_die_table currently in use. */
2256 static unsigned abbrev_die_table_in_use;
2258 /* Size (in elements) of increments by which we may expand the
2259 abbrev_die_table. */
2260 #define ABBREV_DIE_TABLE_INCREMENT 256
2262 /* A pointer to the base of a table that contains line information
2263 for each source code line in .text in the compilation unit. */
2264 static dw_line_info_ref line_info_table;
2266 /* Number of elements currently allocated for line_info_table. */
2267 static unsigned line_info_table_allocated;
2269 /* Number of elements in separate_line_info_table currently in use. */
2270 static unsigned separate_line_info_table_in_use;
2272 /* A pointer to the base of a table that contains line information
2273 for each source code line outside of .text in the compilation unit. */
2274 static dw_separate_line_info_ref separate_line_info_table;
2276 /* Number of elements currently allocated for separate_line_info_table. */
2277 static unsigned separate_line_info_table_allocated;
2279 /* Number of elements in line_info_table currently in use. */
2280 static unsigned line_info_table_in_use;
2282 /* Size (in elements) of increments by which we may expand the
2284 #define LINE_INFO_TABLE_INCREMENT 1024
2286 /* A pointer to the base of a table that contains a list of publicly
2287 accessible names. */
2288 static pubname_ref pubname_table;
2290 /* Number of elements currently allocated for pubname_table. */
2291 static unsigned pubname_table_allocated;
2293 /* Number of elements in pubname_table currently in use. */
2294 static unsigned pubname_table_in_use;
2296 /* Size (in elements) of increments by which we may expand the
2298 #define PUBNAME_TABLE_INCREMENT 64
2300 /* A pointer to the base of a table that contains a list of publicly
2301 accessible names. */
2302 static arange_ref arange_table;
2304 /* Number of elements currently allocated for arange_table. */
2305 static unsigned arange_table_allocated;
2307 /* Number of elements in arange_table currently in use. */
2308 static unsigned arange_table_in_use;
2310 /* Size (in elements) of increments by which we may expand the
2312 #define ARANGE_TABLE_INCREMENT 64
2314 /* A pointer to the base of a list of incomplete types which might be
2315 completed at some later time. */
2317 static tree *incomplete_types_list;
2319 /* Number of elements currently allocated for the incomplete_types_list. */
2320 static unsigned incomplete_types_allocated;
2322 /* Number of elements of incomplete_types_list currently in use. */
2323 static unsigned incomplete_types;
2325 /* Size (in elements) of increments by which we may expand the incomplete
2326 types list. Actually, a single hunk of space of this size should
2327 be enough for most typical programs. */
2328 #define INCOMPLETE_TYPES_INCREMENT 64
2330 /* Record whether the function being analyzed contains inlined functions. */
2331 static int current_function_has_inlines;
2332 #if 0 && defined (MIPS_DEBUGGING_INFO)
2333 static int comp_unit_has_inlines;
2336 /* Forward declarations for functions defined in this file. */
2338 static void addr_const_to_string PROTO((dyn_string_t, rtx));
2339 static char *addr_to_string PROTO((rtx));
2340 static int is_pseudo_reg PROTO((rtx));
2341 static tree type_main_variant PROTO((tree));
2342 static int is_tagged_type PROTO((tree));
2343 static const char *dwarf_tag_name PROTO((unsigned));
2344 static const char *dwarf_attr_name PROTO((unsigned));
2345 static const char *dwarf_form_name PROTO((unsigned));
2346 static const char *dwarf_stack_op_name PROTO((unsigned));
2348 static const char *dwarf_type_encoding_name PROTO((unsigned));
2350 static tree decl_ultimate_origin PROTO((tree));
2351 static tree block_ultimate_origin PROTO((tree));
2352 static tree decl_class_context PROTO((tree));
2353 static void add_dwarf_attr PROTO((dw_die_ref, dw_attr_ref));
2354 static void add_AT_flag PROTO((dw_die_ref,
2355 enum dwarf_attribute,
2357 static void add_AT_int PROTO((dw_die_ref,
2358 enum dwarf_attribute, long));
2359 static void add_AT_unsigned PROTO((dw_die_ref,
2360 enum dwarf_attribute,
2362 static void add_AT_long_long PROTO((dw_die_ref,
2363 enum dwarf_attribute,
2364 unsigned long, unsigned long));
2365 static void add_AT_float PROTO((dw_die_ref,
2366 enum dwarf_attribute,
2368 static void add_AT_string PROTO((dw_die_ref,
2369 enum dwarf_attribute,
2371 static void add_AT_die_ref PROTO((dw_die_ref,
2372 enum dwarf_attribute,
2374 static void add_AT_fde_ref PROTO((dw_die_ref,
2375 enum dwarf_attribute,
2377 static void add_AT_loc PROTO((dw_die_ref,
2378 enum dwarf_attribute,
2380 static void add_AT_addr PROTO((dw_die_ref,
2381 enum dwarf_attribute, char *));
2382 static void add_AT_lbl_id PROTO((dw_die_ref,
2383 enum dwarf_attribute, char *));
2384 static void add_AT_lbl_offset PROTO((dw_die_ref,
2385 enum dwarf_attribute, char *));
2386 static dw_attr_ref get_AT PROTO((dw_die_ref,
2387 enum dwarf_attribute));
2388 static const char *get_AT_low_pc PROTO((dw_die_ref));
2389 static const char *get_AT_hi_pc PROTO((dw_die_ref));
2390 static const char *get_AT_string PROTO((dw_die_ref,
2391 enum dwarf_attribute));
2392 static int get_AT_flag PROTO((dw_die_ref,
2393 enum dwarf_attribute));
2394 static unsigned get_AT_unsigned PROTO((dw_die_ref,
2395 enum dwarf_attribute));
2396 static int is_c_family PROTO((void));
2397 static int is_fortran PROTO((void));
2398 static void remove_AT PROTO((dw_die_ref,
2399 enum dwarf_attribute));
2400 static void remove_children PROTO((dw_die_ref));
2401 static void add_child_die PROTO((dw_die_ref, dw_die_ref));
2402 static dw_die_ref new_die PROTO((enum dwarf_tag, dw_die_ref));
2403 static dw_die_ref lookup_type_die PROTO((tree));
2404 static void equate_type_number_to_die PROTO((tree, dw_die_ref));
2405 static dw_die_ref lookup_decl_die PROTO((tree));
2406 static void equate_decl_number_to_die PROTO((tree, dw_die_ref));
2407 static dw_loc_descr_ref new_loc_descr PROTO((enum dwarf_location_atom,
2408 unsigned long, unsigned long));
2409 static void add_loc_descr PROTO((dw_loc_descr_ref *,
2411 static void print_spaces PROTO((FILE *));
2412 static void print_die PROTO((dw_die_ref, FILE *));
2413 static void print_dwarf_line_table PROTO((FILE *));
2414 static void add_sibling_attributes PROTO((dw_die_ref));
2415 static void build_abbrev_table PROTO((dw_die_ref));
2416 static unsigned long size_of_string PROTO((const char *));
2417 static unsigned long size_of_loc_descr PROTO((dw_loc_descr_ref));
2418 static unsigned long size_of_locs PROTO((dw_loc_descr_ref));
2419 static int constant_size PROTO((long unsigned));
2420 static unsigned long size_of_die PROTO((dw_die_ref));
2421 static void calc_die_sizes PROTO((dw_die_ref));
2422 static unsigned long size_of_line_prolog PROTO((void));
2423 static unsigned long size_of_pubnames PROTO((void));
2424 static unsigned long size_of_aranges PROTO((void));
2425 static enum dwarf_form value_format PROTO((dw_attr_ref));
2426 static void output_value_format PROTO((dw_attr_ref));
2427 static void output_abbrev_section PROTO((void));
2428 static void output_loc_operands PROTO((dw_loc_descr_ref));
2429 static void output_die PROTO((dw_die_ref));
2430 static void output_compilation_unit_header PROTO((void));
2431 static const char *dwarf2_name PROTO((tree, int));
2432 static void add_pubname PROTO((tree, dw_die_ref));
2433 static void output_pubnames PROTO((void));
2434 static void add_arange PROTO((tree, dw_die_ref));
2435 static void output_aranges PROTO((void));
2436 static void output_line_info PROTO((void));
2437 static int is_body_block PROTO((tree));
2438 static dw_die_ref base_type_die PROTO((tree));
2439 static tree root_type PROTO((tree));
2440 static int is_base_type PROTO((tree));
2441 static dw_die_ref modified_type_die PROTO((tree, int, int, dw_die_ref));
2442 static int type_is_enum PROTO((tree));
2443 static dw_loc_descr_ref reg_loc_descriptor PROTO((rtx));
2444 static dw_loc_descr_ref based_loc_descr PROTO((unsigned, long));
2445 static int is_based_loc PROTO((rtx));
2446 static dw_loc_descr_ref mem_loc_descriptor PROTO((rtx, enum machine_mode mode));
2447 static dw_loc_descr_ref concat_loc_descriptor PROTO((rtx, rtx));
2448 static dw_loc_descr_ref loc_descriptor PROTO((rtx));
2449 static unsigned ceiling PROTO((unsigned, unsigned));
2450 static tree field_type PROTO((tree));
2451 static unsigned simple_type_align_in_bits PROTO((tree));
2452 static unsigned simple_type_size_in_bits PROTO((tree));
2453 static unsigned field_byte_offset PROTO((tree));
2454 static void add_AT_location_description PROTO((dw_die_ref,
2455 enum dwarf_attribute, rtx));
2456 static void add_data_member_location_attribute PROTO((dw_die_ref, tree));
2457 static void add_const_value_attribute PROTO((dw_die_ref, rtx));
2458 static void add_location_or_const_value_attribute PROTO((dw_die_ref, tree));
2459 static void add_name_attribute PROTO((dw_die_ref, const char *));
2460 static void add_bound_info PROTO((dw_die_ref,
2461 enum dwarf_attribute, tree));
2462 static void add_subscript_info PROTO((dw_die_ref, tree));
2463 static void add_byte_size_attribute PROTO((dw_die_ref, tree));
2464 static void add_bit_offset_attribute PROTO((dw_die_ref, tree));
2465 static void add_bit_size_attribute PROTO((dw_die_ref, tree));
2466 static void add_prototyped_attribute PROTO((dw_die_ref, tree));
2467 static void add_abstract_origin_attribute PROTO((dw_die_ref, tree));
2468 static void add_pure_or_virtual_attribute PROTO((dw_die_ref, tree));
2469 static void add_src_coords_attributes PROTO((dw_die_ref, tree));
2470 static void add_name_and_src_coords_attributes PROTO((dw_die_ref, tree));
2471 static void push_decl_scope PROTO((tree));
2472 static dw_die_ref scope_die_for PROTO((tree, dw_die_ref));
2473 static void pop_decl_scope PROTO((void));
2474 static void add_type_attribute PROTO((dw_die_ref, tree, int, int,
2476 static char *type_tag PROTO((tree));
2477 static tree member_declared_type PROTO((tree));
2479 static char *decl_start_label PROTO((tree));
2481 static void gen_array_type_die PROTO((tree, dw_die_ref));
2482 static void gen_set_type_die PROTO((tree, dw_die_ref));
2484 static void gen_entry_point_die PROTO((tree, dw_die_ref));
2486 static void gen_inlined_enumeration_type_die PROTO((tree, dw_die_ref));
2487 static void gen_inlined_structure_type_die PROTO((tree, dw_die_ref));
2488 static void gen_inlined_union_type_die PROTO((tree, dw_die_ref));
2489 static void gen_enumeration_type_die PROTO((tree, dw_die_ref));
2490 static dw_die_ref gen_formal_parameter_die PROTO((tree, dw_die_ref));
2491 static void gen_unspecified_parameters_die PROTO((tree, dw_die_ref));
2492 static void gen_formal_types_die PROTO((tree, dw_die_ref));
2493 static void gen_subprogram_die PROTO((tree, dw_die_ref));
2494 static void gen_variable_die PROTO((tree, dw_die_ref));
2495 static void gen_label_die PROTO((tree, dw_die_ref));
2496 static void gen_lexical_block_die PROTO((tree, dw_die_ref, int));
2497 static void gen_inlined_subroutine_die PROTO((tree, dw_die_ref, int));
2498 static void gen_field_die PROTO((tree, dw_die_ref));
2499 static void gen_ptr_to_mbr_type_die PROTO((tree, dw_die_ref));
2500 static dw_die_ref gen_compile_unit_die PROTO((const char *));
2501 static void gen_string_type_die PROTO((tree, dw_die_ref));
2502 static void gen_inheritance_die PROTO((tree, dw_die_ref));
2503 static void gen_member_die PROTO((tree, dw_die_ref));
2504 static void gen_struct_or_union_type_die PROTO((tree, dw_die_ref));
2505 static void gen_subroutine_type_die PROTO((tree, dw_die_ref));
2506 static void gen_typedef_die PROTO((tree, dw_die_ref));
2507 static void gen_type_die PROTO((tree, dw_die_ref));
2508 static void gen_tagged_type_instantiation_die PROTO((tree, dw_die_ref));
2509 static void gen_block_die PROTO((tree, dw_die_ref, int));
2510 static void decls_for_scope PROTO((tree, dw_die_ref, int));
2511 static int is_redundant_typedef PROTO((tree));
2512 static void gen_decl_die PROTO((tree, dw_die_ref));
2513 static unsigned lookup_filename PROTO((const char *));
2514 static void add_incomplete_type PROTO((tree));
2515 static void retry_incomplete_types PROTO((void));
2516 static void gen_type_die_for_member PROTO((tree, tree, dw_die_ref));
2517 static void gen_abstract_function PROTO((tree));
2519 /* Section names used to hold DWARF debugging information. */
2520 #ifndef DEBUG_INFO_SECTION
2521 #define DEBUG_INFO_SECTION ".debug_info"
2523 #ifndef ABBREV_SECTION
2524 #define ABBREV_SECTION ".debug_abbrev"
2526 #ifndef ARANGES_SECTION
2527 #define ARANGES_SECTION ".debug_aranges"
2529 #ifndef DW_MACINFO_SECTION
2530 #define DW_MACINFO_SECTION ".debug_macinfo"
2532 #ifndef DEBUG_LINE_SECTION
2533 #define DEBUG_LINE_SECTION ".debug_line"
2536 #define LOC_SECTION ".debug_loc"
2538 #ifndef PUBNAMES_SECTION
2539 #define PUBNAMES_SECTION ".debug_pubnames"
2542 #define STR_SECTION ".debug_str"
2545 /* Standard ELF section names for compiled code and data. */
2546 #ifndef TEXT_SECTION
2547 #define TEXT_SECTION ".text"
2549 #ifndef DATA_SECTION
2550 #define DATA_SECTION ".data"
2553 #define BSS_SECTION ".bss"
2556 /* Labels we insert at beginning sections we can reference instead of
2557 the section names themselves. */
2559 #ifndef TEXT_SECTION_LABEL
2560 #define TEXT_SECTION_LABEL "Ltext"
2562 #ifndef DEBUG_LINE_SECTION_LABEL
2563 #define DEBUG_LINE_SECTION_LABEL "Ldebug_line"
2565 #ifndef DEBUG_INFO_SECTION_LABEL
2566 #define DEBUG_INFO_SECTION_LABEL "Ldebug_info"
2568 #ifndef ABBREV_SECTION_LABEL
2569 #define ABBREV_SECTION_LABEL "Ldebug_abbrev"
2573 /* Definitions of defaults for formats and names of various special
2574 (artificial) labels which may be generated within this file (when the -g
2575 options is used and DWARF_DEBUGGING_INFO is in effect.
2576 If necessary, these may be overridden from within the tm.h file, but
2577 typically, overriding these defaults is unnecessary. */
2579 static char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
2580 static char text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
2581 static char abbrev_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
2582 static char debug_info_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
2583 static char debug_line_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
2585 #ifndef TEXT_END_LABEL
2586 #define TEXT_END_LABEL "Letext"
2588 #ifndef DATA_END_LABEL
2589 #define DATA_END_LABEL "Ledata"
2591 #ifndef BSS_END_LABEL
2592 #define BSS_END_LABEL "Lebss"
2594 #ifndef INSN_LABEL_FMT
2595 #define INSN_LABEL_FMT "LI%u_"
2597 #ifndef BLOCK_BEGIN_LABEL
2598 #define BLOCK_BEGIN_LABEL "LBB"
2600 #ifndef BLOCK_END_LABEL
2601 #define BLOCK_END_LABEL "LBE"
2603 #ifndef BODY_BEGIN_LABEL
2604 #define BODY_BEGIN_LABEL "Lbb"
2606 #ifndef BODY_END_LABEL
2607 #define BODY_END_LABEL "Lbe"
2609 #ifndef LINE_CODE_LABEL
2610 #define LINE_CODE_LABEL "LM"
2612 #ifndef SEPARATE_LINE_CODE_LABEL
2613 #define SEPARATE_LINE_CODE_LABEL "LSM"
2616 /* Convert a reference to the assembler name of a C-level name. This
2617 macro has the same effect as ASM_OUTPUT_LABELREF, but copies to
2618 a string rather than writing to a file. */
2619 #ifndef ASM_NAME_TO_STRING
2620 #define ASM_NAME_TO_STRING(STR, NAME) \
2622 if ((NAME)[0] == '*') \
2623 dyn_string_append (STR, NAME + 1); \
2626 const char *newstr; \
2627 STRIP_NAME_ENCODING (newstr, NAME); \
2628 dyn_string_append (STR, user_label_prefix); \
2629 dyn_string_append (STR, newstr); \
2635 /* We allow a language front-end to designate a function that is to be
2636 called to "demangle" any name before it it put into a DIE. */
2638 static const char *(*demangle_name_func) PROTO((const char *));
2641 dwarf2out_set_demangle_name_func (func)
2642 const char *(*func) PROTO((const char *));
2644 demangle_name_func = func;
2647 /* Convert an integer constant expression into assembler syntax. Addition
2648 and subtraction are the only arithmetic that may appear in these
2649 expressions. This is an adaptation of output_addr_const in final.c.
2650 Here, the target of the conversion is a string buffer. We can't use
2651 output_addr_const directly, because it writes to a file. */
2654 addr_const_to_string (str, x)
2661 switch (GET_CODE (x))
2665 dyn_string_append (str, ",");
2671 ASM_NAME_TO_STRING (str, XSTR (x, 0));
2675 ASM_GENERATE_INTERNAL_LABEL (buf1, "L", CODE_LABEL_NUMBER (XEXP (x, 0)));
2676 ASM_NAME_TO_STRING (str, buf1);
2680 ASM_GENERATE_INTERNAL_LABEL (buf1, "L", CODE_LABEL_NUMBER (x));
2681 ASM_NAME_TO_STRING (str, buf1);
2685 sprintf (buf1, HOST_WIDE_INT_PRINT_DEC, INTVAL (x));
2686 dyn_string_append (str, buf1);
2690 /* This used to output parentheses around the expression, but that does
2691 not work on the 386 (either ATT or BSD assembler). */
2692 addr_const_to_string (str, XEXP (x, 0));
2696 if (GET_MODE (x) == VOIDmode)
2698 /* We can use %d if the number is one word and positive. */
2699 if (CONST_DOUBLE_HIGH (x))
2700 sprintf (buf1, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
2701 CONST_DOUBLE_HIGH (x), CONST_DOUBLE_LOW (x));
2702 else if (CONST_DOUBLE_LOW (x) < 0)
2703 sprintf (buf1, HOST_WIDE_INT_PRINT_HEX, CONST_DOUBLE_LOW (x));
2705 sprintf (buf1, HOST_WIDE_INT_PRINT_DEC,
2706 CONST_DOUBLE_LOW (x));
2707 dyn_string_append (str, buf1);
2710 /* We can't handle floating point constants; PRINT_OPERAND must
2712 output_operand_lossage ("floating constant misused");
2716 /* Some assemblers need integer constants to appear last (eg masm). */
2717 if (GET_CODE (XEXP (x, 0)) == CONST_INT)
2719 addr_const_to_string (str, XEXP (x, 1));
2720 if (INTVAL (XEXP (x, 0)) >= 0)
2721 dyn_string_append (str, "+");
2723 addr_const_to_string (str, XEXP (x, 0));
2727 addr_const_to_string (str, XEXP (x, 0));
2728 if (INTVAL (XEXP (x, 1)) >= 0)
2729 dyn_string_append (str, "+");
2731 addr_const_to_string (str, XEXP (x, 1));
2736 /* Avoid outputting things like x-x or x+5-x, since some assemblers
2737 can't handle that. */
2738 x = simplify_subtraction (x);
2739 if (GET_CODE (x) != MINUS)
2742 addr_const_to_string (str, XEXP (x, 0));
2743 dyn_string_append (str, "-");
2744 if (GET_CODE (XEXP (x, 1)) == CONST_INT
2745 && INTVAL (XEXP (x, 1)) < 0)
2747 dyn_string_append (str, ASM_OPEN_PAREN);
2748 addr_const_to_string (str, XEXP (x, 1));
2749 dyn_string_append (str, ASM_CLOSE_PAREN);
2752 addr_const_to_string (str, XEXP (x, 1));
2757 addr_const_to_string (str, XEXP (x, 0));
2761 output_operand_lossage ("invalid expression as operand");
2765 /* Convert an address constant to a string, and return a pointer to
2766 a copy of the result, located on the heap. */
2772 dyn_string_t ds = dyn_string_new (256);
2775 addr_const_to_string (ds, x);
2777 /* Return the dynamically allocated string, but free the
2778 dyn_string_t itself. */
2784 /* Test if rtl node points to a pseudo register. */
2790 return (((GET_CODE (rtl) == REG) && (REGNO (rtl) >= FIRST_PSEUDO_REGISTER))
2791 || ((GET_CODE (rtl) == SUBREG)
2792 && (REGNO (XEXP (rtl, 0)) >= FIRST_PSEUDO_REGISTER)));
2795 /* Return a reference to a type, with its const and volatile qualifiers
2799 type_main_variant (type)
2802 type = TYPE_MAIN_VARIANT (type);
2804 /* There really should be only one main variant among any group of variants
2805 of a given type (and all of the MAIN_VARIANT values for all members of
2806 the group should point to that one type) but sometimes the C front-end
2807 messes this up for array types, so we work around that bug here. */
2809 if (TREE_CODE (type) == ARRAY_TYPE)
2810 while (type != TYPE_MAIN_VARIANT (type))
2811 type = TYPE_MAIN_VARIANT (type);
2816 /* Return non-zero if the given type node represents a tagged type. */
2819 is_tagged_type (type)
2822 register enum tree_code code = TREE_CODE (type);
2824 return (code == RECORD_TYPE || code == UNION_TYPE
2825 || code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE);
2828 /* Convert a DIE tag into its string name. */
2831 dwarf_tag_name (tag)
2832 register unsigned tag;
2836 case DW_TAG_padding:
2837 return "DW_TAG_padding";
2838 case DW_TAG_array_type:
2839 return "DW_TAG_array_type";
2840 case DW_TAG_class_type:
2841 return "DW_TAG_class_type";
2842 case DW_TAG_entry_point:
2843 return "DW_TAG_entry_point";
2844 case DW_TAG_enumeration_type:
2845 return "DW_TAG_enumeration_type";
2846 case DW_TAG_formal_parameter:
2847 return "DW_TAG_formal_parameter";
2848 case DW_TAG_imported_declaration:
2849 return "DW_TAG_imported_declaration";
2851 return "DW_TAG_label";
2852 case DW_TAG_lexical_block:
2853 return "DW_TAG_lexical_block";
2855 return "DW_TAG_member";
2856 case DW_TAG_pointer_type:
2857 return "DW_TAG_pointer_type";
2858 case DW_TAG_reference_type:
2859 return "DW_TAG_reference_type";
2860 case DW_TAG_compile_unit:
2861 return "DW_TAG_compile_unit";
2862 case DW_TAG_string_type:
2863 return "DW_TAG_string_type";
2864 case DW_TAG_structure_type:
2865 return "DW_TAG_structure_type";
2866 case DW_TAG_subroutine_type:
2867 return "DW_TAG_subroutine_type";
2868 case DW_TAG_typedef:
2869 return "DW_TAG_typedef";
2870 case DW_TAG_union_type:
2871 return "DW_TAG_union_type";
2872 case DW_TAG_unspecified_parameters:
2873 return "DW_TAG_unspecified_parameters";
2874 case DW_TAG_variant:
2875 return "DW_TAG_variant";
2876 case DW_TAG_common_block:
2877 return "DW_TAG_common_block";
2878 case DW_TAG_common_inclusion:
2879 return "DW_TAG_common_inclusion";
2880 case DW_TAG_inheritance:
2881 return "DW_TAG_inheritance";
2882 case DW_TAG_inlined_subroutine:
2883 return "DW_TAG_inlined_subroutine";
2885 return "DW_TAG_module";
2886 case DW_TAG_ptr_to_member_type:
2887 return "DW_TAG_ptr_to_member_type";
2888 case DW_TAG_set_type:
2889 return "DW_TAG_set_type";
2890 case DW_TAG_subrange_type:
2891 return "DW_TAG_subrange_type";
2892 case DW_TAG_with_stmt:
2893 return "DW_TAG_with_stmt";
2894 case DW_TAG_access_declaration:
2895 return "DW_TAG_access_declaration";
2896 case DW_TAG_base_type:
2897 return "DW_TAG_base_type";
2898 case DW_TAG_catch_block:
2899 return "DW_TAG_catch_block";
2900 case DW_TAG_const_type:
2901 return "DW_TAG_const_type";
2902 case DW_TAG_constant:
2903 return "DW_TAG_constant";
2904 case DW_TAG_enumerator:
2905 return "DW_TAG_enumerator";
2906 case DW_TAG_file_type:
2907 return "DW_TAG_file_type";
2909 return "DW_TAG_friend";
2910 case DW_TAG_namelist:
2911 return "DW_TAG_namelist";
2912 case DW_TAG_namelist_item:
2913 return "DW_TAG_namelist_item";
2914 case DW_TAG_packed_type:
2915 return "DW_TAG_packed_type";
2916 case DW_TAG_subprogram:
2917 return "DW_TAG_subprogram";
2918 case DW_TAG_template_type_param:
2919 return "DW_TAG_template_type_param";
2920 case DW_TAG_template_value_param:
2921 return "DW_TAG_template_value_param";
2922 case DW_TAG_thrown_type:
2923 return "DW_TAG_thrown_type";
2924 case DW_TAG_try_block:
2925 return "DW_TAG_try_block";
2926 case DW_TAG_variant_part:
2927 return "DW_TAG_variant_part";
2928 case DW_TAG_variable:
2929 return "DW_TAG_variable";
2930 case DW_TAG_volatile_type:
2931 return "DW_TAG_volatile_type";
2932 case DW_TAG_MIPS_loop:
2933 return "DW_TAG_MIPS_loop";
2934 case DW_TAG_format_label:
2935 return "DW_TAG_format_label";
2936 case DW_TAG_function_template:
2937 return "DW_TAG_function_template";
2938 case DW_TAG_class_template:
2939 return "DW_TAG_class_template";
2941 return "DW_TAG_<unknown>";
2945 /* Convert a DWARF attribute code into its string name. */
2948 dwarf_attr_name (attr)
2949 register unsigned attr;
2954 return "DW_AT_sibling";
2955 case DW_AT_location:
2956 return "DW_AT_location";
2958 return "DW_AT_name";
2959 case DW_AT_ordering:
2960 return "DW_AT_ordering";
2961 case DW_AT_subscr_data:
2962 return "DW_AT_subscr_data";
2963 case DW_AT_byte_size:
2964 return "DW_AT_byte_size";
2965 case DW_AT_bit_offset:
2966 return "DW_AT_bit_offset";
2967 case DW_AT_bit_size:
2968 return "DW_AT_bit_size";
2969 case DW_AT_element_list:
2970 return "DW_AT_element_list";
2971 case DW_AT_stmt_list:
2972 return "DW_AT_stmt_list";
2974 return "DW_AT_low_pc";
2976 return "DW_AT_high_pc";
2977 case DW_AT_language:
2978 return "DW_AT_language";
2980 return "DW_AT_member";
2982 return "DW_AT_discr";
2983 case DW_AT_discr_value:
2984 return "DW_AT_discr_value";
2985 case DW_AT_visibility:
2986 return "DW_AT_visibility";
2988 return "DW_AT_import";
2989 case DW_AT_string_length:
2990 return "DW_AT_string_length";
2991 case DW_AT_common_reference:
2992 return "DW_AT_common_reference";
2993 case DW_AT_comp_dir:
2994 return "DW_AT_comp_dir";
2995 case DW_AT_const_value:
2996 return "DW_AT_const_value";
2997 case DW_AT_containing_type:
2998 return "DW_AT_containing_type";
2999 case DW_AT_default_value:
3000 return "DW_AT_default_value";
3002 return "DW_AT_inline";
3003 case DW_AT_is_optional:
3004 return "DW_AT_is_optional";
3005 case DW_AT_lower_bound:
3006 return "DW_AT_lower_bound";
3007 case DW_AT_producer:
3008 return "DW_AT_producer";
3009 case DW_AT_prototyped:
3010 return "DW_AT_prototyped";
3011 case DW_AT_return_addr:
3012 return "DW_AT_return_addr";
3013 case DW_AT_start_scope:
3014 return "DW_AT_start_scope";
3015 case DW_AT_stride_size:
3016 return "DW_AT_stride_size";
3017 case DW_AT_upper_bound:
3018 return "DW_AT_upper_bound";
3019 case DW_AT_abstract_origin:
3020 return "DW_AT_abstract_origin";
3021 case DW_AT_accessibility:
3022 return "DW_AT_accessibility";
3023 case DW_AT_address_class:
3024 return "DW_AT_address_class";
3025 case DW_AT_artificial:
3026 return "DW_AT_artificial";
3027 case DW_AT_base_types:
3028 return "DW_AT_base_types";
3029 case DW_AT_calling_convention:
3030 return "DW_AT_calling_convention";
3032 return "DW_AT_count";
3033 case DW_AT_data_member_location:
3034 return "DW_AT_data_member_location";
3035 case DW_AT_decl_column:
3036 return "DW_AT_decl_column";
3037 case DW_AT_decl_file:
3038 return "DW_AT_decl_file";
3039 case DW_AT_decl_line:
3040 return "DW_AT_decl_line";
3041 case DW_AT_declaration:
3042 return "DW_AT_declaration";
3043 case DW_AT_discr_list:
3044 return "DW_AT_discr_list";
3045 case DW_AT_encoding:
3046 return "DW_AT_encoding";
3047 case DW_AT_external:
3048 return "DW_AT_external";
3049 case DW_AT_frame_base:
3050 return "DW_AT_frame_base";
3052 return "DW_AT_friend";
3053 case DW_AT_identifier_case:
3054 return "DW_AT_identifier_case";
3055 case DW_AT_macro_info:
3056 return "DW_AT_macro_info";
3057 case DW_AT_namelist_items:
3058 return "DW_AT_namelist_items";
3059 case DW_AT_priority:
3060 return "DW_AT_priority";
3062 return "DW_AT_segment";
3063 case DW_AT_specification:
3064 return "DW_AT_specification";
3065 case DW_AT_static_link:
3066 return "DW_AT_static_link";
3068 return "DW_AT_type";
3069 case DW_AT_use_location:
3070 return "DW_AT_use_location";
3071 case DW_AT_variable_parameter:
3072 return "DW_AT_variable_parameter";
3073 case DW_AT_virtuality:
3074 return "DW_AT_virtuality";
3075 case DW_AT_vtable_elem_location:
3076 return "DW_AT_vtable_elem_location";
3078 case DW_AT_MIPS_fde:
3079 return "DW_AT_MIPS_fde";
3080 case DW_AT_MIPS_loop_begin:
3081 return "DW_AT_MIPS_loop_begin";
3082 case DW_AT_MIPS_tail_loop_begin:
3083 return "DW_AT_MIPS_tail_loop_begin";
3084 case DW_AT_MIPS_epilog_begin:
3085 return "DW_AT_MIPS_epilog_begin";
3086 case DW_AT_MIPS_loop_unroll_factor:
3087 return "DW_AT_MIPS_loop_unroll_factor";
3088 case DW_AT_MIPS_software_pipeline_depth:
3089 return "DW_AT_MIPS_software_pipeline_depth";
3090 case DW_AT_MIPS_linkage_name:
3091 return "DW_AT_MIPS_linkage_name";
3092 case DW_AT_MIPS_stride:
3093 return "DW_AT_MIPS_stride";
3094 case DW_AT_MIPS_abstract_name:
3095 return "DW_AT_MIPS_abstract_name";
3096 case DW_AT_MIPS_clone_origin:
3097 return "DW_AT_MIPS_clone_origin";
3098 case DW_AT_MIPS_has_inlines:
3099 return "DW_AT_MIPS_has_inlines";
3101 case DW_AT_sf_names:
3102 return "DW_AT_sf_names";
3103 case DW_AT_src_info:
3104 return "DW_AT_src_info";
3105 case DW_AT_mac_info:
3106 return "DW_AT_mac_info";
3107 case DW_AT_src_coords:
3108 return "DW_AT_src_coords";
3109 case DW_AT_body_begin:
3110 return "DW_AT_body_begin";
3111 case DW_AT_body_end:
3112 return "DW_AT_body_end";
3114 return "DW_AT_<unknown>";
3118 /* Convert a DWARF value form code into its string name. */
3121 dwarf_form_name (form)
3122 register unsigned form;
3127 return "DW_FORM_addr";
3128 case DW_FORM_block2:
3129 return "DW_FORM_block2";
3130 case DW_FORM_block4:
3131 return "DW_FORM_block4";
3133 return "DW_FORM_data2";
3135 return "DW_FORM_data4";
3137 return "DW_FORM_data8";
3138 case DW_FORM_string:
3139 return "DW_FORM_string";
3141 return "DW_FORM_block";
3142 case DW_FORM_block1:
3143 return "DW_FORM_block1";
3145 return "DW_FORM_data1";
3147 return "DW_FORM_flag";
3149 return "DW_FORM_sdata";
3151 return "DW_FORM_strp";
3153 return "DW_FORM_udata";
3154 case DW_FORM_ref_addr:
3155 return "DW_FORM_ref_addr";
3157 return "DW_FORM_ref1";
3159 return "DW_FORM_ref2";
3161 return "DW_FORM_ref4";
3163 return "DW_FORM_ref8";
3164 case DW_FORM_ref_udata:
3165 return "DW_FORM_ref_udata";
3166 case DW_FORM_indirect:
3167 return "DW_FORM_indirect";
3169 return "DW_FORM_<unknown>";
3173 /* Convert a DWARF stack opcode into its string name. */
3176 dwarf_stack_op_name (op)
3177 register unsigned op;
3182 return "DW_OP_addr";
3184 return "DW_OP_deref";
3186 return "DW_OP_const1u";
3188 return "DW_OP_const1s";
3190 return "DW_OP_const2u";
3192 return "DW_OP_const2s";
3194 return "DW_OP_const4u";
3196 return "DW_OP_const4s";
3198 return "DW_OP_const8u";
3200 return "DW_OP_const8s";
3202 return "DW_OP_constu";
3204 return "DW_OP_consts";
3208 return "DW_OP_drop";
3210 return "DW_OP_over";
3212 return "DW_OP_pick";
3214 return "DW_OP_swap";
3218 return "DW_OP_xderef";
3226 return "DW_OP_minus";
3238 return "DW_OP_plus";
3239 case DW_OP_plus_uconst:
3240 return "DW_OP_plus_uconst";
3246 return "DW_OP_shra";
3264 return "DW_OP_skip";
3266 return "DW_OP_lit0";
3268 return "DW_OP_lit1";
3270 return "DW_OP_lit2";
3272 return "DW_OP_lit3";
3274 return "DW_OP_lit4";
3276 return "DW_OP_lit5";
3278 return "DW_OP_lit6";
3280 return "DW_OP_lit7";
3282 return "DW_OP_lit8";
3284 return "DW_OP_lit9";
3286 return "DW_OP_lit10";
3288 return "DW_OP_lit11";
3290 return "DW_OP_lit12";
3292 return "DW_OP_lit13";
3294 return "DW_OP_lit14";
3296 return "DW_OP_lit15";
3298 return "DW_OP_lit16";
3300 return "DW_OP_lit17";
3302 return "DW_OP_lit18";
3304 return "DW_OP_lit19";
3306 return "DW_OP_lit20";
3308 return "DW_OP_lit21";
3310 return "DW_OP_lit22";
3312 return "DW_OP_lit23";
3314 return "DW_OP_lit24";
3316 return "DW_OP_lit25";
3318 return "DW_OP_lit26";
3320 return "DW_OP_lit27";
3322 return "DW_OP_lit28";
3324 return "DW_OP_lit29";
3326 return "DW_OP_lit30";
3328 return "DW_OP_lit31";
3330 return "DW_OP_reg0";
3332 return "DW_OP_reg1";
3334 return "DW_OP_reg2";
3336 return "DW_OP_reg3";
3338 return "DW_OP_reg4";
3340 return "DW_OP_reg5";
3342 return "DW_OP_reg6";
3344 return "DW_OP_reg7";
3346 return "DW_OP_reg8";
3348 return "DW_OP_reg9";
3350 return "DW_OP_reg10";
3352 return "DW_OP_reg11";
3354 return "DW_OP_reg12";
3356 return "DW_OP_reg13";
3358 return "DW_OP_reg14";
3360 return "DW_OP_reg15";
3362 return "DW_OP_reg16";
3364 return "DW_OP_reg17";
3366 return "DW_OP_reg18";
3368 return "DW_OP_reg19";
3370 return "DW_OP_reg20";
3372 return "DW_OP_reg21";
3374 return "DW_OP_reg22";
3376 return "DW_OP_reg23";
3378 return "DW_OP_reg24";
3380 return "DW_OP_reg25";
3382 return "DW_OP_reg26";
3384 return "DW_OP_reg27";
3386 return "DW_OP_reg28";
3388 return "DW_OP_reg29";
3390 return "DW_OP_reg30";
3392 return "DW_OP_reg31";
3394 return "DW_OP_breg0";
3396 return "DW_OP_breg1";
3398 return "DW_OP_breg2";
3400 return "DW_OP_breg3";
3402 return "DW_OP_breg4";
3404 return "DW_OP_breg5";
3406 return "DW_OP_breg6";
3408 return "DW_OP_breg7";
3410 return "DW_OP_breg8";
3412 return "DW_OP_breg9";
3414 return "DW_OP_breg10";
3416 return "DW_OP_breg11";
3418 return "DW_OP_breg12";
3420 return "DW_OP_breg13";
3422 return "DW_OP_breg14";
3424 return "DW_OP_breg15";
3426 return "DW_OP_breg16";
3428 return "DW_OP_breg17";
3430 return "DW_OP_breg18";
3432 return "DW_OP_breg19";
3434 return "DW_OP_breg20";
3436 return "DW_OP_breg21";
3438 return "DW_OP_breg22";
3440 return "DW_OP_breg23";
3442 return "DW_OP_breg24";
3444 return "DW_OP_breg25";
3446 return "DW_OP_breg26";
3448 return "DW_OP_breg27";
3450 return "DW_OP_breg28";
3452 return "DW_OP_breg29";
3454 return "DW_OP_breg30";
3456 return "DW_OP_breg31";
3458 return "DW_OP_regx";
3460 return "DW_OP_fbreg";
3462 return "DW_OP_bregx";
3464 return "DW_OP_piece";
3465 case DW_OP_deref_size:
3466 return "DW_OP_deref_size";
3467 case DW_OP_xderef_size:
3468 return "DW_OP_xderef_size";
3472 return "OP_<unknown>";
3476 /* Convert a DWARF type code into its string name. */
3480 dwarf_type_encoding_name (enc)
3481 register unsigned enc;
3485 case DW_ATE_address:
3486 return "DW_ATE_address";
3487 case DW_ATE_boolean:
3488 return "DW_ATE_boolean";
3489 case DW_ATE_complex_float:
3490 return "DW_ATE_complex_float";
3492 return "DW_ATE_float";
3494 return "DW_ATE_signed";
3495 case DW_ATE_signed_char:
3496 return "DW_ATE_signed_char";
3497 case DW_ATE_unsigned:
3498 return "DW_ATE_unsigned";
3499 case DW_ATE_unsigned_char:
3500 return "DW_ATE_unsigned_char";
3502 return "DW_ATE_<unknown>";
3507 /* Determine the "ultimate origin" of a decl. The decl may be an inlined
3508 instance of an inlined instance of a decl which is local to an inline
3509 function, so we have to trace all of the way back through the origin chain
3510 to find out what sort of node actually served as the original seed for the
3514 decl_ultimate_origin (decl)
3517 /* output_inline_function sets DECL_ABSTRACT_ORIGIN for all the
3518 nodes in the function to point to themselves; ignore that if
3519 we're trying to output the abstract instance of this function. */
3520 if (DECL_ABSTRACT (decl) && DECL_ABSTRACT_ORIGIN (decl) == decl)
3523 #ifdef ENABLE_CHECKING
3524 if (DECL_FROM_INLINE (DECL_ORIGIN (decl)))
3525 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
3526 most distant ancestor, this should never happen. */
3530 return DECL_ABSTRACT_ORIGIN (decl);
3533 /* Determine the "ultimate origin" of a block. The block may be an inlined
3534 instance of an inlined instance of a block which is local to an inline
3535 function, so we have to trace all of the way back through the origin chain
3536 to find out what sort of node actually served as the original seed for the
3540 block_ultimate_origin (block)
3541 register tree block;
3543 register tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block);
3545 /* output_inline_function sets BLOCK_ABSTRACT_ORIGIN for all the
3546 nodes in the function to point to themselves; ignore that if
3547 we're trying to output the abstract instance of this function. */
3548 if (BLOCK_ABSTRACT (block) && immediate_origin == block)
3551 if (immediate_origin == NULL_TREE)
3555 register tree ret_val;
3556 register tree lookahead = immediate_origin;
3560 ret_val = lookahead;
3561 lookahead = (TREE_CODE (ret_val) == BLOCK)
3562 ? BLOCK_ABSTRACT_ORIGIN (ret_val)
3565 while (lookahead != NULL && lookahead != ret_val);
3571 /* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT
3572 of a virtual function may refer to a base class, so we check the 'this'
3576 decl_class_context (decl)
3579 tree context = NULL_TREE;
3581 if (TREE_CODE (decl) != FUNCTION_DECL || ! DECL_VINDEX (decl))
3582 context = DECL_CONTEXT (decl);
3584 context = TYPE_MAIN_VARIANT
3585 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
3587 if (context && TREE_CODE_CLASS (TREE_CODE (context)) != 't')
3588 context = NULL_TREE;
3593 /* Add an attribute/value pair to a DIE. We build the lists up in reverse
3594 addition order, and correct that in add_sibling_attributes. */
3597 add_dwarf_attr (die, attr)
3598 register dw_die_ref die;
3599 register dw_attr_ref attr;
3601 if (die != NULL && attr != NULL)
3603 attr->dw_attr_next = die->die_attr;
3604 die->die_attr = attr;
3608 static inline dw_val_class
3612 return a->dw_attr_val.val_class;
3615 /* Add a flag value attribute to a DIE. */
3618 add_AT_flag (die, attr_kind, flag)
3619 register dw_die_ref die;
3620 register enum dwarf_attribute attr_kind;
3621 register unsigned flag;
3623 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3625 attr->dw_attr_next = NULL;
3626 attr->dw_attr = attr_kind;
3627 attr->dw_attr_val.val_class = dw_val_class_flag;
3628 attr->dw_attr_val.v.val_flag = flag;
3629 add_dwarf_attr (die, attr);
3632 static inline unsigned
3634 register dw_attr_ref a;
3636 if (a && AT_class (a) == dw_val_class_flag)
3637 return a->dw_attr_val.v.val_flag;
3642 /* Add a signed integer attribute value to a DIE. */
3645 add_AT_int (die, attr_kind, int_val)
3646 register dw_die_ref die;
3647 register enum dwarf_attribute attr_kind;
3648 register long int int_val;
3650 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3652 attr->dw_attr_next = NULL;
3653 attr->dw_attr = attr_kind;
3654 attr->dw_attr_val.val_class = dw_val_class_const;
3655 attr->dw_attr_val.v.val_int = int_val;
3656 add_dwarf_attr (die, attr);
3659 static inline long int
3661 register dw_attr_ref a;
3663 if (a && AT_class (a) == dw_val_class_const)
3664 return a->dw_attr_val.v.val_int;
3669 /* Add an unsigned integer attribute value to a DIE. */
3672 add_AT_unsigned (die, attr_kind, unsigned_val)
3673 register dw_die_ref die;
3674 register enum dwarf_attribute attr_kind;
3675 register unsigned long unsigned_val;
3677 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3679 attr->dw_attr_next = NULL;
3680 attr->dw_attr = attr_kind;
3681 attr->dw_attr_val.val_class = dw_val_class_unsigned_const;
3682 attr->dw_attr_val.v.val_unsigned = unsigned_val;
3683 add_dwarf_attr (die, attr);
3686 static inline unsigned long
3688 register dw_attr_ref a;
3690 if (a && AT_class (a) == dw_val_class_unsigned_const)
3691 return a->dw_attr_val.v.val_unsigned;
3696 /* Add an unsigned double integer attribute value to a DIE. */
3699 add_AT_long_long (die, attr_kind, val_hi, val_low)
3700 register dw_die_ref die;
3701 register enum dwarf_attribute attr_kind;
3702 register unsigned long val_hi;
3703 register unsigned long val_low;
3705 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3707 attr->dw_attr_next = NULL;
3708 attr->dw_attr = attr_kind;
3709 attr->dw_attr_val.val_class = dw_val_class_long_long;
3710 attr->dw_attr_val.v.val_long_long.hi = val_hi;
3711 attr->dw_attr_val.v.val_long_long.low = val_low;
3712 add_dwarf_attr (die, attr);
3715 /* Add a floating point attribute value to a DIE and return it. */
3718 add_AT_float (die, attr_kind, length, array)
3719 register dw_die_ref die;
3720 register enum dwarf_attribute attr_kind;
3721 register unsigned length;
3722 register long *array;
3724 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3726 attr->dw_attr_next = NULL;
3727 attr->dw_attr = attr_kind;
3728 attr->dw_attr_val.val_class = dw_val_class_float;
3729 attr->dw_attr_val.v.val_float.length = length;
3730 attr->dw_attr_val.v.val_float.array = array;
3731 add_dwarf_attr (die, attr);
3734 /* Add a string attribute value to a DIE. */
3737 add_AT_string (die, attr_kind, str)
3738 register dw_die_ref die;
3739 register enum dwarf_attribute attr_kind;
3740 register const char *str;
3742 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3744 attr->dw_attr_next = NULL;
3745 attr->dw_attr = attr_kind;
3746 attr->dw_attr_val.val_class = dw_val_class_str;
3747 attr->dw_attr_val.v.val_str = xstrdup (str);
3748 add_dwarf_attr (die, attr);
3751 static inline const char *
3753 register dw_attr_ref a;
3755 if (a && AT_class (a) == dw_val_class_str)
3756 return a->dw_attr_val.v.val_str;
3761 /* Add a DIE reference attribute value to a DIE. */
3764 add_AT_die_ref (die, attr_kind, targ_die)
3765 register dw_die_ref die;
3766 register enum dwarf_attribute attr_kind;
3767 register dw_die_ref targ_die;
3769 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3771 attr->dw_attr_next = NULL;
3772 attr->dw_attr = attr_kind;
3773 attr->dw_attr_val.val_class = dw_val_class_die_ref;
3774 attr->dw_attr_val.v.val_die_ref = targ_die;
3775 add_dwarf_attr (die, attr);
3778 static inline dw_die_ref
3780 register dw_attr_ref a;
3782 if (a && AT_class (a) == dw_val_class_die_ref)
3783 return a->dw_attr_val.v.val_die_ref;
3788 /* Add an FDE reference attribute value to a DIE. */
3791 add_AT_fde_ref (die, attr_kind, targ_fde)
3792 register dw_die_ref die;
3793 register enum dwarf_attribute attr_kind;
3794 register unsigned targ_fde;
3796 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3798 attr->dw_attr_next = NULL;
3799 attr->dw_attr = attr_kind;
3800 attr->dw_attr_val.val_class = dw_val_class_fde_ref;
3801 attr->dw_attr_val.v.val_fde_index = targ_fde;
3802 add_dwarf_attr (die, attr);
3805 /* Add a location description attribute value to a DIE. */
3808 add_AT_loc (die, attr_kind, loc)
3809 register dw_die_ref die;
3810 register enum dwarf_attribute attr_kind;
3811 register dw_loc_descr_ref loc;
3813 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3815 attr->dw_attr_next = NULL;
3816 attr->dw_attr = attr_kind;
3817 attr->dw_attr_val.val_class = dw_val_class_loc;
3818 attr->dw_attr_val.v.val_loc = loc;
3819 add_dwarf_attr (die, attr);
3822 static inline dw_loc_descr_ref
3824 register dw_attr_ref a;
3826 if (a && AT_class (a) == dw_val_class_loc)
3827 return a->dw_attr_val.v.val_loc;
3832 /* Add an address constant attribute value to a DIE. */
3835 add_AT_addr (die, attr_kind, addr)
3836 register dw_die_ref die;
3837 register enum dwarf_attribute attr_kind;
3840 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3842 attr->dw_attr_next = NULL;
3843 attr->dw_attr = attr_kind;
3844 attr->dw_attr_val.val_class = dw_val_class_addr;
3845 attr->dw_attr_val.v.val_addr = addr;
3846 add_dwarf_attr (die, attr);
3849 static inline const char *
3851 register dw_attr_ref a;
3853 if (a && AT_class (a) == dw_val_class_addr)
3854 return a->dw_attr_val.v.val_addr;
3859 /* Add a label identifier attribute value to a DIE. */
3862 add_AT_lbl_id (die, attr_kind, lbl_id)
3863 register dw_die_ref die;
3864 register enum dwarf_attribute attr_kind;
3865 register char *lbl_id;
3867 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3869 attr->dw_attr_next = NULL;
3870 attr->dw_attr = attr_kind;
3871 attr->dw_attr_val.val_class = dw_val_class_lbl_id;
3872 attr->dw_attr_val.v.val_lbl_id = xstrdup (lbl_id);
3873 add_dwarf_attr (die, attr);
3876 /* Add a section offset attribute value to a DIE. */
3879 add_AT_lbl_offset (die, attr_kind, label)
3880 register dw_die_ref die;
3881 register enum dwarf_attribute attr_kind;
3882 register char *label;
3884 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3886 attr->dw_attr_next = NULL;
3887 attr->dw_attr = attr_kind;
3888 attr->dw_attr_val.val_class = dw_val_class_lbl_offset;
3889 attr->dw_attr_val.v.val_lbl_id = xstrdup (label);
3890 add_dwarf_attr (die, attr);
3894 static inline const char *
3896 register dw_attr_ref a;
3898 if (a && (AT_class (a) == dw_val_class_lbl_id
3899 || AT_class (a) == dw_val_class_lbl_offset))
3900 return a->dw_attr_val.v.val_lbl_id;
3905 /* Get the attribute of type attr_kind. */
3907 static inline dw_attr_ref
3908 get_AT (die, attr_kind)
3909 register dw_die_ref die;
3910 register enum dwarf_attribute attr_kind;
3912 register dw_attr_ref a;
3913 register dw_die_ref spec = NULL;
3917 for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
3919 if (a->dw_attr == attr_kind)
3922 if (a->dw_attr == DW_AT_specification
3923 || a->dw_attr == DW_AT_abstract_origin)
3928 return get_AT (spec, attr_kind);
3934 /* Return the "low pc" attribute value, typically associated with
3935 a subprogram DIE. Return null if the "low pc" attribute is
3936 either not prsent, or if it cannot be represented as an
3937 assembler label identifier. */
3939 static inline const char *
3941 register dw_die_ref die;
3943 register dw_attr_ref a = get_AT (die, DW_AT_low_pc);
3947 /* Return the "high pc" attribute value, typically associated with
3948 a subprogram DIE. Return null if the "high pc" attribute is
3949 either not prsent, or if it cannot be represented as an
3950 assembler label identifier. */
3952 static inline const char *
3954 register dw_die_ref die;
3956 register dw_attr_ref a = get_AT (die, DW_AT_high_pc);
3960 /* Return the value of the string attribute designated by ATTR_KIND, or
3961 NULL if it is not present. */
3963 static inline const char *
3964 get_AT_string (die, attr_kind)
3965 register dw_die_ref die;
3966 register enum dwarf_attribute attr_kind;
3968 register dw_attr_ref a = get_AT (die, attr_kind);
3969 return AT_string (a);
3972 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
3973 if it is not present. */
3976 get_AT_flag (die, attr_kind)
3977 register dw_die_ref die;
3978 register enum dwarf_attribute attr_kind;
3980 register dw_attr_ref a = get_AT (die, attr_kind);
3984 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
3985 if it is not present. */
3987 static inline unsigned
3988 get_AT_unsigned (die, attr_kind)
3989 register dw_die_ref die;
3990 register enum dwarf_attribute attr_kind;
3992 register dw_attr_ref a = get_AT (die, attr_kind);
3993 return AT_unsigned (a);
3996 static inline dw_die_ref
3997 get_AT_ref (die, attr_kind)
3999 register enum dwarf_attribute attr_kind;
4001 register dw_attr_ref a = get_AT (die, attr_kind);
4008 register unsigned lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
4010 return (lang == DW_LANG_C || lang == DW_LANG_C89
4011 || lang == DW_LANG_C_plus_plus);
4017 register unsigned lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
4019 return (lang == DW_LANG_Fortran77 || lang == DW_LANG_Fortran90);
4022 /* Free up the memory used by A. */
4028 switch (AT_class (a))
4030 case dw_val_class_addr:
4031 case dw_val_class_str:
4032 case dw_val_class_lbl_id:
4033 case dw_val_class_lbl_offset:
4034 free (a->dw_attr_val.v.val_str);
4044 /* Remove the specified attribute if present. */
4047 remove_AT (die, attr_kind)
4048 register dw_die_ref die;
4049 register enum dwarf_attribute attr_kind;
4051 register dw_attr_ref *p;
4052 register dw_attr_ref removed = NULL;
4056 for (p = &(die->die_attr); *p; p = &((*p)->dw_attr_next))
4057 if ((*p)->dw_attr == attr_kind)
4060 *p = (*p)->dw_attr_next;
4069 /* Free up the memory used by DIE. */
4075 remove_children (die);
4079 /* Discard the children of this DIE. */
4082 remove_children (die)
4083 register dw_die_ref die;
4085 register dw_die_ref child_die = die->die_child;
4087 die->die_child = NULL;
4089 while (child_die != NULL)
4091 register dw_die_ref tmp_die = child_die;
4092 register dw_attr_ref a;
4094 child_die = child_die->die_sib;
4096 for (a = tmp_die->die_attr; a != NULL; )
4098 register dw_attr_ref tmp_a = a;
4100 a = a->dw_attr_next;
4108 /* Add a child DIE below its parent. We build the lists up in reverse
4109 addition order, and correct that in add_sibling_attributes. */
4112 add_child_die (die, child_die)
4113 register dw_die_ref die;
4114 register dw_die_ref child_die;
4116 if (die != NULL && child_die != NULL)
4118 if (die == child_die)
4120 child_die->die_parent = die;
4121 child_die->die_sib = die->die_child;
4122 die->die_child = child_die;
4126 /* Move CHILD, which must be a child of PARENT or the DIE for which PARENT
4127 is the specification, to the front of PARENT's list of children. */
4130 splice_child_die (parent, child)
4131 dw_die_ref parent, child;
4135 /* We want the declaration DIE from inside the class, not the
4136 specification DIE at toplevel. */
4137 if (child->die_parent != parent)
4139 dw_die_ref tmp = get_AT_ref (child, DW_AT_specification);
4144 if (child->die_parent != parent
4145 && child->die_parent != get_AT_ref (parent, DW_AT_specification))
4148 for (p = &(parent->die_child); *p; p = &((*p)->die_sib))
4151 *p = child->die_sib;
4155 child->die_sib = parent->die_child;
4156 parent->die_child = child;
4159 /* Return a pointer to a newly created DIE node. */
4161 static inline dw_die_ref
4162 new_die (tag_value, parent_die)
4163 register enum dwarf_tag tag_value;
4164 register dw_die_ref parent_die;
4166 register dw_die_ref die = (dw_die_ref) xmalloc (sizeof (die_node));
4168 die->die_tag = tag_value;
4169 die->die_abbrev = 0;
4170 die->die_offset = 0;
4171 die->die_child = NULL;
4172 die->die_parent = NULL;
4173 die->die_sib = NULL;
4174 die->die_attr = NULL;
4176 if (parent_die != NULL)
4177 add_child_die (parent_die, die);
4180 limbo_die_node *limbo_node;
4182 limbo_node = (limbo_die_node *) xmalloc (sizeof (limbo_die_node));
4183 limbo_node->die = die;
4184 limbo_node->next = limbo_die_list;
4185 limbo_die_list = limbo_node;
4191 /* Return the DIE associated with the given type specifier. */
4193 static inline dw_die_ref
4194 lookup_type_die (type)
4197 return (dw_die_ref) TYPE_SYMTAB_POINTER (type);
4200 /* Equate a DIE to a given type specifier. */
4203 equate_type_number_to_die (type, type_die)
4205 register dw_die_ref type_die;
4207 TYPE_SYMTAB_POINTER (type) = (char *) type_die;
4210 /* Return the DIE associated with a given declaration. */
4212 static inline dw_die_ref
4213 lookup_decl_die (decl)
4216 register unsigned decl_id = DECL_UID (decl);
4218 return (decl_id < decl_die_table_in_use
4219 ? decl_die_table[decl_id] : NULL);
4222 /* Equate a DIE to a particular declaration. */
4225 equate_decl_number_to_die (decl, decl_die)
4227 register dw_die_ref decl_die;
4229 register unsigned decl_id = DECL_UID (decl);
4230 register unsigned num_allocated;
4232 if (decl_id >= decl_die_table_allocated)
4235 = ((decl_id + 1 + DECL_DIE_TABLE_INCREMENT - 1)
4236 / DECL_DIE_TABLE_INCREMENT)
4237 * DECL_DIE_TABLE_INCREMENT;
4240 = (dw_die_ref *) xrealloc (decl_die_table,
4241 sizeof (dw_die_ref) * num_allocated);
4243 bzero ((char *) &decl_die_table[decl_die_table_allocated],
4244 (num_allocated - decl_die_table_allocated) * sizeof (dw_die_ref));
4245 decl_die_table_allocated = num_allocated;
4248 if (decl_id >= decl_die_table_in_use)
4249 decl_die_table_in_use = (decl_id + 1);
4251 decl_die_table[decl_id] = decl_die;
4254 /* Return a pointer to a newly allocated location description. Location
4255 descriptions are simple expression terms that can be strung
4256 together to form more complicated location (address) descriptions. */
4258 static inline dw_loc_descr_ref
4259 new_loc_descr (op, oprnd1, oprnd2)
4260 register enum dwarf_location_atom op;
4261 register unsigned long oprnd1;
4262 register unsigned long oprnd2;
4264 register dw_loc_descr_ref descr
4265 = (dw_loc_descr_ref) xmalloc (sizeof (dw_loc_descr_node));
4267 descr->dw_loc_next = NULL;
4268 descr->dw_loc_opc = op;
4269 descr->dw_loc_oprnd1.val_class = dw_val_class_unsigned_const;
4270 descr->dw_loc_oprnd1.v.val_unsigned = oprnd1;
4271 descr->dw_loc_oprnd2.val_class = dw_val_class_unsigned_const;
4272 descr->dw_loc_oprnd2.v.val_unsigned = oprnd2;
4277 /* Add a location description term to a location description expression. */
4280 add_loc_descr (list_head, descr)
4281 register dw_loc_descr_ref *list_head;
4282 register dw_loc_descr_ref descr;
4284 register dw_loc_descr_ref *d;
4286 /* Find the end of the chain. */
4287 for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
4293 /* Keep track of the number of spaces used to indent the
4294 output of the debugging routines that print the structure of
4295 the DIE internal representation. */
4296 static int print_indent;
4298 /* Indent the line the number of spaces given by print_indent. */
4301 print_spaces (outfile)
4304 fprintf (outfile, "%*s", print_indent, "");
4307 /* Print the information associated with a given DIE, and its children.
4308 This routine is a debugging aid only. */
4311 print_die (die, outfile)
4315 register dw_attr_ref a;
4316 register dw_die_ref c;
4318 print_spaces (outfile);
4319 fprintf (outfile, "DIE %4lu: %s\n",
4320 die->die_offset, dwarf_tag_name (die->die_tag));
4321 print_spaces (outfile);
4322 fprintf (outfile, " abbrev id: %lu", die->die_abbrev);
4323 fprintf (outfile, " offset: %lu\n", die->die_offset);
4325 for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
4327 print_spaces (outfile);
4328 fprintf (outfile, " %s: ", dwarf_attr_name (a->dw_attr));
4330 switch (AT_class (a))
4332 case dw_val_class_addr:
4333 fprintf (outfile, "address");
4335 case dw_val_class_loc:
4336 fprintf (outfile, "location descriptor");
4338 case dw_val_class_const:
4339 fprintf (outfile, "%ld", AT_int (a));
4341 case dw_val_class_unsigned_const:
4342 fprintf (outfile, "%lu", AT_unsigned (a));
4344 case dw_val_class_long_long:
4345 fprintf (outfile, "constant (%lu,%lu)",
4346 a->dw_attr_val.v.val_long_long.hi,
4347 a->dw_attr_val.v.val_long_long.low);
4349 case dw_val_class_float:
4350 fprintf (outfile, "floating-point constant");
4352 case dw_val_class_flag:
4353 fprintf (outfile, "%u", AT_flag (a));
4355 case dw_val_class_die_ref:
4356 if (AT_ref (a) != NULL)
4357 fprintf (outfile, "die -> %lu", AT_ref (a)->die_offset);
4359 fprintf (outfile, "die -> <null>");
4361 case dw_val_class_lbl_id:
4362 case dw_val_class_lbl_offset:
4363 fprintf (outfile, "label: %s", AT_lbl (a));
4365 case dw_val_class_str:
4366 if (AT_string (a) != NULL)
4367 fprintf (outfile, "\"%s\"", AT_string (a));
4369 fprintf (outfile, "<null>");
4375 fprintf (outfile, "\n");
4378 if (die->die_child != NULL)
4381 for (c = die->die_child; c != NULL; c = c->die_sib)
4382 print_die (c, outfile);
4388 /* Print the contents of the source code line number correspondence table.
4389 This routine is a debugging aid only. */
4392 print_dwarf_line_table (outfile)
4395 register unsigned i;
4396 register dw_line_info_ref line_info;
4398 fprintf (outfile, "\n\nDWARF source line information\n");
4399 for (i = 1; i < line_info_table_in_use; ++i)
4401 line_info = &line_info_table[i];
4402 fprintf (outfile, "%5d: ", i);
4403 fprintf (outfile, "%-20s", file_table[line_info->dw_file_num]);
4404 fprintf (outfile, "%6ld", line_info->dw_line_num);
4405 fprintf (outfile, "\n");
4408 fprintf (outfile, "\n\n");
4411 /* Print the information collected for a given DIE. */
4414 debug_dwarf_die (die)
4417 print_die (die, stderr);
4420 /* Print all DWARF information collected for the compilation unit.
4421 This routine is a debugging aid only. */
4427 print_die (comp_unit_die, stderr);
4428 if (! DWARF2_ASM_LINE_DEBUG_INFO)
4429 print_dwarf_line_table (stderr);
4432 /* We build up the lists of children and attributes by pushing new ones
4433 onto the beginning of the list. Reverse the lists for DIE so that
4434 they are in order of addition. */
4437 reverse_die_lists (die)
4438 register dw_die_ref die;
4440 register dw_die_ref c, cp, cn;
4441 register dw_attr_ref a, ap, an;
4443 for (a = die->die_attr, ap = 0; a; a = an)
4445 an = a->dw_attr_next;
4446 a->dw_attr_next = ap;
4451 for (c = die->die_child, cp = 0; c; c = cn)
4457 die->die_child = cp;
4460 /* Traverse the DIE, reverse its lists of attributes and children, and
4461 add a sibling attribute if it may have the effect of speeding up
4462 access to siblings. To save some space, avoid generating sibling
4463 attributes for DIE's without children. */
4466 add_sibling_attributes (die)
4467 register dw_die_ref die;
4469 register dw_die_ref c;
4471 reverse_die_lists (die);
4473 if (die != comp_unit_die && die->die_sib && die->die_child != NULL)
4474 /* Add the sibling link to the front of the attribute list. */
4475 add_AT_die_ref (die, DW_AT_sibling, die->die_sib);
4477 for (c = die->die_child; c != NULL; c = c->die_sib)
4478 add_sibling_attributes (c);
4481 /* The format of each DIE (and its attribute value pairs)
4482 is encoded in an abbreviation table. This routine builds the
4483 abbreviation table and assigns a unique abbreviation id for
4484 each abbreviation entry. The children of each die are visited
4488 build_abbrev_table (die)
4489 register dw_die_ref die;
4491 register unsigned long abbrev_id;
4492 register unsigned long n_alloc;
4493 register dw_die_ref c;
4494 register dw_attr_ref d_attr, a_attr;
4495 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
4497 register dw_die_ref abbrev = abbrev_die_table[abbrev_id];
4499 if (abbrev->die_tag == die->die_tag)
4501 if ((abbrev->die_child != NULL) == (die->die_child != NULL))
4503 a_attr = abbrev->die_attr;
4504 d_attr = die->die_attr;
4506 while (a_attr != NULL && d_attr != NULL)
4508 if ((a_attr->dw_attr != d_attr->dw_attr)
4509 || (value_format (a_attr) != value_format (d_attr)))
4512 a_attr = a_attr->dw_attr_next;
4513 d_attr = d_attr->dw_attr_next;
4516 if (a_attr == NULL && d_attr == NULL)
4522 if (abbrev_id >= abbrev_die_table_in_use)
4524 if (abbrev_die_table_in_use >= abbrev_die_table_allocated)
4526 n_alloc = abbrev_die_table_allocated + ABBREV_DIE_TABLE_INCREMENT;
4528 = (dw_die_ref *) xrealloc (abbrev_die_table,
4529 sizeof (dw_die_ref) * n_alloc);
4531 bzero ((char *) &abbrev_die_table[abbrev_die_table_allocated],
4532 (n_alloc - abbrev_die_table_allocated) * sizeof (dw_die_ref));
4533 abbrev_die_table_allocated = n_alloc;
4536 ++abbrev_die_table_in_use;
4537 abbrev_die_table[abbrev_id] = die;
4540 die->die_abbrev = abbrev_id;
4541 for (c = die->die_child; c != NULL; c = c->die_sib)
4542 build_abbrev_table (c);
4545 /* Return the size of a string, including the null byte.
4547 This used to treat backslashes as escapes, and hence they were not included
4548 in the count. However, that conflicts with what ASM_OUTPUT_ASCII does,
4549 which treats a backslash as a backslash, escaping it if necessary, and hence
4550 we must include them in the count. */
4552 static unsigned long
4553 size_of_string (str)
4554 register const char *str;
4556 return strlen (str) + 1;
4559 /* Return the size of a location descriptor. */
4561 static unsigned long
4562 size_of_loc_descr (loc)
4563 register dw_loc_descr_ref loc;
4565 register unsigned long size = 1;
4567 switch (loc->dw_loc_opc)
4589 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4592 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
4597 case DW_OP_plus_uconst:
4598 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4636 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
4639 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4642 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
4645 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4646 size += size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int);
4649 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4651 case DW_OP_deref_size:
4652 case DW_OP_xderef_size:
4662 /* Return the size of a series of location descriptors. */
4664 static unsigned long
4666 register dw_loc_descr_ref loc;
4668 register unsigned long size = 0;
4670 for (; loc != NULL; loc = loc->dw_loc_next)
4671 size += size_of_loc_descr (loc);
4676 /* Return the power-of-two number of bytes necessary to represent VALUE. */
4679 constant_size (value)
4680 long unsigned value;
4687 log = floor_log2 (value);
4690 log = 1 << (floor_log2 (log) + 1);
4695 /* Return the size of a DIE, as it is represented in the
4696 .debug_info section. */
4698 static unsigned long
4700 register dw_die_ref die;
4702 register unsigned long size = 0;
4703 register dw_attr_ref a;
4705 size += size_of_uleb128 (die->die_abbrev);
4706 for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
4708 switch (AT_class (a))
4710 case dw_val_class_addr:
4713 case dw_val_class_loc:
4715 register unsigned long lsize = size_of_locs (AT_loc (a));
4718 size += constant_size (lsize);
4722 case dw_val_class_const:
4725 case dw_val_class_unsigned_const:
4726 size += constant_size (AT_unsigned (a));
4728 case dw_val_class_long_long:
4729 size += 1 + 8; /* block */
4731 case dw_val_class_float:
4732 size += 1 + a->dw_attr_val.v.val_float.length * 4; /* block */
4734 case dw_val_class_flag:
4737 case dw_val_class_die_ref:
4738 size += DWARF_OFFSET_SIZE;
4740 case dw_val_class_fde_ref:
4741 size += DWARF_OFFSET_SIZE;
4743 case dw_val_class_lbl_id:
4746 case dw_val_class_lbl_offset:
4747 size += DWARF_OFFSET_SIZE;
4749 case dw_val_class_str:
4750 size += size_of_string (AT_string (a));
4760 /* Size the debugging information associated with a given DIE.
4761 Visits the DIE's children recursively. Updates the global
4762 variable next_die_offset, on each time through. Uses the
4763 current value of next_die_offset to update the die_offset
4764 field in each DIE. */
4767 calc_die_sizes (die)
4770 register dw_die_ref c;
4771 die->die_offset = next_die_offset;
4772 next_die_offset += size_of_die (die);
4774 for (c = die->die_child; c != NULL; c = c->die_sib)
4777 if (die->die_child != NULL)
4778 /* Count the null byte used to terminate sibling lists. */
4779 next_die_offset += 1;
4782 /* Return the size of the line information prolog generated for the
4783 compilation unit. */
4785 static unsigned long
4786 size_of_line_prolog ()
4788 register unsigned long size;
4789 register unsigned long ft_index;
4791 size = DWARF_LINE_PROLOG_HEADER_SIZE;
4793 /* Count the size of the table giving number of args for each
4795 size += DWARF_LINE_OPCODE_BASE - 1;
4797 /* Include directory table is empty (at present). Count only the
4798 null byte used to terminate the table. */
4801 for (ft_index = 1; ft_index < file_table_in_use; ++ft_index)
4803 /* File name entry. */
4804 size += size_of_string (file_table[ft_index]);
4806 /* Include directory index. */
4807 size += size_of_uleb128 (0);
4809 /* Modification time. */
4810 size += size_of_uleb128 (0);
4812 /* File length in bytes. */
4813 size += size_of_uleb128 (0);
4816 /* Count the file table terminator. */
4821 /* Return the size of the .debug_pubnames table generated for the
4822 compilation unit. */
4824 static unsigned long
4827 register unsigned long size;
4828 register unsigned i;
4830 size = DWARF_PUBNAMES_HEADER_SIZE;
4831 for (i = 0; i < pubname_table_in_use; ++i)
4833 register pubname_ref p = &pubname_table[i];
4834 size += DWARF_OFFSET_SIZE + size_of_string (p->name);
4837 size += DWARF_OFFSET_SIZE;
4841 /* Return the size of the information in the .debug_aranges section. */
4843 static unsigned long
4846 register unsigned long size;
4848 size = DWARF_ARANGES_HEADER_SIZE;
4850 /* Count the address/length pair for this compilation unit. */
4851 size += 2 * PTR_SIZE;
4852 size += 2 * PTR_SIZE * arange_table_in_use;
4854 /* Count the two zero words used to terminated the address range table. */
4855 size += 2 * PTR_SIZE;
4859 /* Select the encoding of an attribute value. */
4861 static enum dwarf_form
4865 switch (a->dw_attr_val.val_class)
4867 case dw_val_class_addr:
4868 return DW_FORM_addr;
4869 case dw_val_class_loc:
4870 switch (constant_size (size_of_locs (AT_loc (a))))
4873 return DW_FORM_block1;
4875 return DW_FORM_block2;
4879 case dw_val_class_const:
4880 return DW_FORM_data4;
4881 case dw_val_class_unsigned_const:
4882 switch (constant_size (AT_unsigned (a)))
4885 return DW_FORM_data1;
4887 return DW_FORM_data2;
4889 return DW_FORM_data4;
4891 return DW_FORM_data8;
4895 case dw_val_class_long_long:
4896 return DW_FORM_block1;
4897 case dw_val_class_float:
4898 return DW_FORM_block1;
4899 case dw_val_class_flag:
4900 return DW_FORM_flag;
4901 case dw_val_class_die_ref:
4903 case dw_val_class_fde_ref:
4904 return DW_FORM_data;
4905 case dw_val_class_lbl_id:
4906 return DW_FORM_addr;
4907 case dw_val_class_lbl_offset:
4908 return DW_FORM_data;
4909 case dw_val_class_str:
4910 return DW_FORM_string;
4916 /* Output the encoding of an attribute value. */
4919 output_value_format (a)
4922 enum dwarf_form form = value_format (a);
4924 output_uleb128 (form);
4926 fprintf (asm_out_file, " (%s)", dwarf_form_name (form));
4928 fputc ('\n', asm_out_file);
4931 /* Output the .debug_abbrev section which defines the DIE abbreviation
4935 output_abbrev_section ()
4937 unsigned long abbrev_id;
4940 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
4942 register dw_die_ref abbrev = abbrev_die_table[abbrev_id];
4944 output_uleb128 (abbrev_id);
4946 fprintf (asm_out_file, " (abbrev code)");
4948 fputc ('\n', asm_out_file);
4949 output_uleb128 (abbrev->die_tag);
4951 fprintf (asm_out_file, " (TAG: %s)",
4952 dwarf_tag_name (abbrev->die_tag));
4954 fputc ('\n', asm_out_file);
4955 fprintf (asm_out_file, "\t%s\t0x%x", ASM_BYTE_OP,
4956 abbrev->die_child != NULL ? DW_children_yes : DW_children_no);
4959 fprintf (asm_out_file, "\t%s %s",
4961 (abbrev->die_child != NULL
4962 ? "DW_children_yes" : "DW_children_no"));
4964 fputc ('\n', asm_out_file);
4966 for (a_attr = abbrev->die_attr; a_attr != NULL;
4967 a_attr = a_attr->dw_attr_next)
4969 output_uleb128 (a_attr->dw_attr);
4971 fprintf (asm_out_file, " (%s)",
4972 dwarf_attr_name (a_attr->dw_attr));
4974 fputc ('\n', asm_out_file);
4975 output_value_format (a_attr);
4978 fprintf (asm_out_file, "\t%s\t0,0\n", ASM_BYTE_OP);
4981 /* Terminate the table. */
4982 fprintf (asm_out_file, "\t%s\t0\n", ASM_BYTE_OP);
4985 /* Output location description stack opcode's operands (if any). */
4988 output_loc_operands (loc)
4989 register dw_loc_descr_ref loc;
4991 register dw_val_ref val1 = &loc->dw_loc_oprnd1;
4992 register dw_val_ref val2 = &loc->dw_loc_oprnd2;
4994 switch (loc->dw_loc_opc)
4997 ASM_OUTPUT_DWARF_ADDR_CONST (asm_out_file, val1->v.val_addr);
4998 fputc ('\n', asm_out_file);
5002 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, val1->v.val_flag);
5003 fputc ('\n', asm_out_file);
5007 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, val1->v.val_int);
5008 fputc ('\n', asm_out_file);
5012 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, val1->v.val_int);
5013 fputc ('\n', asm_out_file);
5018 fputc ('\n', asm_out_file);
5021 output_uleb128 (val1->v.val_unsigned);
5022 fputc ('\n', asm_out_file);
5025 output_sleb128 (val1->v.val_int);
5026 fputc ('\n', asm_out_file);
5029 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, val1->v.val_int);
5030 fputc ('\n', asm_out_file);
5032 case DW_OP_plus_uconst:
5033 output_uleb128 (val1->v.val_unsigned);
5034 fputc ('\n', asm_out_file);
5038 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, val1->v.val_int);
5039 fputc ('\n', asm_out_file);
5073 output_sleb128 (val1->v.val_int);
5074 fputc ('\n', asm_out_file);
5077 output_uleb128 (val1->v.val_unsigned);
5078 fputc ('\n', asm_out_file);
5081 output_sleb128 (val1->v.val_int);
5082 fputc ('\n', asm_out_file);
5085 output_uleb128 (val1->v.val_unsigned);
5086 fputc ('\n', asm_out_file);
5087 output_sleb128 (val2->v.val_int);
5088 fputc ('\n', asm_out_file);
5091 output_uleb128 (val1->v.val_unsigned);
5092 fputc ('\n', asm_out_file);
5094 case DW_OP_deref_size:
5095 case DW_OP_xderef_size:
5096 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, val1->v.val_flag);
5097 fputc ('\n', asm_out_file);
5104 /* Output the DIE and its attributes. Called recursively to generate
5105 the definitions of each child DIE. */
5109 register dw_die_ref die;
5111 register dw_attr_ref a;
5112 register dw_die_ref c;
5113 register unsigned long size;
5114 register dw_loc_descr_ref loc;
5116 output_uleb128 (die->die_abbrev);
5118 fprintf (asm_out_file, " (DIE (0x%lx) %s)",
5119 die->die_offset, dwarf_tag_name (die->die_tag));
5121 fputc ('\n', asm_out_file);
5123 for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
5125 switch (AT_class (a))
5127 case dw_val_class_addr:
5128 ASM_OUTPUT_DWARF_ADDR_CONST (asm_out_file, AT_addr (a));
5131 case dw_val_class_loc:
5132 size = size_of_locs (AT_loc (a));
5134 /* Output the block length for this list of location operations. */
5135 switch (constant_size (size))
5138 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, size);
5141 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, size);
5148 fprintf (asm_out_file, "\t%s %s",
5149 ASM_COMMENT_START, dwarf_attr_name (a->dw_attr));
5151 fputc ('\n', asm_out_file);
5152 for (loc = AT_loc (a); loc != NULL; loc = loc->dw_loc_next)
5154 /* Output the opcode. */
5155 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, loc->dw_loc_opc);
5157 fprintf (asm_out_file, "\t%s %s", ASM_COMMENT_START,
5158 dwarf_stack_op_name (loc->dw_loc_opc));
5160 fputc ('\n', asm_out_file);
5162 /* Output the operand(s) (if any). */
5163 output_loc_operands (loc);
5167 case dw_val_class_const:
5168 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, AT_int (a));
5171 case dw_val_class_unsigned_const:
5172 switch (constant_size (AT_unsigned (a)))
5175 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, AT_unsigned (a));
5178 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, AT_unsigned (a));
5181 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, AT_unsigned (a));
5184 ASM_OUTPUT_DWARF_DATA8 (asm_out_file,
5185 a->dw_attr_val.v.val_long_long.hi,
5186 a->dw_attr_val.v.val_long_long.low);
5193 case dw_val_class_long_long:
5194 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 8);
5196 fprintf (asm_out_file, "\t%s %s",
5197 ASM_COMMENT_START, dwarf_attr_name (a->dw_attr));
5199 fputc ('\n', asm_out_file);
5200 ASM_OUTPUT_DWARF_DATA8 (asm_out_file,
5201 a->dw_attr_val.v.val_long_long.hi,
5202 a->dw_attr_val.v.val_long_long.low);
5205 fprintf (asm_out_file,
5206 "\t%s long long constant", ASM_COMMENT_START);
5208 fputc ('\n', asm_out_file);
5211 case dw_val_class_float:
5213 register unsigned int i;
5214 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
5215 a->dw_attr_val.v.val_float.length * 4);
5217 fprintf (asm_out_file, "\t%s %s",
5218 ASM_COMMENT_START, dwarf_attr_name (a->dw_attr));
5220 fputc ('\n', asm_out_file);
5221 for (i = 0; i < a->dw_attr_val.v.val_float.length; ++i)
5223 ASM_OUTPUT_DWARF_DATA4 (asm_out_file,
5224 a->dw_attr_val.v.val_float.array[i]);
5226 fprintf (asm_out_file, "\t%s fp constant word %u",
5227 ASM_COMMENT_START, i);
5229 fputc ('\n', asm_out_file);
5234 case dw_val_class_flag:
5235 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, AT_flag (a));
5238 case dw_val_class_die_ref:
5239 ASM_OUTPUT_DWARF_DATA (asm_out_file, AT_ref (a)->die_offset);
5242 case dw_val_class_fde_ref:
5245 ASM_GENERATE_INTERNAL_LABEL
5246 (l1, FDE_AFTER_SIZE_LABEL, a->dw_attr_val.v.val_fde_index * 2);
5247 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, l1);
5248 fprintf (asm_out_file, " - %d", DWARF_OFFSET_SIZE);
5252 case dw_val_class_lbl_id:
5253 ASM_OUTPUT_DWARF_ADDR (asm_out_file, AT_lbl (a));
5256 case dw_val_class_lbl_offset:
5257 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, AT_lbl (a));
5260 case dw_val_class_str:
5262 ASM_OUTPUT_DWARF_STRING (asm_out_file, AT_string (a));
5264 ASM_OUTPUT_ASCII (asm_out_file, AT_string (a),
5265 (int) strlen (AT_string (a)) + 1);
5272 if (AT_class (a) != dw_val_class_loc
5273 && AT_class (a) != dw_val_class_long_long
5274 && AT_class (a) != dw_val_class_float)
5277 fprintf (asm_out_file, "\t%s %s",
5278 ASM_COMMENT_START, dwarf_attr_name (a->dw_attr));
5280 fputc ('\n', asm_out_file);
5284 for (c = die->die_child; c != NULL; c = c->die_sib)
5287 if (die->die_child != NULL)
5289 /* Add null byte to terminate sibling list. */
5290 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5292 fprintf (asm_out_file, "\t%s end of children of DIE 0x%lx",
5293 ASM_COMMENT_START, die->die_offset);
5295 fputc ('\n', asm_out_file);
5299 /* Output the compilation unit that appears at the beginning of the
5300 .debug_info section, and precedes the DIE descriptions. */
5303 output_compilation_unit_header ()
5305 ASM_OUTPUT_DWARF_DATA (asm_out_file, next_die_offset - DWARF_OFFSET_SIZE);
5307 fprintf (asm_out_file, "\t%s Length of Compilation Unit Info.",
5310 fputc ('\n', asm_out_file);
5311 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, DWARF_VERSION);
5313 fprintf (asm_out_file, "\t%s DWARF version number", ASM_COMMENT_START);
5315 fputc ('\n', asm_out_file);
5316 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, abbrev_section_label);
5318 fprintf (asm_out_file, "\t%s Offset Into Abbrev. Section",
5321 fputc ('\n', asm_out_file);
5322 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, PTR_SIZE);
5324 fprintf (asm_out_file, "\t%s Pointer Size (in bytes)", ASM_COMMENT_START);
5326 fputc ('\n', asm_out_file);
5329 /* The DWARF2 pubname for a nested thingy looks like "A::f". The output
5330 of decl_printable_name for C++ looks like "A::f(int)". Let's drop the
5331 argument list, and maybe the scope. */
5334 dwarf2_name (decl, scope)
5338 return (*decl_printable_name) (decl, scope ? 1 : 0);
5341 /* Add a new entry to .debug_pubnames if appropriate. */
5344 add_pubname (decl, die)
5350 if (! TREE_PUBLIC (decl))
5353 if (pubname_table_in_use == pubname_table_allocated)
5355 pubname_table_allocated += PUBNAME_TABLE_INCREMENT;
5356 pubname_table = (pubname_ref) xrealloc
5357 (pubname_table, pubname_table_allocated * sizeof (pubname_entry));
5360 p = &pubname_table[pubname_table_in_use++];
5363 p->name = xstrdup (dwarf2_name (decl, 1));
5366 /* Output the public names table used to speed up access to externally
5367 visible names. For now, only generate entries for externally
5368 visible procedures. */
5373 register unsigned i;
5374 register unsigned long pubnames_length = size_of_pubnames ();
5376 ASM_OUTPUT_DWARF_DATA (asm_out_file, pubnames_length);
5379 fprintf (asm_out_file, "\t%s Length of Public Names Info.",
5382 fputc ('\n', asm_out_file);
5383 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, DWARF_VERSION);
5386 fprintf (asm_out_file, "\t%s DWARF Version", ASM_COMMENT_START);
5388 fputc ('\n', asm_out_file);
5389 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, debug_info_section_label);
5391 fprintf (asm_out_file, "\t%s Offset of Compilation Unit Info.",
5394 fputc ('\n', asm_out_file);
5395 ASM_OUTPUT_DWARF_DATA (asm_out_file, next_die_offset);
5397 fprintf (asm_out_file, "\t%s Compilation Unit Length", ASM_COMMENT_START);
5399 fputc ('\n', asm_out_file);
5400 for (i = 0; i < pubname_table_in_use; ++i)
5402 register pubname_ref pub = &pubname_table[i];
5404 ASM_OUTPUT_DWARF_DATA (asm_out_file, pub->die->die_offset);
5406 fprintf (asm_out_file, "\t%s DIE offset", ASM_COMMENT_START);
5408 fputc ('\n', asm_out_file);
5412 ASM_OUTPUT_DWARF_STRING (asm_out_file, pub->name);
5413 fprintf (asm_out_file, "%s external name", ASM_COMMENT_START);
5417 ASM_OUTPUT_ASCII (asm_out_file, pub->name,
5418 (int) strlen (pub->name) + 1);
5421 fputc ('\n', asm_out_file);
5424 ASM_OUTPUT_DWARF_DATA (asm_out_file, 0);
5425 fputc ('\n', asm_out_file);
5428 /* Add a new entry to .debug_aranges if appropriate. */
5431 add_arange (decl, die)
5435 if (! DECL_SECTION_NAME (decl))
5438 if (arange_table_in_use == arange_table_allocated)
5440 arange_table_allocated += ARANGE_TABLE_INCREMENT;
5442 = (arange_ref) xrealloc (arange_table,
5443 arange_table_allocated * sizeof (dw_die_ref));
5446 arange_table[arange_table_in_use++] = die;
5449 /* Output the information that goes into the .debug_aranges table.
5450 Namely, define the beginning and ending address range of the
5451 text section generated for this compilation unit. */
5456 register unsigned i;
5457 register unsigned long aranges_length = size_of_aranges ();
5459 ASM_OUTPUT_DWARF_DATA (asm_out_file, aranges_length);
5461 fprintf (asm_out_file, "\t%s Length of Address Ranges Info.",
5464 fputc ('\n', asm_out_file);
5465 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, DWARF_VERSION);
5467 fprintf (asm_out_file, "\t%s DWARF Version", ASM_COMMENT_START);
5469 fputc ('\n', asm_out_file);
5470 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, debug_info_section_label);
5472 fprintf (asm_out_file, "\t%s Offset of Compilation Unit Info.",
5475 fputc ('\n', asm_out_file);
5476 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, PTR_SIZE);
5478 fprintf (asm_out_file, "\t%s Size of Address", ASM_COMMENT_START);
5480 fputc ('\n', asm_out_file);
5481 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5483 fprintf (asm_out_file, "\t%s Size of Segment Descriptor",
5486 fputc ('\n', asm_out_file);
5487 /* We need to align to twice the pointer size here.
5488 If DWARF_OFFSET_SIZE == 4, then we have emitted 12 bytes, and need 4
5489 bytes of padding to align for either 4 or 8 byte pointers. */
5490 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0);
5491 /* If DWARF_OFFSET_SIZE == 8, then we have emitted 20 bytes, and need 12
5492 bytes of padding to align for 8 byte pointers. We have already emitted
5493 4 bytes of padding, so emit 8 more here. */
5494 if (DWARF_OFFSET_SIZE == 8)
5495 fprintf (asm_out_file, ",0,0");
5498 fprintf (asm_out_file, "\t%s Pad to %d byte boundary",
5499 ASM_COMMENT_START, 2 * PTR_SIZE);
5501 fputc ('\n', asm_out_file);
5502 ASM_OUTPUT_DWARF_ADDR (asm_out_file, text_section_label);
5504 fprintf (asm_out_file, "\t%s Address", ASM_COMMENT_START);
5506 fputc ('\n', asm_out_file);
5507 ASM_OUTPUT_DWARF_ADDR_DELTA (asm_out_file, text_end_label,
5508 text_section_label);
5510 fprintf (asm_out_file, "%s Length", ASM_COMMENT_START);
5512 fputc ('\n', asm_out_file);
5513 for (i = 0; i < arange_table_in_use; ++i)
5515 dw_die_ref die = arange_table[i];
5517 if (die->die_tag == DW_TAG_subprogram)
5518 ASM_OUTPUT_DWARF_ADDR (asm_out_file, get_AT_low_pc (die));
5521 /* A static variable; extract the symbol from DW_AT_location.
5522 Note that this code isn't currently hit, as we only emit
5523 aranges for functions (jason 9/23/99). */
5525 dw_attr_ref a = get_AT (die, DW_AT_location);
5526 dw_loc_descr_ref loc;
5527 if (! a || AT_class (a) != dw_val_class_loc)
5531 if (loc->dw_loc_opc != DW_OP_addr)
5534 ASM_OUTPUT_DWARF_ADDR (asm_out_file, loc->dw_loc_oprnd1.v.val_addr);
5538 fprintf (asm_out_file, "\t%s Address", ASM_COMMENT_START);
5540 fputc ('\n', asm_out_file);
5541 if (die->die_tag == DW_TAG_subprogram)
5542 ASM_OUTPUT_DWARF_ADDR_DELTA (asm_out_file, get_AT_hi_pc (die),
5543 get_AT_low_pc (die));
5545 ASM_OUTPUT_DWARF_ADDR_DATA (asm_out_file,
5546 get_AT_unsigned (die, DW_AT_byte_size));
5549 fprintf (asm_out_file, "%s Length", ASM_COMMENT_START);
5551 fputc ('\n', asm_out_file);
5554 /* Output the terminator words. */
5555 ASM_OUTPUT_DWARF_ADDR_DATA (asm_out_file, 0);
5556 fputc ('\n', asm_out_file);
5557 ASM_OUTPUT_DWARF_ADDR_DATA (asm_out_file, 0);
5558 fputc ('\n', asm_out_file);
5561 /* Output the source line number correspondence information. This
5562 information goes into the .debug_line section. */
5567 char line_label[MAX_ARTIFICIAL_LABEL_BYTES];
5568 char prev_line_label[MAX_ARTIFICIAL_LABEL_BYTES];
5569 register unsigned opc;
5570 register unsigned n_op_args;
5571 register unsigned long ft_index;
5572 register unsigned long lt_index;
5573 register unsigned long current_line;
5574 register long line_offset;
5575 register long line_delta;
5576 register unsigned long current_file;
5577 register unsigned long function;
5579 ASM_OUTPUT_DWARF_DELTA (asm_out_file, ".LTEND", ".LTSTART");
5581 fprintf (asm_out_file, "\t%s Length of Source Line Info.",
5584 fputc ('\n', asm_out_file);
5585 ASM_OUTPUT_LABEL (asm_out_file, ".LTSTART");
5586 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, DWARF_VERSION);
5588 fprintf (asm_out_file, "\t%s DWARF Version", ASM_COMMENT_START);
5590 fputc ('\n', asm_out_file);
5591 ASM_OUTPUT_DWARF_DATA (asm_out_file, size_of_line_prolog ());
5593 fprintf (asm_out_file, "\t%s Prolog Length", ASM_COMMENT_START);
5595 fputc ('\n', asm_out_file);
5596 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DWARF_LINE_MIN_INSTR_LENGTH);
5598 fprintf (asm_out_file, "\t%s Minimum Instruction Length",
5601 fputc ('\n', asm_out_file);
5602 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DWARF_LINE_DEFAULT_IS_STMT_START);
5604 fprintf (asm_out_file, "\t%s Default is_stmt_start flag",
5607 fputc ('\n', asm_out_file);
5608 fprintf (asm_out_file, "\t%s\t%d", ASM_BYTE_OP, DWARF_LINE_BASE);
5610 fprintf (asm_out_file, "\t%s Line Base Value (Special Opcodes)",
5613 fputc ('\n', asm_out_file);
5614 fprintf (asm_out_file, "\t%s\t%u", ASM_BYTE_OP, DWARF_LINE_RANGE);
5616 fprintf (asm_out_file, "\t%s Line Range Value (Special Opcodes)",
5619 fputc ('\n', asm_out_file);
5620 fprintf (asm_out_file, "\t%s\t%u", ASM_BYTE_OP, DWARF_LINE_OPCODE_BASE);
5622 fprintf (asm_out_file, "\t%s Special Opcode Base", ASM_COMMENT_START);
5624 fputc ('\n', asm_out_file);
5625 for (opc = 1; opc < DWARF_LINE_OPCODE_BASE; ++opc)
5629 case DW_LNS_advance_pc:
5630 case DW_LNS_advance_line:
5631 case DW_LNS_set_file:
5632 case DW_LNS_set_column:
5633 case DW_LNS_fixed_advance_pc:
5640 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, n_op_args);
5642 fprintf (asm_out_file, "\t%s opcode: 0x%x has %d args",
5643 ASM_COMMENT_START, opc, n_op_args);
5644 fputc ('\n', asm_out_file);
5648 fprintf (asm_out_file, "%s Include Directory Table\n", ASM_COMMENT_START);
5650 /* Include directory table is empty, at present */
5651 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5652 fputc ('\n', asm_out_file);
5654 fprintf (asm_out_file, "%s File Name Table\n", ASM_COMMENT_START);
5656 for (ft_index = 1; ft_index < file_table_in_use; ++ft_index)
5660 ASM_OUTPUT_DWARF_STRING (asm_out_file, file_table[ft_index]);
5661 fprintf (asm_out_file, "%s File Entry: 0x%lx",
5662 ASM_COMMENT_START, ft_index);
5666 ASM_OUTPUT_ASCII (asm_out_file,
5667 file_table[ft_index],
5668 (int) strlen (file_table[ft_index]) + 1);
5671 fputc ('\n', asm_out_file);
5673 /* Include directory index */
5675 fputc ('\n', asm_out_file);
5677 /* Modification time */
5679 fputc ('\n', asm_out_file);
5681 /* File length in bytes */
5683 fputc ('\n', asm_out_file);
5686 /* Terminate the file name table */
5687 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5688 fputc ('\n', asm_out_file);
5690 /* We used to set the address register to the first location in the text
5691 section here, but that didn't accomplish anything since we already
5692 have a line note for the opening brace of the first function. */
5694 /* Generate the line number to PC correspondence table, encoded as
5695 a series of state machine operations. */
5698 strcpy (prev_line_label, text_section_label);
5699 for (lt_index = 1; lt_index < line_info_table_in_use; ++lt_index)
5701 register dw_line_info_ref line_info = &line_info_table[lt_index];
5704 /* Disable this optimization for now; GDB wants to see two line notes
5705 at the beginning of a function so it can find the end of the
5708 /* Don't emit anything for redundant notes. Just updating the
5709 address doesn't accomplish anything, because we already assume
5710 that anything after the last address is this line. */
5711 if (line_info->dw_line_num == current_line
5712 && line_info->dw_file_num == current_file)
5716 /* Emit debug info for the address of the current line, choosing
5717 the encoding that uses the least amount of space. */
5718 /* ??? Unfortunately, we have little choice here currently, and must
5719 always use the most general form. Gcc does not know the address
5720 delta itself, so we can't use DW_LNS_advance_pc. There are no known
5721 dwarf2 aware assemblers at this time, so we can't use any special
5722 pseudo ops that would allow the assembler to optimally encode this for
5723 us. Many ports do have length attributes which will give an upper
5724 bound on the address range. We could perhaps use length attributes
5725 to determine when it is safe to use DW_LNS_fixed_advance_pc. */
5726 ASM_GENERATE_INTERNAL_LABEL (line_label, LINE_CODE_LABEL, lt_index);
5729 /* This can handle deltas up to 0xffff. This takes 3 bytes. */
5730 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc);
5732 fprintf (asm_out_file, "\t%s DW_LNS_fixed_advance_pc",
5735 fputc ('\n', asm_out_file);
5736 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, line_label, prev_line_label);
5737 fputc ('\n', asm_out_file);
5741 /* This can handle any delta. This takes 4+PTR_SIZE bytes. */
5742 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5744 fprintf (asm_out_file, "\t%s DW_LNE_set_address",
5746 fputc ('\n', asm_out_file);
5747 output_uleb128 (1 + PTR_SIZE);
5748 fputc ('\n', asm_out_file);
5749 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address);
5750 fputc ('\n', asm_out_file);
5751 ASM_OUTPUT_DWARF_ADDR (asm_out_file, line_label);
5752 fputc ('\n', asm_out_file);
5754 strcpy (prev_line_label, line_label);
5756 /* Emit debug info for the source file of the current line, if
5757 different from the previous line. */
5758 if (line_info->dw_file_num != current_file)
5760 current_file = line_info->dw_file_num;
5761 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_set_file);
5763 fprintf (asm_out_file, "\t%s DW_LNS_set_file", ASM_COMMENT_START);
5765 fputc ('\n', asm_out_file);
5766 output_uleb128 (current_file);
5768 fprintf (asm_out_file, " (\"%s\")", file_table[current_file]);
5770 fputc ('\n', asm_out_file);
5773 /* Emit debug info for the current line number, choosing the encoding
5774 that uses the least amount of space. */
5775 if (line_info->dw_line_num != current_line)
5777 line_offset = line_info->dw_line_num - current_line;
5778 line_delta = line_offset - DWARF_LINE_BASE;
5779 current_line = line_info->dw_line_num;
5780 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
5782 /* This can handle deltas from -10 to 234, using the current
5783 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE. This
5785 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
5786 DWARF_LINE_OPCODE_BASE + line_delta);
5788 fprintf (asm_out_file,
5789 "\t%s line %ld", ASM_COMMENT_START, current_line);
5791 fputc ('\n', asm_out_file);
5795 /* This can handle any delta. This takes at least 4 bytes,
5796 depending on the value being encoded. */
5797 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_advance_line);
5799 fprintf (asm_out_file, "\t%s advance to line %ld",
5800 ASM_COMMENT_START, current_line);
5802 fputc ('\n', asm_out_file);
5803 output_sleb128 (line_offset);
5804 fputc ('\n', asm_out_file);
5805 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_copy);
5807 fprintf (asm_out_file, "\t%s DW_LNS_copy", ASM_COMMENT_START);
5808 fputc ('\n', asm_out_file);
5813 /* We still need to start a new row, so output a copy insn. */
5814 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_copy);
5816 fprintf (asm_out_file, "\t%s DW_LNS_copy", ASM_COMMENT_START);
5817 fputc ('\n', asm_out_file);
5821 /* Emit debug info for the address of the end of the function. */
5824 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc);
5826 fprintf (asm_out_file, "\t%s DW_LNS_fixed_advance_pc",
5829 fputc ('\n', asm_out_file);
5830 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, text_end_label, prev_line_label);
5831 fputc ('\n', asm_out_file);
5835 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5837 fprintf (asm_out_file, "\t%s DW_LNE_set_address", ASM_COMMENT_START);
5838 fputc ('\n', asm_out_file);
5839 output_uleb128 (1 + PTR_SIZE);
5840 fputc ('\n', asm_out_file);
5841 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address);
5842 fputc ('\n', asm_out_file);
5843 ASM_OUTPUT_DWARF_ADDR (asm_out_file, text_end_label);
5844 fputc ('\n', asm_out_file);
5847 /* Output the marker for the end of the line number info. */
5848 ASM_OUTPUT_LABEL (asm_out_file, ".LTEND");
5849 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5851 fprintf (asm_out_file, "\t%s DW_LNE_end_sequence", ASM_COMMENT_START);
5853 fputc ('\n', asm_out_file);
5855 fputc ('\n', asm_out_file);
5856 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_end_sequence);
5857 fputc ('\n', asm_out_file);
5862 for (lt_index = 0; lt_index < separate_line_info_table_in_use; )
5864 register dw_separate_line_info_ref line_info
5865 = &separate_line_info_table[lt_index];
5868 /* Don't emit anything for redundant notes. */
5869 if (line_info->dw_line_num == current_line
5870 && line_info->dw_file_num == current_file
5871 && line_info->function == function)
5875 /* Emit debug info for the address of the current line. If this is
5876 a new function, or the first line of a function, then we need
5877 to handle it differently. */
5878 ASM_GENERATE_INTERNAL_LABEL (line_label, SEPARATE_LINE_CODE_LABEL,
5880 if (function != line_info->function)
5882 function = line_info->function;
5884 /* Set the address register to the first line in the function */
5885 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5887 fprintf (asm_out_file, "\t%s DW_LNE_set_address",
5890 fputc ('\n', asm_out_file);
5891 output_uleb128 (1 + PTR_SIZE);
5892 fputc ('\n', asm_out_file);
5893 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address);
5894 fputc ('\n', asm_out_file);
5895 ASM_OUTPUT_DWARF_ADDR (asm_out_file, line_label);
5896 fputc ('\n', asm_out_file);
5900 /* ??? See the DW_LNS_advance_pc comment above. */
5903 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc);
5905 fprintf (asm_out_file, "\t%s DW_LNS_fixed_advance_pc",
5908 fputc ('\n', asm_out_file);
5909 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, line_label,
5911 fputc ('\n', asm_out_file);
5915 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5917 fprintf (asm_out_file, "\t%s DW_LNE_set_address",
5919 fputc ('\n', asm_out_file);
5920 output_uleb128 (1 + PTR_SIZE);
5921 fputc ('\n', asm_out_file);
5922 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address);
5923 fputc ('\n', asm_out_file);
5924 ASM_OUTPUT_DWARF_ADDR (asm_out_file, line_label);
5925 fputc ('\n', asm_out_file);
5928 strcpy (prev_line_label, line_label);
5930 /* Emit debug info for the source file of the current line, if
5931 different from the previous line. */
5932 if (line_info->dw_file_num != current_file)
5934 current_file = line_info->dw_file_num;
5935 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_set_file);
5937 fprintf (asm_out_file, "\t%s DW_LNS_set_file", ASM_COMMENT_START);
5939 fputc ('\n', asm_out_file);
5940 output_uleb128 (current_file);
5942 fprintf (asm_out_file, " (\"%s\")", file_table[current_file]);
5944 fputc ('\n', asm_out_file);
5947 /* Emit debug info for the current line number, choosing the encoding
5948 that uses the least amount of space. */
5949 if (line_info->dw_line_num != current_line)
5951 line_offset = line_info->dw_line_num - current_line;
5952 line_delta = line_offset - DWARF_LINE_BASE;
5953 current_line = line_info->dw_line_num;
5954 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
5956 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
5957 DWARF_LINE_OPCODE_BASE + line_delta);
5959 fprintf (asm_out_file,
5960 "\t%s line %ld", ASM_COMMENT_START, current_line);
5962 fputc ('\n', asm_out_file);
5966 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_advance_line);
5968 fprintf (asm_out_file, "\t%s advance to line %ld",
5969 ASM_COMMENT_START, current_line);
5971 fputc ('\n', asm_out_file);
5972 output_sleb128 (line_offset);
5973 fputc ('\n', asm_out_file);
5974 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_copy);
5976 fprintf (asm_out_file, "\t%s DW_LNS_copy", ASM_COMMENT_START);
5977 fputc ('\n', asm_out_file);
5982 /* We still need to start a new row, so output a copy insn. */
5983 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_copy);
5985 fprintf (asm_out_file, "\t%s DW_LNS_copy", ASM_COMMENT_START);
5986 fputc ('\n', asm_out_file);
5994 /* If we're done with a function, end its sequence. */
5995 if (lt_index == separate_line_info_table_in_use
5996 || separate_line_info_table[lt_index].function != function)
6001 /* Emit debug info for the address of the end of the function. */
6002 ASM_GENERATE_INTERNAL_LABEL (line_label, FUNC_END_LABEL, function);
6005 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc);
6007 fprintf (asm_out_file, "\t%s DW_LNS_fixed_advance_pc",
6010 fputc ('\n', asm_out_file);
6011 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, line_label,
6013 fputc ('\n', asm_out_file);
6017 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
6019 fprintf (asm_out_file, "\t%s DW_LNE_set_address",
6021 fputc ('\n', asm_out_file);
6022 output_uleb128 (1 + PTR_SIZE);
6023 fputc ('\n', asm_out_file);
6024 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address);
6025 fputc ('\n', asm_out_file);
6026 ASM_OUTPUT_DWARF_ADDR (asm_out_file, line_label);
6027 fputc ('\n', asm_out_file);
6030 /* Output the marker for the end of this sequence. */
6031 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
6033 fprintf (asm_out_file, "\t%s DW_LNE_end_sequence",
6036 fputc ('\n', asm_out_file);
6038 fputc ('\n', asm_out_file);
6039 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_end_sequence);
6040 fputc ('\n', asm_out_file);
6045 /* Given a pointer to a BLOCK node return non-zero if (and only if) the node
6046 in question represents the outermost pair of curly braces (i.e. the "body
6047 block") of a function or method.
6049 For any BLOCK node representing a "body block" of a function or method, the
6050 BLOCK_SUPERCONTEXT of the node will point to another BLOCK node which
6051 represents the outermost (function) scope for the function or method (i.e.
6052 the one which includes the formal parameters). The BLOCK_SUPERCONTEXT of
6053 *that* node in turn will point to the relevant FUNCTION_DECL node. */
6056 is_body_block (stmt)
6059 if (TREE_CODE (stmt) == BLOCK)
6061 register tree parent = BLOCK_SUPERCONTEXT (stmt);
6063 if (TREE_CODE (parent) == BLOCK)
6065 register tree grandparent = BLOCK_SUPERCONTEXT (parent);
6067 if (TREE_CODE (grandparent) == FUNCTION_DECL)
6075 /* Given a pointer to a tree node for some base type, return a pointer to
6076 a DIE that describes the given type.
6078 This routine must only be called for GCC type nodes that correspond to
6079 Dwarf base (fundamental) types. */
6082 base_type_die (type)
6085 register dw_die_ref base_type_result;
6086 register const char *type_name;
6087 register enum dwarf_type encoding;
6088 register tree name = TYPE_NAME (type);
6090 if (TREE_CODE (type) == ERROR_MARK
6091 || TREE_CODE (type) == VOID_TYPE)
6096 if (TREE_CODE (name) == TYPE_DECL)
6097 name = DECL_NAME (name);
6099 type_name = IDENTIFIER_POINTER (name);
6102 type_name = "__unknown__";
6104 switch (TREE_CODE (type))
6107 /* Carefully distinguish the C character types, without messing
6108 up if the language is not C. Note that we check only for the names
6109 that contain spaces; other names might occur by coincidence in other
6111 if (! (TYPE_PRECISION (type) == CHAR_TYPE_SIZE
6112 && (type == char_type_node
6113 || ! strcmp (type_name, "signed char")
6114 || ! strcmp (type_name, "unsigned char"))))
6116 if (TREE_UNSIGNED (type))
6117 encoding = DW_ATE_unsigned;
6119 encoding = DW_ATE_signed;
6122 /* else fall through */
6125 /* GNU Pascal/Ada CHAR type. Not used in C. */
6126 if (TREE_UNSIGNED (type))
6127 encoding = DW_ATE_unsigned_char;
6129 encoding = DW_ATE_signed_char;
6133 encoding = DW_ATE_float;
6136 /* Dwarf2 doesn't know anything about complex ints, so use
6137 a user defined type for it. */
6139 if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
6140 encoding = DW_ATE_complex_float;
6142 encoding = DW_ATE_lo_user;
6146 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */
6147 encoding = DW_ATE_boolean;
6151 abort (); /* No other TREE_CODEs are Dwarf fundamental types. */
6154 base_type_result = new_die (DW_TAG_base_type, comp_unit_die);
6155 if (demangle_name_func)
6156 type_name = (*demangle_name_func) (type_name);
6158 add_AT_string (base_type_result, DW_AT_name, type_name);
6159 add_AT_unsigned (base_type_result, DW_AT_byte_size,
6160 int_size_in_bytes (type));
6161 add_AT_unsigned (base_type_result, DW_AT_encoding, encoding);
6163 return base_type_result;
6166 /* Given a pointer to an arbitrary ..._TYPE tree node, return a pointer to
6167 the Dwarf "root" type for the given input type. The Dwarf "root" type of
6168 a given type is generally the same as the given type, except that if the
6169 given type is a pointer or reference type, then the root type of the given
6170 type is the root type of the "basis" type for the pointer or reference
6171 type. (This definition of the "root" type is recursive.) Also, the root
6172 type of a `const' qualified type or a `volatile' qualified type is the
6173 root type of the given type without the qualifiers. */
6179 if (TREE_CODE (type) == ERROR_MARK)
6180 return error_mark_node;
6182 switch (TREE_CODE (type))
6185 return error_mark_node;
6188 case REFERENCE_TYPE:
6189 return type_main_variant (root_type (TREE_TYPE (type)));
6192 return type_main_variant (type);
6196 /* Given a pointer to an arbitrary ..._TYPE tree node, return non-zero if the
6197 given input type is a Dwarf "fundamental" type. Otherwise return null. */
6203 switch (TREE_CODE (type))
6218 case QUAL_UNION_TYPE:
6223 case REFERENCE_TYPE:
6236 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
6237 entry that chains various modifiers in front of the given type. */
6240 modified_type_die (type, is_const_type, is_volatile_type, context_die)
6242 register int is_const_type;
6243 register int is_volatile_type;
6244 register dw_die_ref context_die;
6246 register enum tree_code code = TREE_CODE (type);
6247 register dw_die_ref mod_type_die = NULL;
6248 register dw_die_ref sub_die = NULL;
6249 register tree item_type = NULL;
6251 if (code != ERROR_MARK)
6253 type = build_type_variant (type, is_const_type, is_volatile_type);
6255 mod_type_die = lookup_type_die (type);
6257 return mod_type_die;
6259 /* Handle C typedef types. */
6260 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
6261 && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
6263 tree dtype = TREE_TYPE (TYPE_NAME (type));
6266 /* For a named type, use the typedef. */
6267 gen_type_die (type, context_die);
6268 mod_type_die = lookup_type_die (type);
6271 else if (is_const_type < TYPE_READONLY (dtype)
6272 || is_volatile_type < TYPE_VOLATILE (dtype))
6273 /* cv-unqualified version of named type. Just use the unnamed
6274 type to which it refers. */
6276 = modified_type_die (DECL_ORIGINAL_TYPE (TYPE_NAME (type)),
6277 is_const_type, is_volatile_type,
6279 /* Else cv-qualified version of named type; fall through. */
6284 else if (is_const_type)
6286 mod_type_die = new_die (DW_TAG_const_type, comp_unit_die);
6287 sub_die = modified_type_die (type, 0, is_volatile_type, context_die);
6289 else if (is_volatile_type)
6291 mod_type_die = new_die (DW_TAG_volatile_type, comp_unit_die);
6292 sub_die = modified_type_die (type, 0, 0, context_die);
6294 else if (code == POINTER_TYPE)
6296 mod_type_die = new_die (DW_TAG_pointer_type, comp_unit_die);
6297 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
6299 add_AT_unsigned (mod_type_die, DW_AT_address_class, 0);
6301 item_type = TREE_TYPE (type);
6303 else if (code == REFERENCE_TYPE)
6305 mod_type_die = new_die (DW_TAG_reference_type, comp_unit_die);
6306 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
6308 add_AT_unsigned (mod_type_die, DW_AT_address_class, 0);
6310 item_type = TREE_TYPE (type);
6312 else if (is_base_type (type))
6313 mod_type_die = base_type_die (type);
6316 gen_type_die (type, context_die);
6318 /* We have to get the type_main_variant here (and pass that to the
6319 `lookup_type_die' routine) because the ..._TYPE node we have
6320 might simply be a *copy* of some original type node (where the
6321 copy was created to help us keep track of typedef names) and
6322 that copy might have a different TYPE_UID from the original
6324 mod_type_die = lookup_type_die (type_main_variant (type));
6325 if (mod_type_die == NULL)
6330 equate_type_number_to_die (type, mod_type_die);
6332 /* We must do this after the equate_type_number_to_die call, in case
6333 this is a recursive type. This ensures that the modified_type_die
6334 recursion will terminate even if the type is recursive. Recursive
6335 types are possible in Ada. */
6336 sub_die = modified_type_die (item_type,
6337 TYPE_READONLY (item_type),
6338 TYPE_VOLATILE (item_type),
6341 if (sub_die != NULL)
6342 add_AT_die_ref (mod_type_die, DW_AT_type, sub_die);
6344 return mod_type_die;
6347 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
6348 an enumerated type. */
6354 return TREE_CODE (type) == ENUMERAL_TYPE;
6357 /* Return a location descriptor that designates a machine register. */
6359 static dw_loc_descr_ref
6360 reg_loc_descriptor (rtl)
6363 register dw_loc_descr_ref loc_result = NULL;
6364 register unsigned reg = reg_number (rtl);
6367 loc_result = new_loc_descr (DW_OP_reg0 + reg, 0, 0);
6369 loc_result = new_loc_descr (DW_OP_regx, reg, 0);
6374 /* Return a location descriptor that designates a base+offset location. */
6376 static dw_loc_descr_ref
6377 based_loc_descr (reg, offset)
6381 register dw_loc_descr_ref loc_result;
6382 /* For the "frame base", we use the frame pointer or stack pointer
6383 registers, since the RTL for local variables is relative to one of
6385 register unsigned fp_reg = DBX_REGISTER_NUMBER (frame_pointer_needed
6386 ? HARD_FRAME_POINTER_REGNUM
6387 : STACK_POINTER_REGNUM);
6390 loc_result = new_loc_descr (DW_OP_fbreg, offset, 0);
6392 loc_result = new_loc_descr (DW_OP_breg0 + reg, offset, 0);
6394 loc_result = new_loc_descr (DW_OP_bregx, reg, offset);
6399 /* Return true if this RTL expression describes a base+offset calculation. */
6405 return (GET_CODE (rtl) == PLUS
6406 && ((GET_CODE (XEXP (rtl, 0)) == REG
6407 && GET_CODE (XEXP (rtl, 1)) == CONST_INT)));
6410 /* The following routine converts the RTL for a variable or parameter
6411 (resident in memory) into an equivalent Dwarf representation of a
6412 mechanism for getting the address of that same variable onto the top of a
6413 hypothetical "address evaluation" stack.
6415 When creating memory location descriptors, we are effectively transforming
6416 the RTL for a memory-resident object into its Dwarf postfix expression
6417 equivalent. This routine recursively descends an RTL tree, turning
6418 it into Dwarf postfix code as it goes.
6420 MODE is the mode of the memory reference, needed to handle some
6421 autoincrement addressing modes. */
6423 static dw_loc_descr_ref
6424 mem_loc_descriptor (rtl, mode)
6426 enum machine_mode mode;
6428 dw_loc_descr_ref mem_loc_result = NULL;
6429 /* Note that for a dynamically sized array, the location we will generate a
6430 description of here will be the lowest numbered location which is
6431 actually within the array. That's *not* necessarily the same as the
6432 zeroth element of the array. */
6434 switch (GET_CODE (rtl))
6438 /* POST_INC and POST_DEC can be handled just like a SUBREG. So we
6439 just fall into the SUBREG code. */
6441 /* ... fall through ... */
6444 /* The case of a subreg may arise when we have a local (register)
6445 variable or a formal (register) parameter which doesn't quite fill
6446 up an entire register. For now, just assume that it is
6447 legitimate to make the Dwarf info refer to the whole register which
6448 contains the given subreg. */
6449 rtl = XEXP (rtl, 0);
6451 /* ... fall through ... */
6454 /* Whenever a register number forms a part of the description of the
6455 method for calculating the (dynamic) address of a memory resident
6456 object, DWARF rules require the register number be referred to as
6457 a "base register". This distinction is not based in any way upon
6458 what category of register the hardware believes the given register
6459 belongs to. This is strictly DWARF terminology we're dealing with
6460 here. Note that in cases where the location of a memory-resident
6461 data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
6462 OP_CONST (0)) the actual DWARF location descriptor that we generate
6463 may just be OP_BASEREG (basereg). This may look deceptively like
6464 the object in question was allocated to a register (rather than in
6465 memory) so DWARF consumers need to be aware of the subtle
6466 distinction between OP_REG and OP_BASEREG. */
6467 mem_loc_result = based_loc_descr (reg_number (rtl), 0);
6471 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), mode);
6472 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_deref, 0, 0));
6476 /* Some ports can transform a symbol ref into a label ref, because
6477 the symbol ref is too far away and has to be dumped into a constant
6481 mem_loc_result = new_loc_descr (DW_OP_addr, 0, 0);
6482 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_addr;
6483 mem_loc_result->dw_loc_oprnd1.v.val_addr = addr_to_string (rtl);
6488 /* Turn these into a PLUS expression and fall into the PLUS code
6490 rtl = gen_rtx_PLUS (word_mode, XEXP (rtl, 0),
6491 GEN_INT (GET_CODE (rtl) == PRE_INC
6492 ? GET_MODE_UNIT_SIZE (mode)
6493 : - GET_MODE_UNIT_SIZE (mode)));
6495 /* ... fall through ... */
6498 if (is_based_loc (rtl))
6499 mem_loc_result = based_loc_descr (reg_number (XEXP (rtl, 0)),
6500 INTVAL (XEXP (rtl, 1)));
6503 add_loc_descr (&mem_loc_result, mem_loc_descriptor (XEXP (rtl, 0),
6505 add_loc_descr (&mem_loc_result, mem_loc_descriptor (XEXP (rtl, 1),
6507 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_plus, 0, 0));
6512 /* If a pseudo-reg is optimized away, it is possible for it to
6513 be replaced with a MEM containing a multiply. */
6514 add_loc_descr (&mem_loc_result, mem_loc_descriptor (XEXP (rtl, 0), mode));
6515 add_loc_descr (&mem_loc_result, mem_loc_descriptor (XEXP (rtl, 1), mode));
6516 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_mul, 0, 0));
6520 mem_loc_result = new_loc_descr (DW_OP_constu, INTVAL (rtl), 0);
6527 return mem_loc_result;
6530 /* Return a descriptor that describes the concatenation of two locations.
6531 This is typically a complex variable. */
6533 static dw_loc_descr_ref
6534 concat_loc_descriptor (x0, x1)
6535 register rtx x0, x1;
6537 dw_loc_descr_ref cc_loc_result = NULL;
6539 if (!is_pseudo_reg (x0)
6540 && (GET_CODE (x0) != MEM || !is_pseudo_reg (XEXP (x0, 0))))
6541 add_loc_descr (&cc_loc_result, loc_descriptor (x0));
6542 add_loc_descr (&cc_loc_result,
6543 new_loc_descr (DW_OP_piece, GET_MODE_SIZE (GET_MODE (x0)), 0));
6545 if (!is_pseudo_reg (x1)
6546 && (GET_CODE (x1) != MEM || !is_pseudo_reg (XEXP (x1, 0))))
6547 add_loc_descr (&cc_loc_result, loc_descriptor (x1));
6548 add_loc_descr (&cc_loc_result,
6549 new_loc_descr (DW_OP_piece, GET_MODE_SIZE (GET_MODE (x1)), 0));
6551 return cc_loc_result;
6554 /* Output a proper Dwarf location descriptor for a variable or parameter
6555 which is either allocated in a register or in a memory location. For a
6556 register, we just generate an OP_REG and the register number. For a
6557 memory location we provide a Dwarf postfix expression describing how to
6558 generate the (dynamic) address of the object onto the address stack. */
6560 static dw_loc_descr_ref
6561 loc_descriptor (rtl)
6564 dw_loc_descr_ref loc_result = NULL;
6565 switch (GET_CODE (rtl))
6568 /* The case of a subreg may arise when we have a local (register)
6569 variable or a formal (register) parameter which doesn't quite fill
6570 up an entire register. For now, just assume that it is
6571 legitimate to make the Dwarf info refer to the whole register which
6572 contains the given subreg. */
6573 rtl = XEXP (rtl, 0);
6575 /* ... fall through ... */
6578 loc_result = reg_loc_descriptor (rtl);
6582 loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl));
6586 loc_result = concat_loc_descriptor (XEXP (rtl, 0), XEXP (rtl, 1));
6596 /* Given an unsigned value, round it up to the lowest multiple of `boundary'
6597 which is not less than the value itself. */
6599 static inline unsigned
6600 ceiling (value, boundary)
6601 register unsigned value;
6602 register unsigned boundary;
6604 return (((value + boundary - 1) / boundary) * boundary);
6607 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
6608 pointer to the declared type for the relevant field variable, or return
6609 `integer_type_node' if the given node turns out to be an
6618 if (TREE_CODE (decl) == ERROR_MARK)
6619 return integer_type_node;
6621 type = DECL_BIT_FIELD_TYPE (decl);
6622 if (type == NULL_TREE)
6623 type = TREE_TYPE (decl);
6628 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
6629 node, return the alignment in bits for the type, or else return
6630 BITS_PER_WORD if the node actually turns out to be an
6633 static inline unsigned
6634 simple_type_align_in_bits (type)
6637 return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD;
6640 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
6641 node, return the size in bits for the type if it is a constant, or else
6642 return the alignment for the type if the type's size is not constant, or
6643 else return BITS_PER_WORD if the type actually turns out to be an
6646 static inline unsigned
6647 simple_type_size_in_bits (type)
6650 if (TREE_CODE (type) == ERROR_MARK)
6651 return BITS_PER_WORD;
6654 register tree type_size_tree = TYPE_SIZE (type);
6656 if (TREE_CODE (type_size_tree) != INTEGER_CST)
6657 return TYPE_ALIGN (type);
6659 return (unsigned) TREE_INT_CST_LOW (type_size_tree);
6663 /* Given a pointer to what is assumed to be a FIELD_DECL node, compute and
6664 return the byte offset of the lowest addressed byte of the "containing
6665 object" for the given FIELD_DECL, or return 0 if we are unable to
6666 determine what that offset is, either because the argument turns out to
6667 be a pointer to an ERROR_MARK node, or because the offset is actually
6668 variable. (We can't handle the latter case just yet). */
6671 field_byte_offset (decl)
6674 register unsigned type_align_in_bytes;
6675 register unsigned type_align_in_bits;
6676 register unsigned type_size_in_bits;
6677 register unsigned object_offset_in_align_units;
6678 register unsigned object_offset_in_bits;
6679 register unsigned object_offset_in_bytes;
6681 register tree bitpos_tree;
6682 register tree field_size_tree;
6683 register unsigned bitpos_int;
6684 register unsigned deepest_bitpos;
6685 register unsigned field_size_in_bits;
6687 if (TREE_CODE (decl) == ERROR_MARK)
6690 if (TREE_CODE (decl) != FIELD_DECL)
6693 type = field_type (decl);
6695 bitpos_tree = DECL_FIELD_BITPOS (decl);
6696 field_size_tree = DECL_SIZE (decl);
6698 /* If there was an error, the size could be zero. */
6699 if (! field_size_tree)
6706 /* We cannot yet cope with fields whose positions are variable, so
6707 for now, when we see such things, we simply return 0. Someday, we may
6708 be able to handle such cases, but it will be damn difficult. */
6709 if (TREE_CODE (bitpos_tree) != INTEGER_CST)
6712 bitpos_int = (unsigned) TREE_INT_CST_LOW (bitpos_tree);
6714 /* If we don't know the size of the field, pretend it's a full word. */
6715 if (TREE_CODE (field_size_tree) == INTEGER_CST)
6716 field_size_in_bits = (unsigned) TREE_INT_CST_LOW (field_size_tree);
6718 field_size_in_bits = BITS_PER_WORD;
6720 type_size_in_bits = simple_type_size_in_bits (type);
6721 type_align_in_bits = simple_type_align_in_bits (type);
6722 type_align_in_bytes = type_align_in_bits / BITS_PER_UNIT;
6724 /* Note that the GCC front-end doesn't make any attempt to keep track of
6725 the starting bit offset (relative to the start of the containing
6726 structure type) of the hypothetical "containing object" for a bit-
6727 field. Thus, when computing the byte offset value for the start of the
6728 "containing object" of a bit-field, we must deduce this information on
6729 our own. This can be rather tricky to do in some cases. For example,
6730 handling the following structure type definition when compiling for an
6731 i386/i486 target (which only aligns long long's to 32-bit boundaries)
6734 struct S { int field1; long long field2:31; };
6736 Fortunately, there is a simple rule-of-thumb which can be
6737 used in such cases. When compiling for an i386/i486, GCC will allocate
6738 8 bytes for the structure shown above. It decides to do this based upon
6739 one simple rule for bit-field allocation. Quite simply, GCC allocates
6740 each "containing object" for each bit-field at the first (i.e. lowest
6741 addressed) legitimate alignment boundary (based upon the required
6742 minimum alignment for the declared type of the field) which it can
6743 possibly use, subject to the condition that there is still enough
6744 available space remaining in the containing object (when allocated at
6745 the selected point) to fully accommodate all of the bits of the
6746 bit-field itself. This simple rule makes it obvious why GCC allocates
6747 8 bytes for each object of the structure type shown above. When looking
6748 for a place to allocate the "containing object" for `field2', the
6749 compiler simply tries to allocate a 64-bit "containing object" at each
6750 successive 32-bit boundary (starting at zero) until it finds a place to
6751 allocate that 64- bit field such that at least 31 contiguous (and
6752 previously unallocated) bits remain within that selected 64 bit field.
6753 (As it turns out, for the example above, the compiler finds that it is
6754 OK to allocate the "containing object" 64-bit field at bit-offset zero
6755 within the structure type.) Here we attempt to work backwards from the
6756 limited set of facts we're given, and we try to deduce from those facts,
6757 where GCC must have believed that the containing object started (within
6758 the structure type). The value we deduce is then used (by the callers of
6759 this routine) to generate DW_AT_location and DW_AT_bit_offset attributes
6760 for fields (both bit-fields and, in the case of DW_AT_location, regular
6763 /* Figure out the bit-distance from the start of the structure to the
6764 "deepest" bit of the bit-field. */
6765 deepest_bitpos = bitpos_int + field_size_in_bits;
6767 /* This is the tricky part. Use some fancy footwork to deduce where the
6768 lowest addressed bit of the containing object must be. */
6769 object_offset_in_bits
6770 = ceiling (deepest_bitpos, type_align_in_bits) - type_size_in_bits;
6772 /* Compute the offset of the containing object in "alignment units". */
6773 object_offset_in_align_units = object_offset_in_bits / type_align_in_bits;
6775 /* Compute the offset of the containing object in bytes. */
6776 object_offset_in_bytes = object_offset_in_align_units * type_align_in_bytes;
6778 return object_offset_in_bytes;
6781 /* The following routines define various Dwarf attributes and any data
6782 associated with them. */
6784 /* Add a location description attribute value to a DIE.
6786 This emits location attributes suitable for whole variables and
6787 whole parameters. Note that the location attributes for struct fields are
6788 generated by the routine `data_member_location_attribute' below. */
6791 add_AT_location_description (die, attr_kind, rtl)
6793 enum dwarf_attribute attr_kind;
6796 /* Handle a special case. If we are about to output a location descriptor
6797 for a variable or parameter which has been optimized out of existence,
6798 don't do that. A variable which has been optimized out
6799 of existence will have a DECL_RTL value which denotes a pseudo-reg.
6800 Currently, in some rare cases, variables can have DECL_RTL values which
6801 look like (MEM (REG pseudo-reg#)). These cases are due to bugs
6802 elsewhere in the compiler. We treat such cases as if the variable(s) in
6803 question had been optimized out of existence. */
6805 if (is_pseudo_reg (rtl)
6806 || (GET_CODE (rtl) == MEM
6807 && is_pseudo_reg (XEXP (rtl, 0)))
6808 /* This can happen for a PARM_DECL with a DECL_INCOMING_RTL which
6809 references the internal argument pointer (a pseudo) in a function
6810 where all references to the internal argument pointer were
6811 eliminated via the optimizers. */
6812 || (GET_CODE (rtl) == MEM
6813 && GET_CODE (XEXP (rtl, 0)) == PLUS
6814 && is_pseudo_reg (XEXP (XEXP (rtl, 0), 0)))
6815 || (GET_CODE (rtl) == CONCAT
6816 && is_pseudo_reg (XEXP (rtl, 0))
6817 && is_pseudo_reg (XEXP (rtl, 1))))
6820 add_AT_loc (die, attr_kind, loc_descriptor (rtl));
6823 /* Attach the specialized form of location attribute used for data
6824 members of struct and union types. In the special case of a
6825 FIELD_DECL node which represents a bit-field, the "offset" part
6826 of this special location descriptor must indicate the distance
6827 in bytes from the lowest-addressed byte of the containing struct
6828 or union type to the lowest-addressed byte of the "containing
6829 object" for the bit-field. (See the `field_byte_offset' function
6830 above).. For any given bit-field, the "containing object" is a
6831 hypothetical object (of some integral or enum type) within which
6832 the given bit-field lives. The type of this hypothetical
6833 "containing object" is always the same as the declared type of
6834 the individual bit-field itself (for GCC anyway... the DWARF
6835 spec doesn't actually mandate this). Note that it is the size
6836 (in bytes) of the hypothetical "containing object" which will
6837 be given in the DW_AT_byte_size attribute for this bit-field.
6838 (See the `byte_size_attribute' function below.) It is also used
6839 when calculating the value of the DW_AT_bit_offset attribute.
6840 (See the `bit_offset_attribute' function below). */
6843 add_data_member_location_attribute (die, decl)
6844 register dw_die_ref die;
6847 register unsigned long offset;
6848 register dw_loc_descr_ref loc_descr;
6849 register enum dwarf_location_atom op;
6851 if (TREE_CODE (decl) == TREE_VEC)
6852 offset = TREE_INT_CST_LOW (BINFO_OFFSET (decl));
6854 offset = field_byte_offset (decl);
6856 /* The DWARF2 standard says that we should assume that the structure address
6857 is already on the stack, so we can specify a structure field address
6858 by using DW_OP_plus_uconst. */
6860 #ifdef MIPS_DEBUGGING_INFO
6861 /* ??? The SGI dwarf reader does not handle the DW_OP_plus_uconst operator
6862 correctly. It works only if we leave the offset on the stack. */
6865 op = DW_OP_plus_uconst;
6868 loc_descr = new_loc_descr (op, offset, 0);
6869 add_AT_loc (die, DW_AT_data_member_location, loc_descr);
6872 /* Attach an DW_AT_const_value attribute for a variable or a parameter which
6873 does not have a "location" either in memory or in a register. These
6874 things can arise in GNU C when a constant is passed as an actual parameter
6875 to an inlined function. They can also arise in C++ where declared
6876 constants do not necessarily get memory "homes". */
6879 add_const_value_attribute (die, rtl)
6880 register dw_die_ref die;
6883 switch (GET_CODE (rtl))
6886 /* Note that a CONST_INT rtx could represent either an integer or a
6887 floating-point constant. A CONST_INT is used whenever the constant
6888 will fit into a single word. In all such cases, the original mode
6889 of the constant value is wiped out, and the CONST_INT rtx is
6890 assigned VOIDmode. */
6891 add_AT_unsigned (die, DW_AT_const_value, (unsigned) INTVAL (rtl));
6895 /* Note that a CONST_DOUBLE rtx could represent either an integer or a
6896 floating-point constant. A CONST_DOUBLE is used whenever the
6897 constant requires more than one word in order to be adequately
6898 represented. We output CONST_DOUBLEs as blocks. */
6900 register enum machine_mode mode = GET_MODE (rtl);
6902 if (GET_MODE_CLASS (mode) == MODE_FLOAT)
6904 register unsigned length = GET_MODE_SIZE (mode) / sizeof (long);
6908 REAL_VALUE_FROM_CONST_DOUBLE (rv, rtl);
6912 REAL_VALUE_TO_TARGET_SINGLE (rv, array[0]);
6916 REAL_VALUE_TO_TARGET_DOUBLE (rv, array);
6921 REAL_VALUE_TO_TARGET_LONG_DOUBLE (rv, array);
6928 add_AT_float (die, DW_AT_const_value, length, array);
6931 add_AT_long_long (die, DW_AT_const_value,
6932 CONST_DOUBLE_HIGH (rtl), CONST_DOUBLE_LOW (rtl));
6937 add_AT_string (die, DW_AT_const_value, XSTR (rtl, 0));
6943 add_AT_addr (die, DW_AT_const_value, addr_to_string (rtl));
6947 /* In cases where an inlined instance of an inline function is passed
6948 the address of an `auto' variable (which is local to the caller) we
6949 can get a situation where the DECL_RTL of the artificial local
6950 variable (for the inlining) which acts as a stand-in for the
6951 corresponding formal parameter (of the inline function) will look
6952 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not
6953 exactly a compile-time constant expression, but it isn't the address
6954 of the (artificial) local variable either. Rather, it represents the
6955 *value* which the artificial local variable always has during its
6956 lifetime. We currently have no way to represent such quasi-constant
6957 values in Dwarf, so for now we just punt and generate nothing. */
6961 /* No other kinds of rtx should be possible here. */
6967 /* Generate *either* an DW_AT_location attribute or else an DW_AT_const_value
6968 data attribute for a variable or a parameter. We generate the
6969 DW_AT_const_value attribute only in those cases where the given variable
6970 or parameter does not have a true "location" either in memory or in a
6971 register. This can happen (for example) when a constant is passed as an
6972 actual argument in a call to an inline function. (It's possible that
6973 these things can crop up in other ways also.) Note that one type of
6974 constant value which can be passed into an inlined function is a constant
6975 pointer. This can happen for example if an actual argument in an inlined
6976 function call evaluates to a compile-time constant address. */
6979 add_location_or_const_value_attribute (die, decl)
6980 register dw_die_ref die;
6984 register tree declared_type;
6985 register tree passed_type;
6987 if (TREE_CODE (decl) == ERROR_MARK)
6990 if (TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != PARM_DECL)
6993 /* Here we have to decide where we are going to say the parameter "lives"
6994 (as far as the debugger is concerned). We only have a couple of
6995 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
6997 DECL_RTL normally indicates where the parameter lives during most of the
6998 activation of the function. If optimization is enabled however, this
6999 could be either NULL or else a pseudo-reg. Both of those cases indicate
7000 that the parameter doesn't really live anywhere (as far as the code
7001 generation parts of GCC are concerned) during most of the function's
7002 activation. That will happen (for example) if the parameter is never
7003 referenced within the function.
7005 We could just generate a location descriptor here for all non-NULL
7006 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
7007 a little nicer than that if we also consider DECL_INCOMING_RTL in cases
7008 where DECL_RTL is NULL or is a pseudo-reg.
7010 Note however that we can only get away with using DECL_INCOMING_RTL as
7011 a backup substitute for DECL_RTL in certain limited cases. In cases
7012 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
7013 we can be sure that the parameter was passed using the same type as it is
7014 declared to have within the function, and that its DECL_INCOMING_RTL
7015 points us to a place where a value of that type is passed.
7017 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
7018 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
7019 because in these cases DECL_INCOMING_RTL points us to a value of some
7020 type which is *different* from the type of the parameter itself. Thus,
7021 if we tried to use DECL_INCOMING_RTL to generate a location attribute in
7022 such cases, the debugger would end up (for example) trying to fetch a
7023 `float' from a place which actually contains the first part of a
7024 `double'. That would lead to really incorrect and confusing
7025 output at debug-time.
7027 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
7028 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There
7029 are a couple of exceptions however. On little-endian machines we can
7030 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
7031 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
7032 an integral type that is smaller than TREE_TYPE (decl). These cases arise
7033 when (on a little-endian machine) a non-prototyped function has a
7034 parameter declared to be of type `short' or `char'. In such cases,
7035 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
7036 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
7037 passed `int' value. If the debugger then uses that address to fetch
7038 a `short' or a `char' (on a little-endian machine) the result will be
7039 the correct data, so we allow for such exceptional cases below.
7041 Note that our goal here is to describe the place where the given formal
7042 parameter lives during most of the function's activation (i.e. between
7043 the end of the prologue and the start of the epilogue). We'll do that
7044 as best as we can. Note however that if the given formal parameter is
7045 modified sometime during the execution of the function, then a stack
7046 backtrace (at debug-time) will show the function as having been
7047 called with the *new* value rather than the value which was
7048 originally passed in. This happens rarely enough that it is not
7049 a major problem, but it *is* a problem, and I'd like to fix it.
7051 A future version of dwarf2out.c may generate two additional
7052 attributes for any given DW_TAG_formal_parameter DIE which will
7053 describe the "passed type" and the "passed location" for the
7054 given formal parameter in addition to the attributes we now
7055 generate to indicate the "declared type" and the "active
7056 location" for each parameter. This additional set of attributes
7057 could be used by debuggers for stack backtraces. Separately, note
7058 that sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be
7059 NULL also. This happens (for example) for inlined-instances of
7060 inline function formal parameters which are never referenced.
7061 This really shouldn't be happening. All PARM_DECL nodes should
7062 get valid non-NULL DECL_INCOMING_RTL values, but integrate.c
7063 doesn't currently generate these values for inlined instances of
7064 inline function parameters, so when we see such cases, we are
7065 just out-of-luck for the time being (until integrate.c
7068 /* Use DECL_RTL as the "location" unless we find something better. */
7069 rtl = DECL_RTL (decl);
7071 if (TREE_CODE (decl) == PARM_DECL)
7073 if (rtl == NULL_RTX || is_pseudo_reg (rtl))
7075 declared_type = type_main_variant (TREE_TYPE (decl));
7076 passed_type = type_main_variant (DECL_ARG_TYPE (decl));
7078 /* This decl represents a formal parameter which was optimized out.
7079 Note that DECL_INCOMING_RTL may be NULL in here, but we handle
7080 all* cases where (rtl == NULL_RTX) just below. */
7081 if (declared_type == passed_type)
7082 rtl = DECL_INCOMING_RTL (decl);
7083 else if (! BYTES_BIG_ENDIAN
7084 && TREE_CODE (declared_type) == INTEGER_TYPE
7085 && (GET_MODE_SIZE (TYPE_MODE (declared_type))
7086 <= GET_MODE_SIZE (TYPE_MODE (passed_type))))
7087 rtl = DECL_INCOMING_RTL (decl);
7090 /* If the parm was passed in registers, but lives on the stack, then
7091 make a big endian correction if the mode of the type of the
7092 parameter is not the same as the mode of the rtl. */
7093 /* ??? This is the same series of checks that are made in dbxout.c before
7094 we reach the big endian correction code there. It isn't clear if all
7095 of these checks are necessary here, but keeping them all is the safe
7097 else if (GET_CODE (rtl) == MEM
7098 && XEXP (rtl, 0) != const0_rtx
7099 && ! CONSTANT_P (XEXP (rtl, 0))
7100 /* Not passed in memory. */
7101 && GET_CODE (DECL_INCOMING_RTL (decl)) != MEM
7102 /* Not passed by invisible reference. */
7103 && (GET_CODE (XEXP (rtl, 0)) != REG
7104 || REGNO (XEXP (rtl, 0)) == HARD_FRAME_POINTER_REGNUM
7105 || REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM
7106 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
7107 || REGNO (XEXP (rtl, 0)) == ARG_POINTER_REGNUM
7110 /* Big endian correction check. */
7112 && TYPE_MODE (TREE_TYPE (decl)) != GET_MODE (rtl)
7113 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)))
7116 int offset = (UNITS_PER_WORD
7117 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl))));
7118 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
7119 plus_constant (XEXP (rtl, 0), offset));
7123 if (rtl == NULL_RTX)
7126 rtl = eliminate_regs (rtl, 0, NULL_RTX);
7127 #ifdef LEAF_REG_REMAP
7128 if (current_function_uses_only_leaf_regs)
7129 leaf_renumber_regs_insn (rtl);
7132 switch (GET_CODE (rtl))
7135 /* The address of a variable that was optimized away; don't emit
7146 /* DECL_RTL could be (plus (reg ...) (const_int ...)) */
7147 add_const_value_attribute (die, rtl);
7154 add_AT_location_description (die, DW_AT_location, rtl);
7162 /* Generate an DW_AT_name attribute given some string value to be included as
7163 the value of the attribute. */
7166 add_name_attribute (die, name_string)
7167 register dw_die_ref die;
7168 register const char *name_string;
7170 if (name_string != NULL && *name_string != 0)
7172 if (demangle_name_func)
7173 name_string = (*demangle_name_func) (name_string);
7175 add_AT_string (die, DW_AT_name, name_string);
7179 /* Given a tree node describing an array bound (either lower or upper) output
7180 a representation for that bound. */
7183 add_bound_info (subrange_die, bound_attr, bound)
7184 register dw_die_ref subrange_die;
7185 register enum dwarf_attribute bound_attr;
7186 register tree bound;
7188 register unsigned bound_value = 0;
7190 /* If this is an Ada unconstrained array type, then don't emit any debug
7191 info because the array bounds are unknown. They are parameterized when
7192 the type is instantiated. */
7193 if (contains_placeholder_p (bound))
7196 switch (TREE_CODE (bound))
7201 /* All fixed-bounds are represented by INTEGER_CST nodes. */
7203 bound_value = TREE_INT_CST_LOW (bound);
7204 if (bound_attr == DW_AT_lower_bound
7205 && ((is_c_family () && bound_value == 0)
7206 || (is_fortran () && bound_value == 1)))
7207 /* use the default */;
7209 add_AT_unsigned (subrange_die, bound_attr, bound_value);
7214 case NON_LVALUE_EXPR:
7215 add_bound_info (subrange_die, bound_attr, TREE_OPERAND (bound, 0));
7219 /* If optimization is turned on, the SAVE_EXPRs that describe how to
7220 access the upper bound values may be bogus. If they refer to a
7221 register, they may only describe how to get at these values at the
7222 points in the generated code right after they have just been
7223 computed. Worse yet, in the typical case, the upper bound values
7224 will not even *be* computed in the optimized code (though the
7225 number of elements will), so these SAVE_EXPRs are entirely
7226 bogus. In order to compensate for this fact, we check here to see
7227 if optimization is enabled, and if so, we don't add an attribute
7228 for the (unknown and unknowable) upper bound. This should not
7229 cause too much trouble for existing (stupid?) debuggers because
7230 they have to deal with empty upper bounds location descriptions
7231 anyway in order to be able to deal with incomplete array types.
7232 Of course an intelligent debugger (GDB?) should be able to
7233 comprehend that a missing upper bound specification in a array
7234 type used for a storage class `auto' local array variable
7235 indicates that the upper bound is both unknown (at compile- time)
7236 and unknowable (at run-time) due to optimization.
7238 We assume that a MEM rtx is safe because gcc wouldn't put the
7239 value there unless it was going to be used repeatedly in the
7240 function, i.e. for cleanups. */
7241 if (! optimize || GET_CODE (SAVE_EXPR_RTL (bound)) == MEM)
7243 register dw_die_ref ctx = lookup_decl_die (current_function_decl);
7244 register dw_die_ref decl_die = new_die (DW_TAG_variable, ctx);
7245 register rtx loc = SAVE_EXPR_RTL (bound);
7247 /* If the RTL for the SAVE_EXPR is memory, handle the case where
7248 it references an outer function's frame. */
7250 if (GET_CODE (loc) == MEM)
7252 rtx new_addr = fix_lexical_addr (XEXP (loc, 0), bound);
7254 if (XEXP (loc, 0) != new_addr)
7255 loc = gen_rtx_MEM (GET_MODE (loc), new_addr);
7258 add_AT_flag (decl_die, DW_AT_artificial, 1);
7259 add_type_attribute (decl_die, TREE_TYPE (bound), 1, 0, ctx);
7260 add_AT_location_description (decl_die, DW_AT_location, loc);
7261 add_AT_die_ref (subrange_die, bound_attr, decl_die);
7264 /* Else leave out the attribute. */
7270 /* ??? These types of bounds can be created by the Ada front end,
7271 and it isn't clear how to emit debug info for them. */
7279 /* Note that the block of subscript information for an array type also
7280 includes information about the element type of type given array type. */
7283 add_subscript_info (type_die, type)
7284 register dw_die_ref type_die;
7287 #ifndef MIPS_DEBUGGING_INFO
7288 register unsigned dimension_number;
7290 register tree lower, upper;
7291 register dw_die_ref subrange_die;
7293 /* The GNU compilers represent multidimensional array types as sequences of
7294 one dimensional array types whose element types are themselves array
7295 types. Here we squish that down, so that each multidimensional array
7296 type gets only one array_type DIE in the Dwarf debugging info. The draft
7297 Dwarf specification say that we are allowed to do this kind of
7298 compression in C (because there is no difference between an array or
7299 arrays and a multidimensional array in C) but for other source languages
7300 (e.g. Ada) we probably shouldn't do this. */
7302 /* ??? The SGI dwarf reader fails for multidimensional arrays with a
7303 const enum type. E.g. const enum machine_mode insn_operand_mode[2][10].
7304 We work around this by disabling this feature. See also
7305 gen_array_type_die. */
7306 #ifndef MIPS_DEBUGGING_INFO
7307 for (dimension_number = 0;
7308 TREE_CODE (type) == ARRAY_TYPE;
7309 type = TREE_TYPE (type), dimension_number++)
7312 register tree domain = TYPE_DOMAIN (type);
7314 /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
7315 and (in GNU C only) variable bounds. Handle all three forms
7317 subrange_die = new_die (DW_TAG_subrange_type, type_die);
7320 /* We have an array type with specified bounds. */
7321 lower = TYPE_MIN_VALUE (domain);
7322 upper = TYPE_MAX_VALUE (domain);
7324 /* define the index type. */
7325 if (TREE_TYPE (domain))
7327 /* ??? This is probably an Ada unnamed subrange type. Ignore the
7328 TREE_TYPE field. We can't emit debug info for this
7329 because it is an unnamed integral type. */
7330 if (TREE_CODE (domain) == INTEGER_TYPE
7331 && TYPE_NAME (domain) == NULL_TREE
7332 && TREE_CODE (TREE_TYPE (domain)) == INTEGER_TYPE
7333 && TYPE_NAME (TREE_TYPE (domain)) == NULL_TREE)
7336 add_type_attribute (subrange_die, TREE_TYPE (domain), 0, 0,
7340 /* ??? If upper is NULL, the array has unspecified length,
7341 but it does have a lower bound. This happens with Fortran
7343 Since the debugger is definitely going to need to know N
7344 to produce useful results, go ahead and output the lower
7345 bound solo, and hope the debugger can cope. */
7347 add_bound_info (subrange_die, DW_AT_lower_bound, lower);
7349 add_bound_info (subrange_die, DW_AT_upper_bound, upper);
7352 /* We have an array type with an unspecified length. The DWARF-2
7353 spec does not say how to handle this; let's just leave out the
7358 #ifndef MIPS_DEBUGGING_INFO
7364 add_byte_size_attribute (die, tree_node)
7366 register tree tree_node;
7368 register unsigned size;
7370 switch (TREE_CODE (tree_node))
7378 case QUAL_UNION_TYPE:
7379 size = int_size_in_bytes (tree_node);
7382 /* For a data member of a struct or union, the DW_AT_byte_size is
7383 generally given as the number of bytes normally allocated for an
7384 object of the *declared* type of the member itself. This is true
7385 even for bit-fields. */
7386 size = simple_type_size_in_bits (field_type (tree_node)) / BITS_PER_UNIT;
7392 /* Note that `size' might be -1 when we get to this point. If it is, that
7393 indicates that the byte size of the entity in question is variable. We
7394 have no good way of expressing this fact in Dwarf at the present time,
7395 so just let the -1 pass on through. */
7397 add_AT_unsigned (die, DW_AT_byte_size, size);
7400 /* For a FIELD_DECL node which represents a bit-field, output an attribute
7401 which specifies the distance in bits from the highest order bit of the
7402 "containing object" for the bit-field to the highest order bit of the
7405 For any given bit-field, the "containing object" is a hypothetical
7406 object (of some integral or enum type) within which the given bit-field
7407 lives. The type of this hypothetical "containing object" is always the
7408 same as the declared type of the individual bit-field itself. The
7409 determination of the exact location of the "containing object" for a
7410 bit-field is rather complicated. It's handled by the
7411 `field_byte_offset' function (above).
7413 Note that it is the size (in bytes) of the hypothetical "containing object"
7414 which will be given in the DW_AT_byte_size attribute for this bit-field.
7415 (See `byte_size_attribute' above). */
7418 add_bit_offset_attribute (die, decl)
7419 register dw_die_ref die;
7422 register unsigned object_offset_in_bytes = field_byte_offset (decl);
7423 register tree type = DECL_BIT_FIELD_TYPE (decl);
7424 register tree bitpos_tree = DECL_FIELD_BITPOS (decl);
7425 register unsigned bitpos_int;
7426 register unsigned highest_order_object_bit_offset;
7427 register unsigned highest_order_field_bit_offset;
7428 register unsigned bit_offset;
7430 /* Must be a field and a bit field. */
7432 || TREE_CODE (decl) != FIELD_DECL)
7435 /* We can't yet handle bit-fields whose offsets are variable, so if we
7436 encounter such things, just return without generating any attribute
7438 if (TREE_CODE (bitpos_tree) != INTEGER_CST)
7441 bitpos_int = (unsigned) TREE_INT_CST_LOW (bitpos_tree);
7443 /* Note that the bit offset is always the distance (in bits) from the
7444 highest-order bit of the "containing object" to the highest-order bit of
7445 the bit-field itself. Since the "high-order end" of any object or field
7446 is different on big-endian and little-endian machines, the computation
7447 below must take account of these differences. */
7448 highest_order_object_bit_offset = object_offset_in_bytes * BITS_PER_UNIT;
7449 highest_order_field_bit_offset = bitpos_int;
7451 if (! BYTES_BIG_ENDIAN)
7453 highest_order_field_bit_offset
7454 += (unsigned) TREE_INT_CST_LOW (DECL_SIZE (decl));
7456 highest_order_object_bit_offset += simple_type_size_in_bits (type);
7460 = (! BYTES_BIG_ENDIAN
7461 ? highest_order_object_bit_offset - highest_order_field_bit_offset
7462 : highest_order_field_bit_offset - highest_order_object_bit_offset);
7464 add_AT_unsigned (die, DW_AT_bit_offset, bit_offset);
7467 /* For a FIELD_DECL node which represents a bit field, output an attribute
7468 which specifies the length in bits of the given field. */
7471 add_bit_size_attribute (die, decl)
7472 register dw_die_ref die;
7475 /* Must be a field and a bit field. */
7476 if (TREE_CODE (decl) != FIELD_DECL
7477 || ! DECL_BIT_FIELD_TYPE (decl))
7479 add_AT_unsigned (die, DW_AT_bit_size,
7480 (unsigned) TREE_INT_CST_LOW (DECL_SIZE (decl)));
7483 /* If the compiled language is ANSI C, then add a 'prototyped'
7484 attribute, if arg types are given for the parameters of a function. */
7487 add_prototyped_attribute (die, func_type)
7488 register dw_die_ref die;
7489 register tree func_type;
7491 if (get_AT_unsigned (comp_unit_die, DW_AT_language) == DW_LANG_C89
7492 && TYPE_ARG_TYPES (func_type) != NULL)
7493 add_AT_flag (die, DW_AT_prototyped, 1);
7497 /* Add an 'abstract_origin' attribute below a given DIE. The DIE is found
7498 by looking in either the type declaration or object declaration
7502 add_abstract_origin_attribute (die, origin)
7503 register dw_die_ref die;
7504 register tree origin;
7506 dw_die_ref origin_die = NULL;
7508 /* We may have gotten separated from the block for the inlined
7509 function, if we're in an exception handler or some such; make
7510 sure that the abstract function has been written out. */
7511 tree fn = decl_function_context (origin);
7513 gen_abstract_function (fn);
7515 if (TREE_CODE_CLASS (TREE_CODE (origin)) == 'd')
7516 origin_die = lookup_decl_die (origin);
7517 else if (TREE_CODE_CLASS (TREE_CODE (origin)) == 't')
7518 origin_die = lookup_type_die (origin);
7520 if (origin_die == NULL)
7523 add_AT_die_ref (die, DW_AT_abstract_origin, origin_die);
7526 /* We do not currently support the pure_virtual attribute. */
7529 add_pure_or_virtual_attribute (die, func_decl)
7530 register dw_die_ref die;
7531 register tree func_decl;
7533 if (DECL_VINDEX (func_decl))
7535 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
7536 add_AT_loc (die, DW_AT_vtable_elem_location,
7537 new_loc_descr (DW_OP_constu,
7538 TREE_INT_CST_LOW (DECL_VINDEX (func_decl)),
7541 /* GNU extension: Record what type this method came from originally. */
7542 if (debug_info_level > DINFO_LEVEL_TERSE)
7543 add_AT_die_ref (die, DW_AT_containing_type,
7544 lookup_type_die (DECL_CONTEXT (func_decl)));
7548 /* Add source coordinate attributes for the given decl. */
7551 add_src_coords_attributes (die, decl)
7552 register dw_die_ref die;
7555 register unsigned file_index = lookup_filename (DECL_SOURCE_FILE (decl));
7557 add_AT_unsigned (die, DW_AT_decl_file, file_index);
7558 add_AT_unsigned (die, DW_AT_decl_line, DECL_SOURCE_LINE (decl));
7561 /* Add an DW_AT_name attribute and source coordinate attribute for the
7562 given decl, but only if it actually has a name. */
7565 add_name_and_src_coords_attributes (die, decl)
7566 register dw_die_ref die;
7569 register tree decl_name;
7571 decl_name = DECL_NAME (decl);
7572 if (decl_name != NULL && IDENTIFIER_POINTER (decl_name) != NULL)
7574 add_name_attribute (die, dwarf2_name (decl, 0));
7575 if (! DECL_ARTIFICIAL (decl))
7576 add_src_coords_attributes (die, decl);
7578 if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
7579 && DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
7580 add_AT_string (die, DW_AT_MIPS_linkage_name,
7581 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
7585 /* Push a new declaration scope. */
7588 push_decl_scope (scope)
7591 /* Make room in the decl_scope_table, if necessary. */
7592 if (decl_scope_table_allocated == decl_scope_depth)
7594 decl_scope_table_allocated += DECL_SCOPE_TABLE_INCREMENT;
7596 = (tree *) xrealloc (decl_scope_table,
7597 decl_scope_table_allocated * sizeof (tree));
7600 decl_scope_table[decl_scope_depth] = scope;
7604 /* Pop a declaration scope. */
7608 if (decl_scope_depth <= 0)
7613 /* Return the DIE for the scope that immediately contains this type.
7614 Non-named types get global scope. Named types nested in other
7615 types get their containing scope if it's open, or global scope
7616 otherwise. All other types (i.e. function-local named types) get
7617 the current active scope. */
7620 scope_die_for (t, context_die)
7622 register dw_die_ref context_die;
7624 register dw_die_ref scope_die = NULL;
7625 register tree containing_scope;
7628 /* Non-types always go in the current scope. */
7632 containing_scope = TYPE_CONTEXT (t);
7634 /* Ignore namespaces for the moment. */
7635 if (containing_scope && TREE_CODE (containing_scope) == NAMESPACE_DECL)
7636 containing_scope = NULL_TREE;
7638 /* Ignore function type "scopes" from the C frontend. They mean that
7639 a tagged type is local to a parmlist of a function declarator, but
7640 that isn't useful to DWARF. */
7641 if (containing_scope && TREE_CODE (containing_scope) == FUNCTION_TYPE)
7642 containing_scope = NULL_TREE;
7644 if (containing_scope == NULL_TREE)
7645 scope_die = comp_unit_die;
7646 else if (TYPE_P (containing_scope))
7648 /* For types, we can just look up the appropriate DIE. But
7649 first we check to see if we're in the middle of emitting it
7650 so we know where the new DIE should go. */
7652 for (i = decl_scope_depth - 1; i >= 0; --i)
7653 if (decl_scope_table[i] == containing_scope)
7658 if (debug_info_level > DINFO_LEVEL_TERSE
7659 && !TREE_ASM_WRITTEN (containing_scope))
7662 /* If none of the current dies are suitable, we get file scope. */
7663 scope_die = comp_unit_die;
7666 scope_die = lookup_type_die (containing_scope);
7669 scope_die = context_die;
7674 /* Returns nonzero iff CONTEXT_DIE is internal to a function. */
7677 local_scope_p (context_die)
7678 dw_die_ref context_die;
7680 for (; context_die; context_die = context_die->die_parent)
7681 if (context_die->die_tag == DW_TAG_inlined_subroutine
7682 || context_die->die_tag == DW_TAG_subprogram)
7687 /* Returns nonzero iff CONTEXT_DIE is a class. */
7690 class_scope_p (context_die)
7691 dw_die_ref context_die;
7694 && (context_die->die_tag == DW_TAG_structure_type
7695 || context_die->die_tag == DW_TAG_union_type));
7698 /* Many forms of DIEs require a "type description" attribute. This
7699 routine locates the proper "type descriptor" die for the type given
7700 by 'type', and adds an DW_AT_type attribute below the given die. */
7703 add_type_attribute (object_die, type, decl_const, decl_volatile, context_die)
7704 register dw_die_ref object_die;
7706 register int decl_const;
7707 register int decl_volatile;
7708 register dw_die_ref context_die;
7710 register enum tree_code code = TREE_CODE (type);
7711 register dw_die_ref type_die = NULL;
7713 /* ??? If this type is an unnamed subrange type of an integral or
7714 floating-point type, use the inner type. This is because we have no
7715 support for unnamed types in base_type_die. This can happen if this is
7716 an Ada subrange type. Correct solution is emit a subrange type die. */
7717 if ((code == INTEGER_TYPE || code == REAL_TYPE)
7718 && TREE_TYPE (type) != 0 && TYPE_NAME (type) == 0)
7719 type = TREE_TYPE (type), code = TREE_CODE (type);
7721 if (code == ERROR_MARK)
7724 /* Handle a special case. For functions whose return type is void, we
7725 generate *no* type attribute. (Note that no object may have type
7726 `void', so this only applies to function return types). */
7727 if (code == VOID_TYPE)
7730 type_die = modified_type_die (type,
7731 decl_const || TYPE_READONLY (type),
7732 decl_volatile || TYPE_VOLATILE (type),
7734 if (type_die != NULL)
7735 add_AT_die_ref (object_die, DW_AT_type, type_die);
7738 /* Given a tree pointer to a struct, class, union, or enum type node, return
7739 a pointer to the (string) tag name for the given type, or zero if the type
7740 was declared without a tag. */
7746 register char *name = 0;
7748 if (TYPE_NAME (type) != 0)
7750 register tree t = 0;
7752 /* Find the IDENTIFIER_NODE for the type name. */
7753 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
7754 t = TYPE_NAME (type);
7756 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
7757 a TYPE_DECL node, regardless of whether or not a `typedef' was
7759 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
7760 && ! DECL_IGNORED_P (TYPE_NAME (type)))
7761 t = DECL_NAME (TYPE_NAME (type));
7763 /* Now get the name as a string, or invent one. */
7765 name = IDENTIFIER_POINTER (t);
7768 return (name == 0 || *name == '\0') ? 0 : name;
7771 /* Return the type associated with a data member, make a special check
7772 for bit field types. */
7775 member_declared_type (member)
7776 register tree member;
7778 return (DECL_BIT_FIELD_TYPE (member)
7779 ? DECL_BIT_FIELD_TYPE (member)
7780 : TREE_TYPE (member));
7783 /* Get the decl's label, as described by its RTL. This may be different
7784 from the DECL_NAME name used in the source file. */
7788 decl_start_label (decl)
7793 x = DECL_RTL (decl);
7794 if (GET_CODE (x) != MEM)
7798 if (GET_CODE (x) != SYMBOL_REF)
7801 fnname = XSTR (x, 0);
7806 /* These routines generate the internal representation of the DIE's for
7807 the compilation unit. Debugging information is collected by walking
7808 the declaration trees passed in from dwarf2out_decl(). */
7811 gen_array_type_die (type, context_die)
7813 register dw_die_ref context_die;
7815 register dw_die_ref scope_die = scope_die_for (type, context_die);
7816 register dw_die_ref array_die;
7817 register tree element_type;
7819 /* ??? The SGI dwarf reader fails for array of array of enum types unless
7820 the inner array type comes before the outer array type. Thus we must
7821 call gen_type_die before we call new_die. See below also. */
7822 #ifdef MIPS_DEBUGGING_INFO
7823 gen_type_die (TREE_TYPE (type), context_die);
7826 array_die = new_die (DW_TAG_array_type, scope_die);
7829 /* We default the array ordering. SDB will probably do
7830 the right things even if DW_AT_ordering is not present. It's not even
7831 an issue until we start to get into multidimensional arrays anyway. If
7832 SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
7833 then we'll have to put the DW_AT_ordering attribute back in. (But if
7834 and when we find out that we need to put these in, we will only do so
7835 for multidimensional arrays. */
7836 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major);
7839 #ifdef MIPS_DEBUGGING_INFO
7840 /* The SGI compilers handle arrays of unknown bound by setting
7841 AT_declaration and not emitting any subrange DIEs. */
7842 if (! TYPE_DOMAIN (type))
7843 add_AT_unsigned (array_die, DW_AT_declaration, 1);
7846 add_subscript_info (array_die, type);
7848 add_name_attribute (array_die, type_tag (type));
7849 equate_type_number_to_die (type, array_die);
7851 /* Add representation of the type of the elements of this array type. */
7852 element_type = TREE_TYPE (type);
7854 /* ??? The SGI dwarf reader fails for multidimensional arrays with a
7855 const enum type. E.g. const enum machine_mode insn_operand_mode[2][10].
7856 We work around this by disabling this feature. See also
7857 add_subscript_info. */
7858 #ifndef MIPS_DEBUGGING_INFO
7859 while (TREE_CODE (element_type) == ARRAY_TYPE)
7860 element_type = TREE_TYPE (element_type);
7862 gen_type_die (element_type, context_die);
7865 add_type_attribute (array_die, element_type, 0, 0, context_die);
7869 gen_set_type_die (type, context_die)
7871 register dw_die_ref context_die;
7873 register dw_die_ref type_die
7874 = new_die (DW_TAG_set_type, scope_die_for (type, context_die));
7876 equate_type_number_to_die (type, type_die);
7877 add_type_attribute (type_die, TREE_TYPE (type), 0, 0, context_die);
7882 gen_entry_point_die (decl, context_die)
7884 register dw_die_ref context_die;
7886 register tree origin = decl_ultimate_origin (decl);
7887 register dw_die_ref decl_die = new_die (DW_TAG_entry_point, context_die);
7889 add_abstract_origin_attribute (decl_die, origin);
7892 add_name_and_src_coords_attributes (decl_die, decl);
7893 add_type_attribute (decl_die, TREE_TYPE (TREE_TYPE (decl)),
7897 if (DECL_ABSTRACT (decl))
7898 equate_decl_number_to_die (decl, decl_die);
7900 add_AT_lbl_id (decl_die, DW_AT_low_pc, decl_start_label (decl));
7904 /* Remember a type in the incomplete_types_list. */
7907 add_incomplete_type (type)
7910 if (incomplete_types == incomplete_types_allocated)
7912 incomplete_types_allocated += INCOMPLETE_TYPES_INCREMENT;
7913 incomplete_types_list
7914 = (tree *) xrealloc (incomplete_types_list,
7915 sizeof (tree) * incomplete_types_allocated);
7918 incomplete_types_list[incomplete_types++] = type;
7921 /* Walk through the list of incomplete types again, trying once more to
7922 emit full debugging info for them. */
7925 retry_incomplete_types ()
7929 while (incomplete_types)
7932 type = incomplete_types_list[incomplete_types];
7933 gen_type_die (type, comp_unit_die);
7937 /* Generate a DIE to represent an inlined instance of an enumeration type. */
7940 gen_inlined_enumeration_type_die (type, context_die)
7942 register dw_die_ref context_die;
7944 register dw_die_ref type_die = new_die (DW_TAG_enumeration_type,
7946 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
7947 be incomplete and such types are not marked. */
7948 add_abstract_origin_attribute (type_die, type);
7951 /* Generate a DIE to represent an inlined instance of a structure type. */
7954 gen_inlined_structure_type_die (type, context_die)
7956 register dw_die_ref context_die;
7958 register dw_die_ref type_die = new_die (DW_TAG_structure_type, context_die);
7960 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
7961 be incomplete and such types are not marked. */
7962 add_abstract_origin_attribute (type_die, type);
7965 /* Generate a DIE to represent an inlined instance of a union type. */
7968 gen_inlined_union_type_die (type, context_die)
7970 register dw_die_ref context_die;
7972 register dw_die_ref type_die = new_die (DW_TAG_union_type, context_die);
7974 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
7975 be incomplete and such types are not marked. */
7976 add_abstract_origin_attribute (type_die, type);
7979 /* Generate a DIE to represent an enumeration type. Note that these DIEs
7980 include all of the information about the enumeration values also. Each
7981 enumerated type name/value is listed as a child of the enumerated type
7985 gen_enumeration_type_die (type, context_die)
7987 register dw_die_ref context_die;
7989 register dw_die_ref type_die = lookup_type_die (type);
7991 if (type_die == NULL)
7993 type_die = new_die (DW_TAG_enumeration_type,
7994 scope_die_for (type, context_die));
7995 equate_type_number_to_die (type, type_die);
7996 add_name_attribute (type_die, type_tag (type));
7998 else if (! TYPE_SIZE (type))
8001 remove_AT (type_die, DW_AT_declaration);
8003 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the
8004 given enum type is incomplete, do not generate the DW_AT_byte_size
8005 attribute or the DW_AT_element_list attribute. */
8006 if (TYPE_SIZE (type))
8010 TREE_ASM_WRITTEN (type) = 1;
8011 add_byte_size_attribute (type_die, type);
8012 if (TYPE_STUB_DECL (type) != NULL_TREE)
8013 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
8015 /* If the first reference to this type was as the return type of an
8016 inline function, then it may not have a parent. Fix this now. */
8017 if (type_die->die_parent == NULL)
8018 add_child_die (scope_die_for (type, context_die), type_die);
8020 for (link = TYPE_FIELDS (type);
8021 link != NULL; link = TREE_CHAIN (link))
8023 register dw_die_ref enum_die = new_die (DW_TAG_enumerator, type_die);
8025 add_name_attribute (enum_die,
8026 IDENTIFIER_POINTER (TREE_PURPOSE (link)));
8027 add_AT_unsigned (enum_die, DW_AT_const_value,
8028 (unsigned) TREE_INT_CST_LOW (TREE_VALUE (link)));
8032 add_AT_flag (type_die, DW_AT_declaration, 1);
8036 /* Generate a DIE to represent either a real live formal parameter decl or to
8037 represent just the type of some formal parameter position in some function
8040 Note that this routine is a bit unusual because its argument may be a
8041 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
8042 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
8043 node. If it's the former then this function is being called to output a
8044 DIE to represent a formal parameter object (or some inlining thereof). If
8045 it's the latter, then this function is only being called to output a
8046 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
8047 argument type of some subprogram type. */
8050 gen_formal_parameter_die (node, context_die)
8052 register dw_die_ref context_die;
8054 register dw_die_ref parm_die
8055 = new_die (DW_TAG_formal_parameter, context_die);
8056 register tree origin;
8058 switch (TREE_CODE_CLASS (TREE_CODE (node)))
8061 origin = decl_ultimate_origin (node);
8063 add_abstract_origin_attribute (parm_die, origin);
8066 add_name_and_src_coords_attributes (parm_die, node);
8067 add_type_attribute (parm_die, TREE_TYPE (node),
8068 TREE_READONLY (node),
8069 TREE_THIS_VOLATILE (node),
8071 if (DECL_ARTIFICIAL (node))
8072 add_AT_flag (parm_die, DW_AT_artificial, 1);
8075 equate_decl_number_to_die (node, parm_die);
8076 if (! DECL_ABSTRACT (node))
8077 add_location_or_const_value_attribute (parm_die, node);
8082 /* We were called with some kind of a ..._TYPE node. */
8083 add_type_attribute (parm_die, node, 0, 0, context_die);
8093 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
8094 at the end of an (ANSI prototyped) formal parameters list. */
8097 gen_unspecified_parameters_die (decl_or_type, context_die)
8098 register tree decl_or_type ATTRIBUTE_UNUSED;
8099 register dw_die_ref context_die;
8101 new_die (DW_TAG_unspecified_parameters, context_die);
8104 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
8105 DW_TAG_unspecified_parameters DIE) to represent the types of the formal
8106 parameters as specified in some function type specification (except for
8107 those which appear as part of a function *definition*).
8109 Note we must be careful here to output all of the parameter DIEs before*
8110 we output any DIEs needed to represent the types of the formal parameters.
8111 This keeps svr4 SDB happy because it (incorrectly) thinks that the first
8112 non-parameter DIE it sees ends the formal parameter list. */
8115 gen_formal_types_die (function_or_method_type, context_die)
8116 register tree function_or_method_type;
8117 register dw_die_ref context_die;
8120 register tree formal_type = NULL;
8121 register tree first_parm_type = TYPE_ARG_TYPES (function_or_method_type);
8124 /* In the case where we are generating a formal types list for a C++
8125 non-static member function type, skip over the first thing on the
8126 TYPE_ARG_TYPES list because it only represents the type of the hidden
8127 `this pointer'. The debugger should be able to figure out (without
8128 being explicitly told) that this non-static member function type takes a
8129 `this pointer' and should be able to figure what the type of that hidden
8130 parameter is from the DW_AT_member attribute of the parent
8131 DW_TAG_subroutine_type DIE. */
8132 if (TREE_CODE (function_or_method_type) == METHOD_TYPE)
8133 first_parm_type = TREE_CHAIN (first_parm_type);
8136 /* Make our first pass over the list of formal parameter types and output a
8137 DW_TAG_formal_parameter DIE for each one. */
8138 for (link = first_parm_type; link; link = TREE_CHAIN (link))
8140 register dw_die_ref parm_die;
8142 formal_type = TREE_VALUE (link);
8143 if (formal_type == void_type_node)
8146 /* Output a (nameless) DIE to represent the formal parameter itself. */
8147 parm_die = gen_formal_parameter_die (formal_type, context_die);
8148 if (TREE_CODE (function_or_method_type) == METHOD_TYPE
8149 && link == first_parm_type)
8150 add_AT_flag (parm_die, DW_AT_artificial, 1);
8153 /* If this function type has an ellipsis, add a
8154 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */
8155 if (formal_type != void_type_node)
8156 gen_unspecified_parameters_die (function_or_method_type, context_die);
8158 /* Make our second (and final) pass over the list of formal parameter types
8159 and output DIEs to represent those types (as necessary). */
8160 for (link = TYPE_ARG_TYPES (function_or_method_type);
8162 link = TREE_CHAIN (link))
8164 formal_type = TREE_VALUE (link);
8165 if (formal_type == void_type_node)
8168 gen_type_die (formal_type, context_die);
8172 /* We want to generate the DIE for TYPE so that we can generate the
8173 die for MEMBER, which has been defined; we will need to refer back
8174 to the member declaration nested within TYPE. If we're trying to
8175 generate minimal debug info for TYPE, processing TYPE won't do the
8176 trick; we need to attach the member declaration by hand. */
8179 gen_type_die_for_member (type, member, context_die)
8181 dw_die_ref context_die;
8183 gen_type_die (type, context_die);
8185 /* If we're trying to avoid duplicate debug info, we may not have
8186 emitted the member decl for this function. Emit it now. */
8187 if (TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))
8188 && ! lookup_decl_die (member))
8190 if (decl_ultimate_origin (member))
8193 push_decl_scope (type);
8194 if (TREE_CODE (member) == FUNCTION_DECL)
8195 gen_subprogram_die (member, lookup_type_die (type));
8197 gen_variable_die (member, lookup_type_die (type));
8202 /* Generate the DWARF2 info for the "abstract" instance
8203 of a function which we may later generate inlined and/or
8204 out-of-line instances of. */
8207 gen_abstract_function (decl)
8210 register dw_die_ref old_die = lookup_decl_die (decl);
8213 if (old_die && get_AT_unsigned (old_die, DW_AT_inline))
8214 /* We've already generated the abstract instance. */
8217 save_fn = current_function_decl;
8218 current_function_decl = decl;
8220 set_decl_abstract_flags (decl, 1);
8221 dwarf2out_decl (decl);
8222 set_decl_abstract_flags (decl, 0);
8224 current_function_decl = save_fn;
8227 /* Generate a DIE to represent a declared function (either file-scope or
8231 gen_subprogram_die (decl, context_die)
8233 register dw_die_ref context_die;
8235 char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
8236 register tree origin = decl_ultimate_origin (decl);
8237 register dw_die_ref subr_die;
8238 register rtx fp_reg;
8239 register tree fn_arg_types;
8240 register tree outer_scope;
8241 register dw_die_ref old_die = lookup_decl_die (decl);
8242 register int declaration = (current_function_decl != decl
8243 || class_scope_p (context_die));
8245 /* Note that it is possible to have both DECL_ABSTRACT and `declaration'
8246 be true, if we started to generate the abstract instance of an inline,
8247 decided to output its containing class, and proceeded to emit the
8248 declaration of the inline from the member list for the class. In that
8249 case, `declaration' takes priority; we'll get back to the abstract
8250 instance when we're done with the class. */
8254 if (declaration && ! local_scope_p (context_die))
8257 subr_die = new_die (DW_TAG_subprogram, context_die);
8258 add_abstract_origin_attribute (subr_die, origin);
8260 else if (old_die && DECL_ABSTRACT (decl)
8261 && get_AT_unsigned (old_die, DW_AT_inline))
8263 /* This must be a redefinition of an extern inline function.
8264 We can just reuse the old die here. */
8267 /* Clear out the inlined attribute and parm types. */
8268 remove_AT (subr_die, DW_AT_inline);
8269 remove_children (subr_die);
8273 register unsigned file_index
8274 = lookup_filename (DECL_SOURCE_FILE (decl));
8276 if (get_AT_flag (old_die, DW_AT_declaration) != 1)
8278 /* ??? This can happen if there is a bug in the program, for
8279 instance, if it has duplicate function definitions. Ideally,
8280 we should detect this case and ignore it. For now, if we have
8281 already reported an error, any error at all, then assume that
8282 we got here because of a input error, not a dwarf2 bug. */
8288 /* If the definition comes from the same place as the declaration,
8289 maybe use the old DIE. We always want the DIE for this function
8290 that has the *_pc attributes to be under comp_unit_die so the
8291 debugger can find it. For inlines, that is the concrete instance,
8292 so we can use the old DIE here. For non-inline methods, we want a
8293 specification DIE at toplevel, so we need a new DIE. For local
8294 class methods, this doesn't apply; we just use the old DIE. */
8295 if ((DECL_ABSTRACT (decl) || old_die->die_parent == comp_unit_die
8296 || context_die == NULL)
8297 && (DECL_ARTIFICIAL (decl)
8298 || (get_AT_unsigned (old_die, DW_AT_decl_file) == file_index
8299 && (get_AT_unsigned (old_die, DW_AT_decl_line)
8300 == (unsigned)DECL_SOURCE_LINE (decl)))))
8304 /* Clear out the declaration attribute and the parm types. */
8305 remove_AT (subr_die, DW_AT_declaration);
8306 remove_children (subr_die);
8310 subr_die = new_die (DW_TAG_subprogram, context_die);
8311 add_AT_die_ref (subr_die, DW_AT_specification, old_die);
8312 if (get_AT_unsigned (old_die, DW_AT_decl_file) != file_index)
8313 add_AT_unsigned (subr_die, DW_AT_decl_file, file_index);
8314 if (get_AT_unsigned (old_die, DW_AT_decl_line)
8315 != (unsigned)DECL_SOURCE_LINE (decl))
8317 (subr_die, DW_AT_decl_line, DECL_SOURCE_LINE (decl));
8322 subr_die = new_die (DW_TAG_subprogram, context_die);
8324 if (TREE_PUBLIC (decl))
8325 add_AT_flag (subr_die, DW_AT_external, 1);
8327 add_name_and_src_coords_attributes (subr_die, decl);
8328 if (debug_info_level > DINFO_LEVEL_TERSE)
8330 register tree type = TREE_TYPE (decl);
8332 add_prototyped_attribute (subr_die, type);
8333 add_type_attribute (subr_die, TREE_TYPE (type), 0, 0, context_die);
8336 add_pure_or_virtual_attribute (subr_die, decl);
8337 if (DECL_ARTIFICIAL (decl))
8338 add_AT_flag (subr_die, DW_AT_artificial, 1);
8339 if (TREE_PROTECTED (decl))
8340 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_protected);
8341 else if (TREE_PRIVATE (decl))
8342 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_private);
8348 add_AT_flag (subr_die, DW_AT_declaration, 1);
8350 /* The first time we see a member function, it is in the context of
8351 the class to which it belongs. We make sure of this by emitting
8352 the class first. The next time is the definition, which is
8353 handled above. The two may come from the same source text. */
8354 if (DECL_CONTEXT (decl) || DECL_ABSTRACT (decl))
8355 equate_decl_number_to_die (decl, subr_die);
8357 else if (DECL_ABSTRACT (decl))
8359 if (DECL_INLINE (decl) && !flag_no_inline)
8361 /* ??? Checking DECL_DEFER_OUTPUT is correct for static
8362 inline functions, but not for extern inline functions.
8363 We can't get this completely correct because information
8364 about whether the function was declared inline is not
8366 if (DECL_DEFER_OUTPUT (decl))
8367 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_inlined);
8369 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_inlined);
8372 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_not_inlined);
8374 equate_decl_number_to_die (decl, subr_die);
8376 else if (!DECL_EXTERNAL (decl))
8378 if (origin == NULL_TREE)
8379 equate_decl_number_to_die (decl, subr_die);
8381 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_BEGIN_LABEL,
8382 current_funcdef_number);
8383 add_AT_lbl_id (subr_die, DW_AT_low_pc, label_id);
8384 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
8385 current_funcdef_number);
8386 add_AT_lbl_id (subr_die, DW_AT_high_pc, label_id);
8388 add_pubname (decl, subr_die);
8389 add_arange (decl, subr_die);
8391 #ifdef MIPS_DEBUGGING_INFO
8392 /* Add a reference to the FDE for this routine. */
8393 add_AT_fde_ref (subr_die, DW_AT_MIPS_fde, current_funcdef_fde);
8396 /* Define the "frame base" location for this routine. We use the
8397 frame pointer or stack pointer registers, since the RTL for local
8398 variables is relative to one of them. */
8400 = frame_pointer_needed ? hard_frame_pointer_rtx : stack_pointer_rtx;
8401 add_AT_loc (subr_die, DW_AT_frame_base, reg_loc_descriptor (fp_reg));
8404 /* ??? This fails for nested inline functions, because context_display
8405 is not part of the state saved/restored for inline functions. */
8406 if (current_function_needs_context)
8407 add_AT_location_description (subr_die, DW_AT_static_link,
8408 lookup_static_chain (decl));
8412 /* Now output descriptions of the arguments for this function. This gets
8413 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
8414 for a FUNCTION_DECL doesn't indicate cases where there was a trailing
8415 `...' at the end of the formal parameter list. In order to find out if
8416 there was a trailing ellipsis or not, we must instead look at the type
8417 associated with the FUNCTION_DECL. This will be a node of type
8418 FUNCTION_TYPE. If the chain of type nodes hanging off of this
8419 FUNCTION_TYPE node ends with a void_type_node then there should *not* be
8420 an ellipsis at the end. */
8422 /* In the case where we are describing a mere function declaration, all we
8423 need to do here (and all we *can* do here) is to describe the *types* of
8424 its formal parameters. */
8425 if (debug_info_level <= DINFO_LEVEL_TERSE)
8427 else if (declaration)
8428 gen_formal_types_die (TREE_TYPE (decl), subr_die);
8431 /* Generate DIEs to represent all known formal parameters */
8432 register tree arg_decls = DECL_ARGUMENTS (decl);
8435 /* When generating DIEs, generate the unspecified_parameters DIE
8436 instead if we come across the arg "__builtin_va_alist" */
8437 for (parm = arg_decls; parm; parm = TREE_CHAIN (parm))
8438 if (TREE_CODE (parm) == PARM_DECL)
8440 if (DECL_NAME (parm)
8441 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (parm)),
8442 "__builtin_va_alist"))
8443 gen_unspecified_parameters_die (parm, subr_die);
8445 gen_decl_die (parm, subr_die);
8448 /* Decide whether we need a unspecified_parameters DIE at the end.
8449 There are 2 more cases to do this for: 1) the ansi ... declaration -
8450 this is detectable when the end of the arg list is not a
8451 void_type_node 2) an unprototyped function declaration (not a
8452 definition). This just means that we have no info about the
8453 parameters at all. */
8454 fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
8455 if (fn_arg_types != NULL)
8457 /* this is the prototyped case, check for ... */
8458 if (TREE_VALUE (tree_last (fn_arg_types)) != void_type_node)
8459 gen_unspecified_parameters_die (decl, subr_die);
8461 else if (DECL_INITIAL (decl) == NULL_TREE)
8462 gen_unspecified_parameters_die (decl, subr_die);
8465 /* Output Dwarf info for all of the stuff within the body of the function
8466 (if it has one - it may be just a declaration). */
8467 outer_scope = DECL_INITIAL (decl);
8469 /* Note that here, `outer_scope' is a pointer to the outermost BLOCK
8470 node created to represent a function. This outermost BLOCK actually
8471 represents the outermost binding contour for the function, i.e. the
8472 contour in which the function's formal parameters and labels get
8473 declared. Curiously, it appears that the front end doesn't actually
8474 put the PARM_DECL nodes for the current function onto the BLOCK_VARS
8475 list for this outer scope. (They are strung off of the DECL_ARGUMENTS
8476 list for the function instead.) The BLOCK_VARS list for the
8477 `outer_scope' does provide us with a list of the LABEL_DECL nodes for
8478 the function however, and we output DWARF info for those in
8479 decls_for_scope. Just within the `outer_scope' there will be a BLOCK
8480 node representing the function's outermost pair of curly braces, and
8481 any blocks used for the base and member initializers of a C++
8482 constructor function. */
8483 if (! declaration && TREE_CODE (outer_scope) != ERROR_MARK)
8485 current_function_has_inlines = 0;
8486 decls_for_scope (outer_scope, subr_die, 0);
8488 #if 0 && defined (MIPS_DEBUGGING_INFO)
8489 if (current_function_has_inlines)
8491 add_AT_flag (subr_die, DW_AT_MIPS_has_inlines, 1);
8492 if (! comp_unit_has_inlines)
8494 add_AT_flag (comp_unit_die, DW_AT_MIPS_has_inlines, 1);
8495 comp_unit_has_inlines = 1;
8502 /* Generate a DIE to represent a declared data object. */
8505 gen_variable_die (decl, context_die)
8507 register dw_die_ref context_die;
8509 register tree origin = decl_ultimate_origin (decl);
8510 register dw_die_ref var_die = new_die (DW_TAG_variable, context_die);
8512 dw_die_ref old_die = lookup_decl_die (decl);
8513 int declaration = (DECL_EXTERNAL (decl)
8514 || class_scope_p (context_die));
8517 add_abstract_origin_attribute (var_die, origin);
8518 /* Loop unrolling can create multiple blocks that refer to the same
8519 static variable, so we must test for the DW_AT_declaration flag. */
8520 /* ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
8521 copy decls and set the DECL_ABSTRACT flag on them instead of
8523 else if (old_die && TREE_STATIC (decl)
8524 && get_AT_flag (old_die, DW_AT_declaration) == 1)
8526 /* This is a definition of a C++ class level static. */
8527 add_AT_die_ref (var_die, DW_AT_specification, old_die);
8528 if (DECL_NAME (decl))
8530 register unsigned file_index
8531 = lookup_filename (DECL_SOURCE_FILE (decl));
8533 if (get_AT_unsigned (old_die, DW_AT_decl_file) != file_index)
8534 add_AT_unsigned (var_die, DW_AT_decl_file, file_index);
8536 if (get_AT_unsigned (old_die, DW_AT_decl_line)
8537 != (unsigned)DECL_SOURCE_LINE (decl))
8539 add_AT_unsigned (var_die, DW_AT_decl_line,
8540 DECL_SOURCE_LINE (decl));
8545 add_name_and_src_coords_attributes (var_die, decl);
8546 add_type_attribute (var_die, TREE_TYPE (decl),
8547 TREE_READONLY (decl),
8548 TREE_THIS_VOLATILE (decl), context_die);
8550 if (TREE_PUBLIC (decl))
8551 add_AT_flag (var_die, DW_AT_external, 1);
8553 if (DECL_ARTIFICIAL (decl))
8554 add_AT_flag (var_die, DW_AT_artificial, 1);
8556 if (TREE_PROTECTED (decl))
8557 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_protected);
8559 else if (TREE_PRIVATE (decl))
8560 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_private);
8564 add_AT_flag (var_die, DW_AT_declaration, 1);
8566 if (class_scope_p (context_die) || DECL_ABSTRACT (decl))
8567 equate_decl_number_to_die (decl, var_die);
8569 if (! declaration && ! DECL_ABSTRACT (decl))
8571 add_location_or_const_value_attribute (var_die, decl);
8572 add_pubname (decl, var_die);
8576 /* Generate a DIE to represent a label identifier. */
8579 gen_label_die (decl, context_die)
8581 register dw_die_ref context_die;
8583 register tree origin = decl_ultimate_origin (decl);
8584 register dw_die_ref lbl_die = new_die (DW_TAG_label, context_die);
8586 char label[MAX_ARTIFICIAL_LABEL_BYTES];
8587 char label2[MAX_ARTIFICIAL_LABEL_BYTES];
8590 add_abstract_origin_attribute (lbl_die, origin);
8592 add_name_and_src_coords_attributes (lbl_die, decl);
8594 if (DECL_ABSTRACT (decl))
8595 equate_decl_number_to_die (decl, lbl_die);
8598 insn = DECL_RTL (decl);
8600 /* Deleted labels are programmer specified labels which have been
8601 eliminated because of various optimisations. We still emit them
8602 here so that it is possible to put breakpoints on them. */
8603 if (GET_CODE (insn) == CODE_LABEL
8604 || ((GET_CODE (insn) == NOTE
8605 && NOTE_LINE_NUMBER (insn) == NOTE_INSN_DELETED_LABEL)))
8607 /* When optimization is enabled (via -O) some parts of the compiler
8608 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
8609 represent source-level labels which were explicitly declared by
8610 the user. This really shouldn't be happening though, so catch
8611 it if it ever does happen. */
8612 if (INSN_DELETED_P (insn))
8615 sprintf (label2, INSN_LABEL_FMT, current_funcdef_number);
8616 ASM_GENERATE_INTERNAL_LABEL (label, label2,
8617 (unsigned) INSN_UID (insn));
8618 add_AT_lbl_id (lbl_die, DW_AT_low_pc, label);
8623 /* Generate a DIE for a lexical block. */
8626 gen_lexical_block_die (stmt, context_die, depth)
8628 register dw_die_ref context_die;
8631 register dw_die_ref stmt_die = new_die (DW_TAG_lexical_block, context_die);
8632 char label[MAX_ARTIFICIAL_LABEL_BYTES];
8634 if (! BLOCK_ABSTRACT (stmt))
8636 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
8638 add_AT_lbl_id (stmt_die, DW_AT_low_pc, label);
8639 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL, next_block_number);
8640 add_AT_lbl_id (stmt_die, DW_AT_high_pc, label);
8643 decls_for_scope (stmt, stmt_die, depth);
8646 /* Generate a DIE for an inlined subprogram. */
8649 gen_inlined_subroutine_die (stmt, context_die, depth)
8651 register dw_die_ref context_die;
8654 if (! BLOCK_ABSTRACT (stmt))
8656 register dw_die_ref subr_die
8657 = new_die (DW_TAG_inlined_subroutine, context_die);
8658 register tree decl = block_ultimate_origin (stmt);
8659 char label[MAX_ARTIFICIAL_LABEL_BYTES];
8661 /* Emit info for the abstract instance first, if we haven't yet. */
8662 gen_abstract_function (decl);
8664 add_abstract_origin_attribute (subr_die, decl);
8665 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
8667 add_AT_lbl_id (subr_die, DW_AT_low_pc, label);
8668 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL, next_block_number);
8669 add_AT_lbl_id (subr_die, DW_AT_high_pc, label);
8670 decls_for_scope (stmt, subr_die, depth);
8671 current_function_has_inlines = 1;
8675 /* Generate a DIE for a field in a record, or structure. */
8678 gen_field_die (decl, context_die)
8680 register dw_die_ref context_die;
8682 register dw_die_ref decl_die = new_die (DW_TAG_member, context_die);
8684 add_name_and_src_coords_attributes (decl_die, decl);
8685 add_type_attribute (decl_die, member_declared_type (decl),
8686 TREE_READONLY (decl), TREE_THIS_VOLATILE (decl),
8689 /* If this is a bit field... */
8690 if (DECL_BIT_FIELD_TYPE (decl))
8692 add_byte_size_attribute (decl_die, decl);
8693 add_bit_size_attribute (decl_die, decl);
8694 add_bit_offset_attribute (decl_die, decl);
8697 if (TREE_CODE (DECL_FIELD_CONTEXT (decl)) != UNION_TYPE)
8698 add_data_member_location_attribute (decl_die, decl);
8700 if (DECL_ARTIFICIAL (decl))
8701 add_AT_flag (decl_die, DW_AT_artificial, 1);
8703 if (TREE_PROTECTED (decl))
8704 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_protected);
8706 else if (TREE_PRIVATE (decl))
8707 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_private);
8711 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
8712 Use modified_type_die instead.
8713 We keep this code here just in case these types of DIEs may be needed to
8714 represent certain things in other languages (e.g. Pascal) someday. */
8716 gen_pointer_type_die (type, context_die)
8718 register dw_die_ref context_die;
8720 register dw_die_ref ptr_die
8721 = new_die (DW_TAG_pointer_type, scope_die_for (type, context_die));
8723 equate_type_number_to_die (type, ptr_die);
8724 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
8725 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
8728 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
8729 Use modified_type_die instead.
8730 We keep this code here just in case these types of DIEs may be needed to
8731 represent certain things in other languages (e.g. Pascal) someday. */
8733 gen_reference_type_die (type, context_die)
8735 register dw_die_ref context_die;
8737 register dw_die_ref ref_die
8738 = new_die (DW_TAG_reference_type, scope_die_for (type, context_die));
8740 equate_type_number_to_die (type, ref_die);
8741 add_type_attribute (ref_die, TREE_TYPE (type), 0, 0, context_die);
8742 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
8746 /* Generate a DIE for a pointer to a member type. */
8748 gen_ptr_to_mbr_type_die (type, context_die)
8750 register dw_die_ref context_die;
8752 register dw_die_ref ptr_die
8753 = new_die (DW_TAG_ptr_to_member_type, scope_die_for (type, context_die));
8755 equate_type_number_to_die (type, ptr_die);
8756 add_AT_die_ref (ptr_die, DW_AT_containing_type,
8757 lookup_type_die (TYPE_OFFSET_BASETYPE (type)));
8758 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
8761 /* Generate the DIE for the compilation unit. */
8764 gen_compile_unit_die (filename)
8765 register const char *filename;
8767 register dw_die_ref die;
8769 char *wd = getpwd ();
8772 die = new_die (DW_TAG_compile_unit, NULL);
8773 add_name_attribute (die, filename);
8775 if (wd != NULL && filename[0] != DIR_SEPARATOR)
8776 add_AT_string (die, DW_AT_comp_dir, wd);
8778 sprintf (producer, "%s %s", language_string, version_string);
8780 #ifdef MIPS_DEBUGGING_INFO
8781 /* The MIPS/SGI compilers place the 'cc' command line options in the producer
8782 string. The SGI debugger looks for -g, -g1, -g2, or -g3; if they do
8783 not appear in the producer string, the debugger reaches the conclusion
8784 that the object file is stripped and has no debugging information.
8785 To get the MIPS/SGI debugger to believe that there is debugging
8786 information in the object file, we add a -g to the producer string. */
8787 if (debug_info_level > DINFO_LEVEL_TERSE)
8788 strcat (producer, " -g");
8791 add_AT_string (die, DW_AT_producer, producer);
8793 if (strcmp (language_string, "GNU C++") == 0)
8794 language = DW_LANG_C_plus_plus;
8795 else if (strcmp (language_string, "GNU Ada") == 0)
8796 language = DW_LANG_Ada83;
8797 else if (strcmp (language_string, "GNU F77") == 0)
8798 language = DW_LANG_Fortran77;
8799 else if (strcmp (language_string, "GNU Pascal") == 0)
8800 language = DW_LANG_Pascal83;
8801 else if (flag_traditional)
8802 language = DW_LANG_C;
8804 language = DW_LANG_C89;
8806 add_AT_unsigned (die, DW_AT_language, language);
8811 /* Generate a DIE for a string type. */
8814 gen_string_type_die (type, context_die)
8816 register dw_die_ref context_die;
8818 register dw_die_ref type_die
8819 = new_die (DW_TAG_string_type, scope_die_for (type, context_die));
8821 equate_type_number_to_die (type, type_die);
8823 /* Fudge the string length attribute for now. */
8825 /* TODO: add string length info.
8826 string_length_attribute (TYPE_MAX_VALUE (TYPE_DOMAIN (type)));
8827 bound_representation (upper_bound, 0, 'u'); */
8830 /* Generate the DIE for a base class. */
8833 gen_inheritance_die (binfo, context_die)
8834 register tree binfo;
8835 register dw_die_ref context_die;
8837 dw_die_ref die = new_die (DW_TAG_inheritance, context_die);
8839 add_type_attribute (die, BINFO_TYPE (binfo), 0, 0, context_die);
8840 add_data_member_location_attribute (die, binfo);
8842 if (TREE_VIA_VIRTUAL (binfo))
8843 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
8844 if (TREE_VIA_PUBLIC (binfo))
8845 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public);
8846 else if (TREE_VIA_PROTECTED (binfo))
8847 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected);
8850 /* Generate a DIE for a class member. */
8853 gen_member_die (type, context_die)
8855 register dw_die_ref context_die;
8857 register tree member;
8860 /* If this is not an incomplete type, output descriptions of each of its
8861 members. Note that as we output the DIEs necessary to represent the
8862 members of this record or union type, we will also be trying to output
8863 DIEs to represent the *types* of those members. However the `type'
8864 function (above) will specifically avoid generating type DIEs for member
8865 types *within* the list of member DIEs for this (containing) type execpt
8866 for those types (of members) which are explicitly marked as also being
8867 members of this (containing) type themselves. The g++ front- end can
8868 force any given type to be treated as a member of some other
8869 (containing) type by setting the TYPE_CONTEXT of the given (member) type
8870 to point to the TREE node representing the appropriate (containing)
8873 /* First output info about the base classes. */
8874 if (TYPE_BINFO (type) && TYPE_BINFO_BASETYPES (type))
8876 register tree bases = TYPE_BINFO_BASETYPES (type);
8877 register int n_bases = TREE_VEC_LENGTH (bases);
8880 for (i = 0; i < n_bases; i++)
8881 gen_inheritance_die (TREE_VEC_ELT (bases, i), context_die);
8884 /* Now output info about the data members and type members. */
8885 for (member = TYPE_FIELDS (type); member; member = TREE_CHAIN (member))
8887 /* If we thought we were generating minimal debug info for TYPE
8888 and then changed our minds, some of the member declarations
8889 may have already been defined. Don't define them again, but
8890 do put them in the right order. */
8892 child = lookup_decl_die (member);
8894 splice_child_die (context_die, child);
8896 gen_decl_die (member, context_die);
8899 /* Now output info about the function members (if any). */
8900 for (member = TYPE_METHODS (type); member; member = TREE_CHAIN (member))
8902 child = lookup_decl_die (member);
8904 splice_child_die (context_die, child);
8906 gen_decl_die (member, context_die);
8910 /* Generate a DIE for a structure or union type. If TYPE_DECL_SUPPRESS_DEBUG
8911 is set, we pretend that the type was never defined, so we only get the
8912 member DIEs needed by later specification DIEs. */
8915 gen_struct_or_union_type_die (type, context_die)
8917 register dw_die_ref context_die;
8919 register dw_die_ref type_die = lookup_type_die (type);
8920 register dw_die_ref scope_die = 0;
8921 register int nested = 0;
8922 int complete = (TYPE_SIZE (type)
8923 && ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type)));
8925 if (type_die && ! complete)
8928 if (TYPE_CONTEXT (type) != NULL_TREE
8929 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type)))
8932 scope_die = scope_die_for (type, context_die);
8934 if (! type_die || (nested && scope_die == comp_unit_die))
8935 /* First occurrence of type or toplevel definition of nested class. */
8937 register dw_die_ref old_die = type_die;
8939 type_die = new_die (TREE_CODE (type) == RECORD_TYPE
8940 ? DW_TAG_structure_type : DW_TAG_union_type,
8942 equate_type_number_to_die (type, type_die);
8943 add_name_attribute (type_die, type_tag (type));
8945 add_AT_die_ref (type_die, DW_AT_specification, old_die);
8948 remove_AT (type_die, DW_AT_declaration);
8950 /* If this type has been completed, then give it a byte_size attribute and
8951 then give a list of members. */
8954 /* Prevent infinite recursion in cases where the type of some member of
8955 this type is expressed in terms of this type itself. */
8956 TREE_ASM_WRITTEN (type) = 1;
8957 add_byte_size_attribute (type_die, type);
8958 if (TYPE_STUB_DECL (type) != NULL_TREE)
8959 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
8961 /* If the first reference to this type was as the return type of an
8962 inline function, then it may not have a parent. Fix this now. */
8963 if (type_die->die_parent == NULL)
8964 add_child_die (scope_die, type_die);
8966 push_decl_scope (type);
8967 gen_member_die (type, type_die);
8970 /* GNU extension: Record what type our vtable lives in. */
8971 if (TYPE_VFIELD (type))
8973 tree vtype = DECL_FCONTEXT (TYPE_VFIELD (type));
8975 gen_type_die (vtype, context_die);
8976 add_AT_die_ref (type_die, DW_AT_containing_type,
8977 lookup_type_die (vtype));
8982 add_AT_flag (type_die, DW_AT_declaration, 1);
8984 /* We don't need to do this for function-local types. */
8986 add_incomplete_type (type);
8990 /* Generate a DIE for a subroutine _type_. */
8993 gen_subroutine_type_die (type, context_die)
8995 register dw_die_ref context_die;
8997 register tree return_type = TREE_TYPE (type);
8998 register dw_die_ref subr_die
8999 = new_die (DW_TAG_subroutine_type, scope_die_for (type, context_die));
9001 equate_type_number_to_die (type, subr_die);
9002 add_prototyped_attribute (subr_die, type);
9003 add_type_attribute (subr_die, return_type, 0, 0, context_die);
9004 gen_formal_types_die (type, subr_die);
9007 /* Generate a DIE for a type definition */
9010 gen_typedef_die (decl, context_die)
9012 register dw_die_ref context_die;
9014 register dw_die_ref type_die;
9015 register tree origin;
9017 if (TREE_ASM_WRITTEN (decl))
9019 TREE_ASM_WRITTEN (decl) = 1;
9021 type_die = new_die (DW_TAG_typedef, context_die);
9022 origin = decl_ultimate_origin (decl);
9024 add_abstract_origin_attribute (type_die, origin);
9028 add_name_and_src_coords_attributes (type_die, decl);
9029 if (DECL_ORIGINAL_TYPE (decl))
9031 type = DECL_ORIGINAL_TYPE (decl);
9032 equate_type_number_to_die (TREE_TYPE (decl), type_die);
9035 type = TREE_TYPE (decl);
9036 add_type_attribute (type_die, type, TREE_READONLY (decl),
9037 TREE_THIS_VOLATILE (decl), context_die);
9040 if (DECL_ABSTRACT (decl))
9041 equate_decl_number_to_die (decl, type_die);
9044 /* Generate a type description DIE. */
9047 gen_type_die (type, context_die)
9049 register dw_die_ref context_die;
9053 if (type == NULL_TREE || type == error_mark_node)
9056 /* We are going to output a DIE to represent the unqualified version of
9057 this type (i.e. without any const or volatile qualifiers) so get the
9058 main variant (i.e. the unqualified version) of this type now. */
9059 type = type_main_variant (type);
9061 if (TREE_ASM_WRITTEN (type))
9064 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
9065 && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
9067 TREE_ASM_WRITTEN (type) = 1;
9068 gen_decl_die (TYPE_NAME (type), context_die);
9072 switch (TREE_CODE (type))
9078 case REFERENCE_TYPE:
9079 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This
9080 ensures that the gen_type_die recursion will terminate even if the
9081 type is recursive. Recursive types are possible in Ada. */
9082 /* ??? We could perhaps do this for all types before the switch
9084 TREE_ASM_WRITTEN (type) = 1;
9086 /* For these types, all that is required is that we output a DIE (or a
9087 set of DIEs) to represent the "basis" type. */
9088 gen_type_die (TREE_TYPE (type), context_die);
9092 /* This code is used for C++ pointer-to-data-member types.
9093 Output a description of the relevant class type. */
9094 gen_type_die (TYPE_OFFSET_BASETYPE (type), context_die);
9096 /* Output a description of the type of the object pointed to. */
9097 gen_type_die (TREE_TYPE (type), context_die);
9099 /* Now output a DIE to represent this pointer-to-data-member type
9101 gen_ptr_to_mbr_type_die (type, context_die);
9105 gen_type_die (TYPE_DOMAIN (type), context_die);
9106 gen_set_type_die (type, context_die);
9110 gen_type_die (TREE_TYPE (type), context_die);
9111 abort (); /* No way to represent these in Dwarf yet! */
9115 /* Force out return type (in case it wasn't forced out already). */
9116 gen_type_die (TREE_TYPE (type), context_die);
9117 gen_subroutine_type_die (type, context_die);
9121 /* Force out return type (in case it wasn't forced out already). */
9122 gen_type_die (TREE_TYPE (type), context_die);
9123 gen_subroutine_type_die (type, context_die);
9127 if (TYPE_STRING_FLAG (type) && TREE_CODE (TREE_TYPE (type)) == CHAR_TYPE)
9129 gen_type_die (TREE_TYPE (type), context_die);
9130 gen_string_type_die (type, context_die);
9133 gen_array_type_die (type, context_die);
9139 case QUAL_UNION_TYPE:
9140 /* If this is a nested type whose containing class hasn't been
9141 written out yet, writing it out will cover this one, too.
9142 This does not apply to instantiations of member class templates;
9143 they need to be added to the containing class as they are
9144 generated. FIXME: This hurts the idea of combining type decls
9145 from multiple TUs, since we can't predict what set of template
9146 instantiations we'll get. */
9147 if (TYPE_CONTEXT (type)
9148 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
9149 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
9151 gen_type_die (TYPE_CONTEXT (type), context_die);
9153 if (TREE_ASM_WRITTEN (type))
9156 /* If that failed, attach ourselves to the stub. */
9157 push_decl_scope (TYPE_CONTEXT (type));
9158 context_die = lookup_type_die (TYPE_CONTEXT (type));
9164 if (TREE_CODE (type) == ENUMERAL_TYPE)
9165 gen_enumeration_type_die (type, context_die);
9167 gen_struct_or_union_type_die (type, context_die);
9172 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
9173 it up if it is ever completed. gen_*_type_die will set it for us
9174 when appropriate. */
9183 /* No DIEs needed for fundamental types. */
9187 /* No Dwarf representation currently defined. */
9194 TREE_ASM_WRITTEN (type) = 1;
9197 /* Generate a DIE for a tagged type instantiation. */
9200 gen_tagged_type_instantiation_die (type, context_die)
9202 register dw_die_ref context_die;
9204 if (type == NULL_TREE || type == error_mark_node)
9207 /* We are going to output a DIE to represent the unqualified version of
9208 this type (i.e. without any const or volatile qualifiers) so make sure
9209 that we have the main variant (i.e. the unqualified version) of this
9211 if (type != type_main_variant (type))
9214 /* Do not check TREE_ASM_WRITTEN(type) as it may not be set if this is
9215 an instance of an unresolved type. */
9217 switch (TREE_CODE (type))
9223 gen_inlined_enumeration_type_die (type, context_die);
9227 gen_inlined_structure_type_die (type, context_die);
9231 case QUAL_UNION_TYPE:
9232 gen_inlined_union_type_die (type, context_die);
9240 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
9241 things which are local to the given block. */
9244 gen_block_die (stmt, context_die, depth)
9246 register dw_die_ref context_die;
9249 register int must_output_die = 0;
9250 register tree origin;
9252 register enum tree_code origin_code;
9254 /* Ignore blocks never really used to make RTL. */
9256 if (stmt == NULL_TREE || !TREE_USED (stmt))
9259 /* Determine the "ultimate origin" of this block. This block may be an
9260 inlined instance of an inlined instance of inline function, so we have
9261 to trace all of the way back through the origin chain to find out what
9262 sort of node actually served as the original seed for the creation of
9263 the current block. */
9264 origin = block_ultimate_origin (stmt);
9265 origin_code = (origin != NULL) ? TREE_CODE (origin) : ERROR_MARK;
9267 /* Determine if we need to output any Dwarf DIEs at all to represent this
9269 if (origin_code == FUNCTION_DECL)
9270 /* The outer scopes for inlinings *must* always be represented. We
9271 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */
9272 must_output_die = 1;
9275 /* In the case where the current block represents an inlining of the
9276 "body block" of an inline function, we must *NOT* output any DIE for
9277 this block because we have already output a DIE to represent the
9278 whole inlined function scope and the "body block" of any function
9279 doesn't really represent a different scope according to ANSI C
9280 rules. So we check here to make sure that this block does not
9281 represent a "body block inlining" before trying to set the
9282 `must_output_die' flag. */
9283 if (! is_body_block (origin ? origin : stmt))
9285 /* Determine if this block directly contains any "significant"
9286 local declarations which we will need to output DIEs for. */
9287 if (debug_info_level > DINFO_LEVEL_TERSE)
9288 /* We are not in terse mode so *any* local declaration counts
9289 as being a "significant" one. */
9290 must_output_die = (BLOCK_VARS (stmt) != NULL);
9292 /* We are in terse mode, so only local (nested) function
9293 definitions count as "significant" local declarations. */
9294 for (decl = BLOCK_VARS (stmt);
9295 decl != NULL; decl = TREE_CHAIN (decl))
9296 if (TREE_CODE (decl) == FUNCTION_DECL
9297 && DECL_INITIAL (decl))
9299 must_output_die = 1;
9305 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
9306 DIE for any block which contains no significant local declarations at
9307 all. Rather, in such cases we just call `decls_for_scope' so that any
9308 needed Dwarf info for any sub-blocks will get properly generated. Note
9309 that in terse mode, our definition of what constitutes a "significant"
9310 local declaration gets restricted to include only inlined function
9311 instances and local (nested) function definitions. */
9312 if (must_output_die)
9314 if (origin_code == FUNCTION_DECL)
9315 gen_inlined_subroutine_die (stmt, context_die, depth);
9317 gen_lexical_block_die (stmt, context_die, depth);
9320 decls_for_scope (stmt, context_die, depth);
9323 /* Generate all of the decls declared within a given scope and (recursively)
9324 all of its sub-blocks. */
9327 decls_for_scope (stmt, context_die, depth)
9329 register dw_die_ref context_die;
9333 register tree subblocks;
9335 /* Ignore blocks never really used to make RTL. */
9336 if (stmt == NULL_TREE || ! TREE_USED (stmt))
9339 if (!BLOCK_ABSTRACT (stmt) && depth > 0)
9340 next_block_number++;
9342 /* Output the DIEs to represent all of the data objects and typedefs
9343 declared directly within this block but not within any nested
9344 sub-blocks. Also, nested function and tag DIEs have been
9345 generated with a parent of NULL; fix that up now. */
9346 for (decl = BLOCK_VARS (stmt);
9347 decl != NULL; decl = TREE_CHAIN (decl))
9349 register dw_die_ref die;
9351 if (TREE_CODE (decl) == FUNCTION_DECL)
9352 die = lookup_decl_die (decl);
9353 else if (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl))
9354 die = lookup_type_die (TREE_TYPE (decl));
9358 if (die != NULL && die->die_parent == NULL)
9359 add_child_die (context_die, die);
9361 gen_decl_die (decl, context_die);
9364 /* Output the DIEs to represent all sub-blocks (and the items declared
9365 therein) of this block. */
9366 for (subblocks = BLOCK_SUBBLOCKS (stmt);
9368 subblocks = BLOCK_CHAIN (subblocks))
9369 gen_block_die (subblocks, context_die, depth + 1);
9372 /* Is this a typedef we can avoid emitting? */
9375 is_redundant_typedef (decl)
9378 if (TYPE_DECL_IS_STUB (decl))
9381 if (DECL_ARTIFICIAL (decl)
9382 && DECL_CONTEXT (decl)
9383 && is_tagged_type (DECL_CONTEXT (decl))
9384 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl))) == TYPE_DECL
9385 && DECL_NAME (decl) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))))
9386 /* Also ignore the artificial member typedef for the class name. */
9392 /* Generate Dwarf debug information for a decl described by DECL. */
9395 gen_decl_die (decl, context_die)
9397 register dw_die_ref context_die;
9399 register tree origin;
9401 if (TREE_CODE (decl) == ERROR_MARK)
9404 /* If this ..._DECL node is marked to be ignored, then ignore it. But don't
9405 ignore a function definition, since that would screw up our count of
9406 blocks, and that in turn will completely screw up the labels we will
9407 reference in subsequent DW_AT_low_pc and DW_AT_high_pc attributes (for
9408 subsequent blocks). */
9409 if (DECL_IGNORED_P (decl) && TREE_CODE (decl) != FUNCTION_DECL)
9412 switch (TREE_CODE (decl))
9415 /* The individual enumerators of an enum type get output when we output
9416 the Dwarf representation of the relevant enum type itself. */
9420 /* Don't output any DIEs to represent mere function declarations,
9421 unless they are class members or explicit block externs. */
9422 if (DECL_INITIAL (decl) == NULL_TREE && DECL_CONTEXT (decl) == NULL_TREE
9423 && (current_function_decl == NULL_TREE || DECL_ARTIFICIAL (decl)))
9426 /* Emit info for the abstract instance first, if we haven't yet. */
9427 origin = decl_ultimate_origin (decl);
9429 gen_abstract_function (origin);
9431 if (debug_info_level > DINFO_LEVEL_TERSE)
9433 /* Before we describe the FUNCTION_DECL itself, make sure that we
9434 have described its return type. */
9435 gen_type_die (TREE_TYPE (TREE_TYPE (decl)), context_die);
9437 /* And its virtual context. */
9438 if (DECL_VINDEX (decl) != NULL_TREE)
9439 gen_type_die (DECL_CONTEXT (decl), context_die);
9441 /* And its containing type. */
9442 origin = decl_class_context (decl);
9443 if (origin != NULL_TREE)
9444 gen_type_die_for_member (origin, decl, context_die);
9447 /* Now output a DIE to represent the function itself. */
9448 gen_subprogram_die (decl, context_die);
9452 /* If we are in terse mode, don't generate any DIEs to represent any
9454 if (debug_info_level <= DINFO_LEVEL_TERSE)
9457 /* In the special case of a TYPE_DECL node representing the
9458 declaration of some type tag, if the given TYPE_DECL is marked as
9459 having been instantiated from some other (original) TYPE_DECL node
9460 (e.g. one which was generated within the original definition of an
9461 inline function) we have to generate a special (abbreviated)
9462 DW_TAG_structure_type, DW_TAG_union_type, or DW_TAG_enumeration_type
9464 if (TYPE_DECL_IS_STUB (decl) && decl_ultimate_origin (decl) != NULL_TREE)
9466 gen_tagged_type_instantiation_die (TREE_TYPE (decl), context_die);
9470 if (is_redundant_typedef (decl))
9471 gen_type_die (TREE_TYPE (decl), context_die);
9473 /* Output a DIE to represent the typedef itself. */
9474 gen_typedef_die (decl, context_die);
9478 if (debug_info_level >= DINFO_LEVEL_NORMAL)
9479 gen_label_die (decl, context_die);
9483 /* If we are in terse mode, don't generate any DIEs to represent any
9484 variable declarations or definitions. */
9485 if (debug_info_level <= DINFO_LEVEL_TERSE)
9488 /* Output any DIEs that are needed to specify the type of this data
9490 gen_type_die (TREE_TYPE (decl), context_die);
9492 /* And its containing type. */
9493 origin = decl_class_context (decl);
9494 if (origin != NULL_TREE)
9495 gen_type_die_for_member (origin, decl, context_die);
9497 /* Now output the DIE to represent the data object itself. This gets
9498 complicated because of the possibility that the VAR_DECL really
9499 represents an inlined instance of a formal parameter for an inline
9501 origin = decl_ultimate_origin (decl);
9502 if (origin != NULL_TREE && TREE_CODE (origin) == PARM_DECL)
9503 gen_formal_parameter_die (decl, context_die);
9505 gen_variable_die (decl, context_die);
9509 /* Ignore the nameless fields that are used to skip bits, but
9510 handle C++ anonymous unions. */
9511 if (DECL_NAME (decl) != NULL_TREE
9512 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE)
9514 gen_type_die (member_declared_type (decl), context_die);
9515 gen_field_die (decl, context_die);
9520 gen_type_die (TREE_TYPE (decl), context_die);
9521 gen_formal_parameter_die (decl, context_die);
9524 case NAMESPACE_DECL:
9525 /* Ignore for now. */
9533 /* Add Ada "use" clause information for SGI Workshop debugger. */
9536 dwarf2out_add_library_unit_info (filename, context_list)
9540 unsigned int file_index;
9542 if (filename != NULL)
9544 dw_die_ref unit_die = new_die (DW_TAG_module, comp_unit_die);
9545 tree context_list_decl
9546 = build_decl (LABEL_DECL, get_identifier (context_list),
9549 TREE_PUBLIC (context_list_decl) = TRUE;
9550 add_name_attribute (unit_die, context_list);
9551 file_index = lookup_filename (filename);
9552 add_AT_unsigned (unit_die, DW_AT_decl_file, file_index);
9553 add_pubname (context_list_decl, unit_die);
9557 /* Write the debugging output for DECL. */
9560 dwarf2out_decl (decl)
9563 register dw_die_ref context_die = comp_unit_die;
9565 if (TREE_CODE (decl) == ERROR_MARK)
9568 /* If this ..._DECL node is marked to be ignored, then ignore it. We gotta
9569 hope that the node in question doesn't represent a function definition.
9570 If it does, then totally ignoring it is bound to screw up our count of
9571 blocks, and that in turn will completely screw up the labels we will
9572 reference in subsequent DW_AT_low_pc and DW_AT_high_pc attributes (for
9573 subsequent blocks). (It's too bad that BLOCK nodes don't carry their
9574 own sequence numbers with them!) */
9575 if (DECL_IGNORED_P (decl))
9577 if (TREE_CODE (decl) == FUNCTION_DECL
9578 && DECL_INITIAL (decl) != NULL)
9584 switch (TREE_CODE (decl))
9587 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration of a
9588 builtin function. Explicit programmer-supplied declarations of
9589 these same functions should NOT be ignored however. */
9590 if (DECL_EXTERNAL (decl) && DECL_BUILT_IN (decl))
9593 /* What we would really like to do here is to filter out all mere
9594 file-scope declarations of file-scope functions which are never
9595 referenced later within this translation unit (and keep all of ones
9596 that *are* referenced later on) but we aren't clairvoyant, so we have
9597 no idea which functions will be referenced in the future (i.e. later
9598 on within the current translation unit). So here we just ignore all
9599 file-scope function declarations which are not also definitions. If
9600 and when the debugger needs to know something about these functions,
9601 it will have to hunt around and find the DWARF information associated
9602 with the definition of the function. Note that we can't just check
9603 `DECL_EXTERNAL' to find out which FUNCTION_DECL nodes represent
9604 definitions and which ones represent mere declarations. We have to
9605 check `DECL_INITIAL' instead. That's because the C front-end
9606 supports some weird semantics for "extern inline" function
9607 definitions. These can get inlined within the current translation
9608 unit (an thus, we need to generate DWARF info for their abstract
9609 instances so that the DWARF info for the concrete inlined instances
9610 can have something to refer to) but the compiler never generates any
9611 out-of-lines instances of such things (despite the fact that they
9612 *are* definitions). The important point is that the C front-end
9613 marks these "extern inline" functions as DECL_EXTERNAL, but we need
9614 to generate DWARF for them anyway. Note that the C++ front-end also
9615 plays some similar games for inline function definitions appearing
9616 within include files which also contain
9617 `#pragma interface' pragmas. */
9618 if (DECL_INITIAL (decl) == NULL_TREE)
9621 /* If we're a nested function, initially use a parent of NULL; if we're
9622 a plain function, this will be fixed up in decls_for_scope. If
9623 we're a method, it will be ignored, since we already have a DIE. */
9624 if (decl_function_context (decl))
9630 /* Ignore this VAR_DECL if it refers to a file-scope extern data object
9631 declaration and if the declaration was never even referenced from
9632 within this entire compilation unit. We suppress these DIEs in
9633 order to save space in the .debug section (by eliminating entries
9634 which are probably useless). Note that we must not suppress
9635 block-local extern declarations (whether used or not) because that
9636 would screw-up the debugger's name lookup mechanism and cause it to
9637 miss things which really ought to be in scope at a given point. */
9638 if (DECL_EXTERNAL (decl) && !TREE_USED (decl))
9641 /* If we are in terse mode, don't generate any DIEs to represent any
9642 variable declarations or definitions. */
9643 if (debug_info_level <= DINFO_LEVEL_TERSE)
9648 /* Don't bother trying to generate any DIEs to represent any of the
9649 normal built-in types for the language we are compiling. */
9650 if (DECL_SOURCE_LINE (decl) == 0)
9652 /* OK, we need to generate one for `bool' so GDB knows what type
9653 comparisons have. */
9654 if ((get_AT_unsigned (comp_unit_die, DW_AT_language)
9655 == DW_LANG_C_plus_plus)
9656 && TREE_CODE (TREE_TYPE (decl)) == BOOLEAN_TYPE)
9657 modified_type_die (TREE_TYPE (decl), 0, 0, NULL);
9662 /* If we are in terse mode, don't generate any DIEs for types. */
9663 if (debug_info_level <= DINFO_LEVEL_TERSE)
9666 /* If we're a function-scope tag, initially use a parent of NULL;
9667 this will be fixed up in decls_for_scope. */
9668 if (decl_function_context (decl))
9677 gen_decl_die (decl, context_die);
9680 /* Output a marker (i.e. a label) for the beginning of the generated code for
9684 dwarf2out_begin_block (blocknum)
9685 register unsigned blocknum;
9687 function_section (current_function_decl);
9688 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, BLOCK_BEGIN_LABEL, blocknum);
9691 /* Output a marker (i.e. a label) for the end of the generated code for a
9695 dwarf2out_end_block (blocknum)
9696 register unsigned blocknum;
9698 function_section (current_function_decl);
9699 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, BLOCK_END_LABEL, blocknum);
9702 /* Output a marker (i.e. a label) at a point in the assembly code which
9703 corresponds to a given source level label. */
9706 dwarf2out_label (insn)
9709 char label[MAX_ARTIFICIAL_LABEL_BYTES];
9711 if (debug_info_level >= DINFO_LEVEL_NORMAL)
9713 function_section (current_function_decl);
9714 sprintf (label, INSN_LABEL_FMT, current_funcdef_number);
9715 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, label,
9716 (unsigned) INSN_UID (insn));
9720 /* Lookup a filename (in the list of filenames that we know about here in
9721 dwarf2out.c) and return its "index". The index of each (known) filename is
9722 just a unique number which is associated with only that one filename.
9723 We need such numbers for the sake of generating labels
9724 (in the .debug_sfnames section) and references to those
9725 files numbers (in the .debug_srcinfo and.debug_macinfo sections).
9726 If the filename given as an argument is not found in our current list,
9727 add it to the list and assign it the next available unique index number.
9728 In order to speed up searches, we remember the index of the filename
9729 was looked up last. This handles the majority of all searches. */
9732 lookup_filename (file_name)
9733 const char *file_name;
9735 static unsigned last_file_lookup_index = 0;
9736 register unsigned i;
9738 /* Check to see if the file name that was searched on the previous call
9739 matches this file name. If so, return the index. */
9740 if (last_file_lookup_index != 0)
9741 if (strcmp (file_name, file_table[last_file_lookup_index]) == 0)
9742 return last_file_lookup_index;
9744 /* Didn't match the previous lookup, search the table */
9745 for (i = 1; i < file_table_in_use; ++i)
9746 if (strcmp (file_name, file_table[i]) == 0)
9748 last_file_lookup_index = i;
9752 /* Prepare to add a new table entry by making sure there is enough space in
9753 the table to do so. If not, expand the current table. */
9754 if (file_table_in_use == file_table_allocated)
9756 file_table_allocated += FILE_TABLE_INCREMENT;
9758 = (char **) xrealloc (file_table,
9759 file_table_allocated * sizeof (char *));
9762 /* Add the new entry to the end of the filename table. */
9763 file_table[file_table_in_use] = xstrdup (file_name);
9764 last_file_lookup_index = file_table_in_use++;
9766 return last_file_lookup_index;
9769 /* Output a label to mark the beginning of a source code line entry
9770 and record information relating to this source line, in
9771 'line_info_table' for later output of the .debug_line section. */
9774 dwarf2out_line (filename, line)
9775 register const char *filename;
9776 register unsigned line;
9778 if (debug_info_level >= DINFO_LEVEL_NORMAL)
9780 function_section (current_function_decl);
9782 if (DWARF2_ASM_LINE_DEBUG_INFO)
9784 static const char *lastfile;
9786 /* Emit the .file and .loc directives understood by GNU as. */
9787 if (lastfile == 0 || strcmp (filename, lastfile))
9790 ggc_add_string_root ((char **) &lastfile, 1);
9792 fprintf (asm_out_file, "\t.file 0 \"%s\"\n", filename);
9793 lastfile = filename;
9796 fprintf (asm_out_file, "\t.loc 0 %d 0\n", line);
9798 /* Indicate that line number info exists. */
9799 ++line_info_table_in_use;
9801 /* Indicate that multiple line number tables exist. */
9802 if (DECL_SECTION_NAME (current_function_decl))
9803 ++separate_line_info_table_in_use;
9805 else if (DECL_SECTION_NAME (current_function_decl))
9807 register dw_separate_line_info_ref line_info;
9808 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, SEPARATE_LINE_CODE_LABEL,
9809 separate_line_info_table_in_use);
9811 fprintf (asm_out_file, "\t%s line %d", ASM_COMMENT_START, line);
9812 fputc ('\n', asm_out_file);
9814 /* expand the line info table if necessary */
9815 if (separate_line_info_table_in_use
9816 == separate_line_info_table_allocated)
9818 separate_line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
9819 separate_line_info_table
9820 = (dw_separate_line_info_ref)
9821 xrealloc (separate_line_info_table,
9822 separate_line_info_table_allocated
9823 * sizeof (dw_separate_line_info_entry));
9826 /* Add the new entry at the end of the line_info_table. */
9828 = &separate_line_info_table[separate_line_info_table_in_use++];
9829 line_info->dw_file_num = lookup_filename (filename);
9830 line_info->dw_line_num = line;
9831 line_info->function = current_funcdef_number;
9835 register dw_line_info_ref line_info;
9837 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, LINE_CODE_LABEL,
9838 line_info_table_in_use);
9840 fprintf (asm_out_file, "\t%s line %d", ASM_COMMENT_START, line);
9841 fputc ('\n', asm_out_file);
9843 /* Expand the line info table if necessary. */
9844 if (line_info_table_in_use == line_info_table_allocated)
9846 line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
9848 = (dw_line_info_ref)
9849 xrealloc (line_info_table,
9850 (line_info_table_allocated
9851 * sizeof (dw_line_info_entry)));
9854 /* Add the new entry at the end of the line_info_table. */
9855 line_info = &line_info_table[line_info_table_in_use++];
9856 line_info->dw_file_num = lookup_filename (filename);
9857 line_info->dw_line_num = line;
9862 /* Record the beginning of a new source file, for later output
9863 of the .debug_macinfo section. At present, unimplemented. */
9866 dwarf2out_start_source_file (filename)
9867 register const char *filename ATTRIBUTE_UNUSED;
9871 /* Record the end of a source file, for later output
9872 of the .debug_macinfo section. At present, unimplemented. */
9875 dwarf2out_end_source_file ()
9879 /* Called from check_newline in c-parse.y. The `buffer' parameter contains
9880 the tail part of the directive line, i.e. the part which is past the
9881 initial whitespace, #, whitespace, directive-name, whitespace part. */
9884 dwarf2out_define (lineno, buffer)
9885 register unsigned lineno ATTRIBUTE_UNUSED;
9886 register const char *buffer ATTRIBUTE_UNUSED;
9888 static int initialized = 0;
9891 dwarf2out_start_source_file (primary_filename);
9896 /* Called from check_newline in c-parse.y. The `buffer' parameter contains
9897 the tail part of the directive line, i.e. the part which is past the
9898 initial whitespace, #, whitespace, directive-name, whitespace part. */
9901 dwarf2out_undef (lineno, buffer)
9902 register unsigned lineno ATTRIBUTE_UNUSED;
9903 register const char *buffer ATTRIBUTE_UNUSED;
9907 /* Set up for Dwarf output at the start of compilation. */
9910 dwarf2out_init (asm_out_file, main_input_filename)
9911 register FILE *asm_out_file;
9912 register char *main_input_filename;
9914 /* Remember the name of the primary input file. */
9915 primary_filename = main_input_filename;
9917 /* Allocate the initial hunk of the file_table. */
9918 file_table = (char **) xcalloc (FILE_TABLE_INCREMENT, sizeof (char *));
9919 file_table_allocated = FILE_TABLE_INCREMENT;
9921 /* Skip the first entry - file numbers begin at 1. */
9922 file_table_in_use = 1;
9924 /* Allocate the initial hunk of the decl_die_table. */
9926 = (dw_die_ref *) xcalloc (DECL_DIE_TABLE_INCREMENT, sizeof (dw_die_ref));
9927 decl_die_table_allocated = DECL_DIE_TABLE_INCREMENT;
9928 decl_die_table_in_use = 0;
9930 /* Allocate the initial hunk of the decl_scope_table. */
9932 = (tree *) xcalloc (DECL_SCOPE_TABLE_INCREMENT, sizeof (tree));
9933 decl_scope_table_allocated = DECL_SCOPE_TABLE_INCREMENT;
9934 decl_scope_depth = 0;
9936 /* Allocate the initial hunk of the abbrev_die_table. */
9938 = (dw_die_ref *) xcalloc (ABBREV_DIE_TABLE_INCREMENT,
9939 sizeof (dw_die_ref));
9940 abbrev_die_table_allocated = ABBREV_DIE_TABLE_INCREMENT;
9941 /* Zero-th entry is allocated, but unused */
9942 abbrev_die_table_in_use = 1;
9944 /* Allocate the initial hunk of the line_info_table. */
9946 = (dw_line_info_ref) xcalloc (LINE_INFO_TABLE_INCREMENT,
9947 sizeof (dw_line_info_entry));
9948 line_info_table_allocated = LINE_INFO_TABLE_INCREMENT;
9949 /* Zero-th entry is allocated, but unused */
9950 line_info_table_in_use = 1;
9952 /* Generate the initial DIE for the .debug section. Note that the (string)
9953 value given in the DW_AT_name attribute of the DW_TAG_compile_unit DIE
9954 will (typically) be a relative pathname and that this pathname should be
9955 taken as being relative to the directory from which the compiler was
9956 invoked when the given (base) source file was compiled. */
9957 comp_unit_die = gen_compile_unit_die (main_input_filename);
9959 ASM_GENERATE_INTERNAL_LABEL (text_end_label, TEXT_END_LABEL, 0);
9960 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label, ABBREV_SECTION_LABEL, 0);
9961 if (DWARF2_GENERATE_TEXT_SECTION_LABEL)
9962 ASM_GENERATE_INTERNAL_LABEL (text_section_label, TEXT_SECTION_LABEL, 0);
9964 strcpy (text_section_label, stripattributes (TEXT_SECTION));
9965 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label,
9966 DEBUG_INFO_SECTION_LABEL, 0);
9967 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label,
9968 DEBUG_LINE_SECTION_LABEL, 0);
9970 ASM_OUTPUT_SECTION (asm_out_file, ABBREV_SECTION);
9971 ASM_OUTPUT_LABEL (asm_out_file, abbrev_section_label);
9972 if (DWARF2_GENERATE_TEXT_SECTION_LABEL)
9974 ASM_OUTPUT_SECTION (asm_out_file, TEXT_SECTION);
9975 ASM_OUTPUT_LABEL (asm_out_file, text_section_label);
9977 ASM_OUTPUT_SECTION (asm_out_file, DEBUG_INFO_SECTION);
9978 ASM_OUTPUT_LABEL (asm_out_file, debug_info_section_label);
9979 ASM_OUTPUT_SECTION (asm_out_file, DEBUG_LINE_SECTION);
9980 ASM_OUTPUT_LABEL (asm_out_file, debug_line_section_label);
9983 /* Output stuff that dwarf requires at the end of every file,
9984 and generate the DWARF-2 debugging info. */
9989 limbo_die_node *node, *next_node;
9992 /* Traverse the limbo die list, and add parent/child links. The only
9993 dies without parents that should be here are concrete instances of
9994 inline functions, and the comp_unit_die. We can ignore the comp_unit_die.
9995 For concrete instances, we can get the parent die from the abstract
9997 for (node = limbo_die_list; node; node = next_node)
9999 next_node = node->next;
10002 if (die->die_parent == NULL)
10004 dw_die_ref origin = get_AT_ref (die, DW_AT_abstract_origin);
10006 add_child_die (origin->die_parent, die);
10007 else if (die == comp_unit_die)
10014 limbo_die_list = NULL;
10016 /* Walk through the list of incomplete types again, trying once more to
10017 emit full debugging info for them. */
10018 retry_incomplete_types ();
10020 /* Traverse the DIE's, reverse their lists of attributes and children,
10021 and add add sibling attributes to those DIE's that have children. */
10022 add_sibling_attributes (comp_unit_die);
10024 /* Output a terminator label for the .text section. */
10025 fputc ('\n', asm_out_file);
10026 ASM_OUTPUT_SECTION (asm_out_file, TEXT_SECTION);
10027 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, TEXT_END_LABEL, 0);
10030 /* Output a terminator label for the .data section. */
10031 fputc ('\n', asm_out_file);
10032 ASM_OUTPUT_SECTION (asm_out_file, DATA_SECTION);
10033 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, DATA_END_LABEL, 0);
10035 /* Output a terminator label for the .bss section. */
10036 fputc ('\n', asm_out_file);
10037 ASM_OUTPUT_SECTION (asm_out_file, BSS_SECTION);
10038 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, BSS_END_LABEL, 0);
10041 /* Output the source line correspondence table. */
10042 if (line_info_table_in_use > 1 || separate_line_info_table_in_use)
10044 if (! DWARF2_ASM_LINE_DEBUG_INFO)
10046 fputc ('\n', asm_out_file);
10047 ASM_OUTPUT_SECTION (asm_out_file, DEBUG_LINE_SECTION);
10048 output_line_info ();
10051 /* We can only use the low/high_pc attributes if all of the code
10053 if (separate_line_info_table_in_use == 0)
10055 add_AT_lbl_id (comp_unit_die, DW_AT_low_pc, text_section_label);
10056 add_AT_lbl_id (comp_unit_die, DW_AT_high_pc, text_end_label);
10059 add_AT_lbl_offset (comp_unit_die, DW_AT_stmt_list,
10060 debug_line_section_label);
10063 #if 0 /* unimplemented */
10064 if (debug_info_level >= DINFO_LEVEL_VERBOSE && primary)
10065 add_AT_unsigned (die, DW_AT_macro_info, 0);
10068 /* Output the abbreviation table. */
10069 fputc ('\n', asm_out_file);
10070 ASM_OUTPUT_SECTION (asm_out_file, ABBREV_SECTION);
10071 build_abbrev_table (comp_unit_die);
10072 output_abbrev_section ();
10074 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
10075 next_die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE;
10076 calc_die_sizes (comp_unit_die);
10078 /* Output debugging information. */
10079 fputc ('\n', asm_out_file);
10080 ASM_OUTPUT_SECTION (asm_out_file, DEBUG_INFO_SECTION);
10081 output_compilation_unit_header ();
10082 output_die (comp_unit_die);
10084 if (pubname_table_in_use)
10086 /* Output public names table. */
10087 fputc ('\n', asm_out_file);
10088 ASM_OUTPUT_SECTION (asm_out_file, PUBNAMES_SECTION);
10089 output_pubnames ();
10092 /* We only put functions in the arange table, so don't write it out if
10093 we don't have any. */
10094 if (fde_table_in_use)
10096 /* Output the address range information. */
10097 fputc ('\n', asm_out_file);
10098 ASM_OUTPUT_SECTION (asm_out_file, ARANGES_SECTION);
10102 #endif /* DWARF2_DEBUGGING_INFO */