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
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 void dbxout_type_name (tree
);
326 static void dbxout_class_name_qualifiers (tree
);
327 static int dbxout_symbol_location (tree
, tree
, const char *, rtx
);
328 static void dbxout_symbol_name (tree
, const char *, int);
329 static void dbxout_block (tree
, int, tree
);
330 static void dbxout_global_decl (tree
);
331 static void dbxout_type_decl (tree
, int);
332 static void dbxout_handle_pch (unsigned);
334 /* The debug hooks structure. */
335 #if defined (DBX_DEBUGGING_INFO)
337 static void dbxout_source_line (unsigned int, const char *);
338 static void dbxout_begin_prologue (unsigned int, const char *);
339 static void dbxout_source_file (const char *);
340 static void dbxout_function_end (tree
);
341 static void dbxout_begin_function (tree
);
342 static void dbxout_begin_block (unsigned, unsigned);
343 static void dbxout_end_block (unsigned, unsigned);
344 static void dbxout_function_decl (tree
);
346 const struct gcc_debug_hooks dbx_debug_hooks
=
350 debug_nothing_int_charstar
,
351 debug_nothing_int_charstar
,
352 dbxout_start_source_file
,
353 dbxout_end_source_file
,
356 debug_true_tree
, /* ignore_block */
357 dbxout_source_line
, /* source_line */
358 dbxout_begin_prologue
, /* begin_prologue */
359 debug_nothing_int_charstar
, /* end_prologue */
360 debug_nothing_int_charstar
, /* end_epilogue */
361 #ifdef DBX_FUNCTION_FIRST
362 dbxout_begin_function
,
364 debug_nothing_tree
, /* begin_function */
366 debug_nothing_int
, /* end_function */
367 dbxout_function_decl
,
368 dbxout_global_decl
, /* global_decl */
369 dbxout_type_decl
, /* type_decl */
370 debug_nothing_tree_tree
, /* imported_module_or_decl */
371 debug_nothing_tree
, /* deferred_inline_function */
372 debug_nothing_tree
, /* outlining_inline_function */
373 debug_nothing_rtx
, /* label */
374 dbxout_handle_pch
, /* handle_pch */
375 debug_nothing_rtx
, /* var_location */
376 debug_nothing_void
, /* switch_text_section */
377 0 /* start_end_main_source_file */
379 #endif /* DBX_DEBUGGING_INFO */
381 #if defined (XCOFF_DEBUGGING_INFO)
382 const struct gcc_debug_hooks xcoff_debug_hooks
=
386 debug_nothing_int_charstar
,
387 debug_nothing_int_charstar
,
388 dbxout_start_source_file
,
389 dbxout_end_source_file
,
390 xcoffout_begin_block
,
392 debug_true_tree
, /* ignore_block */
393 xcoffout_source_line
,
394 xcoffout_begin_prologue
, /* begin_prologue */
395 debug_nothing_int_charstar
, /* end_prologue */
396 xcoffout_end_epilogue
,
397 debug_nothing_tree
, /* begin_function */
398 xcoffout_end_function
,
399 debug_nothing_tree
, /* function_decl */
400 dbxout_global_decl
, /* global_decl */
401 dbxout_type_decl
, /* type_decl */
402 debug_nothing_tree_tree
, /* imported_module_or_decl */
403 debug_nothing_tree
, /* deferred_inline_function */
404 debug_nothing_tree
, /* outlining_inline_function */
405 debug_nothing_rtx
, /* label */
406 dbxout_handle_pch
, /* handle_pch */
407 debug_nothing_rtx
, /* var_location */
408 debug_nothing_void
, /* switch_text_section */
409 0 /* start_end_main_source_file */
411 #endif /* XCOFF_DEBUGGING_INFO */
413 /* Numeric formatting helper macro. Note that this does not handle
415 #define NUMBER_FMT_LOOP(P, NUM, BASE) \
418 int digit = NUM % BASE; \
420 *--P = digit + '0'; \
424 /* Utility: write a decimal integer NUM to asm_out_file. */
429 char *p
= buf
+ sizeof buf
;
434 putc ('0', asm_out_file
);
439 putc ('-', asm_out_file
);
445 NUMBER_FMT_LOOP (p
, unum
, 10);
447 while (p
< buf
+ sizeof buf
)
449 putc (*p
, asm_out_file
);
455 /* Primitives for emitting simple stabs directives. All other stabs
456 routines should use these functions instead of directly emitting
457 stabs. They are exported because machine-dependent code may need
458 to invoke them, e.g. in a DBX_OUTPUT_* macro whose definition
459 forwards to code in CPU.c. */
461 /* The following functions should all be called immediately after one
462 of the dbxout_begin_stab* functions (below). They write out
463 various things as the value of a stab. */
465 /* Write out a literal zero as the value of a stab. */
467 dbxout_stab_value_zero (void)
469 fputs ("0\n", asm_out_file
);
472 /* Write out the label LABEL as the value of a stab. */
474 dbxout_stab_value_label (const char *label
)
476 assemble_name (asm_out_file
, label
);
477 putc ('\n', asm_out_file
);
480 /* Write out the difference of two labels, LABEL - BASE, as the value
483 dbxout_stab_value_label_diff (const char *label
, const char *base
)
485 assemble_name (asm_out_file
, label
);
486 putc ('-', asm_out_file
);
487 assemble_name (asm_out_file
, base
);
488 putc ('\n', asm_out_file
);
491 /* Write out an internal label as the value of a stab, and immediately
492 emit that internal label. This should be used only when
493 dbxout_stabd will not work. STEM is the name stem of the label,
494 COUNTERP is a pointer to a counter variable which will be used to
495 guarantee label uniqueness. */
497 dbxout_stab_value_internal_label (const char *stem
, int *counterp
)
500 int counter
= counterp
? (*counterp
)++ : 0;
502 ASM_GENERATE_INTERNAL_LABEL (label
, stem
, counter
);
503 dbxout_stab_value_label (label
);
504 targetm
.asm_out
.internal_label (asm_out_file
, stem
, counter
);
507 /* Write out the difference between BASE and an internal label as the
508 value of a stab, and immediately emit that internal label. STEM and
509 COUNTERP are as for dbxout_stab_value_internal_label. */
511 dbxout_stab_value_internal_label_diff (const char *stem
, int *counterp
,
515 int counter
= counterp
? (*counterp
)++ : 0;
517 ASM_GENERATE_INTERNAL_LABEL (label
, stem
, counter
);
518 dbxout_stab_value_label_diff (label
, base
);
519 targetm
.asm_out
.internal_label (asm_out_file
, stem
, counter
);
522 /* The following functions produce specific kinds of stab directives. */
524 /* Write a .stabd directive with type STYPE and desc SDESC to asm_out_file. */
526 dbxout_stabd (int stype
, int sdesc
)
528 fputs (ASM_STABD_OP
, asm_out_file
);
530 fputs (",0,", asm_out_file
);
532 putc ('\n', asm_out_file
);
535 /* Write a .stabn directive with type STYPE. This function stops
536 short of emitting the value field, which is the responsibility of
537 the caller (normally it will be either a symbol or the difference
541 dbxout_begin_stabn (int stype
)
543 fputs (ASM_STABN_OP
, asm_out_file
);
545 fputs (",0,0,", asm_out_file
);
548 /* Write a .stabn directive with type N_SLINE and desc LINE. As above,
549 the value field is the responsibility of the caller. */
551 dbxout_begin_stabn_sline (int lineno
)
553 fputs (ASM_STABN_OP
, asm_out_file
);
554 dbxout_int (N_SLINE
);
555 fputs (",0,", asm_out_file
);
557 putc (',', asm_out_file
);
560 /* Begin a .stabs directive with string "", type STYPE, and desc and
561 other fields 0. The value field is the responsibility of the
562 caller. This function cannot be used for .stabx directives. */
564 dbxout_begin_empty_stabs (int stype
)
566 fputs (ASM_STABS_OP
, asm_out_file
);
567 fputs ("\"\",", asm_out_file
);
569 fputs (",0,0,", asm_out_file
);
572 /* Begin a .stabs directive with string STR, type STYPE, and desc 0.
573 The value field is the responsibility of the caller. */
575 dbxout_begin_simple_stabs (const char *str
, int stype
)
577 fputs (ASM_STABS_OP
, asm_out_file
);
578 output_quoted_string (asm_out_file
, str
);
579 putc (',', asm_out_file
);
581 fputs (",0,0,", asm_out_file
);
584 /* As above but use SDESC for the desc field. */
586 dbxout_begin_simple_stabs_desc (const char *str
, int stype
, int sdesc
)
588 fputs (ASM_STABS_OP
, asm_out_file
);
589 output_quoted_string (asm_out_file
, str
);
590 putc (',', asm_out_file
);
592 fputs (",0,", asm_out_file
);
594 putc (',', asm_out_file
);
597 /* The next set of functions are entirely concerned with production of
598 "complex" .stabs directives: that is, .stabs directives whose
599 strings have to be constructed piecemeal. dbxout_type,
600 dbxout_symbol, etc. use these routines heavily. The string is queued
601 up in an obstack, then written out by dbxout_finish_complex_stabs, which
602 is also responsible for splitting it up if it exceeds DBX_CONTIN_LENGTH.
603 (You might think it would be more efficient to go straight to stdio
604 when DBX_CONTIN_LENGTH is 0 (i.e. no length limit) but that turns
605 out not to be the case, and anyway this needs fewer #ifdefs.) */
607 /* Begin a complex .stabs directive. If we can, write the initial
608 ASM_STABS_OP to the asm_out_file. */
611 dbxout_begin_complex_stabs (void)
613 emit_pending_bincls_if_required ();
615 fputs (ASM_STABS_OP
, asm_out_file
);
616 putc ('"', asm_out_file
);
617 gcc_assert (stabstr_last_contin_point
== 0);
620 /* As above, but do not force text or emit pending bincls. This is
621 used by dbxout_symbol_location, which needs to do something else. */
623 dbxout_begin_complex_stabs_noforcetext (void)
625 fputs (ASM_STABS_OP
, asm_out_file
);
626 putc ('"', asm_out_file
);
627 gcc_assert (stabstr_last_contin_point
== 0);
630 /* Add CHR, a single character, to the string being built. */
631 #define stabstr_C(chr) obstack_1grow (&stabstr_ob, chr)
633 /* Add STR, a normal C string, to the string being built. */
634 #define stabstr_S(str) obstack_grow (&stabstr_ob, str, strlen(str))
636 /* Add the text of ID, an IDENTIFIER_NODE, to the string being built. */
637 #define stabstr_I(id) obstack_grow (&stabstr_ob, \
638 IDENTIFIER_POINTER (id), \
639 IDENTIFIER_LENGTH (id))
641 /* Add NUM, a signed decimal number, to the string being built. */
643 stabstr_D (HOST_WIDE_INT num
)
646 char *p
= buf
+ sizeof buf
;
662 NUMBER_FMT_LOOP (p
, unum
, 10);
664 obstack_grow (&stabstr_ob
, p
, (buf
+ sizeof buf
) - p
);
667 /* Add NUM, an unsigned decimal number, to the string being built. */
669 stabstr_U (unsigned HOST_WIDE_INT num
)
672 char *p
= buf
+ sizeof buf
;
678 NUMBER_FMT_LOOP (p
, num
, 10);
679 obstack_grow (&stabstr_ob
, p
, (buf
+ sizeof buf
) - p
);
682 /* Add CST, an INTEGER_CST tree, to the string being built as an
683 unsigned octal number. This routine handles values which are
684 larger than a single HOST_WIDE_INT. */
688 unsigned HOST_WIDE_INT high
= TREE_INT_CST_HIGH (cst
);
689 unsigned HOST_WIDE_INT low
= TREE_INT_CST_LOW (cst
);
692 char *p
= buf
+ sizeof buf
;
694 /* GDB wants constants with no extra leading "1" bits, so
695 we need to remove any sign-extension that might be
698 const unsigned int width
= TYPE_PRECISION (TREE_TYPE (cst
));
699 if (width
== HOST_BITS_PER_WIDE_INT
* 2)
701 else if (width
> HOST_BITS_PER_WIDE_INT
)
702 high
&= (((HOST_WIDE_INT
) 1 << (width
- HOST_BITS_PER_WIDE_INT
)) - 1);
703 else if (width
== HOST_BITS_PER_WIDE_INT
)
706 high
= 0, low
&= (((HOST_WIDE_INT
) 1 << width
) - 1);
709 /* Leading zero for base indicator. */
712 /* If the value is zero, the base indicator will serve as the value
714 if (high
== 0 && low
== 0)
717 /* If the high half is zero, we need only print the low half normally. */
719 NUMBER_FMT_LOOP (p
, low
, 8);
722 /* When high != 0, we need to print enough zeroes from low to
723 give the digits from high their proper place-values. Hence
724 NUMBER_FMT_LOOP cannot be used. */
725 const int n_digits
= HOST_BITS_PER_WIDE_INT
/ 3;
728 for (i
= 1; i
<= n_digits
; i
++)
730 unsigned int digit
= low
% 8;
735 /* Octal digits carry exactly three bits of information. The
736 width of a HOST_WIDE_INT is not normally a multiple of three.
737 Therefore, the next digit printed probably needs to carry
738 information from both low and high. */
739 if (HOST_BITS_PER_WIDE_INT
% 3 != 0)
741 const int n_leftover_bits
= HOST_BITS_PER_WIDE_INT
% 3;
742 const int n_bits_from_high
= 3 - n_leftover_bits
;
744 const unsigned HOST_WIDE_INT
745 low_mask
= (((unsigned HOST_WIDE_INT
)1) << n_leftover_bits
) - 1;
746 const unsigned HOST_WIDE_INT
747 high_mask
= (((unsigned HOST_WIDE_INT
)1) << n_bits_from_high
) - 1;
751 /* At this point, only the bottom n_leftover_bits bits of low
753 gcc_assert (!(low
& ~low_mask
));
755 digit
= (low
| ((high
& high_mask
) << n_leftover_bits
));
756 high
>>= n_bits_from_high
;
761 /* Now we can format high in the normal manner. However, if
762 the only bits of high that were set were handled by the
763 digit split between low and high, high will now be zero, and
764 we don't want to print extra digits in that case. */
766 NUMBER_FMT_LOOP (p
, high
, 8);
769 obstack_grow (&stabstr_ob
, p
, (buf
+ sizeof buf
) - p
);
772 /* Called whenever it is safe to break a stabs string into multiple
773 .stabs directives. If the current string has exceeded the limit
774 set by DBX_CONTIN_LENGTH, mark the current position in the buffer
775 as a continuation point by inserting DBX_CONTIN_CHAR (doubled if
776 it is a backslash) and a null character. */
778 stabstr_continue (void)
780 if (DBX_CONTIN_LENGTH
> 0
781 && obstack_object_size (&stabstr_ob
) - stabstr_last_contin_point
784 if (DBX_CONTIN_CHAR
== '\\')
785 obstack_1grow (&stabstr_ob
, '\\');
786 obstack_1grow (&stabstr_ob
, DBX_CONTIN_CHAR
);
787 obstack_1grow (&stabstr_ob
, '\0');
788 stabstr_last_contin_point
= obstack_object_size (&stabstr_ob
);
791 #define CONTIN stabstr_continue ()
793 /* Macro subroutine of dbxout_finish_complex_stabs, which emits
794 all of the arguments to the .stabs directive after the string.
795 Overridden by xcoffout.h. CODE is the stabs code for this symbol;
796 LINE is the source line to write into the desc field (in extended
797 mode); SYM is the symbol itself.
799 ADDR, LABEL, and NUMBER are three different ways to represent the
800 stabs value field. At most one of these should be nonzero.
802 ADDR is used most of the time; it represents the value as an
803 RTL address constant.
805 LABEL is used (currently) only for N_CATCH stabs; it represents
806 the value as a string suitable for assemble_name.
808 NUMBER is used when the value is an offset from an implicit base
809 pointer (e.g. for a stack variable), or an index (e.g. for a
810 register variable). It represents the value as a decimal integer. */
812 #ifndef DBX_FINISH_STABS
813 #define DBX_FINISH_STABS(SYM, CODE, LINE, ADDR, LABEL, NUMBER) \
815 int line_ = use_gnu_debug_info_extensions ? LINE : 0; \
818 fputs (",0,", asm_out_file); \
819 dbxout_int (line_); \
820 putc (',', asm_out_file); \
822 output_addr_const (asm_out_file, ADDR); \
824 assemble_name (asm_out_file, LABEL); \
826 dbxout_int (NUMBER); \
827 putc ('\n', asm_out_file); \
831 /* Finish the emission of a complex .stabs directive. When DBX_CONTIN_LENGTH
832 is zero, this has only to emit the close quote and the remainder of
833 the arguments. When it is nonzero, the string has been marshalled in
834 stabstr_ob, and this routine is responsible for breaking it up into
835 DBX_CONTIN_LENGTH-sized chunks.
837 SYM is the DECL of the symbol under consideration; it is used only
838 for its DECL_SOURCE_LINE. The other arguments are all passed directly
839 to DBX_FINISH_STABS; see above for details. */
842 dbxout_finish_complex_stabs (tree sym
, STAB_CODE_TYPE code
,
843 rtx addr
, const char *label
, int number
)
845 int line ATTRIBUTE_UNUSED
;
849 line
= sym
? DECL_SOURCE_LINE (sym
) : 0;
850 if (DBX_CONTIN_LENGTH
> 0)
855 /* Nul-terminate the growing string, then get its size and
857 obstack_1grow (&stabstr_ob
, '\0');
859 len
= obstack_object_size (&stabstr_ob
);
860 chunk
= str
= XOBFINISH (&stabstr_ob
, char *);
862 /* Within the buffer are a sequence of NUL-separated strings,
863 each of which is to be written out as a separate stab
867 chunklen
= strlen (chunk
);
868 fwrite (chunk
, 1, chunklen
, asm_out_file
);
869 fputs ("\",", asm_out_file
);
871 /* Must add an extra byte to account for the NUL separator. */
872 chunk
+= chunklen
+ 1;
875 /* Only put a line number on the last stab in the sequence. */
876 DBX_FINISH_STABS (sym
, code
, len
== 0 ? line
: 0,
877 addr
, label
, number
);
881 fputs (ASM_STABS_OP
, asm_out_file
);
882 putc ('"', asm_out_file
);
884 stabstr_last_contin_point
= 0;
888 /* No continuations - we can put the whole string out at once.
889 It is faster to augment the string with the close quote and
890 comma than to do a two-character fputs. */
891 obstack_grow (&stabstr_ob
, "\",", 2);
892 len
= obstack_object_size (&stabstr_ob
);
893 str
= XOBFINISH (&stabstr_ob
, char *);
895 fwrite (str
, 1, len
, asm_out_file
);
896 DBX_FINISH_STABS (sym
, code
, line
, addr
, label
, number
);
898 obstack_free (&stabstr_ob
, str
);
901 #if defined (DBX_DEBUGGING_INFO)
904 dbxout_function_end (tree decl
)
906 char lscope_label_name
[100];
908 /* The Lscope label must be emitted even if we aren't doing anything
909 else; dbxout_block needs it. */
910 switch_to_section (function_section (current_function_decl
));
912 /* Convert Lscope into the appropriate format for local labels in case
913 the system doesn't insert underscores in front of user generated
915 ASM_GENERATE_INTERNAL_LABEL (lscope_label_name
, "Lscope", scope_labelno
);
916 targetm
.asm_out
.internal_label (asm_out_file
, "Lscope", scope_labelno
);
918 /* The N_FUN tag at the end of the function is a GNU extension,
919 which may be undesirable, and is unnecessary if we do not have
921 if (!use_gnu_debug_info_extensions
922 || NO_DBX_FUNCTION_END
923 || !targetm
.have_named_sections
924 || DECL_IGNORED_P (decl
))
927 /* By convention, GCC will mark the end of a function with an N_FUN
928 symbol and an empty string. */
929 if (flag_reorder_blocks_and_partition
)
931 dbxout_begin_empty_stabs (N_FUN
);
932 dbxout_stab_value_label_diff (cfun
->hot_section_end_label
,
933 cfun
->hot_section_label
);
934 dbxout_begin_empty_stabs (N_FUN
);
935 dbxout_stab_value_label_diff (cfun
->cold_section_end_label
,
936 cfun
->cold_section_label
);
940 char begin_label
[20];
941 /* Reference current function start using LFBB. */
942 ASM_GENERATE_INTERNAL_LABEL (begin_label
, "LFBB", scope_labelno
);
943 dbxout_begin_empty_stabs (N_FUN
);
944 dbxout_stab_value_label_diff (lscope_label_name
, begin_label
);
947 if (!NO_DBX_BNSYM_ENSYM
&& !flag_debug_only_used_symbols
)
948 dbxout_stabd (N_ENSYM
, 0);
950 #endif /* DBX_DEBUGGING_INFO */
952 /* Get lang description for N_SO stab. */
953 static unsigned int ATTRIBUTE_UNUSED
954 get_lang_number (void)
956 const char *language_string
= lang_hooks
.name
;
958 if (strcmp (language_string
, "GNU C") == 0)
960 else if (strcmp (language_string
, "GNU C++") == 0)
962 else if (strcmp (language_string
, "GNU F77") == 0)
964 else if (strcmp (language_string
, "GNU F95") == 0)
965 return N_SO_FORTRAN90
; /* CHECKME */
966 else if (strcmp (language_string
, "GNU Pascal") == 0)
968 else if (strcmp (language_string
, "GNU Objective-C") == 0)
970 else if (strcmp (language_string
, "GNU Objective-C++") == 0)
971 return N_SO_OBJCPLUS
;
977 /* At the beginning of compilation, start writing the symbol table.
978 Initialize `typevec' and output the standard data types of C. */
981 dbxout_init (const char *input_file_name
)
983 char ltext_label_name
[100];
984 bool used_ltext_label_name
= false;
985 tree syms
= lang_hooks
.decls
.getdecls ();
988 typevec
= ggc_calloc (typevec_len
, sizeof typevec
[0]);
990 /* stabstr_ob contains one string, which will be just fine with
992 obstack_specify_allocation (&stabstr_ob
, 0, 1, xmalloc
, free
);
994 /* Convert Ltext into the appropriate format for local labels in case
995 the system doesn't insert underscores in front of user generated
997 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name
, "Ltext", 0);
999 /* Put the current working directory in an N_SO symbol. */
1000 if (use_gnu_debug_info_extensions
&& !NO_DBX_MAIN_SOURCE_DIRECTORY
)
1002 static const char *cwd
;
1006 cwd
= get_src_pwd ();
1009 else if (!IS_DIR_SEPARATOR (cwd
[strlen (cwd
) - 1]))
1010 cwd
= concat (cwd
, "/", NULL
);
1012 #ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
1013 DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asm_out_file
, cwd
);
1014 #else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
1015 dbxout_begin_simple_stabs_desc (cwd
, N_SO
, get_lang_number ());
1016 dbxout_stab_value_label (ltext_label_name
);
1017 used_ltext_label_name
= true;
1018 #endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
1021 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
1022 DBX_OUTPUT_MAIN_SOURCE_FILENAME (asm_out_file
, input_file_name
);
1024 dbxout_begin_simple_stabs_desc (input_file_name
, N_SO
, get_lang_number ());
1025 dbxout_stab_value_label (ltext_label_name
);
1026 used_ltext_label_name
= true;
1029 if (used_ltext_label_name
)
1031 switch_to_section (text_section
);
1032 targetm
.asm_out
.internal_label (asm_out_file
, "Ltext", 0);
1035 /* Emit an N_OPT stab to indicate that this file was compiled by GCC.
1036 The string used is historical. */
1037 #ifndef NO_DBX_GCC_MARKER
1038 dbxout_begin_simple_stabs ("gcc2_compiled.", N_OPT
);
1039 dbxout_stab_value_zero ();
1042 base_input_file
= lastfile
= input_file_name
;
1044 next_type_number
= 1;
1046 #ifdef DBX_USE_BINCL
1047 current_file
= XNEW (struct dbx_file
);
1048 current_file
->next
= NULL
;
1049 current_file
->file_number
= 0;
1050 current_file
->next_type_number
= 1;
1051 next_file_number
= 1;
1052 current_file
->prev
= NULL
;
1053 current_file
->bincl_status
= BINCL_NOT_REQUIRED
;
1054 current_file
->pending_bincl_name
= NULL
;
1057 /* Get all permanent types that have typedef names, and output them
1058 all, except for those already output. Some language front ends
1059 put these declarations in the top-level scope; some do not;
1060 the latter are responsible for calling debug_hooks->type_decl from
1061 their record_builtin_type function. */
1062 dbxout_typedefs (syms
);
1064 if (preinit_symbols
)
1067 for (t
= nreverse (preinit_symbols
); t
; t
= TREE_CHAIN (t
))
1068 dbxout_symbol (TREE_VALUE (t
), 0);
1069 preinit_symbols
= 0;
1073 /* Output any typedef names for types described by TYPE_DECLs in SYMS. */
1076 dbxout_typedefs (tree syms
)
1078 for (; syms
!= NULL_TREE
; syms
= TREE_CHAIN (syms
))
1080 if (TREE_CODE (syms
) == TYPE_DECL
)
1082 tree type
= TREE_TYPE (syms
);
1083 if (TYPE_NAME (type
)
1084 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1085 && COMPLETE_OR_VOID_TYPE_P (type
)
1086 && ! TREE_ASM_WRITTEN (TYPE_NAME (type
)))
1087 dbxout_symbol (TYPE_NAME (type
), 0);
1092 #ifdef DBX_USE_BINCL
1093 /* Emit BINCL stab using given name. */
1095 emit_bincl_stab (const char *name
)
1097 dbxout_begin_simple_stabs (name
, N_BINCL
);
1098 dbxout_stab_value_zero ();
1101 /* If there are pending bincls then it is time to emit all of them. */
1104 emit_pending_bincls_if_required (void)
1107 emit_pending_bincls ();
1110 /* Emit all pending bincls. */
1113 emit_pending_bincls (void)
1115 struct dbx_file
*f
= current_file
;
1117 /* Find first pending bincl. */
1118 while (f
->bincl_status
== BINCL_PENDING
)
1121 /* Now emit all bincls. */
1126 if (f
->bincl_status
== BINCL_PENDING
)
1128 emit_bincl_stab (f
->pending_bincl_name
);
1130 /* Update file number and status. */
1131 f
->file_number
= next_file_number
++;
1132 f
->bincl_status
= BINCL_PROCESSED
;
1134 if (f
== current_file
)
1139 /* All pending bincls have been emitted. */
1146 emit_pending_bincls_if_required (void) {}
1149 /* Change to reading from a new source file. Generate a N_BINCL stab. */
1152 dbxout_start_source_file (unsigned int line ATTRIBUTE_UNUSED
,
1153 const char *filename ATTRIBUTE_UNUSED
)
1155 #ifdef DBX_USE_BINCL
1156 struct dbx_file
*n
= XNEW (struct dbx_file
);
1158 n
->next
= current_file
;
1159 n
->next_type_number
= 1;
1160 /* Do not assign file number now.
1161 Delay it until we actually emit BINCL. */
1164 current_file
->prev
= n
;
1165 n
->bincl_status
= BINCL_PENDING
;
1166 n
->pending_bincl_name
= filename
;
1172 /* Revert to reading a previous source file. Generate a N_EINCL stab. */
1175 dbxout_end_source_file (unsigned int line ATTRIBUTE_UNUSED
)
1177 #ifdef DBX_USE_BINCL
1178 /* Emit EINCL stab only if BINCL is not pending. */
1179 if (current_file
->bincl_status
== BINCL_PROCESSED
)
1181 dbxout_begin_stabn (N_EINCL
);
1182 dbxout_stab_value_zero ();
1184 current_file
->bincl_status
= BINCL_NOT_REQUIRED
;
1185 current_file
= current_file
->next
;
1189 /* Handle a few odd cases that occur when trying to make PCH files work. */
1192 dbxout_handle_pch (unsigned at_end
)
1196 /* When using the PCH, this file will be included, so we need to output
1198 dbxout_start_source_file (0, lastfile
);
1200 /* The base file when using the PCH won't be the same as
1201 the base file when it's being generated. */
1206 /* ... and an EINCL. */
1207 dbxout_end_source_file (0);
1209 /* Deal with cases where 'lastfile' was never actually changed. */
1210 lastfile_is_base
= lastfile
== NULL
;
1214 #if defined (DBX_DEBUGGING_INFO)
1215 /* Output debugging info to FILE to switch to sourcefile FILENAME. */
1218 dbxout_source_file (const char *filename
)
1220 if (lastfile
== 0 && lastfile_is_base
)
1222 lastfile
= base_input_file
;
1223 lastfile_is_base
= 0;
1226 if (filename
&& (lastfile
== 0 || strcmp (filename
, lastfile
)))
1228 /* Don't change section amid function. */
1229 if (current_function_decl
== NULL_TREE
)
1230 switch_to_section (text_section
);
1232 dbxout_begin_simple_stabs (filename
, N_SOL
);
1233 dbxout_stab_value_internal_label ("Ltext", &source_label_number
);
1234 lastfile
= filename
;
1238 /* Output N_BNSYM, line number symbol entry, and local symbol at
1242 dbxout_begin_prologue (unsigned int lineno
, const char *filename
)
1244 if (use_gnu_debug_info_extensions
1245 && !NO_DBX_FUNCTION_END
1246 && !NO_DBX_BNSYM_ENSYM
1247 && !flag_debug_only_used_symbols
)
1248 dbxout_stabd (N_BNSYM
, 0);
1250 /* pre-increment the scope counter */
1253 dbxout_source_line (lineno
, filename
);
1254 /* Output function begin block at function scope, referenced
1255 by dbxout_block, dbxout_source_line and dbxout_function_end. */
1256 emit_pending_bincls_if_required ();
1257 targetm
.asm_out
.internal_label (asm_out_file
, "LFBB", scope_labelno
);
1260 /* Output a line number symbol entry for source file FILENAME and line
1264 dbxout_source_line (unsigned int lineno
, const char *filename
)
1266 dbxout_source_file (filename
);
1268 #ifdef DBX_OUTPUT_SOURCE_LINE
1269 DBX_OUTPUT_SOURCE_LINE (asm_out_file
, lineno
, dbxout_source_line_counter
);
1271 if (DBX_LINES_FUNCTION_RELATIVE
)
1273 char begin_label
[20];
1274 dbxout_begin_stabn_sline (lineno
);
1275 /* Reference current function start using LFBB. */
1276 ASM_GENERATE_INTERNAL_LABEL (begin_label
, "LFBB", scope_labelno
);
1277 dbxout_stab_value_internal_label_diff ("LM", &dbxout_source_line_counter
,
1281 dbxout_stabd (N_SLINE
, lineno
);
1285 /* Describe the beginning of an internal block within a function. */
1288 dbxout_begin_block (unsigned int line ATTRIBUTE_UNUSED
, unsigned int n
)
1290 emit_pending_bincls_if_required ();
1291 targetm
.asm_out
.internal_label (asm_out_file
, "LBB", n
);
1294 /* Describe the end line-number of an internal block within a function. */
1297 dbxout_end_block (unsigned int line ATTRIBUTE_UNUSED
, unsigned int n
)
1299 emit_pending_bincls_if_required ();
1300 targetm
.asm_out
.internal_label (asm_out_file
, "LBE", n
);
1303 /* Output dbx data for a function definition.
1304 This includes a definition of the function name itself (a symbol),
1305 definitions of the parameters (locating them in the parameter list)
1306 and then output the block that makes up the function's body
1307 (including all the auto variables of the function). */
1310 dbxout_function_decl (tree decl
)
1312 emit_pending_bincls_if_required ();
1313 #ifndef DBX_FUNCTION_FIRST
1314 dbxout_begin_function (decl
);
1316 dbxout_block (DECL_INITIAL (decl
), 0, DECL_ARGUMENTS (decl
));
1317 dbxout_function_end (decl
);
1320 #endif /* DBX_DEBUGGING_INFO */
1322 /* Debug information for a global DECL. Called from toplev.c after
1323 compilation proper has finished. */
1325 dbxout_global_decl (tree decl
)
1327 if (TREE_CODE (decl
) == VAR_DECL
&& !DECL_EXTERNAL (decl
))
1329 int saved_tree_used
= TREE_USED (decl
);
1330 TREE_USED (decl
) = 1;
1331 dbxout_symbol (decl
, 0);
1332 TREE_USED (decl
) = saved_tree_used
;
1336 /* This is just a function-type adapter; dbxout_symbol does exactly
1337 what we want but returns an int. */
1339 dbxout_type_decl (tree decl
, int local
)
1341 dbxout_symbol (decl
, local
);
1344 /* At the end of compilation, finish writing the symbol table.
1345 The default is to call debug_free_queue but do nothing else. */
1348 dbxout_finish (const char *filename ATTRIBUTE_UNUSED
)
1350 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
1351 DBX_OUTPUT_MAIN_SOURCE_FILE_END (asm_out_file
, filename
);
1352 #elif defined DBX_OUTPUT_NULL_N_SO_AT_MAIN_SOURCE_FILE_END
1354 switch_to_section (text_section
);
1355 dbxout_begin_empty_stabs (N_SO
);
1356 dbxout_stab_value_internal_label ("Letext", 0);
1359 debug_free_queue ();
1362 /* Output the index of a type. */
1365 dbxout_type_index (tree type
)
1367 #ifndef DBX_USE_BINCL
1368 stabstr_D (TYPE_SYMTAB_ADDRESS (type
));
1370 struct typeinfo
*t
= &typevec
[TYPE_SYMTAB_ADDRESS (type
)];
1372 stabstr_D (t
->file_number
);
1374 stabstr_D (t
->type_number
);
1381 /* Used in several places: evaluates to '0' for a private decl,
1382 '1' for a protected decl, '2' for a public decl. */
1383 #define DECL_ACCESSIBILITY_CHAR(DECL) \
1384 (TREE_PRIVATE (DECL) ? '0' : TREE_PROTECTED (DECL) ? '1' : '2')
1386 /* Subroutine of `dbxout_type'. Output the type fields of TYPE.
1387 This must be a separate function because anonymous unions require
1391 dbxout_type_fields (tree type
)
1395 /* Output the name, type, position (in bits), size (in bits) of each
1396 field that we can support. */
1397 for (tem
= TYPE_FIELDS (type
); tem
; tem
= TREE_CHAIN (tem
))
1399 /* If one of the nodes is an error_mark or its type is then
1401 if (tem
== error_mark_node
|| TREE_TYPE (tem
) == error_mark_node
)
1404 /* Omit here local type decls until we know how to support them. */
1405 if (TREE_CODE (tem
) == TYPE_DECL
1406 /* Omit here the nameless fields that are used to skip bits. */
1407 || DECL_IGNORED_P (tem
)
1408 /* Omit fields whose position or size are variable or too large to
1410 || (TREE_CODE (tem
) == FIELD_DECL
1411 && (! host_integerp (bit_position (tem
), 0)
1412 || ! DECL_SIZE (tem
)
1413 || ! host_integerp (DECL_SIZE (tem
), 1))))
1416 else if (TREE_CODE (tem
) != CONST_DECL
)
1418 /* Continue the line if necessary,
1419 but not before the first field. */
1420 if (tem
!= TYPE_FIELDS (type
))
1423 if (DECL_NAME (tem
))
1424 stabstr_I (DECL_NAME (tem
));
1427 if (use_gnu_debug_info_extensions
1428 && (TREE_PRIVATE (tem
) || TREE_PROTECTED (tem
)
1429 || TREE_CODE (tem
) != FIELD_DECL
))
1432 stabstr_C (DECL_ACCESSIBILITY_CHAR (tem
));
1435 dbxout_type ((TREE_CODE (tem
) == FIELD_DECL
1436 && DECL_BIT_FIELD_TYPE (tem
))
1437 ? DECL_BIT_FIELD_TYPE (tem
) : TREE_TYPE (tem
), 0);
1439 if (TREE_CODE (tem
) == VAR_DECL
)
1441 if (TREE_STATIC (tem
) && use_gnu_debug_info_extensions
)
1443 tree name
= DECL_ASSEMBLER_NAME (tem
);
1450 /* If TEM is non-static, GDB won't understand it. */
1451 stabstr_S (",0,0;");
1456 stabstr_D (int_bit_position (tem
));
1458 stabstr_D (tree_low_cst (DECL_SIZE (tem
), 1));
1465 /* Subroutine of `dbxout_type_methods'. Output debug info about the
1466 method described DECL. */
1469 dbxout_type_method_1 (tree decl
)
1473 if (TREE_CODE (TREE_TYPE (decl
)) == FUNCTION_TYPE
)
1475 else /* it's a METHOD_TYPE. */
1477 tree firstarg
= TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)));
1478 /* A for normal functions.
1479 B for `const' member functions.
1480 C for `volatile' member functions.
1481 D for `const volatile' member functions. */
1482 if (TYPE_READONLY (TREE_TYPE (firstarg
)))
1484 if (TYPE_VOLATILE (TREE_TYPE (firstarg
)))
1487 if (DECL_VINDEX (decl
))
1493 /* ??? Output the mangled name, which contains an encoding of the
1494 method's type signature. May not be necessary anymore. */
1496 stabstr_I (DECL_ASSEMBLER_NAME (decl
));
1498 stabstr_C (DECL_ACCESSIBILITY_CHAR (decl
));
1502 if (DECL_VINDEX (decl
) && host_integerp (DECL_VINDEX (decl
), 0))
1504 stabstr_D (tree_low_cst (DECL_VINDEX (decl
), 0));
1506 dbxout_type (DECL_CONTEXT (decl
), 0);
1511 /* Subroutine of `dbxout_type'. Output debug info about the methods defined
1515 dbxout_type_methods (tree type
)
1517 /* C++: put out the method names and their parameter lists */
1518 tree methods
= TYPE_METHODS (type
);
1522 if (methods
== NULL_TREE
)
1525 if (TREE_CODE (methods
) != TREE_VEC
)
1527 else if (TREE_VEC_ELT (methods
, 0) != NULL_TREE
)
1528 fndecl
= TREE_VEC_ELT (methods
, 0);
1530 fndecl
= TREE_VEC_ELT (methods
, 1);
1534 int need_prefix
= 1;
1536 /* Group together all the methods for the same operation.
1537 These differ in the types of the arguments. */
1538 for (last
= NULL_TREE
;
1539 fndecl
&& (last
== NULL_TREE
|| DECL_NAME (fndecl
) == DECL_NAME (last
));
1540 fndecl
= TREE_CHAIN (fndecl
))
1541 /* Output the name of the field (after overloading), as
1542 well as the name of the field before overloading, along
1543 with its parameter list */
1545 /* Skip methods that aren't FUNCTION_DECLs. (In C++, these
1546 include TEMPLATE_DECLs.) The debugger doesn't know what
1547 to do with such entities anyhow. */
1548 if (TREE_CODE (fndecl
) != FUNCTION_DECL
)
1555 /* Also ignore abstract methods; those are only interesting to
1556 the DWARF backends. */
1557 if (DECL_IGNORED_P (fndecl
) || DECL_ABSTRACT (fndecl
))
1560 /* Redundantly output the plain name, since that's what gdb
1564 stabstr_I (DECL_NAME (fndecl
));
1569 dbxout_type (TREE_TYPE (fndecl
), 0);
1570 dbxout_type_method_1 (fndecl
);
1577 /* Emit a "range" type specification, which has the form:
1578 "r<index type>;<lower bound>;<upper bound>;".
1579 TYPE is an INTEGER_TYPE. */
1582 dbxout_range_type (tree type
)
1585 if (TREE_TYPE (type
))
1586 dbxout_type (TREE_TYPE (type
), 0);
1587 else if (TREE_CODE (type
) != INTEGER_TYPE
)
1588 dbxout_type (type
, 0); /* E.g. Pascal's ARRAY [BOOLEAN] of INTEGER */
1591 /* Traditionally, we made sure 'int' was type 1, and builtin types
1592 were defined to be sub-ranges of int. Unfortunately, this
1593 does not allow us to distinguish true sub-ranges from integer
1594 types. So, instead we define integer (non-sub-range) types as
1595 sub-ranges of themselves. This matters for Chill. If this isn't
1596 a subrange type, then we want to define it in terms of itself.
1597 However, in C, this may be an anonymous integer type, and we don't
1598 want to emit debug info referring to it. Just calling
1599 dbxout_type_index won't work anyways, because the type hasn't been
1600 defined yet. We make this work for both cases by checked to see
1601 whether this is a defined type, referring to it if it is, and using
1603 if (TYPE_SYMTAB_ADDRESS (type
) != 0)
1604 dbxout_type_index (type
);
1606 dbxout_type_index (integer_type_node
);
1610 if (TYPE_MIN_VALUE (type
) != 0
1611 && host_integerp (TYPE_MIN_VALUE (type
), 0))
1613 if (print_int_cst_bounds_in_octal_p (type
))
1614 stabstr_O (TYPE_MIN_VALUE (type
));
1616 stabstr_D (tree_low_cst (TYPE_MIN_VALUE (type
), 0));
1622 if (TYPE_MAX_VALUE (type
) != 0
1623 && host_integerp (TYPE_MAX_VALUE (type
), 0))
1625 if (print_int_cst_bounds_in_octal_p (type
))
1626 stabstr_O (TYPE_MAX_VALUE (type
));
1628 stabstr_D (tree_low_cst (TYPE_MAX_VALUE (type
), 0));
1636 /* Output a reference to a type. If the type has not yet been
1637 described in the dbx output, output its definition now.
1638 For a type already defined, just refer to its definition
1639 using the type number.
1641 If FULL is nonzero, and the type has been described only with
1642 a forward-reference, output the definition now.
1643 If FULL is zero in this case, just refer to the forward-reference
1644 using the number previously allocated. */
1647 dbxout_type (tree type
, int full
)
1651 static int anonymous_type_number
= 0;
1652 bool vector_type
= false;
1654 if (TREE_CODE (type
) == VECTOR_TYPE
)
1656 /* The frontend feeds us a representation for the vector as a struct
1657 containing an array. Pull out the array type. */
1658 type
= TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type
)));
1662 /* If there was an input error and we don't really have a type,
1663 avoid crashing and write something that is at least valid
1664 by assuming `int'. */
1665 if (type
== error_mark_node
)
1666 type
= integer_type_node
;
1669 if (TYPE_NAME (type
)
1670 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1671 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type
)))
1675 /* Try to find the "main variant" with the same name. */
1676 if (TYPE_NAME (type
) && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1677 && DECL_ORIGINAL_TYPE (TYPE_NAME (type
)))
1678 main_variant
= TREE_TYPE (TYPE_NAME (type
));
1680 main_variant
= TYPE_MAIN_VARIANT (type
);
1682 /* If we are not using extensions, stabs does not distinguish const and
1683 volatile, so there is no need to make them separate types. */
1684 if (!use_gnu_debug_info_extensions
)
1685 type
= main_variant
;
1687 if (TYPE_SYMTAB_ADDRESS (type
) == 0)
1689 /* Type has no dbx number assigned. Assign next available number. */
1690 TYPE_SYMTAB_ADDRESS (type
) = next_type_number
++;
1692 /* Make sure type vector is long enough to record about this type. */
1694 if (next_type_number
== typevec_len
)
1697 = ggc_realloc (typevec
, (typevec_len
* 2 * sizeof typevec
[0]));
1698 memset (typevec
+ typevec_len
, 0, typevec_len
* sizeof typevec
[0]);
1702 #ifdef DBX_USE_BINCL
1703 emit_pending_bincls_if_required ();
1704 typevec
[TYPE_SYMTAB_ADDRESS (type
)].file_number
1705 = current_file
->file_number
;
1706 typevec
[TYPE_SYMTAB_ADDRESS (type
)].type_number
1707 = current_file
->next_type_number
++;
1711 if (flag_debug_only_used_symbols
)
1713 if ((TREE_CODE (type
) == RECORD_TYPE
1714 || TREE_CODE (type
) == UNION_TYPE
1715 || TREE_CODE (type
) == QUAL_UNION_TYPE
1716 || TREE_CODE (type
) == ENUMERAL_TYPE
)
1717 && TYPE_STUB_DECL (type
)
1718 && DECL_P (TYPE_STUB_DECL (type
))
1719 && ! DECL_IGNORED_P (TYPE_STUB_DECL (type
)))
1720 debug_queue_symbol (TYPE_STUB_DECL (type
));
1721 else if (TYPE_NAME (type
)
1722 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
1723 debug_queue_symbol (TYPE_NAME (type
));
1726 /* Output the number of this type, to refer to it. */
1727 dbxout_type_index (type
);
1729 #ifdef DBX_TYPE_DEFINED
1730 if (DBX_TYPE_DEFINED (type
))
1734 /* If this type's definition has been output or is now being output,
1737 switch (typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
)
1742 /* If we have already had a cross reference,
1743 and either that's all we want or that's the best we could do,
1744 don't repeat the cross reference.
1745 Sun dbx crashes if we do. */
1746 if (! full
|| !COMPLETE_TYPE_P (type
)
1747 /* No way in DBX fmt to describe a variable size. */
1748 || ! host_integerp (TYPE_SIZE (type
), 1))
1756 /* For systems where dbx output does not allow the `=xsNAME:' syntax,
1757 leave the type-number completely undefined rather than output
1758 a cross-reference. If we have already used GNU debug info extensions,
1759 then it is OK to output a cross reference. This is necessary to get
1760 proper C++ debug output. */
1761 if ((TREE_CODE (type
) == RECORD_TYPE
|| TREE_CODE (type
) == UNION_TYPE
1762 || TREE_CODE (type
) == QUAL_UNION_TYPE
1763 || TREE_CODE (type
) == ENUMERAL_TYPE
)
1764 && ! use_gnu_debug_info_extensions
)
1765 /* We must use the same test here as we use twice below when deciding
1766 whether to emit a cross-reference. */
1767 if ((TYPE_NAME (type
) != 0
1768 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1769 && DECL_IGNORED_P (TYPE_NAME (type
)))
1771 || !COMPLETE_TYPE_P (type
)
1772 /* No way in DBX fmt to describe a variable size. */
1773 || ! host_integerp (TYPE_SIZE (type
), 1))
1775 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1780 /* Output a definition now. */
1783 /* Mark it as defined, so that if it is self-referent
1784 we will not get into an infinite recursion of definitions. */
1786 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_DEFINED
;
1788 /* If this type is a variant of some other, hand off. Types with
1789 different names are usefully distinguished. We only distinguish
1790 cv-qualified types if we're using extensions. */
1791 if (TYPE_READONLY (type
) > TYPE_READONLY (main_variant
))
1794 dbxout_type (build_type_variant (type
, 0, TYPE_VOLATILE (type
)), 0);
1797 else if (TYPE_VOLATILE (type
) > TYPE_VOLATILE (main_variant
))
1800 dbxout_type (build_type_variant (type
, TYPE_READONLY (type
), 0), 0);
1803 else if (main_variant
!= TYPE_MAIN_VARIANT (type
))
1805 if (flag_debug_only_used_symbols
)
1807 tree orig_type
= DECL_ORIGINAL_TYPE (TYPE_NAME (type
));
1809 if ((TREE_CODE (orig_type
) == RECORD_TYPE
1810 || TREE_CODE (orig_type
) == UNION_TYPE
1811 || TREE_CODE (orig_type
) == QUAL_UNION_TYPE
1812 || TREE_CODE (orig_type
) == ENUMERAL_TYPE
)
1813 && TYPE_STUB_DECL (orig_type
)
1814 && ! DECL_IGNORED_P (TYPE_STUB_DECL (orig_type
)))
1815 debug_queue_symbol (TYPE_STUB_DECL (orig_type
));
1817 /* 'type' is a typedef; output the type it refers to. */
1818 dbxout_type (DECL_ORIGINAL_TYPE (TYPE_NAME (type
)), 0);
1821 /* else continue. */
1823 switch (TREE_CODE (type
))
1827 /* For a void type, just define it as itself; i.e., "5=5".
1828 This makes us consider it defined
1829 without saying what it is. The debugger will make it
1830 a void type when the reference is seen, and nothing will
1831 ever override that default. */
1832 dbxout_type_index (type
);
1836 if (type
== char_type_node
&& ! TYPE_UNSIGNED (type
))
1838 /* Output the type `char' as a subrange of itself!
1839 I don't understand this definition, just copied it
1840 from the output of pcc.
1841 This used to use `r2' explicitly and we used to
1842 take care to make sure that `char' was type number 2. */
1844 dbxout_type_index (type
);
1845 stabstr_S (";0;127;");
1848 /* If this is a subtype of another integer type, always prefer to
1849 write it as a subtype. */
1850 else if (TREE_TYPE (type
) != 0
1851 && TREE_CODE (TREE_TYPE (type
)) == INTEGER_TYPE
)
1853 /* If the size is non-standard, say what it is if we can use
1856 if (use_gnu_debug_info_extensions
1857 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
1860 stabstr_D (TYPE_PRECISION (type
));
1864 dbxout_range_type (type
);
1869 /* If the size is non-standard, say what it is if we can use
1872 if (use_gnu_debug_info_extensions
1873 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
1876 stabstr_D (TYPE_PRECISION (type
));
1880 if (print_int_cst_bounds_in_octal_p (type
))
1884 /* If this type derives from another type, output type index of
1885 parent type. This is particularly important when parent type
1886 is an enumerated type, because not generating the parent type
1887 index would transform the definition of this enumerated type
1888 into a plain unsigned type. */
1889 if (TREE_TYPE (type
) != 0)
1890 dbxout_type_index (TREE_TYPE (type
));
1892 dbxout_type_index (type
);
1895 stabstr_O (TYPE_MIN_VALUE (type
));
1897 stabstr_O (TYPE_MAX_VALUE (type
));
1902 /* Output other integer types as subranges of `int'. */
1903 dbxout_range_type (type
);
1909 /* This used to say `r1' and we used to take care
1910 to make sure that `int' was type number 1. */
1912 dbxout_type_index (integer_type_node
);
1914 stabstr_D (int_size_in_bytes (type
));
1919 if (use_gnu_debug_info_extensions
)
1922 stabstr_D (BITS_PER_UNIT
* int_size_in_bytes (type
));
1923 stabstr_S (";-16;");
1925 else /* Define as enumeral type (False, True) */
1926 stabstr_S ("eFalse:0,True:1,;");
1930 /* Differs from the REAL_TYPE by its new data type number.
1931 R3 is NF_COMPLEX. We don't try to use any of the other NF_*
1932 codes since gdb doesn't care anyway. */
1934 if (TREE_CODE (TREE_TYPE (type
)) == REAL_TYPE
)
1937 stabstr_D (2 * int_size_in_bytes (TREE_TYPE (type
)));
1942 /* Output a complex integer type as a structure,
1943 pending some other way to do it. */
1945 stabstr_D (int_size_in_bytes (type
));
1947 stabstr_S ("real:");
1948 dbxout_type (TREE_TYPE (type
), 0);
1950 stabstr_D (TYPE_PRECISION (TREE_TYPE (type
)));
1952 stabstr_S (";imag:");
1953 dbxout_type (TREE_TYPE (type
), 0);
1955 stabstr_D (TYPE_PRECISION (TREE_TYPE (type
)));
1957 stabstr_D (TYPE_PRECISION (TREE_TYPE (type
)));
1963 /* Make arrays of packed bits look like bitstrings for chill. */
1964 if (TYPE_PACKED (type
) && use_gnu_debug_info_extensions
)
1967 stabstr_D (BITS_PER_UNIT
* int_size_in_bytes (type
));
1968 stabstr_S (";@S;S");
1969 dbxout_type (TYPE_DOMAIN (type
), 0);
1973 if (use_gnu_debug_info_extensions
&& vector_type
)
1976 /* Output "a" followed by a range type definition
1977 for the index type of the array
1978 followed by a reference to the target-type.
1979 ar1;0;N;M for a C array of type M and size N+1. */
1980 /* Check if a character string type, which in Chill is
1981 different from an array of characters. */
1982 if (TYPE_STRING_FLAG (type
) && use_gnu_debug_info_extensions
)
1986 tem
= TYPE_DOMAIN (type
);
1990 dbxout_type_index (integer_type_node
);
1991 stabstr_S (";0;-1;");
1996 dbxout_range_type (tem
);
1999 dbxout_type (TREE_TYPE (type
), 0);
2004 case QUAL_UNION_TYPE
:
2006 tree binfo
= TYPE_BINFO (type
);
2008 /* Output a structure type. We must use the same test here as we
2009 use in the DBX_NO_XREFS case above. */
2010 if ((TYPE_NAME (type
) != 0
2011 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
2012 && DECL_IGNORED_P (TYPE_NAME (type
)))
2014 || !COMPLETE_TYPE_P (type
)
2015 /* No way in DBX fmt to describe a variable size. */
2016 || ! host_integerp (TYPE_SIZE (type
), 1))
2018 /* If the type is just a cross reference, output one
2019 and mark the type as partially described.
2020 If it later becomes defined, we will output
2021 its real definition.
2022 If the type has a name, don't nest its definition within
2023 another type's definition; instead, output an xref
2024 and let the definition come when the name is defined. */
2025 stabstr_S ((TREE_CODE (type
) == RECORD_TYPE
) ? "xs" : "xu");
2026 if (TYPE_NAME (type
) != 0
2027 /* The C frontend creates for anonymous variable length
2028 records/unions TYPE_NAME with DECL_NAME NULL. */
2029 && (TREE_CODE (TYPE_NAME (type
)) != TYPE_DECL
2030 || DECL_NAME (TYPE_NAME (type
))))
2031 dbxout_type_name (type
);
2035 stabstr_D (anonymous_type_number
++);
2039 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
2043 /* Identify record or union, and print its size. */
2044 stabstr_C ((TREE_CODE (type
) == RECORD_TYPE
) ? 's' : 'u');
2045 stabstr_D (int_size_in_bytes (type
));
2051 VEC(tree
,gc
) *accesses
= BINFO_BASE_ACCESSES (binfo
);
2053 if (use_gnu_debug_info_extensions
)
2055 if (BINFO_N_BASE_BINFOS (binfo
))
2058 stabstr_U (BINFO_N_BASE_BINFOS (binfo
));
2062 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, child
); i
++)
2064 tree access
= (accesses
? VEC_index (tree
, accesses
, i
)
2065 : access_public_node
);
2067 if (use_gnu_debug_info_extensions
)
2069 stabstr_C (BINFO_VIRTUAL_P (child
) ? '1' : '0');
2070 stabstr_C (access
== access_public_node
? '2' :
2071 access
== access_protected_node
2073 if (BINFO_VIRTUAL_P (child
)
2074 && (strcmp (lang_hooks
.name
, "GNU C++") == 0
2075 || strcmp (lang_hooks
.name
, "GNU Objective-C++") == 0))
2076 /* For a virtual base, print the (negative)
2077 offset within the vtable where we must look
2078 to find the necessary adjustment. */
2080 (tree_low_cst (BINFO_VPTR_FIELD (child
), 0)
2083 stabstr_D (tree_low_cst (BINFO_OFFSET (child
), 0)
2086 dbxout_type (BINFO_TYPE (child
), 0);
2091 /* Print out the base class information with
2092 fields which have the same names at the types
2094 dbxout_type_name (BINFO_TYPE (child
));
2096 dbxout_type (BINFO_TYPE (child
), full
);
2098 stabstr_D (tree_low_cst (BINFO_OFFSET (child
), 0)
2102 (tree_low_cst (TYPE_SIZE (BINFO_TYPE (child
)), 0)
2110 /* Write out the field declarations. */
2111 dbxout_type_fields (type
);
2112 if (use_gnu_debug_info_extensions
&& TYPE_METHODS (type
) != NULL_TREE
)
2114 dbxout_type_methods (type
);
2119 if (use_gnu_debug_info_extensions
&& TREE_CODE (type
) == RECORD_TYPE
2120 /* Avoid the ~ if we don't really need it--it confuses dbx. */
2121 && TYPE_VFIELD (type
))
2124 /* We need to write out info about what field this class
2125 uses as its "main" vtable pointer field, because if this
2126 field is inherited from a base class, GDB cannot necessarily
2127 figure out which field it's using in time. */
2129 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type
)), 0);
2135 /* We must use the same test here as we use in the DBX_NO_XREFS case
2136 above. We simplify it a bit since an enum will never have a variable
2138 if ((TYPE_NAME (type
) != 0
2139 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
2140 && DECL_IGNORED_P (TYPE_NAME (type
)))
2142 || !COMPLETE_TYPE_P (type
))
2145 dbxout_type_name (type
);
2146 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
2150 if (use_gnu_debug_info_extensions
2151 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
2154 stabstr_D (TYPE_PRECISION (type
));
2159 for (tem
= TYPE_VALUES (type
); tem
; tem
= TREE_CHAIN (tem
))
2161 stabstr_I (TREE_PURPOSE (tem
));
2164 if (TREE_INT_CST_HIGH (TREE_VALUE (tem
)) == 0)
2165 stabstr_D (TREE_INT_CST_LOW (TREE_VALUE (tem
)));
2166 else if (TREE_INT_CST_HIGH (TREE_VALUE (tem
)) == -1
2167 && (HOST_WIDE_INT
) TREE_INT_CST_LOW (TREE_VALUE (tem
)) < 0)
2168 stabstr_D (TREE_INT_CST_LOW (TREE_VALUE (tem
)));
2170 stabstr_O (TREE_VALUE (tem
));
2173 if (TREE_CHAIN (tem
) != 0)
2182 dbxout_type (TREE_TYPE (type
), 0);
2186 if (use_gnu_debug_info_extensions
)
2190 /* Write the argument types out longhand. */
2191 dbxout_type (TYPE_METHOD_BASETYPE (type
), 0);
2193 dbxout_type (TREE_TYPE (type
), 0);
2194 dbxout_args (TYPE_ARG_TYPES (type
));
2198 /* Treat it as a function type. */
2199 dbxout_type (TREE_TYPE (type
), 0);
2203 if (use_gnu_debug_info_extensions
)
2206 dbxout_type (TYPE_OFFSET_BASETYPE (type
), 0);
2208 dbxout_type (TREE_TYPE (type
), 0);
2211 /* Should print as an int, because it is really just an offset. */
2212 dbxout_type (integer_type_node
, 0);
2215 case REFERENCE_TYPE
:
2216 if (use_gnu_debug_info_extensions
)
2222 dbxout_type (TREE_TYPE (type
), 0);
2227 dbxout_type (TREE_TYPE (type
), 0);
2235 /* Return nonzero if the given type represents an integer whose bounds
2236 should be printed in octal format. */
2239 print_int_cst_bounds_in_octal_p (tree type
)
2241 /* If we can use GDB extensions and the size is wider than a long
2242 (the size used by GDB to read them) or we may have trouble writing
2243 the bounds the usual way, write them in octal. Note the test is for
2244 the *target's* size of "long", not that of the host. The host test
2245 is just to make sure we can write it out in case the host wide int
2246 is narrower than the target "long".
2248 For unsigned types, we use octal if they are the same size or larger.
2249 This is because we print the bounds as signed decimal, and hence they
2250 can't span same size unsigned types. */
2252 if (use_gnu_debug_info_extensions
2253 && TYPE_MIN_VALUE (type
) != 0
2254 && TREE_CODE (TYPE_MIN_VALUE (type
)) == INTEGER_CST
2255 && TYPE_MAX_VALUE (type
) != 0
2256 && TREE_CODE (TYPE_MAX_VALUE (type
)) == INTEGER_CST
2257 && (TYPE_PRECISION (type
) > TYPE_PRECISION (integer_type_node
)
2258 || ((TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
))
2259 && TYPE_UNSIGNED (type
))
2260 || TYPE_PRECISION (type
) > HOST_BITS_PER_WIDE_INT
2261 || (TYPE_PRECISION (type
) == HOST_BITS_PER_WIDE_INT
2262 && TYPE_UNSIGNED (type
))))
2268 /* Output the name of type TYPE, with no punctuation.
2269 Such names can be set up either by typedef declarations
2270 or by struct, enum and union tags. */
2273 dbxout_type_name (tree type
)
2275 tree t
= TYPE_NAME (type
);
2278 switch (TREE_CODE (t
))
2280 case IDENTIFIER_NODE
:
2292 /* Output leading leading struct or class names needed for qualifying
2293 type whose scope is limited to a struct or class. */
2296 dbxout_class_name_qualifiers (tree decl
)
2298 tree context
= decl_type_context (decl
);
2300 if (context
!= NULL_TREE
2301 && TREE_CODE(context
) == RECORD_TYPE
2302 && TYPE_NAME (context
) != 0
2303 && (TREE_CODE (TYPE_NAME (context
)) == IDENTIFIER_NODE
2304 || (DECL_NAME (TYPE_NAME (context
)) != 0)))
2306 tree name
= TYPE_NAME (context
);
2308 if (TREE_CODE (name
) == TYPE_DECL
)
2310 dbxout_class_name_qualifiers (name
);
2311 name
= DECL_NAME (name
);
2318 /* This is a specialized subset of expand_expr for use by dbxout_symbol in
2319 evaluating DECL_VALUE_EXPR. In particular, we stop if we find decls that
2320 havn't been expanded, or if the expression is getting so complex we won't
2321 be able to represent it in stabs anyway. Returns NULL on failure. */
2324 dbxout_expand_expr (tree expr
)
2326 switch (TREE_CODE (expr
))
2330 if (DECL_HAS_VALUE_EXPR_P (expr
))
2331 return dbxout_expand_expr (DECL_VALUE_EXPR (expr
));
2336 return DECL_RTL_IF_SET (expr
);
2339 return expand_expr (expr
, NULL_RTX
, VOIDmode
, EXPAND_INITIALIZER
);
2343 case ARRAY_RANGE_REF
:
2346 enum machine_mode mode
;
2347 HOST_WIDE_INT bitsize
, bitpos
;
2349 int volatilep
= 0, unsignedp
= 0;
2352 tem
= get_inner_reference (expr
, &bitsize
, &bitpos
, &offset
,
2353 &mode
, &unsignedp
, &volatilep
, true);
2355 x
= dbxout_expand_expr (tem
);
2356 if (x
== NULL
|| !MEM_P (x
))
2360 if (!host_integerp (offset
, 0))
2362 x
= adjust_address_nv (x
, mode
, tree_low_cst (offset
, 0));
2365 x
= adjust_address_nv (x
, mode
, bitpos
/ BITS_PER_UNIT
);
2375 /* Helper function for output_used_types. Queue one entry from the
2376 used types hash to be output. */
2379 output_used_types_helper (void **slot
, void *data
)
2382 VEC(tree
, heap
) **types_p
= data
;
2384 if ((TREE_CODE (type
) == RECORD_TYPE
2385 || TREE_CODE (type
) == UNION_TYPE
2386 || TREE_CODE (type
) == QUAL_UNION_TYPE
2387 || TREE_CODE (type
) == ENUMERAL_TYPE
)
2388 && TYPE_STUB_DECL (type
)
2389 && DECL_P (TYPE_STUB_DECL (type
))
2390 && ! DECL_IGNORED_P (TYPE_STUB_DECL (type
)))
2391 VEC_quick_push (tree
, *types_p
, TYPE_STUB_DECL (type
));
2392 else if (TYPE_NAME (type
)
2393 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
2394 VEC_quick_push (tree
, *types_p
, TYPE_NAME (type
));
2399 /* This is a qsort callback which sorts types and declarations into a
2400 predictable order (types, then declarations, sorted by UID
2404 output_types_sort (const void *pa
, const void *pb
)
2406 const tree lhs
= *((const tree
*)pa
);
2407 const tree rhs
= *((const tree
*)pb
);
2412 return TYPE_UID (lhs
) - TYPE_UID (rhs
);
2421 return DECL_UID (lhs
) - DECL_UID (rhs
);
2426 /* Force all types used by this function to be output in debug
2430 output_used_types (void)
2432 if (cfun
&& cfun
->used_types_hash
)
2434 VEC(tree
, heap
) *types
;
2438 types
= VEC_alloc (tree
, heap
, htab_elements (cfun
->used_types_hash
));
2439 htab_traverse (cfun
->used_types_hash
, output_used_types_helper
, &types
);
2441 /* Sort by UID to prevent dependence on hash table ordering. */
2442 qsort (VEC_address (tree
, types
), VEC_length (tree
, types
),
2443 sizeof (tree
), output_types_sort
);
2445 for (i
= 0; VEC_iterate (tree
, types
, i
, type
); i
++)
2446 debug_queue_symbol (type
);
2448 VEC_free (tree
, heap
, types
);
2452 /* Output a .stabs for the symbol defined by DECL,
2453 which must be a ..._DECL node in the normal namespace.
2454 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
2455 LOCAL is nonzero if the scope is less than the entire file.
2456 Return 1 if a stabs might have been emitted. */
2459 dbxout_symbol (tree decl
, int local ATTRIBUTE_UNUSED
)
2461 tree type
= TREE_TYPE (decl
);
2462 tree context
= NULL_TREE
;
2466 /* "Intercept" dbxout_symbol() calls like we do all debug_hooks. */
2469 /* Ignore nameless syms, but don't ignore type tags. */
2471 if ((DECL_NAME (decl
) == 0 && TREE_CODE (decl
) != TYPE_DECL
)
2472 || DECL_IGNORED_P (decl
))
2473 DBXOUT_DECR_NESTING_AND_RETURN (0);
2475 /* If we are to generate only the symbols actually used then such
2476 symbol nodes are flagged with TREE_USED. Ignore any that
2477 aren't flaged as TREE_USED. */
2479 if (flag_debug_only_used_symbols
2480 && (!TREE_USED (decl
)
2481 && (TREE_CODE (decl
) != VAR_DECL
|| !DECL_INITIAL (decl
))))
2482 DBXOUT_DECR_NESTING_AND_RETURN (0);
2484 /* If dbxout_init has not yet run, queue this symbol for later. */
2487 preinit_symbols
= tree_cons (0, decl
, preinit_symbols
);
2488 DBXOUT_DECR_NESTING_AND_RETURN (0);
2491 if (flag_debug_only_used_symbols
)
2495 /* We now have a used symbol. We need to generate the info for
2496 the symbol's type in addition to the symbol itself. These
2497 type symbols are queued to be generated after were done with
2498 the symbol itself (otherwise they would fight over the
2501 Note, because the TREE_TYPE(type) might be something like a
2502 pointer to a named type we need to look for the first name
2503 we see following the TREE_TYPE chain. */
2506 while (POINTER_TYPE_P (t
))
2509 /* RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, and ENUMERAL_TYPE
2510 need special treatment. The TYPE_STUB_DECL field in these
2511 types generally represents the tag name type we want to
2512 output. In addition there could be a typedef type with
2513 a different name. In that case we also want to output
2516 if (TREE_CODE (t
) == RECORD_TYPE
2517 || TREE_CODE (t
) == UNION_TYPE
2518 || TREE_CODE (t
) == QUAL_UNION_TYPE
2519 || TREE_CODE (t
) == ENUMERAL_TYPE
)
2521 if (TYPE_STUB_DECL (t
)
2522 && TYPE_STUB_DECL (t
) != decl
2523 && DECL_P (TYPE_STUB_DECL (t
))
2524 && ! DECL_IGNORED_P (TYPE_STUB_DECL (t
)))
2526 debug_queue_symbol (TYPE_STUB_DECL (t
));
2528 && TYPE_NAME (t
) != TYPE_STUB_DECL (t
)
2529 && TYPE_NAME (t
) != decl
2530 && DECL_P (TYPE_NAME (t
)))
2531 debug_queue_symbol (TYPE_NAME (t
));
2534 else if (TYPE_NAME (t
)
2535 && TYPE_NAME (t
) != decl
2536 && DECL_P (TYPE_NAME (t
)))
2537 debug_queue_symbol (TYPE_NAME (t
));
2540 emit_pending_bincls_if_required ();
2542 switch (TREE_CODE (decl
))
2545 /* Enum values are defined by defining the enum type. */
2549 decl_rtl
= DECL_RTL_IF_SET (decl
);
2551 DBXOUT_DECR_NESTING_AND_RETURN (0);
2552 if (DECL_EXTERNAL (decl
))
2554 /* Don't mention a nested function under its parent. */
2555 context
= decl_function_context (decl
);
2556 if (context
== current_function_decl
)
2558 /* Don't mention an inline instance of a nested function. */
2559 if (context
&& DECL_FROM_INLINE (decl
))
2561 if (!MEM_P (decl_rtl
)
2562 || GET_CODE (XEXP (decl_rtl
, 0)) != SYMBOL_REF
)
2565 if (flag_debug_only_used_symbols
)
2566 output_used_types ();
2568 dbxout_begin_complex_stabs ();
2569 stabstr_I (DECL_ASSEMBLER_NAME (decl
));
2570 stabstr_S (TREE_PUBLIC (decl
) ? ":F" : ":f");
2573 if (TREE_TYPE (type
))
2574 dbxout_type (TREE_TYPE (type
), 0);
2576 dbxout_type (void_type_node
, 0);
2578 /* For a nested function, when that function is compiled,
2579 mention the containing function name
2580 as well as (since dbx wants it) our own assembler-name. */
2584 stabstr_I (DECL_ASSEMBLER_NAME (decl
));
2586 stabstr_I (DECL_NAME (context
));
2589 dbxout_finish_complex_stabs (decl
, N_FUN
, XEXP (decl_rtl
, 0), 0, 0);
2593 /* Don't output the same typedef twice.
2594 And don't output what language-specific stuff doesn't want output. */
2595 if (TREE_ASM_WRITTEN (decl
) || TYPE_DECL_SUPPRESS_DEBUG (decl
))
2596 DBXOUT_DECR_NESTING_AND_RETURN (0);
2598 /* Don't output typedefs for types with magic type numbers (XCOFF). */
2599 #ifdef DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER
2601 int fundamental_type_number
=
2602 DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER (decl
);
2604 if (fundamental_type_number
!= 0)
2606 TREE_ASM_WRITTEN (decl
) = 1;
2607 TYPE_SYMTAB_ADDRESS (TREE_TYPE (decl
)) = fundamental_type_number
;
2608 DBXOUT_DECR_NESTING_AND_RETURN (0);
2618 if (DECL_NAME (decl
))
2620 /* Nonzero means we must output a tag as well as a typedef. */
2623 /* Handle the case of a C++ structure or union
2624 where the TYPE_NAME is a TYPE_DECL
2625 which gives both a typedef name and a tag. */
2626 /* dbx requires the tag first and the typedef second. */
2627 if ((TREE_CODE (type
) == RECORD_TYPE
2628 || TREE_CODE (type
) == UNION_TYPE
2629 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
2630 && TYPE_NAME (type
) == decl
2631 && !use_gnu_debug_info_extensions
2632 && !TREE_ASM_WRITTEN (TYPE_NAME (type
))
2633 /* Distinguish the implicit typedefs of C++
2634 from explicit ones that might be found in C. */
2635 && DECL_ARTIFICIAL (decl
)
2636 /* Do not generate a tag for incomplete records. */
2637 && COMPLETE_TYPE_P (type
)
2638 /* Do not generate a tag for records of variable size,
2639 since this type can not be properly described in the
2640 DBX format, and it confuses some tools such as objdump. */
2641 && host_integerp (TYPE_SIZE (type
), 1))
2643 tree name
= TYPE_NAME (type
);
2644 if (TREE_CODE (name
) == TYPE_DECL
)
2645 name
= DECL_NAME (name
);
2647 dbxout_begin_complex_stabs ();
2650 dbxout_type (type
, 1);
2651 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE
,
2655 dbxout_begin_complex_stabs ();
2657 /* Output leading class/struct qualifiers. */
2658 if (use_gnu_debug_info_extensions
)
2659 dbxout_class_name_qualifiers (decl
);
2661 /* Output typedef name. */
2662 stabstr_I (DECL_NAME (decl
));
2665 /* Short cut way to output a tag also. */
2666 if ((TREE_CODE (type
) == RECORD_TYPE
2667 || TREE_CODE (type
) == UNION_TYPE
2668 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
2669 && TYPE_NAME (type
) == decl
2670 /* Distinguish the implicit typedefs of C++
2671 from explicit ones that might be found in C. */
2672 && DECL_ARTIFICIAL (decl
))
2674 if (use_gnu_debug_info_extensions
)
2677 TREE_ASM_WRITTEN (TYPE_NAME (type
)) = 1;
2682 dbxout_type (type
, 1);
2683 dbxout_finish_complex_stabs (decl
, DBX_TYPE_DECL_STABS_CODE
,
2688 /* Don't output a tag if this is an incomplete type. This prevents
2689 the sun4 Sun OS 4.x dbx from crashing. */
2691 if (tag_needed
&& TYPE_NAME (type
) != 0
2692 && (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
2693 || (DECL_NAME (TYPE_NAME (type
)) != 0))
2694 && COMPLETE_TYPE_P (type
)
2695 && !TREE_ASM_WRITTEN (TYPE_NAME (type
)))
2697 /* For a TYPE_DECL with no name, but the type has a name,
2699 This is what represents `struct foo' with no typedef. */
2700 /* In C++, the name of a type is the corresponding typedef.
2701 In C, it is an IDENTIFIER_NODE. */
2702 tree name
= TYPE_NAME (type
);
2703 if (TREE_CODE (name
) == TYPE_DECL
)
2704 name
= DECL_NAME (name
);
2706 dbxout_begin_complex_stabs ();
2709 dbxout_type (type
, 1);
2710 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE
, 0, 0, 0);
2714 /* If an enum type has no name, it cannot be referred to, but
2715 we must output it anyway, to record the enumeration
2718 if (!did_output
&& TREE_CODE (type
) == ENUMERAL_TYPE
)
2720 dbxout_begin_complex_stabs ();
2721 /* Some debuggers fail when given NULL names, so give this a
2722 harmless name of " " (Why not "(anon)"?). */
2724 dbxout_type (type
, 1);
2725 dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE
, 0, 0, 0);
2728 /* Prevent duplicate output of a typedef. */
2729 TREE_ASM_WRITTEN (decl
) = 1;
2734 /* Parm decls go in their own separate chains
2735 and are output by dbxout_reg_parms and dbxout_parms. */
2740 /* Don't mention a variable that is external.
2741 Let the file that defines it describe it. */
2742 if (DECL_EXTERNAL (decl
))
2745 /* If the variable is really a constant
2746 and not written in memory, inform the debugger.
2748 ??? Why do we skip emitting the type and location in this case? */
2749 if (TREE_STATIC (decl
) && TREE_READONLY (decl
)
2750 && DECL_INITIAL (decl
) != 0
2751 && host_integerp (DECL_INITIAL (decl
), 0)
2752 && ! TREE_ASM_WRITTEN (decl
)
2753 && (DECL_CONTEXT (decl
) == NULL_TREE
2754 || TREE_CODE (DECL_CONTEXT (decl
)) == BLOCK
2755 || TREE_CODE (DECL_CONTEXT (decl
)) == NAMESPACE_DECL
)
2756 && TREE_PUBLIC (decl
) == 0)
2758 /* The sun4 assembler does not grok this. */
2760 if (TREE_CODE (TREE_TYPE (decl
)) == INTEGER_TYPE
2761 || TREE_CODE (TREE_TYPE (decl
)) == ENUMERAL_TYPE
)
2763 HOST_WIDE_INT ival
= TREE_INT_CST_LOW (DECL_INITIAL (decl
));
2765 dbxout_begin_complex_stabs ();
2766 dbxout_symbol_name (decl
, NULL
, 'c');
2769 dbxout_finish_complex_stabs (0, N_LSYM
, 0, 0, 0);
2770 DBXOUT_DECR_NESTING
;
2776 /* else it is something we handle like a normal variable. */
2778 decl_rtl
= dbxout_expand_expr (decl
);
2780 DBXOUT_DECR_NESTING_AND_RETURN (0);
2782 decl_rtl
= eliminate_regs (decl_rtl
, 0, NULL_RTX
);
2783 #ifdef LEAF_REG_REMAP
2784 if (current_function_uses_only_leaf_regs
)
2785 leaf_renumber_regs_insn (decl_rtl
);
2788 result
= dbxout_symbol_location (decl
, type
, 0, decl_rtl
);
2794 DBXOUT_DECR_NESTING
;
2798 /* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL.
2799 Add SUFFIX to its name, if SUFFIX is not 0.
2800 Describe the variable as residing in HOME
2801 (usually HOME is DECL_RTL (DECL), but not always).
2802 Returns 1 if the stab was really emitted. */
2805 dbxout_symbol_location (tree decl
, tree type
, const char *suffix
, rtx home
)
2808 STAB_CODE_TYPE code
;
2813 /* Don't mention a variable at all
2814 if it was completely optimized into nothingness.
2816 If the decl was from an inline function, then its rtl
2817 is not identically the rtl that was used in this
2818 particular compilation. */
2819 if (GET_CODE (home
) == SUBREG
)
2823 while (GET_CODE (value
) == SUBREG
)
2824 value
= SUBREG_REG (value
);
2827 if (REGNO (value
) >= FIRST_PSEUDO_REGISTER
)
2830 home
= alter_subreg (&home
);
2834 regno
= REGNO (home
);
2835 if (regno
>= FIRST_PSEUDO_REGISTER
)
2839 /* The kind-of-variable letter depends on where
2840 the variable is and on the scope of its name:
2841 G and N_GSYM for static storage and global scope,
2842 S for static storage and file scope,
2843 V for static storage and local scope,
2844 for those two, use N_LCSYM if data is in bss segment,
2845 N_STSYM if in data segment, N_FUN otherwise.
2846 (We used N_FUN originally, then changed to N_STSYM
2847 to please GDB. However, it seems that confused ld.
2848 Now GDB has been fixed to like N_FUN, says Kingdon.)
2849 no letter at all, and N_LSYM, for auto variable,
2850 r and N_RSYM for register variable. */
2852 if (MEM_P (home
) && GET_CODE (XEXP (home
, 0)) == SYMBOL_REF
)
2854 if (TREE_PUBLIC (decl
))
2861 addr
= XEXP (home
, 0);
2863 letter
= decl_function_context (decl
) ? 'V' : 'S';
2865 /* Some ports can transform a symbol ref into a label ref,
2866 because the symbol ref is too far away and has to be
2867 dumped into a constant pool. Alternatively, the symbol
2868 in the constant pool might be referenced by a different
2870 if (GET_CODE (addr
) == SYMBOL_REF
2871 && CONSTANT_POOL_ADDRESS_P (addr
))
2874 rtx tmp
= get_pool_constant_mark (addr
, &marked
);
2876 if (GET_CODE (tmp
) == SYMBOL_REF
)
2879 if (CONSTANT_POOL_ADDRESS_P (addr
))
2880 get_pool_constant_mark (addr
, &marked
);
2884 else if (GET_CODE (tmp
) == LABEL_REF
)
2890 /* If all references to the constant pool were optimized
2891 out, we just ignore the symbol. */
2896 /* This should be the same condition as in assemble_variable, but
2897 we don't have access to dont_output_data here. So, instead,
2898 we rely on the fact that error_mark_node initializers always
2899 end up in bss for C++ and never end up in bss for C. */
2900 if (DECL_INITIAL (decl
) == 0
2901 || (!strcmp (lang_hooks
.name
, "GNU C++")
2902 && DECL_INITIAL (decl
) == error_mark_node
))
2904 else if (DECL_IN_TEXT_SECTION (decl
))
2905 /* This is not quite right, but it's the closest
2906 of all the codes that Unix defines. */
2907 code
= DBX_STATIC_CONST_VAR_CODE
;
2910 /* Ultrix `as' seems to need this. */
2911 #ifdef DBX_STATIC_STAB_DATA_SECTION
2912 switch_to_section (data_section
);
2918 else if (regno
>= 0)
2922 number
= DBX_REGISTER_NUMBER (regno
);
2924 else if (MEM_P (home
)
2925 && (MEM_P (XEXP (home
, 0))
2926 || (REG_P (XEXP (home
, 0))
2927 && REGNO (XEXP (home
, 0)) != HARD_FRAME_POINTER_REGNUM
2928 && REGNO (XEXP (home
, 0)) != STACK_POINTER_REGNUM
2929 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2930 && REGNO (XEXP (home
, 0)) != ARG_POINTER_REGNUM
2933 /* If the value is indirect by memory or by a register
2934 that isn't the frame pointer
2935 then it means the object is variable-sized and address through
2936 that register or stack slot. DBX has no way to represent this
2937 so all we can do is output the variable as a pointer.
2938 If it's not a parameter, ignore it. */
2940 if (REG_P (XEXP (home
, 0)))
2944 if (REGNO (XEXP (home
, 0)) >= FIRST_PSEUDO_REGISTER
)
2946 number
= DBX_REGISTER_NUMBER (REGNO (XEXP (home
, 0)));
2951 /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
2952 We want the value of that CONST_INT. */
2953 number
= DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home
, 0), 0));
2956 /* Effectively do build_pointer_type, but don't cache this type,
2957 since it might be temporary whereas the type it points to
2958 might have been saved for inlining. */
2959 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
2960 type
= make_node (POINTER_TYPE
);
2961 TREE_TYPE (type
) = TREE_TYPE (decl
);
2963 else if (MEM_P (home
)
2964 && REG_P (XEXP (home
, 0)))
2967 number
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
2969 else if (MEM_P (home
)
2970 && GET_CODE (XEXP (home
, 0)) == PLUS
2971 && GET_CODE (XEXP (XEXP (home
, 0), 1)) == CONST_INT
)
2974 /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
2975 We want the value of that CONST_INT. */
2976 number
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
2978 else if (MEM_P (home
)
2979 && GET_CODE (XEXP (home
, 0)) == CONST
)
2981 /* Handle an obscure case which can arise when optimizing and
2982 when there are few available registers. (This is *always*
2983 the case for i386/i486 targets). The RTL looks like
2984 (MEM (CONST ...)) even though this variable is a local `auto'
2985 or a local `register' variable. In effect, what has happened
2986 is that the reload pass has seen that all assignments and
2987 references for one such a local variable can be replaced by
2988 equivalent assignments and references to some static storage
2989 variable, thereby avoiding the need for a register. In such
2990 cases we're forced to lie to debuggers and tell them that
2991 this variable was itself `static'. */
2994 addr
= XEXP (XEXP (home
, 0), 0);
2996 else if (GET_CODE (home
) == CONCAT
)
3000 /* If TYPE is not a COMPLEX_TYPE (it might be a RECORD_TYPE,
3001 for example), then there is no easy way to figure out
3002 what SUBTYPE should be. So, we give up. */
3003 if (TREE_CODE (type
) != COMPLEX_TYPE
)
3006 subtype
= TREE_TYPE (type
);
3008 /* If the variable's storage is in two parts,
3009 output each as a separate stab with a modified name. */
3010 if (WORDS_BIG_ENDIAN
)
3011 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 0));
3013 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 0));
3015 if (WORDS_BIG_ENDIAN
)
3016 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 1));
3018 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 1));
3022 /* Address might be a MEM, when DECL is a variable-sized object.
3023 Or it might be const0_rtx, meaning previous passes
3024 want us to ignore this variable. */
3027 /* Ok, start a symtab entry and output the variable name. */
3028 emit_pending_bincls_if_required ();
3031 #ifdef DBX_STATIC_BLOCK_START
3032 DBX_STATIC_BLOCK_START (asm_out_file
, code
);
3035 dbxout_begin_complex_stabs_noforcetext ();
3036 dbxout_symbol_name (decl
, suffix
, letter
);
3037 dbxout_type (type
, 0);
3038 dbxout_finish_complex_stabs (decl
, code
, addr
, 0, number
);
3040 #ifdef DBX_STATIC_BLOCK_END
3041 DBX_STATIC_BLOCK_END (asm_out_file
, code
);
3046 /* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
3047 Then output LETTER to indicate the kind of location the symbol has. */
3050 dbxout_symbol_name (tree decl
, const char *suffix
, int letter
)
3054 if (DECL_CONTEXT (decl
)
3055 && (TYPE_P (DECL_CONTEXT (decl
))
3056 || TREE_CODE (DECL_CONTEXT (decl
)) == NAMESPACE_DECL
))
3057 /* One slight hitch: if this is a VAR_DECL which is a class member
3058 or a namespace member, we must put out the mangled name instead of the
3059 DECL_NAME. Note also that static member (variable) names DO NOT begin
3060 with underscores in .stabs directives. */
3061 name
= DECL_ASSEMBLER_NAME (decl
);
3063 /* ...but if we're function-local, we don't want to include the junk
3064 added by ASM_FORMAT_PRIVATE_NAME. */
3065 name
= DECL_NAME (decl
);
3070 stabstr_S ("(anon)");
3079 /* Output definitions of all the decls in a chain. Return nonzero if
3080 anything was output */
3083 dbxout_syms (tree syms
)
3088 result
+= dbxout_symbol (syms
, 1);
3089 syms
= TREE_CHAIN (syms
);
3094 /* The following two functions output definitions of function parameters.
3095 Each parameter gets a definition locating it in the parameter list.
3096 Each parameter that is a register variable gets a second definition
3097 locating it in the register.
3099 Printing or argument lists in gdb uses the definitions that
3100 locate in the parameter list. But reference to the variable in
3101 expressions uses preferentially the definition as a register. */
3103 /* Output definitions, referring to storage in the parmlist,
3104 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
3107 dbxout_parms (tree parms
)
3110 emit_pending_bincls_if_required ();
3112 for (; parms
; parms
= TREE_CHAIN (parms
))
3113 if (DECL_NAME (parms
)
3114 && TREE_TYPE (parms
) != error_mark_node
3115 && DECL_RTL_SET_P (parms
)
3116 && DECL_INCOMING_RTL (parms
))
3120 STAB_CODE_TYPE code
;
3123 /* Perform any necessary register eliminations on the parameter's rtl,
3124 so that the debugging output will be accurate. */
3125 DECL_INCOMING_RTL (parms
)
3126 = eliminate_regs (DECL_INCOMING_RTL (parms
), 0, NULL_RTX
);
3127 SET_DECL_RTL (parms
, eliminate_regs (DECL_RTL (parms
), 0, NULL_RTX
));
3128 #ifdef LEAF_REG_REMAP
3129 if (current_function_uses_only_leaf_regs
)
3131 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms
));
3132 leaf_renumber_regs_insn (DECL_RTL (parms
));
3136 if (PARM_PASSED_IN_MEMORY (parms
))
3138 rtx inrtl
= XEXP (DECL_INCOMING_RTL (parms
), 0);
3140 /* ??? Here we assume that the parm address is indexed
3141 off the frame pointer or arg pointer.
3142 If that is not true, we produce meaningless results,
3143 but do not crash. */
3144 if (GET_CODE (inrtl
) == PLUS
3145 && GET_CODE (XEXP (inrtl
, 1)) == CONST_INT
)
3146 number
= INTVAL (XEXP (inrtl
, 1));
3151 number
= DEBUGGER_ARG_OFFSET (number
, inrtl
);
3154 /* It is quite tempting to use TREE_TYPE (parms) instead
3155 of DECL_ARG_TYPE (parms) for the eff_type, so that gcc
3156 reports the actual type of the parameter, rather than
3157 the promoted type. This certainly makes GDB's life
3158 easier, at least for some ports. The change is a bad
3159 idea however, since GDB expects to be able access the
3160 type without performing any conversions. So for
3161 example, if we were passing a float to an unprototyped
3162 function, gcc will store a double on the stack, but if
3163 we emit a stab saying the type is a float, then gdb
3164 will only read in a single value, and this will produce
3165 an erroneous value. */
3166 eff_type
= DECL_ARG_TYPE (parms
);
3168 else if (REG_P (DECL_RTL (parms
)))
3172 /* Parm passed in registers and lives in registers or nowhere. */
3173 code
= DBX_REGPARM_STABS_CODE
;
3174 letter
= DBX_REGPARM_STABS_LETTER
;
3176 /* For parms passed in registers, it is better to use the
3177 declared type of the variable, not the type it arrived in. */
3178 eff_type
= TREE_TYPE (parms
);
3180 /* If parm lives in a register, use that register; pretend
3181 the parm was passed there. It would be more consistent
3182 to describe the register where the parm was passed, but
3183 in practice that register usually holds something else.
3184 If the parm lives nowhere, use the register where it
3186 if (REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
3187 best_rtl
= DECL_RTL (parms
);
3189 best_rtl
= DECL_INCOMING_RTL (parms
);
3191 number
= DBX_REGISTER_NUMBER (REGNO (best_rtl
));
3193 else if (MEM_P (DECL_RTL (parms
))
3194 && REG_P (XEXP (DECL_RTL (parms
), 0))
3195 && REGNO (XEXP (DECL_RTL (parms
), 0)) != HARD_FRAME_POINTER_REGNUM
3196 && REGNO (XEXP (DECL_RTL (parms
), 0)) != STACK_POINTER_REGNUM
3197 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
3198 && REGNO (XEXP (DECL_RTL (parms
), 0)) != ARG_POINTER_REGNUM
3202 /* Parm was passed via invisible reference.
3203 That is, its address was passed in a register.
3204 Output it as if it lived in that register.
3205 The debugger will know from the type
3206 that it was actually passed by invisible reference. */
3208 code
= DBX_REGPARM_STABS_CODE
;
3210 /* GDB likes this marked with a special letter. */
3211 letter
= (use_gnu_debug_info_extensions
3212 ? 'a' : DBX_REGPARM_STABS_LETTER
);
3213 eff_type
= TREE_TYPE (parms
);
3215 /* DECL_RTL looks like (MEM (REG...). Get the register number.
3216 If it is an unallocated pseudo-reg, then use the register where
3217 it was passed instead.
3218 ??? Why is DBX_REGISTER_NUMBER not used here? */
3220 if (REGNO (XEXP (DECL_RTL (parms
), 0)) < FIRST_PSEUDO_REGISTER
)
3221 number
= REGNO (XEXP (DECL_RTL (parms
), 0));
3223 number
= REGNO (DECL_INCOMING_RTL (parms
));
3225 else if (MEM_P (DECL_RTL (parms
))
3226 && MEM_P (XEXP (DECL_RTL (parms
), 0)))
3228 /* Parm was passed via invisible reference, with the reference
3229 living on the stack. DECL_RTL looks like
3230 (MEM (MEM (PLUS (REG ...) (CONST_INT ...)))) or it
3231 could look like (MEM (MEM (REG))). */
3235 eff_type
= TREE_TYPE (parms
);
3237 if (!REG_P (XEXP (XEXP (DECL_RTL (parms
), 0), 0)))
3238 number
= INTVAL (XEXP (XEXP (XEXP (DECL_RTL (parms
), 0), 0), 1));
3242 number
= DEBUGGER_ARG_OFFSET (number
,
3243 XEXP (XEXP (DECL_RTL (parms
), 0), 0));
3245 else if (MEM_P (DECL_RTL (parms
))
3246 && XEXP (DECL_RTL (parms
), 0) != const0_rtx
3247 /* ??? A constant address for a parm can happen
3248 when the reg it lives in is equiv to a constant in memory.
3249 Should make this not happen, after 2.4. */
3250 && ! CONSTANT_P (XEXP (DECL_RTL (parms
), 0)))
3252 /* Parm was passed in registers but lives on the stack. */
3256 eff_type
= TREE_TYPE (parms
);
3258 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
3259 in which case we want the value of that CONST_INT,
3261 in which case we use a value of zero. */
3262 if (!REG_P (XEXP (DECL_RTL (parms
), 0)))
3263 number
= INTVAL (XEXP (XEXP (DECL_RTL (parms
), 0), 1));
3267 /* Make a big endian correction if the mode of the type of the
3268 parameter is not the same as the mode of the rtl. */
3269 if (BYTES_BIG_ENDIAN
3270 && TYPE_MODE (TREE_TYPE (parms
)) != GET_MODE (DECL_RTL (parms
))
3271 && GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms
))) < UNITS_PER_WORD
)
3272 number
+= (GET_MODE_SIZE (GET_MODE (DECL_RTL (parms
)))
3273 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms
))));
3276 /* ??? We don't know how to represent this argument. */
3279 dbxout_begin_complex_stabs ();
3281 if (DECL_NAME (parms
))
3283 stabstr_I (DECL_NAME (parms
));
3287 stabstr_S ("(anon):");
3289 dbxout_type (eff_type
, 0);
3290 dbxout_finish_complex_stabs (parms
, code
, 0, 0, number
);
3292 DBXOUT_DECR_NESTING
;
3295 /* Output definitions for the places where parms live during the function,
3296 when different from where they were passed, when the parms were passed
3299 It is not useful to do this for parms passed in registers
3300 that live during the function in different registers, because it is
3301 impossible to look in the passed register for the passed value,
3302 so we use the within-the-function register to begin with.
3304 PARMS is a chain of PARM_DECL nodes. */
3307 dbxout_reg_parms (tree parms
)
3311 for (; parms
; parms
= TREE_CHAIN (parms
))
3312 if (DECL_NAME (parms
) && PARM_PASSED_IN_MEMORY (parms
))
3314 /* Report parms that live in registers during the function
3315 but were passed in memory. */
3316 if (REG_P (DECL_RTL (parms
))
3317 && REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
3318 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
3319 0, DECL_RTL (parms
));
3320 else if (GET_CODE (DECL_RTL (parms
)) == CONCAT
)
3321 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
3322 0, DECL_RTL (parms
));
3323 /* Report parms that live in memory but not where they were passed. */
3324 else if (MEM_P (DECL_RTL (parms
))
3325 && ! rtx_equal_p (DECL_RTL (parms
), DECL_INCOMING_RTL (parms
)))
3326 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
3327 0, DECL_RTL (parms
));
3329 DBXOUT_DECR_NESTING
;
3332 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
3333 output definitions of those names, in raw form */
3336 dbxout_args (tree args
)
3341 dbxout_type (TREE_VALUE (args
), 0);
3342 args
= TREE_CHAIN (args
);
3346 /* Subroutine of dbxout_block. Emit an N_LBRAC stab referencing LABEL.
3347 BEGIN_LABEL is the name of the beginning of the function, which may
3350 dbx_output_lbrac (const char *label
,
3351 const char *begin_label ATTRIBUTE_UNUSED
)
3353 dbxout_begin_stabn (N_LBRAC
);
3354 if (DBX_BLOCKS_FUNCTION_RELATIVE
)
3355 dbxout_stab_value_label_diff (label
, begin_label
);
3357 dbxout_stab_value_label (label
);
3360 /* Subroutine of dbxout_block. Emit an N_RBRAC stab referencing LABEL.
3361 BEGIN_LABEL is the name of the beginning of the function, which may
3364 dbx_output_rbrac (const char *label
,
3365 const char *begin_label ATTRIBUTE_UNUSED
)
3367 dbxout_begin_stabn (N_RBRAC
);
3368 if (DBX_BLOCKS_FUNCTION_RELATIVE
)
3369 dbxout_stab_value_label_diff (label
, begin_label
);
3371 dbxout_stab_value_label (label
);
3374 /* Output everything about a symbol block (a BLOCK node
3375 that represents a scope level),
3376 including recursive output of contained blocks.
3378 BLOCK is the BLOCK node.
3379 DEPTH is its depth within containing symbol blocks.
3380 ARGS is usually zero; but for the outermost block of the
3381 body of a function, it is a chain of PARM_DECLs for the function parameters.
3382 We output definitions of all the register parms
3383 as if they were local variables of that block.
3385 If -g1 was used, we count blocks just the same, but output nothing
3386 except for the outermost block.
3388 Actually, BLOCK may be several blocks chained together.
3389 We handle them all in sequence. */
3392 dbxout_block (tree block
, int depth
, tree args
)
3394 char begin_label
[20];
3395 /* Reference current function start using LFBB. */
3396 ASM_GENERATE_INTERNAL_LABEL (begin_label
, "LFBB", scope_labelno
);
3400 /* Ignore blocks never expanded or otherwise marked as real. */
3401 if (TREE_USED (block
) && TREE_ASM_WRITTEN (block
))
3404 int blocknum
= BLOCK_NUMBER (block
);
3406 /* In dbx format, the syms of a block come before the N_LBRAC.
3407 If nothing is output, we don't need the N_LBRAC, either. */
3409 if (debug_info_level
!= DINFO_LEVEL_TERSE
|| depth
== 0)
3410 did_output
= dbxout_syms (BLOCK_VARS (block
));
3412 dbxout_reg_parms (args
);
3414 /* Now output an N_LBRAC symbol to represent the beginning of
3415 the block. Use the block's tree-walk order to generate
3416 the assembler symbols LBBn and LBEn
3417 that final will define around the code in this block. */
3421 const char *scope_start
;
3424 /* The outermost block doesn't get LBB labels; use
3425 the LFBB local symbol emitted by dbxout_begin_prologue. */
3426 scope_start
= begin_label
;
3429 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBB", blocknum
);
3433 if (BLOCK_HANDLER_BLOCK (block
))
3435 /* A catch block. Must precede N_LBRAC. */
3436 tree decl
= BLOCK_VARS (block
);
3439 dbxout_begin_complex_stabs ();
3440 stabstr_I (DECL_NAME (decl
));
3442 dbxout_finish_complex_stabs (0, N_CATCH
, 0,
3444 decl
= TREE_CHAIN (decl
);
3447 dbx_output_lbrac (scope_start
, begin_label
);
3450 /* Output the subblocks. */
3451 dbxout_block (BLOCK_SUBBLOCKS (block
), depth
+ 1, NULL_TREE
);
3453 /* Refer to the marker for the end of the block. */
3458 /* The outermost block doesn't get LBE labels;
3459 use the "scope" label which will be emitted
3460 by dbxout_function_end. */
3461 ASM_GENERATE_INTERNAL_LABEL (buf
, "Lscope", scope_labelno
);
3463 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBE", blocknum
);
3465 dbx_output_rbrac (buf
, begin_label
);
3468 block
= BLOCK_CHAIN (block
);
3472 /* Output the information about a function and its arguments and result.
3473 Usually this follows the function's code,
3474 but on some systems, it comes before. */
3476 #if defined (DBX_DEBUGGING_INFO)
3478 dbxout_begin_function (tree decl
)
3480 int saved_tree_used1
;
3482 if (DECL_IGNORED_P (decl
))
3485 saved_tree_used1
= TREE_USED (decl
);
3486 TREE_USED (decl
) = 1;
3487 if (DECL_NAME (DECL_RESULT (decl
)) != 0)
3489 int saved_tree_used2
= TREE_USED (DECL_RESULT (decl
));
3490 TREE_USED (DECL_RESULT (decl
)) = 1;
3491 dbxout_symbol (decl
, 0);
3492 TREE_USED (DECL_RESULT (decl
)) = saved_tree_used2
;
3495 dbxout_symbol (decl
, 0);
3496 TREE_USED (decl
) = saved_tree_used1
;
3498 dbxout_parms (DECL_ARGUMENTS (decl
));
3499 if (DECL_NAME (DECL_RESULT (decl
)) != 0)
3500 dbxout_symbol (DECL_RESULT (decl
), 1);
3502 #endif /* DBX_DEBUGGING_INFO */
3504 #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */
3506 #include "gt-dbxout.h"