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
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 typeinfo
GTY(())
176 enum typestatus status
;
181 /* Vector recording information about C data types.
182 When we first notice a data type (a tree node),
183 we assign it a number using next_type_number.
184 That is its index in this vector. */
186 static GTY ((length ("typevec_len"))) struct typeinfo
*typevec
;
188 /* Number of elements of space allocated in `typevec'. */
190 static GTY(()) int typevec_len
;
192 /* In dbx output, each type gets a unique number.
193 This is the number for the next type output.
194 The number, once assigned, is in the TYPE_SYMTAB_ADDRESS field. */
196 static GTY(()) int next_type_number
;
198 /* The C front end may call dbxout_symbol before dbxout_init runs.
199 We save all such decls in this list and output them when we get
202 static GTY(()) tree preinit_symbols
;
204 enum binclstatus
{BINCL_NOT_REQUIRED
, BINCL_PENDING
, BINCL_PROCESSED
};
206 /* When using N_BINCL in dbx output, each type number is actually a
207 pair of the file number and the type number within the file.
208 This is a stack of input files. */
212 struct dbx_file
*next
;
214 int next_type_number
;
215 enum binclstatus bincl_status
; /* Keep track of lazy bincl. */
216 const char *pending_bincl_name
; /* Name of bincl. */
217 struct dbx_file
*prev
; /* Chain to traverse all pending bincls. */
220 /* This is the top of the stack.
222 This is not saved for PCH, because restoring a PCH should not change it.
223 next_file_number does have to be saved, because the PCH may use some
224 file numbers; however, just before restoring a PCH, next_file_number
225 should always be 0 because we should not have needed any file numbers
228 #if (defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)) \
229 && defined (DBX_USE_BINCL)
230 static struct dbx_file
*current_file
;
233 /* This is the next file number to use. */
235 static GTY(()) int next_file_number
;
237 /* A counter for dbxout_function_end. */
239 static GTY(()) int scope_labelno
;
241 /* A counter for dbxout_source_line. */
243 static GTY(()) int dbxout_source_line_counter
;
245 /* Number for the next N_SOL filename stabs label. The number 0 is reserved
246 for the N_SO filename stabs label. */
248 static GTY(()) int source_label_number
= 1;
250 /* Last source file name mentioned in a NOTE insn. */
252 static GTY(()) const char *lastfile
;
254 /* Used by PCH machinery to detect if 'lastfile' should be reset to
256 static GTY(()) int lastfile_is_base
;
258 /* Typical USG systems don't have stab.h, and they also have
259 no use for DBX-format debugging info. */
261 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
264 /* If zero then there is no pending BINCL. */
265 static int pending_bincls
= 0;
268 /* The original input file name. */
269 static const char *base_input_file
;
271 #ifdef DEBUG_SYMS_TEXT
272 #define FORCE_TEXT switch_to_section (current_function_section ())
279 #define STAB_CODE_TYPE enum __stab_debug_code
281 /* 1 if PARM is passed to this function in memory. */
283 #define PARM_PASSED_IN_MEMORY(PARM) \
284 (MEM_P (DECL_INCOMING_RTL (PARM)))
286 /* A C expression for the integer offset value of an automatic variable
287 (N_LSYM) having address X (an RTX). */
288 #ifndef DEBUGGER_AUTO_OFFSET
289 #define DEBUGGER_AUTO_OFFSET(X) \
290 (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
293 /* A C expression for the integer offset value of an argument (N_PSYM)
294 having address X (an RTX). The nominal offset is OFFSET. */
295 #ifndef DEBUGGER_ARG_OFFSET
296 #define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET)
299 /* This obstack holds the stab string currently being constructed. We
300 build it up here, then write it out, so we can split long lines up
301 properly (see dbxout_finish_complex_stabs). */
302 static struct obstack stabstr_ob
;
303 static size_t stabstr_last_contin_point
;
306 static void emit_bincl_stab (const char *c
);
307 static void emit_pending_bincls (void);
309 static inline void emit_pending_bincls_if_required (void);
311 static void dbxout_init (const char *);
313 static void dbxout_finish (const char *);
314 static void dbxout_start_source_file (unsigned, const char *);
315 static void dbxout_end_source_file (unsigned);
316 static void dbxout_typedefs (tree
);
317 static void dbxout_type_index (tree
);
318 static void dbxout_args (tree
);
319 static void dbxout_type_fields (tree
);
320 static void dbxout_type_method_1 (tree
);
321 static void dbxout_type_methods (tree
);
322 static void dbxout_range_type (tree
);
323 static void dbxout_type (tree
, int);
324 static bool print_int_cst_bounds_in_octal_p (tree
);
325 static bool is_fortran (void);
326 static void dbxout_type_name (tree
);
327 static void dbxout_class_name_qualifiers (tree
);
328 static int dbxout_symbol_location (tree
, tree
, const char *, rtx
);
329 static void dbxout_symbol_name (tree
, const char *, int);
330 static void dbxout_common_name (tree
, const char *, STAB_CODE_TYPE
);
331 static const char *dbxout_common_check (tree
, int *);
332 static void dbxout_global_decl (tree
);
333 static void dbxout_type_decl (tree
, int);
334 static void dbxout_handle_pch (unsigned);
336 /* The debug hooks structure. */
337 #if defined (DBX_DEBUGGING_INFO)
339 static void dbxout_source_line (unsigned int, const char *);
340 static void dbxout_begin_prologue (unsigned int, const char *);
341 static void dbxout_source_file (const char *);
342 static void dbxout_function_end (tree
);
343 static void dbxout_begin_function (tree
);
344 static void dbxout_begin_block (unsigned, unsigned);
345 static void dbxout_end_block (unsigned, unsigned);
346 static void dbxout_function_decl (tree
);
348 const struct gcc_debug_hooks dbx_debug_hooks
=
352 debug_nothing_int_charstar
,
353 debug_nothing_int_charstar
,
354 dbxout_start_source_file
,
355 dbxout_end_source_file
,
358 debug_true_const_tree
, /* ignore_block */
359 dbxout_source_line
, /* source_line */
360 dbxout_begin_prologue
, /* begin_prologue */
361 debug_nothing_int_charstar
, /* end_prologue */
362 debug_nothing_int_charstar
, /* end_epilogue */
363 #ifdef DBX_FUNCTION_FIRST
364 dbxout_begin_function
,
366 debug_nothing_tree
, /* begin_function */
368 debug_nothing_int
, /* end_function */
369 dbxout_function_decl
,
370 dbxout_global_decl
, /* global_decl */
371 dbxout_type_decl
, /* type_decl */
372 debug_nothing_tree_tree_tree_bool
, /* imported_module_or_decl */
373 debug_nothing_tree
, /* deferred_inline_function */
374 debug_nothing_tree
, /* outlining_inline_function */
375 debug_nothing_rtx
, /* label */
376 dbxout_handle_pch
, /* handle_pch */
377 debug_nothing_rtx
, /* var_location */
378 debug_nothing_void
, /* switch_text_section */
379 0 /* start_end_main_source_file */
381 #endif /* DBX_DEBUGGING_INFO */
383 #if defined (XCOFF_DEBUGGING_INFO)
384 const struct gcc_debug_hooks xcoff_debug_hooks
=
388 debug_nothing_int_charstar
,
389 debug_nothing_int_charstar
,
390 dbxout_start_source_file
,
391 dbxout_end_source_file
,
392 xcoffout_begin_block
,
394 debug_true_const_tree
, /* ignore_block */
395 xcoffout_source_line
,
396 xcoffout_begin_prologue
, /* begin_prologue */
397 debug_nothing_int_charstar
, /* end_prologue */
398 xcoffout_end_epilogue
,
399 debug_nothing_tree
, /* begin_function */
400 xcoffout_end_function
,
401 debug_nothing_tree
, /* function_decl */
402 dbxout_global_decl
, /* global_decl */
403 dbxout_type_decl
, /* type_decl */
404 debug_nothing_tree_tree_tree_bool
, /* imported_module_or_decl */
405 debug_nothing_tree
, /* deferred_inline_function */
406 debug_nothing_tree
, /* outlining_inline_function */
407 debug_nothing_rtx
, /* label */
408 dbxout_handle_pch
, /* handle_pch */
409 debug_nothing_rtx
, /* var_location */
410 debug_nothing_void
, /* switch_text_section */
411 0 /* start_end_main_source_file */
413 #endif /* XCOFF_DEBUGGING_INFO */
415 /* Numeric formatting helper macro. Note that this does not handle
417 #define NUMBER_FMT_LOOP(P, NUM, BASE) \
420 int digit = NUM % BASE; \
422 *--P = digit + '0'; \
426 /* Utility: write a decimal integer NUM to asm_out_file. */
431 char *p
= buf
+ sizeof buf
;
436 putc ('0', asm_out_file
);
441 putc ('-', asm_out_file
);
447 NUMBER_FMT_LOOP (p
, unum
, 10);
449 while (p
< buf
+ sizeof buf
)
451 putc (*p
, asm_out_file
);
457 /* Primitives for emitting simple stabs directives. All other stabs
458 routines should use these functions instead of directly emitting
459 stabs. They are exported because machine-dependent code may need
460 to invoke them, e.g. in a DBX_OUTPUT_* macro whose definition
461 forwards to code in CPU.c. */
463 /* The following functions should all be called immediately after one
464 of the dbxout_begin_stab* functions (below). They write out
465 various things as the value of a stab. */
467 /* Write out a literal zero as the value of a stab. */
469 dbxout_stab_value_zero (void)
471 fputs ("0\n", asm_out_file
);
474 /* Write out the label LABEL as the value of a stab. */
476 dbxout_stab_value_label (const char *label
)
478 assemble_name (asm_out_file
, label
);
479 putc ('\n', asm_out_file
);
482 /* Write out the difference of two labels, LABEL - BASE, as the value
485 dbxout_stab_value_label_diff (const char *label
, const char *base
)
487 assemble_name (asm_out_file
, label
);
488 putc ('-', asm_out_file
);
489 assemble_name (asm_out_file
, base
);
490 putc ('\n', asm_out_file
);
493 /* Write out an internal label as the value of a stab, and immediately
494 emit that internal label. This should be used only when
495 dbxout_stabd will not work. STEM is the name stem of the label,
496 COUNTERP is a pointer to a counter variable which will be used to
497 guarantee label uniqueness. */
499 dbxout_stab_value_internal_label (const char *stem
, int *counterp
)
502 int counter
= counterp
? (*counterp
)++ : 0;
504 ASM_GENERATE_INTERNAL_LABEL (label
, stem
, counter
);
505 dbxout_stab_value_label (label
);
506 targetm
.asm_out
.internal_label (asm_out_file
, stem
, counter
);
509 /* Write out the difference between BASE and an internal label as the
510 value of a stab, and immediately emit that internal label. STEM and
511 COUNTERP are as for dbxout_stab_value_internal_label. */
513 dbxout_stab_value_internal_label_diff (const char *stem
, int *counterp
,
517 int counter
= counterp
? (*counterp
)++ : 0;
519 ASM_GENERATE_INTERNAL_LABEL (label
, stem
, counter
);
520 dbxout_stab_value_label_diff (label
, base
);
521 targetm
.asm_out
.internal_label (asm_out_file
, stem
, counter
);
524 /* The following functions produce specific kinds of stab directives. */
526 /* Write a .stabd directive with type STYPE and desc SDESC to asm_out_file. */
528 dbxout_stabd (int stype
, int sdesc
)
530 fputs (ASM_STABD_OP
, asm_out_file
);
532 fputs (",0,", asm_out_file
);
534 putc ('\n', asm_out_file
);
537 /* Write a .stabn directive with type STYPE. This function stops
538 short of emitting the value field, which is the responsibility of
539 the caller (normally it will be either a symbol or the difference
543 dbxout_begin_stabn (int stype
)
545 fputs (ASM_STABN_OP
, asm_out_file
);
547 fputs (",0,0,", asm_out_file
);
550 /* Write a .stabn directive with type N_SLINE and desc LINE. As above,
551 the value field is the responsibility of the caller. */
553 dbxout_begin_stabn_sline (int lineno
)
555 fputs (ASM_STABN_OP
, asm_out_file
);
556 dbxout_int (N_SLINE
);
557 fputs (",0,", asm_out_file
);
559 putc (',', asm_out_file
);
562 /* Begin a .stabs directive with string "", type STYPE, and desc and
563 other fields 0. The value field is the responsibility of the
564 caller. This function cannot be used for .stabx directives. */
566 dbxout_begin_empty_stabs (int stype
)
568 fputs (ASM_STABS_OP
, asm_out_file
);
569 fputs ("\"\",", asm_out_file
);
571 fputs (",0,0,", asm_out_file
);
574 /* Begin a .stabs directive with string STR, type STYPE, and desc 0.
575 The value field is the responsibility of the caller. */
577 dbxout_begin_simple_stabs (const char *str
, int stype
)
579 fputs (ASM_STABS_OP
, asm_out_file
);
580 output_quoted_string (asm_out_file
, str
);
581 putc (',', asm_out_file
);
583 fputs (",0,0,", asm_out_file
);
586 /* As above but use SDESC for the desc field. */
588 dbxout_begin_simple_stabs_desc (const char *str
, int stype
, int sdesc
)
590 fputs (ASM_STABS_OP
, asm_out_file
);
591 output_quoted_string (asm_out_file
, str
);
592 putc (',', asm_out_file
);
594 fputs (",0,", asm_out_file
);
596 putc (',', asm_out_file
);
599 /* The next set of functions are entirely concerned with production of
600 "complex" .stabs directives: that is, .stabs directives whose
601 strings have to be constructed piecemeal. dbxout_type,
602 dbxout_symbol, etc. use these routines heavily. The string is queued
603 up in an obstack, then written out by dbxout_finish_complex_stabs, which
604 is also responsible for splitting it up if it exceeds DBX_CONTIN_LENGTH.
605 (You might think it would be more efficient to go straight to stdio
606 when DBX_CONTIN_LENGTH is 0 (i.e. no length limit) but that turns
607 out not to be the case, and anyway this needs fewer #ifdefs.) */
609 /* Begin a complex .stabs directive. If we can, write the initial
610 ASM_STABS_OP to the asm_out_file. */
613 dbxout_begin_complex_stabs (void)
615 emit_pending_bincls_if_required ();
617 fputs (ASM_STABS_OP
, asm_out_file
);
618 putc ('"', asm_out_file
);
619 gcc_assert (stabstr_last_contin_point
== 0);
622 /* As above, but do not force text or emit pending bincls. This is
623 used by dbxout_symbol_location, which needs to do something else. */
625 dbxout_begin_complex_stabs_noforcetext (void)
627 fputs (ASM_STABS_OP
, asm_out_file
);
628 putc ('"', asm_out_file
);
629 gcc_assert (stabstr_last_contin_point
== 0);
632 /* Add CHR, a single character, to the string being built. */
633 #define stabstr_C(chr) obstack_1grow (&stabstr_ob, chr)
635 /* Add STR, a normal C string, to the string being built. */
636 #define stabstr_S(str) obstack_grow (&stabstr_ob, str, strlen(str))
638 /* Add the text of ID, an IDENTIFIER_NODE, to the string being built. */
639 #define stabstr_I(id) obstack_grow (&stabstr_ob, \
640 IDENTIFIER_POINTER (id), \
641 IDENTIFIER_LENGTH (id))
643 /* Add NUM, a signed decimal number, to the string being built. */
645 stabstr_D (HOST_WIDE_INT num
)
648 char *p
= buf
+ sizeof buf
;
664 NUMBER_FMT_LOOP (p
, unum
, 10);
666 obstack_grow (&stabstr_ob
, p
, (buf
+ sizeof buf
) - p
);
669 /* Add NUM, an unsigned decimal number, to the string being built. */
671 stabstr_U (unsigned HOST_WIDE_INT num
)
674 char *p
= buf
+ sizeof buf
;
680 NUMBER_FMT_LOOP (p
, num
, 10);
681 obstack_grow (&stabstr_ob
, p
, (buf
+ sizeof buf
) - p
);
684 /* Add CST, an INTEGER_CST tree, to the string being built as an
685 unsigned octal number. This routine handles values which are
686 larger than a single HOST_WIDE_INT. */
690 unsigned HOST_WIDE_INT high
= TREE_INT_CST_HIGH (cst
);
691 unsigned HOST_WIDE_INT low
= TREE_INT_CST_LOW (cst
);
694 char *p
= buf
+ sizeof buf
;
696 /* GDB wants constants with no extra leading "1" bits, so
697 we need to remove any sign-extension that might be
700 const unsigned int width
= TYPE_PRECISION (TREE_TYPE (cst
));
701 if (width
== HOST_BITS_PER_WIDE_INT
* 2)
703 else if (width
> HOST_BITS_PER_WIDE_INT
)
704 high
&= (((HOST_WIDE_INT
) 1 << (width
- HOST_BITS_PER_WIDE_INT
)) - 1);
705 else if (width
== HOST_BITS_PER_WIDE_INT
)
708 high
= 0, low
&= (((HOST_WIDE_INT
) 1 << width
) - 1);
711 /* Leading zero for base indicator. */
714 /* If the value is zero, the base indicator will serve as the value
716 if (high
== 0 && low
== 0)
719 /* If the high half is zero, we need only print the low half normally. */
721 NUMBER_FMT_LOOP (p
, low
, 8);
724 /* When high != 0, we need to print enough zeroes from low to
725 give the digits from high their proper place-values. Hence
726 NUMBER_FMT_LOOP cannot be used. */
727 const int n_digits
= HOST_BITS_PER_WIDE_INT
/ 3;
730 for (i
= 1; i
<= n_digits
; i
++)
732 unsigned int digit
= low
% 8;
737 /* Octal digits carry exactly three bits of information. The
738 width of a HOST_WIDE_INT is not normally a multiple of three.
739 Therefore, the next digit printed probably needs to carry
740 information from both low and high. */
741 if (HOST_BITS_PER_WIDE_INT
% 3 != 0)
743 const int n_leftover_bits
= HOST_BITS_PER_WIDE_INT
% 3;
744 const int n_bits_from_high
= 3 - n_leftover_bits
;
746 const unsigned HOST_WIDE_INT
747 low_mask
= (((unsigned HOST_WIDE_INT
)1) << n_leftover_bits
) - 1;
748 const unsigned HOST_WIDE_INT
749 high_mask
= (((unsigned HOST_WIDE_INT
)1) << n_bits_from_high
) - 1;
753 /* At this point, only the bottom n_leftover_bits bits of low
755 gcc_assert (!(low
& ~low_mask
));
757 digit
= (low
| ((high
& high_mask
) << n_leftover_bits
));
758 high
>>= n_bits_from_high
;
763 /* Now we can format high in the normal manner. However, if
764 the only bits of high that were set were handled by the
765 digit split between low and high, high will now be zero, and
766 we don't want to print extra digits in that case. */
768 NUMBER_FMT_LOOP (p
, high
, 8);
771 obstack_grow (&stabstr_ob
, p
, (buf
+ sizeof buf
) - p
);
774 /* Called whenever it is safe to break a stabs string into multiple
775 .stabs directives. If the current string has exceeded the limit
776 set by DBX_CONTIN_LENGTH, mark the current position in the buffer
777 as a continuation point by inserting DBX_CONTIN_CHAR (doubled if
778 it is a backslash) and a null character. */
780 stabstr_continue (void)
782 if (DBX_CONTIN_LENGTH
> 0
783 && obstack_object_size (&stabstr_ob
) - stabstr_last_contin_point
786 if (DBX_CONTIN_CHAR
== '\\')
787 obstack_1grow (&stabstr_ob
, '\\');
788 obstack_1grow (&stabstr_ob
, DBX_CONTIN_CHAR
);
789 obstack_1grow (&stabstr_ob
, '\0');
790 stabstr_last_contin_point
= obstack_object_size (&stabstr_ob
);
793 #define CONTIN stabstr_continue ()
795 /* Macro subroutine of dbxout_finish_complex_stabs, which emits
796 all of the arguments to the .stabs directive after the string.
797 Overridden by xcoffout.h. CODE is the stabs code for this symbol;
798 LINE is the source line to write into the desc field (in extended
799 mode); SYM is the symbol itself.
801 ADDR, LABEL, and NUMBER are three different ways to represent the
802 stabs value field. At most one of these should be nonzero.
804 ADDR is used most of the time; it represents the value as an
805 RTL address constant.
807 LABEL is used (currently) only for N_CATCH stabs; it represents
808 the value as a string suitable for assemble_name.
810 NUMBER is used when the value is an offset from an implicit base
811 pointer (e.g. for a stack variable), or an index (e.g. for a
812 register variable). It represents the value as a decimal integer. */
814 #ifndef DBX_FINISH_STABS
815 #define DBX_FINISH_STABS(SYM, CODE, LINE, ADDR, LABEL, NUMBER) \
817 int line_ = use_gnu_debug_info_extensions ? LINE : 0; \
820 fputs (",0,", asm_out_file); \
821 dbxout_int (line_); \
822 putc (',', asm_out_file); \
824 output_addr_const (asm_out_file, ADDR); \
826 assemble_name (asm_out_file, LABEL); \
828 dbxout_int (NUMBER); \
829 putc ('\n', asm_out_file); \
833 /* Finish the emission of a complex .stabs directive. When DBX_CONTIN_LENGTH
834 is zero, this has only to emit the close quote and the remainder of
835 the arguments. When it is nonzero, the string has been marshalled in
836 stabstr_ob, and this routine is responsible for breaking it up into
837 DBX_CONTIN_LENGTH-sized chunks.
839 SYM is the DECL of the symbol under consideration; it is used only
840 for its DECL_SOURCE_LINE. The other arguments are all passed directly
841 to DBX_FINISH_STABS; see above for details. */
844 dbxout_finish_complex_stabs (tree sym
, STAB_CODE_TYPE code
,
845 rtx addr
, const char *label
, int number
)
847 int line ATTRIBUTE_UNUSED
;
851 line
= sym
? DECL_SOURCE_LINE (sym
) : 0;
852 if (DBX_CONTIN_LENGTH
> 0)
857 /* Nul-terminate the growing string, then get its size and
859 obstack_1grow (&stabstr_ob
, '\0');
861 len
= obstack_object_size (&stabstr_ob
);
862 chunk
= str
= XOBFINISH (&stabstr_ob
, char *);
864 /* Within the buffer are a sequence of NUL-separated strings,
865 each of which is to be written out as a separate stab
869 chunklen
= strlen (chunk
);
870 fwrite (chunk
, 1, chunklen
, asm_out_file
);
871 fputs ("\",", asm_out_file
);
873 /* Must add an extra byte to account for the NUL separator. */
874 chunk
+= chunklen
+ 1;
877 /* Only put a line number on the last stab in the sequence. */
878 DBX_FINISH_STABS (sym
, code
, len
== 0 ? line
: 0,
879 addr
, label
, number
);
883 fputs (ASM_STABS_OP
, asm_out_file
);
884 putc ('"', asm_out_file
);
886 stabstr_last_contin_point
= 0;
890 /* No continuations - we can put the whole string out at once.
891 It is faster to augment the string with the close quote and
892 comma than to do a two-character fputs. */
893 obstack_grow (&stabstr_ob
, "\",", 2);
894 len
= obstack_object_size (&stabstr_ob
);
895 str
= XOBFINISH (&stabstr_ob
, char *);
897 fwrite (str
, 1, len
, asm_out_file
);
898 DBX_FINISH_STABS (sym
, code
, line
, addr
, label
, number
);
900 obstack_free (&stabstr_ob
, str
);
903 #if defined (DBX_DEBUGGING_INFO)
906 dbxout_function_end (tree decl
)
908 char lscope_label_name
[100];
910 /* The Lscope label must be emitted even if we aren't doing anything
911 else; dbxout_block needs it. */
912 switch_to_section (function_section (current_function_decl
));
914 /* Convert Lscope into the appropriate format for local labels in case
915 the system doesn't insert underscores in front of user generated
917 ASM_GENERATE_INTERNAL_LABEL (lscope_label_name
, "Lscope", scope_labelno
);
918 targetm
.asm_out
.internal_label (asm_out_file
, "Lscope", scope_labelno
);
920 /* The N_FUN tag at the end of the function is a GNU extension,
921 which may be undesirable, and is unnecessary if we do not have
923 if (!use_gnu_debug_info_extensions
924 || NO_DBX_FUNCTION_END
925 || !targetm
.have_named_sections
926 || DECL_IGNORED_P (decl
))
929 /* By convention, GCC will mark the end of a function with an N_FUN
930 symbol and an empty string. */
931 if (flag_reorder_blocks_and_partition
)
933 dbxout_begin_empty_stabs (N_FUN
);
934 dbxout_stab_value_label_diff (crtl
->subsections
.hot_section_end_label
,
935 crtl
->subsections
.hot_section_label
);
936 dbxout_begin_empty_stabs (N_FUN
);
937 dbxout_stab_value_label_diff (crtl
->subsections
.cold_section_end_label
,
938 crtl
->subsections
.cold_section_label
);
942 char begin_label
[20];
943 /* Reference current function start using LFBB. */
944 ASM_GENERATE_INTERNAL_LABEL (begin_label
, "LFBB", scope_labelno
);
945 dbxout_begin_empty_stabs (N_FUN
);
946 dbxout_stab_value_label_diff (lscope_label_name
, begin_label
);
949 if (!NO_DBX_BNSYM_ENSYM
&& !flag_debug_only_used_symbols
)
950 dbxout_stabd (N_ENSYM
, 0);
952 #endif /* DBX_DEBUGGING_INFO */
954 /* Get lang description for N_SO stab. */
955 static unsigned int ATTRIBUTE_UNUSED
956 get_lang_number (void)
958 const char *language_string
= lang_hooks
.name
;
960 if (strcmp (language_string
, "GNU C") == 0)
962 else if (strcmp (language_string
, "GNU C++") == 0)
964 else if (strcmp (language_string
, "GNU F77") == 0)
966 else if (strcmp (language_string
, "GNU Fortran") == 0)
967 return N_SO_FORTRAN90
; /* CHECKME */
968 else if (strcmp (language_string
, "GNU Pascal") == 0)
970 else if (strcmp (language_string
, "GNU Objective-C") == 0)
972 else if (strcmp (language_string
, "GNU Objective-C++") == 0)
973 return N_SO_OBJCPLUS
;
982 unsigned int lang
= get_lang_number ();
984 return (lang
== N_SO_FORTRAN
) || (lang
== N_SO_FORTRAN90
);
987 /* At the beginning of compilation, start writing the symbol table.
988 Initialize `typevec' and output the standard data types of C. */
991 dbxout_init (const char *input_file_name
)
993 char ltext_label_name
[100];
994 bool used_ltext_label_name
= false;
995 tree syms
= lang_hooks
.decls
.getdecls ();
996 const char *mapped_name
;
999 typevec
= GGC_CNEWVEC (struct typeinfo
, typevec_len
);
1001 /* stabstr_ob contains one string, which will be just fine with
1002 1-byte alignment. */
1003 obstack_specify_allocation (&stabstr_ob
, 0, 1, xmalloc
, free
);
1005 /* Convert Ltext into the appropriate format for local labels in case
1006 the system doesn't insert underscores in front of user generated
1008 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name
, "Ltext", 0);
1010 /* Put the current working directory in an N_SO symbol. */
1011 if (use_gnu_debug_info_extensions
&& !NO_DBX_MAIN_SOURCE_DIRECTORY
)
1013 static const char *cwd
;
1017 cwd
= get_src_pwd ();
1020 else if (!IS_DIR_SEPARATOR (cwd
[strlen (cwd
) - 1]))
1021 cwd
= concat (cwd
, "/", NULL
);
1022 cwd
= remap_debug_filename (cwd
);
1024 #ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
1025 DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asm_out_file
, cwd
);
1026 #else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
1027 dbxout_begin_simple_stabs_desc (cwd
, N_SO
, get_lang_number ());
1028 dbxout_stab_value_label (ltext_label_name
);
1029 used_ltext_label_name
= true;
1030 #endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
1033 mapped_name
= remap_debug_filename (input_file_name
);
1034 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
1035 DBX_OUTPUT_MAIN_SOURCE_FILENAME (asm_out_file
, mapped_name
);
1037 dbxout_begin_simple_stabs_desc (mapped_name
, N_SO
, get_lang_number ());
1038 dbxout_stab_value_label (ltext_label_name
);
1039 used_ltext_label_name
= true;
1042 if (used_ltext_label_name
)
1044 switch_to_section (text_section
);
1045 targetm
.asm_out
.internal_label (asm_out_file
, "Ltext", 0);
1048 /* Emit an N_OPT stab to indicate that this file was compiled by GCC.
1049 The string used is historical. */
1050 #ifndef NO_DBX_GCC_MARKER
1051 dbxout_begin_simple_stabs ("gcc2_compiled.", N_OPT
);
1052 dbxout_stab_value_zero ();
1055 base_input_file
= lastfile
= input_file_name
;
1057 next_type_number
= 1;
1059 #ifdef DBX_USE_BINCL
1060 current_file
= XNEW (struct dbx_file
);
1061 current_file
->next
= NULL
;
1062 current_file
->file_number
= 0;
1063 current_file
->next_type_number
= 1;
1064 next_file_number
= 1;
1065 current_file
->prev
= NULL
;
1066 current_file
->bincl_status
= BINCL_NOT_REQUIRED
;
1067 current_file
->pending_bincl_name
= NULL
;
1070 /* Get all permanent types that have typedef names, and output them
1071 all, except for those already output. Some language front ends
1072 put these declarations in the top-level scope; some do not;
1073 the latter are responsible for calling debug_hooks->type_decl from
1074 their record_builtin_type function. */
1075 dbxout_typedefs (syms
);
1077 if (preinit_symbols
)
1080 for (t
= nreverse (preinit_symbols
); t
; t
= TREE_CHAIN (t
))
1081 dbxout_symbol (TREE_VALUE (t
), 0);
1082 preinit_symbols
= 0;
1086 /* Output any typedef names for types described by TYPE_DECLs in SYMS. */
1089 dbxout_typedefs (tree syms
)
1091 for (; syms
!= NULL_TREE
; syms
= TREE_CHAIN (syms
))
1093 if (TREE_CODE (syms
) == TYPE_DECL
)
1095 tree type
= TREE_TYPE (syms
);
1096 if (TYPE_NAME (type
)
1097 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1098 && COMPLETE_OR_VOID_TYPE_P (type
)
1099 && ! TREE_ASM_WRITTEN (TYPE_NAME (type
)))
1100 dbxout_symbol (TYPE_NAME (type
), 0);
1105 #ifdef DBX_USE_BINCL
1106 /* Emit BINCL stab using given name. */
1108 emit_bincl_stab (const char *name
)
1110 dbxout_begin_simple_stabs (name
, N_BINCL
);
1111 dbxout_stab_value_zero ();
1114 /* If there are pending bincls then it is time to emit all of them. */
1117 emit_pending_bincls_if_required (void)
1120 emit_pending_bincls ();
1123 /* Emit all pending bincls. */
1126 emit_pending_bincls (void)
1128 struct dbx_file
*f
= current_file
;
1130 /* Find first pending bincl. */
1131 while (f
->bincl_status
== BINCL_PENDING
)
1134 /* Now emit all bincls. */
1139 if (f
->bincl_status
== BINCL_PENDING
)
1141 emit_bincl_stab (f
->pending_bincl_name
);
1143 /* Update file number and status. */
1144 f
->file_number
= next_file_number
++;
1145 f
->bincl_status
= BINCL_PROCESSED
;
1147 if (f
== current_file
)
1152 /* All pending bincls have been emitted. */
1159 emit_pending_bincls_if_required (void) {}
1162 /* Change to reading from a new source file. Generate a N_BINCL stab. */
1165 dbxout_start_source_file (unsigned int line ATTRIBUTE_UNUSED
,
1166 const char *filename ATTRIBUTE_UNUSED
)
1168 #ifdef DBX_USE_BINCL
1169 struct dbx_file
*n
= XNEW (struct dbx_file
);
1171 n
->next
= current_file
;
1172 n
->next_type_number
= 1;
1173 /* Do not assign file number now.
1174 Delay it until we actually emit BINCL. */
1177 current_file
->prev
= n
;
1178 n
->bincl_status
= BINCL_PENDING
;
1179 n
->pending_bincl_name
= remap_debug_filename (filename
);
1185 /* Revert to reading a previous source file. Generate a N_EINCL stab. */
1188 dbxout_end_source_file (unsigned int line ATTRIBUTE_UNUSED
)
1190 #ifdef DBX_USE_BINCL
1191 /* Emit EINCL stab only if BINCL is not pending. */
1192 if (current_file
->bincl_status
== BINCL_PROCESSED
)
1194 dbxout_begin_stabn (N_EINCL
);
1195 dbxout_stab_value_zero ();
1197 current_file
->bincl_status
= BINCL_NOT_REQUIRED
;
1198 current_file
= current_file
->next
;
1202 /* Handle a few odd cases that occur when trying to make PCH files work. */
1205 dbxout_handle_pch (unsigned at_end
)
1209 /* When using the PCH, this file will be included, so we need to output
1211 dbxout_start_source_file (0, lastfile
);
1213 /* The base file when using the PCH won't be the same as
1214 the base file when it's being generated. */
1219 /* ... and an EINCL. */
1220 dbxout_end_source_file (0);
1222 /* Deal with cases where 'lastfile' was never actually changed. */
1223 lastfile_is_base
= lastfile
== NULL
;
1227 #if defined (DBX_DEBUGGING_INFO)
1229 static void dbxout_block (tree
, int, tree
);
1231 /* Output debugging info to FILE to switch to sourcefile FILENAME. */
1234 dbxout_source_file (const char *filename
)
1236 if (lastfile
== 0 && lastfile_is_base
)
1238 lastfile
= base_input_file
;
1239 lastfile_is_base
= 0;
1242 if (filename
&& (lastfile
== 0 || strcmp (filename
, lastfile
)))
1244 /* Don't change section amid function. */
1245 if (current_function_decl
== NULL_TREE
)
1246 switch_to_section (text_section
);
1248 dbxout_begin_simple_stabs (remap_debug_filename (filename
), N_SOL
);
1249 dbxout_stab_value_internal_label ("Ltext", &source_label_number
);
1250 lastfile
= filename
;
1254 /* Output N_BNSYM, line number symbol entry, and local symbol at
1258 dbxout_begin_prologue (unsigned int lineno
, const char *filename
)
1260 if (use_gnu_debug_info_extensions
1261 && !NO_DBX_FUNCTION_END
1262 && !NO_DBX_BNSYM_ENSYM
1263 && !flag_debug_only_used_symbols
)
1264 dbxout_stabd (N_BNSYM
, 0);
1266 /* pre-increment the scope counter */
1269 dbxout_source_line (lineno
, filename
);
1270 /* Output function begin block at function scope, referenced
1271 by dbxout_block, dbxout_source_line and dbxout_function_end. */
1272 emit_pending_bincls_if_required ();
1273 targetm
.asm_out
.internal_label (asm_out_file
, "LFBB", scope_labelno
);
1276 /* Output a line number symbol entry for source file FILENAME and line
1280 dbxout_source_line (unsigned int lineno
, const char *filename
)
1282 dbxout_source_file (filename
);
1284 #ifdef DBX_OUTPUT_SOURCE_LINE
1285 DBX_OUTPUT_SOURCE_LINE (asm_out_file
, lineno
, dbxout_source_line_counter
);
1287 if (DBX_LINES_FUNCTION_RELATIVE
)
1289 char begin_label
[20];
1290 dbxout_begin_stabn_sline (lineno
);
1291 /* Reference current function start using LFBB. */
1292 ASM_GENERATE_INTERNAL_LABEL (begin_label
, "LFBB", scope_labelno
);
1293 dbxout_stab_value_internal_label_diff ("LM", &dbxout_source_line_counter
,
1297 dbxout_stabd (N_SLINE
, lineno
);
1301 /* Describe the beginning of an internal block within a function. */
1304 dbxout_begin_block (unsigned int line ATTRIBUTE_UNUSED
, unsigned int n
)
1306 emit_pending_bincls_if_required ();
1307 targetm
.asm_out
.internal_label (asm_out_file
, "LBB", n
);
1310 /* Describe the end line-number of an internal block within a function. */
1313 dbxout_end_block (unsigned int line ATTRIBUTE_UNUSED
, unsigned int n
)
1315 emit_pending_bincls_if_required ();
1316 targetm
.asm_out
.internal_label (asm_out_file
, "LBE", n
);
1319 /* Output dbx data for a function definition.
1320 This includes a definition of the function name itself (a symbol),
1321 definitions of the parameters (locating them in the parameter list)
1322 and then output the block that makes up the function's body
1323 (including all the auto variables of the function). */
1326 dbxout_function_decl (tree decl
)
1328 emit_pending_bincls_if_required ();
1329 #ifndef DBX_FUNCTION_FIRST
1330 dbxout_begin_function (decl
);
1332 dbxout_block (DECL_INITIAL (decl
), 0, DECL_ARGUMENTS (decl
));
1333 dbxout_function_end (decl
);
1336 #endif /* DBX_DEBUGGING_INFO */
1338 /* Debug information for a global DECL. Called from toplev.c after
1339 compilation proper has finished. */
1341 dbxout_global_decl (tree decl
)
1343 if (TREE_CODE (decl
) == VAR_DECL
&& !DECL_EXTERNAL (decl
))
1345 int saved_tree_used
= TREE_USED (decl
);
1346 TREE_USED (decl
) = 1;
1347 dbxout_symbol (decl
, 0);
1348 TREE_USED (decl
) = saved_tree_used
;
1352 /* This is just a function-type adapter; dbxout_symbol does exactly
1353 what we want but returns an int. */
1355 dbxout_type_decl (tree decl
, int local
)
1357 dbxout_symbol (decl
, local
);
1360 /* At the end of compilation, finish writing the symbol table.
1361 The default is to call debug_free_queue but do nothing else. */
1364 dbxout_finish (const char *filename ATTRIBUTE_UNUSED
)
1366 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
1367 DBX_OUTPUT_MAIN_SOURCE_FILE_END (asm_out_file
, filename
);
1368 #elif defined DBX_OUTPUT_NULL_N_SO_AT_MAIN_SOURCE_FILE_END
1370 switch_to_section (text_section
);
1371 dbxout_begin_empty_stabs (N_SO
);
1372 dbxout_stab_value_internal_label ("Letext", 0);
1375 debug_free_queue ();
1378 /* Output the index of a type. */
1381 dbxout_type_index (tree type
)
1383 #ifndef DBX_USE_BINCL
1384 stabstr_D (TYPE_SYMTAB_ADDRESS (type
));
1386 struct typeinfo
*t
= &typevec
[TYPE_SYMTAB_ADDRESS (type
)];
1388 stabstr_D (t
->file_number
);
1390 stabstr_D (t
->type_number
);
1397 /* Used in several places: evaluates to '0' for a private decl,
1398 '1' for a protected decl, '2' for a public decl. */
1399 #define DECL_ACCESSIBILITY_CHAR(DECL) \
1400 (TREE_PRIVATE (DECL) ? '0' : TREE_PROTECTED (DECL) ? '1' : '2')
1402 /* Subroutine of `dbxout_type'. Output the type fields of TYPE.
1403 This must be a separate function because anonymous unions require
1407 dbxout_type_fields (tree type
)
1411 /* Output the name, type, position (in bits), size (in bits) of each
1412 field that we can support. */
1413 for (tem
= TYPE_FIELDS (type
); tem
; tem
= TREE_CHAIN (tem
))
1415 /* If one of the nodes is an error_mark or its type is then
1417 if (tem
== error_mark_node
|| TREE_TYPE (tem
) == error_mark_node
)
1420 /* Omit here local type decls until we know how to support them. */
1421 if (TREE_CODE (tem
) == TYPE_DECL
1422 /* Omit here the nameless fields that are used to skip bits. */
1423 || DECL_IGNORED_P (tem
)
1424 /* Omit fields whose position or size are variable or too large to
1426 || (TREE_CODE (tem
) == FIELD_DECL
1427 && (! host_integerp (bit_position (tem
), 0)
1428 || ! DECL_SIZE (tem
)
1429 || ! host_integerp (DECL_SIZE (tem
), 1))))
1432 else if (TREE_CODE (tem
) != CONST_DECL
)
1434 /* Continue the line if necessary,
1435 but not before the first field. */
1436 if (tem
!= TYPE_FIELDS (type
))
1439 if (DECL_NAME (tem
))
1440 stabstr_I (DECL_NAME (tem
));
1443 if (use_gnu_debug_info_extensions
1444 && (TREE_PRIVATE (tem
) || TREE_PROTECTED (tem
)
1445 || TREE_CODE (tem
) != FIELD_DECL
))
1448 stabstr_C (DECL_ACCESSIBILITY_CHAR (tem
));
1451 dbxout_type ((TREE_CODE (tem
) == FIELD_DECL
1452 && DECL_BIT_FIELD_TYPE (tem
))
1453 ? DECL_BIT_FIELD_TYPE (tem
) : TREE_TYPE (tem
), 0);
1455 if (TREE_CODE (tem
) == VAR_DECL
)
1457 if (TREE_STATIC (tem
) && use_gnu_debug_info_extensions
)
1459 tree name
= DECL_ASSEMBLER_NAME (tem
);
1466 /* If TEM is non-static, GDB won't understand it. */
1467 stabstr_S (",0,0;");
1472 stabstr_D (int_bit_position (tem
));
1474 stabstr_D (tree_low_cst (DECL_SIZE (tem
), 1));
1481 /* Subroutine of `dbxout_type_methods'. Output debug info about the
1482 method described DECL. */
1485 dbxout_type_method_1 (tree decl
)
1489 if (TREE_CODE (TREE_TYPE (decl
)) == FUNCTION_TYPE
)
1491 else /* it's a METHOD_TYPE. */
1493 tree firstarg
= TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)));
1494 /* A for normal functions.
1495 B for `const' member functions.
1496 C for `volatile' member functions.
1497 D for `const volatile' member functions. */
1498 if (TYPE_READONLY (TREE_TYPE (firstarg
)))
1500 if (TYPE_VOLATILE (TREE_TYPE (firstarg
)))
1503 if (DECL_VINDEX (decl
))
1509 /* ??? Output the mangled name, which contains an encoding of the
1510 method's type signature. May not be necessary anymore. */
1512 stabstr_I (DECL_ASSEMBLER_NAME (decl
));
1514 stabstr_C (DECL_ACCESSIBILITY_CHAR (decl
));
1518 if (DECL_VINDEX (decl
) && host_integerp (DECL_VINDEX (decl
), 0))
1520 stabstr_D (tree_low_cst (DECL_VINDEX (decl
), 0));
1522 dbxout_type (DECL_CONTEXT (decl
), 0);
1527 /* Subroutine of `dbxout_type'. Output debug info about the methods defined
1531 dbxout_type_methods (tree type
)
1533 /* C++: put out the method names and their parameter lists */
1534 tree methods
= TYPE_METHODS (type
);
1538 if (methods
== NULL_TREE
)
1541 if (TREE_CODE (methods
) != TREE_VEC
)
1543 else if (TREE_VEC_ELT (methods
, 0) != NULL_TREE
)
1544 fndecl
= TREE_VEC_ELT (methods
, 0);
1546 fndecl
= TREE_VEC_ELT (methods
, 1);
1550 int need_prefix
= 1;
1552 /* Group together all the methods for the same operation.
1553 These differ in the types of the arguments. */
1554 for (last
= NULL_TREE
;
1555 fndecl
&& (last
== NULL_TREE
|| DECL_NAME (fndecl
) == DECL_NAME (last
));
1556 fndecl
= TREE_CHAIN (fndecl
))
1557 /* Output the name of the field (after overloading), as
1558 well as the name of the field before overloading, along
1559 with its parameter list */
1561 /* Skip methods that aren't FUNCTION_DECLs. (In C++, these
1562 include TEMPLATE_DECLs.) The debugger doesn't know what
1563 to do with such entities anyhow. */
1564 if (TREE_CODE (fndecl
) != FUNCTION_DECL
)
1571 /* Also ignore abstract methods; those are only interesting to
1572 the DWARF backends. */
1573 if (DECL_IGNORED_P (fndecl
) || DECL_ABSTRACT (fndecl
))
1576 /* Redundantly output the plain name, since that's what gdb
1580 stabstr_I (DECL_NAME (fndecl
));
1585 dbxout_type (TREE_TYPE (fndecl
), 0);
1586 dbxout_type_method_1 (fndecl
);
1593 /* Emit a "range" type specification, which has the form:
1594 "r<index type>;<lower bound>;<upper bound>;".
1595 TYPE is an INTEGER_TYPE. */
1598 dbxout_range_type (tree type
)
1601 if (TREE_TYPE (type
))
1602 dbxout_type (TREE_TYPE (type
), 0);
1603 else if (TREE_CODE (type
) != INTEGER_TYPE
)
1604 dbxout_type (type
, 0); /* E.g. Pascal's ARRAY [BOOLEAN] of INTEGER */
1607 /* Traditionally, we made sure 'int' was type 1, and builtin types
1608 were defined to be sub-ranges of int. Unfortunately, this
1609 does not allow us to distinguish true sub-ranges from integer
1610 types. So, instead we define integer (non-sub-range) types as
1611 sub-ranges of themselves. This matters for Chill. If this isn't
1612 a subrange type, then we want to define it in terms of itself.
1613 However, in C, this may be an anonymous integer type, and we don't
1614 want to emit debug info referring to it. Just calling
1615 dbxout_type_index won't work anyways, because the type hasn't been
1616 defined yet. We make this work for both cases by checked to see
1617 whether this is a defined type, referring to it if it is, and using
1619 if (TYPE_SYMTAB_ADDRESS (type
) != 0)
1620 dbxout_type_index (type
);
1622 dbxout_type_index (integer_type_node
);
1626 if (TYPE_MIN_VALUE (type
) != 0
1627 && host_integerp (TYPE_MIN_VALUE (type
), 0))
1629 if (print_int_cst_bounds_in_octal_p (type
))
1630 stabstr_O (TYPE_MIN_VALUE (type
));
1632 stabstr_D (tree_low_cst (TYPE_MIN_VALUE (type
), 0));
1638 if (TYPE_MAX_VALUE (type
) != 0
1639 && host_integerp (TYPE_MAX_VALUE (type
), 0))
1641 if (print_int_cst_bounds_in_octal_p (type
))
1642 stabstr_O (TYPE_MAX_VALUE (type
));
1644 stabstr_D (tree_low_cst (TYPE_MAX_VALUE (type
), 0));
1652 /* Output a reference to a type. If the type has not yet been
1653 described in the dbx output, output its definition now.
1654 For a type already defined, just refer to its definition
1655 using the type number.
1657 If FULL is nonzero, and the type has been described only with
1658 a forward-reference, output the definition now.
1659 If FULL is zero in this case, just refer to the forward-reference
1660 using the number previously allocated. */
1663 dbxout_type (tree type
, int full
)
1667 static int anonymous_type_number
= 0;
1668 bool vector_type
= false;
1670 if (TREE_CODE (type
) == VECTOR_TYPE
)
1672 /* The frontend feeds us a representation for the vector as a struct
1673 containing an array. Pull out the array type. */
1674 type
= TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type
)));
1678 /* If there was an input error and we don't really have a type,
1679 avoid crashing and write something that is at least valid
1680 by assuming `int'. */
1681 if (type
== error_mark_node
)
1682 type
= integer_type_node
;
1685 if (TYPE_NAME (type
)
1686 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1687 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type
)))
1691 /* Try to find the "main variant" with the same name. */
1692 if (TYPE_NAME (type
) && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1693 && DECL_ORIGINAL_TYPE (TYPE_NAME (type
)))
1694 main_variant
= TREE_TYPE (TYPE_NAME (type
));
1696 main_variant
= TYPE_MAIN_VARIANT (type
);
1698 /* If we are not using extensions, stabs does not distinguish const and
1699 volatile, so there is no need to make them separate types. */
1700 if (!use_gnu_debug_info_extensions
)
1701 type
= main_variant
;
1703 if (TYPE_SYMTAB_ADDRESS (type
) == 0)
1705 /* Type has no dbx number assigned. Assign next available number. */
1706 TYPE_SYMTAB_ADDRESS (type
) = next_type_number
++;
1708 /* Make sure type vector is long enough to record about this type. */
1710 if (next_type_number
== typevec_len
)
1712 typevec
= GGC_RESIZEVEC (struct typeinfo
, typevec
, typevec_len
* 2);
1713 memset (typevec
+ typevec_len
, 0, typevec_len
* sizeof typevec
[0]);
1717 #ifdef DBX_USE_BINCL
1718 emit_pending_bincls_if_required ();
1719 typevec
[TYPE_SYMTAB_ADDRESS (type
)].file_number
1720 = current_file
->file_number
;
1721 typevec
[TYPE_SYMTAB_ADDRESS (type
)].type_number
1722 = current_file
->next_type_number
++;
1726 if (flag_debug_only_used_symbols
)
1728 if ((TREE_CODE (type
) == RECORD_TYPE
1729 || TREE_CODE (type
) == UNION_TYPE
1730 || TREE_CODE (type
) == QUAL_UNION_TYPE
1731 || TREE_CODE (type
) == ENUMERAL_TYPE
)
1732 && TYPE_STUB_DECL (type
)
1733 && DECL_P (TYPE_STUB_DECL (type
))
1734 && ! DECL_IGNORED_P (TYPE_STUB_DECL (type
)))
1735 debug_queue_symbol (TYPE_STUB_DECL (type
));
1736 else if (TYPE_NAME (type
)
1737 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
1738 debug_queue_symbol (TYPE_NAME (type
));
1741 /* Output the number of this type, to refer to it. */
1742 dbxout_type_index (type
);
1744 #ifdef DBX_TYPE_DEFINED
1745 if (DBX_TYPE_DEFINED (type
))
1749 /* If this type's definition has been output or is now being output,
1752 switch (typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
)
1757 /* If we have already had a cross reference,
1758 and either that's all we want or that's the best we could do,
1759 don't repeat the cross reference.
1760 Sun dbx crashes if we do. */
1761 if (! full
|| !COMPLETE_TYPE_P (type
)
1762 /* No way in DBX fmt to describe a variable size. */
1763 || ! host_integerp (TYPE_SIZE (type
), 1))
1771 /* For systems where dbx output does not allow the `=xsNAME:' syntax,
1772 leave the type-number completely undefined rather than output
1773 a cross-reference. If we have already used GNU debug info extensions,
1774 then it is OK to output a cross reference. This is necessary to get
1775 proper C++ debug output. */
1776 if ((TREE_CODE (type
) == RECORD_TYPE
|| TREE_CODE (type
) == UNION_TYPE
1777 || TREE_CODE (type
) == QUAL_UNION_TYPE
1778 || TREE_CODE (type
) == ENUMERAL_TYPE
)
1779 && ! use_gnu_debug_info_extensions
)
1780 /* We must use the same test here as we use twice below when deciding
1781 whether to emit a cross-reference. */
1782 if ((TYPE_NAME (type
) != 0
1783 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1784 && DECL_IGNORED_P (TYPE_NAME (type
)))
1786 || !COMPLETE_TYPE_P (type
)
1787 /* No way in DBX fmt to describe a variable size. */
1788 || ! host_integerp (TYPE_SIZE (type
), 1))
1790 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1795 /* Output a definition now. */
1798 /* Mark it as defined, so that if it is self-referent
1799 we will not get into an infinite recursion of definitions. */
1801 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_DEFINED
;
1803 /* If this type is a variant of some other, hand off. Types with
1804 different names are usefully distinguished. We only distinguish
1805 cv-qualified types if we're using extensions. */
1806 if (TYPE_READONLY (type
) > TYPE_READONLY (main_variant
))
1809 dbxout_type (build_type_variant (type
, 0, TYPE_VOLATILE (type
)), 0);
1812 else if (TYPE_VOLATILE (type
) > TYPE_VOLATILE (main_variant
))
1815 dbxout_type (build_type_variant (type
, TYPE_READONLY (type
), 0), 0);
1818 else if (main_variant
!= TYPE_MAIN_VARIANT (type
))
1820 if (flag_debug_only_used_symbols
)
1822 tree orig_type
= DECL_ORIGINAL_TYPE (TYPE_NAME (type
));
1824 if ((TREE_CODE (orig_type
) == RECORD_TYPE
1825 || TREE_CODE (orig_type
) == UNION_TYPE
1826 || TREE_CODE (orig_type
) == QUAL_UNION_TYPE
1827 || TREE_CODE (orig_type
) == ENUMERAL_TYPE
)
1828 && TYPE_STUB_DECL (orig_type
)
1829 && ! DECL_IGNORED_P (TYPE_STUB_DECL (orig_type
)))
1830 debug_queue_symbol (TYPE_STUB_DECL (orig_type
));
1832 /* 'type' is a typedef; output the type it refers to. */
1833 dbxout_type (DECL_ORIGINAL_TYPE (TYPE_NAME (type
)), 0);
1836 /* else continue. */
1838 switch (TREE_CODE (type
))
1842 /* For a void type, just define it as itself; i.e., "5=5".
1843 This makes us consider it defined
1844 without saying what it is. The debugger will make it
1845 a void type when the reference is seen, and nothing will
1846 ever override that default. */
1847 dbxout_type_index (type
);
1851 if (type
== char_type_node
&& ! TYPE_UNSIGNED (type
))
1853 /* Output the type `char' as a subrange of itself!
1854 I don't understand this definition, just copied it
1855 from the output of pcc.
1856 This used to use `r2' explicitly and we used to
1857 take care to make sure that `char' was type number 2. */
1859 dbxout_type_index (type
);
1860 stabstr_S (";0;127;");
1863 /* If this is a subtype of another integer type, always prefer to
1864 write it as a subtype. */
1865 else if (TREE_TYPE (type
) != 0
1866 && TREE_CODE (TREE_TYPE (type
)) == INTEGER_TYPE
)
1868 /* If the size is non-standard, say what it is if we can use
1871 if (use_gnu_debug_info_extensions
1872 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
1875 stabstr_D (TYPE_PRECISION (type
));
1879 dbxout_range_type (type
);
1884 /* If the size is non-standard, say what it is if we can use
1887 if (use_gnu_debug_info_extensions
1888 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
1891 stabstr_D (TYPE_PRECISION (type
));
1895 if (print_int_cst_bounds_in_octal_p (type
))
1899 /* If this type derives from another type, output type index of
1900 parent type. This is particularly important when parent type
1901 is an enumerated type, because not generating the parent type
1902 index would transform the definition of this enumerated type
1903 into a plain unsigned type. */
1904 if (TREE_TYPE (type
) != 0)
1905 dbxout_type_index (TREE_TYPE (type
));
1907 dbxout_type_index (type
);
1910 stabstr_O (TYPE_MIN_VALUE (type
));
1912 stabstr_O (TYPE_MAX_VALUE (type
));
1917 /* Output other integer types as subranges of `int'. */
1918 dbxout_range_type (type
);
1924 case FIXED_POINT_TYPE
:
1925 /* This used to say `r1' and we used to take care
1926 to make sure that `int' was type number 1. */
1928 dbxout_type_index (integer_type_node
);
1930 stabstr_D (int_size_in_bytes (type
));
1935 if (use_gnu_debug_info_extensions
)
1938 stabstr_D (BITS_PER_UNIT
* int_size_in_bytes (type
));
1939 stabstr_S (";-16;");
1941 else /* Define as enumeral type (False, True) */
1942 stabstr_S ("eFalse:0,True:1,;");
1946 /* Differs from the REAL_TYPE by its new data type number.
1947 R3 is NF_COMPLEX. We don't try to use any of the other NF_*
1948 codes since gdb doesn't care anyway. */
1950 if (TREE_CODE (TREE_TYPE (type
)) == REAL_TYPE
)
1953 stabstr_D (2 * int_size_in_bytes (TREE_TYPE (type
)));
1958 /* Output a complex integer type as a structure,
1959 pending some other way to do it. */
1961 stabstr_D (int_size_in_bytes (type
));
1963 stabstr_S ("real:");
1964 dbxout_type (TREE_TYPE (type
), 0);
1966 stabstr_D (TYPE_PRECISION (TREE_TYPE (type
)));
1968 stabstr_S (";imag:");
1969 dbxout_type (TREE_TYPE (type
), 0);
1971 stabstr_D (TYPE_PRECISION (TREE_TYPE (type
)));
1973 stabstr_D (TYPE_PRECISION (TREE_TYPE (type
)));
1979 /* Make arrays of packed bits look like bitstrings for chill. */
1980 if (TYPE_PACKED (type
) && use_gnu_debug_info_extensions
)
1983 stabstr_D (BITS_PER_UNIT
* int_size_in_bytes (type
));
1984 stabstr_S (";@S;S");
1985 dbxout_type (TYPE_DOMAIN (type
), 0);
1989 if (use_gnu_debug_info_extensions
&& vector_type
)
1992 /* Output "a" followed by a range type definition
1993 for the index type of the array
1994 followed by a reference to the target-type.
1995 ar1;0;N;M for a C array of type M and size N+1. */
1996 /* Check if a character string type, which in Chill is
1997 different from an array of characters. */
1998 if (TYPE_STRING_FLAG (type
) && use_gnu_debug_info_extensions
)
2002 tem
= TYPE_DOMAIN (type
);
2006 dbxout_type_index (integer_type_node
);
2007 stabstr_S (";0;-1;");
2012 dbxout_range_type (tem
);
2015 dbxout_type (TREE_TYPE (type
), 0);
2020 case QUAL_UNION_TYPE
:
2022 tree binfo
= TYPE_BINFO (type
);
2024 /* Output a structure type. We must use the same test here as we
2025 use in the DBX_NO_XREFS case above. */
2026 if ((TYPE_NAME (type
) != 0
2027 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
2028 && DECL_IGNORED_P (TYPE_NAME (type
)))
2030 || !COMPLETE_TYPE_P (type
)
2031 /* No way in DBX fmt to describe a variable size. */
2032 || ! host_integerp (TYPE_SIZE (type
), 1))
2034 /* If the type is just a cross reference, output one
2035 and mark the type as partially described.
2036 If it later becomes defined, we will output
2037 its real definition.
2038 If the type has a name, don't nest its definition within
2039 another type's definition; instead, output an xref
2040 and let the definition come when the name is defined. */
2041 stabstr_S ((TREE_CODE (type
) == RECORD_TYPE
) ? "xs" : "xu");
2042 if (TYPE_NAME (type
) != 0
2043 /* The C frontend creates for anonymous variable length
2044 records/unions TYPE_NAME with DECL_NAME NULL. */
2045 && (TREE_CODE (TYPE_NAME (type
)) != TYPE_DECL
2046 || DECL_NAME (TYPE_NAME (type
))))
2047 dbxout_type_name (type
);
2051 stabstr_D (anonymous_type_number
++);
2055 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
2059 /* Identify record or union, and print its size. */
2060 stabstr_C ((TREE_CODE (type
) == RECORD_TYPE
) ? 's' : 'u');
2061 stabstr_D (int_size_in_bytes (type
));
2067 VEC(tree
,gc
) *accesses
= BINFO_BASE_ACCESSES (binfo
);
2069 if (use_gnu_debug_info_extensions
)
2071 if (BINFO_N_BASE_BINFOS (binfo
))
2074 stabstr_U (BINFO_N_BASE_BINFOS (binfo
));
2078 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, child
); i
++)
2080 tree access
= (accesses
? VEC_index (tree
, accesses
, i
)
2081 : access_public_node
);
2083 if (use_gnu_debug_info_extensions
)
2085 stabstr_C (BINFO_VIRTUAL_P (child
) ? '1' : '0');
2086 stabstr_C (access
== access_public_node
? '2' :
2087 access
== access_protected_node
2089 if (BINFO_VIRTUAL_P (child
)
2090 && (strcmp (lang_hooks
.name
, "GNU C++") == 0
2091 || strcmp (lang_hooks
.name
, "GNU Objective-C++") == 0))
2092 /* For a virtual base, print the (negative)
2093 offset within the vtable where we must look
2094 to find the necessary adjustment. */
2096 (tree_low_cst (BINFO_VPTR_FIELD (child
), 0)
2099 stabstr_D (tree_low_cst (BINFO_OFFSET (child
), 0)
2102 dbxout_type (BINFO_TYPE (child
), 0);
2107 /* Print out the base class information with
2108 fields which have the same names at the types
2110 dbxout_type_name (BINFO_TYPE (child
));
2112 dbxout_type (BINFO_TYPE (child
), full
);
2114 stabstr_D (tree_low_cst (BINFO_OFFSET (child
), 0)
2118 (tree_low_cst (TYPE_SIZE (BINFO_TYPE (child
)), 0)
2126 /* Write out the field declarations. */
2127 dbxout_type_fields (type
);
2128 if (use_gnu_debug_info_extensions
&& TYPE_METHODS (type
) != NULL_TREE
)
2130 dbxout_type_methods (type
);
2135 if (use_gnu_debug_info_extensions
&& TREE_CODE (type
) == RECORD_TYPE
2136 /* Avoid the ~ if we don't really need it--it confuses dbx. */
2137 && TYPE_VFIELD (type
))
2140 /* We need to write out info about what field this class
2141 uses as its "main" vtable pointer field, because if this
2142 field is inherited from a base class, GDB cannot necessarily
2143 figure out which field it's using in time. */
2145 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type
)), 0);
2151 /* We must use the same test here as we use in the DBX_NO_XREFS case
2152 above. We simplify it a bit since an enum will never have a variable
2154 if ((TYPE_NAME (type
) != 0
2155 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
2156 && DECL_IGNORED_P (TYPE_NAME (type
)))
2158 || !COMPLETE_TYPE_P (type
))
2161 dbxout_type_name (type
);
2162 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
2166 if (use_gnu_debug_info_extensions
2167 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
2170 stabstr_D (TYPE_PRECISION (type
));
2175 for (tem
= TYPE_VALUES (type
); tem
; tem
= TREE_CHAIN (tem
))
2177 tree value
= TREE_VALUE (tem
);
2179 stabstr_I (TREE_PURPOSE (tem
));
2182 if (TREE_CODE (value
) == CONST_DECL
)
2183 value
= DECL_INITIAL (value
);
2185 if (TREE_INT_CST_HIGH (value
) == 0)
2186 stabstr_D (TREE_INT_CST_LOW (value
));
2187 else if (TREE_INT_CST_HIGH (value
) == -1
2188 && (HOST_WIDE_INT
) TREE_INT_CST_LOW (value
) < 0)
2189 stabstr_D (TREE_INT_CST_LOW (value
));
2194 if (TREE_CHAIN (tem
) != 0)
2203 dbxout_type (TREE_TYPE (type
), 0);
2207 if (use_gnu_debug_info_extensions
)
2211 /* Write the argument types out longhand. */
2212 dbxout_type (TYPE_METHOD_BASETYPE (type
), 0);
2214 dbxout_type (TREE_TYPE (type
), 0);
2215 dbxout_args (TYPE_ARG_TYPES (type
));
2219 /* Treat it as a function type. */
2220 dbxout_type (TREE_TYPE (type
), 0);
2224 if (use_gnu_debug_info_extensions
)
2227 dbxout_type (TYPE_OFFSET_BASETYPE (type
), 0);
2229 dbxout_type (TREE_TYPE (type
), 0);
2232 /* Should print as an int, because it is really just an offset. */
2233 dbxout_type (integer_type_node
, 0);
2236 case REFERENCE_TYPE
:
2237 if (use_gnu_debug_info_extensions
)
2243 dbxout_type (TREE_TYPE (type
), 0);
2248 dbxout_type (TREE_TYPE (type
), 0);
2256 /* Return nonzero if the given type represents an integer whose bounds
2257 should be printed in octal format. */
2260 print_int_cst_bounds_in_octal_p (tree type
)
2262 /* If we can use GDB extensions and the size is wider than a long
2263 (the size used by GDB to read them) or we may have trouble writing
2264 the bounds the usual way, write them in octal. Note the test is for
2265 the *target's* size of "long", not that of the host. The host test
2266 is just to make sure we can write it out in case the host wide int
2267 is narrower than the target "long".
2269 For unsigned types, we use octal if they are the same size or larger.
2270 This is because we print the bounds as signed decimal, and hence they
2271 can't span same size unsigned types. */
2273 if (use_gnu_debug_info_extensions
2274 && TYPE_MIN_VALUE (type
) != 0
2275 && TREE_CODE (TYPE_MIN_VALUE (type
)) == INTEGER_CST
2276 && TYPE_MAX_VALUE (type
) != 0
2277 && TREE_CODE (TYPE_MAX_VALUE (type
)) == INTEGER_CST
2278 && (TYPE_PRECISION (type
) > TYPE_PRECISION (integer_type_node
)
2279 || ((TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
))
2280 && TYPE_UNSIGNED (type
))
2281 || TYPE_PRECISION (type
) > HOST_BITS_PER_WIDE_INT
2282 || (TYPE_PRECISION (type
) == HOST_BITS_PER_WIDE_INT
2283 && TYPE_UNSIGNED (type
))))
2289 /* Output the name of type TYPE, with no punctuation.
2290 Such names can be set up either by typedef declarations
2291 or by struct, enum and union tags. */
2294 dbxout_type_name (tree type
)
2296 tree t
= TYPE_NAME (type
);
2299 switch (TREE_CODE (t
))
2301 case IDENTIFIER_NODE
:
2313 /* Output leading leading struct or class names needed for qualifying
2314 type whose scope is limited to a struct or class. */
2317 dbxout_class_name_qualifiers (tree decl
)
2319 tree context
= decl_type_context (decl
);
2321 if (context
!= NULL_TREE
2322 && TREE_CODE(context
) == RECORD_TYPE
2323 && TYPE_NAME (context
) != 0
2324 && (TREE_CODE (TYPE_NAME (context
)) == IDENTIFIER_NODE
2325 || (DECL_NAME (TYPE_NAME (context
)) != 0)))
2327 tree name
= TYPE_NAME (context
);
2329 if (TREE_CODE (name
) == TYPE_DECL
)
2331 dbxout_class_name_qualifiers (name
);
2332 name
= DECL_NAME (name
);
2339 /* This is a specialized subset of expand_expr for use by dbxout_symbol in
2340 evaluating DECL_VALUE_EXPR. In particular, we stop if we find decls that
2341 haven't been expanded, or if the expression is getting so complex we won't
2342 be able to represent it in stabs anyway. Returns NULL on failure. */
2345 dbxout_expand_expr (tree expr
)
2347 switch (TREE_CODE (expr
))
2350 /* We can't handle emulated tls variables, because the address is an
2351 offset to the return value of __emutls_get_address, and there is no
2352 way to express that in stabs. Also, there are name mangling issues
2353 here. We end up with references to undefined symbols if we don't
2354 disable debug info for these variables. */
2355 if (!targetm
.have_tls
&& DECL_THREAD_LOCAL_P (expr
))
2360 if (DECL_HAS_VALUE_EXPR_P (expr
))
2361 return dbxout_expand_expr (DECL_VALUE_EXPR (expr
));
2366 return DECL_RTL_IF_SET (expr
);
2369 return expand_expr (expr
, NULL_RTX
, VOIDmode
, EXPAND_INITIALIZER
);
2373 case ARRAY_RANGE_REF
:
2376 enum machine_mode mode
;
2377 HOST_WIDE_INT bitsize
, bitpos
;
2379 int volatilep
= 0, unsignedp
= 0;
2382 tem
= get_inner_reference (expr
, &bitsize
, &bitpos
, &offset
,
2383 &mode
, &unsignedp
, &volatilep
, true);
2385 x
= dbxout_expand_expr (tem
);
2386 if (x
== NULL
|| !MEM_P (x
))
2390 if (!host_integerp (offset
, 0))
2392 x
= adjust_address_nv (x
, mode
, tree_low_cst (offset
, 0));
2395 x
= adjust_address_nv (x
, mode
, bitpos
/ BITS_PER_UNIT
);
2405 /* Helper function for output_used_types. Queue one entry from the
2406 used types hash to be output. */
2409 output_used_types_helper (void **slot
, void *data
)
2411 tree type
= (tree
) *slot
;
2412 VEC(tree
, heap
) **types_p
= (VEC(tree
, heap
) **) data
;
2414 if ((TREE_CODE (type
) == RECORD_TYPE
2415 || TREE_CODE (type
) == UNION_TYPE
2416 || TREE_CODE (type
) == QUAL_UNION_TYPE
2417 || TREE_CODE (type
) == ENUMERAL_TYPE
)
2418 && TYPE_STUB_DECL (type
)
2419 && DECL_P (TYPE_STUB_DECL (type
))
2420 && ! DECL_IGNORED_P (TYPE_STUB_DECL (type
)))
2421 VEC_quick_push (tree
, *types_p
, TYPE_STUB_DECL (type
));
2422 else if (TYPE_NAME (type
)
2423 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
2424 VEC_quick_push (tree
, *types_p
, TYPE_NAME (type
));
2429 /* This is a qsort callback which sorts types and declarations into a
2430 predictable order (types, then declarations, sorted by UID
2434 output_types_sort (const void *pa
, const void *pb
)
2436 const tree lhs
= *((const tree
*)pa
);
2437 const tree rhs
= *((const tree
*)pb
);
2442 return TYPE_UID (lhs
) - TYPE_UID (rhs
);
2451 return DECL_UID (lhs
) - DECL_UID (rhs
);
2456 /* Force all types used by this function to be output in debug
2460 output_used_types (void)
2462 if (cfun
&& cfun
->used_types_hash
)
2464 VEC(tree
, heap
) *types
;
2468 types
= VEC_alloc (tree
, heap
, htab_elements (cfun
->used_types_hash
));
2469 htab_traverse (cfun
->used_types_hash
, output_used_types_helper
, &types
);
2471 /* Sort by UID to prevent dependence on hash table ordering. */
2472 qsort (VEC_address (tree
, types
), VEC_length (tree
, types
),
2473 sizeof (tree
), output_types_sort
);
2475 for (i
= 0; VEC_iterate (tree
, types
, i
, type
); i
++)
2476 debug_queue_symbol (type
);
2478 VEC_free (tree
, heap
, types
);
2482 /* Output a .stabs for the symbol defined by DECL,
2483 which must be a ..._DECL node in the normal namespace.
2484 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
2485 LOCAL is nonzero if the scope is less than the entire file.
2486 Return 1 if a stabs might have been emitted. */
2489 dbxout_symbol (tree decl
, int local ATTRIBUTE_UNUSED
)
2491 tree type
= TREE_TYPE (decl
);
2492 tree context
= NULL_TREE
;
2496 /* "Intercept" dbxout_symbol() calls like we do all debug_hooks. */
2499 /* Ignore nameless syms, but don't ignore type tags. */
2501 if ((DECL_NAME (decl
) == 0 && TREE_CODE (decl
) != TYPE_DECL
)
2502 || DECL_IGNORED_P (decl
))
2503 DBXOUT_DECR_NESTING_AND_RETURN (0);
2505 /* If we are to generate only the symbols actually used then such
2506 symbol nodes are flagged with TREE_USED. Ignore any that
2507 aren't flagged as TREE_USED. */
2509 if (flag_debug_only_used_symbols
2510 && (!TREE_USED (decl
)
2511 && (TREE_CODE (decl
) != VAR_DECL
|| !DECL_INITIAL (decl
))))
2512 DBXOUT_DECR_NESTING_AND_RETURN (0);
2514 /* If dbxout_init has not yet run, queue this symbol for later. */
2517 preinit_symbols
= tree_cons (0, decl
, preinit_symbols
);
2518 DBXOUT_DECR_NESTING_AND_RETURN (0);
2521 if (flag_debug_only_used_symbols
)
2525 /* We now have a used symbol. We need to generate the info for
2526 the symbol's type in addition to the symbol itself. These
2527 type symbols are queued to be generated after were done with
2528 the symbol itself (otherwise they would fight over the
2531 Note, because the TREE_TYPE(type) might be something like a
2532 pointer to a named type we need to look for the first name
2533 we see following the TREE_TYPE chain. */
2536 while (POINTER_TYPE_P (t
))
2539 /* RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, and ENUMERAL_TYPE
2540 need special treatment. The TYPE_STUB_DECL field in these
2541 types generally represents the tag name type we want to
2542 output. In addition there could be a typedef type with
2543 a different name. In that case we also want to output
2546 if (TREE_CODE (t
) == RECORD_TYPE
2547 || TREE_CODE (t
) == UNION_TYPE
2548 || TREE_CODE (t
) == QUAL_UNION_TYPE
2549 || TREE_CODE (t
) == ENUMERAL_TYPE
)
2551 if (TYPE_STUB_DECL (t
)
2552 && TYPE_STUB_DECL (t
) != decl
2553 && DECL_P (TYPE_STUB_DECL (t
))
2554 && ! DECL_IGNORED_P (TYPE_STUB_DECL (t
)))
2556 debug_queue_symbol (TYPE_STUB_DECL (t
));
2558 && TYPE_NAME (t
) != TYPE_STUB_DECL (t
)
2559 && TYPE_NAME (t
) != decl
2560 && DECL_P (TYPE_NAME (t
)))
2561 debug_queue_symbol (TYPE_NAME (t
));
2564 else if (TYPE_NAME (t
)
2565 && TYPE_NAME (t
) != decl
2566 && DECL_P (TYPE_NAME (t
)))
2567 debug_queue_symbol (TYPE_NAME (t
));
2570 emit_pending_bincls_if_required ();
2572 switch (TREE_CODE (decl
))
2575 /* Enum values are defined by defining the enum type. */
2579 decl_rtl
= DECL_RTL_IF_SET (decl
);
2581 DBXOUT_DECR_NESTING_AND_RETURN (0);
2582 if (DECL_EXTERNAL (decl
))
2584 /* Don't mention a nested function under its parent. */
2585 context
= decl_function_context (decl
);
2586 if (context
== current_function_decl
)
2588 /* Don't mention an inline instance of a nested function. */
2589 if (context
&& DECL_FROM_INLINE (decl
))
2591 if (!MEM_P (decl_rtl
)
2592 || GET_CODE (XEXP (decl_rtl
, 0)) != SYMBOL_REF
)
2595 if (flag_debug_only_used_symbols
)
2596 output_used_types ();
2598 dbxout_begin_complex_stabs ();
2599 stabstr_I (DECL_ASSEMBLER_NAME (decl
));
2600 stabstr_S (TREE_PUBLIC (decl
) ? ":F" : ":f");
2603 if (TREE_TYPE (type
))
2604 dbxout_type (TREE_TYPE (type
), 0);
2606 dbxout_type (void_type_node
, 0);
2608 /* For a nested function, when that function is compiled,
2609 mention the containing function name
2610 as well as (since dbx wants it) our own assembler-name. */
2614 stabstr_I (DECL_ASSEMBLER_NAME (decl
));
2616 stabstr_I (DECL_NAME (context
));
2619 dbxout_finish_complex_stabs (decl
, N_FUN
, XEXP (decl_rtl
, 0), 0, 0);
2623 /* Don't output the same typedef twice.
2624 And don't output what language-specific stuff doesn't want output. */
2625 if (TREE_ASM_WRITTEN (decl
) || TYPE_DECL_SUPPRESS_DEBUG (decl
))
2626 DBXOUT_DECR_NESTING_AND_RETURN (0);
2628 /* Don't output typedefs for types with magic type numbers (XCOFF). */
2629 #ifdef DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER
2631 int fundamental_type_number
=
2632 DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER (decl
);
2634 if (fundamental_type_number
!= 0)
2636 TREE_ASM_WRITTEN (decl
) = 1;
2637 TYPE_SYMTAB_ADDRESS (TREE_TYPE (decl
)) = fundamental_type_number
;
2638 DBXOUT_DECR_NESTING_AND_RETURN (0);
2648 if (DECL_NAME (decl
))
2650 /* Nonzero means we must output a tag as well as a typedef. */
2653 /* Handle the case of a C++ structure or union
2654 where the TYPE_NAME is a TYPE_DECL
2655 which gives both a typedef name and a tag. */
2656 /* dbx requires the tag first and the typedef second. */
2657 if ((TREE_CODE (type
) == RECORD_TYPE
2658 || TREE_CODE (type
) == UNION_TYPE
2659 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
2660 && TYPE_NAME (type
) == decl
2661 && !use_gnu_debug_info_extensions
2662 && !TREE_ASM_WRITTEN (TYPE_NAME (type
))
2663 /* Distinguish the implicit typedefs of C++
2664 from explicit ones that might be found in C. */
2665 && DECL_ARTIFICIAL (decl
)
2666 /* Do not generate a tag for incomplete records. */
2667 && COMPLETE_TYPE_P (type
)
2668 /* Do not generate a tag for records of variable size,
2669 since this type can not be properly described in the
2670 DBX format, and it confuses some tools such as objdump. */
2671 && host_integerp (TYPE_SIZE (type
), 1))
2673 tree name
= TYPE_NAME (type
);
2674 if (TREE_CODE (name
) == TYPE_DECL
)
2675 name
= DECL_NAME (name
);
2677 dbxout_begin_complex_stabs ();
2680 dbxout_type (type
, 1);
2681 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE
,
2685 dbxout_begin_complex_stabs ();
2687 /* Output leading class/struct qualifiers. */
2688 if (use_gnu_debug_info_extensions
)
2689 dbxout_class_name_qualifiers (decl
);
2691 /* Output typedef name. */
2692 stabstr_I (DECL_NAME (decl
));
2695 /* Short cut way to output a tag also. */
2696 if ((TREE_CODE (type
) == RECORD_TYPE
2697 || TREE_CODE (type
) == UNION_TYPE
2698 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
2699 && TYPE_NAME (type
) == decl
2700 /* Distinguish the implicit typedefs of C++
2701 from explicit ones that might be found in C. */
2702 && DECL_ARTIFICIAL (decl
))
2704 if (use_gnu_debug_info_extensions
)
2707 TREE_ASM_WRITTEN (TYPE_NAME (type
)) = 1;
2712 dbxout_type (type
, 1);
2713 dbxout_finish_complex_stabs (decl
, DBX_TYPE_DECL_STABS_CODE
,
2718 /* Don't output a tag if this is an incomplete type. This prevents
2719 the sun4 Sun OS 4.x dbx from crashing. */
2721 if (tag_needed
&& TYPE_NAME (type
) != 0
2722 && (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
2723 || (DECL_NAME (TYPE_NAME (type
)) != 0))
2724 && COMPLETE_TYPE_P (type
)
2725 && !TREE_ASM_WRITTEN (TYPE_NAME (type
)))
2727 /* For a TYPE_DECL with no name, but the type has a name,
2729 This is what represents `struct foo' with no typedef. */
2730 /* In C++, the name of a type is the corresponding typedef.
2731 In C, it is an IDENTIFIER_NODE. */
2732 tree name
= TYPE_NAME (type
);
2733 if (TREE_CODE (name
) == TYPE_DECL
)
2734 name
= DECL_NAME (name
);
2736 dbxout_begin_complex_stabs ();
2739 dbxout_type (type
, 1);
2740 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE
, 0, 0, 0);
2744 /* If an enum type has no name, it cannot be referred to, but
2745 we must output it anyway, to record the enumeration
2748 if (!did_output
&& TREE_CODE (type
) == ENUMERAL_TYPE
)
2750 dbxout_begin_complex_stabs ();
2751 /* Some debuggers fail when given NULL names, so give this a
2752 harmless name of " " (Why not "(anon)"?). */
2754 dbxout_type (type
, 1);
2755 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE
, 0, 0, 0);
2758 /* Prevent duplicate output of a typedef. */
2759 TREE_ASM_WRITTEN (decl
) = 1;
2764 /* Parm decls go in their own separate chains
2765 and are output by dbxout_reg_parms and dbxout_parms. */
2770 /* Don't mention a variable that is external.
2771 Let the file that defines it describe it. */
2772 if (DECL_EXTERNAL (decl
))
2775 /* If the variable is really a constant
2776 and not written in memory, inform the debugger.
2778 ??? Why do we skip emitting the type and location in this case? */
2779 if (TREE_STATIC (decl
) && TREE_READONLY (decl
)
2780 && DECL_INITIAL (decl
) != 0
2781 && host_integerp (DECL_INITIAL (decl
), 0)
2782 && ! TREE_ASM_WRITTEN (decl
)
2783 && (DECL_CONTEXT (decl
) == NULL_TREE
2784 || TREE_CODE (DECL_CONTEXT (decl
)) == BLOCK
2785 || TREE_CODE (DECL_CONTEXT (decl
)) == NAMESPACE_DECL
)
2786 && TREE_PUBLIC (decl
) == 0)
2788 /* The sun4 assembler does not grok this. */
2790 if (TREE_CODE (TREE_TYPE (decl
)) == INTEGER_TYPE
2791 || TREE_CODE (TREE_TYPE (decl
)) == ENUMERAL_TYPE
)
2793 HOST_WIDE_INT ival
= TREE_INT_CST_LOW (DECL_INITIAL (decl
));
2795 dbxout_begin_complex_stabs ();
2796 dbxout_symbol_name (decl
, NULL
, 'c');
2799 dbxout_finish_complex_stabs (0, N_LSYM
, 0, 0, 0);
2800 DBXOUT_DECR_NESTING
;
2806 /* else it is something we handle like a normal variable. */
2808 decl_rtl
= dbxout_expand_expr (decl
);
2810 DBXOUT_DECR_NESTING_AND_RETURN (0);
2812 decl_rtl
= eliminate_regs (decl_rtl
, 0, NULL_RTX
);
2813 #ifdef LEAF_REG_REMAP
2814 if (current_function_uses_only_leaf_regs
)
2815 leaf_renumber_regs_insn (decl_rtl
);
2818 result
= dbxout_symbol_location (decl
, type
, 0, decl_rtl
);
2824 DBXOUT_DECR_NESTING
;
2828 /* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL.
2829 Add SUFFIX to its name, if SUFFIX is not 0.
2830 Describe the variable as residing in HOME
2831 (usually HOME is DECL_RTL (DECL), but not always).
2832 Returns 1 if the stab was really emitted. */
2835 dbxout_symbol_location (tree decl
, tree type
, const char *suffix
, rtx home
)
2838 STAB_CODE_TYPE code
;
2843 /* Don't mention a variable at all
2844 if it was completely optimized into nothingness.
2846 If the decl was from an inline function, then its rtl
2847 is not identically the rtl that was used in this
2848 particular compilation. */
2849 if (GET_CODE (home
) == SUBREG
)
2853 while (GET_CODE (value
) == SUBREG
)
2854 value
= SUBREG_REG (value
);
2857 if (REGNO (value
) >= FIRST_PSEUDO_REGISTER
)
2860 home
= alter_subreg (&home
);
2864 regno
= REGNO (home
);
2865 if (regno
>= FIRST_PSEUDO_REGISTER
)
2869 /* The kind-of-variable letter depends on where
2870 the variable is and on the scope of its name:
2871 G and N_GSYM for static storage and global scope,
2872 S for static storage and file scope,
2873 V for static storage and local scope,
2874 for those two, use N_LCSYM if data is in bss segment,
2875 N_STSYM if in data segment, N_FUN otherwise.
2876 (We used N_FUN originally, then changed to N_STSYM
2877 to please GDB. However, it seems that confused ld.
2878 Now GDB has been fixed to like N_FUN, says Kingdon.)
2879 no letter at all, and N_LSYM, for auto variable,
2880 r and N_RSYM for register variable. */
2882 if (MEM_P (home
) && GET_CODE (XEXP (home
, 0)) == SYMBOL_REF
)
2884 if (TREE_PUBLIC (decl
))
2889 if (NULL
!= dbxout_common_check (decl
, &offs
))
2898 addr
= XEXP (home
, 0);
2900 letter
= decl_function_context (decl
) ? 'V' : 'S';
2902 /* Some ports can transform a symbol ref into a label ref,
2903 because the symbol ref is too far away and has to be
2904 dumped into a constant pool. Alternatively, the symbol
2905 in the constant pool might be referenced by a different
2907 if (GET_CODE (addr
) == SYMBOL_REF
2908 && CONSTANT_POOL_ADDRESS_P (addr
))
2911 rtx tmp
= get_pool_constant_mark (addr
, &marked
);
2913 if (GET_CODE (tmp
) == SYMBOL_REF
)
2916 if (CONSTANT_POOL_ADDRESS_P (addr
))
2917 get_pool_constant_mark (addr
, &marked
);
2921 else if (GET_CODE (tmp
) == LABEL_REF
)
2927 /* If all references to the constant pool were optimized
2928 out, we just ignore the symbol. */
2933 /* This should be the same condition as in assemble_variable, but
2934 we don't have access to dont_output_data here. So, instead,
2935 we rely on the fact that error_mark_node initializers always
2936 end up in bss for C++ and never end up in bss for C. */
2937 if (DECL_INITIAL (decl
) == 0
2938 || (!strcmp (lang_hooks
.name
, "GNU C++")
2939 && DECL_INITIAL (decl
) == error_mark_node
))
2943 if (NULL
!= dbxout_common_check (decl
, &offs
))
2951 else if (DECL_IN_TEXT_SECTION (decl
))
2952 /* This is not quite right, but it's the closest
2953 of all the codes that Unix defines. */
2954 code
= DBX_STATIC_CONST_VAR_CODE
;
2957 /* Ultrix `as' seems to need this. */
2958 #ifdef DBX_STATIC_STAB_DATA_SECTION
2959 switch_to_section (data_section
);
2965 else if (regno
>= 0)
2969 number
= DBX_REGISTER_NUMBER (regno
);
2971 else if (MEM_P (home
)
2972 && (MEM_P (XEXP (home
, 0))
2973 || (REG_P (XEXP (home
, 0))
2974 && REGNO (XEXP (home
, 0)) != HARD_FRAME_POINTER_REGNUM
2975 && REGNO (XEXP (home
, 0)) != STACK_POINTER_REGNUM
2976 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2977 && REGNO (XEXP (home
, 0)) != ARG_POINTER_REGNUM
2980 /* If the value is indirect by memory or by a register
2981 that isn't the frame pointer
2982 then it means the object is variable-sized and address through
2983 that register or stack slot. DBX has no way to represent this
2984 so all we can do is output the variable as a pointer.
2985 If it's not a parameter, ignore it. */
2987 if (REG_P (XEXP (home
, 0)))
2991 if (REGNO (XEXP (home
, 0)) >= FIRST_PSEUDO_REGISTER
)
2993 number
= DBX_REGISTER_NUMBER (REGNO (XEXP (home
, 0)));
2998 /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
2999 We want the value of that CONST_INT. */
3000 number
= DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home
, 0), 0));
3003 /* Effectively do build_pointer_type, but don't cache this type,
3004 since it might be temporary whereas the type it points to
3005 might have been saved for inlining. */
3006 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
3007 type
= make_node (POINTER_TYPE
);
3008 TREE_TYPE (type
) = TREE_TYPE (decl
);
3010 else if (MEM_P (home
)
3011 && REG_P (XEXP (home
, 0)))
3014 number
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
3016 else if (MEM_P (home
)
3017 && GET_CODE (XEXP (home
, 0)) == PLUS
3018 && GET_CODE (XEXP (XEXP (home
, 0), 1)) == CONST_INT
)
3021 /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
3022 We want the value of that CONST_INT. */
3023 number
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
3025 else if (MEM_P (home
)
3026 && GET_CODE (XEXP (home
, 0)) == CONST
)
3028 /* Handle an obscure case which can arise when optimizing and
3029 when there are few available registers. (This is *always*
3030 the case for i386/i486 targets). The RTL looks like
3031 (MEM (CONST ...)) even though this variable is a local `auto'
3032 or a local `register' variable. In effect, what has happened
3033 is that the reload pass has seen that all assignments and
3034 references for one such a local variable can be replaced by
3035 equivalent assignments and references to some static storage
3036 variable, thereby avoiding the need for a register. In such
3037 cases we're forced to lie to debuggers and tell them that
3038 this variable was itself `static'. */
3042 if (NULL
== dbxout_common_check (decl
, &offs
))
3043 addr
= XEXP (XEXP (home
, 0), 0);
3051 else if (GET_CODE (home
) == CONCAT
)
3055 /* If TYPE is not a COMPLEX_TYPE (it might be a RECORD_TYPE,
3056 for example), then there is no easy way to figure out
3057 what SUBTYPE should be. So, we give up. */
3058 if (TREE_CODE (type
) != COMPLEX_TYPE
)
3061 subtype
= TREE_TYPE (type
);
3063 /* If the variable's storage is in two parts,
3064 output each as a separate stab with a modified name. */
3065 if (WORDS_BIG_ENDIAN
)
3066 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 0));
3068 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 0));
3070 if (WORDS_BIG_ENDIAN
)
3071 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 1));
3073 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 1));
3077 /* Address might be a MEM, when DECL is a variable-sized object.
3078 Or it might be const0_rtx, meaning previous passes
3079 want us to ignore this variable. */
3082 /* Ok, start a symtab entry and output the variable name. */
3083 emit_pending_bincls_if_required ();
3086 #ifdef DBX_STATIC_BLOCK_START
3087 DBX_STATIC_BLOCK_START (asm_out_file
, code
);
3090 dbxout_begin_complex_stabs_noforcetext ();
3091 dbxout_symbol_name (decl
, suffix
, letter
);
3092 dbxout_type (type
, 0);
3093 dbxout_finish_complex_stabs (decl
, code
, addr
, 0, number
);
3095 #ifdef DBX_STATIC_BLOCK_END
3096 DBX_STATIC_BLOCK_END (asm_out_file
, code
);
3101 /* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
3102 Then output LETTER to indicate the kind of location the symbol has. */
3105 dbxout_symbol_name (tree decl
, const char *suffix
, int letter
)
3109 if (DECL_CONTEXT (decl
)
3110 && (TYPE_P (DECL_CONTEXT (decl
))
3111 || TREE_CODE (DECL_CONTEXT (decl
)) == NAMESPACE_DECL
))
3112 /* One slight hitch: if this is a VAR_DECL which is a class member
3113 or a namespace member, we must put out the mangled name instead of the
3114 DECL_NAME. Note also that static member (variable) names DO NOT begin
3115 with underscores in .stabs directives. */
3116 name
= DECL_ASSEMBLER_NAME (decl
);
3118 /* ...but if we're function-local, we don't want to include the junk
3119 added by ASM_FORMAT_PRIVATE_NAME. */
3120 name
= DECL_NAME (decl
);
3125 stabstr_S ("(anon)");
3135 /* Output the common block name for DECL in a stabs.
3137 Symbols in global common (.comm) get wrapped with an N_BCOMM/N_ECOMM pair
3138 around each group of symbols in the same .comm area. The N_GSYM stabs
3139 that are emitted only contain the offset in the common area. This routine
3140 emits the N_BCOMM and N_ECOMM stabs. */
3143 dbxout_common_name (tree decl
, const char *name
, STAB_CODE_TYPE op
)
3145 dbxout_begin_complex_stabs ();
3147 dbxout_finish_complex_stabs (decl
, op
, NULL_RTX
, NULL
, 0);
3150 /* Check decl to determine whether it is a VAR_DECL destined for storage in a
3151 common area. If it is, the return value will be a non-null string giving
3152 the name of the common storage block it will go into. If non-null, the
3153 value is the offset into the common block for that symbol's storage. */
3156 dbxout_common_check (tree decl
, int *value
)
3160 const char *name
= NULL
;
3162 /* If the decl isn't a VAR_DECL, or if it isn't public or static, or if
3163 it does not have a value (the offset into the common area), or if it
3164 is thread local (as opposed to global) then it isn't common, and shouldn't
3167 ??? DECL_THREAD_LOCAL_P check prevents problems with improper .stabs
3168 for thread-local symbols. Can be handled via same mechanism as used
3170 if (TREE_CODE (decl
) != VAR_DECL
3171 || !TREE_PUBLIC(decl
)
3172 || !TREE_STATIC(decl
)
3173 || !DECL_HAS_VALUE_EXPR_P(decl
)
3174 || DECL_THREAD_LOCAL_P (decl
)
3178 home
= DECL_RTL (decl
);
3179 if (home
== NULL_RTX
|| GET_CODE (home
) != MEM
)
3182 sym_addr
= dbxout_expand_expr (DECL_VALUE_EXPR (decl
));
3183 if (sym_addr
== NULL_RTX
|| GET_CODE (sym_addr
) != MEM
)
3186 sym_addr
= XEXP (sym_addr
, 0);
3187 if (GET_CODE (sym_addr
) == CONST
)
3188 sym_addr
= XEXP (sym_addr
, 0);
3189 if ((GET_CODE (sym_addr
) == SYMBOL_REF
|| GET_CODE (sym_addr
) == PLUS
)
3190 && DECL_INITIAL (decl
) == 0)
3193 /* We have a sym that will go into a common area, meaning that it
3194 will get storage reserved with a .comm/.lcomm assembler pseudo-op.
3196 Determine name of common area this symbol will be an offset into,
3197 and offset into that area. Also retrieve the decl for the area
3198 that the symbol is offset into. */
3201 switch (GET_CODE (sym_addr
))
3204 if (GET_CODE (XEXP (sym_addr
, 0)) == CONST_INT
)
3207 targetm
.strip_name_encoding(XSTR (XEXP (sym_addr
, 1), 0));
3208 *value
= INTVAL (XEXP (sym_addr
, 0));
3209 cdecl = SYMBOL_REF_DECL (XEXP (sym_addr
, 1));
3214 targetm
.strip_name_encoding(XSTR (XEXP (sym_addr
, 0), 0));
3215 *value
= INTVAL (XEXP (sym_addr
, 1));
3216 cdecl = SYMBOL_REF_DECL (XEXP (sym_addr
, 0));
3221 name
= targetm
.strip_name_encoding(XSTR (sym_addr
, 0));
3223 cdecl = SYMBOL_REF_DECL (sym_addr
);
3227 error ("common symbol debug info is not structured as "
3231 /* Check area common symbol is offset into. If this is not public, then
3232 it is not a symbol in a common block. It must be a .lcomm symbol, not
3234 if (cdecl == NULL
|| !TREE_PUBLIC(cdecl))
3243 /* Output definitions of all the decls in a chain. Return nonzero if
3244 anything was output */
3247 dbxout_syms (tree syms
)
3250 const char *comm_prev
= NULL
;
3251 tree syms_prev
= NULL
;
3255 int temp
, copen
, cclos
;
3256 const char *comm_new
;
3258 /* Check for common symbol, and then progression into a new/different
3259 block of common symbols. Emit closing/opening common bracket if
3261 comm_new
= dbxout_common_check (syms
, &temp
);
3262 copen
= comm_new
!= NULL
3263 && (comm_prev
== NULL
|| strcmp (comm_new
, comm_prev
));
3264 cclos
= comm_prev
!= NULL
3265 && (comm_new
== NULL
|| strcmp (comm_new
, comm_prev
));
3267 dbxout_common_name (syms_prev
, comm_prev
, N_ECOMM
);
3270 dbxout_common_name (syms
, comm_new
, N_BCOMM
);
3273 comm_prev
= comm_new
;
3275 result
+= dbxout_symbol (syms
, 1);
3276 syms
= TREE_CHAIN (syms
);
3279 if (comm_prev
!= NULL
)
3280 dbxout_common_name (syms_prev
, comm_prev
, N_ECOMM
);
3285 /* The following two functions output definitions of function parameters.
3286 Each parameter gets a definition locating it in the parameter list.
3287 Each parameter that is a register variable gets a second definition
3288 locating it in the register.
3290 Printing or argument lists in gdb uses the definitions that
3291 locate in the parameter list. But reference to the variable in
3292 expressions uses preferentially the definition as a register. */
3294 /* Output definitions, referring to storage in the parmlist,
3295 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
3298 dbxout_parms (tree parms
)
3301 emit_pending_bincls_if_required ();
3303 for (; parms
; parms
= TREE_CHAIN (parms
))
3304 if (DECL_NAME (parms
)
3305 && TREE_TYPE (parms
) != error_mark_node
3306 && DECL_RTL_SET_P (parms
)
3307 && DECL_INCOMING_RTL (parms
))
3311 STAB_CODE_TYPE code
;
3314 /* Perform any necessary register eliminations on the parameter's rtl,
3315 so that the debugging output will be accurate. */
3316 DECL_INCOMING_RTL (parms
)
3317 = eliminate_regs (DECL_INCOMING_RTL (parms
), 0, NULL_RTX
);
3318 SET_DECL_RTL (parms
, eliminate_regs (DECL_RTL (parms
), 0, NULL_RTX
));
3319 #ifdef LEAF_REG_REMAP
3320 if (current_function_uses_only_leaf_regs
)
3322 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms
));
3323 leaf_renumber_regs_insn (DECL_RTL (parms
));
3327 if (PARM_PASSED_IN_MEMORY (parms
))
3329 rtx inrtl
= XEXP (DECL_INCOMING_RTL (parms
), 0);
3331 /* ??? Here we assume that the parm address is indexed
3332 off the frame pointer or arg pointer.
3333 If that is not true, we produce meaningless results,
3334 but do not crash. */
3335 if (GET_CODE (inrtl
) == PLUS
3336 && GET_CODE (XEXP (inrtl
, 1)) == CONST_INT
)
3337 number
= INTVAL (XEXP (inrtl
, 1));
3342 number
= DEBUGGER_ARG_OFFSET (number
, inrtl
);
3345 /* It is quite tempting to use TREE_TYPE (parms) instead
3346 of DECL_ARG_TYPE (parms) for the eff_type, so that gcc
3347 reports the actual type of the parameter, rather than
3348 the promoted type. This certainly makes GDB's life
3349 easier, at least for some ports. The change is a bad
3350 idea however, since GDB expects to be able access the
3351 type without performing any conversions. So for
3352 example, if we were passing a float to an unprototyped
3353 function, gcc will store a double on the stack, but if
3354 we emit a stab saying the type is a float, then gdb
3355 will only read in a single value, and this will produce
3356 an erroneous value. */
3357 eff_type
= DECL_ARG_TYPE (parms
);
3359 else if (REG_P (DECL_RTL (parms
)))
3363 /* Parm passed in registers and lives in registers or nowhere. */
3364 code
= DBX_REGPARM_STABS_CODE
;
3365 letter
= DBX_REGPARM_STABS_LETTER
;
3367 /* For parms passed in registers, it is better to use the
3368 declared type of the variable, not the type it arrived in. */
3369 eff_type
= TREE_TYPE (parms
);
3371 /* If parm lives in a register, use that register; pretend
3372 the parm was passed there. It would be more consistent
3373 to describe the register where the parm was passed, but
3374 in practice that register usually holds something else.
3375 If the parm lives nowhere, use the register where it
3377 if (REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
3378 best_rtl
= DECL_RTL (parms
);
3379 else if (GET_CODE (DECL_INCOMING_RTL (parms
)) == PARALLEL
)
3380 best_rtl
= XEXP (XVECEXP (DECL_INCOMING_RTL (parms
), 0, 0), 0);
3382 best_rtl
= DECL_INCOMING_RTL (parms
);
3384 number
= DBX_REGISTER_NUMBER (REGNO (best_rtl
));
3386 else if (MEM_P (DECL_RTL (parms
))
3387 && REG_P (XEXP (DECL_RTL (parms
), 0))
3388 && REGNO (XEXP (DECL_RTL (parms
), 0)) != HARD_FRAME_POINTER_REGNUM
3389 && REGNO (XEXP (DECL_RTL (parms
), 0)) != STACK_POINTER_REGNUM
3390 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
3391 && REGNO (XEXP (DECL_RTL (parms
), 0)) != ARG_POINTER_REGNUM
3395 /* Parm was passed via invisible reference.
3396 That is, its address was passed in a register.
3397 Output it as if it lived in that register.
3398 The debugger will know from the type
3399 that it was actually passed by invisible reference. */
3401 code
= DBX_REGPARM_STABS_CODE
;
3403 /* GDB likes this marked with a special letter. */
3404 letter
= (use_gnu_debug_info_extensions
3405 ? 'a' : DBX_REGPARM_STABS_LETTER
);
3406 eff_type
= TREE_TYPE (parms
);
3408 /* DECL_RTL looks like (MEM (REG...). Get the register number.
3409 If it is an unallocated pseudo-reg, then use the register where
3410 it was passed instead.
3411 ??? Why is DBX_REGISTER_NUMBER not used here? */
3413 if (REGNO (XEXP (DECL_RTL (parms
), 0)) < FIRST_PSEUDO_REGISTER
)
3414 number
= REGNO (XEXP (DECL_RTL (parms
), 0));
3416 number
= REGNO (DECL_INCOMING_RTL (parms
));
3418 else if (MEM_P (DECL_RTL (parms
))
3419 && MEM_P (XEXP (DECL_RTL (parms
), 0)))
3421 /* Parm was passed via invisible reference, with the reference
3422 living on the stack. DECL_RTL looks like
3423 (MEM (MEM (PLUS (REG ...) (CONST_INT ...)))) or it
3424 could look like (MEM (MEM (REG))). */
3428 eff_type
= TREE_TYPE (parms
);
3430 if (!REG_P (XEXP (XEXP (DECL_RTL (parms
), 0), 0)))
3431 number
= INTVAL (XEXP (XEXP (XEXP (DECL_RTL (parms
), 0), 0), 1));
3435 number
= DEBUGGER_ARG_OFFSET (number
,
3436 XEXP (XEXP (DECL_RTL (parms
), 0), 0));
3438 else if (MEM_P (DECL_RTL (parms
))
3439 && XEXP (DECL_RTL (parms
), 0) != const0_rtx
3440 /* ??? A constant address for a parm can happen
3441 when the reg it lives in is equiv to a constant in memory.
3442 Should make this not happen, after 2.4. */
3443 && ! CONSTANT_P (XEXP (DECL_RTL (parms
), 0)))
3445 /* Parm was passed in registers but lives on the stack. */
3449 eff_type
= TREE_TYPE (parms
);
3451 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
3452 in which case we want the value of that CONST_INT,
3454 in which case we use a value of zero. */
3455 if (!REG_P (XEXP (DECL_RTL (parms
), 0)))
3456 number
= INTVAL (XEXP (XEXP (DECL_RTL (parms
), 0), 1));
3460 /* Make a big endian correction if the mode of the type of the
3461 parameter is not the same as the mode of the rtl. */
3462 if (BYTES_BIG_ENDIAN
3463 && TYPE_MODE (TREE_TYPE (parms
)) != GET_MODE (DECL_RTL (parms
))
3464 && GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms
))) < UNITS_PER_WORD
)
3465 number
+= (GET_MODE_SIZE (GET_MODE (DECL_RTL (parms
)))
3466 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms
))));
3469 /* ??? We don't know how to represent this argument. */
3472 dbxout_begin_complex_stabs ();
3474 if (DECL_NAME (parms
))
3476 stabstr_I (DECL_NAME (parms
));
3480 stabstr_S ("(anon):");
3482 dbxout_type (eff_type
, 0);
3483 dbxout_finish_complex_stabs (parms
, code
, 0, 0, number
);
3485 DBXOUT_DECR_NESTING
;
3488 /* Output definitions for the places where parms live during the function,
3489 when different from where they were passed, when the parms were passed
3492 It is not useful to do this for parms passed in registers
3493 that live during the function in different registers, because it is
3494 impossible to look in the passed register for the passed value,
3495 so we use the within-the-function register to begin with.
3497 PARMS is a chain of PARM_DECL nodes. */
3500 dbxout_reg_parms (tree parms
)
3504 for (; parms
; parms
= TREE_CHAIN (parms
))
3505 if (DECL_NAME (parms
) && PARM_PASSED_IN_MEMORY (parms
))
3507 /* Report parms that live in registers during the function
3508 but were passed in memory. */
3509 if (REG_P (DECL_RTL (parms
))
3510 && REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
3511 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
3512 0, DECL_RTL (parms
));
3513 else if (GET_CODE (DECL_RTL (parms
)) == CONCAT
)
3514 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
3515 0, DECL_RTL (parms
));
3516 /* Report parms that live in memory but not where they were passed. */
3517 else if (MEM_P (DECL_RTL (parms
))
3518 && ! rtx_equal_p (DECL_RTL (parms
), DECL_INCOMING_RTL (parms
)))
3519 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
3520 0, DECL_RTL (parms
));
3522 DBXOUT_DECR_NESTING
;
3525 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
3526 output definitions of those names, in raw form */
3529 dbxout_args (tree args
)
3534 dbxout_type (TREE_VALUE (args
), 0);
3535 args
= TREE_CHAIN (args
);
3539 #if defined (DBX_DEBUGGING_INFO)
3541 /* Subroutine of dbxout_block. Emit an N_LBRAC stab referencing LABEL.
3542 BEGIN_LABEL is the name of the beginning of the function, which may
3545 dbx_output_lbrac (const char *label
,
3546 const char *begin_label ATTRIBUTE_UNUSED
)
3548 dbxout_begin_stabn (N_LBRAC
);
3549 if (DBX_BLOCKS_FUNCTION_RELATIVE
)
3550 dbxout_stab_value_label_diff (label
, begin_label
);
3552 dbxout_stab_value_label (label
);
3555 /* Subroutine of dbxout_block. Emit an N_RBRAC stab referencing LABEL.
3556 BEGIN_LABEL is the name of the beginning of the function, which may
3559 dbx_output_rbrac (const char *label
,
3560 const char *begin_label ATTRIBUTE_UNUSED
)
3562 dbxout_begin_stabn (N_RBRAC
);
3563 if (DBX_BLOCKS_FUNCTION_RELATIVE
)
3564 dbxout_stab_value_label_diff (label
, begin_label
);
3566 dbxout_stab_value_label (label
);
3569 /* Output everything about a symbol block (a BLOCK node
3570 that represents a scope level),
3571 including recursive output of contained blocks.
3573 BLOCK is the BLOCK node.
3574 DEPTH is its depth within containing symbol blocks.
3575 ARGS is usually zero; but for the outermost block of the
3576 body of a function, it is a chain of PARM_DECLs for the function parameters.
3577 We output definitions of all the register parms
3578 as if they were local variables of that block.
3580 If -g1 was used, we count blocks just the same, but output nothing
3581 except for the outermost block.
3583 Actually, BLOCK may be several blocks chained together.
3584 We handle them all in sequence. */
3587 dbxout_block (tree block
, int depth
, tree args
)
3589 char begin_label
[20];
3590 /* Reference current function start using LFBB. */
3591 ASM_GENERATE_INTERNAL_LABEL (begin_label
, "LFBB", scope_labelno
);
3595 /* Ignore blocks never expanded or otherwise marked as real. */
3596 if (TREE_ASM_WRITTEN (block
))
3599 int blocknum
= BLOCK_NUMBER (block
);
3601 /* In dbx format, the syms of a block come before the N_LBRAC.
3602 If nothing is output, we don't need the N_LBRAC, either. */
3604 if (debug_info_level
!= DINFO_LEVEL_TERSE
|| depth
== 0)
3605 did_output
= dbxout_syms (BLOCK_VARS (block
));
3607 dbxout_reg_parms (args
);
3609 /* Now output an N_LBRAC symbol to represent the beginning of
3610 the block. Use the block's tree-walk order to generate
3611 the assembler symbols LBBn and LBEn
3612 that final will define around the code in this block. */
3616 const char *scope_start
;
3619 /* The outermost block doesn't get LBB labels; use
3620 the LFBB local symbol emitted by dbxout_begin_prologue. */
3621 scope_start
= begin_label
;
3624 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBB", blocknum
);
3628 if (BLOCK_HANDLER_BLOCK (block
))
3630 /* A catch block. Must precede N_LBRAC. */
3631 tree decl
= BLOCK_VARS (block
);
3634 dbxout_begin_complex_stabs ();
3635 stabstr_I (DECL_NAME (decl
));
3637 dbxout_finish_complex_stabs (0, N_CATCH
, 0,
3639 decl
= TREE_CHAIN (decl
);
3642 dbx_output_lbrac (scope_start
, begin_label
);
3645 /* Output the subblocks. */
3646 dbxout_block (BLOCK_SUBBLOCKS (block
), depth
+ 1, NULL_TREE
);
3648 /* Refer to the marker for the end of the block. */
3653 /* The outermost block doesn't get LBE labels;
3654 use the "scope" label which will be emitted
3655 by dbxout_function_end. */
3656 ASM_GENERATE_INTERNAL_LABEL (buf
, "Lscope", scope_labelno
);
3658 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBE", blocknum
);
3660 dbx_output_rbrac (buf
, begin_label
);
3663 block
= BLOCK_CHAIN (block
);
3667 /* Output the information about a function and its arguments and result.
3668 Usually this follows the function's code,
3669 but on some systems, it comes before. */
3672 dbxout_begin_function (tree decl
)
3674 int saved_tree_used1
;
3676 if (DECL_IGNORED_P (decl
))
3679 saved_tree_used1
= TREE_USED (decl
);
3680 TREE_USED (decl
) = 1;
3681 if (DECL_NAME (DECL_RESULT (decl
)) != 0)
3683 int saved_tree_used2
= TREE_USED (DECL_RESULT (decl
));
3684 TREE_USED (DECL_RESULT (decl
)) = 1;
3685 dbxout_symbol (decl
, 0);
3686 TREE_USED (DECL_RESULT (decl
)) = saved_tree_used2
;
3689 dbxout_symbol (decl
, 0);
3690 TREE_USED (decl
) = saved_tree_used1
;
3692 dbxout_parms (DECL_ARGUMENTS (decl
));
3693 if (DECL_NAME (DECL_RESULT (decl
)) != 0)
3694 dbxout_symbol (DECL_RESULT (decl
), 1);
3696 #endif /* DBX_DEBUGGING_INFO */
3698 #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */
3700 #include "gt-dbxout.h"