1 /* Output dbx-format symbol table information from GNU compiler.
2 Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
23 /* Output dbx-format symbol table data.
24 This consists of many symbol table entries, each of them
25 a .stabs assembler pseudo-op with four operands:
26 a "name" which is really a description of one symbol and its type,
27 a "code", which is a symbol defined in stab.h whose name starts with N_,
28 an unused operand always 0,
29 and a "value" which is an address or an offset.
30 The name is enclosed in doublequote characters.
32 Each function, variable, typedef, and structure tag
33 has a symbol table entry to define it.
34 The beginning and end of each level of name scoping within
35 a function are also marked by special symbol table entries.
37 The "name" consists of the symbol name, a colon, a kind-of-symbol letter,
38 and a data type number. The data type number may be followed by
39 "=" and a type definition; normally this will happen the first time
40 the type number is mentioned. The type definition may refer to
41 other types by number, and those type numbers may be followed
42 by "=" and nested definitions.
44 This can make the "name" quite long.
45 When a name is more than 80 characters, we split the .stabs pseudo-op
46 into two .stabs pseudo-ops, both sharing the same "code" and "value".
47 The first one is marked as continued with a double-backslash at the
50 The kind-of-symbol letter distinguished function names from global
51 variables from file-scope variables from parameters from auto
52 variables in memory from typedef names from register variables.
55 The "code" is mostly redundant with the kind-of-symbol letter
56 that goes in the "name", but not entirely: for symbols located
57 in static storage, the "code" says which segment the address is in,
58 which controls how it is relocated.
60 The "value" for a symbol in static storage
61 is the core address of the symbol (actually, the assembler
62 label for the symbol). For a symbol located in a stack slot
63 it is the stack offset; for one in a register, the register number.
64 For a typedef symbol, it is zero.
66 If DEBUG_SYMS_TEXT is defined, all debugging symbols must be
67 output while in the text section.
69 For more on data type definitions, see `dbxout_type'. */
73 #include "coretypes.h"
80 #include "insn-config.h"
90 #include "langhooks.h"
93 #ifdef XCOFF_DEBUGGING_INFO
97 #define DBXOUT_DECR_NESTING \
98 if (--debug_nesting == 0 && symbol_queue_index > 0) \
99 { emit_pending_bincls_if_required (); debug_flush_symbol_queue (); }
101 #define DBXOUT_DECR_NESTING_AND_RETURN(x) \
102 do {--debug_nesting; return (x);} while (0)
105 # ifdef XCOFF_DEBUGGING_INFO
106 # define ASM_STABS_OP "\t.stabx\t"
108 # define ASM_STABS_OP "\t.stabs\t"
113 #define ASM_STABN_OP "\t.stabn\t"
117 #define ASM_STABD_OP "\t.stabd\t"
120 #ifndef DBX_TYPE_DECL_STABS_CODE
121 #define DBX_TYPE_DECL_STABS_CODE N_LSYM
124 #ifndef DBX_STATIC_CONST_VAR_CODE
125 #define DBX_STATIC_CONST_VAR_CODE N_FUN
128 #ifndef DBX_REGPARM_STABS_CODE
129 #define DBX_REGPARM_STABS_CODE N_RSYM
132 #ifndef DBX_REGPARM_STABS_LETTER
133 #define DBX_REGPARM_STABS_LETTER 'P'
136 #ifndef NO_DBX_FUNCTION_END
137 #define NO_DBX_FUNCTION_END 0
140 #ifndef NO_DBX_BNSYM_ENSYM
141 #define NO_DBX_BNSYM_ENSYM 0
144 #ifndef NO_DBX_MAIN_SOURCE_DIRECTORY
145 #define NO_DBX_MAIN_SOURCE_DIRECTORY 0
148 #ifndef DBX_BLOCKS_FUNCTION_RELATIVE
149 #define DBX_BLOCKS_FUNCTION_RELATIVE 0
152 #ifndef DBX_LINES_FUNCTION_RELATIVE
153 #define DBX_LINES_FUNCTION_RELATIVE 0
156 #ifndef DBX_CONTIN_LENGTH
157 #define DBX_CONTIN_LENGTH 80
160 #ifndef DBX_CONTIN_CHAR
161 #define DBX_CONTIN_CHAR '\\'
164 enum typestatus
{TYPE_UNSEEN
, TYPE_XREF
, TYPE_DEFINED
};
166 /* Structure recording information about a C data type.
167 The status element says whether we have yet output
168 the definition of the type. TYPE_XREF says we have
169 output it as a cross-reference only.
170 The file_number and type_number elements are used if DBX_USE_BINCL
173 struct typeinfo
GTY(())
175 enum typestatus status
;
180 /* Vector recording information about C data types.
181 When we first notice a data type (a tree node),
182 we assign it a number using next_type_number.
183 That is its index in this vector. */
185 static GTY ((length ("typevec_len"))) struct typeinfo
*typevec
;
187 /* Number of elements of space allocated in `typevec'. */
189 static GTY(()) int typevec_len
;
191 /* In dbx output, each type gets a unique number.
192 This is the number for the next type output.
193 The number, once assigned, is in the TYPE_SYMTAB_ADDRESS field. */
195 static GTY(()) int next_type_number
;
197 /* The C front end may call dbxout_symbol before dbxout_init runs.
198 We save all such decls in this list and output them when we get
201 static GTY(()) tree preinit_symbols
;
203 enum binclstatus
{BINCL_NOT_REQUIRED
, BINCL_PENDING
, BINCL_PROCESSED
};
205 /* When using N_BINCL in dbx output, each type number is actually a
206 pair of the file number and the type number within the file.
207 This is a stack of input files. */
211 struct dbx_file
*next
;
213 int next_type_number
;
214 enum binclstatus bincl_status
; /* Keep track of lazy bincl. */
215 const char *pending_bincl_name
; /* Name of bincl. */
216 struct dbx_file
*prev
; /* Chain to traverse all pending bincls. */
219 /* This is the top of the stack.
221 This is not saved for PCH, because restoring a PCH should not change it.
222 next_file_number does have to be saved, because the PCH may use some
223 file numbers; however, just before restoring a PCH, next_file_number
224 should always be 0 because we should not have needed any file numbers
227 #if (defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)) \
228 && defined (DBX_USE_BINCL)
229 static struct dbx_file
*current_file
;
232 /* This is the next file number to use. */
234 static GTY(()) int next_file_number
;
236 /* A counter for dbxout_function_end. */
238 static GTY(()) int scope_labelno
;
240 /* A counter for dbxout_source_line. */
242 static GTY(()) int dbxout_source_line_counter
;
244 /* Nonzero if we have actually used any of the GDB extensions
245 to the debugging format. The idea is that we use them for the
246 first time only if there's a strong reason, but once we have done that,
247 we use them whenever convenient. */
249 static GTY(()) int have_used_extensions
= 0;
251 /* Number for the next N_SOL filename stabs label. The number 0 is reserved
252 for the N_SO filename stabs label. */
254 static GTY(()) int source_label_number
= 1;
256 /* Last source file name mentioned in a NOTE insn. */
258 static GTY(()) const char *lastfile
;
260 /* Used by PCH machinery to detect if 'lastfile' should be reset to
262 static GTY(()) int lastfile_is_base
;
264 /* Typical USG systems don't have stab.h, and they also have
265 no use for DBX-format debugging info. */
267 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
270 /* If zero then there is no pending BINCL. */
271 static int pending_bincls
= 0;
274 /* The original input file name. */
275 static const char *base_input_file
;
277 #ifdef DEBUG_SYMS_TEXT
278 #define FORCE_TEXT function_section (current_function_decl);
285 #define STAB_CODE_TYPE enum __stab_debug_code
287 /* 1 if PARM is passed to this function in memory. */
289 #define PARM_PASSED_IN_MEMORY(PARM) \
290 (MEM_P (DECL_INCOMING_RTL (PARM)))
292 /* A C expression for the integer offset value of an automatic variable
293 (N_LSYM) having address X (an RTX). */
294 #ifndef DEBUGGER_AUTO_OFFSET
295 #define DEBUGGER_AUTO_OFFSET(X) \
296 (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
299 /* A C expression for the integer offset value of an argument (N_PSYM)
300 having address X (an RTX). The nominal offset is OFFSET. */
301 #ifndef DEBUGGER_ARG_OFFSET
302 #define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET)
305 /* This obstack holds the stab string currently being constructed. We
306 build it up here, then write it out, so we can split long lines up
307 properly (see dbxout_finish_complex_stabs). */
308 static struct obstack stabstr_ob
;
309 static size_t stabstr_last_contin_point
;
312 static void emit_bincl_stab (const char *c
);
313 static void emit_pending_bincls (void);
315 static inline void emit_pending_bincls_if_required (void);
317 static void dbxout_init (const char *);
319 static void dbxout_finish (const char *);
320 static void dbxout_start_source_file (unsigned, const char *);
321 static void dbxout_end_source_file (unsigned);
322 static void dbxout_typedefs (tree
);
323 static void dbxout_type_index (tree
);
324 static void dbxout_args (tree
);
325 static void dbxout_type_fields (tree
);
326 static void dbxout_type_method_1 (tree
);
327 static void dbxout_type_methods (tree
);
328 static void dbxout_range_type (tree
);
329 static void dbxout_type (tree
, int);
330 static bool print_int_cst_bounds_in_octal_p (tree
);
331 static void dbxout_type_name (tree
);
332 static void dbxout_class_name_qualifiers (tree
);
333 static int dbxout_symbol_location (tree
, tree
, const char *, rtx
);
334 static void dbxout_symbol_name (tree
, const char *, int);
335 static void dbxout_block (tree
, int, tree
);
336 static void dbxout_global_decl (tree
);
337 static void dbxout_type_decl (tree
, int);
338 static void dbxout_handle_pch (unsigned);
340 /* The debug hooks structure. */
341 #if defined (DBX_DEBUGGING_INFO)
343 static void dbxout_source_line (unsigned int, const char *);
344 static void dbxout_begin_prologue (unsigned int, const char *);
345 static void dbxout_source_file (const char *);
346 static void dbxout_function_end (void);
347 static void dbxout_begin_function (tree
);
348 static void dbxout_begin_block (unsigned, unsigned);
349 static void dbxout_end_block (unsigned, unsigned);
350 static void dbxout_function_decl (tree
);
352 const struct gcc_debug_hooks dbx_debug_hooks
=
356 debug_nothing_int_charstar
,
357 debug_nothing_int_charstar
,
358 dbxout_start_source_file
,
359 dbxout_end_source_file
,
362 debug_true_tree
, /* ignore_block */
363 dbxout_source_line
, /* source_line */
364 dbxout_begin_prologue
, /* begin_prologue */
365 debug_nothing_int_charstar
, /* end_prologue */
366 debug_nothing_int_charstar
, /* end_epilogue */
367 #ifdef DBX_FUNCTION_FIRST
368 dbxout_begin_function
,
370 debug_nothing_tree
, /* begin_function */
372 debug_nothing_int
, /* end_function */
373 dbxout_function_decl
,
374 dbxout_global_decl
, /* global_decl */
375 dbxout_type_decl
, /* type_decl */
376 debug_nothing_tree_tree
, /* imported_module_or_decl */
377 debug_nothing_tree
, /* deferred_inline_function */
378 debug_nothing_tree
, /* outlining_inline_function */
379 debug_nothing_rtx
, /* label */
380 dbxout_handle_pch
, /* handle_pch */
381 debug_nothing_rtx
/* var_location */
383 #endif /* DBX_DEBUGGING_INFO */
385 #if defined (XCOFF_DEBUGGING_INFO)
386 const struct gcc_debug_hooks xcoff_debug_hooks
=
390 debug_nothing_int_charstar
,
391 debug_nothing_int_charstar
,
392 dbxout_start_source_file
,
393 dbxout_end_source_file
,
394 xcoffout_begin_block
,
396 debug_true_tree
, /* ignore_block */
397 xcoffout_source_line
,
398 xcoffout_begin_prologue
, /* begin_prologue */
399 debug_nothing_int_charstar
, /* end_prologue */
400 xcoffout_end_epilogue
,
401 debug_nothing_tree
, /* begin_function */
402 xcoffout_end_function
,
403 debug_nothing_tree
, /* function_decl */
404 dbxout_global_decl
, /* global_decl */
405 dbxout_type_decl
, /* type_decl */
406 debug_nothing_tree_tree
, /* imported_module_or_decl */
407 debug_nothing_tree
, /* deferred_inline_function */
408 debug_nothing_tree
, /* outlining_inline_function */
409 debug_nothing_rtx
, /* label */
410 dbxout_handle_pch
, /* handle_pch */
411 debug_nothing_rtx
/* var_location */
413 #endif /* XCOFF_DEBUGGING_INFO */
415 /* Numeric formatting helper macro. Note that this does not handle
417 #define NUMBER_FMT_LOOP(P, NUM, BASE) \
420 int digit = NUM % BASE; \
422 *--P = digit + '0'; \
426 /* Utility: write a decimal integer NUM to asm_out_file. */
431 char *p
= buf
+ sizeof buf
;
436 putc ('0', asm_out_file
);
441 putc ('-', asm_out_file
);
447 NUMBER_FMT_LOOP (p
, unum
, 10);
449 while (p
< buf
+ sizeof buf
)
451 putc (*p
, asm_out_file
);
457 /* Primitives for emitting simple stabs directives. All other stabs
458 routines should use these functions instead of directly emitting
459 stabs. They are exported because machine-dependent code may need
460 to invoke them, e.g. in a DBX_OUTPUT_* macro whose definition
461 forwards to code in CPU.c. */
463 /* The following functions should all be called immediately after one
464 of the dbxout_begin_stab* functions (below). They write out
465 various things as the value of a stab. */
467 /* Write out a literal zero as the value of a stab. */
469 dbxout_stab_value_zero (void)
471 fputs ("0\n", asm_out_file
);
474 /* Write out the label LABEL as the value of a stab. */
476 dbxout_stab_value_label (const char *label
)
478 assemble_name (asm_out_file
, label
);
479 putc ('\n', asm_out_file
);
482 /* Write out the difference of two labels, LABEL - BASE, as the value
485 dbxout_stab_value_label_diff (const char *label
, const char *base
)
487 assemble_name (asm_out_file
, label
);
488 putc ('-', asm_out_file
);
489 assemble_name (asm_out_file
, base
);
490 putc ('\n', asm_out_file
);
493 /* Write out an internal label as the value of a stab, and immediately
494 emit that internal label. This should be used only when
495 dbxout_stabd will not work. STEM is the name stem of the label,
496 COUNTERP is a pointer to a counter variable which will be used to
497 guarantee label uniqueness. */
499 dbxout_stab_value_internal_label (const char *stem
, int *counterp
)
502 int counter
= counterp
? (*counterp
)++ : 0;
504 ASM_GENERATE_INTERNAL_LABEL (label
, stem
, counter
);
505 dbxout_stab_value_label (label
);
506 targetm
.asm_out
.internal_label (asm_out_file
, stem
, counter
);
509 /* Write out the difference between BASE and an internal label as the
510 value of a stab, and immediately emit that internal label. STEM and
511 COUNTERP are as for dbxout_stab_value_internal_label. */
513 dbxout_stab_value_internal_label_diff (const char *stem
, int *counterp
,
517 int counter
= counterp
? (*counterp
)++ : 0;
519 ASM_GENERATE_INTERNAL_LABEL (label
, stem
, counter
);
520 dbxout_stab_value_label_diff (label
, base
);
521 targetm
.asm_out
.internal_label (asm_out_file
, stem
, counter
);
524 /* The following functions produce specific kinds of stab directives. */
526 /* Write a .stabd directive with type STYPE and desc SDESC to asm_out_file. */
528 dbxout_stabd (int stype
, int sdesc
)
530 fputs (ASM_STABD_OP
, asm_out_file
);
532 fputs (",0,", asm_out_file
);
534 putc ('\n', asm_out_file
);
537 /* Write a .stabn directive with type STYPE. This function stops
538 short of emitting the value field, which is the responsibility of
539 the caller (normally it will be either a symbol or the difference
543 dbxout_begin_stabn (int stype
)
545 fputs (ASM_STABN_OP
, asm_out_file
);
547 fputs (",0,0,", asm_out_file
);
550 /* Write a .stabn directive with type N_SLINE and desc LINE. As above,
551 the value field is the responsibility of the caller. */
553 dbxout_begin_stabn_sline (int lineno
)
555 fputs (ASM_STABN_OP
, asm_out_file
);
556 dbxout_int (N_SLINE
);
557 fputs (",0,", asm_out_file
);
559 putc (',', asm_out_file
);
562 /* Begin a .stabs directive with string "", type STYPE, and desc and
563 other fields 0. The value field is the responsibility of the
564 caller. This function cannot be used for .stabx directives. */
566 dbxout_begin_empty_stabs (int stype
)
568 fputs (ASM_STABS_OP
, asm_out_file
);
569 fputs ("\"\",", asm_out_file
);
571 fputs (",0,0,", asm_out_file
);
574 /* Begin a .stabs directive with string STR, type STYPE, and desc 0.
575 The value field is the responsibility of the caller. */
577 dbxout_begin_simple_stabs (const char *str
, int stype
)
579 fputs (ASM_STABS_OP
, asm_out_file
);
580 output_quoted_string (asm_out_file
, str
);
581 putc (',', asm_out_file
);
583 fputs (",0,0,", asm_out_file
);
586 /* As above but use SDESC for the desc field. */
588 dbxout_begin_simple_stabs_desc (const char *str
, int stype
, int sdesc
)
590 fputs (ASM_STABS_OP
, asm_out_file
);
591 output_quoted_string (asm_out_file
, str
);
592 putc (',', asm_out_file
);
594 fputs (",0,", asm_out_file
);
596 putc (',', asm_out_file
);
599 /* The next set of functions are entirely concerned with production of
600 "complex" .stabs directives: that is, .stabs directives whose
601 strings have to be constructed piecemeal. dbxout_type,
602 dbxout_symbol, etc. use these routines heavily. The string is queued
603 up in an obstack, then written out by dbxout_finish_complex_stabs, which
604 is also responsible for splitting it up if it exceeds DBX_CONTIN_LENGTH.
605 (You might think it would be more efficient to go straight to stdio
606 when DBX_CONTIN_LENGTH is 0 (i.e. no length limit) but that turns
607 out not to be the case, and anyway this needs fewer #ifdefs.) */
609 /* Begin a complex .stabs directive. If we can, write the initial
610 ASM_STABS_OP to the asm_out_file. */
613 dbxout_begin_complex_stabs (void)
615 emit_pending_bincls_if_required ();
617 fputs (ASM_STABS_OP
, asm_out_file
);
618 putc ('"', asm_out_file
);
619 gcc_assert (stabstr_last_contin_point
== 0);
622 /* As above, but do not force text or emit pending bincls. This is
623 used by dbxout_symbol_location, which needs to do something else. */
625 dbxout_begin_complex_stabs_noforcetext (void)
627 fputs (ASM_STABS_OP
, asm_out_file
);
628 putc ('"', asm_out_file
);
629 gcc_assert (stabstr_last_contin_point
== 0);
632 /* Add CHR, a single character, to the string being built. */
633 #define stabstr_C(chr) obstack_1grow (&stabstr_ob, chr)
635 /* Add STR, a normal C string, to the string being built. */
636 #define stabstr_S(str) obstack_grow (&stabstr_ob, str, strlen(str))
638 /* Add the text of ID, an IDENTIFIER_NODE, to the string being built. */
639 #define stabstr_I(id) obstack_grow (&stabstr_ob, \
640 IDENTIFIER_POINTER (id), \
641 IDENTIFIER_LENGTH (id))
643 /* Add NUM, a signed decimal number, to the string being built. */
645 stabstr_D (HOST_WIDE_INT num
)
648 char *p
= buf
+ sizeof buf
;
664 NUMBER_FMT_LOOP (p
, unum
, 10);
666 obstack_grow (&stabstr_ob
, p
, (buf
+ sizeof buf
) - p
);
669 /* Add NUM, an unsigned decimal number, to the string being built. */
671 stabstr_U (unsigned HOST_WIDE_INT num
)
674 char *p
= buf
+ sizeof buf
;
680 NUMBER_FMT_LOOP (p
, num
, 10);
681 obstack_grow (&stabstr_ob
, p
, (buf
+ sizeof buf
) - p
);
684 /* Add CST, an INTEGER_CST tree, to the string being built as an
685 unsigned octal number. This routine handles values which are
686 larger than a single HOST_WIDE_INT. */
690 unsigned HOST_WIDE_INT high
= TREE_INT_CST_HIGH (cst
);
691 unsigned HOST_WIDE_INT low
= TREE_INT_CST_LOW (cst
);
694 char *p
= buf
+ sizeof buf
;
696 /* GDB wants constants with no extra leading "1" bits, so
697 we need to remove any sign-extension that might be
700 const unsigned int width
= TYPE_PRECISION (TREE_TYPE (cst
));
701 if (width
== HOST_BITS_PER_WIDE_INT
* 2)
703 else if (width
> HOST_BITS_PER_WIDE_INT
)
704 high
&= (((HOST_WIDE_INT
) 1 << (width
- HOST_BITS_PER_WIDE_INT
)) - 1);
705 else if (width
== HOST_BITS_PER_WIDE_INT
)
708 high
= 0, low
&= (((HOST_WIDE_INT
) 1 << width
) - 1);
711 /* Leading zero for base indicator. */
714 /* If the value is zero, the base indicator will serve as the value
716 if (high
== 0 && low
== 0)
719 /* If the high half is zero, we need only print the low half normally. */
721 NUMBER_FMT_LOOP (p
, low
, 8);
724 /* When high != 0, we need to print enough zeroes from low to
725 give the digits from high their proper place-values. Hence
726 NUMBER_FMT_LOOP cannot be used. */
727 const int n_digits
= HOST_BITS_PER_WIDE_INT
/ 3;
730 for (i
= 1; i
<= n_digits
; i
++)
732 unsigned int digit
= low
% 8;
737 /* Octal digits carry exactly three bits of information. The
738 width of a HOST_WIDE_INT is not normally a multiple of three.
739 Therefore, the next digit printed probably needs to carry
740 information from both low and high. */
741 if (HOST_BITS_PER_WIDE_INT
% 3 != 0)
743 const int n_leftover_bits
= HOST_BITS_PER_WIDE_INT
% 3;
744 const int n_bits_from_high
= 3 - n_leftover_bits
;
746 const unsigned HOST_WIDE_INT
747 low_mask
= (((unsigned HOST_WIDE_INT
)1) << n_leftover_bits
) - 1;
748 const unsigned HOST_WIDE_INT
749 high_mask
= (((unsigned HOST_WIDE_INT
)1) << n_bits_from_high
) - 1;
753 /* At this point, only the bottom n_leftover_bits bits of low
755 gcc_assert (!(low
& ~low_mask
));
757 digit
= (low
| ((high
& high_mask
) << n_leftover_bits
));
758 high
>>= n_bits_from_high
;
763 /* Now we can format high in the normal manner. However, if
764 the only bits of high that were set were handled by the
765 digit split between low and high, high will now be zero, and
766 we don't want to print extra digits in that case. */
768 NUMBER_FMT_LOOP (p
, high
, 8);
771 obstack_grow (&stabstr_ob
, p
, (buf
+ sizeof buf
) - p
);
774 /* Called whenever it is safe to break a stabs string into multiple
775 .stabs directives. If the current string has exceeded the limit
776 set by DBX_CONTIN_LENGTH, mark the current position in the buffer
777 as a continuation point by inserting DBX_CONTIN_CHAR (doubled if
778 it is a backslash) and a null character. */
780 stabstr_continue (void)
782 if (DBX_CONTIN_LENGTH
> 0
783 && obstack_object_size (&stabstr_ob
) - stabstr_last_contin_point
786 if (DBX_CONTIN_CHAR
== '\\')
787 obstack_1grow (&stabstr_ob
, '\\');
788 obstack_1grow (&stabstr_ob
, DBX_CONTIN_CHAR
);
789 obstack_1grow (&stabstr_ob
, '\0');
790 stabstr_last_contin_point
= obstack_object_size (&stabstr_ob
);
793 #define CONTIN stabstr_continue ()
795 /* Macro subroutine of dbxout_finish_complex_stabs, which emits
796 all of the arguments to the .stabs directive after the string.
797 Overridden by xcoffout.h. CODE is the stabs code for this symbol;
798 LINE is the source line to write into the desc field (in extended
799 mode); SYM is the symbol itself.
801 ADDR, LABEL, and NUMBER are three different ways to represent the
802 stabs value field. At most one of these should be nonzero.
804 ADDR is used most of the time; it represents the value as an
805 RTL address constant.
807 LABEL is used (currently) only for N_CATCH stabs; it represents
808 the value as a string suitable for assemble_name.
810 NUMBER is used when the value is an offset from an implicit base
811 pointer (e.g. for a stack variable), or an index (e.g. for a
812 register variable). It represents the value as a decimal integer. */
814 #ifndef DBX_FINISH_STABS
815 #define DBX_FINISH_STABS(SYM, CODE, LINE, ADDR, LABEL, NUMBER) \
817 int line_ = use_gnu_debug_info_extensions ? LINE : 0; \
820 fputs (",0,", asm_out_file); \
821 dbxout_int (line_); \
822 putc (',', asm_out_file); \
824 output_addr_const (asm_out_file, ADDR); \
826 assemble_name (asm_out_file, LABEL); \
828 dbxout_int (NUMBER); \
829 putc ('\n', asm_out_file); \
833 /* Finish the emission of a complex .stabs directive. When DBX_CONTIN_LENGTH
834 is zero, this has only to emit the close quote and the remainder of
835 the arguments. When it is nonzero, the string has been marshalled in
836 stabstr_ob, and this routine is responsible for breaking it up into
837 DBX_CONTIN_LENGTH-sized chunks.
839 SYM is the DECL of the symbol under consideration; it is used only
840 for its DECL_SOURCE_LINE. The other arguments are all passed directly
841 to DBX_FINISH_STABS; see above for details. */
844 dbxout_finish_complex_stabs (tree sym
, STAB_CODE_TYPE code
,
845 rtx addr
, const char *label
, int number
)
847 int line ATTRIBUTE_UNUSED
;
851 line
= sym
? DECL_SOURCE_LINE (sym
) : 0;
852 if (DBX_CONTIN_LENGTH
> 0)
857 /* Nul-terminate the growing string, then get its size and
859 obstack_1grow (&stabstr_ob
, '\0');
861 len
= obstack_object_size (&stabstr_ob
);
862 chunk
= str
= obstack_finish (&stabstr_ob
);
864 /* Within the buffer are a sequence of NUL-separated strings,
865 each of which is to be written out as a separate stab
869 chunklen
= strlen (chunk
);
870 fwrite (chunk
, 1, chunklen
, asm_out_file
);
871 fputs ("\",", asm_out_file
);
873 /* Must add an extra byte to account for the NUL separator. */
874 chunk
+= chunklen
+ 1;
877 /* Only put a line number on the last stab in the sequence. */
878 DBX_FINISH_STABS (sym
, code
, len
== 0 ? line
: 0,
879 addr
, label
, number
);
883 fputs (ASM_STABS_OP
, asm_out_file
);
884 putc ('"', asm_out_file
);
886 stabstr_last_contin_point
= 0;
890 /* No continuations - we can put the whole string out at once.
891 It is faster to augment the string with the close quote and
892 comma than to do a two-character fputs. */
893 obstack_grow (&stabstr_ob
, "\",", 2);
894 len
= obstack_object_size (&stabstr_ob
);
895 str
= obstack_finish (&stabstr_ob
);
897 fwrite (str
, 1, len
, asm_out_file
);
898 DBX_FINISH_STABS (sym
, code
, line
, addr
, label
, number
);
900 obstack_free (&stabstr_ob
, str
);
903 #if defined (DBX_DEBUGGING_INFO)
906 dbxout_function_end (void)
908 char lscope_label_name
[100];
910 /* The Lscope label must be emitted even if we aren't doing anything
911 else; dbxout_block needs it. */
912 function_section (current_function_decl
);
914 /* Convert Lscope into the appropriate format for local labels in case
915 the system doesn't insert underscores in front of user generated
917 ASM_GENERATE_INTERNAL_LABEL (lscope_label_name
, "Lscope", scope_labelno
);
918 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
)
929 /* By convention, GCC will mark the end of a function with an N_FUN
930 symbol and an empty string. */
931 #ifdef DBX_OUTPUT_NFUN
932 DBX_OUTPUT_NFUN (asm_out_file
, lscope_label_name
, current_function_decl
);
934 dbxout_begin_empty_stabs (N_FUN
);
935 dbxout_stab_value_label_diff (lscope_label_name
,
936 XSTR (XEXP (DECL_RTL (current_function_decl
), 0), 0));
940 if (!NO_DBX_BNSYM_ENSYM
&& !flag_debug_only_used_symbols
)
941 dbxout_stabd (N_ENSYM
, 0);
943 #endif /* DBX_DEBUGGING_INFO */
945 /* Get lang description for N_SO stab. */
946 static unsigned int ATTRIBUTE_UNUSED
947 get_lang_number (void)
949 const char *language_string
= lang_hooks
.name
;
951 if (strcmp (language_string
, "GNU C") == 0)
953 else if (strcmp (language_string
, "GNU C++") == 0)
955 else if (strcmp (language_string
, "GNU F77") == 0)
957 else if (strcmp (language_string
, "GNU F95") == 0)
958 return N_SO_FORTRAN90
; /* CHECKME */
959 else if (strcmp (language_string
, "GNU Pascal") == 0)
961 else if (strcmp (language_string
, "GNU Objective-C") == 0)
968 /* At the beginning of compilation, start writing the symbol table.
969 Initialize `typevec' and output the standard data types of C. */
972 dbxout_init (const char *input_file_name
)
974 char ltext_label_name
[100];
975 bool used_ltext_label_name
= false;
976 tree syms
= lang_hooks
.decls
.getdecls ();
979 typevec
= ggc_calloc (typevec_len
, sizeof typevec
[0]);
981 /* stabstr_ob contains one string, which will be just fine with
983 obstack_specify_allocation (&stabstr_ob
, 0, 1, xmalloc
, free
);
985 /* Convert Ltext into the appropriate format for local labels in case
986 the system doesn't insert underscores in front of user generated
988 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name
, "Ltext", 0);
990 /* Put the current working directory in an N_SO symbol. */
991 if (use_gnu_debug_info_extensions
&& !NO_DBX_MAIN_SOURCE_DIRECTORY
)
993 static const char *cwd
;
997 cwd
= get_src_pwd ();
1000 else if (!IS_DIR_SEPARATOR (cwd
[strlen (cwd
) - 1]))
1001 cwd
= concat (cwd
, "/", NULL
);
1003 #ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
1004 DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asm_out_file
, cwd
);
1005 #else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
1006 dbxout_begin_simple_stabs_desc (cwd
, N_SO
, get_lang_number ());
1007 dbxout_stab_value_label (ltext_label_name
);
1008 used_ltext_label_name
= true;
1009 #endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
1012 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
1013 DBX_OUTPUT_MAIN_SOURCE_FILENAME (asm_out_file
, input_file_name
);
1015 dbxout_begin_simple_stabs_desc (input_file_name
, N_SO
, get_lang_number ());
1016 dbxout_stab_value_label (ltext_label_name
);
1017 used_ltext_label_name
= true;
1020 if (used_ltext_label_name
)
1023 targetm
.asm_out
.internal_label (asm_out_file
, "Ltext", 0);
1026 /* Emit an N_OPT stab to indicate that this file was compiled by GCC.
1027 The string used is historical. */
1028 #ifndef NO_DBX_GCC_MARKER
1029 dbxout_begin_simple_stabs ("gcc2_compiled.", N_OPT
);
1030 dbxout_stab_value_zero ();
1033 base_input_file
= lastfile
= input_file_name
;
1035 next_type_number
= 1;
1037 #ifdef DBX_USE_BINCL
1038 current_file
= xmalloc (sizeof *current_file
);
1039 current_file
->next
= NULL
;
1040 current_file
->file_number
= 0;
1041 current_file
->next_type_number
= 1;
1042 next_file_number
= 1;
1043 current_file
->prev
= NULL
;
1044 current_file
->bincl_status
= BINCL_NOT_REQUIRED
;
1045 current_file
->pending_bincl_name
= NULL
;
1048 /* Get all permanent types that have typedef names, and output them
1049 all, except for those already output. Some language front ends
1050 put these declarations in the top-level scope; some do not;
1051 the latter are responsible for calling debug_hooks->type_decl from
1052 their record_builtin_type function. */
1053 dbxout_typedefs (syms
);
1055 if (preinit_symbols
)
1058 for (t
= nreverse (preinit_symbols
); t
; t
= TREE_CHAIN (t
))
1059 dbxout_symbol (TREE_VALUE (t
), 0);
1060 preinit_symbols
= 0;
1064 /* Output any typedef names for types described by TYPE_DECLs in SYMS. */
1067 dbxout_typedefs (tree syms
)
1069 for (; syms
!= NULL_TREE
; syms
= TREE_CHAIN (syms
))
1071 if (TREE_CODE (syms
) == TYPE_DECL
)
1073 tree type
= TREE_TYPE (syms
);
1074 if (TYPE_NAME (type
)
1075 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1076 && COMPLETE_OR_VOID_TYPE_P (type
)
1077 && ! TREE_ASM_WRITTEN (TYPE_NAME (type
)))
1078 dbxout_symbol (TYPE_NAME (type
), 0);
1083 #ifdef DBX_USE_BINCL
1084 /* Emit BINCL stab using given name. */
1086 emit_bincl_stab (const char *name
)
1088 dbxout_begin_simple_stabs (name
, N_BINCL
);
1089 dbxout_stab_value_zero ();
1092 /* If there are pending bincls then it is time to emit all of them. */
1095 emit_pending_bincls_if_required (void)
1098 emit_pending_bincls ();
1101 /* Emit all pending bincls. */
1104 emit_pending_bincls (void)
1106 struct dbx_file
*f
= current_file
;
1108 /* Find first pending bincl. */
1109 while (f
->bincl_status
== BINCL_PENDING
)
1112 /* Now emit all bincls. */
1117 if (f
->bincl_status
== BINCL_PENDING
)
1119 emit_bincl_stab (f
->pending_bincl_name
);
1121 /* Update file number and status. */
1122 f
->file_number
= next_file_number
++;
1123 f
->bincl_status
= BINCL_PROCESSED
;
1125 if (f
== current_file
)
1130 /* All pending bincls have been emitted. */
1137 emit_pending_bincls_if_required (void) {}
1140 /* Change to reading from a new source file. Generate a N_BINCL stab. */
1143 dbxout_start_source_file (unsigned int line ATTRIBUTE_UNUSED
,
1144 const char *filename ATTRIBUTE_UNUSED
)
1146 #ifdef DBX_USE_BINCL
1147 struct dbx_file
*n
= xmalloc (sizeof *n
);
1149 n
->next
= current_file
;
1150 n
->next_type_number
= 1;
1151 /* Do not assign file number now.
1152 Delay it until we actually emit BINCL. */
1155 current_file
->prev
= n
;
1156 n
->bincl_status
= BINCL_PENDING
;
1157 n
->pending_bincl_name
= filename
;
1163 /* Revert to reading a previous source file. Generate a N_EINCL stab. */
1166 dbxout_end_source_file (unsigned int line ATTRIBUTE_UNUSED
)
1168 #ifdef DBX_USE_BINCL
1169 /* Emit EINCL stab only if BINCL is not pending. */
1170 if (current_file
->bincl_status
== BINCL_PROCESSED
)
1172 dbxout_begin_stabn (N_EINCL
);
1173 dbxout_stab_value_zero ();
1175 current_file
->bincl_status
= BINCL_NOT_REQUIRED
;
1176 current_file
= current_file
->next
;
1180 /* Handle a few odd cases that occur when trying to make PCH files work. */
1183 dbxout_handle_pch (unsigned at_end
)
1187 /* When using the PCH, this file will be included, so we need to output
1189 dbxout_start_source_file (0, lastfile
);
1191 /* The base file when using the PCH won't be the same as
1192 the base file when it's being generated. */
1197 /* ... and an EINCL. */
1198 dbxout_end_source_file (0);
1200 /* Deal with cases where 'lastfile' was never actually changed. */
1201 lastfile_is_base
= lastfile
== NULL
;
1205 #if defined (DBX_DEBUGGING_INFO)
1206 /* Output debugging info to FILE to switch to sourcefile FILENAME. */
1209 dbxout_source_file (const char *filename
)
1211 if (lastfile
== 0 && lastfile_is_base
)
1213 lastfile
= base_input_file
;
1214 lastfile_is_base
= 0;
1217 if (filename
&& (lastfile
== 0 || strcmp (filename
, lastfile
)))
1219 /* Don't change section amid function. */
1220 if (current_function_decl
== NULL_TREE
)
1223 dbxout_begin_simple_stabs (filename
, N_SOL
);
1224 dbxout_stab_value_internal_label ("Ltext", &source_label_number
);
1225 lastfile
= filename
;
1229 /* Output N_BNSYM and line number symbol entry. */
1232 dbxout_begin_prologue (unsigned int lineno
, const char *filename
)
1234 if (use_gnu_debug_info_extensions
1235 && !NO_DBX_FUNCTION_END
1236 && !NO_DBX_BNSYM_ENSYM
1237 && !flag_debug_only_used_symbols
)
1238 dbxout_stabd (N_BNSYM
, 0);
1240 dbxout_source_line (lineno
, filename
);
1243 /* Output a line number symbol entry for source file FILENAME and line
1247 dbxout_source_line (unsigned int lineno
, const char *filename
)
1249 dbxout_source_file (filename
);
1251 #ifdef DBX_OUTPUT_SOURCE_LINE
1252 DBX_OUTPUT_SOURCE_LINE (asm_out_file
, lineno
, dbxout_source_line_counter
);
1254 if (DBX_LINES_FUNCTION_RELATIVE
)
1256 rtx begin_label
= XEXP (DECL_RTL (current_function_decl
), 0);
1257 dbxout_begin_stabn_sline (lineno
);
1258 dbxout_stab_value_internal_label_diff ("LM", &dbxout_source_line_counter
,
1259 XSTR (begin_label
, 0));
1263 dbxout_stabd (N_SLINE
, lineno
);
1267 /* Describe the beginning of an internal block within a function. */
1270 dbxout_begin_block (unsigned int line ATTRIBUTE_UNUSED
, unsigned int n
)
1272 emit_pending_bincls_if_required ();
1273 targetm
.asm_out
.internal_label (asm_out_file
, "LBB", n
);
1276 /* Describe the end line-number of an internal block within a function. */
1279 dbxout_end_block (unsigned int line ATTRIBUTE_UNUSED
, unsigned int n
)
1281 emit_pending_bincls_if_required ();
1282 targetm
.asm_out
.internal_label (asm_out_file
, "LBE", n
);
1285 /* Output dbx data for a function definition.
1286 This includes a definition of the function name itself (a symbol),
1287 definitions of the parameters (locating them in the parameter list)
1288 and then output the block that makes up the function's body
1289 (including all the auto variables of the function). */
1292 dbxout_function_decl (tree decl
)
1294 emit_pending_bincls_if_required ();
1295 #ifndef DBX_FUNCTION_FIRST
1296 dbxout_begin_function (decl
);
1298 dbxout_block (DECL_INITIAL (decl
), 0, DECL_ARGUMENTS (decl
));
1299 dbxout_function_end ();
1302 #endif /* DBX_DEBUGGING_INFO */
1304 /* Debug information for a global DECL. Called from toplev.c after
1305 compilation proper has finished. */
1307 dbxout_global_decl (tree decl
)
1309 if (TREE_CODE (decl
) == VAR_DECL
1310 && ! DECL_EXTERNAL (decl
)
1311 && DECL_RTL_SET_P (decl
)) /* Not necessary? */
1313 int saved_tree_used
= TREE_USED (decl
);
1314 TREE_USED (decl
) = 1;
1315 dbxout_symbol (decl
, 0);
1316 TREE_USED (decl
) = saved_tree_used
;
1320 /* This is just a function-type adapter; dbxout_symbol does exactly
1321 what we want but returns an int. */
1323 dbxout_type_decl (tree decl
, int local
)
1325 dbxout_symbol (decl
, local
);
1328 /* At the end of compilation, finish writing the symbol table.
1329 The default is to call debug_free_queue but do nothing else. */
1332 dbxout_finish (const char *filename ATTRIBUTE_UNUSED
)
1334 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
1335 DBX_OUTPUT_MAIN_SOURCE_FILE_END (asm_out_file
, filename
);
1336 #elif defined DBX_OUTPUT_NULL_N_SO_AT_MAIN_SOURCE_FILE_END
1339 dbxout_begin_empty_stabs (N_SO
);
1340 dbxout_stab_value_internal_label ("Letext", 0);
1343 debug_free_queue ();
1346 /* Output the index of a type. */
1349 dbxout_type_index (tree type
)
1351 #ifndef DBX_USE_BINCL
1352 stabstr_D (TYPE_SYMTAB_ADDRESS (type
));
1354 struct typeinfo
*t
= &typevec
[TYPE_SYMTAB_ADDRESS (type
)];
1356 stabstr_D (t
->file_number
);
1358 stabstr_D (t
->type_number
);
1365 /* Used in several places: evaluates to '0' for a private decl,
1366 '1' for a protected decl, '2' for a public decl. */
1367 #define DECL_ACCESSIBILITY_CHAR(DECL) \
1368 (TREE_PRIVATE (DECL) ? '0' : TREE_PROTECTED (DECL) ? '1' : '2')
1370 /* Subroutine of `dbxout_type'. Output the type fields of TYPE.
1371 This must be a separate function because anonymous unions require
1375 dbxout_type_fields (tree type
)
1379 /* Output the name, type, position (in bits), size (in bits) of each
1380 field that we can support. */
1381 for (tem
= TYPE_FIELDS (type
); tem
; tem
= TREE_CHAIN (tem
))
1383 /* If one of the nodes is an error_mark or its type is then
1385 if (tem
== error_mark_node
|| TREE_TYPE (tem
) == error_mark_node
)
1388 /* Omit here local type decls until we know how to support them. */
1389 if (TREE_CODE (tem
) == TYPE_DECL
1390 /* Omit fields whose position or size are variable or too large to
1392 || (TREE_CODE (tem
) == FIELD_DECL
1393 && (! host_integerp (bit_position (tem
), 0)
1394 || ! DECL_SIZE (tem
)
1395 || ! host_integerp (DECL_SIZE (tem
), 1)))
1396 /* Omit here the nameless fields that are used to skip bits. */
1397 || DECL_IGNORED_P (tem
))
1400 else if (TREE_CODE (tem
) != CONST_DECL
)
1402 /* Continue the line if necessary,
1403 but not before the first field. */
1404 if (tem
!= TYPE_FIELDS (type
))
1407 if (DECL_NAME (tem
))
1408 stabstr_I (DECL_NAME (tem
));
1411 if (use_gnu_debug_info_extensions
1412 && (TREE_PRIVATE (tem
) || TREE_PROTECTED (tem
)
1413 || TREE_CODE (tem
) != FIELD_DECL
))
1415 have_used_extensions
= 1;
1417 stabstr_C (DECL_ACCESSIBILITY_CHAR (tem
));
1420 dbxout_type ((TREE_CODE (tem
) == FIELD_DECL
1421 && DECL_BIT_FIELD_TYPE (tem
))
1422 ? DECL_BIT_FIELD_TYPE (tem
) : TREE_TYPE (tem
), 0);
1424 if (TREE_CODE (tem
) == VAR_DECL
)
1426 if (TREE_STATIC (tem
) && use_gnu_debug_info_extensions
)
1428 tree name
= DECL_ASSEMBLER_NAME (tem
);
1430 have_used_extensions
= 1;
1436 /* If TEM is non-static, GDB won't understand it. */
1437 stabstr_S (",0,0;");
1442 stabstr_D (int_bit_position (tem
));
1444 stabstr_D (tree_low_cst (DECL_SIZE (tem
), 1));
1451 /* Subroutine of `dbxout_type_methods'. Output debug info about the
1452 method described DECL. */
1455 dbxout_type_method_1 (tree decl
)
1459 if (TREE_CODE (TREE_TYPE (decl
)) == FUNCTION_TYPE
)
1461 else /* it's a METHOD_TYPE. */
1463 tree firstarg
= TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)));
1464 /* A for normal functions.
1465 B for `const' member functions.
1466 C for `volatile' member functions.
1467 D for `const volatile' member functions. */
1468 if (TYPE_READONLY (TREE_TYPE (firstarg
)))
1470 if (TYPE_VOLATILE (TREE_TYPE (firstarg
)))
1473 if (DECL_VINDEX (decl
))
1479 /* ??? Output the mangled name, which contains an encoding of the
1480 method's type signature. May not be necessary anymore. */
1482 stabstr_I (DECL_ASSEMBLER_NAME (decl
));
1484 stabstr_C (DECL_ACCESSIBILITY_CHAR (decl
));
1488 if (DECL_VINDEX (decl
) && host_integerp (DECL_VINDEX (decl
), 0))
1490 stabstr_D (tree_low_cst (DECL_VINDEX (decl
), 0));
1492 dbxout_type (DECL_CONTEXT (decl
), 0);
1497 /* Subroutine of `dbxout_type'. Output debug info about the methods defined
1501 dbxout_type_methods (tree type
)
1503 /* C++: put out the method names and their parameter lists */
1504 tree methods
= TYPE_METHODS (type
);
1508 if (methods
== NULL_TREE
)
1511 if (TREE_CODE (methods
) != TREE_VEC
)
1513 else if (TREE_VEC_ELT (methods
, 0) != NULL_TREE
)
1514 fndecl
= TREE_VEC_ELT (methods
, 0);
1516 fndecl
= TREE_VEC_ELT (methods
, 1);
1520 int need_prefix
= 1;
1522 /* Group together all the methods for the same operation.
1523 These differ in the types of the arguments. */
1524 for (last
= NULL_TREE
;
1525 fndecl
&& (last
== NULL_TREE
|| DECL_NAME (fndecl
) == DECL_NAME (last
));
1526 fndecl
= TREE_CHAIN (fndecl
))
1527 /* Output the name of the field (after overloading), as
1528 well as the name of the field before overloading, along
1529 with its parameter list */
1531 /* Skip methods that aren't FUNCTION_DECLs. (In C++, these
1532 include TEMPLATE_DECLs.) The debugger doesn't know what
1533 to do with such entities anyhow. */
1534 if (TREE_CODE (fndecl
) != FUNCTION_DECL
)
1541 /* Also ignore abstract methods; those are only interesting to
1542 the DWARF backends. */
1543 if (DECL_IGNORED_P (fndecl
) || DECL_ABSTRACT (fndecl
))
1546 /* Redundantly output the plain name, since that's what gdb
1550 stabstr_I (DECL_NAME (fndecl
));
1555 dbxout_type (TREE_TYPE (fndecl
), 0);
1556 dbxout_type_method_1 (fndecl
);
1563 /* Emit a "range" type specification, which has the form:
1564 "r<index type>;<lower bound>;<upper bound>;".
1565 TYPE is an INTEGER_TYPE. */
1568 dbxout_range_type (tree type
)
1571 if (TREE_TYPE (type
))
1572 dbxout_type (TREE_TYPE (type
), 0);
1573 else if (TREE_CODE (type
) != INTEGER_TYPE
)
1574 dbxout_type (type
, 0); /* E.g. Pascal's ARRAY [BOOLEAN] of INTEGER */
1577 /* Traditionally, we made sure 'int' was type 1, and builtin types
1578 were defined to be sub-ranges of int. Unfortunately, this
1579 does not allow us to distinguish true sub-ranges from integer
1580 types. So, instead we define integer (non-sub-range) types as
1581 sub-ranges of themselves. This matters for Chill. If this isn't
1582 a subrange type, then we want to define it in terms of itself.
1583 However, in C, this may be an anonymous integer type, and we don't
1584 want to emit debug info referring to it. Just calling
1585 dbxout_type_index won't work anyways, because the type hasn't been
1586 defined yet. We make this work for both cases by checked to see
1587 whether this is a defined type, referring to it if it is, and using
1589 if (TYPE_SYMTAB_ADDRESS (type
) != 0)
1590 dbxout_type_index (type
);
1592 dbxout_type_index (integer_type_node
);
1596 if (TYPE_MIN_VALUE (type
) != 0
1597 && host_integerp (TYPE_MIN_VALUE (type
), 0))
1599 if (print_int_cst_bounds_in_octal_p (type
))
1600 stabstr_O (TYPE_MIN_VALUE (type
));
1602 stabstr_D (tree_low_cst (TYPE_MIN_VALUE (type
), 0));
1608 if (TYPE_MAX_VALUE (type
) != 0
1609 && host_integerp (TYPE_MAX_VALUE (type
), 0))
1611 if (print_int_cst_bounds_in_octal_p (type
))
1612 stabstr_O (TYPE_MAX_VALUE (type
));
1614 stabstr_D (tree_low_cst (TYPE_MAX_VALUE (type
), 0));
1622 /* Output a reference to a type. If the type has not yet been
1623 described in the dbx output, output its definition now.
1624 For a type already defined, just refer to its definition
1625 using the type number.
1627 If FULL is nonzero, and the type has been described only with
1628 a forward-reference, output the definition now.
1629 If FULL is zero in this case, just refer to the forward-reference
1630 using the number previously allocated. */
1633 dbxout_type (tree type
, int full
)
1637 static int anonymous_type_number
= 0;
1639 if (TREE_CODE (type
) == VECTOR_TYPE
)
1640 /* The frontend feeds us a representation for the vector as a struct
1641 containing an array. Pull out the array type. */
1642 type
= TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type
)));
1644 /* If there was an input error and we don't really have a type,
1645 avoid crashing and write something that is at least valid
1646 by assuming `int'. */
1647 if (type
== error_mark_node
)
1648 type
= integer_type_node
;
1651 if (TYPE_NAME (type
)
1652 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1653 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type
)))
1657 /* Try to find the "main variant" with the same name. */
1658 if (TYPE_NAME (type
) && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1659 && DECL_ORIGINAL_TYPE (TYPE_NAME (type
)))
1660 main_variant
= TREE_TYPE (TYPE_NAME (type
));
1662 main_variant
= TYPE_MAIN_VARIANT (type
);
1664 /* If we are not using extensions, stabs does not distinguish const and
1665 volatile, so there is no need to make them separate types. */
1666 if (!use_gnu_debug_info_extensions
)
1667 type
= main_variant
;
1669 if (TYPE_SYMTAB_ADDRESS (type
) == 0)
1671 /* Type has no dbx number assigned. Assign next available number. */
1672 TYPE_SYMTAB_ADDRESS (type
) = next_type_number
++;
1674 /* Make sure type vector is long enough to record about this type. */
1676 if (next_type_number
== typevec_len
)
1679 = ggc_realloc (typevec
, (typevec_len
* 2 * sizeof typevec
[0]));
1680 memset (typevec
+ typevec_len
, 0, typevec_len
* sizeof typevec
[0]);
1684 #ifdef DBX_USE_BINCL
1685 emit_pending_bincls_if_required ();
1686 typevec
[TYPE_SYMTAB_ADDRESS (type
)].file_number
1687 = current_file
->file_number
;
1688 typevec
[TYPE_SYMTAB_ADDRESS (type
)].type_number
1689 = current_file
->next_type_number
++;
1693 if (flag_debug_only_used_symbols
)
1695 if ((TREE_CODE (type
) == RECORD_TYPE
1696 || TREE_CODE (type
) == UNION_TYPE
1697 || TREE_CODE (type
) == QUAL_UNION_TYPE
1698 || TREE_CODE (type
) == ENUMERAL_TYPE
)
1699 && TYPE_STUB_DECL (type
)
1700 && DECL_P (TYPE_STUB_DECL (type
))
1701 && ! DECL_IGNORED_P (TYPE_STUB_DECL (type
)))
1702 debug_queue_symbol (TYPE_STUB_DECL (type
));
1703 else if (TYPE_NAME (type
)
1704 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
1705 debug_queue_symbol (TYPE_NAME (type
));
1708 /* Output the number of this type, to refer to it. */
1709 dbxout_type_index (type
);
1711 #ifdef DBX_TYPE_DEFINED
1712 if (DBX_TYPE_DEFINED (type
))
1716 /* If this type's definition has been output or is now being output,
1719 switch (typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
)
1724 /* If we have already had a cross reference,
1725 and either that's all we want or that's the best we could do,
1726 don't repeat the cross reference.
1727 Sun dbx crashes if we do. */
1728 if (! full
|| !COMPLETE_TYPE_P (type
)
1729 /* No way in DBX fmt to describe a variable size. */
1730 || ! host_integerp (TYPE_SIZE (type
), 1))
1738 /* For systems where dbx output does not allow the `=xsNAME:' syntax,
1739 leave the type-number completely undefined rather than output
1740 a cross-reference. If we have already used GNU debug info extensions,
1741 then it is OK to output a cross reference. This is necessary to get
1742 proper C++ debug output. */
1743 if ((TREE_CODE (type
) == RECORD_TYPE
|| TREE_CODE (type
) == UNION_TYPE
1744 || TREE_CODE (type
) == QUAL_UNION_TYPE
1745 || TREE_CODE (type
) == ENUMERAL_TYPE
)
1746 && ! use_gnu_debug_info_extensions
)
1747 /* We must use the same test here as we use twice below when deciding
1748 whether to emit a cross-reference. */
1749 if ((TYPE_NAME (type
) != 0
1750 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1751 && DECL_IGNORED_P (TYPE_NAME (type
)))
1753 || !COMPLETE_TYPE_P (type
)
1754 /* No way in DBX fmt to describe a variable size. */
1755 || ! host_integerp (TYPE_SIZE (type
), 1))
1757 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1762 /* Output a definition now. */
1765 /* Mark it as defined, so that if it is self-referent
1766 we will not get into an infinite recursion of definitions. */
1768 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_DEFINED
;
1770 /* If this type is a variant of some other, hand off. Types with
1771 different names are usefully distinguished. We only distinguish
1772 cv-qualified types if we're using extensions. */
1773 if (TYPE_READONLY (type
) > TYPE_READONLY (main_variant
))
1776 dbxout_type (build_type_variant (type
, 0, TYPE_VOLATILE (type
)), 0);
1779 else if (TYPE_VOLATILE (type
) > TYPE_VOLATILE (main_variant
))
1782 dbxout_type (build_type_variant (type
, TYPE_READONLY (type
), 0), 0);
1785 else if (main_variant
!= TYPE_MAIN_VARIANT (type
))
1787 if (flag_debug_only_used_symbols
)
1789 tree orig_type
= DECL_ORIGINAL_TYPE (TYPE_NAME (type
));
1791 if ((TREE_CODE (orig_type
) == RECORD_TYPE
1792 || TREE_CODE (orig_type
) == UNION_TYPE
1793 || TREE_CODE (orig_type
) == QUAL_UNION_TYPE
1794 || TREE_CODE (orig_type
) == ENUMERAL_TYPE
)
1795 && TYPE_STUB_DECL (orig_type
)
1796 && ! DECL_IGNORED_P (TYPE_STUB_DECL (orig_type
)))
1797 debug_queue_symbol (TYPE_STUB_DECL (orig_type
));
1799 /* 'type' is a typedef; output the type it refers to. */
1800 dbxout_type (DECL_ORIGINAL_TYPE (TYPE_NAME (type
)), 0);
1803 /* else continue. */
1805 switch (TREE_CODE (type
))
1809 /* For a void type, just define it as itself; i.e., "5=5".
1810 This makes us consider it defined
1811 without saying what it is. The debugger will make it
1812 a void type when the reference is seen, and nothing will
1813 ever override that default. */
1814 dbxout_type_index (type
);
1818 if (type
== char_type_node
&& ! TYPE_UNSIGNED (type
))
1820 /* Output the type `char' as a subrange of itself!
1821 I don't understand this definition, just copied it
1822 from the output of pcc.
1823 This used to use `r2' explicitly and we used to
1824 take care to make sure that `char' was type number 2. */
1826 dbxout_type_index (type
);
1827 stabstr_S (";0;127;");
1830 /* If this is a subtype of another integer type, always prefer to
1831 write it as a subtype. */
1832 else if (TREE_TYPE (type
) != 0
1833 && TREE_CODE (TREE_TYPE (type
)) == INTEGER_TYPE
)
1835 /* If the size is non-standard, say what it is if we can use
1838 if (use_gnu_debug_info_extensions
1839 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
1841 have_used_extensions
= 1;
1843 stabstr_D (TYPE_PRECISION (type
));
1847 dbxout_range_type (type
);
1852 /* If the size is non-standard, say what it is if we can use
1855 if (use_gnu_debug_info_extensions
1856 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
1858 have_used_extensions
= 1;
1860 stabstr_D (TYPE_PRECISION (type
));
1864 if (print_int_cst_bounds_in_octal_p (type
))
1868 /* If this type derives from another type, output type index of
1869 parent type. This is particularly important when parent type
1870 is an enumerated type, because not generating the parent type
1871 index would transform the definition of this enumerated type
1872 into a plain unsigned type. */
1873 if (TREE_TYPE (type
) != 0)
1874 dbxout_type_index (TREE_TYPE (type
));
1876 dbxout_type_index (type
);
1879 stabstr_O (TYPE_MIN_VALUE (type
));
1881 stabstr_O (TYPE_MAX_VALUE (type
));
1886 /* Output other integer types as subranges of `int'. */
1887 dbxout_range_type (type
);
1893 /* This used to say `r1' and we used to take care
1894 to make sure that `int' was type number 1. */
1896 dbxout_type_index (integer_type_node
);
1898 stabstr_D (int_size_in_bytes (type
));
1903 if (use_gnu_debug_info_extensions
)
1905 have_used_extensions
= 1;
1907 stabstr_D (BITS_PER_UNIT
* int_size_in_bytes (type
));
1908 stabstr_S (";-20;");
1912 /* Output the type `char' as a subrange of itself.
1913 That is what pcc seems to do. */
1915 dbxout_type_index (char_type_node
);
1916 stabstr_S (TYPE_UNSIGNED (type
) ? ";0;255;" : ";0;127;");
1921 if (use_gnu_debug_info_extensions
)
1923 have_used_extensions
= 1;
1925 stabstr_D (BITS_PER_UNIT
* int_size_in_bytes (type
));
1926 stabstr_S (";-16;");
1928 else /* Define as enumeral type (False, True) */
1929 stabstr_S ("eFalse:0,True:1,;");
1934 dbxout_type (TREE_TYPE (type
), 0);
1938 /* Differs from the REAL_TYPE by its new data type number.
1939 R3 is NF_COMPLEX. We don't try to use any of the other NF_*
1940 codes since gdb doesn't care anyway. */
1942 if (TREE_CODE (TREE_TYPE (type
)) == REAL_TYPE
)
1945 stabstr_D (2 * int_size_in_bytes (TREE_TYPE (type
)));
1950 /* Output a complex integer type as a structure,
1951 pending some other way to do it. */
1953 stabstr_D (int_size_in_bytes (type
));
1955 stabstr_S ("real:");
1956 dbxout_type (TREE_TYPE (type
), 0);
1958 stabstr_D (TYPE_PRECISION (TREE_TYPE (type
)));
1960 stabstr_S (";imag:");
1961 dbxout_type (TREE_TYPE (type
), 0);
1963 stabstr_D (TYPE_PRECISION (TREE_TYPE (type
)));
1965 stabstr_D (TYPE_PRECISION (TREE_TYPE (type
)));
1971 /* Make arrays of packed bits look like bitstrings for chill. */
1972 if (TYPE_PACKED (type
) && use_gnu_debug_info_extensions
)
1974 have_used_extensions
= 1;
1976 stabstr_D (BITS_PER_UNIT
* int_size_in_bytes (type
));
1977 stabstr_S (";@S;S");
1978 dbxout_type (TYPE_DOMAIN (type
), 0);
1982 /* Output "a" followed by a range type definition
1983 for the index type of the array
1984 followed by a reference to the target-type.
1985 ar1;0;N;M for a C array of type M and size N+1. */
1986 /* Check if a character string type, which in Chill is
1987 different from an array of characters. */
1988 if (TYPE_STRING_FLAG (type
) && use_gnu_debug_info_extensions
)
1990 have_used_extensions
= 1;
1993 tem
= TYPE_DOMAIN (type
);
1997 dbxout_type_index (integer_type_node
);
1998 stabstr_S (";0;-1;");
2003 dbxout_range_type (tem
);
2006 dbxout_type (TREE_TYPE (type
), 0);
2011 case QUAL_UNION_TYPE
:
2013 tree binfo
= TYPE_BINFO (type
);
2015 /* Output a structure type. We must use the same test here as we
2016 use in the DBX_NO_XREFS case above. */
2017 if ((TYPE_NAME (type
) != 0
2018 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
2019 && DECL_IGNORED_P (TYPE_NAME (type
)))
2021 || !COMPLETE_TYPE_P (type
)
2022 /* No way in DBX fmt to describe a variable size. */
2023 || ! host_integerp (TYPE_SIZE (type
), 1))
2025 /* If the type is just a cross reference, output one
2026 and mark the type as partially described.
2027 If it later becomes defined, we will output
2028 its real definition.
2029 If the type has a name, don't nest its definition within
2030 another type's definition; instead, output an xref
2031 and let the definition come when the name is defined. */
2032 stabstr_S ((TREE_CODE (type
) == RECORD_TYPE
) ? "xs" : "xu");
2033 if (TYPE_NAME (type
) != 0)
2034 dbxout_type_name (type
);
2038 stabstr_D (anonymous_type_number
++);
2042 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
2046 /* Identify record or union, and print its size. */
2047 stabstr_C ((TREE_CODE (type
) == RECORD_TYPE
) ? 's' : 'u');
2048 stabstr_D (int_size_in_bytes (type
));
2054 VEC (tree
) *accesses
= BINFO_BASE_ACCESSES (binfo
);
2056 if (use_gnu_debug_info_extensions
)
2058 if (BINFO_N_BASE_BINFOS (binfo
))
2060 have_used_extensions
= 1;
2062 stabstr_U (BINFO_N_BASE_BINFOS (binfo
));
2066 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, child
); i
++)
2068 tree access
= (accesses
? VEC_index (tree
, accesses
, i
)
2069 : access_public_node
);
2071 if (use_gnu_debug_info_extensions
)
2073 have_used_extensions
= 1;
2074 stabstr_C (BINFO_VIRTUAL_P (child
) ? '1' : '0');
2075 stabstr_C (access
== access_public_node
? '2' :
2076 access
== access_protected_node
2078 if (BINFO_VIRTUAL_P (child
)
2079 && strcmp (lang_hooks
.name
, "GNU C++") == 0)
2080 /* For a virtual base, print the (negative)
2081 offset within the vtable where we must look
2082 to find the necessary adjustment. */
2084 (tree_low_cst (BINFO_VPTR_FIELD (child
), 0)
2087 stabstr_D (tree_low_cst (BINFO_OFFSET (child
), 0)
2090 dbxout_type (BINFO_TYPE (child
), 0);
2095 /* Print out the base class information with
2096 fields which have the same names at the types
2098 dbxout_type_name (BINFO_TYPE (child
));
2100 dbxout_type (BINFO_TYPE (child
), full
);
2102 stabstr_D (tree_low_cst (BINFO_OFFSET (child
), 0)
2106 (tree_low_cst (TYPE_SIZE (BINFO_TYPE (child
)), 0)
2114 /* Write out the field declarations. */
2115 dbxout_type_fields (type
);
2116 if (use_gnu_debug_info_extensions
&& TYPE_METHODS (type
) != NULL_TREE
)
2118 have_used_extensions
= 1;
2119 dbxout_type_methods (type
);
2124 if (use_gnu_debug_info_extensions
&& TREE_CODE (type
) == RECORD_TYPE
2125 /* Avoid the ~ if we don't really need it--it confuses dbx. */
2126 && TYPE_VFIELD (type
))
2128 have_used_extensions
= 1;
2130 /* We need to write out info about what field this class
2131 uses as its "main" vtable pointer field, because if this
2132 field is inherited from a base class, GDB cannot necessarily
2133 figure out which field it's using in time. */
2135 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type
)), 0);
2141 /* We must use the same test here as we use in the DBX_NO_XREFS case
2142 above. We simplify it a bit since an enum will never have a variable
2144 if ((TYPE_NAME (type
) != 0
2145 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
2146 && DECL_IGNORED_P (TYPE_NAME (type
)))
2148 || !COMPLETE_TYPE_P (type
))
2151 dbxout_type_name (type
);
2152 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
2156 if (use_gnu_debug_info_extensions
2157 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
2159 have_used_extensions
= 1;
2161 stabstr_D (TYPE_PRECISION (type
));
2166 for (tem
= TYPE_VALUES (type
); tem
; tem
= TREE_CHAIN (tem
))
2168 stabstr_I (TREE_PURPOSE (tem
));
2171 if (TREE_INT_CST_HIGH (TREE_VALUE (tem
)) == 0)
2172 stabstr_D (TREE_INT_CST_LOW (TREE_VALUE (tem
)));
2173 else if (TREE_INT_CST_HIGH (TREE_VALUE (tem
)) == -1
2174 && (HOST_WIDE_INT
) TREE_INT_CST_LOW (TREE_VALUE (tem
)) < 0)
2175 stabstr_D (TREE_INT_CST_LOW (TREE_VALUE (tem
)));
2177 stabstr_O (TREE_VALUE (tem
));
2180 if (TREE_CHAIN (tem
) != 0)
2189 dbxout_type (TREE_TYPE (type
), 0);
2193 if (use_gnu_debug_info_extensions
)
2195 have_used_extensions
= 1;
2198 /* Write the argument types out longhand. */
2199 dbxout_type (TYPE_METHOD_BASETYPE (type
), 0);
2201 dbxout_type (TREE_TYPE (type
), 0);
2202 dbxout_args (TYPE_ARG_TYPES (type
));
2206 /* Treat it as a function type. */
2207 dbxout_type (TREE_TYPE (type
), 0);
2211 if (use_gnu_debug_info_extensions
)
2213 have_used_extensions
= 1;
2215 dbxout_type (TYPE_OFFSET_BASETYPE (type
), 0);
2217 dbxout_type (TREE_TYPE (type
), 0);
2220 /* Should print as an int, because it is really just an offset. */
2221 dbxout_type (integer_type_node
, 0);
2224 case REFERENCE_TYPE
:
2225 if (use_gnu_debug_info_extensions
)
2227 have_used_extensions
= 1;
2232 dbxout_type (TREE_TYPE (type
), 0);
2237 dbxout_type (TREE_TYPE (type
), 0);
2245 /* Return nonzero if the given type represents an integer whose bounds
2246 should be printed in octal format. */
2249 print_int_cst_bounds_in_octal_p (tree type
)
2251 /* If we can use GDB extensions and the size is wider than a long
2252 (the size used by GDB to read them) or we may have trouble writing
2253 the bounds the usual way, write them in octal. Note the test is for
2254 the *target's* size of "long", not that of the host. The host test
2255 is just to make sure we can write it out in case the host wide int
2256 is narrower than the target "long".
2258 For unsigned types, we use octal if they are the same size or larger.
2259 This is because we print the bounds as signed decimal, and hence they
2260 can't span same size unsigned types. */
2262 if (use_gnu_debug_info_extensions
2263 && TYPE_MIN_VALUE (type
) != 0
2264 && TREE_CODE (TYPE_MIN_VALUE (type
)) == INTEGER_CST
2265 && TYPE_MAX_VALUE (type
) != 0
2266 && TREE_CODE (TYPE_MAX_VALUE (type
)) == INTEGER_CST
2267 && (TYPE_PRECISION (type
) > TYPE_PRECISION (integer_type_node
)
2268 || ((TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
))
2269 && TYPE_UNSIGNED (type
))
2270 || TYPE_PRECISION (type
) > HOST_BITS_PER_WIDE_INT
2271 || (TYPE_PRECISION (type
) == HOST_BITS_PER_WIDE_INT
2272 && TYPE_UNSIGNED (type
))))
2278 /* Output the name of type TYPE, with no punctuation.
2279 Such names can be set up either by typedef declarations
2280 or by struct, enum and union tags. */
2283 dbxout_type_name (tree type
)
2285 tree t
= TYPE_NAME (type
);
2288 switch (TREE_CODE (t
))
2290 case IDENTIFIER_NODE
:
2302 /* Output leading leading struct or class names needed for qualifying
2303 type whose scope is limited to a struct or class. */
2306 dbxout_class_name_qualifiers (tree decl
)
2308 tree context
= decl_type_context (decl
);
2310 if (context
!= NULL_TREE
2311 && TREE_CODE(context
) == RECORD_TYPE
2312 && TYPE_NAME (context
) != 0
2313 && (TREE_CODE (TYPE_NAME (context
)) == IDENTIFIER_NODE
2314 || (DECL_NAME (TYPE_NAME (context
)) != 0)))
2316 tree name
= TYPE_NAME (context
);
2318 if (TREE_CODE (name
) == TYPE_DECL
)
2320 dbxout_class_name_qualifiers (name
);
2321 name
= DECL_NAME (name
);
2328 /* Output a .stabs for the symbol defined by DECL,
2329 which must be a ..._DECL node in the normal namespace.
2330 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
2331 LOCAL is nonzero if the scope is less than the entire file.
2332 Return 1 if a stabs might have been emitted. */
2335 dbxout_symbol (tree decl
, int local ATTRIBUTE_UNUSED
)
2337 tree type
= TREE_TYPE (decl
);
2338 tree context
= NULL_TREE
;
2341 /* "Intercept" dbxout_symbol() calls like we do all debug_hooks. */
2344 /* Ignore nameless syms, but don't ignore type tags. */
2346 if ((DECL_NAME (decl
) == 0 && TREE_CODE (decl
) != TYPE_DECL
)
2347 || DECL_IGNORED_P (decl
))
2348 DBXOUT_DECR_NESTING_AND_RETURN (0);
2350 /* If we are to generate only the symbols actually used then such
2351 symbol nodees are flagged with TREE_USED. Ignore any that
2352 aren't flaged as TREE_USED. */
2354 if (flag_debug_only_used_symbols
2355 && (!TREE_USED (decl
)
2356 && (TREE_CODE (decl
) != VAR_DECL
|| !DECL_INITIAL (decl
))))
2357 DBXOUT_DECR_NESTING_AND_RETURN (0);
2359 /* If dbxout_init has not yet run, queue this symbol for later. */
2362 preinit_symbols
= tree_cons (0, decl
, preinit_symbols
);
2363 DBXOUT_DECR_NESTING_AND_RETURN (0);
2366 if (flag_debug_only_used_symbols
)
2370 /* We now have a used symbol. We need to generate the info for
2371 the symbol's type in addition to the symbol itself. These
2372 type symbols are queued to be generated after were done with
2373 the symbol itself (otherwise they would fight over the
2376 Note, because the TREE_TYPE(type) might be something like a
2377 pointer to a named type we need to look for the first name
2378 we see following the TREE_TYPE chain. */
2381 while (POINTER_TYPE_P (t
))
2384 /* RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, and ENUMERAL_TYPE
2385 need special treatment. The TYPE_STUB_DECL field in these
2386 types generally represents the tag name type we want to
2387 output. In addition there could be a typedef type with
2388 a different name. In that case we also want to output
2391 if (TREE_CODE (t
) == RECORD_TYPE
2392 || TREE_CODE (t
) == UNION_TYPE
2393 || TREE_CODE (t
) == QUAL_UNION_TYPE
2394 || TREE_CODE (t
) == ENUMERAL_TYPE
)
2396 if (TYPE_STUB_DECL (t
)
2397 && TYPE_STUB_DECL (t
) != decl
2398 && DECL_P (TYPE_STUB_DECL (t
))
2399 && ! DECL_IGNORED_P (TYPE_STUB_DECL (t
)))
2401 debug_queue_symbol (TYPE_STUB_DECL (t
));
2403 && TYPE_NAME (t
) != TYPE_STUB_DECL (t
)
2404 && TYPE_NAME (t
) != decl
2405 && DECL_P (TYPE_NAME (t
)))
2406 debug_queue_symbol (TYPE_NAME (t
));
2409 else if (TYPE_NAME (t
)
2410 && TYPE_NAME (t
) != decl
2411 && DECL_P (TYPE_NAME (t
)))
2412 debug_queue_symbol (TYPE_NAME (t
));
2415 emit_pending_bincls_if_required ();
2417 switch (TREE_CODE (decl
))
2420 /* Enum values are defined by defining the enum type. */
2424 if (DECL_RTL (decl
) == 0)
2425 DBXOUT_DECR_NESTING_AND_RETURN (0);
2426 if (DECL_EXTERNAL (decl
))
2428 /* Don't mention a nested function under its parent. */
2429 context
= decl_function_context (decl
);
2430 if (context
== current_function_decl
)
2432 /* Don't mention an inline instance of a nested function. */
2433 if (context
&& DECL_FROM_INLINE (decl
))
2435 if (!MEM_P (DECL_RTL (decl
))
2436 || GET_CODE (XEXP (DECL_RTL (decl
), 0)) != SYMBOL_REF
)
2439 dbxout_begin_complex_stabs ();
2440 stabstr_I (DECL_ASSEMBLER_NAME (decl
));
2441 stabstr_S (TREE_PUBLIC (decl
) ? ":F" : ":f");
2444 if (TREE_TYPE (type
))
2445 dbxout_type (TREE_TYPE (type
), 0);
2447 dbxout_type (void_type_node
, 0);
2449 /* For a nested function, when that function is compiled,
2450 mention the containing function name
2451 as well as (since dbx wants it) our own assembler-name. */
2455 stabstr_I (DECL_ASSEMBLER_NAME (decl
));
2457 stabstr_I (DECL_NAME (context
));
2460 dbxout_finish_complex_stabs (decl
, N_FUN
, XEXP (DECL_RTL (decl
), 0),
2465 /* Don't output the same typedef twice.
2466 And don't output what language-specific stuff doesn't want output. */
2467 if (TREE_ASM_WRITTEN (decl
) || TYPE_DECL_SUPPRESS_DEBUG (decl
))
2468 DBXOUT_DECR_NESTING_AND_RETURN (0);
2470 /* Don't output typedefs for types with magic type numbers (XCOFF). */
2471 #ifdef DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER
2473 int fundamental_type_number
=
2474 DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER (decl
);
2476 if (fundamental_type_number
!= 0)
2478 TREE_ASM_WRITTEN (decl
) = 1;
2479 TYPE_SYMTAB_ADDRESS (TREE_TYPE (decl
)) = fundamental_type_number
;
2480 DBXOUT_DECR_NESTING_AND_RETURN (0);
2490 if (DECL_NAME (decl
))
2492 /* Nonzero means we must output a tag as well as a typedef. */
2495 /* Handle the case of a C++ structure or union
2496 where the TYPE_NAME is a TYPE_DECL
2497 which gives both a typedef name and a tag. */
2498 /* dbx requires the tag first and the typedef second. */
2499 if ((TREE_CODE (type
) == RECORD_TYPE
2500 || TREE_CODE (type
) == UNION_TYPE
2501 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
2502 && TYPE_NAME (type
) == decl
2503 && !(use_gnu_debug_info_extensions
&& have_used_extensions
)
2504 && !TREE_ASM_WRITTEN (TYPE_NAME (type
))
2505 /* Distinguish the implicit typedefs of C++
2506 from explicit ones that might be found in C. */
2507 && DECL_ARTIFICIAL (decl
)
2508 /* Do not generate a tag for incomplete records. */
2509 && COMPLETE_TYPE_P (type
)
2510 /* Do not generate a tag for records of variable size,
2511 since this type can not be properly described in the
2512 DBX format, and it confuses some tools such as objdump. */
2513 && host_integerp (TYPE_SIZE (type
), 1))
2515 tree name
= TYPE_NAME (type
);
2516 if (TREE_CODE (name
) == TYPE_DECL
)
2517 name
= DECL_NAME (name
);
2519 dbxout_begin_complex_stabs ();
2522 dbxout_type (type
, 1);
2523 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE
,
2527 dbxout_begin_complex_stabs ();
2529 /* Output leading class/struct qualifiers.
2530 ??? why not set have_used_extensions here ... because
2531 then the test of it below would always be true, I
2532 guess. But it's not clear to me why we shouldn't do
2533 that always in extended mode. */
2534 if (use_gnu_debug_info_extensions
)
2535 dbxout_class_name_qualifiers (decl
);
2537 /* Output typedef name. */
2538 stabstr_I (DECL_NAME (decl
));
2541 /* Short cut way to output a tag also. */
2542 if ((TREE_CODE (type
) == RECORD_TYPE
2543 || TREE_CODE (type
) == UNION_TYPE
2544 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
2545 && TYPE_NAME (type
) == decl
2546 /* Distinguish the implicit typedefs of C++
2547 from explicit ones that might be found in C. */
2548 && DECL_ARTIFICIAL (decl
))
2550 if (use_gnu_debug_info_extensions
&& have_used_extensions
)
2553 TREE_ASM_WRITTEN (TYPE_NAME (type
)) = 1;
2558 dbxout_type (type
, 1);
2559 dbxout_finish_complex_stabs (decl
, DBX_TYPE_DECL_STABS_CODE
,
2564 /* Don't output a tag if this is an incomplete type. This prevents
2565 the sun4 Sun OS 4.x dbx from crashing. */
2567 if (tag_needed
&& TYPE_NAME (type
) != 0
2568 && (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
2569 || (DECL_NAME (TYPE_NAME (type
)) != 0))
2570 && COMPLETE_TYPE_P (type
)
2571 && !TREE_ASM_WRITTEN (TYPE_NAME (type
)))
2573 /* For a TYPE_DECL with no name, but the type has a name,
2575 This is what represents `struct foo' with no typedef. */
2576 /* In C++, the name of a type is the corresponding typedef.
2577 In C, it is an IDENTIFIER_NODE. */
2578 tree name
= TYPE_NAME (type
);
2579 if (TREE_CODE (name
) == TYPE_DECL
)
2580 name
= DECL_NAME (name
);
2582 dbxout_begin_complex_stabs ();
2585 dbxout_type (type
, 1);
2586 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE
, 0, 0, 0);
2590 /* If an enum type has no name, it cannot be referred to, but
2591 we must output it anyway, to record the enumeration
2594 if (!did_output
&& TREE_CODE (type
) == ENUMERAL_TYPE
)
2596 dbxout_begin_complex_stabs ();
2597 /* Some debuggers fail when given NULL names, so give this a
2598 harmless name of " " (Why not "(anon)"?). */
2600 dbxout_type (type
, 1);
2601 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE
, 0, 0, 0);
2604 /* Prevent duplicate output of a typedef. */
2605 TREE_ASM_WRITTEN (decl
) = 1;
2610 /* Parm decls go in their own separate chains
2611 and are output by dbxout_reg_parms and dbxout_parms. */
2615 /* Named return value, treat like a VAR_DECL. */
2617 if (! DECL_RTL_SET_P (decl
))
2618 DBXOUT_DECR_NESTING_AND_RETURN (0);
2619 /* Don't mention a variable that is external.
2620 Let the file that defines it describe it. */
2621 if (DECL_EXTERNAL (decl
))
2624 /* If the variable is really a constant
2625 and not written in memory, inform the debugger.
2627 ??? Why do we skip emitting the type and location in this case? */
2628 if (TREE_STATIC (decl
) && TREE_READONLY (decl
)
2629 && DECL_INITIAL (decl
) != 0
2630 && host_integerp (DECL_INITIAL (decl
), 0)
2631 && ! TREE_ASM_WRITTEN (decl
)
2632 && (DECL_CONTEXT (decl
) == NULL_TREE
2633 || TREE_CODE (DECL_CONTEXT (decl
)) == BLOCK
)
2634 && TREE_PUBLIC (decl
) == 0)
2636 /* The sun4 assembler does not grok this. */
2638 if (TREE_CODE (TREE_TYPE (decl
)) == INTEGER_TYPE
2639 || TREE_CODE (TREE_TYPE (decl
)) == ENUMERAL_TYPE
)
2641 HOST_WIDE_INT ival
= TREE_INT_CST_LOW (DECL_INITIAL (decl
));
2643 dbxout_begin_complex_stabs ();
2644 stabstr_I (DECL_NAME (decl
));
2647 dbxout_finish_complex_stabs (0, N_LSYM
, 0, 0, 0);
2648 DBXOUT_DECR_NESTING
;
2654 /* else it is something we handle like a normal variable. */
2656 SET_DECL_RTL (decl
, eliminate_regs (DECL_RTL (decl
), 0, NULL_RTX
));
2657 #ifdef LEAF_REG_REMAP
2658 if (current_function_uses_only_leaf_regs
)
2659 leaf_renumber_regs_insn (DECL_RTL (decl
));
2662 result
= dbxout_symbol_location (decl
, type
, 0, DECL_RTL (decl
));
2668 DBXOUT_DECR_NESTING
;
2672 /* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL.
2673 Add SUFFIX to its name, if SUFFIX is not 0.
2674 Describe the variable as residing in HOME
2675 (usually HOME is DECL_RTL (DECL), but not always).
2676 Returns 1 if the stab was really emitted. */
2679 dbxout_symbol_location (tree decl
, tree type
, const char *suffix
, rtx home
)
2682 STAB_CODE_TYPE code
;
2687 /* Don't mention a variable at all
2688 if it was completely optimized into nothingness.
2690 If the decl was from an inline function, then its rtl
2691 is not identically the rtl that was used in this
2692 particular compilation. */
2693 if (GET_CODE (home
) == SUBREG
)
2697 while (GET_CODE (value
) == SUBREG
)
2698 value
= SUBREG_REG (value
);
2701 if (REGNO (value
) >= FIRST_PSEUDO_REGISTER
)
2704 home
= alter_subreg (&home
);
2708 regno
= REGNO (home
);
2709 if (regno
>= FIRST_PSEUDO_REGISTER
)
2713 /* The kind-of-variable letter depends on where
2714 the variable is and on the scope of its name:
2715 G and N_GSYM for static storage and global scope,
2716 S for static storage and file scope,
2717 V for static storage and local scope,
2718 for those two, use N_LCSYM if data is in bss segment,
2719 N_STSYM if in data segment, N_FUN otherwise.
2720 (We used N_FUN originally, then changed to N_STSYM
2721 to please GDB. However, it seems that confused ld.
2722 Now GDB has been fixed to like N_FUN, says Kingdon.)
2723 no letter at all, and N_LSYM, for auto variable,
2724 r and N_RSYM for register variable. */
2726 if (MEM_P (home
) && GET_CODE (XEXP (home
, 0)) == SYMBOL_REF
)
2728 if (TREE_PUBLIC (decl
))
2735 addr
= XEXP (home
, 0);
2737 letter
= decl_function_context (decl
) ? 'V' : 'S';
2739 /* Some ports can transform a symbol ref into a label ref,
2740 because the symbol ref is too far away and has to be
2741 dumped into a constant pool. Alternatively, the symbol
2742 in the constant pool might be referenced by a different
2744 if (GET_CODE (addr
) == SYMBOL_REF
2745 && CONSTANT_POOL_ADDRESS_P (addr
))
2748 rtx tmp
= get_pool_constant_mark (addr
, &marked
);
2750 if (GET_CODE (tmp
) == SYMBOL_REF
)
2753 if (CONSTANT_POOL_ADDRESS_P (addr
))
2754 get_pool_constant_mark (addr
, &marked
);
2758 else if (GET_CODE (tmp
) == LABEL_REF
)
2764 /* If all references to the constant pool were optimized
2765 out, we just ignore the symbol. */
2770 /* This should be the same condition as in assemble_variable, but
2771 we don't have access to dont_output_data here. So, instead,
2772 we rely on the fact that error_mark_node initializers always
2773 end up in bss for C++ and never end up in bss for C. */
2774 if (DECL_INITIAL (decl
) == 0
2775 || (!strcmp (lang_hooks
.name
, "GNU C++")
2776 && DECL_INITIAL (decl
) == error_mark_node
))
2778 else if (DECL_IN_TEXT_SECTION (decl
))
2779 /* This is not quite right, but it's the closest
2780 of all the codes that Unix defines. */
2781 code
= DBX_STATIC_CONST_VAR_CODE
;
2784 /* Ultrix `as' seems to need this. */
2785 #ifdef DBX_STATIC_STAB_DATA_SECTION
2792 else if (regno
>= 0)
2796 number
= DBX_REGISTER_NUMBER (regno
);
2798 else if (MEM_P (home
)
2799 && (MEM_P (XEXP (home
, 0))
2800 || (REG_P (XEXP (home
, 0))
2801 && REGNO (XEXP (home
, 0)) != HARD_FRAME_POINTER_REGNUM
2802 && REGNO (XEXP (home
, 0)) != STACK_POINTER_REGNUM
2803 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2804 && REGNO (XEXP (home
, 0)) != ARG_POINTER_REGNUM
2807 /* If the value is indirect by memory or by a register
2808 that isn't the frame pointer
2809 then it means the object is variable-sized and address through
2810 that register or stack slot. DBX has no way to represent this
2811 so all we can do is output the variable as a pointer.
2812 If it's not a parameter, ignore it. */
2814 if (REG_P (XEXP (home
, 0)))
2818 if (REGNO (XEXP (home
, 0)) >= FIRST_PSEUDO_REGISTER
)
2820 number
= DBX_REGISTER_NUMBER (REGNO (XEXP (home
, 0)));
2825 /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
2826 We want the value of that CONST_INT. */
2827 number
= DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home
, 0), 0));
2830 /* Effectively do build_pointer_type, but don't cache this type,
2831 since it might be temporary whereas the type it points to
2832 might have been saved for inlining. */
2833 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
2834 type
= make_node (POINTER_TYPE
);
2835 TREE_TYPE (type
) = TREE_TYPE (decl
);
2837 else if (MEM_P (home
)
2838 && REG_P (XEXP (home
, 0)))
2841 number
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
2843 else if (MEM_P (home
)
2844 && GET_CODE (XEXP (home
, 0)) == PLUS
2845 && GET_CODE (XEXP (XEXP (home
, 0), 1)) == CONST_INT
)
2848 /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
2849 We want the value of that CONST_INT. */
2850 number
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
2852 else if (MEM_P (home
)
2853 && GET_CODE (XEXP (home
, 0)) == CONST
)
2855 /* Handle an obscure case which can arise when optimizing and
2856 when there are few available registers. (This is *always*
2857 the case for i386/i486 targets). The RTL looks like
2858 (MEM (CONST ...)) even though this variable is a local `auto'
2859 or a local `register' variable. In effect, what has happened
2860 is that the reload pass has seen that all assignments and
2861 references for one such a local variable can be replaced by
2862 equivalent assignments and references to some static storage
2863 variable, thereby avoiding the need for a register. In such
2864 cases we're forced to lie to debuggers and tell them that
2865 this variable was itself `static'. */
2868 addr
= XEXP (XEXP (home
, 0), 0);
2870 else if (GET_CODE (home
) == CONCAT
)
2874 /* If TYPE is not a COMPLEX_TYPE (it might be a RECORD_TYPE,
2875 for example), then there is no easy way to figure out
2876 what SUBTYPE should be. So, we give up. */
2877 if (TREE_CODE (type
) != COMPLEX_TYPE
)
2880 subtype
= TREE_TYPE (type
);
2882 /* If the variable's storage is in two parts,
2883 output each as a separate stab with a modified name. */
2884 if (WORDS_BIG_ENDIAN
)
2885 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 0));
2887 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 0));
2889 if (WORDS_BIG_ENDIAN
)
2890 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 1));
2892 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 1));
2896 /* Address might be a MEM, when DECL is a variable-sized object.
2897 Or it might be const0_rtx, meaning previous passes
2898 want us to ignore this variable. */
2901 /* Ok, start a symtab entry and output the variable name. */
2902 emit_pending_bincls_if_required ();
2905 #ifdef DBX_STATIC_BLOCK_START
2906 DBX_STATIC_BLOCK_START (asm_out_file
, code
);
2909 dbxout_begin_complex_stabs_noforcetext ();
2910 dbxout_symbol_name (decl
, suffix
, letter
);
2911 dbxout_type (type
, 0);
2912 dbxout_finish_complex_stabs (decl
, code
, addr
, 0, number
);
2914 #ifdef DBX_STATIC_BLOCK_END
2915 DBX_STATIC_BLOCK_END (asm_out_file
, code
);
2920 /* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
2921 Then output LETTER to indicate the kind of location the symbol has. */
2924 dbxout_symbol_name (tree decl
, const char *suffix
, int letter
)
2928 if (DECL_CONTEXT (decl
)
2929 && (TYPE_P (DECL_CONTEXT (decl
))
2930 || TREE_CODE (DECL_CONTEXT (decl
)) == NAMESPACE_DECL
))
2931 /* One slight hitch: if this is a VAR_DECL which is a class member
2932 or a namespace member, we must put out the mangled name instead of the
2933 DECL_NAME. Note also that static member (variable) names DO NOT begin
2934 with underscores in .stabs directives. */
2935 name
= DECL_ASSEMBLER_NAME (decl
);
2937 /* ...but if we're function-local, we don't want to include the junk
2938 added by ASM_FORMAT_PRIVATE_NAME. */
2939 name
= DECL_NAME (decl
);
2944 stabstr_S ("(anon)");
2953 /* Output definitions of all the decls in a chain. Return nonzero if
2954 anything was output */
2957 dbxout_syms (tree syms
)
2962 result
+= dbxout_symbol (syms
, 1);
2963 syms
= TREE_CHAIN (syms
);
2968 /* The following two functions output definitions of function parameters.
2969 Each parameter gets a definition locating it in the parameter list.
2970 Each parameter that is a register variable gets a second definition
2971 locating it in the register.
2973 Printing or argument lists in gdb uses the definitions that
2974 locate in the parameter list. But reference to the variable in
2975 expressions uses preferentially the definition as a register. */
2977 /* Output definitions, referring to storage in the parmlist,
2978 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
2981 dbxout_parms (tree parms
)
2984 emit_pending_bincls_if_required ();
2986 for (; parms
; parms
= TREE_CHAIN (parms
))
2987 if (DECL_NAME (parms
)
2988 && TREE_TYPE (parms
) != error_mark_node
2989 && DECL_RTL_SET_P (parms
)
2990 && DECL_INCOMING_RTL (parms
))
2994 STAB_CODE_TYPE code
;
2997 /* Perform any necessary register eliminations on the parameter's rtl,
2998 so that the debugging output will be accurate. */
2999 DECL_INCOMING_RTL (parms
)
3000 = eliminate_regs (DECL_INCOMING_RTL (parms
), 0, NULL_RTX
);
3001 SET_DECL_RTL (parms
, eliminate_regs (DECL_RTL (parms
), 0, NULL_RTX
));
3002 #ifdef LEAF_REG_REMAP
3003 if (current_function_uses_only_leaf_regs
)
3005 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms
));
3006 leaf_renumber_regs_insn (DECL_RTL (parms
));
3010 if (PARM_PASSED_IN_MEMORY (parms
))
3012 rtx inrtl
= XEXP (DECL_INCOMING_RTL (parms
), 0);
3014 /* ??? Here we assume that the parm address is indexed
3015 off the frame pointer or arg pointer.
3016 If that is not true, we produce meaningless results,
3017 but do not crash. */
3018 if (GET_CODE (inrtl
) == PLUS
3019 && GET_CODE (XEXP (inrtl
, 1)) == CONST_INT
)
3020 number
= INTVAL (XEXP (inrtl
, 1));
3025 number
= DEBUGGER_ARG_OFFSET (number
, inrtl
);
3028 /* It is quite tempting to use TREE_TYPE (parms) instead
3029 of DECL_ARG_TYPE (parms) for the eff_type, so that gcc
3030 reports the actual type of the parameter, rather than
3031 the promoted type. This certainly makes GDB's life
3032 easier, at least for some ports. The change is a bad
3033 idea however, since GDB expects to be able access the
3034 type without performing any conversions. So for
3035 example, if we were passing a float to an unprototyped
3036 function, gcc will store a double on the stack, but if
3037 we emit a stab saying the type is a float, then gdb
3038 will only read in a single value, and this will produce
3039 an erroneous value. */
3040 eff_type
= DECL_ARG_TYPE (parms
);
3042 else if (REG_P (DECL_RTL (parms
)))
3046 /* Parm passed in registers and lives in registers or nowhere. */
3047 code
= DBX_REGPARM_STABS_CODE
;
3048 letter
= DBX_REGPARM_STABS_LETTER
;
3050 /* For parms passed in registers, it is better to use the
3051 declared type of the variable, not the type it arrived in. */
3052 eff_type
= TREE_TYPE (parms
);
3054 /* If parm lives in a register, use that register; pretend
3055 the parm was passed there. It would be more consistent
3056 to describe the register where the parm was passed, but
3057 in practice that register usually holds something else.
3058 If the parm lives nowhere, use the register where it
3060 if (REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
3061 best_rtl
= DECL_RTL (parms
);
3063 best_rtl
= DECL_INCOMING_RTL (parms
);
3065 number
= DBX_REGISTER_NUMBER (REGNO (best_rtl
));
3067 else if (MEM_P (DECL_RTL (parms
))
3068 && REG_P (XEXP (DECL_RTL (parms
), 0))
3069 && REGNO (XEXP (DECL_RTL (parms
), 0)) != HARD_FRAME_POINTER_REGNUM
3070 && REGNO (XEXP (DECL_RTL (parms
), 0)) != STACK_POINTER_REGNUM
3071 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
3072 && REGNO (XEXP (DECL_RTL (parms
), 0)) != ARG_POINTER_REGNUM
3076 /* Parm was passed via invisible reference.
3077 That is, its address was passed in a register.
3078 Output it as if it lived in that register.
3079 The debugger will know from the type
3080 that it was actually passed by invisible reference. */
3082 code
= DBX_REGPARM_STABS_CODE
;
3084 /* GDB likes this marked with a special letter. */
3085 letter
= (use_gnu_debug_info_extensions
3086 ? 'a' : DBX_REGPARM_STABS_LETTER
);
3087 eff_type
= TREE_TYPE (parms
);
3089 /* DECL_RTL looks like (MEM (REG...). Get the register number.
3090 If it is an unallocated pseudo-reg, then use the register where
3091 it was passed instead.
3092 ??? Why is DBX_REGISTER_NUMBER not used here? */
3094 if (REGNO (XEXP (DECL_RTL (parms
), 0)) < FIRST_PSEUDO_REGISTER
)
3095 number
= REGNO (XEXP (DECL_RTL (parms
), 0));
3097 number
= REGNO (DECL_INCOMING_RTL (parms
));
3099 else if (MEM_P (DECL_RTL (parms
))
3100 && MEM_P (XEXP (DECL_RTL (parms
), 0)))
3102 /* Parm was passed via invisible reference, with the reference
3103 living on the stack. DECL_RTL looks like
3104 (MEM (MEM (PLUS (REG ...) (CONST_INT ...)))) or it
3105 could look like (MEM (MEM (REG))). */
3109 eff_type
= TREE_TYPE (parms
);
3111 if (!REG_P (XEXP (XEXP (DECL_RTL (parms
), 0), 0)))
3112 number
= INTVAL (XEXP (XEXP (XEXP (DECL_RTL (parms
), 0), 0), 1));
3116 number
= DEBUGGER_ARG_OFFSET (number
,
3117 XEXP (XEXP (DECL_RTL (parms
), 0), 0));
3119 else if (MEM_P (DECL_RTL (parms
))
3120 && XEXP (DECL_RTL (parms
), 0) != const0_rtx
3121 /* ??? A constant address for a parm can happen
3122 when the reg it lives in is equiv to a constant in memory.
3123 Should make this not happen, after 2.4. */
3124 && ! CONSTANT_P (XEXP (DECL_RTL (parms
), 0)))
3126 /* Parm was passed in registers but lives on the stack. */
3130 eff_type
= TREE_TYPE (parms
);
3132 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
3133 in which case we want the value of that CONST_INT,
3135 in which case we use a value of zero. */
3136 if (!REG_P (XEXP (DECL_RTL (parms
), 0)))
3137 number
= INTVAL (XEXP (XEXP (DECL_RTL (parms
), 0), 1));
3141 /* Make a big endian correction if the mode of the type of the
3142 parameter is not the same as the mode of the rtl. */
3143 if (BYTES_BIG_ENDIAN
3144 && TYPE_MODE (TREE_TYPE (parms
)) != GET_MODE (DECL_RTL (parms
))
3145 && GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms
))) < UNITS_PER_WORD
)
3146 number
+= (GET_MODE_SIZE (GET_MODE (DECL_RTL (parms
)))
3147 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms
))));
3150 /* ??? We don't know how to represent this argument. */
3153 dbxout_begin_complex_stabs ();
3155 if (DECL_NAME (parms
))
3157 stabstr_I (DECL_NAME (parms
));
3161 stabstr_S ("(anon):");
3163 dbxout_type (eff_type
, 0);
3164 dbxout_finish_complex_stabs (parms
, code
, 0, 0, number
);
3166 DBXOUT_DECR_NESTING
;
3169 /* Output definitions for the places where parms live during the function,
3170 when different from where they were passed, when the parms were passed
3173 It is not useful to do this for parms passed in registers
3174 that live during the function in different registers, because it is
3175 impossible to look in the passed register for the passed value,
3176 so we use the within-the-function register to begin with.
3178 PARMS is a chain of PARM_DECL nodes. */
3181 dbxout_reg_parms (tree parms
)
3185 for (; parms
; parms
= TREE_CHAIN (parms
))
3186 if (DECL_NAME (parms
) && PARM_PASSED_IN_MEMORY (parms
))
3188 /* Report parms that live in registers during the function
3189 but were passed in memory. */
3190 if (REG_P (DECL_RTL (parms
))
3191 && REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
3192 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
3193 0, DECL_RTL (parms
));
3194 else if (GET_CODE (DECL_RTL (parms
)) == CONCAT
)
3195 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
3196 0, DECL_RTL (parms
));
3197 /* Report parms that live in memory but not where they were passed. */
3198 else if (MEM_P (DECL_RTL (parms
))
3199 && ! rtx_equal_p (DECL_RTL (parms
), DECL_INCOMING_RTL (parms
)))
3200 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
3201 0, DECL_RTL (parms
));
3203 DBXOUT_DECR_NESTING
;
3206 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
3207 output definitions of those names, in raw form */
3210 dbxout_args (tree args
)
3215 dbxout_type (TREE_VALUE (args
), 0);
3216 args
= TREE_CHAIN (args
);
3220 /* Subroutine of dbxout_block. Emit an N_LBRAC stab referencing LABEL.
3221 BEGIN_LABEL is the name of the beginning of the function, which may
3224 dbx_output_lbrac (const char *label
,
3225 const char *begin_label ATTRIBUTE_UNUSED
)
3227 #ifdef DBX_OUTPUT_LBRAC
3228 DBX_OUTPUT_LBRAC (asm_out_file
, label
);
3230 dbxout_begin_stabn (N_LBRAC
);
3231 if (DBX_BLOCKS_FUNCTION_RELATIVE
)
3232 dbxout_stab_value_label_diff (label
, begin_label
);
3234 dbxout_stab_value_label (label
);
3238 /* Subroutine of dbxout_block. Emit an N_RBRAC stab referencing LABEL.
3239 BEGIN_LABEL is the name of the beginning of the function, which may
3242 dbx_output_rbrac (const char *label
,
3243 const char *begin_label ATTRIBUTE_UNUSED
)
3245 #ifdef DBX_OUTPUT_RBRAC
3246 DBX_OUTPUT_RBRAC (asm_out_file
, label
);
3248 dbxout_begin_stabn (N_RBRAC
);
3249 if (DBX_BLOCKS_FUNCTION_RELATIVE
)
3250 dbxout_stab_value_label_diff (label
, begin_label
);
3252 dbxout_stab_value_label (label
);
3256 /* Output everything about a symbol block (a BLOCK node
3257 that represents a scope level),
3258 including recursive output of contained blocks.
3260 BLOCK is the BLOCK node.
3261 DEPTH is its depth within containing symbol blocks.
3262 ARGS is usually zero; but for the outermost block of the
3263 body of a function, it is a chain of PARM_DECLs for the function parameters.
3264 We output definitions of all the register parms
3265 as if they were local variables of that block.
3267 If -g1 was used, we count blocks just the same, but output nothing
3268 except for the outermost block.
3270 Actually, BLOCK may be several blocks chained together.
3271 We handle them all in sequence. */
3274 dbxout_block (tree block
, int depth
, tree args
)
3276 const char *begin_label
3277 = XSTR (XEXP (DECL_RTL (current_function_decl
), 0), 0);
3281 /* Ignore blocks never expanded or otherwise marked as real. */
3282 if (TREE_USED (block
) && TREE_ASM_WRITTEN (block
))
3285 int blocknum
= BLOCK_NUMBER (block
);
3287 /* In dbx format, the syms of a block come before the N_LBRAC.
3288 If nothing is output, we don't need the N_LBRAC, either. */
3290 if (debug_info_level
!= DINFO_LEVEL_TERSE
|| depth
== 0)
3291 did_output
= dbxout_syms (BLOCK_VARS (block
));
3293 dbxout_reg_parms (args
);
3295 /* Now output an N_LBRAC symbol to represent the beginning of
3296 the block. Use the block's tree-walk order to generate
3297 the assembler symbols LBBn and LBEn
3298 that final will define around the code in this block. */
3302 const char *scope_start
;
3305 /* The outermost block doesn't get LBB labels; use
3306 the function symbol. */
3307 scope_start
= begin_label
;
3310 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBB", blocknum
);
3314 if (BLOCK_HANDLER_BLOCK (block
))
3316 /* A catch block. Must precede N_LBRAC. */
3317 tree decl
= BLOCK_VARS (block
);
3320 dbxout_begin_complex_stabs ();
3321 stabstr_I (DECL_NAME (decl
));
3323 dbxout_finish_complex_stabs (0, N_CATCH
, 0,
3325 decl
= TREE_CHAIN (decl
);
3328 dbx_output_lbrac (scope_start
, begin_label
);
3331 /* Output the subblocks. */
3332 dbxout_block (BLOCK_SUBBLOCKS (block
), depth
+ 1, NULL_TREE
);
3334 /* Refer to the marker for the end of the block. */
3339 /* The outermost block doesn't get LBE labels;
3340 use the "scope" label which will be emitted
3341 by dbxout_function_end. */
3342 ASM_GENERATE_INTERNAL_LABEL (buf
, "Lscope", scope_labelno
);
3344 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBE", blocknum
);
3346 dbx_output_rbrac (buf
, begin_label
);
3349 block
= BLOCK_CHAIN (block
);
3353 /* Output the information about a function and its arguments and result.
3354 Usually this follows the function's code,
3355 but on some systems, it comes before. */
3357 #if defined (DBX_DEBUGGING_INFO)
3359 dbxout_begin_function (tree decl
)
3361 int saved_tree_used1
= TREE_USED (decl
);
3362 TREE_USED (decl
) = 1;
3363 if (DECL_NAME (DECL_RESULT (decl
)) != 0)
3365 int saved_tree_used2
= TREE_USED (DECL_RESULT (decl
));
3366 TREE_USED (DECL_RESULT (decl
)) = 1;
3367 dbxout_symbol (decl
, 0);
3368 TREE_USED (DECL_RESULT (decl
)) = saved_tree_used2
;
3371 dbxout_symbol (decl
, 0);
3372 TREE_USED (decl
) = saved_tree_used1
;
3374 dbxout_parms (DECL_ARGUMENTS (decl
));
3375 if (DECL_NAME (DECL_RESULT (decl
)) != 0)
3376 dbxout_symbol (DECL_RESULT (decl
), 1);
3378 #endif /* DBX_DEBUGGING_INFO */
3380 #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */
3382 #include "gt-dbxout.h"