1 /* Output Dwarf2 format symbol table information from the GNU C compiler.
2 Copyright (C) 1992, 1993, 1995, 1996, 1997 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
23 /* The first part of this file deals with the DWARF 2 frame unwind
24 information, which is also used by the GCC efficient exception handling
25 mechanism. The second part, controlled only by an #ifdef
26 DWARF2_DEBUGGING_INFO, deals with the other DWARF 2 debugging
35 #include "hard-reg-set.h"
37 #include "insn-config.h"
44 /* Decide whether we want to emit frame unwind information for the current
50 return (write_symbols == DWARF2_DEBUG
51 #ifdef DWARF2_UNWIND_INFO
52 || (flag_exceptions && ! exceptions_via_longjmp)
57 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
63 /* How to start an assembler comment. */
64 #ifndef ASM_COMMENT_START
65 #define ASM_COMMENT_START ";#"
68 typedef struct dw_cfi_struct *dw_cfi_ref;
69 typedef struct dw_fde_struct *dw_fde_ref;
70 typedef union dw_cfi_oprnd_struct *dw_cfi_oprnd_ref;
72 /* Call frames are described using a sequence of Call Frame
73 Information instructions. The register number, offset
74 and address fields are provided as possible operands;
75 their use is selected by the opcode field. */
77 typedef union dw_cfi_oprnd_struct
79 unsigned long dw_cfi_reg_num;
80 long int dw_cfi_offset;
85 typedef struct dw_cfi_struct
87 dw_cfi_ref dw_cfi_next;
88 enum dwarf_call_frame_info dw_cfi_opc;
89 dw_cfi_oprnd dw_cfi_oprnd1;
90 dw_cfi_oprnd dw_cfi_oprnd2;
94 /* All call frame descriptions (FDE's) in the GCC generated DWARF
95 refer to a single Common Information Entry (CIE), defined at
96 the beginning of the .debug_frame section. This used of a single
97 CIE obviates the need to keep track of multiple CIE's
98 in the DWARF generation routines below. */
100 typedef struct dw_fde_struct
103 char *dw_fde_current_label;
105 dw_cfi_ref dw_fde_cfi;
109 /* Maximum size (in bytes) of an artificially generated label. */
110 #define MAX_ARTIFICIAL_LABEL_BYTES 30
112 /* Make sure we know the sizes of the various types dwarf can describe. These
113 are only defaults. If the sizes are different for your target, you should
114 override these values by defining the appropriate symbols in your tm.h
117 #ifndef CHAR_TYPE_SIZE
118 #define CHAR_TYPE_SIZE BITS_PER_UNIT
121 #define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
124 /* The size in bytes of a DWARF field indicating an offset or length
125 relative to a debug info section, specified to be 4 bytes in the DWARF-2
126 specification. The SGI/MIPS ABI defines it to be the same as PTR_SIZE. */
128 #ifndef DWARF_OFFSET_SIZE
129 #define DWARF_OFFSET_SIZE 4
132 #define DWARF_VERSION 2
134 /* Round SIZE up to the nearest BOUNDARY. */
135 #define DWARF_ROUND(SIZE,BOUNDARY) \
136 (((SIZE) + (BOUNDARY) - 1) & ~((BOUNDARY) - 1))
138 /* Offsets recorded in opcodes are a multiple of this alignment factor. */
139 #ifdef STACK_GROWS_DOWNWARD
140 #define DWARF_CIE_DATA_ALIGNMENT (-UNITS_PER_WORD)
142 #define DWARF_CIE_DATA_ALIGNMENT UNITS_PER_WORD
145 /* A pointer to the base of a table that contains frame description
146 information for each routine. */
147 static dw_fde_ref fde_table;
149 /* Number of elements currently allocated for fde_table. */
150 static unsigned fde_table_allocated;
152 /* Number of elements in fde_table currently in use. */
153 static unsigned fde_table_in_use;
155 /* Size (in elements) of increments by which we may expand the
157 #define FDE_TABLE_INCREMENT 256
159 /* A list of call frame insns for the CIE. */
160 static dw_cfi_ref cie_cfi_head;
162 /* The number of the current function definition for which debugging
163 information is being generated. These numbers range from 1 up to the
164 maximum number of function definitions contained within the current
165 compilation unit. These numbers are used to create unique label id's
166 unique to each function definition. */
167 static unsigned current_funcdef_number = 0;
169 /* Some DWARF extensions (e.g., MIPS/SGI) implement a subprogram
170 attribute that accelerates the lookup of the FDE associated
171 with the subprogram. This variable holds the table index of the FDE
172 associated with the current function (body) definition. */
173 static unsigned current_funcdef_fde;
175 /* Forward declarations for functions defined in this file. */
177 static char *stripattributes PROTO((char *));
178 static char *dwarf_cfi_name PROTO((unsigned));
179 static dw_cfi_ref new_cfi PROTO((void));
180 static void add_cfi PROTO((dw_cfi_ref *, dw_cfi_ref));
181 static unsigned long size_of_uleb128 PROTO((unsigned long));
182 static unsigned long size_of_sleb128 PROTO((long));
183 static void output_uleb128 PROTO((unsigned long));
184 static void output_sleb128 PROTO((long));
185 static void add_fde_cfi PROTO((char *, dw_cfi_ref));
186 static void lookup_cfa_1 PROTO((dw_cfi_ref, unsigned long *,
188 static void lookup_cfa PROTO((unsigned long *, long *));
189 static void reg_save PROTO((char *, unsigned, unsigned,
191 static void initial_return_save PROTO((rtx));
192 static void output_cfi PROTO((dw_cfi_ref, dw_fde_ref));
193 static void output_call_frame_info PROTO((int));
194 static unsigned reg_number PROTO((rtx));
196 /* Definitions of defaults for assembler-dependent names of various
197 pseudo-ops and section names.
198 Theses may be overridden in the tm.h file (if necessary) for a particular
201 #ifdef OBJECT_FORMAT_ELF
202 #ifndef UNALIGNED_SHORT_ASM_OP
203 #define UNALIGNED_SHORT_ASM_OP ".2byte"
205 #ifndef UNALIGNED_INT_ASM_OP
206 #define UNALIGNED_INT_ASM_OP ".4byte"
208 #ifndef UNALIGNED_DOUBLE_INT_ASM_OP
209 #define UNALIGNED_DOUBLE_INT_ASM_OP ".8byte"
211 #endif /* OBJECT_FORMAT_ELF */
214 #define ASM_BYTE_OP ".byte"
217 /* Data and reference forms for relocatable data. */
218 #define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
219 #define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
221 /* Pseudo-op for defining a new section. */
222 #ifndef SECTION_ASM_OP
223 #define SECTION_ASM_OP ".section"
226 /* The default format used by the ASM_OUTPUT_SECTION macro (see below) to
227 print the SECTION_ASM_OP and the section name. The default here works for
228 almost all svr4 assemblers, except for the sparc, where the section name
229 must be enclosed in double quotes. (See sparcv4.h). */
230 #ifndef SECTION_FORMAT
231 #ifdef PUSHSECTION_FORMAT
232 #define SECTION_FORMAT PUSHSECTION_FORMAT
234 #define SECTION_FORMAT "\t%s\t%s\n"
238 #ifndef FRAME_SECTION
239 #define FRAME_SECTION ".debug_frame"
242 #ifndef FUNC_BEGIN_LABEL
243 #define FUNC_BEGIN_LABEL "LFB"
245 #ifndef FUNC_END_LABEL
246 #define FUNC_END_LABEL "LFE"
248 #define CIE_AFTER_SIZE_LABEL "LSCIE"
249 #define CIE_END_LABEL "LECIE"
250 #define CIE_LENGTH_LABEL "LLCIE"
251 #define FDE_AFTER_SIZE_LABEL "LSFDE"
252 #define FDE_END_LABEL "LEFDE"
253 #define FDE_LENGTH_LABEL "LLFDE"
255 /* Definitions of defaults for various types of primitive assembly language
256 output operations. These may be overridden from within the tm.h file,
257 but typically, that is unnecessary. */
259 #ifndef ASM_OUTPUT_SECTION
260 #define ASM_OUTPUT_SECTION(FILE, SECTION) \
261 fprintf ((FILE), SECTION_FORMAT, SECTION_ASM_OP, SECTION)
264 #ifndef ASM_OUTPUT_DWARF_DATA1
265 #define ASM_OUTPUT_DWARF_DATA1(FILE,VALUE) \
266 fprintf ((FILE), "\t%s\t0x%x", ASM_BYTE_OP, VALUE)
269 #ifndef ASM_OUTPUT_DWARF_DELTA1
270 #define ASM_OUTPUT_DWARF_DELTA1(FILE,LABEL1,LABEL2) \
271 do { fprintf ((FILE), "\t%s\t", ASM_BYTE_OP); \
272 assemble_name (FILE, LABEL1); \
273 fprintf (FILE, "-"); \
274 assemble_name (FILE, LABEL2); \
278 #ifdef UNALIGNED_INT_ASM_OP
280 #ifndef UNALIGNED_OFFSET_ASM_OP
281 #define UNALIGNED_OFFSET_ASM_OP \
282 (DWARF_OFFSET_SIZE == 8 ? UNALIGNED_DOUBLE_INT_ASM_OP : UNALIGNED_INT_ASM_OP)
285 #ifndef UNALIGNED_WORD_ASM_OP
286 #define UNALIGNED_WORD_ASM_OP \
287 (PTR_SIZE == 8 ? UNALIGNED_DOUBLE_INT_ASM_OP : UNALIGNED_INT_ASM_OP)
290 #ifndef ASM_OUTPUT_DWARF_DELTA2
291 #define ASM_OUTPUT_DWARF_DELTA2(FILE,LABEL1,LABEL2) \
292 do { fprintf ((FILE), "\t%s\t", UNALIGNED_SHORT_ASM_OP); \
293 assemble_name (FILE, LABEL1); \
294 fprintf (FILE, "-"); \
295 assemble_name (FILE, LABEL2); \
299 #ifndef ASM_OUTPUT_DWARF_DELTA4
300 #define ASM_OUTPUT_DWARF_DELTA4(FILE,LABEL1,LABEL2) \
301 do { fprintf ((FILE), "\t%s\t", UNALIGNED_INT_ASM_OP); \
302 assemble_name (FILE, LABEL1); \
303 fprintf (FILE, "-"); \
304 assemble_name (FILE, LABEL2); \
308 #ifndef ASM_OUTPUT_DWARF_DELTA
309 #define ASM_OUTPUT_DWARF_DELTA(FILE,LABEL1,LABEL2) \
310 do { fprintf ((FILE), "\t%s\t", UNALIGNED_OFFSET_ASM_OP); \
311 assemble_name (FILE, LABEL1); \
312 fprintf (FILE, "-"); \
313 assemble_name (FILE, LABEL2); \
317 #ifndef ASM_OUTPUT_DWARF_ADDR_DELTA
318 #define ASM_OUTPUT_DWARF_ADDR_DELTA(FILE,LABEL1,LABEL2) \
319 do { fprintf ((FILE), "\t%s\t", UNALIGNED_WORD_ASM_OP); \
320 assemble_name (FILE, LABEL1); \
321 fprintf (FILE, "-"); \
322 assemble_name (FILE, LABEL2); \
326 #ifndef ASM_OUTPUT_DWARF_ADDR
327 #define ASM_OUTPUT_DWARF_ADDR(FILE,LABEL) \
328 do { fprintf ((FILE), "\t%s\t", UNALIGNED_WORD_ASM_OP); \
329 assemble_name (FILE, LABEL); \
333 #ifndef ASM_OUTPUT_DWARF_ADDR_CONST
334 #define ASM_OUTPUT_DWARF_ADDR_CONST(FILE,ADDR) \
335 fprintf ((FILE), "\t%s\t%s", UNALIGNED_WORD_ASM_OP, (ADDR))
338 #ifndef ASM_OUTPUT_DWARF_OFFSET4
339 #define ASM_OUTPUT_DWARF_OFFSET4(FILE,LABEL) \
340 do { fprintf ((FILE), "\t%s\t", UNALIGNED_INT_ASM_OP); \
341 assemble_name (FILE, LABEL); \
345 #ifndef ASM_OUTPUT_DWARF_OFFSET
346 #define ASM_OUTPUT_DWARF_OFFSET(FILE,LABEL) \
347 do { fprintf ((FILE), "\t%s\t", UNALIGNED_OFFSET_ASM_OP); \
348 assemble_name (FILE, LABEL); \
352 #ifndef ASM_OUTPUT_DWARF_DATA2
353 #define ASM_OUTPUT_DWARF_DATA2(FILE,VALUE) \
354 fprintf ((FILE), "\t%s\t0x%x", UNALIGNED_SHORT_ASM_OP, (unsigned) VALUE)
357 #ifndef ASM_OUTPUT_DWARF_DATA4
358 #define ASM_OUTPUT_DWARF_DATA4(FILE,VALUE) \
359 fprintf ((FILE), "\t%s\t0x%x", UNALIGNED_INT_ASM_OP, (unsigned) VALUE)
362 #ifndef ASM_OUTPUT_DWARF_DATA
363 #define ASM_OUTPUT_DWARF_DATA(FILE,VALUE) \
364 fprintf ((FILE), "\t%s\t0x%lx", UNALIGNED_OFFSET_ASM_OP, \
365 (unsigned long) VALUE)
368 #ifndef ASM_OUTPUT_DWARF_ADDR_DATA
369 #define ASM_OUTPUT_DWARF_ADDR_DATA(FILE,VALUE) \
370 fprintf ((FILE), "\t%s\t0x%lx", UNALIGNED_WORD_ASM_OP, \
371 (unsigned long) VALUE)
374 #ifndef ASM_OUTPUT_DWARF_DATA8
375 #define ASM_OUTPUT_DWARF_DATA8(FILE,HIGH_VALUE,LOW_VALUE) \
377 if (WORDS_BIG_ENDIAN) \
379 fprintf ((FILE), "\t%s\t0x%x\n", UNALIGNED_INT_ASM_OP, HIGH_VALUE); \
380 fprintf ((FILE), "\t%s\t0x%x", UNALIGNED_INT_ASM_OP, LOW_VALUE);\
384 fprintf ((FILE), "\t%s\t0x%x\n", UNALIGNED_INT_ASM_OP, LOW_VALUE);\
385 fprintf ((FILE), "\t%s\t0x%x", UNALIGNED_INT_ASM_OP, HIGH_VALUE); \
390 #else /* UNALIGNED_INT_ASM_OP */
392 /* We don't have unaligned support, let's hope the normal output works for
395 #define ASM_OUTPUT_DWARF_ADDR(FILE,LABEL) \
396 assemble_integer (gen_rtx (SYMBOL_REF, Pmode, LABEL), PTR_SIZE, 1)
398 #define ASM_OUTPUT_DWARF_OFFSET4(FILE,LABEL) \
399 assemble_integer (gen_rtx (SYMBOL_REF, SImode, LABEL), 4, 1)
401 #define ASM_OUTPUT_DWARF_OFFSET(FILE,LABEL) \
402 assemble_integer (gen_rtx (SYMBOL_REF, SImode, LABEL), 4, 1)
404 #define ASM_OUTPUT_DWARF_DELTA2(FILE,LABEL1,LABEL2) \
405 assemble_integer (gen_rtx (MINUS, HImode, \
406 gen_rtx (SYMBOL_REF, Pmode, LABEL1), \
407 gen_rtx (SYMBOL_REF, Pmode, LABEL2)), \
410 #define ASM_OUTPUT_DWARF_DELTA4(FILE,LABEL1,LABEL2) \
411 assemble_integer (gen_rtx (MINUS, SImode, \
412 gen_rtx (SYMBOL_REF, Pmode, LABEL1), \
413 gen_rtx (SYMBOL_REF, Pmode, LABEL2)), \
416 #define ASM_OUTPUT_DWARF_ADDR_DELTA(FILE,LABEL1,LABEL2) \
417 assemble_integer (gen_rtx (MINUS, Pmode, \
418 gen_rtx (SYMBOL_REF, Pmode, LABEL1), \
419 gen_rtx (SYMBOL_REF, Pmode, LABEL2)), \
422 #define ASM_OUTPUT_DWARF_DELTA(FILE,LABEL1,LABEL2) \
423 ASM_OUTPUT_DWARF_DELTA4 (FILE,LABEL1,LABEL2)
425 #define ASM_OUTPUT_DWARF_DATA4(FILE,VALUE) \
426 assemble_integer (GEN_INT (VALUE), 4, 1)
428 #endif /* UNALIGNED_INT_ASM_OP */
431 #ifndef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
432 #define ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL(FILE, SY, HI, LO) \
434 fprintf (FILE, "\t%s\t", SET_ASM_OP); \
435 assemble_name (FILE, SY); \
437 assemble_name (FILE, HI); \
439 assemble_name (FILE, LO); \
442 #endif /* SET_ASM_OP */
444 /* This is similar to the default ASM_OUTPUT_ASCII, except that no trailing
445 newline is produced. When flag_debug_asm is asserted, we add commentary
446 at the end of the line, so we must avoid output of a newline here. */
447 #ifndef ASM_OUTPUT_DWARF_STRING
448 #define ASM_OUTPUT_DWARF_STRING(FILE,P) \
450 register int slen = strlen(P); \
451 register char *p = (P); \
453 fprintf (FILE, "\t.ascii \""); \
454 for (i = 0; i < slen; i++) \
456 register int c = p[i]; \
457 if (c == '\"' || c == '\\') \
459 if (c >= ' ' && c < 0177) \
463 fprintf (FILE, "\\%o", c); \
466 fprintf (FILE, "\\0\""); \
471 /* The DWARF 2 CFA column which tracks the return address. Normally this
472 is the column for PC, or the first column after all of the hard
474 #ifndef DWARF_FRAME_RETURN_COLUMN
476 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (PC_REGNUM)
478 #define DWARF_FRAME_RETURN_COLUMN FIRST_PSEUDO_REGISTER
482 /* The mapping from gcc register number to DWARF 2 CFA column number. By
483 default, we just provide columns for all registers. */
484 #ifndef DWARF_FRAME_REGNUM
485 #define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG)
488 /* Hook used by __throw. */
491 expand_builtin_dwarf_fp_regnum ()
493 return GEN_INT (DWARF_FRAME_REGNUM (HARD_FRAME_POINTER_REGNUM));
496 /* The offset from the incoming value of %sp to the top of the stack frame
497 for the current function. */
498 #ifndef INCOMING_FRAME_SP_OFFSET
499 #define INCOMING_FRAME_SP_OFFSET 0
502 /* Return a pointer to a copy of the section string name S with all
503 attributes stripped off. */
509 char *stripped = xstrdup (s);
512 while (*p && *p != ',')
519 /* Return the register number described by a given RTL node. */
525 register unsigned regno = REGNO (rtl);
527 if (regno >= FIRST_PSEUDO_REGISTER)
529 warning ("internal regno botch: regno = %d\n", regno);
533 regno = DBX_REGISTER_NUMBER (regno);
537 struct reg_size_range
544 /* Given a register number in REG_TREE, return an rtx for its size in bytes.
545 We do this in kind of a roundabout way, by building up a list of
546 register size ranges and seeing where our register falls in one of those
547 ranges. We need to do it this way because REG_TREE is not a constant,
548 and the target macros were not designed to make this task easy. */
551 expand_builtin_dwarf_reg_size (reg_tree, target)
555 enum machine_mode mode;
557 struct reg_size_range ranges[5];
564 for (; i < FIRST_PSEUDO_REGISTER; ++i)
566 /* The return address is out of order on the MIPS, and we don't use
567 copy_reg for it anyway, so we don't care here how large it is. */
568 if (DWARF_FRAME_REGNUM (i) == DWARF_FRAME_RETURN_COLUMN)
571 mode = reg_raw_mode[i];
572 /* CCmode is arbitrarily given a size of 4 bytes. It is more useful
573 to use the same size as word_mode, since that reduces the number
574 of ranges we need. It should not matter, since the result should
575 never be used for a condition code register anyways. */
578 size = GET_MODE_SIZE (mode);
580 if (size != last_size)
582 ranges[n_ranges].beg = i;
583 ranges[n_ranges].size = last_size = GET_MODE_SIZE (reg_raw_mode[i]);
588 ranges[n_ranges-1].end = i;
591 /* The usual case: fp regs surrounded by general regs. */
592 if (n_ranges == 3 && ranges[0].size == ranges[2].size)
594 if ((DWARF_FRAME_REGNUM (ranges[1].end)
595 - DWARF_FRAME_REGNUM (ranges[1].beg))
596 != ranges[1].end - ranges[1].beg)
598 t = fold (build (GE_EXPR, integer_type_node, reg_tree,
599 build_int_2 (DWARF_FRAME_REGNUM (ranges[1].beg), 0)));
600 t2 = fold (build (LE_EXPR, integer_type_node, reg_tree,
601 build_int_2 (DWARF_FRAME_REGNUM (ranges[1].end), 0)));
602 t = fold (build (TRUTH_ANDIF_EXPR, integer_type_node, t, t2));
603 t = fold (build (COND_EXPR, integer_type_node, t,
604 build_int_2 (ranges[1].size, 0),
605 build_int_2 (ranges[0].size, 0)));
610 t = build_int_2 (ranges[n_ranges].size, 0);
611 size = DWARF_FRAME_REGNUM (ranges[n_ranges].beg);
614 if ((DWARF_FRAME_REGNUM (ranges[n_ranges].end)
615 - DWARF_FRAME_REGNUM (ranges[n_ranges].beg))
616 != ranges[n_ranges].end - ranges[n_ranges].beg)
618 if (DWARF_FRAME_REGNUM (ranges[n_ranges].beg) >= size)
620 size = DWARF_FRAME_REGNUM (ranges[n_ranges].beg);
621 t2 = fold (build (LE_EXPR, integer_type_node, reg_tree,
622 build_int_2 (DWARF_FRAME_REGNUM
623 (ranges[n_ranges].end), 0)));
624 t = fold (build (COND_EXPR, integer_type_node, t2,
625 build_int_2 (ranges[n_ranges].size, 0), t));
628 return expand_expr (t, target, Pmode, 0);
631 /* Convert a DWARF call frame info. operation to its string name */
634 dwarf_cfi_name (cfi_opc)
635 register unsigned cfi_opc;
639 case DW_CFA_advance_loc:
640 return "DW_CFA_advance_loc";
642 return "DW_CFA_offset";
644 return "DW_CFA_restore";
648 return "DW_CFA_set_loc";
649 case DW_CFA_advance_loc1:
650 return "DW_CFA_advance_loc1";
651 case DW_CFA_advance_loc2:
652 return "DW_CFA_advance_loc2";
653 case DW_CFA_advance_loc4:
654 return "DW_CFA_advance_loc4";
655 case DW_CFA_offset_extended:
656 return "DW_CFA_offset_extended";
657 case DW_CFA_restore_extended:
658 return "DW_CFA_restore_extended";
659 case DW_CFA_undefined:
660 return "DW_CFA_undefined";
661 case DW_CFA_same_value:
662 return "DW_CFA_same_value";
663 case DW_CFA_register:
664 return "DW_CFA_register";
665 case DW_CFA_remember_state:
666 return "DW_CFA_remember_state";
667 case DW_CFA_restore_state:
668 return "DW_CFA_restore_state";
670 return "DW_CFA_def_cfa";
671 case DW_CFA_def_cfa_register:
672 return "DW_CFA_def_cfa_register";
673 case DW_CFA_def_cfa_offset:
674 return "DW_CFA_def_cfa_offset";
676 /* SGI/MIPS specific */
677 case DW_CFA_MIPS_advance_loc8:
678 return "DW_CFA_MIPS_advance_loc8";
681 case DW_CFA_GNU_window_save:
682 return "DW_CFA_GNU_window_save";
683 case DW_CFA_GNU_args_size:
684 return "DW_CFA_GNU_args_size";
687 return "DW_CFA_<unknown>";
691 /* Return a pointer to a newly allocated Call Frame Instruction. */
693 static inline dw_cfi_ref
696 register dw_cfi_ref cfi = (dw_cfi_ref) xmalloc (sizeof (dw_cfi_node));
698 cfi->dw_cfi_next = NULL;
699 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = 0;
700 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = 0;
705 /* Add a Call Frame Instruction to list of instructions. */
708 add_cfi (list_head, cfi)
709 register dw_cfi_ref *list_head;
710 register dw_cfi_ref cfi;
712 register dw_cfi_ref *p;
714 /* Find the end of the chain. */
715 for (p = list_head; (*p) != NULL; p = &(*p)->dw_cfi_next)
721 /* Generate a new label for the CFI info to refer to. */
724 dwarf2out_cfi_label ()
726 static char label[20];
727 static unsigned long label_num = 0;
729 ASM_GENERATE_INTERNAL_LABEL (label, "LCFI", label_num++);
730 ASM_OUTPUT_LABEL (asm_out_file, label);
735 /* Add CFI to the current fde at the PC value indicated by LABEL if specified,
736 or to the CIE if LABEL is NULL. */
739 add_fde_cfi (label, cfi)
740 register char *label;
741 register dw_cfi_ref cfi;
745 register dw_fde_ref fde = &fde_table[fde_table_in_use - 1];
748 label = dwarf2out_cfi_label ();
750 if (fde->dw_fde_current_label == NULL
751 || strcmp (label, fde->dw_fde_current_label) != 0)
753 register dw_cfi_ref xcfi;
755 fde->dw_fde_current_label = label = xstrdup (label);
757 /* Set the location counter to the new label. */
759 xcfi->dw_cfi_opc = DW_CFA_advance_loc4;
760 xcfi->dw_cfi_oprnd1.dw_cfi_addr = label;
761 add_cfi (&fde->dw_fde_cfi, xcfi);
764 add_cfi (&fde->dw_fde_cfi, cfi);
768 add_cfi (&cie_cfi_head, cfi);
771 /* Subroutine of lookup_cfa. */
774 lookup_cfa_1 (cfi, regp, offsetp)
775 register dw_cfi_ref cfi;
776 register unsigned long *regp;
777 register long *offsetp;
779 switch (cfi->dw_cfi_opc)
781 case DW_CFA_def_cfa_offset:
782 *offsetp = cfi->dw_cfi_oprnd1.dw_cfi_offset;
784 case DW_CFA_def_cfa_register:
785 *regp = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
788 *regp = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
789 *offsetp = cfi->dw_cfi_oprnd2.dw_cfi_offset;
796 /* Find the previous value for the CFA. */
799 lookup_cfa (regp, offsetp)
800 register unsigned long *regp;
801 register long *offsetp;
803 register dw_cfi_ref cfi;
805 *regp = (unsigned long) -1;
808 for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
809 lookup_cfa_1 (cfi, regp, offsetp);
811 if (fde_table_in_use)
813 register dw_fde_ref fde = &fde_table[fde_table_in_use - 1];
814 for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
815 lookup_cfa_1 (cfi, regp, offsetp);
819 /* The current rule for calculating the DWARF2 canonical frame address. */
820 static unsigned long cfa_reg;
821 static long cfa_offset;
823 /* The register used for saving registers to the stack, and its offset
825 static unsigned cfa_store_reg;
826 static long cfa_store_offset;
828 /* The running total of the size of arguments pushed onto the stack. */
829 static long args_size;
831 /* Entry point to update the canonical frame address (CFA).
832 LABEL is passed to add_fde_cfi. The value of CFA is now to be
833 calculated from REG+OFFSET. */
836 dwarf2out_def_cfa (label, reg, offset)
837 register char *label;
838 register unsigned reg;
839 register long offset;
841 register dw_cfi_ref cfi;
842 unsigned long old_reg;
847 if (cfa_store_reg == reg)
848 cfa_store_offset = offset;
850 reg = DWARF_FRAME_REGNUM (reg);
851 lookup_cfa (&old_reg, &old_offset);
853 if (reg == old_reg && offset == old_offset)
860 cfi->dw_cfi_opc = DW_CFA_def_cfa_offset;
861 cfi->dw_cfi_oprnd1.dw_cfi_offset = offset;
864 #ifndef MIPS_DEBUGGING_INFO /* SGI dbx thinks this means no offset. */
865 else if (offset == old_offset && old_reg != (unsigned long) -1)
867 cfi->dw_cfi_opc = DW_CFA_def_cfa_register;
868 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
874 cfi->dw_cfi_opc = DW_CFA_def_cfa;
875 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
876 cfi->dw_cfi_oprnd2.dw_cfi_offset = offset;
879 add_fde_cfi (label, cfi);
882 /* Add the CFI for saving a register. REG is the CFA column number.
883 LABEL is passed to add_fde_cfi.
884 If SREG is -1, the register is saved at OFFSET from the CFA;
885 otherwise it is saved in SREG. */
888 reg_save (label, reg, sreg, offset)
889 register char * label;
890 register unsigned reg;
891 register unsigned sreg;
892 register long offset;
894 register dw_cfi_ref cfi = new_cfi ();
896 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
901 /* The register number won't fit in 6 bits, so we have to use
903 cfi->dw_cfi_opc = DW_CFA_offset_extended;
905 cfi->dw_cfi_opc = DW_CFA_offset;
907 offset /= DWARF_CIE_DATA_ALIGNMENT;
910 cfi->dw_cfi_oprnd2.dw_cfi_offset = offset;
914 cfi->dw_cfi_opc = DW_CFA_register;
915 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = sreg;
918 add_fde_cfi (label, cfi);
921 /* Add the CFI for saving a register window. LABEL is passed to reg_save.
922 This CFI tells the unwinder that it needs to restore the window registers
923 from the previous frame's window save area.
925 ??? Perhaps we should note in the CIE where windows are saved (instead of
926 assuming 0(cfa)) and what registers are in the window. */
929 dwarf2out_window_save (label)
930 register char * label;
932 register dw_cfi_ref cfi = new_cfi ();
933 cfi->dw_cfi_opc = DW_CFA_GNU_window_save;
934 add_fde_cfi (label, cfi);
937 /* Add a CFI to update the running total of the size of arguments
938 pushed onto the stack. */
941 dwarf2out_args_size (label, size)
945 register dw_cfi_ref cfi = new_cfi ();
946 cfi->dw_cfi_opc = DW_CFA_GNU_args_size;
947 cfi->dw_cfi_oprnd1.dw_cfi_offset = size;
948 add_fde_cfi (label, cfi);
951 /* Entry point for saving a register to the stack. REG is the GCC register
952 number. LABEL and OFFSET are passed to reg_save. */
955 dwarf2out_reg_save (label, reg, offset)
956 register char * label;
957 register unsigned reg;
958 register long offset;
960 reg_save (label, DWARF_FRAME_REGNUM (reg), -1, offset);
963 /* Entry point for saving the return address in the stack.
964 LABEL and OFFSET are passed to reg_save. */
967 dwarf2out_return_save (label, offset)
968 register char * label;
969 register long offset;
971 reg_save (label, DWARF_FRAME_RETURN_COLUMN, -1, offset);
974 /* Entry point for saving the return address in a register.
975 LABEL and SREG are passed to reg_save. */
978 dwarf2out_return_reg (label, sreg)
979 register char * label;
980 register unsigned sreg;
982 reg_save (label, DWARF_FRAME_RETURN_COLUMN, sreg, 0);
985 /* Record the initial position of the return address. RTL is
986 INCOMING_RETURN_ADDR_RTX. */
989 initial_return_save (rtl)
995 switch (GET_CODE (rtl))
998 /* RA is in a register. */
999 reg = reg_number (rtl);
1002 /* RA is on the stack. */
1003 rtl = XEXP (rtl, 0);
1004 switch (GET_CODE (rtl))
1007 if (REGNO (rtl) != STACK_POINTER_REGNUM)
1012 if (REGNO (XEXP (rtl, 0)) != STACK_POINTER_REGNUM)
1014 offset = INTVAL (XEXP (rtl, 1));
1017 if (REGNO (XEXP (rtl, 0)) != STACK_POINTER_REGNUM)
1019 offset = -INTVAL (XEXP (rtl, 1));
1026 /* The return address is at some offset from any value we can
1027 actually load. For instance, on the SPARC it is in %i7+8. Just
1028 ignore the offset for now; it doesn't matter for unwinding frames. */
1029 if (GET_CODE (XEXP (rtl, 1)) != CONST_INT)
1031 initial_return_save (XEXP (rtl, 0));
1037 reg_save (NULL, DWARF_FRAME_RETURN_COLUMN, reg, offset - cfa_offset);
1040 /* Check INSN to see if it looks like a push or a stack adjustment, and
1041 make a note of it if it does. EH uses this information to find out how
1042 much extra space it needs to pop off the stack. */
1045 dwarf2out_stack_adjust (insn)
1051 if (GET_CODE (insn) == BARRIER)
1053 /* When we see a BARRIER, we know to reset args_size to 0. Usually
1054 the compiler will have already emitted a stack adjustment, but
1055 doesn't bother for calls to noreturn functions. */
1056 #ifdef STACK_GROWS_DOWNWARD
1057 offset = -args_size;
1062 else if (GET_CODE (PATTERN (insn)) == SET)
1067 insn = PATTERN (insn);
1068 src = SET_SRC (insn);
1069 dest = SET_DEST (insn);
1071 if (dest == stack_pointer_rtx)
1073 /* (set (reg sp) (plus (reg sp) (const_int))) */
1074 code = GET_CODE (src);
1075 if (! (code == PLUS || code == MINUS)
1076 || XEXP (src, 0) != stack_pointer_rtx
1077 || GET_CODE (XEXP (src, 1)) != CONST_INT)
1080 offset = INTVAL (XEXP (src, 1));
1082 else if (GET_CODE (dest) == MEM)
1084 /* (set (mem (pre_dec (reg sp))) (foo)) */
1085 src = XEXP (dest, 0);
1086 code = GET_CODE (src);
1088 if (! (code == PRE_DEC || code == PRE_INC)
1089 || XEXP (src, 0) != stack_pointer_rtx)
1092 offset = GET_MODE_SIZE (GET_MODE (dest));
1097 if (code == PLUS || code == PRE_INC)
1106 if (cfa_reg == STACK_POINTER_REGNUM)
1107 cfa_offset += offset;
1109 #ifndef STACK_GROWS_DOWNWARD
1112 args_size += offset;
1116 label = dwarf2out_cfi_label ();
1117 dwarf2out_def_cfa (label, cfa_reg, cfa_offset);
1118 dwarf2out_args_size (label, args_size);
1121 /* Record call frame debugging information for INSN, which either
1122 sets SP or FP (adjusting how we calculate the frame address) or saves a
1123 register to the stack. If INSN is NULL_RTX, initialize our state. */
1126 dwarf2out_frame_debug (insn)
1133 /* A temporary register used in adjusting SP or setting up the store_reg. */
1134 static unsigned cfa_temp_reg;
1135 static long cfa_temp_value;
1137 if (insn == NULL_RTX)
1139 /* Set up state for generating call frame debug info. */
1140 lookup_cfa (&cfa_reg, &cfa_offset);
1141 if (cfa_reg != DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM))
1143 cfa_reg = STACK_POINTER_REGNUM;
1144 cfa_store_reg = cfa_reg;
1145 cfa_store_offset = cfa_offset;
1151 if (! RTX_FRAME_RELATED_P (insn))
1153 dwarf2out_stack_adjust (insn);
1157 label = dwarf2out_cfi_label ();
1159 insn = PATTERN (insn);
1160 /* Assume that in a PARALLEL prologue insn, only the first elt is
1161 significant. Currently this is true. */
1162 if (GET_CODE (insn) == PARALLEL)
1163 insn = XVECEXP (insn, 0, 0);
1164 if (GET_CODE (insn) != SET)
1167 src = SET_SRC (insn);
1168 dest = SET_DEST (insn);
1170 switch (GET_CODE (dest))
1173 /* Update the CFA rule wrt SP or FP. Make sure src is
1174 relative to the current CFA register. */
1175 switch (GET_CODE (src))
1177 /* Setting FP from SP. */
1179 if (cfa_reg != REGNO (src))
1181 if (REGNO (dest) != STACK_POINTER_REGNUM
1182 && !(frame_pointer_needed
1183 && REGNO (dest) == HARD_FRAME_POINTER_REGNUM))
1185 cfa_reg = REGNO (dest);
1190 if (dest == stack_pointer_rtx)
1193 switch (GET_CODE (XEXP (src, 1)))
1196 offset = INTVAL (XEXP (src, 1));
1199 if (REGNO (XEXP (src, 1)) != cfa_temp_reg)
1201 offset = cfa_temp_value;
1207 if (XEXP (src, 0) == hard_frame_pointer_rtx)
1209 /* Restoring SP from FP in the epilogue. */
1210 if (cfa_reg != HARD_FRAME_POINTER_REGNUM)
1212 cfa_reg = STACK_POINTER_REGNUM;
1214 else if (XEXP (src, 0) != stack_pointer_rtx)
1217 if (GET_CODE (src) == PLUS)
1219 if (cfa_reg == STACK_POINTER_REGNUM)
1220 cfa_offset += offset;
1221 if (cfa_store_reg == STACK_POINTER_REGNUM)
1222 cfa_store_offset += offset;
1224 else if (dest == hard_frame_pointer_rtx)
1226 /* Either setting the FP from an offset of the SP,
1227 or adjusting the FP */
1228 if (! frame_pointer_needed
1229 || REGNO (dest) != HARD_FRAME_POINTER_REGNUM)
1232 if (XEXP (src, 0) == stack_pointer_rtx
1233 && GET_CODE (XEXP (src, 1)) == CONST_INT)
1235 if (cfa_reg != STACK_POINTER_REGNUM)
1237 offset = INTVAL (XEXP (src, 1));
1238 if (GET_CODE (src) == PLUS)
1240 cfa_offset += offset;
1241 cfa_reg = HARD_FRAME_POINTER_REGNUM;
1243 else if (XEXP (src, 0) == hard_frame_pointer_rtx
1244 && GET_CODE (XEXP (src, 1)) == CONST_INT)
1246 if (cfa_reg != HARD_FRAME_POINTER_REGNUM)
1248 offset = INTVAL (XEXP (src, 1));
1249 if (GET_CODE (src) == PLUS)
1251 cfa_offset += offset;
1259 if (GET_CODE (src) != PLUS
1260 || XEXP (src, 1) != stack_pointer_rtx)
1262 if (GET_CODE (XEXP (src, 0)) != REG
1263 || REGNO (XEXP (src, 0)) != cfa_temp_reg)
1265 if (cfa_reg != STACK_POINTER_REGNUM)
1267 cfa_store_reg = REGNO (dest);
1268 cfa_store_offset = cfa_offset - cfa_temp_value;
1273 cfa_temp_reg = REGNO (dest);
1274 cfa_temp_value = INTVAL (src);
1278 if (GET_CODE (XEXP (src, 0)) != REG
1279 || REGNO (XEXP (src, 0)) != cfa_temp_reg
1280 || REGNO (dest) != cfa_temp_reg
1281 || GET_CODE (XEXP (src, 1)) != CONST_INT)
1283 cfa_temp_value |= INTVAL (XEXP (src, 1));
1289 dwarf2out_def_cfa (label, cfa_reg, cfa_offset);
1293 /* Saving a register to the stack. Make sure dest is relative to the
1295 if (GET_CODE (src) != REG)
1297 switch (GET_CODE (XEXP (dest, 0)))
1302 offset = GET_MODE_SIZE (GET_MODE (dest));
1303 if (GET_CODE (XEXP (dest, 0)) == PRE_INC)
1306 if (REGNO (XEXP (XEXP (dest, 0), 0)) != STACK_POINTER_REGNUM
1307 || cfa_store_reg != STACK_POINTER_REGNUM)
1309 cfa_store_offset += offset;
1310 if (cfa_reg == STACK_POINTER_REGNUM)
1311 cfa_offset = cfa_store_offset;
1313 offset = -cfa_store_offset;
1316 /* With an offset. */
1319 offset = INTVAL (XEXP (XEXP (dest, 0), 1));
1320 if (GET_CODE (src) == MINUS)
1323 if (cfa_store_reg != REGNO (XEXP (XEXP (dest, 0), 0)))
1325 offset -= cfa_store_offset;
1331 dwarf2out_def_cfa (label, cfa_reg, cfa_offset);
1332 dwarf2out_reg_save (label, REGNO (src), offset);
1340 /* Return the size of an unsigned LEB128 quantity. */
1342 static inline unsigned long
1343 size_of_uleb128 (value)
1344 register unsigned long value;
1346 register unsigned long size = 0;
1347 register unsigned byte;
1351 byte = (value & 0x7f);
1360 /* Return the size of a signed LEB128 quantity. */
1362 static inline unsigned long
1363 size_of_sleb128 (value)
1364 register long value;
1366 register unsigned long size = 0;
1367 register unsigned byte;
1371 byte = (value & 0x7f);
1375 while (!(((value == 0) && ((byte & 0x40) == 0))
1376 || ((value == -1) && ((byte & 0x40) != 0))));
1381 /* Output an unsigned LEB128 quantity. */
1384 output_uleb128 (value)
1385 register unsigned long value;
1387 unsigned long save_value = value;
1389 fprintf (asm_out_file, "\t%s\t", ASM_BYTE_OP);
1392 register unsigned byte = (value & 0x7f);
1395 /* More bytes to follow. */
1398 fprintf (asm_out_file, "0x%x", byte);
1400 fprintf (asm_out_file, ",");
1405 fprintf (asm_out_file, "\t%s ULEB128 0x%x", ASM_COMMENT_START, save_value);
1408 /* Output an signed LEB128 quantity. */
1411 output_sleb128 (value)
1412 register long value;
1415 register unsigned byte;
1416 long save_value = value;
1418 fprintf (asm_out_file, "\t%s\t", ASM_BYTE_OP);
1421 byte = (value & 0x7f);
1422 /* arithmetic shift */
1424 more = !((((value == 0) && ((byte & 0x40) == 0))
1425 || ((value == -1) && ((byte & 0x40) != 0))));
1429 fprintf (asm_out_file, "0x%x", byte);
1431 fprintf (asm_out_file, ",");
1436 fprintf (asm_out_file, "\t%s SLEB128 %d", ASM_COMMENT_START, save_value);
1439 /* Output a Call Frame Information opcode and its operand(s). */
1442 output_cfi (cfi, fde)
1443 register dw_cfi_ref cfi;
1444 register dw_fde_ref fde;
1446 if (cfi->dw_cfi_opc == DW_CFA_advance_loc)
1448 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
1450 | (cfi->dw_cfi_oprnd1.dw_cfi_offset & 0x3f));
1452 fprintf (asm_out_file, "\t%s DW_CFA_advance_loc 0x%x",
1453 ASM_COMMENT_START, cfi->dw_cfi_oprnd1.dw_cfi_offset);
1454 fputc ('\n', asm_out_file);
1457 else if (cfi->dw_cfi_opc == DW_CFA_offset)
1459 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
1461 | (cfi->dw_cfi_oprnd1.dw_cfi_reg_num & 0x3f));
1463 fprintf (asm_out_file, "\t%s DW_CFA_offset, column 0x%x",
1464 ASM_COMMENT_START, cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
1466 fputc ('\n', asm_out_file);
1467 output_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset);
1468 fputc ('\n', asm_out_file);
1470 else if (cfi->dw_cfi_opc == DW_CFA_restore)
1472 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
1474 | (cfi->dw_cfi_oprnd1.dw_cfi_reg_num & 0x3f));
1476 fprintf (asm_out_file, "\t%s DW_CFA_restore, column 0x%x",
1477 ASM_COMMENT_START, cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
1479 fputc ('\n', asm_out_file);
1483 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, cfi->dw_cfi_opc);
1485 fprintf (asm_out_file, "\t%s %s", ASM_COMMENT_START,
1486 dwarf_cfi_name (cfi->dw_cfi_opc));
1488 fputc ('\n', asm_out_file);
1489 switch (cfi->dw_cfi_opc)
1491 case DW_CFA_set_loc:
1492 ASM_OUTPUT_DWARF_ADDR (asm_out_file, cfi->dw_cfi_oprnd1.dw_cfi_addr);
1493 fputc ('\n', asm_out_file);
1495 case DW_CFA_advance_loc1:
1496 ASM_OUTPUT_DWARF_DELTA1 (asm_out_file,
1497 cfi->dw_cfi_oprnd1.dw_cfi_addr,
1498 fde->dw_fde_current_label);
1499 fputc ('\n', asm_out_file);
1500 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
1502 case DW_CFA_advance_loc2:
1503 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file,
1504 cfi->dw_cfi_oprnd1.dw_cfi_addr,
1505 fde->dw_fde_current_label);
1506 fputc ('\n', asm_out_file);
1507 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
1509 case DW_CFA_advance_loc4:
1510 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file,
1511 cfi->dw_cfi_oprnd1.dw_cfi_addr,
1512 fde->dw_fde_current_label);
1513 fputc ('\n', asm_out_file);
1514 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
1516 #ifdef MIPS_DEBUGGING_INFO
1517 case DW_CFA_MIPS_advance_loc8:
1518 /* TODO: not currently implemented. */
1522 case DW_CFA_offset_extended:
1523 case DW_CFA_def_cfa:
1524 output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
1525 fputc ('\n', asm_out_file);
1526 output_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset);
1527 fputc ('\n', asm_out_file);
1529 case DW_CFA_restore_extended:
1530 case DW_CFA_undefined:
1531 output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
1532 fputc ('\n', asm_out_file);
1534 case DW_CFA_same_value:
1535 case DW_CFA_def_cfa_register:
1536 output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
1537 fputc ('\n', asm_out_file);
1539 case DW_CFA_register:
1540 output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
1541 fputc ('\n', asm_out_file);
1542 output_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_reg_num);
1543 fputc ('\n', asm_out_file);
1545 case DW_CFA_def_cfa_offset:
1546 output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset);
1547 fputc ('\n', asm_out_file);
1549 case DW_CFA_GNU_window_save:
1551 case DW_CFA_GNU_args_size:
1552 output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset);
1553 fputc ('\n', asm_out_file);
1561 #if !defined (EH_FRAME_SECTION)
1562 #if defined (EH_FRAME_SECTION_ASM_OP)
1563 #define EH_FRAME_SECTION() eh_frame_section();
1565 #if defined (ASM_OUTPUT_SECTION_NAME)
1566 #define EH_FRAME_SECTION() \
1568 named_section (NULL_TREE, ".eh_frame", 0); \
1574 /* Output the call frame information used to used to record information
1575 that relates to calculating the frame pointer, and records the
1576 location of saved registers. */
1579 output_call_frame_info (for_eh)
1582 register unsigned long i, j;
1583 register dw_fde_ref fde;
1584 register unsigned long fde_size;
1585 register dw_cfi_ref cfi;
1586 unsigned long fde_pad;
1587 char l1[20], l2[20];
1588 #ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
1592 /* Do we want to include a pointer to the exception table? */
1593 int eh_ptr = for_eh && exception_table_p ();
1595 fputc ('\n', asm_out_file);
1597 /* We're going to be generating comments, so turn on app. */
1603 #ifdef EH_FRAME_SECTION
1604 EH_FRAME_SECTION ();
1606 tree label = get_file_function_name ('F');
1609 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
1610 ASM_GLOBALIZE_LABEL (asm_out_file, IDENTIFIER_POINTER (label));
1611 ASM_OUTPUT_LABEL (asm_out_file, IDENTIFIER_POINTER (label));
1613 assemble_label ("__FRAME_BEGIN__");
1616 ASM_OUTPUT_SECTION (asm_out_file, FRAME_SECTION);
1618 /* Output the CIE. */
1619 ASM_GENERATE_INTERNAL_LABEL (l1, CIE_AFTER_SIZE_LABEL, for_eh);
1620 ASM_GENERATE_INTERNAL_LABEL (l2, CIE_END_LABEL, for_eh);
1621 #ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
1622 ASM_GENERATE_INTERNAL_LABEL (ld, CIE_LENGTH_LABEL, for_eh);
1624 ASM_OUTPUT_DWARF_OFFSET4 (asm_out_file, ld);
1626 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, ld);
1629 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, l2, l1);
1631 ASM_OUTPUT_DWARF_DELTA (asm_out_file, l2, l1);
1634 fprintf (asm_out_file, "\t%s Length of Common Information Entry",
1637 fputc ('\n', asm_out_file);
1638 ASM_OUTPUT_LABEL (asm_out_file, l1);
1641 /* Now that the CIE pointer is PC-relative for EH,
1642 use 0 to identify the CIE. */
1643 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0);
1645 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, DW_CIE_ID);
1648 fprintf (asm_out_file, "\t%s CIE Identifier Tag", ASM_COMMENT_START);
1650 fputc ('\n', asm_out_file);
1651 if (! for_eh && DWARF_OFFSET_SIZE == 8)
1653 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, DW_CIE_ID);
1654 fputc ('\n', asm_out_file);
1657 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_CIE_VERSION);
1659 fprintf (asm_out_file, "\t%s CIE Version", ASM_COMMENT_START);
1661 fputc ('\n', asm_out_file);
1664 /* The CIE contains a pointer to the exception region info for the
1665 frame. Make the augmentation string three bytes (including the
1666 trailing null) so the pointer is 4-byte aligned. The Solaris ld
1667 can't handle unaligned relocs. */
1670 ASM_OUTPUT_DWARF_STRING (asm_out_file, "eh");
1671 fprintf (asm_out_file, "\t%s CIE Augmentation", ASM_COMMENT_START);
1675 ASM_OUTPUT_ASCII (asm_out_file, "eh", 3);
1677 fputc ('\n', asm_out_file);
1679 ASM_OUTPUT_DWARF_ADDR (asm_out_file, "__EXCEPTION_TABLE__");
1681 fprintf (asm_out_file, "\t%s pointer to exception region info",
1686 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
1688 fprintf (asm_out_file, "\t%s CIE Augmentation (none)",
1692 fputc ('\n', asm_out_file);
1695 fprintf (asm_out_file, " (CIE Code Alignment Factor)");
1697 fputc ('\n', asm_out_file);
1698 output_sleb128 (DWARF_CIE_DATA_ALIGNMENT);
1700 fprintf (asm_out_file, " (CIE Data Alignment Factor)");
1702 fputc ('\n', asm_out_file);
1703 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DWARF_FRAME_RETURN_COLUMN);
1705 fprintf (asm_out_file, "\t%s CIE RA Column", ASM_COMMENT_START);
1707 fputc ('\n', asm_out_file);
1709 for (cfi = cie_cfi_head; cfi != NULL; cfi = cfi->dw_cfi_next)
1710 output_cfi (cfi, NULL);
1712 /* Pad the CIE out to an address sized boundary. */
1713 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
1714 ASM_OUTPUT_LABEL (asm_out_file, l2);
1715 #ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
1716 ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL (asm_out_file, ld, l2, l1);
1718 fprintf (asm_out_file, "\t%s CIE Length Symbol", ASM_COMMENT_START);
1719 fputc ('\n', asm_out_file);
1722 /* Loop through all of the FDE's. */
1723 for (i = 0; i < fde_table_in_use; ++i)
1725 fde = &fde_table[i];
1727 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_AFTER_SIZE_LABEL, for_eh + i*2);
1728 ASM_GENERATE_INTERNAL_LABEL (l2, FDE_END_LABEL, for_eh + i*2);
1729 #ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
1730 ASM_GENERATE_INTERNAL_LABEL (ld, FDE_LENGTH_LABEL, for_eh + i*2);
1732 ASM_OUTPUT_DWARF_OFFSET4 (asm_out_file, ld);
1734 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, ld);
1737 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, l2, l1);
1739 ASM_OUTPUT_DWARF_DELTA (asm_out_file, l2, l1);
1742 fprintf (asm_out_file, "\t%s FDE Length", ASM_COMMENT_START);
1743 fputc ('\n', asm_out_file);
1744 ASM_OUTPUT_LABEL (asm_out_file, l1);
1747 ASM_OUTPUT_DWARF_DELTA (asm_out_file, l1, "__FRAME_BEGIN__");
1749 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, stripattributes (FRAME_SECTION));
1751 fprintf (asm_out_file, "\t%s FDE CIE offset", ASM_COMMENT_START);
1753 fputc ('\n', asm_out_file);
1754 ASM_OUTPUT_DWARF_ADDR (asm_out_file, fde->dw_fde_begin);
1756 fprintf (asm_out_file, "\t%s FDE initial location", ASM_COMMENT_START);
1758 fputc ('\n', asm_out_file);
1759 ASM_OUTPUT_DWARF_ADDR_DELTA (asm_out_file,
1760 fde->dw_fde_end, fde->dw_fde_begin);
1762 fprintf (asm_out_file, "\t%s FDE address range", ASM_COMMENT_START);
1764 fputc ('\n', asm_out_file);
1766 /* Loop through the Call Frame Instructions associated with
1768 fde->dw_fde_current_label = fde->dw_fde_begin;
1769 for (cfi = fde->dw_fde_cfi; cfi != NULL; cfi = cfi->dw_cfi_next)
1770 output_cfi (cfi, fde);
1772 /* Pad the FDE out to an address sized boundary. */
1773 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
1774 ASM_OUTPUT_LABEL (asm_out_file, l2);
1775 #ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
1776 ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL (asm_out_file, ld, l2, l1);
1778 fprintf (asm_out_file, "\t%s FDE Length Symbol", ASM_COMMENT_START);
1779 fputc ('\n', asm_out_file);
1782 #ifndef EH_FRAME_SECTION
1785 /* Emit terminating zero for table. */
1786 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0);
1787 fputc ('\n', asm_out_file);
1790 #ifdef MIPS_DEBUGGING_INFO
1791 /* Work around Irix 6 assembler bug whereby labels at the end of a section
1792 get a value of 0. Putting .align 0 after the label fixes it. */
1793 ASM_OUTPUT_ALIGN (asm_out_file, 0);
1796 /* Turn off app to make assembly quicker. */
1801 /* Output a marker (i.e. a label) for the beginning of a function, before
1805 dwarf2out_begin_prologue ()
1807 char label[MAX_ARTIFICIAL_LABEL_BYTES];
1808 register dw_fde_ref fde;
1810 ++current_funcdef_number;
1812 function_section (current_function_decl);
1813 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_BEGIN_LABEL,
1814 current_funcdef_number);
1815 ASM_OUTPUT_LABEL (asm_out_file, label);
1817 /* Expand the fde table if necessary. */
1818 if (fde_table_in_use == fde_table_allocated)
1820 fde_table_allocated += FDE_TABLE_INCREMENT;
1822 = (dw_fde_ref) xrealloc (fde_table,
1823 fde_table_allocated * sizeof (dw_fde_node));
1826 /* Record the FDE associated with this function. */
1827 current_funcdef_fde = fde_table_in_use;
1829 /* Add the new FDE at the end of the fde_table. */
1830 fde = &fde_table[fde_table_in_use++];
1831 fde->dw_fde_begin = xstrdup (label);
1832 fde->dw_fde_current_label = NULL;
1833 fde->dw_fde_end = NULL;
1834 fde->dw_fde_cfi = NULL;
1839 /* Output a marker (i.e. a label) for the absolute end of the generated code
1840 for a function definition. This gets called *after* the epilogue code has
1844 dwarf2out_end_epilogue ()
1847 char label[MAX_ARTIFICIAL_LABEL_BYTES];
1849 /* Output a label to mark the endpoint of the code generated for this
1851 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL, current_funcdef_number);
1852 ASM_OUTPUT_LABEL (asm_out_file, label);
1853 fde = &fde_table[fde_table_in_use - 1];
1854 fde->dw_fde_end = xstrdup (label);
1858 dwarf2out_frame_init ()
1860 /* Allocate the initial hunk of the fde_table. */
1862 = (dw_fde_ref) xmalloc (FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
1863 bzero ((char *) fde_table, FDE_TABLE_INCREMENT * sizeof (dw_fde_node));
1864 fde_table_allocated = FDE_TABLE_INCREMENT;
1865 fde_table_in_use = 0;
1867 /* Generate the CFA instructions common to all FDE's. Do it now for the
1868 sake of lookup_cfa. */
1870 #ifdef DWARF2_UNWIND_INFO
1871 /* On entry, the Canonical Frame Address is at SP. */
1872 dwarf2out_def_cfa (NULL, STACK_POINTER_REGNUM, INCOMING_FRAME_SP_OFFSET);
1873 initial_return_save (INCOMING_RETURN_ADDR_RTX);
1878 dwarf2out_frame_finish ()
1880 /* Output call frame information. */
1881 #ifdef MIPS_DEBUGGING_INFO
1882 if (write_symbols == DWARF2_DEBUG)
1883 output_call_frame_info (0);
1884 if (flag_exceptions && ! exceptions_via_longjmp)
1885 output_call_frame_info (1);
1887 if (write_symbols == DWARF2_DEBUG
1888 || (flag_exceptions && ! exceptions_via_longjmp))
1889 output_call_frame_info (1);
1893 #endif /* .debug_frame support */
1895 /* And now, the support for symbolic debugging information. */
1896 #ifdef DWARF2_DEBUGGING_INFO
1898 extern char *getpwd ();
1900 /* NOTE: In the comments in this file, many references are made to
1901 "Debugging Information Entries". This term is abbreviated as `DIE'
1902 throughout the remainder of this file. */
1904 /* An internal representation of the DWARF output is built, and then
1905 walked to generate the DWARF debugging info. The walk of the internal
1906 representation is done after the entire program has been compiled.
1907 The types below are used to describe the internal representation. */
1909 /* Each DIE may have a series of attribute/value pairs. Values
1910 can take on several forms. The forms that are used in this
1911 implementation are listed below. */
1918 dw_val_class_unsigned_const,
1919 dw_val_class_long_long,
1922 dw_val_class_die_ref,
1923 dw_val_class_fde_ref,
1924 dw_val_class_lbl_id,
1925 dw_val_class_section_offset,
1930 /* Various DIE's use offsets relative to the beginning of the
1931 .debug_info section to refer to each other. */
1933 typedef long int dw_offset;
1935 /* Define typedefs here to avoid circular dependencies. */
1937 typedef struct die_struct *dw_die_ref;
1938 typedef struct dw_attr_struct *dw_attr_ref;
1939 typedef struct dw_val_struct *dw_val_ref;
1940 typedef struct dw_line_info_struct *dw_line_info_ref;
1941 typedef struct dw_separate_line_info_struct *dw_separate_line_info_ref;
1942 typedef struct dw_loc_descr_struct *dw_loc_descr_ref;
1943 typedef struct pubname_struct *pubname_ref;
1944 typedef dw_die_ref *arange_ref;
1946 /* Describe a double word constant value. */
1948 typedef struct dw_long_long_struct
1955 /* Describe a floating point constant value. */
1957 typedef struct dw_fp_struct
1964 /* Each entry in the line_info_table maintains the file and
1965 line number associated with the label generated for that
1966 entry. The label gives the PC value associated with
1967 the line number entry. */
1969 typedef struct dw_line_info_struct
1971 unsigned long dw_file_num;
1972 unsigned long dw_line_num;
1976 /* Line information for functions in separate sections; each one gets its
1978 typedef struct dw_separate_line_info_struct
1980 unsigned long dw_file_num;
1981 unsigned long dw_line_num;
1982 unsigned long function;
1984 dw_separate_line_info_entry;
1986 /* The dw_val_node describes an attribute's value, as it is
1987 represented internally. */
1989 typedef struct dw_val_struct
1991 dw_val_class val_class;
1995 dw_loc_descr_ref val_loc;
1997 long unsigned val_unsigned;
1998 dw_long_long_const val_long_long;
1999 dw_float_const val_float;
2000 dw_die_ref val_die_ref;
2001 unsigned val_fde_index;
2005 unsigned char val_flag;
2011 /* Locations in memory are described using a sequence of stack machine
2014 typedef struct dw_loc_descr_struct
2016 dw_loc_descr_ref dw_loc_next;
2017 enum dwarf_location_atom dw_loc_opc;
2018 dw_val_node dw_loc_oprnd1;
2019 dw_val_node dw_loc_oprnd2;
2023 /* Each DIE attribute has a field specifying the attribute kind,
2024 a link to the next attribute in the chain, and an attribute value.
2025 Attributes are typically linked below the DIE they modify. */
2027 typedef struct dw_attr_struct
2029 enum dwarf_attribute dw_attr;
2030 dw_attr_ref dw_attr_next;
2031 dw_val_node dw_attr_val;
2035 /* The Debugging Information Entry (DIE) structure */
2037 typedef struct die_struct
2039 enum dwarf_tag die_tag;
2040 dw_attr_ref die_attr;
2041 dw_attr_ref die_attr_last;
2042 dw_die_ref die_parent;
2043 dw_die_ref die_child;
2044 dw_die_ref die_child_last;
2046 dw_offset die_offset;
2047 unsigned long die_abbrev;
2051 /* The pubname structure */
2053 typedef struct pubname_struct
2060 /* The limbo die list structure. */
2061 typedef struct limbo_die_struct
2064 struct limbo_die_struct *next;
2068 /* How to start an assembler comment. */
2069 #ifndef ASM_COMMENT_START
2070 #define ASM_COMMENT_START ";#"
2073 /* Define a macro which returns non-zero for a TYPE_DECL which was
2074 implicitly generated for a tagged type.
2076 Note that unlike the gcc front end (which generates a NULL named
2077 TYPE_DECL node for each complete tagged type, each array type, and
2078 each function type node created) the g++ front end generates a
2079 _named_ TYPE_DECL node for each tagged type node created.
2080 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
2081 generate a DW_TAG_typedef DIE for them. */
2083 #define TYPE_DECL_IS_STUB(decl) \
2084 (DECL_NAME (decl) == NULL_TREE \
2085 || (DECL_ARTIFICIAL (decl) \
2086 && is_tagged_type (TREE_TYPE (decl)) \
2087 && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \
2088 /* This is necessary for stub decls that \
2089 appear in nested inline functions. */ \
2090 || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
2091 && (decl_ultimate_origin (decl) \
2092 == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
2094 /* Information concerning the compilation unit's programming
2095 language, and compiler version. */
2097 extern int flag_traditional;
2098 extern char *version_string;
2099 extern char *language_string;
2101 /* Fixed size portion of the DWARF compilation unit header. */
2102 #define DWARF_COMPILE_UNIT_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 3)
2104 /* Fixed size portion of debugging line information prolog. */
2105 #define DWARF_LINE_PROLOG_HEADER_SIZE 5
2107 /* Fixed size portion of public names info. */
2108 #define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
2110 /* Fixed size portion of the address range info. */
2111 #define DWARF_ARANGES_HEADER_SIZE \
2112 (DWARF_ROUND (2 * DWARF_OFFSET_SIZE + 4, PTR_SIZE * 2) - DWARF_OFFSET_SIZE)
2114 /* Define the architecture-dependent minimum instruction length (in bytes).
2115 In this implementation of DWARF, this field is used for information
2116 purposes only. Since GCC generates assembly language, we have
2117 no a priori knowledge of how many instruction bytes are generated
2118 for each source line, and therefore can use only the DW_LNE_set_address
2119 and DW_LNS_fixed_advance_pc line information commands. */
2121 #ifndef DWARF_LINE_MIN_INSTR_LENGTH
2122 #define DWARF_LINE_MIN_INSTR_LENGTH 4
2125 /* Minimum line offset in a special line info. opcode.
2126 This value was chosen to give a reasonable range of values. */
2127 #define DWARF_LINE_BASE -10
2129 /* First special line opcde - leave room for the standard opcodes. */
2130 #define DWARF_LINE_OPCODE_BASE 10
2132 /* Range of line offsets in a special line info. opcode. */
2133 #define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1)
2135 /* Flag that indicates the initial value of the is_stmt_start flag.
2136 In the present implementation, we do not mark any lines as
2137 the beginning of a source statement, because that information
2138 is not made available by the GCC front-end. */
2139 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
2141 /* This location is used by calc_die_sizes() to keep track
2142 the offset of each DIE within the .debug_info section. */
2143 static unsigned long next_die_offset;
2145 /* Record the root of the DIE's built for the current compilation unit. */
2146 static dw_die_ref comp_unit_die;
2148 /* A list of DIEs with a NULL parent waiting to be relocated. */
2149 static limbo_die_node *limbo_die_list = 0;
2151 /* Pointer to an array of filenames referenced by this compilation unit. */
2152 static char **file_table;
2154 /* Total number of entries in the table (i.e. array) pointed to by
2155 `file_table'. This is the *total* and includes both used and unused
2157 static unsigned file_table_allocated;
2159 /* Number of entries in the file_table which are actually in use. */
2160 static unsigned file_table_in_use;
2162 /* Size (in elements) of increments by which we may expand the filename
2164 #define FILE_TABLE_INCREMENT 64
2166 /* Local pointer to the name of the main input file. Initialized in
2168 static char *primary_filename;
2170 /* For Dwarf output, we must assign lexical-blocks id numbers in the order in
2171 which their beginnings are encountered. We output Dwarf debugging info
2172 that refers to the beginnings and ends of the ranges of code for each
2173 lexical block. The labels themselves are generated in final.c, which
2174 assigns numbers to the blocks in the same way. */
2175 static unsigned next_block_number = 2;
2177 /* A pointer to the base of a table of references to DIE's that describe
2178 declarations. The table is indexed by DECL_UID() which is a unique
2179 number identifying each decl. */
2180 static dw_die_ref *decl_die_table;
2182 /* Number of elements currently allocated for the decl_die_table. */
2183 static unsigned decl_die_table_allocated;
2185 /* Number of elements in decl_die_table currently in use. */
2186 static unsigned decl_die_table_in_use;
2188 /* Size (in elements) of increments by which we may expand the
2190 #define DECL_DIE_TABLE_INCREMENT 256
2192 /* A pointer to the base of a table of references to declaration
2193 scopes. This table is a display which tracks the nesting
2194 of declaration scopes at the current scope and containing
2195 scopes. This table is used to find the proper place to
2196 define type declaration DIE's. */
2197 static tree *decl_scope_table;
2199 /* Number of elements currently allocated for the decl_scope_table. */
2200 static unsigned decl_scope_table_allocated;
2202 /* Current level of nesting of declaration scopes. */
2203 static unsigned decl_scope_depth;
2205 /* Size (in elements) of increments by which we may expand the
2206 decl_scope_table. */
2207 #define DECL_SCOPE_TABLE_INCREMENT 64
2209 /* A pointer to the base of a list of references to DIE's that
2210 are uniquely identified by their tag, presence/absence of
2211 children DIE's, and list of attribute/value pairs. */
2212 static dw_die_ref *abbrev_die_table;
2214 /* Number of elements currently allocated for abbrev_die_table. */
2215 static unsigned abbrev_die_table_allocated;
2217 /* Number of elements in type_die_table currently in use. */
2218 static unsigned abbrev_die_table_in_use;
2220 /* Size (in elements) of increments by which we may expand the
2221 abbrev_die_table. */
2222 #define ABBREV_DIE_TABLE_INCREMENT 256
2224 /* A pointer to the base of a table that contains line information
2225 for each source code line in .text in the compilation unit. */
2226 static dw_line_info_ref line_info_table;
2228 /* Number of elements currently allocated for line_info_table. */
2229 static unsigned line_info_table_allocated;
2231 /* Number of elements in separate_line_info_table currently in use. */
2232 static unsigned separate_line_info_table_in_use;
2234 /* A pointer to the base of a table that contains line information
2235 for each source code line outside of .text in the compilation unit. */
2236 static dw_separate_line_info_ref separate_line_info_table;
2238 /* Number of elements currently allocated for separate_line_info_table. */
2239 static unsigned separate_line_info_table_allocated;
2241 /* Number of elements in line_info_table currently in use. */
2242 static unsigned line_info_table_in_use;
2244 /* Size (in elements) of increments by which we may expand the
2246 #define LINE_INFO_TABLE_INCREMENT 1024
2248 /* A pointer to the base of a table that contains a list of publicly
2249 accessible names. */
2250 static pubname_ref pubname_table;
2252 /* Number of elements currently allocated for pubname_table. */
2253 static unsigned pubname_table_allocated;
2255 /* Number of elements in pubname_table currently in use. */
2256 static unsigned pubname_table_in_use;
2258 /* Size (in elements) of increments by which we may expand the
2260 #define PUBNAME_TABLE_INCREMENT 64
2262 /* A pointer to the base of a table that contains a list of publicly
2263 accessible names. */
2264 static arange_ref arange_table;
2266 /* Number of elements currently allocated for arange_table. */
2267 static unsigned arange_table_allocated;
2269 /* Number of elements in arange_table currently in use. */
2270 static unsigned arange_table_in_use;
2272 /* Size (in elements) of increments by which we may expand the
2274 #define ARANGE_TABLE_INCREMENT 64
2276 /* A pointer to the base of a list of pending types which we haven't
2277 generated DIEs for yet, but which we will have to come back to
2280 static tree *pending_types_list;
2282 /* Number of elements currently allocated for the pending_types_list. */
2283 static unsigned pending_types_allocated;
2285 /* Number of elements of pending_types_list currently in use. */
2286 static unsigned pending_types;
2288 /* Size (in elements) of increments by which we may expand the pending
2289 types list. Actually, a single hunk of space of this size should
2290 be enough for most typical programs. */
2291 #define PENDING_TYPES_INCREMENT 64
2293 /* Record whether the function being analyzed contains inlined functions. */
2294 static int current_function_has_inlines;
2295 static int comp_unit_has_inlines;
2297 /* A pointer to the ..._DECL node which we have most recently been working
2298 on. We keep this around just in case something about it looks screwy and
2299 we want to tell the user what the source coordinates for the actual
2301 static tree dwarf_last_decl;
2303 /* Forward declarations for functions defined in this file. */
2305 static void addr_const_to_string PROTO((char *, rtx));
2306 static char *addr_to_string PROTO((rtx));
2307 static int is_pseudo_reg PROTO((rtx));
2308 static tree type_main_variant PROTO((tree));
2309 static int is_tagged_type PROTO((tree));
2310 static char *dwarf_tag_name PROTO((unsigned));
2311 static char *dwarf_attr_name PROTO((unsigned));
2312 static char *dwarf_form_name PROTO((unsigned));
2313 static char *dwarf_stack_op_name PROTO((unsigned));
2314 static char *dwarf_type_encoding_name PROTO((unsigned));
2315 static tree decl_ultimate_origin PROTO((tree));
2316 static tree block_ultimate_origin PROTO((tree));
2317 static tree decl_class_context PROTO((tree));
2318 static void add_dwarf_attr PROTO((dw_die_ref, dw_attr_ref));
2319 static void add_AT_flag PROTO((dw_die_ref,
2320 enum dwarf_attribute,
2322 static void add_AT_int PROTO((dw_die_ref,
2323 enum dwarf_attribute, long));
2324 static void add_AT_unsigned PROTO((dw_die_ref,
2325 enum dwarf_attribute,
2327 static void add_AT_long_long PROTO((dw_die_ref,
2328 enum dwarf_attribute,
2329 unsigned long, unsigned long));
2330 static void add_AT_float PROTO((dw_die_ref,
2331 enum dwarf_attribute,
2333 static void add_AT_string PROTO((dw_die_ref,
2334 enum dwarf_attribute, char *));
2335 static void add_AT_die_ref PROTO((dw_die_ref,
2336 enum dwarf_attribute,
2338 static void add_AT_fde_ref PROTO((dw_die_ref,
2339 enum dwarf_attribute,
2341 static void add_AT_loc PROTO((dw_die_ref,
2342 enum dwarf_attribute,
2344 static void add_AT_addr PROTO((dw_die_ref,
2345 enum dwarf_attribute, char *));
2346 static void add_AT_lbl_id PROTO((dw_die_ref,
2347 enum dwarf_attribute, char *));
2348 static void add_AT_section_offset PROTO((dw_die_ref,
2349 enum dwarf_attribute, char *));
2350 static int is_extern_subr_die PROTO((dw_die_ref));
2351 static dw_attr_ref get_AT PROTO((dw_die_ref,
2352 enum dwarf_attribute));
2353 static char *get_AT_low_pc PROTO((dw_die_ref));
2354 static char *get_AT_hi_pc PROTO((dw_die_ref));
2355 static char *get_AT_string PROTO((dw_die_ref,
2356 enum dwarf_attribute));
2357 static int get_AT_flag PROTO((dw_die_ref,
2358 enum dwarf_attribute));
2359 static unsigned get_AT_unsigned PROTO((dw_die_ref,
2360 enum dwarf_attribute));
2361 static int is_c_family PROTO((void));
2362 static int is_fortran PROTO((void));
2363 static void remove_AT PROTO((dw_die_ref,
2364 enum dwarf_attribute));
2365 static void remove_children PROTO((dw_die_ref));
2366 static void add_child_die PROTO((dw_die_ref, dw_die_ref));
2367 static dw_die_ref new_die PROTO((enum dwarf_tag, dw_die_ref));
2368 static dw_die_ref lookup_type_die PROTO((tree));
2369 static void equate_type_number_to_die PROTO((tree, dw_die_ref));
2370 static dw_die_ref lookup_decl_die PROTO((tree));
2371 static void equate_decl_number_to_die PROTO((tree, dw_die_ref));
2372 static dw_loc_descr_ref new_loc_descr PROTO((enum dwarf_location_atom,
2373 unsigned long, unsigned long));
2374 static void add_loc_descr PROTO((dw_loc_descr_ref *,
2376 static void print_spaces PROTO((FILE *));
2377 static void print_die PROTO((dw_die_ref, FILE *));
2378 static void print_dwarf_line_table PROTO((FILE *));
2379 static void add_sibling_attributes PROTO((dw_die_ref));
2380 static void build_abbrev_table PROTO((dw_die_ref));
2381 static unsigned long size_of_string PROTO((char *));
2382 static unsigned long size_of_loc_descr PROTO((dw_loc_descr_ref));
2383 static unsigned long size_of_locs PROTO((dw_loc_descr_ref));
2384 static int constant_size PROTO((long unsigned));
2385 static unsigned long size_of_die PROTO((dw_die_ref));
2386 static void calc_die_sizes PROTO((dw_die_ref));
2387 static unsigned long size_of_prolog PROTO((void));
2388 static unsigned long size_of_line_info PROTO((void));
2389 static unsigned long size_of_pubnames PROTO((void));
2390 static unsigned long size_of_aranges PROTO((void));
2391 static enum dwarf_form value_format PROTO((dw_val_ref));
2392 static void output_value_format PROTO((dw_val_ref));
2393 static void output_abbrev_section PROTO((void));
2394 static void output_loc_operands PROTO((dw_loc_descr_ref));
2395 static unsigned long sibling_offset PROTO((dw_die_ref));
2396 static void output_die PROTO((dw_die_ref));
2397 static void output_compilation_unit_header PROTO((void));
2398 static char *dwarf2_name PROTO((tree, int));
2399 static void add_pubname PROTO((tree, dw_die_ref));
2400 static void output_pubnames PROTO((void));
2401 static void add_arrange PROTO((tree, dw_die_ref));
2402 static void output_arranges PROTO((void));
2403 static void output_line_info PROTO((void));
2404 static int is_body_block PROTO((tree));
2405 static dw_die_ref base_type_die PROTO((tree));
2406 static tree root_type PROTO((tree));
2407 static int is_base_type PROTO((tree));
2408 static dw_die_ref modified_type_die PROTO((tree, int, int, dw_die_ref));
2409 static int type_is_enum PROTO((tree));
2410 static dw_loc_descr_ref reg_loc_descriptor PROTO((rtx));
2411 static dw_loc_descr_ref based_loc_descr PROTO((unsigned, long));
2412 static int is_based_loc PROTO((rtx));
2413 static dw_loc_descr_ref mem_loc_descriptor PROTO((rtx));
2414 static dw_loc_descr_ref concat_loc_descriptor PROTO((rtx, rtx));
2415 static dw_loc_descr_ref loc_descriptor PROTO((rtx));
2416 static unsigned ceiling PROTO((unsigned, unsigned));
2417 static tree field_type PROTO((tree));
2418 static unsigned simple_type_align_in_bits PROTO((tree));
2419 static unsigned simple_type_size_in_bits PROTO((tree));
2420 static unsigned field_byte_offset PROTO((tree));
2421 static void add_AT_location_description PROTO((dw_die_ref,
2422 enum dwarf_attribute, rtx));
2423 static void add_data_member_location_attribute PROTO((dw_die_ref, tree));
2424 static void add_const_value_attribute PROTO((dw_die_ref, rtx));
2425 static void add_location_or_const_value_attribute PROTO((dw_die_ref, tree));
2426 static void add_name_attribute PROTO((dw_die_ref, char *));
2427 static void add_bound_info PROTO((dw_die_ref,
2428 enum dwarf_attribute, tree));
2429 static void add_subscript_info PROTO((dw_die_ref, tree));
2430 static void add_byte_size_attribute PROTO((dw_die_ref, tree));
2431 static void add_bit_offset_attribute PROTO((dw_die_ref, tree));
2432 static void add_bit_size_attribute PROTO((dw_die_ref, tree));
2433 static void add_prototyped_attribute PROTO((dw_die_ref, tree));
2434 static void add_abstract_origin_attribute PROTO((dw_die_ref, tree));
2435 static void add_pure_or_virtual_attribute PROTO((dw_die_ref, tree));
2436 static void add_src_coords_attributes PROTO((dw_die_ref, tree));
2437 static void ad_name_and_src_coords_attributes PROTO((dw_die_ref, tree));
2438 static void push_decl_scope PROTO((tree));
2439 static dw_die_ref scope_die_for PROTO((tree, dw_die_ref));
2440 static void pop_decl_scope PROTO((void));
2441 static void add_type_attribute PROTO((dw_die_ref, tree, int, int,
2443 static char *type_tag PROTO((tree));
2444 static tree member_declared_type PROTO((tree));
2445 static char *decl_start_label PROTO((tree));
2446 static void gen_arrqay_type_die PROTO((tree, dw_die_ref));
2447 static void gen_set_type_die PROTO((tree, dw_die_ref));
2448 static void gen_entry_point_die PROTO((tree, dw_die_ref));
2449 static void pend_type PROTO((tree));
2450 static void output_pending_types_for_scope PROTO((dw_die_ref));
2451 static void gen_inlined_enumeration_type_die PROTO((tree, dw_die_ref));
2452 static void gen_inlined_structure_type_die PROTO((tree, dw_die_ref));
2453 static void gen_inlined_union_type_die PROTO((tree, dw_die_ref));
2454 static void gen_enumeration_type_die PROTO((tree, dw_die_ref));
2455 static dw_die_ref gen_formal_parameter_die PROTO((tree, dw_die_ref));
2456 static void gen_unspecified_parameters_die PROTO((tree, dw_die_ref));
2457 static void gen_formal_types_die PROTO((tree, dw_die_ref));
2458 static void gen_subprogram_die PROTO((tree, dw_die_ref));
2459 static void gen_variable_die PROTO((tree, dw_die_ref));
2460 static void gen_label_die PROTO((tree, dw_die_ref));
2461 static void gen_lexical_block_die PROTO((tree, dw_die_ref, int));
2462 static void gen_inlined_subprogram_die PROTO((tree, dw_die_ref, int));
2463 static void gen_field_die PROTO((tree, dw_die_ref));
2464 static void gen_ptr_to_mbr_type_die PROTO((tree, dw_die_ref));
2465 static void gen_compile_unit_die PROTO((char *));
2466 static void gen_string_type_die PROTO((tree, dw_die_ref));
2467 static void gen_inheritance_die PROTO((tree, dw_die_ref));
2468 static void gen_member_die PROTO((tree, dw_die_ref));
2469 static void gen_struct_or_union_type_die PROTO((tree, dw_die_ref));
2470 static void gen_subroutine_type_die PROTO((tree, dw_die_ref));
2471 static void gen_typedef_die PROTO((tree, dw_die_ref));
2472 static void gen_type_die PROTO((tree, dw_die_ref));
2473 static void gen_tagged_type_instantiation_die PROTO((tree, dw_die_ref));
2474 static void gen_block_die PROTO((tree, dw_die_ref, int));
2475 static void decls_for_scope PROTO((tree, dw_die_ref, int));
2476 static int is_redundant_typedef PROTO((tree));
2477 static void gen_decl_die PROTO((tree, dw_die_ref));
2478 static unsigned lookup_filename PROTO((char *));
2480 /* Section names used to hold DWARF debugging information. */
2481 #ifndef DEBUG_INFO_SECTION
2482 #define DEBUG_INFO_SECTION ".debug_info"
2484 #ifndef ABBREV_SECTION
2485 #define ABBREV_SECTION ".debug_abbrev"
2487 #ifndef ARANGES_SECTION
2488 #define ARANGES_SECTION ".debug_aranges"
2490 #ifndef DW_MACINFO_SECTION
2491 #define DW_MACINFO_SECTION ".debug_macinfo"
2493 #ifndef DEBUG_LINE_SECTION
2494 #define DEBUG_LINE_SECTION ".debug_line"
2497 #define LOC_SECTION ".debug_loc"
2499 #ifndef PUBNAMES_SECTION
2500 #define PUBNAMES_SECTION ".debug_pubnames"
2503 #define STR_SECTION ".debug_str"
2506 /* Standard ELF section names for compiled code and data. */
2507 #ifndef TEXT_SECTION
2508 #define TEXT_SECTION ".text"
2510 #ifndef DATA_SECTION
2511 #define DATA_SECTION ".data"
2514 #define BSS_SECTION ".bss"
2518 /* Definitions of defaults for formats and names of various special
2519 (artificial) labels which may be generated within this file (when the -g
2520 options is used and DWARF_DEBUGGING_INFO is in effect.
2521 If necessary, these may be overridden from within the tm.h file, but
2522 typically, overriding these defaults is unnecessary. */
2524 static char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
2526 #ifndef TEXT_END_LABEL
2527 #define TEXT_END_LABEL "Letext"
2529 #ifndef DATA_END_LABEL
2530 #define DATA_END_LABEL "Ledata"
2532 #ifndef BSS_END_LABEL
2533 #define BSS_END_LABEL "Lebss"
2535 #ifndef INSN_LABEL_FMT
2536 #define INSN_LABEL_FMT "LI%u_"
2538 #ifndef BLOCK_BEGIN_LABEL
2539 #define BLOCK_BEGIN_LABEL "LBB"
2541 #ifndef BLOCK_END_LABEL
2542 #define BLOCK_END_LABEL "LBE"
2544 #ifndef BODY_BEGIN_LABEL
2545 #define BODY_BEGIN_LABEL "Lbb"
2547 #ifndef BODY_END_LABEL
2548 #define BODY_END_LABEL "Lbe"
2550 #ifndef LINE_CODE_LABEL
2551 #define LINE_CODE_LABEL "LM"
2553 #ifndef SEPARATE_LINE_CODE_LABEL
2554 #define SEPARATE_LINE_CODE_LABEL "LSM"
2557 /* Convert a reference to the assembler name of a C-level name. This
2558 macro has the same effect as ASM_OUTPUT_LABELREF, but copies to
2559 a string rather than writing to a file. */
2560 #ifndef ASM_NAME_TO_STRING
2561 #define ASM_NAME_TO_STRING(STR, NAME) \
2563 if ((NAME)[0] == '*') \
2564 strcpy (STR, NAME+1); \
2566 strcpy (STR, NAME); \
2571 /* Convert an integer constant expression into assembler syntax. Addition
2572 and subtraction are the only arithmetic that may appear in these
2573 expressions. This is an adaptation of output_addr_const in final.c.
2574 Here, the target of the conversion is a string buffer. We can't use
2575 output_addr_const directly, because it writes to a file. */
2578 addr_const_to_string (str, x)
2587 switch (GET_CODE (x))
2597 ASM_NAME_TO_STRING (buf1, XSTR (x, 0));
2602 ASM_GENERATE_INTERNAL_LABEL (buf1, "L", CODE_LABEL_NUMBER (XEXP (x, 0)));
2603 ASM_NAME_TO_STRING (buf2, buf1);
2608 ASM_GENERATE_INTERNAL_LABEL (buf1, "L", CODE_LABEL_NUMBER (x));
2609 ASM_NAME_TO_STRING (buf2, buf1);
2614 sprintf (buf1, HOST_WIDE_INT_PRINT_DEC, INTVAL (x));
2619 /* This used to output parentheses around the expression, but that does
2620 not work on the 386 (either ATT or BSD assembler). */
2621 addr_const_to_string (buf1, XEXP (x, 0));
2626 if (GET_MODE (x) == VOIDmode)
2628 /* We can use %d if the number is one word and positive. */
2629 if (CONST_DOUBLE_HIGH (x))
2630 sprintf (buf1, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
2631 CONST_DOUBLE_HIGH (x), CONST_DOUBLE_LOW (x));
2632 else if (CONST_DOUBLE_LOW (x) < 0)
2633 sprintf (buf1, HOST_WIDE_INT_PRINT_HEX, CONST_DOUBLE_LOW (x));
2635 sprintf (buf1, HOST_WIDE_INT_PRINT_DEC,
2636 CONST_DOUBLE_LOW (x));
2640 /* We can't handle floating point constants; PRINT_OPERAND must
2642 output_operand_lossage ("floating constant misused");
2646 /* Some assemblers need integer constants to appear last (eg masm). */
2647 if (GET_CODE (XEXP (x, 0)) == CONST_INT)
2649 addr_const_to_string (buf1, XEXP (x, 1));
2651 if (INTVAL (XEXP (x, 0)) >= 0)
2654 addr_const_to_string (buf1, XEXP (x, 0));
2659 addr_const_to_string (buf1, XEXP (x, 0));
2661 if (INTVAL (XEXP (x, 1)) >= 0)
2664 addr_const_to_string (buf1, XEXP (x, 1));
2670 /* Avoid outputting things like x-x or x+5-x, since some assemblers
2671 can't handle that. */
2672 x = simplify_subtraction (x);
2673 if (GET_CODE (x) != MINUS)
2676 addr_const_to_string (buf1, XEXP (x, 0));
2679 if (GET_CODE (XEXP (x, 1)) == CONST_INT
2680 && INTVAL (XEXP (x, 1)) < 0)
2682 strcat (str, ASM_OPEN_PAREN);
2683 addr_const_to_string (buf1, XEXP (x, 1));
2685 strcat (str, ASM_CLOSE_PAREN);
2689 addr_const_to_string (buf1, XEXP (x, 1));
2696 addr_const_to_string (buf1, XEXP (x, 0));
2701 output_operand_lossage ("invalid expression as operand");
2705 /* Convert an address constant to a string, and return a pointer to
2706 a copy of the result, located on the heap. */
2713 addr_const_to_string (buf, x);
2714 return xstrdup (buf);
2717 /* Test if rtl node points to a pseudo register. */
2723 return (((GET_CODE (rtl) == REG) && (REGNO (rtl) >= FIRST_PSEUDO_REGISTER))
2724 || ((GET_CODE (rtl) == SUBREG)
2725 && (REGNO (XEXP (rtl, 0)) >= FIRST_PSEUDO_REGISTER)));
2728 /* Return a reference to a type, with its const and volatile qualifiers
2732 type_main_variant (type)
2735 type = TYPE_MAIN_VARIANT (type);
2737 /* There really should be only one main variant among any group of variants
2738 of a given type (and all of the MAIN_VARIANT values for all members of
2739 the group should point to that one type) but sometimes the C front-end
2740 messes this up for array types, so we work around that bug here. */
2742 if (TREE_CODE (type) == ARRAY_TYPE)
2743 while (type != TYPE_MAIN_VARIANT (type))
2744 type = TYPE_MAIN_VARIANT (type);
2749 /* Return non-zero if the given type node represents a tagged type. */
2752 is_tagged_type (type)
2755 register enum tree_code code = TREE_CODE (type);
2757 return (code == RECORD_TYPE || code == UNION_TYPE
2758 || code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE);
2761 /* Convert a DIE tag into its string name. */
2764 dwarf_tag_name (tag)
2765 register unsigned tag;
2769 case DW_TAG_padding:
2770 return "DW_TAG_padding";
2771 case DW_TAG_array_type:
2772 return "DW_TAG_array_type";
2773 case DW_TAG_class_type:
2774 return "DW_TAG_class_type";
2775 case DW_TAG_entry_point:
2776 return "DW_TAG_entry_point";
2777 case DW_TAG_enumeration_type:
2778 return "DW_TAG_enumeration_type";
2779 case DW_TAG_formal_parameter:
2780 return "DW_TAG_formal_parameter";
2781 case DW_TAG_imported_declaration:
2782 return "DW_TAG_imported_declaration";
2784 return "DW_TAG_label";
2785 case DW_TAG_lexical_block:
2786 return "DW_TAG_lexical_block";
2788 return "DW_TAG_member";
2789 case DW_TAG_pointer_type:
2790 return "DW_TAG_pointer_type";
2791 case DW_TAG_reference_type:
2792 return "DW_TAG_reference_type";
2793 case DW_TAG_compile_unit:
2794 return "DW_TAG_compile_unit";
2795 case DW_TAG_string_type:
2796 return "DW_TAG_string_type";
2797 case DW_TAG_structure_type:
2798 return "DW_TAG_structure_type";
2799 case DW_TAG_subroutine_type:
2800 return "DW_TAG_subroutine_type";
2801 case DW_TAG_typedef:
2802 return "DW_TAG_typedef";
2803 case DW_TAG_union_type:
2804 return "DW_TAG_union_type";
2805 case DW_TAG_unspecified_parameters:
2806 return "DW_TAG_unspecified_parameters";
2807 case DW_TAG_variant:
2808 return "DW_TAG_variant";
2809 case DW_TAG_common_block:
2810 return "DW_TAG_common_block";
2811 case DW_TAG_common_inclusion:
2812 return "DW_TAG_common_inclusion";
2813 case DW_TAG_inheritance:
2814 return "DW_TAG_inheritance";
2815 case DW_TAG_inlined_subroutine:
2816 return "DW_TAG_inlined_subroutine";
2818 return "DW_TAG_module";
2819 case DW_TAG_ptr_to_member_type:
2820 return "DW_TAG_ptr_to_member_type";
2821 case DW_TAG_set_type:
2822 return "DW_TAG_set_type";
2823 case DW_TAG_subrange_type:
2824 return "DW_TAG_subrange_type";
2825 case DW_TAG_with_stmt:
2826 return "DW_TAG_with_stmt";
2827 case DW_TAG_access_declaration:
2828 return "DW_TAG_access_declaration";
2829 case DW_TAG_base_type:
2830 return "DW_TAG_base_type";
2831 case DW_TAG_catch_block:
2832 return "DW_TAG_catch_block";
2833 case DW_TAG_const_type:
2834 return "DW_TAG_const_type";
2835 case DW_TAG_constant:
2836 return "DW_TAG_constant";
2837 case DW_TAG_enumerator:
2838 return "DW_TAG_enumerator";
2839 case DW_TAG_file_type:
2840 return "DW_TAG_file_type";
2842 return "DW_TAG_friend";
2843 case DW_TAG_namelist:
2844 return "DW_TAG_namelist";
2845 case DW_TAG_namelist_item:
2846 return "DW_TAG_namelist_item";
2847 case DW_TAG_packed_type:
2848 return "DW_TAG_packed_type";
2849 case DW_TAG_subprogram:
2850 return "DW_TAG_subprogram";
2851 case DW_TAG_template_type_param:
2852 return "DW_TAG_template_type_param";
2853 case DW_TAG_template_value_param:
2854 return "DW_TAG_template_value_param";
2855 case DW_TAG_thrown_type:
2856 return "DW_TAG_thrown_type";
2857 case DW_TAG_try_block:
2858 return "DW_TAG_try_block";
2859 case DW_TAG_variant_part:
2860 return "DW_TAG_variant_part";
2861 case DW_TAG_variable:
2862 return "DW_TAG_variable";
2863 case DW_TAG_volatile_type:
2864 return "DW_TAG_volatile_type";
2865 case DW_TAG_MIPS_loop:
2866 return "DW_TAG_MIPS_loop";
2867 case DW_TAG_format_label:
2868 return "DW_TAG_format_label";
2869 case DW_TAG_function_template:
2870 return "DW_TAG_function_template";
2871 case DW_TAG_class_template:
2872 return "DW_TAG_class_template";
2874 return "DW_TAG_<unknown>";
2878 /* Convert a DWARF attribute code into its string name. */
2881 dwarf_attr_name (attr)
2882 register unsigned attr;
2887 return "DW_AT_sibling";
2888 case DW_AT_location:
2889 return "DW_AT_location";
2891 return "DW_AT_name";
2892 case DW_AT_ordering:
2893 return "DW_AT_ordering";
2894 case DW_AT_subscr_data:
2895 return "DW_AT_subscr_data";
2896 case DW_AT_byte_size:
2897 return "DW_AT_byte_size";
2898 case DW_AT_bit_offset:
2899 return "DW_AT_bit_offset";
2900 case DW_AT_bit_size:
2901 return "DW_AT_bit_size";
2902 case DW_AT_element_list:
2903 return "DW_AT_element_list";
2904 case DW_AT_stmt_list:
2905 return "DW_AT_stmt_list";
2907 return "DW_AT_low_pc";
2909 return "DW_AT_high_pc";
2910 case DW_AT_language:
2911 return "DW_AT_language";
2913 return "DW_AT_member";
2915 return "DW_AT_discr";
2916 case DW_AT_discr_value:
2917 return "DW_AT_discr_value";
2918 case DW_AT_visibility:
2919 return "DW_AT_visibility";
2921 return "DW_AT_import";
2922 case DW_AT_string_length:
2923 return "DW_AT_string_length";
2924 case DW_AT_common_reference:
2925 return "DW_AT_common_reference";
2926 case DW_AT_comp_dir:
2927 return "DW_AT_comp_dir";
2928 case DW_AT_const_value:
2929 return "DW_AT_const_value";
2930 case DW_AT_containing_type:
2931 return "DW_AT_containing_type";
2932 case DW_AT_default_value:
2933 return "DW_AT_default_value";
2935 return "DW_AT_inline";
2936 case DW_AT_is_optional:
2937 return "DW_AT_is_optional";
2938 case DW_AT_lower_bound:
2939 return "DW_AT_lower_bound";
2940 case DW_AT_producer:
2941 return "DW_AT_producer";
2942 case DW_AT_prototyped:
2943 return "DW_AT_prototyped";
2944 case DW_AT_return_addr:
2945 return "DW_AT_return_addr";
2946 case DW_AT_start_scope:
2947 return "DW_AT_start_scope";
2948 case DW_AT_stride_size:
2949 return "DW_AT_stride_size";
2950 case DW_AT_upper_bound:
2951 return "DW_AT_upper_bound";
2952 case DW_AT_abstract_origin:
2953 return "DW_AT_abstract_origin";
2954 case DW_AT_accessibility:
2955 return "DW_AT_accessibility";
2956 case DW_AT_address_class:
2957 return "DW_AT_address_class";
2958 case DW_AT_artificial:
2959 return "DW_AT_artificial";
2960 case DW_AT_base_types:
2961 return "DW_AT_base_types";
2962 case DW_AT_calling_convention:
2963 return "DW_AT_calling_convention";
2965 return "DW_AT_count";
2966 case DW_AT_data_member_location:
2967 return "DW_AT_data_member_location";
2968 case DW_AT_decl_column:
2969 return "DW_AT_decl_column";
2970 case DW_AT_decl_file:
2971 return "DW_AT_decl_file";
2972 case DW_AT_decl_line:
2973 return "DW_AT_decl_line";
2974 case DW_AT_declaration:
2975 return "DW_AT_declaration";
2976 case DW_AT_discr_list:
2977 return "DW_AT_discr_list";
2978 case DW_AT_encoding:
2979 return "DW_AT_encoding";
2980 case DW_AT_external:
2981 return "DW_AT_external";
2982 case DW_AT_frame_base:
2983 return "DW_AT_frame_base";
2985 return "DW_AT_friend";
2986 case DW_AT_identifier_case:
2987 return "DW_AT_identifier_case";
2988 case DW_AT_macro_info:
2989 return "DW_AT_macro_info";
2990 case DW_AT_namelist_items:
2991 return "DW_AT_namelist_items";
2992 case DW_AT_priority:
2993 return "DW_AT_priority";
2995 return "DW_AT_segment";
2996 case DW_AT_specification:
2997 return "DW_AT_specification";
2998 case DW_AT_static_link:
2999 return "DW_AT_static_link";
3001 return "DW_AT_type";
3002 case DW_AT_use_location:
3003 return "DW_AT_use_location";
3004 case DW_AT_variable_parameter:
3005 return "DW_AT_variable_parameter";
3006 case DW_AT_virtuality:
3007 return "DW_AT_virtuality";
3008 case DW_AT_vtable_elem_location:
3009 return "DW_AT_vtable_elem_location";
3011 case DW_AT_MIPS_fde:
3012 return "DW_AT_MIPS_fde";
3013 case DW_AT_MIPS_loop_begin:
3014 return "DW_AT_MIPS_loop_begin";
3015 case DW_AT_MIPS_tail_loop_begin:
3016 return "DW_AT_MIPS_tail_loop_begin";
3017 case DW_AT_MIPS_epilog_begin:
3018 return "DW_AT_MIPS_epilog_begin";
3019 case DW_AT_MIPS_loop_unroll_factor:
3020 return "DW_AT_MIPS_loop_unroll_factor";
3021 case DW_AT_MIPS_software_pipeline_depth:
3022 return "DW_AT_MIPS_software_pipeline_depth";
3023 case DW_AT_MIPS_linkage_name:
3024 return "DW_AT_MIPS_linkage_name";
3025 case DW_AT_MIPS_stride:
3026 return "DW_AT_MIPS_stride";
3027 case DW_AT_MIPS_abstract_name:
3028 return "DW_AT_MIPS_abstract_name";
3029 case DW_AT_MIPS_clone_origin:
3030 return "DW_AT_MIPS_clone_origin";
3031 case DW_AT_MIPS_has_inlines:
3032 return "DW_AT_MIPS_has_inlines";
3034 case DW_AT_sf_names:
3035 return "DW_AT_sf_names";
3036 case DW_AT_src_info:
3037 return "DW_AT_src_info";
3038 case DW_AT_mac_info:
3039 return "DW_AT_mac_info";
3040 case DW_AT_src_coords:
3041 return "DW_AT_src_coords";
3042 case DW_AT_body_begin:
3043 return "DW_AT_body_begin";
3044 case DW_AT_body_end:
3045 return "DW_AT_body_end";
3047 return "DW_AT_<unknown>";
3051 /* Convert a DWARF value form code into its string name. */
3054 dwarf_form_name (form)
3055 register unsigned form;
3060 return "DW_FORM_addr";
3061 case DW_FORM_block2:
3062 return "DW_FORM_block2";
3063 case DW_FORM_block4:
3064 return "DW_FORM_block4";
3066 return "DW_FORM_data2";
3068 return "DW_FORM_data4";
3070 return "DW_FORM_data8";
3071 case DW_FORM_string:
3072 return "DW_FORM_string";
3074 return "DW_FORM_block";
3075 case DW_FORM_block1:
3076 return "DW_FORM_block1";
3078 return "DW_FORM_data1";
3080 return "DW_FORM_flag";
3082 return "DW_FORM_sdata";
3084 return "DW_FORM_strp";
3086 return "DW_FORM_udata";
3087 case DW_FORM_ref_addr:
3088 return "DW_FORM_ref_addr";
3090 return "DW_FORM_ref1";
3092 return "DW_FORM_ref2";
3094 return "DW_FORM_ref4";
3096 return "DW_FORM_ref8";
3097 case DW_FORM_ref_udata:
3098 return "DW_FORM_ref_udata";
3099 case DW_FORM_indirect:
3100 return "DW_FORM_indirect";
3102 return "DW_FORM_<unknown>";
3106 /* Convert a DWARF stack opcode into its string name. */
3109 dwarf_stack_op_name (op)
3110 register unsigned op;
3115 return "DW_OP_addr";
3117 return "DW_OP_deref";
3119 return "DW_OP_const1u";
3121 return "DW_OP_const1s";
3123 return "DW_OP_const2u";
3125 return "DW_OP_const2s";
3127 return "DW_OP_const4u";
3129 return "DW_OP_const4s";
3131 return "DW_OP_const8u";
3133 return "DW_OP_const8s";
3135 return "DW_OP_constu";
3137 return "DW_OP_consts";
3141 return "DW_OP_drop";
3143 return "DW_OP_over";
3145 return "DW_OP_pick";
3147 return "DW_OP_swap";
3151 return "DW_OP_xderef";
3159 return "DW_OP_minus";
3171 return "DW_OP_plus";
3172 case DW_OP_plus_uconst:
3173 return "DW_OP_plus_uconst";
3179 return "DW_OP_shra";
3197 return "DW_OP_skip";
3199 return "DW_OP_lit0";
3201 return "DW_OP_lit1";
3203 return "DW_OP_lit2";
3205 return "DW_OP_lit3";
3207 return "DW_OP_lit4";
3209 return "DW_OP_lit5";
3211 return "DW_OP_lit6";
3213 return "DW_OP_lit7";
3215 return "DW_OP_lit8";
3217 return "DW_OP_lit9";
3219 return "DW_OP_lit10";
3221 return "DW_OP_lit11";
3223 return "DW_OP_lit12";
3225 return "DW_OP_lit13";
3227 return "DW_OP_lit14";
3229 return "DW_OP_lit15";
3231 return "DW_OP_lit16";
3233 return "DW_OP_lit17";
3235 return "DW_OP_lit18";
3237 return "DW_OP_lit19";
3239 return "DW_OP_lit20";
3241 return "DW_OP_lit21";
3243 return "DW_OP_lit22";
3245 return "DW_OP_lit23";
3247 return "DW_OP_lit24";
3249 return "DW_OP_lit25";
3251 return "DW_OP_lit26";
3253 return "DW_OP_lit27";
3255 return "DW_OP_lit28";
3257 return "DW_OP_lit29";
3259 return "DW_OP_lit30";
3261 return "DW_OP_lit31";
3263 return "DW_OP_reg0";
3265 return "DW_OP_reg1";
3267 return "DW_OP_reg2";
3269 return "DW_OP_reg3";
3271 return "DW_OP_reg4";
3273 return "DW_OP_reg5";
3275 return "DW_OP_reg6";
3277 return "DW_OP_reg7";
3279 return "DW_OP_reg8";
3281 return "DW_OP_reg9";
3283 return "DW_OP_reg10";
3285 return "DW_OP_reg11";
3287 return "DW_OP_reg12";
3289 return "DW_OP_reg13";
3291 return "DW_OP_reg14";
3293 return "DW_OP_reg15";
3295 return "DW_OP_reg16";
3297 return "DW_OP_reg17";
3299 return "DW_OP_reg18";
3301 return "DW_OP_reg19";
3303 return "DW_OP_reg20";
3305 return "DW_OP_reg21";
3307 return "DW_OP_reg22";
3309 return "DW_OP_reg23";
3311 return "DW_OP_reg24";
3313 return "DW_OP_reg25";
3315 return "DW_OP_reg26";
3317 return "DW_OP_reg27";
3319 return "DW_OP_reg28";
3321 return "DW_OP_reg29";
3323 return "DW_OP_reg30";
3325 return "DW_OP_reg31";
3327 return "DW_OP_breg0";
3329 return "DW_OP_breg1";
3331 return "DW_OP_breg2";
3333 return "DW_OP_breg3";
3335 return "DW_OP_breg4";
3337 return "DW_OP_breg5";
3339 return "DW_OP_breg6";
3341 return "DW_OP_breg7";
3343 return "DW_OP_breg8";
3345 return "DW_OP_breg9";
3347 return "DW_OP_breg10";
3349 return "DW_OP_breg11";
3351 return "DW_OP_breg12";
3353 return "DW_OP_breg13";
3355 return "DW_OP_breg14";
3357 return "DW_OP_breg15";
3359 return "DW_OP_breg16";
3361 return "DW_OP_breg17";
3363 return "DW_OP_breg18";
3365 return "DW_OP_breg19";
3367 return "DW_OP_breg20";
3369 return "DW_OP_breg21";
3371 return "DW_OP_breg22";
3373 return "DW_OP_breg23";
3375 return "DW_OP_breg24";
3377 return "DW_OP_breg25";
3379 return "DW_OP_breg26";
3381 return "DW_OP_breg27";
3383 return "DW_OP_breg28";
3385 return "DW_OP_breg29";
3387 return "DW_OP_breg30";
3389 return "DW_OP_breg31";
3391 return "DW_OP_regx";
3393 return "DW_OP_fbreg";
3395 return "DW_OP_bregx";
3397 return "DW_OP_piece";
3398 case DW_OP_deref_size:
3399 return "DW_OP_deref_size";
3400 case DW_OP_xderef_size:
3401 return "DW_OP_xderef_size";
3405 return "OP_<unknown>";
3409 /* Convert a DWARF type code into its string name. */
3412 dwarf_type_encoding_name (enc)
3413 register unsigned enc;
3417 case DW_ATE_address:
3418 return "DW_ATE_address";
3419 case DW_ATE_boolean:
3420 return "DW_ATE_boolean";
3421 case DW_ATE_complex_float:
3422 return "DW_ATE_complex_float";
3424 return "DW_ATE_float";
3426 return "DW_ATE_signed";
3427 case DW_ATE_signed_char:
3428 return "DW_ATE_signed_char";
3429 case DW_ATE_unsigned:
3430 return "DW_ATE_unsigned";
3431 case DW_ATE_unsigned_char:
3432 return "DW_ATE_unsigned_char";
3434 return "DW_ATE_<unknown>";
3438 /* Determine the "ultimate origin" of a decl. The decl may be an inlined
3439 instance of an inlined instance of a decl which is local to an inline
3440 function, so we have to trace all of the way back through the origin chain
3441 to find out what sort of node actually served as the original seed for the
3445 decl_ultimate_origin (decl)
3448 register tree immediate_origin = DECL_ABSTRACT_ORIGIN (decl);
3450 if (immediate_origin == NULL_TREE)
3454 register tree ret_val;
3455 register tree lookahead = immediate_origin;
3459 ret_val = lookahead;
3460 lookahead = DECL_ABSTRACT_ORIGIN (ret_val);
3462 while (lookahead != NULL && lookahead != ret_val);
3468 /* Determine the "ultimate origin" of a block. The block may be an inlined
3469 instance of an inlined instance of a block which is local to an inline
3470 function, so we have to trace all of the way back through the origin chain
3471 to find out what sort of node actually served as the original seed for the
3475 block_ultimate_origin (block)
3476 register tree block;
3478 register tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block);
3480 if (immediate_origin == NULL_TREE)
3484 register tree ret_val;
3485 register tree lookahead = immediate_origin;
3489 ret_val = lookahead;
3490 lookahead = (TREE_CODE (ret_val) == BLOCK)
3491 ? BLOCK_ABSTRACT_ORIGIN (ret_val)
3494 while (lookahead != NULL && lookahead != ret_val);
3500 /* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT
3501 of a virtual function may refer to a base class, so we check the 'this'
3505 decl_class_context (decl)
3508 tree context = NULL_TREE;
3510 if (TREE_CODE (decl) != FUNCTION_DECL || ! DECL_VINDEX (decl))
3511 context = DECL_CONTEXT (decl);
3513 context = TYPE_MAIN_VARIANT
3514 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
3516 if (context && TREE_CODE_CLASS (TREE_CODE (context)) != 't')
3517 context = NULL_TREE;
3522 /* Add an attribute/value pair to a DIE */
3525 add_dwarf_attr (die, attr)
3526 register dw_die_ref die;
3527 register dw_attr_ref attr;
3529 if (die != NULL && attr != NULL)
3531 if (die->die_attr == NULL)
3533 die->die_attr = attr;
3534 die->die_attr_last = attr;
3538 die->die_attr_last->dw_attr_next = attr;
3539 die->die_attr_last = attr;
3544 /* Add a flag value attribute to a DIE. */
3547 add_AT_flag (die, attr_kind, flag)
3548 register dw_die_ref die;
3549 register enum dwarf_attribute attr_kind;
3550 register unsigned flag;
3552 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3554 attr->dw_attr_next = NULL;
3555 attr->dw_attr = attr_kind;
3556 attr->dw_attr_val.val_class = dw_val_class_flag;
3557 attr->dw_attr_val.v.val_flag = flag;
3558 add_dwarf_attr (die, attr);
3561 /* Add a signed integer attribute value to a DIE. */
3564 add_AT_int (die, attr_kind, int_val)
3565 register dw_die_ref die;
3566 register enum dwarf_attribute attr_kind;
3567 register long int int_val;
3569 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3571 attr->dw_attr_next = NULL;
3572 attr->dw_attr = attr_kind;
3573 attr->dw_attr_val.val_class = dw_val_class_const;
3574 attr->dw_attr_val.v.val_int = int_val;
3575 add_dwarf_attr (die, attr);
3578 /* Add an unsigned integer attribute value to a DIE. */
3581 add_AT_unsigned (die, attr_kind, unsigned_val)
3582 register dw_die_ref die;
3583 register enum dwarf_attribute attr_kind;
3584 register unsigned long unsigned_val;
3586 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3588 attr->dw_attr_next = NULL;
3589 attr->dw_attr = attr_kind;
3590 attr->dw_attr_val.val_class = dw_val_class_unsigned_const;
3591 attr->dw_attr_val.v.val_unsigned = unsigned_val;
3592 add_dwarf_attr (die, attr);
3595 /* Add an unsigned double integer attribute value to a DIE. */
3598 add_AT_long_long (die, attr_kind, val_hi, val_low)
3599 register dw_die_ref die;
3600 register enum dwarf_attribute attr_kind;
3601 register unsigned long val_hi;
3602 register unsigned long val_low;
3604 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3606 attr->dw_attr_next = NULL;
3607 attr->dw_attr = attr_kind;
3608 attr->dw_attr_val.val_class = dw_val_class_long_long;
3609 attr->dw_attr_val.v.val_long_long.hi = val_hi;
3610 attr->dw_attr_val.v.val_long_long.low = val_low;
3611 add_dwarf_attr (die, attr);
3614 /* Add a floating point attribute value to a DIE and return it. */
3617 add_AT_float (die, attr_kind, length, array)
3618 register dw_die_ref die;
3619 register enum dwarf_attribute attr_kind;
3620 register unsigned length;
3621 register long *array;
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_float;
3628 attr->dw_attr_val.v.val_float.length = length;
3629 attr->dw_attr_val.v.val_float.array = array;
3630 add_dwarf_attr (die, attr);
3633 /* Add a string attribute value to a DIE. */
3636 add_AT_string (die, attr_kind, str)
3637 register dw_die_ref die;
3638 register enum dwarf_attribute attr_kind;
3641 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3643 attr->dw_attr_next = NULL;
3644 attr->dw_attr = attr_kind;
3645 attr->dw_attr_val.val_class = dw_val_class_str;
3646 attr->dw_attr_val.v.val_str = xstrdup (str);
3647 add_dwarf_attr (die, attr);
3650 /* Add a DIE reference attribute value to a DIE. */
3653 add_AT_die_ref (die, attr_kind, targ_die)
3654 register dw_die_ref die;
3655 register enum dwarf_attribute attr_kind;
3656 register dw_die_ref targ_die;
3658 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3660 attr->dw_attr_next = NULL;
3661 attr->dw_attr = attr_kind;
3662 attr->dw_attr_val.val_class = dw_val_class_die_ref;
3663 attr->dw_attr_val.v.val_die_ref = targ_die;
3664 add_dwarf_attr (die, attr);
3667 /* Add an FDE reference attribute value to a DIE. */
3670 add_AT_fde_ref (die, attr_kind, targ_fde)
3671 register dw_die_ref die;
3672 register enum dwarf_attribute attr_kind;
3673 register unsigned targ_fde;
3675 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3677 attr->dw_attr_next = NULL;
3678 attr->dw_attr = attr_kind;
3679 attr->dw_attr_val.val_class = dw_val_class_fde_ref;
3680 attr->dw_attr_val.v.val_fde_index = targ_fde;
3681 add_dwarf_attr (die, attr);
3684 /* Add a location description attribute value to a DIE. */
3687 add_AT_loc (die, attr_kind, loc)
3688 register dw_die_ref die;
3689 register enum dwarf_attribute attr_kind;
3690 register dw_loc_descr_ref loc;
3692 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3694 attr->dw_attr_next = NULL;
3695 attr->dw_attr = attr_kind;
3696 attr->dw_attr_val.val_class = dw_val_class_loc;
3697 attr->dw_attr_val.v.val_loc = loc;
3698 add_dwarf_attr (die, attr);
3701 /* Add an address constant attribute value to a DIE. */
3704 add_AT_addr (die, attr_kind, addr)
3705 register dw_die_ref die;
3706 register enum dwarf_attribute attr_kind;
3709 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3711 attr->dw_attr_next = NULL;
3712 attr->dw_attr = attr_kind;
3713 attr->dw_attr_val.val_class = dw_val_class_addr;
3714 attr->dw_attr_val.v.val_addr = addr;
3715 add_dwarf_attr (die, attr);
3718 /* Add a label identifier attribute value to a DIE. */
3721 add_AT_lbl_id (die, attr_kind, lbl_id)
3722 register dw_die_ref die;
3723 register enum dwarf_attribute attr_kind;
3724 register char *lbl_id;
3726 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3728 attr->dw_attr_next = NULL;
3729 attr->dw_attr = attr_kind;
3730 attr->dw_attr_val.val_class = dw_val_class_lbl_id;
3731 attr->dw_attr_val.v.val_lbl_id = xstrdup (lbl_id);
3732 add_dwarf_attr (die, attr);
3735 /* Add a section offset attribute value to a DIE. */
3738 add_AT_section_offset (die, attr_kind, section)
3739 register dw_die_ref die;
3740 register enum dwarf_attribute attr_kind;
3741 register char *section;
3743 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3745 attr->dw_attr_next = NULL;
3746 attr->dw_attr = attr_kind;
3747 attr->dw_attr_val.val_class = dw_val_class_section_offset;
3748 attr->dw_attr_val.v.val_section = section;
3749 add_dwarf_attr (die, attr);
3753 /* Test if die refers to an external subroutine. */
3756 is_extern_subr_die (die)
3757 register dw_die_ref die;
3759 register dw_attr_ref a;
3760 register int is_subr = FALSE;
3761 register int is_extern = FALSE;
3763 if (die != NULL && die->die_tag == DW_TAG_subprogram)
3766 for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
3768 if (a->dw_attr == DW_AT_external
3769 && a->dw_attr_val.val_class == dw_val_class_flag
3770 && a->dw_attr_val.v.val_flag != 0)
3778 return is_subr && is_extern;
3781 /* Get the attribute of type attr_kind. */
3783 static inline dw_attr_ref
3784 get_AT (die, attr_kind)
3785 register dw_die_ref die;
3786 register enum dwarf_attribute attr_kind;
3788 register dw_attr_ref a;
3789 register dw_die_ref spec = NULL;
3793 for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
3795 if (a->dw_attr == attr_kind)
3798 if (a->dw_attr == DW_AT_specification
3799 || a->dw_attr == DW_AT_abstract_origin)
3800 spec = a->dw_attr_val.v.val_die_ref;
3804 return get_AT (spec, attr_kind);
3810 /* Return the "low pc" attribute value, typically associated with
3811 a subprogram DIE. Return null if the "low pc" attribute is
3812 either not prsent, or if it cannot be represented as an
3813 assembler label identifier. */
3815 static inline char *
3817 register dw_die_ref die;
3819 register dw_attr_ref a = get_AT (die, DW_AT_low_pc);
3821 if (a && a->dw_attr_val.val_class == dw_val_class_lbl_id)
3822 return a->dw_attr_val.v.val_lbl_id;
3827 /* Return the "high pc" attribute value, typically associated with
3828 a subprogram DIE. Return null if the "high pc" attribute is
3829 either not prsent, or if it cannot be represented as an
3830 assembler label identifier. */
3832 static inline char *
3834 register dw_die_ref die;
3836 register dw_attr_ref a = get_AT (die, DW_AT_high_pc);
3838 if (a && a->dw_attr_val.val_class == dw_val_class_lbl_id)
3839 return a->dw_attr_val.v.val_lbl_id;
3844 /* Return the value of the string attribute designated by ATTR_KIND, or
3845 NULL if it is not present. */
3847 static inline char *
3848 get_AT_string (die, attr_kind)
3849 register dw_die_ref die;
3850 register enum dwarf_attribute attr_kind;
3852 register dw_attr_ref a = get_AT (die, attr_kind);
3854 if (a && a->dw_attr_val.val_class == dw_val_class_str)
3855 return a->dw_attr_val.v.val_str;
3860 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
3861 if it is not present. */
3864 get_AT_flag (die, attr_kind)
3865 register dw_die_ref die;
3866 register enum dwarf_attribute attr_kind;
3868 register dw_attr_ref a = get_AT (die, attr_kind);
3870 if (a && a->dw_attr_val.val_class == dw_val_class_flag)
3871 return a->dw_attr_val.v.val_flag;
3876 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
3877 if it is not present. */
3879 static inline unsigned
3880 get_AT_unsigned (die, attr_kind)
3881 register dw_die_ref die;
3882 register enum dwarf_attribute attr_kind;
3884 register dw_attr_ref a = get_AT (die, attr_kind);
3886 if (a && a->dw_attr_val.val_class == dw_val_class_unsigned_const)
3887 return a->dw_attr_val.v.val_unsigned;
3895 register unsigned lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
3897 return (lang == DW_LANG_C || lang == DW_LANG_C89
3898 || lang == DW_LANG_C_plus_plus);
3904 register unsigned lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
3906 return (lang == DW_LANG_Fortran77 || lang == DW_LANG_Fortran90);
3909 /* Remove the specified attribute if present. */
3912 remove_AT (die, attr_kind)
3913 register dw_die_ref die;
3914 register enum dwarf_attribute attr_kind;
3916 register dw_attr_ref a;
3917 register dw_attr_ref removed = NULL;;
3921 if (die->die_attr->dw_attr == attr_kind)
3923 removed = die->die_attr;
3924 if (die->die_attr_last == die->die_attr)
3925 die->die_attr_last = NULL;
3927 die->die_attr = die->die_attr->dw_attr_next;
3931 for (a = die->die_attr; a->dw_attr_next != NULL;
3932 a = a->dw_attr_next)
3933 if (a->dw_attr_next->dw_attr == attr_kind)
3935 removed = a->dw_attr_next;
3936 if (die->die_attr_last == a->dw_attr_next)
3937 die->die_attr_last = a;
3939 a->dw_attr_next = a->dw_attr_next->dw_attr_next;
3948 /* Discard the children of this DIE. */
3951 remove_children (die)
3952 register dw_die_ref die;
3954 register dw_die_ref child_die = die->die_child;
3956 die->die_child = NULL;
3957 die->die_child_last = NULL;
3959 while (child_die != NULL)
3961 register dw_die_ref tmp_die = child_die;
3962 register dw_attr_ref a;
3964 child_die = child_die->die_sib;
3966 for (a = tmp_die->die_attr; a != NULL; )
3968 register dw_attr_ref tmp_a = a;
3970 a = a->dw_attr_next;
3978 /* Add a child DIE below its parent. */
3981 add_child_die (die, child_die)
3982 register dw_die_ref die;
3983 register dw_die_ref child_die;
3985 if (die != NULL && child_die != NULL)
3987 if (die == child_die)
3989 child_die->die_parent = die;
3990 child_die->die_sib = NULL;
3992 if (die->die_child == NULL)
3994 die->die_child = child_die;
3995 die->die_child_last = child_die;
3999 die->die_child_last->die_sib = child_die;
4000 die->die_child_last = child_die;
4005 /* Return a pointer to a newly created DIE node. */
4007 static inline dw_die_ref
4008 new_die (tag_value, parent_die)
4009 register enum dwarf_tag tag_value;
4010 register dw_die_ref parent_die;
4012 register dw_die_ref die = (dw_die_ref) xmalloc (sizeof (die_node));
4014 die->die_tag = tag_value;
4015 die->die_abbrev = 0;
4016 die->die_offset = 0;
4017 die->die_child = NULL;
4018 die->die_parent = NULL;
4019 die->die_sib = NULL;
4020 die->die_child_last = NULL;
4021 die->die_attr = NULL;
4022 die->die_attr_last = NULL;
4024 if (parent_die != NULL)
4025 add_child_die (parent_die, die);
4028 limbo_die_node *limbo_node;
4030 limbo_node = (limbo_die_node *) xmalloc (sizeof (limbo_die_node));
4031 limbo_node->die = die;
4032 limbo_node->next = limbo_die_list;
4033 limbo_die_list = limbo_node;
4039 /* Return the DIE associated with the given type specifier. */
4041 static inline dw_die_ref
4042 lookup_type_die (type)
4045 return (dw_die_ref) TYPE_SYMTAB_POINTER (type);
4048 /* Equate a DIE to a given type specifier. */
4051 equate_type_number_to_die (type, type_die)
4053 register dw_die_ref type_die;
4055 TYPE_SYMTAB_POINTER (type) = (char *) type_die;
4058 /* Return the DIE associated with a given declaration. */
4060 static inline dw_die_ref
4061 lookup_decl_die (decl)
4064 register unsigned decl_id = DECL_UID (decl);
4066 return (decl_id < decl_die_table_in_use
4067 ? decl_die_table[decl_id] : NULL);
4070 /* Equate a DIE to a particular declaration. */
4073 equate_decl_number_to_die (decl, decl_die)
4075 register dw_die_ref decl_die;
4077 register unsigned decl_id = DECL_UID (decl);
4078 register unsigned i;
4079 register unsigned num_allocated;
4081 if (decl_id >= decl_die_table_allocated)
4084 = ((decl_id + 1 + DECL_DIE_TABLE_INCREMENT - 1)
4085 / DECL_DIE_TABLE_INCREMENT)
4086 * DECL_DIE_TABLE_INCREMENT;
4089 = (dw_die_ref *) xrealloc (decl_die_table,
4090 sizeof (dw_die_ref) * num_allocated);
4092 bzero ((char *) &decl_die_table[decl_die_table_allocated],
4093 (num_allocated - decl_die_table_allocated) * sizeof (dw_die_ref));
4094 decl_die_table_allocated = num_allocated;
4097 if (decl_id >= decl_die_table_in_use)
4098 decl_die_table_in_use = (decl_id + 1);
4100 decl_die_table[decl_id] = decl_die;
4103 /* Return a pointer to a newly allocated location description. Location
4104 descriptions are simple expression terms that can be strung
4105 together to form more complicated location (address) descriptions. */
4107 static inline dw_loc_descr_ref
4108 new_loc_descr (op, oprnd1, oprnd2)
4109 register enum dwarf_location_atom op;
4110 register unsigned long oprnd1;
4111 register unsigned long oprnd2;
4113 register dw_loc_descr_ref descr
4114 = (dw_loc_descr_ref) xmalloc (sizeof (dw_loc_descr_node));
4116 descr->dw_loc_next = NULL;
4117 descr->dw_loc_opc = op;
4118 descr->dw_loc_oprnd1.val_class = dw_val_class_unsigned_const;
4119 descr->dw_loc_oprnd1.v.val_unsigned = oprnd1;
4120 descr->dw_loc_oprnd2.val_class = dw_val_class_unsigned_const;
4121 descr->dw_loc_oprnd2.v.val_unsigned = oprnd2;
4126 /* Add a location description term to a location description expression. */
4129 add_loc_descr (list_head, descr)
4130 register dw_loc_descr_ref *list_head;
4131 register dw_loc_descr_ref descr;
4133 register dw_loc_descr_ref *d;
4135 /* Find the end of the chain. */
4136 for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
4142 /* Keep track of the number of spaces used to indent the
4143 output of the debugging routines that print the structure of
4144 the DIE internal representation. */
4145 static int print_indent;
4147 /* Indent the line the number of spaces given by print_indent. */
4150 print_spaces (outfile)
4153 fprintf (outfile, "%*s", print_indent, "");
4156 /* Print the information associated with a given DIE, and its children.
4157 This routine is a debugging aid only. */
4160 print_die (die, outfile)
4164 register dw_attr_ref a;
4165 register dw_die_ref c;
4167 print_spaces (outfile);
4168 fprintf (outfile, "DIE %4u: %s\n",
4169 die->die_offset, dwarf_tag_name (die->die_tag));
4170 print_spaces (outfile);
4171 fprintf (outfile, " abbrev id: %u", die->die_abbrev);
4172 fprintf (outfile, " offset: %u\n", die->die_offset);
4174 for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
4176 print_spaces (outfile);
4177 fprintf (outfile, " %s: ", dwarf_attr_name (a->dw_attr));
4179 switch (a->dw_attr_val.val_class)
4181 case dw_val_class_addr:
4182 fprintf (outfile, "address");
4184 case dw_val_class_loc:
4185 fprintf (outfile, "location descriptor");
4187 case dw_val_class_const:
4188 fprintf (outfile, "%d", a->dw_attr_val.v.val_int);
4190 case dw_val_class_unsigned_const:
4191 fprintf (outfile, "%u", a->dw_attr_val.v.val_unsigned);
4193 case dw_val_class_long_long:
4194 fprintf (outfile, "constant (%u,%u)",
4195 a->dw_attr_val.v.val_long_long.hi,
4196 a->dw_attr_val.v.val_long_long.low);
4198 case dw_val_class_float:
4199 fprintf (outfile, "floating-point constant");
4201 case dw_val_class_flag:
4202 fprintf (outfile, "%u", a->dw_attr_val.v.val_flag);
4204 case dw_val_class_die_ref:
4205 if (a->dw_attr_val.v.val_die_ref != NULL)
4206 fprintf (outfile, "die -> %u",
4207 a->dw_attr_val.v.val_die_ref->die_offset);
4209 fprintf (outfile, "die -> <null>");
4211 case dw_val_class_lbl_id:
4212 fprintf (outfile, "label: %s", a->dw_attr_val.v.val_lbl_id);
4214 case dw_val_class_section_offset:
4215 fprintf (outfile, "section: %s", a->dw_attr_val.v.val_section);
4217 case dw_val_class_str:
4218 if (a->dw_attr_val.v.val_str != NULL)
4219 fprintf (outfile, "\"%s\"", a->dw_attr_val.v.val_str);
4221 fprintf (outfile, "<null>");
4227 fprintf (outfile, "\n");
4230 if (die->die_child != NULL)
4233 for (c = die->die_child; c != NULL; c = c->die_sib)
4234 print_die (c, outfile);
4240 /* Print the contents of the source code line number correspondence table.
4241 This routine is a debugging aid only. */
4244 print_dwarf_line_table (outfile)
4247 register unsigned i;
4248 register dw_line_info_ref line_info;
4250 fprintf (outfile, "\n\nDWARF source line information\n");
4251 for (i = 1; i < line_info_table_in_use; ++i)
4253 line_info = &line_info_table[i];
4254 fprintf (outfile, "%5d: ", i);
4255 fprintf (outfile, "%-20s", file_table[line_info->dw_file_num]);
4256 fprintf (outfile, "%6d", line_info->dw_line_num);
4257 fprintf (outfile, "\n");
4260 fprintf (outfile, "\n\n");
4263 /* Print the information collected for a given DIE. */
4266 debug_dwarf_die (die)
4269 print_die (die, stderr);
4272 /* Print all DWARF information collected for the compilation unit.
4273 This routine is a debugging aid only. */
4279 print_die (comp_unit_die, stderr);
4280 print_dwarf_line_table (stderr);
4283 /* Traverse the DIE, and add a sibling attribute if it may have the
4284 effect of speeding up access to siblings. To save some space,
4285 avoid generating sibling attributes for DIE's without children. */
4288 add_sibling_attributes(die)
4289 register dw_die_ref die;
4291 register dw_die_ref c;
4292 register dw_attr_ref attr;
4293 if (die != comp_unit_die && die->die_child != NULL)
4295 attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
4296 attr->dw_attr_next = NULL;
4297 attr->dw_attr = DW_AT_sibling;
4298 attr->dw_attr_val.val_class = dw_val_class_die_ref;
4299 attr->dw_attr_val.v.val_die_ref = die->die_sib;
4301 /* Add the sibling link to the front of the attribute list. */
4302 attr->dw_attr_next = die->die_attr;
4303 if (die->die_attr == NULL)
4304 die->die_attr_last = attr;
4306 die->die_attr = attr;
4309 for (c = die->die_child; c != NULL; c = c->die_sib)
4310 add_sibling_attributes (c);
4313 /* The format of each DIE (and its attribute value pairs)
4314 is encoded in an abbreviation table. This routine builds the
4315 abbreviation table and assigns a unique abbreviation id for
4316 each abbreviation entry. The children of each die are visited
4320 build_abbrev_table (die)
4321 register dw_die_ref die;
4323 register unsigned long abbrev_id;
4324 register unsigned long n_alloc;
4325 register dw_die_ref c;
4326 register dw_attr_ref d_attr, a_attr;
4327 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
4329 register dw_die_ref abbrev = abbrev_die_table[abbrev_id];
4331 if (abbrev->die_tag == die->die_tag)
4333 if ((abbrev->die_child != NULL) == (die->die_child != NULL))
4335 a_attr = abbrev->die_attr;
4336 d_attr = die->die_attr;
4338 while (a_attr != NULL && d_attr != NULL)
4340 if ((a_attr->dw_attr != d_attr->dw_attr)
4341 || (value_format (&a_attr->dw_attr_val)
4342 != value_format (&d_attr->dw_attr_val)))
4345 a_attr = a_attr->dw_attr_next;
4346 d_attr = d_attr->dw_attr_next;
4349 if (a_attr == NULL && d_attr == NULL)
4355 if (abbrev_id >= abbrev_die_table_in_use)
4357 if (abbrev_die_table_in_use >= abbrev_die_table_allocated)
4359 n_alloc = abbrev_die_table_allocated + ABBREV_DIE_TABLE_INCREMENT;
4361 = (dw_die_ref *) xrealloc (abbrev_die_table,
4362 sizeof (dw_die_ref) * n_alloc);
4364 bzero ((char *) &abbrev_die_table[abbrev_die_table_allocated],
4365 (n_alloc - abbrev_die_table_allocated) * sizeof (dw_die_ref));
4366 abbrev_die_table_allocated = n_alloc;
4369 ++abbrev_die_table_in_use;
4370 abbrev_die_table[abbrev_id] = die;
4373 die->die_abbrev = abbrev_id;
4374 for (c = die->die_child; c != NULL; c = c->die_sib)
4375 build_abbrev_table (c);
4378 /* Return the size of a string, including the null byte. */
4380 static unsigned long
4381 size_of_string (str)
4384 register unsigned long size = 0;
4385 register unsigned long slen = strlen (str);
4386 register unsigned long i;
4387 register unsigned c;
4389 for (i = 0; i < slen; ++i)
4398 /* Null terminator. */
4403 /* Return the size of a location descriptor. */
4405 static unsigned long
4406 size_of_loc_descr (loc)
4407 register dw_loc_descr_ref loc;
4409 register unsigned long size = 1;
4411 switch (loc->dw_loc_opc)
4433 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4436 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
4441 case DW_OP_plus_uconst:
4442 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4480 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
4483 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4486 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
4489 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4490 size += size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int);
4493 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4495 case DW_OP_deref_size:
4496 case DW_OP_xderef_size:
4506 /* Return the size of a series of location descriptors. */
4508 static unsigned long
4510 register dw_loc_descr_ref loc;
4512 register unsigned long size = 0;
4514 for (; loc != NULL; loc = loc->dw_loc_next)
4515 size += size_of_loc_descr (loc);
4520 /* Return the power-of-two number of bytes necessary to represent VALUE. */
4523 constant_size (value)
4524 long unsigned value;
4531 log = floor_log2 (value);
4534 log = 1 << (floor_log2 (log) + 1);
4539 /* Return the size of a DIE, as it is represented in the
4540 .debug_info section. */
4542 static unsigned long
4544 register dw_die_ref die;
4546 register unsigned long size = 0;
4547 register dw_attr_ref a;
4549 size += size_of_uleb128 (die->die_abbrev);
4550 for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
4552 switch (a->dw_attr_val.val_class)
4554 case dw_val_class_addr:
4557 case dw_val_class_loc:
4559 register unsigned long lsize
4560 = size_of_locs (a->dw_attr_val.v.val_loc);
4563 size += constant_size (lsize);
4567 case dw_val_class_const:
4570 case dw_val_class_unsigned_const:
4571 size += constant_size (a->dw_attr_val.v.val_unsigned);
4573 case dw_val_class_long_long:
4574 size += 1 + 8; /* block */
4576 case dw_val_class_float:
4577 size += 1 + a->dw_attr_val.v.val_float.length * 4; /* block */
4579 case dw_val_class_flag:
4582 case dw_val_class_die_ref:
4583 size += DWARF_OFFSET_SIZE;
4585 case dw_val_class_fde_ref:
4586 size += DWARF_OFFSET_SIZE;
4588 case dw_val_class_lbl_id:
4591 case dw_val_class_section_offset:
4592 size += DWARF_OFFSET_SIZE;
4594 case dw_val_class_str:
4595 size += size_of_string (a->dw_attr_val.v.val_str);
4605 /* Size the debugging information associated with a given DIE.
4606 Visits the DIE's children recursively. Updates the global
4607 variable next_die_offset, on each time through. Uses the
4608 current value of next_die_offset to update the die_offset
4609 field in each DIE. */
4612 calc_die_sizes (die)
4615 register dw_die_ref c;
4616 die->die_offset = next_die_offset;
4617 next_die_offset += size_of_die (die);
4619 for (c = die->die_child; c != NULL; c = c->die_sib)
4622 if (die->die_child != NULL)
4623 /* Count the null byte used to terminate sibling lists. */
4624 next_die_offset += 1;
4627 /* Return the size of the line information prolog generated for the
4628 compilation unit. */
4630 static unsigned long
4631 size_of_line_prolog ()
4633 register unsigned long size;
4634 register unsigned long ft_index;
4636 size = DWARF_LINE_PROLOG_HEADER_SIZE;
4638 /* Count the size of the table giving number of args for each
4640 size += DWARF_LINE_OPCODE_BASE - 1;
4642 /* Include directory table is empty (at present). Count only the
4643 the null byte used to terminate the table. */
4646 for (ft_index = 1; ft_index < file_table_in_use; ++ft_index)
4648 /* File name entry. */
4649 size += size_of_string (file_table[ft_index]);
4651 /* Include directory index. */
4652 size += size_of_uleb128 (0);
4654 /* Modification time. */
4655 size += size_of_uleb128 (0);
4657 /* File length in bytes. */
4658 size += size_of_uleb128 (0);
4661 /* Count the file table terminator. */
4666 /* Return the size of the line information generated for this
4667 compilation unit. */
4669 static unsigned long
4670 size_of_line_info ()
4672 register unsigned long size;
4673 register unsigned long lt_index;
4674 register unsigned long current_line;
4675 register long line_offset;
4676 register long line_delta;
4677 register unsigned long current_file;
4678 register unsigned long function;
4679 unsigned long size_of_set_address;
4681 /* Size of a DW_LNE_set_address instruction. */
4682 size_of_set_address = 1 + size_of_uleb128 (1 + PTR_SIZE) + 1 + PTR_SIZE;
4684 /* Version number. */
4687 /* Prolog length specifier. */
4688 size += DWARF_OFFSET_SIZE;
4691 size += size_of_line_prolog ();
4693 /* Set address register instruction. */
4694 size += size_of_set_address;
4698 for (lt_index = 1; lt_index < line_info_table_in_use; ++lt_index)
4700 register dw_line_info_ref line_info;
4702 /* Advance pc instruction. */
4703 /* ??? See the DW_LNS_advance_pc comment in output_line_info. */
4707 size += size_of_set_address;
4709 line_info = &line_info_table[lt_index];
4710 if (line_info->dw_file_num != current_file)
4712 /* Set file number instruction. */
4714 current_file = line_info->dw_file_num;
4715 size += size_of_uleb128 (current_file);
4718 if (line_info->dw_line_num != current_line)
4720 line_offset = line_info->dw_line_num - current_line;
4721 line_delta = line_offset - DWARF_LINE_BASE;
4722 current_line = line_info->dw_line_num;
4723 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
4724 /* 1-byte special line number instruction. */
4728 /* Advance line instruction. */
4730 size += size_of_sleb128 (line_offset);
4731 /* Generate line entry instruction. */
4737 /* Advance pc instruction. */
4741 size += size_of_set_address;
4743 /* End of line number info. marker. */
4744 size += 1 + size_of_uleb128 (1) + 1;
4749 for (lt_index = 0; lt_index < separate_line_info_table_in_use; )
4751 register dw_separate_line_info_ref line_info
4752 = &separate_line_info_table[lt_index];
4753 if (function != line_info->function)
4755 function = line_info->function;
4756 /* Set address register instruction. */
4757 size += size_of_set_address;
4761 /* Advance pc instruction. */
4765 size += size_of_set_address;
4768 if (line_info->dw_file_num != current_file)
4770 /* Set file number instruction. */
4772 current_file = line_info->dw_file_num;
4773 size += size_of_uleb128 (current_file);
4776 if (line_info->dw_line_num != current_line)
4778 line_offset = line_info->dw_line_num - current_line;
4779 line_delta = line_offset - DWARF_LINE_BASE;
4780 current_line = line_info->dw_line_num;
4781 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
4782 /* 1-byte special line number instruction. */
4786 /* Advance line instruction. */
4788 size += size_of_sleb128 (line_offset);
4790 /* Generate line entry instruction. */
4797 /* If we're done with a function, end its sequence. */
4798 if (lt_index == separate_line_info_table_in_use
4799 || separate_line_info_table[lt_index].function != function)
4804 /* Advance pc instruction. */
4808 size += size_of_set_address;
4810 /* End of line number info. marker. */
4811 size += 1 + size_of_uleb128 (1) + 1;
4818 /* Return the size of the .debug_pubnames table generated for the
4819 compilation unit. */
4821 static unsigned long
4824 register unsigned long size;
4825 register unsigned i;
4827 size = DWARF_PUBNAMES_HEADER_SIZE;
4828 for (i = 0; i < pubname_table_in_use; ++i)
4830 register pubname_ref p = &pubname_table[i];
4831 size += DWARF_OFFSET_SIZE + size_of_string (p->name);
4834 size += DWARF_OFFSET_SIZE;
4838 /* Return the size of the information in the .debug_aranges section. */
4840 static unsigned long
4843 register unsigned long size;
4845 size = DWARF_ARANGES_HEADER_SIZE;
4847 /* Count the address/length pair for this compilation unit. */
4848 size += 2 * PTR_SIZE;
4849 size += 2 * PTR_SIZE * arange_table_in_use;
4851 /* Count the two zero words used to terminated the address range table. */
4852 size += 2 * PTR_SIZE;
4856 /* Select the encoding of an attribute value. */
4858 static enum dwarf_form
4862 switch (v->val_class)
4864 case dw_val_class_addr:
4865 return DW_FORM_addr;
4866 case dw_val_class_loc:
4867 switch (constant_size (size_of_locs (v->v.val_loc)))
4870 return DW_FORM_block1;
4872 return DW_FORM_block2;
4876 case dw_val_class_const:
4877 return DW_FORM_data4;
4878 case dw_val_class_unsigned_const:
4879 switch (constant_size (v->v.val_unsigned))
4882 return DW_FORM_data1;
4884 return DW_FORM_data2;
4886 return DW_FORM_data4;
4888 return DW_FORM_data8;
4892 case dw_val_class_long_long:
4893 return DW_FORM_block1;
4894 case dw_val_class_float:
4895 return DW_FORM_block1;
4896 case dw_val_class_flag:
4897 return DW_FORM_flag;
4898 case dw_val_class_die_ref:
4900 case dw_val_class_fde_ref:
4901 return DW_FORM_data;
4902 case dw_val_class_lbl_id:
4903 return DW_FORM_addr;
4904 case dw_val_class_section_offset:
4905 return DW_FORM_data;
4906 case dw_val_class_str:
4907 return DW_FORM_string;
4913 /* Output the encoding of an attribute value. */
4916 output_value_format (v)
4919 enum dwarf_form form = value_format (v);
4921 output_uleb128 (form);
4923 fprintf (asm_out_file, " (%s)", dwarf_form_name (form));
4925 fputc ('\n', asm_out_file);
4928 /* Output the .debug_abbrev section which defines the DIE abbreviation
4932 output_abbrev_section ()
4934 unsigned long abbrev_id;
4937 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
4939 register dw_die_ref abbrev = abbrev_die_table[abbrev_id];
4941 output_uleb128 (abbrev_id);
4943 fprintf (asm_out_file, " (abbrev code)");
4945 fputc ('\n', asm_out_file);
4946 output_uleb128 (abbrev->die_tag);
4948 fprintf (asm_out_file, " (TAG: %s)",
4949 dwarf_tag_name (abbrev->die_tag));
4951 fputc ('\n', asm_out_file);
4952 fprintf (asm_out_file, "\t%s\t0x%x", ASM_BYTE_OP,
4953 abbrev->die_child != NULL ? DW_children_yes : DW_children_no);
4956 fprintf (asm_out_file, "\t%s %s",
4958 (abbrev->die_child != NULL
4959 ? "DW_children_yes" : "DW_children_no"));
4961 fputc ('\n', asm_out_file);
4963 for (a_attr = abbrev->die_attr; a_attr != NULL;
4964 a_attr = a_attr->dw_attr_next)
4966 output_uleb128 (a_attr->dw_attr);
4968 fprintf (asm_out_file, " (%s)",
4969 dwarf_attr_name (a_attr->dw_attr));
4971 fputc ('\n', asm_out_file);
4972 output_value_format (&a_attr->dw_attr_val);
4975 fprintf (asm_out_file, "\t%s\t0,0\n", ASM_BYTE_OP);
4979 /* Output location description stack opcode's operands (if any). */
4982 output_loc_operands (loc)
4983 register dw_loc_descr_ref loc;
4985 register dw_val_ref val1 = &loc->dw_loc_oprnd1;
4986 register dw_val_ref val2 = &loc->dw_loc_oprnd2;
4988 switch (loc->dw_loc_opc)
4991 ASM_OUTPUT_DWARF_ADDR_CONST (asm_out_file, val1->v.val_addr);
4992 fputc ('\n', asm_out_file);
4996 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, val1->v.val_flag);
4997 fputc ('\n', asm_out_file);
5001 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, val1->v.val_int);
5002 fputc ('\n', asm_out_file);
5006 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, val1->v.val_int);
5007 fputc ('\n', asm_out_file);
5012 fputc ('\n', asm_out_file);
5015 output_uleb128 (val1->v.val_unsigned);
5016 fputc ('\n', asm_out_file);
5019 output_sleb128 (val1->v.val_int);
5020 fputc ('\n', asm_out_file);
5023 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, val1->v.val_int);
5024 fputc ('\n', asm_out_file);
5026 case DW_OP_plus_uconst:
5027 output_uleb128 (val1->v.val_unsigned);
5028 fputc ('\n', asm_out_file);
5032 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, val1->v.val_int);
5033 fputc ('\n', asm_out_file);
5067 output_sleb128 (val1->v.val_int);
5068 fputc ('\n', asm_out_file);
5071 output_uleb128 (val1->v.val_unsigned);
5072 fputc ('\n', asm_out_file);
5075 output_sleb128 (val1->v.val_int);
5076 fputc ('\n', asm_out_file);
5079 output_uleb128 (val1->v.val_unsigned);
5080 fputc ('\n', asm_out_file);
5081 output_sleb128 (val2->v.val_int);
5082 fputc ('\n', asm_out_file);
5085 output_uleb128 (val1->v.val_unsigned);
5086 fputc ('\n', asm_out_file);
5088 case DW_OP_deref_size:
5089 case DW_OP_xderef_size:
5090 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, val1->v.val_flag);
5091 fputc ('\n', asm_out_file);
5098 /* Compute the offset of a sibling. */
5100 static unsigned long
5101 sibling_offset (die)
5104 unsigned long offset;
5106 if (die->die_child_last == NULL)
5107 offset = die->die_offset + size_of_die (die);
5109 offset = sibling_offset (die->die_child_last) + 1;
5114 /* Output the DIE and its attributes. Called recursively to generate
5115 the definitions of each child DIE. */
5119 register dw_die_ref die;
5121 register dw_attr_ref a;
5122 register dw_die_ref c;
5123 register unsigned long ref_offset;
5124 register unsigned long size;
5125 register dw_loc_descr_ref loc;
5128 output_uleb128 (die->die_abbrev);
5130 fprintf (asm_out_file, " (DIE (0x%x) %s)",
5131 die->die_offset, dwarf_tag_name (die->die_tag));
5133 fputc ('\n', asm_out_file);
5135 for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
5137 switch (a->dw_attr_val.val_class)
5139 case dw_val_class_addr:
5140 ASM_OUTPUT_DWARF_ADDR_CONST (asm_out_file,
5141 a->dw_attr_val.v.val_addr);
5144 case dw_val_class_loc:
5145 size = size_of_locs (a->dw_attr_val.v.val_loc);
5147 /* Output the block length for this list of location operations. */
5148 switch (constant_size (size))
5151 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, size);
5154 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, size);
5161 fprintf (asm_out_file, "\t%s %s",
5162 ASM_COMMENT_START, dwarf_attr_name (a->dw_attr));
5164 fputc ('\n', asm_out_file);
5165 for (loc = a->dw_attr_val.v.val_loc; loc != NULL;
5166 loc = loc->dw_loc_next)
5168 /* Output the opcode. */
5169 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, loc->dw_loc_opc);
5171 fprintf (asm_out_file, "\t%s %s", ASM_COMMENT_START,
5172 dwarf_stack_op_name (loc->dw_loc_opc));
5174 fputc ('\n', asm_out_file);
5176 /* Output the operand(s) (if any). */
5177 output_loc_operands (loc);
5181 case dw_val_class_const:
5182 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, a->dw_attr_val.v.val_int);
5185 case dw_val_class_unsigned_const:
5186 switch (constant_size (a->dw_attr_val.v.val_unsigned))
5189 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
5190 a->dw_attr_val.v.val_unsigned);
5193 ASM_OUTPUT_DWARF_DATA2 (asm_out_file,
5194 a->dw_attr_val.v.val_unsigned);
5197 ASM_OUTPUT_DWARF_DATA4 (asm_out_file,
5198 a->dw_attr_val.v.val_unsigned);
5201 ASM_OUTPUT_DWARF_DATA8 (asm_out_file,
5202 a->dw_attr_val.v.val_long_long.hi,
5203 a->dw_attr_val.v.val_long_long.low);
5210 case dw_val_class_long_long:
5211 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 8);
5213 fprintf (asm_out_file, "\t%s %s",
5214 ASM_COMMENT_START, dwarf_attr_name (a->dw_attr));
5216 fputc ('\n', asm_out_file);
5217 ASM_OUTPUT_DWARF_DATA8 (asm_out_file,
5218 a->dw_attr_val.v.val_long_long.hi,
5219 a->dw_attr_val.v.val_long_long.low);
5222 fprintf (asm_out_file,
5223 "\t%s long long constant", ASM_COMMENT_START);
5225 fputc ('\n', asm_out_file);
5228 case dw_val_class_float:
5229 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
5230 a->dw_attr_val.v.val_float.length * 4);
5232 fprintf (asm_out_file, "\t%s %s",
5233 ASM_COMMENT_START, dwarf_attr_name (a->dw_attr));
5235 fputc ('\n', asm_out_file);
5236 for (i = 0; i < a->dw_attr_val.v.val_float.length; ++i)
5238 ASM_OUTPUT_DWARF_DATA4 (asm_out_file,
5239 a->dw_attr_val.v.val_float.array[i]);
5241 fprintf (asm_out_file, "\t%s fp constant word %d",
5242 ASM_COMMENT_START, i);
5244 fputc ('\n', asm_out_file);
5248 case dw_val_class_flag:
5249 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, a->dw_attr_val.v.val_flag);
5252 case dw_val_class_die_ref:
5253 if (a->dw_attr_val.v.val_die_ref != NULL)
5254 ref_offset = a->dw_attr_val.v.val_die_ref->die_offset;
5255 else if (a->dw_attr == DW_AT_sibling)
5256 ref_offset = sibling_offset(die);
5260 ASM_OUTPUT_DWARF_DATA (asm_out_file, ref_offset);
5263 case dw_val_class_fde_ref:
5266 ASM_GENERATE_INTERNAL_LABEL
5267 (l1, FDE_AFTER_SIZE_LABEL, a->dw_attr_val.v.val_fde_index * 2);
5268 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, l1);
5269 fprintf (asm_out_file, " - %d", DWARF_OFFSET_SIZE);
5273 case dw_val_class_lbl_id:
5274 ASM_OUTPUT_DWARF_ADDR (asm_out_file, a->dw_attr_val.v.val_lbl_id);
5277 case dw_val_class_section_offset:
5278 ASM_OUTPUT_DWARF_OFFSET (asm_out_file,
5280 (a->dw_attr_val.v.val_section));
5283 case dw_val_class_str:
5285 ASM_OUTPUT_DWARF_STRING (asm_out_file, a->dw_attr_val.v.val_str);
5287 ASM_OUTPUT_ASCII (asm_out_file,
5288 a->dw_attr_val.v.val_str,
5289 strlen (a->dw_attr_val.v.val_str) + 1);
5296 if (a->dw_attr_val.val_class != dw_val_class_loc
5297 && a->dw_attr_val.val_class != dw_val_class_long_long
5298 && a->dw_attr_val.val_class != dw_val_class_float)
5301 fprintf (asm_out_file, "\t%s %s",
5302 ASM_COMMENT_START, dwarf_attr_name (a->dw_attr));
5304 fputc ('\n', asm_out_file);
5308 for (c = die->die_child; c != NULL; c = c->die_sib)
5311 if (die->die_child != NULL)
5313 /* Add null byte to terminate sibling list. */
5314 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5316 fprintf (asm_out_file, "\t%s end of children of DIE 0x%x",
5317 ASM_COMMENT_START, die->die_offset);
5319 fputc ('\n', asm_out_file);
5323 /* Output the compilation unit that appears at the beginning of the
5324 .debug_info section, and precedes the DIE descriptions. */
5327 output_compilation_unit_header ()
5329 ASM_OUTPUT_DWARF_DATA (asm_out_file, next_die_offset - DWARF_OFFSET_SIZE);
5331 fprintf (asm_out_file, "\t%s Length of Compilation Unit Info.",
5334 fputc ('\n', asm_out_file);
5335 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, DWARF_VERSION);
5337 fprintf (asm_out_file, "\t%s DWARF version number", ASM_COMMENT_START);
5339 fputc ('\n', asm_out_file);
5340 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, stripattributes (ABBREV_SECTION));
5342 fprintf (asm_out_file, "\t%s Offset Into Abbrev. Section",
5345 fputc ('\n', asm_out_file);
5346 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, PTR_SIZE);
5348 fprintf (asm_out_file, "\t%s Pointer Size (in bytes)", ASM_COMMENT_START);
5350 fputc ('\n', asm_out_file);
5353 /* The DWARF2 pubname for a nested thingy looks like "A::f". The output
5354 of decl_printable_name for C++ looks like "A::f(int)". Let's drop the
5355 argument list, and maybe the scope. */
5358 dwarf2_name (decl, scope)
5362 return (*decl_printable_name) (decl, scope ? 1 : 0);
5365 /* Add a new entry to .debug_pubnames if appropriate. */
5368 add_pubname (decl, die)
5374 if (! TREE_PUBLIC (decl))
5377 if (pubname_table_in_use == pubname_table_allocated)
5379 pubname_table_allocated += PUBNAME_TABLE_INCREMENT;
5380 pubname_table = (pubname_ref) xrealloc
5381 (pubname_table, pubname_table_allocated * sizeof (pubname_entry));
5384 p = &pubname_table[pubname_table_in_use++];
5387 p->name = xstrdup (dwarf2_name (decl, 1));
5390 /* Output the public names table used to speed up access to externally
5391 visible names. For now, only generate entries for externally
5392 visible procedures. */
5397 register unsigned i;
5398 register unsigned long pubnames_length = size_of_pubnames ();
5400 ASM_OUTPUT_DWARF_DATA (asm_out_file, pubnames_length);
5403 fprintf (asm_out_file, "\t%s Length of Public Names Info.",
5406 fputc ('\n', asm_out_file);
5407 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, DWARF_VERSION);
5410 fprintf (asm_out_file, "\t%s DWARF Version", ASM_COMMENT_START);
5412 fputc ('\n', asm_out_file);
5413 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, stripattributes (DEBUG_INFO_SECTION));
5415 fprintf (asm_out_file, "\t%s Offset of Compilation Unit Info.",
5418 fputc ('\n', asm_out_file);
5419 ASM_OUTPUT_DWARF_DATA (asm_out_file, next_die_offset);
5421 fprintf (asm_out_file, "\t%s Compilation Unit Length", ASM_COMMENT_START);
5423 fputc ('\n', asm_out_file);
5424 for (i = 0; i < pubname_table_in_use; ++i)
5426 register pubname_ref pub = &pubname_table[i];
5428 ASM_OUTPUT_DWARF_DATA (asm_out_file, pub->die->die_offset);
5430 fprintf (asm_out_file, "\t%s DIE offset", ASM_COMMENT_START);
5432 fputc ('\n', asm_out_file);
5436 ASM_OUTPUT_DWARF_STRING (asm_out_file, pub->name);
5437 fprintf (asm_out_file, "%s external name", ASM_COMMENT_START);
5441 ASM_OUTPUT_ASCII (asm_out_file, pub->name, strlen (pub->name) + 1);
5444 fputc ('\n', asm_out_file);
5447 ASM_OUTPUT_DWARF_DATA (asm_out_file, 0);
5448 fputc ('\n', asm_out_file);
5451 /* Add a new entry to .debug_aranges if appropriate. */
5454 add_arange (decl, die)
5458 if (! DECL_SECTION_NAME (decl))
5461 if (arange_table_in_use == arange_table_allocated)
5463 arange_table_allocated += ARANGE_TABLE_INCREMENT;
5465 = (arange_ref) xrealloc (arange_table,
5466 arange_table_allocated * sizeof (dw_die_ref));
5469 arange_table[arange_table_in_use++] = die;
5472 /* Output the information that goes into the .debug_aranges table.
5473 Namely, define the beginning and ending address range of the
5474 text section generated for this compilation unit. */
5479 register unsigned i;
5480 register unsigned long aranges_length = size_of_aranges ();
5482 ASM_OUTPUT_DWARF_DATA (asm_out_file, aranges_length);
5484 fprintf (asm_out_file, "\t%s Length of Address Ranges Info.",
5487 fputc ('\n', asm_out_file);
5488 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, DWARF_VERSION);
5490 fprintf (asm_out_file, "\t%s DWARF Version", ASM_COMMENT_START);
5492 fputc ('\n', asm_out_file);
5493 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, stripattributes (DEBUG_INFO_SECTION));
5495 fprintf (asm_out_file, "\t%s Offset of Compilation Unit Info.",
5498 fputc ('\n', asm_out_file);
5499 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, PTR_SIZE);
5501 fprintf (asm_out_file, "\t%s Size of Address", ASM_COMMENT_START);
5503 fputc ('\n', asm_out_file);
5504 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5506 fprintf (asm_out_file, "\t%s Size of Segment Descriptor",
5509 fputc ('\n', asm_out_file);
5510 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 4);
5512 fprintf (asm_out_file, ",0,0");
5515 fprintf (asm_out_file, "\t%s Pad to %d byte boundary",
5516 ASM_COMMENT_START, 2 * PTR_SIZE);
5518 fputc ('\n', asm_out_file);
5519 ASM_OUTPUT_DWARF_ADDR (asm_out_file, TEXT_SECTION);
5521 fprintf (asm_out_file, "\t%s Address", ASM_COMMENT_START);
5523 fputc ('\n', asm_out_file);
5524 ASM_OUTPUT_DWARF_ADDR_DELTA (asm_out_file, text_end_label, TEXT_SECTION);
5526 fprintf (asm_out_file, "%s Length", ASM_COMMENT_START);
5528 fputc ('\n', asm_out_file);
5529 for (i = 0; i < arange_table_in_use; ++i)
5531 dw_die_ref a = arange_table[i];
5533 if (a->die_tag == DW_TAG_subprogram)
5534 ASM_OUTPUT_DWARF_ADDR (asm_out_file, get_AT_low_pc (a));
5537 char *name = get_AT_string (a, DW_AT_MIPS_linkage_name);
5539 name = get_AT_string (a, DW_AT_name);
5541 ASM_OUTPUT_DWARF_ADDR (asm_out_file, name);
5545 fprintf (asm_out_file, "\t%s Address", ASM_COMMENT_START);
5547 fputc ('\n', asm_out_file);
5548 if (a->die_tag == DW_TAG_subprogram)
5549 ASM_OUTPUT_DWARF_ADDR_DELTA (asm_out_file, get_AT_hi_pc (a),
5552 ASM_OUTPUT_DWARF_ADDR_DATA (asm_out_file,
5553 get_AT_unsigned (a, DW_AT_byte_size));
5556 fprintf (asm_out_file, "%s Length", ASM_COMMENT_START);
5558 fputc ('\n', asm_out_file);
5561 /* Output the terminator words. */
5562 ASM_OUTPUT_DWARF_ADDR_DATA (asm_out_file, 0);
5563 fputc ('\n', asm_out_file);
5564 ASM_OUTPUT_DWARF_ADDR_DATA (asm_out_file, 0);
5565 fputc ('\n', asm_out_file);
5568 /* Output the source line number correspondence information. This
5569 information goes into the .debug_line section.
5571 If the format of this data changes, then the function size_of_line_info
5572 must also be adjusted the same way. */
5577 char line_label[MAX_ARTIFICIAL_LABEL_BYTES];
5578 char prev_line_label[MAX_ARTIFICIAL_LABEL_BYTES];
5579 register unsigned opc;
5580 register unsigned n_op_args;
5581 register unsigned long ft_index;
5582 register unsigned long lt_index;
5583 register unsigned long current_line;
5584 register long line_offset;
5585 register long line_delta;
5586 register unsigned long current_file;
5587 register unsigned long function;
5589 ASM_OUTPUT_DWARF_DATA (asm_out_file, size_of_line_info ());
5591 fprintf (asm_out_file, "\t%s Length of Source Line Info.",
5594 fputc ('\n', asm_out_file);
5595 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, DWARF_VERSION);
5597 fprintf (asm_out_file, "\t%s DWARF Version", ASM_COMMENT_START);
5599 fputc ('\n', asm_out_file);
5600 ASM_OUTPUT_DWARF_DATA (asm_out_file, size_of_line_prolog ());
5602 fprintf (asm_out_file, "\t%s Prolog Length", ASM_COMMENT_START);
5604 fputc ('\n', asm_out_file);
5605 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DWARF_LINE_MIN_INSTR_LENGTH);
5607 fprintf (asm_out_file, "\t%s Minimum Instruction Length",
5610 fputc ('\n', asm_out_file);
5611 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DWARF_LINE_DEFAULT_IS_STMT_START);
5613 fprintf (asm_out_file, "\t%s Default is_stmt_start flag",
5616 fputc ('\n', asm_out_file);
5617 fprintf (asm_out_file, "\t%s\t%d", ASM_BYTE_OP, DWARF_LINE_BASE);
5619 fprintf (asm_out_file, "\t%s Line Base Value (Special Opcodes)",
5622 fputc ('\n', asm_out_file);
5623 fprintf (asm_out_file, "\t%s\t%u", ASM_BYTE_OP, DWARF_LINE_RANGE);
5625 fprintf (asm_out_file, "\t%s Line Range Value (Special Opcodes)",
5628 fputc ('\n', asm_out_file);
5629 fprintf (asm_out_file, "\t%s\t%u", ASM_BYTE_OP, DWARF_LINE_OPCODE_BASE);
5631 fprintf (asm_out_file, "\t%s Special Opcode Base", ASM_COMMENT_START);
5633 fputc ('\n', asm_out_file);
5634 for (opc = 1; opc < DWARF_LINE_OPCODE_BASE; ++opc)
5638 case DW_LNS_advance_pc:
5639 case DW_LNS_advance_line:
5640 case DW_LNS_set_file:
5641 case DW_LNS_set_column:
5642 case DW_LNS_fixed_advance_pc:
5649 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, n_op_args);
5651 fprintf (asm_out_file, "\t%s opcode: 0x%x has %d args",
5652 ASM_COMMENT_START, opc, n_op_args);
5653 fputc ('\n', asm_out_file);
5657 fprintf (asm_out_file, "%s Include Directory Table\n", ASM_COMMENT_START);
5659 /* Include directory table is empty, at present */
5660 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5661 fputc ('\n', asm_out_file);
5663 fprintf (asm_out_file, "%s File Name Table\n", ASM_COMMENT_START);
5665 for (ft_index = 1; ft_index < file_table_in_use; ++ft_index)
5669 ASM_OUTPUT_DWARF_STRING (asm_out_file, file_table[ft_index]);
5670 fprintf (asm_out_file, "%s File Entry: 0x%x",
5671 ASM_COMMENT_START, ft_index);
5675 ASM_OUTPUT_ASCII (asm_out_file,
5676 file_table[ft_index],
5677 strlen (file_table[ft_index]) + 1);
5680 fputc ('\n', asm_out_file);
5682 /* Include directory index */
5684 fputc ('\n', asm_out_file);
5686 /* Modification time */
5688 fputc ('\n', asm_out_file);
5690 /* File length in bytes */
5692 fputc ('\n', asm_out_file);
5695 /* Terminate the file name table */
5696 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5697 fputc ('\n', asm_out_file);
5699 /* Set the address register to the first location in the text section */
5700 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5702 fprintf (asm_out_file, "\t%s DW_LNE_set_address", ASM_COMMENT_START);
5704 fputc ('\n', asm_out_file);
5705 output_uleb128 (1 + PTR_SIZE);
5706 fputc ('\n', asm_out_file);
5707 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address);
5708 fputc ('\n', asm_out_file);
5709 ASM_OUTPUT_DWARF_ADDR (asm_out_file, TEXT_SECTION);
5710 fputc ('\n', asm_out_file);
5712 /* Generate the line number to PC correspondence table, encoded as
5713 a series of state machine operations. */
5716 strcpy (prev_line_label, TEXT_SECTION);
5717 for (lt_index = 1; lt_index < line_info_table_in_use; ++lt_index)
5719 register dw_line_info_ref line_info;
5721 /* Emit debug info for the address of the current line, choosing
5722 the encoding that uses the least amount of space. */
5723 /* ??? Unfortunately, we have little choice here currently, and must
5724 always use the most general form. Gcc does not know the address
5725 delta itself, so we can't use DW_LNS_advance_pc. There are no known
5726 dwarf2 aware assemblers at this time, so we can't use any special
5727 pseudo ops that would allow the assembler to optimally encode this for
5728 us. Many ports do have length attributes which will give an upper
5729 bound on the address range. We could perhaps use length attributes
5730 to determine when it is safe to use DW_LNS_fixed_advance_pc. */
5731 ASM_GENERATE_INTERNAL_LABEL (line_label, LINE_CODE_LABEL, lt_index);
5734 /* This can handle deltas up to 0xffff. This takes 3 bytes. */
5735 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc);
5737 fprintf (asm_out_file, "\t%s DW_LNS_fixed_advance_pc",
5740 fputc ('\n', asm_out_file);
5741 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, line_label, prev_line_label);
5742 fputc ('\n', asm_out_file);
5746 /* This can handle any delta. This takes 4+PTR_SIZE bytes. */
5747 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5749 fprintf (asm_out_file, "\t%s DW_LNE_set_address",
5751 fputc ('\n', asm_out_file);
5752 output_uleb128 (1 + PTR_SIZE);
5753 fputc ('\n', asm_out_file);
5754 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address);
5755 fputc ('\n', asm_out_file);
5756 ASM_OUTPUT_DWARF_ADDR (asm_out_file, line_label);
5757 fputc ('\n', asm_out_file);
5759 strcpy (prev_line_label, line_label);
5761 /* Emit debug info for the source file of the current line, if
5762 different from the previous line. */
5763 line_info = &line_info_table[lt_index];
5764 if (line_info->dw_file_num != current_file)
5766 current_file = line_info->dw_file_num;
5767 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_set_file);
5769 fprintf (asm_out_file, "\t%s DW_LNS_set_file", ASM_COMMENT_START);
5771 fputc ('\n', asm_out_file);
5772 output_uleb128 (current_file);
5774 fprintf (asm_out_file, " (\"%s\")", file_table[current_file]);
5776 fputc ('\n', asm_out_file);
5779 /* Emit debug info for the current line number, choosing the encoding
5780 that uses the least amount of space. */
5781 line_offset = line_info->dw_line_num - current_line;
5782 line_delta = line_offset - DWARF_LINE_BASE;
5783 current_line = line_info->dw_line_num;
5784 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
5786 /* This can handle deltas from -10 to 234, using the current
5787 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE. This
5789 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
5790 DWARF_LINE_OPCODE_BASE + line_delta);
5792 fprintf (asm_out_file,
5793 "\t%s line %d", ASM_COMMENT_START, current_line);
5795 fputc ('\n', asm_out_file);
5799 /* This can handle any delta. This takes at least 4 bytes, depending
5800 on the value being encoded. */
5801 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_advance_line);
5803 fprintf (asm_out_file, "\t%s advance to line %d",
5804 ASM_COMMENT_START, current_line);
5806 fputc ('\n', asm_out_file);
5807 output_sleb128 (line_offset);
5808 fputc ('\n', asm_out_file);
5809 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_copy);
5810 fputc ('\n', asm_out_file);
5814 /* Emit debug info for the address of the end of the function. */
5817 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc);
5819 fprintf (asm_out_file, "\t%s DW_LNS_fixed_advance_pc",
5822 fputc ('\n', asm_out_file);
5823 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, text_end_label, prev_line_label);
5824 fputc ('\n', asm_out_file);
5828 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5830 fprintf (asm_out_file, "\t%s DW_LNE_set_address", ASM_COMMENT_START);
5831 fputc ('\n', asm_out_file);
5832 output_uleb128 (1 + PTR_SIZE);
5833 fputc ('\n', asm_out_file);
5834 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address);
5835 fputc ('\n', asm_out_file);
5836 ASM_OUTPUT_DWARF_ADDR (asm_out_file, text_end_label);
5837 fputc ('\n', asm_out_file);
5840 /* Output the marker for the end of the line number info. */
5841 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5843 fprintf (asm_out_file, "\t%s DW_LNE_end_sequence", ASM_COMMENT_START);
5845 fputc ('\n', asm_out_file);
5847 fputc ('\n', asm_out_file);
5848 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_end_sequence);
5849 fputc ('\n', asm_out_file);
5854 for (lt_index = 0; lt_index < separate_line_info_table_in_use; )
5856 register dw_separate_line_info_ref line_info
5857 = &separate_line_info_table[lt_index];
5859 /* Emit debug info for the address of the current line. If this is
5860 a new function, or the first line of a function, then we need
5861 to handle it differently. */
5862 ASM_GENERATE_INTERNAL_LABEL (line_label, SEPARATE_LINE_CODE_LABEL,
5864 if (function != line_info->function)
5866 function = line_info->function;
5868 /* Set the address register to the first line in the function */
5869 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5871 fprintf (asm_out_file, "\t%s DW_LNE_set_address",
5874 fputc ('\n', asm_out_file);
5875 output_uleb128 (1 + PTR_SIZE);
5876 fputc ('\n', asm_out_file);
5877 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address);
5878 fputc ('\n', asm_out_file);
5879 ASM_OUTPUT_DWARF_ADDR (asm_out_file, line_label);
5880 fputc ('\n', asm_out_file);
5884 /* ??? See the DW_LNS_advance_pc comment above. */
5887 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc);
5889 fprintf (asm_out_file, "\t%s DW_LNS_fixed_advance_pc",
5892 fputc ('\n', asm_out_file);
5893 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, line_label,
5895 fputc ('\n', asm_out_file);
5899 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5901 fprintf (asm_out_file, "\t%s DW_LNE_set_address",
5903 fputc ('\n', asm_out_file);
5904 output_uleb128 (1 + PTR_SIZE);
5905 fputc ('\n', asm_out_file);
5906 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address);
5907 fputc ('\n', asm_out_file);
5908 ASM_OUTPUT_DWARF_ADDR (asm_out_file, line_label);
5909 fputc ('\n', asm_out_file);
5912 strcpy (prev_line_label, line_label);
5914 /* Emit debug info for the source file of the current line, if
5915 different from the previous line. */
5916 if (line_info->dw_file_num != current_file)
5918 current_file = line_info->dw_file_num;
5919 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_set_file);
5921 fprintf (asm_out_file, "\t%s DW_LNS_set_file", ASM_COMMENT_START);
5923 fputc ('\n', asm_out_file);
5924 output_uleb128 (current_file);
5926 fprintf (asm_out_file, " (\"%s\")", file_table[current_file]);
5928 fputc ('\n', asm_out_file);
5931 /* Emit debug info for the current line number, choosing the encoding
5932 that uses the least amount of space. */
5933 if (line_info->dw_line_num != current_line)
5935 line_offset = line_info->dw_line_num - current_line;
5936 line_delta = line_offset - DWARF_LINE_BASE;
5937 current_line = line_info->dw_line_num;
5938 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
5940 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
5941 DWARF_LINE_OPCODE_BASE + line_delta);
5943 fprintf (asm_out_file,
5944 "\t%s line %d", ASM_COMMENT_START, current_line);
5946 fputc ('\n', asm_out_file);
5950 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_advance_line);
5952 fprintf (asm_out_file, "\t%s advance to line %d",
5953 ASM_COMMENT_START, current_line);
5955 fputc ('\n', asm_out_file);
5956 output_sleb128 (line_offset);
5957 fputc ('\n', asm_out_file);
5958 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_copy);
5959 fputc ('\n', asm_out_file);
5965 /* If we're done with a function, end its sequence. */
5966 if (lt_index == separate_line_info_table_in_use
5967 || separate_line_info_table[lt_index].function != function)
5972 /* Emit debug info for the address of the end of the function. */
5973 ASM_GENERATE_INTERNAL_LABEL (line_label, FUNC_END_LABEL, function);
5976 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc);
5978 fprintf (asm_out_file, "\t%s DW_LNS_fixed_advance_pc",
5981 fputc ('\n', asm_out_file);
5982 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, line_label,
5984 fputc ('\n', asm_out_file);
5988 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5990 fprintf (asm_out_file, "\t%s DW_LNE_set_address",
5992 fputc ('\n', asm_out_file);
5993 output_uleb128 (1 + PTR_SIZE);
5994 fputc ('\n', asm_out_file);
5995 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address);
5996 fputc ('\n', asm_out_file);
5997 ASM_OUTPUT_DWARF_ADDR (asm_out_file, line_label);
5998 fputc ('\n', asm_out_file);
6001 /* Output the marker for the end of this sequence. */
6002 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
6004 fprintf (asm_out_file, "\t%s DW_LNE_end_sequence",
6007 fputc ('\n', asm_out_file);
6009 fputc ('\n', asm_out_file);
6010 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_end_sequence);
6011 fputc ('\n', asm_out_file);
6016 /* Given a pointer to a BLOCK node return non-zero if (and only if) the node
6017 in question represents the outermost pair of curly braces (i.e. the "body
6018 block") of a function or method.
6020 For any BLOCK node representing a "body block" of a function or method, the
6021 BLOCK_SUPERCONTEXT of the node will point to another BLOCK node which
6022 represents the outermost (function) scope for the function or method (i.e.
6023 the one which includes the formal parameters). The BLOCK_SUPERCONTEXT of
6024 *that* node in turn will point to the relevant FUNCTION_DECL node. */
6027 is_body_block (stmt)
6030 if (TREE_CODE (stmt) == BLOCK)
6032 register tree parent = BLOCK_SUPERCONTEXT (stmt);
6034 if (TREE_CODE (parent) == BLOCK)
6036 register tree grandparent = BLOCK_SUPERCONTEXT (parent);
6038 if (TREE_CODE (grandparent) == FUNCTION_DECL)
6046 /* Given a pointer to a tree node for some base type, return a pointer to
6047 a DIE that describes the given type.
6049 This routine must only be called for GCC type nodes that correspond to
6050 Dwarf base (fundamental) types. */
6053 base_type_die (type)
6056 register dw_die_ref base_type_result;
6057 register char *type_name;
6058 register enum dwarf_type encoding;
6059 register tree name = TYPE_NAME (type);
6061 if (TREE_CODE (type) == ERROR_MARK
6062 || TREE_CODE (type) == VOID_TYPE)
6065 if (TREE_CODE (name) == TYPE_DECL)
6066 name = DECL_NAME (name);
6067 type_name = IDENTIFIER_POINTER (name);
6069 switch (TREE_CODE (type))
6072 /* Carefully distinguish the C character types, without messing
6073 up if the language is not C. Note that we check only for the names
6074 that contain spaces; other names might occur by coincidence in other
6076 if (! (TYPE_PRECISION (type) == CHAR_TYPE_SIZE
6077 && (type == char_type_node
6078 || ! strcmp (type_name, "signed char")
6079 || ! strcmp (type_name, "unsigned char"))))
6081 if (TREE_UNSIGNED (type))
6082 encoding = DW_ATE_unsigned;
6084 encoding = DW_ATE_signed;
6087 /* else fall through */
6090 /* GNU Pascal/Ada CHAR type. Not used in C. */
6091 if (TREE_UNSIGNED (type))
6092 encoding = DW_ATE_unsigned_char;
6094 encoding = DW_ATE_signed_char;
6098 encoding = DW_ATE_float;
6102 encoding = DW_ATE_complex_float;
6106 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */
6107 encoding = DW_ATE_boolean;
6111 abort (); /* No other TREE_CODEs are Dwarf fundamental types. */
6114 base_type_result = new_die (DW_TAG_base_type, comp_unit_die);
6115 add_AT_string (base_type_result, DW_AT_name, type_name);
6116 add_AT_unsigned (base_type_result, DW_AT_byte_size,
6117 TYPE_PRECISION (type) / BITS_PER_UNIT);
6118 add_AT_unsigned (base_type_result, DW_AT_encoding, encoding);
6120 return base_type_result;
6123 /* Given a pointer to an arbitrary ..._TYPE tree node, return a pointer to
6124 the Dwarf "root" type for the given input type. The Dwarf "root" type of
6125 a given type is generally the same as the given type, except that if the
6126 given type is a pointer or reference type, then the root type of the given
6127 type is the root type of the "basis" type for the pointer or reference
6128 type. (This definition of the "root" type is recursive.) Also, the root
6129 type of a `const' qualified type or a `volatile' qualified type is the
6130 root type of the given type without the qualifiers. */
6136 if (TREE_CODE (type) == ERROR_MARK)
6137 return error_mark_node;
6139 switch (TREE_CODE (type))
6142 return error_mark_node;
6145 case REFERENCE_TYPE:
6146 return type_main_variant (root_type (TREE_TYPE (type)));
6149 return type_main_variant (type);
6153 /* Given a pointer to an arbitrary ..._TYPE tree node, return non-zero if the
6154 given input type is a Dwarf "fundamental" type. Otherwise return null. */
6160 switch (TREE_CODE (type))
6175 case QUAL_UNION_TYPE:
6180 case REFERENCE_TYPE:
6193 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
6194 entry that chains various modifiers in front of the given type. */
6197 modified_type_die (type, is_const_type, is_volatile_type, context_die)
6199 register int is_const_type;
6200 register int is_volatile_type;
6201 register dw_die_ref context_die;
6203 register enum tree_code code = TREE_CODE (type);
6204 register dw_die_ref mod_type_die = NULL;
6205 register dw_die_ref sub_die = NULL;
6206 register tree item_type = NULL;
6208 if (code != ERROR_MARK)
6210 type = build_type_variant (type, is_const_type, is_volatile_type);
6212 mod_type_die = lookup_type_die (type);
6214 return mod_type_die;
6216 /* Handle C typedef types. */
6217 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
6218 && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
6220 tree dtype = TREE_TYPE (TYPE_NAME (type));
6223 /* For a named type, use the typedef. */
6224 gen_type_die (type, context_die);
6225 mod_type_die = lookup_type_die (type);
6228 else if (is_const_type < TYPE_READONLY (dtype)
6229 || is_volatile_type < TYPE_VOLATILE (dtype))
6230 /* cv-unqualified version of named type. Just use the unnamed
6231 type to which it refers. */
6233 = modified_type_die (DECL_ORIGINAL_TYPE (TYPE_NAME (type)),
6234 is_const_type, is_volatile_type,
6236 /* Else cv-qualified version of named type; fall through. */
6241 else if (is_const_type)
6243 mod_type_die = new_die (DW_TAG_const_type, comp_unit_die);
6244 sub_die = modified_type_die (type, 0, is_volatile_type, context_die);
6246 else if (is_volatile_type)
6248 mod_type_die = new_die (DW_TAG_volatile_type, comp_unit_die);
6249 sub_die = modified_type_die (type, 0, 0, context_die);
6251 else if (code == POINTER_TYPE)
6253 mod_type_die = new_die (DW_TAG_pointer_type, comp_unit_die);
6254 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
6256 add_AT_unsigned (mod_type_die, DW_AT_address_class, 0);
6258 item_type = TREE_TYPE (type);
6260 else if (code == REFERENCE_TYPE)
6262 mod_type_die = new_die (DW_TAG_reference_type, comp_unit_die);
6263 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
6265 add_AT_unsigned (mod_type_die, DW_AT_address_class, 0);
6267 item_type = TREE_TYPE (type);
6269 else if (is_base_type (type))
6270 mod_type_die = base_type_die (type);
6273 gen_type_die (type, context_die);
6275 /* We have to get the type_main_variant here (and pass that to the
6276 `lookup_type_die' routine) because the ..._TYPE node we have
6277 might simply be a *copy* of some original type node (where the
6278 copy was created to help us keep track of typedef names) and
6279 that copy might have a different TYPE_UID from the original
6281 mod_type_die = lookup_type_die (type_main_variant (type));
6282 if (mod_type_die == NULL)
6287 equate_type_number_to_die (type, mod_type_die);
6289 /* We must do this after the equate_type_number_to_die call, in case
6290 this is a recursive type. This ensures that the modified_type_die
6291 recursion will terminate even if the type is recursive. Recursive
6292 types are possible in Ada. */
6293 sub_die = modified_type_die (item_type,
6294 TYPE_READONLY (item_type),
6295 TYPE_VOLATILE (item_type),
6298 if (sub_die != NULL)
6299 add_AT_die_ref (mod_type_die, DW_AT_type, sub_die);
6301 return mod_type_die;
6304 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
6305 an enumerated type. */
6311 return TREE_CODE (type) == ENUMERAL_TYPE;
6314 /* Return a location descriptor that designates a machine register. */
6316 static dw_loc_descr_ref
6317 reg_loc_descriptor (rtl)
6320 register dw_loc_descr_ref loc_result = NULL;
6321 register unsigned reg = reg_number (rtl);
6323 if (reg >= 0 && reg <= 31)
6324 loc_result = new_loc_descr (DW_OP_reg0 + reg, 0, 0);
6326 loc_result = new_loc_descr (DW_OP_regx, reg, 0);
6331 /* Return a location descriptor that designates a base+offset location. */
6333 static dw_loc_descr_ref
6334 based_loc_descr (reg, offset)
6338 register dw_loc_descr_ref loc_result;
6339 /* For the "frame base", we use the frame pointer or stack pointer
6340 registers, since the RTL for local variables is relative to one of
6342 register unsigned fp_reg = DBX_REGISTER_NUMBER (frame_pointer_needed
6343 ? HARD_FRAME_POINTER_REGNUM
6344 : STACK_POINTER_REGNUM);
6347 loc_result = new_loc_descr (DW_OP_fbreg, offset, 0);
6348 else if (reg >= 0 && reg <= 31)
6349 loc_result = new_loc_descr (DW_OP_breg0 + reg, offset, 0);
6351 loc_result = new_loc_descr (DW_OP_bregx, reg, offset);
6356 /* Return true if this RTL expression describes a base+offset calculation. */
6362 return (GET_CODE (rtl) == PLUS
6363 && ((GET_CODE (XEXP (rtl, 0)) == REG
6364 && GET_CODE (XEXP (rtl, 1)) == CONST_INT)));
6367 /* The following routine converts the RTL for a variable or parameter
6368 (resident in memory) into an equivalent Dwarf representation of a
6369 mechanism for getting the address of that same variable onto the top of a
6370 hypothetical "address evaluation" stack.
6372 When creating memory location descriptors, we are effectively transforming
6373 the RTL for a memory-resident object into its Dwarf postfix expression
6374 equivalent. This routine recursively descends an RTL tree, turning
6375 it into Dwarf postfix code as it goes. */
6377 static dw_loc_descr_ref
6378 mem_loc_descriptor (rtl)
6381 dw_loc_descr_ref mem_loc_result = NULL;
6382 /* Note that for a dynamically sized array, the location we will generate a
6383 description of here will be the lowest numbered location which is
6384 actually within the array. That's *not* necessarily the same as the
6385 zeroth element of the array. */
6387 switch (GET_CODE (rtl))
6390 /* The case of a subreg may arise when we have a local (register)
6391 variable or a formal (register) parameter which doesn't quite fill
6392 up an entire register. For now, just assume that it is
6393 legitimate to make the Dwarf info refer to the whole register which
6394 contains the given subreg. */
6395 rtl = XEXP (rtl, 0);
6397 /* ... fall through ... */
6400 /* Whenever a register number forms a part of the description of the
6401 method for calculating the (dynamic) address of a memory resident
6402 object, DWARF rules require the register number be referred to as
6403 a "base register". This distinction is not based in any way upon
6404 what category of register the hardware believes the given register
6405 belongs to. This is strictly DWARF terminology we're dealing with
6406 here. Note that in cases where the location of a memory-resident
6407 data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
6408 OP_CONST (0)) the actual DWARF location descriptor that we generate
6409 may just be OP_BASEREG (basereg). This may look deceptively like
6410 the object in question was allocated to a register (rather than in
6411 memory) so DWARF consumers need to be aware of the subtle
6412 distinction between OP_REG and OP_BASEREG. */
6413 mem_loc_result = based_loc_descr (reg_number (rtl), 0);
6417 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0));
6418 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_deref, 0, 0));
6423 mem_loc_result = new_loc_descr (DW_OP_addr, 0, 0);
6424 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_addr;
6425 mem_loc_result->dw_loc_oprnd1.v.val_addr = addr_to_string (rtl);
6429 if (is_based_loc (rtl))
6430 mem_loc_result = based_loc_descr (reg_number (XEXP (rtl, 0)),
6431 INTVAL (XEXP (rtl, 1)));
6434 add_loc_descr (&mem_loc_result, mem_loc_descriptor (XEXP (rtl, 0)));
6435 add_loc_descr (&mem_loc_result, mem_loc_descriptor (XEXP (rtl, 1)));
6436 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_plus, 0, 0));
6441 /* If a pseudo-reg is optimized away, it is possible for it to
6442 be replaced with a MEM containing a multiply. */
6443 add_loc_descr (&mem_loc_result, mem_loc_descriptor (XEXP (rtl, 0)));
6444 add_loc_descr (&mem_loc_result, mem_loc_descriptor (XEXP (rtl, 1)));
6445 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_mul, 0, 0));
6449 mem_loc_result = new_loc_descr (DW_OP_constu, INTVAL (rtl), 0);
6456 return mem_loc_result;
6459 /* Return a descriptor that describes the concatenation of two locations.
6460 This is typically a complex variable. */
6462 static dw_loc_descr_ref
6463 concat_loc_descriptor (x0, x1)
6464 register rtx x0, x1;
6466 dw_loc_descr_ref cc_loc_result = NULL;
6468 if (!is_pseudo_reg (x0)
6469 && (GET_CODE (x0) != MEM || !is_pseudo_reg (XEXP (x0, 0))))
6470 add_loc_descr (&cc_loc_result, loc_descriptor (x0));
6471 add_loc_descr (&cc_loc_result,
6472 new_loc_descr (DW_OP_piece, GET_MODE_SIZE (GET_MODE (x0)), 0));
6474 if (!is_pseudo_reg (x1)
6475 && (GET_CODE (x1) != MEM || !is_pseudo_reg (XEXP (x1, 0))))
6476 add_loc_descr (&cc_loc_result, loc_descriptor (x1));
6477 add_loc_descr (&cc_loc_result,
6478 new_loc_descr (DW_OP_piece, GET_MODE_SIZE (GET_MODE (x1)), 0));
6480 return cc_loc_result;
6483 /* Output a proper Dwarf location descriptor for a variable or parameter
6484 which is either allocated in a register or in a memory location. For a
6485 register, we just generate an OP_REG and the register number. For a
6486 memory location we provide a Dwarf postfix expression describing how to
6487 generate the (dynamic) address of the object onto the address stack. */
6489 static dw_loc_descr_ref
6490 loc_descriptor (rtl)
6493 dw_loc_descr_ref loc_result = NULL;
6494 switch (GET_CODE (rtl))
6497 /* The case of a subreg may arise when we have a local (register)
6498 variable or a formal (register) parameter which doesn't quite fill
6499 up an entire register. For now, just assume that it is
6500 legitimate to make the Dwarf info refer to the whole register which
6501 contains the given subreg. */
6502 rtl = XEXP (rtl, 0);
6504 /* ... fall through ... */
6507 loc_result = reg_loc_descriptor (rtl);
6511 loc_result = mem_loc_descriptor (XEXP (rtl, 0));
6515 loc_result = concat_loc_descriptor (XEXP (rtl, 0), XEXP (rtl, 1));
6525 /* Given an unsigned value, round it up to the lowest multiple of `boundary'
6526 which is not less than the value itself. */
6528 static inline unsigned
6529 ceiling (value, boundary)
6530 register unsigned value;
6531 register unsigned boundary;
6533 return (((value + boundary - 1) / boundary) * boundary);
6536 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
6537 pointer to the declared type for the relevant field variable, or return
6538 `integer_type_node' if the given node turns out to be an
6547 if (TREE_CODE (decl) == ERROR_MARK)
6548 return integer_type_node;
6550 type = DECL_BIT_FIELD_TYPE (decl);
6551 if (type == NULL_TREE)
6552 type = TREE_TYPE (decl);
6557 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
6558 node, return the alignment in bits for the type, or else return
6559 BITS_PER_WORD if the node actually turns out to be an
6562 static inline unsigned
6563 simple_type_align_in_bits (type)
6566 return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD;
6569 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
6570 node, return the size in bits for the type if it is a constant, or else
6571 return the alignment for the type if the type's size is not constant, or
6572 else return BITS_PER_WORD if the type actually turns out to be an
6575 static inline unsigned
6576 simple_type_size_in_bits (type)
6579 if (TREE_CODE (type) == ERROR_MARK)
6580 return BITS_PER_WORD;
6583 register tree type_size_tree = TYPE_SIZE (type);
6585 if (TREE_CODE (type_size_tree) != INTEGER_CST)
6586 return TYPE_ALIGN (type);
6588 return (unsigned) TREE_INT_CST_LOW (type_size_tree);
6592 /* Given a pointer to what is assumed to be a FIELD_DECL node, compute and
6593 return the byte offset of the lowest addressed byte of the "containing
6594 object" for the given FIELD_DECL, or return 0 if we are unable to
6595 determine what that offset is, either because the argument turns out to
6596 be a pointer to an ERROR_MARK node, or because the offset is actually
6597 variable. (We can't handle the latter case just yet). */
6600 field_byte_offset (decl)
6603 register unsigned type_align_in_bytes;
6604 register unsigned type_align_in_bits;
6605 register unsigned type_size_in_bits;
6606 register unsigned object_offset_in_align_units;
6607 register unsigned object_offset_in_bits;
6608 register unsigned object_offset_in_bytes;
6610 register tree bitpos_tree;
6611 register tree field_size_tree;
6612 register unsigned bitpos_int;
6613 register unsigned deepest_bitpos;
6614 register unsigned field_size_in_bits;
6616 if (TREE_CODE (decl) == ERROR_MARK)
6619 if (TREE_CODE (decl) != FIELD_DECL)
6622 type = field_type (decl);
6624 bitpos_tree = DECL_FIELD_BITPOS (decl);
6625 field_size_tree = DECL_SIZE (decl);
6627 /* We cannot yet cope with fields whose positions or sizes are variable, so
6628 for now, when we see such things, we simply return 0. Someday, we may
6629 be able to handle such cases, but it will be damn difficult. */
6630 if (TREE_CODE (bitpos_tree) != INTEGER_CST)
6632 bitpos_int = (unsigned) TREE_INT_CST_LOW (bitpos_tree);
6634 if (TREE_CODE (field_size_tree) != INTEGER_CST)
6637 field_size_in_bits = (unsigned) TREE_INT_CST_LOW (field_size_tree);
6638 type_size_in_bits = simple_type_size_in_bits (type);
6639 type_align_in_bits = simple_type_align_in_bits (type);
6640 type_align_in_bytes = type_align_in_bits / BITS_PER_UNIT;
6642 /* Note that the GCC front-end doesn't make any attempt to keep track of
6643 the starting bit offset (relative to the start of the containing
6644 structure type) of the hypothetical "containing object" for a bit-
6645 field. Thus, when computing the byte offset value for the start of the
6646 "containing object" of a bit-field, we must deduce this information on
6647 our own. This can be rather tricky to do in some cases. For example,
6648 handling the following structure type definition when compiling for an
6649 i386/i486 target (which only aligns long long's to 32-bit boundaries)
6652 struct S { int field1; long long field2:31; };
6654 Fortunately, there is a simple rule-of-thumb which can be
6655 used in such cases. When compiling for an i386/i486, GCC will allocate
6656 8 bytes for the structure shown above. It decides to do this based upon
6657 one simple rule for bit-field allocation. Quite simply, GCC allocates
6658 each "containing object" for each bit-field at the first (i.e. lowest
6659 addressed) legitimate alignment boundary (based upon the required
6660 minimum alignment for the declared type of the field) which it can
6661 possibly use, subject to the condition that there is still enough
6662 available space remaining in the containing object (when allocated at
6663 the selected point) to fully accommodate all of the bits of the
6664 bit-field itself. This simple rule makes it obvious why GCC allocates
6665 8 bytes for each object of the structure type shown above. When looking
6666 for a place to allocate the "containing object" for `field2', the
6667 compiler simply tries to allocate a 64-bit "containing object" at each
6668 successive 32-bit boundary (starting at zero) until it finds a place to
6669 allocate that 64- bit field such that at least 31 contiguous (and
6670 previously unallocated) bits remain within that selected 64 bit field.
6671 (As it turns out, for the example above, the compiler finds that it is
6672 OK to allocate the "containing object" 64-bit field at bit-offset zero
6673 within the structure type.) Here we attempt to work backwards from the
6674 limited set of facts we're given, and we try to deduce from those facts,
6675 where GCC must have believed that the containing object started (within
6676 the structure type). The value we deduce is then used (by the callers of
6677 this routine) to generate DW_AT_location and DW_AT_bit_offset attributes
6678 for fields (both bit-fields and, in the case of DW_AT_location, regular
6681 /* Figure out the bit-distance from the start of the structure to the
6682 "deepest" bit of the bit-field. */
6683 deepest_bitpos = bitpos_int + field_size_in_bits;
6685 /* This is the tricky part. Use some fancy footwork to deduce where the
6686 lowest addressed bit of the containing object must be. */
6687 object_offset_in_bits
6688 = ceiling (deepest_bitpos, type_align_in_bits) - type_size_in_bits;
6690 /* Compute the offset of the containing object in "alignment units". */
6691 object_offset_in_align_units = object_offset_in_bits / type_align_in_bits;
6693 /* Compute the offset of the containing object in bytes. */
6694 object_offset_in_bytes = object_offset_in_align_units * type_align_in_bytes;
6696 return object_offset_in_bytes;
6699 /* The following routines define various Dwarf attributes and any data
6700 associated with them. */
6702 /* Add a location description attribute value to a DIE.
6704 This emits location attributes suitable for whole variables and
6705 whole parameters. Note that the location attributes for struct fields are
6706 generated by the routine `data_member_location_attribute' below. */
6709 add_AT_location_description (die, attr_kind, rtl)
6711 enum dwarf_attribute attr_kind;
6714 /* Handle a special case. If we are about to output a location descriptor
6715 for a variable or parameter which has been optimized out of existence,
6716 don't do that. A variable which has been optimized out
6717 of existence will have a DECL_RTL value which denotes a pseudo-reg.
6718 Currently, in some rare cases, variables can have DECL_RTL values which
6719 look like (MEM (REG pseudo-reg#)). These cases are due to bugs
6720 elsewhere in the compiler. We treat such cases as if the variable(s) in
6721 question had been optimized out of existence. */
6723 if (is_pseudo_reg (rtl)
6724 || (GET_CODE (rtl) == MEM
6725 && is_pseudo_reg (XEXP (rtl, 0)))
6726 || (GET_CODE (rtl) == CONCAT
6727 && is_pseudo_reg (XEXP (rtl, 0))
6728 && is_pseudo_reg (XEXP (rtl, 1))))
6731 add_AT_loc (die, attr_kind, loc_descriptor (rtl));
6734 /* Attach the specialized form of location attribute used for data
6735 members of struct and union types. In the special case of a
6736 FIELD_DECL node which represents a bit-field, the "offset" part
6737 of this special location descriptor must indicate the distance
6738 in bytes from the lowest-addressed byte of the containing struct
6739 or union type to the lowest-addressed byte of the "containing
6740 object" for the bit-field. (See the `field_byte_offset' function
6741 above).. For any given bit-field, the "containing object" is a
6742 hypothetical object (of some integral or enum type) within which
6743 the given bit-field lives. The type of this hypothetical
6744 "containing object" is always the same as the declared type of
6745 the individual bit-field itself (for GCC anyway... the DWARF
6746 spec doesn't actually mandate this). Note that it is the size
6747 (in bytes) of the hypothetical "containing object" which will
6748 be given in the DW_AT_byte_size attribute for this bit-field.
6749 (See the `byte_size_attribute' function below.) It is also used
6750 when calculating the value of the DW_AT_bit_offset attribute.
6751 (See the `bit_offset_attribute' function below). */
6754 add_data_member_location_attribute (die, decl)
6755 register dw_die_ref die;
6758 register unsigned long offset;
6759 register dw_loc_descr_ref loc_descr;
6760 register enum dwarf_location_atom op;
6762 if (TREE_CODE (decl) == TREE_VEC)
6763 offset = TREE_INT_CST_LOW (BINFO_OFFSET (decl));
6765 offset = field_byte_offset (decl);
6767 /* The DWARF2 standard says that we should assume that the structure address
6768 is already on the stack, so we can specify a structure field address
6769 by using DW_OP_plus_uconst. */
6771 #ifdef MIPS_DEBUGGING_INFO
6772 /* ??? The SGI dwarf reader does not handle the DW_OP_plus_uconst operator
6773 correctly. It works only if we leave the offset on the stack. */
6776 op = DW_OP_plus_uconst;
6779 loc_descr = new_loc_descr (op, offset, 0);
6780 add_AT_loc (die, DW_AT_data_member_location, loc_descr);
6783 /* Attach an DW_AT_const_value attribute for a variable or a parameter which
6784 does not have a "location" either in memory or in a register. These
6785 things can arise in GNU C when a constant is passed as an actual parameter
6786 to an inlined function. They can also arise in C++ where declared
6787 constants do not necessarily get memory "homes". */
6790 add_const_value_attribute (die, rtl)
6791 register dw_die_ref die;
6794 switch (GET_CODE (rtl))
6797 /* Note that a CONST_INT rtx could represent either an integer or a
6798 floating-point constant. A CONST_INT is used whenever the constant
6799 will fit into a single word. In all such cases, the original mode
6800 of the constant value is wiped out, and the CONST_INT rtx is
6801 assigned VOIDmode. */
6802 add_AT_unsigned (die, DW_AT_const_value, (unsigned) INTVAL (rtl));
6806 /* Note that a CONST_DOUBLE rtx could represent either an integer or a
6807 floating-point constant. A CONST_DOUBLE is used whenever the
6808 constant requires more than one word in order to be adequately
6809 represented. We output CONST_DOUBLEs as blocks. */
6811 register enum machine_mode mode = GET_MODE (rtl);
6813 if (GET_MODE_CLASS (mode) == MODE_FLOAT)
6815 register unsigned length = GET_MODE_SIZE (mode) / sizeof (long);
6819 REAL_VALUE_FROM_CONST_DOUBLE (rv, rtl);
6823 REAL_VALUE_TO_TARGET_SINGLE (rv, array[0]);
6827 REAL_VALUE_TO_TARGET_DOUBLE (rv, array);
6832 REAL_VALUE_TO_TARGET_LONG_DOUBLE (rv, array);
6839 add_AT_float (die, DW_AT_const_value, length, array);
6842 add_AT_long_long (die, DW_AT_const_value,
6843 CONST_DOUBLE_HIGH (rtl), CONST_DOUBLE_LOW (rtl));
6848 add_AT_string (die, DW_AT_const_value, XSTR (rtl, 0));
6854 add_AT_addr (die, DW_AT_const_value, addr_to_string (rtl));
6858 /* In cases where an inlined instance of an inline function is passed
6859 the address of an `auto' variable (which is local to the caller) we
6860 can get a situation where the DECL_RTL of the artificial local
6861 variable (for the inlining) which acts as a stand-in for the
6862 corresponding formal parameter (of the inline function) will look
6863 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not
6864 exactly a compile-time constant expression, but it isn't the address
6865 of the (artificial) local variable either. Rather, it represents the
6866 *value* which the artificial local variable always has during its
6867 lifetime. We currently have no way to represent such quasi-constant
6868 values in Dwarf, so for now we just punt and generate nothing. */
6872 /* No other kinds of rtx should be possible here. */
6878 /* Generate *either* an DW_AT_location attribute or else an DW_AT_const_value
6879 data attribute for a variable or a parameter. We generate the
6880 DW_AT_const_value attribute only in those cases where the given variable
6881 or parameter does not have a true "location" either in memory or in a
6882 register. This can happen (for example) when a constant is passed as an
6883 actual argument in a call to an inline function. (It's possible that
6884 these things can crop up in other ways also.) Note that one type of
6885 constant value which can be passed into an inlined function is a constant
6886 pointer. This can happen for example if an actual argument in an inlined
6887 function call evaluates to a compile-time constant address. */
6890 add_location_or_const_value_attribute (die, decl)
6891 register dw_die_ref die;
6895 register tree declared_type;
6896 register tree passed_type;
6898 if (TREE_CODE (decl) == ERROR_MARK)
6901 if (TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != PARM_DECL)
6904 /* Here we have to decide where we are going to say the parameter "lives"
6905 (as far as the debugger is concerned). We only have a couple of
6906 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
6908 DECL_RTL normally indicates where the parameter lives during most of the
6909 activation of the function. If optimization is enabled however, this
6910 could be either NULL or else a pseudo-reg. Both of those cases indicate
6911 that the parameter doesn't really live anywhere (as far as the code
6912 generation parts of GCC are concerned) during most of the function's
6913 activation. That will happen (for example) if the parameter is never
6914 referenced within the function.
6916 We could just generate a location descriptor here for all non-NULL
6917 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
6918 a little nicer than that if we also consider DECL_INCOMING_RTL in cases
6919 where DECL_RTL is NULL or is a pseudo-reg.
6921 Note however that we can only get away with using DECL_INCOMING_RTL as
6922 a backup substitute for DECL_RTL in certain limited cases. In cases
6923 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
6924 we can be sure that the parameter was passed using the same type as it is
6925 declared to have within the function, and that its DECL_INCOMING_RTL
6926 points us to a place where a value of that type is passed.
6928 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
6929 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
6930 because in these cases DECL_INCOMING_RTL points us to a value of some
6931 type which is *different* from the type of the parameter itself. Thus,
6932 if we tried to use DECL_INCOMING_RTL to generate a location attribute in
6933 such cases, the debugger would end up (for example) trying to fetch a
6934 `float' from a place which actually contains the first part of a
6935 `double'. That would lead to really incorrect and confusing
6936 output at debug-time.
6938 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
6939 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There
6940 are a couple of exceptions however. On little-endian machines we can
6941 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
6942 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
6943 an integral type that is smaller than TREE_TYPE (decl). These cases arise
6944 when (on a little-endian machine) a non-prototyped function has a
6945 parameter declared to be of type `short' or `char'. In such cases,
6946 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
6947 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
6948 passed `int' value. If the debugger then uses that address to fetch
6949 a `short' or a `char' (on a little-endian machine) the result will be
6950 the correct data, so we allow for such exceptional cases below.
6952 Note that our goal here is to describe the place where the given formal
6953 parameter lives during most of the function's activation (i.e. between
6954 the end of the prologue and the start of the epilogue). We'll do that
6955 as best as we can. Note however that if the given formal parameter is
6956 modified sometime during the execution of the function, then a stack
6957 backtrace (at debug-time) will show the function as having been
6958 called with the *new* value rather than the value which was
6959 originally passed in. This happens rarely enough that it is not
6960 a major problem, but it *is* a problem, and I'd like to fix it.
6962 A future version of dwarf2out.c may generate two additional
6963 attributes for any given DW_TAG_formal_parameter DIE which will
6964 describe the "passed type" and the "passed location" for the
6965 given formal parameter in addition to the attributes we now
6966 generate to indicate the "declared type" and the "active
6967 location" for each parameter. This additional set of attributes
6968 could be used by debuggers for stack backtraces. Separately, note
6969 that sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be
6970 NULL also. This happens (for example) for inlined-instances of
6971 inline function formal parameters which are never referenced.
6972 This really shouldn't be happening. All PARM_DECL nodes should
6973 get valid non-NULL DECL_INCOMING_RTL values, but integrate.c
6974 doesn't currently generate these values for inlined instances of
6975 inline function parameters, so when we see such cases, we are
6976 just out-of-luck for the time being (until integrate.c
6979 /* Use DECL_RTL as the "location" unless we find something better. */
6980 rtl = DECL_RTL (decl);
6982 if (TREE_CODE (decl) == PARM_DECL)
6984 if (rtl == NULL_RTX || is_pseudo_reg (rtl))
6986 declared_type = type_main_variant (TREE_TYPE (decl));
6987 passed_type = type_main_variant (DECL_ARG_TYPE (decl));
6989 /* This decl represents a formal parameter which was optimized out.
6990 Note that DECL_INCOMING_RTL may be NULL in here, but we handle
6991 all* cases where (rtl == NULL_RTX) just below. */
6992 if (declared_type == passed_type)
6993 rtl = DECL_INCOMING_RTL (decl);
6994 else if (! BYTES_BIG_ENDIAN
6995 && TREE_CODE (declared_type) == INTEGER_TYPE
6996 && TYPE_SIZE (declared_type) <= TYPE_SIZE (passed_type))
6997 rtl = DECL_INCOMING_RTL (decl);
7001 if (rtl == NULL_RTX)
7004 rtl = eliminate_regs (rtl, 0, NULL_RTX);
7005 #ifdef LEAF_REG_REMAP
7007 leaf_renumber_regs_insn (rtl);
7010 switch (GET_CODE (rtl))
7013 /* The address of a variable that was optimized away; don't emit
7024 /* DECL_RTL could be (plus (reg ...) (const_int ...)) */
7025 add_const_value_attribute (die, rtl);
7032 add_AT_location_description (die, DW_AT_location, rtl);
7040 /* Generate an DW_AT_name attribute given some string value to be included as
7041 the value of the attribute. */
7044 add_name_attribute (die, name_string)
7045 register dw_die_ref die;
7046 register char *name_string;
7048 if (name_string != NULL && *name_string != 0)
7049 add_AT_string (die, DW_AT_name, name_string);
7052 /* Given a tree node describing an array bound (either lower or upper) output
7053 a representation for that bound. */
7056 add_bound_info (subrange_die, bound_attr, bound)
7057 register dw_die_ref subrange_die;
7058 register enum dwarf_attribute bound_attr;
7059 register tree bound;
7061 register unsigned bound_value = 0;
7063 /* If this is an Ada unconstrained array type, then don't emit any debug
7064 info because the array bounds are unknown. They are parameterized when
7065 the type is instantiated. */
7066 if (contains_placeholder_p (bound))
7069 switch (TREE_CODE (bound))
7074 /* All fixed-bounds are represented by INTEGER_CST nodes. */
7076 bound_value = TREE_INT_CST_LOW (bound);
7077 if (bound_attr == DW_AT_lower_bound
7078 && ((is_c_family () && bound_value == 0)
7079 || (is_fortran () && bound_value == 1)))
7080 /* use the default */;
7082 add_AT_unsigned (subrange_die, bound_attr, bound_value);
7087 case NON_LVALUE_EXPR:
7088 add_bound_info (subrange_die, bound_attr, TREE_OPERAND (bound, 0));
7092 /* If optimization is turned on, the SAVE_EXPRs that describe how to
7093 access the upper bound values may be bogus. If they refer to a
7094 register, they may only describe how to get at these values at the
7095 points in the generated code right after they have just been
7096 computed. Worse yet, in the typical case, the upper bound values
7097 will not even *be* computed in the optimized code (though the
7098 number of elements will), so these SAVE_EXPRs are entirely
7099 bogus. In order to compensate for this fact, we check here to see
7100 if optimization is enabled, and if so, we don't add an attribute
7101 for the (unknown and unknowable) upper bound. This should not
7102 cause too much trouble for existing (stupid?) debuggers because
7103 they have to deal with empty upper bounds location descriptions
7104 anyway in order to be able to deal with incomplete array types.
7105 Of course an intelligent debugger (GDB?) should be able to
7106 comprehend that a missing upper bound specification in a array
7107 type used for a storage class `auto' local array variable
7108 indicates that the upper bound is both unknown (at compile- time)
7109 and unknowable (at run-time) due to optimization.
7111 We assume that a MEM rtx is safe because gcc wouldn't put the
7112 value there unless it was going to be used repeatedly in the
7113 function, i.e. for cleanups. */
7114 if (! optimize || GET_CODE (SAVE_EXPR_RTL (bound)) == MEM)
7116 register dw_die_ref ctx = lookup_decl_die (current_function_decl);
7117 register dw_die_ref decl_die = new_die (DW_TAG_variable, ctx);
7118 add_AT_flag (decl_die, DW_AT_artificial, 1);
7119 add_type_attribute (decl_die, TREE_TYPE (bound), 1, 0, ctx);
7120 add_AT_location_description (decl_die, DW_AT_location,
7121 SAVE_EXPR_RTL (bound));
7122 add_AT_die_ref (subrange_die, bound_attr, decl_die);
7125 /* Else leave out the attribute. */
7130 /* ??? These types of bounds can be created by the Ada front end,
7131 and it isn't clear how to emit debug info for them. */
7139 /* Note that the block of subscript information for an array type also
7140 includes information about the element type of type given array type. */
7143 add_subscript_info (type_die, type)
7144 register dw_die_ref type_die;
7147 register unsigned dimension_number;
7148 register tree lower, upper;
7149 register dw_die_ref subrange_die;
7151 /* The GNU compilers represent multidimensional array types as sequences of
7152 one dimensional array types whose element types are themselves array
7153 types. Here we squish that down, so that each multidimensional array
7154 type gets only one array_type DIE in the Dwarf debugging info. The draft
7155 Dwarf specification say that we are allowed to do this kind of
7156 compression in C (because there is no difference between an array or
7157 arrays and a multidimensional array in C) but for other source languages
7158 (e.g. Ada) we probably shouldn't do this. */
7160 /* ??? The SGI dwarf reader fails for multidimensional arrays with a
7161 const enum type. E.g. const enum machine_mode insn_operand_mode[2][10].
7162 We work around this by disabling this feature. See also
7163 gen_array_type_die. */
7164 #ifndef MIPS_DEBUGGING_INFO
7165 for (dimension_number = 0;
7166 TREE_CODE (type) == ARRAY_TYPE;
7167 type = TREE_TYPE (type), dimension_number++)
7170 register tree domain = TYPE_DOMAIN (type);
7172 /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
7173 and (in GNU C only) variable bounds. Handle all three forms
7175 subrange_die = new_die (DW_TAG_subrange_type, type_die);
7178 /* We have an array type with specified bounds. */
7179 lower = TYPE_MIN_VALUE (domain);
7180 upper = TYPE_MAX_VALUE (domain);
7182 /* define the index type. */
7183 if (TREE_TYPE (domain))
7185 /* ??? This is probably an Ada unnamed subrange type. Ignore the
7186 TREE_TYPE field. We can't emit debug info for this
7187 because it is an unnamed integral type. */
7188 if (TREE_CODE (domain) == INTEGER_TYPE
7189 && TYPE_NAME (domain) == NULL_TREE
7190 && TREE_CODE (TREE_TYPE (domain)) == INTEGER_TYPE
7191 && TYPE_NAME (TREE_TYPE (domain)) == NULL_TREE)
7194 add_type_attribute (subrange_die, TREE_TYPE (domain), 0, 0,
7198 /* ??? If upper is NULL, the array has unspecified length,
7199 but it does have a lower bound. This happens with Fortran
7201 Since the debugger is definitely going to need to know N
7202 to produce useful results, go ahead and output the lower
7203 bound solo, and hope the debugger can cope. */
7205 add_bound_info (subrange_die, DW_AT_lower_bound, lower);
7207 add_bound_info (subrange_die, DW_AT_upper_bound, upper);
7210 /* We have an array type with an unspecified length. The DWARF-2
7211 spec does not say how to handle this; let's just leave out the
7215 #ifndef MIPS_DEBUGGING_INFO
7221 add_byte_size_attribute (die, tree_node)
7223 register tree tree_node;
7225 register unsigned size;
7227 switch (TREE_CODE (tree_node))
7235 case QUAL_UNION_TYPE:
7236 size = int_size_in_bytes (tree_node);
7239 /* For a data member of a struct or union, the DW_AT_byte_size is
7240 generally given as the number of bytes normally allocated for an
7241 object of the *declared* type of the member itself. This is true
7242 even for bit-fields. */
7243 size = simple_type_size_in_bits (field_type (tree_node)) / BITS_PER_UNIT;
7249 /* Note that `size' might be -1 when we get to this point. If it is, that
7250 indicates that the byte size of the entity in question is variable. We
7251 have no good way of expressing this fact in Dwarf at the present time,
7252 so just let the -1 pass on through. */
7254 add_AT_unsigned (die, DW_AT_byte_size, size);
7257 /* For a FIELD_DECL node which represents a bit-field, output an attribute
7258 which specifies the distance in bits from the highest order bit of the
7259 "containing object" for the bit-field to the highest order bit of the
7262 For any given bit-field, the "containing object" is a hypothetical
7263 object (of some integral or enum type) within which the given bit-field
7264 lives. The type of this hypothetical "containing object" is always the
7265 same as the declared type of the individual bit-field itself. The
7266 determination of the exact location of the "containing object" for a
7267 bit-field is rather complicated. It's handled by the
7268 `field_byte_offset' function (above).
7270 Note that it is the size (in bytes) of the hypothetical "containing object"
7271 which will be given in the DW_AT_byte_size attribute for this bit-field.
7272 (See `byte_size_attribute' above). */
7275 add_bit_offset_attribute (die, decl)
7276 register dw_die_ref die;
7279 register unsigned object_offset_in_bytes = field_byte_offset (decl);
7280 register tree type = DECL_BIT_FIELD_TYPE (decl);
7281 register tree bitpos_tree = DECL_FIELD_BITPOS (decl);
7282 register unsigned bitpos_int;
7283 register unsigned highest_order_object_bit_offset;
7284 register unsigned highest_order_field_bit_offset;
7285 register unsigned bit_offset;
7287 /* Must be a field and a bit field. */
7289 || TREE_CODE (decl) != FIELD_DECL)
7292 /* We can't yet handle bit-fields whose offsets are variable, so if we
7293 encounter such things, just return without generating any attribute
7295 if (TREE_CODE (bitpos_tree) != INTEGER_CST)
7298 bitpos_int = (unsigned) TREE_INT_CST_LOW (bitpos_tree);
7300 /* Note that the bit offset is always the distance (in bits) from the
7301 highest-order bit of the "containing object" to the highest-order bit of
7302 the bit-field itself. Since the "high-order end" of any object or field
7303 is different on big-endian and little-endian machines, the computation
7304 below must take account of these differences. */
7305 highest_order_object_bit_offset = object_offset_in_bytes * BITS_PER_UNIT;
7306 highest_order_field_bit_offset = bitpos_int;
7308 if (! BYTES_BIG_ENDIAN)
7310 highest_order_field_bit_offset
7311 += (unsigned) TREE_INT_CST_LOW (DECL_SIZE (decl));
7313 highest_order_object_bit_offset += simple_type_size_in_bits (type);
7317 = (! BYTES_BIG_ENDIAN
7318 ? highest_order_object_bit_offset - highest_order_field_bit_offset
7319 : highest_order_field_bit_offset - highest_order_object_bit_offset);
7321 add_AT_unsigned (die, DW_AT_bit_offset, bit_offset);
7324 /* For a FIELD_DECL node which represents a bit field, output an attribute
7325 which specifies the length in bits of the given field. */
7328 add_bit_size_attribute (die, decl)
7329 register dw_die_ref die;
7332 /* Must be a field and a bit field. */
7333 if (TREE_CODE (decl) != FIELD_DECL
7334 || ! DECL_BIT_FIELD_TYPE (decl))
7336 add_AT_unsigned (die, DW_AT_bit_size,
7337 (unsigned) TREE_INT_CST_LOW (DECL_SIZE (decl)));
7340 /* If the compiled language is ANSI C, then add a 'prototyped'
7341 attribute, if arg types are given for the parameters of a function. */
7344 add_prototyped_attribute (die, func_type)
7345 register dw_die_ref die;
7346 register tree func_type;
7348 if (get_AT_unsigned (comp_unit_die, DW_AT_language) == DW_LANG_C89
7349 && TYPE_ARG_TYPES (func_type) != NULL)
7350 add_AT_flag (die, DW_AT_prototyped, 1);
7354 /* Add an 'abstract_origin' attribute below a given DIE. The DIE is found
7355 by looking in either the type declaration or object declaration
7359 add_abstract_origin_attribute (die, origin)
7360 register dw_die_ref die;
7361 register tree origin;
7363 dw_die_ref origin_die = NULL;
7364 if (TREE_CODE_CLASS (TREE_CODE (origin)) == 'd')
7365 origin_die = lookup_decl_die (origin);
7366 else if (TREE_CODE_CLASS (TREE_CODE (origin)) == 't')
7367 origin_die = lookup_type_die (origin);
7369 add_AT_die_ref (die, DW_AT_abstract_origin, origin_die);
7372 /* We do not currently support the pure_virtual attribute. */
7375 add_pure_or_virtual_attribute (die, func_decl)
7376 register dw_die_ref die;
7377 register tree func_decl;
7379 if (DECL_VINDEX (func_decl))
7381 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
7382 add_AT_loc (die, DW_AT_vtable_elem_location,
7383 new_loc_descr (DW_OP_constu,
7384 TREE_INT_CST_LOW (DECL_VINDEX (func_decl)),
7387 /* GNU extension: Record what type this method came from originally. */
7388 if (debug_info_level > DINFO_LEVEL_TERSE)
7389 add_AT_die_ref (die, DW_AT_containing_type,
7390 lookup_type_die (DECL_CONTEXT (func_decl)));
7394 /* Add source coordinate attributes for the given decl. */
7397 add_src_coords_attributes (die, decl)
7398 register dw_die_ref die;
7401 register unsigned file_index = lookup_filename (DECL_SOURCE_FILE (decl));
7403 add_AT_unsigned (die, DW_AT_decl_file, file_index);
7404 add_AT_unsigned (die, DW_AT_decl_line, DECL_SOURCE_LINE (decl));
7407 /* Add an DW_AT_name attribute and source coordinate attribute for the
7408 given decl, but only if it actually has a name. */
7411 add_name_and_src_coords_attributes (die, decl)
7412 register dw_die_ref die;
7415 register tree decl_name;
7417 decl_name = DECL_NAME (decl);
7418 if (decl_name != NULL && IDENTIFIER_POINTER (decl_name) != NULL)
7420 add_name_attribute (die, dwarf2_name (decl, 0));
7421 add_src_coords_attributes (die, decl);
7422 if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
7423 && DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
7424 add_AT_string (die, DW_AT_MIPS_linkage_name,
7425 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
7429 /* Push a new declaration scope. */
7432 push_decl_scope (scope)
7435 /* Make room in the decl_scope_table, if necessary. */
7436 if (decl_scope_table_allocated == decl_scope_depth)
7438 decl_scope_table_allocated += DECL_SCOPE_TABLE_INCREMENT;
7440 = (tree *) xrealloc (decl_scope_table,
7441 decl_scope_table_allocated * sizeof (tree));
7444 decl_scope_table[decl_scope_depth++] = scope;
7447 /* Return the DIE for the scope the immediately contains this declaration. */
7450 scope_die_for (t, context_die)
7452 register dw_die_ref context_die;
7454 register dw_die_ref scope_die = NULL;
7455 register tree containing_scope;
7456 register unsigned long i;
7458 /* Walk back up the declaration tree looking for a place to define
7460 if (TREE_CODE_CLASS (TREE_CODE (t)) == 't')
7461 containing_scope = TYPE_CONTEXT (t);
7462 else if (TREE_CODE (t) == FUNCTION_DECL && DECL_VINDEX (t))
7463 containing_scope = decl_class_context (t);
7465 containing_scope = DECL_CONTEXT (t);
7467 /* Function-local tags and functions get stuck in limbo until they are
7468 fixed up by decls_for_scope. */
7469 if (context_die == NULL && containing_scope != NULL_TREE
7470 && (TREE_CODE (t) == FUNCTION_DECL || is_tagged_type (t)))
7473 if (containing_scope == NULL_TREE)
7474 scope_die = comp_unit_die;
7477 for (i = decl_scope_depth, scope_die = context_die;
7478 i > 0 && decl_scope_table[i - 1] != containing_scope;
7479 scope_die = scope_die->die_parent, --i)
7484 if (scope_die != comp_unit_die
7485 || TREE_CODE_CLASS (TREE_CODE (containing_scope)) != 't')
7487 if (debug_info_level > DINFO_LEVEL_TERSE
7488 && !TREE_ASM_WRITTEN (containing_scope))
7496 /* Pop a declaration scope. */
7500 if (decl_scope_depth <= 0)
7505 /* Many forms of DIEs require a "type description" attribute. This
7506 routine locates the proper "type descriptor" die for the type given
7507 by 'type', and adds an DW_AT_type attribute below the given die. */
7510 add_type_attribute (object_die, type, decl_const, decl_volatile, context_die)
7511 register dw_die_ref object_die;
7513 register int decl_const;
7514 register int decl_volatile;
7515 register dw_die_ref context_die;
7517 register enum tree_code code = TREE_CODE (type);
7518 register dw_die_ref type_die = NULL;
7520 /* ??? If this type is an unnamed subrange type of an integral or
7521 floating-point type, use the inner type. This is because we have no
7522 support for unnamed types in base_type_die. This can happen if this is
7523 an Ada subrange type. Correct solution is emit a subrange type die. */
7524 if ((code == INTEGER_TYPE || code == REAL_TYPE)
7525 && TREE_TYPE (type) != 0 && TYPE_NAME (type) == 0)
7526 type = TREE_TYPE (type), code = TREE_CODE (type);
7528 if (code == ERROR_MARK)
7531 /* Handle a special case. For functions whose return type is void, we
7532 generate *no* type attribute. (Note that no object may have type
7533 `void', so this only applies to function return types). */
7534 if (code == VOID_TYPE)
7537 type_die = modified_type_die (type,
7538 decl_const || TYPE_READONLY (type),
7539 decl_volatile || TYPE_VOLATILE (type),
7541 if (type_die != NULL)
7542 add_AT_die_ref (object_die, DW_AT_type, type_die);
7545 /* Given a tree pointer to a struct, class, union, or enum type node, return
7546 a pointer to the (string) tag name for the given type, or zero if the type
7547 was declared without a tag. */
7553 register char *name = 0;
7555 if (TYPE_NAME (type) != 0)
7557 register tree t = 0;
7559 /* Find the IDENTIFIER_NODE for the type name. */
7560 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
7561 t = TYPE_NAME (type);
7563 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
7564 a TYPE_DECL node, regardless of whether or not a `typedef' was
7566 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
7567 && ! DECL_IGNORED_P (TYPE_NAME (type)))
7568 t = DECL_NAME (TYPE_NAME (type));
7570 /* Now get the name as a string, or invent one. */
7572 name = IDENTIFIER_POINTER (t);
7575 return (name == 0 || *name == '\0') ? 0 : name;
7578 /* Return the type associated with a data member, make a special check
7579 for bit field types. */
7582 member_declared_type (member)
7583 register tree member;
7585 return (DECL_BIT_FIELD_TYPE (member)
7586 ? DECL_BIT_FIELD_TYPE (member)
7587 : TREE_TYPE (member));
7590 /* Get the decl's label, as described by its RTL. This may be different
7591 from the DECL_NAME name used in the source file. */
7594 decl_start_label (decl)
7599 x = DECL_RTL (decl);
7600 if (GET_CODE (x) != MEM)
7604 if (GET_CODE (x) != SYMBOL_REF)
7607 fnname = XSTR (x, 0);
7611 /* These routines generate the internal representation of the DIE's for
7612 the compilation unit. Debugging information is collected by walking
7613 the declaration trees passed in from dwarf2out_decl(). */
7616 gen_array_type_die (type, context_die)
7618 register dw_die_ref context_die;
7620 register dw_die_ref scope_die = scope_die_for (type, context_die);
7621 register dw_die_ref array_die;
7622 register tree element_type;
7624 /* ??? The SGI dwarf reader fails for array of array of enum types unless
7625 the inner array type comes before the outer array type. Thus we must
7626 call gen_type_die before we call new_die. See below also. */
7627 #ifdef MIPS_DEBUGGING_INFO
7628 gen_type_die (TREE_TYPE (type), context_die);
7631 array_die = new_die (DW_TAG_array_type, scope_die);
7634 /* We default the array ordering. SDB will probably do
7635 the right things even if DW_AT_ordering is not present. It's not even
7636 an issue until we start to get into multidimensional arrays anyway. If
7637 SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
7638 then we'll have to put the DW_AT_ordering attribute back in. (But if
7639 and when we find out that we need to put these in, we will only do so
7640 for multidimensional arrays. */
7641 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major);
7644 #ifdef MIPS_DEBUGGING_INFO
7645 /* The SGI compilers handle arrays of unknown bound by setting
7646 AT_declaration and not emitting any subrange DIEs. */
7647 if (! TYPE_DOMAIN (type))
7648 add_AT_unsigned (array_die, DW_AT_declaration, 1);
7651 add_subscript_info (array_die, type);
7653 equate_type_number_to_die (type, array_die);
7655 /* Add representation of the type of the elements of this array type. */
7656 element_type = TREE_TYPE (type);
7658 /* ??? The SGI dwarf reader fails for multidimensional arrays with a
7659 const enum type. E.g. const enum machine_mode insn_operand_mode[2][10].
7660 We work around this by disabling this feature. See also
7661 add_subscript_info. */
7662 #ifndef MIPS_DEBUGGING_INFO
7663 while (TREE_CODE (element_type) == ARRAY_TYPE)
7664 element_type = TREE_TYPE (element_type);
7666 gen_type_die (element_type, context_die);
7669 add_type_attribute (array_die, element_type, 0, 0, context_die);
7673 gen_set_type_die (type, context_die)
7675 register dw_die_ref context_die;
7677 register dw_die_ref type_die
7678 = new_die (DW_TAG_set_type, scope_die_for (type, context_die));
7680 equate_type_number_to_die (type, type_die);
7681 add_type_attribute (type_die, TREE_TYPE (type), 0, 0, context_die);
7685 gen_entry_point_die (decl, context_die)
7687 register dw_die_ref context_die;
7689 register tree origin = decl_ultimate_origin (decl);
7690 register dw_die_ref decl_die = new_die (DW_TAG_entry_point, context_die);
7692 add_abstract_origin_attribute (decl_die, origin);
7695 add_name_and_src_coords_attributes (decl_die, decl);
7696 add_type_attribute (decl_die, TREE_TYPE (TREE_TYPE (decl)),
7700 if (DECL_ABSTRACT (decl))
7701 equate_decl_number_to_die (decl, decl_die);
7703 add_AT_lbl_id (decl_die, DW_AT_low_pc, decl_start_label (decl));
7706 /* Remember a type in the pending_types_list. */
7712 if (pending_types == pending_types_allocated)
7714 pending_types_allocated += PENDING_TYPES_INCREMENT;
7716 = (tree *) xrealloc (pending_types_list,
7717 sizeof (tree) * pending_types_allocated);
7720 pending_types_list[pending_types++] = type;
7723 /* Output any pending types (from the pending_types list) which we can output
7724 now (taking into account the scope that we are working on now).
7726 For each type output, remove the given type from the pending_types_list
7727 *before* we try to output it. */
7730 output_pending_types_for_scope (context_die)
7731 register dw_die_ref context_die;
7735 while (pending_types)
7738 type = pending_types_list[pending_types];
7739 gen_type_die (type, context_die);
7740 if (!TREE_ASM_WRITTEN (type))
7745 /* Generate a DIE to represent an inlined instance of an enumeration type. */
7748 gen_inlined_enumeration_type_die (type, context_die)
7750 register dw_die_ref context_die;
7752 register dw_die_ref type_die = new_die (DW_TAG_enumeration_type,
7753 scope_die_for (type, context_die));
7755 if (!TREE_ASM_WRITTEN (type))
7757 add_abstract_origin_attribute (type_die, type);
7760 /* Generate a DIE to represent an inlined instance of a structure type. */
7763 gen_inlined_structure_type_die (type, context_die)
7765 register dw_die_ref context_die;
7767 register dw_die_ref type_die = new_die (DW_TAG_structure_type,
7768 scope_die_for (type, context_die));
7770 if (!TREE_ASM_WRITTEN (type))
7772 add_abstract_origin_attribute (type_die, type);
7775 /* Generate a DIE to represent an inlined instance of a union type. */
7778 gen_inlined_union_type_die (type, context_die)
7780 register dw_die_ref context_die;
7782 register dw_die_ref type_die = new_die (DW_TAG_union_type,
7783 scope_die_for (type, context_die));
7785 if (!TREE_ASM_WRITTEN (type))
7787 add_abstract_origin_attribute (type_die, type);
7790 /* Generate a DIE to represent an enumeration type. Note that these DIEs
7791 include all of the information about the enumeration values also. Each
7792 enumerated type name/value is listed as a child of the enumerated type
7796 gen_enumeration_type_die (type, context_die)
7798 register dw_die_ref context_die;
7800 register dw_die_ref type_die = lookup_type_die (type);
7802 if (type_die == NULL)
7804 type_die = new_die (DW_TAG_enumeration_type,
7805 scope_die_for (type, context_die));
7806 equate_type_number_to_die (type, type_die);
7807 add_name_attribute (type_die, type_tag (type));
7809 else if (! TYPE_SIZE (type))
7812 remove_AT (type_die, DW_AT_declaration);
7814 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the
7815 given enum type is incomplete, do not generate the DW_AT_byte_size
7816 attribute or the DW_AT_element_list attribute. */
7817 if (TYPE_SIZE (type))
7821 TREE_ASM_WRITTEN (type) = 1;
7822 add_byte_size_attribute (type_die, type);
7823 if (TYPE_STUB_DECL (type) != NULL_TREE)
7824 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
7826 /* If the first reference to this type was as the return type of an
7827 inline function, then it may not have a parent. Fix this now. */
7828 if (type_die->die_parent == NULL)
7829 add_child_die (scope_die_for (type, context_die), type_die);
7831 for (link = TYPE_FIELDS (type);
7832 link != NULL; link = TREE_CHAIN (link))
7834 register dw_die_ref enum_die = new_die (DW_TAG_enumerator, type_die);
7836 add_name_attribute (enum_die,
7837 IDENTIFIER_POINTER (TREE_PURPOSE (link)));
7838 add_AT_unsigned (enum_die, DW_AT_const_value,
7839 (unsigned) TREE_INT_CST_LOW (TREE_VALUE (link)));
7843 add_AT_flag (type_die, DW_AT_declaration, 1);
7847 /* Generate a DIE to represent either a real live formal parameter decl or to
7848 represent just the type of some formal parameter position in some function
7851 Note that this routine is a bit unusual because its argument may be a
7852 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
7853 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
7854 node. If it's the former then this function is being called to output a
7855 DIE to represent a formal parameter object (or some inlining thereof). If
7856 it's the latter, then this function is only being called to output a
7857 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
7858 argument type of some subprogram type. */
7861 gen_formal_parameter_die (node, context_die)
7863 register dw_die_ref context_die;
7865 register dw_die_ref parm_die
7866 = new_die (DW_TAG_formal_parameter, context_die);
7867 register tree origin;
7869 switch (TREE_CODE_CLASS (TREE_CODE (node)))
7872 origin = decl_ultimate_origin (node);
7874 add_abstract_origin_attribute (parm_die, origin);
7877 add_name_and_src_coords_attributes (parm_die, node);
7878 add_type_attribute (parm_die, TREE_TYPE (node),
7879 TREE_READONLY (node),
7880 TREE_THIS_VOLATILE (node),
7882 if (DECL_ARTIFICIAL (node))
7883 add_AT_flag (parm_die, DW_AT_artificial, 1);
7886 equate_decl_number_to_die (node, parm_die);
7887 if (! DECL_ABSTRACT (node))
7888 add_location_or_const_value_attribute (parm_die, node);
7893 /* We were called with some kind of a ..._TYPE node. */
7894 add_type_attribute (parm_die, node, 0, 0, context_die);
7904 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
7905 at the end of an (ANSI prototyped) formal parameters list. */
7908 gen_unspecified_parameters_die (decl_or_type, context_die)
7909 register tree decl_or_type;
7910 register dw_die_ref context_die;
7912 register dw_die_ref parm_die = new_die (DW_TAG_unspecified_parameters,
7916 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
7917 DW_TAG_unspecified_parameters DIE) to represent the types of the formal
7918 parameters as specified in some function type specification (except for
7919 those which appear as part of a function *definition*).
7921 Note we must be careful here to output all of the parameter DIEs before*
7922 we output any DIEs needed to represent the types of the formal parameters.
7923 This keeps svr4 SDB happy because it (incorrectly) thinks that the first
7924 non-parameter DIE it sees ends the formal parameter list. */
7927 gen_formal_types_die (function_or_method_type, context_die)
7928 register tree function_or_method_type;
7929 register dw_die_ref context_die;
7932 register tree formal_type = NULL;
7933 register tree first_parm_type = TYPE_ARG_TYPES (function_or_method_type);
7936 /* In the case where we are generating a formal types list for a C++
7937 non-static member function type, skip over the first thing on the
7938 TYPE_ARG_TYPES list because it only represents the type of the hidden
7939 `this pointer'. The debugger should be able to figure out (without
7940 being explicitly told) that this non-static member function type takes a
7941 `this pointer' and should be able to figure what the type of that hidden
7942 parameter is from the DW_AT_member attribute of the parent
7943 DW_TAG_subroutine_type DIE. */
7944 if (TREE_CODE (function_or_method_type) == METHOD_TYPE)
7945 first_parm_type = TREE_CHAIN (first_parm_type);
7948 /* Make our first pass over the list of formal parameter types and output a
7949 DW_TAG_formal_parameter DIE for each one. */
7950 for (link = first_parm_type; link; link = TREE_CHAIN (link))
7952 register dw_die_ref parm_die;
7954 formal_type = TREE_VALUE (link);
7955 if (formal_type == void_type_node)
7958 /* Output a (nameless) DIE to represent the formal parameter itself. */
7959 parm_die = gen_formal_parameter_die (formal_type, context_die);
7960 if (TREE_CODE (function_or_method_type) == METHOD_TYPE
7961 && link == first_parm_type)
7962 add_AT_flag (parm_die, DW_AT_artificial, 1);
7965 /* If this function type has an ellipsis, add a
7966 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */
7967 if (formal_type != void_type_node)
7968 gen_unspecified_parameters_die (function_or_method_type, context_die);
7970 /* Make our second (and final) pass over the list of formal parameter types
7971 and output DIEs to represent those types (as necessary). */
7972 for (link = TYPE_ARG_TYPES (function_or_method_type);
7974 link = TREE_CHAIN (link))
7976 formal_type = TREE_VALUE (link);
7977 if (formal_type == void_type_node)
7980 gen_type_die (formal_type, context_die);
7984 /* Generate a DIE to represent a declared function (either file-scope or
7988 gen_subprogram_die (decl, context_die)
7990 register dw_die_ref context_die;
7992 char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
7993 register tree origin = decl_ultimate_origin (decl);
7994 register dw_die_ref subr_die;
7995 register dw_loc_descr_ref fp_loc = NULL;
7996 register rtx fp_reg;
7997 register tree fn_arg_types;
7998 register tree outer_scope;
7999 register dw_die_ref old_die = lookup_decl_die (decl);
8000 register int declaration
8001 = (current_function_decl != decl
8003 && (context_die->die_tag == DW_TAG_structure_type
8004 || context_die->die_tag == DW_TAG_union_type)));
8008 subr_die = new_die (DW_TAG_subprogram, context_die);
8009 add_abstract_origin_attribute (subr_die, origin);
8011 else if (old_die && DECL_ABSTRACT (decl)
8012 && get_AT_unsigned (old_die, DW_AT_inline))
8014 /* This must be a redefinition of an extern inline function.
8015 We can just reuse the old die here. */
8018 /* Clear out the inlined attribute and parm types. */
8019 remove_AT (subr_die, DW_AT_inline);
8020 remove_children (subr_die);
8024 register unsigned file_index
8025 = lookup_filename (DECL_SOURCE_FILE (decl));
8027 if (get_AT_flag (old_die, DW_AT_declaration) != 1)
8030 /* If the definition comes from the same place as the declaration,
8031 maybe use the old DIE. We always want the DIE for this function
8032 that has the *_pc attributes to be under comp_unit_die so the
8033 debugger can find it. For inlines, that is the concrete instance,
8034 so we can use the old DIE here. For non-inline methods, we want a
8035 specification DIE at toplevel, so we need a new DIE. For local
8036 class methods, this does not apply. */
8037 if ((DECL_ABSTRACT (decl) || old_die->die_parent == comp_unit_die
8038 || context_die == NULL)
8039 && get_AT_unsigned (old_die, DW_AT_decl_file) == file_index
8040 && (get_AT_unsigned (old_die, DW_AT_decl_line)
8041 == DECL_SOURCE_LINE (decl)))
8045 /* Clear out the declaration attribute and the parm types. */
8046 remove_AT (subr_die, DW_AT_declaration);
8047 remove_children (subr_die);
8051 subr_die = new_die (DW_TAG_subprogram, context_die);
8052 add_AT_die_ref (subr_die, DW_AT_specification, old_die);
8053 if (get_AT_unsigned (old_die, DW_AT_decl_file) != file_index)
8054 add_AT_unsigned (subr_die, DW_AT_decl_file, file_index);
8055 if (get_AT_unsigned (old_die, DW_AT_decl_line)
8056 != DECL_SOURCE_LINE (decl))
8058 (subr_die, DW_AT_decl_line, DECL_SOURCE_LINE (decl));
8063 register dw_die_ref scope_die;
8065 if (DECL_CONTEXT (decl))
8066 scope_die = scope_die_for (decl, context_die);
8068 /* Don't put block extern declarations under comp_unit_die. */
8069 scope_die = context_die;
8071 subr_die = new_die (DW_TAG_subprogram, scope_die);
8073 if (TREE_PUBLIC (decl))
8074 add_AT_flag (subr_die, DW_AT_external, 1);
8076 add_name_and_src_coords_attributes (subr_die, decl);
8077 if (debug_info_level > DINFO_LEVEL_TERSE)
8079 register tree type = TREE_TYPE (decl);
8081 add_prototyped_attribute (subr_die, type);
8082 add_type_attribute (subr_die, TREE_TYPE (type), 0, 0, context_die);
8085 add_pure_or_virtual_attribute (subr_die, decl);
8086 if (DECL_ARTIFICIAL (decl))
8087 add_AT_flag (subr_die, DW_AT_artificial, 1);
8088 if (TREE_PROTECTED (decl))
8089 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_protected);
8090 else if (TREE_PRIVATE (decl))
8091 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_private);
8096 add_AT_flag (subr_die, DW_AT_declaration, 1);
8098 /* The first time we see a member function, it is in the context of
8099 the class to which it belongs. We make sure of this by emitting
8100 the class first. The next time is the definition, which is
8101 handled above. The two may come from the same source text. */
8102 if (DECL_CONTEXT (decl))
8103 equate_decl_number_to_die (decl, subr_die);
8105 else if (DECL_ABSTRACT (decl))
8107 /* ??? Checking DECL_DEFER_OUTPUT is correct for static inline functions,
8108 but not for extern inline functions. We can't get this completely
8109 correct because information about whether the function was declared
8110 inline is not saved anywhere. */
8111 if (DECL_DEFER_OUTPUT (decl))
8113 if (DECL_INLINE (decl))
8114 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_inlined);
8116 add_AT_unsigned (subr_die, DW_AT_inline,
8117 DW_INL_declared_not_inlined);
8119 else if (DECL_INLINE (decl))
8120 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_inlined);
8124 equate_decl_number_to_die (decl, subr_die);
8126 else if (!DECL_EXTERNAL (decl))
8128 if (origin == NULL_TREE)
8129 equate_decl_number_to_die (decl, subr_die);
8131 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_BEGIN_LABEL,
8132 current_funcdef_number);
8133 add_AT_lbl_id (subr_die, DW_AT_low_pc, label_id);
8134 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
8135 current_funcdef_number);
8136 add_AT_lbl_id (subr_die, DW_AT_high_pc, label_id);
8138 add_pubname (decl, subr_die);
8139 add_arange (decl, subr_die);
8141 #ifdef MIPS_DEBUGGING_INFO
8142 /* Add a reference to the FDE for this routine. */
8143 add_AT_fde_ref (subr_die, DW_AT_MIPS_fde, current_funcdef_fde);
8146 /* Define the "frame base" location for this routine. We use the
8147 frame pointer or stack pointer registers, since the RTL for local
8148 variables is relative to one of them. */
8150 = frame_pointer_needed ? hard_frame_pointer_rtx : stack_pointer_rtx;
8151 add_AT_loc (subr_die, DW_AT_frame_base, reg_loc_descriptor (fp_reg));
8154 /* ??? This fails for nested inline functions, because context_display
8155 is not part of the state saved/restored for inline functions. */
8156 if (current_function_needs_context)
8157 add_AT_location_description (subr_die, DW_AT_static_link,
8158 lookup_static_chain (decl));
8162 /* Now output descriptions of the arguments for this function. This gets
8163 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
8164 for a FUNCTION_DECL doesn't indicate cases where there was a trailing
8165 `...' at the end of the formal parameter list. In order to find out if
8166 there was a trailing ellipsis or not, we must instead look at the type
8167 associated with the FUNCTION_DECL. This will be a node of type
8168 FUNCTION_TYPE. If the chain of type nodes hanging off of this
8169 FUNCTION_TYPE node ends with a void_type_node then there should *not* be
8170 an ellipsis at the end. */
8171 push_decl_scope (decl);
8173 /* In the case where we are describing a mere function declaration, all we
8174 need to do here (and all we *can* do here) is to describe the *types* of
8175 its formal parameters. */
8176 if (debug_info_level <= DINFO_LEVEL_TERSE)
8178 else if (declaration)
8179 gen_formal_types_die (TREE_TYPE (decl), subr_die);
8182 /* Generate DIEs to represent all known formal parameters */
8183 register tree arg_decls = DECL_ARGUMENTS (decl);
8186 /* When generating DIEs, generate the unspecified_parameters DIE
8187 instead if we come across the arg "__builtin_va_alist" */
8188 for (parm = arg_decls; parm; parm = TREE_CHAIN (parm))
8189 if (TREE_CODE (parm) == PARM_DECL)
8191 if (DECL_NAME (parm)
8192 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (parm)),
8193 "__builtin_va_alist"))
8194 gen_unspecified_parameters_die (parm, subr_die);
8196 gen_decl_die (parm, subr_die);
8199 /* Decide whether we need a unspecified_parameters DIE at the end.
8200 There are 2 more cases to do this for: 1) the ansi ... declaration -
8201 this is detectable when the end of the arg list is not a
8202 void_type_node 2) an unprototyped function declaration (not a
8203 definition). This just means that we have no info about the
8204 parameters at all. */
8205 fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
8206 if (fn_arg_types != NULL)
8208 /* this is the prototyped case, check for ... */
8209 if (TREE_VALUE (tree_last (fn_arg_types)) != void_type_node)
8210 gen_unspecified_parameters_die (decl, subr_die);
8212 else if (DECL_INITIAL (decl) == NULL_TREE)
8213 gen_unspecified_parameters_die (decl, subr_die);
8216 /* Output Dwarf info for all of the stuff within the body of the function
8217 (if it has one - it may be just a declaration). */
8218 outer_scope = DECL_INITIAL (decl);
8220 /* Note that here, `outer_scope' is a pointer to the outermost BLOCK
8221 node created to represent a function. This outermost BLOCK actually
8222 represents the outermost binding contour for the function, i.e. the
8223 contour in which the function's formal parameters and labels get
8224 declared. Curiously, it appears that the front end doesn't actually
8225 put the PARM_DECL nodes for the current function onto the BLOCK_VARS
8226 list for this outer scope. (They are strung off of the DECL_ARGUMENTS
8227 list for the function instead.) The BLOCK_VARS list for the
8228 `outer_scope' does provide us with a list of the LABEL_DECL nodes for
8229 the function however, and we output DWARF info for those in
8230 decls_for_scope. Just within the `outer_scope' there will be a BLOCK
8231 node representing the function's outermost pair of curly braces, and
8232 any blocks used for the base and member initializers of a C++
8233 constructor function. */
8234 if (! declaration && TREE_CODE (outer_scope) != ERROR_MARK)
8236 current_function_has_inlines = 0;
8237 decls_for_scope (outer_scope, subr_die, 0);
8239 #if 0 && defined (MIPS_DEBUGGING_INFO)
8240 if (current_function_has_inlines)
8242 add_AT_flag (subr_die, DW_AT_MIPS_has_inlines, 1);
8243 if (! comp_unit_has_inlines)
8245 add_AT_flag (comp_unit_die, DW_AT_MIPS_has_inlines, 1);
8246 comp_unit_has_inlines = 1;
8255 /* Generate a DIE to represent a declared data object. */
8258 gen_variable_die (decl, context_die)
8260 register dw_die_ref context_die;
8262 register tree origin = decl_ultimate_origin (decl);
8263 register dw_die_ref var_die = new_die (DW_TAG_variable, context_die);
8265 dw_die_ref old_die = lookup_decl_die (decl);
8267 = (DECL_EXTERNAL (decl)
8268 || current_function_decl != decl_function_context (decl)
8269 || context_die->die_tag == DW_TAG_structure_type
8270 || context_die->die_tag == DW_TAG_union_type);
8273 add_abstract_origin_attribute (var_die, origin);
8274 /* Loop unrolling can create multiple blocks that refer to the same
8275 static variable, so we must test for the DW_AT_declaration flag. */
8276 /* ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
8277 copy decls and set the DECL_ABSTRACT flag on them instead of
8279 else if (old_die && TREE_STATIC (decl)
8280 && get_AT_flag (old_die, DW_AT_declaration) == 1)
8282 /* ??? This is an instantiation of a C++ class level static. */
8283 add_AT_die_ref (var_die, DW_AT_specification, old_die);
8284 if (DECL_NAME (decl))
8286 register unsigned file_index
8287 = lookup_filename (DECL_SOURCE_FILE (decl));
8289 if (get_AT_unsigned (old_die, DW_AT_decl_file) != file_index)
8290 add_AT_unsigned (var_die, DW_AT_decl_file, file_index);
8292 if (get_AT_unsigned (old_die, DW_AT_decl_line)
8293 != DECL_SOURCE_LINE (decl))
8295 add_AT_unsigned (var_die, DW_AT_decl_line,
8296 DECL_SOURCE_LINE (decl));
8301 add_name_and_src_coords_attributes (var_die, decl);
8302 add_type_attribute (var_die, TREE_TYPE (decl),
8303 TREE_READONLY (decl),
8304 TREE_THIS_VOLATILE (decl), context_die);
8306 if (TREE_PUBLIC (decl))
8307 add_AT_flag (var_die, DW_AT_external, 1);
8309 if (DECL_ARTIFICIAL (decl))
8310 add_AT_flag (var_die, DW_AT_artificial, 1);
8312 if (TREE_PROTECTED (decl))
8313 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_protected);
8315 else if (TREE_PRIVATE (decl))
8316 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_private);
8320 add_AT_flag (var_die, DW_AT_declaration, 1);
8322 if ((declaration && decl_class_context (decl)) || DECL_ABSTRACT (decl))
8323 equate_decl_number_to_die (decl, var_die);
8325 if (! declaration && ! DECL_ABSTRACT (decl))
8327 equate_decl_number_to_die (decl, var_die);
8328 add_location_or_const_value_attribute (var_die, decl);
8329 add_pubname (decl, var_die);
8333 /* Generate a DIE to represent a label identifier. */
8336 gen_label_die (decl, context_die)
8338 register dw_die_ref context_die;
8340 register tree origin = decl_ultimate_origin (decl);
8341 register dw_die_ref lbl_die = new_die (DW_TAG_label, context_die);
8343 char label[MAX_ARTIFICIAL_LABEL_BYTES];
8344 char label2[MAX_ARTIFICIAL_LABEL_BYTES];
8347 add_abstract_origin_attribute (lbl_die, origin);
8349 add_name_and_src_coords_attributes (lbl_die, decl);
8351 if (DECL_ABSTRACT (decl))
8352 equate_decl_number_to_die (decl, lbl_die);
8355 insn = DECL_RTL (decl);
8356 if (GET_CODE (insn) == CODE_LABEL)
8358 /* When optimization is enabled (via -O) some parts of the compiler
8359 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
8360 represent source-level labels which were explicitly declared by
8361 the user. This really shouldn't be happening though, so catch
8362 it if it ever does happen. */
8363 if (INSN_DELETED_P (insn))
8366 sprintf (label2, INSN_LABEL_FMT, current_funcdef_number);
8367 ASM_GENERATE_INTERNAL_LABEL (label, label2,
8368 (unsigned) INSN_UID (insn));
8369 add_AT_lbl_id (lbl_die, DW_AT_low_pc, label);
8374 /* Generate a DIE for a lexical block. */
8377 gen_lexical_block_die (stmt, context_die, depth)
8379 register dw_die_ref context_die;
8382 register dw_die_ref stmt_die = new_die (DW_TAG_lexical_block, context_die);
8383 char label[MAX_ARTIFICIAL_LABEL_BYTES];
8385 if (! BLOCK_ABSTRACT (stmt))
8387 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
8389 add_AT_lbl_id (stmt_die, DW_AT_low_pc, label);
8390 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL, next_block_number);
8391 add_AT_lbl_id (stmt_die, DW_AT_high_pc, label);
8394 push_decl_scope (stmt);
8395 decls_for_scope (stmt, stmt_die, depth);
8399 /* Generate a DIE for an inlined subprogram. */
8402 gen_inlined_subroutine_die (stmt, context_die, depth)
8404 register dw_die_ref context_die;
8407 if (! BLOCK_ABSTRACT (stmt))
8409 register dw_die_ref subr_die
8410 = new_die (DW_TAG_inlined_subroutine, context_die);
8411 register tree decl = block_ultimate_origin (stmt);
8412 char label[MAX_ARTIFICIAL_LABEL_BYTES];
8414 add_abstract_origin_attribute (subr_die, decl);
8415 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
8417 add_AT_lbl_id (subr_die, DW_AT_low_pc, label);
8418 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL, next_block_number);
8419 add_AT_lbl_id (subr_die, DW_AT_high_pc, label);
8420 push_decl_scope (decl);
8421 decls_for_scope (stmt, subr_die, depth);
8423 current_function_has_inlines = 1;
8427 /* Generate a DIE for a field in a record, or structure. */
8430 gen_field_die (decl, context_die)
8432 register dw_die_ref context_die;
8434 register dw_die_ref decl_die = new_die (DW_TAG_member, context_die);
8436 add_name_and_src_coords_attributes (decl_die, decl);
8437 add_type_attribute (decl_die, member_declared_type (decl),
8438 TREE_READONLY (decl), TREE_THIS_VOLATILE (decl),
8441 /* If this is a bit field... */
8442 if (DECL_BIT_FIELD_TYPE (decl))
8444 add_byte_size_attribute (decl_die, decl);
8445 add_bit_size_attribute (decl_die, decl);
8446 add_bit_offset_attribute (decl_die, decl);
8449 if (TREE_CODE (DECL_FIELD_CONTEXT (decl)) != UNION_TYPE)
8450 add_data_member_location_attribute (decl_die, decl);
8452 if (DECL_ARTIFICIAL (decl))
8453 add_AT_flag (decl_die, DW_AT_artificial, 1);
8455 if (TREE_PROTECTED (decl))
8456 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_protected);
8458 else if (TREE_PRIVATE (decl))
8459 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_private);
8463 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
8464 Use modified_type_die instead.
8465 We keep this code here just in case these types of DIEs may be needed to
8466 represent certain things in other languages (e.g. Pascal) someday. */
8468 gen_pointer_type_die (type, context_die)
8470 register dw_die_ref context_die;
8472 register dw_die_ref ptr_die
8473 = new_die (DW_TAG_pointer_type, scope_die_for (type, context_die));
8475 equate_type_number_to_die (type, ptr_die);
8476 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
8477 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
8480 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
8481 Use modified_type_die instead.
8482 We keep this code here just in case these types of DIEs may be needed to
8483 represent certain things in other languages (e.g. Pascal) someday. */
8485 gen_reference_type_die (type, context_die)
8487 register dw_die_ref context_die;
8489 register dw_die_ref ref_die
8490 = new_die (DW_TAG_reference_type, scope_die_for (type, context_die));
8492 equate_type_number_to_die (type, ref_die);
8493 add_type_attribute (ref_die, TREE_TYPE (type), 0, 0, context_die);
8494 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
8498 /* Generate a DIE for a pointer to a member type. */
8500 gen_ptr_to_mbr_type_die (type, context_die)
8502 register dw_die_ref context_die;
8504 register dw_die_ref ptr_die
8505 = new_die (DW_TAG_ptr_to_member_type, scope_die_for (type, context_die));
8507 equate_type_number_to_die (type, ptr_die);
8508 add_AT_die_ref (ptr_die, DW_AT_containing_type,
8509 lookup_type_die (TYPE_OFFSET_BASETYPE (type)));
8510 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
8513 /* Generate the DIE for the compilation unit. */
8516 gen_compile_unit_die (main_input_filename)
8517 register char *main_input_filename;
8520 char *wd = getpwd ();
8522 comp_unit_die = new_die (DW_TAG_compile_unit, NULL);
8523 add_name_attribute (comp_unit_die, main_input_filename);
8526 add_AT_string (comp_unit_die, DW_AT_comp_dir, wd);
8528 sprintf (producer, "%s %s", language_string, version_string);
8530 #ifdef MIPS_DEBUGGING_INFO
8531 /* The MIPS/SGI compilers place the 'cc' command line options in the producer
8532 string. The SGI debugger looks for -g, -g1, -g2, or -g3; if they do
8533 not appear in the producer string, the debugger reaches the conclusion
8534 that the object file is stripped and has no debugging information.
8535 To get the MIPS/SGI debugger to believe that there is debugging
8536 information in the object file, we add a -g to the producer string. */
8537 if (debug_info_level > DINFO_LEVEL_TERSE)
8538 strcat (producer, " -g");
8541 add_AT_string (comp_unit_die, DW_AT_producer, producer);
8543 if (strcmp (language_string, "GNU C++") == 0)
8544 add_AT_unsigned (comp_unit_die, DW_AT_language, DW_LANG_C_plus_plus);
8546 else if (strcmp (language_string, "GNU Ada") == 0)
8547 add_AT_unsigned (comp_unit_die, DW_AT_language, DW_LANG_Ada83);
8549 else if (strcmp (language_string, "GNU F77") == 0)
8550 add_AT_unsigned (comp_unit_die, DW_AT_language, DW_LANG_Fortran77);
8552 else if (strcmp (language_string, "GNU Pascal") == 0)
8553 add_AT_unsigned (comp_unit_die, DW_AT_language, DW_LANG_Pascal83);
8555 else if (flag_traditional)
8556 add_AT_unsigned (comp_unit_die, DW_AT_language, DW_LANG_C);
8559 add_AT_unsigned (comp_unit_die, DW_AT_language, DW_LANG_C89);
8561 #if 0 /* unimplemented */
8562 if (debug_info_level >= DINFO_LEVEL_VERBOSE)
8563 add_AT_unsigned (comp_unit_die, DW_AT_macro_info, 0);
8567 /* Generate a DIE for a string type. */
8570 gen_string_type_die (type, context_die)
8572 register dw_die_ref context_die;
8574 register dw_die_ref type_die
8575 = new_die (DW_TAG_string_type, scope_die_for (type, context_die));
8577 equate_type_number_to_die (type, type_die);
8579 /* Fudge the string length attribute for now. */
8581 /* TODO: add string length info.
8582 string_length_attribute (TYPE_MAX_VALUE (TYPE_DOMAIN (type)));
8583 bound_representation (upper_bound, 0, 'u'); */
8586 /* Generate the DIE for a base class. */
8589 gen_inheritance_die (binfo, context_die)
8590 register tree binfo;
8591 register dw_die_ref context_die;
8593 dw_die_ref die = new_die (DW_TAG_inheritance, context_die);
8595 add_type_attribute (die, BINFO_TYPE (binfo), 0, 0, context_die);
8596 add_data_member_location_attribute (die, binfo);
8598 if (TREE_VIA_VIRTUAL (binfo))
8599 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
8600 if (TREE_VIA_PUBLIC (binfo))
8601 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public);
8602 else if (TREE_VIA_PROTECTED (binfo))
8603 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected);
8606 /* Generate a DIE for a class member. */
8609 gen_member_die (type, context_die)
8611 register dw_die_ref context_die;
8613 register tree member;
8615 /* If this is not an incomplete type, output descriptions of each of its
8616 members. Note that as we output the DIEs necessary to represent the
8617 members of this record or union type, we will also be trying to output
8618 DIEs to represent the *types* of those members. However the `type'
8619 function (above) will specifically avoid generating type DIEs for member
8620 types *within* the list of member DIEs for this (containing) type execpt
8621 for those types (of members) which are explicitly marked as also being
8622 members of this (containing) type themselves. The g++ front- end can
8623 force any given type to be treated as a member of some other
8624 (containing) type by setting the TYPE_CONTEXT of the given (member) type
8625 to point to the TREE node representing the appropriate (containing)
8628 /* First output info about the base classes. */
8629 if (TYPE_BINFO (type) && TYPE_BINFO_BASETYPES (type))
8631 register tree bases = TYPE_BINFO_BASETYPES (type);
8632 register int n_bases = TREE_VEC_LENGTH (bases);
8635 for (i = 0; i < n_bases; i++)
8636 gen_inheritance_die (TREE_VEC_ELT (bases, i), context_die);
8639 /* Now output info about the data members and type members. */
8640 for (member = TYPE_FIELDS (type); member; member = TREE_CHAIN (member))
8641 gen_decl_die (member, context_die);
8643 /* Now output info about the function members (if any). */
8644 for (member = TYPE_METHODS (type); member; member = TREE_CHAIN (member))
8645 gen_decl_die (member, context_die);
8648 /* Generate a DIE for a structure or union type. */
8651 gen_struct_or_union_type_die (type, context_die)
8653 register dw_die_ref context_die;
8655 register dw_die_ref type_die = lookup_type_die (type);
8656 register dw_die_ref scope_die = 0;
8657 register int nested = 0;
8659 if (type_die && ! TYPE_SIZE (type))
8662 if (TYPE_CONTEXT (type) != NULL_TREE
8663 && TREE_CODE_CLASS (TREE_CODE (TYPE_CONTEXT (type))) == 't')
8666 scope_die = scope_die_for (type, context_die);
8668 if (! type_die || (nested && scope_die == comp_unit_die))
8669 /* First occurrence of type or toplevel definition of nested class. */
8671 register dw_die_ref old_die = type_die;
8673 type_die = new_die (TREE_CODE (type) == RECORD_TYPE
8674 ? DW_TAG_structure_type : DW_TAG_union_type,
8676 equate_type_number_to_die (type, type_die);
8677 add_name_attribute (type_die, type_tag (type));
8679 add_AT_die_ref (type_die, DW_AT_specification, old_die);
8682 remove_AT (type_die, DW_AT_declaration);
8684 /* If we're not in the right context to be defining this type, defer to
8685 avoid tricky recursion. */
8686 if (TYPE_SIZE (type) && decl_scope_depth > 0 && scope_die == comp_unit_die)
8688 add_AT_flag (type_die, DW_AT_declaration, 1);
8691 /* If this type has been completed, then give it a byte_size attribute and
8692 then give a list of members. */
8693 else if (TYPE_SIZE (type))
8695 /* Prevent infinite recursion in cases where the type of some member of
8696 this type is expressed in terms of this type itself. */
8697 TREE_ASM_WRITTEN (type) = 1;
8698 add_byte_size_attribute (type_die, type);
8699 if (TYPE_STUB_DECL (type) != NULL_TREE)
8700 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
8702 /* If the first reference to this type was as the return type of an
8703 inline function, then it may not have a parent. Fix this now. */
8704 if (type_die->die_parent == NULL)
8705 add_child_die (scope_die, type_die);
8707 push_decl_scope (type);
8708 gen_member_die (type, type_die);
8711 /* GNU extension: Record what type our vtable lives in. */
8712 if (TYPE_VFIELD (type))
8714 tree vtype = DECL_FCONTEXT (TYPE_VFIELD (type));
8716 gen_type_die (vtype, context_die);
8717 add_AT_die_ref (type_die, DW_AT_containing_type,
8718 lookup_type_die (vtype));
8722 add_AT_flag (type_die, DW_AT_declaration, 1);
8725 /* Generate a DIE for a subroutine _type_. */
8728 gen_subroutine_type_die (type, context_die)
8730 register dw_die_ref context_die;
8732 register tree return_type = TREE_TYPE (type);
8733 register dw_die_ref subr_die
8734 = new_die (DW_TAG_subroutine_type, scope_die_for (type, context_die));
8736 equate_type_number_to_die (type, subr_die);
8737 add_prototyped_attribute (subr_die, type);
8738 add_type_attribute (subr_die, return_type, 0, 0, context_die);
8739 gen_formal_types_die (type, subr_die);
8742 /* Generate a DIE for a type definition */
8745 gen_typedef_die (decl, context_die)
8747 register dw_die_ref context_die;
8749 register dw_die_ref type_die;
8750 register tree origin;
8752 if (TREE_ASM_WRITTEN (decl))
8754 TREE_ASM_WRITTEN (decl) = 1;
8756 type_die = new_die (DW_TAG_typedef, scope_die_for (decl, context_die));
8757 origin = decl_ultimate_origin (decl);
8759 add_abstract_origin_attribute (type_die, origin);
8763 add_name_and_src_coords_attributes (type_die, decl);
8764 if (DECL_ORIGINAL_TYPE (decl))
8766 type = DECL_ORIGINAL_TYPE (decl);
8767 equate_type_number_to_die (TREE_TYPE (decl), type_die);
8770 type = TREE_TYPE (decl);
8771 add_type_attribute (type_die, type, TREE_READONLY (decl),
8772 TREE_THIS_VOLATILE (decl), context_die);
8775 if (DECL_ABSTRACT (decl))
8776 equate_decl_number_to_die (decl, type_die);
8779 /* Generate a type description DIE. */
8782 gen_type_die (type, context_die)
8784 register dw_die_ref context_die;
8786 if (type == NULL_TREE || type == error_mark_node)
8789 /* We are going to output a DIE to represent the unqualified version of of
8790 this type (i.e. without any const or volatile qualifiers) so get the
8791 main variant (i.e. the unqualified version) of this type now. */
8792 type = type_main_variant (type);
8794 if (TREE_ASM_WRITTEN (type))
8797 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
8798 && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
8800 TREE_ASM_WRITTEN (type) = 1;
8801 gen_decl_die (TYPE_NAME (type), context_die);
8805 switch (TREE_CODE (type))
8811 case REFERENCE_TYPE:
8812 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This
8813 ensures that the gen_type_die recursion will terminate even if the
8814 type is recursive. Recursive types are possible in Ada. */
8815 /* ??? We could perhaps do this for all types before the switch
8817 TREE_ASM_WRITTEN (type) = 1;
8819 /* For these types, all that is required is that we output a DIE (or a
8820 set of DIEs) to represent the "basis" type. */
8821 gen_type_die (TREE_TYPE (type), context_die);
8825 /* This code is used for C++ pointer-to-data-member types.
8826 Output a description of the relevant class type. */
8827 gen_type_die (TYPE_OFFSET_BASETYPE (type), context_die);
8829 /* Output a description of the type of the object pointed to. */
8830 gen_type_die (TREE_TYPE (type), context_die);
8832 /* Now output a DIE to represent this pointer-to-data-member type
8834 gen_ptr_to_mbr_type_die (type, context_die);
8838 gen_type_die (TYPE_DOMAIN (type), context_die);
8839 gen_set_type_die (type, context_die);
8843 gen_type_die (TREE_TYPE (type), context_die);
8844 abort (); /* No way to represent these in Dwarf yet! */
8848 /* Force out return type (in case it wasn't forced out already). */
8849 gen_type_die (TREE_TYPE (type), context_die);
8850 gen_subroutine_type_die (type, context_die);
8854 /* Force out return type (in case it wasn't forced out already). */
8855 gen_type_die (TREE_TYPE (type), context_die);
8856 gen_subroutine_type_die (type, context_die);
8860 if (TYPE_STRING_FLAG (type) && TREE_CODE (TREE_TYPE (type)) == CHAR_TYPE)
8862 gen_type_die (TREE_TYPE (type), context_die);
8863 gen_string_type_die (type, context_die);
8866 gen_array_type_die (type, context_die);
8872 case QUAL_UNION_TYPE:
8873 /* If this is a nested type whose containing class hasn't been
8874 written out yet, writing it out will cover this one, too. */
8875 if (TYPE_CONTEXT (type)
8876 && TREE_CODE_CLASS (TREE_CODE (TYPE_CONTEXT (type))) == 't'
8877 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
8879 gen_type_die (TYPE_CONTEXT (type), context_die);
8881 if (TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
8884 /* If that failed, attach ourselves to the stub. */
8885 push_decl_scope (TYPE_CONTEXT (type));
8886 context_die = lookup_type_die (TYPE_CONTEXT (type));
8889 if (TREE_CODE (type) == ENUMERAL_TYPE)
8890 gen_enumeration_type_die (type, context_die);
8892 gen_struct_or_union_type_die (type, context_die);
8894 if (TYPE_CONTEXT (type)
8895 && TREE_CODE_CLASS (TREE_CODE (TYPE_CONTEXT (type))) == 't'
8896 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
8899 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
8900 it up if it is ever completed. gen_*_type_die will set it for us
8901 when appropriate. */
8910 /* No DIEs needed for fundamental types. */
8914 /* No Dwarf representation currently defined. */
8921 TREE_ASM_WRITTEN (type) = 1;
8924 /* Generate a DIE for a tagged type instantiation. */
8927 gen_tagged_type_instantiation_die (type, context_die)
8929 register dw_die_ref context_die;
8931 if (type == NULL_TREE || type == error_mark_node)
8934 /* We are going to output a DIE to represent the unqualified version of of
8935 this type (i.e. without any const or volatile qualifiers) so make sure
8936 that we have the main variant (i.e. the unqualified version) of this
8938 if (type != type_main_variant (type)
8939 || !TREE_ASM_WRITTEN (type))
8942 switch (TREE_CODE (type))
8948 gen_inlined_enumeration_type_die (type, context_die);
8952 gen_inlined_structure_type_die (type, context_die);
8956 case QUAL_UNION_TYPE:
8957 gen_inlined_union_type_die (type, context_die);
8965 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
8966 things which are local to the given block. */
8969 gen_block_die (stmt, context_die, depth)
8971 register dw_die_ref context_die;
8974 register int must_output_die = 0;
8975 register tree origin;
8977 register enum tree_code origin_code;
8979 /* Ignore blocks never really used to make RTL. */
8981 if (stmt == NULL_TREE || !TREE_USED (stmt))
8984 /* Determine the "ultimate origin" of this block. This block may be an
8985 inlined instance of an inlined instance of inline function, so we have
8986 to trace all of the way back through the origin chain to find out what
8987 sort of node actually served as the original seed for the creation of
8988 the current block. */
8989 origin = block_ultimate_origin (stmt);
8990 origin_code = (origin != NULL) ? TREE_CODE (origin) : ERROR_MARK;
8992 /* Determine if we need to output any Dwarf DIEs at all to represent this
8994 if (origin_code == FUNCTION_DECL)
8995 /* The outer scopes for inlinings *must* always be represented. We
8996 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */
8997 must_output_die = 1;
9000 /* In the case where the current block represents an inlining of the
9001 "body block" of an inline function, we must *NOT* output any DIE for
9002 this block because we have already output a DIE to represent the
9003 whole inlined function scope and the "body block" of any function
9004 doesn't really represent a different scope according to ANSI C
9005 rules. So we check here to make sure that this block does not
9006 represent a "body block inlining" before trying to set the
9007 `must_output_die' flag. */
9008 if (! is_body_block (origin ? origin : stmt))
9010 /* Determine if this block directly contains any "significant"
9011 local declarations which we will need to output DIEs for. */
9012 if (debug_info_level > DINFO_LEVEL_TERSE)
9013 /* We are not in terse mode so *any* local declaration counts
9014 as being a "significant" one. */
9015 must_output_die = (BLOCK_VARS (stmt) != NULL);
9017 /* We are in terse mode, so only local (nested) function
9018 definitions count as "significant" local declarations. */
9019 for (decl = BLOCK_VARS (stmt);
9020 decl != NULL; decl = TREE_CHAIN (decl))
9021 if (TREE_CODE (decl) == FUNCTION_DECL
9022 && DECL_INITIAL (decl))
9024 must_output_die = 1;
9030 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
9031 DIE for any block which contains no significant local declarations at
9032 all. Rather, in such cases we just call `decls_for_scope' so that any
9033 needed Dwarf info for any sub-blocks will get properly generated. Note
9034 that in terse mode, our definition of what constitutes a "significant"
9035 local declaration gets restricted to include only inlined function
9036 instances and local (nested) function definitions. */
9037 if (must_output_die)
9039 if (origin_code == FUNCTION_DECL)
9040 gen_inlined_subroutine_die (stmt, context_die, depth);
9042 gen_lexical_block_die (stmt, context_die, depth);
9045 decls_for_scope (stmt, context_die, depth);
9048 /* Generate all of the decls declared within a given scope and (recursively)
9049 all of it's sub-blocks. */
9052 decls_for_scope (stmt, context_die, depth)
9054 register dw_die_ref context_die;
9058 register tree subblocks;
9060 /* Ignore blocks never really used to make RTL. */
9061 if (stmt == NULL_TREE || ! TREE_USED (stmt))
9064 if (!BLOCK_ABSTRACT (stmt) && depth > 0)
9065 next_block_number++;
9067 /* Output the DIEs to represent all of the data objects and typedefs
9068 declared directly within this block but not within any nested
9069 sub-blocks. Also, nested function and tag DIEs have been
9070 generated with a parent of NULL; fix that up now. */
9071 for (decl = BLOCK_VARS (stmt);
9072 decl != NULL; decl = TREE_CHAIN (decl))
9074 register dw_die_ref die;
9076 if (TREE_CODE (decl) == FUNCTION_DECL)
9077 die = lookup_decl_die (decl);
9078 else if (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl))
9079 die = lookup_type_die (TREE_TYPE (decl));
9083 if (die != NULL && die->die_parent == NULL)
9084 add_child_die (context_die, die);
9086 gen_decl_die (decl, context_die);
9089 /* Output the DIEs to represent all sub-blocks (and the items declared
9090 therein) of this block. */
9091 for (subblocks = BLOCK_SUBBLOCKS (stmt);
9093 subblocks = BLOCK_CHAIN (subblocks))
9094 gen_block_die (subblocks, context_die, depth + 1);
9097 /* Is this a typedef we can avoid emitting? */
9100 is_redundant_typedef (decl)
9103 if (TYPE_DECL_IS_STUB (decl))
9106 if (DECL_ARTIFICIAL (decl)
9107 && DECL_CONTEXT (decl)
9108 && is_tagged_type (DECL_CONTEXT (decl))
9109 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl))) == TYPE_DECL
9110 && DECL_NAME (decl) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))))
9111 /* Also ignore the artificial member typedef for the class name. */
9117 /* Generate Dwarf debug information for a decl described by DECL. */
9120 gen_decl_die (decl, context_die)
9122 register dw_die_ref context_die;
9124 register tree origin;
9126 /* Make a note of the decl node we are going to be working on. We may need
9127 to give the user the source coordinates of where it appeared in case we
9128 notice (later on) that something about it looks screwy. */
9129 dwarf_last_decl = decl;
9131 if (TREE_CODE (decl) == ERROR_MARK)
9134 /* If this ..._DECL node is marked to be ignored, then ignore it. But don't
9135 ignore a function definition, since that would screw up our count of
9136 blocks, and that it turn will completely screw up the the labels we will
9137 reference in subsequent DW_AT_low_pc and DW_AT_high_pc attributes (for
9138 subsequent blocks). */
9139 if (DECL_IGNORED_P (decl) && TREE_CODE (decl) != FUNCTION_DECL)
9142 switch (TREE_CODE (decl))
9145 /* The individual enumerators of an enum type get output when we output
9146 the Dwarf representation of the relevant enum type itself. */
9150 /* Don't output any DIEs to represent mere function declarations,
9151 unless they are class members or explicit block externs. */
9152 if (DECL_INITIAL (decl) == NULL_TREE && DECL_CONTEXT (decl) == NULL_TREE
9153 && (current_function_decl == NULL_TREE || ! DECL_ARTIFICIAL (decl)))
9156 if (debug_info_level > DINFO_LEVEL_TERSE)
9158 /* Before we describe the FUNCTION_DECL itself, make sure that we
9159 have described its return type. */
9160 gen_type_die (TREE_TYPE (TREE_TYPE (decl)), context_die);
9162 /* And its containing type. */
9163 origin = decl_class_context (decl);
9164 if (origin != NULL_TREE)
9165 gen_type_die (origin, context_die);
9167 /* And its virtual context. */
9168 if (DECL_VINDEX (decl) != NULL_TREE)
9169 gen_type_die (DECL_CONTEXT (decl), context_die);
9172 /* Now output a DIE to represent the function itself. */
9173 gen_subprogram_die (decl, context_die);
9177 /* If we are in terse mode, don't generate any DIEs to represent any
9179 if (debug_info_level <= DINFO_LEVEL_TERSE)
9182 /* In the special case of a TYPE_DECL node representing the
9183 declaration of some type tag, if the given TYPE_DECL is marked as
9184 having been instantiated from some other (original) TYPE_DECL node
9185 (e.g. one which was generated within the original definition of an
9186 inline function) we have to generate a special (abbreviated)
9187 DW_TAG_structure_type, DW_TAG_union_type, or DW_TAG_enumeration_type
9189 if (TYPE_DECL_IS_STUB (decl) && DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE)
9191 gen_tagged_type_instantiation_die (TREE_TYPE (decl), context_die);
9195 if (is_redundant_typedef (decl))
9196 gen_type_die (TREE_TYPE (decl), context_die);
9198 /* Output a DIE to represent the typedef itself. */
9199 gen_typedef_die (decl, context_die);
9203 if (debug_info_level >= DINFO_LEVEL_NORMAL)
9204 gen_label_die (decl, context_die);
9208 /* If we are in terse mode, don't generate any DIEs to represent any
9209 variable declarations or definitions. */
9210 if (debug_info_level <= DINFO_LEVEL_TERSE)
9213 /* Output any DIEs that are needed to specify the type of this data
9215 gen_type_die (TREE_TYPE (decl), context_die);
9217 /* And its containing type. */
9218 origin = decl_class_context (decl);
9219 if (origin != NULL_TREE)
9220 gen_type_die (origin, context_die);
9222 /* Now output the DIE to represent the data object itself. This gets
9223 complicated because of the possibility that the VAR_DECL really
9224 represents an inlined instance of a formal parameter for an inline
9226 origin = decl_ultimate_origin (decl);
9227 if (origin != NULL_TREE && TREE_CODE (origin) == PARM_DECL)
9228 gen_formal_parameter_die (decl, context_die);
9230 gen_variable_die (decl, context_die);
9234 /* Ignore the nameless fields that are used to skip bits, but
9235 handle C++ anonymous unions. */
9236 if (DECL_NAME (decl) != NULL_TREE
9237 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE)
9239 gen_type_die (member_declared_type (decl), context_die);
9240 gen_field_die (decl, context_die);
9245 gen_type_die (TREE_TYPE (decl), context_die);
9246 gen_formal_parameter_die (decl, context_die);
9254 /* Write the debugging output for DECL. */
9257 dwarf2out_decl (decl)
9260 register dw_die_ref context_die = comp_unit_die;
9262 if (TREE_CODE (decl) == ERROR_MARK)
9265 /* If this ..._DECL node is marked to be ignored, then ignore it. We gotta
9266 hope that the node in question doesn't represent a function definition.
9267 If it does, then totally ignoring it is bound to screw up our count of
9268 blocks, and that it turn will completely screw up the the labels we will
9269 reference in subsequent DW_AT_low_pc and DW_AT_high_pc attributes (for
9270 subsequent blocks). (It's too bad that BLOCK nodes don't carry their
9271 own sequence numbers with them!) */
9272 if (DECL_IGNORED_P (decl))
9274 if (TREE_CODE (decl) == FUNCTION_DECL
9275 && DECL_INITIAL (decl) != NULL)
9281 switch (TREE_CODE (decl))
9284 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration of a
9285 builtin function. Explicit programmer-supplied declarations of
9286 these same functions should NOT be ignored however. */
9287 if (DECL_EXTERNAL (decl) && DECL_FUNCTION_CODE (decl))
9290 /* What we would really like to do here is to filter out all mere
9291 file-scope declarations of file-scope functions which are never
9292 referenced later within this translation unit (and keep all of ones
9293 that *are* referenced later on) but we aren't clairvoyant, so we have
9294 no idea which functions will be referenced in the future (i.e. later
9295 on within the current translation unit). So here we just ignore all
9296 file-scope function declarations which are not also definitions. If
9297 and when the debugger needs to know something about these functions,
9298 it wil have to hunt around and find the DWARF information associated
9299 with the definition of the function. Note that we can't just check
9300 `DECL_EXTERNAL' to find out which FUNCTION_DECL nodes represent
9301 definitions and which ones represent mere declarations. We have to
9302 check `DECL_INITIAL' instead. That's because the C front-end
9303 supports some weird semantics for "extern inline" function
9304 definitions. These can get inlined within the current translation
9305 unit (an thus, we need to generate DWARF info for their abstract
9306 instances so that the DWARF info for the concrete inlined instances
9307 can have something to refer to) but the compiler never generates any
9308 out-of-lines instances of such things (despite the fact that they
9309 *are* definitions). The important point is that the C front-end
9310 marks these "extern inline" functions as DECL_EXTERNAL, but we need
9311 to generate DWARF for them anyway. Note that the C++ front-end also
9312 plays some similar games for inline function definitions appearing
9313 within include files which also contain
9314 `#pragma interface' pragmas. */
9315 if (DECL_INITIAL (decl) == NULL_TREE)
9318 /* If we're a nested function, initially use a parent of NULL; if we're
9319 a plain function, this will be fixed up in decls_for_scope. If
9320 we're a method, it will be ignored, since we already have a DIE. */
9321 if (decl_function_context (decl))
9327 /* Ignore this VAR_DECL if it refers to a file-scope extern data object
9328 declaration and if the declaration was never even referenced from
9329 within this entire compilation unit. We suppress these DIEs in
9330 order to save space in the .debug section (by eliminating entries
9331 which are probably useless). Note that we must not suppress
9332 block-local extern declarations (whether used or not) because that
9333 would screw-up the debugger's name lookup mechanism and cause it to
9334 miss things which really ought to be in scope at a given point. */
9335 if (DECL_EXTERNAL (decl) && !TREE_USED (decl))
9338 /* If we are in terse mode, don't generate any DIEs to represent any
9339 variable declarations or definitions. */
9340 if (debug_info_level <= DINFO_LEVEL_TERSE)
9345 /* Don't bother trying to generate any DIEs to represent any of the
9346 normal built-in types for the language we are compiling. */
9347 if (DECL_SOURCE_LINE (decl) == 0)
9349 /* OK, we need to generate one for `bool' so GDB knows what type
9350 comparisons have. */
9351 if ((get_AT_unsigned (comp_unit_die, DW_AT_language)
9352 == DW_LANG_C_plus_plus)
9353 && TREE_CODE (TREE_TYPE (decl)) == BOOLEAN_TYPE)
9354 modified_type_die (TREE_TYPE (decl), 0, 0, NULL);
9359 /* If we are in terse mode, don't generate any DIEs for types. */
9360 if (debug_info_level <= DINFO_LEVEL_TERSE)
9363 /* If we're a function-scope tag, initially use a parent of NULL;
9364 this will be fixed up in decls_for_scope. */
9365 if (decl_function_context (decl))
9374 gen_decl_die (decl, context_die);
9375 output_pending_types_for_scope (comp_unit_die);
9378 /* Output a marker (i.e. a label) for the beginning of the generated code for
9382 dwarf2out_begin_block (blocknum)
9383 register unsigned blocknum;
9385 function_section (current_function_decl);
9386 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, BLOCK_BEGIN_LABEL, blocknum);
9389 /* Output a marker (i.e. a label) for the end of the generated code for a
9393 dwarf2out_end_block (blocknum)
9394 register unsigned blocknum;
9396 function_section (current_function_decl);
9397 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, BLOCK_END_LABEL, blocknum);
9400 /* Output a marker (i.e. a label) at a point in the assembly code which
9401 corresponds to a given source level label. */
9404 dwarf2out_label (insn)
9407 char label[MAX_ARTIFICIAL_LABEL_BYTES];
9409 if (debug_info_level >= DINFO_LEVEL_NORMAL)
9411 function_section (current_function_decl);
9412 sprintf (label, INSN_LABEL_FMT, current_funcdef_number);
9413 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, label,
9414 (unsigned) INSN_UID (insn));
9418 /* Lookup a filename (in the list of filenames that we know about here in
9419 dwarf2out.c) and return its "index". The index of each (known) filename is
9420 just a unique number which is associated with only that one filename.
9421 We need such numbers for the sake of generating labels
9422 (in the .debug_sfnames section) and references to those
9423 files numbers (in the .debug_srcinfo and.debug_macinfo sections).
9424 If the filename given as an argument is not found in our current list,
9425 add it to the list and assign it the next available unique index number.
9426 In order to speed up searches, we remember the index of the filename
9427 was looked up last. This handles the majority of all searches. */
9430 lookup_filename (file_name)
9433 static unsigned last_file_lookup_index = 0;
9434 register unsigned i;
9436 /* Check to see if the file name that was searched on the previous call
9437 matches this file name. If so, return the index. */
9438 if (last_file_lookup_index != 0)
9439 if (strcmp (file_name, file_table[last_file_lookup_index]) == 0)
9440 return last_file_lookup_index;
9442 /* Didn't match the previous lookup, search the table */
9443 for (i = 1; i < file_table_in_use; ++i)
9444 if (strcmp (file_name, file_table[i]) == 0)
9446 last_file_lookup_index = i;
9450 /* Prepare to add a new table entry by making sure there is enough space in
9451 the table to do so. If not, expand the current table. */
9452 if (file_table_in_use == file_table_allocated)
9454 file_table_allocated += FILE_TABLE_INCREMENT;
9456 = (char **) xrealloc (file_table,
9457 file_table_allocated * sizeof (char *));
9460 /* Add the new entry to the end of the filename table. */
9461 file_table[file_table_in_use] = xstrdup (file_name);
9462 last_file_lookup_index = file_table_in_use++;
9464 return last_file_lookup_index;
9467 /* Output a label to mark the beginning of a source code line entry
9468 and record information relating to this source line, in
9469 'line_info_table' for later output of the .debug_line section. */
9472 dwarf2out_line (filename, line)
9473 register char *filename;
9474 register unsigned line;
9476 if (debug_info_level >= DINFO_LEVEL_NORMAL)
9478 function_section (current_function_decl);
9480 if (DECL_SECTION_NAME (current_function_decl))
9482 register dw_separate_line_info_ref line_info;
9483 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, SEPARATE_LINE_CODE_LABEL,
9484 separate_line_info_table_in_use);
9485 fputc ('\n', asm_out_file);
9487 /* expand the line info table if necessary */
9488 if (separate_line_info_table_in_use
9489 == separate_line_info_table_allocated)
9491 separate_line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
9492 separate_line_info_table
9493 = (dw_separate_line_info_ref)
9494 xrealloc (separate_line_info_table,
9495 separate_line_info_table_allocated
9496 * sizeof (dw_separate_line_info_entry));
9499 /* Add the new entry at the end of the line_info_table. */
9501 = &separate_line_info_table[separate_line_info_table_in_use++];
9502 line_info->dw_file_num = lookup_filename (filename);
9503 line_info->dw_line_num = line;
9504 line_info->function = current_funcdef_number;
9508 register dw_line_info_ref line_info;
9510 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, LINE_CODE_LABEL,
9511 line_info_table_in_use);
9512 fputc ('\n', asm_out_file);
9514 /* Expand the line info table if necessary. */
9515 if (line_info_table_in_use == line_info_table_allocated)
9517 line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
9519 = (dw_line_info_ref)
9520 xrealloc (line_info_table,
9521 (line_info_table_allocated
9522 * sizeof (dw_line_info_entry)));
9525 /* Add the new entry at the end of the line_info_table. */
9526 line_info = &line_info_table[line_info_table_in_use++];
9527 line_info->dw_file_num = lookup_filename (filename);
9528 line_info->dw_line_num = line;
9533 /* Record the beginning of a new source file, for later output
9534 of the .debug_macinfo section. At present, unimplemented. */
9537 dwarf2out_start_source_file (filename)
9538 register char *filename;
9542 /* Record the end of a source file, for later output
9543 of the .debug_macinfo section. At present, unimplemented. */
9546 dwarf2out_end_source_file ()
9550 /* Called from check_newline in c-parse.y. The `buffer' parameter contains
9551 the tail part of the directive line, i.e. the part which is past the
9552 initial whitespace, #, whitespace, directive-name, whitespace part. */
9555 dwarf2out_define (lineno, buffer)
9556 register unsigned lineno;
9557 register char *buffer;
9559 static int initialized = 0;
9562 dwarf2out_start_source_file (primary_filename);
9567 /* Called from check_newline in c-parse.y. The `buffer' parameter contains
9568 the tail part of the directive line, i.e. the part which is past the
9569 initial whitespace, #, whitespace, directive-name, whitespace part. */
9572 dwarf2out_undef (lineno, buffer)
9573 register unsigned lineno;
9574 register char *buffer;
9578 /* Set up for Dwarf output at the start of compilation. */
9581 dwarf2out_init (asm_out_file, main_input_filename)
9582 register FILE *asm_out_file;
9583 register char *main_input_filename;
9585 /* Remember the name of the primary input file. */
9586 primary_filename = main_input_filename;
9588 /* Allocate the initial hunk of the file_table. */
9589 file_table = (char **) xmalloc (FILE_TABLE_INCREMENT * sizeof (char *));
9590 bzero ((char *) file_table, FILE_TABLE_INCREMENT * sizeof (char *));
9591 file_table_allocated = FILE_TABLE_INCREMENT;
9593 /* Skip the first entry - file numbers begin at 1. */
9594 file_table_in_use = 1;
9596 /* Allocate the initial hunk of the decl_die_table. */
9598 = (dw_die_ref *) xmalloc (DECL_DIE_TABLE_INCREMENT * sizeof (dw_die_ref));
9599 bzero ((char *) decl_die_table,
9600 DECL_DIE_TABLE_INCREMENT * sizeof (dw_die_ref));
9601 decl_die_table_allocated = DECL_DIE_TABLE_INCREMENT;
9602 decl_die_table_in_use = 0;
9604 /* Allocate the initial hunk of the decl_scope_table. */
9606 = (tree *) xmalloc (DECL_SCOPE_TABLE_INCREMENT * sizeof (tree));
9607 bzero ((char *) decl_scope_table,
9608 DECL_SCOPE_TABLE_INCREMENT * sizeof (tree));
9609 decl_scope_table_allocated = DECL_SCOPE_TABLE_INCREMENT;
9610 decl_scope_depth = 0;
9612 /* Allocate the initial hunk of the abbrev_die_table. */
9614 = (dw_die_ref *) xmalloc (ABBREV_DIE_TABLE_INCREMENT
9615 * sizeof (dw_die_ref));
9616 bzero ((char *) abbrev_die_table,
9617 ABBREV_DIE_TABLE_INCREMENT * sizeof (dw_die_ref));
9618 abbrev_die_table_allocated = ABBREV_DIE_TABLE_INCREMENT;
9619 /* Zero-th entry is allocated, but unused */
9620 abbrev_die_table_in_use = 1;
9622 /* Allocate the initial hunk of the line_info_table. */
9624 = (dw_line_info_ref) xmalloc (LINE_INFO_TABLE_INCREMENT
9625 * sizeof (dw_line_info_entry));
9626 bzero ((char *) line_info_table,
9627 LINE_INFO_TABLE_INCREMENT * sizeof (dw_line_info_entry));
9628 line_info_table_allocated = LINE_INFO_TABLE_INCREMENT;
9629 /* Zero-th entry is allocated, but unused */
9630 line_info_table_in_use = 1;
9632 /* Generate the initial DIE for the .debug section. Note that the (string)
9633 value given in the DW_AT_name attribute of the DW_TAG_compile_unit DIE
9634 will (typically) be a relative pathname and that this pathname should be
9635 taken as being relative to the directory from which the compiler was
9636 invoked when the given (base) source file was compiled. */
9637 gen_compile_unit_die (main_input_filename);
9639 ASM_GENERATE_INTERNAL_LABEL (text_end_label, TEXT_END_LABEL, 0);
9642 /* Output stuff that dwarf requires at the end of every file,
9643 and generate the DWARF-2 debugging info. */
9648 limbo_die_node *node, *next_node;
9652 /* Traverse the limbo die list, and add parent/child links. The only
9653 dies without parents that should be here are concrete instances of
9654 inline functions, and the comp_unit_die. We can ignore the comp_unit_die.
9655 For concrete instances, we can get the parent die from the abstract
9657 for (node = limbo_die_list; node; node = next_node)
9659 next_node = node->next;
9662 if (die->die_parent == NULL)
9664 a = get_AT (die, DW_AT_abstract_origin);
9666 add_child_die (a->dw_attr_val.v.val_die_ref->die_parent, die);
9667 else if (die == comp_unit_die)
9675 /* Traverse the DIE tree and add sibling attributes to those DIE's
9676 that have children. */
9677 add_sibling_attributes (comp_unit_die);
9679 /* Output a terminator label for the .text section. */
9680 fputc ('\n', asm_out_file);
9681 ASM_OUTPUT_SECTION (asm_out_file, TEXT_SECTION);
9682 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, TEXT_END_LABEL, 0);
9685 /* Output a terminator label for the .data section. */
9686 fputc ('\n', asm_out_file);
9687 ASM_OUTPUT_SECTION (asm_out_file, DATA_SECTION);
9688 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, DATA_END_LABEL, 0);
9690 /* Output a terminator label for the .bss section. */
9691 fputc ('\n', asm_out_file);
9692 ASM_OUTPUT_SECTION (asm_out_file, BSS_SECTION);
9693 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, BSS_END_LABEL, 0);
9696 /* Output the source line correspondence table. */
9697 if (line_info_table_in_use > 1 || separate_line_info_table_in_use)
9699 fputc ('\n', asm_out_file);
9700 ASM_OUTPUT_SECTION (asm_out_file, DEBUG_LINE_SECTION);
9701 output_line_info ();
9703 /* We can only use the low/high_pc attributes if all of the code
9705 if (separate_line_info_table_in_use == 0)
9707 add_AT_lbl_id (comp_unit_die, DW_AT_low_pc, TEXT_SECTION);
9708 add_AT_lbl_id (comp_unit_die, DW_AT_high_pc, text_end_label);
9711 add_AT_section_offset (comp_unit_die, DW_AT_stmt_list, DEBUG_LINE_SECTION);
9714 /* Output the abbreviation table. */
9715 fputc ('\n', asm_out_file);
9716 ASM_OUTPUT_SECTION (asm_out_file, ABBREV_SECTION);
9717 build_abbrev_table (comp_unit_die);
9718 output_abbrev_section ();
9720 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
9721 next_die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE;
9722 calc_die_sizes (comp_unit_die);
9724 /* Output debugging information. */
9725 fputc ('\n', asm_out_file);
9726 ASM_OUTPUT_SECTION (asm_out_file, DEBUG_INFO_SECTION);
9727 output_compilation_unit_header ();
9728 output_die (comp_unit_die);
9730 if (pubname_table_in_use)
9732 /* Output public names table. */
9733 fputc ('\n', asm_out_file);
9734 ASM_OUTPUT_SECTION (asm_out_file, PUBNAMES_SECTION);
9738 if (fde_table_in_use)
9740 /* Output the address range information. */
9741 fputc ('\n', asm_out_file);
9742 ASM_OUTPUT_SECTION (asm_out_file, ARANGES_SECTION);
9746 #endif /* DWARF2_DEBUGGING_INFO */