1 /* Output dbx-format symbol table information from GNU compiler.
2 Copyright (C) 1987-2017 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
21 /* Output dbx-format symbol table data.
22 This consists of many symbol table entries, each of them
23 a .stabs assembler pseudo-op with four operands:
24 a "name" which is really a description of one symbol and its type,
25 a "code", which is a symbol defined in stab.h whose name starts with N_,
26 an unused operand always 0,
27 and a "value" which is an address or an offset.
28 The name is enclosed in doublequote characters.
30 Each function, variable, typedef, and structure tag
31 has a symbol table entry to define it.
32 The beginning and end of each level of name scoping within
33 a function are also marked by special symbol table entries.
35 The "name" consists of the symbol name, a colon, a kind-of-symbol letter,
36 and a data type number. The data type number may be followed by
37 "=" and a type definition; normally this will happen the first time
38 the type number is mentioned. The type definition may refer to
39 other types by number, and those type numbers may be followed
40 by "=" and nested definitions.
42 This can make the "name" quite long.
43 When a name is more than 80 characters, we split the .stabs pseudo-op
44 into two .stabs pseudo-ops, both sharing the same "code" and "value".
45 The first one is marked as continued with a double-backslash at the
48 The kind-of-symbol letter distinguished function names from global
49 variables from file-scope variables from parameters from auto
50 variables in memory from typedef names from register variables.
53 The "code" is mostly redundant with the kind-of-symbol letter
54 that goes in the "name", but not entirely: for symbols located
55 in static storage, the "code" says which segment the address is in,
56 which controls how it is relocated.
58 The "value" for a symbol in static storage
59 is the core address of the symbol (actually, the assembler
60 label for the symbol). For a symbol located in a stack slot
61 it is the stack offset; for one in a register, the register number.
62 For a typedef symbol, it is zero.
64 If DEBUG_SYMS_TEXT is defined, all debugging symbols must be
65 output while in the text section.
67 For more on data type definitions, see `dbxout_type'. */
71 #include "coretypes.h"
78 #include "stringpool.h"
79 #include "insn-config.h"
82 #include "diagnostic-core.h"
83 #include "fold-const.h"
85 #include "stor-layout.h"
91 #include "common/common-target.h"
92 #include "langhooks.h"
95 #ifdef XCOFF_DEBUGGING_INFO
100 # ifdef XCOFF_DEBUGGING_INFO
101 # define ASM_STABS_OP "\t.stabx\t"
103 # define ASM_STABS_OP "\t.stabs\t"
108 #define ASM_STABN_OP "\t.stabn\t"
112 #define ASM_STABD_OP "\t.stabd\t"
115 #ifndef DBX_TYPE_DECL_STABS_CODE
116 #define DBX_TYPE_DECL_STABS_CODE N_LSYM
119 #ifndef DBX_STATIC_CONST_VAR_CODE
120 #define DBX_STATIC_CONST_VAR_CODE N_FUN
123 #ifndef DBX_REGPARM_STABS_CODE
124 #define DBX_REGPARM_STABS_CODE N_RSYM
127 #ifndef DBX_REGPARM_STABS_LETTER
128 #define DBX_REGPARM_STABS_LETTER 'P'
131 #ifndef NO_DBX_FUNCTION_END
132 #define NO_DBX_FUNCTION_END 0
135 #ifndef NO_DBX_BNSYM_ENSYM
136 #define NO_DBX_BNSYM_ENSYM 0
139 #ifndef NO_DBX_MAIN_SOURCE_DIRECTORY
140 #define NO_DBX_MAIN_SOURCE_DIRECTORY 0
143 #ifndef DBX_BLOCKS_FUNCTION_RELATIVE
144 #define DBX_BLOCKS_FUNCTION_RELATIVE 0
147 #ifndef DBX_LINES_FUNCTION_RELATIVE
148 #define DBX_LINES_FUNCTION_RELATIVE 0
151 #ifndef DBX_CONTIN_LENGTH
152 #define DBX_CONTIN_LENGTH 80
155 #ifndef DBX_CONTIN_CHAR
156 #define DBX_CONTIN_CHAR '\\'
159 enum typestatus
{TYPE_UNSEEN
, TYPE_XREF
, TYPE_DEFINED
};
161 /* Structure recording information about a C data type.
162 The status element says whether we have yet output
163 the definition of the type. TYPE_XREF says we have
164 output it as a cross-reference only.
165 The file_number and type_number elements are used if DBX_USE_BINCL
168 struct GTY(()) typeinfo
{
169 enum typestatus status
;
174 /* Vector recording information about C data types.
175 When we first notice a data type (a tree node),
176 we assign it a number using next_type_number.
177 That is its index in this vector. */
179 static GTY ((length ("typevec_len"))) struct typeinfo
*typevec
;
181 /* Number of elements of space allocated in `typevec'. */
183 static GTY(()) int typevec_len
;
185 /* In dbx output, each type gets a unique number.
186 This is the number for the next type output.
187 The number, once assigned, is in the TYPE_SYMTAB_ADDRESS field. */
189 static GTY(()) int next_type_number
;
191 /* The C front end may call dbxout_symbol before dbxout_init runs.
192 We save all such decls in this list and output them when we get
195 static GTY(()) tree preinit_symbols
;
197 enum binclstatus
{BINCL_NOT_REQUIRED
, BINCL_PENDING
, BINCL_PROCESSED
};
199 /* When using N_BINCL in dbx output, each type number is actually a
200 pair of the file number and the type number within the file.
201 This is a stack of input files. */
205 struct dbx_file
*next
;
207 int next_type_number
;
208 enum binclstatus bincl_status
; /* Keep track of lazy bincl. */
209 const char *pending_bincl_name
; /* Name of bincl. */
210 struct dbx_file
*prev
; /* Chain to traverse all pending bincls. */
213 /* This is the top of the stack.
215 This is not saved for PCH, because restoring a PCH should not change it.
216 next_file_number does have to be saved, because the PCH may use some
217 file numbers; however, just before restoring a PCH, next_file_number
218 should always be 0 because we should not have needed any file numbers
221 #if (defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)) \
222 && defined (DBX_USE_BINCL)
223 static struct dbx_file
*current_file
;
226 /* This is the next file number to use. */
228 static GTY(()) int next_file_number
;
230 /* A counter for dbxout_function_end. */
232 static GTY(()) int scope_labelno
;
234 /* A counter for dbxout_source_line. */
236 static GTY(()) int dbxout_source_line_counter
;
238 /* Number for the next N_SOL filename stabs label. The number 0 is reserved
239 for the N_SO filename stabs label. */
241 static GTY(()) int source_label_number
= 1;
243 /* Last source file name mentioned in a NOTE insn. */
245 static GTY(()) const char *lastfile
;
247 /* Used by PCH machinery to detect if 'lastfile' should be reset to
249 static GTY(()) int lastfile_is_base
;
251 /* Typical USG systems don't have stab.h, and they also have
252 no use for DBX-format debugging info. */
254 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
257 /* If zero then there is no pending BINCL. */
258 static int pending_bincls
= 0;
261 /* The original input file name. */
262 static const char *base_input_file
;
264 #ifdef DEBUG_SYMS_TEXT
265 #define FORCE_TEXT switch_to_section (current_function_section ())
272 /* 1 if PARM is passed to this function in memory. */
274 #define PARM_PASSED_IN_MEMORY(PARM) \
275 (MEM_P (DECL_INCOMING_RTL (PARM)))
277 /* A C expression for the integer offset value of an automatic variable
278 (N_LSYM) having address X (an RTX). */
279 #ifndef DEBUGGER_AUTO_OFFSET
280 #define DEBUGGER_AUTO_OFFSET(X) \
281 (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
284 /* A C expression for the integer offset value of an argument (N_PSYM)
285 having address X (an RTX). The nominal offset is OFFSET.
286 Note that we use OFFSET + 0 here to avoid the self-assign warning
287 when the macro is called in a context like
288 number = DEBUGGER_ARG_OFFSET(number, X) */
289 #ifndef DEBUGGER_ARG_OFFSET
290 #define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET + 0)
293 /* This obstack holds the stab string currently being constructed. We
294 build it up here, then write it out, so we can split long lines up
295 properly (see dbxout_finish_complex_stabs). */
296 static struct obstack stabstr_ob
;
297 static size_t stabstr_last_contin_point
;
300 static void emit_bincl_stab (const char *c
);
301 static void emit_pending_bincls (void);
303 static inline void emit_pending_bincls_if_required (void);
305 static void dbxout_init (const char *);
307 static void dbxout_finish (const char *);
308 static void dbxout_start_source_file (unsigned, const char *);
309 static void dbxout_end_source_file (unsigned);
310 static void dbxout_typedefs (tree
);
311 static void dbxout_type_index (tree
);
312 static void dbxout_args (tree
);
313 static void dbxout_type_fields (tree
);
314 static void dbxout_type_method_1 (tree
);
315 static void dbxout_type_methods (tree
);
316 static void dbxout_range_type (tree
, tree
, tree
);
317 static void dbxout_type (tree
, int);
318 static bool print_int_cst_bounds_in_octal_p (tree
, tree
, tree
);
319 static bool is_fortran (void);
320 static void dbxout_type_name (tree
);
321 static void dbxout_class_name_qualifiers (tree
);
322 static int dbxout_symbol_location (tree
, tree
, const char *, rtx
);
323 static void dbxout_symbol_name (tree
, const char *, int);
324 static void dbxout_common_name (tree
, const char *, stab_code_type
);
325 static const char *dbxout_common_check (tree
, int *);
326 static void dbxout_early_global_decl (tree
);
327 static void dbxout_late_global_decl (tree
);
328 static void dbxout_type_decl (tree
, int);
329 static void dbxout_handle_pch (unsigned);
330 static void debug_free_queue (void);
332 /* The debug hooks structure. */
333 #if defined (DBX_DEBUGGING_INFO)
335 static void dbxout_source_line (unsigned int, unsigned int, const char *,
337 static void dbxout_begin_prologue (unsigned int, unsigned int, const char *);
338 static void dbxout_source_file (const char *);
339 static void dbxout_function_end (tree
);
340 static void dbxout_begin_function (tree
);
341 static void dbxout_begin_block (unsigned, unsigned);
342 static void dbxout_end_block (unsigned, unsigned);
343 static void dbxout_function_decl (tree
);
345 const struct gcc_debug_hooks dbx_debug_hooks
=
349 debug_nothing_charstar
,
351 debug_nothing_int_charstar
,
352 debug_nothing_int_charstar
,
353 dbxout_start_source_file
,
354 dbxout_end_source_file
,
357 debug_true_const_tree
, /* ignore_block */
358 dbxout_source_line
, /* source_line */
359 dbxout_begin_prologue
, /* begin_prologue */
360 debug_nothing_int_charstar
, /* end_prologue */
361 debug_nothing_int_charstar
, /* begin_epilogue */
362 debug_nothing_int_charstar
, /* end_epilogue */
363 #ifdef DBX_FUNCTION_FIRST
364 dbxout_begin_function
,
366 debug_nothing_tree
, /* begin_function */
368 debug_nothing_int
, /* end_function */
369 debug_nothing_tree
, /* register_main_translation_unit */
370 dbxout_function_decl
,
371 dbxout_early_global_decl
, /* early_global_decl */
372 dbxout_late_global_decl
, /* late_global_decl */
373 dbxout_type_decl
, /* type_decl */
374 debug_nothing_tree_tree_tree_bool_bool
,/* imported_module_or_decl */
375 debug_nothing_tree
, /* deferred_inline_function */
376 debug_nothing_tree
, /* outlining_inline_function */
377 debug_nothing_rtx_code_label
, /* label */
378 dbxout_handle_pch
, /* handle_pch */
379 debug_nothing_rtx_insn
, /* var_location */
380 debug_nothing_tree
, /* size_function */
381 debug_nothing_void
, /* switch_text_section */
382 debug_nothing_tree_tree
, /* set_name */
383 0, /* start_end_main_source_file */
384 TYPE_SYMTAB_IS_ADDRESS
/* tree_type_symtab_field */
386 #endif /* DBX_DEBUGGING_INFO */
388 #if defined (XCOFF_DEBUGGING_INFO)
389 const struct gcc_debug_hooks xcoff_debug_hooks
=
393 debug_nothing_charstar
,
395 debug_nothing_int_charstar
,
396 debug_nothing_int_charstar
,
397 dbxout_start_source_file
,
398 dbxout_end_source_file
,
399 xcoffout_begin_block
,
401 debug_true_const_tree
, /* ignore_block */
402 xcoffout_source_line
,
403 xcoffout_begin_prologue
, /* begin_prologue */
404 debug_nothing_int_charstar
, /* end_prologue */
405 debug_nothing_int_charstar
, /* begin_epilogue */
406 xcoffout_end_epilogue
,
407 debug_nothing_tree
, /* begin_function */
408 xcoffout_end_function
,
409 debug_nothing_tree
, /* register_main_translation_unit */
410 debug_nothing_tree
, /* function_decl */
411 dbxout_early_global_decl
, /* early_global_decl */
412 dbxout_late_global_decl
, /* late_global_decl */
413 dbxout_type_decl
, /* type_decl */
414 debug_nothing_tree_tree_tree_bool_bool
,/* imported_module_or_decl */
415 debug_nothing_tree
, /* deferred_inline_function */
416 debug_nothing_tree
, /* outlining_inline_function */
417 debug_nothing_rtx_code_label
, /* label */
418 dbxout_handle_pch
, /* handle_pch */
419 debug_nothing_rtx_insn
, /* var_location */
420 debug_nothing_tree
, /* size_function */
421 debug_nothing_void
, /* switch_text_section */
422 debug_nothing_tree_tree
, /* set_name */
423 0, /* start_end_main_source_file */
424 TYPE_SYMTAB_IS_ADDRESS
/* tree_type_symtab_field */
426 #endif /* XCOFF_DEBUGGING_INFO */
428 /* Numeric formatting helper macro. Note that this does not handle
430 #define NUMBER_FMT_LOOP(P, NUM, BASE) \
433 int digit = NUM % BASE; \
435 *--P = digit + '0'; \
439 /* Utility: write a decimal integer NUM to asm_out_file. */
444 char *p
= buf
+ sizeof buf
;
449 putc ('0', asm_out_file
);
454 putc ('-', asm_out_file
);
460 NUMBER_FMT_LOOP (p
, unum
, 10);
462 while (p
< buf
+ sizeof buf
)
464 putc (*p
, asm_out_file
);
470 /* Primitives for emitting simple stabs directives. All other stabs
471 routines should use these functions instead of directly emitting
472 stabs. They are exported because machine-dependent code may need
473 to invoke them, e.g. in a DBX_OUTPUT_* macro whose definition
474 forwards to code in CPU.c. */
476 /* The following functions should all be called immediately after one
477 of the dbxout_begin_stab* functions (below). They write out
478 various things as the value of a stab. */
480 /* Write out a literal zero as the value of a stab. */
482 dbxout_stab_value_zero (void)
484 fputs ("0\n", asm_out_file
);
487 /* Write out the label LABEL as the value of a stab. */
489 dbxout_stab_value_label (const char *label
)
491 assemble_name (asm_out_file
, label
);
492 putc ('\n', asm_out_file
);
495 /* Write out the difference of two labels, LABEL - BASE, as the value
498 dbxout_stab_value_label_diff (const char *label
, const char *base
)
500 assemble_name (asm_out_file
, label
);
501 putc ('-', asm_out_file
);
502 assemble_name (asm_out_file
, base
);
503 putc ('\n', asm_out_file
);
506 /* Write out an internal label as the value of a stab, and immediately
507 emit that internal label. This should be used only when
508 dbxout_stabd will not work. STEM is the name stem of the label,
509 COUNTERP is a pointer to a counter variable which will be used to
510 guarantee label uniqueness. */
512 dbxout_stab_value_internal_label (const char *stem
, int *counterp
)
515 int counter
= counterp
? (*counterp
)++ : 0;
517 ASM_GENERATE_INTERNAL_LABEL (label
, stem
, counter
);
518 dbxout_stab_value_label (label
);
519 targetm
.asm_out
.internal_label (asm_out_file
, stem
, counter
);
522 /* Write out the difference between BASE and an internal label as the
523 value of a stab, and immediately emit that internal label. STEM and
524 COUNTERP are as for dbxout_stab_value_internal_label. */
526 dbxout_stab_value_internal_label_diff (const char *stem
, int *counterp
,
530 int counter
= counterp
? (*counterp
)++ : 0;
532 ASM_GENERATE_INTERNAL_LABEL (label
, stem
, counter
);
533 dbxout_stab_value_label_diff (label
, base
);
534 targetm
.asm_out
.internal_label (asm_out_file
, stem
, counter
);
537 /* The following functions produce specific kinds of stab directives. */
539 /* Write a .stabd directive with type STYPE and desc SDESC to asm_out_file. */
541 dbxout_stabd (int stype
, int sdesc
)
543 fputs (ASM_STABD_OP
, asm_out_file
);
545 fputs (",0,", asm_out_file
);
547 putc ('\n', asm_out_file
);
550 /* Write a .stabn directive with type STYPE. This function stops
551 short of emitting the value field, which is the responsibility of
552 the caller (normally it will be either a symbol or the difference
556 dbxout_begin_stabn (int stype
)
558 fputs (ASM_STABN_OP
, asm_out_file
);
560 fputs (",0,0,", asm_out_file
);
563 /* Write a .stabn directive with type N_SLINE and desc LINE. As above,
564 the value field is the responsibility of the caller. */
566 dbxout_begin_stabn_sline (int lineno
)
568 fputs (ASM_STABN_OP
, asm_out_file
);
569 dbxout_int (N_SLINE
);
570 fputs (",0,", asm_out_file
);
572 putc (',', asm_out_file
);
575 /* Begin a .stabs directive with string "", type STYPE, and desc and
576 other fields 0. The value field is the responsibility of the
577 caller. This function cannot be used for .stabx directives. */
579 dbxout_begin_empty_stabs (int stype
)
581 fputs (ASM_STABS_OP
, asm_out_file
);
582 fputs ("\"\",", asm_out_file
);
584 fputs (",0,0,", asm_out_file
);
587 /* Begin a .stabs directive with string STR, type STYPE, and desc 0.
588 The value field is the responsibility of the caller. */
590 dbxout_begin_simple_stabs (const char *str
, int stype
)
592 fputs (ASM_STABS_OP
, asm_out_file
);
593 output_quoted_string (asm_out_file
, str
);
594 putc (',', asm_out_file
);
596 fputs (",0,0,", asm_out_file
);
599 /* As above but use SDESC for the desc field. */
601 dbxout_begin_simple_stabs_desc (const char *str
, int stype
, int sdesc
)
603 fputs (ASM_STABS_OP
, asm_out_file
);
604 output_quoted_string (asm_out_file
, str
);
605 putc (',', asm_out_file
);
607 fputs (",0,", asm_out_file
);
609 putc (',', asm_out_file
);
612 /* The next set of functions are entirely concerned with production of
613 "complex" .stabs directives: that is, .stabs directives whose
614 strings have to be constructed piecemeal. dbxout_type,
615 dbxout_symbol, etc. use these routines heavily. The string is queued
616 up in an obstack, then written out by dbxout_finish_complex_stabs, which
617 is also responsible for splitting it up if it exceeds DBX_CONTIN_LENGTH.
618 (You might think it would be more efficient to go straight to stdio
619 when DBX_CONTIN_LENGTH is 0 (i.e. no length limit) but that turns
620 out not to be the case, and anyway this needs fewer #ifdefs.) */
622 /* Begin a complex .stabs directive. If we can, write the initial
623 ASM_STABS_OP to the asm_out_file. */
626 dbxout_begin_complex_stabs (void)
628 emit_pending_bincls_if_required ();
630 fputs (ASM_STABS_OP
, asm_out_file
);
631 putc ('"', asm_out_file
);
632 gcc_assert (stabstr_last_contin_point
== 0);
635 /* As above, but do not force text or emit pending bincls. This is
636 used by dbxout_symbol_location, which needs to do something else. */
638 dbxout_begin_complex_stabs_noforcetext (void)
640 fputs (ASM_STABS_OP
, asm_out_file
);
641 putc ('"', asm_out_file
);
642 gcc_assert (stabstr_last_contin_point
== 0);
645 /* Add CHR, a single character, to the string being built. */
646 #define stabstr_C(chr) obstack_1grow (&stabstr_ob, chr)
648 /* Add STR, a normal C string, to the string being built. */
649 #define stabstr_S(str) obstack_grow (&stabstr_ob, str, strlen (str))
651 /* Add the text of ID, an IDENTIFIER_NODE, to the string being built. */
652 #define stabstr_I(id) obstack_grow (&stabstr_ob, \
653 IDENTIFIER_POINTER (id), \
654 IDENTIFIER_LENGTH (id))
656 /* Add NUM, a signed decimal number, to the string being built. */
658 stabstr_D (HOST_WIDE_INT num
)
661 char *p
= buf
+ sizeof buf
;
677 NUMBER_FMT_LOOP (p
, unum
, 10);
679 obstack_grow (&stabstr_ob
, p
, (buf
+ sizeof buf
) - p
);
682 /* Add NUM, an unsigned decimal number, to the string being built. */
684 stabstr_U (unsigned HOST_WIDE_INT num
)
687 char *p
= buf
+ sizeof buf
;
693 NUMBER_FMT_LOOP (p
, num
, 10);
694 obstack_grow (&stabstr_ob
, p
, (buf
+ sizeof buf
) - p
);
697 /* Add CST, an INTEGER_CST tree, to the string being built as an
698 unsigned octal number. This routine handles values which are
699 larger than a single HOST_WIDE_INT. */
703 int prec
= TYPE_PRECISION (TREE_TYPE (cst
));
704 int res_pres
= prec
% 3;
708 /* Leading zero for base indicator. */
711 /* If the value is zero, the base indicator will serve as the value
713 if (wi::eq_p (cst
, 0))
716 /* GDB wants constants with no extra leading "1" bits, so
717 we need to remove any sign-extension that might be
721 digit
= wi::extract_uhwi (cst
, prec
- 1, 1);
722 stabstr_C ('0' + digit
);
724 else if (res_pres
== 2)
726 digit
= wi::extract_uhwi (cst
, prec
- 2, 2);
727 stabstr_C ('0' + digit
);
731 for (i
= prec
- 3; i
>= 0; i
= i
- 3)
733 digit
= wi::extract_uhwi (cst
, i
, 3);
734 stabstr_C ('0' + digit
);
738 /* Called whenever it is safe to break a stabs string into multiple
739 .stabs directives. If the current string has exceeded the limit
740 set by DBX_CONTIN_LENGTH, mark the current position in the buffer
741 as a continuation point by inserting DBX_CONTIN_CHAR (doubled if
742 it is a backslash) and a null character. */
744 stabstr_continue (void)
746 if (DBX_CONTIN_LENGTH
> 0
747 && obstack_object_size (&stabstr_ob
) - stabstr_last_contin_point
750 if (DBX_CONTIN_CHAR
== '\\')
751 obstack_1grow (&stabstr_ob
, '\\');
752 obstack_1grow (&stabstr_ob
, DBX_CONTIN_CHAR
);
753 obstack_1grow (&stabstr_ob
, '\0');
754 stabstr_last_contin_point
= obstack_object_size (&stabstr_ob
);
757 #define CONTIN stabstr_continue ()
759 /* Macro subroutine of dbxout_finish_complex_stabs, which emits
760 all of the arguments to the .stabs directive after the string.
761 Overridden by xcoffout.h. CODE is the stabs code for this symbol;
762 LINE is the source line to write into the desc field (in extended
763 mode); SYM is the symbol itself.
765 ADDR, LABEL, and NUMBER are three different ways to represent the
766 stabs value field. At most one of these should be nonzero.
768 ADDR is used most of the time; it represents the value as an
769 RTL address constant.
771 LABEL is used (currently) only for N_CATCH stabs; it represents
772 the value as a string suitable for assemble_name.
774 NUMBER is used when the value is an offset from an implicit base
775 pointer (e.g. for a stack variable), or an index (e.g. for a
776 register variable). It represents the value as a decimal integer. */
778 #ifndef DBX_FINISH_STABS
779 #define DBX_FINISH_STABS(SYM, CODE, LINE, ADDR, LABEL, NUMBER) \
781 int line_ = use_gnu_debug_info_extensions ? LINE : 0; \
784 fputs (",0,", asm_out_file); \
785 dbxout_int (line_); \
786 putc (',', asm_out_file); \
788 output_addr_const (asm_out_file, ADDR); \
790 assemble_name (asm_out_file, LABEL); \
792 dbxout_int (NUMBER); \
793 putc ('\n', asm_out_file); \
797 /* Finish the emission of a complex .stabs directive. When DBX_CONTIN_LENGTH
798 is zero, this has only to emit the close quote and the remainder of
799 the arguments. When it is nonzero, the string has been marshalled in
800 stabstr_ob, and this routine is responsible for breaking it up into
801 DBX_CONTIN_LENGTH-sized chunks.
803 SYM is the DECL of the symbol under consideration; it is used only
804 for its DECL_SOURCE_LINE. The other arguments are all passed directly
805 to DBX_FINISH_STABS; see above for details. */
808 dbxout_finish_complex_stabs (tree sym
, stab_code_type code
,
809 rtx addr
, const char *label
, int number
)
811 int line ATTRIBUTE_UNUSED
;
815 line
= sym
? DECL_SOURCE_LINE (sym
) : 0;
816 if (DBX_CONTIN_LENGTH
> 0)
821 /* Nul-terminate the growing string, then get its size and
823 obstack_1grow (&stabstr_ob
, '\0');
825 len
= obstack_object_size (&stabstr_ob
);
826 chunk
= str
= XOBFINISH (&stabstr_ob
, char *);
828 /* Within the buffer are a sequence of NUL-separated strings,
829 each of which is to be written out as a separate stab
833 chunklen
= strlen (chunk
);
834 fwrite (chunk
, 1, chunklen
, asm_out_file
);
835 fputs ("\",", asm_out_file
);
837 /* Must add an extra byte to account for the NUL separator. */
838 chunk
+= chunklen
+ 1;
841 /* Only put a line number on the last stab in the sequence. */
842 DBX_FINISH_STABS (sym
, code
, len
== 0 ? line
: 0,
843 addr
, label
, number
);
847 fputs (ASM_STABS_OP
, asm_out_file
);
848 putc ('"', asm_out_file
);
850 stabstr_last_contin_point
= 0;
854 /* No continuations - we can put the whole string out at once.
855 It is faster to augment the string with the close quote and
856 comma than to do a two-character fputs. */
857 obstack_grow (&stabstr_ob
, "\",", 2);
858 len
= obstack_object_size (&stabstr_ob
);
859 str
= XOBFINISH (&stabstr_ob
, char *);
861 fwrite (str
, 1, len
, asm_out_file
);
862 DBX_FINISH_STABS (sym
, code
, line
, addr
, label
, number
);
864 obstack_free (&stabstr_ob
, str
);
867 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
869 /* When -gused is used, emit debug info for only used symbols. But in
870 addition to the standard intercepted debug_hooks there are some
871 direct calls into this file, i.e., dbxout_symbol, dbxout_parms, and
872 dbxout_reg_params. Those routines may also be called from a higher
873 level intercepted routine. So to prevent recording data for an inner
874 call to one of these for an intercept, we maintain an intercept
875 nesting counter (debug_nesting). We only save the intercepted
876 arguments if the nesting is 1. */
877 static int debug_nesting
= 0;
879 static tree
*symbol_queue
;
880 static int symbol_queue_index
= 0;
881 static int symbol_queue_size
= 0;
883 #define DBXOUT_DECR_NESTING \
884 if (--debug_nesting == 0 && symbol_queue_index > 0) \
885 { emit_pending_bincls_if_required (); debug_flush_symbol_queue (); }
887 #define DBXOUT_DECR_NESTING_AND_RETURN(x) \
888 do {--debug_nesting; return (x);} while (0)
890 #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */
892 #if defined (DBX_DEBUGGING_INFO)
895 dbxout_function_end (tree decl ATTRIBUTE_UNUSED
)
897 char lscope_label_name
[100];
899 /* The Lscope label must be emitted even if we aren't doing anything
900 else; dbxout_block needs it. */
901 switch_to_section (function_section (current_function_decl
));
903 /* Convert Lscope into the appropriate format for local labels in case
904 the system doesn't insert underscores in front of user generated
906 ASM_GENERATE_INTERNAL_LABEL (lscope_label_name
, "Lscope", scope_labelno
);
907 targetm
.asm_out
.internal_label (asm_out_file
, "Lscope", scope_labelno
);
909 /* The N_FUN tag at the end of the function is a GNU extension,
910 which may be undesirable, and is unnecessary if we do not have
912 if (!use_gnu_debug_info_extensions
913 || NO_DBX_FUNCTION_END
914 || !targetm_common
.have_named_sections
)
917 /* By convention, GCC will mark the end of a function with an N_FUN
918 symbol and an empty string. */
919 if (crtl
->has_bb_partition
)
921 dbxout_begin_empty_stabs (N_FUN
);
922 dbxout_stab_value_label_diff (crtl
->subsections
.hot_section_end_label
,
923 crtl
->subsections
.hot_section_label
);
924 dbxout_begin_empty_stabs (N_FUN
);
925 dbxout_stab_value_label_diff (crtl
->subsections
.cold_section_end_label
,
926 crtl
->subsections
.cold_section_label
);
930 char begin_label
[20];
931 /* Reference current function start using LFBB. */
932 ASM_GENERATE_INTERNAL_LABEL (begin_label
, "LFBB", scope_labelno
);
933 dbxout_begin_empty_stabs (N_FUN
);
934 dbxout_stab_value_label_diff (lscope_label_name
, begin_label
);
937 if (!NO_DBX_BNSYM_ENSYM
&& !flag_debug_only_used_symbols
)
938 dbxout_stabd (N_ENSYM
, 0);
940 #endif /* DBX_DEBUGGING_INFO */
942 /* Get lang description for N_SO stab. */
943 static unsigned int ATTRIBUTE_UNUSED
944 get_lang_number (void)
946 const char *language_string
= lang_hooks
.name
;
949 else if (lang_GNU_CXX ())
951 else if (strcmp (language_string
, "GNU F77") == 0)
953 else if (lang_GNU_Fortran ())
954 return N_SO_FORTRAN90
; /* CHECKME */
955 else if (strcmp (language_string
, "GNU Objective-C") == 0)
957 else if (strcmp (language_string
, "GNU Objective-C++") == 0)
958 return N_SO_OBJCPLUS
;
967 unsigned int lang
= get_lang_number ();
969 return (lang
== N_SO_FORTRAN
) || (lang
== N_SO_FORTRAN90
);
972 /* At the beginning of compilation, start writing the symbol table.
973 Initialize `typevec' and output the standard data types of C. */
976 dbxout_init (const char *input_file_name
)
978 char ltext_label_name
[100];
979 bool used_ltext_label_name
= false;
980 tree syms
= lang_hooks
.decls
.getdecls ();
981 const char *mapped_name
;
984 typevec
= ggc_cleared_vec_alloc
<typeinfo
> (typevec_len
);
986 /* stabstr_ob contains one string, which will be just fine with
988 obstack_specify_allocation (&stabstr_ob
, 0, 1, xmalloc
, free
);
990 /* Convert Ltext into the appropriate format for local labels in case
991 the system doesn't insert underscores in front of user generated
993 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name
, "Ltext", 0);
995 /* Put the current working directory in an N_SO symbol. */
996 if (use_gnu_debug_info_extensions
&& !NO_DBX_MAIN_SOURCE_DIRECTORY
)
998 static const char *cwd
;
1002 cwd
= get_src_pwd ();
1005 else if (!IS_DIR_SEPARATOR (cwd
[strlen (cwd
) - 1]))
1006 cwd
= concat (cwd
, "/", NULL
);
1007 cwd
= remap_debug_filename (cwd
);
1009 #ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
1010 DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asm_out_file
, cwd
);
1011 #else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
1012 dbxout_begin_simple_stabs_desc (cwd
, N_SO
, get_lang_number ());
1013 dbxout_stab_value_label (ltext_label_name
);
1014 used_ltext_label_name
= true;
1015 #endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
1018 mapped_name
= remap_debug_filename (input_file_name
);
1019 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
1020 DBX_OUTPUT_MAIN_SOURCE_FILENAME (asm_out_file
, mapped_name
);
1022 dbxout_begin_simple_stabs_desc (mapped_name
, N_SO
, get_lang_number ());
1023 dbxout_stab_value_label (ltext_label_name
);
1024 used_ltext_label_name
= true;
1027 if (used_ltext_label_name
)
1029 switch_to_section (text_section
);
1030 targetm
.asm_out
.internal_label (asm_out_file
, "Ltext", 0);
1033 /* Emit an N_OPT stab to indicate that this file was compiled by GCC.
1034 The string used is historical. */
1035 #ifndef NO_DBX_GCC_MARKER
1036 dbxout_begin_simple_stabs ("gcc2_compiled.", N_OPT
);
1037 dbxout_stab_value_zero ();
1040 base_input_file
= lastfile
= input_file_name
;
1042 next_type_number
= 1;
1044 #ifdef DBX_USE_BINCL
1045 current_file
= XNEW (struct dbx_file
);
1046 current_file
->next
= NULL
;
1047 current_file
->file_number
= 0;
1048 current_file
->next_type_number
= 1;
1049 next_file_number
= 1;
1050 current_file
->prev
= NULL
;
1051 current_file
->bincl_status
= BINCL_NOT_REQUIRED
;
1052 current_file
->pending_bincl_name
= NULL
;
1055 /* Get all permanent types that have typedef names, and output them
1056 all, except for those already output. Some language front ends
1057 put these declarations in the top-level scope; some do not;
1058 the latter are responsible for calling debug_hooks->type_decl from
1059 their record_builtin_type function. */
1060 dbxout_typedefs (syms
);
1062 if (preinit_symbols
)
1065 for (t
= nreverse (preinit_symbols
); t
; t
= TREE_CHAIN (t
))
1066 dbxout_symbol (TREE_VALUE (t
), 0);
1067 preinit_symbols
= 0;
1071 /* Output any typedef names for types described by TYPE_DECLs in SYMS. */
1074 dbxout_typedefs (tree syms
)
1076 for (; syms
!= NULL_TREE
; syms
= DECL_CHAIN (syms
))
1078 if (TREE_CODE (syms
) == TYPE_DECL
)
1080 tree type
= TREE_TYPE (syms
);
1081 if (TYPE_NAME (type
)
1082 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1083 && COMPLETE_OR_VOID_TYPE_P (type
)
1084 && ! TREE_ASM_WRITTEN (TYPE_NAME (type
)))
1085 dbxout_symbol (TYPE_NAME (type
), 0);
1090 #ifdef DBX_USE_BINCL
1091 /* Emit BINCL stab using given name. */
1093 emit_bincl_stab (const char *name
)
1095 dbxout_begin_simple_stabs (name
, N_BINCL
);
1096 dbxout_stab_value_zero ();
1099 /* If there are pending bincls then it is time to emit all of them. */
1102 emit_pending_bincls_if_required (void)
1105 emit_pending_bincls ();
1108 /* Emit all pending bincls. */
1111 emit_pending_bincls (void)
1113 struct dbx_file
*f
= current_file
;
1115 /* Find first pending bincl. */
1116 while (f
->bincl_status
== BINCL_PENDING
)
1119 /* Now emit all bincls. */
1124 if (f
->bincl_status
== BINCL_PENDING
)
1126 emit_bincl_stab (f
->pending_bincl_name
);
1128 /* Update file number and status. */
1129 f
->file_number
= next_file_number
++;
1130 f
->bincl_status
= BINCL_PROCESSED
;
1132 if (f
== current_file
)
1137 /* All pending bincls have been emitted. */
1144 emit_pending_bincls_if_required (void) {}
1147 /* Change to reading from a new source file. Generate a N_BINCL stab. */
1150 dbxout_start_source_file (unsigned int line ATTRIBUTE_UNUSED
,
1151 const char *filename ATTRIBUTE_UNUSED
)
1153 #ifdef DBX_USE_BINCL
1154 struct dbx_file
*n
= XNEW (struct dbx_file
);
1156 n
->next
= current_file
;
1157 n
->next_type_number
= 1;
1158 /* Do not assign file number now.
1159 Delay it until we actually emit BINCL. */
1162 current_file
->prev
= n
;
1163 n
->bincl_status
= BINCL_PENDING
;
1164 n
->pending_bincl_name
= remap_debug_filename (filename
);
1170 /* Revert to reading a previous source file. Generate a N_EINCL stab. */
1173 dbxout_end_source_file (unsigned int line ATTRIBUTE_UNUSED
)
1175 #ifdef DBX_USE_BINCL
1176 /* Emit EINCL stab only if BINCL is not pending. */
1177 if (current_file
->bincl_status
== BINCL_PROCESSED
)
1179 dbxout_begin_stabn (N_EINCL
);
1180 dbxout_stab_value_zero ();
1182 current_file
->bincl_status
= BINCL_NOT_REQUIRED
;
1183 current_file
= current_file
->next
;
1187 /* Handle a few odd cases that occur when trying to make PCH files work. */
1190 dbxout_handle_pch (unsigned at_end
)
1194 /* When using the PCH, this file will be included, so we need to output
1196 dbxout_start_source_file (0, lastfile
);
1198 /* The base file when using the PCH won't be the same as
1199 the base file when it's being generated. */
1204 /* ... and an EINCL. */
1205 dbxout_end_source_file (0);
1207 /* Deal with cases where 'lastfile' was never actually changed. */
1208 lastfile_is_base
= lastfile
== NULL
;
1212 #if defined (DBX_DEBUGGING_INFO)
1214 static void dbxout_block (tree
, int, tree
);
1216 /* Output debugging info to FILE to switch to sourcefile FILENAME. */
1219 dbxout_source_file (const char *filename
)
1221 if (lastfile
== 0 && lastfile_is_base
)
1223 lastfile
= base_input_file
;
1224 lastfile_is_base
= 0;
1227 if (filename
&& (lastfile
== 0 || strcmp (filename
, lastfile
)))
1229 /* Don't change section amid function. */
1230 if (current_function_decl
== NULL_TREE
)
1231 switch_to_section (text_section
);
1233 dbxout_begin_simple_stabs (remap_debug_filename (filename
), N_SOL
);
1234 dbxout_stab_value_internal_label ("Ltext", &source_label_number
);
1235 lastfile
= filename
;
1239 /* Output N_BNSYM, line number symbol entry, and local symbol at
1243 dbxout_begin_prologue (unsigned int lineno
,
1244 unsigned int column ATTRIBUTE_UNUSED
,
1245 const char *filename
)
1247 if (use_gnu_debug_info_extensions
1248 && !NO_DBX_FUNCTION_END
1249 && !NO_DBX_BNSYM_ENSYM
1250 && !flag_debug_only_used_symbols
)
1251 dbxout_stabd (N_BNSYM
, 0);
1253 /* pre-increment the scope counter */
1256 dbxout_source_line (lineno
, 0, filename
, 0, true);
1257 /* Output function begin block at function scope, referenced
1258 by dbxout_block, dbxout_source_line and dbxout_function_end. */
1259 emit_pending_bincls_if_required ();
1260 targetm
.asm_out
.internal_label (asm_out_file
, "LFBB", scope_labelno
);
1263 /* Output a line number symbol entry for source file FILENAME and line
1267 dbxout_source_line (unsigned int lineno
, unsigned int column ATTRIBUTE_UNUSED
,
1268 const char *filename
, int discriminator ATTRIBUTE_UNUSED
,
1269 bool is_stmt ATTRIBUTE_UNUSED
)
1271 dbxout_source_file (filename
);
1273 #ifdef DBX_OUTPUT_SOURCE_LINE
1274 DBX_OUTPUT_SOURCE_LINE (asm_out_file
, lineno
, dbxout_source_line_counter
);
1276 if (DBX_LINES_FUNCTION_RELATIVE
)
1278 char begin_label
[20];
1279 dbxout_begin_stabn_sline (lineno
);
1280 /* Reference current function start using LFBB. */
1281 ASM_GENERATE_INTERNAL_LABEL (begin_label
, "LFBB", scope_labelno
);
1282 dbxout_stab_value_internal_label_diff ("LM", &dbxout_source_line_counter
,
1286 dbxout_stabd (N_SLINE
, lineno
);
1290 /* Describe the beginning of an internal block within a function. */
1293 dbxout_begin_block (unsigned int line ATTRIBUTE_UNUSED
, unsigned int n
)
1295 emit_pending_bincls_if_required ();
1296 targetm
.asm_out
.internal_label (asm_out_file
, "LBB", n
);
1299 /* Describe the end line-number of an internal block within a function. */
1302 dbxout_end_block (unsigned int line ATTRIBUTE_UNUSED
, unsigned int n
)
1304 emit_pending_bincls_if_required ();
1305 targetm
.asm_out
.internal_label (asm_out_file
, "LBE", n
);
1308 /* Output dbx data for a function definition.
1309 This includes a definition of the function name itself (a symbol),
1310 definitions of the parameters (locating them in the parameter list)
1311 and then output the block that makes up the function's body
1312 (including all the auto variables of the function). */
1315 dbxout_function_decl (tree decl
)
1317 emit_pending_bincls_if_required ();
1318 #ifndef DBX_FUNCTION_FIRST
1319 dbxout_begin_function (decl
);
1321 dbxout_block (DECL_INITIAL (decl
), 0, DECL_ARGUMENTS (decl
));
1322 dbxout_function_end (decl
);
1325 #endif /* DBX_DEBUGGING_INFO */
1328 dbxout_early_global_decl (tree decl ATTRIBUTE_UNUSED
)
1330 /* NYI for non-dwarf. */
1333 /* Debug information for a global DECL. Called from toplev.c after
1334 compilation proper has finished. */
1336 dbxout_late_global_decl (tree decl
)
1338 if (VAR_P (decl
) && !DECL_EXTERNAL (decl
))
1340 int saved_tree_used
= TREE_USED (decl
);
1341 TREE_USED (decl
) = 1;
1342 dbxout_symbol (decl
, 0);
1343 TREE_USED (decl
) = saved_tree_used
;
1347 /* This is just a function-type adapter; dbxout_symbol does exactly
1348 what we want but returns an int. */
1350 dbxout_type_decl (tree decl
, int local
)
1352 dbxout_symbol (decl
, local
);
1355 /* At the end of compilation, finish writing the symbol table.
1356 The default is to call debug_free_queue but do nothing else. */
1359 dbxout_finish (const char *filename ATTRIBUTE_UNUSED
)
1361 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
1362 DBX_OUTPUT_MAIN_SOURCE_FILE_END (asm_out_file
, filename
);
1363 #elif defined DBX_OUTPUT_NULL_N_SO_AT_MAIN_SOURCE_FILE_END
1365 switch_to_section (text_section
);
1366 dbxout_begin_empty_stabs (N_SO
);
1367 dbxout_stab_value_internal_label ("Letext", 0);
1370 debug_free_queue ();
1373 /* Output the index of a type. */
1376 dbxout_type_index (tree type
)
1378 #ifndef DBX_USE_BINCL
1379 stabstr_D (TYPE_SYMTAB_ADDRESS (type
));
1381 struct typeinfo
*t
= &typevec
[TYPE_SYMTAB_ADDRESS (type
)];
1383 stabstr_D (t
->file_number
);
1385 stabstr_D (t
->type_number
);
1391 /* Generate the symbols for any queued up type symbols we encountered
1392 while generating the type info for some originally used symbol.
1393 This might generate additional entries in the queue. Only when
1394 the nesting depth goes to 0 is this routine called. */
1397 debug_flush_symbol_queue (void)
1401 /* Make sure that additionally queued items are not flushed
1406 for (i
= 0; i
< symbol_queue_index
; ++i
)
1408 /* If we pushed queued symbols then such symbols must be
1409 output no matter what anyone else says. Specifically,
1410 we need to make sure dbxout_symbol() thinks the symbol was
1411 used and also we need to override TYPE_DECL_SUPPRESS_DEBUG
1412 which may be set for outside reasons. */
1413 int saved_tree_used
= TREE_USED (symbol_queue
[i
]);
1414 int saved_suppress_debug
= TYPE_DECL_SUPPRESS_DEBUG (symbol_queue
[i
]);
1415 TREE_USED (symbol_queue
[i
]) = 1;
1416 TYPE_DECL_SUPPRESS_DEBUG (symbol_queue
[i
]) = 0;
1418 #ifdef DBX_DEBUGGING_INFO
1419 dbxout_symbol (symbol_queue
[i
], 0);
1422 TREE_USED (symbol_queue
[i
]) = saved_tree_used
;
1423 TYPE_DECL_SUPPRESS_DEBUG (symbol_queue
[i
]) = saved_suppress_debug
;
1426 symbol_queue_index
= 0;
1430 /* Queue a type symbol needed as part of the definition of a decl
1431 symbol. These symbols are generated when debug_flush_symbol_queue()
1435 debug_queue_symbol (tree decl
)
1437 if (symbol_queue_index
>= symbol_queue_size
)
1439 symbol_queue_size
+= 10;
1440 symbol_queue
= XRESIZEVEC (tree
, symbol_queue
, symbol_queue_size
);
1443 symbol_queue
[symbol_queue_index
++] = decl
;
1446 /* Free symbol queue. */
1448 debug_free_queue (void)
1452 free (symbol_queue
);
1453 symbol_queue
= NULL
;
1454 symbol_queue_size
= 0;
1458 /* Used in several places: evaluates to '0' for a private decl,
1459 '1' for a protected decl, '2' for a public decl. */
1460 #define DECL_ACCESSIBILITY_CHAR(DECL) \
1461 (TREE_PRIVATE (DECL) ? '0' : TREE_PROTECTED (DECL) ? '1' : '2')
1463 /* Subroutine of `dbxout_type'. Output the type fields of TYPE.
1464 This must be a separate function because anonymous unions require
1468 dbxout_type_fields (tree type
)
1472 /* Output the name, type, position (in bits), size (in bits) of each
1473 field that we can support. */
1474 for (tem
= TYPE_FIELDS (type
); tem
; tem
= DECL_CHAIN (tem
))
1476 /* If one of the nodes is an error_mark or its type is then
1478 if (error_operand_p (tem
))
1481 /* Omit here local type decls until we know how to support them. */
1482 if (TREE_CODE (tem
) == TYPE_DECL
1483 || TREE_CODE (tem
) == TEMPLATE_DECL
1484 /* Member functions emitted after fields. */
1485 || TREE_CODE (tem
) == FUNCTION_DECL
1486 /* Omit here the nameless fields that are used to skip bits. */
1487 || DECL_IGNORED_P (tem
)
1488 /* Omit fields whose position or size are variable or too large to
1490 || (TREE_CODE (tem
) == FIELD_DECL
1491 && (! tree_fits_shwi_p (bit_position (tem
))
1492 || ! DECL_SIZE (tem
)
1493 || ! tree_fits_uhwi_p (DECL_SIZE (tem
)))))
1496 else if (TREE_CODE (tem
) != CONST_DECL
)
1498 /* Continue the line if necessary,
1499 but not before the first field. */
1500 if (tem
!= TYPE_FIELDS (type
))
1503 if (DECL_NAME (tem
))
1504 stabstr_I (DECL_NAME (tem
));
1507 if (use_gnu_debug_info_extensions
1508 && (TREE_PRIVATE (tem
) || TREE_PROTECTED (tem
)
1509 || TREE_CODE (tem
) != FIELD_DECL
))
1512 stabstr_C (DECL_ACCESSIBILITY_CHAR (tem
));
1515 dbxout_type ((TREE_CODE (tem
) == FIELD_DECL
1516 && DECL_BIT_FIELD_TYPE (tem
))
1517 ? DECL_BIT_FIELD_TYPE (tem
) : TREE_TYPE (tem
), 0);
1521 if (TREE_STATIC (tem
) && use_gnu_debug_info_extensions
)
1523 tree name
= DECL_ASSEMBLER_NAME (tem
);
1530 /* If TEM is non-static, GDB won't understand it. */
1531 stabstr_S (",0,0;");
1536 stabstr_D (int_bit_position (tem
));
1538 stabstr_D (tree_to_uhwi (DECL_SIZE (tem
)));
1545 /* Subroutine of `dbxout_type_methods'. Output debug info about the
1546 method described DECL. */
1549 dbxout_type_method_1 (tree decl
)
1553 if (TREE_CODE (TREE_TYPE (decl
)) == FUNCTION_TYPE
)
1555 else /* it's a METHOD_TYPE. */
1557 tree firstarg
= TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)));
1558 /* A for normal functions.
1559 B for `const' member functions.
1560 C for `volatile' member functions.
1561 D for `const volatile' member functions. */
1562 if (TYPE_READONLY (TREE_TYPE (firstarg
)))
1564 if (TYPE_VOLATILE (TREE_TYPE (firstarg
)))
1567 if (DECL_VINDEX (decl
))
1573 /* ??? Output the mangled name, which contains an encoding of the
1574 method's type signature. May not be necessary anymore. */
1576 stabstr_I (DECL_ASSEMBLER_NAME (decl
));
1578 stabstr_C (DECL_ACCESSIBILITY_CHAR (decl
));
1582 if (DECL_VINDEX (decl
) && tree_fits_shwi_p (DECL_VINDEX (decl
)))
1584 stabstr_D (tree_to_shwi (DECL_VINDEX (decl
)));
1586 dbxout_type (DECL_CONTEXT (decl
), 0);
1591 /* Subroutine of `dbxout_type'. Output debug info about the member
1592 functions defined in TYPE. */
1595 dbxout_type_methods (tree type
)
1597 for (tree fndecl
= TYPE_FIELDS (type
); fndecl
;)
1599 int need_prefix
= 1;
1601 /* Group together all the methods for the same operation.
1602 These differ in the types of the arguments. */
1603 for (tree last
= NULL_TREE
;
1604 fndecl
&& (last
== NULL_TREE
|| DECL_NAME (fndecl
) == DECL_NAME (last
));
1605 fndecl
= DECL_CHAIN (fndecl
))
1606 /* Output the name of the field (after overloading), as
1607 well as the name of the field before overloading, along
1608 with its parameter list */
1610 /* Skip non-functions. */
1611 if (TREE_CODE (fndecl
) != FUNCTION_DECL
)
1614 /* Also ignore abstract methods; those are only interesting to
1615 the DWARF backends. */
1616 if (DECL_IGNORED_P (fndecl
) || DECL_ABSTRACT_P (fndecl
))
1623 /* Redundantly output the plain name, since that's what gdb
1627 stabstr_I (DECL_NAME (fndecl
));
1632 dbxout_type (TREE_TYPE (fndecl
), 0);
1633 dbxout_type_method_1 (fndecl
);
1640 /* Emit a "range" type specification, which has the form:
1641 "r<index type>;<lower bound>;<upper bound>;".
1642 TYPE is an INTEGER_TYPE, LOW and HIGH are the bounds. */
1645 dbxout_range_type (tree type
, tree low
, tree high
)
1648 if (TREE_TYPE (type
))
1649 dbxout_type (TREE_TYPE (type
), 0);
1650 else if (TREE_CODE (type
) != INTEGER_TYPE
)
1651 dbxout_type (type
, 0); /* E.g. Pascal's ARRAY [BOOLEAN] of INTEGER */
1654 /* Traditionally, we made sure 'int' was type 1, and builtin types
1655 were defined to be sub-ranges of int. Unfortunately, this
1656 does not allow us to distinguish true sub-ranges from integer
1657 types. So, instead we define integer (non-sub-range) types as
1658 sub-ranges of themselves. This matters for Chill. If this isn't
1659 a subrange type, then we want to define it in terms of itself.
1660 However, in C, this may be an anonymous integer type, and we don't
1661 want to emit debug info referring to it. Just calling
1662 dbxout_type_index won't work anyways, because the type hasn't been
1663 defined yet. We make this work for both cases by checked to see
1664 whether this is a defined type, referring to it if it is, and using
1666 if (TYPE_SYMTAB_ADDRESS (type
) != 0)
1667 dbxout_type_index (type
);
1669 dbxout_type_index (integer_type_node
);
1673 if (low
&& tree_fits_shwi_p (low
))
1675 if (print_int_cst_bounds_in_octal_p (type
, low
, high
))
1678 stabstr_D (tree_to_shwi (low
));
1684 if (high
&& tree_fits_shwi_p (high
))
1686 if (print_int_cst_bounds_in_octal_p (type
, low
, high
))
1689 stabstr_D (tree_to_shwi (high
));
1697 /* Output a reference to a type. If the type has not yet been
1698 described in the dbx output, output its definition now.
1699 For a type already defined, just refer to its definition
1700 using the type number.
1702 If FULL is nonzero, and the type has been described only with
1703 a forward-reference, output the definition now.
1704 If FULL is zero in this case, just refer to the forward-reference
1705 using the number previously allocated. */
1708 dbxout_type (tree type
, int full
)
1710 static int anonymous_type_number
= 0;
1711 tree tem
, main_variant
, low
, high
;
1713 if (TREE_CODE (type
) == INTEGER_TYPE
)
1715 if (TREE_TYPE (type
) == 0)
1717 low
= TYPE_MIN_VALUE (type
);
1718 high
= TYPE_MAX_VALUE (type
);
1721 else if (subrange_type_for_debug_p (type
, &low
, &high
))
1724 /* If this is a subtype that should not be emitted as a subrange type,
1725 use the base type. */
1728 type
= TREE_TYPE (type
);
1729 low
= TYPE_MIN_VALUE (type
);
1730 high
= TYPE_MAX_VALUE (type
);
1734 /* If there was an input error and we don't really have a type,
1735 avoid crashing and write something that is at least valid
1736 by assuming `int'. */
1737 if (type
== error_mark_node
)
1738 type
= integer_type_node
;
1741 if (TYPE_NAME (type
)
1742 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1743 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type
)))
1747 /* Try to find the "main variant" with the same name. */
1748 if (TYPE_NAME (type
) && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1749 && DECL_ORIGINAL_TYPE (TYPE_NAME (type
)))
1750 main_variant
= TREE_TYPE (TYPE_NAME (type
));
1752 main_variant
= TYPE_MAIN_VARIANT (type
);
1754 /* If we are not using extensions, stabs does not distinguish const and
1755 volatile, so there is no need to make them separate types. */
1756 if (!use_gnu_debug_info_extensions
)
1757 type
= main_variant
;
1759 if (TYPE_SYMTAB_ADDRESS (type
) == 0)
1761 /* Type has no dbx number assigned. Assign next available number. */
1762 TYPE_SYMTAB_ADDRESS (type
) = next_type_number
++;
1764 /* Make sure type vector is long enough to record about this type. */
1766 if (next_type_number
== typevec_len
)
1768 typevec
= GGC_RESIZEVEC (struct typeinfo
, typevec
, typevec_len
* 2);
1769 memset (typevec
+ typevec_len
, 0, typevec_len
* sizeof typevec
[0]);
1773 #ifdef DBX_USE_BINCL
1774 emit_pending_bincls_if_required ();
1775 typevec
[TYPE_SYMTAB_ADDRESS (type
)].file_number
1776 = current_file
->file_number
;
1777 typevec
[TYPE_SYMTAB_ADDRESS (type
)].type_number
1778 = current_file
->next_type_number
++;
1782 if (flag_debug_only_used_symbols
)
1784 if ((TREE_CODE (type
) == RECORD_TYPE
1785 || TREE_CODE (type
) == UNION_TYPE
1786 || TREE_CODE (type
) == QUAL_UNION_TYPE
1787 || TREE_CODE (type
) == ENUMERAL_TYPE
)
1788 && TYPE_STUB_DECL (type
)
1789 && DECL_P (TYPE_STUB_DECL (type
))
1790 && ! DECL_IGNORED_P (TYPE_STUB_DECL (type
)))
1791 debug_queue_symbol (TYPE_STUB_DECL (type
));
1792 else if (TYPE_NAME (type
)
1793 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
1794 debug_queue_symbol (TYPE_NAME (type
));
1797 /* Output the number of this type, to refer to it. */
1798 dbxout_type_index (type
);
1800 #ifdef DBX_TYPE_DEFINED
1801 if (DBX_TYPE_DEFINED (type
))
1805 /* If this type's definition has been output or is now being output,
1808 switch (typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
)
1813 /* If we have already had a cross reference,
1814 and either that's all we want or that's the best we could do,
1815 don't repeat the cross reference.
1816 Sun dbx crashes if we do. */
1817 if (! full
|| !COMPLETE_TYPE_P (type
)
1818 /* No way in DBX fmt to describe a variable size. */
1819 || ! tree_fits_uhwi_p (TYPE_SIZE (type
)))
1827 /* For systems where dbx output does not allow the `=xsNAME:' syntax,
1828 leave the type-number completely undefined rather than output
1829 a cross-reference. If we have already used GNU debug info extensions,
1830 then it is OK to output a cross reference. This is necessary to get
1831 proper C++ debug output. */
1832 if ((TREE_CODE (type
) == RECORD_TYPE
|| TREE_CODE (type
) == UNION_TYPE
1833 || TREE_CODE (type
) == QUAL_UNION_TYPE
1834 || TREE_CODE (type
) == ENUMERAL_TYPE
)
1835 && ! use_gnu_debug_info_extensions
)
1836 /* We must use the same test here as we use twice below when deciding
1837 whether to emit a cross-reference. */
1838 if ((TYPE_NAME (type
) != 0
1839 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1840 && DECL_IGNORED_P (TYPE_NAME (type
)))
1842 || !COMPLETE_TYPE_P (type
)
1843 /* No way in DBX fmt to describe a variable size. */
1844 || ! tree_fits_uhwi_p (TYPE_SIZE (type
)))
1846 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1851 /* Output a definition now. */
1854 /* Mark it as defined, so that if it is self-referent
1855 we will not get into an infinite recursion of definitions. */
1857 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_DEFINED
;
1859 /* If this type is a variant of some other, hand off. Types with
1860 different names are usefully distinguished. We only distinguish
1861 cv-qualified types if we're using extensions. */
1862 if (TYPE_READONLY (type
) > TYPE_READONLY (main_variant
))
1865 dbxout_type (build_type_variant (type
, 0, TYPE_VOLATILE (type
)), 0);
1868 else if (TYPE_VOLATILE (type
) > TYPE_VOLATILE (main_variant
))
1871 dbxout_type (build_type_variant (type
, TYPE_READONLY (type
), 0), 0);
1874 else if (main_variant
!= TYPE_MAIN_VARIANT (type
))
1876 if (flag_debug_only_used_symbols
)
1878 tree orig_type
= DECL_ORIGINAL_TYPE (TYPE_NAME (type
));
1880 if ((TREE_CODE (orig_type
) == RECORD_TYPE
1881 || TREE_CODE (orig_type
) == UNION_TYPE
1882 || TREE_CODE (orig_type
) == QUAL_UNION_TYPE
1883 || TREE_CODE (orig_type
) == ENUMERAL_TYPE
)
1884 && TYPE_STUB_DECL (orig_type
)
1885 && ! DECL_IGNORED_P (TYPE_STUB_DECL (orig_type
)))
1886 debug_queue_symbol (TYPE_STUB_DECL (orig_type
));
1888 /* 'type' is a typedef; output the type it refers to. */
1889 dbxout_type (DECL_ORIGINAL_TYPE (TYPE_NAME (type
)), 0);
1892 /* else continue. */
1894 switch (TREE_CODE (type
))
1899 /* For a void type, just define it as itself; i.e., "5=5".
1900 This makes us consider it defined
1901 without saying what it is. The debugger will make it
1902 a void type when the reference is seen, and nothing will
1903 ever override that default. */
1904 dbxout_type_index (type
);
1908 if (type
== char_type_node
&& ! TYPE_UNSIGNED (type
))
1910 /* Output the type `char' as a subrange of itself!
1911 I don't understand this definition, just copied it
1912 from the output of pcc.
1913 This used to use `r2' explicitly and we used to
1914 take care to make sure that `char' was type number 2. */
1916 dbxout_type_index (type
);
1917 stabstr_S (";0;127;");
1920 /* If this is a subtype of another integer type, always prefer to
1921 write it as a subtype. */
1922 else if (TREE_TYPE (type
) != 0
1923 && TREE_CODE (TREE_TYPE (type
)) == INTEGER_TYPE
)
1925 /* If the size is non-standard, say what it is if we can use
1928 if (use_gnu_debug_info_extensions
1929 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
1932 stabstr_D (TYPE_PRECISION (type
));
1936 dbxout_range_type (type
, low
, high
);
1941 /* If the size is non-standard, say what it is if we can use
1944 if (use_gnu_debug_info_extensions
1945 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
1948 stabstr_D (TYPE_PRECISION (type
));
1952 if (print_int_cst_bounds_in_octal_p (type
, low
, high
))
1956 /* If this type derives from another type, output type index of
1957 parent type. This is particularly important when parent type
1958 is an enumerated type, because not generating the parent type
1959 index would transform the definition of this enumerated type
1960 into a plain unsigned type. */
1961 if (TREE_TYPE (type
) != 0)
1962 dbxout_type_index (TREE_TYPE (type
));
1964 dbxout_type_index (type
);
1974 /* Output other integer types as subranges of `int'. */
1975 dbxout_range_type (type
, low
, high
);
1981 case FIXED_POINT_TYPE
:
1982 /* This used to say `r1' and we used to take care
1983 to make sure that `int' was type number 1. */
1985 dbxout_type_index (integer_type_node
);
1987 stabstr_D (int_size_in_bytes (type
));
1992 if (use_gnu_debug_info_extensions
)
1995 stabstr_D (BITS_PER_UNIT
* int_size_in_bytes (type
));
1996 stabstr_S (";-16;");
1998 else /* Define as enumeral type (False, True) */
1999 stabstr_S ("eFalse:0,True:1,;");
2003 /* Differs from the REAL_TYPE by its new data type number.
2004 R3 is NF_COMPLEX. We don't try to use any of the other NF_*
2005 codes since gdb doesn't care anyway. */
2007 if (TREE_CODE (TREE_TYPE (type
)) == REAL_TYPE
)
2010 stabstr_D (2 * int_size_in_bytes (TREE_TYPE (type
)));
2015 /* Output a complex integer type as a structure,
2016 pending some other way to do it. */
2018 stabstr_D (int_size_in_bytes (type
));
2020 stabstr_S ("real:");
2021 dbxout_type (TREE_TYPE (type
), 0);
2023 stabstr_D (TYPE_PRECISION (TREE_TYPE (type
)));
2025 stabstr_S (";imag:");
2026 dbxout_type (TREE_TYPE (type
), 0);
2028 stabstr_D (TYPE_PRECISION (TREE_TYPE (type
)));
2030 stabstr_D (TYPE_PRECISION (TREE_TYPE (type
)));
2036 /* Make arrays of packed bits look like bitstrings for chill. */
2037 if (TYPE_PACKED (type
) && use_gnu_debug_info_extensions
)
2040 stabstr_D (BITS_PER_UNIT
* int_size_in_bytes (type
));
2041 stabstr_S (";@S;S");
2042 dbxout_type (TYPE_DOMAIN (type
), 0);
2046 /* Output "a" followed by a range type definition
2047 for the index type of the array
2048 followed by a reference to the target-type.
2049 ar1;0;N;M for a C array of type M and size N+1. */
2050 /* Check if a character string type, which in Chill is
2051 different from an array of characters. */
2052 if (TYPE_STRING_FLAG (type
) && use_gnu_debug_info_extensions
)
2056 tem
= TYPE_DOMAIN (type
);
2060 dbxout_type_index (integer_type_node
);
2061 stabstr_S (";0;-1;");
2066 dbxout_range_type (tem
, TYPE_MIN_VALUE (tem
), TYPE_MAX_VALUE (tem
));
2069 dbxout_type (TREE_TYPE (type
), 0);
2073 /* Make vectors look like an array. */
2074 if (use_gnu_debug_info_extensions
)
2077 /* Output "a" followed by a range type definition
2078 for the index type of the array
2079 followed by a reference to the target-type.
2080 ar1;0;N;M for a C array of type M and size N+1. */
2082 dbxout_range_type (integer_type_node
, size_zero_node
,
2083 size_int (TYPE_VECTOR_SUBPARTS (type
) - 1));
2085 dbxout_type (TREE_TYPE (type
), 0);
2090 case QUAL_UNION_TYPE
:
2092 tree binfo
= TYPE_BINFO (type
);
2094 /* Output a structure type. We must use the same test here as we
2095 use in the DBX_NO_XREFS case above. */
2096 if ((TYPE_NAME (type
) != 0
2097 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
2098 && DECL_IGNORED_P (TYPE_NAME (type
)))
2100 || !COMPLETE_TYPE_P (type
)
2101 /* No way in DBX fmt to describe a variable size. */
2102 || ! tree_fits_uhwi_p (TYPE_SIZE (type
)))
2104 /* If the type is just a cross reference, output one
2105 and mark the type as partially described.
2106 If it later becomes defined, we will output
2107 its real definition.
2108 If the type has a name, don't nest its definition within
2109 another type's definition; instead, output an xref
2110 and let the definition come when the name is defined. */
2111 stabstr_S ((TREE_CODE (type
) == RECORD_TYPE
) ? "xs" : "xu");
2112 if (TYPE_IDENTIFIER (type
))
2114 /* Note that the C frontend creates for anonymous variable
2115 length records/unions TYPE_NAME with DECL_NAME NULL. */
2116 dbxout_type_name (type
);
2121 stabstr_D (anonymous_type_number
++);
2125 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
2129 /* Identify record or union, and print its size. */
2130 stabstr_C ((TREE_CODE (type
) == RECORD_TYPE
) ? 's' : 'u');
2131 stabstr_D (int_size_in_bytes (type
));
2137 vec
<tree
, va_gc
> *accesses
= BINFO_BASE_ACCESSES (binfo
);
2139 if (use_gnu_debug_info_extensions
)
2141 if (BINFO_N_BASE_BINFOS (binfo
))
2144 stabstr_U (BINFO_N_BASE_BINFOS (binfo
));
2148 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, child
); i
++)
2150 tree access
= (accesses
? (*accesses
)[i
] : access_public_node
);
2152 if (use_gnu_debug_info_extensions
)
2154 stabstr_C (BINFO_VIRTUAL_P (child
) ? '1' : '0');
2155 stabstr_C (access
== access_public_node
? '2' :
2156 access
== access_protected_node
2158 if (BINFO_VIRTUAL_P (child
)
2160 || strcmp (lang_hooks
.name
, "GNU Objective-C++") == 0))
2161 /* For a virtual base, print the (negative)
2162 offset within the vtable where we must look
2163 to find the necessary adjustment. */
2165 (tree_to_shwi (BINFO_VPTR_FIELD (child
))
2168 stabstr_D (tree_to_shwi (BINFO_OFFSET (child
))
2171 dbxout_type (BINFO_TYPE (child
), 0);
2176 /* Print out the base class information with
2177 fields which have the same names at the types
2179 dbxout_type_name (BINFO_TYPE (child
));
2181 dbxout_type (BINFO_TYPE (child
), full
);
2183 stabstr_D (tree_to_shwi (BINFO_OFFSET (child
))
2187 (tree_to_shwi (TYPE_SIZE (BINFO_TYPE (child
)))
2195 /* Write out the field declarations. */
2196 dbxout_type_fields (type
);
2197 if (use_gnu_debug_info_extensions
)
2198 dbxout_type_methods (type
);
2202 if (use_gnu_debug_info_extensions
&& TREE_CODE (type
) == RECORD_TYPE
2203 /* Avoid the ~ if we don't really need it--it confuses dbx. */
2204 && TYPE_VFIELD (type
))
2207 /* We need to write out info about what field this class
2208 uses as its "main" vtable pointer field, because if this
2209 field is inherited from a base class, GDB cannot necessarily
2210 figure out which field it's using in time. */
2212 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type
)), 0);
2218 /* We must use the same test here as we use in the DBX_NO_XREFS case
2219 above. We simplify it a bit since an enum will never have a variable
2221 if ((TYPE_NAME (type
) != 0
2222 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
2223 && DECL_IGNORED_P (TYPE_NAME (type
)))
2225 || !COMPLETE_TYPE_P (type
))
2228 dbxout_type_name (type
);
2229 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
2233 if (use_gnu_debug_info_extensions
2234 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
2237 stabstr_D (TYPE_PRECISION (type
));
2242 for (tem
= TYPE_VALUES (type
); tem
; tem
= TREE_CHAIN (tem
))
2244 tree value
= TREE_VALUE (tem
);
2246 stabstr_I (TREE_PURPOSE (tem
));
2249 if (TREE_CODE (value
) == CONST_DECL
)
2250 value
= DECL_INITIAL (value
);
2252 if (cst_and_fits_in_hwi (value
))
2253 stabstr_D (TREE_INT_CST_LOW (value
));
2258 if (TREE_CHAIN (tem
) != 0)
2267 dbxout_type (TREE_TYPE (type
), 0);
2271 if (use_gnu_debug_info_extensions
)
2275 /* Write the argument types out longhand. */
2276 dbxout_type (TYPE_METHOD_BASETYPE (type
), 0);
2278 dbxout_type (TREE_TYPE (type
), 0);
2279 dbxout_args (TYPE_ARG_TYPES (type
));
2283 /* Treat it as a function type. */
2284 dbxout_type (TREE_TYPE (type
), 0);
2288 if (use_gnu_debug_info_extensions
)
2291 dbxout_type (TYPE_OFFSET_BASETYPE (type
), 0);
2293 dbxout_type (TREE_TYPE (type
), 0);
2296 /* Should print as an int, because it is really just an offset. */
2297 dbxout_type (integer_type_node
, 0);
2300 case REFERENCE_TYPE
:
2301 if (use_gnu_debug_info_extensions
)
2307 dbxout_type (TREE_TYPE (type
), 0);
2312 dbxout_type (TREE_TYPE (type
), 0);
2315 case POINTER_BOUNDS_TYPE
:
2316 /* No debug info for pointer bounds type supported yet. */
2320 /* A C++ function with deduced return type can have a TEMPLATE_TYPE_PARM
2321 named 'auto' in its type.
2322 No debug info for TEMPLATE_TYPE_PARM type supported yet. */
2323 if (lang_GNU_CXX ())
2325 tree name
= TYPE_IDENTIFIER (type
);
2326 if (name
== get_identifier ("auto")
2327 || name
== get_identifier ("decltype(auto)"))
2335 /* Return nonzero if the given type represents an integer whose bounds
2336 should be printed in octal format. */
2339 print_int_cst_bounds_in_octal_p (tree type
, tree low
, tree high
)
2341 /* If we can use GDB extensions and the size is wider than a long
2342 (the size used by GDB to read them) or we may have trouble writing
2343 the bounds the usual way, write them in octal. Note the test is for
2344 the *target's* size of "long", not that of the host. The host test
2345 is just to make sure we can write it out in case the host wide int
2346 is narrower than the target "long".
2348 For unsigned types, we use octal if they are the same size or larger.
2349 This is because we print the bounds as signed decimal, and hence they
2350 can't span same size unsigned types. */
2352 if (use_gnu_debug_info_extensions
2353 && low
&& TREE_CODE (low
) == INTEGER_CST
2354 && high
&& TREE_CODE (high
) == INTEGER_CST
2355 && (TYPE_PRECISION (type
) > TYPE_PRECISION (integer_type_node
)
2356 || ((TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
))
2357 && TYPE_UNSIGNED (type
))
2358 || TYPE_PRECISION (type
) > HOST_BITS_PER_WIDE_INT
2359 || (TYPE_PRECISION (type
) == HOST_BITS_PER_WIDE_INT
2360 && TYPE_UNSIGNED (type
))))
2366 /* Output the name of type TYPE, with no punctuation.
2367 Such names can be set up either by typedef declarations
2368 or by struct, enum and union tags. */
2371 dbxout_type_name (tree type
)
2373 tree t
= TYPE_NAME (type
);
2376 switch (TREE_CODE (t
))
2378 case IDENTIFIER_NODE
:
2390 /* Output leading struct or class names needed for qualifying type
2391 whose scope is limited to a struct or class. */
2394 dbxout_class_name_qualifiers (tree decl
)
2396 tree context
= decl_type_context (decl
);
2398 if (context
!= NULL_TREE
2399 && TREE_CODE (context
) == RECORD_TYPE
2400 && TYPE_NAME (context
) != 0
2401 && (TREE_CODE (TYPE_NAME (context
)) == IDENTIFIER_NODE
2402 || (DECL_NAME (TYPE_NAME (context
)) != 0)))
2404 tree name
= TYPE_NAME (context
);
2406 if (TREE_CODE (name
) == TYPE_DECL
)
2408 dbxout_class_name_qualifiers (name
);
2409 name
= DECL_NAME (name
);
2416 /* This is a specialized subset of expand_expr for use by dbxout_symbol in
2417 evaluating DECL_VALUE_EXPR. In particular, we stop if we find decls that
2418 haven't been expanded, or if the expression is getting so complex we won't
2419 be able to represent it in stabs anyway. Returns NULL on failure. */
2422 dbxout_expand_expr (tree expr
)
2424 switch (TREE_CODE (expr
))
2427 /* We can't handle emulated tls variables, because the address is an
2428 offset to the return value of __emutls_get_address, and there is no
2429 way to express that in stabs. Also, there are name mangling issues
2430 here. We end up with references to undefined symbols if we don't
2431 disable debug info for these variables. */
2432 if (!targetm
.have_tls
&& DECL_THREAD_LOCAL_P (expr
))
2434 if (TREE_STATIC (expr
)
2435 && !TREE_ASM_WRITTEN (expr
)
2436 && !DECL_HAS_VALUE_EXPR_P (expr
)
2437 && !TREE_PUBLIC (expr
)
2438 && DECL_RTL_SET_P (expr
)
2439 && MEM_P (DECL_RTL (expr
)))
2441 /* If this is a var that might not be actually output,
2442 return NULL, otherwise stabs might reference an undefined
2444 varpool_node
*node
= varpool_node::get (expr
);
2445 if (!node
|| !node
->definition
)
2452 if (DECL_HAS_VALUE_EXPR_P (expr
))
2453 return dbxout_expand_expr (DECL_VALUE_EXPR (expr
));
2457 return DECL_RTL_IF_SET (expr
);
2460 return expand_expr (expr
, NULL_RTX
, VOIDmode
, EXPAND_INITIALIZER
);
2464 case ARRAY_RANGE_REF
:
2468 HOST_WIDE_INT bitsize
, bitpos
;
2470 int unsignedp
, reversep
, volatilep
= 0;
2473 tem
= get_inner_reference (expr
, &bitsize
, &bitpos
, &offset
, &mode
,
2474 &unsignedp
, &reversep
, &volatilep
);
2476 x
= dbxout_expand_expr (tem
);
2477 if (x
== NULL
|| !MEM_P (x
))
2481 if (!tree_fits_shwi_p (offset
))
2483 x
= adjust_address_nv (x
, mode
, tree_to_shwi (offset
));
2486 x
= adjust_address_nv (x
, mode
, bitpos
/ BITS_PER_UNIT
);
2496 /* Helper function for output_used_types. Queue one entry from the
2497 used types hash to be output. */
2500 output_used_types_helper (tree
const &type
, vec
<tree
> *types_p
)
2502 if ((TREE_CODE (type
) == RECORD_TYPE
2503 || TREE_CODE (type
) == UNION_TYPE
2504 || TREE_CODE (type
) == QUAL_UNION_TYPE
2505 || TREE_CODE (type
) == ENUMERAL_TYPE
)
2506 && TYPE_STUB_DECL (type
)
2507 && DECL_P (TYPE_STUB_DECL (type
))
2508 && ! DECL_IGNORED_P (TYPE_STUB_DECL (type
)))
2509 types_p
->quick_push (TYPE_STUB_DECL (type
));
2510 else if (TYPE_NAME (type
)
2511 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
2512 types_p
->quick_push (TYPE_NAME (type
));
2517 /* This is a qsort callback which sorts types and declarations into a
2518 predictable order (types, then declarations, sorted by UID
2522 output_types_sort (const void *pa
, const void *pb
)
2524 const tree lhs
= *((const tree
*)pa
);
2525 const tree rhs
= *((const tree
*)pb
);
2530 return TYPE_UID (lhs
) - TYPE_UID (rhs
);
2539 return DECL_UID (lhs
) - DECL_UID (rhs
);
2544 /* Force all types used by this function to be output in debug
2548 output_used_types (void)
2550 if (cfun
&& cfun
->used_types_hash
)
2556 types
.create (cfun
->used_types_hash
->elements ());
2557 cfun
->used_types_hash
->traverse
<vec
<tree
> *, output_used_types_helper
>
2560 /* Sort by UID to prevent dependence on hash table ordering. */
2561 types
.qsort (output_types_sort
);
2563 FOR_EACH_VEC_ELT (types
, i
, type
)
2564 debug_queue_symbol (type
);
2570 /* Output a .stabs for the symbol defined by DECL,
2571 which must be a ..._DECL node in the normal namespace.
2572 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
2573 LOCAL is nonzero if the scope is less than the entire file.
2574 Return 1 if a stabs might have been emitted. */
2577 dbxout_symbol (tree decl
, int local ATTRIBUTE_UNUSED
)
2579 tree type
= TREE_TYPE (decl
);
2580 tree context
= NULL_TREE
;
2584 /* "Intercept" dbxout_symbol() calls like we do all debug_hooks. */
2587 /* Ignore nameless syms, but don't ignore type tags. */
2589 if ((DECL_NAME (decl
) == 0 && TREE_CODE (decl
) != TYPE_DECL
)
2590 || DECL_IGNORED_P (decl
))
2591 DBXOUT_DECR_NESTING_AND_RETURN (0);
2593 /* If we are to generate only the symbols actually used then such
2594 symbol nodes are flagged with TREE_USED. Ignore any that
2595 aren't flagged as TREE_USED. */
2597 if (flag_debug_only_used_symbols
2598 && (!TREE_USED (decl
)
2599 && (!VAR_P (decl
) || !DECL_INITIAL (decl
))))
2600 DBXOUT_DECR_NESTING_AND_RETURN (0);
2602 /* If dbxout_init has not yet run, queue this symbol for later. */
2605 preinit_symbols
= tree_cons (0, decl
, preinit_symbols
);
2606 DBXOUT_DECR_NESTING_AND_RETURN (0);
2609 if (flag_debug_only_used_symbols
)
2613 /* We now have a used symbol. We need to generate the info for
2614 the symbol's type in addition to the symbol itself. These
2615 type symbols are queued to be generated after were done with
2616 the symbol itself (otherwise they would fight over the
2619 Note, because the TREE_TYPE(type) might be something like a
2620 pointer to a named type we need to look for the first name
2621 we see following the TREE_TYPE chain. */
2624 while (POINTER_TYPE_P (t
))
2627 /* RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, and ENUMERAL_TYPE
2628 need special treatment. The TYPE_STUB_DECL field in these
2629 types generally represents the tag name type we want to
2630 output. In addition there could be a typedef type with
2631 a different name. In that case we also want to output
2634 if (TREE_CODE (t
) == RECORD_TYPE
2635 || TREE_CODE (t
) == UNION_TYPE
2636 || TREE_CODE (t
) == QUAL_UNION_TYPE
2637 || TREE_CODE (t
) == ENUMERAL_TYPE
)
2639 if (TYPE_STUB_DECL (t
)
2640 && TYPE_STUB_DECL (t
) != decl
2641 && DECL_P (TYPE_STUB_DECL (t
))
2642 && ! DECL_IGNORED_P (TYPE_STUB_DECL (t
)))
2644 debug_queue_symbol (TYPE_STUB_DECL (t
));
2646 && TYPE_NAME (t
) != TYPE_STUB_DECL (t
)
2647 && TYPE_NAME (t
) != decl
2648 && DECL_P (TYPE_NAME (t
)))
2649 debug_queue_symbol (TYPE_NAME (t
));
2652 else if (TYPE_NAME (t
)
2653 && TYPE_NAME (t
) != decl
2654 && DECL_P (TYPE_NAME (t
)))
2655 debug_queue_symbol (TYPE_NAME (t
));
2658 emit_pending_bincls_if_required ();
2660 switch (TREE_CODE (decl
))
2663 /* Enum values are defined by defining the enum type. */
2667 decl_rtl
= DECL_RTL_IF_SET (decl
);
2669 DBXOUT_DECR_NESTING_AND_RETURN (0);
2670 if (DECL_EXTERNAL (decl
))
2672 /* Don't mention a nested function under its parent. */
2673 context
= decl_function_context (decl
);
2674 if (context
== current_function_decl
)
2676 /* Don't mention an inline instance of a nested function. */
2677 if (context
&& DECL_FROM_INLINE (decl
))
2679 if (!MEM_P (decl_rtl
)
2680 || GET_CODE (XEXP (decl_rtl
, 0)) != SYMBOL_REF
)
2683 if (flag_debug_only_used_symbols
)
2684 output_used_types ();
2686 dbxout_begin_complex_stabs ();
2687 stabstr_I (DECL_ASSEMBLER_NAME (decl
));
2688 stabstr_S (TREE_PUBLIC (decl
) ? ":F" : ":f");
2691 if (TREE_TYPE (type
))
2692 dbxout_type (TREE_TYPE (type
), 0);
2694 dbxout_type (void_type_node
, 0);
2696 /* For a nested function, when that function is compiled,
2697 mention the containing function name
2698 as well as (since dbx wants it) our own assembler-name. */
2702 stabstr_I (DECL_ASSEMBLER_NAME (decl
));
2704 stabstr_I (DECL_NAME (context
));
2707 dbxout_finish_complex_stabs (decl
, N_FUN
, XEXP (decl_rtl
, 0), 0, 0);
2711 /* Don't output the same typedef twice.
2712 And don't output what language-specific stuff doesn't want output. */
2713 if (TREE_ASM_WRITTEN (decl
) || TYPE_DECL_SUPPRESS_DEBUG (decl
))
2714 DBXOUT_DECR_NESTING_AND_RETURN (0);
2716 /* Don't output typedefs for types with magic type numbers (XCOFF). */
2717 #ifdef DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER
2719 int fundamental_type_number
=
2720 DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER (decl
);
2722 if (fundamental_type_number
!= 0)
2724 TREE_ASM_WRITTEN (decl
) = 1;
2725 TYPE_SYMTAB_ADDRESS (TREE_TYPE (decl
)) = fundamental_type_number
;
2726 DBXOUT_DECR_NESTING_AND_RETURN (0);
2736 if (DECL_NAME (decl
))
2738 /* Nonzero means we must output a tag as well as a typedef. */
2741 /* Handle the case of a C++ structure or union
2742 where the TYPE_NAME is a TYPE_DECL
2743 which gives both a typedef name and a tag. */
2744 /* dbx requires the tag first and the typedef second. */
2745 if ((TREE_CODE (type
) == RECORD_TYPE
2746 || TREE_CODE (type
) == UNION_TYPE
2747 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
2748 && TYPE_NAME (type
) == decl
2749 && !use_gnu_debug_info_extensions
2750 && !TREE_ASM_WRITTEN (TYPE_NAME (type
))
2751 /* Distinguish the implicit typedefs of C++
2752 from explicit ones that might be found in C. */
2753 && DECL_ARTIFICIAL (decl
)
2754 /* Do not generate a tag for incomplete records. */
2755 && COMPLETE_TYPE_P (type
)
2756 /* Do not generate a tag for records of variable size,
2757 since this type can not be properly described in the
2758 DBX format, and it confuses some tools such as objdump. */
2759 && tree_fits_uhwi_p (TYPE_SIZE (type
)))
2761 tree name
= TYPE_IDENTIFIER (type
);
2763 dbxout_begin_complex_stabs ();
2766 dbxout_type (type
, 1);
2767 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE
,
2771 dbxout_begin_complex_stabs ();
2773 /* Output leading class/struct qualifiers. */
2774 if (use_gnu_debug_info_extensions
)
2775 dbxout_class_name_qualifiers (decl
);
2777 /* Output typedef name. */
2778 stabstr_I (DECL_NAME (decl
));
2781 /* Short cut way to output a tag also. */
2782 if ((TREE_CODE (type
) == RECORD_TYPE
2783 || TREE_CODE (type
) == UNION_TYPE
2784 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
2785 && TYPE_NAME (type
) == decl
2786 /* Distinguish the implicit typedefs of C++
2787 from explicit ones that might be found in C. */
2788 && DECL_ARTIFICIAL (decl
))
2790 if (use_gnu_debug_info_extensions
)
2793 TREE_ASM_WRITTEN (TYPE_NAME (type
)) = 1;
2798 dbxout_type (type
, 1);
2799 dbxout_finish_complex_stabs (decl
, DBX_TYPE_DECL_STABS_CODE
,
2804 /* Don't output a tag if this is an incomplete type. This prevents
2805 the sun4 Sun OS 4.x dbx from crashing. */
2807 if (tag_needed
&& TYPE_NAME (type
) != 0
2808 && (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
2809 || (DECL_NAME (TYPE_NAME (type
)) != 0))
2810 && COMPLETE_TYPE_P (type
)
2811 && !TREE_ASM_WRITTEN (TYPE_NAME (type
)))
2813 /* For a TYPE_DECL with no name, but the type has a name,
2815 This is what represents `struct foo' with no typedef. */
2816 /* In C++, the name of a type is the corresponding typedef.
2817 In C, it is an IDENTIFIER_NODE. */
2818 tree name
= TYPE_IDENTIFIER (type
);
2820 dbxout_begin_complex_stabs ();
2823 dbxout_type (type
, 1);
2824 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE
, 0, 0, 0);
2828 /* If an enum type has no name, it cannot be referred to, but
2829 we must output it anyway, to record the enumeration
2832 if (!did_output
&& TREE_CODE (type
) == ENUMERAL_TYPE
)
2834 dbxout_begin_complex_stabs ();
2835 /* Some debuggers fail when given NULL names, so give this a
2836 harmless name of " " (Why not "(anon)"?). */
2838 dbxout_type (type
, 1);
2839 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE
, 0, 0, 0);
2842 /* Prevent duplicate output of a typedef. */
2843 TREE_ASM_WRITTEN (decl
) = 1;
2848 if (DECL_HAS_VALUE_EXPR_P (decl
))
2849 decl
= DECL_VALUE_EXPR (decl
);
2851 /* PARM_DECLs go in their own separate chain and are output by
2852 dbxout_reg_parms and dbxout_parms, except for those that are
2853 disguised VAR_DECLs like Out parameters in Ada. */
2854 gcc_assert (VAR_P (decl
));
2860 /* Don't mention a variable that is external.
2861 Let the file that defines it describe it. */
2862 if (DECL_EXTERNAL (decl
))
2865 /* If the variable is really a constant
2866 and not written in memory, inform the debugger.
2868 ??? Why do we skip emitting the type and location in this case? */
2869 if (TREE_STATIC (decl
) && TREE_READONLY (decl
)
2870 && DECL_INITIAL (decl
) != 0
2871 && tree_fits_shwi_p (DECL_INITIAL (decl
))
2872 && ! TREE_ASM_WRITTEN (decl
)
2873 && (DECL_FILE_SCOPE_P (decl
)
2874 || TREE_CODE (DECL_CONTEXT (decl
)) == BLOCK
2875 || TREE_CODE (DECL_CONTEXT (decl
)) == NAMESPACE_DECL
)
2876 && TREE_PUBLIC (decl
) == 0)
2878 /* The sun4 assembler does not grok this. */
2880 if (TREE_CODE (TREE_TYPE (decl
)) == INTEGER_TYPE
2881 || TREE_CODE (TREE_TYPE (decl
)) == ENUMERAL_TYPE
)
2883 HOST_WIDE_INT ival
= tree_to_shwi (DECL_INITIAL (decl
));
2885 dbxout_begin_complex_stabs ();
2886 dbxout_symbol_name (decl
, NULL
, 'c');
2889 dbxout_finish_complex_stabs (0, N_LSYM
, 0, 0, 0);
2890 DBXOUT_DECR_NESTING
;
2896 /* else it is something we handle like a normal variable. */
2898 decl_rtl
= dbxout_expand_expr (decl
);
2900 DBXOUT_DECR_NESTING_AND_RETURN (0);
2902 if (!is_global_var (decl
))
2903 decl_rtl
= eliminate_regs (decl_rtl
, VOIDmode
, NULL_RTX
);
2904 #ifdef LEAF_REG_REMAP
2905 if (crtl
->uses_only_leaf_regs
)
2906 leaf_renumber_regs_insn (decl_rtl
);
2909 result
= dbxout_symbol_location (decl
, type
, 0, decl_rtl
);
2915 DBXOUT_DECR_NESTING
;
2919 /* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL.
2920 Add SUFFIX to its name, if SUFFIX is not 0.
2921 Describe the variable as residing in HOME
2922 (usually HOME is DECL_RTL (DECL), but not always).
2923 Returns 1 if the stab was really emitted. */
2926 dbxout_symbol_location (tree decl
, tree type
, const char *suffix
, rtx home
)
2929 stab_code_type code
;
2934 /* Don't mention a variable at all
2935 if it was completely optimized into nothingness.
2937 If the decl was from an inline function, then its rtl
2938 is not identically the rtl that was used in this
2939 particular compilation. */
2940 if (GET_CODE (home
) == SUBREG
)
2944 while (GET_CODE (value
) == SUBREG
)
2945 value
= SUBREG_REG (value
);
2948 if (REGNO (value
) >= FIRST_PSEUDO_REGISTER
)
2951 home
= alter_subreg (&home
, true);
2955 regno
= REGNO (home
);
2956 if (regno
>= FIRST_PSEUDO_REGISTER
)
2960 /* The kind-of-variable letter depends on where
2961 the variable is and on the scope of its name:
2962 G and N_GSYM for static storage and global scope,
2963 S for static storage and file scope,
2964 V for static storage and local scope,
2965 for those two, use N_LCSYM if data is in bss segment,
2966 N_STSYM if in data segment, N_FUN otherwise.
2967 (We used N_FUN originally, then changed to N_STSYM
2968 to please GDB. However, it seems that confused ld.
2969 Now GDB has been fixed to like N_FUN, says Kingdon.)
2970 no letter at all, and N_LSYM, for auto variable,
2971 r and N_RSYM for register variable. */
2973 if (MEM_P (home
) && GET_CODE (XEXP (home
, 0)) == SYMBOL_REF
)
2975 if (TREE_PUBLIC (decl
))
2980 if (NULL
!= dbxout_common_check (decl
, &offs
))
2989 addr
= XEXP (home
, 0);
2991 letter
= decl_function_context (decl
) ? 'V' : 'S';
2993 /* Some ports can transform a symbol ref into a label ref,
2994 because the symbol ref is too far away and has to be
2995 dumped into a constant pool. Alternatively, the symbol
2996 in the constant pool might be referenced by a different
2998 if (GET_CODE (addr
) == SYMBOL_REF
2999 && CONSTANT_POOL_ADDRESS_P (addr
))
3002 rtx tmp
= get_pool_constant_mark (addr
, &marked
);
3004 if (GET_CODE (tmp
) == SYMBOL_REF
)
3007 if (CONSTANT_POOL_ADDRESS_P (addr
))
3008 get_pool_constant_mark (addr
, &marked
);
3012 else if (GET_CODE (tmp
) == LABEL_REF
)
3018 /* If all references to the constant pool were optimized
3019 out, we just ignore the symbol. */
3024 /* This should be the same condition as in assemble_variable, but
3025 we don't have access to dont_output_data here. So, instead,
3026 we rely on the fact that error_mark_node initializers always
3027 end up in bss for C++ and never end up in bss for C. */
3028 if (DECL_INITIAL (decl
) == 0
3030 && DECL_INITIAL (decl
) == error_mark_node
))
3034 if (NULL
!= dbxout_common_check (decl
, &offs
))
3042 else if (DECL_IN_TEXT_SECTION (decl
))
3043 /* This is not quite right, but it's the closest
3044 of all the codes that Unix defines. */
3045 code
= DBX_STATIC_CONST_VAR_CODE
;
3048 /* Ultrix `as' seems to need this. */
3049 #ifdef DBX_STATIC_STAB_DATA_SECTION
3050 switch_to_section (data_section
);
3056 else if (regno
>= 0)
3060 number
= DBX_REGISTER_NUMBER (regno
);
3062 else if (MEM_P (home
)
3063 && (MEM_P (XEXP (home
, 0))
3064 || (REG_P (XEXP (home
, 0))
3065 && REGNO (XEXP (home
, 0)) != HARD_FRAME_POINTER_REGNUM
3066 && REGNO (XEXP (home
, 0)) != STACK_POINTER_REGNUM
3067 #if !HARD_FRAME_POINTER_IS_ARG_POINTER
3068 && REGNO (XEXP (home
, 0)) != ARG_POINTER_REGNUM
3071 /* If the value is indirect by memory or by a register
3072 that isn't the frame pointer
3073 then it means the object is variable-sized and address through
3074 that register or stack slot. DBX has no way to represent this
3075 so all we can do is output the variable as a pointer.
3076 If it's not a parameter, ignore it. */
3078 if (REG_P (XEXP (home
, 0)))
3082 if (REGNO (XEXP (home
, 0)) >= FIRST_PSEUDO_REGISTER
)
3084 number
= DBX_REGISTER_NUMBER (REGNO (XEXP (home
, 0)));
3089 /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
3090 We want the value of that CONST_INT. */
3091 number
= DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home
, 0), 0));
3094 /* Effectively do build_pointer_type, but don't cache this type,
3095 since it might be temporary whereas the type it points to
3096 might have been saved for inlining. */
3097 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
3098 type
= make_node (POINTER_TYPE
);
3099 TREE_TYPE (type
) = TREE_TYPE (decl
);
3101 else if (MEM_P (home
)
3102 && REG_P (XEXP (home
, 0)))
3105 number
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
3107 else if (MEM_P (home
)
3108 && GET_CODE (XEXP (home
, 0)) == PLUS
3109 && CONST_INT_P (XEXP (XEXP (home
, 0), 1)))
3112 /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
3113 We want the value of that CONST_INT. */
3114 number
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
3116 else if (MEM_P (home
)
3117 && GET_CODE (XEXP (home
, 0)) == CONST
)
3119 /* Handle an obscure case which can arise when optimizing and
3120 when there are few available registers. (This is *always*
3121 the case for i386/i486 targets). The RTL looks like
3122 (MEM (CONST ...)) even though this variable is a local `auto'
3123 or a local `register' variable. In effect, what has happened
3124 is that the reload pass has seen that all assignments and
3125 references for one such a local variable can be replaced by
3126 equivalent assignments and references to some static storage
3127 variable, thereby avoiding the need for a register. In such
3128 cases we're forced to lie to debuggers and tell them that
3129 this variable was itself `static'. */
3133 if (NULL
== dbxout_common_check (decl
, &offs
))
3134 addr
= XEXP (XEXP (home
, 0), 0);
3142 else if (GET_CODE (home
) == CONCAT
)
3146 /* If TYPE is not a COMPLEX_TYPE (it might be a RECORD_TYPE,
3147 for example), then there is no easy way to figure out
3148 what SUBTYPE should be. So, we give up. */
3149 if (TREE_CODE (type
) != COMPLEX_TYPE
)
3152 subtype
= TREE_TYPE (type
);
3154 /* If the variable's storage is in two parts,
3155 output each as a separate stab with a modified name. */
3156 if (WORDS_BIG_ENDIAN
)
3157 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 0));
3159 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 0));
3161 if (WORDS_BIG_ENDIAN
)
3162 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 1));
3164 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 1));
3168 /* Address might be a MEM, when DECL is a variable-sized object.
3169 Or it might be const0_rtx, meaning previous passes
3170 want us to ignore this variable. */
3173 /* Ok, start a symtab entry and output the variable name. */
3174 emit_pending_bincls_if_required ();
3177 #ifdef DBX_STATIC_BLOCK_START
3178 DBX_STATIC_BLOCK_START (asm_out_file
, code
);
3181 dbxout_begin_complex_stabs_noforcetext ();
3182 dbxout_symbol_name (decl
, suffix
, letter
);
3183 dbxout_type (type
, 0);
3184 dbxout_finish_complex_stabs (decl
, code
, addr
, 0, number
);
3186 #ifdef DBX_STATIC_BLOCK_END
3187 DBX_STATIC_BLOCK_END (asm_out_file
, code
);
3192 /* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
3193 Then output LETTER to indicate the kind of location the symbol has. */
3196 dbxout_symbol_name (tree decl
, const char *suffix
, int letter
)
3200 if (DECL_CONTEXT (decl
)
3201 && (TYPE_P (DECL_CONTEXT (decl
))
3202 || TREE_CODE (DECL_CONTEXT (decl
)) == NAMESPACE_DECL
))
3203 /* One slight hitch: if this is a VAR_DECL which is a class member
3204 or a namespace member, we must put out the mangled name instead of the
3205 DECL_NAME. Note also that static member (variable) names DO NOT begin
3206 with underscores in .stabs directives. */
3207 name
= DECL_ASSEMBLER_NAME (decl
);
3209 /* ...but if we're function-local, we don't want to include the junk
3210 added by ASM_FORMAT_PRIVATE_NAME. */
3211 name
= DECL_NAME (decl
);
3216 stabstr_S ("(anon)");
3226 /* Output the common block name for DECL in a stabs.
3228 Symbols in global common (.comm) get wrapped with an N_BCOMM/N_ECOMM pair
3229 around each group of symbols in the same .comm area. The N_GSYM stabs
3230 that are emitted only contain the offset in the common area. This routine
3231 emits the N_BCOMM and N_ECOMM stabs. */
3234 dbxout_common_name (tree decl
, const char *name
, stab_code_type op
)
3236 dbxout_begin_complex_stabs ();
3238 dbxout_finish_complex_stabs (decl
, op
, NULL_RTX
, NULL
, 0);
3241 /* Check decl to determine whether it is a VAR_DECL destined for storage in a
3242 common area. If it is, the return value will be a non-null string giving
3243 the name of the common storage block it will go into. If non-null, the
3244 value is the offset into the common block for that symbol's storage. */
3247 dbxout_common_check (tree decl
, int *value
)
3251 const char *name
= NULL
;
3253 /* If the decl isn't a VAR_DECL, or if it isn't static, or if
3254 it does not have a value (the offset into the common area), or if it
3255 is thread local (as opposed to global) then it isn't common, and shouldn't
3258 ??? DECL_THREAD_LOCAL_P check prevents problems with improper .stabs
3259 for thread-local symbols. Can be handled via same mechanism as used
3262 || !TREE_STATIC (decl
)
3263 || !DECL_HAS_VALUE_EXPR_P (decl
)
3264 || DECL_THREAD_LOCAL_P (decl
)
3268 home
= DECL_RTL (decl
);
3269 if (home
== NULL_RTX
|| GET_CODE (home
) != MEM
)
3272 sym_addr
= dbxout_expand_expr (DECL_VALUE_EXPR (decl
));
3273 if (sym_addr
== NULL_RTX
|| GET_CODE (sym_addr
) != MEM
)
3276 sym_addr
= XEXP (sym_addr
, 0);
3277 if (GET_CODE (sym_addr
) == CONST
)
3278 sym_addr
= XEXP (sym_addr
, 0);
3279 if ((GET_CODE (sym_addr
) == SYMBOL_REF
|| GET_CODE (sym_addr
) == PLUS
)
3280 && DECL_INITIAL (decl
) == 0)
3283 /* We have a sym that will go into a common area, meaning that it
3284 will get storage reserved with a .comm/.lcomm assembler pseudo-op.
3286 Determine name of common area this symbol will be an offset into,
3287 and offset into that area. Also retrieve the decl for the area
3288 that the symbol is offset into. */
3291 switch (GET_CODE (sym_addr
))
3294 if (CONST_INT_P (XEXP (sym_addr
, 0)))
3297 targetm
.strip_name_encoding (XSTR (XEXP (sym_addr
, 1), 0));
3298 *value
= INTVAL (XEXP (sym_addr
, 0));
3299 cdecl = SYMBOL_REF_DECL (XEXP (sym_addr
, 1));
3304 targetm
.strip_name_encoding (XSTR (XEXP (sym_addr
, 0), 0));
3305 *value
= INTVAL (XEXP (sym_addr
, 1));
3306 cdecl = SYMBOL_REF_DECL (XEXP (sym_addr
, 0));
3311 name
= targetm
.strip_name_encoding (XSTR (sym_addr
, 0));
3313 cdecl = SYMBOL_REF_DECL (sym_addr
);
3317 error ("common symbol debug info is not structured as "
3321 /* Check area common symbol is offset into. If this is not public, then
3322 it is not a symbol in a common block. It must be a .lcomm symbol, not
3324 if (cdecl == NULL
|| !TREE_PUBLIC (cdecl))
3333 /* Output definitions of all the decls in a chain. Return nonzero if
3334 anything was output */
3337 dbxout_syms (tree syms
)
3340 const char *comm_prev
= NULL
;
3341 tree syms_prev
= NULL
;
3345 int temp
, copen
, cclos
;
3346 const char *comm_new
;
3348 /* Check for common symbol, and then progression into a new/different
3349 block of common symbols. Emit closing/opening common bracket if
3351 comm_new
= dbxout_common_check (syms
, &temp
);
3352 copen
= comm_new
!= NULL
3353 && (comm_prev
== NULL
|| strcmp (comm_new
, comm_prev
));
3354 cclos
= comm_prev
!= NULL
3355 && (comm_new
== NULL
|| strcmp (comm_new
, comm_prev
));
3357 dbxout_common_name (syms_prev
, comm_prev
, N_ECOMM
);
3360 dbxout_common_name (syms
, comm_new
, N_BCOMM
);
3363 comm_prev
= comm_new
;
3365 result
+= dbxout_symbol (syms
, 1);
3366 syms
= DECL_CHAIN (syms
);
3369 if (comm_prev
!= NULL
)
3370 dbxout_common_name (syms_prev
, comm_prev
, N_ECOMM
);
3375 /* The following two functions output definitions of function parameters.
3376 Each parameter gets a definition locating it in the parameter list.
3377 Each parameter that is a register variable gets a second definition
3378 locating it in the register.
3380 Printing or argument lists in gdb uses the definitions that
3381 locate in the parameter list. But reference to the variable in
3382 expressions uses preferentially the definition as a register. */
3384 /* Output definitions, referring to storage in the parmlist,
3385 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
3388 dbxout_parms (tree parms
)
3391 emit_pending_bincls_if_required ();
3393 for (; parms
; parms
= DECL_CHAIN (parms
))
3394 if (DECL_NAME (parms
)
3395 && TREE_TYPE (parms
) != error_mark_node
3396 && DECL_RTL_SET_P (parms
)
3397 && DECL_INCOMING_RTL (parms
))
3401 stab_code_type code
;
3404 /* Perform any necessary register eliminations on the parameter's rtl,
3405 so that the debugging output will be accurate. */
3406 DECL_INCOMING_RTL (parms
)
3407 = eliminate_regs (DECL_INCOMING_RTL (parms
), VOIDmode
, NULL_RTX
);
3408 SET_DECL_RTL (parms
,
3409 eliminate_regs (DECL_RTL (parms
), VOIDmode
, NULL_RTX
));
3410 #ifdef LEAF_REG_REMAP
3411 if (crtl
->uses_only_leaf_regs
)
3413 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms
));
3414 leaf_renumber_regs_insn (DECL_RTL (parms
));
3418 if (PARM_PASSED_IN_MEMORY (parms
))
3420 rtx inrtl
= XEXP (DECL_INCOMING_RTL (parms
), 0);
3422 /* ??? Here we assume that the parm address is indexed
3423 off the frame pointer or arg pointer.
3424 If that is not true, we produce meaningless results,
3425 but do not crash. */
3426 if (GET_CODE (inrtl
) == PLUS
3427 && CONST_INT_P (XEXP (inrtl
, 1)))
3428 number
= INTVAL (XEXP (inrtl
, 1));
3433 number
= DEBUGGER_ARG_OFFSET (number
, inrtl
);
3436 /* It is quite tempting to use TREE_TYPE (parms) instead
3437 of DECL_ARG_TYPE (parms) for the eff_type, so that gcc
3438 reports the actual type of the parameter, rather than
3439 the promoted type. This certainly makes GDB's life
3440 easier, at least for some ports. The change is a bad
3441 idea however, since GDB expects to be able access the
3442 type without performing any conversions. So for
3443 example, if we were passing a float to an unprototyped
3444 function, gcc will store a double on the stack, but if
3445 we emit a stab saying the type is a float, then gdb
3446 will only read in a single value, and this will produce
3447 an erroneous value. */
3448 eff_type
= DECL_ARG_TYPE (parms
);
3450 else if (REG_P (DECL_RTL (parms
)))
3454 /* Parm passed in registers and lives in registers or nowhere. */
3455 code
= DBX_REGPARM_STABS_CODE
;
3456 letter
= DBX_REGPARM_STABS_LETTER
;
3458 /* For parms passed in registers, it is better to use the
3459 declared type of the variable, not the type it arrived in. */
3460 eff_type
= TREE_TYPE (parms
);
3462 /* If parm lives in a register, use that register; pretend
3463 the parm was passed there. It would be more consistent
3464 to describe the register where the parm was passed, but
3465 in practice that register usually holds something else.
3466 If the parm lives nowhere, use the register where it
3468 if (REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
3469 best_rtl
= DECL_RTL (parms
);
3470 else if (GET_CODE (DECL_INCOMING_RTL (parms
)) == PARALLEL
)
3471 best_rtl
= XEXP (XVECEXP (DECL_INCOMING_RTL (parms
), 0, 0), 0);
3473 best_rtl
= DECL_INCOMING_RTL (parms
);
3475 number
= DBX_REGISTER_NUMBER (REGNO (best_rtl
));
3477 else if (MEM_P (DECL_RTL (parms
))
3478 && REG_P (XEXP (DECL_RTL (parms
), 0))
3479 && REGNO (XEXP (DECL_RTL (parms
), 0)) != HARD_FRAME_POINTER_REGNUM
3480 && REGNO (XEXP (DECL_RTL (parms
), 0)) != STACK_POINTER_REGNUM
3481 #if !HARD_FRAME_POINTER_IS_ARG_POINTER
3482 && REGNO (XEXP (DECL_RTL (parms
), 0)) != ARG_POINTER_REGNUM
3486 /* Parm was passed via invisible reference.
3487 That is, its address was passed in a register.
3488 Output it as if it lived in that register.
3489 The debugger will know from the type
3490 that it was actually passed by invisible reference. */
3492 code
= DBX_REGPARM_STABS_CODE
;
3494 /* GDB likes this marked with a special letter. */
3495 letter
= (use_gnu_debug_info_extensions
3496 ? 'a' : DBX_REGPARM_STABS_LETTER
);
3497 eff_type
= TREE_TYPE (parms
);
3499 /* DECL_RTL looks like (MEM (REG...). Get the register number.
3500 If it is an unallocated pseudo-reg, then use the register where
3501 it was passed instead.
3502 ??? Why is DBX_REGISTER_NUMBER not used here? */
3504 if (REGNO (XEXP (DECL_RTL (parms
), 0)) < FIRST_PSEUDO_REGISTER
)
3505 number
= REGNO (XEXP (DECL_RTL (parms
), 0));
3507 number
= REGNO (DECL_INCOMING_RTL (parms
));
3509 else if (MEM_P (DECL_RTL (parms
))
3510 && MEM_P (XEXP (DECL_RTL (parms
), 0)))
3512 /* Parm was passed via invisible reference, with the reference
3513 living on the stack. DECL_RTL looks like
3514 (MEM (MEM (PLUS (REG ...) (CONST_INT ...)))) or it
3515 could look like (MEM (MEM (REG))). */
3519 eff_type
= TREE_TYPE (parms
);
3521 if (!REG_P (XEXP (XEXP (DECL_RTL (parms
), 0), 0)))
3522 number
= INTVAL (XEXP (XEXP (XEXP (DECL_RTL (parms
), 0), 0), 1));
3526 number
= DEBUGGER_ARG_OFFSET (number
,
3527 XEXP (XEXP (DECL_RTL (parms
), 0), 0));
3529 else if (MEM_P (DECL_RTL (parms
))
3530 && XEXP (DECL_RTL (parms
), 0) != const0_rtx
3531 /* ??? A constant address for a parm can happen
3532 when the reg it lives in is equiv to a constant in memory.
3533 Should make this not happen, after 2.4. */
3534 && ! CONSTANT_P (XEXP (DECL_RTL (parms
), 0)))
3536 /* Parm was passed in registers but lives on the stack. */
3540 eff_type
= TREE_TYPE (parms
);
3542 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
3543 in which case we want the value of that CONST_INT,
3545 in which case we use a value of zero. */
3546 if (!REG_P (XEXP (DECL_RTL (parms
), 0)))
3547 number
= INTVAL (XEXP (XEXP (DECL_RTL (parms
), 0), 1));
3551 /* Make a big endian correction if the mode of the type of the
3552 parameter is not the same as the mode of the rtl. */
3553 if (BYTES_BIG_ENDIAN
3554 && TYPE_MODE (TREE_TYPE (parms
)) != GET_MODE (DECL_RTL (parms
))
3555 && GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms
))) < UNITS_PER_WORD
)
3556 number
+= (GET_MODE_SIZE (GET_MODE (DECL_RTL (parms
)))
3557 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms
))));
3560 /* ??? We don't know how to represent this argument. */
3563 dbxout_begin_complex_stabs ();
3565 if (DECL_NAME (parms
))
3567 stabstr_I (DECL_NAME (parms
));
3571 stabstr_S ("(anon):");
3573 dbxout_type (eff_type
, 0);
3574 dbxout_finish_complex_stabs (parms
, code
, 0, 0, number
);
3576 DBXOUT_DECR_NESTING
;
3579 /* Output definitions for the places where parms live during the function,
3580 when different from where they were passed, when the parms were passed
3583 It is not useful to do this for parms passed in registers
3584 that live during the function in different registers, because it is
3585 impossible to look in the passed register for the passed value,
3586 so we use the within-the-function register to begin with.
3588 PARMS is a chain of PARM_DECL nodes. */
3591 dbxout_reg_parms (tree parms
)
3595 for (; parms
; parms
= DECL_CHAIN (parms
))
3596 if (DECL_NAME (parms
) && PARM_PASSED_IN_MEMORY (parms
))
3598 /* Report parms that live in registers during the function
3599 but were passed in memory. */
3600 if (REG_P (DECL_RTL (parms
))
3601 && REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
3602 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
3603 0, DECL_RTL (parms
));
3604 else if (GET_CODE (DECL_RTL (parms
)) == CONCAT
)
3605 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
3606 0, DECL_RTL (parms
));
3607 /* Report parms that live in memory but not where they were passed. */
3608 else if (MEM_P (DECL_RTL (parms
))
3609 && ! rtx_equal_p (DECL_RTL (parms
), DECL_INCOMING_RTL (parms
)))
3610 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
3611 0, DECL_RTL (parms
));
3613 DBXOUT_DECR_NESTING
;
3616 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
3617 output definitions of those names, in raw form */
3620 dbxout_args (tree args
)
3625 dbxout_type (TREE_VALUE (args
), 0);
3626 args
= TREE_CHAIN (args
);
3630 #if defined (DBX_DEBUGGING_INFO)
3632 /* Subroutine of dbxout_block. Emit an N_LBRAC stab referencing LABEL.
3633 BEGIN_LABEL is the name of the beginning of the function, which may
3636 dbx_output_lbrac (const char *label
,
3637 const char *begin_label ATTRIBUTE_UNUSED
)
3639 dbxout_begin_stabn (N_LBRAC
);
3640 if (DBX_BLOCKS_FUNCTION_RELATIVE
)
3641 dbxout_stab_value_label_diff (label
, begin_label
);
3643 dbxout_stab_value_label (label
);
3646 /* Subroutine of dbxout_block. Emit an N_RBRAC stab referencing LABEL.
3647 BEGIN_LABEL is the name of the beginning of the function, which may
3650 dbx_output_rbrac (const char *label
,
3651 const char *begin_label ATTRIBUTE_UNUSED
)
3653 dbxout_begin_stabn (N_RBRAC
);
3654 if (DBX_BLOCKS_FUNCTION_RELATIVE
)
3655 dbxout_stab_value_label_diff (label
, begin_label
);
3657 dbxout_stab_value_label (label
);
3660 /* Output everything about a symbol block (a BLOCK node
3661 that represents a scope level),
3662 including recursive output of contained blocks.
3664 BLOCK is the BLOCK node.
3665 DEPTH is its depth within containing symbol blocks.
3666 ARGS is usually zero; but for the outermost block of the
3667 body of a function, it is a chain of PARM_DECLs for the function parameters.
3668 We output definitions of all the register parms
3669 as if they were local variables of that block.
3671 If -g1 was used, we count blocks just the same, but output nothing
3672 except for the outermost block.
3674 Actually, BLOCK may be several blocks chained together.
3675 We handle them all in sequence. */
3678 dbxout_block (tree block
, int depth
, tree args
)
3680 char begin_label
[20];
3681 /* Reference current function start using LFBB. */
3682 ASM_GENERATE_INTERNAL_LABEL (begin_label
, "LFBB", scope_labelno
);
3686 /* Ignore blocks never expanded or otherwise marked as real. */
3687 if (TREE_USED (block
) && TREE_ASM_WRITTEN (block
))
3690 int blocknum
= BLOCK_NUMBER (block
);
3692 /* In dbx format, the syms of a block come before the N_LBRAC.
3693 If nothing is output, we don't need the N_LBRAC, either. */
3695 if (debug_info_level
!= DINFO_LEVEL_TERSE
|| depth
== 0)
3696 did_output
= dbxout_syms (BLOCK_VARS (block
));
3698 dbxout_reg_parms (args
);
3700 /* Now output an N_LBRAC symbol to represent the beginning of
3701 the block. Use the block's tree-walk order to generate
3702 the assembler symbols LBBn and LBEn
3703 that final will define around the code in this block. */
3707 const char *scope_start
;
3710 /* The outermost block doesn't get LBB labels; use
3711 the LFBB local symbol emitted by dbxout_begin_prologue. */
3712 scope_start
= begin_label
;
3715 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBB", blocknum
);
3719 dbx_output_lbrac (scope_start
, begin_label
);
3722 /* Output the subblocks. */
3723 dbxout_block (BLOCK_SUBBLOCKS (block
), depth
+ 1, NULL_TREE
);
3725 /* Refer to the marker for the end of the block. */
3730 /* The outermost block doesn't get LBE labels;
3731 use the "scope" label which will be emitted
3732 by dbxout_function_end. */
3733 ASM_GENERATE_INTERNAL_LABEL (buf
, "Lscope", scope_labelno
);
3735 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBE", blocknum
);
3737 dbx_output_rbrac (buf
, begin_label
);
3740 block
= BLOCK_CHAIN (block
);
3744 /* Output the information about a function and its arguments and result.
3745 Usually this follows the function's code,
3746 but on some systems, it comes before. */
3749 dbxout_begin_function (tree decl
)
3751 int saved_tree_used1
;
3753 saved_tree_used1
= TREE_USED (decl
);
3754 TREE_USED (decl
) = 1;
3755 if (DECL_NAME (DECL_RESULT (decl
)) != 0)
3757 int saved_tree_used2
= TREE_USED (DECL_RESULT (decl
));
3758 TREE_USED (DECL_RESULT (decl
)) = 1;
3759 dbxout_symbol (decl
, 0);
3760 TREE_USED (DECL_RESULT (decl
)) = saved_tree_used2
;
3763 dbxout_symbol (decl
, 0);
3764 TREE_USED (decl
) = saved_tree_used1
;
3766 dbxout_parms (DECL_ARGUMENTS (decl
));
3767 if (DECL_NAME (DECL_RESULT (decl
)) != 0)
3768 dbxout_symbol (DECL_RESULT (decl
), 1);
3770 #endif /* DBX_DEBUGGING_INFO */
3772 #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */
3774 /* Record an element in the table of global destructors. SYMBOL is
3775 a SYMBOL_REF of the function to be called; PRIORITY is a number
3776 between 0 and MAX_INIT_PRIORITY. */
3779 default_stabs_asm_out_destructor (rtx symbol ATTRIBUTE_UNUSED
,
3780 int priority ATTRIBUTE_UNUSED
)
3782 #if defined DBX_DEBUGGING_INFO || defined XCOFF_DEBUGGING_INFO
3783 /* Tell GNU LD that this is part of the static destructor set.
3784 This will work for any system that uses stabs, most usefully
3786 dbxout_begin_simple_stabs ("___DTOR_LIST__", 22 /* N_SETT */);
3787 dbxout_stab_value_label (XSTR (symbol
, 0));
3789 sorry ("global destructors not supported on this target");
3793 /* Likewise for global constructors. */
3796 default_stabs_asm_out_constructor (rtx symbol ATTRIBUTE_UNUSED
,
3797 int priority ATTRIBUTE_UNUSED
)
3799 #if defined DBX_DEBUGGING_INFO || defined XCOFF_DEBUGGING_INFO
3800 /* Tell GNU LD that this is part of the static destructor set.
3801 This will work for any system that uses stabs, most usefully
3803 dbxout_begin_simple_stabs ("___CTOR_LIST__", 22 /* N_SETT */);
3804 dbxout_stab_value_label (XSTR (symbol
, 0));
3806 sorry ("global constructors not supported on this target");
3810 #include "gt-dbxout.h"