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 /* 1 if PARM is passed to this function in memory. */
280 #define PARM_PASSED_IN_MEMORY(PARM) \
281 (MEM_P (DECL_INCOMING_RTL (PARM)))
283 /* A C expression for the integer offset value of an automatic variable
284 (N_LSYM) having address X (an RTX). */
285 #ifndef DEBUGGER_AUTO_OFFSET
286 #define DEBUGGER_AUTO_OFFSET(X) \
287 (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
290 /* A C expression for the integer offset value of an argument (N_PSYM)
291 having address X (an RTX). The nominal offset is OFFSET. */
292 #ifndef DEBUGGER_ARG_OFFSET
293 #define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET)
296 /* This obstack holds the stab string currently being constructed. We
297 build it up here, then write it out, so we can split long lines up
298 properly (see dbxout_finish_complex_stabs). */
299 static struct obstack stabstr_ob
;
300 static size_t stabstr_last_contin_point
;
303 static void emit_bincl_stab (const char *c
);
304 static void emit_pending_bincls (void);
306 static inline void emit_pending_bincls_if_required (void);
308 static void dbxout_init (const char *);
310 static void dbxout_finish (const char *);
311 static void dbxout_start_source_file (unsigned, const char *);
312 static void dbxout_end_source_file (unsigned);
313 static void dbxout_typedefs (tree
);
314 static void dbxout_type_index (tree
);
315 static void dbxout_args (tree
);
316 static void dbxout_type_fields (tree
);
317 static void dbxout_type_method_1 (tree
);
318 static void dbxout_type_methods (tree
);
319 static void dbxout_range_type (tree
, tree
, tree
);
320 static void dbxout_type (tree
, int);
321 static bool print_int_cst_bounds_in_octal_p (tree
, tree
, tree
);
322 static bool is_fortran (void);
323 static void dbxout_type_name (tree
);
324 static void dbxout_class_name_qualifiers (tree
);
325 static int dbxout_symbol_location (tree
, tree
, const char *, rtx
);
326 static void dbxout_symbol_name (tree
, const char *, int);
327 static void dbxout_common_name (tree
, const char *, stab_code_type
);
328 static const char *dbxout_common_check (tree
, int *);
329 static void dbxout_global_decl (tree
);
330 static void dbxout_type_decl (tree
, int);
331 static void dbxout_handle_pch (unsigned);
333 /* The debug hooks structure. */
334 #if defined (DBX_DEBUGGING_INFO)
336 static void dbxout_source_line (unsigned int, const char *, int, bool);
337 static void dbxout_begin_prologue (unsigned int, const char *);
338 static void dbxout_source_file (const char *);
339 static void dbxout_function_end (tree
);
340 static void dbxout_begin_function (tree
);
341 static void dbxout_begin_block (unsigned, unsigned);
342 static void dbxout_end_block (unsigned, unsigned);
343 static void dbxout_function_decl (tree
);
345 const struct gcc_debug_hooks dbx_debug_hooks
=
349 debug_nothing_int_charstar
,
350 debug_nothing_int_charstar
,
351 dbxout_start_source_file
,
352 dbxout_end_source_file
,
355 debug_true_const_tree
, /* ignore_block */
356 dbxout_source_line
, /* source_line */
357 dbxout_begin_prologue
, /* begin_prologue */
358 debug_nothing_int_charstar
, /* end_prologue */
359 debug_nothing_int_charstar
, /* end_epilogue */
360 #ifdef DBX_FUNCTION_FIRST
361 dbxout_begin_function
,
363 debug_nothing_tree
, /* begin_function */
365 debug_nothing_int
, /* end_function */
366 dbxout_function_decl
,
367 dbxout_global_decl
, /* global_decl */
368 dbxout_type_decl
, /* type_decl */
369 debug_nothing_tree_tree_tree_bool
, /* imported_module_or_decl */
370 debug_nothing_tree
, /* deferred_inline_function */
371 debug_nothing_tree
, /* outlining_inline_function */
372 debug_nothing_rtx
, /* label */
373 dbxout_handle_pch
, /* handle_pch */
374 debug_nothing_rtx
, /* var_location */
375 debug_nothing_void
, /* switch_text_section */
376 debug_nothing_tree_tree
, /* set_name */
377 0 /* start_end_main_source_file */
379 #endif /* DBX_DEBUGGING_INFO */
381 #if defined (XCOFF_DEBUGGING_INFO)
382 const struct gcc_debug_hooks xcoff_debug_hooks
=
386 debug_nothing_int_charstar
,
387 debug_nothing_int_charstar
,
388 dbxout_start_source_file
,
389 dbxout_end_source_file
,
390 xcoffout_begin_block
,
392 debug_true_const_tree
, /* ignore_block */
393 xcoffout_source_line
,
394 xcoffout_begin_prologue
, /* begin_prologue */
395 debug_nothing_int_charstar
, /* end_prologue */
396 xcoffout_end_epilogue
,
397 debug_nothing_tree
, /* begin_function */
398 xcoffout_end_function
,
399 debug_nothing_tree
, /* function_decl */
400 dbxout_global_decl
, /* global_decl */
401 dbxout_type_decl
, /* type_decl */
402 debug_nothing_tree_tree_tree_bool
, /* imported_module_or_decl */
403 debug_nothing_tree
, /* deferred_inline_function */
404 debug_nothing_tree
, /* outlining_inline_function */
405 debug_nothing_rtx
, /* label */
406 dbxout_handle_pch
, /* handle_pch */
407 debug_nothing_rtx
, /* var_location */
408 debug_nothing_void
, /* switch_text_section */
409 debug_nothing_tree_tree
, /* set_name */
410 0 /* start_end_main_source_file */
412 #endif /* XCOFF_DEBUGGING_INFO */
414 /* Numeric formatting helper macro. Note that this does not handle
416 #define NUMBER_FMT_LOOP(P, NUM, BASE) \
419 int digit = NUM % BASE; \
421 *--P = digit + '0'; \
425 /* Utility: write a decimal integer NUM to asm_out_file. */
430 char *p
= buf
+ sizeof buf
;
435 putc ('0', asm_out_file
);
440 putc ('-', asm_out_file
);
446 NUMBER_FMT_LOOP (p
, unum
, 10);
448 while (p
< buf
+ sizeof buf
)
450 putc (*p
, asm_out_file
);
456 /* Primitives for emitting simple stabs directives. All other stabs
457 routines should use these functions instead of directly emitting
458 stabs. They are exported because machine-dependent code may need
459 to invoke them, e.g. in a DBX_OUTPUT_* macro whose definition
460 forwards to code in CPU.c. */
462 /* The following functions should all be called immediately after one
463 of the dbxout_begin_stab* functions (below). They write out
464 various things as the value of a stab. */
466 /* Write out a literal zero as the value of a stab. */
468 dbxout_stab_value_zero (void)
470 fputs ("0\n", asm_out_file
);
473 /* Write out the label LABEL as the value of a stab. */
475 dbxout_stab_value_label (const char *label
)
477 assemble_name (asm_out_file
, label
);
478 putc ('\n', asm_out_file
);
481 /* Write out the difference of two labels, LABEL - BASE, as the value
484 dbxout_stab_value_label_diff (const char *label
, const char *base
)
486 assemble_name (asm_out_file
, label
);
487 putc ('-', asm_out_file
);
488 assemble_name (asm_out_file
, base
);
489 putc ('\n', asm_out_file
);
492 /* Write out an internal label as the value of a stab, and immediately
493 emit that internal label. This should be used only when
494 dbxout_stabd will not work. STEM is the name stem of the label,
495 COUNTERP is a pointer to a counter variable which will be used to
496 guarantee label uniqueness. */
498 dbxout_stab_value_internal_label (const char *stem
, int *counterp
)
501 int counter
= counterp
? (*counterp
)++ : 0;
503 ASM_GENERATE_INTERNAL_LABEL (label
, stem
, counter
);
504 dbxout_stab_value_label (label
);
505 targetm
.asm_out
.internal_label (asm_out_file
, stem
, counter
);
508 /* Write out the difference between BASE and an internal label as the
509 value of a stab, and immediately emit that internal label. STEM and
510 COUNTERP are as for dbxout_stab_value_internal_label. */
512 dbxout_stab_value_internal_label_diff (const char *stem
, int *counterp
,
516 int counter
= counterp
? (*counterp
)++ : 0;
518 ASM_GENERATE_INTERNAL_LABEL (label
, stem
, counter
);
519 dbxout_stab_value_label_diff (label
, base
);
520 targetm
.asm_out
.internal_label (asm_out_file
, stem
, counter
);
523 /* The following functions produce specific kinds of stab directives. */
525 /* Write a .stabd directive with type STYPE and desc SDESC to asm_out_file. */
527 dbxout_stabd (int stype
, int sdesc
)
529 fputs (ASM_STABD_OP
, asm_out_file
);
531 fputs (",0,", asm_out_file
);
533 putc ('\n', asm_out_file
);
536 /* Write a .stabn directive with type STYPE. This function stops
537 short of emitting the value field, which is the responsibility of
538 the caller (normally it will be either a symbol or the difference
542 dbxout_begin_stabn (int stype
)
544 fputs (ASM_STABN_OP
, asm_out_file
);
546 fputs (",0,0,", asm_out_file
);
549 /* Write a .stabn directive with type N_SLINE and desc LINE. As above,
550 the value field is the responsibility of the caller. */
552 dbxout_begin_stabn_sline (int lineno
)
554 fputs (ASM_STABN_OP
, asm_out_file
);
555 dbxout_int (N_SLINE
);
556 fputs (",0,", asm_out_file
);
558 putc (',', asm_out_file
);
561 /* Begin a .stabs directive with string "", type STYPE, and desc and
562 other fields 0. The value field is the responsibility of the
563 caller. This function cannot be used for .stabx directives. */
565 dbxout_begin_empty_stabs (int stype
)
567 fputs (ASM_STABS_OP
, asm_out_file
);
568 fputs ("\"\",", asm_out_file
);
570 fputs (",0,0,", asm_out_file
);
573 /* Begin a .stabs directive with string STR, type STYPE, and desc 0.
574 The value field is the responsibility of the caller. */
576 dbxout_begin_simple_stabs (const char *str
, int stype
)
578 fputs (ASM_STABS_OP
, asm_out_file
);
579 output_quoted_string (asm_out_file
, str
);
580 putc (',', asm_out_file
);
582 fputs (",0,0,", asm_out_file
);
585 /* As above but use SDESC for the desc field. */
587 dbxout_begin_simple_stabs_desc (const char *str
, int stype
, int sdesc
)
589 fputs (ASM_STABS_OP
, asm_out_file
);
590 output_quoted_string (asm_out_file
, str
);
591 putc (',', asm_out_file
);
593 fputs (",0,", asm_out_file
);
595 putc (',', asm_out_file
);
598 /* The next set of functions are entirely concerned with production of
599 "complex" .stabs directives: that is, .stabs directives whose
600 strings have to be constructed piecemeal. dbxout_type,
601 dbxout_symbol, etc. use these routines heavily. The string is queued
602 up in an obstack, then written out by dbxout_finish_complex_stabs, which
603 is also responsible for splitting it up if it exceeds DBX_CONTIN_LENGTH.
604 (You might think it would be more efficient to go straight to stdio
605 when DBX_CONTIN_LENGTH is 0 (i.e. no length limit) but that turns
606 out not to be the case, and anyway this needs fewer #ifdefs.) */
608 /* Begin a complex .stabs directive. If we can, write the initial
609 ASM_STABS_OP to the asm_out_file. */
612 dbxout_begin_complex_stabs (void)
614 emit_pending_bincls_if_required ();
616 fputs (ASM_STABS_OP
, asm_out_file
);
617 putc ('"', asm_out_file
);
618 gcc_assert (stabstr_last_contin_point
== 0);
621 /* As above, but do not force text or emit pending bincls. This is
622 used by dbxout_symbol_location, which needs to do something else. */
624 dbxout_begin_complex_stabs_noforcetext (void)
626 fputs (ASM_STABS_OP
, asm_out_file
);
627 putc ('"', asm_out_file
);
628 gcc_assert (stabstr_last_contin_point
== 0);
631 /* Add CHR, a single character, to the string being built. */
632 #define stabstr_C(chr) obstack_1grow (&stabstr_ob, chr)
634 /* Add STR, a normal C string, to the string being built. */
635 #define stabstr_S(str) obstack_grow (&stabstr_ob, str, strlen(str))
637 /* Add the text of ID, an IDENTIFIER_NODE, to the string being built. */
638 #define stabstr_I(id) obstack_grow (&stabstr_ob, \
639 IDENTIFIER_POINTER (id), \
640 IDENTIFIER_LENGTH (id))
642 /* Add NUM, a signed decimal number, to the string being built. */
644 stabstr_D (HOST_WIDE_INT num
)
647 char *p
= buf
+ sizeof buf
;
663 NUMBER_FMT_LOOP (p
, unum
, 10);
665 obstack_grow (&stabstr_ob
, p
, (buf
+ sizeof buf
) - p
);
668 /* Add NUM, an unsigned decimal number, to the string being built. */
670 stabstr_U (unsigned HOST_WIDE_INT num
)
673 char *p
= buf
+ sizeof buf
;
679 NUMBER_FMT_LOOP (p
, num
, 10);
680 obstack_grow (&stabstr_ob
, p
, (buf
+ sizeof buf
) - p
);
683 /* Add CST, an INTEGER_CST tree, to the string being built as an
684 unsigned octal number. This routine handles values which are
685 larger than a single HOST_WIDE_INT. */
689 unsigned HOST_WIDE_INT high
= TREE_INT_CST_HIGH (cst
);
690 unsigned HOST_WIDE_INT low
= TREE_INT_CST_LOW (cst
);
693 char *p
= buf
+ sizeof buf
;
695 /* GDB wants constants with no extra leading "1" bits, so
696 we need to remove any sign-extension that might be
699 const unsigned int width
= TYPE_PRECISION (TREE_TYPE (cst
));
700 if (width
== HOST_BITS_PER_WIDE_INT
* 2)
702 else if (width
> HOST_BITS_PER_WIDE_INT
)
703 high
&= (((HOST_WIDE_INT
) 1 << (width
- HOST_BITS_PER_WIDE_INT
)) - 1);
704 else if (width
== HOST_BITS_PER_WIDE_INT
)
707 high
= 0, low
&= (((HOST_WIDE_INT
) 1 << width
) - 1);
710 /* Leading zero for base indicator. */
713 /* If the value is zero, the base indicator will serve as the value
715 if (high
== 0 && low
== 0)
718 /* If the high half is zero, we need only print the low half normally. */
720 NUMBER_FMT_LOOP (p
, low
, 8);
723 /* When high != 0, we need to print enough zeroes from low to
724 give the digits from high their proper place-values. Hence
725 NUMBER_FMT_LOOP cannot be used. */
726 const int n_digits
= HOST_BITS_PER_WIDE_INT
/ 3;
729 for (i
= 1; i
<= n_digits
; i
++)
731 unsigned int digit
= low
% 8;
736 /* Octal digits carry exactly three bits of information. The
737 width of a HOST_WIDE_INT is not normally a multiple of three.
738 Therefore, the next digit printed probably needs to carry
739 information from both low and high. */
740 if (HOST_BITS_PER_WIDE_INT
% 3 != 0)
742 const int n_leftover_bits
= HOST_BITS_PER_WIDE_INT
% 3;
743 const int n_bits_from_high
= 3 - n_leftover_bits
;
745 const unsigned HOST_WIDE_INT
746 low_mask
= (((unsigned HOST_WIDE_INT
)1) << n_leftover_bits
) - 1;
747 const unsigned HOST_WIDE_INT
748 high_mask
= (((unsigned HOST_WIDE_INT
)1) << n_bits_from_high
) - 1;
752 /* At this point, only the bottom n_leftover_bits bits of low
754 gcc_assert (!(low
& ~low_mask
));
756 digit
= (low
| ((high
& high_mask
) << n_leftover_bits
));
757 high
>>= n_bits_from_high
;
762 /* Now we can format high in the normal manner. However, if
763 the only bits of high that were set were handled by the
764 digit split between low and high, high will now be zero, and
765 we don't want to print extra digits in that case. */
767 NUMBER_FMT_LOOP (p
, high
, 8);
770 obstack_grow (&stabstr_ob
, p
, (buf
+ sizeof buf
) - p
);
773 /* Called whenever it is safe to break a stabs string into multiple
774 .stabs directives. If the current string has exceeded the limit
775 set by DBX_CONTIN_LENGTH, mark the current position in the buffer
776 as a continuation point by inserting DBX_CONTIN_CHAR (doubled if
777 it is a backslash) and a null character. */
779 stabstr_continue (void)
781 if (DBX_CONTIN_LENGTH
> 0
782 && obstack_object_size (&stabstr_ob
) - stabstr_last_contin_point
785 if (DBX_CONTIN_CHAR
== '\\')
786 obstack_1grow (&stabstr_ob
, '\\');
787 obstack_1grow (&stabstr_ob
, DBX_CONTIN_CHAR
);
788 obstack_1grow (&stabstr_ob
, '\0');
789 stabstr_last_contin_point
= obstack_object_size (&stabstr_ob
);
792 #define CONTIN stabstr_continue ()
794 /* Macro subroutine of dbxout_finish_complex_stabs, which emits
795 all of the arguments to the .stabs directive after the string.
796 Overridden by xcoffout.h. CODE is the stabs code for this symbol;
797 LINE is the source line to write into the desc field (in extended
798 mode); SYM is the symbol itself.
800 ADDR, LABEL, and NUMBER are three different ways to represent the
801 stabs value field. At most one of these should be nonzero.
803 ADDR is used most of the time; it represents the value as an
804 RTL address constant.
806 LABEL is used (currently) only for N_CATCH stabs; it represents
807 the value as a string suitable for assemble_name.
809 NUMBER is used when the value is an offset from an implicit base
810 pointer (e.g. for a stack variable), or an index (e.g. for a
811 register variable). It represents the value as a decimal integer. */
813 #ifndef DBX_FINISH_STABS
814 #define DBX_FINISH_STABS(SYM, CODE, LINE, ADDR, LABEL, NUMBER) \
816 int line_ = use_gnu_debug_info_extensions ? LINE : 0; \
819 fputs (",0,", asm_out_file); \
820 dbxout_int (line_); \
821 putc (',', asm_out_file); \
823 output_addr_const (asm_out_file, ADDR); \
825 assemble_name (asm_out_file, LABEL); \
827 dbxout_int (NUMBER); \
828 putc ('\n', asm_out_file); \
832 /* Finish the emission of a complex .stabs directive. When DBX_CONTIN_LENGTH
833 is zero, this has only to emit the close quote and the remainder of
834 the arguments. When it is nonzero, the string has been marshalled in
835 stabstr_ob, and this routine is responsible for breaking it up into
836 DBX_CONTIN_LENGTH-sized chunks.
838 SYM is the DECL of the symbol under consideration; it is used only
839 for its DECL_SOURCE_LINE. The other arguments are all passed directly
840 to DBX_FINISH_STABS; see above for details. */
843 dbxout_finish_complex_stabs (tree sym
, stab_code_type code
,
844 rtx addr
, const char *label
, int number
)
846 int line ATTRIBUTE_UNUSED
;
850 line
= sym
? DECL_SOURCE_LINE (sym
) : 0;
851 if (DBX_CONTIN_LENGTH
> 0)
856 /* Nul-terminate the growing string, then get its size and
858 obstack_1grow (&stabstr_ob
, '\0');
860 len
= obstack_object_size (&stabstr_ob
);
861 chunk
= str
= XOBFINISH (&stabstr_ob
, char *);
863 /* Within the buffer are a sequence of NUL-separated strings,
864 each of which is to be written out as a separate stab
868 chunklen
= strlen (chunk
);
869 fwrite (chunk
, 1, chunklen
, asm_out_file
);
870 fputs ("\",", asm_out_file
);
872 /* Must add an extra byte to account for the NUL separator. */
873 chunk
+= chunklen
+ 1;
876 /* Only put a line number on the last stab in the sequence. */
877 DBX_FINISH_STABS (sym
, code
, len
== 0 ? line
: 0,
878 addr
, label
, number
);
882 fputs (ASM_STABS_OP
, asm_out_file
);
883 putc ('"', asm_out_file
);
885 stabstr_last_contin_point
= 0;
889 /* No continuations - we can put the whole string out at once.
890 It is faster to augment the string with the close quote and
891 comma than to do a two-character fputs. */
892 obstack_grow (&stabstr_ob
, "\",", 2);
893 len
= obstack_object_size (&stabstr_ob
);
894 str
= XOBFINISH (&stabstr_ob
, char *);
896 fwrite (str
, 1, len
, asm_out_file
);
897 DBX_FINISH_STABS (sym
, code
, line
, addr
, label
, number
);
899 obstack_free (&stabstr_ob
, str
);
902 #if defined (DBX_DEBUGGING_INFO)
905 dbxout_function_end (tree decl ATTRIBUTE_UNUSED
)
907 char lscope_label_name
[100];
909 /* The Lscope label must be emitted even if we aren't doing anything
910 else; dbxout_block needs it. */
911 switch_to_section (function_section (current_function_decl
));
913 /* Convert Lscope into the appropriate format for local labels in case
914 the system doesn't insert underscores in front of user generated
916 ASM_GENERATE_INTERNAL_LABEL (lscope_label_name
, "Lscope", scope_labelno
);
917 targetm
.asm_out
.internal_label (asm_out_file
, "Lscope", scope_labelno
);
919 /* The N_FUN tag at the end of the function is a GNU extension,
920 which may be undesirable, and is unnecessary if we do not have
922 if (!use_gnu_debug_info_extensions
923 || NO_DBX_FUNCTION_END
924 || !targetm
.have_named_sections
)
927 /* By convention, GCC will mark the end of a function with an N_FUN
928 symbol and an empty string. */
929 if (flag_reorder_blocks_and_partition
)
931 dbxout_begin_empty_stabs (N_FUN
);
932 dbxout_stab_value_label_diff (crtl
->subsections
.hot_section_end_label
,
933 crtl
->subsections
.hot_section_label
);
934 dbxout_begin_empty_stabs (N_FUN
);
935 dbxout_stab_value_label_diff (crtl
->subsections
.cold_section_end_label
,
936 crtl
->subsections
.cold_section_label
);
940 char begin_label
[20];
941 /* Reference current function start using LFBB. */
942 ASM_GENERATE_INTERNAL_LABEL (begin_label
, "LFBB", scope_labelno
);
943 dbxout_begin_empty_stabs (N_FUN
);
944 dbxout_stab_value_label_diff (lscope_label_name
, begin_label
);
947 if (!NO_DBX_BNSYM_ENSYM
&& !flag_debug_only_used_symbols
)
948 dbxout_stabd (N_ENSYM
, 0);
950 #endif /* DBX_DEBUGGING_INFO */
952 /* Get lang description for N_SO stab. */
953 static unsigned int ATTRIBUTE_UNUSED
954 get_lang_number (void)
956 const char *language_string
= lang_hooks
.name
;
958 if (strcmp (language_string
, "GNU C") == 0)
960 else if (strcmp (language_string
, "GNU C++") == 0)
962 else if (strcmp (language_string
, "GNU F77") == 0)
964 else if (strcmp (language_string
, "GNU Fortran") == 0)
965 return N_SO_FORTRAN90
; /* CHECKME */
966 else if (strcmp (language_string
, "GNU Pascal") == 0)
968 else if (strcmp (language_string
, "GNU Objective-C") == 0)
970 else if (strcmp (language_string
, "GNU Objective-C++") == 0)
971 return N_SO_OBJCPLUS
;
980 unsigned int lang
= get_lang_number ();
982 return (lang
== N_SO_FORTRAN
) || (lang
== N_SO_FORTRAN90
);
985 /* At the beginning of compilation, start writing the symbol table.
986 Initialize `typevec' and output the standard data types of C. */
989 dbxout_init (const char *input_file_name
)
991 char ltext_label_name
[100];
992 bool used_ltext_label_name
= false;
993 tree syms
= lang_hooks
.decls
.getdecls ();
994 const char *mapped_name
;
997 typevec
= GGC_CNEWVEC (struct typeinfo
, typevec_len
);
999 /* stabstr_ob contains one string, which will be just fine with
1000 1-byte alignment. */
1001 obstack_specify_allocation (&stabstr_ob
, 0, 1, xmalloc
, free
);
1003 /* Convert Ltext into the appropriate format for local labels in case
1004 the system doesn't insert underscores in front of user generated
1006 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name
, "Ltext", 0);
1008 /* Put the current working directory in an N_SO symbol. */
1009 if (use_gnu_debug_info_extensions
&& !NO_DBX_MAIN_SOURCE_DIRECTORY
)
1011 static const char *cwd
;
1015 cwd
= get_src_pwd ();
1018 else if (!IS_DIR_SEPARATOR (cwd
[strlen (cwd
) - 1]))
1019 cwd
= concat (cwd
, "/", NULL
);
1020 cwd
= remap_debug_filename (cwd
);
1022 #ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
1023 DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asm_out_file
, cwd
);
1024 #else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
1025 dbxout_begin_simple_stabs_desc (cwd
, N_SO
, get_lang_number ());
1026 dbxout_stab_value_label (ltext_label_name
);
1027 used_ltext_label_name
= true;
1028 #endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
1031 mapped_name
= remap_debug_filename (input_file_name
);
1032 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
1033 DBX_OUTPUT_MAIN_SOURCE_FILENAME (asm_out_file
, mapped_name
);
1035 dbxout_begin_simple_stabs_desc (mapped_name
, N_SO
, get_lang_number ());
1036 dbxout_stab_value_label (ltext_label_name
);
1037 used_ltext_label_name
= true;
1040 if (used_ltext_label_name
)
1042 switch_to_section (text_section
);
1043 targetm
.asm_out
.internal_label (asm_out_file
, "Ltext", 0);
1046 /* Emit an N_OPT stab to indicate that this file was compiled by GCC.
1047 The string used is historical. */
1048 #ifndef NO_DBX_GCC_MARKER
1049 dbxout_begin_simple_stabs ("gcc2_compiled.", N_OPT
);
1050 dbxout_stab_value_zero ();
1053 base_input_file
= lastfile
= input_file_name
;
1055 next_type_number
= 1;
1057 #ifdef DBX_USE_BINCL
1058 current_file
= XNEW (struct dbx_file
);
1059 current_file
->next
= NULL
;
1060 current_file
->file_number
= 0;
1061 current_file
->next_type_number
= 1;
1062 next_file_number
= 1;
1063 current_file
->prev
= NULL
;
1064 current_file
->bincl_status
= BINCL_NOT_REQUIRED
;
1065 current_file
->pending_bincl_name
= NULL
;
1068 /* Get all permanent types that have typedef names, and output them
1069 all, except for those already output. Some language front ends
1070 put these declarations in the top-level scope; some do not;
1071 the latter are responsible for calling debug_hooks->type_decl from
1072 their record_builtin_type function. */
1073 dbxout_typedefs (syms
);
1075 if (preinit_symbols
)
1078 for (t
= nreverse (preinit_symbols
); t
; t
= TREE_CHAIN (t
))
1079 dbxout_symbol (TREE_VALUE (t
), 0);
1080 preinit_symbols
= 0;
1084 /* Output any typedef names for types described by TYPE_DECLs in SYMS. */
1087 dbxout_typedefs (tree syms
)
1089 for (; syms
!= NULL_TREE
; syms
= TREE_CHAIN (syms
))
1091 if (TREE_CODE (syms
) == TYPE_DECL
)
1093 tree type
= TREE_TYPE (syms
);
1094 if (TYPE_NAME (type
)
1095 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1096 && COMPLETE_OR_VOID_TYPE_P (type
)
1097 && ! TREE_ASM_WRITTEN (TYPE_NAME (type
)))
1098 dbxout_symbol (TYPE_NAME (type
), 0);
1103 #ifdef DBX_USE_BINCL
1104 /* Emit BINCL stab using given name. */
1106 emit_bincl_stab (const char *name
)
1108 dbxout_begin_simple_stabs (name
, N_BINCL
);
1109 dbxout_stab_value_zero ();
1112 /* If there are pending bincls then it is time to emit all of them. */
1115 emit_pending_bincls_if_required (void)
1118 emit_pending_bincls ();
1121 /* Emit all pending bincls. */
1124 emit_pending_bincls (void)
1126 struct dbx_file
*f
= current_file
;
1128 /* Find first pending bincl. */
1129 while (f
->bincl_status
== BINCL_PENDING
)
1132 /* Now emit all bincls. */
1137 if (f
->bincl_status
== BINCL_PENDING
)
1139 emit_bincl_stab (f
->pending_bincl_name
);
1141 /* Update file number and status. */
1142 f
->file_number
= next_file_number
++;
1143 f
->bincl_status
= BINCL_PROCESSED
;
1145 if (f
== current_file
)
1150 /* All pending bincls have been emitted. */
1157 emit_pending_bincls_if_required (void) {}
1160 /* Change to reading from a new source file. Generate a N_BINCL stab. */
1163 dbxout_start_source_file (unsigned int line ATTRIBUTE_UNUSED
,
1164 const char *filename ATTRIBUTE_UNUSED
)
1166 #ifdef DBX_USE_BINCL
1167 struct dbx_file
*n
= XNEW (struct dbx_file
);
1169 n
->next
= current_file
;
1170 n
->next_type_number
= 1;
1171 /* Do not assign file number now.
1172 Delay it until we actually emit BINCL. */
1175 current_file
->prev
= n
;
1176 n
->bincl_status
= BINCL_PENDING
;
1177 n
->pending_bincl_name
= remap_debug_filename (filename
);
1183 /* Revert to reading a previous source file. Generate a N_EINCL stab. */
1186 dbxout_end_source_file (unsigned int line ATTRIBUTE_UNUSED
)
1188 #ifdef DBX_USE_BINCL
1189 /* Emit EINCL stab only if BINCL is not pending. */
1190 if (current_file
->bincl_status
== BINCL_PROCESSED
)
1192 dbxout_begin_stabn (N_EINCL
);
1193 dbxout_stab_value_zero ();
1195 current_file
->bincl_status
= BINCL_NOT_REQUIRED
;
1196 current_file
= current_file
->next
;
1200 /* Handle a few odd cases that occur when trying to make PCH files work. */
1203 dbxout_handle_pch (unsigned at_end
)
1207 /* When using the PCH, this file will be included, so we need to output
1209 dbxout_start_source_file (0, lastfile
);
1211 /* The base file when using the PCH won't be the same as
1212 the base file when it's being generated. */
1217 /* ... and an EINCL. */
1218 dbxout_end_source_file (0);
1220 /* Deal with cases where 'lastfile' was never actually changed. */
1221 lastfile_is_base
= lastfile
== NULL
;
1225 #if defined (DBX_DEBUGGING_INFO)
1227 static void dbxout_block (tree
, int, tree
);
1229 /* Output debugging info to FILE to switch to sourcefile FILENAME. */
1232 dbxout_source_file (const char *filename
)
1234 if (lastfile
== 0 && lastfile_is_base
)
1236 lastfile
= base_input_file
;
1237 lastfile_is_base
= 0;
1240 if (filename
&& (lastfile
== 0 || strcmp (filename
, lastfile
)))
1242 /* Don't change section amid function. */
1243 if (current_function_decl
== NULL_TREE
)
1244 switch_to_section (text_section
);
1246 dbxout_begin_simple_stabs (remap_debug_filename (filename
), N_SOL
);
1247 dbxout_stab_value_internal_label ("Ltext", &source_label_number
);
1248 lastfile
= filename
;
1252 /* Output N_BNSYM, line number symbol entry, and local symbol at
1256 dbxout_begin_prologue (unsigned int lineno
, const char *filename
)
1258 if (use_gnu_debug_info_extensions
1259 && !NO_DBX_FUNCTION_END
1260 && !NO_DBX_BNSYM_ENSYM
1261 && !flag_debug_only_used_symbols
)
1262 dbxout_stabd (N_BNSYM
, 0);
1264 /* pre-increment the scope counter */
1267 dbxout_source_line (lineno
, filename
, 0, true);
1268 /* Output function begin block at function scope, referenced
1269 by dbxout_block, dbxout_source_line and dbxout_function_end. */
1270 emit_pending_bincls_if_required ();
1271 targetm
.asm_out
.internal_label (asm_out_file
, "LFBB", scope_labelno
);
1274 /* Output a line number symbol entry for source file FILENAME and line
1278 dbxout_source_line (unsigned int lineno
, const char *filename
,
1279 int discriminator ATTRIBUTE_UNUSED
,
1280 bool is_stmt ATTRIBUTE_UNUSED
)
1282 dbxout_source_file (filename
);
1284 #ifdef DBX_OUTPUT_SOURCE_LINE
1285 DBX_OUTPUT_SOURCE_LINE (asm_out_file
, lineno
, dbxout_source_line_counter
);
1287 if (DBX_LINES_FUNCTION_RELATIVE
)
1289 char begin_label
[20];
1290 dbxout_begin_stabn_sline (lineno
);
1291 /* Reference current function start using LFBB. */
1292 ASM_GENERATE_INTERNAL_LABEL (begin_label
, "LFBB", scope_labelno
);
1293 dbxout_stab_value_internal_label_diff ("LM", &dbxout_source_line_counter
,
1297 dbxout_stabd (N_SLINE
, lineno
);
1301 /* Describe the beginning of an internal block within a function. */
1304 dbxout_begin_block (unsigned int line ATTRIBUTE_UNUSED
, unsigned int n
)
1306 emit_pending_bincls_if_required ();
1307 targetm
.asm_out
.internal_label (asm_out_file
, "LBB", n
);
1310 /* Describe the end line-number of an internal block within a function. */
1313 dbxout_end_block (unsigned int line ATTRIBUTE_UNUSED
, unsigned int n
)
1315 emit_pending_bincls_if_required ();
1316 targetm
.asm_out
.internal_label (asm_out_file
, "LBE", n
);
1319 /* Output dbx data for a function definition.
1320 This includes a definition of the function name itself (a symbol),
1321 definitions of the parameters (locating them in the parameter list)
1322 and then output the block that makes up the function's body
1323 (including all the auto variables of the function). */
1326 dbxout_function_decl (tree decl
)
1328 emit_pending_bincls_if_required ();
1329 #ifndef DBX_FUNCTION_FIRST
1330 dbxout_begin_function (decl
);
1332 dbxout_block (DECL_INITIAL (decl
), 0, DECL_ARGUMENTS (decl
));
1333 dbxout_function_end (decl
);
1336 #endif /* DBX_DEBUGGING_INFO */
1338 /* Debug information for a global DECL. Called from toplev.c after
1339 compilation proper has finished. */
1341 dbxout_global_decl (tree decl
)
1343 if (TREE_CODE (decl
) == VAR_DECL
&& !DECL_EXTERNAL (decl
))
1345 int saved_tree_used
= TREE_USED (decl
);
1346 TREE_USED (decl
) = 1;
1347 dbxout_symbol (decl
, 0);
1348 TREE_USED (decl
) = saved_tree_used
;
1352 /* This is just a function-type adapter; dbxout_symbol does exactly
1353 what we want but returns an int. */
1355 dbxout_type_decl (tree decl
, int local
)
1357 dbxout_symbol (decl
, local
);
1360 /* At the end of compilation, finish writing the symbol table.
1361 The default is to call debug_free_queue but do nothing else. */
1364 dbxout_finish (const char *filename ATTRIBUTE_UNUSED
)
1366 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
1367 DBX_OUTPUT_MAIN_SOURCE_FILE_END (asm_out_file
, filename
);
1368 #elif defined DBX_OUTPUT_NULL_N_SO_AT_MAIN_SOURCE_FILE_END
1370 switch_to_section (text_section
);
1371 dbxout_begin_empty_stabs (N_SO
);
1372 dbxout_stab_value_internal_label ("Letext", 0);
1375 debug_free_queue ();
1378 /* Output the index of a type. */
1381 dbxout_type_index (tree type
)
1383 #ifndef DBX_USE_BINCL
1384 stabstr_D (TYPE_SYMTAB_ADDRESS (type
));
1386 struct typeinfo
*t
= &typevec
[TYPE_SYMTAB_ADDRESS (type
)];
1388 stabstr_D (t
->file_number
);
1390 stabstr_D (t
->type_number
);
1397 /* Used in several places: evaluates to '0' for a private decl,
1398 '1' for a protected decl, '2' for a public decl. */
1399 #define DECL_ACCESSIBILITY_CHAR(DECL) \
1400 (TREE_PRIVATE (DECL) ? '0' : TREE_PROTECTED (DECL) ? '1' : '2')
1402 /* Subroutine of `dbxout_type'. Output the type fields of TYPE.
1403 This must be a separate function because anonymous unions require
1407 dbxout_type_fields (tree type
)
1411 /* Output the name, type, position (in bits), size (in bits) of each
1412 field that we can support. */
1413 for (tem
= TYPE_FIELDS (type
); tem
; tem
= TREE_CHAIN (tem
))
1415 /* If one of the nodes is an error_mark or its type is then
1417 if (tem
== error_mark_node
|| TREE_TYPE (tem
) == error_mark_node
)
1420 /* Omit here local type decls until we know how to support them. */
1421 if (TREE_CODE (tem
) == TYPE_DECL
1422 /* Omit here the nameless fields that are used to skip bits. */
1423 || DECL_IGNORED_P (tem
)
1424 /* Omit fields whose position or size are variable or too large to
1426 || (TREE_CODE (tem
) == FIELD_DECL
1427 && (! host_integerp (bit_position (tem
), 0)
1428 || ! DECL_SIZE (tem
)
1429 || ! host_integerp (DECL_SIZE (tem
), 1))))
1432 else if (TREE_CODE (tem
) != CONST_DECL
)
1434 /* Continue the line if necessary,
1435 but not before the first field. */
1436 if (tem
!= TYPE_FIELDS (type
))
1439 if (DECL_NAME (tem
))
1440 stabstr_I (DECL_NAME (tem
));
1443 if (use_gnu_debug_info_extensions
1444 && (TREE_PRIVATE (tem
) || TREE_PROTECTED (tem
)
1445 || TREE_CODE (tem
) != FIELD_DECL
))
1448 stabstr_C (DECL_ACCESSIBILITY_CHAR (tem
));
1451 dbxout_type ((TREE_CODE (tem
) == FIELD_DECL
1452 && DECL_BIT_FIELD_TYPE (tem
))
1453 ? DECL_BIT_FIELD_TYPE (tem
) : TREE_TYPE (tem
), 0);
1455 if (TREE_CODE (tem
) == VAR_DECL
)
1457 if (TREE_STATIC (tem
) && use_gnu_debug_info_extensions
)
1459 tree name
= DECL_ASSEMBLER_NAME (tem
);
1466 /* If TEM is non-static, GDB won't understand it. */
1467 stabstr_S (",0,0;");
1472 stabstr_D (int_bit_position (tem
));
1474 stabstr_D (tree_low_cst (DECL_SIZE (tem
), 1));
1481 /* Subroutine of `dbxout_type_methods'. Output debug info about the
1482 method described DECL. */
1485 dbxout_type_method_1 (tree decl
)
1489 if (TREE_CODE (TREE_TYPE (decl
)) == FUNCTION_TYPE
)
1491 else /* it's a METHOD_TYPE. */
1493 tree firstarg
= TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)));
1494 /* A for normal functions.
1495 B for `const' member functions.
1496 C for `volatile' member functions.
1497 D for `const volatile' member functions. */
1498 if (TYPE_READONLY (TREE_TYPE (firstarg
)))
1500 if (TYPE_VOLATILE (TREE_TYPE (firstarg
)))
1503 if (DECL_VINDEX (decl
))
1509 /* ??? Output the mangled name, which contains an encoding of the
1510 method's type signature. May not be necessary anymore. */
1512 stabstr_I (DECL_ASSEMBLER_NAME (decl
));
1514 stabstr_C (DECL_ACCESSIBILITY_CHAR (decl
));
1518 if (DECL_VINDEX (decl
) && host_integerp (DECL_VINDEX (decl
), 0))
1520 stabstr_D (tree_low_cst (DECL_VINDEX (decl
), 0));
1522 dbxout_type (DECL_CONTEXT (decl
), 0);
1527 /* Subroutine of `dbxout_type'. Output debug info about the methods defined
1531 dbxout_type_methods (tree type
)
1533 /* C++: put out the method names and their parameter lists */
1534 tree methods
= TYPE_METHODS (type
);
1538 if (methods
== NULL_TREE
)
1541 if (TREE_CODE (methods
) != TREE_VEC
)
1543 else if (TREE_VEC_ELT (methods
, 0) != NULL_TREE
)
1544 fndecl
= TREE_VEC_ELT (methods
, 0);
1546 fndecl
= TREE_VEC_ELT (methods
, 1);
1550 int need_prefix
= 1;
1552 /* Group together all the methods for the same operation.
1553 These differ in the types of the arguments. */
1554 for (last
= NULL_TREE
;
1555 fndecl
&& (last
== NULL_TREE
|| DECL_NAME (fndecl
) == DECL_NAME (last
));
1556 fndecl
= TREE_CHAIN (fndecl
))
1557 /* Output the name of the field (after overloading), as
1558 well as the name of the field before overloading, along
1559 with its parameter list */
1561 /* Skip methods that aren't FUNCTION_DECLs. (In C++, these
1562 include TEMPLATE_DECLs.) The debugger doesn't know what
1563 to do with such entities anyhow. */
1564 if (TREE_CODE (fndecl
) != FUNCTION_DECL
)
1571 /* Also ignore abstract methods; those are only interesting to
1572 the DWARF backends. */
1573 if (DECL_IGNORED_P (fndecl
) || DECL_ABSTRACT (fndecl
))
1576 /* Redundantly output the plain name, since that's what gdb
1580 stabstr_I (DECL_NAME (fndecl
));
1585 dbxout_type (TREE_TYPE (fndecl
), 0);
1586 dbxout_type_method_1 (fndecl
);
1593 /* Emit a "range" type specification, which has the form:
1594 "r<index type>;<lower bound>;<upper bound>;".
1595 TYPE is an INTEGER_TYPE, LOW and HIGH are the bounds. */
1598 dbxout_range_type (tree type
, tree low
, tree high
)
1601 if (TREE_TYPE (type
))
1602 dbxout_type (TREE_TYPE (type
), 0);
1603 else if (TREE_CODE (type
) != INTEGER_TYPE
)
1604 dbxout_type (type
, 0); /* E.g. Pascal's ARRAY [BOOLEAN] of INTEGER */
1607 /* Traditionally, we made sure 'int' was type 1, and builtin types
1608 were defined to be sub-ranges of int. Unfortunately, this
1609 does not allow us to distinguish true sub-ranges from integer
1610 types. So, instead we define integer (non-sub-range) types as
1611 sub-ranges of themselves. This matters for Chill. If this isn't
1612 a subrange type, then we want to define it in terms of itself.
1613 However, in C, this may be an anonymous integer type, and we don't
1614 want to emit debug info referring to it. Just calling
1615 dbxout_type_index won't work anyways, because the type hasn't been
1616 defined yet. We make this work for both cases by checked to see
1617 whether this is a defined type, referring to it if it is, and using
1619 if (TYPE_SYMTAB_ADDRESS (type
) != 0)
1620 dbxout_type_index (type
);
1622 dbxout_type_index (integer_type_node
);
1626 if (low
&& host_integerp (low
, 0))
1628 if (print_int_cst_bounds_in_octal_p (type
, low
, high
))
1631 stabstr_D (tree_low_cst (low
, 0));
1637 if (high
&& host_integerp (high
, 0))
1639 if (print_int_cst_bounds_in_octal_p (type
, low
, high
))
1642 stabstr_D (tree_low_cst (high
, 0));
1650 /* Output a reference to a type. If the type has not yet been
1651 described in the dbx output, output its definition now.
1652 For a type already defined, just refer to its definition
1653 using the type number.
1655 If FULL is nonzero, and the type has been described only with
1656 a forward-reference, output the definition now.
1657 If FULL is zero in this case, just refer to the forward-reference
1658 using the number previously allocated. */
1661 dbxout_type (tree type
, int full
)
1663 static int anonymous_type_number
= 0;
1664 bool vector_type
= false;
1665 tree tem
, main_variant
, low
, high
;
1667 if (TREE_CODE (type
) == VECTOR_TYPE
)
1669 /* The frontend feeds us a representation for the vector as a struct
1670 containing an array. Pull out the array type. */
1671 type
= TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type
)));
1675 if (TREE_CODE (type
) == INTEGER_TYPE
)
1677 if (TREE_TYPE (type
) == 0)
1679 low
= TYPE_MIN_VALUE (type
);
1680 high
= TYPE_MAX_VALUE (type
);
1683 else if (subrange_type_for_debug_p (type
, &low
, &high
))
1686 /* If this is a subtype that should not be emitted as a subrange type,
1687 use the base type. */
1690 type
= TREE_TYPE (type
);
1691 low
= TYPE_MIN_VALUE (type
);
1692 high
= TYPE_MAX_VALUE (type
);
1696 /* If there was an input error and we don't really have a type,
1697 avoid crashing and write something that is at least valid
1698 by assuming `int'. */
1699 if (type
== error_mark_node
)
1700 type
= integer_type_node
;
1703 if (TYPE_NAME (type
)
1704 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1705 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type
)))
1709 /* Try to find the "main variant" with the same name. */
1710 if (TYPE_NAME (type
) && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1711 && DECL_ORIGINAL_TYPE (TYPE_NAME (type
)))
1712 main_variant
= TREE_TYPE (TYPE_NAME (type
));
1714 main_variant
= TYPE_MAIN_VARIANT (type
);
1716 /* If we are not using extensions, stabs does not distinguish const and
1717 volatile, so there is no need to make them separate types. */
1718 if (!use_gnu_debug_info_extensions
)
1719 type
= main_variant
;
1721 if (TYPE_SYMTAB_ADDRESS (type
) == 0)
1723 /* Type has no dbx number assigned. Assign next available number. */
1724 TYPE_SYMTAB_ADDRESS (type
) = next_type_number
++;
1726 /* Make sure type vector is long enough to record about this type. */
1728 if (next_type_number
== typevec_len
)
1730 typevec
= GGC_RESIZEVEC (struct typeinfo
, typevec
, typevec_len
* 2);
1731 memset (typevec
+ typevec_len
, 0, typevec_len
* sizeof typevec
[0]);
1735 #ifdef DBX_USE_BINCL
1736 emit_pending_bincls_if_required ();
1737 typevec
[TYPE_SYMTAB_ADDRESS (type
)].file_number
1738 = current_file
->file_number
;
1739 typevec
[TYPE_SYMTAB_ADDRESS (type
)].type_number
1740 = current_file
->next_type_number
++;
1744 if (flag_debug_only_used_symbols
)
1746 if ((TREE_CODE (type
) == RECORD_TYPE
1747 || TREE_CODE (type
) == UNION_TYPE
1748 || TREE_CODE (type
) == QUAL_UNION_TYPE
1749 || TREE_CODE (type
) == ENUMERAL_TYPE
)
1750 && TYPE_STUB_DECL (type
)
1751 && DECL_P (TYPE_STUB_DECL (type
))
1752 && ! DECL_IGNORED_P (TYPE_STUB_DECL (type
)))
1753 debug_queue_symbol (TYPE_STUB_DECL (type
));
1754 else if (TYPE_NAME (type
)
1755 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
1756 debug_queue_symbol (TYPE_NAME (type
));
1759 /* Output the number of this type, to refer to it. */
1760 dbxout_type_index (type
);
1762 #ifdef DBX_TYPE_DEFINED
1763 if (DBX_TYPE_DEFINED (type
))
1767 /* If this type's definition has been output or is now being output,
1770 switch (typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
)
1775 /* If we have already had a cross reference,
1776 and either that's all we want or that's the best we could do,
1777 don't repeat the cross reference.
1778 Sun dbx crashes if we do. */
1779 if (! full
|| !COMPLETE_TYPE_P (type
)
1780 /* No way in DBX fmt to describe a variable size. */
1781 || ! host_integerp (TYPE_SIZE (type
), 1))
1789 /* For systems where dbx output does not allow the `=xsNAME:' syntax,
1790 leave the type-number completely undefined rather than output
1791 a cross-reference. If we have already used GNU debug info extensions,
1792 then it is OK to output a cross reference. This is necessary to get
1793 proper C++ debug output. */
1794 if ((TREE_CODE (type
) == RECORD_TYPE
|| TREE_CODE (type
) == UNION_TYPE
1795 || TREE_CODE (type
) == QUAL_UNION_TYPE
1796 || TREE_CODE (type
) == ENUMERAL_TYPE
)
1797 && ! use_gnu_debug_info_extensions
)
1798 /* We must use the same test here as we use twice below when deciding
1799 whether to emit a cross-reference. */
1800 if ((TYPE_NAME (type
) != 0
1801 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1802 && DECL_IGNORED_P (TYPE_NAME (type
)))
1804 || !COMPLETE_TYPE_P (type
)
1805 /* No way in DBX fmt to describe a variable size. */
1806 || ! host_integerp (TYPE_SIZE (type
), 1))
1808 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1813 /* Output a definition now. */
1816 /* Mark it as defined, so that if it is self-referent
1817 we will not get into an infinite recursion of definitions. */
1819 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_DEFINED
;
1821 /* If this type is a variant of some other, hand off. Types with
1822 different names are usefully distinguished. We only distinguish
1823 cv-qualified types if we're using extensions. */
1824 if (TYPE_READONLY (type
) > TYPE_READONLY (main_variant
))
1827 dbxout_type (build_type_variant (type
, 0, TYPE_VOLATILE (type
)), 0);
1830 else if (TYPE_VOLATILE (type
) > TYPE_VOLATILE (main_variant
))
1833 dbxout_type (build_type_variant (type
, TYPE_READONLY (type
), 0), 0);
1836 else if (main_variant
!= TYPE_MAIN_VARIANT (type
))
1838 if (flag_debug_only_used_symbols
)
1840 tree orig_type
= DECL_ORIGINAL_TYPE (TYPE_NAME (type
));
1842 if ((TREE_CODE (orig_type
) == RECORD_TYPE
1843 || TREE_CODE (orig_type
) == UNION_TYPE
1844 || TREE_CODE (orig_type
) == QUAL_UNION_TYPE
1845 || TREE_CODE (orig_type
) == ENUMERAL_TYPE
)
1846 && TYPE_STUB_DECL (orig_type
)
1847 && ! DECL_IGNORED_P (TYPE_STUB_DECL (orig_type
)))
1848 debug_queue_symbol (TYPE_STUB_DECL (orig_type
));
1850 /* 'type' is a typedef; output the type it refers to. */
1851 dbxout_type (DECL_ORIGINAL_TYPE (TYPE_NAME (type
)), 0);
1854 /* else continue. */
1856 switch (TREE_CODE (type
))
1860 /* For a void type, just define it as itself; i.e., "5=5".
1861 This makes us consider it defined
1862 without saying what it is. The debugger will make it
1863 a void type when the reference is seen, and nothing will
1864 ever override that default. */
1865 dbxout_type_index (type
);
1869 if (type
== char_type_node
&& ! TYPE_UNSIGNED (type
))
1871 /* Output the type `char' as a subrange of itself!
1872 I don't understand this definition, just copied it
1873 from the output of pcc.
1874 This used to use `r2' explicitly and we used to
1875 take care to make sure that `char' was type number 2. */
1877 dbxout_type_index (type
);
1878 stabstr_S (";0;127;");
1881 /* If this is a subtype of another integer type, always prefer to
1882 write it as a subtype. */
1883 else if (TREE_TYPE (type
) != 0
1884 && TREE_CODE (TREE_TYPE (type
)) == INTEGER_TYPE
)
1886 /* If the size is non-standard, say what it is if we can use
1889 if (use_gnu_debug_info_extensions
1890 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
1893 stabstr_D (TYPE_PRECISION (type
));
1897 dbxout_range_type (type
, low
, high
);
1902 /* If the size is non-standard, say what it is if we can use
1905 if (use_gnu_debug_info_extensions
1906 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
1909 stabstr_D (TYPE_PRECISION (type
));
1913 if (print_int_cst_bounds_in_octal_p (type
, low
, high
))
1917 /* If this type derives from another type, output type index of
1918 parent type. This is particularly important when parent type
1919 is an enumerated type, because not generating the parent type
1920 index would transform the definition of this enumerated type
1921 into a plain unsigned type. */
1922 if (TREE_TYPE (type
) != 0)
1923 dbxout_type_index (TREE_TYPE (type
));
1925 dbxout_type_index (type
);
1935 /* Output other integer types as subranges of `int'. */
1936 dbxout_range_type (type
, low
, high
);
1942 case FIXED_POINT_TYPE
:
1943 /* This used to say `r1' and we used to take care
1944 to make sure that `int' was type number 1. */
1946 dbxout_type_index (integer_type_node
);
1948 stabstr_D (int_size_in_bytes (type
));
1953 if (use_gnu_debug_info_extensions
)
1956 stabstr_D (BITS_PER_UNIT
* int_size_in_bytes (type
));
1957 stabstr_S (";-16;");
1959 else /* Define as enumeral type (False, True) */
1960 stabstr_S ("eFalse:0,True:1,;");
1964 /* Differs from the REAL_TYPE by its new data type number.
1965 R3 is NF_COMPLEX. We don't try to use any of the other NF_*
1966 codes since gdb doesn't care anyway. */
1968 if (TREE_CODE (TREE_TYPE (type
)) == REAL_TYPE
)
1971 stabstr_D (2 * int_size_in_bytes (TREE_TYPE (type
)));
1976 /* Output a complex integer type as a structure,
1977 pending some other way to do it. */
1979 stabstr_D (int_size_in_bytes (type
));
1981 stabstr_S ("real:");
1982 dbxout_type (TREE_TYPE (type
), 0);
1984 stabstr_D (TYPE_PRECISION (TREE_TYPE (type
)));
1986 stabstr_S (";imag:");
1987 dbxout_type (TREE_TYPE (type
), 0);
1989 stabstr_D (TYPE_PRECISION (TREE_TYPE (type
)));
1991 stabstr_D (TYPE_PRECISION (TREE_TYPE (type
)));
1997 /* Make arrays of packed bits look like bitstrings for chill. */
1998 if (TYPE_PACKED (type
) && use_gnu_debug_info_extensions
)
2001 stabstr_D (BITS_PER_UNIT
* int_size_in_bytes (type
));
2002 stabstr_S (";@S;S");
2003 dbxout_type (TYPE_DOMAIN (type
), 0);
2007 if (use_gnu_debug_info_extensions
&& vector_type
)
2010 /* Output "a" followed by a range type definition
2011 for the index type of the array
2012 followed by a reference to the target-type.
2013 ar1;0;N;M for a C array of type M and size N+1. */
2014 /* Check if a character string type, which in Chill is
2015 different from an array of characters. */
2016 if (TYPE_STRING_FLAG (type
) && use_gnu_debug_info_extensions
)
2020 tem
= TYPE_DOMAIN (type
);
2024 dbxout_type_index (integer_type_node
);
2025 stabstr_S (";0;-1;");
2030 dbxout_range_type (tem
, TYPE_MIN_VALUE (tem
), TYPE_MAX_VALUE (tem
));
2033 dbxout_type (TREE_TYPE (type
), 0);
2038 case QUAL_UNION_TYPE
:
2040 tree binfo
= TYPE_BINFO (type
);
2042 /* Output a structure type. We must use the same test here as we
2043 use in the DBX_NO_XREFS case above. */
2044 if ((TYPE_NAME (type
) != 0
2045 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
2046 && DECL_IGNORED_P (TYPE_NAME (type
)))
2048 || !COMPLETE_TYPE_P (type
)
2049 /* No way in DBX fmt to describe a variable size. */
2050 || ! host_integerp (TYPE_SIZE (type
), 1))
2052 /* If the type is just a cross reference, output one
2053 and mark the type as partially described.
2054 If it later becomes defined, we will output
2055 its real definition.
2056 If the type has a name, don't nest its definition within
2057 another type's definition; instead, output an xref
2058 and let the definition come when the name is defined. */
2059 stabstr_S ((TREE_CODE (type
) == RECORD_TYPE
) ? "xs" : "xu");
2060 if (TYPE_NAME (type
) != 0
2061 /* The C frontend creates for anonymous variable length
2062 records/unions TYPE_NAME with DECL_NAME NULL. */
2063 && (TREE_CODE (TYPE_NAME (type
)) != TYPE_DECL
2064 || DECL_NAME (TYPE_NAME (type
))))
2065 dbxout_type_name (type
);
2069 stabstr_D (anonymous_type_number
++);
2073 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
2077 /* Identify record or union, and print its size. */
2078 stabstr_C ((TREE_CODE (type
) == RECORD_TYPE
) ? 's' : 'u');
2079 stabstr_D (int_size_in_bytes (type
));
2085 VEC(tree
,gc
) *accesses
= BINFO_BASE_ACCESSES (binfo
);
2087 if (use_gnu_debug_info_extensions
)
2089 if (BINFO_N_BASE_BINFOS (binfo
))
2092 stabstr_U (BINFO_N_BASE_BINFOS (binfo
));
2096 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, child
); i
++)
2098 tree access
= (accesses
? VEC_index (tree
, accesses
, i
)
2099 : access_public_node
);
2101 if (use_gnu_debug_info_extensions
)
2103 stabstr_C (BINFO_VIRTUAL_P (child
) ? '1' : '0');
2104 stabstr_C (access
== access_public_node
? '2' :
2105 access
== access_protected_node
2107 if (BINFO_VIRTUAL_P (child
)
2108 && (strcmp (lang_hooks
.name
, "GNU C++") == 0
2109 || strcmp (lang_hooks
.name
, "GNU Objective-C++") == 0))
2110 /* For a virtual base, print the (negative)
2111 offset within the vtable where we must look
2112 to find the necessary adjustment. */
2114 (tree_low_cst (BINFO_VPTR_FIELD (child
), 0)
2117 stabstr_D (tree_low_cst (BINFO_OFFSET (child
), 0)
2120 dbxout_type (BINFO_TYPE (child
), 0);
2125 /* Print out the base class information with
2126 fields which have the same names at the types
2128 dbxout_type_name (BINFO_TYPE (child
));
2130 dbxout_type (BINFO_TYPE (child
), full
);
2132 stabstr_D (tree_low_cst (BINFO_OFFSET (child
), 0)
2136 (tree_low_cst (TYPE_SIZE (BINFO_TYPE (child
)), 0)
2144 /* Write out the field declarations. */
2145 dbxout_type_fields (type
);
2146 if (use_gnu_debug_info_extensions
&& TYPE_METHODS (type
) != NULL_TREE
)
2148 dbxout_type_methods (type
);
2153 if (use_gnu_debug_info_extensions
&& TREE_CODE (type
) == RECORD_TYPE
2154 /* Avoid the ~ if we don't really need it--it confuses dbx. */
2155 && TYPE_VFIELD (type
))
2158 /* We need to write out info about what field this class
2159 uses as its "main" vtable pointer field, because if this
2160 field is inherited from a base class, GDB cannot necessarily
2161 figure out which field it's using in time. */
2163 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type
)), 0);
2169 /* We must use the same test here as we use in the DBX_NO_XREFS case
2170 above. We simplify it a bit since an enum will never have a variable
2172 if ((TYPE_NAME (type
) != 0
2173 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
2174 && DECL_IGNORED_P (TYPE_NAME (type
)))
2176 || !COMPLETE_TYPE_P (type
))
2179 dbxout_type_name (type
);
2180 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
2184 if (use_gnu_debug_info_extensions
2185 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
2188 stabstr_D (TYPE_PRECISION (type
));
2193 for (tem
= TYPE_VALUES (type
); tem
; tem
= TREE_CHAIN (tem
))
2195 tree value
= TREE_VALUE (tem
);
2197 stabstr_I (TREE_PURPOSE (tem
));
2200 if (TREE_CODE (value
) == CONST_DECL
)
2201 value
= DECL_INITIAL (value
);
2203 if (TREE_INT_CST_HIGH (value
) == 0)
2204 stabstr_D (TREE_INT_CST_LOW (value
));
2205 else if (TREE_INT_CST_HIGH (value
) == -1
2206 && (HOST_WIDE_INT
) TREE_INT_CST_LOW (value
) < 0)
2207 stabstr_D (TREE_INT_CST_LOW (value
));
2212 if (TREE_CHAIN (tem
) != 0)
2221 dbxout_type (TREE_TYPE (type
), 0);
2225 if (use_gnu_debug_info_extensions
)
2229 /* Write the argument types out longhand. */
2230 dbxout_type (TYPE_METHOD_BASETYPE (type
), 0);
2232 dbxout_type (TREE_TYPE (type
), 0);
2233 dbxout_args (TYPE_ARG_TYPES (type
));
2237 /* Treat it as a function type. */
2238 dbxout_type (TREE_TYPE (type
), 0);
2242 if (use_gnu_debug_info_extensions
)
2245 dbxout_type (TYPE_OFFSET_BASETYPE (type
), 0);
2247 dbxout_type (TREE_TYPE (type
), 0);
2250 /* Should print as an int, because it is really just an offset. */
2251 dbxout_type (integer_type_node
, 0);
2254 case REFERENCE_TYPE
:
2255 if (use_gnu_debug_info_extensions
)
2261 dbxout_type (TREE_TYPE (type
), 0);
2266 dbxout_type (TREE_TYPE (type
), 0);
2274 /* Return nonzero if the given type represents an integer whose bounds
2275 should be printed in octal format. */
2278 print_int_cst_bounds_in_octal_p (tree type
, tree low
, tree high
)
2280 /* If we can use GDB extensions and the size is wider than a long
2281 (the size used by GDB to read them) or we may have trouble writing
2282 the bounds the usual way, write them in octal. Note the test is for
2283 the *target's* size of "long", not that of the host. The host test
2284 is just to make sure we can write it out in case the host wide int
2285 is narrower than the target "long".
2287 For unsigned types, we use octal if they are the same size or larger.
2288 This is because we print the bounds as signed decimal, and hence they
2289 can't span same size unsigned types. */
2291 if (use_gnu_debug_info_extensions
2292 && low
&& TREE_CODE (low
) == INTEGER_CST
2293 && high
&& TREE_CODE (high
) == INTEGER_CST
2294 && (TYPE_PRECISION (type
) > TYPE_PRECISION (integer_type_node
)
2295 || ((TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
))
2296 && TYPE_UNSIGNED (type
))
2297 || TYPE_PRECISION (type
) > HOST_BITS_PER_WIDE_INT
2298 || (TYPE_PRECISION (type
) == HOST_BITS_PER_WIDE_INT
2299 && TYPE_UNSIGNED (type
))))
2305 /* Output the name of type TYPE, with no punctuation.
2306 Such names can be set up either by typedef declarations
2307 or by struct, enum and union tags. */
2310 dbxout_type_name (tree type
)
2312 tree t
= TYPE_NAME (type
);
2315 switch (TREE_CODE (t
))
2317 case IDENTIFIER_NODE
:
2329 /* Output leading leading struct or class names needed for qualifying
2330 type whose scope is limited to a struct or class. */
2333 dbxout_class_name_qualifiers (tree decl
)
2335 tree context
= decl_type_context (decl
);
2337 if (context
!= NULL_TREE
2338 && TREE_CODE(context
) == RECORD_TYPE
2339 && TYPE_NAME (context
) != 0
2340 && (TREE_CODE (TYPE_NAME (context
)) == IDENTIFIER_NODE
2341 || (DECL_NAME (TYPE_NAME (context
)) != 0)))
2343 tree name
= TYPE_NAME (context
);
2345 if (TREE_CODE (name
) == TYPE_DECL
)
2347 dbxout_class_name_qualifiers (name
);
2348 name
= DECL_NAME (name
);
2355 /* This is a specialized subset of expand_expr for use by dbxout_symbol in
2356 evaluating DECL_VALUE_EXPR. In particular, we stop if we find decls that
2357 haven't been expanded, or if the expression is getting so complex we won't
2358 be able to represent it in stabs anyway. Returns NULL on failure. */
2361 dbxout_expand_expr (tree expr
)
2363 switch (TREE_CODE (expr
))
2366 /* We can't handle emulated tls variables, because the address is an
2367 offset to the return value of __emutls_get_address, and there is no
2368 way to express that in stabs. Also, there are name mangling issues
2369 here. We end up with references to undefined symbols if we don't
2370 disable debug info for these variables. */
2371 if (!targetm
.have_tls
&& DECL_THREAD_LOCAL_P (expr
))
2376 if (DECL_HAS_VALUE_EXPR_P (expr
))
2377 return dbxout_expand_expr (DECL_VALUE_EXPR (expr
));
2382 return DECL_RTL_IF_SET (expr
);
2385 return expand_expr (expr
, NULL_RTX
, VOIDmode
, EXPAND_INITIALIZER
);
2389 case ARRAY_RANGE_REF
:
2392 enum machine_mode mode
;
2393 HOST_WIDE_INT bitsize
, bitpos
;
2395 int volatilep
= 0, unsignedp
= 0;
2398 tem
= get_inner_reference (expr
, &bitsize
, &bitpos
, &offset
,
2399 &mode
, &unsignedp
, &volatilep
, true);
2401 x
= dbxout_expand_expr (tem
);
2402 if (x
== NULL
|| !MEM_P (x
))
2406 if (!host_integerp (offset
, 0))
2408 x
= adjust_address_nv (x
, mode
, tree_low_cst (offset
, 0));
2411 x
= adjust_address_nv (x
, mode
, bitpos
/ BITS_PER_UNIT
);
2421 /* Helper function for output_used_types. Queue one entry from the
2422 used types hash to be output. */
2425 output_used_types_helper (void **slot
, void *data
)
2427 tree type
= (tree
) *slot
;
2428 VEC(tree
, heap
) **types_p
= (VEC(tree
, heap
) **) data
;
2430 if ((TREE_CODE (type
) == RECORD_TYPE
2431 || TREE_CODE (type
) == UNION_TYPE
2432 || TREE_CODE (type
) == QUAL_UNION_TYPE
2433 || TREE_CODE (type
) == ENUMERAL_TYPE
)
2434 && TYPE_STUB_DECL (type
)
2435 && DECL_P (TYPE_STUB_DECL (type
))
2436 && ! DECL_IGNORED_P (TYPE_STUB_DECL (type
)))
2437 VEC_quick_push (tree
, *types_p
, TYPE_STUB_DECL (type
));
2438 else if (TYPE_NAME (type
)
2439 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
2440 VEC_quick_push (tree
, *types_p
, TYPE_NAME (type
));
2445 /* This is a qsort callback which sorts types and declarations into a
2446 predictable order (types, then declarations, sorted by UID
2450 output_types_sort (const void *pa
, const void *pb
)
2452 const tree lhs
= *((const tree
*)pa
);
2453 const tree rhs
= *((const tree
*)pb
);
2458 return TYPE_UID (lhs
) - TYPE_UID (rhs
);
2467 return DECL_UID (lhs
) - DECL_UID (rhs
);
2472 /* Force all types used by this function to be output in debug
2476 output_used_types (void)
2478 if (cfun
&& cfun
->used_types_hash
)
2480 VEC(tree
, heap
) *types
;
2484 types
= VEC_alloc (tree
, heap
, htab_elements (cfun
->used_types_hash
));
2485 htab_traverse (cfun
->used_types_hash
, output_used_types_helper
, &types
);
2487 /* Sort by UID to prevent dependence on hash table ordering. */
2488 qsort (VEC_address (tree
, types
), VEC_length (tree
, types
),
2489 sizeof (tree
), output_types_sort
);
2491 for (i
= 0; VEC_iterate (tree
, types
, i
, type
); i
++)
2492 debug_queue_symbol (type
);
2494 VEC_free (tree
, heap
, types
);
2498 /* Output a .stabs for the symbol defined by DECL,
2499 which must be a ..._DECL node in the normal namespace.
2500 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
2501 LOCAL is nonzero if the scope is less than the entire file.
2502 Return 1 if a stabs might have been emitted. */
2505 dbxout_symbol (tree decl
, int local ATTRIBUTE_UNUSED
)
2507 tree type
= TREE_TYPE (decl
);
2508 tree context
= NULL_TREE
;
2512 /* "Intercept" dbxout_symbol() calls like we do all debug_hooks. */
2515 /* Ignore nameless syms, but don't ignore type tags. */
2517 if ((DECL_NAME (decl
) == 0 && TREE_CODE (decl
) != TYPE_DECL
)
2518 || DECL_IGNORED_P (decl
))
2519 DBXOUT_DECR_NESTING_AND_RETURN (0);
2521 /* If we are to generate only the symbols actually used then such
2522 symbol nodes are flagged with TREE_USED. Ignore any that
2523 aren't flagged as TREE_USED. */
2525 if (flag_debug_only_used_symbols
2526 && (!TREE_USED (decl
)
2527 && (TREE_CODE (decl
) != VAR_DECL
|| !DECL_INITIAL (decl
))))
2528 DBXOUT_DECR_NESTING_AND_RETURN (0);
2530 /* If dbxout_init has not yet run, queue this symbol for later. */
2533 preinit_symbols
= tree_cons (0, decl
, preinit_symbols
);
2534 DBXOUT_DECR_NESTING_AND_RETURN (0);
2537 if (flag_debug_only_used_symbols
)
2541 /* We now have a used symbol. We need to generate the info for
2542 the symbol's type in addition to the symbol itself. These
2543 type symbols are queued to be generated after were done with
2544 the symbol itself (otherwise they would fight over the
2547 Note, because the TREE_TYPE(type) might be something like a
2548 pointer to a named type we need to look for the first name
2549 we see following the TREE_TYPE chain. */
2552 while (POINTER_TYPE_P (t
))
2555 /* RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, and ENUMERAL_TYPE
2556 need special treatment. The TYPE_STUB_DECL field in these
2557 types generally represents the tag name type we want to
2558 output. In addition there could be a typedef type with
2559 a different name. In that case we also want to output
2562 if (TREE_CODE (t
) == RECORD_TYPE
2563 || TREE_CODE (t
) == UNION_TYPE
2564 || TREE_CODE (t
) == QUAL_UNION_TYPE
2565 || TREE_CODE (t
) == ENUMERAL_TYPE
)
2567 if (TYPE_STUB_DECL (t
)
2568 && TYPE_STUB_DECL (t
) != decl
2569 && DECL_P (TYPE_STUB_DECL (t
))
2570 && ! DECL_IGNORED_P (TYPE_STUB_DECL (t
)))
2572 debug_queue_symbol (TYPE_STUB_DECL (t
));
2574 && TYPE_NAME (t
) != TYPE_STUB_DECL (t
)
2575 && TYPE_NAME (t
) != decl
2576 && DECL_P (TYPE_NAME (t
)))
2577 debug_queue_symbol (TYPE_NAME (t
));
2580 else if (TYPE_NAME (t
)
2581 && TYPE_NAME (t
) != decl
2582 && DECL_P (TYPE_NAME (t
)))
2583 debug_queue_symbol (TYPE_NAME (t
));
2586 emit_pending_bincls_if_required ();
2588 switch (TREE_CODE (decl
))
2591 /* Enum values are defined by defining the enum type. */
2595 decl_rtl
= DECL_RTL_IF_SET (decl
);
2597 DBXOUT_DECR_NESTING_AND_RETURN (0);
2598 if (DECL_EXTERNAL (decl
))
2600 /* Don't mention a nested function under its parent. */
2601 context
= decl_function_context (decl
);
2602 if (context
== current_function_decl
)
2604 /* Don't mention an inline instance of a nested function. */
2605 if (context
&& DECL_FROM_INLINE (decl
))
2607 if (!MEM_P (decl_rtl
)
2608 || GET_CODE (XEXP (decl_rtl
, 0)) != SYMBOL_REF
)
2611 if (flag_debug_only_used_symbols
)
2612 output_used_types ();
2614 dbxout_begin_complex_stabs ();
2615 stabstr_I (DECL_ASSEMBLER_NAME (decl
));
2616 stabstr_S (TREE_PUBLIC (decl
) ? ":F" : ":f");
2619 if (TREE_TYPE (type
))
2620 dbxout_type (TREE_TYPE (type
), 0);
2622 dbxout_type (void_type_node
, 0);
2624 /* For a nested function, when that function is compiled,
2625 mention the containing function name
2626 as well as (since dbx wants it) our own assembler-name. */
2630 stabstr_I (DECL_ASSEMBLER_NAME (decl
));
2632 stabstr_I (DECL_NAME (context
));
2635 dbxout_finish_complex_stabs (decl
, N_FUN
, XEXP (decl_rtl
, 0), 0, 0);
2639 /* Don't output the same typedef twice.
2640 And don't output what language-specific stuff doesn't want output. */
2641 if (TREE_ASM_WRITTEN (decl
) || TYPE_DECL_SUPPRESS_DEBUG (decl
))
2642 DBXOUT_DECR_NESTING_AND_RETURN (0);
2644 /* Don't output typedefs for types with magic type numbers (XCOFF). */
2645 #ifdef DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER
2647 int fundamental_type_number
=
2648 DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER (decl
);
2650 if (fundamental_type_number
!= 0)
2652 TREE_ASM_WRITTEN (decl
) = 1;
2653 TYPE_SYMTAB_ADDRESS (TREE_TYPE (decl
)) = fundamental_type_number
;
2654 DBXOUT_DECR_NESTING_AND_RETURN (0);
2664 if (DECL_NAME (decl
))
2666 /* Nonzero means we must output a tag as well as a typedef. */
2669 /* Handle the case of a C++ structure or union
2670 where the TYPE_NAME is a TYPE_DECL
2671 which gives both a typedef name and a tag. */
2672 /* dbx requires the tag first and the typedef second. */
2673 if ((TREE_CODE (type
) == RECORD_TYPE
2674 || TREE_CODE (type
) == UNION_TYPE
2675 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
2676 && TYPE_NAME (type
) == decl
2677 && !use_gnu_debug_info_extensions
2678 && !TREE_ASM_WRITTEN (TYPE_NAME (type
))
2679 /* Distinguish the implicit typedefs of C++
2680 from explicit ones that might be found in C. */
2681 && DECL_ARTIFICIAL (decl
)
2682 /* Do not generate a tag for incomplete records. */
2683 && COMPLETE_TYPE_P (type
)
2684 /* Do not generate a tag for records of variable size,
2685 since this type can not be properly described in the
2686 DBX format, and it confuses some tools such as objdump. */
2687 && host_integerp (TYPE_SIZE (type
), 1))
2689 tree name
= TYPE_NAME (type
);
2690 if (TREE_CODE (name
) == TYPE_DECL
)
2691 name
= DECL_NAME (name
);
2693 dbxout_begin_complex_stabs ();
2696 dbxout_type (type
, 1);
2697 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE
,
2701 dbxout_begin_complex_stabs ();
2703 /* Output leading class/struct qualifiers. */
2704 if (use_gnu_debug_info_extensions
)
2705 dbxout_class_name_qualifiers (decl
);
2707 /* Output typedef name. */
2708 stabstr_I (DECL_NAME (decl
));
2711 /* Short cut way to output a tag also. */
2712 if ((TREE_CODE (type
) == RECORD_TYPE
2713 || TREE_CODE (type
) == UNION_TYPE
2714 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
2715 && TYPE_NAME (type
) == decl
2716 /* Distinguish the implicit typedefs of C++
2717 from explicit ones that might be found in C. */
2718 && DECL_ARTIFICIAL (decl
))
2720 if (use_gnu_debug_info_extensions
)
2723 TREE_ASM_WRITTEN (TYPE_NAME (type
)) = 1;
2728 dbxout_type (type
, 1);
2729 dbxout_finish_complex_stabs (decl
, DBX_TYPE_DECL_STABS_CODE
,
2734 /* Don't output a tag if this is an incomplete type. This prevents
2735 the sun4 Sun OS 4.x dbx from crashing. */
2737 if (tag_needed
&& TYPE_NAME (type
) != 0
2738 && (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
2739 || (DECL_NAME (TYPE_NAME (type
)) != 0))
2740 && COMPLETE_TYPE_P (type
)
2741 && !TREE_ASM_WRITTEN (TYPE_NAME (type
)))
2743 /* For a TYPE_DECL with no name, but the type has a name,
2745 This is what represents `struct foo' with no typedef. */
2746 /* In C++, the name of a type is the corresponding typedef.
2747 In C, it is an IDENTIFIER_NODE. */
2748 tree name
= TYPE_NAME (type
);
2749 if (TREE_CODE (name
) == TYPE_DECL
)
2750 name
= DECL_NAME (name
);
2752 dbxout_begin_complex_stabs ();
2755 dbxout_type (type
, 1);
2756 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE
, 0, 0, 0);
2760 /* If an enum type has no name, it cannot be referred to, but
2761 we must output it anyway, to record the enumeration
2764 if (!did_output
&& TREE_CODE (type
) == ENUMERAL_TYPE
)
2766 dbxout_begin_complex_stabs ();
2767 /* Some debuggers fail when given NULL names, so give this a
2768 harmless name of " " (Why not "(anon)"?). */
2770 dbxout_type (type
, 1);
2771 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE
, 0, 0, 0);
2774 /* Prevent duplicate output of a typedef. */
2775 TREE_ASM_WRITTEN (decl
) = 1;
2780 if (DECL_HAS_VALUE_EXPR_P (decl
))
2781 decl
= DECL_VALUE_EXPR (decl
);
2783 /* PARM_DECLs go in their own separate chain and are output by
2784 dbxout_reg_parms and dbxout_parms, except for those that are
2785 disguised VAR_DECLs like Out parameters in Ada. */
2786 gcc_assert (TREE_CODE (decl
) == VAR_DECL
);
2788 /* ... fall through ... */
2792 /* Don't mention a variable that is external.
2793 Let the file that defines it describe it. */
2794 if (DECL_EXTERNAL (decl
))
2797 /* If the variable is really a constant
2798 and not written in memory, inform the debugger.
2800 ??? Why do we skip emitting the type and location in this case? */
2801 if (TREE_STATIC (decl
) && TREE_READONLY (decl
)
2802 && DECL_INITIAL (decl
) != 0
2803 && host_integerp (DECL_INITIAL (decl
), 0)
2804 && ! TREE_ASM_WRITTEN (decl
)
2805 && (DECL_CONTEXT (decl
) == NULL_TREE
2806 || TREE_CODE (DECL_CONTEXT (decl
)) == BLOCK
2807 || TREE_CODE (DECL_CONTEXT (decl
)) == NAMESPACE_DECL
)
2808 && TREE_PUBLIC (decl
) == 0)
2810 /* The sun4 assembler does not grok this. */
2812 if (TREE_CODE (TREE_TYPE (decl
)) == INTEGER_TYPE
2813 || TREE_CODE (TREE_TYPE (decl
)) == ENUMERAL_TYPE
)
2815 HOST_WIDE_INT ival
= TREE_INT_CST_LOW (DECL_INITIAL (decl
));
2817 dbxout_begin_complex_stabs ();
2818 dbxout_symbol_name (decl
, NULL
, 'c');
2821 dbxout_finish_complex_stabs (0, N_LSYM
, 0, 0, 0);
2822 DBXOUT_DECR_NESTING
;
2828 /* else it is something we handle like a normal variable. */
2830 decl_rtl
= dbxout_expand_expr (decl
);
2832 DBXOUT_DECR_NESTING_AND_RETURN (0);
2834 decl_rtl
= eliminate_regs (decl_rtl
, VOIDmode
, NULL_RTX
);
2835 #ifdef LEAF_REG_REMAP
2836 if (current_function_uses_only_leaf_regs
)
2837 leaf_renumber_regs_insn (decl_rtl
);
2840 result
= dbxout_symbol_location (decl
, type
, 0, decl_rtl
);
2846 DBXOUT_DECR_NESTING
;
2850 /* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL.
2851 Add SUFFIX to its name, if SUFFIX is not 0.
2852 Describe the variable as residing in HOME
2853 (usually HOME is DECL_RTL (DECL), but not always).
2854 Returns 1 if the stab was really emitted. */
2857 dbxout_symbol_location (tree decl
, tree type
, const char *suffix
, rtx home
)
2860 stab_code_type code
;
2865 /* Don't mention a variable at all
2866 if it was completely optimized into nothingness.
2868 If the decl was from an inline function, then its rtl
2869 is not identically the rtl that was used in this
2870 particular compilation. */
2871 if (GET_CODE (home
) == SUBREG
)
2875 while (GET_CODE (value
) == SUBREG
)
2876 value
= SUBREG_REG (value
);
2879 if (REGNO (value
) >= FIRST_PSEUDO_REGISTER
)
2882 home
= alter_subreg (&home
);
2886 regno
= REGNO (home
);
2887 if (regno
>= FIRST_PSEUDO_REGISTER
)
2891 /* The kind-of-variable letter depends on where
2892 the variable is and on the scope of its name:
2893 G and N_GSYM for static storage and global scope,
2894 S for static storage and file scope,
2895 V for static storage and local scope,
2896 for those two, use N_LCSYM if data is in bss segment,
2897 N_STSYM if in data segment, N_FUN otherwise.
2898 (We used N_FUN originally, then changed to N_STSYM
2899 to please GDB. However, it seems that confused ld.
2900 Now GDB has been fixed to like N_FUN, says Kingdon.)
2901 no letter at all, and N_LSYM, for auto variable,
2902 r and N_RSYM for register variable. */
2904 if (MEM_P (home
) && GET_CODE (XEXP (home
, 0)) == SYMBOL_REF
)
2906 if (TREE_PUBLIC (decl
))
2911 if (NULL
!= dbxout_common_check (decl
, &offs
))
2920 addr
= XEXP (home
, 0);
2922 letter
= decl_function_context (decl
) ? 'V' : 'S';
2924 /* Some ports can transform a symbol ref into a label ref,
2925 because the symbol ref is too far away and has to be
2926 dumped into a constant pool. Alternatively, the symbol
2927 in the constant pool might be referenced by a different
2929 if (GET_CODE (addr
) == SYMBOL_REF
2930 && CONSTANT_POOL_ADDRESS_P (addr
))
2933 rtx tmp
= get_pool_constant_mark (addr
, &marked
);
2935 if (GET_CODE (tmp
) == SYMBOL_REF
)
2938 if (CONSTANT_POOL_ADDRESS_P (addr
))
2939 get_pool_constant_mark (addr
, &marked
);
2943 else if (GET_CODE (tmp
) == LABEL_REF
)
2949 /* If all references to the constant pool were optimized
2950 out, we just ignore the symbol. */
2955 /* This should be the same condition as in assemble_variable, but
2956 we don't have access to dont_output_data here. So, instead,
2957 we rely on the fact that error_mark_node initializers always
2958 end up in bss for C++ and never end up in bss for C. */
2959 if (DECL_INITIAL (decl
) == 0
2960 || (!strcmp (lang_hooks
.name
, "GNU C++")
2961 && DECL_INITIAL (decl
) == error_mark_node
))
2965 if (NULL
!= dbxout_common_check (decl
, &offs
))
2973 else if (DECL_IN_TEXT_SECTION (decl
))
2974 /* This is not quite right, but it's the closest
2975 of all the codes that Unix defines. */
2976 code
= DBX_STATIC_CONST_VAR_CODE
;
2979 /* Ultrix `as' seems to need this. */
2980 #ifdef DBX_STATIC_STAB_DATA_SECTION
2981 switch_to_section (data_section
);
2987 else if (regno
>= 0)
2991 number
= DBX_REGISTER_NUMBER (regno
);
2993 else if (MEM_P (home
)
2994 && (MEM_P (XEXP (home
, 0))
2995 || (REG_P (XEXP (home
, 0))
2996 && REGNO (XEXP (home
, 0)) != HARD_FRAME_POINTER_REGNUM
2997 && REGNO (XEXP (home
, 0)) != STACK_POINTER_REGNUM
2998 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2999 && REGNO (XEXP (home
, 0)) != ARG_POINTER_REGNUM
3002 /* If the value is indirect by memory or by a register
3003 that isn't the frame pointer
3004 then it means the object is variable-sized and address through
3005 that register or stack slot. DBX has no way to represent this
3006 so all we can do is output the variable as a pointer.
3007 If it's not a parameter, ignore it. */
3009 if (REG_P (XEXP (home
, 0)))
3013 if (REGNO (XEXP (home
, 0)) >= FIRST_PSEUDO_REGISTER
)
3015 number
= DBX_REGISTER_NUMBER (REGNO (XEXP (home
, 0)));
3020 /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
3021 We want the value of that CONST_INT. */
3022 number
= DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home
, 0), 0));
3025 /* Effectively do build_pointer_type, but don't cache this type,
3026 since it might be temporary whereas the type it points to
3027 might have been saved for inlining. */
3028 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
3029 type
= make_node (POINTER_TYPE
);
3030 TREE_TYPE (type
) = TREE_TYPE (decl
);
3032 else if (MEM_P (home
)
3033 && REG_P (XEXP (home
, 0)))
3036 number
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
3038 else if (MEM_P (home
)
3039 && GET_CODE (XEXP (home
, 0)) == PLUS
3040 && CONST_INT_P (XEXP (XEXP (home
, 0), 1)))
3043 /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
3044 We want the value of that CONST_INT. */
3045 number
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
3047 else if (MEM_P (home
)
3048 && GET_CODE (XEXP (home
, 0)) == CONST
)
3050 /* Handle an obscure case which can arise when optimizing and
3051 when there are few available registers. (This is *always*
3052 the case for i386/i486 targets). The RTL looks like
3053 (MEM (CONST ...)) even though this variable is a local `auto'
3054 or a local `register' variable. In effect, what has happened
3055 is that the reload pass has seen that all assignments and
3056 references for one such a local variable can be replaced by
3057 equivalent assignments and references to some static storage
3058 variable, thereby avoiding the need for a register. In such
3059 cases we're forced to lie to debuggers and tell them that
3060 this variable was itself `static'. */
3064 if (NULL
== dbxout_common_check (decl
, &offs
))
3065 addr
= XEXP (XEXP (home
, 0), 0);
3073 else if (GET_CODE (home
) == CONCAT
)
3077 /* If TYPE is not a COMPLEX_TYPE (it might be a RECORD_TYPE,
3078 for example), then there is no easy way to figure out
3079 what SUBTYPE should be. So, we give up. */
3080 if (TREE_CODE (type
) != COMPLEX_TYPE
)
3083 subtype
= TREE_TYPE (type
);
3085 /* If the variable's storage is in two parts,
3086 output each as a separate stab with a modified name. */
3087 if (WORDS_BIG_ENDIAN
)
3088 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 0));
3090 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 0));
3092 if (WORDS_BIG_ENDIAN
)
3093 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 1));
3095 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 1));
3099 /* Address might be a MEM, when DECL is a variable-sized object.
3100 Or it might be const0_rtx, meaning previous passes
3101 want us to ignore this variable. */
3104 /* Ok, start a symtab entry and output the variable name. */
3105 emit_pending_bincls_if_required ();
3108 #ifdef DBX_STATIC_BLOCK_START
3109 DBX_STATIC_BLOCK_START (asm_out_file
, code
);
3112 dbxout_begin_complex_stabs_noforcetext ();
3113 dbxout_symbol_name (decl
, suffix
, letter
);
3114 dbxout_type (type
, 0);
3115 dbxout_finish_complex_stabs (decl
, code
, addr
, 0, number
);
3117 #ifdef DBX_STATIC_BLOCK_END
3118 DBX_STATIC_BLOCK_END (asm_out_file
, code
);
3123 /* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
3124 Then output LETTER to indicate the kind of location the symbol has. */
3127 dbxout_symbol_name (tree decl
, const char *suffix
, int letter
)
3131 if (DECL_CONTEXT (decl
)
3132 && (TYPE_P (DECL_CONTEXT (decl
))
3133 || TREE_CODE (DECL_CONTEXT (decl
)) == NAMESPACE_DECL
))
3134 /* One slight hitch: if this is a VAR_DECL which is a class member
3135 or a namespace member, we must put out the mangled name instead of the
3136 DECL_NAME. Note also that static member (variable) names DO NOT begin
3137 with underscores in .stabs directives. */
3138 name
= DECL_ASSEMBLER_NAME (decl
);
3140 /* ...but if we're function-local, we don't want to include the junk
3141 added by ASM_FORMAT_PRIVATE_NAME. */
3142 name
= DECL_NAME (decl
);
3147 stabstr_S ("(anon)");
3157 /* Output the common block name for DECL in a stabs.
3159 Symbols in global common (.comm) get wrapped with an N_BCOMM/N_ECOMM pair
3160 around each group of symbols in the same .comm area. The N_GSYM stabs
3161 that are emitted only contain the offset in the common area. This routine
3162 emits the N_BCOMM and N_ECOMM stabs. */
3165 dbxout_common_name (tree decl
, const char *name
, stab_code_type op
)
3167 dbxout_begin_complex_stabs ();
3169 dbxout_finish_complex_stabs (decl
, op
, NULL_RTX
, NULL
, 0);
3172 /* Check decl to determine whether it is a VAR_DECL destined for storage in a
3173 common area. If it is, the return value will be a non-null string giving
3174 the name of the common storage block it will go into. If non-null, the
3175 value is the offset into the common block for that symbol's storage. */
3178 dbxout_common_check (tree decl
, int *value
)
3182 const char *name
= NULL
;
3184 /* If the decl isn't a VAR_DECL, or if it isn't public or static, or if
3185 it does not have a value (the offset into the common area), or if it
3186 is thread local (as opposed to global) then it isn't common, and shouldn't
3189 ??? DECL_THREAD_LOCAL_P check prevents problems with improper .stabs
3190 for thread-local symbols. Can be handled via same mechanism as used
3192 if (TREE_CODE (decl
) != VAR_DECL
3193 || !TREE_PUBLIC(decl
)
3194 || !TREE_STATIC(decl
)
3195 || !DECL_HAS_VALUE_EXPR_P(decl
)
3196 || DECL_THREAD_LOCAL_P (decl
)
3200 home
= DECL_RTL (decl
);
3201 if (home
== NULL_RTX
|| GET_CODE (home
) != MEM
)
3204 sym_addr
= dbxout_expand_expr (DECL_VALUE_EXPR (decl
));
3205 if (sym_addr
== NULL_RTX
|| GET_CODE (sym_addr
) != MEM
)
3208 sym_addr
= XEXP (sym_addr
, 0);
3209 if (GET_CODE (sym_addr
) == CONST
)
3210 sym_addr
= XEXP (sym_addr
, 0);
3211 if ((GET_CODE (sym_addr
) == SYMBOL_REF
|| GET_CODE (sym_addr
) == PLUS
)
3212 && DECL_INITIAL (decl
) == 0)
3215 /* We have a sym that will go into a common area, meaning that it
3216 will get storage reserved with a .comm/.lcomm assembler pseudo-op.
3218 Determine name of common area this symbol will be an offset into,
3219 and offset into that area. Also retrieve the decl for the area
3220 that the symbol is offset into. */
3223 switch (GET_CODE (sym_addr
))
3226 if (CONST_INT_P (XEXP (sym_addr
, 0)))
3229 targetm
.strip_name_encoding(XSTR (XEXP (sym_addr
, 1), 0));
3230 *value
= INTVAL (XEXP (sym_addr
, 0));
3231 cdecl = SYMBOL_REF_DECL (XEXP (sym_addr
, 1));
3236 targetm
.strip_name_encoding(XSTR (XEXP (sym_addr
, 0), 0));
3237 *value
= INTVAL (XEXP (sym_addr
, 1));
3238 cdecl = SYMBOL_REF_DECL (XEXP (sym_addr
, 0));
3243 name
= targetm
.strip_name_encoding(XSTR (sym_addr
, 0));
3245 cdecl = SYMBOL_REF_DECL (sym_addr
);
3249 error ("common symbol debug info is not structured as "
3253 /* Check area common symbol is offset into. If this is not public, then
3254 it is not a symbol in a common block. It must be a .lcomm symbol, not
3256 if (cdecl == NULL
|| !TREE_PUBLIC(cdecl))
3265 /* Output definitions of all the decls in a chain. Return nonzero if
3266 anything was output */
3269 dbxout_syms (tree syms
)
3272 const char *comm_prev
= NULL
;
3273 tree syms_prev
= NULL
;
3277 int temp
, copen
, cclos
;
3278 const char *comm_new
;
3280 /* Check for common symbol, and then progression into a new/different
3281 block of common symbols. Emit closing/opening common bracket if
3283 comm_new
= dbxout_common_check (syms
, &temp
);
3284 copen
= comm_new
!= NULL
3285 && (comm_prev
== NULL
|| strcmp (comm_new
, comm_prev
));
3286 cclos
= comm_prev
!= NULL
3287 && (comm_new
== NULL
|| strcmp (comm_new
, comm_prev
));
3289 dbxout_common_name (syms_prev
, comm_prev
, N_ECOMM
);
3292 dbxout_common_name (syms
, comm_new
, N_BCOMM
);
3295 comm_prev
= comm_new
;
3297 result
+= dbxout_symbol (syms
, 1);
3298 syms
= TREE_CHAIN (syms
);
3301 if (comm_prev
!= NULL
)
3302 dbxout_common_name (syms_prev
, comm_prev
, N_ECOMM
);
3307 /* The following two functions output definitions of function parameters.
3308 Each parameter gets a definition locating it in the parameter list.
3309 Each parameter that is a register variable gets a second definition
3310 locating it in the register.
3312 Printing or argument lists in gdb uses the definitions that
3313 locate in the parameter list. But reference to the variable in
3314 expressions uses preferentially the definition as a register. */
3316 /* Output definitions, referring to storage in the parmlist,
3317 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
3320 dbxout_parms (tree parms
)
3323 emit_pending_bincls_if_required ();
3325 for (; parms
; parms
= TREE_CHAIN (parms
))
3326 if (DECL_NAME (parms
)
3327 && TREE_TYPE (parms
) != error_mark_node
3328 && DECL_RTL_SET_P (parms
)
3329 && DECL_INCOMING_RTL (parms
))
3333 stab_code_type code
;
3336 /* Perform any necessary register eliminations on the parameter's rtl,
3337 so that the debugging output will be accurate. */
3338 DECL_INCOMING_RTL (parms
)
3339 = eliminate_regs (DECL_INCOMING_RTL (parms
), VOIDmode
, NULL_RTX
);
3340 SET_DECL_RTL (parms
,
3341 eliminate_regs (DECL_RTL (parms
), VOIDmode
, NULL_RTX
));
3342 #ifdef LEAF_REG_REMAP
3343 if (current_function_uses_only_leaf_regs
)
3345 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms
));
3346 leaf_renumber_regs_insn (DECL_RTL (parms
));
3350 if (PARM_PASSED_IN_MEMORY (parms
))
3352 rtx inrtl
= XEXP (DECL_INCOMING_RTL (parms
), 0);
3354 /* ??? Here we assume that the parm address is indexed
3355 off the frame pointer or arg pointer.
3356 If that is not true, we produce meaningless results,
3357 but do not crash. */
3358 if (GET_CODE (inrtl
) == PLUS
3359 && CONST_INT_P (XEXP (inrtl
, 1)))
3360 number
= INTVAL (XEXP (inrtl
, 1));
3365 number
= DEBUGGER_ARG_OFFSET (number
, inrtl
);
3368 /* It is quite tempting to use TREE_TYPE (parms) instead
3369 of DECL_ARG_TYPE (parms) for the eff_type, so that gcc
3370 reports the actual type of the parameter, rather than
3371 the promoted type. This certainly makes GDB's life
3372 easier, at least for some ports. The change is a bad
3373 idea however, since GDB expects to be able access the
3374 type without performing any conversions. So for
3375 example, if we were passing a float to an unprototyped
3376 function, gcc will store a double on the stack, but if
3377 we emit a stab saying the type is a float, then gdb
3378 will only read in a single value, and this will produce
3379 an erroneous value. */
3380 eff_type
= DECL_ARG_TYPE (parms
);
3382 else if (REG_P (DECL_RTL (parms
)))
3386 /* Parm passed in registers and lives in registers or nowhere. */
3387 code
= DBX_REGPARM_STABS_CODE
;
3388 letter
= DBX_REGPARM_STABS_LETTER
;
3390 /* For parms passed in registers, it is better to use the
3391 declared type of the variable, not the type it arrived in. */
3392 eff_type
= TREE_TYPE (parms
);
3394 /* If parm lives in a register, use that register; pretend
3395 the parm was passed there. It would be more consistent
3396 to describe the register where the parm was passed, but
3397 in practice that register usually holds something else.
3398 If the parm lives nowhere, use the register where it
3400 if (REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
3401 best_rtl
= DECL_RTL (parms
);
3402 else if (GET_CODE (DECL_INCOMING_RTL (parms
)) == PARALLEL
)
3403 best_rtl
= XEXP (XVECEXP (DECL_INCOMING_RTL (parms
), 0, 0), 0);
3405 best_rtl
= DECL_INCOMING_RTL (parms
);
3407 number
= DBX_REGISTER_NUMBER (REGNO (best_rtl
));
3409 else if (MEM_P (DECL_RTL (parms
))
3410 && REG_P (XEXP (DECL_RTL (parms
), 0))
3411 && REGNO (XEXP (DECL_RTL (parms
), 0)) != HARD_FRAME_POINTER_REGNUM
3412 && REGNO (XEXP (DECL_RTL (parms
), 0)) != STACK_POINTER_REGNUM
3413 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
3414 && REGNO (XEXP (DECL_RTL (parms
), 0)) != ARG_POINTER_REGNUM
3418 /* Parm was passed via invisible reference.
3419 That is, its address was passed in a register.
3420 Output it as if it lived in that register.
3421 The debugger will know from the type
3422 that it was actually passed by invisible reference. */
3424 code
= DBX_REGPARM_STABS_CODE
;
3426 /* GDB likes this marked with a special letter. */
3427 letter
= (use_gnu_debug_info_extensions
3428 ? 'a' : DBX_REGPARM_STABS_LETTER
);
3429 eff_type
= TREE_TYPE (parms
);
3431 /* DECL_RTL looks like (MEM (REG...). Get the register number.
3432 If it is an unallocated pseudo-reg, then use the register where
3433 it was passed instead.
3434 ??? Why is DBX_REGISTER_NUMBER not used here? */
3436 if (REGNO (XEXP (DECL_RTL (parms
), 0)) < FIRST_PSEUDO_REGISTER
)
3437 number
= REGNO (XEXP (DECL_RTL (parms
), 0));
3439 number
= REGNO (DECL_INCOMING_RTL (parms
));
3441 else if (MEM_P (DECL_RTL (parms
))
3442 && MEM_P (XEXP (DECL_RTL (parms
), 0)))
3444 /* Parm was passed via invisible reference, with the reference
3445 living on the stack. DECL_RTL looks like
3446 (MEM (MEM (PLUS (REG ...) (CONST_INT ...)))) or it
3447 could look like (MEM (MEM (REG))). */
3451 eff_type
= TREE_TYPE (parms
);
3453 if (!REG_P (XEXP (XEXP (DECL_RTL (parms
), 0), 0)))
3454 number
= INTVAL (XEXP (XEXP (XEXP (DECL_RTL (parms
), 0), 0), 1));
3458 number
= DEBUGGER_ARG_OFFSET (number
,
3459 XEXP (XEXP (DECL_RTL (parms
), 0), 0));
3461 else if (MEM_P (DECL_RTL (parms
))
3462 && XEXP (DECL_RTL (parms
), 0) != const0_rtx
3463 /* ??? A constant address for a parm can happen
3464 when the reg it lives in is equiv to a constant in memory.
3465 Should make this not happen, after 2.4. */
3466 && ! CONSTANT_P (XEXP (DECL_RTL (parms
), 0)))
3468 /* Parm was passed in registers but lives on the stack. */
3472 eff_type
= TREE_TYPE (parms
);
3474 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
3475 in which case we want the value of that CONST_INT,
3477 in which case we use a value of zero. */
3478 if (!REG_P (XEXP (DECL_RTL (parms
), 0)))
3479 number
= INTVAL (XEXP (XEXP (DECL_RTL (parms
), 0), 1));
3483 /* Make a big endian correction if the mode of the type of the
3484 parameter is not the same as the mode of the rtl. */
3485 if (BYTES_BIG_ENDIAN
3486 && TYPE_MODE (TREE_TYPE (parms
)) != GET_MODE (DECL_RTL (parms
))
3487 && GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms
))) < UNITS_PER_WORD
)
3488 number
+= (GET_MODE_SIZE (GET_MODE (DECL_RTL (parms
)))
3489 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms
))));
3492 /* ??? We don't know how to represent this argument. */
3495 dbxout_begin_complex_stabs ();
3497 if (DECL_NAME (parms
))
3499 stabstr_I (DECL_NAME (parms
));
3503 stabstr_S ("(anon):");
3505 dbxout_type (eff_type
, 0);
3506 dbxout_finish_complex_stabs (parms
, code
, 0, 0, number
);
3508 DBXOUT_DECR_NESTING
;
3511 /* Output definitions for the places where parms live during the function,
3512 when different from where they were passed, when the parms were passed
3515 It is not useful to do this for parms passed in registers
3516 that live during the function in different registers, because it is
3517 impossible to look in the passed register for the passed value,
3518 so we use the within-the-function register to begin with.
3520 PARMS is a chain of PARM_DECL nodes. */
3523 dbxout_reg_parms (tree parms
)
3527 for (; parms
; parms
= TREE_CHAIN (parms
))
3528 if (DECL_NAME (parms
) && PARM_PASSED_IN_MEMORY (parms
))
3530 /* Report parms that live in registers during the function
3531 but were passed in memory. */
3532 if (REG_P (DECL_RTL (parms
))
3533 && REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
3534 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
3535 0, DECL_RTL (parms
));
3536 else if (GET_CODE (DECL_RTL (parms
)) == CONCAT
)
3537 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
3538 0, DECL_RTL (parms
));
3539 /* Report parms that live in memory but not where they were passed. */
3540 else if (MEM_P (DECL_RTL (parms
))
3541 && ! rtx_equal_p (DECL_RTL (parms
), DECL_INCOMING_RTL (parms
)))
3542 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
3543 0, DECL_RTL (parms
));
3545 DBXOUT_DECR_NESTING
;
3548 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
3549 output definitions of those names, in raw form */
3552 dbxout_args (tree args
)
3557 dbxout_type (TREE_VALUE (args
), 0);
3558 args
= TREE_CHAIN (args
);
3562 #if defined (DBX_DEBUGGING_INFO)
3564 /* Subroutine of dbxout_block. Emit an N_LBRAC stab referencing LABEL.
3565 BEGIN_LABEL is the name of the beginning of the function, which may
3568 dbx_output_lbrac (const char *label
,
3569 const char *begin_label ATTRIBUTE_UNUSED
)
3571 dbxout_begin_stabn (N_LBRAC
);
3572 if (DBX_BLOCKS_FUNCTION_RELATIVE
)
3573 dbxout_stab_value_label_diff (label
, begin_label
);
3575 dbxout_stab_value_label (label
);
3578 /* Subroutine of dbxout_block. Emit an N_RBRAC stab referencing LABEL.
3579 BEGIN_LABEL is the name of the beginning of the function, which may
3582 dbx_output_rbrac (const char *label
,
3583 const char *begin_label ATTRIBUTE_UNUSED
)
3585 dbxout_begin_stabn (N_RBRAC
);
3586 if (DBX_BLOCKS_FUNCTION_RELATIVE
)
3587 dbxout_stab_value_label_diff (label
, begin_label
);
3589 dbxout_stab_value_label (label
);
3592 /* Output everything about a symbol block (a BLOCK node
3593 that represents a scope level),
3594 including recursive output of contained blocks.
3596 BLOCK is the BLOCK node.
3597 DEPTH is its depth within containing symbol blocks.
3598 ARGS is usually zero; but for the outermost block of the
3599 body of a function, it is a chain of PARM_DECLs for the function parameters.
3600 We output definitions of all the register parms
3601 as if they were local variables of that block.
3603 If -g1 was used, we count blocks just the same, but output nothing
3604 except for the outermost block.
3606 Actually, BLOCK may be several blocks chained together.
3607 We handle them all in sequence. */
3610 dbxout_block (tree block
, int depth
, tree args
)
3612 char begin_label
[20];
3613 /* Reference current function start using LFBB. */
3614 ASM_GENERATE_INTERNAL_LABEL (begin_label
, "LFBB", scope_labelno
);
3618 /* Ignore blocks never expanded or otherwise marked as real. */
3619 if (TREE_USED (block
) && TREE_ASM_WRITTEN (block
))
3622 int blocknum
= BLOCK_NUMBER (block
);
3624 /* In dbx format, the syms of a block come before the N_LBRAC.
3625 If nothing is output, we don't need the N_LBRAC, either. */
3627 if (debug_info_level
!= DINFO_LEVEL_TERSE
|| depth
== 0)
3628 did_output
= dbxout_syms (BLOCK_VARS (block
));
3630 dbxout_reg_parms (args
);
3632 /* Now output an N_LBRAC symbol to represent the beginning of
3633 the block. Use the block's tree-walk order to generate
3634 the assembler symbols LBBn and LBEn
3635 that final will define around the code in this block. */
3639 const char *scope_start
;
3642 /* The outermost block doesn't get LBB labels; use
3643 the LFBB local symbol emitted by dbxout_begin_prologue. */
3644 scope_start
= begin_label
;
3647 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBB", blocknum
);
3651 dbx_output_lbrac (scope_start
, begin_label
);
3654 /* Output the subblocks. */
3655 dbxout_block (BLOCK_SUBBLOCKS (block
), depth
+ 1, NULL_TREE
);
3657 /* Refer to the marker for the end of the block. */
3662 /* The outermost block doesn't get LBE labels;
3663 use the "scope" label which will be emitted
3664 by dbxout_function_end. */
3665 ASM_GENERATE_INTERNAL_LABEL (buf
, "Lscope", scope_labelno
);
3667 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBE", blocknum
);
3669 dbx_output_rbrac (buf
, begin_label
);
3672 block
= BLOCK_CHAIN (block
);
3676 /* Output the information about a function and its arguments and result.
3677 Usually this follows the function's code,
3678 but on some systems, it comes before. */
3681 dbxout_begin_function (tree decl
)
3683 int saved_tree_used1
;
3685 saved_tree_used1
= TREE_USED (decl
);
3686 TREE_USED (decl
) = 1;
3687 if (DECL_NAME (DECL_RESULT (decl
)) != 0)
3689 int saved_tree_used2
= TREE_USED (DECL_RESULT (decl
));
3690 TREE_USED (DECL_RESULT (decl
)) = 1;
3691 dbxout_symbol (decl
, 0);
3692 TREE_USED (DECL_RESULT (decl
)) = saved_tree_used2
;
3695 dbxout_symbol (decl
, 0);
3696 TREE_USED (decl
) = saved_tree_used1
;
3698 dbxout_parms (DECL_ARGUMENTS (decl
));
3699 if (DECL_NAME (DECL_RESULT (decl
)) != 0)
3700 dbxout_symbol (DECL_RESULT (decl
), 1);
3702 #endif /* DBX_DEBUGGING_INFO */
3704 #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */
3706 #include "gt-dbxout.h"