1 /* Output dbx-format symbol table information from GNU compiler.
2 Copyright (C) 1987-2013 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 "insn-config.h"
82 #include "diagnostic-core.h"
89 #include "common/common-target.h"
90 #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_global_decl (tree
);
327 static void dbxout_type_decl (tree
, int);
328 static void dbxout_handle_pch (unsigned);
329 static void debug_free_queue (void);
331 /* The debug hooks structure. */
332 #if defined (DBX_DEBUGGING_INFO)
334 static void dbxout_source_line (unsigned int, const char *, int, bool);
335 static void dbxout_begin_prologue (unsigned int, const char *);
336 static void dbxout_source_file (const char *);
337 static void dbxout_function_end (tree
);
338 static void dbxout_begin_function (tree
);
339 static void dbxout_begin_block (unsigned, unsigned);
340 static void dbxout_end_block (unsigned, unsigned);
341 static void dbxout_function_decl (tree
);
343 const struct gcc_debug_hooks dbx_debug_hooks
=
348 debug_nothing_int_charstar
,
349 debug_nothing_int_charstar
,
350 dbxout_start_source_file
,
351 dbxout_end_source_file
,
354 debug_true_const_tree
, /* ignore_block */
355 dbxout_source_line
, /* source_line */
356 dbxout_begin_prologue
, /* begin_prologue */
357 debug_nothing_int_charstar
, /* end_prologue */
358 debug_nothing_int_charstar
, /* begin_epilogue */
359 debug_nothing_int_charstar
, /* end_epilogue */
360 #ifdef DBX_FUNCTION_FIRST
361 dbxout_begin_function
,
363 debug_nothing_tree
, /* begin_function */
365 debug_nothing_int
, /* end_function */
366 dbxout_function_decl
,
367 dbxout_global_decl
, /* global_decl */
368 dbxout_type_decl
, /* type_decl */
369 debug_nothing_tree_tree_tree_bool
, /* imported_module_or_decl */
370 debug_nothing_tree
, /* deferred_inline_function */
371 debug_nothing_tree
, /* outlining_inline_function */
372 debug_nothing_rtx
, /* label */
373 dbxout_handle_pch
, /* handle_pch */
374 debug_nothing_rtx
, /* var_location */
375 debug_nothing_void
, /* switch_text_section */
376 debug_nothing_tree_tree
, /* set_name */
377 0, /* start_end_main_source_file */
378 TYPE_SYMTAB_IS_ADDRESS
/* tree_type_symtab_field */
380 #endif /* DBX_DEBUGGING_INFO */
382 #if defined (XCOFF_DEBUGGING_INFO)
383 const struct gcc_debug_hooks xcoff_debug_hooks
=
388 debug_nothing_int_charstar
,
389 debug_nothing_int_charstar
,
390 dbxout_start_source_file
,
391 dbxout_end_source_file
,
392 xcoffout_begin_block
,
394 debug_true_const_tree
, /* ignore_block */
395 xcoffout_source_line
,
396 xcoffout_begin_prologue
, /* begin_prologue */
397 debug_nothing_int_charstar
, /* end_prologue */
398 debug_nothing_int_charstar
, /* begin_epilogue */
399 xcoffout_end_epilogue
,
400 debug_nothing_tree
, /* begin_function */
401 xcoffout_end_function
,
402 debug_nothing_tree
, /* function_decl */
403 dbxout_global_decl
, /* global_decl */
404 dbxout_type_decl
, /* type_decl */
405 debug_nothing_tree_tree_tree_bool
, /* imported_module_or_decl */
406 debug_nothing_tree
, /* deferred_inline_function */
407 debug_nothing_tree
, /* outlining_inline_function */
408 debug_nothing_rtx
, /* label */
409 dbxout_handle_pch
, /* handle_pch */
410 debug_nothing_rtx
, /* var_location */
411 debug_nothing_void
, /* switch_text_section */
412 debug_nothing_tree_tree
, /* set_name */
413 0, /* start_end_main_source_file */
414 TYPE_SYMTAB_IS_ADDRESS
/* tree_type_symtab_field */
416 #endif /* XCOFF_DEBUGGING_INFO */
418 /* Numeric formatting helper macro. Note that this does not handle
420 #define NUMBER_FMT_LOOP(P, NUM, BASE) \
423 int digit = NUM % BASE; \
425 *--P = digit + '0'; \
429 /* Utility: write a decimal integer NUM to asm_out_file. */
434 char *p
= buf
+ sizeof buf
;
439 putc ('0', asm_out_file
);
444 putc ('-', asm_out_file
);
450 NUMBER_FMT_LOOP (p
, unum
, 10);
452 while (p
< buf
+ sizeof buf
)
454 putc (*p
, asm_out_file
);
460 /* Primitives for emitting simple stabs directives. All other stabs
461 routines should use these functions instead of directly emitting
462 stabs. They are exported because machine-dependent code may need
463 to invoke them, e.g. in a DBX_OUTPUT_* macro whose definition
464 forwards to code in CPU.c. */
466 /* The following functions should all be called immediately after one
467 of the dbxout_begin_stab* functions (below). They write out
468 various things as the value of a stab. */
470 /* Write out a literal zero as the value of a stab. */
472 dbxout_stab_value_zero (void)
474 fputs ("0\n", asm_out_file
);
477 /* Write out the label LABEL as the value of a stab. */
479 dbxout_stab_value_label (const char *label
)
481 assemble_name (asm_out_file
, label
);
482 putc ('\n', asm_out_file
);
485 /* Write out the difference of two labels, LABEL - BASE, as the value
488 dbxout_stab_value_label_diff (const char *label
, const char *base
)
490 assemble_name (asm_out_file
, label
);
491 putc ('-', asm_out_file
);
492 assemble_name (asm_out_file
, base
);
493 putc ('\n', asm_out_file
);
496 /* Write out an internal label as the value of a stab, and immediately
497 emit that internal label. This should be used only when
498 dbxout_stabd will not work. STEM is the name stem of the label,
499 COUNTERP is a pointer to a counter variable which will be used to
500 guarantee label uniqueness. */
502 dbxout_stab_value_internal_label (const char *stem
, int *counterp
)
505 int counter
= counterp
? (*counterp
)++ : 0;
507 ASM_GENERATE_INTERNAL_LABEL (label
, stem
, counter
);
508 dbxout_stab_value_label (label
);
509 targetm
.asm_out
.internal_label (asm_out_file
, stem
, counter
);
512 /* Write out the difference between BASE and an internal label as the
513 value of a stab, and immediately emit that internal label. STEM and
514 COUNTERP are as for dbxout_stab_value_internal_label. */
516 dbxout_stab_value_internal_label_diff (const char *stem
, int *counterp
,
520 int counter
= counterp
? (*counterp
)++ : 0;
522 ASM_GENERATE_INTERNAL_LABEL (label
, stem
, counter
);
523 dbxout_stab_value_label_diff (label
, base
);
524 targetm
.asm_out
.internal_label (asm_out_file
, stem
, counter
);
527 /* The following functions produce specific kinds of stab directives. */
529 /* Write a .stabd directive with type STYPE and desc SDESC to asm_out_file. */
531 dbxout_stabd (int stype
, int sdesc
)
533 fputs (ASM_STABD_OP
, asm_out_file
);
535 fputs (",0,", asm_out_file
);
537 putc ('\n', asm_out_file
);
540 /* Write a .stabn directive with type STYPE. This function stops
541 short of emitting the value field, which is the responsibility of
542 the caller (normally it will be either a symbol or the difference
546 dbxout_begin_stabn (int stype
)
548 fputs (ASM_STABN_OP
, asm_out_file
);
550 fputs (",0,0,", asm_out_file
);
553 /* Write a .stabn directive with type N_SLINE and desc LINE. As above,
554 the value field is the responsibility of the caller. */
556 dbxout_begin_stabn_sline (int lineno
)
558 fputs (ASM_STABN_OP
, asm_out_file
);
559 dbxout_int (N_SLINE
);
560 fputs (",0,", asm_out_file
);
562 putc (',', asm_out_file
);
565 /* Begin a .stabs directive with string "", type STYPE, and desc and
566 other fields 0. The value field is the responsibility of the
567 caller. This function cannot be used for .stabx directives. */
569 dbxout_begin_empty_stabs (int stype
)
571 fputs (ASM_STABS_OP
, asm_out_file
);
572 fputs ("\"\",", asm_out_file
);
574 fputs (",0,0,", asm_out_file
);
577 /* Begin a .stabs directive with string STR, type STYPE, and desc 0.
578 The value field is the responsibility of the caller. */
580 dbxout_begin_simple_stabs (const char *str
, int stype
)
582 fputs (ASM_STABS_OP
, asm_out_file
);
583 output_quoted_string (asm_out_file
, str
);
584 putc (',', asm_out_file
);
586 fputs (",0,0,", asm_out_file
);
589 /* As above but use SDESC for the desc field. */
591 dbxout_begin_simple_stabs_desc (const char *str
, int stype
, int sdesc
)
593 fputs (ASM_STABS_OP
, asm_out_file
);
594 output_quoted_string (asm_out_file
, str
);
595 putc (',', asm_out_file
);
597 fputs (",0,", asm_out_file
);
599 putc (',', asm_out_file
);
602 /* The next set of functions are entirely concerned with production of
603 "complex" .stabs directives: that is, .stabs directives whose
604 strings have to be constructed piecemeal. dbxout_type,
605 dbxout_symbol, etc. use these routines heavily. The string is queued
606 up in an obstack, then written out by dbxout_finish_complex_stabs, which
607 is also responsible for splitting it up if it exceeds DBX_CONTIN_LENGTH.
608 (You might think it would be more efficient to go straight to stdio
609 when DBX_CONTIN_LENGTH is 0 (i.e. no length limit) but that turns
610 out not to be the case, and anyway this needs fewer #ifdefs.) */
612 /* Begin a complex .stabs directive. If we can, write the initial
613 ASM_STABS_OP to the asm_out_file. */
616 dbxout_begin_complex_stabs (void)
618 emit_pending_bincls_if_required ();
620 fputs (ASM_STABS_OP
, asm_out_file
);
621 putc ('"', asm_out_file
);
622 gcc_assert (stabstr_last_contin_point
== 0);
625 /* As above, but do not force text or emit pending bincls. This is
626 used by dbxout_symbol_location, which needs to do something else. */
628 dbxout_begin_complex_stabs_noforcetext (void)
630 fputs (ASM_STABS_OP
, asm_out_file
);
631 putc ('"', asm_out_file
);
632 gcc_assert (stabstr_last_contin_point
== 0);
635 /* Add CHR, a single character, to the string being built. */
636 #define stabstr_C(chr) obstack_1grow (&stabstr_ob, chr)
638 /* Add STR, a normal C string, to the string being built. */
639 #define stabstr_S(str) obstack_grow (&stabstr_ob, str, strlen (str))
641 /* Add the text of ID, an IDENTIFIER_NODE, to the string being built. */
642 #define stabstr_I(id) obstack_grow (&stabstr_ob, \
643 IDENTIFIER_POINTER (id), \
644 IDENTIFIER_LENGTH (id))
646 /* Add NUM, a signed decimal number, to the string being built. */
648 stabstr_D (HOST_WIDE_INT num
)
651 char *p
= buf
+ sizeof buf
;
667 NUMBER_FMT_LOOP (p
, unum
, 10);
669 obstack_grow (&stabstr_ob
, p
, (buf
+ sizeof buf
) - p
);
672 /* Add NUM, an unsigned decimal number, to the string being built. */
674 stabstr_U (unsigned HOST_WIDE_INT num
)
677 char *p
= buf
+ sizeof buf
;
683 NUMBER_FMT_LOOP (p
, num
, 10);
684 obstack_grow (&stabstr_ob
, p
, (buf
+ sizeof buf
) - p
);
687 /* Add CST, an INTEGER_CST tree, to the string being built as an
688 unsigned octal number. This routine handles values which are
689 larger than a single HOST_WIDE_INT. */
693 int prec
= TYPE_PRECISION (TREE_TYPE (cst
));
694 int res_pres
= prec
% 3;
698 /* Leading zero for base indicator. */
701 /* If the value is zero, the base indicator will serve as the value
703 if (wi::eq_p (cst
, 0))
706 /* GDB wants constants with no extra leading "1" bits, so
707 we need to remove any sign-extension that might be
711 digit
= wi::extract_uhwi (cst
, prec
- 1, 1);
712 stabstr_C ('0' + digit
);
714 else if (res_pres
== 2)
716 digit
= wi::extract_uhwi (cst
, prec
- 2, 2);
717 stabstr_C ('0' + digit
);
721 for (i
= prec
- 3; i
<= 0; i
= i
- 3)
723 digit
= wi::extract_uhwi (cst
, i
, 3);
724 stabstr_C ('0' + digit
);
728 /* Called whenever it is safe to break a stabs string into multiple
729 .stabs directives. If the current string has exceeded the limit
730 set by DBX_CONTIN_LENGTH, mark the current position in the buffer
731 as a continuation point by inserting DBX_CONTIN_CHAR (doubled if
732 it is a backslash) and a null character. */
734 stabstr_continue (void)
736 if (DBX_CONTIN_LENGTH
> 0
737 && obstack_object_size (&stabstr_ob
) - stabstr_last_contin_point
740 if (DBX_CONTIN_CHAR
== '\\')
741 obstack_1grow (&stabstr_ob
, '\\');
742 obstack_1grow (&stabstr_ob
, DBX_CONTIN_CHAR
);
743 obstack_1grow (&stabstr_ob
, '\0');
744 stabstr_last_contin_point
= obstack_object_size (&stabstr_ob
);
747 #define CONTIN stabstr_continue ()
749 /* Macro subroutine of dbxout_finish_complex_stabs, which emits
750 all of the arguments to the .stabs directive after the string.
751 Overridden by xcoffout.h. CODE is the stabs code for this symbol;
752 LINE is the source line to write into the desc field (in extended
753 mode); SYM is the symbol itself.
755 ADDR, LABEL, and NUMBER are three different ways to represent the
756 stabs value field. At most one of these should be nonzero.
758 ADDR is used most of the time; it represents the value as an
759 RTL address constant.
761 LABEL is used (currently) only for N_CATCH stabs; it represents
762 the value as a string suitable for assemble_name.
764 NUMBER is used when the value is an offset from an implicit base
765 pointer (e.g. for a stack variable), or an index (e.g. for a
766 register variable). It represents the value as a decimal integer. */
768 #ifndef DBX_FINISH_STABS
769 #define DBX_FINISH_STABS(SYM, CODE, LINE, ADDR, LABEL, NUMBER) \
771 int line_ = use_gnu_debug_info_extensions ? LINE : 0; \
774 fputs (",0,", asm_out_file); \
775 dbxout_int (line_); \
776 putc (',', asm_out_file); \
778 output_addr_const (asm_out_file, ADDR); \
780 assemble_name (asm_out_file, LABEL); \
782 dbxout_int (NUMBER); \
783 putc ('\n', asm_out_file); \
787 /* Finish the emission of a complex .stabs directive. When DBX_CONTIN_LENGTH
788 is zero, this has only to emit the close quote and the remainder of
789 the arguments. When it is nonzero, the string has been marshalled in
790 stabstr_ob, and this routine is responsible for breaking it up into
791 DBX_CONTIN_LENGTH-sized chunks.
793 SYM is the DECL of the symbol under consideration; it is used only
794 for its DECL_SOURCE_LINE. The other arguments are all passed directly
795 to DBX_FINISH_STABS; see above for details. */
798 dbxout_finish_complex_stabs (tree sym
, stab_code_type code
,
799 rtx addr
, const char *label
, int number
)
801 int line ATTRIBUTE_UNUSED
;
805 line
= sym
? DECL_SOURCE_LINE (sym
) : 0;
806 if (DBX_CONTIN_LENGTH
> 0)
811 /* Nul-terminate the growing string, then get its size and
813 obstack_1grow (&stabstr_ob
, '\0');
815 len
= obstack_object_size (&stabstr_ob
);
816 chunk
= str
= XOBFINISH (&stabstr_ob
, char *);
818 /* Within the buffer are a sequence of NUL-separated strings,
819 each of which is to be written out as a separate stab
823 chunklen
= strlen (chunk
);
824 fwrite (chunk
, 1, chunklen
, asm_out_file
);
825 fputs ("\",", asm_out_file
);
827 /* Must add an extra byte to account for the NUL separator. */
828 chunk
+= chunklen
+ 1;
831 /* Only put a line number on the last stab in the sequence. */
832 DBX_FINISH_STABS (sym
, code
, len
== 0 ? line
: 0,
833 addr
, label
, number
);
837 fputs (ASM_STABS_OP
, asm_out_file
);
838 putc ('"', asm_out_file
);
840 stabstr_last_contin_point
= 0;
844 /* No continuations - we can put the whole string out at once.
845 It is faster to augment the string with the close quote and
846 comma than to do a two-character fputs. */
847 obstack_grow (&stabstr_ob
, "\",", 2);
848 len
= obstack_object_size (&stabstr_ob
);
849 str
= XOBFINISH (&stabstr_ob
, char *);
851 fwrite (str
, 1, len
, asm_out_file
);
852 DBX_FINISH_STABS (sym
, code
, line
, addr
, label
, number
);
854 obstack_free (&stabstr_ob
, str
);
857 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
859 /* When -gused is used, emit debug info for only used symbols. But in
860 addition to the standard intercepted debug_hooks there are some
861 direct calls into this file, i.e., dbxout_symbol, dbxout_parms, and
862 dbxout_reg_params. Those routines may also be called from a higher
863 level intercepted routine. So to prevent recording data for an inner
864 call to one of these for an intercept, we maintain an intercept
865 nesting counter (debug_nesting). We only save the intercepted
866 arguments if the nesting is 1. */
867 static int debug_nesting
= 0;
869 static tree
*symbol_queue
;
870 static int symbol_queue_index
= 0;
871 static int symbol_queue_size
= 0;
873 #define DBXOUT_DECR_NESTING \
874 if (--debug_nesting == 0 && symbol_queue_index > 0) \
875 { emit_pending_bincls_if_required (); debug_flush_symbol_queue (); }
877 #define DBXOUT_DECR_NESTING_AND_RETURN(x) \
878 do {--debug_nesting; return (x);} while (0)
880 #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */
882 #if defined (DBX_DEBUGGING_INFO)
885 dbxout_function_end (tree decl ATTRIBUTE_UNUSED
)
887 char lscope_label_name
[100];
889 /* The Lscope label must be emitted even if we aren't doing anything
890 else; dbxout_block needs it. */
891 switch_to_section (function_section (current_function_decl
));
893 /* Convert Lscope into the appropriate format for local labels in case
894 the system doesn't insert underscores in front of user generated
896 ASM_GENERATE_INTERNAL_LABEL (lscope_label_name
, "Lscope", scope_labelno
);
897 targetm
.asm_out
.internal_label (asm_out_file
, "Lscope", scope_labelno
);
899 /* The N_FUN tag at the end of the function is a GNU extension,
900 which may be undesirable, and is unnecessary if we do not have
902 if (!use_gnu_debug_info_extensions
903 || NO_DBX_FUNCTION_END
904 || !targetm_common
.have_named_sections
)
907 /* By convention, GCC will mark the end of a function with an N_FUN
908 symbol and an empty string. */
909 if (flag_reorder_blocks_and_partition
)
911 dbxout_begin_empty_stabs (N_FUN
);
912 dbxout_stab_value_label_diff (crtl
->subsections
.hot_section_end_label
,
913 crtl
->subsections
.hot_section_label
);
914 dbxout_begin_empty_stabs (N_FUN
);
915 dbxout_stab_value_label_diff (crtl
->subsections
.cold_section_end_label
,
916 crtl
->subsections
.cold_section_label
);
920 char begin_label
[20];
921 /* Reference current function start using LFBB. */
922 ASM_GENERATE_INTERNAL_LABEL (begin_label
, "LFBB", scope_labelno
);
923 dbxout_begin_empty_stabs (N_FUN
);
924 dbxout_stab_value_label_diff (lscope_label_name
, begin_label
);
927 if (!NO_DBX_BNSYM_ENSYM
&& !flag_debug_only_used_symbols
)
928 dbxout_stabd (N_ENSYM
, 0);
930 #endif /* DBX_DEBUGGING_INFO */
932 /* Get lang description for N_SO stab. */
933 static unsigned int ATTRIBUTE_UNUSED
934 get_lang_number (void)
936 const char *language_string
= lang_hooks
.name
;
938 if (strcmp (language_string
, "GNU C") == 0)
940 else if (strcmp (language_string
, "GNU C++") == 0)
942 else if (strcmp (language_string
, "GNU F77") == 0)
944 else if (strcmp (language_string
, "GNU Fortran") == 0)
945 return N_SO_FORTRAN90
; /* CHECKME */
946 else if (strcmp (language_string
, "GNU Pascal") == 0)
948 else if (strcmp (language_string
, "GNU Objective-C") == 0)
950 else if (strcmp (language_string
, "GNU Objective-C++") == 0)
951 return N_SO_OBJCPLUS
;
960 unsigned int lang
= get_lang_number ();
962 return (lang
== N_SO_FORTRAN
) || (lang
== N_SO_FORTRAN90
);
965 /* At the beginning of compilation, start writing the symbol table.
966 Initialize `typevec' and output the standard data types of C. */
969 dbxout_init (const char *input_file_name
)
971 char ltext_label_name
[100];
972 bool used_ltext_label_name
= false;
973 tree syms
= lang_hooks
.decls
.getdecls ();
974 const char *mapped_name
;
977 typevec
= ggc_alloc_cleared_vec_typeinfo (typevec_len
);
979 /* stabstr_ob contains one string, which will be just fine with
981 obstack_specify_allocation (&stabstr_ob
, 0, 1, xmalloc
, free
);
983 /* Convert Ltext into the appropriate format for local labels in case
984 the system doesn't insert underscores in front of user generated
986 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name
, "Ltext", 0);
988 /* Put the current working directory in an N_SO symbol. */
989 if (use_gnu_debug_info_extensions
&& !NO_DBX_MAIN_SOURCE_DIRECTORY
)
991 static const char *cwd
;
995 cwd
= get_src_pwd ();
998 else if (!IS_DIR_SEPARATOR (cwd
[strlen (cwd
) - 1]))
999 cwd
= concat (cwd
, "/", NULL
);
1000 cwd
= remap_debug_filename (cwd
);
1002 #ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
1003 DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asm_out_file
, cwd
);
1004 #else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
1005 dbxout_begin_simple_stabs_desc (cwd
, N_SO
, get_lang_number ());
1006 dbxout_stab_value_label (ltext_label_name
);
1007 used_ltext_label_name
= true;
1008 #endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
1011 mapped_name
= remap_debug_filename (input_file_name
);
1012 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
1013 DBX_OUTPUT_MAIN_SOURCE_FILENAME (asm_out_file
, mapped_name
);
1015 dbxout_begin_simple_stabs_desc (mapped_name
, N_SO
, get_lang_number ());
1016 dbxout_stab_value_label (ltext_label_name
);
1017 used_ltext_label_name
= true;
1020 if (used_ltext_label_name
)
1022 switch_to_section (text_section
);
1023 targetm
.asm_out
.internal_label (asm_out_file
, "Ltext", 0);
1026 /* Emit an N_OPT stab to indicate that this file was compiled by GCC.
1027 The string used is historical. */
1028 #ifndef NO_DBX_GCC_MARKER
1029 dbxout_begin_simple_stabs ("gcc2_compiled.", N_OPT
);
1030 dbxout_stab_value_zero ();
1033 base_input_file
= lastfile
= input_file_name
;
1035 next_type_number
= 1;
1037 #ifdef DBX_USE_BINCL
1038 current_file
= XNEW (struct dbx_file
);
1039 current_file
->next
= NULL
;
1040 current_file
->file_number
= 0;
1041 current_file
->next_type_number
= 1;
1042 next_file_number
= 1;
1043 current_file
->prev
= NULL
;
1044 current_file
->bincl_status
= BINCL_NOT_REQUIRED
;
1045 current_file
->pending_bincl_name
= NULL
;
1048 /* Get all permanent types that have typedef names, and output them
1049 all, except for those already output. Some language front ends
1050 put these declarations in the top-level scope; some do not;
1051 the latter are responsible for calling debug_hooks->type_decl from
1052 their record_builtin_type function. */
1053 dbxout_typedefs (syms
);
1055 if (preinit_symbols
)
1058 for (t
= nreverse (preinit_symbols
); t
; t
= TREE_CHAIN (t
))
1059 dbxout_symbol (TREE_VALUE (t
), 0);
1060 preinit_symbols
= 0;
1064 /* Output any typedef names for types described by TYPE_DECLs in SYMS. */
1067 dbxout_typedefs (tree syms
)
1069 for (; syms
!= NULL_TREE
; syms
= DECL_CHAIN (syms
))
1071 if (TREE_CODE (syms
) == TYPE_DECL
)
1073 tree type
= TREE_TYPE (syms
);
1074 if (TYPE_NAME (type
)
1075 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1076 && COMPLETE_OR_VOID_TYPE_P (type
)
1077 && ! TREE_ASM_WRITTEN (TYPE_NAME (type
)))
1078 dbxout_symbol (TYPE_NAME (type
), 0);
1083 #ifdef DBX_USE_BINCL
1084 /* Emit BINCL stab using given name. */
1086 emit_bincl_stab (const char *name
)
1088 dbxout_begin_simple_stabs (name
, N_BINCL
);
1089 dbxout_stab_value_zero ();
1092 /* If there are pending bincls then it is time to emit all of them. */
1095 emit_pending_bincls_if_required (void)
1098 emit_pending_bincls ();
1101 /* Emit all pending bincls. */
1104 emit_pending_bincls (void)
1106 struct dbx_file
*f
= current_file
;
1108 /* Find first pending bincl. */
1109 while (f
->bincl_status
== BINCL_PENDING
)
1112 /* Now emit all bincls. */
1117 if (f
->bincl_status
== BINCL_PENDING
)
1119 emit_bincl_stab (f
->pending_bincl_name
);
1121 /* Update file number and status. */
1122 f
->file_number
= next_file_number
++;
1123 f
->bincl_status
= BINCL_PROCESSED
;
1125 if (f
== current_file
)
1130 /* All pending bincls have been emitted. */
1137 emit_pending_bincls_if_required (void) {}
1140 /* Change to reading from a new source file. Generate a N_BINCL stab. */
1143 dbxout_start_source_file (unsigned int line ATTRIBUTE_UNUSED
,
1144 const char *filename ATTRIBUTE_UNUSED
)
1146 #ifdef DBX_USE_BINCL
1147 struct dbx_file
*n
= XNEW (struct dbx_file
);
1149 n
->next
= current_file
;
1150 n
->next_type_number
= 1;
1151 /* Do not assign file number now.
1152 Delay it until we actually emit BINCL. */
1155 current_file
->prev
= n
;
1156 n
->bincl_status
= BINCL_PENDING
;
1157 n
->pending_bincl_name
= remap_debug_filename (filename
);
1163 /* Revert to reading a previous source file. Generate a N_EINCL stab. */
1166 dbxout_end_source_file (unsigned int line ATTRIBUTE_UNUSED
)
1168 #ifdef DBX_USE_BINCL
1169 /* Emit EINCL stab only if BINCL is not pending. */
1170 if (current_file
->bincl_status
== BINCL_PROCESSED
)
1172 dbxout_begin_stabn (N_EINCL
);
1173 dbxout_stab_value_zero ();
1175 current_file
->bincl_status
= BINCL_NOT_REQUIRED
;
1176 current_file
= current_file
->next
;
1180 /* Handle a few odd cases that occur when trying to make PCH files work. */
1183 dbxout_handle_pch (unsigned at_end
)
1187 /* When using the PCH, this file will be included, so we need to output
1189 dbxout_start_source_file (0, lastfile
);
1191 /* The base file when using the PCH won't be the same as
1192 the base file when it's being generated. */
1197 /* ... and an EINCL. */
1198 dbxout_end_source_file (0);
1200 /* Deal with cases where 'lastfile' was never actually changed. */
1201 lastfile_is_base
= lastfile
== NULL
;
1205 #if defined (DBX_DEBUGGING_INFO)
1207 static void dbxout_block (tree
, int, tree
);
1209 /* Output debugging info to FILE to switch to sourcefile FILENAME. */
1212 dbxout_source_file (const char *filename
)
1214 if (lastfile
== 0 && lastfile_is_base
)
1216 lastfile
= base_input_file
;
1217 lastfile_is_base
= 0;
1220 if (filename
&& (lastfile
== 0 || strcmp (filename
, lastfile
)))
1222 /* Don't change section amid function. */
1223 if (current_function_decl
== NULL_TREE
)
1224 switch_to_section (text_section
);
1226 dbxout_begin_simple_stabs (remap_debug_filename (filename
), N_SOL
);
1227 dbxout_stab_value_internal_label ("Ltext", &source_label_number
);
1228 lastfile
= filename
;
1232 /* Output N_BNSYM, line number symbol entry, and local symbol at
1236 dbxout_begin_prologue (unsigned int lineno
, const char *filename
)
1238 if (use_gnu_debug_info_extensions
1239 && !NO_DBX_FUNCTION_END
1240 && !NO_DBX_BNSYM_ENSYM
1241 && !flag_debug_only_used_symbols
)
1242 dbxout_stabd (N_BNSYM
, 0);
1244 /* pre-increment the scope counter */
1247 dbxout_source_line (lineno
, filename
, 0, true);
1248 /* Output function begin block at function scope, referenced
1249 by dbxout_block, dbxout_source_line and dbxout_function_end. */
1250 emit_pending_bincls_if_required ();
1251 targetm
.asm_out
.internal_label (asm_out_file
, "LFBB", scope_labelno
);
1254 /* Output a line number symbol entry for source file FILENAME and line
1258 dbxout_source_line (unsigned int lineno
, const char *filename
,
1259 int discriminator ATTRIBUTE_UNUSED
,
1260 bool is_stmt ATTRIBUTE_UNUSED
)
1262 dbxout_source_file (filename
);
1264 #ifdef DBX_OUTPUT_SOURCE_LINE
1265 DBX_OUTPUT_SOURCE_LINE (asm_out_file
, lineno
, dbxout_source_line_counter
);
1267 if (DBX_LINES_FUNCTION_RELATIVE
)
1269 char begin_label
[20];
1270 dbxout_begin_stabn_sline (lineno
);
1271 /* Reference current function start using LFBB. */
1272 ASM_GENERATE_INTERNAL_LABEL (begin_label
, "LFBB", scope_labelno
);
1273 dbxout_stab_value_internal_label_diff ("LM", &dbxout_source_line_counter
,
1277 dbxout_stabd (N_SLINE
, lineno
);
1281 /* Describe the beginning of an internal block within a function. */
1284 dbxout_begin_block (unsigned int line ATTRIBUTE_UNUSED
, unsigned int n
)
1286 emit_pending_bincls_if_required ();
1287 targetm
.asm_out
.internal_label (asm_out_file
, "LBB", n
);
1290 /* Describe the end line-number of an internal block within a function. */
1293 dbxout_end_block (unsigned int line ATTRIBUTE_UNUSED
, unsigned int n
)
1295 emit_pending_bincls_if_required ();
1296 targetm
.asm_out
.internal_label (asm_out_file
, "LBE", n
);
1299 /* Output dbx data for a function definition.
1300 This includes a definition of the function name itself (a symbol),
1301 definitions of the parameters (locating them in the parameter list)
1302 and then output the block that makes up the function's body
1303 (including all the auto variables of the function). */
1306 dbxout_function_decl (tree decl
)
1308 emit_pending_bincls_if_required ();
1309 #ifndef DBX_FUNCTION_FIRST
1310 dbxout_begin_function (decl
);
1312 dbxout_block (DECL_INITIAL (decl
), 0, DECL_ARGUMENTS (decl
));
1313 dbxout_function_end (decl
);
1316 #endif /* DBX_DEBUGGING_INFO */
1318 /* Debug information for a global DECL. Called from toplev.c after
1319 compilation proper has finished. */
1321 dbxout_global_decl (tree decl
)
1323 if (TREE_CODE (decl
) == VAR_DECL
&& !DECL_EXTERNAL (decl
))
1325 int saved_tree_used
= TREE_USED (decl
);
1326 TREE_USED (decl
) = 1;
1327 dbxout_symbol (decl
, 0);
1328 TREE_USED (decl
) = saved_tree_used
;
1332 /* This is just a function-type adapter; dbxout_symbol does exactly
1333 what we want but returns an int. */
1335 dbxout_type_decl (tree decl
, int local
)
1337 dbxout_symbol (decl
, local
);
1340 /* At the end of compilation, finish writing the symbol table.
1341 The default is to call debug_free_queue but do nothing else. */
1344 dbxout_finish (const char *filename ATTRIBUTE_UNUSED
)
1346 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
1347 DBX_OUTPUT_MAIN_SOURCE_FILE_END (asm_out_file
, filename
);
1348 #elif defined DBX_OUTPUT_NULL_N_SO_AT_MAIN_SOURCE_FILE_END
1350 switch_to_section (text_section
);
1351 dbxout_begin_empty_stabs (N_SO
);
1352 dbxout_stab_value_internal_label ("Letext", 0);
1355 debug_free_queue ();
1358 /* Output the index of a type. */
1361 dbxout_type_index (tree type
)
1363 #ifndef DBX_USE_BINCL
1364 stabstr_D (TYPE_SYMTAB_ADDRESS (type
));
1366 struct typeinfo
*t
= &typevec
[TYPE_SYMTAB_ADDRESS (type
)];
1368 stabstr_D (t
->file_number
);
1370 stabstr_D (t
->type_number
);
1376 /* Generate the symbols for any queued up type symbols we encountered
1377 while generating the type info for some originally used symbol.
1378 This might generate additional entries in the queue. Only when
1379 the nesting depth goes to 0 is this routine called. */
1382 debug_flush_symbol_queue (void)
1386 /* Make sure that additionally queued items are not flushed
1391 for (i
= 0; i
< symbol_queue_index
; ++i
)
1393 /* If we pushed queued symbols then such symbols must be
1394 output no matter what anyone else says. Specifically,
1395 we need to make sure dbxout_symbol() thinks the symbol was
1396 used and also we need to override TYPE_DECL_SUPPRESS_DEBUG
1397 which may be set for outside reasons. */
1398 int saved_tree_used
= TREE_USED (symbol_queue
[i
]);
1399 int saved_suppress_debug
= TYPE_DECL_SUPPRESS_DEBUG (symbol_queue
[i
]);
1400 TREE_USED (symbol_queue
[i
]) = 1;
1401 TYPE_DECL_SUPPRESS_DEBUG (symbol_queue
[i
]) = 0;
1403 #ifdef DBX_DEBUGGING_INFO
1404 dbxout_symbol (symbol_queue
[i
], 0);
1407 TREE_USED (symbol_queue
[i
]) = saved_tree_used
;
1408 TYPE_DECL_SUPPRESS_DEBUG (symbol_queue
[i
]) = saved_suppress_debug
;
1411 symbol_queue_index
= 0;
1415 /* Queue a type symbol needed as part of the definition of a decl
1416 symbol. These symbols are generated when debug_flush_symbol_queue()
1420 debug_queue_symbol (tree decl
)
1422 if (symbol_queue_index
>= symbol_queue_size
)
1424 symbol_queue_size
+= 10;
1425 symbol_queue
= XRESIZEVEC (tree
, symbol_queue
, symbol_queue_size
);
1428 symbol_queue
[symbol_queue_index
++] = decl
;
1431 /* Free symbol queue. */
1433 debug_free_queue (void)
1437 free (symbol_queue
);
1438 symbol_queue
= NULL
;
1439 symbol_queue_size
= 0;
1443 /* Used in several places: evaluates to '0' for a private decl,
1444 '1' for a protected decl, '2' for a public decl. */
1445 #define DECL_ACCESSIBILITY_CHAR(DECL) \
1446 (TREE_PRIVATE (DECL) ? '0' : TREE_PROTECTED (DECL) ? '1' : '2')
1448 /* Subroutine of `dbxout_type'. Output the type fields of TYPE.
1449 This must be a separate function because anonymous unions require
1453 dbxout_type_fields (tree type
)
1457 /* Output the name, type, position (in bits), size (in bits) of each
1458 field that we can support. */
1459 for (tem
= TYPE_FIELDS (type
); tem
; tem
= DECL_CHAIN (tem
))
1461 /* If one of the nodes is an error_mark or its type is then
1463 if (error_operand_p (tem
))
1466 /* Omit here local type decls until we know how to support them. */
1467 if (TREE_CODE (tem
) == TYPE_DECL
1468 /* Omit here the nameless fields that are used to skip bits. */
1469 || DECL_IGNORED_P (tem
)
1470 /* Omit fields whose position or size are variable or too large to
1472 || (TREE_CODE (tem
) == FIELD_DECL
1473 && (! tree_fits_shwi_p (bit_position (tem
))
1474 || ! DECL_SIZE (tem
)
1475 || ! tree_fits_uhwi_p (DECL_SIZE (tem
)))))
1478 else if (TREE_CODE (tem
) != CONST_DECL
)
1480 /* Continue the line if necessary,
1481 but not before the first field. */
1482 if (tem
!= TYPE_FIELDS (type
))
1485 if (DECL_NAME (tem
))
1486 stabstr_I (DECL_NAME (tem
));
1489 if (use_gnu_debug_info_extensions
1490 && (TREE_PRIVATE (tem
) || TREE_PROTECTED (tem
)
1491 || TREE_CODE (tem
) != FIELD_DECL
))
1494 stabstr_C (DECL_ACCESSIBILITY_CHAR (tem
));
1497 dbxout_type ((TREE_CODE (tem
) == FIELD_DECL
1498 && DECL_BIT_FIELD_TYPE (tem
))
1499 ? DECL_BIT_FIELD_TYPE (tem
) : TREE_TYPE (tem
), 0);
1501 if (TREE_CODE (tem
) == VAR_DECL
)
1503 if (TREE_STATIC (tem
) && use_gnu_debug_info_extensions
)
1505 tree name
= DECL_ASSEMBLER_NAME (tem
);
1512 /* If TEM is non-static, GDB won't understand it. */
1513 stabstr_S (",0,0;");
1518 stabstr_D (int_bit_position (tem
));
1520 stabstr_D (tree_to_uhwi (DECL_SIZE (tem
)));
1527 /* Subroutine of `dbxout_type_methods'. Output debug info about the
1528 method described DECL. */
1531 dbxout_type_method_1 (tree decl
)
1535 if (TREE_CODE (TREE_TYPE (decl
)) == FUNCTION_TYPE
)
1537 else /* it's a METHOD_TYPE. */
1539 tree firstarg
= TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)));
1540 /* A for normal functions.
1541 B for `const' member functions.
1542 C for `volatile' member functions.
1543 D for `const volatile' member functions. */
1544 if (TYPE_READONLY (TREE_TYPE (firstarg
)))
1546 if (TYPE_VOLATILE (TREE_TYPE (firstarg
)))
1549 if (DECL_VINDEX (decl
))
1555 /* ??? Output the mangled name, which contains an encoding of the
1556 method's type signature. May not be necessary anymore. */
1558 stabstr_I (DECL_ASSEMBLER_NAME (decl
));
1560 stabstr_C (DECL_ACCESSIBILITY_CHAR (decl
));
1564 if (DECL_VINDEX (decl
) && tree_fits_shwi_p (DECL_VINDEX (decl
)))
1566 stabstr_D (tree_to_shwi (DECL_VINDEX (decl
)));
1568 dbxout_type (DECL_CONTEXT (decl
), 0);
1573 /* Subroutine of `dbxout_type'. Output debug info about the methods defined
1577 dbxout_type_methods (tree type
)
1579 /* C++: put out the method names and their parameter lists */
1580 tree methods
= TYPE_METHODS (type
);
1584 if (methods
== NULL_TREE
)
1587 if (TREE_CODE (methods
) != TREE_VEC
)
1589 else if (TREE_VEC_ELT (methods
, 0) != NULL_TREE
)
1590 fndecl
= TREE_VEC_ELT (methods
, 0);
1592 fndecl
= TREE_VEC_ELT (methods
, 1);
1596 int need_prefix
= 1;
1598 /* Group together all the methods for the same operation.
1599 These differ in the types of the arguments. */
1600 for (last
= NULL_TREE
;
1601 fndecl
&& (last
== NULL_TREE
|| DECL_NAME (fndecl
) == DECL_NAME (last
));
1602 fndecl
= DECL_CHAIN (fndecl
))
1603 /* Output the name of the field (after overloading), as
1604 well as the name of the field before overloading, along
1605 with its parameter list */
1607 /* Skip methods that aren't FUNCTION_DECLs. (In C++, these
1608 include TEMPLATE_DECLs.) The debugger doesn't know what
1609 to do with such entities anyhow. */
1610 if (TREE_CODE (fndecl
) != FUNCTION_DECL
)
1617 /* Also ignore abstract methods; those are only interesting to
1618 the DWARF backends. */
1619 if (DECL_IGNORED_P (fndecl
) || DECL_ABSTRACT (fndecl
))
1622 /* Redundantly output the plain name, since that's what gdb
1626 stabstr_I (DECL_NAME (fndecl
));
1631 dbxout_type (TREE_TYPE (fndecl
), 0);
1632 dbxout_type_method_1 (fndecl
);
1639 /* Emit a "range" type specification, which has the form:
1640 "r<index type>;<lower bound>;<upper bound>;".
1641 TYPE is an INTEGER_TYPE, LOW and HIGH are the bounds. */
1644 dbxout_range_type (tree type
, tree low
, tree high
)
1647 if (TREE_TYPE (type
))
1648 dbxout_type (TREE_TYPE (type
), 0);
1649 else if (TREE_CODE (type
) != INTEGER_TYPE
)
1650 dbxout_type (type
, 0); /* E.g. Pascal's ARRAY [BOOLEAN] of INTEGER */
1653 /* Traditionally, we made sure 'int' was type 1, and builtin types
1654 were defined to be sub-ranges of int. Unfortunately, this
1655 does not allow us to distinguish true sub-ranges from integer
1656 types. So, instead we define integer (non-sub-range) types as
1657 sub-ranges of themselves. This matters for Chill. If this isn't
1658 a subrange type, then we want to define it in terms of itself.
1659 However, in C, this may be an anonymous integer type, and we don't
1660 want to emit debug info referring to it. Just calling
1661 dbxout_type_index won't work anyways, because the type hasn't been
1662 defined yet. We make this work for both cases by checked to see
1663 whether this is a defined type, referring to it if it is, and using
1665 if (TYPE_SYMTAB_ADDRESS (type
) != 0)
1666 dbxout_type_index (type
);
1668 dbxout_type_index (integer_type_node
);
1672 if (low
&& tree_fits_shwi_p (low
))
1674 if (print_int_cst_bounds_in_octal_p (type
, low
, high
))
1677 stabstr_D (tree_to_shwi (low
));
1683 if (high
&& tree_fits_shwi_p (high
))
1685 if (print_int_cst_bounds_in_octal_p (type
, low
, high
))
1688 stabstr_D (tree_to_shwi (high
));
1696 /* Output a reference to a type. If the type has not yet been
1697 described in the dbx output, output its definition now.
1698 For a type already defined, just refer to its definition
1699 using the type number.
1701 If FULL is nonzero, and the type has been described only with
1702 a forward-reference, output the definition now.
1703 If FULL is zero in this case, just refer to the forward-reference
1704 using the number previously allocated. */
1707 dbxout_type (tree type
, int full
)
1709 static int anonymous_type_number
= 0;
1710 tree tem
, main_variant
, low
, high
;
1712 if (TREE_CODE (type
) == INTEGER_TYPE
)
1714 if (TREE_TYPE (type
) == 0)
1716 low
= TYPE_MIN_VALUE (type
);
1717 high
= TYPE_MAX_VALUE (type
);
1720 else if (subrange_type_for_debug_p (type
, &low
, &high
))
1723 /* If this is a subtype that should not be emitted as a subrange type,
1724 use the base type. */
1727 type
= TREE_TYPE (type
);
1728 low
= TYPE_MIN_VALUE (type
);
1729 high
= TYPE_MAX_VALUE (type
);
1733 /* If there was an input error and we don't really have a type,
1734 avoid crashing and write something that is at least valid
1735 by assuming `int'. */
1736 if (type
== error_mark_node
)
1737 type
= integer_type_node
;
1740 if (TYPE_NAME (type
)
1741 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1742 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type
)))
1746 /* Try to find the "main variant" with the same name. */
1747 if (TYPE_NAME (type
) && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1748 && DECL_ORIGINAL_TYPE (TYPE_NAME (type
)))
1749 main_variant
= TREE_TYPE (TYPE_NAME (type
));
1751 main_variant
= TYPE_MAIN_VARIANT (type
);
1753 /* If we are not using extensions, stabs does not distinguish const and
1754 volatile, so there is no need to make them separate types. */
1755 if (!use_gnu_debug_info_extensions
)
1756 type
= main_variant
;
1758 if (TYPE_SYMTAB_ADDRESS (type
) == 0)
1760 /* Type has no dbx number assigned. Assign next available number. */
1761 TYPE_SYMTAB_ADDRESS (type
) = next_type_number
++;
1763 /* Make sure type vector is long enough to record about this type. */
1765 if (next_type_number
== typevec_len
)
1767 typevec
= GGC_RESIZEVEC (struct typeinfo
, typevec
, typevec_len
* 2);
1768 memset (typevec
+ typevec_len
, 0, typevec_len
* sizeof typevec
[0]);
1772 #ifdef DBX_USE_BINCL
1773 emit_pending_bincls_if_required ();
1774 typevec
[TYPE_SYMTAB_ADDRESS (type
)].file_number
1775 = current_file
->file_number
;
1776 typevec
[TYPE_SYMTAB_ADDRESS (type
)].type_number
1777 = current_file
->next_type_number
++;
1781 if (flag_debug_only_used_symbols
)
1783 if ((TREE_CODE (type
) == RECORD_TYPE
1784 || TREE_CODE (type
) == UNION_TYPE
1785 || TREE_CODE (type
) == QUAL_UNION_TYPE
1786 || TREE_CODE (type
) == ENUMERAL_TYPE
)
1787 && TYPE_STUB_DECL (type
)
1788 && DECL_P (TYPE_STUB_DECL (type
))
1789 && ! DECL_IGNORED_P (TYPE_STUB_DECL (type
)))
1790 debug_queue_symbol (TYPE_STUB_DECL (type
));
1791 else if (TYPE_NAME (type
)
1792 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
1793 debug_queue_symbol (TYPE_NAME (type
));
1796 /* Output the number of this type, to refer to it. */
1797 dbxout_type_index (type
);
1799 #ifdef DBX_TYPE_DEFINED
1800 if (DBX_TYPE_DEFINED (type
))
1804 /* If this type's definition has been output or is now being output,
1807 switch (typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
)
1812 /* If we have already had a cross reference,
1813 and either that's all we want or that's the best we could do,
1814 don't repeat the cross reference.
1815 Sun dbx crashes if we do. */
1816 if (! full
|| !COMPLETE_TYPE_P (type
)
1817 /* No way in DBX fmt to describe a variable size. */
1818 || ! tree_fits_uhwi_p (TYPE_SIZE (type
)))
1826 /* For systems where dbx output does not allow the `=xsNAME:' syntax,
1827 leave the type-number completely undefined rather than output
1828 a cross-reference. If we have already used GNU debug info extensions,
1829 then it is OK to output a cross reference. This is necessary to get
1830 proper C++ debug output. */
1831 if ((TREE_CODE (type
) == RECORD_TYPE
|| TREE_CODE (type
) == UNION_TYPE
1832 || TREE_CODE (type
) == QUAL_UNION_TYPE
1833 || TREE_CODE (type
) == ENUMERAL_TYPE
)
1834 && ! use_gnu_debug_info_extensions
)
1835 /* We must use the same test here as we use twice below when deciding
1836 whether to emit a cross-reference. */
1837 if ((TYPE_NAME (type
) != 0
1838 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1839 && DECL_IGNORED_P (TYPE_NAME (type
)))
1841 || !COMPLETE_TYPE_P (type
)
1842 /* No way in DBX fmt to describe a variable size. */
1843 || ! tree_fits_uhwi_p (TYPE_SIZE (type
)))
1845 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1850 /* Output a definition now. */
1853 /* Mark it as defined, so that if it is self-referent
1854 we will not get into an infinite recursion of definitions. */
1856 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_DEFINED
;
1858 /* If this type is a variant of some other, hand off. Types with
1859 different names are usefully distinguished. We only distinguish
1860 cv-qualified types if we're using extensions. */
1861 if (TYPE_READONLY (type
) > TYPE_READONLY (main_variant
))
1864 dbxout_type (build_type_variant (type
, 0, TYPE_VOLATILE (type
)), 0);
1867 else if (TYPE_VOLATILE (type
) > TYPE_VOLATILE (main_variant
))
1870 dbxout_type (build_type_variant (type
, TYPE_READONLY (type
), 0), 0);
1873 else if (main_variant
!= TYPE_MAIN_VARIANT (type
))
1875 if (flag_debug_only_used_symbols
)
1877 tree orig_type
= DECL_ORIGINAL_TYPE (TYPE_NAME (type
));
1879 if ((TREE_CODE (orig_type
) == RECORD_TYPE
1880 || TREE_CODE (orig_type
) == UNION_TYPE
1881 || TREE_CODE (orig_type
) == QUAL_UNION_TYPE
1882 || TREE_CODE (orig_type
) == ENUMERAL_TYPE
)
1883 && TYPE_STUB_DECL (orig_type
)
1884 && ! DECL_IGNORED_P (TYPE_STUB_DECL (orig_type
)))
1885 debug_queue_symbol (TYPE_STUB_DECL (orig_type
));
1887 /* 'type' is a typedef; output the type it refers to. */
1888 dbxout_type (DECL_ORIGINAL_TYPE (TYPE_NAME (type
)), 0);
1891 /* else continue. */
1893 switch (TREE_CODE (type
))
1898 /* For a void type, just define it as itself; i.e., "5=5".
1899 This makes us consider it defined
1900 without saying what it is. The debugger will make it
1901 a void type when the reference is seen, and nothing will
1902 ever override that default. */
1903 dbxout_type_index (type
);
1907 if (type
== char_type_node
&& ! TYPE_UNSIGNED (type
))
1909 /* Output the type `char' as a subrange of itself!
1910 I don't understand this definition, just copied it
1911 from the output of pcc.
1912 This used to use `r2' explicitly and we used to
1913 take care to make sure that `char' was type number 2. */
1915 dbxout_type_index (type
);
1916 stabstr_S (";0;127;");
1919 /* If this is a subtype of another integer type, always prefer to
1920 write it as a subtype. */
1921 else if (TREE_TYPE (type
) != 0
1922 && TREE_CODE (TREE_TYPE (type
)) == INTEGER_TYPE
)
1924 /* If the size is non-standard, say what it is if we can use
1927 if (use_gnu_debug_info_extensions
1928 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
1931 stabstr_D (TYPE_PRECISION (type
));
1935 dbxout_range_type (type
, low
, high
);
1940 /* If the size is non-standard, say what it is if we can use
1943 if (use_gnu_debug_info_extensions
1944 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
1947 stabstr_D (TYPE_PRECISION (type
));
1951 if (print_int_cst_bounds_in_octal_p (type
, low
, high
))
1955 /* If this type derives from another type, output type index of
1956 parent type. This is particularly important when parent type
1957 is an enumerated type, because not generating the parent type
1958 index would transform the definition of this enumerated type
1959 into a plain unsigned type. */
1960 if (TREE_TYPE (type
) != 0)
1961 dbxout_type_index (TREE_TYPE (type
));
1963 dbxout_type_index (type
);
1973 /* Output other integer types as subranges of `int'. */
1974 dbxout_range_type (type
, low
, high
);
1980 case FIXED_POINT_TYPE
:
1981 /* This used to say `r1' and we used to take care
1982 to make sure that `int' was type number 1. */
1984 dbxout_type_index (integer_type_node
);
1986 stabstr_D (int_size_in_bytes (type
));
1991 if (use_gnu_debug_info_extensions
)
1994 stabstr_D (BITS_PER_UNIT
* int_size_in_bytes (type
));
1995 stabstr_S (";-16;");
1997 else /* Define as enumeral type (False, True) */
1998 stabstr_S ("eFalse:0,True:1,;");
2002 /* Differs from the REAL_TYPE by its new data type number.
2003 R3 is NF_COMPLEX. We don't try to use any of the other NF_*
2004 codes since gdb doesn't care anyway. */
2006 if (TREE_CODE (TREE_TYPE (type
)) == REAL_TYPE
)
2009 stabstr_D (2 * int_size_in_bytes (TREE_TYPE (type
)));
2014 /* Output a complex integer type as a structure,
2015 pending some other way to do it. */
2017 stabstr_D (int_size_in_bytes (type
));
2019 stabstr_S ("real:");
2020 dbxout_type (TREE_TYPE (type
), 0);
2022 stabstr_D (TYPE_PRECISION (TREE_TYPE (type
)));
2024 stabstr_S (";imag:");
2025 dbxout_type (TREE_TYPE (type
), 0);
2027 stabstr_D (TYPE_PRECISION (TREE_TYPE (type
)));
2029 stabstr_D (TYPE_PRECISION (TREE_TYPE (type
)));
2035 /* Make arrays of packed bits look like bitstrings for chill. */
2036 if (TYPE_PACKED (type
) && use_gnu_debug_info_extensions
)
2039 stabstr_D (BITS_PER_UNIT
* int_size_in_bytes (type
));
2040 stabstr_S (";@S;S");
2041 dbxout_type (TYPE_DOMAIN (type
), 0);
2045 /* Output "a" followed by a range type definition
2046 for the index type of the array
2047 followed by a reference to the target-type.
2048 ar1;0;N;M for a C array of type M and size N+1. */
2049 /* Check if a character string type, which in Chill is
2050 different from an array of characters. */
2051 if (TYPE_STRING_FLAG (type
) && use_gnu_debug_info_extensions
)
2055 tem
= TYPE_DOMAIN (type
);
2059 dbxout_type_index (integer_type_node
);
2060 stabstr_S (";0;-1;");
2065 dbxout_range_type (tem
, TYPE_MIN_VALUE (tem
), TYPE_MAX_VALUE (tem
));
2068 dbxout_type (TREE_TYPE (type
), 0);
2072 /* Make vectors look like an array. */
2073 if (use_gnu_debug_info_extensions
)
2076 /* Output "a" followed by a range type definition
2077 for the index type of the array
2078 followed by a reference to the target-type.
2079 ar1;0;N;M for a C array of type M and size N+1. */
2081 dbxout_range_type (integer_type_node
, size_zero_node
,
2082 size_int (TYPE_VECTOR_SUBPARTS (type
) - 1));
2084 dbxout_type (TREE_TYPE (type
), 0);
2089 case QUAL_UNION_TYPE
:
2091 tree binfo
= TYPE_BINFO (type
);
2093 /* Output a structure type. We must use the same test here as we
2094 use in the DBX_NO_XREFS case above. */
2095 if ((TYPE_NAME (type
) != 0
2096 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
2097 && DECL_IGNORED_P (TYPE_NAME (type
)))
2099 || !COMPLETE_TYPE_P (type
)
2100 /* No way in DBX fmt to describe a variable size. */
2101 || ! tree_fits_uhwi_p (TYPE_SIZE (type
)))
2103 /* If the type is just a cross reference, output one
2104 and mark the type as partially described.
2105 If it later becomes defined, we will output
2106 its real definition.
2107 If the type has a name, don't nest its definition within
2108 another type's definition; instead, output an xref
2109 and let the definition come when the name is defined. */
2110 stabstr_S ((TREE_CODE (type
) == RECORD_TYPE
) ? "xs" : "xu");
2111 if (TYPE_NAME (type
) != 0
2112 /* The C frontend creates for anonymous variable length
2113 records/unions TYPE_NAME with DECL_NAME NULL. */
2114 && (TREE_CODE (TYPE_NAME (type
)) != TYPE_DECL
2115 || DECL_NAME (TYPE_NAME (type
))))
2116 dbxout_type_name (type
);
2120 stabstr_D (anonymous_type_number
++);
2124 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
2128 /* Identify record or union, and print its size. */
2129 stabstr_C ((TREE_CODE (type
) == RECORD_TYPE
) ? 's' : 'u');
2130 stabstr_D (int_size_in_bytes (type
));
2136 vec
<tree
, va_gc
> *accesses
= BINFO_BASE_ACCESSES (binfo
);
2138 if (use_gnu_debug_info_extensions
)
2140 if (BINFO_N_BASE_BINFOS (binfo
))
2143 stabstr_U (BINFO_N_BASE_BINFOS (binfo
));
2147 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, child
); i
++)
2149 tree access
= (accesses
? (*accesses
)[i
] : access_public_node
);
2151 if (use_gnu_debug_info_extensions
)
2153 stabstr_C (BINFO_VIRTUAL_P (child
) ? '1' : '0');
2154 stabstr_C (access
== access_public_node
? '2' :
2155 access
== access_protected_node
2157 if (BINFO_VIRTUAL_P (child
)
2158 && (strcmp (lang_hooks
.name
, "GNU C++") == 0
2159 || strcmp (lang_hooks
.name
, "GNU Objective-C++") == 0))
2160 /* For a virtual base, print the (negative)
2161 offset within the vtable where we must look
2162 to find the necessary adjustment. */
2164 (tree_to_shwi (BINFO_VPTR_FIELD (child
))
2167 stabstr_D (tree_to_shwi (BINFO_OFFSET (child
))
2170 dbxout_type (BINFO_TYPE (child
), 0);
2175 /* Print out the base class information with
2176 fields which have the same names at the types
2178 dbxout_type_name (BINFO_TYPE (child
));
2180 dbxout_type (BINFO_TYPE (child
), full
);
2182 stabstr_D (tree_to_shwi (BINFO_OFFSET (child
))
2186 (tree_to_shwi (TYPE_SIZE (BINFO_TYPE (child
)))
2194 /* Write out the field declarations. */
2195 dbxout_type_fields (type
);
2196 if (use_gnu_debug_info_extensions
&& TYPE_METHODS (type
) != NULL_TREE
)
2198 dbxout_type_methods (type
);
2203 if (use_gnu_debug_info_extensions
&& TREE_CODE (type
) == RECORD_TYPE
2204 /* Avoid the ~ if we don't really need it--it confuses dbx. */
2205 && TYPE_VFIELD (type
))
2208 /* We need to write out info about what field this class
2209 uses as its "main" vtable pointer field, because if this
2210 field is inherited from a base class, GDB cannot necessarily
2211 figure out which field it's using in time. */
2213 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type
)), 0);
2219 /* We must use the same test here as we use in the DBX_NO_XREFS case
2220 above. We simplify it a bit since an enum will never have a variable
2222 if ((TYPE_NAME (type
) != 0
2223 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
2224 && DECL_IGNORED_P (TYPE_NAME (type
)))
2226 || !COMPLETE_TYPE_P (type
))
2229 dbxout_type_name (type
);
2230 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
2234 if (use_gnu_debug_info_extensions
2235 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
2238 stabstr_D (TYPE_PRECISION (type
));
2243 for (tem
= TYPE_VALUES (type
); tem
; tem
= TREE_CHAIN (tem
))
2245 tree value
= TREE_VALUE (tem
);
2247 stabstr_I (TREE_PURPOSE (tem
));
2250 if (TREE_CODE (value
) == CONST_DECL
)
2251 value
= DECL_INITIAL (value
);
2253 if (cst_fits_shwi_p (value
))
2254 stabstr_D (TREE_INT_CST_LOW (value
));
2259 if (TREE_CHAIN (tem
) != 0)
2268 dbxout_type (TREE_TYPE (type
), 0);
2272 if (use_gnu_debug_info_extensions
)
2276 /* Write the argument types out longhand. */
2277 dbxout_type (TYPE_METHOD_BASETYPE (type
), 0);
2279 dbxout_type (TREE_TYPE (type
), 0);
2280 dbxout_args (TYPE_ARG_TYPES (type
));
2284 /* Treat it as a function type. */
2285 dbxout_type (TREE_TYPE (type
), 0);
2289 if (use_gnu_debug_info_extensions
)
2292 dbxout_type (TYPE_OFFSET_BASETYPE (type
), 0);
2294 dbxout_type (TREE_TYPE (type
), 0);
2297 /* Should print as an int, because it is really just an offset. */
2298 dbxout_type (integer_type_node
, 0);
2301 case REFERENCE_TYPE
:
2302 if (use_gnu_debug_info_extensions
)
2308 dbxout_type (TREE_TYPE (type
), 0);
2313 dbxout_type (TREE_TYPE (type
), 0);
2321 /* Return nonzero if the given type represents an integer whose bounds
2322 should be printed in octal format. */
2325 print_int_cst_bounds_in_octal_p (tree type
, tree low
, tree high
)
2327 /* If we can use GDB extensions and the size is wider than a long
2328 (the size used by GDB to read them) or we may have trouble writing
2329 the bounds the usual way, write them in octal. Note the test is for
2330 the *target's* size of "long", not that of the host. The host test
2331 is just to make sure we can write it out in case the host wide int
2332 is narrower than the target "long".
2334 For unsigned types, we use octal if they are the same size or larger.
2335 This is because we print the bounds as signed decimal, and hence they
2336 can't span same size unsigned types. */
2338 if (use_gnu_debug_info_extensions
2339 && low
&& TREE_CODE (low
) == INTEGER_CST
2340 && high
&& TREE_CODE (high
) == INTEGER_CST
2341 && (TYPE_PRECISION (type
) > TYPE_PRECISION (integer_type_node
)
2342 || ((TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
))
2343 && TYPE_UNSIGNED (type
))
2344 || TYPE_PRECISION (type
) > HOST_BITS_PER_WIDE_INT
2345 || (TYPE_PRECISION (type
) == HOST_BITS_PER_WIDE_INT
2346 && TYPE_UNSIGNED (type
))))
2352 /* Output the name of type TYPE, with no punctuation.
2353 Such names can be set up either by typedef declarations
2354 or by struct, enum and union tags. */
2357 dbxout_type_name (tree type
)
2359 tree t
= TYPE_NAME (type
);
2362 switch (TREE_CODE (t
))
2364 case IDENTIFIER_NODE
:
2376 /* Output leading leading struct or class names needed for qualifying
2377 type whose scope is limited to a struct or class. */
2380 dbxout_class_name_qualifiers (tree decl
)
2382 tree context
= decl_type_context (decl
);
2384 if (context
!= NULL_TREE
2385 && TREE_CODE (context
) == RECORD_TYPE
2386 && TYPE_NAME (context
) != 0
2387 && (TREE_CODE (TYPE_NAME (context
)) == IDENTIFIER_NODE
2388 || (DECL_NAME (TYPE_NAME (context
)) != 0)))
2390 tree name
= TYPE_NAME (context
);
2392 if (TREE_CODE (name
) == TYPE_DECL
)
2394 dbxout_class_name_qualifiers (name
);
2395 name
= DECL_NAME (name
);
2402 /* This is a specialized subset of expand_expr for use by dbxout_symbol in
2403 evaluating DECL_VALUE_EXPR. In particular, we stop if we find decls that
2404 haven't been expanded, or if the expression is getting so complex we won't
2405 be able to represent it in stabs anyway. Returns NULL on failure. */
2408 dbxout_expand_expr (tree expr
)
2410 switch (TREE_CODE (expr
))
2413 /* We can't handle emulated tls variables, because the address is an
2414 offset to the return value of __emutls_get_address, and there is no
2415 way to express that in stabs. Also, there are name mangling issues
2416 here. We end up with references to undefined symbols if we don't
2417 disable debug info for these variables. */
2418 if (!targetm
.have_tls
&& DECL_THREAD_LOCAL_P (expr
))
2420 if (TREE_STATIC (expr
)
2421 && !TREE_ASM_WRITTEN (expr
)
2422 && !DECL_HAS_VALUE_EXPR_P (expr
)
2423 && !TREE_PUBLIC (expr
)
2424 && DECL_RTL_SET_P (expr
)
2425 && MEM_P (DECL_RTL (expr
)))
2427 /* If this is a var that might not be actually output,
2428 return NULL, otherwise stabs might reference an undefined
2430 struct varpool_node
*node
= varpool_get_node (expr
);
2431 if (!node
|| !node
->definition
)
2438 if (DECL_HAS_VALUE_EXPR_P (expr
))
2439 return dbxout_expand_expr (DECL_VALUE_EXPR (expr
));
2443 return DECL_RTL_IF_SET (expr
);
2446 return expand_expr (expr
, NULL_RTX
, VOIDmode
, EXPAND_INITIALIZER
);
2450 case ARRAY_RANGE_REF
:
2453 enum machine_mode mode
;
2454 HOST_WIDE_INT bitsize
, bitpos
;
2456 int volatilep
= 0, unsignedp
= 0;
2459 tem
= get_inner_reference (expr
, &bitsize
, &bitpos
, &offset
,
2460 &mode
, &unsignedp
, &volatilep
, true);
2462 x
= dbxout_expand_expr (tem
);
2463 if (x
== NULL
|| !MEM_P (x
))
2467 if (!tree_fits_shwi_p (offset
))
2469 x
= adjust_address_nv (x
, mode
, tree_to_shwi (offset
));
2472 x
= adjust_address_nv (x
, mode
, bitpos
/ BITS_PER_UNIT
);
2482 /* Helper function for output_used_types. Queue one entry from the
2483 used types hash to be output. */
2486 output_used_types_helper (void **slot
, void *data
)
2488 tree type
= (tree
) *slot
;
2489 vec
<tree
> *types_p
= (vec
<tree
> *) data
;
2491 if ((TREE_CODE (type
) == RECORD_TYPE
2492 || TREE_CODE (type
) == UNION_TYPE
2493 || TREE_CODE (type
) == QUAL_UNION_TYPE
2494 || TREE_CODE (type
) == ENUMERAL_TYPE
)
2495 && TYPE_STUB_DECL (type
)
2496 && DECL_P (TYPE_STUB_DECL (type
))
2497 && ! DECL_IGNORED_P (TYPE_STUB_DECL (type
)))
2498 types_p
->quick_push (TYPE_STUB_DECL (type
));
2499 else if (TYPE_NAME (type
)
2500 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
2501 types_p
->quick_push (TYPE_NAME (type
));
2506 /* This is a qsort callback which sorts types and declarations into a
2507 predictable order (types, then declarations, sorted by UID
2511 output_types_sort (const void *pa
, const void *pb
)
2513 const tree lhs
= *((const tree
*)pa
);
2514 const tree rhs
= *((const tree
*)pb
);
2519 return TYPE_UID (lhs
) - TYPE_UID (rhs
);
2528 return DECL_UID (lhs
) - DECL_UID (rhs
);
2533 /* Force all types used by this function to be output in debug
2537 output_used_types (void)
2539 if (cfun
&& cfun
->used_types_hash
)
2545 types
.create (htab_elements (cfun
->used_types_hash
));
2546 htab_traverse (cfun
->used_types_hash
, output_used_types_helper
, &types
);
2548 /* Sort by UID to prevent dependence on hash table ordering. */
2549 types
.qsort (output_types_sort
);
2551 FOR_EACH_VEC_ELT (types
, i
, type
)
2552 debug_queue_symbol (type
);
2558 /* Output a .stabs for the symbol defined by DECL,
2559 which must be a ..._DECL node in the normal namespace.
2560 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
2561 LOCAL is nonzero if the scope is less than the entire file.
2562 Return 1 if a stabs might have been emitted. */
2565 dbxout_symbol (tree decl
, int local ATTRIBUTE_UNUSED
)
2567 tree type
= TREE_TYPE (decl
);
2568 tree context
= NULL_TREE
;
2572 /* "Intercept" dbxout_symbol() calls like we do all debug_hooks. */
2575 /* Ignore nameless syms, but don't ignore type tags. */
2577 if ((DECL_NAME (decl
) == 0 && TREE_CODE (decl
) != TYPE_DECL
)
2578 || DECL_IGNORED_P (decl
))
2579 DBXOUT_DECR_NESTING_AND_RETURN (0);
2581 /* If we are to generate only the symbols actually used then such
2582 symbol nodes are flagged with TREE_USED. Ignore any that
2583 aren't flagged as TREE_USED. */
2585 if (flag_debug_only_used_symbols
2586 && (!TREE_USED (decl
)
2587 && (TREE_CODE (decl
) != VAR_DECL
|| !DECL_INITIAL (decl
))))
2588 DBXOUT_DECR_NESTING_AND_RETURN (0);
2590 /* If dbxout_init has not yet run, queue this symbol for later. */
2593 preinit_symbols
= tree_cons (0, decl
, preinit_symbols
);
2594 DBXOUT_DECR_NESTING_AND_RETURN (0);
2597 if (flag_debug_only_used_symbols
)
2601 /* We now have a used symbol. We need to generate the info for
2602 the symbol's type in addition to the symbol itself. These
2603 type symbols are queued to be generated after were done with
2604 the symbol itself (otherwise they would fight over the
2607 Note, because the TREE_TYPE(type) might be something like a
2608 pointer to a named type we need to look for the first name
2609 we see following the TREE_TYPE chain. */
2612 while (POINTER_TYPE_P (t
))
2615 /* RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, and ENUMERAL_TYPE
2616 need special treatment. The TYPE_STUB_DECL field in these
2617 types generally represents the tag name type we want to
2618 output. In addition there could be a typedef type with
2619 a different name. In that case we also want to output
2622 if (TREE_CODE (t
) == RECORD_TYPE
2623 || TREE_CODE (t
) == UNION_TYPE
2624 || TREE_CODE (t
) == QUAL_UNION_TYPE
2625 || TREE_CODE (t
) == ENUMERAL_TYPE
)
2627 if (TYPE_STUB_DECL (t
)
2628 && TYPE_STUB_DECL (t
) != decl
2629 && DECL_P (TYPE_STUB_DECL (t
))
2630 && ! DECL_IGNORED_P (TYPE_STUB_DECL (t
)))
2632 debug_queue_symbol (TYPE_STUB_DECL (t
));
2634 && TYPE_NAME (t
) != TYPE_STUB_DECL (t
)
2635 && TYPE_NAME (t
) != decl
2636 && DECL_P (TYPE_NAME (t
)))
2637 debug_queue_symbol (TYPE_NAME (t
));
2640 else if (TYPE_NAME (t
)
2641 && TYPE_NAME (t
) != decl
2642 && DECL_P (TYPE_NAME (t
)))
2643 debug_queue_symbol (TYPE_NAME (t
));
2646 emit_pending_bincls_if_required ();
2648 switch (TREE_CODE (decl
))
2651 /* Enum values are defined by defining the enum type. */
2655 decl_rtl
= DECL_RTL_IF_SET (decl
);
2657 DBXOUT_DECR_NESTING_AND_RETURN (0);
2658 if (DECL_EXTERNAL (decl
))
2660 /* Don't mention a nested function under its parent. */
2661 context
= decl_function_context (decl
);
2662 if (context
== current_function_decl
)
2664 /* Don't mention an inline instance of a nested function. */
2665 if (context
&& DECL_FROM_INLINE (decl
))
2667 if (!MEM_P (decl_rtl
)
2668 || GET_CODE (XEXP (decl_rtl
, 0)) != SYMBOL_REF
)
2671 if (flag_debug_only_used_symbols
)
2672 output_used_types ();
2674 dbxout_begin_complex_stabs ();
2675 stabstr_I (DECL_ASSEMBLER_NAME (decl
));
2676 stabstr_S (TREE_PUBLIC (decl
) ? ":F" : ":f");
2679 if (TREE_TYPE (type
))
2680 dbxout_type (TREE_TYPE (type
), 0);
2682 dbxout_type (void_type_node
, 0);
2684 /* For a nested function, when that function is compiled,
2685 mention the containing function name
2686 as well as (since dbx wants it) our own assembler-name. */
2690 stabstr_I (DECL_ASSEMBLER_NAME (decl
));
2692 stabstr_I (DECL_NAME (context
));
2695 dbxout_finish_complex_stabs (decl
, N_FUN
, XEXP (decl_rtl
, 0), 0, 0);
2699 /* Don't output the same typedef twice.
2700 And don't output what language-specific stuff doesn't want output. */
2701 if (TREE_ASM_WRITTEN (decl
) || TYPE_DECL_SUPPRESS_DEBUG (decl
))
2702 DBXOUT_DECR_NESTING_AND_RETURN (0);
2704 /* Don't output typedefs for types with magic type numbers (XCOFF). */
2705 #ifdef DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER
2707 int fundamental_type_number
=
2708 DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER (decl
);
2710 if (fundamental_type_number
!= 0)
2712 TREE_ASM_WRITTEN (decl
) = 1;
2713 TYPE_SYMTAB_ADDRESS (TREE_TYPE (decl
)) = fundamental_type_number
;
2714 DBXOUT_DECR_NESTING_AND_RETURN (0);
2724 if (DECL_NAME (decl
))
2726 /* Nonzero means we must output a tag as well as a typedef. */
2729 /* Handle the case of a C++ structure or union
2730 where the TYPE_NAME is a TYPE_DECL
2731 which gives both a typedef name and a tag. */
2732 /* dbx requires the tag first and the typedef second. */
2733 if ((TREE_CODE (type
) == RECORD_TYPE
2734 || TREE_CODE (type
) == UNION_TYPE
2735 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
2736 && TYPE_NAME (type
) == decl
2737 && !use_gnu_debug_info_extensions
2738 && !TREE_ASM_WRITTEN (TYPE_NAME (type
))
2739 /* Distinguish the implicit typedefs of C++
2740 from explicit ones that might be found in C. */
2741 && DECL_ARTIFICIAL (decl
)
2742 /* Do not generate a tag for incomplete records. */
2743 && COMPLETE_TYPE_P (type
)
2744 /* Do not generate a tag for records of variable size,
2745 since this type can not be properly described in the
2746 DBX format, and it confuses some tools such as objdump. */
2747 && tree_fits_uhwi_p (TYPE_SIZE (type
)))
2749 tree name
= TYPE_NAME (type
);
2750 if (TREE_CODE (name
) == TYPE_DECL
)
2751 name
= DECL_NAME (name
);
2753 dbxout_begin_complex_stabs ();
2756 dbxout_type (type
, 1);
2757 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE
,
2761 dbxout_begin_complex_stabs ();
2763 /* Output leading class/struct qualifiers. */
2764 if (use_gnu_debug_info_extensions
)
2765 dbxout_class_name_qualifiers (decl
);
2767 /* Output typedef name. */
2768 stabstr_I (DECL_NAME (decl
));
2771 /* Short cut way to output a tag also. */
2772 if ((TREE_CODE (type
) == RECORD_TYPE
2773 || TREE_CODE (type
) == UNION_TYPE
2774 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
2775 && TYPE_NAME (type
) == decl
2776 /* Distinguish the implicit typedefs of C++
2777 from explicit ones that might be found in C. */
2778 && DECL_ARTIFICIAL (decl
))
2780 if (use_gnu_debug_info_extensions
)
2783 TREE_ASM_WRITTEN (TYPE_NAME (type
)) = 1;
2788 dbxout_type (type
, 1);
2789 dbxout_finish_complex_stabs (decl
, DBX_TYPE_DECL_STABS_CODE
,
2794 /* Don't output a tag if this is an incomplete type. This prevents
2795 the sun4 Sun OS 4.x dbx from crashing. */
2797 if (tag_needed
&& TYPE_NAME (type
) != 0
2798 && (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
2799 || (DECL_NAME (TYPE_NAME (type
)) != 0))
2800 && COMPLETE_TYPE_P (type
)
2801 && !TREE_ASM_WRITTEN (TYPE_NAME (type
)))
2803 /* For a TYPE_DECL with no name, but the type has a name,
2805 This is what represents `struct foo' with no typedef. */
2806 /* In C++, the name of a type is the corresponding typedef.
2807 In C, it is an IDENTIFIER_NODE. */
2808 tree name
= TYPE_NAME (type
);
2809 if (TREE_CODE (name
) == TYPE_DECL
)
2810 name
= DECL_NAME (name
);
2812 dbxout_begin_complex_stabs ();
2815 dbxout_type (type
, 1);
2816 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE
, 0, 0, 0);
2820 /* If an enum type has no name, it cannot be referred to, but
2821 we must output it anyway, to record the enumeration
2824 if (!did_output
&& TREE_CODE (type
) == ENUMERAL_TYPE
)
2826 dbxout_begin_complex_stabs ();
2827 /* Some debuggers fail when given NULL names, so give this a
2828 harmless name of " " (Why not "(anon)"?). */
2830 dbxout_type (type
, 1);
2831 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE
, 0, 0, 0);
2834 /* Prevent duplicate output of a typedef. */
2835 TREE_ASM_WRITTEN (decl
) = 1;
2840 if (DECL_HAS_VALUE_EXPR_P (decl
))
2841 decl
= DECL_VALUE_EXPR (decl
);
2843 /* PARM_DECLs go in their own separate chain and are output by
2844 dbxout_reg_parms and dbxout_parms, except for those that are
2845 disguised VAR_DECLs like Out parameters in Ada. */
2846 gcc_assert (TREE_CODE (decl
) == VAR_DECL
);
2848 /* ... fall through ... */
2852 /* Don't mention a variable that is external.
2853 Let the file that defines it describe it. */
2854 if (DECL_EXTERNAL (decl
))
2857 /* If the variable is really a constant
2858 and not written in memory, inform the debugger.
2860 ??? Why do we skip emitting the type and location in this case? */
2861 if (TREE_STATIC (decl
) && TREE_READONLY (decl
)
2862 && DECL_INITIAL (decl
) != 0
2863 && tree_fits_shwi_p (DECL_INITIAL (decl
))
2864 && ! TREE_ASM_WRITTEN (decl
)
2865 && (DECL_FILE_SCOPE_P (decl
)
2866 || TREE_CODE (DECL_CONTEXT (decl
)) == BLOCK
2867 || TREE_CODE (DECL_CONTEXT (decl
)) == NAMESPACE_DECL
)
2868 && TREE_PUBLIC (decl
) == 0)
2870 /* The sun4 assembler does not grok this. */
2872 if (TREE_CODE (TREE_TYPE (decl
)) == INTEGER_TYPE
2873 || TREE_CODE (TREE_TYPE (decl
)) == ENUMERAL_TYPE
)
2875 HOST_WIDE_INT ival
= TREE_INT_CST_LOW (DECL_INITIAL (decl
));
2877 dbxout_begin_complex_stabs ();
2878 dbxout_symbol_name (decl
, NULL
, 'c');
2881 dbxout_finish_complex_stabs (0, N_LSYM
, 0, 0, 0);
2882 DBXOUT_DECR_NESTING
;
2888 /* else it is something we handle like a normal variable. */
2890 decl_rtl
= dbxout_expand_expr (decl
);
2892 DBXOUT_DECR_NESTING_AND_RETURN (0);
2894 decl_rtl
= eliminate_regs (decl_rtl
, VOIDmode
, NULL_RTX
);
2895 #ifdef LEAF_REG_REMAP
2896 if (crtl
->uses_only_leaf_regs
)
2897 leaf_renumber_regs_insn (decl_rtl
);
2900 result
= dbxout_symbol_location (decl
, type
, 0, decl_rtl
);
2906 DBXOUT_DECR_NESTING
;
2910 /* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL.
2911 Add SUFFIX to its name, if SUFFIX is not 0.
2912 Describe the variable as residing in HOME
2913 (usually HOME is DECL_RTL (DECL), but not always).
2914 Returns 1 if the stab was really emitted. */
2917 dbxout_symbol_location (tree decl
, tree type
, const char *suffix
, rtx home
)
2920 stab_code_type code
;
2925 /* Don't mention a variable at all
2926 if it was completely optimized into nothingness.
2928 If the decl was from an inline function, then its rtl
2929 is not identically the rtl that was used in this
2930 particular compilation. */
2931 if (GET_CODE (home
) == SUBREG
)
2935 while (GET_CODE (value
) == SUBREG
)
2936 value
= SUBREG_REG (value
);
2939 if (REGNO (value
) >= FIRST_PSEUDO_REGISTER
)
2942 home
= alter_subreg (&home
, true);
2946 regno
= REGNO (home
);
2947 if (regno
>= FIRST_PSEUDO_REGISTER
)
2951 /* The kind-of-variable letter depends on where
2952 the variable is and on the scope of its name:
2953 G and N_GSYM for static storage and global scope,
2954 S for static storage and file scope,
2955 V for static storage and local scope,
2956 for those two, use N_LCSYM if data is in bss segment,
2957 N_STSYM if in data segment, N_FUN otherwise.
2958 (We used N_FUN originally, then changed to N_STSYM
2959 to please GDB. However, it seems that confused ld.
2960 Now GDB has been fixed to like N_FUN, says Kingdon.)
2961 no letter at all, and N_LSYM, for auto variable,
2962 r and N_RSYM for register variable. */
2964 if (MEM_P (home
) && GET_CODE (XEXP (home
, 0)) == SYMBOL_REF
)
2966 if (TREE_PUBLIC (decl
))
2971 if (NULL
!= dbxout_common_check (decl
, &offs
))
2980 addr
= XEXP (home
, 0);
2982 letter
= decl_function_context (decl
) ? 'V' : 'S';
2984 /* Some ports can transform a symbol ref into a label ref,
2985 because the symbol ref is too far away and has to be
2986 dumped into a constant pool. Alternatively, the symbol
2987 in the constant pool might be referenced by a different
2989 if (GET_CODE (addr
) == SYMBOL_REF
2990 && CONSTANT_POOL_ADDRESS_P (addr
))
2993 rtx tmp
= get_pool_constant_mark (addr
, &marked
);
2995 if (GET_CODE (tmp
) == SYMBOL_REF
)
2998 if (CONSTANT_POOL_ADDRESS_P (addr
))
2999 get_pool_constant_mark (addr
, &marked
);
3003 else if (GET_CODE (tmp
) == LABEL_REF
)
3009 /* If all references to the constant pool were optimized
3010 out, we just ignore the symbol. */
3015 /* This should be the same condition as in assemble_variable, but
3016 we don't have access to dont_output_data here. So, instead,
3017 we rely on the fact that error_mark_node initializers always
3018 end up in bss for C++ and never end up in bss for C. */
3019 if (DECL_INITIAL (decl
) == 0
3020 || (!strcmp (lang_hooks
.name
, "GNU C++")
3021 && DECL_INITIAL (decl
) == error_mark_node
))
3025 if (NULL
!= dbxout_common_check (decl
, &offs
))
3033 else if (DECL_IN_TEXT_SECTION (decl
))
3034 /* This is not quite right, but it's the closest
3035 of all the codes that Unix defines. */
3036 code
= DBX_STATIC_CONST_VAR_CODE
;
3039 /* Ultrix `as' seems to need this. */
3040 #ifdef DBX_STATIC_STAB_DATA_SECTION
3041 switch_to_section (data_section
);
3047 else if (regno
>= 0)
3051 number
= DBX_REGISTER_NUMBER (regno
);
3053 else if (MEM_P (home
)
3054 && (MEM_P (XEXP (home
, 0))
3055 || (REG_P (XEXP (home
, 0))
3056 && REGNO (XEXP (home
, 0)) != HARD_FRAME_POINTER_REGNUM
3057 && REGNO (XEXP (home
, 0)) != STACK_POINTER_REGNUM
3058 #if !HARD_FRAME_POINTER_IS_ARG_POINTER
3059 && REGNO (XEXP (home
, 0)) != ARG_POINTER_REGNUM
3062 /* If the value is indirect by memory or by a register
3063 that isn't the frame pointer
3064 then it means the object is variable-sized and address through
3065 that register or stack slot. DBX has no way to represent this
3066 so all we can do is output the variable as a pointer.
3067 If it's not a parameter, ignore it. */
3069 if (REG_P (XEXP (home
, 0)))
3073 if (REGNO (XEXP (home
, 0)) >= FIRST_PSEUDO_REGISTER
)
3075 number
= DBX_REGISTER_NUMBER (REGNO (XEXP (home
, 0)));
3080 /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
3081 We want the value of that CONST_INT. */
3082 number
= DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home
, 0), 0));
3085 /* Effectively do build_pointer_type, but don't cache this type,
3086 since it might be temporary whereas the type it points to
3087 might have been saved for inlining. */
3088 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
3089 type
= make_node (POINTER_TYPE
);
3090 TREE_TYPE (type
) = TREE_TYPE (decl
);
3092 else if (MEM_P (home
)
3093 && REG_P (XEXP (home
, 0)))
3096 number
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
3098 else if (MEM_P (home
)
3099 && GET_CODE (XEXP (home
, 0)) == PLUS
3100 && CONST_INT_P (XEXP (XEXP (home
, 0), 1)))
3103 /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
3104 We want the value of that CONST_INT. */
3105 number
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
3107 else if (MEM_P (home
)
3108 && GET_CODE (XEXP (home
, 0)) == CONST
)
3110 /* Handle an obscure case which can arise when optimizing and
3111 when there are few available registers. (This is *always*
3112 the case for i386/i486 targets). The RTL looks like
3113 (MEM (CONST ...)) even though this variable is a local `auto'
3114 or a local `register' variable. In effect, what has happened
3115 is that the reload pass has seen that all assignments and
3116 references for one such a local variable can be replaced by
3117 equivalent assignments and references to some static storage
3118 variable, thereby avoiding the need for a register. In such
3119 cases we're forced to lie to debuggers and tell them that
3120 this variable was itself `static'. */
3124 if (NULL
== dbxout_common_check (decl
, &offs
))
3125 addr
= XEXP (XEXP (home
, 0), 0);
3133 else if (GET_CODE (home
) == CONCAT
)
3137 /* If TYPE is not a COMPLEX_TYPE (it might be a RECORD_TYPE,
3138 for example), then there is no easy way to figure out
3139 what SUBTYPE should be. So, we give up. */
3140 if (TREE_CODE (type
) != COMPLEX_TYPE
)
3143 subtype
= TREE_TYPE (type
);
3145 /* If the variable's storage is in two parts,
3146 output each as a separate stab with a modified name. */
3147 if (WORDS_BIG_ENDIAN
)
3148 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 0));
3150 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 0));
3152 if (WORDS_BIG_ENDIAN
)
3153 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 1));
3155 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 1));
3159 /* Address might be a MEM, when DECL is a variable-sized object.
3160 Or it might be const0_rtx, meaning previous passes
3161 want us to ignore this variable. */
3164 /* Ok, start a symtab entry and output the variable name. */
3165 emit_pending_bincls_if_required ();
3168 #ifdef DBX_STATIC_BLOCK_START
3169 DBX_STATIC_BLOCK_START (asm_out_file
, code
);
3172 dbxout_begin_complex_stabs_noforcetext ();
3173 dbxout_symbol_name (decl
, suffix
, letter
);
3174 dbxout_type (type
, 0);
3175 dbxout_finish_complex_stabs (decl
, code
, addr
, 0, number
);
3177 #ifdef DBX_STATIC_BLOCK_END
3178 DBX_STATIC_BLOCK_END (asm_out_file
, code
);
3183 /* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
3184 Then output LETTER to indicate the kind of location the symbol has. */
3187 dbxout_symbol_name (tree decl
, const char *suffix
, int letter
)
3191 if (DECL_CONTEXT (decl
)
3192 && (TYPE_P (DECL_CONTEXT (decl
))
3193 || TREE_CODE (DECL_CONTEXT (decl
)) == NAMESPACE_DECL
))
3194 /* One slight hitch: if this is a VAR_DECL which is a class member
3195 or a namespace member, we must put out the mangled name instead of the
3196 DECL_NAME. Note also that static member (variable) names DO NOT begin
3197 with underscores in .stabs directives. */
3198 name
= DECL_ASSEMBLER_NAME (decl
);
3200 /* ...but if we're function-local, we don't want to include the junk
3201 added by ASM_FORMAT_PRIVATE_NAME. */
3202 name
= DECL_NAME (decl
);
3207 stabstr_S ("(anon)");
3217 /* Output the common block name for DECL in a stabs.
3219 Symbols in global common (.comm) get wrapped with an N_BCOMM/N_ECOMM pair
3220 around each group of symbols in the same .comm area. The N_GSYM stabs
3221 that are emitted only contain the offset in the common area. This routine
3222 emits the N_BCOMM and N_ECOMM stabs. */
3225 dbxout_common_name (tree decl
, const char *name
, stab_code_type op
)
3227 dbxout_begin_complex_stabs ();
3229 dbxout_finish_complex_stabs (decl
, op
, NULL_RTX
, NULL
, 0);
3232 /* Check decl to determine whether it is a VAR_DECL destined for storage in a
3233 common area. If it is, the return value will be a non-null string giving
3234 the name of the common storage block it will go into. If non-null, the
3235 value is the offset into the common block for that symbol's storage. */
3238 dbxout_common_check (tree decl
, int *value
)
3242 const char *name
= NULL
;
3244 /* If the decl isn't a VAR_DECL, or if it isn't static, or if
3245 it does not have a value (the offset into the common area), or if it
3246 is thread local (as opposed to global) then it isn't common, and shouldn't
3249 ??? DECL_THREAD_LOCAL_P check prevents problems with improper .stabs
3250 for thread-local symbols. Can be handled via same mechanism as used
3252 if (TREE_CODE (decl
) != VAR_DECL
3253 || !TREE_STATIC (decl
)
3254 || !DECL_HAS_VALUE_EXPR_P (decl
)
3255 || DECL_THREAD_LOCAL_P (decl
)
3259 home
= DECL_RTL (decl
);
3260 if (home
== NULL_RTX
|| GET_CODE (home
) != MEM
)
3263 sym_addr
= dbxout_expand_expr (DECL_VALUE_EXPR (decl
));
3264 if (sym_addr
== NULL_RTX
|| GET_CODE (sym_addr
) != MEM
)
3267 sym_addr
= XEXP (sym_addr
, 0);
3268 if (GET_CODE (sym_addr
) == CONST
)
3269 sym_addr
= XEXP (sym_addr
, 0);
3270 if ((GET_CODE (sym_addr
) == SYMBOL_REF
|| GET_CODE (sym_addr
) == PLUS
)
3271 && DECL_INITIAL (decl
) == 0)
3274 /* We have a sym that will go into a common area, meaning that it
3275 will get storage reserved with a .comm/.lcomm assembler pseudo-op.
3277 Determine name of common area this symbol will be an offset into,
3278 and offset into that area. Also retrieve the decl for the area
3279 that the symbol is offset into. */
3282 switch (GET_CODE (sym_addr
))
3285 if (CONST_INT_P (XEXP (sym_addr
, 0)))
3288 targetm
.strip_name_encoding (XSTR (XEXP (sym_addr
, 1), 0));
3289 *value
= INTVAL (XEXP (sym_addr
, 0));
3290 cdecl = SYMBOL_REF_DECL (XEXP (sym_addr
, 1));
3295 targetm
.strip_name_encoding (XSTR (XEXP (sym_addr
, 0), 0));
3296 *value
= INTVAL (XEXP (sym_addr
, 1));
3297 cdecl = SYMBOL_REF_DECL (XEXP (sym_addr
, 0));
3302 name
= targetm
.strip_name_encoding (XSTR (sym_addr
, 0));
3304 cdecl = SYMBOL_REF_DECL (sym_addr
);
3308 error ("common symbol debug info is not structured as "
3312 /* Check area common symbol is offset into. If this is not public, then
3313 it is not a symbol in a common block. It must be a .lcomm symbol, not
3315 if (cdecl == NULL
|| !TREE_PUBLIC (cdecl))
3324 /* Output definitions of all the decls in a chain. Return nonzero if
3325 anything was output */
3328 dbxout_syms (tree syms
)
3331 const char *comm_prev
= NULL
;
3332 tree syms_prev
= NULL
;
3336 int temp
, copen
, cclos
;
3337 const char *comm_new
;
3339 /* Check for common symbol, and then progression into a new/different
3340 block of common symbols. Emit closing/opening common bracket if
3342 comm_new
= dbxout_common_check (syms
, &temp
);
3343 copen
= comm_new
!= NULL
3344 && (comm_prev
== NULL
|| strcmp (comm_new
, comm_prev
));
3345 cclos
= comm_prev
!= NULL
3346 && (comm_new
== NULL
|| strcmp (comm_new
, comm_prev
));
3348 dbxout_common_name (syms_prev
, comm_prev
, N_ECOMM
);
3351 dbxout_common_name (syms
, comm_new
, N_BCOMM
);
3354 comm_prev
= comm_new
;
3356 result
+= dbxout_symbol (syms
, 1);
3357 syms
= DECL_CHAIN (syms
);
3360 if (comm_prev
!= NULL
)
3361 dbxout_common_name (syms_prev
, comm_prev
, N_ECOMM
);
3366 /* The following two functions output definitions of function parameters.
3367 Each parameter gets a definition locating it in the parameter list.
3368 Each parameter that is a register variable gets a second definition
3369 locating it in the register.
3371 Printing or argument lists in gdb uses the definitions that
3372 locate in the parameter list. But reference to the variable in
3373 expressions uses preferentially the definition as a register. */
3375 /* Output definitions, referring to storage in the parmlist,
3376 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
3379 dbxout_parms (tree parms
)
3382 emit_pending_bincls_if_required ();
3384 for (; parms
; parms
= DECL_CHAIN (parms
))
3385 if (DECL_NAME (parms
)
3386 && TREE_TYPE (parms
) != error_mark_node
3387 && DECL_RTL_SET_P (parms
)
3388 && DECL_INCOMING_RTL (parms
))
3392 stab_code_type code
;
3395 /* Perform any necessary register eliminations on the parameter's rtl,
3396 so that the debugging output will be accurate. */
3397 DECL_INCOMING_RTL (parms
)
3398 = eliminate_regs (DECL_INCOMING_RTL (parms
), VOIDmode
, NULL_RTX
);
3399 SET_DECL_RTL (parms
,
3400 eliminate_regs (DECL_RTL (parms
), VOIDmode
, NULL_RTX
));
3401 #ifdef LEAF_REG_REMAP
3402 if (crtl
->uses_only_leaf_regs
)
3404 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms
));
3405 leaf_renumber_regs_insn (DECL_RTL (parms
));
3409 if (PARM_PASSED_IN_MEMORY (parms
))
3411 rtx inrtl
= XEXP (DECL_INCOMING_RTL (parms
), 0);
3413 /* ??? Here we assume that the parm address is indexed
3414 off the frame pointer or arg pointer.
3415 If that is not true, we produce meaningless results,
3416 but do not crash. */
3417 if (GET_CODE (inrtl
) == PLUS
3418 && CONST_INT_P (XEXP (inrtl
, 1)))
3419 number
= INTVAL (XEXP (inrtl
, 1));
3424 number
= DEBUGGER_ARG_OFFSET (number
, inrtl
);
3427 /* It is quite tempting to use TREE_TYPE (parms) instead
3428 of DECL_ARG_TYPE (parms) for the eff_type, so that gcc
3429 reports the actual type of the parameter, rather than
3430 the promoted type. This certainly makes GDB's life
3431 easier, at least for some ports. The change is a bad
3432 idea however, since GDB expects to be able access the
3433 type without performing any conversions. So for
3434 example, if we were passing a float to an unprototyped
3435 function, gcc will store a double on the stack, but if
3436 we emit a stab saying the type is a float, then gdb
3437 will only read in a single value, and this will produce
3438 an erroneous value. */
3439 eff_type
= DECL_ARG_TYPE (parms
);
3441 else if (REG_P (DECL_RTL (parms
)))
3445 /* Parm passed in registers and lives in registers or nowhere. */
3446 code
= DBX_REGPARM_STABS_CODE
;
3447 letter
= DBX_REGPARM_STABS_LETTER
;
3449 /* For parms passed in registers, it is better to use the
3450 declared type of the variable, not the type it arrived in. */
3451 eff_type
= TREE_TYPE (parms
);
3453 /* If parm lives in a register, use that register; pretend
3454 the parm was passed there. It would be more consistent
3455 to describe the register where the parm was passed, but
3456 in practice that register usually holds something else.
3457 If the parm lives nowhere, use the register where it
3459 if (REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
3460 best_rtl
= DECL_RTL (parms
);
3461 else if (GET_CODE (DECL_INCOMING_RTL (parms
)) == PARALLEL
)
3462 best_rtl
= XEXP (XVECEXP (DECL_INCOMING_RTL (parms
), 0, 0), 0);
3464 best_rtl
= DECL_INCOMING_RTL (parms
);
3466 number
= DBX_REGISTER_NUMBER (REGNO (best_rtl
));
3468 else if (MEM_P (DECL_RTL (parms
))
3469 && REG_P (XEXP (DECL_RTL (parms
), 0))
3470 && REGNO (XEXP (DECL_RTL (parms
), 0)) != HARD_FRAME_POINTER_REGNUM
3471 && REGNO (XEXP (DECL_RTL (parms
), 0)) != STACK_POINTER_REGNUM
3472 #if !HARD_FRAME_POINTER_IS_ARG_POINTER
3473 && REGNO (XEXP (DECL_RTL (parms
), 0)) != ARG_POINTER_REGNUM
3477 /* Parm was passed via invisible reference.
3478 That is, its address was passed in a register.
3479 Output it as if it lived in that register.
3480 The debugger will know from the type
3481 that it was actually passed by invisible reference. */
3483 code
= DBX_REGPARM_STABS_CODE
;
3485 /* GDB likes this marked with a special letter. */
3486 letter
= (use_gnu_debug_info_extensions
3487 ? 'a' : DBX_REGPARM_STABS_LETTER
);
3488 eff_type
= TREE_TYPE (parms
);
3490 /* DECL_RTL looks like (MEM (REG...). Get the register number.
3491 If it is an unallocated pseudo-reg, then use the register where
3492 it was passed instead.
3493 ??? Why is DBX_REGISTER_NUMBER not used here? */
3495 if (REGNO (XEXP (DECL_RTL (parms
), 0)) < FIRST_PSEUDO_REGISTER
)
3496 number
= REGNO (XEXP (DECL_RTL (parms
), 0));
3498 number
= REGNO (DECL_INCOMING_RTL (parms
));
3500 else if (MEM_P (DECL_RTL (parms
))
3501 && MEM_P (XEXP (DECL_RTL (parms
), 0)))
3503 /* Parm was passed via invisible reference, with the reference
3504 living on the stack. DECL_RTL looks like
3505 (MEM (MEM (PLUS (REG ...) (CONST_INT ...)))) or it
3506 could look like (MEM (MEM (REG))). */
3510 eff_type
= TREE_TYPE (parms
);
3512 if (!REG_P (XEXP (XEXP (DECL_RTL (parms
), 0), 0)))
3513 number
= INTVAL (XEXP (XEXP (XEXP (DECL_RTL (parms
), 0), 0), 1));
3517 number
= DEBUGGER_ARG_OFFSET (number
,
3518 XEXP (XEXP (DECL_RTL (parms
), 0), 0));
3520 else if (MEM_P (DECL_RTL (parms
))
3521 && XEXP (DECL_RTL (parms
), 0) != const0_rtx
3522 /* ??? A constant address for a parm can happen
3523 when the reg it lives in is equiv to a constant in memory.
3524 Should make this not happen, after 2.4. */
3525 && ! CONSTANT_P (XEXP (DECL_RTL (parms
), 0)))
3527 /* Parm was passed in registers but lives on the stack. */
3531 eff_type
= TREE_TYPE (parms
);
3533 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
3534 in which case we want the value of that CONST_INT,
3536 in which case we use a value of zero. */
3537 if (!REG_P (XEXP (DECL_RTL (parms
), 0)))
3538 number
= INTVAL (XEXP (XEXP (DECL_RTL (parms
), 0), 1));
3542 /* Make a big endian correction if the mode of the type of the
3543 parameter is not the same as the mode of the rtl. */
3544 if (BYTES_BIG_ENDIAN
3545 && TYPE_MODE (TREE_TYPE (parms
)) != GET_MODE (DECL_RTL (parms
))
3546 && GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms
))) < UNITS_PER_WORD
)
3547 number
+= (GET_MODE_SIZE (GET_MODE (DECL_RTL (parms
)))
3548 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms
))));
3551 /* ??? We don't know how to represent this argument. */
3554 dbxout_begin_complex_stabs ();
3556 if (DECL_NAME (parms
))
3558 stabstr_I (DECL_NAME (parms
));
3562 stabstr_S ("(anon):");
3564 dbxout_type (eff_type
, 0);
3565 dbxout_finish_complex_stabs (parms
, code
, 0, 0, number
);
3567 DBXOUT_DECR_NESTING
;
3570 /* Output definitions for the places where parms live during the function,
3571 when different from where they were passed, when the parms were passed
3574 It is not useful to do this for parms passed in registers
3575 that live during the function in different registers, because it is
3576 impossible to look in the passed register for the passed value,
3577 so we use the within-the-function register to begin with.
3579 PARMS is a chain of PARM_DECL nodes. */
3582 dbxout_reg_parms (tree parms
)
3586 for (; parms
; parms
= DECL_CHAIN (parms
))
3587 if (DECL_NAME (parms
) && PARM_PASSED_IN_MEMORY (parms
))
3589 /* Report parms that live in registers during the function
3590 but were passed in memory. */
3591 if (REG_P (DECL_RTL (parms
))
3592 && REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
3593 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
3594 0, DECL_RTL (parms
));
3595 else if (GET_CODE (DECL_RTL (parms
)) == CONCAT
)
3596 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
3597 0, DECL_RTL (parms
));
3598 /* Report parms that live in memory but not where they were passed. */
3599 else if (MEM_P (DECL_RTL (parms
))
3600 && ! rtx_equal_p (DECL_RTL (parms
), DECL_INCOMING_RTL (parms
)))
3601 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
3602 0, DECL_RTL (parms
));
3604 DBXOUT_DECR_NESTING
;
3607 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
3608 output definitions of those names, in raw form */
3611 dbxout_args (tree args
)
3616 dbxout_type (TREE_VALUE (args
), 0);
3617 args
= TREE_CHAIN (args
);
3621 #if defined (DBX_DEBUGGING_INFO)
3623 /* Subroutine of dbxout_block. Emit an N_LBRAC stab referencing LABEL.
3624 BEGIN_LABEL is the name of the beginning of the function, which may
3627 dbx_output_lbrac (const char *label
,
3628 const char *begin_label ATTRIBUTE_UNUSED
)
3630 dbxout_begin_stabn (N_LBRAC
);
3631 if (DBX_BLOCKS_FUNCTION_RELATIVE
)
3632 dbxout_stab_value_label_diff (label
, begin_label
);
3634 dbxout_stab_value_label (label
);
3637 /* Subroutine of dbxout_block. Emit an N_RBRAC stab referencing LABEL.
3638 BEGIN_LABEL is the name of the beginning of the function, which may
3641 dbx_output_rbrac (const char *label
,
3642 const char *begin_label ATTRIBUTE_UNUSED
)
3644 dbxout_begin_stabn (N_RBRAC
);
3645 if (DBX_BLOCKS_FUNCTION_RELATIVE
)
3646 dbxout_stab_value_label_diff (label
, begin_label
);
3648 dbxout_stab_value_label (label
);
3651 /* Output everything about a symbol block (a BLOCK node
3652 that represents a scope level),
3653 including recursive output of contained blocks.
3655 BLOCK is the BLOCK node.
3656 DEPTH is its depth within containing symbol blocks.
3657 ARGS is usually zero; but for the outermost block of the
3658 body of a function, it is a chain of PARM_DECLs for the function parameters.
3659 We output definitions of all the register parms
3660 as if they were local variables of that block.
3662 If -g1 was used, we count blocks just the same, but output nothing
3663 except for the outermost block.
3665 Actually, BLOCK may be several blocks chained together.
3666 We handle them all in sequence. */
3669 dbxout_block (tree block
, int depth
, tree args
)
3671 char begin_label
[20];
3672 /* Reference current function start using LFBB. */
3673 ASM_GENERATE_INTERNAL_LABEL (begin_label
, "LFBB", scope_labelno
);
3677 /* Ignore blocks never expanded or otherwise marked as real. */
3678 if (TREE_USED (block
) && TREE_ASM_WRITTEN (block
))
3681 int blocknum
= BLOCK_NUMBER (block
);
3683 /* In dbx format, the syms of a block come before the N_LBRAC.
3684 If nothing is output, we don't need the N_LBRAC, either. */
3686 if (debug_info_level
!= DINFO_LEVEL_TERSE
|| depth
== 0)
3687 did_output
= dbxout_syms (BLOCK_VARS (block
));
3689 dbxout_reg_parms (args
);
3691 /* Now output an N_LBRAC symbol to represent the beginning of
3692 the block. Use the block's tree-walk order to generate
3693 the assembler symbols LBBn and LBEn
3694 that final will define around the code in this block. */
3698 const char *scope_start
;
3701 /* The outermost block doesn't get LBB labels; use
3702 the LFBB local symbol emitted by dbxout_begin_prologue. */
3703 scope_start
= begin_label
;
3706 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBB", blocknum
);
3710 dbx_output_lbrac (scope_start
, begin_label
);
3713 /* Output the subblocks. */
3714 dbxout_block (BLOCK_SUBBLOCKS (block
), depth
+ 1, NULL_TREE
);
3716 /* Refer to the marker for the end of the block. */
3721 /* The outermost block doesn't get LBE labels;
3722 use the "scope" label which will be emitted
3723 by dbxout_function_end. */
3724 ASM_GENERATE_INTERNAL_LABEL (buf
, "Lscope", scope_labelno
);
3726 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBE", blocknum
);
3728 dbx_output_rbrac (buf
, begin_label
);
3731 block
= BLOCK_CHAIN (block
);
3735 /* Output the information about a function and its arguments and result.
3736 Usually this follows the function's code,
3737 but on some systems, it comes before. */
3740 dbxout_begin_function (tree decl
)
3742 int saved_tree_used1
;
3744 saved_tree_used1
= TREE_USED (decl
);
3745 TREE_USED (decl
) = 1;
3746 if (DECL_NAME (DECL_RESULT (decl
)) != 0)
3748 int saved_tree_used2
= TREE_USED (DECL_RESULT (decl
));
3749 TREE_USED (DECL_RESULT (decl
)) = 1;
3750 dbxout_symbol (decl
, 0);
3751 TREE_USED (DECL_RESULT (decl
)) = saved_tree_used2
;
3754 dbxout_symbol (decl
, 0);
3755 TREE_USED (decl
) = saved_tree_used1
;
3757 dbxout_parms (DECL_ARGUMENTS (decl
));
3758 if (DECL_NAME (DECL_RESULT (decl
)) != 0)
3759 dbxout_symbol (DECL_RESULT (decl
), 1);
3761 #endif /* DBX_DEBUGGING_INFO */
3763 #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */
3765 /* Record an element in the table of global destructors. SYMBOL is
3766 a SYMBOL_REF of the function to be called; PRIORITY is a number
3767 between 0 and MAX_INIT_PRIORITY. */
3770 default_stabs_asm_out_destructor (rtx symbol ATTRIBUTE_UNUSED
,
3771 int priority ATTRIBUTE_UNUSED
)
3773 #if defined DBX_DEBUGGING_INFO || defined XCOFF_DEBUGGING_INFO
3774 /* Tell GNU LD that this is part of the static destructor set.
3775 This will work for any system that uses stabs, most usefully
3777 dbxout_begin_simple_stabs ("___DTOR_LIST__", 22 /* N_SETT */);
3778 dbxout_stab_value_label (XSTR (symbol
, 0));
3780 sorry ("global destructors not supported on this target");
3784 /* Likewise for global constructors. */
3787 default_stabs_asm_out_constructor (rtx symbol ATTRIBUTE_UNUSED
,
3788 int priority ATTRIBUTE_UNUSED
)
3790 #if defined DBX_DEBUGGING_INFO || defined XCOFF_DEBUGGING_INFO
3791 /* Tell GNU LD that this is part of the static destructor set.
3792 This will work for any system that uses stabs, most usefully
3794 dbxout_begin_simple_stabs ("___CTOR_LIST__", 22 /* N_SETT */);
3795 dbxout_stab_value_label (XSTR (symbol
, 0));
3797 sorry ("global constructors not supported on this target");
3801 #include "gt-dbxout.h"