1 /* Output dbx-format symbol table information from GNU compiler.
2 Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
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 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
23 /* Output dbx-format symbol table data.
24 This consists of many symbol table entries, each of them
25 a .stabs assembler pseudo-op with four operands:
26 a "name" which is really a description of one symbol and its type,
27 a "code", which is a symbol defined in stab.h whose name starts with N_,
28 an unused operand always 0,
29 and a "value" which is an address or an offset.
30 The name is enclosed in doublequote characters.
32 Each function, variable, typedef, and structure tag
33 has a symbol table entry to define it.
34 The beginning and end of each level of name scoping within
35 a function are also marked by special symbol table entries.
37 The "name" consists of the symbol name, a colon, a kind-of-symbol letter,
38 and a data type number. The data type number may be followed by
39 "=" and a type definition; normally this will happen the first time
40 the type number is mentioned. The type definition may refer to
41 other types by number, and those type numbers may be followed
42 by "=" and nested definitions.
44 This can make the "name" quite long.
45 When a name is more than 80 characters, we split the .stabs pseudo-op
46 into two .stabs pseudo-ops, both sharing the same "code" and "value".
47 The first one is marked as continued with a double-backslash at the
50 The kind-of-symbol letter distinguished function names from global
51 variables from file-scope variables from parameters from auto
52 variables in memory from typedef names from register variables.
55 The "code" is mostly redundant with the kind-of-symbol letter
56 that goes in the "name", but not entirely: for symbols located
57 in static storage, the "code" says which segment the address is in,
58 which controls how it is relocated.
60 The "value" for a symbol in static storage
61 is the core address of the symbol (actually, the assembler
62 label for the symbol). For a symbol located in a stack slot
63 it is the stack offset; for one in a register, the register number.
64 For a typedef symbol, it is zero.
66 If DEBUG_SYMS_TEXT is defined, all debugging symbols must be
67 output while in the text section.
69 For more on data type definitions, see `dbxout_type'. */
73 #include "coretypes.h"
80 #include "insn-config.h"
90 #include "langhooks.h"
94 #ifdef XCOFF_DEBUGGING_INFO
98 #define DBXOUT_DECR_NESTING \
99 if (--debug_nesting == 0 && symbol_queue_index > 0) \
100 { emit_pending_bincls_if_required (); debug_flush_symbol_queue (); }
102 #define DBXOUT_DECR_NESTING_AND_RETURN(x) \
103 do {--debug_nesting; return (x);} while (0)
106 # ifdef XCOFF_DEBUGGING_INFO
107 # define ASM_STABS_OP "\t.stabx\t"
109 # define ASM_STABS_OP "\t.stabs\t"
114 #define ASM_STABN_OP "\t.stabn\t"
118 #define ASM_STABD_OP "\t.stabd\t"
121 #ifndef DBX_TYPE_DECL_STABS_CODE
122 #define DBX_TYPE_DECL_STABS_CODE N_LSYM
125 #ifndef DBX_STATIC_CONST_VAR_CODE
126 #define DBX_STATIC_CONST_VAR_CODE N_FUN
129 #ifndef DBX_REGPARM_STABS_CODE
130 #define DBX_REGPARM_STABS_CODE N_RSYM
133 #ifndef DBX_REGPARM_STABS_LETTER
134 #define DBX_REGPARM_STABS_LETTER 'P'
137 #ifndef NO_DBX_FUNCTION_END
138 #define NO_DBX_FUNCTION_END 0
141 #ifndef NO_DBX_BNSYM_ENSYM
142 #define NO_DBX_BNSYM_ENSYM 0
145 #ifndef NO_DBX_MAIN_SOURCE_DIRECTORY
146 #define NO_DBX_MAIN_SOURCE_DIRECTORY 0
149 #ifndef DBX_BLOCKS_FUNCTION_RELATIVE
150 #define DBX_BLOCKS_FUNCTION_RELATIVE 0
153 #ifndef DBX_LINES_FUNCTION_RELATIVE
154 #define DBX_LINES_FUNCTION_RELATIVE 0
157 #ifndef DBX_CONTIN_LENGTH
158 #define DBX_CONTIN_LENGTH 80
161 #ifndef DBX_CONTIN_CHAR
162 #define DBX_CONTIN_CHAR '\\'
165 enum typestatus {TYPE_UNSEEN, TYPE_XREF, TYPE_DEFINED};
167 /* Structure recording information about a C data type.
168 The status element says whether we have yet output
169 the definition of the type. TYPE_XREF says we have
170 output it as a cross-reference only.
171 The file_number and type_number elements are used if DBX_USE_BINCL
174 struct GTY(()) typeinfo {
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 /* Number for the next N_SOL filename stabs label. The number 0 is reserved
245 for the N_SO filename stabs label. */
247 static GTY(()) int source_label_number = 1;
249 /* Last source file name mentioned in a NOTE insn. */
251 static GTY(()) const char *lastfile;
253 /* Used by PCH machinery to detect if 'lastfile' should be reset to
255 static GTY(()) int lastfile_is_base;
257 /* Typical USG systems don't have stab.h, and they also have
258 no use for DBX-format debugging info. */
260 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
263 /* If zero then there is no pending BINCL. */
264 static int pending_bincls = 0;
267 /* The original input file name. */
268 static const char *base_input_file;
270 #ifdef DEBUG_SYMS_TEXT
271 #define FORCE_TEXT switch_to_section (current_function_section ())
278 #define STAB_CODE_TYPE enum __stab_debug_code
280 /* 1 if PARM is passed to this function in memory. */
282 #define PARM_PASSED_IN_MEMORY(PARM) \
283 (MEM_P (DECL_INCOMING_RTL (PARM)))
285 /* A C expression for the integer offset value of an automatic variable
286 (N_LSYM) having address X (an RTX). */
287 #ifndef DEBUGGER_AUTO_OFFSET
288 #define DEBUGGER_AUTO_OFFSET(X) \
289 (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
292 /* A C expression for the integer offset value of an argument (N_PSYM)
293 having address X (an RTX). The nominal offset is OFFSET. */
294 #ifndef DEBUGGER_ARG_OFFSET
295 #define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET)
298 /* This obstack holds the stab string currently being constructed. We
299 build it up here, then write it out, so we can split long lines up
300 properly (see dbxout_finish_complex_stabs). */
301 static struct obstack stabstr_ob;
302 static size_t stabstr_last_contin_point;
305 static void emit_bincl_stab (const char *c);
306 static void emit_pending_bincls (void);
308 static inline void emit_pending_bincls_if_required (void);
310 static void dbxout_init (const char *);
312 static void dbxout_finish (const char *);
313 static void dbxout_start_source_file (unsigned, const char *);
314 static void dbxout_end_source_file (unsigned);
315 static void dbxout_typedefs (tree);
316 static void dbxout_type_index (tree);
317 static void dbxout_args (tree);
318 static void dbxout_type_fields (tree);
319 static void dbxout_type_method_1 (tree);
320 static void dbxout_type_methods (tree);
321 static void dbxout_range_type (tree);
322 static void dbxout_type (tree, int);
323 static bool print_int_cst_bounds_in_octal_p (tree);
324 static bool is_fortran (void);
325 static void dbxout_type_name (tree);
326 static void dbxout_class_name_qualifiers (tree);
327 static int dbxout_symbol_location (tree, tree, const char *, rtx);
328 static void dbxout_symbol_name (tree, const char *, int);
329 static void dbxout_common_name (tree, const char *, STAB_CODE_TYPE);
330 static const char *dbxout_common_check (tree, int *);
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_const_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_tree_bool, /* 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 debug_nothing_tree_tree, /* set_name */
379 0 /* start_end_main_source_file */
381 #endif /* DBX_DEBUGGING_INFO */
383 #if defined (XCOFF_DEBUGGING_INFO)
384 const struct gcc_debug_hooks xcoff_debug_hooks =
388 debug_nothing_int_charstar,
389 debug_nothing_int_charstar,
390 dbxout_start_source_file,
391 dbxout_end_source_file,
392 xcoffout_begin_block,
394 debug_true_const_tree, /* ignore_block */
395 xcoffout_source_line,
396 xcoffout_begin_prologue, /* begin_prologue */
397 debug_nothing_int_charstar, /* end_prologue */
398 xcoffout_end_epilogue,
399 debug_nothing_tree, /* begin_function */
400 xcoffout_end_function,
401 debug_nothing_tree, /* function_decl */
402 dbxout_global_decl, /* global_decl */
403 dbxout_type_decl, /* type_decl */
404 debug_nothing_tree_tree_tree_bool, /* imported_module_or_decl */
405 debug_nothing_tree, /* deferred_inline_function */
406 debug_nothing_tree, /* outlining_inline_function */
407 debug_nothing_rtx, /* label */
408 dbxout_handle_pch, /* handle_pch */
409 debug_nothing_rtx, /* var_location */
410 debug_nothing_void, /* switch_text_section */
411 debug_nothing_tree_tree, /* set_name */
412 0 /* start_end_main_source_file */
414 #endif /* XCOFF_DEBUGGING_INFO */
416 /* Numeric formatting helper macro. Note that this does not handle
418 #define NUMBER_FMT_LOOP(P, NUM, BASE) \
421 int digit = NUM % BASE; \
423 *--P = digit + '0'; \
427 /* Utility: write a decimal integer NUM to asm_out_file. */
432 char *p = buf + sizeof buf;
437 putc ('0', asm_out_file);
442 putc ('-', asm_out_file);
448 NUMBER_FMT_LOOP (p, unum, 10);
450 while (p < buf + sizeof buf)
452 putc (*p, asm_out_file);
458 /* Primitives for emitting simple stabs directives. All other stabs
459 routines should use these functions instead of directly emitting
460 stabs. They are exported because machine-dependent code may need
461 to invoke them, e.g. in a DBX_OUTPUT_* macro whose definition
462 forwards to code in CPU.c. */
464 /* The following functions should all be called immediately after one
465 of the dbxout_begin_stab* functions (below). They write out
466 various things as the value of a stab. */
468 /* Write out a literal zero as the value of a stab. */
470 dbxout_stab_value_zero (void)
472 fputs ("0\n", asm_out_file);
475 /* Write out the label LABEL as the value of a stab. */
477 dbxout_stab_value_label (const char *label)
479 assemble_name (asm_out_file, label);
480 putc ('\n', asm_out_file);
483 /* Write out the difference of two labels, LABEL - BASE, as the value
486 dbxout_stab_value_label_diff (const char *label, const char *base)
488 assemble_name (asm_out_file, label);
489 putc ('-', asm_out_file);
490 assemble_name (asm_out_file, base);
491 putc ('\n', asm_out_file);
494 /* Write out an internal label as the value of a stab, and immediately
495 emit that internal label. This should be used only when
496 dbxout_stabd will not work. STEM is the name stem of the label,
497 COUNTERP is a pointer to a counter variable which will be used to
498 guarantee label uniqueness. */
500 dbxout_stab_value_internal_label (const char *stem, int *counterp)
503 int counter = counterp ? (*counterp)++ : 0;
505 ASM_GENERATE_INTERNAL_LABEL (label, stem, counter);
506 dbxout_stab_value_label (label);
507 targetm.asm_out.internal_label (asm_out_file, stem, counter);
510 /* Write out the difference between BASE and an internal label as the
511 value of a stab, and immediately emit that internal label. STEM and
512 COUNTERP are as for dbxout_stab_value_internal_label. */
514 dbxout_stab_value_internal_label_diff (const char *stem, int *counterp,
518 int counter = counterp ? (*counterp)++ : 0;
520 ASM_GENERATE_INTERNAL_LABEL (label, stem, counter);
521 dbxout_stab_value_label_diff (label, base);
522 targetm.asm_out.internal_label (asm_out_file, stem, counter);
525 /* The following functions produce specific kinds of stab directives. */
527 /* Write a .stabd directive with type STYPE and desc SDESC to asm_out_file. */
529 dbxout_stabd (int stype, int sdesc)
531 fputs (ASM_STABD_OP, asm_out_file);
533 fputs (",0,", asm_out_file);
535 putc ('\n', asm_out_file);
538 /* Write a .stabn directive with type STYPE. This function stops
539 short of emitting the value field, which is the responsibility of
540 the caller (normally it will be either a symbol or the difference
544 dbxout_begin_stabn (int stype)
546 fputs (ASM_STABN_OP, asm_out_file);
548 fputs (",0,0,", asm_out_file);
551 /* Write a .stabn directive with type N_SLINE and desc LINE. As above,
552 the value field is the responsibility of the caller. */
554 dbxout_begin_stabn_sline (int lineno)
556 fputs (ASM_STABN_OP, asm_out_file);
557 dbxout_int (N_SLINE);
558 fputs (",0,", asm_out_file);
560 putc (',', asm_out_file);
563 /* Begin a .stabs directive with string "", type STYPE, and desc and
564 other fields 0. The value field is the responsibility of the
565 caller. This function cannot be used for .stabx directives. */
567 dbxout_begin_empty_stabs (int stype)
569 fputs (ASM_STABS_OP, asm_out_file);
570 fputs ("\"\",", asm_out_file);
572 fputs (",0,0,", asm_out_file);
575 /* Begin a .stabs directive with string STR, type STYPE, and desc 0.
576 The value field is the responsibility of the caller. */
578 dbxout_begin_simple_stabs (const char *str, int stype)
580 fputs (ASM_STABS_OP, asm_out_file);
581 output_quoted_string (asm_out_file, str);
582 putc (',', asm_out_file);
584 fputs (",0,0,", asm_out_file);
587 /* As above but use SDESC for the desc field. */
589 dbxout_begin_simple_stabs_desc (const char *str, int stype, int sdesc)
591 fputs (ASM_STABS_OP, asm_out_file);
592 output_quoted_string (asm_out_file, str);
593 putc (',', asm_out_file);
595 fputs (",0,", asm_out_file);
597 putc (',', asm_out_file);
600 /* The next set of functions are entirely concerned with production of
601 "complex" .stabs directives: that is, .stabs directives whose
602 strings have to be constructed piecemeal. dbxout_type,
603 dbxout_symbol, etc. use these routines heavily. The string is queued
604 up in an obstack, then written out by dbxout_finish_complex_stabs, which
605 is also responsible for splitting it up if it exceeds DBX_CONTIN_LENGTH.
606 (You might think it would be more efficient to go straight to stdio
607 when DBX_CONTIN_LENGTH is 0 (i.e. no length limit) but that turns
608 out not to be the case, and anyway this needs fewer #ifdefs.) */
610 /* Begin a complex .stabs directive. If we can, write the initial
611 ASM_STABS_OP to the asm_out_file. */
614 dbxout_begin_complex_stabs (void)
616 emit_pending_bincls_if_required ();
618 fputs (ASM_STABS_OP, asm_out_file);
619 putc ('"', asm_out_file);
620 gcc_assert (stabstr_last_contin_point == 0);
623 /* As above, but do not force text or emit pending bincls. This is
624 used by dbxout_symbol_location, which needs to do something else. */
626 dbxout_begin_complex_stabs_noforcetext (void)
628 fputs (ASM_STABS_OP, asm_out_file);
629 putc ('"', asm_out_file);
630 gcc_assert (stabstr_last_contin_point == 0);
633 /* Add CHR, a single character, to the string being built. */
634 #define stabstr_C(chr) obstack_1grow (&stabstr_ob, chr)
636 /* Add STR, a normal C string, to the string being built. */
637 #define stabstr_S(str) obstack_grow (&stabstr_ob, str, strlen(str))
639 /* Add the text of ID, an IDENTIFIER_NODE, to the string being built. */
640 #define stabstr_I(id) obstack_grow (&stabstr_ob, \
641 IDENTIFIER_POINTER (id), \
642 IDENTIFIER_LENGTH (id))
644 /* Add NUM, a signed decimal number, to the string being built. */
646 stabstr_D (HOST_WIDE_INT num)
649 char *p = buf + sizeof buf;
665 NUMBER_FMT_LOOP (p, unum, 10);
667 obstack_grow (&stabstr_ob, p, (buf + sizeof buf) - p);
670 /* Add NUM, an unsigned decimal number, to the string being built. */
672 stabstr_U (unsigned HOST_WIDE_INT num)
675 char *p = buf + sizeof buf;
681 NUMBER_FMT_LOOP (p, num, 10);
682 obstack_grow (&stabstr_ob, p, (buf + sizeof buf) - p);
685 /* Add CST, an INTEGER_CST tree, to the string being built as an
686 unsigned octal number. This routine handles values which are
687 larger than a single HOST_WIDE_INT. */
691 unsigned HOST_WIDE_INT high = TREE_INT_CST_HIGH (cst);
692 unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (cst);
695 char *p = buf + sizeof buf;
697 /* GDB wants constants with no extra leading "1" bits, so
698 we need to remove any sign-extension that might be
701 const unsigned int width = TYPE_PRECISION (TREE_TYPE (cst));
702 if (width == HOST_BITS_PER_WIDE_INT * 2)
704 else if (width > HOST_BITS_PER_WIDE_INT)
705 high &= (((HOST_WIDE_INT) 1 << (width - HOST_BITS_PER_WIDE_INT)) - 1);
706 else if (width == HOST_BITS_PER_WIDE_INT)
709 high = 0, low &= (((HOST_WIDE_INT) 1 << width) - 1);
712 /* Leading zero for base indicator. */
715 /* If the value is zero, the base indicator will serve as the value
717 if (high == 0 && low == 0)
720 /* If the high half is zero, we need only print the low half normally. */
722 NUMBER_FMT_LOOP (p, low, 8);
725 /* When high != 0, we need to print enough zeroes from low to
726 give the digits from high their proper place-values. Hence
727 NUMBER_FMT_LOOP cannot be used. */
728 const int n_digits = HOST_BITS_PER_WIDE_INT / 3;
731 for (i = 1; i <= n_digits; i++)
733 unsigned int digit = low % 8;
738 /* Octal digits carry exactly three bits of information. The
739 width of a HOST_WIDE_INT is not normally a multiple of three.
740 Therefore, the next digit printed probably needs to carry
741 information from both low and high. */
742 if (HOST_BITS_PER_WIDE_INT % 3 != 0)
744 const int n_leftover_bits = HOST_BITS_PER_WIDE_INT % 3;
745 const int n_bits_from_high = 3 - n_leftover_bits;
747 const unsigned HOST_WIDE_INT
748 low_mask = (((unsigned HOST_WIDE_INT)1) << n_leftover_bits) - 1;
749 const unsigned HOST_WIDE_INT
750 high_mask = (((unsigned HOST_WIDE_INT)1) << n_bits_from_high) - 1;
754 /* At this point, only the bottom n_leftover_bits bits of low
756 gcc_assert (!(low & ~low_mask));
758 digit = (low | ((high & high_mask) << n_leftover_bits));
759 high >>= n_bits_from_high;
764 /* Now we can format high in the normal manner. However, if
765 the only bits of high that were set were handled by the
766 digit split between low and high, high will now be zero, and
767 we don't want to print extra digits in that case. */
769 NUMBER_FMT_LOOP (p, high, 8);
772 obstack_grow (&stabstr_ob, p, (buf + sizeof buf) - p);
775 /* Called whenever it is safe to break a stabs string into multiple
776 .stabs directives. If the current string has exceeded the limit
777 set by DBX_CONTIN_LENGTH, mark the current position in the buffer
778 as a continuation point by inserting DBX_CONTIN_CHAR (doubled if
779 it is a backslash) and a null character. */
781 stabstr_continue (void)
783 if (DBX_CONTIN_LENGTH > 0
784 && obstack_object_size (&stabstr_ob) - stabstr_last_contin_point
787 if (DBX_CONTIN_CHAR == '\\')
788 obstack_1grow (&stabstr_ob, '\\');
789 obstack_1grow (&stabstr_ob, DBX_CONTIN_CHAR);
790 obstack_1grow (&stabstr_ob, '\0');
791 stabstr_last_contin_point = obstack_object_size (&stabstr_ob);
794 #define CONTIN stabstr_continue ()
796 /* Macro subroutine of dbxout_finish_complex_stabs, which emits
797 all of the arguments to the .stabs directive after the string.
798 Overridden by xcoffout.h. CODE is the stabs code for this symbol;
799 LINE is the source line to write into the desc field (in extended
800 mode); SYM is the symbol itself.
802 ADDR, LABEL, and NUMBER are three different ways to represent the
803 stabs value field. At most one of these should be nonzero.
805 ADDR is used most of the time; it represents the value as an
806 RTL address constant.
808 LABEL is used (currently) only for N_CATCH stabs; it represents
809 the value as a string suitable for assemble_name.
811 NUMBER is used when the value is an offset from an implicit base
812 pointer (e.g. for a stack variable), or an index (e.g. for a
813 register variable). It represents the value as a decimal integer. */
815 #ifndef DBX_FINISH_STABS
816 #define DBX_FINISH_STABS(SYM, CODE, LINE, ADDR, LABEL, NUMBER) \
818 int line_ = use_gnu_debug_info_extensions ? LINE : 0; \
821 fputs (",0,", asm_out_file); \
822 dbxout_int (line_); \
823 putc (',', asm_out_file); \
825 output_addr_const (asm_out_file, ADDR); \
827 assemble_name (asm_out_file, LABEL); \
829 dbxout_int (NUMBER); \
830 putc ('\n', asm_out_file); \
834 /* Finish the emission of a complex .stabs directive. When DBX_CONTIN_LENGTH
835 is zero, this has only to emit the close quote and the remainder of
836 the arguments. When it is nonzero, the string has been marshalled in
837 stabstr_ob, and this routine is responsible for breaking it up into
838 DBX_CONTIN_LENGTH-sized chunks.
840 SYM is the DECL of the symbol under consideration; it is used only
841 for its DECL_SOURCE_LINE. The other arguments are all passed directly
842 to DBX_FINISH_STABS; see above for details. */
845 dbxout_finish_complex_stabs (tree sym, STAB_CODE_TYPE code,
846 rtx addr, const char *label, int number)
848 int line ATTRIBUTE_UNUSED;
852 line = sym ? DECL_SOURCE_LINE (sym) : 0;
853 if (DBX_CONTIN_LENGTH > 0)
858 /* Nul-terminate the growing string, then get its size and
860 obstack_1grow (&stabstr_ob, '\0');
862 len = obstack_object_size (&stabstr_ob);
863 chunk = str = XOBFINISH (&stabstr_ob, char *);
865 /* Within the buffer are a sequence of NUL-separated strings,
866 each of which is to be written out as a separate stab
870 chunklen = strlen (chunk);
871 fwrite (chunk, 1, chunklen, asm_out_file);
872 fputs ("\",", asm_out_file);
874 /* Must add an extra byte to account for the NUL separator. */
875 chunk += chunklen + 1;
878 /* Only put a line number on the last stab in the sequence. */
879 DBX_FINISH_STABS (sym, code, len == 0 ? line : 0,
880 addr, label, number);
884 fputs (ASM_STABS_OP, asm_out_file);
885 putc ('"', asm_out_file);
887 stabstr_last_contin_point = 0;
891 /* No continuations - we can put the whole string out at once.
892 It is faster to augment the string with the close quote and
893 comma than to do a two-character fputs. */
894 obstack_grow (&stabstr_ob, "\",", 2);
895 len = obstack_object_size (&stabstr_ob);
896 str = XOBFINISH (&stabstr_ob, char *);
898 fwrite (str, 1, len, asm_out_file);
899 DBX_FINISH_STABS (sym, code, line, addr, label, number);
901 obstack_free (&stabstr_ob, str);
904 #if defined (DBX_DEBUGGING_INFO)
907 dbxout_function_end (tree decl)
909 char lscope_label_name[100];
911 /* The Lscope label must be emitted even if we aren't doing anything
912 else; dbxout_block needs it. */
913 switch_to_section (function_section (current_function_decl));
915 /* Convert Lscope into the appropriate format for local labels in case
916 the system doesn't insert underscores in front of user generated
918 ASM_GENERATE_INTERNAL_LABEL (lscope_label_name, "Lscope", scope_labelno);
919 targetm.asm_out.internal_label (asm_out_file, "Lscope", scope_labelno);
921 /* The N_FUN tag at the end of the function is a GNU extension,
922 which may be undesirable, and is unnecessary if we do not have
924 if (!use_gnu_debug_info_extensions
925 || NO_DBX_FUNCTION_END
926 || !targetm.have_named_sections
927 || DECL_IGNORED_P (decl))
930 /* By convention, GCC will mark the end of a function with an N_FUN
931 symbol and an empty string. */
932 if (flag_reorder_blocks_and_partition)
934 dbxout_begin_empty_stabs (N_FUN);
935 dbxout_stab_value_label_diff (crtl->subsections.hot_section_end_label,
936 crtl->subsections.hot_section_label);
937 dbxout_begin_empty_stabs (N_FUN);
938 dbxout_stab_value_label_diff (crtl->subsections.cold_section_end_label,
939 crtl->subsections.cold_section_label);
943 char begin_label[20];
944 /* Reference current function start using LFBB. */
945 ASM_GENERATE_INTERNAL_LABEL (begin_label, "LFBB", scope_labelno);
946 dbxout_begin_empty_stabs (N_FUN);
947 dbxout_stab_value_label_diff (lscope_label_name, begin_label);
950 if (!NO_DBX_BNSYM_ENSYM && !flag_debug_only_used_symbols)
951 dbxout_stabd (N_ENSYM, 0);
953 #endif /* DBX_DEBUGGING_INFO */
955 /* Get lang description for N_SO stab. */
956 static unsigned int ATTRIBUTE_UNUSED
957 get_lang_number (void)
959 const char *language_string = lang_hooks.name;
961 if (strcmp (language_string, "GNU C") == 0)
963 else if (strcmp (language_string, "GNU C++") == 0)
965 else if (strcmp (language_string, "GNU F77") == 0)
967 else if (strcmp (language_string, "GNU Fortran") == 0)
968 return N_SO_FORTRAN90; /* CHECKME */
969 else if (strcmp (language_string, "GNU Pascal") == 0)
971 else if (strcmp (language_string, "GNU Objective-C") == 0)
973 else if (strcmp (language_string, "GNU Objective-C++") == 0)
974 return N_SO_OBJCPLUS;
983 unsigned int lang = get_lang_number ();
985 return (lang == N_SO_FORTRAN) || (lang == N_SO_FORTRAN90);
988 /* At the beginning of compilation, start writing the symbol table.
989 Initialize `typevec' and output the standard data types of C. */
992 dbxout_init (const char *input_file_name)
994 char ltext_label_name[100];
995 bool used_ltext_label_name = false;
996 tree syms = lang_hooks.decls.getdecls ();
997 const char *mapped_name;
1000 typevec = GGC_CNEWVEC (struct typeinfo, typevec_len);
1002 /* stabstr_ob contains one string, which will be just fine with
1003 1-byte alignment. */
1004 obstack_specify_allocation (&stabstr_ob, 0, 1, xmalloc, free);
1006 /* Convert Ltext into the appropriate format for local labels in case
1007 the system doesn't insert underscores in front of user generated
1009 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext", 0);
1011 /* Put the current working directory in an N_SO symbol. */
1012 if (use_gnu_debug_info_extensions && !NO_DBX_MAIN_SOURCE_DIRECTORY)
1014 static const char *cwd;
1018 cwd = get_src_pwd ();
1021 else if (!IS_DIR_SEPARATOR (cwd[strlen (cwd) - 1]))
1022 cwd = concat (cwd, "/", NULL);
1023 cwd = remap_debug_filename (cwd);
1025 #ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
1026 DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asm_out_file, cwd);
1027 #else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
1028 dbxout_begin_simple_stabs_desc (cwd, N_SO, get_lang_number ());
1029 dbxout_stab_value_label (ltext_label_name);
1030 used_ltext_label_name = true;
1031 #endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
1034 mapped_name = remap_debug_filename (input_file_name);
1035 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
1036 DBX_OUTPUT_MAIN_SOURCE_FILENAME (asm_out_file, mapped_name);
1038 dbxout_begin_simple_stabs_desc (mapped_name, N_SO, get_lang_number ());
1039 dbxout_stab_value_label (ltext_label_name);
1040 used_ltext_label_name = true;
1043 if (used_ltext_label_name)
1045 switch_to_section (text_section);
1046 targetm.asm_out.internal_label (asm_out_file, "Ltext", 0);
1049 /* Emit an N_OPT stab to indicate that this file was compiled by GCC.
1050 The string used is historical. */
1051 #ifndef NO_DBX_GCC_MARKER
1052 dbxout_begin_simple_stabs ("gcc2_compiled.", N_OPT);
1053 dbxout_stab_value_zero ();
1056 base_input_file = lastfile = input_file_name;
1058 next_type_number = 1;
1060 #ifdef DBX_USE_BINCL
1061 current_file = XNEW (struct dbx_file);
1062 current_file->next = NULL;
1063 current_file->file_number = 0;
1064 current_file->next_type_number = 1;
1065 next_file_number = 1;
1066 current_file->prev = NULL;
1067 current_file->bincl_status = BINCL_NOT_REQUIRED;
1068 current_file->pending_bincl_name = NULL;
1071 /* Get all permanent types that have typedef names, and output them
1072 all, except for those already output. Some language front ends
1073 put these declarations in the top-level scope; some do not;
1074 the latter are responsible for calling debug_hooks->type_decl from
1075 their record_builtin_type function. */
1076 dbxout_typedefs (syms);
1078 if (preinit_symbols)
1081 for (t = nreverse (preinit_symbols); t; t = TREE_CHAIN (t))
1082 dbxout_symbol (TREE_VALUE (t), 0);
1083 preinit_symbols = 0;
1087 /* Output any typedef names for types described by TYPE_DECLs in SYMS. */
1090 dbxout_typedefs (tree syms)
1092 for (; syms != NULL_TREE; syms = TREE_CHAIN (syms))
1094 if (TREE_CODE (syms) == TYPE_DECL)
1096 tree type = TREE_TYPE (syms);
1097 if (TYPE_NAME (type)
1098 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1099 && COMPLETE_OR_VOID_TYPE_P (type)
1100 && ! TREE_ASM_WRITTEN (TYPE_NAME (type)))
1101 dbxout_symbol (TYPE_NAME (type), 0);
1106 #ifdef DBX_USE_BINCL
1107 /* Emit BINCL stab using given name. */
1109 emit_bincl_stab (const char *name)
1111 dbxout_begin_simple_stabs (name, N_BINCL);
1112 dbxout_stab_value_zero ();
1115 /* If there are pending bincls then it is time to emit all of them. */
1118 emit_pending_bincls_if_required (void)
1121 emit_pending_bincls ();
1124 /* Emit all pending bincls. */
1127 emit_pending_bincls (void)
1129 struct dbx_file *f = current_file;
1131 /* Find first pending bincl. */
1132 while (f->bincl_status == BINCL_PENDING)
1135 /* Now emit all bincls. */
1140 if (f->bincl_status == BINCL_PENDING)
1142 emit_bincl_stab (f->pending_bincl_name);
1144 /* Update file number and status. */
1145 f->file_number = next_file_number++;
1146 f->bincl_status = BINCL_PROCESSED;
1148 if (f == current_file)
1153 /* All pending bincls have been emitted. */
1160 emit_pending_bincls_if_required (void) {}
1163 /* Change to reading from a new source file. Generate a N_BINCL stab. */
1166 dbxout_start_source_file (unsigned int line ATTRIBUTE_UNUSED,
1167 const char *filename ATTRIBUTE_UNUSED)
1169 #ifdef DBX_USE_BINCL
1170 struct dbx_file *n = XNEW (struct dbx_file);
1172 n->next = current_file;
1173 n->next_type_number = 1;
1174 /* Do not assign file number now.
1175 Delay it until we actually emit BINCL. */
1178 current_file->prev = n;
1179 n->bincl_status = BINCL_PENDING;
1180 n->pending_bincl_name = remap_debug_filename (filename);
1186 /* Revert to reading a previous source file. Generate a N_EINCL stab. */
1189 dbxout_end_source_file (unsigned int line ATTRIBUTE_UNUSED)
1191 #ifdef DBX_USE_BINCL
1192 /* Emit EINCL stab only if BINCL is not pending. */
1193 if (current_file->bincl_status == BINCL_PROCESSED)
1195 dbxout_begin_stabn (N_EINCL);
1196 dbxout_stab_value_zero ();
1198 current_file->bincl_status = BINCL_NOT_REQUIRED;
1199 current_file = current_file->next;
1203 /* Handle a few odd cases that occur when trying to make PCH files work. */
1206 dbxout_handle_pch (unsigned at_end)
1210 /* When using the PCH, this file will be included, so we need to output
1212 dbxout_start_source_file (0, lastfile);
1214 /* The base file when using the PCH won't be the same as
1215 the base file when it's being generated. */
1220 /* ... and an EINCL. */
1221 dbxout_end_source_file (0);
1223 /* Deal with cases where 'lastfile' was never actually changed. */
1224 lastfile_is_base = lastfile == NULL;
1228 #if defined (DBX_DEBUGGING_INFO)
1230 static void dbxout_block (tree, int, tree);
1232 /* Output debugging info to FILE to switch to sourcefile FILENAME. */
1235 dbxout_source_file (const char *filename)
1237 if (lastfile == 0 && lastfile_is_base)
1239 lastfile = base_input_file;
1240 lastfile_is_base = 0;
1243 if (filename && (lastfile == 0 || strcmp (filename, lastfile)))
1245 /* Don't change section amid function. */
1246 if (current_function_decl == NULL_TREE)
1247 switch_to_section (text_section);
1249 dbxout_begin_simple_stabs (remap_debug_filename (filename), N_SOL);
1250 dbxout_stab_value_internal_label ("Ltext", &source_label_number);
1251 lastfile = filename;
1255 /* Output N_BNSYM, line number symbol entry, and local symbol at
1259 dbxout_begin_prologue (unsigned int lineno, const char *filename)
1261 if (use_gnu_debug_info_extensions
1262 && !NO_DBX_FUNCTION_END
1263 && !NO_DBX_BNSYM_ENSYM
1264 && !flag_debug_only_used_symbols)
1265 dbxout_stabd (N_BNSYM, 0);
1267 /* pre-increment the scope counter */
1270 dbxout_source_line (lineno, filename);
1271 /* Output function begin block at function scope, referenced
1272 by dbxout_block, dbxout_source_line and dbxout_function_end. */
1273 emit_pending_bincls_if_required ();
1274 targetm.asm_out.internal_label (asm_out_file, "LFBB", scope_labelno);
1277 /* Output a line number symbol entry for source file FILENAME and line
1281 dbxout_source_line (unsigned int lineno, const char *filename)
1283 dbxout_source_file (filename);
1285 #ifdef DBX_OUTPUT_SOURCE_LINE
1286 DBX_OUTPUT_SOURCE_LINE (asm_out_file, lineno, dbxout_source_line_counter);
1288 if (DBX_LINES_FUNCTION_RELATIVE)
1290 char begin_label[20];
1291 dbxout_begin_stabn_sline (lineno);
1292 /* Reference current function start using LFBB. */
1293 ASM_GENERATE_INTERNAL_LABEL (begin_label, "LFBB", scope_labelno);
1294 dbxout_stab_value_internal_label_diff ("LM", &dbxout_source_line_counter,
1298 dbxout_stabd (N_SLINE, lineno);
1302 /* Describe the beginning of an internal block within a function. */
1305 dbxout_begin_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int n)
1307 emit_pending_bincls_if_required ();
1308 targetm.asm_out.internal_label (asm_out_file, "LBB", n);
1311 /* Describe the end line-number of an internal block within a function. */
1314 dbxout_end_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int n)
1316 emit_pending_bincls_if_required ();
1317 targetm.asm_out.internal_label (asm_out_file, "LBE", n);
1320 /* Output dbx data for a function definition.
1321 This includes a definition of the function name itself (a symbol),
1322 definitions of the parameters (locating them in the parameter list)
1323 and then output the block that makes up the function's body
1324 (including all the auto variables of the function). */
1327 dbxout_function_decl (tree decl)
1329 emit_pending_bincls_if_required ();
1330 #ifndef DBX_FUNCTION_FIRST
1331 dbxout_begin_function (decl);
1333 dbxout_block (DECL_INITIAL (decl), 0, DECL_ARGUMENTS (decl));
1334 dbxout_function_end (decl);
1337 #endif /* DBX_DEBUGGING_INFO */
1339 /* Debug information for a global DECL. Called from toplev.c after
1340 compilation proper has finished. */
1342 dbxout_global_decl (tree decl)
1344 if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl))
1346 int saved_tree_used = TREE_USED (decl);
1347 TREE_USED (decl) = 1;
1348 dbxout_symbol (decl, 0);
1349 TREE_USED (decl) = saved_tree_used;
1353 /* This is just a function-type adapter; dbxout_symbol does exactly
1354 what we want but returns an int. */
1356 dbxout_type_decl (tree decl, int local)
1358 dbxout_symbol (decl, local);
1361 /* At the end of compilation, finish writing the symbol table.
1362 The default is to call debug_free_queue but do nothing else. */
1365 dbxout_finish (const char *filename ATTRIBUTE_UNUSED)
1367 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
1368 DBX_OUTPUT_MAIN_SOURCE_FILE_END (asm_out_file, filename);
1369 #elif defined DBX_OUTPUT_NULL_N_SO_AT_MAIN_SOURCE_FILE_END
1371 switch_to_section (text_section);
1372 dbxout_begin_empty_stabs (N_SO);
1373 dbxout_stab_value_internal_label ("Letext", 0);
1376 debug_free_queue ();
1379 /* Output the index of a type. */
1382 dbxout_type_index (tree type)
1384 #ifndef DBX_USE_BINCL
1385 stabstr_D (TYPE_SYMTAB_ADDRESS (type));
1387 struct typeinfo *t = &typevec[TYPE_SYMTAB_ADDRESS (type)];
1389 stabstr_D (t->file_number);
1391 stabstr_D (t->type_number);
1398 /* Used in several places: evaluates to '0' for a private decl,
1399 '1' for a protected decl, '2' for a public decl. */
1400 #define DECL_ACCESSIBILITY_CHAR(DECL) \
1401 ((TREE_CODE (DECL) != PARM_DECL && TREE_CODE (DECL) != RESULT_DECL \
1402 && (TREE_CODE (DECL) != VAR_DECL || TREE_STATIC (DECL)) \
1403 && TREE_PRIVATE (DECL)) ? '0' : TREE_PROTECTED (DECL) ? '1' : '2')
1405 /* Subroutine of `dbxout_type'. Output the type fields of TYPE.
1406 This must be a separate function because anonymous unions require
1410 dbxout_type_fields (tree type)
1414 /* Output the name, type, position (in bits), size (in bits) of each
1415 field that we can support. */
1416 for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
1418 /* If one of the nodes is an error_mark or its type is then
1420 if (tem == error_mark_node || TREE_TYPE (tem) == error_mark_node)
1423 /* Omit here local type decls until we know how to support them. */
1424 if (TREE_CODE (tem) == TYPE_DECL
1425 /* Omit here the nameless fields that are used to skip bits. */
1426 || DECL_IGNORED_P (tem)
1427 /* Omit fields whose position or size are variable or too large to
1429 || (TREE_CODE (tem) == FIELD_DECL
1430 && (! host_integerp (bit_position (tem), 0)
1431 || ! DECL_SIZE (tem)
1432 || ! host_integerp (DECL_SIZE (tem), 1))))
1435 else if (TREE_CODE (tem) != CONST_DECL)
1437 /* Continue the line if necessary,
1438 but not before the first field. */
1439 if (tem != TYPE_FIELDS (type))
1442 if (DECL_NAME (tem))
1443 stabstr_I (DECL_NAME (tem));
1446 if (use_gnu_debug_info_extensions
1447 && (TREE_PRIVATE (tem) || TREE_PROTECTED (tem)
1448 || TREE_CODE (tem) != FIELD_DECL))
1451 stabstr_C (DECL_ACCESSIBILITY_CHAR (tem));
1454 dbxout_type ((TREE_CODE (tem) == FIELD_DECL
1455 && DECL_BIT_FIELD_TYPE (tem))
1456 ? DECL_BIT_FIELD_TYPE (tem) : TREE_TYPE (tem), 0);
1458 if (TREE_CODE (tem) == VAR_DECL)
1460 if (TREE_STATIC (tem) && use_gnu_debug_info_extensions)
1462 tree name = DECL_ASSEMBLER_NAME (tem);
1469 /* If TEM is non-static, GDB won't understand it. */
1470 stabstr_S (",0,0;");
1475 stabstr_D (int_bit_position (tem));
1477 stabstr_D (tree_low_cst (DECL_SIZE (tem), 1));
1484 /* Subroutine of `dbxout_type_methods'. Output debug info about the
1485 method described DECL. */
1488 dbxout_type_method_1 (tree decl)
1492 if (TREE_CODE (TREE_TYPE (decl)) == FUNCTION_TYPE)
1494 else /* it's a METHOD_TYPE. */
1496 tree firstarg = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)));
1497 /* A for normal functions.
1498 B for `const' member functions.
1499 C for `volatile' member functions.
1500 D for `const volatile' member functions. */
1501 if (TYPE_READONLY (TREE_TYPE (firstarg)))
1503 if (TYPE_VOLATILE (TREE_TYPE (firstarg)))
1506 if (DECL_VINDEX (decl))
1512 /* ??? Output the mangled name, which contains an encoding of the
1513 method's type signature. May not be necessary anymore. */
1515 stabstr_I (DECL_ASSEMBLER_NAME (decl));
1517 stabstr_C (DECL_ACCESSIBILITY_CHAR (decl));
1521 if (DECL_VINDEX (decl) && host_integerp (DECL_VINDEX (decl), 0))
1523 stabstr_D (tree_low_cst (DECL_VINDEX (decl), 0));
1525 dbxout_type (DECL_CONTEXT (decl), 0);
1530 /* Subroutine of `dbxout_type'. Output debug info about the methods defined
1534 dbxout_type_methods (tree type)
1536 /* C++: put out the method names and their parameter lists */
1537 tree methods = TYPE_METHODS (type);
1541 if (methods == NULL_TREE)
1544 if (TREE_CODE (methods) != TREE_VEC)
1546 else if (TREE_VEC_ELT (methods, 0) != NULL_TREE)
1547 fndecl = TREE_VEC_ELT (methods, 0);
1549 fndecl = TREE_VEC_ELT (methods, 1);
1553 int need_prefix = 1;
1555 /* Group together all the methods for the same operation.
1556 These differ in the types of the arguments. */
1557 for (last = NULL_TREE;
1558 fndecl && (last == NULL_TREE || DECL_NAME (fndecl) == DECL_NAME (last));
1559 fndecl = TREE_CHAIN (fndecl))
1560 /* Output the name of the field (after overloading), as
1561 well as the name of the field before overloading, along
1562 with its parameter list */
1564 /* Skip methods that aren't FUNCTION_DECLs. (In C++, these
1565 include TEMPLATE_DECLs.) The debugger doesn't know what
1566 to do with such entities anyhow. */
1567 if (TREE_CODE (fndecl) != FUNCTION_DECL)
1574 /* Also ignore abstract methods; those are only interesting to
1575 the DWARF backends. */
1576 if (DECL_IGNORED_P (fndecl) || DECL_ABSTRACT (fndecl))
1579 /* Redundantly output the plain name, since that's what gdb
1583 stabstr_I (DECL_NAME (fndecl));
1588 dbxout_type (TREE_TYPE (fndecl), 0);
1589 dbxout_type_method_1 (fndecl);
1596 /* Emit a "range" type specification, which has the form:
1597 "r<index type>;<lower bound>;<upper bound>;".
1598 TYPE is an INTEGER_TYPE. */
1601 dbxout_range_type (tree type)
1604 if (TREE_TYPE (type))
1605 dbxout_type (TREE_TYPE (type), 0);
1606 else if (TREE_CODE (type) != INTEGER_TYPE)
1607 dbxout_type (type, 0); /* E.g. Pascal's ARRAY [BOOLEAN] of INTEGER */
1610 /* Traditionally, we made sure 'int' was type 1, and builtin types
1611 were defined to be sub-ranges of int. Unfortunately, this
1612 does not allow us to distinguish true sub-ranges from integer
1613 types. So, instead we define integer (non-sub-range) types as
1614 sub-ranges of themselves. This matters for Chill. If this isn't
1615 a subrange type, then we want to define it in terms of itself.
1616 However, in C, this may be an anonymous integer type, and we don't
1617 want to emit debug info referring to it. Just calling
1618 dbxout_type_index won't work anyways, because the type hasn't been
1619 defined yet. We make this work for both cases by checked to see
1620 whether this is a defined type, referring to it if it is, and using
1622 if (TYPE_SYMTAB_ADDRESS (type) != 0)
1623 dbxout_type_index (type);
1625 dbxout_type_index (integer_type_node);
1629 if (TYPE_MIN_VALUE (type) != 0
1630 && host_integerp (TYPE_MIN_VALUE (type), 0))
1632 if (print_int_cst_bounds_in_octal_p (type))
1633 stabstr_O (TYPE_MIN_VALUE (type));
1635 stabstr_D (tree_low_cst (TYPE_MIN_VALUE (type), 0));
1641 if (TYPE_MAX_VALUE (type) != 0
1642 && host_integerp (TYPE_MAX_VALUE (type), 0))
1644 if (print_int_cst_bounds_in_octal_p (type))
1645 stabstr_O (TYPE_MAX_VALUE (type));
1647 stabstr_D (tree_low_cst (TYPE_MAX_VALUE (type), 0));
1655 /* Output a reference to a type. If the type has not yet been
1656 described in the dbx output, output its definition now.
1657 For a type already defined, just refer to its definition
1658 using the type number.
1660 If FULL is nonzero, and the type has been described only with
1661 a forward-reference, output the definition now.
1662 If FULL is zero in this case, just refer to the forward-reference
1663 using the number previously allocated. */
1666 dbxout_type (tree type, int full)
1670 static int anonymous_type_number = 0;
1671 bool vector_type = false;
1673 if (TREE_CODE (type) == VECTOR_TYPE)
1675 /* The frontend feeds us a representation for the vector as a struct
1676 containing an array. Pull out the array type. */
1677 type = TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type)));
1681 /* If there was an input error and we don't really have a type,
1682 avoid crashing and write something that is at least valid
1683 by assuming `int'. */
1684 if (type == error_mark_node)
1685 type = integer_type_node;
1688 if (TYPE_NAME (type)
1689 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1690 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type)))
1694 /* Try to find the "main variant" with the same name. */
1695 if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1696 && DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
1697 main_variant = TREE_TYPE (TYPE_NAME (type));
1699 main_variant = TYPE_MAIN_VARIANT (type);
1701 /* If we are not using extensions, stabs does not distinguish const and
1702 volatile, so there is no need to make them separate types. */
1703 if (!use_gnu_debug_info_extensions)
1704 type = main_variant;
1706 if (TYPE_SYMTAB_ADDRESS (type) == 0)
1708 /* Type has no dbx number assigned. Assign next available number. */
1709 TYPE_SYMTAB_ADDRESS (type) = next_type_number++;
1711 /* Make sure type vector is long enough to record about this type. */
1713 if (next_type_number == typevec_len)
1715 typevec = GGC_RESIZEVEC (struct typeinfo, typevec, typevec_len * 2);
1716 memset (typevec + typevec_len, 0, typevec_len * sizeof typevec[0]);
1720 #ifdef DBX_USE_BINCL
1721 emit_pending_bincls_if_required ();
1722 typevec[TYPE_SYMTAB_ADDRESS (type)].file_number
1723 = current_file->file_number;
1724 typevec[TYPE_SYMTAB_ADDRESS (type)].type_number
1725 = current_file->next_type_number++;
1729 if (flag_debug_only_used_symbols)
1731 if ((TREE_CODE (type) == RECORD_TYPE
1732 || TREE_CODE (type) == UNION_TYPE
1733 || TREE_CODE (type) == QUAL_UNION_TYPE
1734 || TREE_CODE (type) == ENUMERAL_TYPE)
1735 && TYPE_STUB_DECL (type)
1736 && DECL_P (TYPE_STUB_DECL (type))
1737 && ! DECL_IGNORED_P (TYPE_STUB_DECL (type)))
1738 debug_queue_symbol (TYPE_STUB_DECL (type));
1739 else if (TYPE_NAME (type)
1740 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
1741 debug_queue_symbol (TYPE_NAME (type));
1744 /* Output the number of this type, to refer to it. */
1745 dbxout_type_index (type);
1747 #ifdef DBX_TYPE_DEFINED
1748 if (DBX_TYPE_DEFINED (type))
1752 /* If this type's definition has been output or is now being output,
1755 switch (typevec[TYPE_SYMTAB_ADDRESS (type)].status)
1760 /* If we have already had a cross reference,
1761 and either that's all we want or that's the best we could do,
1762 don't repeat the cross reference.
1763 Sun dbx crashes if we do. */
1764 if (! full || !COMPLETE_TYPE_P (type)
1765 /* No way in DBX fmt to describe a variable size. */
1766 || ! host_integerp (TYPE_SIZE (type), 1))
1774 /* For systems where dbx output does not allow the `=xsNAME:' syntax,
1775 leave the type-number completely undefined rather than output
1776 a cross-reference. If we have already used GNU debug info extensions,
1777 then it is OK to output a cross reference. This is necessary to get
1778 proper C++ debug output. */
1779 if ((TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE
1780 || TREE_CODE (type) == QUAL_UNION_TYPE
1781 || TREE_CODE (type) == ENUMERAL_TYPE)
1782 && ! use_gnu_debug_info_extensions)
1783 /* We must use the same test here as we use twice below when deciding
1784 whether to emit a cross-reference. */
1785 if ((TYPE_NAME (type) != 0
1786 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
1787 && DECL_IGNORED_P (TYPE_NAME (type)))
1789 || !COMPLETE_TYPE_P (type)
1790 /* No way in DBX fmt to describe a variable size. */
1791 || ! host_integerp (TYPE_SIZE (type), 1))
1793 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
1798 /* Output a definition now. */
1801 /* Mark it as defined, so that if it is self-referent
1802 we will not get into an infinite recursion of definitions. */
1804 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_DEFINED;
1806 /* If this type is a variant of some other, hand off. Types with
1807 different names are usefully distinguished. We only distinguish
1808 cv-qualified types if we're using extensions. */
1809 if (TYPE_READONLY (type) > TYPE_READONLY (main_variant))
1812 dbxout_type (build_type_variant (type, 0, TYPE_VOLATILE (type)), 0);
1815 else if (TYPE_VOLATILE (type) > TYPE_VOLATILE (main_variant))
1818 dbxout_type (build_type_variant (type, TYPE_READONLY (type), 0), 0);
1821 else if (main_variant != TYPE_MAIN_VARIANT (type))
1823 if (flag_debug_only_used_symbols)
1825 tree orig_type = DECL_ORIGINAL_TYPE (TYPE_NAME (type));
1827 if ((TREE_CODE (orig_type) == RECORD_TYPE
1828 || TREE_CODE (orig_type) == UNION_TYPE
1829 || TREE_CODE (orig_type) == QUAL_UNION_TYPE
1830 || TREE_CODE (orig_type) == ENUMERAL_TYPE)
1831 && TYPE_STUB_DECL (orig_type)
1832 && ! DECL_IGNORED_P (TYPE_STUB_DECL (orig_type)))
1833 debug_queue_symbol (TYPE_STUB_DECL (orig_type));
1835 /* 'type' is a typedef; output the type it refers to. */
1836 dbxout_type (DECL_ORIGINAL_TYPE (TYPE_NAME (type)), 0);
1839 /* else continue. */
1841 switch (TREE_CODE (type))
1845 /* For a void type, just define it as itself; i.e., "5=5".
1846 This makes us consider it defined
1847 without saying what it is. The debugger will make it
1848 a void type when the reference is seen, and nothing will
1849 ever override that default. */
1850 dbxout_type_index (type);
1854 if (type == char_type_node && ! TYPE_UNSIGNED (type))
1856 /* Output the type `char' as a subrange of itself!
1857 I don't understand this definition, just copied it
1858 from the output of pcc.
1859 This used to use `r2' explicitly and we used to
1860 take care to make sure that `char' was type number 2. */
1862 dbxout_type_index (type);
1863 stabstr_S (";0;127;");
1866 /* If this is a subtype of another integer type, always prefer to
1867 write it as a subtype. */
1868 else if (TREE_TYPE (type) != 0
1869 && TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE)
1871 /* If the size is non-standard, say what it is if we can use
1874 if (use_gnu_debug_info_extensions
1875 && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
1878 stabstr_D (TYPE_PRECISION (type));
1882 dbxout_range_type (type);
1887 /* If the size is non-standard, say what it is if we can use
1890 if (use_gnu_debug_info_extensions
1891 && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
1894 stabstr_D (TYPE_PRECISION (type));
1898 if (print_int_cst_bounds_in_octal_p (type))
1902 /* If this type derives from another type, output type index of
1903 parent type. This is particularly important when parent type
1904 is an enumerated type, because not generating the parent type
1905 index would transform the definition of this enumerated type
1906 into a plain unsigned type. */
1907 if (TREE_TYPE (type) != 0)
1908 dbxout_type_index (TREE_TYPE (type));
1910 dbxout_type_index (type);
1913 stabstr_O (TYPE_MIN_VALUE (type));
1915 stabstr_O (TYPE_MAX_VALUE (type));
1920 /* Output other integer types as subranges of `int'. */
1921 dbxout_range_type (type);
1927 case FIXED_POINT_TYPE:
1928 /* This used to say `r1' and we used to take care
1929 to make sure that `int' was type number 1. */
1931 dbxout_type_index (integer_type_node);
1933 stabstr_D (int_size_in_bytes (type));
1938 if (use_gnu_debug_info_extensions)
1941 stabstr_D (BITS_PER_UNIT * int_size_in_bytes (type));
1942 stabstr_S (";-16;");
1944 else /* Define as enumeral type (False, True) */
1945 stabstr_S ("eFalse:0,True:1,;");
1949 /* Differs from the REAL_TYPE by its new data type number.
1950 R3 is NF_COMPLEX. We don't try to use any of the other NF_*
1951 codes since gdb doesn't care anyway. */
1953 if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
1956 stabstr_D (2 * int_size_in_bytes (TREE_TYPE (type)));
1961 /* Output a complex integer type as a structure,
1962 pending some other way to do it. */
1964 stabstr_D (int_size_in_bytes (type));
1966 stabstr_S ("real:");
1967 dbxout_type (TREE_TYPE (type), 0);
1969 stabstr_D (TYPE_PRECISION (TREE_TYPE (type)));
1971 stabstr_S (";imag:");
1972 dbxout_type (TREE_TYPE (type), 0);
1974 stabstr_D (TYPE_PRECISION (TREE_TYPE (type)));
1976 stabstr_D (TYPE_PRECISION (TREE_TYPE (type)));
1982 /* Make arrays of packed bits look like bitstrings for chill. */
1983 if (TYPE_PACKED (type) && use_gnu_debug_info_extensions)
1986 stabstr_D (BITS_PER_UNIT * int_size_in_bytes (type));
1987 stabstr_S (";@S;S");
1988 dbxout_type (TYPE_DOMAIN (type), 0);
1992 if (use_gnu_debug_info_extensions && vector_type)
1995 /* Output "a" followed by a range type definition
1996 for the index type of the array
1997 followed by a reference to the target-type.
1998 ar1;0;N;M for a C array of type M and size N+1. */
1999 /* Check if a character string type, which in Chill is
2000 different from an array of characters. */
2001 if (TYPE_STRING_FLAG (type) && use_gnu_debug_info_extensions)
2005 tem = TYPE_DOMAIN (type);
2009 dbxout_type_index (integer_type_node);
2010 stabstr_S (";0;-1;");
2015 dbxout_range_type (tem);
2018 dbxout_type (TREE_TYPE (type), 0);
2023 case QUAL_UNION_TYPE:
2025 tree binfo = TYPE_BINFO (type);
2027 /* Output a structure type. We must use the same test here as we
2028 use in the DBX_NO_XREFS case above. */
2029 if ((TYPE_NAME (type) != 0
2030 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
2031 && DECL_IGNORED_P (TYPE_NAME (type)))
2033 || !COMPLETE_TYPE_P (type)
2034 /* No way in DBX fmt to describe a variable size. */
2035 || ! host_integerp (TYPE_SIZE (type), 1))
2037 /* If the type is just a cross reference, output one
2038 and mark the type as partially described.
2039 If it later becomes defined, we will output
2040 its real definition.
2041 If the type has a name, don't nest its definition within
2042 another type's definition; instead, output an xref
2043 and let the definition come when the name is defined. */
2044 stabstr_S ((TREE_CODE (type) == RECORD_TYPE) ? "xs" : "xu");
2045 if (TYPE_NAME (type) != 0
2046 /* The C frontend creates for anonymous variable length
2047 records/unions TYPE_NAME with DECL_NAME NULL. */
2048 && (TREE_CODE (TYPE_NAME (type)) != TYPE_DECL
2049 || DECL_NAME (TYPE_NAME (type))))
2050 dbxout_type_name (type);
2054 stabstr_D (anonymous_type_number++);
2058 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
2062 /* Identify record or union, and print its size. */
2063 stabstr_C ((TREE_CODE (type) == RECORD_TYPE) ? 's' : 'u');
2064 stabstr_D (int_size_in_bytes (type));
2070 VEC(tree,gc) *accesses = BINFO_BASE_ACCESSES (binfo);
2072 if (use_gnu_debug_info_extensions)
2074 if (BINFO_N_BASE_BINFOS (binfo))
2077 stabstr_U (BINFO_N_BASE_BINFOS (binfo));
2081 for (i = 0; BINFO_BASE_ITERATE (binfo, i, child); i++)
2083 tree access = (accesses ? VEC_index (tree, accesses, i)
2084 : access_public_node);
2086 if (use_gnu_debug_info_extensions)
2088 stabstr_C (BINFO_VIRTUAL_P (child) ? '1' : '0');
2089 stabstr_C (access == access_public_node ? '2' :
2090 access == access_protected_node
2092 if (BINFO_VIRTUAL_P (child)
2093 && (strcmp (lang_hooks.name, "GNU C++") == 0
2094 || strcmp (lang_hooks.name, "GNU Objective-C++") == 0))
2095 /* For a virtual base, print the (negative)
2096 offset within the vtable where we must look
2097 to find the necessary adjustment. */
2099 (tree_low_cst (BINFO_VPTR_FIELD (child), 0)
2102 stabstr_D (tree_low_cst (BINFO_OFFSET (child), 0)
2105 dbxout_type (BINFO_TYPE (child), 0);
2110 /* Print out the base class information with
2111 fields which have the same names at the types
2113 dbxout_type_name (BINFO_TYPE (child));
2115 dbxout_type (BINFO_TYPE (child), full);
2117 stabstr_D (tree_low_cst (BINFO_OFFSET (child), 0)
2121 (tree_low_cst (TYPE_SIZE (BINFO_TYPE (child)), 0)
2129 /* Write out the field declarations. */
2130 dbxout_type_fields (type);
2131 if (use_gnu_debug_info_extensions && TYPE_METHODS (type) != NULL_TREE)
2133 dbxout_type_methods (type);
2138 if (use_gnu_debug_info_extensions && TREE_CODE (type) == RECORD_TYPE
2139 /* Avoid the ~ if we don't really need it--it confuses dbx. */
2140 && TYPE_VFIELD (type))
2143 /* We need to write out info about what field this class
2144 uses as its "main" vtable pointer field, because if this
2145 field is inherited from a base class, GDB cannot necessarily
2146 figure out which field it's using in time. */
2148 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type)), 0);
2154 /* We must use the same test here as we use in the DBX_NO_XREFS case
2155 above. We simplify it a bit since an enum will never have a variable
2157 if ((TYPE_NAME (type) != 0
2158 && ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
2159 && DECL_IGNORED_P (TYPE_NAME (type)))
2161 || !COMPLETE_TYPE_P (type))
2164 dbxout_type_name (type);
2165 typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
2169 if (use_gnu_debug_info_extensions
2170 && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
2173 stabstr_D (TYPE_PRECISION (type));
2178 for (tem = TYPE_VALUES (type); tem; tem = TREE_CHAIN (tem))
2180 tree value = TREE_VALUE (tem);
2182 stabstr_I (TREE_PURPOSE (tem));
2185 if (TREE_CODE (value) == CONST_DECL)
2186 value = DECL_INITIAL (value);
2188 if (TREE_INT_CST_HIGH (value) == 0)
2189 stabstr_D (TREE_INT_CST_LOW (value));
2190 else if (TREE_INT_CST_HIGH (value) == -1
2191 && (HOST_WIDE_INT) TREE_INT_CST_LOW (value) < 0)
2192 stabstr_D (TREE_INT_CST_LOW (value));
2197 if (TREE_CHAIN (tem) != 0)
2206 dbxout_type (TREE_TYPE (type), 0);
2210 if (use_gnu_debug_info_extensions)
2214 /* Write the argument types out longhand. */
2215 dbxout_type (TYPE_METHOD_BASETYPE (type), 0);
2217 dbxout_type (TREE_TYPE (type), 0);
2218 dbxout_args (TYPE_ARG_TYPES (type));
2222 /* Treat it as a function type. */
2223 dbxout_type (TREE_TYPE (type), 0);
2227 if (use_gnu_debug_info_extensions)
2230 dbxout_type (TYPE_OFFSET_BASETYPE (type), 0);
2232 dbxout_type (TREE_TYPE (type), 0);
2235 /* Should print as an int, because it is really just an offset. */
2236 dbxout_type (integer_type_node, 0);
2239 case REFERENCE_TYPE:
2240 if (use_gnu_debug_info_extensions)
2246 dbxout_type (TREE_TYPE (type), 0);
2251 dbxout_type (TREE_TYPE (type), 0);
2259 /* Return nonzero if the given type represents an integer whose bounds
2260 should be printed in octal format. */
2263 print_int_cst_bounds_in_octal_p (tree type)
2265 /* If we can use GDB extensions and the size is wider than a long
2266 (the size used by GDB to read them) or we may have trouble writing
2267 the bounds the usual way, write them in octal. Note the test is for
2268 the *target's* size of "long", not that of the host. The host test
2269 is just to make sure we can write it out in case the host wide int
2270 is narrower than the target "long".
2272 For unsigned types, we use octal if they are the same size or larger.
2273 This is because we print the bounds as signed decimal, and hence they
2274 can't span same size unsigned types. */
2276 if (use_gnu_debug_info_extensions
2277 && TYPE_MIN_VALUE (type) != 0
2278 && TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST
2279 && TYPE_MAX_VALUE (type) != 0
2280 && TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST
2281 && (TYPE_PRECISION (type) > TYPE_PRECISION (integer_type_node)
2282 || ((TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
2283 && TYPE_UNSIGNED (type))
2284 || TYPE_PRECISION (type) > HOST_BITS_PER_WIDE_INT
2285 || (TYPE_PRECISION (type) == HOST_BITS_PER_WIDE_INT
2286 && TYPE_UNSIGNED (type))))
2292 /* Output the name of type TYPE, with no punctuation.
2293 Such names can be set up either by typedef declarations
2294 or by struct, enum and union tags. */
2297 dbxout_type_name (tree type)
2299 tree t = TYPE_NAME (type);
2302 switch (TREE_CODE (t))
2304 case IDENTIFIER_NODE:
2316 /* Output leading leading struct or class names needed for qualifying
2317 type whose scope is limited to a struct or class. */
2320 dbxout_class_name_qualifiers (tree decl)
2322 tree context = decl_type_context (decl);
2324 if (context != NULL_TREE
2325 && TREE_CODE(context) == RECORD_TYPE
2326 && TYPE_NAME (context) != 0
2327 && (TREE_CODE (TYPE_NAME (context)) == IDENTIFIER_NODE
2328 || (DECL_NAME (TYPE_NAME (context)) != 0)))
2330 tree name = TYPE_NAME (context);
2332 if (TREE_CODE (name) == TYPE_DECL)
2334 dbxout_class_name_qualifiers (name);
2335 name = DECL_NAME (name);
2342 /* This is a specialized subset of expand_expr for use by dbxout_symbol in
2343 evaluating DECL_VALUE_EXPR. In particular, we stop if we find decls that
2344 haven't been expanded, or if the expression is getting so complex we won't
2345 be able to represent it in stabs anyway. Returns NULL on failure. */
2348 dbxout_expand_expr (tree expr)
2350 switch (TREE_CODE (expr))
2353 /* We can't handle emulated tls variables, because the address is an
2354 offset to the return value of __emutls_get_address, and there is no
2355 way to express that in stabs. Also, there are name mangling issues
2356 here. We end up with references to undefined symbols if we don't
2357 disable debug info for these variables. */
2358 if (!targetm.have_tls && DECL_THREAD_LOCAL_P (expr))
2363 if (DECL_HAS_VALUE_EXPR_P (expr))
2364 return dbxout_expand_expr (DECL_VALUE_EXPR (expr));
2369 return DECL_RTL_IF_SET (expr);
2372 return expand_expr (expr, NULL_RTX, VOIDmode, EXPAND_INITIALIZER);
2376 case ARRAY_RANGE_REF:
2379 enum machine_mode mode;
2380 HOST_WIDE_INT bitsize, bitpos;
2382 int volatilep = 0, unsignedp = 0;
2385 tem = get_inner_reference (expr, &bitsize, &bitpos, &offset,
2386 &mode, &unsignedp, &volatilep, true);
2388 x = dbxout_expand_expr (tem);
2389 if (x == NULL || !MEM_P (x))
2393 if (!host_integerp (offset, 0))
2395 x = adjust_address_nv (x, mode, tree_low_cst (offset, 0));
2398 x = adjust_address_nv (x, mode, bitpos / BITS_PER_UNIT);
2408 /* Helper function for output_used_types. Queue one entry from the
2409 used types hash to be output. */
2412 output_used_types_helper (void **slot, void *data)
2414 tree type = (tree) *slot;
2415 VEC(tree, heap) **types_p = (VEC(tree, heap) **) data;
2417 if ((TREE_CODE (type) == RECORD_TYPE
2418 || TREE_CODE (type) == UNION_TYPE
2419 || TREE_CODE (type) == QUAL_UNION_TYPE
2420 || TREE_CODE (type) == ENUMERAL_TYPE)
2421 && TYPE_STUB_DECL (type)
2422 && DECL_P (TYPE_STUB_DECL (type))
2423 && ! DECL_IGNORED_P (TYPE_STUB_DECL (type)))
2424 VEC_quick_push (tree, *types_p, TYPE_STUB_DECL (type));
2425 else if (TYPE_NAME (type)
2426 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
2427 VEC_quick_push (tree, *types_p, TYPE_NAME (type));
2432 /* This is a qsort callback which sorts types and declarations into a
2433 predictable order (types, then declarations, sorted by UID
2437 output_types_sort (const void *pa, const void *pb)
2439 const tree lhs = *((const tree *)pa);
2440 const tree rhs = *((const tree *)pb);
2445 return TYPE_UID (lhs) - TYPE_UID (rhs);
2454 return DECL_UID (lhs) - DECL_UID (rhs);
2459 /* Force all types used by this function to be output in debug
2463 output_used_types (void)
2465 if (cfun && cfun->used_types_hash)
2467 VEC(tree, heap) *types;
2471 types = VEC_alloc (tree, heap, htab_elements (cfun->used_types_hash));
2472 htab_traverse (cfun->used_types_hash, output_used_types_helper, &types);
2474 /* Sort by UID to prevent dependence on hash table ordering. */
2475 qsort (VEC_address (tree, types), VEC_length (tree, types),
2476 sizeof (tree), output_types_sort);
2478 for (i = 0; VEC_iterate (tree, types, i, type); i++)
2479 debug_queue_symbol (type);
2481 VEC_free (tree, heap, types);
2485 /* Output a .stabs for the symbol defined by DECL,
2486 which must be a ..._DECL node in the normal namespace.
2487 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
2488 LOCAL is nonzero if the scope is less than the entire file.
2489 Return 1 if a stabs might have been emitted. */
2492 dbxout_symbol (tree decl, int local ATTRIBUTE_UNUSED)
2494 tree type = TREE_TYPE (decl);
2495 tree context = NULL_TREE;
2499 /* "Intercept" dbxout_symbol() calls like we do all debug_hooks. */
2502 /* Ignore nameless syms, but don't ignore type tags. */
2504 if ((DECL_NAME (decl) == 0 && TREE_CODE (decl) != TYPE_DECL)
2505 || DECL_IGNORED_P (decl))
2506 DBXOUT_DECR_NESTING_AND_RETURN (0);
2508 /* If we are to generate only the symbols actually used then such
2509 symbol nodes are flagged with TREE_USED. Ignore any that
2510 aren't flagged as TREE_USED. */
2512 if (flag_debug_only_used_symbols
2513 && (!TREE_USED (decl)
2514 && (TREE_CODE (decl) != VAR_DECL || !DECL_INITIAL (decl))))
2515 DBXOUT_DECR_NESTING_AND_RETURN (0);
2517 /* If dbxout_init has not yet run, queue this symbol for later. */
2520 preinit_symbols = tree_cons (0, decl, preinit_symbols);
2521 DBXOUT_DECR_NESTING_AND_RETURN (0);
2524 if (flag_debug_only_used_symbols)
2528 /* We now have a used symbol. We need to generate the info for
2529 the symbol's type in addition to the symbol itself. These
2530 type symbols are queued to be generated after were done with
2531 the symbol itself (otherwise they would fight over the
2534 Note, because the TREE_TYPE(type) might be something like a
2535 pointer to a named type we need to look for the first name
2536 we see following the TREE_TYPE chain. */
2539 while (POINTER_TYPE_P (t))
2542 /* RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, and ENUMERAL_TYPE
2543 need special treatment. The TYPE_STUB_DECL field in these
2544 types generally represents the tag name type we want to
2545 output. In addition there could be a typedef type with
2546 a different name. In that case we also want to output
2549 if (TREE_CODE (t) == RECORD_TYPE
2550 || TREE_CODE (t) == UNION_TYPE
2551 || TREE_CODE (t) == QUAL_UNION_TYPE
2552 || TREE_CODE (t) == ENUMERAL_TYPE)
2554 if (TYPE_STUB_DECL (t)
2555 && TYPE_STUB_DECL (t) != decl
2556 && DECL_P (TYPE_STUB_DECL (t))
2557 && ! DECL_IGNORED_P (TYPE_STUB_DECL (t)))
2559 debug_queue_symbol (TYPE_STUB_DECL (t));
2561 && TYPE_NAME (t) != TYPE_STUB_DECL (t)
2562 && TYPE_NAME (t) != decl
2563 && DECL_P (TYPE_NAME (t)))
2564 debug_queue_symbol (TYPE_NAME (t));
2567 else if (TYPE_NAME (t)
2568 && TYPE_NAME (t) != decl
2569 && DECL_P (TYPE_NAME (t)))
2570 debug_queue_symbol (TYPE_NAME (t));
2573 emit_pending_bincls_if_required ();
2575 switch (TREE_CODE (decl))
2578 /* Enum values are defined by defining the enum type. */
2582 decl_rtl = DECL_RTL_IF_SET (decl);
2584 DBXOUT_DECR_NESTING_AND_RETURN (0);
2585 if (DECL_EXTERNAL (decl))
2587 /* Don't mention a nested function under its parent. */
2588 context = decl_function_context (decl);
2589 if (context == current_function_decl)
2591 /* Don't mention an inline instance of a nested function. */
2592 if (context && DECL_FROM_INLINE (decl))
2594 if (!MEM_P (decl_rtl)
2595 || GET_CODE (XEXP (decl_rtl, 0)) != SYMBOL_REF)
2598 if (flag_debug_only_used_symbols)
2599 output_used_types ();
2601 dbxout_begin_complex_stabs ();
2602 stabstr_I (DECL_ASSEMBLER_NAME (decl));
2603 stabstr_S (TREE_PUBLIC (decl) ? ":F" : ":f");
2606 if (TREE_TYPE (type))
2607 dbxout_type (TREE_TYPE (type), 0);
2609 dbxout_type (void_type_node, 0);
2611 /* For a nested function, when that function is compiled,
2612 mention the containing function name
2613 as well as (since dbx wants it) our own assembler-name. */
2617 stabstr_I (DECL_ASSEMBLER_NAME (decl));
2619 stabstr_I (DECL_NAME (context));
2622 dbxout_finish_complex_stabs (decl, N_FUN, XEXP (decl_rtl, 0), 0, 0);
2626 /* Don't output the same typedef twice.
2627 And don't output what language-specific stuff doesn't want output. */
2628 if (TREE_ASM_WRITTEN (decl) || TYPE_DECL_SUPPRESS_DEBUG (decl))
2629 DBXOUT_DECR_NESTING_AND_RETURN (0);
2631 /* Don't output typedefs for types with magic type numbers (XCOFF). */
2632 #ifdef DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER
2634 int fundamental_type_number =
2635 DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER (decl);
2637 if (fundamental_type_number != 0)
2639 TREE_ASM_WRITTEN (decl) = 1;
2640 TYPE_SYMTAB_ADDRESS (TREE_TYPE (decl)) = fundamental_type_number;
2641 DBXOUT_DECR_NESTING_AND_RETURN (0);
2651 if (DECL_NAME (decl))
2653 /* Nonzero means we must output a tag as well as a typedef. */
2656 /* Handle the case of a C++ structure or union
2657 where the TYPE_NAME is a TYPE_DECL
2658 which gives both a typedef name and a tag. */
2659 /* dbx requires the tag first and the typedef second. */
2660 if ((TREE_CODE (type) == RECORD_TYPE
2661 || TREE_CODE (type) == UNION_TYPE
2662 || TREE_CODE (type) == QUAL_UNION_TYPE)
2663 && TYPE_NAME (type) == decl
2664 && !use_gnu_debug_info_extensions
2665 && !TREE_ASM_WRITTEN (TYPE_NAME (type))
2666 /* Distinguish the implicit typedefs of C++
2667 from explicit ones that might be found in C. */
2668 && DECL_ARTIFICIAL (decl)
2669 /* Do not generate a tag for incomplete records. */
2670 && COMPLETE_TYPE_P (type)
2671 /* Do not generate a tag for records of variable size,
2672 since this type can not be properly described in the
2673 DBX format, and it confuses some tools such as objdump. */
2674 && host_integerp (TYPE_SIZE (type), 1))
2676 tree name = TYPE_NAME (type);
2677 if (TREE_CODE (name) == TYPE_DECL)
2678 name = DECL_NAME (name);
2680 dbxout_begin_complex_stabs ();
2683 dbxout_type (type, 1);
2684 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE,
2688 dbxout_begin_complex_stabs ();
2690 /* Output leading class/struct qualifiers. */
2691 if (use_gnu_debug_info_extensions)
2692 dbxout_class_name_qualifiers (decl);
2694 /* Output typedef name. */
2695 stabstr_I (DECL_NAME (decl));
2698 /* Short cut way to output a tag also. */
2699 if ((TREE_CODE (type) == RECORD_TYPE
2700 || TREE_CODE (type) == UNION_TYPE
2701 || TREE_CODE (type) == QUAL_UNION_TYPE)
2702 && TYPE_NAME (type) == decl
2703 /* Distinguish the implicit typedefs of C++
2704 from explicit ones that might be found in C. */
2705 && DECL_ARTIFICIAL (decl))
2707 if (use_gnu_debug_info_extensions)
2710 TREE_ASM_WRITTEN (TYPE_NAME (type)) = 1;
2715 dbxout_type (type, 1);
2716 dbxout_finish_complex_stabs (decl, DBX_TYPE_DECL_STABS_CODE,
2721 /* Don't output a tag if this is an incomplete type. This prevents
2722 the sun4 Sun OS 4.x dbx from crashing. */
2724 if (tag_needed && TYPE_NAME (type) != 0
2725 && (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE
2726 || (DECL_NAME (TYPE_NAME (type)) != 0))
2727 && COMPLETE_TYPE_P (type)
2728 && !TREE_ASM_WRITTEN (TYPE_NAME (type)))
2730 /* For a TYPE_DECL with no name, but the type has a name,
2732 This is what represents `struct foo' with no typedef. */
2733 /* In C++, the name of a type is the corresponding typedef.
2734 In C, it is an IDENTIFIER_NODE. */
2735 tree name = TYPE_NAME (type);
2736 if (TREE_CODE (name) == TYPE_DECL)
2737 name = DECL_NAME (name);
2739 dbxout_begin_complex_stabs ();
2742 dbxout_type (type, 1);
2743 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE, 0, 0, 0);
2747 /* If an enum type has no name, it cannot be referred to, but
2748 we must output it anyway, to record the enumeration
2751 if (!did_output && TREE_CODE (type) == ENUMERAL_TYPE)
2753 dbxout_begin_complex_stabs ();
2754 /* Some debuggers fail when given NULL names, so give this a
2755 harmless name of " " (Why not "(anon)"?). */
2757 dbxout_type (type, 1);
2758 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE, 0, 0, 0);
2761 /* Prevent duplicate output of a typedef. */
2762 TREE_ASM_WRITTEN (decl) = 1;
2767 /* Parm decls go in their own separate chains
2768 and are output by dbxout_reg_parms and dbxout_parms. */
2773 /* Don't mention a variable that is external.
2774 Let the file that defines it describe it. */
2775 if (DECL_EXTERNAL (decl))
2778 /* If the variable is really a constant
2779 and not written in memory, inform the debugger.
2781 ??? Why do we skip emitting the type and location in this case? */
2782 if (TREE_STATIC (decl) && TREE_READONLY (decl)
2783 && DECL_INITIAL (decl) != 0
2784 && host_integerp (DECL_INITIAL (decl), 0)
2785 && ! TREE_ASM_WRITTEN (decl)
2786 && (DECL_CONTEXT (decl) == NULL_TREE
2787 || TREE_CODE (DECL_CONTEXT (decl)) == BLOCK
2788 || TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL)
2789 && TREE_PUBLIC (decl) == 0)
2791 /* The sun4 assembler does not grok this. */
2793 if (TREE_CODE (TREE_TYPE (decl)) == INTEGER_TYPE
2794 || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
2796 HOST_WIDE_INT ival = TREE_INT_CST_LOW (DECL_INITIAL (decl));
2798 dbxout_begin_complex_stabs ();
2799 dbxout_symbol_name (decl, NULL, 'c');
2802 dbxout_finish_complex_stabs (0, N_LSYM, 0, 0, 0);
2803 DBXOUT_DECR_NESTING;
2809 /* else it is something we handle like a normal variable. */
2811 decl_rtl = dbxout_expand_expr (decl);
2813 DBXOUT_DECR_NESTING_AND_RETURN (0);
2815 decl_rtl = eliminate_regs (decl_rtl, VOIDmode, NULL_RTX);
2816 #ifdef LEAF_REG_REMAP
2817 if (current_function_uses_only_leaf_regs)
2818 leaf_renumber_regs_insn (decl_rtl);
2821 result = dbxout_symbol_location (decl, type, 0, decl_rtl);
2827 DBXOUT_DECR_NESTING;
2831 /* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL.
2832 Add SUFFIX to its name, if SUFFIX is not 0.
2833 Describe the variable as residing in HOME
2834 (usually HOME is DECL_RTL (DECL), but not always).
2835 Returns 1 if the stab was really emitted. */
2838 dbxout_symbol_location (tree decl, tree type, const char *suffix, rtx home)
2841 STAB_CODE_TYPE code;
2846 /* Don't mention a variable at all
2847 if it was completely optimized into nothingness.
2849 If the decl was from an inline function, then its rtl
2850 is not identically the rtl that was used in this
2851 particular compilation. */
2852 if (GET_CODE (home) == SUBREG)
2856 while (GET_CODE (value) == SUBREG)
2857 value = SUBREG_REG (value);
2860 if (REGNO (value) >= FIRST_PSEUDO_REGISTER)
2863 home = alter_subreg (&home);
2867 regno = REGNO (home);
2868 if (regno >= FIRST_PSEUDO_REGISTER)
2872 /* The kind-of-variable letter depends on where
2873 the variable is and on the scope of its name:
2874 G and N_GSYM for static storage and global scope,
2875 S for static storage and file scope,
2876 V for static storage and local scope,
2877 for those two, use N_LCSYM if data is in bss segment,
2878 N_STSYM if in data segment, N_FUN otherwise.
2879 (We used N_FUN originally, then changed to N_STSYM
2880 to please GDB. However, it seems that confused ld.
2881 Now GDB has been fixed to like N_FUN, says Kingdon.)
2882 no letter at all, and N_LSYM, for auto variable,
2883 r and N_RSYM for register variable. */
2885 if (MEM_P (home) && GET_CODE (XEXP (home, 0)) == SYMBOL_REF)
2887 if (TREE_PUBLIC (decl))
2892 if (NULL != dbxout_common_check (decl, &offs))
2901 addr = XEXP (home, 0);
2903 letter = decl_function_context (decl) ? 'V' : 'S';
2905 /* Some ports can transform a symbol ref into a label ref,
2906 because the symbol ref is too far away and has to be
2907 dumped into a constant pool. Alternatively, the symbol
2908 in the constant pool might be referenced by a different
2910 if (GET_CODE (addr) == SYMBOL_REF
2911 && CONSTANT_POOL_ADDRESS_P (addr))
2914 rtx tmp = get_pool_constant_mark (addr, &marked);
2916 if (GET_CODE (tmp) == SYMBOL_REF)
2919 if (CONSTANT_POOL_ADDRESS_P (addr))
2920 get_pool_constant_mark (addr, &marked);
2924 else if (GET_CODE (tmp) == LABEL_REF)
2930 /* If all references to the constant pool were optimized
2931 out, we just ignore the symbol. */
2936 /* This should be the same condition as in assemble_variable, but
2937 we don't have access to dont_output_data here. So, instead,
2938 we rely on the fact that error_mark_node initializers always
2939 end up in bss for C++ and never end up in bss for C. */
2940 if (DECL_INITIAL (decl) == 0
2941 || (!strcmp (lang_hooks.name, "GNU C++")
2942 && DECL_INITIAL (decl) == error_mark_node))
2946 if (NULL != dbxout_common_check (decl, &offs))
2954 else if (DECL_IN_TEXT_SECTION (decl))
2955 /* This is not quite right, but it's the closest
2956 of all the codes that Unix defines. */
2957 code = DBX_STATIC_CONST_VAR_CODE;
2960 /* Ultrix `as' seems to need this. */
2961 #ifdef DBX_STATIC_STAB_DATA_SECTION
2962 switch_to_section (data_section);
2968 else if (regno >= 0)
2972 number = DBX_REGISTER_NUMBER (regno);
2974 else if (MEM_P (home)
2975 && (MEM_P (XEXP (home, 0))
2976 || (REG_P (XEXP (home, 0))
2977 && REGNO (XEXP (home, 0)) != HARD_FRAME_POINTER_REGNUM
2978 && REGNO (XEXP (home, 0)) != STACK_POINTER_REGNUM
2979 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2980 && REGNO (XEXP (home, 0)) != ARG_POINTER_REGNUM
2983 /* If the value is indirect by memory or by a register
2984 that isn't the frame pointer
2985 then it means the object is variable-sized and address through
2986 that register or stack slot. DBX has no way to represent this
2987 so all we can do is output the variable as a pointer.
2988 If it's not a parameter, ignore it. */
2990 if (REG_P (XEXP (home, 0)))
2994 if (REGNO (XEXP (home, 0)) >= FIRST_PSEUDO_REGISTER)
2996 number = DBX_REGISTER_NUMBER (REGNO (XEXP (home, 0)));
3001 /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
3002 We want the value of that CONST_INT. */
3003 number = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home, 0), 0));
3006 /* Effectively do build_pointer_type, but don't cache this type,
3007 since it might be temporary whereas the type it points to
3008 might have been saved for inlining. */
3009 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
3010 type = make_node (POINTER_TYPE);
3011 TREE_TYPE (type) = TREE_TYPE (decl);
3013 else if (MEM_P (home)
3014 && REG_P (XEXP (home, 0)))
3017 number = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
3019 else if (MEM_P (home)
3020 && GET_CODE (XEXP (home, 0)) == PLUS
3021 && GET_CODE (XEXP (XEXP (home, 0), 1)) == CONST_INT)
3024 /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
3025 We want the value of that CONST_INT. */
3026 number = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
3028 else if (MEM_P (home)
3029 && GET_CODE (XEXP (home, 0)) == CONST)
3031 /* Handle an obscure case which can arise when optimizing and
3032 when there are few available registers. (This is *always*
3033 the case for i386/i486 targets). The RTL looks like
3034 (MEM (CONST ...)) even though this variable is a local `auto'
3035 or a local `register' variable. In effect, what has happened
3036 is that the reload pass has seen that all assignments and
3037 references for one such a local variable can be replaced by
3038 equivalent assignments and references to some static storage
3039 variable, thereby avoiding the need for a register. In such
3040 cases we're forced to lie to debuggers and tell them that
3041 this variable was itself `static'. */
3045 if (NULL == dbxout_common_check (decl, &offs))
3046 addr = XEXP (XEXP (home, 0), 0);
3054 else if (GET_CODE (home) == CONCAT)
3058 /* If TYPE is not a COMPLEX_TYPE (it might be a RECORD_TYPE,
3059 for example), then there is no easy way to figure out
3060 what SUBTYPE should be. So, we give up. */
3061 if (TREE_CODE (type) != COMPLEX_TYPE)
3064 subtype = TREE_TYPE (type);
3066 /* If the variable's storage is in two parts,
3067 output each as a separate stab with a modified name. */
3068 if (WORDS_BIG_ENDIAN)
3069 dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 0));
3071 dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 0));
3073 if (WORDS_BIG_ENDIAN)
3074 dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 1));
3076 dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 1));
3080 /* Address might be a MEM, when DECL is a variable-sized object.
3081 Or it might be const0_rtx, meaning previous passes
3082 want us to ignore this variable. */
3085 /* Ok, start a symtab entry and output the variable name. */
3086 emit_pending_bincls_if_required ();
3089 #ifdef DBX_STATIC_BLOCK_START
3090 DBX_STATIC_BLOCK_START (asm_out_file, code);
3093 dbxout_begin_complex_stabs_noforcetext ();
3094 dbxout_symbol_name (decl, suffix, letter);
3095 dbxout_type (type, 0);
3096 dbxout_finish_complex_stabs (decl, code, addr, 0, number);
3098 #ifdef DBX_STATIC_BLOCK_END
3099 DBX_STATIC_BLOCK_END (asm_out_file, code);
3104 /* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
3105 Then output LETTER to indicate the kind of location the symbol has. */
3108 dbxout_symbol_name (tree decl, const char *suffix, int letter)
3112 if (DECL_CONTEXT (decl)
3113 && (TYPE_P (DECL_CONTEXT (decl))
3114 || TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL))
3115 /* One slight hitch: if this is a VAR_DECL which is a class member
3116 or a namespace member, we must put out the mangled name instead of the
3117 DECL_NAME. Note also that static member (variable) names DO NOT begin
3118 with underscores in .stabs directives. */
3119 name = DECL_ASSEMBLER_NAME (decl);
3121 /* ...but if we're function-local, we don't want to include the junk
3122 added by ASM_FORMAT_PRIVATE_NAME. */
3123 name = DECL_NAME (decl);
3128 stabstr_S ("(anon)");
3138 /* Output the common block name for DECL in a stabs.
3140 Symbols in global common (.comm) get wrapped with an N_BCOMM/N_ECOMM pair
3141 around each group of symbols in the same .comm area. The N_GSYM stabs
3142 that are emitted only contain the offset in the common area. This routine
3143 emits the N_BCOMM and N_ECOMM stabs. */
3146 dbxout_common_name (tree decl, const char *name, STAB_CODE_TYPE op)
3148 dbxout_begin_complex_stabs ();
3150 dbxout_finish_complex_stabs (decl, op, NULL_RTX, NULL, 0);
3153 /* Check decl to determine whether it is a VAR_DECL destined for storage in a
3154 common area. If it is, the return value will be a non-null string giving
3155 the name of the common storage block it will go into. If non-null, the
3156 value is the offset into the common block for that symbol's storage. */
3159 dbxout_common_check (tree decl, int *value)
3163 const char *name = NULL;
3165 /* If the decl isn't a VAR_DECL, or if it isn't public or static, or if
3166 it does not have a value (the offset into the common area), or if it
3167 is thread local (as opposed to global) then it isn't common, and shouldn't
3170 ??? DECL_THREAD_LOCAL_P check prevents problems with improper .stabs
3171 for thread-local symbols. Can be handled via same mechanism as used
3173 if (TREE_CODE (decl) != VAR_DECL
3174 || !TREE_PUBLIC(decl)
3175 || !TREE_STATIC(decl)
3176 || !DECL_HAS_VALUE_EXPR_P(decl)
3177 || DECL_THREAD_LOCAL_P (decl)
3181 home = DECL_RTL (decl);
3182 if (home == NULL_RTX || GET_CODE (home) != MEM)
3185 sym_addr = dbxout_expand_expr (DECL_VALUE_EXPR (decl));
3186 if (sym_addr == NULL_RTX || GET_CODE (sym_addr) != MEM)
3189 sym_addr = XEXP (sym_addr, 0);
3190 if (GET_CODE (sym_addr) == CONST)
3191 sym_addr = XEXP (sym_addr, 0);
3192 if ((GET_CODE (sym_addr) == SYMBOL_REF || GET_CODE (sym_addr) == PLUS)
3193 && DECL_INITIAL (decl) == 0)
3196 /* We have a sym that will go into a common area, meaning that it
3197 will get storage reserved with a .comm/.lcomm assembler pseudo-op.
3199 Determine name of common area this symbol will be an offset into,
3200 and offset into that area. Also retrieve the decl for the area
3201 that the symbol is offset into. */
3204 switch (GET_CODE (sym_addr))
3207 if (GET_CODE (XEXP (sym_addr, 0)) == CONST_INT)
3210 targetm.strip_name_encoding(XSTR (XEXP (sym_addr, 1), 0));
3211 *value = INTVAL (XEXP (sym_addr, 0));
3212 cdecl = SYMBOL_REF_DECL (XEXP (sym_addr, 1));
3217 targetm.strip_name_encoding(XSTR (XEXP (sym_addr, 0), 0));
3218 *value = INTVAL (XEXP (sym_addr, 1));
3219 cdecl = SYMBOL_REF_DECL (XEXP (sym_addr, 0));
3224 name = targetm.strip_name_encoding(XSTR (sym_addr, 0));
3226 cdecl = SYMBOL_REF_DECL (sym_addr);
3230 error ("common symbol debug info is not structured as "
3234 /* Check area common symbol is offset into. If this is not public, then
3235 it is not a symbol in a common block. It must be a .lcomm symbol, not
3237 if (cdecl == NULL || !TREE_PUBLIC(cdecl))
3246 /* Output definitions of all the decls in a chain. Return nonzero if
3247 anything was output */
3250 dbxout_syms (tree syms)
3253 const char *comm_prev = NULL;
3254 tree syms_prev = NULL;
3258 int temp, copen, cclos;
3259 const char *comm_new;
3261 /* Check for common symbol, and then progression into a new/different
3262 block of common symbols. Emit closing/opening common bracket if
3264 comm_new = dbxout_common_check (syms, &temp);
3265 copen = comm_new != NULL
3266 && (comm_prev == NULL || strcmp (comm_new, comm_prev));
3267 cclos = comm_prev != NULL
3268 && (comm_new == NULL || strcmp (comm_new, comm_prev));
3270 dbxout_common_name (syms_prev, comm_prev, N_ECOMM);
3273 dbxout_common_name (syms, comm_new, N_BCOMM);
3276 comm_prev = comm_new;
3278 result += dbxout_symbol (syms, 1);
3279 syms = TREE_CHAIN (syms);
3282 if (comm_prev != NULL)
3283 dbxout_common_name (syms_prev, comm_prev, N_ECOMM);
3288 /* The following two functions output definitions of function parameters.
3289 Each parameter gets a definition locating it in the parameter list.
3290 Each parameter that is a register variable gets a second definition
3291 locating it in the register.
3293 Printing or argument lists in gdb uses the definitions that
3294 locate in the parameter list. But reference to the variable in
3295 expressions uses preferentially the definition as a register. */
3297 /* Output definitions, referring to storage in the parmlist,
3298 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
3301 dbxout_parms (tree parms)
3304 emit_pending_bincls_if_required ();
3306 for (; parms; parms = TREE_CHAIN (parms))
3307 if (DECL_NAME (parms)
3308 && TREE_TYPE (parms) != error_mark_node
3309 && DECL_RTL_SET_P (parms)
3310 && DECL_INCOMING_RTL (parms))
3314 STAB_CODE_TYPE code;
3317 /* Perform any necessary register eliminations on the parameter's rtl,
3318 so that the debugging output will be accurate. */
3319 DECL_INCOMING_RTL (parms)
3320 = eliminate_regs (DECL_INCOMING_RTL (parms), VOIDmode, NULL_RTX);
3321 SET_DECL_RTL (parms,
3322 eliminate_regs (DECL_RTL (parms), VOIDmode, NULL_RTX));
3323 #ifdef LEAF_REG_REMAP
3324 if (current_function_uses_only_leaf_regs)
3326 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms));
3327 leaf_renumber_regs_insn (DECL_RTL (parms));
3331 if (PARM_PASSED_IN_MEMORY (parms))
3333 rtx inrtl = XEXP (DECL_INCOMING_RTL (parms), 0);
3335 /* ??? Here we assume that the parm address is indexed
3336 off the frame pointer or arg pointer.
3337 If that is not true, we produce meaningless results,
3338 but do not crash. */
3339 if (GET_CODE (inrtl) == PLUS
3340 && GET_CODE (XEXP (inrtl, 1)) == CONST_INT)
3341 number = INTVAL (XEXP (inrtl, 1));
3346 number = DEBUGGER_ARG_OFFSET (number, inrtl);
3349 /* It is quite tempting to use TREE_TYPE (parms) instead
3350 of DECL_ARG_TYPE (parms) for the eff_type, so that gcc
3351 reports the actual type of the parameter, rather than
3352 the promoted type. This certainly makes GDB's life
3353 easier, at least for some ports. The change is a bad
3354 idea however, since GDB expects to be able access the
3355 type without performing any conversions. So for
3356 example, if we were passing a float to an unprototyped
3357 function, gcc will store a double on the stack, but if
3358 we emit a stab saying the type is a float, then gdb
3359 will only read in a single value, and this will produce
3360 an erroneous value. */
3361 eff_type = DECL_ARG_TYPE (parms);
3363 else if (REG_P (DECL_RTL (parms)))
3367 /* Parm passed in registers and lives in registers or nowhere. */
3368 code = DBX_REGPARM_STABS_CODE;
3369 letter = DBX_REGPARM_STABS_LETTER;
3371 /* For parms passed in registers, it is better to use the
3372 declared type of the variable, not the type it arrived in. */
3373 eff_type = TREE_TYPE (parms);
3375 /* If parm lives in a register, use that register; pretend
3376 the parm was passed there. It would be more consistent
3377 to describe the register where the parm was passed, but
3378 in practice that register usually holds something else.
3379 If the parm lives nowhere, use the register where it
3381 if (REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
3382 best_rtl = DECL_RTL (parms);
3383 else if (GET_CODE (DECL_INCOMING_RTL (parms)) == PARALLEL)
3384 best_rtl = XEXP (XVECEXP (DECL_INCOMING_RTL (parms), 0, 0), 0);
3386 best_rtl = DECL_INCOMING_RTL (parms);
3388 number = DBX_REGISTER_NUMBER (REGNO (best_rtl));
3390 else if (MEM_P (DECL_RTL (parms))
3391 && REG_P (XEXP (DECL_RTL (parms), 0))
3392 && REGNO (XEXP (DECL_RTL (parms), 0)) != HARD_FRAME_POINTER_REGNUM
3393 && REGNO (XEXP (DECL_RTL (parms), 0)) != STACK_POINTER_REGNUM
3394 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
3395 && REGNO (XEXP (DECL_RTL (parms), 0)) != ARG_POINTER_REGNUM
3399 /* Parm was passed via invisible reference.
3400 That is, its address was passed in a register.
3401 Output it as if it lived in that register.
3402 The debugger will know from the type
3403 that it was actually passed by invisible reference. */
3405 code = DBX_REGPARM_STABS_CODE;
3407 /* GDB likes this marked with a special letter. */
3408 letter = (use_gnu_debug_info_extensions
3409 ? 'a' : DBX_REGPARM_STABS_LETTER);
3410 eff_type = TREE_TYPE (parms);
3412 /* DECL_RTL looks like (MEM (REG...). Get the register number.
3413 If it is an unallocated pseudo-reg, then use the register where
3414 it was passed instead.
3415 ??? Why is DBX_REGISTER_NUMBER not used here? */
3417 if (REGNO (XEXP (DECL_RTL (parms), 0)) < FIRST_PSEUDO_REGISTER)
3418 number = REGNO (XEXP (DECL_RTL (parms), 0));
3420 number = REGNO (DECL_INCOMING_RTL (parms));
3422 else if (MEM_P (DECL_RTL (parms))
3423 && MEM_P (XEXP (DECL_RTL (parms), 0)))
3425 /* Parm was passed via invisible reference, with the reference
3426 living on the stack. DECL_RTL looks like
3427 (MEM (MEM (PLUS (REG ...) (CONST_INT ...)))) or it
3428 could look like (MEM (MEM (REG))). */
3432 eff_type = TREE_TYPE (parms);
3434 if (!REG_P (XEXP (XEXP (DECL_RTL (parms), 0), 0)))
3435 number = INTVAL (XEXP (XEXP (XEXP (DECL_RTL (parms), 0), 0), 1));
3439 number = DEBUGGER_ARG_OFFSET (number,
3440 XEXP (XEXP (DECL_RTL (parms), 0), 0));
3442 else if (MEM_P (DECL_RTL (parms))
3443 && XEXP (DECL_RTL (parms), 0) != const0_rtx
3444 /* ??? A constant address for a parm can happen
3445 when the reg it lives in is equiv to a constant in memory.
3446 Should make this not happen, after 2.4. */
3447 && ! CONSTANT_P (XEXP (DECL_RTL (parms), 0)))
3449 /* Parm was passed in registers but lives on the stack. */
3453 eff_type = TREE_TYPE (parms);
3455 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
3456 in which case we want the value of that CONST_INT,
3458 in which case we use a value of zero. */
3459 if (!REG_P (XEXP (DECL_RTL (parms), 0)))
3460 number = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1));
3464 /* Make a big endian correction if the mode of the type of the
3465 parameter is not the same as the mode of the rtl. */
3466 if (BYTES_BIG_ENDIAN
3467 && TYPE_MODE (TREE_TYPE (parms)) != GET_MODE (DECL_RTL (parms))
3468 && GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms))) < UNITS_PER_WORD)
3469 number += (GET_MODE_SIZE (GET_MODE (DECL_RTL (parms)))
3470 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms))));
3473 /* ??? We don't know how to represent this argument. */
3476 dbxout_begin_complex_stabs ();
3478 if (DECL_NAME (parms))
3480 stabstr_I (DECL_NAME (parms));
3484 stabstr_S ("(anon):");
3486 dbxout_type (eff_type, 0);
3487 dbxout_finish_complex_stabs (parms, code, 0, 0, number);
3489 DBXOUT_DECR_NESTING;
3492 /* Output definitions for the places where parms live during the function,
3493 when different from where they were passed, when the parms were passed
3496 It is not useful to do this for parms passed in registers
3497 that live during the function in different registers, because it is
3498 impossible to look in the passed register for the passed value,
3499 so we use the within-the-function register to begin with.
3501 PARMS is a chain of PARM_DECL nodes. */
3504 dbxout_reg_parms (tree parms)
3508 for (; parms; parms = TREE_CHAIN (parms))
3509 if (DECL_NAME (parms) && PARM_PASSED_IN_MEMORY (parms))
3511 /* Report parms that live in registers during the function
3512 but were passed in memory. */
3513 if (REG_P (DECL_RTL (parms))
3514 && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
3515 dbxout_symbol_location (parms, TREE_TYPE (parms),
3516 0, DECL_RTL (parms));
3517 else if (GET_CODE (DECL_RTL (parms)) == CONCAT)
3518 dbxout_symbol_location (parms, TREE_TYPE (parms),
3519 0, DECL_RTL (parms));
3520 /* Report parms that live in memory but not where they were passed. */
3521 else if (MEM_P (DECL_RTL (parms))
3522 && ! rtx_equal_p (DECL_RTL (parms), DECL_INCOMING_RTL (parms)))
3523 dbxout_symbol_location (parms, TREE_TYPE (parms),
3524 0, DECL_RTL (parms));
3526 DBXOUT_DECR_NESTING;
3529 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
3530 output definitions of those names, in raw form */
3533 dbxout_args (tree args)
3538 dbxout_type (TREE_VALUE (args), 0);
3539 args = TREE_CHAIN (args);
3543 #if defined (DBX_DEBUGGING_INFO)
3545 /* Subroutine of dbxout_block. Emit an N_LBRAC stab referencing LABEL.
3546 BEGIN_LABEL is the name of the beginning of the function, which may
3549 dbx_output_lbrac (const char *label,
3550 const char *begin_label ATTRIBUTE_UNUSED)
3552 dbxout_begin_stabn (N_LBRAC);
3553 if (DBX_BLOCKS_FUNCTION_RELATIVE)
3554 dbxout_stab_value_label_diff (label, begin_label);
3556 dbxout_stab_value_label (label);
3559 /* Subroutine of dbxout_block. Emit an N_RBRAC stab referencing LABEL.
3560 BEGIN_LABEL is the name of the beginning of the function, which may
3563 dbx_output_rbrac (const char *label,
3564 const char *begin_label ATTRIBUTE_UNUSED)
3566 dbxout_begin_stabn (N_RBRAC);
3567 if (DBX_BLOCKS_FUNCTION_RELATIVE)
3568 dbxout_stab_value_label_diff (label, begin_label);
3570 dbxout_stab_value_label (label);
3573 /* Output everything about a symbol block (a BLOCK node
3574 that represents a scope level),
3575 including recursive output of contained blocks.
3577 BLOCK is the BLOCK node.
3578 DEPTH is its depth within containing symbol blocks.
3579 ARGS is usually zero; but for the outermost block of the
3580 body of a function, it is a chain of PARM_DECLs for the function parameters.
3581 We output definitions of all the register parms
3582 as if they were local variables of that block.
3584 If -g1 was used, we count blocks just the same, but output nothing
3585 except for the outermost block.
3587 Actually, BLOCK may be several blocks chained together.
3588 We handle them all in sequence. */
3591 dbxout_block (tree block, int depth, tree args)
3593 char begin_label[20];
3594 /* Reference current function start using LFBB. */
3595 ASM_GENERATE_INTERNAL_LABEL (begin_label, "LFBB", scope_labelno);
3599 /* Ignore blocks never expanded or otherwise marked as real. */
3600 if (TREE_USED (block) && TREE_ASM_WRITTEN (block))
3603 int blocknum = BLOCK_NUMBER (block);
3605 /* In dbx format, the syms of a block come before the N_LBRAC.
3606 If nothing is output, we don't need the N_LBRAC, either. */
3608 if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
3609 did_output = dbxout_syms (BLOCK_VARS (block));
3611 dbxout_reg_parms (args);
3613 /* Now output an N_LBRAC symbol to represent the beginning of
3614 the block. Use the block's tree-walk order to generate
3615 the assembler symbols LBBn and LBEn
3616 that final will define around the code in this block. */
3620 const char *scope_start;
3623 /* The outermost block doesn't get LBB labels; use
3624 the LFBB local symbol emitted by dbxout_begin_prologue. */
3625 scope_start = begin_label;
3628 ASM_GENERATE_INTERNAL_LABEL (buf, "LBB", blocknum);
3632 dbx_output_lbrac (scope_start, begin_label);
3635 /* Output the subblocks. */
3636 dbxout_block (BLOCK_SUBBLOCKS (block), depth + 1, NULL_TREE);
3638 /* Refer to the marker for the end of the block. */
3643 /* The outermost block doesn't get LBE labels;
3644 use the "scope" label which will be emitted
3645 by dbxout_function_end. */
3646 ASM_GENERATE_INTERNAL_LABEL (buf, "Lscope", scope_labelno);
3648 ASM_GENERATE_INTERNAL_LABEL (buf, "LBE", blocknum);
3650 dbx_output_rbrac (buf, begin_label);
3653 block = BLOCK_CHAIN (block);
3657 /* Output the information about a function and its arguments and result.
3658 Usually this follows the function's code,
3659 but on some systems, it comes before. */
3662 dbxout_begin_function (tree decl)
3664 int saved_tree_used1;
3666 if (DECL_IGNORED_P (decl))
3669 saved_tree_used1 = TREE_USED (decl);
3670 TREE_USED (decl) = 1;
3671 if (DECL_NAME (DECL_RESULT (decl)) != 0)
3673 int saved_tree_used2 = TREE_USED (DECL_RESULT (decl));
3674 TREE_USED (DECL_RESULT (decl)) = 1;
3675 dbxout_symbol (decl, 0);
3676 TREE_USED (DECL_RESULT (decl)) = saved_tree_used2;
3679 dbxout_symbol (decl, 0);
3680 TREE_USED (decl) = saved_tree_used1;
3682 dbxout_parms (DECL_ARGUMENTS (decl));
3683 if (DECL_NAME (DECL_RESULT (decl)) != 0)
3684 dbxout_symbol (DECL_RESULT (decl), 1);
3686 #endif /* DBX_DEBUGGING_INFO */
3688 #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */
3690 #include "gt-dbxout.h"