1 /* Output Dwarf2 format symbol table information from the GNU C compiler.
2 Copyright (C) 1992, 93, 95-98, 1999 Free Software Foundation, Inc.
3 Contributed by Gary Funck (gary@intrepid.com).
4 Derived from DWARF 1 implementation of Ron Guilmette (rfg@monkeys.com).
5 Extensively modified by Jason Merrill (jason@cygnus.com).
7 This file is part of GNU CC.
9 GNU CC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2, or (at your option)
14 GNU CC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GNU CC; see the file COPYING. If not, write to
21 the Free Software Foundation, 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
24 /* TODO: Implement .debug_str handling, and share entries somehow.
25 Eliminate duplicates by putting common info in a separate section
26 to be collected by the linker and referring to it with
28 Emit .debug_line header even when there are no functions, since
29 the file numbers are used by .debug_info. Alternately, leave
30 out locations for types and decls.
31 Avoid talking about ctors and op= for PODs.
32 Factor out common prologue sequences into multiple CIEs. */
34 /* The first part of this file deals with the DWARF 2 frame unwind
35 information, which is also used by the GCC efficient exception handling
36 mechanism. The second part, controlled only by an #ifdef
37 DWARF2_DEBUGGING_INFO, deals with the other DWARF 2 debugging
46 #include "hard-reg-set.h"
48 #include "insn-config.h"
54 #include "dwarf2out.h"
56 #include "dyn-string.h"
59 /* We cannot use <assert.h> in GCC source, since that would include
60 GCC's assert.h, which may not be compatible with the host compiler. */
65 # define assert(e) do { if (! (e)) abort (); } while (0)
69 #define DIR_SEPARATOR '/'
72 /* Decide whether we want to emit frame unwind information for the current
78 return (write_symbols
== DWARF2_DEBUG
79 #ifdef DWARF2_FRAME_INFO
82 #ifdef DWARF2_UNWIND_INFO
84 || (flag_exceptions
&& ! exceptions_via_longjmp
)
89 #if defined (DWARF2_DEBUGGING_INFO) || defined (DWARF2_UNWIND_INFO)
91 /* How to start an assembler comment. */
92 #ifndef ASM_COMMENT_START
93 #define ASM_COMMENT_START ";#"
96 typedef struct dw_cfi_struct
*dw_cfi_ref
;
97 typedef struct dw_fde_struct
*dw_fde_ref
;
98 typedef union dw_cfi_oprnd_struct
*dw_cfi_oprnd_ref
;
100 /* Call frames are described using a sequence of Call Frame
101 Information instructions. The register number, offset
102 and address fields are provided as possible operands;
103 their use is selected by the opcode field. */
105 typedef union dw_cfi_oprnd_struct
107 unsigned long dw_cfi_reg_num
;
108 long int dw_cfi_offset
;
113 typedef struct dw_cfi_struct
115 dw_cfi_ref dw_cfi_next
;
116 enum dwarf_call_frame_info dw_cfi_opc
;
117 dw_cfi_oprnd dw_cfi_oprnd1
;
118 dw_cfi_oprnd dw_cfi_oprnd2
;
122 /* All call frame descriptions (FDE's) in the GCC generated DWARF
123 refer to a single Common Information Entry (CIE), defined at
124 the beginning of the .debug_frame section. This used of a single
125 CIE obviates the need to keep track of multiple CIE's
126 in the DWARF generation routines below. */
128 typedef struct dw_fde_struct
131 char *dw_fde_current_label
;
133 dw_cfi_ref dw_fde_cfi
;
137 /* Maximum size (in bytes) of an artificially generated label. */
138 #define MAX_ARTIFICIAL_LABEL_BYTES 30
140 /* Make sure we know the sizes of the various types dwarf can describe. These
141 are only defaults. If the sizes are different for your target, you should
142 override these values by defining the appropriate symbols in your tm.h
145 #ifndef CHAR_TYPE_SIZE
146 #define CHAR_TYPE_SIZE BITS_PER_UNIT
149 #define PTR_SIZE (POINTER_SIZE / BITS_PER_UNIT)
152 /* The size in bytes of a DWARF field indicating an offset or length
153 relative to a debug info section, specified to be 4 bytes in the DWARF-2
154 specification. The SGI/MIPS ABI defines it to be the same as PTR_SIZE. */
156 #ifndef DWARF_OFFSET_SIZE
157 #define DWARF_OFFSET_SIZE 4
160 #define DWARF_VERSION 2
162 /* Round SIZE up to the nearest BOUNDARY. */
163 #define DWARF_ROUND(SIZE,BOUNDARY) \
164 (((SIZE) + (BOUNDARY) - 1) & ~((BOUNDARY) - 1))
166 /* Offsets recorded in opcodes are a multiple of this alignment factor. */
167 #ifdef STACK_GROWS_DOWNWARD
168 #define DWARF_CIE_DATA_ALIGNMENT (-UNITS_PER_WORD)
170 #define DWARF_CIE_DATA_ALIGNMENT UNITS_PER_WORD
173 /* A pointer to the base of a table that contains frame description
174 information for each routine. */
175 static dw_fde_ref fde_table
;
177 /* Number of elements currently allocated for fde_table. */
178 static unsigned fde_table_allocated
;
180 /* Number of elements in fde_table currently in use. */
181 static unsigned fde_table_in_use
;
183 /* Size (in elements) of increments by which we may expand the
185 #define FDE_TABLE_INCREMENT 256
187 /* A list of call frame insns for the CIE. */
188 static dw_cfi_ref cie_cfi_head
;
190 /* The number of the current function definition for which debugging
191 information is being generated. These numbers range from 1 up to the
192 maximum number of function definitions contained within the current
193 compilation unit. These numbers are used to create unique label id's
194 unique to each function definition. */
195 static unsigned current_funcdef_number
= 0;
197 /* Some DWARF extensions (e.g., MIPS/SGI) implement a subprogram
198 attribute that accelerates the lookup of the FDE associated
199 with the subprogram. This variable holds the table index of the FDE
200 associated with the current function (body) definition. */
201 static unsigned current_funcdef_fde
;
203 /* Forward declarations for functions defined in this file. */
205 static char *stripattributes
PROTO((const char *));
206 static const char *dwarf_cfi_name
PROTO((unsigned));
207 static dw_cfi_ref new_cfi
PROTO((void));
208 static void add_cfi
PROTO((dw_cfi_ref
*, dw_cfi_ref
));
209 static unsigned long size_of_uleb128
PROTO((unsigned long));
210 static unsigned long size_of_sleb128
PROTO((long));
211 static void output_uleb128
PROTO((unsigned long));
212 static void output_sleb128
PROTO((long));
213 static void add_fde_cfi
PROTO((char *, dw_cfi_ref
));
214 static void lookup_cfa_1
PROTO((dw_cfi_ref
, unsigned long *,
216 static void lookup_cfa
PROTO((unsigned long *, long *));
217 static void reg_save
PROTO((char *, unsigned, unsigned,
219 static void initial_return_save
PROTO((rtx
));
220 static void output_cfi
PROTO((dw_cfi_ref
, dw_fde_ref
));
221 static void output_call_frame_info
PROTO((int));
222 static unsigned reg_number
PROTO((rtx
));
223 static void dwarf2out_stack_adjust
PROTO((rtx
));
224 static void dwarf2out_frame_debug_expr
PROTO((rtx
, char *));
226 /* Definitions of defaults for assembler-dependent names of various
227 pseudo-ops and section names.
228 Theses may be overridden in the tm.h file (if necessary) for a particular
231 #ifdef OBJECT_FORMAT_ELF
232 #ifndef UNALIGNED_SHORT_ASM_OP
233 #define UNALIGNED_SHORT_ASM_OP ".2byte"
235 #ifndef UNALIGNED_INT_ASM_OP
236 #define UNALIGNED_INT_ASM_OP ".4byte"
238 #ifndef UNALIGNED_DOUBLE_INT_ASM_OP
239 #define UNALIGNED_DOUBLE_INT_ASM_OP ".8byte"
241 #endif /* OBJECT_FORMAT_ELF */
244 #define ASM_BYTE_OP ".byte"
247 /* Data and reference forms for relocatable data. */
248 #define DW_FORM_data (DWARF_OFFSET_SIZE == 8 ? DW_FORM_data8 : DW_FORM_data4)
249 #define DW_FORM_ref (DWARF_OFFSET_SIZE == 8 ? DW_FORM_ref8 : DW_FORM_ref4)
251 /* Pseudo-op for defining a new section. */
252 #ifndef SECTION_ASM_OP
253 #define SECTION_ASM_OP ".section"
256 /* The default format used by the ASM_OUTPUT_SECTION macro (see below) to
257 print the SECTION_ASM_OP and the section name. The default here works for
258 almost all svr4 assemblers, except for the sparc, where the section name
259 must be enclosed in double quotes. (See sparcv4.h). */
260 #ifndef SECTION_FORMAT
261 #ifdef PUSHSECTION_FORMAT
262 #define SECTION_FORMAT PUSHSECTION_FORMAT
264 #define SECTION_FORMAT "\t%s\t%s\n"
268 #ifndef FRAME_SECTION
269 #define FRAME_SECTION ".debug_frame"
272 #ifndef FUNC_BEGIN_LABEL
273 #define FUNC_BEGIN_LABEL "LFB"
275 #ifndef FUNC_END_LABEL
276 #define FUNC_END_LABEL "LFE"
278 #define CIE_AFTER_SIZE_LABEL "LSCIE"
279 #define CIE_END_LABEL "LECIE"
280 #define CIE_LENGTH_LABEL "LLCIE"
281 #define FDE_AFTER_SIZE_LABEL "LSFDE"
282 #define FDE_END_LABEL "LEFDE"
283 #define FDE_LENGTH_LABEL "LLFDE"
285 /* Definitions of defaults for various types of primitive assembly language
286 output operations. These may be overridden from within the tm.h file,
287 but typically, that is unnecessary. */
289 #ifndef ASM_OUTPUT_SECTION
290 #define ASM_OUTPUT_SECTION(FILE, SECTION) \
291 fprintf ((FILE), SECTION_FORMAT, SECTION_ASM_OP, SECTION)
294 #ifndef ASM_OUTPUT_DWARF_DATA1
295 #define ASM_OUTPUT_DWARF_DATA1(FILE,VALUE) \
296 fprintf ((FILE), "\t%s\t0x%x", ASM_BYTE_OP, (unsigned) (VALUE))
299 #ifndef ASM_OUTPUT_DWARF_DELTA1
300 #define ASM_OUTPUT_DWARF_DELTA1(FILE,LABEL1,LABEL2) \
301 do { fprintf ((FILE), "\t%s\t", ASM_BYTE_OP); \
302 assemble_name (FILE, LABEL1); \
303 fprintf (FILE, "-"); \
304 assemble_name (FILE, LABEL2); \
308 #ifdef UNALIGNED_INT_ASM_OP
310 #ifndef UNALIGNED_OFFSET_ASM_OP
311 #define UNALIGNED_OFFSET_ASM_OP \
312 (DWARF_OFFSET_SIZE == 8 ? UNALIGNED_DOUBLE_INT_ASM_OP : UNALIGNED_INT_ASM_OP)
315 #ifndef UNALIGNED_WORD_ASM_OP
316 #define UNALIGNED_WORD_ASM_OP \
317 (PTR_SIZE == 8 ? UNALIGNED_DOUBLE_INT_ASM_OP : UNALIGNED_INT_ASM_OP)
320 #ifndef ASM_OUTPUT_DWARF_DELTA2
321 #define ASM_OUTPUT_DWARF_DELTA2(FILE,LABEL1,LABEL2) \
322 do { fprintf ((FILE), "\t%s\t", UNALIGNED_SHORT_ASM_OP); \
323 assemble_name (FILE, LABEL1); \
324 fprintf (FILE, "-"); \
325 assemble_name (FILE, LABEL2); \
329 #ifndef ASM_OUTPUT_DWARF_DELTA4
330 #define ASM_OUTPUT_DWARF_DELTA4(FILE,LABEL1,LABEL2) \
331 do { fprintf ((FILE), "\t%s\t", UNALIGNED_INT_ASM_OP); \
332 assemble_name (FILE, LABEL1); \
333 fprintf (FILE, "-"); \
334 assemble_name (FILE, LABEL2); \
338 #ifndef ASM_OUTPUT_DWARF_DELTA
339 #define ASM_OUTPUT_DWARF_DELTA(FILE,LABEL1,LABEL2) \
340 do { fprintf ((FILE), "\t%s\t", UNALIGNED_OFFSET_ASM_OP); \
341 assemble_name (FILE, LABEL1); \
342 fprintf (FILE, "-"); \
343 assemble_name (FILE, LABEL2); \
347 #ifndef ASM_OUTPUT_DWARF_ADDR_DELTA
348 #define ASM_OUTPUT_DWARF_ADDR_DELTA(FILE,LABEL1,LABEL2) \
349 do { fprintf ((FILE), "\t%s\t", UNALIGNED_WORD_ASM_OP); \
350 assemble_name (FILE, LABEL1); \
351 fprintf (FILE, "-"); \
352 assemble_name (FILE, LABEL2); \
356 #ifndef ASM_OUTPUT_DWARF_ADDR
357 #define ASM_OUTPUT_DWARF_ADDR(FILE,LABEL) \
358 do { fprintf ((FILE), "\t%s\t", UNALIGNED_WORD_ASM_OP); \
359 assemble_name (FILE, LABEL); \
363 /* ??? This macro takes an RTX in dwarfout.c and a string in dwarf2out.c.
364 We resolve the conflict by creating a new macro ASM_OUTPUT_DWARF2_ADDR_CONST
365 for ports that want to support both DWARF1 and DWARF2. This needs a better
366 solution. See also the comments in sparc/sp64-elf.h. */
367 #ifdef ASM_OUTPUT_DWARF2_ADDR_CONST
368 #undef ASM_OUTPUT_DWARF_ADDR_CONST
369 #define ASM_OUTPUT_DWARF_ADDR_CONST(FILE,ADDR) \
370 ASM_OUTPUT_DWARF2_ADDR_CONST (FILE, ADDR)
373 #ifndef ASM_OUTPUT_DWARF_ADDR_CONST
374 #define ASM_OUTPUT_DWARF_ADDR_CONST(FILE,ADDR) \
375 fprintf ((FILE), "\t%s\t%s", UNALIGNED_WORD_ASM_OP, (ADDR))
378 #ifndef ASM_OUTPUT_DWARF_OFFSET4
379 #define ASM_OUTPUT_DWARF_OFFSET4(FILE,LABEL) \
380 do { fprintf ((FILE), "\t%s\t", UNALIGNED_INT_ASM_OP); \
381 assemble_name (FILE, LABEL); \
385 #ifndef ASM_OUTPUT_DWARF_OFFSET
386 #define ASM_OUTPUT_DWARF_OFFSET(FILE,LABEL) \
387 do { fprintf ((FILE), "\t%s\t", UNALIGNED_OFFSET_ASM_OP); \
388 assemble_name (FILE, LABEL); \
392 #ifndef ASM_OUTPUT_DWARF_DATA2
393 #define ASM_OUTPUT_DWARF_DATA2(FILE,VALUE) \
394 fprintf ((FILE), "\t%s\t0x%x", UNALIGNED_SHORT_ASM_OP, (unsigned) (VALUE))
397 #ifndef ASM_OUTPUT_DWARF_DATA4
398 #define ASM_OUTPUT_DWARF_DATA4(FILE,VALUE) \
399 fprintf ((FILE), "\t%s\t0x%x", UNALIGNED_INT_ASM_OP, (unsigned) (VALUE))
402 #ifndef ASM_OUTPUT_DWARF_DATA
403 #define ASM_OUTPUT_DWARF_DATA(FILE,VALUE) \
404 fprintf ((FILE), "\t%s\t0x%lx", UNALIGNED_OFFSET_ASM_OP, \
405 (unsigned long) (VALUE))
408 #ifndef ASM_OUTPUT_DWARF_ADDR_DATA
409 #define ASM_OUTPUT_DWARF_ADDR_DATA(FILE,VALUE) \
410 fprintf ((FILE), "\t%s\t0x%lx", UNALIGNED_WORD_ASM_OP, \
411 (unsigned long) (VALUE))
414 #ifndef ASM_OUTPUT_DWARF_DATA8
415 #define ASM_OUTPUT_DWARF_DATA8(FILE,HIGH_VALUE,LOW_VALUE) \
417 if (WORDS_BIG_ENDIAN) \
419 fprintf ((FILE), "\t%s\t0x%lx\n", UNALIGNED_INT_ASM_OP, (HIGH_VALUE));\
420 fprintf ((FILE), "\t%s\t0x%lx", UNALIGNED_INT_ASM_OP, (LOW_VALUE));\
424 fprintf ((FILE), "\t%s\t0x%lx\n", UNALIGNED_INT_ASM_OP, (LOW_VALUE)); \
425 fprintf ((FILE), "\t%s\t0x%lx", UNALIGNED_INT_ASM_OP, (HIGH_VALUE)); \
430 #else /* UNALIGNED_INT_ASM_OP */
432 /* We don't have unaligned support, let's hope the normal output works for
435 #define ASM_OUTPUT_DWARF_ADDR(FILE,LABEL) \
436 assemble_integer (gen_rtx_SYMBOL_REF (Pmode, LABEL), PTR_SIZE, 1)
438 #define ASM_OUTPUT_DWARF_OFFSET4(FILE,LABEL) \
439 assemble_integer (gen_rtx_SYMBOL_REF (SImode, LABEL), 4, 1)
441 #define ASM_OUTPUT_DWARF_OFFSET(FILE,LABEL) \
442 assemble_integer (gen_rtx_SYMBOL_REF (SImode, LABEL), 4, 1)
444 #define ASM_OUTPUT_DWARF_DELTA2(FILE,LABEL1,LABEL2) \
445 assemble_integer (gen_rtx_MINUS (HImode, \
446 gen_rtx_SYMBOL_REF (Pmode, LABEL1), \
447 gen_rtx_SYMBOL_REF (Pmode, LABEL2)), \
450 #define ASM_OUTPUT_DWARF_DELTA4(FILE,LABEL1,LABEL2) \
451 assemble_integer (gen_rtx_MINUS (SImode, \
452 gen_rtx_SYMBOL_REF (Pmode, LABEL1), \
453 gen_rtx_SYMBOL_REF (Pmode, LABEL2)), \
456 #define ASM_OUTPUT_DWARF_ADDR_DELTA(FILE,LABEL1,LABEL2) \
457 assemble_integer (gen_rtx_MINUS (Pmode, \
458 gen_rtx_SYMBOL_REF (Pmode, LABEL1), \
459 gen_rtx_SYMBOL_REF (Pmode, LABEL2)), \
462 #define ASM_OUTPUT_DWARF_DELTA(FILE,LABEL1,LABEL2) \
463 ASM_OUTPUT_DWARF_DELTA4 (FILE,LABEL1,LABEL2)
465 #define ASM_OUTPUT_DWARF_DATA4(FILE,VALUE) \
466 assemble_integer (GEN_INT (VALUE), 4, 1)
468 #endif /* UNALIGNED_INT_ASM_OP */
471 #ifndef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
472 #define ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL(FILE, SY, HI, LO) \
474 fprintf (FILE, "\t%s\t", SET_ASM_OP); \
475 assemble_name (FILE, SY); \
477 assemble_name (FILE, HI); \
479 assemble_name (FILE, LO); \
482 #endif /* SET_ASM_OP */
484 /* This is similar to the default ASM_OUTPUT_ASCII, except that no trailing
485 newline is produced. When flag_debug_asm is asserted, we add commentary
486 at the end of the line, so we must avoid output of a newline here. */
487 #ifndef ASM_OUTPUT_DWARF_STRING
488 #define ASM_OUTPUT_DWARF_STRING(FILE,P) \
490 register int slen = strlen(P); \
491 register const char *p = (P); \
493 fprintf (FILE, "\t.ascii \""); \
494 for (i = 0; i < slen; i++) \
496 register int c = p[i]; \
497 if (c == '\"' || c == '\\') \
503 fprintf (FILE, "\\%o", c); \
506 fprintf (FILE, "\\0\""); \
511 /* The DWARF 2 CFA column which tracks the return address. Normally this
512 is the column for PC, or the first column after all of the hard
514 #ifndef DWARF_FRAME_RETURN_COLUMN
516 #define DWARF_FRAME_RETURN_COLUMN DWARF_FRAME_REGNUM (PC_REGNUM)
518 #define DWARF_FRAME_RETURN_COLUMN FIRST_PSEUDO_REGISTER
522 /* The mapping from gcc register number to DWARF 2 CFA column number. By
523 default, we just provide columns for all registers. */
524 #ifndef DWARF_FRAME_REGNUM
525 #define DWARF_FRAME_REGNUM(REG) DBX_REGISTER_NUMBER (REG)
528 /* Hook used by __throw. */
531 expand_builtin_dwarf_fp_regnum ()
533 return GEN_INT (DWARF_FRAME_REGNUM (HARD_FRAME_POINTER_REGNUM
));
536 /* The offset from the incoming value of %sp to the top of the stack frame
537 for the current function. */
538 #ifndef INCOMING_FRAME_SP_OFFSET
539 #define INCOMING_FRAME_SP_OFFSET 0
542 /* Return a pointer to a copy of the section string name S with all
543 attributes stripped off, and an asterisk prepended (for assemble_name). */
549 char *stripped
= xmalloc (strlen (s
) + 2);
554 while (*s
&& *s
!= ',')
561 /* Return the register number described by a given RTL node. */
567 register unsigned regno
= REGNO (rtl
);
569 if (regno
>= FIRST_PSEUDO_REGISTER
)
571 warning ("internal regno botch: regno = %d\n", regno
);
575 regno
= DBX_REGISTER_NUMBER (regno
);
579 /* Generate code to initialize the register size table. */
582 expand_builtin_init_dwarf_reg_sizes (address
)
586 enum machine_mode mode
= TYPE_MODE (char_type_node
);
587 rtx addr
= expand_expr (address
, NULL_RTX
, VOIDmode
, 0);
588 rtx mem
= gen_rtx_MEM (mode
, addr
);
590 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; ++i
)
592 int offset
= i
* GET_MODE_SIZE (mode
);
593 int size
= GET_MODE_SIZE (reg_raw_mode
[i
]);
595 emit_move_insn (change_address (mem
, mode
,
596 plus_constant (addr
, offset
)),
601 /* Convert a DWARF call frame info. operation to its string name */
604 dwarf_cfi_name (cfi_opc
)
605 register unsigned cfi_opc
;
609 case DW_CFA_advance_loc
:
610 return "DW_CFA_advance_loc";
612 return "DW_CFA_offset";
614 return "DW_CFA_restore";
618 return "DW_CFA_set_loc";
619 case DW_CFA_advance_loc1
:
620 return "DW_CFA_advance_loc1";
621 case DW_CFA_advance_loc2
:
622 return "DW_CFA_advance_loc2";
623 case DW_CFA_advance_loc4
:
624 return "DW_CFA_advance_loc4";
625 case DW_CFA_offset_extended
:
626 return "DW_CFA_offset_extended";
627 case DW_CFA_restore_extended
:
628 return "DW_CFA_restore_extended";
629 case DW_CFA_undefined
:
630 return "DW_CFA_undefined";
631 case DW_CFA_same_value
:
632 return "DW_CFA_same_value";
633 case DW_CFA_register
:
634 return "DW_CFA_register";
635 case DW_CFA_remember_state
:
636 return "DW_CFA_remember_state";
637 case DW_CFA_restore_state
:
638 return "DW_CFA_restore_state";
640 return "DW_CFA_def_cfa";
641 case DW_CFA_def_cfa_register
:
642 return "DW_CFA_def_cfa_register";
643 case DW_CFA_def_cfa_offset
:
644 return "DW_CFA_def_cfa_offset";
646 /* SGI/MIPS specific */
647 case DW_CFA_MIPS_advance_loc8
:
648 return "DW_CFA_MIPS_advance_loc8";
651 case DW_CFA_GNU_window_save
:
652 return "DW_CFA_GNU_window_save";
653 case DW_CFA_GNU_args_size
:
654 return "DW_CFA_GNU_args_size";
657 return "DW_CFA_<unknown>";
661 /* Return a pointer to a newly allocated Call Frame Instruction. */
663 static inline dw_cfi_ref
666 register dw_cfi_ref cfi
= (dw_cfi_ref
) xmalloc (sizeof (dw_cfi_node
));
668 cfi
->dw_cfi_next
= NULL
;
669 cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
= 0;
670 cfi
->dw_cfi_oprnd2
.dw_cfi_reg_num
= 0;
675 /* Add a Call Frame Instruction to list of instructions. */
678 add_cfi (list_head
, cfi
)
679 register dw_cfi_ref
*list_head
;
680 register dw_cfi_ref cfi
;
682 register dw_cfi_ref
*p
;
684 /* Find the end of the chain. */
685 for (p
= list_head
; (*p
) != NULL
; p
= &(*p
)->dw_cfi_next
)
691 /* Generate a new label for the CFI info to refer to. */
694 dwarf2out_cfi_label ()
696 static char label
[20];
697 static unsigned long label_num
= 0;
699 ASM_GENERATE_INTERNAL_LABEL (label
, "LCFI", label_num
++);
700 ASM_OUTPUT_LABEL (asm_out_file
, label
);
705 /* Add CFI to the current fde at the PC value indicated by LABEL if specified,
706 or to the CIE if LABEL is NULL. */
709 add_fde_cfi (label
, cfi
)
710 register char *label
;
711 register dw_cfi_ref cfi
;
715 register dw_fde_ref fde
= &fde_table
[fde_table_in_use
- 1];
718 label
= dwarf2out_cfi_label ();
720 if (fde
->dw_fde_current_label
== NULL
721 || strcmp (label
, fde
->dw_fde_current_label
) != 0)
723 register dw_cfi_ref xcfi
;
725 fde
->dw_fde_current_label
= label
= xstrdup (label
);
727 /* Set the location counter to the new label. */
729 xcfi
->dw_cfi_opc
= DW_CFA_advance_loc4
;
730 xcfi
->dw_cfi_oprnd1
.dw_cfi_addr
= label
;
731 add_cfi (&fde
->dw_fde_cfi
, xcfi
);
734 add_cfi (&fde
->dw_fde_cfi
, cfi
);
738 add_cfi (&cie_cfi_head
, cfi
);
741 /* Subroutine of lookup_cfa. */
744 lookup_cfa_1 (cfi
, regp
, offsetp
)
745 register dw_cfi_ref cfi
;
746 register unsigned long *regp
;
747 register long *offsetp
;
749 switch (cfi
->dw_cfi_opc
)
751 case DW_CFA_def_cfa_offset
:
752 *offsetp
= cfi
->dw_cfi_oprnd1
.dw_cfi_offset
;
754 case DW_CFA_def_cfa_register
:
755 *regp
= cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
;
758 *regp
= cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
;
759 *offsetp
= cfi
->dw_cfi_oprnd2
.dw_cfi_offset
;
766 /* Find the previous value for the CFA. */
769 lookup_cfa (regp
, offsetp
)
770 register unsigned long *regp
;
771 register long *offsetp
;
773 register dw_cfi_ref cfi
;
775 *regp
= (unsigned long) -1;
778 for (cfi
= cie_cfi_head
; cfi
; cfi
= cfi
->dw_cfi_next
)
779 lookup_cfa_1 (cfi
, regp
, offsetp
);
781 if (fde_table_in_use
)
783 register dw_fde_ref fde
= &fde_table
[fde_table_in_use
- 1];
784 for (cfi
= fde
->dw_fde_cfi
; cfi
; cfi
= cfi
->dw_cfi_next
)
785 lookup_cfa_1 (cfi
, regp
, offsetp
);
789 /* The current rule for calculating the DWARF2 canonical frame address. */
790 static unsigned long cfa_reg
;
791 static long cfa_offset
;
793 /* The register used for saving registers to the stack, and its offset
795 static unsigned cfa_store_reg
;
796 static long cfa_store_offset
;
798 /* The running total of the size of arguments pushed onto the stack. */
799 static long args_size
;
801 /* The last args_size we actually output. */
802 static long old_args_size
;
804 /* Entry point to update the canonical frame address (CFA).
805 LABEL is passed to add_fde_cfi. The value of CFA is now to be
806 calculated from REG+OFFSET. */
809 dwarf2out_def_cfa (label
, reg
, offset
)
810 register char *label
;
811 register unsigned reg
;
812 register long offset
;
814 register dw_cfi_ref cfi
;
815 unsigned long old_reg
;
820 if (cfa_store_reg
== reg
)
821 cfa_store_offset
= offset
;
823 reg
= DWARF_FRAME_REGNUM (reg
);
824 lookup_cfa (&old_reg
, &old_offset
);
826 if (reg
== old_reg
&& offset
== old_offset
)
833 cfi
->dw_cfi_opc
= DW_CFA_def_cfa_offset
;
834 cfi
->dw_cfi_oprnd1
.dw_cfi_offset
= offset
;
837 #ifndef MIPS_DEBUGGING_INFO /* SGI dbx thinks this means no offset. */
838 else if (offset
== old_offset
&& old_reg
!= (unsigned long) -1)
840 cfi
->dw_cfi_opc
= DW_CFA_def_cfa_register
;
841 cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
= reg
;
847 cfi
->dw_cfi_opc
= DW_CFA_def_cfa
;
848 cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
= reg
;
849 cfi
->dw_cfi_oprnd2
.dw_cfi_offset
= offset
;
852 add_fde_cfi (label
, cfi
);
855 /* Add the CFI for saving a register. REG is the CFA column number.
856 LABEL is passed to add_fde_cfi.
857 If SREG is -1, the register is saved at OFFSET from the CFA;
858 otherwise it is saved in SREG. */
861 reg_save (label
, reg
, sreg
, offset
)
862 register char * label
;
863 register unsigned reg
;
864 register unsigned sreg
;
865 register long offset
;
867 register dw_cfi_ref cfi
= new_cfi ();
869 cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
= reg
;
871 /* The following comparison is correct. -1 is used to indicate that
872 the value isn't a register number. */
873 if (sreg
== (unsigned int) -1)
876 /* The register number won't fit in 6 bits, so we have to use
878 cfi
->dw_cfi_opc
= DW_CFA_offset_extended
;
880 cfi
->dw_cfi_opc
= DW_CFA_offset
;
882 offset
/= DWARF_CIE_DATA_ALIGNMENT
;
885 cfi
->dw_cfi_oprnd2
.dw_cfi_offset
= offset
;
889 cfi
->dw_cfi_opc
= DW_CFA_register
;
890 cfi
->dw_cfi_oprnd2
.dw_cfi_reg_num
= sreg
;
893 add_fde_cfi (label
, cfi
);
896 /* Add the CFI for saving a register window. LABEL is passed to reg_save.
897 This CFI tells the unwinder that it needs to restore the window registers
898 from the previous frame's window save area.
900 ??? Perhaps we should note in the CIE where windows are saved (instead of
901 assuming 0(cfa)) and what registers are in the window. */
904 dwarf2out_window_save (label
)
905 register char * label
;
907 register dw_cfi_ref cfi
= new_cfi ();
908 cfi
->dw_cfi_opc
= DW_CFA_GNU_window_save
;
909 add_fde_cfi (label
, cfi
);
912 /* Add a CFI to update the running total of the size of arguments
913 pushed onto the stack. */
916 dwarf2out_args_size (label
, size
)
920 register dw_cfi_ref cfi
;
922 if (size
== old_args_size
)
924 old_args_size
= size
;
927 cfi
->dw_cfi_opc
= DW_CFA_GNU_args_size
;
928 cfi
->dw_cfi_oprnd1
.dw_cfi_offset
= size
;
929 add_fde_cfi (label
, cfi
);
932 /* Entry point for saving a register to the stack. REG is the GCC register
933 number. LABEL and OFFSET are passed to reg_save. */
936 dwarf2out_reg_save (label
, reg
, offset
)
937 register char * label
;
938 register unsigned reg
;
939 register long offset
;
941 reg_save (label
, DWARF_FRAME_REGNUM (reg
), -1, offset
);
944 /* Entry point for saving the return address in the stack.
945 LABEL and OFFSET are passed to reg_save. */
948 dwarf2out_return_save (label
, offset
)
949 register char * label
;
950 register long offset
;
952 reg_save (label
, DWARF_FRAME_RETURN_COLUMN
, -1, offset
);
955 /* Entry point for saving the return address in a register.
956 LABEL and SREG are passed to reg_save. */
959 dwarf2out_return_reg (label
, sreg
)
960 register char * label
;
961 register unsigned sreg
;
963 reg_save (label
, DWARF_FRAME_RETURN_COLUMN
, sreg
, 0);
966 /* Record the initial position of the return address. RTL is
967 INCOMING_RETURN_ADDR_RTX. */
970 initial_return_save (rtl
)
973 unsigned int reg
= (unsigned int) -1;
976 switch (GET_CODE (rtl
))
979 /* RA is in a register. */
980 reg
= reg_number (rtl
);
983 /* RA is on the stack. */
985 switch (GET_CODE (rtl
))
988 if (REGNO (rtl
) != STACK_POINTER_REGNUM
)
993 if (REGNO (XEXP (rtl
, 0)) != STACK_POINTER_REGNUM
)
995 offset
= INTVAL (XEXP (rtl
, 1));
998 if (REGNO (XEXP (rtl
, 0)) != STACK_POINTER_REGNUM
)
1000 offset
= -INTVAL (XEXP (rtl
, 1));
1007 /* The return address is at some offset from any value we can
1008 actually load. For instance, on the SPARC it is in %i7+8. Just
1009 ignore the offset for now; it doesn't matter for unwinding frames. */
1010 if (GET_CODE (XEXP (rtl
, 1)) != CONST_INT
)
1012 initial_return_save (XEXP (rtl
, 0));
1018 reg_save (NULL
, DWARF_FRAME_RETURN_COLUMN
, reg
, offset
- cfa_offset
);
1021 /* Check INSN to see if it looks like a push or a stack adjustment, and
1022 make a note of it if it does. EH uses this information to find out how
1023 much extra space it needs to pop off the stack. */
1026 dwarf2out_stack_adjust (insn
)
1032 if (! asynchronous_exceptions
&& GET_CODE (insn
) == CALL_INSN
)
1034 /* Extract the size of the args from the CALL rtx itself. */
1036 insn
= PATTERN (insn
);
1037 if (GET_CODE (insn
) == PARALLEL
)
1038 insn
= XVECEXP (insn
, 0, 0);
1039 if (GET_CODE (insn
) == SET
)
1040 insn
= SET_SRC (insn
);
1041 assert (GET_CODE (insn
) == CALL
);
1042 dwarf2out_args_size ("", INTVAL (XEXP (insn
, 1)));
1046 /* If only calls can throw, and we have a frame pointer,
1047 save up adjustments until we see the CALL_INSN. */
1048 else if (! asynchronous_exceptions
1049 && cfa_reg
!= STACK_POINTER_REGNUM
)
1052 if (GET_CODE (insn
) == BARRIER
)
1054 /* When we see a BARRIER, we know to reset args_size to 0. Usually
1055 the compiler will have already emitted a stack adjustment, but
1056 doesn't bother for calls to noreturn functions. */
1057 #ifdef STACK_GROWS_DOWNWARD
1058 offset
= -args_size
;
1063 else if (GET_CODE (PATTERN (insn
)) == SET
)
1068 insn
= PATTERN (insn
);
1069 src
= SET_SRC (insn
);
1070 dest
= SET_DEST (insn
);
1072 if (dest
== stack_pointer_rtx
)
1074 /* (set (reg sp) (plus (reg sp) (const_int))) */
1075 code
= GET_CODE (src
);
1076 if (! (code
== PLUS
|| code
== MINUS
)
1077 || XEXP (src
, 0) != stack_pointer_rtx
1078 || GET_CODE (XEXP (src
, 1)) != CONST_INT
)
1081 offset
= INTVAL (XEXP (src
, 1));
1083 else if (GET_CODE (dest
) == MEM
)
1085 /* (set (mem (pre_dec (reg sp))) (foo)) */
1086 src
= XEXP (dest
, 0);
1087 code
= GET_CODE (src
);
1089 if (! (code
== PRE_DEC
|| code
== PRE_INC
)
1090 || XEXP (src
, 0) != stack_pointer_rtx
)
1093 offset
= GET_MODE_SIZE (GET_MODE (dest
));
1098 if (code
== PLUS
|| code
== PRE_INC
)
1107 if (cfa_reg
== STACK_POINTER_REGNUM
)
1108 cfa_offset
+= offset
;
1110 #ifndef STACK_GROWS_DOWNWARD
1113 args_size
+= offset
;
1117 label
= dwarf2out_cfi_label ();
1118 dwarf2out_def_cfa (label
, cfa_reg
, cfa_offset
);
1119 dwarf2out_args_size (label
, args_size
);
1122 /* A temporary register used in adjusting SP or setting up the store_reg. */
1123 static unsigned cfa_temp_reg
;
1125 /* A temporary value used in adjusting SP or setting up the store_reg. */
1126 static long cfa_temp_value
;
1128 /* Record call frame debugging information for an expression, which either
1129 sets SP or FP (adjusting how we calculate the frame address) or saves a
1130 register to the stack. */
1133 dwarf2out_frame_debug_expr (expr
, label
)
1140 /* If RTX_FRAME_RELATED_P is set on a PARALLEL, process each member of
1141 the PARALLEL independantly. The first element is always processed if
1142 it is a SET. This is for backward compatability. Other elements
1143 are processed only if they are SETs and the RTX_FRAME_RELATED_P
1144 flag is set in them. */
1146 if (GET_CODE (expr
) == PARALLEL
)
1149 int limit
= XVECLEN (expr
, 0);
1151 for (par_index
= 0; par_index
< limit
; par_index
++)
1153 rtx x
= XVECEXP (expr
, 0, par_index
);
1155 if (GET_CODE (x
) == SET
&&
1156 (RTX_FRAME_RELATED_P (x
) || par_index
== 0))
1157 dwarf2out_frame_debug_expr (x
, label
);
1162 if (GET_CODE (expr
) != SET
)
1165 src
= SET_SRC (expr
);
1166 dest
= SET_DEST (expr
);
1168 switch (GET_CODE (dest
))
1171 /* Update the CFA rule wrt SP or FP. Make sure src is
1172 relative to the current CFA register. */
1173 switch (GET_CODE (src
))
1175 /* Setting FP from SP. */
1177 if (cfa_reg
!= (unsigned) REGNO (src
))
1179 if (REGNO (dest
) != STACK_POINTER_REGNUM
1180 && !(frame_pointer_needed
1181 && REGNO (dest
) == HARD_FRAME_POINTER_REGNUM
))
1183 cfa_reg
= REGNO (dest
);
1188 if (dest
== stack_pointer_rtx
)
1191 switch (GET_CODE (XEXP (src
, 1)))
1194 offset
= INTVAL (XEXP (src
, 1));
1197 if ((unsigned) REGNO (XEXP (src
, 1)) != cfa_temp_reg
)
1199 offset
= cfa_temp_value
;
1205 if (XEXP (src
, 0) == hard_frame_pointer_rtx
)
1207 /* Restoring SP from FP in the epilogue. */
1208 if (cfa_reg
!= (unsigned) HARD_FRAME_POINTER_REGNUM
)
1210 cfa_reg
= STACK_POINTER_REGNUM
;
1212 else if (XEXP (src
, 0) != stack_pointer_rtx
)
1215 if (GET_CODE (src
) == PLUS
)
1217 if (cfa_reg
== STACK_POINTER_REGNUM
)
1218 cfa_offset
+= offset
;
1219 if (cfa_store_reg
== STACK_POINTER_REGNUM
)
1220 cfa_store_offset
+= offset
;
1222 else if (dest
== hard_frame_pointer_rtx
)
1224 /* Either setting the FP from an offset of the SP,
1225 or adjusting the FP */
1226 if (! frame_pointer_needed
1227 || REGNO (dest
) != HARD_FRAME_POINTER_REGNUM
)
1230 if (XEXP (src
, 0) == stack_pointer_rtx
1231 && GET_CODE (XEXP (src
, 1)) == CONST_INT
)
1233 if (cfa_reg
!= STACK_POINTER_REGNUM
)
1235 offset
= INTVAL (XEXP (src
, 1));
1236 if (GET_CODE (src
) == PLUS
)
1238 cfa_offset
+= offset
;
1239 cfa_reg
= HARD_FRAME_POINTER_REGNUM
;
1241 else if (XEXP (src
, 0) == hard_frame_pointer_rtx
1242 && GET_CODE (XEXP (src
, 1)) == CONST_INT
)
1244 if (cfa_reg
!= (unsigned) HARD_FRAME_POINTER_REGNUM
)
1246 offset
= INTVAL (XEXP (src
, 1));
1247 if (GET_CODE (src
) == PLUS
)
1249 cfa_offset
+= offset
;
1257 if (GET_CODE (src
) != PLUS
1258 || XEXP (src
, 1) != stack_pointer_rtx
)
1260 if (GET_CODE (XEXP (src
, 0)) != REG
1261 || (unsigned) REGNO (XEXP (src
, 0)) != cfa_temp_reg
)
1263 if (cfa_reg
!= STACK_POINTER_REGNUM
)
1265 cfa_store_reg
= REGNO (dest
);
1266 cfa_store_offset
= cfa_offset
- cfa_temp_value
;
1271 cfa_temp_reg
= REGNO (dest
);
1272 cfa_temp_value
= INTVAL (src
);
1276 if (GET_CODE (XEXP (src
, 0)) != REG
1277 || (unsigned) REGNO (XEXP (src
, 0)) != cfa_temp_reg
1278 || (unsigned) REGNO (dest
) != cfa_temp_reg
1279 || GET_CODE (XEXP (src
, 1)) != CONST_INT
)
1281 cfa_temp_value
|= INTVAL (XEXP (src
, 1));
1287 dwarf2out_def_cfa (label
, cfa_reg
, cfa_offset
);
1291 /* Saving a register to the stack. Make sure dest is relative to the
1293 if (GET_CODE (src
) != REG
)
1295 switch (GET_CODE (XEXP (dest
, 0)))
1300 offset
= GET_MODE_SIZE (GET_MODE (dest
));
1301 if (GET_CODE (XEXP (dest
, 0)) == PRE_INC
)
1304 if (REGNO (XEXP (XEXP (dest
, 0), 0)) != STACK_POINTER_REGNUM
1305 || cfa_store_reg
!= STACK_POINTER_REGNUM
)
1307 cfa_store_offset
+= offset
;
1308 if (cfa_reg
== STACK_POINTER_REGNUM
)
1309 cfa_offset
= cfa_store_offset
;
1311 offset
= -cfa_store_offset
;
1314 /* With an offset. */
1317 offset
= INTVAL (XEXP (XEXP (dest
, 0), 1));
1318 if (GET_CODE (XEXP (dest
, 0)) == MINUS
)
1321 if (cfa_store_reg
!= (unsigned) REGNO (XEXP (XEXP (dest
, 0), 0)))
1323 offset
-= cfa_store_offset
;
1326 /* Without an offset. */
1328 if (cfa_store_reg
!= (unsigned) REGNO (XEXP (dest
, 0)))
1330 offset
= -cfa_store_offset
;
1336 dwarf2out_def_cfa (label
, cfa_reg
, cfa_offset
);
1337 dwarf2out_reg_save (label
, REGNO (src
), offset
);
1346 /* Record call frame debugging information for INSN, which either
1347 sets SP or FP (adjusting how we calculate the frame address) or saves a
1348 register to the stack. If INSN is NULL_RTX, initialize our state. */
1351 dwarf2out_frame_debug (insn
)
1357 if (insn
== NULL_RTX
)
1359 /* Set up state for generating call frame debug info. */
1360 lookup_cfa (&cfa_reg
, &cfa_offset
);
1361 if (cfa_reg
!= DWARF_FRAME_REGNUM (STACK_POINTER_REGNUM
))
1363 cfa_reg
= STACK_POINTER_REGNUM
;
1364 cfa_store_reg
= cfa_reg
;
1365 cfa_store_offset
= cfa_offset
;
1371 if (! RTX_FRAME_RELATED_P (insn
))
1373 dwarf2out_stack_adjust (insn
);
1377 label
= dwarf2out_cfi_label ();
1379 src
= find_reg_note (insn
, REG_FRAME_RELATED_EXPR
, NULL_RTX
);
1381 insn
= XEXP (src
, 0);
1383 insn
= PATTERN (insn
);
1385 dwarf2out_frame_debug_expr (insn
, label
);
1388 /* Return the size of an unsigned LEB128 quantity. */
1390 static inline unsigned long
1391 size_of_uleb128 (value
)
1392 register unsigned long value
;
1394 register unsigned long size
= 0;
1395 register unsigned byte
;
1399 byte
= (value
& 0x7f);
1408 /* Return the size of a signed LEB128 quantity. */
1410 static inline unsigned long
1411 size_of_sleb128 (value
)
1412 register long value
;
1414 register unsigned long size
= 0;
1415 register unsigned byte
;
1419 byte
= (value
& 0x7f);
1423 while (!(((value
== 0) && ((byte
& 0x40) == 0))
1424 || ((value
== -1) && ((byte
& 0x40) != 0))));
1429 /* Output an unsigned LEB128 quantity. */
1432 output_uleb128 (value
)
1433 register unsigned long value
;
1435 unsigned long save_value
= value
;
1437 fprintf (asm_out_file
, "\t%s\t", ASM_BYTE_OP
);
1440 register unsigned byte
= (value
& 0x7f);
1443 /* More bytes to follow. */
1446 fprintf (asm_out_file
, "0x%x", byte
);
1448 fprintf (asm_out_file
, ",");
1453 fprintf (asm_out_file
, "\t%s ULEB128 0x%lx", ASM_COMMENT_START
, save_value
);
1456 /* Output an signed LEB128 quantity. */
1459 output_sleb128 (value
)
1460 register long value
;
1463 register unsigned byte
;
1464 long save_value
= value
;
1466 fprintf (asm_out_file
, "\t%s\t", ASM_BYTE_OP
);
1469 byte
= (value
& 0x7f);
1470 /* arithmetic shift */
1472 more
= !((((value
== 0) && ((byte
& 0x40) == 0))
1473 || ((value
== -1) && ((byte
& 0x40) != 0))));
1477 fprintf (asm_out_file
, "0x%x", byte
);
1479 fprintf (asm_out_file
, ",");
1484 fprintf (asm_out_file
, "\t%s SLEB128 %ld", ASM_COMMENT_START
, save_value
);
1487 /* Output a Call Frame Information opcode and its operand(s). */
1490 output_cfi (cfi
, fde
)
1491 register dw_cfi_ref cfi
;
1492 register dw_fde_ref fde
;
1494 if (cfi
->dw_cfi_opc
== DW_CFA_advance_loc
)
1496 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
,
1498 | (cfi
->dw_cfi_oprnd1
.dw_cfi_offset
& 0x3f));
1500 fprintf (asm_out_file
, "\t%s DW_CFA_advance_loc 0x%lx",
1501 ASM_COMMENT_START
, cfi
->dw_cfi_oprnd1
.dw_cfi_offset
);
1502 fputc ('\n', asm_out_file
);
1505 else if (cfi
->dw_cfi_opc
== DW_CFA_offset
)
1507 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
,
1509 | (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
& 0x3f));
1511 fprintf (asm_out_file
, "\t%s DW_CFA_offset, column 0x%lx",
1512 ASM_COMMENT_START
, cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
);
1514 fputc ('\n', asm_out_file
);
1515 output_uleb128 (cfi
->dw_cfi_oprnd2
.dw_cfi_offset
);
1516 fputc ('\n', asm_out_file
);
1518 else if (cfi
->dw_cfi_opc
== DW_CFA_restore
)
1520 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
,
1522 | (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
& 0x3f));
1524 fprintf (asm_out_file
, "\t%s DW_CFA_restore, column 0x%lx",
1525 ASM_COMMENT_START
, cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
);
1527 fputc ('\n', asm_out_file
);
1531 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, cfi
->dw_cfi_opc
);
1533 fprintf (asm_out_file
, "\t%s %s", ASM_COMMENT_START
,
1534 dwarf_cfi_name (cfi
->dw_cfi_opc
));
1536 fputc ('\n', asm_out_file
);
1537 switch (cfi
->dw_cfi_opc
)
1539 case DW_CFA_set_loc
:
1540 ASM_OUTPUT_DWARF_ADDR (asm_out_file
, cfi
->dw_cfi_oprnd1
.dw_cfi_addr
);
1541 fputc ('\n', asm_out_file
);
1543 case DW_CFA_advance_loc1
:
1544 ASM_OUTPUT_DWARF_DELTA1 (asm_out_file
,
1545 cfi
->dw_cfi_oprnd1
.dw_cfi_addr
,
1546 fde
->dw_fde_current_label
);
1547 fputc ('\n', asm_out_file
);
1548 fde
->dw_fde_current_label
= cfi
->dw_cfi_oprnd1
.dw_cfi_addr
;
1550 case DW_CFA_advance_loc2
:
1551 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file
,
1552 cfi
->dw_cfi_oprnd1
.dw_cfi_addr
,
1553 fde
->dw_fde_current_label
);
1554 fputc ('\n', asm_out_file
);
1555 fde
->dw_fde_current_label
= cfi
->dw_cfi_oprnd1
.dw_cfi_addr
;
1557 case DW_CFA_advance_loc4
:
1558 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file
,
1559 cfi
->dw_cfi_oprnd1
.dw_cfi_addr
,
1560 fde
->dw_fde_current_label
);
1561 fputc ('\n', asm_out_file
);
1562 fde
->dw_fde_current_label
= cfi
->dw_cfi_oprnd1
.dw_cfi_addr
;
1564 #ifdef MIPS_DEBUGGING_INFO
1565 case DW_CFA_MIPS_advance_loc8
:
1566 /* TODO: not currently implemented. */
1570 case DW_CFA_offset_extended
:
1571 case DW_CFA_def_cfa
:
1572 output_uleb128 (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
);
1573 fputc ('\n', asm_out_file
);
1574 output_uleb128 (cfi
->dw_cfi_oprnd2
.dw_cfi_offset
);
1575 fputc ('\n', asm_out_file
);
1577 case DW_CFA_restore_extended
:
1578 case DW_CFA_undefined
:
1579 output_uleb128 (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
);
1580 fputc ('\n', asm_out_file
);
1582 case DW_CFA_same_value
:
1583 case DW_CFA_def_cfa_register
:
1584 output_uleb128 (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
);
1585 fputc ('\n', asm_out_file
);
1587 case DW_CFA_register
:
1588 output_uleb128 (cfi
->dw_cfi_oprnd1
.dw_cfi_reg_num
);
1589 fputc ('\n', asm_out_file
);
1590 output_uleb128 (cfi
->dw_cfi_oprnd2
.dw_cfi_reg_num
);
1591 fputc ('\n', asm_out_file
);
1593 case DW_CFA_def_cfa_offset
:
1594 output_uleb128 (cfi
->dw_cfi_oprnd1
.dw_cfi_offset
);
1595 fputc ('\n', asm_out_file
);
1597 case DW_CFA_GNU_window_save
:
1599 case DW_CFA_GNU_args_size
:
1600 output_uleb128 (cfi
->dw_cfi_oprnd1
.dw_cfi_offset
);
1601 fputc ('\n', asm_out_file
);
1609 /* Output the call frame information used to used to record information
1610 that relates to calculating the frame pointer, and records the
1611 location of saved registers. */
1614 output_call_frame_info (for_eh
)
1617 register unsigned long i
;
1618 register dw_fde_ref fde
;
1619 register dw_cfi_ref cfi
;
1620 char l1
[20], l2
[20];
1621 #ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
1625 /* Do we want to include a pointer to the exception table? */
1626 int eh_ptr
= for_eh
&& exception_table_p ();
1628 fputc ('\n', asm_out_file
);
1630 /* We're going to be generating comments, so turn on app. */
1636 #ifdef EH_FRAME_SECTION
1637 EH_FRAME_SECTION ();
1639 tree label
= get_file_function_name ('F');
1641 force_data_section ();
1642 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (PTR_SIZE
));
1643 ASM_GLOBALIZE_LABEL (asm_out_file
, IDENTIFIER_POINTER (label
));
1644 ASM_OUTPUT_LABEL (asm_out_file
, IDENTIFIER_POINTER (label
));
1646 assemble_label ("__FRAME_BEGIN__");
1649 ASM_OUTPUT_SECTION (asm_out_file
, FRAME_SECTION
);
1651 /* Output the CIE. */
1652 ASM_GENERATE_INTERNAL_LABEL (l1
, CIE_AFTER_SIZE_LABEL
, for_eh
);
1653 ASM_GENERATE_INTERNAL_LABEL (l2
, CIE_END_LABEL
, for_eh
);
1654 #ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
1655 ASM_GENERATE_INTERNAL_LABEL (ld
, CIE_LENGTH_LABEL
, for_eh
);
1657 ASM_OUTPUT_DWARF_OFFSET4 (asm_out_file
, ld
);
1659 ASM_OUTPUT_DWARF_OFFSET (asm_out_file
, ld
);
1662 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file
, l2
, l1
);
1664 ASM_OUTPUT_DWARF_DELTA (asm_out_file
, l2
, l1
);
1667 fprintf (asm_out_file
, "\t%s Length of Common Information Entry",
1670 fputc ('\n', asm_out_file
);
1671 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
1674 /* Now that the CIE pointer is PC-relative for EH,
1675 use 0 to identify the CIE. */
1676 ASM_OUTPUT_DWARF_DATA4 (asm_out_file
, 0);
1678 ASM_OUTPUT_DWARF_DATA4 (asm_out_file
, DW_CIE_ID
);
1681 fprintf (asm_out_file
, "\t%s CIE Identifier Tag", ASM_COMMENT_START
);
1683 fputc ('\n', asm_out_file
);
1684 if (! for_eh
&& DWARF_OFFSET_SIZE
== 8)
1686 ASM_OUTPUT_DWARF_DATA4 (asm_out_file
, DW_CIE_ID
);
1687 fputc ('\n', asm_out_file
);
1690 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, DW_CIE_VERSION
);
1692 fprintf (asm_out_file
, "\t%s CIE Version", ASM_COMMENT_START
);
1694 fputc ('\n', asm_out_file
);
1697 /* The CIE contains a pointer to the exception region info for the
1698 frame. Make the augmentation string three bytes (including the
1699 trailing null) so the pointer is 4-byte aligned. The Solaris ld
1700 can't handle unaligned relocs. */
1703 ASM_OUTPUT_DWARF_STRING (asm_out_file
, "eh");
1704 fprintf (asm_out_file
, "\t%s CIE Augmentation", ASM_COMMENT_START
);
1708 ASM_OUTPUT_ASCII (asm_out_file
, "eh", 3);
1710 fputc ('\n', asm_out_file
);
1712 ASM_OUTPUT_DWARF_ADDR (asm_out_file
, "__EXCEPTION_TABLE__");
1714 fprintf (asm_out_file
, "\t%s pointer to exception region info",
1719 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, 0);
1721 fprintf (asm_out_file
, "\t%s CIE Augmentation (none)",
1725 fputc ('\n', asm_out_file
);
1728 fprintf (asm_out_file
, " (CIE Code Alignment Factor)");
1730 fputc ('\n', asm_out_file
);
1731 output_sleb128 (DWARF_CIE_DATA_ALIGNMENT
);
1733 fprintf (asm_out_file
, " (CIE Data Alignment Factor)");
1735 fputc ('\n', asm_out_file
);
1736 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, DWARF_FRAME_RETURN_COLUMN
);
1738 fprintf (asm_out_file
, "\t%s CIE RA Column", ASM_COMMENT_START
);
1740 fputc ('\n', asm_out_file
);
1742 for (cfi
= cie_cfi_head
; cfi
!= NULL
; cfi
= cfi
->dw_cfi_next
)
1743 output_cfi (cfi
, NULL
);
1745 /* Pad the CIE out to an address sized boundary. */
1746 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (PTR_SIZE
));
1747 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
1748 #ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
1749 ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL (asm_out_file
, ld
, l2
, l1
);
1751 fprintf (asm_out_file
, "\t%s CIE Length Symbol", ASM_COMMENT_START
);
1752 fputc ('\n', asm_out_file
);
1755 /* Loop through all of the FDE's. */
1756 for (i
= 0; i
< fde_table_in_use
; ++i
)
1758 fde
= &fde_table
[i
];
1760 ASM_GENERATE_INTERNAL_LABEL (l1
, FDE_AFTER_SIZE_LABEL
, for_eh
+ i
*2);
1761 ASM_GENERATE_INTERNAL_LABEL (l2
, FDE_END_LABEL
, for_eh
+ i
*2);
1762 #ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
1763 ASM_GENERATE_INTERNAL_LABEL (ld
, FDE_LENGTH_LABEL
, for_eh
+ i
*2);
1765 ASM_OUTPUT_DWARF_OFFSET4 (asm_out_file
, ld
);
1767 ASM_OUTPUT_DWARF_OFFSET (asm_out_file
, ld
);
1770 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file
, l2
, l1
);
1772 ASM_OUTPUT_DWARF_DELTA (asm_out_file
, l2
, l1
);
1775 fprintf (asm_out_file
, "\t%s FDE Length", ASM_COMMENT_START
);
1776 fputc ('\n', asm_out_file
);
1777 ASM_OUTPUT_LABEL (asm_out_file
, l1
);
1779 /* ??? This always emits a 4 byte offset when for_eh is true, but it
1780 emits a target dependent sized offset when for_eh is not true.
1781 This inconsistency may confuse gdb. The only case where we need a
1782 non-4 byte offset is for the Irix6 N64 ABI, so we may lose SGI
1783 compatibility if we emit a 4 byte offset. We need a 4 byte offset
1784 though in order to be compatible with the dwarf_fde struct in frame.c.
1785 If the for_eh case is changed, then the struct in frame.c has
1786 to be adjusted appropriately. */
1788 ASM_OUTPUT_DWARF_DELTA4 (asm_out_file
, l1
, "__FRAME_BEGIN__");
1790 ASM_OUTPUT_DWARF_OFFSET (asm_out_file
, stripattributes (FRAME_SECTION
));
1792 fprintf (asm_out_file
, "\t%s FDE CIE offset", ASM_COMMENT_START
);
1794 fputc ('\n', asm_out_file
);
1795 ASM_OUTPUT_DWARF_ADDR (asm_out_file
, fde
->dw_fde_begin
);
1797 fprintf (asm_out_file
, "\t%s FDE initial location", ASM_COMMENT_START
);
1799 fputc ('\n', asm_out_file
);
1800 ASM_OUTPUT_DWARF_ADDR_DELTA (asm_out_file
,
1801 fde
->dw_fde_end
, fde
->dw_fde_begin
);
1803 fprintf (asm_out_file
, "\t%s FDE address range", ASM_COMMENT_START
);
1805 fputc ('\n', asm_out_file
);
1807 /* Loop through the Call Frame Instructions associated with
1809 fde
->dw_fde_current_label
= fde
->dw_fde_begin
;
1810 for (cfi
= fde
->dw_fde_cfi
; cfi
!= NULL
; cfi
= cfi
->dw_cfi_next
)
1811 output_cfi (cfi
, fde
);
1813 /* Pad the FDE out to an address sized boundary. */
1814 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (PTR_SIZE
));
1815 ASM_OUTPUT_LABEL (asm_out_file
, l2
);
1816 #ifdef ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL
1817 ASM_OUTPUT_DEFINE_LABEL_DIFFERENCE_SYMBOL (asm_out_file
, ld
, l2
, l1
);
1819 fprintf (asm_out_file
, "\t%s FDE Length Symbol", ASM_COMMENT_START
);
1820 fputc ('\n', asm_out_file
);
1823 #ifndef EH_FRAME_SECTION
1826 /* Emit terminating zero for table. */
1827 ASM_OUTPUT_DWARF_DATA4 (asm_out_file
, 0);
1828 fputc ('\n', asm_out_file
);
1831 #ifdef MIPS_DEBUGGING_INFO
1832 /* Work around Irix 6 assembler bug whereby labels at the end of a section
1833 get a value of 0. Putting .align 0 after the label fixes it. */
1834 ASM_OUTPUT_ALIGN (asm_out_file
, 0);
1837 /* Turn off app to make assembly quicker. */
1842 /* Output a marker (i.e. a label) for the beginning of a function, before
1846 dwarf2out_begin_prologue ()
1848 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1849 register dw_fde_ref fde
;
1851 ++current_funcdef_number
;
1853 function_section (current_function_decl
);
1854 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_BEGIN_LABEL
,
1855 current_funcdef_number
);
1856 ASM_OUTPUT_LABEL (asm_out_file
, label
);
1858 /* Expand the fde table if necessary. */
1859 if (fde_table_in_use
== fde_table_allocated
)
1861 fde_table_allocated
+= FDE_TABLE_INCREMENT
;
1863 = (dw_fde_ref
) xrealloc (fde_table
,
1864 fde_table_allocated
* sizeof (dw_fde_node
));
1867 /* Record the FDE associated with this function. */
1868 current_funcdef_fde
= fde_table_in_use
;
1870 /* Add the new FDE at the end of the fde_table. */
1871 fde
= &fde_table
[fde_table_in_use
++];
1872 fde
->dw_fde_begin
= xstrdup (label
);
1873 fde
->dw_fde_current_label
= NULL
;
1874 fde
->dw_fde_end
= NULL
;
1875 fde
->dw_fde_cfi
= NULL
;
1877 args_size
= old_args_size
= 0;
1880 /* Output a marker (i.e. a label) for the absolute end of the generated code
1881 for a function definition. This gets called *after* the epilogue code has
1885 dwarf2out_end_epilogue ()
1888 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
1890 /* Output a label to mark the endpoint of the code generated for this
1892 ASM_GENERATE_INTERNAL_LABEL (label
, FUNC_END_LABEL
, current_funcdef_number
);
1893 ASM_OUTPUT_LABEL (asm_out_file
, label
);
1894 fde
= &fde_table
[fde_table_in_use
- 1];
1895 fde
->dw_fde_end
= xstrdup (label
);
1899 dwarf2out_frame_init ()
1901 /* Allocate the initial hunk of the fde_table. */
1902 fde_table
= (dw_fde_ref
) xcalloc (FDE_TABLE_INCREMENT
, sizeof (dw_fde_node
));
1903 fde_table_allocated
= FDE_TABLE_INCREMENT
;
1904 fde_table_in_use
= 0;
1906 /* Generate the CFA instructions common to all FDE's. Do it now for the
1907 sake of lookup_cfa. */
1909 #ifdef DWARF2_UNWIND_INFO
1910 /* On entry, the Canonical Frame Address is at SP. */
1911 dwarf2out_def_cfa (NULL
, STACK_POINTER_REGNUM
, INCOMING_FRAME_SP_OFFSET
);
1912 initial_return_save (INCOMING_RETURN_ADDR_RTX
);
1917 dwarf2out_frame_finish ()
1919 /* Output call frame information. */
1920 #ifdef MIPS_DEBUGGING_INFO
1921 if (write_symbols
== DWARF2_DEBUG
)
1922 output_call_frame_info (0);
1923 if (flag_unwind_tables
|| (flag_exceptions
&& ! exceptions_via_longjmp
))
1924 output_call_frame_info (1);
1926 if (write_symbols
== DWARF2_DEBUG
1927 || flag_unwind_tables
|| (flag_exceptions
&& ! exceptions_via_longjmp
))
1928 output_call_frame_info (1);
1932 #endif /* .debug_frame support */
1934 /* And now, the support for symbolic debugging information. */
1935 #ifdef DWARF2_DEBUGGING_INFO
1937 /* NOTE: In the comments in this file, many references are made to
1938 "Debugging Information Entries". This term is abbreviated as `DIE'
1939 throughout the remainder of this file. */
1941 /* An internal representation of the DWARF output is built, and then
1942 walked to generate the DWARF debugging info. The walk of the internal
1943 representation is done after the entire program has been compiled.
1944 The types below are used to describe the internal representation. */
1946 /* Each DIE may have a series of attribute/value pairs. Values
1947 can take on several forms. The forms that are used in this
1948 implementation are listed below. */
1955 dw_val_class_unsigned_const
,
1956 dw_val_class_long_long
,
1959 dw_val_class_die_ref
,
1960 dw_val_class_fde_ref
,
1961 dw_val_class_lbl_id
,
1962 dw_val_class_lbl_offset
,
1967 /* Various DIE's use offsets relative to the beginning of the
1968 .debug_info section to refer to each other. */
1970 typedef long int dw_offset
;
1972 /* Define typedefs here to avoid circular dependencies. */
1974 typedef struct die_struct
*dw_die_ref
;
1975 typedef struct dw_attr_struct
*dw_attr_ref
;
1976 typedef struct dw_val_struct
*dw_val_ref
;
1977 typedef struct dw_line_info_struct
*dw_line_info_ref
;
1978 typedef struct dw_separate_line_info_struct
*dw_separate_line_info_ref
;
1979 typedef struct dw_loc_descr_struct
*dw_loc_descr_ref
;
1980 typedef struct pubname_struct
*pubname_ref
;
1981 typedef dw_die_ref
*arange_ref
;
1983 /* Describe a double word constant value. */
1985 typedef struct dw_long_long_struct
1992 /* Describe a floating point constant value. */
1994 typedef struct dw_fp_struct
2001 /* Each entry in the line_info_table maintains the file and
2002 line number associated with the label generated for that
2003 entry. The label gives the PC value associated with
2004 the line number entry. */
2006 typedef struct dw_line_info_struct
2008 unsigned long dw_file_num
;
2009 unsigned long dw_line_num
;
2013 /* Line information for functions in separate sections; each one gets its
2015 typedef struct dw_separate_line_info_struct
2017 unsigned long dw_file_num
;
2018 unsigned long dw_line_num
;
2019 unsigned long function
;
2021 dw_separate_line_info_entry
;
2023 /* The dw_val_node describes an attribute's value, as it is
2024 represented internally. */
2026 typedef struct dw_val_struct
2028 dw_val_class val_class
;
2032 dw_loc_descr_ref val_loc
;
2034 long unsigned val_unsigned
;
2035 dw_long_long_const val_long_long
;
2036 dw_float_const val_float
;
2037 dw_die_ref val_die_ref
;
2038 unsigned val_fde_index
;
2041 unsigned char val_flag
;
2047 /* Locations in memory are described using a sequence of stack machine
2050 typedef struct dw_loc_descr_struct
2052 dw_loc_descr_ref dw_loc_next
;
2053 enum dwarf_location_atom dw_loc_opc
;
2054 dw_val_node dw_loc_oprnd1
;
2055 dw_val_node dw_loc_oprnd2
;
2059 /* Each DIE attribute has a field specifying the attribute kind,
2060 a link to the next attribute in the chain, and an attribute value.
2061 Attributes are typically linked below the DIE they modify. */
2063 typedef struct dw_attr_struct
2065 enum dwarf_attribute dw_attr
;
2066 dw_attr_ref dw_attr_next
;
2067 dw_val_node dw_attr_val
;
2071 /* The Debugging Information Entry (DIE) structure */
2073 typedef struct die_struct
2075 enum dwarf_tag die_tag
;
2076 dw_attr_ref die_attr
;
2077 dw_die_ref die_parent
;
2078 dw_die_ref die_child
;
2080 dw_offset die_offset
;
2081 unsigned long die_abbrev
;
2085 /* The pubname structure */
2087 typedef struct pubname_struct
2094 /* The limbo die list structure. */
2095 typedef struct limbo_die_struct
2098 struct limbo_die_struct
*next
;
2102 /* How to start an assembler comment. */
2103 #ifndef ASM_COMMENT_START
2104 #define ASM_COMMENT_START ";#"
2107 /* Define a macro which returns non-zero for a TYPE_DECL which was
2108 implicitly generated for a tagged type.
2110 Note that unlike the gcc front end (which generates a NULL named
2111 TYPE_DECL node for each complete tagged type, each array type, and
2112 each function type node created) the g++ front end generates a
2113 _named_ TYPE_DECL node for each tagged type node created.
2114 These TYPE_DECLs have DECL_ARTIFICIAL set, so we know not to
2115 generate a DW_TAG_typedef DIE for them. */
2117 #define TYPE_DECL_IS_STUB(decl) \
2118 (DECL_NAME (decl) == NULL_TREE \
2119 || (DECL_ARTIFICIAL (decl) \
2120 && is_tagged_type (TREE_TYPE (decl)) \
2121 && ((decl == TYPE_STUB_DECL (TREE_TYPE (decl))) \
2122 /* This is necessary for stub decls that \
2123 appear in nested inline functions. */ \
2124 || (DECL_ABSTRACT_ORIGIN (decl) != NULL_TREE \
2125 && (decl_ultimate_origin (decl) \
2126 == TYPE_STUB_DECL (TREE_TYPE (decl)))))))
2128 /* Information concerning the compilation unit's programming
2129 language, and compiler version. */
2131 extern int flag_traditional
;
2132 extern char *version_string
;
2134 /* Fixed size portion of the DWARF compilation unit header. */
2135 #define DWARF_COMPILE_UNIT_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 3)
2137 /* Fixed size portion of debugging line information prolog. */
2138 #define DWARF_LINE_PROLOG_HEADER_SIZE 5
2140 /* Fixed size portion of public names info. */
2141 #define DWARF_PUBNAMES_HEADER_SIZE (2 * DWARF_OFFSET_SIZE + 2)
2143 /* Fixed size portion of the address range info. */
2144 #define DWARF_ARANGES_HEADER_SIZE \
2145 (DWARF_ROUND (2 * DWARF_OFFSET_SIZE + 4, PTR_SIZE * 2) - DWARF_OFFSET_SIZE)
2147 /* The default is to have gcc emit the line number tables. */
2148 #ifndef DWARF2_ASM_LINE_DEBUG_INFO
2149 #define DWARF2_ASM_LINE_DEBUG_INFO 0
2152 /* Define the architecture-dependent minimum instruction length (in bytes).
2153 In this implementation of DWARF, this field is used for information
2154 purposes only. Since GCC generates assembly language, we have
2155 no a priori knowledge of how many instruction bytes are generated
2156 for each source line, and therefore can use only the DW_LNE_set_address
2157 and DW_LNS_fixed_advance_pc line information commands. */
2159 #ifndef DWARF_LINE_MIN_INSTR_LENGTH
2160 #define DWARF_LINE_MIN_INSTR_LENGTH 4
2163 /* Minimum line offset in a special line info. opcode.
2164 This value was chosen to give a reasonable range of values. */
2165 #define DWARF_LINE_BASE -10
2167 /* First special line opcde - leave room for the standard opcodes. */
2168 #define DWARF_LINE_OPCODE_BASE 10
2170 /* Range of line offsets in a special line info. opcode. */
2171 #define DWARF_LINE_RANGE (254-DWARF_LINE_OPCODE_BASE+1)
2173 /* Flag that indicates the initial value of the is_stmt_start flag.
2174 In the present implementation, we do not mark any lines as
2175 the beginning of a source statement, because that information
2176 is not made available by the GCC front-end. */
2177 #define DWARF_LINE_DEFAULT_IS_STMT_START 1
2179 /* This location is used by calc_die_sizes() to keep track
2180 the offset of each DIE within the .debug_info section. */
2181 static unsigned long next_die_offset
;
2183 /* Record the root of the DIE's built for the current compilation unit. */
2184 static dw_die_ref comp_unit_die
;
2186 /* A list of DIEs with a NULL parent waiting to be relocated. */
2187 static limbo_die_node
*limbo_die_list
= 0;
2189 /* Pointer to an array of filenames referenced by this compilation unit. */
2190 static char **file_table
;
2192 /* Total number of entries in the table (i.e. array) pointed to by
2193 `file_table'. This is the *total* and includes both used and unused
2195 static unsigned file_table_allocated
;
2197 /* Number of entries in the file_table which are actually in use. */
2198 static unsigned file_table_in_use
;
2200 /* Size (in elements) of increments by which we may expand the filename
2202 #define FILE_TABLE_INCREMENT 64
2204 /* Local pointer to the name of the main input file. Initialized in
2206 static char *primary_filename
;
2208 /* For Dwarf output, we must assign lexical-blocks id numbers in the order in
2209 which their beginnings are encountered. We output Dwarf debugging info
2210 that refers to the beginnings and ends of the ranges of code for each
2211 lexical block. The labels themselves are generated in final.c, which
2212 assigns numbers to the blocks in the same way. */
2213 static unsigned next_block_number
= 2;
2215 /* A pointer to the base of a table of references to DIE's that describe
2216 declarations. The table is indexed by DECL_UID() which is a unique
2217 number identifying each decl. */
2218 static dw_die_ref
*decl_die_table
;
2220 /* Number of elements currently allocated for the decl_die_table. */
2221 static unsigned decl_die_table_allocated
;
2223 /* Number of elements in decl_die_table currently in use. */
2224 static unsigned decl_die_table_in_use
;
2226 /* Size (in elements) of increments by which we may expand the
2228 #define DECL_DIE_TABLE_INCREMENT 256
2230 /* Structure used for the decl_scope table. scope is the current declaration
2231 scope, and previous is the entry that is the parent of this scope. This
2232 is usually but not always the immediately preceeding entry. */
2234 typedef struct decl_scope_struct
2241 /* A pointer to the base of a table of references to declaration
2242 scopes. This table is a display which tracks the nesting
2243 of declaration scopes at the current scope and containing
2244 scopes. This table is used to find the proper place to
2245 define type declaration DIE's. */
2246 static decl_scope_node
*decl_scope_table
;
2248 /* Number of elements currently allocated for the decl_scope_table. */
2249 static int decl_scope_table_allocated
;
2251 /* Current level of nesting of declaration scopes. */
2252 static int decl_scope_depth
;
2254 /* Size (in elements) of increments by which we may expand the
2255 decl_scope_table. */
2256 #define DECL_SCOPE_TABLE_INCREMENT 64
2258 /* A pointer to the base of a list of references to DIE's that
2259 are uniquely identified by their tag, presence/absence of
2260 children DIE's, and list of attribute/value pairs. */
2261 static dw_die_ref
*abbrev_die_table
;
2263 /* Number of elements currently allocated for abbrev_die_table. */
2264 static unsigned abbrev_die_table_allocated
;
2266 /* Number of elements in type_die_table currently in use. */
2267 static unsigned abbrev_die_table_in_use
;
2269 /* Size (in elements) of increments by which we may expand the
2270 abbrev_die_table. */
2271 #define ABBREV_DIE_TABLE_INCREMENT 256
2273 /* A pointer to the base of a table that contains line information
2274 for each source code line in .text in the compilation unit. */
2275 static dw_line_info_ref line_info_table
;
2277 /* Number of elements currently allocated for line_info_table. */
2278 static unsigned line_info_table_allocated
;
2280 /* Number of elements in separate_line_info_table currently in use. */
2281 static unsigned separate_line_info_table_in_use
;
2283 /* A pointer to the base of a table that contains line information
2284 for each source code line outside of .text in the compilation unit. */
2285 static dw_separate_line_info_ref separate_line_info_table
;
2287 /* Number of elements currently allocated for separate_line_info_table. */
2288 static unsigned separate_line_info_table_allocated
;
2290 /* Number of elements in line_info_table currently in use. */
2291 static unsigned line_info_table_in_use
;
2293 /* Size (in elements) of increments by which we may expand the
2295 #define LINE_INFO_TABLE_INCREMENT 1024
2297 /* A pointer to the base of a table that contains a list of publicly
2298 accessible names. */
2299 static pubname_ref pubname_table
;
2301 /* Number of elements currently allocated for pubname_table. */
2302 static unsigned pubname_table_allocated
;
2304 /* Number of elements in pubname_table currently in use. */
2305 static unsigned pubname_table_in_use
;
2307 /* Size (in elements) of increments by which we may expand the
2309 #define PUBNAME_TABLE_INCREMENT 64
2311 /* A pointer to the base of a table that contains a list of publicly
2312 accessible names. */
2313 static arange_ref arange_table
;
2315 /* Number of elements currently allocated for arange_table. */
2316 static unsigned arange_table_allocated
;
2318 /* Number of elements in arange_table currently in use. */
2319 static unsigned arange_table_in_use
;
2321 /* Size (in elements) of increments by which we may expand the
2323 #define ARANGE_TABLE_INCREMENT 64
2325 /* A pointer to the base of a list of pending types which we haven't
2326 generated DIEs for yet, but which we will have to come back to
2329 static tree
*pending_types_list
;
2331 /* Number of elements currently allocated for the pending_types_list. */
2332 static unsigned pending_types_allocated
;
2334 /* Number of elements of pending_types_list currently in use. */
2335 static unsigned pending_types
;
2337 /* Size (in elements) of increments by which we may expand the pending
2338 types list. Actually, a single hunk of space of this size should
2339 be enough for most typical programs. */
2340 #define PENDING_TYPES_INCREMENT 64
2342 /* A pointer to the base of a list of incomplete types which might be
2343 completed at some later time. */
2345 static tree
*incomplete_types_list
;
2347 /* Number of elements currently allocated for the incomplete_types_list. */
2348 static unsigned incomplete_types_allocated
;
2350 /* Number of elements of incomplete_types_list currently in use. */
2351 static unsigned incomplete_types
;
2353 /* Size (in elements) of increments by which we may expand the incomplete
2354 types list. Actually, a single hunk of space of this size should
2355 be enough for most typical programs. */
2356 #define INCOMPLETE_TYPES_INCREMENT 64
2358 /* Record whether the function being analyzed contains inlined functions. */
2359 static int current_function_has_inlines
;
2360 #if 0 && defined (MIPS_DEBUGGING_INFO)
2361 static int comp_unit_has_inlines
;
2364 /* Forward declarations for functions defined in this file. */
2366 static void addr_const_to_string
PROTO((dyn_string_t
, rtx
));
2367 static char *addr_to_string
PROTO((rtx
));
2368 static int is_pseudo_reg
PROTO((rtx
));
2369 static tree type_main_variant
PROTO((tree
));
2370 static int is_tagged_type
PROTO((tree
));
2371 static const char *dwarf_tag_name
PROTO((unsigned));
2372 static const char *dwarf_attr_name
PROTO((unsigned));
2373 static const char *dwarf_form_name
PROTO((unsigned));
2374 static const char *dwarf_stack_op_name
PROTO((unsigned));
2376 static const char *dwarf_type_encoding_name
PROTO((unsigned));
2378 static tree decl_ultimate_origin
PROTO((tree
));
2379 static tree block_ultimate_origin
PROTO((tree
));
2380 static tree decl_class_context
PROTO((tree
));
2381 static void add_dwarf_attr
PROTO((dw_die_ref
, dw_attr_ref
));
2382 static void add_AT_flag
PROTO((dw_die_ref
,
2383 enum dwarf_attribute
,
2385 static void add_AT_int
PROTO((dw_die_ref
,
2386 enum dwarf_attribute
, long));
2387 static void add_AT_unsigned
PROTO((dw_die_ref
,
2388 enum dwarf_attribute
,
2390 static void add_AT_long_long
PROTO((dw_die_ref
,
2391 enum dwarf_attribute
,
2392 unsigned long, unsigned long));
2393 static void add_AT_float
PROTO((dw_die_ref
,
2394 enum dwarf_attribute
,
2396 static void add_AT_string
PROTO((dw_die_ref
,
2397 enum dwarf_attribute
,
2399 static void add_AT_die_ref
PROTO((dw_die_ref
,
2400 enum dwarf_attribute
,
2402 static void add_AT_fde_ref
PROTO((dw_die_ref
,
2403 enum dwarf_attribute
,
2405 static void add_AT_loc
PROTO((dw_die_ref
,
2406 enum dwarf_attribute
,
2408 static void add_AT_addr
PROTO((dw_die_ref
,
2409 enum dwarf_attribute
, char *));
2410 static void add_AT_lbl_id
PROTO((dw_die_ref
,
2411 enum dwarf_attribute
, char *));
2412 static void add_AT_lbl_offset
PROTO((dw_die_ref
,
2413 enum dwarf_attribute
, char *));
2414 static dw_attr_ref get_AT
PROTO((dw_die_ref
,
2415 enum dwarf_attribute
));
2416 static const char *get_AT_low_pc
PROTO((dw_die_ref
));
2417 static const char *get_AT_hi_pc
PROTO((dw_die_ref
));
2418 static const char *get_AT_string
PROTO((dw_die_ref
,
2419 enum dwarf_attribute
));
2420 static int get_AT_flag
PROTO((dw_die_ref
,
2421 enum dwarf_attribute
));
2422 static unsigned get_AT_unsigned
PROTO((dw_die_ref
,
2423 enum dwarf_attribute
));
2424 static int is_c_family
PROTO((void));
2425 static int is_fortran
PROTO((void));
2426 static void remove_AT
PROTO((dw_die_ref
,
2427 enum dwarf_attribute
));
2428 static void remove_children
PROTO((dw_die_ref
));
2429 static void add_child_die
PROTO((dw_die_ref
, dw_die_ref
));
2430 static dw_die_ref new_die
PROTO((enum dwarf_tag
, dw_die_ref
));
2431 static dw_die_ref lookup_type_die
PROTO((tree
));
2432 static void equate_type_number_to_die
PROTO((tree
, dw_die_ref
));
2433 static dw_die_ref lookup_decl_die
PROTO((tree
));
2434 static void equate_decl_number_to_die
PROTO((tree
, dw_die_ref
));
2435 static dw_loc_descr_ref new_loc_descr
PROTO((enum dwarf_location_atom
,
2436 unsigned long, unsigned long));
2437 static void add_loc_descr
PROTO((dw_loc_descr_ref
*,
2439 static void print_spaces
PROTO((FILE *));
2440 static void print_die
PROTO((dw_die_ref
, FILE *));
2441 static void print_dwarf_line_table
PROTO((FILE *));
2442 static void add_sibling_attributes
PROTO((dw_die_ref
));
2443 static void build_abbrev_table
PROTO((dw_die_ref
));
2444 static unsigned long size_of_string
PROTO((const char *));
2445 static unsigned long size_of_loc_descr
PROTO((dw_loc_descr_ref
));
2446 static unsigned long size_of_locs
PROTO((dw_loc_descr_ref
));
2447 static int constant_size
PROTO((long unsigned));
2448 static unsigned long size_of_die
PROTO((dw_die_ref
));
2449 static void calc_die_sizes
PROTO((dw_die_ref
));
2450 static unsigned long size_of_line_prolog
PROTO((void));
2451 static unsigned long size_of_pubnames
PROTO((void));
2452 static unsigned long size_of_aranges
PROTO((void));
2453 static enum dwarf_form value_format
PROTO((dw_attr_ref
));
2454 static void output_value_format
PROTO((dw_attr_ref
));
2455 static void output_abbrev_section
PROTO((void));
2456 static void output_loc_operands
PROTO((dw_loc_descr_ref
));
2457 static void output_die
PROTO((dw_die_ref
));
2458 static void output_compilation_unit_header
PROTO((void));
2459 static const char *dwarf2_name
PROTO((tree
, int));
2460 static void add_pubname
PROTO((tree
, dw_die_ref
));
2461 static void output_pubnames
PROTO((void));
2462 static void add_arange
PROTO((tree
, dw_die_ref
));
2463 static void output_aranges
PROTO((void));
2464 static void output_line_info
PROTO((void));
2465 static int is_body_block
PROTO((tree
));
2466 static dw_die_ref base_type_die
PROTO((tree
));
2467 static tree root_type
PROTO((tree
));
2468 static int is_base_type
PROTO((tree
));
2469 static dw_die_ref modified_type_die
PROTO((tree
, int, int, dw_die_ref
));
2470 static int type_is_enum
PROTO((tree
));
2471 static dw_loc_descr_ref reg_loc_descriptor
PROTO((rtx
));
2472 static dw_loc_descr_ref based_loc_descr
PROTO((unsigned, long));
2473 static int is_based_loc
PROTO((rtx
));
2474 static dw_loc_descr_ref mem_loc_descriptor
PROTO((rtx
, enum machine_mode mode
));
2475 static dw_loc_descr_ref concat_loc_descriptor
PROTO((rtx
, rtx
));
2476 static dw_loc_descr_ref loc_descriptor
PROTO((rtx
));
2477 static unsigned ceiling
PROTO((unsigned, unsigned));
2478 static tree field_type
PROTO((tree
));
2479 static unsigned simple_type_align_in_bits
PROTO((tree
));
2480 static unsigned simple_type_size_in_bits
PROTO((tree
));
2481 static unsigned field_byte_offset
PROTO((tree
));
2482 static void add_AT_location_description
PROTO((dw_die_ref
,
2483 enum dwarf_attribute
, rtx
));
2484 static void add_data_member_location_attribute
PROTO((dw_die_ref
, tree
));
2485 static void add_const_value_attribute
PROTO((dw_die_ref
, rtx
));
2486 static void add_location_or_const_value_attribute
PROTO((dw_die_ref
, tree
));
2487 static void add_name_attribute
PROTO((dw_die_ref
, const char *));
2488 static void add_bound_info
PROTO((dw_die_ref
,
2489 enum dwarf_attribute
, tree
));
2490 static void add_subscript_info
PROTO((dw_die_ref
, tree
));
2491 static void add_byte_size_attribute
PROTO((dw_die_ref
, tree
));
2492 static void add_bit_offset_attribute
PROTO((dw_die_ref
, tree
));
2493 static void add_bit_size_attribute
PROTO((dw_die_ref
, tree
));
2494 static void add_prototyped_attribute
PROTO((dw_die_ref
, tree
));
2495 static void add_abstract_origin_attribute
PROTO((dw_die_ref
, tree
));
2496 static void add_pure_or_virtual_attribute
PROTO((dw_die_ref
, tree
));
2497 static void add_src_coords_attributes
PROTO((dw_die_ref
, tree
));
2498 static void add_name_and_src_coords_attributes
PROTO((dw_die_ref
, tree
));
2499 static void push_decl_scope
PROTO((tree
));
2500 static dw_die_ref scope_die_for
PROTO((tree
, dw_die_ref
));
2501 static void pop_decl_scope
PROTO((void));
2502 static void add_type_attribute
PROTO((dw_die_ref
, tree
, int, int,
2504 static char *type_tag
PROTO((tree
));
2505 static tree member_declared_type
PROTO((tree
));
2507 static char *decl_start_label
PROTO((tree
));
2509 static void gen_array_type_die
PROTO((tree
, dw_die_ref
));
2510 static void gen_set_type_die
PROTO((tree
, dw_die_ref
));
2512 static void gen_entry_point_die
PROTO((tree
, dw_die_ref
));
2514 static void pend_type
PROTO((tree
));
2515 static void output_pending_types_for_scope
PROTO((dw_die_ref
));
2516 static void gen_inlined_enumeration_type_die
PROTO((tree
, dw_die_ref
));
2517 static void gen_inlined_structure_type_die
PROTO((tree
, dw_die_ref
));
2518 static void gen_inlined_union_type_die
PROTO((tree
, dw_die_ref
));
2519 static void gen_enumeration_type_die
PROTO((tree
, dw_die_ref
));
2520 static dw_die_ref gen_formal_parameter_die
PROTO((tree
, dw_die_ref
));
2521 static void gen_unspecified_parameters_die
PROTO((tree
, dw_die_ref
));
2522 static void gen_formal_types_die
PROTO((tree
, dw_die_ref
));
2523 static void gen_subprogram_die
PROTO((tree
, dw_die_ref
));
2524 static void gen_variable_die
PROTO((tree
, dw_die_ref
));
2525 static void gen_label_die
PROTO((tree
, dw_die_ref
));
2526 static void gen_lexical_block_die
PROTO((tree
, dw_die_ref
, int));
2527 static void gen_inlined_subroutine_die
PROTO((tree
, dw_die_ref
, int));
2528 static void gen_field_die
PROTO((tree
, dw_die_ref
));
2529 static void gen_ptr_to_mbr_type_die
PROTO((tree
, dw_die_ref
));
2530 static dw_die_ref gen_compile_unit_die
PROTO((const char *));
2531 static void gen_string_type_die
PROTO((tree
, dw_die_ref
));
2532 static void gen_inheritance_die
PROTO((tree
, dw_die_ref
));
2533 static void gen_member_die
PROTO((tree
, dw_die_ref
));
2534 static void gen_struct_or_union_type_die
PROTO((tree
, dw_die_ref
));
2535 static void gen_subroutine_type_die
PROTO((tree
, dw_die_ref
));
2536 static void gen_typedef_die
PROTO((tree
, dw_die_ref
));
2537 static void gen_type_die
PROTO((tree
, dw_die_ref
));
2538 static void gen_tagged_type_instantiation_die
PROTO((tree
, dw_die_ref
));
2539 static void gen_block_die
PROTO((tree
, dw_die_ref
, int));
2540 static void decls_for_scope
PROTO((tree
, dw_die_ref
, int));
2541 static int is_redundant_typedef
PROTO((tree
));
2542 static void gen_decl_die
PROTO((tree
, dw_die_ref
));
2543 static unsigned lookup_filename
PROTO((const char *));
2544 static void add_incomplete_type
PROTO((tree
));
2545 static void retry_incomplete_types
PROTO((void));
2547 /* Section names used to hold DWARF debugging information. */
2548 #ifndef DEBUG_INFO_SECTION
2549 #define DEBUG_INFO_SECTION ".debug_info"
2551 #ifndef ABBREV_SECTION
2552 #define ABBREV_SECTION ".debug_abbrev"
2554 #ifndef ARANGES_SECTION
2555 #define ARANGES_SECTION ".debug_aranges"
2557 #ifndef DW_MACINFO_SECTION
2558 #define DW_MACINFO_SECTION ".debug_macinfo"
2560 #ifndef DEBUG_LINE_SECTION
2561 #define DEBUG_LINE_SECTION ".debug_line"
2564 #define LOC_SECTION ".debug_loc"
2566 #ifndef PUBNAMES_SECTION
2567 #define PUBNAMES_SECTION ".debug_pubnames"
2570 #define STR_SECTION ".debug_str"
2573 /* Standard ELF section names for compiled code and data. */
2574 #ifndef TEXT_SECTION
2575 #define TEXT_SECTION ".text"
2577 #ifndef DATA_SECTION
2578 #define DATA_SECTION ".data"
2581 #define BSS_SECTION ".bss"
2584 /* Labels we insert at beginning sections we can reference instead of
2585 the section names themselves. */
2587 #ifndef TEXT_SECTION_LABEL
2588 #define TEXT_SECTION_LABEL "Ltext"
2590 #ifndef DEBUG_LINE_SECTION_LABEL
2591 #define DEBUG_LINE_SECTION_LABEL "Ldebug_line"
2593 #ifndef DEBUG_INFO_SECTION_LABEL
2594 #define DEBUG_INFO_SECTION_LABEL "Ldebug_info"
2596 #ifndef ABBREV_SECTION_LABEL
2597 #define ABBREV_SECTION_LABEL "Ldebug_abbrev"
2601 /* Definitions of defaults for formats and names of various special
2602 (artificial) labels which may be generated within this file (when the -g
2603 options is used and DWARF_DEBUGGING_INFO is in effect.
2604 If necessary, these may be overridden from within the tm.h file, but
2605 typically, overriding these defaults is unnecessary. */
2607 static char text_end_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
2608 static char text_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
2609 static char abbrev_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
2610 static char debug_info_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
2611 static char debug_line_section_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
2613 #ifndef TEXT_END_LABEL
2614 #define TEXT_END_LABEL "Letext"
2616 #ifndef DATA_END_LABEL
2617 #define DATA_END_LABEL "Ledata"
2619 #ifndef BSS_END_LABEL
2620 #define BSS_END_LABEL "Lebss"
2622 #ifndef INSN_LABEL_FMT
2623 #define INSN_LABEL_FMT "LI%u_"
2625 #ifndef BLOCK_BEGIN_LABEL
2626 #define BLOCK_BEGIN_LABEL "LBB"
2628 #ifndef BLOCK_END_LABEL
2629 #define BLOCK_END_LABEL "LBE"
2631 #ifndef BODY_BEGIN_LABEL
2632 #define BODY_BEGIN_LABEL "Lbb"
2634 #ifndef BODY_END_LABEL
2635 #define BODY_END_LABEL "Lbe"
2637 #ifndef LINE_CODE_LABEL
2638 #define LINE_CODE_LABEL "LM"
2640 #ifndef SEPARATE_LINE_CODE_LABEL
2641 #define SEPARATE_LINE_CODE_LABEL "LSM"
2644 /* Convert a reference to the assembler name of a C-level name. This
2645 macro has the same effect as ASM_OUTPUT_LABELREF, but copies to
2646 a string rather than writing to a file. */
2647 #ifndef ASM_NAME_TO_STRING
2648 #define ASM_NAME_TO_STRING(STR, NAME) \
2650 if ((NAME)[0] == '*') \
2651 dyn_string_append (STR, NAME + 1); \
2654 const char *newstr; \
2655 STRIP_NAME_ENCODING (newstr, NAME); \
2656 dyn_string_append (STR, user_label_prefix); \
2657 dyn_string_append (STR, newstr); \
2663 /* We allow a language front-end to designate a function that is to be
2664 called to "demangle" any name before it it put into a DIE. */
2666 static const char *(*demangle_name_func
) PROTO((const char *));
2669 dwarf2out_set_demangle_name_func (func
)
2670 const char *(*func
) PROTO((const char *));
2672 demangle_name_func
= func
;
2675 /* Convert an integer constant expression into assembler syntax. Addition
2676 and subtraction are the only arithmetic that may appear in these
2677 expressions. This is an adaptation of output_addr_const in final.c.
2678 Here, the target of the conversion is a string buffer. We can't use
2679 output_addr_const directly, because it writes to a file. */
2682 addr_const_to_string (str
, x
)
2689 switch (GET_CODE (x
))
2693 dyn_string_append (str
, ",");
2699 ASM_NAME_TO_STRING (str
, XSTR (x
, 0));
2703 ASM_GENERATE_INTERNAL_LABEL (buf1
, "L", CODE_LABEL_NUMBER (XEXP (x
, 0)));
2704 ASM_NAME_TO_STRING (str
, buf1
);
2708 ASM_GENERATE_INTERNAL_LABEL (buf1
, "L", CODE_LABEL_NUMBER (x
));
2709 ASM_NAME_TO_STRING (str
, buf1
);
2713 sprintf (buf1
, HOST_WIDE_INT_PRINT_DEC
, INTVAL (x
));
2714 dyn_string_append (str
, buf1
);
2718 /* This used to output parentheses around the expression, but that does
2719 not work on the 386 (either ATT or BSD assembler). */
2720 addr_const_to_string (str
, XEXP (x
, 0));
2724 if (GET_MODE (x
) == VOIDmode
)
2726 /* We can use %d if the number is one word and positive. */
2727 if (CONST_DOUBLE_HIGH (x
))
2728 sprintf (buf1
, HOST_WIDE_INT_PRINT_DOUBLE_HEX
,
2729 CONST_DOUBLE_HIGH (x
), CONST_DOUBLE_LOW (x
));
2730 else if (CONST_DOUBLE_LOW (x
) < 0)
2731 sprintf (buf1
, HOST_WIDE_INT_PRINT_HEX
, CONST_DOUBLE_LOW (x
));
2733 sprintf (buf1
, HOST_WIDE_INT_PRINT_DEC
,
2734 CONST_DOUBLE_LOW (x
));
2735 dyn_string_append (str
, buf1
);
2738 /* We can't handle floating point constants; PRINT_OPERAND must
2740 output_operand_lossage ("floating constant misused");
2744 /* Some assemblers need integer constants to appear last (eg masm). */
2745 if (GET_CODE (XEXP (x
, 0)) == CONST_INT
)
2747 addr_const_to_string (str
, XEXP (x
, 1));
2748 if (INTVAL (XEXP (x
, 0)) >= 0)
2749 dyn_string_append (str
, "+");
2751 addr_const_to_string (str
, XEXP (x
, 0));
2755 addr_const_to_string (str
, XEXP (x
, 0));
2756 if (INTVAL (XEXP (x
, 1)) >= 0)
2757 dyn_string_append (str
, "+");
2759 addr_const_to_string (str
, XEXP (x
, 1));
2764 /* Avoid outputting things like x-x or x+5-x, since some assemblers
2765 can't handle that. */
2766 x
= simplify_subtraction (x
);
2767 if (GET_CODE (x
) != MINUS
)
2770 addr_const_to_string (str
, XEXP (x
, 0));
2771 dyn_string_append (str
, "-");
2772 if (GET_CODE (XEXP (x
, 1)) == CONST_INT
2773 && INTVAL (XEXP (x
, 1)) < 0)
2775 dyn_string_append (str
, ASM_OPEN_PAREN
);
2776 addr_const_to_string (str
, XEXP (x
, 1));
2777 dyn_string_append (str
, ASM_CLOSE_PAREN
);
2780 addr_const_to_string (str
, XEXP (x
, 1));
2785 addr_const_to_string (str
, XEXP (x
, 0));
2789 output_operand_lossage ("invalid expression as operand");
2793 /* Convert an address constant to a string, and return a pointer to
2794 a copy of the result, located on the heap. */
2800 dyn_string_t ds
= dyn_string_new (256);
2803 addr_const_to_string (ds
, x
);
2805 /* Return the dynamically allocated string, but free the
2806 dyn_string_t itself. */
2812 /* Test if rtl node points to a pseudo register. */
2818 return (((GET_CODE (rtl
) == REG
) && (REGNO (rtl
) >= FIRST_PSEUDO_REGISTER
))
2819 || ((GET_CODE (rtl
) == SUBREG
)
2820 && (REGNO (XEXP (rtl
, 0)) >= FIRST_PSEUDO_REGISTER
)));
2823 /* Return a reference to a type, with its const and volatile qualifiers
2827 type_main_variant (type
)
2830 type
= TYPE_MAIN_VARIANT (type
);
2832 /* There really should be only one main variant among any group of variants
2833 of a given type (and all of the MAIN_VARIANT values for all members of
2834 the group should point to that one type) but sometimes the C front-end
2835 messes this up for array types, so we work around that bug here. */
2837 if (TREE_CODE (type
) == ARRAY_TYPE
)
2838 while (type
!= TYPE_MAIN_VARIANT (type
))
2839 type
= TYPE_MAIN_VARIANT (type
);
2844 /* Return non-zero if the given type node represents a tagged type. */
2847 is_tagged_type (type
)
2850 register enum tree_code code
= TREE_CODE (type
);
2852 return (code
== RECORD_TYPE
|| code
== UNION_TYPE
2853 || code
== QUAL_UNION_TYPE
|| code
== ENUMERAL_TYPE
);
2856 /* Convert a DIE tag into its string name. */
2859 dwarf_tag_name (tag
)
2860 register unsigned tag
;
2864 case DW_TAG_padding
:
2865 return "DW_TAG_padding";
2866 case DW_TAG_array_type
:
2867 return "DW_TAG_array_type";
2868 case DW_TAG_class_type
:
2869 return "DW_TAG_class_type";
2870 case DW_TAG_entry_point
:
2871 return "DW_TAG_entry_point";
2872 case DW_TAG_enumeration_type
:
2873 return "DW_TAG_enumeration_type";
2874 case DW_TAG_formal_parameter
:
2875 return "DW_TAG_formal_parameter";
2876 case DW_TAG_imported_declaration
:
2877 return "DW_TAG_imported_declaration";
2879 return "DW_TAG_label";
2880 case DW_TAG_lexical_block
:
2881 return "DW_TAG_lexical_block";
2883 return "DW_TAG_member";
2884 case DW_TAG_pointer_type
:
2885 return "DW_TAG_pointer_type";
2886 case DW_TAG_reference_type
:
2887 return "DW_TAG_reference_type";
2888 case DW_TAG_compile_unit
:
2889 return "DW_TAG_compile_unit";
2890 case DW_TAG_string_type
:
2891 return "DW_TAG_string_type";
2892 case DW_TAG_structure_type
:
2893 return "DW_TAG_structure_type";
2894 case DW_TAG_subroutine_type
:
2895 return "DW_TAG_subroutine_type";
2896 case DW_TAG_typedef
:
2897 return "DW_TAG_typedef";
2898 case DW_TAG_union_type
:
2899 return "DW_TAG_union_type";
2900 case DW_TAG_unspecified_parameters
:
2901 return "DW_TAG_unspecified_parameters";
2902 case DW_TAG_variant
:
2903 return "DW_TAG_variant";
2904 case DW_TAG_common_block
:
2905 return "DW_TAG_common_block";
2906 case DW_TAG_common_inclusion
:
2907 return "DW_TAG_common_inclusion";
2908 case DW_TAG_inheritance
:
2909 return "DW_TAG_inheritance";
2910 case DW_TAG_inlined_subroutine
:
2911 return "DW_TAG_inlined_subroutine";
2913 return "DW_TAG_module";
2914 case DW_TAG_ptr_to_member_type
:
2915 return "DW_TAG_ptr_to_member_type";
2916 case DW_TAG_set_type
:
2917 return "DW_TAG_set_type";
2918 case DW_TAG_subrange_type
:
2919 return "DW_TAG_subrange_type";
2920 case DW_TAG_with_stmt
:
2921 return "DW_TAG_with_stmt";
2922 case DW_TAG_access_declaration
:
2923 return "DW_TAG_access_declaration";
2924 case DW_TAG_base_type
:
2925 return "DW_TAG_base_type";
2926 case DW_TAG_catch_block
:
2927 return "DW_TAG_catch_block";
2928 case DW_TAG_const_type
:
2929 return "DW_TAG_const_type";
2930 case DW_TAG_constant
:
2931 return "DW_TAG_constant";
2932 case DW_TAG_enumerator
:
2933 return "DW_TAG_enumerator";
2934 case DW_TAG_file_type
:
2935 return "DW_TAG_file_type";
2937 return "DW_TAG_friend";
2938 case DW_TAG_namelist
:
2939 return "DW_TAG_namelist";
2940 case DW_TAG_namelist_item
:
2941 return "DW_TAG_namelist_item";
2942 case DW_TAG_packed_type
:
2943 return "DW_TAG_packed_type";
2944 case DW_TAG_subprogram
:
2945 return "DW_TAG_subprogram";
2946 case DW_TAG_template_type_param
:
2947 return "DW_TAG_template_type_param";
2948 case DW_TAG_template_value_param
:
2949 return "DW_TAG_template_value_param";
2950 case DW_TAG_thrown_type
:
2951 return "DW_TAG_thrown_type";
2952 case DW_TAG_try_block
:
2953 return "DW_TAG_try_block";
2954 case DW_TAG_variant_part
:
2955 return "DW_TAG_variant_part";
2956 case DW_TAG_variable
:
2957 return "DW_TAG_variable";
2958 case DW_TAG_volatile_type
:
2959 return "DW_TAG_volatile_type";
2960 case DW_TAG_MIPS_loop
:
2961 return "DW_TAG_MIPS_loop";
2962 case DW_TAG_format_label
:
2963 return "DW_TAG_format_label";
2964 case DW_TAG_function_template
:
2965 return "DW_TAG_function_template";
2966 case DW_TAG_class_template
:
2967 return "DW_TAG_class_template";
2969 return "DW_TAG_<unknown>";
2973 /* Convert a DWARF attribute code into its string name. */
2976 dwarf_attr_name (attr
)
2977 register unsigned attr
;
2982 return "DW_AT_sibling";
2983 case DW_AT_location
:
2984 return "DW_AT_location";
2986 return "DW_AT_name";
2987 case DW_AT_ordering
:
2988 return "DW_AT_ordering";
2989 case DW_AT_subscr_data
:
2990 return "DW_AT_subscr_data";
2991 case DW_AT_byte_size
:
2992 return "DW_AT_byte_size";
2993 case DW_AT_bit_offset
:
2994 return "DW_AT_bit_offset";
2995 case DW_AT_bit_size
:
2996 return "DW_AT_bit_size";
2997 case DW_AT_element_list
:
2998 return "DW_AT_element_list";
2999 case DW_AT_stmt_list
:
3000 return "DW_AT_stmt_list";
3002 return "DW_AT_low_pc";
3004 return "DW_AT_high_pc";
3005 case DW_AT_language
:
3006 return "DW_AT_language";
3008 return "DW_AT_member";
3010 return "DW_AT_discr";
3011 case DW_AT_discr_value
:
3012 return "DW_AT_discr_value";
3013 case DW_AT_visibility
:
3014 return "DW_AT_visibility";
3016 return "DW_AT_import";
3017 case DW_AT_string_length
:
3018 return "DW_AT_string_length";
3019 case DW_AT_common_reference
:
3020 return "DW_AT_common_reference";
3021 case DW_AT_comp_dir
:
3022 return "DW_AT_comp_dir";
3023 case DW_AT_const_value
:
3024 return "DW_AT_const_value";
3025 case DW_AT_containing_type
:
3026 return "DW_AT_containing_type";
3027 case DW_AT_default_value
:
3028 return "DW_AT_default_value";
3030 return "DW_AT_inline";
3031 case DW_AT_is_optional
:
3032 return "DW_AT_is_optional";
3033 case DW_AT_lower_bound
:
3034 return "DW_AT_lower_bound";
3035 case DW_AT_producer
:
3036 return "DW_AT_producer";
3037 case DW_AT_prototyped
:
3038 return "DW_AT_prototyped";
3039 case DW_AT_return_addr
:
3040 return "DW_AT_return_addr";
3041 case DW_AT_start_scope
:
3042 return "DW_AT_start_scope";
3043 case DW_AT_stride_size
:
3044 return "DW_AT_stride_size";
3045 case DW_AT_upper_bound
:
3046 return "DW_AT_upper_bound";
3047 case DW_AT_abstract_origin
:
3048 return "DW_AT_abstract_origin";
3049 case DW_AT_accessibility
:
3050 return "DW_AT_accessibility";
3051 case DW_AT_address_class
:
3052 return "DW_AT_address_class";
3053 case DW_AT_artificial
:
3054 return "DW_AT_artificial";
3055 case DW_AT_base_types
:
3056 return "DW_AT_base_types";
3057 case DW_AT_calling_convention
:
3058 return "DW_AT_calling_convention";
3060 return "DW_AT_count";
3061 case DW_AT_data_member_location
:
3062 return "DW_AT_data_member_location";
3063 case DW_AT_decl_column
:
3064 return "DW_AT_decl_column";
3065 case DW_AT_decl_file
:
3066 return "DW_AT_decl_file";
3067 case DW_AT_decl_line
:
3068 return "DW_AT_decl_line";
3069 case DW_AT_declaration
:
3070 return "DW_AT_declaration";
3071 case DW_AT_discr_list
:
3072 return "DW_AT_discr_list";
3073 case DW_AT_encoding
:
3074 return "DW_AT_encoding";
3075 case DW_AT_external
:
3076 return "DW_AT_external";
3077 case DW_AT_frame_base
:
3078 return "DW_AT_frame_base";
3080 return "DW_AT_friend";
3081 case DW_AT_identifier_case
:
3082 return "DW_AT_identifier_case";
3083 case DW_AT_macro_info
:
3084 return "DW_AT_macro_info";
3085 case DW_AT_namelist_items
:
3086 return "DW_AT_namelist_items";
3087 case DW_AT_priority
:
3088 return "DW_AT_priority";
3090 return "DW_AT_segment";
3091 case DW_AT_specification
:
3092 return "DW_AT_specification";
3093 case DW_AT_static_link
:
3094 return "DW_AT_static_link";
3096 return "DW_AT_type";
3097 case DW_AT_use_location
:
3098 return "DW_AT_use_location";
3099 case DW_AT_variable_parameter
:
3100 return "DW_AT_variable_parameter";
3101 case DW_AT_virtuality
:
3102 return "DW_AT_virtuality";
3103 case DW_AT_vtable_elem_location
:
3104 return "DW_AT_vtable_elem_location";
3106 case DW_AT_MIPS_fde
:
3107 return "DW_AT_MIPS_fde";
3108 case DW_AT_MIPS_loop_begin
:
3109 return "DW_AT_MIPS_loop_begin";
3110 case DW_AT_MIPS_tail_loop_begin
:
3111 return "DW_AT_MIPS_tail_loop_begin";
3112 case DW_AT_MIPS_epilog_begin
:
3113 return "DW_AT_MIPS_epilog_begin";
3114 case DW_AT_MIPS_loop_unroll_factor
:
3115 return "DW_AT_MIPS_loop_unroll_factor";
3116 case DW_AT_MIPS_software_pipeline_depth
:
3117 return "DW_AT_MIPS_software_pipeline_depth";
3118 case DW_AT_MIPS_linkage_name
:
3119 return "DW_AT_MIPS_linkage_name";
3120 case DW_AT_MIPS_stride
:
3121 return "DW_AT_MIPS_stride";
3122 case DW_AT_MIPS_abstract_name
:
3123 return "DW_AT_MIPS_abstract_name";
3124 case DW_AT_MIPS_clone_origin
:
3125 return "DW_AT_MIPS_clone_origin";
3126 case DW_AT_MIPS_has_inlines
:
3127 return "DW_AT_MIPS_has_inlines";
3129 case DW_AT_sf_names
:
3130 return "DW_AT_sf_names";
3131 case DW_AT_src_info
:
3132 return "DW_AT_src_info";
3133 case DW_AT_mac_info
:
3134 return "DW_AT_mac_info";
3135 case DW_AT_src_coords
:
3136 return "DW_AT_src_coords";
3137 case DW_AT_body_begin
:
3138 return "DW_AT_body_begin";
3139 case DW_AT_body_end
:
3140 return "DW_AT_body_end";
3142 return "DW_AT_<unknown>";
3146 /* Convert a DWARF value form code into its string name. */
3149 dwarf_form_name (form
)
3150 register unsigned form
;
3155 return "DW_FORM_addr";
3156 case DW_FORM_block2
:
3157 return "DW_FORM_block2";
3158 case DW_FORM_block4
:
3159 return "DW_FORM_block4";
3161 return "DW_FORM_data2";
3163 return "DW_FORM_data4";
3165 return "DW_FORM_data8";
3166 case DW_FORM_string
:
3167 return "DW_FORM_string";
3169 return "DW_FORM_block";
3170 case DW_FORM_block1
:
3171 return "DW_FORM_block1";
3173 return "DW_FORM_data1";
3175 return "DW_FORM_flag";
3177 return "DW_FORM_sdata";
3179 return "DW_FORM_strp";
3181 return "DW_FORM_udata";
3182 case DW_FORM_ref_addr
:
3183 return "DW_FORM_ref_addr";
3185 return "DW_FORM_ref1";
3187 return "DW_FORM_ref2";
3189 return "DW_FORM_ref4";
3191 return "DW_FORM_ref8";
3192 case DW_FORM_ref_udata
:
3193 return "DW_FORM_ref_udata";
3194 case DW_FORM_indirect
:
3195 return "DW_FORM_indirect";
3197 return "DW_FORM_<unknown>";
3201 /* Convert a DWARF stack opcode into its string name. */
3204 dwarf_stack_op_name (op
)
3205 register unsigned op
;
3210 return "DW_OP_addr";
3212 return "DW_OP_deref";
3214 return "DW_OP_const1u";
3216 return "DW_OP_const1s";
3218 return "DW_OP_const2u";
3220 return "DW_OP_const2s";
3222 return "DW_OP_const4u";
3224 return "DW_OP_const4s";
3226 return "DW_OP_const8u";
3228 return "DW_OP_const8s";
3230 return "DW_OP_constu";
3232 return "DW_OP_consts";
3236 return "DW_OP_drop";
3238 return "DW_OP_over";
3240 return "DW_OP_pick";
3242 return "DW_OP_swap";
3246 return "DW_OP_xderef";
3254 return "DW_OP_minus";
3266 return "DW_OP_plus";
3267 case DW_OP_plus_uconst
:
3268 return "DW_OP_plus_uconst";
3274 return "DW_OP_shra";
3292 return "DW_OP_skip";
3294 return "DW_OP_lit0";
3296 return "DW_OP_lit1";
3298 return "DW_OP_lit2";
3300 return "DW_OP_lit3";
3302 return "DW_OP_lit4";
3304 return "DW_OP_lit5";
3306 return "DW_OP_lit6";
3308 return "DW_OP_lit7";
3310 return "DW_OP_lit8";
3312 return "DW_OP_lit9";
3314 return "DW_OP_lit10";
3316 return "DW_OP_lit11";
3318 return "DW_OP_lit12";
3320 return "DW_OP_lit13";
3322 return "DW_OP_lit14";
3324 return "DW_OP_lit15";
3326 return "DW_OP_lit16";
3328 return "DW_OP_lit17";
3330 return "DW_OP_lit18";
3332 return "DW_OP_lit19";
3334 return "DW_OP_lit20";
3336 return "DW_OP_lit21";
3338 return "DW_OP_lit22";
3340 return "DW_OP_lit23";
3342 return "DW_OP_lit24";
3344 return "DW_OP_lit25";
3346 return "DW_OP_lit26";
3348 return "DW_OP_lit27";
3350 return "DW_OP_lit28";
3352 return "DW_OP_lit29";
3354 return "DW_OP_lit30";
3356 return "DW_OP_lit31";
3358 return "DW_OP_reg0";
3360 return "DW_OP_reg1";
3362 return "DW_OP_reg2";
3364 return "DW_OP_reg3";
3366 return "DW_OP_reg4";
3368 return "DW_OP_reg5";
3370 return "DW_OP_reg6";
3372 return "DW_OP_reg7";
3374 return "DW_OP_reg8";
3376 return "DW_OP_reg9";
3378 return "DW_OP_reg10";
3380 return "DW_OP_reg11";
3382 return "DW_OP_reg12";
3384 return "DW_OP_reg13";
3386 return "DW_OP_reg14";
3388 return "DW_OP_reg15";
3390 return "DW_OP_reg16";
3392 return "DW_OP_reg17";
3394 return "DW_OP_reg18";
3396 return "DW_OP_reg19";
3398 return "DW_OP_reg20";
3400 return "DW_OP_reg21";
3402 return "DW_OP_reg22";
3404 return "DW_OP_reg23";
3406 return "DW_OP_reg24";
3408 return "DW_OP_reg25";
3410 return "DW_OP_reg26";
3412 return "DW_OP_reg27";
3414 return "DW_OP_reg28";
3416 return "DW_OP_reg29";
3418 return "DW_OP_reg30";
3420 return "DW_OP_reg31";
3422 return "DW_OP_breg0";
3424 return "DW_OP_breg1";
3426 return "DW_OP_breg2";
3428 return "DW_OP_breg3";
3430 return "DW_OP_breg4";
3432 return "DW_OP_breg5";
3434 return "DW_OP_breg6";
3436 return "DW_OP_breg7";
3438 return "DW_OP_breg8";
3440 return "DW_OP_breg9";
3442 return "DW_OP_breg10";
3444 return "DW_OP_breg11";
3446 return "DW_OP_breg12";
3448 return "DW_OP_breg13";
3450 return "DW_OP_breg14";
3452 return "DW_OP_breg15";
3454 return "DW_OP_breg16";
3456 return "DW_OP_breg17";
3458 return "DW_OP_breg18";
3460 return "DW_OP_breg19";
3462 return "DW_OP_breg20";
3464 return "DW_OP_breg21";
3466 return "DW_OP_breg22";
3468 return "DW_OP_breg23";
3470 return "DW_OP_breg24";
3472 return "DW_OP_breg25";
3474 return "DW_OP_breg26";
3476 return "DW_OP_breg27";
3478 return "DW_OP_breg28";
3480 return "DW_OP_breg29";
3482 return "DW_OP_breg30";
3484 return "DW_OP_breg31";
3486 return "DW_OP_regx";
3488 return "DW_OP_fbreg";
3490 return "DW_OP_bregx";
3492 return "DW_OP_piece";
3493 case DW_OP_deref_size
:
3494 return "DW_OP_deref_size";
3495 case DW_OP_xderef_size
:
3496 return "DW_OP_xderef_size";
3500 return "OP_<unknown>";
3504 /* Convert a DWARF type code into its string name. */
3508 dwarf_type_encoding_name (enc
)
3509 register unsigned enc
;
3513 case DW_ATE_address
:
3514 return "DW_ATE_address";
3515 case DW_ATE_boolean
:
3516 return "DW_ATE_boolean";
3517 case DW_ATE_complex_float
:
3518 return "DW_ATE_complex_float";
3520 return "DW_ATE_float";
3522 return "DW_ATE_signed";
3523 case DW_ATE_signed_char
:
3524 return "DW_ATE_signed_char";
3525 case DW_ATE_unsigned
:
3526 return "DW_ATE_unsigned";
3527 case DW_ATE_unsigned_char
:
3528 return "DW_ATE_unsigned_char";
3530 return "DW_ATE_<unknown>";
3535 /* Determine the "ultimate origin" of a decl. The decl may be an inlined
3536 instance of an inlined instance of a decl which is local to an inline
3537 function, so we have to trace all of the way back through the origin chain
3538 to find out what sort of node actually served as the original seed for the
3542 decl_ultimate_origin (decl
)
3545 #ifdef ENABLE_CHECKING
3546 if (DECL_FROM_INLINE (DECL_ORIGIN (decl
)))
3547 /* Since the DECL_ABSTRACT_ORIGIN for a DECL is supposed to be the
3548 most distant ancestor, this should never happen. */
3552 return DECL_ABSTRACT_ORIGIN (decl
);
3555 /* Determine the "ultimate origin" of a block. The block may be an inlined
3556 instance of an inlined instance of a block which is local to an inline
3557 function, so we have to trace all of the way back through the origin chain
3558 to find out what sort of node actually served as the original seed for the
3562 block_ultimate_origin (block
)
3563 register tree block
;
3565 register tree immediate_origin
= BLOCK_ABSTRACT_ORIGIN (block
);
3567 if (immediate_origin
== NULL_TREE
)
3571 register tree ret_val
;
3572 register tree lookahead
= immediate_origin
;
3576 ret_val
= lookahead
;
3577 lookahead
= (TREE_CODE (ret_val
) == BLOCK
)
3578 ? BLOCK_ABSTRACT_ORIGIN (ret_val
)
3581 while (lookahead
!= NULL
&& lookahead
!= ret_val
);
3587 /* Get the class to which DECL belongs, if any. In g++, the DECL_CONTEXT
3588 of a virtual function may refer to a base class, so we check the 'this'
3592 decl_class_context (decl
)
3595 tree context
= NULL_TREE
;
3597 if (TREE_CODE (decl
) != FUNCTION_DECL
|| ! DECL_VINDEX (decl
))
3598 context
= DECL_CONTEXT (decl
);
3600 context
= TYPE_MAIN_VARIANT
3601 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)))));
3603 if (context
&& TREE_CODE_CLASS (TREE_CODE (context
)) != 't')
3604 context
= NULL_TREE
;
3609 /* Add an attribute/value pair to a DIE. We build the lists up in reverse
3610 addition order, and correct that in add_sibling_attributes. */
3613 add_dwarf_attr (die
, attr
)
3614 register dw_die_ref die
;
3615 register dw_attr_ref attr
;
3617 if (die
!= NULL
&& attr
!= NULL
)
3619 attr
->dw_attr_next
= die
->die_attr
;
3620 die
->die_attr
= attr
;
3624 static inline dw_val_class
3628 return a
->dw_attr_val
.val_class
;
3631 /* Add a flag value attribute to a DIE. */
3634 add_AT_flag (die
, attr_kind
, flag
)
3635 register dw_die_ref die
;
3636 register enum dwarf_attribute attr_kind
;
3637 register unsigned flag
;
3639 register dw_attr_ref attr
= (dw_attr_ref
) xmalloc (sizeof (dw_attr_node
));
3641 attr
->dw_attr_next
= NULL
;
3642 attr
->dw_attr
= attr_kind
;
3643 attr
->dw_attr_val
.val_class
= dw_val_class_flag
;
3644 attr
->dw_attr_val
.v
.val_flag
= flag
;
3645 add_dwarf_attr (die
, attr
);
3648 static inline unsigned
3650 register dw_attr_ref a
;
3652 if (a
&& AT_class (a
) == dw_val_class_flag
)
3653 return a
->dw_attr_val
.v
.val_flag
;
3658 /* Add a signed integer attribute value to a DIE. */
3661 add_AT_int (die
, attr_kind
, int_val
)
3662 register dw_die_ref die
;
3663 register enum dwarf_attribute attr_kind
;
3664 register long int int_val
;
3666 register dw_attr_ref attr
= (dw_attr_ref
) xmalloc (sizeof (dw_attr_node
));
3668 attr
->dw_attr_next
= NULL
;
3669 attr
->dw_attr
= attr_kind
;
3670 attr
->dw_attr_val
.val_class
= dw_val_class_const
;
3671 attr
->dw_attr_val
.v
.val_int
= int_val
;
3672 add_dwarf_attr (die
, attr
);
3675 static inline long int
3677 register dw_attr_ref a
;
3679 if (a
&& AT_class (a
) == dw_val_class_const
)
3680 return a
->dw_attr_val
.v
.val_int
;
3685 /* Add an unsigned integer attribute value to a DIE. */
3688 add_AT_unsigned (die
, attr_kind
, unsigned_val
)
3689 register dw_die_ref die
;
3690 register enum dwarf_attribute attr_kind
;
3691 register unsigned long unsigned_val
;
3693 register dw_attr_ref attr
= (dw_attr_ref
) xmalloc (sizeof (dw_attr_node
));
3695 attr
->dw_attr_next
= NULL
;
3696 attr
->dw_attr
= attr_kind
;
3697 attr
->dw_attr_val
.val_class
= dw_val_class_unsigned_const
;
3698 attr
->dw_attr_val
.v
.val_unsigned
= unsigned_val
;
3699 add_dwarf_attr (die
, attr
);
3702 static inline unsigned long
3704 register dw_attr_ref a
;
3706 if (a
&& AT_class (a
) == dw_val_class_unsigned_const
)
3707 return a
->dw_attr_val
.v
.val_unsigned
;
3712 /* Add an unsigned double integer attribute value to a DIE. */
3715 add_AT_long_long (die
, attr_kind
, val_hi
, val_low
)
3716 register dw_die_ref die
;
3717 register enum dwarf_attribute attr_kind
;
3718 register unsigned long val_hi
;
3719 register unsigned long val_low
;
3721 register dw_attr_ref attr
= (dw_attr_ref
) xmalloc (sizeof (dw_attr_node
));
3723 attr
->dw_attr_next
= NULL
;
3724 attr
->dw_attr
= attr_kind
;
3725 attr
->dw_attr_val
.val_class
= dw_val_class_long_long
;
3726 attr
->dw_attr_val
.v
.val_long_long
.hi
= val_hi
;
3727 attr
->dw_attr_val
.v
.val_long_long
.low
= val_low
;
3728 add_dwarf_attr (die
, attr
);
3731 /* Add a floating point attribute value to a DIE and return it. */
3734 add_AT_float (die
, attr_kind
, length
, array
)
3735 register dw_die_ref die
;
3736 register enum dwarf_attribute attr_kind
;
3737 register unsigned length
;
3738 register long *array
;
3740 register dw_attr_ref attr
= (dw_attr_ref
) xmalloc (sizeof (dw_attr_node
));
3742 attr
->dw_attr_next
= NULL
;
3743 attr
->dw_attr
= attr_kind
;
3744 attr
->dw_attr_val
.val_class
= dw_val_class_float
;
3745 attr
->dw_attr_val
.v
.val_float
.length
= length
;
3746 attr
->dw_attr_val
.v
.val_float
.array
= array
;
3747 add_dwarf_attr (die
, attr
);
3750 /* Add a string attribute value to a DIE. */
3753 add_AT_string (die
, attr_kind
, str
)
3754 register dw_die_ref die
;
3755 register enum dwarf_attribute attr_kind
;
3756 register const char *str
;
3758 register dw_attr_ref attr
= (dw_attr_ref
) xmalloc (sizeof (dw_attr_node
));
3760 attr
->dw_attr_next
= NULL
;
3761 attr
->dw_attr
= attr_kind
;
3762 attr
->dw_attr_val
.val_class
= dw_val_class_str
;
3763 attr
->dw_attr_val
.v
.val_str
= xstrdup (str
);
3764 add_dwarf_attr (die
, attr
);
3767 static inline const char *
3769 register dw_attr_ref a
;
3771 if (a
&& AT_class (a
) == dw_val_class_str
)
3772 return a
->dw_attr_val
.v
.val_str
;
3777 /* Add a DIE reference attribute value to a DIE. */
3780 add_AT_die_ref (die
, attr_kind
, targ_die
)
3781 register dw_die_ref die
;
3782 register enum dwarf_attribute attr_kind
;
3783 register dw_die_ref targ_die
;
3785 register dw_attr_ref attr
= (dw_attr_ref
) xmalloc (sizeof (dw_attr_node
));
3787 attr
->dw_attr_next
= NULL
;
3788 attr
->dw_attr
= attr_kind
;
3789 attr
->dw_attr_val
.val_class
= dw_val_class_die_ref
;
3790 attr
->dw_attr_val
.v
.val_die_ref
= targ_die
;
3791 add_dwarf_attr (die
, attr
);
3794 static inline dw_die_ref
3796 register dw_attr_ref a
;
3798 if (a
&& AT_class (a
) == dw_val_class_die_ref
)
3799 return a
->dw_attr_val
.v
.val_die_ref
;
3804 /* Add an FDE reference attribute value to a DIE. */
3807 add_AT_fde_ref (die
, attr_kind
, targ_fde
)
3808 register dw_die_ref die
;
3809 register enum dwarf_attribute attr_kind
;
3810 register unsigned targ_fde
;
3812 register dw_attr_ref attr
= (dw_attr_ref
) xmalloc (sizeof (dw_attr_node
));
3814 attr
->dw_attr_next
= NULL
;
3815 attr
->dw_attr
= attr_kind
;
3816 attr
->dw_attr_val
.val_class
= dw_val_class_fde_ref
;
3817 attr
->dw_attr_val
.v
.val_fde_index
= targ_fde
;
3818 add_dwarf_attr (die
, attr
);
3821 /* Add a location description attribute value to a DIE. */
3824 add_AT_loc (die
, attr_kind
, loc
)
3825 register dw_die_ref die
;
3826 register enum dwarf_attribute attr_kind
;
3827 register dw_loc_descr_ref loc
;
3829 register dw_attr_ref attr
= (dw_attr_ref
) xmalloc (sizeof (dw_attr_node
));
3831 attr
->dw_attr_next
= NULL
;
3832 attr
->dw_attr
= attr_kind
;
3833 attr
->dw_attr_val
.val_class
= dw_val_class_loc
;
3834 attr
->dw_attr_val
.v
.val_loc
= loc
;
3835 add_dwarf_attr (die
, attr
);
3838 static inline dw_loc_descr_ref
3840 register dw_attr_ref a
;
3842 if (a
&& AT_class (a
) == dw_val_class_loc
)
3843 return a
->dw_attr_val
.v
.val_loc
;
3848 /* Add an address constant attribute value to a DIE. */
3851 add_AT_addr (die
, attr_kind
, addr
)
3852 register dw_die_ref die
;
3853 register enum dwarf_attribute attr_kind
;
3856 register dw_attr_ref attr
= (dw_attr_ref
) xmalloc (sizeof (dw_attr_node
));
3858 attr
->dw_attr_next
= NULL
;
3859 attr
->dw_attr
= attr_kind
;
3860 attr
->dw_attr_val
.val_class
= dw_val_class_addr
;
3861 attr
->dw_attr_val
.v
.val_addr
= addr
;
3862 add_dwarf_attr (die
, attr
);
3865 static inline const char *
3867 register dw_attr_ref a
;
3869 if (a
&& AT_class (a
) == dw_val_class_addr
)
3870 return a
->dw_attr_val
.v
.val_addr
;
3875 /* Add a label identifier attribute value to a DIE. */
3878 add_AT_lbl_id (die
, attr_kind
, lbl_id
)
3879 register dw_die_ref die
;
3880 register enum dwarf_attribute attr_kind
;
3881 register char *lbl_id
;
3883 register dw_attr_ref attr
= (dw_attr_ref
) xmalloc (sizeof (dw_attr_node
));
3885 attr
->dw_attr_next
= NULL
;
3886 attr
->dw_attr
= attr_kind
;
3887 attr
->dw_attr_val
.val_class
= dw_val_class_lbl_id
;
3888 attr
->dw_attr_val
.v
.val_lbl_id
= xstrdup (lbl_id
);
3889 add_dwarf_attr (die
, attr
);
3892 /* Add a section offset attribute value to a DIE. */
3895 add_AT_lbl_offset (die
, attr_kind
, label
)
3896 register dw_die_ref die
;
3897 register enum dwarf_attribute attr_kind
;
3898 register char *label
;
3900 register dw_attr_ref attr
= (dw_attr_ref
) xmalloc (sizeof (dw_attr_node
));
3902 attr
->dw_attr_next
= NULL
;
3903 attr
->dw_attr
= attr_kind
;
3904 attr
->dw_attr_val
.val_class
= dw_val_class_lbl_offset
;
3905 attr
->dw_attr_val
.v
.val_lbl_id
= xstrdup (label
);
3906 add_dwarf_attr (die
, attr
);
3910 static inline const char *
3912 register dw_attr_ref a
;
3914 if (a
&& (AT_class (a
) == dw_val_class_lbl_id
3915 || AT_class (a
) == dw_val_class_lbl_offset
))
3916 return a
->dw_attr_val
.v
.val_lbl_id
;
3921 /* Get the attribute of type attr_kind. */
3923 static inline dw_attr_ref
3924 get_AT (die
, attr_kind
)
3925 register dw_die_ref die
;
3926 register enum dwarf_attribute attr_kind
;
3928 register dw_attr_ref a
;
3929 register dw_die_ref spec
= NULL
;
3933 for (a
= die
->die_attr
; a
!= NULL
; a
= a
->dw_attr_next
)
3935 if (a
->dw_attr
== attr_kind
)
3938 if (a
->dw_attr
== DW_AT_specification
3939 || a
->dw_attr
== DW_AT_abstract_origin
)
3944 return get_AT (spec
, attr_kind
);
3950 /* Return the "low pc" attribute value, typically associated with
3951 a subprogram DIE. Return null if the "low pc" attribute is
3952 either not prsent, or if it cannot be represented as an
3953 assembler label identifier. */
3955 static inline const char *
3957 register dw_die_ref die
;
3959 register dw_attr_ref a
= get_AT (die
, DW_AT_low_pc
);
3963 /* Return the "high pc" attribute value, typically associated with
3964 a subprogram DIE. Return null if the "high pc" attribute is
3965 either not prsent, or if it cannot be represented as an
3966 assembler label identifier. */
3968 static inline const char *
3970 register dw_die_ref die
;
3972 register dw_attr_ref a
= get_AT (die
, DW_AT_high_pc
);
3976 /* Return the value of the string attribute designated by ATTR_KIND, or
3977 NULL if it is not present. */
3979 static inline const char *
3980 get_AT_string (die
, attr_kind
)
3981 register dw_die_ref die
;
3982 register enum dwarf_attribute attr_kind
;
3984 register dw_attr_ref a
= get_AT (die
, attr_kind
);
3985 return AT_string (a
);
3988 /* Return the value of the flag attribute designated by ATTR_KIND, or -1
3989 if it is not present. */
3992 get_AT_flag (die
, attr_kind
)
3993 register dw_die_ref die
;
3994 register enum dwarf_attribute attr_kind
;
3996 register dw_attr_ref a
= get_AT (die
, attr_kind
);
4000 /* Return the value of the unsigned attribute designated by ATTR_KIND, or 0
4001 if it is not present. */
4003 static inline unsigned
4004 get_AT_unsigned (die
, attr_kind
)
4005 register dw_die_ref die
;
4006 register enum dwarf_attribute attr_kind
;
4008 register dw_attr_ref a
= get_AT (die
, attr_kind
);
4009 return AT_unsigned (a
);
4012 static inline dw_die_ref
4013 get_AT_ref (die
, attr_kind
)
4015 register enum dwarf_attribute attr_kind
;
4017 register dw_attr_ref a
= get_AT (die
, attr_kind
);
4024 register unsigned lang
= get_AT_unsigned (comp_unit_die
, DW_AT_language
);
4026 return (lang
== DW_LANG_C
|| lang
== DW_LANG_C89
4027 || lang
== DW_LANG_C_plus_plus
);
4033 register unsigned lang
= get_AT_unsigned (comp_unit_die
, DW_AT_language
);
4035 return (lang
== DW_LANG_Fortran77
|| lang
== DW_LANG_Fortran90
);
4038 /* Remove the specified attribute if present. */
4041 remove_AT (die
, attr_kind
)
4042 register dw_die_ref die
;
4043 register enum dwarf_attribute attr_kind
;
4045 register dw_attr_ref
*p
;
4046 register dw_attr_ref removed
= NULL
;
4050 for (p
= &(die
->die_attr
); *p
; p
= &((*p
)->dw_attr_next
))
4051 if ((*p
)->dw_attr
== attr_kind
)
4054 *p
= (*p
)->dw_attr_next
;
4060 switch (AT_class (removed
))
4062 case dw_val_class_addr
:
4063 case dw_val_class_str
:
4064 case dw_val_class_lbl_id
:
4065 case dw_val_class_lbl_offset
:
4066 free (removed
->dw_attr_val
.v
.val_str
);
4078 /* Discard the children of this DIE. */
4081 remove_children (die
)
4082 register dw_die_ref die
;
4084 register dw_die_ref child_die
= die
->die_child
;
4086 die
->die_child
= NULL
;
4088 while (child_die
!= NULL
)
4090 register dw_die_ref tmp_die
= child_die
;
4091 register dw_attr_ref a
;
4093 child_die
= child_die
->die_sib
;
4095 for (a
= tmp_die
->die_attr
; a
!= NULL
; )
4097 register dw_attr_ref tmp_a
= a
;
4099 a
= a
->dw_attr_next
;
4107 /* Add a child DIE below its parent. We build the lists up in reverse
4108 addition order, and correct that in add_sibling_attributes. */
4111 add_child_die (die
, child_die
)
4112 register dw_die_ref die
;
4113 register dw_die_ref child_die
;
4115 if (die
!= NULL
&& child_die
!= NULL
)
4117 if (die
== child_die
)
4119 child_die
->die_parent
= die
;
4120 child_die
->die_sib
= die
->die_child
;
4121 die
->die_child
= child_die
;
4125 /* Return a pointer to a newly created DIE node. */
4127 static inline dw_die_ref
4128 new_die (tag_value
, parent_die
)
4129 register enum dwarf_tag tag_value
;
4130 register dw_die_ref parent_die
;
4132 register dw_die_ref die
= (dw_die_ref
) xmalloc (sizeof (die_node
));
4134 die
->die_tag
= tag_value
;
4135 die
->die_abbrev
= 0;
4136 die
->die_offset
= 0;
4137 die
->die_child
= NULL
;
4138 die
->die_parent
= NULL
;
4139 die
->die_sib
= NULL
;
4140 die
->die_attr
= NULL
;
4142 if (parent_die
!= NULL
)
4143 add_child_die (parent_die
, die
);
4146 limbo_die_node
*limbo_node
;
4148 limbo_node
= (limbo_die_node
*) xmalloc (sizeof (limbo_die_node
));
4149 limbo_node
->die
= die
;
4150 limbo_node
->next
= limbo_die_list
;
4151 limbo_die_list
= limbo_node
;
4157 /* Return the DIE associated with the given type specifier. */
4159 static inline dw_die_ref
4160 lookup_type_die (type
)
4163 return (dw_die_ref
) TYPE_SYMTAB_POINTER (type
);
4166 /* Equate a DIE to a given type specifier. */
4169 equate_type_number_to_die (type
, type_die
)
4171 register dw_die_ref type_die
;
4173 TYPE_SYMTAB_POINTER (type
) = (char *) type_die
;
4176 /* Return the DIE associated with a given declaration. */
4178 static inline dw_die_ref
4179 lookup_decl_die (decl
)
4182 register unsigned decl_id
= DECL_UID (decl
);
4184 return (decl_id
< decl_die_table_in_use
4185 ? decl_die_table
[decl_id
] : NULL
);
4188 /* Equate a DIE to a particular declaration. */
4191 equate_decl_number_to_die (decl
, decl_die
)
4193 register dw_die_ref decl_die
;
4195 register unsigned decl_id
= DECL_UID (decl
);
4196 register unsigned num_allocated
;
4198 if (decl_id
>= decl_die_table_allocated
)
4201 = ((decl_id
+ 1 + DECL_DIE_TABLE_INCREMENT
- 1)
4202 / DECL_DIE_TABLE_INCREMENT
)
4203 * DECL_DIE_TABLE_INCREMENT
;
4206 = (dw_die_ref
*) xrealloc (decl_die_table
,
4207 sizeof (dw_die_ref
) * num_allocated
);
4209 bzero ((char *) &decl_die_table
[decl_die_table_allocated
],
4210 (num_allocated
- decl_die_table_allocated
) * sizeof (dw_die_ref
));
4211 decl_die_table_allocated
= num_allocated
;
4214 if (decl_id
>= decl_die_table_in_use
)
4215 decl_die_table_in_use
= (decl_id
+ 1);
4217 decl_die_table
[decl_id
] = decl_die
;
4220 /* Return a pointer to a newly allocated location description. Location
4221 descriptions are simple expression terms that can be strung
4222 together to form more complicated location (address) descriptions. */
4224 static inline dw_loc_descr_ref
4225 new_loc_descr (op
, oprnd1
, oprnd2
)
4226 register enum dwarf_location_atom op
;
4227 register unsigned long oprnd1
;
4228 register unsigned long oprnd2
;
4230 register dw_loc_descr_ref descr
4231 = (dw_loc_descr_ref
) xmalloc (sizeof (dw_loc_descr_node
));
4233 descr
->dw_loc_next
= NULL
;
4234 descr
->dw_loc_opc
= op
;
4235 descr
->dw_loc_oprnd1
.val_class
= dw_val_class_unsigned_const
;
4236 descr
->dw_loc_oprnd1
.v
.val_unsigned
= oprnd1
;
4237 descr
->dw_loc_oprnd2
.val_class
= dw_val_class_unsigned_const
;
4238 descr
->dw_loc_oprnd2
.v
.val_unsigned
= oprnd2
;
4243 /* Add a location description term to a location description expression. */
4246 add_loc_descr (list_head
, descr
)
4247 register dw_loc_descr_ref
*list_head
;
4248 register dw_loc_descr_ref descr
;
4250 register dw_loc_descr_ref
*d
;
4252 /* Find the end of the chain. */
4253 for (d
= list_head
; (*d
) != NULL
; d
= &(*d
)->dw_loc_next
)
4259 /* Keep track of the number of spaces used to indent the
4260 output of the debugging routines that print the structure of
4261 the DIE internal representation. */
4262 static int print_indent
;
4264 /* Indent the line the number of spaces given by print_indent. */
4267 print_spaces (outfile
)
4270 fprintf (outfile
, "%*s", print_indent
, "");
4273 /* Print the information associated with a given DIE, and its children.
4274 This routine is a debugging aid only. */
4277 print_die (die
, outfile
)
4281 register dw_attr_ref a
;
4282 register dw_die_ref c
;
4284 print_spaces (outfile
);
4285 fprintf (outfile
, "DIE %4lu: %s\n",
4286 die
->die_offset
, dwarf_tag_name (die
->die_tag
));
4287 print_spaces (outfile
);
4288 fprintf (outfile
, " abbrev id: %lu", die
->die_abbrev
);
4289 fprintf (outfile
, " offset: %lu\n", die
->die_offset
);
4291 for (a
= die
->die_attr
; a
!= NULL
; a
= a
->dw_attr_next
)
4293 print_spaces (outfile
);
4294 fprintf (outfile
, " %s: ", dwarf_attr_name (a
->dw_attr
));
4296 switch (AT_class (a
))
4298 case dw_val_class_addr
:
4299 fprintf (outfile
, "address");
4301 case dw_val_class_loc
:
4302 fprintf (outfile
, "location descriptor");
4304 case dw_val_class_const
:
4305 fprintf (outfile
, "%ld", AT_int (a
));
4307 case dw_val_class_unsigned_const
:
4308 fprintf (outfile
, "%lu", AT_unsigned (a
));
4310 case dw_val_class_long_long
:
4311 fprintf (outfile
, "constant (%lu,%lu)",
4312 a
->dw_attr_val
.v
.val_long_long
.hi
,
4313 a
->dw_attr_val
.v
.val_long_long
.low
);
4315 case dw_val_class_float
:
4316 fprintf (outfile
, "floating-point constant");
4318 case dw_val_class_flag
:
4319 fprintf (outfile
, "%u", AT_flag (a
));
4321 case dw_val_class_die_ref
:
4322 if (AT_ref (a
) != NULL
)
4323 fprintf (outfile
, "die -> %lu", AT_ref (a
)->die_offset
);
4325 fprintf (outfile
, "die -> <null>");
4327 case dw_val_class_lbl_id
:
4328 case dw_val_class_lbl_offset
:
4329 fprintf (outfile
, "label: %s", AT_lbl (a
));
4331 case dw_val_class_str
:
4332 if (AT_string (a
) != NULL
)
4333 fprintf (outfile
, "\"%s\"", AT_string (a
));
4335 fprintf (outfile
, "<null>");
4341 fprintf (outfile
, "\n");
4344 if (die
->die_child
!= NULL
)
4347 for (c
= die
->die_child
; c
!= NULL
; c
= c
->die_sib
)
4348 print_die (c
, outfile
);
4354 /* Print the contents of the source code line number correspondence table.
4355 This routine is a debugging aid only. */
4358 print_dwarf_line_table (outfile
)
4361 register unsigned i
;
4362 register dw_line_info_ref line_info
;
4364 fprintf (outfile
, "\n\nDWARF source line information\n");
4365 for (i
= 1; i
< line_info_table_in_use
; ++i
)
4367 line_info
= &line_info_table
[i
];
4368 fprintf (outfile
, "%5d: ", i
);
4369 fprintf (outfile
, "%-20s", file_table
[line_info
->dw_file_num
]);
4370 fprintf (outfile
, "%6ld", line_info
->dw_line_num
);
4371 fprintf (outfile
, "\n");
4374 fprintf (outfile
, "\n\n");
4377 /* Print the information collected for a given DIE. */
4380 debug_dwarf_die (die
)
4383 print_die (die
, stderr
);
4386 /* Print all DWARF information collected for the compilation unit.
4387 This routine is a debugging aid only. */
4393 print_die (comp_unit_die
, stderr
);
4394 if (! DWARF2_ASM_LINE_DEBUG_INFO
)
4395 print_dwarf_line_table (stderr
);
4398 /* We build up the lists of children and attributes by pushing new ones
4399 onto the beginning of the list. Reverse the lists for DIE so that
4400 they are in order of addition. */
4403 reverse_die_lists (die
)
4404 register dw_die_ref die
;
4406 register dw_die_ref c
, cp
, cn
;
4407 register dw_attr_ref a
, ap
, an
;
4409 for (a
= die
->die_attr
, ap
= 0; a
; a
= an
)
4411 an
= a
->dw_attr_next
;
4412 a
->dw_attr_next
= ap
;
4417 for (c
= die
->die_child
, cp
= 0; c
; c
= cn
)
4423 die
->die_child
= cp
;
4426 /* Traverse the DIE, reverse its lists of attributes and children, and
4427 add a sibling attribute if it may have the effect of speeding up
4428 access to siblings. To save some space, avoid generating sibling
4429 attributes for DIE's without children. */
4432 add_sibling_attributes (die
)
4433 register dw_die_ref die
;
4435 register dw_die_ref c
;
4437 reverse_die_lists (die
);
4439 if (die
!= comp_unit_die
&& die
->die_sib
&& die
->die_child
!= NULL
)
4440 /* Add the sibling link to the front of the attribute list. */
4441 add_AT_die_ref (die
, DW_AT_sibling
, die
->die_sib
);
4443 for (c
= die
->die_child
; c
!= NULL
; c
= c
->die_sib
)
4444 add_sibling_attributes (c
);
4447 /* The format of each DIE (and its attribute value pairs)
4448 is encoded in an abbreviation table. This routine builds the
4449 abbreviation table and assigns a unique abbreviation id for
4450 each abbreviation entry. The children of each die are visited
4454 build_abbrev_table (die
)
4455 register dw_die_ref die
;
4457 register unsigned long abbrev_id
;
4458 register unsigned long n_alloc
;
4459 register dw_die_ref c
;
4460 register dw_attr_ref d_attr
, a_attr
;
4461 for (abbrev_id
= 1; abbrev_id
< abbrev_die_table_in_use
; ++abbrev_id
)
4463 register dw_die_ref abbrev
= abbrev_die_table
[abbrev_id
];
4465 if (abbrev
->die_tag
== die
->die_tag
)
4467 if ((abbrev
->die_child
!= NULL
) == (die
->die_child
!= NULL
))
4469 a_attr
= abbrev
->die_attr
;
4470 d_attr
= die
->die_attr
;
4472 while (a_attr
!= NULL
&& d_attr
!= NULL
)
4474 if ((a_attr
->dw_attr
!= d_attr
->dw_attr
)
4475 || (value_format (a_attr
) != value_format (d_attr
)))
4478 a_attr
= a_attr
->dw_attr_next
;
4479 d_attr
= d_attr
->dw_attr_next
;
4482 if (a_attr
== NULL
&& d_attr
== NULL
)
4488 if (abbrev_id
>= abbrev_die_table_in_use
)
4490 if (abbrev_die_table_in_use
>= abbrev_die_table_allocated
)
4492 n_alloc
= abbrev_die_table_allocated
+ ABBREV_DIE_TABLE_INCREMENT
;
4494 = (dw_die_ref
*) xrealloc (abbrev_die_table
,
4495 sizeof (dw_die_ref
) * n_alloc
);
4497 bzero ((char *) &abbrev_die_table
[abbrev_die_table_allocated
],
4498 (n_alloc
- abbrev_die_table_allocated
) * sizeof (dw_die_ref
));
4499 abbrev_die_table_allocated
= n_alloc
;
4502 ++abbrev_die_table_in_use
;
4503 abbrev_die_table
[abbrev_id
] = die
;
4506 die
->die_abbrev
= abbrev_id
;
4507 for (c
= die
->die_child
; c
!= NULL
; c
= c
->die_sib
)
4508 build_abbrev_table (c
);
4511 /* Return the size of a string, including the null byte.
4513 This used to treat backslashes as escapes, and hence they were not included
4514 in the count. However, that conflicts with what ASM_OUTPUT_ASCII does,
4515 which treats a backslash as a backslash, escaping it if necessary, and hence
4516 we must include them in the count. */
4518 static unsigned long
4519 size_of_string (str
)
4520 register const char *str
;
4522 return strlen (str
) + 1;
4525 /* Return the size of a location descriptor. */
4527 static unsigned long
4528 size_of_loc_descr (loc
)
4529 register dw_loc_descr_ref loc
;
4531 register unsigned long size
= 1;
4533 switch (loc
->dw_loc_opc
)
4555 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
4558 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
4563 case DW_OP_plus_uconst
:
4564 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
4602 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
4605 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
4608 size
+= size_of_sleb128 (loc
->dw_loc_oprnd1
.v
.val_int
);
4611 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
4612 size
+= size_of_sleb128 (loc
->dw_loc_oprnd2
.v
.val_int
);
4615 size
+= size_of_uleb128 (loc
->dw_loc_oprnd1
.v
.val_unsigned
);
4617 case DW_OP_deref_size
:
4618 case DW_OP_xderef_size
:
4628 /* Return the size of a series of location descriptors. */
4630 static unsigned long
4632 register dw_loc_descr_ref loc
;
4634 register unsigned long size
= 0;
4636 for (; loc
!= NULL
; loc
= loc
->dw_loc_next
)
4637 size
+= size_of_loc_descr (loc
);
4642 /* Return the power-of-two number of bytes necessary to represent VALUE. */
4645 constant_size (value
)
4646 long unsigned value
;
4653 log
= floor_log2 (value
);
4656 log
= 1 << (floor_log2 (log
) + 1);
4661 /* Return the size of a DIE, as it is represented in the
4662 .debug_info section. */
4664 static unsigned long
4666 register dw_die_ref die
;
4668 register unsigned long size
= 0;
4669 register dw_attr_ref a
;
4671 size
+= size_of_uleb128 (die
->die_abbrev
);
4672 for (a
= die
->die_attr
; a
!= NULL
; a
= a
->dw_attr_next
)
4674 switch (AT_class (a
))
4676 case dw_val_class_addr
:
4679 case dw_val_class_loc
:
4681 register unsigned long lsize
= size_of_locs (AT_loc (a
));
4684 size
+= constant_size (lsize
);
4688 case dw_val_class_const
:
4691 case dw_val_class_unsigned_const
:
4692 size
+= constant_size (AT_unsigned (a
));
4694 case dw_val_class_long_long
:
4695 size
+= 1 + 8; /* block */
4697 case dw_val_class_float
:
4698 size
+= 1 + a
->dw_attr_val
.v
.val_float
.length
* 4; /* block */
4700 case dw_val_class_flag
:
4703 case dw_val_class_die_ref
:
4704 size
+= DWARF_OFFSET_SIZE
;
4706 case dw_val_class_fde_ref
:
4707 size
+= DWARF_OFFSET_SIZE
;
4709 case dw_val_class_lbl_id
:
4712 case dw_val_class_lbl_offset
:
4713 size
+= DWARF_OFFSET_SIZE
;
4715 case dw_val_class_str
:
4716 size
+= size_of_string (AT_string (a
));
4726 /* Size the debugging information associated with a given DIE.
4727 Visits the DIE's children recursively. Updates the global
4728 variable next_die_offset, on each time through. Uses the
4729 current value of next_die_offset to update the die_offset
4730 field in each DIE. */
4733 calc_die_sizes (die
)
4736 register dw_die_ref c
;
4737 die
->die_offset
= next_die_offset
;
4738 next_die_offset
+= size_of_die (die
);
4740 for (c
= die
->die_child
; c
!= NULL
; c
= c
->die_sib
)
4743 if (die
->die_child
!= NULL
)
4744 /* Count the null byte used to terminate sibling lists. */
4745 next_die_offset
+= 1;
4748 /* Return the size of the line information prolog generated for the
4749 compilation unit. */
4751 static unsigned long
4752 size_of_line_prolog ()
4754 register unsigned long size
;
4755 register unsigned long ft_index
;
4757 size
= DWARF_LINE_PROLOG_HEADER_SIZE
;
4759 /* Count the size of the table giving number of args for each
4761 size
+= DWARF_LINE_OPCODE_BASE
- 1;
4763 /* Include directory table is empty (at present). Count only the
4764 null byte used to terminate the table. */
4767 for (ft_index
= 1; ft_index
< file_table_in_use
; ++ft_index
)
4769 /* File name entry. */
4770 size
+= size_of_string (file_table
[ft_index
]);
4772 /* Include directory index. */
4773 size
+= size_of_uleb128 (0);
4775 /* Modification time. */
4776 size
+= size_of_uleb128 (0);
4778 /* File length in bytes. */
4779 size
+= size_of_uleb128 (0);
4782 /* Count the file table terminator. */
4787 /* Return the size of the .debug_pubnames table generated for the
4788 compilation unit. */
4790 static unsigned long
4793 register unsigned long size
;
4794 register unsigned i
;
4796 size
= DWARF_PUBNAMES_HEADER_SIZE
;
4797 for (i
= 0; i
< pubname_table_in_use
; ++i
)
4799 register pubname_ref p
= &pubname_table
[i
];
4800 size
+= DWARF_OFFSET_SIZE
+ size_of_string (p
->name
);
4803 size
+= DWARF_OFFSET_SIZE
;
4807 /* Return the size of the information in the .debug_aranges section. */
4809 static unsigned long
4812 register unsigned long size
;
4814 size
= DWARF_ARANGES_HEADER_SIZE
;
4816 /* Count the address/length pair for this compilation unit. */
4817 size
+= 2 * PTR_SIZE
;
4818 size
+= 2 * PTR_SIZE
* arange_table_in_use
;
4820 /* Count the two zero words used to terminated the address range table. */
4821 size
+= 2 * PTR_SIZE
;
4825 /* Select the encoding of an attribute value. */
4827 static enum dwarf_form
4831 switch (a
->dw_attr_val
.val_class
)
4833 case dw_val_class_addr
:
4834 return DW_FORM_addr
;
4835 case dw_val_class_loc
:
4836 switch (constant_size (size_of_locs (AT_loc (a
))))
4839 return DW_FORM_block1
;
4841 return DW_FORM_block2
;
4845 case dw_val_class_const
:
4846 return DW_FORM_data4
;
4847 case dw_val_class_unsigned_const
:
4848 switch (constant_size (AT_unsigned (a
)))
4851 return DW_FORM_data1
;
4853 return DW_FORM_data2
;
4855 return DW_FORM_data4
;
4857 return DW_FORM_data8
;
4861 case dw_val_class_long_long
:
4862 return DW_FORM_block1
;
4863 case dw_val_class_float
:
4864 return DW_FORM_block1
;
4865 case dw_val_class_flag
:
4866 return DW_FORM_flag
;
4867 case dw_val_class_die_ref
:
4869 case dw_val_class_fde_ref
:
4870 return DW_FORM_data
;
4871 case dw_val_class_lbl_id
:
4872 return DW_FORM_addr
;
4873 case dw_val_class_lbl_offset
:
4874 return DW_FORM_data
;
4875 case dw_val_class_str
:
4876 return DW_FORM_string
;
4882 /* Output the encoding of an attribute value. */
4885 output_value_format (a
)
4888 enum dwarf_form form
= value_format (a
);
4890 output_uleb128 (form
);
4892 fprintf (asm_out_file
, " (%s)", dwarf_form_name (form
));
4894 fputc ('\n', asm_out_file
);
4897 /* Output the .debug_abbrev section which defines the DIE abbreviation
4901 output_abbrev_section ()
4903 unsigned long abbrev_id
;
4906 for (abbrev_id
= 1; abbrev_id
< abbrev_die_table_in_use
; ++abbrev_id
)
4908 register dw_die_ref abbrev
= abbrev_die_table
[abbrev_id
];
4910 output_uleb128 (abbrev_id
);
4912 fprintf (asm_out_file
, " (abbrev code)");
4914 fputc ('\n', asm_out_file
);
4915 output_uleb128 (abbrev
->die_tag
);
4917 fprintf (asm_out_file
, " (TAG: %s)",
4918 dwarf_tag_name (abbrev
->die_tag
));
4920 fputc ('\n', asm_out_file
);
4921 fprintf (asm_out_file
, "\t%s\t0x%x", ASM_BYTE_OP
,
4922 abbrev
->die_child
!= NULL
? DW_children_yes
: DW_children_no
);
4925 fprintf (asm_out_file
, "\t%s %s",
4927 (abbrev
->die_child
!= NULL
4928 ? "DW_children_yes" : "DW_children_no"));
4930 fputc ('\n', asm_out_file
);
4932 for (a_attr
= abbrev
->die_attr
; a_attr
!= NULL
;
4933 a_attr
= a_attr
->dw_attr_next
)
4935 output_uleb128 (a_attr
->dw_attr
);
4937 fprintf (asm_out_file
, " (%s)",
4938 dwarf_attr_name (a_attr
->dw_attr
));
4940 fputc ('\n', asm_out_file
);
4941 output_value_format (a_attr
);
4944 fprintf (asm_out_file
, "\t%s\t0,0\n", ASM_BYTE_OP
);
4947 /* Terminate the table. */
4948 fprintf (asm_out_file
, "\t%s\t0\n", ASM_BYTE_OP
);
4951 /* Output location description stack opcode's operands (if any). */
4954 output_loc_operands (loc
)
4955 register dw_loc_descr_ref loc
;
4957 register dw_val_ref val1
= &loc
->dw_loc_oprnd1
;
4958 register dw_val_ref val2
= &loc
->dw_loc_oprnd2
;
4960 switch (loc
->dw_loc_opc
)
4963 ASM_OUTPUT_DWARF_ADDR_CONST (asm_out_file
, val1
->v
.val_addr
);
4964 fputc ('\n', asm_out_file
);
4968 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, val1
->v
.val_flag
);
4969 fputc ('\n', asm_out_file
);
4973 ASM_OUTPUT_DWARF_DATA2 (asm_out_file
, val1
->v
.val_int
);
4974 fputc ('\n', asm_out_file
);
4978 ASM_OUTPUT_DWARF_DATA4 (asm_out_file
, val1
->v
.val_int
);
4979 fputc ('\n', asm_out_file
);
4984 fputc ('\n', asm_out_file
);
4987 output_uleb128 (val1
->v
.val_unsigned
);
4988 fputc ('\n', asm_out_file
);
4991 output_sleb128 (val1
->v
.val_int
);
4992 fputc ('\n', asm_out_file
);
4995 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, val1
->v
.val_int
);
4996 fputc ('\n', asm_out_file
);
4998 case DW_OP_plus_uconst
:
4999 output_uleb128 (val1
->v
.val_unsigned
);
5000 fputc ('\n', asm_out_file
);
5004 ASM_OUTPUT_DWARF_DATA2 (asm_out_file
, val1
->v
.val_int
);
5005 fputc ('\n', asm_out_file
);
5039 output_sleb128 (val1
->v
.val_int
);
5040 fputc ('\n', asm_out_file
);
5043 output_uleb128 (val1
->v
.val_unsigned
);
5044 fputc ('\n', asm_out_file
);
5047 output_sleb128 (val1
->v
.val_int
);
5048 fputc ('\n', asm_out_file
);
5051 output_uleb128 (val1
->v
.val_unsigned
);
5052 fputc ('\n', asm_out_file
);
5053 output_sleb128 (val2
->v
.val_int
);
5054 fputc ('\n', asm_out_file
);
5057 output_uleb128 (val1
->v
.val_unsigned
);
5058 fputc ('\n', asm_out_file
);
5060 case DW_OP_deref_size
:
5061 case DW_OP_xderef_size
:
5062 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, val1
->v
.val_flag
);
5063 fputc ('\n', asm_out_file
);
5070 /* Output the DIE and its attributes. Called recursively to generate
5071 the definitions of each child DIE. */
5075 register dw_die_ref die
;
5077 register dw_attr_ref a
;
5078 register dw_die_ref c
;
5079 register unsigned long size
;
5080 register dw_loc_descr_ref loc
;
5082 output_uleb128 (die
->die_abbrev
);
5084 fprintf (asm_out_file
, " (DIE (0x%lx) %s)",
5085 die
->die_offset
, dwarf_tag_name (die
->die_tag
));
5087 fputc ('\n', asm_out_file
);
5089 for (a
= die
->die_attr
; a
!= NULL
; a
= a
->dw_attr_next
)
5091 switch (AT_class (a
))
5093 case dw_val_class_addr
:
5094 ASM_OUTPUT_DWARF_ADDR_CONST (asm_out_file
, AT_addr (a
));
5097 case dw_val_class_loc
:
5098 size
= size_of_locs (AT_loc (a
));
5100 /* Output the block length for this list of location operations. */
5101 switch (constant_size (size
))
5104 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, size
);
5107 ASM_OUTPUT_DWARF_DATA2 (asm_out_file
, size
);
5114 fprintf (asm_out_file
, "\t%s %s",
5115 ASM_COMMENT_START
, dwarf_attr_name (a
->dw_attr
));
5117 fputc ('\n', asm_out_file
);
5118 for (loc
= AT_loc (a
); loc
!= NULL
; loc
= loc
->dw_loc_next
)
5120 /* Output the opcode. */
5121 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, loc
->dw_loc_opc
);
5123 fprintf (asm_out_file
, "\t%s %s", ASM_COMMENT_START
,
5124 dwarf_stack_op_name (loc
->dw_loc_opc
));
5126 fputc ('\n', asm_out_file
);
5128 /* Output the operand(s) (if any). */
5129 output_loc_operands (loc
);
5133 case dw_val_class_const
:
5134 ASM_OUTPUT_DWARF_DATA4 (asm_out_file
, AT_int (a
));
5137 case dw_val_class_unsigned_const
:
5138 switch (constant_size (AT_unsigned (a
)))
5141 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, AT_unsigned (a
));
5144 ASM_OUTPUT_DWARF_DATA2 (asm_out_file
, AT_unsigned (a
));
5147 ASM_OUTPUT_DWARF_DATA4 (asm_out_file
, AT_unsigned (a
));
5150 ASM_OUTPUT_DWARF_DATA8 (asm_out_file
,
5151 a
->dw_attr_val
.v
.val_long_long
.hi
,
5152 a
->dw_attr_val
.v
.val_long_long
.low
);
5159 case dw_val_class_long_long
:
5160 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, 8);
5162 fprintf (asm_out_file
, "\t%s %s",
5163 ASM_COMMENT_START
, dwarf_attr_name (a
->dw_attr
));
5165 fputc ('\n', asm_out_file
);
5166 ASM_OUTPUT_DWARF_DATA8 (asm_out_file
,
5167 a
->dw_attr_val
.v
.val_long_long
.hi
,
5168 a
->dw_attr_val
.v
.val_long_long
.low
);
5171 fprintf (asm_out_file
,
5172 "\t%s long long constant", ASM_COMMENT_START
);
5174 fputc ('\n', asm_out_file
);
5177 case dw_val_class_float
:
5179 register unsigned int i
;
5180 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
,
5181 a
->dw_attr_val
.v
.val_float
.length
* 4);
5183 fprintf (asm_out_file
, "\t%s %s",
5184 ASM_COMMENT_START
, dwarf_attr_name (a
->dw_attr
));
5186 fputc ('\n', asm_out_file
);
5187 for (i
= 0; i
< a
->dw_attr_val
.v
.val_float
.length
; ++i
)
5189 ASM_OUTPUT_DWARF_DATA4 (asm_out_file
,
5190 a
->dw_attr_val
.v
.val_float
.array
[i
]);
5192 fprintf (asm_out_file
, "\t%s fp constant word %u",
5193 ASM_COMMENT_START
, i
);
5195 fputc ('\n', asm_out_file
);
5200 case dw_val_class_flag
:
5201 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, AT_flag (a
));
5204 case dw_val_class_die_ref
:
5205 ASM_OUTPUT_DWARF_DATA (asm_out_file
, AT_ref (a
)->die_offset
);
5208 case dw_val_class_fde_ref
:
5211 ASM_GENERATE_INTERNAL_LABEL
5212 (l1
, FDE_AFTER_SIZE_LABEL
, a
->dw_attr_val
.v
.val_fde_index
* 2);
5213 ASM_OUTPUT_DWARF_OFFSET (asm_out_file
, l1
);
5214 fprintf (asm_out_file
, " - %d", DWARF_OFFSET_SIZE
);
5218 case dw_val_class_lbl_id
:
5219 ASM_OUTPUT_DWARF_ADDR (asm_out_file
, AT_lbl (a
));
5222 case dw_val_class_lbl_offset
:
5223 ASM_OUTPUT_DWARF_OFFSET (asm_out_file
, AT_lbl (a
));
5226 case dw_val_class_str
:
5228 ASM_OUTPUT_DWARF_STRING (asm_out_file
, AT_string (a
));
5230 ASM_OUTPUT_ASCII (asm_out_file
, AT_string (a
),
5231 (int) strlen (AT_string (a
)) + 1);
5238 if (AT_class (a
) != dw_val_class_loc
5239 && AT_class (a
) != dw_val_class_long_long
5240 && AT_class (a
) != dw_val_class_float
)
5243 fprintf (asm_out_file
, "\t%s %s",
5244 ASM_COMMENT_START
, dwarf_attr_name (a
->dw_attr
));
5246 fputc ('\n', asm_out_file
);
5250 for (c
= die
->die_child
; c
!= NULL
; c
= c
->die_sib
)
5253 if (die
->die_child
!= NULL
)
5255 /* Add null byte to terminate sibling list. */
5256 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, 0);
5258 fprintf (asm_out_file
, "\t%s end of children of DIE 0x%lx",
5259 ASM_COMMENT_START
, die
->die_offset
);
5261 fputc ('\n', asm_out_file
);
5265 /* Output the compilation unit that appears at the beginning of the
5266 .debug_info section, and precedes the DIE descriptions. */
5269 output_compilation_unit_header ()
5271 ASM_OUTPUT_DWARF_DATA (asm_out_file
, next_die_offset
- DWARF_OFFSET_SIZE
);
5273 fprintf (asm_out_file
, "\t%s Length of Compilation Unit Info.",
5276 fputc ('\n', asm_out_file
);
5277 ASM_OUTPUT_DWARF_DATA2 (asm_out_file
, DWARF_VERSION
);
5279 fprintf (asm_out_file
, "\t%s DWARF version number", ASM_COMMENT_START
);
5281 fputc ('\n', asm_out_file
);
5282 ASM_OUTPUT_DWARF_OFFSET (asm_out_file
, abbrev_section_label
);
5284 fprintf (asm_out_file
, "\t%s Offset Into Abbrev. Section",
5287 fputc ('\n', asm_out_file
);
5288 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, PTR_SIZE
);
5290 fprintf (asm_out_file
, "\t%s Pointer Size (in bytes)", ASM_COMMENT_START
);
5292 fputc ('\n', asm_out_file
);
5295 /* The DWARF2 pubname for a nested thingy looks like "A::f". The output
5296 of decl_printable_name for C++ looks like "A::f(int)". Let's drop the
5297 argument list, and maybe the scope. */
5300 dwarf2_name (decl
, scope
)
5304 return (*decl_printable_name
) (decl
, scope
? 1 : 0);
5307 /* Add a new entry to .debug_pubnames if appropriate. */
5310 add_pubname (decl
, die
)
5316 if (! TREE_PUBLIC (decl
))
5319 if (pubname_table_in_use
== pubname_table_allocated
)
5321 pubname_table_allocated
+= PUBNAME_TABLE_INCREMENT
;
5322 pubname_table
= (pubname_ref
) xrealloc
5323 (pubname_table
, pubname_table_allocated
* sizeof (pubname_entry
));
5326 p
= &pubname_table
[pubname_table_in_use
++];
5329 p
->name
= xstrdup (dwarf2_name (decl
, 1));
5332 /* Output the public names table used to speed up access to externally
5333 visible names. For now, only generate entries for externally
5334 visible procedures. */
5339 register unsigned i
;
5340 register unsigned long pubnames_length
= size_of_pubnames ();
5342 ASM_OUTPUT_DWARF_DATA (asm_out_file
, pubnames_length
);
5345 fprintf (asm_out_file
, "\t%s Length of Public Names Info.",
5348 fputc ('\n', asm_out_file
);
5349 ASM_OUTPUT_DWARF_DATA2 (asm_out_file
, DWARF_VERSION
);
5352 fprintf (asm_out_file
, "\t%s DWARF Version", ASM_COMMENT_START
);
5354 fputc ('\n', asm_out_file
);
5355 ASM_OUTPUT_DWARF_OFFSET (asm_out_file
, debug_info_section_label
);
5357 fprintf (asm_out_file
, "\t%s Offset of Compilation Unit Info.",
5360 fputc ('\n', asm_out_file
);
5361 ASM_OUTPUT_DWARF_DATA (asm_out_file
, next_die_offset
);
5363 fprintf (asm_out_file
, "\t%s Compilation Unit Length", ASM_COMMENT_START
);
5365 fputc ('\n', asm_out_file
);
5366 for (i
= 0; i
< pubname_table_in_use
; ++i
)
5368 register pubname_ref pub
= &pubname_table
[i
];
5370 ASM_OUTPUT_DWARF_DATA (asm_out_file
, pub
->die
->die_offset
);
5372 fprintf (asm_out_file
, "\t%s DIE offset", ASM_COMMENT_START
);
5374 fputc ('\n', asm_out_file
);
5378 ASM_OUTPUT_DWARF_STRING (asm_out_file
, pub
->name
);
5379 fprintf (asm_out_file
, "%s external name", ASM_COMMENT_START
);
5383 ASM_OUTPUT_ASCII (asm_out_file
, pub
->name
,
5384 (int) strlen (pub
->name
) + 1);
5387 fputc ('\n', asm_out_file
);
5390 ASM_OUTPUT_DWARF_DATA (asm_out_file
, 0);
5391 fputc ('\n', asm_out_file
);
5394 /* Add a new entry to .debug_aranges if appropriate. */
5397 add_arange (decl
, die
)
5401 if (! DECL_SECTION_NAME (decl
))
5404 if (arange_table_in_use
== arange_table_allocated
)
5406 arange_table_allocated
+= ARANGE_TABLE_INCREMENT
;
5408 = (arange_ref
) xrealloc (arange_table
,
5409 arange_table_allocated
* sizeof (dw_die_ref
));
5412 arange_table
[arange_table_in_use
++] = die
;
5415 /* Output the information that goes into the .debug_aranges table.
5416 Namely, define the beginning and ending address range of the
5417 text section generated for this compilation unit. */
5422 register unsigned i
;
5423 register unsigned long aranges_length
= size_of_aranges ();
5425 ASM_OUTPUT_DWARF_DATA (asm_out_file
, aranges_length
);
5427 fprintf (asm_out_file
, "\t%s Length of Address Ranges Info.",
5430 fputc ('\n', asm_out_file
);
5431 ASM_OUTPUT_DWARF_DATA2 (asm_out_file
, DWARF_VERSION
);
5433 fprintf (asm_out_file
, "\t%s DWARF Version", ASM_COMMENT_START
);
5435 fputc ('\n', asm_out_file
);
5436 ASM_OUTPUT_DWARF_OFFSET (asm_out_file
, debug_info_section_label
);
5438 fprintf (asm_out_file
, "\t%s Offset of Compilation Unit Info.",
5441 fputc ('\n', asm_out_file
);
5442 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, PTR_SIZE
);
5444 fprintf (asm_out_file
, "\t%s Size of Address", ASM_COMMENT_START
);
5446 fputc ('\n', asm_out_file
);
5447 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, 0);
5449 fprintf (asm_out_file
, "\t%s Size of Segment Descriptor",
5452 fputc ('\n', asm_out_file
);
5453 /* We need to align to twice the pointer size here.
5454 If DWARF_OFFSET_SIZE == 4, then we have emitted 12 bytes, and need 4
5455 bytes of padding to align for either 4 or 8 byte pointers. */
5456 ASM_OUTPUT_DWARF_DATA4 (asm_out_file
, 0);
5457 /* If DWARF_OFFSET_SIZE == 8, then we have emitted 20 bytes, and need 12
5458 bytes of padding to align for 8 byte pointers. We have already emitted
5459 4 bytes of padding, so emit 8 more here. */
5460 if (DWARF_OFFSET_SIZE
== 8)
5461 fprintf (asm_out_file
, ",0,0");
5464 fprintf (asm_out_file
, "\t%s Pad to %d byte boundary",
5465 ASM_COMMENT_START
, 2 * PTR_SIZE
);
5467 fputc ('\n', asm_out_file
);
5468 ASM_OUTPUT_DWARF_ADDR (asm_out_file
, text_section_label
);
5470 fprintf (asm_out_file
, "\t%s Address", ASM_COMMENT_START
);
5472 fputc ('\n', asm_out_file
);
5473 ASM_OUTPUT_DWARF_ADDR_DELTA (asm_out_file
, text_end_label
,
5474 text_section_label
);
5476 fprintf (asm_out_file
, "%s Length", ASM_COMMENT_START
);
5478 fputc ('\n', asm_out_file
);
5479 for (i
= 0; i
< arange_table_in_use
; ++i
)
5481 dw_die_ref die
= arange_table
[i
];
5483 if (die
->die_tag
== DW_TAG_subprogram
)
5484 ASM_OUTPUT_DWARF_ADDR (asm_out_file
, get_AT_low_pc (die
));
5487 /* A static variable; extract the symbol from DW_AT_location.
5488 Note that this code isn't currently hit, as we only emit
5489 aranges for functions (jason 9/23/99). */
5491 dw_attr_ref a
= get_AT (die
, DW_AT_location
);
5492 dw_loc_descr_ref loc
;
5493 if (! a
|| AT_class (a
) != dw_val_class_loc
)
5497 if (loc
->dw_loc_opc
!= DW_OP_addr
)
5500 ASM_OUTPUT_DWARF_ADDR (asm_out_file
, loc
->dw_loc_oprnd1
.v
.val_addr
);
5504 fprintf (asm_out_file
, "\t%s Address", ASM_COMMENT_START
);
5506 fputc ('\n', asm_out_file
);
5507 if (die
->die_tag
== DW_TAG_subprogram
)
5508 ASM_OUTPUT_DWARF_ADDR_DELTA (asm_out_file
, get_AT_hi_pc (die
),
5509 get_AT_low_pc (die
));
5511 ASM_OUTPUT_DWARF_ADDR_DATA (asm_out_file
,
5512 get_AT_unsigned (die
, DW_AT_byte_size
));
5515 fprintf (asm_out_file
, "%s Length", ASM_COMMENT_START
);
5517 fputc ('\n', asm_out_file
);
5520 /* Output the terminator words. */
5521 ASM_OUTPUT_DWARF_ADDR_DATA (asm_out_file
, 0);
5522 fputc ('\n', asm_out_file
);
5523 ASM_OUTPUT_DWARF_ADDR_DATA (asm_out_file
, 0);
5524 fputc ('\n', asm_out_file
);
5527 /* Output the source line number correspondence information. This
5528 information goes into the .debug_line section. */
5533 char line_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
5534 char prev_line_label
[MAX_ARTIFICIAL_LABEL_BYTES
];
5535 register unsigned opc
;
5536 register unsigned n_op_args
;
5537 register unsigned long ft_index
;
5538 register unsigned long lt_index
;
5539 register unsigned long current_line
;
5540 register long line_offset
;
5541 register long line_delta
;
5542 register unsigned long current_file
;
5543 register unsigned long function
;
5545 ASM_OUTPUT_DWARF_DELTA (asm_out_file
, ".LTEND", ".LTSTART");
5547 fprintf (asm_out_file
, "\t%s Length of Source Line Info.",
5550 fputc ('\n', asm_out_file
);
5551 ASM_OUTPUT_LABEL (asm_out_file
, ".LTSTART");
5552 ASM_OUTPUT_DWARF_DATA2 (asm_out_file
, DWARF_VERSION
);
5554 fprintf (asm_out_file
, "\t%s DWARF Version", ASM_COMMENT_START
);
5556 fputc ('\n', asm_out_file
);
5557 ASM_OUTPUT_DWARF_DATA (asm_out_file
, size_of_line_prolog ());
5559 fprintf (asm_out_file
, "\t%s Prolog Length", ASM_COMMENT_START
);
5561 fputc ('\n', asm_out_file
);
5562 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, DWARF_LINE_MIN_INSTR_LENGTH
);
5564 fprintf (asm_out_file
, "\t%s Minimum Instruction Length",
5567 fputc ('\n', asm_out_file
);
5568 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, DWARF_LINE_DEFAULT_IS_STMT_START
);
5570 fprintf (asm_out_file
, "\t%s Default is_stmt_start flag",
5573 fputc ('\n', asm_out_file
);
5574 fprintf (asm_out_file
, "\t%s\t%d", ASM_BYTE_OP
, DWARF_LINE_BASE
);
5576 fprintf (asm_out_file
, "\t%s Line Base Value (Special Opcodes)",
5579 fputc ('\n', asm_out_file
);
5580 fprintf (asm_out_file
, "\t%s\t%u", ASM_BYTE_OP
, DWARF_LINE_RANGE
);
5582 fprintf (asm_out_file
, "\t%s Line Range Value (Special Opcodes)",
5585 fputc ('\n', asm_out_file
);
5586 fprintf (asm_out_file
, "\t%s\t%u", ASM_BYTE_OP
, DWARF_LINE_OPCODE_BASE
);
5588 fprintf (asm_out_file
, "\t%s Special Opcode Base", ASM_COMMENT_START
);
5590 fputc ('\n', asm_out_file
);
5591 for (opc
= 1; opc
< DWARF_LINE_OPCODE_BASE
; ++opc
)
5595 case DW_LNS_advance_pc
:
5596 case DW_LNS_advance_line
:
5597 case DW_LNS_set_file
:
5598 case DW_LNS_set_column
:
5599 case DW_LNS_fixed_advance_pc
:
5606 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, n_op_args
);
5608 fprintf (asm_out_file
, "\t%s opcode: 0x%x has %d args",
5609 ASM_COMMENT_START
, opc
, n_op_args
);
5610 fputc ('\n', asm_out_file
);
5614 fprintf (asm_out_file
, "%s Include Directory Table\n", ASM_COMMENT_START
);
5616 /* Include directory table is empty, at present */
5617 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, 0);
5618 fputc ('\n', asm_out_file
);
5620 fprintf (asm_out_file
, "%s File Name Table\n", ASM_COMMENT_START
);
5622 for (ft_index
= 1; ft_index
< file_table_in_use
; ++ft_index
)
5626 ASM_OUTPUT_DWARF_STRING (asm_out_file
, file_table
[ft_index
]);
5627 fprintf (asm_out_file
, "%s File Entry: 0x%lx",
5628 ASM_COMMENT_START
, ft_index
);
5632 ASM_OUTPUT_ASCII (asm_out_file
,
5633 file_table
[ft_index
],
5634 (int) strlen (file_table
[ft_index
]) + 1);
5637 fputc ('\n', asm_out_file
);
5639 /* Include directory index */
5641 fputc ('\n', asm_out_file
);
5643 /* Modification time */
5645 fputc ('\n', asm_out_file
);
5647 /* File length in bytes */
5649 fputc ('\n', asm_out_file
);
5652 /* Terminate the file name table */
5653 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, 0);
5654 fputc ('\n', asm_out_file
);
5656 /* We used to set the address register to the first location in the text
5657 section here, but that didn't accomplish anything since we already
5658 have a line note for the opening brace of the first function. */
5660 /* Generate the line number to PC correspondence table, encoded as
5661 a series of state machine operations. */
5664 strcpy (prev_line_label
, text_section_label
);
5665 for (lt_index
= 1; lt_index
< line_info_table_in_use
; ++lt_index
)
5667 register dw_line_info_ref line_info
= &line_info_table
[lt_index
];
5669 /* Don't emit anything for redundant notes. Just updating the
5670 address doesn't accomplish anything, because we already assume
5671 that anything after the last address is this line. */
5672 if (line_info
->dw_line_num
== current_line
5673 && line_info
->dw_file_num
== current_file
)
5676 /* Emit debug info for the address of the current line, choosing
5677 the encoding that uses the least amount of space. */
5678 /* ??? Unfortunately, we have little choice here currently, and must
5679 always use the most general form. Gcc does not know the address
5680 delta itself, so we can't use DW_LNS_advance_pc. There are no known
5681 dwarf2 aware assemblers at this time, so we can't use any special
5682 pseudo ops that would allow the assembler to optimally encode this for
5683 us. Many ports do have length attributes which will give an upper
5684 bound on the address range. We could perhaps use length attributes
5685 to determine when it is safe to use DW_LNS_fixed_advance_pc. */
5686 ASM_GENERATE_INTERNAL_LABEL (line_label
, LINE_CODE_LABEL
, lt_index
);
5689 /* This can handle deltas up to 0xffff. This takes 3 bytes. */
5690 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, DW_LNS_fixed_advance_pc
);
5692 fprintf (asm_out_file
, "\t%s DW_LNS_fixed_advance_pc",
5695 fputc ('\n', asm_out_file
);
5696 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file
, line_label
, prev_line_label
);
5697 fputc ('\n', asm_out_file
);
5701 /* This can handle any delta. This takes 4+PTR_SIZE bytes. */
5702 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, 0);
5704 fprintf (asm_out_file
, "\t%s DW_LNE_set_address",
5706 fputc ('\n', asm_out_file
);
5707 output_uleb128 (1 + PTR_SIZE
);
5708 fputc ('\n', asm_out_file
);
5709 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, DW_LNE_set_address
);
5710 fputc ('\n', asm_out_file
);
5711 ASM_OUTPUT_DWARF_ADDR (asm_out_file
, line_label
);
5712 fputc ('\n', asm_out_file
);
5714 strcpy (prev_line_label
, line_label
);
5716 /* Emit debug info for the source file of the current line, if
5717 different from the previous line. */
5718 if (line_info
->dw_file_num
!= current_file
)
5720 current_file
= line_info
->dw_file_num
;
5721 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, DW_LNS_set_file
);
5723 fprintf (asm_out_file
, "\t%s DW_LNS_set_file", ASM_COMMENT_START
);
5725 fputc ('\n', asm_out_file
);
5726 output_uleb128 (current_file
);
5728 fprintf (asm_out_file
, " (\"%s\")", file_table
[current_file
]);
5730 fputc ('\n', asm_out_file
);
5733 /* Emit debug info for the current line number, choosing the encoding
5734 that uses the least amount of space. */
5735 if (line_info
->dw_line_num
!= current_line
)
5737 line_offset
= line_info
->dw_line_num
- current_line
;
5738 line_delta
= line_offset
- DWARF_LINE_BASE
;
5739 current_line
= line_info
->dw_line_num
;
5740 if (line_delta
>= 0 && line_delta
< (DWARF_LINE_RANGE
- 1))
5742 /* This can handle deltas from -10 to 234, using the current
5743 definitions of DWARF_LINE_BASE and DWARF_LINE_RANGE. This
5745 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
,
5746 DWARF_LINE_OPCODE_BASE
+ line_delta
);
5748 fprintf (asm_out_file
,
5749 "\t%s line %ld", ASM_COMMENT_START
, current_line
);
5751 fputc ('\n', asm_out_file
);
5755 /* This can handle any delta. This takes at least 4 bytes,
5756 depending on the value being encoded. */
5757 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, DW_LNS_advance_line
);
5759 fprintf (asm_out_file
, "\t%s advance to line %ld",
5760 ASM_COMMENT_START
, current_line
);
5762 fputc ('\n', asm_out_file
);
5763 output_sleb128 (line_offset
);
5764 fputc ('\n', asm_out_file
);
5765 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, DW_LNS_copy
);
5767 fprintf (asm_out_file
, "\t%s DW_LNS_copy", ASM_COMMENT_START
);
5768 fputc ('\n', asm_out_file
);
5773 /* We still need to start a new row, so output a copy insn. */
5774 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, DW_LNS_copy
);
5776 fprintf (asm_out_file
, "\t%s DW_LNS_copy", ASM_COMMENT_START
);
5777 fputc ('\n', asm_out_file
);
5781 /* Emit debug info for the address of the end of the function. */
5784 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, DW_LNS_fixed_advance_pc
);
5786 fprintf (asm_out_file
, "\t%s DW_LNS_fixed_advance_pc",
5789 fputc ('\n', asm_out_file
);
5790 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file
, text_end_label
, prev_line_label
);
5791 fputc ('\n', asm_out_file
);
5795 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, 0);
5797 fprintf (asm_out_file
, "\t%s DW_LNE_set_address", ASM_COMMENT_START
);
5798 fputc ('\n', asm_out_file
);
5799 output_uleb128 (1 + PTR_SIZE
);
5800 fputc ('\n', asm_out_file
);
5801 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, DW_LNE_set_address
);
5802 fputc ('\n', asm_out_file
);
5803 ASM_OUTPUT_DWARF_ADDR (asm_out_file
, text_end_label
);
5804 fputc ('\n', asm_out_file
);
5807 /* Output the marker for the end of the line number info. */
5808 ASM_OUTPUT_LABEL (asm_out_file
, ".LTEND");
5809 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, 0);
5811 fprintf (asm_out_file
, "\t%s DW_LNE_end_sequence", ASM_COMMENT_START
);
5813 fputc ('\n', asm_out_file
);
5815 fputc ('\n', asm_out_file
);
5816 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, DW_LNE_end_sequence
);
5817 fputc ('\n', asm_out_file
);
5822 for (lt_index
= 0; lt_index
< separate_line_info_table_in_use
; )
5824 register dw_separate_line_info_ref line_info
5825 = &separate_line_info_table
[lt_index
];
5827 /* Don't emit anything for redundant notes. */
5828 if (line_info
->dw_line_num
== current_line
5829 && line_info
->dw_file_num
== current_file
5830 && line_info
->function
== function
)
5833 /* Emit debug info for the address of the current line. If this is
5834 a new function, or the first line of a function, then we need
5835 to handle it differently. */
5836 ASM_GENERATE_INTERNAL_LABEL (line_label
, SEPARATE_LINE_CODE_LABEL
,
5838 if (function
!= line_info
->function
)
5840 function
= line_info
->function
;
5842 /* Set the address register to the first line in the function */
5843 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, 0);
5845 fprintf (asm_out_file
, "\t%s DW_LNE_set_address",
5848 fputc ('\n', asm_out_file
);
5849 output_uleb128 (1 + PTR_SIZE
);
5850 fputc ('\n', asm_out_file
);
5851 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, DW_LNE_set_address
);
5852 fputc ('\n', asm_out_file
);
5853 ASM_OUTPUT_DWARF_ADDR (asm_out_file
, line_label
);
5854 fputc ('\n', asm_out_file
);
5858 /* ??? See the DW_LNS_advance_pc comment above. */
5861 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, DW_LNS_fixed_advance_pc
);
5863 fprintf (asm_out_file
, "\t%s DW_LNS_fixed_advance_pc",
5866 fputc ('\n', asm_out_file
);
5867 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file
, line_label
,
5869 fputc ('\n', asm_out_file
);
5873 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, 0);
5875 fprintf (asm_out_file
, "\t%s DW_LNE_set_address",
5877 fputc ('\n', asm_out_file
);
5878 output_uleb128 (1 + PTR_SIZE
);
5879 fputc ('\n', asm_out_file
);
5880 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, DW_LNE_set_address
);
5881 fputc ('\n', asm_out_file
);
5882 ASM_OUTPUT_DWARF_ADDR (asm_out_file
, line_label
);
5883 fputc ('\n', asm_out_file
);
5886 strcpy (prev_line_label
, line_label
);
5888 /* Emit debug info for the source file of the current line, if
5889 different from the previous line. */
5890 if (line_info
->dw_file_num
!= current_file
)
5892 current_file
= line_info
->dw_file_num
;
5893 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, DW_LNS_set_file
);
5895 fprintf (asm_out_file
, "\t%s DW_LNS_set_file", ASM_COMMENT_START
);
5897 fputc ('\n', asm_out_file
);
5898 output_uleb128 (current_file
);
5900 fprintf (asm_out_file
, " (\"%s\")", file_table
[current_file
]);
5902 fputc ('\n', asm_out_file
);
5905 /* Emit debug info for the current line number, choosing the encoding
5906 that uses the least amount of space. */
5907 if (line_info
->dw_line_num
!= current_line
)
5909 line_offset
= line_info
->dw_line_num
- current_line
;
5910 line_delta
= line_offset
- DWARF_LINE_BASE
;
5911 current_line
= line_info
->dw_line_num
;
5912 if (line_delta
>= 0 && line_delta
< (DWARF_LINE_RANGE
- 1))
5914 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
,
5915 DWARF_LINE_OPCODE_BASE
+ line_delta
);
5917 fprintf (asm_out_file
,
5918 "\t%s line %ld", ASM_COMMENT_START
, current_line
);
5920 fputc ('\n', asm_out_file
);
5924 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, DW_LNS_advance_line
);
5926 fprintf (asm_out_file
, "\t%s advance to line %ld",
5927 ASM_COMMENT_START
, current_line
);
5929 fputc ('\n', asm_out_file
);
5930 output_sleb128 (line_offset
);
5931 fputc ('\n', asm_out_file
);
5932 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, DW_LNS_copy
);
5934 fprintf (asm_out_file
, "\t%s DW_LNS_copy", ASM_COMMENT_START
);
5935 fputc ('\n', asm_out_file
);
5940 /* We still need to start a new row, so output a copy insn. */
5941 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, DW_LNS_copy
);
5943 fprintf (asm_out_file
, "\t%s DW_LNS_copy", ASM_COMMENT_START
);
5944 fputc ('\n', asm_out_file
);
5950 /* If we're done with a function, end its sequence. */
5951 if (lt_index
== separate_line_info_table_in_use
5952 || separate_line_info_table
[lt_index
].function
!= function
)
5957 /* Emit debug info for the address of the end of the function. */
5958 ASM_GENERATE_INTERNAL_LABEL (line_label
, FUNC_END_LABEL
, function
);
5961 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, DW_LNS_fixed_advance_pc
);
5963 fprintf (asm_out_file
, "\t%s DW_LNS_fixed_advance_pc",
5966 fputc ('\n', asm_out_file
);
5967 ASM_OUTPUT_DWARF_DELTA2 (asm_out_file
, line_label
,
5969 fputc ('\n', asm_out_file
);
5973 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, 0);
5975 fprintf (asm_out_file
, "\t%s DW_LNE_set_address",
5977 fputc ('\n', asm_out_file
);
5978 output_uleb128 (1 + PTR_SIZE
);
5979 fputc ('\n', asm_out_file
);
5980 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, DW_LNE_set_address
);
5981 fputc ('\n', asm_out_file
);
5982 ASM_OUTPUT_DWARF_ADDR (asm_out_file
, line_label
);
5983 fputc ('\n', asm_out_file
);
5986 /* Output the marker for the end of this sequence. */
5987 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, 0);
5989 fprintf (asm_out_file
, "\t%s DW_LNE_end_sequence",
5992 fputc ('\n', asm_out_file
);
5994 fputc ('\n', asm_out_file
);
5995 ASM_OUTPUT_DWARF_DATA1 (asm_out_file
, DW_LNE_end_sequence
);
5996 fputc ('\n', asm_out_file
);
6001 /* Given a pointer to a BLOCK node return non-zero if (and only if) the node
6002 in question represents the outermost pair of curly braces (i.e. the "body
6003 block") of a function or method.
6005 For any BLOCK node representing a "body block" of a function or method, the
6006 BLOCK_SUPERCONTEXT of the node will point to another BLOCK node which
6007 represents the outermost (function) scope for the function or method (i.e.
6008 the one which includes the formal parameters). The BLOCK_SUPERCONTEXT of
6009 *that* node in turn will point to the relevant FUNCTION_DECL node. */
6012 is_body_block (stmt
)
6015 if (TREE_CODE (stmt
) == BLOCK
)
6017 register tree parent
= BLOCK_SUPERCONTEXT (stmt
);
6019 if (TREE_CODE (parent
) == BLOCK
)
6021 register tree grandparent
= BLOCK_SUPERCONTEXT (parent
);
6023 if (TREE_CODE (grandparent
) == FUNCTION_DECL
)
6031 /* Given a pointer to a tree node for some base type, return a pointer to
6032 a DIE that describes the given type.
6034 This routine must only be called for GCC type nodes that correspond to
6035 Dwarf base (fundamental) types. */
6038 base_type_die (type
)
6041 register dw_die_ref base_type_result
;
6042 register const char *type_name
;
6043 register enum dwarf_type encoding
;
6044 register tree name
= TYPE_NAME (type
);
6046 if (TREE_CODE (type
) == ERROR_MARK
6047 || TREE_CODE (type
) == VOID_TYPE
)
6052 if (TREE_CODE (name
) == TYPE_DECL
)
6053 name
= DECL_NAME (name
);
6055 type_name
= IDENTIFIER_POINTER (name
);
6058 type_name
= "__unknown__";
6060 switch (TREE_CODE (type
))
6063 /* Carefully distinguish the C character types, without messing
6064 up if the language is not C. Note that we check only for the names
6065 that contain spaces; other names might occur by coincidence in other
6067 if (! (TYPE_PRECISION (type
) == CHAR_TYPE_SIZE
6068 && (type
== char_type_node
6069 || ! strcmp (type_name
, "signed char")
6070 || ! strcmp (type_name
, "unsigned char"))))
6072 if (TREE_UNSIGNED (type
))
6073 encoding
= DW_ATE_unsigned
;
6075 encoding
= DW_ATE_signed
;
6078 /* else fall through */
6081 /* GNU Pascal/Ada CHAR type. Not used in C. */
6082 if (TREE_UNSIGNED (type
))
6083 encoding
= DW_ATE_unsigned_char
;
6085 encoding
= DW_ATE_signed_char
;
6089 encoding
= DW_ATE_float
;
6092 /* Dwarf2 doesn't know anything about complex ints, so use
6093 a user defined type for it. */
6095 if (TREE_CODE (TREE_TYPE (type
)) == REAL_TYPE
)
6096 encoding
= DW_ATE_complex_float
;
6098 encoding
= DW_ATE_lo_user
;
6102 /* GNU FORTRAN/Ada/C++ BOOLEAN type. */
6103 encoding
= DW_ATE_boolean
;
6107 abort (); /* No other TREE_CODEs are Dwarf fundamental types. */
6110 base_type_result
= new_die (DW_TAG_base_type
, comp_unit_die
);
6111 if (demangle_name_func
)
6112 type_name
= (*demangle_name_func
) (type_name
);
6114 add_AT_string (base_type_result
, DW_AT_name
, type_name
);
6115 add_AT_unsigned (base_type_result
, DW_AT_byte_size
,
6116 int_size_in_bytes (type
));
6117 add_AT_unsigned (base_type_result
, DW_AT_encoding
, encoding
);
6119 return base_type_result
;
6122 /* Given a pointer to an arbitrary ..._TYPE tree node, return a pointer to
6123 the Dwarf "root" type for the given input type. The Dwarf "root" type of
6124 a given type is generally the same as the given type, except that if the
6125 given type is a pointer or reference type, then the root type of the given
6126 type is the root type of the "basis" type for the pointer or reference
6127 type. (This definition of the "root" type is recursive.) Also, the root
6128 type of a `const' qualified type or a `volatile' qualified type is the
6129 root type of the given type without the qualifiers. */
6135 if (TREE_CODE (type
) == ERROR_MARK
)
6136 return error_mark_node
;
6138 switch (TREE_CODE (type
))
6141 return error_mark_node
;
6144 case REFERENCE_TYPE
:
6145 return type_main_variant (root_type (TREE_TYPE (type
)));
6148 return type_main_variant (type
);
6152 /* Given a pointer to an arbitrary ..._TYPE tree node, return non-zero if the
6153 given input type is a Dwarf "fundamental" type. Otherwise return null. */
6159 switch (TREE_CODE (type
))
6174 case QUAL_UNION_TYPE
:
6179 case REFERENCE_TYPE
:
6192 /* Given a pointer to an arbitrary ..._TYPE tree node, return a debugging
6193 entry that chains various modifiers in front of the given type. */
6196 modified_type_die (type
, is_const_type
, is_volatile_type
, context_die
)
6198 register int is_const_type
;
6199 register int is_volatile_type
;
6200 register dw_die_ref context_die
;
6202 register enum tree_code code
= TREE_CODE (type
);
6203 register dw_die_ref mod_type_die
= NULL
;
6204 register dw_die_ref sub_die
= NULL
;
6205 register tree item_type
= NULL
;
6207 if (code
!= ERROR_MARK
)
6209 type
= build_type_variant (type
, is_const_type
, is_volatile_type
);
6211 mod_type_die
= lookup_type_die (type
);
6213 return mod_type_die
;
6215 /* Handle C typedef types. */
6216 if (TYPE_NAME (type
) && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
6217 && DECL_ORIGINAL_TYPE (TYPE_NAME (type
)))
6219 tree dtype
= TREE_TYPE (TYPE_NAME (type
));
6222 /* For a named type, use the typedef. */
6223 gen_type_die (type
, context_die
);
6224 mod_type_die
= lookup_type_die (type
);
6227 else if (is_const_type
< TYPE_READONLY (dtype
)
6228 || is_volatile_type
< TYPE_VOLATILE (dtype
))
6229 /* cv-unqualified version of named type. Just use the unnamed
6230 type to which it refers. */
6232 = modified_type_die (DECL_ORIGINAL_TYPE (TYPE_NAME (type
)),
6233 is_const_type
, is_volatile_type
,
6235 /* Else cv-qualified version of named type; fall through. */
6240 else if (is_const_type
)
6242 mod_type_die
= new_die (DW_TAG_const_type
, comp_unit_die
);
6243 sub_die
= modified_type_die (type
, 0, is_volatile_type
, context_die
);
6245 else if (is_volatile_type
)
6247 mod_type_die
= new_die (DW_TAG_volatile_type
, comp_unit_die
);
6248 sub_die
= modified_type_die (type
, 0, 0, context_die
);
6250 else if (code
== POINTER_TYPE
)
6252 mod_type_die
= new_die (DW_TAG_pointer_type
, comp_unit_die
);
6253 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
, PTR_SIZE
);
6255 add_AT_unsigned (mod_type_die
, DW_AT_address_class
, 0);
6257 item_type
= TREE_TYPE (type
);
6259 else if (code
== REFERENCE_TYPE
)
6261 mod_type_die
= new_die (DW_TAG_reference_type
, comp_unit_die
);
6262 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
, PTR_SIZE
);
6264 add_AT_unsigned (mod_type_die
, DW_AT_address_class
, 0);
6266 item_type
= TREE_TYPE (type
);
6268 else if (is_base_type (type
))
6269 mod_type_die
= base_type_die (type
);
6272 gen_type_die (type
, context_die
);
6274 /* We have to get the type_main_variant here (and pass that to the
6275 `lookup_type_die' routine) because the ..._TYPE node we have
6276 might simply be a *copy* of some original type node (where the
6277 copy was created to help us keep track of typedef names) and
6278 that copy might have a different TYPE_UID from the original
6280 mod_type_die
= lookup_type_die (type_main_variant (type
));
6281 if (mod_type_die
== NULL
)
6286 equate_type_number_to_die (type
, mod_type_die
);
6288 /* We must do this after the equate_type_number_to_die call, in case
6289 this is a recursive type. This ensures that the modified_type_die
6290 recursion will terminate even if the type is recursive. Recursive
6291 types are possible in Ada. */
6292 sub_die
= modified_type_die (item_type
,
6293 TYPE_READONLY (item_type
),
6294 TYPE_VOLATILE (item_type
),
6297 if (sub_die
!= NULL
)
6298 add_AT_die_ref (mod_type_die
, DW_AT_type
, sub_die
);
6300 return mod_type_die
;
6303 /* Given a pointer to an arbitrary ..._TYPE tree node, return true if it is
6304 an enumerated type. */
6310 return TREE_CODE (type
) == ENUMERAL_TYPE
;
6313 /* Return a location descriptor that designates a machine register. */
6315 static dw_loc_descr_ref
6316 reg_loc_descriptor (rtl
)
6319 register dw_loc_descr_ref loc_result
= NULL
;
6320 register unsigned reg
= reg_number (rtl
);
6323 loc_result
= new_loc_descr (DW_OP_reg0
+ reg
, 0, 0);
6325 loc_result
= new_loc_descr (DW_OP_regx
, reg
, 0);
6330 /* Return a location descriptor that designates a base+offset location. */
6332 static dw_loc_descr_ref
6333 based_loc_descr (reg
, offset
)
6337 register dw_loc_descr_ref loc_result
;
6338 /* For the "frame base", we use the frame pointer or stack pointer
6339 registers, since the RTL for local variables is relative to one of
6341 register unsigned fp_reg
= DBX_REGISTER_NUMBER (frame_pointer_needed
6342 ? HARD_FRAME_POINTER_REGNUM
6343 : STACK_POINTER_REGNUM
);
6346 loc_result
= new_loc_descr (DW_OP_fbreg
, offset
, 0);
6348 loc_result
= new_loc_descr (DW_OP_breg0
+ reg
, offset
, 0);
6350 loc_result
= new_loc_descr (DW_OP_bregx
, reg
, offset
);
6355 /* Return true if this RTL expression describes a base+offset calculation. */
6361 return (GET_CODE (rtl
) == PLUS
6362 && ((GET_CODE (XEXP (rtl
, 0)) == REG
6363 && GET_CODE (XEXP (rtl
, 1)) == CONST_INT
)));
6366 /* The following routine converts the RTL for a variable or parameter
6367 (resident in memory) into an equivalent Dwarf representation of a
6368 mechanism for getting the address of that same variable onto the top of a
6369 hypothetical "address evaluation" stack.
6371 When creating memory location descriptors, we are effectively transforming
6372 the RTL for a memory-resident object into its Dwarf postfix expression
6373 equivalent. This routine recursively descends an RTL tree, turning
6374 it into Dwarf postfix code as it goes.
6376 MODE is the mode of the memory reference, needed to handle some
6377 autoincrement addressing modes. */
6379 static dw_loc_descr_ref
6380 mem_loc_descriptor (rtl
, mode
)
6382 enum machine_mode mode
;
6384 dw_loc_descr_ref mem_loc_result
= NULL
;
6385 /* Note that for a dynamically sized array, the location we will generate a
6386 description of here will be the lowest numbered location which is
6387 actually within the array. That's *not* necessarily the same as the
6388 zeroth element of the array. */
6390 switch (GET_CODE (rtl
))
6394 /* POST_INC and POST_DEC can be handled just like a SUBREG. So we
6395 just fall into the SUBREG code. */
6397 /* ... fall through ... */
6400 /* The case of a subreg may arise when we have a local (register)
6401 variable or a formal (register) parameter which doesn't quite fill
6402 up an entire register. For now, just assume that it is
6403 legitimate to make the Dwarf info refer to the whole register which
6404 contains the given subreg. */
6405 rtl
= XEXP (rtl
, 0);
6407 /* ... fall through ... */
6410 /* Whenever a register number forms a part of the description of the
6411 method for calculating the (dynamic) address of a memory resident
6412 object, DWARF rules require the register number be referred to as
6413 a "base register". This distinction is not based in any way upon
6414 what category of register the hardware believes the given register
6415 belongs to. This is strictly DWARF terminology we're dealing with
6416 here. Note that in cases where the location of a memory-resident
6417 data object could be expressed as: OP_ADD (OP_BASEREG (basereg),
6418 OP_CONST (0)) the actual DWARF location descriptor that we generate
6419 may just be OP_BASEREG (basereg). This may look deceptively like
6420 the object in question was allocated to a register (rather than in
6421 memory) so DWARF consumers need to be aware of the subtle
6422 distinction between OP_REG and OP_BASEREG. */
6423 mem_loc_result
= based_loc_descr (reg_number (rtl
), 0);
6427 mem_loc_result
= mem_loc_descriptor (XEXP (rtl
, 0), mode
);
6428 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_deref
, 0, 0));
6432 /* Some ports can transform a symbol ref into a label ref, because
6433 the symbol ref is too far away and has to be dumped into a constant
6437 mem_loc_result
= new_loc_descr (DW_OP_addr
, 0, 0);
6438 mem_loc_result
->dw_loc_oprnd1
.val_class
= dw_val_class_addr
;
6439 mem_loc_result
->dw_loc_oprnd1
.v
.val_addr
= addr_to_string (rtl
);
6444 /* Turn these into a PLUS expression and fall into the PLUS code
6446 rtl
= gen_rtx_PLUS (word_mode
, XEXP (rtl
, 0),
6447 GEN_INT (GET_CODE (rtl
) == PRE_INC
6448 ? GET_MODE_UNIT_SIZE (mode
)
6449 : - GET_MODE_UNIT_SIZE (mode
)));
6451 /* ... fall through ... */
6454 if (is_based_loc (rtl
))
6455 mem_loc_result
= based_loc_descr (reg_number (XEXP (rtl
, 0)),
6456 INTVAL (XEXP (rtl
, 1)));
6459 add_loc_descr (&mem_loc_result
, mem_loc_descriptor (XEXP (rtl
, 0),
6461 add_loc_descr (&mem_loc_result
, mem_loc_descriptor (XEXP (rtl
, 1),
6463 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_plus
, 0, 0));
6468 /* If a pseudo-reg is optimized away, it is possible for it to
6469 be replaced with a MEM containing a multiply. */
6470 add_loc_descr (&mem_loc_result
, mem_loc_descriptor (XEXP (rtl
, 0), mode
));
6471 add_loc_descr (&mem_loc_result
, mem_loc_descriptor (XEXP (rtl
, 1), mode
));
6472 add_loc_descr (&mem_loc_result
, new_loc_descr (DW_OP_mul
, 0, 0));
6476 mem_loc_result
= new_loc_descr (DW_OP_constu
, INTVAL (rtl
), 0);
6483 return mem_loc_result
;
6486 /* Return a descriptor that describes the concatenation of two locations.
6487 This is typically a complex variable. */
6489 static dw_loc_descr_ref
6490 concat_loc_descriptor (x0
, x1
)
6491 register rtx x0
, x1
;
6493 dw_loc_descr_ref cc_loc_result
= NULL
;
6495 if (!is_pseudo_reg (x0
)
6496 && (GET_CODE (x0
) != MEM
|| !is_pseudo_reg (XEXP (x0
, 0))))
6497 add_loc_descr (&cc_loc_result
, loc_descriptor (x0
));
6498 add_loc_descr (&cc_loc_result
,
6499 new_loc_descr (DW_OP_piece
, GET_MODE_SIZE (GET_MODE (x0
)), 0));
6501 if (!is_pseudo_reg (x1
)
6502 && (GET_CODE (x1
) != MEM
|| !is_pseudo_reg (XEXP (x1
, 0))))
6503 add_loc_descr (&cc_loc_result
, loc_descriptor (x1
));
6504 add_loc_descr (&cc_loc_result
,
6505 new_loc_descr (DW_OP_piece
, GET_MODE_SIZE (GET_MODE (x1
)), 0));
6507 return cc_loc_result
;
6510 /* Output a proper Dwarf location descriptor for a variable or parameter
6511 which is either allocated in a register or in a memory location. For a
6512 register, we just generate an OP_REG and the register number. For a
6513 memory location we provide a Dwarf postfix expression describing how to
6514 generate the (dynamic) address of the object onto the address stack. */
6516 static dw_loc_descr_ref
6517 loc_descriptor (rtl
)
6520 dw_loc_descr_ref loc_result
= NULL
;
6521 switch (GET_CODE (rtl
))
6524 /* The case of a subreg may arise when we have a local (register)
6525 variable or a formal (register) parameter which doesn't quite fill
6526 up an entire register. For now, just assume that it is
6527 legitimate to make the Dwarf info refer to the whole register which
6528 contains the given subreg. */
6529 rtl
= XEXP (rtl
, 0);
6531 /* ... fall through ... */
6534 loc_result
= reg_loc_descriptor (rtl
);
6538 loc_result
= mem_loc_descriptor (XEXP (rtl
, 0), GET_MODE (rtl
));
6542 loc_result
= concat_loc_descriptor (XEXP (rtl
, 0), XEXP (rtl
, 1));
6552 /* Given an unsigned value, round it up to the lowest multiple of `boundary'
6553 which is not less than the value itself. */
6555 static inline unsigned
6556 ceiling (value
, boundary
)
6557 register unsigned value
;
6558 register unsigned boundary
;
6560 return (((value
+ boundary
- 1) / boundary
) * boundary
);
6563 /* Given a pointer to what is assumed to be a FIELD_DECL node, return a
6564 pointer to the declared type for the relevant field variable, or return
6565 `integer_type_node' if the given node turns out to be an
6574 if (TREE_CODE (decl
) == ERROR_MARK
)
6575 return integer_type_node
;
6577 type
= DECL_BIT_FIELD_TYPE (decl
);
6578 if (type
== NULL_TREE
)
6579 type
= TREE_TYPE (decl
);
6584 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
6585 node, return the alignment in bits for the type, or else return
6586 BITS_PER_WORD if the node actually turns out to be an
6589 static inline unsigned
6590 simple_type_align_in_bits (type
)
6593 return (TREE_CODE (type
) != ERROR_MARK
) ? TYPE_ALIGN (type
) : BITS_PER_WORD
;
6596 /* Given a pointer to a tree node, assumed to be some kind of a ..._TYPE
6597 node, return the size in bits for the type if it is a constant, or else
6598 return the alignment for the type if the type's size is not constant, or
6599 else return BITS_PER_WORD if the type actually turns out to be an
6602 static inline unsigned
6603 simple_type_size_in_bits (type
)
6606 if (TREE_CODE (type
) == ERROR_MARK
)
6607 return BITS_PER_WORD
;
6610 register tree type_size_tree
= TYPE_SIZE (type
);
6612 if (TREE_CODE (type_size_tree
) != INTEGER_CST
)
6613 return TYPE_ALIGN (type
);
6615 return (unsigned) TREE_INT_CST_LOW (type_size_tree
);
6619 /* Given a pointer to what is assumed to be a FIELD_DECL node, compute and
6620 return the byte offset of the lowest addressed byte of the "containing
6621 object" for the given FIELD_DECL, or return 0 if we are unable to
6622 determine what that offset is, either because the argument turns out to
6623 be a pointer to an ERROR_MARK node, or because the offset is actually
6624 variable. (We can't handle the latter case just yet). */
6627 field_byte_offset (decl
)
6630 register unsigned type_align_in_bytes
;
6631 register unsigned type_align_in_bits
;
6632 register unsigned type_size_in_bits
;
6633 register unsigned object_offset_in_align_units
;
6634 register unsigned object_offset_in_bits
;
6635 register unsigned object_offset_in_bytes
;
6637 register tree bitpos_tree
;
6638 register tree field_size_tree
;
6639 register unsigned bitpos_int
;
6640 register unsigned deepest_bitpos
;
6641 register unsigned field_size_in_bits
;
6643 if (TREE_CODE (decl
) == ERROR_MARK
)
6646 if (TREE_CODE (decl
) != FIELD_DECL
)
6649 type
= field_type (decl
);
6651 bitpos_tree
= DECL_FIELD_BITPOS (decl
);
6652 field_size_tree
= DECL_SIZE (decl
);
6654 /* We cannot yet cope with fields whose positions are variable, so
6655 for now, when we see such things, we simply return 0. Someday, we may
6656 be able to handle such cases, but it will be damn difficult. */
6657 if (TREE_CODE (bitpos_tree
) != INTEGER_CST
)
6660 bitpos_int
= (unsigned) TREE_INT_CST_LOW (bitpos_tree
);
6662 /* If we don't know the size of the field, pretend it's a full word. */
6663 if (TREE_CODE (field_size_tree
) == INTEGER_CST
)
6664 field_size_in_bits
= (unsigned) TREE_INT_CST_LOW (field_size_tree
);
6666 field_size_in_bits
= BITS_PER_WORD
;
6668 type_size_in_bits
= simple_type_size_in_bits (type
);
6669 type_align_in_bits
= simple_type_align_in_bits (type
);
6670 type_align_in_bytes
= type_align_in_bits
/ BITS_PER_UNIT
;
6672 /* Note that the GCC front-end doesn't make any attempt to keep track of
6673 the starting bit offset (relative to the start of the containing
6674 structure type) of the hypothetical "containing object" for a bit-
6675 field. Thus, when computing the byte offset value for the start of the
6676 "containing object" of a bit-field, we must deduce this information on
6677 our own. This can be rather tricky to do in some cases. For example,
6678 handling the following structure type definition when compiling for an
6679 i386/i486 target (which only aligns long long's to 32-bit boundaries)
6682 struct S { int field1; long long field2:31; };
6684 Fortunately, there is a simple rule-of-thumb which can be
6685 used in such cases. When compiling for an i386/i486, GCC will allocate
6686 8 bytes for the structure shown above. It decides to do this based upon
6687 one simple rule for bit-field allocation. Quite simply, GCC allocates
6688 each "containing object" for each bit-field at the first (i.e. lowest
6689 addressed) legitimate alignment boundary (based upon the required
6690 minimum alignment for the declared type of the field) which it can
6691 possibly use, subject to the condition that there is still enough
6692 available space remaining in the containing object (when allocated at
6693 the selected point) to fully accommodate all of the bits of the
6694 bit-field itself. This simple rule makes it obvious why GCC allocates
6695 8 bytes for each object of the structure type shown above. When looking
6696 for a place to allocate the "containing object" for `field2', the
6697 compiler simply tries to allocate a 64-bit "containing object" at each
6698 successive 32-bit boundary (starting at zero) until it finds a place to
6699 allocate that 64- bit field such that at least 31 contiguous (and
6700 previously unallocated) bits remain within that selected 64 bit field.
6701 (As it turns out, for the example above, the compiler finds that it is
6702 OK to allocate the "containing object" 64-bit field at bit-offset zero
6703 within the structure type.) Here we attempt to work backwards from the
6704 limited set of facts we're given, and we try to deduce from those facts,
6705 where GCC must have believed that the containing object started (within
6706 the structure type). The value we deduce is then used (by the callers of
6707 this routine) to generate DW_AT_location and DW_AT_bit_offset attributes
6708 for fields (both bit-fields and, in the case of DW_AT_location, regular
6711 /* Figure out the bit-distance from the start of the structure to the
6712 "deepest" bit of the bit-field. */
6713 deepest_bitpos
= bitpos_int
+ field_size_in_bits
;
6715 /* This is the tricky part. Use some fancy footwork to deduce where the
6716 lowest addressed bit of the containing object must be. */
6717 object_offset_in_bits
6718 = ceiling (deepest_bitpos
, type_align_in_bits
) - type_size_in_bits
;
6720 /* Compute the offset of the containing object in "alignment units". */
6721 object_offset_in_align_units
= object_offset_in_bits
/ type_align_in_bits
;
6723 /* Compute the offset of the containing object in bytes. */
6724 object_offset_in_bytes
= object_offset_in_align_units
* type_align_in_bytes
;
6726 return object_offset_in_bytes
;
6729 /* The following routines define various Dwarf attributes and any data
6730 associated with them. */
6732 /* Add a location description attribute value to a DIE.
6734 This emits location attributes suitable for whole variables and
6735 whole parameters. Note that the location attributes for struct fields are
6736 generated by the routine `data_member_location_attribute' below. */
6739 add_AT_location_description (die
, attr_kind
, rtl
)
6741 enum dwarf_attribute attr_kind
;
6744 /* Handle a special case. If we are about to output a location descriptor
6745 for a variable or parameter which has been optimized out of existence,
6746 don't do that. A variable which has been optimized out
6747 of existence will have a DECL_RTL value which denotes a pseudo-reg.
6748 Currently, in some rare cases, variables can have DECL_RTL values which
6749 look like (MEM (REG pseudo-reg#)). These cases are due to bugs
6750 elsewhere in the compiler. We treat such cases as if the variable(s) in
6751 question had been optimized out of existence. */
6753 if (is_pseudo_reg (rtl
)
6754 || (GET_CODE (rtl
) == MEM
6755 && is_pseudo_reg (XEXP (rtl
, 0)))
6756 /* This can happen for a PARM_DECL with a DECL_INCOMING_RTL which
6757 references the internal argument pointer (a pseudo) in a function
6758 where all references to the internal argument pointer were
6759 eliminated via the optimizers. */
6760 || (GET_CODE (rtl
) == MEM
6761 && GET_CODE (XEXP (rtl
, 0)) == PLUS
6762 && is_pseudo_reg (XEXP (XEXP (rtl
, 0), 0)))
6763 || (GET_CODE (rtl
) == CONCAT
6764 && is_pseudo_reg (XEXP (rtl
, 0))
6765 && is_pseudo_reg (XEXP (rtl
, 1))))
6768 add_AT_loc (die
, attr_kind
, loc_descriptor (rtl
));
6771 /* Attach the specialized form of location attribute used for data
6772 members of struct and union types. In the special case of a
6773 FIELD_DECL node which represents a bit-field, the "offset" part
6774 of this special location descriptor must indicate the distance
6775 in bytes from the lowest-addressed byte of the containing struct
6776 or union type to the lowest-addressed byte of the "containing
6777 object" for the bit-field. (See the `field_byte_offset' function
6778 above).. For any given bit-field, the "containing object" is a
6779 hypothetical object (of some integral or enum type) within which
6780 the given bit-field lives. The type of this hypothetical
6781 "containing object" is always the same as the declared type of
6782 the individual bit-field itself (for GCC anyway... the DWARF
6783 spec doesn't actually mandate this). Note that it is the size
6784 (in bytes) of the hypothetical "containing object" which will
6785 be given in the DW_AT_byte_size attribute for this bit-field.
6786 (See the `byte_size_attribute' function below.) It is also used
6787 when calculating the value of the DW_AT_bit_offset attribute.
6788 (See the `bit_offset_attribute' function below). */
6791 add_data_member_location_attribute (die
, decl
)
6792 register dw_die_ref die
;
6795 register unsigned long offset
;
6796 register dw_loc_descr_ref loc_descr
;
6797 register enum dwarf_location_atom op
;
6799 if (TREE_CODE (decl
) == TREE_VEC
)
6800 offset
= TREE_INT_CST_LOW (BINFO_OFFSET (decl
));
6802 offset
= field_byte_offset (decl
);
6804 /* The DWARF2 standard says that we should assume that the structure address
6805 is already on the stack, so we can specify a structure field address
6806 by using DW_OP_plus_uconst. */
6808 #ifdef MIPS_DEBUGGING_INFO
6809 /* ??? The SGI dwarf reader does not handle the DW_OP_plus_uconst operator
6810 correctly. It works only if we leave the offset on the stack. */
6813 op
= DW_OP_plus_uconst
;
6816 loc_descr
= new_loc_descr (op
, offset
, 0);
6817 add_AT_loc (die
, DW_AT_data_member_location
, loc_descr
);
6820 /* Attach an DW_AT_const_value attribute for a variable or a parameter which
6821 does not have a "location" either in memory or in a register. These
6822 things can arise in GNU C when a constant is passed as an actual parameter
6823 to an inlined function. They can also arise in C++ where declared
6824 constants do not necessarily get memory "homes". */
6827 add_const_value_attribute (die
, rtl
)
6828 register dw_die_ref die
;
6831 switch (GET_CODE (rtl
))
6834 /* Note that a CONST_INT rtx could represent either an integer or a
6835 floating-point constant. A CONST_INT is used whenever the constant
6836 will fit into a single word. In all such cases, the original mode
6837 of the constant value is wiped out, and the CONST_INT rtx is
6838 assigned VOIDmode. */
6839 add_AT_unsigned (die
, DW_AT_const_value
, (unsigned) INTVAL (rtl
));
6843 /* Note that a CONST_DOUBLE rtx could represent either an integer or a
6844 floating-point constant. A CONST_DOUBLE is used whenever the
6845 constant requires more than one word in order to be adequately
6846 represented. We output CONST_DOUBLEs as blocks. */
6848 register enum machine_mode mode
= GET_MODE (rtl
);
6850 if (GET_MODE_CLASS (mode
) == MODE_FLOAT
)
6852 register unsigned length
= GET_MODE_SIZE (mode
) / sizeof (long);
6856 REAL_VALUE_FROM_CONST_DOUBLE (rv
, rtl
);
6860 REAL_VALUE_TO_TARGET_SINGLE (rv
, array
[0]);
6864 REAL_VALUE_TO_TARGET_DOUBLE (rv
, array
);
6869 REAL_VALUE_TO_TARGET_LONG_DOUBLE (rv
, array
);
6876 add_AT_float (die
, DW_AT_const_value
, length
, array
);
6879 add_AT_long_long (die
, DW_AT_const_value
,
6880 CONST_DOUBLE_HIGH (rtl
), CONST_DOUBLE_LOW (rtl
));
6885 add_AT_string (die
, DW_AT_const_value
, XSTR (rtl
, 0));
6891 add_AT_addr (die
, DW_AT_const_value
, addr_to_string (rtl
));
6895 /* In cases where an inlined instance of an inline function is passed
6896 the address of an `auto' variable (which is local to the caller) we
6897 can get a situation where the DECL_RTL of the artificial local
6898 variable (for the inlining) which acts as a stand-in for the
6899 corresponding formal parameter (of the inline function) will look
6900 like (plus:SI (reg:SI FRAME_PTR) (const_int ...)). This is not
6901 exactly a compile-time constant expression, but it isn't the address
6902 of the (artificial) local variable either. Rather, it represents the
6903 *value* which the artificial local variable always has during its
6904 lifetime. We currently have no way to represent such quasi-constant
6905 values in Dwarf, so for now we just punt and generate nothing. */
6909 /* No other kinds of rtx should be possible here. */
6915 /* Generate *either* an DW_AT_location attribute or else an DW_AT_const_value
6916 data attribute for a variable or a parameter. We generate the
6917 DW_AT_const_value attribute only in those cases where the given variable
6918 or parameter does not have a true "location" either in memory or in a
6919 register. This can happen (for example) when a constant is passed as an
6920 actual argument in a call to an inline function. (It's possible that
6921 these things can crop up in other ways also.) Note that one type of
6922 constant value which can be passed into an inlined function is a constant
6923 pointer. This can happen for example if an actual argument in an inlined
6924 function call evaluates to a compile-time constant address. */
6927 add_location_or_const_value_attribute (die
, decl
)
6928 register dw_die_ref die
;
6932 register tree declared_type
;
6933 register tree passed_type
;
6935 if (TREE_CODE (decl
) == ERROR_MARK
)
6938 if (TREE_CODE (decl
) != VAR_DECL
&& TREE_CODE (decl
) != PARM_DECL
)
6941 /* Here we have to decide where we are going to say the parameter "lives"
6942 (as far as the debugger is concerned). We only have a couple of
6943 choices. GCC provides us with DECL_RTL and with DECL_INCOMING_RTL.
6945 DECL_RTL normally indicates where the parameter lives during most of the
6946 activation of the function. If optimization is enabled however, this
6947 could be either NULL or else a pseudo-reg. Both of those cases indicate
6948 that the parameter doesn't really live anywhere (as far as the code
6949 generation parts of GCC are concerned) during most of the function's
6950 activation. That will happen (for example) if the parameter is never
6951 referenced within the function.
6953 We could just generate a location descriptor here for all non-NULL
6954 non-pseudo values of DECL_RTL and ignore all of the rest, but we can be
6955 a little nicer than that if we also consider DECL_INCOMING_RTL in cases
6956 where DECL_RTL is NULL or is a pseudo-reg.
6958 Note however that we can only get away with using DECL_INCOMING_RTL as
6959 a backup substitute for DECL_RTL in certain limited cases. In cases
6960 where DECL_ARG_TYPE (decl) indicates the same type as TREE_TYPE (decl),
6961 we can be sure that the parameter was passed using the same type as it is
6962 declared to have within the function, and that its DECL_INCOMING_RTL
6963 points us to a place where a value of that type is passed.
6965 In cases where DECL_ARG_TYPE (decl) and TREE_TYPE (decl) are different,
6966 we cannot (in general) use DECL_INCOMING_RTL as a substitute for DECL_RTL
6967 because in these cases DECL_INCOMING_RTL points us to a value of some
6968 type which is *different* from the type of the parameter itself. Thus,
6969 if we tried to use DECL_INCOMING_RTL to generate a location attribute in
6970 such cases, the debugger would end up (for example) trying to fetch a
6971 `float' from a place which actually contains the first part of a
6972 `double'. That would lead to really incorrect and confusing
6973 output at debug-time.
6975 So, in general, we *do not* use DECL_INCOMING_RTL as a backup for DECL_RTL
6976 in cases where DECL_ARG_TYPE (decl) != TREE_TYPE (decl). There
6977 are a couple of exceptions however. On little-endian machines we can
6978 get away with using DECL_INCOMING_RTL even when DECL_ARG_TYPE (decl) is
6979 not the same as TREE_TYPE (decl), but only when DECL_ARG_TYPE (decl) is
6980 an integral type that is smaller than TREE_TYPE (decl). These cases arise
6981 when (on a little-endian machine) a non-prototyped function has a
6982 parameter declared to be of type `short' or `char'. In such cases,
6983 TREE_TYPE (decl) will be `short' or `char', DECL_ARG_TYPE (decl) will
6984 be `int', and DECL_INCOMING_RTL will point to the lowest-order byte of the
6985 passed `int' value. If the debugger then uses that address to fetch
6986 a `short' or a `char' (on a little-endian machine) the result will be
6987 the correct data, so we allow for such exceptional cases below.
6989 Note that our goal here is to describe the place where the given formal
6990 parameter lives during most of the function's activation (i.e. between
6991 the end of the prologue and the start of the epilogue). We'll do that
6992 as best as we can. Note however that if the given formal parameter is
6993 modified sometime during the execution of the function, then a stack
6994 backtrace (at debug-time) will show the function as having been
6995 called with the *new* value rather than the value which was
6996 originally passed in. This happens rarely enough that it is not
6997 a major problem, but it *is* a problem, and I'd like to fix it.
6999 A future version of dwarf2out.c may generate two additional
7000 attributes for any given DW_TAG_formal_parameter DIE which will
7001 describe the "passed type" and the "passed location" for the
7002 given formal parameter in addition to the attributes we now
7003 generate to indicate the "declared type" and the "active
7004 location" for each parameter. This additional set of attributes
7005 could be used by debuggers for stack backtraces. Separately, note
7006 that sometimes DECL_RTL can be NULL and DECL_INCOMING_RTL can be
7007 NULL also. This happens (for example) for inlined-instances of
7008 inline function formal parameters which are never referenced.
7009 This really shouldn't be happening. All PARM_DECL nodes should
7010 get valid non-NULL DECL_INCOMING_RTL values, but integrate.c
7011 doesn't currently generate these values for inlined instances of
7012 inline function parameters, so when we see such cases, we are
7013 just out-of-luck for the time being (until integrate.c
7016 /* Use DECL_RTL as the "location" unless we find something better. */
7017 rtl
= DECL_RTL (decl
);
7019 if (TREE_CODE (decl
) == PARM_DECL
)
7021 if (rtl
== NULL_RTX
|| is_pseudo_reg (rtl
))
7023 declared_type
= type_main_variant (TREE_TYPE (decl
));
7024 passed_type
= type_main_variant (DECL_ARG_TYPE (decl
));
7026 /* This decl represents a formal parameter which was optimized out.
7027 Note that DECL_INCOMING_RTL may be NULL in here, but we handle
7028 all* cases where (rtl == NULL_RTX) just below. */
7029 if (declared_type
== passed_type
)
7030 rtl
= DECL_INCOMING_RTL (decl
);
7031 else if (! BYTES_BIG_ENDIAN
7032 && TREE_CODE (declared_type
) == INTEGER_TYPE
7033 && (GET_MODE_SIZE (TYPE_MODE (declared_type
))
7034 <= GET_MODE_SIZE (TYPE_MODE (passed_type
))))
7035 rtl
= DECL_INCOMING_RTL (decl
);
7038 /* If the parm was passed in registers, but lives on the stack, then
7039 make a big endian correction if the mode of the type of the
7040 parameter is not the same as the mode of the rtl. */
7041 /* ??? This is the same series of checks that are made in dbxout.c before
7042 we reach the big endian correction code there. It isn't clear if all
7043 of these checks are necessary here, but keeping them all is the safe
7045 else if (GET_CODE (rtl
) == MEM
7046 && XEXP (rtl
, 0) != const0_rtx
7047 && ! CONSTANT_P (XEXP (rtl
, 0))
7048 /* Not passed in memory. */
7049 && GET_CODE (DECL_INCOMING_RTL (decl
)) != MEM
7050 /* Not passed by invisible reference. */
7051 && (GET_CODE (XEXP (rtl
, 0)) != REG
7052 || REGNO (XEXP (rtl
, 0)) == HARD_FRAME_POINTER_REGNUM
7053 || REGNO (XEXP (rtl
, 0)) == STACK_POINTER_REGNUM
7054 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
7055 || REGNO (XEXP (rtl
, 0)) == ARG_POINTER_REGNUM
7058 /* Big endian correction check. */
7060 && TYPE_MODE (TREE_TYPE (decl
)) != GET_MODE (rtl
)
7061 && (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl
)))
7064 int offset
= (UNITS_PER_WORD
7065 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (decl
))));
7066 rtl
= gen_rtx_MEM (TYPE_MODE (TREE_TYPE (decl
)),
7067 plus_constant (XEXP (rtl
, 0), offset
));
7071 if (rtl
== NULL_RTX
)
7074 rtl
= eliminate_regs (rtl
, 0, NULL_RTX
);
7075 #ifdef LEAF_REG_REMAP
7076 if (current_function_uses_only_leaf_regs
)
7077 leaf_renumber_regs_insn (rtl
);
7080 switch (GET_CODE (rtl
))
7083 /* The address of a variable that was optimized away; don't emit
7094 /* DECL_RTL could be (plus (reg ...) (const_int ...)) */
7095 add_const_value_attribute (die
, rtl
);
7102 add_AT_location_description (die
, DW_AT_location
, rtl
);
7110 /* Generate an DW_AT_name attribute given some string value to be included as
7111 the value of the attribute. */
7114 add_name_attribute (die
, name_string
)
7115 register dw_die_ref die
;
7116 register const char *name_string
;
7118 if (name_string
!= NULL
&& *name_string
!= 0)
7120 if (demangle_name_func
)
7121 name_string
= (*demangle_name_func
) (name_string
);
7123 add_AT_string (die
, DW_AT_name
, name_string
);
7127 /* Given a tree node describing an array bound (either lower or upper) output
7128 a representation for that bound. */
7131 add_bound_info (subrange_die
, bound_attr
, bound
)
7132 register dw_die_ref subrange_die
;
7133 register enum dwarf_attribute bound_attr
;
7134 register tree bound
;
7136 register unsigned bound_value
= 0;
7138 /* If this is an Ada unconstrained array type, then don't emit any debug
7139 info because the array bounds are unknown. They are parameterized when
7140 the type is instantiated. */
7141 if (contains_placeholder_p (bound
))
7144 switch (TREE_CODE (bound
))
7149 /* All fixed-bounds are represented by INTEGER_CST nodes. */
7151 bound_value
= TREE_INT_CST_LOW (bound
);
7152 if (bound_attr
== DW_AT_lower_bound
7153 && ((is_c_family () && bound_value
== 0)
7154 || (is_fortran () && bound_value
== 1)))
7155 /* use the default */;
7157 add_AT_unsigned (subrange_die
, bound_attr
, bound_value
);
7162 case NON_LVALUE_EXPR
:
7163 add_bound_info (subrange_die
, bound_attr
, TREE_OPERAND (bound
, 0));
7167 /* If optimization is turned on, the SAVE_EXPRs that describe how to
7168 access the upper bound values may be bogus. If they refer to a
7169 register, they may only describe how to get at these values at the
7170 points in the generated code right after they have just been
7171 computed. Worse yet, in the typical case, the upper bound values
7172 will not even *be* computed in the optimized code (though the
7173 number of elements will), so these SAVE_EXPRs are entirely
7174 bogus. In order to compensate for this fact, we check here to see
7175 if optimization is enabled, and if so, we don't add an attribute
7176 for the (unknown and unknowable) upper bound. This should not
7177 cause too much trouble for existing (stupid?) debuggers because
7178 they have to deal with empty upper bounds location descriptions
7179 anyway in order to be able to deal with incomplete array types.
7180 Of course an intelligent debugger (GDB?) should be able to
7181 comprehend that a missing upper bound specification in a array
7182 type used for a storage class `auto' local array variable
7183 indicates that the upper bound is both unknown (at compile- time)
7184 and unknowable (at run-time) due to optimization.
7186 We assume that a MEM rtx is safe because gcc wouldn't put the
7187 value there unless it was going to be used repeatedly in the
7188 function, i.e. for cleanups. */
7189 if (! optimize
|| GET_CODE (SAVE_EXPR_RTL (bound
)) == MEM
)
7191 register dw_die_ref ctx
= lookup_decl_die (current_function_decl
);
7192 register dw_die_ref decl_die
= new_die (DW_TAG_variable
, ctx
);
7193 register rtx loc
= SAVE_EXPR_RTL (bound
);
7195 /* If the RTL for the SAVE_EXPR is memory, handle the case where
7196 it references an outer function's frame. */
7198 if (GET_CODE (loc
) == MEM
)
7200 rtx new_addr
= fix_lexical_addr (XEXP (loc
, 0), bound
);
7202 if (XEXP (loc
, 0) != new_addr
)
7203 loc
= gen_rtx_MEM (GET_MODE (loc
), new_addr
);
7206 add_AT_flag (decl_die
, DW_AT_artificial
, 1);
7207 add_type_attribute (decl_die
, TREE_TYPE (bound
), 1, 0, ctx
);
7208 add_AT_location_description (decl_die
, DW_AT_location
, loc
);
7209 add_AT_die_ref (subrange_die
, bound_attr
, decl_die
);
7212 /* Else leave out the attribute. */
7218 /* ??? These types of bounds can be created by the Ada front end,
7219 and it isn't clear how to emit debug info for them. */
7227 /* Note that the block of subscript information for an array type also
7228 includes information about the element type of type given array type. */
7231 add_subscript_info (type_die
, type
)
7232 register dw_die_ref type_die
;
7235 #ifndef MIPS_DEBUGGING_INFO
7236 register unsigned dimension_number
;
7238 register tree lower
, upper
;
7239 register dw_die_ref subrange_die
;
7241 /* The GNU compilers represent multidimensional array types as sequences of
7242 one dimensional array types whose element types are themselves array
7243 types. Here we squish that down, so that each multidimensional array
7244 type gets only one array_type DIE in the Dwarf debugging info. The draft
7245 Dwarf specification say that we are allowed to do this kind of
7246 compression in C (because there is no difference between an array or
7247 arrays and a multidimensional array in C) but for other source languages
7248 (e.g. Ada) we probably shouldn't do this. */
7250 /* ??? The SGI dwarf reader fails for multidimensional arrays with a
7251 const enum type. E.g. const enum machine_mode insn_operand_mode[2][10].
7252 We work around this by disabling this feature. See also
7253 gen_array_type_die. */
7254 #ifndef MIPS_DEBUGGING_INFO
7255 for (dimension_number
= 0;
7256 TREE_CODE (type
) == ARRAY_TYPE
;
7257 type
= TREE_TYPE (type
), dimension_number
++)
7260 register tree domain
= TYPE_DOMAIN (type
);
7262 /* Arrays come in three flavors: Unspecified bounds, fixed bounds,
7263 and (in GNU C only) variable bounds. Handle all three forms
7265 subrange_die
= new_die (DW_TAG_subrange_type
, type_die
);
7268 /* We have an array type with specified bounds. */
7269 lower
= TYPE_MIN_VALUE (domain
);
7270 upper
= TYPE_MAX_VALUE (domain
);
7272 /* define the index type. */
7273 if (TREE_TYPE (domain
))
7275 /* ??? This is probably an Ada unnamed subrange type. Ignore the
7276 TREE_TYPE field. We can't emit debug info for this
7277 because it is an unnamed integral type. */
7278 if (TREE_CODE (domain
) == INTEGER_TYPE
7279 && TYPE_NAME (domain
) == NULL_TREE
7280 && TREE_CODE (TREE_TYPE (domain
)) == INTEGER_TYPE
7281 && TYPE_NAME (TREE_TYPE (domain
)) == NULL_TREE
)
7284 add_type_attribute (subrange_die
, TREE_TYPE (domain
), 0, 0,
7288 /* ??? If upper is NULL, the array has unspecified length,
7289 but it does have a lower bound. This happens with Fortran
7291 Since the debugger is definitely going to need to know N
7292 to produce useful results, go ahead and output the lower
7293 bound solo, and hope the debugger can cope. */
7295 add_bound_info (subrange_die
, DW_AT_lower_bound
, lower
);
7297 add_bound_info (subrange_die
, DW_AT_upper_bound
, upper
);
7300 /* We have an array type with an unspecified length. The DWARF-2
7301 spec does not say how to handle this; let's just leave out the
7306 #ifndef MIPS_DEBUGGING_INFO
7312 add_byte_size_attribute (die
, tree_node
)
7314 register tree tree_node
;
7316 register unsigned size
;
7318 switch (TREE_CODE (tree_node
))
7326 case QUAL_UNION_TYPE
:
7327 size
= int_size_in_bytes (tree_node
);
7330 /* For a data member of a struct or union, the DW_AT_byte_size is
7331 generally given as the number of bytes normally allocated for an
7332 object of the *declared* type of the member itself. This is true
7333 even for bit-fields. */
7334 size
= simple_type_size_in_bits (field_type (tree_node
)) / BITS_PER_UNIT
;
7340 /* Note that `size' might be -1 when we get to this point. If it is, that
7341 indicates that the byte size of the entity in question is variable. We
7342 have no good way of expressing this fact in Dwarf at the present time,
7343 so just let the -1 pass on through. */
7345 add_AT_unsigned (die
, DW_AT_byte_size
, size
);
7348 /* For a FIELD_DECL node which represents a bit-field, output an attribute
7349 which specifies the distance in bits from the highest order bit of the
7350 "containing object" for the bit-field to the highest order bit of the
7353 For any given bit-field, the "containing object" is a hypothetical
7354 object (of some integral or enum type) within which the given bit-field
7355 lives. The type of this hypothetical "containing object" is always the
7356 same as the declared type of the individual bit-field itself. The
7357 determination of the exact location of the "containing object" for a
7358 bit-field is rather complicated. It's handled by the
7359 `field_byte_offset' function (above).
7361 Note that it is the size (in bytes) of the hypothetical "containing object"
7362 which will be given in the DW_AT_byte_size attribute for this bit-field.
7363 (See `byte_size_attribute' above). */
7366 add_bit_offset_attribute (die
, decl
)
7367 register dw_die_ref die
;
7370 register unsigned object_offset_in_bytes
= field_byte_offset (decl
);
7371 register tree type
= DECL_BIT_FIELD_TYPE (decl
);
7372 register tree bitpos_tree
= DECL_FIELD_BITPOS (decl
);
7373 register unsigned bitpos_int
;
7374 register unsigned highest_order_object_bit_offset
;
7375 register unsigned highest_order_field_bit_offset
;
7376 register unsigned bit_offset
;
7378 /* Must be a field and a bit field. */
7380 || TREE_CODE (decl
) != FIELD_DECL
)
7383 /* We can't yet handle bit-fields whose offsets are variable, so if we
7384 encounter such things, just return without generating any attribute
7386 if (TREE_CODE (bitpos_tree
) != INTEGER_CST
)
7389 bitpos_int
= (unsigned) TREE_INT_CST_LOW (bitpos_tree
);
7391 /* Note that the bit offset is always the distance (in bits) from the
7392 highest-order bit of the "containing object" to the highest-order bit of
7393 the bit-field itself. Since the "high-order end" of any object or field
7394 is different on big-endian and little-endian machines, the computation
7395 below must take account of these differences. */
7396 highest_order_object_bit_offset
= object_offset_in_bytes
* BITS_PER_UNIT
;
7397 highest_order_field_bit_offset
= bitpos_int
;
7399 if (! BYTES_BIG_ENDIAN
)
7401 highest_order_field_bit_offset
7402 += (unsigned) TREE_INT_CST_LOW (DECL_SIZE (decl
));
7404 highest_order_object_bit_offset
+= simple_type_size_in_bits (type
);
7408 = (! BYTES_BIG_ENDIAN
7409 ? highest_order_object_bit_offset
- highest_order_field_bit_offset
7410 : highest_order_field_bit_offset
- highest_order_object_bit_offset
);
7412 add_AT_unsigned (die
, DW_AT_bit_offset
, bit_offset
);
7415 /* For a FIELD_DECL node which represents a bit field, output an attribute
7416 which specifies the length in bits of the given field. */
7419 add_bit_size_attribute (die
, decl
)
7420 register dw_die_ref die
;
7423 /* Must be a field and a bit field. */
7424 if (TREE_CODE (decl
) != FIELD_DECL
7425 || ! DECL_BIT_FIELD_TYPE (decl
))
7427 add_AT_unsigned (die
, DW_AT_bit_size
,
7428 (unsigned) TREE_INT_CST_LOW (DECL_SIZE (decl
)));
7431 /* If the compiled language is ANSI C, then add a 'prototyped'
7432 attribute, if arg types are given for the parameters of a function. */
7435 add_prototyped_attribute (die
, func_type
)
7436 register dw_die_ref die
;
7437 register tree func_type
;
7439 if (get_AT_unsigned (comp_unit_die
, DW_AT_language
) == DW_LANG_C89
7440 && TYPE_ARG_TYPES (func_type
) != NULL
)
7441 add_AT_flag (die
, DW_AT_prototyped
, 1);
7445 /* Add an 'abstract_origin' attribute below a given DIE. The DIE is found
7446 by looking in either the type declaration or object declaration
7450 add_abstract_origin_attribute (die
, origin
)
7451 register dw_die_ref die
;
7452 register tree origin
;
7454 dw_die_ref origin_die
= NULL
;
7456 if (TREE_CODE_CLASS (TREE_CODE (origin
)) == 'd')
7457 origin_die
= lookup_decl_die (origin
);
7458 else if (TREE_CODE_CLASS (TREE_CODE (origin
)) == 't')
7459 origin_die
= lookup_type_die (origin
);
7461 if (origin_die
== NULL
)
7464 add_AT_die_ref (die
, DW_AT_abstract_origin
, origin_die
);
7467 /* We do not currently support the pure_virtual attribute. */
7470 add_pure_or_virtual_attribute (die
, func_decl
)
7471 register dw_die_ref die
;
7472 register tree func_decl
;
7474 if (DECL_VINDEX (func_decl
))
7476 add_AT_unsigned (die
, DW_AT_virtuality
, DW_VIRTUALITY_virtual
);
7477 add_AT_loc (die
, DW_AT_vtable_elem_location
,
7478 new_loc_descr (DW_OP_constu
,
7479 TREE_INT_CST_LOW (DECL_VINDEX (func_decl
)),
7482 /* GNU extension: Record what type this method came from originally. */
7483 if (debug_info_level
> DINFO_LEVEL_TERSE
)
7484 add_AT_die_ref (die
, DW_AT_containing_type
,
7485 lookup_type_die (DECL_CONTEXT (func_decl
)));
7489 /* Add source coordinate attributes for the given decl. */
7492 add_src_coords_attributes (die
, decl
)
7493 register dw_die_ref die
;
7496 register unsigned file_index
= lookup_filename (DECL_SOURCE_FILE (decl
));
7498 add_AT_unsigned (die
, DW_AT_decl_file
, file_index
);
7499 add_AT_unsigned (die
, DW_AT_decl_line
, DECL_SOURCE_LINE (decl
));
7502 /* Add an DW_AT_name attribute and source coordinate attribute for the
7503 given decl, but only if it actually has a name. */
7506 add_name_and_src_coords_attributes (die
, decl
)
7507 register dw_die_ref die
;
7510 register tree decl_name
;
7512 decl_name
= DECL_NAME (decl
);
7513 if (decl_name
!= NULL
&& IDENTIFIER_POINTER (decl_name
) != NULL
)
7515 add_name_attribute (die
, dwarf2_name (decl
, 0));
7516 if (! DECL_ARTIFICIAL (decl
))
7517 add_src_coords_attributes (die
, decl
);
7519 if ((TREE_CODE (decl
) == FUNCTION_DECL
|| TREE_CODE (decl
) == VAR_DECL
)
7520 && DECL_ASSEMBLER_NAME (decl
) != DECL_NAME (decl
))
7521 add_AT_string (die
, DW_AT_MIPS_linkage_name
,
7522 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)));
7526 /* Push a new declaration scope. */
7529 push_decl_scope (scope
)
7532 /* Make room in the decl_scope_table, if necessary. */
7533 if (decl_scope_table_allocated
== decl_scope_depth
)
7535 decl_scope_table_allocated
+= DECL_SCOPE_TABLE_INCREMENT
;
7537 = (decl_scope_node
*) xrealloc (decl_scope_table
,
7538 (decl_scope_table_allocated
7539 * sizeof (decl_scope_node
)));
7542 decl_scope_table
[decl_scope_depth
].scope
= scope
;
7544 /* If we're starting to emit a global class while we're in the middle
7545 of emitting a function, we need to find the proper .previous. */
7547 if (AGGREGATE_TYPE_P (scope
))
7549 tree containing_scope
= TYPE_CONTEXT (scope
);
7552 for (i
= decl_scope_depth
- 1; i
>= 0; --i
)
7553 if (decl_scope_table
[i
].scope
== containing_scope
)
7556 decl_scope_table
[decl_scope_depth
].previous
= i
;
7559 decl_scope_table
[decl_scope_depth
].previous
= decl_scope_depth
- 1;
7564 /* Return the DIE for the scope that immediately contains this declaration. */
7567 scope_die_for (t
, context_die
)
7569 register dw_die_ref context_die
;
7571 register dw_die_ref scope_die
= NULL
;
7572 register tree containing_scope
;
7575 /* Walk back up the declaration tree looking for a place to define
7577 if (TREE_CODE_CLASS (TREE_CODE (t
)) == 't')
7578 containing_scope
= TYPE_CONTEXT (t
);
7579 else if (TREE_CODE (t
) == FUNCTION_DECL
&& DECL_VINDEX (t
))
7580 containing_scope
= decl_class_context (t
);
7582 containing_scope
= DECL_CONTEXT (t
);
7584 /* Ignore namespaces for the moment. */
7585 if (containing_scope
&& TREE_CODE (containing_scope
) == NAMESPACE_DECL
)
7586 containing_scope
= NULL_TREE
;
7588 /* Ignore function type "scopes" from the C frontend. They mean that
7589 a tagged type is local to a parmlist of a function declarator, but
7590 that isn't useful to DWARF. */
7591 if (containing_scope
&& TREE_CODE (containing_scope
) == FUNCTION_TYPE
)
7592 containing_scope
= NULL_TREE
;
7594 /* Function-local tags and functions get stuck in limbo until they are
7595 fixed up by decls_for_scope. */
7596 if (context_die
== NULL
&& containing_scope
!= NULL_TREE
7597 && (TREE_CODE (t
) == FUNCTION_DECL
|| is_tagged_type (t
)))
7600 if (containing_scope
== NULL_TREE
)
7601 scope_die
= comp_unit_die
;
7602 else if (TYPE_P (containing_scope
) || DECL_P (containing_scope
))
7604 /* For types and decls, we can just look up the appropriate DIE. But
7605 first we check to see if we're in the middle of emitting it so we
7606 know where the new DIE should go. */
7608 for (i
= decl_scope_depth
- 1; i
>= 0; --i
)
7609 if (decl_scope_table
[i
].scope
== containing_scope
)
7614 /* Function-local tags and functions get stuck in limbo
7615 until they are fixed up by decls_for_scope. */
7616 if (TREE_CODE (containing_scope
) == FUNCTION_DECL
7617 && (TREE_CODE (t
) == FUNCTION_DECL
|| is_tagged_type (t
)))
7620 if (! TYPE_P (containing_scope
))
7622 if (debug_info_level
> DINFO_LEVEL_TERSE
7623 && !TREE_ASM_WRITTEN (containing_scope
))
7626 /* If none of the current dies are suitable, we get file scope. */
7627 scope_die
= comp_unit_die
;
7631 if (TYPE_P (containing_scope
))
7632 scope_die
= lookup_type_die (containing_scope
);
7634 scope_die
= lookup_decl_die (containing_scope
);
7639 /* Something that we can't just look up the DIE for, such as a
7642 for (i
= decl_scope_depth
- 1, scope_die
= context_die
;
7643 i
>= 0 && decl_scope_table
[i
].scope
!= containing_scope
;
7644 (scope_die
= scope_die
->die_parent
,
7645 i
= decl_scope_table
[i
].previous
))
7648 /* ??? Integrate_decl_tree does not handle BLOCK_TYPE_TAGS, nor
7649 does it try to handle types defined by TYPE_DECLs. Such types
7650 thus have an incorrect TYPE_CONTEXT, which points to the block
7651 they were originally defined in, instead of the current block
7652 created by function inlining. We try to detect that here and
7655 if (i
< 0 && scope_die
== comp_unit_die
7656 && TREE_CODE (containing_scope
) == BLOCK
7657 && is_tagged_type (t
)
7658 && (block_ultimate_origin (decl_scope_table
[decl_scope_depth
- 1].scope
)
7659 == containing_scope
))
7661 scope_die
= context_die
;
7662 /* Since the checks below are no longer applicable. */
7673 /* Pop a declaration scope. */
7677 if (decl_scope_depth
<= 0)
7682 /* Many forms of DIEs require a "type description" attribute. This
7683 routine locates the proper "type descriptor" die for the type given
7684 by 'type', and adds an DW_AT_type attribute below the given die. */
7687 add_type_attribute (object_die
, type
, decl_const
, decl_volatile
, context_die
)
7688 register dw_die_ref object_die
;
7690 register int decl_const
;
7691 register int decl_volatile
;
7692 register dw_die_ref context_die
;
7694 register enum tree_code code
= TREE_CODE (type
);
7695 register dw_die_ref type_die
= NULL
;
7697 /* ??? If this type is an unnamed subrange type of an integral or
7698 floating-point type, use the inner type. This is because we have no
7699 support for unnamed types in base_type_die. This can happen if this is
7700 an Ada subrange type. Correct solution is emit a subrange type die. */
7701 if ((code
== INTEGER_TYPE
|| code
== REAL_TYPE
)
7702 && TREE_TYPE (type
) != 0 && TYPE_NAME (type
) == 0)
7703 type
= TREE_TYPE (type
), code
= TREE_CODE (type
);
7705 if (code
== ERROR_MARK
)
7708 /* Handle a special case. For functions whose return type is void, we
7709 generate *no* type attribute. (Note that no object may have type
7710 `void', so this only applies to function return types). */
7711 if (code
== VOID_TYPE
)
7714 type_die
= modified_type_die (type
,
7715 decl_const
|| TYPE_READONLY (type
),
7716 decl_volatile
|| TYPE_VOLATILE (type
),
7718 if (type_die
!= NULL
)
7719 add_AT_die_ref (object_die
, DW_AT_type
, type_die
);
7722 /* Given a tree pointer to a struct, class, union, or enum type node, return
7723 a pointer to the (string) tag name for the given type, or zero if the type
7724 was declared without a tag. */
7730 register char *name
= 0;
7732 if (TYPE_NAME (type
) != 0)
7734 register tree t
= 0;
7736 /* Find the IDENTIFIER_NODE for the type name. */
7737 if (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
)
7738 t
= TYPE_NAME (type
);
7740 /* The g++ front end makes the TYPE_NAME of *each* tagged type point to
7741 a TYPE_DECL node, regardless of whether or not a `typedef' was
7743 else if (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
7744 && ! DECL_IGNORED_P (TYPE_NAME (type
)))
7745 t
= DECL_NAME (TYPE_NAME (type
));
7747 /* Now get the name as a string, or invent one. */
7749 name
= IDENTIFIER_POINTER (t
);
7752 return (name
== 0 || *name
== '\0') ? 0 : name
;
7755 /* Return the type associated with a data member, make a special check
7756 for bit field types. */
7759 member_declared_type (member
)
7760 register tree member
;
7762 return (DECL_BIT_FIELD_TYPE (member
)
7763 ? DECL_BIT_FIELD_TYPE (member
)
7764 : TREE_TYPE (member
));
7767 /* Get the decl's label, as described by its RTL. This may be different
7768 from the DECL_NAME name used in the source file. */
7772 decl_start_label (decl
)
7777 x
= DECL_RTL (decl
);
7778 if (GET_CODE (x
) != MEM
)
7782 if (GET_CODE (x
) != SYMBOL_REF
)
7785 fnname
= XSTR (x
, 0);
7790 /* These routines generate the internal representation of the DIE's for
7791 the compilation unit. Debugging information is collected by walking
7792 the declaration trees passed in from dwarf2out_decl(). */
7795 gen_array_type_die (type
, context_die
)
7797 register dw_die_ref context_die
;
7799 register dw_die_ref scope_die
= scope_die_for (type
, context_die
);
7800 register dw_die_ref array_die
;
7801 register tree element_type
;
7803 /* ??? The SGI dwarf reader fails for array of array of enum types unless
7804 the inner array type comes before the outer array type. Thus we must
7805 call gen_type_die before we call new_die. See below also. */
7806 #ifdef MIPS_DEBUGGING_INFO
7807 gen_type_die (TREE_TYPE (type
), context_die
);
7810 array_die
= new_die (DW_TAG_array_type
, scope_die
);
7813 /* We default the array ordering. SDB will probably do
7814 the right things even if DW_AT_ordering is not present. It's not even
7815 an issue until we start to get into multidimensional arrays anyway. If
7816 SDB is ever caught doing the Wrong Thing for multi-dimensional arrays,
7817 then we'll have to put the DW_AT_ordering attribute back in. (But if
7818 and when we find out that we need to put these in, we will only do so
7819 for multidimensional arrays. */
7820 add_AT_unsigned (array_die
, DW_AT_ordering
, DW_ORD_row_major
);
7823 #ifdef MIPS_DEBUGGING_INFO
7824 /* The SGI compilers handle arrays of unknown bound by setting
7825 AT_declaration and not emitting any subrange DIEs. */
7826 if (! TYPE_DOMAIN (type
))
7827 add_AT_unsigned (array_die
, DW_AT_declaration
, 1);
7830 add_subscript_info (array_die
, type
);
7832 add_name_attribute (array_die
, type_tag (type
));
7833 equate_type_number_to_die (type
, array_die
);
7835 /* Add representation of the type of the elements of this array type. */
7836 element_type
= TREE_TYPE (type
);
7838 /* ??? The SGI dwarf reader fails for multidimensional arrays with a
7839 const enum type. E.g. const enum machine_mode insn_operand_mode[2][10].
7840 We work around this by disabling this feature. See also
7841 add_subscript_info. */
7842 #ifndef MIPS_DEBUGGING_INFO
7843 while (TREE_CODE (element_type
) == ARRAY_TYPE
)
7844 element_type
= TREE_TYPE (element_type
);
7846 gen_type_die (element_type
, context_die
);
7849 add_type_attribute (array_die
, element_type
, 0, 0, context_die
);
7853 gen_set_type_die (type
, context_die
)
7855 register dw_die_ref context_die
;
7857 register dw_die_ref type_die
7858 = new_die (DW_TAG_set_type
, scope_die_for (type
, context_die
));
7860 equate_type_number_to_die (type
, type_die
);
7861 add_type_attribute (type_die
, TREE_TYPE (type
), 0, 0, context_die
);
7866 gen_entry_point_die (decl
, context_die
)
7868 register dw_die_ref context_die
;
7870 register tree origin
= decl_ultimate_origin (decl
);
7871 register dw_die_ref decl_die
= new_die (DW_TAG_entry_point
, context_die
);
7873 add_abstract_origin_attribute (decl_die
, origin
);
7876 add_name_and_src_coords_attributes (decl_die
, decl
);
7877 add_type_attribute (decl_die
, TREE_TYPE (TREE_TYPE (decl
)),
7881 if (DECL_ABSTRACT (decl
))
7882 equate_decl_number_to_die (decl
, decl_die
);
7884 add_AT_lbl_id (decl_die
, DW_AT_low_pc
, decl_start_label (decl
));
7888 /* Remember a type in the pending_types_list. */
7894 if (pending_types
== pending_types_allocated
)
7896 pending_types_allocated
+= PENDING_TYPES_INCREMENT
;
7898 = (tree
*) xrealloc (pending_types_list
,
7899 sizeof (tree
) * pending_types_allocated
);
7902 pending_types_list
[pending_types
++] = type
;
7905 /* Output any pending types (from the pending_types list) which we can output
7906 now (taking into account the scope that we are working on now).
7908 For each type output, remove the given type from the pending_types_list
7909 *before* we try to output it. */
7912 output_pending_types_for_scope (context_die
)
7913 register dw_die_ref context_die
;
7917 while (pending_types
)
7920 type
= pending_types_list
[pending_types
];
7921 gen_type_die (type
, context_die
);
7922 if (!TREE_ASM_WRITTEN (type
))
7927 /* Remember a type in the incomplete_types_list. */
7930 add_incomplete_type (type
)
7933 if (incomplete_types
== incomplete_types_allocated
)
7935 incomplete_types_allocated
+= INCOMPLETE_TYPES_INCREMENT
;
7936 incomplete_types_list
7937 = (tree
*) xrealloc (incomplete_types_list
,
7938 sizeof (tree
) * incomplete_types_allocated
);
7941 incomplete_types_list
[incomplete_types
++] = type
;
7944 /* Walk through the list of incomplete types again, trying once more to
7945 emit full debugging info for them. */
7948 retry_incomplete_types ()
7952 while (incomplete_types
)
7955 type
= incomplete_types_list
[incomplete_types
];
7956 gen_type_die (type
, comp_unit_die
);
7960 /* Generate a DIE to represent an inlined instance of an enumeration type. */
7963 gen_inlined_enumeration_type_die (type
, context_die
)
7965 register dw_die_ref context_die
;
7967 register dw_die_ref type_die
= new_die (DW_TAG_enumeration_type
,
7968 scope_die_for (type
, context_die
));
7969 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
7970 be incomplete and such types are not marked. */
7971 add_abstract_origin_attribute (type_die
, type
);
7974 /* Generate a DIE to represent an inlined instance of a structure type. */
7977 gen_inlined_structure_type_die (type
, context_die
)
7979 register dw_die_ref context_die
;
7981 register dw_die_ref type_die
= new_die (DW_TAG_structure_type
,
7982 scope_die_for (type
, context_die
));
7983 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
7984 be incomplete and such types are not marked. */
7985 add_abstract_origin_attribute (type_die
, type
);
7988 /* Generate a DIE to represent an inlined instance of a union type. */
7991 gen_inlined_union_type_die (type
, context_die
)
7993 register dw_die_ref context_die
;
7995 register dw_die_ref type_die
= new_die (DW_TAG_union_type
,
7996 scope_die_for (type
, context_die
));
7997 /* We do not check for TREE_ASM_WRITTEN (type) being set, as the type may
7998 be incomplete and such types are not marked. */
7999 add_abstract_origin_attribute (type_die
, type
);
8002 /* Generate a DIE to represent an enumeration type. Note that these DIEs
8003 include all of the information about the enumeration values also. Each
8004 enumerated type name/value is listed as a child of the enumerated type
8008 gen_enumeration_type_die (type
, context_die
)
8010 register dw_die_ref context_die
;
8012 register dw_die_ref type_die
= lookup_type_die (type
);
8014 if (type_die
== NULL
)
8016 type_die
= new_die (DW_TAG_enumeration_type
,
8017 scope_die_for (type
, context_die
));
8018 equate_type_number_to_die (type
, type_die
);
8019 add_name_attribute (type_die
, type_tag (type
));
8021 else if (! TYPE_SIZE (type
))
8024 remove_AT (type_die
, DW_AT_declaration
);
8026 /* Handle a GNU C/C++ extension, i.e. incomplete enum types. If the
8027 given enum type is incomplete, do not generate the DW_AT_byte_size
8028 attribute or the DW_AT_element_list attribute. */
8029 if (TYPE_SIZE (type
))
8033 TREE_ASM_WRITTEN (type
) = 1;
8034 add_byte_size_attribute (type_die
, type
);
8035 if (TYPE_STUB_DECL (type
) != NULL_TREE
)
8036 add_src_coords_attributes (type_die
, TYPE_STUB_DECL (type
));
8038 /* If the first reference to this type was as the return type of an
8039 inline function, then it may not have a parent. Fix this now. */
8040 if (type_die
->die_parent
== NULL
)
8041 add_child_die (scope_die_for (type
, context_die
), type_die
);
8043 for (link
= TYPE_FIELDS (type
);
8044 link
!= NULL
; link
= TREE_CHAIN (link
))
8046 register dw_die_ref enum_die
= new_die (DW_TAG_enumerator
, type_die
);
8048 add_name_attribute (enum_die
,
8049 IDENTIFIER_POINTER (TREE_PURPOSE (link
)));
8050 add_AT_unsigned (enum_die
, DW_AT_const_value
,
8051 (unsigned) TREE_INT_CST_LOW (TREE_VALUE (link
)));
8055 add_AT_flag (type_die
, DW_AT_declaration
, 1);
8059 /* Generate a DIE to represent either a real live formal parameter decl or to
8060 represent just the type of some formal parameter position in some function
8063 Note that this routine is a bit unusual because its argument may be a
8064 ..._DECL node (i.e. either a PARM_DECL or perhaps a VAR_DECL which
8065 represents an inlining of some PARM_DECL) or else some sort of a ..._TYPE
8066 node. If it's the former then this function is being called to output a
8067 DIE to represent a formal parameter object (or some inlining thereof). If
8068 it's the latter, then this function is only being called to output a
8069 DW_TAG_formal_parameter DIE to stand as a placeholder for some formal
8070 argument type of some subprogram type. */
8073 gen_formal_parameter_die (node
, context_die
)
8075 register dw_die_ref context_die
;
8077 register dw_die_ref parm_die
8078 = new_die (DW_TAG_formal_parameter
, context_die
);
8079 register tree origin
;
8081 switch (TREE_CODE_CLASS (TREE_CODE (node
)))
8084 origin
= decl_ultimate_origin (node
);
8086 add_abstract_origin_attribute (parm_die
, origin
);
8089 add_name_and_src_coords_attributes (parm_die
, node
);
8090 add_type_attribute (parm_die
, TREE_TYPE (node
),
8091 TREE_READONLY (node
),
8092 TREE_THIS_VOLATILE (node
),
8094 if (DECL_ARTIFICIAL (node
))
8095 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
8098 equate_decl_number_to_die (node
, parm_die
);
8099 if (! DECL_ABSTRACT (node
))
8100 add_location_or_const_value_attribute (parm_die
, node
);
8105 /* We were called with some kind of a ..._TYPE node. */
8106 add_type_attribute (parm_die
, node
, 0, 0, context_die
);
8116 /* Generate a special type of DIE used as a stand-in for a trailing ellipsis
8117 at the end of an (ANSI prototyped) formal parameters list. */
8120 gen_unspecified_parameters_die (decl_or_type
, context_die
)
8121 register tree decl_or_type ATTRIBUTE_UNUSED
;
8122 register dw_die_ref context_die
;
8124 new_die (DW_TAG_unspecified_parameters
, context_die
);
8127 /* Generate a list of nameless DW_TAG_formal_parameter DIEs (and perhaps a
8128 DW_TAG_unspecified_parameters DIE) to represent the types of the formal
8129 parameters as specified in some function type specification (except for
8130 those which appear as part of a function *definition*).
8132 Note we must be careful here to output all of the parameter DIEs before*
8133 we output any DIEs needed to represent the types of the formal parameters.
8134 This keeps svr4 SDB happy because it (incorrectly) thinks that the first
8135 non-parameter DIE it sees ends the formal parameter list. */
8138 gen_formal_types_die (function_or_method_type
, context_die
)
8139 register tree function_or_method_type
;
8140 register dw_die_ref context_die
;
8143 register tree formal_type
= NULL
;
8144 register tree first_parm_type
= TYPE_ARG_TYPES (function_or_method_type
);
8147 /* In the case where we are generating a formal types list for a C++
8148 non-static member function type, skip over the first thing on the
8149 TYPE_ARG_TYPES list because it only represents the type of the hidden
8150 `this pointer'. The debugger should be able to figure out (without
8151 being explicitly told) that this non-static member function type takes a
8152 `this pointer' and should be able to figure what the type of that hidden
8153 parameter is from the DW_AT_member attribute of the parent
8154 DW_TAG_subroutine_type DIE. */
8155 if (TREE_CODE (function_or_method_type
) == METHOD_TYPE
)
8156 first_parm_type
= TREE_CHAIN (first_parm_type
);
8159 /* Make our first pass over the list of formal parameter types and output a
8160 DW_TAG_formal_parameter DIE for each one. */
8161 for (link
= first_parm_type
; link
; link
= TREE_CHAIN (link
))
8163 register dw_die_ref parm_die
;
8165 formal_type
= TREE_VALUE (link
);
8166 if (formal_type
== void_type_node
)
8169 /* Output a (nameless) DIE to represent the formal parameter itself. */
8170 parm_die
= gen_formal_parameter_die (formal_type
, context_die
);
8171 if (TREE_CODE (function_or_method_type
) == METHOD_TYPE
8172 && link
== first_parm_type
)
8173 add_AT_flag (parm_die
, DW_AT_artificial
, 1);
8176 /* If this function type has an ellipsis, add a
8177 DW_TAG_unspecified_parameters DIE to the end of the parameter list. */
8178 if (formal_type
!= void_type_node
)
8179 gen_unspecified_parameters_die (function_or_method_type
, context_die
);
8181 /* Make our second (and final) pass over the list of formal parameter types
8182 and output DIEs to represent those types (as necessary). */
8183 for (link
= TYPE_ARG_TYPES (function_or_method_type
);
8185 link
= TREE_CHAIN (link
))
8187 formal_type
= TREE_VALUE (link
);
8188 if (formal_type
== void_type_node
)
8191 gen_type_die (formal_type
, context_die
);
8195 /* Generate a DIE to represent a declared function (either file-scope or
8199 gen_subprogram_die (decl
, context_die
)
8201 register dw_die_ref context_die
;
8203 char label_id
[MAX_ARTIFICIAL_LABEL_BYTES
];
8204 register tree origin
= decl_ultimate_origin (decl
);
8205 register dw_die_ref subr_die
;
8206 register rtx fp_reg
;
8207 register tree fn_arg_types
;
8208 register tree outer_scope
;
8209 register dw_die_ref old_die
= lookup_decl_die (decl
);
8210 register int declaration
8211 = (current_function_decl
!= decl
8213 && (context_die
->die_tag
== DW_TAG_structure_type
8214 || context_die
->die_tag
== DW_TAG_union_type
)));
8218 subr_die
= new_die (DW_TAG_subprogram
, context_die
);
8219 add_abstract_origin_attribute (subr_die
, origin
);
8221 else if (old_die
&& DECL_ABSTRACT (decl
)
8222 && get_AT_unsigned (old_die
, DW_AT_inline
))
8224 /* This must be a redefinition of an extern inline function.
8225 We can just reuse the old die here. */
8228 /* Clear out the inlined attribute and parm types. */
8229 remove_AT (subr_die
, DW_AT_inline
);
8230 remove_children (subr_die
);
8234 register unsigned file_index
8235 = lookup_filename (DECL_SOURCE_FILE (decl
));
8237 if (get_AT_flag (old_die
, DW_AT_declaration
) != 1)
8239 /* ??? This can happen if there is a bug in the program, for
8240 instance, if it has duplicate function definitions. Ideally,
8241 we should detect this case and ignore it. For now, if we have
8242 already reported an error, any error at all, then assume that
8243 we got here because of a input error, not a dwarf2 bug. */
8249 /* If the definition comes from the same place as the declaration,
8250 maybe use the old DIE. We always want the DIE for this function
8251 that has the *_pc attributes to be under comp_unit_die so the
8252 debugger can find it. For inlines, that is the concrete instance,
8253 so we can use the old DIE here. For non-inline methods, we want a
8254 specification DIE at toplevel, so we need a new DIE. For local
8255 class methods, this doesn't apply; we just use the old DIE. */
8256 if ((DECL_ABSTRACT (decl
) || old_die
->die_parent
== comp_unit_die
8257 || context_die
== NULL
)
8258 && (DECL_ARTIFICIAL (decl
)
8259 || (get_AT_unsigned (old_die
, DW_AT_decl_file
) == file_index
8260 && (get_AT_unsigned (old_die
, DW_AT_decl_line
)
8261 == (unsigned)DECL_SOURCE_LINE (decl
)))))
8265 /* Clear out the declaration attribute and the parm types. */
8266 remove_AT (subr_die
, DW_AT_declaration
);
8267 remove_children (subr_die
);
8271 subr_die
= new_die (DW_TAG_subprogram
, context_die
);
8272 add_AT_die_ref (subr_die
, DW_AT_specification
, old_die
);
8273 if (get_AT_unsigned (old_die
, DW_AT_decl_file
) != file_index
)
8274 add_AT_unsigned (subr_die
, DW_AT_decl_file
, file_index
);
8275 if (get_AT_unsigned (old_die
, DW_AT_decl_line
)
8276 != (unsigned)DECL_SOURCE_LINE (decl
))
8278 (subr_die
, DW_AT_decl_line
, DECL_SOURCE_LINE (decl
));
8283 register dw_die_ref scope_die
;
8285 if (DECL_CONTEXT (decl
))
8286 scope_die
= scope_die_for (decl
, context_die
);
8288 /* Don't put block extern declarations under comp_unit_die. */
8289 scope_die
= context_die
;
8291 subr_die
= new_die (DW_TAG_subprogram
, scope_die
);
8293 if (TREE_PUBLIC (decl
))
8294 add_AT_flag (subr_die
, DW_AT_external
, 1);
8296 add_name_and_src_coords_attributes (subr_die
, decl
);
8297 if (debug_info_level
> DINFO_LEVEL_TERSE
)
8299 register tree type
= TREE_TYPE (decl
);
8301 add_prototyped_attribute (subr_die
, type
);
8302 add_type_attribute (subr_die
, TREE_TYPE (type
), 0, 0, context_die
);
8305 add_pure_or_virtual_attribute (subr_die
, decl
);
8306 if (DECL_ARTIFICIAL (decl
))
8307 add_AT_flag (subr_die
, DW_AT_artificial
, 1);
8308 if (TREE_PROTECTED (decl
))
8309 add_AT_unsigned (subr_die
, DW_AT_accessibility
, DW_ACCESS_protected
);
8310 else if (TREE_PRIVATE (decl
))
8311 add_AT_unsigned (subr_die
, DW_AT_accessibility
, DW_ACCESS_private
);
8316 add_AT_flag (subr_die
, DW_AT_declaration
, 1);
8318 /* The first time we see a member function, it is in the context of
8319 the class to which it belongs. We make sure of this by emitting
8320 the class first. The next time is the definition, which is
8321 handled above. The two may come from the same source text. */
8322 if (DECL_CONTEXT (decl
))
8323 equate_decl_number_to_die (decl
, subr_die
);
8325 else if (DECL_ABSTRACT (decl
))
8327 /* ??? Checking DECL_DEFER_OUTPUT is correct for static inline functions,
8328 but not for extern inline functions. We can't get this completely
8329 correct because information about whether the function was declared
8330 inline is not saved anywhere. */
8331 if (DECL_DEFER_OUTPUT (decl
))
8333 if (DECL_INLINE (decl
) && !flag_no_inline
)
8334 add_AT_unsigned (subr_die
, DW_AT_inline
, DW_INL_declared_inlined
);
8336 add_AT_unsigned (subr_die
, DW_AT_inline
,
8337 DW_INL_declared_not_inlined
);
8339 else if (DECL_INLINE (decl
) && !flag_no_inline
)
8340 add_AT_unsigned (subr_die
, DW_AT_inline
, DW_INL_inlined
);
8344 equate_decl_number_to_die (decl
, subr_die
);
8346 else if (!DECL_EXTERNAL (decl
))
8348 if (origin
== NULL_TREE
)
8349 equate_decl_number_to_die (decl
, subr_die
);
8351 ASM_GENERATE_INTERNAL_LABEL (label_id
, FUNC_BEGIN_LABEL
,
8352 current_funcdef_number
);
8353 add_AT_lbl_id (subr_die
, DW_AT_low_pc
, label_id
);
8354 ASM_GENERATE_INTERNAL_LABEL (label_id
, FUNC_END_LABEL
,
8355 current_funcdef_number
);
8356 add_AT_lbl_id (subr_die
, DW_AT_high_pc
, label_id
);
8358 add_pubname (decl
, subr_die
);
8359 add_arange (decl
, subr_die
);
8361 #ifdef MIPS_DEBUGGING_INFO
8362 /* Add a reference to the FDE for this routine. */
8363 add_AT_fde_ref (subr_die
, DW_AT_MIPS_fde
, current_funcdef_fde
);
8366 /* Define the "frame base" location for this routine. We use the
8367 frame pointer or stack pointer registers, since the RTL for local
8368 variables is relative to one of them. */
8370 = frame_pointer_needed
? hard_frame_pointer_rtx
: stack_pointer_rtx
;
8371 add_AT_loc (subr_die
, DW_AT_frame_base
, reg_loc_descriptor (fp_reg
));
8374 /* ??? This fails for nested inline functions, because context_display
8375 is not part of the state saved/restored for inline functions. */
8376 if (current_function_needs_context
)
8377 add_AT_location_description (subr_die
, DW_AT_static_link
,
8378 lookup_static_chain (decl
));
8382 /* Now output descriptions of the arguments for this function. This gets
8383 (unnecessarily?) complex because of the fact that the DECL_ARGUMENT list
8384 for a FUNCTION_DECL doesn't indicate cases where there was a trailing
8385 `...' at the end of the formal parameter list. In order to find out if
8386 there was a trailing ellipsis or not, we must instead look at the type
8387 associated with the FUNCTION_DECL. This will be a node of type
8388 FUNCTION_TYPE. If the chain of type nodes hanging off of this
8389 FUNCTION_TYPE node ends with a void_type_node then there should *not* be
8390 an ellipsis at the end. */
8391 push_decl_scope (decl
);
8393 /* In the case where we are describing a mere function declaration, all we
8394 need to do here (and all we *can* do here) is to describe the *types* of
8395 its formal parameters. */
8396 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
8398 else if (declaration
)
8399 gen_formal_types_die (TREE_TYPE (decl
), subr_die
);
8402 /* Generate DIEs to represent all known formal parameters */
8403 register tree arg_decls
= DECL_ARGUMENTS (decl
);
8406 /* When generating DIEs, generate the unspecified_parameters DIE
8407 instead if we come across the arg "__builtin_va_alist" */
8408 for (parm
= arg_decls
; parm
; parm
= TREE_CHAIN (parm
))
8409 if (TREE_CODE (parm
) == PARM_DECL
)
8411 if (DECL_NAME (parm
)
8412 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (parm
)),
8413 "__builtin_va_alist"))
8414 gen_unspecified_parameters_die (parm
, subr_die
);
8416 gen_decl_die (parm
, subr_die
);
8419 /* Decide whether we need a unspecified_parameters DIE at the end.
8420 There are 2 more cases to do this for: 1) the ansi ... declaration -
8421 this is detectable when the end of the arg list is not a
8422 void_type_node 2) an unprototyped function declaration (not a
8423 definition). This just means that we have no info about the
8424 parameters at all. */
8425 fn_arg_types
= TYPE_ARG_TYPES (TREE_TYPE (decl
));
8426 if (fn_arg_types
!= NULL
)
8428 /* this is the prototyped case, check for ... */
8429 if (TREE_VALUE (tree_last (fn_arg_types
)) != void_type_node
)
8430 gen_unspecified_parameters_die (decl
, subr_die
);
8432 else if (DECL_INITIAL (decl
) == NULL_TREE
)
8433 gen_unspecified_parameters_die (decl
, subr_die
);
8436 /* Output Dwarf info for all of the stuff within the body of the function
8437 (if it has one - it may be just a declaration). */
8438 outer_scope
= DECL_INITIAL (decl
);
8440 /* Note that here, `outer_scope' is a pointer to the outermost BLOCK
8441 node created to represent a function. This outermost BLOCK actually
8442 represents the outermost binding contour for the function, i.e. the
8443 contour in which the function's formal parameters and labels get
8444 declared. Curiously, it appears that the front end doesn't actually
8445 put the PARM_DECL nodes for the current function onto the BLOCK_VARS
8446 list for this outer scope. (They are strung off of the DECL_ARGUMENTS
8447 list for the function instead.) The BLOCK_VARS list for the
8448 `outer_scope' does provide us with a list of the LABEL_DECL nodes for
8449 the function however, and we output DWARF info for those in
8450 decls_for_scope. Just within the `outer_scope' there will be a BLOCK
8451 node representing the function's outermost pair of curly braces, and
8452 any blocks used for the base and member initializers of a C++
8453 constructor function. */
8454 if (! declaration
&& TREE_CODE (outer_scope
) != ERROR_MARK
)
8456 current_function_has_inlines
= 0;
8457 decls_for_scope (outer_scope
, subr_die
, 0);
8459 #if 0 && defined (MIPS_DEBUGGING_INFO)
8460 if (current_function_has_inlines
)
8462 add_AT_flag (subr_die
, DW_AT_MIPS_has_inlines
, 1);
8463 if (! comp_unit_has_inlines
)
8465 add_AT_flag (comp_unit_die
, DW_AT_MIPS_has_inlines
, 1);
8466 comp_unit_has_inlines
= 1;
8475 /* Generate a DIE to represent a declared data object. */
8478 gen_variable_die (decl
, context_die
)
8480 register dw_die_ref context_die
;
8482 register tree origin
= decl_ultimate_origin (decl
);
8483 register dw_die_ref var_die
= new_die (DW_TAG_variable
, context_die
);
8485 dw_die_ref old_die
= lookup_decl_die (decl
);
8487 = (DECL_EXTERNAL (decl
)
8488 || current_function_decl
!= decl_function_context (decl
)
8489 || context_die
->die_tag
== DW_TAG_structure_type
8490 || context_die
->die_tag
== DW_TAG_union_type
);
8493 add_abstract_origin_attribute (var_die
, origin
);
8494 /* Loop unrolling can create multiple blocks that refer to the same
8495 static variable, so we must test for the DW_AT_declaration flag. */
8496 /* ??? Loop unrolling/reorder_blocks should perhaps be rewritten to
8497 copy decls and set the DECL_ABSTRACT flag on them instead of
8499 else if (old_die
&& TREE_STATIC (decl
)
8500 && get_AT_flag (old_die
, DW_AT_declaration
) == 1)
8502 /* This is a definition of a C++ class level static. */
8503 add_AT_die_ref (var_die
, DW_AT_specification
, old_die
);
8504 if (DECL_NAME (decl
))
8506 register unsigned file_index
8507 = lookup_filename (DECL_SOURCE_FILE (decl
));
8509 if (get_AT_unsigned (old_die
, DW_AT_decl_file
) != file_index
)
8510 add_AT_unsigned (var_die
, DW_AT_decl_file
, file_index
);
8512 if (get_AT_unsigned (old_die
, DW_AT_decl_line
)
8513 != (unsigned)DECL_SOURCE_LINE (decl
))
8515 add_AT_unsigned (var_die
, DW_AT_decl_line
,
8516 DECL_SOURCE_LINE (decl
));
8521 add_name_and_src_coords_attributes (var_die
, decl
);
8522 add_type_attribute (var_die
, TREE_TYPE (decl
),
8523 TREE_READONLY (decl
),
8524 TREE_THIS_VOLATILE (decl
), context_die
);
8526 if (TREE_PUBLIC (decl
))
8527 add_AT_flag (var_die
, DW_AT_external
, 1);
8529 if (DECL_ARTIFICIAL (decl
))
8530 add_AT_flag (var_die
, DW_AT_artificial
, 1);
8532 if (TREE_PROTECTED (decl
))
8533 add_AT_unsigned (var_die
, DW_AT_accessibility
, DW_ACCESS_protected
);
8535 else if (TREE_PRIVATE (decl
))
8536 add_AT_unsigned (var_die
, DW_AT_accessibility
, DW_ACCESS_private
);
8540 add_AT_flag (var_die
, DW_AT_declaration
, 1);
8542 if ((declaration
&& decl_class_context (decl
)) || DECL_ABSTRACT (decl
))
8543 equate_decl_number_to_die (decl
, var_die
);
8545 if (! declaration
&& ! DECL_ABSTRACT (decl
))
8547 equate_decl_number_to_die (decl
, var_die
);
8548 add_location_or_const_value_attribute (var_die
, decl
);
8549 add_pubname (decl
, var_die
);
8553 /* Generate a DIE to represent a label identifier. */
8556 gen_label_die (decl
, context_die
)
8558 register dw_die_ref context_die
;
8560 register tree origin
= decl_ultimate_origin (decl
);
8561 register dw_die_ref lbl_die
= new_die (DW_TAG_label
, context_die
);
8563 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
8564 char label2
[MAX_ARTIFICIAL_LABEL_BYTES
];
8567 add_abstract_origin_attribute (lbl_die
, origin
);
8569 add_name_and_src_coords_attributes (lbl_die
, decl
);
8571 if (DECL_ABSTRACT (decl
))
8572 equate_decl_number_to_die (decl
, lbl_die
);
8575 insn
= DECL_RTL (decl
);
8577 /* Deleted labels are programmer specified labels which have been
8578 eliminated because of various optimisations. We still emit them
8579 here so that it is possible to put breakpoints on them. */
8580 if (GET_CODE (insn
) == CODE_LABEL
8581 || ((GET_CODE (insn
) == NOTE
8582 && NOTE_LINE_NUMBER (insn
) == NOTE_INSN_DELETED_LABEL
)))
8584 /* When optimization is enabled (via -O) some parts of the compiler
8585 (e.g. jump.c and cse.c) may try to delete CODE_LABEL insns which
8586 represent source-level labels which were explicitly declared by
8587 the user. This really shouldn't be happening though, so catch
8588 it if it ever does happen. */
8589 if (INSN_DELETED_P (insn
))
8592 sprintf (label2
, INSN_LABEL_FMT
, current_funcdef_number
);
8593 ASM_GENERATE_INTERNAL_LABEL (label
, label2
,
8594 (unsigned) INSN_UID (insn
));
8595 add_AT_lbl_id (lbl_die
, DW_AT_low_pc
, label
);
8600 /* Generate a DIE for a lexical block. */
8603 gen_lexical_block_die (stmt
, context_die
, depth
)
8605 register dw_die_ref context_die
;
8608 register dw_die_ref stmt_die
= new_die (DW_TAG_lexical_block
, context_die
);
8609 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
8611 if (! BLOCK_ABSTRACT (stmt
))
8613 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_BEGIN_LABEL
,
8615 add_AT_lbl_id (stmt_die
, DW_AT_low_pc
, label
);
8616 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_END_LABEL
, next_block_number
);
8617 add_AT_lbl_id (stmt_die
, DW_AT_high_pc
, label
);
8620 push_decl_scope (stmt
);
8621 decls_for_scope (stmt
, stmt_die
, depth
);
8625 /* Generate a DIE for an inlined subprogram. */
8628 gen_inlined_subroutine_die (stmt
, context_die
, depth
)
8630 register dw_die_ref context_die
;
8633 if (! BLOCK_ABSTRACT (stmt
))
8635 register dw_die_ref subr_die
8636 = new_die (DW_TAG_inlined_subroutine
, context_die
);
8637 register tree decl
= block_ultimate_origin (stmt
);
8638 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
8640 add_abstract_origin_attribute (subr_die
, decl
);
8641 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_BEGIN_LABEL
,
8643 add_AT_lbl_id (subr_die
, DW_AT_low_pc
, label
);
8644 ASM_GENERATE_INTERNAL_LABEL (label
, BLOCK_END_LABEL
, next_block_number
);
8645 add_AT_lbl_id (subr_die
, DW_AT_high_pc
, label
);
8646 push_decl_scope (decl
);
8647 decls_for_scope (stmt
, subr_die
, depth
);
8649 current_function_has_inlines
= 1;
8653 /* Generate a DIE for a field in a record, or structure. */
8656 gen_field_die (decl
, context_die
)
8658 register dw_die_ref context_die
;
8660 register dw_die_ref decl_die
= new_die (DW_TAG_member
, context_die
);
8662 add_name_and_src_coords_attributes (decl_die
, decl
);
8663 add_type_attribute (decl_die
, member_declared_type (decl
),
8664 TREE_READONLY (decl
), TREE_THIS_VOLATILE (decl
),
8667 /* If this is a bit field... */
8668 if (DECL_BIT_FIELD_TYPE (decl
))
8670 add_byte_size_attribute (decl_die
, decl
);
8671 add_bit_size_attribute (decl_die
, decl
);
8672 add_bit_offset_attribute (decl_die
, decl
);
8675 if (TREE_CODE (DECL_FIELD_CONTEXT (decl
)) != UNION_TYPE
)
8676 add_data_member_location_attribute (decl_die
, decl
);
8678 if (DECL_ARTIFICIAL (decl
))
8679 add_AT_flag (decl_die
, DW_AT_artificial
, 1);
8681 if (TREE_PROTECTED (decl
))
8682 add_AT_unsigned (decl_die
, DW_AT_accessibility
, DW_ACCESS_protected
);
8684 else if (TREE_PRIVATE (decl
))
8685 add_AT_unsigned (decl_die
, DW_AT_accessibility
, DW_ACCESS_private
);
8689 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
8690 Use modified_type_die instead.
8691 We keep this code here just in case these types of DIEs may be needed to
8692 represent certain things in other languages (e.g. Pascal) someday. */
8694 gen_pointer_type_die (type
, context_die
)
8696 register dw_die_ref context_die
;
8698 register dw_die_ref ptr_die
8699 = new_die (DW_TAG_pointer_type
, scope_die_for (type
, context_die
));
8701 equate_type_number_to_die (type
, ptr_die
);
8702 add_type_attribute (ptr_die
, TREE_TYPE (type
), 0, 0, context_die
);
8703 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
, PTR_SIZE
);
8706 /* Don't generate either pointer_type DIEs or reference_type DIEs here.
8707 Use modified_type_die instead.
8708 We keep this code here just in case these types of DIEs may be needed to
8709 represent certain things in other languages (e.g. Pascal) someday. */
8711 gen_reference_type_die (type
, context_die
)
8713 register dw_die_ref context_die
;
8715 register dw_die_ref ref_die
8716 = new_die (DW_TAG_reference_type
, scope_die_for (type
, context_die
));
8718 equate_type_number_to_die (type
, ref_die
);
8719 add_type_attribute (ref_die
, TREE_TYPE (type
), 0, 0, context_die
);
8720 add_AT_unsigned (mod_type_die
, DW_AT_byte_size
, PTR_SIZE
);
8724 /* Generate a DIE for a pointer to a member type. */
8726 gen_ptr_to_mbr_type_die (type
, context_die
)
8728 register dw_die_ref context_die
;
8730 register dw_die_ref ptr_die
8731 = new_die (DW_TAG_ptr_to_member_type
, scope_die_for (type
, context_die
));
8733 equate_type_number_to_die (type
, ptr_die
);
8734 add_AT_die_ref (ptr_die
, DW_AT_containing_type
,
8735 lookup_type_die (TYPE_OFFSET_BASETYPE (type
)));
8736 add_type_attribute (ptr_die
, TREE_TYPE (type
), 0, 0, context_die
);
8739 /* Generate the DIE for the compilation unit. */
8742 gen_compile_unit_die (filename
)
8743 register const char *filename
;
8745 register dw_die_ref die
;
8747 char *wd
= getpwd ();
8750 die
= new_die (DW_TAG_compile_unit
, NULL
);
8751 add_name_attribute (die
, filename
);
8753 if (wd
!= NULL
&& filename
[0] != DIR_SEPARATOR
)
8754 add_AT_string (die
, DW_AT_comp_dir
, wd
);
8756 sprintf (producer
, "%s %s", language_string
, version_string
);
8758 #ifdef MIPS_DEBUGGING_INFO
8759 /* The MIPS/SGI compilers place the 'cc' command line options in the producer
8760 string. The SGI debugger looks for -g, -g1, -g2, or -g3; if they do
8761 not appear in the producer string, the debugger reaches the conclusion
8762 that the object file is stripped and has no debugging information.
8763 To get the MIPS/SGI debugger to believe that there is debugging
8764 information in the object file, we add a -g to the producer string. */
8765 if (debug_info_level
> DINFO_LEVEL_TERSE
)
8766 strcat (producer
, " -g");
8769 add_AT_string (die
, DW_AT_producer
, producer
);
8771 if (strcmp (language_string
, "GNU C++") == 0)
8772 language
= DW_LANG_C_plus_plus
;
8773 else if (strcmp (language_string
, "GNU Ada") == 0)
8774 language
= DW_LANG_Ada83
;
8775 else if (strcmp (language_string
, "GNU F77") == 0)
8776 language
= DW_LANG_Fortran77
;
8777 else if (strcmp (language_string
, "GNU Pascal") == 0)
8778 language
= DW_LANG_Pascal83
;
8779 else if (flag_traditional
)
8780 language
= DW_LANG_C
;
8782 language
= DW_LANG_C89
;
8784 add_AT_unsigned (die
, DW_AT_language
, language
);
8789 /* Generate a DIE for a string type. */
8792 gen_string_type_die (type
, context_die
)
8794 register dw_die_ref context_die
;
8796 register dw_die_ref type_die
8797 = new_die (DW_TAG_string_type
, scope_die_for (type
, context_die
));
8799 equate_type_number_to_die (type
, type_die
);
8801 /* Fudge the string length attribute for now. */
8803 /* TODO: add string length info.
8804 string_length_attribute (TYPE_MAX_VALUE (TYPE_DOMAIN (type)));
8805 bound_representation (upper_bound, 0, 'u'); */
8808 /* Generate the DIE for a base class. */
8811 gen_inheritance_die (binfo
, context_die
)
8812 register tree binfo
;
8813 register dw_die_ref context_die
;
8815 dw_die_ref die
= new_die (DW_TAG_inheritance
, context_die
);
8817 add_type_attribute (die
, BINFO_TYPE (binfo
), 0, 0, context_die
);
8818 add_data_member_location_attribute (die
, binfo
);
8820 if (TREE_VIA_VIRTUAL (binfo
))
8821 add_AT_unsigned (die
, DW_AT_virtuality
, DW_VIRTUALITY_virtual
);
8822 if (TREE_VIA_PUBLIC (binfo
))
8823 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_public
);
8824 else if (TREE_VIA_PROTECTED (binfo
))
8825 add_AT_unsigned (die
, DW_AT_accessibility
, DW_ACCESS_protected
);
8828 /* Generate a DIE for a class member. */
8831 gen_member_die (type
, context_die
)
8833 register dw_die_ref context_die
;
8835 register tree member
;
8837 /* If this is not an incomplete type, output descriptions of each of its
8838 members. Note that as we output the DIEs necessary to represent the
8839 members of this record or union type, we will also be trying to output
8840 DIEs to represent the *types* of those members. However the `type'
8841 function (above) will specifically avoid generating type DIEs for member
8842 types *within* the list of member DIEs for this (containing) type execpt
8843 for those types (of members) which are explicitly marked as also being
8844 members of this (containing) type themselves. The g++ front- end can
8845 force any given type to be treated as a member of some other
8846 (containing) type by setting the TYPE_CONTEXT of the given (member) type
8847 to point to the TREE node representing the appropriate (containing)
8850 /* First output info about the base classes. */
8851 if (TYPE_BINFO (type
) && TYPE_BINFO_BASETYPES (type
))
8853 register tree bases
= TYPE_BINFO_BASETYPES (type
);
8854 register int n_bases
= TREE_VEC_LENGTH (bases
);
8857 for (i
= 0; i
< n_bases
; i
++)
8858 gen_inheritance_die (TREE_VEC_ELT (bases
, i
), context_die
);
8861 /* Now output info about the data members and type members. */
8862 for (member
= TYPE_FIELDS (type
); member
; member
= TREE_CHAIN (member
))
8863 gen_decl_die (member
, context_die
);
8865 /* Now output info about the function members (if any). */
8866 for (member
= TYPE_METHODS (type
); member
; member
= TREE_CHAIN (member
))
8867 gen_decl_die (member
, context_die
);
8870 /* Generate a DIE for a structure or union type. */
8873 gen_struct_or_union_type_die (type
, context_die
)
8875 register dw_die_ref context_die
;
8877 register dw_die_ref type_die
= lookup_type_die (type
);
8878 register dw_die_ref scope_die
= 0;
8879 register int nested
= 0;
8881 if (type_die
&& ! TYPE_SIZE (type
))
8884 if (TYPE_CONTEXT (type
) != NULL_TREE
8885 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type
)))
8888 scope_die
= scope_die_for (type
, context_die
);
8890 if (! type_die
|| (nested
&& scope_die
== comp_unit_die
))
8891 /* First occurrence of type or toplevel definition of nested class. */
8893 register dw_die_ref old_die
= type_die
;
8895 type_die
= new_die (TREE_CODE (type
) == RECORD_TYPE
8896 ? DW_TAG_structure_type
: DW_TAG_union_type
,
8898 equate_type_number_to_die (type
, type_die
);
8899 add_name_attribute (type_die
, type_tag (type
));
8901 add_AT_die_ref (type_die
, DW_AT_specification
, old_die
);
8904 remove_AT (type_die
, DW_AT_declaration
);
8906 /* If we're not in the right context to be defining this type, defer to
8907 avoid tricky recursion. */
8908 if (TYPE_SIZE (type
) && decl_scope_depth
> 0 && scope_die
== comp_unit_die
)
8910 add_AT_flag (type_die
, DW_AT_declaration
, 1);
8913 /* If this type has been completed, then give it a byte_size attribute and
8914 then give a list of members. */
8915 else if (TYPE_SIZE (type
))
8917 /* Prevent infinite recursion in cases where the type of some member of
8918 this type is expressed in terms of this type itself. */
8919 TREE_ASM_WRITTEN (type
) = 1;
8920 add_byte_size_attribute (type_die
, type
);
8921 if (TYPE_STUB_DECL (type
) != NULL_TREE
)
8922 add_src_coords_attributes (type_die
, TYPE_STUB_DECL (type
));
8924 /* If the first reference to this type was as the return type of an
8925 inline function, then it may not have a parent. Fix this now. */
8926 if (type_die
->die_parent
== NULL
)
8927 add_child_die (scope_die
, type_die
);
8929 push_decl_scope (type
);
8930 gen_member_die (type
, type_die
);
8933 /* GNU extension: Record what type our vtable lives in. */
8934 if (TYPE_VFIELD (type
))
8936 tree vtype
= DECL_FCONTEXT (TYPE_VFIELD (type
));
8940 gen_type_die (vtype
, context_die
);
8941 add_AT_die_ref (type_die
, DW_AT_containing_type
,
8942 lookup_type_die (vtype
));
8948 add_AT_flag (type_die
, DW_AT_declaration
, 1);
8950 /* We can't do this for function-local types, and we don't need to. */
8951 if (! decl_function_context (TYPE_STUB_DECL (type
)))
8952 add_incomplete_type (type
);
8956 /* Generate a DIE for a subroutine _type_. */
8959 gen_subroutine_type_die (type
, context_die
)
8961 register dw_die_ref context_die
;
8963 register tree return_type
= TREE_TYPE (type
);
8964 register dw_die_ref subr_die
8965 = new_die (DW_TAG_subroutine_type
, scope_die_for (type
, context_die
));
8967 equate_type_number_to_die (type
, subr_die
);
8968 add_prototyped_attribute (subr_die
, type
);
8969 add_type_attribute (subr_die
, return_type
, 0, 0, context_die
);
8970 gen_formal_types_die (type
, subr_die
);
8973 /* Generate a DIE for a type definition */
8976 gen_typedef_die (decl
, context_die
)
8978 register dw_die_ref context_die
;
8980 register dw_die_ref type_die
;
8981 register tree origin
;
8983 if (TREE_ASM_WRITTEN (decl
))
8985 TREE_ASM_WRITTEN (decl
) = 1;
8987 type_die
= new_die (DW_TAG_typedef
, scope_die_for (decl
, context_die
));
8988 origin
= decl_ultimate_origin (decl
);
8990 add_abstract_origin_attribute (type_die
, origin
);
8994 add_name_and_src_coords_attributes (type_die
, decl
);
8995 if (DECL_ORIGINAL_TYPE (decl
))
8997 type
= DECL_ORIGINAL_TYPE (decl
);
8998 equate_type_number_to_die (TREE_TYPE (decl
), type_die
);
9001 type
= TREE_TYPE (decl
);
9002 add_type_attribute (type_die
, type
, TREE_READONLY (decl
),
9003 TREE_THIS_VOLATILE (decl
), context_die
);
9006 if (DECL_ABSTRACT (decl
))
9007 equate_decl_number_to_die (decl
, type_die
);
9010 /* Generate a type description DIE. */
9013 gen_type_die (type
, context_die
)
9015 register dw_die_ref context_die
;
9019 if (type
== NULL_TREE
|| type
== error_mark_node
)
9022 /* We are going to output a DIE to represent the unqualified version of
9023 this type (i.e. without any const or volatile qualifiers) so get the
9024 main variant (i.e. the unqualified version) of this type now. */
9025 type
= type_main_variant (type
);
9027 if (TREE_ASM_WRITTEN (type
))
9030 if (TYPE_NAME (type
) && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
9031 && DECL_ORIGINAL_TYPE (TYPE_NAME (type
)))
9033 TREE_ASM_WRITTEN (type
) = 1;
9034 gen_decl_die (TYPE_NAME (type
), context_die
);
9038 switch (TREE_CODE (type
))
9044 case REFERENCE_TYPE
:
9045 /* We must set TREE_ASM_WRITTEN in case this is a recursive type. This
9046 ensures that the gen_type_die recursion will terminate even if the
9047 type is recursive. Recursive types are possible in Ada. */
9048 /* ??? We could perhaps do this for all types before the switch
9050 TREE_ASM_WRITTEN (type
) = 1;
9052 /* For these types, all that is required is that we output a DIE (or a
9053 set of DIEs) to represent the "basis" type. */
9054 gen_type_die (TREE_TYPE (type
), context_die
);
9058 /* This code is used for C++ pointer-to-data-member types.
9059 Output a description of the relevant class type. */
9060 gen_type_die (TYPE_OFFSET_BASETYPE (type
), context_die
);
9062 /* Output a description of the type of the object pointed to. */
9063 gen_type_die (TREE_TYPE (type
), context_die
);
9065 /* Now output a DIE to represent this pointer-to-data-member type
9067 gen_ptr_to_mbr_type_die (type
, context_die
);
9071 gen_type_die (TYPE_DOMAIN (type
), context_die
);
9072 gen_set_type_die (type
, context_die
);
9076 gen_type_die (TREE_TYPE (type
), context_die
);
9077 abort (); /* No way to represent these in Dwarf yet! */
9081 /* Force out return type (in case it wasn't forced out already). */
9082 gen_type_die (TREE_TYPE (type
), context_die
);
9083 gen_subroutine_type_die (type
, context_die
);
9087 /* Force out return type (in case it wasn't forced out already). */
9088 gen_type_die (TREE_TYPE (type
), context_die
);
9089 gen_subroutine_type_die (type
, context_die
);
9093 if (TYPE_STRING_FLAG (type
) && TREE_CODE (TREE_TYPE (type
)) == CHAR_TYPE
)
9095 gen_type_die (TREE_TYPE (type
), context_die
);
9096 gen_string_type_die (type
, context_die
);
9099 gen_array_type_die (type
, context_die
);
9105 case QUAL_UNION_TYPE
:
9106 /* If this is a nested type whose containing class hasn't been
9107 written out yet, writing it out will cover this one, too.
9108 This does not apply to instantiations of member class templates;
9109 they need to be added to the containing class as they are
9110 generated. FIXME: This breaks the idea of combining type decls
9111 from multiple TUs, since we can't predict what set of template
9112 instantiations we'll get. */
9113 if (TYPE_CONTEXT (type
)
9114 && AGGREGATE_TYPE_P (TYPE_CONTEXT (type
))
9115 && ! TREE_ASM_WRITTEN (TYPE_CONTEXT (type
)))
9117 gen_type_die (TYPE_CONTEXT (type
), context_die
);
9119 if (TREE_ASM_WRITTEN (type
))
9122 /* If that failed, attach ourselves to the stub. */
9123 push_decl_scope (TYPE_CONTEXT (type
));
9124 context_die
= lookup_type_die (TYPE_CONTEXT (type
));
9130 if (TREE_CODE (type
) == ENUMERAL_TYPE
)
9131 gen_enumeration_type_die (type
, context_die
);
9133 gen_struct_or_union_type_die (type
, context_die
);
9138 /* Don't set TREE_ASM_WRITTEN on an incomplete struct; we want to fix
9139 it up if it is ever completed. gen_*_type_die will set it for us
9140 when appropriate. */
9149 /* No DIEs needed for fundamental types. */
9153 /* No Dwarf representation currently defined. */
9160 TREE_ASM_WRITTEN (type
) = 1;
9163 /* Generate a DIE for a tagged type instantiation. */
9166 gen_tagged_type_instantiation_die (type
, context_die
)
9168 register dw_die_ref context_die
;
9170 if (type
== NULL_TREE
|| type
== error_mark_node
)
9173 /* We are going to output a DIE to represent the unqualified version of
9174 this type (i.e. without any const or volatile qualifiers) so make sure
9175 that we have the main variant (i.e. the unqualified version) of this
9177 if (type
!= type_main_variant (type
))
9180 /* Do not check TREE_ASM_WRITTEN(type) as it may not be set if this is
9181 an instance of an unresolved type. */
9183 switch (TREE_CODE (type
))
9189 gen_inlined_enumeration_type_die (type
, context_die
);
9193 gen_inlined_structure_type_die (type
, context_die
);
9197 case QUAL_UNION_TYPE
:
9198 gen_inlined_union_type_die (type
, context_die
);
9206 /* Generate a DW_TAG_lexical_block DIE followed by DIEs to represent all of the
9207 things which are local to the given block. */
9210 gen_block_die (stmt
, context_die
, depth
)
9212 register dw_die_ref context_die
;
9215 register int must_output_die
= 0;
9216 register tree origin
;
9218 register enum tree_code origin_code
;
9220 /* Ignore blocks never really used to make RTL. */
9222 if (stmt
== NULL_TREE
|| !TREE_USED (stmt
))
9225 /* Determine the "ultimate origin" of this block. This block may be an
9226 inlined instance of an inlined instance of inline function, so we have
9227 to trace all of the way back through the origin chain to find out what
9228 sort of node actually served as the original seed for the creation of
9229 the current block. */
9230 origin
= block_ultimate_origin (stmt
);
9231 origin_code
= (origin
!= NULL
) ? TREE_CODE (origin
) : ERROR_MARK
;
9233 /* Determine if we need to output any Dwarf DIEs at all to represent this
9235 if (origin_code
== FUNCTION_DECL
)
9236 /* The outer scopes for inlinings *must* always be represented. We
9237 generate DW_TAG_inlined_subroutine DIEs for them. (See below.) */
9238 must_output_die
= 1;
9241 /* In the case where the current block represents an inlining of the
9242 "body block" of an inline function, we must *NOT* output any DIE for
9243 this block because we have already output a DIE to represent the
9244 whole inlined function scope and the "body block" of any function
9245 doesn't really represent a different scope according to ANSI C
9246 rules. So we check here to make sure that this block does not
9247 represent a "body block inlining" before trying to set the
9248 `must_output_die' flag. */
9249 if (! is_body_block (origin
? origin
: stmt
))
9251 /* Determine if this block directly contains any "significant"
9252 local declarations which we will need to output DIEs for. */
9253 if (debug_info_level
> DINFO_LEVEL_TERSE
)
9254 /* We are not in terse mode so *any* local declaration counts
9255 as being a "significant" one. */
9256 must_output_die
= (BLOCK_VARS (stmt
) != NULL
);
9258 /* We are in terse mode, so only local (nested) function
9259 definitions count as "significant" local declarations. */
9260 for (decl
= BLOCK_VARS (stmt
);
9261 decl
!= NULL
; decl
= TREE_CHAIN (decl
))
9262 if (TREE_CODE (decl
) == FUNCTION_DECL
9263 && DECL_INITIAL (decl
))
9265 must_output_die
= 1;
9271 /* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
9272 DIE for any block which contains no significant local declarations at
9273 all. Rather, in such cases we just call `decls_for_scope' so that any
9274 needed Dwarf info for any sub-blocks will get properly generated. Note
9275 that in terse mode, our definition of what constitutes a "significant"
9276 local declaration gets restricted to include only inlined function
9277 instances and local (nested) function definitions. */
9278 if (must_output_die
)
9280 if (origin_code
== FUNCTION_DECL
)
9281 gen_inlined_subroutine_die (stmt
, context_die
, depth
);
9283 gen_lexical_block_die (stmt
, context_die
, depth
);
9286 decls_for_scope (stmt
, context_die
, depth
);
9289 /* Generate all of the decls declared within a given scope and (recursively)
9290 all of its sub-blocks. */
9293 decls_for_scope (stmt
, context_die
, depth
)
9295 register dw_die_ref context_die
;
9299 register tree subblocks
;
9301 /* Ignore blocks never really used to make RTL. */
9302 if (stmt
== NULL_TREE
|| ! TREE_USED (stmt
))
9305 if (!BLOCK_ABSTRACT (stmt
) && depth
> 0)
9306 next_block_number
++;
9308 /* Output the DIEs to represent all of the data objects and typedefs
9309 declared directly within this block but not within any nested
9310 sub-blocks. Also, nested function and tag DIEs have been
9311 generated with a parent of NULL; fix that up now. */
9312 for (decl
= BLOCK_VARS (stmt
);
9313 decl
!= NULL
; decl
= TREE_CHAIN (decl
))
9315 register dw_die_ref die
;
9317 if (TREE_CODE (decl
) == FUNCTION_DECL
)
9318 die
= lookup_decl_die (decl
);
9319 else if (TREE_CODE (decl
) == TYPE_DECL
&& TYPE_DECL_IS_STUB (decl
))
9320 die
= lookup_type_die (TREE_TYPE (decl
));
9324 if (die
!= NULL
&& die
->die_parent
== NULL
)
9325 add_child_die (context_die
, die
);
9327 gen_decl_die (decl
, context_die
);
9330 /* Output the DIEs to represent all sub-blocks (and the items declared
9331 therein) of this block. */
9332 for (subblocks
= BLOCK_SUBBLOCKS (stmt
);
9334 subblocks
= BLOCK_CHAIN (subblocks
))
9335 gen_block_die (subblocks
, context_die
, depth
+ 1);
9338 /* Is this a typedef we can avoid emitting? */
9341 is_redundant_typedef (decl
)
9344 if (TYPE_DECL_IS_STUB (decl
))
9347 if (DECL_ARTIFICIAL (decl
)
9348 && DECL_CONTEXT (decl
)
9349 && is_tagged_type (DECL_CONTEXT (decl
))
9350 && TREE_CODE (TYPE_NAME (DECL_CONTEXT (decl
))) == TYPE_DECL
9351 && DECL_NAME (decl
) == DECL_NAME (TYPE_NAME (DECL_CONTEXT (decl
))))
9352 /* Also ignore the artificial member typedef for the class name. */
9358 /* Generate Dwarf debug information for a decl described by DECL. */
9361 gen_decl_die (decl
, context_die
)
9363 register dw_die_ref context_die
;
9365 register tree origin
;
9367 if (TREE_CODE (decl
) == ERROR_MARK
)
9370 /* If this ..._DECL node is marked to be ignored, then ignore it. But don't
9371 ignore a function definition, since that would screw up our count of
9372 blocks, and that in turn will completely screw up the labels we will
9373 reference in subsequent DW_AT_low_pc and DW_AT_high_pc attributes (for
9374 subsequent blocks). */
9375 if (DECL_IGNORED_P (decl
) && TREE_CODE (decl
) != FUNCTION_DECL
)
9378 switch (TREE_CODE (decl
))
9381 /* The individual enumerators of an enum type get output when we output
9382 the Dwarf representation of the relevant enum type itself. */
9386 /* Don't output any DIEs to represent mere function declarations,
9387 unless they are class members or explicit block externs. */
9388 if (DECL_INITIAL (decl
) == NULL_TREE
&& DECL_CONTEXT (decl
) == NULL_TREE
9389 && (current_function_decl
== NULL_TREE
|| ! DECL_ARTIFICIAL (decl
)))
9392 if (debug_info_level
> DINFO_LEVEL_TERSE
)
9394 /* Before we describe the FUNCTION_DECL itself, make sure that we
9395 have described its return type. */
9396 gen_type_die (TREE_TYPE (TREE_TYPE (decl
)), context_die
);
9398 /* And its containing type. */
9399 origin
= decl_class_context (decl
);
9400 if (origin
!= NULL_TREE
)
9401 gen_type_die (origin
, context_die
);
9403 /* And its virtual context. */
9404 if (DECL_VINDEX (decl
) != NULL_TREE
)
9405 gen_type_die (DECL_CONTEXT (decl
), context_die
);
9408 /* Now output a DIE to represent the function itself. */
9409 gen_subprogram_die (decl
, context_die
);
9413 /* If we are in terse mode, don't generate any DIEs to represent any
9415 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
9418 /* In the special case of a TYPE_DECL node representing the
9419 declaration of some type tag, if the given TYPE_DECL is marked as
9420 having been instantiated from some other (original) TYPE_DECL node
9421 (e.g. one which was generated within the original definition of an
9422 inline function) we have to generate a special (abbreviated)
9423 DW_TAG_structure_type, DW_TAG_union_type, or DW_TAG_enumeration_type
9425 if (TYPE_DECL_IS_STUB (decl
) && DECL_ABSTRACT_ORIGIN (decl
) != NULL_TREE
)
9427 gen_tagged_type_instantiation_die (TREE_TYPE (decl
), context_die
);
9431 if (is_redundant_typedef (decl
))
9432 gen_type_die (TREE_TYPE (decl
), context_die
);
9434 /* Output a DIE to represent the typedef itself. */
9435 gen_typedef_die (decl
, context_die
);
9439 if (debug_info_level
>= DINFO_LEVEL_NORMAL
)
9440 gen_label_die (decl
, context_die
);
9444 /* If we are in terse mode, don't generate any DIEs to represent any
9445 variable declarations or definitions. */
9446 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
9449 /* Output any DIEs that are needed to specify the type of this data
9451 gen_type_die (TREE_TYPE (decl
), context_die
);
9453 /* And its containing type. */
9454 origin
= decl_class_context (decl
);
9455 if (origin
!= NULL_TREE
)
9456 gen_type_die (origin
, context_die
);
9458 /* Now output the DIE to represent the data object itself. This gets
9459 complicated because of the possibility that the VAR_DECL really
9460 represents an inlined instance of a formal parameter for an inline
9462 origin
= decl_ultimate_origin (decl
);
9463 if (origin
!= NULL_TREE
&& TREE_CODE (origin
) == PARM_DECL
)
9464 gen_formal_parameter_die (decl
, context_die
);
9466 gen_variable_die (decl
, context_die
);
9470 /* Ignore the nameless fields that are used to skip bits, but
9471 handle C++ anonymous unions. */
9472 if (DECL_NAME (decl
) != NULL_TREE
9473 || TREE_CODE (TREE_TYPE (decl
)) == UNION_TYPE
)
9475 gen_type_die (member_declared_type (decl
), context_die
);
9476 gen_field_die (decl
, context_die
);
9481 gen_type_die (TREE_TYPE (decl
), context_die
);
9482 gen_formal_parameter_die (decl
, context_die
);
9485 case NAMESPACE_DECL
:
9486 /* Ignore for now. */
9494 /* Add Ada "use" clause information for SGI Workshop debugger. */
9497 dwarf2out_add_library_unit_info (filename
, context_list
)
9501 unsigned int file_index
;
9503 if (filename
!= NULL
)
9505 dw_die_ref unit_die
= new_die (DW_TAG_module
, comp_unit_die
);
9506 tree context_list_decl
9507 = build_decl (LABEL_DECL
, get_identifier (context_list
),
9510 TREE_PUBLIC (context_list_decl
) = TRUE
;
9511 add_name_attribute (unit_die
, context_list
);
9512 file_index
= lookup_filename (filename
);
9513 add_AT_unsigned (unit_die
, DW_AT_decl_file
, file_index
);
9514 add_pubname (context_list_decl
, unit_die
);
9518 /* Write the debugging output for DECL. */
9521 dwarf2out_decl (decl
)
9524 register dw_die_ref context_die
= comp_unit_die
;
9526 if (TREE_CODE (decl
) == ERROR_MARK
)
9529 /* If this ..._DECL node is marked to be ignored, then ignore it. We gotta
9530 hope that the node in question doesn't represent a function definition.
9531 If it does, then totally ignoring it is bound to screw up our count of
9532 blocks, and that in turn will completely screw up the labels we will
9533 reference in subsequent DW_AT_low_pc and DW_AT_high_pc attributes (for
9534 subsequent blocks). (It's too bad that BLOCK nodes don't carry their
9535 own sequence numbers with them!) */
9536 if (DECL_IGNORED_P (decl
))
9538 if (TREE_CODE (decl
) == FUNCTION_DECL
9539 && DECL_INITIAL (decl
) != NULL
)
9545 switch (TREE_CODE (decl
))
9548 /* Ignore this FUNCTION_DECL if it refers to a builtin declaration of a
9549 builtin function. Explicit programmer-supplied declarations of
9550 these same functions should NOT be ignored however. */
9551 if (DECL_EXTERNAL (decl
) && DECL_FUNCTION_CODE (decl
))
9554 /* What we would really like to do here is to filter out all mere
9555 file-scope declarations of file-scope functions which are never
9556 referenced later within this translation unit (and keep all of ones
9557 that *are* referenced later on) but we aren't clairvoyant, so we have
9558 no idea which functions will be referenced in the future (i.e. later
9559 on within the current translation unit). So here we just ignore all
9560 file-scope function declarations which are not also definitions. If
9561 and when the debugger needs to know something about these functions,
9562 it will have to hunt around and find the DWARF information associated
9563 with the definition of the function. Note that we can't just check
9564 `DECL_EXTERNAL' to find out which FUNCTION_DECL nodes represent
9565 definitions and which ones represent mere declarations. We have to
9566 check `DECL_INITIAL' instead. That's because the C front-end
9567 supports some weird semantics for "extern inline" function
9568 definitions. These can get inlined within the current translation
9569 unit (an thus, we need to generate DWARF info for their abstract
9570 instances so that the DWARF info for the concrete inlined instances
9571 can have something to refer to) but the compiler never generates any
9572 out-of-lines instances of such things (despite the fact that they
9573 *are* definitions). The important point is that the C front-end
9574 marks these "extern inline" functions as DECL_EXTERNAL, but we need
9575 to generate DWARF for them anyway. Note that the C++ front-end also
9576 plays some similar games for inline function definitions appearing
9577 within include files which also contain
9578 `#pragma interface' pragmas. */
9579 if (DECL_INITIAL (decl
) == NULL_TREE
)
9582 /* If we're a nested function, initially use a parent of NULL; if we're
9583 a plain function, this will be fixed up in decls_for_scope. If
9584 we're a method, it will be ignored, since we already have a DIE. */
9585 if (decl_function_context (decl
))
9591 /* Ignore this VAR_DECL if it refers to a file-scope extern data object
9592 declaration and if the declaration was never even referenced from
9593 within this entire compilation unit. We suppress these DIEs in
9594 order to save space in the .debug section (by eliminating entries
9595 which are probably useless). Note that we must not suppress
9596 block-local extern declarations (whether used or not) because that
9597 would screw-up the debugger's name lookup mechanism and cause it to
9598 miss things which really ought to be in scope at a given point. */
9599 if (DECL_EXTERNAL (decl
) && !TREE_USED (decl
))
9602 /* If we are in terse mode, don't generate any DIEs to represent any
9603 variable declarations or definitions. */
9604 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
9609 /* Don't bother trying to generate any DIEs to represent any of the
9610 normal built-in types for the language we are compiling. */
9611 if (DECL_SOURCE_LINE (decl
) == 0)
9613 /* OK, we need to generate one for `bool' so GDB knows what type
9614 comparisons have. */
9615 if ((get_AT_unsigned (comp_unit_die
, DW_AT_language
)
9616 == DW_LANG_C_plus_plus
)
9617 && TREE_CODE (TREE_TYPE (decl
)) == BOOLEAN_TYPE
)
9618 modified_type_die (TREE_TYPE (decl
), 0, 0, NULL
);
9623 /* If we are in terse mode, don't generate any DIEs for types. */
9624 if (debug_info_level
<= DINFO_LEVEL_TERSE
)
9627 /* If we're a function-scope tag, initially use a parent of NULL;
9628 this will be fixed up in decls_for_scope. */
9629 if (decl_function_context (decl
))
9638 gen_decl_die (decl
, context_die
);
9639 output_pending_types_for_scope (comp_unit_die
);
9642 /* Output a marker (i.e. a label) for the beginning of the generated code for
9646 dwarf2out_begin_block (blocknum
)
9647 register unsigned blocknum
;
9649 function_section (current_function_decl
);
9650 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file
, BLOCK_BEGIN_LABEL
, blocknum
);
9653 /* Output a marker (i.e. a label) for the end of the generated code for a
9657 dwarf2out_end_block (blocknum
)
9658 register unsigned blocknum
;
9660 function_section (current_function_decl
);
9661 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file
, BLOCK_END_LABEL
, blocknum
);
9664 /* Output a marker (i.e. a label) at a point in the assembly code which
9665 corresponds to a given source level label. */
9668 dwarf2out_label (insn
)
9671 char label
[MAX_ARTIFICIAL_LABEL_BYTES
];
9673 if (debug_info_level
>= DINFO_LEVEL_NORMAL
)
9675 function_section (current_function_decl
);
9676 sprintf (label
, INSN_LABEL_FMT
, current_funcdef_number
);
9677 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file
, label
,
9678 (unsigned) INSN_UID (insn
));
9682 /* Lookup a filename (in the list of filenames that we know about here in
9683 dwarf2out.c) and return its "index". The index of each (known) filename is
9684 just a unique number which is associated with only that one filename.
9685 We need such numbers for the sake of generating labels
9686 (in the .debug_sfnames section) and references to those
9687 files numbers (in the .debug_srcinfo and.debug_macinfo sections).
9688 If the filename given as an argument is not found in our current list,
9689 add it to the list and assign it the next available unique index number.
9690 In order to speed up searches, we remember the index of the filename
9691 was looked up last. This handles the majority of all searches. */
9694 lookup_filename (file_name
)
9695 const char *file_name
;
9697 static unsigned last_file_lookup_index
= 0;
9698 register unsigned i
;
9700 /* Check to see if the file name that was searched on the previous call
9701 matches this file name. If so, return the index. */
9702 if (last_file_lookup_index
!= 0)
9703 if (strcmp (file_name
, file_table
[last_file_lookup_index
]) == 0)
9704 return last_file_lookup_index
;
9706 /* Didn't match the previous lookup, search the table */
9707 for (i
= 1; i
< file_table_in_use
; ++i
)
9708 if (strcmp (file_name
, file_table
[i
]) == 0)
9710 last_file_lookup_index
= i
;
9714 /* Prepare to add a new table entry by making sure there is enough space in
9715 the table to do so. If not, expand the current table. */
9716 if (file_table_in_use
== file_table_allocated
)
9718 file_table_allocated
+= FILE_TABLE_INCREMENT
;
9720 = (char **) xrealloc (file_table
,
9721 file_table_allocated
* sizeof (char *));
9724 /* Add the new entry to the end of the filename table. */
9725 file_table
[file_table_in_use
] = xstrdup (file_name
);
9726 last_file_lookup_index
= file_table_in_use
++;
9728 return last_file_lookup_index
;
9731 /* Output a label to mark the beginning of a source code line entry
9732 and record information relating to this source line, in
9733 'line_info_table' for later output of the .debug_line section. */
9736 dwarf2out_line (filename
, line
)
9737 register const char *filename
;
9738 register unsigned line
;
9740 if (debug_info_level
>= DINFO_LEVEL_NORMAL
)
9742 function_section (current_function_decl
);
9744 if (DWARF2_ASM_LINE_DEBUG_INFO
)
9746 static const char *lastfile
;
9748 /* Emit the .file and .loc directives understood by GNU as. */
9749 if (lastfile
== 0 || strcmp (filename
, lastfile
))
9752 ggc_add_string_root ((char **) &lastfile
, 1);
9754 fprintf (asm_out_file
, "\t.file 0 \"%s\"\n", filename
);
9755 lastfile
= filename
;
9758 fprintf (asm_out_file
, "\t.loc 0 %d 0\n", line
);
9760 /* Indicate that line number info exists. */
9761 ++line_info_table_in_use
;
9763 /* Indicate that multiple line number tables exist. */
9764 if (DECL_SECTION_NAME (current_function_decl
))
9765 ++separate_line_info_table_in_use
;
9767 else if (DECL_SECTION_NAME (current_function_decl
))
9769 register dw_separate_line_info_ref line_info
;
9770 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file
, SEPARATE_LINE_CODE_LABEL
,
9771 separate_line_info_table_in_use
);
9773 fprintf (asm_out_file
, "\t%s line %d", ASM_COMMENT_START
, line
);
9774 fputc ('\n', asm_out_file
);
9776 /* expand the line info table if necessary */
9777 if (separate_line_info_table_in_use
9778 == separate_line_info_table_allocated
)
9780 separate_line_info_table_allocated
+= LINE_INFO_TABLE_INCREMENT
;
9781 separate_line_info_table
9782 = (dw_separate_line_info_ref
)
9783 xrealloc (separate_line_info_table
,
9784 separate_line_info_table_allocated
9785 * sizeof (dw_separate_line_info_entry
));
9788 /* Add the new entry at the end of the line_info_table. */
9790 = &separate_line_info_table
[separate_line_info_table_in_use
++];
9791 line_info
->dw_file_num
= lookup_filename (filename
);
9792 line_info
->dw_line_num
= line
;
9793 line_info
->function
= current_funcdef_number
;
9797 register dw_line_info_ref line_info
;
9799 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file
, LINE_CODE_LABEL
,
9800 line_info_table_in_use
);
9802 fprintf (asm_out_file
, "\t%s line %d", ASM_COMMENT_START
, line
);
9803 fputc ('\n', asm_out_file
);
9805 /* Expand the line info table if necessary. */
9806 if (line_info_table_in_use
== line_info_table_allocated
)
9808 line_info_table_allocated
+= LINE_INFO_TABLE_INCREMENT
;
9810 = (dw_line_info_ref
)
9811 xrealloc (line_info_table
,
9812 (line_info_table_allocated
9813 * sizeof (dw_line_info_entry
)));
9816 /* Add the new entry at the end of the line_info_table. */
9817 line_info
= &line_info_table
[line_info_table_in_use
++];
9818 line_info
->dw_file_num
= lookup_filename (filename
);
9819 line_info
->dw_line_num
= line
;
9824 /* Record the beginning of a new source file, for later output
9825 of the .debug_macinfo section. At present, unimplemented. */
9828 dwarf2out_start_source_file (filename
)
9829 register const char *filename ATTRIBUTE_UNUSED
;
9833 /* Record the end of a source file, for later output
9834 of the .debug_macinfo section. At present, unimplemented. */
9837 dwarf2out_end_source_file ()
9841 /* Called from check_newline in c-parse.y. The `buffer' parameter contains
9842 the tail part of the directive line, i.e. the part which is past the
9843 initial whitespace, #, whitespace, directive-name, whitespace part. */
9846 dwarf2out_define (lineno
, buffer
)
9847 register unsigned lineno ATTRIBUTE_UNUSED
;
9848 register const char *buffer ATTRIBUTE_UNUSED
;
9850 static int initialized
= 0;
9853 dwarf2out_start_source_file (primary_filename
);
9858 /* Called from check_newline in c-parse.y. The `buffer' parameter contains
9859 the tail part of the directive line, i.e. the part which is past the
9860 initial whitespace, #, whitespace, directive-name, whitespace part. */
9863 dwarf2out_undef (lineno
, buffer
)
9864 register unsigned lineno ATTRIBUTE_UNUSED
;
9865 register const char *buffer ATTRIBUTE_UNUSED
;
9869 /* Set up for Dwarf output at the start of compilation. */
9872 dwarf2out_init (asm_out_file
, main_input_filename
)
9873 register FILE *asm_out_file
;
9874 register char *main_input_filename
;
9876 /* Remember the name of the primary input file. */
9877 primary_filename
= main_input_filename
;
9879 /* Allocate the initial hunk of the file_table. */
9880 file_table
= (char **) xcalloc (FILE_TABLE_INCREMENT
, sizeof (char *));
9881 file_table_allocated
= FILE_TABLE_INCREMENT
;
9883 /* Skip the first entry - file numbers begin at 1. */
9884 file_table_in_use
= 1;
9886 /* Allocate the initial hunk of the decl_die_table. */
9888 = (dw_die_ref
*) xcalloc (DECL_DIE_TABLE_INCREMENT
, sizeof (dw_die_ref
));
9889 decl_die_table_allocated
= DECL_DIE_TABLE_INCREMENT
;
9890 decl_die_table_in_use
= 0;
9892 /* Allocate the initial hunk of the decl_scope_table. */
9894 = (decl_scope_node
*) xcalloc (DECL_SCOPE_TABLE_INCREMENT
,
9895 sizeof (decl_scope_node
));
9896 decl_scope_table_allocated
= DECL_SCOPE_TABLE_INCREMENT
;
9897 decl_scope_depth
= 0;
9899 /* Allocate the initial hunk of the abbrev_die_table. */
9901 = (dw_die_ref
*) xcalloc (ABBREV_DIE_TABLE_INCREMENT
,
9902 sizeof (dw_die_ref
));
9903 abbrev_die_table_allocated
= ABBREV_DIE_TABLE_INCREMENT
;
9904 /* Zero-th entry is allocated, but unused */
9905 abbrev_die_table_in_use
= 1;
9907 /* Allocate the initial hunk of the line_info_table. */
9909 = (dw_line_info_ref
) xcalloc (LINE_INFO_TABLE_INCREMENT
,
9910 sizeof (dw_line_info_entry
));
9911 line_info_table_allocated
= LINE_INFO_TABLE_INCREMENT
;
9912 /* Zero-th entry is allocated, but unused */
9913 line_info_table_in_use
= 1;
9915 /* Generate the initial DIE for the .debug section. Note that the (string)
9916 value given in the DW_AT_name attribute of the DW_TAG_compile_unit DIE
9917 will (typically) be a relative pathname and that this pathname should be
9918 taken as being relative to the directory from which the compiler was
9919 invoked when the given (base) source file was compiled. */
9920 comp_unit_die
= gen_compile_unit_die (main_input_filename
);
9922 ASM_GENERATE_INTERNAL_LABEL (text_end_label
, TEXT_END_LABEL
, 0);
9923 ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label
, ABBREV_SECTION_LABEL
, 0);
9924 if (DWARF2_GENERATE_TEXT_SECTION_LABEL
)
9925 ASM_GENERATE_INTERNAL_LABEL (text_section_label
, TEXT_SECTION_LABEL
, 0);
9927 strcpy (text_section_label
, stripattributes (TEXT_SECTION
));
9928 ASM_GENERATE_INTERNAL_LABEL (debug_info_section_label
,
9929 DEBUG_INFO_SECTION_LABEL
, 0);
9930 ASM_GENERATE_INTERNAL_LABEL (debug_line_section_label
,
9931 DEBUG_LINE_SECTION_LABEL
, 0);
9933 ASM_OUTPUT_SECTION (asm_out_file
, ABBREV_SECTION
);
9934 ASM_OUTPUT_LABEL (asm_out_file
, abbrev_section_label
);
9935 if (DWARF2_GENERATE_TEXT_SECTION_LABEL
)
9937 ASM_OUTPUT_SECTION (asm_out_file
, TEXT_SECTION
);
9938 ASM_OUTPUT_LABEL (asm_out_file
, text_section_label
);
9940 ASM_OUTPUT_SECTION (asm_out_file
, DEBUG_INFO_SECTION
);
9941 ASM_OUTPUT_LABEL (asm_out_file
, debug_info_section_label
);
9942 ASM_OUTPUT_SECTION (asm_out_file
, DEBUG_LINE_SECTION
);
9943 ASM_OUTPUT_LABEL (asm_out_file
, debug_line_section_label
);
9946 /* Output stuff that dwarf requires at the end of every file,
9947 and generate the DWARF-2 debugging info. */
9952 limbo_die_node
*node
, *next_node
;
9955 /* Traverse the limbo die list, and add parent/child links. The only
9956 dies without parents that should be here are concrete instances of
9957 inline functions, and the comp_unit_die. We can ignore the comp_unit_die.
9958 For concrete instances, we can get the parent die from the abstract
9960 for (node
= limbo_die_list
; node
; node
= next_node
)
9962 next_node
= node
->next
;
9965 if (die
->die_parent
== NULL
)
9967 dw_die_ref origin
= get_AT_ref (die
, DW_AT_abstract_origin
);
9969 add_child_die (origin
->die_parent
, die
);
9970 else if (die
== comp_unit_die
)
9977 limbo_die_list
= NULL
;
9979 /* Walk through the list of incomplete types again, trying once more to
9980 emit full debugging info for them. */
9981 retry_incomplete_types ();
9983 /* Traverse the DIE's, reverse their lists of attributes and children,
9984 and add add sibling attributes to those DIE's that have children. */
9985 add_sibling_attributes (comp_unit_die
);
9987 /* Output a terminator label for the .text section. */
9988 fputc ('\n', asm_out_file
);
9989 ASM_OUTPUT_SECTION (asm_out_file
, TEXT_SECTION
);
9990 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file
, TEXT_END_LABEL
, 0);
9993 /* Output a terminator label for the .data section. */
9994 fputc ('\n', asm_out_file
);
9995 ASM_OUTPUT_SECTION (asm_out_file
, DATA_SECTION
);
9996 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file
, DATA_END_LABEL
, 0);
9998 /* Output a terminator label for the .bss section. */
9999 fputc ('\n', asm_out_file
);
10000 ASM_OUTPUT_SECTION (asm_out_file
, BSS_SECTION
);
10001 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file
, BSS_END_LABEL
, 0);
10004 /* Output the source line correspondence table. */
10005 if (line_info_table_in_use
> 1 || separate_line_info_table_in_use
)
10007 if (! DWARF2_ASM_LINE_DEBUG_INFO
)
10009 fputc ('\n', asm_out_file
);
10010 ASM_OUTPUT_SECTION (asm_out_file
, DEBUG_LINE_SECTION
);
10011 output_line_info ();
10014 /* We can only use the low/high_pc attributes if all of the code
10016 if (separate_line_info_table_in_use
== 0)
10018 add_AT_lbl_id (comp_unit_die
, DW_AT_low_pc
, text_section_label
);
10019 add_AT_lbl_id (comp_unit_die
, DW_AT_high_pc
, text_end_label
);
10022 add_AT_lbl_offset (comp_unit_die
, DW_AT_stmt_list
,
10023 debug_line_section_label
);
10026 #if 0 /* unimplemented */
10027 if (debug_info_level
>= DINFO_LEVEL_VERBOSE
&& primary
)
10028 add_AT_unsigned (die
, DW_AT_macro_info
, 0);
10031 /* Output the abbreviation table. */
10032 fputc ('\n', asm_out_file
);
10033 ASM_OUTPUT_SECTION (asm_out_file
, ABBREV_SECTION
);
10034 build_abbrev_table (comp_unit_die
);
10035 output_abbrev_section ();
10037 /* Initialize the beginning DIE offset - and calculate sizes/offsets. */
10038 next_die_offset
= DWARF_COMPILE_UNIT_HEADER_SIZE
;
10039 calc_die_sizes (comp_unit_die
);
10041 /* Output debugging information. */
10042 fputc ('\n', asm_out_file
);
10043 ASM_OUTPUT_SECTION (asm_out_file
, DEBUG_INFO_SECTION
);
10044 output_compilation_unit_header ();
10045 output_die (comp_unit_die
);
10047 if (pubname_table_in_use
)
10049 /* Output public names table. */
10050 fputc ('\n', asm_out_file
);
10051 ASM_OUTPUT_SECTION (asm_out_file
, PUBNAMES_SECTION
);
10052 output_pubnames ();
10055 /* We only put functions in the arange table, so don't write it out if
10056 we don't have any. */
10057 if (fde_table_in_use
)
10059 /* Output the address range information. */
10060 fputc ('\n', asm_out_file
);
10061 ASM_OUTPUT_SECTION (asm_out_file
, ARANGES_SECTION
);
10065 #endif /* DWARF2_DEBUGGING_INFO */