1 /* Output Dwarf2 format symbol table information from the GNU C compiler.
2 Copyright (C) 1992, 93, 95-98, 1999 Free Software Foundation, Inc.
3 Contributed by Gary Funck (gary@intrepid.com).
4 Derived from DWARF 1 implementation of Ron Guilmette (rfg@monkeys.com).
5 Extensively modified by Jason Merrill (jason@cygnus.com).
7 This file is part of GNU CC.
9 GNU CC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2, or (at your option)
14 GNU CC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GNU CC; see the file COPYING. If not, write to
21 the Free Software Foundation, 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
24 /* The first part of this file deals with the DWARF 2 frame unwind
25 information, which is also used by the GCC efficient exception handling
26 mechanism. The second part, controlled only by an #ifdef
27 DWARF2_DEBUGGING_INFO, deals with the other DWARF 2 debugging
36 #include "hard-reg-set.h"
38 #include "insn-config.h"
44 #include "dwarf2out.h"
46 #include "dyn-string.h"
48 /* We cannot use <assert.h> in GCC source, since that would include
49 GCC's assert.h, which may not be compatible with the host compiler. */
54 # define assert(e) do { if (! (e)) abort (); } while (0)
57 /* Decide whether we want to emit frame unwind information for the current
63 return (write_symbols
== DWARF2_DEBUG
64 #ifdef DWARF2_FRAME_INFO
67 #ifdef DWARF2_UNWIND_INFO
68 || (flag_exceptions
&& ! exceptions_via_longjmp
)
73 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
75 /* How to start an assembler comment. */
76 #ifndef ASM_COMMENT_START
77 #define ASM_COMMENT_START ";#"
80 typedef struct dw_cfi_struct
*dw_cfi_ref
;
81 typedef struct dw_fde_struct
*dw_fde_ref
;
82 typedef union dw_cfi_oprnd_struct
*dw_cfi_oprnd_ref
;
84 /* Call frames are described using a sequence of Call Frame
85 Information instructions. The register number, offset
86 and address fields are provided as possible operands;
87 their use is selected by the opcode field. */
89 typedef union dw_cfi_oprnd_struct
91 unsigned long dw_cfi_reg_num
;
92 long int dw_cfi_offset
;
97 typedef struct dw_cfi_struct
99 dw_cfi_ref dw_cfi_next
;
100 enum dwarf_call_frame_info dw_cfi_opc
;
101 dw_cfi_oprnd dw_cfi_oprnd1
;
102 dw_cfi_oprnd dw_cfi_oprnd2
;
106 /* All call frame descriptions (FDE's) in the GCC generated DWARF
107 refer to a single Common Information Entry (CIE), defined at
108 the beginning of the .debug_frame section. This used of a single
109 CIE obviates the need to keep track of multiple CIE's
110 in the DWARF generation routines below. */
112 typedef struct dw_fde_struct
115 char *dw_fde_current_label
;
117 dw_cfi_ref dw_fde_cfi
;
121 /* Maximum size (in bytes) of an artificially generated label. */
122 #define MAX_ARTIFICIAL_LABEL_BYTES 30
124 /* Make sure we know the sizes of the various types dwarf can describe. These
125 are only defaults. If the sizes are different for your target, you should
126 override these values by defining the appropriate symbols in your tm.h
129 #ifndef CHAR_TYPE_SIZE
130 #define CHAR_TYPE_SIZE BITS_PER_UNIT
133 #define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
136 /* The size in bytes of a DWARF field indicating an offset or length
137 relative to a debug info section, specified to be 4 bytes in the DWARF-2
138 specification. The SGI/MIPS ABI defines it to be the same as PTR_SIZE. */
140 #ifndef DWARF_OFFSET_SIZE
141 #define DWARF_OFFSET_SIZE 4
144 #define DWARF_VERSION 2
146 /* Round SIZE up to the nearest BOUNDARY. */
147 #define DWARF_ROUND(SIZE,BOUNDARY) \
148 (((SIZE) + (BOUNDARY) - 1) & ~((BOUNDARY) - 1))
150 /* Offsets recorded in opcodes are a multiple of this alignment factor. */
151 #ifdef STACK_GROWS_DOWNWARD
152 #define DWARF_CIE_DATA_ALIGNMENT (-UNITS_PER_WORD)
154 #define DWARF_CIE_DATA_ALIGNMENT UNITS_PER_WORD
157 /* A pointer to the base of a table that contains frame description
158 information for each routine. */
159 static dw_fde_ref fde_table
;
161 /* Number of elements currently allocated for fde_table. */
162 static unsigned fde_table_allocated
;
164 /* Number of elements in fde_table currently in use. */
165 static unsigned fde_table_in_use
;
167 /* Size (in elements) of increments by which we may expand the
169 #define FDE_TABLE_INCREMENT 256
171 /* A list of call frame insns for the CIE. */
172 static dw_cfi_ref cie_cfi_head
;
174 /* The number of the current function definition for which debugging
175 information is being generated. These numbers range from 1 up to the
176 maximum number of function definitions contained within the current
177 compilation unit. These numbers are used to create unique label id's
178 unique to each function definition. */
179 static unsigned current_funcdef_number
= 0;
181 /* Some DWARF extensions (e.g., MIPS/SGI) implement a subprogram
182 attribute that accelerates the lookup of the FDE associated
183 with the subprogram. This variable holds the table index of the FDE
184 associated with the current function (body) definition. */
185 static unsigned current_funcdef_fde
;
187 /* Forward declarations for functions defined in this file. */
189 static char *stripattributes
PROTO((char *));
190 static char *dwarf_cfi_name
PROTO((unsigned));
191 static dw_cfi_ref new_cfi
PROTO((void));
192 static void add_cfi
PROTO((dw_cfi_ref
*, dw_cfi_ref
));
193 static unsigned long size_of_uleb128
PROTO((unsigned long));
194 static unsigned long size_of_sleb128
PROTO((long));
195 static void output_uleb128
PROTO((unsigned long));
196 static void output_sleb128
PROTO((long));
197 static void add_fde_cfi
PROTO((char *, dw_cfi_ref
));
198 static void lookup_cfa_1
PROTO((dw_cfi_ref
, unsigned long *,
200 static void lookup_cfa
PROTO((unsigned long *, long *));
201 static void reg_save
PROTO((char *, unsigned, unsigned,
203 static void initial_return_save
PROTO((rtx
));
204 static void output_cfi
PROTO((dw_cfi_ref
, dw_fde_ref
));
205 static void output_call_frame_info
PROTO((int));
206 static unsigned reg_number
PROTO((rtx
));
207 static void dwarf2out_stack_adjust
PROTO((rtx
));
209 /* Definitions of defaults for assembler-dependent names of various
210 pseudo-ops and section names.
211 Theses may be overridden in the tm.h file (if necessary) for a particular
214 #ifdef OBJECT_FORMAT_ELF
215 #ifndef UNALIGNED_SHORT_ASM_OP
216 #define UNALIGNED_SHORT_ASM_OP ".2byte"
218 #ifndef UNALIGNED_INT_ASM_OP
219 #define UNALIGNED_INT_ASM_OP ".4byte"
221 #ifndef UNALIGNED_DOUBLE_INT_ASM_OP
222 #define UNALIGNED_DOUBLE_INT_ASM_OP ".8byte"
224 #endif /* OBJECT_FORMAT_ELF */
227 #define ASM_BYTE_OP ".byte"
230 /* Data and reference forms for relocatable data. */
231 #define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
232 #define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
234 /* Pseudo-op for defining a new section. */
235 #ifndef SECTION_ASM_OP
236 #define SECTION_ASM_OP ".section"
239 /* The default format used by the ASM_OUTPUT_SECTION macro (see below) to
240 print the SECTION_ASM_OP and the section name. The default here works for
241 almost all svr4 assemblers, except for the sparc, where the section name
242 must be enclosed in double quotes. (See sparcv4.h). */
243 #ifndef SECTION_FORMAT
244 #ifdef PUSHSECTION_FORMAT
245 #define SECTION_FORMAT PUSHSECTION_FORMAT
247 #define SECTION_FORMAT "\t%s\t%s\n"
251 #ifndef FRAME_SECTION
252 #define FRAME_SECTION ".debug_frame"
255 #ifndef FUNC_BEGIN_LABEL
256 #define FUNC_BEGIN_LABEL "LFB"
258 #ifndef FUNC_END_LABEL
259 #define FUNC_END_LABEL "LFE"
261 #define CIE_AFTER_SIZE_LABEL "LSCIE"
262 #define CIE_END_LABEL "LECIE"
263 #define CIE_LENGTH_LABEL "LLCIE"
264 #define FDE_AFTER_SIZE_LABEL "LSFDE"
265 #define FDE_END_LABEL "LEFDE"
266 #define FDE_LENGTH_LABEL "LLFDE"
268 /* Definitions of defaults for various types of primitive assembly language
269 output operations. These may be overridden from within the tm.h file,
270 but typically, that is unnecessary. */
272 #ifndef ASM_OUTPUT_SECTION
273 #define ASM_OUTPUT_SECTION(FILE, SECTION) \
274 fprintf ((FILE), SECTION_FORMAT, SECTION_ASM_OP, SECTION)
277 #ifndef ASM_OUTPUT_DWARF_DATA1
278 #define ASM_OUTPUT_DWARF_DATA1(FILE,VALUE) \
279 fprintf ((FILE), "\t%s\t0x%x", ASM_BYTE_OP, (unsigned) (VALUE))
282 #ifndef ASM_OUTPUT_DWARF_DELTA1
283 #define ASM_OUTPUT_DWARF_DELTA1(FILE,LABEL1,LABEL2) \
284 do { fprintf ((FILE), "\t%s\t", ASM_BYTE_OP); \
285 assemble_name (FILE, LABEL1); \
286 fprintf (FILE, "-"); \
287 assemble_name (FILE, LABEL2); \
291 #ifdef UNALIGNED_INT_ASM_OP
293 #ifndef UNALIGNED_OFFSET_ASM_OP
294 #define UNALIGNED_OFFSET_ASM_OP \
295 (DWARF_OFFSET_SIZE == 8 ? UNALIGNED_DOUBLE_INT_ASM_OP : UNALIGNED_INT_ASM_OP)
298 #ifndef UNALIGNED_WORD_ASM_OP
299 #define UNALIGNED_WORD_ASM_OP \
300 (PTR_SIZE == 8 ? UNALIGNED_DOUBLE_INT_ASM_OP : UNALIGNED_INT_ASM_OP)
303 #ifndef ASM_OUTPUT_DWARF_DELTA2
304 #define ASM_OUTPUT_DWARF_DELTA2(FILE,LABEL1,LABEL2) \
305 do { fprintf ((FILE), "\t%s\t", UNALIGNED_SHORT_ASM_OP); \
306 assemble_name (FILE, LABEL1); \
307 fprintf (FILE, "-"); \
308 assemble_name (FILE, LABEL2); \
312 #ifndef ASM_OUTPUT_DWARF_DELTA4
313 #define ASM_OUTPUT_DWARF_DELTA4(FILE,LABEL1,LABEL2) \
314 do { fprintf ((FILE), "\t%s\t", UNALIGNED_INT_ASM_OP); \
315 assemble_name (FILE, LABEL1); \
316 fprintf (FILE, "-"); \
317 assemble_name (FILE, LABEL2); \
321 #ifndef ASM_OUTPUT_DWARF_DELTA
322 #define ASM_OUTPUT_DWARF_DELTA(FILE,LABEL1,LABEL2) \
323 do { fprintf ((FILE), "\t%s\t", UNALIGNED_OFFSET_ASM_OP); \
324 assemble_name (FILE, LABEL1); \
325 fprintf (FILE, "-"); \
326 assemble_name (FILE, LABEL2); \
330 #ifndef ASM_OUTPUT_DWARF_ADDR_DELTA
331 #define ASM_OUTPUT_DWARF_ADDR_DELTA(FILE,LABEL1,LABEL2) \
332 do { fprintf ((FILE), "\t%s\t", UNALIGNED_WORD_ASM_OP); \
333 assemble_name (FILE, LABEL1); \
334 fprintf (FILE, "-"); \
335 assemble_name (FILE, LABEL2); \
339 #ifndef ASM_OUTPUT_DWARF_ADDR
340 #define ASM_OUTPUT_DWARF_ADDR(FILE,LABEL) \
341 do { fprintf ((FILE), "\t%s\t", UNALIGNED_WORD_ASM_OP); \
342 assemble_name (FILE, LABEL); \
346 /* ??? This macro takes an RTX in dwarfout.c and a string in dwarf2out.c.
347 We resolve the conflict by creating a new macro ASM_OUTPUT_DWARF2_ADDR_CONST
348 for ports that want to support both DWARF1 and DWARF2. This needs a better
349 solution. See also the comments in sparc/sp64-elf.h. */
350 #ifdef ASM_OUTPUT_DWARF2_ADDR_CONST
351 #undef ASM_OUTPUT_DWARF_ADDR_CONST
352 #define ASM_OUTPUT_DWARF_ADDR_CONST(FILE,ADDR) \
353 ASM_OUTPUT_DWARF2_ADDR_CONST (FILE, ADDR)
356 #ifndef ASM_OUTPUT_DWARF_ADDR_CONST
357 #define ASM_OUTPUT_DWARF_ADDR_CONST(FILE,ADDR) \
358 fprintf ((FILE), "\t%s\t%s", UNALIGNED_WORD_ASM_OP, (ADDR))
361 #ifndef ASM_OUTPUT_DWARF_OFFSET4
362 #define ASM_OUTPUT_DWARF_OFFSET4(FILE,LABEL) \
363 do { fprintf ((FILE), "\t%s\t", UNALIGNED_INT_ASM_OP); \
364 assemble_name (FILE, LABEL); \
368 #ifndef ASM_OUTPUT_DWARF_OFFSET
369 #define ASM_OUTPUT_DWARF_OFFSET(FILE,LABEL) \
370 do { fprintf ((FILE), "\t%s\t", UNALIGNED_OFFSET_ASM_OP); \
371 assemble_name (FILE, LABEL); \
375 #ifndef ASM_OUTPUT_DWARF_DATA2
376 #define ASM_OUTPUT_DWARF_DATA2(FILE,VALUE) \
377 fprintf ((FILE), "\t%s\t0x%x", UNALIGNED_SHORT_ASM_OP, (unsigned) (VALUE))
380 #ifndef ASM_OUTPUT_DWARF_DATA4
381 #define ASM_OUTPUT_DWARF_DATA4(FILE,VALUE) \
382 fprintf ((FILE), "\t%s\t0x%x", UNALIGNED_INT_ASM_OP, (unsigned) (VALUE))
385 #ifndef ASM_OUTPUT_DWARF_DATA
386 #define ASM_OUTPUT_DWARF_DATA(FILE,VALUE) \
387 fprintf ((FILE), "\t%s\t0x%lx", UNALIGNED_OFFSET_ASM_OP, \
388 (unsigned long) (VALUE))
391 #ifndef ASM_OUTPUT_DWARF_ADDR_DATA
392 #define ASM_OUTPUT_DWARF_ADDR_DATA(FILE,VALUE) \
393 fprintf ((FILE), "\t%s\t0x%lx", UNALIGNED_WORD_ASM_OP, \
394 (unsigned long) (VALUE))
397 #ifndef ASM_OUTPUT_DWARF_DATA8
398 #define ASM_OUTPUT_DWARF_DATA8(FILE,HIGH_VALUE,LOW_VALUE) \
400 if (WORDS_BIG_ENDIAN) \
402 fprintf ((FILE), "\t%s\t0x%lx\n", UNALIGNED_INT_ASM_OP, (HIGH_VALUE));\
403 fprintf ((FILE), "\t%s\t0x%lx", UNALIGNED_INT_ASM_OP, (LOW_VALUE));\
407 fprintf ((FILE), "\t%s\t0x%lx\n", UNALIGNED_INT_ASM_OP, (LOW_VALUE)); \
408 fprintf ((FILE), "\t%s\t0x%lx", UNALIGNED_INT_ASM_OP, (HIGH_VALUE)); \
413 #else /* UNALIGNED_INT_ASM_OP */
415 /* We don't have unaligned support, let's hope the normal output works for
418 #define ASM_OUTPUT_DWARF_ADDR(FILE,LABEL) \
419 assemble_integer (gen_rtx_SYMBOL_REF (Pmode, LABEL), PTR_SIZE, 1)
421 #define ASM_OUTPUT_DWARF_OFFSET4(FILE,LABEL) \
422 assemble_integer (gen_rtx_SYMBOL_REF (SImode, LABEL), 4, 1)
424 #define ASM_OUTPUT_DWARF_OFFSET(FILE,LABEL) \
425 assemble_integer (gen_rtx_SYMBOL_REF (SImode, LABEL), 4, 1)
427 #define ASM_OUTPUT_DWARF_DELTA2(FILE,LABEL1,LABEL2) \
428 assemble_integer (gen_rtx_MINUS (HImode, \
429 gen_rtx_SYMBOL_REF (Pmode, LABEL1), \
430 gen_rtx_SYMBOL_REF (Pmode, LABEL2)), \
433 #define ASM_OUTPUT_DWARF_DELTA4(FILE,LABEL1,LABEL2) \
434 assemble_integer (gen_rtx_MINUS (SImode, \
435 gen_rtx_SYMBOL_REF (Pmode, LABEL1), \
436 gen_rtx_SYMBOL_REF (Pmode, LABEL2)), \
439 #define ASM_OUTPUT_DWARF_ADDR_DELTA(FILE,LABEL1,LABEL2) \
440 assemble_integer (gen_rtx_MINUS (Pmode, \
441 gen_rtx_SYMBOL_REF (Pmode, LABEL1), \
442 gen_rtx_SYMBOL_REF (Pmode, LABEL2)), \
445 #define ASM_OUTPUT_DWARF_DELTA(FILE,LABEL1,LABEL2) \
446 ASM_OUTPUT_DWARF_DELTA4 (FILE,LABEL1,LABEL2)
448 #define ASM_OUTPUT_DWARF_DATA4(FILE,VALUE) \
449 assemble_integer (GEN_INT (VALUE), 4, 1)
451 #endif /* UNALIGNED_INT_ASM_OP */
454 #ifndef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
455 #define ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL(FILE, SY, HI, LO) \
457 fprintf (FILE, "\t%s\t", SET_ASM_OP); \
458 assemble_name (FILE, SY); \
460 assemble_name (FILE, HI); \
462 assemble_name (FILE, LO); \
465 #endif /* SET_ASM_OP */
467 /* This is similar to the default ASM_OUTPUT_ASCII, except that no trailing
468 newline is produced. When flag_debug_asm is asserted, we add commentary
469 at the end of the line, so we must avoid output of a newline here. */
470 #ifndef ASM_OUTPUT_DWARF_STRING
471 #define ASM_OUTPUT_DWARF_STRING(FILE,P) \
473 register int slen = strlen(P); \
474 register char *p = (P); \
476 fprintf (FILE, "\t.ascii \""); \
477 for (i = 0; i < slen; i++) \
479 register int c = p[i]; \
480 if (c == '\"' || c == '\\') \
482 if (c >= ' ' && c < 0177) \
486 fprintf (FILE, "\\%o", c); \
489 fprintf (FILE, "\\0\""); \
494 /* The DWARF 2 CFA column which tracks the return address. Normally this
495 is the column for PC, or the first column after all of the hard
497 #ifndef DWARF_FRAME_RETURN_COLUMN
499 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (PC_REGNUM)
501 #define DWARF_FRAME_RETURN_COLUMN FIRST_PSEUDO_REGISTER
505 /* The mapping from gcc register number to DWARF 2 CFA column number. By
506 default, we just provide columns for all registers. */
507 #ifndef DWARF_FRAME_REGNUM
508 #define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG)
511 /* Hook used by __throw. */
514 expand_builtin_dwarf_fp_regnum ()
516 return GEN_INT (DWARF_FRAME_REGNUM (HARD_FRAME_POINTER_REGNUM
));
519 /* The offset from the incoming value of %sp to the top of the stack frame
520 for the current function. */
521 #ifndef INCOMING_FRAME_SP_OFFSET
522 #define INCOMING_FRAME_SP_OFFSET 0
525 /* Return a pointer to a copy of the section string name S with all
526 attributes stripped off, and an asterisk prepended (for assemble_name). */
532 char *stripped
= xmalloc (strlen (s
) + 2);
537 while (*s
&& *s
!= ',')
544 /* Return the register number described by a given RTL node. */
550 register unsigned regno
= REGNO (rtl
);
552 if (regno
>= FIRST_PSEUDO_REGISTER
)
554 warning ("internal regno botch: regno = %d\n", regno
);
558 regno
= DBX_REGISTER_NUMBER (regno
);
562 struct reg_size_range
569 /* Given a register number in REG_TREE, return an rtx for its size in bytes.
570 We do this in kind of a roundabout way, by building up a list of
571 register size ranges and seeing where our register falls in one of those
572 ranges. We need to do it this way because REG_TREE is not a constant,
573 and the target macros were not designed to make this task easy. */
576 expand_builtin_dwarf_reg_size (reg_tree
, target
)
580 enum machine_mode mode
;
582 struct reg_size_range ranges
[5];
589 for (; i
< FIRST_PSEUDO_REGISTER
; ++i
)
591 /* The return address is out of order on the MIPS, and we don't use
592 copy_reg for it anyway, so we don't care here how large it is. */
593 if (DWARF_FRAME_REGNUM (i
) == DWARF_FRAME_RETURN_COLUMN
)
596 mode
= reg_raw_mode
[i
];
598 /* CCmode is arbitrarily given a size of 4 bytes. It is more useful
599 to use the same size as word_mode, since that reduces the number
600 of ranges we need. It should not matter, since the result should
601 never be used for a condition code register anyways. */
602 if (GET_MODE_CLASS (mode
) == MODE_CC
)
605 size
= GET_MODE_SIZE (mode
);
607 /* If this register is not valid in the specified mode and
608 we have a previous size, use that for the size of this
609 register to avoid making junk tiny ranges. */
610 if (! HARD_REGNO_MODE_OK (i
, mode
) && last_size
!= -1)
613 if (size
!= last_size
)
615 ranges
[n_ranges
].beg
= i
;
616 ranges
[n_ranges
].size
= last_size
= size
;
621 ranges
[n_ranges
-1].end
= i
;
624 /* The usual case: fp regs surrounded by general regs. */
625 if (n_ranges
== 3 && ranges
[0].size
== ranges
[2].size
)
627 if ((DWARF_FRAME_REGNUM (ranges
[1].end
)
628 - DWARF_FRAME_REGNUM (ranges
[1].beg
))
629 != ranges
[1].end
- ranges
[1].beg
)
631 t
= fold (build (GE_EXPR
, integer_type_node
, reg_tree
,
632 build_int_2 (DWARF_FRAME_REGNUM (ranges
[1].beg
), 0)));
633 t2
= fold (build (LE_EXPR
, integer_type_node
, reg_tree
,
634 build_int_2 (DWARF_FRAME_REGNUM (ranges
[1].end
), 0)));
635 t
= fold (build (TRUTH_ANDIF_EXPR
, integer_type_node
, t
, t2
));
636 t
= fold (build (COND_EXPR
, integer_type_node
, t
,
637 build_int_2 (ranges
[1].size
, 0),
638 build_int_2 (ranges
[0].size
, 0)));
642 /* Initialize last_end to be larger than any possible
643 DWARF_FRAME_REGNUM. */
644 int last_end
= 0x7fffffff;
646 t
= build_int_2 (ranges
[n_ranges
].size
, 0);
649 int beg
= DWARF_FRAME_REGNUM (ranges
[n_ranges
].beg
);
650 int end
= DWARF_FRAME_REGNUM (ranges
[n_ranges
].end
);
656 if (end
- beg
!= ranges
[n_ranges
].end
- ranges
[n_ranges
].beg
)
658 t2
= fold (build (LE_EXPR
, integer_type_node
, reg_tree
,
659 build_int_2 (end
, 0)));
660 t
= fold (build (COND_EXPR
, integer_type_node
, t2
,
661 build_int_2 (ranges
[n_ranges
].size
, 0), t
));
663 while (--n_ranges
>= 0);
665 return expand_expr (t
, target
, Pmode
, 0);
668 /* Convert a DWARF call frame info. operation to its string name */
671 dwarf_cfi_name (cfi_opc
)
672 register unsigned cfi_opc
;
676 case DW_CFA_advance_loc
:
677 return "DW_CFA_advance_loc";
679 return "DW_CFA_offset";
681 return "DW_CFA_restore";
685 return "DW_CFA_set_loc";
686 case DW_CFA_advance_loc1
:
687 return "DW_CFA_advance_loc1";
688 case DW_CFA_advance_loc2
:
689 return "DW_CFA_advance_loc2";
690 case DW_CFA_advance_loc4
:
691 return "DW_CFA_advance_loc4";
692 case DW_CFA_offset_extended
:
693 return "DW_CFA_offset_extended";
694 case DW_CFA_restore_extended
:
695 return "DW_CFA_restore_extended";
696 case DW_CFA_undefined
:
697 return "DW_CFA_undefined";
698 case DW_CFA_same_value
:
699 return "DW_CFA_same_value";
700 case DW_CFA_register
:
701 return "DW_CFA_register";
702 case DW_CFA_remember_state
:
703 return "DW_CFA_remember_state";
704 case DW_CFA_restore_state
:
705 return "DW_CFA_restore_state";
707 return "DW_CFA_def_cfa";
708 case DW_CFA_def_cfa_register
:
709 return "DW_CFA_def_cfa_register";
710 case DW_CFA_def_cfa_offset
:
711 return "DW_CFA_def_cfa_offset";
713 /* SGI/MIPS specific */
714 case DW_CFA_MIPS_advance_loc8
:
715 return "DW_CFA_MIPS_advance_loc8";
718 case DW_CFA_GNU_window_save
:
719 return "DW_CFA_GNU_window_save";
720 case DW_CFA_GNU_args_size
:
721 return "DW_CFA_GNU_args_size";
724 return "DW_CFA_<unknown>";
728 /* Return a pointer to a newly allocated Call Frame Instruction. */
730 static inline dw_cfi_ref
733 register dw_cfi_ref cfi
= (dw_cfi_ref
) xmalloc (sizeof (dw_cfi_node
));
735 cfi
->dw_cfi_next
= NULL
;
736 cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
= 0;
737 cfi
->dw_cfi_oprnd2
.dw_cfi_reg_num
= 0;
742 /* Add a Call Frame Instruction to list of instructions. */
745 add_cfi (list_head
, cfi
)
746 register dw_cfi_ref
*list_head
;
747 register dw_cfi_ref cfi
;
749 register dw_cfi_ref
*p
;
751 /* Find the end of the chain. */
752 for (p
= list_head
; (*p
) != NULL
; p
= &(*p
)->dw_cfi_next
)
758 /* Generate a new label for the CFI info to refer to. */
761 dwarf2out_cfi_label ()
763 static char label
[20];
764 static unsigned long label_num
= 0;
766 ASM_GENERATE_INTERNAL_LABEL (label
, "LCFI", label_num
++);
767 ASM_OUTPUT_LABEL (asm_out_file
, label
);
772 /* Add CFI to the current fde at the PC value indicated by LABEL if specified,
773 or to the CIE if LABEL is NULL. */
776 add_fde_cfi (label
, cfi
)
777 register char *label
;
778 register dw_cfi_ref cfi
;
782 register dw_fde_ref fde
= &fde_table
[fde_table_in_use
- 1];
785 label
= dwarf2out_cfi_label ();
787 if (fde
->dw_fde_current_label
== NULL
788 || strcmp (label
, fde
->dw_fde_current_label
) != 0)
790 register dw_cfi_ref xcfi
;
792 fde
->dw_fde_current_label
= label
= xstrdup (label
);
794 /* Set the location counter to the new label. */
796 xcfi
->dw_cfi_opc
= DW_CFA_advance_loc4
;
797 xcfi
->dw_cfi_oprnd1
.dw_cfi_addr
= label
;
798 add_cfi (&fde
->dw_fde_cfi
, xcfi
);
801 add_cfi (&fde
->dw_fde_cfi
, cfi
);
805 add_cfi (&cie_cfi_head
, cfi
);
808 /* Subroutine of lookup_cfa. */
811 lookup_cfa_1 (cfi
, regp
, offsetp
)
812 register dw_cfi_ref cfi
;
813 register unsigned long *regp
;
814 register long *offsetp
;
816 switch (cfi
->dw_cfi_opc
)
818 case DW_CFA_def_cfa_offset
:
819 *offsetp
= cfi
->dw_cfi_oprnd1
.dw_cfi_offset
;
821 case DW_CFA_def_cfa_register
:
822 *regp
= cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
;
825 *regp
= cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
;
826 *offsetp
= cfi
->dw_cfi_oprnd2
.dw_cfi_offset
;
833 /* Find the previous value for the CFA. */
836 lookup_cfa (regp
, offsetp
)
837 register unsigned long *regp
;
838 register long *offsetp
;
840 register dw_cfi_ref cfi
;
842 *regp
= (unsigned long) -1;
845 for (cfi
= cie_cfi_head
; cfi
; cfi
= cfi
->dw_cfi_next
)
846 lookup_cfa_1 (cfi
, regp
, offsetp
);
848 if (fde_table_in_use
)
850 register dw_fde_ref fde
= &fde_table
[fde_table_in_use
- 1];
851 for (cfi
= fde
->dw_fde_cfi
; cfi
; cfi
= cfi
->dw_cfi_next
)
852 lookup_cfa_1 (cfi
, regp
, offsetp
);
856 /* The current rule for calculating the DWARF2 canonical frame address. */
857 static unsigned long cfa_reg
;
858 static long cfa_offset
;
860 /* The register used for saving registers to the stack, and its offset
862 static unsigned cfa_store_reg
;
863 static long cfa_store_offset
;
865 /* The running total of the size of arguments pushed onto the stack. */
866 static long args_size
;
868 /* The last args_size we actually output. */
869 static long old_args_size
;
871 /* Entry point to update the canonical frame address (CFA).
872 LABEL is passed to add_fde_cfi. The value of CFA is now to be
873 calculated from REG+OFFSET. */
876 dwarf2out_def_cfa (label
, reg
, offset
)
877 register char *label
;
878 register unsigned reg
;
879 register long offset
;
881 register dw_cfi_ref cfi
;
882 unsigned long old_reg
;
887 if (cfa_store_reg
== reg
)
888 cfa_store_offset
= offset
;
890 reg
= DWARF_FRAME_REGNUM (reg
);
891 lookup_cfa (&old_reg
, &old_offset
);
893 if (reg
== old_reg
&& offset
== old_offset
)
900 cfi
->dw_cfi_opc
= DW_CFA_def_cfa_offset
;
901 cfi
->dw_cfi_oprnd1
.dw_cfi_offset
= offset
;
904 #ifndef MIPS_DEBUGGING_INFO /* SGI dbx thinks this means no offset. */
905 else if (offset
== old_offset
&& old_reg
!= (unsigned long) -1)
907 cfi
->dw_cfi_opc
= DW_CFA_def_cfa_register
;
908 cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
= reg
;
914 cfi
->dw_cfi_opc
= DW_CFA_def_cfa
;
915 cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
= reg
;
916 cfi
->dw_cfi_oprnd2
.dw_cfi_offset
= offset
;
919 add_fde_cfi (label
, cfi
);
922 /* Add the CFI for saving a register. REG is the CFA column number.
923 LABEL is passed to add_fde_cfi.
924 If SREG is -1, the register is saved at OFFSET from the CFA;
925 otherwise it is saved in SREG. */
928 reg_save (label
, reg
, sreg
, offset
)
929 register char * label
;
930 register unsigned reg
;
931 register unsigned sreg
;
932 register long offset
;
934 register dw_cfi_ref cfi
= new_cfi ();
936 cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
= reg
;
938 /* The following comparison is correct. -1 is used to indicate that
939 the value isn't a register number. */
940 if (sreg
== (unsigned int) -1)
943 /* The register number won't fit in 6 bits, so we have to use
945 cfi
->dw_cfi_opc
= DW_CFA_offset_extended
;
947 cfi
->dw_cfi_opc
= DW_CFA_offset
;
949 offset
/= DWARF_CIE_DATA_ALIGNMENT
;
952 cfi
->dw_cfi_oprnd2
.dw_cfi_offset
= offset
;
956 cfi
->dw_cfi_opc
= DW_CFA_register
;
957 cfi
->dw_cfi_oprnd2
.dw_cfi_reg_num
= sreg
;
960 add_fde_cfi (label
, cfi
);
963 /* Add the CFI for saving a register window. LABEL is passed to reg_save.
964 This CFI tells the unwinder that it needs to restore the window registers
965 from the previous frame's window save area.
967 ??? Perhaps we should note in the CIE where windows are saved (instead of
968 assuming 0(cfa)) and what registers are in the window. */
971 dwarf2out_window_save (label
)
972 register char * label
;
974 register dw_cfi_ref cfi
= new_cfi ();
975 cfi
->dw_cfi_opc
= DW_CFA_GNU_window_save
;
976 add_fde_cfi (label
, cfi
);
979 /* Add a CFI to update the running total of the size of arguments
980 pushed onto the stack. */
983 dwarf2out_args_size (label
, size
)
987 register dw_cfi_ref cfi
;
989 if (size
== old_args_size
)
991 old_args_size
= size
;
994 cfi
->dw_cfi_opc
= DW_CFA_GNU_args_size
;
995 cfi
->dw_cfi_oprnd1
.dw_cfi_offset
= size
;
996 add_fde_cfi (label
, cfi
);
999 /* Entry point for saving a register to the stack. REG is the GCC register
1000 number. LABEL and OFFSET are passed to reg_save. */
1003 dwarf2out_reg_save (label
, reg
, offset
)
1004 register char * label
;
1005 register unsigned reg
;
1006 register long offset
;
1008 reg_save (label
, DWARF_FRAME_REGNUM (reg
), -1, offset
);
1011 /* Entry point for saving the return address in the stack.
1012 LABEL and OFFSET are passed to reg_save. */
1015 dwarf2out_return_save (label
, offset
)
1016 register char * label
;
1017 register long offset
;
1019 reg_save (label
, DWARF_FRAME_RETURN_COLUMN
, -1, offset
);
1022 /* Entry point for saving the return address in a register.
1023 LABEL and SREG are passed to reg_save. */
1026 dwarf2out_return_reg (label
, sreg
)
1027 register char * label
;
1028 register unsigned sreg
;
1030 reg_save (label
, DWARF_FRAME_RETURN_COLUMN
, sreg
, 0);
1033 /* Record the initial position of the return address. RTL is
1034 INCOMING_RETURN_ADDR_RTX. */
1037 initial_return_save (rtl
)
1040 unsigned int reg
= (unsigned int) -1;
1043 switch (GET_CODE (rtl
))
1046 /* RA is in a register. */
1047 reg
= reg_number (rtl
);
1050 /* RA is on the stack. */
1051 rtl
= XEXP (rtl
, 0);
1052 switch (GET_CODE (rtl
))
1055 if (REGNO (rtl
) != STACK_POINTER_REGNUM
)
1060 if (REGNO (XEXP (rtl
, 0)) != STACK_POINTER_REGNUM
)
1062 offset
= INTVAL (XEXP (rtl
, 1));
1065 if (REGNO (XEXP (rtl
, 0)) != STACK_POINTER_REGNUM
)
1067 offset
= -INTVAL (XEXP (rtl
, 1));
1074 /* The return address is at some offset from any value we can
1075 actually load. For instance, on the SPARC it is in %i7+8. Just
1076 ignore the offset for now; it doesn't matter for unwinding frames. */
1077 if (GET_CODE (XEXP (rtl
, 1)) != CONST_INT
)
1079 initial_return_save (XEXP (rtl
, 0));
1085 reg_save (NULL
, DWARF_FRAME_RETURN_COLUMN
, reg
, offset
- cfa_offset
);
1088 /* Check INSN to see if it looks like a push or a stack adjustment, and
1089 make a note of it if it does. EH uses this information to find out how
1090 much extra space it needs to pop off the stack. */
1093 dwarf2out_stack_adjust (insn
)
1099 if (! asynchronous_exceptions
&& GET_CODE (insn
) == CALL_INSN
)
1101 /* Extract the size of the args from the CALL rtx itself. */
1103 insn
= PATTERN (insn
);
1104 if (GET_CODE (insn
) == PARALLEL
)
1105 insn
= XVECEXP (insn
, 0, 0);
1106 if (GET_CODE (insn
) == SET
)
1107 insn
= SET_SRC (insn
);
1108 assert (GET_CODE (insn
) == CALL
);
1109 dwarf2out_args_size ("", INTVAL (XEXP (insn
, 1)));
1113 /* If only calls can throw, and we have a frame pointer,
1114 save up adjustments until we see the CALL_INSN. */
1115 else if (! asynchronous_exceptions
1116 && cfa_reg
!= STACK_POINTER_REGNUM
)
1119 if (GET_CODE (insn
) == BARRIER
)
1121 /* When we see a BARRIER, we know to reset args_size to 0. Usually
1122 the compiler will have already emitted a stack adjustment, but
1123 doesn't bother for calls to noreturn functions. */
1124 #ifdef STACK_GROWS_DOWNWARD
1125 offset
= -args_size
;
1130 else if (GET_CODE (PATTERN (insn
)) == SET
)
1135 insn
= PATTERN (insn
);
1136 src
= SET_SRC (insn
);
1137 dest
= SET_DEST (insn
);
1139 if (dest
== stack_pointer_rtx
)
1141 /* (set (reg sp) (plus (reg sp) (const_int))) */
1142 code
= GET_CODE (src
);
1143 if (! (code
== PLUS
|| code
== MINUS
)
1144 || XEXP (src
, 0) != stack_pointer_rtx
1145 || GET_CODE (XEXP (src
, 1)) != CONST_INT
)
1148 offset
= INTVAL (XEXP (src
, 1));
1150 else if (GET_CODE (dest
) == MEM
)
1152 /* (set (mem (pre_dec (reg sp))) (foo)) */
1153 src
= XEXP (dest
, 0);
1154 code
= GET_CODE (src
);
1156 if (! (code
== PRE_DEC
|| code
== PRE_INC
)
1157 || XEXP (src
, 0) != stack_pointer_rtx
)
1160 offset
= GET_MODE_SIZE (GET_MODE (dest
));
1165 if (code
== PLUS
|| code
== PRE_INC
)
1174 if (cfa_reg
== STACK_POINTER_REGNUM
)
1175 cfa_offset
+= offset
;
1177 #ifndef STACK_GROWS_DOWNWARD
1180 args_size
+= offset
;
1184 label
= dwarf2out_cfi_label ();
1185 dwarf2out_def_cfa (label
, cfa_reg
, cfa_offset
);
1186 dwarf2out_args_size (label
, args_size
);
1189 /* A temporary register used in adjusting SP or setting up the store_reg. */
1190 static unsigned cfa_temp_reg
;
1192 /* A temporary value used in adjusting SP or setting up the store_reg. */
1193 static long cfa_temp_value
;
1195 /* Record call frame debugging information for an expression, which either
1196 sets SP or FP (adjusting how we calculate the frame address) or saves a
1197 register to the stack. */
1200 dwarf2out_frame_debug_expr (expr
, label
)
1207 /* If RTX_FRAME_RELATED_P is set on a PARALLEL, process each member of
1208 the PARALLEL independantly. The first element is always processed if
1209 it is a SET. This is for backward compatability. Other elements
1210 are processed only if they are SETs and the RTX_FRAME_RELATED_P
1211 flag is set in them. */
1213 if (GET_CODE (expr
) == PARALLEL
)
1216 int limit
= XVECLEN (expr
, 0);
1218 for (par_index
= 0; par_index
< limit
; par_index
++)
1220 rtx x
= XVECEXP (expr
, 0, par_index
);
1222 if (GET_CODE (x
) == SET
&&
1223 (RTX_FRAME_RELATED_P (x
) || par_index
== 0))
1224 dwarf2out_frame_debug_expr (x
, label
);
1229 if (GET_CODE (expr
) != SET
)
1232 src
= SET_SRC (expr
);
1233 dest
= SET_DEST (expr
);
1235 switch (GET_CODE (dest
))
1238 /* Update the CFA rule wrt SP or FP. Make sure src is
1239 relative to the current CFA register. */
1240 switch (GET_CODE (src
))
1242 /* Setting FP from SP. */
1244 if (cfa_reg
!= (unsigned) REGNO (src
))
1246 if (REGNO (dest
) != STACK_POINTER_REGNUM
1247 && !(frame_pointer_needed
1248 && REGNO (dest
) == HARD_FRAME_POINTER_REGNUM
))
1250 cfa_reg
= REGNO (dest
);
1255 if (dest
== stack_pointer_rtx
)
1258 switch (GET_CODE (XEXP (src
, 1)))
1261 offset
= INTVAL (XEXP (src
, 1));
1264 if ((unsigned) REGNO (XEXP (src
, 1)) != cfa_temp_reg
)
1266 offset
= cfa_temp_value
;
1272 if (XEXP (src
, 0) == hard_frame_pointer_rtx
)
1274 /* Restoring SP from FP in the epilogue. */
1275 if (cfa_reg
!= (unsigned) HARD_FRAME_POINTER_REGNUM
)
1277 cfa_reg
= STACK_POINTER_REGNUM
;
1279 else if (XEXP (src
, 0) != stack_pointer_rtx
)
1282 if (GET_CODE (src
) == PLUS
)
1284 if (cfa_reg
== STACK_POINTER_REGNUM
)
1285 cfa_offset
+= offset
;
1286 if (cfa_store_reg
== STACK_POINTER_REGNUM
)
1287 cfa_store_offset
+= offset
;
1289 else if (dest
== hard_frame_pointer_rtx
)
1291 /* Either setting the FP from an offset of the SP,
1292 or adjusting the FP */
1293 if (! frame_pointer_needed
1294 || REGNO (dest
) != HARD_FRAME_POINTER_REGNUM
)
1297 if (XEXP (src
, 0) == stack_pointer_rtx
1298 && GET_CODE (XEXP (src
, 1)) == CONST_INT
)
1300 if (cfa_reg
!= STACK_POINTER_REGNUM
)
1302 offset
= INTVAL (XEXP (src
, 1));
1303 if (GET_CODE (src
) == PLUS
)
1305 cfa_offset
+= offset
;
1306 cfa_reg
= HARD_FRAME_POINTER_REGNUM
;
1308 else if (XEXP (src
, 0) == hard_frame_pointer_rtx
1309 && GET_CODE (XEXP (src
, 1)) == CONST_INT
)
1311 if (cfa_reg
!= (unsigned) HARD_FRAME_POINTER_REGNUM
)
1313 offset
= INTVAL (XEXP (src
, 1));
1314 if (GET_CODE (src
) == PLUS
)
1316 cfa_offset
+= offset
;
1324 if (GET_CODE (src
) != PLUS
1325 || XEXP (src
, 1) != stack_pointer_rtx
)
1327 if (GET_CODE (XEXP (src
, 0)) != REG
1328 || (unsigned) REGNO (XEXP (src
, 0)) != cfa_temp_reg
)
1330 if (cfa_reg
!= STACK_POINTER_REGNUM
)
1332 cfa_store_reg
= REGNO (dest
);
1333 cfa_store_offset
= cfa_offset
- cfa_temp_value
;
1338 cfa_temp_reg
= REGNO (dest
);
1339 cfa_temp_value
= INTVAL (src
);
1343 if (GET_CODE (XEXP (src
, 0)) != REG
1344 || (unsigned) REGNO (XEXP (src
, 0)) != cfa_temp_reg
1345 || (unsigned) REGNO (dest
) != cfa_temp_reg
1346 || GET_CODE (XEXP (src
, 1)) != CONST_INT
)
1348 cfa_temp_value
|= INTVAL (XEXP (src
, 1));
1354 dwarf2out_def_cfa (label
, cfa_reg
, cfa_offset
);
1358 /* Saving a register to the stack. Make sure dest is relative to the
1360 if (GET_CODE (src
) != REG
)
1362 switch (GET_CODE (XEXP (dest
, 0)))
1367 offset
= GET_MODE_SIZE (GET_MODE (dest
));
1368 if (GET_CODE (XEXP (dest
, 0)) == PRE_INC
)
1371 if (REGNO (XEXP (XEXP (dest
, 0), 0)) != STACK_POINTER_REGNUM
1372 || cfa_store_reg
!= STACK_POINTER_REGNUM
)
1374 cfa_store_offset
+= offset
;
1375 if (cfa_reg
== STACK_POINTER_REGNUM
)
1376 cfa_offset
= cfa_store_offset
;
1378 offset
= -cfa_store_offset
;
1381 /* With an offset. */
1384 offset
= INTVAL (XEXP (XEXP (dest
, 0), 1));
1385 if (GET_CODE (XEXP (dest
, 0)) == MINUS
)
1388 if (cfa_store_reg
!= (unsigned) REGNO (XEXP (XEXP (dest
, 0), 0)))
1390 offset
-= cfa_store_offset
;
1393 /* Without an offset. */
1395 if (cfa_store_reg
!= (unsigned) REGNO (XEXP (dest
, 0)))
1397 offset
= -cfa_store_offset
;
1403 dwarf2out_def_cfa (label
, cfa_reg
, cfa_offset
);
1404 dwarf2out_reg_save (label
, REGNO (src
), offset
);
1413 /* Record call frame debugging information for INSN, which either
1414 sets SP or FP (adjusting how we calculate the frame address) or saves a
1415 register to the stack. If INSN is NULL_RTX, initialize our state. */
1418 dwarf2out_frame_debug (insn
)
1424 if (insn
== NULL_RTX
)
1426 /* Set up state for generating call frame debug info. */
1427 lookup_cfa (&cfa_reg
, &cfa_offset
);
1428 if (cfa_reg
!= DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM
))
1430 cfa_reg
= STACK_POINTER_REGNUM
;
1431 cfa_store_reg
= cfa_reg
;
1432 cfa_store_offset
= cfa_offset
;
1438 if (! RTX_FRAME_RELATED_P (insn
))
1440 dwarf2out_stack_adjust (insn
);
1444 label
= dwarf2out_cfi_label ();
1446 src
= find_reg_note (insn
, REG_FRAME_RELATED_EXPR
, NULL_RTX
);
1448 insn
= XEXP (src
, 0);
1450 insn
= PATTERN (insn
);
1452 dwarf2out_frame_debug_expr (insn
, label
);
1455 /* Return the size of an unsigned LEB128 quantity. */
1457 static inline unsigned long
1458 size_of_uleb128 (value
)
1459 register unsigned long value
;
1461 register unsigned long size
= 0;
1462 register unsigned byte
;
1466 byte
= (value
& 0x7f);
1475 /* Return the size of a signed LEB128 quantity. */
1477 static inline unsigned long
1478 size_of_sleb128 (value
)
1479 register long value
;
1481 register unsigned long size
= 0;
1482 register unsigned byte
;
1486 byte
= (value
& 0x7f);
1490 while (!(((value
== 0) && ((byte
& 0x40) == 0))
1491 || ((value
== -1) && ((byte
& 0x40) != 0))));
1496 /* Output an unsigned LEB128 quantity. */
1499 output_uleb128 (value
)
1500 register unsigned long value
;
1502 unsigned long save_value
= value
;
1504 fprintf (asm_out_file
, "\t%s\t", ASM_BYTE_OP
);
1507 register unsigned byte
= (value
& 0x7f);
1510 /* More bytes to follow. */
1513 fprintf (asm_out_file
, "0x%x", byte
);
1515 fprintf (asm_out_file
, ",");
1520 fprintf (asm_out_file
, "\t%s ULEB128 0x%lx", ASM_COMMENT_START
, save_value
);
1523 /* Output an signed LEB128 quantity. */
1526 output_sleb128 (value
)
1527 register long value
;
1530 register unsigned byte
;
1531 long save_value
= value
;
1533 fprintf (asm_out_file
, "\t%s\t", ASM_BYTE_OP
);
1536 byte
= (value
& 0x7f);
1537 /* arithmetic shift */
1539 more
= !((((value
== 0) && ((byte
& 0x40) == 0))
1540 || ((value
== -1) && ((byte
& 0x40) != 0))));
1544 fprintf (asm_out_file
, "0x%x", byte
);
1546 fprintf (asm_out_file
, ",");
1551 fprintf (asm_out_file
, "\t%s SLEB128 %ld", ASM_COMMENT_START
, save_value
);
1554 /* Output a Call Frame Information opcode and its operand(s). */
1557 output_cfi (cfi
, fde
)
1558 register dw_cfi_ref cfi
;
1559 register dw_fde_ref fde
;
1561 if (cfi
->dw_cfi_opc
== DW_CFA_advance_loc
)
1563 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
,
1565 | (cfi
->dw_cfi_oprnd1
.dw_cfi_offset
& 0x3f));
1567 fprintf (asm_out_file
, "\t%s DW_CFA_advance_loc 0x%lx",
1568 ASM_COMMENT_START
, cfi
->dw_cfi_oprnd1
.dw_cfi_offset
);
1569 fputc ('\n', asm_out_file
);
1572 else if (cfi
->dw_cfi_opc
== DW_CFA_offset
)
1574 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
,
1576 | (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
& 0x3f));
1578 fprintf (asm_out_file
, "\t%s DW_CFA_offset, column 0x%lx",
1579 ASM_COMMENT_START
, cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
);
1581 fputc ('\n', asm_out_file
);
1582 output_uleb128 (cfi
->dw_cfi_oprnd2
.dw_cfi_offset
);
1583 fputc ('\n', asm_out_file
);
1585 else if (cfi
->dw_cfi_opc
== DW_CFA_restore
)
1587 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
,
1589 | (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
& 0x3f));
1591 fprintf (asm_out_file
, "\t%s DW_CFA_restore, column 0x%lx",
1592 ASM_COMMENT_START
, cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
);
1594 fputc ('\n', asm_out_file
);
1598 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, cfi
->dw_cfi_opc
);
1600 fprintf (asm_out_file
, "\t%s %s", ASM_COMMENT_START
,
1601 dwarf_cfi_name (cfi
->dw_cfi_opc
));
1603 fputc ('\n', asm_out_file
);
1604 switch (cfi
->dw_cfi_opc
)
1606 case DW_CFA_set_loc
:
1607 ASM_OUTPUT_DWARF_ADDR (asm_out_file
, cfi
->dw_cfi_oprnd1
.dw_cfi_addr
);
1608 fputc ('\n', asm_out_file
);
1610 case DW_CFA_advance_loc1
:
1611 ASM_OUTPUT_DWARF_DELTA1 (asm_out_file
,
1612 cfi
->dw_cfi_oprnd1
.dw_cfi_addr
,
1613 fde
->dw_fde_current_label
);
1614 fputc ('\n', asm_out_file
);
1615 fde
->dw_fde_current_label
= cfi
->dw_cfi_oprnd1
.dw_cfi_addr
;
1617 case DW_CFA_advance_loc2
:
1618 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file
,
1619 cfi
->dw_cfi_oprnd1
.dw_cfi_addr
,
1620 fde
->dw_fde_current_label
);
1621 fputc ('\n', asm_out_file
);
1622 fde
->dw_fde_current_label
= cfi
->dw_cfi_oprnd1
.dw_cfi_addr
;
1624 case DW_CFA_advance_loc4
:
1625 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file
,
1626 cfi
->dw_cfi_oprnd1
.dw_cfi_addr
,
1627 fde
->dw_fde_current_label
);
1628 fputc ('\n', asm_out_file
);
1629 fde
->dw_fde_current_label
= cfi
->dw_cfi_oprnd1
.dw_cfi_addr
;
1631 #ifdef MIPS_DEBUGGING_INFO
1632 case DW_CFA_MIPS_advance_loc8
:
1633 /* TODO: not currently implemented. */
1637 case DW_CFA_offset_extended
:
1638 case DW_CFA_def_cfa
:
1639 output_uleb128 (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
);
1640 fputc ('\n', asm_out_file
);
1641 output_uleb128 (cfi
->dw_cfi_oprnd2
.dw_cfi_offset
);
1642 fputc ('\n', asm_out_file
);
1644 case DW_CFA_restore_extended
:
1645 case DW_CFA_undefined
:
1646 output_uleb128 (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
);
1647 fputc ('\n', asm_out_file
);
1649 case DW_CFA_same_value
:
1650 case DW_CFA_def_cfa_register
:
1651 output_uleb128 (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
);
1652 fputc ('\n', asm_out_file
);
1654 case DW_CFA_register
:
1655 output_uleb128 (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
);
1656 fputc ('\n', asm_out_file
);
1657 output_uleb128 (cfi
->dw_cfi_oprnd2
.dw_cfi_reg_num
);
1658 fputc ('\n', asm_out_file
);
1660 case DW_CFA_def_cfa_offset
:
1661 output_uleb128 (cfi
->dw_cfi_oprnd1
.dw_cfi_offset
);
1662 fputc ('\n', asm_out_file
);
1664 case DW_CFA_GNU_window_save
:
1666 case DW_CFA_GNU_args_size
:
1667 output_uleb128 (cfi
->dw_cfi_oprnd1
.dw_cfi_offset
);
1668 fputc ('\n', asm_out_file
);
1676 #if !defined (EH_FRAME_SECTION)
1677 #if defined (EH_FRAME_SECTION_ASM_OP)
1678 #define EH_FRAME_SECTION() eh_frame_section();
1680 #if defined (ASM_OUTPUT_SECTION_NAME)
1681 #define EH_FRAME_SECTION() \
1683 named_section (NULL_TREE, ".eh_frame", 0); \
1689 /* If we aren't using crtstuff to run ctors, don't use it for EH. */
1690 #if !defined (HAS_INIT_SECTION) && !defined (INIT_SECTION_ASM_OP)
1691 #undef EH_FRAME_SECTION
1694 /* Output the call frame information used to used to record information
1695 that relates to calculating the frame pointer, and records the
1696 location of saved registers. */
1699 output_call_frame_info (for_eh
)
1702 register unsigned long i
;
1703 register dw_fde_ref fde
;
1704 register dw_cfi_ref cfi
;
1705 char l1
[20], l2
[20];
1706 #ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
1710 /* Do we want to include a pointer to the exception table? */
1711 int eh_ptr
= for_eh
&& exception_table_p ();
1713 fputc ('\n', asm_out_file
);
1715 /* We're going to be generating comments, so turn on app. */
1721 #ifdef EH_FRAME_SECTION
1722 EH_FRAME_SECTION ();
1724 tree label
= get_file_function_name ('F');
1726 force_data_section ();
1727 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (PTR_SIZE
));
1728 ASM_GLOBALIZE_LABEL (asm_out_file
, IDENTIFIER_POINTER (label
));
1729 ASM_OUTPUT_LABEL (asm_out_file
, IDENTIFIER_POINTER (label
));
1731 assemble_label ("__FRAME_BEGIN__");
1734 ASM_OUTPUT_SECTION (asm_out_file
, FRAME_SECTION
);
1736 /* Output the CIE. */
1737 ASM_GENERATE_INTERNAL_LABEL (l1
, CIE_AFTER_SIZE_LABEL
, for_eh
);
1738 ASM_GENERATE_INTERNAL_LABEL (l2
, CIE_END_LABEL
, for_eh
);
1739 #ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
1740 ASM_GENERATE_INTERNAL_LABEL (ld
, CIE_LENGTH_LABEL
, for_eh
);
1742 ASM_OUTPUT_DWARF_OFFSET4 (asm_out_file
, ld
);
1744 ASM_OUTPUT_DWARF_OFFSET (asm_out_file
, ld
);
1747 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file
, l2
, l1
);
1749 ASM_OUTPUT_DWARF_DELTA (asm_out_file
, l2
, l1
);
1752 fprintf (asm_out_file
, "\t%s Length of Common Information Entry",
1755 fputc ('\n', asm_out_file
);
1756 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
1759 /* Now that the CIE pointer is PC-relative for EH,
1760 use 0 to identify the CIE. */
1761 ASM_OUTPUT_DWARF_DATA4 (asm_out_file
, 0);
1763 ASM_OUTPUT_DWARF_DATA4 (asm_out_file
, DW_CIE_ID
);
1766 fprintf (asm_out_file
, "\t%s CIE Identifier Tag", ASM_COMMENT_START
);
1768 fputc ('\n', asm_out_file
);
1769 if (! for_eh
&& DWARF_OFFSET_SIZE
== 8)
1771 ASM_OUTPUT_DWARF_DATA4 (asm_out_file
, DW_CIE_ID
);
1772 fputc ('\n', asm_out_file
);
1775 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, DW_CIE_VERSION
);
1777 fprintf (asm_out_file
, "\t%s CIE Version", ASM_COMMENT_START
);
1779 fputc ('\n', asm_out_file
);
1782 /* The CIE contains a pointer to the exception region info for the
1783 frame. Make the augmentation string three bytes (including the
1784 trailing null) so the pointer is 4-byte aligned. The Solaris ld
1785 can't handle unaligned relocs. */
1788 ASM_OUTPUT_DWARF_STRING (asm_out_file
, "eh");
1789 fprintf (asm_out_file
, "\t%s CIE Augmentation", ASM_COMMENT_START
);
1793 ASM_OUTPUT_ASCII (asm_out_file
, "eh", 3);
1795 fputc ('\n', asm_out_file
);
1797 ASM_OUTPUT_DWARF_ADDR (asm_out_file
, "__EXCEPTION_TABLE__");
1799 fprintf (asm_out_file
, "\t%s pointer to exception region info",
1804 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, 0);
1806 fprintf (asm_out_file
, "\t%s CIE Augmentation (none)",
1810 fputc ('\n', asm_out_file
);
1813 fprintf (asm_out_file
, " (CIE Code Alignment Factor)");
1815 fputc ('\n', asm_out_file
);
1816 output_sleb128 (DWARF_CIE_DATA_ALIGNMENT
);
1818 fprintf (asm_out_file
, " (CIE Data Alignment Factor)");
1820 fputc ('\n', asm_out_file
);
1821 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, DWARF_FRAME_RETURN_COLUMN
);
1823 fprintf (asm_out_file
, "\t%s CIE RA Column", ASM_COMMENT_START
);
1825 fputc ('\n', asm_out_file
);
1827 for (cfi
= cie_cfi_head
; cfi
!= NULL
; cfi
= cfi
->dw_cfi_next
)
1828 output_cfi (cfi
, NULL
);
1830 /* Pad the CIE out to an address sized boundary. */
1831 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (PTR_SIZE
));
1832 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
1833 #ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
1834 ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL (asm_out_file
, ld
, l2
, l1
);
1836 fprintf (asm_out_file
, "\t%s CIE Length Symbol", ASM_COMMENT_START
);
1837 fputc ('\n', asm_out_file
);
1840 /* Loop through all of the FDE's. */
1841 for (i
= 0; i
< fde_table_in_use
; ++i
)
1843 fde
= &fde_table
[i
];
1845 ASM_GENERATE_INTERNAL_LABEL (l1
, FDE_AFTER_SIZE_LABEL
, for_eh
+ i
*2);
1846 ASM_GENERATE_INTERNAL_LABEL (l2
, FDE_END_LABEL
, for_eh
+ i
*2);
1847 #ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
1848 ASM_GENERATE_INTERNAL_LABEL (ld
, FDE_LENGTH_LABEL
, for_eh
+ i
*2);
1850 ASM_OUTPUT_DWARF_OFFSET4 (asm_out_file
, ld
);
1852 ASM_OUTPUT_DWARF_OFFSET (asm_out_file
, ld
);
1855 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file
, l2
, l1
);
1857 ASM_OUTPUT_DWARF_DELTA (asm_out_file
, l2
, l1
);
1860 fprintf (asm_out_file
, "\t%s FDE Length", ASM_COMMENT_START
);
1861 fputc ('\n', asm_out_file
);
1862 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
1864 /* ??? This always emits a 4 byte offset when for_eh is true, but it
1865 emits a target dependent sized offset when for_eh is not true.
1866 This inconsistency may confuse gdb. The only case where we need a
1867 non-4 byte offset is for the Irix6 N64 ABI, so we may lose SGI
1868 compatibility if we emit a 4 byte offset. We need a 4 byte offset
1869 though in order to be compatible with the dwarf_fde struct in frame.c.
1870 If the for_eh case is changed, then the struct in frame.c has
1871 to be adjusted appropriately. */
1873 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file
, l1
, "__FRAME_BEGIN__");
1875 ASM_OUTPUT_DWARF_OFFSET (asm_out_file
, stripattributes (FRAME_SECTION
));
1877 fprintf (asm_out_file
, "\t%s FDE CIE offset", ASM_COMMENT_START
);
1879 fputc ('\n', asm_out_file
);
1880 ASM_OUTPUT_DWARF_ADDR (asm_out_file
, fde
->dw_fde_begin
);
1882 fprintf (asm_out_file
, "\t%s FDE initial location", ASM_COMMENT_START
);
1884 fputc ('\n', asm_out_file
);
1885 ASM_OUTPUT_DWARF_ADDR_DELTA (asm_out_file
,
1886 fde
->dw_fde_end
, fde
->dw_fde_begin
);
1888 fprintf (asm_out_file
, "\t%s FDE address range", ASM_COMMENT_START
);
1890 fputc ('\n', asm_out_file
);
1892 /* Loop through the Call Frame Instructions associated with
1894 fde
->dw_fde_current_label
= fde
->dw_fde_begin
;
1895 for (cfi
= fde
->dw_fde_cfi
; cfi
!= NULL
; cfi
= cfi
->dw_cfi_next
)
1896 output_cfi (cfi
, fde
);
1898 /* Pad the FDE out to an address sized boundary. */
1899 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (PTR_SIZE
));
1900 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
1901 #ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
1902 ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL (asm_out_file
, ld
, l2
, l1
);
1904 fprintf (asm_out_file
, "\t%s FDE Length Symbol", ASM_COMMENT_START
);
1905 fputc ('\n', asm_out_file
);
1908 #ifndef EH_FRAME_SECTION
1911 /* Emit terminating zero for table. */
1912 ASM_OUTPUT_DWARF_DATA4 (asm_out_file
, 0);
1913 fputc ('\n', asm_out_file
);
1916 #ifdef MIPS_DEBUGGING_INFO
1917 /* Work around Irix 6 assembler bug whereby labels at the end of a section
1918 get a value of 0. Putting .align 0 after the label fixes it. */
1919 ASM_OUTPUT_ALIGN (asm_out_file
, 0);
1922 /* Turn off app to make assembly quicker. */
1927 /* Output a marker (i.e. a label) for the beginning of a function, before
1931 dwarf2out_begin_prologue ()
1933 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1934 register dw_fde_ref fde
;
1936 ++current_funcdef_number
;
1938 function_section (current_function_decl
);
1939 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_BEGIN_LABEL
,
1940 current_funcdef_number
);
1941 ASM_OUTPUT_LABEL (asm_out_file
, label
);
1943 /* Expand the fde table if necessary. */
1944 if (fde_table_in_use
== fde_table_allocated
)
1946 fde_table_allocated
+= FDE_TABLE_INCREMENT
;
1948 = (dw_fde_ref
) xrealloc (fde_table
,
1949 fde_table_allocated
* sizeof (dw_fde_node
));
1952 /* Record the FDE associated with this function. */
1953 current_funcdef_fde
= fde_table_in_use
;
1955 /* Add the new FDE at the end of the fde_table. */
1956 fde
= &fde_table
[fde_table_in_use
++];
1957 fde
->dw_fde_begin
= xstrdup (label
);
1958 fde
->dw_fde_current_label
= NULL
;
1959 fde
->dw_fde_end
= NULL
;
1960 fde
->dw_fde_cfi
= NULL
;
1962 args_size
= old_args_size
= 0;
1965 /* Output a marker (i.e. a label) for the absolute end of the generated code
1966 for a function definition. This gets called *after* the epilogue code has
1970 dwarf2out_end_epilogue ()
1973 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1975 /* Output a label to mark the endpoint of the code generated for this
1977 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_END_LABEL
, current_funcdef_number
);
1978 ASM_OUTPUT_LABEL (asm_out_file
, label
);
1979 fde
= &fde_table
[fde_table_in_use
- 1];
1980 fde
->dw_fde_end
= xstrdup (label
);
1984 dwarf2out_frame_init ()
1986 /* Allocate the initial hunk of the fde_table. */
1988 = (dw_fde_ref
) xmalloc (FDE_TABLE_INCREMENT
* sizeof (dw_fde_node
));
1989 bzero ((char *) fde_table
, FDE_TABLE_INCREMENT
* sizeof (dw_fde_node
));
1990 fde_table_allocated
= FDE_TABLE_INCREMENT
;
1991 fde_table_in_use
= 0;
1993 /* Generate the CFA instructions common to all FDE's. Do it now for the
1994 sake of lookup_cfa. */
1996 #ifdef DWARF2_UNWIND_INFO
1997 /* On entry, the Canonical Frame Address is at SP. */
1998 dwarf2out_def_cfa (NULL
, STACK_POINTER_REGNUM
, INCOMING_FRAME_SP_OFFSET
);
1999 initial_return_save (INCOMING_RETURN_ADDR_RTX
);
2004 dwarf2out_frame_finish ()
2006 /* Output call frame information. */
2007 #ifdef MIPS_DEBUGGING_INFO
2008 if (write_symbols
== DWARF2_DEBUG
)
2009 output_call_frame_info (0);
2010 if (flag_exceptions
&& ! exceptions_via_longjmp
)
2011 output_call_frame_info (1);
2013 if (write_symbols
== DWARF2_DEBUG
2014 || (flag_exceptions
&& ! exceptions_via_longjmp
))
2015 output_call_frame_info (1);
2019 #endif /* .debug_frame support */
2021 /* And now, the support for symbolic debugging information. */
2022 #ifdef DWARF2_DEBUGGING_INFO
2024 extern char *getpwd
PROTO((void));
2026 /* NOTE: In the comments in this file, many references are made to
2027 "Debugging Information Entries". This term is abbreviated as `DIE'
2028 throughout the remainder of this file. */
2030 /* An internal representation of the DWARF output is built, and then
2031 walked to generate the DWARF debugging info. The walk of the internal
2032 representation is done after the entire program has been compiled.
2033 The types below are used to describe the internal representation. */
2035 /* Each DIE may have a series of attribute/value pairs. Values
2036 can take on several forms. The forms that are used in this
2037 implementation are listed below. */
2044 dw_val_class_unsigned_const
,
2045 dw_val_class_long_long
,
2048 dw_val_class_die_ref
,
2049 dw_val_class_fde_ref
,
2050 dw_val_class_lbl_id
,
2051 dw_val_class_lbl_offset
,
2056 /* Various DIE's use offsets relative to the beginning of the
2057 .debug_info section to refer to each other. */
2059 typedef long int dw_offset
;
2061 /* Define typedefs here to avoid circular dependencies. */
2063 typedef struct die_struct
*dw_die_ref
;
2064 typedef struct dw_attr_struct
*dw_attr_ref
;
2065 typedef struct dw_val_struct
*dw_val_ref
;
2066 typedef struct dw_line_info_struct
*dw_line_info_ref
;
2067 typedef struct dw_separate_line_info_struct
*dw_separate_line_info_ref
;
2068 typedef struct dw_loc_descr_struct
*dw_loc_descr_ref
;
2069 typedef struct pubname_struct
*pubname_ref
;
2070 typedef dw_die_ref
*arange_ref
;
2072 /* Describe a double word constant value. */
2074 typedef struct dw_long_long_struct
2081 /* Describe a floating point constant value. */
2083 typedef struct dw_fp_struct
2090 /* Each entry in the line_info_table maintains the file and
2091 line number associated with the label generated for that
2092 entry. The label gives the PC value associated with
2093 the line number entry. */
2095 typedef struct dw_line_info_struct
2097 unsigned long dw_file_num
;
2098 unsigned long dw_line_num
;
2102 /* Line information for functions in separate sections; each one gets its
2104 typedef struct dw_separate_line_info_struct
2106 unsigned long dw_file_num
;
2107 unsigned long dw_line_num
;
2108 unsigned long function
;
2110 dw_separate_line_info_entry
;
2112 /* The dw_val_node describes an attribute's value, as it is
2113 represented internally. */
2115 typedef struct dw_val_struct
2117 dw_val_class val_class
;
2121 dw_loc_descr_ref val_loc
;
2123 long unsigned val_unsigned
;
2124 dw_long_long_const val_long_long
;
2125 dw_float_const val_float
;
2126 dw_die_ref val_die_ref
;
2127 unsigned val_fde_index
;
2130 unsigned char val_flag
;
2136 /* Locations in memory are described using a sequence of stack machine
2139 typedef struct dw_loc_descr_struct
2141 dw_loc_descr_ref dw_loc_next
;
2142 enum dwarf_location_atom dw_loc_opc
;
2143 dw_val_node dw_loc_oprnd1
;
2144 dw_val_node dw_loc_oprnd2
;
2148 /* Each DIE attribute has a field specifying the attribute kind,
2149 a link to the next attribute in the chain, and an attribute value.
2150 Attributes are typically linked below the DIE they modify. */
2152 typedef struct dw_attr_struct
2154 enum dwarf_attribute dw_attr
;
2155 dw_attr_ref dw_attr_next
;
2156 dw_val_node dw_attr_val
;
2160 /* The Debugging Information Entry (DIE) structure */
2162 typedef struct die_struct
2164 enum dwarf_tag die_tag
;
2165 dw_attr_ref die_attr
;
2166 dw_attr_ref die_attr_last
;
2167 dw_die_ref die_parent
;
2168 dw_die_ref die_child
;
2169 dw_die_ref die_child_last
;
2171 dw_offset die_offset
;
2172 unsigned long die_abbrev
;
2176 /* The pubname structure */
2178 typedef struct pubname_struct
2185 /* The limbo die list structure. */
2186 typedef struct limbo_die_struct
2189 struct limbo_die_struct
*next
;
2193 /* How to start an assembler comment. */
2194 #ifndef ASM_COMMENT_START
2195 #define ASM_COMMENT_START ";#"
2198 /* Define a macro which returns non-zero for a TYPE_DECL which was
2199 implicitly generated for a tagged type.
2201 Note that unlike the gcc front end (which generates a NULL named
2202 TYPE_DECL node for each complete tagged type, each array type, and
2203 each function type node created) the g++ front end generates a
2204 _named_ TYPE_DECL node for each tagged type node created.
2205 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
2206 generate a DW_TAG_typedef DIE for them. */
2208 #define TYPE_DECL_IS_STUB(decl) \
2209 (DECL_NAME (decl) == NULL_TREE \
2210 || (DECL_ARTIFICIAL (decl) \
2211 && is_tagged_type (TREE_TYPE (decl)) \
2212 && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \
2213 /* This is necessary for stub decls that \
2214 appear in nested inline functions. */ \
2215 || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
2216 && (decl_ultimate_origin (decl) \
2217 == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
2219 /* Information concerning the compilation unit's programming
2220 language, and compiler version. */
2222 extern int flag_traditional
;
2223 extern char *version_string
;
2224 extern char *language_string
;
2226 /* Fixed size portion of the DWARF compilation unit header. */
2227 #define DWARF_COMPILE_UNIT_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 3)
2229 /* Fixed size portion of debugging line information prolog. */
2230 #define DWARF_LINE_PROLOG_HEADER_SIZE 5
2232 /* Fixed size portion of public names info. */
2233 #define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
2235 /* Fixed size portion of the address range info. */
2236 #define DWARF_ARANGES_HEADER_SIZE \
2237 (DWARF_ROUND (2 * DWARF_OFFSET_SIZE + 4, PTR_SIZE * 2) - DWARF_OFFSET_SIZE)
2239 /* Define the architecture-dependent minimum instruction length (in bytes).
2240 In this implementation of DWARF, this field is used for information
2241 purposes only. Since GCC generates assembly language, we have
2242 no a priori knowledge of how many instruction bytes are generated
2243 for each source line, and therefore can use only the DW_LNE_set_address
2244 and DW_LNS_fixed_advance_pc line information commands. */
2246 #ifndef DWARF_LINE_MIN_INSTR_LENGTH
2247 #define DWARF_LINE_MIN_INSTR_LENGTH 4
2250 /* Minimum line offset in a special line info. opcode.
2251 This value was chosen to give a reasonable range of values. */
2252 #define DWARF_LINE_BASE -10
2254 /* First special line opcde - leave room for the standard opcodes. */
2255 #define DWARF_LINE_OPCODE_BASE 10
2257 /* Range of line offsets in a special line info. opcode. */
2258 #define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1)
2260 /* Flag that indicates the initial value of the is_stmt_start flag.
2261 In the present implementation, we do not mark any lines as
2262 the beginning of a source statement, because that information
2263 is not made available by the GCC front-end. */
2264 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
2266 /* This location is used by calc_die_sizes() to keep track
2267 the offset of each DIE within the .debug_info section. */
2268 static unsigned long next_die_offset
;
2270 /* Record the root of the DIE's built for the current compilation unit. */
2271 static dw_die_ref comp_unit_die
;
2273 /* A list of DIEs with a NULL parent waiting to be relocated. */
2274 static limbo_die_node
*limbo_die_list
= 0;
2276 /* Pointer to an array of filenames referenced by this compilation unit. */
2277 static char **file_table
;
2279 /* Total number of entries in the table (i.e. array) pointed to by
2280 `file_table'. This is the *total* and includes both used and unused
2282 static unsigned file_table_allocated
;
2284 /* Number of entries in the file_table which are actually in use. */
2285 static unsigned file_table_in_use
;
2287 /* Size (in elements) of increments by which we may expand the filename
2289 #define FILE_TABLE_INCREMENT 64
2291 /* Local pointer to the name of the main input file. Initialized in
2293 static char *primary_filename
;
2295 /* For Dwarf output, we must assign lexical-blocks id numbers in the order in
2296 which their beginnings are encountered. We output Dwarf debugging info
2297 that refers to the beginnings and ends of the ranges of code for each
2298 lexical block. The labels themselves are generated in final.c, which
2299 assigns numbers to the blocks in the same way. */
2300 static unsigned next_block_number
= 2;
2302 /* A pointer to the base of a table of references to DIE's that describe
2303 declarations. The table is indexed by DECL_UID() which is a unique
2304 number identifying each decl. */
2305 static dw_die_ref
*decl_die_table
;
2307 /* Number of elements currently allocated for the decl_die_table. */
2308 static unsigned decl_die_table_allocated
;
2310 /* Number of elements in decl_die_table currently in use. */
2311 static unsigned decl_die_table_in_use
;
2313 /* Size (in elements) of increments by which we may expand the
2315 #define DECL_DIE_TABLE_INCREMENT 256
2317 /* Structure used for the decl_scope table. scope is the current declaration
2318 scope, and previous is the entry that is the parent of this scope. This
2319 is usually but not always the immediately preceeding entry. */
2321 typedef struct decl_scope_struct
2328 /* A pointer to the base of a table of references to declaration
2329 scopes. This table is a display which tracks the nesting
2330 of declaration scopes at the current scope and containing
2331 scopes. This table is used to find the proper place to
2332 define type declaration DIE's. */
2333 static decl_scope_node
*decl_scope_table
;
2335 /* Number of elements currently allocated for the decl_scope_table. */
2336 static int decl_scope_table_allocated
;
2338 /* Current level of nesting of declaration scopes. */
2339 static int decl_scope_depth
;
2341 /* Size (in elements) of increments by which we may expand the
2342 decl_scope_table. */
2343 #define DECL_SCOPE_TABLE_INCREMENT 64
2345 /* A pointer to the base of a list of references to DIE's that
2346 are uniquely identified by their tag, presence/absence of
2347 children DIE's, and list of attribute/value pairs. */
2348 static dw_die_ref
*abbrev_die_table
;
2350 /* Number of elements currently allocated for abbrev_die_table. */
2351 static unsigned abbrev_die_table_allocated
;
2353 /* Number of elements in type_die_table currently in use. */
2354 static unsigned abbrev_die_table_in_use
;
2356 /* Size (in elements) of increments by which we may expand the
2357 abbrev_die_table. */
2358 #define ABBREV_DIE_TABLE_INCREMENT 256
2360 /* A pointer to the base of a table that contains line information
2361 for each source code line in .text in the compilation unit. */
2362 static dw_line_info_ref line_info_table
;
2364 /* Number of elements currently allocated for line_info_table. */
2365 static unsigned line_info_table_allocated
;
2367 /* Number of elements in separate_line_info_table currently in use. */
2368 static unsigned separate_line_info_table_in_use
;
2370 /* A pointer to the base of a table that contains line information
2371 for each source code line outside of .text in the compilation unit. */
2372 static dw_separate_line_info_ref separate_line_info_table
;
2374 /* Number of elements currently allocated for separate_line_info_table. */
2375 static unsigned separate_line_info_table_allocated
;
2377 /* Number of elements in line_info_table currently in use. */
2378 static unsigned line_info_table_in_use
;
2380 /* Size (in elements) of increments by which we may expand the
2382 #define LINE_INFO_TABLE_INCREMENT 1024
2384 /* A pointer to the base of a table that contains a list of publicly
2385 accessible names. */
2386 static pubname_ref pubname_table
;
2388 /* Number of elements currently allocated for pubname_table. */
2389 static unsigned pubname_table_allocated
;
2391 /* Number of elements in pubname_table currently in use. */
2392 static unsigned pubname_table_in_use
;
2394 /* Size (in elements) of increments by which we may expand the
2396 #define PUBNAME_TABLE_INCREMENT 64
2398 /* A pointer to the base of a table that contains a list of publicly
2399 accessible names. */
2400 static arange_ref arange_table
;
2402 /* Number of elements currently allocated for arange_table. */
2403 static unsigned arange_table_allocated
;
2405 /* Number of elements in arange_table currently in use. */
2406 static unsigned arange_table_in_use
;
2408 /* Size (in elements) of increments by which we may expand the
2410 #define ARANGE_TABLE_INCREMENT 64
2412 /* A pointer to the base of a list of pending types which we haven't
2413 generated DIEs for yet, but which we will have to come back to
2416 static tree
*pending_types_list
;
2418 /* Number of elements currently allocated for the pending_types_list. */
2419 static unsigned pending_types_allocated
;
2421 /* Number of elements of pending_types_list currently in use. */
2422 static unsigned pending_types
;
2424 /* Size (in elements) of increments by which we may expand the pending
2425 types list. Actually, a single hunk of space of this size should
2426 be enough for most typical programs. */
2427 #define PENDING_TYPES_INCREMENT 64
2429 /* A pointer to the base of a list of incomplete types which might be
2430 completed at some later time. */
2432 static tree
*incomplete_types_list
;
2434 /* Number of elements currently allocated for the incomplete_types_list. */
2435 static unsigned incomplete_types_allocated
;
2437 /* Number of elements of incomplete_types_list currently in use. */
2438 static unsigned incomplete_types
;
2440 /* Size (in elements) of increments by which we may expand the incomplete
2441 types list. Actually, a single hunk of space of this size should
2442 be enough for most typical programs. */
2443 #define INCOMPLETE_TYPES_INCREMENT 64
2445 /* Record whether the function being analyzed contains inlined functions. */
2446 static int current_function_has_inlines
;
2447 #if 0 && defined (MIPS_DEBUGGING_INFO)
2448 static int comp_unit_has_inlines
;
2451 /* A pointer to the ..._DECL node which we have most recently been working
2452 on. We keep this around just in case something about it looks screwy and
2453 we want to tell the user what the source coordinates for the actual
2455 static tree dwarf_last_decl
;
2457 /* Forward declarations for functions defined in this file. */
2459 static void addr_const_to_string
PROTO((dyn_string_t
, rtx
));
2460 static char *addr_to_string
PROTO((rtx
));
2461 static int is_pseudo_reg
PROTO((rtx
));
2462 static tree type_main_variant
PROTO((tree
));
2463 static int is_tagged_type
PROTO((tree
));
2464 static char *dwarf_tag_name
PROTO((unsigned));
2465 static char *dwarf_attr_name
PROTO((unsigned));
2466 static char *dwarf_form_name
PROTO((unsigned));
2467 static char *dwarf_stack_op_name
PROTO((unsigned));
2469 static char *dwarf_type_encoding_name
PROTO((unsigned));
2471 static tree decl_ultimate_origin
PROTO((tree
));
2472 static tree block_ultimate_origin
PROTO((tree
));
2473 static tree decl_class_context
PROTO((tree
));
2474 static void add_dwarf_attr
PROTO((dw_die_ref
, dw_attr_ref
));
2475 static void add_AT_flag
PROTO((dw_die_ref
,
2476 enum dwarf_attribute
,
2478 static void add_AT_int
PROTO((dw_die_ref
,
2479 enum dwarf_attribute
, long));
2480 static void add_AT_unsigned
PROTO((dw_die_ref
,
2481 enum dwarf_attribute
,
2483 static void add_AT_long_long
PROTO((dw_die_ref
,
2484 enum dwarf_attribute
,
2485 unsigned long, unsigned long));
2486 static void add_AT_float
PROTO((dw_die_ref
,
2487 enum dwarf_attribute
,
2489 static void add_AT_string
PROTO((dw_die_ref
,
2490 enum dwarf_attribute
, char *));
2491 static void add_AT_die_ref
PROTO((dw_die_ref
,
2492 enum dwarf_attribute
,
2494 static void add_AT_fde_ref
PROTO((dw_die_ref
,
2495 enum dwarf_attribute
,
2497 static void add_AT_loc
PROTO((dw_die_ref
,
2498 enum dwarf_attribute
,
2500 static void add_AT_addr
PROTO((dw_die_ref
,
2501 enum dwarf_attribute
, char *));
2502 static void add_AT_lbl_id
PROTO((dw_die_ref
,
2503 enum dwarf_attribute
, char *));
2504 static void add_AT_lbl_offset
PROTO((dw_die_ref
,
2505 enum dwarf_attribute
, char *));
2506 static int is_extern_subr_die
PROTO((dw_die_ref
));
2507 static dw_attr_ref get_AT
PROTO((dw_die_ref
,
2508 enum dwarf_attribute
));
2509 static char *get_AT_low_pc
PROTO((dw_die_ref
));
2510 static char *get_AT_hi_pc
PROTO((dw_die_ref
));
2511 static char *get_AT_string
PROTO((dw_die_ref
,
2512 enum dwarf_attribute
));
2513 static int get_AT_flag
PROTO((dw_die_ref
,
2514 enum dwarf_attribute
));
2515 static unsigned get_AT_unsigned
PROTO((dw_die_ref
,
2516 enum dwarf_attribute
));
2517 static int is_c_family
PROTO((void));
2518 static int is_fortran
PROTO((void));
2519 static void remove_AT
PROTO((dw_die_ref
,
2520 enum dwarf_attribute
));
2521 static void remove_children
PROTO((dw_die_ref
));
2522 static void add_child_die
PROTO((dw_die_ref
, dw_die_ref
));
2523 static dw_die_ref new_die
PROTO((enum dwarf_tag
, dw_die_ref
));
2524 static dw_die_ref lookup_type_die
PROTO((tree
));
2525 static void equate_type_number_to_die
PROTO((tree
, dw_die_ref
));
2526 static dw_die_ref lookup_decl_die
PROTO((tree
));
2527 static void equate_decl_number_to_die
PROTO((tree
, dw_die_ref
));
2528 static dw_loc_descr_ref new_loc_descr
PROTO((enum dwarf_location_atom
,
2529 unsigned long, unsigned long));
2530 static void add_loc_descr
PROTO((dw_loc_descr_ref
*,
2532 static void print_spaces
PROTO((FILE *));
2533 static void print_die
PROTO((dw_die_ref
, FILE *));
2534 static void print_dwarf_line_table
PROTO((FILE *));
2535 static void add_sibling_attributes
PROTO((dw_die_ref
));
2536 static void build_abbrev_table
PROTO((dw_die_ref
));
2537 static unsigned long size_of_string
PROTO((char *));
2538 static unsigned long size_of_loc_descr
PROTO((dw_loc_descr_ref
));
2539 static unsigned long size_of_locs
PROTO((dw_loc_descr_ref
));
2540 static int constant_size
PROTO((long unsigned));
2541 static unsigned long size_of_die
PROTO((dw_die_ref
));
2542 static void calc_die_sizes
PROTO((dw_die_ref
));
2543 static unsigned long size_of_line_prolog
PROTO((void));
2544 static unsigned long size_of_line_info
PROTO((void));
2545 static unsigned long size_of_pubnames
PROTO((void));
2546 static unsigned long size_of_aranges
PROTO((void));
2547 static enum dwarf_form value_format
PROTO((dw_val_ref
));
2548 static void output_value_format
PROTO((dw_val_ref
));
2549 static void output_abbrev_section
PROTO((void));
2550 static void output_loc_operands
PROTO((dw_loc_descr_ref
));
2551 static unsigned long sibling_offset
PROTO((dw_die_ref
));
2552 static void output_die
PROTO((dw_die_ref
));
2553 static void output_compilation_unit_header
PROTO((void));
2554 static char *dwarf2_name
PROTO((tree
, int));
2555 static void add_pubname
PROTO((tree
, dw_die_ref
));
2556 static void output_pubnames
PROTO((void));
2557 static void add_arange
PROTO((tree
, dw_die_ref
));
2558 static void output_aranges
PROTO((void));
2559 static void output_line_info
PROTO((void));
2560 static int is_body_block
PROTO((tree
));
2561 static dw_die_ref base_type_die
PROTO((tree
));
2562 static tree root_type
PROTO((tree
));
2563 static int is_base_type
PROTO((tree
));
2564 static dw_die_ref modified_type_die
PROTO((tree
, int, int, dw_die_ref
));
2565 static int type_is_enum
PROTO((tree
));
2566 static dw_loc_descr_ref reg_loc_descriptor
PROTO((rtx
));
2567 static dw_loc_descr_ref based_loc_descr
PROTO((unsigned, long));
2568 static int is_based_loc
PROTO((rtx
));
2569 static dw_loc_descr_ref mem_loc_descriptor
PROTO((rtx
));
2570 static dw_loc_descr_ref concat_loc_descriptor
PROTO((rtx
, rtx
));
2571 static dw_loc_descr_ref loc_descriptor
PROTO((rtx
));
2572 static unsigned ceiling
PROTO((unsigned, unsigned));
2573 static tree field_type
PROTO((tree
));
2574 static unsigned simple_type_align_in_bits
PROTO((tree
));
2575 static unsigned simple_type_size_in_bits
PROTO((tree
));
2576 static unsigned field_byte_offset
PROTO((tree
));
2577 static void add_AT_location_description
PROTO((dw_die_ref
,
2578 enum dwarf_attribute
, rtx
));
2579 static void add_data_member_location_attribute
PROTO((dw_die_ref
, tree
));
2580 static void add_const_value_attribute
PROTO((dw_die_ref
, rtx
));
2581 static void add_location_or_const_value_attribute
PROTO((dw_die_ref
, tree
));
2582 static void add_name_attribute
PROTO((dw_die_ref
, char *));
2583 static void add_bound_info
PROTO((dw_die_ref
,
2584 enum dwarf_attribute
, tree
));
2585 static void add_subscript_info
PROTO((dw_die_ref
, tree
));
2586 static void add_byte_size_attribute
PROTO((dw_die_ref
, tree
));
2587 static void add_bit_offset_attribute
PROTO((dw_die_ref
, tree
));
2588 static void add_bit_size_attribute
PROTO((dw_die_ref
, tree
));
2589 static void add_prototyped_attribute
PROTO((dw_die_ref
, tree
));
2590 static void add_abstract_origin_attribute
PROTO((dw_die_ref
, tree
));
2591 static void add_pure_or_virtual_attribute
PROTO((dw_die_ref
, tree
));
2592 static void add_src_coords_attributes
PROTO((dw_die_ref
, tree
));
2593 static void add_name_and_src_coords_attributes
PROTO((dw_die_ref
, tree
));
2594 static void push_decl_scope
PROTO((tree
));
2595 static dw_die_ref scope_die_for
PROTO((tree
, dw_die_ref
));
2596 static void pop_decl_scope
PROTO((void));
2597 static void add_type_attribute
PROTO((dw_die_ref
, tree
, int, int,
2599 static char *type_tag
PROTO((tree
));
2600 static tree member_declared_type
PROTO((tree
));
2602 static char *decl_start_label
PROTO((tree
));
2604 static void gen_array_type_die
PROTO((tree
, dw_die_ref
));
2605 static void gen_set_type_die
PROTO((tree
, dw_die_ref
));
2607 static void gen_entry_point_die
PROTO((tree
, dw_die_ref
));
2609 static void pend_type
PROTO((tree
));
2610 static void output_pending_types_for_scope
PROTO((dw_die_ref
));
2611 static void gen_inlined_enumeration_type_die
PROTO((tree
, dw_die_ref
));
2612 static void gen_inlined_structure_type_die
PROTO((tree
, dw_die_ref
));
2613 static void gen_inlined_union_type_die
PROTO((tree
, dw_die_ref
));
2614 static void gen_enumeration_type_die
PROTO((tree
, dw_die_ref
));
2615 static dw_die_ref gen_formal_parameter_die
PROTO((tree
, dw_die_ref
));
2616 static void gen_unspecified_parameters_die
PROTO((tree
, dw_die_ref
));
2617 static void gen_formal_types_die
PROTO((tree
, dw_die_ref
));
2618 static void gen_subprogram_die
PROTO((tree
, dw_die_ref
));
2619 static void gen_variable_die
PROTO((tree
, dw_die_ref
));
2620 static void gen_label_die
PROTO((tree
, dw_die_ref
));
2621 static void gen_lexical_block_die
PROTO((tree
, dw_die_ref
, int));
2622 static void gen_inlined_subroutine_die
PROTO((tree
, dw_die_ref
, int));
2623 static void gen_field_die
PROTO((tree
, dw_die_ref
));
2624 static void gen_ptr_to_mbr_type_die
PROTO((tree
, dw_die_ref
));
2625 static void gen_compile_unit_die
PROTO((char *));
2626 static void gen_string_type_die
PROTO((tree
, dw_die_ref
));
2627 static void gen_inheritance_die
PROTO((tree
, dw_die_ref
));
2628 static void gen_member_die
PROTO((tree
, dw_die_ref
));
2629 static void gen_struct_or_union_type_die
PROTO((tree
, dw_die_ref
));
2630 static void gen_subroutine_type_die
PROTO((tree
, dw_die_ref
));
2631 static void gen_typedef_die
PROTO((tree
, dw_die_ref
));
2632 static void gen_type_die
PROTO((tree
, dw_die_ref
));
2633 static void gen_tagged_type_instantiation_die
PROTO((tree
, dw_die_ref
));
2634 static void gen_block_die
PROTO((tree
, dw_die_ref
, int));
2635 static void decls_for_scope
PROTO((tree
, dw_die_ref
, int));
2636 static int is_redundant_typedef
PROTO((tree
));
2637 static void gen_decl_die
PROTO((tree
, dw_die_ref
));
2638 static unsigned lookup_filename
PROTO((char *));
2640 /* Section names used to hold DWARF debugging information. */
2641 #ifndef DEBUG_INFO_SECTION
2642 #define DEBUG_INFO_SECTION ".debug_info"
2644 #ifndef ABBREV_SECTION
2645 #define ABBREV_SECTION ".debug_abbrev"
2647 #ifndef ARANGES_SECTION
2648 #define ARANGES_SECTION ".debug_aranges"
2650 #ifndef DW_MACINFO_SECTION
2651 #define DW_MACINFO_SECTION ".debug_macinfo"
2653 #ifndef DEBUG_LINE_SECTION
2654 #define DEBUG_LINE_SECTION ".debug_line"
2657 #define LOC_SECTION ".debug_loc"
2659 #ifndef PUBNAMES_SECTION
2660 #define PUBNAMES_SECTION ".debug_pubnames"
2663 #define STR_SECTION ".debug_str"
2666 /* Standard ELF section names for compiled code and data. */
2667 #ifndef TEXT_SECTION
2668 #define TEXT_SECTION ".text"
2670 #ifndef DATA_SECTION
2671 #define DATA_SECTION ".data"
2674 #define BSS_SECTION ".bss"
2677 /* Labels we insert at beginning sections we can reference instead of
2678 the section names themselves. */
2680 #ifndef TEXT_SECTION_LABEL
2681 #define TEXT_SECTION_LABEL "Ltext"
2683 #ifndef DEBUG_LINE_SECTION_LABEL
2684 #define DEBUG_LINE_SECTION_LABEL "Ldebug_line"
2686 #ifndef DEBUG_INFO_SECTION_LABEL
2687 #define DEBUG_INFO_SECTION_LABEL "Ldebug_info"
2689 #ifndef ABBREV_SECTION_LABEL
2690 #define ABBREV_SECTION_LABEL "Ldebug_abbrev"
2694 /* Definitions of defaults for formats and names of various special
2695 (artificial) labels which may be generated within this file (when the -g
2696 options is used and DWARF_DEBUGGING_INFO is in effect.
2697 If necessary, these may be overridden from within the tm.h file, but
2698 typically, overriding these defaults is unnecessary. */
2700 static char text_end_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
2701 static char text_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
2702 static char abbrev_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
2703 static char debug_info_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
2704 static char debug_line_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
2706 #ifndef TEXT_END_LABEL
2707 #define TEXT_END_LABEL "Letext"
2709 #ifndef DATA_END_LABEL
2710 #define DATA_END_LABEL "Ledata"
2712 #ifndef BSS_END_LABEL
2713 #define BSS_END_LABEL "Lebss"
2715 #ifndef INSN_LABEL_FMT
2716 #define INSN_LABEL_FMT "LI%u_"
2718 #ifndef BLOCK_BEGIN_LABEL
2719 #define BLOCK_BEGIN_LABEL "LBB"
2721 #ifndef BLOCK_END_LABEL
2722 #define BLOCK_END_LABEL "LBE"
2724 #ifndef BODY_BEGIN_LABEL
2725 #define BODY_BEGIN_LABEL "Lbb"
2727 #ifndef BODY_END_LABEL
2728 #define BODY_END_LABEL "Lbe"
2730 #ifndef LINE_CODE_LABEL
2731 #define LINE_CODE_LABEL "LM"
2733 #ifndef SEPARATE_LINE_CODE_LABEL
2734 #define SEPARATE_LINE_CODE_LABEL "LSM"
2737 /* Convert a reference to the assembler name of a C-level name. This
2738 macro has the same effect as ASM_OUTPUT_LABELREF, but copies to
2739 a string rather than writing to a file. */
2740 #ifndef ASM_NAME_TO_STRING
2741 #define ASM_NAME_TO_STRING(STR, NAME) \
2743 if ((NAME)[0] == '*') \
2744 dyn_string_append (STR, NAME + 1); \
2748 STRIP_NAME_ENCODING (newstr, NAME); \
2749 dyn_string_append (STR, user_label_prefix); \
2750 dyn_string_append (STR, newstr); \
2756 /* Convert an integer constant expression into assembler syntax. Addition
2757 and subtraction are the only arithmetic that may appear in these
2758 expressions. This is an adaptation of output_addr_const in final.c.
2759 Here, the target of the conversion is a string buffer. We can't use
2760 output_addr_const directly, because it writes to a file. */
2763 addr_const_to_string (str
, x
)
2770 switch (GET_CODE (x
))
2774 dyn_string_append (str
, ",");
2780 ASM_NAME_TO_STRING (str
, XSTR (x
, 0));
2784 ASM_GENERATE_INTERNAL_LABEL (buf1
, "L", CODE_LABEL_NUMBER (XEXP (x
, 0)));
2785 ASM_NAME_TO_STRING (str
, buf1
);
2789 ASM_GENERATE_INTERNAL_LABEL (buf1
, "L", CODE_LABEL_NUMBER (x
));
2790 ASM_NAME_TO_STRING (str
, buf1
);
2794 sprintf (buf1
, HOST_WIDE_INT_PRINT_DEC
, INTVAL (x
));
2795 dyn_string_append (str
, buf1
);
2799 /* This used to output parentheses around the expression, but that does
2800 not work on the 386 (either ATT or BSD assembler). */
2801 addr_const_to_string (str
, XEXP (x
, 0));
2805 if (GET_MODE (x
) == VOIDmode
)
2807 /* We can use %d if the number is one word and positive. */
2808 if (CONST_DOUBLE_HIGH (x
))
2809 sprintf (buf1
, HOST_WIDE_INT_PRINT_DOUBLE_HEX
,
2810 CONST_DOUBLE_HIGH (x
), CONST_DOUBLE_LOW (x
));
2811 else if (CONST_DOUBLE_LOW (x
) < 0)
2812 sprintf (buf1
, HOST_WIDE_INT_PRINT_HEX
, CONST_DOUBLE_LOW (x
));
2814 sprintf (buf1
, HOST_WIDE_INT_PRINT_DEC
,
2815 CONST_DOUBLE_LOW (x
));
2816 dyn_string_append (str
, buf1
);
2819 /* We can't handle floating point constants; PRINT_OPERAND must
2821 output_operand_lossage ("floating constant misused");
2825 /* Some assemblers need integer constants to appear last (eg masm). */
2826 if (GET_CODE (XEXP (x
, 0)) == CONST_INT
)
2828 addr_const_to_string (str
, XEXP (x
, 1));
2829 if (INTVAL (XEXP (x
, 0)) >= 0)
2830 dyn_string_append (str
, "+");
2832 addr_const_to_string (str
, XEXP (x
, 0));
2836 addr_const_to_string (str
, XEXP (x
, 0));
2837 if (INTVAL (XEXP (x
, 1)) >= 0)
2838 dyn_string_append (str
, "+");
2840 addr_const_to_string (str
, XEXP (x
, 1));
2845 /* Avoid outputting things like x-x or x+5-x, since some assemblers
2846 can't handle that. */
2847 x
= simplify_subtraction (x
);
2848 if (GET_CODE (x
) != MINUS
)
2851 addr_const_to_string (str
, XEXP (x
, 0));
2852 dyn_string_append (str
, "-");
2853 if (GET_CODE (XEXP (x
, 1)) == CONST_INT
2854 && INTVAL (XEXP (x
, 1)) < 0)
2856 dyn_string_append (str
, ASM_OPEN_PAREN
);
2857 addr_const_to_string (str
, XEXP (x
, 1));
2858 dyn_string_append (str
, ASM_CLOSE_PAREN
);
2861 addr_const_to_string (str
, XEXP (x
, 1));
2866 addr_const_to_string (str
, XEXP (x
, 0));
2870 output_operand_lossage ("invalid expression as operand");
2874 /* Convert an address constant to a string, and return a pointer to
2875 a copy of the result, located on the heap. */
2881 dyn_string_t ds
= dyn_string_new (256);
2884 addr_const_to_string (ds
, x
);
2886 /* Return the dynamically allocated string, but free the
2887 dyn_string_t itself. */
2893 /* Test if rtl node points to a pseudo register. */
2899 return (((GET_CODE (rtl
) == REG
) && (REGNO (rtl
) >= FIRST_PSEUDO_REGISTER
))
2900 || ((GET_CODE (rtl
) == SUBREG
)
2901 && (REGNO (XEXP (rtl
, 0)) >= FIRST_PSEUDO_REGISTER
)));
2904 /* Return a reference to a type, with its const and volatile qualifiers
2908 type_main_variant (type
)
2911 type
= TYPE_MAIN_VARIANT (type
);
2913 /* There really should be only one main variant among any group of variants
2914 of a given type (and all of the MAIN_VARIANT values for all members of
2915 the group should point to that one type) but sometimes the C front-end
2916 messes this up for array types, so we work around that bug here. */
2918 if (TREE_CODE (type
) == ARRAY_TYPE
)
2919 while (type
!= TYPE_MAIN_VARIANT (type
))
2920 type
= TYPE_MAIN_VARIANT (type
);
2925 /* Return non-zero if the given type node represents a tagged type. */
2928 is_tagged_type (type
)
2931 register enum tree_code code
= TREE_CODE (type
);
2933 return (code
== RECORD_TYPE
|| code
== UNION_TYPE
2934 || code
== QUAL_UNION_TYPE
|| code
== ENUMERAL_TYPE
);
2937 /* Convert a DIE tag into its string name. */
2940 dwarf_tag_name (tag
)
2941 register unsigned tag
;
2945 case DW_TAG_padding
:
2946 return "DW_TAG_padding";
2947 case DW_TAG_array_type
:
2948 return "DW_TAG_array_type";
2949 case DW_TAG_class_type
:
2950 return "DW_TAG_class_type";
2951 case DW_TAG_entry_point
:
2952 return "DW_TAG_entry_point";
2953 case DW_TAG_enumeration_type
:
2954 return "DW_TAG_enumeration_type";
2955 case DW_TAG_formal_parameter
:
2956 return "DW_TAG_formal_parameter";
2957 case DW_TAG_imported_declaration
:
2958 return "DW_TAG_imported_declaration";
2960 return "DW_TAG_label";
2961 case DW_TAG_lexical_block
:
2962 return "DW_TAG_lexical_block";
2964 return "DW_TAG_member";
2965 case DW_TAG_pointer_type
:
2966 return "DW_TAG_pointer_type";
2967 case DW_TAG_reference_type
:
2968 return "DW_TAG_reference_type";
2969 case DW_TAG_compile_unit
:
2970 return "DW_TAG_compile_unit";
2971 case DW_TAG_string_type
:
2972 return "DW_TAG_string_type";
2973 case DW_TAG_structure_type
:
2974 return "DW_TAG_structure_type";
2975 case DW_TAG_subroutine_type
:
2976 return "DW_TAG_subroutine_type";
2977 case DW_TAG_typedef
:
2978 return "DW_TAG_typedef";
2979 case DW_TAG_union_type
:
2980 return "DW_TAG_union_type";
2981 case DW_TAG_unspecified_parameters
:
2982 return "DW_TAG_unspecified_parameters";
2983 case DW_TAG_variant
:
2984 return "DW_TAG_variant";
2985 case DW_TAG_common_block
:
2986 return "DW_TAG_common_block";
2987 case DW_TAG_common_inclusion
:
2988 return "DW_TAG_common_inclusion";
2989 case DW_TAG_inheritance
:
2990 return "DW_TAG_inheritance";
2991 case DW_TAG_inlined_subroutine
:
2992 return "DW_TAG_inlined_subroutine";
2994 return "DW_TAG_module";
2995 case DW_TAG_ptr_to_member_type
:
2996 return "DW_TAG_ptr_to_member_type";
2997 case DW_TAG_set_type
:
2998 return "DW_TAG_set_type";
2999 case DW_TAG_subrange_type
:
3000 return "DW_TAG_subrange_type";
3001 case DW_TAG_with_stmt
:
3002 return "DW_TAG_with_stmt";
3003 case DW_TAG_access_declaration
:
3004 return "DW_TAG_access_declaration";
3005 case DW_TAG_base_type
:
3006 return "DW_TAG_base_type";
3007 case DW_TAG_catch_block
:
3008 return "DW_TAG_catch_block";
3009 case DW_TAG_const_type
:
3010 return "DW_TAG_const_type";
3011 case DW_TAG_constant
:
3012 return "DW_TAG_constant";
3013 case DW_TAG_enumerator
:
3014 return "DW_TAG_enumerator";
3015 case DW_TAG_file_type
:
3016 return "DW_TAG_file_type";
3018 return "DW_TAG_friend";
3019 case DW_TAG_namelist
:
3020 return "DW_TAG_namelist";
3021 case DW_TAG_namelist_item
:
3022 return "DW_TAG_namelist_item";
3023 case DW_TAG_packed_type
:
3024 return "DW_TAG_packed_type";
3025 case DW_TAG_subprogram
:
3026 return "DW_TAG_subprogram";
3027 case DW_TAG_template_type_param
:
3028 return "DW_TAG_template_type_param";
3029 case DW_TAG_template_value_param
:
3030 return "DW_TAG_template_value_param";
3031 case DW_TAG_thrown_type
:
3032 return "DW_TAG_thrown_type";
3033 case DW_TAG_try_block
:
3034 return "DW_TAG_try_block";
3035 case DW_TAG_variant_part
:
3036 return "DW_TAG_variant_part";
3037 case DW_TAG_variable
:
3038 return "DW_TAG_variable";
3039 case DW_TAG_volatile_type
:
3040 return "DW_TAG_volatile_type";
3041 case DW_TAG_MIPS_loop
:
3042 return "DW_TAG_MIPS_loop";
3043 case DW_TAG_format_label
:
3044 return "DW_TAG_format_label";
3045 case DW_TAG_function_template
:
3046 return "DW_TAG_function_template";
3047 case DW_TAG_class_template
:
3048 return "DW_TAG_class_template";
3050 return "DW_TAG_<unknown>";
3054 /* Convert a DWARF attribute code into its string name. */
3057 dwarf_attr_name (attr
)
3058 register unsigned attr
;
3063 return "DW_AT_sibling";
3064 case DW_AT_location
:
3065 return "DW_AT_location";
3067 return "DW_AT_name";
3068 case DW_AT_ordering
:
3069 return "DW_AT_ordering";
3070 case DW_AT_subscr_data
:
3071 return "DW_AT_subscr_data";
3072 case DW_AT_byte_size
:
3073 return "DW_AT_byte_size";
3074 case DW_AT_bit_offset
:
3075 return "DW_AT_bit_offset";
3076 case DW_AT_bit_size
:
3077 return "DW_AT_bit_size";
3078 case DW_AT_element_list
:
3079 return "DW_AT_element_list";
3080 case DW_AT_stmt_list
:
3081 return "DW_AT_stmt_list";
3083 return "DW_AT_low_pc";
3085 return "DW_AT_high_pc";
3086 case DW_AT_language
:
3087 return "DW_AT_language";
3089 return "DW_AT_member";
3091 return "DW_AT_discr";
3092 case DW_AT_discr_value
:
3093 return "DW_AT_discr_value";
3094 case DW_AT_visibility
:
3095 return "DW_AT_visibility";
3097 return "DW_AT_import";
3098 case DW_AT_string_length
:
3099 return "DW_AT_string_length";
3100 case DW_AT_common_reference
:
3101 return "DW_AT_common_reference";
3102 case DW_AT_comp_dir
:
3103 return "DW_AT_comp_dir";
3104 case DW_AT_const_value
:
3105 return "DW_AT_const_value";
3106 case DW_AT_containing_type
:
3107 return "DW_AT_containing_type";
3108 case DW_AT_default_value
:
3109 return "DW_AT_default_value";
3111 return "DW_AT_inline";
3112 case DW_AT_is_optional
:
3113 return "DW_AT_is_optional";
3114 case DW_AT_lower_bound
:
3115 return "DW_AT_lower_bound";
3116 case DW_AT_producer
:
3117 return "DW_AT_producer";
3118 case DW_AT_prototyped
:
3119 return "DW_AT_prototyped";
3120 case DW_AT_return_addr
:
3121 return "DW_AT_return_addr";
3122 case DW_AT_start_scope
:
3123 return "DW_AT_start_scope";
3124 case DW_AT_stride_size
:
3125 return "DW_AT_stride_size";
3126 case DW_AT_upper_bound
:
3127 return "DW_AT_upper_bound";
3128 case DW_AT_abstract_origin
:
3129 return "DW_AT_abstract_origin";
3130 case DW_AT_accessibility
:
3131 return "DW_AT_accessibility";
3132 case DW_AT_address_class
:
3133 return "DW_AT_address_class";
3134 case DW_AT_artificial
:
3135 return "DW_AT_artificial";
3136 case DW_AT_base_types
:
3137 return "DW_AT_base_types";
3138 case DW_AT_calling_convention
:
3139 return "DW_AT_calling_convention";
3141 return "DW_AT_count";
3142 case DW_AT_data_member_location
:
3143 return "DW_AT_data_member_location";
3144 case DW_AT_decl_column
:
3145 return "DW_AT_decl_column";
3146 case DW_AT_decl_file
:
3147 return "DW_AT_decl_file";
3148 case DW_AT_decl_line
:
3149 return "DW_AT_decl_line";
3150 case DW_AT_declaration
:
3151 return "DW_AT_declaration";
3152 case DW_AT_discr_list
:
3153 return "DW_AT_discr_list";
3154 case DW_AT_encoding
:
3155 return "DW_AT_encoding";
3156 case DW_AT_external
:
3157 return "DW_AT_external";
3158 case DW_AT_frame_base
:
3159 return "DW_AT_frame_base";
3161 return "DW_AT_friend";
3162 case DW_AT_identifier_case
:
3163 return "DW_AT_identifier_case";
3164 case DW_AT_macro_info
:
3165 return "DW_AT_macro_info";
3166 case DW_AT_namelist_items
:
3167 return "DW_AT_namelist_items";
3168 case DW_AT_priority
:
3169 return "DW_AT_priority";
3171 return "DW_AT_segment";
3172 case DW_AT_specification
:
3173 return "DW_AT_specification";
3174 case DW_AT_static_link
:
3175 return "DW_AT_static_link";
3177 return "DW_AT_type";
3178 case DW_AT_use_location
:
3179 return "DW_AT_use_location";
3180 case DW_AT_variable_parameter
:
3181 return "DW_AT_variable_parameter";
3182 case DW_AT_virtuality
:
3183 return "DW_AT_virtuality";
3184 case DW_AT_vtable_elem_location
:
3185 return "DW_AT_vtable_elem_location";
3187 case DW_AT_MIPS_fde
:
3188 return "DW_AT_MIPS_fde";
3189 case DW_AT_MIPS_loop_begin
:
3190 return "DW_AT_MIPS_loop_begin";
3191 case DW_AT_MIPS_tail_loop_begin
:
3192 return "DW_AT_MIPS_tail_loop_begin";
3193 case DW_AT_MIPS_epilog_begin
:
3194 return "DW_AT_MIPS_epilog_begin";
3195 case DW_AT_MIPS_loop_unroll_factor
:
3196 return "DW_AT_MIPS_loop_unroll_factor";
3197 case DW_AT_MIPS_software_pipeline_depth
:
3198 return "DW_AT_MIPS_software_pipeline_depth";
3199 case DW_AT_MIPS_linkage_name
:
3200 return "DW_AT_MIPS_linkage_name";
3201 case DW_AT_MIPS_stride
:
3202 return "DW_AT_MIPS_stride";
3203 case DW_AT_MIPS_abstract_name
:
3204 return "DW_AT_MIPS_abstract_name";
3205 case DW_AT_MIPS_clone_origin
:
3206 return "DW_AT_MIPS_clone_origin";
3207 case DW_AT_MIPS_has_inlines
:
3208 return "DW_AT_MIPS_has_inlines";
3210 case DW_AT_sf_names
:
3211 return "DW_AT_sf_names";
3212 case DW_AT_src_info
:
3213 return "DW_AT_src_info";
3214 case DW_AT_mac_info
:
3215 return "DW_AT_mac_info";
3216 case DW_AT_src_coords
:
3217 return "DW_AT_src_coords";
3218 case DW_AT_body_begin
:
3219 return "DW_AT_body_begin";
3220 case DW_AT_body_end
:
3221 return "DW_AT_body_end";
3223 return "DW_AT_<unknown>";
3227 /* Convert a DWARF value form code into its string name. */
3230 dwarf_form_name (form
)
3231 register unsigned form
;
3236 return "DW_FORM_addr";
3237 case DW_FORM_block2
:
3238 return "DW_FORM_block2";
3239 case DW_FORM_block4
:
3240 return "DW_FORM_block4";
3242 return "DW_FORM_data2";
3244 return "DW_FORM_data4";
3246 return "DW_FORM_data8";
3247 case DW_FORM_string
:
3248 return "DW_FORM_string";
3250 return "DW_FORM_block";
3251 case DW_FORM_block1
:
3252 return "DW_FORM_block1";
3254 return "DW_FORM_data1";
3256 return "DW_FORM_flag";
3258 return "DW_FORM_sdata";
3260 return "DW_FORM_strp";
3262 return "DW_FORM_udata";
3263 case DW_FORM_ref_addr
:
3264 return "DW_FORM_ref_addr";
3266 return "DW_FORM_ref1";
3268 return "DW_FORM_ref2";
3270 return "DW_FORM_ref4";
3272 return "DW_FORM_ref8";
3273 case DW_FORM_ref_udata
:
3274 return "DW_FORM_ref_udata";
3275 case DW_FORM_indirect
:
3276 return "DW_FORM_indirect";
3278 return "DW_FORM_<unknown>";
3282 /* Convert a DWARF stack opcode into its string name. */
3285 dwarf_stack_op_name (op
)
3286 register unsigned op
;
3291 return "DW_OP_addr";
3293 return "DW_OP_deref";
3295 return "DW_OP_const1u";
3297 return "DW_OP_const1s";
3299 return "DW_OP_const2u";
3301 return "DW_OP_const2s";
3303 return "DW_OP_const4u";
3305 return "DW_OP_const4s";
3307 return "DW_OP_const8u";
3309 return "DW_OP_const8s";
3311 return "DW_OP_constu";
3313 return "DW_OP_consts";
3317 return "DW_OP_drop";
3319 return "DW_OP_over";
3321 return "DW_OP_pick";
3323 return "DW_OP_swap";
3327 return "DW_OP_xderef";
3335 return "DW_OP_minus";
3347 return "DW_OP_plus";
3348 case DW_OP_plus_uconst
:
3349 return "DW_OP_plus_uconst";
3355 return "DW_OP_shra";
3373 return "DW_OP_skip";
3375 return "DW_OP_lit0";
3377 return "DW_OP_lit1";
3379 return "DW_OP_lit2";
3381 return "DW_OP_lit3";
3383 return "DW_OP_lit4";
3385 return "DW_OP_lit5";
3387 return "DW_OP_lit6";
3389 return "DW_OP_lit7";
3391 return "DW_OP_lit8";
3393 return "DW_OP_lit9";
3395 return "DW_OP_lit10";
3397 return "DW_OP_lit11";
3399 return "DW_OP_lit12";
3401 return "DW_OP_lit13";
3403 return "DW_OP_lit14";
3405 return "DW_OP_lit15";
3407 return "DW_OP_lit16";
3409 return "DW_OP_lit17";
3411 return "DW_OP_lit18";
3413 return "DW_OP_lit19";
3415 return "DW_OP_lit20";
3417 return "DW_OP_lit21";
3419 return "DW_OP_lit22";
3421 return "DW_OP_lit23";
3423 return "DW_OP_lit24";
3425 return "DW_OP_lit25";
3427 return "DW_OP_lit26";
3429 return "DW_OP_lit27";
3431 return "DW_OP_lit28";
3433 return "DW_OP_lit29";
3435 return "DW_OP_lit30";
3437 return "DW_OP_lit31";
3439 return "DW_OP_reg0";
3441 return "DW_OP_reg1";
3443 return "DW_OP_reg2";
3445 return "DW_OP_reg3";
3447 return "DW_OP_reg4";
3449 return "DW_OP_reg5";
3451 return "DW_OP_reg6";
3453 return "DW_OP_reg7";
3455 return "DW_OP_reg8";
3457 return "DW_OP_reg9";
3459 return "DW_OP_reg10";
3461 return "DW_OP_reg11";
3463 return "DW_OP_reg12";
3465 return "DW_OP_reg13";
3467 return "DW_OP_reg14";
3469 return "DW_OP_reg15";
3471 return "DW_OP_reg16";
3473 return "DW_OP_reg17";
3475 return "DW_OP_reg18";
3477 return "DW_OP_reg19";
3479 return "DW_OP_reg20";
3481 return "DW_OP_reg21";
3483 return "DW_OP_reg22";
3485 return "DW_OP_reg23";
3487 return "DW_OP_reg24";
3489 return "DW_OP_reg25";
3491 return "DW_OP_reg26";
3493 return "DW_OP_reg27";
3495 return "DW_OP_reg28";
3497 return "DW_OP_reg29";
3499 return "DW_OP_reg30";
3501 return "DW_OP_reg31";
3503 return "DW_OP_breg0";
3505 return "DW_OP_breg1";
3507 return "DW_OP_breg2";
3509 return "DW_OP_breg3";
3511 return "DW_OP_breg4";
3513 return "DW_OP_breg5";
3515 return "DW_OP_breg6";
3517 return "DW_OP_breg7";
3519 return "DW_OP_breg8";
3521 return "DW_OP_breg9";
3523 return "DW_OP_breg10";
3525 return "DW_OP_breg11";
3527 return "DW_OP_breg12";
3529 return "DW_OP_breg13";
3531 return "DW_OP_breg14";
3533 return "DW_OP_breg15";
3535 return "DW_OP_breg16";
3537 return "DW_OP_breg17";
3539 return "DW_OP_breg18";
3541 return "DW_OP_breg19";
3543 return "DW_OP_breg20";
3545 return "DW_OP_breg21";
3547 return "DW_OP_breg22";
3549 return "DW_OP_breg23";
3551 return "DW_OP_breg24";
3553 return "DW_OP_breg25";
3555 return "DW_OP_breg26";
3557 return "DW_OP_breg27";
3559 return "DW_OP_breg28";
3561 return "DW_OP_breg29";
3563 return "DW_OP_breg30";
3565 return "DW_OP_breg31";
3567 return "DW_OP_regx";
3569 return "DW_OP_fbreg";
3571 return "DW_OP_bregx";
3573 return "DW_OP_piece";
3574 case DW_OP_deref_size
:
3575 return "DW_OP_deref_size";
3576 case DW_OP_xderef_size
:
3577 return "DW_OP_xderef_size";
3581 return "OP_<unknown>";
3585 /* Convert a DWARF type code into its string name. */
3589 dwarf_type_encoding_name (enc
)
3590 register unsigned enc
;
3594 case DW_ATE_address
:
3595 return "DW_ATE_address";
3596 case DW_ATE_boolean
:
3597 return "DW_ATE_boolean";
3598 case DW_ATE_complex_float
:
3599 return "DW_ATE_complex_float";
3601 return "DW_ATE_float";
3603 return "DW_ATE_signed";
3604 case DW_ATE_signed_char
:
3605 return "DW_ATE_signed_char";
3606 case DW_ATE_unsigned
:
3607 return "DW_ATE_unsigned";
3608 case DW_ATE_unsigned_char
:
3609 return "DW_ATE_unsigned_char";
3611 return "DW_ATE_<unknown>";
3616 /* Determine the "ultimate origin" of a decl. The decl may be an inlined
3617 instance of an inlined instance of a decl which is local to an inline
3618 function, so we have to trace all of the way back through the origin chain
3619 to find out what sort of node actually served as the original seed for the
3623 decl_ultimate_origin (decl
)
3626 #ifdef ENABLE_CHECKING
3627 if (DECL_FROM_INLINE (DECL_ORIGIN (decl
)))
3628 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
3629 most distant ancestor, this should never happen. */
3633 return DECL_ABSTRACT_ORIGIN (decl
);
3636 /* Determine the "ultimate origin" of a block. The block may be an inlined
3637 instance of an inlined instance of a block which is local to an inline
3638 function, so we have to trace all of the way back through the origin chain
3639 to find out what sort of node actually served as the original seed for the
3643 block_ultimate_origin (block
)
3644 register tree block
;
3646 register tree immediate_origin
= BLOCK_ABSTRACT_ORIGIN (block
);
3648 if (immediate_origin
== NULL_TREE
)
3652 register tree ret_val
;
3653 register tree lookahead
= immediate_origin
;
3657 ret_val
= lookahead
;
3658 lookahead
= (TREE_CODE (ret_val
) == BLOCK
)
3659 ? BLOCK_ABSTRACT_ORIGIN (ret_val
)
3662 while (lookahead
!= NULL
&& lookahead
!= ret_val
);
3668 /* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT
3669 of a virtual function may refer to a base class, so we check the 'this'
3673 decl_class_context (decl
)
3676 tree context
= NULL_TREE
;
3678 if (TREE_CODE (decl
) != FUNCTION_DECL
|| ! DECL_VINDEX (decl
))
3679 context
= DECL_CONTEXT (decl
);
3681 context
= TYPE_MAIN_VARIANT
3682 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)))));
3684 if (context
&& TREE_CODE_CLASS (TREE_CODE (context
)) != 't')
3685 context
= NULL_TREE
;
3690 /* Add an attribute/value pair to a DIE */
3693 add_dwarf_attr (die
, attr
)
3694 register dw_die_ref die
;
3695 register dw_attr_ref attr
;
3697 if (die
!= NULL
&& attr
!= NULL
)
3699 if (die
->die_attr
== NULL
)
3701 die
->die_attr
= attr
;
3702 die
->die_attr_last
= attr
;
3706 die
->die_attr_last
->dw_attr_next
= attr
;
3707 die
->die_attr_last
= attr
;
3712 /* Add a flag value attribute to a DIE. */
3715 add_AT_flag (die
, attr_kind
, flag
)
3716 register dw_die_ref die
;
3717 register enum dwarf_attribute attr_kind
;
3718 register unsigned flag
;
3720 register dw_attr_ref attr
= (dw_attr_ref
) xmalloc (sizeof (dw_attr_node
));
3722 attr
->dw_attr_next
= NULL
;
3723 attr
->dw_attr
= attr_kind
;
3724 attr
->dw_attr_val
.val_class
= dw_val_class_flag
;
3725 attr
->dw_attr_val
.v
.val_flag
= flag
;
3726 add_dwarf_attr (die
, attr
);
3729 /* Add a signed integer attribute value to a DIE. */
3732 add_AT_int (die
, attr_kind
, int_val
)
3733 register dw_die_ref die
;
3734 register enum dwarf_attribute attr_kind
;
3735 register long int int_val
;
3737 register dw_attr_ref attr
= (dw_attr_ref
) xmalloc (sizeof (dw_attr_node
));
3739 attr
->dw_attr_next
= NULL
;
3740 attr
->dw_attr
= attr_kind
;
3741 attr
->dw_attr_val
.val_class
= dw_val_class_const
;
3742 attr
->dw_attr_val
.v
.val_int
= int_val
;
3743 add_dwarf_attr (die
, attr
);
3746 /* Add an unsigned integer attribute value to a DIE. */
3749 add_AT_unsigned (die
, attr_kind
, unsigned_val
)
3750 register dw_die_ref die
;
3751 register enum dwarf_attribute attr_kind
;
3752 register unsigned long unsigned_val
;
3754 register dw_attr_ref attr
= (dw_attr_ref
) xmalloc (sizeof (dw_attr_node
));
3756 attr
->dw_attr_next
= NULL
;
3757 attr
->dw_attr
= attr_kind
;
3758 attr
->dw_attr_val
.val_class
= dw_val_class_unsigned_const
;
3759 attr
->dw_attr_val
.v
.val_unsigned
= unsigned_val
;
3760 add_dwarf_attr (die
, attr
);
3763 /* Add an unsigned double integer attribute value to a DIE. */
3766 add_AT_long_long (die
, attr_kind
, val_hi
, val_low
)
3767 register dw_die_ref die
;
3768 register enum dwarf_attribute attr_kind
;
3769 register unsigned long val_hi
;
3770 register unsigned long val_low
;
3772 register dw_attr_ref attr
= (dw_attr_ref
) xmalloc (sizeof (dw_attr_node
));
3774 attr
->dw_attr_next
= NULL
;
3775 attr
->dw_attr
= attr_kind
;
3776 attr
->dw_attr_val
.val_class
= dw_val_class_long_long
;
3777 attr
->dw_attr_val
.v
.val_long_long
.hi
= val_hi
;
3778 attr
->dw_attr_val
.v
.val_long_long
.low
= val_low
;
3779 add_dwarf_attr (die
, attr
);
3782 /* Add a floating point attribute value to a DIE and return it. */
3785 add_AT_float (die
, attr_kind
, length
, array
)
3786 register dw_die_ref die
;
3787 register enum dwarf_attribute attr_kind
;
3788 register unsigned length
;
3789 register long *array
;
3791 register dw_attr_ref attr
= (dw_attr_ref
) xmalloc (sizeof (dw_attr_node
));
3793 attr
->dw_attr_next
= NULL
;
3794 attr
->dw_attr
= attr_kind
;
3795 attr
->dw_attr_val
.val_class
= dw_val_class_float
;
3796 attr
->dw_attr_val
.v
.val_float
.length
= length
;
3797 attr
->dw_attr_val
.v
.val_float
.array
= array
;
3798 add_dwarf_attr (die
, attr
);
3801 /* Add a string attribute value to a DIE. */
3804 add_AT_string (die
, attr_kind
, str
)
3805 register dw_die_ref die
;
3806 register enum dwarf_attribute attr_kind
;
3809 register dw_attr_ref attr
= (dw_attr_ref
) xmalloc (sizeof (dw_attr_node
));
3811 attr
->dw_attr_next
= NULL
;
3812 attr
->dw_attr
= attr_kind
;
3813 attr
->dw_attr_val
.val_class
= dw_val_class_str
;
3814 attr
->dw_attr_val
.v
.val_str
= xstrdup (str
);
3815 add_dwarf_attr (die
, attr
);
3818 /* Add a DIE reference attribute value to a DIE. */
3821 add_AT_die_ref (die
, attr_kind
, targ_die
)
3822 register dw_die_ref die
;
3823 register enum dwarf_attribute attr_kind
;
3824 register dw_die_ref targ_die
;
3826 register dw_attr_ref attr
= (dw_attr_ref
) xmalloc (sizeof (dw_attr_node
));
3828 attr
->dw_attr_next
= NULL
;
3829 attr
->dw_attr
= attr_kind
;
3830 attr
->dw_attr_val
.val_class
= dw_val_class_die_ref
;
3831 attr
->dw_attr_val
.v
.val_die_ref
= targ_die
;
3832 add_dwarf_attr (die
, attr
);
3835 /* Add an FDE reference attribute value to a DIE. */
3838 add_AT_fde_ref (die
, attr_kind
, targ_fde
)
3839 register dw_die_ref die
;
3840 register enum dwarf_attribute attr_kind
;
3841 register unsigned targ_fde
;
3843 register dw_attr_ref attr
= (dw_attr_ref
) xmalloc (sizeof (dw_attr_node
));
3845 attr
->dw_attr_next
= NULL
;
3846 attr
->dw_attr
= attr_kind
;
3847 attr
->dw_attr_val
.val_class
= dw_val_class_fde_ref
;
3848 attr
->dw_attr_val
.v
.val_fde_index
= targ_fde
;
3849 add_dwarf_attr (die
, attr
);
3852 /* Add a location description attribute value to a DIE. */
3855 add_AT_loc (die
, attr_kind
, loc
)
3856 register dw_die_ref die
;
3857 register enum dwarf_attribute attr_kind
;
3858 register dw_loc_descr_ref loc
;
3860 register dw_attr_ref attr
= (dw_attr_ref
) xmalloc (sizeof (dw_attr_node
));
3862 attr
->dw_attr_next
= NULL
;
3863 attr
->dw_attr
= attr_kind
;
3864 attr
->dw_attr_val
.val_class
= dw_val_class_loc
;
3865 attr
->dw_attr_val
.v
.val_loc
= loc
;
3866 add_dwarf_attr (die
, attr
);
3869 /* Add an address constant attribute value to a DIE. */
3872 add_AT_addr (die
, attr_kind
, addr
)
3873 register dw_die_ref die
;
3874 register enum dwarf_attribute attr_kind
;
3877 register dw_attr_ref attr
= (dw_attr_ref
) xmalloc (sizeof (dw_attr_node
));
3879 attr
->dw_attr_next
= NULL
;
3880 attr
->dw_attr
= attr_kind
;
3881 attr
->dw_attr_val
.val_class
= dw_val_class_addr
;
3882 attr
->dw_attr_val
.v
.val_addr
= addr
;
3883 add_dwarf_attr (die
, attr
);
3886 /* Add a label identifier attribute value to a DIE. */
3889 add_AT_lbl_id (die
, attr_kind
, lbl_id
)
3890 register dw_die_ref die
;
3891 register enum dwarf_attribute attr_kind
;
3892 register char *lbl_id
;
3894 register dw_attr_ref attr
= (dw_attr_ref
) xmalloc (sizeof (dw_attr_node
));
3896 attr
->dw_attr_next
= NULL
;
3897 attr
->dw_attr
= attr_kind
;
3898 attr
->dw_attr_val
.val_class
= dw_val_class_lbl_id
;
3899 attr
->dw_attr_val
.v
.val_lbl_id
= xstrdup (lbl_id
);
3900 add_dwarf_attr (die
, attr
);
3903 /* Add a section offset attribute value to a DIE. */
3906 add_AT_lbl_offset (die
, attr_kind
, label
)
3907 register dw_die_ref die
;
3908 register enum dwarf_attribute attr_kind
;
3909 register char *label
;
3911 register dw_attr_ref attr
= (dw_attr_ref
) xmalloc (sizeof (dw_attr_node
));
3913 attr
->dw_attr_next
= NULL
;
3914 attr
->dw_attr
= attr_kind
;
3915 attr
->dw_attr_val
.val_class
= dw_val_class_lbl_offset
;
3916 attr
->dw_attr_val
.v
.val_lbl_id
= label
;
3917 add_dwarf_attr (die
, attr
);
3921 /* Test if die refers to an external subroutine. */
3924 is_extern_subr_die (die
)
3925 register dw_die_ref die
;
3927 register dw_attr_ref a
;
3928 register int is_subr
= FALSE
;
3929 register int is_extern
= FALSE
;
3931 if (die
!= NULL
&& die
->die_tag
== DW_TAG_subprogram
)
3934 for (a
= die
->die_attr
; a
!= NULL
; a
= a
->dw_attr_next
)
3936 if (a
->dw_attr
== DW_AT_external
3937 && a
->dw_attr_val
.val_class
== dw_val_class_flag
3938 && a
->dw_attr_val
.v
.val_flag
!= 0)
3946 return is_subr
&& is_extern
;
3949 /* Get the attribute of type attr_kind. */
3951 static inline dw_attr_ref
3952 get_AT (die
, attr_kind
)
3953 register dw_die_ref die
;
3954 register enum dwarf_attribute attr_kind
;
3956 register dw_attr_ref a
;
3957 register dw_die_ref spec
= NULL
;
3961 for (a
= die
->die_attr
; a
!= NULL
; a
= a
->dw_attr_next
)
3963 if (a
->dw_attr
== attr_kind
)
3966 if (a
->dw_attr
== DW_AT_specification
3967 || a
->dw_attr
== DW_AT_abstract_origin
)
3968 spec
= a
->dw_attr_val
.v
.val_die_ref
;
3972 return get_AT (spec
, attr_kind
);
3978 /* Return the "low pc" attribute value, typically associated with
3979 a subprogram DIE. Return null if the "low pc" attribute is
3980 either not prsent, or if it cannot be represented as an
3981 assembler label identifier. */
3983 static inline char *
3985 register dw_die_ref die
;
3987 register dw_attr_ref a
= get_AT (die
, DW_AT_low_pc
);
3989 if (a
&& a
->dw_attr_val
.val_class
== dw_val_class_lbl_id
)
3990 return a
->dw_attr_val
.v
.val_lbl_id
;
3995 /* Return the "high pc" attribute value, typically associated with
3996 a subprogram DIE. Return null if the "high pc" attribute is
3997 either not prsent, or if it cannot be represented as an
3998 assembler label identifier. */
4000 static inline char *
4002 register dw_die_ref die
;
4004 register dw_attr_ref a
= get_AT (die
, DW_AT_high_pc
);
4006 if (a
&& a
->dw_attr_val
.val_class
== dw_val_class_lbl_id
)
4007 return a
->dw_attr_val
.v
.val_lbl_id
;
4012 /* Return the value of the string attribute designated by ATTR_KIND, or
4013 NULL if it is not present. */
4015 static inline char *
4016 get_AT_string (die
, attr_kind
)
4017 register dw_die_ref die
;
4018 register enum dwarf_attribute attr_kind
;
4020 register dw_attr_ref a
= get_AT (die
, attr_kind
);
4022 if (a
&& a
->dw_attr_val
.val_class
== dw_val_class_str
)
4023 return a
->dw_attr_val
.v
.val_str
;
4028 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
4029 if it is not present. */
4032 get_AT_flag (die
, attr_kind
)
4033 register dw_die_ref die
;
4034 register enum dwarf_attribute attr_kind
;
4036 register dw_attr_ref a
= get_AT (die
, attr_kind
);
4038 if (a
&& a
->dw_attr_val
.val_class
== dw_val_class_flag
)
4039 return a
->dw_attr_val
.v
.val_flag
;
4044 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
4045 if it is not present. */
4047 static inline unsigned
4048 get_AT_unsigned (die
, attr_kind
)
4049 register dw_die_ref die
;
4050 register enum dwarf_attribute attr_kind
;
4052 register dw_attr_ref a
= get_AT (die
, attr_kind
);
4054 if (a
&& a
->dw_attr_val
.val_class
== dw_val_class_unsigned_const
)
4055 return a
->dw_attr_val
.v
.val_unsigned
;
4063 register unsigned lang
= get_AT_unsigned (comp_unit_die
, DW_AT_language
);
4065 return (lang
== DW_LANG_C
|| lang
== DW_LANG_C89
4066 || lang
== DW_LANG_C_plus_plus
);
4072 register unsigned lang
= get_AT_unsigned (comp_unit_die
, DW_AT_language
);
4074 return (lang
== DW_LANG_Fortran77
|| lang
== DW_LANG_Fortran90
);
4077 /* Remove the specified attribute if present. */
4080 remove_AT (die
, attr_kind
)
4081 register dw_die_ref die
;
4082 register enum dwarf_attribute attr_kind
;
4084 register dw_attr_ref a
;
4085 register dw_attr_ref removed
= NULL
;;
4089 if (die
->die_attr
->dw_attr
== attr_kind
)
4091 removed
= die
->die_attr
;
4092 if (die
->die_attr_last
== die
->die_attr
)
4093 die
->die_attr_last
= NULL
;
4095 die
->die_attr
= die
->die_attr
->dw_attr_next
;
4099 for (a
= die
->die_attr
; a
->dw_attr_next
!= NULL
;
4100 a
= a
->dw_attr_next
)
4101 if (a
->dw_attr_next
->dw_attr
== attr_kind
)
4103 removed
= a
->dw_attr_next
;
4104 if (die
->die_attr_last
== a
->dw_attr_next
)
4105 die
->die_attr_last
= a
;
4107 a
->dw_attr_next
= a
->dw_attr_next
->dw_attr_next
;
4116 /* Discard the children of this DIE. */
4119 remove_children (die
)
4120 register dw_die_ref die
;
4122 register dw_die_ref child_die
= die
->die_child
;
4124 die
->die_child
= NULL
;
4125 die
->die_child_last
= NULL
;
4127 while (child_die
!= NULL
)
4129 register dw_die_ref tmp_die
= child_die
;
4130 register dw_attr_ref a
;
4132 child_die
= child_die
->die_sib
;
4134 for (a
= tmp_die
->die_attr
; a
!= NULL
; )
4136 register dw_attr_ref tmp_a
= a
;
4138 a
= a
->dw_attr_next
;
4146 /* Add a child DIE below its parent. */
4149 add_child_die (die
, child_die
)
4150 register dw_die_ref die
;
4151 register dw_die_ref child_die
;
4153 if (die
!= NULL
&& child_die
!= NULL
)
4155 if (die
== child_die
)
4157 child_die
->die_parent
= die
;
4158 child_die
->die_sib
= NULL
;
4160 if (die
->die_child
== NULL
)
4162 die
->die_child
= child_die
;
4163 die
->die_child_last
= child_die
;
4167 die
->die_child_last
->die_sib
= child_die
;
4168 die
->die_child_last
= child_die
;
4173 /* Return a pointer to a newly created DIE node. */
4175 static inline dw_die_ref
4176 new_die (tag_value
, parent_die
)
4177 register enum dwarf_tag tag_value
;
4178 register dw_die_ref parent_die
;
4180 register dw_die_ref die
= (dw_die_ref
) xmalloc (sizeof (die_node
));
4182 die
->die_tag
= tag_value
;
4183 die
->die_abbrev
= 0;
4184 die
->die_offset
= 0;
4185 die
->die_child
= NULL
;
4186 die
->die_parent
= NULL
;
4187 die
->die_sib
= NULL
;
4188 die
->die_child_last
= NULL
;
4189 die
->die_attr
= NULL
;
4190 die
->die_attr_last
= NULL
;
4192 if (parent_die
!= NULL
)
4193 add_child_die (parent_die
, die
);
4196 limbo_die_node
*limbo_node
;
4198 limbo_node
= (limbo_die_node
*) xmalloc (sizeof (limbo_die_node
));
4199 limbo_node
->die
= die
;
4200 limbo_node
->next
= limbo_die_list
;
4201 limbo_die_list
= limbo_node
;
4207 /* Return the DIE associated with the given type specifier. */
4209 static inline dw_die_ref
4210 lookup_type_die (type
)
4213 return (dw_die_ref
) TYPE_SYMTAB_POINTER (type
);
4216 /* Equate a DIE to a given type specifier. */
4219 equate_type_number_to_die (type
, type_die
)
4221 register dw_die_ref type_die
;
4223 TYPE_SYMTAB_POINTER (type
) = (char *) type_die
;
4226 /* Return the DIE associated with a given declaration. */
4228 static inline dw_die_ref
4229 lookup_decl_die (decl
)
4232 register unsigned decl_id
= DECL_UID (decl
);
4234 return (decl_id
< decl_die_table_in_use
4235 ? decl_die_table
[decl_id
] : NULL
);
4238 /* Equate a DIE to a particular declaration. */
4241 equate_decl_number_to_die (decl
, decl_die
)
4243 register dw_die_ref decl_die
;
4245 register unsigned decl_id
= DECL_UID (decl
);
4246 register unsigned num_allocated
;
4248 if (decl_id
>= decl_die_table_allocated
)
4251 = ((decl_id
+ 1 + DECL_DIE_TABLE_INCREMENT
- 1)
4252 / DECL_DIE_TABLE_INCREMENT
)
4253 * DECL_DIE_TABLE_INCREMENT
;
4256 = (dw_die_ref
*) xrealloc (decl_die_table
,
4257 sizeof (dw_die_ref
) * num_allocated
);
4259 bzero ((char *) &decl_die_table
[decl_die_table_allocated
],
4260 (num_allocated
- decl_die_table_allocated
) * sizeof (dw_die_ref
));
4261 decl_die_table_allocated
= num_allocated
;
4264 if (decl_id
>= decl_die_table_in_use
)
4265 decl_die_table_in_use
= (decl_id
+ 1);
4267 decl_die_table
[decl_id
] = decl_die
;
4270 /* Return a pointer to a newly allocated location description. Location
4271 descriptions are simple expression terms that can be strung
4272 together to form more complicated location (address) descriptions. */
4274 static inline dw_loc_descr_ref
4275 new_loc_descr (op
, oprnd1
, oprnd2
)
4276 register enum dwarf_location_atom op
;
4277 register unsigned long oprnd1
;
4278 register unsigned long oprnd2
;
4280 register dw_loc_descr_ref descr
4281 = (dw_loc_descr_ref
) xmalloc (sizeof (dw_loc_descr_node
));
4283 descr
->dw_loc_next
= NULL
;
4284 descr
->dw_loc_opc
= op
;
4285 descr
->dw_loc_oprnd1
.val_class
= dw_val_class_unsigned_const
;
4286 descr
->dw_loc_oprnd1
.v
.val_unsigned
= oprnd1
;
4287 descr
->dw_loc_oprnd2
.val_class
= dw_val_class_unsigned_const
;
4288 descr
->dw_loc_oprnd2
.v
.val_unsigned
= oprnd2
;
4293 /* Add a location description term to a location description expression. */
4296 add_loc_descr (list_head
, descr
)
4297 register dw_loc_descr_ref
*list_head
;
4298 register dw_loc_descr_ref descr
;
4300 register dw_loc_descr_ref
*d
;
4302 /* Find the end of the chain. */
4303 for (d
= list_head
; (*d
) != NULL
; d
= &(*d
)->dw_loc_next
)
4309 /* Keep track of the number of spaces used to indent the
4310 output of the debugging routines that print the structure of
4311 the DIE internal representation. */
4312 static int print_indent
;
4314 /* Indent the line the number of spaces given by print_indent. */
4317 print_spaces (outfile
)
4320 fprintf (outfile
, "%*s", print_indent
, "");
4323 /* Print the information associated with a given DIE, and its children.
4324 This routine is a debugging aid only. */
4327 print_die (die
, outfile
)
4331 register dw_attr_ref a
;
4332 register dw_die_ref c
;
4334 print_spaces (outfile
);
4335 fprintf (outfile
, "DIE %4lu: %s\n",
4336 die
->die_offset
, dwarf_tag_name (die
->die_tag
));
4337 print_spaces (outfile
);
4338 fprintf (outfile
, " abbrev id: %lu", die
->die_abbrev
);
4339 fprintf (outfile
, " offset: %lu\n", die
->die_offset
);
4341 for (a
= die
->die_attr
; a
!= NULL
; a
= a
->dw_attr_next
)
4343 print_spaces (outfile
);
4344 fprintf (outfile
, " %s: ", dwarf_attr_name (a
->dw_attr
));
4346 switch (a
->dw_attr_val
.val_class
)
4348 case dw_val_class_addr
:
4349 fprintf (outfile
, "address");
4351 case dw_val_class_loc
:
4352 fprintf (outfile
, "location descriptor");
4354 case dw_val_class_const
:
4355 fprintf (outfile
, "%ld", a
->dw_attr_val
.v
.val_int
);
4357 case dw_val_class_unsigned_const
:
4358 fprintf (outfile
, "%lu", a
->dw_attr_val
.v
.val_unsigned
);
4360 case dw_val_class_long_long
:
4361 fprintf (outfile
, "constant (%lu,%lu)",
4362 a
->dw_attr_val
.v
.val_long_long
.hi
,
4363 a
->dw_attr_val
.v
.val_long_long
.low
);
4365 case dw_val_class_float
:
4366 fprintf (outfile
, "floating-point constant");
4368 case dw_val_class_flag
:
4369 fprintf (outfile
, "%u", a
->dw_attr_val
.v
.val_flag
);
4371 case dw_val_class_die_ref
:
4372 if (a
->dw_attr_val
.v
.val_die_ref
!= NULL
)
4373 fprintf (outfile
, "die -> %lu",
4374 a
->dw_attr_val
.v
.val_die_ref
->die_offset
);
4376 fprintf (outfile
, "die -> <null>");
4378 case dw_val_class_lbl_id
:
4379 case dw_val_class_lbl_offset
:
4380 fprintf (outfile
, "label: %s", a
->dw_attr_val
.v
.val_lbl_id
);
4382 case dw_val_class_str
:
4383 if (a
->dw_attr_val
.v
.val_str
!= NULL
)
4384 fprintf (outfile
, "\"%s\"", a
->dw_attr_val
.v
.val_str
);
4386 fprintf (outfile
, "<null>");
4392 fprintf (outfile
, "\n");
4395 if (die
->die_child
!= NULL
)
4398 for (c
= die
->die_child
; c
!= NULL
; c
= c
->die_sib
)
4399 print_die (c
, outfile
);
4405 /* Print the contents of the source code line number correspondence table.
4406 This routine is a debugging aid only. */
4409 print_dwarf_line_table (outfile
)
4412 register unsigned i
;
4413 register dw_line_info_ref line_info
;
4415 fprintf (outfile
, "\n\nDWARF source line information\n");
4416 for (i
= 1; i
< line_info_table_in_use
; ++i
)
4418 line_info
= &line_info_table
[i
];
4419 fprintf (outfile
, "%5d: ", i
);
4420 fprintf (outfile
, "%-20s", file_table
[line_info
->dw_file_num
]);
4421 fprintf (outfile
, "%6ld", line_info
->dw_line_num
);
4422 fprintf (outfile
, "\n");
4425 fprintf (outfile
, "\n\n");
4428 /* Print the information collected for a given DIE. */
4431 debug_dwarf_die (die
)
4434 print_die (die
, stderr
);
4437 /* Print all DWARF information collected for the compilation unit.
4438 This routine is a debugging aid only. */
4444 print_die (comp_unit_die
, stderr
);
4445 print_dwarf_line_table (stderr
);
4448 /* Traverse the DIE, and add a sibling attribute if it may have the
4449 effect of speeding up access to siblings. To save some space,
4450 avoid generating sibling attributes for DIE's without children. */
4453 add_sibling_attributes(die
)
4454 register dw_die_ref die
;
4456 register dw_die_ref c
;
4457 register dw_attr_ref attr
;
4458 if (die
!= comp_unit_die
&& die
->die_child
!= NULL
)
4460 attr
= (dw_attr_ref
) xmalloc (sizeof (dw_attr_node
));
4461 attr
->dw_attr_next
= NULL
;
4462 attr
->dw_attr
= DW_AT_sibling
;
4463 attr
->dw_attr_val
.val_class
= dw_val_class_die_ref
;
4464 attr
->dw_attr_val
.v
.val_die_ref
= die
->die_sib
;
4466 /* Add the sibling link to the front of the attribute list. */
4467 attr
->dw_attr_next
= die
->die_attr
;
4468 if (die
->die_attr
== NULL
)
4469 die
->die_attr_last
= attr
;
4471 die
->die_attr
= attr
;
4474 for (c
= die
->die_child
; c
!= NULL
; c
= c
->die_sib
)
4475 add_sibling_attributes (c
);
4478 /* The format of each DIE (and its attribute value pairs)
4479 is encoded in an abbreviation table. This routine builds the
4480 abbreviation table and assigns a unique abbreviation id for
4481 each abbreviation entry. The children of each die are visited
4485 build_abbrev_table (die
)
4486 register dw_die_ref die
;
4488 register unsigned long abbrev_id
;
4489 register unsigned long n_alloc
;
4490 register dw_die_ref c
;
4491 register dw_attr_ref d_attr
, a_attr
;
4492 for (abbrev_id
= 1; abbrev_id
< abbrev_die_table_in_use
; ++abbrev_id
)
4494 register dw_die_ref abbrev
= abbrev_die_table
[abbrev_id
];
4496 if (abbrev
->die_tag
== die
->die_tag
)
4498 if ((abbrev
->die_child
!= NULL
) == (die
->die_child
!= NULL
))
4500 a_attr
= abbrev
->die_attr
;
4501 d_attr
= die
->die_attr
;
4503 while (a_attr
!= NULL
&& d_attr
!= NULL
)
4505 if ((a_attr
->dw_attr
!= d_attr
->dw_attr
)
4506 || (value_format (&a_attr
->dw_attr_val
)
4507 != value_format (&d_attr
->dw_attr_val
)))
4510 a_attr
= a_attr
->dw_attr_next
;
4511 d_attr
= d_attr
->dw_attr_next
;
4514 if (a_attr
== NULL
&& d_attr
== NULL
)
4520 if (abbrev_id
>= abbrev_die_table_in_use
)
4522 if (abbrev_die_table_in_use
>= abbrev_die_table_allocated
)
4524 n_alloc
= abbrev_die_table_allocated
+ ABBREV_DIE_TABLE_INCREMENT
;
4526 = (dw_die_ref
*) xrealloc (abbrev_die_table
,
4527 sizeof (dw_die_ref
) * n_alloc
);
4529 bzero ((char *) &abbrev_die_table
[abbrev_die_table_allocated
],
4530 (n_alloc
- abbrev_die_table_allocated
) * sizeof (dw_die_ref
));
4531 abbrev_die_table_allocated
= n_alloc
;
4534 ++abbrev_die_table_in_use
;
4535 abbrev_die_table
[abbrev_id
] = die
;
4538 die
->die_abbrev
= abbrev_id
;
4539 for (c
= die
->die_child
; c
!= NULL
; c
= c
->die_sib
)
4540 build_abbrev_table (c
);
4543 /* Return the size of a string, including the null byte.
4545 This used to treat backslashes as escapes, and hence they were not included
4546 in the count. However, that conflicts with what ASM_OUTPUT_ASCII does,
4547 which treats a backslash as a backslash, escaping it if necessary, and hence
4548 we must include them in the count. */
4550 static unsigned long
4551 size_of_string (str
)
4554 return strlen (str
) + 1;
4557 /* Return the size of a location descriptor. */
4559 static unsigned long
4560 size_of_loc_descr (loc
)
4561 register dw_loc_descr_ref loc
;
4563 register unsigned long size
= 1;
4565 switch (loc
->dw_loc_opc
)
4587 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
4590 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
4595 case DW_OP_plus_uconst
:
4596 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
4634 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
4637 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
4640 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
4643 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
4644 size
+= size_of_sleb128 (loc
->dw_loc_oprnd2
.v
.val_int
);
4647 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
4649 case DW_OP_deref_size
:
4650 case DW_OP_xderef_size
:
4660 /* Return the size of a series of location descriptors. */
4662 static unsigned long
4664 register dw_loc_descr_ref loc
;
4666 register unsigned long size
= 0;
4668 for (; loc
!= NULL
; loc
= loc
->dw_loc_next
)
4669 size
+= size_of_loc_descr (loc
);
4674 /* Return the power-of-two number of bytes necessary to represent VALUE. */
4677 constant_size (value
)
4678 long unsigned value
;
4685 log
= floor_log2 (value
);
4688 log
= 1 << (floor_log2 (log
) + 1);
4693 /* Return the size of a DIE, as it is represented in the
4694 .debug_info section. */
4696 static unsigned long
4698 register dw_die_ref die
;
4700 register unsigned long size
= 0;
4701 register dw_attr_ref a
;
4703 size
+= size_of_uleb128 (die
->die_abbrev
);
4704 for (a
= die
->die_attr
; a
!= NULL
; a
= a
->dw_attr_next
)
4706 switch (a
->dw_attr_val
.val_class
)
4708 case dw_val_class_addr
:
4711 case dw_val_class_loc
:
4713 register unsigned long lsize
4714 = size_of_locs (a
->dw_attr_val
.v
.val_loc
);
4717 size
+= constant_size (lsize
);
4721 case dw_val_class_const
:
4724 case dw_val_class_unsigned_const
:
4725 size
+= constant_size (a
->dw_attr_val
.v
.val_unsigned
);
4727 case dw_val_class_long_long
:
4728 size
+= 1 + 8; /* block */
4730 case dw_val_class_float
:
4731 size
+= 1 + a
->dw_attr_val
.v
.val_float
.length
* 4; /* block */
4733 case dw_val_class_flag
:
4736 case dw_val_class_die_ref
:
4737 size
+= DWARF_OFFSET_SIZE
;
4739 case dw_val_class_fde_ref
:
4740 size
+= DWARF_OFFSET_SIZE
;
4742 case dw_val_class_lbl_id
:
4745 case dw_val_class_lbl_offset
:
4746 size
+= DWARF_OFFSET_SIZE
;
4748 case dw_val_class_str
:
4749 size
+= size_of_string (a
->dw_attr_val
.v
.val_str
);
4759 /* Size the debugging information associated with a given DIE.
4760 Visits the DIE's children recursively. Updates the global
4761 variable next_die_offset, on each time through. Uses the
4762 current value of next_die_offset to update the die_offset
4763 field in each DIE. */
4766 calc_die_sizes (die
)
4769 register dw_die_ref c
;
4770 die
->die_offset
= next_die_offset
;
4771 next_die_offset
+= size_of_die (die
);
4773 for (c
= die
->die_child
; c
!= NULL
; c
= c
->die_sib
)
4776 if (die
->die_child
!= NULL
)
4777 /* Count the null byte used to terminate sibling lists. */
4778 next_die_offset
+= 1;
4781 /* Return the size of the line information prolog generated for the
4782 compilation unit. */
4784 static unsigned long
4785 size_of_line_prolog ()
4787 register unsigned long size
;
4788 register unsigned long ft_index
;
4790 size
= DWARF_LINE_PROLOG_HEADER_SIZE
;
4792 /* Count the size of the table giving number of args for each
4794 size
+= DWARF_LINE_OPCODE_BASE
- 1;
4796 /* Include directory table is empty (at present). Count only the
4797 null byte used to terminate the table. */
4800 for (ft_index
= 1; ft_index
< file_table_in_use
; ++ft_index
)
4802 /* File name entry. */
4803 size
+= size_of_string (file_table
[ft_index
]);
4805 /* Include directory index. */
4806 size
+= size_of_uleb128 (0);
4808 /* Modification time. */
4809 size
+= size_of_uleb128 (0);
4811 /* File length in bytes. */
4812 size
+= size_of_uleb128 (0);
4815 /* Count the file table terminator. */
4820 /* Return the size of the line information generated for this
4821 compilation unit. */
4823 static unsigned long
4824 size_of_line_info ()
4826 register unsigned long size
;
4827 register unsigned long lt_index
;
4828 register unsigned long current_line
;
4829 register long line_offset
;
4830 register long line_delta
;
4831 register unsigned long current_file
;
4832 register unsigned long function
;
4833 unsigned long size_of_set_address
;
4835 /* Size of a DW_LNE_set_address instruction. */
4836 size_of_set_address
= 1 + size_of_uleb128 (1 + PTR_SIZE
) + 1 + PTR_SIZE
;
4838 /* Version number. */
4841 /* Prolog length specifier. */
4842 size
+= DWARF_OFFSET_SIZE
;
4845 size
+= size_of_line_prolog ();
4849 for (lt_index
= 1; lt_index
< line_info_table_in_use
; ++lt_index
)
4851 register dw_line_info_ref line_info
= &line_info_table
[lt_index
];
4853 if (line_info
->dw_line_num
== current_line
4854 && line_info
->dw_file_num
== current_file
)
4857 /* Advance pc instruction. */
4858 /* ??? See the DW_LNS_advance_pc comment in output_line_info. */
4862 size
+= size_of_set_address
;
4864 if (line_info
->dw_file_num
!= current_file
)
4866 /* Set file number instruction. */
4868 current_file
= line_info
->dw_file_num
;
4869 size
+= size_of_uleb128 (current_file
);
4872 if (line_info
->dw_line_num
!= current_line
)
4874 line_offset
= line_info
->dw_line_num
- current_line
;
4875 line_delta
= line_offset
- DWARF_LINE_BASE
;
4876 current_line
= line_info
->dw_line_num
;
4877 if (line_delta
>= 0 && line_delta
< (DWARF_LINE_RANGE
- 1))
4878 /* 1-byte special line number instruction. */
4882 /* Advance line instruction. */
4884 size
+= size_of_sleb128 (line_offset
);
4885 /* Generate line entry instruction. */
4891 /* Advance pc instruction. */
4895 size
+= size_of_set_address
;
4897 /* End of line number info. marker. */
4898 size
+= 1 + size_of_uleb128 (1) + 1;
4903 for (lt_index
= 0; lt_index
< separate_line_info_table_in_use
; )
4905 register dw_separate_line_info_ref line_info
4906 = &separate_line_info_table
[lt_index
];
4908 if (line_info
->dw_line_num
== current_line
4909 && line_info
->dw_file_num
== current_file
4910 && line_info
->function
== function
)
4913 if (function
!= line_info
->function
)
4915 function
= line_info
->function
;
4916 /* Set address register instruction. */
4917 size
+= size_of_set_address
;
4921 /* Advance pc instruction. */
4925 size
+= size_of_set_address
;
4928 if (line_info
->dw_file_num
!= current_file
)
4930 /* Set file number instruction. */
4932 current_file
= line_info
->dw_file_num
;
4933 size
+= size_of_uleb128 (current_file
);
4936 if (line_info
->dw_line_num
!= current_line
)
4938 line_offset
= line_info
->dw_line_num
- current_line
;
4939 line_delta
= line_offset
- DWARF_LINE_BASE
;
4940 current_line
= line_info
->dw_line_num
;
4941 if (line_delta
>= 0 && line_delta
< (DWARF_LINE_RANGE
- 1))
4942 /* 1-byte special line number instruction. */
4946 /* Advance line instruction. */
4948 size
+= size_of_sleb128 (line_offset
);
4950 /* Generate line entry instruction. */
4958 /* If we're done with a function, end its sequence. */
4959 if (lt_index
== separate_line_info_table_in_use
4960 || separate_line_info_table
[lt_index
].function
!= function
)
4965 /* Advance pc instruction. */
4969 size
+= size_of_set_address
;
4971 /* End of line number info. marker. */
4972 size
+= 1 + size_of_uleb128 (1) + 1;
4979 /* Return the size of the .debug_pubnames table generated for the
4980 compilation unit. */
4982 static unsigned long
4985 register unsigned long size
;
4986 register unsigned i
;
4988 size
= DWARF_PUBNAMES_HEADER_SIZE
;
4989 for (i
= 0; i
< pubname_table_in_use
; ++i
)
4991 register pubname_ref p
= &pubname_table
[i
];
4992 size
+= DWARF_OFFSET_SIZE
+ size_of_string (p
->name
);
4995 size
+= DWARF_OFFSET_SIZE
;
4999 /* Return the size of the information in the .debug_aranges section. */
5001 static unsigned long
5004 register unsigned long size
;
5006 size
= DWARF_ARANGES_HEADER_SIZE
;
5008 /* Count the address/length pair for this compilation unit. */
5009 size
+= 2 * PTR_SIZE
;
5010 size
+= 2 * PTR_SIZE
* arange_table_in_use
;
5012 /* Count the two zero words used to terminated the address range table. */
5013 size
+= 2 * PTR_SIZE
;
5017 /* Select the encoding of an attribute value. */
5019 static enum dwarf_form
5023 switch (v
->val_class
)
5025 case dw_val_class_addr
:
5026 return DW_FORM_addr
;
5027 case dw_val_class_loc
:
5028 switch (constant_size (size_of_locs (v
->v
.val_loc
)))
5031 return DW_FORM_block1
;
5033 return DW_FORM_block2
;
5037 case dw_val_class_const
:
5038 return DW_FORM_data4
;
5039 case dw_val_class_unsigned_const
:
5040 switch (constant_size (v
->v
.val_unsigned
))
5043 return DW_FORM_data1
;
5045 return DW_FORM_data2
;
5047 return DW_FORM_data4
;
5049 return DW_FORM_data8
;
5053 case dw_val_class_long_long
:
5054 return DW_FORM_block1
;
5055 case dw_val_class_float
:
5056 return DW_FORM_block1
;
5057 case dw_val_class_flag
:
5058 return DW_FORM_flag
;
5059 case dw_val_class_die_ref
:
5061 case dw_val_class_fde_ref
:
5062 return DW_FORM_data
;
5063 case dw_val_class_lbl_id
:
5064 return DW_FORM_addr
;
5065 case dw_val_class_lbl_offset
:
5066 return DW_FORM_data
;
5067 case dw_val_class_str
:
5068 return DW_FORM_string
;
5074 /* Output the encoding of an attribute value. */
5077 output_value_format (v
)
5080 enum dwarf_form form
= value_format (v
);
5082 output_uleb128 (form
);
5084 fprintf (asm_out_file
, " (%s)", dwarf_form_name (form
));
5086 fputc ('\n', asm_out_file
);
5089 /* Output the .debug_abbrev section which defines the DIE abbreviation
5093 output_abbrev_section ()
5095 unsigned long abbrev_id
;
5098 for (abbrev_id
= 1; abbrev_id
< abbrev_die_table_in_use
; ++abbrev_id
)
5100 register dw_die_ref abbrev
= abbrev_die_table
[abbrev_id
];
5102 output_uleb128 (abbrev_id
);
5104 fprintf (asm_out_file
, " (abbrev code)");
5106 fputc ('\n', asm_out_file
);
5107 output_uleb128 (abbrev
->die_tag
);
5109 fprintf (asm_out_file
, " (TAG: %s)",
5110 dwarf_tag_name (abbrev
->die_tag
));
5112 fputc ('\n', asm_out_file
);
5113 fprintf (asm_out_file
, "\t%s\t0x%x", ASM_BYTE_OP
,
5114 abbrev
->die_child
!= NULL
? DW_children_yes
: DW_children_no
);
5117 fprintf (asm_out_file
, "\t%s %s",
5119 (abbrev
->die_child
!= NULL
5120 ? "DW_children_yes" : "DW_children_no"));
5122 fputc ('\n', asm_out_file
);
5124 for (a_attr
= abbrev
->die_attr
; a_attr
!= NULL
;
5125 a_attr
= a_attr
->dw_attr_next
)
5127 output_uleb128 (a_attr
->dw_attr
);
5129 fprintf (asm_out_file
, " (%s)",
5130 dwarf_attr_name (a_attr
->dw_attr
));
5132 fputc ('\n', asm_out_file
);
5133 output_value_format (&a_attr
->dw_attr_val
);
5136 fprintf (asm_out_file
, "\t%s\t0,0\n", ASM_BYTE_OP
);
5140 /* Output location description stack opcode's operands (if any). */
5143 output_loc_operands (loc
)
5144 register dw_loc_descr_ref loc
;
5146 register dw_val_ref val1
= &loc
->dw_loc_oprnd1
;
5147 register dw_val_ref val2
= &loc
->dw_loc_oprnd2
;
5149 switch (loc
->dw_loc_opc
)
5152 ASM_OUTPUT_DWARF_ADDR_CONST (asm_out_file
, val1
->v
.val_addr
);
5153 fputc ('\n', asm_out_file
);
5157 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, val1
->v
.val_flag
);
5158 fputc ('\n', asm_out_file
);
5162 ASM_OUTPUT_DWARF_DATA2 (asm_out_file
, val1
->v
.val_int
);
5163 fputc ('\n', asm_out_file
);
5167 ASM_OUTPUT_DWARF_DATA4 (asm_out_file
, val1
->v
.val_int
);
5168 fputc ('\n', asm_out_file
);
5173 fputc ('\n', asm_out_file
);
5176 output_uleb128 (val1
->v
.val_unsigned
);
5177 fputc ('\n', asm_out_file
);
5180 output_sleb128 (val1
->v
.val_int
);
5181 fputc ('\n', asm_out_file
);
5184 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, val1
->v
.val_int
);
5185 fputc ('\n', asm_out_file
);
5187 case DW_OP_plus_uconst
:
5188 output_uleb128 (val1
->v
.val_unsigned
);
5189 fputc ('\n', asm_out_file
);
5193 ASM_OUTPUT_DWARF_DATA2 (asm_out_file
, val1
->v
.val_int
);
5194 fputc ('\n', asm_out_file
);
5228 output_sleb128 (val1
->v
.val_int
);
5229 fputc ('\n', asm_out_file
);
5232 output_uleb128 (val1
->v
.val_unsigned
);
5233 fputc ('\n', asm_out_file
);
5236 output_sleb128 (val1
->v
.val_int
);
5237 fputc ('\n', asm_out_file
);
5240 output_uleb128 (val1
->v
.val_unsigned
);
5241 fputc ('\n', asm_out_file
);
5242 output_sleb128 (val2
->v
.val_int
);
5243 fputc ('\n', asm_out_file
);
5246 output_uleb128 (val1
->v
.val_unsigned
);
5247 fputc ('\n', asm_out_file
);
5249 case DW_OP_deref_size
:
5250 case DW_OP_xderef_size
:
5251 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, val1
->v
.val_flag
);
5252 fputc ('\n', asm_out_file
);
5259 /* Compute the offset of a sibling. */
5261 static unsigned long
5262 sibling_offset (die
)
5265 unsigned long offset
;
5267 if (die
->die_child_last
== NULL
)
5268 offset
= die
->die_offset
+ size_of_die (die
);
5270 offset
= sibling_offset (die
->die_child_last
) + 1;
5275 /* Output the DIE and its attributes. Called recursively to generate
5276 the definitions of each child DIE. */
5280 register dw_die_ref die
;
5282 register dw_attr_ref a
;
5283 register dw_die_ref c
;
5284 register unsigned long ref_offset
;
5285 register unsigned long size
;
5286 register dw_loc_descr_ref loc
;
5288 output_uleb128 (die
->die_abbrev
);
5290 fprintf (asm_out_file
, " (DIE (0x%lx) %s)",
5291 die
->die_offset
, dwarf_tag_name (die
->die_tag
));
5293 fputc ('\n', asm_out_file
);
5295 for (a
= die
->die_attr
; a
!= NULL
; a
= a
->dw_attr_next
)
5297 switch (a
->dw_attr_val
.val_class
)
5299 case dw_val_class_addr
:
5300 ASM_OUTPUT_DWARF_ADDR_CONST (asm_out_file
,
5301 a
->dw_attr_val
.v
.val_addr
);
5304 case dw_val_class_loc
:
5305 size
= size_of_locs (a
->dw_attr_val
.v
.val_loc
);
5307 /* Output the block length for this list of location operations. */
5308 switch (constant_size (size
))
5311 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, size
);
5314 ASM_OUTPUT_DWARF_DATA2 (asm_out_file
, size
);
5321 fprintf (asm_out_file
, "\t%s %s",
5322 ASM_COMMENT_START
, dwarf_attr_name (a
->dw_attr
));
5324 fputc ('\n', asm_out_file
);
5325 for (loc
= a
->dw_attr_val
.v
.val_loc
; loc
!= NULL
;
5326 loc
= loc
->dw_loc_next
)
5328 /* Output the opcode. */
5329 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, loc
->dw_loc_opc
);
5331 fprintf (asm_out_file
, "\t%s %s", ASM_COMMENT_START
,
5332 dwarf_stack_op_name (loc
->dw_loc_opc
));
5334 fputc ('\n', asm_out_file
);
5336 /* Output the operand(s) (if any). */
5337 output_loc_operands (loc
);
5341 case dw_val_class_const
:
5342 ASM_OUTPUT_DWARF_DATA4 (asm_out_file
, a
->dw_attr_val
.v
.val_int
);
5345 case dw_val_class_unsigned_const
:
5346 switch (constant_size (a
->dw_attr_val
.v
.val_unsigned
))
5349 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
,
5350 a
->dw_attr_val
.v
.val_unsigned
);
5353 ASM_OUTPUT_DWARF_DATA2 (asm_out_file
,
5354 a
->dw_attr_val
.v
.val_unsigned
);
5357 ASM_OUTPUT_DWARF_DATA4 (asm_out_file
,
5358 a
->dw_attr_val
.v
.val_unsigned
);
5361 ASM_OUTPUT_DWARF_DATA8 (asm_out_file
,
5362 a
->dw_attr_val
.v
.val_long_long
.hi
,
5363 a
->dw_attr_val
.v
.val_long_long
.low
);
5370 case dw_val_class_long_long
:
5371 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, 8);
5373 fprintf (asm_out_file
, "\t%s %s",
5374 ASM_COMMENT_START
, dwarf_attr_name (a
->dw_attr
));
5376 fputc ('\n', asm_out_file
);
5377 ASM_OUTPUT_DWARF_DATA8 (asm_out_file
,
5378 a
->dw_attr_val
.v
.val_long_long
.hi
,
5379 a
->dw_attr_val
.v
.val_long_long
.low
);
5382 fprintf (asm_out_file
,
5383 "\t%s long long constant", ASM_COMMENT_START
);
5385 fputc ('\n', asm_out_file
);
5388 case dw_val_class_float
:
5390 register unsigned int i
;
5391 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
,
5392 a
->dw_attr_val
.v
.val_float
.length
* 4);
5394 fprintf (asm_out_file
, "\t%s %s",
5395 ASM_COMMENT_START
, dwarf_attr_name (a
->dw_attr
));
5397 fputc ('\n', asm_out_file
);
5398 for (i
= 0; i
< a
->dw_attr_val
.v
.val_float
.length
; ++i
)
5400 ASM_OUTPUT_DWARF_DATA4 (asm_out_file
,
5401 a
->dw_attr_val
.v
.val_float
.array
[i
]);
5403 fprintf (asm_out_file
, "\t%s fp constant word %u",
5404 ASM_COMMENT_START
, i
);
5406 fputc ('\n', asm_out_file
);
5411 case dw_val_class_flag
:
5412 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, a
->dw_attr_val
.v
.val_flag
);
5415 case dw_val_class_die_ref
:
5416 if (a
->dw_attr_val
.v
.val_die_ref
!= NULL
)
5417 ref_offset
= a
->dw_attr_val
.v
.val_die_ref
->die_offset
;
5418 else if (a
->dw_attr
== DW_AT_sibling
)
5419 ref_offset
= sibling_offset(die
);
5423 ASM_OUTPUT_DWARF_DATA (asm_out_file
, ref_offset
);
5426 case dw_val_class_fde_ref
:
5429 ASM_GENERATE_INTERNAL_LABEL
5430 (l1
, FDE_AFTER_SIZE_LABEL
, a
->dw_attr_val
.v
.val_fde_index
* 2);
5431 ASM_OUTPUT_DWARF_OFFSET (asm_out_file
, l1
);
5432 fprintf (asm_out_file
, " - %d", DWARF_OFFSET_SIZE
);
5436 case dw_val_class_lbl_id
:
5437 ASM_OUTPUT_DWARF_ADDR (asm_out_file
, a
->dw_attr_val
.v
.val_lbl_id
);
5440 case dw_val_class_lbl_offset
:
5441 ASM_OUTPUT_DWARF_OFFSET (asm_out_file
, a
->dw_attr_val
.v
.val_lbl_id
);
5444 case dw_val_class_str
:
5446 ASM_OUTPUT_DWARF_STRING (asm_out_file
, a
->dw_attr_val
.v
.val_str
);
5448 ASM_OUTPUT_ASCII (asm_out_file
,
5449 a
->dw_attr_val
.v
.val_str
,
5450 (int) strlen (a
->dw_attr_val
.v
.val_str
) + 1);
5457 if (a
->dw_attr_val
.val_class
!= dw_val_class_loc
5458 && a
->dw_attr_val
.val_class
!= dw_val_class_long_long
5459 && a
->dw_attr_val
.val_class
!= dw_val_class_float
)
5462 fprintf (asm_out_file
, "\t%s %s",
5463 ASM_COMMENT_START
, dwarf_attr_name (a
->dw_attr
));
5465 fputc ('\n', asm_out_file
);
5469 for (c
= die
->die_child
; c
!= NULL
; c
= c
->die_sib
)
5472 if (die
->die_child
!= NULL
)
5474 /* Add null byte to terminate sibling list. */
5475 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, 0);
5477 fprintf (asm_out_file
, "\t%s end of children of DIE 0x%lx",
5478 ASM_COMMENT_START
, die
->die_offset
);
5480 fputc ('\n', asm_out_file
);
5484 /* Output the compilation unit that appears at the beginning of the
5485 .debug_info section, and precedes the DIE descriptions. */
5488 output_compilation_unit_header ()
5490 ASM_OUTPUT_DWARF_DATA (asm_out_file
, next_die_offset
- DWARF_OFFSET_SIZE
);
5492 fprintf (asm_out_file
, "\t%s Length of Compilation Unit Info.",
5495 fputc ('\n', asm_out_file
);
5496 ASM_OUTPUT_DWARF_DATA2 (asm_out_file
, DWARF_VERSION
);
5498 fprintf (asm_out_file
, "\t%s DWARF version number", ASM_COMMENT_START
);
5500 fputc ('\n', asm_out_file
);
5501 ASM_OUTPUT_DWARF_OFFSET (asm_out_file
, abbrev_section_label
);
5503 fprintf (asm_out_file
, "\t%s Offset Into Abbrev. Section",
5506 fputc ('\n', asm_out_file
);
5507 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, PTR_SIZE
);
5509 fprintf (asm_out_file
, "\t%s Pointer Size (in bytes)", ASM_COMMENT_START
);
5511 fputc ('\n', asm_out_file
);
5514 /* The DWARF2 pubname for a nested thingy looks like "A::f". The output
5515 of decl_printable_name for C++ looks like "A::f(int)". Let's drop the
5516 argument list, and maybe the scope. */
5519 dwarf2_name (decl
, scope
)
5523 return (*decl_printable_name
) (decl
, scope
? 1 : 0);
5526 /* Add a new entry to .debug_pubnames if appropriate. */
5529 add_pubname (decl
, die
)
5535 if (! TREE_PUBLIC (decl
))
5538 if (pubname_table_in_use
== pubname_table_allocated
)
5540 pubname_table_allocated
+= PUBNAME_TABLE_INCREMENT
;
5541 pubname_table
= (pubname_ref
) xrealloc
5542 (pubname_table
, pubname_table_allocated
* sizeof (pubname_entry
));
5545 p
= &pubname_table
[pubname_table_in_use
++];
5548 p
->name
= xstrdup (dwarf2_name (decl
, 1));
5551 /* Output the public names table used to speed up access to externally
5552 visible names. For now, only generate entries for externally
5553 visible procedures. */
5558 register unsigned i
;
5559 register unsigned long pubnames_length
= size_of_pubnames ();
5561 ASM_OUTPUT_DWARF_DATA (asm_out_file
, pubnames_length
);
5564 fprintf (asm_out_file
, "\t%s Length of Public Names Info.",
5567 fputc ('\n', asm_out_file
);
5568 ASM_OUTPUT_DWARF_DATA2 (asm_out_file
, DWARF_VERSION
);
5571 fprintf (asm_out_file
, "\t%s DWARF Version", ASM_COMMENT_START
);
5573 fputc ('\n', asm_out_file
);
5574 ASM_OUTPUT_DWARF_OFFSET (asm_out_file
, debug_info_section_label
);
5576 fprintf (asm_out_file
, "\t%s Offset of Compilation Unit Info.",
5579 fputc ('\n', asm_out_file
);
5580 ASM_OUTPUT_DWARF_DATA (asm_out_file
, next_die_offset
);
5582 fprintf (asm_out_file
, "\t%s Compilation Unit Length", ASM_COMMENT_START
);
5584 fputc ('\n', asm_out_file
);
5585 for (i
= 0; i
< pubname_table_in_use
; ++i
)
5587 register pubname_ref pub
= &pubname_table
[i
];
5589 ASM_OUTPUT_DWARF_DATA (asm_out_file
, pub
->die
->die_offset
);
5591 fprintf (asm_out_file
, "\t%s DIE offset", ASM_COMMENT_START
);
5593 fputc ('\n', asm_out_file
);
5597 ASM_OUTPUT_DWARF_STRING (asm_out_file
, pub
->name
);
5598 fprintf (asm_out_file
, "%s external name", ASM_COMMENT_START
);
5602 ASM_OUTPUT_ASCII (asm_out_file
, pub
->name
,
5603 (int) strlen (pub
->name
) + 1);
5606 fputc ('\n', asm_out_file
);
5609 ASM_OUTPUT_DWARF_DATA (asm_out_file
, 0);
5610 fputc ('\n', asm_out_file
);
5613 /* Add a new entry to .debug_aranges if appropriate. */
5616 add_arange (decl
, die
)
5620 if (! DECL_SECTION_NAME (decl
))
5623 if (arange_table_in_use
== arange_table_allocated
)
5625 arange_table_allocated
+= ARANGE_TABLE_INCREMENT
;
5627 = (arange_ref
) xrealloc (arange_table
,
5628 arange_table_allocated
* sizeof (dw_die_ref
));
5631 arange_table
[arange_table_in_use
++] = die
;
5634 /* Output the information that goes into the .debug_aranges table.
5635 Namely, define the beginning and ending address range of the
5636 text section generated for this compilation unit. */
5641 register unsigned i
;
5642 register unsigned long aranges_length
= size_of_aranges ();
5644 ASM_OUTPUT_DWARF_DATA (asm_out_file
, aranges_length
);
5646 fprintf (asm_out_file
, "\t%s Length of Address Ranges Info.",
5649 fputc ('\n', asm_out_file
);
5650 ASM_OUTPUT_DWARF_DATA2 (asm_out_file
, DWARF_VERSION
);
5652 fprintf (asm_out_file
, "\t%s DWARF Version", ASM_COMMENT_START
);
5654 fputc ('\n', asm_out_file
);
5655 ASM_OUTPUT_DWARF_OFFSET (asm_out_file
, debug_info_section_label
);
5657 fprintf (asm_out_file
, "\t%s Offset of Compilation Unit Info.",
5660 fputc ('\n', asm_out_file
);
5661 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, PTR_SIZE
);
5663 fprintf (asm_out_file
, "\t%s Size of Address", ASM_COMMENT_START
);
5665 fputc ('\n', asm_out_file
);
5666 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, 0);
5668 fprintf (asm_out_file
, "\t%s Size of Segment Descriptor",
5671 fputc ('\n', asm_out_file
);
5672 ASM_OUTPUT_DWARF_DATA4 (asm_out_file
, 4);
5674 fprintf (asm_out_file
, ",0,0");
5677 fprintf (asm_out_file
, "\t%s Pad to %d byte boundary",
5678 ASM_COMMENT_START
, 2 * PTR_SIZE
);
5680 fputc ('\n', asm_out_file
);
5681 ASM_OUTPUT_DWARF_ADDR (asm_out_file
, text_section_label
);
5683 fprintf (asm_out_file
, "\t%s Address", ASM_COMMENT_START
);
5685 fputc ('\n', asm_out_file
);
5686 ASM_OUTPUT_DWARF_ADDR_DELTA (asm_out_file
, text_end_label
,
5687 text_section_label
);
5689 fprintf (asm_out_file
, "%s Length", ASM_COMMENT_START
);
5691 fputc ('\n', asm_out_file
);
5692 for (i
= 0; i
< arange_table_in_use
; ++i
)
5694 dw_die_ref a
= arange_table
[i
];
5696 if (a
->die_tag
== DW_TAG_subprogram
)
5697 ASM_OUTPUT_DWARF_ADDR (asm_out_file
, get_AT_low_pc (a
));
5700 char *name
= get_AT_string (a
, DW_AT_MIPS_linkage_name
);
5702 name
= get_AT_string (a
, DW_AT_name
);
5704 ASM_OUTPUT_DWARF_ADDR (asm_out_file
, name
);
5708 fprintf (asm_out_file
, "\t%s Address", ASM_COMMENT_START
);
5710 fputc ('\n', asm_out_file
);
5711 if (a
->die_tag
== DW_TAG_subprogram
)
5712 ASM_OUTPUT_DWARF_ADDR_DELTA (asm_out_file
, get_AT_hi_pc (a
),
5715 ASM_OUTPUT_DWARF_ADDR_DATA (asm_out_file
,
5716 get_AT_unsigned (a
, DW_AT_byte_size
));
5719 fprintf (asm_out_file
, "%s Length", ASM_COMMENT_START
);
5721 fputc ('\n', asm_out_file
);
5724 /* Output the terminator words. */
5725 ASM_OUTPUT_DWARF_ADDR_DATA (asm_out_file
, 0);
5726 fputc ('\n', asm_out_file
);
5727 ASM_OUTPUT_DWARF_ADDR_DATA (asm_out_file
, 0);
5728 fputc ('\n', asm_out_file
);
5731 /* Output the source line number correspondence information. This
5732 information goes into the .debug_line section.
5734 If the format of this data changes, then the function size_of_line_info
5735 must also be adjusted the same way. */
5740 char line_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
5741 char prev_line_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
5742 register unsigned opc
;
5743 register unsigned n_op_args
;
5744 register unsigned long ft_index
;
5745 register unsigned long lt_index
;
5746 register unsigned long current_line
;
5747 register long line_offset
;
5748 register long line_delta
;
5749 register unsigned long current_file
;
5750 register unsigned long function
;
5752 ASM_OUTPUT_DWARF_DATA (asm_out_file
, size_of_line_info ());
5754 fprintf (asm_out_file
, "\t%s Length of Source Line Info.",
5757 fputc ('\n', asm_out_file
);
5758 ASM_OUTPUT_DWARF_DATA2 (asm_out_file
, DWARF_VERSION
);
5760 fprintf (asm_out_file
, "\t%s DWARF Version", ASM_COMMENT_START
);
5762 fputc ('\n', asm_out_file
);
5763 ASM_OUTPUT_DWARF_DATA (asm_out_file
, size_of_line_prolog ());
5765 fprintf (asm_out_file
, "\t%s Prolog Length", ASM_COMMENT_START
);
5767 fputc ('\n', asm_out_file
);
5768 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, DWARF_LINE_MIN_INSTR_LENGTH
);
5770 fprintf (asm_out_file
, "\t%s Minimum Instruction Length",
5773 fputc ('\n', asm_out_file
);
5774 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, DWARF_LINE_DEFAULT_IS_STMT_START
);
5776 fprintf (asm_out_file
, "\t%s Default is_stmt_start flag",
5779 fputc ('\n', asm_out_file
);
5780 fprintf (asm_out_file
, "\t%s\t%d", ASM_BYTE_OP
, DWARF_LINE_BASE
);
5782 fprintf (asm_out_file
, "\t%s Line Base Value (Special Opcodes)",
5785 fputc ('\n', asm_out_file
);
5786 fprintf (asm_out_file
, "\t%s\t%u", ASM_BYTE_OP
, DWARF_LINE_RANGE
);
5788 fprintf (asm_out_file
, "\t%s Line Range Value (Special Opcodes)",
5791 fputc ('\n', asm_out_file
);
5792 fprintf (asm_out_file
, "\t%s\t%u", ASM_BYTE_OP
, DWARF_LINE_OPCODE_BASE
);
5794 fprintf (asm_out_file
, "\t%s Special Opcode Base", ASM_COMMENT_START
);
5796 fputc ('\n', asm_out_file
);
5797 for (opc
= 1; opc
< DWARF_LINE_OPCODE_BASE
; ++opc
)
5801 case DW_LNS_advance_pc
:
5802 case DW_LNS_advance_line
:
5803 case DW_LNS_set_file
:
5804 case DW_LNS_set_column
:
5805 case DW_LNS_fixed_advance_pc
:
5812 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, n_op_args
);
5814 fprintf (asm_out_file
, "\t%s opcode: 0x%x has %d args",
5815 ASM_COMMENT_START
, opc
, n_op_args
);
5816 fputc ('\n', asm_out_file
);
5820 fprintf (asm_out_file
, "%s Include Directory Table\n", ASM_COMMENT_START
);
5822 /* Include directory table is empty, at present */
5823 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, 0);
5824 fputc ('\n', asm_out_file
);
5826 fprintf (asm_out_file
, "%s File Name Table\n", ASM_COMMENT_START
);
5828 for (ft_index
= 1; ft_index
< file_table_in_use
; ++ft_index
)
5832 ASM_OUTPUT_DWARF_STRING (asm_out_file
, file_table
[ft_index
]);
5833 fprintf (asm_out_file
, "%s File Entry: 0x%lx",
5834 ASM_COMMENT_START
, ft_index
);
5838 ASM_OUTPUT_ASCII (asm_out_file
,
5839 file_table
[ft_index
],
5840 (int) strlen (file_table
[ft_index
]) + 1);
5843 fputc ('\n', asm_out_file
);
5845 /* Include directory index */
5847 fputc ('\n', asm_out_file
);
5849 /* Modification time */
5851 fputc ('\n', asm_out_file
);
5853 /* File length in bytes */
5855 fputc ('\n', asm_out_file
);
5858 /* Terminate the file name table */
5859 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, 0);
5860 fputc ('\n', asm_out_file
);
5862 /* We used to set the address register to the first location in the text
5863 section here, but that didn't accomplish anything since we already
5864 have a line note for the opening brace of the first function. */
5866 /* Generate the line number to PC correspondence table, encoded as
5867 a series of state machine operations. */
5870 strcpy (prev_line_label
, text_section_label
);
5871 for (lt_index
= 1; lt_index
< line_info_table_in_use
; ++lt_index
)
5873 register dw_line_info_ref line_info
= &line_info_table
[lt_index
];
5875 /* Don't emit anything for redundant notes. Just updating the
5876 address doesn't accomplish anything, because we already assume
5877 that anything after the last address is this line. */
5878 if (line_info
->dw_line_num
== current_line
5879 && line_info
->dw_file_num
== current_file
)
5882 /* Emit debug info for the address of the current line, choosing
5883 the encoding that uses the least amount of space. */
5884 /* ??? Unfortunately, we have little choice here currently, and must
5885 always use the most general form. Gcc does not know the address
5886 delta itself, so we can't use DW_LNS_advance_pc. There are no known
5887 dwarf2 aware assemblers at this time, so we can't use any special
5888 pseudo ops that would allow the assembler to optimally encode this for
5889 us. Many ports do have length attributes which will give an upper
5890 bound on the address range. We could perhaps use length attributes
5891 to determine when it is safe to use DW_LNS_fixed_advance_pc. */
5892 ASM_GENERATE_INTERNAL_LABEL (line_label
, LINE_CODE_LABEL
, lt_index
);
5895 /* This can handle deltas up to 0xffff. This takes 3 bytes. */
5896 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, DW_LNS_fixed_advance_pc
);
5898 fprintf (asm_out_file
, "\t%s DW_LNS_fixed_advance_pc",
5901 fputc ('\n', asm_out_file
);
5902 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file
, line_label
, prev_line_label
);
5903 fputc ('\n', asm_out_file
);
5907 /* This can handle any delta. This takes 4+PTR_SIZE bytes. */
5908 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, 0);
5910 fprintf (asm_out_file
, "\t%s DW_LNE_set_address",
5912 fputc ('\n', asm_out_file
);
5913 output_uleb128 (1 + PTR_SIZE
);
5914 fputc ('\n', asm_out_file
);
5915 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, DW_LNE_set_address
);
5916 fputc ('\n', asm_out_file
);
5917 ASM_OUTPUT_DWARF_ADDR (asm_out_file
, line_label
);
5918 fputc ('\n', asm_out_file
);
5920 strcpy (prev_line_label
, line_label
);
5922 /* Emit debug info for the source file of the current line, if
5923 different from the previous line. */
5924 if (line_info
->dw_file_num
!= current_file
)
5926 current_file
= line_info
->dw_file_num
;
5927 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, DW_LNS_set_file
);
5929 fprintf (asm_out_file
, "\t%s DW_LNS_set_file", ASM_COMMENT_START
);
5931 fputc ('\n', asm_out_file
);
5932 output_uleb128 (current_file
);
5934 fprintf (asm_out_file
, " (\"%s\")", file_table
[current_file
]);
5936 fputc ('\n', asm_out_file
);
5939 /* Emit debug info for the current line number, choosing the encoding
5940 that uses the least amount of space. */
5941 if (line_info
->dw_line_num
!= current_line
)
5943 line_offset
= line_info
->dw_line_num
- current_line
;
5944 line_delta
= line_offset
- DWARF_LINE_BASE
;
5945 current_line
= line_info
->dw_line_num
;
5946 if (line_delta
>= 0 && line_delta
< (DWARF_LINE_RANGE
- 1))
5948 /* This can handle deltas from -10 to 234, using the current
5949 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE. This
5951 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
,
5952 DWARF_LINE_OPCODE_BASE
+ line_delta
);
5954 fprintf (asm_out_file
,
5955 "\t%s line %ld", ASM_COMMENT_START
, current_line
);
5957 fputc ('\n', asm_out_file
);
5961 /* This can handle any delta. This takes at least 4 bytes,
5962 depending on the value being encoded. */
5963 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, DW_LNS_advance_line
);
5965 fprintf (asm_out_file
, "\t%s advance to line %ld",
5966 ASM_COMMENT_START
, current_line
);
5968 fputc ('\n', asm_out_file
);
5969 output_sleb128 (line_offset
);
5970 fputc ('\n', asm_out_file
);
5971 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, DW_LNS_copy
);
5973 fprintf (asm_out_file
, "\t%s DW_LNS_copy", ASM_COMMENT_START
);
5974 fputc ('\n', asm_out_file
);
5979 /* We still need to start a new row, so output a copy insn. */
5980 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, DW_LNS_copy
);
5982 fprintf (asm_out_file
, "\t%s DW_LNS_copy", ASM_COMMENT_START
);
5983 fputc ('\n', asm_out_file
);
5987 /* Emit debug info for the address of the end of the function. */
5990 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, DW_LNS_fixed_advance_pc
);
5992 fprintf (asm_out_file
, "\t%s DW_LNS_fixed_advance_pc",
5995 fputc ('\n', asm_out_file
);
5996 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file
, text_end_label
, prev_line_label
);
5997 fputc ('\n', asm_out_file
);
6001 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, 0);
6003 fprintf (asm_out_file
, "\t%s DW_LNE_set_address", ASM_COMMENT_START
);
6004 fputc ('\n', asm_out_file
);
6005 output_uleb128 (1 + PTR_SIZE
);
6006 fputc ('\n', asm_out_file
);
6007 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, DW_LNE_set_address
);
6008 fputc ('\n', asm_out_file
);
6009 ASM_OUTPUT_DWARF_ADDR (asm_out_file
, text_end_label
);
6010 fputc ('\n', asm_out_file
);
6013 /* Output the marker for the end of the line number info. */
6014 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, 0);
6016 fprintf (asm_out_file
, "\t%s DW_LNE_end_sequence", ASM_COMMENT_START
);
6018 fputc ('\n', asm_out_file
);
6020 fputc ('\n', asm_out_file
);
6021 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, DW_LNE_end_sequence
);
6022 fputc ('\n', asm_out_file
);
6027 for (lt_index
= 0; lt_index
< separate_line_info_table_in_use
; )
6029 register dw_separate_line_info_ref line_info
6030 = &separate_line_info_table
[lt_index
];
6032 /* Don't emit anything for redundant notes. */
6033 if (line_info
->dw_line_num
== current_line
6034 && line_info
->dw_file_num
== current_file
6035 && line_info
->function
== function
)
6038 /* Emit debug info for the address of the current line. If this is
6039 a new function, or the first line of a function, then we need
6040 to handle it differently. */
6041 ASM_GENERATE_INTERNAL_LABEL (line_label
, SEPARATE_LINE_CODE_LABEL
,
6043 if (function
!= line_info
->function
)
6045 function
= line_info
->function
;
6047 /* Set the address register to the first line in the function */
6048 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, 0);
6050 fprintf (asm_out_file
, "\t%s DW_LNE_set_address",
6053 fputc ('\n', asm_out_file
);
6054 output_uleb128 (1 + PTR_SIZE
);
6055 fputc ('\n', asm_out_file
);
6056 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, DW_LNE_set_address
);
6057 fputc ('\n', asm_out_file
);
6058 ASM_OUTPUT_DWARF_ADDR (asm_out_file
, line_label
);
6059 fputc ('\n', asm_out_file
);
6063 /* ??? See the DW_LNS_advance_pc comment above. */
6066 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, DW_LNS_fixed_advance_pc
);
6068 fprintf (asm_out_file
, "\t%s DW_LNS_fixed_advance_pc",
6071 fputc ('\n', asm_out_file
);
6072 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file
, line_label
,
6074 fputc ('\n', asm_out_file
);
6078 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, 0);
6080 fprintf (asm_out_file
, "\t%s DW_LNE_set_address",
6082 fputc ('\n', asm_out_file
);
6083 output_uleb128 (1 + PTR_SIZE
);
6084 fputc ('\n', asm_out_file
);
6085 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, DW_LNE_set_address
);
6086 fputc ('\n', asm_out_file
);
6087 ASM_OUTPUT_DWARF_ADDR (asm_out_file
, line_label
);
6088 fputc ('\n', asm_out_file
);
6091 strcpy (prev_line_label
, line_label
);
6093 /* Emit debug info for the source file of the current line, if
6094 different from the previous line. */
6095 if (line_info
->dw_file_num
!= current_file
)
6097 current_file
= line_info
->dw_file_num
;
6098 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, DW_LNS_set_file
);
6100 fprintf (asm_out_file
, "\t%s DW_LNS_set_file", ASM_COMMENT_START
);
6102 fputc ('\n', asm_out_file
);
6103 output_uleb128 (current_file
);
6105 fprintf (asm_out_file
, " (\"%s\")", file_table
[current_file
]);
6107 fputc ('\n', asm_out_file
);
6110 /* Emit debug info for the current line number, choosing the encoding
6111 that uses the least amount of space. */
6112 if (line_info
->dw_line_num
!= current_line
)
6114 line_offset
= line_info
->dw_line_num
- current_line
;
6115 line_delta
= line_offset
- DWARF_LINE_BASE
;
6116 current_line
= line_info
->dw_line_num
;
6117 if (line_delta
>= 0 && line_delta
< (DWARF_LINE_RANGE
- 1))
6119 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
,
6120 DWARF_LINE_OPCODE_BASE
+ line_delta
);
6122 fprintf (asm_out_file
,
6123 "\t%s line %ld", ASM_COMMENT_START
, current_line
);
6125 fputc ('\n', asm_out_file
);
6129 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, DW_LNS_advance_line
);
6131 fprintf (asm_out_file
, "\t%s advance to line %ld",
6132 ASM_COMMENT_START
, current_line
);
6134 fputc ('\n', asm_out_file
);
6135 output_sleb128 (line_offset
);
6136 fputc ('\n', asm_out_file
);
6137 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, DW_LNS_copy
);
6139 fprintf (asm_out_file
, "\t%s DW_LNS_copy", ASM_COMMENT_START
);
6140 fputc ('\n', asm_out_file
);
6145 /* We still need to start a new row, so output a copy insn. */
6146 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, DW_LNS_copy
);
6148 fprintf (asm_out_file
, "\t%s DW_LNS_copy", ASM_COMMENT_START
);
6149 fputc ('\n', asm_out_file
);
6155 /* If we're done with a function, end its sequence. */
6156 if (lt_index
== separate_line_info_table_in_use
6157 || separate_line_info_table
[lt_index
].function
!= function
)
6162 /* Emit debug info for the address of the end of the function. */
6163 ASM_GENERATE_INTERNAL_LABEL (line_label
, FUNC_END_LABEL
, function
);
6166 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, DW_LNS_fixed_advance_pc
);
6168 fprintf (asm_out_file
, "\t%s DW_LNS_fixed_advance_pc",
6171 fputc ('\n', asm_out_file
);
6172 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file
, line_label
,
6174 fputc ('\n', asm_out_file
);
6178 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, 0);
6180 fprintf (asm_out_file
, "\t%s DW_LNE_set_address",
6182 fputc ('\n', asm_out_file
);
6183 output_uleb128 (1 + PTR_SIZE
);
6184 fputc ('\n', asm_out_file
);
6185 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, DW_LNE_set_address
);
6186 fputc ('\n', asm_out_file
);
6187 ASM_OUTPUT_DWARF_ADDR (asm_out_file
, line_label
);
6188 fputc ('\n', asm_out_file
);
6191 /* Output the marker for the end of this sequence. */
6192 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, 0);
6194 fprintf (asm_out_file
, "\t%s DW_LNE_end_sequence",
6197 fputc ('\n', asm_out_file
);
6199 fputc ('\n', asm_out_file
);
6200 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, DW_LNE_end_sequence
);
6201 fputc ('\n', asm_out_file
);
6206 /* Given a pointer to a BLOCK node return non-zero if (and only if) the node
6207 in question represents the outermost pair of curly braces (i.e. the "body
6208 block") of a function or method.
6210 For any BLOCK node representing a "body block" of a function or method, the
6211 BLOCK_SUPERCONTEXT of the node will point to another BLOCK node which
6212 represents the outermost (function) scope for the function or method (i.e.
6213 the one which includes the formal parameters). The BLOCK_SUPERCONTEXT of
6214 *that* node in turn will point to the relevant FUNCTION_DECL node. */
6217 is_body_block (stmt
)
6220 if (TREE_CODE (stmt
) == BLOCK
)
6222 register tree parent
= BLOCK_SUPERCONTEXT (stmt
);
6224 if (TREE_CODE (parent
) == BLOCK
)
6226 register tree grandparent
= BLOCK_SUPERCONTEXT (parent
);
6228 if (TREE_CODE (grandparent
) == FUNCTION_DECL
)
6236 /* Given a pointer to a tree node for some base type, return a pointer to
6237 a DIE that describes the given type.
6239 This routine must only be called for GCC type nodes that correspond to
6240 Dwarf base (fundamental) types. */
6243 base_type_die (type
)
6246 register dw_die_ref base_type_result
;
6247 register char *type_name
;
6248 register enum dwarf_type encoding
;
6249 register tree name
= TYPE_NAME (type
);
6251 if (TREE_CODE (type
) == ERROR_MARK
6252 || TREE_CODE (type
) == VOID_TYPE
)
6255 if (TREE_CODE (name
) == TYPE_DECL
)
6256 name
= DECL_NAME (name
);
6257 type_name
= IDENTIFIER_POINTER (name
);
6259 switch (TREE_CODE (type
))
6262 /* Carefully distinguish the C character types, without messing
6263 up if the language is not C. Note that we check only for the names
6264 that contain spaces; other names might occur by coincidence in other
6266 if (! (TYPE_PRECISION (type
) == CHAR_TYPE_SIZE
6267 && (type
== char_type_node
6268 || ! strcmp (type_name
, "signed char")
6269 || ! strcmp (type_name
, "unsigned char"))))
6271 if (TREE_UNSIGNED (type
))
6272 encoding
= DW_ATE_unsigned
;
6274 encoding
= DW_ATE_signed
;
6277 /* else fall through */
6280 /* GNU Pascal/Ada CHAR type. Not used in C. */
6281 if (TREE_UNSIGNED (type
))
6282 encoding
= DW_ATE_unsigned_char
;
6284 encoding
= DW_ATE_signed_char
;
6288 encoding
= DW_ATE_float
;
6292 encoding
= DW_ATE_complex_float
;
6296 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */
6297 encoding
= DW_ATE_boolean
;
6301 abort (); /* No other TREE_CODEs are Dwarf fundamental types. */
6304 base_type_result
= new_die (DW_TAG_base_type
, comp_unit_die
);
6305 add_AT_string (base_type_result
, DW_AT_name
, type_name
);
6306 add_AT_unsigned (base_type_result
, DW_AT_byte_size
,
6307 int_size_in_bytes (type
));
6308 add_AT_unsigned (base_type_result
, DW_AT_encoding
, encoding
);
6310 return base_type_result
;
6313 /* Given a pointer to an arbitrary ..._TYPE tree node, return a pointer to
6314 the Dwarf "root" type for the given input type. The Dwarf "root" type of
6315 a given type is generally the same as the given type, except that if the
6316 given type is a pointer or reference type, then the root type of the given
6317 type is the root type of the "basis" type for the pointer or reference
6318 type. (This definition of the "root" type is recursive.) Also, the root
6319 type of a `const' qualified type or a `volatile' qualified type is the
6320 root type of the given type without the qualifiers. */
6326 if (TREE_CODE (type
) == ERROR_MARK
)
6327 return error_mark_node
;
6329 switch (TREE_CODE (type
))
6332 return error_mark_node
;
6335 case REFERENCE_TYPE
:
6336 return type_main_variant (root_type (TREE_TYPE (type
)));
6339 return type_main_variant (type
);
6343 /* Given a pointer to an arbitrary ..._TYPE tree node, return non-zero if the
6344 given input type is a Dwarf "fundamental" type. Otherwise return null. */
6350 switch (TREE_CODE (type
))
6365 case QUAL_UNION_TYPE
:
6370 case REFERENCE_TYPE
:
6383 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
6384 entry that chains various modifiers in front of the given type. */
6387 modified_type_die (type
, is_const_type
, is_volatile_type
, context_die
)
6389 register int is_const_type
;
6390 register int is_volatile_type
;
6391 register dw_die_ref context_die
;
6393 register enum tree_code code
= TREE_CODE (type
);
6394 register dw_die_ref mod_type_die
= NULL
;
6395 register dw_die_ref sub_die
= NULL
;
6396 register tree item_type
= NULL
;
6398 if (code
!= ERROR_MARK
)
6400 type
= build_type_variant (type
, is_const_type
, is_volatile_type
);
6402 mod_type_die
= lookup_type_die (type
);
6404 return mod_type_die
;
6406 /* Handle C typedef types. */
6407 if (TYPE_NAME (type
) && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
6408 && DECL_ORIGINAL_TYPE (TYPE_NAME (type
)))
6410 tree dtype
= TREE_TYPE (TYPE_NAME (type
));
6413 /* For a named type, use the typedef. */
6414 gen_type_die (type
, context_die
);
6415 mod_type_die
= lookup_type_die (type
);
6418 else if (is_const_type
< TYPE_READONLY (dtype
)
6419 || is_volatile_type
< TYPE_VOLATILE (dtype
))
6420 /* cv-unqualified version of named type. Just use the unnamed
6421 type to which it refers. */
6423 = modified_type_die (DECL_ORIGINAL_TYPE (TYPE_NAME (type
)),
6424 is_const_type
, is_volatile_type
,
6426 /* Else cv-qualified version of named type; fall through. */
6431 else if (is_const_type
)
6433 mod_type_die
= new_die (DW_TAG_const_type
, comp_unit_die
);
6434 sub_die
= modified_type_die (type
, 0, is_volatile_type
, context_die
);
6436 else if (is_volatile_type
)
6438 mod_type_die
= new_die (DW_TAG_volatile_type
, comp_unit_die
);
6439 sub_die
= modified_type_die (type
, 0, 0, context_die
);
6441 else if (code
== POINTER_TYPE
)
6443 mod_type_die
= new_die (DW_TAG_pointer_type
, comp_unit_die
);
6444 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
, PTR_SIZE
);
6446 add_AT_unsigned (mod_type_die
, DW_AT_address_class
, 0);
6448 item_type
= TREE_TYPE (type
);
6450 else if (code
== REFERENCE_TYPE
)
6452 mod_type_die
= new_die (DW_TAG_reference_type
, comp_unit_die
);
6453 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
, PTR_SIZE
);
6455 add_AT_unsigned (mod_type_die
, DW_AT_address_class
, 0);
6457 item_type
= TREE_TYPE (type
);
6459 else if (is_base_type (type
))
6460 mod_type_die
= base_type_die (type
);
6463 gen_type_die (type
, context_die
);
6465 /* We have to get the type_main_variant here (and pass that to the
6466 `lookup_type_die' routine) because the ..._TYPE node we have
6467 might simply be a *copy* of some original type node (where the
6468 copy was created to help us keep track of typedef names) and
6469 that copy might have a different TYPE_UID from the original
6471 mod_type_die
= lookup_type_die (type_main_variant (type
));
6472 if (mod_type_die
== NULL
)
6477 equate_type_number_to_die (type
, mod_type_die
);
6479 /* We must do this after the equate_type_number_to_die call, in case
6480 this is a recursive type. This ensures that the modified_type_die
6481 recursion will terminate even if the type is recursive. Recursive
6482 types are possible in Ada. */
6483 sub_die
= modified_type_die (item_type
,
6484 TYPE_READONLY (item_type
),
6485 TYPE_VOLATILE (item_type
),
6488 if (sub_die
!= NULL
)
6489 add_AT_die_ref (mod_type_die
, DW_AT_type
, sub_die
);
6491 return mod_type_die
;
6494 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
6495 an enumerated type. */
6501 return TREE_CODE (type
) == ENUMERAL_TYPE
;
6504 /* Return a location descriptor that designates a machine register. */
6506 static dw_loc_descr_ref
6507 reg_loc_descriptor (rtl
)
6510 register dw_loc_descr_ref loc_result
= NULL
;
6511 register unsigned reg
= reg_number (rtl
);
6514 loc_result
= new_loc_descr (DW_OP_reg0
+ reg
, 0, 0);
6516 loc_result
= new_loc_descr (DW_OP_regx
, reg
, 0);
6521 /* Return a location descriptor that designates a base+offset location. */
6523 static dw_loc_descr_ref
6524 based_loc_descr (reg
, offset
)
6528 register dw_loc_descr_ref loc_result
;
6529 /* For the "frame base", we use the frame pointer or stack pointer
6530 registers, since the RTL for local variables is relative to one of
6532 register unsigned fp_reg
= DBX_REGISTER_NUMBER (frame_pointer_needed
6533 ? HARD_FRAME_POINTER_REGNUM
6534 : STACK_POINTER_REGNUM
);
6537 loc_result
= new_loc_descr (DW_OP_fbreg
, offset
, 0);
6539 loc_result
= new_loc_descr (DW_OP_breg0
+ reg
, offset
, 0);
6541 loc_result
= new_loc_descr (DW_OP_bregx
, reg
, offset
);
6546 /* Return true if this RTL expression describes a base+offset calculation. */
6552 return (GET_CODE (rtl
) == PLUS
6553 && ((GET_CODE (XEXP (rtl
, 0)) == REG
6554 && GET_CODE (XEXP (rtl
, 1)) == CONST_INT
)));
6557 /* The following routine converts the RTL for a variable or parameter
6558 (resident in memory) into an equivalent Dwarf representation of a
6559 mechanism for getting the address of that same variable onto the top of a
6560 hypothetical "address evaluation" stack.
6562 When creating memory location descriptors, we are effectively transforming
6563 the RTL for a memory-resident object into its Dwarf postfix expression
6564 equivalent. This routine recursively descends an RTL tree, turning
6565 it into Dwarf postfix code as it goes. */
6567 static dw_loc_descr_ref
6568 mem_loc_descriptor (rtl
)
6571 dw_loc_descr_ref mem_loc_result
= NULL
;
6572 /* Note that for a dynamically sized array, the location we will generate a
6573 description of here will be the lowest numbered location which is
6574 actually within the array. That's *not* necessarily the same as the
6575 zeroth element of the array. */
6577 switch (GET_CODE (rtl
))
6580 /* The case of a subreg may arise when we have a local (register)
6581 variable or a formal (register) parameter which doesn't quite fill
6582 up an entire register. For now, just assume that it is
6583 legitimate to make the Dwarf info refer to the whole register which
6584 contains the given subreg. */
6585 rtl
= XEXP (rtl
, 0);
6587 /* ... fall through ... */
6590 /* Whenever a register number forms a part of the description of the
6591 method for calculating the (dynamic) address of a memory resident
6592 object, DWARF rules require the register number be referred to as
6593 a "base register". This distinction is not based in any way upon
6594 what category of register the hardware believes the given register
6595 belongs to. This is strictly DWARF terminology we're dealing with
6596 here. Note that in cases where the location of a memory-resident
6597 data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
6598 OP_CONST (0)) the actual DWARF location descriptor that we generate
6599 may just be OP_BASEREG (basereg). This may look deceptively like
6600 the object in question was allocated to a register (rather than in
6601 memory) so DWARF consumers need to be aware of the subtle
6602 distinction between OP_REG and OP_BASEREG. */
6603 mem_loc_result
= based_loc_descr (reg_number (rtl
), 0);
6607 mem_loc_result
= mem_loc_descriptor (XEXP (rtl
, 0));
6608 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_deref
, 0, 0));
6613 mem_loc_result
= new_loc_descr (DW_OP_addr
, 0, 0);
6614 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_addr
;
6615 mem_loc_result
->dw_loc_oprnd1
.v
.val_addr
= addr_to_string (rtl
);
6619 if (is_based_loc (rtl
))
6620 mem_loc_result
= based_loc_descr (reg_number (XEXP (rtl
, 0)),
6621 INTVAL (XEXP (rtl
, 1)));
6624 add_loc_descr (&mem_loc_result
, mem_loc_descriptor (XEXP (rtl
, 0)));
6625 add_loc_descr (&mem_loc_result
, mem_loc_descriptor (XEXP (rtl
, 1)));
6626 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_plus
, 0, 0));
6631 /* If a pseudo-reg is optimized away, it is possible for it to
6632 be replaced with a MEM containing a multiply. */
6633 add_loc_descr (&mem_loc_result
, mem_loc_descriptor (XEXP (rtl
, 0)));
6634 add_loc_descr (&mem_loc_result
, mem_loc_descriptor (XEXP (rtl
, 1)));
6635 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_mul
, 0, 0));
6639 mem_loc_result
= new_loc_descr (DW_OP_constu
, INTVAL (rtl
), 0);
6646 return mem_loc_result
;
6649 /* Return a descriptor that describes the concatenation of two locations.
6650 This is typically a complex variable. */
6652 static dw_loc_descr_ref
6653 concat_loc_descriptor (x0
, x1
)
6654 register rtx x0
, x1
;
6656 dw_loc_descr_ref cc_loc_result
= NULL
;
6658 if (!is_pseudo_reg (x0
)
6659 && (GET_CODE (x0
) != MEM
|| !is_pseudo_reg (XEXP (x0
, 0))))
6660 add_loc_descr (&cc_loc_result
, loc_descriptor (x0
));
6661 add_loc_descr (&cc_loc_result
,
6662 new_loc_descr (DW_OP_piece
, GET_MODE_SIZE (GET_MODE (x0
)), 0));
6664 if (!is_pseudo_reg (x1
)
6665 && (GET_CODE (x1
) != MEM
|| !is_pseudo_reg (XEXP (x1
, 0))))
6666 add_loc_descr (&cc_loc_result
, loc_descriptor (x1
));
6667 add_loc_descr (&cc_loc_result
,
6668 new_loc_descr (DW_OP_piece
, GET_MODE_SIZE (GET_MODE (x1
)), 0));
6670 return cc_loc_result
;
6673 /* Output a proper Dwarf location descriptor for a variable or parameter
6674 which is either allocated in a register or in a memory location. For a
6675 register, we just generate an OP_REG and the register number. For a
6676 memory location we provide a Dwarf postfix expression describing how to
6677 generate the (dynamic) address of the object onto the address stack. */
6679 static dw_loc_descr_ref
6680 loc_descriptor (rtl
)
6683 dw_loc_descr_ref loc_result
= NULL
;
6684 switch (GET_CODE (rtl
))
6687 /* The case of a subreg may arise when we have a local (register)
6688 variable or a formal (register) parameter which doesn't quite fill
6689 up an entire register. For now, just assume that it is
6690 legitimate to make the Dwarf info refer to the whole register which
6691 contains the given subreg. */
6692 rtl
= XEXP (rtl
, 0);
6694 /* ... fall through ... */
6697 loc_result
= reg_loc_descriptor (rtl
);
6701 loc_result
= mem_loc_descriptor (XEXP (rtl
, 0));
6705 loc_result
= concat_loc_descriptor (XEXP (rtl
, 0), XEXP (rtl
, 1));
6715 /* Given an unsigned value, round it up to the lowest multiple of `boundary'
6716 which is not less than the value itself. */
6718 static inline unsigned
6719 ceiling (value
, boundary
)
6720 register unsigned value
;
6721 register unsigned boundary
;
6723 return (((value
+ boundary
- 1) / boundary
) * boundary
);
6726 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
6727 pointer to the declared type for the relevant field variable, or return
6728 `integer_type_node' if the given node turns out to be an
6737 if (TREE_CODE (decl
) == ERROR_MARK
)
6738 return integer_type_node
;
6740 type
= DECL_BIT_FIELD_TYPE (decl
);
6741 if (type
== NULL_TREE
)
6742 type
= TREE_TYPE (decl
);
6747 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
6748 node, return the alignment in bits for the type, or else return
6749 BITS_PER_WORD if the node actually turns out to be an
6752 static inline unsigned
6753 simple_type_align_in_bits (type
)
6756 return (TREE_CODE (type
) != ERROR_MARK
) ? TYPE_ALIGN (type
) : BITS_PER_WORD
;
6759 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
6760 node, return the size in bits for the type if it is a constant, or else
6761 return the alignment for the type if the type's size is not constant, or
6762 else return BITS_PER_WORD if the type actually turns out to be an
6765 static inline unsigned
6766 simple_type_size_in_bits (type
)
6769 if (TREE_CODE (type
) == ERROR_MARK
)
6770 return BITS_PER_WORD
;
6773 register tree type_size_tree
= TYPE_SIZE (type
);
6775 if (TREE_CODE (type_size_tree
) != INTEGER_CST
)
6776 return TYPE_ALIGN (type
);
6778 return (unsigned) TREE_INT_CST_LOW (type_size_tree
);
6782 /* Given a pointer to what is assumed to be a FIELD_DECL node, compute and
6783 return the byte offset of the lowest addressed byte of the "containing
6784 object" for the given FIELD_DECL, or return 0 if we are unable to
6785 determine what that offset is, either because the argument turns out to
6786 be a pointer to an ERROR_MARK node, or because the offset is actually
6787 variable. (We can't handle the latter case just yet). */
6790 field_byte_offset (decl
)
6793 register unsigned type_align_in_bytes
;
6794 register unsigned type_align_in_bits
;
6795 register unsigned type_size_in_bits
;
6796 register unsigned object_offset_in_align_units
;
6797 register unsigned object_offset_in_bits
;
6798 register unsigned object_offset_in_bytes
;
6800 register tree bitpos_tree
;
6801 register tree field_size_tree
;
6802 register unsigned bitpos_int
;
6803 register unsigned deepest_bitpos
;
6804 register unsigned field_size_in_bits
;
6806 if (TREE_CODE (decl
) == ERROR_MARK
)
6809 if (TREE_CODE (decl
) != FIELD_DECL
)
6812 type
= field_type (decl
);
6814 bitpos_tree
= DECL_FIELD_BITPOS (decl
);
6815 field_size_tree
= DECL_SIZE (decl
);
6817 /* We cannot yet cope with fields whose positions or sizes are variable, so
6818 for now, when we see such things, we simply return 0. Someday, we may
6819 be able to handle such cases, but it will be damn difficult. */
6820 if (TREE_CODE (bitpos_tree
) != INTEGER_CST
)
6822 bitpos_int
= (unsigned) TREE_INT_CST_LOW (bitpos_tree
);
6824 if (TREE_CODE (field_size_tree
) != INTEGER_CST
)
6827 field_size_in_bits
= (unsigned) TREE_INT_CST_LOW (field_size_tree
);
6828 type_size_in_bits
= simple_type_size_in_bits (type
);
6829 type_align_in_bits
= simple_type_align_in_bits (type
);
6830 type_align_in_bytes
= type_align_in_bits
/ BITS_PER_UNIT
;
6832 /* Note that the GCC front-end doesn't make any attempt to keep track of
6833 the starting bit offset (relative to the start of the containing
6834 structure type) of the hypothetical "containing object" for a bit-
6835 field. Thus, when computing the byte offset value for the start of the
6836 "containing object" of a bit-field, we must deduce this information on
6837 our own. This can be rather tricky to do in some cases. For example,
6838 handling the following structure type definition when compiling for an
6839 i386/i486 target (which only aligns long long's to 32-bit boundaries)
6842 struct S { int field1; long long field2:31; };
6844 Fortunately, there is a simple rule-of-thumb which can be
6845 used in such cases. When compiling for an i386/i486, GCC will allocate
6846 8 bytes for the structure shown above. It decides to do this based upon
6847 one simple rule for bit-field allocation. Quite simply, GCC allocates
6848 each "containing object" for each bit-field at the first (i.e. lowest
6849 addressed) legitimate alignment boundary (based upon the required
6850 minimum alignment for the declared type of the field) which it can
6851 possibly use, subject to the condition that there is still enough
6852 available space remaining in the containing object (when allocated at
6853 the selected point) to fully accommodate all of the bits of the
6854 bit-field itself. This simple rule makes it obvious why GCC allocates
6855 8 bytes for each object of the structure type shown above. When looking
6856 for a place to allocate the "containing object" for `field2', the
6857 compiler simply tries to allocate a 64-bit "containing object" at each
6858 successive 32-bit boundary (starting at zero) until it finds a place to
6859 allocate that 64- bit field such that at least 31 contiguous (and
6860 previously unallocated) bits remain within that selected 64 bit field.
6861 (As it turns out, for the example above, the compiler finds that it is
6862 OK to allocate the "containing object" 64-bit field at bit-offset zero
6863 within the structure type.) Here we attempt to work backwards from the
6864 limited set of facts we're given, and we try to deduce from those facts,
6865 where GCC must have believed that the containing object started (within
6866 the structure type). The value we deduce is then used (by the callers of
6867 this routine) to generate DW_AT_location and DW_AT_bit_offset attributes
6868 for fields (both bit-fields and, in the case of DW_AT_location, regular
6871 /* Figure out the bit-distance from the start of the structure to the
6872 "deepest" bit of the bit-field. */
6873 deepest_bitpos
= bitpos_int
+ field_size_in_bits
;
6875 /* This is the tricky part. Use some fancy footwork to deduce where the
6876 lowest addressed bit of the containing object must be. */
6877 object_offset_in_bits
6878 = ceiling (deepest_bitpos
, type_align_in_bits
) - type_size_in_bits
;
6880 /* Compute the offset of the containing object in "alignment units". */
6881 object_offset_in_align_units
= object_offset_in_bits
/ type_align_in_bits
;
6883 /* Compute the offset of the containing object in bytes. */
6884 object_offset_in_bytes
= object_offset_in_align_units
* type_align_in_bytes
;
6886 return object_offset_in_bytes
;
6889 /* The following routines define various Dwarf attributes and any data
6890 associated with them. */
6892 /* Add a location description attribute value to a DIE.
6894 This emits location attributes suitable for whole variables and
6895 whole parameters. Note that the location attributes for struct fields are
6896 generated by the routine `data_member_location_attribute' below. */
6899 add_AT_location_description (die
, attr_kind
, rtl
)
6901 enum dwarf_attribute attr_kind
;
6904 /* Handle a special case. If we are about to output a location descriptor
6905 for a variable or parameter which has been optimized out of existence,
6906 don't do that. A variable which has been optimized out
6907 of existence will have a DECL_RTL value which denotes a pseudo-reg.
6908 Currently, in some rare cases, variables can have DECL_RTL values which
6909 look like (MEM (REG pseudo-reg#)). These cases are due to bugs
6910 elsewhere in the compiler. We treat such cases as if the variable(s) in
6911 question had been optimized out of existence. */
6913 if (is_pseudo_reg (rtl
)
6914 || (GET_CODE (rtl
) == MEM
6915 && is_pseudo_reg (XEXP (rtl
, 0)))
6916 || (GET_CODE (rtl
) == CONCAT
6917 && is_pseudo_reg (XEXP (rtl
, 0))
6918 && is_pseudo_reg (XEXP (rtl
, 1))))
6921 add_AT_loc (die
, attr_kind
, loc_descriptor (rtl
));
6924 /* Attach the specialized form of location attribute used for data
6925 members of struct and union types. In the special case of a
6926 FIELD_DECL node which represents a bit-field, the "offset" part
6927 of this special location descriptor must indicate the distance
6928 in bytes from the lowest-addressed byte of the containing struct
6929 or union type to the lowest-addressed byte of the "containing
6930 object" for the bit-field. (See the `field_byte_offset' function
6931 above).. For any given bit-field, the "containing object" is a
6932 hypothetical object (of some integral or enum type) within which
6933 the given bit-field lives. The type of this hypothetical
6934 "containing object" is always the same as the declared type of
6935 the individual bit-field itself (for GCC anyway... the DWARF
6936 spec doesn't actually mandate this). Note that it is the size
6937 (in bytes) of the hypothetical "containing object" which will
6938 be given in the DW_AT_byte_size attribute for this bit-field.
6939 (See the `byte_size_attribute' function below.) It is also used
6940 when calculating the value of the DW_AT_bit_offset attribute.
6941 (See the `bit_offset_attribute' function below). */
6944 add_data_member_location_attribute (die
, decl
)
6945 register dw_die_ref die
;
6948 register unsigned long offset
;
6949 register dw_loc_descr_ref loc_descr
;
6950 register enum dwarf_location_atom op
;
6952 if (TREE_CODE (decl
) == TREE_VEC
)
6953 offset
= TREE_INT_CST_LOW (BINFO_OFFSET (decl
));
6955 offset
= field_byte_offset (decl
);
6957 /* The DWARF2 standard says that we should assume that the structure address
6958 is already on the stack, so we can specify a structure field address
6959 by using DW_OP_plus_uconst. */
6961 #ifdef MIPS_DEBUGGING_INFO
6962 /* ??? The SGI dwarf reader does not handle the DW_OP_plus_uconst operator
6963 correctly. It works only if we leave the offset on the stack. */
6966 op
= DW_OP_plus_uconst
;
6969 loc_descr
= new_loc_descr (op
, offset
, 0);
6970 add_AT_loc (die
, DW_AT_data_member_location
, loc_descr
);
6973 /* Attach an DW_AT_const_value attribute for a variable or a parameter which
6974 does not have a "location" either in memory or in a register. These
6975 things can arise in GNU C when a constant is passed as an actual parameter
6976 to an inlined function. They can also arise in C++ where declared
6977 constants do not necessarily get memory "homes". */
6980 add_const_value_attribute (die
, rtl
)
6981 register dw_die_ref die
;
6984 switch (GET_CODE (rtl
))
6987 /* Note that a CONST_INT rtx could represent either an integer or a
6988 floating-point constant. A CONST_INT is used whenever the constant
6989 will fit into a single word. In all such cases, the original mode
6990 of the constant value is wiped out, and the CONST_INT rtx is
6991 assigned VOIDmode. */
6992 add_AT_unsigned (die
, DW_AT_const_value
, (unsigned) INTVAL (rtl
));
6996 /* Note that a CONST_DOUBLE rtx could represent either an integer or a
6997 floating-point constant. A CONST_DOUBLE is used whenever the
6998 constant requires more than one word in order to be adequately
6999 represented. We output CONST_DOUBLEs as blocks. */
7001 register enum machine_mode mode
= GET_MODE (rtl
);
7003 if (GET_MODE_CLASS (mode
) == MODE_FLOAT
)
7005 register unsigned length
= GET_MODE_SIZE (mode
) / sizeof (long);
7009 REAL_VALUE_FROM_CONST_DOUBLE (rv
, rtl
);
7013 REAL_VALUE_TO_TARGET_SINGLE (rv
, array
[0]);
7017 REAL_VALUE_TO_TARGET_DOUBLE (rv
, array
);
7022 REAL_VALUE_TO_TARGET_LONG_DOUBLE (rv
, array
);
7029 add_AT_float (die
, DW_AT_const_value
, length
, array
);
7032 add_AT_long_long (die
, DW_AT_const_value
,
7033 CONST_DOUBLE_HIGH (rtl
), CONST_DOUBLE_LOW (rtl
));
7038 add_AT_string (die
, DW_AT_const_value
, XSTR (rtl
, 0));
7044 add_AT_addr (die
, DW_AT_const_value
, addr_to_string (rtl
));
7048 /* In cases where an inlined instance of an inline function is passed
7049 the address of an `auto' variable (which is local to the caller) we
7050 can get a situation where the DECL_RTL of the artificial local
7051 variable (for the inlining) which acts as a stand-in for the
7052 corresponding formal parameter (of the inline function) will look
7053 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not
7054 exactly a compile-time constant expression, but it isn't the address
7055 of the (artificial) local variable either. Rather, it represents the
7056 *value* which the artificial local variable always has during its
7057 lifetime. We currently have no way to represent such quasi-constant
7058 values in Dwarf, so for now we just punt and generate nothing. */
7062 /* No other kinds of rtx should be possible here. */
7068 /* Generate *either* an DW_AT_location attribute or else an DW_AT_const_value
7069 data attribute for a variable or a parameter. We generate the
7070 DW_AT_const_value attribute only in those cases where the given variable
7071 or parameter does not have a true "location" either in memory or in a
7072 register. This can happen (for example) when a constant is passed as an
7073 actual argument in a call to an inline function. (It's possible that
7074 these things can crop up in other ways also.) Note that one type of
7075 constant value which can be passed into an inlined function is a constant
7076 pointer. This can happen for example if an actual argument in an inlined
7077 function call evaluates to a compile-time constant address. */
7080 add_location_or_const_value_attribute (die
, decl
)
7081 register dw_die_ref die
;
7085 register tree declared_type
;
7086 register tree passed_type
;
7088 if (TREE_CODE (decl
) == ERROR_MARK
)
7091 if (TREE_CODE (decl
) != VAR_DECL
&& TREE_CODE (decl
) != PARM_DECL
)
7094 /* Here we have to decide where we are going to say the parameter "lives"
7095 (as far as the debugger is concerned). We only have a couple of
7096 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
7098 DECL_RTL normally indicates where the parameter lives during most of the
7099 activation of the function. If optimization is enabled however, this
7100 could be either NULL or else a pseudo-reg. Both of those cases indicate
7101 that the parameter doesn't really live anywhere (as far as the code
7102 generation parts of GCC are concerned) during most of the function's
7103 activation. That will happen (for example) if the parameter is never
7104 referenced within the function.
7106 We could just generate a location descriptor here for all non-NULL
7107 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
7108 a little nicer than that if we also consider DECL_INCOMING_RTL in cases
7109 where DECL_RTL is NULL or is a pseudo-reg.
7111 Note however that we can only get away with using DECL_INCOMING_RTL as
7112 a backup substitute for DECL_RTL in certain limited cases. In cases
7113 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
7114 we can be sure that the parameter was passed using the same type as it is
7115 declared to have within the function, and that its DECL_INCOMING_RTL
7116 points us to a place where a value of that type is passed.
7118 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
7119 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
7120 because in these cases DECL_INCOMING_RTL points us to a value of some
7121 type which is *different* from the type of the parameter itself. Thus,
7122 if we tried to use DECL_INCOMING_RTL to generate a location attribute in
7123 such cases, the debugger would end up (for example) trying to fetch a
7124 `float' from a place which actually contains the first part of a
7125 `double'. That would lead to really incorrect and confusing
7126 output at debug-time.
7128 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
7129 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There
7130 are a couple of exceptions however. On little-endian machines we can
7131 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
7132 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
7133 an integral type that is smaller than TREE_TYPE (decl). These cases arise
7134 when (on a little-endian machine) a non-prototyped function has a
7135 parameter declared to be of type `short' or `char'. In such cases,
7136 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
7137 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
7138 passed `int' value. If the debugger then uses that address to fetch
7139 a `short' or a `char' (on a little-endian machine) the result will be
7140 the correct data, so we allow for such exceptional cases below.
7142 Note that our goal here is to describe the place where the given formal
7143 parameter lives during most of the function's activation (i.e. between
7144 the end of the prologue and the start of the epilogue). We'll do that
7145 as best as we can. Note however that if the given formal parameter is
7146 modified sometime during the execution of the function, then a stack
7147 backtrace (at debug-time) will show the function as having been
7148 called with the *new* value rather than the value which was
7149 originally passed in. This happens rarely enough that it is not
7150 a major problem, but it *is* a problem, and I'd like to fix it.
7152 A future version of dwarf2out.c may generate two additional
7153 attributes for any given DW_TAG_formal_parameter DIE which will
7154 describe the "passed type" and the "passed location" for the
7155 given formal parameter in addition to the attributes we now
7156 generate to indicate the "declared type" and the "active
7157 location" for each parameter. This additional set of attributes
7158 could be used by debuggers for stack backtraces. Separately, note
7159 that sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be
7160 NULL also. This happens (for example) for inlined-instances of
7161 inline function formal parameters which are never referenced.
7162 This really shouldn't be happening. All PARM_DECL nodes should
7163 get valid non-NULL DECL_INCOMING_RTL values, but integrate.c
7164 doesn't currently generate these values for inlined instances of
7165 inline function parameters, so when we see such cases, we are
7166 just out-of-luck for the time being (until integrate.c
7169 /* Use DECL_RTL as the "location" unless we find something better. */
7170 rtl
= DECL_RTL (decl
);
7172 if (TREE_CODE (decl
) == PARM_DECL
)
7174 if (rtl
== NULL_RTX
|| is_pseudo_reg (rtl
))
7176 declared_type
= type_main_variant (TREE_TYPE (decl
));
7177 passed_type
= type_main_variant (DECL_ARG_TYPE (decl
));
7179 /* This decl represents a formal parameter which was optimized out.
7180 Note that DECL_INCOMING_RTL may be NULL in here, but we handle
7181 all* cases where (rtl == NULL_RTX) just below. */
7182 if (declared_type
== passed_type
)
7183 rtl
= DECL_INCOMING_RTL (decl
);
7184 else if (! BYTES_BIG_ENDIAN
7185 && TREE_CODE (declared_type
) == INTEGER_TYPE
7186 && TYPE_SIZE (declared_type
) <= TYPE_SIZE (passed_type
))
7187 rtl
= DECL_INCOMING_RTL (decl
);
7190 /* If the parm was passed in registers, but lives on the stack, then
7191 make a big endian correction if the mode of the type of the
7192 parameter is not the same as the mode of the rtl. */
7193 /* ??? This is the same series of checks that are made in dbxout.c before
7194 we reach the big endian correction code there. It isn't clear if all
7195 of these checks are necessary here, but keeping them all is the safe
7197 else if (GET_CODE (rtl
) == MEM
7198 && XEXP (rtl
, 0) != const0_rtx
7199 && ! CONSTANT_P (XEXP (rtl
, 0))
7200 /* Not passed in memory. */
7201 && GET_CODE (DECL_INCOMING_RTL (decl
)) != MEM
7202 /* Not passed by invisible reference. */
7203 && (GET_CODE (XEXP (rtl
, 0)) != REG
7204 || REGNO (XEXP (rtl
, 0)) == HARD_FRAME_POINTER_REGNUM
7205 || REGNO (XEXP (rtl
, 0)) == STACK_POINTER_REGNUM
7206 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
7207 || REGNO (XEXP (rtl
, 0)) == ARG_POINTER_REGNUM
7210 /* Big endian correction check. */
7212 && TYPE_MODE (TREE_TYPE (decl
)) != GET_MODE (rtl
)
7213 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl
)))
7216 int offset
= (UNITS_PER_WORD
7217 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl
))));
7218 rtl
= gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl
)),
7219 plus_constant (XEXP (rtl
, 0), offset
));
7223 if (rtl
== NULL_RTX
)
7226 rtl
= eliminate_regs (rtl
, 0, NULL_RTX
);
7227 #ifdef LEAF_REG_REMAP
7228 if (current_function_uses_only_leaf_regs
)
7229 leaf_renumber_regs_insn (rtl
);
7232 switch (GET_CODE (rtl
))
7235 /* The address of a variable that was optimized away; don't emit
7246 /* DECL_RTL could be (plus (reg ...) (const_int ...)) */
7247 add_const_value_attribute (die
, rtl
);
7254 add_AT_location_description (die
, DW_AT_location
, rtl
);
7262 /* Generate an DW_AT_name attribute given some string value to be included as
7263 the value of the attribute. */
7266 add_name_attribute (die
, name_string
)
7267 register dw_die_ref die
;
7268 register char *name_string
;
7270 if (name_string
!= NULL
&& *name_string
!= 0)
7271 add_AT_string (die
, DW_AT_name
, name_string
);
7274 /* Given a tree node describing an array bound (either lower or upper) output
7275 a representation for that bound. */
7278 add_bound_info (subrange_die
, bound_attr
, bound
)
7279 register dw_die_ref subrange_die
;
7280 register enum dwarf_attribute bound_attr
;
7281 register tree bound
;
7283 register unsigned bound_value
= 0;
7285 /* If this is an Ada unconstrained array type, then don't emit any debug
7286 info because the array bounds are unknown. They are parameterized when
7287 the type is instantiated. */
7288 if (contains_placeholder_p (bound
))
7291 switch (TREE_CODE (bound
))
7296 /* All fixed-bounds are represented by INTEGER_CST nodes. */
7298 bound_value
= TREE_INT_CST_LOW (bound
);
7299 if (bound_attr
== DW_AT_lower_bound
7300 && ((is_c_family () && bound_value
== 0)
7301 || (is_fortran () && bound_value
== 1)))
7302 /* use the default */;
7304 add_AT_unsigned (subrange_die
, bound_attr
, bound_value
);
7309 case NON_LVALUE_EXPR
:
7310 add_bound_info (subrange_die
, bound_attr
, TREE_OPERAND (bound
, 0));
7314 /* If optimization is turned on, the SAVE_EXPRs that describe how to
7315 access the upper bound values may be bogus. If they refer to a
7316 register, they may only describe how to get at these values at the
7317 points in the generated code right after they have just been
7318 computed. Worse yet, in the typical case, the upper bound values
7319 will not even *be* computed in the optimized code (though the
7320 number of elements will), so these SAVE_EXPRs are entirely
7321 bogus. In order to compensate for this fact, we check here to see
7322 if optimization is enabled, and if so, we don't add an attribute
7323 for the (unknown and unknowable) upper bound. This should not
7324 cause too much trouble for existing (stupid?) debuggers because
7325 they have to deal with empty upper bounds location descriptions
7326 anyway in order to be able to deal with incomplete array types.
7327 Of course an intelligent debugger (GDB?) should be able to
7328 comprehend that a missing upper bound specification in a array
7329 type used for a storage class `auto' local array variable
7330 indicates that the upper bound is both unknown (at compile- time)
7331 and unknowable (at run-time) due to optimization.
7333 We assume that a MEM rtx is safe because gcc wouldn't put the
7334 value there unless it was going to be used repeatedly in the
7335 function, i.e. for cleanups. */
7336 if (! optimize
|| GET_CODE (SAVE_EXPR_RTL (bound
)) == MEM
)
7338 register dw_die_ref ctx
= lookup_decl_die (current_function_decl
);
7339 register dw_die_ref decl_die
= new_die (DW_TAG_variable
, ctx
);
7340 register rtx loc
= SAVE_EXPR_RTL (bound
);
7342 /* If the RTL for the SAVE_EXPR is memory, handle the case where
7343 it references an outer function's frame. */
7345 if (GET_CODE (loc
) == MEM
)
7347 rtx new_addr
= fix_lexical_addr (XEXP (loc
, 0), bound
);
7349 if (XEXP (loc
, 0) != new_addr
)
7350 loc
= gen_rtx (MEM
, GET_MODE (loc
), new_addr
);
7353 add_AT_flag (decl_die
, DW_AT_artificial
, 1);
7354 add_type_attribute (decl_die
, TREE_TYPE (bound
), 1, 0, ctx
);
7355 add_AT_location_description (decl_die
, DW_AT_location
, loc
);
7356 add_AT_die_ref (subrange_die
, bound_attr
, decl_die
);
7359 /* Else leave out the attribute. */
7365 /* ??? These types of bounds can be created by the Ada front end,
7366 and it isn't clear how to emit debug info for them. */
7374 /* Note that the block of subscript information for an array type also
7375 includes information about the element type of type given array type. */
7378 add_subscript_info (type_die
, type
)
7379 register dw_die_ref type_die
;
7382 #ifndef MIPS_DEBUGGING_INFO
7383 register unsigned dimension_number
;
7385 register tree lower
, upper
;
7386 register dw_die_ref subrange_die
;
7388 /* The GNU compilers represent multidimensional array types as sequences of
7389 one dimensional array types whose element types are themselves array
7390 types. Here we squish that down, so that each multidimensional array
7391 type gets only one array_type DIE in the Dwarf debugging info. The draft
7392 Dwarf specification say that we are allowed to do this kind of
7393 compression in C (because there is no difference between an array or
7394 arrays and a multidimensional array in C) but for other source languages
7395 (e.g. Ada) we probably shouldn't do this. */
7397 /* ??? The SGI dwarf reader fails for multidimensional arrays with a
7398 const enum type. E.g. const enum machine_mode insn_operand_mode[2][10].
7399 We work around this by disabling this feature. See also
7400 gen_array_type_die. */
7401 #ifndef MIPS_DEBUGGING_INFO
7402 for (dimension_number
= 0;
7403 TREE_CODE (type
) == ARRAY_TYPE
;
7404 type
= TREE_TYPE (type
), dimension_number
++)
7407 register tree domain
= TYPE_DOMAIN (type
);
7409 /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
7410 and (in GNU C only) variable bounds. Handle all three forms
7412 subrange_die
= new_die (DW_TAG_subrange_type
, type_die
);
7415 /* We have an array type with specified bounds. */
7416 lower
= TYPE_MIN_VALUE (domain
);
7417 upper
= TYPE_MAX_VALUE (domain
);
7419 /* define the index type. */
7420 if (TREE_TYPE (domain
))
7422 /* ??? This is probably an Ada unnamed subrange type. Ignore the
7423 TREE_TYPE field. We can't emit debug info for this
7424 because it is an unnamed integral type. */
7425 if (TREE_CODE (domain
) == INTEGER_TYPE
7426 && TYPE_NAME (domain
) == NULL_TREE
7427 && TREE_CODE (TREE_TYPE (domain
)) == INTEGER_TYPE
7428 && TYPE_NAME (TREE_TYPE (domain
)) == NULL_TREE
)
7431 add_type_attribute (subrange_die
, TREE_TYPE (domain
), 0, 0,
7435 /* ??? If upper is NULL, the array has unspecified length,
7436 but it does have a lower bound. This happens with Fortran
7438 Since the debugger is definitely going to need to know N
7439 to produce useful results, go ahead and output the lower
7440 bound solo, and hope the debugger can cope. */
7442 add_bound_info (subrange_die
, DW_AT_lower_bound
, lower
);
7444 add_bound_info (subrange_die
, DW_AT_upper_bound
, upper
);
7447 /* We have an array type with an unspecified length. The DWARF-2
7448 spec does not say how to handle this; let's just leave out the
7453 #ifndef MIPS_DEBUGGING_INFO
7459 add_byte_size_attribute (die
, tree_node
)
7461 register tree tree_node
;
7463 register unsigned size
;
7465 switch (TREE_CODE (tree_node
))
7473 case QUAL_UNION_TYPE
:
7474 size
= int_size_in_bytes (tree_node
);
7477 /* For a data member of a struct or union, the DW_AT_byte_size is
7478 generally given as the number of bytes normally allocated for an
7479 object of the *declared* type of the member itself. This is true
7480 even for bit-fields. */
7481 size
= simple_type_size_in_bits (field_type (tree_node
)) / BITS_PER_UNIT
;
7487 /* Note that `size' might be -1 when we get to this point. If it is, that
7488 indicates that the byte size of the entity in question is variable. We
7489 have no good way of expressing this fact in Dwarf at the present time,
7490 so just let the -1 pass on through. */
7492 add_AT_unsigned (die
, DW_AT_byte_size
, size
);
7495 /* For a FIELD_DECL node which represents a bit-field, output an attribute
7496 which specifies the distance in bits from the highest order bit of the
7497 "containing object" for the bit-field to the highest order bit of the
7500 For any given bit-field, the "containing object" is a hypothetical
7501 object (of some integral or enum type) within which the given bit-field
7502 lives. The type of this hypothetical "containing object" is always the
7503 same as the declared type of the individual bit-field itself. The
7504 determination of the exact location of the "containing object" for a
7505 bit-field is rather complicated. It's handled by the
7506 `field_byte_offset' function (above).
7508 Note that it is the size (in bytes) of the hypothetical "containing object"
7509 which will be given in the DW_AT_byte_size attribute for this bit-field.
7510 (See `byte_size_attribute' above). */
7513 add_bit_offset_attribute (die
, decl
)
7514 register dw_die_ref die
;
7517 register unsigned object_offset_in_bytes
= field_byte_offset (decl
);
7518 register tree type
= DECL_BIT_FIELD_TYPE (decl
);
7519 register tree bitpos_tree
= DECL_FIELD_BITPOS (decl
);
7520 register unsigned bitpos_int
;
7521 register unsigned highest_order_object_bit_offset
;
7522 register unsigned highest_order_field_bit_offset
;
7523 register unsigned bit_offset
;
7525 /* Must be a field and a bit field. */
7527 || TREE_CODE (decl
) != FIELD_DECL
)
7530 /* We can't yet handle bit-fields whose offsets are variable, so if we
7531 encounter such things, just return without generating any attribute
7533 if (TREE_CODE (bitpos_tree
) != INTEGER_CST
)
7536 bitpos_int
= (unsigned) TREE_INT_CST_LOW (bitpos_tree
);
7538 /* Note that the bit offset is always the distance (in bits) from the
7539 highest-order bit of the "containing object" to the highest-order bit of
7540 the bit-field itself. Since the "high-order end" of any object or field
7541 is different on big-endian and little-endian machines, the computation
7542 below must take account of these differences. */
7543 highest_order_object_bit_offset
= object_offset_in_bytes
* BITS_PER_UNIT
;
7544 highest_order_field_bit_offset
= bitpos_int
;
7546 if (! BYTES_BIG_ENDIAN
)
7548 highest_order_field_bit_offset
7549 += (unsigned) TREE_INT_CST_LOW (DECL_SIZE (decl
));
7551 highest_order_object_bit_offset
+= simple_type_size_in_bits (type
);
7555 = (! BYTES_BIG_ENDIAN
7556 ? highest_order_object_bit_offset
- highest_order_field_bit_offset
7557 : highest_order_field_bit_offset
- highest_order_object_bit_offset
);
7559 add_AT_unsigned (die
, DW_AT_bit_offset
, bit_offset
);
7562 /* For a FIELD_DECL node which represents a bit field, output an attribute
7563 which specifies the length in bits of the given field. */
7566 add_bit_size_attribute (die
, decl
)
7567 register dw_die_ref die
;
7570 /* Must be a field and a bit field. */
7571 if (TREE_CODE (decl
) != FIELD_DECL
7572 || ! DECL_BIT_FIELD_TYPE (decl
))
7574 add_AT_unsigned (die
, DW_AT_bit_size
,
7575 (unsigned) TREE_INT_CST_LOW (DECL_SIZE (decl
)));
7578 /* If the compiled language is ANSI C, then add a 'prototyped'
7579 attribute, if arg types are given for the parameters of a function. */
7582 add_prototyped_attribute (die
, func_type
)
7583 register dw_die_ref die
;
7584 register tree func_type
;
7586 if (get_AT_unsigned (comp_unit_die
, DW_AT_language
) == DW_LANG_C89
7587 && TYPE_ARG_TYPES (func_type
) != NULL
)
7588 add_AT_flag (die
, DW_AT_prototyped
, 1);
7592 /* Add an 'abstract_origin' attribute below a given DIE. The DIE is found
7593 by looking in either the type declaration or object declaration
7597 add_abstract_origin_attribute (die
, origin
)
7598 register dw_die_ref die
;
7599 register tree origin
;
7601 dw_die_ref origin_die
= NULL
;
7602 if (TREE_CODE_CLASS (TREE_CODE (origin
)) == 'd')
7603 origin_die
= lookup_decl_die (origin
);
7604 else if (TREE_CODE_CLASS (TREE_CODE (origin
)) == 't')
7605 origin_die
= lookup_type_die (origin
);
7607 add_AT_die_ref (die
, DW_AT_abstract_origin
, origin_die
);
7610 /* We do not currently support the pure_virtual attribute. */
7613 add_pure_or_virtual_attribute (die
, func_decl
)
7614 register dw_die_ref die
;
7615 register tree func_decl
;
7617 if (DECL_VINDEX (func_decl
))
7619 add_AT_unsigned (die
, DW_AT_virtuality
, DW_VIRTUALITY_virtual
);
7620 add_AT_loc (die
, DW_AT_vtable_elem_location
,
7621 new_loc_descr (DW_OP_constu
,
7622 TREE_INT_CST_LOW (DECL_VINDEX (func_decl
)),
7625 /* GNU extension: Record what type this method came from originally. */
7626 if (debug_info_level
> DINFO_LEVEL_TERSE
)
7627 add_AT_die_ref (die
, DW_AT_containing_type
,
7628 lookup_type_die (DECL_CONTEXT (func_decl
)));
7632 /* Add source coordinate attributes for the given decl. */
7635 add_src_coords_attributes (die
, decl
)
7636 register dw_die_ref die
;
7639 register unsigned file_index
= lookup_filename (DECL_SOURCE_FILE (decl
));
7641 add_AT_unsigned (die
, DW_AT_decl_file
, file_index
);
7642 add_AT_unsigned (die
, DW_AT_decl_line
, DECL_SOURCE_LINE (decl
));
7645 /* Add an DW_AT_name attribute and source coordinate attribute for the
7646 given decl, but only if it actually has a name. */
7649 add_name_and_src_coords_attributes (die
, decl
)
7650 register dw_die_ref die
;
7653 register tree decl_name
;
7655 decl_name
= DECL_NAME (decl
);
7656 if (decl_name
!= NULL
&& IDENTIFIER_POINTER (decl_name
) != NULL
)
7658 add_name_attribute (die
, dwarf2_name (decl
, 0));
7659 add_src_coords_attributes (die
, decl
);
7660 if ((TREE_CODE (decl
) == FUNCTION_DECL
|| TREE_CODE (decl
) == VAR_DECL
)
7661 && DECL_ASSEMBLER_NAME (decl
) != DECL_NAME (decl
))
7662 add_AT_string (die
, DW_AT_MIPS_linkage_name
,
7663 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)));
7667 /* Push a new declaration scope. */
7670 push_decl_scope (scope
)
7673 tree containing_scope
;
7676 /* Make room in the decl_scope_table, if necessary. */
7677 if (decl_scope_table_allocated
== decl_scope_depth
)
7679 decl_scope_table_allocated
+= DECL_SCOPE_TABLE_INCREMENT
;
7681 = (decl_scope_node
*) xrealloc (decl_scope_table
,
7682 (decl_scope_table_allocated
7683 * sizeof (decl_scope_node
)));
7686 decl_scope_table
[decl_scope_depth
].scope
= scope
;
7688 /* Sometimes, while recursively emitting subtypes within a class type,
7689 we end up recuring on a subtype at a higher level then the current
7690 subtype. In such a case, we need to search the decl_scope_table to
7691 find the parent of this subtype. */
7693 if (AGGREGATE_TYPE_P (scope
))
7694 containing_scope
= TYPE_CONTEXT (scope
);
7696 containing_scope
= NULL_TREE
;
7698 /* The normal case. */
7699 if (decl_scope_depth
== 0
7700 || containing_scope
== NULL_TREE
7701 /* Ignore namespaces for the moment. */
7702 || TREE_CODE (containing_scope
) == NAMESPACE_DECL
7703 || containing_scope
== decl_scope_table
[decl_scope_depth
- 1].scope
)
7704 decl_scope_table
[decl_scope_depth
].previous
= decl_scope_depth
- 1;
7707 /* We need to search for the containing_scope. */
7708 for (i
= 0; i
< decl_scope_depth
; i
++)
7709 if (decl_scope_table
[i
].scope
== containing_scope
)
7712 if (i
== decl_scope_depth
)
7715 decl_scope_table
[decl_scope_depth
].previous
= i
;
7721 /* Return the DIE for the scope that immediately contains this declaration. */
7724 scope_die_for (t
, context_die
)
7726 register dw_die_ref context_die
;
7728 register dw_die_ref scope_die
= NULL
;
7729 register tree containing_scope
;
7732 /* Walk back up the declaration tree looking for a place to define
7734 if (TREE_CODE_CLASS (TREE_CODE (t
)) == 't')
7735 containing_scope
= TYPE_CONTEXT (t
);
7736 else if (TREE_CODE (t
) == FUNCTION_DECL
&& DECL_VINDEX (t
))
7737 containing_scope
= decl_class_context (t
);
7739 containing_scope
= DECL_CONTEXT (t
);
7741 /* Ignore namespaces for the moment. */
7742 if (containing_scope
&& TREE_CODE (containing_scope
) == NAMESPACE_DECL
)
7743 containing_scope
= NULL_TREE
;
7745 /* Ignore function type "scopes" from the C frontend. They mean that
7746 a tagged type is local to a parmlist of a function declarator, but
7747 that isn't useful to DWARF. */
7748 if (containing_scope
&& TREE_CODE (containing_scope
) == FUNCTION_TYPE
)
7749 containing_scope
= NULL_TREE
;
7751 /* Function-local tags and functions get stuck in limbo until they are
7752 fixed up by decls_for_scope. */
7753 if (context_die
== NULL
&& containing_scope
!= NULL_TREE
7754 && (TREE_CODE (t
) == FUNCTION_DECL
|| is_tagged_type (t
)))
7757 if (containing_scope
== NULL_TREE
)
7758 scope_die
= comp_unit_die
;
7761 for (i
= decl_scope_depth
- 1, scope_die
= context_die
;
7762 i
>= 0 && decl_scope_table
[i
].scope
!= containing_scope
;
7763 (scope_die
= scope_die
->die_parent
,
7764 i
= decl_scope_table
[i
].previous
))
7767 /* ??? Integrate_decl_tree does not handle BLOCK_TYPE_TAGS, nor
7768 does it try to handle types defined by TYPE_DECLs. Such types
7769 thus have an incorrect TYPE_CONTEXT, which points to the block
7770 they were originally defined in, instead of the current block
7771 created by function inlining. We try to detect that here and
7774 if (i
< 0 && scope_die
== comp_unit_die
7775 && TREE_CODE (containing_scope
) == BLOCK
7776 && is_tagged_type (t
)
7777 && (block_ultimate_origin (decl_scope_table
[decl_scope_depth
- 1].scope
)
7778 == containing_scope
))
7780 scope_die
= context_die
;
7781 /* Since the checks below are no longer applicable. */
7787 if (TREE_CODE_CLASS (TREE_CODE (containing_scope
)) != 't')
7789 if (debug_info_level
> DINFO_LEVEL_TERSE
7790 && !TREE_ASM_WRITTEN (containing_scope
))
7793 /* If none of the current dies are suitable, we get file scope. */
7794 scope_die
= comp_unit_die
;
7801 /* Pop a declaration scope. */
7805 if (decl_scope_depth
<= 0)
7810 /* Many forms of DIEs require a "type description" attribute. This
7811 routine locates the proper "type descriptor" die for the type given
7812 by 'type', and adds an DW_AT_type attribute below the given die. */
7815 add_type_attribute (object_die
, type
, decl_const
, decl_volatile
, context_die
)
7816 register dw_die_ref object_die
;
7818 register int decl_const
;
7819 register int decl_volatile
;
7820 register dw_die_ref context_die
;
7822 register enum tree_code code
= TREE_CODE (type
);
7823 register dw_die_ref type_die
= NULL
;
7825 /* ??? If this type is an unnamed subrange type of an integral or
7826 floating-point type, use the inner type. This is because we have no
7827 support for unnamed types in base_type_die. This can happen if this is
7828 an Ada subrange type. Correct solution is emit a subrange type die. */
7829 if ((code
== INTEGER_TYPE
|| code
== REAL_TYPE
)
7830 && TREE_TYPE (type
) != 0 && TYPE_NAME (type
) == 0)
7831 type
= TREE_TYPE (type
), code
= TREE_CODE (type
);
7833 if (code
== ERROR_MARK
)
7836 /* Handle a special case. For functions whose return type is void, we
7837 generate *no* type attribute. (Note that no object may have type
7838 `void', so this only applies to function return types). */
7839 if (code
== VOID_TYPE
)
7842 type_die
= modified_type_die (type
,
7843 decl_const
|| TYPE_READONLY (type
),
7844 decl_volatile
|| TYPE_VOLATILE (type
),
7846 if (type_die
!= NULL
)
7847 add_AT_die_ref (object_die
, DW_AT_type
, type_die
);
7850 /* Given a tree pointer to a struct, class, union, or enum type node, return
7851 a pointer to the (string) tag name for the given type, or zero if the type
7852 was declared without a tag. */
7858 register char *name
= 0;
7860 if (TYPE_NAME (type
) != 0)
7862 register tree t
= 0;
7864 /* Find the IDENTIFIER_NODE for the type name. */
7865 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
7866 t
= TYPE_NAME (type
);
7868 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
7869 a TYPE_DECL node, regardless of whether or not a `typedef' was
7871 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
7872 && ! DECL_IGNORED_P (TYPE_NAME (type
)))
7873 t
= DECL_NAME (TYPE_NAME (type
));
7875 /* Now get the name as a string, or invent one. */
7877 name
= IDENTIFIER_POINTER (t
);
7880 return (name
== 0 || *name
== '\0') ? 0 : name
;
7883 /* Return the type associated with a data member, make a special check
7884 for bit field types. */
7887 member_declared_type (member
)
7888 register tree member
;
7890 return (DECL_BIT_FIELD_TYPE (member
)
7891 ? DECL_BIT_FIELD_TYPE (member
)
7892 : TREE_TYPE (member
));
7895 /* Get the decl's label, as described by its RTL. This may be different
7896 from the DECL_NAME name used in the source file. */
7900 decl_start_label (decl
)
7905 x
= DECL_RTL (decl
);
7906 if (GET_CODE (x
) != MEM
)
7910 if (GET_CODE (x
) != SYMBOL_REF
)
7913 fnname
= XSTR (x
, 0);
7918 /* These routines generate the internal representation of the DIE's for
7919 the compilation unit. Debugging information is collected by walking
7920 the declaration trees passed in from dwarf2out_decl(). */
7923 gen_array_type_die (type
, context_die
)
7925 register dw_die_ref context_die
;
7927 register dw_die_ref scope_die
= scope_die_for (type
, context_die
);
7928 register dw_die_ref array_die
;
7929 register tree element_type
;
7931 /* ??? The SGI dwarf reader fails for array of array of enum types unless
7932 the inner array type comes before the outer array type. Thus we must
7933 call gen_type_die before we call new_die. See below also. */
7934 #ifdef MIPS_DEBUGGING_INFO
7935 gen_type_die (TREE_TYPE (type
), context_die
);
7938 array_die
= new_die (DW_TAG_array_type
, scope_die
);
7941 /* We default the array ordering. SDB will probably do
7942 the right things even if DW_AT_ordering is not present. It's not even
7943 an issue until we start to get into multidimensional arrays anyway. If
7944 SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
7945 then we'll have to put the DW_AT_ordering attribute back in. (But if
7946 and when we find out that we need to put these in, we will only do so
7947 for multidimensional arrays. */
7948 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_row_major
);
7951 #ifdef MIPS_DEBUGGING_INFO
7952 /* The SGI compilers handle arrays of unknown bound by setting
7953 AT_declaration and not emitting any subrange DIEs. */
7954 if (! TYPE_DOMAIN (type
))
7955 add_AT_unsigned (array_die
, DW_AT_declaration
, 1);
7958 add_subscript_info (array_die
, type
);
7960 equate_type_number_to_die (type
, array_die
);
7962 /* Add representation of the type of the elements of this array type. */
7963 element_type
= TREE_TYPE (type
);
7965 /* ??? The SGI dwarf reader fails for multidimensional arrays with a
7966 const enum type. E.g. const enum machine_mode insn_operand_mode[2][10].
7967 We work around this by disabling this feature. See also
7968 add_subscript_info. */
7969 #ifndef MIPS_DEBUGGING_INFO
7970 while (TREE_CODE (element_type
) == ARRAY_TYPE
)
7971 element_type
= TREE_TYPE (element_type
);
7973 gen_type_die (element_type
, context_die
);
7976 add_type_attribute (array_die
, element_type
, 0, 0, context_die
);
7980 gen_set_type_die (type
, context_die
)
7982 register dw_die_ref context_die
;
7984 register dw_die_ref type_die
7985 = new_die (DW_TAG_set_type
, scope_die_for (type
, context_die
));
7987 equate_type_number_to_die (type
, type_die
);
7988 add_type_attribute (type_die
, TREE_TYPE (type
), 0, 0, context_die
);
7993 gen_entry_point_die (decl
, context_die
)
7995 register dw_die_ref context_die
;
7997 register tree origin
= decl_ultimate_origin (decl
);
7998 register dw_die_ref decl_die
= new_die (DW_TAG_entry_point
, context_die
);
8000 add_abstract_origin_attribute (decl_die
, origin
);
8003 add_name_and_src_coords_attributes (decl_die
, decl
);
8004 add_type_attribute (decl_die
, TREE_TYPE (TREE_TYPE (decl
)),
8008 if (DECL_ABSTRACT (decl
))
8009 equate_decl_number_to_die (decl
, decl_die
);
8011 add_AT_lbl_id (decl_die
, DW_AT_low_pc
, decl_start_label (decl
));
8015 /* Remember a type in the pending_types_list. */
8021 if (pending_types
== pending_types_allocated
)
8023 pending_types_allocated
+= PENDING_TYPES_INCREMENT
;
8025 = (tree
*) xrealloc (pending_types_list
,
8026 sizeof (tree
) * pending_types_allocated
);
8029 pending_types_list
[pending_types
++] = type
;
8032 /* Output any pending types (from the pending_types list) which we can output
8033 now (taking into account the scope that we are working on now).
8035 For each type output, remove the given type from the pending_types_list
8036 *before* we try to output it. */
8039 output_pending_types_for_scope (context_die
)
8040 register dw_die_ref context_die
;
8044 while (pending_types
)
8047 type
= pending_types_list
[pending_types
];
8048 gen_type_die (type
, context_die
);
8049 if (!TREE_ASM_WRITTEN (type
))
8054 /* Remember a type in the incomplete_types_list. */
8057 add_incomplete_type (type
)
8060 if (incomplete_types
== incomplete_types_allocated
)
8062 incomplete_types_allocated
+= INCOMPLETE_TYPES_INCREMENT
;
8063 incomplete_types_list
8064 = (tree
*) xrealloc (incomplete_types_list
,
8065 sizeof (tree
) * incomplete_types_allocated
);
8068 incomplete_types_list
[incomplete_types
++] = type
;
8071 /* Walk through the list of incomplete types again, trying once more to
8072 emit full debugging info for them. */
8075 retry_incomplete_types ()
8079 while (incomplete_types
)
8082 type
= incomplete_types_list
[incomplete_types
];
8083 gen_type_die (type
, comp_unit_die
);
8087 /* Generate a DIE to represent an inlined instance of an enumeration type. */
8090 gen_inlined_enumeration_type_die (type
, context_die
)
8092 register dw_die_ref context_die
;
8094 register dw_die_ref type_die
= new_die (DW_TAG_enumeration_type
,
8095 scope_die_for (type
, context_die
));
8097 if (!TREE_ASM_WRITTEN (type
))
8099 add_abstract_origin_attribute (type_die
, type
);
8102 /* Generate a DIE to represent an inlined instance of a structure type. */
8105 gen_inlined_structure_type_die (type
, context_die
)
8107 register dw_die_ref context_die
;
8109 register dw_die_ref type_die
= new_die (DW_TAG_structure_type
,
8110 scope_die_for (type
, context_die
));
8112 if (!TREE_ASM_WRITTEN (type
))
8114 add_abstract_origin_attribute (type_die
, type
);
8117 /* Generate a DIE to represent an inlined instance of a union type. */
8120 gen_inlined_union_type_die (type
, context_die
)
8122 register dw_die_ref context_die
;
8124 register dw_die_ref type_die
= new_die (DW_TAG_union_type
,
8125 scope_die_for (type
, context_die
));
8127 if (!TREE_ASM_WRITTEN (type
))
8129 add_abstract_origin_attribute (type_die
, type
);
8132 /* Generate a DIE to represent an enumeration type. Note that these DIEs
8133 include all of the information about the enumeration values also. Each
8134 enumerated type name/value is listed as a child of the enumerated type
8138 gen_enumeration_type_die (type
, context_die
)
8140 register dw_die_ref context_die
;
8142 register dw_die_ref type_die
= lookup_type_die (type
);
8144 if (type_die
== NULL
)
8146 type_die
= new_die (DW_TAG_enumeration_type
,
8147 scope_die_for (type
, context_die
));
8148 equate_type_number_to_die (type
, type_die
);
8149 add_name_attribute (type_die
, type_tag (type
));
8151 else if (! TYPE_SIZE (type
))
8154 remove_AT (type_die
, DW_AT_declaration
);
8156 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the
8157 given enum type is incomplete, do not generate the DW_AT_byte_size
8158 attribute or the DW_AT_element_list attribute. */
8159 if (TYPE_SIZE (type
))
8163 TREE_ASM_WRITTEN (type
) = 1;
8164 add_byte_size_attribute (type_die
, type
);
8165 if (TYPE_STUB_DECL (type
) != NULL_TREE
)
8166 add_src_coords_attributes (type_die
, TYPE_STUB_DECL (type
));
8168 /* If the first reference to this type was as the return type of an
8169 inline function, then it may not have a parent. Fix this now. */
8170 if (type_die
->die_parent
== NULL
)
8171 add_child_die (scope_die_for (type
, context_die
), type_die
);
8173 for (link
= TYPE_FIELDS (type
);
8174 link
!= NULL
; link
= TREE_CHAIN (link
))
8176 register dw_die_ref enum_die
= new_die (DW_TAG_enumerator
, type_die
);
8178 add_name_attribute (enum_die
,
8179 IDENTIFIER_POINTER (TREE_PURPOSE (link
)));
8180 add_AT_unsigned (enum_die
, DW_AT_const_value
,
8181 (unsigned) TREE_INT_CST_LOW (TREE_VALUE (link
)));
8185 add_AT_flag (type_die
, DW_AT_declaration
, 1);
8189 /* Generate a DIE to represent either a real live formal parameter decl or to
8190 represent just the type of some formal parameter position in some function
8193 Note that this routine is a bit unusual because its argument may be a
8194 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
8195 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
8196 node. If it's the former then this function is being called to output a
8197 DIE to represent a formal parameter object (or some inlining thereof). If
8198 it's the latter, then this function is only being called to output a
8199 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
8200 argument type of some subprogram type. */
8203 gen_formal_parameter_die (node
, context_die
)
8205 register dw_die_ref context_die
;
8207 register dw_die_ref parm_die
8208 = new_die (DW_TAG_formal_parameter
, context_die
);
8209 register tree origin
;
8211 switch (TREE_CODE_CLASS (TREE_CODE (node
)))
8214 origin
= decl_ultimate_origin (node
);
8216 add_abstract_origin_attribute (parm_die
, origin
);
8219 add_name_and_src_coords_attributes (parm_die
, node
);
8220 add_type_attribute (parm_die
, TREE_TYPE (node
),
8221 TREE_READONLY (node
),
8222 TREE_THIS_VOLATILE (node
),
8224 if (DECL_ARTIFICIAL (node
))
8225 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
8228 equate_decl_number_to_die (node
, parm_die
);
8229 if (! DECL_ABSTRACT (node
))
8230 add_location_or_const_value_attribute (parm_die
, node
);
8235 /* We were called with some kind of a ..._TYPE node. */
8236 add_type_attribute (parm_die
, node
, 0, 0, context_die
);
8246 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
8247 at the end of an (ANSI prototyped) formal parameters list. */
8250 gen_unspecified_parameters_die (decl_or_type
, context_die
)
8251 register tree decl_or_type ATTRIBUTE_UNUSED
;
8252 register dw_die_ref context_die
;
8254 new_die (DW_TAG_unspecified_parameters
, context_die
);
8257 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
8258 DW_TAG_unspecified_parameters DIE) to represent the types of the formal
8259 parameters as specified in some function type specification (except for
8260 those which appear as part of a function *definition*).
8262 Note we must be careful here to output all of the parameter DIEs before*
8263 we output any DIEs needed to represent the types of the formal parameters.
8264 This keeps svr4 SDB happy because it (incorrectly) thinks that the first
8265 non-parameter DIE it sees ends the formal parameter list. */
8268 gen_formal_types_die (function_or_method_type
, context_die
)
8269 register tree function_or_method_type
;
8270 register dw_die_ref context_die
;
8273 register tree formal_type
= NULL
;
8274 register tree first_parm_type
= TYPE_ARG_TYPES (function_or_method_type
);
8277 /* In the case where we are generating a formal types list for a C++
8278 non-static member function type, skip over the first thing on the
8279 TYPE_ARG_TYPES list because it only represents the type of the hidden
8280 `this pointer'. The debugger should be able to figure out (without
8281 being explicitly told) that this non-static member function type takes a
8282 `this pointer' and should be able to figure what the type of that hidden
8283 parameter is from the DW_AT_member attribute of the parent
8284 DW_TAG_subroutine_type DIE. */
8285 if (TREE_CODE (function_or_method_type
) == METHOD_TYPE
)
8286 first_parm_type
= TREE_CHAIN (first_parm_type
);
8289 /* Make our first pass over the list of formal parameter types and output a
8290 DW_TAG_formal_parameter DIE for each one. */
8291 for (link
= first_parm_type
; link
; link
= TREE_CHAIN (link
))
8293 register dw_die_ref parm_die
;
8295 formal_type
= TREE_VALUE (link
);
8296 if (formal_type
== void_type_node
)
8299 /* Output a (nameless) DIE to represent the formal parameter itself. */
8300 parm_die
= gen_formal_parameter_die (formal_type
, context_die
);
8301 if (TREE_CODE (function_or_method_type
) == METHOD_TYPE
8302 && link
== first_parm_type
)
8303 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
8306 /* If this function type has an ellipsis, add a
8307 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */
8308 if (formal_type
!= void_type_node
)
8309 gen_unspecified_parameters_die (function_or_method_type
, context_die
);
8311 /* Make our second (and final) pass over the list of formal parameter types
8312 and output DIEs to represent those types (as necessary). */
8313 for (link
= TYPE_ARG_TYPES (function_or_method_type
);
8315 link
= TREE_CHAIN (link
))
8317 formal_type
= TREE_VALUE (link
);
8318 if (formal_type
== void_type_node
)
8321 gen_type_die (formal_type
, context_die
);
8325 /* Generate a DIE to represent a declared function (either file-scope or
8329 gen_subprogram_die (decl
, context_die
)
8331 register dw_die_ref context_die
;
8333 char label_id
[MAX_ARTIFICIAL_LABEL_BYTES
];
8334 register tree origin
= decl_ultimate_origin (decl
);
8335 register dw_die_ref subr_die
;
8336 register rtx fp_reg
;
8337 register tree fn_arg_types
;
8338 register tree outer_scope
;
8339 register dw_die_ref old_die
= lookup_decl_die (decl
);
8340 register int declaration
8341 = (current_function_decl
!= decl
8343 && (context_die
->die_tag
== DW_TAG_structure_type
8344 || context_die
->die_tag
== DW_TAG_union_type
)));
8348 subr_die
= new_die (DW_TAG_subprogram
, context_die
);
8349 add_abstract_origin_attribute (subr_die
, origin
);
8351 else if (old_die
&& DECL_ABSTRACT (decl
)
8352 && get_AT_unsigned (old_die
, DW_AT_inline
))
8354 /* This must be a redefinition of an extern inline function.
8355 We can just reuse the old die here. */
8358 /* Clear out the inlined attribute and parm types. */
8359 remove_AT (subr_die
, DW_AT_inline
);
8360 remove_children (subr_die
);
8364 register unsigned file_index
8365 = lookup_filename (DECL_SOURCE_FILE (decl
));
8367 if (get_AT_flag (old_die
, DW_AT_declaration
) != 1)
8369 /* ??? This can happen if there is a bug in the program, for
8370 instance, if it has duplicate function definitions. Ideally,
8371 we should detect this case and ignore it. For now, if we have
8372 already reported an error, any error at all, then assume that
8373 we got here because of a input error, not a dwarf2 bug. */
8374 extern int errorcount
;
8380 /* If the definition comes from the same place as the declaration,
8381 maybe use the old DIE. We always want the DIE for this function
8382 that has the *_pc attributes to be under comp_unit_die so the
8383 debugger can find it. For inlines, that is the concrete instance,
8384 so we can use the old DIE here. For non-inline methods, we want a
8385 specification DIE at toplevel, so we need a new DIE. For local
8386 class methods, this does not apply. */
8387 if ((DECL_ABSTRACT (decl
) || old_die
->die_parent
== comp_unit_die
8388 || context_die
== NULL
)
8389 && get_AT_unsigned (old_die
, DW_AT_decl_file
) == file_index
8390 && (get_AT_unsigned (old_die
, DW_AT_decl_line
)
8391 == (unsigned)DECL_SOURCE_LINE (decl
)))
8395 /* Clear out the declaration attribute and the parm types. */
8396 remove_AT (subr_die
, DW_AT_declaration
);
8397 remove_children (subr_die
);
8401 subr_die
= new_die (DW_TAG_subprogram
, context_die
);
8402 add_AT_die_ref (subr_die
, DW_AT_specification
, old_die
);
8403 if (get_AT_unsigned (old_die
, DW_AT_decl_file
) != file_index
)
8404 add_AT_unsigned (subr_die
, DW_AT_decl_file
, file_index
);
8405 if (get_AT_unsigned (old_die
, DW_AT_decl_line
)
8406 != (unsigned)DECL_SOURCE_LINE (decl
))
8408 (subr_die
, DW_AT_decl_line
, DECL_SOURCE_LINE (decl
));
8413 register dw_die_ref scope_die
;
8415 if (DECL_CONTEXT (decl
))
8416 scope_die
= scope_die_for (decl
, context_die
);
8418 /* Don't put block extern declarations under comp_unit_die. */
8419 scope_die
= context_die
;
8421 subr_die
= new_die (DW_TAG_subprogram
, scope_die
);
8423 if (TREE_PUBLIC (decl
))
8424 add_AT_flag (subr_die
, DW_AT_external
, 1);
8426 add_name_and_src_coords_attributes (subr_die
, decl
);
8427 if (debug_info_level
> DINFO_LEVEL_TERSE
)
8429 register tree type
= TREE_TYPE (decl
);
8431 add_prototyped_attribute (subr_die
, type
);
8432 add_type_attribute (subr_die
, TREE_TYPE (type
), 0, 0, context_die
);
8435 add_pure_or_virtual_attribute (subr_die
, decl
);
8436 if (DECL_ARTIFICIAL (decl
))
8437 add_AT_flag (subr_die
, DW_AT_artificial
, 1);
8438 if (TREE_PROTECTED (decl
))
8439 add_AT_unsigned (subr_die
, DW_AT_accessibility
, DW_ACCESS_protected
);
8440 else if (TREE_PRIVATE (decl
))
8441 add_AT_unsigned (subr_die
, DW_AT_accessibility
, DW_ACCESS_private
);
8446 add_AT_flag (subr_die
, DW_AT_declaration
, 1);
8448 /* The first time we see a member function, it is in the context of
8449 the class to which it belongs. We make sure of this by emitting
8450 the class first. The next time is the definition, which is
8451 handled above. The two may come from the same source text. */
8452 if (DECL_CONTEXT (decl
))
8453 equate_decl_number_to_die (decl
, subr_die
);
8455 else if (DECL_ABSTRACT (decl
))
8457 /* ??? Checking DECL_DEFER_OUTPUT is correct for static inline functions,
8458 but not for extern inline functions. We can't get this completely
8459 correct because information about whether the function was declared
8460 inline is not saved anywhere. */
8461 if (DECL_DEFER_OUTPUT (decl
))
8463 if (DECL_INLINE (decl
))
8464 add_AT_unsigned (subr_die
, DW_AT_inline
, DW_INL_declared_inlined
);
8466 add_AT_unsigned (subr_die
, DW_AT_inline
,
8467 DW_INL_declared_not_inlined
);
8469 else if (DECL_INLINE (decl
))
8470 add_AT_unsigned (subr_die
, DW_AT_inline
, DW_INL_inlined
);
8474 equate_decl_number_to_die (decl
, subr_die
);
8476 else if (!DECL_EXTERNAL (decl
))
8478 if (origin
== NULL_TREE
)
8479 equate_decl_number_to_die (decl
, subr_die
);
8481 ASM_GENERATE_INTERNAL_LABEL (label_id
, FUNC_BEGIN_LABEL
,
8482 current_funcdef_number
);
8483 add_AT_lbl_id (subr_die
, DW_AT_low_pc
, label_id
);
8484 ASM_GENERATE_INTERNAL_LABEL (label_id
, FUNC_END_LABEL
,
8485 current_funcdef_number
);
8486 add_AT_lbl_id (subr_die
, DW_AT_high_pc
, label_id
);
8488 add_pubname (decl
, subr_die
);
8489 add_arange (decl
, subr_die
);
8491 #ifdef MIPS_DEBUGGING_INFO
8492 /* Add a reference to the FDE for this routine. */
8493 add_AT_fde_ref (subr_die
, DW_AT_MIPS_fde
, current_funcdef_fde
);
8496 /* Define the "frame base" location for this routine. We use the
8497 frame pointer or stack pointer registers, since the RTL for local
8498 variables is relative to one of them. */
8500 = frame_pointer_needed
? hard_frame_pointer_rtx
: stack_pointer_rtx
;
8501 add_AT_loc (subr_die
, DW_AT_frame_base
, reg_loc_descriptor (fp_reg
));
8504 /* ??? This fails for nested inline functions, because context_display
8505 is not part of the state saved/restored for inline functions. */
8506 if (current_function_needs_context
)
8507 add_AT_location_description (subr_die
, DW_AT_static_link
,
8508 lookup_static_chain (decl
));
8512 /* Now output descriptions of the arguments for this function. This gets
8513 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
8514 for a FUNCTION_DECL doesn't indicate cases where there was a trailing
8515 `...' at the end of the formal parameter list. In order to find out if
8516 there was a trailing ellipsis or not, we must instead look at the type
8517 associated with the FUNCTION_DECL. This will be a node of type
8518 FUNCTION_TYPE. If the chain of type nodes hanging off of this
8519 FUNCTION_TYPE node ends with a void_type_node then there should *not* be
8520 an ellipsis at the end. */
8521 push_decl_scope (decl
);
8523 /* In the case where we are describing a mere function declaration, all we
8524 need to do here (and all we *can* do here) is to describe the *types* of
8525 its formal parameters. */
8526 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
8528 else if (declaration
)
8529 gen_formal_types_die (TREE_TYPE (decl
), subr_die
);
8532 /* Generate DIEs to represent all known formal parameters */
8533 register tree arg_decls
= DECL_ARGUMENTS (decl
);
8536 /* When generating DIEs, generate the unspecified_parameters DIE
8537 instead if we come across the arg "__builtin_va_alist" */
8538 for (parm
= arg_decls
; parm
; parm
= TREE_CHAIN (parm
))
8539 if (TREE_CODE (parm
) == PARM_DECL
)
8541 if (DECL_NAME (parm
)
8542 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (parm
)),
8543 "__builtin_va_alist"))
8544 gen_unspecified_parameters_die (parm
, subr_die
);
8546 gen_decl_die (parm
, subr_die
);
8549 /* Decide whether we need a unspecified_parameters DIE at the end.
8550 There are 2 more cases to do this for: 1) the ansi ... declaration -
8551 this is detectable when the end of the arg list is not a
8552 void_type_node 2) an unprototyped function declaration (not a
8553 definition). This just means that we have no info about the
8554 parameters at all. */
8555 fn_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
8556 if (fn_arg_types
!= NULL
)
8558 /* this is the prototyped case, check for ... */
8559 if (TREE_VALUE (tree_last (fn_arg_types
)) != void_type_node
)
8560 gen_unspecified_parameters_die (decl
, subr_die
);
8562 else if (DECL_INITIAL (decl
) == NULL_TREE
)
8563 gen_unspecified_parameters_die (decl
, subr_die
);
8566 /* Output Dwarf info for all of the stuff within the body of the function
8567 (if it has one - it may be just a declaration). */
8568 outer_scope
= DECL_INITIAL (decl
);
8570 /* Note that here, `outer_scope' is a pointer to the outermost BLOCK
8571 node created to represent a function. This outermost BLOCK actually
8572 represents the outermost binding contour for the function, i.e. the
8573 contour in which the function's formal parameters and labels get
8574 declared. Curiously, it appears that the front end doesn't actually
8575 put the PARM_DECL nodes for the current function onto the BLOCK_VARS
8576 list for this outer scope. (They are strung off of the DECL_ARGUMENTS
8577 list for the function instead.) The BLOCK_VARS list for the
8578 `outer_scope' does provide us with a list of the LABEL_DECL nodes for
8579 the function however, and we output DWARF info for those in
8580 decls_for_scope. Just within the `outer_scope' there will be a BLOCK
8581 node representing the function's outermost pair of curly braces, and
8582 any blocks used for the base and member initializers of a C++
8583 constructor function. */
8584 if (! declaration
&& TREE_CODE (outer_scope
) != ERROR_MARK
)
8586 current_function_has_inlines
= 0;
8587 decls_for_scope (outer_scope
, subr_die
, 0);
8589 #if 0 && defined (MIPS_DEBUGGING_INFO)
8590 if (current_function_has_inlines
)
8592 add_AT_flag (subr_die
, DW_AT_MIPS_has_inlines
, 1);
8593 if (! comp_unit_has_inlines
)
8595 add_AT_flag (comp_unit_die
, DW_AT_MIPS_has_inlines
, 1);
8596 comp_unit_has_inlines
= 1;
8605 /* Generate a DIE to represent a declared data object. */
8608 gen_variable_die (decl
, context_die
)
8610 register dw_die_ref context_die
;
8612 register tree origin
= decl_ultimate_origin (decl
);
8613 register dw_die_ref var_die
= new_die (DW_TAG_variable
, context_die
);
8615 dw_die_ref old_die
= lookup_decl_die (decl
);
8617 = (DECL_EXTERNAL (decl
)
8618 || current_function_decl
!= decl_function_context (decl
)
8619 || context_die
->die_tag
== DW_TAG_structure_type
8620 || context_die
->die_tag
== DW_TAG_union_type
);
8623 add_abstract_origin_attribute (var_die
, origin
);
8624 /* Loop unrolling can create multiple blocks that refer to the same
8625 static variable, so we must test for the DW_AT_declaration flag. */
8626 /* ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
8627 copy decls and set the DECL_ABSTRACT flag on them instead of
8629 else if (old_die
&& TREE_STATIC (decl
)
8630 && get_AT_flag (old_die
, DW_AT_declaration
) == 1)
8632 /* ??? This is an instantiation of a C++ class level static. */
8633 add_AT_die_ref (var_die
, DW_AT_specification
, old_die
);
8634 if (DECL_NAME (decl
))
8636 register unsigned file_index
8637 = lookup_filename (DECL_SOURCE_FILE (decl
));
8639 if (get_AT_unsigned (old_die
, DW_AT_decl_file
) != file_index
)
8640 add_AT_unsigned (var_die
, DW_AT_decl_file
, file_index
);
8642 if (get_AT_unsigned (old_die
, DW_AT_decl_line
)
8643 != (unsigned)DECL_SOURCE_LINE (decl
))
8645 add_AT_unsigned (var_die
, DW_AT_decl_line
,
8646 DECL_SOURCE_LINE (decl
));
8651 add_name_and_src_coords_attributes (var_die
, decl
);
8652 add_type_attribute (var_die
, TREE_TYPE (decl
),
8653 TREE_READONLY (decl
),
8654 TREE_THIS_VOLATILE (decl
), context_die
);
8656 if (TREE_PUBLIC (decl
))
8657 add_AT_flag (var_die
, DW_AT_external
, 1);
8659 if (DECL_ARTIFICIAL (decl
))
8660 add_AT_flag (var_die
, DW_AT_artificial
, 1);
8662 if (TREE_PROTECTED (decl
))
8663 add_AT_unsigned (var_die
, DW_AT_accessibility
, DW_ACCESS_protected
);
8665 else if (TREE_PRIVATE (decl
))
8666 add_AT_unsigned (var_die
, DW_AT_accessibility
, DW_ACCESS_private
);
8670 add_AT_flag (var_die
, DW_AT_declaration
, 1);
8672 if ((declaration
&& decl_class_context (decl
)) || DECL_ABSTRACT (decl
))
8673 equate_decl_number_to_die (decl
, var_die
);
8675 if (! declaration
&& ! DECL_ABSTRACT (decl
))
8677 equate_decl_number_to_die (decl
, var_die
);
8678 add_location_or_const_value_attribute (var_die
, decl
);
8679 add_pubname (decl
, var_die
);
8683 /* Generate a DIE to represent a label identifier. */
8686 gen_label_die (decl
, context_die
)
8688 register dw_die_ref context_die
;
8690 register tree origin
= decl_ultimate_origin (decl
);
8691 register dw_die_ref lbl_die
= new_die (DW_TAG_label
, context_die
);
8693 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
8694 char label2
[MAX_ARTIFICIAL_LABEL_BYTES
];
8697 add_abstract_origin_attribute (lbl_die
, origin
);
8699 add_name_and_src_coords_attributes (lbl_die
, decl
);
8701 if (DECL_ABSTRACT (decl
))
8702 equate_decl_number_to_die (decl
, lbl_die
);
8705 insn
= DECL_RTL (decl
);
8707 /* Deleted labels are programmer specified labels which have been
8708 eliminated because of various optimisations. We still emit them
8709 here so that it is possible to put breakpoints on them. */
8710 if (GET_CODE (insn
) == CODE_LABEL
8711 || ((GET_CODE (insn
) == NOTE
8712 && NOTE_LINE_NUMBER (insn
) == NOTE_INSN_DELETED_LABEL
)))
8714 /* When optimization is enabled (via -O) some parts of the compiler
8715 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
8716 represent source-level labels which were explicitly declared by
8717 the user. This really shouldn't be happening though, so catch
8718 it if it ever does happen. */
8719 if (INSN_DELETED_P (insn
))
8722 sprintf (label2
, INSN_LABEL_FMT
, current_funcdef_number
);
8723 ASM_GENERATE_INTERNAL_LABEL (label
, label2
,
8724 (unsigned) INSN_UID (insn
));
8725 add_AT_lbl_id (lbl_die
, DW_AT_low_pc
, label
);
8730 /* Generate a DIE for a lexical block. */
8733 gen_lexical_block_die (stmt
, context_die
, depth
)
8735 register dw_die_ref context_die
;
8738 register dw_die_ref stmt_die
= new_die (DW_TAG_lexical_block
, context_die
);
8739 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
8741 if (! BLOCK_ABSTRACT (stmt
))
8743 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_BEGIN_LABEL
,
8745 add_AT_lbl_id (stmt_die
, DW_AT_low_pc
, label
);
8746 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_END_LABEL
, next_block_number
);
8747 add_AT_lbl_id (stmt_die
, DW_AT_high_pc
, label
);
8750 push_decl_scope (stmt
);
8751 decls_for_scope (stmt
, stmt_die
, depth
);
8755 /* Generate a DIE for an inlined subprogram. */
8758 gen_inlined_subroutine_die (stmt
, context_die
, depth
)
8760 register dw_die_ref context_die
;
8763 if (! BLOCK_ABSTRACT (stmt
))
8765 register dw_die_ref subr_die
8766 = new_die (DW_TAG_inlined_subroutine
, context_die
);
8767 register tree decl
= block_ultimate_origin (stmt
);
8768 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
8770 add_abstract_origin_attribute (subr_die
, decl
);
8771 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_BEGIN_LABEL
,
8773 add_AT_lbl_id (subr_die
, DW_AT_low_pc
, label
);
8774 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_END_LABEL
, next_block_number
);
8775 add_AT_lbl_id (subr_die
, DW_AT_high_pc
, label
);
8776 push_decl_scope (decl
);
8777 decls_for_scope (stmt
, subr_die
, depth
);
8779 current_function_has_inlines
= 1;
8783 /* Generate a DIE for a field in a record, or structure. */
8786 gen_field_die (decl
, context_die
)
8788 register dw_die_ref context_die
;
8790 register dw_die_ref decl_die
= new_die (DW_TAG_member
, context_die
);
8792 add_name_and_src_coords_attributes (decl_die
, decl
);
8793 add_type_attribute (decl_die
, member_declared_type (decl
),
8794 TREE_READONLY (decl
), TREE_THIS_VOLATILE (decl
),
8797 /* If this is a bit field... */
8798 if (DECL_BIT_FIELD_TYPE (decl
))
8800 add_byte_size_attribute (decl_die
, decl
);
8801 add_bit_size_attribute (decl_die
, decl
);
8802 add_bit_offset_attribute (decl_die
, decl
);
8805 if (TREE_CODE (DECL_FIELD_CONTEXT (decl
)) != UNION_TYPE
)
8806 add_data_member_location_attribute (decl_die
, decl
);
8808 if (DECL_ARTIFICIAL (decl
))
8809 add_AT_flag (decl_die
, DW_AT_artificial
, 1);
8811 if (TREE_PROTECTED (decl
))
8812 add_AT_unsigned (decl_die
, DW_AT_accessibility
, DW_ACCESS_protected
);
8814 else if (TREE_PRIVATE (decl
))
8815 add_AT_unsigned (decl_die
, DW_AT_accessibility
, DW_ACCESS_private
);
8819 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
8820 Use modified_type_die instead.
8821 We keep this code here just in case these types of DIEs may be needed to
8822 represent certain things in other languages (e.g. Pascal) someday. */
8824 gen_pointer_type_die (type
, context_die
)
8826 register dw_die_ref context_die
;
8828 register dw_die_ref ptr_die
8829 = new_die (DW_TAG_pointer_type
, scope_die_for (type
, context_die
));
8831 equate_type_number_to_die (type
, ptr_die
);
8832 add_type_attribute (ptr_die
, TREE_TYPE (type
), 0, 0, context_die
);
8833 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
, PTR_SIZE
);
8836 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
8837 Use modified_type_die instead.
8838 We keep this code here just in case these types of DIEs may be needed to
8839 represent certain things in other languages (e.g. Pascal) someday. */
8841 gen_reference_type_die (type
, context_die
)
8843 register dw_die_ref context_die
;
8845 register dw_die_ref ref_die
8846 = new_die (DW_TAG_reference_type
, scope_die_for (type
, context_die
));
8848 equate_type_number_to_die (type
, ref_die
);
8849 add_type_attribute (ref_die
, TREE_TYPE (type
), 0, 0, context_die
);
8850 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
, PTR_SIZE
);
8854 /* Generate a DIE for a pointer to a member type. */
8856 gen_ptr_to_mbr_type_die (type
, context_die
)
8858 register dw_die_ref context_die
;
8860 register dw_die_ref ptr_die
8861 = new_die (DW_TAG_ptr_to_member_type
, scope_die_for (type
, context_die
));
8863 equate_type_number_to_die (type
, ptr_die
);
8864 add_AT_die_ref (ptr_die
, DW_AT_containing_type
,
8865 lookup_type_die (TYPE_OFFSET_BASETYPE (type
)));
8866 add_type_attribute (ptr_die
, TREE_TYPE (type
), 0, 0, context_die
);
8869 /* Generate the DIE for the compilation unit. */
8872 gen_compile_unit_die (main_input_filename
)
8873 register char *main_input_filename
;
8876 char *wd
= getpwd ();
8878 comp_unit_die
= new_die (DW_TAG_compile_unit
, NULL
);
8879 add_name_attribute (comp_unit_die
, main_input_filename
);
8882 add_AT_string (comp_unit_die
, DW_AT_comp_dir
, wd
);
8884 sprintf (producer
, "%s %s", language_string
, version_string
);
8886 #ifdef MIPS_DEBUGGING_INFO
8887 /* The MIPS/SGI compilers place the 'cc' command line options in the producer
8888 string. The SGI debugger looks for -g, -g1, -g2, or -g3; if they do
8889 not appear in the producer string, the debugger reaches the conclusion
8890 that the object file is stripped and has no debugging information.
8891 To get the MIPS/SGI debugger to believe that there is debugging
8892 information in the object file, we add a -g to the producer string. */
8893 if (debug_info_level
> DINFO_LEVEL_TERSE
)
8894 strcat (producer
, " -g");
8897 add_AT_string (comp_unit_die
, DW_AT_producer
, producer
);
8899 if (strcmp (language_string
, "GNU C++") == 0)
8900 add_AT_unsigned (comp_unit_die
, DW_AT_language
, DW_LANG_C_plus_plus
);
8902 else if (strcmp (language_string
, "GNU Ada") == 0)
8903 add_AT_unsigned (comp_unit_die
, DW_AT_language
, DW_LANG_Ada83
);
8905 else if (strcmp (language_string
, "GNU F77") == 0)
8906 add_AT_unsigned (comp_unit_die
, DW_AT_language
, DW_LANG_Fortran77
);
8908 else if (strcmp (language_string
, "GNU Pascal") == 0)
8909 add_AT_unsigned (comp_unit_die
, DW_AT_language
, DW_LANG_Pascal83
);
8911 else if (flag_traditional
)
8912 add_AT_unsigned (comp_unit_die
, DW_AT_language
, DW_LANG_C
);
8915 add_AT_unsigned (comp_unit_die
, DW_AT_language
, DW_LANG_C89
);
8917 #if 0 /* unimplemented */
8918 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
)
8919 add_AT_unsigned (comp_unit_die
, DW_AT_macro_info
, 0);
8923 /* Generate a DIE for a string type. */
8926 gen_string_type_die (type
, context_die
)
8928 register dw_die_ref context_die
;
8930 register dw_die_ref type_die
8931 = new_die (DW_TAG_string_type
, scope_die_for (type
, context_die
));
8933 equate_type_number_to_die (type
, type_die
);
8935 /* Fudge the string length attribute for now. */
8937 /* TODO: add string length info.
8938 string_length_attribute (TYPE_MAX_VALUE (TYPE_DOMAIN (type)));
8939 bound_representation (upper_bound, 0, 'u'); */
8942 /* Generate the DIE for a base class. */
8945 gen_inheritance_die (binfo
, context_die
)
8946 register tree binfo
;
8947 register dw_die_ref context_die
;
8949 dw_die_ref die
= new_die (DW_TAG_inheritance
, context_die
);
8951 add_type_attribute (die
, BINFO_TYPE (binfo
), 0, 0, context_die
);
8952 add_data_member_location_attribute (die
, binfo
);
8954 if (TREE_VIA_VIRTUAL (binfo
))
8955 add_AT_unsigned (die
, DW_AT_virtuality
, DW_VIRTUALITY_virtual
);
8956 if (TREE_VIA_PUBLIC (binfo
))
8957 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_public
);
8958 else if (TREE_VIA_PROTECTED (binfo
))
8959 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_protected
);
8962 /* Generate a DIE for a class member. */
8965 gen_member_die (type
, context_die
)
8967 register dw_die_ref context_die
;
8969 register tree member
;
8971 /* If this is not an incomplete type, output descriptions of each of its
8972 members. Note that as we output the DIEs necessary to represent the
8973 members of this record or union type, we will also be trying to output
8974 DIEs to represent the *types* of those members. However the `type'
8975 function (above) will specifically avoid generating type DIEs for member
8976 types *within* the list of member DIEs for this (containing) type execpt
8977 for those types (of members) which are explicitly marked as also being
8978 members of this (containing) type themselves. The g++ front- end can
8979 force any given type to be treated as a member of some other
8980 (containing) type by setting the TYPE_CONTEXT of the given (member) type
8981 to point to the TREE node representing the appropriate (containing)
8984 /* First output info about the base classes. */
8985 if (TYPE_BINFO (type
) && TYPE_BINFO_BASETYPES (type
))
8987 register tree bases
= TYPE_BINFO_BASETYPES (type
);
8988 register int n_bases
= TREE_VEC_LENGTH (bases
);
8991 for (i
= 0; i
< n_bases
; i
++)
8992 gen_inheritance_die (TREE_VEC_ELT (bases
, i
), context_die
);
8995 /* Now output info about the data members and type members. */
8996 for (member
= TYPE_FIELDS (type
); member
; member
= TREE_CHAIN (member
))
8997 gen_decl_die (member
, context_die
);
8999 /* Now output info about the function members (if any). */
9000 for (member
= TYPE_METHODS (type
); member
; member
= TREE_CHAIN (member
))
9001 gen_decl_die (member
, context_die
);
9004 /* Generate a DIE for a structure or union type. */
9007 gen_struct_or_union_type_die (type
, context_die
)
9009 register dw_die_ref context_die
;
9011 register dw_die_ref type_die
= lookup_type_die (type
);
9012 register dw_die_ref scope_die
= 0;
9013 register int nested
= 0;
9015 if (type_die
&& ! TYPE_SIZE (type
))
9018 if (TYPE_CONTEXT (type
) != NULL_TREE
9019 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type
)))
9022 scope_die
= scope_die_for (type
, context_die
);
9024 if (! type_die
|| (nested
&& scope_die
== comp_unit_die
))
9025 /* First occurrence of type or toplevel definition of nested class. */
9027 register dw_die_ref old_die
= type_die
;
9029 type_die
= new_die (TREE_CODE (type
) == RECORD_TYPE
9030 ? DW_TAG_structure_type
: DW_TAG_union_type
,
9032 equate_type_number_to_die (type
, type_die
);
9033 add_name_attribute (type_die
, type_tag (type
));
9035 add_AT_die_ref (type_die
, DW_AT_specification
, old_die
);
9038 remove_AT (type_die
, DW_AT_declaration
);
9040 /* If we're not in the right context to be defining this type, defer to
9041 avoid tricky recursion. */
9042 if (TYPE_SIZE (type
) && decl_scope_depth
> 0 && scope_die
== comp_unit_die
)
9044 add_AT_flag (type_die
, DW_AT_declaration
, 1);
9047 /* If this type has been completed, then give it a byte_size attribute and
9048 then give a list of members. */
9049 else if (TYPE_SIZE (type
))
9051 /* Prevent infinite recursion in cases where the type of some member of
9052 this type is expressed in terms of this type itself. */
9053 TREE_ASM_WRITTEN (type
) = 1;
9054 add_byte_size_attribute (type_die
, type
);
9055 if (TYPE_STUB_DECL (type
) != NULL_TREE
)
9056 add_src_coords_attributes (type_die
, TYPE_STUB_DECL (type
));
9058 /* If the first reference to this type was as the return type of an
9059 inline function, then it may not have a parent. Fix this now. */
9060 if (type_die
->die_parent
== NULL
)
9061 add_child_die (scope_die
, type_die
);
9063 push_decl_scope (type
);
9064 gen_member_die (type
, type_die
);
9067 /* GNU extension: Record what type our vtable lives in. */
9068 if (TYPE_VFIELD (type
))
9070 tree vtype
= DECL_FCONTEXT (TYPE_VFIELD (type
));
9072 gen_type_die (vtype
, context_die
);
9073 add_AT_die_ref (type_die
, DW_AT_containing_type
,
9074 lookup_type_die (vtype
));
9079 add_AT_flag (type_die
, DW_AT_declaration
, 1);
9080 add_incomplete_type (type
);
9084 /* Generate a DIE for a subroutine _type_. */
9087 gen_subroutine_type_die (type
, context_die
)
9089 register dw_die_ref context_die
;
9091 register tree return_type
= TREE_TYPE (type
);
9092 register dw_die_ref subr_die
9093 = new_die (DW_TAG_subroutine_type
, scope_die_for (type
, context_die
));
9095 equate_type_number_to_die (type
, subr_die
);
9096 add_prototyped_attribute (subr_die
, type
);
9097 add_type_attribute (subr_die
, return_type
, 0, 0, context_die
);
9098 gen_formal_types_die (type
, subr_die
);
9101 /* Generate a DIE for a type definition */
9104 gen_typedef_die (decl
, context_die
)
9106 register dw_die_ref context_die
;
9108 register dw_die_ref type_die
;
9109 register tree origin
;
9111 if (TREE_ASM_WRITTEN (decl
))
9113 TREE_ASM_WRITTEN (decl
) = 1;
9115 type_die
= new_die (DW_TAG_typedef
, scope_die_for (decl
, context_die
));
9116 origin
= decl_ultimate_origin (decl
);
9118 add_abstract_origin_attribute (type_die
, origin
);
9122 add_name_and_src_coords_attributes (type_die
, decl
);
9123 if (DECL_ORIGINAL_TYPE (decl
))
9125 type
= DECL_ORIGINAL_TYPE (decl
);
9126 equate_type_number_to_die (TREE_TYPE (decl
), type_die
);
9129 type
= TREE_TYPE (decl
);
9130 add_type_attribute (type_die
, type
, TREE_READONLY (decl
),
9131 TREE_THIS_VOLATILE (decl
), context_die
);
9134 if (DECL_ABSTRACT (decl
))
9135 equate_decl_number_to_die (decl
, type_die
);
9138 /* Generate a type description DIE. */
9141 gen_type_die (type
, context_die
)
9143 register dw_die_ref context_die
;
9145 if (type
== NULL_TREE
|| type
== error_mark_node
)
9148 /* We are going to output a DIE to represent the unqualified version of
9149 this type (i.e. without any const or volatile qualifiers) so get the
9150 main variant (i.e. the unqualified version) of this type now. */
9151 type
= type_main_variant (type
);
9153 if (TREE_ASM_WRITTEN (type
))
9156 if (TYPE_NAME (type
) && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
9157 && DECL_ORIGINAL_TYPE (TYPE_NAME (type
)))
9159 TREE_ASM_WRITTEN (type
) = 1;
9160 gen_decl_die (TYPE_NAME (type
), context_die
);
9164 switch (TREE_CODE (type
))
9170 case REFERENCE_TYPE
:
9171 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This
9172 ensures that the gen_type_die recursion will terminate even if the
9173 type is recursive. Recursive types are possible in Ada. */
9174 /* ??? We could perhaps do this for all types before the switch
9176 TREE_ASM_WRITTEN (type
) = 1;
9178 /* For these types, all that is required is that we output a DIE (or a
9179 set of DIEs) to represent the "basis" type. */
9180 gen_type_die (TREE_TYPE (type
), context_die
);
9184 /* This code is used for C++ pointer-to-data-member types.
9185 Output a description of the relevant class type. */
9186 gen_type_die (TYPE_OFFSET_BASETYPE (type
), context_die
);
9188 /* Output a description of the type of the object pointed to. */
9189 gen_type_die (TREE_TYPE (type
), context_die
);
9191 /* Now output a DIE to represent this pointer-to-data-member type
9193 gen_ptr_to_mbr_type_die (type
, context_die
);
9197 gen_type_die (TYPE_DOMAIN (type
), context_die
);
9198 gen_set_type_die (type
, context_die
);
9202 gen_type_die (TREE_TYPE (type
), context_die
);
9203 abort (); /* No way to represent these in Dwarf yet! */
9207 /* Force out return type (in case it wasn't forced out already). */
9208 gen_type_die (TREE_TYPE (type
), context_die
);
9209 gen_subroutine_type_die (type
, context_die
);
9213 /* Force out return type (in case it wasn't forced out already). */
9214 gen_type_die (TREE_TYPE (type
), context_die
);
9215 gen_subroutine_type_die (type
, context_die
);
9219 if (TYPE_STRING_FLAG (type
) && TREE_CODE (TREE_TYPE (type
)) == CHAR_TYPE
)
9221 gen_type_die (TREE_TYPE (type
), context_die
);
9222 gen_string_type_die (type
, context_die
);
9225 gen_array_type_die (type
, context_die
);
9231 case QUAL_UNION_TYPE
:
9232 /* If this is a nested type whose containing class hasn't been
9233 written out yet, writing it out will cover this one, too. */
9234 if (TYPE_CONTEXT (type
)
9235 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type
))
9236 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type
)))
9238 gen_type_die (TYPE_CONTEXT (type
), context_die
);
9240 if (TREE_ASM_WRITTEN (TYPE_CONTEXT (type
)))
9243 /* If that failed, attach ourselves to the stub. */
9244 push_decl_scope (TYPE_CONTEXT (type
));
9245 context_die
= lookup_type_die (TYPE_CONTEXT (type
));
9248 if (TREE_CODE (type
) == ENUMERAL_TYPE
)
9249 gen_enumeration_type_die (type
, context_die
);
9251 gen_struct_or_union_type_die (type
, context_die
);
9253 if (TYPE_CONTEXT (type
)
9254 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type
))
9255 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type
)))
9258 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
9259 it up if it is ever completed. gen_*_type_die will set it for us
9260 when appropriate. */
9269 /* No DIEs needed for fundamental types. */
9273 /* No Dwarf representation currently defined. */
9280 TREE_ASM_WRITTEN (type
) = 1;
9283 /* Generate a DIE for a tagged type instantiation. */
9286 gen_tagged_type_instantiation_die (type
, context_die
)
9288 register dw_die_ref context_die
;
9290 if (type
== NULL_TREE
|| type
== error_mark_node
)
9293 /* We are going to output a DIE to represent the unqualified version of
9294 this type (i.e. without any const or volatile qualifiers) so make sure
9295 that we have the main variant (i.e. the unqualified version) of this
9297 if (type
!= type_main_variant (type
)
9298 || !TREE_ASM_WRITTEN (type
))
9301 switch (TREE_CODE (type
))
9307 gen_inlined_enumeration_type_die (type
, context_die
);
9311 gen_inlined_structure_type_die (type
, context_die
);
9315 case QUAL_UNION_TYPE
:
9316 gen_inlined_union_type_die (type
, context_die
);
9324 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
9325 things which are local to the given block. */
9328 gen_block_die (stmt
, context_die
, depth
)
9330 register dw_die_ref context_die
;
9333 register int must_output_die
= 0;
9334 register tree origin
;
9336 register enum tree_code origin_code
;
9338 /* Ignore blocks never really used to make RTL. */
9340 if (stmt
== NULL_TREE
|| !TREE_USED (stmt
))
9343 /* Determine the "ultimate origin" of this block. This block may be an
9344 inlined instance of an inlined instance of inline function, so we have
9345 to trace all of the way back through the origin chain to find out what
9346 sort of node actually served as the original seed for the creation of
9347 the current block. */
9348 origin
= block_ultimate_origin (stmt
);
9349 origin_code
= (origin
!= NULL
) ? TREE_CODE (origin
) : ERROR_MARK
;
9351 /* Determine if we need to output any Dwarf DIEs at all to represent this
9353 if (origin_code
== FUNCTION_DECL
)
9354 /* The outer scopes for inlinings *must* always be represented. We
9355 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */
9356 must_output_die
= 1;
9359 /* In the case where the current block represents an inlining of the
9360 "body block" of an inline function, we must *NOT* output any DIE for
9361 this block because we have already output a DIE to represent the
9362 whole inlined function scope and the "body block" of any function
9363 doesn't really represent a different scope according to ANSI C
9364 rules. So we check here to make sure that this block does not
9365 represent a "body block inlining" before trying to set the
9366 `must_output_die' flag. */
9367 if (! is_body_block (origin
? origin
: stmt
))
9369 /* Determine if this block directly contains any "significant"
9370 local declarations which we will need to output DIEs for. */
9371 if (debug_info_level
> DINFO_LEVEL_TERSE
)
9372 /* We are not in terse mode so *any* local declaration counts
9373 as being a "significant" one. */
9374 must_output_die
= (BLOCK_VARS (stmt
) != NULL
);
9376 /* We are in terse mode, so only local (nested) function
9377 definitions count as "significant" local declarations. */
9378 for (decl
= BLOCK_VARS (stmt
);
9379 decl
!= NULL
; decl
= TREE_CHAIN (decl
))
9380 if (TREE_CODE (decl
) == FUNCTION_DECL
9381 && DECL_INITIAL (decl
))
9383 must_output_die
= 1;
9389 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
9390 DIE for any block which contains no significant local declarations at
9391 all. Rather, in such cases we just call `decls_for_scope' so that any
9392 needed Dwarf info for any sub-blocks will get properly generated. Note
9393 that in terse mode, our definition of what constitutes a "significant"
9394 local declaration gets restricted to include only inlined function
9395 instances and local (nested) function definitions. */
9396 if (must_output_die
)
9398 if (origin_code
== FUNCTION_DECL
)
9399 gen_inlined_subroutine_die (stmt
, context_die
, depth
);
9401 gen_lexical_block_die (stmt
, context_die
, depth
);
9404 decls_for_scope (stmt
, context_die
, depth
);
9407 /* Generate all of the decls declared within a given scope and (recursively)
9408 all of its sub-blocks. */
9411 decls_for_scope (stmt
, context_die
, depth
)
9413 register dw_die_ref context_die
;
9417 register tree subblocks
;
9419 /* Ignore blocks never really used to make RTL. */
9420 if (stmt
== NULL_TREE
|| ! TREE_USED (stmt
))
9423 if (!BLOCK_ABSTRACT (stmt
) && depth
> 0)
9424 next_block_number
++;
9426 /* Output the DIEs to represent all of the data objects and typedefs
9427 declared directly within this block but not within any nested
9428 sub-blocks. Also, nested function and tag DIEs have been
9429 generated with a parent of NULL; fix that up now. */
9430 for (decl
= BLOCK_VARS (stmt
);
9431 decl
!= NULL
; decl
= TREE_CHAIN (decl
))
9433 register dw_die_ref die
;
9435 if (TREE_CODE (decl
) == FUNCTION_DECL
)
9436 die
= lookup_decl_die (decl
);
9437 else if (TREE_CODE (decl
) == TYPE_DECL
&& TYPE_DECL_IS_STUB (decl
))
9438 die
= lookup_type_die (TREE_TYPE (decl
));
9442 if (die
!= NULL
&& die
->die_parent
== NULL
)
9443 add_child_die (context_die
, die
);
9445 gen_decl_die (decl
, context_die
);
9448 /* Output the DIEs to represent all sub-blocks (and the items declared
9449 therein) of this block. */
9450 for (subblocks
= BLOCK_SUBBLOCKS (stmt
);
9452 subblocks
= BLOCK_CHAIN (subblocks
))
9453 gen_block_die (subblocks
, context_die
, depth
+ 1);
9456 /* Is this a typedef we can avoid emitting? */
9459 is_redundant_typedef (decl
)
9462 if (TYPE_DECL_IS_STUB (decl
))
9465 if (DECL_ARTIFICIAL (decl
)
9466 && DECL_CONTEXT (decl
)
9467 && is_tagged_type (DECL_CONTEXT (decl
))
9468 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl
))) == TYPE_DECL
9469 && DECL_NAME (decl
) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl
))))
9470 /* Also ignore the artificial member typedef for the class name. */
9476 /* Generate Dwarf debug information for a decl described by DECL. */
9479 gen_decl_die (decl
, context_die
)
9481 register dw_die_ref context_die
;
9483 register tree origin
;
9485 /* Make a note of the decl node we are going to be working on. We may need
9486 to give the user the source coordinates of where it appeared in case we
9487 notice (later on) that something about it looks screwy. */
9488 dwarf_last_decl
= decl
;
9490 if (TREE_CODE (decl
) == ERROR_MARK
)
9493 /* If this ..._DECL node is marked to be ignored, then ignore it. But don't
9494 ignore a function definition, since that would screw up our count of
9495 blocks, and that in turn will completely screw up the labels we will
9496 reference in subsequent DW_AT_low_pc and DW_AT_high_pc attributes (for
9497 subsequent blocks). */
9498 if (DECL_IGNORED_P (decl
) && TREE_CODE (decl
) != FUNCTION_DECL
)
9501 switch (TREE_CODE (decl
))
9504 /* The individual enumerators of an enum type get output when we output
9505 the Dwarf representation of the relevant enum type itself. */
9509 /* Don't output any DIEs to represent mere function declarations,
9510 unless they are class members or explicit block externs. */
9511 if (DECL_INITIAL (decl
) == NULL_TREE
&& DECL_CONTEXT (decl
) == NULL_TREE
9512 && (current_function_decl
== NULL_TREE
|| ! DECL_ARTIFICIAL (decl
)))
9515 if (debug_info_level
> DINFO_LEVEL_TERSE
)
9517 /* Before we describe the FUNCTION_DECL itself, make sure that we
9518 have described its return type. */
9519 gen_type_die (TREE_TYPE (TREE_TYPE (decl
)), context_die
);
9521 /* And its containing type. */
9522 origin
= decl_class_context (decl
);
9523 if (origin
!= NULL_TREE
)
9524 gen_type_die (origin
, context_die
);
9526 /* And its virtual context. */
9527 if (DECL_VINDEX (decl
) != NULL_TREE
)
9528 gen_type_die (DECL_CONTEXT (decl
), context_die
);
9531 /* Now output a DIE to represent the function itself. */
9532 gen_subprogram_die (decl
, context_die
);
9536 /* If we are in terse mode, don't generate any DIEs to represent any
9538 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
9541 /* In the special case of a TYPE_DECL node representing the
9542 declaration of some type tag, if the given TYPE_DECL is marked as
9543 having been instantiated from some other (original) TYPE_DECL node
9544 (e.g. one which was generated within the original definition of an
9545 inline function) we have to generate a special (abbreviated)
9546 DW_TAG_structure_type, DW_TAG_union_type, or DW_TAG_enumeration_type
9548 if (TYPE_DECL_IS_STUB (decl
) && DECL_ABSTRACT_ORIGIN (decl
) != NULL_TREE
)
9550 gen_tagged_type_instantiation_die (TREE_TYPE (decl
), context_die
);
9554 if (is_redundant_typedef (decl
))
9555 gen_type_die (TREE_TYPE (decl
), context_die
);
9557 /* Output a DIE to represent the typedef itself. */
9558 gen_typedef_die (decl
, context_die
);
9562 if (debug_info_level
>= DINFO_LEVEL_NORMAL
)
9563 gen_label_die (decl
, context_die
);
9567 /* If we are in terse mode, don't generate any DIEs to represent any
9568 variable declarations or definitions. */
9569 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
9572 /* Output any DIEs that are needed to specify the type of this data
9574 gen_type_die (TREE_TYPE (decl
), context_die
);
9576 /* And its containing type. */
9577 origin
= decl_class_context (decl
);
9578 if (origin
!= NULL_TREE
)
9579 gen_type_die (origin
, context_die
);
9581 /* Now output the DIE to represent the data object itself. This gets
9582 complicated because of the possibility that the VAR_DECL really
9583 represents an inlined instance of a formal parameter for an inline
9585 origin
= decl_ultimate_origin (decl
);
9586 if (origin
!= NULL_TREE
&& TREE_CODE (origin
) == PARM_DECL
)
9587 gen_formal_parameter_die (decl
, context_die
);
9589 gen_variable_die (decl
, context_die
);
9593 /* Ignore the nameless fields that are used to skip bits, but
9594 handle C++ anonymous unions. */
9595 if (DECL_NAME (decl
) != NULL_TREE
9596 || TREE_CODE (TREE_TYPE (decl
)) == UNION_TYPE
)
9598 gen_type_die (member_declared_type (decl
), context_die
);
9599 gen_field_die (decl
, context_die
);
9604 gen_type_die (TREE_TYPE (decl
), context_die
);
9605 gen_formal_parameter_die (decl
, context_die
);
9613 /* Write the debugging output for DECL. */
9616 dwarf2out_decl (decl
)
9619 register dw_die_ref context_die
= comp_unit_die
;
9621 if (TREE_CODE (decl
) == ERROR_MARK
)
9624 /* If this ..._DECL node is marked to be ignored, then ignore it. We gotta
9625 hope that the node in question doesn't represent a function definition.
9626 If it does, then totally ignoring it is bound to screw up our count of
9627 blocks, and that in turn will completely screw up the labels we will
9628 reference in subsequent DW_AT_low_pc and DW_AT_high_pc attributes (for
9629 subsequent blocks). (It's too bad that BLOCK nodes don't carry their
9630 own sequence numbers with them!) */
9631 if (DECL_IGNORED_P (decl
))
9633 if (TREE_CODE (decl
) == FUNCTION_DECL
9634 && DECL_INITIAL (decl
) != NULL
)
9640 switch (TREE_CODE (decl
))
9643 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration of a
9644 builtin function. Explicit programmer-supplied declarations of
9645 these same functions should NOT be ignored however. */
9646 if (DECL_EXTERNAL (decl
) && DECL_FUNCTION_CODE (decl
))
9649 /* What we would really like to do here is to filter out all mere
9650 file-scope declarations of file-scope functions which are never
9651 referenced later within this translation unit (and keep all of ones
9652 that *are* referenced later on) but we aren't clairvoyant, so we have
9653 no idea which functions will be referenced in the future (i.e. later
9654 on within the current translation unit). So here we just ignore all
9655 file-scope function declarations which are not also definitions. If
9656 and when the debugger needs to know something about these functions,
9657 it wil have to hunt around and find the DWARF information associated
9658 with the definition of the function. Note that we can't just check
9659 `DECL_EXTERNAL' to find out which FUNCTION_DECL nodes represent
9660 definitions and which ones represent mere declarations. We have to
9661 check `DECL_INITIAL' instead. That's because the C front-end
9662 supports some weird semantics for "extern inline" function
9663 definitions. These can get inlined within the current translation
9664 unit (an thus, we need to generate DWARF info for their abstract
9665 instances so that the DWARF info for the concrete inlined instances
9666 can have something to refer to) but the compiler never generates any
9667 out-of-lines instances of such things (despite the fact that they
9668 *are* definitions). The important point is that the C front-end
9669 marks these "extern inline" functions as DECL_EXTERNAL, but we need
9670 to generate DWARF for them anyway. Note that the C++ front-end also
9671 plays some similar games for inline function definitions appearing
9672 within include files which also contain
9673 `#pragma interface' pragmas. */
9674 if (DECL_INITIAL (decl
) == NULL_TREE
)
9677 /* If we're a nested function, initially use a parent of NULL; if we're
9678 a plain function, this will be fixed up in decls_for_scope. If
9679 we're a method, it will be ignored, since we already have a DIE. */
9680 if (decl_function_context (decl
))
9686 /* Ignore this VAR_DECL if it refers to a file-scope extern data object
9687 declaration and if the declaration was never even referenced from
9688 within this entire compilation unit. We suppress these DIEs in
9689 order to save space in the .debug section (by eliminating entries
9690 which are probably useless). Note that we must not suppress
9691 block-local extern declarations (whether used or not) because that
9692 would screw-up the debugger's name lookup mechanism and cause it to
9693 miss things which really ought to be in scope at a given point. */
9694 if (DECL_EXTERNAL (decl
) && !TREE_USED (decl
))
9697 /* If we are in terse mode, don't generate any DIEs to represent any
9698 variable declarations or definitions. */
9699 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
9704 /* Don't bother trying to generate any DIEs to represent any of the
9705 normal built-in types for the language we are compiling. */
9706 if (DECL_SOURCE_LINE (decl
) == 0)
9708 /* OK, we need to generate one for `bool' so GDB knows what type
9709 comparisons have. */
9710 if ((get_AT_unsigned (comp_unit_die
, DW_AT_language
)
9711 == DW_LANG_C_plus_plus
)
9712 && TREE_CODE (TREE_TYPE (decl
)) == BOOLEAN_TYPE
)
9713 modified_type_die (TREE_TYPE (decl
), 0, 0, NULL
);
9718 /* If we are in terse mode, don't generate any DIEs for types. */
9719 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
9722 /* If we're a function-scope tag, initially use a parent of NULL;
9723 this will be fixed up in decls_for_scope. */
9724 if (decl_function_context (decl
))
9733 gen_decl_die (decl
, context_die
);
9734 output_pending_types_for_scope (comp_unit_die
);
9737 /* Output a marker (i.e. a label) for the beginning of the generated code for
9741 dwarf2out_begin_block (blocknum
)
9742 register unsigned blocknum
;
9744 function_section (current_function_decl
);
9745 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file
, BLOCK_BEGIN_LABEL
, blocknum
);
9748 /* Output a marker (i.e. a label) for the end of the generated code for a
9752 dwarf2out_end_block (blocknum
)
9753 register unsigned blocknum
;
9755 function_section (current_function_decl
);
9756 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file
, BLOCK_END_LABEL
, blocknum
);
9759 /* Output a marker (i.e. a label) at a point in the assembly code which
9760 corresponds to a given source level label. */
9763 dwarf2out_label (insn
)
9766 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
9768 if (debug_info_level
>= DINFO_LEVEL_NORMAL
)
9770 function_section (current_function_decl
);
9771 sprintf (label
, INSN_LABEL_FMT
, current_funcdef_number
);
9772 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file
, label
,
9773 (unsigned) INSN_UID (insn
));
9777 /* Lookup a filename (in the list of filenames that we know about here in
9778 dwarf2out.c) and return its "index". The index of each (known) filename is
9779 just a unique number which is associated with only that one filename.
9780 We need such numbers for the sake of generating labels
9781 (in the .debug_sfnames section) and references to those
9782 files numbers (in the .debug_srcinfo and.debug_macinfo sections).
9783 If the filename given as an argument is not found in our current list,
9784 add it to the list and assign it the next available unique index number.
9785 In order to speed up searches, we remember the index of the filename
9786 was looked up last. This handles the majority of all searches. */
9789 lookup_filename (file_name
)
9792 static unsigned last_file_lookup_index
= 0;
9793 register unsigned i
;
9795 /* Check to see if the file name that was searched on the previous call
9796 matches this file name. If so, return the index. */
9797 if (last_file_lookup_index
!= 0)
9798 if (strcmp (file_name
, file_table
[last_file_lookup_index
]) == 0)
9799 return last_file_lookup_index
;
9801 /* Didn't match the previous lookup, search the table */
9802 for (i
= 1; i
< file_table_in_use
; ++i
)
9803 if (strcmp (file_name
, file_table
[i
]) == 0)
9805 last_file_lookup_index
= i
;
9809 /* Prepare to add a new table entry by making sure there is enough space in
9810 the table to do so. If not, expand the current table. */
9811 if (file_table_in_use
== file_table_allocated
)
9813 file_table_allocated
+= FILE_TABLE_INCREMENT
;
9815 = (char **) xrealloc (file_table
,
9816 file_table_allocated
* sizeof (char *));
9819 /* Add the new entry to the end of the filename table. */
9820 file_table
[file_table_in_use
] = xstrdup (file_name
);
9821 last_file_lookup_index
= file_table_in_use
++;
9823 return last_file_lookup_index
;
9826 /* Output a label to mark the beginning of a source code line entry
9827 and record information relating to this source line, in
9828 'line_info_table' for later output of the .debug_line section. */
9831 dwarf2out_line (filename
, line
)
9832 register char *filename
;
9833 register unsigned line
;
9835 if (debug_info_level
>= DINFO_LEVEL_NORMAL
)
9837 function_section (current_function_decl
);
9839 if (DECL_SECTION_NAME (current_function_decl
))
9841 register dw_separate_line_info_ref line_info
;
9842 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file
, SEPARATE_LINE_CODE_LABEL
,
9843 separate_line_info_table_in_use
);
9844 fputc ('\n', asm_out_file
);
9846 /* expand the line info table if necessary */
9847 if (separate_line_info_table_in_use
9848 == separate_line_info_table_allocated
)
9850 separate_line_info_table_allocated
+= LINE_INFO_TABLE_INCREMENT
;
9851 separate_line_info_table
9852 = (dw_separate_line_info_ref
)
9853 xrealloc (separate_line_info_table
,
9854 separate_line_info_table_allocated
9855 * sizeof (dw_separate_line_info_entry
));
9858 /* Add the new entry at the end of the line_info_table. */
9860 = &separate_line_info_table
[separate_line_info_table_in_use
++];
9861 line_info
->dw_file_num
= lookup_filename (filename
);
9862 line_info
->dw_line_num
= line
;
9863 line_info
->function
= current_funcdef_number
;
9867 register dw_line_info_ref line_info
;
9869 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file
, LINE_CODE_LABEL
,
9870 line_info_table_in_use
);
9871 fputc ('\n', asm_out_file
);
9873 /* Expand the line info table if necessary. */
9874 if (line_info_table_in_use
== line_info_table_allocated
)
9876 line_info_table_allocated
+= LINE_INFO_TABLE_INCREMENT
;
9878 = (dw_line_info_ref
)
9879 xrealloc (line_info_table
,
9880 (line_info_table_allocated
9881 * sizeof (dw_line_info_entry
)));
9884 /* Add the new entry at the end of the line_info_table. */
9885 line_info
= &line_info_table
[line_info_table_in_use
++];
9886 line_info
->dw_file_num
= lookup_filename (filename
);
9887 line_info
->dw_line_num
= line
;
9892 /* Record the beginning of a new source file, for later output
9893 of the .debug_macinfo section. At present, unimplemented. */
9896 dwarf2out_start_source_file (filename
)
9897 register char *filename ATTRIBUTE_UNUSED
;
9901 /* Record the end of a source file, for later output
9902 of the .debug_macinfo section. At present, unimplemented. */
9905 dwarf2out_end_source_file ()
9909 /* Called from check_newline in c-parse.y. The `buffer' parameter contains
9910 the tail part of the directive line, i.e. the part which is past the
9911 initial whitespace, #, whitespace, directive-name, whitespace part. */
9914 dwarf2out_define (lineno
, buffer
)
9915 register unsigned lineno ATTRIBUTE_UNUSED
;
9916 register char *buffer ATTRIBUTE_UNUSED
;
9918 static int initialized
= 0;
9921 dwarf2out_start_source_file (primary_filename
);
9926 /* Called from check_newline in c-parse.y. The `buffer' parameter contains
9927 the tail part of the directive line, i.e. the part which is past the
9928 initial whitespace, #, whitespace, directive-name, whitespace part. */
9931 dwarf2out_undef (lineno
, buffer
)
9932 register unsigned lineno ATTRIBUTE_UNUSED
;
9933 register char *buffer ATTRIBUTE_UNUSED
;
9937 /* Set up for Dwarf output at the start of compilation. */
9940 dwarf2out_init (asm_out_file
, main_input_filename
)
9941 register FILE *asm_out_file
;
9942 register char *main_input_filename
;
9944 /* Remember the name of the primary input file. */
9945 primary_filename
= main_input_filename
;
9947 /* Allocate the initial hunk of the file_table. */
9948 file_table
= (char **) xmalloc (FILE_TABLE_INCREMENT
* sizeof (char *));
9949 bzero ((char *) file_table
, FILE_TABLE_INCREMENT
* sizeof (char *));
9950 file_table_allocated
= FILE_TABLE_INCREMENT
;
9952 /* Skip the first entry - file numbers begin at 1. */
9953 file_table_in_use
= 1;
9955 /* Allocate the initial hunk of the decl_die_table. */
9957 = (dw_die_ref
*) xmalloc (DECL_DIE_TABLE_INCREMENT
* sizeof (dw_die_ref
));
9958 bzero ((char *) decl_die_table
,
9959 DECL_DIE_TABLE_INCREMENT
* sizeof (dw_die_ref
));
9960 decl_die_table_allocated
= DECL_DIE_TABLE_INCREMENT
;
9961 decl_die_table_in_use
= 0;
9963 /* Allocate the initial hunk of the decl_scope_table. */
9965 = (decl_scope_node
*) xmalloc (DECL_SCOPE_TABLE_INCREMENT
9966 * sizeof (decl_scope_node
));
9967 bzero ((char *) decl_scope_table
,
9968 DECL_SCOPE_TABLE_INCREMENT
* sizeof (decl_scope_node
));
9969 decl_scope_table_allocated
= DECL_SCOPE_TABLE_INCREMENT
;
9970 decl_scope_depth
= 0;
9972 /* Allocate the initial hunk of the abbrev_die_table. */
9974 = (dw_die_ref
*) xmalloc (ABBREV_DIE_TABLE_INCREMENT
9975 * sizeof (dw_die_ref
));
9976 bzero ((char *) abbrev_die_table
,
9977 ABBREV_DIE_TABLE_INCREMENT
* sizeof (dw_die_ref
));
9978 abbrev_die_table_allocated
= ABBREV_DIE_TABLE_INCREMENT
;
9979 /* Zero-th entry is allocated, but unused */
9980 abbrev_die_table_in_use
= 1;
9982 /* Allocate the initial hunk of the line_info_table. */
9984 = (dw_line_info_ref
) xmalloc (LINE_INFO_TABLE_INCREMENT
9985 * sizeof (dw_line_info_entry
));
9986 bzero ((char *) line_info_table
,
9987 LINE_INFO_TABLE_INCREMENT
* sizeof (dw_line_info_entry
));
9988 line_info_table_allocated
= LINE_INFO_TABLE_INCREMENT
;
9989 /* Zero-th entry is allocated, but unused */
9990 line_info_table_in_use
= 1;
9992 /* Generate the initial DIE for the .debug section. Note that the (string)
9993 value given in the DW_AT_name attribute of the DW_TAG_compile_unit DIE
9994 will (typically) be a relative pathname and that this pathname should be
9995 taken as being relative to the directory from which the compiler was
9996 invoked when the given (base) source file was compiled. */
9997 gen_compile_unit_die (main_input_filename
);
9999 ASM_GENERATE_INTERNAL_LABEL (text_end_label
, TEXT_END_LABEL
, 0);
10000 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label
, ABBREV_SECTION_LABEL
, 0);
10001 ASM_GENERATE_INTERNAL_LABEL (text_section_label
, TEXT_SECTION_LABEL
, 0);
10002 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label
,
10003 DEBUG_INFO_SECTION_LABEL
, 0);
10004 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label
,
10005 DEBUG_LINE_SECTION_LABEL
, 0);
10007 ASM_OUTPUT_SECTION (asm_out_file
, ABBREV_SECTION
);
10008 ASM_OUTPUT_LABEL (asm_out_file
, abbrev_section_label
);
10009 ASM_OUTPUT_SECTION (asm_out_file
, TEXT_SECTION
);
10010 ASM_OUTPUT_LABEL (asm_out_file
, text_section_label
);
10011 ASM_OUTPUT_SECTION (asm_out_file
, DEBUG_INFO_SECTION
);
10012 ASM_OUTPUT_LABEL (asm_out_file
, debug_info_section_label
);
10013 ASM_OUTPUT_SECTION (asm_out_file
, DEBUG_LINE_SECTION
);
10014 ASM_OUTPUT_LABEL (asm_out_file
, debug_line_section_label
);
10017 /* Output stuff that dwarf requires at the end of every file,
10018 and generate the DWARF-2 debugging info. */
10021 dwarf2out_finish ()
10023 limbo_die_node
*node
, *next_node
;
10027 /* Traverse the limbo die list, and add parent/child links. The only
10028 dies without parents that should be here are concrete instances of
10029 inline functions, and the comp_unit_die. We can ignore the comp_unit_die.
10030 For concrete instances, we can get the parent die from the abstract
10032 for (node
= limbo_die_list
; node
; node
= next_node
)
10034 next_node
= node
->next
;
10037 if (die
->die_parent
== NULL
)
10039 a
= get_AT (die
, DW_AT_abstract_origin
);
10041 add_child_die (a
->dw_attr_val
.v
.val_die_ref
->die_parent
, die
);
10042 else if (die
== comp_unit_die
)
10050 /* Walk through the list of incomplete types again, trying once more to
10051 emit full debugging info for them. */
10052 retry_incomplete_types ();
10054 /* Traverse the DIE tree and add sibling attributes to those DIE's
10055 that have children. */
10056 add_sibling_attributes (comp_unit_die
);
10058 /* Output a terminator label for the .text section. */
10059 fputc ('\n', asm_out_file
);
10060 ASM_OUTPUT_SECTION (asm_out_file
, TEXT_SECTION
);
10061 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file
, TEXT_END_LABEL
, 0);
10064 /* Output a terminator label for the .data section. */
10065 fputc ('\n', asm_out_file
);
10066 ASM_OUTPUT_SECTION (asm_out_file
, DATA_SECTION
);
10067 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file
, DATA_END_LABEL
, 0);
10069 /* Output a terminator label for the .bss section. */
10070 fputc ('\n', asm_out_file
);
10071 ASM_OUTPUT_SECTION (asm_out_file
, BSS_SECTION
);
10072 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file
, BSS_END_LABEL
, 0);
10075 /* Output the source line correspondence table. */
10076 if (line_info_table_in_use
> 1 || separate_line_info_table_in_use
)
10078 fputc ('\n', asm_out_file
);
10079 ASM_OUTPUT_SECTION (asm_out_file
, DEBUG_LINE_SECTION
);
10080 output_line_info ();
10082 /* We can only use the low/high_pc attributes if all of the code
10084 if (separate_line_info_table_in_use
== 0)
10086 add_AT_lbl_id (comp_unit_die
, DW_AT_low_pc
, text_section_label
);
10087 add_AT_lbl_id (comp_unit_die
, DW_AT_high_pc
, text_end_label
);
10090 add_AT_lbl_offset (comp_unit_die
, DW_AT_stmt_list
,
10091 debug_line_section_label
);
10094 /* Output the abbreviation table. */
10095 fputc ('\n', asm_out_file
);
10096 ASM_OUTPUT_SECTION (asm_out_file
, ABBREV_SECTION
);
10097 build_abbrev_table (comp_unit_die
);
10098 output_abbrev_section ();
10100 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
10101 next_die_offset
= DWARF_COMPILE_UNIT_HEADER_SIZE
;
10102 calc_die_sizes (comp_unit_die
);
10104 /* Output debugging information. */
10105 fputc ('\n', asm_out_file
);
10106 ASM_OUTPUT_SECTION (asm_out_file
, DEBUG_INFO_SECTION
);
10107 output_compilation_unit_header ();
10108 output_die (comp_unit_die
);
10110 if (pubname_table_in_use
)
10112 /* Output public names table. */
10113 fputc ('\n', asm_out_file
);
10114 ASM_OUTPUT_SECTION (asm_out_file
, PUBNAMES_SECTION
);
10115 output_pubnames ();
10118 if (fde_table_in_use
)
10120 /* Output the address range information. */
10121 fputc ('\n', asm_out_file
);
10122 ASM_OUTPUT_SECTION (asm_out_file
, ARANGES_SECTION
);
10126 #endif /* DWARF2_DEBUGGING_INFO */