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 *);
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
)
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
925 || DECL_IGNORED_P (decl
))
928 /* By convention, GCC will mark the end of a function with an N_FUN
929 symbol and an empty string. */
930 if (flag_reorder_blocks_and_partition
)
932 dbxout_begin_empty_stabs (N_FUN
);
933 dbxout_stab_value_label_diff (crtl
->subsections
.hot_section_end_label
,
934 crtl
->subsections
.hot_section_label
);
935 dbxout_begin_empty_stabs (N_FUN
);
936 dbxout_stab_value_label_diff (crtl
->subsections
.cold_section_end_label
,
937 crtl
->subsections
.cold_section_label
);
941 char begin_label
[20];
942 /* Reference current function start using LFBB. */
943 ASM_GENERATE_INTERNAL_LABEL (begin_label
, "LFBB", scope_labelno
);
944 dbxout_begin_empty_stabs (N_FUN
);
945 dbxout_stab_value_label_diff (lscope_label_name
, begin_label
);
948 if (!NO_DBX_BNSYM_ENSYM
&& !flag_debug_only_used_symbols
)
949 dbxout_stabd (N_ENSYM
, 0);
951 #endif /* DBX_DEBUGGING_INFO */
953 /* Get lang description for N_SO stab. */
954 static unsigned int ATTRIBUTE_UNUSED
955 get_lang_number (void)
957 const char *language_string
= lang_hooks
.name
;
959 if (strcmp (language_string
, "GNU C") == 0)
961 else if (strcmp (language_string
, "GNU C++") == 0)
963 else if (strcmp (language_string
, "GNU F77") == 0)
965 else if (strcmp (language_string
, "GNU Fortran") == 0)
966 return N_SO_FORTRAN90
; /* CHECKME */
967 else if (strcmp (language_string
, "GNU Pascal") == 0)
969 else if (strcmp (language_string
, "GNU Objective-C") == 0)
971 else if (strcmp (language_string
, "GNU Objective-C++") == 0)
972 return N_SO_OBJCPLUS
;
981 unsigned int lang
= get_lang_number ();
983 return (lang
== N_SO_FORTRAN
) || (lang
== N_SO_FORTRAN90
);
986 /* At the beginning of compilation, start writing the symbol table.
987 Initialize `typevec' and output the standard data types of C. */
990 dbxout_init (const char *input_file_name
)
992 char ltext_label_name
[100];
993 bool used_ltext_label_name
= false;
994 tree syms
= lang_hooks
.decls
.getdecls ();
995 const char *mapped_name
;
998 typevec
= GGC_CNEWVEC (struct typeinfo
, typevec_len
);
1000 /* stabstr_ob contains one string, which will be just fine with
1001 1-byte alignment. */
1002 obstack_specify_allocation (&stabstr_ob
, 0, 1, xmalloc
, free
);
1004 /* Convert Ltext into the appropriate format for local labels in case
1005 the system doesn't insert underscores in front of user generated
1007 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name
, "Ltext", 0);
1009 /* Put the current working directory in an N_SO symbol. */
1010 if (use_gnu_debug_info_extensions
&& !NO_DBX_MAIN_SOURCE_DIRECTORY
)
1012 static const char *cwd
;
1016 cwd
= get_src_pwd ();
1019 else if (!IS_DIR_SEPARATOR (cwd
[strlen (cwd
) - 1]))
1020 cwd
= concat (cwd
, "/", NULL
);
1021 cwd
= remap_debug_filename (cwd
);
1023 #ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
1024 DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asm_out_file
, cwd
);
1025 #else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
1026 dbxout_begin_simple_stabs_desc (cwd
, N_SO
, get_lang_number ());
1027 dbxout_stab_value_label (ltext_label_name
);
1028 used_ltext_label_name
= true;
1029 #endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
1032 mapped_name
= remap_debug_filename (input_file_name
);
1033 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
1034 DBX_OUTPUT_MAIN_SOURCE_FILENAME (asm_out_file
, mapped_name
);
1036 dbxout_begin_simple_stabs_desc (mapped_name
, N_SO
, get_lang_number ());
1037 dbxout_stab_value_label (ltext_label_name
);
1038 used_ltext_label_name
= true;
1041 if (used_ltext_label_name
)
1043 switch_to_section (text_section
);
1044 targetm
.asm_out
.internal_label (asm_out_file
, "Ltext", 0);
1047 /* Emit an N_OPT stab to indicate that this file was compiled by GCC.
1048 The string used is historical. */
1049 #ifndef NO_DBX_GCC_MARKER
1050 dbxout_begin_simple_stabs ("gcc2_compiled.", N_OPT
);
1051 dbxout_stab_value_zero ();
1054 base_input_file
= lastfile
= input_file_name
;
1056 next_type_number
= 1;
1058 #ifdef DBX_USE_BINCL
1059 current_file
= XNEW (struct dbx_file
);
1060 current_file
->next
= NULL
;
1061 current_file
->file_number
= 0;
1062 current_file
->next_type_number
= 1;
1063 next_file_number
= 1;
1064 current_file
->prev
= NULL
;
1065 current_file
->bincl_status
= BINCL_NOT_REQUIRED
;
1066 current_file
->pending_bincl_name
= NULL
;
1069 /* Get all permanent types that have typedef names, and output them
1070 all, except for those already output. Some language front ends
1071 put these declarations in the top-level scope; some do not;
1072 the latter are responsible for calling debug_hooks->type_decl from
1073 their record_builtin_type function. */
1074 dbxout_typedefs (syms
);
1076 if (preinit_symbols
)
1079 for (t
= nreverse (preinit_symbols
); t
; t
= TREE_CHAIN (t
))
1080 dbxout_symbol (TREE_VALUE (t
), 0);
1081 preinit_symbols
= 0;
1085 /* Output any typedef names for types described by TYPE_DECLs in SYMS. */
1088 dbxout_typedefs (tree syms
)
1090 for (; syms
!= NULL_TREE
; syms
= TREE_CHAIN (syms
))
1092 if (TREE_CODE (syms
) == TYPE_DECL
)
1094 tree type
= TREE_TYPE (syms
);
1095 if (TYPE_NAME (type
)
1096 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1097 && COMPLETE_OR_VOID_TYPE_P (type
)
1098 && ! TREE_ASM_WRITTEN (TYPE_NAME (type
)))
1099 dbxout_symbol (TYPE_NAME (type
), 0);
1104 #ifdef DBX_USE_BINCL
1105 /* Emit BINCL stab using given name. */
1107 emit_bincl_stab (const char *name
)
1109 dbxout_begin_simple_stabs (name
, N_BINCL
);
1110 dbxout_stab_value_zero ();
1113 /* If there are pending bincls then it is time to emit all of them. */
1116 emit_pending_bincls_if_required (void)
1119 emit_pending_bincls ();
1122 /* Emit all pending bincls. */
1125 emit_pending_bincls (void)
1127 struct dbx_file
*f
= current_file
;
1129 /* Find first pending bincl. */
1130 while (f
->bincl_status
== BINCL_PENDING
)
1133 /* Now emit all bincls. */
1138 if (f
->bincl_status
== BINCL_PENDING
)
1140 emit_bincl_stab (f
->pending_bincl_name
);
1142 /* Update file number and status. */
1143 f
->file_number
= next_file_number
++;
1144 f
->bincl_status
= BINCL_PROCESSED
;
1146 if (f
== current_file
)
1151 /* All pending bincls have been emitted. */
1158 emit_pending_bincls_if_required (void) {}
1161 /* Change to reading from a new source file. Generate a N_BINCL stab. */
1164 dbxout_start_source_file (unsigned int line ATTRIBUTE_UNUSED
,
1165 const char *filename ATTRIBUTE_UNUSED
)
1167 #ifdef DBX_USE_BINCL
1168 struct dbx_file
*n
= XNEW (struct dbx_file
);
1170 n
->next
= current_file
;
1171 n
->next_type_number
= 1;
1172 /* Do not assign file number now.
1173 Delay it until we actually emit BINCL. */
1176 current_file
->prev
= n
;
1177 n
->bincl_status
= BINCL_PENDING
;
1178 n
->pending_bincl_name
= remap_debug_filename (filename
);
1184 /* Revert to reading a previous source file. Generate a N_EINCL stab. */
1187 dbxout_end_source_file (unsigned int line ATTRIBUTE_UNUSED
)
1189 #ifdef DBX_USE_BINCL
1190 /* Emit EINCL stab only if BINCL is not pending. */
1191 if (current_file
->bincl_status
== BINCL_PROCESSED
)
1193 dbxout_begin_stabn (N_EINCL
);
1194 dbxout_stab_value_zero ();
1196 current_file
->bincl_status
= BINCL_NOT_REQUIRED
;
1197 current_file
= current_file
->next
;
1201 /* Handle a few odd cases that occur when trying to make PCH files work. */
1204 dbxout_handle_pch (unsigned at_end
)
1208 /* When using the PCH, this file will be included, so we need to output
1210 dbxout_start_source_file (0, lastfile
);
1212 /* The base file when using the PCH won't be the same as
1213 the base file when it's being generated. */
1218 /* ... and an EINCL. */
1219 dbxout_end_source_file (0);
1221 /* Deal with cases where 'lastfile' was never actually changed. */
1222 lastfile_is_base
= lastfile
== NULL
;
1226 #if defined (DBX_DEBUGGING_INFO)
1228 static void dbxout_block (tree
, int, tree
);
1230 /* Output debugging info to FILE to switch to sourcefile FILENAME. */
1233 dbxout_source_file (const char *filename
)
1235 if (lastfile
== 0 && lastfile_is_base
)
1237 lastfile
= base_input_file
;
1238 lastfile_is_base
= 0;
1241 if (filename
&& (lastfile
== 0 || strcmp (filename
, lastfile
)))
1243 /* Don't change section amid function. */
1244 if (current_function_decl
== NULL_TREE
)
1245 switch_to_section (text_section
);
1247 dbxout_begin_simple_stabs (remap_debug_filename (filename
), N_SOL
);
1248 dbxout_stab_value_internal_label ("Ltext", &source_label_number
);
1249 lastfile
= filename
;
1253 /* Output N_BNSYM, line number symbol entry, and local symbol at
1257 dbxout_begin_prologue (unsigned int lineno
, const char *filename
)
1259 if (use_gnu_debug_info_extensions
1260 && !NO_DBX_FUNCTION_END
1261 && !NO_DBX_BNSYM_ENSYM
1262 && !flag_debug_only_used_symbols
)
1263 dbxout_stabd (N_BNSYM
, 0);
1265 /* pre-increment the scope counter */
1268 dbxout_source_line (lineno
, filename
);
1269 /* Output function begin block at function scope, referenced
1270 by dbxout_block, dbxout_source_line and dbxout_function_end. */
1271 emit_pending_bincls_if_required ();
1272 targetm
.asm_out
.internal_label (asm_out_file
, "LFBB", scope_labelno
);
1275 /* Output a line number symbol entry for source file FILENAME and line
1279 dbxout_source_line (unsigned int lineno
, const char *filename
)
1281 dbxout_source_file (filename
);
1283 #ifdef DBX_OUTPUT_SOURCE_LINE
1284 DBX_OUTPUT_SOURCE_LINE (asm_out_file
, lineno
, dbxout_source_line_counter
);
1286 if (DBX_LINES_FUNCTION_RELATIVE
)
1288 char begin_label
[20];
1289 dbxout_begin_stabn_sline (lineno
);
1290 /* Reference current function start using LFBB. */
1291 ASM_GENERATE_INTERNAL_LABEL (begin_label
, "LFBB", scope_labelno
);
1292 dbxout_stab_value_internal_label_diff ("LM", &dbxout_source_line_counter
,
1296 dbxout_stabd (N_SLINE
, lineno
);
1300 /* Describe the beginning of an internal block within a function. */
1303 dbxout_begin_block (unsigned int line ATTRIBUTE_UNUSED
, unsigned int n
)
1305 emit_pending_bincls_if_required ();
1306 targetm
.asm_out
.internal_label (asm_out_file
, "LBB", n
);
1309 /* Describe the end line-number of an internal block within a function. */
1312 dbxout_end_block (unsigned int line ATTRIBUTE_UNUSED
, unsigned int n
)
1314 emit_pending_bincls_if_required ();
1315 targetm
.asm_out
.internal_label (asm_out_file
, "LBE", n
);
1318 /* Output dbx data for a function definition.
1319 This includes a definition of the function name itself (a symbol),
1320 definitions of the parameters (locating them in the parameter list)
1321 and then output the block that makes up the function's body
1322 (including all the auto variables of the function). */
1325 dbxout_function_decl (tree decl
)
1327 emit_pending_bincls_if_required ();
1328 #ifndef DBX_FUNCTION_FIRST
1329 dbxout_begin_function (decl
);
1331 dbxout_block (DECL_INITIAL (decl
), 0, DECL_ARGUMENTS (decl
));
1332 dbxout_function_end (decl
);
1335 #endif /* DBX_DEBUGGING_INFO */
1337 /* Debug information for a global DECL. Called from toplev.c after
1338 compilation proper has finished. */
1340 dbxout_global_decl (tree decl
)
1342 if (TREE_CODE (decl
) == VAR_DECL
&& !DECL_EXTERNAL (decl
))
1344 int saved_tree_used
= TREE_USED (decl
);
1345 TREE_USED (decl
) = 1;
1346 dbxout_symbol (decl
, 0);
1347 TREE_USED (decl
) = saved_tree_used
;
1351 /* This is just a function-type adapter; dbxout_symbol does exactly
1352 what we want but returns an int. */
1354 dbxout_type_decl (tree decl
, int local
)
1356 dbxout_symbol (decl
, local
);
1359 /* At the end of compilation, finish writing the symbol table.
1360 The default is to call debug_free_queue but do nothing else. */
1363 dbxout_finish (const char *filename ATTRIBUTE_UNUSED
)
1365 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
1366 DBX_OUTPUT_MAIN_SOURCE_FILE_END (asm_out_file
, filename
);
1367 #elif defined DBX_OUTPUT_NULL_N_SO_AT_MAIN_SOURCE_FILE_END
1369 switch_to_section (text_section
);
1370 dbxout_begin_empty_stabs (N_SO
);
1371 dbxout_stab_value_internal_label ("Letext", 0);
1374 debug_free_queue ();
1377 /* Output the index of a type. */
1380 dbxout_type_index (tree type
)
1382 #ifndef DBX_USE_BINCL
1383 stabstr_D (TYPE_SYMTAB_ADDRESS (type
));
1385 struct typeinfo
*t
= &typevec
[TYPE_SYMTAB_ADDRESS (type
)];
1387 stabstr_D (t
->file_number
);
1389 stabstr_D (t
->type_number
);
1396 /* Used in several places: evaluates to '0' for a private decl,
1397 '1' for a protected decl, '2' for a public decl. */
1398 #define DECL_ACCESSIBILITY_CHAR(DECL) \
1399 (TREE_PRIVATE (DECL) ? '0' : TREE_PROTECTED (DECL) ? '1' : '2')
1401 /* Subroutine of `dbxout_type'. Output the type fields of TYPE.
1402 This must be a separate function because anonymous unions require
1406 dbxout_type_fields (tree type
)
1410 /* Output the name, type, position (in bits), size (in bits) of each
1411 field that we can support. */
1412 for (tem
= TYPE_FIELDS (type
); tem
; tem
= TREE_CHAIN (tem
))
1414 /* If one of the nodes is an error_mark or its type is then
1416 if (tem
== error_mark_node
|| TREE_TYPE (tem
) == error_mark_node
)
1419 /* Omit here local type decls until we know how to support them. */
1420 if (TREE_CODE (tem
) == TYPE_DECL
1421 /* Omit here the nameless fields that are used to skip bits. */
1422 || DECL_IGNORED_P (tem
)
1423 /* Omit fields whose position or size are variable or too large to
1425 || (TREE_CODE (tem
) == FIELD_DECL
1426 && (! host_integerp (bit_position (tem
), 0)
1427 || ! DECL_SIZE (tem
)
1428 || ! host_integerp (DECL_SIZE (tem
), 1))))
1431 else if (TREE_CODE (tem
) != CONST_DECL
)
1433 /* Continue the line if necessary,
1434 but not before the first field. */
1435 if (tem
!= TYPE_FIELDS (type
))
1438 if (DECL_NAME (tem
))
1439 stabstr_I (DECL_NAME (tem
));
1442 if (use_gnu_debug_info_extensions
1443 && (TREE_PRIVATE (tem
) || TREE_PROTECTED (tem
)
1444 || TREE_CODE (tem
) != FIELD_DECL
))
1447 stabstr_C (DECL_ACCESSIBILITY_CHAR (tem
));
1450 dbxout_type ((TREE_CODE (tem
) == FIELD_DECL
1451 && DECL_BIT_FIELD_TYPE (tem
))
1452 ? DECL_BIT_FIELD_TYPE (tem
) : TREE_TYPE (tem
), 0);
1454 if (TREE_CODE (tem
) == VAR_DECL
)
1456 if (TREE_STATIC (tem
) && use_gnu_debug_info_extensions
)
1458 tree name
= DECL_ASSEMBLER_NAME (tem
);
1465 /* If TEM is non-static, GDB won't understand it. */
1466 stabstr_S (",0,0;");
1471 stabstr_D (int_bit_position (tem
));
1473 stabstr_D (tree_low_cst (DECL_SIZE (tem
), 1));
1480 /* Subroutine of `dbxout_type_methods'. Output debug info about the
1481 method described DECL. */
1484 dbxout_type_method_1 (tree decl
)
1488 if (TREE_CODE (TREE_TYPE (decl
)) == FUNCTION_TYPE
)
1490 else /* it's a METHOD_TYPE. */
1492 tree firstarg
= TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)));
1493 /* A for normal functions.
1494 B for `const' member functions.
1495 C for `volatile' member functions.
1496 D for `const volatile' member functions. */
1497 if (TYPE_READONLY (TREE_TYPE (firstarg
)))
1499 if (TYPE_VOLATILE (TREE_TYPE (firstarg
)))
1502 if (DECL_VINDEX (decl
))
1508 /* ??? Output the mangled name, which contains an encoding of the
1509 method's type signature. May not be necessary anymore. */
1511 stabstr_I (DECL_ASSEMBLER_NAME (decl
));
1513 stabstr_C (DECL_ACCESSIBILITY_CHAR (decl
));
1517 if (DECL_VINDEX (decl
) && host_integerp (DECL_VINDEX (decl
), 0))
1519 stabstr_D (tree_low_cst (DECL_VINDEX (decl
), 0));
1521 dbxout_type (DECL_CONTEXT (decl
), 0);
1526 /* Subroutine of `dbxout_type'. Output debug info about the methods defined
1530 dbxout_type_methods (tree type
)
1532 /* C++: put out the method names and their parameter lists */
1533 tree methods
= TYPE_METHODS (type
);
1537 if (methods
== NULL_TREE
)
1540 if (TREE_CODE (methods
) != TREE_VEC
)
1542 else if (TREE_VEC_ELT (methods
, 0) != NULL_TREE
)
1543 fndecl
= TREE_VEC_ELT (methods
, 0);
1545 fndecl
= TREE_VEC_ELT (methods
, 1);
1549 int need_prefix
= 1;
1551 /* Group together all the methods for the same operation.
1552 These differ in the types of the arguments. */
1553 for (last
= NULL_TREE
;
1554 fndecl
&& (last
== NULL_TREE
|| DECL_NAME (fndecl
) == DECL_NAME (last
));
1555 fndecl
= TREE_CHAIN (fndecl
))
1556 /* Output the name of the field (after overloading), as
1557 well as the name of the field before overloading, along
1558 with its parameter list */
1560 /* Skip methods that aren't FUNCTION_DECLs. (In C++, these
1561 include TEMPLATE_DECLs.) The debugger doesn't know what
1562 to do with such entities anyhow. */
1563 if (TREE_CODE (fndecl
) != FUNCTION_DECL
)
1570 /* Also ignore abstract methods; those are only interesting to
1571 the DWARF backends. */
1572 if (DECL_IGNORED_P (fndecl
) || DECL_ABSTRACT (fndecl
))
1575 /* Redundantly output the plain name, since that's what gdb
1579 stabstr_I (DECL_NAME (fndecl
));
1584 dbxout_type (TREE_TYPE (fndecl
), 0);
1585 dbxout_type_method_1 (fndecl
);
1592 /* Emit a "range" type specification, which has the form:
1593 "r<index type>;<lower bound>;<upper bound>;".
1594 TYPE is an INTEGER_TYPE, LOW and HIGH are the bounds. */
1597 dbxout_range_type (tree type
, tree low
, tree high
)
1600 if (TREE_TYPE (type
))
1601 dbxout_type (TREE_TYPE (type
), 0);
1602 else if (TREE_CODE (type
) != INTEGER_TYPE
)
1603 dbxout_type (type
, 0); /* E.g. Pascal's ARRAY [BOOLEAN] of INTEGER */
1606 /* Traditionally, we made sure 'int' was type 1, and builtin types
1607 were defined to be sub-ranges of int. Unfortunately, this
1608 does not allow us to distinguish true sub-ranges from integer
1609 types. So, instead we define integer (non-sub-range) types as
1610 sub-ranges of themselves. This matters for Chill. If this isn't
1611 a subrange type, then we want to define it in terms of itself.
1612 However, in C, this may be an anonymous integer type, and we don't
1613 want to emit debug info referring to it. Just calling
1614 dbxout_type_index won't work anyways, because the type hasn't been
1615 defined yet. We make this work for both cases by checked to see
1616 whether this is a defined type, referring to it if it is, and using
1618 if (TYPE_SYMTAB_ADDRESS (type
) != 0)
1619 dbxout_type_index (type
);
1621 dbxout_type_index (integer_type_node
);
1625 if (low
&& host_integerp (low
, 0))
1627 if (print_int_cst_bounds_in_octal_p (type
, low
, high
))
1630 stabstr_D (tree_low_cst (low
, 0));
1636 if (high
&& host_integerp (high
, 0))
1638 if (print_int_cst_bounds_in_octal_p (type
, low
, high
))
1641 stabstr_D (tree_low_cst (high
, 0));
1649 /* Output a reference to a type. If the type has not yet been
1650 described in the dbx output, output its definition now.
1651 For a type already defined, just refer to its definition
1652 using the type number.
1654 If FULL is nonzero, and the type has been described only with
1655 a forward-reference, output the definition now.
1656 If FULL is zero in this case, just refer to the forward-reference
1657 using the number previously allocated. */
1660 dbxout_type (tree type
, int full
)
1662 static int anonymous_type_number
= 0;
1663 bool vector_type
= false;
1664 tree tem
, main_variant
, low
, high
;
1666 if (TREE_CODE (type
) == VECTOR_TYPE
)
1668 /* The frontend feeds us a representation for the vector as a struct
1669 containing an array. Pull out the array type. */
1670 type
= TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type
)));
1674 if (TREE_CODE (type
) == INTEGER_TYPE
)
1676 if (TREE_TYPE (type
) == 0)
1678 low
= TYPE_MIN_VALUE (type
);
1679 high
= TYPE_MAX_VALUE (type
);
1682 else if (subrange_type_for_debug_p (type
, &low
, &high
))
1685 /* If this is a subtype that should not be emitted as a subrange type,
1686 use the base type. */
1689 type
= TREE_TYPE (type
);
1690 low
= TYPE_MIN_VALUE (type
);
1691 high
= TYPE_MAX_VALUE (type
);
1695 /* If there was an input error and we don't really have a type,
1696 avoid crashing and write something that is at least valid
1697 by assuming `int'. */
1698 if (type
== error_mark_node
)
1699 type
= integer_type_node
;
1702 if (TYPE_NAME (type
)
1703 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1704 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type
)))
1708 /* Try to find the "main variant" with the same name. */
1709 if (TYPE_NAME (type
) && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1710 && DECL_ORIGINAL_TYPE (TYPE_NAME (type
)))
1711 main_variant
= TREE_TYPE (TYPE_NAME (type
));
1713 main_variant
= TYPE_MAIN_VARIANT (type
);
1715 /* If we are not using extensions, stabs does not distinguish const and
1716 volatile, so there is no need to make them separate types. */
1717 if (!use_gnu_debug_info_extensions
)
1718 type
= main_variant
;
1720 if (TYPE_SYMTAB_ADDRESS (type
) == 0)
1722 /* Type has no dbx number assigned. Assign next available number. */
1723 TYPE_SYMTAB_ADDRESS (type
) = next_type_number
++;
1725 /* Make sure type vector is long enough to record about this type. */
1727 if (next_type_number
== typevec_len
)
1729 typevec
= GGC_RESIZEVEC (struct typeinfo
, typevec
, typevec_len
* 2);
1730 memset (typevec
+ typevec_len
, 0, typevec_len
* sizeof typevec
[0]);
1734 #ifdef DBX_USE_BINCL
1735 emit_pending_bincls_if_required ();
1736 typevec
[TYPE_SYMTAB_ADDRESS (type
)].file_number
1737 = current_file
->file_number
;
1738 typevec
[TYPE_SYMTAB_ADDRESS (type
)].type_number
1739 = current_file
->next_type_number
++;
1743 if (flag_debug_only_used_symbols
)
1745 if ((TREE_CODE (type
) == RECORD_TYPE
1746 || TREE_CODE (type
) == UNION_TYPE
1747 || TREE_CODE (type
) == QUAL_UNION_TYPE
1748 || TREE_CODE (type
) == ENUMERAL_TYPE
)
1749 && TYPE_STUB_DECL (type
)
1750 && DECL_P (TYPE_STUB_DECL (type
))
1751 && ! DECL_IGNORED_P (TYPE_STUB_DECL (type
)))
1752 debug_queue_symbol (TYPE_STUB_DECL (type
));
1753 else if (TYPE_NAME (type
)
1754 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
1755 debug_queue_symbol (TYPE_NAME (type
));
1758 /* Output the number of this type, to refer to it. */
1759 dbxout_type_index (type
);
1761 #ifdef DBX_TYPE_DEFINED
1762 if (DBX_TYPE_DEFINED (type
))
1766 /* If this type's definition has been output or is now being output,
1769 switch (typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
)
1774 /* If we have already had a cross reference,
1775 and either that's all we want or that's the best we could do,
1776 don't repeat the cross reference.
1777 Sun dbx crashes if we do. */
1778 if (! full
|| !COMPLETE_TYPE_P (type
)
1779 /* No way in DBX fmt to describe a variable size. */
1780 || ! host_integerp (TYPE_SIZE (type
), 1))
1788 /* For systems where dbx output does not allow the `=xsNAME:' syntax,
1789 leave the type-number completely undefined rather than output
1790 a cross-reference. If we have already used GNU debug info extensions,
1791 then it is OK to output a cross reference. This is necessary to get
1792 proper C++ debug output. */
1793 if ((TREE_CODE (type
) == RECORD_TYPE
|| TREE_CODE (type
) == UNION_TYPE
1794 || TREE_CODE (type
) == QUAL_UNION_TYPE
1795 || TREE_CODE (type
) == ENUMERAL_TYPE
)
1796 && ! use_gnu_debug_info_extensions
)
1797 /* We must use the same test here as we use twice below when deciding
1798 whether to emit a cross-reference. */
1799 if ((TYPE_NAME (type
) != 0
1800 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1801 && DECL_IGNORED_P (TYPE_NAME (type
)))
1803 || !COMPLETE_TYPE_P (type
)
1804 /* No way in DBX fmt to describe a variable size. */
1805 || ! host_integerp (TYPE_SIZE (type
), 1))
1807 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1812 /* Output a definition now. */
1815 /* Mark it as defined, so that if it is self-referent
1816 we will not get into an infinite recursion of definitions. */
1818 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_DEFINED
;
1820 /* If this type is a variant of some other, hand off. Types with
1821 different names are usefully distinguished. We only distinguish
1822 cv-qualified types if we're using extensions. */
1823 if (TYPE_READONLY (type
) > TYPE_READONLY (main_variant
))
1826 dbxout_type (build_type_variant (type
, 0, TYPE_VOLATILE (type
)), 0);
1829 else if (TYPE_VOLATILE (type
) > TYPE_VOLATILE (main_variant
))
1832 dbxout_type (build_type_variant (type
, TYPE_READONLY (type
), 0), 0);
1835 else if (main_variant
!= TYPE_MAIN_VARIANT (type
))
1837 if (flag_debug_only_used_symbols
)
1839 tree orig_type
= DECL_ORIGINAL_TYPE (TYPE_NAME (type
));
1841 if ((TREE_CODE (orig_type
) == RECORD_TYPE
1842 || TREE_CODE (orig_type
) == UNION_TYPE
1843 || TREE_CODE (orig_type
) == QUAL_UNION_TYPE
1844 || TREE_CODE (orig_type
) == ENUMERAL_TYPE
)
1845 && TYPE_STUB_DECL (orig_type
)
1846 && ! DECL_IGNORED_P (TYPE_STUB_DECL (orig_type
)))
1847 debug_queue_symbol (TYPE_STUB_DECL (orig_type
));
1849 /* 'type' is a typedef; output the type it refers to. */
1850 dbxout_type (DECL_ORIGINAL_TYPE (TYPE_NAME (type
)), 0);
1853 /* else continue. */
1855 switch (TREE_CODE (type
))
1859 /* For a void type, just define it as itself; i.e., "5=5".
1860 This makes us consider it defined
1861 without saying what it is. The debugger will make it
1862 a void type when the reference is seen, and nothing will
1863 ever override that default. */
1864 dbxout_type_index (type
);
1868 if (type
== char_type_node
&& ! TYPE_UNSIGNED (type
))
1870 /* Output the type `char' as a subrange of itself!
1871 I don't understand this definition, just copied it
1872 from the output of pcc.
1873 This used to use `r2' explicitly and we used to
1874 take care to make sure that `char' was type number 2. */
1876 dbxout_type_index (type
);
1877 stabstr_S (";0;127;");
1880 /* If this is a subtype of another integer type, always prefer to
1881 write it as a subtype. */
1882 else if (TREE_TYPE (type
) != 0
1883 && TREE_CODE (TREE_TYPE (type
)) == INTEGER_TYPE
)
1885 /* If the size is non-standard, say what it is if we can use
1888 if (use_gnu_debug_info_extensions
1889 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
1892 stabstr_D (TYPE_PRECISION (type
));
1896 dbxout_range_type (type
, low
, high
);
1901 /* If the size is non-standard, say what it is if we can use
1904 if (use_gnu_debug_info_extensions
1905 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
1908 stabstr_D (TYPE_PRECISION (type
));
1912 if (print_int_cst_bounds_in_octal_p (type
, low
, high
))
1916 /* If this type derives from another type, output type index of
1917 parent type. This is particularly important when parent type
1918 is an enumerated type, because not generating the parent type
1919 index would transform the definition of this enumerated type
1920 into a plain unsigned type. */
1921 if (TREE_TYPE (type
) != 0)
1922 dbxout_type_index (TREE_TYPE (type
));
1924 dbxout_type_index (type
);
1934 /* Output other integer types as subranges of `int'. */
1935 dbxout_range_type (type
, low
, high
);
1941 case FIXED_POINT_TYPE
:
1942 /* This used to say `r1' and we used to take care
1943 to make sure that `int' was type number 1. */
1945 dbxout_type_index (integer_type_node
);
1947 stabstr_D (int_size_in_bytes (type
));
1952 if (use_gnu_debug_info_extensions
)
1955 stabstr_D (BITS_PER_UNIT
* int_size_in_bytes (type
));
1956 stabstr_S (";-16;");
1958 else /* Define as enumeral type (False, True) */
1959 stabstr_S ("eFalse:0,True:1,;");
1963 /* Differs from the REAL_TYPE by its new data type number.
1964 R3 is NF_COMPLEX. We don't try to use any of the other NF_*
1965 codes since gdb doesn't care anyway. */
1967 if (TREE_CODE (TREE_TYPE (type
)) == REAL_TYPE
)
1970 stabstr_D (2 * int_size_in_bytes (TREE_TYPE (type
)));
1975 /* Output a complex integer type as a structure,
1976 pending some other way to do it. */
1978 stabstr_D (int_size_in_bytes (type
));
1980 stabstr_S ("real:");
1981 dbxout_type (TREE_TYPE (type
), 0);
1983 stabstr_D (TYPE_PRECISION (TREE_TYPE (type
)));
1985 stabstr_S (";imag:");
1986 dbxout_type (TREE_TYPE (type
), 0);
1988 stabstr_D (TYPE_PRECISION (TREE_TYPE (type
)));
1990 stabstr_D (TYPE_PRECISION (TREE_TYPE (type
)));
1996 /* Make arrays of packed bits look like bitstrings for chill. */
1997 if (TYPE_PACKED (type
) && use_gnu_debug_info_extensions
)
2000 stabstr_D (BITS_PER_UNIT
* int_size_in_bytes (type
));
2001 stabstr_S (";@S;S");
2002 dbxout_type (TYPE_DOMAIN (type
), 0);
2006 if (use_gnu_debug_info_extensions
&& vector_type
)
2009 /* Output "a" followed by a range type definition
2010 for the index type of the array
2011 followed by a reference to the target-type.
2012 ar1;0;N;M for a C array of type M and size N+1. */
2013 /* Check if a character string type, which in Chill is
2014 different from an array of characters. */
2015 if (TYPE_STRING_FLAG (type
) && use_gnu_debug_info_extensions
)
2019 tem
= TYPE_DOMAIN (type
);
2023 dbxout_type_index (integer_type_node
);
2024 stabstr_S (";0;-1;");
2029 dbxout_range_type (tem
, TYPE_MIN_VALUE (tem
), TYPE_MAX_VALUE (tem
));
2032 dbxout_type (TREE_TYPE (type
), 0);
2037 case QUAL_UNION_TYPE
:
2039 tree binfo
= TYPE_BINFO (type
);
2041 /* Output a structure type. We must use the same test here as we
2042 use in the DBX_NO_XREFS case above. */
2043 if ((TYPE_NAME (type
) != 0
2044 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
2045 && DECL_IGNORED_P (TYPE_NAME (type
)))
2047 || !COMPLETE_TYPE_P (type
)
2048 /* No way in DBX fmt to describe a variable size. */
2049 || ! host_integerp (TYPE_SIZE (type
), 1))
2051 /* If the type is just a cross reference, output one
2052 and mark the type as partially described.
2053 If it later becomes defined, we will output
2054 its real definition.
2055 If the type has a name, don't nest its definition within
2056 another type's definition; instead, output an xref
2057 and let the definition come when the name is defined. */
2058 stabstr_S ((TREE_CODE (type
) == RECORD_TYPE
) ? "xs" : "xu");
2059 if (TYPE_NAME (type
) != 0
2060 /* The C frontend creates for anonymous variable length
2061 records/unions TYPE_NAME with DECL_NAME NULL. */
2062 && (TREE_CODE (TYPE_NAME (type
)) != TYPE_DECL
2063 || DECL_NAME (TYPE_NAME (type
))))
2064 dbxout_type_name (type
);
2068 stabstr_D (anonymous_type_number
++);
2072 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
2076 /* Identify record or union, and print its size. */
2077 stabstr_C ((TREE_CODE (type
) == RECORD_TYPE
) ? 's' : 'u');
2078 stabstr_D (int_size_in_bytes (type
));
2084 VEC(tree
,gc
) *accesses
= BINFO_BASE_ACCESSES (binfo
);
2086 if (use_gnu_debug_info_extensions
)
2088 if (BINFO_N_BASE_BINFOS (binfo
))
2091 stabstr_U (BINFO_N_BASE_BINFOS (binfo
));
2095 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, child
); i
++)
2097 tree access
= (accesses
? VEC_index (tree
, accesses
, i
)
2098 : access_public_node
);
2100 if (use_gnu_debug_info_extensions
)
2102 stabstr_C (BINFO_VIRTUAL_P (child
) ? '1' : '0');
2103 stabstr_C (access
== access_public_node
? '2' :
2104 access
== access_protected_node
2106 if (BINFO_VIRTUAL_P (child
)
2107 && (strcmp (lang_hooks
.name
, "GNU C++") == 0
2108 || strcmp (lang_hooks
.name
, "GNU Objective-C++") == 0))
2109 /* For a virtual base, print the (negative)
2110 offset within the vtable where we must look
2111 to find the necessary adjustment. */
2113 (tree_low_cst (BINFO_VPTR_FIELD (child
), 0)
2116 stabstr_D (tree_low_cst (BINFO_OFFSET (child
), 0)
2119 dbxout_type (BINFO_TYPE (child
), 0);
2124 /* Print out the base class information with
2125 fields which have the same names at the types
2127 dbxout_type_name (BINFO_TYPE (child
));
2129 dbxout_type (BINFO_TYPE (child
), full
);
2131 stabstr_D (tree_low_cst (BINFO_OFFSET (child
), 0)
2135 (tree_low_cst (TYPE_SIZE (BINFO_TYPE (child
)), 0)
2143 /* Write out the field declarations. */
2144 dbxout_type_fields (type
);
2145 if (use_gnu_debug_info_extensions
&& TYPE_METHODS (type
) != NULL_TREE
)
2147 dbxout_type_methods (type
);
2152 if (use_gnu_debug_info_extensions
&& TREE_CODE (type
) == RECORD_TYPE
2153 /* Avoid the ~ if we don't really need it--it confuses dbx. */
2154 && TYPE_VFIELD (type
))
2157 /* We need to write out info about what field this class
2158 uses as its "main" vtable pointer field, because if this
2159 field is inherited from a base class, GDB cannot necessarily
2160 figure out which field it's using in time. */
2162 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type
)), 0);
2168 /* We must use the same test here as we use in the DBX_NO_XREFS case
2169 above. We simplify it a bit since an enum will never have a variable
2171 if ((TYPE_NAME (type
) != 0
2172 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
2173 && DECL_IGNORED_P (TYPE_NAME (type
)))
2175 || !COMPLETE_TYPE_P (type
))
2178 dbxout_type_name (type
);
2179 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
2183 if (use_gnu_debug_info_extensions
2184 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
2187 stabstr_D (TYPE_PRECISION (type
));
2192 for (tem
= TYPE_VALUES (type
); tem
; tem
= TREE_CHAIN (tem
))
2194 tree value
= TREE_VALUE (tem
);
2196 stabstr_I (TREE_PURPOSE (tem
));
2199 if (TREE_CODE (value
) == CONST_DECL
)
2200 value
= DECL_INITIAL (value
);
2202 if (TREE_INT_CST_HIGH (value
) == 0)
2203 stabstr_D (TREE_INT_CST_LOW (value
));
2204 else if (TREE_INT_CST_HIGH (value
) == -1
2205 && (HOST_WIDE_INT
) TREE_INT_CST_LOW (value
) < 0)
2206 stabstr_D (TREE_INT_CST_LOW (value
));
2211 if (TREE_CHAIN (tem
) != 0)
2220 dbxout_type (TREE_TYPE (type
), 0);
2224 if (use_gnu_debug_info_extensions
)
2228 /* Write the argument types out longhand. */
2229 dbxout_type (TYPE_METHOD_BASETYPE (type
), 0);
2231 dbxout_type (TREE_TYPE (type
), 0);
2232 dbxout_args (TYPE_ARG_TYPES (type
));
2236 /* Treat it as a function type. */
2237 dbxout_type (TREE_TYPE (type
), 0);
2241 if (use_gnu_debug_info_extensions
)
2244 dbxout_type (TYPE_OFFSET_BASETYPE (type
), 0);
2246 dbxout_type (TREE_TYPE (type
), 0);
2249 /* Should print as an int, because it is really just an offset. */
2250 dbxout_type (integer_type_node
, 0);
2253 case REFERENCE_TYPE
:
2254 if (use_gnu_debug_info_extensions
)
2260 dbxout_type (TREE_TYPE (type
), 0);
2265 dbxout_type (TREE_TYPE (type
), 0);
2273 /* Return nonzero if the given type represents an integer whose bounds
2274 should be printed in octal format. */
2277 print_int_cst_bounds_in_octal_p (tree type
, tree low
, tree high
)
2279 /* If we can use GDB extensions and the size is wider than a long
2280 (the size used by GDB to read them) or we may have trouble writing
2281 the bounds the usual way, write them in octal. Note the test is for
2282 the *target's* size of "long", not that of the host. The host test
2283 is just to make sure we can write it out in case the host wide int
2284 is narrower than the target "long".
2286 For unsigned types, we use octal if they are the same size or larger.
2287 This is because we print the bounds as signed decimal, and hence they
2288 can't span same size unsigned types. */
2290 if (use_gnu_debug_info_extensions
2291 && low
&& TREE_CODE (low
) == INTEGER_CST
2292 && high
&& TREE_CODE (high
) == INTEGER_CST
2293 && (TYPE_PRECISION (type
) > TYPE_PRECISION (integer_type_node
)
2294 || ((TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
))
2295 && TYPE_UNSIGNED (type
))
2296 || TYPE_PRECISION (type
) > HOST_BITS_PER_WIDE_INT
2297 || (TYPE_PRECISION (type
) == HOST_BITS_PER_WIDE_INT
2298 && TYPE_UNSIGNED (type
))))
2304 /* Output the name of type TYPE, with no punctuation.
2305 Such names can be set up either by typedef declarations
2306 or by struct, enum and union tags. */
2309 dbxout_type_name (tree type
)
2311 tree t
= TYPE_NAME (type
);
2314 switch (TREE_CODE (t
))
2316 case IDENTIFIER_NODE
:
2328 /* Output leading leading struct or class names needed for qualifying
2329 type whose scope is limited to a struct or class. */
2332 dbxout_class_name_qualifiers (tree decl
)
2334 tree context
= decl_type_context (decl
);
2336 if (context
!= NULL_TREE
2337 && TREE_CODE(context
) == RECORD_TYPE
2338 && TYPE_NAME (context
) != 0
2339 && (TREE_CODE (TYPE_NAME (context
)) == IDENTIFIER_NODE
2340 || (DECL_NAME (TYPE_NAME (context
)) != 0)))
2342 tree name
= TYPE_NAME (context
);
2344 if (TREE_CODE (name
) == TYPE_DECL
)
2346 dbxout_class_name_qualifiers (name
);
2347 name
= DECL_NAME (name
);
2354 /* This is a specialized subset of expand_expr for use by dbxout_symbol in
2355 evaluating DECL_VALUE_EXPR. In particular, we stop if we find decls that
2356 haven't been expanded, or if the expression is getting so complex we won't
2357 be able to represent it in stabs anyway. Returns NULL on failure. */
2360 dbxout_expand_expr (tree expr
)
2362 switch (TREE_CODE (expr
))
2365 /* We can't handle emulated tls variables, because the address is an
2366 offset to the return value of __emutls_get_address, and there is no
2367 way to express that in stabs. Also, there are name mangling issues
2368 here. We end up with references to undefined symbols if we don't
2369 disable debug info for these variables. */
2370 if (!targetm
.have_tls
&& DECL_THREAD_LOCAL_P (expr
))
2375 if (DECL_HAS_VALUE_EXPR_P (expr
))
2376 return dbxout_expand_expr (DECL_VALUE_EXPR (expr
));
2381 return DECL_RTL_IF_SET (expr
);
2384 return expand_expr (expr
, NULL_RTX
, VOIDmode
, EXPAND_INITIALIZER
);
2388 case ARRAY_RANGE_REF
:
2391 enum machine_mode mode
;
2392 HOST_WIDE_INT bitsize
, bitpos
;
2394 int volatilep
= 0, unsignedp
= 0;
2397 tem
= get_inner_reference (expr
, &bitsize
, &bitpos
, &offset
,
2398 &mode
, &unsignedp
, &volatilep
, true);
2400 x
= dbxout_expand_expr (tem
);
2401 if (x
== NULL
|| !MEM_P (x
))
2405 if (!host_integerp (offset
, 0))
2407 x
= adjust_address_nv (x
, mode
, tree_low_cst (offset
, 0));
2410 x
= adjust_address_nv (x
, mode
, bitpos
/ BITS_PER_UNIT
);
2420 /* Helper function for output_used_types. Queue one entry from the
2421 used types hash to be output. */
2424 output_used_types_helper (void **slot
, void *data
)
2426 tree type
= (tree
) *slot
;
2427 VEC(tree
, heap
) **types_p
= (VEC(tree
, heap
) **) data
;
2429 if ((TREE_CODE (type
) == RECORD_TYPE
2430 || TREE_CODE (type
) == UNION_TYPE
2431 || TREE_CODE (type
) == QUAL_UNION_TYPE
2432 || TREE_CODE (type
) == ENUMERAL_TYPE
)
2433 && TYPE_STUB_DECL (type
)
2434 && DECL_P (TYPE_STUB_DECL (type
))
2435 && ! DECL_IGNORED_P (TYPE_STUB_DECL (type
)))
2436 VEC_quick_push (tree
, *types_p
, TYPE_STUB_DECL (type
));
2437 else if (TYPE_NAME (type
)
2438 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
2439 VEC_quick_push (tree
, *types_p
, TYPE_NAME (type
));
2444 /* This is a qsort callback which sorts types and declarations into a
2445 predictable order (types, then declarations, sorted by UID
2449 output_types_sort (const void *pa
, const void *pb
)
2451 const tree lhs
= *((const tree
*)pa
);
2452 const tree rhs
= *((const tree
*)pb
);
2457 return TYPE_UID (lhs
) - TYPE_UID (rhs
);
2466 return DECL_UID (lhs
) - DECL_UID (rhs
);
2471 /* Force all types used by this function to be output in debug
2475 output_used_types (void)
2477 if (cfun
&& cfun
->used_types_hash
)
2479 VEC(tree
, heap
) *types
;
2483 types
= VEC_alloc (tree
, heap
, htab_elements (cfun
->used_types_hash
));
2484 htab_traverse (cfun
->used_types_hash
, output_used_types_helper
, &types
);
2486 /* Sort by UID to prevent dependence on hash table ordering. */
2487 qsort (VEC_address (tree
, types
), VEC_length (tree
, types
),
2488 sizeof (tree
), output_types_sort
);
2490 for (i
= 0; VEC_iterate (tree
, types
, i
, type
); i
++)
2491 debug_queue_symbol (type
);
2493 VEC_free (tree
, heap
, types
);
2497 /* Output a .stabs for the symbol defined by DECL,
2498 which must be a ..._DECL node in the normal namespace.
2499 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
2500 LOCAL is nonzero if the scope is less than the entire file.
2501 Return 1 if a stabs might have been emitted. */
2504 dbxout_symbol (tree decl
, int local ATTRIBUTE_UNUSED
)
2506 tree type
= TREE_TYPE (decl
);
2507 tree context
= NULL_TREE
;
2511 /* "Intercept" dbxout_symbol() calls like we do all debug_hooks. */
2514 /* Ignore nameless syms, but don't ignore type tags. */
2516 if ((DECL_NAME (decl
) == 0 && TREE_CODE (decl
) != TYPE_DECL
)
2517 || DECL_IGNORED_P (decl
))
2518 DBXOUT_DECR_NESTING_AND_RETURN (0);
2520 /* If we are to generate only the symbols actually used then such
2521 symbol nodes are flagged with TREE_USED. Ignore any that
2522 aren't flagged as TREE_USED. */
2524 if (flag_debug_only_used_symbols
2525 && (!TREE_USED (decl
)
2526 && (TREE_CODE (decl
) != VAR_DECL
|| !DECL_INITIAL (decl
))))
2527 DBXOUT_DECR_NESTING_AND_RETURN (0);
2529 /* If dbxout_init has not yet run, queue this symbol for later. */
2532 preinit_symbols
= tree_cons (0, decl
, preinit_symbols
);
2533 DBXOUT_DECR_NESTING_AND_RETURN (0);
2536 if (flag_debug_only_used_symbols
)
2540 /* We now have a used symbol. We need to generate the info for
2541 the symbol's type in addition to the symbol itself. These
2542 type symbols are queued to be generated after were done with
2543 the symbol itself (otherwise they would fight over the
2546 Note, because the TREE_TYPE(type) might be something like a
2547 pointer to a named type we need to look for the first name
2548 we see following the TREE_TYPE chain. */
2551 while (POINTER_TYPE_P (t
))
2554 /* RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, and ENUMERAL_TYPE
2555 need special treatment. The TYPE_STUB_DECL field in these
2556 types generally represents the tag name type we want to
2557 output. In addition there could be a typedef type with
2558 a different name. In that case we also want to output
2561 if (TREE_CODE (t
) == RECORD_TYPE
2562 || TREE_CODE (t
) == UNION_TYPE
2563 || TREE_CODE (t
) == QUAL_UNION_TYPE
2564 || TREE_CODE (t
) == ENUMERAL_TYPE
)
2566 if (TYPE_STUB_DECL (t
)
2567 && TYPE_STUB_DECL (t
) != decl
2568 && DECL_P (TYPE_STUB_DECL (t
))
2569 && ! DECL_IGNORED_P (TYPE_STUB_DECL (t
)))
2571 debug_queue_symbol (TYPE_STUB_DECL (t
));
2573 && TYPE_NAME (t
) != TYPE_STUB_DECL (t
)
2574 && TYPE_NAME (t
) != decl
2575 && DECL_P (TYPE_NAME (t
)))
2576 debug_queue_symbol (TYPE_NAME (t
));
2579 else if (TYPE_NAME (t
)
2580 && TYPE_NAME (t
) != decl
2581 && DECL_P (TYPE_NAME (t
)))
2582 debug_queue_symbol (TYPE_NAME (t
));
2585 emit_pending_bincls_if_required ();
2587 switch (TREE_CODE (decl
))
2590 /* Enum values are defined by defining the enum type. */
2594 decl_rtl
= DECL_RTL_IF_SET (decl
);
2596 DBXOUT_DECR_NESTING_AND_RETURN (0);
2597 if (DECL_EXTERNAL (decl
))
2599 /* Don't mention a nested function under its parent. */
2600 context
= decl_function_context (decl
);
2601 if (context
== current_function_decl
)
2603 /* Don't mention an inline instance of a nested function. */
2604 if (context
&& DECL_FROM_INLINE (decl
))
2606 if (!MEM_P (decl_rtl
)
2607 || GET_CODE (XEXP (decl_rtl
, 0)) != SYMBOL_REF
)
2610 if (flag_debug_only_used_symbols
)
2611 output_used_types ();
2613 dbxout_begin_complex_stabs ();
2614 stabstr_I (DECL_ASSEMBLER_NAME (decl
));
2615 stabstr_S (TREE_PUBLIC (decl
) ? ":F" : ":f");
2618 if (TREE_TYPE (type
))
2619 dbxout_type (TREE_TYPE (type
), 0);
2621 dbxout_type (void_type_node
, 0);
2623 /* For a nested function, when that function is compiled,
2624 mention the containing function name
2625 as well as (since dbx wants it) our own assembler-name. */
2629 stabstr_I (DECL_ASSEMBLER_NAME (decl
));
2631 stabstr_I (DECL_NAME (context
));
2634 dbxout_finish_complex_stabs (decl
, N_FUN
, XEXP (decl_rtl
, 0), 0, 0);
2638 /* Don't output the same typedef twice.
2639 And don't output what language-specific stuff doesn't want output. */
2640 if (TREE_ASM_WRITTEN (decl
) || TYPE_DECL_SUPPRESS_DEBUG (decl
))
2641 DBXOUT_DECR_NESTING_AND_RETURN (0);
2643 /* Don't output typedefs for types with magic type numbers (XCOFF). */
2644 #ifdef DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER
2646 int fundamental_type_number
=
2647 DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER (decl
);
2649 if (fundamental_type_number
!= 0)
2651 TREE_ASM_WRITTEN (decl
) = 1;
2652 TYPE_SYMTAB_ADDRESS (TREE_TYPE (decl
)) = fundamental_type_number
;
2653 DBXOUT_DECR_NESTING_AND_RETURN (0);
2663 if (DECL_NAME (decl
))
2665 /* Nonzero means we must output a tag as well as a typedef. */
2668 /* Handle the case of a C++ structure or union
2669 where the TYPE_NAME is a TYPE_DECL
2670 which gives both a typedef name and a tag. */
2671 /* dbx requires the tag first and the typedef second. */
2672 if ((TREE_CODE (type
) == RECORD_TYPE
2673 || TREE_CODE (type
) == UNION_TYPE
2674 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
2675 && TYPE_NAME (type
) == decl
2676 && !use_gnu_debug_info_extensions
2677 && !TREE_ASM_WRITTEN (TYPE_NAME (type
))
2678 /* Distinguish the implicit typedefs of C++
2679 from explicit ones that might be found in C. */
2680 && DECL_ARTIFICIAL (decl
)
2681 /* Do not generate a tag for incomplete records. */
2682 && COMPLETE_TYPE_P (type
)
2683 /* Do not generate a tag for records of variable size,
2684 since this type can not be properly described in the
2685 DBX format, and it confuses some tools such as objdump. */
2686 && host_integerp (TYPE_SIZE (type
), 1))
2688 tree name
= TYPE_NAME (type
);
2689 if (TREE_CODE (name
) == TYPE_DECL
)
2690 name
= DECL_NAME (name
);
2692 dbxout_begin_complex_stabs ();
2695 dbxout_type (type
, 1);
2696 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE
,
2700 dbxout_begin_complex_stabs ();
2702 /* Output leading class/struct qualifiers. */
2703 if (use_gnu_debug_info_extensions
)
2704 dbxout_class_name_qualifiers (decl
);
2706 /* Output typedef name. */
2707 stabstr_I (DECL_NAME (decl
));
2710 /* Short cut way to output a tag also. */
2711 if ((TREE_CODE (type
) == RECORD_TYPE
2712 || TREE_CODE (type
) == UNION_TYPE
2713 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
2714 && TYPE_NAME (type
) == decl
2715 /* Distinguish the implicit typedefs of C++
2716 from explicit ones that might be found in C. */
2717 && DECL_ARTIFICIAL (decl
))
2719 if (use_gnu_debug_info_extensions
)
2722 TREE_ASM_WRITTEN (TYPE_NAME (type
)) = 1;
2727 dbxout_type (type
, 1);
2728 dbxout_finish_complex_stabs (decl
, DBX_TYPE_DECL_STABS_CODE
,
2733 /* Don't output a tag if this is an incomplete type. This prevents
2734 the sun4 Sun OS 4.x dbx from crashing. */
2736 if (tag_needed
&& TYPE_NAME (type
) != 0
2737 && (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
2738 || (DECL_NAME (TYPE_NAME (type
)) != 0))
2739 && COMPLETE_TYPE_P (type
)
2740 && !TREE_ASM_WRITTEN (TYPE_NAME (type
)))
2742 /* For a TYPE_DECL with no name, but the type has a name,
2744 This is what represents `struct foo' with no typedef. */
2745 /* In C++, the name of a type is the corresponding typedef.
2746 In C, it is an IDENTIFIER_NODE. */
2747 tree name
= TYPE_NAME (type
);
2748 if (TREE_CODE (name
) == TYPE_DECL
)
2749 name
= DECL_NAME (name
);
2751 dbxout_begin_complex_stabs ();
2754 dbxout_type (type
, 1);
2755 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE
, 0, 0, 0);
2759 /* If an enum type has no name, it cannot be referred to, but
2760 we must output it anyway, to record the enumeration
2763 if (!did_output
&& TREE_CODE (type
) == ENUMERAL_TYPE
)
2765 dbxout_begin_complex_stabs ();
2766 /* Some debuggers fail when given NULL names, so give this a
2767 harmless name of " " (Why not "(anon)"?). */
2769 dbxout_type (type
, 1);
2770 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE
, 0, 0, 0);
2773 /* Prevent duplicate output of a typedef. */
2774 TREE_ASM_WRITTEN (decl
) = 1;
2779 /* Parm decls go in their own separate chains
2780 and are output by dbxout_reg_parms and dbxout_parms. */
2785 /* Don't mention a variable that is external.
2786 Let the file that defines it describe it. */
2787 if (DECL_EXTERNAL (decl
))
2790 /* If the variable is really a constant
2791 and not written in memory, inform the debugger.
2793 ??? Why do we skip emitting the type and location in this case? */
2794 if (TREE_STATIC (decl
) && TREE_READONLY (decl
)
2795 && DECL_INITIAL (decl
) != 0
2796 && host_integerp (DECL_INITIAL (decl
), 0)
2797 && ! TREE_ASM_WRITTEN (decl
)
2798 && (DECL_CONTEXT (decl
) == NULL_TREE
2799 || TREE_CODE (DECL_CONTEXT (decl
)) == BLOCK
2800 || TREE_CODE (DECL_CONTEXT (decl
)) == NAMESPACE_DECL
)
2801 && TREE_PUBLIC (decl
) == 0)
2803 /* The sun4 assembler does not grok this. */
2805 if (TREE_CODE (TREE_TYPE (decl
)) == INTEGER_TYPE
2806 || TREE_CODE (TREE_TYPE (decl
)) == ENUMERAL_TYPE
)
2808 HOST_WIDE_INT ival
= TREE_INT_CST_LOW (DECL_INITIAL (decl
));
2810 dbxout_begin_complex_stabs ();
2811 dbxout_symbol_name (decl
, NULL
, 'c');
2814 dbxout_finish_complex_stabs (0, N_LSYM
, 0, 0, 0);
2815 DBXOUT_DECR_NESTING
;
2821 /* else it is something we handle like a normal variable. */
2823 decl_rtl
= dbxout_expand_expr (decl
);
2825 DBXOUT_DECR_NESTING_AND_RETURN (0);
2827 decl_rtl
= eliminate_regs (decl_rtl
, VOIDmode
, NULL_RTX
);
2828 #ifdef LEAF_REG_REMAP
2829 if (current_function_uses_only_leaf_regs
)
2830 leaf_renumber_regs_insn (decl_rtl
);
2833 result
= dbxout_symbol_location (decl
, type
, 0, decl_rtl
);
2839 DBXOUT_DECR_NESTING
;
2843 /* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL.
2844 Add SUFFIX to its name, if SUFFIX is not 0.
2845 Describe the variable as residing in HOME
2846 (usually HOME is DECL_RTL (DECL), but not always).
2847 Returns 1 if the stab was really emitted. */
2850 dbxout_symbol_location (tree decl
, tree type
, const char *suffix
, rtx home
)
2853 stab_code_type code
;
2858 /* Don't mention a variable at all
2859 if it was completely optimized into nothingness.
2861 If the decl was from an inline function, then its rtl
2862 is not identically the rtl that was used in this
2863 particular compilation. */
2864 if (GET_CODE (home
) == SUBREG
)
2868 while (GET_CODE (value
) == SUBREG
)
2869 value
= SUBREG_REG (value
);
2872 if (REGNO (value
) >= FIRST_PSEUDO_REGISTER
)
2875 home
= alter_subreg (&home
);
2879 regno
= REGNO (home
);
2880 if (regno
>= FIRST_PSEUDO_REGISTER
)
2884 /* The kind-of-variable letter depends on where
2885 the variable is and on the scope of its name:
2886 G and N_GSYM for static storage and global scope,
2887 S for static storage and file scope,
2888 V for static storage and local scope,
2889 for those two, use N_LCSYM if data is in bss segment,
2890 N_STSYM if in data segment, N_FUN otherwise.
2891 (We used N_FUN originally, then changed to N_STSYM
2892 to please GDB. However, it seems that confused ld.
2893 Now GDB has been fixed to like N_FUN, says Kingdon.)
2894 no letter at all, and N_LSYM, for auto variable,
2895 r and N_RSYM for register variable. */
2897 if (MEM_P (home
) && GET_CODE (XEXP (home
, 0)) == SYMBOL_REF
)
2899 if (TREE_PUBLIC (decl
))
2904 if (NULL
!= dbxout_common_check (decl
, &offs
))
2913 addr
= XEXP (home
, 0);
2915 letter
= decl_function_context (decl
) ? 'V' : 'S';
2917 /* Some ports can transform a symbol ref into a label ref,
2918 because the symbol ref is too far away and has to be
2919 dumped into a constant pool. Alternatively, the symbol
2920 in the constant pool might be referenced by a different
2922 if (GET_CODE (addr
) == SYMBOL_REF
2923 && CONSTANT_POOL_ADDRESS_P (addr
))
2926 rtx tmp
= get_pool_constant_mark (addr
, &marked
);
2928 if (GET_CODE (tmp
) == SYMBOL_REF
)
2931 if (CONSTANT_POOL_ADDRESS_P (addr
))
2932 get_pool_constant_mark (addr
, &marked
);
2936 else if (GET_CODE (tmp
) == LABEL_REF
)
2942 /* If all references to the constant pool were optimized
2943 out, we just ignore the symbol. */
2948 /* This should be the same condition as in assemble_variable, but
2949 we don't have access to dont_output_data here. So, instead,
2950 we rely on the fact that error_mark_node initializers always
2951 end up in bss for C++ and never end up in bss for C. */
2952 if (DECL_INITIAL (decl
) == 0
2953 || (!strcmp (lang_hooks
.name
, "GNU C++")
2954 && DECL_INITIAL (decl
) == error_mark_node
))
2958 if (NULL
!= dbxout_common_check (decl
, &offs
))
2966 else if (DECL_IN_TEXT_SECTION (decl
))
2967 /* This is not quite right, but it's the closest
2968 of all the codes that Unix defines. */
2969 code
= DBX_STATIC_CONST_VAR_CODE
;
2972 /* Ultrix `as' seems to need this. */
2973 #ifdef DBX_STATIC_STAB_DATA_SECTION
2974 switch_to_section (data_section
);
2980 else if (regno
>= 0)
2984 number
= DBX_REGISTER_NUMBER (regno
);
2986 else if (MEM_P (home
)
2987 && (MEM_P (XEXP (home
, 0))
2988 || (REG_P (XEXP (home
, 0))
2989 && REGNO (XEXP (home
, 0)) != HARD_FRAME_POINTER_REGNUM
2990 && REGNO (XEXP (home
, 0)) != STACK_POINTER_REGNUM
2991 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2992 && REGNO (XEXP (home
, 0)) != ARG_POINTER_REGNUM
2995 /* If the value is indirect by memory or by a register
2996 that isn't the frame pointer
2997 then it means the object is variable-sized and address through
2998 that register or stack slot. DBX has no way to represent this
2999 so all we can do is output the variable as a pointer.
3000 If it's not a parameter, ignore it. */
3002 if (REG_P (XEXP (home
, 0)))
3006 if (REGNO (XEXP (home
, 0)) >= FIRST_PSEUDO_REGISTER
)
3008 number
= DBX_REGISTER_NUMBER (REGNO (XEXP (home
, 0)));
3013 /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
3014 We want the value of that CONST_INT. */
3015 number
= DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home
, 0), 0));
3018 /* Effectively do build_pointer_type, but don't cache this type,
3019 since it might be temporary whereas the type it points to
3020 might have been saved for inlining. */
3021 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
3022 type
= make_node (POINTER_TYPE
);
3023 TREE_TYPE (type
) = TREE_TYPE (decl
);
3025 else if (MEM_P (home
)
3026 && REG_P (XEXP (home
, 0)))
3029 number
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
3031 else if (MEM_P (home
)
3032 && GET_CODE (XEXP (home
, 0)) == PLUS
3033 && GET_CODE (XEXP (XEXP (home
, 0), 1)) == CONST_INT
)
3036 /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
3037 We want the value of that CONST_INT. */
3038 number
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
3040 else if (MEM_P (home
)
3041 && GET_CODE (XEXP (home
, 0)) == CONST
)
3043 /* Handle an obscure case which can arise when optimizing and
3044 when there are few available registers. (This is *always*
3045 the case for i386/i486 targets). The RTL looks like
3046 (MEM (CONST ...)) even though this variable is a local `auto'
3047 or a local `register' variable. In effect, what has happened
3048 is that the reload pass has seen that all assignments and
3049 references for one such a local variable can be replaced by
3050 equivalent assignments and references to some static storage
3051 variable, thereby avoiding the need for a register. In such
3052 cases we're forced to lie to debuggers and tell them that
3053 this variable was itself `static'. */
3057 if (NULL
== dbxout_common_check (decl
, &offs
))
3058 addr
= XEXP (XEXP (home
, 0), 0);
3066 else if (GET_CODE (home
) == CONCAT
)
3070 /* If TYPE is not a COMPLEX_TYPE (it might be a RECORD_TYPE,
3071 for example), then there is no easy way to figure out
3072 what SUBTYPE should be. So, we give up. */
3073 if (TREE_CODE (type
) != COMPLEX_TYPE
)
3076 subtype
= TREE_TYPE (type
);
3078 /* If the variable's storage is in two parts,
3079 output each as a separate stab with a modified name. */
3080 if (WORDS_BIG_ENDIAN
)
3081 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 0));
3083 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 0));
3085 if (WORDS_BIG_ENDIAN
)
3086 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 1));
3088 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 1));
3092 /* Address might be a MEM, when DECL is a variable-sized object.
3093 Or it might be const0_rtx, meaning previous passes
3094 want us to ignore this variable. */
3097 /* Ok, start a symtab entry and output the variable name. */
3098 emit_pending_bincls_if_required ();
3101 #ifdef DBX_STATIC_BLOCK_START
3102 DBX_STATIC_BLOCK_START (asm_out_file
, code
);
3105 dbxout_begin_complex_stabs_noforcetext ();
3106 dbxout_symbol_name (decl
, suffix
, letter
);
3107 dbxout_type (type
, 0);
3108 dbxout_finish_complex_stabs (decl
, code
, addr
, 0, number
);
3110 #ifdef DBX_STATIC_BLOCK_END
3111 DBX_STATIC_BLOCK_END (asm_out_file
, code
);
3116 /* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
3117 Then output LETTER to indicate the kind of location the symbol has. */
3120 dbxout_symbol_name (tree decl
, const char *suffix
, int letter
)
3124 if (DECL_CONTEXT (decl
)
3125 && (TYPE_P (DECL_CONTEXT (decl
))
3126 || TREE_CODE (DECL_CONTEXT (decl
)) == NAMESPACE_DECL
))
3127 /* One slight hitch: if this is a VAR_DECL which is a class member
3128 or a namespace member, we must put out the mangled name instead of the
3129 DECL_NAME. Note also that static member (variable) names DO NOT begin
3130 with underscores in .stabs directives. */
3131 name
= DECL_ASSEMBLER_NAME (decl
);
3133 /* ...but if we're function-local, we don't want to include the junk
3134 added by ASM_FORMAT_PRIVATE_NAME. */
3135 name
= DECL_NAME (decl
);
3140 stabstr_S ("(anon)");
3150 /* Output the common block name for DECL in a stabs.
3152 Symbols in global common (.comm) get wrapped with an N_BCOMM/N_ECOMM pair
3153 around each group of symbols in the same .comm area. The N_GSYM stabs
3154 that are emitted only contain the offset in the common area. This routine
3155 emits the N_BCOMM and N_ECOMM stabs. */
3158 dbxout_common_name (tree decl
, const char *name
, stab_code_type op
)
3160 dbxout_begin_complex_stabs ();
3162 dbxout_finish_complex_stabs (decl
, op
, NULL_RTX
, NULL
, 0);
3165 /* Check decl to determine whether it is a VAR_DECL destined for storage in a
3166 common area. If it is, the return value will be a non-null string giving
3167 the name of the common storage block it will go into. If non-null, the
3168 value is the offset into the common block for that symbol's storage. */
3171 dbxout_common_check (tree decl
, int *value
)
3175 const char *name
= NULL
;
3177 /* If the decl isn't a VAR_DECL, or if it isn't public or static, or if
3178 it does not have a value (the offset into the common area), or if it
3179 is thread local (as opposed to global) then it isn't common, and shouldn't
3182 ??? DECL_THREAD_LOCAL_P check prevents problems with improper .stabs
3183 for thread-local symbols. Can be handled via same mechanism as used
3185 if (TREE_CODE (decl
) != VAR_DECL
3186 || !TREE_PUBLIC(decl
)
3187 || !TREE_STATIC(decl
)
3188 || !DECL_HAS_VALUE_EXPR_P(decl
)
3189 || DECL_THREAD_LOCAL_P (decl
)
3193 home
= DECL_RTL (decl
);
3194 if (home
== NULL_RTX
|| GET_CODE (home
) != MEM
)
3197 sym_addr
= dbxout_expand_expr (DECL_VALUE_EXPR (decl
));
3198 if (sym_addr
== NULL_RTX
|| GET_CODE (sym_addr
) != MEM
)
3201 sym_addr
= XEXP (sym_addr
, 0);
3202 if (GET_CODE (sym_addr
) == CONST
)
3203 sym_addr
= XEXP (sym_addr
, 0);
3204 if ((GET_CODE (sym_addr
) == SYMBOL_REF
|| GET_CODE (sym_addr
) == PLUS
)
3205 && DECL_INITIAL (decl
) == 0)
3208 /* We have a sym that will go into a common area, meaning that it
3209 will get storage reserved with a .comm/.lcomm assembler pseudo-op.
3211 Determine name of common area this symbol will be an offset into,
3212 and offset into that area. Also retrieve the decl for the area
3213 that the symbol is offset into. */
3216 switch (GET_CODE (sym_addr
))
3219 if (GET_CODE (XEXP (sym_addr
, 0)) == CONST_INT
)
3222 targetm
.strip_name_encoding(XSTR (XEXP (sym_addr
, 1), 0));
3223 *value
= INTVAL (XEXP (sym_addr
, 0));
3224 cdecl = SYMBOL_REF_DECL (XEXP (sym_addr
, 1));
3229 targetm
.strip_name_encoding(XSTR (XEXP (sym_addr
, 0), 0));
3230 *value
= INTVAL (XEXP (sym_addr
, 1));
3231 cdecl = SYMBOL_REF_DECL (XEXP (sym_addr
, 0));
3236 name
= targetm
.strip_name_encoding(XSTR (sym_addr
, 0));
3238 cdecl = SYMBOL_REF_DECL (sym_addr
);
3242 error ("common symbol debug info is not structured as "
3246 /* Check area common symbol is offset into. If this is not public, then
3247 it is not a symbol in a common block. It must be a .lcomm symbol, not
3249 if (cdecl == NULL
|| !TREE_PUBLIC(cdecl))
3258 /* Output definitions of all the decls in a chain. Return nonzero if
3259 anything was output */
3262 dbxout_syms (tree syms
)
3265 const char *comm_prev
= NULL
;
3266 tree syms_prev
= NULL
;
3270 int temp
, copen
, cclos
;
3271 const char *comm_new
;
3273 /* Check for common symbol, and then progression into a new/different
3274 block of common symbols. Emit closing/opening common bracket if
3276 comm_new
= dbxout_common_check (syms
, &temp
);
3277 copen
= comm_new
!= NULL
3278 && (comm_prev
== NULL
|| strcmp (comm_new
, comm_prev
));
3279 cclos
= comm_prev
!= NULL
3280 && (comm_new
== NULL
|| strcmp (comm_new
, comm_prev
));
3282 dbxout_common_name (syms_prev
, comm_prev
, N_ECOMM
);
3285 dbxout_common_name (syms
, comm_new
, N_BCOMM
);
3288 comm_prev
= comm_new
;
3290 result
+= dbxout_symbol (syms
, 1);
3291 syms
= TREE_CHAIN (syms
);
3294 if (comm_prev
!= NULL
)
3295 dbxout_common_name (syms_prev
, comm_prev
, N_ECOMM
);
3300 /* The following two functions output definitions of function parameters.
3301 Each parameter gets a definition locating it in the parameter list.
3302 Each parameter that is a register variable gets a second definition
3303 locating it in the register.
3305 Printing or argument lists in gdb uses the definitions that
3306 locate in the parameter list. But reference to the variable in
3307 expressions uses preferentially the definition as a register. */
3309 /* Output definitions, referring to storage in the parmlist,
3310 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
3313 dbxout_parms (tree parms
)
3316 emit_pending_bincls_if_required ();
3318 for (; parms
; parms
= TREE_CHAIN (parms
))
3319 if (DECL_NAME (parms
)
3320 && TREE_TYPE (parms
) != error_mark_node
3321 && DECL_RTL_SET_P (parms
)
3322 && DECL_INCOMING_RTL (parms
))
3326 stab_code_type code
;
3329 /* Perform any necessary register eliminations on the parameter's rtl,
3330 so that the debugging output will be accurate. */
3331 DECL_INCOMING_RTL (parms
)
3332 = eliminate_regs (DECL_INCOMING_RTL (parms
), VOIDmode
, NULL_RTX
);
3333 SET_DECL_RTL (parms
,
3334 eliminate_regs (DECL_RTL (parms
), VOIDmode
, NULL_RTX
));
3335 #ifdef LEAF_REG_REMAP
3336 if (current_function_uses_only_leaf_regs
)
3338 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms
));
3339 leaf_renumber_regs_insn (DECL_RTL (parms
));
3343 if (PARM_PASSED_IN_MEMORY (parms
))
3345 rtx inrtl
= XEXP (DECL_INCOMING_RTL (parms
), 0);
3347 /* ??? Here we assume that the parm address is indexed
3348 off the frame pointer or arg pointer.
3349 If that is not true, we produce meaningless results,
3350 but do not crash. */
3351 if (GET_CODE (inrtl
) == PLUS
3352 && GET_CODE (XEXP (inrtl
, 1)) == CONST_INT
)
3353 number
= INTVAL (XEXP (inrtl
, 1));
3358 number
= DEBUGGER_ARG_OFFSET (number
, inrtl
);
3361 /* It is quite tempting to use TREE_TYPE (parms) instead
3362 of DECL_ARG_TYPE (parms) for the eff_type, so that gcc
3363 reports the actual type of the parameter, rather than
3364 the promoted type. This certainly makes GDB's life
3365 easier, at least for some ports. The change is a bad
3366 idea however, since GDB expects to be able access the
3367 type without performing any conversions. So for
3368 example, if we were passing a float to an unprototyped
3369 function, gcc will store a double on the stack, but if
3370 we emit a stab saying the type is a float, then gdb
3371 will only read in a single value, and this will produce
3372 an erroneous value. */
3373 eff_type
= DECL_ARG_TYPE (parms
);
3375 else if (REG_P (DECL_RTL (parms
)))
3379 /* Parm passed in registers and lives in registers or nowhere. */
3380 code
= DBX_REGPARM_STABS_CODE
;
3381 letter
= DBX_REGPARM_STABS_LETTER
;
3383 /* For parms passed in registers, it is better to use the
3384 declared type of the variable, not the type it arrived in. */
3385 eff_type
= TREE_TYPE (parms
);
3387 /* If parm lives in a register, use that register; pretend
3388 the parm was passed there. It would be more consistent
3389 to describe the register where the parm was passed, but
3390 in practice that register usually holds something else.
3391 If the parm lives nowhere, use the register where it
3393 if (REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
3394 best_rtl
= DECL_RTL (parms
);
3395 else if (GET_CODE (DECL_INCOMING_RTL (parms
)) == PARALLEL
)
3396 best_rtl
= XEXP (XVECEXP (DECL_INCOMING_RTL (parms
), 0, 0), 0);
3398 best_rtl
= DECL_INCOMING_RTL (parms
);
3400 number
= DBX_REGISTER_NUMBER (REGNO (best_rtl
));
3402 else if (MEM_P (DECL_RTL (parms
))
3403 && REG_P (XEXP (DECL_RTL (parms
), 0))
3404 && REGNO (XEXP (DECL_RTL (parms
), 0)) != HARD_FRAME_POINTER_REGNUM
3405 && REGNO (XEXP (DECL_RTL (parms
), 0)) != STACK_POINTER_REGNUM
3406 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
3407 && REGNO (XEXP (DECL_RTL (parms
), 0)) != ARG_POINTER_REGNUM
3411 /* Parm was passed via invisible reference.
3412 That is, its address was passed in a register.
3413 Output it as if it lived in that register.
3414 The debugger will know from the type
3415 that it was actually passed by invisible reference. */
3417 code
= DBX_REGPARM_STABS_CODE
;
3419 /* GDB likes this marked with a special letter. */
3420 letter
= (use_gnu_debug_info_extensions
3421 ? 'a' : DBX_REGPARM_STABS_LETTER
);
3422 eff_type
= TREE_TYPE (parms
);
3424 /* DECL_RTL looks like (MEM (REG...). Get the register number.
3425 If it is an unallocated pseudo-reg, then use the register where
3426 it was passed instead.
3427 ??? Why is DBX_REGISTER_NUMBER not used here? */
3429 if (REGNO (XEXP (DECL_RTL (parms
), 0)) < FIRST_PSEUDO_REGISTER
)
3430 number
= REGNO (XEXP (DECL_RTL (parms
), 0));
3432 number
= REGNO (DECL_INCOMING_RTL (parms
));
3434 else if (MEM_P (DECL_RTL (parms
))
3435 && MEM_P (XEXP (DECL_RTL (parms
), 0)))
3437 /* Parm was passed via invisible reference, with the reference
3438 living on the stack. DECL_RTL looks like
3439 (MEM (MEM (PLUS (REG ...) (CONST_INT ...)))) or it
3440 could look like (MEM (MEM (REG))). */
3444 eff_type
= TREE_TYPE (parms
);
3446 if (!REG_P (XEXP (XEXP (DECL_RTL (parms
), 0), 0)))
3447 number
= INTVAL (XEXP (XEXP (XEXP (DECL_RTL (parms
), 0), 0), 1));
3451 number
= DEBUGGER_ARG_OFFSET (number
,
3452 XEXP (XEXP (DECL_RTL (parms
), 0), 0));
3454 else if (MEM_P (DECL_RTL (parms
))
3455 && XEXP (DECL_RTL (parms
), 0) != const0_rtx
3456 /* ??? A constant address for a parm can happen
3457 when the reg it lives in is equiv to a constant in memory.
3458 Should make this not happen, after 2.4. */
3459 && ! CONSTANT_P (XEXP (DECL_RTL (parms
), 0)))
3461 /* Parm was passed in registers but lives on the stack. */
3465 eff_type
= TREE_TYPE (parms
);
3467 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
3468 in which case we want the value of that CONST_INT,
3470 in which case we use a value of zero. */
3471 if (!REG_P (XEXP (DECL_RTL (parms
), 0)))
3472 number
= INTVAL (XEXP (XEXP (DECL_RTL (parms
), 0), 1));
3476 /* Make a big endian correction if the mode of the type of the
3477 parameter is not the same as the mode of the rtl. */
3478 if (BYTES_BIG_ENDIAN
3479 && TYPE_MODE (TREE_TYPE (parms
)) != GET_MODE (DECL_RTL (parms
))
3480 && GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms
))) < UNITS_PER_WORD
)
3481 number
+= (GET_MODE_SIZE (GET_MODE (DECL_RTL (parms
)))
3482 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms
))));
3485 /* ??? We don't know how to represent this argument. */
3488 dbxout_begin_complex_stabs ();
3490 if (DECL_NAME (parms
))
3492 stabstr_I (DECL_NAME (parms
));
3496 stabstr_S ("(anon):");
3498 dbxout_type (eff_type
, 0);
3499 dbxout_finish_complex_stabs (parms
, code
, 0, 0, number
);
3501 DBXOUT_DECR_NESTING
;
3504 /* Output definitions for the places where parms live during the function,
3505 when different from where they were passed, when the parms were passed
3508 It is not useful to do this for parms passed in registers
3509 that live during the function in different registers, because it is
3510 impossible to look in the passed register for the passed value,
3511 so we use the within-the-function register to begin with.
3513 PARMS is a chain of PARM_DECL nodes. */
3516 dbxout_reg_parms (tree parms
)
3520 for (; parms
; parms
= TREE_CHAIN (parms
))
3521 if (DECL_NAME (parms
) && PARM_PASSED_IN_MEMORY (parms
))
3523 /* Report parms that live in registers during the function
3524 but were passed in memory. */
3525 if (REG_P (DECL_RTL (parms
))
3526 && REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
3527 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
3528 0, DECL_RTL (parms
));
3529 else if (GET_CODE (DECL_RTL (parms
)) == CONCAT
)
3530 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
3531 0, DECL_RTL (parms
));
3532 /* Report parms that live in memory but not where they were passed. */
3533 else if (MEM_P (DECL_RTL (parms
))
3534 && ! rtx_equal_p (DECL_RTL (parms
), DECL_INCOMING_RTL (parms
)))
3535 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
3536 0, DECL_RTL (parms
));
3538 DBXOUT_DECR_NESTING
;
3541 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
3542 output definitions of those names, in raw form */
3545 dbxout_args (tree args
)
3550 dbxout_type (TREE_VALUE (args
), 0);
3551 args
= TREE_CHAIN (args
);
3555 #if defined (DBX_DEBUGGING_INFO)
3557 /* Subroutine of dbxout_block. Emit an N_LBRAC stab referencing LABEL.
3558 BEGIN_LABEL is the name of the beginning of the function, which may
3561 dbx_output_lbrac (const char *label
,
3562 const char *begin_label ATTRIBUTE_UNUSED
)
3564 dbxout_begin_stabn (N_LBRAC
);
3565 if (DBX_BLOCKS_FUNCTION_RELATIVE
)
3566 dbxout_stab_value_label_diff (label
, begin_label
);
3568 dbxout_stab_value_label (label
);
3571 /* Subroutine of dbxout_block. Emit an N_RBRAC stab referencing LABEL.
3572 BEGIN_LABEL is the name of the beginning of the function, which may
3575 dbx_output_rbrac (const char *label
,
3576 const char *begin_label ATTRIBUTE_UNUSED
)
3578 dbxout_begin_stabn (N_RBRAC
);
3579 if (DBX_BLOCKS_FUNCTION_RELATIVE
)
3580 dbxout_stab_value_label_diff (label
, begin_label
);
3582 dbxout_stab_value_label (label
);
3585 /* Output everything about a symbol block (a BLOCK node
3586 that represents a scope level),
3587 including recursive output of contained blocks.
3589 BLOCK is the BLOCK node.
3590 DEPTH is its depth within containing symbol blocks.
3591 ARGS is usually zero; but for the outermost block of the
3592 body of a function, it is a chain of PARM_DECLs for the function parameters.
3593 We output definitions of all the register parms
3594 as if they were local variables of that block.
3596 If -g1 was used, we count blocks just the same, but output nothing
3597 except for the outermost block.
3599 Actually, BLOCK may be several blocks chained together.
3600 We handle them all in sequence. */
3603 dbxout_block (tree block
, int depth
, tree args
)
3605 char begin_label
[20];
3606 /* Reference current function start using LFBB. */
3607 ASM_GENERATE_INTERNAL_LABEL (begin_label
, "LFBB", scope_labelno
);
3611 /* Ignore blocks never expanded or otherwise marked as real. */
3612 if (TREE_USED (block
) && TREE_ASM_WRITTEN (block
))
3615 int blocknum
= BLOCK_NUMBER (block
);
3617 /* In dbx format, the syms of a block come before the N_LBRAC.
3618 If nothing is output, we don't need the N_LBRAC, either. */
3620 if (debug_info_level
!= DINFO_LEVEL_TERSE
|| depth
== 0)
3621 did_output
= dbxout_syms (BLOCK_VARS (block
));
3623 dbxout_reg_parms (args
);
3625 /* Now output an N_LBRAC symbol to represent the beginning of
3626 the block. Use the block's tree-walk order to generate
3627 the assembler symbols LBBn and LBEn
3628 that final will define around the code in this block. */
3632 const char *scope_start
;
3635 /* The outermost block doesn't get LBB labels; use
3636 the LFBB local symbol emitted by dbxout_begin_prologue. */
3637 scope_start
= begin_label
;
3640 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBB", blocknum
);
3644 dbx_output_lbrac (scope_start
, begin_label
);
3647 /* Output the subblocks. */
3648 dbxout_block (BLOCK_SUBBLOCKS (block
), depth
+ 1, NULL_TREE
);
3650 /* Refer to the marker for the end of the block. */
3655 /* The outermost block doesn't get LBE labels;
3656 use the "scope" label which will be emitted
3657 by dbxout_function_end. */
3658 ASM_GENERATE_INTERNAL_LABEL (buf
, "Lscope", scope_labelno
);
3660 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBE", blocknum
);
3662 dbx_output_rbrac (buf
, begin_label
);
3665 block
= BLOCK_CHAIN (block
);
3669 /* Output the information about a function and its arguments and result.
3670 Usually this follows the function's code,
3671 but on some systems, it comes before. */
3674 dbxout_begin_function (tree decl
)
3676 int saved_tree_used1
;
3678 if (DECL_IGNORED_P (decl
))
3681 saved_tree_used1
= TREE_USED (decl
);
3682 TREE_USED (decl
) = 1;
3683 if (DECL_NAME (DECL_RESULT (decl
)) != 0)
3685 int saved_tree_used2
= TREE_USED (DECL_RESULT (decl
));
3686 TREE_USED (DECL_RESULT (decl
)) = 1;
3687 dbxout_symbol (decl
, 0);
3688 TREE_USED (DECL_RESULT (decl
)) = saved_tree_used2
;
3691 dbxout_symbol (decl
, 0);
3692 TREE_USED (decl
) = saved_tree_used1
;
3694 dbxout_parms (DECL_ARGUMENTS (decl
));
3695 if (DECL_NAME (DECL_RESULT (decl
)) != 0)
3696 dbxout_symbol (DECL_RESULT (decl
), 1);
3698 #endif /* DBX_DEBUGGING_INFO */
3700 #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */
3702 #include "gt-dbxout.h"