1 /* Output Dwarf2 format symbol table information from the GNU C compiler.
2 Copyright (C) 1992, 93, 95-99, 2000 Free Software Foundation, Inc.
3 Contributed by Gary Funck (gary@intrepid.com).
4 Derived from DWARF 1 implementation of Ron Guilmette (rfg@monkeys.com).
5 Extensively modified by Jason Merrill (jason@cygnus.com).
7 This file is part of GNU CC.
9 GNU CC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2, or (at your option)
14 GNU CC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GNU CC; see the file COPYING. If not, write to
21 the Free Software Foundation, 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
24 /* TODO: Implement .debug_str handling, and share entries somehow.
25 Eliminate duplicates by putting common info in a separate section
26 to be collected by the linker and referring to it with
28 Emit .debug_line header even when there are no functions, since
29 the file numbers are used by .debug_info. Alternately, leave
30 out locations for types and decls.
31 Avoid talking about ctors and op= for PODs.
32 Factor out common prologue sequences into multiple CIEs. */
34 /* The first part of this file deals with the DWARF 2 frame unwind
35 information, which is also used by the GCC efficient exception handling
36 mechanism. The second part, controlled only by an #ifdef
37 DWARF2_DEBUGGING_INFO, deals with the other DWARF 2 debugging
46 #include "hard-reg-set.h"
48 #include "insn-config.h"
54 #include "dwarf2out.h"
56 #include "dyn-string.h"
60 /* We cannot use <assert.h> in GCC source, since that would include
61 GCC's assert.h, which may not be compatible with the host compiler. */
66 # define assert(e) do { if (! (e)) abort (); } while (0)
69 /* Decide whether we want to emit frame unwind information for the current
75 return (write_symbols == DWARF2_DEBUG
76 #ifdef DWARF2_FRAME_INFO
79 #ifdef DWARF2_UNWIND_INFO
81 || (flag_exceptions && ! exceptions_via_longjmp)
86 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
88 /* How to start an assembler comment. */
89 #ifndef ASM_COMMENT_START
90 #define ASM_COMMENT_START ";#"
93 typedef struct dw_cfi_struct *dw_cfi_ref;
94 typedef struct dw_fde_struct *dw_fde_ref;
95 typedef union dw_cfi_oprnd_struct *dw_cfi_oprnd_ref;
97 /* Call frames are described using a sequence of Call Frame
98 Information instructions. The register number, offset
99 and address fields are provided as possible operands;
100 their use is selected by the opcode field. */
102 typedef union dw_cfi_oprnd_struct
104 unsigned long dw_cfi_reg_num;
105 long int dw_cfi_offset;
110 typedef struct dw_cfi_struct
112 dw_cfi_ref dw_cfi_next;
113 enum dwarf_call_frame_info dw_cfi_opc;
114 dw_cfi_oprnd dw_cfi_oprnd1;
115 dw_cfi_oprnd dw_cfi_oprnd2;
119 /* All call frame descriptions (FDE's) in the GCC generated DWARF
120 refer to a single Common Information Entry (CIE), defined at
121 the beginning of the .debug_frame section. This used of a single
122 CIE obviates the need to keep track of multiple CIE's
123 in the DWARF generation routines below. */
125 typedef struct dw_fde_struct
128 char *dw_fde_current_label;
130 dw_cfi_ref dw_fde_cfi;
134 /* Maximum size (in bytes) of an artificially generated label. */
135 #define MAX_ARTIFICIAL_LABEL_BYTES 30
137 /* Make sure we know the sizes of the various types dwarf can describe. These
138 are only defaults. If the sizes are different for your target, you should
139 override these values by defining the appropriate symbols in your tm.h
142 #ifndef CHAR_TYPE_SIZE
143 #define CHAR_TYPE_SIZE BITS_PER_UNIT
146 #define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
149 /* The size in bytes of a DWARF field indicating an offset or length
150 relative to a debug info section, specified to be 4 bytes in the DWARF-2
151 specification. The SGI/MIPS ABI defines it to be the same as PTR_SIZE. */
153 #ifndef DWARF_OFFSET_SIZE
154 #define DWARF_OFFSET_SIZE 4
157 #define DWARF_VERSION 2
159 /* Round SIZE up to the nearest BOUNDARY. */
160 #define DWARF_ROUND(SIZE,BOUNDARY) \
161 (((SIZE) + (BOUNDARY) - 1) & ~((BOUNDARY) - 1))
163 /* Offsets recorded in opcodes are a multiple of this alignment factor. */
164 #ifdef STACK_GROWS_DOWNWARD
165 #define DWARF_CIE_DATA_ALIGNMENT (-UNITS_PER_WORD)
167 #define DWARF_CIE_DATA_ALIGNMENT UNITS_PER_WORD
170 /* A pointer to the base of a table that contains frame description
171 information for each routine. */
172 static dw_fde_ref fde_table;
174 /* Number of elements currently allocated for fde_table. */
175 static unsigned fde_table_allocated;
177 /* Number of elements in fde_table currently in use. */
178 static unsigned fde_table_in_use;
180 /* Size (in elements) of increments by which we may expand the
182 #define FDE_TABLE_INCREMENT 256
184 /* A list of call frame insns for the CIE. */
185 static dw_cfi_ref cie_cfi_head;
187 /* The number of the current function definition for which debugging
188 information is being generated. These numbers range from 1 up to the
189 maximum number of function definitions contained within the current
190 compilation unit. These numbers are used to create unique label id's
191 unique to each function definition. */
192 static unsigned current_funcdef_number = 0;
194 /* Some DWARF extensions (e.g., MIPS/SGI) implement a subprogram
195 attribute that accelerates the lookup of the FDE associated
196 with the subprogram. This variable holds the table index of the FDE
197 associated with the current function (body) definition. */
198 static unsigned current_funcdef_fde;
200 /* Forward declarations for functions defined in this file. */
202 static char *stripattributes PARAMS ((const char *));
203 static const char *dwarf_cfi_name PARAMS ((unsigned));
204 static dw_cfi_ref new_cfi PARAMS ((void));
205 static void add_cfi PARAMS ((dw_cfi_ref *, dw_cfi_ref));
206 static unsigned long size_of_uleb128 PARAMS ((unsigned long));
207 static unsigned long size_of_sleb128 PARAMS ((long));
208 static void output_uleb128 PARAMS ((unsigned long));
209 static void output_sleb128 PARAMS ((long));
210 static void add_fde_cfi PARAMS ((char *, dw_cfi_ref));
211 static void lookup_cfa_1 PARAMS ((dw_cfi_ref, unsigned long *,
213 static void lookup_cfa PARAMS ((unsigned long *, long *));
214 static void reg_save PARAMS ((char *, unsigned, unsigned,
216 static void initial_return_save PARAMS ((rtx));
217 static void output_cfi PARAMS ((dw_cfi_ref, dw_fde_ref));
218 static void output_call_frame_info PARAMS ((int));
219 static unsigned reg_number PARAMS ((rtx));
220 static void dwarf2out_stack_adjust PARAMS ((rtx));
221 static void dwarf2out_frame_debug_expr PARAMS ((rtx, char *));
223 /* Definitions of defaults for assembler-dependent names of various
224 pseudo-ops and section names.
225 Theses may be overridden in the tm.h file (if necessary) for a particular
228 #ifdef OBJECT_FORMAT_ELF
229 #ifndef UNALIGNED_SHORT_ASM_OP
230 #define UNALIGNED_SHORT_ASM_OP ".2byte"
232 #ifndef UNALIGNED_INT_ASM_OP
233 #define UNALIGNED_INT_ASM_OP ".4byte"
235 #ifndef UNALIGNED_DOUBLE_INT_ASM_OP
236 #define UNALIGNED_DOUBLE_INT_ASM_OP ".8byte"
238 #endif /* OBJECT_FORMAT_ELF */
241 #define ASM_BYTE_OP ".byte"
244 /* Data and reference forms for relocatable data. */
245 #define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
246 #define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
248 /* Pseudo-op for defining a new section. */
249 #ifndef SECTION_ASM_OP
250 #define SECTION_ASM_OP ".section"
253 /* The default format used by the ASM_OUTPUT_SECTION macro (see below) to
254 print the SECTION_ASM_OP and the section name. The default here works for
255 almost all svr4 assemblers, except for the sparc, where the section name
256 must be enclosed in double quotes. (See sparcv4.h). */
257 #ifndef SECTION_FORMAT
258 #ifdef PUSHSECTION_FORMAT
259 #define SECTION_FORMAT PUSHSECTION_FORMAT
261 #define SECTION_FORMAT "\t%s\t%s\n"
265 #ifndef FRAME_SECTION
266 #define FRAME_SECTION ".debug_frame"
269 #ifndef FUNC_BEGIN_LABEL
270 #define FUNC_BEGIN_LABEL "LFB"
272 #ifndef FUNC_END_LABEL
273 #define FUNC_END_LABEL "LFE"
275 #define CIE_AFTER_SIZE_LABEL "LSCIE"
276 #define CIE_END_LABEL "LECIE"
277 #define CIE_LENGTH_LABEL "LLCIE"
278 #define FDE_AFTER_SIZE_LABEL "LSFDE"
279 #define FDE_END_LABEL "LEFDE"
280 #define FDE_LENGTH_LABEL "LLFDE"
282 /* Definitions of defaults for various types of primitive assembly language
283 output operations. These may be overridden from within the tm.h file,
284 but typically, that is unnecessary. */
286 #ifndef ASM_OUTPUT_SECTION
287 #define ASM_OUTPUT_SECTION(FILE, SECTION) \
288 fprintf ((FILE), SECTION_FORMAT, SECTION_ASM_OP, SECTION)
291 #ifndef ASM_OUTPUT_DWARF_DATA1
292 #define ASM_OUTPUT_DWARF_DATA1(FILE,VALUE) \
293 fprintf ((FILE), "\t%s\t0x%x", ASM_BYTE_OP, (unsigned) (VALUE))
296 #ifndef ASM_OUTPUT_DWARF_DELTA1
297 #define ASM_OUTPUT_DWARF_DELTA1(FILE,LABEL1,LABEL2) \
298 do { fprintf ((FILE), "\t%s\t", ASM_BYTE_OP); \
299 assemble_name (FILE, LABEL1); \
300 fprintf (FILE, "-"); \
301 assemble_name (FILE, LABEL2); \
305 #ifdef UNALIGNED_INT_ASM_OP
307 #ifndef UNALIGNED_OFFSET_ASM_OP
308 #define UNALIGNED_OFFSET_ASM_OP \
309 (DWARF_OFFSET_SIZE == 8 ? UNALIGNED_DOUBLE_INT_ASM_OP : UNALIGNED_INT_ASM_OP)
312 #ifndef UNALIGNED_WORD_ASM_OP
313 #define UNALIGNED_WORD_ASM_OP \
314 (PTR_SIZE == 8 ? UNALIGNED_DOUBLE_INT_ASM_OP : UNALIGNED_INT_ASM_OP)
317 #ifndef ASM_OUTPUT_DWARF_DELTA2
318 #define ASM_OUTPUT_DWARF_DELTA2(FILE,LABEL1,LABEL2) \
319 do { fprintf ((FILE), "\t%s\t", UNALIGNED_SHORT_ASM_OP); \
320 assemble_name (FILE, LABEL1); \
321 fprintf (FILE, "-"); \
322 assemble_name (FILE, LABEL2); \
326 #ifndef ASM_OUTPUT_DWARF_DELTA4
327 #define ASM_OUTPUT_DWARF_DELTA4(FILE,LABEL1,LABEL2) \
328 do { fprintf ((FILE), "\t%s\t", UNALIGNED_INT_ASM_OP); \
329 assemble_name (FILE, LABEL1); \
330 fprintf (FILE, "-"); \
331 assemble_name (FILE, LABEL2); \
335 #ifndef ASM_OUTPUT_DWARF_DELTA
336 #define ASM_OUTPUT_DWARF_DELTA(FILE,LABEL1,LABEL2) \
337 do { fprintf ((FILE), "\t%s\t", UNALIGNED_OFFSET_ASM_OP); \
338 assemble_name (FILE, LABEL1); \
339 fprintf (FILE, "-"); \
340 assemble_name (FILE, LABEL2); \
344 #ifndef ASM_OUTPUT_DWARF_ADDR_DELTA
345 #define ASM_OUTPUT_DWARF_ADDR_DELTA(FILE,LABEL1,LABEL2) \
346 do { fprintf ((FILE), "\t%s\t", UNALIGNED_WORD_ASM_OP); \
347 assemble_name (FILE, LABEL1); \
348 fprintf (FILE, "-"); \
349 assemble_name (FILE, LABEL2); \
353 #ifndef ASM_OUTPUT_DWARF_ADDR
354 #define ASM_OUTPUT_DWARF_ADDR(FILE,LABEL) \
355 do { fprintf ((FILE), "\t%s\t", UNALIGNED_WORD_ASM_OP); \
356 assemble_name (FILE, LABEL); \
360 /* ??? This macro takes an RTX in dwarfout.c and a string in dwarf2out.c.
361 We resolve the conflict by creating a new macro ASM_OUTPUT_DWARF2_ADDR_CONST
362 for ports that want to support both DWARF1 and DWARF2. This needs a better
363 solution. See also the comments in sparc/sp64-elf.h. */
364 #ifdef ASM_OUTPUT_DWARF2_ADDR_CONST
365 #undef ASM_OUTPUT_DWARF_ADDR_CONST
366 #define ASM_OUTPUT_DWARF_ADDR_CONST(FILE,ADDR) \
367 ASM_OUTPUT_DWARF2_ADDR_CONST (FILE, ADDR)
370 #ifndef ASM_OUTPUT_DWARF_ADDR_CONST
371 #define ASM_OUTPUT_DWARF_ADDR_CONST(FILE,ADDR) \
372 fprintf ((FILE), "\t%s\t%s", UNALIGNED_WORD_ASM_OP, (ADDR))
375 #ifndef ASM_OUTPUT_DWARF_OFFSET4
376 #define ASM_OUTPUT_DWARF_OFFSET4(FILE,LABEL) \
377 do { fprintf ((FILE), "\t%s\t", UNALIGNED_INT_ASM_OP); \
378 assemble_name (FILE, LABEL); \
382 #ifndef ASM_OUTPUT_DWARF_OFFSET
383 #define ASM_OUTPUT_DWARF_OFFSET(FILE,LABEL) \
384 do { fprintf ((FILE), "\t%s\t", UNALIGNED_OFFSET_ASM_OP); \
385 assemble_name (FILE, LABEL); \
389 #ifndef ASM_OUTPUT_DWARF_DATA2
390 #define ASM_OUTPUT_DWARF_DATA2(FILE,VALUE) \
391 fprintf ((FILE), "\t%s\t0x%x", UNALIGNED_SHORT_ASM_OP, (unsigned) (VALUE))
394 #ifndef ASM_OUTPUT_DWARF_DATA4
395 #define ASM_OUTPUT_DWARF_DATA4(FILE,VALUE) \
396 fprintf ((FILE), "\t%s\t0x%x", UNALIGNED_INT_ASM_OP, (unsigned) (VALUE))
399 #ifndef ASM_OUTPUT_DWARF_DATA
400 #define ASM_OUTPUT_DWARF_DATA(FILE,VALUE) \
401 fprintf ((FILE), "\t%s\t0x%lx", UNALIGNED_OFFSET_ASM_OP, \
402 (unsigned long) (VALUE))
405 #ifndef ASM_OUTPUT_DWARF_ADDR_DATA
406 #define ASM_OUTPUT_DWARF_ADDR_DATA(FILE,VALUE) \
407 fprintf ((FILE), "\t%s\t0x%lx", UNALIGNED_WORD_ASM_OP, \
408 (unsigned long) (VALUE))
411 #ifndef ASM_OUTPUT_DWARF_DATA8
412 #define ASM_OUTPUT_DWARF_DATA8(FILE,HIGH_VALUE,LOW_VALUE) \
414 if (WORDS_BIG_ENDIAN) \
416 fprintf ((FILE), "\t%s\t0x%lx\n", UNALIGNED_INT_ASM_OP, (HIGH_VALUE));\
417 fprintf ((FILE), "\t%s\t0x%lx", UNALIGNED_INT_ASM_OP, (LOW_VALUE));\
421 fprintf ((FILE), "\t%s\t0x%lx\n", UNALIGNED_INT_ASM_OP, (LOW_VALUE)); \
422 fprintf ((FILE), "\t%s\t0x%lx", UNALIGNED_INT_ASM_OP, (HIGH_VALUE)); \
427 #else /* UNALIGNED_INT_ASM_OP */
429 /* We don't have unaligned support, let's hope the normal output works for
432 #define ASM_OUTPUT_DWARF_ADDR(FILE,LABEL) \
433 assemble_integer (gen_rtx_SYMBOL_REF (Pmode, LABEL), PTR_SIZE, 1)
435 #define ASM_OUTPUT_DWARF_OFFSET4(FILE,LABEL) \
436 assemble_integer (gen_rtx_SYMBOL_REF (SImode, LABEL), 4, 1)
438 #define ASM_OUTPUT_DWARF_OFFSET(FILE,LABEL) \
439 assemble_integer (gen_rtx_SYMBOL_REF (SImode, LABEL), 4, 1)
441 #define ASM_OUTPUT_DWARF_DELTA2(FILE,LABEL1,LABEL2) \
442 assemble_integer (gen_rtx_MINUS (HImode, \
443 gen_rtx_SYMBOL_REF (Pmode, LABEL1), \
444 gen_rtx_SYMBOL_REF (Pmode, LABEL2)), \
447 #define ASM_OUTPUT_DWARF_DELTA4(FILE,LABEL1,LABEL2) \
448 assemble_integer (gen_rtx_MINUS (SImode, \
449 gen_rtx_SYMBOL_REF (Pmode, LABEL1), \
450 gen_rtx_SYMBOL_REF (Pmode, LABEL2)), \
453 #define ASM_OUTPUT_DWARF_ADDR_DELTA(FILE,LABEL1,LABEL2) \
454 assemble_integer (gen_rtx_MINUS (Pmode, \
455 gen_rtx_SYMBOL_REF (Pmode, LABEL1), \
456 gen_rtx_SYMBOL_REF (Pmode, LABEL2)), \
459 #define ASM_OUTPUT_DWARF_DELTA(FILE,LABEL1,LABEL2) \
460 ASM_OUTPUT_DWARF_DELTA4 (FILE,LABEL1,LABEL2)
462 #define ASM_OUTPUT_DWARF_DATA4(FILE,VALUE) \
463 assemble_integer (GEN_INT (VALUE), 4, 1)
465 #endif /* UNALIGNED_INT_ASM_OP */
468 #ifndef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
469 #define ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL(FILE, SY, HI, LO) \
471 fprintf (FILE, "\t%s\t", SET_ASM_OP); \
472 assemble_name (FILE, SY); \
474 assemble_name (FILE, HI); \
476 assemble_name (FILE, LO); \
479 #endif /* SET_ASM_OP */
481 /* This is similar to the default ASM_OUTPUT_ASCII, except that no trailing
482 newline is produced. When flag_debug_asm is asserted, we add commentary
483 at the end of the line, so we must avoid output of a newline here. */
484 #ifndef ASM_OUTPUT_DWARF_STRING
485 #define ASM_OUTPUT_DWARF_STRING(FILE,P) \
487 register int slen = strlen(P); \
488 register const char *p = (P); \
490 fprintf (FILE, "\t.ascii \""); \
491 for (i = 0; i < slen; i++) \
493 register int c = p[i]; \
494 if (c == '\"' || c == '\\') \
500 fprintf (FILE, "\\%o", c); \
503 fprintf (FILE, "\\0\""); \
508 /* The DWARF 2 CFA column which tracks the return address. Normally this
509 is the column for PC, or the first column after all of the hard
511 #ifndef DWARF_FRAME_RETURN_COLUMN
513 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (PC_REGNUM)
515 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGISTERS
519 /* The mapping from gcc register number to DWARF 2 CFA column number. By
520 default, we just provide columns for all registers. */
521 #ifndef DWARF_FRAME_REGNUM
522 #define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG)
525 /* Hook used by __throw. */
528 expand_builtin_dwarf_fp_regnum ()
530 return GEN_INT (DWARF_FRAME_REGNUM (HARD_FRAME_POINTER_REGNUM));
533 /* The offset from the incoming value of %sp to the top of the stack frame
534 for the current function. */
535 #ifndef INCOMING_FRAME_SP_OFFSET
536 #define INCOMING_FRAME_SP_OFFSET 0
539 /* Return a pointer to a copy of the section string name S with all
540 attributes stripped off, and an asterisk prepended (for assemble_name). */
546 char *stripped = xmalloc (strlen (s) + 2);
551 while (*s && *s != ',')
558 /* Return the register number described by a given RTL node. */
564 register unsigned regno = REGNO (rtl);
566 if (regno >= DWARF_FRAME_REGISTERS)
568 warning ("internal regno botch: regno = %d\n", regno);
572 regno = DBX_REGISTER_NUMBER (regno);
576 /* Generate code to initialize the register size table. */
579 expand_builtin_init_dwarf_reg_sizes (address)
583 enum machine_mode mode = TYPE_MODE (char_type_node);
584 rtx addr = expand_expr (address, NULL_RTX, VOIDmode, 0);
585 rtx mem = gen_rtx_MEM (mode, addr);
587 for (i = 0; i < DWARF_FRAME_REGISTERS; ++i)
589 int offset = i * GET_MODE_SIZE (mode);
590 int size = GET_MODE_SIZE (reg_raw_mode[i]);
592 emit_move_insn (change_address (mem, mode,
593 plus_constant (addr, offset)),
598 /* Convert a DWARF call frame info. operation to its string name */
601 dwarf_cfi_name (cfi_opc)
602 register unsigned cfi_opc;
606 case DW_CFA_advance_loc:
607 return "DW_CFA_advance_loc";
609 return "DW_CFA_offset";
611 return "DW_CFA_restore";
615 return "DW_CFA_set_loc";
616 case DW_CFA_advance_loc1:
617 return "DW_CFA_advance_loc1";
618 case DW_CFA_advance_loc2:
619 return "DW_CFA_advance_loc2";
620 case DW_CFA_advance_loc4:
621 return "DW_CFA_advance_loc4";
622 case DW_CFA_offset_extended:
623 return "DW_CFA_offset_extended";
624 case DW_CFA_restore_extended:
625 return "DW_CFA_restore_extended";
626 case DW_CFA_undefined:
627 return "DW_CFA_undefined";
628 case DW_CFA_same_value:
629 return "DW_CFA_same_value";
630 case DW_CFA_register:
631 return "DW_CFA_register";
632 case DW_CFA_remember_state:
633 return "DW_CFA_remember_state";
634 case DW_CFA_restore_state:
635 return "DW_CFA_restore_state";
637 return "DW_CFA_def_cfa";
638 case DW_CFA_def_cfa_register:
639 return "DW_CFA_def_cfa_register";
640 case DW_CFA_def_cfa_offset:
641 return "DW_CFA_def_cfa_offset";
643 /* SGI/MIPS specific */
644 case DW_CFA_MIPS_advance_loc8:
645 return "DW_CFA_MIPS_advance_loc8";
648 case DW_CFA_GNU_window_save:
649 return "DW_CFA_GNU_window_save";
650 case DW_CFA_GNU_args_size:
651 return "DW_CFA_GNU_args_size";
654 return "DW_CFA_<unknown>";
658 /* Return a pointer to a newly allocated Call Frame Instruction. */
660 static inline dw_cfi_ref
663 register dw_cfi_ref cfi = (dw_cfi_ref) xmalloc (sizeof (dw_cfi_node));
665 cfi->dw_cfi_next = NULL;
666 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = 0;
667 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = 0;
672 /* Add a Call Frame Instruction to list of instructions. */
675 add_cfi (list_head, cfi)
676 register dw_cfi_ref *list_head;
677 register dw_cfi_ref cfi;
679 register dw_cfi_ref *p;
681 /* Find the end of the chain. */
682 for (p = list_head; (*p) != NULL; p = &(*p)->dw_cfi_next)
688 /* Generate a new label for the CFI info to refer to. */
691 dwarf2out_cfi_label ()
693 static char label[20];
694 static unsigned long label_num = 0;
696 ASM_GENERATE_INTERNAL_LABEL (label, "LCFI", label_num++);
697 ASM_OUTPUT_LABEL (asm_out_file, label);
702 /* Add CFI to the current fde at the PC value indicated by LABEL if specified,
703 or to the CIE if LABEL is NULL. */
706 add_fde_cfi (label, cfi)
707 register char *label;
708 register dw_cfi_ref cfi;
712 register dw_fde_ref fde = &fde_table[fde_table_in_use - 1];
715 label = dwarf2out_cfi_label ();
717 if (fde->dw_fde_current_label == NULL
718 || strcmp (label, fde->dw_fde_current_label) != 0)
720 register dw_cfi_ref xcfi;
722 fde->dw_fde_current_label = label = xstrdup (label);
724 /* Set the location counter to the new label. */
726 xcfi->dw_cfi_opc = DW_CFA_advance_loc4;
727 xcfi->dw_cfi_oprnd1.dw_cfi_addr = label;
728 add_cfi (&fde->dw_fde_cfi, xcfi);
731 add_cfi (&fde->dw_fde_cfi, cfi);
735 add_cfi (&cie_cfi_head, cfi);
738 /* Subroutine of lookup_cfa. */
741 lookup_cfa_1 (cfi, regp, offsetp)
742 register dw_cfi_ref cfi;
743 register unsigned long *regp;
744 register long *offsetp;
746 switch (cfi->dw_cfi_opc)
748 case DW_CFA_def_cfa_offset:
749 *offsetp = cfi->dw_cfi_oprnd1.dw_cfi_offset;
751 case DW_CFA_def_cfa_register:
752 *regp = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
755 *regp = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
756 *offsetp = cfi->dw_cfi_oprnd2.dw_cfi_offset;
763 /* Find the previous value for the CFA. */
766 lookup_cfa (regp, offsetp)
767 register unsigned long *regp;
768 register long *offsetp;
770 register dw_cfi_ref cfi;
772 *regp = (unsigned long) -1;
775 for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
776 lookup_cfa_1 (cfi, regp, offsetp);
778 if (fde_table_in_use)
780 register dw_fde_ref fde = &fde_table[fde_table_in_use - 1];
781 for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
782 lookup_cfa_1 (cfi, regp, offsetp);
786 /* The current rule for calculating the DWARF2 canonical frame address. */
787 static unsigned long cfa_reg;
788 static long cfa_offset;
790 /* The register used for saving registers to the stack, and its offset
792 static unsigned cfa_store_reg;
793 static long cfa_store_offset;
795 /* The running total of the size of arguments pushed onto the stack. */
796 static long args_size;
798 /* The last args_size we actually output. */
799 static long old_args_size;
801 /* Entry point to update the canonical frame address (CFA).
802 LABEL is passed to add_fde_cfi. The value of CFA is now to be
803 calculated from REG+OFFSET. */
806 dwarf2out_def_cfa (label, reg, offset)
807 register char *label;
808 register unsigned reg;
809 register long offset;
811 register dw_cfi_ref cfi;
812 unsigned long old_reg;
817 if (cfa_store_reg == reg)
818 cfa_store_offset = offset;
820 reg = DWARF_FRAME_REGNUM (reg);
821 lookup_cfa (&old_reg, &old_offset);
823 if (reg == old_reg && offset == old_offset)
830 cfi->dw_cfi_opc = DW_CFA_def_cfa_offset;
831 cfi->dw_cfi_oprnd1.dw_cfi_offset = offset;
834 #ifndef MIPS_DEBUGGING_INFO /* SGI dbx thinks this means no offset. */
835 else if (offset == old_offset && old_reg != (unsigned long) -1)
837 cfi->dw_cfi_opc = DW_CFA_def_cfa_register;
838 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
844 cfi->dw_cfi_opc = DW_CFA_def_cfa;
845 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
846 cfi->dw_cfi_oprnd2.dw_cfi_offset = offset;
849 add_fde_cfi (label, cfi);
852 /* Add the CFI for saving a register. REG is the CFA column number.
853 LABEL is passed to add_fde_cfi.
854 If SREG is -1, the register is saved at OFFSET from the CFA;
855 otherwise it is saved in SREG. */
858 reg_save (label, reg, sreg, offset)
859 register char * label;
860 register unsigned reg;
861 register unsigned sreg;
862 register long offset;
864 register dw_cfi_ref cfi = new_cfi ();
866 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
868 /* The following comparison is correct. -1 is used to indicate that
869 the value isn't a register number. */
870 if (sreg == (unsigned int) -1)
873 /* The register number won't fit in 6 bits, so we have to use
875 cfi->dw_cfi_opc = DW_CFA_offset_extended;
877 cfi->dw_cfi_opc = DW_CFA_offset;
879 offset /= DWARF_CIE_DATA_ALIGNMENT;
882 cfi->dw_cfi_oprnd2.dw_cfi_offset = offset;
886 cfi->dw_cfi_opc = DW_CFA_register;
887 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = sreg;
890 add_fde_cfi (label, cfi);
893 /* Add the CFI for saving a register window. LABEL is passed to reg_save.
894 This CFI tells the unwinder that it needs to restore the window registers
895 from the previous frame's window save area.
897 ??? Perhaps we should note in the CIE where windows are saved (instead of
898 assuming 0(cfa)) and what registers are in the window. */
901 dwarf2out_window_save (label)
902 register char * label;
904 register dw_cfi_ref cfi = new_cfi ();
905 cfi->dw_cfi_opc = DW_CFA_GNU_window_save;
906 add_fde_cfi (label, cfi);
909 /* Add a CFI to update the running total of the size of arguments
910 pushed onto the stack. */
913 dwarf2out_args_size (label, size)
917 register dw_cfi_ref cfi;
919 if (size == old_args_size)
921 old_args_size = size;
924 cfi->dw_cfi_opc = DW_CFA_GNU_args_size;
925 cfi->dw_cfi_oprnd1.dw_cfi_offset = size;
926 add_fde_cfi (label, cfi);
929 /* Entry point for saving a register to the stack. REG is the GCC register
930 number. LABEL and OFFSET are passed to reg_save. */
933 dwarf2out_reg_save (label, reg, offset)
934 register char * label;
935 register unsigned reg;
936 register long offset;
938 reg_save (label, DWARF_FRAME_REGNUM (reg), -1, offset);
941 /* Entry point for saving the return address in the stack.
942 LABEL and OFFSET are passed to reg_save. */
945 dwarf2out_return_save (label, offset)
946 register char * label;
947 register long offset;
949 reg_save (label, DWARF_FRAME_RETURN_COLUMN, -1, offset);
952 /* Entry point for saving the return address in a register.
953 LABEL and SREG are passed to reg_save. */
956 dwarf2out_return_reg (label, sreg)
957 register char * label;
958 register unsigned sreg;
960 reg_save (label, DWARF_FRAME_RETURN_COLUMN, sreg, 0);
963 /* Record the initial position of the return address. RTL is
964 INCOMING_RETURN_ADDR_RTX. */
967 initial_return_save (rtl)
970 unsigned int reg = (unsigned int) -1;
973 switch (GET_CODE (rtl))
976 /* RA is in a register. */
977 reg = reg_number (rtl);
980 /* RA is on the stack. */
982 switch (GET_CODE (rtl))
985 if (REGNO (rtl) != STACK_POINTER_REGNUM)
990 if (REGNO (XEXP (rtl, 0)) != STACK_POINTER_REGNUM)
992 offset = INTVAL (XEXP (rtl, 1));
995 if (REGNO (XEXP (rtl, 0)) != STACK_POINTER_REGNUM)
997 offset = -INTVAL (XEXP (rtl, 1));
1004 /* The return address is at some offset from any value we can
1005 actually load. For instance, on the SPARC it is in %i7+8. Just
1006 ignore the offset for now; it doesn't matter for unwinding frames. */
1007 if (GET_CODE (XEXP (rtl, 1)) != CONST_INT)
1009 initial_return_save (XEXP (rtl, 0));
1015 reg_save (NULL, DWARF_FRAME_RETURN_COLUMN, reg, offset - cfa_offset);
1018 /* Check INSN to see if it looks like a push or a stack adjustment, and
1019 make a note of it if it does. EH uses this information to find out how
1020 much extra space it needs to pop off the stack. */
1023 dwarf2out_stack_adjust (insn)
1029 if (! asynchronous_exceptions && GET_CODE (insn) == CALL_INSN)
1031 /* Extract the size of the args from the CALL rtx itself. */
1033 insn = PATTERN (insn);
1034 if (GET_CODE (insn) == PARALLEL)
1035 insn = XVECEXP (insn, 0, 0);
1036 if (GET_CODE (insn) == SET)
1037 insn = SET_SRC (insn);
1038 assert (GET_CODE (insn) == CALL);
1039 dwarf2out_args_size ("", INTVAL (XEXP (insn, 1)));
1043 /* If only calls can throw, and we have a frame pointer,
1044 save up adjustments until we see the CALL_INSN. */
1045 else if (! asynchronous_exceptions
1046 && cfa_reg != STACK_POINTER_REGNUM)
1049 if (GET_CODE (insn) == BARRIER)
1051 /* When we see a BARRIER, we know to reset args_size to 0. Usually
1052 the compiler will have already emitted a stack adjustment, but
1053 doesn't bother for calls to noreturn functions. */
1054 #ifdef STACK_GROWS_DOWNWARD
1055 offset = -args_size;
1060 else if (GET_CODE (PATTERN (insn)) == SET)
1065 insn = PATTERN (insn);
1066 src = SET_SRC (insn);
1067 dest = SET_DEST (insn);
1069 if (dest == stack_pointer_rtx)
1071 /* (set (reg sp) (plus (reg sp) (const_int))) */
1072 code = GET_CODE (src);
1073 if (! (code == PLUS || code == MINUS)
1074 || XEXP (src, 0) != stack_pointer_rtx
1075 || GET_CODE (XEXP (src, 1)) != CONST_INT)
1078 offset = INTVAL (XEXP (src, 1));
1080 else if (GET_CODE (dest) == MEM)
1082 /* (set (mem (pre_dec (reg sp))) (foo)) */
1083 src = XEXP (dest, 0);
1084 code = GET_CODE (src);
1086 if (! (code == PRE_DEC || code == PRE_INC)
1087 || XEXP (src, 0) != stack_pointer_rtx)
1090 offset = GET_MODE_SIZE (GET_MODE (dest));
1095 if (code == PLUS || code == PRE_INC)
1104 if (cfa_reg == STACK_POINTER_REGNUM)
1105 cfa_offset += offset;
1107 #ifndef STACK_GROWS_DOWNWARD
1110 args_size += offset;
1114 label = dwarf2out_cfi_label ();
1115 dwarf2out_def_cfa (label, cfa_reg, cfa_offset);
1116 dwarf2out_args_size (label, args_size);
1119 /* A temporary register used in adjusting SP or setting up the store_reg. */
1120 static unsigned cfa_temp_reg;
1122 /* A temporary value used in adjusting SP or setting up the store_reg. */
1123 static long cfa_temp_value;
1125 /* Record call frame debugging information for an expression, which either
1126 sets SP or FP (adjusting how we calculate the frame address) or saves a
1127 register to the stack. */
1130 dwarf2out_frame_debug_expr (expr, label)
1137 /* If RTX_FRAME_RELATED_P is set on a PARALLEL, process each member of
1138 the PARALLEL independantly. The first element is always processed if
1139 it is a SET. This is for backward compatability. Other elements
1140 are processed only if they are SETs and the RTX_FRAME_RELATED_P
1141 flag is set in them. */
1143 if (GET_CODE (expr) == PARALLEL)
1146 int limit = XVECLEN (expr, 0);
1148 for (par_index = 0; par_index < limit; par_index++)
1150 rtx x = XVECEXP (expr, 0, par_index);
1152 if (GET_CODE (x) == SET &&
1153 (RTX_FRAME_RELATED_P (x) || par_index == 0))
1154 dwarf2out_frame_debug_expr (x, label);
1159 if (GET_CODE (expr) != SET)
1162 src = SET_SRC (expr);
1163 dest = SET_DEST (expr);
1165 switch (GET_CODE (dest))
1168 /* Update the CFA rule wrt SP or FP. Make sure src is
1169 relative to the current CFA register. */
1170 switch (GET_CODE (src))
1172 /* Setting FP from SP. */
1174 if (cfa_reg != (unsigned) REGNO (src))
1176 if (REGNO (dest) != STACK_POINTER_REGNUM
1177 && !(frame_pointer_needed
1178 && REGNO (dest) == HARD_FRAME_POINTER_REGNUM))
1180 cfa_reg = REGNO (dest);
1185 if (dest == stack_pointer_rtx)
1188 switch (GET_CODE (XEXP (src, 1)))
1191 offset = INTVAL (XEXP (src, 1));
1194 if ((unsigned) REGNO (XEXP (src, 1)) != cfa_temp_reg)
1196 offset = cfa_temp_value;
1202 if (XEXP (src, 0) == hard_frame_pointer_rtx)
1204 /* Restoring SP from FP in the epilogue. */
1205 if (cfa_reg != (unsigned) HARD_FRAME_POINTER_REGNUM)
1207 cfa_reg = STACK_POINTER_REGNUM;
1209 else if (XEXP (src, 0) != stack_pointer_rtx)
1212 if (GET_CODE (src) == PLUS)
1214 if (cfa_reg == STACK_POINTER_REGNUM)
1215 cfa_offset += offset;
1216 if (cfa_store_reg == STACK_POINTER_REGNUM)
1217 cfa_store_offset += offset;
1219 else if (dest == hard_frame_pointer_rtx)
1221 /* Either setting the FP from an offset of the SP,
1222 or adjusting the FP */
1223 if (! frame_pointer_needed
1224 || REGNO (dest) != HARD_FRAME_POINTER_REGNUM)
1227 if (XEXP (src, 0) == stack_pointer_rtx
1228 && GET_CODE (XEXP (src, 1)) == CONST_INT)
1230 if (cfa_reg != STACK_POINTER_REGNUM)
1232 offset = INTVAL (XEXP (src, 1));
1233 if (GET_CODE (src) == PLUS)
1235 cfa_offset += offset;
1236 cfa_reg = HARD_FRAME_POINTER_REGNUM;
1238 else if (XEXP (src, 0) == hard_frame_pointer_rtx
1239 && GET_CODE (XEXP (src, 1)) == CONST_INT)
1241 if (cfa_reg != (unsigned) HARD_FRAME_POINTER_REGNUM)
1243 offset = INTVAL (XEXP (src, 1));
1244 if (GET_CODE (src) == PLUS)
1246 cfa_offset += offset;
1254 if (GET_CODE (src) != PLUS
1255 || XEXP (src, 1) != stack_pointer_rtx)
1257 if (GET_CODE (XEXP (src, 0)) != REG
1258 || (unsigned) REGNO (XEXP (src, 0)) != cfa_temp_reg)
1260 if (cfa_reg != STACK_POINTER_REGNUM)
1262 cfa_store_reg = REGNO (dest);
1263 cfa_store_offset = cfa_offset - cfa_temp_value;
1268 cfa_temp_reg = REGNO (dest);
1269 cfa_temp_value = INTVAL (src);
1273 if (GET_CODE (XEXP (src, 0)) != REG
1274 || (unsigned) REGNO (XEXP (src, 0)) != cfa_temp_reg
1275 || (unsigned) REGNO (dest) != cfa_temp_reg
1276 || GET_CODE (XEXP (src, 1)) != CONST_INT)
1278 cfa_temp_value |= INTVAL (XEXP (src, 1));
1284 dwarf2out_def_cfa (label, cfa_reg, cfa_offset);
1288 /* Saving a register to the stack. Make sure dest is relative to the
1290 if (GET_CODE (src) != REG)
1292 switch (GET_CODE (XEXP (dest, 0)))
1297 offset = GET_MODE_SIZE (GET_MODE (dest));
1298 if (GET_CODE (XEXP (dest, 0)) == PRE_INC)
1301 if (REGNO (XEXP (XEXP (dest, 0), 0)) != STACK_POINTER_REGNUM
1302 || cfa_store_reg != STACK_POINTER_REGNUM)
1304 cfa_store_offset += offset;
1305 if (cfa_reg == STACK_POINTER_REGNUM)
1306 cfa_offset = cfa_store_offset;
1308 offset = -cfa_store_offset;
1311 /* With an offset. */
1314 offset = INTVAL (XEXP (XEXP (dest, 0), 1));
1315 if (GET_CODE (XEXP (dest, 0)) == MINUS)
1318 if (cfa_store_reg != (unsigned) REGNO (XEXP (XEXP (dest, 0), 0)))
1320 offset -= cfa_store_offset;
1323 /* Without an offset. */
1325 if (cfa_store_reg != (unsigned) REGNO (XEXP (dest, 0)))
1327 offset = -cfa_store_offset;
1333 dwarf2out_def_cfa (label, cfa_reg, cfa_offset);
1334 dwarf2out_reg_save (label, REGNO (src), offset);
1343 /* Record call frame debugging information for INSN, which either
1344 sets SP or FP (adjusting how we calculate the frame address) or saves a
1345 register to the stack. If INSN is NULL_RTX, initialize our state. */
1348 dwarf2out_frame_debug (insn)
1354 if (insn == NULL_RTX)
1356 /* Set up state for generating call frame debug info. */
1357 lookup_cfa (&cfa_reg, &cfa_offset);
1358 if (cfa_reg != DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM))
1360 cfa_reg = STACK_POINTER_REGNUM;
1361 cfa_store_reg = cfa_reg;
1362 cfa_store_offset = cfa_offset;
1368 if (! RTX_FRAME_RELATED_P (insn))
1370 dwarf2out_stack_adjust (insn);
1374 label = dwarf2out_cfi_label ();
1376 src = find_reg_note (insn, REG_FRAME_RELATED_EXPR, NULL_RTX);
1378 insn = XEXP (src, 0);
1380 insn = PATTERN (insn);
1382 dwarf2out_frame_debug_expr (insn, label);
1385 /* Return the size of an unsigned LEB128 quantity. */
1387 static inline unsigned long
1388 size_of_uleb128 (value)
1389 register unsigned long value;
1391 register unsigned long size = 0;
1392 register unsigned byte;
1396 byte = (value & 0x7f);
1405 /* Return the size of a signed LEB128 quantity. */
1407 static inline unsigned long
1408 size_of_sleb128 (value)
1409 register long value;
1411 register unsigned long size = 0;
1412 register unsigned byte;
1416 byte = (value & 0x7f);
1420 while (!(((value == 0) && ((byte & 0x40) == 0))
1421 || ((value == -1) && ((byte & 0x40) != 0))));
1426 /* Output an unsigned LEB128 quantity. */
1429 output_uleb128 (value)
1430 register unsigned long value;
1432 unsigned long save_value = value;
1434 fprintf (asm_out_file, "\t%s\t", ASM_BYTE_OP);
1437 register unsigned byte = (value & 0x7f);
1440 /* More bytes to follow. */
1443 fprintf (asm_out_file, "0x%x", byte);
1445 fprintf (asm_out_file, ",");
1450 fprintf (asm_out_file, "\t%s ULEB128 0x%lx", ASM_COMMENT_START, save_value);
1453 /* Output an signed LEB128 quantity. */
1456 output_sleb128 (value)
1457 register long value;
1460 register unsigned byte;
1461 long save_value = value;
1463 fprintf (asm_out_file, "\t%s\t", ASM_BYTE_OP);
1466 byte = (value & 0x7f);
1467 /* arithmetic shift */
1469 more = !((((value == 0) && ((byte & 0x40) == 0))
1470 || ((value == -1) && ((byte & 0x40) != 0))));
1474 fprintf (asm_out_file, "0x%x", byte);
1476 fprintf (asm_out_file, ",");
1481 fprintf (asm_out_file, "\t%s SLEB128 %ld", ASM_COMMENT_START, save_value);
1484 /* Output a Call Frame Information opcode and its operand(s). */
1487 output_cfi (cfi, fde)
1488 register dw_cfi_ref cfi;
1489 register dw_fde_ref fde;
1491 if (cfi->dw_cfi_opc == DW_CFA_advance_loc)
1493 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
1495 | (cfi->dw_cfi_oprnd1.dw_cfi_offset & 0x3f));
1497 fprintf (asm_out_file, "\t%s DW_CFA_advance_loc 0x%lx",
1498 ASM_COMMENT_START, cfi->dw_cfi_oprnd1.dw_cfi_offset);
1499 fputc ('\n', asm_out_file);
1502 else if (cfi->dw_cfi_opc == DW_CFA_offset)
1504 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
1506 | (cfi->dw_cfi_oprnd1.dw_cfi_reg_num & 0x3f));
1508 fprintf (asm_out_file, "\t%s DW_CFA_offset, column 0x%lx",
1509 ASM_COMMENT_START, cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
1511 fputc ('\n', asm_out_file);
1512 output_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset);
1513 fputc ('\n', asm_out_file);
1515 else if (cfi->dw_cfi_opc == DW_CFA_restore)
1517 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
1519 | (cfi->dw_cfi_oprnd1.dw_cfi_reg_num & 0x3f));
1521 fprintf (asm_out_file, "\t%s DW_CFA_restore, column 0x%lx",
1522 ASM_COMMENT_START, cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
1524 fputc ('\n', asm_out_file);
1528 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, cfi->dw_cfi_opc);
1530 fprintf (asm_out_file, "\t%s %s", ASM_COMMENT_START,
1531 dwarf_cfi_name (cfi->dw_cfi_opc));
1533 fputc ('\n', asm_out_file);
1534 switch (cfi->dw_cfi_opc)
1536 case DW_CFA_set_loc:
1537 ASM_OUTPUT_DWARF_ADDR (asm_out_file, cfi->dw_cfi_oprnd1.dw_cfi_addr);
1538 fputc ('\n', asm_out_file);
1540 case DW_CFA_advance_loc1:
1541 ASM_OUTPUT_DWARF_DELTA1 (asm_out_file,
1542 cfi->dw_cfi_oprnd1.dw_cfi_addr,
1543 fde->dw_fde_current_label);
1544 fputc ('\n', asm_out_file);
1545 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
1547 case DW_CFA_advance_loc2:
1548 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file,
1549 cfi->dw_cfi_oprnd1.dw_cfi_addr,
1550 fde->dw_fde_current_label);
1551 fputc ('\n', asm_out_file);
1552 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
1554 case DW_CFA_advance_loc4:
1555 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file,
1556 cfi->dw_cfi_oprnd1.dw_cfi_addr,
1557 fde->dw_fde_current_label);
1558 fputc ('\n', asm_out_file);
1559 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
1561 #ifdef MIPS_DEBUGGING_INFO
1562 case DW_CFA_MIPS_advance_loc8:
1563 /* TODO: not currently implemented. */
1567 case DW_CFA_offset_extended:
1568 case DW_CFA_def_cfa:
1569 output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
1570 fputc ('\n', asm_out_file);
1571 output_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset);
1572 fputc ('\n', asm_out_file);
1574 case DW_CFA_restore_extended:
1575 case DW_CFA_undefined:
1576 output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
1577 fputc ('\n', asm_out_file);
1579 case DW_CFA_same_value:
1580 case DW_CFA_def_cfa_register:
1581 output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
1582 fputc ('\n', asm_out_file);
1584 case DW_CFA_register:
1585 output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
1586 fputc ('\n', asm_out_file);
1587 output_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_reg_num);
1588 fputc ('\n', asm_out_file);
1590 case DW_CFA_def_cfa_offset:
1591 output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset);
1592 fputc ('\n', asm_out_file);
1594 case DW_CFA_GNU_window_save:
1596 case DW_CFA_GNU_args_size:
1597 output_uleb128 (cfi->dw_cfi_oprnd1.dw_cfi_offset);
1598 fputc ('\n', asm_out_file);
1606 /* Output the call frame information used to used to record information
1607 that relates to calculating the frame pointer, and records the
1608 location of saved registers. */
1611 output_call_frame_info (for_eh)
1614 register unsigned long i;
1615 register dw_fde_ref fde;
1616 register dw_cfi_ref cfi;
1617 char l1[20], l2[20];
1618 #ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
1622 /* Do we want to include a pointer to the exception table? */
1623 int eh_ptr = for_eh && exception_table_p ();
1625 fputc ('\n', asm_out_file);
1627 /* We're going to be generating comments, so turn on app. */
1633 #ifdef EH_FRAME_SECTION
1634 EH_FRAME_SECTION ();
1636 tree label = get_file_function_name ('F');
1638 force_data_section ();
1639 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
1640 ASM_GLOBALIZE_LABEL (asm_out_file, IDENTIFIER_POINTER (label));
1641 ASM_OUTPUT_LABEL (asm_out_file, IDENTIFIER_POINTER (label));
1643 assemble_label ("__FRAME_BEGIN__");
1646 ASM_OUTPUT_SECTION (asm_out_file, FRAME_SECTION);
1648 /* Output the CIE. */
1649 ASM_GENERATE_INTERNAL_LABEL (l1, CIE_AFTER_SIZE_LABEL, for_eh);
1650 ASM_GENERATE_INTERNAL_LABEL (l2, CIE_END_LABEL, for_eh);
1651 #ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
1652 ASM_GENERATE_INTERNAL_LABEL (ld, CIE_LENGTH_LABEL, for_eh);
1654 ASM_OUTPUT_DWARF_OFFSET4 (asm_out_file, ld);
1656 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, ld);
1659 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, l2, l1);
1661 ASM_OUTPUT_DWARF_DELTA (asm_out_file, l2, l1);
1664 fprintf (asm_out_file, "\t%s Length of Common Information Entry",
1667 fputc ('\n', asm_out_file);
1668 ASM_OUTPUT_LABEL (asm_out_file, l1);
1671 /* Now that the CIE pointer is PC-relative for EH,
1672 use 0 to identify the CIE. */
1673 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0);
1675 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, DW_CIE_ID);
1678 fprintf (asm_out_file, "\t%s CIE Identifier Tag", ASM_COMMENT_START);
1680 fputc ('\n', asm_out_file);
1681 if (! for_eh && DWARF_OFFSET_SIZE == 8)
1683 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, DW_CIE_ID);
1684 fputc ('\n', asm_out_file);
1687 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_CIE_VERSION);
1689 fprintf (asm_out_file, "\t%s CIE Version", ASM_COMMENT_START);
1691 fputc ('\n', asm_out_file);
1694 /* The CIE contains a pointer to the exception region info for the
1695 frame. Make the augmentation string three bytes (including the
1696 trailing null) so the pointer is 4-byte aligned. The Solaris ld
1697 can't handle unaligned relocs. */
1700 ASM_OUTPUT_DWARF_STRING (asm_out_file, "eh");
1701 fprintf (asm_out_file, "\t%s CIE Augmentation", ASM_COMMENT_START);
1705 ASM_OUTPUT_ASCII (asm_out_file, "eh", 3);
1707 fputc ('\n', asm_out_file);
1709 ASM_OUTPUT_DWARF_ADDR (asm_out_file, "__EXCEPTION_TABLE__");
1711 fprintf (asm_out_file, "\t%s pointer to exception region info",
1716 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
1718 fprintf (asm_out_file, "\t%s CIE Augmentation (none)",
1722 fputc ('\n', asm_out_file);
1725 fprintf (asm_out_file, " (CIE Code Alignment Factor)");
1727 fputc ('\n', asm_out_file);
1728 output_sleb128 (DWARF_CIE_DATA_ALIGNMENT);
1730 fprintf (asm_out_file, " (CIE Data Alignment Factor)");
1732 fputc ('\n', asm_out_file);
1733 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DWARF_FRAME_RETURN_COLUMN);
1735 fprintf (asm_out_file, "\t%s CIE RA Column", ASM_COMMENT_START);
1737 fputc ('\n', asm_out_file);
1739 for (cfi = cie_cfi_head; cfi != NULL; cfi = cfi->dw_cfi_next)
1740 output_cfi (cfi, NULL);
1742 /* Pad the CIE out to an address sized boundary. */
1743 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
1744 ASM_OUTPUT_LABEL (asm_out_file, l2);
1745 #ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
1746 ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL (asm_out_file, ld, l2, l1);
1748 fprintf (asm_out_file, "\t%s CIE Length Symbol", ASM_COMMENT_START);
1749 fputc ('\n', asm_out_file);
1752 /* Loop through all of the FDE's. */
1753 for (i = 0; i < fde_table_in_use; ++i)
1755 fde = &fde_table[i];
1757 ASM_GENERATE_INTERNAL_LABEL (l1, FDE_AFTER_SIZE_LABEL, for_eh + i*2);
1758 ASM_GENERATE_INTERNAL_LABEL (l2, FDE_END_LABEL, for_eh + i*2);
1759 #ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
1760 ASM_GENERATE_INTERNAL_LABEL (ld, FDE_LENGTH_LABEL, for_eh + i*2);
1762 ASM_OUTPUT_DWARF_OFFSET4 (asm_out_file, ld);
1764 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, ld);
1767 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, l2, l1);
1769 ASM_OUTPUT_DWARF_DELTA (asm_out_file, l2, l1);
1772 fprintf (asm_out_file, "\t%s FDE Length", ASM_COMMENT_START);
1773 fputc ('\n', asm_out_file);
1774 ASM_OUTPUT_LABEL (asm_out_file, l1);
1776 /* ??? This always emits a 4 byte offset when for_eh is true, but it
1777 emits a target dependent sized offset when for_eh is not true.
1778 This inconsistency may confuse gdb. The only case where we need a
1779 non-4 byte offset is for the Irix6 N64 ABI, so we may lose SGI
1780 compatibility if we emit a 4 byte offset. We need a 4 byte offset
1781 though in order to be compatible with the dwarf_fde struct in frame.c.
1782 If the for_eh case is changed, then the struct in frame.c has
1783 to be adjusted appropriately. */
1785 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file, l1, "__FRAME_BEGIN__");
1787 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, stripattributes (FRAME_SECTION));
1789 fprintf (asm_out_file, "\t%s FDE CIE offset", ASM_COMMENT_START);
1791 fputc ('\n', asm_out_file);
1792 ASM_OUTPUT_DWARF_ADDR (asm_out_file, fde->dw_fde_begin);
1794 fprintf (asm_out_file, "\t%s FDE initial location", ASM_COMMENT_START);
1796 fputc ('\n', asm_out_file);
1797 ASM_OUTPUT_DWARF_ADDR_DELTA (asm_out_file,
1798 fde->dw_fde_end, fde->dw_fde_begin);
1800 fprintf (asm_out_file, "\t%s FDE address range", ASM_COMMENT_START);
1802 fputc ('\n', asm_out_file);
1804 /* Loop through the Call Frame Instructions associated with
1806 fde->dw_fde_current_label = fde->dw_fde_begin;
1807 for (cfi = fde->dw_fde_cfi; cfi != NULL; cfi = cfi->dw_cfi_next)
1808 output_cfi (cfi, fde);
1810 /* Pad the FDE out to an address sized boundary. */
1811 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (PTR_SIZE));
1812 ASM_OUTPUT_LABEL (asm_out_file, l2);
1813 #ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
1814 ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL (asm_out_file, ld, l2, l1);
1816 fprintf (asm_out_file, "\t%s FDE Length Symbol", ASM_COMMENT_START);
1817 fputc ('\n', asm_out_file);
1820 #ifndef EH_FRAME_SECTION
1823 /* Emit terminating zero for table. */
1824 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0);
1825 fputc ('\n', asm_out_file);
1828 #ifdef MIPS_DEBUGGING_INFO
1829 /* Work around Irix 6 assembler bug whereby labels at the end of a section
1830 get a value of 0. Putting .align 0 after the label fixes it. */
1831 ASM_OUTPUT_ALIGN (asm_out_file, 0);
1834 /* Turn off app to make assembly quicker. */
1839 /* Output a marker (i.e. a label) for the beginning of a function, before
1843 dwarf2out_begin_prologue ()
1845 char label[MAX_ARTIFICIAL_LABEL_BYTES];
1846 register dw_fde_ref fde;
1848 ++current_funcdef_number;
1850 function_section (current_function_decl);
1851 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_BEGIN_LABEL,
1852 current_funcdef_number);
1853 ASM_OUTPUT_LABEL (asm_out_file, label);
1855 /* Expand the fde table if necessary. */
1856 if (fde_table_in_use == fde_table_allocated)
1858 fde_table_allocated += FDE_TABLE_INCREMENT;
1860 = (dw_fde_ref) xrealloc (fde_table,
1861 fde_table_allocated * sizeof (dw_fde_node));
1864 /* Record the FDE associated with this function. */
1865 current_funcdef_fde = fde_table_in_use;
1867 /* Add the new FDE at the end of the fde_table. */
1868 fde = &fde_table[fde_table_in_use++];
1869 fde->dw_fde_begin = xstrdup (label);
1870 fde->dw_fde_current_label = NULL;
1871 fde->dw_fde_end = NULL;
1872 fde->dw_fde_cfi = NULL;
1874 args_size = old_args_size = 0;
1877 /* Output a marker (i.e. a label) for the absolute end of the generated code
1878 for a function definition. This gets called *after* the epilogue code has
1882 dwarf2out_end_epilogue ()
1885 char label[MAX_ARTIFICIAL_LABEL_BYTES];
1887 /* Output a label to mark the endpoint of the code generated for this
1889 ASM_GENERATE_INTERNAL_LABEL (label, FUNC_END_LABEL, current_funcdef_number);
1890 ASM_OUTPUT_LABEL (asm_out_file, label);
1891 fde = &fde_table[fde_table_in_use - 1];
1892 fde->dw_fde_end = xstrdup (label);
1896 dwarf2out_frame_init ()
1898 /* Allocate the initial hunk of the fde_table. */
1899 fde_table = (dw_fde_ref) xcalloc (FDE_TABLE_INCREMENT, sizeof (dw_fde_node));
1900 fde_table_allocated = FDE_TABLE_INCREMENT;
1901 fde_table_in_use = 0;
1903 /* Generate the CFA instructions common to all FDE's. Do it now for the
1904 sake of lookup_cfa. */
1906 #ifdef DWARF2_UNWIND_INFO
1907 /* On entry, the Canonical Frame Address is at SP. */
1908 dwarf2out_def_cfa (NULL, STACK_POINTER_REGNUM, INCOMING_FRAME_SP_OFFSET);
1909 initial_return_save (INCOMING_RETURN_ADDR_RTX);
1914 dwarf2out_frame_finish ()
1916 /* Output call frame information. */
1917 #ifdef MIPS_DEBUGGING_INFO
1918 if (write_symbols == DWARF2_DEBUG)
1919 output_call_frame_info (0);
1920 if (flag_unwind_tables || (flag_exceptions && ! exceptions_via_longjmp))
1921 output_call_frame_info (1);
1923 if (write_symbols == DWARF2_DEBUG
1924 || flag_unwind_tables || (flag_exceptions && ! exceptions_via_longjmp))
1925 output_call_frame_info (1);
1929 #endif /* .debug_frame support */
1931 /* And now, the support for symbolic debugging information. */
1932 #ifdef DWARF2_DEBUGGING_INFO
1934 /* NOTE: In the comments in this file, many references are made to
1935 "Debugging Information Entries". This term is abbreviated as `DIE'
1936 throughout the remainder of this file. */
1938 /* An internal representation of the DWARF output is built, and then
1939 walked to generate the DWARF debugging info. The walk of the internal
1940 representation is done after the entire program has been compiled.
1941 The types below are used to describe the internal representation. */
1943 /* Each DIE may have a series of attribute/value pairs. Values
1944 can take on several forms. The forms that are used in this
1945 implementation are listed below. */
1952 dw_val_class_unsigned_const,
1953 dw_val_class_long_long,
1956 dw_val_class_die_ref,
1957 dw_val_class_fde_ref,
1958 dw_val_class_lbl_id,
1959 dw_val_class_lbl_offset,
1964 /* Various DIE's use offsets relative to the beginning of the
1965 .debug_info section to refer to each other. */
1967 typedef long int dw_offset;
1969 /* Define typedefs here to avoid circular dependencies. */
1971 typedef struct die_struct *dw_die_ref;
1972 typedef struct dw_attr_struct *dw_attr_ref;
1973 typedef struct dw_val_struct *dw_val_ref;
1974 typedef struct dw_line_info_struct *dw_line_info_ref;
1975 typedef struct dw_separate_line_info_struct *dw_separate_line_info_ref;
1976 typedef struct dw_loc_descr_struct *dw_loc_descr_ref;
1977 typedef struct pubname_struct *pubname_ref;
1978 typedef dw_die_ref *arange_ref;
1980 /* Describe a double word constant value. */
1982 typedef struct dw_long_long_struct
1989 /* Describe a floating point constant value. */
1991 typedef struct dw_fp_struct
1998 /* Each entry in the line_info_table maintains the file and
1999 line number associated with the label generated for that
2000 entry. The label gives the PC value associated with
2001 the line number entry. */
2003 typedef struct dw_line_info_struct
2005 unsigned long dw_file_num;
2006 unsigned long dw_line_num;
2010 /* Line information for functions in separate sections; each one gets its
2012 typedef struct dw_separate_line_info_struct
2014 unsigned long dw_file_num;
2015 unsigned long dw_line_num;
2016 unsigned long function;
2018 dw_separate_line_info_entry;
2020 /* The dw_val_node describes an attribute's value, as it is
2021 represented internally. */
2023 typedef struct dw_val_struct
2025 dw_val_class val_class;
2029 dw_loc_descr_ref val_loc;
2031 long unsigned val_unsigned;
2032 dw_long_long_const val_long_long;
2033 dw_float_const val_float;
2034 dw_die_ref val_die_ref;
2035 unsigned val_fde_index;
2038 unsigned char val_flag;
2044 /* Locations in memory are described using a sequence of stack machine
2047 typedef struct dw_loc_descr_struct
2049 dw_loc_descr_ref dw_loc_next;
2050 enum dwarf_location_atom dw_loc_opc;
2051 dw_val_node dw_loc_oprnd1;
2052 dw_val_node dw_loc_oprnd2;
2056 /* Each DIE attribute has a field specifying the attribute kind,
2057 a link to the next attribute in the chain, and an attribute value.
2058 Attributes are typically linked below the DIE they modify. */
2060 typedef struct dw_attr_struct
2062 enum dwarf_attribute dw_attr;
2063 dw_attr_ref dw_attr_next;
2064 dw_val_node dw_attr_val;
2068 /* The Debugging Information Entry (DIE) structure */
2070 typedef struct die_struct
2072 enum dwarf_tag die_tag;
2073 dw_attr_ref die_attr;
2074 dw_die_ref die_parent;
2075 dw_die_ref die_child;
2077 dw_offset die_offset;
2078 unsigned long die_abbrev;
2082 /* The pubname structure */
2084 typedef struct pubname_struct
2091 /* The limbo die list structure. */
2092 typedef struct limbo_die_struct
2095 struct limbo_die_struct *next;
2099 /* How to start an assembler comment. */
2100 #ifndef ASM_COMMENT_START
2101 #define ASM_COMMENT_START ";#"
2104 /* Define a macro which returns non-zero for a TYPE_DECL which was
2105 implicitly generated for a tagged type.
2107 Note that unlike the gcc front end (which generates a NULL named
2108 TYPE_DECL node for each complete tagged type, each array type, and
2109 each function type node created) the g++ front end generates a
2110 _named_ TYPE_DECL node for each tagged type node created.
2111 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
2112 generate a DW_TAG_typedef DIE for them. */
2114 #define TYPE_DECL_IS_STUB(decl) \
2115 (DECL_NAME (decl) == NULL_TREE \
2116 || (DECL_ARTIFICIAL (decl) \
2117 && is_tagged_type (TREE_TYPE (decl)) \
2118 && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \
2119 /* This is necessary for stub decls that \
2120 appear in nested inline functions. */ \
2121 || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
2122 && (decl_ultimate_origin (decl) \
2123 == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
2125 /* Information concerning the compilation unit's programming
2126 language, and compiler version. */
2128 extern int flag_traditional;
2129 extern char *version_string;
2131 /* Fixed size portion of the DWARF compilation unit header. */
2132 #define DWARF_COMPILE_UNIT_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 3)
2134 /* Fixed size portion of debugging line information prolog. */
2135 #define DWARF_LINE_PROLOG_HEADER_SIZE 5
2137 /* Fixed size portion of public names info. */
2138 #define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
2140 /* Fixed size portion of the address range info. */
2141 #define DWARF_ARANGES_HEADER_SIZE \
2142 (DWARF_ROUND (2 * DWARF_OFFSET_SIZE + 4, PTR_SIZE * 2) - DWARF_OFFSET_SIZE)
2144 /* The default is to have gcc emit the line number tables. */
2145 #ifndef DWARF2_ASM_LINE_DEBUG_INFO
2146 #define DWARF2_ASM_LINE_DEBUG_INFO 0
2149 /* Define the architecture-dependent minimum instruction length (in bytes).
2150 In this implementation of DWARF, this field is used for information
2151 purposes only. Since GCC generates assembly language, we have
2152 no a priori knowledge of how many instruction bytes are generated
2153 for each source line, and therefore can use only the DW_LNE_set_address
2154 and DW_LNS_fixed_advance_pc line information commands. */
2156 #ifndef DWARF_LINE_MIN_INSTR_LENGTH
2157 #define DWARF_LINE_MIN_INSTR_LENGTH 4
2160 /* Minimum line offset in a special line info. opcode.
2161 This value was chosen to give a reasonable range of values. */
2162 #define DWARF_LINE_BASE -10
2164 /* First special line opcde - leave room for the standard opcodes. */
2165 #define DWARF_LINE_OPCODE_BASE 10
2167 /* Range of line offsets in a special line info. opcode. */
2168 #define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1)
2170 /* Flag that indicates the initial value of the is_stmt_start flag.
2171 In the present implementation, we do not mark any lines as
2172 the beginning of a source statement, because that information
2173 is not made available by the GCC front-end. */
2174 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
2176 /* This location is used by calc_die_sizes() to keep track
2177 the offset of each DIE within the .debug_info section. */
2178 static unsigned long next_die_offset;
2180 /* Record the root of the DIE's built for the current compilation unit. */
2181 static dw_die_ref comp_unit_die;
2183 /* A list of DIEs with a NULL parent waiting to be relocated. */
2184 static limbo_die_node *limbo_die_list = 0;
2186 /* Pointer to an array of filenames referenced by this compilation unit. */
2187 static char **file_table;
2189 /* Total number of entries in the table (i.e. array) pointed to by
2190 `file_table'. This is the *total* and includes both used and unused
2192 static unsigned file_table_allocated;
2194 /* Number of entries in the file_table which are actually in use. */
2195 static unsigned file_table_in_use;
2197 /* Size (in elements) of increments by which we may expand the filename
2199 #define FILE_TABLE_INCREMENT 64
2201 /* Local pointer to the name of the main input file. Initialized in
2203 static char *primary_filename;
2205 /* For Dwarf output, we must assign lexical-blocks id numbers in the order in
2206 which their beginnings are encountered. We output Dwarf debugging info
2207 that refers to the beginnings and ends of the ranges of code for each
2208 lexical block. The labels themselves are generated in final.c, which
2209 assigns numbers to the blocks in the same way. */
2210 static unsigned next_block_number = 2;
2212 /* A pointer to the base of a table of references to DIE's that describe
2213 declarations. The table is indexed by DECL_UID() which is a unique
2214 number identifying each decl. */
2215 static dw_die_ref *decl_die_table;
2217 /* Number of elements currently allocated for the decl_die_table. */
2218 static unsigned decl_die_table_allocated;
2220 /* Number of elements in decl_die_table currently in use. */
2221 static unsigned decl_die_table_in_use;
2223 /* Size (in elements) of increments by which we may expand the
2225 #define DECL_DIE_TABLE_INCREMENT 256
2227 /* A pointer to the base of a table of references to declaration
2228 scopes. This table is a display which tracks the nesting
2229 of declaration scopes at the current scope and containing
2230 scopes. This table is used to find the proper place to
2231 define type declaration DIE's. */
2232 static tree *decl_scope_table;
2234 /* Number of elements currently allocated for the decl_scope_table. */
2235 static int decl_scope_table_allocated;
2237 /* Current level of nesting of declaration scopes. */
2238 static int decl_scope_depth;
2240 /* Size (in elements) of increments by which we may expand the
2241 decl_scope_table. */
2242 #define DECL_SCOPE_TABLE_INCREMENT 64
2244 /* A pointer to the base of a list of references to DIE's that
2245 are uniquely identified by their tag, presence/absence of
2246 children DIE's, and list of attribute/value pairs. */
2247 static dw_die_ref *abbrev_die_table;
2249 /* Number of elements currently allocated for abbrev_die_table. */
2250 static unsigned abbrev_die_table_allocated;
2252 /* Number of elements in type_die_table currently in use. */
2253 static unsigned abbrev_die_table_in_use;
2255 /* Size (in elements) of increments by which we may expand the
2256 abbrev_die_table. */
2257 #define ABBREV_DIE_TABLE_INCREMENT 256
2259 /* A pointer to the base of a table that contains line information
2260 for each source code line in .text in the compilation unit. */
2261 static dw_line_info_ref line_info_table;
2263 /* Number of elements currently allocated for line_info_table. */
2264 static unsigned line_info_table_allocated;
2266 /* Number of elements in separate_line_info_table currently in use. */
2267 static unsigned separate_line_info_table_in_use;
2269 /* A pointer to the base of a table that contains line information
2270 for each source code line outside of .text in the compilation unit. */
2271 static dw_separate_line_info_ref separate_line_info_table;
2273 /* Number of elements currently allocated for separate_line_info_table. */
2274 static unsigned separate_line_info_table_allocated;
2276 /* Number of elements in line_info_table currently in use. */
2277 static unsigned line_info_table_in_use;
2279 /* Size (in elements) of increments by which we may expand the
2281 #define LINE_INFO_TABLE_INCREMENT 1024
2283 /* A pointer to the base of a table that contains a list of publicly
2284 accessible names. */
2285 static pubname_ref pubname_table;
2287 /* Number of elements currently allocated for pubname_table. */
2288 static unsigned pubname_table_allocated;
2290 /* Number of elements in pubname_table currently in use. */
2291 static unsigned pubname_table_in_use;
2293 /* Size (in elements) of increments by which we may expand the
2295 #define PUBNAME_TABLE_INCREMENT 64
2297 /* A pointer to the base of a table that contains a list of publicly
2298 accessible names. */
2299 static arange_ref arange_table;
2301 /* Number of elements currently allocated for arange_table. */
2302 static unsigned arange_table_allocated;
2304 /* Number of elements in arange_table currently in use. */
2305 static unsigned arange_table_in_use;
2307 /* Size (in elements) of increments by which we may expand the
2309 #define ARANGE_TABLE_INCREMENT 64
2311 /* A pointer to the base of a list of incomplete types which might be
2312 completed at some later time. */
2314 static tree *incomplete_types_list;
2316 /* Number of elements currently allocated for the incomplete_types_list. */
2317 static unsigned incomplete_types_allocated;
2319 /* Number of elements of incomplete_types_list currently in use. */
2320 static unsigned incomplete_types;
2322 /* Size (in elements) of increments by which we may expand the incomplete
2323 types list. Actually, a single hunk of space of this size should
2324 be enough for most typical programs. */
2325 #define INCOMPLETE_TYPES_INCREMENT 64
2327 /* Record whether the function being analyzed contains inlined functions. */
2328 static int current_function_has_inlines;
2329 #if 0 && defined (MIPS_DEBUGGING_INFO)
2330 static int comp_unit_has_inlines;
2333 /* Forward declarations for functions defined in this file. */
2335 static void addr_const_to_string PARAMS ((dyn_string_t, rtx));
2336 static char *addr_to_string PARAMS ((rtx));
2337 static int is_pseudo_reg PARAMS ((rtx));
2338 static tree type_main_variant PARAMS ((tree));
2339 static int is_tagged_type PARAMS ((tree));
2340 static const char *dwarf_tag_name PARAMS ((unsigned));
2341 static const char *dwarf_attr_name PARAMS ((unsigned));
2342 static const char *dwarf_form_name PARAMS ((unsigned));
2343 static const char *dwarf_stack_op_name PARAMS ((unsigned));
2345 static const char *dwarf_type_encoding_name PARAMS ((unsigned));
2347 static tree decl_ultimate_origin PARAMS ((tree));
2348 static tree block_ultimate_origin PARAMS ((tree));
2349 static tree decl_class_context PARAMS ((tree));
2350 static void add_dwarf_attr PARAMS ((dw_die_ref, dw_attr_ref));
2351 static void add_AT_flag PARAMS ((dw_die_ref,
2352 enum dwarf_attribute,
2354 static void add_AT_int PARAMS ((dw_die_ref,
2355 enum dwarf_attribute, long));
2356 static void add_AT_unsigned PARAMS ((dw_die_ref,
2357 enum dwarf_attribute,
2359 static void add_AT_long_long PARAMS ((dw_die_ref,
2360 enum dwarf_attribute,
2363 static void add_AT_float PARAMS ((dw_die_ref,
2364 enum dwarf_attribute,
2366 static void add_AT_string PARAMS ((dw_die_ref,
2367 enum dwarf_attribute,
2369 static void add_AT_die_ref PARAMS ((dw_die_ref,
2370 enum dwarf_attribute,
2372 static void add_AT_fde_ref PARAMS ((dw_die_ref,
2373 enum dwarf_attribute,
2375 static void add_AT_loc PARAMS ((dw_die_ref,
2376 enum dwarf_attribute,
2378 static void add_AT_addr PARAMS ((dw_die_ref,
2379 enum dwarf_attribute,
2381 static void add_AT_lbl_id PARAMS ((dw_die_ref,
2382 enum dwarf_attribute,
2384 static void add_AT_lbl_offset PARAMS ((dw_die_ref,
2385 enum dwarf_attribute,
2387 static dw_attr_ref get_AT PARAMS ((dw_die_ref,
2388 enum dwarf_attribute));
2389 static const char *get_AT_low_pc PARAMS ((dw_die_ref));
2390 static const char *get_AT_hi_pc PARAMS ((dw_die_ref));
2391 static const char *get_AT_string PARAMS ((dw_die_ref,
2392 enum dwarf_attribute));
2393 static int get_AT_flag PARAMS ((dw_die_ref,
2394 enum dwarf_attribute));
2395 static unsigned get_AT_unsigned PARAMS ((dw_die_ref,
2396 enum dwarf_attribute));
2397 static int is_c_family PARAMS ((void));
2398 static int is_fortran PARAMS ((void));
2399 static void remove_AT PARAMS ((dw_die_ref,
2400 enum dwarf_attribute));
2401 static void remove_children PARAMS ((dw_die_ref));
2402 static void add_child_die PARAMS ((dw_die_ref, dw_die_ref));
2403 static dw_die_ref new_die PARAMS ((enum dwarf_tag, dw_die_ref));
2404 static dw_die_ref lookup_type_die PARAMS ((tree));
2405 static void equate_type_number_to_die PARAMS ((tree, dw_die_ref));
2406 static dw_die_ref lookup_decl_die PARAMS ((tree));
2407 static void equate_decl_number_to_die PARAMS ((tree, dw_die_ref));
2408 static dw_loc_descr_ref new_loc_descr PARAMS ((enum dwarf_location_atom,
2411 static void add_loc_descr PARAMS ((dw_loc_descr_ref *,
2413 static void print_spaces PARAMS ((FILE *));
2414 static void print_die PARAMS ((dw_die_ref, FILE *));
2415 static void print_dwarf_line_table PARAMS ((FILE *));
2416 static void add_sibling_attributes PARAMS ((dw_die_ref));
2417 static void build_abbrev_table PARAMS ((dw_die_ref));
2418 static unsigned long size_of_string PARAMS ((const char *));
2419 static unsigned long size_of_loc_descr PARAMS ((dw_loc_descr_ref));
2420 static unsigned long size_of_locs PARAMS ((dw_loc_descr_ref));
2421 static int constant_size PARAMS ((long unsigned));
2422 static unsigned long size_of_die PARAMS ((dw_die_ref));
2423 static void calc_die_sizes PARAMS ((dw_die_ref));
2424 static unsigned long size_of_line_prolog PARAMS ((void));
2425 static unsigned long size_of_pubnames PARAMS ((void));
2426 static unsigned long size_of_aranges PARAMS ((void));
2427 static enum dwarf_form value_format PARAMS ((dw_attr_ref));
2428 static void output_value_format PARAMS ((dw_attr_ref));
2429 static void output_abbrev_section PARAMS ((void));
2430 static void output_loc_operands PARAMS ((dw_loc_descr_ref));
2431 static void output_die PARAMS ((dw_die_ref));
2432 static void output_compilation_unit_header PARAMS ((void));
2433 static const char *dwarf2_name PARAMS ((tree, int));
2434 static void add_pubname PARAMS ((tree, dw_die_ref));
2435 static void output_pubnames PARAMS ((void));
2436 static void add_arange PARAMS ((tree, dw_die_ref));
2437 static void output_aranges PARAMS ((void));
2438 static void output_line_info PARAMS ((void));
2439 static int is_body_block PARAMS ((tree));
2440 static dw_die_ref base_type_die PARAMS ((tree));
2441 static tree root_type PARAMS ((tree));
2442 static int is_base_type PARAMS ((tree));
2443 static dw_die_ref modified_type_die PARAMS ((tree, int, int, dw_die_ref));
2444 static int type_is_enum PARAMS ((tree));
2445 static dw_loc_descr_ref reg_loc_descriptor PARAMS ((rtx));
2446 static dw_loc_descr_ref based_loc_descr PARAMS ((unsigned, long));
2447 static int is_based_loc PARAMS ((rtx));
2448 static dw_loc_descr_ref mem_loc_descriptor PARAMS ((rtx, enum machine_mode mode));
2449 static dw_loc_descr_ref concat_loc_descriptor PARAMS ((rtx, rtx));
2450 static dw_loc_descr_ref loc_descriptor PARAMS ((rtx));
2451 static unsigned ceiling PARAMS ((unsigned, unsigned));
2452 static tree field_type PARAMS ((tree));
2453 static unsigned simple_type_align_in_bits PARAMS ((tree));
2454 static unsigned simple_type_size_in_bits PARAMS ((tree));
2455 static unsigned field_byte_offset PARAMS ((tree));
2456 static void add_AT_location_description PARAMS ((dw_die_ref,
2457 enum dwarf_attribute, rtx));
2458 static void add_data_member_location_attribute PARAMS ((dw_die_ref, tree));
2459 static void add_const_value_attribute PARAMS ((dw_die_ref, rtx));
2460 static void add_location_or_const_value_attribute PARAMS ((dw_die_ref, tree));
2461 static void add_name_attribute PARAMS ((dw_die_ref, const char *));
2462 static void add_bound_info PARAMS ((dw_die_ref,
2463 enum dwarf_attribute, tree));
2464 static void add_subscript_info PARAMS ((dw_die_ref, tree));
2465 static void add_byte_size_attribute PARAMS ((dw_die_ref, tree));
2466 static void add_bit_offset_attribute PARAMS ((dw_die_ref, tree));
2467 static void add_bit_size_attribute PARAMS ((dw_die_ref, tree));
2468 static void add_prototyped_attribute PARAMS ((dw_die_ref, tree));
2469 static void add_abstract_origin_attribute PARAMS ((dw_die_ref, tree));
2470 static void add_pure_or_virtual_attribute PARAMS ((dw_die_ref, tree));
2471 static void add_src_coords_attributes PARAMS ((dw_die_ref, tree));
2472 static void add_name_and_src_coords_attributes PARAMS ((dw_die_ref, tree));
2473 static void push_decl_scope PARAMS ((tree));
2474 static dw_die_ref scope_die_for PARAMS ((tree, dw_die_ref));
2475 static void pop_decl_scope PARAMS ((void));
2476 static void add_type_attribute PARAMS ((dw_die_ref, tree, int, int,
2478 static char *type_tag PARAMS ((tree));
2479 static tree member_declared_type PARAMS ((tree));
2481 static char *decl_start_label PARAMS ((tree));
2483 static void gen_array_type_die PARAMS ((tree, dw_die_ref));
2484 static void gen_set_type_die PARAMS ((tree, dw_die_ref));
2486 static void gen_entry_point_die PARAMS ((tree, dw_die_ref));
2488 static void gen_inlined_enumeration_type_die PARAMS ((tree, dw_die_ref));
2489 static void gen_inlined_structure_type_die PARAMS ((tree, dw_die_ref));
2490 static void gen_inlined_union_type_die PARAMS ((tree, dw_die_ref));
2491 static void gen_enumeration_type_die PARAMS ((tree, dw_die_ref));
2492 static dw_die_ref gen_formal_parameter_die PARAMS ((tree, dw_die_ref));
2493 static void gen_unspecified_parameters_die PARAMS ((tree, dw_die_ref));
2494 static void gen_formal_types_die PARAMS ((tree, dw_die_ref));
2495 static void gen_subprogram_die PARAMS ((tree, dw_die_ref));
2496 static void gen_variable_die PARAMS ((tree, dw_die_ref));
2497 static void gen_label_die PARAMS ((tree, dw_die_ref));
2498 static void gen_lexical_block_die PARAMS ((tree, dw_die_ref, int));
2499 static void gen_inlined_subroutine_die PARAMS ((tree, dw_die_ref, int));
2500 static void gen_field_die PARAMS ((tree, dw_die_ref));
2501 static void gen_ptr_to_mbr_type_die PARAMS ((tree, dw_die_ref));
2502 static dw_die_ref gen_compile_unit_die PARAMS ((const char *));
2503 static void gen_string_type_die PARAMS ((tree, dw_die_ref));
2504 static void gen_inheritance_die PARAMS ((tree, dw_die_ref));
2505 static void gen_member_die PARAMS ((tree, dw_die_ref));
2506 static void gen_struct_or_union_type_die PARAMS ((tree, dw_die_ref));
2507 static void gen_subroutine_type_die PARAMS ((tree, dw_die_ref));
2508 static void gen_typedef_die PARAMS ((tree, dw_die_ref));
2509 static void gen_type_die PARAMS ((tree, dw_die_ref));
2510 static void gen_tagged_type_instantiation_die PARAMS ((tree, dw_die_ref));
2511 static void gen_block_die PARAMS ((tree, dw_die_ref, int));
2512 static void decls_for_scope PARAMS ((tree, dw_die_ref, int));
2513 static int is_redundant_typedef PARAMS ((tree));
2514 static void gen_decl_die PARAMS ((tree, dw_die_ref));
2515 static unsigned lookup_filename PARAMS ((const char *));
2516 static void add_incomplete_type PARAMS ((tree));
2517 static void retry_incomplete_types PARAMS ((void));
2518 static void gen_type_die_for_member PARAMS ((tree, tree, dw_die_ref));
2519 static void gen_abstract_function PARAMS ((tree));
2521 /* Section names used to hold DWARF debugging information. */
2522 #ifndef DEBUG_INFO_SECTION
2523 #define DEBUG_INFO_SECTION ".debug_info"
2525 #ifndef ABBREV_SECTION
2526 #define ABBREV_SECTION ".debug_abbrev"
2528 #ifndef ARANGES_SECTION
2529 #define ARANGES_SECTION ".debug_aranges"
2531 #ifndef DW_MACINFO_SECTION
2532 #define DW_MACINFO_SECTION ".debug_macinfo"
2534 #ifndef DEBUG_LINE_SECTION
2535 #define DEBUG_LINE_SECTION ".debug_line"
2538 #define LOC_SECTION ".debug_loc"
2540 #ifndef PUBNAMES_SECTION
2541 #define PUBNAMES_SECTION ".debug_pubnames"
2544 #define STR_SECTION ".debug_str"
2547 /* Standard ELF section names for compiled code and data. */
2548 #ifndef TEXT_SECTION
2549 #define TEXT_SECTION ".text"
2551 #ifndef DATA_SECTION
2552 #define DATA_SECTION ".data"
2555 #define BSS_SECTION ".bss"
2558 /* Labels we insert at beginning sections we can reference instead of
2559 the section names themselves. */
2561 #ifndef TEXT_SECTION_LABEL
2562 #define TEXT_SECTION_LABEL "Ltext"
2564 #ifndef DEBUG_LINE_SECTION_LABEL
2565 #define DEBUG_LINE_SECTION_LABEL "Ldebug_line"
2567 #ifndef DEBUG_INFO_SECTION_LABEL
2568 #define DEBUG_INFO_SECTION_LABEL "Ldebug_info"
2570 #ifndef ABBREV_SECTION_LABEL
2571 #define ABBREV_SECTION_LABEL "Ldebug_abbrev"
2575 /* Definitions of defaults for formats and names of various special
2576 (artificial) labels which may be generated within this file (when the -g
2577 options is used and DWARF_DEBUGGING_INFO is in effect.
2578 If necessary, these may be overridden from within the tm.h file, but
2579 typically, overriding these defaults is unnecessary. */
2581 static char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
2582 static char text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
2583 static char abbrev_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
2584 static char debug_info_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
2585 static char debug_line_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
2587 #ifndef TEXT_END_LABEL
2588 #define TEXT_END_LABEL "Letext"
2590 #ifndef DATA_END_LABEL
2591 #define DATA_END_LABEL "Ledata"
2593 #ifndef BSS_END_LABEL
2594 #define BSS_END_LABEL "Lebss"
2596 #ifndef INSN_LABEL_FMT
2597 #define INSN_LABEL_FMT "LI%u_"
2599 #ifndef BLOCK_BEGIN_LABEL
2600 #define BLOCK_BEGIN_LABEL "LBB"
2602 #ifndef BLOCK_END_LABEL
2603 #define BLOCK_END_LABEL "LBE"
2605 #ifndef BODY_BEGIN_LABEL
2606 #define BODY_BEGIN_LABEL "Lbb"
2608 #ifndef BODY_END_LABEL
2609 #define BODY_END_LABEL "Lbe"
2611 #ifndef LINE_CODE_LABEL
2612 #define LINE_CODE_LABEL "LM"
2614 #ifndef SEPARATE_LINE_CODE_LABEL
2615 #define SEPARATE_LINE_CODE_LABEL "LSM"
2618 /* Convert a reference to the assembler name of a C-level name. This
2619 macro has the same effect as ASM_OUTPUT_LABELREF, but copies to
2620 a string rather than writing to a file. */
2621 #ifndef ASM_NAME_TO_STRING
2622 #define ASM_NAME_TO_STRING(STR, NAME) \
2624 if ((NAME)[0] == '*') \
2625 dyn_string_append (STR, NAME + 1); \
2628 const char *newstr; \
2629 STRIP_NAME_ENCODING (newstr, NAME); \
2630 dyn_string_append (STR, user_label_prefix); \
2631 dyn_string_append (STR, newstr); \
2637 /* We allow a language front-end to designate a function that is to be
2638 called to "demangle" any name before it it put into a DIE. */
2640 static const char *(*demangle_name_func) PARAMS ((const char *));
2643 dwarf2out_set_demangle_name_func (func)
2644 const char *(*func) PARAMS ((const char *));
2646 demangle_name_func = func;
2649 /* Convert an integer constant expression into assembler syntax. Addition
2650 and subtraction are the only arithmetic that may appear in these
2651 expressions. This is an adaptation of output_addr_const in final.c.
2652 Here, the target of the conversion is a string buffer. We can't use
2653 output_addr_const directly, because it writes to a file. */
2656 addr_const_to_string (str, x)
2663 switch (GET_CODE (x))
2667 dyn_string_append (str, ",");
2673 ASM_NAME_TO_STRING (str, XSTR (x, 0));
2677 ASM_GENERATE_INTERNAL_LABEL (buf1, "L", CODE_LABEL_NUMBER (XEXP (x, 0)));
2678 ASM_NAME_TO_STRING (str, buf1);
2682 ASM_GENERATE_INTERNAL_LABEL (buf1, "L", CODE_LABEL_NUMBER (x));
2683 ASM_NAME_TO_STRING (str, buf1);
2687 sprintf (buf1, HOST_WIDE_INT_PRINT_DEC, INTVAL (x));
2688 dyn_string_append (str, buf1);
2692 /* This used to output parentheses around the expression, but that does
2693 not work on the 386 (either ATT or BSD assembler). */
2694 addr_const_to_string (str, XEXP (x, 0));
2698 if (GET_MODE (x) == VOIDmode)
2700 /* We can use %d if the number is one word and positive. */
2701 if (CONST_DOUBLE_HIGH (x))
2702 sprintf (buf1, HOST_WIDE_INT_PRINT_DOUBLE_HEX,
2703 CONST_DOUBLE_HIGH (x), CONST_DOUBLE_LOW (x));
2704 else if (CONST_DOUBLE_LOW (x) < 0)
2705 sprintf (buf1, HOST_WIDE_INT_PRINT_HEX, CONST_DOUBLE_LOW (x));
2707 sprintf (buf1, HOST_WIDE_INT_PRINT_DEC,
2708 CONST_DOUBLE_LOW (x));
2709 dyn_string_append (str, buf1);
2712 /* We can't handle floating point constants; PRINT_OPERAND must
2714 output_operand_lossage ("floating constant misused");
2718 /* Some assemblers need integer constants to appear last (eg masm). */
2719 if (GET_CODE (XEXP (x, 0)) == CONST_INT)
2721 addr_const_to_string (str, XEXP (x, 1));
2722 if (INTVAL (XEXP (x, 0)) >= 0)
2723 dyn_string_append (str, "+");
2725 addr_const_to_string (str, XEXP (x, 0));
2729 addr_const_to_string (str, XEXP (x, 0));
2730 if (INTVAL (XEXP (x, 1)) >= 0)
2731 dyn_string_append (str, "+");
2733 addr_const_to_string (str, XEXP (x, 1));
2738 /* Avoid outputting things like x-x or x+5-x, since some assemblers
2739 can't handle that. */
2740 x = simplify_subtraction (x);
2741 if (GET_CODE (x) != MINUS)
2744 addr_const_to_string (str, XEXP (x, 0));
2745 dyn_string_append (str, "-");
2746 if (GET_CODE (XEXP (x, 1)) == CONST_INT
2747 && INTVAL (XEXP (x, 1)) < 0)
2749 dyn_string_append (str, ASM_OPEN_PAREN);
2750 addr_const_to_string (str, XEXP (x, 1));
2751 dyn_string_append (str, ASM_CLOSE_PAREN);
2754 addr_const_to_string (str, XEXP (x, 1));
2759 addr_const_to_string (str, XEXP (x, 0));
2763 output_operand_lossage ("invalid expression as operand");
2767 /* Convert an address constant to a string, and return a pointer to
2768 a copy of the result, located on the heap. */
2774 dyn_string_t ds = dyn_string_new (256);
2777 addr_const_to_string (ds, x);
2779 /* Return the dynamically allocated string, but free the
2780 dyn_string_t itself. */
2786 /* Test if rtl node points to a pseudo register. */
2792 return (((GET_CODE (rtl) == REG) && (REGNO (rtl) >= FIRST_PSEUDO_REGISTER))
2793 || ((GET_CODE (rtl) == SUBREG)
2794 && (REGNO (XEXP (rtl, 0)) >= FIRST_PSEUDO_REGISTER)));
2797 /* Return a reference to a type, with its const and volatile qualifiers
2801 type_main_variant (type)
2804 type = TYPE_MAIN_VARIANT (type);
2806 /* There really should be only one main variant among any group of variants
2807 of a given type (and all of the MAIN_VARIANT values for all members of
2808 the group should point to that one type) but sometimes the C front-end
2809 messes this up for array types, so we work around that bug here. */
2811 if (TREE_CODE (type) == ARRAY_TYPE)
2812 while (type != TYPE_MAIN_VARIANT (type))
2813 type = TYPE_MAIN_VARIANT (type);
2818 /* Return non-zero if the given type node represents a tagged type. */
2821 is_tagged_type (type)
2824 register enum tree_code code = TREE_CODE (type);
2826 return (code == RECORD_TYPE || code == UNION_TYPE
2827 || code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE);
2830 /* Convert a DIE tag into its string name. */
2833 dwarf_tag_name (tag)
2834 register unsigned tag;
2838 case DW_TAG_padding:
2839 return "DW_TAG_padding";
2840 case DW_TAG_array_type:
2841 return "DW_TAG_array_type";
2842 case DW_TAG_class_type:
2843 return "DW_TAG_class_type";
2844 case DW_TAG_entry_point:
2845 return "DW_TAG_entry_point";
2846 case DW_TAG_enumeration_type:
2847 return "DW_TAG_enumeration_type";
2848 case DW_TAG_formal_parameter:
2849 return "DW_TAG_formal_parameter";
2850 case DW_TAG_imported_declaration:
2851 return "DW_TAG_imported_declaration";
2853 return "DW_TAG_label";
2854 case DW_TAG_lexical_block:
2855 return "DW_TAG_lexical_block";
2857 return "DW_TAG_member";
2858 case DW_TAG_pointer_type:
2859 return "DW_TAG_pointer_type";
2860 case DW_TAG_reference_type:
2861 return "DW_TAG_reference_type";
2862 case DW_TAG_compile_unit:
2863 return "DW_TAG_compile_unit";
2864 case DW_TAG_string_type:
2865 return "DW_TAG_string_type";
2866 case DW_TAG_structure_type:
2867 return "DW_TAG_structure_type";
2868 case DW_TAG_subroutine_type:
2869 return "DW_TAG_subroutine_type";
2870 case DW_TAG_typedef:
2871 return "DW_TAG_typedef";
2872 case DW_TAG_union_type:
2873 return "DW_TAG_union_type";
2874 case DW_TAG_unspecified_parameters:
2875 return "DW_TAG_unspecified_parameters";
2876 case DW_TAG_variant:
2877 return "DW_TAG_variant";
2878 case DW_TAG_common_block:
2879 return "DW_TAG_common_block";
2880 case DW_TAG_common_inclusion:
2881 return "DW_TAG_common_inclusion";
2882 case DW_TAG_inheritance:
2883 return "DW_TAG_inheritance";
2884 case DW_TAG_inlined_subroutine:
2885 return "DW_TAG_inlined_subroutine";
2887 return "DW_TAG_module";
2888 case DW_TAG_ptr_to_member_type:
2889 return "DW_TAG_ptr_to_member_type";
2890 case DW_TAG_set_type:
2891 return "DW_TAG_set_type";
2892 case DW_TAG_subrange_type:
2893 return "DW_TAG_subrange_type";
2894 case DW_TAG_with_stmt:
2895 return "DW_TAG_with_stmt";
2896 case DW_TAG_access_declaration:
2897 return "DW_TAG_access_declaration";
2898 case DW_TAG_base_type:
2899 return "DW_TAG_base_type";
2900 case DW_TAG_catch_block:
2901 return "DW_TAG_catch_block";
2902 case DW_TAG_const_type:
2903 return "DW_TAG_const_type";
2904 case DW_TAG_constant:
2905 return "DW_TAG_constant";
2906 case DW_TAG_enumerator:
2907 return "DW_TAG_enumerator";
2908 case DW_TAG_file_type:
2909 return "DW_TAG_file_type";
2911 return "DW_TAG_friend";
2912 case DW_TAG_namelist:
2913 return "DW_TAG_namelist";
2914 case DW_TAG_namelist_item:
2915 return "DW_TAG_namelist_item";
2916 case DW_TAG_packed_type:
2917 return "DW_TAG_packed_type";
2918 case DW_TAG_subprogram:
2919 return "DW_TAG_subprogram";
2920 case DW_TAG_template_type_param:
2921 return "DW_TAG_template_type_param";
2922 case DW_TAG_template_value_param:
2923 return "DW_TAG_template_value_param";
2924 case DW_TAG_thrown_type:
2925 return "DW_TAG_thrown_type";
2926 case DW_TAG_try_block:
2927 return "DW_TAG_try_block";
2928 case DW_TAG_variant_part:
2929 return "DW_TAG_variant_part";
2930 case DW_TAG_variable:
2931 return "DW_TAG_variable";
2932 case DW_TAG_volatile_type:
2933 return "DW_TAG_volatile_type";
2934 case DW_TAG_MIPS_loop:
2935 return "DW_TAG_MIPS_loop";
2936 case DW_TAG_format_label:
2937 return "DW_TAG_format_label";
2938 case DW_TAG_function_template:
2939 return "DW_TAG_function_template";
2940 case DW_TAG_class_template:
2941 return "DW_TAG_class_template";
2943 return "DW_TAG_<unknown>";
2947 /* Convert a DWARF attribute code into its string name. */
2950 dwarf_attr_name (attr)
2951 register unsigned attr;
2956 return "DW_AT_sibling";
2957 case DW_AT_location:
2958 return "DW_AT_location";
2960 return "DW_AT_name";
2961 case DW_AT_ordering:
2962 return "DW_AT_ordering";
2963 case DW_AT_subscr_data:
2964 return "DW_AT_subscr_data";
2965 case DW_AT_byte_size:
2966 return "DW_AT_byte_size";
2967 case DW_AT_bit_offset:
2968 return "DW_AT_bit_offset";
2969 case DW_AT_bit_size:
2970 return "DW_AT_bit_size";
2971 case DW_AT_element_list:
2972 return "DW_AT_element_list";
2973 case DW_AT_stmt_list:
2974 return "DW_AT_stmt_list";
2976 return "DW_AT_low_pc";
2978 return "DW_AT_high_pc";
2979 case DW_AT_language:
2980 return "DW_AT_language";
2982 return "DW_AT_member";
2984 return "DW_AT_discr";
2985 case DW_AT_discr_value:
2986 return "DW_AT_discr_value";
2987 case DW_AT_visibility:
2988 return "DW_AT_visibility";
2990 return "DW_AT_import";
2991 case DW_AT_string_length:
2992 return "DW_AT_string_length";
2993 case DW_AT_common_reference:
2994 return "DW_AT_common_reference";
2995 case DW_AT_comp_dir:
2996 return "DW_AT_comp_dir";
2997 case DW_AT_const_value:
2998 return "DW_AT_const_value";
2999 case DW_AT_containing_type:
3000 return "DW_AT_containing_type";
3001 case DW_AT_default_value:
3002 return "DW_AT_default_value";
3004 return "DW_AT_inline";
3005 case DW_AT_is_optional:
3006 return "DW_AT_is_optional";
3007 case DW_AT_lower_bound:
3008 return "DW_AT_lower_bound";
3009 case DW_AT_producer:
3010 return "DW_AT_producer";
3011 case DW_AT_prototyped:
3012 return "DW_AT_prototyped";
3013 case DW_AT_return_addr:
3014 return "DW_AT_return_addr";
3015 case DW_AT_start_scope:
3016 return "DW_AT_start_scope";
3017 case DW_AT_stride_size:
3018 return "DW_AT_stride_size";
3019 case DW_AT_upper_bound:
3020 return "DW_AT_upper_bound";
3021 case DW_AT_abstract_origin:
3022 return "DW_AT_abstract_origin";
3023 case DW_AT_accessibility:
3024 return "DW_AT_accessibility";
3025 case DW_AT_address_class:
3026 return "DW_AT_address_class";
3027 case DW_AT_artificial:
3028 return "DW_AT_artificial";
3029 case DW_AT_base_types:
3030 return "DW_AT_base_types";
3031 case DW_AT_calling_convention:
3032 return "DW_AT_calling_convention";
3034 return "DW_AT_count";
3035 case DW_AT_data_member_location:
3036 return "DW_AT_data_member_location";
3037 case DW_AT_decl_column:
3038 return "DW_AT_decl_column";
3039 case DW_AT_decl_file:
3040 return "DW_AT_decl_file";
3041 case DW_AT_decl_line:
3042 return "DW_AT_decl_line";
3043 case DW_AT_declaration:
3044 return "DW_AT_declaration";
3045 case DW_AT_discr_list:
3046 return "DW_AT_discr_list";
3047 case DW_AT_encoding:
3048 return "DW_AT_encoding";
3049 case DW_AT_external:
3050 return "DW_AT_external";
3051 case DW_AT_frame_base:
3052 return "DW_AT_frame_base";
3054 return "DW_AT_friend";
3055 case DW_AT_identifier_case:
3056 return "DW_AT_identifier_case";
3057 case DW_AT_macro_info:
3058 return "DW_AT_macro_info";
3059 case DW_AT_namelist_items:
3060 return "DW_AT_namelist_items";
3061 case DW_AT_priority:
3062 return "DW_AT_priority";
3064 return "DW_AT_segment";
3065 case DW_AT_specification:
3066 return "DW_AT_specification";
3067 case DW_AT_static_link:
3068 return "DW_AT_static_link";
3070 return "DW_AT_type";
3071 case DW_AT_use_location:
3072 return "DW_AT_use_location";
3073 case DW_AT_variable_parameter:
3074 return "DW_AT_variable_parameter";
3075 case DW_AT_virtuality:
3076 return "DW_AT_virtuality";
3077 case DW_AT_vtable_elem_location:
3078 return "DW_AT_vtable_elem_location";
3080 case DW_AT_MIPS_fde:
3081 return "DW_AT_MIPS_fde";
3082 case DW_AT_MIPS_loop_begin:
3083 return "DW_AT_MIPS_loop_begin";
3084 case DW_AT_MIPS_tail_loop_begin:
3085 return "DW_AT_MIPS_tail_loop_begin";
3086 case DW_AT_MIPS_epilog_begin:
3087 return "DW_AT_MIPS_epilog_begin";
3088 case DW_AT_MIPS_loop_unroll_factor:
3089 return "DW_AT_MIPS_loop_unroll_factor";
3090 case DW_AT_MIPS_software_pipeline_depth:
3091 return "DW_AT_MIPS_software_pipeline_depth";
3092 case DW_AT_MIPS_linkage_name:
3093 return "DW_AT_MIPS_linkage_name";
3094 case DW_AT_MIPS_stride:
3095 return "DW_AT_MIPS_stride";
3096 case DW_AT_MIPS_abstract_name:
3097 return "DW_AT_MIPS_abstract_name";
3098 case DW_AT_MIPS_clone_origin:
3099 return "DW_AT_MIPS_clone_origin";
3100 case DW_AT_MIPS_has_inlines:
3101 return "DW_AT_MIPS_has_inlines";
3103 case DW_AT_sf_names:
3104 return "DW_AT_sf_names";
3105 case DW_AT_src_info:
3106 return "DW_AT_src_info";
3107 case DW_AT_mac_info:
3108 return "DW_AT_mac_info";
3109 case DW_AT_src_coords:
3110 return "DW_AT_src_coords";
3111 case DW_AT_body_begin:
3112 return "DW_AT_body_begin";
3113 case DW_AT_body_end:
3114 return "DW_AT_body_end";
3116 return "DW_AT_<unknown>";
3120 /* Convert a DWARF value form code into its string name. */
3123 dwarf_form_name (form)
3124 register unsigned form;
3129 return "DW_FORM_addr";
3130 case DW_FORM_block2:
3131 return "DW_FORM_block2";
3132 case DW_FORM_block4:
3133 return "DW_FORM_block4";
3135 return "DW_FORM_data2";
3137 return "DW_FORM_data4";
3139 return "DW_FORM_data8";
3140 case DW_FORM_string:
3141 return "DW_FORM_string";
3143 return "DW_FORM_block";
3144 case DW_FORM_block1:
3145 return "DW_FORM_block1";
3147 return "DW_FORM_data1";
3149 return "DW_FORM_flag";
3151 return "DW_FORM_sdata";
3153 return "DW_FORM_strp";
3155 return "DW_FORM_udata";
3156 case DW_FORM_ref_addr:
3157 return "DW_FORM_ref_addr";
3159 return "DW_FORM_ref1";
3161 return "DW_FORM_ref2";
3163 return "DW_FORM_ref4";
3165 return "DW_FORM_ref8";
3166 case DW_FORM_ref_udata:
3167 return "DW_FORM_ref_udata";
3168 case DW_FORM_indirect:
3169 return "DW_FORM_indirect";
3171 return "DW_FORM_<unknown>";
3175 /* Convert a DWARF stack opcode into its string name. */
3178 dwarf_stack_op_name (op)
3179 register unsigned op;
3184 return "DW_OP_addr";
3186 return "DW_OP_deref";
3188 return "DW_OP_const1u";
3190 return "DW_OP_const1s";
3192 return "DW_OP_const2u";
3194 return "DW_OP_const2s";
3196 return "DW_OP_const4u";
3198 return "DW_OP_const4s";
3200 return "DW_OP_const8u";
3202 return "DW_OP_const8s";
3204 return "DW_OP_constu";
3206 return "DW_OP_consts";
3210 return "DW_OP_drop";
3212 return "DW_OP_over";
3214 return "DW_OP_pick";
3216 return "DW_OP_swap";
3220 return "DW_OP_xderef";
3228 return "DW_OP_minus";
3240 return "DW_OP_plus";
3241 case DW_OP_plus_uconst:
3242 return "DW_OP_plus_uconst";
3248 return "DW_OP_shra";
3266 return "DW_OP_skip";
3268 return "DW_OP_lit0";
3270 return "DW_OP_lit1";
3272 return "DW_OP_lit2";
3274 return "DW_OP_lit3";
3276 return "DW_OP_lit4";
3278 return "DW_OP_lit5";
3280 return "DW_OP_lit6";
3282 return "DW_OP_lit7";
3284 return "DW_OP_lit8";
3286 return "DW_OP_lit9";
3288 return "DW_OP_lit10";
3290 return "DW_OP_lit11";
3292 return "DW_OP_lit12";
3294 return "DW_OP_lit13";
3296 return "DW_OP_lit14";
3298 return "DW_OP_lit15";
3300 return "DW_OP_lit16";
3302 return "DW_OP_lit17";
3304 return "DW_OP_lit18";
3306 return "DW_OP_lit19";
3308 return "DW_OP_lit20";
3310 return "DW_OP_lit21";
3312 return "DW_OP_lit22";
3314 return "DW_OP_lit23";
3316 return "DW_OP_lit24";
3318 return "DW_OP_lit25";
3320 return "DW_OP_lit26";
3322 return "DW_OP_lit27";
3324 return "DW_OP_lit28";
3326 return "DW_OP_lit29";
3328 return "DW_OP_lit30";
3330 return "DW_OP_lit31";
3332 return "DW_OP_reg0";
3334 return "DW_OP_reg1";
3336 return "DW_OP_reg2";
3338 return "DW_OP_reg3";
3340 return "DW_OP_reg4";
3342 return "DW_OP_reg5";
3344 return "DW_OP_reg6";
3346 return "DW_OP_reg7";
3348 return "DW_OP_reg8";
3350 return "DW_OP_reg9";
3352 return "DW_OP_reg10";
3354 return "DW_OP_reg11";
3356 return "DW_OP_reg12";
3358 return "DW_OP_reg13";
3360 return "DW_OP_reg14";
3362 return "DW_OP_reg15";
3364 return "DW_OP_reg16";
3366 return "DW_OP_reg17";
3368 return "DW_OP_reg18";
3370 return "DW_OP_reg19";
3372 return "DW_OP_reg20";
3374 return "DW_OP_reg21";
3376 return "DW_OP_reg22";
3378 return "DW_OP_reg23";
3380 return "DW_OP_reg24";
3382 return "DW_OP_reg25";
3384 return "DW_OP_reg26";
3386 return "DW_OP_reg27";
3388 return "DW_OP_reg28";
3390 return "DW_OP_reg29";
3392 return "DW_OP_reg30";
3394 return "DW_OP_reg31";
3396 return "DW_OP_breg0";
3398 return "DW_OP_breg1";
3400 return "DW_OP_breg2";
3402 return "DW_OP_breg3";
3404 return "DW_OP_breg4";
3406 return "DW_OP_breg5";
3408 return "DW_OP_breg6";
3410 return "DW_OP_breg7";
3412 return "DW_OP_breg8";
3414 return "DW_OP_breg9";
3416 return "DW_OP_breg10";
3418 return "DW_OP_breg11";
3420 return "DW_OP_breg12";
3422 return "DW_OP_breg13";
3424 return "DW_OP_breg14";
3426 return "DW_OP_breg15";
3428 return "DW_OP_breg16";
3430 return "DW_OP_breg17";
3432 return "DW_OP_breg18";
3434 return "DW_OP_breg19";
3436 return "DW_OP_breg20";
3438 return "DW_OP_breg21";
3440 return "DW_OP_breg22";
3442 return "DW_OP_breg23";
3444 return "DW_OP_breg24";
3446 return "DW_OP_breg25";
3448 return "DW_OP_breg26";
3450 return "DW_OP_breg27";
3452 return "DW_OP_breg28";
3454 return "DW_OP_breg29";
3456 return "DW_OP_breg30";
3458 return "DW_OP_breg31";
3460 return "DW_OP_regx";
3462 return "DW_OP_fbreg";
3464 return "DW_OP_bregx";
3466 return "DW_OP_piece";
3467 case DW_OP_deref_size:
3468 return "DW_OP_deref_size";
3469 case DW_OP_xderef_size:
3470 return "DW_OP_xderef_size";
3474 return "OP_<unknown>";
3478 /* Convert a DWARF type code into its string name. */
3482 dwarf_type_encoding_name (enc)
3483 register unsigned enc;
3487 case DW_ATE_address:
3488 return "DW_ATE_address";
3489 case DW_ATE_boolean:
3490 return "DW_ATE_boolean";
3491 case DW_ATE_complex_float:
3492 return "DW_ATE_complex_float";
3494 return "DW_ATE_float";
3496 return "DW_ATE_signed";
3497 case DW_ATE_signed_char:
3498 return "DW_ATE_signed_char";
3499 case DW_ATE_unsigned:
3500 return "DW_ATE_unsigned";
3501 case DW_ATE_unsigned_char:
3502 return "DW_ATE_unsigned_char";
3504 return "DW_ATE_<unknown>";
3509 /* Determine the "ultimate origin" of a decl. The decl may be an inlined
3510 instance of an inlined instance of a decl which is local to an inline
3511 function, so we have to trace all of the way back through the origin chain
3512 to find out what sort of node actually served as the original seed for the
3516 decl_ultimate_origin (decl)
3519 /* output_inline_function sets DECL_ABSTRACT_ORIGIN for all the
3520 nodes in the function to point to themselves; ignore that if
3521 we're trying to output the abstract instance of this function. */
3522 if (DECL_ABSTRACT (decl) && DECL_ABSTRACT_ORIGIN (decl) == decl)
3525 #ifdef ENABLE_CHECKING
3526 if (DECL_FROM_INLINE (DECL_ORIGIN (decl)))
3527 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
3528 most distant ancestor, this should never happen. */
3532 return DECL_ABSTRACT_ORIGIN (decl);
3535 /* Determine the "ultimate origin" of a block. The block may be an inlined
3536 instance of an inlined instance of a block which is local to an inline
3537 function, so we have to trace all of the way back through the origin chain
3538 to find out what sort of node actually served as the original seed for the
3542 block_ultimate_origin (block)
3543 register tree block;
3545 register tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block);
3547 /* output_inline_function sets BLOCK_ABSTRACT_ORIGIN for all the
3548 nodes in the function to point to themselves; ignore that if
3549 we're trying to output the abstract instance of this function. */
3550 if (BLOCK_ABSTRACT (block) && immediate_origin == block)
3553 if (immediate_origin == NULL_TREE)
3557 register tree ret_val;
3558 register tree lookahead = immediate_origin;
3562 ret_val = lookahead;
3563 lookahead = (TREE_CODE (ret_val) == BLOCK)
3564 ? BLOCK_ABSTRACT_ORIGIN (ret_val)
3567 while (lookahead != NULL && lookahead != ret_val);
3573 /* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT
3574 of a virtual function may refer to a base class, so we check the 'this'
3578 decl_class_context (decl)
3581 tree context = NULL_TREE;
3583 if (TREE_CODE (decl) != FUNCTION_DECL || ! DECL_VINDEX (decl))
3584 context = DECL_CONTEXT (decl);
3586 context = TYPE_MAIN_VARIANT
3587 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
3589 if (context && TREE_CODE_CLASS (TREE_CODE (context)) != 't')
3590 context = NULL_TREE;
3595 /* Add an attribute/value pair to a DIE. We build the lists up in reverse
3596 addition order, and correct that in add_sibling_attributes. */
3599 add_dwarf_attr (die, attr)
3600 register dw_die_ref die;
3601 register dw_attr_ref attr;
3603 if (die != NULL && attr != NULL)
3605 attr->dw_attr_next = die->die_attr;
3606 die->die_attr = attr;
3610 static inline dw_val_class
3614 return a->dw_attr_val.val_class;
3617 /* Add a flag value attribute to a DIE. */
3620 add_AT_flag (die, attr_kind, flag)
3621 register dw_die_ref die;
3622 register enum dwarf_attribute attr_kind;
3623 register unsigned flag;
3625 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3627 attr->dw_attr_next = NULL;
3628 attr->dw_attr = attr_kind;
3629 attr->dw_attr_val.val_class = dw_val_class_flag;
3630 attr->dw_attr_val.v.val_flag = flag;
3631 add_dwarf_attr (die, attr);
3634 static inline unsigned
3636 register dw_attr_ref a;
3638 if (a && AT_class (a) == dw_val_class_flag)
3639 return a->dw_attr_val.v.val_flag;
3644 /* Add a signed integer attribute value to a DIE. */
3647 add_AT_int (die, attr_kind, int_val)
3648 register dw_die_ref die;
3649 register enum dwarf_attribute attr_kind;
3650 register long int int_val;
3652 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3654 attr->dw_attr_next = NULL;
3655 attr->dw_attr = attr_kind;
3656 attr->dw_attr_val.val_class = dw_val_class_const;
3657 attr->dw_attr_val.v.val_int = int_val;
3658 add_dwarf_attr (die, attr);
3661 static inline long int
3663 register dw_attr_ref a;
3665 if (a && AT_class (a) == dw_val_class_const)
3666 return a->dw_attr_val.v.val_int;
3671 /* Add an unsigned integer attribute value to a DIE. */
3674 add_AT_unsigned (die, attr_kind, unsigned_val)
3675 register dw_die_ref die;
3676 register enum dwarf_attribute attr_kind;
3677 register unsigned long unsigned_val;
3679 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3681 attr->dw_attr_next = NULL;
3682 attr->dw_attr = attr_kind;
3683 attr->dw_attr_val.val_class = dw_val_class_unsigned_const;
3684 attr->dw_attr_val.v.val_unsigned = unsigned_val;
3685 add_dwarf_attr (die, attr);
3688 static inline unsigned long
3690 register dw_attr_ref a;
3692 if (a && AT_class (a) == dw_val_class_unsigned_const)
3693 return a->dw_attr_val.v.val_unsigned;
3698 /* Add an unsigned double integer attribute value to a DIE. */
3701 add_AT_long_long (die, attr_kind, val_hi, val_low)
3702 register dw_die_ref die;
3703 register enum dwarf_attribute attr_kind;
3704 register unsigned long val_hi;
3705 register unsigned long val_low;
3707 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3709 attr->dw_attr_next = NULL;
3710 attr->dw_attr = attr_kind;
3711 attr->dw_attr_val.val_class = dw_val_class_long_long;
3712 attr->dw_attr_val.v.val_long_long.hi = val_hi;
3713 attr->dw_attr_val.v.val_long_long.low = val_low;
3714 add_dwarf_attr (die, attr);
3717 /* Add a floating point attribute value to a DIE and return it. */
3720 add_AT_float (die, attr_kind, length, array)
3721 register dw_die_ref die;
3722 register enum dwarf_attribute attr_kind;
3723 register unsigned length;
3724 register long *array;
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_float;
3731 attr->dw_attr_val.v.val_float.length = length;
3732 attr->dw_attr_val.v.val_float.array = array;
3733 add_dwarf_attr (die, attr);
3736 /* Add a string attribute value to a DIE. */
3739 add_AT_string (die, attr_kind, str)
3740 register dw_die_ref die;
3741 register enum dwarf_attribute attr_kind;
3742 register const char *str;
3744 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3746 attr->dw_attr_next = NULL;
3747 attr->dw_attr = attr_kind;
3748 attr->dw_attr_val.val_class = dw_val_class_str;
3749 attr->dw_attr_val.v.val_str = xstrdup (str);
3750 add_dwarf_attr (die, attr);
3753 static inline const char *
3755 register dw_attr_ref a;
3757 if (a && AT_class (a) == dw_val_class_str)
3758 return a->dw_attr_val.v.val_str;
3763 /* Add a DIE reference attribute value to a DIE. */
3766 add_AT_die_ref (die, attr_kind, targ_die)
3767 register dw_die_ref die;
3768 register enum dwarf_attribute attr_kind;
3769 register dw_die_ref targ_die;
3771 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3773 attr->dw_attr_next = NULL;
3774 attr->dw_attr = attr_kind;
3775 attr->dw_attr_val.val_class = dw_val_class_die_ref;
3776 attr->dw_attr_val.v.val_die_ref = targ_die;
3777 add_dwarf_attr (die, attr);
3780 static inline dw_die_ref
3782 register dw_attr_ref a;
3784 if (a && AT_class (a) == dw_val_class_die_ref)
3785 return a->dw_attr_val.v.val_die_ref;
3790 /* Add an FDE reference attribute value to a DIE. */
3793 add_AT_fde_ref (die, attr_kind, targ_fde)
3794 register dw_die_ref die;
3795 register enum dwarf_attribute attr_kind;
3796 register unsigned targ_fde;
3798 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3800 attr->dw_attr_next = NULL;
3801 attr->dw_attr = attr_kind;
3802 attr->dw_attr_val.val_class = dw_val_class_fde_ref;
3803 attr->dw_attr_val.v.val_fde_index = targ_fde;
3804 add_dwarf_attr (die, attr);
3807 /* Add a location description attribute value to a DIE. */
3810 add_AT_loc (die, attr_kind, loc)
3811 register dw_die_ref die;
3812 register enum dwarf_attribute attr_kind;
3813 register dw_loc_descr_ref loc;
3815 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3817 attr->dw_attr_next = NULL;
3818 attr->dw_attr = attr_kind;
3819 attr->dw_attr_val.val_class = dw_val_class_loc;
3820 attr->dw_attr_val.v.val_loc = loc;
3821 add_dwarf_attr (die, attr);
3824 static inline dw_loc_descr_ref
3826 register dw_attr_ref a;
3828 if (a && AT_class (a) == dw_val_class_loc)
3829 return a->dw_attr_val.v.val_loc;
3834 /* Add an address constant attribute value to a DIE. */
3837 add_AT_addr (die, attr_kind, addr)
3838 register dw_die_ref die;
3839 register enum dwarf_attribute attr_kind;
3842 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3844 attr->dw_attr_next = NULL;
3845 attr->dw_attr = attr_kind;
3846 attr->dw_attr_val.val_class = dw_val_class_addr;
3847 attr->dw_attr_val.v.val_addr = addr;
3848 add_dwarf_attr (die, attr);
3851 static inline const char *
3853 register dw_attr_ref a;
3855 if (a && AT_class (a) == dw_val_class_addr)
3856 return a->dw_attr_val.v.val_addr;
3861 /* Add a label identifier attribute value to a DIE. */
3864 add_AT_lbl_id (die, attr_kind, lbl_id)
3865 register dw_die_ref die;
3866 register enum dwarf_attribute attr_kind;
3867 register char *lbl_id;
3869 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3871 attr->dw_attr_next = NULL;
3872 attr->dw_attr = attr_kind;
3873 attr->dw_attr_val.val_class = dw_val_class_lbl_id;
3874 attr->dw_attr_val.v.val_lbl_id = xstrdup (lbl_id);
3875 add_dwarf_attr (die, attr);
3878 /* Add a section offset attribute value to a DIE. */
3881 add_AT_lbl_offset (die, attr_kind, label)
3882 register dw_die_ref die;
3883 register enum dwarf_attribute attr_kind;
3884 register char *label;
3886 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3888 attr->dw_attr_next = NULL;
3889 attr->dw_attr = attr_kind;
3890 attr->dw_attr_val.val_class = dw_val_class_lbl_offset;
3891 attr->dw_attr_val.v.val_lbl_id = xstrdup (label);
3892 add_dwarf_attr (die, attr);
3896 static inline const char *
3898 register dw_attr_ref a;
3900 if (a && (AT_class (a) == dw_val_class_lbl_id
3901 || AT_class (a) == dw_val_class_lbl_offset))
3902 return a->dw_attr_val.v.val_lbl_id;
3907 /* Get the attribute of type attr_kind. */
3909 static inline dw_attr_ref
3910 get_AT (die, attr_kind)
3911 register dw_die_ref die;
3912 register enum dwarf_attribute attr_kind;
3914 register dw_attr_ref a;
3915 register dw_die_ref spec = NULL;
3919 for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
3921 if (a->dw_attr == attr_kind)
3924 if (a->dw_attr == DW_AT_specification
3925 || a->dw_attr == DW_AT_abstract_origin)
3930 return get_AT (spec, attr_kind);
3936 /* Return the "low pc" attribute value, typically associated with
3937 a subprogram DIE. Return null if the "low pc" attribute is
3938 either not prsent, or if it cannot be represented as an
3939 assembler label identifier. */
3941 static inline const char *
3943 register dw_die_ref die;
3945 register dw_attr_ref a = get_AT (die, DW_AT_low_pc);
3949 /* Return the "high pc" attribute value, typically associated with
3950 a subprogram DIE. Return null if the "high pc" attribute is
3951 either not prsent, or if it cannot be represented as an
3952 assembler label identifier. */
3954 static inline const char *
3956 register dw_die_ref die;
3958 register dw_attr_ref a = get_AT (die, DW_AT_high_pc);
3962 /* Return the value of the string attribute designated by ATTR_KIND, or
3963 NULL if it is not present. */
3965 static inline const char *
3966 get_AT_string (die, attr_kind)
3967 register dw_die_ref die;
3968 register enum dwarf_attribute attr_kind;
3970 register dw_attr_ref a = get_AT (die, attr_kind);
3971 return AT_string (a);
3974 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
3975 if it is not present. */
3978 get_AT_flag (die, attr_kind)
3979 register dw_die_ref die;
3980 register enum dwarf_attribute attr_kind;
3982 register dw_attr_ref a = get_AT (die, attr_kind);
3986 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
3987 if it is not present. */
3989 static inline unsigned
3990 get_AT_unsigned (die, attr_kind)
3991 register dw_die_ref die;
3992 register enum dwarf_attribute attr_kind;
3994 register dw_attr_ref a = get_AT (die, attr_kind);
3995 return AT_unsigned (a);
3998 static inline dw_die_ref
3999 get_AT_ref (die, attr_kind)
4001 register enum dwarf_attribute attr_kind;
4003 register dw_attr_ref a = get_AT (die, attr_kind);
4010 register unsigned lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
4012 return (lang == DW_LANG_C || lang == DW_LANG_C89
4013 || lang == DW_LANG_C_plus_plus);
4019 register unsigned lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
4021 return (lang == DW_LANG_Fortran77 || lang == DW_LANG_Fortran90);
4024 /* Free up the memory used by A. */
4030 switch (AT_class (a))
4032 case dw_val_class_addr:
4033 case dw_val_class_str:
4034 case dw_val_class_lbl_id:
4035 case dw_val_class_lbl_offset:
4036 free (a->dw_attr_val.v.val_str);
4046 /* Remove the specified attribute if present. */
4049 remove_AT (die, attr_kind)
4050 register dw_die_ref die;
4051 register enum dwarf_attribute attr_kind;
4053 register dw_attr_ref *p;
4054 register dw_attr_ref removed = NULL;
4058 for (p = &(die->die_attr); *p; p = &((*p)->dw_attr_next))
4059 if ((*p)->dw_attr == attr_kind)
4062 *p = (*p)->dw_attr_next;
4071 /* Free up the memory used by DIE. */
4077 remove_children (die);
4081 /* Discard the children of this DIE. */
4084 remove_children (die)
4085 register dw_die_ref die;
4087 register dw_die_ref child_die = die->die_child;
4089 die->die_child = NULL;
4091 while (child_die != NULL)
4093 register dw_die_ref tmp_die = child_die;
4094 register dw_attr_ref a;
4096 child_die = child_die->die_sib;
4098 for (a = tmp_die->die_attr; a != NULL; )
4100 register dw_attr_ref tmp_a = a;
4102 a = a->dw_attr_next;
4110 /* Add a child DIE below its parent. We build the lists up in reverse
4111 addition order, and correct that in add_sibling_attributes. */
4114 add_child_die (die, child_die)
4115 register dw_die_ref die;
4116 register dw_die_ref child_die;
4118 if (die != NULL && child_die != NULL)
4120 if (die == child_die)
4122 child_die->die_parent = die;
4123 child_die->die_sib = die->die_child;
4124 die->die_child = child_die;
4128 /* Move CHILD, which must be a child of PARENT or the DIE for which PARENT
4129 is the specification, to the front of PARENT's list of children. */
4132 splice_child_die (parent, child)
4133 dw_die_ref parent, child;
4137 /* We want the declaration DIE from inside the class, not the
4138 specification DIE at toplevel. */
4139 if (child->die_parent != parent)
4141 dw_die_ref tmp = get_AT_ref (child, DW_AT_specification);
4146 if (child->die_parent != parent
4147 && child->die_parent != get_AT_ref (parent, DW_AT_specification))
4150 for (p = &(parent->die_child); *p; p = &((*p)->die_sib))
4153 *p = child->die_sib;
4157 child->die_sib = parent->die_child;
4158 parent->die_child = child;
4161 /* Return a pointer to a newly created DIE node. */
4163 static inline dw_die_ref
4164 new_die (tag_value, parent_die)
4165 register enum dwarf_tag tag_value;
4166 register dw_die_ref parent_die;
4168 register dw_die_ref die = (dw_die_ref) xmalloc (sizeof (die_node));
4170 die->die_tag = tag_value;
4171 die->die_abbrev = 0;
4172 die->die_offset = 0;
4173 die->die_child = NULL;
4174 die->die_parent = NULL;
4175 die->die_sib = NULL;
4176 die->die_attr = NULL;
4178 if (parent_die != NULL)
4179 add_child_die (parent_die, die);
4182 limbo_die_node *limbo_node;
4184 limbo_node = (limbo_die_node *) xmalloc (sizeof (limbo_die_node));
4185 limbo_node->die = die;
4186 limbo_node->next = limbo_die_list;
4187 limbo_die_list = limbo_node;
4193 /* Return the DIE associated with the given type specifier. */
4195 static inline dw_die_ref
4196 lookup_type_die (type)
4199 return (dw_die_ref) TYPE_SYMTAB_POINTER (type);
4202 /* Equate a DIE to a given type specifier. */
4205 equate_type_number_to_die (type, type_die)
4207 register dw_die_ref type_die;
4209 TYPE_SYMTAB_POINTER (type) = (char *) type_die;
4212 /* Return the DIE associated with a given declaration. */
4214 static inline dw_die_ref
4215 lookup_decl_die (decl)
4218 register unsigned decl_id = DECL_UID (decl);
4220 return (decl_id < decl_die_table_in_use
4221 ? decl_die_table[decl_id] : NULL);
4224 /* Equate a DIE to a particular declaration. */
4227 equate_decl_number_to_die (decl, decl_die)
4229 register dw_die_ref decl_die;
4231 register unsigned decl_id = DECL_UID (decl);
4232 register unsigned num_allocated;
4234 if (decl_id >= decl_die_table_allocated)
4237 = ((decl_id + 1 + DECL_DIE_TABLE_INCREMENT - 1)
4238 / DECL_DIE_TABLE_INCREMENT)
4239 * DECL_DIE_TABLE_INCREMENT;
4242 = (dw_die_ref *) xrealloc (decl_die_table,
4243 sizeof (dw_die_ref) * num_allocated);
4245 bzero ((char *) &decl_die_table[decl_die_table_allocated],
4246 (num_allocated - decl_die_table_allocated) * sizeof (dw_die_ref));
4247 decl_die_table_allocated = num_allocated;
4250 if (decl_id >= decl_die_table_in_use)
4251 decl_die_table_in_use = (decl_id + 1);
4253 decl_die_table[decl_id] = decl_die;
4256 /* Return a pointer to a newly allocated location description. Location
4257 descriptions are simple expression terms that can be strung
4258 together to form more complicated location (address) descriptions. */
4260 static inline dw_loc_descr_ref
4261 new_loc_descr (op, oprnd1, oprnd2)
4262 register enum dwarf_location_atom op;
4263 register unsigned long oprnd1;
4264 register unsigned long oprnd2;
4266 register dw_loc_descr_ref descr
4267 = (dw_loc_descr_ref) xmalloc (sizeof (dw_loc_descr_node));
4269 descr->dw_loc_next = NULL;
4270 descr->dw_loc_opc = op;
4271 descr->dw_loc_oprnd1.val_class = dw_val_class_unsigned_const;
4272 descr->dw_loc_oprnd1.v.val_unsigned = oprnd1;
4273 descr->dw_loc_oprnd2.val_class = dw_val_class_unsigned_const;
4274 descr->dw_loc_oprnd2.v.val_unsigned = oprnd2;
4279 /* Add a location description term to a location description expression. */
4282 add_loc_descr (list_head, descr)
4283 register dw_loc_descr_ref *list_head;
4284 register dw_loc_descr_ref descr;
4286 register dw_loc_descr_ref *d;
4288 /* Find the end of the chain. */
4289 for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
4295 /* Keep track of the number of spaces used to indent the
4296 output of the debugging routines that print the structure of
4297 the DIE internal representation. */
4298 static int print_indent;
4300 /* Indent the line the number of spaces given by print_indent. */
4303 print_spaces (outfile)
4306 fprintf (outfile, "%*s", print_indent, "");
4309 /* Print the information associated with a given DIE, and its children.
4310 This routine is a debugging aid only. */
4313 print_die (die, outfile)
4317 register dw_attr_ref a;
4318 register dw_die_ref c;
4320 print_spaces (outfile);
4321 fprintf (outfile, "DIE %4lu: %s\n",
4322 die->die_offset, dwarf_tag_name (die->die_tag));
4323 print_spaces (outfile);
4324 fprintf (outfile, " abbrev id: %lu", die->die_abbrev);
4325 fprintf (outfile, " offset: %lu\n", die->die_offset);
4327 for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
4329 print_spaces (outfile);
4330 fprintf (outfile, " %s: ", dwarf_attr_name (a->dw_attr));
4332 switch (AT_class (a))
4334 case dw_val_class_addr:
4335 fprintf (outfile, "address");
4337 case dw_val_class_loc:
4338 fprintf (outfile, "location descriptor");
4340 case dw_val_class_const:
4341 fprintf (outfile, "%ld", AT_int (a));
4343 case dw_val_class_unsigned_const:
4344 fprintf (outfile, "%lu", AT_unsigned (a));
4346 case dw_val_class_long_long:
4347 fprintf (outfile, "constant (%lu,%lu)",
4348 a->dw_attr_val.v.val_long_long.hi,
4349 a->dw_attr_val.v.val_long_long.low);
4351 case dw_val_class_float:
4352 fprintf (outfile, "floating-point constant");
4354 case dw_val_class_flag:
4355 fprintf (outfile, "%u", AT_flag (a));
4357 case dw_val_class_die_ref:
4358 if (AT_ref (a) != NULL)
4359 fprintf (outfile, "die -> %lu", AT_ref (a)->die_offset);
4361 fprintf (outfile, "die -> <null>");
4363 case dw_val_class_lbl_id:
4364 case dw_val_class_lbl_offset:
4365 fprintf (outfile, "label: %s", AT_lbl (a));
4367 case dw_val_class_str:
4368 if (AT_string (a) != NULL)
4369 fprintf (outfile, "\"%s\"", AT_string (a));
4371 fprintf (outfile, "<null>");
4377 fprintf (outfile, "\n");
4380 if (die->die_child != NULL)
4383 for (c = die->die_child; c != NULL; c = c->die_sib)
4384 print_die (c, outfile);
4390 /* Print the contents of the source code line number correspondence table.
4391 This routine is a debugging aid only. */
4394 print_dwarf_line_table (outfile)
4397 register unsigned i;
4398 register dw_line_info_ref line_info;
4400 fprintf (outfile, "\n\nDWARF source line information\n");
4401 for (i = 1; i < line_info_table_in_use; ++i)
4403 line_info = &line_info_table[i];
4404 fprintf (outfile, "%5d: ", i);
4405 fprintf (outfile, "%-20s", file_table[line_info->dw_file_num]);
4406 fprintf (outfile, "%6ld", line_info->dw_line_num);
4407 fprintf (outfile, "\n");
4410 fprintf (outfile, "\n\n");
4413 /* Print the information collected for a given DIE. */
4416 debug_dwarf_die (die)
4419 print_die (die, stderr);
4422 /* Print all DWARF information collected for the compilation unit.
4423 This routine is a debugging aid only. */
4429 print_die (comp_unit_die, stderr);
4430 if (! DWARF2_ASM_LINE_DEBUG_INFO)
4431 print_dwarf_line_table (stderr);
4434 /* We build up the lists of children and attributes by pushing new ones
4435 onto the beginning of the list. Reverse the lists for DIE so that
4436 they are in order of addition. */
4439 reverse_die_lists (die)
4440 register dw_die_ref die;
4442 register dw_die_ref c, cp, cn;
4443 register dw_attr_ref a, ap, an;
4445 for (a = die->die_attr, ap = 0; a; a = an)
4447 an = a->dw_attr_next;
4448 a->dw_attr_next = ap;
4453 for (c = die->die_child, cp = 0; c; c = cn)
4459 die->die_child = cp;
4462 /* Traverse the DIE, reverse its lists of attributes and children, and
4463 add a sibling attribute if it may have the effect of speeding up
4464 access to siblings. To save some space, avoid generating sibling
4465 attributes for DIE's without children. */
4468 add_sibling_attributes (die)
4469 register dw_die_ref die;
4471 register dw_die_ref c;
4473 reverse_die_lists (die);
4475 if (die != comp_unit_die && die->die_sib && die->die_child != NULL)
4476 /* Add the sibling link to the front of the attribute list. */
4477 add_AT_die_ref (die, DW_AT_sibling, die->die_sib);
4479 for (c = die->die_child; c != NULL; c = c->die_sib)
4480 add_sibling_attributes (c);
4483 /* The format of each DIE (and its attribute value pairs)
4484 is encoded in an abbreviation table. This routine builds the
4485 abbreviation table and assigns a unique abbreviation id for
4486 each abbreviation entry. The children of each die are visited
4490 build_abbrev_table (die)
4491 register dw_die_ref die;
4493 register unsigned long abbrev_id;
4494 register unsigned long n_alloc;
4495 register dw_die_ref c;
4496 register dw_attr_ref d_attr, a_attr;
4497 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
4499 register dw_die_ref abbrev = abbrev_die_table[abbrev_id];
4501 if (abbrev->die_tag == die->die_tag)
4503 if ((abbrev->die_child != NULL) == (die->die_child != NULL))
4505 a_attr = abbrev->die_attr;
4506 d_attr = die->die_attr;
4508 while (a_attr != NULL && d_attr != NULL)
4510 if ((a_attr->dw_attr != d_attr->dw_attr)
4511 || (value_format (a_attr) != value_format (d_attr)))
4514 a_attr = a_attr->dw_attr_next;
4515 d_attr = d_attr->dw_attr_next;
4518 if (a_attr == NULL && d_attr == NULL)
4524 if (abbrev_id >= abbrev_die_table_in_use)
4526 if (abbrev_die_table_in_use >= abbrev_die_table_allocated)
4528 n_alloc = abbrev_die_table_allocated + ABBREV_DIE_TABLE_INCREMENT;
4530 = (dw_die_ref *) xrealloc (abbrev_die_table,
4531 sizeof (dw_die_ref) * n_alloc);
4533 bzero ((char *) &abbrev_die_table[abbrev_die_table_allocated],
4534 (n_alloc - abbrev_die_table_allocated) * sizeof (dw_die_ref));
4535 abbrev_die_table_allocated = n_alloc;
4538 ++abbrev_die_table_in_use;
4539 abbrev_die_table[abbrev_id] = die;
4542 die->die_abbrev = abbrev_id;
4543 for (c = die->die_child; c != NULL; c = c->die_sib)
4544 build_abbrev_table (c);
4547 /* Return the size of a string, including the null byte.
4549 This used to treat backslashes as escapes, and hence they were not included
4550 in the count. However, that conflicts with what ASM_OUTPUT_ASCII does,
4551 which treats a backslash as a backslash, escaping it if necessary, and hence
4552 we must include them in the count. */
4554 static unsigned long
4555 size_of_string (str)
4556 register const char *str;
4558 return strlen (str) + 1;
4561 /* Return the size of a location descriptor. */
4563 static unsigned long
4564 size_of_loc_descr (loc)
4565 register dw_loc_descr_ref loc;
4567 register unsigned long size = 1;
4569 switch (loc->dw_loc_opc)
4591 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4594 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
4599 case DW_OP_plus_uconst:
4600 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4638 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
4641 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4644 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
4647 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4648 size += size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int);
4651 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4653 case DW_OP_deref_size:
4654 case DW_OP_xderef_size:
4664 /* Return the size of a series of location descriptors. */
4666 static unsigned long
4668 register dw_loc_descr_ref loc;
4670 register unsigned long size = 0;
4672 for (; loc != NULL; loc = loc->dw_loc_next)
4673 size += size_of_loc_descr (loc);
4678 /* Return the power-of-two number of bytes necessary to represent VALUE. */
4681 constant_size (value)
4682 long unsigned value;
4689 log = floor_log2 (value);
4692 log = 1 << (floor_log2 (log) + 1);
4697 /* Return the size of a DIE, as it is represented in the
4698 .debug_info section. */
4700 static unsigned long
4702 register dw_die_ref die;
4704 register unsigned long size = 0;
4705 register dw_attr_ref a;
4707 size += size_of_uleb128 (die->die_abbrev);
4708 for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
4710 switch (AT_class (a))
4712 case dw_val_class_addr:
4715 case dw_val_class_loc:
4717 register unsigned long lsize = size_of_locs (AT_loc (a));
4720 size += constant_size (lsize);
4724 case dw_val_class_const:
4727 case dw_val_class_unsigned_const:
4728 size += constant_size (AT_unsigned (a));
4730 case dw_val_class_long_long:
4731 size += 1 + 8; /* block */
4733 case dw_val_class_float:
4734 size += 1 + a->dw_attr_val.v.val_float.length * 4; /* block */
4736 case dw_val_class_flag:
4739 case dw_val_class_die_ref:
4740 size += DWARF_OFFSET_SIZE;
4742 case dw_val_class_fde_ref:
4743 size += DWARF_OFFSET_SIZE;
4745 case dw_val_class_lbl_id:
4748 case dw_val_class_lbl_offset:
4749 size += DWARF_OFFSET_SIZE;
4751 case dw_val_class_str:
4752 size += size_of_string (AT_string (a));
4762 /* Size the debugging information associated with a given DIE.
4763 Visits the DIE's children recursively. Updates the global
4764 variable next_die_offset, on each time through. Uses the
4765 current value of next_die_offset to update the die_offset
4766 field in each DIE. */
4769 calc_die_sizes (die)
4772 register dw_die_ref c;
4773 die->die_offset = next_die_offset;
4774 next_die_offset += size_of_die (die);
4776 for (c = die->die_child; c != NULL; c = c->die_sib)
4779 if (die->die_child != NULL)
4780 /* Count the null byte used to terminate sibling lists. */
4781 next_die_offset += 1;
4784 /* Return the size of the line information prolog generated for the
4785 compilation unit. */
4787 static unsigned long
4788 size_of_line_prolog ()
4790 register unsigned long size;
4791 register unsigned long ft_index;
4793 size = DWARF_LINE_PROLOG_HEADER_SIZE;
4795 /* Count the size of the table giving number of args for each
4797 size += DWARF_LINE_OPCODE_BASE - 1;
4799 /* Include directory table is empty (at present). Count only the
4800 null byte used to terminate the table. */
4803 for (ft_index = 1; ft_index < file_table_in_use; ++ft_index)
4805 /* File name entry. */
4806 size += size_of_string (file_table[ft_index]);
4808 /* Include directory index. */
4809 size += size_of_uleb128 (0);
4811 /* Modification time. */
4812 size += size_of_uleb128 (0);
4814 /* File length in bytes. */
4815 size += size_of_uleb128 (0);
4818 /* Count the file table terminator. */
4823 /* Return the size of the .debug_pubnames table generated for the
4824 compilation unit. */
4826 static unsigned long
4829 register unsigned long size;
4830 register unsigned i;
4832 size = DWARF_PUBNAMES_HEADER_SIZE;
4833 for (i = 0; i < pubname_table_in_use; ++i)
4835 register pubname_ref p = &pubname_table[i];
4836 size += DWARF_OFFSET_SIZE + size_of_string (p->name);
4839 size += DWARF_OFFSET_SIZE;
4843 /* Return the size of the information in the .debug_aranges section. */
4845 static unsigned long
4848 register unsigned long size;
4850 size = DWARF_ARANGES_HEADER_SIZE;
4852 /* Count the address/length pair for this compilation unit. */
4853 size += 2 * PTR_SIZE;
4854 size += 2 * PTR_SIZE * arange_table_in_use;
4856 /* Count the two zero words used to terminated the address range table. */
4857 size += 2 * PTR_SIZE;
4861 /* Select the encoding of an attribute value. */
4863 static enum dwarf_form
4867 switch (a->dw_attr_val.val_class)
4869 case dw_val_class_addr:
4870 return DW_FORM_addr;
4871 case dw_val_class_loc:
4872 switch (constant_size (size_of_locs (AT_loc (a))))
4875 return DW_FORM_block1;
4877 return DW_FORM_block2;
4881 case dw_val_class_const:
4882 return DW_FORM_data4;
4883 case dw_val_class_unsigned_const:
4884 switch (constant_size (AT_unsigned (a)))
4887 return DW_FORM_data1;
4889 return DW_FORM_data2;
4891 return DW_FORM_data4;
4893 return DW_FORM_data8;
4897 case dw_val_class_long_long:
4898 return DW_FORM_block1;
4899 case dw_val_class_float:
4900 return DW_FORM_block1;
4901 case dw_val_class_flag:
4902 return DW_FORM_flag;
4903 case dw_val_class_die_ref:
4905 case dw_val_class_fde_ref:
4906 return DW_FORM_data;
4907 case dw_val_class_lbl_id:
4908 return DW_FORM_addr;
4909 case dw_val_class_lbl_offset:
4910 return DW_FORM_data;
4911 case dw_val_class_str:
4912 return DW_FORM_string;
4918 /* Output the encoding of an attribute value. */
4921 output_value_format (a)
4924 enum dwarf_form form = value_format (a);
4926 output_uleb128 (form);
4928 fprintf (asm_out_file, " (%s)", dwarf_form_name (form));
4930 fputc ('\n', asm_out_file);
4933 /* Output the .debug_abbrev section which defines the DIE abbreviation
4937 output_abbrev_section ()
4939 unsigned long abbrev_id;
4942 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
4944 register dw_die_ref abbrev = abbrev_die_table[abbrev_id];
4946 output_uleb128 (abbrev_id);
4948 fprintf (asm_out_file, " (abbrev code)");
4950 fputc ('\n', asm_out_file);
4951 output_uleb128 (abbrev->die_tag);
4953 fprintf (asm_out_file, " (TAG: %s)",
4954 dwarf_tag_name (abbrev->die_tag));
4956 fputc ('\n', asm_out_file);
4957 fprintf (asm_out_file, "\t%s\t0x%x", ASM_BYTE_OP,
4958 abbrev->die_child != NULL ? DW_children_yes : DW_children_no);
4961 fprintf (asm_out_file, "\t%s %s",
4963 (abbrev->die_child != NULL
4964 ? "DW_children_yes" : "DW_children_no"));
4966 fputc ('\n', asm_out_file);
4968 for (a_attr = abbrev->die_attr; a_attr != NULL;
4969 a_attr = a_attr->dw_attr_next)
4971 output_uleb128 (a_attr->dw_attr);
4973 fprintf (asm_out_file, " (%s)",
4974 dwarf_attr_name (a_attr->dw_attr));
4976 fputc ('\n', asm_out_file);
4977 output_value_format (a_attr);
4980 fprintf (asm_out_file, "\t%s\t0,0\n", ASM_BYTE_OP);
4983 /* Terminate the table. */
4984 fprintf (asm_out_file, "\t%s\t0\n", ASM_BYTE_OP);
4987 /* Output location description stack opcode's operands (if any). */
4990 output_loc_operands (loc)
4991 register dw_loc_descr_ref loc;
4993 register dw_val_ref val1 = &loc->dw_loc_oprnd1;
4994 register dw_val_ref val2 = &loc->dw_loc_oprnd2;
4996 switch (loc->dw_loc_opc)
4999 ASM_OUTPUT_DWARF_ADDR_CONST (asm_out_file, val1->v.val_addr);
5000 fputc ('\n', asm_out_file);
5004 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, val1->v.val_flag);
5005 fputc ('\n', asm_out_file);
5009 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, val1->v.val_int);
5010 fputc ('\n', asm_out_file);
5014 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, val1->v.val_int);
5015 fputc ('\n', asm_out_file);
5020 fputc ('\n', asm_out_file);
5023 output_uleb128 (val1->v.val_unsigned);
5024 fputc ('\n', asm_out_file);
5027 output_sleb128 (val1->v.val_int);
5028 fputc ('\n', asm_out_file);
5031 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, val1->v.val_int);
5032 fputc ('\n', asm_out_file);
5034 case DW_OP_plus_uconst:
5035 output_uleb128 (val1->v.val_unsigned);
5036 fputc ('\n', asm_out_file);
5040 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, val1->v.val_int);
5041 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);
5083 output_sleb128 (val1->v.val_int);
5084 fputc ('\n', asm_out_file);
5087 output_uleb128 (val1->v.val_unsigned);
5088 fputc ('\n', asm_out_file);
5089 output_sleb128 (val2->v.val_int);
5090 fputc ('\n', asm_out_file);
5093 output_uleb128 (val1->v.val_unsigned);
5094 fputc ('\n', asm_out_file);
5096 case DW_OP_deref_size:
5097 case DW_OP_xderef_size:
5098 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, val1->v.val_flag);
5099 fputc ('\n', asm_out_file);
5106 /* Output the DIE and its attributes. Called recursively to generate
5107 the definitions of each child DIE. */
5111 register dw_die_ref die;
5113 register dw_attr_ref a;
5114 register dw_die_ref c;
5115 register unsigned long size;
5116 register dw_loc_descr_ref loc;
5118 output_uleb128 (die->die_abbrev);
5120 fprintf (asm_out_file, " (DIE (0x%lx) %s)",
5121 die->die_offset, dwarf_tag_name (die->die_tag));
5123 fputc ('\n', asm_out_file);
5125 for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
5127 switch (AT_class (a))
5129 case dw_val_class_addr:
5130 ASM_OUTPUT_DWARF_ADDR_CONST (asm_out_file, AT_addr (a));
5133 case dw_val_class_loc:
5134 size = size_of_locs (AT_loc (a));
5136 /* Output the block length for this list of location operations. */
5137 switch (constant_size (size))
5140 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, size);
5143 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, size);
5150 fprintf (asm_out_file, "\t%s %s",
5151 ASM_COMMENT_START, dwarf_attr_name (a->dw_attr));
5153 fputc ('\n', asm_out_file);
5154 for (loc = AT_loc (a); loc != NULL; loc = loc->dw_loc_next)
5156 /* Output the opcode. */
5157 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, loc->dw_loc_opc);
5159 fprintf (asm_out_file, "\t%s %s", ASM_COMMENT_START,
5160 dwarf_stack_op_name (loc->dw_loc_opc));
5162 fputc ('\n', asm_out_file);
5164 /* Output the operand(s) (if any). */
5165 output_loc_operands (loc);
5169 case dw_val_class_const:
5170 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, AT_int (a));
5173 case dw_val_class_unsigned_const:
5174 switch (constant_size (AT_unsigned (a)))
5177 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, AT_unsigned (a));
5180 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, AT_unsigned (a));
5183 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, AT_unsigned (a));
5186 ASM_OUTPUT_DWARF_DATA8 (asm_out_file,
5187 a->dw_attr_val.v.val_long_long.hi,
5188 a->dw_attr_val.v.val_long_long.low);
5195 case dw_val_class_long_long:
5196 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 8);
5198 fprintf (asm_out_file, "\t%s %s",
5199 ASM_COMMENT_START, dwarf_attr_name (a->dw_attr));
5201 fputc ('\n', asm_out_file);
5202 ASM_OUTPUT_DWARF_DATA8 (asm_out_file,
5203 a->dw_attr_val.v.val_long_long.hi,
5204 a->dw_attr_val.v.val_long_long.low);
5207 fprintf (asm_out_file,
5208 "\t%s long long constant", ASM_COMMENT_START);
5210 fputc ('\n', asm_out_file);
5213 case dw_val_class_float:
5215 register unsigned int i;
5216 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
5217 a->dw_attr_val.v.val_float.length * 4);
5219 fprintf (asm_out_file, "\t%s %s",
5220 ASM_COMMENT_START, dwarf_attr_name (a->dw_attr));
5222 fputc ('\n', asm_out_file);
5223 for (i = 0; i < a->dw_attr_val.v.val_float.length; ++i)
5225 ASM_OUTPUT_DWARF_DATA4 (asm_out_file,
5226 a->dw_attr_val.v.val_float.array[i]);
5228 fprintf (asm_out_file, "\t%s fp constant word %u",
5229 ASM_COMMENT_START, i);
5231 fputc ('\n', asm_out_file);
5236 case dw_val_class_flag:
5237 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, AT_flag (a));
5240 case dw_val_class_die_ref:
5241 ASM_OUTPUT_DWARF_DATA (asm_out_file, AT_ref (a)->die_offset);
5244 case dw_val_class_fde_ref:
5247 ASM_GENERATE_INTERNAL_LABEL
5248 (l1, FDE_AFTER_SIZE_LABEL, a->dw_attr_val.v.val_fde_index * 2);
5249 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, l1);
5250 fprintf (asm_out_file, " - %d", DWARF_OFFSET_SIZE);
5254 case dw_val_class_lbl_id:
5255 ASM_OUTPUT_DWARF_ADDR (asm_out_file, AT_lbl (a));
5258 case dw_val_class_lbl_offset:
5259 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, AT_lbl (a));
5262 case dw_val_class_str:
5264 ASM_OUTPUT_DWARF_STRING (asm_out_file, AT_string (a));
5266 ASM_OUTPUT_ASCII (asm_out_file, AT_string (a),
5267 (int) strlen (AT_string (a)) + 1);
5274 if (AT_class (a) != dw_val_class_loc
5275 && AT_class (a) != dw_val_class_long_long
5276 && AT_class (a) != dw_val_class_float)
5279 fprintf (asm_out_file, "\t%s %s",
5280 ASM_COMMENT_START, dwarf_attr_name (a->dw_attr));
5282 fputc ('\n', asm_out_file);
5286 for (c = die->die_child; c != NULL; c = c->die_sib)
5289 if (die->die_child != NULL)
5291 /* Add null byte to terminate sibling list. */
5292 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5294 fprintf (asm_out_file, "\t%s end of children of DIE 0x%lx",
5295 ASM_COMMENT_START, die->die_offset);
5297 fputc ('\n', asm_out_file);
5301 /* Output the compilation unit that appears at the beginning of the
5302 .debug_info section, and precedes the DIE descriptions. */
5305 output_compilation_unit_header ()
5307 ASM_OUTPUT_DWARF_DATA (asm_out_file, next_die_offset - DWARF_OFFSET_SIZE);
5309 fprintf (asm_out_file, "\t%s Length of Compilation Unit Info.",
5312 fputc ('\n', asm_out_file);
5313 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, DWARF_VERSION);
5315 fprintf (asm_out_file, "\t%s DWARF version number", ASM_COMMENT_START);
5317 fputc ('\n', asm_out_file);
5318 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, abbrev_section_label);
5320 fprintf (asm_out_file, "\t%s Offset Into Abbrev. Section",
5323 fputc ('\n', asm_out_file);
5324 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, PTR_SIZE);
5326 fprintf (asm_out_file, "\t%s Pointer Size (in bytes)", ASM_COMMENT_START);
5328 fputc ('\n', asm_out_file);
5331 /* The DWARF2 pubname for a nested thingy looks like "A::f". The output
5332 of decl_printable_name for C++ looks like "A::f(int)". Let's drop the
5333 argument list, and maybe the scope. */
5336 dwarf2_name (decl, scope)
5340 return (*decl_printable_name) (decl, scope ? 1 : 0);
5343 /* Add a new entry to .debug_pubnames if appropriate. */
5346 add_pubname (decl, die)
5352 if (! TREE_PUBLIC (decl))
5355 if (pubname_table_in_use == pubname_table_allocated)
5357 pubname_table_allocated += PUBNAME_TABLE_INCREMENT;
5358 pubname_table = (pubname_ref) xrealloc
5359 (pubname_table, pubname_table_allocated * sizeof (pubname_entry));
5362 p = &pubname_table[pubname_table_in_use++];
5365 p->name = xstrdup (dwarf2_name (decl, 1));
5368 /* Output the public names table used to speed up access to externally
5369 visible names. For now, only generate entries for externally
5370 visible procedures. */
5375 register unsigned i;
5376 register unsigned long pubnames_length = size_of_pubnames ();
5378 ASM_OUTPUT_DWARF_DATA (asm_out_file, pubnames_length);
5381 fprintf (asm_out_file, "\t%s Length of Public Names Info.",
5384 fputc ('\n', asm_out_file);
5385 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, DWARF_VERSION);
5388 fprintf (asm_out_file, "\t%s DWARF Version", ASM_COMMENT_START);
5390 fputc ('\n', asm_out_file);
5391 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, debug_info_section_label);
5393 fprintf (asm_out_file, "\t%s Offset of Compilation Unit Info.",
5396 fputc ('\n', asm_out_file);
5397 ASM_OUTPUT_DWARF_DATA (asm_out_file, next_die_offset);
5399 fprintf (asm_out_file, "\t%s Compilation Unit Length", ASM_COMMENT_START);
5401 fputc ('\n', asm_out_file);
5402 for (i = 0; i < pubname_table_in_use; ++i)
5404 register pubname_ref pub = &pubname_table[i];
5406 ASM_OUTPUT_DWARF_DATA (asm_out_file, pub->die->die_offset);
5408 fprintf (asm_out_file, "\t%s DIE offset", ASM_COMMENT_START);
5410 fputc ('\n', asm_out_file);
5414 ASM_OUTPUT_DWARF_STRING (asm_out_file, pub->name);
5415 fprintf (asm_out_file, "%s external name", ASM_COMMENT_START);
5419 ASM_OUTPUT_ASCII (asm_out_file, pub->name,
5420 (int) strlen (pub->name) + 1);
5423 fputc ('\n', asm_out_file);
5426 ASM_OUTPUT_DWARF_DATA (asm_out_file, 0);
5427 fputc ('\n', asm_out_file);
5430 /* Add a new entry to .debug_aranges if appropriate. */
5433 add_arange (decl, die)
5437 if (! DECL_SECTION_NAME (decl))
5440 if (arange_table_in_use == arange_table_allocated)
5442 arange_table_allocated += ARANGE_TABLE_INCREMENT;
5444 = (arange_ref) xrealloc (arange_table,
5445 arange_table_allocated * sizeof (dw_die_ref));
5448 arange_table[arange_table_in_use++] = die;
5451 /* Output the information that goes into the .debug_aranges table.
5452 Namely, define the beginning and ending address range of the
5453 text section generated for this compilation unit. */
5458 register unsigned i;
5459 register unsigned long aranges_length = size_of_aranges ();
5461 ASM_OUTPUT_DWARF_DATA (asm_out_file, aranges_length);
5463 fprintf (asm_out_file, "\t%s Length of Address Ranges Info.",
5466 fputc ('\n', asm_out_file);
5467 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, DWARF_VERSION);
5469 fprintf (asm_out_file, "\t%s DWARF Version", ASM_COMMENT_START);
5471 fputc ('\n', asm_out_file);
5472 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, debug_info_section_label);
5474 fprintf (asm_out_file, "\t%s Offset of Compilation Unit Info.",
5477 fputc ('\n', asm_out_file);
5478 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, PTR_SIZE);
5480 fprintf (asm_out_file, "\t%s Size of Address", ASM_COMMENT_START);
5482 fputc ('\n', asm_out_file);
5483 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5485 fprintf (asm_out_file, "\t%s Size of Segment Descriptor",
5488 fputc ('\n', asm_out_file);
5489 /* We need to align to twice the pointer size here.
5490 If DWARF_OFFSET_SIZE == 4, then we have emitted 12 bytes, and need 4
5491 bytes of padding to align for either 4 or 8 byte pointers. */
5492 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0);
5493 /* If DWARF_OFFSET_SIZE == 8, then we have emitted 20 bytes, and need 12
5494 bytes of padding to align for 8 byte pointers. We have already emitted
5495 4 bytes of padding, so emit 8 more here. */
5496 if (DWARF_OFFSET_SIZE == 8)
5497 fprintf (asm_out_file, ",0,0");
5500 fprintf (asm_out_file, "\t%s Pad to %d byte boundary",
5501 ASM_COMMENT_START, 2 * PTR_SIZE);
5503 fputc ('\n', asm_out_file);
5504 ASM_OUTPUT_DWARF_ADDR (asm_out_file, text_section_label);
5506 fprintf (asm_out_file, "\t%s Address", ASM_COMMENT_START);
5508 fputc ('\n', asm_out_file);
5509 ASM_OUTPUT_DWARF_ADDR_DELTA (asm_out_file, text_end_label,
5510 text_section_label);
5512 fprintf (asm_out_file, "%s Length", ASM_COMMENT_START);
5514 fputc ('\n', asm_out_file);
5515 for (i = 0; i < arange_table_in_use; ++i)
5517 dw_die_ref die = arange_table[i];
5519 if (die->die_tag == DW_TAG_subprogram)
5520 ASM_OUTPUT_DWARF_ADDR (asm_out_file, get_AT_low_pc (die));
5523 /* A static variable; extract the symbol from DW_AT_location.
5524 Note that this code isn't currently hit, as we only emit
5525 aranges for functions (jason 9/23/99). */
5527 dw_attr_ref a = get_AT (die, DW_AT_location);
5528 dw_loc_descr_ref loc;
5529 if (! a || AT_class (a) != dw_val_class_loc)
5533 if (loc->dw_loc_opc != DW_OP_addr)
5536 ASM_OUTPUT_DWARF_ADDR (asm_out_file, loc->dw_loc_oprnd1.v.val_addr);
5540 fprintf (asm_out_file, "\t%s Address", ASM_COMMENT_START);
5542 fputc ('\n', asm_out_file);
5543 if (die->die_tag == DW_TAG_subprogram)
5544 ASM_OUTPUT_DWARF_ADDR_DELTA (asm_out_file, get_AT_hi_pc (die),
5545 get_AT_low_pc (die));
5547 ASM_OUTPUT_DWARF_ADDR_DATA (asm_out_file,
5548 get_AT_unsigned (die, DW_AT_byte_size));
5551 fprintf (asm_out_file, "%s Length", ASM_COMMENT_START);
5553 fputc ('\n', asm_out_file);
5556 /* Output the terminator words. */
5557 ASM_OUTPUT_DWARF_ADDR_DATA (asm_out_file, 0);
5558 fputc ('\n', asm_out_file);
5559 ASM_OUTPUT_DWARF_ADDR_DATA (asm_out_file, 0);
5560 fputc ('\n', asm_out_file);
5563 /* Output the source line number correspondence information. This
5564 information goes into the .debug_line section. */
5569 char line_label[MAX_ARTIFICIAL_LABEL_BYTES];
5570 char prev_line_label[MAX_ARTIFICIAL_LABEL_BYTES];
5571 register unsigned opc;
5572 register unsigned n_op_args;
5573 register unsigned long ft_index;
5574 register unsigned long lt_index;
5575 register unsigned long current_line;
5576 register long line_offset;
5577 register long line_delta;
5578 register unsigned long current_file;
5579 register unsigned long function;
5581 ASM_OUTPUT_DWARF_DELTA (asm_out_file, ".LTEND", ".LTSTART");
5583 fprintf (asm_out_file, "\t%s Length of Source Line Info.",
5586 fputc ('\n', asm_out_file);
5587 ASM_OUTPUT_LABEL (asm_out_file, ".LTSTART");
5588 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, DWARF_VERSION);
5590 fprintf (asm_out_file, "\t%s DWARF Version", ASM_COMMENT_START);
5592 fputc ('\n', asm_out_file);
5593 ASM_OUTPUT_DWARF_DATA (asm_out_file, size_of_line_prolog ());
5595 fprintf (asm_out_file, "\t%s Prolog Length", ASM_COMMENT_START);
5597 fputc ('\n', asm_out_file);
5598 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DWARF_LINE_MIN_INSTR_LENGTH);
5600 fprintf (asm_out_file, "\t%s Minimum Instruction Length",
5603 fputc ('\n', asm_out_file);
5604 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DWARF_LINE_DEFAULT_IS_STMT_START);
5606 fprintf (asm_out_file, "\t%s Default is_stmt_start flag",
5609 fputc ('\n', asm_out_file);
5610 fprintf (asm_out_file, "\t%s\t%d", ASM_BYTE_OP, DWARF_LINE_BASE);
5612 fprintf (asm_out_file, "\t%s Line Base Value (Special Opcodes)",
5615 fputc ('\n', asm_out_file);
5616 fprintf (asm_out_file, "\t%s\t%u", ASM_BYTE_OP, DWARF_LINE_RANGE);
5618 fprintf (asm_out_file, "\t%s Line Range Value (Special Opcodes)",
5621 fputc ('\n', asm_out_file);
5622 fprintf (asm_out_file, "\t%s\t%u", ASM_BYTE_OP, DWARF_LINE_OPCODE_BASE);
5624 fprintf (asm_out_file, "\t%s Special Opcode Base", ASM_COMMENT_START);
5626 fputc ('\n', asm_out_file);
5627 for (opc = 1; opc < DWARF_LINE_OPCODE_BASE; ++opc)
5631 case DW_LNS_advance_pc:
5632 case DW_LNS_advance_line:
5633 case DW_LNS_set_file:
5634 case DW_LNS_set_column:
5635 case DW_LNS_fixed_advance_pc:
5642 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, n_op_args);
5644 fprintf (asm_out_file, "\t%s opcode: 0x%x has %d args",
5645 ASM_COMMENT_START, opc, n_op_args);
5646 fputc ('\n', asm_out_file);
5650 fprintf (asm_out_file, "%s Include Directory Table\n", ASM_COMMENT_START);
5652 /* Include directory table is empty, at present */
5653 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5654 fputc ('\n', asm_out_file);
5656 fprintf (asm_out_file, "%s File Name Table\n", ASM_COMMENT_START);
5658 for (ft_index = 1; ft_index < file_table_in_use; ++ft_index)
5662 ASM_OUTPUT_DWARF_STRING (asm_out_file, file_table[ft_index]);
5663 fprintf (asm_out_file, "%s File Entry: 0x%lx",
5664 ASM_COMMENT_START, ft_index);
5668 ASM_OUTPUT_ASCII (asm_out_file,
5669 file_table[ft_index],
5670 (int) strlen (file_table[ft_index]) + 1);
5673 fputc ('\n', asm_out_file);
5675 /* Include directory index */
5677 fputc ('\n', asm_out_file);
5679 /* Modification time */
5681 fputc ('\n', asm_out_file);
5683 /* File length in bytes */
5685 fputc ('\n', asm_out_file);
5688 /* Terminate the file name table */
5689 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5690 fputc ('\n', asm_out_file);
5692 /* We used to set the address register to the first location in the text
5693 section here, but that didn't accomplish anything since we already
5694 have a line note for the opening brace of the first function. */
5696 /* Generate the line number to PC correspondence table, encoded as
5697 a series of state machine operations. */
5700 strcpy (prev_line_label, text_section_label);
5701 for (lt_index = 1; lt_index < line_info_table_in_use; ++lt_index)
5703 register dw_line_info_ref line_info = &line_info_table[lt_index];
5706 /* Disable this optimization for now; GDB wants to see two line notes
5707 at the beginning of a function so it can find the end of the
5710 /* Don't emit anything for redundant notes. Just updating the
5711 address doesn't accomplish anything, because we already assume
5712 that anything after the last address is this line. */
5713 if (line_info->dw_line_num == current_line
5714 && line_info->dw_file_num == current_file)
5718 /* Emit debug info for the address of the current line, choosing
5719 the encoding that uses the least amount of space. */
5720 /* ??? Unfortunately, we have little choice here currently, and must
5721 always use the most general form. Gcc does not know the address
5722 delta itself, so we can't use DW_LNS_advance_pc. There are no known
5723 dwarf2 aware assemblers at this time, so we can't use any special
5724 pseudo ops that would allow the assembler to optimally encode this for
5725 us. Many ports do have length attributes which will give an upper
5726 bound on the address range. We could perhaps use length attributes
5727 to determine when it is safe to use DW_LNS_fixed_advance_pc. */
5728 ASM_GENERATE_INTERNAL_LABEL (line_label, LINE_CODE_LABEL, lt_index);
5731 /* This can handle deltas up to 0xffff. This takes 3 bytes. */
5732 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc);
5734 fprintf (asm_out_file, "\t%s DW_LNS_fixed_advance_pc",
5737 fputc ('\n', asm_out_file);
5738 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, line_label, prev_line_label);
5739 fputc ('\n', asm_out_file);
5743 /* This can handle any delta. This takes 4+PTR_SIZE bytes. */
5744 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5746 fprintf (asm_out_file, "\t%s DW_LNE_set_address",
5748 fputc ('\n', asm_out_file);
5749 output_uleb128 (1 + PTR_SIZE);
5750 fputc ('\n', asm_out_file);
5751 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address);
5752 fputc ('\n', asm_out_file);
5753 ASM_OUTPUT_DWARF_ADDR (asm_out_file, line_label);
5754 fputc ('\n', asm_out_file);
5756 strcpy (prev_line_label, line_label);
5758 /* Emit debug info for the source file of the current line, if
5759 different from the previous line. */
5760 if (line_info->dw_file_num != current_file)
5762 current_file = line_info->dw_file_num;
5763 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_set_file);
5765 fprintf (asm_out_file, "\t%s DW_LNS_set_file", ASM_COMMENT_START);
5767 fputc ('\n', asm_out_file);
5768 output_uleb128 (current_file);
5770 fprintf (asm_out_file, " (\"%s\")", file_table[current_file]);
5772 fputc ('\n', asm_out_file);
5775 /* Emit debug info for the current line number, choosing the encoding
5776 that uses the least amount of space. */
5777 if (line_info->dw_line_num != current_line)
5779 line_offset = line_info->dw_line_num - current_line;
5780 line_delta = line_offset - DWARF_LINE_BASE;
5781 current_line = line_info->dw_line_num;
5782 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
5784 /* This can handle deltas from -10 to 234, using the current
5785 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE. This
5787 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
5788 DWARF_LINE_OPCODE_BASE + line_delta);
5790 fprintf (asm_out_file,
5791 "\t%s line %ld", ASM_COMMENT_START, current_line);
5793 fputc ('\n', asm_out_file);
5797 /* This can handle any delta. This takes at least 4 bytes,
5798 depending on the value being encoded. */
5799 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_advance_line);
5801 fprintf (asm_out_file, "\t%s advance to line %ld",
5802 ASM_COMMENT_START, current_line);
5804 fputc ('\n', asm_out_file);
5805 output_sleb128 (line_offset);
5806 fputc ('\n', asm_out_file);
5807 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_copy);
5809 fprintf (asm_out_file, "\t%s DW_LNS_copy", ASM_COMMENT_START);
5810 fputc ('\n', asm_out_file);
5815 /* We still need to start a new row, so output a copy insn. */
5816 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_copy);
5818 fprintf (asm_out_file, "\t%s DW_LNS_copy", ASM_COMMENT_START);
5819 fputc ('\n', asm_out_file);
5823 /* Emit debug info for the address of the end of the function. */
5826 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc);
5828 fprintf (asm_out_file, "\t%s DW_LNS_fixed_advance_pc",
5831 fputc ('\n', asm_out_file);
5832 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, text_end_label, prev_line_label);
5833 fputc ('\n', asm_out_file);
5837 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5839 fprintf (asm_out_file, "\t%s DW_LNE_set_address", ASM_COMMENT_START);
5840 fputc ('\n', asm_out_file);
5841 output_uleb128 (1 + PTR_SIZE);
5842 fputc ('\n', asm_out_file);
5843 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address);
5844 fputc ('\n', asm_out_file);
5845 ASM_OUTPUT_DWARF_ADDR (asm_out_file, text_end_label);
5846 fputc ('\n', asm_out_file);
5849 /* Output the marker for the end of the line number info. */
5850 ASM_OUTPUT_LABEL (asm_out_file, ".LTEND");
5851 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5853 fprintf (asm_out_file, "\t%s DW_LNE_end_sequence", ASM_COMMENT_START);
5855 fputc ('\n', asm_out_file);
5857 fputc ('\n', asm_out_file);
5858 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_end_sequence);
5859 fputc ('\n', asm_out_file);
5864 for (lt_index = 0; lt_index < separate_line_info_table_in_use; )
5866 register dw_separate_line_info_ref line_info
5867 = &separate_line_info_table[lt_index];
5870 /* Don't emit anything for redundant notes. */
5871 if (line_info->dw_line_num == current_line
5872 && line_info->dw_file_num == current_file
5873 && line_info->function == function)
5877 /* Emit debug info for the address of the current line. If this is
5878 a new function, or the first line of a function, then we need
5879 to handle it differently. */
5880 ASM_GENERATE_INTERNAL_LABEL (line_label, SEPARATE_LINE_CODE_LABEL,
5882 if (function != line_info->function)
5884 function = line_info->function;
5886 /* Set the address register to the first line in the function */
5887 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5889 fprintf (asm_out_file, "\t%s DW_LNE_set_address",
5892 fputc ('\n', asm_out_file);
5893 output_uleb128 (1 + PTR_SIZE);
5894 fputc ('\n', asm_out_file);
5895 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address);
5896 fputc ('\n', asm_out_file);
5897 ASM_OUTPUT_DWARF_ADDR (asm_out_file, line_label);
5898 fputc ('\n', asm_out_file);
5902 /* ??? See the DW_LNS_advance_pc comment above. */
5905 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc);
5907 fprintf (asm_out_file, "\t%s DW_LNS_fixed_advance_pc",
5910 fputc ('\n', asm_out_file);
5911 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, line_label,
5913 fputc ('\n', asm_out_file);
5917 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5919 fprintf (asm_out_file, "\t%s DW_LNE_set_address",
5921 fputc ('\n', asm_out_file);
5922 output_uleb128 (1 + PTR_SIZE);
5923 fputc ('\n', asm_out_file);
5924 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address);
5925 fputc ('\n', asm_out_file);
5926 ASM_OUTPUT_DWARF_ADDR (asm_out_file, line_label);
5927 fputc ('\n', asm_out_file);
5930 strcpy (prev_line_label, line_label);
5932 /* Emit debug info for the source file of the current line, if
5933 different from the previous line. */
5934 if (line_info->dw_file_num != current_file)
5936 current_file = line_info->dw_file_num;
5937 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_set_file);
5939 fprintf (asm_out_file, "\t%s DW_LNS_set_file", ASM_COMMENT_START);
5941 fputc ('\n', asm_out_file);
5942 output_uleb128 (current_file);
5944 fprintf (asm_out_file, " (\"%s\")", file_table[current_file]);
5946 fputc ('\n', asm_out_file);
5949 /* Emit debug info for the current line number, choosing the encoding
5950 that uses the least amount of space. */
5951 if (line_info->dw_line_num != current_line)
5953 line_offset = line_info->dw_line_num - current_line;
5954 line_delta = line_offset - DWARF_LINE_BASE;
5955 current_line = line_info->dw_line_num;
5956 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
5958 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
5959 DWARF_LINE_OPCODE_BASE + line_delta);
5961 fprintf (asm_out_file,
5962 "\t%s line %ld", ASM_COMMENT_START, current_line);
5964 fputc ('\n', asm_out_file);
5968 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_advance_line);
5970 fprintf (asm_out_file, "\t%s advance to line %ld",
5971 ASM_COMMENT_START, current_line);
5973 fputc ('\n', asm_out_file);
5974 output_sleb128 (line_offset);
5975 fputc ('\n', asm_out_file);
5976 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_copy);
5978 fprintf (asm_out_file, "\t%s DW_LNS_copy", ASM_COMMENT_START);
5979 fputc ('\n', asm_out_file);
5984 /* We still need to start a new row, so output a copy insn. */
5985 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_copy);
5987 fprintf (asm_out_file, "\t%s DW_LNS_copy", ASM_COMMENT_START);
5988 fputc ('\n', asm_out_file);
5996 /* If we're done with a function, end its sequence. */
5997 if (lt_index == separate_line_info_table_in_use
5998 || separate_line_info_table[lt_index].function != function)
6003 /* Emit debug info for the address of the end of the function. */
6004 ASM_GENERATE_INTERNAL_LABEL (line_label, FUNC_END_LABEL, function);
6007 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc);
6009 fprintf (asm_out_file, "\t%s DW_LNS_fixed_advance_pc",
6012 fputc ('\n', asm_out_file);
6013 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, line_label,
6015 fputc ('\n', asm_out_file);
6019 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
6021 fprintf (asm_out_file, "\t%s DW_LNE_set_address",
6023 fputc ('\n', asm_out_file);
6024 output_uleb128 (1 + PTR_SIZE);
6025 fputc ('\n', asm_out_file);
6026 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address);
6027 fputc ('\n', asm_out_file);
6028 ASM_OUTPUT_DWARF_ADDR (asm_out_file, line_label);
6029 fputc ('\n', asm_out_file);
6032 /* Output the marker for the end of this sequence. */
6033 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
6035 fprintf (asm_out_file, "\t%s DW_LNE_end_sequence",
6038 fputc ('\n', asm_out_file);
6040 fputc ('\n', asm_out_file);
6041 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_end_sequence);
6042 fputc ('\n', asm_out_file);
6047 /* Given a pointer to a BLOCK node return non-zero if (and only if) the node
6048 in question represents the outermost pair of curly braces (i.e. the "body
6049 block") of a function or method.
6051 For any BLOCK node representing a "body block" of a function or method, the
6052 BLOCK_SUPERCONTEXT of the node will point to another BLOCK node which
6053 represents the outermost (function) scope for the function or method (i.e.
6054 the one which includes the formal parameters). The BLOCK_SUPERCONTEXT of
6055 *that* node in turn will point to the relevant FUNCTION_DECL node. */
6058 is_body_block (stmt)
6061 if (TREE_CODE (stmt) == BLOCK)
6063 register tree parent = BLOCK_SUPERCONTEXT (stmt);
6065 if (TREE_CODE (parent) == BLOCK)
6067 register tree grandparent = BLOCK_SUPERCONTEXT (parent);
6069 if (TREE_CODE (grandparent) == FUNCTION_DECL)
6077 /* Given a pointer to a tree node for some base type, return a pointer to
6078 a DIE that describes the given type.
6080 This routine must only be called for GCC type nodes that correspond to
6081 Dwarf base (fundamental) types. */
6084 base_type_die (type)
6087 register dw_die_ref base_type_result;
6088 register const char *type_name;
6089 register enum dwarf_type encoding;
6090 register tree name = TYPE_NAME (type);
6092 if (TREE_CODE (type) == ERROR_MARK
6093 || TREE_CODE (type) == VOID_TYPE)
6098 if (TREE_CODE (name) == TYPE_DECL)
6099 name = DECL_NAME (name);
6101 type_name = IDENTIFIER_POINTER (name);
6104 type_name = "__unknown__";
6106 switch (TREE_CODE (type))
6109 /* Carefully distinguish the C character types, without messing
6110 up if the language is not C. Note that we check only for the names
6111 that contain spaces; other names might occur by coincidence in other
6113 if (! (TYPE_PRECISION (type) == CHAR_TYPE_SIZE
6114 && (type == char_type_node
6115 || ! strcmp (type_name, "signed char")
6116 || ! strcmp (type_name, "unsigned char"))))
6118 if (TREE_UNSIGNED (type))
6119 encoding = DW_ATE_unsigned;
6121 encoding = DW_ATE_signed;
6124 /* else fall through */
6127 /* GNU Pascal/Ada CHAR type. Not used in C. */
6128 if (TREE_UNSIGNED (type))
6129 encoding = DW_ATE_unsigned_char;
6131 encoding = DW_ATE_signed_char;
6135 encoding = DW_ATE_float;
6138 /* Dwarf2 doesn't know anything about complex ints, so use
6139 a user defined type for it. */
6141 if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
6142 encoding = DW_ATE_complex_float;
6144 encoding = DW_ATE_lo_user;
6148 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */
6149 encoding = DW_ATE_boolean;
6153 abort (); /* No other TREE_CODEs are Dwarf fundamental types. */
6156 base_type_result = new_die (DW_TAG_base_type, comp_unit_die);
6157 if (demangle_name_func)
6158 type_name = (*demangle_name_func) (type_name);
6160 add_AT_string (base_type_result, DW_AT_name, type_name);
6161 add_AT_unsigned (base_type_result, DW_AT_byte_size,
6162 int_size_in_bytes (type));
6163 add_AT_unsigned (base_type_result, DW_AT_encoding, encoding);
6165 return base_type_result;
6168 /* Given a pointer to an arbitrary ..._TYPE tree node, return a pointer to
6169 the Dwarf "root" type for the given input type. The Dwarf "root" type of
6170 a given type is generally the same as the given type, except that if the
6171 given type is a pointer or reference type, then the root type of the given
6172 type is the root type of the "basis" type for the pointer or reference
6173 type. (This definition of the "root" type is recursive.) Also, the root
6174 type of a `const' qualified type or a `volatile' qualified type is the
6175 root type of the given type without the qualifiers. */
6181 if (TREE_CODE (type) == ERROR_MARK)
6182 return error_mark_node;
6184 switch (TREE_CODE (type))
6187 return error_mark_node;
6190 case REFERENCE_TYPE:
6191 return type_main_variant (root_type (TREE_TYPE (type)));
6194 return type_main_variant (type);
6198 /* Given a pointer to an arbitrary ..._TYPE tree node, return non-zero if the
6199 given input type is a Dwarf "fundamental" type. Otherwise return null. */
6205 switch (TREE_CODE (type))
6220 case QUAL_UNION_TYPE:
6225 case REFERENCE_TYPE:
6238 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
6239 entry that chains various modifiers in front of the given type. */
6242 modified_type_die (type, is_const_type, is_volatile_type, context_die)
6244 register int is_const_type;
6245 register int is_volatile_type;
6246 register dw_die_ref context_die;
6248 register enum tree_code code = TREE_CODE (type);
6249 register dw_die_ref mod_type_die = NULL;
6250 register dw_die_ref sub_die = NULL;
6251 register tree item_type = NULL;
6253 if (code != ERROR_MARK)
6255 type = build_type_variant (type, is_const_type, is_volatile_type);
6257 mod_type_die = lookup_type_die (type);
6259 return mod_type_die;
6261 /* Handle C typedef types. */
6262 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
6263 && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
6265 tree dtype = TREE_TYPE (TYPE_NAME (type));
6268 /* For a named type, use the typedef. */
6269 gen_type_die (type, context_die);
6270 mod_type_die = lookup_type_die (type);
6273 else if (is_const_type < TYPE_READONLY (dtype)
6274 || is_volatile_type < TYPE_VOLATILE (dtype))
6275 /* cv-unqualified version of named type. Just use the unnamed
6276 type to which it refers. */
6278 = modified_type_die (DECL_ORIGINAL_TYPE (TYPE_NAME (type)),
6279 is_const_type, is_volatile_type,
6281 /* Else cv-qualified version of named type; fall through. */
6286 else if (is_const_type)
6288 mod_type_die = new_die (DW_TAG_const_type, comp_unit_die);
6289 sub_die = modified_type_die (type, 0, is_volatile_type, context_die);
6291 else if (is_volatile_type)
6293 mod_type_die = new_die (DW_TAG_volatile_type, comp_unit_die);
6294 sub_die = modified_type_die (type, 0, 0, context_die);
6296 else if (code == POINTER_TYPE)
6298 mod_type_die = new_die (DW_TAG_pointer_type, comp_unit_die);
6299 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
6301 add_AT_unsigned (mod_type_die, DW_AT_address_class, 0);
6303 item_type = TREE_TYPE (type);
6305 else if (code == REFERENCE_TYPE)
6307 mod_type_die = new_die (DW_TAG_reference_type, comp_unit_die);
6308 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
6310 add_AT_unsigned (mod_type_die, DW_AT_address_class, 0);
6312 item_type = TREE_TYPE (type);
6314 else if (is_base_type (type))
6315 mod_type_die = base_type_die (type);
6318 gen_type_die (type, context_die);
6320 /* We have to get the type_main_variant here (and pass that to the
6321 `lookup_type_die' routine) because the ..._TYPE node we have
6322 might simply be a *copy* of some original type node (where the
6323 copy was created to help us keep track of typedef names) and
6324 that copy might have a different TYPE_UID from the original
6326 mod_type_die = lookup_type_die (type_main_variant (type));
6327 if (mod_type_die == NULL)
6332 equate_type_number_to_die (type, mod_type_die);
6334 /* We must do this after the equate_type_number_to_die call, in case
6335 this is a recursive type. This ensures that the modified_type_die
6336 recursion will terminate even if the type is recursive. Recursive
6337 types are possible in Ada. */
6338 sub_die = modified_type_die (item_type,
6339 TYPE_READONLY (item_type),
6340 TYPE_VOLATILE (item_type),
6343 if (sub_die != NULL)
6344 add_AT_die_ref (mod_type_die, DW_AT_type, sub_die);
6346 return mod_type_die;
6349 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
6350 an enumerated type. */
6356 return TREE_CODE (type) == ENUMERAL_TYPE;
6359 /* Return a location descriptor that designates a machine register. */
6361 static dw_loc_descr_ref
6362 reg_loc_descriptor (rtl)
6365 register dw_loc_descr_ref loc_result = NULL;
6366 register unsigned reg = reg_number (rtl);
6369 loc_result = new_loc_descr (DW_OP_reg0 + reg, 0, 0);
6371 loc_result = new_loc_descr (DW_OP_regx, reg, 0);
6376 /* Return a location descriptor that designates a base+offset location. */
6378 static dw_loc_descr_ref
6379 based_loc_descr (reg, offset)
6383 register dw_loc_descr_ref loc_result;
6384 /* For the "frame base", we use the frame pointer or stack pointer
6385 registers, since the RTL for local variables is relative to one of
6387 register unsigned fp_reg = DBX_REGISTER_NUMBER (frame_pointer_needed
6388 ? HARD_FRAME_POINTER_REGNUM
6389 : STACK_POINTER_REGNUM);
6392 loc_result = new_loc_descr (DW_OP_fbreg, offset, 0);
6394 loc_result = new_loc_descr (DW_OP_breg0 + reg, offset, 0);
6396 loc_result = new_loc_descr (DW_OP_bregx, reg, offset);
6401 /* Return true if this RTL expression describes a base+offset calculation. */
6407 return (GET_CODE (rtl) == PLUS
6408 && ((GET_CODE (XEXP (rtl, 0)) == REG
6409 && GET_CODE (XEXP (rtl, 1)) == CONST_INT)));
6412 /* The following routine converts the RTL for a variable or parameter
6413 (resident in memory) into an equivalent Dwarf representation of a
6414 mechanism for getting the address of that same variable onto the top of a
6415 hypothetical "address evaluation" stack.
6417 When creating memory location descriptors, we are effectively transforming
6418 the RTL for a memory-resident object into its Dwarf postfix expression
6419 equivalent. This routine recursively descends an RTL tree, turning
6420 it into Dwarf postfix code as it goes.
6422 MODE is the mode of the memory reference, needed to handle some
6423 autoincrement addressing modes. */
6425 static dw_loc_descr_ref
6426 mem_loc_descriptor (rtl, mode)
6428 enum machine_mode mode;
6430 dw_loc_descr_ref mem_loc_result = NULL;
6431 /* Note that for a dynamically sized array, the location we will generate a
6432 description of here will be the lowest numbered location which is
6433 actually within the array. That's *not* necessarily the same as the
6434 zeroth element of the array. */
6436 switch (GET_CODE (rtl))
6440 /* POST_INC and POST_DEC can be handled just like a SUBREG. So we
6441 just fall into the SUBREG code. */
6443 /* ... fall through ... */
6446 /* The case of a subreg may arise when we have a local (register)
6447 variable or a formal (register) parameter which doesn't quite fill
6448 up an entire register. For now, just assume that it is
6449 legitimate to make the Dwarf info refer to the whole register which
6450 contains the given subreg. */
6451 rtl = XEXP (rtl, 0);
6453 /* ... fall through ... */
6456 /* Whenever a register number forms a part of the description of the
6457 method for calculating the (dynamic) address of a memory resident
6458 object, DWARF rules require the register number be referred to as
6459 a "base register". This distinction is not based in any way upon
6460 what category of register the hardware believes the given register
6461 belongs to. This is strictly DWARF terminology we're dealing with
6462 here. Note that in cases where the location of a memory-resident
6463 data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
6464 OP_CONST (0)) the actual DWARF location descriptor that we generate
6465 may just be OP_BASEREG (basereg). This may look deceptively like
6466 the object in question was allocated to a register (rather than in
6467 memory) so DWARF consumers need to be aware of the subtle
6468 distinction between OP_REG and OP_BASEREG. */
6469 mem_loc_result = based_loc_descr (reg_number (rtl), 0);
6473 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), mode);
6474 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_deref, 0, 0));
6478 /* Some ports can transform a symbol ref into a label ref, because
6479 the symbol ref is too far away and has to be dumped into a constant
6483 mem_loc_result = new_loc_descr (DW_OP_addr, 0, 0);
6484 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_addr;
6485 mem_loc_result->dw_loc_oprnd1.v.val_addr = addr_to_string (rtl);
6490 /* Turn these into a PLUS expression and fall into the PLUS code
6492 rtl = gen_rtx_PLUS (word_mode, XEXP (rtl, 0),
6493 GEN_INT (GET_CODE (rtl) == PRE_INC
6494 ? GET_MODE_UNIT_SIZE (mode)
6495 : - GET_MODE_UNIT_SIZE (mode)));
6497 /* ... fall through ... */
6500 if (is_based_loc (rtl))
6501 mem_loc_result = based_loc_descr (reg_number (XEXP (rtl, 0)),
6502 INTVAL (XEXP (rtl, 1)));
6505 add_loc_descr (&mem_loc_result, mem_loc_descriptor (XEXP (rtl, 0),
6507 add_loc_descr (&mem_loc_result, mem_loc_descriptor (XEXP (rtl, 1),
6509 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_plus, 0, 0));
6514 /* If a pseudo-reg is optimized away, it is possible for it to
6515 be replaced with a MEM containing a multiply. */
6516 add_loc_descr (&mem_loc_result, mem_loc_descriptor (XEXP (rtl, 0), mode));
6517 add_loc_descr (&mem_loc_result, mem_loc_descriptor (XEXP (rtl, 1), mode));
6518 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_mul, 0, 0));
6522 mem_loc_result = new_loc_descr (DW_OP_constu, INTVAL (rtl), 0);
6529 return mem_loc_result;
6532 /* Return a descriptor that describes the concatenation of two locations.
6533 This is typically a complex variable. */
6535 static dw_loc_descr_ref
6536 concat_loc_descriptor (x0, x1)
6537 register rtx x0, x1;
6539 dw_loc_descr_ref cc_loc_result = NULL;
6541 if (!is_pseudo_reg (x0)
6542 && (GET_CODE (x0) != MEM || !is_pseudo_reg (XEXP (x0, 0))))
6543 add_loc_descr (&cc_loc_result, loc_descriptor (x0));
6544 add_loc_descr (&cc_loc_result,
6545 new_loc_descr (DW_OP_piece, GET_MODE_SIZE (GET_MODE (x0)), 0));
6547 if (!is_pseudo_reg (x1)
6548 && (GET_CODE (x1) != MEM || !is_pseudo_reg (XEXP (x1, 0))))
6549 add_loc_descr (&cc_loc_result, loc_descriptor (x1));
6550 add_loc_descr (&cc_loc_result,
6551 new_loc_descr (DW_OP_piece, GET_MODE_SIZE (GET_MODE (x1)), 0));
6553 return cc_loc_result;
6556 /* Output a proper Dwarf location descriptor for a variable or parameter
6557 which is either allocated in a register or in a memory location. For a
6558 register, we just generate an OP_REG and the register number. For a
6559 memory location we provide a Dwarf postfix expression describing how to
6560 generate the (dynamic) address of the object onto the address stack. */
6562 static dw_loc_descr_ref
6563 loc_descriptor (rtl)
6566 dw_loc_descr_ref loc_result = NULL;
6567 switch (GET_CODE (rtl))
6570 /* The case of a subreg may arise when we have a local (register)
6571 variable or a formal (register) parameter which doesn't quite fill
6572 up an entire register. For now, just assume that it is
6573 legitimate to make the Dwarf info refer to the whole register which
6574 contains the given subreg. */
6575 rtl = XEXP (rtl, 0);
6577 /* ... fall through ... */
6580 loc_result = reg_loc_descriptor (rtl);
6584 loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl));
6588 loc_result = concat_loc_descriptor (XEXP (rtl, 0), XEXP (rtl, 1));
6598 /* Given an unsigned value, round it up to the lowest multiple of `boundary'
6599 which is not less than the value itself. */
6601 static inline unsigned
6602 ceiling (value, boundary)
6603 register unsigned value;
6604 register unsigned boundary;
6606 return (((value + boundary - 1) / boundary) * boundary);
6609 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
6610 pointer to the declared type for the relevant field variable, or return
6611 `integer_type_node' if the given node turns out to be an
6620 if (TREE_CODE (decl) == ERROR_MARK)
6621 return integer_type_node;
6623 type = DECL_BIT_FIELD_TYPE (decl);
6624 if (type == NULL_TREE)
6625 type = TREE_TYPE (decl);
6630 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
6631 node, return the alignment in bits for the type, or else return
6632 BITS_PER_WORD if the node actually turns out to be an
6635 static inline unsigned
6636 simple_type_align_in_bits (type)
6639 return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD;
6642 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
6643 node, return the size in bits for the type if it is a constant, or else
6644 return the alignment for the type if the type's size is not constant, or
6645 else return BITS_PER_WORD if the type actually turns out to be an
6648 static inline unsigned
6649 simple_type_size_in_bits (type)
6652 if (TREE_CODE (type) == ERROR_MARK)
6653 return BITS_PER_WORD;
6656 register tree type_size_tree = TYPE_SIZE (type);
6658 if (TREE_CODE (type_size_tree) != INTEGER_CST)
6659 return TYPE_ALIGN (type);
6661 return (unsigned) TREE_INT_CST_LOW (type_size_tree);
6665 /* Given a pointer to what is assumed to be a FIELD_DECL node, compute and
6666 return the byte offset of the lowest addressed byte of the "containing
6667 object" for the given FIELD_DECL, or return 0 if we are unable to
6668 determine what that offset is, either because the argument turns out to
6669 be a pointer to an ERROR_MARK node, or because the offset is actually
6670 variable. (We can't handle the latter case just yet). */
6673 field_byte_offset (decl)
6676 register unsigned type_align_in_bytes;
6677 register unsigned type_align_in_bits;
6678 register unsigned type_size_in_bits;
6679 register unsigned object_offset_in_align_units;
6680 register unsigned object_offset_in_bits;
6681 register unsigned object_offset_in_bytes;
6683 register tree bitpos_tree;
6684 register tree field_size_tree;
6685 register unsigned bitpos_int;
6686 register unsigned deepest_bitpos;
6687 register unsigned field_size_in_bits;
6689 if (TREE_CODE (decl) == ERROR_MARK)
6692 if (TREE_CODE (decl) != FIELD_DECL)
6695 type = field_type (decl);
6697 bitpos_tree = DECL_FIELD_BITPOS (decl);
6698 field_size_tree = DECL_SIZE (decl);
6700 /* If there was an error, the size could be zero. */
6701 if (! field_size_tree)
6708 /* We cannot yet cope with fields whose positions are variable, so
6709 for now, when we see such things, we simply return 0. Someday, we may
6710 be able to handle such cases, but it will be damn difficult. */
6711 if (TREE_CODE (bitpos_tree) != INTEGER_CST)
6714 bitpos_int = (unsigned) TREE_INT_CST_LOW (bitpos_tree);
6716 /* If we don't know the size of the field, pretend it's a full word. */
6717 if (TREE_CODE (field_size_tree) == INTEGER_CST)
6718 field_size_in_bits = (unsigned) TREE_INT_CST_LOW (field_size_tree);
6720 field_size_in_bits = BITS_PER_WORD;
6722 type_size_in_bits = simple_type_size_in_bits (type);
6723 type_align_in_bits = simple_type_align_in_bits (type);
6724 type_align_in_bytes = type_align_in_bits / BITS_PER_UNIT;
6726 /* Note that the GCC front-end doesn't make any attempt to keep track of
6727 the starting bit offset (relative to the start of the containing
6728 structure type) of the hypothetical "containing object" for a bit-
6729 field. Thus, when computing the byte offset value for the start of the
6730 "containing object" of a bit-field, we must deduce this information on
6731 our own. This can be rather tricky to do in some cases. For example,
6732 handling the following structure type definition when compiling for an
6733 i386/i486 target (which only aligns long long's to 32-bit boundaries)
6736 struct S { int field1; long long field2:31; };
6738 Fortunately, there is a simple rule-of-thumb which can be
6739 used in such cases. When compiling for an i386/i486, GCC will allocate
6740 8 bytes for the structure shown above. It decides to do this based upon
6741 one simple rule for bit-field allocation. Quite simply, GCC allocates
6742 each "containing object" for each bit-field at the first (i.e. lowest
6743 addressed) legitimate alignment boundary (based upon the required
6744 minimum alignment for the declared type of the field) which it can
6745 possibly use, subject to the condition that there is still enough
6746 available space remaining in the containing object (when allocated at
6747 the selected point) to fully accommodate all of the bits of the
6748 bit-field itself. This simple rule makes it obvious why GCC allocates
6749 8 bytes for each object of the structure type shown above. When looking
6750 for a place to allocate the "containing object" for `field2', the
6751 compiler simply tries to allocate a 64-bit "containing object" at each
6752 successive 32-bit boundary (starting at zero) until it finds a place to
6753 allocate that 64- bit field such that at least 31 contiguous (and
6754 previously unallocated) bits remain within that selected 64 bit field.
6755 (As it turns out, for the example above, the compiler finds that it is
6756 OK to allocate the "containing object" 64-bit field at bit-offset zero
6757 within the structure type.) Here we attempt to work backwards from the
6758 limited set of facts we're given, and we try to deduce from those facts,
6759 where GCC must have believed that the containing object started (within
6760 the structure type). The value we deduce is then used (by the callers of
6761 this routine) to generate DW_AT_location and DW_AT_bit_offset attributes
6762 for fields (both bit-fields and, in the case of DW_AT_location, regular
6765 /* Figure out the bit-distance from the start of the structure to the
6766 "deepest" bit of the bit-field. */
6767 deepest_bitpos = bitpos_int + field_size_in_bits;
6769 /* This is the tricky part. Use some fancy footwork to deduce where the
6770 lowest addressed bit of the containing object must be. */
6771 object_offset_in_bits
6772 = ceiling (deepest_bitpos, type_align_in_bits) - type_size_in_bits;
6774 /* Compute the offset of the containing object in "alignment units". */
6775 object_offset_in_align_units = object_offset_in_bits / type_align_in_bits;
6777 /* Compute the offset of the containing object in bytes. */
6778 object_offset_in_bytes = object_offset_in_align_units * type_align_in_bytes;
6780 return object_offset_in_bytes;
6783 /* The following routines define various Dwarf attributes and any data
6784 associated with them. */
6786 /* Add a location description attribute value to a DIE.
6788 This emits location attributes suitable for whole variables and
6789 whole parameters. Note that the location attributes for struct fields are
6790 generated by the routine `data_member_location_attribute' below. */
6793 add_AT_location_description (die, attr_kind, rtl)
6795 enum dwarf_attribute attr_kind;
6798 /* Handle a special case. If we are about to output a location descriptor
6799 for a variable or parameter which has been optimized out of existence,
6800 don't do that. A variable which has been optimized out
6801 of existence will have a DECL_RTL value which denotes a pseudo-reg.
6802 Currently, in some rare cases, variables can have DECL_RTL values which
6803 look like (MEM (REG pseudo-reg#)). These cases are due to bugs
6804 elsewhere in the compiler. We treat such cases as if the variable(s) in
6805 question had been optimized out of existence. */
6807 if (is_pseudo_reg (rtl)
6808 || (GET_CODE (rtl) == MEM
6809 && is_pseudo_reg (XEXP (rtl, 0)))
6810 /* This can happen for a PARM_DECL with a DECL_INCOMING_RTL which
6811 references the internal argument pointer (a pseudo) in a function
6812 where all references to the internal argument pointer were
6813 eliminated via the optimizers. */
6814 || (GET_CODE (rtl) == MEM
6815 && GET_CODE (XEXP (rtl, 0)) == PLUS
6816 && is_pseudo_reg (XEXP (XEXP (rtl, 0), 0)))
6817 || (GET_CODE (rtl) == CONCAT
6818 && is_pseudo_reg (XEXP (rtl, 0))
6819 && is_pseudo_reg (XEXP (rtl, 1))))
6822 add_AT_loc (die, attr_kind, loc_descriptor (rtl));
6825 /* Attach the specialized form of location attribute used for data
6826 members of struct and union types. In the special case of a
6827 FIELD_DECL node which represents a bit-field, the "offset" part
6828 of this special location descriptor must indicate the distance
6829 in bytes from the lowest-addressed byte of the containing struct
6830 or union type to the lowest-addressed byte of the "containing
6831 object" for the bit-field. (See the `field_byte_offset' function
6832 above).. For any given bit-field, the "containing object" is a
6833 hypothetical object (of some integral or enum type) within which
6834 the given bit-field lives. The type of this hypothetical
6835 "containing object" is always the same as the declared type of
6836 the individual bit-field itself (for GCC anyway... the DWARF
6837 spec doesn't actually mandate this). Note that it is the size
6838 (in bytes) of the hypothetical "containing object" which will
6839 be given in the DW_AT_byte_size attribute for this bit-field.
6840 (See the `byte_size_attribute' function below.) It is also used
6841 when calculating the value of the DW_AT_bit_offset attribute.
6842 (See the `bit_offset_attribute' function below). */
6845 add_data_member_location_attribute (die, decl)
6846 register dw_die_ref die;
6849 register unsigned long offset;
6850 register dw_loc_descr_ref loc_descr;
6851 register enum dwarf_location_atom op;
6853 if (TREE_CODE (decl) == TREE_VEC)
6854 offset = TREE_INT_CST_LOW (BINFO_OFFSET (decl));
6856 offset = field_byte_offset (decl);
6858 /* The DWARF2 standard says that we should assume that the structure address
6859 is already on the stack, so we can specify a structure field address
6860 by using DW_OP_plus_uconst. */
6862 #ifdef MIPS_DEBUGGING_INFO
6863 /* ??? The SGI dwarf reader does not handle the DW_OP_plus_uconst operator
6864 correctly. It works only if we leave the offset on the stack. */
6867 op = DW_OP_plus_uconst;
6870 loc_descr = new_loc_descr (op, offset, 0);
6871 add_AT_loc (die, DW_AT_data_member_location, loc_descr);
6874 /* Attach an DW_AT_const_value attribute for a variable or a parameter which
6875 does not have a "location" either in memory or in a register. These
6876 things can arise in GNU C when a constant is passed as an actual parameter
6877 to an inlined function. They can also arise in C++ where declared
6878 constants do not necessarily get memory "homes". */
6881 add_const_value_attribute (die, rtl)
6882 register dw_die_ref die;
6885 switch (GET_CODE (rtl))
6888 /* Note that a CONST_INT rtx could represent either an integer or a
6889 floating-point constant. A CONST_INT is used whenever the constant
6890 will fit into a single word. In all such cases, the original mode
6891 of the constant value is wiped out, and the CONST_INT rtx is
6892 assigned VOIDmode. */
6893 add_AT_unsigned (die, DW_AT_const_value, (unsigned) INTVAL (rtl));
6897 /* Note that a CONST_DOUBLE rtx could represent either an integer or a
6898 floating-point constant. A CONST_DOUBLE is used whenever the
6899 constant requires more than one word in order to be adequately
6900 represented. We output CONST_DOUBLEs as blocks. */
6902 register enum machine_mode mode = GET_MODE (rtl);
6904 if (GET_MODE_CLASS (mode) == MODE_FLOAT)
6906 register unsigned length = GET_MODE_SIZE (mode) / sizeof (long);
6910 REAL_VALUE_FROM_CONST_DOUBLE (rv, rtl);
6914 REAL_VALUE_TO_TARGET_SINGLE (rv, array[0]);
6918 REAL_VALUE_TO_TARGET_DOUBLE (rv, array);
6923 REAL_VALUE_TO_TARGET_LONG_DOUBLE (rv, array);
6930 add_AT_float (die, DW_AT_const_value, length, array);
6933 add_AT_long_long (die, DW_AT_const_value,
6934 CONST_DOUBLE_HIGH (rtl), CONST_DOUBLE_LOW (rtl));
6939 add_AT_string (die, DW_AT_const_value, XSTR (rtl, 0));
6945 add_AT_addr (die, DW_AT_const_value, addr_to_string (rtl));
6949 /* In cases where an inlined instance of an inline function is passed
6950 the address of an `auto' variable (which is local to the caller) we
6951 can get a situation where the DECL_RTL of the artificial local
6952 variable (for the inlining) which acts as a stand-in for the
6953 corresponding formal parameter (of the inline function) will look
6954 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not
6955 exactly a compile-time constant expression, but it isn't the address
6956 of the (artificial) local variable either. Rather, it represents the
6957 *value* which the artificial local variable always has during its
6958 lifetime. We currently have no way to represent such quasi-constant
6959 values in Dwarf, so for now we just punt and generate nothing. */
6963 /* No other kinds of rtx should be possible here. */
6969 /* Generate *either* an DW_AT_location attribute or else an DW_AT_const_value
6970 data attribute for a variable or a parameter. We generate the
6971 DW_AT_const_value attribute only in those cases where the given variable
6972 or parameter does not have a true "location" either in memory or in a
6973 register. This can happen (for example) when a constant is passed as an
6974 actual argument in a call to an inline function. (It's possible that
6975 these things can crop up in other ways also.) Note that one type of
6976 constant value which can be passed into an inlined function is a constant
6977 pointer. This can happen for example if an actual argument in an inlined
6978 function call evaluates to a compile-time constant address. */
6981 add_location_or_const_value_attribute (die, decl)
6982 register dw_die_ref die;
6986 register tree declared_type;
6987 register tree passed_type;
6989 if (TREE_CODE (decl) == ERROR_MARK)
6992 if (TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != PARM_DECL)
6995 /* Here we have to decide where we are going to say the parameter "lives"
6996 (as far as the debugger is concerned). We only have a couple of
6997 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
6999 DECL_RTL normally indicates where the parameter lives during most of the
7000 activation of the function. If optimization is enabled however, this
7001 could be either NULL or else a pseudo-reg. Both of those cases indicate
7002 that the parameter doesn't really live anywhere (as far as the code
7003 generation parts of GCC are concerned) during most of the function's
7004 activation. That will happen (for example) if the parameter is never
7005 referenced within the function.
7007 We could just generate a location descriptor here for all non-NULL
7008 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
7009 a little nicer than that if we also consider DECL_INCOMING_RTL in cases
7010 where DECL_RTL is NULL or is a pseudo-reg.
7012 Note however that we can only get away with using DECL_INCOMING_RTL as
7013 a backup substitute for DECL_RTL in certain limited cases. In cases
7014 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
7015 we can be sure that the parameter was passed using the same type as it is
7016 declared to have within the function, and that its DECL_INCOMING_RTL
7017 points us to a place where a value of that type is passed.
7019 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
7020 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
7021 because in these cases DECL_INCOMING_RTL points us to a value of some
7022 type which is *different* from the type of the parameter itself. Thus,
7023 if we tried to use DECL_INCOMING_RTL to generate a location attribute in
7024 such cases, the debugger would end up (for example) trying to fetch a
7025 `float' from a place which actually contains the first part of a
7026 `double'. That would lead to really incorrect and confusing
7027 output at debug-time.
7029 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
7030 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There
7031 are a couple of exceptions however. On little-endian machines we can
7032 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
7033 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
7034 an integral type that is smaller than TREE_TYPE (decl). These cases arise
7035 when (on a little-endian machine) a non-prototyped function has a
7036 parameter declared to be of type `short' or `char'. In such cases,
7037 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
7038 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
7039 passed `int' value. If the debugger then uses that address to fetch
7040 a `short' or a `char' (on a little-endian machine) the result will be
7041 the correct data, so we allow for such exceptional cases below.
7043 Note that our goal here is to describe the place where the given formal
7044 parameter lives during most of the function's activation (i.e. between
7045 the end of the prologue and the start of the epilogue). We'll do that
7046 as best as we can. Note however that if the given formal parameter is
7047 modified sometime during the execution of the function, then a stack
7048 backtrace (at debug-time) will show the function as having been
7049 called with the *new* value rather than the value which was
7050 originally passed in. This happens rarely enough that it is not
7051 a major problem, but it *is* a problem, and I'd like to fix it.
7053 A future version of dwarf2out.c may generate two additional
7054 attributes for any given DW_TAG_formal_parameter DIE which will
7055 describe the "passed type" and the "passed location" for the
7056 given formal parameter in addition to the attributes we now
7057 generate to indicate the "declared type" and the "active
7058 location" for each parameter. This additional set of attributes
7059 could be used by debuggers for stack backtraces. Separately, note
7060 that sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be
7061 NULL also. This happens (for example) for inlined-instances of
7062 inline function formal parameters which are never referenced.
7063 This really shouldn't be happening. All PARM_DECL nodes should
7064 get valid non-NULL DECL_INCOMING_RTL values, but integrate.c
7065 doesn't currently generate these values for inlined instances of
7066 inline function parameters, so when we see such cases, we are
7067 just out-of-luck for the time being (until integrate.c
7070 /* Use DECL_RTL as the "location" unless we find something better. */
7071 rtl = DECL_RTL (decl);
7073 if (TREE_CODE (decl) == PARM_DECL)
7075 if (rtl == NULL_RTX || is_pseudo_reg (rtl))
7077 declared_type = type_main_variant (TREE_TYPE (decl));
7078 passed_type = type_main_variant (DECL_ARG_TYPE (decl));
7080 /* This decl represents a formal parameter which was optimized out.
7081 Note that DECL_INCOMING_RTL may be NULL in here, but we handle
7082 all* cases where (rtl == NULL_RTX) just below. */
7083 if (declared_type == passed_type)
7084 rtl = DECL_INCOMING_RTL (decl);
7085 else if (! BYTES_BIG_ENDIAN
7086 && TREE_CODE (declared_type) == INTEGER_TYPE
7087 && (GET_MODE_SIZE (TYPE_MODE (declared_type))
7088 <= GET_MODE_SIZE (TYPE_MODE (passed_type))))
7089 rtl = DECL_INCOMING_RTL (decl);
7092 /* If the parm was passed in registers, but lives on the stack, then
7093 make a big endian correction if the mode of the type of the
7094 parameter is not the same as the mode of the rtl. */
7095 /* ??? This is the same series of checks that are made in dbxout.c before
7096 we reach the big endian correction code there. It isn't clear if all
7097 of these checks are necessary here, but keeping them all is the safe
7099 else if (GET_CODE (rtl) == MEM
7100 && XEXP (rtl, 0) != const0_rtx
7101 && ! CONSTANT_P (XEXP (rtl, 0))
7102 /* Not passed in memory. */
7103 && GET_CODE (DECL_INCOMING_RTL (decl)) != MEM
7104 /* Not passed by invisible reference. */
7105 && (GET_CODE (XEXP (rtl, 0)) != REG
7106 || REGNO (XEXP (rtl, 0)) == HARD_FRAME_POINTER_REGNUM
7107 || REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM
7108 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
7109 || REGNO (XEXP (rtl, 0)) == ARG_POINTER_REGNUM
7112 /* Big endian correction check. */
7114 && TYPE_MODE (TREE_TYPE (decl)) != GET_MODE (rtl)
7115 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)))
7118 int offset = (UNITS_PER_WORD
7119 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl))));
7120 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
7121 plus_constant (XEXP (rtl, 0), offset));
7125 if (rtl == NULL_RTX)
7128 rtl = eliminate_regs (rtl, 0, NULL_RTX);
7129 #ifdef LEAF_REG_REMAP
7130 if (current_function_uses_only_leaf_regs)
7131 leaf_renumber_regs_insn (rtl);
7134 switch (GET_CODE (rtl))
7137 /* The address of a variable that was optimized away; don't emit
7148 /* DECL_RTL could be (plus (reg ...) (const_int ...)) */
7149 add_const_value_attribute (die, rtl);
7156 add_AT_location_description (die, DW_AT_location, rtl);
7164 /* Generate an DW_AT_name attribute given some string value to be included as
7165 the value of the attribute. */
7168 add_name_attribute (die, name_string)
7169 register dw_die_ref die;
7170 register const char *name_string;
7172 if (name_string != NULL && *name_string != 0)
7174 if (demangle_name_func)
7175 name_string = (*demangle_name_func) (name_string);
7177 add_AT_string (die, DW_AT_name, name_string);
7181 /* Given a tree node describing an array bound (either lower or upper) output
7182 a representation for that bound. */
7185 add_bound_info (subrange_die, bound_attr, bound)
7186 register dw_die_ref subrange_die;
7187 register enum dwarf_attribute bound_attr;
7188 register tree bound;
7190 register unsigned bound_value = 0;
7192 /* If this is an Ada unconstrained array type, then don't emit any debug
7193 info because the array bounds are unknown. They are parameterized when
7194 the type is instantiated. */
7195 if (contains_placeholder_p (bound))
7198 switch (TREE_CODE (bound))
7203 /* All fixed-bounds are represented by INTEGER_CST nodes. */
7205 bound_value = TREE_INT_CST_LOW (bound);
7206 if (bound_attr == DW_AT_lower_bound
7207 && ((is_c_family () && bound_value == 0)
7208 || (is_fortran () && bound_value == 1)))
7209 /* use the default */;
7211 add_AT_unsigned (subrange_die, bound_attr, bound_value);
7216 case NON_LVALUE_EXPR:
7217 add_bound_info (subrange_die, bound_attr, TREE_OPERAND (bound, 0));
7221 /* If optimization is turned on, the SAVE_EXPRs that describe how to
7222 access the upper bound values may be bogus. If they refer to a
7223 register, they may only describe how to get at these values at the
7224 points in the generated code right after they have just been
7225 computed. Worse yet, in the typical case, the upper bound values
7226 will not even *be* computed in the optimized code (though the
7227 number of elements will), so these SAVE_EXPRs are entirely
7228 bogus. In order to compensate for this fact, we check here to see
7229 if optimization is enabled, and if so, we don't add an attribute
7230 for the (unknown and unknowable) upper bound. This should not
7231 cause too much trouble for existing (stupid?) debuggers because
7232 they have to deal with empty upper bounds location descriptions
7233 anyway in order to be able to deal with incomplete array types.
7234 Of course an intelligent debugger (GDB?) should be able to
7235 comprehend that a missing upper bound specification in a array
7236 type used for a storage class `auto' local array variable
7237 indicates that the upper bound is both unknown (at compile- time)
7238 and unknowable (at run-time) due to optimization.
7240 We assume that a MEM rtx is safe because gcc wouldn't put the
7241 value there unless it was going to be used repeatedly in the
7242 function, i.e. for cleanups. */
7243 if (! optimize || GET_CODE (SAVE_EXPR_RTL (bound)) == MEM)
7245 register dw_die_ref ctx = lookup_decl_die (current_function_decl);
7246 register dw_die_ref decl_die = new_die (DW_TAG_variable, ctx);
7247 register rtx loc = SAVE_EXPR_RTL (bound);
7249 /* If the RTL for the SAVE_EXPR is memory, handle the case where
7250 it references an outer function's frame. */
7252 if (GET_CODE (loc) == MEM)
7254 rtx new_addr = fix_lexical_addr (XEXP (loc, 0), bound);
7256 if (XEXP (loc, 0) != new_addr)
7257 loc = gen_rtx_MEM (GET_MODE (loc), new_addr);
7260 add_AT_flag (decl_die, DW_AT_artificial, 1);
7261 add_type_attribute (decl_die, TREE_TYPE (bound), 1, 0, ctx);
7262 add_AT_location_description (decl_die, DW_AT_location, loc);
7263 add_AT_die_ref (subrange_die, bound_attr, decl_die);
7266 /* Else leave out the attribute. */
7272 /* ??? These types of bounds can be created by the Ada front end,
7273 and it isn't clear how to emit debug info for them. */
7281 /* Note that the block of subscript information for an array type also
7282 includes information about the element type of type given array type. */
7285 add_subscript_info (type_die, type)
7286 register dw_die_ref type_die;
7289 #ifndef MIPS_DEBUGGING_INFO
7290 register unsigned dimension_number;
7292 register tree lower, upper;
7293 register dw_die_ref subrange_die;
7295 /* The GNU compilers represent multidimensional array types as sequences of
7296 one dimensional array types whose element types are themselves array
7297 types. Here we squish that down, so that each multidimensional array
7298 type gets only one array_type DIE in the Dwarf debugging info. The draft
7299 Dwarf specification say that we are allowed to do this kind of
7300 compression in C (because there is no difference between an array or
7301 arrays and a multidimensional array in C) but for other source languages
7302 (e.g. Ada) we probably shouldn't do this. */
7304 /* ??? The SGI dwarf reader fails for multidimensional arrays with a
7305 const enum type. E.g. const enum machine_mode insn_operand_mode[2][10].
7306 We work around this by disabling this feature. See also
7307 gen_array_type_die. */
7308 #ifndef MIPS_DEBUGGING_INFO
7309 for (dimension_number = 0;
7310 TREE_CODE (type) == ARRAY_TYPE;
7311 type = TREE_TYPE (type), dimension_number++)
7314 register tree domain = TYPE_DOMAIN (type);
7316 /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
7317 and (in GNU C only) variable bounds. Handle all three forms
7319 subrange_die = new_die (DW_TAG_subrange_type, type_die);
7322 /* We have an array type with specified bounds. */
7323 lower = TYPE_MIN_VALUE (domain);
7324 upper = TYPE_MAX_VALUE (domain);
7326 /* define the index type. */
7327 if (TREE_TYPE (domain))
7329 /* ??? This is probably an Ada unnamed subrange type. Ignore the
7330 TREE_TYPE field. We can't emit debug info for this
7331 because it is an unnamed integral type. */
7332 if (TREE_CODE (domain) == INTEGER_TYPE
7333 && TYPE_NAME (domain) == NULL_TREE
7334 && TREE_CODE (TREE_TYPE (domain)) == INTEGER_TYPE
7335 && TYPE_NAME (TREE_TYPE (domain)) == NULL_TREE)
7338 add_type_attribute (subrange_die, TREE_TYPE (domain), 0, 0,
7342 /* ??? If upper is NULL, the array has unspecified length,
7343 but it does have a lower bound. This happens with Fortran
7345 Since the debugger is definitely going to need to know N
7346 to produce useful results, go ahead and output the lower
7347 bound solo, and hope the debugger can cope. */
7349 add_bound_info (subrange_die, DW_AT_lower_bound, lower);
7351 add_bound_info (subrange_die, DW_AT_upper_bound, upper);
7354 /* We have an array type with an unspecified length. The DWARF-2
7355 spec does not say how to handle this; let's just leave out the
7360 #ifndef MIPS_DEBUGGING_INFO
7366 add_byte_size_attribute (die, tree_node)
7368 register tree tree_node;
7370 register unsigned size;
7372 switch (TREE_CODE (tree_node))
7380 case QUAL_UNION_TYPE:
7381 size = int_size_in_bytes (tree_node);
7384 /* For a data member of a struct or union, the DW_AT_byte_size is
7385 generally given as the number of bytes normally allocated for an
7386 object of the *declared* type of the member itself. This is true
7387 even for bit-fields. */
7388 size = simple_type_size_in_bits (field_type (tree_node)) / BITS_PER_UNIT;
7394 /* Note that `size' might be -1 when we get to this point. If it is, that
7395 indicates that the byte size of the entity in question is variable. We
7396 have no good way of expressing this fact in Dwarf at the present time,
7397 so just let the -1 pass on through. */
7399 add_AT_unsigned (die, DW_AT_byte_size, size);
7402 /* For a FIELD_DECL node which represents a bit-field, output an attribute
7403 which specifies the distance in bits from the highest order bit of the
7404 "containing object" for the bit-field to the highest order bit of the
7407 For any given bit-field, the "containing object" is a hypothetical
7408 object (of some integral or enum type) within which the given bit-field
7409 lives. The type of this hypothetical "containing object" is always the
7410 same as the declared type of the individual bit-field itself. The
7411 determination of the exact location of the "containing object" for a
7412 bit-field is rather complicated. It's handled by the
7413 `field_byte_offset' function (above).
7415 Note that it is the size (in bytes) of the hypothetical "containing object"
7416 which will be given in the DW_AT_byte_size attribute for this bit-field.
7417 (See `byte_size_attribute' above). */
7420 add_bit_offset_attribute (die, decl)
7421 register dw_die_ref die;
7424 register unsigned object_offset_in_bytes = field_byte_offset (decl);
7425 register tree type = DECL_BIT_FIELD_TYPE (decl);
7426 register tree bitpos_tree = DECL_FIELD_BITPOS (decl);
7427 register unsigned bitpos_int;
7428 register unsigned highest_order_object_bit_offset;
7429 register unsigned highest_order_field_bit_offset;
7430 register unsigned bit_offset;
7432 /* Must be a field and a bit field. */
7434 || TREE_CODE (decl) != FIELD_DECL)
7437 /* We can't yet handle bit-fields whose offsets are variable, so if we
7438 encounter such things, just return without generating any attribute
7440 if (TREE_CODE (bitpos_tree) != INTEGER_CST)
7443 bitpos_int = (unsigned) TREE_INT_CST_LOW (bitpos_tree);
7445 /* Note that the bit offset is always the distance (in bits) from the
7446 highest-order bit of the "containing object" to the highest-order bit of
7447 the bit-field itself. Since the "high-order end" of any object or field
7448 is different on big-endian and little-endian machines, the computation
7449 below must take account of these differences. */
7450 highest_order_object_bit_offset = object_offset_in_bytes * BITS_PER_UNIT;
7451 highest_order_field_bit_offset = bitpos_int;
7453 if (! BYTES_BIG_ENDIAN)
7455 highest_order_field_bit_offset
7456 += (unsigned) TREE_INT_CST_LOW (DECL_SIZE (decl));
7458 highest_order_object_bit_offset += simple_type_size_in_bits (type);
7462 = (! BYTES_BIG_ENDIAN
7463 ? highest_order_object_bit_offset - highest_order_field_bit_offset
7464 : highest_order_field_bit_offset - highest_order_object_bit_offset);
7466 add_AT_unsigned (die, DW_AT_bit_offset, bit_offset);
7469 /* For a FIELD_DECL node which represents a bit field, output an attribute
7470 which specifies the length in bits of the given field. */
7473 add_bit_size_attribute (die, decl)
7474 register dw_die_ref die;
7477 /* Must be a field and a bit field. */
7478 if (TREE_CODE (decl) != FIELD_DECL
7479 || ! DECL_BIT_FIELD_TYPE (decl))
7481 add_AT_unsigned (die, DW_AT_bit_size,
7482 (unsigned) TREE_INT_CST_LOW (DECL_SIZE (decl)));
7485 /* If the compiled language is ANSI C, then add a 'prototyped'
7486 attribute, if arg types are given for the parameters of a function. */
7489 add_prototyped_attribute (die, func_type)
7490 register dw_die_ref die;
7491 register tree func_type;
7493 if (get_AT_unsigned (comp_unit_die, DW_AT_language) == DW_LANG_C89
7494 && TYPE_ARG_TYPES (func_type) != NULL)
7495 add_AT_flag (die, DW_AT_prototyped, 1);
7499 /* Add an 'abstract_origin' attribute below a given DIE. The DIE is found
7500 by looking in either the type declaration or object declaration
7504 add_abstract_origin_attribute (die, origin)
7505 register dw_die_ref die;
7506 register tree origin;
7508 dw_die_ref origin_die = NULL;
7510 /* We may have gotten separated from the block for the inlined
7511 function, if we're in an exception handler or some such; make
7512 sure that the abstract function has been written out. */
7513 tree fn = decl_function_context (origin);
7515 gen_abstract_function (fn);
7517 if (TREE_CODE_CLASS (TREE_CODE (origin)) == 'd')
7518 origin_die = lookup_decl_die (origin);
7519 else if (TREE_CODE_CLASS (TREE_CODE (origin)) == 't')
7520 origin_die = lookup_type_die (origin);
7522 if (origin_die == NULL)
7525 add_AT_die_ref (die, DW_AT_abstract_origin, origin_die);
7528 /* We do not currently support the pure_virtual attribute. */
7531 add_pure_or_virtual_attribute (die, func_decl)
7532 register dw_die_ref die;
7533 register tree func_decl;
7535 if (DECL_VINDEX (func_decl))
7537 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
7538 add_AT_loc (die, DW_AT_vtable_elem_location,
7539 new_loc_descr (DW_OP_constu,
7540 TREE_INT_CST_LOW (DECL_VINDEX (func_decl)),
7543 /* GNU extension: Record what type this method came from originally. */
7544 if (debug_info_level > DINFO_LEVEL_TERSE)
7545 add_AT_die_ref (die, DW_AT_containing_type,
7546 lookup_type_die (DECL_CONTEXT (func_decl)));
7550 /* Add source coordinate attributes for the given decl. */
7553 add_src_coords_attributes (die, decl)
7554 register dw_die_ref die;
7557 register unsigned file_index = lookup_filename (DECL_SOURCE_FILE (decl));
7559 add_AT_unsigned (die, DW_AT_decl_file, file_index);
7560 add_AT_unsigned (die, DW_AT_decl_line, DECL_SOURCE_LINE (decl));
7563 /* Add an DW_AT_name attribute and source coordinate attribute for the
7564 given decl, but only if it actually has a name. */
7567 add_name_and_src_coords_attributes (die, decl)
7568 register dw_die_ref die;
7571 register tree decl_name;
7573 decl_name = DECL_NAME (decl);
7574 if (decl_name != NULL && IDENTIFIER_POINTER (decl_name) != NULL)
7576 add_name_attribute (die, dwarf2_name (decl, 0));
7577 if (! DECL_ARTIFICIAL (decl))
7578 add_src_coords_attributes (die, decl);
7580 if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
7581 && DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
7582 add_AT_string (die, DW_AT_MIPS_linkage_name,
7583 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
7587 /* Push a new declaration scope. */
7590 push_decl_scope (scope)
7593 /* Make room in the decl_scope_table, if necessary. */
7594 if (decl_scope_table_allocated == decl_scope_depth)
7596 decl_scope_table_allocated += DECL_SCOPE_TABLE_INCREMENT;
7598 = (tree *) xrealloc (decl_scope_table,
7599 decl_scope_table_allocated * sizeof (tree));
7602 decl_scope_table[decl_scope_depth] = scope;
7606 /* Pop a declaration scope. */
7610 if (decl_scope_depth <= 0)
7615 /* Return the DIE for the scope that immediately contains this type.
7616 Non-named types get global scope. Named types nested in other
7617 types get their containing scope if it's open, or global scope
7618 otherwise. All other types (i.e. function-local named types) get
7619 the current active scope. */
7622 scope_die_for (t, context_die)
7624 register dw_die_ref context_die;
7626 register dw_die_ref scope_die = NULL;
7627 register tree containing_scope;
7630 /* Non-types always go in the current scope. */
7634 containing_scope = TYPE_CONTEXT (t);
7636 /* Ignore namespaces for the moment. */
7637 if (containing_scope && TREE_CODE (containing_scope) == NAMESPACE_DECL)
7638 containing_scope = NULL_TREE;
7640 /* Ignore function type "scopes" from the C frontend. They mean that
7641 a tagged type is local to a parmlist of a function declarator, but
7642 that isn't useful to DWARF. */
7643 if (containing_scope && TREE_CODE (containing_scope) == FUNCTION_TYPE)
7644 containing_scope = NULL_TREE;
7646 if (containing_scope == NULL_TREE)
7647 scope_die = comp_unit_die;
7648 else if (TYPE_P (containing_scope))
7650 /* For types, we can just look up the appropriate DIE. But
7651 first we check to see if we're in the middle of emitting it
7652 so we know where the new DIE should go. */
7654 for (i = decl_scope_depth - 1; i >= 0; --i)
7655 if (decl_scope_table[i] == containing_scope)
7660 if (debug_info_level > DINFO_LEVEL_TERSE
7661 && !TREE_ASM_WRITTEN (containing_scope))
7664 /* If none of the current dies are suitable, we get file scope. */
7665 scope_die = comp_unit_die;
7668 scope_die = lookup_type_die (containing_scope);
7671 scope_die = context_die;
7676 /* Returns nonzero iff CONTEXT_DIE is internal to a function. */
7679 local_scope_p (context_die)
7680 dw_die_ref context_die;
7682 for (; context_die; context_die = context_die->die_parent)
7683 if (context_die->die_tag == DW_TAG_inlined_subroutine
7684 || context_die->die_tag == DW_TAG_subprogram)
7689 /* Returns nonzero iff CONTEXT_DIE is a class. */
7692 class_scope_p (context_die)
7693 dw_die_ref context_die;
7696 && (context_die->die_tag == DW_TAG_structure_type
7697 || context_die->die_tag == DW_TAG_union_type));
7700 /* Many forms of DIEs require a "type description" attribute. This
7701 routine locates the proper "type descriptor" die for the type given
7702 by 'type', and adds an DW_AT_type attribute below the given die. */
7705 add_type_attribute (object_die, type, decl_const, decl_volatile, context_die)
7706 register dw_die_ref object_die;
7708 register int decl_const;
7709 register int decl_volatile;
7710 register dw_die_ref context_die;
7712 register enum tree_code code = TREE_CODE (type);
7713 register dw_die_ref type_die = NULL;
7715 /* ??? If this type is an unnamed subrange type of an integral or
7716 floating-point type, use the inner type. This is because we have no
7717 support for unnamed types in base_type_die. This can happen if this is
7718 an Ada subrange type. Correct solution is emit a subrange type die. */
7719 if ((code == INTEGER_TYPE || code == REAL_TYPE)
7720 && TREE_TYPE (type) != 0 && TYPE_NAME (type) == 0)
7721 type = TREE_TYPE (type), code = TREE_CODE (type);
7723 if (code == ERROR_MARK)
7726 /* Handle a special case. For functions whose return type is void, we
7727 generate *no* type attribute. (Note that no object may have type
7728 `void', so this only applies to function return types). */
7729 if (code == VOID_TYPE)
7732 type_die = modified_type_die (type,
7733 decl_const || TYPE_READONLY (type),
7734 decl_volatile || TYPE_VOLATILE (type),
7736 if (type_die != NULL)
7737 add_AT_die_ref (object_die, DW_AT_type, type_die);
7740 /* Given a tree pointer to a struct, class, union, or enum type node, return
7741 a pointer to the (string) tag name for the given type, or zero if the type
7742 was declared without a tag. */
7748 register char *name = 0;
7750 if (TYPE_NAME (type) != 0)
7752 register tree t = 0;
7754 /* Find the IDENTIFIER_NODE for the type name. */
7755 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
7756 t = TYPE_NAME (type);
7758 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
7759 a TYPE_DECL node, regardless of whether or not a `typedef' was
7761 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
7762 && ! DECL_IGNORED_P (TYPE_NAME (type)))
7763 t = DECL_NAME (TYPE_NAME (type));
7765 /* Now get the name as a string, or invent one. */
7767 name = IDENTIFIER_POINTER (t);
7770 return (name == 0 || *name == '\0') ? 0 : name;
7773 /* Return the type associated with a data member, make a special check
7774 for bit field types. */
7777 member_declared_type (member)
7778 register tree member;
7780 return (DECL_BIT_FIELD_TYPE (member)
7781 ? DECL_BIT_FIELD_TYPE (member)
7782 : TREE_TYPE (member));
7785 /* Get the decl's label, as described by its RTL. This may be different
7786 from the DECL_NAME name used in the source file. */
7790 decl_start_label (decl)
7795 x = DECL_RTL (decl);
7796 if (GET_CODE (x) != MEM)
7800 if (GET_CODE (x) != SYMBOL_REF)
7803 fnname = XSTR (x, 0);
7808 /* These routines generate the internal representation of the DIE's for
7809 the compilation unit. Debugging information is collected by walking
7810 the declaration trees passed in from dwarf2out_decl(). */
7813 gen_array_type_die (type, context_die)
7815 register dw_die_ref context_die;
7817 register dw_die_ref scope_die = scope_die_for (type, context_die);
7818 register dw_die_ref array_die;
7819 register tree element_type;
7821 /* ??? The SGI dwarf reader fails for array of array of enum types unless
7822 the inner array type comes before the outer array type. Thus we must
7823 call gen_type_die before we call new_die. See below also. */
7824 #ifdef MIPS_DEBUGGING_INFO
7825 gen_type_die (TREE_TYPE (type), context_die);
7828 array_die = new_die (DW_TAG_array_type, scope_die);
7831 /* We default the array ordering. SDB will probably do
7832 the right things even if DW_AT_ordering is not present. It's not even
7833 an issue until we start to get into multidimensional arrays anyway. If
7834 SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
7835 then we'll have to put the DW_AT_ordering attribute back in. (But if
7836 and when we find out that we need to put these in, we will only do so
7837 for multidimensional arrays. */
7838 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major);
7841 #ifdef MIPS_DEBUGGING_INFO
7842 /* The SGI compilers handle arrays of unknown bound by setting
7843 AT_declaration and not emitting any subrange DIEs. */
7844 if (! TYPE_DOMAIN (type))
7845 add_AT_unsigned (array_die, DW_AT_declaration, 1);
7848 add_subscript_info (array_die, type);
7850 add_name_attribute (array_die, type_tag (type));
7851 equate_type_number_to_die (type, array_die);
7853 /* Add representation of the type of the elements of this array type. */
7854 element_type = TREE_TYPE (type);
7856 /* ??? The SGI dwarf reader fails for multidimensional arrays with a
7857 const enum type. E.g. const enum machine_mode insn_operand_mode[2][10].
7858 We work around this by disabling this feature. See also
7859 add_subscript_info. */
7860 #ifndef MIPS_DEBUGGING_INFO
7861 while (TREE_CODE (element_type) == ARRAY_TYPE)
7862 element_type = TREE_TYPE (element_type);
7864 gen_type_die (element_type, context_die);
7867 add_type_attribute (array_die, element_type, 0, 0, context_die);
7871 gen_set_type_die (type, context_die)
7873 register dw_die_ref context_die;
7875 register dw_die_ref type_die
7876 = new_die (DW_TAG_set_type, scope_die_for (type, context_die));
7878 equate_type_number_to_die (type, type_die);
7879 add_type_attribute (type_die, TREE_TYPE (type), 0, 0, context_die);
7884 gen_entry_point_die (decl, context_die)
7886 register dw_die_ref context_die;
7888 register tree origin = decl_ultimate_origin (decl);
7889 register dw_die_ref decl_die = new_die (DW_TAG_entry_point, context_die);
7891 add_abstract_origin_attribute (decl_die, origin);
7894 add_name_and_src_coords_attributes (decl_die, decl);
7895 add_type_attribute (decl_die, TREE_TYPE (TREE_TYPE (decl)),
7899 if (DECL_ABSTRACT (decl))
7900 equate_decl_number_to_die (decl, decl_die);
7902 add_AT_lbl_id (decl_die, DW_AT_low_pc, decl_start_label (decl));
7906 /* Remember a type in the incomplete_types_list. */
7909 add_incomplete_type (type)
7912 if (incomplete_types == incomplete_types_allocated)
7914 incomplete_types_allocated += INCOMPLETE_TYPES_INCREMENT;
7915 incomplete_types_list
7916 = (tree *) xrealloc (incomplete_types_list,
7917 sizeof (tree) * incomplete_types_allocated);
7920 incomplete_types_list[incomplete_types++] = type;
7923 /* Walk through the list of incomplete types again, trying once more to
7924 emit full debugging info for them. */
7927 retry_incomplete_types ()
7931 while (incomplete_types)
7934 type = incomplete_types_list[incomplete_types];
7935 gen_type_die (type, comp_unit_die);
7939 /* Generate a DIE to represent an inlined instance of an enumeration type. */
7942 gen_inlined_enumeration_type_die (type, context_die)
7944 register dw_die_ref context_die;
7946 register dw_die_ref type_die = new_die (DW_TAG_enumeration_type,
7948 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
7949 be incomplete and such types are not marked. */
7950 add_abstract_origin_attribute (type_die, type);
7953 /* Generate a DIE to represent an inlined instance of a structure type. */
7956 gen_inlined_structure_type_die (type, context_die)
7958 register dw_die_ref context_die;
7960 register dw_die_ref type_die = new_die (DW_TAG_structure_type, context_die);
7962 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
7963 be incomplete and such types are not marked. */
7964 add_abstract_origin_attribute (type_die, type);
7967 /* Generate a DIE to represent an inlined instance of a union type. */
7970 gen_inlined_union_type_die (type, context_die)
7972 register dw_die_ref context_die;
7974 register dw_die_ref type_die = new_die (DW_TAG_union_type, context_die);
7976 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
7977 be incomplete and such types are not marked. */
7978 add_abstract_origin_attribute (type_die, type);
7981 /* Generate a DIE to represent an enumeration type. Note that these DIEs
7982 include all of the information about the enumeration values also. Each
7983 enumerated type name/value is listed as a child of the enumerated type
7987 gen_enumeration_type_die (type, context_die)
7989 register dw_die_ref context_die;
7991 register dw_die_ref type_die = lookup_type_die (type);
7993 if (type_die == NULL)
7995 type_die = new_die (DW_TAG_enumeration_type,
7996 scope_die_for (type, context_die));
7997 equate_type_number_to_die (type, type_die);
7998 add_name_attribute (type_die, type_tag (type));
8000 else if (! TYPE_SIZE (type))
8003 remove_AT (type_die, DW_AT_declaration);
8005 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the
8006 given enum type is incomplete, do not generate the DW_AT_byte_size
8007 attribute or the DW_AT_element_list attribute. */
8008 if (TYPE_SIZE (type))
8012 TREE_ASM_WRITTEN (type) = 1;
8013 add_byte_size_attribute (type_die, type);
8014 if (TYPE_STUB_DECL (type) != NULL_TREE)
8015 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
8017 /* If the first reference to this type was as the return type of an
8018 inline function, then it may not have a parent. Fix this now. */
8019 if (type_die->die_parent == NULL)
8020 add_child_die (scope_die_for (type, context_die), type_die);
8022 for (link = TYPE_FIELDS (type);
8023 link != NULL; link = TREE_CHAIN (link))
8025 register dw_die_ref enum_die = new_die (DW_TAG_enumerator, type_die);
8027 add_name_attribute (enum_die,
8028 IDENTIFIER_POINTER (TREE_PURPOSE (link)));
8029 add_AT_unsigned (enum_die, DW_AT_const_value,
8030 (unsigned) TREE_INT_CST_LOW (TREE_VALUE (link)));
8034 add_AT_flag (type_die, DW_AT_declaration, 1);
8038 /* Generate a DIE to represent either a real live formal parameter decl or to
8039 represent just the type of some formal parameter position in some function
8042 Note that this routine is a bit unusual because its argument may be a
8043 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
8044 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
8045 node. If it's the former then this function is being called to output a
8046 DIE to represent a formal parameter object (or some inlining thereof). If
8047 it's the latter, then this function is only being called to output a
8048 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
8049 argument type of some subprogram type. */
8052 gen_formal_parameter_die (node, context_die)
8054 register dw_die_ref context_die;
8056 register dw_die_ref parm_die
8057 = new_die (DW_TAG_formal_parameter, context_die);
8058 register tree origin;
8060 switch (TREE_CODE_CLASS (TREE_CODE (node)))
8063 origin = decl_ultimate_origin (node);
8065 add_abstract_origin_attribute (parm_die, origin);
8068 add_name_and_src_coords_attributes (parm_die, node);
8069 add_type_attribute (parm_die, TREE_TYPE (node),
8070 TREE_READONLY (node),
8071 TREE_THIS_VOLATILE (node),
8073 if (DECL_ARTIFICIAL (node))
8074 add_AT_flag (parm_die, DW_AT_artificial, 1);
8077 equate_decl_number_to_die (node, parm_die);
8078 if (! DECL_ABSTRACT (node))
8079 add_location_or_const_value_attribute (parm_die, node);
8084 /* We were called with some kind of a ..._TYPE node. */
8085 add_type_attribute (parm_die, node, 0, 0, context_die);
8095 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
8096 at the end of an (ANSI prototyped) formal parameters list. */
8099 gen_unspecified_parameters_die (decl_or_type, context_die)
8100 register tree decl_or_type ATTRIBUTE_UNUSED;
8101 register dw_die_ref context_die;
8103 new_die (DW_TAG_unspecified_parameters, context_die);
8106 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
8107 DW_TAG_unspecified_parameters DIE) to represent the types of the formal
8108 parameters as specified in some function type specification (except for
8109 those which appear as part of a function *definition*).
8111 Note we must be careful here to output all of the parameter DIEs before*
8112 we output any DIEs needed to represent the types of the formal parameters.
8113 This keeps svr4 SDB happy because it (incorrectly) thinks that the first
8114 non-parameter DIE it sees ends the formal parameter list. */
8117 gen_formal_types_die (function_or_method_type, context_die)
8118 register tree function_or_method_type;
8119 register dw_die_ref context_die;
8122 register tree formal_type = NULL;
8123 register tree first_parm_type = TYPE_ARG_TYPES (function_or_method_type);
8126 /* In the case where we are generating a formal types list for a C++
8127 non-static member function type, skip over the first thing on the
8128 TYPE_ARG_TYPES list because it only represents the type of the hidden
8129 `this pointer'. The debugger should be able to figure out (without
8130 being explicitly told) that this non-static member function type takes a
8131 `this pointer' and should be able to figure what the type of that hidden
8132 parameter is from the DW_AT_member attribute of the parent
8133 DW_TAG_subroutine_type DIE. */
8134 if (TREE_CODE (function_or_method_type) == METHOD_TYPE)
8135 first_parm_type = TREE_CHAIN (first_parm_type);
8138 /* Make our first pass over the list of formal parameter types and output a
8139 DW_TAG_formal_parameter DIE for each one. */
8140 for (link = first_parm_type; link; link = TREE_CHAIN (link))
8142 register dw_die_ref parm_die;
8144 formal_type = TREE_VALUE (link);
8145 if (formal_type == void_type_node)
8148 /* Output a (nameless) DIE to represent the formal parameter itself. */
8149 parm_die = gen_formal_parameter_die (formal_type, context_die);
8150 if (TREE_CODE (function_or_method_type) == METHOD_TYPE
8151 && link == first_parm_type)
8152 add_AT_flag (parm_die, DW_AT_artificial, 1);
8155 /* If this function type has an ellipsis, add a
8156 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */
8157 if (formal_type != void_type_node)
8158 gen_unspecified_parameters_die (function_or_method_type, context_die);
8160 /* Make our second (and final) pass over the list of formal parameter types
8161 and output DIEs to represent those types (as necessary). */
8162 for (link = TYPE_ARG_TYPES (function_or_method_type);
8164 link = TREE_CHAIN (link))
8166 formal_type = TREE_VALUE (link);
8167 if (formal_type == void_type_node)
8170 gen_type_die (formal_type, context_die);
8174 /* We want to generate the DIE for TYPE so that we can generate the
8175 die for MEMBER, which has been defined; we will need to refer back
8176 to the member declaration nested within TYPE. If we're trying to
8177 generate minimal debug info for TYPE, processing TYPE won't do the
8178 trick; we need to attach the member declaration by hand. */
8181 gen_type_die_for_member (type, member, context_die)
8183 dw_die_ref context_die;
8185 gen_type_die (type, context_die);
8187 /* If we're trying to avoid duplicate debug info, we may not have
8188 emitted the member decl for this function. Emit it now. */
8189 if (TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))
8190 && ! lookup_decl_die (member))
8192 if (decl_ultimate_origin (member))
8195 push_decl_scope (type);
8196 if (TREE_CODE (member) == FUNCTION_DECL)
8197 gen_subprogram_die (member, lookup_type_die (type));
8199 gen_variable_die (member, lookup_type_die (type));
8204 /* Generate the DWARF2 info for the "abstract" instance
8205 of a function which we may later generate inlined and/or
8206 out-of-line instances of. */
8209 gen_abstract_function (decl)
8212 register dw_die_ref old_die = lookup_decl_die (decl);
8215 if (old_die && get_AT_unsigned (old_die, DW_AT_inline))
8216 /* We've already generated the abstract instance. */
8219 save_fn = current_function_decl;
8220 current_function_decl = decl;
8222 set_decl_abstract_flags (decl, 1);
8223 dwarf2out_decl (decl);
8224 set_decl_abstract_flags (decl, 0);
8226 current_function_decl = save_fn;
8229 /* Generate a DIE to represent a declared function (either file-scope or
8233 gen_subprogram_die (decl, context_die)
8235 register dw_die_ref context_die;
8237 char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
8238 register tree origin = decl_ultimate_origin (decl);
8239 register dw_die_ref subr_die;
8240 register rtx fp_reg;
8241 register tree fn_arg_types;
8242 register tree outer_scope;
8243 register dw_die_ref old_die = lookup_decl_die (decl);
8244 register int declaration = (current_function_decl != decl
8245 || class_scope_p (context_die));
8247 /* Note that it is possible to have both DECL_ABSTRACT and `declaration'
8248 be true, if we started to generate the abstract instance of an inline,
8249 decided to output its containing class, and proceeded to emit the
8250 declaration of the inline from the member list for the class. In that
8251 case, `declaration' takes priority; we'll get back to the abstract
8252 instance when we're done with the class. */
8256 if (declaration && ! local_scope_p (context_die))
8259 subr_die = new_die (DW_TAG_subprogram, context_die);
8260 add_abstract_origin_attribute (subr_die, origin);
8262 else if (old_die && DECL_ABSTRACT (decl)
8263 && get_AT_unsigned (old_die, DW_AT_inline))
8265 /* This must be a redefinition of an extern inline function.
8266 We can just reuse the old die here. */
8269 /* Clear out the inlined attribute and parm types. */
8270 remove_AT (subr_die, DW_AT_inline);
8271 remove_children (subr_die);
8275 register unsigned file_index
8276 = lookup_filename (DECL_SOURCE_FILE (decl));
8278 if (get_AT_flag (old_die, DW_AT_declaration) != 1)
8280 /* ??? This can happen if there is a bug in the program, for
8281 instance, if it has duplicate function definitions. Ideally,
8282 we should detect this case and ignore it. For now, if we have
8283 already reported an error, any error at all, then assume that
8284 we got here because of a input error, not a dwarf2 bug. */
8290 /* If the definition comes from the same place as the declaration,
8291 maybe use the old DIE. We always want the DIE for this function
8292 that has the *_pc attributes to be under comp_unit_die so the
8293 debugger can find it. For inlines, that is the concrete instance,
8294 so we can use the old DIE here. For non-inline methods, we want a
8295 specification DIE at toplevel, so we need a new DIE. For local
8296 class methods, this doesn't apply; we just use the old DIE. */
8297 if ((DECL_ABSTRACT (decl) || old_die->die_parent == comp_unit_die
8298 || context_die == NULL)
8299 && (DECL_ARTIFICIAL (decl)
8300 || (get_AT_unsigned (old_die, DW_AT_decl_file) == file_index
8301 && (get_AT_unsigned (old_die, DW_AT_decl_line)
8302 == (unsigned)DECL_SOURCE_LINE (decl)))))
8306 /* Clear out the declaration attribute and the parm types. */
8307 remove_AT (subr_die, DW_AT_declaration);
8308 remove_children (subr_die);
8312 subr_die = new_die (DW_TAG_subprogram, context_die);
8313 add_AT_die_ref (subr_die, DW_AT_specification, old_die);
8314 if (get_AT_unsigned (old_die, DW_AT_decl_file) != file_index)
8315 add_AT_unsigned (subr_die, DW_AT_decl_file, file_index);
8316 if (get_AT_unsigned (old_die, DW_AT_decl_line)
8317 != (unsigned)DECL_SOURCE_LINE (decl))
8319 (subr_die, DW_AT_decl_line, DECL_SOURCE_LINE (decl));
8324 subr_die = new_die (DW_TAG_subprogram, context_die);
8326 if (TREE_PUBLIC (decl))
8327 add_AT_flag (subr_die, DW_AT_external, 1);
8329 add_name_and_src_coords_attributes (subr_die, decl);
8330 if (debug_info_level > DINFO_LEVEL_TERSE)
8332 register tree type = TREE_TYPE (decl);
8334 add_prototyped_attribute (subr_die, type);
8335 add_type_attribute (subr_die, TREE_TYPE (type), 0, 0, context_die);
8338 add_pure_or_virtual_attribute (subr_die, decl);
8339 if (DECL_ARTIFICIAL (decl))
8340 add_AT_flag (subr_die, DW_AT_artificial, 1);
8341 if (TREE_PROTECTED (decl))
8342 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_protected);
8343 else if (TREE_PRIVATE (decl))
8344 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_private);
8350 add_AT_flag (subr_die, DW_AT_declaration, 1);
8352 /* The first time we see a member function, it is in the context of
8353 the class to which it belongs. We make sure of this by emitting
8354 the class first. The next time is the definition, which is
8355 handled above. The two may come from the same source text. */
8356 if (DECL_CONTEXT (decl) || DECL_ABSTRACT (decl))
8357 equate_decl_number_to_die (decl, subr_die);
8359 else if (DECL_ABSTRACT (decl))
8361 if (DECL_INLINE (decl) && !flag_no_inline)
8363 /* ??? Checking DECL_DEFER_OUTPUT is correct for static
8364 inline functions, but not for extern inline functions.
8365 We can't get this completely correct because information
8366 about whether the function was declared inline is not
8368 if (DECL_DEFER_OUTPUT (decl))
8369 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_inlined);
8371 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_inlined);
8374 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_not_inlined);
8376 equate_decl_number_to_die (decl, subr_die);
8378 else if (!DECL_EXTERNAL (decl))
8380 if (origin == NULL_TREE)
8381 equate_decl_number_to_die (decl, subr_die);
8383 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_BEGIN_LABEL,
8384 current_funcdef_number);
8385 add_AT_lbl_id (subr_die, DW_AT_low_pc, label_id);
8386 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
8387 current_funcdef_number);
8388 add_AT_lbl_id (subr_die, DW_AT_high_pc, label_id);
8390 add_pubname (decl, subr_die);
8391 add_arange (decl, subr_die);
8393 #ifdef MIPS_DEBUGGING_INFO
8394 /* Add a reference to the FDE for this routine. */
8395 add_AT_fde_ref (subr_die, DW_AT_MIPS_fde, current_funcdef_fde);
8398 /* Define the "frame base" location for this routine. We use the
8399 frame pointer or stack pointer registers, since the RTL for local
8400 variables is relative to one of them. */
8402 = frame_pointer_needed ? hard_frame_pointer_rtx : stack_pointer_rtx;
8403 add_AT_loc (subr_die, DW_AT_frame_base, reg_loc_descriptor (fp_reg));
8406 /* ??? This fails for nested inline functions, because context_display
8407 is not part of the state saved/restored for inline functions. */
8408 if (current_function_needs_context)
8409 add_AT_location_description (subr_die, DW_AT_static_link,
8410 lookup_static_chain (decl));
8414 /* Now output descriptions of the arguments for this function. This gets
8415 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
8416 for a FUNCTION_DECL doesn't indicate cases where there was a trailing
8417 `...' at the end of the formal parameter list. In order to find out if
8418 there was a trailing ellipsis or not, we must instead look at the type
8419 associated with the FUNCTION_DECL. This will be a node of type
8420 FUNCTION_TYPE. If the chain of type nodes hanging off of this
8421 FUNCTION_TYPE node ends with a void_type_node then there should *not* be
8422 an ellipsis at the end. */
8424 /* In the case where we are describing a mere function declaration, all we
8425 need to do here (and all we *can* do here) is to describe the *types* of
8426 its formal parameters. */
8427 if (debug_info_level <= DINFO_LEVEL_TERSE)
8429 else if (declaration)
8430 gen_formal_types_die (TREE_TYPE (decl), subr_die);
8433 /* Generate DIEs to represent all known formal parameters */
8434 register tree arg_decls = DECL_ARGUMENTS (decl);
8437 /* When generating DIEs, generate the unspecified_parameters DIE
8438 instead if we come across the arg "__builtin_va_alist" */
8439 for (parm = arg_decls; parm; parm = TREE_CHAIN (parm))
8440 if (TREE_CODE (parm) == PARM_DECL)
8442 if (DECL_NAME (parm)
8443 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (parm)),
8444 "__builtin_va_alist"))
8445 gen_unspecified_parameters_die (parm, subr_die);
8447 gen_decl_die (parm, subr_die);
8450 /* Decide whether we need a unspecified_parameters DIE at the end.
8451 There are 2 more cases to do this for: 1) the ansi ... declaration -
8452 this is detectable when the end of the arg list is not a
8453 void_type_node 2) an unprototyped function declaration (not a
8454 definition). This just means that we have no info about the
8455 parameters at all. */
8456 fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
8457 if (fn_arg_types != NULL)
8459 /* this is the prototyped case, check for ... */
8460 if (TREE_VALUE (tree_last (fn_arg_types)) != void_type_node)
8461 gen_unspecified_parameters_die (decl, subr_die);
8463 else if (DECL_INITIAL (decl) == NULL_TREE)
8464 gen_unspecified_parameters_die (decl, subr_die);
8467 /* Output Dwarf info for all of the stuff within the body of the function
8468 (if it has one - it may be just a declaration). */
8469 outer_scope = DECL_INITIAL (decl);
8471 /* Note that here, `outer_scope' is a pointer to the outermost BLOCK
8472 node created to represent a function. This outermost BLOCK actually
8473 represents the outermost binding contour for the function, i.e. the
8474 contour in which the function's formal parameters and labels get
8475 declared. Curiously, it appears that the front end doesn't actually
8476 put the PARM_DECL nodes for the current function onto the BLOCK_VARS
8477 list for this outer scope. (They are strung off of the DECL_ARGUMENTS
8478 list for the function instead.) The BLOCK_VARS list for the
8479 `outer_scope' does provide us with a list of the LABEL_DECL nodes for
8480 the function however, and we output DWARF info for those in
8481 decls_for_scope. Just within the `outer_scope' there will be a BLOCK
8482 node representing the function's outermost pair of curly braces, and
8483 any blocks used for the base and member initializers of a C++
8484 constructor function. */
8485 if (! declaration && TREE_CODE (outer_scope) != ERROR_MARK)
8487 current_function_has_inlines = 0;
8488 decls_for_scope (outer_scope, subr_die, 0);
8490 #if 0 && defined (MIPS_DEBUGGING_INFO)
8491 if (current_function_has_inlines)
8493 add_AT_flag (subr_die, DW_AT_MIPS_has_inlines, 1);
8494 if (! comp_unit_has_inlines)
8496 add_AT_flag (comp_unit_die, DW_AT_MIPS_has_inlines, 1);
8497 comp_unit_has_inlines = 1;
8504 /* Generate a DIE to represent a declared data object. */
8507 gen_variable_die (decl, context_die)
8509 register dw_die_ref context_die;
8511 register tree origin = decl_ultimate_origin (decl);
8512 register dw_die_ref var_die = new_die (DW_TAG_variable, context_die);
8514 dw_die_ref old_die = lookup_decl_die (decl);
8515 int declaration = (DECL_EXTERNAL (decl)
8516 || class_scope_p (context_die));
8519 add_abstract_origin_attribute (var_die, origin);
8520 /* Loop unrolling can create multiple blocks that refer to the same
8521 static variable, so we must test for the DW_AT_declaration flag. */
8522 /* ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
8523 copy decls and set the DECL_ABSTRACT flag on them instead of
8525 else if (old_die && TREE_STATIC (decl)
8526 && get_AT_flag (old_die, DW_AT_declaration) == 1)
8528 /* This is a definition of a C++ class level static. */
8529 add_AT_die_ref (var_die, DW_AT_specification, old_die);
8530 if (DECL_NAME (decl))
8532 register unsigned file_index
8533 = lookup_filename (DECL_SOURCE_FILE (decl));
8535 if (get_AT_unsigned (old_die, DW_AT_decl_file) != file_index)
8536 add_AT_unsigned (var_die, DW_AT_decl_file, file_index);
8538 if (get_AT_unsigned (old_die, DW_AT_decl_line)
8539 != (unsigned)DECL_SOURCE_LINE (decl))
8541 add_AT_unsigned (var_die, DW_AT_decl_line,
8542 DECL_SOURCE_LINE (decl));
8547 add_name_and_src_coords_attributes (var_die, decl);
8548 add_type_attribute (var_die, TREE_TYPE (decl),
8549 TREE_READONLY (decl),
8550 TREE_THIS_VOLATILE (decl), context_die);
8552 if (TREE_PUBLIC (decl))
8553 add_AT_flag (var_die, DW_AT_external, 1);
8555 if (DECL_ARTIFICIAL (decl))
8556 add_AT_flag (var_die, DW_AT_artificial, 1);
8558 if (TREE_PROTECTED (decl))
8559 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_protected);
8561 else if (TREE_PRIVATE (decl))
8562 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_private);
8566 add_AT_flag (var_die, DW_AT_declaration, 1);
8568 if (class_scope_p (context_die) || DECL_ABSTRACT (decl))
8569 equate_decl_number_to_die (decl, var_die);
8571 if (! declaration && ! DECL_ABSTRACT (decl))
8573 add_location_or_const_value_attribute (var_die, decl);
8574 add_pubname (decl, var_die);
8578 /* Generate a DIE to represent a label identifier. */
8581 gen_label_die (decl, context_die)
8583 register dw_die_ref context_die;
8585 register tree origin = decl_ultimate_origin (decl);
8586 register dw_die_ref lbl_die = new_die (DW_TAG_label, context_die);
8588 char label[MAX_ARTIFICIAL_LABEL_BYTES];
8589 char label2[MAX_ARTIFICIAL_LABEL_BYTES];
8592 add_abstract_origin_attribute (lbl_die, origin);
8594 add_name_and_src_coords_attributes (lbl_die, decl);
8596 if (DECL_ABSTRACT (decl))
8597 equate_decl_number_to_die (decl, lbl_die);
8600 insn = DECL_RTL (decl);
8602 /* Deleted labels are programmer specified labels which have been
8603 eliminated because of various optimisations. We still emit them
8604 here so that it is possible to put breakpoints on them. */
8605 if (GET_CODE (insn) == CODE_LABEL
8606 || ((GET_CODE (insn) == NOTE
8607 && NOTE_LINE_NUMBER (insn) == NOTE_INSN_DELETED_LABEL)))
8609 /* When optimization is enabled (via -O) some parts of the compiler
8610 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
8611 represent source-level labels which were explicitly declared by
8612 the user. This really shouldn't be happening though, so catch
8613 it if it ever does happen. */
8614 if (INSN_DELETED_P (insn))
8617 sprintf (label2, INSN_LABEL_FMT, current_funcdef_number);
8618 ASM_GENERATE_INTERNAL_LABEL (label, label2,
8619 (unsigned) INSN_UID (insn));
8620 add_AT_lbl_id (lbl_die, DW_AT_low_pc, label);
8625 /* Generate a DIE for a lexical block. */
8628 gen_lexical_block_die (stmt, context_die, depth)
8630 register dw_die_ref context_die;
8633 register dw_die_ref stmt_die = new_die (DW_TAG_lexical_block, context_die);
8634 char label[MAX_ARTIFICIAL_LABEL_BYTES];
8636 if (! BLOCK_ABSTRACT (stmt))
8638 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
8640 add_AT_lbl_id (stmt_die, DW_AT_low_pc, label);
8641 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL, next_block_number);
8642 add_AT_lbl_id (stmt_die, DW_AT_high_pc, label);
8645 decls_for_scope (stmt, stmt_die, depth);
8648 /* Generate a DIE for an inlined subprogram. */
8651 gen_inlined_subroutine_die (stmt, context_die, depth)
8653 register dw_die_ref context_die;
8656 if (! BLOCK_ABSTRACT (stmt))
8658 register dw_die_ref subr_die
8659 = new_die (DW_TAG_inlined_subroutine, context_die);
8660 register tree decl = block_ultimate_origin (stmt);
8661 char label[MAX_ARTIFICIAL_LABEL_BYTES];
8663 /* Emit info for the abstract instance first, if we haven't yet. */
8664 gen_abstract_function (decl);
8666 add_abstract_origin_attribute (subr_die, decl);
8667 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
8669 add_AT_lbl_id (subr_die, DW_AT_low_pc, label);
8670 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL, next_block_number);
8671 add_AT_lbl_id (subr_die, DW_AT_high_pc, label);
8672 decls_for_scope (stmt, subr_die, depth);
8673 current_function_has_inlines = 1;
8677 /* Generate a DIE for a field in a record, or structure. */
8680 gen_field_die (decl, context_die)
8682 register dw_die_ref context_die;
8684 register dw_die_ref decl_die = new_die (DW_TAG_member, context_die);
8686 add_name_and_src_coords_attributes (decl_die, decl);
8687 add_type_attribute (decl_die, member_declared_type (decl),
8688 TREE_READONLY (decl), TREE_THIS_VOLATILE (decl),
8691 /* If this is a bit field... */
8692 if (DECL_BIT_FIELD_TYPE (decl))
8694 add_byte_size_attribute (decl_die, decl);
8695 add_bit_size_attribute (decl_die, decl);
8696 add_bit_offset_attribute (decl_die, decl);
8699 if (TREE_CODE (DECL_FIELD_CONTEXT (decl)) != UNION_TYPE)
8700 add_data_member_location_attribute (decl_die, decl);
8702 if (DECL_ARTIFICIAL (decl))
8703 add_AT_flag (decl_die, DW_AT_artificial, 1);
8705 if (TREE_PROTECTED (decl))
8706 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_protected);
8708 else if (TREE_PRIVATE (decl))
8709 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_private);
8713 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
8714 Use modified_type_die instead.
8715 We keep this code here just in case these types of DIEs may be needed to
8716 represent certain things in other languages (e.g. Pascal) someday. */
8718 gen_pointer_type_die (type, context_die)
8720 register dw_die_ref context_die;
8722 register dw_die_ref ptr_die
8723 = new_die (DW_TAG_pointer_type, scope_die_for (type, context_die));
8725 equate_type_number_to_die (type, ptr_die);
8726 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
8727 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
8730 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
8731 Use modified_type_die instead.
8732 We keep this code here just in case these types of DIEs may be needed to
8733 represent certain things in other languages (e.g. Pascal) someday. */
8735 gen_reference_type_die (type, context_die)
8737 register dw_die_ref context_die;
8739 register dw_die_ref ref_die
8740 = new_die (DW_TAG_reference_type, scope_die_for (type, context_die));
8742 equate_type_number_to_die (type, ref_die);
8743 add_type_attribute (ref_die, TREE_TYPE (type), 0, 0, context_die);
8744 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
8748 /* Generate a DIE for a pointer to a member type. */
8750 gen_ptr_to_mbr_type_die (type, context_die)
8752 register dw_die_ref context_die;
8754 register dw_die_ref ptr_die
8755 = new_die (DW_TAG_ptr_to_member_type, scope_die_for (type, context_die));
8757 equate_type_number_to_die (type, ptr_die);
8758 add_AT_die_ref (ptr_die, DW_AT_containing_type,
8759 lookup_type_die (TYPE_OFFSET_BASETYPE (type)));
8760 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
8763 /* Generate the DIE for the compilation unit. */
8766 gen_compile_unit_die (filename)
8767 register const char *filename;
8769 register dw_die_ref die;
8771 char *wd = getpwd ();
8774 die = new_die (DW_TAG_compile_unit, NULL);
8775 add_name_attribute (die, filename);
8777 if (wd != NULL && filename[0] != DIR_SEPARATOR)
8778 add_AT_string (die, DW_AT_comp_dir, wd);
8780 sprintf (producer, "%s %s", language_string, version_string);
8782 #ifdef MIPS_DEBUGGING_INFO
8783 /* The MIPS/SGI compilers place the 'cc' command line options in the producer
8784 string. The SGI debugger looks for -g, -g1, -g2, or -g3; if they do
8785 not appear in the producer string, the debugger reaches the conclusion
8786 that the object file is stripped and has no debugging information.
8787 To get the MIPS/SGI debugger to believe that there is debugging
8788 information in the object file, we add a -g to the producer string. */
8789 if (debug_info_level > DINFO_LEVEL_TERSE)
8790 strcat (producer, " -g");
8793 add_AT_string (die, DW_AT_producer, producer);
8795 if (strcmp (language_string, "GNU C++") == 0)
8796 language = DW_LANG_C_plus_plus;
8797 else if (strcmp (language_string, "GNU Ada") == 0)
8798 language = DW_LANG_Ada83;
8799 else if (strcmp (language_string, "GNU F77") == 0)
8800 language = DW_LANG_Fortran77;
8801 else if (strcmp (language_string, "GNU Pascal") == 0)
8802 language = DW_LANG_Pascal83;
8803 else if (flag_traditional)
8804 language = DW_LANG_C;
8806 language = DW_LANG_C89;
8808 add_AT_unsigned (die, DW_AT_language, language);
8813 /* Generate a DIE for a string type. */
8816 gen_string_type_die (type, context_die)
8818 register dw_die_ref context_die;
8820 register dw_die_ref type_die
8821 = new_die (DW_TAG_string_type, scope_die_for (type, context_die));
8823 equate_type_number_to_die (type, type_die);
8825 /* Fudge the string length attribute for now. */
8827 /* TODO: add string length info.
8828 string_length_attribute (TYPE_MAX_VALUE (TYPE_DOMAIN (type)));
8829 bound_representation (upper_bound, 0, 'u'); */
8832 /* Generate the DIE for a base class. */
8835 gen_inheritance_die (binfo, context_die)
8836 register tree binfo;
8837 register dw_die_ref context_die;
8839 dw_die_ref die = new_die (DW_TAG_inheritance, context_die);
8841 add_type_attribute (die, BINFO_TYPE (binfo), 0, 0, context_die);
8842 add_data_member_location_attribute (die, binfo);
8844 if (TREE_VIA_VIRTUAL (binfo))
8845 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
8846 if (TREE_VIA_PUBLIC (binfo))
8847 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public);
8848 else if (TREE_VIA_PROTECTED (binfo))
8849 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected);
8852 /* Generate a DIE for a class member. */
8855 gen_member_die (type, context_die)
8857 register dw_die_ref context_die;
8859 register tree member;
8862 /* If this is not an incomplete type, output descriptions of each of its
8863 members. Note that as we output the DIEs necessary to represent the
8864 members of this record or union type, we will also be trying to output
8865 DIEs to represent the *types* of those members. However the `type'
8866 function (above) will specifically avoid generating type DIEs for member
8867 types *within* the list of member DIEs for this (containing) type execpt
8868 for those types (of members) which are explicitly marked as also being
8869 members of this (containing) type themselves. The g++ front- end can
8870 force any given type to be treated as a member of some other
8871 (containing) type by setting the TYPE_CONTEXT of the given (member) type
8872 to point to the TREE node representing the appropriate (containing)
8875 /* First output info about the base classes. */
8876 if (TYPE_BINFO (type) && TYPE_BINFO_BASETYPES (type))
8878 register tree bases = TYPE_BINFO_BASETYPES (type);
8879 register int n_bases = TREE_VEC_LENGTH (bases);
8882 for (i = 0; i < n_bases; i++)
8883 gen_inheritance_die (TREE_VEC_ELT (bases, i), context_die);
8886 /* Now output info about the data members and type members. */
8887 for (member = TYPE_FIELDS (type); member; member = TREE_CHAIN (member))
8889 /* If we thought we were generating minimal debug info for TYPE
8890 and then changed our minds, some of the member declarations
8891 may have already been defined. Don't define them again, but
8892 do put them in the right order. */
8894 child = lookup_decl_die (member);
8896 splice_child_die (context_die, child);
8898 gen_decl_die (member, context_die);
8901 /* Now output info about the function members (if any). */
8902 for (member = TYPE_METHODS (type); member; member = TREE_CHAIN (member))
8904 child = lookup_decl_die (member);
8906 splice_child_die (context_die, child);
8908 gen_decl_die (member, context_die);
8912 /* Generate a DIE for a structure or union type. If TYPE_DECL_SUPPRESS_DEBUG
8913 is set, we pretend that the type was never defined, so we only get the
8914 member DIEs needed by later specification DIEs. */
8917 gen_struct_or_union_type_die (type, context_die)
8919 register dw_die_ref context_die;
8921 register dw_die_ref type_die = lookup_type_die (type);
8922 register dw_die_ref scope_die = 0;
8923 register int nested = 0;
8924 int complete = (TYPE_SIZE (type)
8925 && (! TYPE_STUB_DECL (type)
8926 || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))));
8928 if (type_die && ! complete)
8931 if (TYPE_CONTEXT (type) != NULL_TREE
8932 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type)))
8935 scope_die = scope_die_for (type, context_die);
8937 if (! type_die || (nested && scope_die == comp_unit_die))
8938 /* First occurrence of type or toplevel definition of nested class. */
8940 register dw_die_ref old_die = type_die;
8942 type_die = new_die (TREE_CODE (type) == RECORD_TYPE
8943 ? DW_TAG_structure_type : DW_TAG_union_type,
8945 equate_type_number_to_die (type, type_die);
8946 add_name_attribute (type_die, type_tag (type));
8948 add_AT_die_ref (type_die, DW_AT_specification, old_die);
8951 remove_AT (type_die, DW_AT_declaration);
8953 /* If this type has been completed, then give it a byte_size attribute and
8954 then give a list of members. */
8957 /* Prevent infinite recursion in cases where the type of some member of
8958 this type is expressed in terms of this type itself. */
8959 TREE_ASM_WRITTEN (type) = 1;
8960 add_byte_size_attribute (type_die, type);
8961 if (TYPE_STUB_DECL (type) != NULL_TREE)
8962 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
8964 /* If the first reference to this type was as the return type of an
8965 inline function, then it may not have a parent. Fix this now. */
8966 if (type_die->die_parent == NULL)
8967 add_child_die (scope_die, type_die);
8969 push_decl_scope (type);
8970 gen_member_die (type, type_die);
8973 /* GNU extension: Record what type our vtable lives in. */
8974 if (TYPE_VFIELD (type))
8976 tree vtype = DECL_FCONTEXT (TYPE_VFIELD (type));
8978 gen_type_die (vtype, context_die);
8979 add_AT_die_ref (type_die, DW_AT_containing_type,
8980 lookup_type_die (vtype));
8985 add_AT_flag (type_die, DW_AT_declaration, 1);
8987 /* We don't need to do this for function-local types. */
8989 add_incomplete_type (type);
8993 /* Generate a DIE for a subroutine _type_. */
8996 gen_subroutine_type_die (type, context_die)
8998 register dw_die_ref context_die;
9000 register tree return_type = TREE_TYPE (type);
9001 register dw_die_ref subr_die
9002 = new_die (DW_TAG_subroutine_type, scope_die_for (type, context_die));
9004 equate_type_number_to_die (type, subr_die);
9005 add_prototyped_attribute (subr_die, type);
9006 add_type_attribute (subr_die, return_type, 0, 0, context_die);
9007 gen_formal_types_die (type, subr_die);
9010 /* Generate a DIE for a type definition */
9013 gen_typedef_die (decl, context_die)
9015 register dw_die_ref context_die;
9017 register dw_die_ref type_die;
9018 register tree origin;
9020 if (TREE_ASM_WRITTEN (decl))
9022 TREE_ASM_WRITTEN (decl) = 1;
9024 type_die = new_die (DW_TAG_typedef, context_die);
9025 origin = decl_ultimate_origin (decl);
9027 add_abstract_origin_attribute (type_die, origin);
9031 add_name_and_src_coords_attributes (type_die, decl);
9032 if (DECL_ORIGINAL_TYPE (decl))
9034 type = DECL_ORIGINAL_TYPE (decl);
9035 equate_type_number_to_die (TREE_TYPE (decl), type_die);
9038 type = TREE_TYPE (decl);
9039 add_type_attribute (type_die, type, TREE_READONLY (decl),
9040 TREE_THIS_VOLATILE (decl), context_die);
9043 if (DECL_ABSTRACT (decl))
9044 equate_decl_number_to_die (decl, type_die);
9047 /* Generate a type description DIE. */
9050 gen_type_die (type, context_die)
9052 register dw_die_ref context_die;
9056 if (type == NULL_TREE || type == error_mark_node)
9059 /* We are going to output a DIE to represent the unqualified version of
9060 this type (i.e. without any const or volatile qualifiers) so get the
9061 main variant (i.e. the unqualified version) of this type now. */
9062 type = type_main_variant (type);
9064 if (TREE_ASM_WRITTEN (type))
9067 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
9068 && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
9070 TREE_ASM_WRITTEN (type) = 1;
9071 gen_decl_die (TYPE_NAME (type), context_die);
9075 switch (TREE_CODE (type))
9081 case REFERENCE_TYPE:
9082 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This
9083 ensures that the gen_type_die recursion will terminate even if the
9084 type is recursive. Recursive types are possible in Ada. */
9085 /* ??? We could perhaps do this for all types before the switch
9087 TREE_ASM_WRITTEN (type) = 1;
9089 /* For these types, all that is required is that we output a DIE (or a
9090 set of DIEs) to represent the "basis" type. */
9091 gen_type_die (TREE_TYPE (type), context_die);
9095 /* This code is used for C++ pointer-to-data-member types.
9096 Output a description of the relevant class type. */
9097 gen_type_die (TYPE_OFFSET_BASETYPE (type), context_die);
9099 /* Output a description of the type of the object pointed to. */
9100 gen_type_die (TREE_TYPE (type), context_die);
9102 /* Now output a DIE to represent this pointer-to-data-member type
9104 gen_ptr_to_mbr_type_die (type, context_die);
9108 gen_type_die (TYPE_DOMAIN (type), context_die);
9109 gen_set_type_die (type, context_die);
9113 gen_type_die (TREE_TYPE (type), context_die);
9114 abort (); /* No way to represent these in Dwarf yet! */
9118 /* Force out return type (in case it wasn't forced out already). */
9119 gen_type_die (TREE_TYPE (type), context_die);
9120 gen_subroutine_type_die (type, context_die);
9124 /* Force out return type (in case it wasn't forced out already). */
9125 gen_type_die (TREE_TYPE (type), context_die);
9126 gen_subroutine_type_die (type, context_die);
9130 if (TYPE_STRING_FLAG (type) && TREE_CODE (TREE_TYPE (type)) == CHAR_TYPE)
9132 gen_type_die (TREE_TYPE (type), context_die);
9133 gen_string_type_die (type, context_die);
9136 gen_array_type_die (type, context_die);
9142 case QUAL_UNION_TYPE:
9143 /* If this is a nested type whose containing class hasn't been
9144 written out yet, writing it out will cover this one, too.
9145 This does not apply to instantiations of member class templates;
9146 they need to be added to the containing class as they are
9147 generated. FIXME: This hurts the idea of combining type decls
9148 from multiple TUs, since we can't predict what set of template
9149 instantiations we'll get. */
9150 if (TYPE_CONTEXT (type)
9151 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
9152 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
9154 gen_type_die (TYPE_CONTEXT (type), context_die);
9156 if (TREE_ASM_WRITTEN (type))
9159 /* If that failed, attach ourselves to the stub. */
9160 push_decl_scope (TYPE_CONTEXT (type));
9161 context_die = lookup_type_die (TYPE_CONTEXT (type));
9167 if (TREE_CODE (type) == ENUMERAL_TYPE)
9168 gen_enumeration_type_die (type, context_die);
9170 gen_struct_or_union_type_die (type, context_die);
9175 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
9176 it up if it is ever completed. gen_*_type_die will set it for us
9177 when appropriate. */
9186 /* No DIEs needed for fundamental types. */
9190 /* No Dwarf representation currently defined. */
9197 TREE_ASM_WRITTEN (type) = 1;
9200 /* Generate a DIE for a tagged type instantiation. */
9203 gen_tagged_type_instantiation_die (type, context_die)
9205 register dw_die_ref context_die;
9207 if (type == NULL_TREE || type == error_mark_node)
9210 /* We are going to output a DIE to represent the unqualified version of
9211 this type (i.e. without any const or volatile qualifiers) so make sure
9212 that we have the main variant (i.e. the unqualified version) of this
9214 if (type != type_main_variant (type))
9217 /* Do not check TREE_ASM_WRITTEN (type) as it may not be set if this is
9218 an instance of an unresolved type. */
9220 switch (TREE_CODE (type))
9226 gen_inlined_enumeration_type_die (type, context_die);
9230 gen_inlined_structure_type_die (type, context_die);
9234 case QUAL_UNION_TYPE:
9235 gen_inlined_union_type_die (type, context_die);
9243 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
9244 things which are local to the given block. */
9247 gen_block_die (stmt, context_die, depth)
9249 register dw_die_ref context_die;
9252 register int must_output_die = 0;
9253 register tree origin;
9255 register enum tree_code origin_code;
9257 /* Ignore blocks never really used to make RTL. */
9259 if (stmt == NULL_TREE || !TREE_USED (stmt))
9262 /* Determine the "ultimate origin" of this block. This block may be an
9263 inlined instance of an inlined instance of inline function, so we have
9264 to trace all of the way back through the origin chain to find out what
9265 sort of node actually served as the original seed for the creation of
9266 the current block. */
9267 origin = block_ultimate_origin (stmt);
9268 origin_code = (origin != NULL) ? TREE_CODE (origin) : ERROR_MARK;
9270 /* Determine if we need to output any Dwarf DIEs at all to represent this
9272 if (origin_code == FUNCTION_DECL)
9273 /* The outer scopes for inlinings *must* always be represented. We
9274 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */
9275 must_output_die = 1;
9278 /* In the case where the current block represents an inlining of the
9279 "body block" of an inline function, we must *NOT* output any DIE for
9280 this block because we have already output a DIE to represent the
9281 whole inlined function scope and the "body block" of any function
9282 doesn't really represent a different scope according to ANSI C
9283 rules. So we check here to make sure that this block does not
9284 represent a "body block inlining" before trying to set the
9285 `must_output_die' flag. */
9286 if (! is_body_block (origin ? origin : stmt))
9288 /* Determine if this block directly contains any "significant"
9289 local declarations which we will need to output DIEs for. */
9290 if (debug_info_level > DINFO_LEVEL_TERSE)
9291 /* We are not in terse mode so *any* local declaration counts
9292 as being a "significant" one. */
9293 must_output_die = (BLOCK_VARS (stmt) != NULL);
9295 /* We are in terse mode, so only local (nested) function
9296 definitions count as "significant" local declarations. */
9297 for (decl = BLOCK_VARS (stmt);
9298 decl != NULL; decl = TREE_CHAIN (decl))
9299 if (TREE_CODE (decl) == FUNCTION_DECL
9300 && DECL_INITIAL (decl))
9302 must_output_die = 1;
9308 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
9309 DIE for any block which contains no significant local declarations at
9310 all. Rather, in such cases we just call `decls_for_scope' so that any
9311 needed Dwarf info for any sub-blocks will get properly generated. Note
9312 that in terse mode, our definition of what constitutes a "significant"
9313 local declaration gets restricted to include only inlined function
9314 instances and local (nested) function definitions. */
9315 if (must_output_die)
9317 if (origin_code == FUNCTION_DECL)
9318 gen_inlined_subroutine_die (stmt, context_die, depth);
9320 gen_lexical_block_die (stmt, context_die, depth);
9323 decls_for_scope (stmt, context_die, depth);
9326 /* Generate all of the decls declared within a given scope and (recursively)
9327 all of its sub-blocks. */
9330 decls_for_scope (stmt, context_die, depth)
9332 register dw_die_ref context_die;
9336 register tree subblocks;
9338 /* Ignore blocks never really used to make RTL. */
9339 if (stmt == NULL_TREE || ! TREE_USED (stmt))
9342 if (!BLOCK_ABSTRACT (stmt) && depth > 0)
9343 next_block_number++;
9345 /* Output the DIEs to represent all of the data objects and typedefs
9346 declared directly within this block but not within any nested
9347 sub-blocks. Also, nested function and tag DIEs have been
9348 generated with a parent of NULL; fix that up now. */
9349 for (decl = BLOCK_VARS (stmt);
9350 decl != NULL; decl = TREE_CHAIN (decl))
9352 register dw_die_ref die;
9354 if (TREE_CODE (decl) == FUNCTION_DECL)
9355 die = lookup_decl_die (decl);
9356 else if (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl))
9357 die = lookup_type_die (TREE_TYPE (decl));
9361 if (die != NULL && die->die_parent == NULL)
9362 add_child_die (context_die, die);
9364 gen_decl_die (decl, context_die);
9367 /* Output the DIEs to represent all sub-blocks (and the items declared
9368 therein) of this block. */
9369 for (subblocks = BLOCK_SUBBLOCKS (stmt);
9371 subblocks = BLOCK_CHAIN (subblocks))
9372 gen_block_die (subblocks, context_die, depth + 1);
9375 /* Is this a typedef we can avoid emitting? */
9378 is_redundant_typedef (decl)
9381 if (TYPE_DECL_IS_STUB (decl))
9384 if (DECL_ARTIFICIAL (decl)
9385 && DECL_CONTEXT (decl)
9386 && is_tagged_type (DECL_CONTEXT (decl))
9387 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl))) == TYPE_DECL
9388 && DECL_NAME (decl) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))))
9389 /* Also ignore the artificial member typedef for the class name. */
9395 /* Generate Dwarf debug information for a decl described by DECL. */
9398 gen_decl_die (decl, context_die)
9400 register dw_die_ref context_die;
9402 register tree origin;
9404 if (TREE_CODE (decl) == ERROR_MARK)
9407 /* If this ..._DECL node is marked to be ignored, then ignore it. But don't
9408 ignore a function definition, since that would screw up our count of
9409 blocks, and that in turn will completely screw up the labels we will
9410 reference in subsequent DW_AT_low_pc and DW_AT_high_pc attributes (for
9411 subsequent blocks). */
9412 if (DECL_IGNORED_P (decl) && TREE_CODE (decl) != FUNCTION_DECL)
9415 switch (TREE_CODE (decl))
9418 /* The individual enumerators of an enum type get output when we output
9419 the Dwarf representation of the relevant enum type itself. */
9423 /* Don't output any DIEs to represent mere function declarations,
9424 unless they are class members or explicit block externs. */
9425 if (DECL_INITIAL (decl) == NULL_TREE && DECL_CONTEXT (decl) == NULL_TREE
9426 && (current_function_decl == NULL_TREE || DECL_ARTIFICIAL (decl)))
9429 /* Emit info for the abstract instance first, if we haven't yet. */
9430 origin = decl_ultimate_origin (decl);
9432 gen_abstract_function (origin);
9434 if (debug_info_level > DINFO_LEVEL_TERSE)
9436 /* Before we describe the FUNCTION_DECL itself, make sure that we
9437 have described its return type. */
9438 gen_type_die (TREE_TYPE (TREE_TYPE (decl)), context_die);
9440 /* And its virtual context. */
9441 if (DECL_VINDEX (decl) != NULL_TREE)
9442 gen_type_die (DECL_CONTEXT (decl), context_die);
9444 /* And its containing type. */
9445 origin = decl_class_context (decl);
9446 if (origin != NULL_TREE)
9447 gen_type_die_for_member (origin, decl, context_die);
9450 /* Now output a DIE to represent the function itself. */
9451 gen_subprogram_die (decl, context_die);
9455 /* If we are in terse mode, don't generate any DIEs to represent any
9457 if (debug_info_level <= DINFO_LEVEL_TERSE)
9460 /* In the special case of a TYPE_DECL node representing the
9461 declaration of some type tag, if the given TYPE_DECL is marked as
9462 having been instantiated from some other (original) TYPE_DECL node
9463 (e.g. one which was generated within the original definition of an
9464 inline function) we have to generate a special (abbreviated)
9465 DW_TAG_structure_type, DW_TAG_union_type, or DW_TAG_enumeration_type
9467 if (TYPE_DECL_IS_STUB (decl) && decl_ultimate_origin (decl) != NULL_TREE)
9469 gen_tagged_type_instantiation_die (TREE_TYPE (decl), context_die);
9473 if (is_redundant_typedef (decl))
9474 gen_type_die (TREE_TYPE (decl), context_die);
9476 /* Output a DIE to represent the typedef itself. */
9477 gen_typedef_die (decl, context_die);
9481 if (debug_info_level >= DINFO_LEVEL_NORMAL)
9482 gen_label_die (decl, context_die);
9486 /* If we are in terse mode, don't generate any DIEs to represent any
9487 variable declarations or definitions. */
9488 if (debug_info_level <= DINFO_LEVEL_TERSE)
9491 /* Output any DIEs that are needed to specify the type of this data
9493 gen_type_die (TREE_TYPE (decl), context_die);
9495 /* And its containing type. */
9496 origin = decl_class_context (decl);
9497 if (origin != NULL_TREE)
9498 gen_type_die_for_member (origin, decl, context_die);
9500 /* Now output the DIE to represent the data object itself. This gets
9501 complicated because of the possibility that the VAR_DECL really
9502 represents an inlined instance of a formal parameter for an inline
9504 origin = decl_ultimate_origin (decl);
9505 if (origin != NULL_TREE && TREE_CODE (origin) == PARM_DECL)
9506 gen_formal_parameter_die (decl, context_die);
9508 gen_variable_die (decl, context_die);
9512 /* Ignore the nameless fields that are used to skip bits, but
9513 handle C++ anonymous unions. */
9514 if (DECL_NAME (decl) != NULL_TREE
9515 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE)
9517 gen_type_die (member_declared_type (decl), context_die);
9518 gen_field_die (decl, context_die);
9523 gen_type_die (TREE_TYPE (decl), context_die);
9524 gen_formal_parameter_die (decl, context_die);
9527 case NAMESPACE_DECL:
9528 /* Ignore for now. */
9536 /* Add Ada "use" clause information for SGI Workshop debugger. */
9539 dwarf2out_add_library_unit_info (filename, context_list)
9543 unsigned int file_index;
9545 if (filename != NULL)
9547 dw_die_ref unit_die = new_die (DW_TAG_module, comp_unit_die);
9548 tree context_list_decl
9549 = build_decl (LABEL_DECL, get_identifier (context_list),
9552 TREE_PUBLIC (context_list_decl) = TRUE;
9553 add_name_attribute (unit_die, context_list);
9554 file_index = lookup_filename (filename);
9555 add_AT_unsigned (unit_die, DW_AT_decl_file, file_index);
9556 add_pubname (context_list_decl, unit_die);
9560 /* Write the debugging output for DECL. */
9563 dwarf2out_decl (decl)
9566 register dw_die_ref context_die = comp_unit_die;
9568 if (TREE_CODE (decl) == ERROR_MARK)
9571 /* If this ..._DECL node is marked to be ignored, then ignore it. We gotta
9572 hope that the node in question doesn't represent a function definition.
9573 If it does, then totally ignoring it is bound to screw up our count of
9574 blocks, and that in turn will completely screw up the labels we will
9575 reference in subsequent DW_AT_low_pc and DW_AT_high_pc attributes (for
9576 subsequent blocks). (It's too bad that BLOCK nodes don't carry their
9577 own sequence numbers with them!) */
9578 if (DECL_IGNORED_P (decl))
9580 if (TREE_CODE (decl) == FUNCTION_DECL
9581 && DECL_INITIAL (decl) != NULL)
9587 switch (TREE_CODE (decl))
9590 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration of a
9591 builtin function. Explicit programmer-supplied declarations of
9592 these same functions should NOT be ignored however. */
9593 if (DECL_EXTERNAL (decl) && DECL_BUILT_IN (decl))
9596 /* What we would really like to do here is to filter out all mere
9597 file-scope declarations of file-scope functions which are never
9598 referenced later within this translation unit (and keep all of ones
9599 that *are* referenced later on) but we aren't clairvoyant, so we have
9600 no idea which functions will be referenced in the future (i.e. later
9601 on within the current translation unit). So here we just ignore all
9602 file-scope function declarations which are not also definitions. If
9603 and when the debugger needs to know something about these functions,
9604 it will have to hunt around and find the DWARF information associated
9605 with the definition of the function. Note that we can't just check
9606 `DECL_EXTERNAL' to find out which FUNCTION_DECL nodes represent
9607 definitions and which ones represent mere declarations. We have to
9608 check `DECL_INITIAL' instead. That's because the C front-end
9609 supports some weird semantics for "extern inline" function
9610 definitions. These can get inlined within the current translation
9611 unit (an thus, we need to generate DWARF info for their abstract
9612 instances so that the DWARF info for the concrete inlined instances
9613 can have something to refer to) but the compiler never generates any
9614 out-of-lines instances of such things (despite the fact that they
9615 *are* definitions). The important point is that the C front-end
9616 marks these "extern inline" functions as DECL_EXTERNAL, but we need
9617 to generate DWARF for them anyway. Note that the C++ front-end also
9618 plays some similar games for inline function definitions appearing
9619 within include files which also contain
9620 `#pragma interface' pragmas. */
9621 if (DECL_INITIAL (decl) == NULL_TREE)
9624 /* If we're a nested function, initially use a parent of NULL; if we're
9625 a plain function, this will be fixed up in decls_for_scope. If
9626 we're a method, it will be ignored, since we already have a DIE. */
9627 if (decl_function_context (decl))
9633 /* Ignore this VAR_DECL if it refers to a file-scope extern data object
9634 declaration and if the declaration was never even referenced from
9635 within this entire compilation unit. We suppress these DIEs in
9636 order to save space in the .debug section (by eliminating entries
9637 which are probably useless). Note that we must not suppress
9638 block-local extern declarations (whether used or not) because that
9639 would screw-up the debugger's name lookup mechanism and cause it to
9640 miss things which really ought to be in scope at a given point. */
9641 if (DECL_EXTERNAL (decl) && !TREE_USED (decl))
9644 /* If we are in terse mode, don't generate any DIEs to represent any
9645 variable declarations or definitions. */
9646 if (debug_info_level <= DINFO_LEVEL_TERSE)
9651 /* Don't bother trying to generate any DIEs to represent any of the
9652 normal built-in types for the language we are compiling. */
9653 if (DECL_SOURCE_LINE (decl) == 0)
9655 /* OK, we need to generate one for `bool' so GDB knows what type
9656 comparisons have. */
9657 if ((get_AT_unsigned (comp_unit_die, DW_AT_language)
9658 == DW_LANG_C_plus_plus)
9659 && TREE_CODE (TREE_TYPE (decl)) == BOOLEAN_TYPE)
9660 modified_type_die (TREE_TYPE (decl), 0, 0, NULL);
9665 /* If we are in terse mode, don't generate any DIEs for types. */
9666 if (debug_info_level <= DINFO_LEVEL_TERSE)
9669 /* If we're a function-scope tag, initially use a parent of NULL;
9670 this will be fixed up in decls_for_scope. */
9671 if (decl_function_context (decl))
9680 gen_decl_die (decl, context_die);
9683 /* Output a marker (i.e. a label) for the beginning of the generated code for
9687 dwarf2out_begin_block (blocknum)
9688 register unsigned blocknum;
9690 function_section (current_function_decl);
9691 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, BLOCK_BEGIN_LABEL, blocknum);
9694 /* Output a marker (i.e. a label) for the end of the generated code for a
9698 dwarf2out_end_block (blocknum)
9699 register unsigned blocknum;
9701 function_section (current_function_decl);
9702 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, BLOCK_END_LABEL, blocknum);
9705 /* Output a marker (i.e. a label) at a point in the assembly code which
9706 corresponds to a given source level label. */
9709 dwarf2out_label (insn)
9712 char label[MAX_ARTIFICIAL_LABEL_BYTES];
9714 if (debug_info_level >= DINFO_LEVEL_NORMAL)
9716 function_section (current_function_decl);
9717 sprintf (label, INSN_LABEL_FMT, current_funcdef_number);
9718 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, label,
9719 (unsigned) INSN_UID (insn));
9723 /* Lookup a filename (in the list of filenames that we know about here in
9724 dwarf2out.c) and return its "index". The index of each (known) filename is
9725 just a unique number which is associated with only that one filename.
9726 We need such numbers for the sake of generating labels
9727 (in the .debug_sfnames section) and references to those
9728 files numbers (in the .debug_srcinfo and.debug_macinfo sections).
9729 If the filename given as an argument is not found in our current list,
9730 add it to the list and assign it the next available unique index number.
9731 In order to speed up searches, we remember the index of the filename
9732 was looked up last. This handles the majority of all searches. */
9735 lookup_filename (file_name)
9736 const char *file_name;
9738 static unsigned last_file_lookup_index = 0;
9739 register unsigned i;
9741 /* Check to see if the file name that was searched on the previous call
9742 matches this file name. If so, return the index. */
9743 if (last_file_lookup_index != 0)
9744 if (strcmp (file_name, file_table[last_file_lookup_index]) == 0)
9745 return last_file_lookup_index;
9747 /* Didn't match the previous lookup, search the table */
9748 for (i = 1; i < file_table_in_use; ++i)
9749 if (strcmp (file_name, file_table[i]) == 0)
9751 last_file_lookup_index = i;
9755 /* Prepare to add a new table entry by making sure there is enough space in
9756 the table to do so. If not, expand the current table. */
9757 if (file_table_in_use == file_table_allocated)
9759 file_table_allocated += FILE_TABLE_INCREMENT;
9761 = (char **) xrealloc (file_table,
9762 file_table_allocated * sizeof (char *));
9765 /* Add the new entry to the end of the filename table. */
9766 file_table[file_table_in_use] = xstrdup (file_name);
9767 last_file_lookup_index = file_table_in_use++;
9769 return last_file_lookup_index;
9772 /* Output a label to mark the beginning of a source code line entry
9773 and record information relating to this source line, in
9774 'line_info_table' for later output of the .debug_line section. */
9777 dwarf2out_line (filename, line)
9778 register const char *filename;
9779 register unsigned line;
9781 if (debug_info_level >= DINFO_LEVEL_NORMAL)
9783 function_section (current_function_decl);
9785 if (DWARF2_ASM_LINE_DEBUG_INFO)
9787 static const char *lastfile;
9789 /* Emit the .file and .loc directives understood by GNU as. */
9790 if (lastfile == 0 || strcmp (filename, lastfile))
9793 ggc_add_string_root ((char **) &lastfile, 1);
9795 fprintf (asm_out_file, "\t.file 0 \"%s\"\n", filename);
9796 lastfile = filename;
9799 fprintf (asm_out_file, "\t.loc 0 %d 0\n", line);
9801 /* Indicate that line number info exists. */
9802 ++line_info_table_in_use;
9804 /* Indicate that multiple line number tables exist. */
9805 if (DECL_SECTION_NAME (current_function_decl))
9806 ++separate_line_info_table_in_use;
9808 else if (DECL_SECTION_NAME (current_function_decl))
9810 register dw_separate_line_info_ref line_info;
9811 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, SEPARATE_LINE_CODE_LABEL,
9812 separate_line_info_table_in_use);
9814 fprintf (asm_out_file, "\t%s line %d", ASM_COMMENT_START, line);
9815 fputc ('\n', asm_out_file);
9817 /* expand the line info table if necessary */
9818 if (separate_line_info_table_in_use
9819 == separate_line_info_table_allocated)
9821 separate_line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
9822 separate_line_info_table
9823 = (dw_separate_line_info_ref)
9824 xrealloc (separate_line_info_table,
9825 separate_line_info_table_allocated
9826 * sizeof (dw_separate_line_info_entry));
9829 /* Add the new entry at the end of the line_info_table. */
9831 = &separate_line_info_table[separate_line_info_table_in_use++];
9832 line_info->dw_file_num = lookup_filename (filename);
9833 line_info->dw_line_num = line;
9834 line_info->function = current_funcdef_number;
9838 register dw_line_info_ref line_info;
9840 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, LINE_CODE_LABEL,
9841 line_info_table_in_use);
9843 fprintf (asm_out_file, "\t%s line %d", ASM_COMMENT_START, line);
9844 fputc ('\n', asm_out_file);
9846 /* Expand the line info table if necessary. */
9847 if (line_info_table_in_use == line_info_table_allocated)
9849 line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
9851 = (dw_line_info_ref)
9852 xrealloc (line_info_table,
9853 (line_info_table_allocated
9854 * sizeof (dw_line_info_entry)));
9857 /* Add the new entry at the end of the line_info_table. */
9858 line_info = &line_info_table[line_info_table_in_use++];
9859 line_info->dw_file_num = lookup_filename (filename);
9860 line_info->dw_line_num = line;
9865 /* Record the beginning of a new source file, for later output
9866 of the .debug_macinfo section. At present, unimplemented. */
9869 dwarf2out_start_source_file (filename)
9870 register const char *filename ATTRIBUTE_UNUSED;
9874 /* Record the end of a source file, for later output
9875 of the .debug_macinfo section. At present, unimplemented. */
9878 dwarf2out_end_source_file ()
9882 /* Called from check_newline in c-parse.y. The `buffer' parameter contains
9883 the tail part of the directive line, i.e. the part which is past the
9884 initial whitespace, #, whitespace, directive-name, whitespace part. */
9887 dwarf2out_define (lineno, buffer)
9888 register unsigned lineno ATTRIBUTE_UNUSED;
9889 register const char *buffer ATTRIBUTE_UNUSED;
9891 static int initialized = 0;
9894 dwarf2out_start_source_file (primary_filename);
9899 /* Called from check_newline in c-parse.y. The `buffer' parameter contains
9900 the tail part of the directive line, i.e. the part which is past the
9901 initial whitespace, #, whitespace, directive-name, whitespace part. */
9904 dwarf2out_undef (lineno, buffer)
9905 register unsigned lineno ATTRIBUTE_UNUSED;
9906 register const char *buffer ATTRIBUTE_UNUSED;
9910 /* Set up for Dwarf output at the start of compilation. */
9913 dwarf2out_init (asm_out_file, main_input_filename)
9914 register FILE *asm_out_file;
9915 register char *main_input_filename;
9917 /* Remember the name of the primary input file. */
9918 primary_filename = main_input_filename;
9920 /* Allocate the initial hunk of the file_table. */
9921 file_table = (char **) xcalloc (FILE_TABLE_INCREMENT, sizeof (char *));
9922 file_table_allocated = FILE_TABLE_INCREMENT;
9924 /* Skip the first entry - file numbers begin at 1. */
9925 file_table_in_use = 1;
9927 /* Allocate the initial hunk of the decl_die_table. */
9929 = (dw_die_ref *) xcalloc (DECL_DIE_TABLE_INCREMENT, sizeof (dw_die_ref));
9930 decl_die_table_allocated = DECL_DIE_TABLE_INCREMENT;
9931 decl_die_table_in_use = 0;
9933 /* Allocate the initial hunk of the decl_scope_table. */
9935 = (tree *) xcalloc (DECL_SCOPE_TABLE_INCREMENT, sizeof (tree));
9936 decl_scope_table_allocated = DECL_SCOPE_TABLE_INCREMENT;
9937 decl_scope_depth = 0;
9939 /* Allocate the initial hunk of the abbrev_die_table. */
9941 = (dw_die_ref *) xcalloc (ABBREV_DIE_TABLE_INCREMENT,
9942 sizeof (dw_die_ref));
9943 abbrev_die_table_allocated = ABBREV_DIE_TABLE_INCREMENT;
9944 /* Zero-th entry is allocated, but unused */
9945 abbrev_die_table_in_use = 1;
9947 /* Allocate the initial hunk of the line_info_table. */
9949 = (dw_line_info_ref) xcalloc (LINE_INFO_TABLE_INCREMENT,
9950 sizeof (dw_line_info_entry));
9951 line_info_table_allocated = LINE_INFO_TABLE_INCREMENT;
9952 /* Zero-th entry is allocated, but unused */
9953 line_info_table_in_use = 1;
9955 /* Generate the initial DIE for the .debug section. Note that the (string)
9956 value given in the DW_AT_name attribute of the DW_TAG_compile_unit DIE
9957 will (typically) be a relative pathname and that this pathname should be
9958 taken as being relative to the directory from which the compiler was
9959 invoked when the given (base) source file was compiled. */
9960 comp_unit_die = gen_compile_unit_die (main_input_filename);
9962 ASM_GENERATE_INTERNAL_LABEL (text_end_label, TEXT_END_LABEL, 0);
9963 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label, ABBREV_SECTION_LABEL, 0);
9964 if (DWARF2_GENERATE_TEXT_SECTION_LABEL)
9965 ASM_GENERATE_INTERNAL_LABEL (text_section_label, TEXT_SECTION_LABEL, 0);
9967 strcpy (text_section_label, stripattributes (TEXT_SECTION));
9968 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label,
9969 DEBUG_INFO_SECTION_LABEL, 0);
9970 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label,
9971 DEBUG_LINE_SECTION_LABEL, 0);
9973 ASM_OUTPUT_SECTION (asm_out_file, ABBREV_SECTION);
9974 ASM_OUTPUT_LABEL (asm_out_file, abbrev_section_label);
9975 if (DWARF2_GENERATE_TEXT_SECTION_LABEL)
9977 ASM_OUTPUT_SECTION (asm_out_file, TEXT_SECTION);
9978 ASM_OUTPUT_LABEL (asm_out_file, text_section_label);
9980 ASM_OUTPUT_SECTION (asm_out_file, DEBUG_INFO_SECTION);
9981 ASM_OUTPUT_LABEL (asm_out_file, debug_info_section_label);
9982 ASM_OUTPUT_SECTION (asm_out_file, DEBUG_LINE_SECTION);
9983 ASM_OUTPUT_LABEL (asm_out_file, debug_line_section_label);
9986 /* Output stuff that dwarf requires at the end of every file,
9987 and generate the DWARF-2 debugging info. */
9992 limbo_die_node *node, *next_node;
9995 /* Traverse the limbo die list, and add parent/child links. The only
9996 dies without parents that should be here are concrete instances of
9997 inline functions, and the comp_unit_die. We can ignore the comp_unit_die.
9998 For concrete instances, we can get the parent die from the abstract
10000 for (node = limbo_die_list; node; node = next_node)
10002 next_node = node->next;
10005 if (die->die_parent == NULL)
10007 dw_die_ref origin = get_AT_ref (die, DW_AT_abstract_origin);
10009 add_child_die (origin->die_parent, die);
10010 else if (die == comp_unit_die)
10017 limbo_die_list = NULL;
10019 /* Walk through the list of incomplete types again, trying once more to
10020 emit full debugging info for them. */
10021 retry_incomplete_types ();
10023 /* Traverse the DIE's, reverse their lists of attributes and children,
10024 and add add sibling attributes to those DIE's that have children. */
10025 add_sibling_attributes (comp_unit_die);
10027 /* Output a terminator label for the .text section. */
10028 fputc ('\n', asm_out_file);
10029 ASM_OUTPUT_SECTION (asm_out_file, TEXT_SECTION);
10030 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, TEXT_END_LABEL, 0);
10033 /* Output a terminator label for the .data section. */
10034 fputc ('\n', asm_out_file);
10035 ASM_OUTPUT_SECTION (asm_out_file, DATA_SECTION);
10036 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, DATA_END_LABEL, 0);
10038 /* Output a terminator label for the .bss section. */
10039 fputc ('\n', asm_out_file);
10040 ASM_OUTPUT_SECTION (asm_out_file, BSS_SECTION);
10041 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, BSS_END_LABEL, 0);
10044 /* Output the source line correspondence table. */
10045 if (line_info_table_in_use > 1 || separate_line_info_table_in_use)
10047 if (! DWARF2_ASM_LINE_DEBUG_INFO)
10049 fputc ('\n', asm_out_file);
10050 ASM_OUTPUT_SECTION (asm_out_file, DEBUG_LINE_SECTION);
10051 output_line_info ();
10054 /* We can only use the low/high_pc attributes if all of the code
10056 if (separate_line_info_table_in_use == 0)
10058 add_AT_lbl_id (comp_unit_die, DW_AT_low_pc, text_section_label);
10059 add_AT_lbl_id (comp_unit_die, DW_AT_high_pc, text_end_label);
10062 add_AT_lbl_offset (comp_unit_die, DW_AT_stmt_list,
10063 debug_line_section_label);
10066 #if 0 /* unimplemented */
10067 if (debug_info_level >= DINFO_LEVEL_VERBOSE && primary)
10068 add_AT_unsigned (die, DW_AT_macro_info, 0);
10071 /* Output the abbreviation table. */
10072 fputc ('\n', asm_out_file);
10073 ASM_OUTPUT_SECTION (asm_out_file, ABBREV_SECTION);
10074 build_abbrev_table (comp_unit_die);
10075 output_abbrev_section ();
10077 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
10078 next_die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE;
10079 calc_die_sizes (comp_unit_die);
10081 /* Output debugging information. */
10082 fputc ('\n', asm_out_file);
10083 ASM_OUTPUT_SECTION (asm_out_file, DEBUG_INFO_SECTION);
10084 output_compilation_unit_header ();
10085 output_die (comp_unit_die);
10087 if (pubname_table_in_use)
10089 /* Output public names table. */
10090 fputc ('\n', asm_out_file);
10091 ASM_OUTPUT_SECTION (asm_out_file, PUBNAMES_SECTION);
10092 output_pubnames ();
10095 /* We only put functions in the arange table, so don't write it out if
10096 we don't have any. */
10097 if (fde_table_in_use)
10099 /* Output the address range information. */
10100 fputc ('\n', asm_out_file);
10101 ASM_OUTPUT_SECTION (asm_out_file, ARANGES_SECTION);
10105 #endif /* DWARF2_DEBUGGING_INFO */