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
4 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 2, 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 COPYING. If not, write to the Free
20 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
24 /* Output dbx-format symbol table data.
25 This consists of many symbol table entries, each of them
26 a .stabs assembler pseudo-op with four operands:
27 a "name" which is really a description of one symbol and its type,
28 a "code", which is a symbol defined in stab.h whose name starts with N_,
29 an unused operand always 0,
30 and a "value" which is an address or an offset.
31 The name is enclosed in doublequote characters.
33 Each function, variable, typedef, and structure tag
34 has a symbol table entry to define it.
35 The beginning and end of each level of name scoping within
36 a function are also marked by special symbol table entries.
38 The "name" consists of the symbol name, a colon, a kind-of-symbol letter,
39 and a data type number. The data type number may be followed by
40 "=" and a type definition; normally this will happen the first time
41 the type number is mentioned. The type definition may refer to
42 other types by number, and those type numbers may be followed
43 by "=" and nested definitions.
45 This can make the "name" quite long.
46 When a name is more than 80 characters, we split the .stabs pseudo-op
47 into two .stabs pseudo-ops, both sharing the same "code" and "value".
48 The first one is marked as continued with a double-backslash at the
51 The kind-of-symbol letter distinguished function names from global
52 variables from file-scope variables from parameters from auto
53 variables in memory from typedef names from register variables.
56 The "code" is mostly redundant with the kind-of-symbol letter
57 that goes in the "name", but not entirely: for symbols located
58 in static storage, the "code" says which segment the address is in,
59 which controls how it is relocated.
61 The "value" for a symbol in static storage
62 is the core address of the symbol (actually, the assembler
63 label for the symbol). For a symbol located in a stack slot
64 it is the stack offset; for one in a register, the register number.
65 For a typedef symbol, it is zero.
67 If DEBUG_SYMS_TEXT is defined, all debugging symbols must be
68 output while in the text section.
70 For more on data type definitions, see `dbxout_type'. */
74 #include "coretypes.h"
81 #include "insn-config.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 typeinfo GTY(())
177 enum typestatus status;
182 /* Vector recording information about C data types.
183 When we first notice a data type (a tree node),
184 we assign it a number using next_type_number.
185 That is its index in this vector. */
187 static GTY ((length ("typevec_len"))) struct typeinfo *typevec;
189 /* Number of elements of space allocated in `typevec'. */
191 static GTY(()) int typevec_len;
193 /* In dbx output, each type gets a unique number.
194 This is the number for the next type output.
195 The number, once assigned, is in the TYPE_SYMTAB_ADDRESS field. */
197 static GTY(()) int next_type_number;
199 /* The C front end may call dbxout_symbol before dbxout_init runs.
200 We save all such decls in this list and output them when we get
203 static GTY(()) tree preinit_symbols;
205 enum binclstatus {BINCL_NOT_REQUIRED, BINCL_PENDING, BINCL_PROCESSED};
207 /* When using N_BINCL in dbx output, each type number is actually a
208 pair of the file number and the type number within the file.
209 This is a stack of input files. */
213 struct dbx_file *next;
215 int next_type_number;
216 enum binclstatus bincl_status; /* Keep track of lazy bincl. */
217 const char *pending_bincl_name; /* Name of bincl. */
218 struct dbx_file *prev; /* Chain to traverse all pending bincls. */
221 /* This is the top of the stack.
223 This is not saved for PCH, because restoring a PCH should not change it.
224 next_file_number does have to be saved, because the PCH may use some
225 file numbers; however, just before restoring a PCH, next_file_number
226 should always be 0 because we should not have needed any file numbers
229 #if (defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)) \
230 && defined (DBX_USE_BINCL)
231 static struct dbx_file *current_file;
234 /* This is the next file number to use. */
236 static GTY(()) int next_file_number;
238 /* A counter for dbxout_function_end. */
240 static GTY(()) int scope_labelno;
242 /* A counter for dbxout_source_line. */
244 static GTY(()) int dbxout_source_line_counter;
246 /* Number for the next N_SOL filename stabs label. The number 0 is reserved
247 for the N_SO filename stabs label. */
249 static GTY(()) int source_label_number = 1;
251 /* Last source file name mentioned in a NOTE insn. */
253 static GTY(()) const char *lastfile;
255 /* Used by PCH machinery to detect if 'lastfile' should be reset to
257 static GTY(()) int lastfile_is_base;
259 /* Typical USG systems don't have stab.h, and they also have
260 no use for DBX-format debugging info. */
262 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
265 /* If zero then there is no pending BINCL. */
266 static int pending_bincls = 0;
269 /* The original input file name. */
270 static const char *base_input_file;
272 #ifdef DEBUG_SYMS_TEXT
273 #define FORCE_TEXT switch_to_section (current_function_section ())
280 #define STAB_CODE_TYPE enum __stab_debug_code
282 /* 1 if PARM is passed to this function in memory. */
284 #define PARM_PASSED_IN_MEMORY(PARM) \
285 (MEM_P (DECL_INCOMING_RTL (PARM)))
287 /* A C expression for the integer offset value of an automatic variable
288 (N_LSYM) having address X (an RTX). */
289 #ifndef DEBUGGER_AUTO_OFFSET
290 #define DEBUGGER_AUTO_OFFSET(X) \
291 (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
294 /* A C expression for the integer offset value of an argument (N_PSYM)
295 having address X (an RTX). The nominal offset is OFFSET. */
296 #ifndef DEBUGGER_ARG_OFFSET
297 #define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET)
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);
324 static void dbxout_type (tree, int);
325 static bool print_int_cst_bounds_in_octal_p (tree);
326 static void dbxout_type_name (tree);
327 static void dbxout_class_name_qualifiers (tree);
328 static int dbxout_symbol_location (tree, tree, const char *, rtx);
329 static void dbxout_symbol_name (tree, const char *, int);
330 static void dbxout_block (tree, int, tree);
331 static void dbxout_global_decl (tree);
332 static void dbxout_type_decl (tree, int);
333 static void dbxout_handle_pch (unsigned);
335 /* The debug hooks structure. */
336 #if defined (DBX_DEBUGGING_INFO)
338 static void dbxout_source_line (unsigned int, const char *);
339 static void dbxout_begin_prologue (unsigned int, const char *);
340 static void dbxout_source_file (const char *);
341 static void dbxout_function_end (tree);
342 static void dbxout_begin_function (tree);
343 static void dbxout_begin_block (unsigned, unsigned);
344 static void dbxout_end_block (unsigned, unsigned);
345 static void dbxout_function_decl (tree);
347 const struct gcc_debug_hooks dbx_debug_hooks =
351 debug_nothing_int_charstar,
352 debug_nothing_int_charstar,
353 dbxout_start_source_file,
354 dbxout_end_source_file,
357 debug_true_tree, /* ignore_block */
358 dbxout_source_line, /* source_line */
359 dbxout_begin_prologue, /* begin_prologue */
360 debug_nothing_int_charstar, /* end_prologue */
361 debug_nothing_int_charstar, /* end_epilogue */
362 #ifdef DBX_FUNCTION_FIRST
363 dbxout_begin_function,
365 debug_nothing_tree, /* begin_function */
367 debug_nothing_int, /* end_function */
368 dbxout_function_decl,
369 dbxout_global_decl, /* global_decl */
370 dbxout_type_decl, /* type_decl */
371 debug_nothing_tree_tree, /* imported_module_or_decl */
372 debug_nothing_tree, /* deferred_inline_function */
373 debug_nothing_tree, /* outlining_inline_function */
374 debug_nothing_rtx, /* label */
375 dbxout_handle_pch, /* handle_pch */
376 debug_nothing_rtx, /* var_location */
377 debug_nothing_void, /* switch_text_section */
378 0 /* start_end_main_source_file */
380 #endif /* DBX_DEBUGGING_INFO */
382 #if defined (XCOFF_DEBUGGING_INFO)
383 const struct gcc_debug_hooks xcoff_debug_hooks =
387 debug_nothing_int_charstar,
388 debug_nothing_int_charstar,
389 dbxout_start_source_file,
390 dbxout_end_source_file,
391 xcoffout_begin_block,
393 debug_true_tree, /* ignore_block */
394 xcoffout_source_line,
395 xcoffout_begin_prologue, /* begin_prologue */
396 debug_nothing_int_charstar, /* end_prologue */
397 xcoffout_end_epilogue,
398 debug_nothing_tree, /* begin_function */
399 xcoffout_end_function,
400 debug_nothing_tree, /* function_decl */
401 dbxout_global_decl, /* global_decl */
402 dbxout_type_decl, /* type_decl */
403 debug_nothing_tree_tree, /* imported_module_or_decl */
404 debug_nothing_tree, /* deferred_inline_function */
405 debug_nothing_tree, /* outlining_inline_function */
406 debug_nothing_rtx, /* label */
407 dbxout_handle_pch, /* handle_pch */
408 debug_nothing_rtx, /* var_location */
409 debug_nothing_void, /* switch_text_section */
410 0 /* start_end_main_source_file */
412 #endif /* XCOFF_DEBUGGING_INFO */
414 /* Numeric formatting helper macro. Note that this does not handle
416 #define NUMBER_FMT_LOOP(P, NUM, BASE) \
419 int digit = NUM % BASE; \
421 *--P = digit + '0'; \
425 /* Utility: write a decimal integer NUM to asm_out_file. */
430 char *p = buf + sizeof buf;
435 putc ('0', asm_out_file);
440 putc ('-', asm_out_file);
446 NUMBER_FMT_LOOP (p, unum, 10);
448 while (p < buf + sizeof buf)
450 putc (*p, asm_out_file);
456 /* Primitives for emitting simple stabs directives. All other stabs
457 routines should use these functions instead of directly emitting
458 stabs. They are exported because machine-dependent code may need
459 to invoke them, e.g. in a DBX_OUTPUT_* macro whose definition
460 forwards to code in CPU.c. */
462 /* The following functions should all be called immediately after one
463 of the dbxout_begin_stab* functions (below). They write out
464 various things as the value of a stab. */
466 /* Write out a literal zero as the value of a stab. */
468 dbxout_stab_value_zero (void)
470 fputs ("0\n", asm_out_file);
473 /* Write out the label LABEL as the value of a stab. */
475 dbxout_stab_value_label (const char *label)
477 assemble_name (asm_out_file, label);
478 putc ('\n', asm_out_file);
481 /* Write out the difference of two labels, LABEL - BASE, as the value
484 dbxout_stab_value_label_diff (const char *label, const char *base)
486 assemble_name (asm_out_file, label);
487 putc ('-', asm_out_file);
488 assemble_name (asm_out_file, base);
489 putc ('\n', asm_out_file);
492 /* Write out an internal label as the value of a stab, and immediately
493 emit that internal label. This should be used only when
494 dbxout_stabd will not work. STEM is the name stem of the label,
495 COUNTERP is a pointer to a counter variable which will be used to
496 guarantee label uniqueness. */
498 dbxout_stab_value_internal_label (const char *stem, int *counterp)
501 int counter = counterp ? (*counterp)++ : 0;
503 ASM_GENERATE_INTERNAL_LABEL (label, stem, counter);
504 dbxout_stab_value_label (label);
505 targetm.asm_out.internal_label (asm_out_file, stem, counter);
508 /* Write out the difference between BASE and an internal label as the
509 value of a stab, and immediately emit that internal label. STEM and
510 COUNTERP are as for dbxout_stab_value_internal_label. */
512 dbxout_stab_value_internal_label_diff (const char *stem, int *counterp,
516 int counter = counterp ? (*counterp)++ : 0;
518 ASM_GENERATE_INTERNAL_LABEL (label, stem, counter);
519 dbxout_stab_value_label_diff (label, base);
520 targetm.asm_out.internal_label (asm_out_file, stem, counter);
523 /* The following functions produce specific kinds of stab directives. */
525 /* Write a .stabd directive with type STYPE and desc SDESC to asm_out_file. */
527 dbxout_stabd (int stype, int sdesc)
529 fputs (ASM_STABD_OP, asm_out_file);
531 fputs (",0,", asm_out_file);
533 putc ('\n', asm_out_file);
536 /* Write a .stabn directive with type STYPE. This function stops
537 short of emitting the value field, which is the responsibility of
538 the caller (normally it will be either a symbol or the difference
542 dbxout_begin_stabn (int stype)
544 fputs (ASM_STABN_OP, asm_out_file);
546 fputs (",0,0,", asm_out_file);
549 /* Write a .stabn directive with type N_SLINE and desc LINE. As above,
550 the value field is the responsibility of the caller. */
552 dbxout_begin_stabn_sline (int lineno)
554 fputs (ASM_STABN_OP, asm_out_file);
555 dbxout_int (N_SLINE);
556 fputs (",0,", asm_out_file);
558 putc (',', asm_out_file);
561 /* Begin a .stabs directive with string "", type STYPE, and desc and
562 other fields 0. The value field is the responsibility of the
563 caller. This function cannot be used for .stabx directives. */
565 dbxout_begin_empty_stabs (int stype)
567 fputs (ASM_STABS_OP, asm_out_file);
568 fputs ("\"\",", asm_out_file);
570 fputs (",0,0,", asm_out_file);
573 /* Begin a .stabs directive with string STR, type STYPE, and desc 0.
574 The value field is the responsibility of the caller. */
576 dbxout_begin_simple_stabs (const char *str, int stype)
578 fputs (ASM_STABS_OP, asm_out_file);
579 output_quoted_string (asm_out_file, str);
580 putc (',', asm_out_file);
582 fputs (",0,0,", asm_out_file);
585 /* As above but use SDESC for the desc field. */
587 dbxout_begin_simple_stabs_desc (const char *str, int stype, int sdesc)
589 fputs (ASM_STABS_OP, asm_out_file);
590 output_quoted_string (asm_out_file, str);
591 putc (',', asm_out_file);
593 fputs (",0,", asm_out_file);
595 putc (',', asm_out_file);
598 /* The next set of functions are entirely concerned with production of
599 "complex" .stabs directives: that is, .stabs directives whose
600 strings have to be constructed piecemeal. dbxout_type,
601 dbxout_symbol, etc. use these routines heavily. The string is queued
602 up in an obstack, then written out by dbxout_finish_complex_stabs, which
603 is also responsible for splitting it up if it exceeds DBX_CONTIN_LENGTH.
604 (You might think it would be more efficient to go straight to stdio
605 when DBX_CONTIN_LENGTH is 0 (i.e. no length limit) but that turns
606 out not to be the case, and anyway this needs fewer #ifdefs.) */
608 /* Begin a complex .stabs directive. If we can, write the initial
609 ASM_STABS_OP to the asm_out_file. */
612 dbxout_begin_complex_stabs (void)
614 emit_pending_bincls_if_required ();
616 fputs (ASM_STABS_OP, asm_out_file);
617 putc ('"', asm_out_file);
618 gcc_assert (stabstr_last_contin_point == 0);
621 /* As above, but do not force text or emit pending bincls. This is
622 used by dbxout_symbol_location, which needs to do something else. */
624 dbxout_begin_complex_stabs_noforcetext (void)
626 fputs (ASM_STABS_OP, asm_out_file);
627 putc ('"', asm_out_file);
628 gcc_assert (stabstr_last_contin_point == 0);
631 /* Add CHR, a single character, to the string being built. */
632 #define stabstr_C(chr) obstack_1grow (&stabstr_ob, chr)
634 /* Add STR, a normal C string, to the string being built. */
635 #define stabstr_S(str) obstack_grow (&stabstr_ob, str, strlen(str))
637 /* Add the text of ID, an IDENTIFIER_NODE, to the string being built. */
638 #define stabstr_I(id) obstack_grow (&stabstr_ob, \
639 IDENTIFIER_POINTER (id), \
640 IDENTIFIER_LENGTH (id))
642 /* Add NUM, a signed decimal number, to the string being built. */
644 stabstr_D (HOST_WIDE_INT num)
647 char *p = buf + sizeof buf;
663 NUMBER_FMT_LOOP (p, unum, 10);
665 obstack_grow (&stabstr_ob, p, (buf + sizeof buf) - p);
668 /* Add NUM, an unsigned decimal number, to the string being built. */
670 stabstr_U (unsigned HOST_WIDE_INT num)
673 char *p = buf + sizeof buf;
679 NUMBER_FMT_LOOP (p, num, 10);
680 obstack_grow (&stabstr_ob, p, (buf + sizeof buf) - p);
683 /* Add CST, an INTEGER_CST tree, to the string being built as an
684 unsigned octal number. This routine handles values which are
685 larger than a single HOST_WIDE_INT. */
689 unsigned HOST_WIDE_INT high = TREE_INT_CST_HIGH (cst);
690 unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (cst);
693 char *p = buf + sizeof buf;
695 /* GDB wants constants with no extra leading "1" bits, so
696 we need to remove any sign-extension that might be
699 const unsigned int width = TYPE_PRECISION (TREE_TYPE (cst));
700 if (width == HOST_BITS_PER_WIDE_INT * 2)
702 else if (width > HOST_BITS_PER_WIDE_INT)
703 high &= (((HOST_WIDE_INT) 1 << (width - HOST_BITS_PER_WIDE_INT)) - 1);
704 else if (width == HOST_BITS_PER_WIDE_INT)
707 high = 0, low &= (((HOST_WIDE_INT) 1 << width) - 1);
710 /* Leading zero for base indicator. */
713 /* If the value is zero, the base indicator will serve as the value
715 if (high == 0 && low == 0)
718 /* If the high half is zero, we need only print the low half normally. */
720 NUMBER_FMT_LOOP (p, low, 8);
723 /* When high != 0, we need to print enough zeroes from low to
724 give the digits from high their proper place-values. Hence
725 NUMBER_FMT_LOOP cannot be used. */
726 const int n_digits = HOST_BITS_PER_WIDE_INT / 3;
729 for (i = 1; i <= n_digits; i++)
731 unsigned int digit = low % 8;
736 /* Octal digits carry exactly three bits of information. The
737 width of a HOST_WIDE_INT is not normally a multiple of three.
738 Therefore, the next digit printed probably needs to carry
739 information from both low and high. */
740 if (HOST_BITS_PER_WIDE_INT % 3 != 0)
742 const int n_leftover_bits = HOST_BITS_PER_WIDE_INT % 3;
743 const int n_bits_from_high = 3 - n_leftover_bits;
745 const unsigned HOST_WIDE_INT
746 low_mask = (((unsigned HOST_WIDE_INT)1) << n_leftover_bits) - 1;
747 const unsigned HOST_WIDE_INT
748 high_mask = (((unsigned HOST_WIDE_INT)1) << n_bits_from_high) - 1;
752 /* At this point, only the bottom n_leftover_bits bits of low
754 gcc_assert (!(low & ~low_mask));
756 digit = (low | ((high & high_mask) << n_leftover_bits));
757 high >>= n_bits_from_high;
762 /* Now we can format high in the normal manner. However, if
763 the only bits of high that were set were handled by the
764 digit split between low and high, high will now be zero, and
765 we don't want to print extra digits in that case. */
767 NUMBER_FMT_LOOP (p, high, 8);
770 obstack_grow (&stabstr_ob, p, (buf + sizeof buf) - p);
773 /* Called whenever it is safe to break a stabs string into multiple
774 .stabs directives. If the current string has exceeded the limit
775 set by DBX_CONTIN_LENGTH, mark the current position in the buffer
776 as a continuation point by inserting DBX_CONTIN_CHAR (doubled if
777 it is a backslash) and a null character. */
779 stabstr_continue (void)
781 if (DBX_CONTIN_LENGTH > 0
782 && obstack_object_size (&stabstr_ob) - stabstr_last_contin_point
785 if (DBX_CONTIN_CHAR == '\\')
786 obstack_1grow (&stabstr_ob, '\\');
787 obstack_1grow (&stabstr_ob, DBX_CONTIN_CHAR);
788 obstack_1grow (&stabstr_ob, '\0');
789 stabstr_last_contin_point = obstack_object_size (&stabstr_ob);
792 #define CONTIN stabstr_continue ()
794 /* Macro subroutine of dbxout_finish_complex_stabs, which emits
795 all of the arguments to the .stabs directive after the string.
796 Overridden by xcoffout.h. CODE is the stabs code for this symbol;
797 LINE is the source line to write into the desc field (in extended
798 mode); SYM is the symbol itself.
800 ADDR, LABEL, and NUMBER are three different ways to represent the
801 stabs value field. At most one of these should be nonzero.
803 ADDR is used most of the time; it represents the value as an
804 RTL address constant.
806 LABEL is used (currently) only for N_CATCH stabs; it represents
807 the value as a string suitable for assemble_name.
809 NUMBER is used when the value is an offset from an implicit base
810 pointer (e.g. for a stack variable), or an index (e.g. for a
811 register variable). It represents the value as a decimal integer. */
813 #ifndef DBX_FINISH_STABS
814 #define DBX_FINISH_STABS(SYM, CODE, LINE, ADDR, LABEL, NUMBER) \
816 int line_ = use_gnu_debug_info_extensions ? LINE : 0; \
819 fputs (",0,", asm_out_file); \
820 dbxout_int (line_); \
821 putc (',', asm_out_file); \
823 output_addr_const (asm_out_file, ADDR); \
825 assemble_name (asm_out_file, LABEL); \
827 dbxout_int (NUMBER); \
828 putc ('\n', asm_out_file); \
832 /* Finish the emission of a complex .stabs directive. When DBX_CONTIN_LENGTH
833 is zero, this has only to emit the close quote and the remainder of
834 the arguments. When it is nonzero, the string has been marshalled in
835 stabstr_ob, and this routine is responsible for breaking it up into
836 DBX_CONTIN_LENGTH-sized chunks.
838 SYM is the DECL of the symbol under consideration; it is used only
839 for its DECL_SOURCE_LINE. The other arguments are all passed directly
840 to DBX_FINISH_STABS; see above for details. */
843 dbxout_finish_complex_stabs (tree sym, STAB_CODE_TYPE code,
844 rtx addr, const char *label, int number)
846 int line ATTRIBUTE_UNUSED;
850 line = sym ? DECL_SOURCE_LINE (sym) : 0;
851 if (DBX_CONTIN_LENGTH > 0)
856 /* Nul-terminate the growing string, then get its size and
858 obstack_1grow (&stabstr_ob, '\0');
860 len = obstack_object_size (&stabstr_ob);
861 chunk = str = XOBFINISH (&stabstr_ob, char *);
863 /* Within the buffer are a sequence of NUL-separated strings,
864 each of which is to be written out as a separate stab
868 chunklen = strlen (chunk);
869 fwrite (chunk, 1, chunklen, asm_out_file);
870 fputs ("\",", asm_out_file);
872 /* Must add an extra byte to account for the NUL separator. */
873 chunk += chunklen + 1;
876 /* Only put a line number on the last stab in the sequence. */
877 DBX_FINISH_STABS (sym, code, len == 0 ? line : 0,
878 addr, label, number);
882 fputs (ASM_STABS_OP, asm_out_file);
883 putc ('"', asm_out_file);
885 stabstr_last_contin_point = 0;
889 /* No continuations - we can put the whole string out at once.
890 It is faster to augment the string with the close quote and
891 comma than to do a two-character fputs. */
892 obstack_grow (&stabstr_ob, "\",", 2);
893 len = obstack_object_size (&stabstr_ob);
894 str = XOBFINISH (&stabstr_ob, char *);
896 fwrite (str, 1, len, asm_out_file);
897 DBX_FINISH_STABS (sym, code, line, addr, label, number);
899 obstack_free (&stabstr_ob, str);
902 #if defined (DBX_DEBUGGING_INFO)
905 dbxout_function_end (tree decl)
907 char lscope_label_name[100];
908 int lscope_labelno = scope_labelno++;
910 /* The Lscope label must be emitted even if we aren't doing anything
911 else; dbxout_block needs it. */
912 switch_to_section (function_section (current_function_decl));
914 /* Convert Lscope into the appropriate format for local labels in case
915 the system doesn't insert underscores in front of user generated
917 ASM_GENERATE_INTERNAL_LABEL (lscope_label_name, "Lscope", lscope_labelno);
918 targetm.asm_out.internal_label (asm_out_file, "Lscope", lscope_labelno);
920 /* The N_FUN tag at the end of the function is a GNU extension,
921 which may be undesirable, and is unnecessary if we do not have
923 if (!use_gnu_debug_info_extensions
924 || NO_DBX_FUNCTION_END
925 || !targetm.have_named_sections
926 || DECL_IGNORED_P (decl))
929 /* By convention, GCC will mark the end of a function with an N_FUN
930 symbol and an empty string. */
931 if (flag_reorder_blocks_and_partition)
933 dbxout_begin_empty_stabs (N_FUN);
934 dbxout_stab_value_label_diff (cfun->hot_section_end_label,
935 cfun->hot_section_label);
936 dbxout_begin_empty_stabs (N_FUN);
937 dbxout_stab_value_label_diff (cfun->cold_section_end_label,
938 cfun->cold_section_label);
942 char begin_label[20];
943 /* Reference current function start using LFBB. */
944 ASM_GENERATE_INTERNAL_LABEL (begin_label, "LFBB", lscope_labelno);
945 dbxout_begin_empty_stabs (N_FUN);
946 dbxout_stab_value_label_diff (lscope_label_name, begin_label);
949 if (!NO_DBX_BNSYM_ENSYM && !flag_debug_only_used_symbols)
950 dbxout_stabd (N_ENSYM, 0);
952 #endif /* DBX_DEBUGGING_INFO */
954 /* Get lang description for N_SO stab. */
955 static unsigned int ATTRIBUTE_UNUSED
956 get_lang_number (void)
958 const char *language_string = lang_hooks.name;
960 if (strcmp (language_string, "GNU C") == 0)
962 else if (strcmp (language_string, "GNU C++") == 0)
964 else if (strcmp (language_string, "GNU F77") == 0)
966 else if (strcmp (language_string, "GNU F95") == 0)
967 return N_SO_FORTRAN90; /* CHECKME */
968 else if (strcmp (language_string, "GNU Pascal") == 0)
970 else if (strcmp (language_string, "GNU Objective-C") == 0)
972 else if (strcmp (language_string, "GNU Objective-C++") == 0)
973 return N_SO_OBJCPLUS;
979 /* At the beginning of compilation, start writing the symbol table.
980 Initialize `typevec' and output the standard data types of C. */
983 dbxout_init (const char *input_file_name)
985 char ltext_label_name[100];
986 bool used_ltext_label_name = false;
987 tree syms = lang_hooks.decls.getdecls ();
990 typevec = ggc_calloc (typevec_len, sizeof typevec[0]);
992 /* stabstr_ob contains one string, which will be just fine with
994 obstack_specify_allocation (&stabstr_ob, 0, 1, xmalloc, free);
996 /* Convert Ltext into the appropriate format for local labels in case
997 the system doesn't insert underscores in front of user generated
999 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext", 0);
1001 /* Put the current working directory in an N_SO symbol. */
1002 if (use_gnu_debug_info_extensions && !NO_DBX_MAIN_SOURCE_DIRECTORY)
1004 static const char *cwd;
1008 cwd = get_src_pwd ();
1011 else if (!IS_DIR_SEPARATOR (cwd[strlen (cwd) - 1]))
1012 cwd = concat (cwd, "/", NULL);
1014 #ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
1015 DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asm_out_file, cwd);
1016 #else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
1017 dbxout_begin_simple_stabs_desc (cwd, N_SO, get_lang_number ());
1018 dbxout_stab_value_label (ltext_label_name);
1019 used_ltext_label_name = true;
1020 #endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
1023 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
1024 DBX_OUTPUT_MAIN_SOURCE_FILENAME (asm_out_file, input_file_name);
1026 dbxout_begin_simple_stabs_desc (input_file_name, N_SO, get_lang_number ());
1027 dbxout_stab_value_label (ltext_label_name);
1028 used_ltext_label_name = true;
1031 if (used_ltext_label_name)
1033 switch_to_section (text_section);
1034 targetm.asm_out.internal_label (asm_out_file, "Ltext", 0);
1037 /* Emit an N_OPT stab to indicate that this file was compiled by GCC.
1038 The string used is historical. */
1039 #ifndef NO_DBX_GCC_MARKER
1040 dbxout_begin_simple_stabs ("gcc2_compiled.", N_OPT);
1041 dbxout_stab_value_zero ();
1044 base_input_file = lastfile = input_file_name;
1046 next_type_number = 1;
1048 #ifdef DBX_USE_BINCL
1049 current_file = XNEW (struct dbx_file);
1050 current_file->next = NULL;
1051 current_file->file_number = 0;
1052 current_file->next_type_number = 1;
1053 next_file_number = 1;
1054 current_file->prev = NULL;
1055 current_file->bincl_status = BINCL_NOT_REQUIRED;
1056 current_file->pending_bincl_name = NULL;
1059 /* Get all permanent types that have typedef names, and output them
1060 all, except for those already output. Some language front ends
1061 put these declarations in the top-level scope; some do not;
1062 the latter are responsible for calling debug_hooks->type_decl from
1063 their record_builtin_type function. */
1064 dbxout_typedefs (syms);
1066 if (preinit_symbols)
1069 for (t = nreverse (preinit_symbols); t; t = TREE_CHAIN (t))
1070 dbxout_symbol (TREE_VALUE (t), 0);
1071 preinit_symbols = 0;
1075 /* Output any typedef names for types described by TYPE_DECLs in SYMS. */
1078 dbxout_typedefs (tree syms)
1080 for (; syms != NULL_TREE; syms = TREE_CHAIN (syms))
1082 if (TREE_CODE (syms) == TYPE_DECL)
1084 tree type = TREE_TYPE (syms);
1085 if (TYPE_NAME (type)
1086 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1087 && COMPLETE_OR_VOID_TYPE_P (type)
1088 && ! TREE_ASM_WRITTEN (TYPE_NAME (type)))
1089 dbxout_symbol (TYPE_NAME (type), 0);
1094 #ifdef DBX_USE_BINCL
1095 /* Emit BINCL stab using given name. */
1097 emit_bincl_stab (const char *name)
1099 dbxout_begin_simple_stabs (name, N_BINCL);
1100 dbxout_stab_value_zero ();
1103 /* If there are pending bincls then it is time to emit all of them. */
1106 emit_pending_bincls_if_required (void)
1109 emit_pending_bincls ();
1112 /* Emit all pending bincls. */
1115 emit_pending_bincls (void)
1117 struct dbx_file *f = current_file;
1119 /* Find first pending bincl. */
1120 while (f->bincl_status == BINCL_PENDING)
1123 /* Now emit all bincls. */
1128 if (f->bincl_status == BINCL_PENDING)
1130 emit_bincl_stab (f->pending_bincl_name);
1132 /* Update file number and status. */
1133 f->file_number = next_file_number++;
1134 f->bincl_status = BINCL_PROCESSED;
1136 if (f == current_file)
1141 /* All pending bincls have been emitted. */
1148 emit_pending_bincls_if_required (void) {}
1151 /* Change to reading from a new source file. Generate a N_BINCL stab. */
1154 dbxout_start_source_file (unsigned int line ATTRIBUTE_UNUSED,
1155 const char *filename ATTRIBUTE_UNUSED)
1157 #ifdef DBX_USE_BINCL
1158 struct dbx_file *n = XNEW (struct dbx_file);
1160 n->next = current_file;
1161 n->next_type_number = 1;
1162 /* Do not assign file number now.
1163 Delay it until we actually emit BINCL. */
1166 current_file->prev = n;
1167 n->bincl_status = BINCL_PENDING;
1168 n->pending_bincl_name = filename;
1174 /* Revert to reading a previous source file. Generate a N_EINCL stab. */
1177 dbxout_end_source_file (unsigned int line ATTRIBUTE_UNUSED)
1179 #ifdef DBX_USE_BINCL
1180 /* Emit EINCL stab only if BINCL is not pending. */
1181 if (current_file->bincl_status == BINCL_PROCESSED)
1183 dbxout_begin_stabn (N_EINCL);
1184 dbxout_stab_value_zero ();
1186 current_file->bincl_status = BINCL_NOT_REQUIRED;
1187 current_file = current_file->next;
1191 /* Handle a few odd cases that occur when trying to make PCH files work. */
1194 dbxout_handle_pch (unsigned at_end)
1198 /* When using the PCH, this file will be included, so we need to output
1200 dbxout_start_source_file (0, lastfile);
1202 /* The base file when using the PCH won't be the same as
1203 the base file when it's being generated. */
1208 /* ... and an EINCL. */
1209 dbxout_end_source_file (0);
1211 /* Deal with cases where 'lastfile' was never actually changed. */
1212 lastfile_is_base = lastfile == NULL;
1216 #if defined (DBX_DEBUGGING_INFO)
1217 /* Output debugging info to FILE to switch to sourcefile FILENAME. */
1220 dbxout_source_file (const char *filename)
1222 if (lastfile == 0 && lastfile_is_base)
1224 lastfile = base_input_file;
1225 lastfile_is_base = 0;
1228 if (filename && (lastfile == 0 || strcmp (filename, lastfile)))
1230 /* Don't change section amid function. */
1231 if (current_function_decl == NULL_TREE)
1232 switch_to_section (text_section);
1234 dbxout_begin_simple_stabs (filename, N_SOL);
1235 dbxout_stab_value_internal_label ("Ltext", &source_label_number);
1236 lastfile = filename;
1240 /* Output N_BNSYM, line number symbol entry, and local symbol at
1244 dbxout_begin_prologue (unsigned int lineno, const char *filename)
1246 if (use_gnu_debug_info_extensions
1247 && !NO_DBX_FUNCTION_END
1248 && !NO_DBX_BNSYM_ENSYM
1249 && !flag_debug_only_used_symbols)
1250 dbxout_stabd (N_BNSYM, 0);
1252 dbxout_source_line (lineno, filename);
1253 /* Output function begin block at function scope, referenced
1254 by dbxout_block, dbxout_source_line and dbxout_function_end. */
1255 emit_pending_bincls_if_required ();
1256 targetm.asm_out.internal_label (asm_out_file, "LFBB", scope_labelno);
1259 /* Output a line number symbol entry for source file FILENAME and line
1263 dbxout_source_line (unsigned int lineno, const char *filename)
1265 dbxout_source_file (filename);
1267 #ifdef DBX_OUTPUT_SOURCE_LINE
1268 DBX_OUTPUT_SOURCE_LINE (asm_out_file, lineno, dbxout_source_line_counter);
1270 if (DBX_LINES_FUNCTION_RELATIVE)
1272 char begin_label[20];
1273 dbxout_begin_stabn_sline (lineno);
1274 /* Reference current function start using LFBB. */
1275 ASM_GENERATE_INTERNAL_LABEL (begin_label, "LFBB", scope_labelno);
1276 dbxout_stab_value_internal_label_diff ("LM", &dbxout_source_line_counter,
1280 dbxout_stabd (N_SLINE, lineno);
1284 /* Describe the beginning of an internal block within a function. */
1287 dbxout_begin_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int n)
1289 emit_pending_bincls_if_required ();
1290 targetm.asm_out.internal_label (asm_out_file, "LBB", n);
1293 /* Describe the end line-number of an internal block within a function. */
1296 dbxout_end_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int n)
1298 emit_pending_bincls_if_required ();
1299 targetm.asm_out.internal_label (asm_out_file, "LBE", n);
1302 /* Output dbx data for a function definition.
1303 This includes a definition of the function name itself (a symbol),
1304 definitions of the parameters (locating them in the parameter list)
1305 and then output the block that makes up the function's body
1306 (including all the auto variables of the function). */
1309 dbxout_function_decl (tree decl)
1311 emit_pending_bincls_if_required ();
1312 #ifndef DBX_FUNCTION_FIRST
1313 dbxout_begin_function (decl);
1315 dbxout_block (DECL_INITIAL (decl), 0, DECL_ARGUMENTS (decl));
1316 dbxout_function_end (decl);
1319 #endif /* DBX_DEBUGGING_INFO */
1321 /* Debug information for a global DECL. Called from toplev.c after
1322 compilation proper has finished. */
1324 dbxout_global_decl (tree decl)
1326 if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl))
1328 int saved_tree_used = TREE_USED (decl);
1329 TREE_USED (decl) = 1;
1330 dbxout_symbol (decl, 0);
1331 TREE_USED (decl) = saved_tree_used;
1335 /* This is just a function-type adapter; dbxout_symbol does exactly
1336 what we want but returns an int. */
1338 dbxout_type_decl (tree decl, int local)
1340 dbxout_symbol (decl, local);
1343 /* At the end of compilation, finish writing the symbol table.
1344 The default is to call debug_free_queue but do nothing else. */
1347 dbxout_finish (const char *filename ATTRIBUTE_UNUSED)
1349 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
1350 DBX_OUTPUT_MAIN_SOURCE_FILE_END (asm_out_file, filename);
1351 #elif defined DBX_OUTPUT_NULL_N_SO_AT_MAIN_SOURCE_FILE_END
1353 switch_to_section (text_section);
1354 dbxout_begin_empty_stabs (N_SO);
1355 dbxout_stab_value_internal_label ("Letext", 0);
1358 debug_free_queue ();
1361 /* Output the index of a type. */
1364 dbxout_type_index (tree type)
1366 #ifndef DBX_USE_BINCL
1367 stabstr_D (TYPE_SYMTAB_ADDRESS (type));
1369 struct typeinfo *t = &typevec[TYPE_SYMTAB_ADDRESS (type)];
1371 stabstr_D (t->file_number);
1373 stabstr_D (t->type_number);
1380 /* Used in several places: evaluates to '0' for a private decl,
1381 '1' for a protected decl, '2' for a public decl. */
1382 #define DECL_ACCESSIBILITY_CHAR(DECL) \
1383 (TREE_PRIVATE (DECL) ? '0' : TREE_PROTECTED (DECL) ? '1' : '2')
1385 /* Subroutine of `dbxout_type'. Output the type fields of TYPE.
1386 This must be a separate function because anonymous unions require
1390 dbxout_type_fields (tree type)
1394 /* Output the name, type, position (in bits), size (in bits) of each
1395 field that we can support. */
1396 for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
1398 /* If one of the nodes is an error_mark or its type is then
1400 if (tem == error_mark_node || TREE_TYPE (tem) == error_mark_node)
1403 /* Omit here local type decls until we know how to support them. */
1404 if (TREE_CODE (tem) == TYPE_DECL
1405 /* Omit here the nameless fields that are used to skip bits. */
1406 || DECL_IGNORED_P (tem)
1407 /* Omit fields whose position or size are variable or too large to
1409 || (TREE_CODE (tem) == FIELD_DECL
1410 && (! host_integerp (bit_position (tem), 0)
1411 || ! DECL_SIZE (tem)
1412 || ! host_integerp (DECL_SIZE (tem), 1))))
1415 else if (TREE_CODE (tem) != CONST_DECL)
1417 /* Continue the line if necessary,
1418 but not before the first field. */
1419 if (tem != TYPE_FIELDS (type))
1422 if (DECL_NAME (tem))
1423 stabstr_I (DECL_NAME (tem));
1426 if (use_gnu_debug_info_extensions
1427 && (TREE_PRIVATE (tem) || TREE_PROTECTED (tem)
1428 || TREE_CODE (tem) != FIELD_DECL))
1431 stabstr_C (DECL_ACCESSIBILITY_CHAR (tem));
1434 dbxout_type ((TREE_CODE (tem) == FIELD_DECL
1435 && DECL_BIT_FIELD_TYPE (tem))
1436 ? DECL_BIT_FIELD_TYPE (tem) : TREE_TYPE (tem), 0);
1438 if (TREE_CODE (tem) == VAR_DECL)
1440 if (TREE_STATIC (tem) && use_gnu_debug_info_extensions)
1442 tree name = DECL_ASSEMBLER_NAME (tem);
1449 /* If TEM is non-static, GDB won't understand it. */
1450 stabstr_S (",0,0;");
1455 stabstr_D (int_bit_position (tem));
1457 stabstr_D (tree_low_cst (DECL_SIZE (tem), 1));
1464 /* Subroutine of `dbxout_type_methods'. Output debug info about the
1465 method described DECL. */
1468 dbxout_type_method_1 (tree decl)
1472 if (TREE_CODE (TREE_TYPE (decl)) == FUNCTION_TYPE)
1474 else /* it's a METHOD_TYPE. */
1476 tree firstarg = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)));
1477 /* A for normal functions.
1478 B for `const' member functions.
1479 C for `volatile' member functions.
1480 D for `const volatile' member functions. */
1481 if (TYPE_READONLY (TREE_TYPE (firstarg)))
1483 if (TYPE_VOLATILE (TREE_TYPE (firstarg)))
1486 if (DECL_VINDEX (decl))
1492 /* ??? Output the mangled name, which contains an encoding of the
1493 method's type signature. May not be necessary anymore. */
1495 stabstr_I (DECL_ASSEMBLER_NAME (decl));
1497 stabstr_C (DECL_ACCESSIBILITY_CHAR (decl));
1501 if (DECL_VINDEX (decl) && host_integerp (DECL_VINDEX (decl), 0))
1503 stabstr_D (tree_low_cst (DECL_VINDEX (decl), 0));
1505 dbxout_type (DECL_CONTEXT (decl), 0);
1510 /* Subroutine of `dbxout_type'. Output debug info about the methods defined
1514 dbxout_type_methods (tree type)
1516 /* C++: put out the method names and their parameter lists */
1517 tree methods = TYPE_METHODS (type);
1521 if (methods == NULL_TREE)
1524 if (TREE_CODE (methods) != TREE_VEC)
1526 else if (TREE_VEC_ELT (methods, 0) != NULL_TREE)
1527 fndecl = TREE_VEC_ELT (methods, 0);
1529 fndecl = TREE_VEC_ELT (methods, 1);
1533 int need_prefix = 1;
1535 /* Group together all the methods for the same operation.
1536 These differ in the types of the arguments. */
1537 for (last = NULL_TREE;
1538 fndecl && (last == NULL_TREE || DECL_NAME (fndecl) == DECL_NAME (last));
1539 fndecl = TREE_CHAIN (fndecl))
1540 /* Output the name of the field (after overloading), as
1541 well as the name of the field before overloading, along
1542 with its parameter list */
1544 /* Skip methods that aren't FUNCTION_DECLs. (In C++, these
1545 include TEMPLATE_DECLs.) The debugger doesn't know what
1546 to do with such entities anyhow. */
1547 if (TREE_CODE (fndecl) != FUNCTION_DECL)
1554 /* Also ignore abstract methods; those are only interesting to
1555 the DWARF backends. */
1556 if (DECL_IGNORED_P (fndecl) || DECL_ABSTRACT (fndecl))
1559 /* Redundantly output the plain name, since that's what gdb
1563 stabstr_I (DECL_NAME (fndecl));
1568 dbxout_type (TREE_TYPE (fndecl), 0);
1569 dbxout_type_method_1 (fndecl);
1576 /* Emit a "range" type specification, which has the form:
1577 "r<index type>;<lower bound>;<upper bound>;".
1578 TYPE is an INTEGER_TYPE. */
1581 dbxout_range_type (tree type)
1584 if (TREE_TYPE (type))
1585 dbxout_type (TREE_TYPE (type), 0);
1586 else if (TREE_CODE (type) != INTEGER_TYPE)
1587 dbxout_type (type, 0); /* E.g. Pascal's ARRAY [BOOLEAN] of INTEGER */
1590 /* Traditionally, we made sure 'int' was type 1, and builtin types
1591 were defined to be sub-ranges of int. Unfortunately, this
1592 does not allow us to distinguish true sub-ranges from integer
1593 types. So, instead we define integer (non-sub-range) types as
1594 sub-ranges of themselves. This matters for Chill. If this isn't
1595 a subrange type, then we want to define it in terms of itself.
1596 However, in C, this may be an anonymous integer type, and we don't
1597 want to emit debug info referring to it. Just calling
1598 dbxout_type_index won't work anyways, because the type hasn't been
1599 defined yet. We make this work for both cases by checked to see
1600 whether this is a defined type, referring to it if it is, and using
1602 if (TYPE_SYMTAB_ADDRESS (type) != 0)
1603 dbxout_type_index (type);
1605 dbxout_type_index (integer_type_node);
1609 if (TYPE_MIN_VALUE (type) != 0
1610 && host_integerp (TYPE_MIN_VALUE (type), 0))
1612 if (print_int_cst_bounds_in_octal_p (type))
1613 stabstr_O (TYPE_MIN_VALUE (type));
1615 stabstr_D (tree_low_cst (TYPE_MIN_VALUE (type), 0));
1621 if (TYPE_MAX_VALUE (type) != 0
1622 && host_integerp (TYPE_MAX_VALUE (type), 0))
1624 if (print_int_cst_bounds_in_octal_p (type))
1625 stabstr_O (TYPE_MAX_VALUE (type));
1627 stabstr_D (tree_low_cst (TYPE_MAX_VALUE (type), 0));
1635 /* Output a reference to a type. If the type has not yet been
1636 described in the dbx output, output its definition now.
1637 For a type already defined, just refer to its definition
1638 using the type number.
1640 If FULL is nonzero, and the type has been described only with
1641 a forward-reference, output the definition now.
1642 If FULL is zero in this case, just refer to the forward-reference
1643 using the number previously allocated. */
1646 dbxout_type (tree type, int full)
1650 static int anonymous_type_number = 0;
1651 bool vector_type = false;
1653 if (TREE_CODE (type) == VECTOR_TYPE)
1655 /* The frontend feeds us a representation for the vector as a struct
1656 containing an array. Pull out the array type. */
1657 type = TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type)));
1661 /* If there was an input error and we don't really have a type,
1662 avoid crashing and write something that is at least valid
1663 by assuming `int'. */
1664 if (type == error_mark_node)
1665 type = integer_type_node;
1668 if (TYPE_NAME (type)
1669 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1670 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type)))
1674 /* Try to find the "main variant" with the same name. */
1675 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1676 && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
1677 main_variant = TREE_TYPE (TYPE_NAME (type));
1679 main_variant = TYPE_MAIN_VARIANT (type);
1681 /* If we are not using extensions, stabs does not distinguish const and
1682 volatile, so there is no need to make them separate types. */
1683 if (!use_gnu_debug_info_extensions)
1684 type = main_variant;
1686 if (TYPE_SYMTAB_ADDRESS (type) == 0)
1688 /* Type has no dbx number assigned. Assign next available number. */
1689 TYPE_SYMTAB_ADDRESS (type) = next_type_number++;
1691 /* Make sure type vector is long enough to record about this type. */
1693 if (next_type_number == typevec_len)
1696 = ggc_realloc (typevec, (typevec_len * 2 * sizeof typevec[0]));
1697 memset (typevec + typevec_len, 0, typevec_len * sizeof typevec[0]);
1701 #ifdef DBX_USE_BINCL
1702 emit_pending_bincls_if_required ();
1703 typevec[TYPE_SYMTAB_ADDRESS (type)].file_number
1704 = current_file->file_number;
1705 typevec[TYPE_SYMTAB_ADDRESS (type)].type_number
1706 = current_file->next_type_number++;
1710 if (flag_debug_only_used_symbols)
1712 if ((TREE_CODE (type) == RECORD_TYPE
1713 || TREE_CODE (type) == UNION_TYPE
1714 || TREE_CODE (type) == QUAL_UNION_TYPE
1715 || TREE_CODE (type) == ENUMERAL_TYPE)
1716 && TYPE_STUB_DECL (type)
1717 && DECL_P (TYPE_STUB_DECL (type))
1718 && ! DECL_IGNORED_P (TYPE_STUB_DECL (type)))
1719 debug_queue_symbol (TYPE_STUB_DECL (type));
1720 else if (TYPE_NAME (type)
1721 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
1722 debug_queue_symbol (TYPE_NAME (type));
1725 /* Output the number of this type, to refer to it. */
1726 dbxout_type_index (type);
1728 #ifdef DBX_TYPE_DEFINED
1729 if (DBX_TYPE_DEFINED (type))
1733 /* If this type's definition has been output or is now being output,
1736 switch (typevec[TYPE_SYMTAB_ADDRESS (type)].status)
1741 /* If we have already had a cross reference,
1742 and either that's all we want or that's the best we could do,
1743 don't repeat the cross reference.
1744 Sun dbx crashes if we do. */
1745 if (! full || !COMPLETE_TYPE_P (type)
1746 /* No way in DBX fmt to describe a variable size. */
1747 || ! host_integerp (TYPE_SIZE (type), 1))
1755 /* For systems where dbx output does not allow the `=xsNAME:' syntax,
1756 leave the type-number completely undefined rather than output
1757 a cross-reference. If we have already used GNU debug info extensions,
1758 then it is OK to output a cross reference. This is necessary to get
1759 proper C++ debug output. */
1760 if ((TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE
1761 || TREE_CODE (type) == QUAL_UNION_TYPE
1762 || TREE_CODE (type) == ENUMERAL_TYPE)
1763 && ! use_gnu_debug_info_extensions)
1764 /* We must use the same test here as we use twice below when deciding
1765 whether to emit a cross-reference. */
1766 if ((TYPE_NAME (type) != 0
1767 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1768 && DECL_IGNORED_P (TYPE_NAME (type)))
1770 || !COMPLETE_TYPE_P (type)
1771 /* No way in DBX fmt to describe a variable size. */
1772 || ! host_integerp (TYPE_SIZE (type), 1))
1774 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
1779 /* Output a definition now. */
1782 /* Mark it as defined, so that if it is self-referent
1783 we will not get into an infinite recursion of definitions. */
1785 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_DEFINED;
1787 /* If this type is a variant of some other, hand off. Types with
1788 different names are usefully distinguished. We only distinguish
1789 cv-qualified types if we're using extensions. */
1790 if (TYPE_READONLY (type) > TYPE_READONLY (main_variant))
1793 dbxout_type (build_type_variant (type, 0, TYPE_VOLATILE (type)), 0);
1796 else if (TYPE_VOLATILE (type) > TYPE_VOLATILE (main_variant))
1799 dbxout_type (build_type_variant (type, TYPE_READONLY (type), 0), 0);
1802 else if (main_variant != TYPE_MAIN_VARIANT (type))
1804 if (flag_debug_only_used_symbols)
1806 tree orig_type = DECL_ORIGINAL_TYPE (TYPE_NAME (type));
1808 if ((TREE_CODE (orig_type) == RECORD_TYPE
1809 || TREE_CODE (orig_type) == UNION_TYPE
1810 || TREE_CODE (orig_type) == QUAL_UNION_TYPE
1811 || TREE_CODE (orig_type) == ENUMERAL_TYPE)
1812 && TYPE_STUB_DECL (orig_type)
1813 && ! DECL_IGNORED_P (TYPE_STUB_DECL (orig_type)))
1814 debug_queue_symbol (TYPE_STUB_DECL (orig_type));
1816 /* 'type' is a typedef; output the type it refers to. */
1817 dbxout_type (DECL_ORIGINAL_TYPE (TYPE_NAME (type)), 0);
1820 /* else continue. */
1822 switch (TREE_CODE (type))
1826 /* For a void type, just define it as itself; i.e., "5=5".
1827 This makes us consider it defined
1828 without saying what it is. The debugger will make it
1829 a void type when the reference is seen, and nothing will
1830 ever override that default. */
1831 dbxout_type_index (type);
1835 if (type == char_type_node && ! TYPE_UNSIGNED (type))
1837 /* Output the type `char' as a subrange of itself!
1838 I don't understand this definition, just copied it
1839 from the output of pcc.
1840 This used to use `r2' explicitly and we used to
1841 take care to make sure that `char' was type number 2. */
1843 dbxout_type_index (type);
1844 stabstr_S (";0;127;");
1847 /* If this is a subtype of another integer type, always prefer to
1848 write it as a subtype. */
1849 else if (TREE_TYPE (type) != 0
1850 && TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE)
1852 /* If the size is non-standard, say what it is if we can use
1855 if (use_gnu_debug_info_extensions
1856 && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
1859 stabstr_D (TYPE_PRECISION (type));
1863 dbxout_range_type (type);
1868 /* If the size is non-standard, say what it is if we can use
1871 if (use_gnu_debug_info_extensions
1872 && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
1875 stabstr_D (TYPE_PRECISION (type));
1879 if (print_int_cst_bounds_in_octal_p (type))
1883 /* If this type derives from another type, output type index of
1884 parent type. This is particularly important when parent type
1885 is an enumerated type, because not generating the parent type
1886 index would transform the definition of this enumerated type
1887 into a plain unsigned type. */
1888 if (TREE_TYPE (type) != 0)
1889 dbxout_type_index (TREE_TYPE (type));
1891 dbxout_type_index (type);
1894 stabstr_O (TYPE_MIN_VALUE (type));
1896 stabstr_O (TYPE_MAX_VALUE (type));
1901 /* Output other integer types as subranges of `int'. */
1902 dbxout_range_type (type);
1908 /* This used to say `r1' and we used to take care
1909 to make sure that `int' was type number 1. */
1911 dbxout_type_index (integer_type_node);
1913 stabstr_D (int_size_in_bytes (type));
1918 if (use_gnu_debug_info_extensions)
1921 stabstr_D (BITS_PER_UNIT * int_size_in_bytes (type));
1922 stabstr_S (";-16;");
1924 else /* Define as enumeral type (False, True) */
1925 stabstr_S ("eFalse:0,True:1,;");
1929 /* Differs from the REAL_TYPE by its new data type number.
1930 R3 is NF_COMPLEX. We don't try to use any of the other NF_*
1931 codes since gdb doesn't care anyway. */
1933 if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
1936 stabstr_D (2 * int_size_in_bytes (TREE_TYPE (type)));
1941 /* Output a complex integer type as a structure,
1942 pending some other way to do it. */
1944 stabstr_D (int_size_in_bytes (type));
1946 stabstr_S ("real:");
1947 dbxout_type (TREE_TYPE (type), 0);
1949 stabstr_D (TYPE_PRECISION (TREE_TYPE (type)));
1951 stabstr_S (";imag:");
1952 dbxout_type (TREE_TYPE (type), 0);
1954 stabstr_D (TYPE_PRECISION (TREE_TYPE (type)));
1956 stabstr_D (TYPE_PRECISION (TREE_TYPE (type)));
1962 /* Make arrays of packed bits look like bitstrings for chill. */
1963 if (TYPE_PACKED (type) && use_gnu_debug_info_extensions)
1966 stabstr_D (BITS_PER_UNIT * int_size_in_bytes (type));
1967 stabstr_S (";@S;S");
1968 dbxout_type (TYPE_DOMAIN (type), 0);
1972 if (use_gnu_debug_info_extensions && vector_type)
1975 /* Output "a" followed by a range type definition
1976 for the index type of the array
1977 followed by a reference to the target-type.
1978 ar1;0;N;M for a C array of type M and size N+1. */
1979 /* Check if a character string type, which in Chill is
1980 different from an array of characters. */
1981 if (TYPE_STRING_FLAG (type) && use_gnu_debug_info_extensions)
1985 tem = TYPE_DOMAIN (type);
1989 dbxout_type_index (integer_type_node);
1990 stabstr_S (";0;-1;");
1995 dbxout_range_type (tem);
1998 dbxout_type (TREE_TYPE (type), 0);
2003 case QUAL_UNION_TYPE:
2005 tree binfo = TYPE_BINFO (type);
2007 /* Output a structure type. We must use the same test here as we
2008 use in the DBX_NO_XREFS case above. */
2009 if ((TYPE_NAME (type) != 0
2010 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
2011 && DECL_IGNORED_P (TYPE_NAME (type)))
2013 || !COMPLETE_TYPE_P (type)
2014 /* No way in DBX fmt to describe a variable size. */
2015 || ! host_integerp (TYPE_SIZE (type), 1))
2017 /* If the type is just a cross reference, output one
2018 and mark the type as partially described.
2019 If it later becomes defined, we will output
2020 its real definition.
2021 If the type has a name, don't nest its definition within
2022 another type's definition; instead, output an xref
2023 and let the definition come when the name is defined. */
2024 stabstr_S ((TREE_CODE (type) == RECORD_TYPE) ? "xs" : "xu");
2025 if (TYPE_NAME (type) != 0)
2026 dbxout_type_name (type);
2030 stabstr_D (anonymous_type_number++);
2034 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
2038 /* Identify record or union, and print its size. */
2039 stabstr_C ((TREE_CODE (type) == RECORD_TYPE) ? 's' : 'u');
2040 stabstr_D (int_size_in_bytes (type));
2046 VEC(tree,gc) *accesses = BINFO_BASE_ACCESSES (binfo);
2048 if (use_gnu_debug_info_extensions)
2050 if (BINFO_N_BASE_BINFOS (binfo))
2053 stabstr_U (BINFO_N_BASE_BINFOS (binfo));
2057 for (i = 0; BINFO_BASE_ITERATE (binfo, i, child); i++)
2059 tree access = (accesses ? VEC_index (tree, accesses, i)
2060 : access_public_node);
2062 if (use_gnu_debug_info_extensions)
2064 stabstr_C (BINFO_VIRTUAL_P (child) ? '1' : '0');
2065 stabstr_C (access == access_public_node ? '2' :
2066 access == access_protected_node
2068 if (BINFO_VIRTUAL_P (child)
2069 && (strcmp (lang_hooks.name, "GNU C++") == 0
2070 || strcmp (lang_hooks.name, "GNU Objective-C++") == 0))
2071 /* For a virtual base, print the (negative)
2072 offset within the vtable where we must look
2073 to find the necessary adjustment. */
2075 (tree_low_cst (BINFO_VPTR_FIELD (child), 0)
2078 stabstr_D (tree_low_cst (BINFO_OFFSET (child), 0)
2081 dbxout_type (BINFO_TYPE (child), 0);
2086 /* Print out the base class information with
2087 fields which have the same names at the types
2089 dbxout_type_name (BINFO_TYPE (child));
2091 dbxout_type (BINFO_TYPE (child), full);
2093 stabstr_D (tree_low_cst (BINFO_OFFSET (child), 0)
2097 (tree_low_cst (TYPE_SIZE (BINFO_TYPE (child)), 0)
2105 /* Write out the field declarations. */
2106 dbxout_type_fields (type);
2107 if (use_gnu_debug_info_extensions && TYPE_METHODS (type) != NULL_TREE)
2109 dbxout_type_methods (type);
2114 if (use_gnu_debug_info_extensions && TREE_CODE (type) == RECORD_TYPE
2115 /* Avoid the ~ if we don't really need it--it confuses dbx. */
2116 && TYPE_VFIELD (type))
2119 /* We need to write out info about what field this class
2120 uses as its "main" vtable pointer field, because if this
2121 field is inherited from a base class, GDB cannot necessarily
2122 figure out which field it's using in time. */
2124 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type)), 0);
2130 /* We must use the same test here as we use in the DBX_NO_XREFS case
2131 above. We simplify it a bit since an enum will never have a variable
2133 if ((TYPE_NAME (type) != 0
2134 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
2135 && DECL_IGNORED_P (TYPE_NAME (type)))
2137 || !COMPLETE_TYPE_P (type))
2140 dbxout_type_name (type);
2141 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
2145 if (use_gnu_debug_info_extensions
2146 && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
2149 stabstr_D (TYPE_PRECISION (type));
2154 for (tem = TYPE_VALUES (type); tem; tem = TREE_CHAIN (tem))
2156 stabstr_I (TREE_PURPOSE (tem));
2159 if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == 0)
2160 stabstr_D (TREE_INT_CST_LOW (TREE_VALUE (tem)));
2161 else if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == -1
2162 && (HOST_WIDE_INT) TREE_INT_CST_LOW (TREE_VALUE (tem)) < 0)
2163 stabstr_D (TREE_INT_CST_LOW (TREE_VALUE (tem)));
2165 stabstr_O (TREE_VALUE (tem));
2168 if (TREE_CHAIN (tem) != 0)
2177 dbxout_type (TREE_TYPE (type), 0);
2181 if (use_gnu_debug_info_extensions)
2185 /* Write the argument types out longhand. */
2186 dbxout_type (TYPE_METHOD_BASETYPE (type), 0);
2188 dbxout_type (TREE_TYPE (type), 0);
2189 dbxout_args (TYPE_ARG_TYPES (type));
2193 /* Treat it as a function type. */
2194 dbxout_type (TREE_TYPE (type), 0);
2198 if (use_gnu_debug_info_extensions)
2201 dbxout_type (TYPE_OFFSET_BASETYPE (type), 0);
2203 dbxout_type (TREE_TYPE (type), 0);
2206 /* Should print as an int, because it is really just an offset. */
2207 dbxout_type (integer_type_node, 0);
2210 case REFERENCE_TYPE:
2211 if (use_gnu_debug_info_extensions)
2217 dbxout_type (TREE_TYPE (type), 0);
2222 dbxout_type (TREE_TYPE (type), 0);
2230 /* Return nonzero if the given type represents an integer whose bounds
2231 should be printed in octal format. */
2234 print_int_cst_bounds_in_octal_p (tree type)
2236 /* If we can use GDB extensions and the size is wider than a long
2237 (the size used by GDB to read them) or we may have trouble writing
2238 the bounds the usual way, write them in octal. Note the test is for
2239 the *target's* size of "long", not that of the host. The host test
2240 is just to make sure we can write it out in case the host wide int
2241 is narrower than the target "long".
2243 For unsigned types, we use octal if they are the same size or larger.
2244 This is because we print the bounds as signed decimal, and hence they
2245 can't span same size unsigned types. */
2247 if (use_gnu_debug_info_extensions
2248 && TYPE_MIN_VALUE (type) != 0
2249 && TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST
2250 && TYPE_MAX_VALUE (type) != 0
2251 && TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST
2252 && (TYPE_PRECISION (type) > TYPE_PRECISION (integer_type_node)
2253 || ((TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
2254 && TYPE_UNSIGNED (type))
2255 || TYPE_PRECISION (type) > HOST_BITS_PER_WIDE_INT
2256 || (TYPE_PRECISION (type) == HOST_BITS_PER_WIDE_INT
2257 && TYPE_UNSIGNED (type))))
2263 /* Output the name of type TYPE, with no punctuation.
2264 Such names can be set up either by typedef declarations
2265 or by struct, enum and union tags. */
2268 dbxout_type_name (tree type)
2270 tree t = TYPE_NAME (type);
2273 switch (TREE_CODE (t))
2275 case IDENTIFIER_NODE:
2287 /* Output leading leading struct or class names needed for qualifying
2288 type whose scope is limited to a struct or class. */
2291 dbxout_class_name_qualifiers (tree decl)
2293 tree context = decl_type_context (decl);
2295 if (context != NULL_TREE
2296 && TREE_CODE(context) == RECORD_TYPE
2297 && TYPE_NAME (context) != 0
2298 && (TREE_CODE (TYPE_NAME (context)) == IDENTIFIER_NODE
2299 || (DECL_NAME (TYPE_NAME (context)) != 0)))
2301 tree name = TYPE_NAME (context);
2303 if (TREE_CODE (name) == TYPE_DECL)
2305 dbxout_class_name_qualifiers (name);
2306 name = DECL_NAME (name);
2313 /* This is a specialized subset of expand_expr for use by dbxout_symbol in
2314 evaluating DECL_VALUE_EXPR. In particular, we stop if we find decls that
2315 havn't been expanded, or if the expression is getting so complex we won't
2316 be able to represent it in stabs anyway. Returns NULL on failure. */
2319 dbxout_expand_expr (tree expr)
2321 switch (TREE_CODE (expr))
2325 if (DECL_HAS_VALUE_EXPR_P (expr))
2326 return dbxout_expand_expr (DECL_VALUE_EXPR (expr));
2331 return DECL_RTL_IF_SET (expr);
2334 return expand_expr (expr, NULL_RTX, VOIDmode, EXPAND_INITIALIZER);
2338 case ARRAY_RANGE_REF:
2341 enum machine_mode mode;
2342 HOST_WIDE_INT bitsize, bitpos;
2344 int volatilep = 0, unsignedp = 0;
2347 tem = get_inner_reference (expr, &bitsize, &bitpos, &offset,
2348 &mode, &unsignedp, &volatilep, true);
2350 x = dbxout_expand_expr (tem);
2351 if (x == NULL || !MEM_P (x))
2355 if (!host_integerp (offset, 0))
2357 x = adjust_address_nv (x, mode, tree_low_cst (offset, 0));
2360 x = adjust_address_nv (x, mode, bitpos / BITS_PER_UNIT);
2370 /* Output a .stabs for the symbol defined by DECL,
2371 which must be a ..._DECL node in the normal namespace.
2372 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
2373 LOCAL is nonzero if the scope is less than the entire file.
2374 Return 1 if a stabs might have been emitted. */
2377 dbxout_symbol (tree decl, int local ATTRIBUTE_UNUSED)
2379 tree type = TREE_TYPE (decl);
2380 tree context = NULL_TREE;
2384 /* "Intercept" dbxout_symbol() calls like we do all debug_hooks. */
2387 /* Ignore nameless syms, but don't ignore type tags. */
2389 if ((DECL_NAME (decl) == 0 && TREE_CODE (decl) != TYPE_DECL)
2390 || DECL_IGNORED_P (decl))
2391 DBXOUT_DECR_NESTING_AND_RETURN (0);
2393 /* If we are to generate only the symbols actually used then such
2394 symbol nodes are flagged with TREE_USED. Ignore any that
2395 aren't flaged as TREE_USED. */
2397 if (flag_debug_only_used_symbols
2398 && (!TREE_USED (decl)
2399 && (TREE_CODE (decl) != VAR_DECL || !DECL_INITIAL (decl))))
2400 DBXOUT_DECR_NESTING_AND_RETURN (0);
2402 /* If dbxout_init has not yet run, queue this symbol for later. */
2405 preinit_symbols = tree_cons (0, decl, preinit_symbols);
2406 DBXOUT_DECR_NESTING_AND_RETURN (0);
2409 if (flag_debug_only_used_symbols)
2413 /* We now have a used symbol. We need to generate the info for
2414 the symbol's type in addition to the symbol itself. These
2415 type symbols are queued to be generated after were done with
2416 the symbol itself (otherwise they would fight over the
2419 Note, because the TREE_TYPE(type) might be something like a
2420 pointer to a named type we need to look for the first name
2421 we see following the TREE_TYPE chain. */
2424 while (POINTER_TYPE_P (t))
2427 /* RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, and ENUMERAL_TYPE
2428 need special treatment. The TYPE_STUB_DECL field in these
2429 types generally represents the tag name type we want to
2430 output. In addition there could be a typedef type with
2431 a different name. In that case we also want to output
2434 if (TREE_CODE (t) == RECORD_TYPE
2435 || TREE_CODE (t) == UNION_TYPE
2436 || TREE_CODE (t) == QUAL_UNION_TYPE
2437 || TREE_CODE (t) == ENUMERAL_TYPE)
2439 if (TYPE_STUB_DECL (t)
2440 && TYPE_STUB_DECL (t) != decl
2441 && DECL_P (TYPE_STUB_DECL (t))
2442 && ! DECL_IGNORED_P (TYPE_STUB_DECL (t)))
2444 debug_queue_symbol (TYPE_STUB_DECL (t));
2446 && TYPE_NAME (t) != TYPE_STUB_DECL (t)
2447 && TYPE_NAME (t) != decl
2448 && DECL_P (TYPE_NAME (t)))
2449 debug_queue_symbol (TYPE_NAME (t));
2452 else if (TYPE_NAME (t)
2453 && TYPE_NAME (t) != decl
2454 && DECL_P (TYPE_NAME (t)))
2455 debug_queue_symbol (TYPE_NAME (t));
2458 emit_pending_bincls_if_required ();
2460 switch (TREE_CODE (decl))
2463 /* Enum values are defined by defining the enum type. */
2467 decl_rtl = DECL_RTL_IF_SET (decl);
2469 DBXOUT_DECR_NESTING_AND_RETURN (0);
2470 if (DECL_EXTERNAL (decl))
2472 /* Don't mention a nested function under its parent. */
2473 context = decl_function_context (decl);
2474 if (context == current_function_decl)
2476 /* Don't mention an inline instance of a nested function. */
2477 if (context && DECL_FROM_INLINE (decl))
2479 if (!MEM_P (decl_rtl)
2480 || GET_CODE (XEXP (decl_rtl, 0)) != SYMBOL_REF)
2483 dbxout_begin_complex_stabs ();
2484 stabstr_I (DECL_ASSEMBLER_NAME (decl));
2485 stabstr_S (TREE_PUBLIC (decl) ? ":F" : ":f");
2488 if (TREE_TYPE (type))
2489 dbxout_type (TREE_TYPE (type), 0);
2491 dbxout_type (void_type_node, 0);
2493 /* For a nested function, when that function is compiled,
2494 mention the containing function name
2495 as well as (since dbx wants it) our own assembler-name. */
2499 stabstr_I (DECL_ASSEMBLER_NAME (decl));
2501 stabstr_I (DECL_NAME (context));
2504 dbxout_finish_complex_stabs (decl, N_FUN, XEXP (decl_rtl, 0), 0, 0);
2508 /* Don't output the same typedef twice.
2509 And don't output what language-specific stuff doesn't want output. */
2510 if (TREE_ASM_WRITTEN (decl) || TYPE_DECL_SUPPRESS_DEBUG (decl))
2511 DBXOUT_DECR_NESTING_AND_RETURN (0);
2513 /* Don't output typedefs for types with magic type numbers (XCOFF). */
2514 #ifdef DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER
2516 int fundamental_type_number =
2517 DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER (decl);
2519 if (fundamental_type_number != 0)
2521 TREE_ASM_WRITTEN (decl) = 1;
2522 TYPE_SYMTAB_ADDRESS (TREE_TYPE (decl)) = fundamental_type_number;
2523 DBXOUT_DECR_NESTING_AND_RETURN (0);
2533 if (DECL_NAME (decl))
2535 /* Nonzero means we must output a tag as well as a typedef. */
2538 /* Handle the case of a C++ structure or union
2539 where the TYPE_NAME is a TYPE_DECL
2540 which gives both a typedef name and a tag. */
2541 /* dbx requires the tag first and the typedef second. */
2542 if ((TREE_CODE (type) == RECORD_TYPE
2543 || TREE_CODE (type) == UNION_TYPE
2544 || TREE_CODE (type) == QUAL_UNION_TYPE)
2545 && TYPE_NAME (type) == decl
2546 && !use_gnu_debug_info_extensions
2547 && !TREE_ASM_WRITTEN (TYPE_NAME (type))
2548 /* Distinguish the implicit typedefs of C++
2549 from explicit ones that might be found in C. */
2550 && DECL_ARTIFICIAL (decl)
2551 /* Do not generate a tag for incomplete records. */
2552 && COMPLETE_TYPE_P (type)
2553 /* Do not generate a tag for records of variable size,
2554 since this type can not be properly described in the
2555 DBX format, and it confuses some tools such as objdump. */
2556 && host_integerp (TYPE_SIZE (type), 1))
2558 tree name = TYPE_NAME (type);
2559 if (TREE_CODE (name) == TYPE_DECL)
2560 name = DECL_NAME (name);
2562 dbxout_begin_complex_stabs ();
2565 dbxout_type (type, 1);
2566 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE,
2570 dbxout_begin_complex_stabs ();
2572 /* Output leading class/struct qualifiers. */
2573 if (use_gnu_debug_info_extensions)
2574 dbxout_class_name_qualifiers (decl);
2576 /* Output typedef name. */
2577 stabstr_I (DECL_NAME (decl));
2580 /* Short cut way to output a tag also. */
2581 if ((TREE_CODE (type) == RECORD_TYPE
2582 || TREE_CODE (type) == UNION_TYPE
2583 || TREE_CODE (type) == QUAL_UNION_TYPE)
2584 && TYPE_NAME (type) == decl
2585 /* Distinguish the implicit typedefs of C++
2586 from explicit ones that might be found in C. */
2587 && DECL_ARTIFICIAL (decl))
2589 if (use_gnu_debug_info_extensions)
2592 TREE_ASM_WRITTEN (TYPE_NAME (type)) = 1;
2597 dbxout_type (type, 1);
2598 dbxout_finish_complex_stabs (decl, DBX_TYPE_DECL_STABS_CODE,
2603 /* Don't output a tag if this is an incomplete type. This prevents
2604 the sun4 Sun OS 4.x dbx from crashing. */
2606 if (tag_needed && TYPE_NAME (type) != 0
2607 && (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE
2608 || (DECL_NAME (TYPE_NAME (type)) != 0))
2609 && COMPLETE_TYPE_P (type)
2610 && !TREE_ASM_WRITTEN (TYPE_NAME (type)))
2612 /* For a TYPE_DECL with no name, but the type has a name,
2614 This is what represents `struct foo' with no typedef. */
2615 /* In C++, the name of a type is the corresponding typedef.
2616 In C, it is an IDENTIFIER_NODE. */
2617 tree name = TYPE_NAME (type);
2618 if (TREE_CODE (name) == TYPE_DECL)
2619 name = DECL_NAME (name);
2621 dbxout_begin_complex_stabs ();
2624 dbxout_type (type, 1);
2625 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE, 0, 0, 0);
2629 /* If an enum type has no name, it cannot be referred to, but
2630 we must output it anyway, to record the enumeration
2633 if (!did_output && TREE_CODE (type) == ENUMERAL_TYPE)
2635 dbxout_begin_complex_stabs ();
2636 /* Some debuggers fail when given NULL names, so give this a
2637 harmless name of " " (Why not "(anon)"?). */
2639 dbxout_type (type, 1);
2640 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE, 0, 0, 0);
2643 /* Prevent duplicate output of a typedef. */
2644 TREE_ASM_WRITTEN (decl) = 1;
2649 /* Parm decls go in their own separate chains
2650 and are output by dbxout_reg_parms and dbxout_parms. */
2655 /* Don't mention a variable that is external.
2656 Let the file that defines it describe it. */
2657 if (DECL_EXTERNAL (decl))
2660 /* If the variable is really a constant
2661 and not written in memory, inform the debugger.
2663 ??? Why do we skip emitting the type and location in this case? */
2664 if (TREE_STATIC (decl) && TREE_READONLY (decl)
2665 && DECL_INITIAL (decl) != 0
2666 && host_integerp (DECL_INITIAL (decl), 0)
2667 && ! TREE_ASM_WRITTEN (decl)
2668 && (DECL_CONTEXT (decl) == NULL_TREE
2669 || TREE_CODE (DECL_CONTEXT (decl)) == BLOCK
2670 || TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL)
2671 && TREE_PUBLIC (decl) == 0)
2673 /* The sun4 assembler does not grok this. */
2675 if (TREE_CODE (TREE_TYPE (decl)) == INTEGER_TYPE
2676 || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
2678 HOST_WIDE_INT ival = TREE_INT_CST_LOW (DECL_INITIAL (decl));
2680 dbxout_begin_complex_stabs ();
2681 dbxout_symbol_name (decl, NULL, 'c');
2684 dbxout_finish_complex_stabs (0, N_LSYM, 0, 0, 0);
2685 DBXOUT_DECR_NESTING;
2691 /* else it is something we handle like a normal variable. */
2693 decl_rtl = dbxout_expand_expr (decl);
2695 DBXOUT_DECR_NESTING_AND_RETURN (0);
2697 decl_rtl = eliminate_regs (decl_rtl, 0, NULL_RTX);
2698 #ifdef LEAF_REG_REMAP
2699 if (current_function_uses_only_leaf_regs)
2700 leaf_renumber_regs_insn (decl_rtl);
2703 result = dbxout_symbol_location (decl, type, 0, decl_rtl);
2709 DBXOUT_DECR_NESTING;
2713 /* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL.
2714 Add SUFFIX to its name, if SUFFIX is not 0.
2715 Describe the variable as residing in HOME
2716 (usually HOME is DECL_RTL (DECL), but not always).
2717 Returns 1 if the stab was really emitted. */
2720 dbxout_symbol_location (tree decl, tree type, const char *suffix, rtx home)
2723 STAB_CODE_TYPE code;
2728 /* Don't mention a variable at all
2729 if it was completely optimized into nothingness.
2731 If the decl was from an inline function, then its rtl
2732 is not identically the rtl that was used in this
2733 particular compilation. */
2734 if (GET_CODE (home) == SUBREG)
2738 while (GET_CODE (value) == SUBREG)
2739 value = SUBREG_REG (value);
2742 if (REGNO (value) >= FIRST_PSEUDO_REGISTER)
2745 home = alter_subreg (&home);
2749 regno = REGNO (home);
2750 if (regno >= FIRST_PSEUDO_REGISTER)
2754 /* The kind-of-variable letter depends on where
2755 the variable is and on the scope of its name:
2756 G and N_GSYM for static storage and global scope,
2757 S for static storage and file scope,
2758 V for static storage and local scope,
2759 for those two, use N_LCSYM if data is in bss segment,
2760 N_STSYM if in data segment, N_FUN otherwise.
2761 (We used N_FUN originally, then changed to N_STSYM
2762 to please GDB. However, it seems that confused ld.
2763 Now GDB has been fixed to like N_FUN, says Kingdon.)
2764 no letter at all, and N_LSYM, for auto variable,
2765 r and N_RSYM for register variable. */
2767 if (MEM_P (home) && GET_CODE (XEXP (home, 0)) == SYMBOL_REF)
2769 if (TREE_PUBLIC (decl))
2776 addr = XEXP (home, 0);
2778 letter = decl_function_context (decl) ? 'V' : 'S';
2780 /* Some ports can transform a symbol ref into a label ref,
2781 because the symbol ref is too far away and has to be
2782 dumped into a constant pool. Alternatively, the symbol
2783 in the constant pool might be referenced by a different
2785 if (GET_CODE (addr) == SYMBOL_REF
2786 && CONSTANT_POOL_ADDRESS_P (addr))
2789 rtx tmp = get_pool_constant_mark (addr, &marked);
2791 if (GET_CODE (tmp) == SYMBOL_REF)
2794 if (CONSTANT_POOL_ADDRESS_P (addr))
2795 get_pool_constant_mark (addr, &marked);
2799 else if (GET_CODE (tmp) == LABEL_REF)
2805 /* If all references to the constant pool were optimized
2806 out, we just ignore the symbol. */
2811 /* This should be the same condition as in assemble_variable, but
2812 we don't have access to dont_output_data here. So, instead,
2813 we rely on the fact that error_mark_node initializers always
2814 end up in bss for C++ and never end up in bss for C. */
2815 if (DECL_INITIAL (decl) == 0
2816 || (!strcmp (lang_hooks.name, "GNU C++")
2817 && DECL_INITIAL (decl) == error_mark_node))
2819 else if (DECL_IN_TEXT_SECTION (decl))
2820 /* This is not quite right, but it's the closest
2821 of all the codes that Unix defines. */
2822 code = DBX_STATIC_CONST_VAR_CODE;
2825 /* Ultrix `as' seems to need this. */
2826 #ifdef DBX_STATIC_STAB_DATA_SECTION
2827 switch_to_section (data_section);
2833 else if (regno >= 0)
2837 number = DBX_REGISTER_NUMBER (regno);
2839 else if (MEM_P (home)
2840 && (MEM_P (XEXP (home, 0))
2841 || (REG_P (XEXP (home, 0))
2842 && REGNO (XEXP (home, 0)) != HARD_FRAME_POINTER_REGNUM
2843 && REGNO (XEXP (home, 0)) != STACK_POINTER_REGNUM
2844 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2845 && REGNO (XEXP (home, 0)) != ARG_POINTER_REGNUM
2848 /* If the value is indirect by memory or by a register
2849 that isn't the frame pointer
2850 then it means the object is variable-sized and address through
2851 that register or stack slot. DBX has no way to represent this
2852 so all we can do is output the variable as a pointer.
2853 If it's not a parameter, ignore it. */
2855 if (REG_P (XEXP (home, 0)))
2859 if (REGNO (XEXP (home, 0)) >= FIRST_PSEUDO_REGISTER)
2861 number = DBX_REGISTER_NUMBER (REGNO (XEXP (home, 0)));
2866 /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
2867 We want the value of that CONST_INT. */
2868 number = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home, 0), 0));
2871 /* Effectively do build_pointer_type, but don't cache this type,
2872 since it might be temporary whereas the type it points to
2873 might have been saved for inlining. */
2874 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
2875 type = make_node (POINTER_TYPE);
2876 TREE_TYPE (type) = TREE_TYPE (decl);
2878 else if (MEM_P (home)
2879 && REG_P (XEXP (home, 0)))
2882 number = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
2884 else if (MEM_P (home)
2885 && GET_CODE (XEXP (home, 0)) == PLUS
2886 && GET_CODE (XEXP (XEXP (home, 0), 1)) == CONST_INT)
2889 /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
2890 We want the value of that CONST_INT. */
2891 number = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
2893 else if (MEM_P (home)
2894 && GET_CODE (XEXP (home, 0)) == CONST)
2896 /* Handle an obscure case which can arise when optimizing and
2897 when there are few available registers. (This is *always*
2898 the case for i386/i486 targets). The RTL looks like
2899 (MEM (CONST ...)) even though this variable is a local `auto'
2900 or a local `register' variable. In effect, what has happened
2901 is that the reload pass has seen that all assignments and
2902 references for one such a local variable can be replaced by
2903 equivalent assignments and references to some static storage
2904 variable, thereby avoiding the need for a register. In such
2905 cases we're forced to lie to debuggers and tell them that
2906 this variable was itself `static'. */
2909 addr = XEXP (XEXP (home, 0), 0);
2911 else if (GET_CODE (home) == CONCAT)
2915 /* If TYPE is not a COMPLEX_TYPE (it might be a RECORD_TYPE,
2916 for example), then there is no easy way to figure out
2917 what SUBTYPE should be. So, we give up. */
2918 if (TREE_CODE (type) != COMPLEX_TYPE)
2921 subtype = TREE_TYPE (type);
2923 /* If the variable's storage is in two parts,
2924 output each as a separate stab with a modified name. */
2925 if (WORDS_BIG_ENDIAN)
2926 dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 0));
2928 dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 0));
2930 if (WORDS_BIG_ENDIAN)
2931 dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 1));
2933 dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 1));
2937 /* Address might be a MEM, when DECL is a variable-sized object.
2938 Or it might be const0_rtx, meaning previous passes
2939 want us to ignore this variable. */
2942 /* Ok, start a symtab entry and output the variable name. */
2943 emit_pending_bincls_if_required ();
2946 #ifdef DBX_STATIC_BLOCK_START
2947 DBX_STATIC_BLOCK_START (asm_out_file, code);
2950 dbxout_begin_complex_stabs_noforcetext ();
2951 dbxout_symbol_name (decl, suffix, letter);
2952 dbxout_type (type, 0);
2953 dbxout_finish_complex_stabs (decl, code, addr, 0, number);
2955 #ifdef DBX_STATIC_BLOCK_END
2956 DBX_STATIC_BLOCK_END (asm_out_file, code);
2961 /* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
2962 Then output LETTER to indicate the kind of location the symbol has. */
2965 dbxout_symbol_name (tree decl, const char *suffix, int letter)
2969 if (DECL_CONTEXT (decl)
2970 && (TYPE_P (DECL_CONTEXT (decl))
2971 || TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL))
2972 /* One slight hitch: if this is a VAR_DECL which is a class member
2973 or a namespace member, we must put out the mangled name instead of the
2974 DECL_NAME. Note also that static member (variable) names DO NOT begin
2975 with underscores in .stabs directives. */
2976 name = DECL_ASSEMBLER_NAME (decl);
2978 /* ...but if we're function-local, we don't want to include the junk
2979 added by ASM_FORMAT_PRIVATE_NAME. */
2980 name = DECL_NAME (decl);
2985 stabstr_S ("(anon)");
2994 /* Output definitions of all the decls in a chain. Return nonzero if
2995 anything was output */
2998 dbxout_syms (tree syms)
3003 result += dbxout_symbol (syms, 1);
3004 syms = TREE_CHAIN (syms);
3009 /* The following two functions output definitions of function parameters.
3010 Each parameter gets a definition locating it in the parameter list.
3011 Each parameter that is a register variable gets a second definition
3012 locating it in the register.
3014 Printing or argument lists in gdb uses the definitions that
3015 locate in the parameter list. But reference to the variable in
3016 expressions uses preferentially the definition as a register. */
3018 /* Output definitions, referring to storage in the parmlist,
3019 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
3022 dbxout_parms (tree parms)
3025 emit_pending_bincls_if_required ();
3027 for (; parms; parms = TREE_CHAIN (parms))
3028 if (DECL_NAME (parms)
3029 && TREE_TYPE (parms) != error_mark_node
3030 && DECL_RTL_SET_P (parms)
3031 && DECL_INCOMING_RTL (parms))
3035 STAB_CODE_TYPE code;
3038 /* Perform any necessary register eliminations on the parameter's rtl,
3039 so that the debugging output will be accurate. */
3040 DECL_INCOMING_RTL (parms)
3041 = eliminate_regs (DECL_INCOMING_RTL (parms), 0, NULL_RTX);
3042 SET_DECL_RTL (parms, eliminate_regs (DECL_RTL (parms), 0, NULL_RTX));
3043 #ifdef LEAF_REG_REMAP
3044 if (current_function_uses_only_leaf_regs)
3046 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms));
3047 leaf_renumber_regs_insn (DECL_RTL (parms));
3051 if (PARM_PASSED_IN_MEMORY (parms))
3053 rtx inrtl = XEXP (DECL_INCOMING_RTL (parms), 0);
3055 /* ??? Here we assume that the parm address is indexed
3056 off the frame pointer or arg pointer.
3057 If that is not true, we produce meaningless results,
3058 but do not crash. */
3059 if (GET_CODE (inrtl) == PLUS
3060 && GET_CODE (XEXP (inrtl, 1)) == CONST_INT)
3061 number = INTVAL (XEXP (inrtl, 1));
3066 number = DEBUGGER_ARG_OFFSET (number, inrtl);
3069 /* It is quite tempting to use TREE_TYPE (parms) instead
3070 of DECL_ARG_TYPE (parms) for the eff_type, so that gcc
3071 reports the actual type of the parameter, rather than
3072 the promoted type. This certainly makes GDB's life
3073 easier, at least for some ports. The change is a bad
3074 idea however, since GDB expects to be able access the
3075 type without performing any conversions. So for
3076 example, if we were passing a float to an unprototyped
3077 function, gcc will store a double on the stack, but if
3078 we emit a stab saying the type is a float, then gdb
3079 will only read in a single value, and this will produce
3080 an erroneous value. */
3081 eff_type = DECL_ARG_TYPE (parms);
3083 else if (REG_P (DECL_RTL (parms)))
3087 /* Parm passed in registers and lives in registers or nowhere. */
3088 code = DBX_REGPARM_STABS_CODE;
3089 letter = DBX_REGPARM_STABS_LETTER;
3091 /* For parms passed in registers, it is better to use the
3092 declared type of the variable, not the type it arrived in. */
3093 eff_type = TREE_TYPE (parms);
3095 /* If parm lives in a register, use that register; pretend
3096 the parm was passed there. It would be more consistent
3097 to describe the register where the parm was passed, but
3098 in practice that register usually holds something else.
3099 If the parm lives nowhere, use the register where it
3101 if (REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
3102 best_rtl = DECL_RTL (parms);
3104 best_rtl = DECL_INCOMING_RTL (parms);
3106 number = DBX_REGISTER_NUMBER (REGNO (best_rtl));
3108 else if (MEM_P (DECL_RTL (parms))
3109 && REG_P (XEXP (DECL_RTL (parms), 0))
3110 && REGNO (XEXP (DECL_RTL (parms), 0)) != HARD_FRAME_POINTER_REGNUM
3111 && REGNO (XEXP (DECL_RTL (parms), 0)) != STACK_POINTER_REGNUM
3112 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
3113 && REGNO (XEXP (DECL_RTL (parms), 0)) != ARG_POINTER_REGNUM
3117 /* Parm was passed via invisible reference.
3118 That is, its address was passed in a register.
3119 Output it as if it lived in that register.
3120 The debugger will know from the type
3121 that it was actually passed by invisible reference. */
3123 code = DBX_REGPARM_STABS_CODE;
3125 /* GDB likes this marked with a special letter. */
3126 letter = (use_gnu_debug_info_extensions
3127 ? 'a' : DBX_REGPARM_STABS_LETTER);
3128 eff_type = TREE_TYPE (parms);
3130 /* DECL_RTL looks like (MEM (REG...). Get the register number.
3131 If it is an unallocated pseudo-reg, then use the register where
3132 it was passed instead.
3133 ??? Why is DBX_REGISTER_NUMBER not used here? */
3135 if (REGNO (XEXP (DECL_RTL (parms), 0)) < FIRST_PSEUDO_REGISTER)
3136 number = REGNO (XEXP (DECL_RTL (parms), 0));
3138 number = REGNO (DECL_INCOMING_RTL (parms));
3140 else if (MEM_P (DECL_RTL (parms))
3141 && MEM_P (XEXP (DECL_RTL (parms), 0)))
3143 /* Parm was passed via invisible reference, with the reference
3144 living on the stack. DECL_RTL looks like
3145 (MEM (MEM (PLUS (REG ...) (CONST_INT ...)))) or it
3146 could look like (MEM (MEM (REG))). */
3150 eff_type = TREE_TYPE (parms);
3152 if (!REG_P (XEXP (XEXP (DECL_RTL (parms), 0), 0)))
3153 number = INTVAL (XEXP (XEXP (XEXP (DECL_RTL (parms), 0), 0), 1));
3157 number = DEBUGGER_ARG_OFFSET (number,
3158 XEXP (XEXP (DECL_RTL (parms), 0), 0));
3160 else if (MEM_P (DECL_RTL (parms))
3161 && XEXP (DECL_RTL (parms), 0) != const0_rtx
3162 /* ??? A constant address for a parm can happen
3163 when the reg it lives in is equiv to a constant in memory.
3164 Should make this not happen, after 2.4. */
3165 && ! CONSTANT_P (XEXP (DECL_RTL (parms), 0)))
3167 /* Parm was passed in registers but lives on the stack. */
3171 eff_type = TREE_TYPE (parms);
3173 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
3174 in which case we want the value of that CONST_INT,
3176 in which case we use a value of zero. */
3177 if (!REG_P (XEXP (DECL_RTL (parms), 0)))
3178 number = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1));
3182 /* Make a big endian correction if the mode of the type of the
3183 parameter is not the same as the mode of the rtl. */
3184 if (BYTES_BIG_ENDIAN
3185 && TYPE_MODE (TREE_TYPE (parms)) != GET_MODE (DECL_RTL (parms))
3186 && GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms))) < UNITS_PER_WORD)
3187 number += (GET_MODE_SIZE (GET_MODE (DECL_RTL (parms)))
3188 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms))));
3191 /* ??? We don't know how to represent this argument. */
3194 dbxout_begin_complex_stabs ();
3196 if (DECL_NAME (parms))
3198 stabstr_I (DECL_NAME (parms));
3202 stabstr_S ("(anon):");
3204 dbxout_type (eff_type, 0);
3205 dbxout_finish_complex_stabs (parms, code, 0, 0, number);
3207 DBXOUT_DECR_NESTING;
3210 /* Output definitions for the places where parms live during the function,
3211 when different from where they were passed, when the parms were passed
3214 It is not useful to do this for parms passed in registers
3215 that live during the function in different registers, because it is
3216 impossible to look in the passed register for the passed value,
3217 so we use the within-the-function register to begin with.
3219 PARMS is a chain of PARM_DECL nodes. */
3222 dbxout_reg_parms (tree parms)
3226 for (; parms; parms = TREE_CHAIN (parms))
3227 if (DECL_NAME (parms) && PARM_PASSED_IN_MEMORY (parms))
3229 /* Report parms that live in registers during the function
3230 but were passed in memory. */
3231 if (REG_P (DECL_RTL (parms))
3232 && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
3233 dbxout_symbol_location (parms, TREE_TYPE (parms),
3234 0, DECL_RTL (parms));
3235 else if (GET_CODE (DECL_RTL (parms)) == CONCAT)
3236 dbxout_symbol_location (parms, TREE_TYPE (parms),
3237 0, DECL_RTL (parms));
3238 /* Report parms that live in memory but not where they were passed. */
3239 else if (MEM_P (DECL_RTL (parms))
3240 && ! rtx_equal_p (DECL_RTL (parms), DECL_INCOMING_RTL (parms)))
3241 dbxout_symbol_location (parms, TREE_TYPE (parms),
3242 0, DECL_RTL (parms));
3244 DBXOUT_DECR_NESTING;
3247 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
3248 output definitions of those names, in raw form */
3251 dbxout_args (tree args)
3256 dbxout_type (TREE_VALUE (args), 0);
3257 args = TREE_CHAIN (args);
3261 /* Subroutine of dbxout_block. Emit an N_LBRAC stab referencing LABEL.
3262 BEGIN_LABEL is the name of the beginning of the function, which may
3265 dbx_output_lbrac (const char *label,
3266 const char *begin_label ATTRIBUTE_UNUSED)
3268 dbxout_begin_stabn (N_LBRAC);
3269 if (DBX_BLOCKS_FUNCTION_RELATIVE)
3270 dbxout_stab_value_label_diff (label, begin_label);
3272 dbxout_stab_value_label (label);
3275 /* Subroutine of dbxout_block. Emit an N_RBRAC stab referencing LABEL.
3276 BEGIN_LABEL is the name of the beginning of the function, which may
3279 dbx_output_rbrac (const char *label,
3280 const char *begin_label ATTRIBUTE_UNUSED)
3282 dbxout_begin_stabn (N_RBRAC);
3283 if (DBX_BLOCKS_FUNCTION_RELATIVE)
3284 dbxout_stab_value_label_diff (label, begin_label);
3286 dbxout_stab_value_label (label);
3289 /* Output everything about a symbol block (a BLOCK node
3290 that represents a scope level),
3291 including recursive output of contained blocks.
3293 BLOCK is the BLOCK node.
3294 DEPTH is its depth within containing symbol blocks.
3295 ARGS is usually zero; but for the outermost block of the
3296 body of a function, it is a chain of PARM_DECLs for the function parameters.
3297 We output definitions of all the register parms
3298 as if they were local variables of that block.
3300 If -g1 was used, we count blocks just the same, but output nothing
3301 except for the outermost block.
3303 Actually, BLOCK may be several blocks chained together.
3304 We handle them all in sequence. */
3307 dbxout_block (tree block, int depth, tree args)
3309 char begin_label[20];
3310 /* Reference current function start using LFBB. */
3311 ASM_GENERATE_INTERNAL_LABEL (begin_label, "LFBB", scope_labelno);
3315 /* Ignore blocks never expanded or otherwise marked as real. */
3316 if (TREE_USED (block) && TREE_ASM_WRITTEN (block))
3319 int blocknum = BLOCK_NUMBER (block);
3321 /* In dbx format, the syms of a block come before the N_LBRAC.
3322 If nothing is output, we don't need the N_LBRAC, either. */
3324 if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
3325 did_output = dbxout_syms (BLOCK_VARS (block));
3327 dbxout_reg_parms (args);
3329 /* Now output an N_LBRAC symbol to represent the beginning of
3330 the block. Use the block's tree-walk order to generate
3331 the assembler symbols LBBn and LBEn
3332 that final will define around the code in this block. */
3336 const char *scope_start;
3339 /* The outermost block doesn't get LBB labels; use
3340 the LFBB local symbol emitted by dbxout_begin_prologue. */
3341 scope_start = begin_label;
3344 ASM_GENERATE_INTERNAL_LABEL (buf, "LBB", blocknum);
3348 if (BLOCK_HANDLER_BLOCK (block))
3350 /* A catch block. Must precede N_LBRAC. */
3351 tree decl = BLOCK_VARS (block);
3354 dbxout_begin_complex_stabs ();
3355 stabstr_I (DECL_NAME (decl));
3357 dbxout_finish_complex_stabs (0, N_CATCH, 0,
3359 decl = TREE_CHAIN (decl);
3362 dbx_output_lbrac (scope_start, begin_label);
3365 /* Output the subblocks. */
3366 dbxout_block (BLOCK_SUBBLOCKS (block), depth + 1, NULL_TREE);
3368 /* Refer to the marker for the end of the block. */
3373 /* The outermost block doesn't get LBE labels;
3374 use the "scope" label which will be emitted
3375 by dbxout_function_end. */
3376 ASM_GENERATE_INTERNAL_LABEL (buf, "Lscope", scope_labelno);
3378 ASM_GENERATE_INTERNAL_LABEL (buf, "LBE", blocknum);
3380 dbx_output_rbrac (buf, begin_label);
3383 block = BLOCK_CHAIN (block);
3387 /* Output the information about a function and its arguments and result.
3388 Usually this follows the function's code,
3389 but on some systems, it comes before. */
3391 #if defined (DBX_DEBUGGING_INFO)
3393 dbxout_begin_function (tree decl)
3395 int saved_tree_used1;
3397 if (DECL_IGNORED_P (decl))
3400 saved_tree_used1 = TREE_USED (decl);
3401 TREE_USED (decl) = 1;
3402 if (DECL_NAME (DECL_RESULT (decl)) != 0)
3404 int saved_tree_used2 = TREE_USED (DECL_RESULT (decl));
3405 TREE_USED (DECL_RESULT (decl)) = 1;
3406 dbxout_symbol (decl, 0);
3407 TREE_USED (DECL_RESULT (decl)) = saved_tree_used2;
3410 dbxout_symbol (decl, 0);
3411 TREE_USED (decl) = saved_tree_used1;
3413 dbxout_parms (DECL_ARGUMENTS (decl));
3414 if (DECL_NAME (DECL_RESULT (decl)) != 0)
3415 dbxout_symbol (DECL_RESULT (decl), 1);
3417 #endif /* DBX_DEBUGGING_INFO */
3419 #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */
3421 #include "gt-dbxout.h"