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"
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 #ifndef ASM_OUTPUT_DWARF_ADDR_CONST
361 #define ASM_OUTPUT_DWARF_ADDR_CONST(FILE,RTX) \
363 fprintf ((FILE), "\t%s\t", UNALIGNED_INT_ASM_OP); \
364 output_addr_const ((FILE), (RTX)); \
365 fputc ('\n', (FILE)); \
369 #ifndef ASM_OUTPUT_DWARF_OFFSET4
370 #define ASM_OUTPUT_DWARF_OFFSET4(FILE,LABEL) \
371 do { fprintf ((FILE), "\t%s\t", UNALIGNED_INT_ASM_OP); \
372 assemble_name (FILE, LABEL); \
376 #ifndef ASM_OUTPUT_DWARF_OFFSET
377 #define ASM_OUTPUT_DWARF_OFFSET(FILE,LABEL) \
378 do { fprintf ((FILE), "\t%s\t", UNALIGNED_OFFSET_ASM_OP); \
379 assemble_name (FILE, LABEL); \
383 #ifndef ASM_OUTPUT_DWARF_DATA2
384 #define ASM_OUTPUT_DWARF_DATA2(FILE,VALUE) \
385 fprintf ((FILE), "\t%s\t0x%x", UNALIGNED_SHORT_ASM_OP, (unsigned) (VALUE))
388 #ifndef ASM_OUTPUT_DWARF_DATA4
389 #define ASM_OUTPUT_DWARF_DATA4(FILE,VALUE) \
390 fprintf ((FILE), "\t%s\t0x%x", UNALIGNED_INT_ASM_OP, (unsigned) (VALUE))
393 #ifndef ASM_OUTPUT_DWARF_DATA
394 #define ASM_OUTPUT_DWARF_DATA(FILE,VALUE) \
395 fprintf ((FILE), "\t%s\t0x%lx", UNALIGNED_OFFSET_ASM_OP, \
396 (unsigned long) (VALUE))
399 #ifndef ASM_OUTPUT_DWARF_ADDR_DATA
400 #define ASM_OUTPUT_DWARF_ADDR_DATA(FILE,VALUE) \
401 fprintf ((FILE), "\t%s\t0x%lx", UNALIGNED_WORD_ASM_OP, \
402 (unsigned long) (VALUE))
405 #ifndef ASM_OUTPUT_DWARF_DATA8
406 #define ASM_OUTPUT_DWARF_DATA8(FILE,HIGH_VALUE,LOW_VALUE) \
408 if (WORDS_BIG_ENDIAN) \
410 fprintf ((FILE), "\t%s\t0x%lx\n", UNALIGNED_INT_ASM_OP, (HIGH_VALUE));\
411 fprintf ((FILE), "\t%s\t0x%lx", UNALIGNED_INT_ASM_OP, (LOW_VALUE));\
415 fprintf ((FILE), "\t%s\t0x%lx\n", UNALIGNED_INT_ASM_OP, (LOW_VALUE)); \
416 fprintf ((FILE), "\t%s\t0x%lx", UNALIGNED_INT_ASM_OP, (HIGH_VALUE)); \
421 #else /* UNALIGNED_INT_ASM_OP */
423 /* We don't have unaligned support, let's hope the normal output works for
426 #define ASM_OUTPUT_DWARF_ADDR(FILE,LABEL) \
427 assemble_integer (gen_rtx_SYMBOL_REF (Pmode, LABEL), PTR_SIZE, 1)
429 #define ASM_OUTPUT_DWARF_OFFSET4(FILE,LABEL) \
430 assemble_integer (gen_rtx_SYMBOL_REF (SImode, LABEL), 4, 1)
432 #define ASM_OUTPUT_DWARF_OFFSET(FILE,LABEL) \
433 assemble_integer (gen_rtx_SYMBOL_REF (SImode, LABEL), 4, 1)
435 #define ASM_OUTPUT_DWARF_DELTA2(FILE,LABEL1,LABEL2) \
436 assemble_integer (gen_rtx_MINUS (HImode, \
437 gen_rtx_SYMBOL_REF (Pmode, LABEL1), \
438 gen_rtx_SYMBOL_REF (Pmode, LABEL2)), \
441 #define ASM_OUTPUT_DWARF_DELTA4(FILE,LABEL1,LABEL2) \
442 assemble_integer (gen_rtx_MINUS (SImode, \
443 gen_rtx_SYMBOL_REF (Pmode, LABEL1), \
444 gen_rtx_SYMBOL_REF (Pmode, LABEL2)), \
447 #define ASM_OUTPUT_DWARF_ADDR_DELTA(FILE,LABEL1,LABEL2) \
448 assemble_integer (gen_rtx_MINUS (Pmode, \
449 gen_rtx_SYMBOL_REF (Pmode, LABEL1), \
450 gen_rtx_SYMBOL_REF (Pmode, LABEL2)), \
453 #define ASM_OUTPUT_DWARF_DELTA(FILE,LABEL1,LABEL2) \
454 ASM_OUTPUT_DWARF_DELTA4 (FILE,LABEL1,LABEL2)
456 #define ASM_OUTPUT_DWARF_DATA4(FILE,VALUE) \
457 assemble_integer (GEN_INT (VALUE), 4, 1)
459 #endif /* UNALIGNED_INT_ASM_OP */
462 #ifndef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
463 #define ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL(FILE, SY, HI, LO) \
465 fprintf (FILE, "\t%s\t", SET_ASM_OP); \
466 assemble_name (FILE, SY); \
468 assemble_name (FILE, HI); \
470 assemble_name (FILE, LO); \
473 #endif /* SET_ASM_OP */
475 /* This is similar to the default ASM_OUTPUT_ASCII, except that no trailing
476 newline is produced. When flag_debug_asm is asserted, we add commentary
477 at the end of the line, so we must avoid output of a newline here. */
478 #ifndef ASM_OUTPUT_DWARF_STRING
479 #define ASM_OUTPUT_DWARF_STRING(FILE,P) \
481 register int slen = strlen(P); \
482 register const char *p = (P); \
484 fprintf (FILE, "\t.ascii \""); \
485 for (i = 0; i < slen; i++) \
487 register int c = p[i]; \
488 if (c == '\"' || c == '\\') \
494 fprintf (FILE, "\\%o", c); \
497 fprintf (FILE, "\\0\""); \
502 /* The DWARF 2 CFA column which tracks the return address. Normally this
503 is the column for PC, or the first column after all of the hard
505 #ifndef DWARF_FRAME_RETURN_COLUMN
507 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (PC_REGNUM)
509 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGISTERS
513 /* The mapping from gcc register number to DWARF 2 CFA column number. By
514 default, we just provide columns for all registers. */
515 #ifndef DWARF_FRAME_REGNUM
516 #define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG)
519 /* Hook used by __throw. */
522 expand_builtin_dwarf_fp_regnum ()
524 return GEN_INT (DWARF_FRAME_REGNUM (HARD_FRAME_POINTER_REGNUM));
527 /* The offset from the incoming value of %sp to the top of the stack frame
528 for the current function. */
529 #ifndef INCOMING_FRAME_SP_OFFSET
530 #define INCOMING_FRAME_SP_OFFSET 0
533 /* Return a pointer to a copy of the section string name S with all
534 attributes stripped off, and an asterisk prepended (for assemble_name). */
540 char *stripped = xmalloc (strlen (s) + 2);
545 while (*s && *s != ',')
552 /* Return the register number described by a given RTL node. */
558 register unsigned regno = REGNO (rtl);
560 if (regno >= DWARF_FRAME_REGISTERS)
562 warning ("internal regno botch: regno = %d\n", regno);
566 regno = DBX_REGISTER_NUMBER (regno);
570 /* Generate code to initialize the register size table. */
573 expand_builtin_init_dwarf_reg_sizes (address)
577 enum machine_mode mode = TYPE_MODE (char_type_node);
578 rtx addr = expand_expr (address, NULL_RTX, VOIDmode, 0);
579 rtx mem = gen_rtx_MEM (mode, addr);
581 for (i = 0; i < DWARF_FRAME_REGISTERS; ++i)
583 int offset = i * GET_MODE_SIZE (mode);
584 int size = GET_MODE_SIZE (reg_raw_mode[i]);
586 emit_move_insn (change_address (mem, mode,
587 plus_constant (addr, offset)),
592 /* Convert a DWARF call frame info. operation to its string name */
595 dwarf_cfi_name (cfi_opc)
596 register unsigned cfi_opc;
600 case DW_CFA_advance_loc:
601 return "DW_CFA_advance_loc";
603 return "DW_CFA_offset";
605 return "DW_CFA_restore";
609 return "DW_CFA_set_loc";
610 case DW_CFA_advance_loc1:
611 return "DW_CFA_advance_loc1";
612 case DW_CFA_advance_loc2:
613 return "DW_CFA_advance_loc2";
614 case DW_CFA_advance_loc4:
615 return "DW_CFA_advance_loc4";
616 case DW_CFA_offset_extended:
617 return "DW_CFA_offset_extended";
618 case DW_CFA_restore_extended:
619 return "DW_CFA_restore_extended";
620 case DW_CFA_undefined:
621 return "DW_CFA_undefined";
622 case DW_CFA_same_value:
623 return "DW_CFA_same_value";
624 case DW_CFA_register:
625 return "DW_CFA_register";
626 case DW_CFA_remember_state:
627 return "DW_CFA_remember_state";
628 case DW_CFA_restore_state:
629 return "DW_CFA_restore_state";
631 return "DW_CFA_def_cfa";
632 case DW_CFA_def_cfa_register:
633 return "DW_CFA_def_cfa_register";
634 case DW_CFA_def_cfa_offset:
635 return "DW_CFA_def_cfa_offset";
637 /* SGI/MIPS specific */
638 case DW_CFA_MIPS_advance_loc8:
639 return "DW_CFA_MIPS_advance_loc8";
642 case DW_CFA_GNU_window_save:
643 return "DW_CFA_GNU_window_save";
644 case DW_CFA_GNU_args_size:
645 return "DW_CFA_GNU_args_size";
646 case DW_CFA_GNU_negative_offset_extended:
647 return "DW_CFA_GNU_negative_offset_extended";
650 return "DW_CFA_<unknown>";
654 /* Return a pointer to a newly allocated Call Frame Instruction. */
656 static inline dw_cfi_ref
659 register dw_cfi_ref cfi = (dw_cfi_ref) xmalloc (sizeof (dw_cfi_node));
661 cfi->dw_cfi_next = NULL;
662 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = 0;
663 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = 0;
668 /* Add a Call Frame Instruction to list of instructions. */
671 add_cfi (list_head, cfi)
672 register dw_cfi_ref *list_head;
673 register dw_cfi_ref cfi;
675 register dw_cfi_ref *p;
677 /* Find the end of the chain. */
678 for (p = list_head; (*p) != NULL; p = &(*p)->dw_cfi_next)
684 /* Generate a new label for the CFI info to refer to. */
687 dwarf2out_cfi_label ()
689 static char label[20];
690 static unsigned long label_num = 0;
692 ASM_GENERATE_INTERNAL_LABEL (label, "LCFI", label_num++);
693 ASM_OUTPUT_LABEL (asm_out_file, label);
698 /* Add CFI to the current fde at the PC value indicated by LABEL if specified,
699 or to the CIE if LABEL is NULL. */
702 add_fde_cfi (label, cfi)
703 register char *label;
704 register dw_cfi_ref cfi;
708 register dw_fde_ref fde = &fde_table[fde_table_in_use - 1];
711 label = dwarf2out_cfi_label ();
713 if (fde->dw_fde_current_label == NULL
714 || strcmp (label, fde->dw_fde_current_label) != 0)
716 register dw_cfi_ref xcfi;
718 fde->dw_fde_current_label = label = xstrdup (label);
720 /* Set the location counter to the new label. */
722 xcfi->dw_cfi_opc = DW_CFA_advance_loc4;
723 xcfi->dw_cfi_oprnd1.dw_cfi_addr = label;
724 add_cfi (&fde->dw_fde_cfi, xcfi);
727 add_cfi (&fde->dw_fde_cfi, cfi);
731 add_cfi (&cie_cfi_head, cfi);
734 /* Subroutine of lookup_cfa. */
737 lookup_cfa_1 (cfi, regp, offsetp)
738 register dw_cfi_ref cfi;
739 register unsigned long *regp;
740 register long *offsetp;
742 switch (cfi->dw_cfi_opc)
744 case DW_CFA_def_cfa_offset:
745 *offsetp = cfi->dw_cfi_oprnd1.dw_cfi_offset;
747 case DW_CFA_def_cfa_register:
748 *regp = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
751 *regp = cfi->dw_cfi_oprnd1.dw_cfi_reg_num;
752 *offsetp = cfi->dw_cfi_oprnd2.dw_cfi_offset;
759 /* Find the previous value for the CFA. */
762 lookup_cfa (regp, offsetp)
763 register unsigned long *regp;
764 register long *offsetp;
766 register dw_cfi_ref cfi;
768 *regp = (unsigned long) -1;
771 for (cfi = cie_cfi_head; cfi; cfi = cfi->dw_cfi_next)
772 lookup_cfa_1 (cfi, regp, offsetp);
774 if (fde_table_in_use)
776 register dw_fde_ref fde = &fde_table[fde_table_in_use - 1];
777 for (cfi = fde->dw_fde_cfi; cfi; cfi = cfi->dw_cfi_next)
778 lookup_cfa_1 (cfi, regp, offsetp);
782 /* The current rule for calculating the DWARF2 canonical frame address. */
783 static unsigned long cfa_reg;
784 static long cfa_offset;
786 /* The register used for saving registers to the stack, and its offset
788 static unsigned cfa_store_reg;
789 static long cfa_store_offset;
791 /* The running total of the size of arguments pushed onto the stack. */
792 static long args_size;
794 /* The last args_size we actually output. */
795 static long old_args_size;
797 /* Entry point to update the canonical frame address (CFA).
798 LABEL is passed to add_fde_cfi. The value of CFA is now to be
799 calculated from REG+OFFSET. */
802 dwarf2out_def_cfa (label, reg, offset)
803 register char *label;
804 register unsigned reg;
805 register long offset;
807 register dw_cfi_ref cfi;
808 unsigned long old_reg;
813 if (cfa_store_reg == reg)
814 cfa_store_offset = offset;
816 reg = DWARF_FRAME_REGNUM (reg);
817 lookup_cfa (&old_reg, &old_offset);
819 if (reg == old_reg && offset == old_offset)
826 cfi->dw_cfi_opc = DW_CFA_def_cfa_offset;
827 cfi->dw_cfi_oprnd1.dw_cfi_offset = offset;
830 #ifndef MIPS_DEBUGGING_INFO /* SGI dbx thinks this means no offset. */
831 else if (offset == old_offset && old_reg != (unsigned long) -1)
833 cfi->dw_cfi_opc = DW_CFA_def_cfa_register;
834 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
840 cfi->dw_cfi_opc = DW_CFA_def_cfa;
841 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
842 cfi->dw_cfi_oprnd2.dw_cfi_offset = offset;
845 add_fde_cfi (label, cfi);
848 /* Add the CFI for saving a register. REG is the CFA column number.
849 LABEL is passed to add_fde_cfi.
850 If SREG is -1, the register is saved at OFFSET from the CFA;
851 otherwise it is saved in SREG. */
854 reg_save (label, reg, sreg, offset)
855 register char * label;
856 register unsigned reg;
857 register unsigned sreg;
858 register long offset;
860 register dw_cfi_ref cfi = new_cfi ();
862 cfi->dw_cfi_oprnd1.dw_cfi_reg_num = reg;
864 /* The following comparison is correct. -1 is used to indicate that
865 the value isn't a register number. */
866 if (sreg == (unsigned int) -1)
869 /* The register number won't fit in 6 bits, so we have to use
871 cfi->dw_cfi_opc = DW_CFA_offset_extended;
873 cfi->dw_cfi_opc = DW_CFA_offset;
875 offset /= DWARF_CIE_DATA_ALIGNMENT;
878 cfi->dw_cfi_opc = DW_CFA_GNU_negative_offset_extended;
881 cfi->dw_cfi_oprnd2.dw_cfi_offset = offset;
885 cfi->dw_cfi_opc = DW_CFA_register;
886 cfi->dw_cfi_oprnd2.dw_cfi_reg_num = sreg;
889 add_fde_cfi (label, cfi);
892 /* Add the CFI for saving a register window. LABEL is passed to reg_save.
893 This CFI tells the unwinder that it needs to restore the window registers
894 from the previous frame's window save area.
896 ??? Perhaps we should note in the CIE where windows are saved (instead of
897 assuming 0(cfa)) and what registers are in the window. */
900 dwarf2out_window_save (label)
901 register char * label;
903 register dw_cfi_ref cfi = new_cfi ();
904 cfi->dw_cfi_opc = DW_CFA_GNU_window_save;
905 add_fde_cfi (label, cfi);
908 /* Add a CFI to update the running total of the size of arguments
909 pushed onto the stack. */
912 dwarf2out_args_size (label, size)
916 register dw_cfi_ref cfi;
918 if (size == old_args_size)
920 old_args_size = size;
923 cfi->dw_cfi_opc = DW_CFA_GNU_args_size;
924 cfi->dw_cfi_oprnd1.dw_cfi_offset = size;
925 add_fde_cfi (label, cfi);
928 /* Entry point for saving a register to the stack. REG is the GCC register
929 number. LABEL and OFFSET are passed to reg_save. */
932 dwarf2out_reg_save (label, reg, offset)
933 register char * label;
934 register unsigned reg;
935 register long offset;
937 reg_save (label, DWARF_FRAME_REGNUM (reg), -1, offset);
940 /* Entry point for saving the return address in the stack.
941 LABEL and OFFSET are passed to reg_save. */
944 dwarf2out_return_save (label, offset)
945 register char * label;
946 register long offset;
948 reg_save (label, DWARF_FRAME_RETURN_COLUMN, -1, offset);
951 /* Entry point for saving the return address in a register.
952 LABEL and SREG are passed to reg_save. */
955 dwarf2out_return_reg (label, sreg)
956 register char * label;
957 register unsigned sreg;
959 reg_save (label, DWARF_FRAME_RETURN_COLUMN, sreg, 0);
962 /* Record the initial position of the return address. RTL is
963 INCOMING_RETURN_ADDR_RTX. */
966 initial_return_save (rtl)
969 unsigned int reg = (unsigned int) -1;
972 switch (GET_CODE (rtl))
975 /* RA is in a register. */
976 reg = reg_number (rtl);
979 /* RA is on the stack. */
981 switch (GET_CODE (rtl))
984 if (REGNO (rtl) != STACK_POINTER_REGNUM)
989 if (REGNO (XEXP (rtl, 0)) != STACK_POINTER_REGNUM)
991 offset = INTVAL (XEXP (rtl, 1));
994 if (REGNO (XEXP (rtl, 0)) != STACK_POINTER_REGNUM)
996 offset = -INTVAL (XEXP (rtl, 1));
1003 /* The return address is at some offset from any value we can
1004 actually load. For instance, on the SPARC it is in %i7+8. Just
1005 ignore the offset for now; it doesn't matter for unwinding frames. */
1006 if (GET_CODE (XEXP (rtl, 1)) != CONST_INT)
1008 initial_return_save (XEXP (rtl, 0));
1014 reg_save (NULL, DWARF_FRAME_RETURN_COLUMN, reg, offset - cfa_offset);
1017 /* Check INSN to see if it looks like a push or a stack adjustment, and
1018 make a note of it if it does. EH uses this information to find out how
1019 much extra space it needs to pop off the stack. */
1022 dwarf2out_stack_adjust (insn)
1028 if (! asynchronous_exceptions && GET_CODE (insn) == CALL_INSN)
1030 /* Extract the size of the args from the CALL rtx itself. */
1032 insn = PATTERN (insn);
1033 if (GET_CODE (insn) == PARALLEL)
1034 insn = XVECEXP (insn, 0, 0);
1035 if (GET_CODE (insn) == SET)
1036 insn = SET_SRC (insn);
1037 assert (GET_CODE (insn) == CALL);
1038 dwarf2out_args_size ("", INTVAL (XEXP (insn, 1)));
1042 /* If only calls can throw, and we have a frame pointer,
1043 save up adjustments until we see the CALL_INSN. */
1044 else if (! asynchronous_exceptions
1045 && cfa_reg != STACK_POINTER_REGNUM)
1048 if (GET_CODE (insn) == BARRIER)
1050 /* When we see a BARRIER, we know to reset args_size to 0. Usually
1051 the compiler will have already emitted a stack adjustment, but
1052 doesn't bother for calls to noreturn functions. */
1053 #ifdef STACK_GROWS_DOWNWARD
1054 offset = -args_size;
1059 else if (GET_CODE (PATTERN (insn)) == SET)
1064 insn = PATTERN (insn);
1065 src = SET_SRC (insn);
1066 dest = SET_DEST (insn);
1068 if (dest == stack_pointer_rtx)
1070 /* (set (reg sp) (plus (reg sp) (const_int))) */
1071 code = GET_CODE (src);
1072 if (! (code == PLUS || code == MINUS)
1073 || XEXP (src, 0) != stack_pointer_rtx
1074 || GET_CODE (XEXP (src, 1)) != CONST_INT)
1077 offset = INTVAL (XEXP (src, 1));
1079 else if (GET_CODE (dest) == MEM)
1081 /* (set (mem (pre_dec (reg sp))) (foo)) */
1082 src = XEXP (dest, 0);
1083 code = GET_CODE (src);
1085 if (! (code == PRE_DEC || code == PRE_INC)
1086 || XEXP (src, 0) != stack_pointer_rtx)
1089 offset = GET_MODE_SIZE (GET_MODE (dest));
1094 if (code == PLUS || code == PRE_INC)
1103 if (cfa_reg == STACK_POINTER_REGNUM)
1104 cfa_offset += offset;
1106 #ifndef STACK_GROWS_DOWNWARD
1109 args_size += offset;
1113 label = dwarf2out_cfi_label ();
1114 dwarf2out_def_cfa (label, cfa_reg, cfa_offset);
1115 dwarf2out_args_size (label, args_size);
1118 /* A temporary register used in adjusting SP or setting up the store_reg. */
1119 static unsigned cfa_temp_reg;
1121 /* A temporary value used in adjusting SP or setting up the store_reg. */
1122 static long cfa_temp_value;
1124 /* Record call frame debugging information for an expression, which either
1125 sets SP or FP (adjusting how we calculate the frame address) or saves a
1126 register to the stack. */
1129 dwarf2out_frame_debug_expr (expr, label)
1136 /* If RTX_FRAME_RELATED_P is set on a PARALLEL, process each member of
1137 the PARALLEL independantly. The first element is always processed if
1138 it is a SET. This is for backward compatability. Other elements
1139 are processed only if they are SETs and the RTX_FRAME_RELATED_P
1140 flag is set in them. */
1142 if (GET_CODE (expr) == PARALLEL)
1145 int limit = XVECLEN (expr, 0);
1147 for (par_index = 0; par_index < limit; par_index++)
1149 rtx x = XVECEXP (expr, 0, par_index);
1151 if (GET_CODE (x) == SET &&
1152 (RTX_FRAME_RELATED_P (x) || par_index == 0))
1153 dwarf2out_frame_debug_expr (x, label);
1158 if (GET_CODE (expr) != SET)
1161 src = SET_SRC (expr);
1162 dest = SET_DEST (expr);
1164 switch (GET_CODE (dest))
1167 /* Update the CFA rule wrt SP or FP. Make sure src is
1168 relative to the current CFA register. */
1169 switch (GET_CODE (src))
1171 /* Setting FP from SP. */
1173 if (cfa_reg != (unsigned) REGNO (src))
1175 if (REGNO (dest) != STACK_POINTER_REGNUM
1176 && !(frame_pointer_needed
1177 && REGNO (dest) == HARD_FRAME_POINTER_REGNUM))
1179 cfa_reg = REGNO (dest);
1184 if (dest == stack_pointer_rtx)
1187 switch (GET_CODE (XEXP (src, 1)))
1190 offset = INTVAL (XEXP (src, 1));
1193 if ((unsigned) REGNO (XEXP (src, 1)) != cfa_temp_reg)
1195 offset = cfa_temp_value;
1201 if (XEXP (src, 0) == hard_frame_pointer_rtx)
1203 /* Restoring SP from FP in the epilogue. */
1204 if (cfa_reg != (unsigned) HARD_FRAME_POINTER_REGNUM)
1206 cfa_reg = STACK_POINTER_REGNUM;
1208 else if (XEXP (src, 0) != stack_pointer_rtx)
1211 if (GET_CODE (src) == PLUS)
1213 if (cfa_reg == STACK_POINTER_REGNUM)
1214 cfa_offset += offset;
1215 if (cfa_store_reg == STACK_POINTER_REGNUM)
1216 cfa_store_offset += offset;
1218 else if (dest == hard_frame_pointer_rtx)
1220 /* Either setting the FP from an offset of the SP,
1221 or adjusting the FP */
1222 if (! frame_pointer_needed
1223 || REGNO (dest) != HARD_FRAME_POINTER_REGNUM)
1226 if (XEXP (src, 0) == stack_pointer_rtx
1227 && GET_CODE (XEXP (src, 1)) == CONST_INT)
1229 if (cfa_reg != STACK_POINTER_REGNUM)
1231 offset = INTVAL (XEXP (src, 1));
1232 if (GET_CODE (src) == PLUS)
1234 cfa_offset += offset;
1235 cfa_reg = HARD_FRAME_POINTER_REGNUM;
1237 else if (XEXP (src, 0) == hard_frame_pointer_rtx
1238 && GET_CODE (XEXP (src, 1)) == CONST_INT)
1240 if (cfa_reg != (unsigned) HARD_FRAME_POINTER_REGNUM)
1242 offset = INTVAL (XEXP (src, 1));
1243 if (GET_CODE (src) == PLUS)
1245 cfa_offset += offset;
1253 if (GET_CODE (src) != PLUS
1254 || XEXP (src, 1) != stack_pointer_rtx)
1256 if (GET_CODE (XEXP (src, 0)) != REG
1257 || (unsigned) REGNO (XEXP (src, 0)) != cfa_temp_reg)
1259 if (cfa_reg != STACK_POINTER_REGNUM)
1261 cfa_store_reg = REGNO (dest);
1262 cfa_store_offset = cfa_offset - cfa_temp_value;
1267 cfa_temp_reg = REGNO (dest);
1268 cfa_temp_value = INTVAL (src);
1272 if (GET_CODE (XEXP (src, 0)) != REG
1273 || (unsigned) REGNO (XEXP (src, 0)) != cfa_temp_reg
1274 || (unsigned) REGNO (dest) != cfa_temp_reg
1275 || GET_CODE (XEXP (src, 1)) != CONST_INT)
1277 cfa_temp_value |= INTVAL (XEXP (src, 1));
1283 dwarf2out_def_cfa (label, cfa_reg, cfa_offset);
1287 /* Saving a register to the stack. Make sure dest is relative to the
1289 if (GET_CODE (src) != REG)
1291 switch (GET_CODE (XEXP (dest, 0)))
1296 offset = GET_MODE_SIZE (GET_MODE (dest));
1297 if (GET_CODE (XEXP (dest, 0)) == PRE_INC)
1300 if (REGNO (XEXP (XEXP (dest, 0), 0)) != STACK_POINTER_REGNUM
1301 || cfa_store_reg != STACK_POINTER_REGNUM)
1303 cfa_store_offset += offset;
1304 if (cfa_reg == STACK_POINTER_REGNUM)
1305 cfa_offset = cfa_store_offset;
1307 offset = -cfa_store_offset;
1310 /* With an offset. */
1313 offset = INTVAL (XEXP (XEXP (dest, 0), 1));
1314 if (GET_CODE (XEXP (dest, 0)) == MINUS)
1317 if (cfa_store_reg != (unsigned) REGNO (XEXP (XEXP (dest, 0), 0)))
1319 offset -= cfa_store_offset;
1322 /* Without an offset. */
1324 if (cfa_store_reg != (unsigned) REGNO (XEXP (dest, 0)))
1326 offset = -cfa_store_offset;
1332 dwarf2out_def_cfa (label, cfa_reg, cfa_offset);
1333 dwarf2out_reg_save (label, REGNO (src), offset);
1342 /* Record call frame debugging information for INSN, which either
1343 sets SP or FP (adjusting how we calculate the frame address) or saves a
1344 register to the stack. If INSN is NULL_RTX, initialize our state. */
1347 dwarf2out_frame_debug (insn)
1353 if (insn == NULL_RTX)
1355 /* Set up state for generating call frame debug info. */
1356 lookup_cfa (&cfa_reg, &cfa_offset);
1357 if (cfa_reg != DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM))
1359 cfa_reg = STACK_POINTER_REGNUM;
1360 cfa_store_reg = cfa_reg;
1361 cfa_store_offset = cfa_offset;
1367 if (! RTX_FRAME_RELATED_P (insn))
1369 dwarf2out_stack_adjust (insn);
1373 label = dwarf2out_cfi_label ();
1375 src = find_reg_note (insn, REG_FRAME_RELATED_EXPR, NULL_RTX);
1377 insn = XEXP (src, 0);
1379 insn = PATTERN (insn);
1381 dwarf2out_frame_debug_expr (insn, label);
1384 /* Return the size of an unsigned LEB128 quantity. */
1386 static inline unsigned long
1387 size_of_uleb128 (value)
1388 register unsigned long value;
1390 register unsigned long size = 0;
1391 register unsigned byte;
1395 byte = (value & 0x7f);
1404 /* Return the size of a signed LEB128 quantity. */
1406 static inline unsigned long
1407 size_of_sleb128 (value)
1408 register long value;
1410 register unsigned long size = 0;
1411 register unsigned byte;
1415 byte = (value & 0x7f);
1419 while (!(((value == 0) && ((byte & 0x40) == 0))
1420 || ((value == -1) && ((byte & 0x40) != 0))));
1425 /* Output an unsigned LEB128 quantity. */
1428 output_uleb128 (value)
1429 register unsigned long value;
1431 unsigned long save_value = value;
1433 fprintf (asm_out_file, "\t%s\t", ASM_BYTE_OP);
1436 register unsigned byte = (value & 0x7f);
1439 /* More bytes to follow. */
1442 fprintf (asm_out_file, "0x%x", byte);
1444 fprintf (asm_out_file, ",");
1449 fprintf (asm_out_file, "\t%s ULEB128 0x%lx", ASM_COMMENT_START, save_value);
1452 /* Output an signed LEB128 quantity. */
1455 output_sleb128 (value)
1456 register long value;
1459 register unsigned byte;
1460 long save_value = value;
1462 fprintf (asm_out_file, "\t%s\t", ASM_BYTE_OP);
1465 byte = (value & 0x7f);
1466 /* arithmetic shift */
1468 more = !((((value == 0) && ((byte & 0x40) == 0))
1469 || ((value == -1) && ((byte & 0x40) != 0))));
1473 fprintf (asm_out_file, "0x%x", byte);
1475 fprintf (asm_out_file, ",");
1480 fprintf (asm_out_file, "\t%s SLEB128 %ld", ASM_COMMENT_START, save_value);
1483 /* Output a Call Frame Information opcode and its operand(s). */
1486 output_cfi (cfi, fde)
1487 register dw_cfi_ref cfi;
1488 register dw_fde_ref fde;
1490 if (cfi->dw_cfi_opc == DW_CFA_advance_loc)
1492 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
1494 | (cfi->dw_cfi_oprnd1.dw_cfi_offset & 0x3f));
1496 fprintf (asm_out_file, "\t%s DW_CFA_advance_loc 0x%lx",
1497 ASM_COMMENT_START, cfi->dw_cfi_oprnd1.dw_cfi_offset);
1498 fputc ('\n', asm_out_file);
1501 else if (cfi->dw_cfi_opc == DW_CFA_offset)
1503 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
1505 | (cfi->dw_cfi_oprnd1.dw_cfi_reg_num & 0x3f));
1507 fprintf (asm_out_file, "\t%s DW_CFA_offset, column 0x%lx",
1508 ASM_COMMENT_START, cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
1510 fputc ('\n', asm_out_file);
1511 output_uleb128 (cfi->dw_cfi_oprnd2.dw_cfi_offset);
1512 fputc ('\n', asm_out_file);
1514 else if (cfi->dw_cfi_opc == DW_CFA_restore)
1516 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
1518 | (cfi->dw_cfi_oprnd1.dw_cfi_reg_num & 0x3f));
1520 fprintf (asm_out_file, "\t%s DW_CFA_restore, column 0x%lx",
1521 ASM_COMMENT_START, cfi->dw_cfi_oprnd1.dw_cfi_reg_num);
1523 fputc ('\n', asm_out_file);
1527 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, cfi->dw_cfi_opc);
1529 fprintf (asm_out_file, "\t%s %s", ASM_COMMENT_START,
1530 dwarf_cfi_name (cfi->dw_cfi_opc));
1532 fputc ('\n', asm_out_file);
1533 switch (cfi->dw_cfi_opc)
1535 case DW_CFA_set_loc:
1536 ASM_OUTPUT_DWARF_ADDR (asm_out_file, cfi->dw_cfi_oprnd1.dw_cfi_addr);
1537 fputc ('\n', asm_out_file);
1539 case DW_CFA_advance_loc1:
1540 ASM_OUTPUT_DWARF_DELTA1 (asm_out_file,
1541 cfi->dw_cfi_oprnd1.dw_cfi_addr,
1542 fde->dw_fde_current_label);
1543 fputc ('\n', asm_out_file);
1544 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
1546 case DW_CFA_advance_loc2:
1547 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file,
1548 cfi->dw_cfi_oprnd1.dw_cfi_addr,
1549 fde->dw_fde_current_label);
1550 fputc ('\n', asm_out_file);
1551 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
1553 case DW_CFA_advance_loc4:
1554 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file,
1555 cfi->dw_cfi_oprnd1.dw_cfi_addr,
1556 fde->dw_fde_current_label);
1557 fputc ('\n', asm_out_file);
1558 fde->dw_fde_current_label = cfi->dw_cfi_oprnd1.dw_cfi_addr;
1560 #ifdef MIPS_DEBUGGING_INFO
1561 case DW_CFA_MIPS_advance_loc8:
1562 /* TODO: not currently implemented. */
1566 case DW_CFA_offset_extended:
1567 case DW_CFA_GNU_negative_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 /* Array of RTXes referenced by the debugging information, which therefore
2334 must be kept around forever. We do this rather than perform GC on
2335 the dwarf info because almost all of the dwarf info lives forever, and
2336 it's easier to support non-GC frontends this way. */
2337 static varray_type used_rtx_varray;
2339 /* Forward declarations for functions defined in this file. */
2341 static int is_pseudo_reg PARAMS ((rtx));
2342 static tree type_main_variant PARAMS ((tree));
2343 static int is_tagged_type PARAMS ((tree));
2344 static const char *dwarf_tag_name PARAMS ((unsigned));
2345 static const char *dwarf_attr_name PARAMS ((unsigned));
2346 static const char *dwarf_form_name PARAMS ((unsigned));
2347 static const char *dwarf_stack_op_name PARAMS ((unsigned));
2349 static const char *dwarf_type_encoding_name PARAMS ((unsigned));
2351 static tree decl_ultimate_origin PARAMS ((tree));
2352 static tree block_ultimate_origin PARAMS ((tree));
2353 static tree decl_class_context PARAMS ((tree));
2354 static void add_dwarf_attr PARAMS ((dw_die_ref, dw_attr_ref));
2355 static void add_AT_flag PARAMS ((dw_die_ref,
2356 enum dwarf_attribute,
2358 static void add_AT_int PARAMS ((dw_die_ref,
2359 enum dwarf_attribute, long));
2360 static void add_AT_unsigned PARAMS ((dw_die_ref,
2361 enum dwarf_attribute,
2363 static void add_AT_long_long PARAMS ((dw_die_ref,
2364 enum dwarf_attribute,
2367 static void add_AT_float PARAMS ((dw_die_ref,
2368 enum dwarf_attribute,
2370 static void add_AT_string PARAMS ((dw_die_ref,
2371 enum dwarf_attribute,
2373 static void add_AT_die_ref PARAMS ((dw_die_ref,
2374 enum dwarf_attribute,
2376 static void add_AT_fde_ref PARAMS ((dw_die_ref,
2377 enum dwarf_attribute,
2379 static void add_AT_loc PARAMS ((dw_die_ref,
2380 enum dwarf_attribute,
2382 static void add_AT_addr PARAMS ((dw_die_ref,
2383 enum dwarf_attribute,
2385 static void add_AT_lbl_id PARAMS ((dw_die_ref,
2386 enum dwarf_attribute,
2388 static void add_AT_lbl_offset PARAMS ((dw_die_ref,
2389 enum dwarf_attribute,
2391 static dw_attr_ref get_AT PARAMS ((dw_die_ref,
2392 enum dwarf_attribute));
2393 static const char *get_AT_low_pc PARAMS ((dw_die_ref));
2394 static const char *get_AT_hi_pc PARAMS ((dw_die_ref));
2395 static const char *get_AT_string PARAMS ((dw_die_ref,
2396 enum dwarf_attribute));
2397 static int get_AT_flag PARAMS ((dw_die_ref,
2398 enum dwarf_attribute));
2399 static unsigned get_AT_unsigned PARAMS ((dw_die_ref,
2400 enum dwarf_attribute));
2401 static int is_c_family PARAMS ((void));
2402 static int is_fortran PARAMS ((void));
2403 static void remove_AT PARAMS ((dw_die_ref,
2404 enum dwarf_attribute));
2405 static void remove_children PARAMS ((dw_die_ref));
2406 static void add_child_die PARAMS ((dw_die_ref, dw_die_ref));
2407 static dw_die_ref new_die PARAMS ((enum dwarf_tag, dw_die_ref));
2408 static dw_die_ref lookup_type_die PARAMS ((tree));
2409 static void equate_type_number_to_die PARAMS ((tree, dw_die_ref));
2410 static dw_die_ref lookup_decl_die PARAMS ((tree));
2411 static void equate_decl_number_to_die PARAMS ((tree, dw_die_ref));
2412 static dw_loc_descr_ref new_loc_descr PARAMS ((enum dwarf_location_atom,
2415 static void add_loc_descr PARAMS ((dw_loc_descr_ref *,
2417 static void print_spaces PARAMS ((FILE *));
2418 static void print_die PARAMS ((dw_die_ref, FILE *));
2419 static void print_dwarf_line_table PARAMS ((FILE *));
2420 static void add_sibling_attributes PARAMS ((dw_die_ref));
2421 static void build_abbrev_table PARAMS ((dw_die_ref));
2422 static unsigned long size_of_string PARAMS ((const char *));
2423 static unsigned long size_of_loc_descr PARAMS ((dw_loc_descr_ref));
2424 static unsigned long size_of_locs PARAMS ((dw_loc_descr_ref));
2425 static int constant_size PARAMS ((long unsigned));
2426 static unsigned long size_of_die PARAMS ((dw_die_ref));
2427 static void calc_die_sizes PARAMS ((dw_die_ref));
2428 static unsigned long size_of_line_prolog PARAMS ((void));
2429 static unsigned long size_of_pubnames PARAMS ((void));
2430 static unsigned long size_of_aranges PARAMS ((void));
2431 static enum dwarf_form value_format PARAMS ((dw_attr_ref));
2432 static void output_value_format PARAMS ((dw_attr_ref));
2433 static void output_abbrev_section PARAMS ((void));
2434 static void output_loc_operands PARAMS ((dw_loc_descr_ref));
2435 static void output_die PARAMS ((dw_die_ref));
2436 static void output_compilation_unit_header PARAMS ((void));
2437 static const char *dwarf2_name PARAMS ((tree, int));
2438 static void add_pubname PARAMS ((tree, dw_die_ref));
2439 static void output_pubnames PARAMS ((void));
2440 static void add_arange PARAMS ((tree, dw_die_ref));
2441 static void output_aranges PARAMS ((void));
2442 static void output_line_info PARAMS ((void));
2443 static int is_body_block PARAMS ((tree));
2444 static dw_die_ref base_type_die PARAMS ((tree));
2445 static tree root_type PARAMS ((tree));
2446 static int is_base_type PARAMS ((tree));
2447 static dw_die_ref modified_type_die PARAMS ((tree, int, int, dw_die_ref));
2448 static int type_is_enum PARAMS ((tree));
2449 static dw_loc_descr_ref reg_loc_descriptor PARAMS ((rtx));
2450 static dw_loc_descr_ref based_loc_descr PARAMS ((unsigned, long));
2451 static int is_based_loc PARAMS ((rtx));
2452 static dw_loc_descr_ref mem_loc_descriptor PARAMS ((rtx, enum machine_mode mode));
2453 static dw_loc_descr_ref concat_loc_descriptor PARAMS ((rtx, rtx));
2454 static dw_loc_descr_ref loc_descriptor PARAMS ((rtx));
2455 static unsigned ceiling PARAMS ((unsigned, unsigned));
2456 static tree field_type PARAMS ((tree));
2457 static unsigned simple_type_align_in_bits PARAMS ((tree));
2458 static unsigned simple_type_size_in_bits PARAMS ((tree));
2459 static unsigned field_byte_offset PARAMS ((tree));
2460 static void add_AT_location_description PARAMS ((dw_die_ref,
2461 enum dwarf_attribute, rtx));
2462 static void add_data_member_location_attribute PARAMS ((dw_die_ref, tree));
2463 static void add_const_value_attribute PARAMS ((dw_die_ref, rtx));
2464 static void add_location_or_const_value_attribute PARAMS ((dw_die_ref, tree));
2465 static void add_name_attribute PARAMS ((dw_die_ref, const char *));
2466 static void add_bound_info PARAMS ((dw_die_ref,
2467 enum dwarf_attribute, tree));
2468 static void add_subscript_info PARAMS ((dw_die_ref, tree));
2469 static void add_byte_size_attribute PARAMS ((dw_die_ref, tree));
2470 static void add_bit_offset_attribute PARAMS ((dw_die_ref, tree));
2471 static void add_bit_size_attribute PARAMS ((dw_die_ref, tree));
2472 static void add_prototyped_attribute PARAMS ((dw_die_ref, tree));
2473 static void add_abstract_origin_attribute PARAMS ((dw_die_ref, tree));
2474 static void add_pure_or_virtual_attribute PARAMS ((dw_die_ref, tree));
2475 static void add_src_coords_attributes PARAMS ((dw_die_ref, tree));
2476 static void add_name_and_src_coords_attributes PARAMS ((dw_die_ref, tree));
2477 static void push_decl_scope PARAMS ((tree));
2478 static dw_die_ref scope_die_for PARAMS ((tree, dw_die_ref));
2479 static void pop_decl_scope PARAMS ((void));
2480 static void add_type_attribute PARAMS ((dw_die_ref, tree, int, int,
2482 static char *type_tag PARAMS ((tree));
2483 static tree member_declared_type PARAMS ((tree));
2485 static char *decl_start_label PARAMS ((tree));
2487 static void gen_array_type_die PARAMS ((tree, dw_die_ref));
2488 static void gen_set_type_die PARAMS ((tree, dw_die_ref));
2490 static void gen_entry_point_die PARAMS ((tree, dw_die_ref));
2492 static void gen_inlined_enumeration_type_die PARAMS ((tree, dw_die_ref));
2493 static void gen_inlined_structure_type_die PARAMS ((tree, dw_die_ref));
2494 static void gen_inlined_union_type_die PARAMS ((tree, dw_die_ref));
2495 static void gen_enumeration_type_die PARAMS ((tree, dw_die_ref));
2496 static dw_die_ref gen_formal_parameter_die PARAMS ((tree, dw_die_ref));
2497 static void gen_unspecified_parameters_die PARAMS ((tree, dw_die_ref));
2498 static void gen_formal_types_die PARAMS ((tree, dw_die_ref));
2499 static void gen_subprogram_die PARAMS ((tree, dw_die_ref));
2500 static void gen_variable_die PARAMS ((tree, dw_die_ref));
2501 static void gen_label_die PARAMS ((tree, dw_die_ref));
2502 static void gen_lexical_block_die PARAMS ((tree, dw_die_ref, int));
2503 static void gen_inlined_subroutine_die PARAMS ((tree, dw_die_ref, int));
2504 static void gen_field_die PARAMS ((tree, dw_die_ref));
2505 static void gen_ptr_to_mbr_type_die PARAMS ((tree, dw_die_ref));
2506 static dw_die_ref gen_compile_unit_die PARAMS ((const char *));
2507 static void gen_string_type_die PARAMS ((tree, dw_die_ref));
2508 static void gen_inheritance_die PARAMS ((tree, dw_die_ref));
2509 static void gen_member_die PARAMS ((tree, dw_die_ref));
2510 static void gen_struct_or_union_type_die PARAMS ((tree, dw_die_ref));
2511 static void gen_subroutine_type_die PARAMS ((tree, dw_die_ref));
2512 static void gen_typedef_die PARAMS ((tree, dw_die_ref));
2513 static void gen_type_die PARAMS ((tree, dw_die_ref));
2514 static void gen_tagged_type_instantiation_die PARAMS ((tree, dw_die_ref));
2515 static void gen_block_die PARAMS ((tree, dw_die_ref, int));
2516 static void decls_for_scope PARAMS ((tree, dw_die_ref, int));
2517 static int is_redundant_typedef PARAMS ((tree));
2518 static void gen_decl_die PARAMS ((tree, dw_die_ref));
2519 static unsigned lookup_filename PARAMS ((const char *));
2520 static void add_incomplete_type PARAMS ((tree));
2521 static void retry_incomplete_types PARAMS ((void));
2522 static void gen_type_die_for_member PARAMS ((tree, tree, dw_die_ref));
2523 static void gen_abstract_function PARAMS ((tree));
2524 static rtx save_rtx PARAMS ((rtx));
2525 static void splice_child_die PARAMS ((dw_die_ref, dw_die_ref));
2526 static void reverse_die_lists PARAMS ((dw_die_ref));
2528 /* Section names used to hold DWARF debugging information. */
2529 #ifndef DEBUG_INFO_SECTION
2530 #define DEBUG_INFO_SECTION ".debug_info"
2532 #ifndef ABBREV_SECTION
2533 #define ABBREV_SECTION ".debug_abbrev"
2535 #ifndef ARANGES_SECTION
2536 #define ARANGES_SECTION ".debug_aranges"
2538 #ifndef DW_MACINFO_SECTION
2539 #define DW_MACINFO_SECTION ".debug_macinfo"
2541 #ifndef DEBUG_LINE_SECTION
2542 #define DEBUG_LINE_SECTION ".debug_line"
2545 #define LOC_SECTION ".debug_loc"
2547 #ifndef PUBNAMES_SECTION
2548 #define PUBNAMES_SECTION ".debug_pubnames"
2551 #define STR_SECTION ".debug_str"
2554 /* Standard ELF section names for compiled code and data. */
2555 #ifndef TEXT_SECTION
2556 #define TEXT_SECTION ".text"
2558 #ifndef DATA_SECTION
2559 #define DATA_SECTION ".data"
2562 #define BSS_SECTION ".bss"
2565 /* Labels we insert at beginning sections we can reference instead of
2566 the section names themselves. */
2568 #ifndef TEXT_SECTION_LABEL
2569 #define TEXT_SECTION_LABEL "Ltext"
2571 #ifndef DEBUG_LINE_SECTION_LABEL
2572 #define DEBUG_LINE_SECTION_LABEL "Ldebug_line"
2574 #ifndef DEBUG_INFO_SECTION_LABEL
2575 #define DEBUG_INFO_SECTION_LABEL "Ldebug_info"
2577 #ifndef ABBREV_SECTION_LABEL
2578 #define ABBREV_SECTION_LABEL "Ldebug_abbrev"
2582 /* Definitions of defaults for formats and names of various special
2583 (artificial) labels which may be generated within this file (when the -g
2584 options is used and DWARF_DEBUGGING_INFO is in effect.
2585 If necessary, these may be overridden from within the tm.h file, but
2586 typically, overriding these defaults is unnecessary. */
2588 static char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
2589 static char text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
2590 static char abbrev_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
2591 static char debug_info_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
2592 static char debug_line_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
2594 #ifndef TEXT_END_LABEL
2595 #define TEXT_END_LABEL "Letext"
2597 #ifndef DATA_END_LABEL
2598 #define DATA_END_LABEL "Ledata"
2600 #ifndef BSS_END_LABEL
2601 #define BSS_END_LABEL "Lebss"
2603 #ifndef INSN_LABEL_FMT
2604 #define INSN_LABEL_FMT "LI%u_"
2606 #ifndef BLOCK_BEGIN_LABEL
2607 #define BLOCK_BEGIN_LABEL "LBB"
2609 #ifndef BLOCK_END_LABEL
2610 #define BLOCK_END_LABEL "LBE"
2612 #ifndef BODY_BEGIN_LABEL
2613 #define BODY_BEGIN_LABEL "Lbb"
2615 #ifndef BODY_END_LABEL
2616 #define BODY_END_LABEL "Lbe"
2618 #ifndef LINE_CODE_LABEL
2619 #define LINE_CODE_LABEL "LM"
2621 #ifndef SEPARATE_LINE_CODE_LABEL
2622 #define SEPARATE_LINE_CODE_LABEL "LSM"
2625 /* We allow a language front-end to designate a function that is to be
2626 called to "demangle" any name before it it put into a DIE. */
2628 static const char *(*demangle_name_func) PARAMS ((const char *));
2631 dwarf2out_set_demangle_name_func (func)
2632 const char *(*func) PARAMS ((const char *));
2634 demangle_name_func = func;
2637 /* Return an rtx like ORIG which lives forever. If we're doing GC,
2638 that means adding it to used_rtx_varray. If not, that means making
2639 a copy on the permanent_obstack. */
2646 VARRAY_PUSH_RTX (used_rtx_varray, orig);
2649 push_obstacks_nochange ();
2650 end_temporary_allocation ();
2651 orig = copy_rtx (orig);
2658 /* Test if rtl node points to a pseudo register. */
2664 return (((GET_CODE (rtl) == REG) && (REGNO (rtl) >= FIRST_PSEUDO_REGISTER))
2665 || ((GET_CODE (rtl) == SUBREG)
2666 && (REGNO (XEXP (rtl, 0)) >= FIRST_PSEUDO_REGISTER)));
2669 /* Return a reference to a type, with its const and volatile qualifiers
2673 type_main_variant (type)
2676 type = TYPE_MAIN_VARIANT (type);
2678 /* There really should be only one main variant among any group of variants
2679 of a given type (and all of the MAIN_VARIANT values for all members of
2680 the group should point to that one type) but sometimes the C front-end
2681 messes this up for array types, so we work around that bug here. */
2683 if (TREE_CODE (type) == ARRAY_TYPE)
2684 while (type != TYPE_MAIN_VARIANT (type))
2685 type = TYPE_MAIN_VARIANT (type);
2690 /* Return non-zero if the given type node represents a tagged type. */
2693 is_tagged_type (type)
2696 register enum tree_code code = TREE_CODE (type);
2698 return (code == RECORD_TYPE || code == UNION_TYPE
2699 || code == QUAL_UNION_TYPE || code == ENUMERAL_TYPE);
2702 /* Convert a DIE tag into its string name. */
2705 dwarf_tag_name (tag)
2706 register unsigned tag;
2710 case DW_TAG_padding:
2711 return "DW_TAG_padding";
2712 case DW_TAG_array_type:
2713 return "DW_TAG_array_type";
2714 case DW_TAG_class_type:
2715 return "DW_TAG_class_type";
2716 case DW_TAG_entry_point:
2717 return "DW_TAG_entry_point";
2718 case DW_TAG_enumeration_type:
2719 return "DW_TAG_enumeration_type";
2720 case DW_TAG_formal_parameter:
2721 return "DW_TAG_formal_parameter";
2722 case DW_TAG_imported_declaration:
2723 return "DW_TAG_imported_declaration";
2725 return "DW_TAG_label";
2726 case DW_TAG_lexical_block:
2727 return "DW_TAG_lexical_block";
2729 return "DW_TAG_member";
2730 case DW_TAG_pointer_type:
2731 return "DW_TAG_pointer_type";
2732 case DW_TAG_reference_type:
2733 return "DW_TAG_reference_type";
2734 case DW_TAG_compile_unit:
2735 return "DW_TAG_compile_unit";
2736 case DW_TAG_string_type:
2737 return "DW_TAG_string_type";
2738 case DW_TAG_structure_type:
2739 return "DW_TAG_structure_type";
2740 case DW_TAG_subroutine_type:
2741 return "DW_TAG_subroutine_type";
2742 case DW_TAG_typedef:
2743 return "DW_TAG_typedef";
2744 case DW_TAG_union_type:
2745 return "DW_TAG_union_type";
2746 case DW_TAG_unspecified_parameters:
2747 return "DW_TAG_unspecified_parameters";
2748 case DW_TAG_variant:
2749 return "DW_TAG_variant";
2750 case DW_TAG_common_block:
2751 return "DW_TAG_common_block";
2752 case DW_TAG_common_inclusion:
2753 return "DW_TAG_common_inclusion";
2754 case DW_TAG_inheritance:
2755 return "DW_TAG_inheritance";
2756 case DW_TAG_inlined_subroutine:
2757 return "DW_TAG_inlined_subroutine";
2759 return "DW_TAG_module";
2760 case DW_TAG_ptr_to_member_type:
2761 return "DW_TAG_ptr_to_member_type";
2762 case DW_TAG_set_type:
2763 return "DW_TAG_set_type";
2764 case DW_TAG_subrange_type:
2765 return "DW_TAG_subrange_type";
2766 case DW_TAG_with_stmt:
2767 return "DW_TAG_with_stmt";
2768 case DW_TAG_access_declaration:
2769 return "DW_TAG_access_declaration";
2770 case DW_TAG_base_type:
2771 return "DW_TAG_base_type";
2772 case DW_TAG_catch_block:
2773 return "DW_TAG_catch_block";
2774 case DW_TAG_const_type:
2775 return "DW_TAG_const_type";
2776 case DW_TAG_constant:
2777 return "DW_TAG_constant";
2778 case DW_TAG_enumerator:
2779 return "DW_TAG_enumerator";
2780 case DW_TAG_file_type:
2781 return "DW_TAG_file_type";
2783 return "DW_TAG_friend";
2784 case DW_TAG_namelist:
2785 return "DW_TAG_namelist";
2786 case DW_TAG_namelist_item:
2787 return "DW_TAG_namelist_item";
2788 case DW_TAG_packed_type:
2789 return "DW_TAG_packed_type";
2790 case DW_TAG_subprogram:
2791 return "DW_TAG_subprogram";
2792 case DW_TAG_template_type_param:
2793 return "DW_TAG_template_type_param";
2794 case DW_TAG_template_value_param:
2795 return "DW_TAG_template_value_param";
2796 case DW_TAG_thrown_type:
2797 return "DW_TAG_thrown_type";
2798 case DW_TAG_try_block:
2799 return "DW_TAG_try_block";
2800 case DW_TAG_variant_part:
2801 return "DW_TAG_variant_part";
2802 case DW_TAG_variable:
2803 return "DW_TAG_variable";
2804 case DW_TAG_volatile_type:
2805 return "DW_TAG_volatile_type";
2806 case DW_TAG_MIPS_loop:
2807 return "DW_TAG_MIPS_loop";
2808 case DW_TAG_format_label:
2809 return "DW_TAG_format_label";
2810 case DW_TAG_function_template:
2811 return "DW_TAG_function_template";
2812 case DW_TAG_class_template:
2813 return "DW_TAG_class_template";
2815 return "DW_TAG_<unknown>";
2819 /* Convert a DWARF attribute code into its string name. */
2822 dwarf_attr_name (attr)
2823 register unsigned attr;
2828 return "DW_AT_sibling";
2829 case DW_AT_location:
2830 return "DW_AT_location";
2832 return "DW_AT_name";
2833 case DW_AT_ordering:
2834 return "DW_AT_ordering";
2835 case DW_AT_subscr_data:
2836 return "DW_AT_subscr_data";
2837 case DW_AT_byte_size:
2838 return "DW_AT_byte_size";
2839 case DW_AT_bit_offset:
2840 return "DW_AT_bit_offset";
2841 case DW_AT_bit_size:
2842 return "DW_AT_bit_size";
2843 case DW_AT_element_list:
2844 return "DW_AT_element_list";
2845 case DW_AT_stmt_list:
2846 return "DW_AT_stmt_list";
2848 return "DW_AT_low_pc";
2850 return "DW_AT_high_pc";
2851 case DW_AT_language:
2852 return "DW_AT_language";
2854 return "DW_AT_member";
2856 return "DW_AT_discr";
2857 case DW_AT_discr_value:
2858 return "DW_AT_discr_value";
2859 case DW_AT_visibility:
2860 return "DW_AT_visibility";
2862 return "DW_AT_import";
2863 case DW_AT_string_length:
2864 return "DW_AT_string_length";
2865 case DW_AT_common_reference:
2866 return "DW_AT_common_reference";
2867 case DW_AT_comp_dir:
2868 return "DW_AT_comp_dir";
2869 case DW_AT_const_value:
2870 return "DW_AT_const_value";
2871 case DW_AT_containing_type:
2872 return "DW_AT_containing_type";
2873 case DW_AT_default_value:
2874 return "DW_AT_default_value";
2876 return "DW_AT_inline";
2877 case DW_AT_is_optional:
2878 return "DW_AT_is_optional";
2879 case DW_AT_lower_bound:
2880 return "DW_AT_lower_bound";
2881 case DW_AT_producer:
2882 return "DW_AT_producer";
2883 case DW_AT_prototyped:
2884 return "DW_AT_prototyped";
2885 case DW_AT_return_addr:
2886 return "DW_AT_return_addr";
2887 case DW_AT_start_scope:
2888 return "DW_AT_start_scope";
2889 case DW_AT_stride_size:
2890 return "DW_AT_stride_size";
2891 case DW_AT_upper_bound:
2892 return "DW_AT_upper_bound";
2893 case DW_AT_abstract_origin:
2894 return "DW_AT_abstract_origin";
2895 case DW_AT_accessibility:
2896 return "DW_AT_accessibility";
2897 case DW_AT_address_class:
2898 return "DW_AT_address_class";
2899 case DW_AT_artificial:
2900 return "DW_AT_artificial";
2901 case DW_AT_base_types:
2902 return "DW_AT_base_types";
2903 case DW_AT_calling_convention:
2904 return "DW_AT_calling_convention";
2906 return "DW_AT_count";
2907 case DW_AT_data_member_location:
2908 return "DW_AT_data_member_location";
2909 case DW_AT_decl_column:
2910 return "DW_AT_decl_column";
2911 case DW_AT_decl_file:
2912 return "DW_AT_decl_file";
2913 case DW_AT_decl_line:
2914 return "DW_AT_decl_line";
2915 case DW_AT_declaration:
2916 return "DW_AT_declaration";
2917 case DW_AT_discr_list:
2918 return "DW_AT_discr_list";
2919 case DW_AT_encoding:
2920 return "DW_AT_encoding";
2921 case DW_AT_external:
2922 return "DW_AT_external";
2923 case DW_AT_frame_base:
2924 return "DW_AT_frame_base";
2926 return "DW_AT_friend";
2927 case DW_AT_identifier_case:
2928 return "DW_AT_identifier_case";
2929 case DW_AT_macro_info:
2930 return "DW_AT_macro_info";
2931 case DW_AT_namelist_items:
2932 return "DW_AT_namelist_items";
2933 case DW_AT_priority:
2934 return "DW_AT_priority";
2936 return "DW_AT_segment";
2937 case DW_AT_specification:
2938 return "DW_AT_specification";
2939 case DW_AT_static_link:
2940 return "DW_AT_static_link";
2942 return "DW_AT_type";
2943 case DW_AT_use_location:
2944 return "DW_AT_use_location";
2945 case DW_AT_variable_parameter:
2946 return "DW_AT_variable_parameter";
2947 case DW_AT_virtuality:
2948 return "DW_AT_virtuality";
2949 case DW_AT_vtable_elem_location:
2950 return "DW_AT_vtable_elem_location";
2952 case DW_AT_MIPS_fde:
2953 return "DW_AT_MIPS_fde";
2954 case DW_AT_MIPS_loop_begin:
2955 return "DW_AT_MIPS_loop_begin";
2956 case DW_AT_MIPS_tail_loop_begin:
2957 return "DW_AT_MIPS_tail_loop_begin";
2958 case DW_AT_MIPS_epilog_begin:
2959 return "DW_AT_MIPS_epilog_begin";
2960 case DW_AT_MIPS_loop_unroll_factor:
2961 return "DW_AT_MIPS_loop_unroll_factor";
2962 case DW_AT_MIPS_software_pipeline_depth:
2963 return "DW_AT_MIPS_software_pipeline_depth";
2964 case DW_AT_MIPS_linkage_name:
2965 return "DW_AT_MIPS_linkage_name";
2966 case DW_AT_MIPS_stride:
2967 return "DW_AT_MIPS_stride";
2968 case DW_AT_MIPS_abstract_name:
2969 return "DW_AT_MIPS_abstract_name";
2970 case DW_AT_MIPS_clone_origin:
2971 return "DW_AT_MIPS_clone_origin";
2972 case DW_AT_MIPS_has_inlines:
2973 return "DW_AT_MIPS_has_inlines";
2975 case DW_AT_sf_names:
2976 return "DW_AT_sf_names";
2977 case DW_AT_src_info:
2978 return "DW_AT_src_info";
2979 case DW_AT_mac_info:
2980 return "DW_AT_mac_info";
2981 case DW_AT_src_coords:
2982 return "DW_AT_src_coords";
2983 case DW_AT_body_begin:
2984 return "DW_AT_body_begin";
2985 case DW_AT_body_end:
2986 return "DW_AT_body_end";
2988 return "DW_AT_<unknown>";
2992 /* Convert a DWARF value form code into its string name. */
2995 dwarf_form_name (form)
2996 register unsigned form;
3001 return "DW_FORM_addr";
3002 case DW_FORM_block2:
3003 return "DW_FORM_block2";
3004 case DW_FORM_block4:
3005 return "DW_FORM_block4";
3007 return "DW_FORM_data2";
3009 return "DW_FORM_data4";
3011 return "DW_FORM_data8";
3012 case DW_FORM_string:
3013 return "DW_FORM_string";
3015 return "DW_FORM_block";
3016 case DW_FORM_block1:
3017 return "DW_FORM_block1";
3019 return "DW_FORM_data1";
3021 return "DW_FORM_flag";
3023 return "DW_FORM_sdata";
3025 return "DW_FORM_strp";
3027 return "DW_FORM_udata";
3028 case DW_FORM_ref_addr:
3029 return "DW_FORM_ref_addr";
3031 return "DW_FORM_ref1";
3033 return "DW_FORM_ref2";
3035 return "DW_FORM_ref4";
3037 return "DW_FORM_ref8";
3038 case DW_FORM_ref_udata:
3039 return "DW_FORM_ref_udata";
3040 case DW_FORM_indirect:
3041 return "DW_FORM_indirect";
3043 return "DW_FORM_<unknown>";
3047 /* Convert a DWARF stack opcode into its string name. */
3050 dwarf_stack_op_name (op)
3051 register unsigned op;
3056 return "DW_OP_addr";
3058 return "DW_OP_deref";
3060 return "DW_OP_const1u";
3062 return "DW_OP_const1s";
3064 return "DW_OP_const2u";
3066 return "DW_OP_const2s";
3068 return "DW_OP_const4u";
3070 return "DW_OP_const4s";
3072 return "DW_OP_const8u";
3074 return "DW_OP_const8s";
3076 return "DW_OP_constu";
3078 return "DW_OP_consts";
3082 return "DW_OP_drop";
3084 return "DW_OP_over";
3086 return "DW_OP_pick";
3088 return "DW_OP_swap";
3092 return "DW_OP_xderef";
3100 return "DW_OP_minus";
3112 return "DW_OP_plus";
3113 case DW_OP_plus_uconst:
3114 return "DW_OP_plus_uconst";
3120 return "DW_OP_shra";
3138 return "DW_OP_skip";
3140 return "DW_OP_lit0";
3142 return "DW_OP_lit1";
3144 return "DW_OP_lit2";
3146 return "DW_OP_lit3";
3148 return "DW_OP_lit4";
3150 return "DW_OP_lit5";
3152 return "DW_OP_lit6";
3154 return "DW_OP_lit7";
3156 return "DW_OP_lit8";
3158 return "DW_OP_lit9";
3160 return "DW_OP_lit10";
3162 return "DW_OP_lit11";
3164 return "DW_OP_lit12";
3166 return "DW_OP_lit13";
3168 return "DW_OP_lit14";
3170 return "DW_OP_lit15";
3172 return "DW_OP_lit16";
3174 return "DW_OP_lit17";
3176 return "DW_OP_lit18";
3178 return "DW_OP_lit19";
3180 return "DW_OP_lit20";
3182 return "DW_OP_lit21";
3184 return "DW_OP_lit22";
3186 return "DW_OP_lit23";
3188 return "DW_OP_lit24";
3190 return "DW_OP_lit25";
3192 return "DW_OP_lit26";
3194 return "DW_OP_lit27";
3196 return "DW_OP_lit28";
3198 return "DW_OP_lit29";
3200 return "DW_OP_lit30";
3202 return "DW_OP_lit31";
3204 return "DW_OP_reg0";
3206 return "DW_OP_reg1";
3208 return "DW_OP_reg2";
3210 return "DW_OP_reg3";
3212 return "DW_OP_reg4";
3214 return "DW_OP_reg5";
3216 return "DW_OP_reg6";
3218 return "DW_OP_reg7";
3220 return "DW_OP_reg8";
3222 return "DW_OP_reg9";
3224 return "DW_OP_reg10";
3226 return "DW_OP_reg11";
3228 return "DW_OP_reg12";
3230 return "DW_OP_reg13";
3232 return "DW_OP_reg14";
3234 return "DW_OP_reg15";
3236 return "DW_OP_reg16";
3238 return "DW_OP_reg17";
3240 return "DW_OP_reg18";
3242 return "DW_OP_reg19";
3244 return "DW_OP_reg20";
3246 return "DW_OP_reg21";
3248 return "DW_OP_reg22";
3250 return "DW_OP_reg23";
3252 return "DW_OP_reg24";
3254 return "DW_OP_reg25";
3256 return "DW_OP_reg26";
3258 return "DW_OP_reg27";
3260 return "DW_OP_reg28";
3262 return "DW_OP_reg29";
3264 return "DW_OP_reg30";
3266 return "DW_OP_reg31";
3268 return "DW_OP_breg0";
3270 return "DW_OP_breg1";
3272 return "DW_OP_breg2";
3274 return "DW_OP_breg3";
3276 return "DW_OP_breg4";
3278 return "DW_OP_breg5";
3280 return "DW_OP_breg6";
3282 return "DW_OP_breg7";
3284 return "DW_OP_breg8";
3286 return "DW_OP_breg9";
3288 return "DW_OP_breg10";
3290 return "DW_OP_breg11";
3292 return "DW_OP_breg12";
3294 return "DW_OP_breg13";
3296 return "DW_OP_breg14";
3298 return "DW_OP_breg15";
3300 return "DW_OP_breg16";
3302 return "DW_OP_breg17";
3304 return "DW_OP_breg18";
3306 return "DW_OP_breg19";
3308 return "DW_OP_breg20";
3310 return "DW_OP_breg21";
3312 return "DW_OP_breg22";
3314 return "DW_OP_breg23";
3316 return "DW_OP_breg24";
3318 return "DW_OP_breg25";
3320 return "DW_OP_breg26";
3322 return "DW_OP_breg27";
3324 return "DW_OP_breg28";
3326 return "DW_OP_breg29";
3328 return "DW_OP_breg30";
3330 return "DW_OP_breg31";
3332 return "DW_OP_regx";
3334 return "DW_OP_fbreg";
3336 return "DW_OP_bregx";
3338 return "DW_OP_piece";
3339 case DW_OP_deref_size:
3340 return "DW_OP_deref_size";
3341 case DW_OP_xderef_size:
3342 return "DW_OP_xderef_size";
3346 return "OP_<unknown>";
3350 /* Convert a DWARF type code into its string name. */
3354 dwarf_type_encoding_name (enc)
3355 register unsigned enc;
3359 case DW_ATE_address:
3360 return "DW_ATE_address";
3361 case DW_ATE_boolean:
3362 return "DW_ATE_boolean";
3363 case DW_ATE_complex_float:
3364 return "DW_ATE_complex_float";
3366 return "DW_ATE_float";
3368 return "DW_ATE_signed";
3369 case DW_ATE_signed_char:
3370 return "DW_ATE_signed_char";
3371 case DW_ATE_unsigned:
3372 return "DW_ATE_unsigned";
3373 case DW_ATE_unsigned_char:
3374 return "DW_ATE_unsigned_char";
3376 return "DW_ATE_<unknown>";
3381 /* Determine the "ultimate origin" of a decl. The decl may be an inlined
3382 instance of an inlined instance of a decl which is local to an inline
3383 function, so we have to trace all of the way back through the origin chain
3384 to find out what sort of node actually served as the original seed for the
3388 decl_ultimate_origin (decl)
3391 /* output_inline_function sets DECL_ABSTRACT_ORIGIN for all the
3392 nodes in the function to point to themselves; ignore that if
3393 we're trying to output the abstract instance of this function. */
3394 if (DECL_ABSTRACT (decl) && DECL_ABSTRACT_ORIGIN (decl) == decl)
3397 #ifdef ENABLE_CHECKING
3398 if (DECL_FROM_INLINE (DECL_ORIGIN (decl)))
3399 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
3400 most distant ancestor, this should never happen. */
3404 return DECL_ABSTRACT_ORIGIN (decl);
3407 /* Determine the "ultimate origin" of a block. The block may be an inlined
3408 instance of an inlined instance of a block which is local to an inline
3409 function, so we have to trace all of the way back through the origin chain
3410 to find out what sort of node actually served as the original seed for the
3414 block_ultimate_origin (block)
3415 register tree block;
3417 register tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block);
3419 /* output_inline_function sets BLOCK_ABSTRACT_ORIGIN for all the
3420 nodes in the function to point to themselves; ignore that if
3421 we're trying to output the abstract instance of this function. */
3422 if (BLOCK_ABSTRACT (block) && immediate_origin == block)
3425 if (immediate_origin == NULL_TREE)
3429 register tree ret_val;
3430 register tree lookahead = immediate_origin;
3434 ret_val = lookahead;
3435 lookahead = (TREE_CODE (ret_val) == BLOCK)
3436 ? BLOCK_ABSTRACT_ORIGIN (ret_val)
3439 while (lookahead != NULL && lookahead != ret_val);
3445 /* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT
3446 of a virtual function may refer to a base class, so we check the 'this'
3450 decl_class_context (decl)
3453 tree context = NULL_TREE;
3455 if (TREE_CODE (decl) != FUNCTION_DECL || ! DECL_VINDEX (decl))
3456 context = DECL_CONTEXT (decl);
3458 context = TYPE_MAIN_VARIANT
3459 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
3461 if (context && TREE_CODE_CLASS (TREE_CODE (context)) != 't')
3462 context = NULL_TREE;
3467 /* Add an attribute/value pair to a DIE. We build the lists up in reverse
3468 addition order, and correct that in add_sibling_attributes. */
3471 add_dwarf_attr (die, attr)
3472 register dw_die_ref die;
3473 register dw_attr_ref attr;
3475 if (die != NULL && attr != NULL)
3477 attr->dw_attr_next = die->die_attr;
3478 die->die_attr = attr;
3482 static inline dw_val_class AT_class PARAMS ((dw_attr_ref));
3483 static inline dw_val_class
3487 return a->dw_attr_val.val_class;
3490 /* Add a flag value attribute to a DIE. */
3493 add_AT_flag (die, attr_kind, flag)
3494 register dw_die_ref die;
3495 register enum dwarf_attribute attr_kind;
3496 register unsigned flag;
3498 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3500 attr->dw_attr_next = NULL;
3501 attr->dw_attr = attr_kind;
3502 attr->dw_attr_val.val_class = dw_val_class_flag;
3503 attr->dw_attr_val.v.val_flag = flag;
3504 add_dwarf_attr (die, attr);
3507 static inline unsigned AT_flag PARAMS ((dw_attr_ref));
3508 static inline unsigned
3510 register dw_attr_ref a;
3512 if (a && AT_class (a) == dw_val_class_flag)
3513 return a->dw_attr_val.v.val_flag;
3518 /* Add a signed integer attribute value to a DIE. */
3521 add_AT_int (die, attr_kind, int_val)
3522 register dw_die_ref die;
3523 register enum dwarf_attribute attr_kind;
3524 register long int int_val;
3526 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3528 attr->dw_attr_next = NULL;
3529 attr->dw_attr = attr_kind;
3530 attr->dw_attr_val.val_class = dw_val_class_const;
3531 attr->dw_attr_val.v.val_int = int_val;
3532 add_dwarf_attr (die, attr);
3535 static inline long int AT_int PARAMS ((dw_attr_ref));
3536 static inline long int
3538 register dw_attr_ref a;
3540 if (a && AT_class (a) == dw_val_class_const)
3541 return a->dw_attr_val.v.val_int;
3546 /* Add an unsigned integer attribute value to a DIE. */
3549 add_AT_unsigned (die, attr_kind, unsigned_val)
3550 register dw_die_ref die;
3551 register enum dwarf_attribute attr_kind;
3552 register unsigned long unsigned_val;
3554 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3556 attr->dw_attr_next = NULL;
3557 attr->dw_attr = attr_kind;
3558 attr->dw_attr_val.val_class = dw_val_class_unsigned_const;
3559 attr->dw_attr_val.v.val_unsigned = unsigned_val;
3560 add_dwarf_attr (die, attr);
3563 static inline unsigned long AT_unsigned PARAMS ((dw_attr_ref));
3564 static inline unsigned long
3566 register dw_attr_ref a;
3568 if (a && AT_class (a) == dw_val_class_unsigned_const)
3569 return a->dw_attr_val.v.val_unsigned;
3574 /* Add an unsigned double integer attribute value to a DIE. */
3577 add_AT_long_long (die, attr_kind, val_hi, val_low)
3578 register dw_die_ref die;
3579 register enum dwarf_attribute attr_kind;
3580 register unsigned long val_hi;
3581 register unsigned long val_low;
3583 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3585 attr->dw_attr_next = NULL;
3586 attr->dw_attr = attr_kind;
3587 attr->dw_attr_val.val_class = dw_val_class_long_long;
3588 attr->dw_attr_val.v.val_long_long.hi = val_hi;
3589 attr->dw_attr_val.v.val_long_long.low = val_low;
3590 add_dwarf_attr (die, attr);
3593 /* Add a floating point attribute value to a DIE and return it. */
3596 add_AT_float (die, attr_kind, length, array)
3597 register dw_die_ref die;
3598 register enum dwarf_attribute attr_kind;
3599 register unsigned length;
3600 register long *array;
3602 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3604 attr->dw_attr_next = NULL;
3605 attr->dw_attr = attr_kind;
3606 attr->dw_attr_val.val_class = dw_val_class_float;
3607 attr->dw_attr_val.v.val_float.length = length;
3608 attr->dw_attr_val.v.val_float.array = array;
3609 add_dwarf_attr (die, attr);
3612 /* Add a string attribute value to a DIE. */
3615 add_AT_string (die, attr_kind, str)
3616 register dw_die_ref die;
3617 register enum dwarf_attribute attr_kind;
3618 register const char *str;
3620 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3622 attr->dw_attr_next = NULL;
3623 attr->dw_attr = attr_kind;
3624 attr->dw_attr_val.val_class = dw_val_class_str;
3625 attr->dw_attr_val.v.val_str = xstrdup (str);
3626 add_dwarf_attr (die, attr);
3629 static inline const char *AT_string PARAMS ((dw_attr_ref));
3630 static inline const char *
3632 register dw_attr_ref a;
3634 if (a && AT_class (a) == dw_val_class_str)
3635 return a->dw_attr_val.v.val_str;
3640 /* Add a DIE reference attribute value to a DIE. */
3643 add_AT_die_ref (die, attr_kind, targ_die)
3644 register dw_die_ref die;
3645 register enum dwarf_attribute attr_kind;
3646 register dw_die_ref targ_die;
3648 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3650 attr->dw_attr_next = NULL;
3651 attr->dw_attr = attr_kind;
3652 attr->dw_attr_val.val_class = dw_val_class_die_ref;
3653 attr->dw_attr_val.v.val_die_ref = targ_die;
3654 add_dwarf_attr (die, attr);
3657 static inline dw_die_ref AT_ref PARAMS ((dw_attr_ref));
3658 static inline dw_die_ref
3660 register dw_attr_ref a;
3662 if (a && AT_class (a) == dw_val_class_die_ref)
3663 return a->dw_attr_val.v.val_die_ref;
3668 /* Add an FDE reference attribute value to a DIE. */
3671 add_AT_fde_ref (die, attr_kind, targ_fde)
3672 register dw_die_ref die;
3673 register enum dwarf_attribute attr_kind;
3674 register unsigned targ_fde;
3676 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3678 attr->dw_attr_next = NULL;
3679 attr->dw_attr = attr_kind;
3680 attr->dw_attr_val.val_class = dw_val_class_fde_ref;
3681 attr->dw_attr_val.v.val_fde_index = targ_fde;
3682 add_dwarf_attr (die, attr);
3685 /* Add a location description attribute value to a DIE. */
3688 add_AT_loc (die, attr_kind, loc)
3689 register dw_die_ref die;
3690 register enum dwarf_attribute attr_kind;
3691 register dw_loc_descr_ref loc;
3693 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3695 attr->dw_attr_next = NULL;
3696 attr->dw_attr = attr_kind;
3697 attr->dw_attr_val.val_class = dw_val_class_loc;
3698 attr->dw_attr_val.v.val_loc = loc;
3699 add_dwarf_attr (die, attr);
3702 static inline dw_loc_descr_ref AT_loc PARAMS ((dw_attr_ref));
3703 static inline dw_loc_descr_ref
3705 register dw_attr_ref a;
3707 if (a && AT_class (a) == dw_val_class_loc)
3708 return a->dw_attr_val.v.val_loc;
3713 /* Add an address constant attribute value to a DIE. */
3716 add_AT_addr (die, attr_kind, addr)
3717 register dw_die_ref die;
3718 register enum dwarf_attribute attr_kind;
3721 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3723 attr->dw_attr_next = NULL;
3724 attr->dw_attr = attr_kind;
3725 attr->dw_attr_val.val_class = dw_val_class_addr;
3726 attr->dw_attr_val.v.val_addr = addr;
3727 add_dwarf_attr (die, attr);
3730 static inline rtx AT_addr PARAMS ((dw_attr_ref));
3733 register dw_attr_ref a;
3735 if (a && AT_class (a) == dw_val_class_addr)
3736 return a->dw_attr_val.v.val_addr;
3741 /* Add a label identifier attribute value to a DIE. */
3744 add_AT_lbl_id (die, attr_kind, lbl_id)
3745 register dw_die_ref die;
3746 register enum dwarf_attribute attr_kind;
3747 register char *lbl_id;
3749 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3751 attr->dw_attr_next = NULL;
3752 attr->dw_attr = attr_kind;
3753 attr->dw_attr_val.val_class = dw_val_class_lbl_id;
3754 attr->dw_attr_val.v.val_lbl_id = xstrdup (lbl_id);
3755 add_dwarf_attr (die, attr);
3758 /* Add a section offset attribute value to a DIE. */
3761 add_AT_lbl_offset (die, attr_kind, label)
3762 register dw_die_ref die;
3763 register enum dwarf_attribute attr_kind;
3764 register char *label;
3766 register dw_attr_ref attr = (dw_attr_ref) xmalloc (sizeof (dw_attr_node));
3768 attr->dw_attr_next = NULL;
3769 attr->dw_attr = attr_kind;
3770 attr->dw_attr_val.val_class = dw_val_class_lbl_offset;
3771 attr->dw_attr_val.v.val_lbl_id = xstrdup (label);
3772 add_dwarf_attr (die, attr);
3776 static inline const char *AT_lbl PARAMS ((dw_attr_ref));
3777 static inline const char *
3779 register dw_attr_ref a;
3781 if (a && (AT_class (a) == dw_val_class_lbl_id
3782 || AT_class (a) == dw_val_class_lbl_offset))
3783 return a->dw_attr_val.v.val_lbl_id;
3788 /* Get the attribute of type attr_kind. */
3790 static inline dw_attr_ref
3791 get_AT (die, attr_kind)
3792 register dw_die_ref die;
3793 register enum dwarf_attribute attr_kind;
3795 register dw_attr_ref a;
3796 register dw_die_ref spec = NULL;
3800 for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
3802 if (a->dw_attr == attr_kind)
3805 if (a->dw_attr == DW_AT_specification
3806 || a->dw_attr == DW_AT_abstract_origin)
3811 return get_AT (spec, attr_kind);
3817 /* Return the "low pc" attribute value, typically associated with
3818 a subprogram DIE. Return null if the "low pc" attribute is
3819 either not prsent, or if it cannot be represented as an
3820 assembler label identifier. */
3822 static inline const char *
3824 register dw_die_ref die;
3826 register dw_attr_ref a = get_AT (die, DW_AT_low_pc);
3830 /* Return the "high pc" attribute value, typically associated with
3831 a subprogram DIE. Return null if the "high pc" attribute is
3832 either not prsent, or if it cannot be represented as an
3833 assembler label identifier. */
3835 static inline const char *
3837 register dw_die_ref die;
3839 register dw_attr_ref a = get_AT (die, DW_AT_high_pc);
3843 /* Return the value of the string attribute designated by ATTR_KIND, or
3844 NULL if it is not present. */
3846 static inline const char *
3847 get_AT_string (die, attr_kind)
3848 register dw_die_ref die;
3849 register enum dwarf_attribute attr_kind;
3851 register dw_attr_ref a = get_AT (die, attr_kind);
3852 return AT_string (a);
3855 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
3856 if it is not present. */
3859 get_AT_flag (die, attr_kind)
3860 register dw_die_ref die;
3861 register enum dwarf_attribute attr_kind;
3863 register dw_attr_ref a = get_AT (die, attr_kind);
3867 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
3868 if it is not present. */
3870 static inline unsigned
3871 get_AT_unsigned (die, attr_kind)
3872 register dw_die_ref die;
3873 register enum dwarf_attribute attr_kind;
3875 register dw_attr_ref a = get_AT (die, attr_kind);
3876 return AT_unsigned (a);
3879 static inline dw_die_ref get_AT_ref PARAMS ((dw_die_ref, enum dwarf_attribute));
3880 static inline dw_die_ref
3881 get_AT_ref (die, attr_kind)
3883 register enum dwarf_attribute attr_kind;
3885 register dw_attr_ref a = get_AT (die, attr_kind);
3892 register unsigned lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
3894 return (lang == DW_LANG_C || lang == DW_LANG_C89
3895 || lang == DW_LANG_C_plus_plus);
3901 register unsigned lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
3903 return (lang == DW_LANG_Fortran77 || lang == DW_LANG_Fortran90);
3906 /* Free up the memory used by A. */
3908 static inline void free_AT PARAMS ((dw_attr_ref));
3913 switch (AT_class (a))
3915 case dw_val_class_str:
3916 case dw_val_class_lbl_id:
3917 case dw_val_class_lbl_offset:
3918 free (a->dw_attr_val.v.val_str);
3928 /* Remove the specified attribute if present. */
3931 remove_AT (die, attr_kind)
3932 register dw_die_ref die;
3933 register enum dwarf_attribute attr_kind;
3935 register dw_attr_ref *p;
3936 register dw_attr_ref removed = NULL;
3940 for (p = &(die->die_attr); *p; p = &((*p)->dw_attr_next))
3941 if ((*p)->dw_attr == attr_kind)
3944 *p = (*p)->dw_attr_next;
3953 /* Free up the memory used by DIE. */
3955 static inline void free_die PARAMS ((dw_die_ref));
3960 remove_children (die);
3964 /* Discard the children of this DIE. */
3967 remove_children (die)
3968 register dw_die_ref die;
3970 register dw_die_ref child_die = die->die_child;
3972 die->die_child = NULL;
3974 while (child_die != NULL)
3976 register dw_die_ref tmp_die = child_die;
3977 register dw_attr_ref a;
3979 child_die = child_die->die_sib;
3981 for (a = tmp_die->die_attr; a != NULL; )
3983 register dw_attr_ref tmp_a = a;
3985 a = a->dw_attr_next;
3993 /* Add a child DIE below its parent. We build the lists up in reverse
3994 addition order, and correct that in add_sibling_attributes. */
3997 add_child_die (die, child_die)
3998 register dw_die_ref die;
3999 register dw_die_ref child_die;
4001 if (die != NULL && child_die != NULL)
4003 if (die == child_die)
4005 child_die->die_parent = die;
4006 child_die->die_sib = die->die_child;
4007 die->die_child = child_die;
4011 /* Move CHILD, which must be a child of PARENT or the DIE for which PARENT
4012 is the specification, to the front of PARENT's list of children. */
4015 splice_child_die (parent, child)
4016 dw_die_ref parent, child;
4020 /* We want the declaration DIE from inside the class, not the
4021 specification DIE at toplevel. */
4022 if (child->die_parent != parent)
4024 dw_die_ref tmp = get_AT_ref (child, DW_AT_specification);
4029 if (child->die_parent != parent
4030 && child->die_parent != get_AT_ref (parent, DW_AT_specification))
4033 for (p = &(parent->die_child); *p; p = &((*p)->die_sib))
4036 *p = child->die_sib;
4040 child->die_sib = parent->die_child;
4041 parent->die_child = child;
4044 /* Return a pointer to a newly created DIE node. */
4046 static inline dw_die_ref
4047 new_die (tag_value, parent_die)
4048 register enum dwarf_tag tag_value;
4049 register dw_die_ref parent_die;
4051 register dw_die_ref die = (dw_die_ref) xmalloc (sizeof (die_node));
4053 die->die_tag = tag_value;
4054 die->die_abbrev = 0;
4055 die->die_offset = 0;
4056 die->die_child = NULL;
4057 die->die_parent = NULL;
4058 die->die_sib = NULL;
4059 die->die_attr = NULL;
4061 if (parent_die != NULL)
4062 add_child_die (parent_die, die);
4065 limbo_die_node *limbo_node;
4067 limbo_node = (limbo_die_node *) xmalloc (sizeof (limbo_die_node));
4068 limbo_node->die = die;
4069 limbo_node->next = limbo_die_list;
4070 limbo_die_list = limbo_node;
4076 /* Return the DIE associated with the given type specifier. */
4078 static inline dw_die_ref
4079 lookup_type_die (type)
4082 return (dw_die_ref) TYPE_SYMTAB_POINTER (type);
4085 /* Equate a DIE to a given type specifier. */
4088 equate_type_number_to_die (type, type_die)
4090 register dw_die_ref type_die;
4092 TYPE_SYMTAB_POINTER (type) = (char *) type_die;
4095 /* Return the DIE associated with a given declaration. */
4097 static inline dw_die_ref
4098 lookup_decl_die (decl)
4101 register unsigned decl_id = DECL_UID (decl);
4103 return (decl_id < decl_die_table_in_use
4104 ? decl_die_table[decl_id] : NULL);
4107 /* Equate a DIE to a particular declaration. */
4110 equate_decl_number_to_die (decl, decl_die)
4112 register dw_die_ref decl_die;
4114 register unsigned decl_id = DECL_UID (decl);
4115 register unsigned num_allocated;
4117 if (decl_id >= decl_die_table_allocated)
4120 = ((decl_id + 1 + DECL_DIE_TABLE_INCREMENT - 1)
4121 / DECL_DIE_TABLE_INCREMENT)
4122 * DECL_DIE_TABLE_INCREMENT;
4125 = (dw_die_ref *) xrealloc (decl_die_table,
4126 sizeof (dw_die_ref) * num_allocated);
4128 bzero ((char *) &decl_die_table[decl_die_table_allocated],
4129 (num_allocated - decl_die_table_allocated) * sizeof (dw_die_ref));
4130 decl_die_table_allocated = num_allocated;
4133 if (decl_id >= decl_die_table_in_use)
4134 decl_die_table_in_use = (decl_id + 1);
4136 decl_die_table[decl_id] = decl_die;
4139 /* Return a pointer to a newly allocated location description. Location
4140 descriptions are simple expression terms that can be strung
4141 together to form more complicated location (address) descriptions. */
4143 static inline dw_loc_descr_ref
4144 new_loc_descr (op, oprnd1, oprnd2)
4145 register enum dwarf_location_atom op;
4146 register unsigned long oprnd1;
4147 register unsigned long oprnd2;
4149 register dw_loc_descr_ref descr
4150 = (dw_loc_descr_ref) xmalloc (sizeof (dw_loc_descr_node));
4152 descr->dw_loc_next = NULL;
4153 descr->dw_loc_opc = op;
4154 descr->dw_loc_oprnd1.val_class = dw_val_class_unsigned_const;
4155 descr->dw_loc_oprnd1.v.val_unsigned = oprnd1;
4156 descr->dw_loc_oprnd2.val_class = dw_val_class_unsigned_const;
4157 descr->dw_loc_oprnd2.v.val_unsigned = oprnd2;
4162 /* Add a location description term to a location description expression. */
4165 add_loc_descr (list_head, descr)
4166 register dw_loc_descr_ref *list_head;
4167 register dw_loc_descr_ref descr;
4169 register dw_loc_descr_ref *d;
4171 /* Find the end of the chain. */
4172 for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
4178 /* Keep track of the number of spaces used to indent the
4179 output of the debugging routines that print the structure of
4180 the DIE internal representation. */
4181 static int print_indent;
4183 /* Indent the line the number of spaces given by print_indent. */
4186 print_spaces (outfile)
4189 fprintf (outfile, "%*s", print_indent, "");
4192 /* Print the information associated with a given DIE, and its children.
4193 This routine is a debugging aid only. */
4196 print_die (die, outfile)
4200 register dw_attr_ref a;
4201 register dw_die_ref c;
4203 print_spaces (outfile);
4204 fprintf (outfile, "DIE %4lu: %s\n",
4205 die->die_offset, dwarf_tag_name (die->die_tag));
4206 print_spaces (outfile);
4207 fprintf (outfile, " abbrev id: %lu", die->die_abbrev);
4208 fprintf (outfile, " offset: %lu\n", die->die_offset);
4210 for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
4212 print_spaces (outfile);
4213 fprintf (outfile, " %s: ", dwarf_attr_name (a->dw_attr));
4215 switch (AT_class (a))
4217 case dw_val_class_addr:
4218 fprintf (outfile, "address");
4220 case dw_val_class_loc:
4221 fprintf (outfile, "location descriptor");
4223 case dw_val_class_const:
4224 fprintf (outfile, "%ld", AT_int (a));
4226 case dw_val_class_unsigned_const:
4227 fprintf (outfile, "%lu", AT_unsigned (a));
4229 case dw_val_class_long_long:
4230 fprintf (outfile, "constant (%lu,%lu)",
4231 a->dw_attr_val.v.val_long_long.hi,
4232 a->dw_attr_val.v.val_long_long.low);
4234 case dw_val_class_float:
4235 fprintf (outfile, "floating-point constant");
4237 case dw_val_class_flag:
4238 fprintf (outfile, "%u", AT_flag (a));
4240 case dw_val_class_die_ref:
4241 if (AT_ref (a) != NULL)
4242 fprintf (outfile, "die -> %lu", AT_ref (a)->die_offset);
4244 fprintf (outfile, "die -> <null>");
4246 case dw_val_class_lbl_id:
4247 case dw_val_class_lbl_offset:
4248 fprintf (outfile, "label: %s", AT_lbl (a));
4250 case dw_val_class_str:
4251 if (AT_string (a) != NULL)
4252 fprintf (outfile, "\"%s\"", AT_string (a));
4254 fprintf (outfile, "<null>");
4260 fprintf (outfile, "\n");
4263 if (die->die_child != NULL)
4266 for (c = die->die_child; c != NULL; c = c->die_sib)
4267 print_die (c, outfile);
4273 /* Print the contents of the source code line number correspondence table.
4274 This routine is a debugging aid only. */
4277 print_dwarf_line_table (outfile)
4280 register unsigned i;
4281 register dw_line_info_ref line_info;
4283 fprintf (outfile, "\n\nDWARF source line information\n");
4284 for (i = 1; i < line_info_table_in_use; ++i)
4286 line_info = &line_info_table[i];
4287 fprintf (outfile, "%5d: ", i);
4288 fprintf (outfile, "%-20s", file_table[line_info->dw_file_num]);
4289 fprintf (outfile, "%6ld", line_info->dw_line_num);
4290 fprintf (outfile, "\n");
4293 fprintf (outfile, "\n\n");
4296 /* Print the information collected for a given DIE. */
4299 debug_dwarf_die (die)
4302 print_die (die, stderr);
4305 /* Print all DWARF information collected for the compilation unit.
4306 This routine is a debugging aid only. */
4312 print_die (comp_unit_die, stderr);
4313 if (! DWARF2_ASM_LINE_DEBUG_INFO)
4314 print_dwarf_line_table (stderr);
4317 /* We build up the lists of children and attributes by pushing new ones
4318 onto the beginning of the list. Reverse the lists for DIE so that
4319 they are in order of addition. */
4322 reverse_die_lists (die)
4323 register dw_die_ref die;
4325 register dw_die_ref c, cp, cn;
4326 register dw_attr_ref a, ap, an;
4328 for (a = die->die_attr, ap = 0; a; a = an)
4330 an = a->dw_attr_next;
4331 a->dw_attr_next = ap;
4336 for (c = die->die_child, cp = 0; c; c = cn)
4342 die->die_child = cp;
4345 /* Traverse the DIE, reverse its lists of attributes and children, and
4346 add a sibling attribute if it may have the effect of speeding up
4347 access to siblings. To save some space, avoid generating sibling
4348 attributes for DIE's without children. */
4351 add_sibling_attributes (die)
4352 register dw_die_ref die;
4354 register dw_die_ref c;
4356 reverse_die_lists (die);
4358 if (die != comp_unit_die && die->die_sib && die->die_child != NULL)
4359 /* Add the sibling link to the front of the attribute list. */
4360 add_AT_die_ref (die, DW_AT_sibling, die->die_sib);
4362 for (c = die->die_child; c != NULL; c = c->die_sib)
4363 add_sibling_attributes (c);
4366 /* The format of each DIE (and its attribute value pairs)
4367 is encoded in an abbreviation table. This routine builds the
4368 abbreviation table and assigns a unique abbreviation id for
4369 each abbreviation entry. The children of each die are visited
4373 build_abbrev_table (die)
4374 register dw_die_ref die;
4376 register unsigned long abbrev_id;
4377 register unsigned long n_alloc;
4378 register dw_die_ref c;
4379 register dw_attr_ref d_attr, a_attr;
4380 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
4382 register dw_die_ref abbrev = abbrev_die_table[abbrev_id];
4384 if (abbrev->die_tag == die->die_tag)
4386 if ((abbrev->die_child != NULL) == (die->die_child != NULL))
4388 a_attr = abbrev->die_attr;
4389 d_attr = die->die_attr;
4391 while (a_attr != NULL && d_attr != NULL)
4393 if ((a_attr->dw_attr != d_attr->dw_attr)
4394 || (value_format (a_attr) != value_format (d_attr)))
4397 a_attr = a_attr->dw_attr_next;
4398 d_attr = d_attr->dw_attr_next;
4401 if (a_attr == NULL && d_attr == NULL)
4407 if (abbrev_id >= abbrev_die_table_in_use)
4409 if (abbrev_die_table_in_use >= abbrev_die_table_allocated)
4411 n_alloc = abbrev_die_table_allocated + ABBREV_DIE_TABLE_INCREMENT;
4413 = (dw_die_ref *) xrealloc (abbrev_die_table,
4414 sizeof (dw_die_ref) * n_alloc);
4416 bzero ((char *) &abbrev_die_table[abbrev_die_table_allocated],
4417 (n_alloc - abbrev_die_table_allocated) * sizeof (dw_die_ref));
4418 abbrev_die_table_allocated = n_alloc;
4421 ++abbrev_die_table_in_use;
4422 abbrev_die_table[abbrev_id] = die;
4425 die->die_abbrev = abbrev_id;
4426 for (c = die->die_child; c != NULL; c = c->die_sib)
4427 build_abbrev_table (c);
4430 /* Return the size of a string, including the null byte.
4432 This used to treat backslashes as escapes, and hence they were not included
4433 in the count. However, that conflicts with what ASM_OUTPUT_ASCII does,
4434 which treats a backslash as a backslash, escaping it if necessary, and hence
4435 we must include them in the count. */
4437 static unsigned long
4438 size_of_string (str)
4439 register const char *str;
4441 return strlen (str) + 1;
4444 /* Return the size of a location descriptor. */
4446 static unsigned long
4447 size_of_loc_descr (loc)
4448 register dw_loc_descr_ref loc;
4450 register unsigned long size = 1;
4452 switch (loc->dw_loc_opc)
4474 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4477 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
4482 case DW_OP_plus_uconst:
4483 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4521 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
4524 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4527 size += size_of_sleb128 (loc->dw_loc_oprnd1.v.val_int);
4530 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4531 size += size_of_sleb128 (loc->dw_loc_oprnd2.v.val_int);
4534 size += size_of_uleb128 (loc->dw_loc_oprnd1.v.val_unsigned);
4536 case DW_OP_deref_size:
4537 case DW_OP_xderef_size:
4547 /* Return the size of a series of location descriptors. */
4549 static unsigned long
4551 register dw_loc_descr_ref loc;
4553 register unsigned long size = 0;
4555 for (; loc != NULL; loc = loc->dw_loc_next)
4556 size += size_of_loc_descr (loc);
4561 /* Return the power-of-two number of bytes necessary to represent VALUE. */
4564 constant_size (value)
4565 long unsigned value;
4572 log = floor_log2 (value);
4575 log = 1 << (floor_log2 (log) + 1);
4580 /* Return the size of a DIE, as it is represented in the
4581 .debug_info section. */
4583 static unsigned long
4585 register dw_die_ref die;
4587 register unsigned long size = 0;
4588 register dw_attr_ref a;
4590 size += size_of_uleb128 (die->die_abbrev);
4591 for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
4593 switch (AT_class (a))
4595 case dw_val_class_addr:
4598 case dw_val_class_loc:
4600 register unsigned long lsize = size_of_locs (AT_loc (a));
4603 size += constant_size (lsize);
4607 case dw_val_class_const:
4610 case dw_val_class_unsigned_const:
4611 size += constant_size (AT_unsigned (a));
4613 case dw_val_class_long_long:
4614 size += 1 + 8; /* block */
4616 case dw_val_class_float:
4617 size += 1 + a->dw_attr_val.v.val_float.length * 4; /* block */
4619 case dw_val_class_flag:
4622 case dw_val_class_die_ref:
4623 size += DWARF_OFFSET_SIZE;
4625 case dw_val_class_fde_ref:
4626 size += DWARF_OFFSET_SIZE;
4628 case dw_val_class_lbl_id:
4631 case dw_val_class_lbl_offset:
4632 size += DWARF_OFFSET_SIZE;
4634 case dw_val_class_str:
4635 size += size_of_string (AT_string (a));
4645 /* Size the debugging information associated with a given DIE.
4646 Visits the DIE's children recursively. Updates the global
4647 variable next_die_offset, on each time through. Uses the
4648 current value of next_die_offset to update the die_offset
4649 field in each DIE. */
4652 calc_die_sizes (die)
4655 register dw_die_ref c;
4656 die->die_offset = next_die_offset;
4657 next_die_offset += size_of_die (die);
4659 for (c = die->die_child; c != NULL; c = c->die_sib)
4662 if (die->die_child != NULL)
4663 /* Count the null byte used to terminate sibling lists. */
4664 next_die_offset += 1;
4667 /* Return the size of the line information prolog generated for the
4668 compilation unit. */
4670 static unsigned long
4671 size_of_line_prolog ()
4673 register unsigned long size;
4674 register unsigned long ft_index;
4676 size = DWARF_LINE_PROLOG_HEADER_SIZE;
4678 /* Count the size of the table giving number of args for each
4680 size += DWARF_LINE_OPCODE_BASE - 1;
4682 /* Include directory table is empty (at present). Count only the
4683 null byte used to terminate the table. */
4686 for (ft_index = 1; ft_index < file_table_in_use; ++ft_index)
4688 /* File name entry. */
4689 size += size_of_string (file_table[ft_index]);
4691 /* Include directory index. */
4692 size += size_of_uleb128 (0);
4694 /* Modification time. */
4695 size += size_of_uleb128 (0);
4697 /* File length in bytes. */
4698 size += size_of_uleb128 (0);
4701 /* Count the file table terminator. */
4706 /* Return the size of the .debug_pubnames table generated for the
4707 compilation unit. */
4709 static unsigned long
4712 register unsigned long size;
4713 register unsigned i;
4715 size = DWARF_PUBNAMES_HEADER_SIZE;
4716 for (i = 0; i < pubname_table_in_use; ++i)
4718 register pubname_ref p = &pubname_table[i];
4719 size += DWARF_OFFSET_SIZE + size_of_string (p->name);
4722 size += DWARF_OFFSET_SIZE;
4726 /* Return the size of the information in the .debug_aranges section. */
4728 static unsigned long
4731 register unsigned long size;
4733 size = DWARF_ARANGES_HEADER_SIZE;
4735 /* Count the address/length pair for this compilation unit. */
4736 size += 2 * PTR_SIZE;
4737 size += 2 * PTR_SIZE * arange_table_in_use;
4739 /* Count the two zero words used to terminated the address range table. */
4740 size += 2 * PTR_SIZE;
4744 /* Select the encoding of an attribute value. */
4746 static enum dwarf_form
4750 switch (a->dw_attr_val.val_class)
4752 case dw_val_class_addr:
4753 return DW_FORM_addr;
4754 case dw_val_class_loc:
4755 switch (constant_size (size_of_locs (AT_loc (a))))
4758 return DW_FORM_block1;
4760 return DW_FORM_block2;
4764 case dw_val_class_const:
4765 return DW_FORM_data4;
4766 case dw_val_class_unsigned_const:
4767 switch (constant_size (AT_unsigned (a)))
4770 return DW_FORM_data1;
4772 return DW_FORM_data2;
4774 return DW_FORM_data4;
4776 return DW_FORM_data8;
4780 case dw_val_class_long_long:
4781 return DW_FORM_block1;
4782 case dw_val_class_float:
4783 return DW_FORM_block1;
4784 case dw_val_class_flag:
4785 return DW_FORM_flag;
4786 case dw_val_class_die_ref:
4788 case dw_val_class_fde_ref:
4789 return DW_FORM_data;
4790 case dw_val_class_lbl_id:
4791 return DW_FORM_addr;
4792 case dw_val_class_lbl_offset:
4793 return DW_FORM_data;
4794 case dw_val_class_str:
4795 return DW_FORM_string;
4801 /* Output the encoding of an attribute value. */
4804 output_value_format (a)
4807 enum dwarf_form form = value_format (a);
4809 output_uleb128 (form);
4811 fprintf (asm_out_file, " (%s)", dwarf_form_name (form));
4813 fputc ('\n', asm_out_file);
4816 /* Output the .debug_abbrev section which defines the DIE abbreviation
4820 output_abbrev_section ()
4822 unsigned long abbrev_id;
4825 for (abbrev_id = 1; abbrev_id < abbrev_die_table_in_use; ++abbrev_id)
4827 register dw_die_ref abbrev = abbrev_die_table[abbrev_id];
4829 output_uleb128 (abbrev_id);
4831 fprintf (asm_out_file, " (abbrev code)");
4833 fputc ('\n', asm_out_file);
4834 output_uleb128 (abbrev->die_tag);
4836 fprintf (asm_out_file, " (TAG: %s)",
4837 dwarf_tag_name (abbrev->die_tag));
4839 fputc ('\n', asm_out_file);
4840 fprintf (asm_out_file, "\t%s\t0x%x", ASM_BYTE_OP,
4841 abbrev->die_child != NULL ? DW_children_yes : DW_children_no);
4844 fprintf (asm_out_file, "\t%s %s",
4846 (abbrev->die_child != NULL
4847 ? "DW_children_yes" : "DW_children_no"));
4849 fputc ('\n', asm_out_file);
4851 for (a_attr = abbrev->die_attr; a_attr != NULL;
4852 a_attr = a_attr->dw_attr_next)
4854 output_uleb128 (a_attr->dw_attr);
4856 fprintf (asm_out_file, " (%s)",
4857 dwarf_attr_name (a_attr->dw_attr));
4859 fputc ('\n', asm_out_file);
4860 output_value_format (a_attr);
4863 fprintf (asm_out_file, "\t%s\t0,0\n", ASM_BYTE_OP);
4866 /* Terminate the table. */
4867 fprintf (asm_out_file, "\t%s\t0\n", ASM_BYTE_OP);
4870 /* Output location description stack opcode's operands (if any). */
4873 output_loc_operands (loc)
4874 register dw_loc_descr_ref loc;
4876 register dw_val_ref val1 = &loc->dw_loc_oprnd1;
4877 register dw_val_ref val2 = &loc->dw_loc_oprnd2;
4879 switch (loc->dw_loc_opc)
4882 ASM_OUTPUT_DWARF_ADDR_CONST (asm_out_file, val1->v.val_addr);
4883 fputc ('\n', asm_out_file);
4887 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, val1->v.val_flag);
4888 fputc ('\n', asm_out_file);
4892 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, val1->v.val_int);
4893 fputc ('\n', asm_out_file);
4897 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, val1->v.val_int);
4898 fputc ('\n', asm_out_file);
4903 fputc ('\n', asm_out_file);
4906 output_uleb128 (val1->v.val_unsigned);
4907 fputc ('\n', asm_out_file);
4910 output_sleb128 (val1->v.val_int);
4911 fputc ('\n', asm_out_file);
4914 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, val1->v.val_int);
4915 fputc ('\n', asm_out_file);
4917 case DW_OP_plus_uconst:
4918 output_uleb128 (val1->v.val_unsigned);
4919 fputc ('\n', asm_out_file);
4923 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, val1->v.val_int);
4924 fputc ('\n', asm_out_file);
4958 output_sleb128 (val1->v.val_int);
4959 fputc ('\n', asm_out_file);
4962 output_uleb128 (val1->v.val_unsigned);
4963 fputc ('\n', asm_out_file);
4966 output_sleb128 (val1->v.val_int);
4967 fputc ('\n', asm_out_file);
4970 output_uleb128 (val1->v.val_unsigned);
4971 fputc ('\n', asm_out_file);
4972 output_sleb128 (val2->v.val_int);
4973 fputc ('\n', asm_out_file);
4976 output_uleb128 (val1->v.val_unsigned);
4977 fputc ('\n', asm_out_file);
4979 case DW_OP_deref_size:
4980 case DW_OP_xderef_size:
4981 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, val1->v.val_flag);
4982 fputc ('\n', asm_out_file);
4989 /* Output the DIE and its attributes. Called recursively to generate
4990 the definitions of each child DIE. */
4994 register dw_die_ref die;
4996 register dw_attr_ref a;
4997 register dw_die_ref c;
4998 register unsigned long size;
4999 register dw_loc_descr_ref loc;
5001 output_uleb128 (die->die_abbrev);
5003 fprintf (asm_out_file, " (DIE (0x%lx) %s)",
5004 die->die_offset, dwarf_tag_name (die->die_tag));
5006 fputc ('\n', asm_out_file);
5008 for (a = die->die_attr; a != NULL; a = a->dw_attr_next)
5010 switch (AT_class (a))
5012 case dw_val_class_addr:
5013 ASM_OUTPUT_DWARF_ADDR_CONST (asm_out_file, AT_addr (a));
5016 case dw_val_class_loc:
5017 size = size_of_locs (AT_loc (a));
5019 /* Output the block length for this list of location operations. */
5020 switch (constant_size (size))
5023 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, size);
5026 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, size);
5033 fprintf (asm_out_file, "\t%s %s",
5034 ASM_COMMENT_START, dwarf_attr_name (a->dw_attr));
5036 fputc ('\n', asm_out_file);
5037 for (loc = AT_loc (a); loc != NULL; loc = loc->dw_loc_next)
5039 /* Output the opcode. */
5040 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, loc->dw_loc_opc);
5042 fprintf (asm_out_file, "\t%s %s", ASM_COMMENT_START,
5043 dwarf_stack_op_name (loc->dw_loc_opc));
5045 fputc ('\n', asm_out_file);
5047 /* Output the operand(s) (if any). */
5048 output_loc_operands (loc);
5052 case dw_val_class_const:
5053 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, AT_int (a));
5056 case dw_val_class_unsigned_const:
5057 switch (constant_size (AT_unsigned (a)))
5060 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, AT_unsigned (a));
5063 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, AT_unsigned (a));
5066 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, AT_unsigned (a));
5069 ASM_OUTPUT_DWARF_DATA8 (asm_out_file,
5070 a->dw_attr_val.v.val_long_long.hi,
5071 a->dw_attr_val.v.val_long_long.low);
5078 case dw_val_class_long_long:
5079 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 8);
5081 fprintf (asm_out_file, "\t%s %s",
5082 ASM_COMMENT_START, dwarf_attr_name (a->dw_attr));
5084 fputc ('\n', asm_out_file);
5085 ASM_OUTPUT_DWARF_DATA8 (asm_out_file,
5086 a->dw_attr_val.v.val_long_long.hi,
5087 a->dw_attr_val.v.val_long_long.low);
5090 fprintf (asm_out_file,
5091 "\t%s long long constant", ASM_COMMENT_START);
5093 fputc ('\n', asm_out_file);
5096 case dw_val_class_float:
5098 register unsigned int i;
5099 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
5100 a->dw_attr_val.v.val_float.length * 4);
5102 fprintf (asm_out_file, "\t%s %s",
5103 ASM_COMMENT_START, dwarf_attr_name (a->dw_attr));
5105 fputc ('\n', asm_out_file);
5106 for (i = 0; i < a->dw_attr_val.v.val_float.length; ++i)
5108 ASM_OUTPUT_DWARF_DATA4 (asm_out_file,
5109 a->dw_attr_val.v.val_float.array[i]);
5111 fprintf (asm_out_file, "\t%s fp constant word %u",
5112 ASM_COMMENT_START, i);
5114 fputc ('\n', asm_out_file);
5119 case dw_val_class_flag:
5120 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, AT_flag (a));
5123 case dw_val_class_die_ref:
5124 ASM_OUTPUT_DWARF_DATA (asm_out_file, AT_ref (a)->die_offset);
5127 case dw_val_class_fde_ref:
5130 ASM_GENERATE_INTERNAL_LABEL
5131 (l1, FDE_AFTER_SIZE_LABEL, a->dw_attr_val.v.val_fde_index * 2);
5132 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, l1);
5133 fprintf (asm_out_file, " - %d", DWARF_OFFSET_SIZE);
5137 case dw_val_class_lbl_id:
5138 ASM_OUTPUT_DWARF_ADDR (asm_out_file, AT_lbl (a));
5141 case dw_val_class_lbl_offset:
5142 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, AT_lbl (a));
5145 case dw_val_class_str:
5147 ASM_OUTPUT_DWARF_STRING (asm_out_file, AT_string (a));
5149 ASM_OUTPUT_ASCII (asm_out_file, AT_string (a),
5150 (int) strlen (AT_string (a)) + 1);
5157 if (AT_class (a) != dw_val_class_loc
5158 && AT_class (a) != dw_val_class_long_long
5159 && AT_class (a) != dw_val_class_float)
5162 fprintf (asm_out_file, "\t%s %s",
5163 ASM_COMMENT_START, dwarf_attr_name (a->dw_attr));
5165 fputc ('\n', asm_out_file);
5169 for (c = die->die_child; c != NULL; c = c->die_sib)
5172 if (die->die_child != NULL)
5174 /* Add null byte to terminate sibling list. */
5175 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5177 fprintf (asm_out_file, "\t%s end of children of DIE 0x%lx",
5178 ASM_COMMENT_START, die->die_offset);
5180 fputc ('\n', asm_out_file);
5184 /* Output the compilation unit that appears at the beginning of the
5185 .debug_info section, and precedes the DIE descriptions. */
5188 output_compilation_unit_header ()
5190 ASM_OUTPUT_DWARF_DATA (asm_out_file, next_die_offset - DWARF_OFFSET_SIZE);
5192 fprintf (asm_out_file, "\t%s Length of Compilation Unit Info.",
5195 fputc ('\n', asm_out_file);
5196 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, DWARF_VERSION);
5198 fprintf (asm_out_file, "\t%s DWARF version number", ASM_COMMENT_START);
5200 fputc ('\n', asm_out_file);
5201 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, abbrev_section_label);
5203 fprintf (asm_out_file, "\t%s Offset Into Abbrev. Section",
5206 fputc ('\n', asm_out_file);
5207 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, PTR_SIZE);
5209 fprintf (asm_out_file, "\t%s Pointer Size (in bytes)", ASM_COMMENT_START);
5211 fputc ('\n', asm_out_file);
5214 /* The DWARF2 pubname for a nested thingy looks like "A::f". The output
5215 of decl_printable_name for C++ looks like "A::f(int)". Let's drop the
5216 argument list, and maybe the scope. */
5219 dwarf2_name (decl, scope)
5223 return (*decl_printable_name) (decl, scope ? 1 : 0);
5226 /* Add a new entry to .debug_pubnames if appropriate. */
5229 add_pubname (decl, die)
5235 if (! TREE_PUBLIC (decl))
5238 if (pubname_table_in_use == pubname_table_allocated)
5240 pubname_table_allocated += PUBNAME_TABLE_INCREMENT;
5241 pubname_table = (pubname_ref) xrealloc
5242 (pubname_table, pubname_table_allocated * sizeof (pubname_entry));
5245 p = &pubname_table[pubname_table_in_use++];
5248 p->name = xstrdup (dwarf2_name (decl, 1));
5251 /* Output the public names table used to speed up access to externally
5252 visible names. For now, only generate entries for externally
5253 visible procedures. */
5258 register unsigned i;
5259 register unsigned long pubnames_length = size_of_pubnames ();
5261 ASM_OUTPUT_DWARF_DATA (asm_out_file, pubnames_length);
5264 fprintf (asm_out_file, "\t%s Length of Public Names Info.",
5267 fputc ('\n', asm_out_file);
5268 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, DWARF_VERSION);
5271 fprintf (asm_out_file, "\t%s DWARF Version", ASM_COMMENT_START);
5273 fputc ('\n', asm_out_file);
5274 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, debug_info_section_label);
5276 fprintf (asm_out_file, "\t%s Offset of Compilation Unit Info.",
5279 fputc ('\n', asm_out_file);
5280 ASM_OUTPUT_DWARF_DATA (asm_out_file, next_die_offset);
5282 fprintf (asm_out_file, "\t%s Compilation Unit Length", ASM_COMMENT_START);
5284 fputc ('\n', asm_out_file);
5285 for (i = 0; i < pubname_table_in_use; ++i)
5287 register pubname_ref pub = &pubname_table[i];
5289 ASM_OUTPUT_DWARF_DATA (asm_out_file, pub->die->die_offset);
5291 fprintf (asm_out_file, "\t%s DIE offset", ASM_COMMENT_START);
5293 fputc ('\n', asm_out_file);
5297 ASM_OUTPUT_DWARF_STRING (asm_out_file, pub->name);
5298 fprintf (asm_out_file, "%s external name", ASM_COMMENT_START);
5302 ASM_OUTPUT_ASCII (asm_out_file, pub->name,
5303 (int) strlen (pub->name) + 1);
5306 fputc ('\n', asm_out_file);
5309 ASM_OUTPUT_DWARF_DATA (asm_out_file, 0);
5310 fputc ('\n', asm_out_file);
5313 /* Add a new entry to .debug_aranges if appropriate. */
5316 add_arange (decl, die)
5320 if (! DECL_SECTION_NAME (decl))
5323 if (arange_table_in_use == arange_table_allocated)
5325 arange_table_allocated += ARANGE_TABLE_INCREMENT;
5327 = (arange_ref) xrealloc (arange_table,
5328 arange_table_allocated * sizeof (dw_die_ref));
5331 arange_table[arange_table_in_use++] = die;
5334 /* Output the information that goes into the .debug_aranges table.
5335 Namely, define the beginning and ending address range of the
5336 text section generated for this compilation unit. */
5341 register unsigned i;
5342 register unsigned long aranges_length = size_of_aranges ();
5344 ASM_OUTPUT_DWARF_DATA (asm_out_file, aranges_length);
5346 fprintf (asm_out_file, "\t%s Length of Address Ranges Info.",
5349 fputc ('\n', asm_out_file);
5350 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, DWARF_VERSION);
5352 fprintf (asm_out_file, "\t%s DWARF Version", ASM_COMMENT_START);
5354 fputc ('\n', asm_out_file);
5355 ASM_OUTPUT_DWARF_OFFSET (asm_out_file, debug_info_section_label);
5357 fprintf (asm_out_file, "\t%s Offset of Compilation Unit Info.",
5360 fputc ('\n', asm_out_file);
5361 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, PTR_SIZE);
5363 fprintf (asm_out_file, "\t%s Size of Address", ASM_COMMENT_START);
5365 fputc ('\n', asm_out_file);
5366 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5368 fprintf (asm_out_file, "\t%s Size of Segment Descriptor",
5371 fputc ('\n', asm_out_file);
5372 /* We need to align to twice the pointer size here.
5373 If DWARF_OFFSET_SIZE == 4, then we have emitted 12 bytes, and need 4
5374 bytes of padding to align for either 4 or 8 byte pointers. */
5375 ASM_OUTPUT_DWARF_DATA4 (asm_out_file, 0);
5376 /* If DWARF_OFFSET_SIZE == 8, then we have emitted 20 bytes, and need 12
5377 bytes of padding to align for 8 byte pointers. We have already emitted
5378 4 bytes of padding, so emit 8 more here. */
5379 if (DWARF_OFFSET_SIZE == 8)
5380 fprintf (asm_out_file, ",0,0");
5383 fprintf (asm_out_file, "\t%s Pad to %d byte boundary",
5384 ASM_COMMENT_START, 2 * PTR_SIZE);
5386 fputc ('\n', asm_out_file);
5387 ASM_OUTPUT_DWARF_ADDR (asm_out_file, text_section_label);
5389 fprintf (asm_out_file, "\t%s Address", ASM_COMMENT_START);
5391 fputc ('\n', asm_out_file);
5392 ASM_OUTPUT_DWARF_ADDR_DELTA (asm_out_file, text_end_label,
5393 text_section_label);
5395 fprintf (asm_out_file, "%s Length", ASM_COMMENT_START);
5397 fputc ('\n', asm_out_file);
5398 for (i = 0; i < arange_table_in_use; ++i)
5400 dw_die_ref die = arange_table[i];
5402 if (die->die_tag == DW_TAG_subprogram)
5403 ASM_OUTPUT_DWARF_ADDR (asm_out_file, get_AT_low_pc (die));
5406 /* A static variable; extract the symbol from DW_AT_location.
5407 Note that this code isn't currently hit, as we only emit
5408 aranges for functions (jason 9/23/99). */
5410 dw_attr_ref a = get_AT (die, DW_AT_location);
5411 dw_loc_descr_ref loc;
5412 if (! a || AT_class (a) != dw_val_class_loc)
5416 if (loc->dw_loc_opc != DW_OP_addr)
5419 ASM_OUTPUT_DWARF_ADDR_CONST (asm_out_file,
5420 loc->dw_loc_oprnd1.v.val_addr);
5424 fprintf (asm_out_file, "\t%s Address", ASM_COMMENT_START);
5426 fputc ('\n', asm_out_file);
5427 if (die->die_tag == DW_TAG_subprogram)
5428 ASM_OUTPUT_DWARF_ADDR_DELTA (asm_out_file, get_AT_hi_pc (die),
5429 get_AT_low_pc (die));
5431 ASM_OUTPUT_DWARF_ADDR_DATA (asm_out_file,
5432 get_AT_unsigned (die, DW_AT_byte_size));
5435 fprintf (asm_out_file, "%s Length", ASM_COMMENT_START);
5437 fputc ('\n', asm_out_file);
5440 /* Output the terminator words. */
5441 ASM_OUTPUT_DWARF_ADDR_DATA (asm_out_file, 0);
5442 fputc ('\n', asm_out_file);
5443 ASM_OUTPUT_DWARF_ADDR_DATA (asm_out_file, 0);
5444 fputc ('\n', asm_out_file);
5447 /* Output the source line number correspondence information. This
5448 information goes into the .debug_line section. */
5453 char line_label[MAX_ARTIFICIAL_LABEL_BYTES];
5454 char prev_line_label[MAX_ARTIFICIAL_LABEL_BYTES];
5455 register unsigned opc;
5456 register unsigned n_op_args;
5457 register unsigned long ft_index;
5458 register unsigned long lt_index;
5459 register unsigned long current_line;
5460 register long line_offset;
5461 register long line_delta;
5462 register unsigned long current_file;
5463 register unsigned long function;
5465 ASM_OUTPUT_DWARF_DELTA (asm_out_file, ".LTEND", ".LTSTART");
5467 fprintf (asm_out_file, "\t%s Length of Source Line Info.",
5470 fputc ('\n', asm_out_file);
5471 ASM_OUTPUT_LABEL (asm_out_file, ".LTSTART");
5472 ASM_OUTPUT_DWARF_DATA2 (asm_out_file, DWARF_VERSION);
5474 fprintf (asm_out_file, "\t%s DWARF Version", ASM_COMMENT_START);
5476 fputc ('\n', asm_out_file);
5477 ASM_OUTPUT_DWARF_DATA (asm_out_file, size_of_line_prolog ());
5479 fprintf (asm_out_file, "\t%s Prolog Length", ASM_COMMENT_START);
5481 fputc ('\n', asm_out_file);
5482 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DWARF_LINE_MIN_INSTR_LENGTH);
5484 fprintf (asm_out_file, "\t%s Minimum Instruction Length",
5487 fputc ('\n', asm_out_file);
5488 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DWARF_LINE_DEFAULT_IS_STMT_START);
5490 fprintf (asm_out_file, "\t%s Default is_stmt_start flag",
5493 fputc ('\n', asm_out_file);
5494 fprintf (asm_out_file, "\t%s\t%d", ASM_BYTE_OP, DWARF_LINE_BASE);
5496 fprintf (asm_out_file, "\t%s Line Base Value (Special Opcodes)",
5499 fputc ('\n', asm_out_file);
5500 fprintf (asm_out_file, "\t%s\t%u", ASM_BYTE_OP, DWARF_LINE_RANGE);
5502 fprintf (asm_out_file, "\t%s Line Range Value (Special Opcodes)",
5505 fputc ('\n', asm_out_file);
5506 fprintf (asm_out_file, "\t%s\t%u", ASM_BYTE_OP, DWARF_LINE_OPCODE_BASE);
5508 fprintf (asm_out_file, "\t%s Special Opcode Base", ASM_COMMENT_START);
5510 fputc ('\n', asm_out_file);
5511 for (opc = 1; opc < DWARF_LINE_OPCODE_BASE; ++opc)
5515 case DW_LNS_advance_pc:
5516 case DW_LNS_advance_line:
5517 case DW_LNS_set_file:
5518 case DW_LNS_set_column:
5519 case DW_LNS_fixed_advance_pc:
5526 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, n_op_args);
5528 fprintf (asm_out_file, "\t%s opcode: 0x%x has %d args",
5529 ASM_COMMENT_START, opc, n_op_args);
5530 fputc ('\n', asm_out_file);
5534 fprintf (asm_out_file, "%s Include Directory Table\n", ASM_COMMENT_START);
5536 /* Include directory table is empty, at present */
5537 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5538 fputc ('\n', asm_out_file);
5540 fprintf (asm_out_file, "%s File Name Table\n", ASM_COMMENT_START);
5542 for (ft_index = 1; ft_index < file_table_in_use; ++ft_index)
5546 ASM_OUTPUT_DWARF_STRING (asm_out_file, file_table[ft_index]);
5547 fprintf (asm_out_file, "%s File Entry: 0x%lx",
5548 ASM_COMMENT_START, ft_index);
5552 ASM_OUTPUT_ASCII (asm_out_file,
5553 file_table[ft_index],
5554 (int) strlen (file_table[ft_index]) + 1);
5557 fputc ('\n', asm_out_file);
5559 /* Include directory index */
5561 fputc ('\n', asm_out_file);
5563 /* Modification time */
5565 fputc ('\n', asm_out_file);
5567 /* File length in bytes */
5569 fputc ('\n', asm_out_file);
5572 /* Terminate the file name table */
5573 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5574 fputc ('\n', asm_out_file);
5576 /* We used to set the address register to the first location in the text
5577 section here, but that didn't accomplish anything since we already
5578 have a line note for the opening brace of the first function. */
5580 /* Generate the line number to PC correspondence table, encoded as
5581 a series of state machine operations. */
5584 strcpy (prev_line_label, text_section_label);
5585 for (lt_index = 1; lt_index < line_info_table_in_use; ++lt_index)
5587 register dw_line_info_ref line_info = &line_info_table[lt_index];
5590 /* Disable this optimization for now; GDB wants to see two line notes
5591 at the beginning of a function so it can find the end of the
5594 /* Don't emit anything for redundant notes. Just updating the
5595 address doesn't accomplish anything, because we already assume
5596 that anything after the last address is this line. */
5597 if (line_info->dw_line_num == current_line
5598 && line_info->dw_file_num == current_file)
5602 /* Emit debug info for the address of the current line, choosing
5603 the encoding that uses the least amount of space. */
5604 /* ??? Unfortunately, we have little choice here currently, and must
5605 always use the most general form. Gcc does not know the address
5606 delta itself, so we can't use DW_LNS_advance_pc. There are no known
5607 dwarf2 aware assemblers at this time, so we can't use any special
5608 pseudo ops that would allow the assembler to optimally encode this for
5609 us. Many ports do have length attributes which will give an upper
5610 bound on the address range. We could perhaps use length attributes
5611 to determine when it is safe to use DW_LNS_fixed_advance_pc. */
5612 ASM_GENERATE_INTERNAL_LABEL (line_label, LINE_CODE_LABEL, lt_index);
5615 /* This can handle deltas up to 0xffff. This takes 3 bytes. */
5616 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc);
5618 fprintf (asm_out_file, "\t%s DW_LNS_fixed_advance_pc",
5621 fputc ('\n', asm_out_file);
5622 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, line_label, prev_line_label);
5623 fputc ('\n', asm_out_file);
5627 /* This can handle any delta. This takes 4+PTR_SIZE bytes. */
5628 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5630 fprintf (asm_out_file, "\t%s DW_LNE_set_address",
5632 fputc ('\n', asm_out_file);
5633 output_uleb128 (1 + PTR_SIZE);
5634 fputc ('\n', asm_out_file);
5635 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address);
5636 fputc ('\n', asm_out_file);
5637 ASM_OUTPUT_DWARF_ADDR (asm_out_file, line_label);
5638 fputc ('\n', asm_out_file);
5640 strcpy (prev_line_label, line_label);
5642 /* Emit debug info for the source file of the current line, if
5643 different from the previous line. */
5644 if (line_info->dw_file_num != current_file)
5646 current_file = line_info->dw_file_num;
5647 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_set_file);
5649 fprintf (asm_out_file, "\t%s DW_LNS_set_file", ASM_COMMENT_START);
5651 fputc ('\n', asm_out_file);
5652 output_uleb128 (current_file);
5654 fprintf (asm_out_file, " (\"%s\")", file_table[current_file]);
5656 fputc ('\n', asm_out_file);
5659 /* Emit debug info for the current line number, choosing the encoding
5660 that uses the least amount of space. */
5661 if (line_info->dw_line_num != current_line)
5663 line_offset = line_info->dw_line_num - current_line;
5664 line_delta = line_offset - DWARF_LINE_BASE;
5665 current_line = line_info->dw_line_num;
5666 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
5668 /* This can handle deltas from -10 to 234, using the current
5669 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE. This
5671 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
5672 DWARF_LINE_OPCODE_BASE + line_delta);
5674 fprintf (asm_out_file,
5675 "\t%s line %ld", ASM_COMMENT_START, current_line);
5677 fputc ('\n', asm_out_file);
5681 /* This can handle any delta. This takes at least 4 bytes,
5682 depending on the value being encoded. */
5683 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_advance_line);
5685 fprintf (asm_out_file, "\t%s advance to line %ld",
5686 ASM_COMMENT_START, current_line);
5688 fputc ('\n', asm_out_file);
5689 output_sleb128 (line_offset);
5690 fputc ('\n', asm_out_file);
5691 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_copy);
5693 fprintf (asm_out_file, "\t%s DW_LNS_copy", ASM_COMMENT_START);
5694 fputc ('\n', asm_out_file);
5699 /* We still need to start a new row, so output a copy insn. */
5700 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_copy);
5702 fprintf (asm_out_file, "\t%s DW_LNS_copy", ASM_COMMENT_START);
5703 fputc ('\n', asm_out_file);
5707 /* Emit debug info for the address of the end of the function. */
5710 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc);
5712 fprintf (asm_out_file, "\t%s DW_LNS_fixed_advance_pc",
5715 fputc ('\n', asm_out_file);
5716 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, text_end_label, prev_line_label);
5717 fputc ('\n', asm_out_file);
5721 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5723 fprintf (asm_out_file, "\t%s DW_LNE_set_address", ASM_COMMENT_START);
5724 fputc ('\n', asm_out_file);
5725 output_uleb128 (1 + PTR_SIZE);
5726 fputc ('\n', asm_out_file);
5727 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address);
5728 fputc ('\n', asm_out_file);
5729 ASM_OUTPUT_DWARF_ADDR (asm_out_file, text_end_label);
5730 fputc ('\n', asm_out_file);
5733 /* Output the marker for the end of the line number info. */
5734 ASM_OUTPUT_LABEL (asm_out_file, ".LTEND");
5735 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5737 fprintf (asm_out_file, "\t%s DW_LNE_end_sequence", ASM_COMMENT_START);
5739 fputc ('\n', asm_out_file);
5741 fputc ('\n', asm_out_file);
5742 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_end_sequence);
5743 fputc ('\n', asm_out_file);
5748 for (lt_index = 0; lt_index < separate_line_info_table_in_use; )
5750 register dw_separate_line_info_ref line_info
5751 = &separate_line_info_table[lt_index];
5754 /* Don't emit anything for redundant notes. */
5755 if (line_info->dw_line_num == current_line
5756 && line_info->dw_file_num == current_file
5757 && line_info->function == function)
5761 /* Emit debug info for the address of the current line. If this is
5762 a new function, or the first line of a function, then we need
5763 to handle it differently. */
5764 ASM_GENERATE_INTERNAL_LABEL (line_label, SEPARATE_LINE_CODE_LABEL,
5766 if (function != line_info->function)
5768 function = line_info->function;
5770 /* Set the address register to the first line in the function */
5771 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5773 fprintf (asm_out_file, "\t%s DW_LNE_set_address",
5776 fputc ('\n', asm_out_file);
5777 output_uleb128 (1 + PTR_SIZE);
5778 fputc ('\n', asm_out_file);
5779 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address);
5780 fputc ('\n', asm_out_file);
5781 ASM_OUTPUT_DWARF_ADDR (asm_out_file, line_label);
5782 fputc ('\n', asm_out_file);
5786 /* ??? See the DW_LNS_advance_pc comment above. */
5789 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc);
5791 fprintf (asm_out_file, "\t%s DW_LNS_fixed_advance_pc",
5794 fputc ('\n', asm_out_file);
5795 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, line_label,
5797 fputc ('\n', asm_out_file);
5801 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5803 fprintf (asm_out_file, "\t%s DW_LNE_set_address",
5805 fputc ('\n', asm_out_file);
5806 output_uleb128 (1 + PTR_SIZE);
5807 fputc ('\n', asm_out_file);
5808 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address);
5809 fputc ('\n', asm_out_file);
5810 ASM_OUTPUT_DWARF_ADDR (asm_out_file, line_label);
5811 fputc ('\n', asm_out_file);
5814 strcpy (prev_line_label, line_label);
5816 /* Emit debug info for the source file of the current line, if
5817 different from the previous line. */
5818 if (line_info->dw_file_num != current_file)
5820 current_file = line_info->dw_file_num;
5821 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_set_file);
5823 fprintf (asm_out_file, "\t%s DW_LNS_set_file", ASM_COMMENT_START);
5825 fputc ('\n', asm_out_file);
5826 output_uleb128 (current_file);
5828 fprintf (asm_out_file, " (\"%s\")", file_table[current_file]);
5830 fputc ('\n', asm_out_file);
5833 /* Emit debug info for the current line number, choosing the encoding
5834 that uses the least amount of space. */
5835 if (line_info->dw_line_num != current_line)
5837 line_offset = line_info->dw_line_num - current_line;
5838 line_delta = line_offset - DWARF_LINE_BASE;
5839 current_line = line_info->dw_line_num;
5840 if (line_delta >= 0 && line_delta < (DWARF_LINE_RANGE - 1))
5842 ASM_OUTPUT_DWARF_DATA1 (asm_out_file,
5843 DWARF_LINE_OPCODE_BASE + line_delta);
5845 fprintf (asm_out_file,
5846 "\t%s line %ld", ASM_COMMENT_START, current_line);
5848 fputc ('\n', asm_out_file);
5852 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_advance_line);
5854 fprintf (asm_out_file, "\t%s advance to line %ld",
5855 ASM_COMMENT_START, current_line);
5857 fputc ('\n', asm_out_file);
5858 output_sleb128 (line_offset);
5859 fputc ('\n', asm_out_file);
5860 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_copy);
5862 fprintf (asm_out_file, "\t%s DW_LNS_copy", ASM_COMMENT_START);
5863 fputc ('\n', asm_out_file);
5868 /* We still need to start a new row, so output a copy insn. */
5869 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_copy);
5871 fprintf (asm_out_file, "\t%s DW_LNS_copy", ASM_COMMENT_START);
5872 fputc ('\n', asm_out_file);
5880 /* If we're done with a function, end its sequence. */
5881 if (lt_index == separate_line_info_table_in_use
5882 || separate_line_info_table[lt_index].function != function)
5887 /* Emit debug info for the address of the end of the function. */
5888 ASM_GENERATE_INTERNAL_LABEL (line_label, FUNC_END_LABEL, function);
5891 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNS_fixed_advance_pc);
5893 fprintf (asm_out_file, "\t%s DW_LNS_fixed_advance_pc",
5896 fputc ('\n', asm_out_file);
5897 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file, line_label,
5899 fputc ('\n', asm_out_file);
5903 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5905 fprintf (asm_out_file, "\t%s DW_LNE_set_address",
5907 fputc ('\n', asm_out_file);
5908 output_uleb128 (1 + PTR_SIZE);
5909 fputc ('\n', asm_out_file);
5910 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_set_address);
5911 fputc ('\n', asm_out_file);
5912 ASM_OUTPUT_DWARF_ADDR (asm_out_file, line_label);
5913 fputc ('\n', asm_out_file);
5916 /* Output the marker for the end of this sequence. */
5917 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, 0);
5919 fprintf (asm_out_file, "\t%s DW_LNE_end_sequence",
5922 fputc ('\n', asm_out_file);
5924 fputc ('\n', asm_out_file);
5925 ASM_OUTPUT_DWARF_DATA1 (asm_out_file, DW_LNE_end_sequence);
5926 fputc ('\n', asm_out_file);
5931 /* Given a pointer to a BLOCK node return non-zero if (and only if) the node
5932 in question represents the outermost pair of curly braces (i.e. the "body
5933 block") of a function or method.
5935 For any BLOCK node representing a "body block" of a function or method, the
5936 BLOCK_SUPERCONTEXT of the node will point to another BLOCK node which
5937 represents the outermost (function) scope for the function or method (i.e.
5938 the one which includes the formal parameters). The BLOCK_SUPERCONTEXT of
5939 *that* node in turn will point to the relevant FUNCTION_DECL node. */
5942 is_body_block (stmt)
5945 if (TREE_CODE (stmt) == BLOCK)
5947 register tree parent = BLOCK_SUPERCONTEXT (stmt);
5949 if (TREE_CODE (parent) == BLOCK)
5951 register tree grandparent = BLOCK_SUPERCONTEXT (parent);
5953 if (TREE_CODE (grandparent) == FUNCTION_DECL)
5961 /* Given a pointer to a tree node for some base type, return a pointer to
5962 a DIE that describes the given type.
5964 This routine must only be called for GCC type nodes that correspond to
5965 Dwarf base (fundamental) types. */
5968 base_type_die (type)
5971 register dw_die_ref base_type_result;
5972 register const char *type_name;
5973 register enum dwarf_type encoding;
5974 register tree name = TYPE_NAME (type);
5976 if (TREE_CODE (type) == ERROR_MARK
5977 || TREE_CODE (type) == VOID_TYPE)
5982 if (TREE_CODE (name) == TYPE_DECL)
5983 name = DECL_NAME (name);
5985 type_name = IDENTIFIER_POINTER (name);
5988 type_name = "__unknown__";
5990 switch (TREE_CODE (type))
5993 /* Carefully distinguish the C character types, without messing
5994 up if the language is not C. Note that we check only for the names
5995 that contain spaces; other names might occur by coincidence in other
5997 if (! (TYPE_PRECISION (type) == CHAR_TYPE_SIZE
5998 && (type == char_type_node
5999 || ! strcmp (type_name, "signed char")
6000 || ! strcmp (type_name, "unsigned char"))))
6002 if (TREE_UNSIGNED (type))
6003 encoding = DW_ATE_unsigned;
6005 encoding = DW_ATE_signed;
6008 /* else fall through */
6011 /* GNU Pascal/Ada CHAR type. Not used in C. */
6012 if (TREE_UNSIGNED (type))
6013 encoding = DW_ATE_unsigned_char;
6015 encoding = DW_ATE_signed_char;
6019 encoding = DW_ATE_float;
6022 /* Dwarf2 doesn't know anything about complex ints, so use
6023 a user defined type for it. */
6025 if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
6026 encoding = DW_ATE_complex_float;
6028 encoding = DW_ATE_lo_user;
6032 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */
6033 encoding = DW_ATE_boolean;
6037 abort (); /* No other TREE_CODEs are Dwarf fundamental types. */
6040 base_type_result = new_die (DW_TAG_base_type, comp_unit_die);
6041 if (demangle_name_func)
6042 type_name = (*demangle_name_func) (type_name);
6044 add_AT_string (base_type_result, DW_AT_name, type_name);
6045 add_AT_unsigned (base_type_result, DW_AT_byte_size,
6046 int_size_in_bytes (type));
6047 add_AT_unsigned (base_type_result, DW_AT_encoding, encoding);
6049 return base_type_result;
6052 /* Given a pointer to an arbitrary ..._TYPE tree node, return a pointer to
6053 the Dwarf "root" type for the given input type. The Dwarf "root" type of
6054 a given type is generally the same as the given type, except that if the
6055 given type is a pointer or reference type, then the root type of the given
6056 type is the root type of the "basis" type for the pointer or reference
6057 type. (This definition of the "root" type is recursive.) Also, the root
6058 type of a `const' qualified type or a `volatile' qualified type is the
6059 root type of the given type without the qualifiers. */
6065 if (TREE_CODE (type) == ERROR_MARK)
6066 return error_mark_node;
6068 switch (TREE_CODE (type))
6071 return error_mark_node;
6074 case REFERENCE_TYPE:
6075 return type_main_variant (root_type (TREE_TYPE (type)));
6078 return type_main_variant (type);
6082 /* Given a pointer to an arbitrary ..._TYPE tree node, return non-zero if the
6083 given input type is a Dwarf "fundamental" type. Otherwise return null. */
6089 switch (TREE_CODE (type))
6104 case QUAL_UNION_TYPE:
6109 case REFERENCE_TYPE:
6122 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
6123 entry that chains various modifiers in front of the given type. */
6126 modified_type_die (type, is_const_type, is_volatile_type, context_die)
6128 register int is_const_type;
6129 register int is_volatile_type;
6130 register dw_die_ref context_die;
6132 register enum tree_code code = TREE_CODE (type);
6133 register dw_die_ref mod_type_die = NULL;
6134 register dw_die_ref sub_die = NULL;
6135 register tree item_type = NULL;
6137 if (code != ERROR_MARK)
6139 type = build_type_variant (type, is_const_type, is_volatile_type);
6141 mod_type_die = lookup_type_die (type);
6143 return mod_type_die;
6145 /* Handle C typedef types. */
6146 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
6147 && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
6149 tree dtype = TREE_TYPE (TYPE_NAME (type));
6152 /* For a named type, use the typedef. */
6153 gen_type_die (type, context_die);
6154 mod_type_die = lookup_type_die (type);
6157 else if (is_const_type < TYPE_READONLY (dtype)
6158 || is_volatile_type < TYPE_VOLATILE (dtype))
6159 /* cv-unqualified version of named type. Just use the unnamed
6160 type to which it refers. */
6162 = modified_type_die (DECL_ORIGINAL_TYPE (TYPE_NAME (type)),
6163 is_const_type, is_volatile_type,
6165 /* Else cv-qualified version of named type; fall through. */
6170 else if (is_const_type)
6172 mod_type_die = new_die (DW_TAG_const_type, comp_unit_die);
6173 sub_die = modified_type_die (type, 0, is_volatile_type, context_die);
6175 else if (is_volatile_type)
6177 mod_type_die = new_die (DW_TAG_volatile_type, comp_unit_die);
6178 sub_die = modified_type_die (type, 0, 0, context_die);
6180 else if (code == POINTER_TYPE)
6182 mod_type_die = new_die (DW_TAG_pointer_type, comp_unit_die);
6183 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
6185 add_AT_unsigned (mod_type_die, DW_AT_address_class, 0);
6187 item_type = TREE_TYPE (type);
6189 else if (code == REFERENCE_TYPE)
6191 mod_type_die = new_die (DW_TAG_reference_type, comp_unit_die);
6192 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
6194 add_AT_unsigned (mod_type_die, DW_AT_address_class, 0);
6196 item_type = TREE_TYPE (type);
6198 else if (is_base_type (type))
6199 mod_type_die = base_type_die (type);
6202 gen_type_die (type, context_die);
6204 /* We have to get the type_main_variant here (and pass that to the
6205 `lookup_type_die' routine) because the ..._TYPE node we have
6206 might simply be a *copy* of some original type node (where the
6207 copy was created to help us keep track of typedef names) and
6208 that copy might have a different TYPE_UID from the original
6210 mod_type_die = lookup_type_die (type_main_variant (type));
6211 if (mod_type_die == NULL)
6216 equate_type_number_to_die (type, mod_type_die);
6218 /* We must do this after the equate_type_number_to_die call, in case
6219 this is a recursive type. This ensures that the modified_type_die
6220 recursion will terminate even if the type is recursive. Recursive
6221 types are possible in Ada. */
6222 sub_die = modified_type_die (item_type,
6223 TYPE_READONLY (item_type),
6224 TYPE_VOLATILE (item_type),
6227 if (sub_die != NULL)
6228 add_AT_die_ref (mod_type_die, DW_AT_type, sub_die);
6230 return mod_type_die;
6233 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
6234 an enumerated type. */
6240 return TREE_CODE (type) == ENUMERAL_TYPE;
6243 /* Return a location descriptor that designates a machine register. */
6245 static dw_loc_descr_ref
6246 reg_loc_descriptor (rtl)
6249 register dw_loc_descr_ref loc_result = NULL;
6250 register unsigned reg = reg_number (rtl);
6253 loc_result = new_loc_descr (DW_OP_reg0 + reg, 0, 0);
6255 loc_result = new_loc_descr (DW_OP_regx, reg, 0);
6260 /* Return a location descriptor that designates a base+offset location. */
6262 static dw_loc_descr_ref
6263 based_loc_descr (reg, offset)
6267 register dw_loc_descr_ref loc_result;
6268 /* For the "frame base", we use the frame pointer or stack pointer
6269 registers, since the RTL for local variables is relative to one of
6271 register unsigned fp_reg = DBX_REGISTER_NUMBER (frame_pointer_needed
6272 ? HARD_FRAME_POINTER_REGNUM
6273 : STACK_POINTER_REGNUM);
6276 loc_result = new_loc_descr (DW_OP_fbreg, offset, 0);
6278 loc_result = new_loc_descr (DW_OP_breg0 + reg, offset, 0);
6280 loc_result = new_loc_descr (DW_OP_bregx, reg, offset);
6285 /* Return true if this RTL expression describes a base+offset calculation. */
6291 return (GET_CODE (rtl) == PLUS
6292 && ((GET_CODE (XEXP (rtl, 0)) == REG
6293 && GET_CODE (XEXP (rtl, 1)) == CONST_INT)));
6296 /* The following routine converts the RTL for a variable or parameter
6297 (resident in memory) into an equivalent Dwarf representation of a
6298 mechanism for getting the address of that same variable onto the top of a
6299 hypothetical "address evaluation" stack.
6301 When creating memory location descriptors, we are effectively transforming
6302 the RTL for a memory-resident object into its Dwarf postfix expression
6303 equivalent. This routine recursively descends an RTL tree, turning
6304 it into Dwarf postfix code as it goes.
6306 MODE is the mode of the memory reference, needed to handle some
6307 autoincrement addressing modes. */
6309 static dw_loc_descr_ref
6310 mem_loc_descriptor (rtl, mode)
6312 enum machine_mode mode;
6314 dw_loc_descr_ref mem_loc_result = NULL;
6315 /* Note that for a dynamically sized array, the location we will generate a
6316 description of here will be the lowest numbered location which is
6317 actually within the array. That's *not* necessarily the same as the
6318 zeroth element of the array. */
6320 #ifdef ASM_SIMPLIFY_DWARF_ADDR
6321 rtl = ASM_SIMPLIFY_DWARF_ADDR (rtl);
6324 switch (GET_CODE (rtl))
6328 /* POST_INC and POST_DEC can be handled just like a SUBREG. So we
6329 just fall into the SUBREG code. */
6331 /* ... fall through ... */
6334 /* The case of a subreg may arise when we have a local (register)
6335 variable or a formal (register) parameter which doesn't quite fill
6336 up an entire register. For now, just assume that it is
6337 legitimate to make the Dwarf info refer to the whole register which
6338 contains the given subreg. */
6339 rtl = XEXP (rtl, 0);
6341 /* ... fall through ... */
6344 /* Whenever a register number forms a part of the description of the
6345 method for calculating the (dynamic) address of a memory resident
6346 object, DWARF rules require the register number be referred to as
6347 a "base register". This distinction is not based in any way upon
6348 what category of register the hardware believes the given register
6349 belongs to. This is strictly DWARF terminology we're dealing with
6350 here. Note that in cases where the location of a memory-resident
6351 data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
6352 OP_CONST (0)) the actual DWARF location descriptor that we generate
6353 may just be OP_BASEREG (basereg). This may look deceptively like
6354 the object in question was allocated to a register (rather than in
6355 memory) so DWARF consumers need to be aware of the subtle
6356 distinction between OP_REG and OP_BASEREG. */
6357 mem_loc_result = based_loc_descr (reg_number (rtl), 0);
6361 mem_loc_result = mem_loc_descriptor (XEXP (rtl, 0), mode);
6362 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_deref, 0, 0));
6366 /* Some ports can transform a symbol ref into a label ref, because
6367 the symbol ref is too far away and has to be dumped into a constant
6371 mem_loc_result = new_loc_descr (DW_OP_addr, 0, 0);
6372 mem_loc_result->dw_loc_oprnd1.val_class = dw_val_class_addr;
6373 mem_loc_result->dw_loc_oprnd1.v.val_addr = save_rtx (rtl);
6378 /* Turn these into a PLUS expression and fall into the PLUS code
6380 rtl = gen_rtx_PLUS (word_mode, XEXP (rtl, 0),
6381 GEN_INT (GET_CODE (rtl) == PRE_INC
6382 ? GET_MODE_UNIT_SIZE (mode)
6383 : - GET_MODE_UNIT_SIZE (mode)));
6385 /* ... fall through ... */
6388 if (is_based_loc (rtl))
6389 mem_loc_result = based_loc_descr (reg_number (XEXP (rtl, 0)),
6390 INTVAL (XEXP (rtl, 1)));
6393 add_loc_descr (&mem_loc_result, mem_loc_descriptor (XEXP (rtl, 0),
6395 add_loc_descr (&mem_loc_result, mem_loc_descriptor (XEXP (rtl, 1),
6397 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_plus, 0, 0));
6402 /* If a pseudo-reg is optimized away, it is possible for it to
6403 be replaced with a MEM containing a multiply. */
6404 add_loc_descr (&mem_loc_result, mem_loc_descriptor (XEXP (rtl, 0), mode));
6405 add_loc_descr (&mem_loc_result, mem_loc_descriptor (XEXP (rtl, 1), mode));
6406 add_loc_descr (&mem_loc_result, new_loc_descr (DW_OP_mul, 0, 0));
6410 mem_loc_result = new_loc_descr (DW_OP_constu, INTVAL (rtl), 0);
6417 return mem_loc_result;
6420 /* Return a descriptor that describes the concatenation of two locations.
6421 This is typically a complex variable. */
6423 static dw_loc_descr_ref
6424 concat_loc_descriptor (x0, x1)
6425 register rtx x0, x1;
6427 dw_loc_descr_ref cc_loc_result = NULL;
6429 if (!is_pseudo_reg (x0)
6430 && (GET_CODE (x0) != MEM || !is_pseudo_reg (XEXP (x0, 0))))
6431 add_loc_descr (&cc_loc_result, loc_descriptor (x0));
6432 add_loc_descr (&cc_loc_result,
6433 new_loc_descr (DW_OP_piece, GET_MODE_SIZE (GET_MODE (x0)), 0));
6435 if (!is_pseudo_reg (x1)
6436 && (GET_CODE (x1) != MEM || !is_pseudo_reg (XEXP (x1, 0))))
6437 add_loc_descr (&cc_loc_result, loc_descriptor (x1));
6438 add_loc_descr (&cc_loc_result,
6439 new_loc_descr (DW_OP_piece, GET_MODE_SIZE (GET_MODE (x1)), 0));
6441 return cc_loc_result;
6444 /* Output a proper Dwarf location descriptor for a variable or parameter
6445 which is either allocated in a register or in a memory location. For a
6446 register, we just generate an OP_REG and the register number. For a
6447 memory location we provide a Dwarf postfix expression describing how to
6448 generate the (dynamic) address of the object onto the address stack. */
6450 static dw_loc_descr_ref
6451 loc_descriptor (rtl)
6454 dw_loc_descr_ref loc_result = NULL;
6455 switch (GET_CODE (rtl))
6458 /* The case of a subreg may arise when we have a local (register)
6459 variable or a formal (register) parameter which doesn't quite fill
6460 up an entire register. For now, just assume that it is
6461 legitimate to make the Dwarf info refer to the whole register which
6462 contains the given subreg. */
6463 rtl = XEXP (rtl, 0);
6465 /* ... fall through ... */
6468 loc_result = reg_loc_descriptor (rtl);
6472 loc_result = mem_loc_descriptor (XEXP (rtl, 0), GET_MODE (rtl));
6476 loc_result = concat_loc_descriptor (XEXP (rtl, 0), XEXP (rtl, 1));
6486 /* Given an unsigned value, round it up to the lowest multiple of `boundary'
6487 which is not less than the value itself. */
6489 static inline unsigned
6490 ceiling (value, boundary)
6491 register unsigned value;
6492 register unsigned boundary;
6494 return (((value + boundary - 1) / boundary) * boundary);
6497 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
6498 pointer to the declared type for the relevant field variable, or return
6499 `integer_type_node' if the given node turns out to be an
6508 if (TREE_CODE (decl) == ERROR_MARK)
6509 return integer_type_node;
6511 type = DECL_BIT_FIELD_TYPE (decl);
6512 if (type == NULL_TREE)
6513 type = TREE_TYPE (decl);
6518 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
6519 node, return the alignment in bits for the type, or else return
6520 BITS_PER_WORD if the node actually turns out to be an
6523 static inline unsigned
6524 simple_type_align_in_bits (type)
6527 return (TREE_CODE (type) != ERROR_MARK) ? TYPE_ALIGN (type) : BITS_PER_WORD;
6530 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
6531 node, return the size in bits for the type if it is a constant, or else
6532 return the alignment for the type if the type's size is not constant, or
6533 else return BITS_PER_WORD if the type actually turns out to be an
6536 static inline unsigned
6537 simple_type_size_in_bits (type)
6540 if (TREE_CODE (type) == ERROR_MARK)
6541 return BITS_PER_WORD;
6544 register tree type_size_tree = TYPE_SIZE (type);
6546 if (TREE_CODE (type_size_tree) != INTEGER_CST)
6547 return TYPE_ALIGN (type);
6549 return (unsigned) TREE_INT_CST_LOW (type_size_tree);
6553 /* Given a pointer to what is assumed to be a FIELD_DECL node, compute and
6554 return the byte offset of the lowest addressed byte of the "containing
6555 object" for the given FIELD_DECL, or return 0 if we are unable to
6556 determine what that offset is, either because the argument turns out to
6557 be a pointer to an ERROR_MARK node, or because the offset is actually
6558 variable. (We can't handle the latter case just yet). */
6561 field_byte_offset (decl)
6564 register unsigned type_align_in_bytes;
6565 register unsigned type_align_in_bits;
6566 register unsigned type_size_in_bits;
6567 register unsigned object_offset_in_align_units;
6568 register unsigned object_offset_in_bits;
6569 register unsigned object_offset_in_bytes;
6571 register tree bitpos_tree;
6572 register tree field_size_tree;
6573 register unsigned bitpos_int;
6574 register unsigned deepest_bitpos;
6575 register unsigned field_size_in_bits;
6577 if (TREE_CODE (decl) == ERROR_MARK)
6580 if (TREE_CODE (decl) != FIELD_DECL)
6583 type = field_type (decl);
6585 bitpos_tree = DECL_FIELD_BITPOS (decl);
6586 field_size_tree = DECL_SIZE (decl);
6588 /* If there was an error, the size could be zero. */
6589 if (! field_size_tree)
6596 /* We cannot yet cope with fields whose positions are variable, so
6597 for now, when we see such things, we simply return 0. Someday, we may
6598 be able to handle such cases, but it will be damn difficult. */
6599 if (TREE_CODE (bitpos_tree) != INTEGER_CST)
6602 bitpos_int = (unsigned) TREE_INT_CST_LOW (bitpos_tree);
6604 /* If we don't know the size of the field, pretend it's a full word. */
6605 if (TREE_CODE (field_size_tree) == INTEGER_CST)
6606 field_size_in_bits = (unsigned) TREE_INT_CST_LOW (field_size_tree);
6608 field_size_in_bits = BITS_PER_WORD;
6610 type_size_in_bits = simple_type_size_in_bits (type);
6611 type_align_in_bits = simple_type_align_in_bits (type);
6612 type_align_in_bytes = type_align_in_bits / BITS_PER_UNIT;
6614 /* Note that the GCC front-end doesn't make any attempt to keep track of
6615 the starting bit offset (relative to the start of the containing
6616 structure type) of the hypothetical "containing object" for a bit-
6617 field. Thus, when computing the byte offset value for the start of the
6618 "containing object" of a bit-field, we must deduce this information on
6619 our own. This can be rather tricky to do in some cases. For example,
6620 handling the following structure type definition when compiling for an
6621 i386/i486 target (which only aligns long long's to 32-bit boundaries)
6624 struct S { int field1; long long field2:31; };
6626 Fortunately, there is a simple rule-of-thumb which can be
6627 used in such cases. When compiling for an i386/i486, GCC will allocate
6628 8 bytes for the structure shown above. It decides to do this based upon
6629 one simple rule for bit-field allocation. Quite simply, GCC allocates
6630 each "containing object" for each bit-field at the first (i.e. lowest
6631 addressed) legitimate alignment boundary (based upon the required
6632 minimum alignment for the declared type of the field) which it can
6633 possibly use, subject to the condition that there is still enough
6634 available space remaining in the containing object (when allocated at
6635 the selected point) to fully accommodate all of the bits of the
6636 bit-field itself. This simple rule makes it obvious why GCC allocates
6637 8 bytes for each object of the structure type shown above. When looking
6638 for a place to allocate the "containing object" for `field2', the
6639 compiler simply tries to allocate a 64-bit "containing object" at each
6640 successive 32-bit boundary (starting at zero) until it finds a place to
6641 allocate that 64- bit field such that at least 31 contiguous (and
6642 previously unallocated) bits remain within that selected 64 bit field.
6643 (As it turns out, for the example above, the compiler finds that it is
6644 OK to allocate the "containing object" 64-bit field at bit-offset zero
6645 within the structure type.) Here we attempt to work backwards from the
6646 limited set of facts we're given, and we try to deduce from those facts,
6647 where GCC must have believed that the containing object started (within
6648 the structure type). The value we deduce is then used (by the callers of
6649 this routine) to generate DW_AT_location and DW_AT_bit_offset attributes
6650 for fields (both bit-fields and, in the case of DW_AT_location, regular
6653 /* Figure out the bit-distance from the start of the structure to the
6654 "deepest" bit of the bit-field. */
6655 deepest_bitpos = bitpos_int + field_size_in_bits;
6657 /* This is the tricky part. Use some fancy footwork to deduce where the
6658 lowest addressed bit of the containing object must be. */
6659 object_offset_in_bits
6660 = ceiling (deepest_bitpos, type_align_in_bits) - type_size_in_bits;
6662 /* Compute the offset of the containing object in "alignment units". */
6663 object_offset_in_align_units = object_offset_in_bits / type_align_in_bits;
6665 /* Compute the offset of the containing object in bytes. */
6666 object_offset_in_bytes = object_offset_in_align_units * type_align_in_bytes;
6668 return object_offset_in_bytes;
6671 /* The following routines define various Dwarf attributes and any data
6672 associated with them. */
6674 /* Add a location description attribute value to a DIE.
6676 This emits location attributes suitable for whole variables and
6677 whole parameters. Note that the location attributes for struct fields are
6678 generated by the routine `data_member_location_attribute' below. */
6681 add_AT_location_description (die, attr_kind, rtl)
6683 enum dwarf_attribute attr_kind;
6686 /* Handle a special case. If we are about to output a location descriptor
6687 for a variable or parameter which has been optimized out of existence,
6688 don't do that. A variable which has been optimized out
6689 of existence will have a DECL_RTL value which denotes a pseudo-reg.
6690 Currently, in some rare cases, variables can have DECL_RTL values which
6691 look like (MEM (REG pseudo-reg#)). These cases are due to bugs
6692 elsewhere in the compiler. We treat such cases as if the variable(s) in
6693 question had been optimized out of existence. */
6695 if (is_pseudo_reg (rtl)
6696 || (GET_CODE (rtl) == MEM
6697 && is_pseudo_reg (XEXP (rtl, 0)))
6698 /* This can happen for a PARM_DECL with a DECL_INCOMING_RTL which
6699 references the internal argument pointer (a pseudo) in a function
6700 where all references to the internal argument pointer were
6701 eliminated via the optimizers. */
6702 || (GET_CODE (rtl) == MEM
6703 && GET_CODE (XEXP (rtl, 0)) == PLUS
6704 && is_pseudo_reg (XEXP (XEXP (rtl, 0), 0)))
6705 || (GET_CODE (rtl) == CONCAT
6706 && is_pseudo_reg (XEXP (rtl, 0))
6707 && is_pseudo_reg (XEXP (rtl, 1))))
6710 add_AT_loc (die, attr_kind, loc_descriptor (rtl));
6713 /* Attach the specialized form of location attribute used for data
6714 members of struct and union types. In the special case of a
6715 FIELD_DECL node which represents a bit-field, the "offset" part
6716 of this special location descriptor must indicate the distance
6717 in bytes from the lowest-addressed byte of the containing struct
6718 or union type to the lowest-addressed byte of the "containing
6719 object" for the bit-field. (See the `field_byte_offset' function
6720 above).. For any given bit-field, the "containing object" is a
6721 hypothetical object (of some integral or enum type) within which
6722 the given bit-field lives. The type of this hypothetical
6723 "containing object" is always the same as the declared type of
6724 the individual bit-field itself (for GCC anyway... the DWARF
6725 spec doesn't actually mandate this). Note that it is the size
6726 (in bytes) of the hypothetical "containing object" which will
6727 be given in the DW_AT_byte_size attribute for this bit-field.
6728 (See the `byte_size_attribute' function below.) It is also used
6729 when calculating the value of the DW_AT_bit_offset attribute.
6730 (See the `bit_offset_attribute' function below). */
6733 add_data_member_location_attribute (die, decl)
6734 register dw_die_ref die;
6737 register unsigned long offset;
6738 register dw_loc_descr_ref loc_descr;
6739 register enum dwarf_location_atom op;
6741 if (TREE_CODE (decl) == TREE_VEC)
6742 offset = TREE_INT_CST_LOW (BINFO_OFFSET (decl));
6744 offset = field_byte_offset (decl);
6746 /* The DWARF2 standard says that we should assume that the structure address
6747 is already on the stack, so we can specify a structure field address
6748 by using DW_OP_plus_uconst. */
6750 #ifdef MIPS_DEBUGGING_INFO
6751 /* ??? The SGI dwarf reader does not handle the DW_OP_plus_uconst operator
6752 correctly. It works only if we leave the offset on the stack. */
6755 op = DW_OP_plus_uconst;
6758 loc_descr = new_loc_descr (op, offset, 0);
6759 add_AT_loc (die, DW_AT_data_member_location, loc_descr);
6762 /* Attach an DW_AT_const_value attribute for a variable or a parameter which
6763 does not have a "location" either in memory or in a register. These
6764 things can arise in GNU C when a constant is passed as an actual parameter
6765 to an inlined function. They can also arise in C++ where declared
6766 constants do not necessarily get memory "homes". */
6769 add_const_value_attribute (die, rtl)
6770 register dw_die_ref die;
6773 switch (GET_CODE (rtl))
6776 /* Note that a CONST_INT rtx could represent either an integer or a
6777 floating-point constant. A CONST_INT is used whenever the constant
6778 will fit into a single word. In all such cases, the original mode
6779 of the constant value is wiped out, and the CONST_INT rtx is
6780 assigned VOIDmode. */
6781 add_AT_unsigned (die, DW_AT_const_value, (unsigned) INTVAL (rtl));
6785 /* Note that a CONST_DOUBLE rtx could represent either an integer or a
6786 floating-point constant. A CONST_DOUBLE is used whenever the
6787 constant requires more than one word in order to be adequately
6788 represented. We output CONST_DOUBLEs as blocks. */
6790 register enum machine_mode mode = GET_MODE (rtl);
6792 if (GET_MODE_CLASS (mode) == MODE_FLOAT)
6794 register unsigned length = GET_MODE_SIZE (mode) / sizeof (long);
6798 REAL_VALUE_FROM_CONST_DOUBLE (rv, rtl);
6802 REAL_VALUE_TO_TARGET_SINGLE (rv, array[0]);
6806 REAL_VALUE_TO_TARGET_DOUBLE (rv, array);
6811 REAL_VALUE_TO_TARGET_LONG_DOUBLE (rv, array);
6818 add_AT_float (die, DW_AT_const_value, length, array);
6821 add_AT_long_long (die, DW_AT_const_value,
6822 CONST_DOUBLE_HIGH (rtl), CONST_DOUBLE_LOW (rtl));
6827 add_AT_string (die, DW_AT_const_value, XSTR (rtl, 0));
6833 add_AT_addr (die, DW_AT_const_value, save_rtx (rtl));
6837 /* In cases where an inlined instance of an inline function is passed
6838 the address of an `auto' variable (which is local to the caller) we
6839 can get a situation where the DECL_RTL of the artificial local
6840 variable (for the inlining) which acts as a stand-in for the
6841 corresponding formal parameter (of the inline function) will look
6842 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not
6843 exactly a compile-time constant expression, but it isn't the address
6844 of the (artificial) local variable either. Rather, it represents the
6845 *value* which the artificial local variable always has during its
6846 lifetime. We currently have no way to represent such quasi-constant
6847 values in Dwarf, so for now we just punt and generate nothing. */
6851 /* No other kinds of rtx should be possible here. */
6857 /* Generate *either* an DW_AT_location attribute or else an DW_AT_const_value
6858 data attribute for a variable or a parameter. We generate the
6859 DW_AT_const_value attribute only in those cases where the given variable
6860 or parameter does not have a true "location" either in memory or in a
6861 register. This can happen (for example) when a constant is passed as an
6862 actual argument in a call to an inline function. (It's possible that
6863 these things can crop up in other ways also.) Note that one type of
6864 constant value which can be passed into an inlined function is a constant
6865 pointer. This can happen for example if an actual argument in an inlined
6866 function call evaluates to a compile-time constant address. */
6869 add_location_or_const_value_attribute (die, decl)
6870 register dw_die_ref die;
6874 register tree declared_type;
6875 register tree passed_type;
6877 if (TREE_CODE (decl) == ERROR_MARK)
6880 if (TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != PARM_DECL)
6883 /* Here we have to decide where we are going to say the parameter "lives"
6884 (as far as the debugger is concerned). We only have a couple of
6885 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
6887 DECL_RTL normally indicates where the parameter lives during most of the
6888 activation of the function. If optimization is enabled however, this
6889 could be either NULL or else a pseudo-reg. Both of those cases indicate
6890 that the parameter doesn't really live anywhere (as far as the code
6891 generation parts of GCC are concerned) during most of the function's
6892 activation. That will happen (for example) if the parameter is never
6893 referenced within the function.
6895 We could just generate a location descriptor here for all non-NULL
6896 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
6897 a little nicer than that if we also consider DECL_INCOMING_RTL in cases
6898 where DECL_RTL is NULL or is a pseudo-reg.
6900 Note however that we can only get away with using DECL_INCOMING_RTL as
6901 a backup substitute for DECL_RTL in certain limited cases. In cases
6902 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
6903 we can be sure that the parameter was passed using the same type as it is
6904 declared to have within the function, and that its DECL_INCOMING_RTL
6905 points us to a place where a value of that type is passed.
6907 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
6908 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
6909 because in these cases DECL_INCOMING_RTL points us to a value of some
6910 type which is *different* from the type of the parameter itself. Thus,
6911 if we tried to use DECL_INCOMING_RTL to generate a location attribute in
6912 such cases, the debugger would end up (for example) trying to fetch a
6913 `float' from a place which actually contains the first part of a
6914 `double'. That would lead to really incorrect and confusing
6915 output at debug-time.
6917 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
6918 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There
6919 are a couple of exceptions however. On little-endian machines we can
6920 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
6921 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
6922 an integral type that is smaller than TREE_TYPE (decl). These cases arise
6923 when (on a little-endian machine) a non-prototyped function has a
6924 parameter declared to be of type `short' or `char'. In such cases,
6925 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
6926 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
6927 passed `int' value. If the debugger then uses that address to fetch
6928 a `short' or a `char' (on a little-endian machine) the result will be
6929 the correct data, so we allow for such exceptional cases below.
6931 Note that our goal here is to describe the place where the given formal
6932 parameter lives during most of the function's activation (i.e. between
6933 the end of the prologue and the start of the epilogue). We'll do that
6934 as best as we can. Note however that if the given formal parameter is
6935 modified sometime during the execution of the function, then a stack
6936 backtrace (at debug-time) will show the function as having been
6937 called with the *new* value rather than the value which was
6938 originally passed in. This happens rarely enough that it is not
6939 a major problem, but it *is* a problem, and I'd like to fix it.
6941 A future version of dwarf2out.c may generate two additional
6942 attributes for any given DW_TAG_formal_parameter DIE which will
6943 describe the "passed type" and the "passed location" for the
6944 given formal parameter in addition to the attributes we now
6945 generate to indicate the "declared type" and the "active
6946 location" for each parameter. This additional set of attributes
6947 could be used by debuggers for stack backtraces. Separately, note
6948 that sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be
6949 NULL also. This happens (for example) for inlined-instances of
6950 inline function formal parameters which are never referenced.
6951 This really shouldn't be happening. All PARM_DECL nodes should
6952 get valid non-NULL DECL_INCOMING_RTL values, but integrate.c
6953 doesn't currently generate these values for inlined instances of
6954 inline function parameters, so when we see such cases, we are
6955 just out-of-luck for the time being (until integrate.c
6958 /* Use DECL_RTL as the "location" unless we find something better. */
6959 rtl = DECL_RTL (decl);
6961 if (TREE_CODE (decl) == PARM_DECL)
6963 if (rtl == NULL_RTX || is_pseudo_reg (rtl))
6965 declared_type = type_main_variant (TREE_TYPE (decl));
6966 passed_type = type_main_variant (DECL_ARG_TYPE (decl));
6968 /* This decl represents a formal parameter which was optimized out.
6969 Note that DECL_INCOMING_RTL may be NULL in here, but we handle
6970 all* cases where (rtl == NULL_RTX) just below. */
6971 if (declared_type == passed_type)
6972 rtl = DECL_INCOMING_RTL (decl);
6973 else if (! BYTES_BIG_ENDIAN
6974 && TREE_CODE (declared_type) == INTEGER_TYPE
6975 && (GET_MODE_SIZE (TYPE_MODE (declared_type))
6976 <= GET_MODE_SIZE (TYPE_MODE (passed_type))))
6977 rtl = DECL_INCOMING_RTL (decl);
6980 /* If the parm was passed in registers, but lives on the stack, then
6981 make a big endian correction if the mode of the type of the
6982 parameter is not the same as the mode of the rtl. */
6983 /* ??? This is the same series of checks that are made in dbxout.c before
6984 we reach the big endian correction code there. It isn't clear if all
6985 of these checks are necessary here, but keeping them all is the safe
6987 else if (GET_CODE (rtl) == MEM
6988 && XEXP (rtl, 0) != const0_rtx
6989 && ! CONSTANT_P (XEXP (rtl, 0))
6990 /* Not passed in memory. */
6991 && GET_CODE (DECL_INCOMING_RTL (decl)) != MEM
6992 /* Not passed by invisible reference. */
6993 && (GET_CODE (XEXP (rtl, 0)) != REG
6994 || REGNO (XEXP (rtl, 0)) == HARD_FRAME_POINTER_REGNUM
6995 || REGNO (XEXP (rtl, 0)) == STACK_POINTER_REGNUM
6996 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
6997 || REGNO (XEXP (rtl, 0)) == ARG_POINTER_REGNUM
7000 /* Big endian correction check. */
7002 && TYPE_MODE (TREE_TYPE (decl)) != GET_MODE (rtl)
7003 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl)))
7006 int offset = (UNITS_PER_WORD
7007 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl))));
7008 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl)),
7009 plus_constant (XEXP (rtl, 0), offset));
7013 if (rtl == NULL_RTX)
7016 rtl = eliminate_regs (rtl, 0, NULL_RTX);
7017 #ifdef LEAF_REG_REMAP
7018 if (current_function_uses_only_leaf_regs)
7019 leaf_renumber_regs_insn (rtl);
7022 switch (GET_CODE (rtl))
7025 /* The address of a variable that was optimized away; don't emit
7036 /* DECL_RTL could be (plus (reg ...) (const_int ...)) */
7037 add_const_value_attribute (die, rtl);
7044 add_AT_location_description (die, DW_AT_location, rtl);
7052 /* Generate an DW_AT_name attribute given some string value to be included as
7053 the value of the attribute. */
7056 add_name_attribute (die, name_string)
7057 register dw_die_ref die;
7058 register const char *name_string;
7060 if (name_string != NULL && *name_string != 0)
7062 if (demangle_name_func)
7063 name_string = (*demangle_name_func) (name_string);
7065 add_AT_string (die, DW_AT_name, name_string);
7069 /* Given a tree node describing an array bound (either lower or upper) output
7070 a representation for that bound. */
7073 add_bound_info (subrange_die, bound_attr, bound)
7074 register dw_die_ref subrange_die;
7075 register enum dwarf_attribute bound_attr;
7076 register tree bound;
7078 register unsigned bound_value = 0;
7080 /* If this is an Ada unconstrained array type, then don't emit any debug
7081 info because the array bounds are unknown. They are parameterized when
7082 the type is instantiated. */
7083 if (contains_placeholder_p (bound))
7086 switch (TREE_CODE (bound))
7091 /* All fixed-bounds are represented by INTEGER_CST nodes. */
7093 bound_value = TREE_INT_CST_LOW (bound);
7094 if (bound_attr == DW_AT_lower_bound
7095 && ((is_c_family () && bound_value == 0)
7096 || (is_fortran () && bound_value == 1)))
7097 /* use the default */;
7099 add_AT_unsigned (subrange_die, bound_attr, bound_value);
7104 case NON_LVALUE_EXPR:
7105 add_bound_info (subrange_die, bound_attr, TREE_OPERAND (bound, 0));
7109 /* If optimization is turned on, the SAVE_EXPRs that describe how to
7110 access the upper bound values may be bogus. If they refer to a
7111 register, they may only describe how to get at these values at the
7112 points in the generated code right after they have just been
7113 computed. Worse yet, in the typical case, the upper bound values
7114 will not even *be* computed in the optimized code (though the
7115 number of elements will), so these SAVE_EXPRs are entirely
7116 bogus. In order to compensate for this fact, we check here to see
7117 if optimization is enabled, and if so, we don't add an attribute
7118 for the (unknown and unknowable) upper bound. This should not
7119 cause too much trouble for existing (stupid?) debuggers because
7120 they have to deal with empty upper bounds location descriptions
7121 anyway in order to be able to deal with incomplete array types.
7122 Of course an intelligent debugger (GDB?) should be able to
7123 comprehend that a missing upper bound specification in a array
7124 type used for a storage class `auto' local array variable
7125 indicates that the upper bound is both unknown (at compile- time)
7126 and unknowable (at run-time) due to optimization.
7128 We assume that a MEM rtx is safe because gcc wouldn't put the
7129 value there unless it was going to be used repeatedly in the
7130 function, i.e. for cleanups. */
7131 if (! optimize || GET_CODE (SAVE_EXPR_RTL (bound)) == MEM)
7133 register dw_die_ref ctx = lookup_decl_die (current_function_decl);
7134 register dw_die_ref decl_die = new_die (DW_TAG_variable, ctx);
7135 register rtx loc = SAVE_EXPR_RTL (bound);
7137 /* If the RTL for the SAVE_EXPR is memory, handle the case where
7138 it references an outer function's frame. */
7140 if (GET_CODE (loc) == MEM)
7142 rtx new_addr = fix_lexical_addr (XEXP (loc, 0), bound);
7144 if (XEXP (loc, 0) != new_addr)
7145 loc = gen_rtx_MEM (GET_MODE (loc), new_addr);
7148 add_AT_flag (decl_die, DW_AT_artificial, 1);
7149 add_type_attribute (decl_die, TREE_TYPE (bound), 1, 0, ctx);
7150 add_AT_location_description (decl_die, DW_AT_location, loc);
7151 add_AT_die_ref (subrange_die, bound_attr, decl_die);
7154 /* Else leave out the attribute. */
7160 /* ??? These types of bounds can be created by the Ada front end,
7161 and it isn't clear how to emit debug info for them. */
7169 /* Note that the block of subscript information for an array type also
7170 includes information about the element type of type given array type. */
7173 add_subscript_info (type_die, type)
7174 register dw_die_ref type_die;
7177 #ifndef MIPS_DEBUGGING_INFO
7178 register unsigned dimension_number;
7180 register tree lower, upper;
7181 register dw_die_ref subrange_die;
7183 /* The GNU compilers represent multidimensional array types as sequences of
7184 one dimensional array types whose element types are themselves array
7185 types. Here we squish that down, so that each multidimensional array
7186 type gets only one array_type DIE in the Dwarf debugging info. The draft
7187 Dwarf specification say that we are allowed to do this kind of
7188 compression in C (because there is no difference between an array or
7189 arrays and a multidimensional array in C) but for other source languages
7190 (e.g. Ada) we probably shouldn't do this. */
7192 /* ??? The SGI dwarf reader fails for multidimensional arrays with a
7193 const enum type. E.g. const enum machine_mode insn_operand_mode[2][10].
7194 We work around this by disabling this feature. See also
7195 gen_array_type_die. */
7196 #ifndef MIPS_DEBUGGING_INFO
7197 for (dimension_number = 0;
7198 TREE_CODE (type) == ARRAY_TYPE;
7199 type = TREE_TYPE (type), dimension_number++)
7202 register tree domain = TYPE_DOMAIN (type);
7204 /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
7205 and (in GNU C only) variable bounds. Handle all three forms
7207 subrange_die = new_die (DW_TAG_subrange_type, type_die);
7210 /* We have an array type with specified bounds. */
7211 lower = TYPE_MIN_VALUE (domain);
7212 upper = TYPE_MAX_VALUE (domain);
7214 /* define the index type. */
7215 if (TREE_TYPE (domain))
7217 /* ??? This is probably an Ada unnamed subrange type. Ignore the
7218 TREE_TYPE field. We can't emit debug info for this
7219 because it is an unnamed integral type. */
7220 if (TREE_CODE (domain) == INTEGER_TYPE
7221 && TYPE_NAME (domain) == NULL_TREE
7222 && TREE_CODE (TREE_TYPE (domain)) == INTEGER_TYPE
7223 && TYPE_NAME (TREE_TYPE (domain)) == NULL_TREE)
7226 add_type_attribute (subrange_die, TREE_TYPE (domain), 0, 0,
7230 /* ??? If upper is NULL, the array has unspecified length,
7231 but it does have a lower bound. This happens with Fortran
7233 Since the debugger is definitely going to need to know N
7234 to produce useful results, go ahead and output the lower
7235 bound solo, and hope the debugger can cope. */
7237 add_bound_info (subrange_die, DW_AT_lower_bound, lower);
7239 add_bound_info (subrange_die, DW_AT_upper_bound, upper);
7242 /* We have an array type with an unspecified length. The DWARF-2
7243 spec does not say how to handle this; let's just leave out the
7248 #ifndef MIPS_DEBUGGING_INFO
7254 add_byte_size_attribute (die, tree_node)
7256 register tree tree_node;
7258 register unsigned size;
7260 switch (TREE_CODE (tree_node))
7268 case QUAL_UNION_TYPE:
7269 size = int_size_in_bytes (tree_node);
7272 /* For a data member of a struct or union, the DW_AT_byte_size is
7273 generally given as the number of bytes normally allocated for an
7274 object of the *declared* type of the member itself. This is true
7275 even for bit-fields. */
7276 size = simple_type_size_in_bits (field_type (tree_node)) / BITS_PER_UNIT;
7282 /* Note that `size' might be -1 when we get to this point. If it is, that
7283 indicates that the byte size of the entity in question is variable. We
7284 have no good way of expressing this fact in Dwarf at the present time,
7285 so just let the -1 pass on through. */
7287 add_AT_unsigned (die, DW_AT_byte_size, size);
7290 /* For a FIELD_DECL node which represents a bit-field, output an attribute
7291 which specifies the distance in bits from the highest order bit of the
7292 "containing object" for the bit-field to the highest order bit of the
7295 For any given bit-field, the "containing object" is a hypothetical
7296 object (of some integral or enum type) within which the given bit-field
7297 lives. The type of this hypothetical "containing object" is always the
7298 same as the declared type of the individual bit-field itself. The
7299 determination of the exact location of the "containing object" for a
7300 bit-field is rather complicated. It's handled by the
7301 `field_byte_offset' function (above).
7303 Note that it is the size (in bytes) of the hypothetical "containing object"
7304 which will be given in the DW_AT_byte_size attribute for this bit-field.
7305 (See `byte_size_attribute' above). */
7308 add_bit_offset_attribute (die, decl)
7309 register dw_die_ref die;
7312 register unsigned object_offset_in_bytes = field_byte_offset (decl);
7313 register tree type = DECL_BIT_FIELD_TYPE (decl);
7314 register tree bitpos_tree = DECL_FIELD_BITPOS (decl);
7315 register unsigned bitpos_int;
7316 register unsigned highest_order_object_bit_offset;
7317 register unsigned highest_order_field_bit_offset;
7318 register unsigned bit_offset;
7320 /* Must be a field and a bit field. */
7322 || TREE_CODE (decl) != FIELD_DECL)
7325 /* We can't yet handle bit-fields whose offsets are variable, so if we
7326 encounter such things, just return without generating any attribute
7328 if (TREE_CODE (bitpos_tree) != INTEGER_CST)
7331 bitpos_int = (unsigned) TREE_INT_CST_LOW (bitpos_tree);
7333 /* Note that the bit offset is always the distance (in bits) from the
7334 highest-order bit of the "containing object" to the highest-order bit of
7335 the bit-field itself. Since the "high-order end" of any object or field
7336 is different on big-endian and little-endian machines, the computation
7337 below must take account of these differences. */
7338 highest_order_object_bit_offset = object_offset_in_bytes * BITS_PER_UNIT;
7339 highest_order_field_bit_offset = bitpos_int;
7341 if (! BYTES_BIG_ENDIAN)
7343 highest_order_field_bit_offset
7344 += (unsigned) TREE_INT_CST_LOW (DECL_SIZE (decl));
7346 highest_order_object_bit_offset += simple_type_size_in_bits (type);
7350 = (! BYTES_BIG_ENDIAN
7351 ? highest_order_object_bit_offset - highest_order_field_bit_offset
7352 : highest_order_field_bit_offset - highest_order_object_bit_offset);
7354 add_AT_unsigned (die, DW_AT_bit_offset, bit_offset);
7357 /* For a FIELD_DECL node which represents a bit field, output an attribute
7358 which specifies the length in bits of the given field. */
7361 add_bit_size_attribute (die, decl)
7362 register dw_die_ref die;
7365 /* Must be a field and a bit field. */
7366 if (TREE_CODE (decl) != FIELD_DECL
7367 || ! DECL_BIT_FIELD_TYPE (decl))
7369 add_AT_unsigned (die, DW_AT_bit_size,
7370 (unsigned) TREE_INT_CST_LOW (DECL_SIZE (decl)));
7373 /* If the compiled language is ANSI C, then add a 'prototyped'
7374 attribute, if arg types are given for the parameters of a function. */
7377 add_prototyped_attribute (die, func_type)
7378 register dw_die_ref die;
7379 register tree func_type;
7381 if (get_AT_unsigned (comp_unit_die, DW_AT_language) == DW_LANG_C89
7382 && TYPE_ARG_TYPES (func_type) != NULL)
7383 add_AT_flag (die, DW_AT_prototyped, 1);
7387 /* Add an 'abstract_origin' attribute below a given DIE. The DIE is found
7388 by looking in either the type declaration or object declaration
7392 add_abstract_origin_attribute (die, origin)
7393 register dw_die_ref die;
7394 register tree origin;
7396 dw_die_ref origin_die = NULL;
7398 if (die->die_tag != DW_TAG_subprogram)
7400 /* We may have gotten separated from the block for the inlined
7401 function, if we're in an exception handler or some such; make
7402 sure that the abstract function has been written out.
7404 Doing this for nested functions is wrong, however; functions are
7405 distinct units, and our context might not even be inline. */
7406 tree fn = decl_function_context (origin);
7408 gen_abstract_function (fn);
7411 if (TREE_CODE_CLASS (TREE_CODE (origin)) == 'd')
7412 origin_die = lookup_decl_die (origin);
7413 else if (TREE_CODE_CLASS (TREE_CODE (origin)) == 't')
7414 origin_die = lookup_type_die (origin);
7416 if (origin_die == NULL)
7419 add_AT_die_ref (die, DW_AT_abstract_origin, origin_die);
7422 /* We do not currently support the pure_virtual attribute. */
7425 add_pure_or_virtual_attribute (die, func_decl)
7426 register dw_die_ref die;
7427 register tree func_decl;
7429 if (DECL_VINDEX (func_decl))
7431 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
7432 add_AT_loc (die, DW_AT_vtable_elem_location,
7433 new_loc_descr (DW_OP_constu,
7434 TREE_INT_CST_LOW (DECL_VINDEX (func_decl)),
7437 /* GNU extension: Record what type this method came from originally. */
7438 if (debug_info_level > DINFO_LEVEL_TERSE)
7439 add_AT_die_ref (die, DW_AT_containing_type,
7440 lookup_type_die (DECL_CONTEXT (func_decl)));
7444 /* Add source coordinate attributes for the given decl. */
7447 add_src_coords_attributes (die, decl)
7448 register dw_die_ref die;
7451 register unsigned file_index = lookup_filename (DECL_SOURCE_FILE (decl));
7453 add_AT_unsigned (die, DW_AT_decl_file, file_index);
7454 add_AT_unsigned (die, DW_AT_decl_line, DECL_SOURCE_LINE (decl));
7457 /* Add an DW_AT_name attribute and source coordinate attribute for the
7458 given decl, but only if it actually has a name. */
7461 add_name_and_src_coords_attributes (die, decl)
7462 register dw_die_ref die;
7465 register tree decl_name;
7467 decl_name = DECL_NAME (decl);
7468 if (decl_name != NULL && IDENTIFIER_POINTER (decl_name) != NULL)
7470 add_name_attribute (die, dwarf2_name (decl, 0));
7471 if (! DECL_ARTIFICIAL (decl))
7472 add_src_coords_attributes (die, decl);
7474 if ((TREE_CODE (decl) == FUNCTION_DECL || TREE_CODE (decl) == VAR_DECL)
7475 && DECL_ASSEMBLER_NAME (decl) != DECL_NAME (decl))
7476 add_AT_string (die, DW_AT_MIPS_linkage_name,
7477 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
7481 /* Push a new declaration scope. */
7484 push_decl_scope (scope)
7487 /* Make room in the decl_scope_table, if necessary. */
7488 if (decl_scope_table_allocated == decl_scope_depth)
7490 decl_scope_table_allocated += DECL_SCOPE_TABLE_INCREMENT;
7492 = (tree *) xrealloc (decl_scope_table,
7493 decl_scope_table_allocated * sizeof (tree));
7496 decl_scope_table[decl_scope_depth] = scope;
7500 /* Pop a declaration scope. */
7504 if (decl_scope_depth <= 0)
7509 /* Return the DIE for the scope that immediately contains this type.
7510 Non-named types get global scope. Named types nested in other
7511 types get their containing scope if it's open, or global scope
7512 otherwise. All other types (i.e. function-local named types) get
7513 the current active scope. */
7516 scope_die_for (t, context_die)
7518 register dw_die_ref context_die;
7520 register dw_die_ref scope_die = NULL;
7521 register tree containing_scope;
7524 /* Non-types always go in the current scope. */
7528 containing_scope = TYPE_CONTEXT (t);
7530 /* Ignore namespaces for the moment. */
7531 if (containing_scope && TREE_CODE (containing_scope) == NAMESPACE_DECL)
7532 containing_scope = NULL_TREE;
7534 /* Ignore function type "scopes" from the C frontend. They mean that
7535 a tagged type is local to a parmlist of a function declarator, but
7536 that isn't useful to DWARF. */
7537 if (containing_scope && TREE_CODE (containing_scope) == FUNCTION_TYPE)
7538 containing_scope = NULL_TREE;
7540 if (containing_scope == NULL_TREE)
7541 scope_die = comp_unit_die;
7542 else if (TYPE_P (containing_scope))
7544 /* For types, we can just look up the appropriate DIE. But
7545 first we check to see if we're in the middle of emitting it
7546 so we know where the new DIE should go. */
7548 for (i = decl_scope_depth - 1; i >= 0; --i)
7549 if (decl_scope_table[i] == containing_scope)
7554 if (debug_info_level > DINFO_LEVEL_TERSE
7555 && !TREE_ASM_WRITTEN (containing_scope))
7558 /* If none of the current dies are suitable, we get file scope. */
7559 scope_die = comp_unit_die;
7562 scope_die = lookup_type_die (containing_scope);
7565 scope_die = context_die;
7570 /* Returns nonzero iff CONTEXT_DIE is internal to a function. */
7572 static inline int local_scope_p PARAMS ((dw_die_ref));
7574 local_scope_p (context_die)
7575 dw_die_ref context_die;
7577 for (; context_die; context_die = context_die->die_parent)
7578 if (context_die->die_tag == DW_TAG_inlined_subroutine
7579 || context_die->die_tag == DW_TAG_subprogram)
7584 /* Returns nonzero iff CONTEXT_DIE is a class. */
7586 static inline int class_scope_p PARAMS ((dw_die_ref));
7588 class_scope_p (context_die)
7589 dw_die_ref context_die;
7592 && (context_die->die_tag == DW_TAG_structure_type
7593 || context_die->die_tag == DW_TAG_union_type));
7596 /* Many forms of DIEs require a "type description" attribute. This
7597 routine locates the proper "type descriptor" die for the type given
7598 by 'type', and adds an DW_AT_type attribute below the given die. */
7601 add_type_attribute (object_die, type, decl_const, decl_volatile, context_die)
7602 register dw_die_ref object_die;
7604 register int decl_const;
7605 register int decl_volatile;
7606 register dw_die_ref context_die;
7608 register enum tree_code code = TREE_CODE (type);
7609 register dw_die_ref type_die = NULL;
7611 /* ??? If this type is an unnamed subrange type of an integral or
7612 floating-point type, use the inner type. This is because we have no
7613 support for unnamed types in base_type_die. This can happen if this is
7614 an Ada subrange type. Correct solution is emit a subrange type die. */
7615 if ((code == INTEGER_TYPE || code == REAL_TYPE)
7616 && TREE_TYPE (type) != 0 && TYPE_NAME (type) == 0)
7617 type = TREE_TYPE (type), code = TREE_CODE (type);
7619 if (code == ERROR_MARK)
7622 /* Handle a special case. For functions whose return type is void, we
7623 generate *no* type attribute. (Note that no object may have type
7624 `void', so this only applies to function return types). */
7625 if (code == VOID_TYPE)
7628 type_die = modified_type_die (type,
7629 decl_const || TYPE_READONLY (type),
7630 decl_volatile || TYPE_VOLATILE (type),
7632 if (type_die != NULL)
7633 add_AT_die_ref (object_die, DW_AT_type, type_die);
7636 /* Given a tree pointer to a struct, class, union, or enum type node, return
7637 a pointer to the (string) tag name for the given type, or zero if the type
7638 was declared without a tag. */
7644 register char *name = 0;
7646 if (TYPE_NAME (type) != 0)
7648 register tree t = 0;
7650 /* Find the IDENTIFIER_NODE for the type name. */
7651 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
7652 t = TYPE_NAME (type);
7654 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
7655 a TYPE_DECL node, regardless of whether or not a `typedef' was
7657 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
7658 && ! DECL_IGNORED_P (TYPE_NAME (type)))
7659 t = DECL_NAME (TYPE_NAME (type));
7661 /* Now get the name as a string, or invent one. */
7663 name = IDENTIFIER_POINTER (t);
7666 return (name == 0 || *name == '\0') ? 0 : name;
7669 /* Return the type associated with a data member, make a special check
7670 for bit field types. */
7673 member_declared_type (member)
7674 register tree member;
7676 return (DECL_BIT_FIELD_TYPE (member)
7677 ? DECL_BIT_FIELD_TYPE (member)
7678 : TREE_TYPE (member));
7681 /* Get the decl's label, as described by its RTL. This may be different
7682 from the DECL_NAME name used in the source file. */
7686 decl_start_label (decl)
7691 x = DECL_RTL (decl);
7692 if (GET_CODE (x) != MEM)
7696 if (GET_CODE (x) != SYMBOL_REF)
7699 fnname = XSTR (x, 0);
7704 /* These routines generate the internal representation of the DIE's for
7705 the compilation unit. Debugging information is collected by walking
7706 the declaration trees passed in from dwarf2out_decl(). */
7709 gen_array_type_die (type, context_die)
7711 register dw_die_ref context_die;
7713 register dw_die_ref scope_die = scope_die_for (type, context_die);
7714 register dw_die_ref array_die;
7715 register tree element_type;
7717 /* ??? The SGI dwarf reader fails for array of array of enum types unless
7718 the inner array type comes before the outer array type. Thus we must
7719 call gen_type_die before we call new_die. See below also. */
7720 #ifdef MIPS_DEBUGGING_INFO
7721 gen_type_die (TREE_TYPE (type), context_die);
7724 array_die = new_die (DW_TAG_array_type, scope_die);
7727 /* We default the array ordering. SDB will probably do
7728 the right things even if DW_AT_ordering is not present. It's not even
7729 an issue until we start to get into multidimensional arrays anyway. If
7730 SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
7731 then we'll have to put the DW_AT_ordering attribute back in. (But if
7732 and when we find out that we need to put these in, we will only do so
7733 for multidimensional arrays. */
7734 add_AT_unsigned (array_die, DW_AT_ordering, DW_ORD_row_major);
7737 #ifdef MIPS_DEBUGGING_INFO
7738 /* The SGI compilers handle arrays of unknown bound by setting
7739 AT_declaration and not emitting any subrange DIEs. */
7740 if (! TYPE_DOMAIN (type))
7741 add_AT_unsigned (array_die, DW_AT_declaration, 1);
7744 add_subscript_info (array_die, type);
7746 add_name_attribute (array_die, type_tag (type));
7747 equate_type_number_to_die (type, array_die);
7749 /* Add representation of the type of the elements of this array type. */
7750 element_type = TREE_TYPE (type);
7752 /* ??? The SGI dwarf reader fails for multidimensional arrays with a
7753 const enum type. E.g. const enum machine_mode insn_operand_mode[2][10].
7754 We work around this by disabling this feature. See also
7755 add_subscript_info. */
7756 #ifndef MIPS_DEBUGGING_INFO
7757 while (TREE_CODE (element_type) == ARRAY_TYPE)
7758 element_type = TREE_TYPE (element_type);
7760 gen_type_die (element_type, context_die);
7763 add_type_attribute (array_die, element_type, 0, 0, context_die);
7767 gen_set_type_die (type, context_die)
7769 register dw_die_ref context_die;
7771 register dw_die_ref type_die
7772 = new_die (DW_TAG_set_type, scope_die_for (type, context_die));
7774 equate_type_number_to_die (type, type_die);
7775 add_type_attribute (type_die, TREE_TYPE (type), 0, 0, context_die);
7780 gen_entry_point_die (decl, context_die)
7782 register dw_die_ref context_die;
7784 register tree origin = decl_ultimate_origin (decl);
7785 register dw_die_ref decl_die = new_die (DW_TAG_entry_point, context_die);
7787 add_abstract_origin_attribute (decl_die, origin);
7790 add_name_and_src_coords_attributes (decl_die, decl);
7791 add_type_attribute (decl_die, TREE_TYPE (TREE_TYPE (decl)),
7795 if (DECL_ABSTRACT (decl))
7796 equate_decl_number_to_die (decl, decl_die);
7798 add_AT_lbl_id (decl_die, DW_AT_low_pc, decl_start_label (decl));
7802 /* Remember a type in the incomplete_types_list. */
7805 add_incomplete_type (type)
7808 if (incomplete_types == incomplete_types_allocated)
7810 incomplete_types_allocated += INCOMPLETE_TYPES_INCREMENT;
7811 incomplete_types_list
7812 = (tree *) xrealloc (incomplete_types_list,
7813 sizeof (tree) * incomplete_types_allocated);
7816 incomplete_types_list[incomplete_types++] = type;
7819 /* Walk through the list of incomplete types again, trying once more to
7820 emit full debugging info for them. */
7823 retry_incomplete_types ()
7827 while (incomplete_types)
7830 type = incomplete_types_list[incomplete_types];
7831 gen_type_die (type, comp_unit_die);
7835 /* Generate a DIE to represent an inlined instance of an enumeration type. */
7838 gen_inlined_enumeration_type_die (type, context_die)
7840 register dw_die_ref context_die;
7842 register dw_die_ref type_die = new_die (DW_TAG_enumeration_type,
7844 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
7845 be incomplete and such types are not marked. */
7846 add_abstract_origin_attribute (type_die, type);
7849 /* Generate a DIE to represent an inlined instance of a structure type. */
7852 gen_inlined_structure_type_die (type, context_die)
7854 register dw_die_ref context_die;
7856 register dw_die_ref type_die = new_die (DW_TAG_structure_type, context_die);
7858 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
7859 be incomplete and such types are not marked. */
7860 add_abstract_origin_attribute (type_die, type);
7863 /* Generate a DIE to represent an inlined instance of a union type. */
7866 gen_inlined_union_type_die (type, context_die)
7868 register dw_die_ref context_die;
7870 register dw_die_ref type_die = new_die (DW_TAG_union_type, context_die);
7872 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
7873 be incomplete and such types are not marked. */
7874 add_abstract_origin_attribute (type_die, type);
7877 /* Generate a DIE to represent an enumeration type. Note that these DIEs
7878 include all of the information about the enumeration values also. Each
7879 enumerated type name/value is listed as a child of the enumerated type
7883 gen_enumeration_type_die (type, context_die)
7885 register dw_die_ref context_die;
7887 register dw_die_ref type_die = lookup_type_die (type);
7889 if (type_die == NULL)
7891 type_die = new_die (DW_TAG_enumeration_type,
7892 scope_die_for (type, context_die));
7893 equate_type_number_to_die (type, type_die);
7894 add_name_attribute (type_die, type_tag (type));
7896 else if (! TYPE_SIZE (type))
7899 remove_AT (type_die, DW_AT_declaration);
7901 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the
7902 given enum type is incomplete, do not generate the DW_AT_byte_size
7903 attribute or the DW_AT_element_list attribute. */
7904 if (TYPE_SIZE (type))
7908 TREE_ASM_WRITTEN (type) = 1;
7909 add_byte_size_attribute (type_die, type);
7910 if (TYPE_STUB_DECL (type) != NULL_TREE)
7911 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
7913 /* If the first reference to this type was as the return type of an
7914 inline function, then it may not have a parent. Fix this now. */
7915 if (type_die->die_parent == NULL)
7916 add_child_die (scope_die_for (type, context_die), type_die);
7918 for (link = TYPE_FIELDS (type);
7919 link != NULL; link = TREE_CHAIN (link))
7921 register dw_die_ref enum_die = new_die (DW_TAG_enumerator, type_die);
7923 add_name_attribute (enum_die,
7924 IDENTIFIER_POINTER (TREE_PURPOSE (link)));
7925 add_AT_unsigned (enum_die, DW_AT_const_value,
7926 (unsigned) TREE_INT_CST_LOW (TREE_VALUE (link)));
7930 add_AT_flag (type_die, DW_AT_declaration, 1);
7934 /* Generate a DIE to represent either a real live formal parameter decl or to
7935 represent just the type of some formal parameter position in some function
7938 Note that this routine is a bit unusual because its argument may be a
7939 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
7940 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
7941 node. If it's the former then this function is being called to output a
7942 DIE to represent a formal parameter object (or some inlining thereof). If
7943 it's the latter, then this function is only being called to output a
7944 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
7945 argument type of some subprogram type. */
7948 gen_formal_parameter_die (node, context_die)
7950 register dw_die_ref context_die;
7952 register dw_die_ref parm_die
7953 = new_die (DW_TAG_formal_parameter, context_die);
7954 register tree origin;
7956 switch (TREE_CODE_CLASS (TREE_CODE (node)))
7959 origin = decl_ultimate_origin (node);
7961 add_abstract_origin_attribute (parm_die, origin);
7964 add_name_and_src_coords_attributes (parm_die, node);
7965 add_type_attribute (parm_die, TREE_TYPE (node),
7966 TREE_READONLY (node),
7967 TREE_THIS_VOLATILE (node),
7969 if (DECL_ARTIFICIAL (node))
7970 add_AT_flag (parm_die, DW_AT_artificial, 1);
7973 equate_decl_number_to_die (node, parm_die);
7974 if (! DECL_ABSTRACT (node))
7975 add_location_or_const_value_attribute (parm_die, node);
7980 /* We were called with some kind of a ..._TYPE node. */
7981 add_type_attribute (parm_die, node, 0, 0, context_die);
7991 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
7992 at the end of an (ANSI prototyped) formal parameters list. */
7995 gen_unspecified_parameters_die (decl_or_type, context_die)
7996 register tree decl_or_type ATTRIBUTE_UNUSED;
7997 register dw_die_ref context_die;
7999 new_die (DW_TAG_unspecified_parameters, context_die);
8002 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
8003 DW_TAG_unspecified_parameters DIE) to represent the types of the formal
8004 parameters as specified in some function type specification (except for
8005 those which appear as part of a function *definition*).
8007 Note we must be careful here to output all of the parameter DIEs before*
8008 we output any DIEs needed to represent the types of the formal parameters.
8009 This keeps svr4 SDB happy because it (incorrectly) thinks that the first
8010 non-parameter DIE it sees ends the formal parameter list. */
8013 gen_formal_types_die (function_or_method_type, context_die)
8014 register tree function_or_method_type;
8015 register dw_die_ref context_die;
8018 register tree formal_type = NULL;
8019 register tree first_parm_type = TYPE_ARG_TYPES (function_or_method_type);
8022 /* In the case where we are generating a formal types list for a C++
8023 non-static member function type, skip over the first thing on the
8024 TYPE_ARG_TYPES list because it only represents the type of the hidden
8025 `this pointer'. The debugger should be able to figure out (without
8026 being explicitly told) that this non-static member function type takes a
8027 `this pointer' and should be able to figure what the type of that hidden
8028 parameter is from the DW_AT_member attribute of the parent
8029 DW_TAG_subroutine_type DIE. */
8030 if (TREE_CODE (function_or_method_type) == METHOD_TYPE)
8031 first_parm_type = TREE_CHAIN (first_parm_type);
8034 /* Make our first pass over the list of formal parameter types and output a
8035 DW_TAG_formal_parameter DIE for each one. */
8036 for (link = first_parm_type; link; link = TREE_CHAIN (link))
8038 register dw_die_ref parm_die;
8040 formal_type = TREE_VALUE (link);
8041 if (formal_type == void_type_node)
8044 /* Output a (nameless) DIE to represent the formal parameter itself. */
8045 parm_die = gen_formal_parameter_die (formal_type, context_die);
8046 if (TREE_CODE (function_or_method_type) == METHOD_TYPE
8047 && link == first_parm_type)
8048 add_AT_flag (parm_die, DW_AT_artificial, 1);
8051 /* If this function type has an ellipsis, add a
8052 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */
8053 if (formal_type != void_type_node)
8054 gen_unspecified_parameters_die (function_or_method_type, context_die);
8056 /* Make our second (and final) pass over the list of formal parameter types
8057 and output DIEs to represent those types (as necessary). */
8058 for (link = TYPE_ARG_TYPES (function_or_method_type);
8060 link = TREE_CHAIN (link))
8062 formal_type = TREE_VALUE (link);
8063 if (formal_type == void_type_node)
8066 gen_type_die (formal_type, context_die);
8070 /* We want to generate the DIE for TYPE so that we can generate the
8071 die for MEMBER, which has been defined; we will need to refer back
8072 to the member declaration nested within TYPE. If we're trying to
8073 generate minimal debug info for TYPE, processing TYPE won't do the
8074 trick; we need to attach the member declaration by hand. */
8077 gen_type_die_for_member (type, member, context_die)
8079 dw_die_ref context_die;
8081 gen_type_die (type, context_die);
8083 /* If we're trying to avoid duplicate debug info, we may not have
8084 emitted the member decl for this function. Emit it now. */
8085 if (TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))
8086 && ! lookup_decl_die (member))
8088 if (decl_ultimate_origin (member))
8091 push_decl_scope (type);
8092 if (TREE_CODE (member) == FUNCTION_DECL)
8093 gen_subprogram_die (member, lookup_type_die (type));
8095 gen_variable_die (member, lookup_type_die (type));
8100 /* Generate the DWARF2 info for the "abstract" instance
8101 of a function which we may later generate inlined and/or
8102 out-of-line instances of. */
8105 gen_abstract_function (decl)
8108 register dw_die_ref old_die = lookup_decl_die (decl);
8111 if (old_die && get_AT_unsigned (old_die, DW_AT_inline))
8112 /* We've already generated the abstract instance. */
8115 save_fn = current_function_decl;
8116 current_function_decl = decl;
8118 set_decl_abstract_flags (decl, 1);
8119 dwarf2out_decl (decl);
8120 set_decl_abstract_flags (decl, 0);
8122 current_function_decl = save_fn;
8125 /* Generate a DIE to represent a declared function (either file-scope or
8129 gen_subprogram_die (decl, context_die)
8131 register dw_die_ref context_die;
8133 char label_id[MAX_ARTIFICIAL_LABEL_BYTES];
8134 register tree origin = decl_ultimate_origin (decl);
8135 register dw_die_ref subr_die;
8136 register rtx fp_reg;
8137 register tree fn_arg_types;
8138 register tree outer_scope;
8139 register dw_die_ref old_die = lookup_decl_die (decl);
8140 register int declaration = (current_function_decl != decl
8141 || class_scope_p (context_die));
8143 /* Note that it is possible to have both DECL_ABSTRACT and `declaration'
8144 be true, if we started to generate the abstract instance of an inline,
8145 decided to output its containing class, and proceeded to emit the
8146 declaration of the inline from the member list for the class. In that
8147 case, `declaration' takes priority; we'll get back to the abstract
8148 instance when we're done with the class. */
8152 if (declaration && ! local_scope_p (context_die))
8155 subr_die = new_die (DW_TAG_subprogram, context_die);
8156 add_abstract_origin_attribute (subr_die, origin);
8158 else if (old_die && DECL_ABSTRACT (decl)
8159 && get_AT_unsigned (old_die, DW_AT_inline))
8161 /* This must be a redefinition of an extern inline function.
8162 We can just reuse the old die here. */
8165 /* Clear out the inlined attribute and parm types. */
8166 remove_AT (subr_die, DW_AT_inline);
8167 remove_children (subr_die);
8171 register unsigned file_index
8172 = lookup_filename (DECL_SOURCE_FILE (decl));
8174 if (get_AT_flag (old_die, DW_AT_declaration) != 1)
8176 /* ??? This can happen if there is a bug in the program, for
8177 instance, if it has duplicate function definitions. Ideally,
8178 we should detect this case and ignore it. For now, if we have
8179 already reported an error, any error at all, then assume that
8180 we got here because of a input error, not a dwarf2 bug. */
8186 /* If the definition comes from the same place as the declaration,
8187 maybe use the old DIE. We always want the DIE for this function
8188 that has the *_pc attributes to be under comp_unit_die so the
8189 debugger can find it. For inlines, that is the concrete instance,
8190 so we can use the old DIE here. For non-inline methods, we want a
8191 specification DIE at toplevel, so we need a new DIE. For local
8192 class methods, this doesn't apply; we just use the old DIE. */
8193 if ((DECL_ABSTRACT (decl) || old_die->die_parent == comp_unit_die
8194 || context_die == NULL)
8195 && (DECL_ARTIFICIAL (decl)
8196 || (get_AT_unsigned (old_die, DW_AT_decl_file) == file_index
8197 && (get_AT_unsigned (old_die, DW_AT_decl_line)
8198 == (unsigned)DECL_SOURCE_LINE (decl)))))
8202 /* Clear out the declaration attribute and the parm types. */
8203 remove_AT (subr_die, DW_AT_declaration);
8204 remove_children (subr_die);
8208 subr_die = new_die (DW_TAG_subprogram, context_die);
8209 add_AT_die_ref (subr_die, DW_AT_specification, old_die);
8210 if (get_AT_unsigned (old_die, DW_AT_decl_file) != file_index)
8211 add_AT_unsigned (subr_die, DW_AT_decl_file, file_index);
8212 if (get_AT_unsigned (old_die, DW_AT_decl_line)
8213 != (unsigned)DECL_SOURCE_LINE (decl))
8215 (subr_die, DW_AT_decl_line, DECL_SOURCE_LINE (decl));
8220 subr_die = new_die (DW_TAG_subprogram, context_die);
8222 if (TREE_PUBLIC (decl))
8223 add_AT_flag (subr_die, DW_AT_external, 1);
8225 add_name_and_src_coords_attributes (subr_die, decl);
8226 if (debug_info_level > DINFO_LEVEL_TERSE)
8228 register tree type = TREE_TYPE (decl);
8230 add_prototyped_attribute (subr_die, type);
8231 add_type_attribute (subr_die, TREE_TYPE (type), 0, 0, context_die);
8234 add_pure_or_virtual_attribute (subr_die, decl);
8235 if (DECL_ARTIFICIAL (decl))
8236 add_AT_flag (subr_die, DW_AT_artificial, 1);
8237 if (TREE_PROTECTED (decl))
8238 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_protected);
8239 else if (TREE_PRIVATE (decl))
8240 add_AT_unsigned (subr_die, DW_AT_accessibility, DW_ACCESS_private);
8246 add_AT_flag (subr_die, DW_AT_declaration, 1);
8248 /* The first time we see a member function, it is in the context of
8249 the class to which it belongs. We make sure of this by emitting
8250 the class first. The next time is the definition, which is
8251 handled above. The two may come from the same source text. */
8252 if (DECL_CONTEXT (decl) || DECL_ABSTRACT (decl))
8253 equate_decl_number_to_die (decl, subr_die);
8255 else if (DECL_ABSTRACT (decl))
8257 if (DECL_INLINE (decl) && !flag_no_inline)
8259 /* ??? Checking DECL_DEFER_OUTPUT is correct for static
8260 inline functions, but not for extern inline functions.
8261 We can't get this completely correct because information
8262 about whether the function was declared inline is not
8264 if (DECL_DEFER_OUTPUT (decl))
8265 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_inlined);
8267 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_inlined);
8270 add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_not_inlined);
8272 equate_decl_number_to_die (decl, subr_die);
8274 else if (!DECL_EXTERNAL (decl))
8276 if (origin == NULL_TREE)
8277 equate_decl_number_to_die (decl, subr_die);
8279 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_BEGIN_LABEL,
8280 current_funcdef_number);
8281 add_AT_lbl_id (subr_die, DW_AT_low_pc, label_id);
8282 ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
8283 current_funcdef_number);
8284 add_AT_lbl_id (subr_die, DW_AT_high_pc, label_id);
8286 add_pubname (decl, subr_die);
8287 add_arange (decl, subr_die);
8289 #ifdef MIPS_DEBUGGING_INFO
8290 /* Add a reference to the FDE for this routine. */
8291 add_AT_fde_ref (subr_die, DW_AT_MIPS_fde, current_funcdef_fde);
8294 /* Define the "frame base" location for this routine. We use the
8295 frame pointer or stack pointer registers, since the RTL for local
8296 variables is relative to one of them. */
8298 = frame_pointer_needed ? hard_frame_pointer_rtx : stack_pointer_rtx;
8299 add_AT_loc (subr_die, DW_AT_frame_base, reg_loc_descriptor (fp_reg));
8302 /* ??? This fails for nested inline functions, because context_display
8303 is not part of the state saved/restored for inline functions. */
8304 if (current_function_needs_context)
8305 add_AT_location_description (subr_die, DW_AT_static_link,
8306 lookup_static_chain (decl));
8310 /* Now output descriptions of the arguments for this function. This gets
8311 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
8312 for a FUNCTION_DECL doesn't indicate cases where there was a trailing
8313 `...' at the end of the formal parameter list. In order to find out if
8314 there was a trailing ellipsis or not, we must instead look at the type
8315 associated with the FUNCTION_DECL. This will be a node of type
8316 FUNCTION_TYPE. If the chain of type nodes hanging off of this
8317 FUNCTION_TYPE node ends with a void_type_node then there should *not* be
8318 an ellipsis at the end. */
8320 /* In the case where we are describing a mere function declaration, all we
8321 need to do here (and all we *can* do here) is to describe the *types* of
8322 its formal parameters. */
8323 if (debug_info_level <= DINFO_LEVEL_TERSE)
8325 else if (declaration)
8326 gen_formal_types_die (TREE_TYPE (decl), subr_die);
8329 /* Generate DIEs to represent all known formal parameters */
8330 register tree arg_decls = DECL_ARGUMENTS (decl);
8333 /* When generating DIEs, generate the unspecified_parameters DIE
8334 instead if we come across the arg "__builtin_va_alist" */
8335 for (parm = arg_decls; parm; parm = TREE_CHAIN (parm))
8336 if (TREE_CODE (parm) == PARM_DECL)
8338 if (DECL_NAME (parm)
8339 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (parm)),
8340 "__builtin_va_alist"))
8341 gen_unspecified_parameters_die (parm, subr_die);
8343 gen_decl_die (parm, subr_die);
8346 /* Decide whether we need a unspecified_parameters DIE at the end.
8347 There are 2 more cases to do this for: 1) the ansi ... declaration -
8348 this is detectable when the end of the arg list is not a
8349 void_type_node 2) an unprototyped function declaration (not a
8350 definition). This just means that we have no info about the
8351 parameters at all. */
8352 fn_arg_types = TYPE_ARG_TYPES (TREE_TYPE (decl));
8353 if (fn_arg_types != NULL)
8355 /* this is the prototyped case, check for ... */
8356 if (TREE_VALUE (tree_last (fn_arg_types)) != void_type_node)
8357 gen_unspecified_parameters_die (decl, subr_die);
8359 else if (DECL_INITIAL (decl) == NULL_TREE)
8360 gen_unspecified_parameters_die (decl, subr_die);
8363 /* Output Dwarf info for all of the stuff within the body of the function
8364 (if it has one - it may be just a declaration). */
8365 outer_scope = DECL_INITIAL (decl);
8367 /* Note that here, `outer_scope' is a pointer to the outermost BLOCK
8368 node created to represent a function. This outermost BLOCK actually
8369 represents the outermost binding contour for the function, i.e. the
8370 contour in which the function's formal parameters and labels get
8371 declared. Curiously, it appears that the front end doesn't actually
8372 put the PARM_DECL nodes for the current function onto the BLOCK_VARS
8373 list for this outer scope. (They are strung off of the DECL_ARGUMENTS
8374 list for the function instead.) The BLOCK_VARS list for the
8375 `outer_scope' does provide us with a list of the LABEL_DECL nodes for
8376 the function however, and we output DWARF info for those in
8377 decls_for_scope. Just within the `outer_scope' there will be a BLOCK
8378 node representing the function's outermost pair of curly braces, and
8379 any blocks used for the base and member initializers of a C++
8380 constructor function. */
8381 if (! declaration && TREE_CODE (outer_scope) != ERROR_MARK)
8383 current_function_has_inlines = 0;
8384 decls_for_scope (outer_scope, subr_die, 0);
8386 #if 0 && defined (MIPS_DEBUGGING_INFO)
8387 if (current_function_has_inlines)
8389 add_AT_flag (subr_die, DW_AT_MIPS_has_inlines, 1);
8390 if (! comp_unit_has_inlines)
8392 add_AT_flag (comp_unit_die, DW_AT_MIPS_has_inlines, 1);
8393 comp_unit_has_inlines = 1;
8400 /* Generate a DIE to represent a declared data object. */
8403 gen_variable_die (decl, context_die)
8405 register dw_die_ref context_die;
8407 register tree origin = decl_ultimate_origin (decl);
8408 register dw_die_ref var_die = new_die (DW_TAG_variable, context_die);
8410 dw_die_ref old_die = lookup_decl_die (decl);
8411 int declaration = (DECL_EXTERNAL (decl)
8412 || class_scope_p (context_die));
8415 add_abstract_origin_attribute (var_die, origin);
8416 /* Loop unrolling can create multiple blocks that refer to the same
8417 static variable, so we must test for the DW_AT_declaration flag. */
8418 /* ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
8419 copy decls and set the DECL_ABSTRACT flag on them instead of
8421 else if (old_die && TREE_STATIC (decl)
8422 && get_AT_flag (old_die, DW_AT_declaration) == 1)
8424 /* This is a definition of a C++ class level static. */
8425 add_AT_die_ref (var_die, DW_AT_specification, old_die);
8426 if (DECL_NAME (decl))
8428 register unsigned file_index
8429 = lookup_filename (DECL_SOURCE_FILE (decl));
8431 if (get_AT_unsigned (old_die, DW_AT_decl_file) != file_index)
8432 add_AT_unsigned (var_die, DW_AT_decl_file, file_index);
8434 if (get_AT_unsigned (old_die, DW_AT_decl_line)
8435 != (unsigned)DECL_SOURCE_LINE (decl))
8437 add_AT_unsigned (var_die, DW_AT_decl_line,
8438 DECL_SOURCE_LINE (decl));
8443 add_name_and_src_coords_attributes (var_die, decl);
8444 add_type_attribute (var_die, TREE_TYPE (decl),
8445 TREE_READONLY (decl),
8446 TREE_THIS_VOLATILE (decl), context_die);
8448 if (TREE_PUBLIC (decl))
8449 add_AT_flag (var_die, DW_AT_external, 1);
8451 if (DECL_ARTIFICIAL (decl))
8452 add_AT_flag (var_die, DW_AT_artificial, 1);
8454 if (TREE_PROTECTED (decl))
8455 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_protected);
8457 else if (TREE_PRIVATE (decl))
8458 add_AT_unsigned (var_die, DW_AT_accessibility, DW_ACCESS_private);
8462 add_AT_flag (var_die, DW_AT_declaration, 1);
8464 if (class_scope_p (context_die) || DECL_ABSTRACT (decl))
8465 equate_decl_number_to_die (decl, var_die);
8467 if (! declaration && ! DECL_ABSTRACT (decl))
8469 add_location_or_const_value_attribute (var_die, decl);
8470 add_pubname (decl, var_die);
8474 /* Generate a DIE to represent a label identifier. */
8477 gen_label_die (decl, context_die)
8479 register dw_die_ref context_die;
8481 register tree origin = decl_ultimate_origin (decl);
8482 register dw_die_ref lbl_die = new_die (DW_TAG_label, context_die);
8484 char label[MAX_ARTIFICIAL_LABEL_BYTES];
8485 char label2[MAX_ARTIFICIAL_LABEL_BYTES];
8488 add_abstract_origin_attribute (lbl_die, origin);
8490 add_name_and_src_coords_attributes (lbl_die, decl);
8492 if (DECL_ABSTRACT (decl))
8493 equate_decl_number_to_die (decl, lbl_die);
8496 insn = DECL_RTL (decl);
8498 /* Deleted labels are programmer specified labels which have been
8499 eliminated because of various optimisations. We still emit them
8500 here so that it is possible to put breakpoints on them. */
8501 if (GET_CODE (insn) == CODE_LABEL
8502 || ((GET_CODE (insn) == NOTE
8503 && NOTE_LINE_NUMBER (insn) == NOTE_INSN_DELETED_LABEL)))
8505 /* When optimization is enabled (via -O) some parts of the compiler
8506 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
8507 represent source-level labels which were explicitly declared by
8508 the user. This really shouldn't be happening though, so catch
8509 it if it ever does happen. */
8510 if (INSN_DELETED_P (insn))
8513 sprintf (label2, INSN_LABEL_FMT, current_funcdef_number);
8514 ASM_GENERATE_INTERNAL_LABEL (label, label2,
8515 (unsigned) INSN_UID (insn));
8516 add_AT_lbl_id (lbl_die, DW_AT_low_pc, label);
8521 /* Generate a DIE for a lexical block. */
8524 gen_lexical_block_die (stmt, context_die, depth)
8526 register dw_die_ref context_die;
8529 register dw_die_ref stmt_die = new_die (DW_TAG_lexical_block, context_die);
8530 char label[MAX_ARTIFICIAL_LABEL_BYTES];
8532 if (! BLOCK_ABSTRACT (stmt))
8534 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
8536 add_AT_lbl_id (stmt_die, DW_AT_low_pc, label);
8537 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL, next_block_number);
8538 add_AT_lbl_id (stmt_die, DW_AT_high_pc, label);
8541 decls_for_scope (stmt, stmt_die, depth);
8544 /* Generate a DIE for an inlined subprogram. */
8547 gen_inlined_subroutine_die (stmt, context_die, depth)
8549 register dw_die_ref context_die;
8552 if (! BLOCK_ABSTRACT (stmt))
8554 register dw_die_ref subr_die
8555 = new_die (DW_TAG_inlined_subroutine, context_die);
8556 register tree decl = block_ultimate_origin (stmt);
8557 char label[MAX_ARTIFICIAL_LABEL_BYTES];
8559 /* Emit info for the abstract instance first, if we haven't yet. */
8560 gen_abstract_function (decl);
8562 add_abstract_origin_attribute (subr_die, decl);
8563 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_BEGIN_LABEL,
8565 add_AT_lbl_id (subr_die, DW_AT_low_pc, label);
8566 ASM_GENERATE_INTERNAL_LABEL (label, BLOCK_END_LABEL, next_block_number);
8567 add_AT_lbl_id (subr_die, DW_AT_high_pc, label);
8568 decls_for_scope (stmt, subr_die, depth);
8569 current_function_has_inlines = 1;
8573 /* Generate a DIE for a field in a record, or structure. */
8576 gen_field_die (decl, context_die)
8578 register dw_die_ref context_die;
8580 register dw_die_ref decl_die = new_die (DW_TAG_member, context_die);
8582 add_name_and_src_coords_attributes (decl_die, decl);
8583 add_type_attribute (decl_die, member_declared_type (decl),
8584 TREE_READONLY (decl), TREE_THIS_VOLATILE (decl),
8587 /* If this is a bit field... */
8588 if (DECL_BIT_FIELD_TYPE (decl))
8590 add_byte_size_attribute (decl_die, decl);
8591 add_bit_size_attribute (decl_die, decl);
8592 add_bit_offset_attribute (decl_die, decl);
8595 if (TREE_CODE (DECL_FIELD_CONTEXT (decl)) != UNION_TYPE)
8596 add_data_member_location_attribute (decl_die, decl);
8598 if (DECL_ARTIFICIAL (decl))
8599 add_AT_flag (decl_die, DW_AT_artificial, 1);
8601 if (TREE_PROTECTED (decl))
8602 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_protected);
8604 else if (TREE_PRIVATE (decl))
8605 add_AT_unsigned (decl_die, DW_AT_accessibility, DW_ACCESS_private);
8609 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
8610 Use modified_type_die instead.
8611 We keep this code here just in case these types of DIEs may be needed to
8612 represent certain things in other languages (e.g. Pascal) someday. */
8614 gen_pointer_type_die (type, context_die)
8616 register dw_die_ref context_die;
8618 register dw_die_ref ptr_die
8619 = new_die (DW_TAG_pointer_type, scope_die_for (type, context_die));
8621 equate_type_number_to_die (type, ptr_die);
8622 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
8623 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
8626 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
8627 Use modified_type_die instead.
8628 We keep this code here just in case these types of DIEs may be needed to
8629 represent certain things in other languages (e.g. Pascal) someday. */
8631 gen_reference_type_die (type, context_die)
8633 register dw_die_ref context_die;
8635 register dw_die_ref ref_die
8636 = new_die (DW_TAG_reference_type, scope_die_for (type, context_die));
8638 equate_type_number_to_die (type, ref_die);
8639 add_type_attribute (ref_die, TREE_TYPE (type), 0, 0, context_die);
8640 add_AT_unsigned (mod_type_die, DW_AT_byte_size, PTR_SIZE);
8644 /* Generate a DIE for a pointer to a member type. */
8646 gen_ptr_to_mbr_type_die (type, context_die)
8648 register dw_die_ref context_die;
8650 register dw_die_ref ptr_die
8651 = new_die (DW_TAG_ptr_to_member_type, scope_die_for (type, context_die));
8653 equate_type_number_to_die (type, ptr_die);
8654 add_AT_die_ref (ptr_die, DW_AT_containing_type,
8655 lookup_type_die (TYPE_OFFSET_BASETYPE (type)));
8656 add_type_attribute (ptr_die, TREE_TYPE (type), 0, 0, context_die);
8659 /* Generate the DIE for the compilation unit. */
8662 gen_compile_unit_die (filename)
8663 register const char *filename;
8665 register dw_die_ref die;
8667 char *wd = getpwd ();
8670 die = new_die (DW_TAG_compile_unit, NULL);
8671 add_name_attribute (die, filename);
8673 if (wd != NULL && filename[0] != DIR_SEPARATOR)
8674 add_AT_string (die, DW_AT_comp_dir, wd);
8676 sprintf (producer, "%s %s", language_string, version_string);
8678 #ifdef MIPS_DEBUGGING_INFO
8679 /* The MIPS/SGI compilers place the 'cc' command line options in the producer
8680 string. The SGI debugger looks for -g, -g1, -g2, or -g3; if they do
8681 not appear in the producer string, the debugger reaches the conclusion
8682 that the object file is stripped and has no debugging information.
8683 To get the MIPS/SGI debugger to believe that there is debugging
8684 information in the object file, we add a -g to the producer string. */
8685 if (debug_info_level > DINFO_LEVEL_TERSE)
8686 strcat (producer, " -g");
8689 add_AT_string (die, DW_AT_producer, producer);
8691 if (strcmp (language_string, "GNU C++") == 0)
8692 language = DW_LANG_C_plus_plus;
8693 else if (strcmp (language_string, "GNU Ada") == 0)
8694 language = DW_LANG_Ada83;
8695 else if (strcmp (language_string, "GNU F77") == 0)
8696 language = DW_LANG_Fortran77;
8697 else if (strcmp (language_string, "GNU Pascal") == 0)
8698 language = DW_LANG_Pascal83;
8699 else if (flag_traditional)
8700 language = DW_LANG_C;
8702 language = DW_LANG_C89;
8704 add_AT_unsigned (die, DW_AT_language, language);
8709 /* Generate a DIE for a string type. */
8712 gen_string_type_die (type, context_die)
8714 register dw_die_ref context_die;
8716 register dw_die_ref type_die
8717 = new_die (DW_TAG_string_type, scope_die_for (type, context_die));
8719 equate_type_number_to_die (type, type_die);
8721 /* Fudge the string length attribute for now. */
8723 /* TODO: add string length info.
8724 string_length_attribute (TYPE_MAX_VALUE (TYPE_DOMAIN (type)));
8725 bound_representation (upper_bound, 0, 'u'); */
8728 /* Generate the DIE for a base class. */
8731 gen_inheritance_die (binfo, context_die)
8732 register tree binfo;
8733 register dw_die_ref context_die;
8735 dw_die_ref die = new_die (DW_TAG_inheritance, context_die);
8737 add_type_attribute (die, BINFO_TYPE (binfo), 0, 0, context_die);
8738 add_data_member_location_attribute (die, binfo);
8740 if (TREE_VIA_VIRTUAL (binfo))
8741 add_AT_unsigned (die, DW_AT_virtuality, DW_VIRTUALITY_virtual);
8742 if (TREE_VIA_PUBLIC (binfo))
8743 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_public);
8744 else if (TREE_VIA_PROTECTED (binfo))
8745 add_AT_unsigned (die, DW_AT_accessibility, DW_ACCESS_protected);
8748 /* Generate a DIE for a class member. */
8751 gen_member_die (type, context_die)
8753 register dw_die_ref context_die;
8755 register tree member;
8758 /* If this is not an incomplete type, output descriptions of each of its
8759 members. Note that as we output the DIEs necessary to represent the
8760 members of this record or union type, we will also be trying to output
8761 DIEs to represent the *types* of those members. However the `type'
8762 function (above) will specifically avoid generating type DIEs for member
8763 types *within* the list of member DIEs for this (containing) type execpt
8764 for those types (of members) which are explicitly marked as also being
8765 members of this (containing) type themselves. The g++ front- end can
8766 force any given type to be treated as a member of some other
8767 (containing) type by setting the TYPE_CONTEXT of the given (member) type
8768 to point to the TREE node representing the appropriate (containing)
8771 /* First output info about the base classes. */
8772 if (TYPE_BINFO (type) && TYPE_BINFO_BASETYPES (type))
8774 register tree bases = TYPE_BINFO_BASETYPES (type);
8775 register int n_bases = TREE_VEC_LENGTH (bases);
8778 for (i = 0; i < n_bases; i++)
8779 gen_inheritance_die (TREE_VEC_ELT (bases, i), context_die);
8782 /* Now output info about the data members and type members. */
8783 for (member = TYPE_FIELDS (type); member; member = TREE_CHAIN (member))
8785 /* If we thought we were generating minimal debug info for TYPE
8786 and then changed our minds, some of the member declarations
8787 may have already been defined. Don't define them again, but
8788 do put them in the right order. */
8790 child = lookup_decl_die (member);
8792 splice_child_die (context_die, child);
8794 gen_decl_die (member, context_die);
8797 /* Now output info about the function members (if any). */
8798 for (member = TYPE_METHODS (type); member; member = TREE_CHAIN (member))
8800 child = lookup_decl_die (member);
8802 splice_child_die (context_die, child);
8804 gen_decl_die (member, context_die);
8808 /* Generate a DIE for a structure or union type. If TYPE_DECL_SUPPRESS_DEBUG
8809 is set, we pretend that the type was never defined, so we only get the
8810 member DIEs needed by later specification DIEs. */
8813 gen_struct_or_union_type_die (type, context_die)
8815 register dw_die_ref context_die;
8817 register dw_die_ref type_die = lookup_type_die (type);
8818 register dw_die_ref scope_die = 0;
8819 register int nested = 0;
8820 int complete = (TYPE_SIZE (type)
8821 && (! TYPE_STUB_DECL (type)
8822 || ! TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (type))));
8824 if (type_die && ! complete)
8827 if (TYPE_CONTEXT (type) != NULL_TREE
8828 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type)))
8831 scope_die = scope_die_for (type, context_die);
8833 if (! type_die || (nested && scope_die == comp_unit_die))
8834 /* First occurrence of type or toplevel definition of nested class. */
8836 register dw_die_ref old_die = type_die;
8838 type_die = new_die (TREE_CODE (type) == RECORD_TYPE
8839 ? DW_TAG_structure_type : DW_TAG_union_type,
8841 equate_type_number_to_die (type, type_die);
8842 add_name_attribute (type_die, type_tag (type));
8844 add_AT_die_ref (type_die, DW_AT_specification, old_die);
8847 remove_AT (type_die, DW_AT_declaration);
8849 /* If this type has been completed, then give it a byte_size attribute and
8850 then give a list of members. */
8853 /* Prevent infinite recursion in cases where the type of some member of
8854 this type is expressed in terms of this type itself. */
8855 TREE_ASM_WRITTEN (type) = 1;
8856 add_byte_size_attribute (type_die, type);
8857 if (TYPE_STUB_DECL (type) != NULL_TREE)
8858 add_src_coords_attributes (type_die, TYPE_STUB_DECL (type));
8860 /* If the first reference to this type was as the return type of an
8861 inline function, then it may not have a parent. Fix this now. */
8862 if (type_die->die_parent == NULL)
8863 add_child_die (scope_die, type_die);
8865 push_decl_scope (type);
8866 gen_member_die (type, type_die);
8869 /* GNU extension: Record what type our vtable lives in. */
8870 if (TYPE_VFIELD (type))
8872 tree vtype = DECL_FCONTEXT (TYPE_VFIELD (type));
8874 gen_type_die (vtype, context_die);
8875 add_AT_die_ref (type_die, DW_AT_containing_type,
8876 lookup_type_die (vtype));
8881 add_AT_flag (type_die, DW_AT_declaration, 1);
8883 /* We don't need to do this for function-local types. */
8885 add_incomplete_type (type);
8889 /* Generate a DIE for a subroutine _type_. */
8892 gen_subroutine_type_die (type, context_die)
8894 register dw_die_ref context_die;
8896 register tree return_type = TREE_TYPE (type);
8897 register dw_die_ref subr_die
8898 = new_die (DW_TAG_subroutine_type, scope_die_for (type, context_die));
8900 equate_type_number_to_die (type, subr_die);
8901 add_prototyped_attribute (subr_die, type);
8902 add_type_attribute (subr_die, return_type, 0, 0, context_die);
8903 gen_formal_types_die (type, subr_die);
8906 /* Generate a DIE for a type definition */
8909 gen_typedef_die (decl, context_die)
8911 register dw_die_ref context_die;
8913 register dw_die_ref type_die;
8914 register tree origin;
8916 if (TREE_ASM_WRITTEN (decl))
8918 TREE_ASM_WRITTEN (decl) = 1;
8920 type_die = new_die (DW_TAG_typedef, context_die);
8921 origin = decl_ultimate_origin (decl);
8923 add_abstract_origin_attribute (type_die, origin);
8927 add_name_and_src_coords_attributes (type_die, decl);
8928 if (DECL_ORIGINAL_TYPE (decl))
8930 type = DECL_ORIGINAL_TYPE (decl);
8931 equate_type_number_to_die (TREE_TYPE (decl), type_die);
8934 type = TREE_TYPE (decl);
8935 add_type_attribute (type_die, type, TREE_READONLY (decl),
8936 TREE_THIS_VOLATILE (decl), context_die);
8939 if (DECL_ABSTRACT (decl))
8940 equate_decl_number_to_die (decl, type_die);
8943 /* Generate a type description DIE. */
8946 gen_type_die (type, context_die)
8948 register dw_die_ref context_die;
8952 if (type == NULL_TREE || type == error_mark_node)
8955 /* We are going to output a DIE to represent the unqualified version of
8956 this type (i.e. without any const or volatile qualifiers) so get the
8957 main variant (i.e. the unqualified version) of this type now. */
8958 type = type_main_variant (type);
8960 if (TREE_ASM_WRITTEN (type))
8963 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
8964 && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
8966 TREE_ASM_WRITTEN (type) = 1;
8967 gen_decl_die (TYPE_NAME (type), context_die);
8971 switch (TREE_CODE (type))
8977 case REFERENCE_TYPE:
8978 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This
8979 ensures that the gen_type_die recursion will terminate even if the
8980 type is recursive. Recursive types are possible in Ada. */
8981 /* ??? We could perhaps do this for all types before the switch
8983 TREE_ASM_WRITTEN (type) = 1;
8985 /* For these types, all that is required is that we output a DIE (or a
8986 set of DIEs) to represent the "basis" type. */
8987 gen_type_die (TREE_TYPE (type), context_die);
8991 /* This code is used for C++ pointer-to-data-member types.
8992 Output a description of the relevant class type. */
8993 gen_type_die (TYPE_OFFSET_BASETYPE (type), context_die);
8995 /* Output a description of the type of the object pointed to. */
8996 gen_type_die (TREE_TYPE (type), context_die);
8998 /* Now output a DIE to represent this pointer-to-data-member type
9000 gen_ptr_to_mbr_type_die (type, context_die);
9004 gen_type_die (TYPE_DOMAIN (type), context_die);
9005 gen_set_type_die (type, context_die);
9009 gen_type_die (TREE_TYPE (type), context_die);
9010 abort (); /* No way to represent these in Dwarf yet! */
9014 /* Force out return type (in case it wasn't forced out already). */
9015 gen_type_die (TREE_TYPE (type), context_die);
9016 gen_subroutine_type_die (type, context_die);
9020 /* Force out return type (in case it wasn't forced out already). */
9021 gen_type_die (TREE_TYPE (type), context_die);
9022 gen_subroutine_type_die (type, context_die);
9026 if (TYPE_STRING_FLAG (type) && TREE_CODE (TREE_TYPE (type)) == CHAR_TYPE)
9028 gen_type_die (TREE_TYPE (type), context_die);
9029 gen_string_type_die (type, context_die);
9032 gen_array_type_die (type, context_die);
9038 case QUAL_UNION_TYPE:
9039 /* If this is a nested type whose containing class hasn't been
9040 written out yet, writing it out will cover this one, too.
9041 This does not apply to instantiations of member class templates;
9042 they need to be added to the containing class as they are
9043 generated. FIXME: This hurts the idea of combining type decls
9044 from multiple TUs, since we can't predict what set of template
9045 instantiations we'll get. */
9046 if (TYPE_CONTEXT (type)
9047 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type))
9048 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type)))
9050 gen_type_die (TYPE_CONTEXT (type), context_die);
9052 if (TREE_ASM_WRITTEN (type))
9055 /* If that failed, attach ourselves to the stub. */
9056 push_decl_scope (TYPE_CONTEXT (type));
9057 context_die = lookup_type_die (TYPE_CONTEXT (type));
9063 if (TREE_CODE (type) == ENUMERAL_TYPE)
9064 gen_enumeration_type_die (type, context_die);
9066 gen_struct_or_union_type_die (type, context_die);
9071 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
9072 it up if it is ever completed. gen_*_type_die will set it for us
9073 when appropriate. */
9082 /* No DIEs needed for fundamental types. */
9086 /* No Dwarf representation currently defined. */
9093 TREE_ASM_WRITTEN (type) = 1;
9096 /* Generate a DIE for a tagged type instantiation. */
9099 gen_tagged_type_instantiation_die (type, context_die)
9101 register dw_die_ref context_die;
9103 if (type == NULL_TREE || type == error_mark_node)
9106 /* We are going to output a DIE to represent the unqualified version of
9107 this type (i.e. without any const or volatile qualifiers) so make sure
9108 that we have the main variant (i.e. the unqualified version) of this
9110 if (type != type_main_variant (type))
9113 /* Do not check TREE_ASM_WRITTEN (type) as it may not be set if this is
9114 an instance of an unresolved type. */
9116 switch (TREE_CODE (type))
9122 gen_inlined_enumeration_type_die (type, context_die);
9126 gen_inlined_structure_type_die (type, context_die);
9130 case QUAL_UNION_TYPE:
9131 gen_inlined_union_type_die (type, context_die);
9139 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
9140 things which are local to the given block. */
9143 gen_block_die (stmt, context_die, depth)
9145 register dw_die_ref context_die;
9148 register int must_output_die = 0;
9149 register tree origin;
9151 register enum tree_code origin_code;
9153 /* Ignore blocks never really used to make RTL. */
9155 if (stmt == NULL_TREE || !TREE_USED (stmt))
9158 /* Determine the "ultimate origin" of this block. This block may be an
9159 inlined instance of an inlined instance of inline function, so we have
9160 to trace all of the way back through the origin chain to find out what
9161 sort of node actually served as the original seed for the creation of
9162 the current block. */
9163 origin = block_ultimate_origin (stmt);
9164 origin_code = (origin != NULL) ? TREE_CODE (origin) : ERROR_MARK;
9166 /* Determine if we need to output any Dwarf DIEs at all to represent this
9168 if (origin_code == FUNCTION_DECL)
9169 /* The outer scopes for inlinings *must* always be represented. We
9170 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */
9171 must_output_die = 1;
9174 /* In the case where the current block represents an inlining of the
9175 "body block" of an inline function, we must *NOT* output any DIE for
9176 this block because we have already output a DIE to represent the
9177 whole inlined function scope and the "body block" of any function
9178 doesn't really represent a different scope according to ANSI C
9179 rules. So we check here to make sure that this block does not
9180 represent a "body block inlining" before trying to set the
9181 `must_output_die' flag. */
9182 if (! is_body_block (origin ? origin : stmt))
9184 /* Determine if this block directly contains any "significant"
9185 local declarations which we will need to output DIEs for. */
9186 if (debug_info_level > DINFO_LEVEL_TERSE)
9187 /* We are not in terse mode so *any* local declaration counts
9188 as being a "significant" one. */
9189 must_output_die = (BLOCK_VARS (stmt) != NULL);
9191 /* We are in terse mode, so only local (nested) function
9192 definitions count as "significant" local declarations. */
9193 for (decl = BLOCK_VARS (stmt);
9194 decl != NULL; decl = TREE_CHAIN (decl))
9195 if (TREE_CODE (decl) == FUNCTION_DECL
9196 && DECL_INITIAL (decl))
9198 must_output_die = 1;
9204 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
9205 DIE for any block which contains no significant local declarations at
9206 all. Rather, in such cases we just call `decls_for_scope' so that any
9207 needed Dwarf info for any sub-blocks will get properly generated. Note
9208 that in terse mode, our definition of what constitutes a "significant"
9209 local declaration gets restricted to include only inlined function
9210 instances and local (nested) function definitions. */
9211 if (must_output_die)
9213 if (origin_code == FUNCTION_DECL)
9214 gen_inlined_subroutine_die (stmt, context_die, depth);
9216 gen_lexical_block_die (stmt, context_die, depth);
9219 decls_for_scope (stmt, context_die, depth);
9222 /* Generate all of the decls declared within a given scope and (recursively)
9223 all of its sub-blocks. */
9226 decls_for_scope (stmt, context_die, depth)
9228 register dw_die_ref context_die;
9232 register tree subblocks;
9234 /* Ignore blocks never really used to make RTL. */
9235 if (stmt == NULL_TREE || ! TREE_USED (stmt))
9238 if (!BLOCK_ABSTRACT (stmt) && depth > 0)
9239 next_block_number++;
9241 /* Output the DIEs to represent all of the data objects and typedefs
9242 declared directly within this block but not within any nested
9243 sub-blocks. Also, nested function and tag DIEs have been
9244 generated with a parent of NULL; fix that up now. */
9245 for (decl = BLOCK_VARS (stmt);
9246 decl != NULL; decl = TREE_CHAIN (decl))
9248 register dw_die_ref die;
9250 if (TREE_CODE (decl) == FUNCTION_DECL)
9251 die = lookup_decl_die (decl);
9252 else if (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl))
9253 die = lookup_type_die (TREE_TYPE (decl));
9257 if (die != NULL && die->die_parent == NULL)
9258 add_child_die (context_die, die);
9260 gen_decl_die (decl, context_die);
9263 /* Output the DIEs to represent all sub-blocks (and the items declared
9264 therein) of this block. */
9265 for (subblocks = BLOCK_SUBBLOCKS (stmt);
9267 subblocks = BLOCK_CHAIN (subblocks))
9268 gen_block_die (subblocks, context_die, depth + 1);
9271 /* Is this a typedef we can avoid emitting? */
9274 is_redundant_typedef (decl)
9277 if (TYPE_DECL_IS_STUB (decl))
9280 if (DECL_ARTIFICIAL (decl)
9281 && DECL_CONTEXT (decl)
9282 && is_tagged_type (DECL_CONTEXT (decl))
9283 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl))) == TYPE_DECL
9284 && DECL_NAME (decl) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl))))
9285 /* Also ignore the artificial member typedef for the class name. */
9291 /* Generate Dwarf debug information for a decl described by DECL. */
9294 gen_decl_die (decl, context_die)
9296 register dw_die_ref context_die;
9298 register tree origin;
9300 if (TREE_CODE (decl) == ERROR_MARK)
9303 /* If this ..._DECL node is marked to be ignored, then ignore it. But don't
9304 ignore a function definition, since that would screw up our count of
9305 blocks, and that in turn will completely screw up the labels we will
9306 reference in subsequent DW_AT_low_pc and DW_AT_high_pc attributes (for
9307 subsequent blocks). */
9308 if (DECL_IGNORED_P (decl) && TREE_CODE (decl) != FUNCTION_DECL)
9311 switch (TREE_CODE (decl))
9314 /* The individual enumerators of an enum type get output when we output
9315 the Dwarf representation of the relevant enum type itself. */
9319 /* Don't output any DIEs to represent mere function declarations,
9320 unless they are class members or explicit block externs. */
9321 if (DECL_INITIAL (decl) == NULL_TREE && DECL_CONTEXT (decl) == NULL_TREE
9322 && (current_function_decl == NULL_TREE || DECL_ARTIFICIAL (decl)))
9325 /* Emit info for the abstract instance first, if we haven't yet. */
9326 origin = decl_ultimate_origin (decl);
9328 gen_abstract_function (origin);
9330 if (debug_info_level > DINFO_LEVEL_TERSE)
9332 /* Before we describe the FUNCTION_DECL itself, make sure that we
9333 have described its return type. */
9334 gen_type_die (TREE_TYPE (TREE_TYPE (decl)), context_die);
9336 /* And its virtual context. */
9337 if (DECL_VINDEX (decl) != NULL_TREE)
9338 gen_type_die (DECL_CONTEXT (decl), context_die);
9340 /* And its containing type. */
9341 origin = decl_class_context (decl);
9342 if (origin != NULL_TREE)
9343 gen_type_die_for_member (origin, decl, context_die);
9346 /* Now output a DIE to represent the function itself. */
9347 gen_subprogram_die (decl, context_die);
9351 /* If we are in terse mode, don't generate any DIEs to represent any
9353 if (debug_info_level <= DINFO_LEVEL_TERSE)
9356 /* In the special case of a TYPE_DECL node representing the
9357 declaration of some type tag, if the given TYPE_DECL is marked as
9358 having been instantiated from some other (original) TYPE_DECL node
9359 (e.g. one which was generated within the original definition of an
9360 inline function) we have to generate a special (abbreviated)
9361 DW_TAG_structure_type, DW_TAG_union_type, or DW_TAG_enumeration_type
9363 if (TYPE_DECL_IS_STUB (decl) && decl_ultimate_origin (decl) != NULL_TREE)
9365 gen_tagged_type_instantiation_die (TREE_TYPE (decl), context_die);
9369 if (is_redundant_typedef (decl))
9370 gen_type_die (TREE_TYPE (decl), context_die);
9372 /* Output a DIE to represent the typedef itself. */
9373 gen_typedef_die (decl, context_die);
9377 if (debug_info_level >= DINFO_LEVEL_NORMAL)
9378 gen_label_die (decl, context_die);
9382 /* If we are in terse mode, don't generate any DIEs to represent any
9383 variable declarations or definitions. */
9384 if (debug_info_level <= DINFO_LEVEL_TERSE)
9387 /* Output any DIEs that are needed to specify the type of this data
9389 gen_type_die (TREE_TYPE (decl), context_die);
9391 /* And its containing type. */
9392 origin = decl_class_context (decl);
9393 if (origin != NULL_TREE)
9394 gen_type_die_for_member (origin, decl, context_die);
9396 /* Now output the DIE to represent the data object itself. This gets
9397 complicated because of the possibility that the VAR_DECL really
9398 represents an inlined instance of a formal parameter for an inline
9400 origin = decl_ultimate_origin (decl);
9401 if (origin != NULL_TREE && TREE_CODE (origin) == PARM_DECL)
9402 gen_formal_parameter_die (decl, context_die);
9404 gen_variable_die (decl, context_die);
9408 /* Ignore the nameless fields that are used to skip bits, but
9409 handle C++ anonymous unions. */
9410 if (DECL_NAME (decl) != NULL_TREE
9411 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE)
9413 gen_type_die (member_declared_type (decl), context_die);
9414 gen_field_die (decl, context_die);
9419 gen_type_die (TREE_TYPE (decl), context_die);
9420 gen_formal_parameter_die (decl, context_die);
9423 case NAMESPACE_DECL:
9424 /* Ignore for now. */
9432 /* Add Ada "use" clause information for SGI Workshop debugger. */
9435 dwarf2out_add_library_unit_info (filename, context_list)
9436 const char *filename;
9437 const char *context_list;
9439 unsigned int file_index;
9441 if (filename != NULL)
9443 dw_die_ref unit_die = new_die (DW_TAG_module, comp_unit_die);
9444 tree context_list_decl
9445 = build_decl (LABEL_DECL, get_identifier (context_list),
9448 TREE_PUBLIC (context_list_decl) = TRUE;
9449 add_name_attribute (unit_die, context_list);
9450 file_index = lookup_filename (filename);
9451 add_AT_unsigned (unit_die, DW_AT_decl_file, file_index);
9452 add_pubname (context_list_decl, unit_die);
9456 /* Write the debugging output for DECL. */
9459 dwarf2out_decl (decl)
9462 register dw_die_ref context_die = comp_unit_die;
9464 if (TREE_CODE (decl) == ERROR_MARK)
9467 /* If this ..._DECL node is marked to be ignored, then ignore it. We gotta
9468 hope that the node in question doesn't represent a function definition.
9469 If it does, then totally ignoring it is bound to screw up our count of
9470 blocks, and that in turn will completely screw up the labels we will
9471 reference in subsequent DW_AT_low_pc and DW_AT_high_pc attributes (for
9472 subsequent blocks). (It's too bad that BLOCK nodes don't carry their
9473 own sequence numbers with them!) */
9474 if (DECL_IGNORED_P (decl))
9476 if (TREE_CODE (decl) == FUNCTION_DECL
9477 && DECL_INITIAL (decl) != NULL)
9483 switch (TREE_CODE (decl))
9486 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration of a
9487 builtin function. Explicit programmer-supplied declarations of
9488 these same functions should NOT be ignored however. */
9489 if (DECL_EXTERNAL (decl) && DECL_BUILT_IN (decl))
9492 /* What we would really like to do here is to filter out all mere
9493 file-scope declarations of file-scope functions which are never
9494 referenced later within this translation unit (and keep all of ones
9495 that *are* referenced later on) but we aren't clairvoyant, so we have
9496 no idea which functions will be referenced in the future (i.e. later
9497 on within the current translation unit). So here we just ignore all
9498 file-scope function declarations which are not also definitions. If
9499 and when the debugger needs to know something about these functions,
9500 it will have to hunt around and find the DWARF information associated
9501 with the definition of the function. Note that we can't just check
9502 `DECL_EXTERNAL' to find out which FUNCTION_DECL nodes represent
9503 definitions and which ones represent mere declarations. We have to
9504 check `DECL_INITIAL' instead. That's because the C front-end
9505 supports some weird semantics for "extern inline" function
9506 definitions. These can get inlined within the current translation
9507 unit (an thus, we need to generate DWARF info for their abstract
9508 instances so that the DWARF info for the concrete inlined instances
9509 can have something to refer to) but the compiler never generates any
9510 out-of-lines instances of such things (despite the fact that they
9511 *are* definitions). The important point is that the C front-end
9512 marks these "extern inline" functions as DECL_EXTERNAL, but we need
9513 to generate DWARF for them anyway. Note that the C++ front-end also
9514 plays some similar games for inline function definitions appearing
9515 within include files which also contain
9516 `#pragma interface' pragmas. */
9517 if (DECL_INITIAL (decl) == NULL_TREE)
9520 /* If we're a nested function, initially use a parent of NULL; if we're
9521 a plain function, this will be fixed up in decls_for_scope. If
9522 we're a method, it will be ignored, since we already have a DIE. */
9523 if (decl_function_context (decl))
9529 /* Ignore this VAR_DECL if it refers to a file-scope extern data object
9530 declaration and if the declaration was never even referenced from
9531 within this entire compilation unit. We suppress these DIEs in
9532 order to save space in the .debug section (by eliminating entries
9533 which are probably useless). Note that we must not suppress
9534 block-local extern declarations (whether used or not) because that
9535 would screw-up the debugger's name lookup mechanism and cause it to
9536 miss things which really ought to be in scope at a given point. */
9537 if (DECL_EXTERNAL (decl) && !TREE_USED (decl))
9540 /* If we are in terse mode, don't generate any DIEs to represent any
9541 variable declarations or definitions. */
9542 if (debug_info_level <= DINFO_LEVEL_TERSE)
9547 /* Don't bother trying to generate any DIEs to represent any of the
9548 normal built-in types for the language we are compiling. */
9549 if (DECL_SOURCE_LINE (decl) == 0)
9551 /* OK, we need to generate one for `bool' so GDB knows what type
9552 comparisons have. */
9553 if ((get_AT_unsigned (comp_unit_die, DW_AT_language)
9554 == DW_LANG_C_plus_plus)
9555 && TREE_CODE (TREE_TYPE (decl)) == BOOLEAN_TYPE)
9556 modified_type_die (TREE_TYPE (decl), 0, 0, NULL);
9561 /* If we are in terse mode, don't generate any DIEs for types. */
9562 if (debug_info_level <= DINFO_LEVEL_TERSE)
9565 /* If we're a function-scope tag, initially use a parent of NULL;
9566 this will be fixed up in decls_for_scope. */
9567 if (decl_function_context (decl))
9576 gen_decl_die (decl, context_die);
9579 /* Output a marker (i.e. a label) for the beginning of the generated code for
9583 dwarf2out_begin_block (blocknum)
9584 register unsigned blocknum;
9586 function_section (current_function_decl);
9587 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, BLOCK_BEGIN_LABEL, blocknum);
9590 /* Output a marker (i.e. a label) for the end of the generated code for a
9594 dwarf2out_end_block (blocknum)
9595 register unsigned blocknum;
9597 function_section (current_function_decl);
9598 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, BLOCK_END_LABEL, blocknum);
9601 /* Output a marker (i.e. a label) at a point in the assembly code which
9602 corresponds to a given source level label. */
9605 dwarf2out_label (insn)
9608 char label[MAX_ARTIFICIAL_LABEL_BYTES];
9610 if (debug_info_level >= DINFO_LEVEL_NORMAL)
9612 function_section (current_function_decl);
9613 sprintf (label, INSN_LABEL_FMT, current_funcdef_number);
9614 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, label,
9615 (unsigned) INSN_UID (insn));
9619 /* Lookup a filename (in the list of filenames that we know about here in
9620 dwarf2out.c) and return its "index". The index of each (known) filename is
9621 just a unique number which is associated with only that one filename.
9622 We need such numbers for the sake of generating labels
9623 (in the .debug_sfnames section) and references to those
9624 files numbers (in the .debug_srcinfo and.debug_macinfo sections).
9625 If the filename given as an argument is not found in our current list,
9626 add it to the list and assign it the next available unique index number.
9627 In order to speed up searches, we remember the index of the filename
9628 was looked up last. This handles the majority of all searches. */
9631 lookup_filename (file_name)
9632 const char *file_name;
9634 static unsigned last_file_lookup_index = 0;
9635 register unsigned i;
9637 /* Check to see if the file name that was searched on the previous call
9638 matches this file name. If so, return the index. */
9639 if (last_file_lookup_index != 0)
9640 if (strcmp (file_name, file_table[last_file_lookup_index]) == 0)
9641 return last_file_lookup_index;
9643 /* Didn't match the previous lookup, search the table */
9644 for (i = 1; i < file_table_in_use; ++i)
9645 if (strcmp (file_name, file_table[i]) == 0)
9647 last_file_lookup_index = i;
9651 /* Prepare to add a new table entry by making sure there is enough space in
9652 the table to do so. If not, expand the current table. */
9653 if (file_table_in_use == file_table_allocated)
9655 file_table_allocated += FILE_TABLE_INCREMENT;
9657 = (char **) xrealloc (file_table,
9658 file_table_allocated * sizeof (char *));
9661 /* Add the new entry to the end of the filename table. */
9662 file_table[file_table_in_use] = xstrdup (file_name);
9663 last_file_lookup_index = file_table_in_use++;
9665 return last_file_lookup_index;
9668 /* Output a label to mark the beginning of a source code line entry
9669 and record information relating to this source line, in
9670 'line_info_table' for later output of the .debug_line section. */
9673 dwarf2out_line (filename, line)
9674 register const char *filename;
9675 register unsigned line;
9677 if (debug_info_level >= DINFO_LEVEL_NORMAL)
9679 function_section (current_function_decl);
9681 if (DWARF2_ASM_LINE_DEBUG_INFO)
9683 static const char *lastfile;
9685 /* Emit the .file and .loc directives understood by GNU as. */
9686 if (lastfile == 0 || strcmp (filename, lastfile))
9689 ggc_add_string_root ((char **) &lastfile, 1);
9691 fprintf (asm_out_file, "\t.file 0 \"%s\"\n", filename);
9692 lastfile = filename;
9695 fprintf (asm_out_file, "\t.loc 0 %d 0\n", line);
9697 /* Indicate that line number info exists. */
9698 ++line_info_table_in_use;
9700 /* Indicate that multiple line number tables exist. */
9701 if (DECL_SECTION_NAME (current_function_decl))
9702 ++separate_line_info_table_in_use;
9704 else if (DECL_SECTION_NAME (current_function_decl))
9706 register dw_separate_line_info_ref line_info;
9707 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, SEPARATE_LINE_CODE_LABEL,
9708 separate_line_info_table_in_use);
9710 fprintf (asm_out_file, "\t%s line %d", ASM_COMMENT_START, line);
9711 fputc ('\n', asm_out_file);
9713 /* expand the line info table if necessary */
9714 if (separate_line_info_table_in_use
9715 == separate_line_info_table_allocated)
9717 separate_line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
9718 separate_line_info_table
9719 = (dw_separate_line_info_ref)
9720 xrealloc (separate_line_info_table,
9721 separate_line_info_table_allocated
9722 * sizeof (dw_separate_line_info_entry));
9725 /* Add the new entry at the end of the line_info_table. */
9727 = &separate_line_info_table[separate_line_info_table_in_use++];
9728 line_info->dw_file_num = lookup_filename (filename);
9729 line_info->dw_line_num = line;
9730 line_info->function = current_funcdef_number;
9734 register dw_line_info_ref line_info;
9736 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, LINE_CODE_LABEL,
9737 line_info_table_in_use);
9739 fprintf (asm_out_file, "\t%s line %d", ASM_COMMENT_START, line);
9740 fputc ('\n', asm_out_file);
9742 /* Expand the line info table if necessary. */
9743 if (line_info_table_in_use == line_info_table_allocated)
9745 line_info_table_allocated += LINE_INFO_TABLE_INCREMENT;
9747 = (dw_line_info_ref)
9748 xrealloc (line_info_table,
9749 (line_info_table_allocated
9750 * sizeof (dw_line_info_entry)));
9753 /* Add the new entry at the end of the line_info_table. */
9754 line_info = &line_info_table[line_info_table_in_use++];
9755 line_info->dw_file_num = lookup_filename (filename);
9756 line_info->dw_line_num = line;
9761 /* Record the beginning of a new source file, for later output
9762 of the .debug_macinfo section. At present, unimplemented. */
9765 dwarf2out_start_source_file (filename)
9766 register const char *filename ATTRIBUTE_UNUSED;
9770 /* Record the end of a source file, for later output
9771 of the .debug_macinfo section. At present, unimplemented. */
9774 dwarf2out_end_source_file ()
9778 /* Called from check_newline in c-parse.y. The `buffer' parameter contains
9779 the tail part of the directive line, i.e. the part which is past the
9780 initial whitespace, #, whitespace, directive-name, whitespace part. */
9783 dwarf2out_define (lineno, buffer)
9784 register unsigned lineno ATTRIBUTE_UNUSED;
9785 register const char *buffer ATTRIBUTE_UNUSED;
9787 static int initialized = 0;
9790 dwarf2out_start_source_file (primary_filename);
9795 /* Called from check_newline in c-parse.y. The `buffer' parameter contains
9796 the tail part of the directive line, i.e. the part which is past the
9797 initial whitespace, #, whitespace, directive-name, whitespace part. */
9800 dwarf2out_undef (lineno, buffer)
9801 register unsigned lineno ATTRIBUTE_UNUSED;
9802 register const char *buffer ATTRIBUTE_UNUSED;
9806 /* Set up for Dwarf output at the start of compilation. */
9809 dwarf2out_init (asm_out_file, main_input_filename)
9810 register FILE *asm_out_file;
9811 register char *main_input_filename;
9813 /* Remember the name of the primary input file. */
9814 primary_filename = main_input_filename;
9816 /* Allocate the initial hunk of the file_table. */
9817 file_table = (char **) xcalloc (FILE_TABLE_INCREMENT, sizeof (char *));
9818 file_table_allocated = FILE_TABLE_INCREMENT;
9820 /* Skip the first entry - file numbers begin at 1. */
9821 file_table_in_use = 1;
9823 /* Allocate the initial hunk of the decl_die_table. */
9825 = (dw_die_ref *) xcalloc (DECL_DIE_TABLE_INCREMENT, sizeof (dw_die_ref));
9826 decl_die_table_allocated = DECL_DIE_TABLE_INCREMENT;
9827 decl_die_table_in_use = 0;
9829 /* Allocate the initial hunk of the decl_scope_table. */
9831 = (tree *) xcalloc (DECL_SCOPE_TABLE_INCREMENT, sizeof (tree));
9832 decl_scope_table_allocated = DECL_SCOPE_TABLE_INCREMENT;
9833 decl_scope_depth = 0;
9835 /* Allocate the initial hunk of the abbrev_die_table. */
9837 = (dw_die_ref *) xcalloc (ABBREV_DIE_TABLE_INCREMENT,
9838 sizeof (dw_die_ref));
9839 abbrev_die_table_allocated = ABBREV_DIE_TABLE_INCREMENT;
9840 /* Zero-th entry is allocated, but unused */
9841 abbrev_die_table_in_use = 1;
9843 /* Allocate the initial hunk of the line_info_table. */
9845 = (dw_line_info_ref) xcalloc (LINE_INFO_TABLE_INCREMENT,
9846 sizeof (dw_line_info_entry));
9847 line_info_table_allocated = LINE_INFO_TABLE_INCREMENT;
9848 /* Zero-th entry is allocated, but unused */
9849 line_info_table_in_use = 1;
9851 /* Generate the initial DIE for the .debug section. Note that the (string)
9852 value given in the DW_AT_name attribute of the DW_TAG_compile_unit DIE
9853 will (typically) be a relative pathname and that this pathname should be
9854 taken as being relative to the directory from which the compiler was
9855 invoked when the given (base) source file was compiled. */
9856 comp_unit_die = gen_compile_unit_die (main_input_filename);
9860 VARRAY_RTX_INIT (used_rtx_varray, 32, "used_rtx_varray");
9861 ggc_add_rtx_varray_root (&used_rtx_varray, 1);
9864 ASM_GENERATE_INTERNAL_LABEL (text_end_label, TEXT_END_LABEL, 0);
9865 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label, ABBREV_SECTION_LABEL, 0);
9866 if (DWARF2_GENERATE_TEXT_SECTION_LABEL)
9867 ASM_GENERATE_INTERNAL_LABEL (text_section_label, TEXT_SECTION_LABEL, 0);
9869 strcpy (text_section_label, stripattributes (TEXT_SECTION));
9870 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label,
9871 DEBUG_INFO_SECTION_LABEL, 0);
9872 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label,
9873 DEBUG_LINE_SECTION_LABEL, 0);
9875 ASM_OUTPUT_SECTION (asm_out_file, ABBREV_SECTION);
9876 ASM_OUTPUT_LABEL (asm_out_file, abbrev_section_label);
9877 if (DWARF2_GENERATE_TEXT_SECTION_LABEL)
9879 ASM_OUTPUT_SECTION (asm_out_file, TEXT_SECTION);
9880 ASM_OUTPUT_LABEL (asm_out_file, text_section_label);
9882 ASM_OUTPUT_SECTION (asm_out_file, DEBUG_INFO_SECTION);
9883 ASM_OUTPUT_LABEL (asm_out_file, debug_info_section_label);
9884 ASM_OUTPUT_SECTION (asm_out_file, DEBUG_LINE_SECTION);
9885 ASM_OUTPUT_LABEL (asm_out_file, debug_line_section_label);
9888 /* Output stuff that dwarf requires at the end of every file,
9889 and generate the DWARF-2 debugging info. */
9894 limbo_die_node *node, *next_node;
9897 /* Traverse the limbo die list, and add parent/child links. The only
9898 dies without parents that should be here are concrete instances of
9899 inline functions, and the comp_unit_die. We can ignore the comp_unit_die.
9900 For concrete instances, we can get the parent die from the abstract
9902 for (node = limbo_die_list; node; node = next_node)
9904 next_node = node->next;
9907 if (die->die_parent == NULL)
9909 dw_die_ref origin = get_AT_ref (die, DW_AT_abstract_origin);
9911 add_child_die (origin->die_parent, die);
9912 else if (die == comp_unit_die)
9919 limbo_die_list = NULL;
9921 /* Walk through the list of incomplete types again, trying once more to
9922 emit full debugging info for them. */
9923 retry_incomplete_types ();
9925 /* Traverse the DIE's, reverse their lists of attributes and children,
9926 and add add sibling attributes to those DIE's that have children. */
9927 add_sibling_attributes (comp_unit_die);
9929 /* Output a terminator label for the .text section. */
9930 fputc ('\n', asm_out_file);
9931 ASM_OUTPUT_SECTION (asm_out_file, TEXT_SECTION);
9932 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, TEXT_END_LABEL, 0);
9935 /* Output a terminator label for the .data section. */
9936 fputc ('\n', asm_out_file);
9937 ASM_OUTPUT_SECTION (asm_out_file, DATA_SECTION);
9938 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, DATA_END_LABEL, 0);
9940 /* Output a terminator label for the .bss section. */
9941 fputc ('\n', asm_out_file);
9942 ASM_OUTPUT_SECTION (asm_out_file, BSS_SECTION);
9943 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, BSS_END_LABEL, 0);
9946 /* Output the source line correspondence table. */
9947 if (line_info_table_in_use > 1 || separate_line_info_table_in_use)
9949 if (! DWARF2_ASM_LINE_DEBUG_INFO)
9951 fputc ('\n', asm_out_file);
9952 ASM_OUTPUT_SECTION (asm_out_file, DEBUG_LINE_SECTION);
9953 output_line_info ();
9956 /* We can only use the low/high_pc attributes if all of the code
9958 if (separate_line_info_table_in_use == 0)
9960 add_AT_lbl_id (comp_unit_die, DW_AT_low_pc, text_section_label);
9961 add_AT_lbl_id (comp_unit_die, DW_AT_high_pc, text_end_label);
9964 add_AT_lbl_offset (comp_unit_die, DW_AT_stmt_list,
9965 debug_line_section_label);
9968 #if 0 /* unimplemented */
9969 if (debug_info_level >= DINFO_LEVEL_VERBOSE && primary)
9970 add_AT_unsigned (die, DW_AT_macro_info, 0);
9973 /* Output the abbreviation table. */
9974 fputc ('\n', asm_out_file);
9975 ASM_OUTPUT_SECTION (asm_out_file, ABBREV_SECTION);
9976 build_abbrev_table (comp_unit_die);
9977 output_abbrev_section ();
9979 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
9980 next_die_offset = DWARF_COMPILE_UNIT_HEADER_SIZE;
9981 calc_die_sizes (comp_unit_die);
9983 /* Output debugging information. */
9984 fputc ('\n', asm_out_file);
9985 ASM_OUTPUT_SECTION (asm_out_file, DEBUG_INFO_SECTION);
9986 output_compilation_unit_header ();
9987 output_die (comp_unit_die);
9989 if (pubname_table_in_use)
9991 /* Output public names table. */
9992 fputc ('\n', asm_out_file);
9993 ASM_OUTPUT_SECTION (asm_out_file, PUBNAMES_SECTION);
9997 /* We only put functions in the arange table, so don't write it out if
9998 we don't have any. */
9999 if (fde_table_in_use)
10001 /* Output the address range information. */
10002 fputc ('\n', asm_out_file);
10003 ASM_OUTPUT_SECTION (asm_out_file, ARANGES_SECTION);
10007 #endif /* DWARF2_DEBUGGING_INFO */