1 /* Output dbx-format symbol table information from GNU compiler.
2 Copyright (C) 1987-2015 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
21 /* Output dbx-format symbol table data.
22 This consists of many symbol table entries, each of them
23 a .stabs assembler pseudo-op with four operands:
24 a "name" which is really a description of one symbol and its type,
25 a "code", which is a symbol defined in stab.h whose name starts with N_,
26 an unused operand always 0,
27 and a "value" which is an address or an offset.
28 The name is enclosed in doublequote characters.
30 Each function, variable, typedef, and structure tag
31 has a symbol table entry to define it.
32 The beginning and end of each level of name scoping within
33 a function are also marked by special symbol table entries.
35 The "name" consists of the symbol name, a colon, a kind-of-symbol letter,
36 and a data type number. The data type number may be followed by
37 "=" and a type definition; normally this will happen the first time
38 the type number is mentioned. The type definition may refer to
39 other types by number, and those type numbers may be followed
40 by "=" and nested definitions.
42 This can make the "name" quite long.
43 When a name is more than 80 characters, we split the .stabs pseudo-op
44 into two .stabs pseudo-ops, both sharing the same "code" and "value".
45 The first one is marked as continued with a double-backslash at the
48 The kind-of-symbol letter distinguished function names from global
49 variables from file-scope variables from parameters from auto
50 variables in memory from typedef names from register variables.
53 The "code" is mostly redundant with the kind-of-symbol letter
54 that goes in the "name", but not entirely: for symbols located
55 in static storage, the "code" says which segment the address is in,
56 which controls how it is relocated.
58 The "value" for a symbol in static storage
59 is the core address of the symbol (actually, the assembler
60 label for the symbol). For a symbol located in a stack slot
61 it is the stack offset; for one in a register, the register number.
62 For a typedef symbol, it is zero.
64 If DEBUG_SYMS_TEXT is defined, all debugging symbols must be
65 output while in the text section.
67 For more on data type definitions, see `dbxout_type'. */
71 #include "coretypes.h"
78 #include "stringpool.h"
80 #include "insn-config.h"
84 #include "diagnostic-core.h"
86 #include "fold-const.h"
88 #include "stor-layout.h"
95 #include "common/common-target.h"
96 #include "langhooks.h"
103 #ifdef XCOFF_DEBUGGING_INFO
104 #include "xcoffout.h"
108 # ifdef XCOFF_DEBUGGING_INFO
109 # define ASM_STABS_OP "\t.stabx\t"
111 # define ASM_STABS_OP "\t.stabs\t"
116 #define ASM_STABN_OP "\t.stabn\t"
120 #define ASM_STABD_OP "\t.stabd\t"
123 #ifndef DBX_TYPE_DECL_STABS_CODE
124 #define DBX_TYPE_DECL_STABS_CODE N_LSYM
127 #ifndef DBX_STATIC_CONST_VAR_CODE
128 #define DBX_STATIC_CONST_VAR_CODE N_FUN
131 #ifndef DBX_REGPARM_STABS_CODE
132 #define DBX_REGPARM_STABS_CODE N_RSYM
135 #ifndef DBX_REGPARM_STABS_LETTER
136 #define DBX_REGPARM_STABS_LETTER 'P'
139 #ifndef NO_DBX_FUNCTION_END
140 #define NO_DBX_FUNCTION_END 0
143 #ifndef NO_DBX_BNSYM_ENSYM
144 #define NO_DBX_BNSYM_ENSYM 0
147 #ifndef NO_DBX_MAIN_SOURCE_DIRECTORY
148 #define NO_DBX_MAIN_SOURCE_DIRECTORY 0
151 #ifndef DBX_BLOCKS_FUNCTION_RELATIVE
152 #define DBX_BLOCKS_FUNCTION_RELATIVE 0
155 #ifndef DBX_LINES_FUNCTION_RELATIVE
156 #define DBX_LINES_FUNCTION_RELATIVE 0
159 #ifndef DBX_CONTIN_LENGTH
160 #define DBX_CONTIN_LENGTH 80
163 #ifndef DBX_CONTIN_CHAR
164 #define DBX_CONTIN_CHAR '\\'
167 enum typestatus
{TYPE_UNSEEN
, TYPE_XREF
, TYPE_DEFINED
};
169 /* Structure recording information about a C data type.
170 The status element says whether we have yet output
171 the definition of the type. TYPE_XREF says we have
172 output it as a cross-reference only.
173 The file_number and type_number elements are used if DBX_USE_BINCL
176 struct GTY(()) typeinfo
{
177 enum typestatus status
;
182 /* Vector recording information about C data types.
183 When we first notice a data type (a tree node),
184 we assign it a number using next_type_number.
185 That is its index in this vector. */
187 static GTY ((length ("typevec_len"))) struct typeinfo
*typevec
;
189 /* Number of elements of space allocated in `typevec'. */
191 static GTY(()) int typevec_len
;
193 /* In dbx output, each type gets a unique number.
194 This is the number for the next type output.
195 The number, once assigned, is in the TYPE_SYMTAB_ADDRESS field. */
197 static GTY(()) int next_type_number
;
199 /* The C front end may call dbxout_symbol before dbxout_init runs.
200 We save all such decls in this list and output them when we get
203 static GTY(()) tree preinit_symbols
;
205 enum binclstatus
{BINCL_NOT_REQUIRED
, BINCL_PENDING
, BINCL_PROCESSED
};
207 /* When using N_BINCL in dbx output, each type number is actually a
208 pair of the file number and the type number within the file.
209 This is a stack of input files. */
213 struct dbx_file
*next
;
215 int next_type_number
;
216 enum binclstatus bincl_status
; /* Keep track of lazy bincl. */
217 const char *pending_bincl_name
; /* Name of bincl. */
218 struct dbx_file
*prev
; /* Chain to traverse all pending bincls. */
221 /* This is the top of the stack.
223 This is not saved for PCH, because restoring a PCH should not change it.
224 next_file_number does have to be saved, because the PCH may use some
225 file numbers; however, just before restoring a PCH, next_file_number
226 should always be 0 because we should not have needed any file numbers
229 #if (defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)) \
230 && defined (DBX_USE_BINCL)
231 static struct dbx_file
*current_file
;
234 /* This is the next file number to use. */
236 static GTY(()) int next_file_number
;
238 /* A counter for dbxout_function_end. */
240 static GTY(()) int scope_labelno
;
242 /* A counter for dbxout_source_line. */
244 static GTY(()) int dbxout_source_line_counter
;
246 /* Number for the next N_SOL filename stabs label. The number 0 is reserved
247 for the N_SO filename stabs label. */
249 static GTY(()) int source_label_number
= 1;
251 /* Last source file name mentioned in a NOTE insn. */
253 static GTY(()) const char *lastfile
;
255 /* Used by PCH machinery to detect if 'lastfile' should be reset to
257 static GTY(()) int lastfile_is_base
;
259 /* Typical USG systems don't have stab.h, and they also have
260 no use for DBX-format debugging info. */
262 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
265 /* If zero then there is no pending BINCL. */
266 static int pending_bincls
= 0;
269 /* The original input file name. */
270 static const char *base_input_file
;
272 #ifdef DEBUG_SYMS_TEXT
273 #define FORCE_TEXT switch_to_section (current_function_section ())
280 /* 1 if PARM is passed to this function in memory. */
282 #define PARM_PASSED_IN_MEMORY(PARM) \
283 (MEM_P (DECL_INCOMING_RTL (PARM)))
285 /* A C expression for the integer offset value of an automatic variable
286 (N_LSYM) having address X (an RTX). */
287 #ifndef DEBUGGER_AUTO_OFFSET
288 #define DEBUGGER_AUTO_OFFSET(X) \
289 (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
292 /* A C expression for the integer offset value of an argument (N_PSYM)
293 having address X (an RTX). The nominal offset is OFFSET.
294 Note that we use OFFSET + 0 here to avoid the self-assign warning
295 when the macro is called in a context like
296 number = DEBUGGER_ARG_OFFSET(number, X) */
297 #ifndef DEBUGGER_ARG_OFFSET
298 #define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET + 0)
301 /* This obstack holds the stab string currently being constructed. We
302 build it up here, then write it out, so we can split long lines up
303 properly (see dbxout_finish_complex_stabs). */
304 static struct obstack stabstr_ob
;
305 static size_t stabstr_last_contin_point
;
308 static void emit_bincl_stab (const char *c
);
309 static void emit_pending_bincls (void);
311 static inline void emit_pending_bincls_if_required (void);
313 static void dbxout_init (const char *);
315 static void dbxout_finish (const char *);
316 static void dbxout_start_source_file (unsigned, const char *);
317 static void dbxout_end_source_file (unsigned);
318 static void dbxout_typedefs (tree
);
319 static void dbxout_type_index (tree
);
320 static void dbxout_args (tree
);
321 static void dbxout_type_fields (tree
);
322 static void dbxout_type_method_1 (tree
);
323 static void dbxout_type_methods (tree
);
324 static void dbxout_range_type (tree
, tree
, tree
);
325 static void dbxout_type (tree
, int);
326 static bool print_int_cst_bounds_in_octal_p (tree
, tree
, tree
);
327 static bool is_fortran (void);
328 static void dbxout_type_name (tree
);
329 static void dbxout_class_name_qualifiers (tree
);
330 static int dbxout_symbol_location (tree
, tree
, const char *, rtx
);
331 static void dbxout_symbol_name (tree
, const char *, int);
332 static void dbxout_common_name (tree
, const char *, stab_code_type
);
333 static const char *dbxout_common_check (tree
, int *);
334 static void dbxout_early_global_decl (tree
);
335 static void dbxout_late_global_decl (tree
);
336 static void dbxout_type_decl (tree
, int);
337 static void dbxout_handle_pch (unsigned);
338 static void debug_free_queue (void);
340 /* The debug hooks structure. */
341 #if defined (DBX_DEBUGGING_INFO)
343 static void dbxout_source_line (unsigned int, const char *, int, bool);
344 static void dbxout_begin_prologue (unsigned int, const char *);
345 static void dbxout_source_file (const char *);
346 static void dbxout_function_end (tree
);
347 static void dbxout_begin_function (tree
);
348 static void dbxout_begin_block (unsigned, unsigned);
349 static void dbxout_end_block (unsigned, unsigned);
350 static void dbxout_function_decl (tree
);
352 const struct gcc_debug_hooks dbx_debug_hooks
=
358 debug_nothing_int_charstar
,
359 debug_nothing_int_charstar
,
360 dbxout_start_source_file
,
361 dbxout_end_source_file
,
364 debug_true_const_tree
, /* ignore_block */
365 dbxout_source_line
, /* source_line */
366 dbxout_begin_prologue
, /* begin_prologue */
367 debug_nothing_int_charstar
, /* end_prologue */
368 debug_nothing_int_charstar
, /* begin_epilogue */
369 debug_nothing_int_charstar
, /* end_epilogue */
370 #ifdef DBX_FUNCTION_FIRST
371 dbxout_begin_function
,
373 debug_nothing_tree
, /* begin_function */
375 debug_nothing_int
, /* end_function */
376 debug_nothing_tree
, /* register_main_translation_unit */
377 dbxout_function_decl
,
378 dbxout_early_global_decl
, /* early_global_decl */
379 dbxout_late_global_decl
, /* late_global_decl */
380 dbxout_type_decl
, /* type_decl */
381 debug_nothing_tree_tree_tree_bool
, /* imported_module_or_decl */
382 debug_nothing_tree
, /* deferred_inline_function */
383 debug_nothing_tree
, /* outlining_inline_function */
384 debug_nothing_rtx_code_label
, /* label */
385 dbxout_handle_pch
, /* handle_pch */
386 debug_nothing_rtx_insn
, /* var_location */
387 debug_nothing_void
, /* switch_text_section */
388 debug_nothing_tree_tree
, /* set_name */
389 0, /* start_end_main_source_file */
390 TYPE_SYMTAB_IS_ADDRESS
/* tree_type_symtab_field */
392 #endif /* DBX_DEBUGGING_INFO */
394 #if defined (XCOFF_DEBUGGING_INFO)
395 const struct gcc_debug_hooks xcoff_debug_hooks
=
401 debug_nothing_int_charstar
,
402 debug_nothing_int_charstar
,
403 dbxout_start_source_file
,
404 dbxout_end_source_file
,
405 xcoffout_begin_block
,
407 debug_true_const_tree
, /* ignore_block */
408 xcoffout_source_line
,
409 xcoffout_begin_prologue
, /* begin_prologue */
410 debug_nothing_int_charstar
, /* end_prologue */
411 debug_nothing_int_charstar
, /* begin_epilogue */
412 xcoffout_end_epilogue
,
413 debug_nothing_tree
, /* begin_function */
414 xcoffout_end_function
,
415 debug_nothing_tree
, /* register_main_translation_unit */
416 debug_nothing_tree
, /* function_decl */
417 dbxout_early_global_decl
, /* early_global_decl */
418 dbxout_late_global_decl
, /* late_global_decl */
419 dbxout_type_decl
, /* type_decl */
420 debug_nothing_tree_tree_tree_bool
, /* imported_module_or_decl */
421 debug_nothing_tree
, /* deferred_inline_function */
422 debug_nothing_tree
, /* outlining_inline_function */
423 debug_nothing_rtx_code_label
, /* label */
424 dbxout_handle_pch
, /* handle_pch */
425 debug_nothing_rtx_insn
, /* var_location */
426 debug_nothing_void
, /* switch_text_section */
427 debug_nothing_tree_tree
, /* set_name */
428 0, /* start_end_main_source_file */
429 TYPE_SYMTAB_IS_ADDRESS
/* tree_type_symtab_field */
431 #endif /* XCOFF_DEBUGGING_INFO */
433 /* Numeric formatting helper macro. Note that this does not handle
435 #define NUMBER_FMT_LOOP(P, NUM, BASE) \
438 int digit = NUM % BASE; \
440 *--P = digit + '0'; \
444 /* Utility: write a decimal integer NUM to asm_out_file. */
449 char *p
= buf
+ sizeof buf
;
454 putc ('0', asm_out_file
);
459 putc ('-', asm_out_file
);
465 NUMBER_FMT_LOOP (p
, unum
, 10);
467 while (p
< buf
+ sizeof buf
)
469 putc (*p
, asm_out_file
);
475 /* Primitives for emitting simple stabs directives. All other stabs
476 routines should use these functions instead of directly emitting
477 stabs. They are exported because machine-dependent code may need
478 to invoke them, e.g. in a DBX_OUTPUT_* macro whose definition
479 forwards to code in CPU.c. */
481 /* The following functions should all be called immediately after one
482 of the dbxout_begin_stab* functions (below). They write out
483 various things as the value of a stab. */
485 /* Write out a literal zero as the value of a stab. */
487 dbxout_stab_value_zero (void)
489 fputs ("0\n", asm_out_file
);
492 /* Write out the label LABEL as the value of a stab. */
494 dbxout_stab_value_label (const char *label
)
496 assemble_name (asm_out_file
, label
);
497 putc ('\n', asm_out_file
);
500 /* Write out the difference of two labels, LABEL - BASE, as the value
503 dbxout_stab_value_label_diff (const char *label
, const char *base
)
505 assemble_name (asm_out_file
, label
);
506 putc ('-', asm_out_file
);
507 assemble_name (asm_out_file
, base
);
508 putc ('\n', asm_out_file
);
511 /* Write out an internal label as the value of a stab, and immediately
512 emit that internal label. This should be used only when
513 dbxout_stabd will not work. STEM is the name stem of the label,
514 COUNTERP is a pointer to a counter variable which will be used to
515 guarantee label uniqueness. */
517 dbxout_stab_value_internal_label (const char *stem
, int *counterp
)
520 int counter
= counterp
? (*counterp
)++ : 0;
522 ASM_GENERATE_INTERNAL_LABEL (label
, stem
, counter
);
523 dbxout_stab_value_label (label
);
524 targetm
.asm_out
.internal_label (asm_out_file
, stem
, counter
);
527 /* Write out the difference between BASE and an internal label as the
528 value of a stab, and immediately emit that internal label. STEM and
529 COUNTERP are as for dbxout_stab_value_internal_label. */
531 dbxout_stab_value_internal_label_diff (const char *stem
, int *counterp
,
535 int counter
= counterp
? (*counterp
)++ : 0;
537 ASM_GENERATE_INTERNAL_LABEL (label
, stem
, counter
);
538 dbxout_stab_value_label_diff (label
, base
);
539 targetm
.asm_out
.internal_label (asm_out_file
, stem
, counter
);
542 /* The following functions produce specific kinds of stab directives. */
544 /* Write a .stabd directive with type STYPE and desc SDESC to asm_out_file. */
546 dbxout_stabd (int stype
, int sdesc
)
548 fputs (ASM_STABD_OP
, asm_out_file
);
550 fputs (",0,", asm_out_file
);
552 putc ('\n', asm_out_file
);
555 /* Write a .stabn directive with type STYPE. This function stops
556 short of emitting the value field, which is the responsibility of
557 the caller (normally it will be either a symbol or the difference
561 dbxout_begin_stabn (int stype
)
563 fputs (ASM_STABN_OP
, asm_out_file
);
565 fputs (",0,0,", asm_out_file
);
568 /* Write a .stabn directive with type N_SLINE and desc LINE. As above,
569 the value field is the responsibility of the caller. */
571 dbxout_begin_stabn_sline (int lineno
)
573 fputs (ASM_STABN_OP
, asm_out_file
);
574 dbxout_int (N_SLINE
);
575 fputs (",0,", asm_out_file
);
577 putc (',', asm_out_file
);
580 /* Begin a .stabs directive with string "", type STYPE, and desc and
581 other fields 0. The value field is the responsibility of the
582 caller. This function cannot be used for .stabx directives. */
584 dbxout_begin_empty_stabs (int stype
)
586 fputs (ASM_STABS_OP
, asm_out_file
);
587 fputs ("\"\",", asm_out_file
);
589 fputs (",0,0,", asm_out_file
);
592 /* Begin a .stabs directive with string STR, type STYPE, and desc 0.
593 The value field is the responsibility of the caller. */
595 dbxout_begin_simple_stabs (const char *str
, int stype
)
597 fputs (ASM_STABS_OP
, asm_out_file
);
598 output_quoted_string (asm_out_file
, str
);
599 putc (',', asm_out_file
);
601 fputs (",0,0,", asm_out_file
);
604 /* As above but use SDESC for the desc field. */
606 dbxout_begin_simple_stabs_desc (const char *str
, int stype
, int sdesc
)
608 fputs (ASM_STABS_OP
, asm_out_file
);
609 output_quoted_string (asm_out_file
, str
);
610 putc (',', asm_out_file
);
612 fputs (",0,", asm_out_file
);
614 putc (',', asm_out_file
);
617 /* The next set of functions are entirely concerned with production of
618 "complex" .stabs directives: that is, .stabs directives whose
619 strings have to be constructed piecemeal. dbxout_type,
620 dbxout_symbol, etc. use these routines heavily. The string is queued
621 up in an obstack, then written out by dbxout_finish_complex_stabs, which
622 is also responsible for splitting it up if it exceeds DBX_CONTIN_LENGTH.
623 (You might think it would be more efficient to go straight to stdio
624 when DBX_CONTIN_LENGTH is 0 (i.e. no length limit) but that turns
625 out not to be the case, and anyway this needs fewer #ifdefs.) */
627 /* Begin a complex .stabs directive. If we can, write the initial
628 ASM_STABS_OP to the asm_out_file. */
631 dbxout_begin_complex_stabs (void)
633 emit_pending_bincls_if_required ();
635 fputs (ASM_STABS_OP
, asm_out_file
);
636 putc ('"', asm_out_file
);
637 gcc_assert (stabstr_last_contin_point
== 0);
640 /* As above, but do not force text or emit pending bincls. This is
641 used by dbxout_symbol_location, which needs to do something else. */
643 dbxout_begin_complex_stabs_noforcetext (void)
645 fputs (ASM_STABS_OP
, asm_out_file
);
646 putc ('"', asm_out_file
);
647 gcc_assert (stabstr_last_contin_point
== 0);
650 /* Add CHR, a single character, to the string being built. */
651 #define stabstr_C(chr) obstack_1grow (&stabstr_ob, chr)
653 /* Add STR, a normal C string, to the string being built. */
654 #define stabstr_S(str) obstack_grow (&stabstr_ob, str, strlen (str))
656 /* Add the text of ID, an IDENTIFIER_NODE, to the string being built. */
657 #define stabstr_I(id) obstack_grow (&stabstr_ob, \
658 IDENTIFIER_POINTER (id), \
659 IDENTIFIER_LENGTH (id))
661 /* Add NUM, a signed decimal number, to the string being built. */
663 stabstr_D (HOST_WIDE_INT num
)
666 char *p
= buf
+ sizeof buf
;
682 NUMBER_FMT_LOOP (p
, unum
, 10);
684 obstack_grow (&stabstr_ob
, p
, (buf
+ sizeof buf
) - p
);
687 /* Add NUM, an unsigned decimal number, to the string being built. */
689 stabstr_U (unsigned HOST_WIDE_INT num
)
692 char *p
= buf
+ sizeof buf
;
698 NUMBER_FMT_LOOP (p
, num
, 10);
699 obstack_grow (&stabstr_ob
, p
, (buf
+ sizeof buf
) - p
);
702 /* Add CST, an INTEGER_CST tree, to the string being built as an
703 unsigned octal number. This routine handles values which are
704 larger than a single HOST_WIDE_INT. */
708 int prec
= TYPE_PRECISION (TREE_TYPE (cst
));
709 int res_pres
= prec
% 3;
713 /* Leading zero for base indicator. */
716 /* If the value is zero, the base indicator will serve as the value
718 if (wi::eq_p (cst
, 0))
721 /* GDB wants constants with no extra leading "1" bits, so
722 we need to remove any sign-extension that might be
726 digit
= wi::extract_uhwi (cst
, prec
- 1, 1);
727 stabstr_C ('0' + digit
);
729 else if (res_pres
== 2)
731 digit
= wi::extract_uhwi (cst
, prec
- 2, 2);
732 stabstr_C ('0' + digit
);
736 for (i
= prec
- 3; i
>= 0; i
= i
- 3)
738 digit
= wi::extract_uhwi (cst
, i
, 3);
739 stabstr_C ('0' + digit
);
743 /* Called whenever it is safe to break a stabs string into multiple
744 .stabs directives. If the current string has exceeded the limit
745 set by DBX_CONTIN_LENGTH, mark the current position in the buffer
746 as a continuation point by inserting DBX_CONTIN_CHAR (doubled if
747 it is a backslash) and a null character. */
749 stabstr_continue (void)
751 if (DBX_CONTIN_LENGTH
> 0
752 && obstack_object_size (&stabstr_ob
) - stabstr_last_contin_point
755 if (DBX_CONTIN_CHAR
== '\\')
756 obstack_1grow (&stabstr_ob
, '\\');
757 obstack_1grow (&stabstr_ob
, DBX_CONTIN_CHAR
);
758 obstack_1grow (&stabstr_ob
, '\0');
759 stabstr_last_contin_point
= obstack_object_size (&stabstr_ob
);
762 #define CONTIN stabstr_continue ()
764 /* Macro subroutine of dbxout_finish_complex_stabs, which emits
765 all of the arguments to the .stabs directive after the string.
766 Overridden by xcoffout.h. CODE is the stabs code for this symbol;
767 LINE is the source line to write into the desc field (in extended
768 mode); SYM is the symbol itself.
770 ADDR, LABEL, and NUMBER are three different ways to represent the
771 stabs value field. At most one of these should be nonzero.
773 ADDR is used most of the time; it represents the value as an
774 RTL address constant.
776 LABEL is used (currently) only for N_CATCH stabs; it represents
777 the value as a string suitable for assemble_name.
779 NUMBER is used when the value is an offset from an implicit base
780 pointer (e.g. for a stack variable), or an index (e.g. for a
781 register variable). It represents the value as a decimal integer. */
783 #ifndef DBX_FINISH_STABS
784 #define DBX_FINISH_STABS(SYM, CODE, LINE, ADDR, LABEL, NUMBER) \
786 int line_ = use_gnu_debug_info_extensions ? LINE : 0; \
789 fputs (",0,", asm_out_file); \
790 dbxout_int (line_); \
791 putc (',', asm_out_file); \
793 output_addr_const (asm_out_file, ADDR); \
795 assemble_name (asm_out_file, LABEL); \
797 dbxout_int (NUMBER); \
798 putc ('\n', asm_out_file); \
802 /* Finish the emission of a complex .stabs directive. When DBX_CONTIN_LENGTH
803 is zero, this has only to emit the close quote and the remainder of
804 the arguments. When it is nonzero, the string has been marshalled in
805 stabstr_ob, and this routine is responsible for breaking it up into
806 DBX_CONTIN_LENGTH-sized chunks.
808 SYM is the DECL of the symbol under consideration; it is used only
809 for its DECL_SOURCE_LINE. The other arguments are all passed directly
810 to DBX_FINISH_STABS; see above for details. */
813 dbxout_finish_complex_stabs (tree sym
, stab_code_type code
,
814 rtx addr
, const char *label
, int number
)
816 int line ATTRIBUTE_UNUSED
;
820 line
= sym
? DECL_SOURCE_LINE (sym
) : 0;
821 if (DBX_CONTIN_LENGTH
> 0)
826 /* Nul-terminate the growing string, then get its size and
828 obstack_1grow (&stabstr_ob
, '\0');
830 len
= obstack_object_size (&stabstr_ob
);
831 chunk
= str
= XOBFINISH (&stabstr_ob
, char *);
833 /* Within the buffer are a sequence of NUL-separated strings,
834 each of which is to be written out as a separate stab
838 chunklen
= strlen (chunk
);
839 fwrite (chunk
, 1, chunklen
, asm_out_file
);
840 fputs ("\",", asm_out_file
);
842 /* Must add an extra byte to account for the NUL separator. */
843 chunk
+= chunklen
+ 1;
846 /* Only put a line number on the last stab in the sequence. */
847 DBX_FINISH_STABS (sym
, code
, len
== 0 ? line
: 0,
848 addr
, label
, number
);
852 fputs (ASM_STABS_OP
, asm_out_file
);
853 putc ('"', asm_out_file
);
855 stabstr_last_contin_point
= 0;
859 /* No continuations - we can put the whole string out at once.
860 It is faster to augment the string with the close quote and
861 comma than to do a two-character fputs. */
862 obstack_grow (&stabstr_ob
, "\",", 2);
863 len
= obstack_object_size (&stabstr_ob
);
864 str
= XOBFINISH (&stabstr_ob
, char *);
866 fwrite (str
, 1, len
, asm_out_file
);
867 DBX_FINISH_STABS (sym
, code
, line
, addr
, label
, number
);
869 obstack_free (&stabstr_ob
, str
);
872 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
874 /* When -gused is used, emit debug info for only used symbols. But in
875 addition to the standard intercepted debug_hooks there are some
876 direct calls into this file, i.e., dbxout_symbol, dbxout_parms, and
877 dbxout_reg_params. Those routines may also be called from a higher
878 level intercepted routine. So to prevent recording data for an inner
879 call to one of these for an intercept, we maintain an intercept
880 nesting counter (debug_nesting). We only save the intercepted
881 arguments if the nesting is 1. */
882 static int debug_nesting
= 0;
884 static tree
*symbol_queue
;
885 static int symbol_queue_index
= 0;
886 static int symbol_queue_size
= 0;
888 #define DBXOUT_DECR_NESTING \
889 if (--debug_nesting == 0 && symbol_queue_index > 0) \
890 { emit_pending_bincls_if_required (); debug_flush_symbol_queue (); }
892 #define DBXOUT_DECR_NESTING_AND_RETURN(x) \
893 do {--debug_nesting; return (x);} while (0)
895 #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */
897 #if defined (DBX_DEBUGGING_INFO)
900 dbxout_function_end (tree decl ATTRIBUTE_UNUSED
)
902 char lscope_label_name
[100];
904 /* The Lscope label must be emitted even if we aren't doing anything
905 else; dbxout_block needs it. */
906 switch_to_section (function_section (current_function_decl
));
908 /* Convert Lscope into the appropriate format for local labels in case
909 the system doesn't insert underscores in front of user generated
911 ASM_GENERATE_INTERNAL_LABEL (lscope_label_name
, "Lscope", scope_labelno
);
912 targetm
.asm_out
.internal_label (asm_out_file
, "Lscope", scope_labelno
);
914 /* The N_FUN tag at the end of the function is a GNU extension,
915 which may be undesirable, and is unnecessary if we do not have
917 if (!use_gnu_debug_info_extensions
918 || NO_DBX_FUNCTION_END
919 || !targetm_common
.have_named_sections
)
922 /* By convention, GCC will mark the end of a function with an N_FUN
923 symbol and an empty string. */
924 if (flag_reorder_blocks_and_partition
)
926 dbxout_begin_empty_stabs (N_FUN
);
927 dbxout_stab_value_label_diff (crtl
->subsections
.hot_section_end_label
,
928 crtl
->subsections
.hot_section_label
);
929 dbxout_begin_empty_stabs (N_FUN
);
930 dbxout_stab_value_label_diff (crtl
->subsections
.cold_section_end_label
,
931 crtl
->subsections
.cold_section_label
);
935 char begin_label
[20];
936 /* Reference current function start using LFBB. */
937 ASM_GENERATE_INTERNAL_LABEL (begin_label
, "LFBB", scope_labelno
);
938 dbxout_begin_empty_stabs (N_FUN
);
939 dbxout_stab_value_label_diff (lscope_label_name
, begin_label
);
942 if (!NO_DBX_BNSYM_ENSYM
&& !flag_debug_only_used_symbols
)
943 dbxout_stabd (N_ENSYM
, 0);
945 #endif /* DBX_DEBUGGING_INFO */
947 /* Get lang description for N_SO stab. */
948 static unsigned int ATTRIBUTE_UNUSED
949 get_lang_number (void)
951 const char *language_string
= lang_hooks
.name
;
954 else if (lang_GNU_CXX ())
956 else if (strcmp (language_string
, "GNU F77") == 0)
958 else if (lang_GNU_Fortran ())
959 return N_SO_FORTRAN90
; /* CHECKME */
960 else if (strcmp (language_string
, "GNU Pascal") == 0)
962 else if (strcmp (language_string
, "GNU Objective-C") == 0)
964 else if (strcmp (language_string
, "GNU Objective-C++") == 0)
965 return N_SO_OBJCPLUS
;
974 unsigned int lang
= get_lang_number ();
976 return (lang
== N_SO_FORTRAN
) || (lang
== N_SO_FORTRAN90
);
979 /* At the beginning of compilation, start writing the symbol table.
980 Initialize `typevec' and output the standard data types of C. */
983 dbxout_init (const char *input_file_name
)
985 char ltext_label_name
[100];
986 bool used_ltext_label_name
= false;
987 tree syms
= lang_hooks
.decls
.getdecls ();
988 const char *mapped_name
;
991 typevec
= ggc_cleared_vec_alloc
<typeinfo
> (typevec_len
);
993 /* stabstr_ob contains one string, which will be just fine with
995 obstack_specify_allocation (&stabstr_ob
, 0, 1, xmalloc
, free
);
997 /* Convert Ltext into the appropriate format for local labels in case
998 the system doesn't insert underscores in front of user generated
1000 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name
, "Ltext", 0);
1002 /* Put the current working directory in an N_SO symbol. */
1003 if (use_gnu_debug_info_extensions
&& !NO_DBX_MAIN_SOURCE_DIRECTORY
)
1005 static const char *cwd
;
1009 cwd
= get_src_pwd ();
1012 else if (!IS_DIR_SEPARATOR (cwd
[strlen (cwd
) - 1]))
1013 cwd
= concat (cwd
, "/", NULL
);
1014 cwd
= remap_debug_filename (cwd
);
1016 #ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
1017 DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asm_out_file
, cwd
);
1018 #else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
1019 dbxout_begin_simple_stabs_desc (cwd
, N_SO
, get_lang_number ());
1020 dbxout_stab_value_label (ltext_label_name
);
1021 used_ltext_label_name
= true;
1022 #endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
1025 mapped_name
= remap_debug_filename (input_file_name
);
1026 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
1027 DBX_OUTPUT_MAIN_SOURCE_FILENAME (asm_out_file
, mapped_name
);
1029 dbxout_begin_simple_stabs_desc (mapped_name
, N_SO
, get_lang_number ());
1030 dbxout_stab_value_label (ltext_label_name
);
1031 used_ltext_label_name
= true;
1034 if (used_ltext_label_name
)
1036 switch_to_section (text_section
);
1037 targetm
.asm_out
.internal_label (asm_out_file
, "Ltext", 0);
1040 /* Emit an N_OPT stab to indicate that this file was compiled by GCC.
1041 The string used is historical. */
1042 #ifndef NO_DBX_GCC_MARKER
1043 dbxout_begin_simple_stabs ("gcc2_compiled.", N_OPT
);
1044 dbxout_stab_value_zero ();
1047 base_input_file
= lastfile
= input_file_name
;
1049 next_type_number
= 1;
1051 #ifdef DBX_USE_BINCL
1052 current_file
= XNEW (struct dbx_file
);
1053 current_file
->next
= NULL
;
1054 current_file
->file_number
= 0;
1055 current_file
->next_type_number
= 1;
1056 next_file_number
= 1;
1057 current_file
->prev
= NULL
;
1058 current_file
->bincl_status
= BINCL_NOT_REQUIRED
;
1059 current_file
->pending_bincl_name
= NULL
;
1062 /* Get all permanent types that have typedef names, and output them
1063 all, except for those already output. Some language front ends
1064 put these declarations in the top-level scope; some do not;
1065 the latter are responsible for calling debug_hooks->type_decl from
1066 their record_builtin_type function. */
1067 dbxout_typedefs (syms
);
1069 if (preinit_symbols
)
1072 for (t
= nreverse (preinit_symbols
); t
; t
= TREE_CHAIN (t
))
1073 dbxout_symbol (TREE_VALUE (t
), 0);
1074 preinit_symbols
= 0;
1078 /* Output any typedef names for types described by TYPE_DECLs in SYMS. */
1081 dbxout_typedefs (tree syms
)
1083 for (; syms
!= NULL_TREE
; syms
= DECL_CHAIN (syms
))
1085 if (TREE_CODE (syms
) == TYPE_DECL
)
1087 tree type
= TREE_TYPE (syms
);
1088 if (TYPE_NAME (type
)
1089 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1090 && COMPLETE_OR_VOID_TYPE_P (type
)
1091 && ! TREE_ASM_WRITTEN (TYPE_NAME (type
)))
1092 dbxout_symbol (TYPE_NAME (type
), 0);
1097 #ifdef DBX_USE_BINCL
1098 /* Emit BINCL stab using given name. */
1100 emit_bincl_stab (const char *name
)
1102 dbxout_begin_simple_stabs (name
, N_BINCL
);
1103 dbxout_stab_value_zero ();
1106 /* If there are pending bincls then it is time to emit all of them. */
1109 emit_pending_bincls_if_required (void)
1112 emit_pending_bincls ();
1115 /* Emit all pending bincls. */
1118 emit_pending_bincls (void)
1120 struct dbx_file
*f
= current_file
;
1122 /* Find first pending bincl. */
1123 while (f
->bincl_status
== BINCL_PENDING
)
1126 /* Now emit all bincls. */
1131 if (f
->bincl_status
== BINCL_PENDING
)
1133 emit_bincl_stab (f
->pending_bincl_name
);
1135 /* Update file number and status. */
1136 f
->file_number
= next_file_number
++;
1137 f
->bincl_status
= BINCL_PROCESSED
;
1139 if (f
== current_file
)
1144 /* All pending bincls have been emitted. */
1151 emit_pending_bincls_if_required (void) {}
1154 /* Change to reading from a new source file. Generate a N_BINCL stab. */
1157 dbxout_start_source_file (unsigned int line ATTRIBUTE_UNUSED
,
1158 const char *filename ATTRIBUTE_UNUSED
)
1160 #ifdef DBX_USE_BINCL
1161 struct dbx_file
*n
= XNEW (struct dbx_file
);
1163 n
->next
= current_file
;
1164 n
->next_type_number
= 1;
1165 /* Do not assign file number now.
1166 Delay it until we actually emit BINCL. */
1169 current_file
->prev
= n
;
1170 n
->bincl_status
= BINCL_PENDING
;
1171 n
->pending_bincl_name
= remap_debug_filename (filename
);
1177 /* Revert to reading a previous source file. Generate a N_EINCL stab. */
1180 dbxout_end_source_file (unsigned int line ATTRIBUTE_UNUSED
)
1182 #ifdef DBX_USE_BINCL
1183 /* Emit EINCL stab only if BINCL is not pending. */
1184 if (current_file
->bincl_status
== BINCL_PROCESSED
)
1186 dbxout_begin_stabn (N_EINCL
);
1187 dbxout_stab_value_zero ();
1189 current_file
->bincl_status
= BINCL_NOT_REQUIRED
;
1190 current_file
= current_file
->next
;
1194 /* Handle a few odd cases that occur when trying to make PCH files work. */
1197 dbxout_handle_pch (unsigned at_end
)
1201 /* When using the PCH, this file will be included, so we need to output
1203 dbxout_start_source_file (0, lastfile
);
1205 /* The base file when using the PCH won't be the same as
1206 the base file when it's being generated. */
1211 /* ... and an EINCL. */
1212 dbxout_end_source_file (0);
1214 /* Deal with cases where 'lastfile' was never actually changed. */
1215 lastfile_is_base
= lastfile
== NULL
;
1219 #if defined (DBX_DEBUGGING_INFO)
1221 static void dbxout_block (tree
, int, tree
);
1223 /* Output debugging info to FILE to switch to sourcefile FILENAME. */
1226 dbxout_source_file (const char *filename
)
1228 if (lastfile
== 0 && lastfile_is_base
)
1230 lastfile
= base_input_file
;
1231 lastfile_is_base
= 0;
1234 if (filename
&& (lastfile
== 0 || strcmp (filename
, lastfile
)))
1236 /* Don't change section amid function. */
1237 if (current_function_decl
== NULL_TREE
)
1238 switch_to_section (text_section
);
1240 dbxout_begin_simple_stabs (remap_debug_filename (filename
), N_SOL
);
1241 dbxout_stab_value_internal_label ("Ltext", &source_label_number
);
1242 lastfile
= filename
;
1246 /* Output N_BNSYM, line number symbol entry, and local symbol at
1250 dbxout_begin_prologue (unsigned int lineno
, const char *filename
)
1252 if (use_gnu_debug_info_extensions
1253 && !NO_DBX_FUNCTION_END
1254 && !NO_DBX_BNSYM_ENSYM
1255 && !flag_debug_only_used_symbols
)
1256 dbxout_stabd (N_BNSYM
, 0);
1258 /* pre-increment the scope counter */
1261 dbxout_source_line (lineno
, filename
, 0, true);
1262 /* Output function begin block at function scope, referenced
1263 by dbxout_block, dbxout_source_line and dbxout_function_end. */
1264 emit_pending_bincls_if_required ();
1265 targetm
.asm_out
.internal_label (asm_out_file
, "LFBB", scope_labelno
);
1268 /* Output a line number symbol entry for source file FILENAME and line
1272 dbxout_source_line (unsigned int lineno
, const char *filename
,
1273 int discriminator ATTRIBUTE_UNUSED
,
1274 bool is_stmt ATTRIBUTE_UNUSED
)
1276 dbxout_source_file (filename
);
1278 #ifdef DBX_OUTPUT_SOURCE_LINE
1279 DBX_OUTPUT_SOURCE_LINE (asm_out_file
, lineno
, dbxout_source_line_counter
);
1281 if (DBX_LINES_FUNCTION_RELATIVE
)
1283 char begin_label
[20];
1284 dbxout_begin_stabn_sline (lineno
);
1285 /* Reference current function start using LFBB. */
1286 ASM_GENERATE_INTERNAL_LABEL (begin_label
, "LFBB", scope_labelno
);
1287 dbxout_stab_value_internal_label_diff ("LM", &dbxout_source_line_counter
,
1291 dbxout_stabd (N_SLINE
, lineno
);
1295 /* Describe the beginning of an internal block within a function. */
1298 dbxout_begin_block (unsigned int line ATTRIBUTE_UNUSED
, unsigned int n
)
1300 emit_pending_bincls_if_required ();
1301 targetm
.asm_out
.internal_label (asm_out_file
, "LBB", n
);
1304 /* Describe the end line-number of an internal block within a function. */
1307 dbxout_end_block (unsigned int line ATTRIBUTE_UNUSED
, unsigned int n
)
1309 emit_pending_bincls_if_required ();
1310 targetm
.asm_out
.internal_label (asm_out_file
, "LBE", n
);
1313 /* Output dbx data for a function definition.
1314 This includes a definition of the function name itself (a symbol),
1315 definitions of the parameters (locating them in the parameter list)
1316 and then output the block that makes up the function's body
1317 (including all the auto variables of the function). */
1320 dbxout_function_decl (tree decl
)
1322 emit_pending_bincls_if_required ();
1323 #ifndef DBX_FUNCTION_FIRST
1324 dbxout_begin_function (decl
);
1326 dbxout_block (DECL_INITIAL (decl
), 0, DECL_ARGUMENTS (decl
));
1327 dbxout_function_end (decl
);
1330 #endif /* DBX_DEBUGGING_INFO */
1333 dbxout_early_global_decl (tree decl ATTRIBUTE_UNUSED
)
1335 /* NYI for non-dwarf. */
1338 /* Debug information for a global DECL. Called from toplev.c after
1339 compilation proper has finished. */
1341 dbxout_late_global_decl (tree decl
)
1343 if (TREE_CODE (decl
) == VAR_DECL
&& !DECL_EXTERNAL (decl
))
1345 int saved_tree_used
= TREE_USED (decl
);
1346 TREE_USED (decl
) = 1;
1347 dbxout_symbol (decl
, 0);
1348 TREE_USED (decl
) = saved_tree_used
;
1352 /* This is just a function-type adapter; dbxout_symbol does exactly
1353 what we want but returns an int. */
1355 dbxout_type_decl (tree decl
, int local
)
1357 dbxout_symbol (decl
, local
);
1360 /* At the end of compilation, finish writing the symbol table.
1361 The default is to call debug_free_queue but do nothing else. */
1364 dbxout_finish (const char *filename ATTRIBUTE_UNUSED
)
1366 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
1367 DBX_OUTPUT_MAIN_SOURCE_FILE_END (asm_out_file
, filename
);
1368 #elif defined DBX_OUTPUT_NULL_N_SO_AT_MAIN_SOURCE_FILE_END
1370 switch_to_section (text_section
);
1371 dbxout_begin_empty_stabs (N_SO
);
1372 dbxout_stab_value_internal_label ("Letext", 0);
1375 debug_free_queue ();
1378 /* Output the index of a type. */
1381 dbxout_type_index (tree type
)
1383 #ifndef DBX_USE_BINCL
1384 stabstr_D (TYPE_SYMTAB_ADDRESS (type
));
1386 struct typeinfo
*t
= &typevec
[TYPE_SYMTAB_ADDRESS (type
)];
1388 stabstr_D (t
->file_number
);
1390 stabstr_D (t
->type_number
);
1396 /* Generate the symbols for any queued up type symbols we encountered
1397 while generating the type info for some originally used symbol.
1398 This might generate additional entries in the queue. Only when
1399 the nesting depth goes to 0 is this routine called. */
1402 debug_flush_symbol_queue (void)
1406 /* Make sure that additionally queued items are not flushed
1411 for (i
= 0; i
< symbol_queue_index
; ++i
)
1413 /* If we pushed queued symbols then such symbols must be
1414 output no matter what anyone else says. Specifically,
1415 we need to make sure dbxout_symbol() thinks the symbol was
1416 used and also we need to override TYPE_DECL_SUPPRESS_DEBUG
1417 which may be set for outside reasons. */
1418 int saved_tree_used
= TREE_USED (symbol_queue
[i
]);
1419 int saved_suppress_debug
= TYPE_DECL_SUPPRESS_DEBUG (symbol_queue
[i
]);
1420 TREE_USED (symbol_queue
[i
]) = 1;
1421 TYPE_DECL_SUPPRESS_DEBUG (symbol_queue
[i
]) = 0;
1423 #ifdef DBX_DEBUGGING_INFO
1424 dbxout_symbol (symbol_queue
[i
], 0);
1427 TREE_USED (symbol_queue
[i
]) = saved_tree_used
;
1428 TYPE_DECL_SUPPRESS_DEBUG (symbol_queue
[i
]) = saved_suppress_debug
;
1431 symbol_queue_index
= 0;
1435 /* Queue a type symbol needed as part of the definition of a decl
1436 symbol. These symbols are generated when debug_flush_symbol_queue()
1440 debug_queue_symbol (tree decl
)
1442 if (symbol_queue_index
>= symbol_queue_size
)
1444 symbol_queue_size
+= 10;
1445 symbol_queue
= XRESIZEVEC (tree
, symbol_queue
, symbol_queue_size
);
1448 symbol_queue
[symbol_queue_index
++] = decl
;
1451 /* Free symbol queue. */
1453 debug_free_queue (void)
1457 free (symbol_queue
);
1458 symbol_queue
= NULL
;
1459 symbol_queue_size
= 0;
1463 /* Used in several places: evaluates to '0' for a private decl,
1464 '1' for a protected decl, '2' for a public decl. */
1465 #define DECL_ACCESSIBILITY_CHAR(DECL) \
1466 (TREE_PRIVATE (DECL) ? '0' : TREE_PROTECTED (DECL) ? '1' : '2')
1468 /* Subroutine of `dbxout_type'. Output the type fields of TYPE.
1469 This must be a separate function because anonymous unions require
1473 dbxout_type_fields (tree type
)
1477 /* Output the name, type, position (in bits), size (in bits) of each
1478 field that we can support. */
1479 for (tem
= TYPE_FIELDS (type
); tem
; tem
= DECL_CHAIN (tem
))
1481 /* If one of the nodes is an error_mark or its type is then
1483 if (error_operand_p (tem
))
1486 /* Omit here local type decls until we know how to support them. */
1487 if (TREE_CODE (tem
) == TYPE_DECL
1488 /* Omit here the nameless fields that are used to skip bits. */
1489 || DECL_IGNORED_P (tem
)
1490 /* Omit fields whose position or size are variable or too large to
1492 || (TREE_CODE (tem
) == FIELD_DECL
1493 && (! tree_fits_shwi_p (bit_position (tem
))
1494 || ! DECL_SIZE (tem
)
1495 || ! tree_fits_uhwi_p (DECL_SIZE (tem
)))))
1498 else if (TREE_CODE (tem
) != CONST_DECL
)
1500 /* Continue the line if necessary,
1501 but not before the first field. */
1502 if (tem
!= TYPE_FIELDS (type
))
1505 if (DECL_NAME (tem
))
1506 stabstr_I (DECL_NAME (tem
));
1509 if (use_gnu_debug_info_extensions
1510 && (TREE_PRIVATE (tem
) || TREE_PROTECTED (tem
)
1511 || TREE_CODE (tem
) != FIELD_DECL
))
1514 stabstr_C (DECL_ACCESSIBILITY_CHAR (tem
));
1517 dbxout_type ((TREE_CODE (tem
) == FIELD_DECL
1518 && DECL_BIT_FIELD_TYPE (tem
))
1519 ? DECL_BIT_FIELD_TYPE (tem
) : TREE_TYPE (tem
), 0);
1521 if (TREE_CODE (tem
) == VAR_DECL
)
1523 if (TREE_STATIC (tem
) && use_gnu_debug_info_extensions
)
1525 tree name
= DECL_ASSEMBLER_NAME (tem
);
1532 /* If TEM is non-static, GDB won't understand it. */
1533 stabstr_S (",0,0;");
1538 stabstr_D (int_bit_position (tem
));
1540 stabstr_D (tree_to_uhwi (DECL_SIZE (tem
)));
1547 /* Subroutine of `dbxout_type_methods'. Output debug info about the
1548 method described DECL. */
1551 dbxout_type_method_1 (tree decl
)
1555 if (TREE_CODE (TREE_TYPE (decl
)) == FUNCTION_TYPE
)
1557 else /* it's a METHOD_TYPE. */
1559 tree firstarg
= TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)));
1560 /* A for normal functions.
1561 B for `const' member functions.
1562 C for `volatile' member functions.
1563 D for `const volatile' member functions. */
1564 if (TYPE_READONLY (TREE_TYPE (firstarg
)))
1566 if (TYPE_VOLATILE (TREE_TYPE (firstarg
)))
1569 if (DECL_VINDEX (decl
))
1575 /* ??? Output the mangled name, which contains an encoding of the
1576 method's type signature. May not be necessary anymore. */
1578 stabstr_I (DECL_ASSEMBLER_NAME (decl
));
1580 stabstr_C (DECL_ACCESSIBILITY_CHAR (decl
));
1584 if (DECL_VINDEX (decl
) && tree_fits_shwi_p (DECL_VINDEX (decl
)))
1586 stabstr_D (tree_to_shwi (DECL_VINDEX (decl
)));
1588 dbxout_type (DECL_CONTEXT (decl
), 0);
1593 /* Subroutine of `dbxout_type'. Output debug info about the methods defined
1597 dbxout_type_methods (tree type
)
1599 /* C++: put out the method names and their parameter lists */
1600 tree methods
= TYPE_METHODS (type
);
1604 if (methods
== NULL_TREE
)
1607 if (TREE_CODE (methods
) != TREE_VEC
)
1609 else if (TREE_VEC_ELT (methods
, 0) != NULL_TREE
)
1610 fndecl
= TREE_VEC_ELT (methods
, 0);
1612 fndecl
= TREE_VEC_ELT (methods
, 1);
1616 int need_prefix
= 1;
1618 /* Group together all the methods for the same operation.
1619 These differ in the types of the arguments. */
1620 for (last
= NULL_TREE
;
1621 fndecl
&& (last
== NULL_TREE
|| DECL_NAME (fndecl
) == DECL_NAME (last
));
1622 fndecl
= DECL_CHAIN (fndecl
))
1623 /* Output the name of the field (after overloading), as
1624 well as the name of the field before overloading, along
1625 with its parameter list */
1627 /* Skip methods that aren't FUNCTION_DECLs. (In C++, these
1628 include TEMPLATE_DECLs.) The debugger doesn't know what
1629 to do with such entities anyhow. */
1630 if (TREE_CODE (fndecl
) != FUNCTION_DECL
)
1637 /* Also ignore abstract methods; those are only interesting to
1638 the DWARF backends. */
1639 if (DECL_IGNORED_P (fndecl
) || DECL_ABSTRACT_P (fndecl
))
1642 /* Redundantly output the plain name, since that's what gdb
1646 stabstr_I (DECL_NAME (fndecl
));
1651 dbxout_type (TREE_TYPE (fndecl
), 0);
1652 dbxout_type_method_1 (fndecl
);
1659 /* Emit a "range" type specification, which has the form:
1660 "r<index type>;<lower bound>;<upper bound>;".
1661 TYPE is an INTEGER_TYPE, LOW and HIGH are the bounds. */
1664 dbxout_range_type (tree type
, tree low
, tree high
)
1667 if (TREE_TYPE (type
))
1668 dbxout_type (TREE_TYPE (type
), 0);
1669 else if (TREE_CODE (type
) != INTEGER_TYPE
)
1670 dbxout_type (type
, 0); /* E.g. Pascal's ARRAY [BOOLEAN] of INTEGER */
1673 /* Traditionally, we made sure 'int' was type 1, and builtin types
1674 were defined to be sub-ranges of int. Unfortunately, this
1675 does not allow us to distinguish true sub-ranges from integer
1676 types. So, instead we define integer (non-sub-range) types as
1677 sub-ranges of themselves. This matters for Chill. If this isn't
1678 a subrange type, then we want to define it in terms of itself.
1679 However, in C, this may be an anonymous integer type, and we don't
1680 want to emit debug info referring to it. Just calling
1681 dbxout_type_index won't work anyways, because the type hasn't been
1682 defined yet. We make this work for both cases by checked to see
1683 whether this is a defined type, referring to it if it is, and using
1685 if (TYPE_SYMTAB_ADDRESS (type
) != 0)
1686 dbxout_type_index (type
);
1688 dbxout_type_index (integer_type_node
);
1692 if (low
&& tree_fits_shwi_p (low
))
1694 if (print_int_cst_bounds_in_octal_p (type
, low
, high
))
1697 stabstr_D (tree_to_shwi (low
));
1703 if (high
&& tree_fits_shwi_p (high
))
1705 if (print_int_cst_bounds_in_octal_p (type
, low
, high
))
1708 stabstr_D (tree_to_shwi (high
));
1716 /* Output a reference to a type. If the type has not yet been
1717 described in the dbx output, output its definition now.
1718 For a type already defined, just refer to its definition
1719 using the type number.
1721 If FULL is nonzero, and the type has been described only with
1722 a forward-reference, output the definition now.
1723 If FULL is zero in this case, just refer to the forward-reference
1724 using the number previously allocated. */
1727 dbxout_type (tree type
, int full
)
1729 static int anonymous_type_number
= 0;
1730 tree tem
, main_variant
, low
, high
;
1732 if (TREE_CODE (type
) == INTEGER_TYPE
)
1734 if (TREE_TYPE (type
) == 0)
1736 low
= TYPE_MIN_VALUE (type
);
1737 high
= TYPE_MAX_VALUE (type
);
1740 else if (subrange_type_for_debug_p (type
, &low
, &high
))
1743 /* If this is a subtype that should not be emitted as a subrange type,
1744 use the base type. */
1747 type
= TREE_TYPE (type
);
1748 low
= TYPE_MIN_VALUE (type
);
1749 high
= TYPE_MAX_VALUE (type
);
1753 /* If there was an input error and we don't really have a type,
1754 avoid crashing and write something that is at least valid
1755 by assuming `int'. */
1756 if (type
== error_mark_node
)
1757 type
= integer_type_node
;
1760 if (TYPE_NAME (type
)
1761 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1762 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type
)))
1766 /* Try to find the "main variant" with the same name. */
1767 if (TYPE_NAME (type
) && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1768 && DECL_ORIGINAL_TYPE (TYPE_NAME (type
)))
1769 main_variant
= TREE_TYPE (TYPE_NAME (type
));
1771 main_variant
= TYPE_MAIN_VARIANT (type
);
1773 /* If we are not using extensions, stabs does not distinguish const and
1774 volatile, so there is no need to make them separate types. */
1775 if (!use_gnu_debug_info_extensions
)
1776 type
= main_variant
;
1778 if (TYPE_SYMTAB_ADDRESS (type
) == 0)
1780 /* Type has no dbx number assigned. Assign next available number. */
1781 TYPE_SYMTAB_ADDRESS (type
) = next_type_number
++;
1783 /* Make sure type vector is long enough to record about this type. */
1785 if (next_type_number
== typevec_len
)
1787 typevec
= GGC_RESIZEVEC (struct typeinfo
, typevec
, typevec_len
* 2);
1788 memset (typevec
+ typevec_len
, 0, typevec_len
* sizeof typevec
[0]);
1792 #ifdef DBX_USE_BINCL
1793 emit_pending_bincls_if_required ();
1794 typevec
[TYPE_SYMTAB_ADDRESS (type
)].file_number
1795 = current_file
->file_number
;
1796 typevec
[TYPE_SYMTAB_ADDRESS (type
)].type_number
1797 = current_file
->next_type_number
++;
1801 if (flag_debug_only_used_symbols
)
1803 if ((TREE_CODE (type
) == RECORD_TYPE
1804 || TREE_CODE (type
) == UNION_TYPE
1805 || TREE_CODE (type
) == QUAL_UNION_TYPE
1806 || TREE_CODE (type
) == ENUMERAL_TYPE
)
1807 && TYPE_STUB_DECL (type
)
1808 && DECL_P (TYPE_STUB_DECL (type
))
1809 && ! DECL_IGNORED_P (TYPE_STUB_DECL (type
)))
1810 debug_queue_symbol (TYPE_STUB_DECL (type
));
1811 else if (TYPE_NAME (type
)
1812 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
1813 debug_queue_symbol (TYPE_NAME (type
));
1816 /* Output the number of this type, to refer to it. */
1817 dbxout_type_index (type
);
1819 #ifdef DBX_TYPE_DEFINED
1820 if (DBX_TYPE_DEFINED (type
))
1824 /* If this type's definition has been output or is now being output,
1827 switch (typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
)
1832 /* If we have already had a cross reference,
1833 and either that's all we want or that's the best we could do,
1834 don't repeat the cross reference.
1835 Sun dbx crashes if we do. */
1836 if (! full
|| !COMPLETE_TYPE_P (type
)
1837 /* No way in DBX fmt to describe a variable size. */
1838 || ! tree_fits_uhwi_p (TYPE_SIZE (type
)))
1846 /* For systems where dbx output does not allow the `=xsNAME:' syntax,
1847 leave the type-number completely undefined rather than output
1848 a cross-reference. If we have already used GNU debug info extensions,
1849 then it is OK to output a cross reference. This is necessary to get
1850 proper C++ debug output. */
1851 if ((TREE_CODE (type
) == RECORD_TYPE
|| TREE_CODE (type
) == UNION_TYPE
1852 || TREE_CODE (type
) == QUAL_UNION_TYPE
1853 || TREE_CODE (type
) == ENUMERAL_TYPE
)
1854 && ! use_gnu_debug_info_extensions
)
1855 /* We must use the same test here as we use twice below when deciding
1856 whether to emit a cross-reference. */
1857 if ((TYPE_NAME (type
) != 0
1858 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1859 && DECL_IGNORED_P (TYPE_NAME (type
)))
1861 || !COMPLETE_TYPE_P (type
)
1862 /* No way in DBX fmt to describe a variable size. */
1863 || ! tree_fits_uhwi_p (TYPE_SIZE (type
)))
1865 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1870 /* Output a definition now. */
1873 /* Mark it as defined, so that if it is self-referent
1874 we will not get into an infinite recursion of definitions. */
1876 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_DEFINED
;
1878 /* If this type is a variant of some other, hand off. Types with
1879 different names are usefully distinguished. We only distinguish
1880 cv-qualified types if we're using extensions. */
1881 if (TYPE_READONLY (type
) > TYPE_READONLY (main_variant
))
1884 dbxout_type (build_type_variant (type
, 0, TYPE_VOLATILE (type
)), 0);
1887 else if (TYPE_VOLATILE (type
) > TYPE_VOLATILE (main_variant
))
1890 dbxout_type (build_type_variant (type
, TYPE_READONLY (type
), 0), 0);
1893 else if (main_variant
!= TYPE_MAIN_VARIANT (type
))
1895 if (flag_debug_only_used_symbols
)
1897 tree orig_type
= DECL_ORIGINAL_TYPE (TYPE_NAME (type
));
1899 if ((TREE_CODE (orig_type
) == RECORD_TYPE
1900 || TREE_CODE (orig_type
) == UNION_TYPE
1901 || TREE_CODE (orig_type
) == QUAL_UNION_TYPE
1902 || TREE_CODE (orig_type
) == ENUMERAL_TYPE
)
1903 && TYPE_STUB_DECL (orig_type
)
1904 && ! DECL_IGNORED_P (TYPE_STUB_DECL (orig_type
)))
1905 debug_queue_symbol (TYPE_STUB_DECL (orig_type
));
1907 /* 'type' is a typedef; output the type it refers to. */
1908 dbxout_type (DECL_ORIGINAL_TYPE (TYPE_NAME (type
)), 0);
1911 /* else continue. */
1913 switch (TREE_CODE (type
))
1918 /* For a void type, just define it as itself; i.e., "5=5".
1919 This makes us consider it defined
1920 without saying what it is. The debugger will make it
1921 a void type when the reference is seen, and nothing will
1922 ever override that default. */
1923 dbxout_type_index (type
);
1927 if (type
== char_type_node
&& ! TYPE_UNSIGNED (type
))
1929 /* Output the type `char' as a subrange of itself!
1930 I don't understand this definition, just copied it
1931 from the output of pcc.
1932 This used to use `r2' explicitly and we used to
1933 take care to make sure that `char' was type number 2. */
1935 dbxout_type_index (type
);
1936 stabstr_S (";0;127;");
1939 /* If this is a subtype of another integer type, always prefer to
1940 write it as a subtype. */
1941 else if (TREE_TYPE (type
) != 0
1942 && TREE_CODE (TREE_TYPE (type
)) == INTEGER_TYPE
)
1944 /* If the size is non-standard, say what it is if we can use
1947 if (use_gnu_debug_info_extensions
1948 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
1951 stabstr_D (TYPE_PRECISION (type
));
1955 dbxout_range_type (type
, low
, high
);
1960 /* If the size is non-standard, say what it is if we can use
1963 if (use_gnu_debug_info_extensions
1964 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
1967 stabstr_D (TYPE_PRECISION (type
));
1971 if (print_int_cst_bounds_in_octal_p (type
, low
, high
))
1975 /* If this type derives from another type, output type index of
1976 parent type. This is particularly important when parent type
1977 is an enumerated type, because not generating the parent type
1978 index would transform the definition of this enumerated type
1979 into a plain unsigned type. */
1980 if (TREE_TYPE (type
) != 0)
1981 dbxout_type_index (TREE_TYPE (type
));
1983 dbxout_type_index (type
);
1993 /* Output other integer types as subranges of `int'. */
1994 dbxout_range_type (type
, low
, high
);
2000 case FIXED_POINT_TYPE
:
2001 /* This used to say `r1' and we used to take care
2002 to make sure that `int' was type number 1. */
2004 dbxout_type_index (integer_type_node
);
2006 stabstr_D (int_size_in_bytes (type
));
2011 if (use_gnu_debug_info_extensions
)
2014 stabstr_D (BITS_PER_UNIT
* int_size_in_bytes (type
));
2015 stabstr_S (";-16;");
2017 else /* Define as enumeral type (False, True) */
2018 stabstr_S ("eFalse:0,True:1,;");
2022 /* Differs from the REAL_TYPE by its new data type number.
2023 R3 is NF_COMPLEX. We don't try to use any of the other NF_*
2024 codes since gdb doesn't care anyway. */
2026 if (TREE_CODE (TREE_TYPE (type
)) == REAL_TYPE
)
2029 stabstr_D (2 * int_size_in_bytes (TREE_TYPE (type
)));
2034 /* Output a complex integer type as a structure,
2035 pending some other way to do it. */
2037 stabstr_D (int_size_in_bytes (type
));
2039 stabstr_S ("real:");
2040 dbxout_type (TREE_TYPE (type
), 0);
2042 stabstr_D (TYPE_PRECISION (TREE_TYPE (type
)));
2044 stabstr_S (";imag:");
2045 dbxout_type (TREE_TYPE (type
), 0);
2047 stabstr_D (TYPE_PRECISION (TREE_TYPE (type
)));
2049 stabstr_D (TYPE_PRECISION (TREE_TYPE (type
)));
2055 /* Make arrays of packed bits look like bitstrings for chill. */
2056 if (TYPE_PACKED (type
) && use_gnu_debug_info_extensions
)
2059 stabstr_D (BITS_PER_UNIT
* int_size_in_bytes (type
));
2060 stabstr_S (";@S;S");
2061 dbxout_type (TYPE_DOMAIN (type
), 0);
2065 /* Output "a" followed by a range type definition
2066 for the index type of the array
2067 followed by a reference to the target-type.
2068 ar1;0;N;M for a C array of type M and size N+1. */
2069 /* Check if a character string type, which in Chill is
2070 different from an array of characters. */
2071 if (TYPE_STRING_FLAG (type
) && use_gnu_debug_info_extensions
)
2075 tem
= TYPE_DOMAIN (type
);
2079 dbxout_type_index (integer_type_node
);
2080 stabstr_S (";0;-1;");
2085 dbxout_range_type (tem
, TYPE_MIN_VALUE (tem
), TYPE_MAX_VALUE (tem
));
2088 dbxout_type (TREE_TYPE (type
), 0);
2092 /* Make vectors look like an array. */
2093 if (use_gnu_debug_info_extensions
)
2096 /* Output "a" followed by a range type definition
2097 for the index type of the array
2098 followed by a reference to the target-type.
2099 ar1;0;N;M for a C array of type M and size N+1. */
2101 dbxout_range_type (integer_type_node
, size_zero_node
,
2102 size_int (TYPE_VECTOR_SUBPARTS (type
) - 1));
2104 dbxout_type (TREE_TYPE (type
), 0);
2109 case QUAL_UNION_TYPE
:
2111 tree binfo
= TYPE_BINFO (type
);
2113 /* Output a structure type. We must use the same test here as we
2114 use in the DBX_NO_XREFS case above. */
2115 if ((TYPE_NAME (type
) != 0
2116 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
2117 && DECL_IGNORED_P (TYPE_NAME (type
)))
2119 || !COMPLETE_TYPE_P (type
)
2120 /* No way in DBX fmt to describe a variable size. */
2121 || ! tree_fits_uhwi_p (TYPE_SIZE (type
)))
2123 /* If the type is just a cross reference, output one
2124 and mark the type as partially described.
2125 If it later becomes defined, we will output
2126 its real definition.
2127 If the type has a name, don't nest its definition within
2128 another type's definition; instead, output an xref
2129 and let the definition come when the name is defined. */
2130 stabstr_S ((TREE_CODE (type
) == RECORD_TYPE
) ? "xs" : "xu");
2131 if (TYPE_IDENTIFIER (type
))
2133 /* Note that the C frontend creates for anonymous variable
2134 length records/unions TYPE_NAME with DECL_NAME NULL. */
2135 dbxout_type_name (type
);
2140 stabstr_D (anonymous_type_number
++);
2144 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
2148 /* Identify record or union, and print its size. */
2149 stabstr_C ((TREE_CODE (type
) == RECORD_TYPE
) ? 's' : 'u');
2150 stabstr_D (int_size_in_bytes (type
));
2156 vec
<tree
, va_gc
> *accesses
= BINFO_BASE_ACCESSES (binfo
);
2158 if (use_gnu_debug_info_extensions
)
2160 if (BINFO_N_BASE_BINFOS (binfo
))
2163 stabstr_U (BINFO_N_BASE_BINFOS (binfo
));
2167 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, child
); i
++)
2169 tree access
= (accesses
? (*accesses
)[i
] : access_public_node
);
2171 if (use_gnu_debug_info_extensions
)
2173 stabstr_C (BINFO_VIRTUAL_P (child
) ? '1' : '0');
2174 stabstr_C (access
== access_public_node
? '2' :
2175 access
== access_protected_node
2177 if (BINFO_VIRTUAL_P (child
)
2179 || strcmp (lang_hooks
.name
, "GNU Objective-C++") == 0))
2180 /* For a virtual base, print the (negative)
2181 offset within the vtable where we must look
2182 to find the necessary adjustment. */
2184 (tree_to_shwi (BINFO_VPTR_FIELD (child
))
2187 stabstr_D (tree_to_shwi (BINFO_OFFSET (child
))
2190 dbxout_type (BINFO_TYPE (child
), 0);
2195 /* Print out the base class information with
2196 fields which have the same names at the types
2198 dbxout_type_name (BINFO_TYPE (child
));
2200 dbxout_type (BINFO_TYPE (child
), full
);
2202 stabstr_D (tree_to_shwi (BINFO_OFFSET (child
))
2206 (tree_to_shwi (TYPE_SIZE (BINFO_TYPE (child
)))
2214 /* Write out the field declarations. */
2215 dbxout_type_fields (type
);
2216 if (use_gnu_debug_info_extensions
&& TYPE_METHODS (type
) != NULL_TREE
)
2218 dbxout_type_methods (type
);
2223 if (use_gnu_debug_info_extensions
&& TREE_CODE (type
) == RECORD_TYPE
2224 /* Avoid the ~ if we don't really need it--it confuses dbx. */
2225 && TYPE_VFIELD (type
))
2228 /* We need to write out info about what field this class
2229 uses as its "main" vtable pointer field, because if this
2230 field is inherited from a base class, GDB cannot necessarily
2231 figure out which field it's using in time. */
2233 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type
)), 0);
2239 /* We must use the same test here as we use in the DBX_NO_XREFS case
2240 above. We simplify it a bit since an enum will never have a variable
2242 if ((TYPE_NAME (type
) != 0
2243 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
2244 && DECL_IGNORED_P (TYPE_NAME (type
)))
2246 || !COMPLETE_TYPE_P (type
))
2249 dbxout_type_name (type
);
2250 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
2254 if (use_gnu_debug_info_extensions
2255 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
2258 stabstr_D (TYPE_PRECISION (type
));
2263 for (tem
= TYPE_VALUES (type
); tem
; tem
= TREE_CHAIN (tem
))
2265 tree value
= TREE_VALUE (tem
);
2267 stabstr_I (TREE_PURPOSE (tem
));
2270 if (TREE_CODE (value
) == CONST_DECL
)
2271 value
= DECL_INITIAL (value
);
2273 if (cst_and_fits_in_hwi (value
))
2274 stabstr_D (TREE_INT_CST_LOW (value
));
2279 if (TREE_CHAIN (tem
) != 0)
2288 dbxout_type (TREE_TYPE (type
), 0);
2292 if (use_gnu_debug_info_extensions
)
2296 /* Write the argument types out longhand. */
2297 dbxout_type (TYPE_METHOD_BASETYPE (type
), 0);
2299 dbxout_type (TREE_TYPE (type
), 0);
2300 dbxout_args (TYPE_ARG_TYPES (type
));
2304 /* Treat it as a function type. */
2305 dbxout_type (TREE_TYPE (type
), 0);
2309 if (use_gnu_debug_info_extensions
)
2312 dbxout_type (TYPE_OFFSET_BASETYPE (type
), 0);
2314 dbxout_type (TREE_TYPE (type
), 0);
2317 /* Should print as an int, because it is really just an offset. */
2318 dbxout_type (integer_type_node
, 0);
2321 case REFERENCE_TYPE
:
2322 if (use_gnu_debug_info_extensions
)
2328 dbxout_type (TREE_TYPE (type
), 0);
2333 dbxout_type (TREE_TYPE (type
), 0);
2336 case POINTER_BOUNDS_TYPE
:
2337 /* No debug info for pointer bounds type supported yet. */
2341 /* A C++ function with deduced return type can have a TEMPLATE_TYPE_PARM
2342 named 'auto' in its type.
2343 No debug info for TEMPLATE_TYPE_PARM type supported yet. */
2344 if (lang_GNU_CXX ())
2346 tree name
= TYPE_IDENTIFIER (type
);
2347 if (name
== get_identifier ("auto")
2348 || name
== get_identifier ("decltype(auto)"))
2356 /* Return nonzero if the given type represents an integer whose bounds
2357 should be printed in octal format. */
2360 print_int_cst_bounds_in_octal_p (tree type
, tree low
, tree high
)
2362 /* If we can use GDB extensions and the size is wider than a long
2363 (the size used by GDB to read them) or we may have trouble writing
2364 the bounds the usual way, write them in octal. Note the test is for
2365 the *target's* size of "long", not that of the host. The host test
2366 is just to make sure we can write it out in case the host wide int
2367 is narrower than the target "long".
2369 For unsigned types, we use octal if they are the same size or larger.
2370 This is because we print the bounds as signed decimal, and hence they
2371 can't span same size unsigned types. */
2373 if (use_gnu_debug_info_extensions
2374 && low
&& TREE_CODE (low
) == INTEGER_CST
2375 && high
&& TREE_CODE (high
) == INTEGER_CST
2376 && (TYPE_PRECISION (type
) > TYPE_PRECISION (integer_type_node
)
2377 || ((TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
))
2378 && TYPE_UNSIGNED (type
))
2379 || TYPE_PRECISION (type
) > HOST_BITS_PER_WIDE_INT
2380 || (TYPE_PRECISION (type
) == HOST_BITS_PER_WIDE_INT
2381 && TYPE_UNSIGNED (type
))))
2387 /* Output the name of type TYPE, with no punctuation.
2388 Such names can be set up either by typedef declarations
2389 or by struct, enum and union tags. */
2392 dbxout_type_name (tree type
)
2394 tree t
= TYPE_NAME (type
);
2397 switch (TREE_CODE (t
))
2399 case IDENTIFIER_NODE
:
2411 /* Output leading struct or class names needed for qualifying type
2412 whose scope is limited to a struct or class. */
2415 dbxout_class_name_qualifiers (tree decl
)
2417 tree context
= decl_type_context (decl
);
2419 if (context
!= NULL_TREE
2420 && TREE_CODE (context
) == RECORD_TYPE
2421 && TYPE_NAME (context
) != 0
2422 && (TREE_CODE (TYPE_NAME (context
)) == IDENTIFIER_NODE
2423 || (DECL_NAME (TYPE_NAME (context
)) != 0)))
2425 tree name
= TYPE_NAME (context
);
2427 if (TREE_CODE (name
) == TYPE_DECL
)
2429 dbxout_class_name_qualifiers (name
);
2430 name
= DECL_NAME (name
);
2437 /* This is a specialized subset of expand_expr for use by dbxout_symbol in
2438 evaluating DECL_VALUE_EXPR. In particular, we stop if we find decls that
2439 haven't been expanded, or if the expression is getting so complex we won't
2440 be able to represent it in stabs anyway. Returns NULL on failure. */
2443 dbxout_expand_expr (tree expr
)
2445 switch (TREE_CODE (expr
))
2448 /* We can't handle emulated tls variables, because the address is an
2449 offset to the return value of __emutls_get_address, and there is no
2450 way to express that in stabs. Also, there are name mangling issues
2451 here. We end up with references to undefined symbols if we don't
2452 disable debug info for these variables. */
2453 if (!targetm
.have_tls
&& DECL_THREAD_LOCAL_P (expr
))
2455 if (TREE_STATIC (expr
)
2456 && !TREE_ASM_WRITTEN (expr
)
2457 && !DECL_HAS_VALUE_EXPR_P (expr
)
2458 && !TREE_PUBLIC (expr
)
2459 && DECL_RTL_SET_P (expr
)
2460 && MEM_P (DECL_RTL (expr
)))
2462 /* If this is a var that might not be actually output,
2463 return NULL, otherwise stabs might reference an undefined
2465 varpool_node
*node
= varpool_node::get (expr
);
2466 if (!node
|| !node
->definition
)
2473 if (DECL_HAS_VALUE_EXPR_P (expr
))
2474 return dbxout_expand_expr (DECL_VALUE_EXPR (expr
));
2478 return DECL_RTL_IF_SET (expr
);
2481 return expand_expr (expr
, NULL_RTX
, VOIDmode
, EXPAND_INITIALIZER
);
2485 case ARRAY_RANGE_REF
:
2489 HOST_WIDE_INT bitsize
, bitpos
;
2491 int volatilep
= 0, unsignedp
= 0;
2494 tem
= get_inner_reference (expr
, &bitsize
, &bitpos
, &offset
,
2495 &mode
, &unsignedp
, &volatilep
, true);
2497 x
= dbxout_expand_expr (tem
);
2498 if (x
== NULL
|| !MEM_P (x
))
2502 if (!tree_fits_shwi_p (offset
))
2504 x
= adjust_address_nv (x
, mode
, tree_to_shwi (offset
));
2507 x
= adjust_address_nv (x
, mode
, bitpos
/ BITS_PER_UNIT
);
2517 /* Helper function for output_used_types. Queue one entry from the
2518 used types hash to be output. */
2521 output_used_types_helper (tree
const &type
, vec
<tree
> *types_p
)
2523 if ((TREE_CODE (type
) == RECORD_TYPE
2524 || TREE_CODE (type
) == UNION_TYPE
2525 || TREE_CODE (type
) == QUAL_UNION_TYPE
2526 || TREE_CODE (type
) == ENUMERAL_TYPE
)
2527 && TYPE_STUB_DECL (type
)
2528 && DECL_P (TYPE_STUB_DECL (type
))
2529 && ! DECL_IGNORED_P (TYPE_STUB_DECL (type
)))
2530 types_p
->quick_push (TYPE_STUB_DECL (type
));
2531 else if (TYPE_NAME (type
)
2532 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
2533 types_p
->quick_push (TYPE_NAME (type
));
2538 /* This is a qsort callback which sorts types and declarations into a
2539 predictable order (types, then declarations, sorted by UID
2543 output_types_sort (const void *pa
, const void *pb
)
2545 const tree lhs
= *((const tree
*)pa
);
2546 const tree rhs
= *((const tree
*)pb
);
2551 return TYPE_UID (lhs
) - TYPE_UID (rhs
);
2560 return DECL_UID (lhs
) - DECL_UID (rhs
);
2565 /* Force all types used by this function to be output in debug
2569 output_used_types (void)
2571 if (cfun
&& cfun
->used_types_hash
)
2577 types
.create (cfun
->used_types_hash
->elements ());
2578 cfun
->used_types_hash
->traverse
<vec
<tree
> *, output_used_types_helper
>
2581 /* Sort by UID to prevent dependence on hash table ordering. */
2582 types
.qsort (output_types_sort
);
2584 FOR_EACH_VEC_ELT (types
, i
, type
)
2585 debug_queue_symbol (type
);
2591 /* Output a .stabs for the symbol defined by DECL,
2592 which must be a ..._DECL node in the normal namespace.
2593 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
2594 LOCAL is nonzero if the scope is less than the entire file.
2595 Return 1 if a stabs might have been emitted. */
2598 dbxout_symbol (tree decl
, int local ATTRIBUTE_UNUSED
)
2600 tree type
= TREE_TYPE (decl
);
2601 tree context
= NULL_TREE
;
2605 /* "Intercept" dbxout_symbol() calls like we do all debug_hooks. */
2608 /* Ignore nameless syms, but don't ignore type tags. */
2610 if ((DECL_NAME (decl
) == 0 && TREE_CODE (decl
) != TYPE_DECL
)
2611 || DECL_IGNORED_P (decl
))
2612 DBXOUT_DECR_NESTING_AND_RETURN (0);
2614 /* If we are to generate only the symbols actually used then such
2615 symbol nodes are flagged with TREE_USED. Ignore any that
2616 aren't flagged as TREE_USED. */
2618 if (flag_debug_only_used_symbols
2619 && (!TREE_USED (decl
)
2620 && (TREE_CODE (decl
) != VAR_DECL
|| !DECL_INITIAL (decl
))))
2621 DBXOUT_DECR_NESTING_AND_RETURN (0);
2623 /* If dbxout_init has not yet run, queue this symbol for later. */
2626 preinit_symbols
= tree_cons (0, decl
, preinit_symbols
);
2627 DBXOUT_DECR_NESTING_AND_RETURN (0);
2630 if (flag_debug_only_used_symbols
)
2634 /* We now have a used symbol. We need to generate the info for
2635 the symbol's type in addition to the symbol itself. These
2636 type symbols are queued to be generated after were done with
2637 the symbol itself (otherwise they would fight over the
2640 Note, because the TREE_TYPE(type) might be something like a
2641 pointer to a named type we need to look for the first name
2642 we see following the TREE_TYPE chain. */
2645 while (POINTER_TYPE_P (t
))
2648 /* RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, and ENUMERAL_TYPE
2649 need special treatment. The TYPE_STUB_DECL field in these
2650 types generally represents the tag name type we want to
2651 output. In addition there could be a typedef type with
2652 a different name. In that case we also want to output
2655 if (TREE_CODE (t
) == RECORD_TYPE
2656 || TREE_CODE (t
) == UNION_TYPE
2657 || TREE_CODE (t
) == QUAL_UNION_TYPE
2658 || TREE_CODE (t
) == ENUMERAL_TYPE
)
2660 if (TYPE_STUB_DECL (t
)
2661 && TYPE_STUB_DECL (t
) != decl
2662 && DECL_P (TYPE_STUB_DECL (t
))
2663 && ! DECL_IGNORED_P (TYPE_STUB_DECL (t
)))
2665 debug_queue_symbol (TYPE_STUB_DECL (t
));
2667 && TYPE_NAME (t
) != TYPE_STUB_DECL (t
)
2668 && TYPE_NAME (t
) != decl
2669 && DECL_P (TYPE_NAME (t
)))
2670 debug_queue_symbol (TYPE_NAME (t
));
2673 else if (TYPE_NAME (t
)
2674 && TYPE_NAME (t
) != decl
2675 && DECL_P (TYPE_NAME (t
)))
2676 debug_queue_symbol (TYPE_NAME (t
));
2679 emit_pending_bincls_if_required ();
2681 switch (TREE_CODE (decl
))
2684 /* Enum values are defined by defining the enum type. */
2688 decl_rtl
= DECL_RTL_IF_SET (decl
);
2690 DBXOUT_DECR_NESTING_AND_RETURN (0);
2691 if (DECL_EXTERNAL (decl
))
2693 /* Don't mention a nested function under its parent. */
2694 context
= decl_function_context (decl
);
2695 if (context
== current_function_decl
)
2697 /* Don't mention an inline instance of a nested function. */
2698 if (context
&& DECL_FROM_INLINE (decl
))
2700 if (!MEM_P (decl_rtl
)
2701 || GET_CODE (XEXP (decl_rtl
, 0)) != SYMBOL_REF
)
2704 if (flag_debug_only_used_symbols
)
2705 output_used_types ();
2707 dbxout_begin_complex_stabs ();
2708 stabstr_I (DECL_ASSEMBLER_NAME (decl
));
2709 stabstr_S (TREE_PUBLIC (decl
) ? ":F" : ":f");
2712 if (TREE_TYPE (type
))
2713 dbxout_type (TREE_TYPE (type
), 0);
2715 dbxout_type (void_type_node
, 0);
2717 /* For a nested function, when that function is compiled,
2718 mention the containing function name
2719 as well as (since dbx wants it) our own assembler-name. */
2723 stabstr_I (DECL_ASSEMBLER_NAME (decl
));
2725 stabstr_I (DECL_NAME (context
));
2728 dbxout_finish_complex_stabs (decl
, N_FUN
, XEXP (decl_rtl
, 0), 0, 0);
2732 /* Don't output the same typedef twice.
2733 And don't output what language-specific stuff doesn't want output. */
2734 if (TREE_ASM_WRITTEN (decl
) || TYPE_DECL_SUPPRESS_DEBUG (decl
))
2735 DBXOUT_DECR_NESTING_AND_RETURN (0);
2737 /* Don't output typedefs for types with magic type numbers (XCOFF). */
2738 #ifdef DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER
2740 int fundamental_type_number
=
2741 DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER (decl
);
2743 if (fundamental_type_number
!= 0)
2745 TREE_ASM_WRITTEN (decl
) = 1;
2746 TYPE_SYMTAB_ADDRESS (TREE_TYPE (decl
)) = fundamental_type_number
;
2747 DBXOUT_DECR_NESTING_AND_RETURN (0);
2757 if (DECL_NAME (decl
))
2759 /* Nonzero means we must output a tag as well as a typedef. */
2762 /* Handle the case of a C++ structure or union
2763 where the TYPE_NAME is a TYPE_DECL
2764 which gives both a typedef name and a tag. */
2765 /* dbx requires the tag first and the typedef second. */
2766 if ((TREE_CODE (type
) == RECORD_TYPE
2767 || TREE_CODE (type
) == UNION_TYPE
2768 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
2769 && TYPE_NAME (type
) == decl
2770 && !use_gnu_debug_info_extensions
2771 && !TREE_ASM_WRITTEN (TYPE_NAME (type
))
2772 /* Distinguish the implicit typedefs of C++
2773 from explicit ones that might be found in C. */
2774 && DECL_ARTIFICIAL (decl
)
2775 /* Do not generate a tag for incomplete records. */
2776 && COMPLETE_TYPE_P (type
)
2777 /* Do not generate a tag for records of variable size,
2778 since this type can not be properly described in the
2779 DBX format, and it confuses some tools such as objdump. */
2780 && tree_fits_uhwi_p (TYPE_SIZE (type
)))
2782 tree name
= TYPE_IDENTIFIER (type
);
2784 dbxout_begin_complex_stabs ();
2787 dbxout_type (type
, 1);
2788 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE
,
2792 dbxout_begin_complex_stabs ();
2794 /* Output leading class/struct qualifiers. */
2795 if (use_gnu_debug_info_extensions
)
2796 dbxout_class_name_qualifiers (decl
);
2798 /* Output typedef name. */
2799 stabstr_I (DECL_NAME (decl
));
2802 /* Short cut way to output a tag also. */
2803 if ((TREE_CODE (type
) == RECORD_TYPE
2804 || TREE_CODE (type
) == UNION_TYPE
2805 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
2806 && TYPE_NAME (type
) == decl
2807 /* Distinguish the implicit typedefs of C++
2808 from explicit ones that might be found in C. */
2809 && DECL_ARTIFICIAL (decl
))
2811 if (use_gnu_debug_info_extensions
)
2814 TREE_ASM_WRITTEN (TYPE_NAME (type
)) = 1;
2819 dbxout_type (type
, 1);
2820 dbxout_finish_complex_stabs (decl
, DBX_TYPE_DECL_STABS_CODE
,
2825 /* Don't output a tag if this is an incomplete type. This prevents
2826 the sun4 Sun OS 4.x dbx from crashing. */
2828 if (tag_needed
&& TYPE_NAME (type
) != 0
2829 && (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
2830 || (DECL_NAME (TYPE_NAME (type
)) != 0))
2831 && COMPLETE_TYPE_P (type
)
2832 && !TREE_ASM_WRITTEN (TYPE_NAME (type
)))
2834 /* For a TYPE_DECL with no name, but the type has a name,
2836 This is what represents `struct foo' with no typedef. */
2837 /* In C++, the name of a type is the corresponding typedef.
2838 In C, it is an IDENTIFIER_NODE. */
2839 tree name
= TYPE_IDENTIFIER (type
);
2841 dbxout_begin_complex_stabs ();
2844 dbxout_type (type
, 1);
2845 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE
, 0, 0, 0);
2849 /* If an enum type has no name, it cannot be referred to, but
2850 we must output it anyway, to record the enumeration
2853 if (!did_output
&& TREE_CODE (type
) == ENUMERAL_TYPE
)
2855 dbxout_begin_complex_stabs ();
2856 /* Some debuggers fail when given NULL names, so give this a
2857 harmless name of " " (Why not "(anon)"?). */
2859 dbxout_type (type
, 1);
2860 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE
, 0, 0, 0);
2863 /* Prevent duplicate output of a typedef. */
2864 TREE_ASM_WRITTEN (decl
) = 1;
2869 if (DECL_HAS_VALUE_EXPR_P (decl
))
2870 decl
= DECL_VALUE_EXPR (decl
);
2872 /* PARM_DECLs go in their own separate chain and are output by
2873 dbxout_reg_parms and dbxout_parms, except for those that are
2874 disguised VAR_DECLs like Out parameters in Ada. */
2875 gcc_assert (TREE_CODE (decl
) == VAR_DECL
);
2877 /* ... fall through ... */
2881 /* Don't mention a variable that is external.
2882 Let the file that defines it describe it. */
2883 if (DECL_EXTERNAL (decl
))
2886 /* If the variable is really a constant
2887 and not written in memory, inform the debugger.
2889 ??? Why do we skip emitting the type and location in this case? */
2890 if (TREE_STATIC (decl
) && TREE_READONLY (decl
)
2891 && DECL_INITIAL (decl
) != 0
2892 && tree_fits_shwi_p (DECL_INITIAL (decl
))
2893 && ! TREE_ASM_WRITTEN (decl
)
2894 && (DECL_FILE_SCOPE_P (decl
)
2895 || TREE_CODE (DECL_CONTEXT (decl
)) == BLOCK
2896 || TREE_CODE (DECL_CONTEXT (decl
)) == NAMESPACE_DECL
)
2897 && TREE_PUBLIC (decl
) == 0)
2899 /* The sun4 assembler does not grok this. */
2901 if (TREE_CODE (TREE_TYPE (decl
)) == INTEGER_TYPE
2902 || TREE_CODE (TREE_TYPE (decl
)) == ENUMERAL_TYPE
)
2904 HOST_WIDE_INT ival
= tree_to_shwi (DECL_INITIAL (decl
));
2906 dbxout_begin_complex_stabs ();
2907 dbxout_symbol_name (decl
, NULL
, 'c');
2910 dbxout_finish_complex_stabs (0, N_LSYM
, 0, 0, 0);
2911 DBXOUT_DECR_NESTING
;
2917 /* else it is something we handle like a normal variable. */
2919 decl_rtl
= dbxout_expand_expr (decl
);
2921 DBXOUT_DECR_NESTING_AND_RETURN (0);
2923 if (!is_global_var (decl
))
2924 decl_rtl
= eliminate_regs (decl_rtl
, VOIDmode
, NULL_RTX
);
2925 #ifdef LEAF_REG_REMAP
2926 if (crtl
->uses_only_leaf_regs
)
2927 leaf_renumber_regs_insn (decl_rtl
);
2930 result
= dbxout_symbol_location (decl
, type
, 0, decl_rtl
);
2936 DBXOUT_DECR_NESTING
;
2940 /* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL.
2941 Add SUFFIX to its name, if SUFFIX is not 0.
2942 Describe the variable as residing in HOME
2943 (usually HOME is DECL_RTL (DECL), but not always).
2944 Returns 1 if the stab was really emitted. */
2947 dbxout_symbol_location (tree decl
, tree type
, const char *suffix
, rtx home
)
2950 stab_code_type code
;
2955 /* Don't mention a variable at all
2956 if it was completely optimized into nothingness.
2958 If the decl was from an inline function, then its rtl
2959 is not identically the rtl that was used in this
2960 particular compilation. */
2961 if (GET_CODE (home
) == SUBREG
)
2965 while (GET_CODE (value
) == SUBREG
)
2966 value
= SUBREG_REG (value
);
2969 if (REGNO (value
) >= FIRST_PSEUDO_REGISTER
)
2972 home
= alter_subreg (&home
, true);
2976 regno
= REGNO (home
);
2977 if (regno
>= FIRST_PSEUDO_REGISTER
)
2981 /* The kind-of-variable letter depends on where
2982 the variable is and on the scope of its name:
2983 G and N_GSYM for static storage and global scope,
2984 S for static storage and file scope,
2985 V for static storage and local scope,
2986 for those two, use N_LCSYM if data is in bss segment,
2987 N_STSYM if in data segment, N_FUN otherwise.
2988 (We used N_FUN originally, then changed to N_STSYM
2989 to please GDB. However, it seems that confused ld.
2990 Now GDB has been fixed to like N_FUN, says Kingdon.)
2991 no letter at all, and N_LSYM, for auto variable,
2992 r and N_RSYM for register variable. */
2994 if (MEM_P (home
) && GET_CODE (XEXP (home
, 0)) == SYMBOL_REF
)
2996 if (TREE_PUBLIC (decl
))
3001 if (NULL
!= dbxout_common_check (decl
, &offs
))
3010 addr
= XEXP (home
, 0);
3012 letter
= decl_function_context (decl
) ? 'V' : 'S';
3014 /* Some ports can transform a symbol ref into a label ref,
3015 because the symbol ref is too far away and has to be
3016 dumped into a constant pool. Alternatively, the symbol
3017 in the constant pool might be referenced by a different
3019 if (GET_CODE (addr
) == SYMBOL_REF
3020 && CONSTANT_POOL_ADDRESS_P (addr
))
3023 rtx tmp
= get_pool_constant_mark (addr
, &marked
);
3025 if (GET_CODE (tmp
) == SYMBOL_REF
)
3028 if (CONSTANT_POOL_ADDRESS_P (addr
))
3029 get_pool_constant_mark (addr
, &marked
);
3033 else if (GET_CODE (tmp
) == LABEL_REF
)
3039 /* If all references to the constant pool were optimized
3040 out, we just ignore the symbol. */
3045 /* This should be the same condition as in assemble_variable, but
3046 we don't have access to dont_output_data here. So, instead,
3047 we rely on the fact that error_mark_node initializers always
3048 end up in bss for C++ and never end up in bss for C. */
3049 if (DECL_INITIAL (decl
) == 0
3051 && DECL_INITIAL (decl
) == error_mark_node
))
3055 if (NULL
!= dbxout_common_check (decl
, &offs
))
3063 else if (DECL_IN_TEXT_SECTION (decl
))
3064 /* This is not quite right, but it's the closest
3065 of all the codes that Unix defines. */
3066 code
= DBX_STATIC_CONST_VAR_CODE
;
3069 /* Ultrix `as' seems to need this. */
3070 #ifdef DBX_STATIC_STAB_DATA_SECTION
3071 switch_to_section (data_section
);
3077 else if (regno
>= 0)
3081 number
= DBX_REGISTER_NUMBER (regno
);
3083 else if (MEM_P (home
)
3084 && (MEM_P (XEXP (home
, 0))
3085 || (REG_P (XEXP (home
, 0))
3086 && REGNO (XEXP (home
, 0)) != HARD_FRAME_POINTER_REGNUM
3087 && REGNO (XEXP (home
, 0)) != STACK_POINTER_REGNUM
3088 #if !HARD_FRAME_POINTER_IS_ARG_POINTER
3089 && REGNO (XEXP (home
, 0)) != ARG_POINTER_REGNUM
3092 /* If the value is indirect by memory or by a register
3093 that isn't the frame pointer
3094 then it means the object is variable-sized and address through
3095 that register or stack slot. DBX has no way to represent this
3096 so all we can do is output the variable as a pointer.
3097 If it's not a parameter, ignore it. */
3099 if (REG_P (XEXP (home
, 0)))
3103 if (REGNO (XEXP (home
, 0)) >= FIRST_PSEUDO_REGISTER
)
3105 number
= DBX_REGISTER_NUMBER (REGNO (XEXP (home
, 0)));
3110 /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
3111 We want the value of that CONST_INT. */
3112 number
= DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home
, 0), 0));
3115 /* Effectively do build_pointer_type, but don't cache this type,
3116 since it might be temporary whereas the type it points to
3117 might have been saved for inlining. */
3118 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
3119 type
= make_node (POINTER_TYPE
);
3120 TREE_TYPE (type
) = TREE_TYPE (decl
);
3122 else if (MEM_P (home
)
3123 && REG_P (XEXP (home
, 0)))
3126 number
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
3128 else if (MEM_P (home
)
3129 && GET_CODE (XEXP (home
, 0)) == PLUS
3130 && CONST_INT_P (XEXP (XEXP (home
, 0), 1)))
3133 /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
3134 We want the value of that CONST_INT. */
3135 number
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
3137 else if (MEM_P (home
)
3138 && GET_CODE (XEXP (home
, 0)) == CONST
)
3140 /* Handle an obscure case which can arise when optimizing and
3141 when there are few available registers. (This is *always*
3142 the case for i386/i486 targets). The RTL looks like
3143 (MEM (CONST ...)) even though this variable is a local `auto'
3144 or a local `register' variable. In effect, what has happened
3145 is that the reload pass has seen that all assignments and
3146 references for one such a local variable can be replaced by
3147 equivalent assignments and references to some static storage
3148 variable, thereby avoiding the need for a register. In such
3149 cases we're forced to lie to debuggers and tell them that
3150 this variable was itself `static'. */
3154 if (NULL
== dbxout_common_check (decl
, &offs
))
3155 addr
= XEXP (XEXP (home
, 0), 0);
3163 else if (GET_CODE (home
) == CONCAT
)
3167 /* If TYPE is not a COMPLEX_TYPE (it might be a RECORD_TYPE,
3168 for example), then there is no easy way to figure out
3169 what SUBTYPE should be. So, we give up. */
3170 if (TREE_CODE (type
) != COMPLEX_TYPE
)
3173 subtype
= TREE_TYPE (type
);
3175 /* If the variable's storage is in two parts,
3176 output each as a separate stab with a modified name. */
3177 if (WORDS_BIG_ENDIAN
)
3178 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 0));
3180 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 0));
3182 if (WORDS_BIG_ENDIAN
)
3183 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 1));
3185 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 1));
3189 /* Address might be a MEM, when DECL is a variable-sized object.
3190 Or it might be const0_rtx, meaning previous passes
3191 want us to ignore this variable. */
3194 /* Ok, start a symtab entry and output the variable name. */
3195 emit_pending_bincls_if_required ();
3198 #ifdef DBX_STATIC_BLOCK_START
3199 DBX_STATIC_BLOCK_START (asm_out_file
, code
);
3202 dbxout_begin_complex_stabs_noforcetext ();
3203 dbxout_symbol_name (decl
, suffix
, letter
);
3204 dbxout_type (type
, 0);
3205 dbxout_finish_complex_stabs (decl
, code
, addr
, 0, number
);
3207 #ifdef DBX_STATIC_BLOCK_END
3208 DBX_STATIC_BLOCK_END (asm_out_file
, code
);
3213 /* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
3214 Then output LETTER to indicate the kind of location the symbol has. */
3217 dbxout_symbol_name (tree decl
, const char *suffix
, int letter
)
3221 if (DECL_CONTEXT (decl
)
3222 && (TYPE_P (DECL_CONTEXT (decl
))
3223 || TREE_CODE (DECL_CONTEXT (decl
)) == NAMESPACE_DECL
))
3224 /* One slight hitch: if this is a VAR_DECL which is a class member
3225 or a namespace member, we must put out the mangled name instead of the
3226 DECL_NAME. Note also that static member (variable) names DO NOT begin
3227 with underscores in .stabs directives. */
3228 name
= DECL_ASSEMBLER_NAME (decl
);
3230 /* ...but if we're function-local, we don't want to include the junk
3231 added by ASM_FORMAT_PRIVATE_NAME. */
3232 name
= DECL_NAME (decl
);
3237 stabstr_S ("(anon)");
3247 /* Output the common block name for DECL in a stabs.
3249 Symbols in global common (.comm) get wrapped with an N_BCOMM/N_ECOMM pair
3250 around each group of symbols in the same .comm area. The N_GSYM stabs
3251 that are emitted only contain the offset in the common area. This routine
3252 emits the N_BCOMM and N_ECOMM stabs. */
3255 dbxout_common_name (tree decl
, const char *name
, stab_code_type op
)
3257 dbxout_begin_complex_stabs ();
3259 dbxout_finish_complex_stabs (decl
, op
, NULL_RTX
, NULL
, 0);
3262 /* Check decl to determine whether it is a VAR_DECL destined for storage in a
3263 common area. If it is, the return value will be a non-null string giving
3264 the name of the common storage block it will go into. If non-null, the
3265 value is the offset into the common block for that symbol's storage. */
3268 dbxout_common_check (tree decl
, int *value
)
3272 const char *name
= NULL
;
3274 /* If the decl isn't a VAR_DECL, or if it isn't static, or if
3275 it does not have a value (the offset into the common area), or if it
3276 is thread local (as opposed to global) then it isn't common, and shouldn't
3279 ??? DECL_THREAD_LOCAL_P check prevents problems with improper .stabs
3280 for thread-local symbols. Can be handled via same mechanism as used
3282 if (TREE_CODE (decl
) != VAR_DECL
3283 || !TREE_STATIC (decl
)
3284 || !DECL_HAS_VALUE_EXPR_P (decl
)
3285 || DECL_THREAD_LOCAL_P (decl
)
3289 home
= DECL_RTL (decl
);
3290 if (home
== NULL_RTX
|| GET_CODE (home
) != MEM
)
3293 sym_addr
= dbxout_expand_expr (DECL_VALUE_EXPR (decl
));
3294 if (sym_addr
== NULL_RTX
|| GET_CODE (sym_addr
) != MEM
)
3297 sym_addr
= XEXP (sym_addr
, 0);
3298 if (GET_CODE (sym_addr
) == CONST
)
3299 sym_addr
= XEXP (sym_addr
, 0);
3300 if ((GET_CODE (sym_addr
) == SYMBOL_REF
|| GET_CODE (sym_addr
) == PLUS
)
3301 && DECL_INITIAL (decl
) == 0)
3304 /* We have a sym that will go into a common area, meaning that it
3305 will get storage reserved with a .comm/.lcomm assembler pseudo-op.
3307 Determine name of common area this symbol will be an offset into,
3308 and offset into that area. Also retrieve the decl for the area
3309 that the symbol is offset into. */
3312 switch (GET_CODE (sym_addr
))
3315 if (CONST_INT_P (XEXP (sym_addr
, 0)))
3318 targetm
.strip_name_encoding (XSTR (XEXP (sym_addr
, 1), 0));
3319 *value
= INTVAL (XEXP (sym_addr
, 0));
3320 cdecl = SYMBOL_REF_DECL (XEXP (sym_addr
, 1));
3325 targetm
.strip_name_encoding (XSTR (XEXP (sym_addr
, 0), 0));
3326 *value
= INTVAL (XEXP (sym_addr
, 1));
3327 cdecl = SYMBOL_REF_DECL (XEXP (sym_addr
, 0));
3332 name
= targetm
.strip_name_encoding (XSTR (sym_addr
, 0));
3334 cdecl = SYMBOL_REF_DECL (sym_addr
);
3338 error ("common symbol debug info is not structured as "
3342 /* Check area common symbol is offset into. If this is not public, then
3343 it is not a symbol in a common block. It must be a .lcomm symbol, not
3345 if (cdecl == NULL
|| !TREE_PUBLIC (cdecl))
3354 /* Output definitions of all the decls in a chain. Return nonzero if
3355 anything was output */
3358 dbxout_syms (tree syms
)
3361 const char *comm_prev
= NULL
;
3362 tree syms_prev
= NULL
;
3366 int temp
, copen
, cclos
;
3367 const char *comm_new
;
3369 /* Check for common symbol, and then progression into a new/different
3370 block of common symbols. Emit closing/opening common bracket if
3372 comm_new
= dbxout_common_check (syms
, &temp
);
3373 copen
= comm_new
!= NULL
3374 && (comm_prev
== NULL
|| strcmp (comm_new
, comm_prev
));
3375 cclos
= comm_prev
!= NULL
3376 && (comm_new
== NULL
|| strcmp (comm_new
, comm_prev
));
3378 dbxout_common_name (syms_prev
, comm_prev
, N_ECOMM
);
3381 dbxout_common_name (syms
, comm_new
, N_BCOMM
);
3384 comm_prev
= comm_new
;
3386 result
+= dbxout_symbol (syms
, 1);
3387 syms
= DECL_CHAIN (syms
);
3390 if (comm_prev
!= NULL
)
3391 dbxout_common_name (syms_prev
, comm_prev
, N_ECOMM
);
3396 /* The following two functions output definitions of function parameters.
3397 Each parameter gets a definition locating it in the parameter list.
3398 Each parameter that is a register variable gets a second definition
3399 locating it in the register.
3401 Printing or argument lists in gdb uses the definitions that
3402 locate in the parameter list. But reference to the variable in
3403 expressions uses preferentially the definition as a register. */
3405 /* Output definitions, referring to storage in the parmlist,
3406 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
3409 dbxout_parms (tree parms
)
3412 emit_pending_bincls_if_required ();
3414 for (; parms
; parms
= DECL_CHAIN (parms
))
3415 if (DECL_NAME (parms
)
3416 && TREE_TYPE (parms
) != error_mark_node
3417 && DECL_RTL_SET_P (parms
)
3418 && DECL_INCOMING_RTL (parms
))
3422 stab_code_type code
;
3425 /* Perform any necessary register eliminations on the parameter's rtl,
3426 so that the debugging output will be accurate. */
3427 DECL_INCOMING_RTL (parms
)
3428 = eliminate_regs (DECL_INCOMING_RTL (parms
), VOIDmode
, NULL_RTX
);
3429 SET_DECL_RTL (parms
,
3430 eliminate_regs (DECL_RTL (parms
), VOIDmode
, NULL_RTX
));
3431 #ifdef LEAF_REG_REMAP
3432 if (crtl
->uses_only_leaf_regs
)
3434 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms
));
3435 leaf_renumber_regs_insn (DECL_RTL (parms
));
3439 if (PARM_PASSED_IN_MEMORY (parms
))
3441 rtx inrtl
= XEXP (DECL_INCOMING_RTL (parms
), 0);
3443 /* ??? Here we assume that the parm address is indexed
3444 off the frame pointer or arg pointer.
3445 If that is not true, we produce meaningless results,
3446 but do not crash. */
3447 if (GET_CODE (inrtl
) == PLUS
3448 && CONST_INT_P (XEXP (inrtl
, 1)))
3449 number
= INTVAL (XEXP (inrtl
, 1));
3454 number
= DEBUGGER_ARG_OFFSET (number
, inrtl
);
3457 /* It is quite tempting to use TREE_TYPE (parms) instead
3458 of DECL_ARG_TYPE (parms) for the eff_type, so that gcc
3459 reports the actual type of the parameter, rather than
3460 the promoted type. This certainly makes GDB's life
3461 easier, at least for some ports. The change is a bad
3462 idea however, since GDB expects to be able access the
3463 type without performing any conversions. So for
3464 example, if we were passing a float to an unprototyped
3465 function, gcc will store a double on the stack, but if
3466 we emit a stab saying the type is a float, then gdb
3467 will only read in a single value, and this will produce
3468 an erroneous value. */
3469 eff_type
= DECL_ARG_TYPE (parms
);
3471 else if (REG_P (DECL_RTL (parms
)))
3475 /* Parm passed in registers and lives in registers or nowhere. */
3476 code
= DBX_REGPARM_STABS_CODE
;
3477 letter
= DBX_REGPARM_STABS_LETTER
;
3479 /* For parms passed in registers, it is better to use the
3480 declared type of the variable, not the type it arrived in. */
3481 eff_type
= TREE_TYPE (parms
);
3483 /* If parm lives in a register, use that register; pretend
3484 the parm was passed there. It would be more consistent
3485 to describe the register where the parm was passed, but
3486 in practice that register usually holds something else.
3487 If the parm lives nowhere, use the register where it
3489 if (REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
3490 best_rtl
= DECL_RTL (parms
);
3491 else if (GET_CODE (DECL_INCOMING_RTL (parms
)) == PARALLEL
)
3492 best_rtl
= XEXP (XVECEXP (DECL_INCOMING_RTL (parms
), 0, 0), 0);
3494 best_rtl
= DECL_INCOMING_RTL (parms
);
3496 number
= DBX_REGISTER_NUMBER (REGNO (best_rtl
));
3498 else if (MEM_P (DECL_RTL (parms
))
3499 && REG_P (XEXP (DECL_RTL (parms
), 0))
3500 && REGNO (XEXP (DECL_RTL (parms
), 0)) != HARD_FRAME_POINTER_REGNUM
3501 && REGNO (XEXP (DECL_RTL (parms
), 0)) != STACK_POINTER_REGNUM
3502 #if !HARD_FRAME_POINTER_IS_ARG_POINTER
3503 && REGNO (XEXP (DECL_RTL (parms
), 0)) != ARG_POINTER_REGNUM
3507 /* Parm was passed via invisible reference.
3508 That is, its address was passed in a register.
3509 Output it as if it lived in that register.
3510 The debugger will know from the type
3511 that it was actually passed by invisible reference. */
3513 code
= DBX_REGPARM_STABS_CODE
;
3515 /* GDB likes this marked with a special letter. */
3516 letter
= (use_gnu_debug_info_extensions
3517 ? 'a' : DBX_REGPARM_STABS_LETTER
);
3518 eff_type
= TREE_TYPE (parms
);
3520 /* DECL_RTL looks like (MEM (REG...). Get the register number.
3521 If it is an unallocated pseudo-reg, then use the register where
3522 it was passed instead.
3523 ??? Why is DBX_REGISTER_NUMBER not used here? */
3525 if (REGNO (XEXP (DECL_RTL (parms
), 0)) < FIRST_PSEUDO_REGISTER
)
3526 number
= REGNO (XEXP (DECL_RTL (parms
), 0));
3528 number
= REGNO (DECL_INCOMING_RTL (parms
));
3530 else if (MEM_P (DECL_RTL (parms
))
3531 && MEM_P (XEXP (DECL_RTL (parms
), 0)))
3533 /* Parm was passed via invisible reference, with the reference
3534 living on the stack. DECL_RTL looks like
3535 (MEM (MEM (PLUS (REG ...) (CONST_INT ...)))) or it
3536 could look like (MEM (MEM (REG))). */
3540 eff_type
= TREE_TYPE (parms
);
3542 if (!REG_P (XEXP (XEXP (DECL_RTL (parms
), 0), 0)))
3543 number
= INTVAL (XEXP (XEXP (XEXP (DECL_RTL (parms
), 0), 0), 1));
3547 number
= DEBUGGER_ARG_OFFSET (number
,
3548 XEXP (XEXP (DECL_RTL (parms
), 0), 0));
3550 else if (MEM_P (DECL_RTL (parms
))
3551 && XEXP (DECL_RTL (parms
), 0) != const0_rtx
3552 /* ??? A constant address for a parm can happen
3553 when the reg it lives in is equiv to a constant in memory.
3554 Should make this not happen, after 2.4. */
3555 && ! CONSTANT_P (XEXP (DECL_RTL (parms
), 0)))
3557 /* Parm was passed in registers but lives on the stack. */
3561 eff_type
= TREE_TYPE (parms
);
3563 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
3564 in which case we want the value of that CONST_INT,
3566 in which case we use a value of zero. */
3567 if (!REG_P (XEXP (DECL_RTL (parms
), 0)))
3568 number
= INTVAL (XEXP (XEXP (DECL_RTL (parms
), 0), 1));
3572 /* Make a big endian correction if the mode of the type of the
3573 parameter is not the same as the mode of the rtl. */
3574 if (BYTES_BIG_ENDIAN
3575 && TYPE_MODE (TREE_TYPE (parms
)) != GET_MODE (DECL_RTL (parms
))
3576 && GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms
))) < UNITS_PER_WORD
)
3577 number
+= (GET_MODE_SIZE (GET_MODE (DECL_RTL (parms
)))
3578 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms
))));
3581 /* ??? We don't know how to represent this argument. */
3584 dbxout_begin_complex_stabs ();
3586 if (DECL_NAME (parms
))
3588 stabstr_I (DECL_NAME (parms
));
3592 stabstr_S ("(anon):");
3594 dbxout_type (eff_type
, 0);
3595 dbxout_finish_complex_stabs (parms
, code
, 0, 0, number
);
3597 DBXOUT_DECR_NESTING
;
3600 /* Output definitions for the places where parms live during the function,
3601 when different from where they were passed, when the parms were passed
3604 It is not useful to do this for parms passed in registers
3605 that live during the function in different registers, because it is
3606 impossible to look in the passed register for the passed value,
3607 so we use the within-the-function register to begin with.
3609 PARMS is a chain of PARM_DECL nodes. */
3612 dbxout_reg_parms (tree parms
)
3616 for (; parms
; parms
= DECL_CHAIN (parms
))
3617 if (DECL_NAME (parms
) && PARM_PASSED_IN_MEMORY (parms
))
3619 /* Report parms that live in registers during the function
3620 but were passed in memory. */
3621 if (REG_P (DECL_RTL (parms
))
3622 && REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
3623 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
3624 0, DECL_RTL (parms
));
3625 else if (GET_CODE (DECL_RTL (parms
)) == CONCAT
)
3626 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
3627 0, DECL_RTL (parms
));
3628 /* Report parms that live in memory but not where they were passed. */
3629 else if (MEM_P (DECL_RTL (parms
))
3630 && ! rtx_equal_p (DECL_RTL (parms
), DECL_INCOMING_RTL (parms
)))
3631 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
3632 0, DECL_RTL (parms
));
3634 DBXOUT_DECR_NESTING
;
3637 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
3638 output definitions of those names, in raw form */
3641 dbxout_args (tree args
)
3646 dbxout_type (TREE_VALUE (args
), 0);
3647 args
= TREE_CHAIN (args
);
3651 #if defined (DBX_DEBUGGING_INFO)
3653 /* Subroutine of dbxout_block. Emit an N_LBRAC stab referencing LABEL.
3654 BEGIN_LABEL is the name of the beginning of the function, which may
3657 dbx_output_lbrac (const char *label
,
3658 const char *begin_label ATTRIBUTE_UNUSED
)
3660 dbxout_begin_stabn (N_LBRAC
);
3661 if (DBX_BLOCKS_FUNCTION_RELATIVE
)
3662 dbxout_stab_value_label_diff (label
, begin_label
);
3664 dbxout_stab_value_label (label
);
3667 /* Subroutine of dbxout_block. Emit an N_RBRAC stab referencing LABEL.
3668 BEGIN_LABEL is the name of the beginning of the function, which may
3671 dbx_output_rbrac (const char *label
,
3672 const char *begin_label ATTRIBUTE_UNUSED
)
3674 dbxout_begin_stabn (N_RBRAC
);
3675 if (DBX_BLOCKS_FUNCTION_RELATIVE
)
3676 dbxout_stab_value_label_diff (label
, begin_label
);
3678 dbxout_stab_value_label (label
);
3681 /* Output everything about a symbol block (a BLOCK node
3682 that represents a scope level),
3683 including recursive output of contained blocks.
3685 BLOCK is the BLOCK node.
3686 DEPTH is its depth within containing symbol blocks.
3687 ARGS is usually zero; but for the outermost block of the
3688 body of a function, it is a chain of PARM_DECLs for the function parameters.
3689 We output definitions of all the register parms
3690 as if they were local variables of that block.
3692 If -g1 was used, we count blocks just the same, but output nothing
3693 except for the outermost block.
3695 Actually, BLOCK may be several blocks chained together.
3696 We handle them all in sequence. */
3699 dbxout_block (tree block
, int depth
, tree args
)
3701 char begin_label
[20];
3702 /* Reference current function start using LFBB. */
3703 ASM_GENERATE_INTERNAL_LABEL (begin_label
, "LFBB", scope_labelno
);
3707 /* Ignore blocks never expanded or otherwise marked as real. */
3708 if (TREE_USED (block
) && TREE_ASM_WRITTEN (block
))
3711 int blocknum
= BLOCK_NUMBER (block
);
3713 /* In dbx format, the syms of a block come before the N_LBRAC.
3714 If nothing is output, we don't need the N_LBRAC, either. */
3716 if (debug_info_level
!= DINFO_LEVEL_TERSE
|| depth
== 0)
3717 did_output
= dbxout_syms (BLOCK_VARS (block
));
3719 dbxout_reg_parms (args
);
3721 /* Now output an N_LBRAC symbol to represent the beginning of
3722 the block. Use the block's tree-walk order to generate
3723 the assembler symbols LBBn and LBEn
3724 that final will define around the code in this block. */
3728 const char *scope_start
;
3731 /* The outermost block doesn't get LBB labels; use
3732 the LFBB local symbol emitted by dbxout_begin_prologue. */
3733 scope_start
= begin_label
;
3736 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBB", blocknum
);
3740 dbx_output_lbrac (scope_start
, begin_label
);
3743 /* Output the subblocks. */
3744 dbxout_block (BLOCK_SUBBLOCKS (block
), depth
+ 1, NULL_TREE
);
3746 /* Refer to the marker for the end of the block. */
3751 /* The outermost block doesn't get LBE labels;
3752 use the "scope" label which will be emitted
3753 by dbxout_function_end. */
3754 ASM_GENERATE_INTERNAL_LABEL (buf
, "Lscope", scope_labelno
);
3756 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBE", blocknum
);
3758 dbx_output_rbrac (buf
, begin_label
);
3761 block
= BLOCK_CHAIN (block
);
3765 /* Output the information about a function and its arguments and result.
3766 Usually this follows the function's code,
3767 but on some systems, it comes before. */
3770 dbxout_begin_function (tree decl
)
3772 int saved_tree_used1
;
3774 saved_tree_used1
= TREE_USED (decl
);
3775 TREE_USED (decl
) = 1;
3776 if (DECL_NAME (DECL_RESULT (decl
)) != 0)
3778 int saved_tree_used2
= TREE_USED (DECL_RESULT (decl
));
3779 TREE_USED (DECL_RESULT (decl
)) = 1;
3780 dbxout_symbol (decl
, 0);
3781 TREE_USED (DECL_RESULT (decl
)) = saved_tree_used2
;
3784 dbxout_symbol (decl
, 0);
3785 TREE_USED (decl
) = saved_tree_used1
;
3787 dbxout_parms (DECL_ARGUMENTS (decl
));
3788 if (DECL_NAME (DECL_RESULT (decl
)) != 0)
3789 dbxout_symbol (DECL_RESULT (decl
), 1);
3791 #endif /* DBX_DEBUGGING_INFO */
3793 #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */
3795 /* Record an element in the table of global destructors. SYMBOL is
3796 a SYMBOL_REF of the function to be called; PRIORITY is a number
3797 between 0 and MAX_INIT_PRIORITY. */
3800 default_stabs_asm_out_destructor (rtx symbol ATTRIBUTE_UNUSED
,
3801 int priority ATTRIBUTE_UNUSED
)
3803 #if defined DBX_DEBUGGING_INFO || defined XCOFF_DEBUGGING_INFO
3804 /* Tell GNU LD that this is part of the static destructor set.
3805 This will work for any system that uses stabs, most usefully
3807 dbxout_begin_simple_stabs ("___DTOR_LIST__", 22 /* N_SETT */);
3808 dbxout_stab_value_label (XSTR (symbol
, 0));
3810 sorry ("global destructors not supported on this target");
3814 /* Likewise for global constructors. */
3817 default_stabs_asm_out_constructor (rtx symbol ATTRIBUTE_UNUSED
,
3818 int priority ATTRIBUTE_UNUSED
)
3820 #if defined DBX_DEBUGGING_INFO || defined XCOFF_DEBUGGING_INFO
3821 /* Tell GNU LD that this is part of the static destructor set.
3822 This will work for any system that uses stabs, most usefully
3824 dbxout_begin_simple_stabs ("___CTOR_LIST__", 22 /* N_SETT */);
3825 dbxout_stab_value_label (XSTR (symbol
, 0));
3827 sorry ("global constructors not supported on this target");
3831 #include "gt-dbxout.h"