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 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
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"
90 #include "langhooks.h"
93 #ifdef XCOFF_DEBUGGING_INFO
97 #define DBXOUT_DECR_NESTING \
98 if (--debug_nesting == 0 && symbol_queue_index > 0) \
99 { emit_pending_bincls_if_required (); debug_flush_symbol_queue (); }
101 #define DBXOUT_DECR_NESTING_AND_RETURN(x) \
102 do {--debug_nesting; return (x);} while (0)
105 # ifdef XCOFF_DEBUGGING_INFO
106 # define ASM_STABS_OP "\t.stabx\t"
108 # define ASM_STABS_OP "\t.stabs\t"
113 #define ASM_STABN_OP "\t.stabn\t"
117 #define ASM_STABD_OP "\t.stabd\t"
120 #ifndef DBX_TYPE_DECL_STABS_CODE
121 #define DBX_TYPE_DECL_STABS_CODE N_LSYM
124 #ifndef DBX_STATIC_CONST_VAR_CODE
125 #define DBX_STATIC_CONST_VAR_CODE N_FUN
128 #ifndef DBX_REGPARM_STABS_CODE
129 #define DBX_REGPARM_STABS_CODE N_RSYM
132 #ifndef DBX_REGPARM_STABS_LETTER
133 #define DBX_REGPARM_STABS_LETTER 'P'
136 #ifndef NO_DBX_FUNCTION_END
137 #define NO_DBX_FUNCTION_END 0
140 #ifndef NO_DBX_BNSYM_ENSYM
141 #define NO_DBX_BNSYM_ENSYM 0
144 #ifndef NO_DBX_MAIN_SOURCE_DIRECTORY
145 #define NO_DBX_MAIN_SOURCE_DIRECTORY 0
148 #ifndef DBX_BLOCKS_FUNCTION_RELATIVE
149 #define DBX_BLOCKS_FUNCTION_RELATIVE 0
152 #ifndef DBX_LINES_FUNCTION_RELATIVE
153 #define DBX_LINES_FUNCTION_RELATIVE 0
156 #ifndef DBX_CONTIN_LENGTH
157 #define DBX_CONTIN_LENGTH 80
160 #ifndef DBX_CONTIN_CHAR
161 #define DBX_CONTIN_CHAR '\\'
164 enum typestatus {TYPE_UNSEEN, TYPE_XREF, TYPE_DEFINED};
166 /* Structure recording information about a C data type.
167 The status element says whether we have yet output
168 the definition of the type. TYPE_XREF says we have
169 output it as a cross-reference only.
170 The file_number and type_number elements are used if DBX_USE_BINCL
173 struct typeinfo GTY(())
175 enum typestatus status;
180 /* Vector recording information about C data types.
181 When we first notice a data type (a tree node),
182 we assign it a number using next_type_number.
183 That is its index in this vector. */
185 static GTY ((length ("typevec_len"))) struct typeinfo *typevec;
187 /* Number of elements of space allocated in `typevec'. */
189 static GTY(()) int typevec_len;
191 /* In dbx output, each type gets a unique number.
192 This is the number for the next type output.
193 The number, once assigned, is in the TYPE_SYMTAB_ADDRESS field. */
195 static GTY(()) int next_type_number;
197 /* The C front end may call dbxout_symbol before dbxout_init runs.
198 We save all such decls in this list and output them when we get
201 static GTY(()) tree preinit_symbols;
203 enum binclstatus {BINCL_NOT_REQUIRED, BINCL_PENDING, BINCL_PROCESSED};
205 /* When using N_BINCL in dbx output, each type number is actually a
206 pair of the file number and the type number within the file.
207 This is a stack of input files. */
211 struct dbx_file *next;
213 int next_type_number;
214 enum binclstatus bincl_status; /* Keep track of lazy bincl. */
215 const char *pending_bincl_name; /* Name of bincl. */
216 struct dbx_file *prev; /* Chain to traverse all pending bincls. */
219 /* This is the top of the stack.
221 This is not saved for PCH, because restoring a PCH should not change it.
222 next_file_number does have to be saved, because the PCH may use some
223 file numbers; however, just before restoring a PCH, next_file_number
224 should always be 0 because we should not have needed any file numbers
227 #if (defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)) \
228 && defined (DBX_USE_BINCL)
229 static struct dbx_file *current_file;
232 /* This is the next file number to use. */
234 static GTY(()) int next_file_number;
236 /* A counter for dbxout_function_end. */
238 static GTY(()) int scope_labelno;
240 /* A counter for dbxout_source_line. */
242 static GTY(()) int dbxout_source_line_counter;
244 /* Nonzero if we have actually used any of the GDB extensions
245 to the debugging format. The idea is that we use them for the
246 first time only if there's a strong reason, but once we have done that,
247 we use them whenever convenient. */
249 static GTY(()) int have_used_extensions = 0;
251 /* Number for the next N_SOL filename stabs label. The number 0 is reserved
252 for the N_SO filename stabs label. */
254 static GTY(()) int source_label_number = 1;
256 /* Last source file name mentioned in a NOTE insn. */
258 static GTY(()) const char *lastfile;
260 /* Used by PCH machinery to detect if 'lastfile' should be reset to
262 static GTY(()) int lastfile_is_base;
264 /* Typical USG systems don't have stab.h, and they also have
265 no use for DBX-format debugging info. */
267 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
270 /* If zero then there is no pending BINCL. */
271 static int pending_bincls = 0;
274 /* The original input file name. */
275 static const char *base_input_file;
277 #ifdef DEBUG_SYMS_TEXT
278 #define FORCE_TEXT function_section (current_function_decl);
285 #define STAB_CODE_TYPE enum __stab_debug_code
287 /* 1 if PARM is passed to this function in memory. */
289 #define PARM_PASSED_IN_MEMORY(PARM) \
290 (MEM_P (DECL_INCOMING_RTL (PARM)))
292 /* A C expression for the integer offset value of an automatic variable
293 (N_LSYM) having address X (an RTX). */
294 #ifndef DEBUGGER_AUTO_OFFSET
295 #define DEBUGGER_AUTO_OFFSET(X) \
296 (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
299 /* A C expression for the integer offset value of an argument (N_PSYM)
300 having address X (an RTX). The nominal offset is OFFSET. */
301 #ifndef DEBUGGER_ARG_OFFSET
302 #define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET)
305 /* This obstack holds the stab string currently being constructed. We
306 build it up here, then write it out, so we can split long lines up
307 properly (see dbxout_finish_complex_stabs). */
308 static struct obstack stabstr_ob;
309 static size_t stabstr_last_contin_point;
312 static void emit_bincl_stab (const char *c);
313 static void emit_pending_bincls (void);
315 static inline void emit_pending_bincls_if_required (void);
317 static void dbxout_init (const char *);
319 static void dbxout_finish (const char *);
320 static void dbxout_start_source_file (unsigned, const char *);
321 static void dbxout_end_source_file (unsigned);
322 static void dbxout_typedefs (tree);
323 static void dbxout_type_index (tree);
324 static void dbxout_args (tree);
325 static void dbxout_type_fields (tree);
326 static void dbxout_type_method_1 (tree);
327 static void dbxout_type_methods (tree);
328 static void dbxout_range_type (tree);
329 static void dbxout_type (tree, int);
330 static bool print_int_cst_bounds_in_octal_p (tree);
331 static void dbxout_type_name (tree);
332 static void dbxout_class_name_qualifiers (tree);
333 static int dbxout_symbol_location (tree, tree, const char *, rtx);
334 static void dbxout_symbol_name (tree, const char *, int);
335 static void dbxout_block (tree, int, tree);
336 static void dbxout_global_decl (tree);
337 static void dbxout_type_decl (tree, int);
338 static void dbxout_handle_pch (unsigned);
340 /* The debug hooks structure. */
341 #if defined (DBX_DEBUGGING_INFO)
343 static void dbxout_source_line (unsigned int, const char *);
344 static void dbxout_begin_prologue (unsigned int, const char *);
345 static void dbxout_source_file (const char *);
346 static void dbxout_function_end (tree);
347 static void dbxout_begin_function (tree);
348 static void dbxout_begin_block (unsigned, unsigned);
349 static void dbxout_end_block (unsigned, unsigned);
350 static void dbxout_function_decl (tree);
352 const struct gcc_debug_hooks dbx_debug_hooks =
356 debug_nothing_int_charstar,
357 debug_nothing_int_charstar,
358 dbxout_start_source_file,
359 dbxout_end_source_file,
362 debug_true_tree, /* ignore_block */
363 dbxout_source_line, /* source_line */
364 dbxout_begin_prologue, /* begin_prologue */
365 debug_nothing_int_charstar, /* end_prologue */
366 debug_nothing_int_charstar, /* end_epilogue */
367 #ifdef DBX_FUNCTION_FIRST
368 dbxout_begin_function,
370 debug_nothing_tree, /* begin_function */
372 debug_nothing_int, /* end_function */
373 dbxout_function_decl,
374 dbxout_global_decl, /* global_decl */
375 dbxout_type_decl, /* type_decl */
376 debug_nothing_tree_tree, /* imported_module_or_decl */
377 debug_nothing_tree, /* deferred_inline_function */
378 debug_nothing_tree, /* outlining_inline_function */
379 debug_nothing_rtx, /* label */
380 dbxout_handle_pch, /* handle_pch */
381 debug_nothing_rtx, /* var_location */
382 0 /* start_end_main_source_file */
384 #endif /* DBX_DEBUGGING_INFO */
386 #if defined (XCOFF_DEBUGGING_INFO)
387 const struct gcc_debug_hooks xcoff_debug_hooks =
391 debug_nothing_int_charstar,
392 debug_nothing_int_charstar,
393 dbxout_start_source_file,
394 dbxout_end_source_file,
395 xcoffout_begin_block,
397 debug_true_tree, /* ignore_block */
398 xcoffout_source_line,
399 xcoffout_begin_prologue, /* begin_prologue */
400 debug_nothing_int_charstar, /* end_prologue */
401 xcoffout_end_epilogue,
402 debug_nothing_tree, /* begin_function */
403 xcoffout_end_function,
404 debug_nothing_tree, /* function_decl */
405 dbxout_global_decl, /* global_decl */
406 dbxout_type_decl, /* type_decl */
407 debug_nothing_tree_tree, /* imported_module_or_decl */
408 debug_nothing_tree, /* deferred_inline_function */
409 debug_nothing_tree, /* outlining_inline_function */
410 debug_nothing_rtx, /* label */
411 dbxout_handle_pch, /* handle_pch */
412 debug_nothing_rtx, /* var_location */
413 0 /* start_end_main_source_file */
415 #endif /* XCOFF_DEBUGGING_INFO */
417 /* Numeric formatting helper macro. Note that this does not handle
419 #define NUMBER_FMT_LOOP(P, NUM, BASE) \
422 int digit = NUM % BASE; \
424 *--P = digit + '0'; \
428 /* Utility: write a decimal integer NUM to asm_out_file. */
433 char *p = buf + sizeof buf;
438 putc ('0', asm_out_file);
443 putc ('-', asm_out_file);
449 NUMBER_FMT_LOOP (p, unum, 10);
451 while (p < buf + sizeof buf)
453 putc (*p, asm_out_file);
459 /* Primitives for emitting simple stabs directives. All other stabs
460 routines should use these functions instead of directly emitting
461 stabs. They are exported because machine-dependent code may need
462 to invoke them, e.g. in a DBX_OUTPUT_* macro whose definition
463 forwards to code in CPU.c. */
465 /* The following functions should all be called immediately after one
466 of the dbxout_begin_stab* functions (below). They write out
467 various things as the value of a stab. */
469 /* Write out a literal zero as the value of a stab. */
471 dbxout_stab_value_zero (void)
473 fputs ("0\n", asm_out_file);
476 /* Write out the label LABEL as the value of a stab. */
478 dbxout_stab_value_label (const char *label)
480 assemble_name (asm_out_file, label);
481 putc ('\n', asm_out_file);
484 /* Write out the difference of two labels, LABEL - BASE, as the value
487 dbxout_stab_value_label_diff (const char *label, const char *base)
489 assemble_name (asm_out_file, label);
490 putc ('-', asm_out_file);
491 assemble_name (asm_out_file, base);
492 putc ('\n', asm_out_file);
495 /* Write out an internal label as the value of a stab, and immediately
496 emit that internal label. This should be used only when
497 dbxout_stabd will not work. STEM is the name stem of the label,
498 COUNTERP is a pointer to a counter variable which will be used to
499 guarantee label uniqueness. */
501 dbxout_stab_value_internal_label (const char *stem, int *counterp)
504 int counter = counterp ? (*counterp)++ : 0;
506 ASM_GENERATE_INTERNAL_LABEL (label, stem, counter);
507 dbxout_stab_value_label (label);
508 targetm.asm_out.internal_label (asm_out_file, stem, counter);
511 /* Write out the difference between BASE and an internal label as the
512 value of a stab, and immediately emit that internal label. STEM and
513 COUNTERP are as for dbxout_stab_value_internal_label. */
515 dbxout_stab_value_internal_label_diff (const char *stem, int *counterp,
519 int counter = counterp ? (*counterp)++ : 0;
521 ASM_GENERATE_INTERNAL_LABEL (label, stem, counter);
522 dbxout_stab_value_label_diff (label, base);
523 targetm.asm_out.internal_label (asm_out_file, stem, counter);
526 /* The following functions produce specific kinds of stab directives. */
528 /* Write a .stabd directive with type STYPE and desc SDESC to asm_out_file. */
530 dbxout_stabd (int stype, int sdesc)
532 fputs (ASM_STABD_OP, asm_out_file);
534 fputs (",0,", asm_out_file);
536 putc ('\n', asm_out_file);
539 /* Write a .stabn directive with type STYPE. This function stops
540 short of emitting the value field, which is the responsibility of
541 the caller (normally it will be either a symbol or the difference
545 dbxout_begin_stabn (int stype)
547 fputs (ASM_STABN_OP, asm_out_file);
549 fputs (",0,0,", asm_out_file);
552 /* Write a .stabn directive with type N_SLINE and desc LINE. As above,
553 the value field is the responsibility of the caller. */
555 dbxout_begin_stabn_sline (int lineno)
557 fputs (ASM_STABN_OP, asm_out_file);
558 dbxout_int (N_SLINE);
559 fputs (",0,", asm_out_file);
561 putc (',', asm_out_file);
564 /* Begin a .stabs directive with string "", type STYPE, and desc and
565 other fields 0. The value field is the responsibility of the
566 caller. This function cannot be used for .stabx directives. */
568 dbxout_begin_empty_stabs (int stype)
570 fputs (ASM_STABS_OP, asm_out_file);
571 fputs ("\"\",", asm_out_file);
573 fputs (",0,0,", asm_out_file);
576 /* Begin a .stabs directive with string STR, type STYPE, and desc 0.
577 The value field is the responsibility of the caller. */
579 dbxout_begin_simple_stabs (const char *str, int stype)
581 fputs (ASM_STABS_OP, asm_out_file);
582 output_quoted_string (asm_out_file, str);
583 putc (',', asm_out_file);
585 fputs (",0,0,", asm_out_file);
588 /* As above but use SDESC for the desc field. */
590 dbxout_begin_simple_stabs_desc (const char *str, int stype, int sdesc)
592 fputs (ASM_STABS_OP, asm_out_file);
593 output_quoted_string (asm_out_file, str);
594 putc (',', asm_out_file);
596 fputs (",0,", asm_out_file);
598 putc (',', asm_out_file);
601 /* The next set of functions are entirely concerned with production of
602 "complex" .stabs directives: that is, .stabs directives whose
603 strings have to be constructed piecemeal. dbxout_type,
604 dbxout_symbol, etc. use these routines heavily. The string is queued
605 up in an obstack, then written out by dbxout_finish_complex_stabs, which
606 is also responsible for splitting it up if it exceeds DBX_CONTIN_LENGTH.
607 (You might think it would be more efficient to go straight to stdio
608 when DBX_CONTIN_LENGTH is 0 (i.e. no length limit) but that turns
609 out not to be the case, and anyway this needs fewer #ifdefs.) */
611 /* Begin a complex .stabs directive. If we can, write the initial
612 ASM_STABS_OP to the asm_out_file. */
615 dbxout_begin_complex_stabs (void)
617 emit_pending_bincls_if_required ();
619 fputs (ASM_STABS_OP, asm_out_file);
620 putc ('"', asm_out_file);
621 gcc_assert (stabstr_last_contin_point == 0);
624 /* As above, but do not force text or emit pending bincls. This is
625 used by dbxout_symbol_location, which needs to do something else. */
627 dbxout_begin_complex_stabs_noforcetext (void)
629 fputs (ASM_STABS_OP, asm_out_file);
630 putc ('"', asm_out_file);
631 gcc_assert (stabstr_last_contin_point == 0);
634 /* Add CHR, a single character, to the string being built. */
635 #define stabstr_C(chr) obstack_1grow (&stabstr_ob, chr)
637 /* Add STR, a normal C string, to the string being built. */
638 #define stabstr_S(str) obstack_grow (&stabstr_ob, str, strlen(str))
640 /* Add the text of ID, an IDENTIFIER_NODE, to the string being built. */
641 #define stabstr_I(id) obstack_grow (&stabstr_ob, \
642 IDENTIFIER_POINTER (id), \
643 IDENTIFIER_LENGTH (id))
645 /* Add NUM, a signed decimal number, to the string being built. */
647 stabstr_D (HOST_WIDE_INT num)
650 char *p = buf + sizeof buf;
666 NUMBER_FMT_LOOP (p, unum, 10);
668 obstack_grow (&stabstr_ob, p, (buf + sizeof buf) - p);
671 /* Add NUM, an unsigned decimal number, to the string being built. */
673 stabstr_U (unsigned HOST_WIDE_INT num)
676 char *p = buf + sizeof buf;
682 NUMBER_FMT_LOOP (p, num, 10);
683 obstack_grow (&stabstr_ob, p, (buf + sizeof buf) - p);
686 /* Add CST, an INTEGER_CST tree, to the string being built as an
687 unsigned octal number. This routine handles values which are
688 larger than a single HOST_WIDE_INT. */
692 unsigned HOST_WIDE_INT high = TREE_INT_CST_HIGH (cst);
693 unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (cst);
696 char *p = buf + sizeof buf;
698 /* GDB wants constants with no extra leading "1" bits, so
699 we need to remove any sign-extension that might be
702 const unsigned int width = TYPE_PRECISION (TREE_TYPE (cst));
703 if (width == HOST_BITS_PER_WIDE_INT * 2)
705 else if (width > HOST_BITS_PER_WIDE_INT)
706 high &= (((HOST_WIDE_INT) 1 << (width - HOST_BITS_PER_WIDE_INT)) - 1);
707 else if (width == HOST_BITS_PER_WIDE_INT)
710 high = 0, low &= (((HOST_WIDE_INT) 1 << width) - 1);
713 /* Leading zero for base indicator. */
716 /* If the value is zero, the base indicator will serve as the value
718 if (high == 0 && low == 0)
721 /* If the high half is zero, we need only print the low half normally. */
723 NUMBER_FMT_LOOP (p, low, 8);
726 /* When high != 0, we need to print enough zeroes from low to
727 give the digits from high their proper place-values. Hence
728 NUMBER_FMT_LOOP cannot be used. */
729 const int n_digits = HOST_BITS_PER_WIDE_INT / 3;
732 for (i = 1; i <= n_digits; i++)
734 unsigned int digit = low % 8;
739 /* Octal digits carry exactly three bits of information. The
740 width of a HOST_WIDE_INT is not normally a multiple of three.
741 Therefore, the next digit printed probably needs to carry
742 information from both low and high. */
743 if (HOST_BITS_PER_WIDE_INT % 3 != 0)
745 const int n_leftover_bits = HOST_BITS_PER_WIDE_INT % 3;
746 const int n_bits_from_high = 3 - n_leftover_bits;
748 const unsigned HOST_WIDE_INT
749 low_mask = (((unsigned HOST_WIDE_INT)1) << n_leftover_bits) - 1;
750 const unsigned HOST_WIDE_INT
751 high_mask = (((unsigned HOST_WIDE_INT)1) << n_bits_from_high) - 1;
755 /* At this point, only the bottom n_leftover_bits bits of low
757 gcc_assert (!(low & ~low_mask));
759 digit = (low | ((high & high_mask) << n_leftover_bits));
760 high >>= n_bits_from_high;
765 /* Now we can format high in the normal manner. However, if
766 the only bits of high that were set were handled by the
767 digit split between low and high, high will now be zero, and
768 we don't want to print extra digits in that case. */
770 NUMBER_FMT_LOOP (p, high, 8);
773 obstack_grow (&stabstr_ob, p, (buf + sizeof buf) - p);
776 /* Called whenever it is safe to break a stabs string into multiple
777 .stabs directives. If the current string has exceeded the limit
778 set by DBX_CONTIN_LENGTH, mark the current position in the buffer
779 as a continuation point by inserting DBX_CONTIN_CHAR (doubled if
780 it is a backslash) and a null character. */
782 stabstr_continue (void)
784 if (DBX_CONTIN_LENGTH > 0
785 && obstack_object_size (&stabstr_ob) - stabstr_last_contin_point
788 if (DBX_CONTIN_CHAR == '\\')
789 obstack_1grow (&stabstr_ob, '\\');
790 obstack_1grow (&stabstr_ob, DBX_CONTIN_CHAR);
791 obstack_1grow (&stabstr_ob, '\0');
792 stabstr_last_contin_point = obstack_object_size (&stabstr_ob);
795 #define CONTIN stabstr_continue ()
797 /* Macro subroutine of dbxout_finish_complex_stabs, which emits
798 all of the arguments to the .stabs directive after the string.
799 Overridden by xcoffout.h. CODE is the stabs code for this symbol;
800 LINE is the source line to write into the desc field (in extended
801 mode); SYM is the symbol itself.
803 ADDR, LABEL, and NUMBER are three different ways to represent the
804 stabs value field. At most one of these should be nonzero.
806 ADDR is used most of the time; it represents the value as an
807 RTL address constant.
809 LABEL is used (currently) only for N_CATCH stabs; it represents
810 the value as a string suitable for assemble_name.
812 NUMBER is used when the value is an offset from an implicit base
813 pointer (e.g. for a stack variable), or an index (e.g. for a
814 register variable). It represents the value as a decimal integer. */
816 #ifndef DBX_FINISH_STABS
817 #define DBX_FINISH_STABS(SYM, CODE, LINE, ADDR, LABEL, NUMBER) \
819 int line_ = use_gnu_debug_info_extensions ? LINE : 0; \
822 fputs (",0,", asm_out_file); \
823 dbxout_int (line_); \
824 putc (',', asm_out_file); \
826 output_addr_const (asm_out_file, ADDR); \
828 assemble_name (asm_out_file, LABEL); \
830 dbxout_int (NUMBER); \
831 putc ('\n', asm_out_file); \
835 /* Finish the emission of a complex .stabs directive. When DBX_CONTIN_LENGTH
836 is zero, this has only to emit the close quote and the remainder of
837 the arguments. When it is nonzero, the string has been marshalled in
838 stabstr_ob, and this routine is responsible for breaking it up into
839 DBX_CONTIN_LENGTH-sized chunks.
841 SYM is the DECL of the symbol under consideration; it is used only
842 for its DECL_SOURCE_LINE. The other arguments are all passed directly
843 to DBX_FINISH_STABS; see above for details. */
846 dbxout_finish_complex_stabs (tree sym, STAB_CODE_TYPE code,
847 rtx addr, const char *label, int number)
849 int line ATTRIBUTE_UNUSED;
853 line = sym ? DECL_SOURCE_LINE (sym) : 0;
854 if (DBX_CONTIN_LENGTH > 0)
859 /* Nul-terminate the growing string, then get its size and
861 obstack_1grow (&stabstr_ob, '\0');
863 len = obstack_object_size (&stabstr_ob);
864 chunk = str = obstack_finish (&stabstr_ob);
866 /* Within the buffer are a sequence of NUL-separated strings,
867 each of which is to be written out as a separate stab
871 chunklen = strlen (chunk);
872 fwrite (chunk, 1, chunklen, asm_out_file);
873 fputs ("\",", asm_out_file);
875 /* Must add an extra byte to account for the NUL separator. */
876 chunk += chunklen + 1;
879 /* Only put a line number on the last stab in the sequence. */
880 DBX_FINISH_STABS (sym, code, len == 0 ? line : 0,
881 addr, label, number);
885 fputs (ASM_STABS_OP, asm_out_file);
886 putc ('"', asm_out_file);
888 stabstr_last_contin_point = 0;
892 /* No continuations - we can put the whole string out at once.
893 It is faster to augment the string with the close quote and
894 comma than to do a two-character fputs. */
895 obstack_grow (&stabstr_ob, "\",", 2);
896 len = obstack_object_size (&stabstr_ob);
897 str = obstack_finish (&stabstr_ob);
899 fwrite (str, 1, len, asm_out_file);
900 DBX_FINISH_STABS (sym, code, line, addr, label, number);
902 obstack_free (&stabstr_ob, str);
905 #if defined (DBX_DEBUGGING_INFO)
908 dbxout_function_end (tree decl)
910 char lscope_label_name[100];
912 /* The Lscope label must be emitted even if we aren't doing anything
913 else; dbxout_block needs it. */
914 function_section (current_function_decl);
916 /* Convert Lscope into the appropriate format for local labels in case
917 the system doesn't insert underscores in front of user generated
919 ASM_GENERATE_INTERNAL_LABEL (lscope_label_name, "Lscope", scope_labelno);
920 targetm.asm_out.internal_label (asm_out_file, "Lscope", scope_labelno);
923 /* The N_FUN tag at the end of the function is a GNU extension,
924 which may be undesirable, and is unnecessary if we do not have
926 if (!use_gnu_debug_info_extensions
927 || NO_DBX_FUNCTION_END
928 || !targetm.have_named_sections
929 || DECL_IGNORED_P (decl))
932 /* By convention, GCC will mark the end of a function with an N_FUN
933 symbol and an empty string. */
934 #ifdef DBX_OUTPUT_NFUN
935 DBX_OUTPUT_NFUN (asm_out_file, lscope_label_name, current_function_decl);
937 dbxout_begin_empty_stabs (N_FUN);
938 dbxout_stab_value_label_diff (lscope_label_name,
939 XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0));
943 if (!NO_DBX_BNSYM_ENSYM && !flag_debug_only_used_symbols)
944 dbxout_stabd (N_ENSYM, 0);
946 #endif /* DBX_DEBUGGING_INFO */
948 /* Get lang description for N_SO stab. */
949 static unsigned int ATTRIBUTE_UNUSED
950 get_lang_number (void)
952 const char *language_string = lang_hooks.name;
954 if (strcmp (language_string, "GNU C") == 0)
956 else if (strcmp (language_string, "GNU C++") == 0)
958 else if (strcmp (language_string, "GNU F77") == 0)
960 else if (strcmp (language_string, "GNU F95") == 0)
961 return N_SO_FORTRAN90; /* CHECKME */
962 else if (strcmp (language_string, "GNU Pascal") == 0)
964 else if (strcmp (language_string, "GNU Objective-C") == 0)
971 /* At the beginning of compilation, start writing the symbol table.
972 Initialize `typevec' and output the standard data types of C. */
975 dbxout_init (const char *input_file_name)
977 char ltext_label_name[100];
978 bool used_ltext_label_name = false;
979 tree syms = lang_hooks.decls.getdecls ();
982 typevec = ggc_calloc (typevec_len, sizeof typevec[0]);
984 /* stabstr_ob contains one string, which will be just fine with
986 obstack_specify_allocation (&stabstr_ob, 0, 1, xmalloc, free);
988 /* Convert Ltext into the appropriate format for local labels in case
989 the system doesn't insert underscores in front of user generated
991 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext", 0);
993 /* Put the current working directory in an N_SO symbol. */
994 if (use_gnu_debug_info_extensions && !NO_DBX_MAIN_SOURCE_DIRECTORY)
996 static const char *cwd;
1000 cwd = get_src_pwd ();
1003 else if (!IS_DIR_SEPARATOR (cwd[strlen (cwd) - 1]))
1004 cwd = concat (cwd, "/", NULL);
1006 #ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
1007 DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asm_out_file, cwd);
1008 #else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
1009 dbxout_begin_simple_stabs_desc (cwd, N_SO, get_lang_number ());
1010 dbxout_stab_value_label (ltext_label_name);
1011 used_ltext_label_name = true;
1012 #endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
1015 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
1016 DBX_OUTPUT_MAIN_SOURCE_FILENAME (asm_out_file, input_file_name);
1018 dbxout_begin_simple_stabs_desc (input_file_name, N_SO, get_lang_number ());
1019 dbxout_stab_value_label (ltext_label_name);
1020 used_ltext_label_name = true;
1023 if (used_ltext_label_name)
1026 targetm.asm_out.internal_label (asm_out_file, "Ltext", 0);
1029 /* Emit an N_OPT stab to indicate that this file was compiled by GCC.
1030 The string used is historical. */
1031 #ifndef NO_DBX_GCC_MARKER
1032 dbxout_begin_simple_stabs ("gcc2_compiled.", N_OPT);
1033 dbxout_stab_value_zero ();
1036 base_input_file = lastfile = input_file_name;
1038 next_type_number = 1;
1040 #ifdef DBX_USE_BINCL
1041 current_file = xmalloc (sizeof *current_file);
1042 current_file->next = NULL;
1043 current_file->file_number = 0;
1044 current_file->next_type_number = 1;
1045 next_file_number = 1;
1046 current_file->prev = NULL;
1047 current_file->bincl_status = BINCL_NOT_REQUIRED;
1048 current_file->pending_bincl_name = NULL;
1051 /* Get all permanent types that have typedef names, and output them
1052 all, except for those already output. Some language front ends
1053 put these declarations in the top-level scope; some do not;
1054 the latter are responsible for calling debug_hooks->type_decl from
1055 their record_builtin_type function. */
1056 dbxout_typedefs (syms);
1058 if (preinit_symbols)
1061 for (t = nreverse (preinit_symbols); t; t = TREE_CHAIN (t))
1062 dbxout_symbol (TREE_VALUE (t), 0);
1063 preinit_symbols = 0;
1067 /* Output any typedef names for types described by TYPE_DECLs in SYMS. */
1070 dbxout_typedefs (tree syms)
1072 for (; syms != NULL_TREE; syms = TREE_CHAIN (syms))
1074 if (TREE_CODE (syms) == TYPE_DECL)
1076 tree type = TREE_TYPE (syms);
1077 if (TYPE_NAME (type)
1078 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1079 && COMPLETE_OR_VOID_TYPE_P (type)
1080 && ! TREE_ASM_WRITTEN (TYPE_NAME (type)))
1081 dbxout_symbol (TYPE_NAME (type), 0);
1086 #ifdef DBX_USE_BINCL
1087 /* Emit BINCL stab using given name. */
1089 emit_bincl_stab (const char *name)
1091 dbxout_begin_simple_stabs (name, N_BINCL);
1092 dbxout_stab_value_zero ();
1095 /* If there are pending bincls then it is time to emit all of them. */
1098 emit_pending_bincls_if_required (void)
1101 emit_pending_bincls ();
1104 /* Emit all pending bincls. */
1107 emit_pending_bincls (void)
1109 struct dbx_file *f = current_file;
1111 /* Find first pending bincl. */
1112 while (f->bincl_status == BINCL_PENDING)
1115 /* Now emit all bincls. */
1120 if (f->bincl_status == BINCL_PENDING)
1122 emit_bincl_stab (f->pending_bincl_name);
1124 /* Update file number and status. */
1125 f->file_number = next_file_number++;
1126 f->bincl_status = BINCL_PROCESSED;
1128 if (f == current_file)
1133 /* All pending bincls have been emitted. */
1140 emit_pending_bincls_if_required (void) {}
1143 /* Change to reading from a new source file. Generate a N_BINCL stab. */
1146 dbxout_start_source_file (unsigned int line ATTRIBUTE_UNUSED,
1147 const char *filename ATTRIBUTE_UNUSED)
1149 #ifdef DBX_USE_BINCL
1150 struct dbx_file *n = xmalloc (sizeof *n);
1152 n->next = current_file;
1153 n->next_type_number = 1;
1154 /* Do not assign file number now.
1155 Delay it until we actually emit BINCL. */
1158 current_file->prev = n;
1159 n->bincl_status = BINCL_PENDING;
1160 n->pending_bincl_name = filename;
1166 /* Revert to reading a previous source file. Generate a N_EINCL stab. */
1169 dbxout_end_source_file (unsigned int line ATTRIBUTE_UNUSED)
1171 #ifdef DBX_USE_BINCL
1172 /* Emit EINCL stab only if BINCL is not pending. */
1173 if (current_file->bincl_status == BINCL_PROCESSED)
1175 dbxout_begin_stabn (N_EINCL);
1176 dbxout_stab_value_zero ();
1178 current_file->bincl_status = BINCL_NOT_REQUIRED;
1179 current_file = current_file->next;
1183 /* Handle a few odd cases that occur when trying to make PCH files work. */
1186 dbxout_handle_pch (unsigned at_end)
1190 /* When using the PCH, this file will be included, so we need to output
1192 dbxout_start_source_file (0, lastfile);
1194 /* The base file when using the PCH won't be the same as
1195 the base file when it's being generated. */
1200 /* ... and an EINCL. */
1201 dbxout_end_source_file (0);
1203 /* Deal with cases where 'lastfile' was never actually changed. */
1204 lastfile_is_base = lastfile == NULL;
1208 #if defined (DBX_DEBUGGING_INFO)
1209 /* Output debugging info to FILE to switch to sourcefile FILENAME. */
1212 dbxout_source_file (const char *filename)
1214 if (lastfile == 0 && lastfile_is_base)
1216 lastfile = base_input_file;
1217 lastfile_is_base = 0;
1220 if (filename && (lastfile == 0 || strcmp (filename, lastfile)))
1222 /* Don't change section amid function. */
1223 if (current_function_decl == NULL_TREE)
1226 dbxout_begin_simple_stabs (filename, N_SOL);
1227 dbxout_stab_value_internal_label ("Ltext", &source_label_number);
1228 lastfile = filename;
1232 /* Output N_BNSYM and line number symbol entry. */
1235 dbxout_begin_prologue (unsigned int lineno, const char *filename)
1237 if (use_gnu_debug_info_extensions
1238 && !NO_DBX_FUNCTION_END
1239 && !NO_DBX_BNSYM_ENSYM
1240 && !flag_debug_only_used_symbols)
1241 dbxout_stabd (N_BNSYM, 0);
1243 dbxout_source_line (lineno, filename);
1246 /* Output a line number symbol entry for source file FILENAME and line
1250 dbxout_source_line (unsigned int lineno, const char *filename)
1252 dbxout_source_file (filename);
1254 #ifdef DBX_OUTPUT_SOURCE_LINE
1255 DBX_OUTPUT_SOURCE_LINE (asm_out_file, lineno, dbxout_source_line_counter);
1257 if (DBX_LINES_FUNCTION_RELATIVE)
1259 rtx begin_label = XEXP (DECL_RTL (current_function_decl), 0);
1260 dbxout_begin_stabn_sline (lineno);
1261 dbxout_stab_value_internal_label_diff ("LM", &dbxout_source_line_counter,
1262 XSTR (begin_label, 0));
1266 dbxout_stabd (N_SLINE, lineno);
1270 /* Describe the beginning of an internal block within a function. */
1273 dbxout_begin_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int n)
1275 emit_pending_bincls_if_required ();
1276 targetm.asm_out.internal_label (asm_out_file, "LBB", n);
1279 /* Describe the end line-number of an internal block within a function. */
1282 dbxout_end_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int n)
1284 emit_pending_bincls_if_required ();
1285 targetm.asm_out.internal_label (asm_out_file, "LBE", n);
1288 /* Output dbx data for a function definition.
1289 This includes a definition of the function name itself (a symbol),
1290 definitions of the parameters (locating them in the parameter list)
1291 and then output the block that makes up the function's body
1292 (including all the auto variables of the function). */
1295 dbxout_function_decl (tree decl)
1297 emit_pending_bincls_if_required ();
1298 #ifndef DBX_FUNCTION_FIRST
1299 dbxout_begin_function (decl);
1301 dbxout_block (DECL_INITIAL (decl), 0, DECL_ARGUMENTS (decl));
1302 dbxout_function_end (decl);
1305 #endif /* DBX_DEBUGGING_INFO */
1307 /* Debug information for a global DECL. Called from toplev.c after
1308 compilation proper has finished. */
1310 dbxout_global_decl (tree decl)
1312 if (TREE_CODE (decl) == VAR_DECL
1313 && ! DECL_EXTERNAL (decl)
1314 && DECL_RTL_SET_P (decl)) /* Not necessary? */
1316 int saved_tree_used = TREE_USED (decl);
1317 TREE_USED (decl) = 1;
1318 dbxout_symbol (decl, 0);
1319 TREE_USED (decl) = saved_tree_used;
1323 /* This is just a function-type adapter; dbxout_symbol does exactly
1324 what we want but returns an int. */
1326 dbxout_type_decl (tree decl, int local)
1328 dbxout_symbol (decl, local);
1331 /* At the end of compilation, finish writing the symbol table.
1332 The default is to call debug_free_queue but do nothing else. */
1335 dbxout_finish (const char *filename ATTRIBUTE_UNUSED)
1337 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
1338 DBX_OUTPUT_MAIN_SOURCE_FILE_END (asm_out_file, filename);
1339 #elif defined DBX_OUTPUT_NULL_N_SO_AT_MAIN_SOURCE_FILE_END
1342 dbxout_begin_empty_stabs (N_SO);
1343 dbxout_stab_value_internal_label ("Letext", 0);
1346 debug_free_queue ();
1349 /* Output the index of a type. */
1352 dbxout_type_index (tree type)
1354 #ifndef DBX_USE_BINCL
1355 stabstr_D (TYPE_SYMTAB_ADDRESS (type));
1357 struct typeinfo *t = &typevec[TYPE_SYMTAB_ADDRESS (type)];
1359 stabstr_D (t->file_number);
1361 stabstr_D (t->type_number);
1368 /* Used in several places: evaluates to '0' for a private decl,
1369 '1' for a protected decl, '2' for a public decl. */
1370 #define DECL_ACCESSIBILITY_CHAR(DECL) \
1371 (TREE_PRIVATE (DECL) ? '0' : TREE_PROTECTED (DECL) ? '1' : '2')
1373 /* Subroutine of `dbxout_type'. Output the type fields of TYPE.
1374 This must be a separate function because anonymous unions require
1378 dbxout_type_fields (tree type)
1382 /* Output the name, type, position (in bits), size (in bits) of each
1383 field that we can support. */
1384 for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
1386 /* If one of the nodes is an error_mark or its type is then
1388 if (tem == error_mark_node || TREE_TYPE (tem) == error_mark_node)
1391 /* Omit here local type decls until we know how to support them. */
1392 if (TREE_CODE (tem) == TYPE_DECL
1393 /* Omit fields whose position or size are variable or too large to
1395 || (TREE_CODE (tem) == FIELD_DECL
1396 && (! host_integerp (bit_position (tem), 0)
1397 || ! DECL_SIZE (tem)
1398 || ! host_integerp (DECL_SIZE (tem), 1)))
1399 /* Omit here the nameless fields that are used to skip bits. */
1400 || DECL_IGNORED_P (tem))
1403 else if (TREE_CODE (tem) != CONST_DECL)
1405 /* Continue the line if necessary,
1406 but not before the first field. */
1407 if (tem != TYPE_FIELDS (type))
1410 if (DECL_NAME (tem))
1411 stabstr_I (DECL_NAME (tem));
1414 if (use_gnu_debug_info_extensions
1415 && (TREE_PRIVATE (tem) || TREE_PROTECTED (tem)
1416 || TREE_CODE (tem) != FIELD_DECL))
1418 have_used_extensions = 1;
1420 stabstr_C (DECL_ACCESSIBILITY_CHAR (tem));
1423 dbxout_type ((TREE_CODE (tem) == FIELD_DECL
1424 && DECL_BIT_FIELD_TYPE (tem))
1425 ? DECL_BIT_FIELD_TYPE (tem) : TREE_TYPE (tem), 0);
1427 if (TREE_CODE (tem) == VAR_DECL)
1429 if (TREE_STATIC (tem) && use_gnu_debug_info_extensions)
1431 tree name = DECL_ASSEMBLER_NAME (tem);
1433 have_used_extensions = 1;
1439 /* If TEM is non-static, GDB won't understand it. */
1440 stabstr_S (",0,0;");
1445 stabstr_D (int_bit_position (tem));
1447 stabstr_D (tree_low_cst (DECL_SIZE (tem), 1));
1454 /* Subroutine of `dbxout_type_methods'. Output debug info about the
1455 method described DECL. */
1458 dbxout_type_method_1 (tree decl)
1462 if (TREE_CODE (TREE_TYPE (decl)) == FUNCTION_TYPE)
1464 else /* it's a METHOD_TYPE. */
1466 tree firstarg = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)));
1467 /* A for normal functions.
1468 B for `const' member functions.
1469 C for `volatile' member functions.
1470 D for `const volatile' member functions. */
1471 if (TYPE_READONLY (TREE_TYPE (firstarg)))
1473 if (TYPE_VOLATILE (TREE_TYPE (firstarg)))
1476 if (DECL_VINDEX (decl))
1482 /* ??? Output the mangled name, which contains an encoding of the
1483 method's type signature. May not be necessary anymore. */
1485 stabstr_I (DECL_ASSEMBLER_NAME (decl));
1487 stabstr_C (DECL_ACCESSIBILITY_CHAR (decl));
1491 if (DECL_VINDEX (decl) && host_integerp (DECL_VINDEX (decl), 0))
1493 stabstr_D (tree_low_cst (DECL_VINDEX (decl), 0));
1495 dbxout_type (DECL_CONTEXT (decl), 0);
1500 /* Subroutine of `dbxout_type'. Output debug info about the methods defined
1504 dbxout_type_methods (tree type)
1506 /* C++: put out the method names and their parameter lists */
1507 tree methods = TYPE_METHODS (type);
1511 if (methods == NULL_TREE)
1514 if (TREE_CODE (methods) != TREE_VEC)
1516 else if (TREE_VEC_ELT (methods, 0) != NULL_TREE)
1517 fndecl = TREE_VEC_ELT (methods, 0);
1519 fndecl = TREE_VEC_ELT (methods, 1);
1523 int need_prefix = 1;
1525 /* Group together all the methods for the same operation.
1526 These differ in the types of the arguments. */
1527 for (last = NULL_TREE;
1528 fndecl && (last == NULL_TREE || DECL_NAME (fndecl) == DECL_NAME (last));
1529 fndecl = TREE_CHAIN (fndecl))
1530 /* Output the name of the field (after overloading), as
1531 well as the name of the field before overloading, along
1532 with its parameter list */
1534 /* Skip methods that aren't FUNCTION_DECLs. (In C++, these
1535 include TEMPLATE_DECLs.) The debugger doesn't know what
1536 to do with such entities anyhow. */
1537 if (TREE_CODE (fndecl) != FUNCTION_DECL)
1544 /* Also ignore abstract methods; those are only interesting to
1545 the DWARF backends. */
1546 if (DECL_IGNORED_P (fndecl) || DECL_ABSTRACT (fndecl))
1549 /* Redundantly output the plain name, since that's what gdb
1553 stabstr_I (DECL_NAME (fndecl));
1558 dbxout_type (TREE_TYPE (fndecl), 0);
1559 dbxout_type_method_1 (fndecl);
1566 /* Emit a "range" type specification, which has the form:
1567 "r<index type>;<lower bound>;<upper bound>;".
1568 TYPE is an INTEGER_TYPE. */
1571 dbxout_range_type (tree type)
1574 if (TREE_TYPE (type))
1575 dbxout_type (TREE_TYPE (type), 0);
1576 else if (TREE_CODE (type) != INTEGER_TYPE)
1577 dbxout_type (type, 0); /* E.g. Pascal's ARRAY [BOOLEAN] of INTEGER */
1580 /* Traditionally, we made sure 'int' was type 1, and builtin types
1581 were defined to be sub-ranges of int. Unfortunately, this
1582 does not allow us to distinguish true sub-ranges from integer
1583 types. So, instead we define integer (non-sub-range) types as
1584 sub-ranges of themselves. This matters for Chill. If this isn't
1585 a subrange type, then we want to define it in terms of itself.
1586 However, in C, this may be an anonymous integer type, and we don't
1587 want to emit debug info referring to it. Just calling
1588 dbxout_type_index won't work anyways, because the type hasn't been
1589 defined yet. We make this work for both cases by checked to see
1590 whether this is a defined type, referring to it if it is, and using
1592 if (TYPE_SYMTAB_ADDRESS (type) != 0)
1593 dbxout_type_index (type);
1595 dbxout_type_index (integer_type_node);
1599 if (TYPE_MIN_VALUE (type) != 0
1600 && host_integerp (TYPE_MIN_VALUE (type), 0))
1602 if (print_int_cst_bounds_in_octal_p (type))
1603 stabstr_O (TYPE_MIN_VALUE (type));
1605 stabstr_D (tree_low_cst (TYPE_MIN_VALUE (type), 0));
1611 if (TYPE_MAX_VALUE (type) != 0
1612 && host_integerp (TYPE_MAX_VALUE (type), 0))
1614 if (print_int_cst_bounds_in_octal_p (type))
1615 stabstr_O (TYPE_MAX_VALUE (type));
1617 stabstr_D (tree_low_cst (TYPE_MAX_VALUE (type), 0));
1625 /* Output a reference to a type. If the type has not yet been
1626 described in the dbx output, output its definition now.
1627 For a type already defined, just refer to its definition
1628 using the type number.
1630 If FULL is nonzero, and the type has been described only with
1631 a forward-reference, output the definition now.
1632 If FULL is zero in this case, just refer to the forward-reference
1633 using the number previously allocated. */
1636 dbxout_type (tree type, int full)
1640 static int anonymous_type_number = 0;
1642 if (TREE_CODE (type) == VECTOR_TYPE)
1643 /* The frontend feeds us a representation for the vector as a struct
1644 containing an array. Pull out the array type. */
1645 type = TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type)));
1647 /* If there was an input error and we don't really have a type,
1648 avoid crashing and write something that is at least valid
1649 by assuming `int'. */
1650 if (type == error_mark_node)
1651 type = integer_type_node;
1654 if (TYPE_NAME (type)
1655 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1656 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type)))
1660 /* Try to find the "main variant" with the same name. */
1661 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1662 && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
1663 main_variant = TREE_TYPE (TYPE_NAME (type));
1665 main_variant = TYPE_MAIN_VARIANT (type);
1667 /* If we are not using extensions, stabs does not distinguish const and
1668 volatile, so there is no need to make them separate types. */
1669 if (!use_gnu_debug_info_extensions)
1670 type = main_variant;
1672 if (TYPE_SYMTAB_ADDRESS (type) == 0)
1674 /* Type has no dbx number assigned. Assign next available number. */
1675 TYPE_SYMTAB_ADDRESS (type) = next_type_number++;
1677 /* Make sure type vector is long enough to record about this type. */
1679 if (next_type_number == typevec_len)
1682 = ggc_realloc (typevec, (typevec_len * 2 * sizeof typevec[0]));
1683 memset (typevec + typevec_len, 0, typevec_len * sizeof typevec[0]);
1687 #ifdef DBX_USE_BINCL
1688 emit_pending_bincls_if_required ();
1689 typevec[TYPE_SYMTAB_ADDRESS (type)].file_number
1690 = current_file->file_number;
1691 typevec[TYPE_SYMTAB_ADDRESS (type)].type_number
1692 = current_file->next_type_number++;
1696 if (flag_debug_only_used_symbols)
1698 if ((TREE_CODE (type) == RECORD_TYPE
1699 || TREE_CODE (type) == UNION_TYPE
1700 || TREE_CODE (type) == QUAL_UNION_TYPE
1701 || TREE_CODE (type) == ENUMERAL_TYPE)
1702 && TYPE_STUB_DECL (type)
1703 && DECL_P (TYPE_STUB_DECL (type))
1704 && ! DECL_IGNORED_P (TYPE_STUB_DECL (type)))
1705 debug_queue_symbol (TYPE_STUB_DECL (type));
1706 else if (TYPE_NAME (type)
1707 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
1708 debug_queue_symbol (TYPE_NAME (type));
1711 /* Output the number of this type, to refer to it. */
1712 dbxout_type_index (type);
1714 #ifdef DBX_TYPE_DEFINED
1715 if (DBX_TYPE_DEFINED (type))
1719 /* If this type's definition has been output or is now being output,
1722 switch (typevec[TYPE_SYMTAB_ADDRESS (type)].status)
1727 /* If we have already had a cross reference,
1728 and either that's all we want or that's the best we could do,
1729 don't repeat the cross reference.
1730 Sun dbx crashes if we do. */
1731 if (! full || !COMPLETE_TYPE_P (type)
1732 /* No way in DBX fmt to describe a variable size. */
1733 || ! host_integerp (TYPE_SIZE (type), 1))
1741 /* For systems where dbx output does not allow the `=xsNAME:' syntax,
1742 leave the type-number completely undefined rather than output
1743 a cross-reference. If we have already used GNU debug info extensions,
1744 then it is OK to output a cross reference. This is necessary to get
1745 proper C++ debug output. */
1746 if ((TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE
1747 || TREE_CODE (type) == QUAL_UNION_TYPE
1748 || TREE_CODE (type) == ENUMERAL_TYPE)
1749 && ! use_gnu_debug_info_extensions)
1750 /* We must use the same test here as we use twice below when deciding
1751 whether to emit a cross-reference. */
1752 if ((TYPE_NAME (type) != 0
1753 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1754 && DECL_IGNORED_P (TYPE_NAME (type)))
1756 || !COMPLETE_TYPE_P (type)
1757 /* No way in DBX fmt to describe a variable size. */
1758 || ! host_integerp (TYPE_SIZE (type), 1))
1760 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
1765 /* Output a definition now. */
1768 /* Mark it as defined, so that if it is self-referent
1769 we will not get into an infinite recursion of definitions. */
1771 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_DEFINED;
1773 /* If this type is a variant of some other, hand off. Types with
1774 different names are usefully distinguished. We only distinguish
1775 cv-qualified types if we're using extensions. */
1776 if (TYPE_READONLY (type) > TYPE_READONLY (main_variant))
1779 dbxout_type (build_type_variant (type, 0, TYPE_VOLATILE (type)), 0);
1782 else if (TYPE_VOLATILE (type) > TYPE_VOLATILE (main_variant))
1785 dbxout_type (build_type_variant (type, TYPE_READONLY (type), 0), 0);
1788 else if (main_variant != TYPE_MAIN_VARIANT (type))
1790 if (flag_debug_only_used_symbols)
1792 tree orig_type = DECL_ORIGINAL_TYPE (TYPE_NAME (type));
1794 if ((TREE_CODE (orig_type) == RECORD_TYPE
1795 || TREE_CODE (orig_type) == UNION_TYPE
1796 || TREE_CODE (orig_type) == QUAL_UNION_TYPE
1797 || TREE_CODE (orig_type) == ENUMERAL_TYPE)
1798 && TYPE_STUB_DECL (orig_type)
1799 && ! DECL_IGNORED_P (TYPE_STUB_DECL (orig_type)))
1800 debug_queue_symbol (TYPE_STUB_DECL (orig_type));
1802 /* 'type' is a typedef; output the type it refers to. */
1803 dbxout_type (DECL_ORIGINAL_TYPE (TYPE_NAME (type)), 0);
1806 /* else continue. */
1808 switch (TREE_CODE (type))
1812 /* For a void type, just define it as itself; i.e., "5=5".
1813 This makes us consider it defined
1814 without saying what it is. The debugger will make it
1815 a void type when the reference is seen, and nothing will
1816 ever override that default. */
1817 dbxout_type_index (type);
1821 if (type == char_type_node && ! TYPE_UNSIGNED (type))
1823 /* Output the type `char' as a subrange of itself!
1824 I don't understand this definition, just copied it
1825 from the output of pcc.
1826 This used to use `r2' explicitly and we used to
1827 take care to make sure that `char' was type number 2. */
1829 dbxout_type_index (type);
1830 stabstr_S (";0;127;");
1833 /* If this is a subtype of another integer type, always prefer to
1834 write it as a subtype. */
1835 else if (TREE_TYPE (type) != 0
1836 && TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE)
1838 /* If the size is non-standard, say what it is if we can use
1841 if (use_gnu_debug_info_extensions
1842 && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
1844 have_used_extensions = 1;
1846 stabstr_D (TYPE_PRECISION (type));
1850 dbxout_range_type (type);
1855 /* If the size is non-standard, say what it is if we can use
1858 if (use_gnu_debug_info_extensions
1859 && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
1861 have_used_extensions = 1;
1863 stabstr_D (TYPE_PRECISION (type));
1867 if (print_int_cst_bounds_in_octal_p (type))
1871 /* If this type derives from another type, output type index of
1872 parent type. This is particularly important when parent type
1873 is an enumerated type, because not generating the parent type
1874 index would transform the definition of this enumerated type
1875 into a plain unsigned type. */
1876 if (TREE_TYPE (type) != 0)
1877 dbxout_type_index (TREE_TYPE (type));
1879 dbxout_type_index (type);
1882 stabstr_O (TYPE_MIN_VALUE (type));
1884 stabstr_O (TYPE_MAX_VALUE (type));
1889 /* Output other integer types as subranges of `int'. */
1890 dbxout_range_type (type);
1896 /* This used to say `r1' and we used to take care
1897 to make sure that `int' was type number 1. */
1899 dbxout_type_index (integer_type_node);
1901 stabstr_D (int_size_in_bytes (type));
1906 if (use_gnu_debug_info_extensions)
1908 have_used_extensions = 1;
1910 stabstr_D (BITS_PER_UNIT * int_size_in_bytes (type));
1911 stabstr_S (";-20;");
1915 /* Output the type `char' as a subrange of itself.
1916 That is what pcc seems to do. */
1918 dbxout_type_index (char_type_node);
1919 stabstr_S (TYPE_UNSIGNED (type) ? ";0;255;" : ";0;127;");
1924 if (use_gnu_debug_info_extensions)
1926 have_used_extensions = 1;
1928 stabstr_D (BITS_PER_UNIT * int_size_in_bytes (type));
1929 stabstr_S (";-16;");
1931 else /* Define as enumeral type (False, True) */
1932 stabstr_S ("eFalse:0,True:1,;");
1936 /* Differs from the REAL_TYPE by its new data type number.
1937 R3 is NF_COMPLEX. We don't try to use any of the other NF_*
1938 codes since gdb doesn't care anyway. */
1940 if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
1943 stabstr_D (2 * int_size_in_bytes (TREE_TYPE (type)));
1948 /* Output a complex integer type as a structure,
1949 pending some other way to do it. */
1951 stabstr_D (int_size_in_bytes (type));
1953 stabstr_S ("real:");
1954 dbxout_type (TREE_TYPE (type), 0);
1956 stabstr_D (TYPE_PRECISION (TREE_TYPE (type)));
1958 stabstr_S (";imag:");
1959 dbxout_type (TREE_TYPE (type), 0);
1961 stabstr_D (TYPE_PRECISION (TREE_TYPE (type)));
1963 stabstr_D (TYPE_PRECISION (TREE_TYPE (type)));
1969 /* Make arrays of packed bits look like bitstrings for chill. */
1970 if (TYPE_PACKED (type) && use_gnu_debug_info_extensions)
1972 have_used_extensions = 1;
1974 stabstr_D (BITS_PER_UNIT * int_size_in_bytes (type));
1975 stabstr_S (";@S;S");
1976 dbxout_type (TYPE_DOMAIN (type), 0);
1980 /* Output "a" followed by a range type definition
1981 for the index type of the array
1982 followed by a reference to the target-type.
1983 ar1;0;N;M for a C array of type M and size N+1. */
1984 /* Check if a character string type, which in Chill is
1985 different from an array of characters. */
1986 if (TYPE_STRING_FLAG (type) && use_gnu_debug_info_extensions)
1988 have_used_extensions = 1;
1991 tem = TYPE_DOMAIN (type);
1995 dbxout_type_index (integer_type_node);
1996 stabstr_S (";0;-1;");
2001 dbxout_range_type (tem);
2004 dbxout_type (TREE_TYPE (type), 0);
2009 case QUAL_UNION_TYPE:
2011 tree binfo = TYPE_BINFO (type);
2013 /* Output a structure type. We must use the same test here as we
2014 use in the DBX_NO_XREFS case above. */
2015 if ((TYPE_NAME (type) != 0
2016 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
2017 && DECL_IGNORED_P (TYPE_NAME (type)))
2019 || !COMPLETE_TYPE_P (type)
2020 /* No way in DBX fmt to describe a variable size. */
2021 || ! host_integerp (TYPE_SIZE (type), 1))
2023 /* If the type is just a cross reference, output one
2024 and mark the type as partially described.
2025 If it later becomes defined, we will output
2026 its real definition.
2027 If the type has a name, don't nest its definition within
2028 another type's definition; instead, output an xref
2029 and let the definition come when the name is defined. */
2030 stabstr_S ((TREE_CODE (type) == RECORD_TYPE) ? "xs" : "xu");
2031 if (TYPE_NAME (type) != 0)
2032 dbxout_type_name (type);
2036 stabstr_D (anonymous_type_number++);
2040 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
2044 /* Identify record or union, and print its size. */
2045 stabstr_C ((TREE_CODE (type) == RECORD_TYPE) ? 's' : 'u');
2046 stabstr_D (int_size_in_bytes (type));
2052 VEC (tree) *accesses = BINFO_BASE_ACCESSES (binfo);
2054 if (use_gnu_debug_info_extensions)
2056 if (BINFO_N_BASE_BINFOS (binfo))
2058 have_used_extensions = 1;
2060 stabstr_U (BINFO_N_BASE_BINFOS (binfo));
2064 for (i = 0; BINFO_BASE_ITERATE (binfo, i, child); i++)
2066 tree access = (accesses ? VEC_index (tree, accesses, i)
2067 : access_public_node);
2069 if (use_gnu_debug_info_extensions)
2071 have_used_extensions = 1;
2072 stabstr_C (BINFO_VIRTUAL_P (child) ? '1' : '0');
2073 stabstr_C (access == access_public_node ? '2' :
2074 access == access_protected_node
2076 if (BINFO_VIRTUAL_P (child)
2077 && strcmp (lang_hooks.name, "GNU C++") == 0)
2078 /* For a virtual base, print the (negative)
2079 offset within the vtable where we must look
2080 to find the necessary adjustment. */
2082 (tree_low_cst (BINFO_VPTR_FIELD (child), 0)
2085 stabstr_D (tree_low_cst (BINFO_OFFSET (child), 0)
2088 dbxout_type (BINFO_TYPE (child), 0);
2093 /* Print out the base class information with
2094 fields which have the same names at the types
2096 dbxout_type_name (BINFO_TYPE (child));
2098 dbxout_type (BINFO_TYPE (child), full);
2100 stabstr_D (tree_low_cst (BINFO_OFFSET (child), 0)
2104 (tree_low_cst (TYPE_SIZE (BINFO_TYPE (child)), 0)
2112 /* Write out the field declarations. */
2113 dbxout_type_fields (type);
2114 if (use_gnu_debug_info_extensions && TYPE_METHODS (type) != NULL_TREE)
2116 have_used_extensions = 1;
2117 dbxout_type_methods (type);
2122 if (use_gnu_debug_info_extensions && TREE_CODE (type) == RECORD_TYPE
2123 /* Avoid the ~ if we don't really need it--it confuses dbx. */
2124 && TYPE_VFIELD (type))
2126 have_used_extensions = 1;
2128 /* We need to write out info about what field this class
2129 uses as its "main" vtable pointer field, because if this
2130 field is inherited from a base class, GDB cannot necessarily
2131 figure out which field it's using in time. */
2133 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type)), 0);
2139 /* We must use the same test here as we use in the DBX_NO_XREFS case
2140 above. We simplify it a bit since an enum will never have a variable
2142 if ((TYPE_NAME (type) != 0
2143 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
2144 && DECL_IGNORED_P (TYPE_NAME (type)))
2146 || !COMPLETE_TYPE_P (type))
2149 dbxout_type_name (type);
2150 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
2154 if (use_gnu_debug_info_extensions
2155 && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
2157 have_used_extensions = 1;
2159 stabstr_D (TYPE_PRECISION (type));
2164 for (tem = TYPE_VALUES (type); tem; tem = TREE_CHAIN (tem))
2166 stabstr_I (TREE_PURPOSE (tem));
2169 if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == 0)
2170 stabstr_D (TREE_INT_CST_LOW (TREE_VALUE (tem)));
2171 else if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == -1
2172 && (HOST_WIDE_INT) TREE_INT_CST_LOW (TREE_VALUE (tem)) < 0)
2173 stabstr_D (TREE_INT_CST_LOW (TREE_VALUE (tem)));
2175 stabstr_O (TREE_VALUE (tem));
2178 if (TREE_CHAIN (tem) != 0)
2187 dbxout_type (TREE_TYPE (type), 0);
2191 if (use_gnu_debug_info_extensions)
2193 have_used_extensions = 1;
2196 /* Write the argument types out longhand. */
2197 dbxout_type (TYPE_METHOD_BASETYPE (type), 0);
2199 dbxout_type (TREE_TYPE (type), 0);
2200 dbxout_args (TYPE_ARG_TYPES (type));
2204 /* Treat it as a function type. */
2205 dbxout_type (TREE_TYPE (type), 0);
2209 if (use_gnu_debug_info_extensions)
2211 have_used_extensions = 1;
2213 dbxout_type (TYPE_OFFSET_BASETYPE (type), 0);
2215 dbxout_type (TREE_TYPE (type), 0);
2218 /* Should print as an int, because it is really just an offset. */
2219 dbxout_type (integer_type_node, 0);
2222 case REFERENCE_TYPE:
2223 if (use_gnu_debug_info_extensions)
2225 have_used_extensions = 1;
2230 dbxout_type (TREE_TYPE (type), 0);
2235 dbxout_type (TREE_TYPE (type), 0);
2243 /* Return nonzero if the given type represents an integer whose bounds
2244 should be printed in octal format. */
2247 print_int_cst_bounds_in_octal_p (tree type)
2249 /* If we can use GDB extensions and the size is wider than a long
2250 (the size used by GDB to read them) or we may have trouble writing
2251 the bounds the usual way, write them in octal. Note the test is for
2252 the *target's* size of "long", not that of the host. The host test
2253 is just to make sure we can write it out in case the host wide int
2254 is narrower than the target "long".
2256 For unsigned types, we use octal if they are the same size or larger.
2257 This is because we print the bounds as signed decimal, and hence they
2258 can't span same size unsigned types. */
2260 if (use_gnu_debug_info_extensions
2261 && TYPE_MIN_VALUE (type) != 0
2262 && TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST
2263 && TYPE_MAX_VALUE (type) != 0
2264 && TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST
2265 && (TYPE_PRECISION (type) > TYPE_PRECISION (integer_type_node)
2266 || ((TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
2267 && TYPE_UNSIGNED (type))
2268 || TYPE_PRECISION (type) > HOST_BITS_PER_WIDE_INT
2269 || (TYPE_PRECISION (type) == HOST_BITS_PER_WIDE_INT
2270 && TYPE_UNSIGNED (type))))
2276 /* Output the name of type TYPE, with no punctuation.
2277 Such names can be set up either by typedef declarations
2278 or by struct, enum and union tags. */
2281 dbxout_type_name (tree type)
2283 tree t = TYPE_NAME (type);
2286 switch (TREE_CODE (t))
2288 case IDENTIFIER_NODE:
2300 /* Output leading leading struct or class names needed for qualifying
2301 type whose scope is limited to a struct or class. */
2304 dbxout_class_name_qualifiers (tree decl)
2306 tree context = decl_type_context (decl);
2308 if (context != NULL_TREE
2309 && TREE_CODE(context) == RECORD_TYPE
2310 && TYPE_NAME (context) != 0
2311 && (TREE_CODE (TYPE_NAME (context)) == IDENTIFIER_NODE
2312 || (DECL_NAME (TYPE_NAME (context)) != 0)))
2314 tree name = TYPE_NAME (context);
2316 if (TREE_CODE (name) == TYPE_DECL)
2318 dbxout_class_name_qualifiers (name);
2319 name = DECL_NAME (name);
2326 /* Output a .stabs for the symbol defined by DECL,
2327 which must be a ..._DECL node in the normal namespace.
2328 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
2329 LOCAL is nonzero if the scope is less than the entire file.
2330 Return 1 if a stabs might have been emitted. */
2333 dbxout_symbol (tree decl, int local ATTRIBUTE_UNUSED)
2335 tree type = TREE_TYPE (decl);
2336 tree context = NULL_TREE;
2339 /* "Intercept" dbxout_symbol() calls like we do all debug_hooks. */
2342 /* Ignore nameless syms, but don't ignore type tags. */
2344 if ((DECL_NAME (decl) == 0 && TREE_CODE (decl) != TYPE_DECL)
2345 || DECL_IGNORED_P (decl))
2346 DBXOUT_DECR_NESTING_AND_RETURN (0);
2348 /* If we are to generate only the symbols actually used then such
2349 symbol nodees are flagged with TREE_USED. Ignore any that
2350 aren't flaged as TREE_USED. */
2352 if (flag_debug_only_used_symbols
2353 && (!TREE_USED (decl)
2354 && (TREE_CODE (decl) != VAR_DECL || !DECL_INITIAL (decl))))
2355 DBXOUT_DECR_NESTING_AND_RETURN (0);
2357 /* If dbxout_init has not yet run, queue this symbol for later. */
2360 preinit_symbols = tree_cons (0, decl, preinit_symbols);
2361 DBXOUT_DECR_NESTING_AND_RETURN (0);
2364 if (flag_debug_only_used_symbols)
2368 /* We now have a used symbol. We need to generate the info for
2369 the symbol's type in addition to the symbol itself. These
2370 type symbols are queued to be generated after were done with
2371 the symbol itself (otherwise they would fight over the
2374 Note, because the TREE_TYPE(type) might be something like a
2375 pointer to a named type we need to look for the first name
2376 we see following the TREE_TYPE chain. */
2379 while (POINTER_TYPE_P (t))
2382 /* RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, and ENUMERAL_TYPE
2383 need special treatment. The TYPE_STUB_DECL field in these
2384 types generally represents the tag name type we want to
2385 output. In addition there could be a typedef type with
2386 a different name. In that case we also want to output
2389 if (TREE_CODE (t) == RECORD_TYPE
2390 || TREE_CODE (t) == UNION_TYPE
2391 || TREE_CODE (t) == QUAL_UNION_TYPE
2392 || TREE_CODE (t) == ENUMERAL_TYPE)
2394 if (TYPE_STUB_DECL (t)
2395 && TYPE_STUB_DECL (t) != decl
2396 && DECL_P (TYPE_STUB_DECL (t))
2397 && ! DECL_IGNORED_P (TYPE_STUB_DECL (t)))
2399 debug_queue_symbol (TYPE_STUB_DECL (t));
2401 && TYPE_NAME (t) != TYPE_STUB_DECL (t)
2402 && TYPE_NAME (t) != decl
2403 && DECL_P (TYPE_NAME (t)))
2404 debug_queue_symbol (TYPE_NAME (t));
2407 else if (TYPE_NAME (t)
2408 && TYPE_NAME (t) != decl
2409 && DECL_P (TYPE_NAME (t)))
2410 debug_queue_symbol (TYPE_NAME (t));
2413 emit_pending_bincls_if_required ();
2415 switch (TREE_CODE (decl))
2418 /* Enum values are defined by defining the enum type. */
2422 if (DECL_RTL (decl) == 0)
2423 DBXOUT_DECR_NESTING_AND_RETURN (0);
2424 if (DECL_EXTERNAL (decl))
2426 /* Don't mention a nested function under its parent. */
2427 context = decl_function_context (decl);
2428 if (context == current_function_decl)
2430 /* Don't mention an inline instance of a nested function. */
2431 if (context && DECL_FROM_INLINE (decl))
2433 if (!MEM_P (DECL_RTL (decl))
2434 || GET_CODE (XEXP (DECL_RTL (decl), 0)) != SYMBOL_REF)
2437 dbxout_begin_complex_stabs ();
2438 stabstr_I (DECL_ASSEMBLER_NAME (decl));
2439 stabstr_S (TREE_PUBLIC (decl) ? ":F" : ":f");
2442 if (TREE_TYPE (type))
2443 dbxout_type (TREE_TYPE (type), 0);
2445 dbxout_type (void_type_node, 0);
2447 /* For a nested function, when that function is compiled,
2448 mention the containing function name
2449 as well as (since dbx wants it) our own assembler-name. */
2453 stabstr_I (DECL_ASSEMBLER_NAME (decl));
2455 stabstr_I (DECL_NAME (context));
2458 dbxout_finish_complex_stabs (decl, N_FUN, XEXP (DECL_RTL (decl), 0),
2463 /* Don't output the same typedef twice.
2464 And don't output what language-specific stuff doesn't want output. */
2465 if (TREE_ASM_WRITTEN (decl) || TYPE_DECL_SUPPRESS_DEBUG (decl))
2466 DBXOUT_DECR_NESTING_AND_RETURN (0);
2468 /* Don't output typedefs for types with magic type numbers (XCOFF). */
2469 #ifdef DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER
2471 int fundamental_type_number =
2472 DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER (decl);
2474 if (fundamental_type_number != 0)
2476 TREE_ASM_WRITTEN (decl) = 1;
2477 TYPE_SYMTAB_ADDRESS (TREE_TYPE (decl)) = fundamental_type_number;
2478 DBXOUT_DECR_NESTING_AND_RETURN (0);
2488 if (DECL_NAME (decl))
2490 /* Nonzero means we must output a tag as well as a typedef. */
2493 /* Handle the case of a C++ structure or union
2494 where the TYPE_NAME is a TYPE_DECL
2495 which gives both a typedef name and a tag. */
2496 /* dbx requires the tag first and the typedef second. */
2497 if ((TREE_CODE (type) == RECORD_TYPE
2498 || TREE_CODE (type) == UNION_TYPE
2499 || TREE_CODE (type) == QUAL_UNION_TYPE)
2500 && TYPE_NAME (type) == decl
2501 && !(use_gnu_debug_info_extensions && have_used_extensions)
2502 && !TREE_ASM_WRITTEN (TYPE_NAME (type))
2503 /* Distinguish the implicit typedefs of C++
2504 from explicit ones that might be found in C. */
2505 && DECL_ARTIFICIAL (decl)
2506 /* Do not generate a tag for incomplete records. */
2507 && COMPLETE_TYPE_P (type)
2508 /* Do not generate a tag for records of variable size,
2509 since this type can not be properly described in the
2510 DBX format, and it confuses some tools such as objdump. */
2511 && host_integerp (TYPE_SIZE (type), 1))
2513 tree name = TYPE_NAME (type);
2514 if (TREE_CODE (name) == TYPE_DECL)
2515 name = DECL_NAME (name);
2517 dbxout_begin_complex_stabs ();
2520 dbxout_type (type, 1);
2521 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE,
2525 dbxout_begin_complex_stabs ();
2527 /* Output leading class/struct qualifiers.
2528 ??? why not set have_used_extensions here ... because
2529 then the test of it below would always be true, I
2530 guess. But it's not clear to me why we shouldn't do
2531 that always in extended mode. */
2532 if (use_gnu_debug_info_extensions)
2533 dbxout_class_name_qualifiers (decl);
2535 /* Output typedef name. */
2536 stabstr_I (DECL_NAME (decl));
2539 /* Short cut way to output a tag also. */
2540 if ((TREE_CODE (type) == RECORD_TYPE
2541 || TREE_CODE (type) == UNION_TYPE
2542 || TREE_CODE (type) == QUAL_UNION_TYPE)
2543 && TYPE_NAME (type) == decl
2544 /* Distinguish the implicit typedefs of C++
2545 from explicit ones that might be found in C. */
2546 && DECL_ARTIFICIAL (decl))
2548 if (use_gnu_debug_info_extensions && have_used_extensions)
2551 TREE_ASM_WRITTEN (TYPE_NAME (type)) = 1;
2556 dbxout_type (type, 1);
2557 dbxout_finish_complex_stabs (decl, DBX_TYPE_DECL_STABS_CODE,
2562 /* Don't output a tag if this is an incomplete type. This prevents
2563 the sun4 Sun OS 4.x dbx from crashing. */
2565 if (tag_needed && TYPE_NAME (type) != 0
2566 && (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE
2567 || (DECL_NAME (TYPE_NAME (type)) != 0))
2568 && COMPLETE_TYPE_P (type)
2569 && !TREE_ASM_WRITTEN (TYPE_NAME (type)))
2571 /* For a TYPE_DECL with no name, but the type has a name,
2573 This is what represents `struct foo' with no typedef. */
2574 /* In C++, the name of a type is the corresponding typedef.
2575 In C, it is an IDENTIFIER_NODE. */
2576 tree name = TYPE_NAME (type);
2577 if (TREE_CODE (name) == TYPE_DECL)
2578 name = DECL_NAME (name);
2580 dbxout_begin_complex_stabs ();
2583 dbxout_type (type, 1);
2584 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE, 0, 0, 0);
2588 /* If an enum type has no name, it cannot be referred to, but
2589 we must output it anyway, to record the enumeration
2592 if (!did_output && TREE_CODE (type) == ENUMERAL_TYPE)
2594 dbxout_begin_complex_stabs ();
2595 /* Some debuggers fail when given NULL names, so give this a
2596 harmless name of " " (Why not "(anon)"?). */
2598 dbxout_type (type, 1);
2599 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE, 0, 0, 0);
2602 /* Prevent duplicate output of a typedef. */
2603 TREE_ASM_WRITTEN (decl) = 1;
2608 /* Parm decls go in their own separate chains
2609 and are output by dbxout_reg_parms and dbxout_parms. */
2613 /* Named return value, treat like a VAR_DECL. */
2615 if (! DECL_RTL_SET_P (decl))
2616 DBXOUT_DECR_NESTING_AND_RETURN (0);
2617 /* Don't mention a variable that is external.
2618 Let the file that defines it describe it. */
2619 if (DECL_EXTERNAL (decl))
2622 /* If the variable is really a constant
2623 and not written in memory, inform the debugger.
2625 ??? Why do we skip emitting the type and location in this case? */
2626 if (TREE_STATIC (decl) && TREE_READONLY (decl)
2627 && DECL_INITIAL (decl) != 0
2628 && host_integerp (DECL_INITIAL (decl), 0)
2629 && ! TREE_ASM_WRITTEN (decl)
2630 && (DECL_CONTEXT (decl) == NULL_TREE
2631 || TREE_CODE (DECL_CONTEXT (decl)) == BLOCK)
2632 && TREE_PUBLIC (decl) == 0)
2634 /* The sun4 assembler does not grok this. */
2636 if (TREE_CODE (TREE_TYPE (decl)) == INTEGER_TYPE
2637 || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
2639 HOST_WIDE_INT ival = TREE_INT_CST_LOW (DECL_INITIAL (decl));
2641 dbxout_begin_complex_stabs ();
2642 stabstr_I (DECL_NAME (decl));
2645 dbxout_finish_complex_stabs (0, N_LSYM, 0, 0, 0);
2646 DBXOUT_DECR_NESTING;
2652 /* else it is something we handle like a normal variable. */
2654 SET_DECL_RTL (decl, eliminate_regs (DECL_RTL (decl), 0, NULL_RTX));
2655 #ifdef LEAF_REG_REMAP
2656 if (current_function_uses_only_leaf_regs)
2657 leaf_renumber_regs_insn (DECL_RTL (decl));
2660 result = dbxout_symbol_location (decl, type, 0, DECL_RTL (decl));
2666 DBXOUT_DECR_NESTING;
2670 /* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL.
2671 Add SUFFIX to its name, if SUFFIX is not 0.
2672 Describe the variable as residing in HOME
2673 (usually HOME is DECL_RTL (DECL), but not always).
2674 Returns 1 if the stab was really emitted. */
2677 dbxout_symbol_location (tree decl, tree type, const char *suffix, rtx home)
2680 STAB_CODE_TYPE code;
2685 /* Don't mention a variable at all
2686 if it was completely optimized into nothingness.
2688 If the decl was from an inline function, then its rtl
2689 is not identically the rtl that was used in this
2690 particular compilation. */
2691 if (GET_CODE (home) == SUBREG)
2695 while (GET_CODE (value) == SUBREG)
2696 value = SUBREG_REG (value);
2699 if (REGNO (value) >= FIRST_PSEUDO_REGISTER)
2702 home = alter_subreg (&home);
2706 regno = REGNO (home);
2707 if (regno >= FIRST_PSEUDO_REGISTER)
2711 /* The kind-of-variable letter depends on where
2712 the variable is and on the scope of its name:
2713 G and N_GSYM for static storage and global scope,
2714 S for static storage and file scope,
2715 V for static storage and local scope,
2716 for those two, use N_LCSYM if data is in bss segment,
2717 N_STSYM if in data segment, N_FUN otherwise.
2718 (We used N_FUN originally, then changed to N_STSYM
2719 to please GDB. However, it seems that confused ld.
2720 Now GDB has been fixed to like N_FUN, says Kingdon.)
2721 no letter at all, and N_LSYM, for auto variable,
2722 r and N_RSYM for register variable. */
2724 if (MEM_P (home) && GET_CODE (XEXP (home, 0)) == SYMBOL_REF)
2726 if (TREE_PUBLIC (decl))
2733 addr = XEXP (home, 0);
2735 letter = decl_function_context (decl) ? 'V' : 'S';
2737 /* Some ports can transform a symbol ref into a label ref,
2738 because the symbol ref is too far away and has to be
2739 dumped into a constant pool. Alternatively, the symbol
2740 in the constant pool might be referenced by a different
2742 if (GET_CODE (addr) == SYMBOL_REF
2743 && CONSTANT_POOL_ADDRESS_P (addr))
2746 rtx tmp = get_pool_constant_mark (addr, &marked);
2748 if (GET_CODE (tmp) == SYMBOL_REF)
2751 if (CONSTANT_POOL_ADDRESS_P (addr))
2752 get_pool_constant_mark (addr, &marked);
2756 else if (GET_CODE (tmp) == LABEL_REF)
2762 /* If all references to the constant pool were optimized
2763 out, we just ignore the symbol. */
2768 /* This should be the same condition as in assemble_variable, but
2769 we don't have access to dont_output_data here. So, instead,
2770 we rely on the fact that error_mark_node initializers always
2771 end up in bss for C++ and never end up in bss for C. */
2772 if (DECL_INITIAL (decl) == 0
2773 || (!strcmp (lang_hooks.name, "GNU C++")
2774 && DECL_INITIAL (decl) == error_mark_node))
2776 else if (DECL_IN_TEXT_SECTION (decl))
2777 /* This is not quite right, but it's the closest
2778 of all the codes that Unix defines. */
2779 code = DBX_STATIC_CONST_VAR_CODE;
2782 /* Ultrix `as' seems to need this. */
2783 #ifdef DBX_STATIC_STAB_DATA_SECTION
2790 else if (regno >= 0)
2794 number = DBX_REGISTER_NUMBER (regno);
2796 else if (MEM_P (home)
2797 && (MEM_P (XEXP (home, 0))
2798 || (REG_P (XEXP (home, 0))
2799 && REGNO (XEXP (home, 0)) != HARD_FRAME_POINTER_REGNUM
2800 && REGNO (XEXP (home, 0)) != STACK_POINTER_REGNUM
2801 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2802 && REGNO (XEXP (home, 0)) != ARG_POINTER_REGNUM
2805 /* If the value is indirect by memory or by a register
2806 that isn't the frame pointer
2807 then it means the object is variable-sized and address through
2808 that register or stack slot. DBX has no way to represent this
2809 so all we can do is output the variable as a pointer.
2810 If it's not a parameter, ignore it. */
2812 if (REG_P (XEXP (home, 0)))
2816 if (REGNO (XEXP (home, 0)) >= FIRST_PSEUDO_REGISTER)
2818 number = DBX_REGISTER_NUMBER (REGNO (XEXP (home, 0)));
2823 /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
2824 We want the value of that CONST_INT. */
2825 number = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home, 0), 0));
2828 /* Effectively do build_pointer_type, but don't cache this type,
2829 since it might be temporary whereas the type it points to
2830 might have been saved for inlining. */
2831 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
2832 type = make_node (POINTER_TYPE);
2833 TREE_TYPE (type) = TREE_TYPE (decl);
2835 else if (MEM_P (home)
2836 && REG_P (XEXP (home, 0)))
2839 number = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
2841 else if (MEM_P (home)
2842 && GET_CODE (XEXP (home, 0)) == PLUS
2843 && GET_CODE (XEXP (XEXP (home, 0), 1)) == CONST_INT)
2846 /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
2847 We want the value of that CONST_INT. */
2848 number = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
2850 else if (MEM_P (home)
2851 && GET_CODE (XEXP (home, 0)) == CONST)
2853 /* Handle an obscure case which can arise when optimizing and
2854 when there are few available registers. (This is *always*
2855 the case for i386/i486 targets). The RTL looks like
2856 (MEM (CONST ...)) even though this variable is a local `auto'
2857 or a local `register' variable. In effect, what has happened
2858 is that the reload pass has seen that all assignments and
2859 references for one such a local variable can be replaced by
2860 equivalent assignments and references to some static storage
2861 variable, thereby avoiding the need for a register. In such
2862 cases we're forced to lie to debuggers and tell them that
2863 this variable was itself `static'. */
2866 addr = XEXP (XEXP (home, 0), 0);
2868 else if (GET_CODE (home) == CONCAT)
2872 /* If TYPE is not a COMPLEX_TYPE (it might be a RECORD_TYPE,
2873 for example), then there is no easy way to figure out
2874 what SUBTYPE should be. So, we give up. */
2875 if (TREE_CODE (type) != COMPLEX_TYPE)
2878 subtype = TREE_TYPE (type);
2880 /* If the variable's storage is in two parts,
2881 output each as a separate stab with a modified name. */
2882 if (WORDS_BIG_ENDIAN)
2883 dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 0));
2885 dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 0));
2887 if (WORDS_BIG_ENDIAN)
2888 dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 1));
2890 dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 1));
2894 /* Address might be a MEM, when DECL is a variable-sized object.
2895 Or it might be const0_rtx, meaning previous passes
2896 want us to ignore this variable. */
2899 /* Ok, start a symtab entry and output the variable name. */
2900 emit_pending_bincls_if_required ();
2903 #ifdef DBX_STATIC_BLOCK_START
2904 DBX_STATIC_BLOCK_START (asm_out_file, code);
2907 dbxout_begin_complex_stabs_noforcetext ();
2908 dbxout_symbol_name (decl, suffix, letter);
2909 dbxout_type (type, 0);
2910 dbxout_finish_complex_stabs (decl, code, addr, 0, number);
2912 #ifdef DBX_STATIC_BLOCK_END
2913 DBX_STATIC_BLOCK_END (asm_out_file, code);
2918 /* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
2919 Then output LETTER to indicate the kind of location the symbol has. */
2922 dbxout_symbol_name (tree decl, const char *suffix, int letter)
2926 if (DECL_CONTEXT (decl)
2927 && (TYPE_P (DECL_CONTEXT (decl))
2928 || TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL))
2929 /* One slight hitch: if this is a VAR_DECL which is a class member
2930 or a namespace member, we must put out the mangled name instead of the
2931 DECL_NAME. Note also that static member (variable) names DO NOT begin
2932 with underscores in .stabs directives. */
2933 name = DECL_ASSEMBLER_NAME (decl);
2935 /* ...but if we're function-local, we don't want to include the junk
2936 added by ASM_FORMAT_PRIVATE_NAME. */
2937 name = DECL_NAME (decl);
2942 stabstr_S ("(anon)");
2951 /* Output definitions of all the decls in a chain. Return nonzero if
2952 anything was output */
2955 dbxout_syms (tree syms)
2960 result += dbxout_symbol (syms, 1);
2961 syms = TREE_CHAIN (syms);
2966 /* The following two functions output definitions of function parameters.
2967 Each parameter gets a definition locating it in the parameter list.
2968 Each parameter that is a register variable gets a second definition
2969 locating it in the register.
2971 Printing or argument lists in gdb uses the definitions that
2972 locate in the parameter list. But reference to the variable in
2973 expressions uses preferentially the definition as a register. */
2975 /* Output definitions, referring to storage in the parmlist,
2976 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
2979 dbxout_parms (tree parms)
2982 emit_pending_bincls_if_required ();
2984 for (; parms; parms = TREE_CHAIN (parms))
2985 if (DECL_NAME (parms)
2986 && TREE_TYPE (parms) != error_mark_node
2987 && DECL_RTL_SET_P (parms)
2988 && DECL_INCOMING_RTL (parms))
2992 STAB_CODE_TYPE code;
2995 /* Perform any necessary register eliminations on the parameter's rtl,
2996 so that the debugging output will be accurate. */
2997 DECL_INCOMING_RTL (parms)
2998 = eliminate_regs (DECL_INCOMING_RTL (parms), 0, NULL_RTX);
2999 SET_DECL_RTL (parms, eliminate_regs (DECL_RTL (parms), 0, NULL_RTX));
3000 #ifdef LEAF_REG_REMAP
3001 if (current_function_uses_only_leaf_regs)
3003 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms));
3004 leaf_renumber_regs_insn (DECL_RTL (parms));
3008 if (PARM_PASSED_IN_MEMORY (parms))
3010 rtx inrtl = XEXP (DECL_INCOMING_RTL (parms), 0);
3012 /* ??? Here we assume that the parm address is indexed
3013 off the frame pointer or arg pointer.
3014 If that is not true, we produce meaningless results,
3015 but do not crash. */
3016 if (GET_CODE (inrtl) == PLUS
3017 && GET_CODE (XEXP (inrtl, 1)) == CONST_INT)
3018 number = INTVAL (XEXP (inrtl, 1));
3023 number = DEBUGGER_ARG_OFFSET (number, inrtl);
3026 /* It is quite tempting to use TREE_TYPE (parms) instead
3027 of DECL_ARG_TYPE (parms) for the eff_type, so that gcc
3028 reports the actual type of the parameter, rather than
3029 the promoted type. This certainly makes GDB's life
3030 easier, at least for some ports. The change is a bad
3031 idea however, since GDB expects to be able access the
3032 type without performing any conversions. So for
3033 example, if we were passing a float to an unprototyped
3034 function, gcc will store a double on the stack, but if
3035 we emit a stab saying the type is a float, then gdb
3036 will only read in a single value, and this will produce
3037 an erroneous value. */
3038 eff_type = DECL_ARG_TYPE (parms);
3040 else if (REG_P (DECL_RTL (parms)))
3044 /* Parm passed in registers and lives in registers or nowhere. */
3045 code = DBX_REGPARM_STABS_CODE;
3046 letter = DBX_REGPARM_STABS_LETTER;
3048 /* For parms passed in registers, it is better to use the
3049 declared type of the variable, not the type it arrived in. */
3050 eff_type = TREE_TYPE (parms);
3052 /* If parm lives in a register, use that register; pretend
3053 the parm was passed there. It would be more consistent
3054 to describe the register where the parm was passed, but
3055 in practice that register usually holds something else.
3056 If the parm lives nowhere, use the register where it
3058 if (REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
3059 best_rtl = DECL_RTL (parms);
3061 best_rtl = DECL_INCOMING_RTL (parms);
3063 number = DBX_REGISTER_NUMBER (REGNO (best_rtl));
3065 else if (MEM_P (DECL_RTL (parms))
3066 && REG_P (XEXP (DECL_RTL (parms), 0))
3067 && REGNO (XEXP (DECL_RTL (parms), 0)) != HARD_FRAME_POINTER_REGNUM
3068 && REGNO (XEXP (DECL_RTL (parms), 0)) != STACK_POINTER_REGNUM
3069 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
3070 && REGNO (XEXP (DECL_RTL (parms), 0)) != ARG_POINTER_REGNUM
3074 /* Parm was passed via invisible reference.
3075 That is, its address was passed in a register.
3076 Output it as if it lived in that register.
3077 The debugger will know from the type
3078 that it was actually passed by invisible reference. */
3080 code = DBX_REGPARM_STABS_CODE;
3082 /* GDB likes this marked with a special letter. */
3083 letter = (use_gnu_debug_info_extensions
3084 ? 'a' : DBX_REGPARM_STABS_LETTER);
3085 eff_type = TREE_TYPE (parms);
3087 /* DECL_RTL looks like (MEM (REG...). Get the register number.
3088 If it is an unallocated pseudo-reg, then use the register where
3089 it was passed instead.
3090 ??? Why is DBX_REGISTER_NUMBER not used here? */
3092 if (REGNO (XEXP (DECL_RTL (parms), 0)) < FIRST_PSEUDO_REGISTER)
3093 number = REGNO (XEXP (DECL_RTL (parms), 0));
3095 number = REGNO (DECL_INCOMING_RTL (parms));
3097 else if (MEM_P (DECL_RTL (parms))
3098 && MEM_P (XEXP (DECL_RTL (parms), 0)))
3100 /* Parm was passed via invisible reference, with the reference
3101 living on the stack. DECL_RTL looks like
3102 (MEM (MEM (PLUS (REG ...) (CONST_INT ...)))) or it
3103 could look like (MEM (MEM (REG))). */
3107 eff_type = TREE_TYPE (parms);
3109 if (!REG_P (XEXP (XEXP (DECL_RTL (parms), 0), 0)))
3110 number = INTVAL (XEXP (XEXP (XEXP (DECL_RTL (parms), 0), 0), 1));
3114 number = DEBUGGER_ARG_OFFSET (number,
3115 XEXP (XEXP (DECL_RTL (parms), 0), 0));
3117 else if (MEM_P (DECL_RTL (parms))
3118 && XEXP (DECL_RTL (parms), 0) != const0_rtx
3119 /* ??? A constant address for a parm can happen
3120 when the reg it lives in is equiv to a constant in memory.
3121 Should make this not happen, after 2.4. */
3122 && ! CONSTANT_P (XEXP (DECL_RTL (parms), 0)))
3124 /* Parm was passed in registers but lives on the stack. */
3128 eff_type = TREE_TYPE (parms);
3130 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
3131 in which case we want the value of that CONST_INT,
3133 in which case we use a value of zero. */
3134 if (!REG_P (XEXP (DECL_RTL (parms), 0)))
3135 number = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1));
3139 /* Make a big endian correction if the mode of the type of the
3140 parameter is not the same as the mode of the rtl. */
3141 if (BYTES_BIG_ENDIAN
3142 && TYPE_MODE (TREE_TYPE (parms)) != GET_MODE (DECL_RTL (parms))
3143 && GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms))) < UNITS_PER_WORD)
3144 number += (GET_MODE_SIZE (GET_MODE (DECL_RTL (parms)))
3145 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms))));
3148 /* ??? We don't know how to represent this argument. */
3151 dbxout_begin_complex_stabs ();
3153 if (DECL_NAME (parms))
3155 stabstr_I (DECL_NAME (parms));
3159 stabstr_S ("(anon):");
3161 dbxout_type (eff_type, 0);
3162 dbxout_finish_complex_stabs (parms, code, 0, 0, number);
3164 DBXOUT_DECR_NESTING;
3167 /* Output definitions for the places where parms live during the function,
3168 when different from where they were passed, when the parms were passed
3171 It is not useful to do this for parms passed in registers
3172 that live during the function in different registers, because it is
3173 impossible to look in the passed register for the passed value,
3174 so we use the within-the-function register to begin with.
3176 PARMS is a chain of PARM_DECL nodes. */
3179 dbxout_reg_parms (tree parms)
3183 for (; parms; parms = TREE_CHAIN (parms))
3184 if (DECL_NAME (parms) && PARM_PASSED_IN_MEMORY (parms))
3186 /* Report parms that live in registers during the function
3187 but were passed in memory. */
3188 if (REG_P (DECL_RTL (parms))
3189 && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
3190 dbxout_symbol_location (parms, TREE_TYPE (parms),
3191 0, DECL_RTL (parms));
3192 else if (GET_CODE (DECL_RTL (parms)) == CONCAT)
3193 dbxout_symbol_location (parms, TREE_TYPE (parms),
3194 0, DECL_RTL (parms));
3195 /* Report parms that live in memory but not where they were passed. */
3196 else if (MEM_P (DECL_RTL (parms))
3197 && ! rtx_equal_p (DECL_RTL (parms), DECL_INCOMING_RTL (parms)))
3198 dbxout_symbol_location (parms, TREE_TYPE (parms),
3199 0, DECL_RTL (parms));
3201 DBXOUT_DECR_NESTING;
3204 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
3205 output definitions of those names, in raw form */
3208 dbxout_args (tree args)
3213 dbxout_type (TREE_VALUE (args), 0);
3214 args = TREE_CHAIN (args);
3218 /* Subroutine of dbxout_block. Emit an N_LBRAC stab referencing LABEL.
3219 BEGIN_LABEL is the name of the beginning of the function, which may
3222 dbx_output_lbrac (const char *label,
3223 const char *begin_label ATTRIBUTE_UNUSED)
3225 #ifdef DBX_OUTPUT_LBRAC
3226 DBX_OUTPUT_LBRAC (asm_out_file, label);
3228 dbxout_begin_stabn (N_LBRAC);
3229 if (DBX_BLOCKS_FUNCTION_RELATIVE)
3230 dbxout_stab_value_label_diff (label, begin_label);
3232 dbxout_stab_value_label (label);
3236 /* Subroutine of dbxout_block. Emit an N_RBRAC stab referencing LABEL.
3237 BEGIN_LABEL is the name of the beginning of the function, which may
3240 dbx_output_rbrac (const char *label,
3241 const char *begin_label ATTRIBUTE_UNUSED)
3243 #ifdef DBX_OUTPUT_RBRAC
3244 DBX_OUTPUT_RBRAC (asm_out_file, label);
3246 dbxout_begin_stabn (N_RBRAC);
3247 if (DBX_BLOCKS_FUNCTION_RELATIVE)
3248 dbxout_stab_value_label_diff (label, begin_label);
3250 dbxout_stab_value_label (label);
3254 /* Output everything about a symbol block (a BLOCK node
3255 that represents a scope level),
3256 including recursive output of contained blocks.
3258 BLOCK is the BLOCK node.
3259 DEPTH is its depth within containing symbol blocks.
3260 ARGS is usually zero; but for the outermost block of the
3261 body of a function, it is a chain of PARM_DECLs for the function parameters.
3262 We output definitions of all the register parms
3263 as if they were local variables of that block.
3265 If -g1 was used, we count blocks just the same, but output nothing
3266 except for the outermost block.
3268 Actually, BLOCK may be several blocks chained together.
3269 We handle them all in sequence. */
3272 dbxout_block (tree block, int depth, tree args)
3274 const char *begin_label
3275 = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0);
3279 /* Ignore blocks never expanded or otherwise marked as real. */
3280 if (TREE_USED (block) && TREE_ASM_WRITTEN (block))
3283 int blocknum = BLOCK_NUMBER (block);
3285 /* In dbx format, the syms of a block come before the N_LBRAC.
3286 If nothing is output, we don't need the N_LBRAC, either. */
3288 if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
3289 did_output = dbxout_syms (BLOCK_VARS (block));
3291 dbxout_reg_parms (args);
3293 /* Now output an N_LBRAC symbol to represent the beginning of
3294 the block. Use the block's tree-walk order to generate
3295 the assembler symbols LBBn and LBEn
3296 that final will define around the code in this block. */
3300 const char *scope_start;
3303 /* The outermost block doesn't get LBB labels; use
3304 the function symbol. */
3305 scope_start = begin_label;
3308 ASM_GENERATE_INTERNAL_LABEL (buf, "LBB", blocknum);
3312 if (BLOCK_HANDLER_BLOCK (block))
3314 /* A catch block. Must precede N_LBRAC. */
3315 tree decl = BLOCK_VARS (block);
3318 dbxout_begin_complex_stabs ();
3319 stabstr_I (DECL_NAME (decl));
3321 dbxout_finish_complex_stabs (0, N_CATCH, 0,
3323 decl = TREE_CHAIN (decl);
3326 dbx_output_lbrac (scope_start, begin_label);
3329 /* Output the subblocks. */
3330 dbxout_block (BLOCK_SUBBLOCKS (block), depth + 1, NULL_TREE);
3332 /* Refer to the marker for the end of the block. */
3337 /* The outermost block doesn't get LBE labels;
3338 use the "scope" label which will be emitted
3339 by dbxout_function_end. */
3340 ASM_GENERATE_INTERNAL_LABEL (buf, "Lscope", scope_labelno);
3342 ASM_GENERATE_INTERNAL_LABEL (buf, "LBE", blocknum);
3344 dbx_output_rbrac (buf, begin_label);
3347 block = BLOCK_CHAIN (block);
3351 /* Output the information about a function and its arguments and result.
3352 Usually this follows the function's code,
3353 but on some systems, it comes before. */
3355 #if defined (DBX_DEBUGGING_INFO)
3357 dbxout_begin_function (tree decl)
3359 int saved_tree_used1;
3361 if (DECL_IGNORED_P (decl))
3364 saved_tree_used1 = TREE_USED (decl);
3365 TREE_USED (decl) = 1;
3366 if (DECL_NAME (DECL_RESULT (decl)) != 0)
3368 int saved_tree_used2 = TREE_USED (DECL_RESULT (decl));
3369 TREE_USED (DECL_RESULT (decl)) = 1;
3370 dbxout_symbol (decl, 0);
3371 TREE_USED (DECL_RESULT (decl)) = saved_tree_used2;
3374 dbxout_symbol (decl, 0);
3375 TREE_USED (decl) = saved_tree_used1;
3377 dbxout_parms (DECL_ARGUMENTS (decl));
3378 if (DECL_NAME (DECL_RESULT (decl)) != 0)
3379 dbxout_symbol (DECL_RESULT (decl), 1);
3381 #endif /* DBX_DEBUGGING_INFO */
3383 #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */
3385 #include "gt-dbxout.h"