1 /* Output dbx-format symbol table information from GNU compiler.
2 Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
4 2011 Free Software Foundation, Inc.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
23 /* Output dbx-format symbol table data.
24 This consists of many symbol table entries, each of them
25 a .stabs assembler pseudo-op with four operands:
26 a "name" which is really a description of one symbol and its type,
27 a "code", which is a symbol defined in stab.h whose name starts with N_,
28 an unused operand always 0,
29 and a "value" which is an address or an offset.
30 The name is enclosed in doublequote characters.
32 Each function, variable, typedef, and structure tag
33 has a symbol table entry to define it.
34 The beginning and end of each level of name scoping within
35 a function are also marked by special symbol table entries.
37 The "name" consists of the symbol name, a colon, a kind-of-symbol letter,
38 and a data type number. The data type number may be followed by
39 "=" and a type definition; normally this will happen the first time
40 the type number is mentioned. The type definition may refer to
41 other types by number, and those type numbers may be followed
42 by "=" and nested definitions.
44 This can make the "name" quite long.
45 When a name is more than 80 characters, we split the .stabs pseudo-op
46 into two .stabs pseudo-ops, both sharing the same "code" and "value".
47 The first one is marked as continued with a double-backslash at the
50 The kind-of-symbol letter distinguished function names from global
51 variables from file-scope variables from parameters from auto
52 variables in memory from typedef names from register variables.
55 The "code" is mostly redundant with the kind-of-symbol letter
56 that goes in the "name", but not entirely: for symbols located
57 in static storage, the "code" says which segment the address is in,
58 which controls how it is relocated.
60 The "value" for a symbol in static storage
61 is the core address of the symbol (actually, the assembler
62 label for the symbol). For a symbol located in a stack slot
63 it is the stack offset; for one in a register, the register number.
64 For a typedef symbol, it is zero.
66 If DEBUG_SYMS_TEXT is defined, all debugging symbols must be
67 output while in the text section.
69 For more on data type definitions, see `dbxout_type'. */
73 #include "coretypes.h"
80 #include "insn-config.h"
84 #include "diagnostic-core.h"
91 #include "langhooks.h"
95 #ifdef XCOFF_DEBUGGING_INFO
99 #define DBXOUT_DECR_NESTING \
100 if (--debug_nesting == 0 && symbol_queue_index > 0) \
101 { emit_pending_bincls_if_required (); debug_flush_symbol_queue (); }
103 #define DBXOUT_DECR_NESTING_AND_RETURN(x) \
104 do {--debug_nesting; return (x);} while (0)
107 # ifdef XCOFF_DEBUGGING_INFO
108 # define ASM_STABS_OP "\t.stabx\t"
110 # define ASM_STABS_OP "\t.stabs\t"
115 #define ASM_STABN_OP "\t.stabn\t"
119 #define ASM_STABD_OP "\t.stabd\t"
122 #ifndef DBX_TYPE_DECL_STABS_CODE
123 #define DBX_TYPE_DECL_STABS_CODE N_LSYM
126 #ifndef DBX_STATIC_CONST_VAR_CODE
127 #define DBX_STATIC_CONST_VAR_CODE N_FUN
130 #ifndef DBX_REGPARM_STABS_CODE
131 #define DBX_REGPARM_STABS_CODE N_RSYM
134 #ifndef DBX_REGPARM_STABS_LETTER
135 #define DBX_REGPARM_STABS_LETTER 'P'
138 #ifndef NO_DBX_FUNCTION_END
139 #define NO_DBX_FUNCTION_END 0
142 #ifndef NO_DBX_BNSYM_ENSYM
143 #define NO_DBX_BNSYM_ENSYM 0
146 #ifndef NO_DBX_MAIN_SOURCE_DIRECTORY
147 #define NO_DBX_MAIN_SOURCE_DIRECTORY 0
150 #ifndef DBX_BLOCKS_FUNCTION_RELATIVE
151 #define DBX_BLOCKS_FUNCTION_RELATIVE 0
154 #ifndef DBX_LINES_FUNCTION_RELATIVE
155 #define DBX_LINES_FUNCTION_RELATIVE 0
158 #ifndef DBX_CONTIN_LENGTH
159 #define DBX_CONTIN_LENGTH 80
162 #ifndef DBX_CONTIN_CHAR
163 #define DBX_CONTIN_CHAR '\\'
166 enum typestatus
{TYPE_UNSEEN
, TYPE_XREF
, TYPE_DEFINED
};
168 /* Structure recording information about a C data type.
169 The status element says whether we have yet output
170 the definition of the type. TYPE_XREF says we have
171 output it as a cross-reference only.
172 The file_number and type_number elements are used if DBX_USE_BINCL
175 struct GTY(()) typeinfo
{
176 enum typestatus status
;
181 /* Vector recording information about C data types.
182 When we first notice a data type (a tree node),
183 we assign it a number using next_type_number.
184 That is its index in this vector. */
186 static GTY ((length ("typevec_len"))) struct typeinfo
*typevec
;
188 /* Number of elements of space allocated in `typevec'. */
190 static GTY(()) int typevec_len
;
192 /* In dbx output, each type gets a unique number.
193 This is the number for the next type output.
194 The number, once assigned, is in the TYPE_SYMTAB_ADDRESS field. */
196 static GTY(()) int next_type_number
;
198 /* The C front end may call dbxout_symbol before dbxout_init runs.
199 We save all such decls in this list and output them when we get
202 static GTY(()) tree preinit_symbols
;
204 enum binclstatus
{BINCL_NOT_REQUIRED
, BINCL_PENDING
, BINCL_PROCESSED
};
206 /* When using N_BINCL in dbx output, each type number is actually a
207 pair of the file number and the type number within the file.
208 This is a stack of input files. */
212 struct dbx_file
*next
;
214 int next_type_number
;
215 enum binclstatus bincl_status
; /* Keep track of lazy bincl. */
216 const char *pending_bincl_name
; /* Name of bincl. */
217 struct dbx_file
*prev
; /* Chain to traverse all pending bincls. */
220 /* This is the top of the stack.
222 This is not saved for PCH, because restoring a PCH should not change it.
223 next_file_number does have to be saved, because the PCH may use some
224 file numbers; however, just before restoring a PCH, next_file_number
225 should always be 0 because we should not have needed any file numbers
228 #if (defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)) \
229 && defined (DBX_USE_BINCL)
230 static struct dbx_file
*current_file
;
233 /* This is the next file number to use. */
235 static GTY(()) int next_file_number
;
237 /* A counter for dbxout_function_end. */
239 static GTY(()) int scope_labelno
;
241 /* A counter for dbxout_source_line. */
243 static GTY(()) int dbxout_source_line_counter
;
245 /* Number for the next N_SOL filename stabs label. The number 0 is reserved
246 for the N_SO filename stabs label. */
248 static GTY(()) int source_label_number
= 1;
250 /* Last source file name mentioned in a NOTE insn. */
252 static GTY(()) const char *lastfile
;
254 /* Used by PCH machinery to detect if 'lastfile' should be reset to
256 static GTY(()) int lastfile_is_base
;
258 /* Typical USG systems don't have stab.h, and they also have
259 no use for DBX-format debugging info. */
261 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
264 /* If zero then there is no pending BINCL. */
265 static int pending_bincls
= 0;
268 /* The original input file name. */
269 static const char *base_input_file
;
271 #ifdef DEBUG_SYMS_TEXT
272 #define FORCE_TEXT switch_to_section (current_function_section ())
279 /* 1 if PARM is passed to this function in memory. */
281 #define PARM_PASSED_IN_MEMORY(PARM) \
282 (MEM_P (DECL_INCOMING_RTL (PARM)))
284 /* A C expression for the integer offset value of an automatic variable
285 (N_LSYM) having address X (an RTX). */
286 #ifndef DEBUGGER_AUTO_OFFSET
287 #define DEBUGGER_AUTO_OFFSET(X) \
288 (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
291 /* A C expression for the integer offset value of an argument (N_PSYM)
292 having address X (an RTX). The nominal offset is OFFSET.
293 Note that we use OFFSET + 0 here to avoid the self-assign warning
294 when the macro is called in a context like
295 number = DEBUGGER_ARG_OFFSET(number, X) */
296 #ifndef DEBUGGER_ARG_OFFSET
297 #define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET + 0)
300 /* This obstack holds the stab string currently being constructed. We
301 build it up here, then write it out, so we can split long lines up
302 properly (see dbxout_finish_complex_stabs). */
303 static struct obstack stabstr_ob
;
304 static size_t stabstr_last_contin_point
;
307 static void emit_bincl_stab (const char *c
);
308 static void emit_pending_bincls (void);
310 static inline void emit_pending_bincls_if_required (void);
312 static void dbxout_init (const char *);
314 static void dbxout_finish (const char *);
315 static void dbxout_start_source_file (unsigned, const char *);
316 static void dbxout_end_source_file (unsigned);
317 static void dbxout_typedefs (tree
);
318 static void dbxout_type_index (tree
);
319 static void dbxout_args (tree
);
320 static void dbxout_type_fields (tree
);
321 static void dbxout_type_method_1 (tree
);
322 static void dbxout_type_methods (tree
);
323 static void dbxout_range_type (tree
, tree
, tree
);
324 static void dbxout_type (tree
, int);
325 static bool print_int_cst_bounds_in_octal_p (tree
, tree
, tree
);
326 static bool is_fortran (void);
327 static void dbxout_type_name (tree
);
328 static void dbxout_class_name_qualifiers (tree
);
329 static int dbxout_symbol_location (tree
, tree
, const char *, rtx
);
330 static void dbxout_symbol_name (tree
, const char *, int);
331 static void dbxout_common_name (tree
, const char *, stab_code_type
);
332 static const char *dbxout_common_check (tree
, int *);
333 static void dbxout_global_decl (tree
);
334 static void dbxout_type_decl (tree
, int);
335 static void dbxout_handle_pch (unsigned);
337 /* The debug hooks structure. */
338 #if defined (DBX_DEBUGGING_INFO)
340 static void dbxout_source_line (unsigned int, const char *, int, bool);
341 static void dbxout_begin_prologue (unsigned int, const char *);
342 static void dbxout_source_file (const char *);
343 static void dbxout_function_end (tree
);
344 static void dbxout_begin_function (tree
);
345 static void dbxout_begin_block (unsigned, unsigned);
346 static void dbxout_end_block (unsigned, unsigned);
347 static void dbxout_function_decl (tree
);
349 const struct gcc_debug_hooks dbx_debug_hooks
=
354 debug_nothing_int_charstar
,
355 debug_nothing_int_charstar
,
356 dbxout_start_source_file
,
357 dbxout_end_source_file
,
360 debug_true_const_tree
, /* ignore_block */
361 dbxout_source_line
, /* source_line */
362 dbxout_begin_prologue
, /* begin_prologue */
363 debug_nothing_int_charstar
, /* end_prologue */
364 debug_nothing_int_charstar
, /* begin_epilogue */
365 debug_nothing_int_charstar
, /* end_epilogue */
366 #ifdef DBX_FUNCTION_FIRST
367 dbxout_begin_function
,
369 debug_nothing_tree
, /* begin_function */
371 debug_nothing_int
, /* end_function */
372 dbxout_function_decl
,
373 dbxout_global_decl
, /* global_decl */
374 dbxout_type_decl
, /* type_decl */
375 debug_nothing_tree_tree_tree_bool
, /* imported_module_or_decl */
376 debug_nothing_tree
, /* deferred_inline_function */
377 debug_nothing_tree
, /* outlining_inline_function */
378 debug_nothing_rtx
, /* label */
379 dbxout_handle_pch
, /* handle_pch */
380 debug_nothing_rtx
, /* var_location */
381 debug_nothing_void
, /* switch_text_section */
382 debug_nothing_tree_tree
, /* set_name */
383 0, /* start_end_main_source_file */
384 TYPE_SYMTAB_IS_ADDRESS
/* tree_type_symtab_field */
386 #endif /* DBX_DEBUGGING_INFO */
388 #if defined (XCOFF_DEBUGGING_INFO)
389 const struct gcc_debug_hooks xcoff_debug_hooks
=
394 debug_nothing_int_charstar
,
395 debug_nothing_int_charstar
,
396 dbxout_start_source_file
,
397 dbxout_end_source_file
,
398 xcoffout_begin_block
,
400 debug_true_const_tree
, /* ignore_block */
401 xcoffout_source_line
,
402 xcoffout_begin_prologue
, /* begin_prologue */
403 debug_nothing_int_charstar
, /* end_prologue */
404 debug_nothing_int_charstar
, /* begin_epilogue */
405 xcoffout_end_epilogue
,
406 debug_nothing_tree
, /* begin_function */
407 xcoffout_end_function
,
408 debug_nothing_tree
, /* function_decl */
409 dbxout_global_decl
, /* global_decl */
410 dbxout_type_decl
, /* type_decl */
411 debug_nothing_tree_tree_tree_bool
, /* imported_module_or_decl */
412 debug_nothing_tree
, /* deferred_inline_function */
413 debug_nothing_tree
, /* outlining_inline_function */
414 debug_nothing_rtx
, /* label */
415 dbxout_handle_pch
, /* handle_pch */
416 debug_nothing_rtx
, /* var_location */
417 debug_nothing_void
, /* switch_text_section */
418 debug_nothing_tree_tree
, /* set_name */
419 0, /* start_end_main_source_file */
420 TYPE_SYMTAB_IS_ADDRESS
/* tree_type_symtab_field */
422 #endif /* XCOFF_DEBUGGING_INFO */
424 /* Numeric formatting helper macro. Note that this does not handle
426 #define NUMBER_FMT_LOOP(P, NUM, BASE) \
429 int digit = NUM % BASE; \
431 *--P = digit + '0'; \
435 /* Utility: write a decimal integer NUM to asm_out_file. */
440 char *p
= buf
+ sizeof buf
;
445 putc ('0', asm_out_file
);
450 putc ('-', asm_out_file
);
456 NUMBER_FMT_LOOP (p
, unum
, 10);
458 while (p
< buf
+ sizeof buf
)
460 putc (*p
, asm_out_file
);
466 /* Primitives for emitting simple stabs directives. All other stabs
467 routines should use these functions instead of directly emitting
468 stabs. They are exported because machine-dependent code may need
469 to invoke them, e.g. in a DBX_OUTPUT_* macro whose definition
470 forwards to code in CPU.c. */
472 /* The following functions should all be called immediately after one
473 of the dbxout_begin_stab* functions (below). They write out
474 various things as the value of a stab. */
476 /* Write out a literal zero as the value of a stab. */
478 dbxout_stab_value_zero (void)
480 fputs ("0\n", asm_out_file
);
483 /* Write out the label LABEL as the value of a stab. */
485 dbxout_stab_value_label (const char *label
)
487 assemble_name (asm_out_file
, label
);
488 putc ('\n', asm_out_file
);
491 /* Write out the difference of two labels, LABEL - BASE, as the value
494 dbxout_stab_value_label_diff (const char *label
, const char *base
)
496 assemble_name (asm_out_file
, label
);
497 putc ('-', asm_out_file
);
498 assemble_name (asm_out_file
, base
);
499 putc ('\n', asm_out_file
);
502 /* Write out an internal label as the value of a stab, and immediately
503 emit that internal label. This should be used only when
504 dbxout_stabd will not work. STEM is the name stem of the label,
505 COUNTERP is a pointer to a counter variable which will be used to
506 guarantee label uniqueness. */
508 dbxout_stab_value_internal_label (const char *stem
, int *counterp
)
511 int counter
= counterp
? (*counterp
)++ : 0;
513 ASM_GENERATE_INTERNAL_LABEL (label
, stem
, counter
);
514 dbxout_stab_value_label (label
);
515 targetm
.asm_out
.internal_label (asm_out_file
, stem
, counter
);
518 /* Write out the difference between BASE and an internal label as the
519 value of a stab, and immediately emit that internal label. STEM and
520 COUNTERP are as for dbxout_stab_value_internal_label. */
522 dbxout_stab_value_internal_label_diff (const char *stem
, int *counterp
,
526 int counter
= counterp
? (*counterp
)++ : 0;
528 ASM_GENERATE_INTERNAL_LABEL (label
, stem
, counter
);
529 dbxout_stab_value_label_diff (label
, base
);
530 targetm
.asm_out
.internal_label (asm_out_file
, stem
, counter
);
533 /* The following functions produce specific kinds of stab directives. */
535 /* Write a .stabd directive with type STYPE and desc SDESC to asm_out_file. */
537 dbxout_stabd (int stype
, int sdesc
)
539 fputs (ASM_STABD_OP
, asm_out_file
);
541 fputs (",0,", asm_out_file
);
543 putc ('\n', asm_out_file
);
546 /* Write a .stabn directive with type STYPE. This function stops
547 short of emitting the value field, which is the responsibility of
548 the caller (normally it will be either a symbol or the difference
552 dbxout_begin_stabn (int stype
)
554 fputs (ASM_STABN_OP
, asm_out_file
);
556 fputs (",0,0,", asm_out_file
);
559 /* Write a .stabn directive with type N_SLINE and desc LINE. As above,
560 the value field is the responsibility of the caller. */
562 dbxout_begin_stabn_sline (int lineno
)
564 fputs (ASM_STABN_OP
, asm_out_file
);
565 dbxout_int (N_SLINE
);
566 fputs (",0,", asm_out_file
);
568 putc (',', asm_out_file
);
571 /* Begin a .stabs directive with string "", type STYPE, and desc and
572 other fields 0. The value field is the responsibility of the
573 caller. This function cannot be used for .stabx directives. */
575 dbxout_begin_empty_stabs (int stype
)
577 fputs (ASM_STABS_OP
, asm_out_file
);
578 fputs ("\"\",", asm_out_file
);
580 fputs (",0,0,", asm_out_file
);
583 /* Begin a .stabs directive with string STR, type STYPE, and desc 0.
584 The value field is the responsibility of the caller. */
586 dbxout_begin_simple_stabs (const char *str
, int stype
)
588 fputs (ASM_STABS_OP
, asm_out_file
);
589 output_quoted_string (asm_out_file
, str
);
590 putc (',', asm_out_file
);
592 fputs (",0,0,", asm_out_file
);
595 /* As above but use SDESC for the desc field. */
597 dbxout_begin_simple_stabs_desc (const char *str
, int stype
, int sdesc
)
599 fputs (ASM_STABS_OP
, asm_out_file
);
600 output_quoted_string (asm_out_file
, str
);
601 putc (',', asm_out_file
);
603 fputs (",0,", asm_out_file
);
605 putc (',', asm_out_file
);
608 /* The next set of functions are entirely concerned with production of
609 "complex" .stabs directives: that is, .stabs directives whose
610 strings have to be constructed piecemeal. dbxout_type,
611 dbxout_symbol, etc. use these routines heavily. The string is queued
612 up in an obstack, then written out by dbxout_finish_complex_stabs, which
613 is also responsible for splitting it up if it exceeds DBX_CONTIN_LENGTH.
614 (You might think it would be more efficient to go straight to stdio
615 when DBX_CONTIN_LENGTH is 0 (i.e. no length limit) but that turns
616 out not to be the case, and anyway this needs fewer #ifdefs.) */
618 /* Begin a complex .stabs directive. If we can, write the initial
619 ASM_STABS_OP to the asm_out_file. */
622 dbxout_begin_complex_stabs (void)
624 emit_pending_bincls_if_required ();
626 fputs (ASM_STABS_OP
, asm_out_file
);
627 putc ('"', asm_out_file
);
628 gcc_assert (stabstr_last_contin_point
== 0);
631 /* As above, but do not force text or emit pending bincls. This is
632 used by dbxout_symbol_location, which needs to do something else. */
634 dbxout_begin_complex_stabs_noforcetext (void)
636 fputs (ASM_STABS_OP
, asm_out_file
);
637 putc ('"', asm_out_file
);
638 gcc_assert (stabstr_last_contin_point
== 0);
641 /* Add CHR, a single character, to the string being built. */
642 #define stabstr_C(chr) obstack_1grow (&stabstr_ob, chr)
644 /* Add STR, a normal C string, to the string being built. */
645 #define stabstr_S(str) obstack_grow (&stabstr_ob, str, strlen(str))
647 /* Add the text of ID, an IDENTIFIER_NODE, to the string being built. */
648 #define stabstr_I(id) obstack_grow (&stabstr_ob, \
649 IDENTIFIER_POINTER (id), \
650 IDENTIFIER_LENGTH (id))
652 /* Add NUM, a signed decimal number, to the string being built. */
654 stabstr_D (HOST_WIDE_INT num
)
657 char *p
= buf
+ sizeof buf
;
673 NUMBER_FMT_LOOP (p
, unum
, 10);
675 obstack_grow (&stabstr_ob
, p
, (buf
+ sizeof buf
) - p
);
678 /* Add NUM, an unsigned decimal number, to the string being built. */
680 stabstr_U (unsigned HOST_WIDE_INT num
)
683 char *p
= buf
+ sizeof buf
;
689 NUMBER_FMT_LOOP (p
, num
, 10);
690 obstack_grow (&stabstr_ob
, p
, (buf
+ sizeof buf
) - p
);
693 /* Add CST, an INTEGER_CST tree, to the string being built as an
694 unsigned octal number. This routine handles values which are
695 larger than a single HOST_WIDE_INT. */
699 unsigned HOST_WIDE_INT high
= TREE_INT_CST_HIGH (cst
);
700 unsigned HOST_WIDE_INT low
= TREE_INT_CST_LOW (cst
);
703 char *p
= buf
+ sizeof buf
;
705 /* GDB wants constants with no extra leading "1" bits, so
706 we need to remove any sign-extension that might be
709 const unsigned int width
= TYPE_PRECISION (TREE_TYPE (cst
));
710 if (width
== HOST_BITS_PER_WIDE_INT
* 2)
712 else if (width
> HOST_BITS_PER_WIDE_INT
)
713 high
&= (((HOST_WIDE_INT
) 1 << (width
- HOST_BITS_PER_WIDE_INT
)) - 1);
714 else if (width
== HOST_BITS_PER_WIDE_INT
)
717 high
= 0, low
&= (((HOST_WIDE_INT
) 1 << width
) - 1);
720 /* Leading zero for base indicator. */
723 /* If the value is zero, the base indicator will serve as the value
725 if (high
== 0 && low
== 0)
728 /* If the high half is zero, we need only print the low half normally. */
730 NUMBER_FMT_LOOP (p
, low
, 8);
733 /* When high != 0, we need to print enough zeroes from low to
734 give the digits from high their proper place-values. Hence
735 NUMBER_FMT_LOOP cannot be used. */
736 const int n_digits
= HOST_BITS_PER_WIDE_INT
/ 3;
739 for (i
= 1; i
<= n_digits
; i
++)
741 unsigned int digit
= low
% 8;
746 /* Octal digits carry exactly three bits of information. The
747 width of a HOST_WIDE_INT is not normally a multiple of three.
748 Therefore, the next digit printed probably needs to carry
749 information from both low and high. */
750 if (HOST_BITS_PER_WIDE_INT
% 3 != 0)
752 const int n_leftover_bits
= HOST_BITS_PER_WIDE_INT
% 3;
753 const int n_bits_from_high
= 3 - n_leftover_bits
;
755 const unsigned HOST_WIDE_INT
756 low_mask
= (((unsigned HOST_WIDE_INT
)1) << n_leftover_bits
) - 1;
757 const unsigned HOST_WIDE_INT
758 high_mask
= (((unsigned HOST_WIDE_INT
)1) << n_bits_from_high
) - 1;
762 /* At this point, only the bottom n_leftover_bits bits of low
764 gcc_assert (!(low
& ~low_mask
));
766 digit
= (low
| ((high
& high_mask
) << n_leftover_bits
));
767 high
>>= n_bits_from_high
;
772 /* Now we can format high in the normal manner. However, if
773 the only bits of high that were set were handled by the
774 digit split between low and high, high will now be zero, and
775 we don't want to print extra digits in that case. */
777 NUMBER_FMT_LOOP (p
, high
, 8);
780 obstack_grow (&stabstr_ob
, p
, (buf
+ sizeof buf
) - p
);
783 /* Called whenever it is safe to break a stabs string into multiple
784 .stabs directives. If the current string has exceeded the limit
785 set by DBX_CONTIN_LENGTH, mark the current position in the buffer
786 as a continuation point by inserting DBX_CONTIN_CHAR (doubled if
787 it is a backslash) and a null character. */
789 stabstr_continue (void)
791 if (DBX_CONTIN_LENGTH
> 0
792 && obstack_object_size (&stabstr_ob
) - stabstr_last_contin_point
795 if (DBX_CONTIN_CHAR
== '\\')
796 obstack_1grow (&stabstr_ob
, '\\');
797 obstack_1grow (&stabstr_ob
, DBX_CONTIN_CHAR
);
798 obstack_1grow (&stabstr_ob
, '\0');
799 stabstr_last_contin_point
= obstack_object_size (&stabstr_ob
);
802 #define CONTIN stabstr_continue ()
804 /* Macro subroutine of dbxout_finish_complex_stabs, which emits
805 all of the arguments to the .stabs directive after the string.
806 Overridden by xcoffout.h. CODE is the stabs code for this symbol;
807 LINE is the source line to write into the desc field (in extended
808 mode); SYM is the symbol itself.
810 ADDR, LABEL, and NUMBER are three different ways to represent the
811 stabs value field. At most one of these should be nonzero.
813 ADDR is used most of the time; it represents the value as an
814 RTL address constant.
816 LABEL is used (currently) only for N_CATCH stabs; it represents
817 the value as a string suitable for assemble_name.
819 NUMBER is used when the value is an offset from an implicit base
820 pointer (e.g. for a stack variable), or an index (e.g. for a
821 register variable). It represents the value as a decimal integer. */
823 #ifndef DBX_FINISH_STABS
824 #define DBX_FINISH_STABS(SYM, CODE, LINE, ADDR, LABEL, NUMBER) \
826 int line_ = use_gnu_debug_info_extensions ? LINE : 0; \
829 fputs (",0,", asm_out_file); \
830 dbxout_int (line_); \
831 putc (',', asm_out_file); \
833 output_addr_const (asm_out_file, ADDR); \
835 assemble_name (asm_out_file, LABEL); \
837 dbxout_int (NUMBER); \
838 putc ('\n', asm_out_file); \
842 /* Finish the emission of a complex .stabs directive. When DBX_CONTIN_LENGTH
843 is zero, this has only to emit the close quote and the remainder of
844 the arguments. When it is nonzero, the string has been marshalled in
845 stabstr_ob, and this routine is responsible for breaking it up into
846 DBX_CONTIN_LENGTH-sized chunks.
848 SYM is the DECL of the symbol under consideration; it is used only
849 for its DECL_SOURCE_LINE. The other arguments are all passed directly
850 to DBX_FINISH_STABS; see above for details. */
853 dbxout_finish_complex_stabs (tree sym
, stab_code_type code
,
854 rtx addr
, const char *label
, int number
)
856 int line ATTRIBUTE_UNUSED
;
860 line
= sym
? DECL_SOURCE_LINE (sym
) : 0;
861 if (DBX_CONTIN_LENGTH
> 0)
866 /* Nul-terminate the growing string, then get its size and
868 obstack_1grow (&stabstr_ob
, '\0');
870 len
= obstack_object_size (&stabstr_ob
);
871 chunk
= str
= XOBFINISH (&stabstr_ob
, char *);
873 /* Within the buffer are a sequence of NUL-separated strings,
874 each of which is to be written out as a separate stab
878 chunklen
= strlen (chunk
);
879 fwrite (chunk
, 1, chunklen
, asm_out_file
);
880 fputs ("\",", asm_out_file
);
882 /* Must add an extra byte to account for the NUL separator. */
883 chunk
+= chunklen
+ 1;
886 /* Only put a line number on the last stab in the sequence. */
887 DBX_FINISH_STABS (sym
, code
, len
== 0 ? line
: 0,
888 addr
, label
, number
);
892 fputs (ASM_STABS_OP
, asm_out_file
);
893 putc ('"', asm_out_file
);
895 stabstr_last_contin_point
= 0;
899 /* No continuations - we can put the whole string out at once.
900 It is faster to augment the string with the close quote and
901 comma than to do a two-character fputs. */
902 obstack_grow (&stabstr_ob
, "\",", 2);
903 len
= obstack_object_size (&stabstr_ob
);
904 str
= XOBFINISH (&stabstr_ob
, char *);
906 fwrite (str
, 1, len
, asm_out_file
);
907 DBX_FINISH_STABS (sym
, code
, line
, addr
, label
, number
);
909 obstack_free (&stabstr_ob
, str
);
912 #if defined (DBX_DEBUGGING_INFO)
915 dbxout_function_end (tree decl ATTRIBUTE_UNUSED
)
917 char lscope_label_name
[100];
919 /* The Lscope label must be emitted even if we aren't doing anything
920 else; dbxout_block needs it. */
921 switch_to_section (function_section (current_function_decl
));
923 /* Convert Lscope into the appropriate format for local labels in case
924 the system doesn't insert underscores in front of user generated
926 ASM_GENERATE_INTERNAL_LABEL (lscope_label_name
, "Lscope", scope_labelno
);
927 targetm
.asm_out
.internal_label (asm_out_file
, "Lscope", scope_labelno
);
929 /* The N_FUN tag at the end of the function is a GNU extension,
930 which may be undesirable, and is unnecessary if we do not have
932 if (!use_gnu_debug_info_extensions
933 || NO_DBX_FUNCTION_END
934 || !targetm
.have_named_sections
)
937 /* By convention, GCC will mark the end of a function with an N_FUN
938 symbol and an empty string. */
939 if (flag_reorder_blocks_and_partition
)
941 dbxout_begin_empty_stabs (N_FUN
);
942 dbxout_stab_value_label_diff (crtl
->subsections
.hot_section_end_label
,
943 crtl
->subsections
.hot_section_label
);
944 dbxout_begin_empty_stabs (N_FUN
);
945 dbxout_stab_value_label_diff (crtl
->subsections
.cold_section_end_label
,
946 crtl
->subsections
.cold_section_label
);
950 char begin_label
[20];
951 /* Reference current function start using LFBB. */
952 ASM_GENERATE_INTERNAL_LABEL (begin_label
, "LFBB", scope_labelno
);
953 dbxout_begin_empty_stabs (N_FUN
);
954 dbxout_stab_value_label_diff (lscope_label_name
, begin_label
);
957 if (!NO_DBX_BNSYM_ENSYM
&& !flag_debug_only_used_symbols
)
958 dbxout_stabd (N_ENSYM
, 0);
960 #endif /* DBX_DEBUGGING_INFO */
962 /* Get lang description for N_SO stab. */
963 static unsigned int ATTRIBUTE_UNUSED
964 get_lang_number (void)
966 const char *language_string
= lang_hooks
.name
;
968 if (strcmp (language_string
, "GNU C") == 0)
970 else if (strcmp (language_string
, "GNU C++") == 0)
972 else if (strcmp (language_string
, "GNU F77") == 0)
974 else if (strcmp (language_string
, "GNU Fortran") == 0)
975 return N_SO_FORTRAN90
; /* CHECKME */
976 else if (strcmp (language_string
, "GNU Pascal") == 0)
978 else if (strcmp (language_string
, "GNU Objective-C") == 0)
980 else if (strcmp (language_string
, "GNU Objective-C++") == 0)
981 return N_SO_OBJCPLUS
;
990 unsigned int lang
= get_lang_number ();
992 return (lang
== N_SO_FORTRAN
) || (lang
== N_SO_FORTRAN90
);
995 /* At the beginning of compilation, start writing the symbol table.
996 Initialize `typevec' and output the standard data types of C. */
999 dbxout_init (const char *input_file_name
)
1001 char ltext_label_name
[100];
1002 bool used_ltext_label_name
= false;
1003 tree syms
= lang_hooks
.decls
.getdecls ();
1004 const char *mapped_name
;
1007 typevec
= ggc_alloc_cleared_vec_typeinfo (typevec_len
);
1009 /* stabstr_ob contains one string, which will be just fine with
1010 1-byte alignment. */
1011 obstack_specify_allocation (&stabstr_ob
, 0, 1, xmalloc
, free
);
1013 /* Convert Ltext into the appropriate format for local labels in case
1014 the system doesn't insert underscores in front of user generated
1016 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name
, "Ltext", 0);
1018 /* Put the current working directory in an N_SO symbol. */
1019 if (use_gnu_debug_info_extensions
&& !NO_DBX_MAIN_SOURCE_DIRECTORY
)
1021 static const char *cwd
;
1025 cwd
= get_src_pwd ();
1028 else if (!IS_DIR_SEPARATOR (cwd
[strlen (cwd
) - 1]))
1029 cwd
= concat (cwd
, "/", NULL
);
1030 cwd
= remap_debug_filename (cwd
);
1032 #ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
1033 DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asm_out_file
, cwd
);
1034 #else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
1035 dbxout_begin_simple_stabs_desc (cwd
, N_SO
, get_lang_number ());
1036 dbxout_stab_value_label (ltext_label_name
);
1037 used_ltext_label_name
= true;
1038 #endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
1041 mapped_name
= remap_debug_filename (input_file_name
);
1042 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
1043 DBX_OUTPUT_MAIN_SOURCE_FILENAME (asm_out_file
, mapped_name
);
1045 dbxout_begin_simple_stabs_desc (mapped_name
, N_SO
, get_lang_number ());
1046 dbxout_stab_value_label (ltext_label_name
);
1047 used_ltext_label_name
= true;
1050 if (used_ltext_label_name
)
1052 switch_to_section (text_section
);
1053 targetm
.asm_out
.internal_label (asm_out_file
, "Ltext", 0);
1056 /* Emit an N_OPT stab to indicate that this file was compiled by GCC.
1057 The string used is historical. */
1058 #ifndef NO_DBX_GCC_MARKER
1059 dbxout_begin_simple_stabs ("gcc2_compiled.", N_OPT
);
1060 dbxout_stab_value_zero ();
1063 base_input_file
= lastfile
= input_file_name
;
1065 next_type_number
= 1;
1067 #ifdef DBX_USE_BINCL
1068 current_file
= XNEW (struct dbx_file
);
1069 current_file
->next
= NULL
;
1070 current_file
->file_number
= 0;
1071 current_file
->next_type_number
= 1;
1072 next_file_number
= 1;
1073 current_file
->prev
= NULL
;
1074 current_file
->bincl_status
= BINCL_NOT_REQUIRED
;
1075 current_file
->pending_bincl_name
= NULL
;
1078 /* Get all permanent types that have typedef names, and output them
1079 all, except for those already output. Some language front ends
1080 put these declarations in the top-level scope; some do not;
1081 the latter are responsible for calling debug_hooks->type_decl from
1082 their record_builtin_type function. */
1083 dbxout_typedefs (syms
);
1085 if (preinit_symbols
)
1088 for (t
= nreverse (preinit_symbols
); t
; t
= TREE_CHAIN (t
))
1089 dbxout_symbol (TREE_VALUE (t
), 0);
1090 preinit_symbols
= 0;
1094 /* Output any typedef names for types described by TYPE_DECLs in SYMS. */
1097 dbxout_typedefs (tree syms
)
1099 for (; syms
!= NULL_TREE
; syms
= DECL_CHAIN (syms
))
1101 if (TREE_CODE (syms
) == TYPE_DECL
)
1103 tree type
= TREE_TYPE (syms
);
1104 if (TYPE_NAME (type
)
1105 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1106 && COMPLETE_OR_VOID_TYPE_P (type
)
1107 && ! TREE_ASM_WRITTEN (TYPE_NAME (type
)))
1108 dbxout_symbol (TYPE_NAME (type
), 0);
1113 #ifdef DBX_USE_BINCL
1114 /* Emit BINCL stab using given name. */
1116 emit_bincl_stab (const char *name
)
1118 dbxout_begin_simple_stabs (name
, N_BINCL
);
1119 dbxout_stab_value_zero ();
1122 /* If there are pending bincls then it is time to emit all of them. */
1125 emit_pending_bincls_if_required (void)
1128 emit_pending_bincls ();
1131 /* Emit all pending bincls. */
1134 emit_pending_bincls (void)
1136 struct dbx_file
*f
= current_file
;
1138 /* Find first pending bincl. */
1139 while (f
->bincl_status
== BINCL_PENDING
)
1142 /* Now emit all bincls. */
1147 if (f
->bincl_status
== BINCL_PENDING
)
1149 emit_bincl_stab (f
->pending_bincl_name
);
1151 /* Update file number and status. */
1152 f
->file_number
= next_file_number
++;
1153 f
->bincl_status
= BINCL_PROCESSED
;
1155 if (f
== current_file
)
1160 /* All pending bincls have been emitted. */
1167 emit_pending_bincls_if_required (void) {}
1170 /* Change to reading from a new source file. Generate a N_BINCL stab. */
1173 dbxout_start_source_file (unsigned int line ATTRIBUTE_UNUSED
,
1174 const char *filename ATTRIBUTE_UNUSED
)
1176 #ifdef DBX_USE_BINCL
1177 struct dbx_file
*n
= XNEW (struct dbx_file
);
1179 n
->next
= current_file
;
1180 n
->next_type_number
= 1;
1181 /* Do not assign file number now.
1182 Delay it until we actually emit BINCL. */
1185 current_file
->prev
= n
;
1186 n
->bincl_status
= BINCL_PENDING
;
1187 n
->pending_bincl_name
= remap_debug_filename (filename
);
1193 /* Revert to reading a previous source file. Generate a N_EINCL stab. */
1196 dbxout_end_source_file (unsigned int line ATTRIBUTE_UNUSED
)
1198 #ifdef DBX_USE_BINCL
1199 /* Emit EINCL stab only if BINCL is not pending. */
1200 if (current_file
->bincl_status
== BINCL_PROCESSED
)
1202 dbxout_begin_stabn (N_EINCL
);
1203 dbxout_stab_value_zero ();
1205 current_file
->bincl_status
= BINCL_NOT_REQUIRED
;
1206 current_file
= current_file
->next
;
1210 /* Handle a few odd cases that occur when trying to make PCH files work. */
1213 dbxout_handle_pch (unsigned at_end
)
1217 /* When using the PCH, this file will be included, so we need to output
1219 dbxout_start_source_file (0, lastfile
);
1221 /* The base file when using the PCH won't be the same as
1222 the base file when it's being generated. */
1227 /* ... and an EINCL. */
1228 dbxout_end_source_file (0);
1230 /* Deal with cases where 'lastfile' was never actually changed. */
1231 lastfile_is_base
= lastfile
== NULL
;
1235 #if defined (DBX_DEBUGGING_INFO)
1237 static void dbxout_block (tree
, int, tree
);
1239 /* Output debugging info to FILE to switch to sourcefile FILENAME. */
1242 dbxout_source_file (const char *filename
)
1244 if (lastfile
== 0 && lastfile_is_base
)
1246 lastfile
= base_input_file
;
1247 lastfile_is_base
= 0;
1250 if (filename
&& (lastfile
== 0 || strcmp (filename
, lastfile
)))
1252 /* Don't change section amid function. */
1253 if (current_function_decl
== NULL_TREE
)
1254 switch_to_section (text_section
);
1256 dbxout_begin_simple_stabs (remap_debug_filename (filename
), N_SOL
);
1257 dbxout_stab_value_internal_label ("Ltext", &source_label_number
);
1258 lastfile
= filename
;
1262 /* Output N_BNSYM, line number symbol entry, and local symbol at
1266 dbxout_begin_prologue (unsigned int lineno
, const char *filename
)
1268 if (use_gnu_debug_info_extensions
1269 && !NO_DBX_FUNCTION_END
1270 && !NO_DBX_BNSYM_ENSYM
1271 && !flag_debug_only_used_symbols
)
1272 dbxout_stabd (N_BNSYM
, 0);
1274 /* pre-increment the scope counter */
1277 dbxout_source_line (lineno
, filename
, 0, true);
1278 /* Output function begin block at function scope, referenced
1279 by dbxout_block, dbxout_source_line and dbxout_function_end. */
1280 emit_pending_bincls_if_required ();
1281 targetm
.asm_out
.internal_label (asm_out_file
, "LFBB", scope_labelno
);
1284 /* Output a line number symbol entry for source file FILENAME and line
1288 dbxout_source_line (unsigned int lineno
, const char *filename
,
1289 int discriminator ATTRIBUTE_UNUSED
,
1290 bool is_stmt ATTRIBUTE_UNUSED
)
1292 dbxout_source_file (filename
);
1294 #ifdef DBX_OUTPUT_SOURCE_LINE
1295 DBX_OUTPUT_SOURCE_LINE (asm_out_file
, lineno
, dbxout_source_line_counter
);
1297 if (DBX_LINES_FUNCTION_RELATIVE
)
1299 char begin_label
[20];
1300 dbxout_begin_stabn_sline (lineno
);
1301 /* Reference current function start using LFBB. */
1302 ASM_GENERATE_INTERNAL_LABEL (begin_label
, "LFBB", scope_labelno
);
1303 dbxout_stab_value_internal_label_diff ("LM", &dbxout_source_line_counter
,
1307 dbxout_stabd (N_SLINE
, lineno
);
1311 /* Describe the beginning of an internal block within a function. */
1314 dbxout_begin_block (unsigned int line ATTRIBUTE_UNUSED
, unsigned int n
)
1316 emit_pending_bincls_if_required ();
1317 targetm
.asm_out
.internal_label (asm_out_file
, "LBB", n
);
1320 /* Describe the end line-number of an internal block within a function. */
1323 dbxout_end_block (unsigned int line ATTRIBUTE_UNUSED
, unsigned int n
)
1325 emit_pending_bincls_if_required ();
1326 targetm
.asm_out
.internal_label (asm_out_file
, "LBE", n
);
1329 /* Output dbx data for a function definition.
1330 This includes a definition of the function name itself (a symbol),
1331 definitions of the parameters (locating them in the parameter list)
1332 and then output the block that makes up the function's body
1333 (including all the auto variables of the function). */
1336 dbxout_function_decl (tree decl
)
1338 emit_pending_bincls_if_required ();
1339 #ifndef DBX_FUNCTION_FIRST
1340 dbxout_begin_function (decl
);
1342 dbxout_block (DECL_INITIAL (decl
), 0, DECL_ARGUMENTS (decl
));
1343 dbxout_function_end (decl
);
1346 #endif /* DBX_DEBUGGING_INFO */
1348 /* Debug information for a global DECL. Called from toplev.c after
1349 compilation proper has finished. */
1351 dbxout_global_decl (tree decl
)
1353 if (TREE_CODE (decl
) == VAR_DECL
&& !DECL_EXTERNAL (decl
))
1355 int saved_tree_used
= TREE_USED (decl
);
1356 TREE_USED (decl
) = 1;
1357 dbxout_symbol (decl
, 0);
1358 TREE_USED (decl
) = saved_tree_used
;
1362 /* This is just a function-type adapter; dbxout_symbol does exactly
1363 what we want but returns an int. */
1365 dbxout_type_decl (tree decl
, int local
)
1367 dbxout_symbol (decl
, local
);
1370 /* At the end of compilation, finish writing the symbol table.
1371 The default is to call debug_free_queue but do nothing else. */
1374 dbxout_finish (const char *filename ATTRIBUTE_UNUSED
)
1376 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
1377 DBX_OUTPUT_MAIN_SOURCE_FILE_END (asm_out_file
, filename
);
1378 #elif defined DBX_OUTPUT_NULL_N_SO_AT_MAIN_SOURCE_FILE_END
1380 switch_to_section (text_section
);
1381 dbxout_begin_empty_stabs (N_SO
);
1382 dbxout_stab_value_internal_label ("Letext", 0);
1385 debug_free_queue ();
1388 /* Output the index of a type. */
1391 dbxout_type_index (tree type
)
1393 #ifndef DBX_USE_BINCL
1394 stabstr_D (TYPE_SYMTAB_ADDRESS (type
));
1396 struct typeinfo
*t
= &typevec
[TYPE_SYMTAB_ADDRESS (type
)];
1398 stabstr_D (t
->file_number
);
1400 stabstr_D (t
->type_number
);
1407 /* Used in several places: evaluates to '0' for a private decl,
1408 '1' for a protected decl, '2' for a public decl. */
1409 #define DECL_ACCESSIBILITY_CHAR(DECL) \
1410 (TREE_PRIVATE (DECL) ? '0' : TREE_PROTECTED (DECL) ? '1' : '2')
1412 /* Subroutine of `dbxout_type'. Output the type fields of TYPE.
1413 This must be a separate function because anonymous unions require
1417 dbxout_type_fields (tree type
)
1421 /* Output the name, type, position (in bits), size (in bits) of each
1422 field that we can support. */
1423 for (tem
= TYPE_FIELDS (type
); tem
; tem
= DECL_CHAIN (tem
))
1425 /* If one of the nodes is an error_mark or its type is then
1427 if (tem
== error_mark_node
|| TREE_TYPE (tem
) == error_mark_node
)
1430 /* Omit here local type decls until we know how to support them. */
1431 if (TREE_CODE (tem
) == TYPE_DECL
1432 /* Omit here the nameless fields that are used to skip bits. */
1433 || DECL_IGNORED_P (tem
)
1434 /* Omit fields whose position or size are variable or too large to
1436 || (TREE_CODE (tem
) == FIELD_DECL
1437 && (! host_integerp (bit_position (tem
), 0)
1438 || ! DECL_SIZE (tem
)
1439 || ! host_integerp (DECL_SIZE (tem
), 1))))
1442 else if (TREE_CODE (tem
) != CONST_DECL
)
1444 /* Continue the line if necessary,
1445 but not before the first field. */
1446 if (tem
!= TYPE_FIELDS (type
))
1449 if (DECL_NAME (tem
))
1450 stabstr_I (DECL_NAME (tem
));
1453 if (use_gnu_debug_info_extensions
1454 && (TREE_PRIVATE (tem
) || TREE_PROTECTED (tem
)
1455 || TREE_CODE (tem
) != FIELD_DECL
))
1458 stabstr_C (DECL_ACCESSIBILITY_CHAR (tem
));
1461 dbxout_type ((TREE_CODE (tem
) == FIELD_DECL
1462 && DECL_BIT_FIELD_TYPE (tem
))
1463 ? DECL_BIT_FIELD_TYPE (tem
) : TREE_TYPE (tem
), 0);
1465 if (TREE_CODE (tem
) == VAR_DECL
)
1467 if (TREE_STATIC (tem
) && use_gnu_debug_info_extensions
)
1469 tree name
= DECL_ASSEMBLER_NAME (tem
);
1476 /* If TEM is non-static, GDB won't understand it. */
1477 stabstr_S (",0,0;");
1482 stabstr_D (int_bit_position (tem
));
1484 stabstr_D (tree_low_cst (DECL_SIZE (tem
), 1));
1491 /* Subroutine of `dbxout_type_methods'. Output debug info about the
1492 method described DECL. */
1495 dbxout_type_method_1 (tree decl
)
1499 if (TREE_CODE (TREE_TYPE (decl
)) == FUNCTION_TYPE
)
1501 else /* it's a METHOD_TYPE. */
1503 tree firstarg
= TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)));
1504 /* A for normal functions.
1505 B for `const' member functions.
1506 C for `volatile' member functions.
1507 D for `const volatile' member functions. */
1508 if (TYPE_READONLY (TREE_TYPE (firstarg
)))
1510 if (TYPE_VOLATILE (TREE_TYPE (firstarg
)))
1513 if (DECL_VINDEX (decl
))
1519 /* ??? Output the mangled name, which contains an encoding of the
1520 method's type signature. May not be necessary anymore. */
1522 stabstr_I (DECL_ASSEMBLER_NAME (decl
));
1524 stabstr_C (DECL_ACCESSIBILITY_CHAR (decl
));
1528 if (DECL_VINDEX (decl
) && host_integerp (DECL_VINDEX (decl
), 0))
1530 stabstr_D (tree_low_cst (DECL_VINDEX (decl
), 0));
1532 dbxout_type (DECL_CONTEXT (decl
), 0);
1537 /* Subroutine of `dbxout_type'. Output debug info about the methods defined
1541 dbxout_type_methods (tree type
)
1543 /* C++: put out the method names and their parameter lists */
1544 tree methods
= TYPE_METHODS (type
);
1548 if (methods
== NULL_TREE
)
1551 if (TREE_CODE (methods
) != TREE_VEC
)
1553 else if (TREE_VEC_ELT (methods
, 0) != NULL_TREE
)
1554 fndecl
= TREE_VEC_ELT (methods
, 0);
1556 fndecl
= TREE_VEC_ELT (methods
, 1);
1560 int need_prefix
= 1;
1562 /* Group together all the methods for the same operation.
1563 These differ in the types of the arguments. */
1564 for (last
= NULL_TREE
;
1565 fndecl
&& (last
== NULL_TREE
|| DECL_NAME (fndecl
) == DECL_NAME (last
));
1566 fndecl
= DECL_CHAIN (fndecl
))
1567 /* Output the name of the field (after overloading), as
1568 well as the name of the field before overloading, along
1569 with its parameter list */
1571 /* Skip methods that aren't FUNCTION_DECLs. (In C++, these
1572 include TEMPLATE_DECLs.) The debugger doesn't know what
1573 to do with such entities anyhow. */
1574 if (TREE_CODE (fndecl
) != FUNCTION_DECL
)
1581 /* Also ignore abstract methods; those are only interesting to
1582 the DWARF backends. */
1583 if (DECL_IGNORED_P (fndecl
) || DECL_ABSTRACT (fndecl
))
1586 /* Redundantly output the plain name, since that's what gdb
1590 stabstr_I (DECL_NAME (fndecl
));
1595 dbxout_type (TREE_TYPE (fndecl
), 0);
1596 dbxout_type_method_1 (fndecl
);
1603 /* Emit a "range" type specification, which has the form:
1604 "r<index type>;<lower bound>;<upper bound>;".
1605 TYPE is an INTEGER_TYPE, LOW and HIGH are the bounds. */
1608 dbxout_range_type (tree type
, tree low
, tree high
)
1611 if (TREE_TYPE (type
))
1612 dbxout_type (TREE_TYPE (type
), 0);
1613 else if (TREE_CODE (type
) != INTEGER_TYPE
)
1614 dbxout_type (type
, 0); /* E.g. Pascal's ARRAY [BOOLEAN] of INTEGER */
1617 /* Traditionally, we made sure 'int' was type 1, and builtin types
1618 were defined to be sub-ranges of int. Unfortunately, this
1619 does not allow us to distinguish true sub-ranges from integer
1620 types. So, instead we define integer (non-sub-range) types as
1621 sub-ranges of themselves. This matters for Chill. If this isn't
1622 a subrange type, then we want to define it in terms of itself.
1623 However, in C, this may be an anonymous integer type, and we don't
1624 want to emit debug info referring to it. Just calling
1625 dbxout_type_index won't work anyways, because the type hasn't been
1626 defined yet. We make this work for both cases by checked to see
1627 whether this is a defined type, referring to it if it is, and using
1629 if (TYPE_SYMTAB_ADDRESS (type
) != 0)
1630 dbxout_type_index (type
);
1632 dbxout_type_index (integer_type_node
);
1636 if (low
&& host_integerp (low
, 0))
1638 if (print_int_cst_bounds_in_octal_p (type
, low
, high
))
1641 stabstr_D (tree_low_cst (low
, 0));
1647 if (high
&& host_integerp (high
, 0))
1649 if (print_int_cst_bounds_in_octal_p (type
, low
, high
))
1652 stabstr_D (tree_low_cst (high
, 0));
1660 /* Output a reference to a type. If the type has not yet been
1661 described in the dbx output, output its definition now.
1662 For a type already defined, just refer to its definition
1663 using the type number.
1665 If FULL is nonzero, and the type has been described only with
1666 a forward-reference, output the definition now.
1667 If FULL is zero in this case, just refer to the forward-reference
1668 using the number previously allocated. */
1671 dbxout_type (tree type
, int full
)
1673 static int anonymous_type_number
= 0;
1674 tree tem
, main_variant
, low
, high
;
1676 if (TREE_CODE (type
) == INTEGER_TYPE
)
1678 if (TREE_TYPE (type
) == 0)
1680 low
= TYPE_MIN_VALUE (type
);
1681 high
= TYPE_MAX_VALUE (type
);
1684 else if (subrange_type_for_debug_p (type
, &low
, &high
))
1687 /* If this is a subtype that should not be emitted as a subrange type,
1688 use the base type. */
1691 type
= TREE_TYPE (type
);
1692 low
= TYPE_MIN_VALUE (type
);
1693 high
= TYPE_MAX_VALUE (type
);
1697 /* If there was an input error and we don't really have a type,
1698 avoid crashing and write something that is at least valid
1699 by assuming `int'. */
1700 if (type
== error_mark_node
)
1701 type
= integer_type_node
;
1704 if (TYPE_NAME (type
)
1705 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1706 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type
)))
1710 /* Try to find the "main variant" with the same name. */
1711 if (TYPE_NAME (type
) && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1712 && DECL_ORIGINAL_TYPE (TYPE_NAME (type
)))
1713 main_variant
= TREE_TYPE (TYPE_NAME (type
));
1715 main_variant
= TYPE_MAIN_VARIANT (type
);
1717 /* If we are not using extensions, stabs does not distinguish const and
1718 volatile, so there is no need to make them separate types. */
1719 if (!use_gnu_debug_info_extensions
)
1720 type
= main_variant
;
1722 if (TYPE_SYMTAB_ADDRESS (type
) == 0)
1724 /* Type has no dbx number assigned. Assign next available number. */
1725 TYPE_SYMTAB_ADDRESS (type
) = next_type_number
++;
1727 /* Make sure type vector is long enough to record about this type. */
1729 if (next_type_number
== typevec_len
)
1731 typevec
= GGC_RESIZEVEC (struct typeinfo
, typevec
, typevec_len
* 2);
1732 memset (typevec
+ typevec_len
, 0, typevec_len
* sizeof typevec
[0]);
1736 #ifdef DBX_USE_BINCL
1737 emit_pending_bincls_if_required ();
1738 typevec
[TYPE_SYMTAB_ADDRESS (type
)].file_number
1739 = current_file
->file_number
;
1740 typevec
[TYPE_SYMTAB_ADDRESS (type
)].type_number
1741 = current_file
->next_type_number
++;
1745 if (flag_debug_only_used_symbols
)
1747 if ((TREE_CODE (type
) == RECORD_TYPE
1748 || TREE_CODE (type
) == UNION_TYPE
1749 || TREE_CODE (type
) == QUAL_UNION_TYPE
1750 || TREE_CODE (type
) == ENUMERAL_TYPE
)
1751 && TYPE_STUB_DECL (type
)
1752 && DECL_P (TYPE_STUB_DECL (type
))
1753 && ! DECL_IGNORED_P (TYPE_STUB_DECL (type
)))
1754 debug_queue_symbol (TYPE_STUB_DECL (type
));
1755 else if (TYPE_NAME (type
)
1756 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
1757 debug_queue_symbol (TYPE_NAME (type
));
1760 /* Output the number of this type, to refer to it. */
1761 dbxout_type_index (type
);
1763 #ifdef DBX_TYPE_DEFINED
1764 if (DBX_TYPE_DEFINED (type
))
1768 /* If this type's definition has been output or is now being output,
1771 switch (typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
)
1776 /* If we have already had a cross reference,
1777 and either that's all we want or that's the best we could do,
1778 don't repeat the cross reference.
1779 Sun dbx crashes if we do. */
1780 if (! full
|| !COMPLETE_TYPE_P (type
)
1781 /* No way in DBX fmt to describe a variable size. */
1782 || ! host_integerp (TYPE_SIZE (type
), 1))
1790 /* For systems where dbx output does not allow the `=xsNAME:' syntax,
1791 leave the type-number completely undefined rather than output
1792 a cross-reference. If we have already used GNU debug info extensions,
1793 then it is OK to output a cross reference. This is necessary to get
1794 proper C++ debug output. */
1795 if ((TREE_CODE (type
) == RECORD_TYPE
|| TREE_CODE (type
) == UNION_TYPE
1796 || TREE_CODE (type
) == QUAL_UNION_TYPE
1797 || TREE_CODE (type
) == ENUMERAL_TYPE
)
1798 && ! use_gnu_debug_info_extensions
)
1799 /* We must use the same test here as we use twice below when deciding
1800 whether to emit a cross-reference. */
1801 if ((TYPE_NAME (type
) != 0
1802 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1803 && DECL_IGNORED_P (TYPE_NAME (type
)))
1805 || !COMPLETE_TYPE_P (type
)
1806 /* No way in DBX fmt to describe a variable size. */
1807 || ! host_integerp (TYPE_SIZE (type
), 1))
1809 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1814 /* Output a definition now. */
1817 /* Mark it as defined, so that if it is self-referent
1818 we will not get into an infinite recursion of definitions. */
1820 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_DEFINED
;
1822 /* If this type is a variant of some other, hand off. Types with
1823 different names are usefully distinguished. We only distinguish
1824 cv-qualified types if we're using extensions. */
1825 if (TYPE_READONLY (type
) > TYPE_READONLY (main_variant
))
1828 dbxout_type (build_type_variant (type
, 0, TYPE_VOLATILE (type
)), 0);
1831 else if (TYPE_VOLATILE (type
) > TYPE_VOLATILE (main_variant
))
1834 dbxout_type (build_type_variant (type
, TYPE_READONLY (type
), 0), 0);
1837 else if (main_variant
!= TYPE_MAIN_VARIANT (type
))
1839 if (flag_debug_only_used_symbols
)
1841 tree orig_type
= DECL_ORIGINAL_TYPE (TYPE_NAME (type
));
1843 if ((TREE_CODE (orig_type
) == RECORD_TYPE
1844 || TREE_CODE (orig_type
) == UNION_TYPE
1845 || TREE_CODE (orig_type
) == QUAL_UNION_TYPE
1846 || TREE_CODE (orig_type
) == ENUMERAL_TYPE
)
1847 && TYPE_STUB_DECL (orig_type
)
1848 && ! DECL_IGNORED_P (TYPE_STUB_DECL (orig_type
)))
1849 debug_queue_symbol (TYPE_STUB_DECL (orig_type
));
1851 /* 'type' is a typedef; output the type it refers to. */
1852 dbxout_type (DECL_ORIGINAL_TYPE (TYPE_NAME (type
)), 0);
1855 /* else continue. */
1857 switch (TREE_CODE (type
))
1862 /* For a void type, just define it as itself; i.e., "5=5".
1863 This makes us consider it defined
1864 without saying what it is. The debugger will make it
1865 a void type when the reference is seen, and nothing will
1866 ever override that default. */
1867 dbxout_type_index (type
);
1871 if (type
== char_type_node
&& ! TYPE_UNSIGNED (type
))
1873 /* Output the type `char' as a subrange of itself!
1874 I don't understand this definition, just copied it
1875 from the output of pcc.
1876 This used to use `r2' explicitly and we used to
1877 take care to make sure that `char' was type number 2. */
1879 dbxout_type_index (type
);
1880 stabstr_S (";0;127;");
1883 /* If this is a subtype of another integer type, always prefer to
1884 write it as a subtype. */
1885 else if (TREE_TYPE (type
) != 0
1886 && TREE_CODE (TREE_TYPE (type
)) == INTEGER_TYPE
)
1888 /* If the size is non-standard, say what it is if we can use
1891 if (use_gnu_debug_info_extensions
1892 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
1895 stabstr_D (TYPE_PRECISION (type
));
1899 dbxout_range_type (type
, low
, high
);
1904 /* If the size is non-standard, say what it is if we can use
1907 if (use_gnu_debug_info_extensions
1908 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
1911 stabstr_D (TYPE_PRECISION (type
));
1915 if (print_int_cst_bounds_in_octal_p (type
, low
, high
))
1919 /* If this type derives from another type, output type index of
1920 parent type. This is particularly important when parent type
1921 is an enumerated type, because not generating the parent type
1922 index would transform the definition of this enumerated type
1923 into a plain unsigned type. */
1924 if (TREE_TYPE (type
) != 0)
1925 dbxout_type_index (TREE_TYPE (type
));
1927 dbxout_type_index (type
);
1937 /* Output other integer types as subranges of `int'. */
1938 dbxout_range_type (type
, low
, high
);
1944 case FIXED_POINT_TYPE
:
1945 /* This used to say `r1' and we used to take care
1946 to make sure that `int' was type number 1. */
1948 dbxout_type_index (integer_type_node
);
1950 stabstr_D (int_size_in_bytes (type
));
1955 if (use_gnu_debug_info_extensions
)
1958 stabstr_D (BITS_PER_UNIT
* int_size_in_bytes (type
));
1959 stabstr_S (";-16;");
1961 else /* Define as enumeral type (False, True) */
1962 stabstr_S ("eFalse:0,True:1,;");
1966 /* Differs from the REAL_TYPE by its new data type number.
1967 R3 is NF_COMPLEX. We don't try to use any of the other NF_*
1968 codes since gdb doesn't care anyway. */
1970 if (TREE_CODE (TREE_TYPE (type
)) == REAL_TYPE
)
1973 stabstr_D (2 * int_size_in_bytes (TREE_TYPE (type
)));
1978 /* Output a complex integer type as a structure,
1979 pending some other way to do it. */
1981 stabstr_D (int_size_in_bytes (type
));
1983 stabstr_S ("real:");
1984 dbxout_type (TREE_TYPE (type
), 0);
1986 stabstr_D (TYPE_PRECISION (TREE_TYPE (type
)));
1988 stabstr_S (";imag:");
1989 dbxout_type (TREE_TYPE (type
), 0);
1991 stabstr_D (TYPE_PRECISION (TREE_TYPE (type
)));
1993 stabstr_D (TYPE_PRECISION (TREE_TYPE (type
)));
1999 /* Make arrays of packed bits look like bitstrings for chill. */
2000 if (TYPE_PACKED (type
) && use_gnu_debug_info_extensions
)
2003 stabstr_D (BITS_PER_UNIT
* int_size_in_bytes (type
));
2004 stabstr_S (";@S;S");
2005 dbxout_type (TYPE_DOMAIN (type
), 0);
2009 /* Output "a" followed by a range type definition
2010 for the index type of the array
2011 followed by a reference to the target-type.
2012 ar1;0;N;M for a C array of type M and size N+1. */
2013 /* Check if a character string type, which in Chill is
2014 different from an array of characters. */
2015 if (TYPE_STRING_FLAG (type
) && use_gnu_debug_info_extensions
)
2019 tem
= TYPE_DOMAIN (type
);
2023 dbxout_type_index (integer_type_node
);
2024 stabstr_S (";0;-1;");
2029 dbxout_range_type (tem
, TYPE_MIN_VALUE (tem
), TYPE_MAX_VALUE (tem
));
2032 dbxout_type (TREE_TYPE (type
), 0);
2036 /* Make vectors look like an array. */
2037 if (use_gnu_debug_info_extensions
)
2040 /* Output "a" followed by a range type definition
2041 for the index type of the array
2042 followed by a reference to the target-type.
2043 ar1;0;N;M for a C array of type M and size N+1. */
2045 dbxout_range_type (integer_type_node
, size_zero_node
,
2046 size_int (TYPE_VECTOR_SUBPARTS (type
) - 1));
2048 dbxout_type (TREE_TYPE (type
), 0);
2053 case QUAL_UNION_TYPE
:
2055 tree binfo
= TYPE_BINFO (type
);
2057 /* Output a structure type. We must use the same test here as we
2058 use in the DBX_NO_XREFS case above. */
2059 if ((TYPE_NAME (type
) != 0
2060 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
2061 && DECL_IGNORED_P (TYPE_NAME (type
)))
2063 || !COMPLETE_TYPE_P (type
)
2064 /* No way in DBX fmt to describe a variable size. */
2065 || ! host_integerp (TYPE_SIZE (type
), 1))
2067 /* If the type is just a cross reference, output one
2068 and mark the type as partially described.
2069 If it later becomes defined, we will output
2070 its real definition.
2071 If the type has a name, don't nest its definition within
2072 another type's definition; instead, output an xref
2073 and let the definition come when the name is defined. */
2074 stabstr_S ((TREE_CODE (type
) == RECORD_TYPE
) ? "xs" : "xu");
2075 if (TYPE_NAME (type
) != 0
2076 /* The C frontend creates for anonymous variable length
2077 records/unions TYPE_NAME with DECL_NAME NULL. */
2078 && (TREE_CODE (TYPE_NAME (type
)) != TYPE_DECL
2079 || DECL_NAME (TYPE_NAME (type
))))
2080 dbxout_type_name (type
);
2084 stabstr_D (anonymous_type_number
++);
2088 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
2092 /* Identify record or union, and print its size. */
2093 stabstr_C ((TREE_CODE (type
) == RECORD_TYPE
) ? 's' : 'u');
2094 stabstr_D (int_size_in_bytes (type
));
2100 VEC(tree
,gc
) *accesses
= BINFO_BASE_ACCESSES (binfo
);
2102 if (use_gnu_debug_info_extensions
)
2104 if (BINFO_N_BASE_BINFOS (binfo
))
2107 stabstr_U (BINFO_N_BASE_BINFOS (binfo
));
2111 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, child
); i
++)
2113 tree access
= (accesses
? VEC_index (tree
, accesses
, i
)
2114 : access_public_node
);
2116 if (use_gnu_debug_info_extensions
)
2118 stabstr_C (BINFO_VIRTUAL_P (child
) ? '1' : '0');
2119 stabstr_C (access
== access_public_node
? '2' :
2120 access
== access_protected_node
2122 if (BINFO_VIRTUAL_P (child
)
2123 && (strcmp (lang_hooks
.name
, "GNU C++") == 0
2124 || strcmp (lang_hooks
.name
, "GNU Objective-C++") == 0))
2125 /* For a virtual base, print the (negative)
2126 offset within the vtable where we must look
2127 to find the necessary adjustment. */
2129 (tree_low_cst (BINFO_VPTR_FIELD (child
), 0)
2132 stabstr_D (tree_low_cst (BINFO_OFFSET (child
), 0)
2135 dbxout_type (BINFO_TYPE (child
), 0);
2140 /* Print out the base class information with
2141 fields which have the same names at the types
2143 dbxout_type_name (BINFO_TYPE (child
));
2145 dbxout_type (BINFO_TYPE (child
), full
);
2147 stabstr_D (tree_low_cst (BINFO_OFFSET (child
), 0)
2151 (tree_low_cst (TYPE_SIZE (BINFO_TYPE (child
)), 0)
2159 /* Write out the field declarations. */
2160 dbxout_type_fields (type
);
2161 if (use_gnu_debug_info_extensions
&& TYPE_METHODS (type
) != NULL_TREE
)
2163 dbxout_type_methods (type
);
2168 if (use_gnu_debug_info_extensions
&& TREE_CODE (type
) == RECORD_TYPE
2169 /* Avoid the ~ if we don't really need it--it confuses dbx. */
2170 && TYPE_VFIELD (type
))
2173 /* We need to write out info about what field this class
2174 uses as its "main" vtable pointer field, because if this
2175 field is inherited from a base class, GDB cannot necessarily
2176 figure out which field it's using in time. */
2178 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type
)), 0);
2184 /* We must use the same test here as we use in the DBX_NO_XREFS case
2185 above. We simplify it a bit since an enum will never have a variable
2187 if ((TYPE_NAME (type
) != 0
2188 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
2189 && DECL_IGNORED_P (TYPE_NAME (type
)))
2191 || !COMPLETE_TYPE_P (type
))
2194 dbxout_type_name (type
);
2195 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
2199 if (use_gnu_debug_info_extensions
2200 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
2203 stabstr_D (TYPE_PRECISION (type
));
2208 for (tem
= TYPE_VALUES (type
); tem
; tem
= TREE_CHAIN (tem
))
2210 tree value
= TREE_VALUE (tem
);
2212 stabstr_I (TREE_PURPOSE (tem
));
2215 if (TREE_CODE (value
) == CONST_DECL
)
2216 value
= DECL_INITIAL (value
);
2218 if (TREE_INT_CST_HIGH (value
) == 0)
2219 stabstr_D (TREE_INT_CST_LOW (value
));
2220 else if (TREE_INT_CST_HIGH (value
) == -1
2221 && (HOST_WIDE_INT
) TREE_INT_CST_LOW (value
) < 0)
2222 stabstr_D (TREE_INT_CST_LOW (value
));
2227 if (TREE_CHAIN (tem
) != 0)
2236 dbxout_type (TREE_TYPE (type
), 0);
2240 if (use_gnu_debug_info_extensions
)
2244 /* Write the argument types out longhand. */
2245 dbxout_type (TYPE_METHOD_BASETYPE (type
), 0);
2247 dbxout_type (TREE_TYPE (type
), 0);
2248 dbxout_args (TYPE_ARG_TYPES (type
));
2252 /* Treat it as a function type. */
2253 dbxout_type (TREE_TYPE (type
), 0);
2257 if (use_gnu_debug_info_extensions
)
2260 dbxout_type (TYPE_OFFSET_BASETYPE (type
), 0);
2262 dbxout_type (TREE_TYPE (type
), 0);
2265 /* Should print as an int, because it is really just an offset. */
2266 dbxout_type (integer_type_node
, 0);
2269 case REFERENCE_TYPE
:
2270 if (use_gnu_debug_info_extensions
)
2276 dbxout_type (TREE_TYPE (type
), 0);
2281 dbxout_type (TREE_TYPE (type
), 0);
2289 /* Return nonzero if the given type represents an integer whose bounds
2290 should be printed in octal format. */
2293 print_int_cst_bounds_in_octal_p (tree type
, tree low
, tree high
)
2295 /* If we can use GDB extensions and the size is wider than a long
2296 (the size used by GDB to read them) or we may have trouble writing
2297 the bounds the usual way, write them in octal. Note the test is for
2298 the *target's* size of "long", not that of the host. The host test
2299 is just to make sure we can write it out in case the host wide int
2300 is narrower than the target "long".
2302 For unsigned types, we use octal if they are the same size or larger.
2303 This is because we print the bounds as signed decimal, and hence they
2304 can't span same size unsigned types. */
2306 if (use_gnu_debug_info_extensions
2307 && low
&& TREE_CODE (low
) == INTEGER_CST
2308 && high
&& TREE_CODE (high
) == INTEGER_CST
2309 && (TYPE_PRECISION (type
) > TYPE_PRECISION (integer_type_node
)
2310 || ((TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
))
2311 && TYPE_UNSIGNED (type
))
2312 || TYPE_PRECISION (type
) > HOST_BITS_PER_WIDE_INT
2313 || (TYPE_PRECISION (type
) == HOST_BITS_PER_WIDE_INT
2314 && TYPE_UNSIGNED (type
))))
2320 /* Output the name of type TYPE, with no punctuation.
2321 Such names can be set up either by typedef declarations
2322 or by struct, enum and union tags. */
2325 dbxout_type_name (tree type
)
2327 tree t
= TYPE_NAME (type
);
2330 switch (TREE_CODE (t
))
2332 case IDENTIFIER_NODE
:
2344 /* Output leading leading struct or class names needed for qualifying
2345 type whose scope is limited to a struct or class. */
2348 dbxout_class_name_qualifiers (tree decl
)
2350 tree context
= decl_type_context (decl
);
2352 if (context
!= NULL_TREE
2353 && TREE_CODE(context
) == RECORD_TYPE
2354 && TYPE_NAME (context
) != 0
2355 && (TREE_CODE (TYPE_NAME (context
)) == IDENTIFIER_NODE
2356 || (DECL_NAME (TYPE_NAME (context
)) != 0)))
2358 tree name
= TYPE_NAME (context
);
2360 if (TREE_CODE (name
) == TYPE_DECL
)
2362 dbxout_class_name_qualifiers (name
);
2363 name
= DECL_NAME (name
);
2370 /* This is a specialized subset of expand_expr for use by dbxout_symbol in
2371 evaluating DECL_VALUE_EXPR. In particular, we stop if we find decls that
2372 haven't been expanded, or if the expression is getting so complex we won't
2373 be able to represent it in stabs anyway. Returns NULL on failure. */
2376 dbxout_expand_expr (tree expr
)
2378 switch (TREE_CODE (expr
))
2381 /* We can't handle emulated tls variables, because the address is an
2382 offset to the return value of __emutls_get_address, and there is no
2383 way to express that in stabs. Also, there are name mangling issues
2384 here. We end up with references to undefined symbols if we don't
2385 disable debug info for these variables. */
2386 if (!targetm
.have_tls
&& DECL_THREAD_LOCAL_P (expr
))
2392 if (DECL_HAS_VALUE_EXPR_P (expr
))
2393 return dbxout_expand_expr (DECL_VALUE_EXPR (expr
));
2397 return DECL_RTL_IF_SET (expr
);
2400 return expand_expr (expr
, NULL_RTX
, VOIDmode
, EXPAND_INITIALIZER
);
2404 case ARRAY_RANGE_REF
:
2407 enum machine_mode mode
;
2408 HOST_WIDE_INT bitsize
, bitpos
;
2410 int volatilep
= 0, unsignedp
= 0;
2413 tem
= get_inner_reference (expr
, &bitsize
, &bitpos
, &offset
,
2414 &mode
, &unsignedp
, &volatilep
, true);
2416 x
= dbxout_expand_expr (tem
);
2417 if (x
== NULL
|| !MEM_P (x
))
2421 if (!host_integerp (offset
, 0))
2423 x
= adjust_address_nv (x
, mode
, tree_low_cst (offset
, 0));
2426 x
= adjust_address_nv (x
, mode
, bitpos
/ BITS_PER_UNIT
);
2436 /* Helper function for output_used_types. Queue one entry from the
2437 used types hash to be output. */
2440 output_used_types_helper (void **slot
, void *data
)
2442 tree type
= (tree
) *slot
;
2443 VEC(tree
, heap
) **types_p
= (VEC(tree
, heap
) **) data
;
2445 if ((TREE_CODE (type
) == RECORD_TYPE
2446 || TREE_CODE (type
) == UNION_TYPE
2447 || TREE_CODE (type
) == QUAL_UNION_TYPE
2448 || TREE_CODE (type
) == ENUMERAL_TYPE
)
2449 && TYPE_STUB_DECL (type
)
2450 && DECL_P (TYPE_STUB_DECL (type
))
2451 && ! DECL_IGNORED_P (TYPE_STUB_DECL (type
)))
2452 VEC_quick_push (tree
, *types_p
, TYPE_STUB_DECL (type
));
2453 else if (TYPE_NAME (type
)
2454 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
2455 VEC_quick_push (tree
, *types_p
, TYPE_NAME (type
));
2460 /* This is a qsort callback which sorts types and declarations into a
2461 predictable order (types, then declarations, sorted by UID
2465 output_types_sort (const void *pa
, const void *pb
)
2467 const tree lhs
= *((const tree
*)pa
);
2468 const tree rhs
= *((const tree
*)pb
);
2473 return TYPE_UID (lhs
) - TYPE_UID (rhs
);
2482 return DECL_UID (lhs
) - DECL_UID (rhs
);
2487 /* Force all types used by this function to be output in debug
2491 output_used_types (void)
2493 if (cfun
&& cfun
->used_types_hash
)
2495 VEC(tree
, heap
) *types
;
2499 types
= VEC_alloc (tree
, heap
, htab_elements (cfun
->used_types_hash
));
2500 htab_traverse (cfun
->used_types_hash
, output_used_types_helper
, &types
);
2502 /* Sort by UID to prevent dependence on hash table ordering. */
2503 VEC_qsort (tree
, types
, output_types_sort
);
2505 FOR_EACH_VEC_ELT (tree
, types
, i
, type
)
2506 debug_queue_symbol (type
);
2508 VEC_free (tree
, heap
, types
);
2512 /* Output a .stabs for the symbol defined by DECL,
2513 which must be a ..._DECL node in the normal namespace.
2514 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
2515 LOCAL is nonzero if the scope is less than the entire file.
2516 Return 1 if a stabs might have been emitted. */
2519 dbxout_symbol (tree decl
, int local ATTRIBUTE_UNUSED
)
2521 tree type
= TREE_TYPE (decl
);
2522 tree context
= NULL_TREE
;
2526 /* "Intercept" dbxout_symbol() calls like we do all debug_hooks. */
2529 /* Ignore nameless syms, but don't ignore type tags. */
2531 if ((DECL_NAME (decl
) == 0 && TREE_CODE (decl
) != TYPE_DECL
)
2532 || DECL_IGNORED_P (decl
))
2533 DBXOUT_DECR_NESTING_AND_RETURN (0);
2535 /* If we are to generate only the symbols actually used then such
2536 symbol nodes are flagged with TREE_USED. Ignore any that
2537 aren't flagged as TREE_USED. */
2539 if (flag_debug_only_used_symbols
2540 && (!TREE_USED (decl
)
2541 && (TREE_CODE (decl
) != VAR_DECL
|| !DECL_INITIAL (decl
))))
2542 DBXOUT_DECR_NESTING_AND_RETURN (0);
2544 /* If dbxout_init has not yet run, queue this symbol for later. */
2547 preinit_symbols
= tree_cons (0, decl
, preinit_symbols
);
2548 DBXOUT_DECR_NESTING_AND_RETURN (0);
2551 if (flag_debug_only_used_symbols
)
2555 /* We now have a used symbol. We need to generate the info for
2556 the symbol's type in addition to the symbol itself. These
2557 type symbols are queued to be generated after were done with
2558 the symbol itself (otherwise they would fight over the
2561 Note, because the TREE_TYPE(type) might be something like a
2562 pointer to a named type we need to look for the first name
2563 we see following the TREE_TYPE chain. */
2566 while (POINTER_TYPE_P (t
))
2569 /* RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, and ENUMERAL_TYPE
2570 need special treatment. The TYPE_STUB_DECL field in these
2571 types generally represents the tag name type we want to
2572 output. In addition there could be a typedef type with
2573 a different name. In that case we also want to output
2576 if (TREE_CODE (t
) == RECORD_TYPE
2577 || TREE_CODE (t
) == UNION_TYPE
2578 || TREE_CODE (t
) == QUAL_UNION_TYPE
2579 || TREE_CODE (t
) == ENUMERAL_TYPE
)
2581 if (TYPE_STUB_DECL (t
)
2582 && TYPE_STUB_DECL (t
) != decl
2583 && DECL_P (TYPE_STUB_DECL (t
))
2584 && ! DECL_IGNORED_P (TYPE_STUB_DECL (t
)))
2586 debug_queue_symbol (TYPE_STUB_DECL (t
));
2588 && TYPE_NAME (t
) != TYPE_STUB_DECL (t
)
2589 && TYPE_NAME (t
) != decl
2590 && DECL_P (TYPE_NAME (t
)))
2591 debug_queue_symbol (TYPE_NAME (t
));
2594 else if (TYPE_NAME (t
)
2595 && TYPE_NAME (t
) != decl
2596 && DECL_P (TYPE_NAME (t
)))
2597 debug_queue_symbol (TYPE_NAME (t
));
2600 emit_pending_bincls_if_required ();
2602 switch (TREE_CODE (decl
))
2605 /* Enum values are defined by defining the enum type. */
2609 decl_rtl
= DECL_RTL_IF_SET (decl
);
2611 DBXOUT_DECR_NESTING_AND_RETURN (0);
2612 if (DECL_EXTERNAL (decl
))
2614 /* Don't mention a nested function under its parent. */
2615 context
= decl_function_context (decl
);
2616 if (context
== current_function_decl
)
2618 /* Don't mention an inline instance of a nested function. */
2619 if (context
&& DECL_FROM_INLINE (decl
))
2621 if (!MEM_P (decl_rtl
)
2622 || GET_CODE (XEXP (decl_rtl
, 0)) != SYMBOL_REF
)
2625 if (flag_debug_only_used_symbols
)
2626 output_used_types ();
2628 dbxout_begin_complex_stabs ();
2629 stabstr_I (DECL_ASSEMBLER_NAME (decl
));
2630 stabstr_S (TREE_PUBLIC (decl
) ? ":F" : ":f");
2633 if (TREE_TYPE (type
))
2634 dbxout_type (TREE_TYPE (type
), 0);
2636 dbxout_type (void_type_node
, 0);
2638 /* For a nested function, when that function is compiled,
2639 mention the containing function name
2640 as well as (since dbx wants it) our own assembler-name. */
2644 stabstr_I (DECL_ASSEMBLER_NAME (decl
));
2646 stabstr_I (DECL_NAME (context
));
2649 dbxout_finish_complex_stabs (decl
, N_FUN
, XEXP (decl_rtl
, 0), 0, 0);
2653 /* Don't output the same typedef twice.
2654 And don't output what language-specific stuff doesn't want output. */
2655 if (TREE_ASM_WRITTEN (decl
) || TYPE_DECL_SUPPRESS_DEBUG (decl
))
2656 DBXOUT_DECR_NESTING_AND_RETURN (0);
2658 /* Don't output typedefs for types with magic type numbers (XCOFF). */
2659 #ifdef DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER
2661 int fundamental_type_number
=
2662 DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER (decl
);
2664 if (fundamental_type_number
!= 0)
2666 TREE_ASM_WRITTEN (decl
) = 1;
2667 TYPE_SYMTAB_ADDRESS (TREE_TYPE (decl
)) = fundamental_type_number
;
2668 DBXOUT_DECR_NESTING_AND_RETURN (0);
2678 if (DECL_NAME (decl
))
2680 /* Nonzero means we must output a tag as well as a typedef. */
2683 /* Handle the case of a C++ structure or union
2684 where the TYPE_NAME is a TYPE_DECL
2685 which gives both a typedef name and a tag. */
2686 /* dbx requires the tag first and the typedef second. */
2687 if ((TREE_CODE (type
) == RECORD_TYPE
2688 || TREE_CODE (type
) == UNION_TYPE
2689 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
2690 && TYPE_NAME (type
) == decl
2691 && !use_gnu_debug_info_extensions
2692 && !TREE_ASM_WRITTEN (TYPE_NAME (type
))
2693 /* Distinguish the implicit typedefs of C++
2694 from explicit ones that might be found in C. */
2695 && DECL_ARTIFICIAL (decl
)
2696 /* Do not generate a tag for incomplete records. */
2697 && COMPLETE_TYPE_P (type
)
2698 /* Do not generate a tag for records of variable size,
2699 since this type can not be properly described in the
2700 DBX format, and it confuses some tools such as objdump. */
2701 && host_integerp (TYPE_SIZE (type
), 1))
2703 tree name
= TYPE_NAME (type
);
2704 if (TREE_CODE (name
) == TYPE_DECL
)
2705 name
= DECL_NAME (name
);
2707 dbxout_begin_complex_stabs ();
2710 dbxout_type (type
, 1);
2711 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE
,
2715 dbxout_begin_complex_stabs ();
2717 /* Output leading class/struct qualifiers. */
2718 if (use_gnu_debug_info_extensions
)
2719 dbxout_class_name_qualifiers (decl
);
2721 /* Output typedef name. */
2722 stabstr_I (DECL_NAME (decl
));
2725 /* Short cut way to output a tag also. */
2726 if ((TREE_CODE (type
) == RECORD_TYPE
2727 || TREE_CODE (type
) == UNION_TYPE
2728 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
2729 && TYPE_NAME (type
) == decl
2730 /* Distinguish the implicit typedefs of C++
2731 from explicit ones that might be found in C. */
2732 && DECL_ARTIFICIAL (decl
))
2734 if (use_gnu_debug_info_extensions
)
2737 TREE_ASM_WRITTEN (TYPE_NAME (type
)) = 1;
2742 dbxout_type (type
, 1);
2743 dbxout_finish_complex_stabs (decl
, DBX_TYPE_DECL_STABS_CODE
,
2748 /* Don't output a tag if this is an incomplete type. This prevents
2749 the sun4 Sun OS 4.x dbx from crashing. */
2751 if (tag_needed
&& TYPE_NAME (type
) != 0
2752 && (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
2753 || (DECL_NAME (TYPE_NAME (type
)) != 0))
2754 && COMPLETE_TYPE_P (type
)
2755 && !TREE_ASM_WRITTEN (TYPE_NAME (type
)))
2757 /* For a TYPE_DECL with no name, but the type has a name,
2759 This is what represents `struct foo' with no typedef. */
2760 /* In C++, the name of a type is the corresponding typedef.
2761 In C, it is an IDENTIFIER_NODE. */
2762 tree name
= TYPE_NAME (type
);
2763 if (TREE_CODE (name
) == TYPE_DECL
)
2764 name
= DECL_NAME (name
);
2766 dbxout_begin_complex_stabs ();
2769 dbxout_type (type
, 1);
2770 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE
, 0, 0, 0);
2774 /* If an enum type has no name, it cannot be referred to, but
2775 we must output it anyway, to record the enumeration
2778 if (!did_output
&& TREE_CODE (type
) == ENUMERAL_TYPE
)
2780 dbxout_begin_complex_stabs ();
2781 /* Some debuggers fail when given NULL names, so give this a
2782 harmless name of " " (Why not "(anon)"?). */
2784 dbxout_type (type
, 1);
2785 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE
, 0, 0, 0);
2788 /* Prevent duplicate output of a typedef. */
2789 TREE_ASM_WRITTEN (decl
) = 1;
2794 if (DECL_HAS_VALUE_EXPR_P (decl
))
2795 decl
= DECL_VALUE_EXPR (decl
);
2797 /* PARM_DECLs go in their own separate chain and are output by
2798 dbxout_reg_parms and dbxout_parms, except for those that are
2799 disguised VAR_DECLs like Out parameters in Ada. */
2800 gcc_assert (TREE_CODE (decl
) == VAR_DECL
);
2802 /* ... fall through ... */
2806 /* Don't mention a variable that is external.
2807 Let the file that defines it describe it. */
2808 if (DECL_EXTERNAL (decl
))
2811 /* If the variable is really a constant
2812 and not written in memory, inform the debugger.
2814 ??? Why do we skip emitting the type and location in this case? */
2815 if (TREE_STATIC (decl
) && TREE_READONLY (decl
)
2816 && DECL_INITIAL (decl
) != 0
2817 && host_integerp (DECL_INITIAL (decl
), 0)
2818 && ! TREE_ASM_WRITTEN (decl
)
2819 && (DECL_FILE_SCOPE_P (decl
)
2820 || TREE_CODE (DECL_CONTEXT (decl
)) == BLOCK
2821 || TREE_CODE (DECL_CONTEXT (decl
)) == NAMESPACE_DECL
)
2822 && TREE_PUBLIC (decl
) == 0)
2824 /* The sun4 assembler does not grok this. */
2826 if (TREE_CODE (TREE_TYPE (decl
)) == INTEGER_TYPE
2827 || TREE_CODE (TREE_TYPE (decl
)) == ENUMERAL_TYPE
)
2829 HOST_WIDE_INT ival
= TREE_INT_CST_LOW (DECL_INITIAL (decl
));
2831 dbxout_begin_complex_stabs ();
2832 dbxout_symbol_name (decl
, NULL
, 'c');
2835 dbxout_finish_complex_stabs (0, N_LSYM
, 0, 0, 0);
2836 DBXOUT_DECR_NESTING
;
2842 /* else it is something we handle like a normal variable. */
2844 decl_rtl
= dbxout_expand_expr (decl
);
2846 DBXOUT_DECR_NESTING_AND_RETURN (0);
2848 decl_rtl
= eliminate_regs (decl_rtl
, VOIDmode
, NULL_RTX
);
2849 #ifdef LEAF_REG_REMAP
2850 if (current_function_uses_only_leaf_regs
)
2851 leaf_renumber_regs_insn (decl_rtl
);
2854 result
= dbxout_symbol_location (decl
, type
, 0, decl_rtl
);
2860 DBXOUT_DECR_NESTING
;
2864 /* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL.
2865 Add SUFFIX to its name, if SUFFIX is not 0.
2866 Describe the variable as residing in HOME
2867 (usually HOME is DECL_RTL (DECL), but not always).
2868 Returns 1 if the stab was really emitted. */
2871 dbxout_symbol_location (tree decl
, tree type
, const char *suffix
, rtx home
)
2874 stab_code_type code
;
2879 /* Don't mention a variable at all
2880 if it was completely optimized into nothingness.
2882 If the decl was from an inline function, then its rtl
2883 is not identically the rtl that was used in this
2884 particular compilation. */
2885 if (GET_CODE (home
) == SUBREG
)
2889 while (GET_CODE (value
) == SUBREG
)
2890 value
= SUBREG_REG (value
);
2893 if (REGNO (value
) >= FIRST_PSEUDO_REGISTER
)
2896 home
= alter_subreg (&home
);
2900 regno
= REGNO (home
);
2901 if (regno
>= FIRST_PSEUDO_REGISTER
)
2905 /* The kind-of-variable letter depends on where
2906 the variable is and on the scope of its name:
2907 G and N_GSYM for static storage and global scope,
2908 S for static storage and file scope,
2909 V for static storage and local scope,
2910 for those two, use N_LCSYM if data is in bss segment,
2911 N_STSYM if in data segment, N_FUN otherwise.
2912 (We used N_FUN originally, then changed to N_STSYM
2913 to please GDB. However, it seems that confused ld.
2914 Now GDB has been fixed to like N_FUN, says Kingdon.)
2915 no letter at all, and N_LSYM, for auto variable,
2916 r and N_RSYM for register variable. */
2918 if (MEM_P (home
) && GET_CODE (XEXP (home
, 0)) == SYMBOL_REF
)
2920 if (TREE_PUBLIC (decl
))
2925 if (NULL
!= dbxout_common_check (decl
, &offs
))
2934 addr
= XEXP (home
, 0);
2936 letter
= decl_function_context (decl
) ? 'V' : 'S';
2938 /* Some ports can transform a symbol ref into a label ref,
2939 because the symbol ref is too far away and has to be
2940 dumped into a constant pool. Alternatively, the symbol
2941 in the constant pool might be referenced by a different
2943 if (GET_CODE (addr
) == SYMBOL_REF
2944 && CONSTANT_POOL_ADDRESS_P (addr
))
2947 rtx tmp
= get_pool_constant_mark (addr
, &marked
);
2949 if (GET_CODE (tmp
) == SYMBOL_REF
)
2952 if (CONSTANT_POOL_ADDRESS_P (addr
))
2953 get_pool_constant_mark (addr
, &marked
);
2957 else if (GET_CODE (tmp
) == LABEL_REF
)
2963 /* If all references to the constant pool were optimized
2964 out, we just ignore the symbol. */
2969 /* This should be the same condition as in assemble_variable, but
2970 we don't have access to dont_output_data here. So, instead,
2971 we rely on the fact that error_mark_node initializers always
2972 end up in bss for C++ and never end up in bss for C. */
2973 if (DECL_INITIAL (decl
) == 0
2974 || (!strcmp (lang_hooks
.name
, "GNU C++")
2975 && DECL_INITIAL (decl
) == error_mark_node
))
2979 if (NULL
!= dbxout_common_check (decl
, &offs
))
2987 else if (DECL_IN_TEXT_SECTION (decl
))
2988 /* This is not quite right, but it's the closest
2989 of all the codes that Unix defines. */
2990 code
= DBX_STATIC_CONST_VAR_CODE
;
2993 /* Ultrix `as' seems to need this. */
2994 #ifdef DBX_STATIC_STAB_DATA_SECTION
2995 switch_to_section (data_section
);
3001 else if (regno
>= 0)
3005 number
= DBX_REGISTER_NUMBER (regno
);
3007 else if (MEM_P (home
)
3008 && (MEM_P (XEXP (home
, 0))
3009 || (REG_P (XEXP (home
, 0))
3010 && REGNO (XEXP (home
, 0)) != HARD_FRAME_POINTER_REGNUM
3011 && REGNO (XEXP (home
, 0)) != STACK_POINTER_REGNUM
3012 #if !HARD_FRAME_POINTER_IS_ARG_POINTER
3013 && REGNO (XEXP (home
, 0)) != ARG_POINTER_REGNUM
3016 /* If the value is indirect by memory or by a register
3017 that isn't the frame pointer
3018 then it means the object is variable-sized and address through
3019 that register or stack slot. DBX has no way to represent this
3020 so all we can do is output the variable as a pointer.
3021 If it's not a parameter, ignore it. */
3023 if (REG_P (XEXP (home
, 0)))
3027 if (REGNO (XEXP (home
, 0)) >= FIRST_PSEUDO_REGISTER
)
3029 number
= DBX_REGISTER_NUMBER (REGNO (XEXP (home
, 0)));
3034 /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
3035 We want the value of that CONST_INT. */
3036 number
= DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home
, 0), 0));
3039 /* Effectively do build_pointer_type, but don't cache this type,
3040 since it might be temporary whereas the type it points to
3041 might have been saved for inlining. */
3042 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
3043 type
= make_node (POINTER_TYPE
);
3044 TREE_TYPE (type
) = TREE_TYPE (decl
);
3046 else if (MEM_P (home
)
3047 && REG_P (XEXP (home
, 0)))
3050 number
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
3052 else if (MEM_P (home
)
3053 && GET_CODE (XEXP (home
, 0)) == PLUS
3054 && CONST_INT_P (XEXP (XEXP (home
, 0), 1)))
3057 /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
3058 We want the value of that CONST_INT. */
3059 number
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
3061 else if (MEM_P (home
)
3062 && GET_CODE (XEXP (home
, 0)) == CONST
)
3064 /* Handle an obscure case which can arise when optimizing and
3065 when there are few available registers. (This is *always*
3066 the case for i386/i486 targets). The RTL looks like
3067 (MEM (CONST ...)) even though this variable is a local `auto'
3068 or a local `register' variable. In effect, what has happened
3069 is that the reload pass has seen that all assignments and
3070 references for one such a local variable can be replaced by
3071 equivalent assignments and references to some static storage
3072 variable, thereby avoiding the need for a register. In such
3073 cases we're forced to lie to debuggers and tell them that
3074 this variable was itself `static'. */
3078 if (NULL
== dbxout_common_check (decl
, &offs
))
3079 addr
= XEXP (XEXP (home
, 0), 0);
3087 else if (GET_CODE (home
) == CONCAT
)
3091 /* If TYPE is not a COMPLEX_TYPE (it might be a RECORD_TYPE,
3092 for example), then there is no easy way to figure out
3093 what SUBTYPE should be. So, we give up. */
3094 if (TREE_CODE (type
) != COMPLEX_TYPE
)
3097 subtype
= TREE_TYPE (type
);
3099 /* If the variable's storage is in two parts,
3100 output each as a separate stab with a modified name. */
3101 if (WORDS_BIG_ENDIAN
)
3102 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 0));
3104 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 0));
3106 if (WORDS_BIG_ENDIAN
)
3107 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 1));
3109 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 1));
3113 /* Address might be a MEM, when DECL is a variable-sized object.
3114 Or it might be const0_rtx, meaning previous passes
3115 want us to ignore this variable. */
3118 /* Ok, start a symtab entry and output the variable name. */
3119 emit_pending_bincls_if_required ();
3122 #ifdef DBX_STATIC_BLOCK_START
3123 DBX_STATIC_BLOCK_START (asm_out_file
, code
);
3126 dbxout_begin_complex_stabs_noforcetext ();
3127 dbxout_symbol_name (decl
, suffix
, letter
);
3128 dbxout_type (type
, 0);
3129 dbxout_finish_complex_stabs (decl
, code
, addr
, 0, number
);
3131 #ifdef DBX_STATIC_BLOCK_END
3132 DBX_STATIC_BLOCK_END (asm_out_file
, code
);
3137 /* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
3138 Then output LETTER to indicate the kind of location the symbol has. */
3141 dbxout_symbol_name (tree decl
, const char *suffix
, int letter
)
3145 if (DECL_CONTEXT (decl
)
3146 && (TYPE_P (DECL_CONTEXT (decl
))
3147 || TREE_CODE (DECL_CONTEXT (decl
)) == NAMESPACE_DECL
))
3148 /* One slight hitch: if this is a VAR_DECL which is a class member
3149 or a namespace member, we must put out the mangled name instead of the
3150 DECL_NAME. Note also that static member (variable) names DO NOT begin
3151 with underscores in .stabs directives. */
3152 name
= DECL_ASSEMBLER_NAME (decl
);
3154 /* ...but if we're function-local, we don't want to include the junk
3155 added by ASM_FORMAT_PRIVATE_NAME. */
3156 name
= DECL_NAME (decl
);
3161 stabstr_S ("(anon)");
3171 /* Output the common block name for DECL in a stabs.
3173 Symbols in global common (.comm) get wrapped with an N_BCOMM/N_ECOMM pair
3174 around each group of symbols in the same .comm area. The N_GSYM stabs
3175 that are emitted only contain the offset in the common area. This routine
3176 emits the N_BCOMM and N_ECOMM stabs. */
3179 dbxout_common_name (tree decl
, const char *name
, stab_code_type op
)
3181 dbxout_begin_complex_stabs ();
3183 dbxout_finish_complex_stabs (decl
, op
, NULL_RTX
, NULL
, 0);
3186 /* Check decl to determine whether it is a VAR_DECL destined for storage in a
3187 common area. If it is, the return value will be a non-null string giving
3188 the name of the common storage block it will go into. If non-null, the
3189 value is the offset into the common block for that symbol's storage. */
3192 dbxout_common_check (tree decl
, int *value
)
3196 const char *name
= NULL
;
3198 /* If the decl isn't a VAR_DECL, or if it isn't static, or if
3199 it does not have a value (the offset into the common area), or if it
3200 is thread local (as opposed to global) then it isn't common, and shouldn't
3203 ??? DECL_THREAD_LOCAL_P check prevents problems with improper .stabs
3204 for thread-local symbols. Can be handled via same mechanism as used
3206 if (TREE_CODE (decl
) != VAR_DECL
3207 || !TREE_STATIC(decl
)
3208 || !DECL_HAS_VALUE_EXPR_P(decl
)
3209 || DECL_THREAD_LOCAL_P (decl
)
3213 home
= DECL_RTL (decl
);
3214 if (home
== NULL_RTX
|| GET_CODE (home
) != MEM
)
3217 sym_addr
= dbxout_expand_expr (DECL_VALUE_EXPR (decl
));
3218 if (sym_addr
== NULL_RTX
|| GET_CODE (sym_addr
) != MEM
)
3221 sym_addr
= XEXP (sym_addr
, 0);
3222 if (GET_CODE (sym_addr
) == CONST
)
3223 sym_addr
= XEXP (sym_addr
, 0);
3224 if ((GET_CODE (sym_addr
) == SYMBOL_REF
|| GET_CODE (sym_addr
) == PLUS
)
3225 && DECL_INITIAL (decl
) == 0)
3228 /* We have a sym that will go into a common area, meaning that it
3229 will get storage reserved with a .comm/.lcomm assembler pseudo-op.
3231 Determine name of common area this symbol will be an offset into,
3232 and offset into that area. Also retrieve the decl for the area
3233 that the symbol is offset into. */
3236 switch (GET_CODE (sym_addr
))
3239 if (CONST_INT_P (XEXP (sym_addr
, 0)))
3242 targetm
.strip_name_encoding(XSTR (XEXP (sym_addr
, 1), 0));
3243 *value
= INTVAL (XEXP (sym_addr
, 0));
3244 cdecl = SYMBOL_REF_DECL (XEXP (sym_addr
, 1));
3249 targetm
.strip_name_encoding(XSTR (XEXP (sym_addr
, 0), 0));
3250 *value
= INTVAL (XEXP (sym_addr
, 1));
3251 cdecl = SYMBOL_REF_DECL (XEXP (sym_addr
, 0));
3256 name
= targetm
.strip_name_encoding(XSTR (sym_addr
, 0));
3258 cdecl = SYMBOL_REF_DECL (sym_addr
);
3262 error ("common symbol debug info is not structured as "
3266 /* Check area common symbol is offset into. If this is not public, then
3267 it is not a symbol in a common block. It must be a .lcomm symbol, not
3269 if (cdecl == NULL
|| !TREE_PUBLIC(cdecl))
3278 /* Output definitions of all the decls in a chain. Return nonzero if
3279 anything was output */
3282 dbxout_syms (tree syms
)
3285 const char *comm_prev
= NULL
;
3286 tree syms_prev
= NULL
;
3290 int temp
, copen
, cclos
;
3291 const char *comm_new
;
3293 /* Check for common symbol, and then progression into a new/different
3294 block of common symbols. Emit closing/opening common bracket if
3296 comm_new
= dbxout_common_check (syms
, &temp
);
3297 copen
= comm_new
!= NULL
3298 && (comm_prev
== NULL
|| strcmp (comm_new
, comm_prev
));
3299 cclos
= comm_prev
!= NULL
3300 && (comm_new
== NULL
|| strcmp (comm_new
, comm_prev
));
3302 dbxout_common_name (syms_prev
, comm_prev
, N_ECOMM
);
3305 dbxout_common_name (syms
, comm_new
, N_BCOMM
);
3308 comm_prev
= comm_new
;
3310 result
+= dbxout_symbol (syms
, 1);
3311 syms
= DECL_CHAIN (syms
);
3314 if (comm_prev
!= NULL
)
3315 dbxout_common_name (syms_prev
, comm_prev
, N_ECOMM
);
3320 /* The following two functions output definitions of function parameters.
3321 Each parameter gets a definition locating it in the parameter list.
3322 Each parameter that is a register variable gets a second definition
3323 locating it in the register.
3325 Printing or argument lists in gdb uses the definitions that
3326 locate in the parameter list. But reference to the variable in
3327 expressions uses preferentially the definition as a register. */
3329 /* Output definitions, referring to storage in the parmlist,
3330 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
3333 dbxout_parms (tree parms
)
3336 emit_pending_bincls_if_required ();
3338 for (; parms
; parms
= DECL_CHAIN (parms
))
3339 if (DECL_NAME (parms
)
3340 && TREE_TYPE (parms
) != error_mark_node
3341 && DECL_RTL_SET_P (parms
)
3342 && DECL_INCOMING_RTL (parms
))
3346 stab_code_type code
;
3349 /* Perform any necessary register eliminations on the parameter's rtl,
3350 so that the debugging output will be accurate. */
3351 DECL_INCOMING_RTL (parms
)
3352 = eliminate_regs (DECL_INCOMING_RTL (parms
), VOIDmode
, NULL_RTX
);
3353 SET_DECL_RTL (parms
,
3354 eliminate_regs (DECL_RTL (parms
), VOIDmode
, NULL_RTX
));
3355 #ifdef LEAF_REG_REMAP
3356 if (current_function_uses_only_leaf_regs
)
3358 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms
));
3359 leaf_renumber_regs_insn (DECL_RTL (parms
));
3363 if (PARM_PASSED_IN_MEMORY (parms
))
3365 rtx inrtl
= XEXP (DECL_INCOMING_RTL (parms
), 0);
3367 /* ??? Here we assume that the parm address is indexed
3368 off the frame pointer or arg pointer.
3369 If that is not true, we produce meaningless results,
3370 but do not crash. */
3371 if (GET_CODE (inrtl
) == PLUS
3372 && CONST_INT_P (XEXP (inrtl
, 1)))
3373 number
= INTVAL (XEXP (inrtl
, 1));
3378 number
= DEBUGGER_ARG_OFFSET (number
, inrtl
);
3381 /* It is quite tempting to use TREE_TYPE (parms) instead
3382 of DECL_ARG_TYPE (parms) for the eff_type, so that gcc
3383 reports the actual type of the parameter, rather than
3384 the promoted type. This certainly makes GDB's life
3385 easier, at least for some ports. The change is a bad
3386 idea however, since GDB expects to be able access the
3387 type without performing any conversions. So for
3388 example, if we were passing a float to an unprototyped
3389 function, gcc will store a double on the stack, but if
3390 we emit a stab saying the type is a float, then gdb
3391 will only read in a single value, and this will produce
3392 an erroneous value. */
3393 eff_type
= DECL_ARG_TYPE (parms
);
3395 else if (REG_P (DECL_RTL (parms
)))
3399 /* Parm passed in registers and lives in registers or nowhere. */
3400 code
= DBX_REGPARM_STABS_CODE
;
3401 letter
= DBX_REGPARM_STABS_LETTER
;
3403 /* For parms passed in registers, it is better to use the
3404 declared type of the variable, not the type it arrived in. */
3405 eff_type
= TREE_TYPE (parms
);
3407 /* If parm lives in a register, use that register; pretend
3408 the parm was passed there. It would be more consistent
3409 to describe the register where the parm was passed, but
3410 in practice that register usually holds something else.
3411 If the parm lives nowhere, use the register where it
3413 if (REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
3414 best_rtl
= DECL_RTL (parms
);
3415 else if (GET_CODE (DECL_INCOMING_RTL (parms
)) == PARALLEL
)
3416 best_rtl
= XEXP (XVECEXP (DECL_INCOMING_RTL (parms
), 0, 0), 0);
3418 best_rtl
= DECL_INCOMING_RTL (parms
);
3420 number
= DBX_REGISTER_NUMBER (REGNO (best_rtl
));
3422 else if (MEM_P (DECL_RTL (parms
))
3423 && REG_P (XEXP (DECL_RTL (parms
), 0))
3424 && REGNO (XEXP (DECL_RTL (parms
), 0)) != HARD_FRAME_POINTER_REGNUM
3425 && REGNO (XEXP (DECL_RTL (parms
), 0)) != STACK_POINTER_REGNUM
3426 #if !HARD_FRAME_POINTER_IS_ARG_POINTER
3427 && REGNO (XEXP (DECL_RTL (parms
), 0)) != ARG_POINTER_REGNUM
3431 /* Parm was passed via invisible reference.
3432 That is, its address was passed in a register.
3433 Output it as if it lived in that register.
3434 The debugger will know from the type
3435 that it was actually passed by invisible reference. */
3437 code
= DBX_REGPARM_STABS_CODE
;
3439 /* GDB likes this marked with a special letter. */
3440 letter
= (use_gnu_debug_info_extensions
3441 ? 'a' : DBX_REGPARM_STABS_LETTER
);
3442 eff_type
= TREE_TYPE (parms
);
3444 /* DECL_RTL looks like (MEM (REG...). Get the register number.
3445 If it is an unallocated pseudo-reg, then use the register where
3446 it was passed instead.
3447 ??? Why is DBX_REGISTER_NUMBER not used here? */
3449 if (REGNO (XEXP (DECL_RTL (parms
), 0)) < FIRST_PSEUDO_REGISTER
)
3450 number
= REGNO (XEXP (DECL_RTL (parms
), 0));
3452 number
= REGNO (DECL_INCOMING_RTL (parms
));
3454 else if (MEM_P (DECL_RTL (parms
))
3455 && MEM_P (XEXP (DECL_RTL (parms
), 0)))
3457 /* Parm was passed via invisible reference, with the reference
3458 living on the stack. DECL_RTL looks like
3459 (MEM (MEM (PLUS (REG ...) (CONST_INT ...)))) or it
3460 could look like (MEM (MEM (REG))). */
3464 eff_type
= TREE_TYPE (parms
);
3466 if (!REG_P (XEXP (XEXP (DECL_RTL (parms
), 0), 0)))
3467 number
= INTVAL (XEXP (XEXP (XEXP (DECL_RTL (parms
), 0), 0), 1));
3471 number
= DEBUGGER_ARG_OFFSET (number
,
3472 XEXP (XEXP (DECL_RTL (parms
), 0), 0));
3474 else if (MEM_P (DECL_RTL (parms
))
3475 && XEXP (DECL_RTL (parms
), 0) != const0_rtx
3476 /* ??? A constant address for a parm can happen
3477 when the reg it lives in is equiv to a constant in memory.
3478 Should make this not happen, after 2.4. */
3479 && ! CONSTANT_P (XEXP (DECL_RTL (parms
), 0)))
3481 /* Parm was passed in registers but lives on the stack. */
3485 eff_type
= TREE_TYPE (parms
);
3487 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
3488 in which case we want the value of that CONST_INT,
3490 in which case we use a value of zero. */
3491 if (!REG_P (XEXP (DECL_RTL (parms
), 0)))
3492 number
= INTVAL (XEXP (XEXP (DECL_RTL (parms
), 0), 1));
3496 /* Make a big endian correction if the mode of the type of the
3497 parameter is not the same as the mode of the rtl. */
3498 if (BYTES_BIG_ENDIAN
3499 && TYPE_MODE (TREE_TYPE (parms
)) != GET_MODE (DECL_RTL (parms
))
3500 && GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms
))) < UNITS_PER_WORD
)
3501 number
+= (GET_MODE_SIZE (GET_MODE (DECL_RTL (parms
)))
3502 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms
))));
3505 /* ??? We don't know how to represent this argument. */
3508 dbxout_begin_complex_stabs ();
3510 if (DECL_NAME (parms
))
3512 stabstr_I (DECL_NAME (parms
));
3516 stabstr_S ("(anon):");
3518 dbxout_type (eff_type
, 0);
3519 dbxout_finish_complex_stabs (parms
, code
, 0, 0, number
);
3521 DBXOUT_DECR_NESTING
;
3524 /* Output definitions for the places where parms live during the function,
3525 when different from where they were passed, when the parms were passed
3528 It is not useful to do this for parms passed in registers
3529 that live during the function in different registers, because it is
3530 impossible to look in the passed register for the passed value,
3531 so we use the within-the-function register to begin with.
3533 PARMS is a chain of PARM_DECL nodes. */
3536 dbxout_reg_parms (tree parms
)
3540 for (; parms
; parms
= DECL_CHAIN (parms
))
3541 if (DECL_NAME (parms
) && PARM_PASSED_IN_MEMORY (parms
))
3543 /* Report parms that live in registers during the function
3544 but were passed in memory. */
3545 if (REG_P (DECL_RTL (parms
))
3546 && REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
3547 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
3548 0, DECL_RTL (parms
));
3549 else if (GET_CODE (DECL_RTL (parms
)) == CONCAT
)
3550 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
3551 0, DECL_RTL (parms
));
3552 /* Report parms that live in memory but not where they were passed. */
3553 else if (MEM_P (DECL_RTL (parms
))
3554 && ! rtx_equal_p (DECL_RTL (parms
), DECL_INCOMING_RTL (parms
)))
3555 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
3556 0, DECL_RTL (parms
));
3558 DBXOUT_DECR_NESTING
;
3561 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
3562 output definitions of those names, in raw form */
3565 dbxout_args (tree args
)
3570 dbxout_type (TREE_VALUE (args
), 0);
3571 args
= TREE_CHAIN (args
);
3575 #if defined (DBX_DEBUGGING_INFO)
3577 /* Subroutine of dbxout_block. Emit an N_LBRAC stab referencing LABEL.
3578 BEGIN_LABEL is the name of the beginning of the function, which may
3581 dbx_output_lbrac (const char *label
,
3582 const char *begin_label ATTRIBUTE_UNUSED
)
3584 dbxout_begin_stabn (N_LBRAC
);
3585 if (DBX_BLOCKS_FUNCTION_RELATIVE
)
3586 dbxout_stab_value_label_diff (label
, begin_label
);
3588 dbxout_stab_value_label (label
);
3591 /* Subroutine of dbxout_block. Emit an N_RBRAC stab referencing LABEL.
3592 BEGIN_LABEL is the name of the beginning of the function, which may
3595 dbx_output_rbrac (const char *label
,
3596 const char *begin_label ATTRIBUTE_UNUSED
)
3598 dbxout_begin_stabn (N_RBRAC
);
3599 if (DBX_BLOCKS_FUNCTION_RELATIVE
)
3600 dbxout_stab_value_label_diff (label
, begin_label
);
3602 dbxout_stab_value_label (label
);
3605 /* Output everything about a symbol block (a BLOCK node
3606 that represents a scope level),
3607 including recursive output of contained blocks.
3609 BLOCK is the BLOCK node.
3610 DEPTH is its depth within containing symbol blocks.
3611 ARGS is usually zero; but for the outermost block of the
3612 body of a function, it is a chain of PARM_DECLs for the function parameters.
3613 We output definitions of all the register parms
3614 as if they were local variables of that block.
3616 If -g1 was used, we count blocks just the same, but output nothing
3617 except for the outermost block.
3619 Actually, BLOCK may be several blocks chained together.
3620 We handle them all in sequence. */
3623 dbxout_block (tree block
, int depth
, tree args
)
3625 char begin_label
[20];
3626 /* Reference current function start using LFBB. */
3627 ASM_GENERATE_INTERNAL_LABEL (begin_label
, "LFBB", scope_labelno
);
3631 /* Ignore blocks never expanded or otherwise marked as real. */
3632 if (TREE_USED (block
) && TREE_ASM_WRITTEN (block
))
3635 int blocknum
= BLOCK_NUMBER (block
);
3637 /* In dbx format, the syms of a block come before the N_LBRAC.
3638 If nothing is output, we don't need the N_LBRAC, either. */
3640 if (debug_info_level
!= DINFO_LEVEL_TERSE
|| depth
== 0)
3641 did_output
= dbxout_syms (BLOCK_VARS (block
));
3643 dbxout_reg_parms (args
);
3645 /* Now output an N_LBRAC symbol to represent the beginning of
3646 the block. Use the block's tree-walk order to generate
3647 the assembler symbols LBBn and LBEn
3648 that final will define around the code in this block. */
3652 const char *scope_start
;
3655 /* The outermost block doesn't get LBB labels; use
3656 the LFBB local symbol emitted by dbxout_begin_prologue. */
3657 scope_start
= begin_label
;
3660 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBB", blocknum
);
3664 dbx_output_lbrac (scope_start
, begin_label
);
3667 /* Output the subblocks. */
3668 dbxout_block (BLOCK_SUBBLOCKS (block
), depth
+ 1, NULL_TREE
);
3670 /* Refer to the marker for the end of the block. */
3675 /* The outermost block doesn't get LBE labels;
3676 use the "scope" label which will be emitted
3677 by dbxout_function_end. */
3678 ASM_GENERATE_INTERNAL_LABEL (buf
, "Lscope", scope_labelno
);
3680 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBE", blocknum
);
3682 dbx_output_rbrac (buf
, begin_label
);
3685 block
= BLOCK_CHAIN (block
);
3689 /* Output the information about a function and its arguments and result.
3690 Usually this follows the function's code,
3691 but on some systems, it comes before. */
3694 dbxout_begin_function (tree decl
)
3696 int saved_tree_used1
;
3698 saved_tree_used1
= TREE_USED (decl
);
3699 TREE_USED (decl
) = 1;
3700 if (DECL_NAME (DECL_RESULT (decl
)) != 0)
3702 int saved_tree_used2
= TREE_USED (DECL_RESULT (decl
));
3703 TREE_USED (DECL_RESULT (decl
)) = 1;
3704 dbxout_symbol (decl
, 0);
3705 TREE_USED (DECL_RESULT (decl
)) = saved_tree_used2
;
3708 dbxout_symbol (decl
, 0);
3709 TREE_USED (decl
) = saved_tree_used1
;
3711 dbxout_parms (DECL_ARGUMENTS (decl
));
3712 if (DECL_NAME (DECL_RESULT (decl
)) != 0)
3713 dbxout_symbol (DECL_RESULT (decl
), 1);
3715 #endif /* DBX_DEBUGGING_INFO */
3717 #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */
3719 #include "gt-dbxout.h"