1 /* Output dbx-format symbol table information from GNU compiler.
2 Copyright (C) 1987-2017 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
21 /* Output dbx-format symbol table data.
22 This consists of many symbol table entries, each of them
23 a .stabs assembler pseudo-op with four operands:
24 a "name" which is really a description of one symbol and its type,
25 a "code", which is a symbol defined in stab.h whose name starts with N_,
26 an unused operand always 0,
27 and a "value" which is an address or an offset.
28 The name is enclosed in doublequote characters.
30 Each function, variable, typedef, and structure tag
31 has a symbol table entry to define it.
32 The beginning and end of each level of name scoping within
33 a function are also marked by special symbol table entries.
35 The "name" consists of the symbol name, a colon, a kind-of-symbol letter,
36 and a data type number. The data type number may be followed by
37 "=" and a type definition; normally this will happen the first time
38 the type number is mentioned. The type definition may refer to
39 other types by number, and those type numbers may be followed
40 by "=" and nested definitions.
42 This can make the "name" quite long.
43 When a name is more than 80 characters, we split the .stabs pseudo-op
44 into two .stabs pseudo-ops, both sharing the same "code" and "value".
45 The first one is marked as continued with a double-backslash at the
48 The kind-of-symbol letter distinguished function names from global
49 variables from file-scope variables from parameters from auto
50 variables in memory from typedef names from register variables.
53 The "code" is mostly redundant with the kind-of-symbol letter
54 that goes in the "name", but not entirely: for symbols located
55 in static storage, the "code" says which segment the address is in,
56 which controls how it is relocated.
58 The "value" for a symbol in static storage
59 is the core address of the symbol (actually, the assembler
60 label for the symbol). For a symbol located in a stack slot
61 it is the stack offset; for one in a register, the register number.
62 For a typedef symbol, it is zero.
64 If DEBUG_SYMS_TEXT is defined, all debugging symbols must be
65 output while in the text section.
67 For more on data type definitions, see `dbxout_type'. */
71 #include "coretypes.h"
78 #include "stringpool.h"
79 #include "insn-config.h"
82 #include "diagnostic-core.h"
83 #include "fold-const.h"
85 #include "stor-layout.h"
91 #include "common/common-target.h"
92 #include "langhooks.h"
95 #ifdef XCOFF_DEBUGGING_INFO
100 # ifdef XCOFF_DEBUGGING_INFO
101 # define ASM_STABS_OP "\t.stabx\t"
103 # define ASM_STABS_OP "\t.stabs\t"
108 #define ASM_STABN_OP "\t.stabn\t"
112 #define ASM_STABD_OP "\t.stabd\t"
115 #ifndef DBX_TYPE_DECL_STABS_CODE
116 #define DBX_TYPE_DECL_STABS_CODE N_LSYM
119 #ifndef DBX_STATIC_CONST_VAR_CODE
120 #define DBX_STATIC_CONST_VAR_CODE N_FUN
123 #ifndef DBX_REGPARM_STABS_CODE
124 #define DBX_REGPARM_STABS_CODE N_RSYM
127 #ifndef DBX_REGPARM_STABS_LETTER
128 #define DBX_REGPARM_STABS_LETTER 'P'
131 #ifndef NO_DBX_FUNCTION_END
132 #define NO_DBX_FUNCTION_END 0
135 #ifndef NO_DBX_BNSYM_ENSYM
136 #define NO_DBX_BNSYM_ENSYM 0
139 #ifndef NO_DBX_MAIN_SOURCE_DIRECTORY
140 #define NO_DBX_MAIN_SOURCE_DIRECTORY 0
143 #ifndef DBX_BLOCKS_FUNCTION_RELATIVE
144 #define DBX_BLOCKS_FUNCTION_RELATIVE 0
147 #ifndef DBX_LINES_FUNCTION_RELATIVE
148 #define DBX_LINES_FUNCTION_RELATIVE 0
151 #ifndef DBX_CONTIN_LENGTH
152 #define DBX_CONTIN_LENGTH 80
155 #ifndef DBX_CONTIN_CHAR
156 #define DBX_CONTIN_CHAR '\\'
159 enum typestatus
{TYPE_UNSEEN
, TYPE_XREF
, TYPE_DEFINED
};
161 /* Structure recording information about a C data type.
162 The status element says whether we have yet output
163 the definition of the type. TYPE_XREF says we have
164 output it as a cross-reference only.
165 The file_number and type_number elements are used if DBX_USE_BINCL
168 struct GTY(()) typeinfo
{
169 enum typestatus status
;
174 /* Vector recording information about C data types.
175 When we first notice a data type (a tree node),
176 we assign it a number using next_type_number.
177 That is its index in this vector. */
179 static GTY ((length ("typevec_len"))) struct typeinfo
*typevec
;
181 /* Number of elements of space allocated in `typevec'. */
183 static GTY(()) int typevec_len
;
185 /* In dbx output, each type gets a unique number.
186 This is the number for the next type output.
187 The number, once assigned, is in the TYPE_SYMTAB_ADDRESS field. */
189 static GTY(()) int next_type_number
;
191 /* The C front end may call dbxout_symbol before dbxout_init runs.
192 We save all such decls in this list and output them when we get
195 static GTY(()) tree preinit_symbols
;
197 enum binclstatus
{BINCL_NOT_REQUIRED
, BINCL_PENDING
, BINCL_PROCESSED
};
199 /* When using N_BINCL in dbx output, each type number is actually a
200 pair of the file number and the type number within the file.
201 This is a stack of input files. */
205 struct dbx_file
*next
;
207 int next_type_number
;
208 enum binclstatus bincl_status
; /* Keep track of lazy bincl. */
209 const char *pending_bincl_name
; /* Name of bincl. */
210 struct dbx_file
*prev
; /* Chain to traverse all pending bincls. */
213 /* This is the top of the stack.
215 This is not saved for PCH, because restoring a PCH should not change it.
216 next_file_number does have to be saved, because the PCH may use some
217 file numbers; however, just before restoring a PCH, next_file_number
218 should always be 0 because we should not have needed any file numbers
221 #if (defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)) \
222 && defined (DBX_USE_BINCL)
223 static struct dbx_file
*current_file
;
226 /* This is the next file number to use. */
228 static GTY(()) int next_file_number
;
230 /* A counter for dbxout_function_end. */
232 static GTY(()) int scope_labelno
;
234 /* A counter for dbxout_source_line. */
236 static GTY(()) int dbxout_source_line_counter
;
238 /* Number for the next N_SOL filename stabs label. The number 0 is reserved
239 for the N_SO filename stabs label. */
241 static GTY(()) int source_label_number
= 1;
243 /* Last source file name mentioned in a NOTE insn. */
245 static GTY(()) const char *lastfile
;
247 /* Last line number mentioned in a NOTE insn. */
249 static GTY(()) unsigned int lastlineno
;
251 /* Used by PCH machinery to detect if 'lastfile' should be reset to
253 static GTY(()) int lastfile_is_base
;
255 /* Typical USG systems don't have stab.h, and they also have
256 no use for DBX-format debugging info. */
258 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
261 /* If zero then there is no pending BINCL. */
262 static int pending_bincls
= 0;
265 /* The original input file name. */
266 static const char *base_input_file
;
268 #ifdef DEBUG_SYMS_TEXT
269 #define FORCE_TEXT switch_to_section (current_function_section ())
276 /* 1 if PARM is passed to this function in memory. */
278 #define PARM_PASSED_IN_MEMORY(PARM) \
279 (MEM_P (DECL_INCOMING_RTL (PARM)))
281 /* A C expression for the integer offset value of an automatic variable
282 (N_LSYM) having address X (an RTX). */
283 #ifndef DEBUGGER_AUTO_OFFSET
284 #define DEBUGGER_AUTO_OFFSET(X) \
285 (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
288 /* A C expression for the integer offset value of an argument (N_PSYM)
289 having address X (an RTX). The nominal offset is OFFSET.
290 Note that we use OFFSET + 0 here to avoid the self-assign warning
291 when the macro is called in a context like
292 number = DEBUGGER_ARG_OFFSET(number, X) */
293 #ifndef DEBUGGER_ARG_OFFSET
294 #define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET + 0)
297 /* This obstack holds the stab string currently being constructed. We
298 build it up here, then write it out, so we can split long lines up
299 properly (see dbxout_finish_complex_stabs). */
300 static struct obstack stabstr_ob
;
301 static size_t stabstr_last_contin_point
;
304 static void emit_bincl_stab (const char *c
);
305 static void emit_pending_bincls (void);
307 static inline void emit_pending_bincls_if_required (void);
309 static void dbxout_init (const char *);
311 static void dbxout_finish (const char *);
312 static void dbxout_start_source_file (unsigned, const char *);
313 static void dbxout_end_source_file (unsigned);
314 static void dbxout_typedefs (tree
);
315 static void dbxout_type_index (tree
);
316 static void dbxout_args (tree
);
317 static void dbxout_type_fields (tree
);
318 static void dbxout_type_method_1 (tree
);
319 static void dbxout_type_methods (tree
);
320 static void dbxout_range_type (tree
, tree
, tree
);
321 static void dbxout_type (tree
, int);
322 static bool print_int_cst_bounds_in_octal_p (tree
, tree
, tree
);
323 static bool is_fortran (void);
324 static void dbxout_type_name (tree
);
325 static void dbxout_class_name_qualifiers (tree
);
326 static int dbxout_symbol_location (tree
, tree
, const char *, rtx
);
327 static void dbxout_symbol_name (tree
, const char *, int);
328 static void dbxout_common_name (tree
, const char *, stab_code_type
);
329 static const char *dbxout_common_check (tree
, int *);
330 static void dbxout_early_global_decl (tree
);
331 static void dbxout_late_global_decl (tree
);
332 static void dbxout_type_decl (tree
, int);
333 static void dbxout_handle_pch (unsigned);
334 static void debug_free_queue (void);
336 /* The debug hooks structure. */
337 #if defined (DBX_DEBUGGING_INFO)
339 static void dbxout_source_line (unsigned int, unsigned int, const char *,
341 static void dbxout_switch_text_section (void);
342 static void dbxout_begin_prologue (unsigned int, unsigned int, const char *);
343 static void dbxout_source_file (const char *);
344 static void dbxout_function_end (tree
);
345 static void dbxout_begin_function (tree
);
346 static void dbxout_begin_block (unsigned, unsigned);
347 static void dbxout_end_block (unsigned, unsigned);
348 static void dbxout_function_decl (tree
);
350 const struct gcc_debug_hooks dbx_debug_hooks
=
354 debug_nothing_charstar
,
356 debug_nothing_int_charstar
,
357 debug_nothing_int_charstar
,
358 dbxout_start_source_file
,
359 dbxout_end_source_file
,
362 debug_true_const_tree
, /* ignore_block */
363 dbxout_source_line
, /* source_line */
364 dbxout_begin_prologue
, /* begin_prologue */
365 debug_nothing_int_charstar
, /* end_prologue */
366 debug_nothing_int_charstar
, /* begin_epilogue */
367 debug_nothing_int_charstar
, /* end_epilogue */
368 #ifdef DBX_FUNCTION_FIRST
369 dbxout_begin_function
,
371 debug_nothing_tree
, /* begin_function */
373 debug_nothing_int
, /* end_function */
374 debug_nothing_tree
, /* register_main_translation_unit */
375 dbxout_function_decl
,
376 dbxout_early_global_decl
, /* early_global_decl */
377 dbxout_late_global_decl
, /* late_global_decl */
378 dbxout_type_decl
, /* type_decl */
379 debug_nothing_tree_tree_tree_bool_bool
,/* imported_module_or_decl */
380 debug_false_tree_charstarstar_uhwistar
,/* die_ref_for_decl */
381 debug_nothing_tree_charstar_uhwi
, /* register_external_die */
382 debug_nothing_tree
, /* deferred_inline_function */
383 debug_nothing_tree
, /* outlining_inline_function */
384 debug_nothing_rtx_code_label
, /* label */
385 dbxout_handle_pch
, /* handle_pch */
386 debug_nothing_rtx_insn
, /* var_location */
387 debug_nothing_tree
, /* size_function */
388 dbxout_switch_text_section
, /* switch_text_section */
389 debug_nothing_tree_tree
, /* set_name */
390 0, /* start_end_main_source_file */
391 TYPE_SYMTAB_IS_ADDRESS
/* tree_type_symtab_field */
393 #endif /* DBX_DEBUGGING_INFO */
395 #if defined (XCOFF_DEBUGGING_INFO)
396 const struct gcc_debug_hooks xcoff_debug_hooks
=
400 debug_nothing_charstar
,
402 debug_nothing_int_charstar
,
403 debug_nothing_int_charstar
,
404 dbxout_start_source_file
,
405 dbxout_end_source_file
,
406 xcoffout_begin_block
,
408 debug_true_const_tree
, /* ignore_block */
409 xcoffout_source_line
,
410 xcoffout_begin_prologue
, /* begin_prologue */
411 debug_nothing_int_charstar
, /* end_prologue */
412 debug_nothing_int_charstar
, /* begin_epilogue */
413 xcoffout_end_epilogue
,
414 debug_nothing_tree
, /* begin_function */
415 xcoffout_end_function
,
416 debug_nothing_tree
, /* register_main_translation_unit */
417 debug_nothing_tree
, /* function_decl */
418 dbxout_early_global_decl
, /* early_global_decl */
419 dbxout_late_global_decl
, /* late_global_decl */
420 dbxout_type_decl
, /* type_decl */
421 debug_nothing_tree_tree_tree_bool_bool
,/* imported_module_or_decl */
422 debug_false_tree_charstarstar_uhwistar
,/* die_ref_for_decl */
423 debug_nothing_tree_charstar_uhwi
, /* register_external_die */
424 debug_nothing_tree
, /* deferred_inline_function */
425 debug_nothing_tree
, /* outlining_inline_function */
426 debug_nothing_rtx_code_label
, /* label */
427 dbxout_handle_pch
, /* handle_pch */
428 debug_nothing_rtx_insn
, /* var_location */
429 debug_nothing_tree
, /* size_function */
430 debug_nothing_void
, /* switch_text_section */
431 debug_nothing_tree_tree
, /* set_name */
432 0, /* start_end_main_source_file */
433 TYPE_SYMTAB_IS_ADDRESS
/* tree_type_symtab_field */
435 #endif /* XCOFF_DEBUGGING_INFO */
437 /* Numeric formatting helper macro. Note that this does not handle
439 #define NUMBER_FMT_LOOP(P, NUM, BASE) \
442 int digit = NUM % BASE; \
444 *--P = digit + '0'; \
448 /* Utility: write a decimal integer NUM to asm_out_file. */
453 char *p
= buf
+ sizeof buf
;
458 putc ('0', asm_out_file
);
463 putc ('-', asm_out_file
);
469 NUMBER_FMT_LOOP (p
, unum
, 10);
471 while (p
< buf
+ sizeof buf
)
473 putc (*p
, asm_out_file
);
479 /* Primitives for emitting simple stabs directives. All other stabs
480 routines should use these functions instead of directly emitting
481 stabs. They are exported because machine-dependent code may need
482 to invoke them, e.g. in a DBX_OUTPUT_* macro whose definition
483 forwards to code in CPU.c. */
485 /* The following functions should all be called immediately after one
486 of the dbxout_begin_stab* functions (below). They write out
487 various things as the value of a stab. */
489 /* Write out a literal zero as the value of a stab. */
491 dbxout_stab_value_zero (void)
493 fputs ("0\n", asm_out_file
);
496 /* Write out the label LABEL as the value of a stab. */
498 dbxout_stab_value_label (const char *label
)
500 assemble_name (asm_out_file
, label
);
501 putc ('\n', asm_out_file
);
504 /* Write out the difference of two labels, LABEL - BASE, as the value
507 dbxout_stab_value_label_diff (const char *label
, const char *base
)
509 assemble_name (asm_out_file
, label
);
510 putc ('-', asm_out_file
);
511 assemble_name (asm_out_file
, base
);
512 putc ('\n', asm_out_file
);
515 /* Write out an internal label as the value of a stab, and immediately
516 emit that internal label. This should be used only when
517 dbxout_stabd will not work. STEM is the name stem of the label,
518 COUNTERP is a pointer to a counter variable which will be used to
519 guarantee label uniqueness. */
521 dbxout_stab_value_internal_label (const char *stem
, int *counterp
)
524 int counter
= counterp
? (*counterp
)++ : 0;
526 ASM_GENERATE_INTERNAL_LABEL (label
, stem
, counter
);
527 dbxout_stab_value_label (label
);
528 targetm
.asm_out
.internal_label (asm_out_file
, stem
, counter
);
531 /* Write out the difference between BASE and an internal label as the
532 value of a stab, and immediately emit that internal label. STEM and
533 COUNTERP are as for dbxout_stab_value_internal_label. */
535 dbxout_stab_value_internal_label_diff (const char *stem
, int *counterp
,
539 int counter
= counterp
? (*counterp
)++ : 0;
541 ASM_GENERATE_INTERNAL_LABEL (label
, stem
, counter
);
542 dbxout_stab_value_label_diff (label
, base
);
543 targetm
.asm_out
.internal_label (asm_out_file
, stem
, counter
);
546 /* The following functions produce specific kinds of stab directives. */
548 /* Write a .stabd directive with type STYPE and desc SDESC to asm_out_file. */
550 dbxout_stabd (int stype
, int sdesc
)
552 fputs (ASM_STABD_OP
, asm_out_file
);
554 fputs (",0,", asm_out_file
);
556 putc ('\n', asm_out_file
);
559 /* Write a .stabn directive with type STYPE. This function stops
560 short of emitting the value field, which is the responsibility of
561 the caller (normally it will be either a symbol or the difference
565 dbxout_begin_stabn (int stype
)
567 fputs (ASM_STABN_OP
, asm_out_file
);
569 fputs (",0,0,", asm_out_file
);
572 /* Write a .stabn directive with type N_SLINE and desc LINE. As above,
573 the value field is the responsibility of the caller. */
575 dbxout_begin_stabn_sline (int lineno
)
577 fputs (ASM_STABN_OP
, asm_out_file
);
578 dbxout_int (N_SLINE
);
579 fputs (",0,", asm_out_file
);
581 putc (',', asm_out_file
);
584 /* Begin a .stabs directive with string "", type STYPE, and desc and
585 other fields 0. The value field is the responsibility of the
586 caller. This function cannot be used for .stabx directives. */
588 dbxout_begin_empty_stabs (int stype
)
590 fputs (ASM_STABS_OP
, asm_out_file
);
591 fputs ("\"\",", asm_out_file
);
593 fputs (",0,0,", asm_out_file
);
596 /* Begin a .stabs directive with string STR, type STYPE, and desc 0.
597 The value field is the responsibility of the caller. */
599 dbxout_begin_simple_stabs (const char *str
, int stype
)
601 fputs (ASM_STABS_OP
, asm_out_file
);
602 output_quoted_string (asm_out_file
, str
);
603 putc (',', asm_out_file
);
605 fputs (",0,0,", asm_out_file
);
608 /* As above but use SDESC for the desc field. */
610 dbxout_begin_simple_stabs_desc (const char *str
, int stype
, int sdesc
)
612 fputs (ASM_STABS_OP
, asm_out_file
);
613 output_quoted_string (asm_out_file
, str
);
614 putc (',', asm_out_file
);
616 fputs (",0,", asm_out_file
);
618 putc (',', asm_out_file
);
621 /* The next set of functions are entirely concerned with production of
622 "complex" .stabs directives: that is, .stabs directives whose
623 strings have to be constructed piecemeal. dbxout_type,
624 dbxout_symbol, etc. use these routines heavily. The string is queued
625 up in an obstack, then written out by dbxout_finish_complex_stabs, which
626 is also responsible for splitting it up if it exceeds DBX_CONTIN_LENGTH.
627 (You might think it would be more efficient to go straight to stdio
628 when DBX_CONTIN_LENGTH is 0 (i.e. no length limit) but that turns
629 out not to be the case, and anyway this needs fewer #ifdefs.) */
631 /* Begin a complex .stabs directive. If we can, write the initial
632 ASM_STABS_OP to the asm_out_file. */
635 dbxout_begin_complex_stabs (void)
637 emit_pending_bincls_if_required ();
639 fputs (ASM_STABS_OP
, asm_out_file
);
640 putc ('"', asm_out_file
);
641 gcc_assert (stabstr_last_contin_point
== 0);
644 /* As above, but do not force text or emit pending bincls. This is
645 used by dbxout_symbol_location, which needs to do something else. */
647 dbxout_begin_complex_stabs_noforcetext (void)
649 fputs (ASM_STABS_OP
, asm_out_file
);
650 putc ('"', asm_out_file
);
651 gcc_assert (stabstr_last_contin_point
== 0);
654 /* Add CHR, a single character, to the string being built. */
655 #define stabstr_C(chr) obstack_1grow (&stabstr_ob, chr)
657 /* Add STR, a normal C string, to the string being built. */
658 #define stabstr_S(str) obstack_grow (&stabstr_ob, str, strlen (str))
660 /* Add the text of ID, an IDENTIFIER_NODE, to the string being built. */
661 #define stabstr_I(id) obstack_grow (&stabstr_ob, \
662 IDENTIFIER_POINTER (id), \
663 IDENTIFIER_LENGTH (id))
665 /* Add NUM, a signed decimal number, to the string being built. */
667 stabstr_D (HOST_WIDE_INT num
)
670 char *p
= buf
+ sizeof buf
;
686 NUMBER_FMT_LOOP (p
, unum
, 10);
688 obstack_grow (&stabstr_ob
, p
, (buf
+ sizeof buf
) - p
);
691 /* Add NUM, an unsigned decimal number, to the string being built. */
693 stabstr_U (unsigned HOST_WIDE_INT num
)
696 char *p
= buf
+ sizeof buf
;
702 NUMBER_FMT_LOOP (p
, num
, 10);
703 obstack_grow (&stabstr_ob
, p
, (buf
+ sizeof buf
) - p
);
706 /* Add CST, an INTEGER_CST tree, to the string being built as an
707 unsigned octal number. This routine handles values which are
708 larger than a single HOST_WIDE_INT. */
712 int prec
= TYPE_PRECISION (TREE_TYPE (cst
));
713 int res_pres
= prec
% 3;
717 /* Leading zero for base indicator. */
720 /* If the value is zero, the base indicator will serve as the value
722 if (wi::to_wide (cst
) == 0)
725 /* GDB wants constants with no extra leading "1" bits, so
726 we need to remove any sign-extension that might be
730 digit
= wi::extract_uhwi (wi::to_wide (cst
), prec
- 1, 1);
731 stabstr_C ('0' + digit
);
733 else if (res_pres
== 2)
735 digit
= wi::extract_uhwi (wi::to_wide (cst
), prec
- 2, 2);
736 stabstr_C ('0' + digit
);
740 for (i
= prec
- 3; i
>= 0; i
= i
- 3)
742 digit
= wi::extract_uhwi (wi::to_wide (cst
), i
, 3);
743 stabstr_C ('0' + digit
);
747 /* Called whenever it is safe to break a stabs string into multiple
748 .stabs directives. If the current string has exceeded the limit
749 set by DBX_CONTIN_LENGTH, mark the current position in the buffer
750 as a continuation point by inserting DBX_CONTIN_CHAR (doubled if
751 it is a backslash) and a null character. */
753 stabstr_continue (void)
755 if (DBX_CONTIN_LENGTH
> 0
756 && obstack_object_size (&stabstr_ob
) - stabstr_last_contin_point
759 if (DBX_CONTIN_CHAR
== '\\')
760 obstack_1grow (&stabstr_ob
, '\\');
761 obstack_1grow (&stabstr_ob
, DBX_CONTIN_CHAR
);
762 obstack_1grow (&stabstr_ob
, '\0');
763 stabstr_last_contin_point
= obstack_object_size (&stabstr_ob
);
766 #define CONTIN stabstr_continue ()
768 /* Macro subroutine of dbxout_finish_complex_stabs, which emits
769 all of the arguments to the .stabs directive after the string.
770 Overridden by xcoffout.h. CODE is the stabs code for this symbol;
771 LINE is the source line to write into the desc field (in extended
772 mode); SYM is the symbol itself.
774 ADDR, LABEL, and NUMBER are three different ways to represent the
775 stabs value field. At most one of these should be nonzero.
777 ADDR is used most of the time; it represents the value as an
778 RTL address constant.
780 LABEL is used (currently) only for N_CATCH stabs; it represents
781 the value as a string suitable for assemble_name.
783 NUMBER is used when the value is an offset from an implicit base
784 pointer (e.g. for a stack variable), or an index (e.g. for a
785 register variable). It represents the value as a decimal integer. */
787 #ifndef DBX_FINISH_STABS
788 #define DBX_FINISH_STABS(SYM, CODE, LINE, ADDR, LABEL, NUMBER) \
790 int line_ = use_gnu_debug_info_extensions ? LINE : 0; \
793 fputs (",0,", asm_out_file); \
794 dbxout_int (line_); \
795 putc (',', asm_out_file); \
797 output_addr_const (asm_out_file, ADDR); \
799 assemble_name (asm_out_file, LABEL); \
801 dbxout_int (NUMBER); \
802 putc ('\n', asm_out_file); \
806 /* Finish the emission of a complex .stabs directive. When DBX_CONTIN_LENGTH
807 is zero, this has only to emit the close quote and the remainder of
808 the arguments. When it is nonzero, the string has been marshalled in
809 stabstr_ob, and this routine is responsible for breaking it up into
810 DBX_CONTIN_LENGTH-sized chunks.
812 SYM is the DECL of the symbol under consideration; it is used only
813 for its DECL_SOURCE_LINE. The other arguments are all passed directly
814 to DBX_FINISH_STABS; see above for details. */
817 dbxout_finish_complex_stabs (tree sym
, stab_code_type code
,
818 rtx addr
, const char *label
, int number
)
820 int line ATTRIBUTE_UNUSED
;
824 line
= sym
? DECL_SOURCE_LINE (sym
) : 0;
825 if (DBX_CONTIN_LENGTH
> 0)
830 /* Nul-terminate the growing string, then get its size and
832 obstack_1grow (&stabstr_ob
, '\0');
834 len
= obstack_object_size (&stabstr_ob
);
835 chunk
= str
= XOBFINISH (&stabstr_ob
, char *);
837 /* Within the buffer are a sequence of NUL-separated strings,
838 each of which is to be written out as a separate stab
842 chunklen
= strlen (chunk
);
843 fwrite (chunk
, 1, chunklen
, asm_out_file
);
844 fputs ("\",", asm_out_file
);
846 /* Must add an extra byte to account for the NUL separator. */
847 chunk
+= chunklen
+ 1;
850 /* Only put a line number on the last stab in the sequence. */
851 DBX_FINISH_STABS (sym
, code
, len
== 0 ? line
: 0,
852 addr
, label
, number
);
856 fputs (ASM_STABS_OP
, asm_out_file
);
857 putc ('"', asm_out_file
);
859 stabstr_last_contin_point
= 0;
863 /* No continuations - we can put the whole string out at once.
864 It is faster to augment the string with the close quote and
865 comma than to do a two-character fputs. */
866 obstack_grow (&stabstr_ob
, "\",", 2);
867 len
= obstack_object_size (&stabstr_ob
);
868 str
= XOBFINISH (&stabstr_ob
, char *);
870 fwrite (str
, 1, len
, asm_out_file
);
871 DBX_FINISH_STABS (sym
, code
, line
, addr
, label
, number
);
873 obstack_free (&stabstr_ob
, str
);
876 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
878 /* When -gused is used, emit debug info for only used symbols. But in
879 addition to the standard intercepted debug_hooks there are some
880 direct calls into this file, i.e., dbxout_symbol, dbxout_parms, and
881 dbxout_reg_params. Those routines may also be called from a higher
882 level intercepted routine. So to prevent recording data for an inner
883 call to one of these for an intercept, we maintain an intercept
884 nesting counter (debug_nesting). We only save the intercepted
885 arguments if the nesting is 1. */
886 static int debug_nesting
= 0;
888 static tree
*symbol_queue
;
889 static int symbol_queue_index
= 0;
890 static int symbol_queue_size
= 0;
892 #define DBXOUT_DECR_NESTING \
893 if (--debug_nesting == 0 && symbol_queue_index > 0) \
894 { emit_pending_bincls_if_required (); debug_flush_symbol_queue (); }
896 #define DBXOUT_DECR_NESTING_AND_RETURN(x) \
897 do {--debug_nesting; return (x);} while (0)
899 #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */
901 #if defined (DBX_DEBUGGING_INFO)
904 dbxout_function_end (tree decl ATTRIBUTE_UNUSED
)
906 char lscope_label_name
[100];
908 /* The Lscope label must be emitted even if we aren't doing anything
909 else; dbxout_block needs it. */
910 switch_to_section (current_function_section ());
912 /* Convert Lscope into the appropriate format for local labels in case
913 the system doesn't insert underscores in front of user generated
915 ASM_GENERATE_INTERNAL_LABEL (lscope_label_name
, "Lscope", scope_labelno
);
916 targetm
.asm_out
.internal_label (asm_out_file
, "Lscope", scope_labelno
);
918 /* The N_FUN tag at the end of the function is a GNU extension,
919 which may be undesirable, and is unnecessary if we do not have
921 if (!use_gnu_debug_info_extensions
922 || NO_DBX_FUNCTION_END
923 || !targetm_common
.have_named_sections
)
926 /* By convention, GCC will mark the end of a function with an N_FUN
927 symbol and an empty string. */
928 if (crtl
->has_bb_partition
)
930 dbxout_begin_empty_stabs (N_FUN
);
931 if (in_cold_section_p
)
932 dbxout_stab_value_label_diff (crtl
->subsections
.cold_section_end_label
,
933 crtl
->subsections
.cold_section_label
);
935 dbxout_stab_value_label_diff (crtl
->subsections
.hot_section_end_label
,
936 crtl
->subsections
.hot_section_label
);
940 char begin_label
[20];
941 /* Reference current function start using LFBB. */
942 ASM_GENERATE_INTERNAL_LABEL (begin_label
, "LFBB", scope_labelno
);
943 dbxout_begin_empty_stabs (N_FUN
);
944 dbxout_stab_value_label_diff (lscope_label_name
, begin_label
);
947 if (!NO_DBX_BNSYM_ENSYM
&& !flag_debug_only_used_symbols
)
948 dbxout_stabd (N_ENSYM
, 0);
950 #endif /* DBX_DEBUGGING_INFO */
952 /* Get lang description for N_SO stab. */
953 static unsigned int ATTRIBUTE_UNUSED
954 get_lang_number (void)
956 const char *language_string
= lang_hooks
.name
;
959 else if (lang_GNU_CXX ())
961 else if (strcmp (language_string
, "GNU F77") == 0)
963 else if (lang_GNU_Fortran ())
964 return N_SO_FORTRAN90
; /* CHECKME */
965 else if (strcmp (language_string
, "GNU Objective-C") == 0)
967 else if (strcmp (language_string
, "GNU Objective-C++") == 0)
968 return N_SO_OBJCPLUS
;
977 unsigned int lang
= get_lang_number ();
979 return (lang
== N_SO_FORTRAN
) || (lang
== N_SO_FORTRAN90
);
982 /* At the beginning of compilation, start writing the symbol table.
983 Initialize `typevec' and output the standard data types of C. */
986 dbxout_init (const char *input_file_name
)
988 char ltext_label_name
[100];
989 bool used_ltext_label_name
= false;
990 tree syms
= lang_hooks
.decls
.getdecls ();
991 const char *mapped_name
;
994 typevec
= ggc_cleared_vec_alloc
<typeinfo
> (typevec_len
);
996 /* stabstr_ob contains one string, which will be just fine with
998 obstack_specify_allocation (&stabstr_ob
, 0, 1, xmalloc
, free
);
1000 /* Convert Ltext into the appropriate format for local labels in case
1001 the system doesn't insert underscores in front of user generated
1003 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name
, "Ltext", 0);
1005 /* Put the current working directory in an N_SO symbol. */
1006 if (use_gnu_debug_info_extensions
&& !NO_DBX_MAIN_SOURCE_DIRECTORY
)
1008 static const char *cwd
;
1012 cwd
= get_src_pwd ();
1015 else if (!IS_DIR_SEPARATOR (cwd
[strlen (cwd
) - 1]))
1016 cwd
= concat (cwd
, "/", NULL
);
1017 cwd
= remap_debug_filename (cwd
);
1019 #ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
1020 DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asm_out_file
, cwd
);
1021 #else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
1022 dbxout_begin_simple_stabs_desc (cwd
, N_SO
, get_lang_number ());
1023 dbxout_stab_value_label (ltext_label_name
);
1024 used_ltext_label_name
= true;
1025 #endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
1028 mapped_name
= remap_debug_filename (input_file_name
);
1029 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
1030 DBX_OUTPUT_MAIN_SOURCE_FILENAME (asm_out_file
, mapped_name
);
1032 dbxout_begin_simple_stabs_desc (mapped_name
, N_SO
, get_lang_number ());
1033 dbxout_stab_value_label (ltext_label_name
);
1034 used_ltext_label_name
= true;
1037 if (used_ltext_label_name
)
1039 switch_to_section (text_section
);
1040 targetm
.asm_out
.internal_label (asm_out_file
, "Ltext", 0);
1043 /* Emit an N_OPT stab to indicate that this file was compiled by GCC.
1044 The string used is historical. */
1045 #ifndef NO_DBX_GCC_MARKER
1046 dbxout_begin_simple_stabs ("gcc2_compiled.", N_OPT
);
1047 dbxout_stab_value_zero ();
1050 base_input_file
= lastfile
= input_file_name
;
1052 next_type_number
= 1;
1054 #ifdef DBX_USE_BINCL
1055 current_file
= XNEW (struct dbx_file
);
1056 current_file
->next
= NULL
;
1057 current_file
->file_number
= 0;
1058 current_file
->next_type_number
= 1;
1059 next_file_number
= 1;
1060 current_file
->prev
= NULL
;
1061 current_file
->bincl_status
= BINCL_NOT_REQUIRED
;
1062 current_file
->pending_bincl_name
= NULL
;
1065 /* Get all permanent types that have typedef names, and output them
1066 all, except for those already output. Some language front ends
1067 put these declarations in the top-level scope; some do not;
1068 the latter are responsible for calling debug_hooks->type_decl from
1069 their record_builtin_type function. */
1070 dbxout_typedefs (syms
);
1072 if (preinit_symbols
)
1075 for (t
= nreverse (preinit_symbols
); t
; t
= TREE_CHAIN (t
))
1076 dbxout_symbol (TREE_VALUE (t
), 0);
1077 preinit_symbols
= 0;
1081 /* Output any typedef names for types described by TYPE_DECLs in SYMS. */
1084 dbxout_typedefs (tree syms
)
1086 for (; syms
!= NULL_TREE
; syms
= DECL_CHAIN (syms
))
1088 if (TREE_CODE (syms
) == TYPE_DECL
)
1090 tree type
= TREE_TYPE (syms
);
1091 if (TYPE_NAME (type
)
1092 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1093 && COMPLETE_OR_VOID_TYPE_P (type
)
1094 && ! TREE_ASM_WRITTEN (TYPE_NAME (type
)))
1095 dbxout_symbol (TYPE_NAME (type
), 0);
1100 #ifdef DBX_USE_BINCL
1101 /* Emit BINCL stab using given name. */
1103 emit_bincl_stab (const char *name
)
1105 dbxout_begin_simple_stabs (name
, N_BINCL
);
1106 dbxout_stab_value_zero ();
1109 /* If there are pending bincls then it is time to emit all of them. */
1112 emit_pending_bincls_if_required (void)
1115 emit_pending_bincls ();
1118 /* Emit all pending bincls. */
1121 emit_pending_bincls (void)
1123 struct dbx_file
*f
= current_file
;
1125 /* Find first pending bincl. */
1126 while (f
->bincl_status
== BINCL_PENDING
)
1129 /* Now emit all bincls. */
1134 if (f
->bincl_status
== BINCL_PENDING
)
1136 emit_bincl_stab (f
->pending_bincl_name
);
1138 /* Update file number and status. */
1139 f
->file_number
= next_file_number
++;
1140 f
->bincl_status
= BINCL_PROCESSED
;
1142 if (f
== current_file
)
1147 /* All pending bincls have been emitted. */
1154 emit_pending_bincls_if_required (void) {}
1157 /* Change to reading from a new source file. Generate a N_BINCL stab. */
1160 dbxout_start_source_file (unsigned int line ATTRIBUTE_UNUSED
,
1161 const char *filename ATTRIBUTE_UNUSED
)
1163 #ifdef DBX_USE_BINCL
1164 struct dbx_file
*n
= XNEW (struct dbx_file
);
1166 n
->next
= current_file
;
1167 n
->next_type_number
= 1;
1168 /* Do not assign file number now.
1169 Delay it until we actually emit BINCL. */
1172 current_file
->prev
= n
;
1173 n
->bincl_status
= BINCL_PENDING
;
1174 n
->pending_bincl_name
= remap_debug_filename (filename
);
1180 /* Revert to reading a previous source file. Generate a N_EINCL stab. */
1183 dbxout_end_source_file (unsigned int line ATTRIBUTE_UNUSED
)
1185 #ifdef DBX_USE_BINCL
1186 /* Emit EINCL stab only if BINCL is not pending. */
1187 if (current_file
->bincl_status
== BINCL_PROCESSED
)
1189 dbxout_begin_stabn (N_EINCL
);
1190 dbxout_stab_value_zero ();
1192 current_file
->bincl_status
= BINCL_NOT_REQUIRED
;
1193 current_file
= current_file
->next
;
1197 /* Handle a few odd cases that occur when trying to make PCH files work. */
1200 dbxout_handle_pch (unsigned at_end
)
1204 /* When using the PCH, this file will be included, so we need to output
1206 dbxout_start_source_file (0, lastfile
);
1208 /* The base file when using the PCH won't be the same as
1209 the base file when it's being generated. */
1214 /* ... and an EINCL. */
1215 dbxout_end_source_file (0);
1217 /* Deal with cases where 'lastfile' was never actually changed. */
1218 lastfile_is_base
= lastfile
== NULL
;
1222 #if defined (DBX_DEBUGGING_INFO)
1224 static bool dbxout_block (tree
, int, tree
, int);
1226 /* Output debugging info to FILE to switch to sourcefile FILENAME. */
1229 dbxout_source_file (const char *filename
)
1231 if (lastfile
== 0 && lastfile_is_base
)
1233 lastfile
= base_input_file
;
1234 lastfile_is_base
= 0;
1237 if (filename
&& (lastfile
== 0 || strcmp (filename
, lastfile
)))
1239 /* Don't change section amid function. */
1240 if (current_function_decl
== NULL_TREE
)
1241 switch_to_section (text_section
);
1243 dbxout_begin_simple_stabs (remap_debug_filename (filename
), N_SOL
);
1244 dbxout_stab_value_internal_label ("Ltext", &source_label_number
);
1245 lastfile
= filename
;
1249 /* Output N_BNSYM, line number symbol entry, and local symbol at
1253 dbxout_begin_prologue (unsigned int lineno
,
1254 unsigned int column ATTRIBUTE_UNUSED
,
1255 const char *filename
)
1257 if (use_gnu_debug_info_extensions
1258 && !NO_DBX_FUNCTION_END
1259 && !NO_DBX_BNSYM_ENSYM
1260 && !flag_debug_only_used_symbols
)
1261 dbxout_stabd (N_BNSYM
, 0);
1263 /* pre-increment the scope counter */
1266 dbxout_source_line (lineno
, 0, filename
, 0, true);
1267 /* Output function begin block at function scope, referenced
1268 by dbxout_block, dbxout_source_line and dbxout_function_end. */
1269 emit_pending_bincls_if_required ();
1270 targetm
.asm_out
.internal_label (asm_out_file
, "LFBB", scope_labelno
);
1273 /* Output a line number symbol entry for source file FILENAME and line
1277 dbxout_source_line (unsigned int lineno
, unsigned int column ATTRIBUTE_UNUSED
,
1278 const char *filename
, int discriminator ATTRIBUTE_UNUSED
,
1279 bool is_stmt ATTRIBUTE_UNUSED
)
1281 dbxout_source_file (filename
);
1283 #ifdef DBX_OUTPUT_SOURCE_LINE
1284 DBX_OUTPUT_SOURCE_LINE (asm_out_file
, lineno
, dbxout_source_line_counter
);
1286 if (DBX_LINES_FUNCTION_RELATIVE
)
1288 char begin_label
[20];
1289 dbxout_begin_stabn_sline (lineno
);
1290 /* Reference current function start using LFBB. */
1291 ASM_GENERATE_INTERNAL_LABEL (begin_label
, "LFBB", scope_labelno
);
1292 dbxout_stab_value_internal_label_diff ("LM", &dbxout_source_line_counter
,
1296 dbxout_stabd (N_SLINE
, lineno
);
1298 lastlineno
= lineno
;
1301 /* Unfortunately, at least when emitting relative addresses, STABS
1302 has no way to express multiple partitions. Represent a function
1303 as two functions in this case. */
1306 dbxout_switch_text_section (void)
1308 /* The N_FUN tag at the end of the function is a GNU extension,
1309 which may be undesirable, and is unnecessary if we do not have
1311 in_cold_section_p
= !in_cold_section_p
;
1312 switch_to_section (current_function_section ());
1313 dbxout_block (DECL_INITIAL (current_function_decl
), 0,
1314 DECL_ARGUMENTS (current_function_decl
), -1);
1315 dbxout_function_end (current_function_decl
);
1316 in_cold_section_p
= !in_cold_section_p
;
1318 switch_to_section (current_function_section ());
1320 tree context
= decl_function_context (current_function_decl
);
1321 extern tree cold_function_name
;
1323 dbxout_begin_complex_stabs ();
1324 stabstr_I (cold_function_name
);
1327 tree type
= TREE_TYPE (current_function_decl
);
1328 if (TREE_TYPE (type
))
1329 dbxout_type (TREE_TYPE (type
), 0);
1331 dbxout_type (void_type_node
, 0);
1336 stabstr_I (cold_function_name
);
1338 stabstr_I (DECL_NAME (context
));
1341 dbxout_finish_complex_stabs (current_function_decl
, N_FUN
, 0,
1342 crtl
->subsections
.cold_section_label
, 0);
1344 /* pre-increment the scope counter */
1347 dbxout_source_line (lastlineno
, 0, lastfile
, 0, true);
1348 /* Output function begin block at function scope, referenced
1349 by dbxout_block, dbxout_source_line and dbxout_function_end. */
1350 emit_pending_bincls_if_required ();
1351 targetm
.asm_out
.internal_label (asm_out_file
, "LFBB", scope_labelno
);
1354 /* Describe the beginning of an internal block within a function. */
1357 dbxout_begin_block (unsigned int line ATTRIBUTE_UNUSED
, unsigned int n
)
1359 emit_pending_bincls_if_required ();
1360 targetm
.asm_out
.internal_label (asm_out_file
, "LBB", n
);
1363 /* Describe the end line-number of an internal block within a function. */
1366 dbxout_end_block (unsigned int line ATTRIBUTE_UNUSED
, unsigned int n
)
1368 emit_pending_bincls_if_required ();
1369 targetm
.asm_out
.internal_label (asm_out_file
, "LBE", n
);
1372 /* Output dbx data for a function definition.
1373 This includes a definition of the function name itself (a symbol),
1374 definitions of the parameters (locating them in the parameter list)
1375 and then output the block that makes up the function's body
1376 (including all the auto variables of the function). */
1379 dbxout_function_decl (tree decl
)
1381 emit_pending_bincls_if_required ();
1382 #ifndef DBX_FUNCTION_FIRST
1383 dbxout_begin_function (decl
);
1385 dbxout_block (DECL_INITIAL (decl
), 0, DECL_ARGUMENTS (decl
), -1);
1386 dbxout_function_end (decl
);
1389 #endif /* DBX_DEBUGGING_INFO */
1392 dbxout_early_global_decl (tree decl ATTRIBUTE_UNUSED
)
1394 /* NYI for non-dwarf. */
1397 /* Debug information for a global DECL. Called from toplev.c after
1398 compilation proper has finished. */
1400 dbxout_late_global_decl (tree decl
)
1402 if (VAR_P (decl
) && !DECL_EXTERNAL (decl
))
1404 int saved_tree_used
= TREE_USED (decl
);
1405 TREE_USED (decl
) = 1;
1406 dbxout_symbol (decl
, 0);
1407 TREE_USED (decl
) = saved_tree_used
;
1411 /* This is just a function-type adapter; dbxout_symbol does exactly
1412 what we want but returns an int. */
1414 dbxout_type_decl (tree decl
, int local
)
1416 dbxout_symbol (decl
, local
);
1419 /* At the end of compilation, finish writing the symbol table.
1420 The default is to call debug_free_queue but do nothing else. */
1423 dbxout_finish (const char *filename ATTRIBUTE_UNUSED
)
1425 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
1426 DBX_OUTPUT_MAIN_SOURCE_FILE_END (asm_out_file
, filename
);
1427 #elif defined DBX_OUTPUT_NULL_N_SO_AT_MAIN_SOURCE_FILE_END
1429 switch_to_section (text_section
);
1430 dbxout_begin_empty_stabs (N_SO
);
1431 dbxout_stab_value_internal_label ("Letext", 0);
1434 debug_free_queue ();
1437 /* Output the index of a type. */
1440 dbxout_type_index (tree type
)
1442 #ifndef DBX_USE_BINCL
1443 stabstr_D (TYPE_SYMTAB_ADDRESS (type
));
1445 struct typeinfo
*t
= &typevec
[TYPE_SYMTAB_ADDRESS (type
)];
1447 stabstr_D (t
->file_number
);
1449 stabstr_D (t
->type_number
);
1455 /* Generate the symbols for any queued up type symbols we encountered
1456 while generating the type info for some originally used symbol.
1457 This might generate additional entries in the queue. Only when
1458 the nesting depth goes to 0 is this routine called. */
1461 debug_flush_symbol_queue (void)
1465 /* Make sure that additionally queued items are not flushed
1470 for (i
= 0; i
< symbol_queue_index
; ++i
)
1472 /* If we pushed queued symbols then such symbols must be
1473 output no matter what anyone else says. Specifically,
1474 we need to make sure dbxout_symbol() thinks the symbol was
1475 used and also we need to override TYPE_DECL_SUPPRESS_DEBUG
1476 which may be set for outside reasons. */
1477 int saved_tree_used
= TREE_USED (symbol_queue
[i
]);
1478 int saved_suppress_debug
= TYPE_DECL_SUPPRESS_DEBUG (symbol_queue
[i
]);
1479 TREE_USED (symbol_queue
[i
]) = 1;
1480 TYPE_DECL_SUPPRESS_DEBUG (symbol_queue
[i
]) = 0;
1482 #ifdef DBX_DEBUGGING_INFO
1483 dbxout_symbol (symbol_queue
[i
], 0);
1486 TREE_USED (symbol_queue
[i
]) = saved_tree_used
;
1487 TYPE_DECL_SUPPRESS_DEBUG (symbol_queue
[i
]) = saved_suppress_debug
;
1490 symbol_queue_index
= 0;
1494 /* Queue a type symbol needed as part of the definition of a decl
1495 symbol. These symbols are generated when debug_flush_symbol_queue()
1499 debug_queue_symbol (tree decl
)
1501 if (symbol_queue_index
>= symbol_queue_size
)
1503 symbol_queue_size
+= 10;
1504 symbol_queue
= XRESIZEVEC (tree
, symbol_queue
, symbol_queue_size
);
1507 symbol_queue
[symbol_queue_index
++] = decl
;
1510 /* Free symbol queue. */
1512 debug_free_queue (void)
1516 free (symbol_queue
);
1517 symbol_queue
= NULL
;
1518 symbol_queue_size
= 0;
1522 /* Used in several places: evaluates to '0' for a private decl,
1523 '1' for a protected decl, '2' for a public decl. */
1524 #define DECL_ACCESSIBILITY_CHAR(DECL) \
1525 (TREE_PRIVATE (DECL) ? '0' : TREE_PROTECTED (DECL) ? '1' : '2')
1527 /* Subroutine of `dbxout_type'. Output the type fields of TYPE.
1528 This must be a separate function because anonymous unions require
1532 dbxout_type_fields (tree type
)
1536 /* Output the name, type, position (in bits), size (in bits) of each
1537 field that we can support. */
1538 for (tem
= TYPE_FIELDS (type
); tem
; tem
= DECL_CHAIN (tem
))
1540 /* If one of the nodes is an error_mark or its type is then
1542 if (error_operand_p (tem
))
1545 /* Omit here local type decls until we know how to support them. */
1546 if (TREE_CODE (tem
) == TYPE_DECL
1547 || TREE_CODE (tem
) == TEMPLATE_DECL
1548 /* Member functions emitted after fields. */
1549 || TREE_CODE (tem
) == FUNCTION_DECL
1550 /* Omit here the nameless fields that are used to skip bits. */
1551 || DECL_IGNORED_P (tem
)
1552 /* Omit fields whose position or size are variable or too large to
1554 || (TREE_CODE (tem
) == FIELD_DECL
1555 && (! tree_fits_shwi_p (bit_position (tem
))
1556 || ! DECL_SIZE (tem
)
1557 || ! tree_fits_uhwi_p (DECL_SIZE (tem
)))))
1560 else if (TREE_CODE (tem
) != CONST_DECL
)
1562 /* Continue the line if necessary,
1563 but not before the first field. */
1564 if (tem
!= TYPE_FIELDS (type
))
1567 if (DECL_NAME (tem
))
1568 stabstr_I (DECL_NAME (tem
));
1571 if (use_gnu_debug_info_extensions
1572 && (TREE_PRIVATE (tem
) || TREE_PROTECTED (tem
)
1573 || TREE_CODE (tem
) != FIELD_DECL
))
1576 stabstr_C (DECL_ACCESSIBILITY_CHAR (tem
));
1579 dbxout_type ((TREE_CODE (tem
) == FIELD_DECL
1580 && DECL_BIT_FIELD_TYPE (tem
))
1581 ? DECL_BIT_FIELD_TYPE (tem
) : TREE_TYPE (tem
), 0);
1585 if (TREE_STATIC (tem
) && use_gnu_debug_info_extensions
)
1587 tree name
= DECL_ASSEMBLER_NAME (tem
);
1594 /* If TEM is non-static, GDB won't understand it. */
1595 stabstr_S (",0,0;");
1600 stabstr_D (int_bit_position (tem
));
1602 stabstr_D (tree_to_uhwi (DECL_SIZE (tem
)));
1609 /* Subroutine of `dbxout_type_methods'. Output debug info about the
1610 method described DECL. */
1613 dbxout_type_method_1 (tree decl
)
1617 if (TREE_CODE (TREE_TYPE (decl
)) == FUNCTION_TYPE
)
1619 else /* it's a METHOD_TYPE. */
1621 tree firstarg
= TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)));
1622 /* A for normal functions.
1623 B for `const' member functions.
1624 C for `volatile' member functions.
1625 D for `const volatile' member functions. */
1626 if (TYPE_READONLY (TREE_TYPE (firstarg
)))
1628 if (TYPE_VOLATILE (TREE_TYPE (firstarg
)))
1631 if (DECL_VINDEX (decl
))
1637 /* ??? Output the mangled name, which contains an encoding of the
1638 method's type signature. May not be necessary anymore. */
1640 stabstr_I (DECL_ASSEMBLER_NAME (decl
));
1642 stabstr_C (DECL_ACCESSIBILITY_CHAR (decl
));
1646 if (DECL_VINDEX (decl
) && tree_fits_shwi_p (DECL_VINDEX (decl
)))
1648 stabstr_D (tree_to_shwi (DECL_VINDEX (decl
)));
1650 dbxout_type (DECL_CONTEXT (decl
), 0);
1655 /* Subroutine of `dbxout_type'. Output debug info about the member
1656 functions defined in TYPE. */
1659 dbxout_type_methods (tree type
)
1661 for (tree fndecl
= TYPE_FIELDS (type
); fndecl
;)
1663 int need_prefix
= 1;
1665 /* Group together all the methods for the same operation.
1666 These differ in the types of the arguments. */
1667 for (tree last
= NULL_TREE
;
1668 fndecl
&& (last
== NULL_TREE
|| DECL_NAME (fndecl
) == DECL_NAME (last
));
1669 fndecl
= DECL_CHAIN (fndecl
))
1670 /* Output the name of the field (after overloading), as
1671 well as the name of the field before overloading, along
1672 with its parameter list */
1674 /* Skip non-functions. */
1675 if (TREE_CODE (fndecl
) != FUNCTION_DECL
)
1678 /* Also ignore abstract methods; those are only interesting to
1679 the DWARF backends. */
1680 if (DECL_IGNORED_P (fndecl
) || DECL_ABSTRACT_P (fndecl
))
1687 /* Redundantly output the plain name, since that's what gdb
1691 stabstr_I (DECL_NAME (fndecl
));
1696 dbxout_type (TREE_TYPE (fndecl
), 0);
1697 dbxout_type_method_1 (fndecl
);
1704 /* Emit a "range" type specification, which has the form:
1705 "r<index type>;<lower bound>;<upper bound>;".
1706 TYPE is an INTEGER_TYPE, LOW and HIGH are the bounds. */
1709 dbxout_range_type (tree type
, tree low
, tree high
)
1712 if (TREE_TYPE (type
))
1713 dbxout_type (TREE_TYPE (type
), 0);
1714 else if (TREE_CODE (type
) != INTEGER_TYPE
)
1715 dbxout_type (type
, 0); /* E.g. Pascal's ARRAY [BOOLEAN] of INTEGER */
1718 /* Traditionally, we made sure 'int' was type 1, and builtin types
1719 were defined to be sub-ranges of int. Unfortunately, this
1720 does not allow us to distinguish true sub-ranges from integer
1721 types. So, instead we define integer (non-sub-range) types as
1722 sub-ranges of themselves. This matters for Chill. If this isn't
1723 a subrange type, then we want to define it in terms of itself.
1724 However, in C, this may be an anonymous integer type, and we don't
1725 want to emit debug info referring to it. Just calling
1726 dbxout_type_index won't work anyways, because the type hasn't been
1727 defined yet. We make this work for both cases by checked to see
1728 whether this is a defined type, referring to it if it is, and using
1730 if (TYPE_SYMTAB_ADDRESS (type
) != 0)
1731 dbxout_type_index (type
);
1733 dbxout_type_index (integer_type_node
);
1737 if (low
&& tree_fits_shwi_p (low
))
1739 if (print_int_cst_bounds_in_octal_p (type
, low
, high
))
1742 stabstr_D (tree_to_shwi (low
));
1748 if (high
&& tree_fits_shwi_p (high
))
1750 if (print_int_cst_bounds_in_octal_p (type
, low
, high
))
1753 stabstr_D (tree_to_shwi (high
));
1761 /* Output a reference to a type. If the type has not yet been
1762 described in the dbx output, output its definition now.
1763 For a type already defined, just refer to its definition
1764 using the type number.
1766 If FULL is nonzero, and the type has been described only with
1767 a forward-reference, output the definition now.
1768 If FULL is zero in this case, just refer to the forward-reference
1769 using the number previously allocated. */
1772 dbxout_type (tree type
, int full
)
1774 static int anonymous_type_number
= 0;
1775 tree tem
, main_variant
, low
, high
;
1777 if (TREE_CODE (type
) == INTEGER_TYPE
)
1779 if (TREE_TYPE (type
) == 0)
1781 low
= TYPE_MIN_VALUE (type
);
1782 high
= TYPE_MAX_VALUE (type
);
1785 else if (subrange_type_for_debug_p (type
, &low
, &high
))
1788 /* If this is a subtype that should not be emitted as a subrange type,
1789 use the base type. */
1792 type
= TREE_TYPE (type
);
1793 low
= TYPE_MIN_VALUE (type
);
1794 high
= TYPE_MAX_VALUE (type
);
1798 /* If there was an input error and we don't really have a type,
1799 avoid crashing and write something that is at least valid
1800 by assuming `int'. */
1801 if (type
== error_mark_node
)
1802 type
= integer_type_node
;
1805 if (TYPE_NAME (type
)
1806 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1807 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type
)))
1811 /* Try to find the "main variant" with the same name. */
1812 if (TYPE_NAME (type
) && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1813 && DECL_ORIGINAL_TYPE (TYPE_NAME (type
)))
1814 main_variant
= TREE_TYPE (TYPE_NAME (type
));
1816 main_variant
= TYPE_MAIN_VARIANT (type
);
1818 /* If we are not using extensions, stabs does not distinguish const and
1819 volatile, so there is no need to make them separate types. */
1820 if (!use_gnu_debug_info_extensions
)
1821 type
= main_variant
;
1823 if (TYPE_SYMTAB_ADDRESS (type
) == 0)
1825 /* Type has no dbx number assigned. Assign next available number. */
1826 TYPE_SYMTAB_ADDRESS (type
) = next_type_number
++;
1828 /* Make sure type vector is long enough to record about this type. */
1830 if (next_type_number
== typevec_len
)
1832 typevec
= GGC_RESIZEVEC (struct typeinfo
, typevec
, typevec_len
* 2);
1833 memset (typevec
+ typevec_len
, 0, typevec_len
* sizeof typevec
[0]);
1837 #ifdef DBX_USE_BINCL
1838 emit_pending_bincls_if_required ();
1839 typevec
[TYPE_SYMTAB_ADDRESS (type
)].file_number
1840 = current_file
->file_number
;
1841 typevec
[TYPE_SYMTAB_ADDRESS (type
)].type_number
1842 = current_file
->next_type_number
++;
1846 if (flag_debug_only_used_symbols
)
1848 if ((TREE_CODE (type
) == RECORD_TYPE
1849 || TREE_CODE (type
) == UNION_TYPE
1850 || TREE_CODE (type
) == QUAL_UNION_TYPE
1851 || TREE_CODE (type
) == ENUMERAL_TYPE
)
1852 && TYPE_STUB_DECL (type
)
1853 && DECL_P (TYPE_STUB_DECL (type
))
1854 && ! DECL_IGNORED_P (TYPE_STUB_DECL (type
)))
1855 debug_queue_symbol (TYPE_STUB_DECL (type
));
1856 else if (TYPE_NAME (type
)
1857 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
1858 debug_queue_symbol (TYPE_NAME (type
));
1861 /* Output the number of this type, to refer to it. */
1862 dbxout_type_index (type
);
1864 #ifdef DBX_TYPE_DEFINED
1865 if (DBX_TYPE_DEFINED (type
))
1869 /* If this type's definition has been output or is now being output,
1872 switch (typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
)
1877 /* If we have already had a cross reference,
1878 and either that's all we want or that's the best we could do,
1879 don't repeat the cross reference.
1880 Sun dbx crashes if we do. */
1881 if (! full
|| !COMPLETE_TYPE_P (type
)
1882 /* No way in DBX fmt to describe a variable size. */
1883 || ! tree_fits_uhwi_p (TYPE_SIZE (type
)))
1891 /* For systems where dbx output does not allow the `=xsNAME:' syntax,
1892 leave the type-number completely undefined rather than output
1893 a cross-reference. If we have already used GNU debug info extensions,
1894 then it is OK to output a cross reference. This is necessary to get
1895 proper C++ debug output. */
1896 if ((TREE_CODE (type
) == RECORD_TYPE
|| TREE_CODE (type
) == UNION_TYPE
1897 || TREE_CODE (type
) == QUAL_UNION_TYPE
1898 || TREE_CODE (type
) == ENUMERAL_TYPE
)
1899 && ! use_gnu_debug_info_extensions
)
1900 /* We must use the same test here as we use twice below when deciding
1901 whether to emit a cross-reference. */
1902 if ((TYPE_NAME (type
) != 0
1903 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1904 && DECL_IGNORED_P (TYPE_NAME (type
)))
1906 || !COMPLETE_TYPE_P (type
)
1907 /* No way in DBX fmt to describe a variable size. */
1908 || ! tree_fits_uhwi_p (TYPE_SIZE (type
)))
1910 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1915 /* Output a definition now. */
1918 /* Mark it as defined, so that if it is self-referent
1919 we will not get into an infinite recursion of definitions. */
1921 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_DEFINED
;
1923 /* If this type is a variant of some other, hand off. Types with
1924 different names are usefully distinguished. We only distinguish
1925 cv-qualified types if we're using extensions. */
1926 if (TYPE_READONLY (type
) > TYPE_READONLY (main_variant
))
1929 dbxout_type (build_type_variant (type
, 0, TYPE_VOLATILE (type
)), 0);
1932 else if (TYPE_VOLATILE (type
) > TYPE_VOLATILE (main_variant
))
1935 dbxout_type (build_type_variant (type
, TYPE_READONLY (type
), 0), 0);
1938 else if (main_variant
!= TYPE_MAIN_VARIANT (type
))
1940 if (flag_debug_only_used_symbols
)
1942 tree orig_type
= DECL_ORIGINAL_TYPE (TYPE_NAME (type
));
1944 if ((TREE_CODE (orig_type
) == RECORD_TYPE
1945 || TREE_CODE (orig_type
) == UNION_TYPE
1946 || TREE_CODE (orig_type
) == QUAL_UNION_TYPE
1947 || TREE_CODE (orig_type
) == ENUMERAL_TYPE
)
1948 && TYPE_STUB_DECL (orig_type
)
1949 && ! DECL_IGNORED_P (TYPE_STUB_DECL (orig_type
)))
1950 debug_queue_symbol (TYPE_STUB_DECL (orig_type
));
1952 /* 'type' is a typedef; output the type it refers to. */
1953 dbxout_type (DECL_ORIGINAL_TYPE (TYPE_NAME (type
)), 0);
1956 /* else continue. */
1958 switch (TREE_CODE (type
))
1963 /* For a void type, just define it as itself; i.e., "5=5".
1964 This makes us consider it defined
1965 without saying what it is. The debugger will make it
1966 a void type when the reference is seen, and nothing will
1967 ever override that default. */
1968 dbxout_type_index (type
);
1972 if (type
== char_type_node
&& ! TYPE_UNSIGNED (type
))
1974 /* Output the type `char' as a subrange of itself!
1975 I don't understand this definition, just copied it
1976 from the output of pcc.
1977 This used to use `r2' explicitly and we used to
1978 take care to make sure that `char' was type number 2. */
1980 dbxout_type_index (type
);
1981 stabstr_S (";0;127;");
1984 /* If this is a subtype of another integer type, always prefer to
1985 write it as a subtype. */
1986 else if (TREE_TYPE (type
) != 0
1987 && TREE_CODE (TREE_TYPE (type
)) == INTEGER_TYPE
)
1989 /* If the size is non-standard, say what it is if we can use
1992 if (use_gnu_debug_info_extensions
1993 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
1996 stabstr_D (TYPE_PRECISION (type
));
2000 dbxout_range_type (type
, low
, high
);
2005 /* If the size is non-standard, say what it is if we can use
2008 if (use_gnu_debug_info_extensions
2009 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
2012 stabstr_D (TYPE_PRECISION (type
));
2016 if (print_int_cst_bounds_in_octal_p (type
, low
, high
))
2020 /* If this type derives from another type, output type index of
2021 parent type. This is particularly important when parent type
2022 is an enumerated type, because not generating the parent type
2023 index would transform the definition of this enumerated type
2024 into a plain unsigned type. */
2025 if (TREE_TYPE (type
) != 0)
2026 dbxout_type_index (TREE_TYPE (type
));
2028 dbxout_type_index (type
);
2038 /* Output other integer types as subranges of `int'. */
2039 dbxout_range_type (type
, low
, high
);
2045 case FIXED_POINT_TYPE
:
2046 /* This used to say `r1' and we used to take care
2047 to make sure that `int' was type number 1. */
2049 dbxout_type_index (integer_type_node
);
2051 stabstr_D (int_size_in_bytes (type
));
2056 if (use_gnu_debug_info_extensions
)
2059 stabstr_D (BITS_PER_UNIT
* int_size_in_bytes (type
));
2060 stabstr_S (";-16;");
2062 else /* Define as enumeral type (False, True) */
2063 stabstr_S ("eFalse:0,True:1,;");
2067 /* Differs from the REAL_TYPE by its new data type number.
2068 R3 is NF_COMPLEX. We don't try to use any of the other NF_*
2069 codes since gdb doesn't care anyway. */
2071 if (TREE_CODE (TREE_TYPE (type
)) == REAL_TYPE
)
2074 stabstr_D (2 * int_size_in_bytes (TREE_TYPE (type
)));
2079 /* Output a complex integer type as a structure,
2080 pending some other way to do it. */
2082 stabstr_D (int_size_in_bytes (type
));
2084 stabstr_S ("real:");
2085 dbxout_type (TREE_TYPE (type
), 0);
2087 stabstr_D (TYPE_PRECISION (TREE_TYPE (type
)));
2089 stabstr_S (";imag:");
2090 dbxout_type (TREE_TYPE (type
), 0);
2092 stabstr_D (TYPE_PRECISION (TREE_TYPE (type
)));
2094 stabstr_D (TYPE_PRECISION (TREE_TYPE (type
)));
2100 /* Make arrays of packed bits look like bitstrings for chill. */
2101 if (TYPE_PACKED (type
) && use_gnu_debug_info_extensions
)
2104 stabstr_D (BITS_PER_UNIT
* int_size_in_bytes (type
));
2105 stabstr_S (";@S;S");
2106 dbxout_type (TYPE_DOMAIN (type
), 0);
2110 /* Output "a" followed by a range type definition
2111 for the index type of the array
2112 followed by a reference to the target-type.
2113 ar1;0;N;M for a C array of type M and size N+1. */
2114 /* Check if a character string type, which in Chill is
2115 different from an array of characters. */
2116 if (TYPE_STRING_FLAG (type
) && use_gnu_debug_info_extensions
)
2120 tem
= TYPE_DOMAIN (type
);
2124 dbxout_type_index (integer_type_node
);
2125 stabstr_S (";0;-1;");
2130 dbxout_range_type (tem
, TYPE_MIN_VALUE (tem
), TYPE_MAX_VALUE (tem
));
2133 dbxout_type (TREE_TYPE (type
), 0);
2137 /* Make vectors look like an array. */
2138 if (use_gnu_debug_info_extensions
)
2141 /* Output "a" followed by a range type definition
2142 for the index type of the array
2143 followed by a reference to the target-type.
2144 ar1;0;N;M for a C array of type M and size N+1. */
2146 dbxout_range_type (integer_type_node
, size_zero_node
,
2147 size_int (TYPE_VECTOR_SUBPARTS (type
) - 1));
2149 dbxout_type (TREE_TYPE (type
), 0);
2154 case QUAL_UNION_TYPE
:
2156 tree binfo
= TYPE_BINFO (type
);
2158 /* Output a structure type. We must use the same test here as we
2159 use in the DBX_NO_XREFS case above. */
2160 if ((TYPE_NAME (type
) != 0
2161 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
2162 && DECL_IGNORED_P (TYPE_NAME (type
)))
2164 || !COMPLETE_TYPE_P (type
)
2165 /* No way in DBX fmt to describe a variable size. */
2166 || ! tree_fits_uhwi_p (TYPE_SIZE (type
)))
2168 /* If the type is just a cross reference, output one
2169 and mark the type as partially described.
2170 If it later becomes defined, we will output
2171 its real definition.
2172 If the type has a name, don't nest its definition within
2173 another type's definition; instead, output an xref
2174 and let the definition come when the name is defined. */
2175 stabstr_S ((TREE_CODE (type
) == RECORD_TYPE
) ? "xs" : "xu");
2176 if (TYPE_IDENTIFIER (type
))
2178 /* Note that the C frontend creates for anonymous variable
2179 length records/unions TYPE_NAME with DECL_NAME NULL. */
2180 dbxout_type_name (type
);
2185 stabstr_D (anonymous_type_number
++);
2189 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
2193 /* Identify record or union, and print its size. */
2194 stabstr_C ((TREE_CODE (type
) == RECORD_TYPE
) ? 's' : 'u');
2195 stabstr_D (int_size_in_bytes (type
));
2201 vec
<tree
, va_gc
> *accesses
= BINFO_BASE_ACCESSES (binfo
);
2203 if (use_gnu_debug_info_extensions
)
2205 if (BINFO_N_BASE_BINFOS (binfo
))
2208 stabstr_U (BINFO_N_BASE_BINFOS (binfo
));
2212 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, child
); i
++)
2214 tree access
= (accesses
? (*accesses
)[i
] : access_public_node
);
2216 if (use_gnu_debug_info_extensions
)
2218 stabstr_C (BINFO_VIRTUAL_P (child
) ? '1' : '0');
2219 stabstr_C (access
== access_public_node
? '2' :
2220 access
== access_protected_node
2222 if (BINFO_VIRTUAL_P (child
)
2224 || strcmp (lang_hooks
.name
, "GNU Objective-C++") == 0))
2225 /* For a virtual base, print the (negative)
2226 offset within the vtable where we must look
2227 to find the necessary adjustment. */
2229 (tree_to_shwi (BINFO_VPTR_FIELD (child
))
2232 stabstr_D (tree_to_shwi (BINFO_OFFSET (child
))
2235 dbxout_type (BINFO_TYPE (child
), 0);
2240 /* Print out the base class information with
2241 fields which have the same names at the types
2243 dbxout_type_name (BINFO_TYPE (child
));
2245 dbxout_type (BINFO_TYPE (child
), full
);
2247 stabstr_D (tree_to_shwi (BINFO_OFFSET (child
))
2251 (tree_to_shwi (TYPE_SIZE (BINFO_TYPE (child
)))
2259 /* Write out the field declarations. */
2260 dbxout_type_fields (type
);
2261 if (use_gnu_debug_info_extensions
)
2262 dbxout_type_methods (type
);
2266 if (use_gnu_debug_info_extensions
&& TREE_CODE (type
) == RECORD_TYPE
2267 /* Avoid the ~ if we don't really need it--it confuses dbx. */
2268 && TYPE_VFIELD (type
))
2271 /* We need to write out info about what field this class
2272 uses as its "main" vtable pointer field, because if this
2273 field is inherited from a base class, GDB cannot necessarily
2274 figure out which field it's using in time. */
2276 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type
)), 0);
2282 /* We must use the same test here as we use in the DBX_NO_XREFS case
2283 above. We simplify it a bit since an enum will never have a variable
2285 if ((TYPE_NAME (type
) != 0
2286 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
2287 && DECL_IGNORED_P (TYPE_NAME (type
)))
2289 || !COMPLETE_TYPE_P (type
))
2292 dbxout_type_name (type
);
2293 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
2297 if (use_gnu_debug_info_extensions
2298 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
2301 stabstr_D (TYPE_PRECISION (type
));
2306 for (tem
= TYPE_VALUES (type
); tem
; tem
= TREE_CHAIN (tem
))
2308 tree value
= TREE_VALUE (tem
);
2310 stabstr_I (TREE_PURPOSE (tem
));
2313 if (TREE_CODE (value
) == CONST_DECL
)
2314 value
= DECL_INITIAL (value
);
2316 if (cst_and_fits_in_hwi (value
))
2317 stabstr_D (TREE_INT_CST_LOW (value
));
2322 if (TREE_CHAIN (tem
) != 0)
2331 dbxout_type (TREE_TYPE (type
), 0);
2335 if (use_gnu_debug_info_extensions
)
2339 /* Write the argument types out longhand. */
2340 dbxout_type (TYPE_METHOD_BASETYPE (type
), 0);
2342 dbxout_type (TREE_TYPE (type
), 0);
2343 dbxout_args (TYPE_ARG_TYPES (type
));
2347 /* Treat it as a function type. */
2348 dbxout_type (TREE_TYPE (type
), 0);
2352 if (use_gnu_debug_info_extensions
)
2355 dbxout_type (TYPE_OFFSET_BASETYPE (type
), 0);
2357 dbxout_type (TREE_TYPE (type
), 0);
2360 /* Should print as an int, because it is really just an offset. */
2361 dbxout_type (integer_type_node
, 0);
2364 case REFERENCE_TYPE
:
2365 if (use_gnu_debug_info_extensions
)
2371 dbxout_type (TREE_TYPE (type
), 0);
2376 dbxout_type (TREE_TYPE (type
), 0);
2379 case POINTER_BOUNDS_TYPE
:
2380 /* No debug info for pointer bounds type supported yet. */
2384 /* A C++ function with deduced return type can have a TEMPLATE_TYPE_PARM
2385 named 'auto' in its type.
2386 No debug info for TEMPLATE_TYPE_PARM type supported yet. */
2387 if (lang_GNU_CXX ())
2389 tree name
= TYPE_IDENTIFIER (type
);
2390 if (name
== get_identifier ("auto")
2391 || name
== get_identifier ("decltype(auto)"))
2399 /* Return nonzero if the given type represents an integer whose bounds
2400 should be printed in octal format. */
2403 print_int_cst_bounds_in_octal_p (tree type
, tree low
, tree high
)
2405 /* If we can use GDB extensions and the size is wider than a long
2406 (the size used by GDB to read them) or we may have trouble writing
2407 the bounds the usual way, write them in octal. Note the test is for
2408 the *target's* size of "long", not that of the host. The host test
2409 is just to make sure we can write it out in case the host wide int
2410 is narrower than the target "long".
2412 For unsigned types, we use octal if they are the same size or larger.
2413 This is because we print the bounds as signed decimal, and hence they
2414 can't span same size unsigned types. */
2416 if (use_gnu_debug_info_extensions
2417 && low
&& TREE_CODE (low
) == INTEGER_CST
2418 && high
&& TREE_CODE (high
) == INTEGER_CST
2419 && (TYPE_PRECISION (type
) > TYPE_PRECISION (integer_type_node
)
2420 || ((TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
))
2421 && TYPE_UNSIGNED (type
))
2422 || TYPE_PRECISION (type
) > HOST_BITS_PER_WIDE_INT
2423 || (TYPE_PRECISION (type
) == HOST_BITS_PER_WIDE_INT
2424 && TYPE_UNSIGNED (type
))))
2430 /* Output the name of type TYPE, with no punctuation.
2431 Such names can be set up either by typedef declarations
2432 or by struct, enum and union tags. */
2435 dbxout_type_name (tree type
)
2437 tree t
= TYPE_NAME (type
);
2440 switch (TREE_CODE (t
))
2442 case IDENTIFIER_NODE
:
2454 /* Output leading struct or class names needed for qualifying type
2455 whose scope is limited to a struct or class. */
2458 dbxout_class_name_qualifiers (tree decl
)
2460 tree context
= decl_type_context (decl
);
2462 if (context
!= NULL_TREE
2463 && TREE_CODE (context
) == RECORD_TYPE
2464 && TYPE_NAME (context
) != 0
2465 && (TREE_CODE (TYPE_NAME (context
)) == IDENTIFIER_NODE
2466 || (DECL_NAME (TYPE_NAME (context
)) != 0)))
2468 tree name
= TYPE_NAME (context
);
2470 if (TREE_CODE (name
) == TYPE_DECL
)
2472 dbxout_class_name_qualifiers (name
);
2473 name
= DECL_NAME (name
);
2480 /* This is a specialized subset of expand_expr for use by dbxout_symbol in
2481 evaluating DECL_VALUE_EXPR. In particular, we stop if we find decls that
2482 haven't been expanded, or if the expression is getting so complex we won't
2483 be able to represent it in stabs anyway. Returns NULL on failure. */
2486 dbxout_expand_expr (tree expr
)
2488 switch (TREE_CODE (expr
))
2491 /* We can't handle emulated tls variables, because the address is an
2492 offset to the return value of __emutls_get_address, and there is no
2493 way to express that in stabs. Also, there are name mangling issues
2494 here. We end up with references to undefined symbols if we don't
2495 disable debug info for these variables. */
2496 if (!targetm
.have_tls
&& DECL_THREAD_LOCAL_P (expr
))
2498 if (TREE_STATIC (expr
)
2499 && !TREE_ASM_WRITTEN (expr
)
2500 && !DECL_HAS_VALUE_EXPR_P (expr
)
2501 && !TREE_PUBLIC (expr
)
2502 && DECL_RTL_SET_P (expr
)
2503 && MEM_P (DECL_RTL (expr
)))
2505 /* If this is a var that might not be actually output,
2506 return NULL, otherwise stabs might reference an undefined
2508 varpool_node
*node
= varpool_node::get (expr
);
2509 if (!node
|| !node
->definition
)
2516 if (DECL_HAS_VALUE_EXPR_P (expr
))
2517 return dbxout_expand_expr (DECL_VALUE_EXPR (expr
));
2521 return DECL_RTL_IF_SET (expr
);
2524 return expand_expr (expr
, NULL_RTX
, VOIDmode
, EXPAND_INITIALIZER
);
2528 case ARRAY_RANGE_REF
:
2532 HOST_WIDE_INT bitsize
, bitpos
;
2534 int unsignedp
, reversep
, volatilep
= 0;
2537 tem
= get_inner_reference (expr
, &bitsize
, &bitpos
, &offset
, &mode
,
2538 &unsignedp
, &reversep
, &volatilep
);
2540 x
= dbxout_expand_expr (tem
);
2541 if (x
== NULL
|| !MEM_P (x
))
2545 if (!tree_fits_shwi_p (offset
))
2547 x
= adjust_address_nv (x
, mode
, tree_to_shwi (offset
));
2550 x
= adjust_address_nv (x
, mode
, bitpos
/ BITS_PER_UNIT
);
2560 /* Helper function for output_used_types. Queue one entry from the
2561 used types hash to be output. */
2564 output_used_types_helper (tree
const &type
, vec
<tree
> *types_p
)
2566 if ((TREE_CODE (type
) == RECORD_TYPE
2567 || TREE_CODE (type
) == UNION_TYPE
2568 || TREE_CODE (type
) == QUAL_UNION_TYPE
2569 || TREE_CODE (type
) == ENUMERAL_TYPE
)
2570 && TYPE_STUB_DECL (type
)
2571 && DECL_P (TYPE_STUB_DECL (type
))
2572 && ! DECL_IGNORED_P (TYPE_STUB_DECL (type
)))
2573 types_p
->quick_push (TYPE_STUB_DECL (type
));
2574 else if (TYPE_NAME (type
)
2575 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
2576 types_p
->quick_push (TYPE_NAME (type
));
2581 /* This is a qsort callback which sorts types and declarations into a
2582 predictable order (types, then declarations, sorted by UID
2586 output_types_sort (const void *pa
, const void *pb
)
2588 const tree lhs
= *((const tree
*)pa
);
2589 const tree rhs
= *((const tree
*)pb
);
2594 return TYPE_UID (lhs
) - TYPE_UID (rhs
);
2603 return DECL_UID (lhs
) - DECL_UID (rhs
);
2608 /* Force all types used by this function to be output in debug
2612 output_used_types (void)
2614 if (cfun
&& cfun
->used_types_hash
)
2620 types
.create (cfun
->used_types_hash
->elements ());
2621 cfun
->used_types_hash
->traverse
<vec
<tree
> *, output_used_types_helper
>
2624 /* Sort by UID to prevent dependence on hash table ordering. */
2625 types
.qsort (output_types_sort
);
2627 FOR_EACH_VEC_ELT (types
, i
, type
)
2628 debug_queue_symbol (type
);
2634 /* Output a .stabs for the symbol defined by DECL,
2635 which must be a ..._DECL node in the normal namespace.
2636 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
2637 LOCAL is nonzero if the scope is less than the entire file.
2638 Return 1 if a stabs might have been emitted. */
2641 dbxout_symbol (tree decl
, int local ATTRIBUTE_UNUSED
)
2643 tree type
= TREE_TYPE (decl
);
2644 tree context
= NULL_TREE
;
2648 /* "Intercept" dbxout_symbol() calls like we do all debug_hooks. */
2651 /* Ignore nameless syms, but don't ignore type tags. */
2653 if ((DECL_NAME (decl
) == 0 && TREE_CODE (decl
) != TYPE_DECL
)
2654 || DECL_IGNORED_P (decl
))
2655 DBXOUT_DECR_NESTING_AND_RETURN (0);
2657 /* If we are to generate only the symbols actually used then such
2658 symbol nodes are flagged with TREE_USED. Ignore any that
2659 aren't flagged as TREE_USED. */
2661 if (flag_debug_only_used_symbols
2662 && (!TREE_USED (decl
)
2663 && (!VAR_P (decl
) || !DECL_INITIAL (decl
))))
2664 DBXOUT_DECR_NESTING_AND_RETURN (0);
2666 /* If dbxout_init has not yet run, queue this symbol for later. */
2669 preinit_symbols
= tree_cons (0, decl
, preinit_symbols
);
2670 DBXOUT_DECR_NESTING_AND_RETURN (0);
2673 if (flag_debug_only_used_symbols
)
2677 /* We now have a used symbol. We need to generate the info for
2678 the symbol's type in addition to the symbol itself. These
2679 type symbols are queued to be generated after were done with
2680 the symbol itself (otherwise they would fight over the
2683 Note, because the TREE_TYPE(type) might be something like a
2684 pointer to a named type we need to look for the first name
2685 we see following the TREE_TYPE chain. */
2688 while (POINTER_TYPE_P (t
))
2691 /* RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, and ENUMERAL_TYPE
2692 need special treatment. The TYPE_STUB_DECL field in these
2693 types generally represents the tag name type we want to
2694 output. In addition there could be a typedef type with
2695 a different name. In that case we also want to output
2698 if (TREE_CODE (t
) == RECORD_TYPE
2699 || TREE_CODE (t
) == UNION_TYPE
2700 || TREE_CODE (t
) == QUAL_UNION_TYPE
2701 || TREE_CODE (t
) == ENUMERAL_TYPE
)
2703 if (TYPE_STUB_DECL (t
)
2704 && TYPE_STUB_DECL (t
) != decl
2705 && DECL_P (TYPE_STUB_DECL (t
))
2706 && ! DECL_IGNORED_P (TYPE_STUB_DECL (t
)))
2708 debug_queue_symbol (TYPE_STUB_DECL (t
));
2710 && TYPE_NAME (t
) != TYPE_STUB_DECL (t
)
2711 && TYPE_NAME (t
) != decl
2712 && DECL_P (TYPE_NAME (t
)))
2713 debug_queue_symbol (TYPE_NAME (t
));
2716 else if (TYPE_NAME (t
)
2717 && TYPE_NAME (t
) != decl
2718 && DECL_P (TYPE_NAME (t
)))
2719 debug_queue_symbol (TYPE_NAME (t
));
2722 emit_pending_bincls_if_required ();
2724 switch (TREE_CODE (decl
))
2727 /* Enum values are defined by defining the enum type. */
2731 decl_rtl
= DECL_RTL_IF_SET (decl
);
2733 DBXOUT_DECR_NESTING_AND_RETURN (0);
2734 if (DECL_EXTERNAL (decl
))
2736 /* Don't mention a nested function under its parent. */
2737 context
= decl_function_context (decl
);
2738 if (context
== current_function_decl
)
2740 /* Don't mention an inline instance of a nested function. */
2741 if (context
&& DECL_FROM_INLINE (decl
))
2743 if (!MEM_P (decl_rtl
)
2744 || GET_CODE (XEXP (decl_rtl
, 0)) != SYMBOL_REF
)
2747 if (flag_debug_only_used_symbols
)
2748 output_used_types ();
2750 dbxout_begin_complex_stabs ();
2751 stabstr_I (DECL_ASSEMBLER_NAME (decl
));
2752 stabstr_S (TREE_PUBLIC (decl
) ? ":F" : ":f");
2755 if (TREE_TYPE (type
))
2756 dbxout_type (TREE_TYPE (type
), 0);
2758 dbxout_type (void_type_node
, 0);
2760 /* For a nested function, when that function is compiled,
2761 mention the containing function name
2762 as well as (since dbx wants it) our own assembler-name. */
2766 stabstr_I (DECL_ASSEMBLER_NAME (decl
));
2768 stabstr_I (DECL_NAME (context
));
2771 dbxout_finish_complex_stabs (decl
, N_FUN
, XEXP (decl_rtl
, 0), 0, 0);
2775 /* Don't output the same typedef twice.
2776 And don't output what language-specific stuff doesn't want output. */
2777 if (TREE_ASM_WRITTEN (decl
) || TYPE_DECL_SUPPRESS_DEBUG (decl
))
2778 DBXOUT_DECR_NESTING_AND_RETURN (0);
2780 /* Don't output typedefs for types with magic type numbers (XCOFF). */
2781 #ifdef DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER
2783 int fundamental_type_number
=
2784 DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER (decl
);
2786 if (fundamental_type_number
!= 0)
2788 TREE_ASM_WRITTEN (decl
) = 1;
2789 TYPE_SYMTAB_ADDRESS (TREE_TYPE (decl
)) = fundamental_type_number
;
2790 DBXOUT_DECR_NESTING_AND_RETURN (0);
2800 if (DECL_NAME (decl
))
2802 /* Nonzero means we must output a tag as well as a typedef. */
2805 /* Handle the case of a C++ structure or union
2806 where the TYPE_NAME is a TYPE_DECL
2807 which gives both a typedef name and a tag. */
2808 /* dbx requires the tag first and the typedef second. */
2809 if ((TREE_CODE (type
) == RECORD_TYPE
2810 || TREE_CODE (type
) == UNION_TYPE
2811 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
2812 && TYPE_NAME (type
) == decl
2813 && !use_gnu_debug_info_extensions
2814 && !TREE_ASM_WRITTEN (TYPE_NAME (type
))
2815 /* Distinguish the implicit typedefs of C++
2816 from explicit ones that might be found in C. */
2817 && DECL_ARTIFICIAL (decl
)
2818 /* Do not generate a tag for incomplete records. */
2819 && COMPLETE_TYPE_P (type
)
2820 /* Do not generate a tag for records of variable size,
2821 since this type can not be properly described in the
2822 DBX format, and it confuses some tools such as objdump. */
2823 && tree_fits_uhwi_p (TYPE_SIZE (type
)))
2825 tree name
= TYPE_IDENTIFIER (type
);
2827 dbxout_begin_complex_stabs ();
2830 dbxout_type (type
, 1);
2831 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE
,
2835 dbxout_begin_complex_stabs ();
2837 /* Output leading class/struct qualifiers. */
2838 if (use_gnu_debug_info_extensions
)
2839 dbxout_class_name_qualifiers (decl
);
2841 /* Output typedef name. */
2842 stabstr_I (DECL_NAME (decl
));
2845 /* Short cut way to output a tag also. */
2846 if ((TREE_CODE (type
) == RECORD_TYPE
2847 || TREE_CODE (type
) == UNION_TYPE
2848 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
2849 && TYPE_NAME (type
) == decl
2850 /* Distinguish the implicit typedefs of C++
2851 from explicit ones that might be found in C. */
2852 && DECL_ARTIFICIAL (decl
))
2854 if (use_gnu_debug_info_extensions
)
2857 TREE_ASM_WRITTEN (TYPE_NAME (type
)) = 1;
2862 dbxout_type (type
, 1);
2863 dbxout_finish_complex_stabs (decl
, DBX_TYPE_DECL_STABS_CODE
,
2868 /* Don't output a tag if this is an incomplete type. This prevents
2869 the sun4 Sun OS 4.x dbx from crashing. */
2871 if (tag_needed
&& TYPE_NAME (type
) != 0
2872 && (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
2873 || (DECL_NAME (TYPE_NAME (type
)) != 0))
2874 && COMPLETE_TYPE_P (type
)
2875 && !TREE_ASM_WRITTEN (TYPE_NAME (type
)))
2877 /* For a TYPE_DECL with no name, but the type has a name,
2879 This is what represents `struct foo' with no typedef. */
2880 /* In C++, the name of a type is the corresponding typedef.
2881 In C, it is an IDENTIFIER_NODE. */
2882 tree name
= TYPE_IDENTIFIER (type
);
2884 dbxout_begin_complex_stabs ();
2887 dbxout_type (type
, 1);
2888 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE
, 0, 0, 0);
2892 /* If an enum type has no name, it cannot be referred to, but
2893 we must output it anyway, to record the enumeration
2896 if (!did_output
&& TREE_CODE (type
) == ENUMERAL_TYPE
)
2898 dbxout_begin_complex_stabs ();
2899 /* Some debuggers fail when given NULL names, so give this a
2900 harmless name of " " (Why not "(anon)"?). */
2902 dbxout_type (type
, 1);
2903 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE
, 0, 0, 0);
2906 /* Prevent duplicate output of a typedef. */
2907 TREE_ASM_WRITTEN (decl
) = 1;
2912 if (DECL_HAS_VALUE_EXPR_P (decl
))
2913 decl
= DECL_VALUE_EXPR (decl
);
2915 /* PARM_DECLs go in their own separate chain and are output by
2916 dbxout_reg_parms and dbxout_parms, except for those that are
2917 disguised VAR_DECLs like Out parameters in Ada. */
2918 gcc_assert (VAR_P (decl
));
2924 /* Don't mention a variable that is external.
2925 Let the file that defines it describe it. */
2926 if (DECL_EXTERNAL (decl
))
2929 /* If the variable is really a constant
2930 and not written in memory, inform the debugger.
2932 ??? Why do we skip emitting the type and location in this case? */
2933 if (TREE_STATIC (decl
) && TREE_READONLY (decl
)
2934 && DECL_INITIAL (decl
) != 0
2935 && tree_fits_shwi_p (DECL_INITIAL (decl
))
2936 && ! TREE_ASM_WRITTEN (decl
)
2937 && (DECL_FILE_SCOPE_P (decl
)
2938 || TREE_CODE (DECL_CONTEXT (decl
)) == BLOCK
2939 || TREE_CODE (DECL_CONTEXT (decl
)) == NAMESPACE_DECL
)
2940 && TREE_PUBLIC (decl
) == 0)
2942 /* The sun4 assembler does not grok this. */
2944 if (TREE_CODE (TREE_TYPE (decl
)) == INTEGER_TYPE
2945 || TREE_CODE (TREE_TYPE (decl
)) == ENUMERAL_TYPE
)
2947 HOST_WIDE_INT ival
= tree_to_shwi (DECL_INITIAL (decl
));
2949 dbxout_begin_complex_stabs ();
2950 dbxout_symbol_name (decl
, NULL
, 'c');
2953 dbxout_finish_complex_stabs (0, N_LSYM
, 0, 0, 0);
2954 DBXOUT_DECR_NESTING
;
2960 /* else it is something we handle like a normal variable. */
2962 decl_rtl
= dbxout_expand_expr (decl
);
2964 DBXOUT_DECR_NESTING_AND_RETURN (0);
2966 if (!is_global_var (decl
))
2967 decl_rtl
= eliminate_regs (decl_rtl
, VOIDmode
, NULL_RTX
);
2968 #ifdef LEAF_REG_REMAP
2969 if (crtl
->uses_only_leaf_regs
)
2970 leaf_renumber_regs_insn (decl_rtl
);
2973 result
= dbxout_symbol_location (decl
, type
, 0, decl_rtl
);
2979 DBXOUT_DECR_NESTING
;
2983 /* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL.
2984 Add SUFFIX to its name, if SUFFIX is not 0.
2985 Describe the variable as residing in HOME
2986 (usually HOME is DECL_RTL (DECL), but not always).
2987 Returns 1 if the stab was really emitted. */
2990 dbxout_symbol_location (tree decl
, tree type
, const char *suffix
, rtx home
)
2993 stab_code_type code
;
2998 /* Don't mention a variable at all
2999 if it was completely optimized into nothingness.
3001 If the decl was from an inline function, then its rtl
3002 is not identically the rtl that was used in this
3003 particular compilation. */
3004 if (GET_CODE (home
) == SUBREG
)
3008 while (GET_CODE (value
) == SUBREG
)
3009 value
= SUBREG_REG (value
);
3012 if (REGNO (value
) >= FIRST_PSEUDO_REGISTER
)
3015 home
= alter_subreg (&home
, true);
3019 regno
= REGNO (home
);
3020 if (regno
>= FIRST_PSEUDO_REGISTER
)
3024 /* The kind-of-variable letter depends on where
3025 the variable is and on the scope of its name:
3026 G and N_GSYM for static storage and global scope,
3027 S for static storage and file scope,
3028 V for static storage and local scope,
3029 for those two, use N_LCSYM if data is in bss segment,
3030 N_STSYM if in data segment, N_FUN otherwise.
3031 (We used N_FUN originally, then changed to N_STSYM
3032 to please GDB. However, it seems that confused ld.
3033 Now GDB has been fixed to like N_FUN, says Kingdon.)
3034 no letter at all, and N_LSYM, for auto variable,
3035 r and N_RSYM for register variable. */
3037 if (MEM_P (home
) && GET_CODE (XEXP (home
, 0)) == SYMBOL_REF
)
3039 if (TREE_PUBLIC (decl
))
3044 if (NULL
!= dbxout_common_check (decl
, &offs
))
3053 addr
= XEXP (home
, 0);
3055 letter
= decl_function_context (decl
) ? 'V' : 'S';
3057 /* Some ports can transform a symbol ref into a label ref,
3058 because the symbol ref is too far away and has to be
3059 dumped into a constant pool. Alternatively, the symbol
3060 in the constant pool might be referenced by a different
3062 if (GET_CODE (addr
) == SYMBOL_REF
3063 && CONSTANT_POOL_ADDRESS_P (addr
))
3066 rtx tmp
= get_pool_constant_mark (addr
, &marked
);
3068 if (GET_CODE (tmp
) == SYMBOL_REF
)
3071 if (CONSTANT_POOL_ADDRESS_P (addr
))
3072 get_pool_constant_mark (addr
, &marked
);
3076 else if (GET_CODE (tmp
) == LABEL_REF
)
3082 /* If all references to the constant pool were optimized
3083 out, we just ignore the symbol. */
3088 /* This should be the same condition as in assemble_variable, but
3089 we don't have access to dont_output_data here. So, instead,
3090 we rely on the fact that error_mark_node initializers always
3091 end up in bss for C++ and never end up in bss for C. */
3092 if (DECL_INITIAL (decl
) == 0
3094 && DECL_INITIAL (decl
) == error_mark_node
))
3098 if (NULL
!= dbxout_common_check (decl
, &offs
))
3106 else if (DECL_IN_TEXT_SECTION (decl
))
3107 /* This is not quite right, but it's the closest
3108 of all the codes that Unix defines. */
3109 code
= DBX_STATIC_CONST_VAR_CODE
;
3112 /* Ultrix `as' seems to need this. */
3113 #ifdef DBX_STATIC_STAB_DATA_SECTION
3114 switch_to_section (data_section
);
3120 else if (regno
>= 0)
3124 number
= DBX_REGISTER_NUMBER (regno
);
3126 else if (MEM_P (home
)
3127 && (MEM_P (XEXP (home
, 0))
3128 || (REG_P (XEXP (home
, 0))
3129 && REGNO (XEXP (home
, 0)) != HARD_FRAME_POINTER_REGNUM
3130 && REGNO (XEXP (home
, 0)) != STACK_POINTER_REGNUM
3131 #if !HARD_FRAME_POINTER_IS_ARG_POINTER
3132 && REGNO (XEXP (home
, 0)) != ARG_POINTER_REGNUM
3135 /* If the value is indirect by memory or by a register
3136 that isn't the frame pointer
3137 then it means the object is variable-sized and address through
3138 that register or stack slot. DBX has no way to represent this
3139 so all we can do is output the variable as a pointer.
3140 If it's not a parameter, ignore it. */
3142 if (REG_P (XEXP (home
, 0)))
3146 if (REGNO (XEXP (home
, 0)) >= FIRST_PSEUDO_REGISTER
)
3148 number
= DBX_REGISTER_NUMBER (REGNO (XEXP (home
, 0)));
3153 /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
3154 We want the value of that CONST_INT. */
3155 number
= DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home
, 0), 0));
3158 /* Effectively do build_pointer_type, but don't cache this type,
3159 since it might be temporary whereas the type it points to
3160 might have been saved for inlining. */
3161 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
3162 type
= make_node (POINTER_TYPE
);
3163 TREE_TYPE (type
) = TREE_TYPE (decl
);
3165 else if (MEM_P (home
)
3166 && REG_P (XEXP (home
, 0)))
3169 number
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
3171 else if (MEM_P (home
)
3172 && GET_CODE (XEXP (home
, 0)) == PLUS
3173 && CONST_INT_P (XEXP (XEXP (home
, 0), 1)))
3176 /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
3177 We want the value of that CONST_INT. */
3178 number
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
3180 else if (MEM_P (home
)
3181 && GET_CODE (XEXP (home
, 0)) == CONST
)
3183 /* Handle an obscure case which can arise when optimizing and
3184 when there are few available registers. (This is *always*
3185 the case for i386/i486 targets). The RTL looks like
3186 (MEM (CONST ...)) even though this variable is a local `auto'
3187 or a local `register' variable. In effect, what has happened
3188 is that the reload pass has seen that all assignments and
3189 references for one such a local variable can be replaced by
3190 equivalent assignments and references to some static storage
3191 variable, thereby avoiding the need for a register. In such
3192 cases we're forced to lie to debuggers and tell them that
3193 this variable was itself `static'. */
3197 if (NULL
== dbxout_common_check (decl
, &offs
))
3198 addr
= XEXP (XEXP (home
, 0), 0);
3206 else if (GET_CODE (home
) == CONCAT
)
3210 /* If TYPE is not a COMPLEX_TYPE (it might be a RECORD_TYPE,
3211 for example), then there is no easy way to figure out
3212 what SUBTYPE should be. So, we give up. */
3213 if (TREE_CODE (type
) != COMPLEX_TYPE
)
3216 subtype
= TREE_TYPE (type
);
3218 /* If the variable's storage is in two parts,
3219 output each as a separate stab with a modified name. */
3220 if (WORDS_BIG_ENDIAN
)
3221 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 0));
3223 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 0));
3225 if (WORDS_BIG_ENDIAN
)
3226 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 1));
3228 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 1));
3232 /* Address might be a MEM, when DECL is a variable-sized object.
3233 Or it might be const0_rtx, meaning previous passes
3234 want us to ignore this variable. */
3237 /* Ok, start a symtab entry and output the variable name. */
3238 emit_pending_bincls_if_required ();
3241 #ifdef DBX_STATIC_BLOCK_START
3242 DBX_STATIC_BLOCK_START (asm_out_file
, code
);
3245 dbxout_begin_complex_stabs_noforcetext ();
3246 dbxout_symbol_name (decl
, suffix
, letter
);
3247 dbxout_type (type
, 0);
3248 dbxout_finish_complex_stabs (decl
, code
, addr
, 0, number
);
3250 #ifdef DBX_STATIC_BLOCK_END
3251 DBX_STATIC_BLOCK_END (asm_out_file
, code
);
3256 /* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
3257 Then output LETTER to indicate the kind of location the symbol has. */
3260 dbxout_symbol_name (tree decl
, const char *suffix
, int letter
)
3264 if (DECL_CONTEXT (decl
)
3265 && (TYPE_P (DECL_CONTEXT (decl
))
3266 || TREE_CODE (DECL_CONTEXT (decl
)) == NAMESPACE_DECL
))
3267 /* One slight hitch: if this is a VAR_DECL which is a class member
3268 or a namespace member, we must put out the mangled name instead of the
3269 DECL_NAME. Note also that static member (variable) names DO NOT begin
3270 with underscores in .stabs directives. */
3271 name
= DECL_ASSEMBLER_NAME (decl
);
3273 /* ...but if we're function-local, we don't want to include the junk
3274 added by ASM_FORMAT_PRIVATE_NAME. */
3275 name
= DECL_NAME (decl
);
3280 stabstr_S ("(anon)");
3290 /* Output the common block name for DECL in a stabs.
3292 Symbols in global common (.comm) get wrapped with an N_BCOMM/N_ECOMM pair
3293 around each group of symbols in the same .comm area. The N_GSYM stabs
3294 that are emitted only contain the offset in the common area. This routine
3295 emits the N_BCOMM and N_ECOMM stabs. */
3298 dbxout_common_name (tree decl
, const char *name
, stab_code_type op
)
3300 dbxout_begin_complex_stabs ();
3302 dbxout_finish_complex_stabs (decl
, op
, NULL_RTX
, NULL
, 0);
3305 /* Check decl to determine whether it is a VAR_DECL destined for storage in a
3306 common area. If it is, the return value will be a non-null string giving
3307 the name of the common storage block it will go into. If non-null, the
3308 value is the offset into the common block for that symbol's storage. */
3311 dbxout_common_check (tree decl
, int *value
)
3315 const char *name
= NULL
;
3317 /* If the decl isn't a VAR_DECL, or if it isn't static, or if
3318 it does not have a value (the offset into the common area), or if it
3319 is thread local (as opposed to global) then it isn't common, and shouldn't
3322 ??? DECL_THREAD_LOCAL_P check prevents problems with improper .stabs
3323 for thread-local symbols. Can be handled via same mechanism as used
3326 || !TREE_STATIC (decl
)
3327 || !DECL_HAS_VALUE_EXPR_P (decl
)
3328 || DECL_THREAD_LOCAL_P (decl
)
3332 home
= DECL_RTL (decl
);
3333 if (home
== NULL_RTX
|| GET_CODE (home
) != MEM
)
3336 sym_addr
= dbxout_expand_expr (DECL_VALUE_EXPR (decl
));
3337 if (sym_addr
== NULL_RTX
|| GET_CODE (sym_addr
) != MEM
)
3340 sym_addr
= XEXP (sym_addr
, 0);
3341 if (GET_CODE (sym_addr
) == CONST
)
3342 sym_addr
= XEXP (sym_addr
, 0);
3343 if ((GET_CODE (sym_addr
) == SYMBOL_REF
|| GET_CODE (sym_addr
) == PLUS
)
3344 && DECL_INITIAL (decl
) == 0)
3347 /* We have a sym that will go into a common area, meaning that it
3348 will get storage reserved with a .comm/.lcomm assembler pseudo-op.
3350 Determine name of common area this symbol will be an offset into,
3351 and offset into that area. Also retrieve the decl for the area
3352 that the symbol is offset into. */
3355 switch (GET_CODE (sym_addr
))
3358 if (CONST_INT_P (XEXP (sym_addr
, 0)))
3361 targetm
.strip_name_encoding (XSTR (XEXP (sym_addr
, 1), 0));
3362 *value
= INTVAL (XEXP (sym_addr
, 0));
3363 cdecl = SYMBOL_REF_DECL (XEXP (sym_addr
, 1));
3368 targetm
.strip_name_encoding (XSTR (XEXP (sym_addr
, 0), 0));
3369 *value
= INTVAL (XEXP (sym_addr
, 1));
3370 cdecl = SYMBOL_REF_DECL (XEXP (sym_addr
, 0));
3375 name
= targetm
.strip_name_encoding (XSTR (sym_addr
, 0));
3377 cdecl = SYMBOL_REF_DECL (sym_addr
);
3381 error ("common symbol debug info is not structured as "
3385 /* Check area common symbol is offset into. If this is not public, then
3386 it is not a symbol in a common block. It must be a .lcomm symbol, not
3388 if (cdecl == NULL
|| !TREE_PUBLIC (cdecl))
3397 /* Output definitions of all the decls in a chain. Return nonzero if
3398 anything was output */
3401 dbxout_syms (tree syms
)
3404 const char *comm_prev
= NULL
;
3405 tree syms_prev
= NULL
;
3409 int temp
, copen
, cclos
;
3410 const char *comm_new
;
3412 /* Check for common symbol, and then progression into a new/different
3413 block of common symbols. Emit closing/opening common bracket if
3415 comm_new
= dbxout_common_check (syms
, &temp
);
3416 copen
= comm_new
!= NULL
3417 && (comm_prev
== NULL
|| strcmp (comm_new
, comm_prev
));
3418 cclos
= comm_prev
!= NULL
3419 && (comm_new
== NULL
|| strcmp (comm_new
, comm_prev
));
3421 dbxout_common_name (syms_prev
, comm_prev
, N_ECOMM
);
3424 dbxout_common_name (syms
, comm_new
, N_BCOMM
);
3427 comm_prev
= comm_new
;
3429 result
+= dbxout_symbol (syms
, 1);
3430 syms
= DECL_CHAIN (syms
);
3433 if (comm_prev
!= NULL
)
3434 dbxout_common_name (syms_prev
, comm_prev
, N_ECOMM
);
3439 /* The following two functions output definitions of function parameters.
3440 Each parameter gets a definition locating it in the parameter list.
3441 Each parameter that is a register variable gets a second definition
3442 locating it in the register.
3444 Printing or argument lists in gdb uses the definitions that
3445 locate in the parameter list. But reference to the variable in
3446 expressions uses preferentially the definition as a register. */
3448 /* Output definitions, referring to storage in the parmlist,
3449 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
3452 dbxout_parms (tree parms
)
3455 emit_pending_bincls_if_required ();
3456 fixed_size_mode rtl_mode
, type_mode
;
3458 for (; parms
; parms
= DECL_CHAIN (parms
))
3459 if (DECL_NAME (parms
)
3460 && TREE_TYPE (parms
) != error_mark_node
3461 && DECL_RTL_SET_P (parms
)
3462 && DECL_INCOMING_RTL (parms
)
3463 /* We can't represent variable-sized types in this format. */
3464 && is_a
<fixed_size_mode
> (TYPE_MODE (TREE_TYPE (parms
)), &type_mode
)
3465 && is_a
<fixed_size_mode
> (GET_MODE (DECL_RTL (parms
)), &rtl_mode
))
3469 stab_code_type code
;
3472 /* Perform any necessary register eliminations on the parameter's rtl,
3473 so that the debugging output will be accurate. */
3474 DECL_INCOMING_RTL (parms
)
3475 = eliminate_regs (DECL_INCOMING_RTL (parms
), VOIDmode
, NULL_RTX
);
3476 SET_DECL_RTL (parms
,
3477 eliminate_regs (DECL_RTL (parms
), VOIDmode
, NULL_RTX
));
3478 #ifdef LEAF_REG_REMAP
3479 if (crtl
->uses_only_leaf_regs
)
3481 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms
));
3482 leaf_renumber_regs_insn (DECL_RTL (parms
));
3486 if (PARM_PASSED_IN_MEMORY (parms
))
3488 rtx inrtl
= XEXP (DECL_INCOMING_RTL (parms
), 0);
3490 /* ??? Here we assume that the parm address is indexed
3491 off the frame pointer or arg pointer.
3492 If that is not true, we produce meaningless results,
3493 but do not crash. */
3494 if (GET_CODE (inrtl
) == PLUS
3495 && CONST_INT_P (XEXP (inrtl
, 1)))
3496 number
= INTVAL (XEXP (inrtl
, 1));
3501 number
= DEBUGGER_ARG_OFFSET (number
, inrtl
);
3504 /* It is quite tempting to use TREE_TYPE (parms) instead
3505 of DECL_ARG_TYPE (parms) for the eff_type, so that gcc
3506 reports the actual type of the parameter, rather than
3507 the promoted type. This certainly makes GDB's life
3508 easier, at least for some ports. The change is a bad
3509 idea however, since GDB expects to be able access the
3510 type without performing any conversions. So for
3511 example, if we were passing a float to an unprototyped
3512 function, gcc will store a double on the stack, but if
3513 we emit a stab saying the type is a float, then gdb
3514 will only read in a single value, and this will produce
3515 an erroneous value. */
3516 eff_type
= DECL_ARG_TYPE (parms
);
3518 else if (REG_P (DECL_RTL (parms
)))
3522 /* Parm passed in registers and lives in registers or nowhere. */
3523 code
= DBX_REGPARM_STABS_CODE
;
3524 letter
= DBX_REGPARM_STABS_LETTER
;
3526 /* For parms passed in registers, it is better to use the
3527 declared type of the variable, not the type it arrived in. */
3528 eff_type
= TREE_TYPE (parms
);
3530 /* If parm lives in a register, use that register; pretend
3531 the parm was passed there. It would be more consistent
3532 to describe the register where the parm was passed, but
3533 in practice that register usually holds something else.
3534 If the parm lives nowhere, use the register where it
3536 if (REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
3537 best_rtl
= DECL_RTL (parms
);
3538 else if (GET_CODE (DECL_INCOMING_RTL (parms
)) == PARALLEL
)
3539 best_rtl
= XEXP (XVECEXP (DECL_INCOMING_RTL (parms
), 0, 0), 0);
3541 best_rtl
= DECL_INCOMING_RTL (parms
);
3543 number
= DBX_REGISTER_NUMBER (REGNO (best_rtl
));
3545 else if (MEM_P (DECL_RTL (parms
))
3546 && REG_P (XEXP (DECL_RTL (parms
), 0))
3547 && REGNO (XEXP (DECL_RTL (parms
), 0)) != HARD_FRAME_POINTER_REGNUM
3548 && REGNO (XEXP (DECL_RTL (parms
), 0)) != STACK_POINTER_REGNUM
3549 #if !HARD_FRAME_POINTER_IS_ARG_POINTER
3550 && REGNO (XEXP (DECL_RTL (parms
), 0)) != ARG_POINTER_REGNUM
3554 /* Parm was passed via invisible reference.
3555 That is, its address was passed in a register.
3556 Output it as if it lived in that register.
3557 The debugger will know from the type
3558 that it was actually passed by invisible reference. */
3560 code
= DBX_REGPARM_STABS_CODE
;
3562 /* GDB likes this marked with a special letter. */
3563 letter
= (use_gnu_debug_info_extensions
3564 ? 'a' : DBX_REGPARM_STABS_LETTER
);
3565 eff_type
= TREE_TYPE (parms
);
3567 /* DECL_RTL looks like (MEM (REG...). Get the register number.
3568 If it is an unallocated pseudo-reg, then use the register where
3569 it was passed instead.
3570 ??? Why is DBX_REGISTER_NUMBER not used here? */
3572 if (REGNO (XEXP (DECL_RTL (parms
), 0)) < FIRST_PSEUDO_REGISTER
)
3573 number
= REGNO (XEXP (DECL_RTL (parms
), 0));
3575 number
= REGNO (DECL_INCOMING_RTL (parms
));
3577 else if (MEM_P (DECL_RTL (parms
))
3578 && MEM_P (XEXP (DECL_RTL (parms
), 0)))
3580 /* Parm was passed via invisible reference, with the reference
3581 living on the stack. DECL_RTL looks like
3582 (MEM (MEM (PLUS (REG ...) (CONST_INT ...)))) or it
3583 could look like (MEM (MEM (REG))). */
3587 eff_type
= TREE_TYPE (parms
);
3589 if (!REG_P (XEXP (XEXP (DECL_RTL (parms
), 0), 0)))
3590 number
= INTVAL (XEXP (XEXP (XEXP (DECL_RTL (parms
), 0), 0), 1));
3594 number
= DEBUGGER_ARG_OFFSET (number
,
3595 XEXP (XEXP (DECL_RTL (parms
), 0), 0));
3597 else if (MEM_P (DECL_RTL (parms
))
3598 && XEXP (DECL_RTL (parms
), 0) != const0_rtx
3599 /* ??? A constant address for a parm can happen
3600 when the reg it lives in is equiv to a constant in memory.
3601 Should make this not happen, after 2.4. */
3602 && ! CONSTANT_P (XEXP (DECL_RTL (parms
), 0)))
3604 /* Parm was passed in registers but lives on the stack. */
3608 eff_type
= TREE_TYPE (parms
);
3610 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
3611 in which case we want the value of that CONST_INT,
3613 in which case we use a value of zero. */
3614 if (!REG_P (XEXP (DECL_RTL (parms
), 0)))
3615 number
= INTVAL (XEXP (XEXP (DECL_RTL (parms
), 0), 1));
3619 /* Make a big endian correction if the mode of the type of the
3620 parameter is not the same as the mode of the rtl. */
3621 if (BYTES_BIG_ENDIAN
3622 && type_mode
!= rtl_mode
3623 && GET_MODE_SIZE (type_mode
) < UNITS_PER_WORD
)
3624 number
+= GET_MODE_SIZE (rtl_mode
) - GET_MODE_SIZE (type_mode
);
3627 /* ??? We don't know how to represent this argument. */
3630 dbxout_begin_complex_stabs ();
3632 if (DECL_NAME (parms
))
3634 stabstr_I (DECL_NAME (parms
));
3638 stabstr_S ("(anon):");
3640 dbxout_type (eff_type
, 0);
3641 dbxout_finish_complex_stabs (parms
, code
, 0, 0, number
);
3643 DBXOUT_DECR_NESTING
;
3646 /* Output definitions for the places where parms live during the function,
3647 when different from where they were passed, when the parms were passed
3650 It is not useful to do this for parms passed in registers
3651 that live during the function in different registers, because it is
3652 impossible to look in the passed register for the passed value,
3653 so we use the within-the-function register to begin with.
3655 PARMS is a chain of PARM_DECL nodes. */
3658 dbxout_reg_parms (tree parms
)
3662 for (; parms
; parms
= DECL_CHAIN (parms
))
3663 if (DECL_NAME (parms
) && PARM_PASSED_IN_MEMORY (parms
))
3665 /* Report parms that live in registers during the function
3666 but were passed in memory. */
3667 if (REG_P (DECL_RTL (parms
))
3668 && REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
3669 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
3670 0, DECL_RTL (parms
));
3671 else if (GET_CODE (DECL_RTL (parms
)) == CONCAT
)
3672 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
3673 0, DECL_RTL (parms
));
3674 /* Report parms that live in memory but not where they were passed. */
3675 else if (MEM_P (DECL_RTL (parms
))
3676 && ! rtx_equal_p (DECL_RTL (parms
), DECL_INCOMING_RTL (parms
)))
3677 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
3678 0, DECL_RTL (parms
));
3680 DBXOUT_DECR_NESTING
;
3683 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
3684 output definitions of those names, in raw form */
3687 dbxout_args (tree args
)
3692 dbxout_type (TREE_VALUE (args
), 0);
3693 args
= TREE_CHAIN (args
);
3697 #if defined (DBX_DEBUGGING_INFO)
3699 /* Subroutine of dbxout_block. Emit an N_LBRAC stab referencing LABEL.
3700 BEGIN_LABEL is the name of the beginning of the function, which may
3703 dbx_output_lbrac (const char *label
,
3704 const char *begin_label ATTRIBUTE_UNUSED
)
3706 dbxout_begin_stabn (N_LBRAC
);
3707 if (DBX_BLOCKS_FUNCTION_RELATIVE
)
3708 dbxout_stab_value_label_diff (label
, begin_label
);
3710 dbxout_stab_value_label (label
);
3713 /* Subroutine of dbxout_block. Emit an N_RBRAC stab referencing LABEL.
3714 BEGIN_LABEL is the name of the beginning of the function, which may
3717 dbx_output_rbrac (const char *label
,
3718 const char *begin_label ATTRIBUTE_UNUSED
)
3720 dbxout_begin_stabn (N_RBRAC
);
3721 if (DBX_BLOCKS_FUNCTION_RELATIVE
)
3722 dbxout_stab_value_label_diff (label
, begin_label
);
3724 dbxout_stab_value_label (label
);
3727 /* Return true if at least one block among BLOCK, its children or siblings
3728 has TREE_USED, TREE_ASM_WRITTEN and BLOCK_IN_COLD_SECTION_P
3729 set. If there is none, clear TREE_USED bit on such blocks. */
3732 dbx_block_with_cold_children (tree block
)
3735 for (; block
; block
= BLOCK_CHAIN (block
))
3736 if (TREE_USED (block
) && TREE_ASM_WRITTEN (block
))
3738 bool children
= dbx_block_with_cold_children (BLOCK_SUBBLOCKS (block
));
3739 if (BLOCK_IN_COLD_SECTION_P (block
) || children
)
3742 TREE_USED (block
) = false;
3747 /* Output everything about a symbol block (a BLOCK node
3748 that represents a scope level),
3749 including recursive output of contained blocks.
3751 BLOCK is the BLOCK node.
3752 DEPTH is its depth within containing symbol blocks.
3753 ARGS is usually zero; but for the outermost block of the
3754 body of a function, it is a chain of PARM_DECLs for the function parameters.
3755 We output definitions of all the register parms
3756 as if they were local variables of that block.
3758 If -g1 was used, we count blocks just the same, but output nothing
3759 except for the outermost block.
3761 Actually, BLOCK may be several blocks chained together.
3762 We handle them all in sequence.
3764 Return true if we emitted any LBRAC/RBRAC. */
3767 dbxout_block (tree block
, int depth
, tree args
, int parent_blocknum
)
3770 char begin_label
[20];
3771 /* Reference current function start using LFBB. */
3772 ASM_GENERATE_INTERNAL_LABEL (begin_label
, "LFBB", scope_labelno
);
3774 /* If called for the second partition, ignore blocks that don't have
3775 any children in the second partition. */
3776 if (crtl
->has_bb_partition
&& in_cold_section_p
&& depth
== 0)
3777 dbx_block_with_cold_children (block
);
3779 for (; block
; block
= BLOCK_CHAIN (block
))
3781 /* Ignore blocks never expanded or otherwise marked as real. */
3782 if (TREE_USED (block
) && TREE_ASM_WRITTEN (block
))
3785 int blocknum
= BLOCK_NUMBER (block
);
3786 int this_parent
= parent_blocknum
;
3788 /* In dbx format, the syms of a block come before the N_LBRAC.
3789 If nothing is output, we don't need the N_LBRAC, either. */
3791 if (debug_info_level
!= DINFO_LEVEL_TERSE
|| depth
== 0)
3792 did_output
= dbxout_syms (BLOCK_VARS (block
));
3794 dbxout_reg_parms (args
);
3796 /* Now output an N_LBRAC symbol to represent the beginning of
3797 the block. Use the block's tree-walk order to generate
3798 the assembler symbols LBBn and LBEn
3799 that final will define around the code in this block. */
3801 && BLOCK_IN_COLD_SECTION_P (block
) == in_cold_section_p
)
3804 const char *scope_start
;
3808 /* The outermost block doesn't get LBB labels; use
3809 the LFBB local symbol emitted by dbxout_begin_prologue. */
3810 scope_start
= begin_label
;
3813 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBB", blocknum
);
3815 this_parent
= blocknum
;
3818 dbx_output_lbrac (scope_start
, begin_label
);
3821 /* Output the subblocks. */
3823 = dbxout_block (BLOCK_SUBBLOCKS (block
), depth
+ 1, NULL_TREE
,
3827 /* Refer to the marker for the end of the block. */
3829 && BLOCK_IN_COLD_SECTION_P (block
) == in_cold_section_p
)
3833 /* The outermost block doesn't get LBE labels;
3834 use the "scope" label which will be emitted
3835 by dbxout_function_end. */
3836 ASM_GENERATE_INTERNAL_LABEL (buf
, "Lscope", scope_labelno
);
3838 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBE", blocknum
);
3840 dbx_output_rbrac (buf
, begin_label
);
3842 else if (did_output
&& !children
)
3844 /* If we emitted any vars and didn't output any LBRAC/RBRAC,
3845 either at this level or any lower level, we need to emit
3846 an empty LBRAC/RBRAC pair now. */
3848 const char *scope_start
;
3851 if (parent_blocknum
== -1)
3852 scope_start
= begin_label
;
3855 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBB", parent_blocknum
);
3859 dbx_output_lbrac (scope_start
, begin_label
);
3860 dbx_output_rbrac (scope_start
, begin_label
);
3867 /* Output the information about a function and its arguments and result.
3868 Usually this follows the function's code,
3869 but on some systems, it comes before. */
3872 dbxout_begin_function (tree decl
)
3874 int saved_tree_used1
;
3876 saved_tree_used1
= TREE_USED (decl
);
3877 TREE_USED (decl
) = 1;
3878 if (DECL_NAME (DECL_RESULT (decl
)) != 0)
3880 int saved_tree_used2
= TREE_USED (DECL_RESULT (decl
));
3881 TREE_USED (DECL_RESULT (decl
)) = 1;
3882 dbxout_symbol (decl
, 0);
3883 TREE_USED (DECL_RESULT (decl
)) = saved_tree_used2
;
3886 dbxout_symbol (decl
, 0);
3887 TREE_USED (decl
) = saved_tree_used1
;
3889 dbxout_parms (DECL_ARGUMENTS (decl
));
3890 if (DECL_NAME (DECL_RESULT (decl
)) != 0)
3891 dbxout_symbol (DECL_RESULT (decl
), 1);
3893 #endif /* DBX_DEBUGGING_INFO */
3895 #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */
3897 /* Record an element in the table of global destructors. SYMBOL is
3898 a SYMBOL_REF of the function to be called; PRIORITY is a number
3899 between 0 and MAX_INIT_PRIORITY. */
3902 default_stabs_asm_out_destructor (rtx symbol ATTRIBUTE_UNUSED
,
3903 int priority ATTRIBUTE_UNUSED
)
3905 #if defined DBX_DEBUGGING_INFO || defined XCOFF_DEBUGGING_INFO
3906 /* Tell GNU LD that this is part of the static destructor set.
3907 This will work for any system that uses stabs, most usefully
3909 dbxout_begin_simple_stabs ("___DTOR_LIST__", 22 /* N_SETT */);
3910 dbxout_stab_value_label (XSTR (symbol
, 0));
3912 sorry ("global destructors not supported on this target");
3916 /* Likewise for global constructors. */
3919 default_stabs_asm_out_constructor (rtx symbol ATTRIBUTE_UNUSED
,
3920 int priority ATTRIBUTE_UNUSED
)
3922 #if defined DBX_DEBUGGING_INFO || defined XCOFF_DEBUGGING_INFO
3923 /* Tell GNU LD that this is part of the static destructor set.
3924 This will work for any system that uses stabs, most usefully
3926 dbxout_begin_simple_stabs ("___CTOR_LIST__", 22 /* N_SETT */);
3927 dbxout_stab_value_label (XSTR (symbol
, 0));
3929 sorry ("global constructors not supported on this target");
3933 #include "gt-dbxout.h"