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"
76 #include "fold-const.h"
78 #include "stor-layout.h"
82 #include "insn-config.h"
86 #include "diagnostic-core.h"
90 #include "hard-reg-set.h"
93 #include "common/common-target.h"
94 #include "langhooks.h"
100 #include "emit-rtl.h"
104 #include "stringpool.h"
106 #ifdef XCOFF_DEBUGGING_INFO
107 #include "xcoffout.h"
111 # ifdef XCOFF_DEBUGGING_INFO
112 # define ASM_STABS_OP "\t.stabx\t"
114 # define ASM_STABS_OP "\t.stabs\t"
119 #define ASM_STABN_OP "\t.stabn\t"
123 #define ASM_STABD_OP "\t.stabd\t"
126 #ifndef DBX_TYPE_DECL_STABS_CODE
127 #define DBX_TYPE_DECL_STABS_CODE N_LSYM
130 #ifndef DBX_STATIC_CONST_VAR_CODE
131 #define DBX_STATIC_CONST_VAR_CODE N_FUN
134 #ifndef DBX_REGPARM_STABS_CODE
135 #define DBX_REGPARM_STABS_CODE N_RSYM
138 #ifndef DBX_REGPARM_STABS_LETTER
139 #define DBX_REGPARM_STABS_LETTER 'P'
142 #ifndef NO_DBX_FUNCTION_END
143 #define NO_DBX_FUNCTION_END 0
146 #ifndef NO_DBX_BNSYM_ENSYM
147 #define NO_DBX_BNSYM_ENSYM 0
150 #ifndef NO_DBX_MAIN_SOURCE_DIRECTORY
151 #define NO_DBX_MAIN_SOURCE_DIRECTORY 0
154 #ifndef DBX_BLOCKS_FUNCTION_RELATIVE
155 #define DBX_BLOCKS_FUNCTION_RELATIVE 0
158 #ifndef DBX_LINES_FUNCTION_RELATIVE
159 #define DBX_LINES_FUNCTION_RELATIVE 0
162 #ifndef DBX_CONTIN_LENGTH
163 #define DBX_CONTIN_LENGTH 80
166 #ifndef DBX_CONTIN_CHAR
167 #define DBX_CONTIN_CHAR '\\'
170 enum typestatus
{TYPE_UNSEEN
, TYPE_XREF
, TYPE_DEFINED
};
172 /* Structure recording information about a C data type.
173 The status element says whether we have yet output
174 the definition of the type. TYPE_XREF says we have
175 output it as a cross-reference only.
176 The file_number and type_number elements are used if DBX_USE_BINCL
179 struct GTY(()) typeinfo
{
180 enum typestatus status
;
185 /* Vector recording information about C data types.
186 When we first notice a data type (a tree node),
187 we assign it a number using next_type_number.
188 That is its index in this vector. */
190 static GTY ((length ("typevec_len"))) struct typeinfo
*typevec
;
192 /* Number of elements of space allocated in `typevec'. */
194 static GTY(()) int typevec_len
;
196 /* In dbx output, each type gets a unique number.
197 This is the number for the next type output.
198 The number, once assigned, is in the TYPE_SYMTAB_ADDRESS field. */
200 static GTY(()) int next_type_number
;
202 /* The C front end may call dbxout_symbol before dbxout_init runs.
203 We save all such decls in this list and output them when we get
206 static GTY(()) tree preinit_symbols
;
208 enum binclstatus
{BINCL_NOT_REQUIRED
, BINCL_PENDING
, BINCL_PROCESSED
};
210 /* When using N_BINCL in dbx output, each type number is actually a
211 pair of the file number and the type number within the file.
212 This is a stack of input files. */
216 struct dbx_file
*next
;
218 int next_type_number
;
219 enum binclstatus bincl_status
; /* Keep track of lazy bincl. */
220 const char *pending_bincl_name
; /* Name of bincl. */
221 struct dbx_file
*prev
; /* Chain to traverse all pending bincls. */
224 /* This is the top of the stack.
226 This is not saved for PCH, because restoring a PCH should not change it.
227 next_file_number does have to be saved, because the PCH may use some
228 file numbers; however, just before restoring a PCH, next_file_number
229 should always be 0 because we should not have needed any file numbers
232 #if (defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)) \
233 && defined (DBX_USE_BINCL)
234 static struct dbx_file
*current_file
;
237 /* This is the next file number to use. */
239 static GTY(()) int next_file_number
;
241 /* A counter for dbxout_function_end. */
243 static GTY(()) int scope_labelno
;
245 /* A counter for dbxout_source_line. */
247 static GTY(()) int dbxout_source_line_counter
;
249 /* Number for the next N_SOL filename stabs label. The number 0 is reserved
250 for the N_SO filename stabs label. */
252 static GTY(()) int source_label_number
= 1;
254 /* Last source file name mentioned in a NOTE insn. */
256 static GTY(()) const char *lastfile
;
258 /* Used by PCH machinery to detect if 'lastfile' should be reset to
260 static GTY(()) int lastfile_is_base
;
262 /* Typical USG systems don't have stab.h, and they also have
263 no use for DBX-format debugging info. */
265 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
268 /* If zero then there is no pending BINCL. */
269 static int pending_bincls
= 0;
272 /* The original input file name. */
273 static const char *base_input_file
;
275 #ifdef DEBUG_SYMS_TEXT
276 #define FORCE_TEXT switch_to_section (current_function_section ())
283 /* 1 if PARM is passed to this function in memory. */
285 #define PARM_PASSED_IN_MEMORY(PARM) \
286 (MEM_P (DECL_INCOMING_RTL (PARM)))
288 /* A C expression for the integer offset value of an automatic variable
289 (N_LSYM) having address X (an RTX). */
290 #ifndef DEBUGGER_AUTO_OFFSET
291 #define DEBUGGER_AUTO_OFFSET(X) \
292 (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
295 /* A C expression for the integer offset value of an argument (N_PSYM)
296 having address X (an RTX). The nominal offset is OFFSET.
297 Note that we use OFFSET + 0 here to avoid the self-assign warning
298 when the macro is called in a context like
299 number = DEBUGGER_ARG_OFFSET(number, X) */
300 #ifndef DEBUGGER_ARG_OFFSET
301 #define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET + 0)
304 /* This obstack holds the stab string currently being constructed. We
305 build it up here, then write it out, so we can split long lines up
306 properly (see dbxout_finish_complex_stabs). */
307 static struct obstack stabstr_ob
;
308 static size_t stabstr_last_contin_point
;
311 static void emit_bincl_stab (const char *c
);
312 static void emit_pending_bincls (void);
314 static inline void emit_pending_bincls_if_required (void);
316 static void dbxout_init (const char *);
318 static void dbxout_finish (const char *);
319 static void dbxout_start_source_file (unsigned, const char *);
320 static void dbxout_end_source_file (unsigned);
321 static void dbxout_typedefs (tree
);
322 static void dbxout_type_index (tree
);
323 static void dbxout_args (tree
);
324 static void dbxout_type_fields (tree
);
325 static void dbxout_type_method_1 (tree
);
326 static void dbxout_type_methods (tree
);
327 static void dbxout_range_type (tree
, tree
, tree
);
328 static void dbxout_type (tree
, int);
329 static bool print_int_cst_bounds_in_octal_p (tree
, tree
, tree
);
330 static bool is_fortran (void);
331 static void dbxout_type_name (tree
);
332 static void dbxout_class_name_qualifiers (tree
);
333 static int dbxout_symbol_location (tree
, tree
, const char *, rtx
);
334 static void dbxout_symbol_name (tree
, const char *, int);
335 static void dbxout_common_name (tree
, const char *, stab_code_type
);
336 static const char *dbxout_common_check (tree
, int *);
337 static void dbxout_early_global_decl (tree
);
338 static void dbxout_late_global_decl (tree
);
339 static void dbxout_type_decl (tree
, int);
340 static void dbxout_handle_pch (unsigned);
341 static void debug_free_queue (void);
343 /* The debug hooks structure. */
344 #if defined (DBX_DEBUGGING_INFO)
346 static void dbxout_source_line (unsigned int, const char *, int, bool);
347 static void dbxout_begin_prologue (unsigned int, const char *);
348 static void dbxout_source_file (const char *);
349 static void dbxout_function_end (tree
);
350 static void dbxout_begin_function (tree
);
351 static void dbxout_begin_block (unsigned, unsigned);
352 static void dbxout_end_block (unsigned, unsigned);
353 static void dbxout_function_decl (tree
);
355 const struct gcc_debug_hooks dbx_debug_hooks
=
361 debug_nothing_int_charstar
,
362 debug_nothing_int_charstar
,
363 dbxout_start_source_file
,
364 dbxout_end_source_file
,
367 debug_true_const_tree
, /* ignore_block */
368 dbxout_source_line
, /* source_line */
369 dbxout_begin_prologue
, /* begin_prologue */
370 debug_nothing_int_charstar
, /* end_prologue */
371 debug_nothing_int_charstar
, /* begin_epilogue */
372 debug_nothing_int_charstar
, /* end_epilogue */
373 #ifdef DBX_FUNCTION_FIRST
374 dbxout_begin_function
,
376 debug_nothing_tree
, /* begin_function */
378 debug_nothing_int
, /* end_function */
379 debug_nothing_tree
, /* register_main_translation_unit */
380 dbxout_function_decl
,
381 dbxout_early_global_decl
, /* early_global_decl */
382 dbxout_late_global_decl
, /* late_global_decl */
383 dbxout_type_decl
, /* type_decl */
384 debug_nothing_tree_tree_tree_bool
, /* imported_module_or_decl */
385 debug_nothing_tree
, /* deferred_inline_function */
386 debug_nothing_tree
, /* outlining_inline_function */
387 debug_nothing_rtx_code_label
, /* label */
388 dbxout_handle_pch
, /* handle_pch */
389 debug_nothing_rtx_insn
, /* var_location */
390 debug_nothing_void
, /* switch_text_section */
391 debug_nothing_tree_tree
, /* set_name */
392 0, /* start_end_main_source_file */
393 TYPE_SYMTAB_IS_ADDRESS
/* tree_type_symtab_field */
395 #endif /* DBX_DEBUGGING_INFO */
397 #if defined (XCOFF_DEBUGGING_INFO)
398 const struct gcc_debug_hooks xcoff_debug_hooks
=
404 debug_nothing_int_charstar
,
405 debug_nothing_int_charstar
,
406 dbxout_start_source_file
,
407 dbxout_end_source_file
,
408 xcoffout_begin_block
,
410 debug_true_const_tree
, /* ignore_block */
411 xcoffout_source_line
,
412 xcoffout_begin_prologue
, /* begin_prologue */
413 debug_nothing_int_charstar
, /* end_prologue */
414 debug_nothing_int_charstar
, /* begin_epilogue */
415 xcoffout_end_epilogue
,
416 debug_nothing_tree
, /* begin_function */
417 xcoffout_end_function
,
418 debug_nothing_tree
, /* register_main_translation_unit */
419 debug_nothing_tree
, /* function_decl */
420 dbxout_early_global_decl
, /* early_global_decl */
421 dbxout_late_global_decl
, /* late_global_decl */
422 dbxout_type_decl
, /* type_decl */
423 debug_nothing_tree_tree_tree_bool
, /* imported_module_or_decl */
424 debug_nothing_tree
, /* deferred_inline_function */
425 debug_nothing_tree
, /* outlining_inline_function */
426 debug_nothing_rtx_code_label
, /* label */
427 dbxout_handle_pch
, /* handle_pch */
428 debug_nothing_rtx_insn
, /* var_location */
429 debug_nothing_void
, /* switch_text_section */
430 debug_nothing_tree_tree
, /* set_name */
431 0, /* start_end_main_source_file */
432 TYPE_SYMTAB_IS_ADDRESS
/* tree_type_symtab_field */
434 #endif /* XCOFF_DEBUGGING_INFO */
436 /* Numeric formatting helper macro. Note that this does not handle
438 #define NUMBER_FMT_LOOP(P, NUM, BASE) \
441 int digit = NUM % BASE; \
443 *--P = digit + '0'; \
447 /* Utility: write a decimal integer NUM to asm_out_file. */
452 char *p
= buf
+ sizeof buf
;
457 putc ('0', asm_out_file
);
462 putc ('-', asm_out_file
);
468 NUMBER_FMT_LOOP (p
, unum
, 10);
470 while (p
< buf
+ sizeof buf
)
472 putc (*p
, asm_out_file
);
478 /* Primitives for emitting simple stabs directives. All other stabs
479 routines should use these functions instead of directly emitting
480 stabs. They are exported because machine-dependent code may need
481 to invoke them, e.g. in a DBX_OUTPUT_* macro whose definition
482 forwards to code in CPU.c. */
484 /* The following functions should all be called immediately after one
485 of the dbxout_begin_stab* functions (below). They write out
486 various things as the value of a stab. */
488 /* Write out a literal zero as the value of a stab. */
490 dbxout_stab_value_zero (void)
492 fputs ("0\n", asm_out_file
);
495 /* Write out the label LABEL as the value of a stab. */
497 dbxout_stab_value_label (const char *label
)
499 assemble_name (asm_out_file
, label
);
500 putc ('\n', asm_out_file
);
503 /* Write out the difference of two labels, LABEL - BASE, as the value
506 dbxout_stab_value_label_diff (const char *label
, const char *base
)
508 assemble_name (asm_out_file
, label
);
509 putc ('-', asm_out_file
);
510 assemble_name (asm_out_file
, base
);
511 putc ('\n', asm_out_file
);
514 /* Write out an internal label as the value of a stab, and immediately
515 emit that internal label. This should be used only when
516 dbxout_stabd will not work. STEM is the name stem of the label,
517 COUNTERP is a pointer to a counter variable which will be used to
518 guarantee label uniqueness. */
520 dbxout_stab_value_internal_label (const char *stem
, int *counterp
)
523 int counter
= counterp
? (*counterp
)++ : 0;
525 ASM_GENERATE_INTERNAL_LABEL (label
, stem
, counter
);
526 dbxout_stab_value_label (label
);
527 targetm
.asm_out
.internal_label (asm_out_file
, stem
, counter
);
530 /* Write out the difference between BASE and an internal label as the
531 value of a stab, and immediately emit that internal label. STEM and
532 COUNTERP are as for dbxout_stab_value_internal_label. */
534 dbxout_stab_value_internal_label_diff (const char *stem
, int *counterp
,
538 int counter
= counterp
? (*counterp
)++ : 0;
540 ASM_GENERATE_INTERNAL_LABEL (label
, stem
, counter
);
541 dbxout_stab_value_label_diff (label
, base
);
542 targetm
.asm_out
.internal_label (asm_out_file
, stem
, counter
);
545 /* The following functions produce specific kinds of stab directives. */
547 /* Write a .stabd directive with type STYPE and desc SDESC to asm_out_file. */
549 dbxout_stabd (int stype
, int sdesc
)
551 fputs (ASM_STABD_OP
, asm_out_file
);
553 fputs (",0,", asm_out_file
);
555 putc ('\n', asm_out_file
);
558 /* Write a .stabn directive with type STYPE. This function stops
559 short of emitting the value field, which is the responsibility of
560 the caller (normally it will be either a symbol or the difference
564 dbxout_begin_stabn (int stype
)
566 fputs (ASM_STABN_OP
, asm_out_file
);
568 fputs (",0,0,", asm_out_file
);
571 /* Write a .stabn directive with type N_SLINE and desc LINE. As above,
572 the value field is the responsibility of the caller. */
574 dbxout_begin_stabn_sline (int lineno
)
576 fputs (ASM_STABN_OP
, asm_out_file
);
577 dbxout_int (N_SLINE
);
578 fputs (",0,", asm_out_file
);
580 putc (',', asm_out_file
);
583 /* Begin a .stabs directive with string "", type STYPE, and desc and
584 other fields 0. The value field is the responsibility of the
585 caller. This function cannot be used for .stabx directives. */
587 dbxout_begin_empty_stabs (int stype
)
589 fputs (ASM_STABS_OP
, asm_out_file
);
590 fputs ("\"\",", asm_out_file
);
592 fputs (",0,0,", asm_out_file
);
595 /* Begin a .stabs directive with string STR, type STYPE, and desc 0.
596 The value field is the responsibility of the caller. */
598 dbxout_begin_simple_stabs (const char *str
, int stype
)
600 fputs (ASM_STABS_OP
, asm_out_file
);
601 output_quoted_string (asm_out_file
, str
);
602 putc (',', asm_out_file
);
604 fputs (",0,0,", asm_out_file
);
607 /* As above but use SDESC for the desc field. */
609 dbxout_begin_simple_stabs_desc (const char *str
, int stype
, int sdesc
)
611 fputs (ASM_STABS_OP
, asm_out_file
);
612 output_quoted_string (asm_out_file
, str
);
613 putc (',', asm_out_file
);
615 fputs (",0,", asm_out_file
);
617 putc (',', asm_out_file
);
620 /* The next set of functions are entirely concerned with production of
621 "complex" .stabs directives: that is, .stabs directives whose
622 strings have to be constructed piecemeal. dbxout_type,
623 dbxout_symbol, etc. use these routines heavily. The string is queued
624 up in an obstack, then written out by dbxout_finish_complex_stabs, which
625 is also responsible for splitting it up if it exceeds DBX_CONTIN_LENGTH.
626 (You might think it would be more efficient to go straight to stdio
627 when DBX_CONTIN_LENGTH is 0 (i.e. no length limit) but that turns
628 out not to be the case, and anyway this needs fewer #ifdefs.) */
630 /* Begin a complex .stabs directive. If we can, write the initial
631 ASM_STABS_OP to the asm_out_file. */
634 dbxout_begin_complex_stabs (void)
636 emit_pending_bincls_if_required ();
638 fputs (ASM_STABS_OP
, asm_out_file
);
639 putc ('"', asm_out_file
);
640 gcc_assert (stabstr_last_contin_point
== 0);
643 /* As above, but do not force text or emit pending bincls. This is
644 used by dbxout_symbol_location, which needs to do something else. */
646 dbxout_begin_complex_stabs_noforcetext (void)
648 fputs (ASM_STABS_OP
, asm_out_file
);
649 putc ('"', asm_out_file
);
650 gcc_assert (stabstr_last_contin_point
== 0);
653 /* Add CHR, a single character, to the string being built. */
654 #define stabstr_C(chr) obstack_1grow (&stabstr_ob, chr)
656 /* Add STR, a normal C string, to the string being built. */
657 #define stabstr_S(str) obstack_grow (&stabstr_ob, str, strlen (str))
659 /* Add the text of ID, an IDENTIFIER_NODE, to the string being built. */
660 #define stabstr_I(id) obstack_grow (&stabstr_ob, \
661 IDENTIFIER_POINTER (id), \
662 IDENTIFIER_LENGTH (id))
664 /* Add NUM, a signed decimal number, to the string being built. */
666 stabstr_D (HOST_WIDE_INT num
)
669 char *p
= buf
+ sizeof buf
;
685 NUMBER_FMT_LOOP (p
, unum
, 10);
687 obstack_grow (&stabstr_ob
, p
, (buf
+ sizeof buf
) - p
);
690 /* Add NUM, an unsigned decimal number, to the string being built. */
692 stabstr_U (unsigned HOST_WIDE_INT num
)
695 char *p
= buf
+ sizeof buf
;
701 NUMBER_FMT_LOOP (p
, num
, 10);
702 obstack_grow (&stabstr_ob
, p
, (buf
+ sizeof buf
) - p
);
705 /* Add CST, an INTEGER_CST tree, to the string being built as an
706 unsigned octal number. This routine handles values which are
707 larger than a single HOST_WIDE_INT. */
711 int prec
= TYPE_PRECISION (TREE_TYPE (cst
));
712 int res_pres
= prec
% 3;
716 /* Leading zero for base indicator. */
719 /* If the value is zero, the base indicator will serve as the value
721 if (wi::eq_p (cst
, 0))
724 /* GDB wants constants with no extra leading "1" bits, so
725 we need to remove any sign-extension that might be
729 digit
= wi::extract_uhwi (cst
, prec
- 1, 1);
730 stabstr_C ('0' + digit
);
732 else if (res_pres
== 2)
734 digit
= wi::extract_uhwi (cst
, prec
- 2, 2);
735 stabstr_C ('0' + digit
);
739 for (i
= prec
- 3; i
>= 0; i
= i
- 3)
741 digit
= wi::extract_uhwi (cst
, i
, 3);
742 stabstr_C ('0' + digit
);
746 /* Called whenever it is safe to break a stabs string into multiple
747 .stabs directives. If the current string has exceeded the limit
748 set by DBX_CONTIN_LENGTH, mark the current position in the buffer
749 as a continuation point by inserting DBX_CONTIN_CHAR (doubled if
750 it is a backslash) and a null character. */
752 stabstr_continue (void)
754 if (DBX_CONTIN_LENGTH
> 0
755 && obstack_object_size (&stabstr_ob
) - stabstr_last_contin_point
758 if (DBX_CONTIN_CHAR
== '\\')
759 obstack_1grow (&stabstr_ob
, '\\');
760 obstack_1grow (&stabstr_ob
, DBX_CONTIN_CHAR
);
761 obstack_1grow (&stabstr_ob
, '\0');
762 stabstr_last_contin_point
= obstack_object_size (&stabstr_ob
);
765 #define CONTIN stabstr_continue ()
767 /* Macro subroutine of dbxout_finish_complex_stabs, which emits
768 all of the arguments to the .stabs directive after the string.
769 Overridden by xcoffout.h. CODE is the stabs code for this symbol;
770 LINE is the source line to write into the desc field (in extended
771 mode); SYM is the symbol itself.
773 ADDR, LABEL, and NUMBER are three different ways to represent the
774 stabs value field. At most one of these should be nonzero.
776 ADDR is used most of the time; it represents the value as an
777 RTL address constant.
779 LABEL is used (currently) only for N_CATCH stabs; it represents
780 the value as a string suitable for assemble_name.
782 NUMBER is used when the value is an offset from an implicit base
783 pointer (e.g. for a stack variable), or an index (e.g. for a
784 register variable). It represents the value as a decimal integer. */
786 #ifndef DBX_FINISH_STABS
787 #define DBX_FINISH_STABS(SYM, CODE, LINE, ADDR, LABEL, NUMBER) \
789 int line_ = use_gnu_debug_info_extensions ? LINE : 0; \
792 fputs (",0,", asm_out_file); \
793 dbxout_int (line_); \
794 putc (',', asm_out_file); \
796 output_addr_const (asm_out_file, ADDR); \
798 assemble_name (asm_out_file, LABEL); \
800 dbxout_int (NUMBER); \
801 putc ('\n', asm_out_file); \
805 /* Finish the emission of a complex .stabs directive. When DBX_CONTIN_LENGTH
806 is zero, this has only to emit the close quote and the remainder of
807 the arguments. When it is nonzero, the string has been marshalled in
808 stabstr_ob, and this routine is responsible for breaking it up into
809 DBX_CONTIN_LENGTH-sized chunks.
811 SYM is the DECL of the symbol under consideration; it is used only
812 for its DECL_SOURCE_LINE. The other arguments are all passed directly
813 to DBX_FINISH_STABS; see above for details. */
816 dbxout_finish_complex_stabs (tree sym
, stab_code_type code
,
817 rtx addr
, const char *label
, int number
)
819 int line ATTRIBUTE_UNUSED
;
823 line
= sym
? DECL_SOURCE_LINE (sym
) : 0;
824 if (DBX_CONTIN_LENGTH
> 0)
829 /* Nul-terminate the growing string, then get its size and
831 obstack_1grow (&stabstr_ob
, '\0');
833 len
= obstack_object_size (&stabstr_ob
);
834 chunk
= str
= XOBFINISH (&stabstr_ob
, char *);
836 /* Within the buffer are a sequence of NUL-separated strings,
837 each of which is to be written out as a separate stab
841 chunklen
= strlen (chunk
);
842 fwrite (chunk
, 1, chunklen
, asm_out_file
);
843 fputs ("\",", asm_out_file
);
845 /* Must add an extra byte to account for the NUL separator. */
846 chunk
+= chunklen
+ 1;
849 /* Only put a line number on the last stab in the sequence. */
850 DBX_FINISH_STABS (sym
, code
, len
== 0 ? line
: 0,
851 addr
, label
, number
);
855 fputs (ASM_STABS_OP
, asm_out_file
);
856 putc ('"', asm_out_file
);
858 stabstr_last_contin_point
= 0;
862 /* No continuations - we can put the whole string out at once.
863 It is faster to augment the string with the close quote and
864 comma than to do a two-character fputs. */
865 obstack_grow (&stabstr_ob
, "\",", 2);
866 len
= obstack_object_size (&stabstr_ob
);
867 str
= XOBFINISH (&stabstr_ob
, char *);
869 fwrite (str
, 1, len
, asm_out_file
);
870 DBX_FINISH_STABS (sym
, code
, line
, addr
, label
, number
);
872 obstack_free (&stabstr_ob
, str
);
875 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
877 /* When -gused is used, emit debug info for only used symbols. But in
878 addition to the standard intercepted debug_hooks there are some
879 direct calls into this file, i.e., dbxout_symbol, dbxout_parms, and
880 dbxout_reg_params. Those routines may also be called from a higher
881 level intercepted routine. So to prevent recording data for an inner
882 call to one of these for an intercept, we maintain an intercept
883 nesting counter (debug_nesting). We only save the intercepted
884 arguments if the nesting is 1. */
885 static int debug_nesting
= 0;
887 static tree
*symbol_queue
;
888 static int symbol_queue_index
= 0;
889 static int symbol_queue_size
= 0;
891 #define DBXOUT_DECR_NESTING \
892 if (--debug_nesting == 0 && symbol_queue_index > 0) \
893 { emit_pending_bincls_if_required (); debug_flush_symbol_queue (); }
895 #define DBXOUT_DECR_NESTING_AND_RETURN(x) \
896 do {--debug_nesting; return (x);} while (0)
898 #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */
900 #if defined (DBX_DEBUGGING_INFO)
903 dbxout_function_end (tree decl ATTRIBUTE_UNUSED
)
905 char lscope_label_name
[100];
907 /* The Lscope label must be emitted even if we aren't doing anything
908 else; dbxout_block needs it. */
909 switch_to_section (function_section (current_function_decl
));
911 /* Convert Lscope into the appropriate format for local labels in case
912 the system doesn't insert underscores in front of user generated
914 ASM_GENERATE_INTERNAL_LABEL (lscope_label_name
, "Lscope", scope_labelno
);
915 targetm
.asm_out
.internal_label (asm_out_file
, "Lscope", scope_labelno
);
917 /* The N_FUN tag at the end of the function is a GNU extension,
918 which may be undesirable, and is unnecessary if we do not have
920 if (!use_gnu_debug_info_extensions
921 || NO_DBX_FUNCTION_END
922 || !targetm_common
.have_named_sections
)
925 /* By convention, GCC will mark the end of a function with an N_FUN
926 symbol and an empty string. */
927 if (flag_reorder_blocks_and_partition
)
929 dbxout_begin_empty_stabs (N_FUN
);
930 dbxout_stab_value_label_diff (crtl
->subsections
.hot_section_end_label
,
931 crtl
->subsections
.hot_section_label
);
932 dbxout_begin_empty_stabs (N_FUN
);
933 dbxout_stab_value_label_diff (crtl
->subsections
.cold_section_end_label
,
934 crtl
->subsections
.cold_section_label
);
938 char begin_label
[20];
939 /* Reference current function start using LFBB. */
940 ASM_GENERATE_INTERNAL_LABEL (begin_label
, "LFBB", scope_labelno
);
941 dbxout_begin_empty_stabs (N_FUN
);
942 dbxout_stab_value_label_diff (lscope_label_name
, begin_label
);
945 if (!NO_DBX_BNSYM_ENSYM
&& !flag_debug_only_used_symbols
)
946 dbxout_stabd (N_ENSYM
, 0);
948 #endif /* DBX_DEBUGGING_INFO */
950 /* Get lang description for N_SO stab. */
951 static unsigned int ATTRIBUTE_UNUSED
952 get_lang_number (void)
954 const char *language_string
= lang_hooks
.name
;
957 else if (lang_GNU_CXX ())
959 else if (strcmp (language_string
, "GNU F77") == 0)
961 else if (lang_GNU_Fortran ())
962 return N_SO_FORTRAN90
; /* CHECKME */
963 else if (strcmp (language_string
, "GNU Pascal") == 0)
965 else if (strcmp (language_string
, "GNU Objective-C") == 0)
967 else if (strcmp (language_string
, "GNU Objective-C++") == 0)
968 return N_SO_OBJCPLUS
;
977 unsigned int lang
= get_lang_number ();
979 return (lang
== N_SO_FORTRAN
) || (lang
== N_SO_FORTRAN90
);
982 /* At the beginning of compilation, start writing the symbol table.
983 Initialize `typevec' and output the standard data types of C. */
986 dbxout_init (const char *input_file_name
)
988 char ltext_label_name
[100];
989 bool used_ltext_label_name
= false;
990 tree syms
= lang_hooks
.decls
.getdecls ();
991 const char *mapped_name
;
994 typevec
= ggc_cleared_vec_alloc
<typeinfo
> (typevec_len
);
996 /* stabstr_ob contains one string, which will be just fine with
998 obstack_specify_allocation (&stabstr_ob
, 0, 1, xmalloc
, free
);
1000 /* Convert Ltext into the appropriate format for local labels in case
1001 the system doesn't insert underscores in front of user generated
1003 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name
, "Ltext", 0);
1005 /* Put the current working directory in an N_SO symbol. */
1006 if (use_gnu_debug_info_extensions
&& !NO_DBX_MAIN_SOURCE_DIRECTORY
)
1008 static const char *cwd
;
1012 cwd
= get_src_pwd ();
1015 else if (!IS_DIR_SEPARATOR (cwd
[strlen (cwd
) - 1]))
1016 cwd
= concat (cwd
, "/", NULL
);
1017 cwd
= remap_debug_filename (cwd
);
1019 #ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
1020 DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asm_out_file
, cwd
);
1021 #else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
1022 dbxout_begin_simple_stabs_desc (cwd
, N_SO
, get_lang_number ());
1023 dbxout_stab_value_label (ltext_label_name
);
1024 used_ltext_label_name
= true;
1025 #endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
1028 mapped_name
= remap_debug_filename (input_file_name
);
1029 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
1030 DBX_OUTPUT_MAIN_SOURCE_FILENAME (asm_out_file
, mapped_name
);
1032 dbxout_begin_simple_stabs_desc (mapped_name
, N_SO
, get_lang_number ());
1033 dbxout_stab_value_label (ltext_label_name
);
1034 used_ltext_label_name
= true;
1037 if (used_ltext_label_name
)
1039 switch_to_section (text_section
);
1040 targetm
.asm_out
.internal_label (asm_out_file
, "Ltext", 0);
1043 /* Emit an N_OPT stab to indicate that this file was compiled by GCC.
1044 The string used is historical. */
1045 #ifndef NO_DBX_GCC_MARKER
1046 dbxout_begin_simple_stabs ("gcc2_compiled.", N_OPT
);
1047 dbxout_stab_value_zero ();
1050 base_input_file
= lastfile
= input_file_name
;
1052 next_type_number
= 1;
1054 #ifdef DBX_USE_BINCL
1055 current_file
= XNEW (struct dbx_file
);
1056 current_file
->next
= NULL
;
1057 current_file
->file_number
= 0;
1058 current_file
->next_type_number
= 1;
1059 next_file_number
= 1;
1060 current_file
->prev
= NULL
;
1061 current_file
->bincl_status
= BINCL_NOT_REQUIRED
;
1062 current_file
->pending_bincl_name
= NULL
;
1065 /* Get all permanent types that have typedef names, and output them
1066 all, except for those already output. Some language front ends
1067 put these declarations in the top-level scope; some do not;
1068 the latter are responsible for calling debug_hooks->type_decl from
1069 their record_builtin_type function. */
1070 dbxout_typedefs (syms
);
1072 if (preinit_symbols
)
1075 for (t
= nreverse (preinit_symbols
); t
; t
= TREE_CHAIN (t
))
1076 dbxout_symbol (TREE_VALUE (t
), 0);
1077 preinit_symbols
= 0;
1081 /* Output any typedef names for types described by TYPE_DECLs in SYMS. */
1084 dbxout_typedefs (tree syms
)
1086 for (; syms
!= NULL_TREE
; syms
= DECL_CHAIN (syms
))
1088 if (TREE_CODE (syms
) == TYPE_DECL
)
1090 tree type
= TREE_TYPE (syms
);
1091 if (TYPE_NAME (type
)
1092 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1093 && COMPLETE_OR_VOID_TYPE_P (type
)
1094 && ! TREE_ASM_WRITTEN (TYPE_NAME (type
)))
1095 dbxout_symbol (TYPE_NAME (type
), 0);
1100 #ifdef DBX_USE_BINCL
1101 /* Emit BINCL stab using given name. */
1103 emit_bincl_stab (const char *name
)
1105 dbxout_begin_simple_stabs (name
, N_BINCL
);
1106 dbxout_stab_value_zero ();
1109 /* If there are pending bincls then it is time to emit all of them. */
1112 emit_pending_bincls_if_required (void)
1115 emit_pending_bincls ();
1118 /* Emit all pending bincls. */
1121 emit_pending_bincls (void)
1123 struct dbx_file
*f
= current_file
;
1125 /* Find first pending bincl. */
1126 while (f
->bincl_status
== BINCL_PENDING
)
1129 /* Now emit all bincls. */
1134 if (f
->bincl_status
== BINCL_PENDING
)
1136 emit_bincl_stab (f
->pending_bincl_name
);
1138 /* Update file number and status. */
1139 f
->file_number
= next_file_number
++;
1140 f
->bincl_status
= BINCL_PROCESSED
;
1142 if (f
== current_file
)
1147 /* All pending bincls have been emitted. */
1154 emit_pending_bincls_if_required (void) {}
1157 /* Change to reading from a new source file. Generate a N_BINCL stab. */
1160 dbxout_start_source_file (unsigned int line ATTRIBUTE_UNUSED
,
1161 const char *filename ATTRIBUTE_UNUSED
)
1163 #ifdef DBX_USE_BINCL
1164 struct dbx_file
*n
= XNEW (struct dbx_file
);
1166 n
->next
= current_file
;
1167 n
->next_type_number
= 1;
1168 /* Do not assign file number now.
1169 Delay it until we actually emit BINCL. */
1172 current_file
->prev
= n
;
1173 n
->bincl_status
= BINCL_PENDING
;
1174 n
->pending_bincl_name
= remap_debug_filename (filename
);
1180 /* Revert to reading a previous source file. Generate a N_EINCL stab. */
1183 dbxout_end_source_file (unsigned int line ATTRIBUTE_UNUSED
)
1185 #ifdef DBX_USE_BINCL
1186 /* Emit EINCL stab only if BINCL is not pending. */
1187 if (current_file
->bincl_status
== BINCL_PROCESSED
)
1189 dbxout_begin_stabn (N_EINCL
);
1190 dbxout_stab_value_zero ();
1192 current_file
->bincl_status
= BINCL_NOT_REQUIRED
;
1193 current_file
= current_file
->next
;
1197 /* Handle a few odd cases that occur when trying to make PCH files work. */
1200 dbxout_handle_pch (unsigned at_end
)
1204 /* When using the PCH, this file will be included, so we need to output
1206 dbxout_start_source_file (0, lastfile
);
1208 /* The base file when using the PCH won't be the same as
1209 the base file when it's being generated. */
1214 /* ... and an EINCL. */
1215 dbxout_end_source_file (0);
1217 /* Deal with cases where 'lastfile' was never actually changed. */
1218 lastfile_is_base
= lastfile
== NULL
;
1222 #if defined (DBX_DEBUGGING_INFO)
1224 static void dbxout_block (tree
, int, tree
);
1226 /* Output debugging info to FILE to switch to sourcefile FILENAME. */
1229 dbxout_source_file (const char *filename
)
1231 if (lastfile
== 0 && lastfile_is_base
)
1233 lastfile
= base_input_file
;
1234 lastfile_is_base
= 0;
1237 if (filename
&& (lastfile
== 0 || strcmp (filename
, lastfile
)))
1239 /* Don't change section amid function. */
1240 if (current_function_decl
== NULL_TREE
)
1241 switch_to_section (text_section
);
1243 dbxout_begin_simple_stabs (remap_debug_filename (filename
), N_SOL
);
1244 dbxout_stab_value_internal_label ("Ltext", &source_label_number
);
1245 lastfile
= filename
;
1249 /* Output N_BNSYM, line number symbol entry, and local symbol at
1253 dbxout_begin_prologue (unsigned int lineno
, const char *filename
)
1255 if (use_gnu_debug_info_extensions
1256 && !NO_DBX_FUNCTION_END
1257 && !NO_DBX_BNSYM_ENSYM
1258 && !flag_debug_only_used_symbols
)
1259 dbxout_stabd (N_BNSYM
, 0);
1261 /* pre-increment the scope counter */
1264 dbxout_source_line (lineno
, filename
, 0, true);
1265 /* Output function begin block at function scope, referenced
1266 by dbxout_block, dbxout_source_line and dbxout_function_end. */
1267 emit_pending_bincls_if_required ();
1268 targetm
.asm_out
.internal_label (asm_out_file
, "LFBB", scope_labelno
);
1271 /* Output a line number symbol entry for source file FILENAME and line
1275 dbxout_source_line (unsigned int lineno
, const char *filename
,
1276 int discriminator ATTRIBUTE_UNUSED
,
1277 bool is_stmt ATTRIBUTE_UNUSED
)
1279 dbxout_source_file (filename
);
1281 #ifdef DBX_OUTPUT_SOURCE_LINE
1282 DBX_OUTPUT_SOURCE_LINE (asm_out_file
, lineno
, dbxout_source_line_counter
);
1284 if (DBX_LINES_FUNCTION_RELATIVE
)
1286 char begin_label
[20];
1287 dbxout_begin_stabn_sline (lineno
);
1288 /* Reference current function start using LFBB. */
1289 ASM_GENERATE_INTERNAL_LABEL (begin_label
, "LFBB", scope_labelno
);
1290 dbxout_stab_value_internal_label_diff ("LM", &dbxout_source_line_counter
,
1294 dbxout_stabd (N_SLINE
, lineno
);
1298 /* Describe the beginning of an internal block within a function. */
1301 dbxout_begin_block (unsigned int line ATTRIBUTE_UNUSED
, unsigned int n
)
1303 emit_pending_bincls_if_required ();
1304 targetm
.asm_out
.internal_label (asm_out_file
, "LBB", n
);
1307 /* Describe the end line-number of an internal block within a function. */
1310 dbxout_end_block (unsigned int line ATTRIBUTE_UNUSED
, unsigned int n
)
1312 emit_pending_bincls_if_required ();
1313 targetm
.asm_out
.internal_label (asm_out_file
, "LBE", n
);
1316 /* Output dbx data for a function definition.
1317 This includes a definition of the function name itself (a symbol),
1318 definitions of the parameters (locating them in the parameter list)
1319 and then output the block that makes up the function's body
1320 (including all the auto variables of the function). */
1323 dbxout_function_decl (tree decl
)
1325 emit_pending_bincls_if_required ();
1326 #ifndef DBX_FUNCTION_FIRST
1327 dbxout_begin_function (decl
);
1329 dbxout_block (DECL_INITIAL (decl
), 0, DECL_ARGUMENTS (decl
));
1330 dbxout_function_end (decl
);
1333 #endif /* DBX_DEBUGGING_INFO */
1336 dbxout_early_global_decl (tree decl ATTRIBUTE_UNUSED
)
1338 /* NYI for non-dwarf. */
1341 /* Debug information for a global DECL. Called from toplev.c after
1342 compilation proper has finished. */
1344 dbxout_late_global_decl (tree decl
)
1346 if (TREE_CODE (decl
) == VAR_DECL
&& !DECL_EXTERNAL (decl
))
1348 int saved_tree_used
= TREE_USED (decl
);
1349 TREE_USED (decl
) = 1;
1350 dbxout_symbol (decl
, 0);
1351 TREE_USED (decl
) = saved_tree_used
;
1355 /* This is just a function-type adapter; dbxout_symbol does exactly
1356 what we want but returns an int. */
1358 dbxout_type_decl (tree decl
, int local
)
1360 dbxout_symbol (decl
, local
);
1363 /* At the end of compilation, finish writing the symbol table.
1364 The default is to call debug_free_queue but do nothing else. */
1367 dbxout_finish (const char *filename ATTRIBUTE_UNUSED
)
1369 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
1370 DBX_OUTPUT_MAIN_SOURCE_FILE_END (asm_out_file
, filename
);
1371 #elif defined DBX_OUTPUT_NULL_N_SO_AT_MAIN_SOURCE_FILE_END
1373 switch_to_section (text_section
);
1374 dbxout_begin_empty_stabs (N_SO
);
1375 dbxout_stab_value_internal_label ("Letext", 0);
1378 debug_free_queue ();
1381 /* Output the index of a type. */
1384 dbxout_type_index (tree type
)
1386 #ifndef DBX_USE_BINCL
1387 stabstr_D (TYPE_SYMTAB_ADDRESS (type
));
1389 struct typeinfo
*t
= &typevec
[TYPE_SYMTAB_ADDRESS (type
)];
1391 stabstr_D (t
->file_number
);
1393 stabstr_D (t
->type_number
);
1399 /* Generate the symbols for any queued up type symbols we encountered
1400 while generating the type info for some originally used symbol.
1401 This might generate additional entries in the queue. Only when
1402 the nesting depth goes to 0 is this routine called. */
1405 debug_flush_symbol_queue (void)
1409 /* Make sure that additionally queued items are not flushed
1414 for (i
= 0; i
< symbol_queue_index
; ++i
)
1416 /* If we pushed queued symbols then such symbols must be
1417 output no matter what anyone else says. Specifically,
1418 we need to make sure dbxout_symbol() thinks the symbol was
1419 used and also we need to override TYPE_DECL_SUPPRESS_DEBUG
1420 which may be set for outside reasons. */
1421 int saved_tree_used
= TREE_USED (symbol_queue
[i
]);
1422 int saved_suppress_debug
= TYPE_DECL_SUPPRESS_DEBUG (symbol_queue
[i
]);
1423 TREE_USED (symbol_queue
[i
]) = 1;
1424 TYPE_DECL_SUPPRESS_DEBUG (symbol_queue
[i
]) = 0;
1426 #ifdef DBX_DEBUGGING_INFO
1427 dbxout_symbol (symbol_queue
[i
], 0);
1430 TREE_USED (symbol_queue
[i
]) = saved_tree_used
;
1431 TYPE_DECL_SUPPRESS_DEBUG (symbol_queue
[i
]) = saved_suppress_debug
;
1434 symbol_queue_index
= 0;
1438 /* Queue a type symbol needed as part of the definition of a decl
1439 symbol. These symbols are generated when debug_flush_symbol_queue()
1443 debug_queue_symbol (tree decl
)
1445 if (symbol_queue_index
>= symbol_queue_size
)
1447 symbol_queue_size
+= 10;
1448 symbol_queue
= XRESIZEVEC (tree
, symbol_queue
, symbol_queue_size
);
1451 symbol_queue
[symbol_queue_index
++] = decl
;
1454 /* Free symbol queue. */
1456 debug_free_queue (void)
1460 free (symbol_queue
);
1461 symbol_queue
= NULL
;
1462 symbol_queue_size
= 0;
1466 /* Used in several places: evaluates to '0' for a private decl,
1467 '1' for a protected decl, '2' for a public decl. */
1468 #define DECL_ACCESSIBILITY_CHAR(DECL) \
1469 (TREE_PRIVATE (DECL) ? '0' : TREE_PROTECTED (DECL) ? '1' : '2')
1471 /* Subroutine of `dbxout_type'. Output the type fields of TYPE.
1472 This must be a separate function because anonymous unions require
1476 dbxout_type_fields (tree type
)
1480 /* Output the name, type, position (in bits), size (in bits) of each
1481 field that we can support. */
1482 for (tem
= TYPE_FIELDS (type
); tem
; tem
= DECL_CHAIN (tem
))
1484 /* If one of the nodes is an error_mark or its type is then
1486 if (error_operand_p (tem
))
1489 /* Omit here local type decls until we know how to support them. */
1490 if (TREE_CODE (tem
) == TYPE_DECL
1491 /* Omit here the nameless fields that are used to skip bits. */
1492 || DECL_IGNORED_P (tem
)
1493 /* Omit fields whose position or size are variable or too large to
1495 || (TREE_CODE (tem
) == FIELD_DECL
1496 && (! tree_fits_shwi_p (bit_position (tem
))
1497 || ! DECL_SIZE (tem
)
1498 || ! tree_fits_uhwi_p (DECL_SIZE (tem
)))))
1501 else if (TREE_CODE (tem
) != CONST_DECL
)
1503 /* Continue the line if necessary,
1504 but not before the first field. */
1505 if (tem
!= TYPE_FIELDS (type
))
1508 if (DECL_NAME (tem
))
1509 stabstr_I (DECL_NAME (tem
));
1512 if (use_gnu_debug_info_extensions
1513 && (TREE_PRIVATE (tem
) || TREE_PROTECTED (tem
)
1514 || TREE_CODE (tem
) != FIELD_DECL
))
1517 stabstr_C (DECL_ACCESSIBILITY_CHAR (tem
));
1520 dbxout_type ((TREE_CODE (tem
) == FIELD_DECL
1521 && DECL_BIT_FIELD_TYPE (tem
))
1522 ? DECL_BIT_FIELD_TYPE (tem
) : TREE_TYPE (tem
), 0);
1524 if (TREE_CODE (tem
) == VAR_DECL
)
1526 if (TREE_STATIC (tem
) && use_gnu_debug_info_extensions
)
1528 tree name
= DECL_ASSEMBLER_NAME (tem
);
1535 /* If TEM is non-static, GDB won't understand it. */
1536 stabstr_S (",0,0;");
1541 stabstr_D (int_bit_position (tem
));
1543 stabstr_D (tree_to_uhwi (DECL_SIZE (tem
)));
1550 /* Subroutine of `dbxout_type_methods'. Output debug info about the
1551 method described DECL. */
1554 dbxout_type_method_1 (tree decl
)
1558 if (TREE_CODE (TREE_TYPE (decl
)) == FUNCTION_TYPE
)
1560 else /* it's a METHOD_TYPE. */
1562 tree firstarg
= TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)));
1563 /* A for normal functions.
1564 B for `const' member functions.
1565 C for `volatile' member functions.
1566 D for `const volatile' member functions. */
1567 if (TYPE_READONLY (TREE_TYPE (firstarg
)))
1569 if (TYPE_VOLATILE (TREE_TYPE (firstarg
)))
1572 if (DECL_VINDEX (decl
))
1578 /* ??? Output the mangled name, which contains an encoding of the
1579 method's type signature. May not be necessary anymore. */
1581 stabstr_I (DECL_ASSEMBLER_NAME (decl
));
1583 stabstr_C (DECL_ACCESSIBILITY_CHAR (decl
));
1587 if (DECL_VINDEX (decl
) && tree_fits_shwi_p (DECL_VINDEX (decl
)))
1589 stabstr_D (tree_to_shwi (DECL_VINDEX (decl
)));
1591 dbxout_type (DECL_CONTEXT (decl
), 0);
1596 /* Subroutine of `dbxout_type'. Output debug info about the methods defined
1600 dbxout_type_methods (tree type
)
1602 /* C++: put out the method names and their parameter lists */
1603 tree methods
= TYPE_METHODS (type
);
1607 if (methods
== NULL_TREE
)
1610 if (TREE_CODE (methods
) != TREE_VEC
)
1612 else if (TREE_VEC_ELT (methods
, 0) != NULL_TREE
)
1613 fndecl
= TREE_VEC_ELT (methods
, 0);
1615 fndecl
= TREE_VEC_ELT (methods
, 1);
1619 int need_prefix
= 1;
1621 /* Group together all the methods for the same operation.
1622 These differ in the types of the arguments. */
1623 for (last
= NULL_TREE
;
1624 fndecl
&& (last
== NULL_TREE
|| DECL_NAME (fndecl
) == DECL_NAME (last
));
1625 fndecl
= DECL_CHAIN (fndecl
))
1626 /* Output the name of the field (after overloading), as
1627 well as the name of the field before overloading, along
1628 with its parameter list */
1630 /* Skip methods that aren't FUNCTION_DECLs. (In C++, these
1631 include TEMPLATE_DECLs.) The debugger doesn't know what
1632 to do with such entities anyhow. */
1633 if (TREE_CODE (fndecl
) != FUNCTION_DECL
)
1640 /* Also ignore abstract methods; those are only interesting to
1641 the DWARF backends. */
1642 if (DECL_IGNORED_P (fndecl
) || DECL_ABSTRACT_P (fndecl
))
1645 /* Redundantly output the plain name, since that's what gdb
1649 stabstr_I (DECL_NAME (fndecl
));
1654 dbxout_type (TREE_TYPE (fndecl
), 0);
1655 dbxout_type_method_1 (fndecl
);
1662 /* Emit a "range" type specification, which has the form:
1663 "r<index type>;<lower bound>;<upper bound>;".
1664 TYPE is an INTEGER_TYPE, LOW and HIGH are the bounds. */
1667 dbxout_range_type (tree type
, tree low
, tree high
)
1670 if (TREE_TYPE (type
))
1671 dbxout_type (TREE_TYPE (type
), 0);
1672 else if (TREE_CODE (type
) != INTEGER_TYPE
)
1673 dbxout_type (type
, 0); /* E.g. Pascal's ARRAY [BOOLEAN] of INTEGER */
1676 /* Traditionally, we made sure 'int' was type 1, and builtin types
1677 were defined to be sub-ranges of int. Unfortunately, this
1678 does not allow us to distinguish true sub-ranges from integer
1679 types. So, instead we define integer (non-sub-range) types as
1680 sub-ranges of themselves. This matters for Chill. If this isn't
1681 a subrange type, then we want to define it in terms of itself.
1682 However, in C, this may be an anonymous integer type, and we don't
1683 want to emit debug info referring to it. Just calling
1684 dbxout_type_index won't work anyways, because the type hasn't been
1685 defined yet. We make this work for both cases by checked to see
1686 whether this is a defined type, referring to it if it is, and using
1688 if (TYPE_SYMTAB_ADDRESS (type
) != 0)
1689 dbxout_type_index (type
);
1691 dbxout_type_index (integer_type_node
);
1695 if (low
&& tree_fits_shwi_p (low
))
1697 if (print_int_cst_bounds_in_octal_p (type
, low
, high
))
1700 stabstr_D (tree_to_shwi (low
));
1706 if (high
&& tree_fits_shwi_p (high
))
1708 if (print_int_cst_bounds_in_octal_p (type
, low
, high
))
1711 stabstr_D (tree_to_shwi (high
));
1719 /* Output a reference to a type. If the type has not yet been
1720 described in the dbx output, output its definition now.
1721 For a type already defined, just refer to its definition
1722 using the type number.
1724 If FULL is nonzero, and the type has been described only with
1725 a forward-reference, output the definition now.
1726 If FULL is zero in this case, just refer to the forward-reference
1727 using the number previously allocated. */
1730 dbxout_type (tree type
, int full
)
1732 static int anonymous_type_number
= 0;
1733 tree tem
, main_variant
, low
, high
;
1735 if (TREE_CODE (type
) == INTEGER_TYPE
)
1737 if (TREE_TYPE (type
) == 0)
1739 low
= TYPE_MIN_VALUE (type
);
1740 high
= TYPE_MAX_VALUE (type
);
1743 else if (subrange_type_for_debug_p (type
, &low
, &high
))
1746 /* If this is a subtype that should not be emitted as a subrange type,
1747 use the base type. */
1750 type
= TREE_TYPE (type
);
1751 low
= TYPE_MIN_VALUE (type
);
1752 high
= TYPE_MAX_VALUE (type
);
1756 /* If there was an input error and we don't really have a type,
1757 avoid crashing and write something that is at least valid
1758 by assuming `int'. */
1759 if (type
== error_mark_node
)
1760 type
= integer_type_node
;
1763 if (TYPE_NAME (type
)
1764 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1765 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type
)))
1769 /* Try to find the "main variant" with the same name. */
1770 if (TYPE_NAME (type
) && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1771 && DECL_ORIGINAL_TYPE (TYPE_NAME (type
)))
1772 main_variant
= TREE_TYPE (TYPE_NAME (type
));
1774 main_variant
= TYPE_MAIN_VARIANT (type
);
1776 /* If we are not using extensions, stabs does not distinguish const and
1777 volatile, so there is no need to make them separate types. */
1778 if (!use_gnu_debug_info_extensions
)
1779 type
= main_variant
;
1781 if (TYPE_SYMTAB_ADDRESS (type
) == 0)
1783 /* Type has no dbx number assigned. Assign next available number. */
1784 TYPE_SYMTAB_ADDRESS (type
) = next_type_number
++;
1786 /* Make sure type vector is long enough to record about this type. */
1788 if (next_type_number
== typevec_len
)
1790 typevec
= GGC_RESIZEVEC (struct typeinfo
, typevec
, typevec_len
* 2);
1791 memset (typevec
+ typevec_len
, 0, typevec_len
* sizeof typevec
[0]);
1795 #ifdef DBX_USE_BINCL
1796 emit_pending_bincls_if_required ();
1797 typevec
[TYPE_SYMTAB_ADDRESS (type
)].file_number
1798 = current_file
->file_number
;
1799 typevec
[TYPE_SYMTAB_ADDRESS (type
)].type_number
1800 = current_file
->next_type_number
++;
1804 if (flag_debug_only_used_symbols
)
1806 if ((TREE_CODE (type
) == RECORD_TYPE
1807 || TREE_CODE (type
) == UNION_TYPE
1808 || TREE_CODE (type
) == QUAL_UNION_TYPE
1809 || TREE_CODE (type
) == ENUMERAL_TYPE
)
1810 && TYPE_STUB_DECL (type
)
1811 && DECL_P (TYPE_STUB_DECL (type
))
1812 && ! DECL_IGNORED_P (TYPE_STUB_DECL (type
)))
1813 debug_queue_symbol (TYPE_STUB_DECL (type
));
1814 else if (TYPE_NAME (type
)
1815 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
1816 debug_queue_symbol (TYPE_NAME (type
));
1819 /* Output the number of this type, to refer to it. */
1820 dbxout_type_index (type
);
1822 #ifdef DBX_TYPE_DEFINED
1823 if (DBX_TYPE_DEFINED (type
))
1827 /* If this type's definition has been output or is now being output,
1830 switch (typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
)
1835 /* If we have already had a cross reference,
1836 and either that's all we want or that's the best we could do,
1837 don't repeat the cross reference.
1838 Sun dbx crashes if we do. */
1839 if (! full
|| !COMPLETE_TYPE_P (type
)
1840 /* No way in DBX fmt to describe a variable size. */
1841 || ! tree_fits_uhwi_p (TYPE_SIZE (type
)))
1849 /* For systems where dbx output does not allow the `=xsNAME:' syntax,
1850 leave the type-number completely undefined rather than output
1851 a cross-reference. If we have already used GNU debug info extensions,
1852 then it is OK to output a cross reference. This is necessary to get
1853 proper C++ debug output. */
1854 if ((TREE_CODE (type
) == RECORD_TYPE
|| TREE_CODE (type
) == UNION_TYPE
1855 || TREE_CODE (type
) == QUAL_UNION_TYPE
1856 || TREE_CODE (type
) == ENUMERAL_TYPE
)
1857 && ! use_gnu_debug_info_extensions
)
1858 /* We must use the same test here as we use twice below when deciding
1859 whether to emit a cross-reference. */
1860 if ((TYPE_NAME (type
) != 0
1861 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1862 && DECL_IGNORED_P (TYPE_NAME (type
)))
1864 || !COMPLETE_TYPE_P (type
)
1865 /* No way in DBX fmt to describe a variable size. */
1866 || ! tree_fits_uhwi_p (TYPE_SIZE (type
)))
1868 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1873 /* Output a definition now. */
1876 /* Mark it as defined, so that if it is self-referent
1877 we will not get into an infinite recursion of definitions. */
1879 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_DEFINED
;
1881 /* If this type is a variant of some other, hand off. Types with
1882 different names are usefully distinguished. We only distinguish
1883 cv-qualified types if we're using extensions. */
1884 if (TYPE_READONLY (type
) > TYPE_READONLY (main_variant
))
1887 dbxout_type (build_type_variant (type
, 0, TYPE_VOLATILE (type
)), 0);
1890 else if (TYPE_VOLATILE (type
) > TYPE_VOLATILE (main_variant
))
1893 dbxout_type (build_type_variant (type
, TYPE_READONLY (type
), 0), 0);
1896 else if (main_variant
!= TYPE_MAIN_VARIANT (type
))
1898 if (flag_debug_only_used_symbols
)
1900 tree orig_type
= DECL_ORIGINAL_TYPE (TYPE_NAME (type
));
1902 if ((TREE_CODE (orig_type
) == RECORD_TYPE
1903 || TREE_CODE (orig_type
) == UNION_TYPE
1904 || TREE_CODE (orig_type
) == QUAL_UNION_TYPE
1905 || TREE_CODE (orig_type
) == ENUMERAL_TYPE
)
1906 && TYPE_STUB_DECL (orig_type
)
1907 && ! DECL_IGNORED_P (TYPE_STUB_DECL (orig_type
)))
1908 debug_queue_symbol (TYPE_STUB_DECL (orig_type
));
1910 /* 'type' is a typedef; output the type it refers to. */
1911 dbxout_type (DECL_ORIGINAL_TYPE (TYPE_NAME (type
)), 0);
1914 /* else continue. */
1916 switch (TREE_CODE (type
))
1921 /* For a void type, just define it as itself; i.e., "5=5".
1922 This makes us consider it defined
1923 without saying what it is. The debugger will make it
1924 a void type when the reference is seen, and nothing will
1925 ever override that default. */
1926 dbxout_type_index (type
);
1930 if (type
== char_type_node
&& ! TYPE_UNSIGNED (type
))
1932 /* Output the type `char' as a subrange of itself!
1933 I don't understand this definition, just copied it
1934 from the output of pcc.
1935 This used to use `r2' explicitly and we used to
1936 take care to make sure that `char' was type number 2. */
1938 dbxout_type_index (type
);
1939 stabstr_S (";0;127;");
1942 /* If this is a subtype of another integer type, always prefer to
1943 write it as a subtype. */
1944 else if (TREE_TYPE (type
) != 0
1945 && TREE_CODE (TREE_TYPE (type
)) == INTEGER_TYPE
)
1947 /* If the size is non-standard, say what it is if we can use
1950 if (use_gnu_debug_info_extensions
1951 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
1954 stabstr_D (TYPE_PRECISION (type
));
1958 dbxout_range_type (type
, low
, high
);
1963 /* If the size is non-standard, say what it is if we can use
1966 if (use_gnu_debug_info_extensions
1967 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
1970 stabstr_D (TYPE_PRECISION (type
));
1974 if (print_int_cst_bounds_in_octal_p (type
, low
, high
))
1978 /* If this type derives from another type, output type index of
1979 parent type. This is particularly important when parent type
1980 is an enumerated type, because not generating the parent type
1981 index would transform the definition of this enumerated type
1982 into a plain unsigned type. */
1983 if (TREE_TYPE (type
) != 0)
1984 dbxout_type_index (TREE_TYPE (type
));
1986 dbxout_type_index (type
);
1996 /* Output other integer types as subranges of `int'. */
1997 dbxout_range_type (type
, low
, high
);
2003 case FIXED_POINT_TYPE
:
2004 /* This used to say `r1' and we used to take care
2005 to make sure that `int' was type number 1. */
2007 dbxout_type_index (integer_type_node
);
2009 stabstr_D (int_size_in_bytes (type
));
2014 if (use_gnu_debug_info_extensions
)
2017 stabstr_D (BITS_PER_UNIT
* int_size_in_bytes (type
));
2018 stabstr_S (";-16;");
2020 else /* Define as enumeral type (False, True) */
2021 stabstr_S ("eFalse:0,True:1,;");
2025 /* Differs from the REAL_TYPE by its new data type number.
2026 R3 is NF_COMPLEX. We don't try to use any of the other NF_*
2027 codes since gdb doesn't care anyway. */
2029 if (TREE_CODE (TREE_TYPE (type
)) == REAL_TYPE
)
2032 stabstr_D (2 * int_size_in_bytes (TREE_TYPE (type
)));
2037 /* Output a complex integer type as a structure,
2038 pending some other way to do it. */
2040 stabstr_D (int_size_in_bytes (type
));
2042 stabstr_S ("real:");
2043 dbxout_type (TREE_TYPE (type
), 0);
2045 stabstr_D (TYPE_PRECISION (TREE_TYPE (type
)));
2047 stabstr_S (";imag:");
2048 dbxout_type (TREE_TYPE (type
), 0);
2050 stabstr_D (TYPE_PRECISION (TREE_TYPE (type
)));
2052 stabstr_D (TYPE_PRECISION (TREE_TYPE (type
)));
2058 /* Make arrays of packed bits look like bitstrings for chill. */
2059 if (TYPE_PACKED (type
) && use_gnu_debug_info_extensions
)
2062 stabstr_D (BITS_PER_UNIT
* int_size_in_bytes (type
));
2063 stabstr_S (";@S;S");
2064 dbxout_type (TYPE_DOMAIN (type
), 0);
2068 /* Output "a" followed by a range type definition
2069 for the index type of the array
2070 followed by a reference to the target-type.
2071 ar1;0;N;M for a C array of type M and size N+1. */
2072 /* Check if a character string type, which in Chill is
2073 different from an array of characters. */
2074 if (TYPE_STRING_FLAG (type
) && use_gnu_debug_info_extensions
)
2078 tem
= TYPE_DOMAIN (type
);
2082 dbxout_type_index (integer_type_node
);
2083 stabstr_S (";0;-1;");
2088 dbxout_range_type (tem
, TYPE_MIN_VALUE (tem
), TYPE_MAX_VALUE (tem
));
2091 dbxout_type (TREE_TYPE (type
), 0);
2095 /* Make vectors look like an array. */
2096 if (use_gnu_debug_info_extensions
)
2099 /* Output "a" followed by a range type definition
2100 for the index type of the array
2101 followed by a reference to the target-type.
2102 ar1;0;N;M for a C array of type M and size N+1. */
2104 dbxout_range_type (integer_type_node
, size_zero_node
,
2105 size_int (TYPE_VECTOR_SUBPARTS (type
) - 1));
2107 dbxout_type (TREE_TYPE (type
), 0);
2112 case QUAL_UNION_TYPE
:
2114 tree binfo
= TYPE_BINFO (type
);
2116 /* Output a structure type. We must use the same test here as we
2117 use in the DBX_NO_XREFS case above. */
2118 if ((TYPE_NAME (type
) != 0
2119 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
2120 && DECL_IGNORED_P (TYPE_NAME (type
)))
2122 || !COMPLETE_TYPE_P (type
)
2123 /* No way in DBX fmt to describe a variable size. */
2124 || ! tree_fits_uhwi_p (TYPE_SIZE (type
)))
2126 /* If the type is just a cross reference, output one
2127 and mark the type as partially described.
2128 If it later becomes defined, we will output
2129 its real definition.
2130 If the type has a name, don't nest its definition within
2131 another type's definition; instead, output an xref
2132 and let the definition come when the name is defined. */
2133 stabstr_S ((TREE_CODE (type
) == RECORD_TYPE
) ? "xs" : "xu");
2134 if (TYPE_IDENTIFIER (type
))
2136 /* Note that the C frontend creates for anonymous variable
2137 length records/unions TYPE_NAME with DECL_NAME NULL. */
2138 dbxout_type_name (type
);
2143 stabstr_D (anonymous_type_number
++);
2147 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
2151 /* Identify record or union, and print its size. */
2152 stabstr_C ((TREE_CODE (type
) == RECORD_TYPE
) ? 's' : 'u');
2153 stabstr_D (int_size_in_bytes (type
));
2159 vec
<tree
, va_gc
> *accesses
= BINFO_BASE_ACCESSES (binfo
);
2161 if (use_gnu_debug_info_extensions
)
2163 if (BINFO_N_BASE_BINFOS (binfo
))
2166 stabstr_U (BINFO_N_BASE_BINFOS (binfo
));
2170 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, child
); i
++)
2172 tree access
= (accesses
? (*accesses
)[i
] : access_public_node
);
2174 if (use_gnu_debug_info_extensions
)
2176 stabstr_C (BINFO_VIRTUAL_P (child
) ? '1' : '0');
2177 stabstr_C (access
== access_public_node
? '2' :
2178 access
== access_protected_node
2180 if (BINFO_VIRTUAL_P (child
)
2182 || strcmp (lang_hooks
.name
, "GNU Objective-C++") == 0))
2183 /* For a virtual base, print the (negative)
2184 offset within the vtable where we must look
2185 to find the necessary adjustment. */
2187 (tree_to_shwi (BINFO_VPTR_FIELD (child
))
2190 stabstr_D (tree_to_shwi (BINFO_OFFSET (child
))
2193 dbxout_type (BINFO_TYPE (child
), 0);
2198 /* Print out the base class information with
2199 fields which have the same names at the types
2201 dbxout_type_name (BINFO_TYPE (child
));
2203 dbxout_type (BINFO_TYPE (child
), full
);
2205 stabstr_D (tree_to_shwi (BINFO_OFFSET (child
))
2209 (tree_to_shwi (TYPE_SIZE (BINFO_TYPE (child
)))
2217 /* Write out the field declarations. */
2218 dbxout_type_fields (type
);
2219 if (use_gnu_debug_info_extensions
&& TYPE_METHODS (type
) != NULL_TREE
)
2221 dbxout_type_methods (type
);
2226 if (use_gnu_debug_info_extensions
&& TREE_CODE (type
) == RECORD_TYPE
2227 /* Avoid the ~ if we don't really need it--it confuses dbx. */
2228 && TYPE_VFIELD (type
))
2231 /* We need to write out info about what field this class
2232 uses as its "main" vtable pointer field, because if this
2233 field is inherited from a base class, GDB cannot necessarily
2234 figure out which field it's using in time. */
2236 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type
)), 0);
2242 /* We must use the same test here as we use in the DBX_NO_XREFS case
2243 above. We simplify it a bit since an enum will never have a variable
2245 if ((TYPE_NAME (type
) != 0
2246 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
2247 && DECL_IGNORED_P (TYPE_NAME (type
)))
2249 || !COMPLETE_TYPE_P (type
))
2252 dbxout_type_name (type
);
2253 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
2257 if (use_gnu_debug_info_extensions
2258 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
2261 stabstr_D (TYPE_PRECISION (type
));
2266 for (tem
= TYPE_VALUES (type
); tem
; tem
= TREE_CHAIN (tem
))
2268 tree value
= TREE_VALUE (tem
);
2270 stabstr_I (TREE_PURPOSE (tem
));
2273 if (TREE_CODE (value
) == CONST_DECL
)
2274 value
= DECL_INITIAL (value
);
2276 if (cst_and_fits_in_hwi (value
))
2277 stabstr_D (TREE_INT_CST_LOW (value
));
2282 if (TREE_CHAIN (tem
) != 0)
2291 dbxout_type (TREE_TYPE (type
), 0);
2295 if (use_gnu_debug_info_extensions
)
2299 /* Write the argument types out longhand. */
2300 dbxout_type (TYPE_METHOD_BASETYPE (type
), 0);
2302 dbxout_type (TREE_TYPE (type
), 0);
2303 dbxout_args (TYPE_ARG_TYPES (type
));
2307 /* Treat it as a function type. */
2308 dbxout_type (TREE_TYPE (type
), 0);
2312 if (use_gnu_debug_info_extensions
)
2315 dbxout_type (TYPE_OFFSET_BASETYPE (type
), 0);
2317 dbxout_type (TREE_TYPE (type
), 0);
2320 /* Should print as an int, because it is really just an offset. */
2321 dbxout_type (integer_type_node
, 0);
2324 case REFERENCE_TYPE
:
2325 if (use_gnu_debug_info_extensions
)
2331 dbxout_type (TREE_TYPE (type
), 0);
2336 dbxout_type (TREE_TYPE (type
), 0);
2339 case POINTER_BOUNDS_TYPE
:
2340 /* No debug info for pointer bounds type supported yet. */
2344 /* A C++ function with deduced return type can have a TEMPLATE_TYPE_PARM
2345 named 'auto' in its type.
2346 No debug info for TEMPLATE_TYPE_PARM type supported yet. */
2347 if (lang_GNU_CXX ())
2349 tree name
= TYPE_IDENTIFIER (type
);
2350 if (name
== get_identifier ("auto")
2351 || name
== get_identifier ("decltype(auto)"))
2359 /* Return nonzero if the given type represents an integer whose bounds
2360 should be printed in octal format. */
2363 print_int_cst_bounds_in_octal_p (tree type
, tree low
, tree high
)
2365 /* If we can use GDB extensions and the size is wider than a long
2366 (the size used by GDB to read them) or we may have trouble writing
2367 the bounds the usual way, write them in octal. Note the test is for
2368 the *target's* size of "long", not that of the host. The host test
2369 is just to make sure we can write it out in case the host wide int
2370 is narrower than the target "long".
2372 For unsigned types, we use octal if they are the same size or larger.
2373 This is because we print the bounds as signed decimal, and hence they
2374 can't span same size unsigned types. */
2376 if (use_gnu_debug_info_extensions
2377 && low
&& TREE_CODE (low
) == INTEGER_CST
2378 && high
&& TREE_CODE (high
) == INTEGER_CST
2379 && (TYPE_PRECISION (type
) > TYPE_PRECISION (integer_type_node
)
2380 || ((TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
))
2381 && TYPE_UNSIGNED (type
))
2382 || TYPE_PRECISION (type
) > HOST_BITS_PER_WIDE_INT
2383 || (TYPE_PRECISION (type
) == HOST_BITS_PER_WIDE_INT
2384 && TYPE_UNSIGNED (type
))))
2390 /* Output the name of type TYPE, with no punctuation.
2391 Such names can be set up either by typedef declarations
2392 or by struct, enum and union tags. */
2395 dbxout_type_name (tree type
)
2397 tree t
= TYPE_NAME (type
);
2400 switch (TREE_CODE (t
))
2402 case IDENTIFIER_NODE
:
2414 /* Output leading leading struct or class names needed for qualifying
2415 type whose scope is limited to a struct or class. */
2418 dbxout_class_name_qualifiers (tree decl
)
2420 tree context
= decl_type_context (decl
);
2422 if (context
!= NULL_TREE
2423 && TREE_CODE (context
) == RECORD_TYPE
2424 && TYPE_NAME (context
) != 0
2425 && (TREE_CODE (TYPE_NAME (context
)) == IDENTIFIER_NODE
2426 || (DECL_NAME (TYPE_NAME (context
)) != 0)))
2428 tree name
= TYPE_NAME (context
);
2430 if (TREE_CODE (name
) == TYPE_DECL
)
2432 dbxout_class_name_qualifiers (name
);
2433 name
= DECL_NAME (name
);
2440 /* This is a specialized subset of expand_expr for use by dbxout_symbol in
2441 evaluating DECL_VALUE_EXPR. In particular, we stop if we find decls that
2442 haven't been expanded, or if the expression is getting so complex we won't
2443 be able to represent it in stabs anyway. Returns NULL on failure. */
2446 dbxout_expand_expr (tree expr
)
2448 switch (TREE_CODE (expr
))
2451 /* We can't handle emulated tls variables, because the address is an
2452 offset to the return value of __emutls_get_address, and there is no
2453 way to express that in stabs. Also, there are name mangling issues
2454 here. We end up with references to undefined symbols if we don't
2455 disable debug info for these variables. */
2456 if (!targetm
.have_tls
&& DECL_THREAD_LOCAL_P (expr
))
2458 if (TREE_STATIC (expr
)
2459 && !TREE_ASM_WRITTEN (expr
)
2460 && !DECL_HAS_VALUE_EXPR_P (expr
)
2461 && !TREE_PUBLIC (expr
)
2462 && DECL_RTL_SET_P (expr
)
2463 && MEM_P (DECL_RTL (expr
)))
2465 /* If this is a var that might not be actually output,
2466 return NULL, otherwise stabs might reference an undefined
2468 varpool_node
*node
= varpool_node::get (expr
);
2469 if (!node
|| !node
->definition
)
2476 if (DECL_HAS_VALUE_EXPR_P (expr
))
2477 return dbxout_expand_expr (DECL_VALUE_EXPR (expr
));
2481 return DECL_RTL_IF_SET (expr
);
2484 return expand_expr (expr
, NULL_RTX
, VOIDmode
, EXPAND_INITIALIZER
);
2488 case ARRAY_RANGE_REF
:
2492 HOST_WIDE_INT bitsize
, bitpos
;
2494 int volatilep
= 0, unsignedp
= 0;
2497 tem
= get_inner_reference (expr
, &bitsize
, &bitpos
, &offset
,
2498 &mode
, &unsignedp
, &volatilep
, true);
2500 x
= dbxout_expand_expr (tem
);
2501 if (x
== NULL
|| !MEM_P (x
))
2505 if (!tree_fits_shwi_p (offset
))
2507 x
= adjust_address_nv (x
, mode
, tree_to_shwi (offset
));
2510 x
= adjust_address_nv (x
, mode
, bitpos
/ BITS_PER_UNIT
);
2520 /* Helper function for output_used_types. Queue one entry from the
2521 used types hash to be output. */
2524 output_used_types_helper (tree
const &type
, vec
<tree
> *types_p
)
2526 if ((TREE_CODE (type
) == RECORD_TYPE
2527 || TREE_CODE (type
) == UNION_TYPE
2528 || TREE_CODE (type
) == QUAL_UNION_TYPE
2529 || TREE_CODE (type
) == ENUMERAL_TYPE
)
2530 && TYPE_STUB_DECL (type
)
2531 && DECL_P (TYPE_STUB_DECL (type
))
2532 && ! DECL_IGNORED_P (TYPE_STUB_DECL (type
)))
2533 types_p
->quick_push (TYPE_STUB_DECL (type
));
2534 else if (TYPE_NAME (type
)
2535 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
2536 types_p
->quick_push (TYPE_NAME (type
));
2541 /* This is a qsort callback which sorts types and declarations into a
2542 predictable order (types, then declarations, sorted by UID
2546 output_types_sort (const void *pa
, const void *pb
)
2548 const tree lhs
= *((const tree
*)pa
);
2549 const tree rhs
= *((const tree
*)pb
);
2554 return TYPE_UID (lhs
) - TYPE_UID (rhs
);
2563 return DECL_UID (lhs
) - DECL_UID (rhs
);
2568 /* Force all types used by this function to be output in debug
2572 output_used_types (void)
2574 if (cfun
&& cfun
->used_types_hash
)
2580 types
.create (cfun
->used_types_hash
->elements ());
2581 cfun
->used_types_hash
->traverse
<vec
<tree
> *, output_used_types_helper
>
2584 /* Sort by UID to prevent dependence on hash table ordering. */
2585 types
.qsort (output_types_sort
);
2587 FOR_EACH_VEC_ELT (types
, i
, type
)
2588 debug_queue_symbol (type
);
2594 /* Output a .stabs for the symbol defined by DECL,
2595 which must be a ..._DECL node in the normal namespace.
2596 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
2597 LOCAL is nonzero if the scope is less than the entire file.
2598 Return 1 if a stabs might have been emitted. */
2601 dbxout_symbol (tree decl
, int local ATTRIBUTE_UNUSED
)
2603 tree type
= TREE_TYPE (decl
);
2604 tree context
= NULL_TREE
;
2608 /* "Intercept" dbxout_symbol() calls like we do all debug_hooks. */
2611 /* Ignore nameless syms, but don't ignore type tags. */
2613 if ((DECL_NAME (decl
) == 0 && TREE_CODE (decl
) != TYPE_DECL
)
2614 || DECL_IGNORED_P (decl
))
2615 DBXOUT_DECR_NESTING_AND_RETURN (0);
2617 /* If we are to generate only the symbols actually used then such
2618 symbol nodes are flagged with TREE_USED. Ignore any that
2619 aren't flagged as TREE_USED. */
2621 if (flag_debug_only_used_symbols
2622 && (!TREE_USED (decl
)
2623 && (TREE_CODE (decl
) != VAR_DECL
|| !DECL_INITIAL (decl
))))
2624 DBXOUT_DECR_NESTING_AND_RETURN (0);
2626 /* If dbxout_init has not yet run, queue this symbol for later. */
2629 preinit_symbols
= tree_cons (0, decl
, preinit_symbols
);
2630 DBXOUT_DECR_NESTING_AND_RETURN (0);
2633 if (flag_debug_only_used_symbols
)
2637 /* We now have a used symbol. We need to generate the info for
2638 the symbol's type in addition to the symbol itself. These
2639 type symbols are queued to be generated after were done with
2640 the symbol itself (otherwise they would fight over the
2643 Note, because the TREE_TYPE(type) might be something like a
2644 pointer to a named type we need to look for the first name
2645 we see following the TREE_TYPE chain. */
2648 while (POINTER_TYPE_P (t
))
2651 /* RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, and ENUMERAL_TYPE
2652 need special treatment. The TYPE_STUB_DECL field in these
2653 types generally represents the tag name type we want to
2654 output. In addition there could be a typedef type with
2655 a different name. In that case we also want to output
2658 if (TREE_CODE (t
) == RECORD_TYPE
2659 || TREE_CODE (t
) == UNION_TYPE
2660 || TREE_CODE (t
) == QUAL_UNION_TYPE
2661 || TREE_CODE (t
) == ENUMERAL_TYPE
)
2663 if (TYPE_STUB_DECL (t
)
2664 && TYPE_STUB_DECL (t
) != decl
2665 && DECL_P (TYPE_STUB_DECL (t
))
2666 && ! DECL_IGNORED_P (TYPE_STUB_DECL (t
)))
2668 debug_queue_symbol (TYPE_STUB_DECL (t
));
2670 && TYPE_NAME (t
) != TYPE_STUB_DECL (t
)
2671 && TYPE_NAME (t
) != decl
2672 && DECL_P (TYPE_NAME (t
)))
2673 debug_queue_symbol (TYPE_NAME (t
));
2676 else if (TYPE_NAME (t
)
2677 && TYPE_NAME (t
) != decl
2678 && DECL_P (TYPE_NAME (t
)))
2679 debug_queue_symbol (TYPE_NAME (t
));
2682 emit_pending_bincls_if_required ();
2684 switch (TREE_CODE (decl
))
2687 /* Enum values are defined by defining the enum type. */
2691 decl_rtl
= DECL_RTL_IF_SET (decl
);
2693 DBXOUT_DECR_NESTING_AND_RETURN (0);
2694 if (DECL_EXTERNAL (decl
))
2696 /* Don't mention a nested function under its parent. */
2697 context
= decl_function_context (decl
);
2698 if (context
== current_function_decl
)
2700 /* Don't mention an inline instance of a nested function. */
2701 if (context
&& DECL_FROM_INLINE (decl
))
2703 if (!MEM_P (decl_rtl
)
2704 || GET_CODE (XEXP (decl_rtl
, 0)) != SYMBOL_REF
)
2707 if (flag_debug_only_used_symbols
)
2708 output_used_types ();
2710 dbxout_begin_complex_stabs ();
2711 stabstr_I (DECL_ASSEMBLER_NAME (decl
));
2712 stabstr_S (TREE_PUBLIC (decl
) ? ":F" : ":f");
2715 if (TREE_TYPE (type
))
2716 dbxout_type (TREE_TYPE (type
), 0);
2718 dbxout_type (void_type_node
, 0);
2720 /* For a nested function, when that function is compiled,
2721 mention the containing function name
2722 as well as (since dbx wants it) our own assembler-name. */
2726 stabstr_I (DECL_ASSEMBLER_NAME (decl
));
2728 stabstr_I (DECL_NAME (context
));
2731 dbxout_finish_complex_stabs (decl
, N_FUN
, XEXP (decl_rtl
, 0), 0, 0);
2735 /* Don't output the same typedef twice.
2736 And don't output what language-specific stuff doesn't want output. */
2737 if (TREE_ASM_WRITTEN (decl
) || TYPE_DECL_SUPPRESS_DEBUG (decl
))
2738 DBXOUT_DECR_NESTING_AND_RETURN (0);
2740 /* Don't output typedefs for types with magic type numbers (XCOFF). */
2741 #ifdef DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER
2743 int fundamental_type_number
=
2744 DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER (decl
);
2746 if (fundamental_type_number
!= 0)
2748 TREE_ASM_WRITTEN (decl
) = 1;
2749 TYPE_SYMTAB_ADDRESS (TREE_TYPE (decl
)) = fundamental_type_number
;
2750 DBXOUT_DECR_NESTING_AND_RETURN (0);
2760 if (DECL_NAME (decl
))
2762 /* Nonzero means we must output a tag as well as a typedef. */
2765 /* Handle the case of a C++ structure or union
2766 where the TYPE_NAME is a TYPE_DECL
2767 which gives both a typedef name and a tag. */
2768 /* dbx requires the tag first and the typedef second. */
2769 if ((TREE_CODE (type
) == RECORD_TYPE
2770 || TREE_CODE (type
) == UNION_TYPE
2771 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
2772 && TYPE_NAME (type
) == decl
2773 && !use_gnu_debug_info_extensions
2774 && !TREE_ASM_WRITTEN (TYPE_NAME (type
))
2775 /* Distinguish the implicit typedefs of C++
2776 from explicit ones that might be found in C. */
2777 && DECL_ARTIFICIAL (decl
)
2778 /* Do not generate a tag for incomplete records. */
2779 && COMPLETE_TYPE_P (type
)
2780 /* Do not generate a tag for records of variable size,
2781 since this type can not be properly described in the
2782 DBX format, and it confuses some tools such as objdump. */
2783 && tree_fits_uhwi_p (TYPE_SIZE (type
)))
2785 tree name
= TYPE_IDENTIFIER (type
);
2787 dbxout_begin_complex_stabs ();
2790 dbxout_type (type
, 1);
2791 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE
,
2795 dbxout_begin_complex_stabs ();
2797 /* Output leading class/struct qualifiers. */
2798 if (use_gnu_debug_info_extensions
)
2799 dbxout_class_name_qualifiers (decl
);
2801 /* Output typedef name. */
2802 stabstr_I (DECL_NAME (decl
));
2805 /* Short cut way to output a tag also. */
2806 if ((TREE_CODE (type
) == RECORD_TYPE
2807 || TREE_CODE (type
) == UNION_TYPE
2808 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
2809 && TYPE_NAME (type
) == decl
2810 /* Distinguish the implicit typedefs of C++
2811 from explicit ones that might be found in C. */
2812 && DECL_ARTIFICIAL (decl
))
2814 if (use_gnu_debug_info_extensions
)
2817 TREE_ASM_WRITTEN (TYPE_NAME (type
)) = 1;
2822 dbxout_type (type
, 1);
2823 dbxout_finish_complex_stabs (decl
, DBX_TYPE_DECL_STABS_CODE
,
2828 /* Don't output a tag if this is an incomplete type. This prevents
2829 the sun4 Sun OS 4.x dbx from crashing. */
2831 if (tag_needed
&& TYPE_NAME (type
) != 0
2832 && (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
2833 || (DECL_NAME (TYPE_NAME (type
)) != 0))
2834 && COMPLETE_TYPE_P (type
)
2835 && !TREE_ASM_WRITTEN (TYPE_NAME (type
)))
2837 /* For a TYPE_DECL with no name, but the type has a name,
2839 This is what represents `struct foo' with no typedef. */
2840 /* In C++, the name of a type is the corresponding typedef.
2841 In C, it is an IDENTIFIER_NODE. */
2842 tree name
= TYPE_IDENTIFIER (type
);
2844 dbxout_begin_complex_stabs ();
2847 dbxout_type (type
, 1);
2848 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE
, 0, 0, 0);
2852 /* If an enum type has no name, it cannot be referred to, but
2853 we must output it anyway, to record the enumeration
2856 if (!did_output
&& TREE_CODE (type
) == ENUMERAL_TYPE
)
2858 dbxout_begin_complex_stabs ();
2859 /* Some debuggers fail when given NULL names, so give this a
2860 harmless name of " " (Why not "(anon)"?). */
2862 dbxout_type (type
, 1);
2863 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE
, 0, 0, 0);
2866 /* Prevent duplicate output of a typedef. */
2867 TREE_ASM_WRITTEN (decl
) = 1;
2872 if (DECL_HAS_VALUE_EXPR_P (decl
))
2873 decl
= DECL_VALUE_EXPR (decl
);
2875 /* PARM_DECLs go in their own separate chain and are output by
2876 dbxout_reg_parms and dbxout_parms, except for those that are
2877 disguised VAR_DECLs like Out parameters in Ada. */
2878 gcc_assert (TREE_CODE (decl
) == VAR_DECL
);
2880 /* ... fall through ... */
2884 /* Don't mention a variable that is external.
2885 Let the file that defines it describe it. */
2886 if (DECL_EXTERNAL (decl
))
2889 /* If the variable is really a constant
2890 and not written in memory, inform the debugger.
2892 ??? Why do we skip emitting the type and location in this case? */
2893 if (TREE_STATIC (decl
) && TREE_READONLY (decl
)
2894 && DECL_INITIAL (decl
) != 0
2895 && tree_fits_shwi_p (DECL_INITIAL (decl
))
2896 && ! TREE_ASM_WRITTEN (decl
)
2897 && (DECL_FILE_SCOPE_P (decl
)
2898 || TREE_CODE (DECL_CONTEXT (decl
)) == BLOCK
2899 || TREE_CODE (DECL_CONTEXT (decl
)) == NAMESPACE_DECL
)
2900 && TREE_PUBLIC (decl
) == 0)
2902 /* The sun4 assembler does not grok this. */
2904 if (TREE_CODE (TREE_TYPE (decl
)) == INTEGER_TYPE
2905 || TREE_CODE (TREE_TYPE (decl
)) == ENUMERAL_TYPE
)
2907 HOST_WIDE_INT ival
= tree_to_shwi (DECL_INITIAL (decl
));
2909 dbxout_begin_complex_stabs ();
2910 dbxout_symbol_name (decl
, NULL
, 'c');
2913 dbxout_finish_complex_stabs (0, N_LSYM
, 0, 0, 0);
2914 DBXOUT_DECR_NESTING
;
2920 /* else it is something we handle like a normal variable. */
2922 decl_rtl
= dbxout_expand_expr (decl
);
2924 DBXOUT_DECR_NESTING_AND_RETURN (0);
2926 if (!is_global_var (decl
))
2927 decl_rtl
= eliminate_regs (decl_rtl
, VOIDmode
, NULL_RTX
);
2928 #ifdef LEAF_REG_REMAP
2929 if (crtl
->uses_only_leaf_regs
)
2930 leaf_renumber_regs_insn (decl_rtl
);
2933 result
= dbxout_symbol_location (decl
, type
, 0, decl_rtl
);
2939 DBXOUT_DECR_NESTING
;
2943 /* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL.
2944 Add SUFFIX to its name, if SUFFIX is not 0.
2945 Describe the variable as residing in HOME
2946 (usually HOME is DECL_RTL (DECL), but not always).
2947 Returns 1 if the stab was really emitted. */
2950 dbxout_symbol_location (tree decl
, tree type
, const char *suffix
, rtx home
)
2953 stab_code_type code
;
2958 /* Don't mention a variable at all
2959 if it was completely optimized into nothingness.
2961 If the decl was from an inline function, then its rtl
2962 is not identically the rtl that was used in this
2963 particular compilation. */
2964 if (GET_CODE (home
) == SUBREG
)
2968 while (GET_CODE (value
) == SUBREG
)
2969 value
= SUBREG_REG (value
);
2972 if (REGNO (value
) >= FIRST_PSEUDO_REGISTER
)
2975 home
= alter_subreg (&home
, true);
2979 regno
= REGNO (home
);
2980 if (regno
>= FIRST_PSEUDO_REGISTER
)
2984 /* The kind-of-variable letter depends on where
2985 the variable is and on the scope of its name:
2986 G and N_GSYM for static storage and global scope,
2987 S for static storage and file scope,
2988 V for static storage and local scope,
2989 for those two, use N_LCSYM if data is in bss segment,
2990 N_STSYM if in data segment, N_FUN otherwise.
2991 (We used N_FUN originally, then changed to N_STSYM
2992 to please GDB. However, it seems that confused ld.
2993 Now GDB has been fixed to like N_FUN, says Kingdon.)
2994 no letter at all, and N_LSYM, for auto variable,
2995 r and N_RSYM for register variable. */
2997 if (MEM_P (home
) && GET_CODE (XEXP (home
, 0)) == SYMBOL_REF
)
2999 if (TREE_PUBLIC (decl
))
3004 if (NULL
!= dbxout_common_check (decl
, &offs
))
3013 addr
= XEXP (home
, 0);
3015 letter
= decl_function_context (decl
) ? 'V' : 'S';
3017 /* Some ports can transform a symbol ref into a label ref,
3018 because the symbol ref is too far away and has to be
3019 dumped into a constant pool. Alternatively, the symbol
3020 in the constant pool might be referenced by a different
3022 if (GET_CODE (addr
) == SYMBOL_REF
3023 && CONSTANT_POOL_ADDRESS_P (addr
))
3026 rtx tmp
= get_pool_constant_mark (addr
, &marked
);
3028 if (GET_CODE (tmp
) == SYMBOL_REF
)
3031 if (CONSTANT_POOL_ADDRESS_P (addr
))
3032 get_pool_constant_mark (addr
, &marked
);
3036 else if (GET_CODE (tmp
) == LABEL_REF
)
3042 /* If all references to the constant pool were optimized
3043 out, we just ignore the symbol. */
3048 /* This should be the same condition as in assemble_variable, but
3049 we don't have access to dont_output_data here. So, instead,
3050 we rely on the fact that error_mark_node initializers always
3051 end up in bss for C++ and never end up in bss for C. */
3052 if (DECL_INITIAL (decl
) == 0
3054 && DECL_INITIAL (decl
) == error_mark_node
))
3058 if (NULL
!= dbxout_common_check (decl
, &offs
))
3066 else if (DECL_IN_TEXT_SECTION (decl
))
3067 /* This is not quite right, but it's the closest
3068 of all the codes that Unix defines. */
3069 code
= DBX_STATIC_CONST_VAR_CODE
;
3072 /* Ultrix `as' seems to need this. */
3073 #ifdef DBX_STATIC_STAB_DATA_SECTION
3074 switch_to_section (data_section
);
3080 else if (regno
>= 0)
3084 number
= DBX_REGISTER_NUMBER (regno
);
3086 else if (MEM_P (home
)
3087 && (MEM_P (XEXP (home
, 0))
3088 || (REG_P (XEXP (home
, 0))
3089 && REGNO (XEXP (home
, 0)) != HARD_FRAME_POINTER_REGNUM
3090 && REGNO (XEXP (home
, 0)) != STACK_POINTER_REGNUM
3091 #if !HARD_FRAME_POINTER_IS_ARG_POINTER
3092 && REGNO (XEXP (home
, 0)) != ARG_POINTER_REGNUM
3095 /* If the value is indirect by memory or by a register
3096 that isn't the frame pointer
3097 then it means the object is variable-sized and address through
3098 that register or stack slot. DBX has no way to represent this
3099 so all we can do is output the variable as a pointer.
3100 If it's not a parameter, ignore it. */
3102 if (REG_P (XEXP (home
, 0)))
3106 if (REGNO (XEXP (home
, 0)) >= FIRST_PSEUDO_REGISTER
)
3108 number
= DBX_REGISTER_NUMBER (REGNO (XEXP (home
, 0)));
3113 /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
3114 We want the value of that CONST_INT. */
3115 number
= DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home
, 0), 0));
3118 /* Effectively do build_pointer_type, but don't cache this type,
3119 since it might be temporary whereas the type it points to
3120 might have been saved for inlining. */
3121 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
3122 type
= make_node (POINTER_TYPE
);
3123 TREE_TYPE (type
) = TREE_TYPE (decl
);
3125 else if (MEM_P (home
)
3126 && REG_P (XEXP (home
, 0)))
3129 number
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
3131 else if (MEM_P (home
)
3132 && GET_CODE (XEXP (home
, 0)) == PLUS
3133 && CONST_INT_P (XEXP (XEXP (home
, 0), 1)))
3136 /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
3137 We want the value of that CONST_INT. */
3138 number
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
3140 else if (MEM_P (home
)
3141 && GET_CODE (XEXP (home
, 0)) == CONST
)
3143 /* Handle an obscure case which can arise when optimizing and
3144 when there are few available registers. (This is *always*
3145 the case for i386/i486 targets). The RTL looks like
3146 (MEM (CONST ...)) even though this variable is a local `auto'
3147 or a local `register' variable. In effect, what has happened
3148 is that the reload pass has seen that all assignments and
3149 references for one such a local variable can be replaced by
3150 equivalent assignments and references to some static storage
3151 variable, thereby avoiding the need for a register. In such
3152 cases we're forced to lie to debuggers and tell them that
3153 this variable was itself `static'. */
3157 if (NULL
== dbxout_common_check (decl
, &offs
))
3158 addr
= XEXP (XEXP (home
, 0), 0);
3166 else if (GET_CODE (home
) == CONCAT
)
3170 /* If TYPE is not a COMPLEX_TYPE (it might be a RECORD_TYPE,
3171 for example), then there is no easy way to figure out
3172 what SUBTYPE should be. So, we give up. */
3173 if (TREE_CODE (type
) != COMPLEX_TYPE
)
3176 subtype
= TREE_TYPE (type
);
3178 /* If the variable's storage is in two parts,
3179 output each as a separate stab with a modified name. */
3180 if (WORDS_BIG_ENDIAN
)
3181 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 0));
3183 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 0));
3185 if (WORDS_BIG_ENDIAN
)
3186 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 1));
3188 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 1));
3192 /* Address might be a MEM, when DECL is a variable-sized object.
3193 Or it might be const0_rtx, meaning previous passes
3194 want us to ignore this variable. */
3197 /* Ok, start a symtab entry and output the variable name. */
3198 emit_pending_bincls_if_required ();
3201 #ifdef DBX_STATIC_BLOCK_START
3202 DBX_STATIC_BLOCK_START (asm_out_file
, code
);
3205 dbxout_begin_complex_stabs_noforcetext ();
3206 dbxout_symbol_name (decl
, suffix
, letter
);
3207 dbxout_type (type
, 0);
3208 dbxout_finish_complex_stabs (decl
, code
, addr
, 0, number
);
3210 #ifdef DBX_STATIC_BLOCK_END
3211 DBX_STATIC_BLOCK_END (asm_out_file
, code
);
3216 /* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
3217 Then output LETTER to indicate the kind of location the symbol has. */
3220 dbxout_symbol_name (tree decl
, const char *suffix
, int letter
)
3224 if (DECL_CONTEXT (decl
)
3225 && (TYPE_P (DECL_CONTEXT (decl
))
3226 || TREE_CODE (DECL_CONTEXT (decl
)) == NAMESPACE_DECL
))
3227 /* One slight hitch: if this is a VAR_DECL which is a class member
3228 or a namespace member, we must put out the mangled name instead of the
3229 DECL_NAME. Note also that static member (variable) names DO NOT begin
3230 with underscores in .stabs directives. */
3231 name
= DECL_ASSEMBLER_NAME (decl
);
3233 /* ...but if we're function-local, we don't want to include the junk
3234 added by ASM_FORMAT_PRIVATE_NAME. */
3235 name
= DECL_NAME (decl
);
3240 stabstr_S ("(anon)");
3250 /* Output the common block name for DECL in a stabs.
3252 Symbols in global common (.comm) get wrapped with an N_BCOMM/N_ECOMM pair
3253 around each group of symbols in the same .comm area. The N_GSYM stabs
3254 that are emitted only contain the offset in the common area. This routine
3255 emits the N_BCOMM and N_ECOMM stabs. */
3258 dbxout_common_name (tree decl
, const char *name
, stab_code_type op
)
3260 dbxout_begin_complex_stabs ();
3262 dbxout_finish_complex_stabs (decl
, op
, NULL_RTX
, NULL
, 0);
3265 /* Check decl to determine whether it is a VAR_DECL destined for storage in a
3266 common area. If it is, the return value will be a non-null string giving
3267 the name of the common storage block it will go into. If non-null, the
3268 value is the offset into the common block for that symbol's storage. */
3271 dbxout_common_check (tree decl
, int *value
)
3275 const char *name
= NULL
;
3277 /* If the decl isn't a VAR_DECL, or if it isn't static, or if
3278 it does not have a value (the offset into the common area), or if it
3279 is thread local (as opposed to global) then it isn't common, and shouldn't
3282 ??? DECL_THREAD_LOCAL_P check prevents problems with improper .stabs
3283 for thread-local symbols. Can be handled via same mechanism as used
3285 if (TREE_CODE (decl
) != VAR_DECL
3286 || !TREE_STATIC (decl
)
3287 || !DECL_HAS_VALUE_EXPR_P (decl
)
3288 || DECL_THREAD_LOCAL_P (decl
)
3292 home
= DECL_RTL (decl
);
3293 if (home
== NULL_RTX
|| GET_CODE (home
) != MEM
)
3296 sym_addr
= dbxout_expand_expr (DECL_VALUE_EXPR (decl
));
3297 if (sym_addr
== NULL_RTX
|| GET_CODE (sym_addr
) != MEM
)
3300 sym_addr
= XEXP (sym_addr
, 0);
3301 if (GET_CODE (sym_addr
) == CONST
)
3302 sym_addr
= XEXP (sym_addr
, 0);
3303 if ((GET_CODE (sym_addr
) == SYMBOL_REF
|| GET_CODE (sym_addr
) == PLUS
)
3304 && DECL_INITIAL (decl
) == 0)
3307 /* We have a sym that will go into a common area, meaning that it
3308 will get storage reserved with a .comm/.lcomm assembler pseudo-op.
3310 Determine name of common area this symbol will be an offset into,
3311 and offset into that area. Also retrieve the decl for the area
3312 that the symbol is offset into. */
3315 switch (GET_CODE (sym_addr
))
3318 if (CONST_INT_P (XEXP (sym_addr
, 0)))
3321 targetm
.strip_name_encoding (XSTR (XEXP (sym_addr
, 1), 0));
3322 *value
= INTVAL (XEXP (sym_addr
, 0));
3323 cdecl = SYMBOL_REF_DECL (XEXP (sym_addr
, 1));
3328 targetm
.strip_name_encoding (XSTR (XEXP (sym_addr
, 0), 0));
3329 *value
= INTVAL (XEXP (sym_addr
, 1));
3330 cdecl = SYMBOL_REF_DECL (XEXP (sym_addr
, 0));
3335 name
= targetm
.strip_name_encoding (XSTR (sym_addr
, 0));
3337 cdecl = SYMBOL_REF_DECL (sym_addr
);
3341 error ("common symbol debug info is not structured as "
3345 /* Check area common symbol is offset into. If this is not public, then
3346 it is not a symbol in a common block. It must be a .lcomm symbol, not
3348 if (cdecl == NULL
|| !TREE_PUBLIC (cdecl))
3357 /* Output definitions of all the decls in a chain. Return nonzero if
3358 anything was output */
3361 dbxout_syms (tree syms
)
3364 const char *comm_prev
= NULL
;
3365 tree syms_prev
= NULL
;
3369 int temp
, copen
, cclos
;
3370 const char *comm_new
;
3372 /* Check for common symbol, and then progression into a new/different
3373 block of common symbols. Emit closing/opening common bracket if
3375 comm_new
= dbxout_common_check (syms
, &temp
);
3376 copen
= comm_new
!= NULL
3377 && (comm_prev
== NULL
|| strcmp (comm_new
, comm_prev
));
3378 cclos
= comm_prev
!= NULL
3379 && (comm_new
== NULL
|| strcmp (comm_new
, comm_prev
));
3381 dbxout_common_name (syms_prev
, comm_prev
, N_ECOMM
);
3384 dbxout_common_name (syms
, comm_new
, N_BCOMM
);
3387 comm_prev
= comm_new
;
3389 result
+= dbxout_symbol (syms
, 1);
3390 syms
= DECL_CHAIN (syms
);
3393 if (comm_prev
!= NULL
)
3394 dbxout_common_name (syms_prev
, comm_prev
, N_ECOMM
);
3399 /* The following two functions output definitions of function parameters.
3400 Each parameter gets a definition locating it in the parameter list.
3401 Each parameter that is a register variable gets a second definition
3402 locating it in the register.
3404 Printing or argument lists in gdb uses the definitions that
3405 locate in the parameter list. But reference to the variable in
3406 expressions uses preferentially the definition as a register. */
3408 /* Output definitions, referring to storage in the parmlist,
3409 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
3412 dbxout_parms (tree parms
)
3415 emit_pending_bincls_if_required ();
3417 for (; parms
; parms
= DECL_CHAIN (parms
))
3418 if (DECL_NAME (parms
)
3419 && TREE_TYPE (parms
) != error_mark_node
3420 && DECL_RTL_SET_P (parms
)
3421 && DECL_INCOMING_RTL (parms
))
3425 stab_code_type code
;
3428 /* Perform any necessary register eliminations on the parameter's rtl,
3429 so that the debugging output will be accurate. */
3430 DECL_INCOMING_RTL (parms
)
3431 = eliminate_regs (DECL_INCOMING_RTL (parms
), VOIDmode
, NULL_RTX
);
3432 SET_DECL_RTL (parms
,
3433 eliminate_regs (DECL_RTL (parms
), VOIDmode
, NULL_RTX
));
3434 #ifdef LEAF_REG_REMAP
3435 if (crtl
->uses_only_leaf_regs
)
3437 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms
));
3438 leaf_renumber_regs_insn (DECL_RTL (parms
));
3442 if (PARM_PASSED_IN_MEMORY (parms
))
3444 rtx inrtl
= XEXP (DECL_INCOMING_RTL (parms
), 0);
3446 /* ??? Here we assume that the parm address is indexed
3447 off the frame pointer or arg pointer.
3448 If that is not true, we produce meaningless results,
3449 but do not crash. */
3450 if (GET_CODE (inrtl
) == PLUS
3451 && CONST_INT_P (XEXP (inrtl
, 1)))
3452 number
= INTVAL (XEXP (inrtl
, 1));
3457 number
= DEBUGGER_ARG_OFFSET (number
, inrtl
);
3460 /* It is quite tempting to use TREE_TYPE (parms) instead
3461 of DECL_ARG_TYPE (parms) for the eff_type, so that gcc
3462 reports the actual type of the parameter, rather than
3463 the promoted type. This certainly makes GDB's life
3464 easier, at least for some ports. The change is a bad
3465 idea however, since GDB expects to be able access the
3466 type without performing any conversions. So for
3467 example, if we were passing a float to an unprototyped
3468 function, gcc will store a double on the stack, but if
3469 we emit a stab saying the type is a float, then gdb
3470 will only read in a single value, and this will produce
3471 an erroneous value. */
3472 eff_type
= DECL_ARG_TYPE (parms
);
3474 else if (REG_P (DECL_RTL (parms
)))
3478 /* Parm passed in registers and lives in registers or nowhere. */
3479 code
= DBX_REGPARM_STABS_CODE
;
3480 letter
= DBX_REGPARM_STABS_LETTER
;
3482 /* For parms passed in registers, it is better to use the
3483 declared type of the variable, not the type it arrived in. */
3484 eff_type
= TREE_TYPE (parms
);
3486 /* If parm lives in a register, use that register; pretend
3487 the parm was passed there. It would be more consistent
3488 to describe the register where the parm was passed, but
3489 in practice that register usually holds something else.
3490 If the parm lives nowhere, use the register where it
3492 if (REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
3493 best_rtl
= DECL_RTL (parms
);
3494 else if (GET_CODE (DECL_INCOMING_RTL (parms
)) == PARALLEL
)
3495 best_rtl
= XEXP (XVECEXP (DECL_INCOMING_RTL (parms
), 0, 0), 0);
3497 best_rtl
= DECL_INCOMING_RTL (parms
);
3499 number
= DBX_REGISTER_NUMBER (REGNO (best_rtl
));
3501 else if (MEM_P (DECL_RTL (parms
))
3502 && REG_P (XEXP (DECL_RTL (parms
), 0))
3503 && REGNO (XEXP (DECL_RTL (parms
), 0)) != HARD_FRAME_POINTER_REGNUM
3504 && REGNO (XEXP (DECL_RTL (parms
), 0)) != STACK_POINTER_REGNUM
3505 #if !HARD_FRAME_POINTER_IS_ARG_POINTER
3506 && REGNO (XEXP (DECL_RTL (parms
), 0)) != ARG_POINTER_REGNUM
3510 /* Parm was passed via invisible reference.
3511 That is, its address was passed in a register.
3512 Output it as if it lived in that register.
3513 The debugger will know from the type
3514 that it was actually passed by invisible reference. */
3516 code
= DBX_REGPARM_STABS_CODE
;
3518 /* GDB likes this marked with a special letter. */
3519 letter
= (use_gnu_debug_info_extensions
3520 ? 'a' : DBX_REGPARM_STABS_LETTER
);
3521 eff_type
= TREE_TYPE (parms
);
3523 /* DECL_RTL looks like (MEM (REG...). Get the register number.
3524 If it is an unallocated pseudo-reg, then use the register where
3525 it was passed instead.
3526 ??? Why is DBX_REGISTER_NUMBER not used here? */
3528 if (REGNO (XEXP (DECL_RTL (parms
), 0)) < FIRST_PSEUDO_REGISTER
)
3529 number
= REGNO (XEXP (DECL_RTL (parms
), 0));
3531 number
= REGNO (DECL_INCOMING_RTL (parms
));
3533 else if (MEM_P (DECL_RTL (parms
))
3534 && MEM_P (XEXP (DECL_RTL (parms
), 0)))
3536 /* Parm was passed via invisible reference, with the reference
3537 living on the stack. DECL_RTL looks like
3538 (MEM (MEM (PLUS (REG ...) (CONST_INT ...)))) or it
3539 could look like (MEM (MEM (REG))). */
3543 eff_type
= TREE_TYPE (parms
);
3545 if (!REG_P (XEXP (XEXP (DECL_RTL (parms
), 0), 0)))
3546 number
= INTVAL (XEXP (XEXP (XEXP (DECL_RTL (parms
), 0), 0), 1));
3550 number
= DEBUGGER_ARG_OFFSET (number
,
3551 XEXP (XEXP (DECL_RTL (parms
), 0), 0));
3553 else if (MEM_P (DECL_RTL (parms
))
3554 && XEXP (DECL_RTL (parms
), 0) != const0_rtx
3555 /* ??? A constant address for a parm can happen
3556 when the reg it lives in is equiv to a constant in memory.
3557 Should make this not happen, after 2.4. */
3558 && ! CONSTANT_P (XEXP (DECL_RTL (parms
), 0)))
3560 /* Parm was passed in registers but lives on the stack. */
3564 eff_type
= TREE_TYPE (parms
);
3566 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
3567 in which case we want the value of that CONST_INT,
3569 in which case we use a value of zero. */
3570 if (!REG_P (XEXP (DECL_RTL (parms
), 0)))
3571 number
= INTVAL (XEXP (XEXP (DECL_RTL (parms
), 0), 1));
3575 /* Make a big endian correction if the mode of the type of the
3576 parameter is not the same as the mode of the rtl. */
3577 if (BYTES_BIG_ENDIAN
3578 && TYPE_MODE (TREE_TYPE (parms
)) != GET_MODE (DECL_RTL (parms
))
3579 && GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms
))) < UNITS_PER_WORD
)
3580 number
+= (GET_MODE_SIZE (GET_MODE (DECL_RTL (parms
)))
3581 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms
))));
3584 /* ??? We don't know how to represent this argument. */
3587 dbxout_begin_complex_stabs ();
3589 if (DECL_NAME (parms
))
3591 stabstr_I (DECL_NAME (parms
));
3595 stabstr_S ("(anon):");
3597 dbxout_type (eff_type
, 0);
3598 dbxout_finish_complex_stabs (parms
, code
, 0, 0, number
);
3600 DBXOUT_DECR_NESTING
;
3603 /* Output definitions for the places where parms live during the function,
3604 when different from where they were passed, when the parms were passed
3607 It is not useful to do this for parms passed in registers
3608 that live during the function in different registers, because it is
3609 impossible to look in the passed register for the passed value,
3610 so we use the within-the-function register to begin with.
3612 PARMS is a chain of PARM_DECL nodes. */
3615 dbxout_reg_parms (tree parms
)
3619 for (; parms
; parms
= DECL_CHAIN (parms
))
3620 if (DECL_NAME (parms
) && PARM_PASSED_IN_MEMORY (parms
))
3622 /* Report parms that live in registers during the function
3623 but were passed in memory. */
3624 if (REG_P (DECL_RTL (parms
))
3625 && REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
3626 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
3627 0, DECL_RTL (parms
));
3628 else if (GET_CODE (DECL_RTL (parms
)) == CONCAT
)
3629 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
3630 0, DECL_RTL (parms
));
3631 /* Report parms that live in memory but not where they were passed. */
3632 else if (MEM_P (DECL_RTL (parms
))
3633 && ! rtx_equal_p (DECL_RTL (parms
), DECL_INCOMING_RTL (parms
)))
3634 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
3635 0, DECL_RTL (parms
));
3637 DBXOUT_DECR_NESTING
;
3640 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
3641 output definitions of those names, in raw form */
3644 dbxout_args (tree args
)
3649 dbxout_type (TREE_VALUE (args
), 0);
3650 args
= TREE_CHAIN (args
);
3654 #if defined (DBX_DEBUGGING_INFO)
3656 /* Subroutine of dbxout_block. Emit an N_LBRAC stab referencing LABEL.
3657 BEGIN_LABEL is the name of the beginning of the function, which may
3660 dbx_output_lbrac (const char *label
,
3661 const char *begin_label ATTRIBUTE_UNUSED
)
3663 dbxout_begin_stabn (N_LBRAC
);
3664 if (DBX_BLOCKS_FUNCTION_RELATIVE
)
3665 dbxout_stab_value_label_diff (label
, begin_label
);
3667 dbxout_stab_value_label (label
);
3670 /* Subroutine of dbxout_block. Emit an N_RBRAC stab referencing LABEL.
3671 BEGIN_LABEL is the name of the beginning of the function, which may
3674 dbx_output_rbrac (const char *label
,
3675 const char *begin_label ATTRIBUTE_UNUSED
)
3677 dbxout_begin_stabn (N_RBRAC
);
3678 if (DBX_BLOCKS_FUNCTION_RELATIVE
)
3679 dbxout_stab_value_label_diff (label
, begin_label
);
3681 dbxout_stab_value_label (label
);
3684 /* Output everything about a symbol block (a BLOCK node
3685 that represents a scope level),
3686 including recursive output of contained blocks.
3688 BLOCK is the BLOCK node.
3689 DEPTH is its depth within containing symbol blocks.
3690 ARGS is usually zero; but for the outermost block of the
3691 body of a function, it is a chain of PARM_DECLs for the function parameters.
3692 We output definitions of all the register parms
3693 as if they were local variables of that block.
3695 If -g1 was used, we count blocks just the same, but output nothing
3696 except for the outermost block.
3698 Actually, BLOCK may be several blocks chained together.
3699 We handle them all in sequence. */
3702 dbxout_block (tree block
, int depth
, tree args
)
3704 char begin_label
[20];
3705 /* Reference current function start using LFBB. */
3706 ASM_GENERATE_INTERNAL_LABEL (begin_label
, "LFBB", scope_labelno
);
3710 /* Ignore blocks never expanded or otherwise marked as real. */
3711 if (TREE_USED (block
) && TREE_ASM_WRITTEN (block
))
3714 int blocknum
= BLOCK_NUMBER (block
);
3716 /* In dbx format, the syms of a block come before the N_LBRAC.
3717 If nothing is output, we don't need the N_LBRAC, either. */
3719 if (debug_info_level
!= DINFO_LEVEL_TERSE
|| depth
== 0)
3720 did_output
= dbxout_syms (BLOCK_VARS (block
));
3722 dbxout_reg_parms (args
);
3724 /* Now output an N_LBRAC symbol to represent the beginning of
3725 the block. Use the block's tree-walk order to generate
3726 the assembler symbols LBBn and LBEn
3727 that final will define around the code in this block. */
3731 const char *scope_start
;
3734 /* The outermost block doesn't get LBB labels; use
3735 the LFBB local symbol emitted by dbxout_begin_prologue. */
3736 scope_start
= begin_label
;
3739 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBB", blocknum
);
3743 dbx_output_lbrac (scope_start
, begin_label
);
3746 /* Output the subblocks. */
3747 dbxout_block (BLOCK_SUBBLOCKS (block
), depth
+ 1, NULL_TREE
);
3749 /* Refer to the marker for the end of the block. */
3754 /* The outermost block doesn't get LBE labels;
3755 use the "scope" label which will be emitted
3756 by dbxout_function_end. */
3757 ASM_GENERATE_INTERNAL_LABEL (buf
, "Lscope", scope_labelno
);
3759 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBE", blocknum
);
3761 dbx_output_rbrac (buf
, begin_label
);
3764 block
= BLOCK_CHAIN (block
);
3768 /* Output the information about a function and its arguments and result.
3769 Usually this follows the function's code,
3770 but on some systems, it comes before. */
3773 dbxout_begin_function (tree decl
)
3775 int saved_tree_used1
;
3777 saved_tree_used1
= TREE_USED (decl
);
3778 TREE_USED (decl
) = 1;
3779 if (DECL_NAME (DECL_RESULT (decl
)) != 0)
3781 int saved_tree_used2
= TREE_USED (DECL_RESULT (decl
));
3782 TREE_USED (DECL_RESULT (decl
)) = 1;
3783 dbxout_symbol (decl
, 0);
3784 TREE_USED (DECL_RESULT (decl
)) = saved_tree_used2
;
3787 dbxout_symbol (decl
, 0);
3788 TREE_USED (decl
) = saved_tree_used1
;
3790 dbxout_parms (DECL_ARGUMENTS (decl
));
3791 if (DECL_NAME (DECL_RESULT (decl
)) != 0)
3792 dbxout_symbol (DECL_RESULT (decl
), 1);
3794 #endif /* DBX_DEBUGGING_INFO */
3796 #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */
3798 /* Record an element in the table of global destructors. SYMBOL is
3799 a SYMBOL_REF of the function to be called; PRIORITY is a number
3800 between 0 and MAX_INIT_PRIORITY. */
3803 default_stabs_asm_out_destructor (rtx symbol ATTRIBUTE_UNUSED
,
3804 int priority ATTRIBUTE_UNUSED
)
3806 #if defined DBX_DEBUGGING_INFO || defined XCOFF_DEBUGGING_INFO
3807 /* Tell GNU LD that this is part of the static destructor set.
3808 This will work for any system that uses stabs, most usefully
3810 dbxout_begin_simple_stabs ("___DTOR_LIST__", 22 /* N_SETT */);
3811 dbxout_stab_value_label (XSTR (symbol
, 0));
3813 sorry ("global destructors not supported on this target");
3817 /* Likewise for global constructors. */
3820 default_stabs_asm_out_constructor (rtx symbol ATTRIBUTE_UNUSED
,
3821 int priority ATTRIBUTE_UNUSED
)
3823 #if defined DBX_DEBUGGING_INFO || defined XCOFF_DEBUGGING_INFO
3824 /* Tell GNU LD that this is part of the static destructor set.
3825 This will work for any system that uses stabs, most usefully
3827 dbxout_begin_simple_stabs ("___CTOR_LIST__", 22 /* N_SETT */);
3828 dbxout_stab_value_label (XSTR (symbol
, 0));
3830 sorry ("global constructors not supported on this target");
3834 #include "gt-dbxout.h"