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 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
23 /* Output dbx-format symbol table data.
24 This consists of many symbol table entries, each of them
25 a .stabs assembler pseudo-op with four operands:
26 a "name" which is really a description of one symbol and its type,
27 a "code", which is a symbol defined in stab.h whose name starts with N_,
28 an unused operand always 0,
29 and a "value" which is an address or an offset.
30 The name is enclosed in doublequote characters.
32 Each function, variable, typedef, and structure tag
33 has a symbol table entry to define it.
34 The beginning and end of each level of name scoping within
35 a function are also marked by special symbol table entries.
37 The "name" consists of the symbol name, a colon, a kind-of-symbol letter,
38 and a data type number. The data type number may be followed by
39 "=" and a type definition; normally this will happen the first time
40 the type number is mentioned. The type definition may refer to
41 other types by number, and those type numbers may be followed
42 by "=" and nested definitions.
44 This can make the "name" quite long.
45 When a name is more than 80 characters, we split the .stabs pseudo-op
46 into two .stabs pseudo-ops, both sharing the same "code" and "value".
47 The first one is marked as continued with a double-backslash at the
50 The kind-of-symbol letter distinguished function names from global
51 variables from file-scope variables from parameters from auto
52 variables in memory from typedef names from register variables.
55 The "code" is mostly redundant with the kind-of-symbol letter
56 that goes in the "name", but not entirely: for symbols located
57 in static storage, the "code" says which segment the address is in,
58 which controls how it is relocated.
60 The "value" for a symbol in static storage
61 is the core address of the symbol (actually, the assembler
62 label for the symbol). For a symbol located in a stack slot
63 it is the stack offset; for one in a register, the register number.
64 For a typedef symbol, it is zero.
66 If DEBUG_SYMS_TEXT is defined, all debugging symbols must be
67 output while in the text section.
69 For more on data type definitions, see `dbxout_type'. */
73 #include "coretypes.h"
80 #include "insn-config.h"
82 #include "output.h" /* ASM_OUTPUT_SOURCE_LINE may refer to sdb functions. */
90 #include "langhooks.h"
92 #ifdef XCOFF_DEBUGGING_INFO
96 #undef DBXOUT_DECR_NESTING
97 #define DBXOUT_DECR_NESTING \
98 if (--debug_nesting == 0 && symbol_queue_index > 0) \
99 { emit_pending_bincls_if_required (); debug_flush_symbol_queue (); }
101 #undef DBXOUT_DECR_NESTING_AND_RETURN
102 #define DBXOUT_DECR_NESTING_AND_RETURN(x) \
103 do {--debug_nesting; return (x);} while (0)
106 #define ASM_STABS_OP "\t.stabs\t"
110 #define ASM_STABN_OP "\t.stabn\t"
113 #ifndef DBX_TYPE_DECL_STABS_CODE
114 #define DBX_TYPE_DECL_STABS_CODE N_LSYM
117 #ifndef DBX_STATIC_CONST_VAR_CODE
118 #define DBX_STATIC_CONST_VAR_CODE N_FUN
121 #ifndef DBX_REGPARM_STABS_CODE
122 #define DBX_REGPARM_STABS_CODE N_RSYM
125 #ifndef DBX_REGPARM_STABS_LETTER
126 #define DBX_REGPARM_STABS_LETTER 'P'
129 /* This is used for parameters passed by invisible reference in a register. */
130 #ifndef GDB_INV_REF_REGPARM_STABS_LETTER
131 #define GDB_INV_REF_REGPARM_STABS_LETTER 'a'
134 #ifndef DBX_MEMPARM_STABS_LETTER
135 #define DBX_MEMPARM_STABS_LETTER 'p'
138 #ifndef FILE_NAME_JOINER
139 #define FILE_NAME_JOINER "/"
142 /* GDB needs to know that the stabs were generated by GCC. We emit an
143 N_OPT stab at the beginning of the source file to indicate this.
144 The string is historical, and different on a very few targets. */
145 #ifndef STABS_GCC_MARKER
146 #define STABS_GCC_MARKER "gcc2_compiled."
149 #ifndef NO_DBX_FUNCTION_END
150 #define NO_DBX_FUNCTION_END 0
153 #ifndef NO_DBX_BNSYM_ENSYM
154 #define NO_DBX_BNSYM_ENSYM 0
157 enum typestatus
{TYPE_UNSEEN
, TYPE_XREF
, TYPE_DEFINED
};
159 /* Structure recording information about a C data type.
160 The status element says whether we have yet output
161 the definition of the type. TYPE_XREF says we have
162 output it as a cross-reference only.
163 The file_number and type_number elements are used if DBX_USE_BINCL
166 struct typeinfo
GTY(())
168 enum typestatus status
;
173 /* Vector recording information about C data types.
174 When we first notice a data type (a tree node),
175 we assign it a number using next_type_number.
176 That is its index in this vector. */
178 static GTY ((length ("typevec_len"))) struct typeinfo
*typevec
;
180 /* Number of elements of space allocated in `typevec'. */
182 static GTY(()) int typevec_len
;
184 /* In dbx output, each type gets a unique number.
185 This is the number for the next type output.
186 The number, once assigned, is in the TYPE_SYMTAB_ADDRESS field. */
188 static GTY(()) int next_type_number
;
190 /* The C front end may call dbxout_symbol before dbxout_init runs.
191 We save all such decls in this list and output them when we get
194 static GTY(()) tree preinit_symbols
;
196 enum binclstatus
{BINCL_NOT_REQUIRED
, BINCL_PENDING
, BINCL_PROCESSED
};
198 /* When using N_BINCL in dbx output, each type number is actually a
199 pair of the file number and the type number within the file.
200 This is a stack of input files. */
204 struct dbx_file
*next
;
206 int next_type_number
;
207 enum binclstatus bincl_status
; /* Keep track of lazy bincl. */
208 const char *pending_bincl_name
; /* Name of bincl. */
209 struct dbx_file
*prev
; /* Chain to traverse all pending bincls. */
212 /* This is the top of the stack.
214 This is not saved for PCH, because restoring a PCH should not change it.
215 next_file_number does have to be saved, because the PCH may use some
216 file numbers; however, just before restoring a PCH, next_file_number
217 should always be 0 because we should not have needed any file numbers
220 #if (defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)) \
221 && defined (DBX_USE_BINCL)
222 static struct dbx_file
*current_file
;
225 /* This is the next file number to use. */
227 static GTY(()) int next_file_number
;
229 /* A counter for dbxout_function_end. */
231 static GTY(()) int scope_labelno
;
233 /* A counter for dbxout_source_line. */
235 static GTY(()) int dbxout_source_line_counter
;
237 /* Nonzero if we have actually used any of the GDB extensions
238 to the debugging format. The idea is that we use them for the
239 first time only if there's a strong reason, but once we have done that,
240 we use them whenever convenient. */
242 static GTY(()) int have_used_extensions
= 0;
244 /* Number for the next N_SOL filename stabs label. The number 0 is reserved
245 for the N_SO filename stabs label. */
247 static GTY(()) int source_label_number
= 1;
249 /* Last source file name mentioned in a NOTE insn. */
251 static GTY(()) const char *lastfile
;
253 /* Used by PCH machinery to detect if 'lastfile' should be reset to
255 static GTY(()) int lastfile_is_base
;
257 /* Typical USG systems don't have stab.h, and they also have
258 no use for DBX-format debugging info. */
260 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
263 /* If zero then there is no pending BINCL. */
264 static int pending_bincls
= 0;
267 /* The original input file name. */
268 static const char *base_input_file
;
270 /* Current working directory. */
272 static const char *cwd
;
274 #ifdef DEBUG_SYMS_TEXT
275 #define FORCE_TEXT function_section (current_function_decl);
282 #define STAB_CODE_TYPE enum __stab_debug_code
284 /* 1 if PARM is passed to this function in memory. */
286 #define PARM_PASSED_IN_MEMORY(PARM) \
287 (MEM_P (DECL_INCOMING_RTL (PARM)))
289 /* A C expression for the integer offset value of an automatic variable
290 (N_LSYM) having address X (an RTX). */
291 #ifndef DEBUGGER_AUTO_OFFSET
292 #define DEBUGGER_AUTO_OFFSET(X) \
293 (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
296 /* A C expression for the integer offset value of an argument (N_PSYM)
297 having address X (an RTX). The nominal offset is OFFSET. */
298 #ifndef DEBUGGER_ARG_OFFSET
299 #define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET)
302 /* Stream for writing to assembler file. */
304 static FILE *asmfile
;
306 /* These variables are for dbxout_symbol to communicate to
307 dbxout_finish_symbol.
308 current_sym_code is the symbol-type-code, a symbol N_... define in stab.h.
309 current_sym_value and current_sym_addr are two ways to address the
310 value to store in the symtab entry.
311 current_sym_addr if nonzero represents the value as an rtx.
312 If that is zero, current_sym_value is used. This is used
313 when the value is an offset (such as for auto variables,
314 register variables and parms). */
316 static STAB_CODE_TYPE current_sym_code
;
317 static int current_sym_value
;
318 static rtx current_sym_addr
;
320 /* Number of chars of symbol-description generated so far for the
321 current symbol. Used by CHARS and CONTIN. */
323 static int current_sym_nchars
;
325 /* Report having output N chars of the current symbol-description. */
327 #define CHARS(N) (current_sym_nchars += (N))
329 /* Break the current symbol-description, generating a continuation,
330 if it has become long. */
332 #ifndef DBX_CONTIN_LENGTH
333 #define DBX_CONTIN_LENGTH 80
336 #if DBX_CONTIN_LENGTH > 0
338 do {if (current_sym_nchars > DBX_CONTIN_LENGTH) dbxout_continue ();} while (0)
340 #define CONTIN do { } while (0)
344 static void emit_bincl_stab (const char *c
);
345 static void emit_pending_bincls (void);
347 static inline void emit_pending_bincls_if_required (void);
349 static void dbxout_init (const char *);
350 #ifndef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
351 static unsigned int get_lang_number (void);
353 static void dbxout_finish (const char *);
354 static void dbxout_start_source_file (unsigned, const char *);
355 static void dbxout_end_source_file (unsigned);
356 static void dbxout_typedefs (tree
);
357 static void dbxout_type_index (tree
);
358 #if DBX_CONTIN_LENGTH > 0
359 static void dbxout_continue (void);
361 static void dbxout_args (tree
);
362 static void dbxout_type_fields (tree
);
363 static void dbxout_type_method_1 (tree
, const char *);
364 static void dbxout_type_methods (tree
);
365 static void dbxout_range_type (tree
);
366 static void dbxout_type (tree
, int);
367 static bool print_int_cst_bounds_in_octal_p (tree
);
368 static void print_int_cst_octal (tree
);
369 static void print_octal (unsigned HOST_WIDE_INT
, int);
370 static void print_wide_int (HOST_WIDE_INT
);
371 static void dbxout_type_name (tree
);
372 static void dbxout_class_name_qualifiers (tree
);
373 static int dbxout_symbol_location (tree
, tree
, const char *, rtx
);
374 static void dbxout_symbol_name (tree
, const char *, int);
375 static void dbxout_prepare_symbol (tree
);
376 static void dbxout_finish_symbol (tree
);
377 static void dbxout_block (tree
, int, tree
);
378 static void dbxout_global_decl (tree
);
379 static void dbxout_type_decl (tree
, int);
380 static void dbxout_handle_pch (unsigned);
382 /* The debug hooks structure. */
383 #if defined (DBX_DEBUGGING_INFO)
385 static void dbxout_source_line (unsigned int, const char *);
386 static void dbxout_begin_prologue (unsigned int, const char *);
387 static void dbxout_source_file (FILE *, const char *);
388 static void dbxout_function_end (void);
389 static void dbxout_begin_function (tree
);
390 static void dbxout_begin_block (unsigned, unsigned);
391 static void dbxout_end_block (unsigned, unsigned);
392 static void dbxout_function_decl (tree
);
394 const struct gcc_debug_hooks dbx_debug_hooks
=
398 debug_nothing_int_charstar
,
399 debug_nothing_int_charstar
,
400 dbxout_start_source_file
,
401 dbxout_end_source_file
,
404 debug_true_tree
, /* ignore_block */
405 dbxout_source_line
, /* source_line */
406 dbxout_begin_prologue
, /* begin_prologue */
407 debug_nothing_int_charstar
, /* end_prologue */
408 debug_nothing_int_charstar
, /* end_epilogue */
409 #ifdef DBX_FUNCTION_FIRST
410 dbxout_begin_function
,
412 debug_nothing_tree
, /* begin_function */
414 debug_nothing_int
, /* end_function */
415 dbxout_function_decl
,
416 dbxout_global_decl
, /* global_decl */
417 dbxout_type_decl
, /* type_decl */
418 debug_nothing_tree_tree
, /* imported_module_or_decl */
419 debug_nothing_tree
, /* deferred_inline_function */
420 debug_nothing_tree
, /* outlining_inline_function */
421 debug_nothing_rtx
, /* label */
422 dbxout_handle_pch
, /* handle_pch */
423 debug_nothing_rtx
/* var_location */
425 #endif /* DBX_DEBUGGING_INFO */
427 #if defined (XCOFF_DEBUGGING_INFO)
428 const struct gcc_debug_hooks xcoff_debug_hooks
=
432 debug_nothing_int_charstar
,
433 debug_nothing_int_charstar
,
434 dbxout_start_source_file
,
435 dbxout_end_source_file
,
436 xcoffout_begin_block
,
438 debug_true_tree
, /* ignore_block */
439 xcoffout_source_line
,
440 xcoffout_begin_prologue
, /* begin_prologue */
441 debug_nothing_int_charstar
, /* end_prologue */
442 xcoffout_end_epilogue
,
443 debug_nothing_tree
, /* begin_function */
444 xcoffout_end_function
,
445 debug_nothing_tree
, /* function_decl */
446 dbxout_global_decl
, /* global_decl */
447 dbxout_type_decl
, /* type_decl */
448 debug_nothing_tree_tree
, /* imported_module_or_decl */
449 debug_nothing_tree
, /* deferred_inline_function */
450 debug_nothing_tree
, /* outlining_inline_function */
451 debug_nothing_rtx
, /* label */
452 dbxout_handle_pch
, /* handle_pch */
453 debug_nothing_rtx
/* var_location */
455 #endif /* XCOFF_DEBUGGING_INFO */
457 #if defined (DBX_DEBUGGING_INFO)
459 dbxout_function_end (void)
461 char lscope_label_name
[100];
463 /* The Lscope label must be emitted even if we aren't doing anything
464 else; dbxout_block needs it. */
465 function_section (current_function_decl
);
467 /* Convert Ltext into the appropriate format for local labels in case
468 the system doesn't insert underscores in front of user generated
470 ASM_GENERATE_INTERNAL_LABEL (lscope_label_name
, "Lscope", scope_labelno
);
471 targetm
.asm_out
.internal_label (asmfile
, "Lscope", scope_labelno
);
474 /* The N_FUN tag at the end of the function is a GNU extension,
475 which may be undesirable, and is unnecessary if we do not have
477 if (!use_gnu_debug_info_extensions
478 || NO_DBX_FUNCTION_END
479 || !targetm
.have_named_sections
)
482 /* By convention, GCC will mark the end of a function with an N_FUN
483 symbol and an empty string. */
484 #ifdef DBX_OUTPUT_NFUN
485 DBX_OUTPUT_NFUN (asmfile
, lscope_label_name
, current_function_decl
);
487 fprintf (asmfile
, "%s\"\",%d,0,0,", ASM_STABS_OP
, N_FUN
);
488 assemble_name (asmfile
, lscope_label_name
);
490 assemble_name (asmfile
, XSTR (XEXP (DECL_RTL (current_function_decl
), 0), 0));
491 fprintf (asmfile
, "\n");
494 if (!NO_DBX_BNSYM_ENSYM
&& !flag_debug_only_used_symbols
)
495 fprintf (asmfile
, "%s%d,0,0\n", ASM_STABD_OP
, N_ENSYM
);
497 #endif /* DBX_DEBUGGING_INFO */
499 #ifndef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
500 /* Get lang description for N_SO stab. */
503 get_lang_number (void)
505 const char *language_string
= lang_hooks
.name
;
507 if (strcmp (language_string
, "GNU C") == 0)
509 else if (strcmp (language_string
, "GNU C++") == 0)
511 else if (strcmp (language_string
, "GNU F77") == 0)
513 else if (strcmp (language_string
, "GNU F95") == 0)
514 return N_SO_FORTRAN90
; /* CHECKME */
515 else if (strcmp (language_string
, "GNU Pascal") == 0)
517 else if (strcmp (language_string
, "GNU Objective-C") == 0)
525 /* At the beginning of compilation, start writing the symbol table.
526 Initialize `typevec' and output the standard data types of C. */
529 dbxout_init (const char *input_file_name
)
531 char ltext_label_name
[100];
532 tree syms
= lang_hooks
.decls
.getdecls ();
534 asmfile
= asm_out_file
;
537 typevec
= ggc_calloc (typevec_len
, sizeof typevec
[0]);
539 /* Convert Ltext into the appropriate format for local labels in case
540 the system doesn't insert underscores in front of user generated
542 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name
, "Ltext", 0);
544 /* Put the current working directory in an N_SO symbol. */
545 if (use_gnu_debug_info_extensions
)
547 if (!cwd
&& (cwd
= get_src_pwd ())
548 && (!*cwd
|| cwd
[strlen (cwd
) - 1] != '/'))
549 cwd
= concat (cwd
, FILE_NAME_JOINER
, NULL
);
552 #ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
553 DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asmfile
, cwd
);
554 #else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
555 fprintf (asmfile
, "%s", ASM_STABS_OP
);
556 output_quoted_string (asmfile
, cwd
);
557 fprintf (asmfile
, ",%d,0,%d,", N_SO
, get_lang_number ());
558 assemble_name (asmfile
, ltext_label_name
);
559 fputc ('\n', asmfile
);
560 #endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
564 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
565 DBX_OUTPUT_MAIN_SOURCE_FILENAME (asmfile
, input_file_name
);
566 #else /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
567 /* We include outputting `Ltext:' here,
568 because that gives you a way to override it. */
569 /* Used to put `Ltext:' before the reference, but that loses on sun 4. */
570 fprintf (asmfile
, "%s", ASM_STABS_OP
);
571 output_quoted_string (asmfile
, input_file_name
);
572 fprintf (asmfile
, ",%d,0,%d,", N_SO
, get_lang_number ());
573 assemble_name (asmfile
, ltext_label_name
);
574 fputc ('\n', asmfile
);
576 targetm
.asm_out
.internal_label (asmfile
, "Ltext", 0);
577 #endif /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
579 #ifdef DBX_OUTPUT_GCC_MARKER
580 DBX_OUTPUT_GCC_MARKER (asmfile
);
582 /* Emit an N_OPT stab to indicate that this file was compiled by GCC. */
583 fprintf (asmfile
, "%s\"%s\",%d,0,0,0\n",
584 ASM_STABS_OP
, STABS_GCC_MARKER
, N_OPT
);
587 base_input_file
= lastfile
= input_file_name
;
589 next_type_number
= 1;
592 current_file
= xmalloc (sizeof *current_file
);
593 current_file
->next
= NULL
;
594 current_file
->file_number
= 0;
595 current_file
->next_type_number
= 1;
596 next_file_number
= 1;
597 current_file
->prev
= NULL
;
598 current_file
->bincl_status
= BINCL_NOT_REQUIRED
;
599 current_file
->pending_bincl_name
= NULL
;
602 /* Get all permanent types that have typedef names, and output them
603 all, except for those already output. Some language front ends
604 put these declarations in the top-level scope; some do not;
605 the latter are responsible for calling debug_hooks->type_decl from
606 their record_builtin_type function. */
607 dbxout_typedefs (syms
);
612 for (t
= nreverse (preinit_symbols
); t
; t
= TREE_CHAIN (t
))
613 dbxout_symbol (TREE_VALUE (t
), 0);
618 /* Output any typedef names for types described by TYPE_DECLs in SYMS. */
621 dbxout_typedefs (tree syms
)
623 for (; syms
!= NULL_TREE
; syms
= TREE_CHAIN (syms
))
625 if (TREE_CODE (syms
) == TYPE_DECL
)
627 tree type
= TREE_TYPE (syms
);
629 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
630 && COMPLETE_OR_VOID_TYPE_P (type
)
631 && ! TREE_ASM_WRITTEN (TYPE_NAME (type
)))
632 dbxout_symbol (TYPE_NAME (type
), 0);
638 /* Emit BINCL stab using given name. */
640 emit_bincl_stab (const char *name
)
642 fprintf (asmfile
, "%s", ASM_STABS_OP
);
643 output_quoted_string (asmfile
, name
);
644 fprintf (asmfile
, ",%d,0,0,0\n", N_BINCL
);
647 /* If there are pending bincls then it is time to emit all of them. */
650 emit_pending_bincls_if_required (void)
653 emit_pending_bincls ();
656 /* Emit all pending bincls. */
659 emit_pending_bincls (void)
661 struct dbx_file
*f
= current_file
;
663 /* Find first pending bincl. */
664 while (f
->bincl_status
== BINCL_PENDING
)
667 /* Now emit all bincls. */
672 if (f
->bincl_status
== BINCL_PENDING
)
674 emit_bincl_stab (f
->pending_bincl_name
);
676 /* Update file number and status. */
677 f
->file_number
= next_file_number
++;
678 f
->bincl_status
= BINCL_PROCESSED
;
680 if (f
== current_file
)
685 /* All pending bincls have been emitted. */
692 emit_pending_bincls_if_required (void) {}
695 /* Change to reading from a new source file. Generate a N_BINCL stab. */
698 dbxout_start_source_file (unsigned int line ATTRIBUTE_UNUSED
,
699 const char *filename ATTRIBUTE_UNUSED
)
702 struct dbx_file
*n
= xmalloc (sizeof *n
);
704 n
->next
= current_file
;
705 n
->next_type_number
= 1;
706 /* Do not assign file number now.
707 Delay it until we actually emit BINCL. */
710 current_file
->prev
= n
;
711 n
->bincl_status
= BINCL_PENDING
;
712 n
->pending_bincl_name
= filename
;
718 /* Revert to reading a previous source file. Generate a N_EINCL stab. */
721 dbxout_end_source_file (unsigned int line ATTRIBUTE_UNUSED
)
724 /* Emit EINCL stab only if BINCL is not pending. */
725 if (current_file
->bincl_status
== BINCL_PROCESSED
)
726 fprintf (asmfile
, "%s%d,0,0,0\n", ASM_STABN_OP
, N_EINCL
);
727 current_file
->bincl_status
= BINCL_NOT_REQUIRED
;
728 current_file
= current_file
->next
;
732 /* Handle a few odd cases that occur when trying to make PCH files work. */
735 dbxout_handle_pch (unsigned at_end
)
739 /* When using the PCH, this file will be included, so we need to output
741 dbxout_start_source_file (0, lastfile
);
743 /* The base file when using the PCH won't be the same as
744 the base file when it's being generated. */
749 /* ... and an EINCL. */
750 dbxout_end_source_file (0);
752 /* Deal with cases where 'lastfile' was never actually changed. */
753 lastfile_is_base
= lastfile
== NULL
;
757 #if defined (DBX_DEBUGGING_INFO)
758 /* Output debugging info to FILE to switch to sourcefile FILENAME. */
761 dbxout_source_file (FILE *file
, const char *filename
)
763 if (lastfile
== 0 && lastfile_is_base
)
765 lastfile
= base_input_file
;
766 lastfile_is_base
= 0;
769 if (filename
&& (lastfile
== 0 || strcmp (filename
, lastfile
)))
771 char ltext_label_name
[100];
773 ASM_GENERATE_INTERNAL_LABEL (ltext_label_name
, "Ltext",
774 source_label_number
);
775 fprintf (file
, "%s", ASM_STABS_OP
);
776 output_quoted_string (file
, filename
);
777 fprintf (asmfile
, ",%d,0,0,", N_SOL
);
778 assemble_name (asmfile
, ltext_label_name
);
779 fputc ('\n', asmfile
);
780 if (current_function_decl
!= NULL_TREE
781 && DECL_SECTION_NAME (current_function_decl
) != NULL_TREE
)
782 ; /* Don't change section amid function. */
785 if (!in_text_section () && !in_unlikely_text_section ())
788 targetm
.asm_out
.internal_label (file
, "Ltext", source_label_number
);
789 source_label_number
++;
794 /* Output N_BNSYM and line number symbol entry. */
797 dbxout_begin_prologue (unsigned int lineno
, const char *filename
)
799 if (use_gnu_debug_info_extensions
800 && !NO_DBX_FUNCTION_END
801 && !NO_DBX_BNSYM_ENSYM
802 && !flag_debug_only_used_symbols
)
803 fprintf (asmfile
, "%s%d,0,0\n", ASM_STABD_OP
, N_BNSYM
);
805 dbxout_source_line (lineno
, filename
);
808 /* Output a line number symbol entry for source file FILENAME and line
812 dbxout_source_line (unsigned int lineno
, const char *filename
)
814 dbxout_source_file (asmfile
, filename
);
816 #ifdef ASM_OUTPUT_SOURCE_LINE
817 dbxout_source_line_counter
+= 1;
818 ASM_OUTPUT_SOURCE_LINE (asmfile
, lineno
, dbxout_source_line_counter
);
820 fprintf (asmfile
, "%s%d,0,%d\n", ASM_STABD_OP
, N_SLINE
, lineno
);
824 /* Describe the beginning of an internal block within a function. */
827 dbxout_begin_block (unsigned int line ATTRIBUTE_UNUSED
, unsigned int n
)
829 emit_pending_bincls_if_required ();
830 targetm
.asm_out
.internal_label (asmfile
, "LBB", n
);
833 /* Describe the end line-number of an internal block within a function. */
836 dbxout_end_block (unsigned int line ATTRIBUTE_UNUSED
, unsigned int n
)
838 emit_pending_bincls_if_required ();
839 targetm
.asm_out
.internal_label (asmfile
, "LBE", n
);
842 /* Output dbx data for a function definition.
843 This includes a definition of the function name itself (a symbol),
844 definitions of the parameters (locating them in the parameter list)
845 and then output the block that makes up the function's body
846 (including all the auto variables of the function). */
849 dbxout_function_decl (tree decl
)
851 emit_pending_bincls_if_required ();
852 #ifndef DBX_FUNCTION_FIRST
853 dbxout_begin_function (decl
);
855 dbxout_block (DECL_INITIAL (decl
), 0, DECL_ARGUMENTS (decl
));
856 #ifdef DBX_OUTPUT_FUNCTION_END
857 DBX_OUTPUT_FUNCTION_END (asmfile
, decl
);
859 dbxout_function_end ();
862 #endif /* DBX_DEBUGGING_INFO */
864 /* Debug information for a global DECL. Called from toplev.c after
865 compilation proper has finished. */
867 dbxout_global_decl (tree decl
)
869 if (TREE_CODE (decl
) == VAR_DECL
870 && ! DECL_EXTERNAL (decl
)
871 && DECL_RTL_SET_P (decl
)) /* Not necessary? */
873 int saved_tree_used
= TREE_USED (decl
);
874 TREE_USED (decl
) = 1;
875 dbxout_symbol (decl
, 0);
876 TREE_USED (decl
) = saved_tree_used
;
880 /* This is just a function-type adapter; dbxout_symbol does exactly
881 what we want but returns an int. */
883 dbxout_type_decl (tree decl
, int local
)
885 dbxout_symbol (decl
, local
);
888 /* At the end of compilation, finish writing the symbol table.
889 Unless you define DBX_OUTPUT_MAIN_SOURCE_FILE_END, the default is
893 dbxout_finish (const char *filename ATTRIBUTE_UNUSED
)
895 #ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
896 DBX_OUTPUT_MAIN_SOURCE_FILE_END (asmfile
, filename
);
897 #endif /* DBX_OUTPUT_MAIN_SOURCE_FILE_END */
902 /* Output the index of a type. */
905 dbxout_type_index (tree type
)
907 #ifndef DBX_USE_BINCL
908 fprintf (asmfile
, "%d", TYPE_SYMTAB_ADDRESS (type
));
911 struct typeinfo
*t
= &typevec
[TYPE_SYMTAB_ADDRESS (type
)];
912 fprintf (asmfile
, "(%d,%d)", t
->file_number
, t
->type_number
);
917 #if DBX_CONTIN_LENGTH > 0
918 /* Continue a symbol-description that gets too big.
919 End one symbol table entry with a double-backslash
920 and start a new one, eventually producing something like
921 .stabs "start......\\",code,0,value
922 .stabs "...rest",code,0,value */
925 dbxout_continue (void)
927 emit_pending_bincls_if_required ();
928 #ifdef DBX_CONTIN_CHAR
929 fprintf (asmfile
, "%c", DBX_CONTIN_CHAR
);
931 fprintf (asmfile
, "\\\\");
933 dbxout_finish_symbol (NULL_TREE
);
934 fprintf (asmfile
, "%s\"", ASM_STABS_OP
);
935 current_sym_nchars
= 0;
937 #endif /* DBX_CONTIN_LENGTH > 0 */
939 /* Subroutine of `dbxout_type'. Output the type fields of TYPE.
940 This must be a separate function because anonymous unions require
944 dbxout_type_fields (tree type
)
948 /* Output the name, type, position (in bits), size (in bits) of each
949 field that we can support. */
950 for (tem
= TYPE_FIELDS (type
); tem
; tem
= TREE_CHAIN (tem
))
952 /* If one of the nodes is an error_mark or its type is then
954 if (tem
== error_mark_node
|| TREE_TYPE (tem
) == error_mark_node
)
957 /* Omit here local type decls until we know how to support them. */
958 if (TREE_CODE (tem
) == TYPE_DECL
959 /* Omit fields whose position or size are variable or too large to
961 || (TREE_CODE (tem
) == FIELD_DECL
962 && (! host_integerp (bit_position (tem
), 0)
964 || ! host_integerp (DECL_SIZE (tem
), 1)))
965 /* Omit here the nameless fields that are used to skip bits. */
966 || DECL_IGNORED_P (tem
))
969 else if (TREE_CODE (tem
) != CONST_DECL
)
971 /* Continue the line if necessary,
972 but not before the first field. */
973 if (tem
!= TYPE_FIELDS (type
))
978 fprintf (asmfile
, "%s:", IDENTIFIER_POINTER (DECL_NAME (tem
)));
979 CHARS (2 + IDENTIFIER_LENGTH (DECL_NAME (tem
)));
983 fprintf (asmfile
, ":");
987 if (use_gnu_debug_info_extensions
988 && (TREE_PRIVATE (tem
) || TREE_PROTECTED (tem
)
989 || TREE_CODE (tem
) != FIELD_DECL
))
991 have_used_extensions
= 1;
993 putc ((TREE_PRIVATE (tem
) ? '0'
994 : TREE_PROTECTED (tem
) ? '1' : '2'),
999 dbxout_type ((TREE_CODE (tem
) == FIELD_DECL
1000 && DECL_BIT_FIELD_TYPE (tem
))
1001 ? DECL_BIT_FIELD_TYPE (tem
) : TREE_TYPE (tem
), 0);
1003 if (TREE_CODE (tem
) == VAR_DECL
)
1005 if (TREE_STATIC (tem
) && use_gnu_debug_info_extensions
)
1007 tree name
= DECL_ASSEMBLER_NAME (tem
);
1009 have_used_extensions
= 1;
1010 fprintf (asmfile
, ":%s;", IDENTIFIER_POINTER (name
));
1011 CHARS (IDENTIFIER_LENGTH (name
) + 2);
1015 /* If TEM is non-static, GDB won't understand it. */
1016 fprintf (asmfile
, ",0,0;");
1022 putc (',', asmfile
);
1023 print_wide_int (int_bit_position (tem
));
1024 putc (',', asmfile
);
1025 print_wide_int (tree_low_cst (DECL_SIZE (tem
), 1));
1026 putc (';', asmfile
);
1033 /* Subroutine of `dbxout_type_methods'. Output debug info about the
1034 method described DECL. DEBUG_NAME is an encoding of the method's
1035 type signature. ??? We may be able to do without DEBUG_NAME altogether
1039 dbxout_type_method_1 (tree decl
, const char *debug_name
)
1043 if (TREE_CODE (TREE_TYPE (decl
)) == FUNCTION_TYPE
)
1045 else /* it's a METHOD_TYPE. */
1047 tree firstarg
= TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl
)));
1048 /* A for normal functions.
1049 B for `const' member functions.
1050 C for `volatile' member functions.
1051 D for `const volatile' member functions. */
1052 if (TYPE_READONLY (TREE_TYPE (firstarg
)))
1054 if (TYPE_VOLATILE (TREE_TYPE (firstarg
)))
1057 if (DECL_VINDEX (decl
))
1063 fprintf (asmfile
, ":%s;%c%c%c", debug_name
,
1064 TREE_PRIVATE (decl
) ? '0'
1065 : TREE_PROTECTED (decl
) ? '1' : '2', c1
, c2
);
1066 CHARS (IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (decl
)) + 6
1067 - (debug_name
- IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
))));
1069 if (DECL_VINDEX (decl
) && host_integerp (DECL_VINDEX (decl
), 0))
1071 print_wide_int (tree_low_cst (DECL_VINDEX (decl
), 0));
1072 putc (';', asmfile
);
1074 dbxout_type (DECL_CONTEXT (decl
), 0);
1075 fprintf (asmfile
, ";");
1080 /* Subroutine of `dbxout_type'. Output debug info about the methods defined
1084 dbxout_type_methods (tree type
)
1086 /* C++: put out the method names and their parameter lists */
1087 tree methods
= TYPE_METHODS (type
);
1091 char formatted_type_identifier_length
[16];
1092 int type_identifier_length
;
1094 if (methods
== NULL_TREE
)
1097 type_encoding
= DECL_NAME (TYPE_NAME (type
));
1100 /* C++: Template classes break some assumptions made by this code about
1101 the class names, constructor names, and encodings for assembler
1102 label names. For now, disable output of dbx info for them. */
1104 const char *ptr
= IDENTIFIER_POINTER (type_encoding
);
1105 /* This should use index. (mrs) */
1106 while (*ptr
&& *ptr
!= '<') ptr
++;
1117 type_identifier_length
= IDENTIFIER_LENGTH (type_encoding
);
1119 sprintf (formatted_type_identifier_length
, "%d", type_identifier_length
);
1121 if (TREE_CODE (methods
) != TREE_VEC
)
1123 else if (TREE_VEC_ELT (methods
, 0) != NULL_TREE
)
1124 fndecl
= TREE_VEC_ELT (methods
, 0);
1126 fndecl
= TREE_VEC_ELT (methods
, 1);
1130 int need_prefix
= 1;
1132 /* Group together all the methods for the same operation.
1133 These differ in the types of the arguments. */
1134 for (last
= NULL_TREE
;
1135 fndecl
&& (last
== NULL_TREE
|| DECL_NAME (fndecl
) == DECL_NAME (last
));
1136 fndecl
= TREE_CHAIN (fndecl
))
1137 /* Output the name of the field (after overloading), as
1138 well as the name of the field before overloading, along
1139 with its parameter list */
1141 /* This is the "mangled" name of the method.
1142 It encodes the argument types. */
1143 const char *debug_name
;
1145 /* Skip methods that aren't FUNCTION_DECLs. (In C++, these
1146 include TEMPLATE_DECLs.) The debugger doesn't know what
1147 to do with such entities anyhow. */
1148 if (TREE_CODE (fndecl
) != FUNCTION_DECL
)
1151 debug_name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl
));
1157 /* Also ignore abstract methods; those are only interesting to
1158 the DWARF backends. */
1159 if (DECL_IGNORED_P (fndecl
) || DECL_ABSTRACT (fndecl
))
1162 /* Redundantly output the plain name, since that's what gdb
1166 tree name
= DECL_NAME (fndecl
);
1167 fprintf (asmfile
, "%s::", IDENTIFIER_POINTER (name
));
1168 CHARS (IDENTIFIER_LENGTH (name
) + 2);
1172 dbxout_type (TREE_TYPE (fndecl
), 0);
1174 dbxout_type_method_1 (fndecl
, debug_name
);
1178 putc (';', asmfile
);
1184 /* Emit a "range" type specification, which has the form:
1185 "r<index type>;<lower bound>;<upper bound>;".
1186 TYPE is an INTEGER_TYPE. */
1189 dbxout_range_type (tree type
)
1191 fprintf (asmfile
, "r");
1192 if (TREE_TYPE (type
))
1193 dbxout_type (TREE_TYPE (type
), 0);
1194 else if (TREE_CODE (type
) != INTEGER_TYPE
)
1195 dbxout_type (type
, 0); /* E.g. Pascal's ARRAY [BOOLEAN] of INTEGER */
1198 /* Traditionally, we made sure 'int' was type 1, and builtin types
1199 were defined to be sub-ranges of int. Unfortunately, this
1200 does not allow us to distinguish true sub-ranges from integer
1201 types. So, instead we define integer (non-sub-range) types as
1202 sub-ranges of themselves. This matters for Chill. If this isn't
1203 a subrange type, then we want to define it in terms of itself.
1204 However, in C, this may be an anonymous integer type, and we don't
1205 want to emit debug info referring to it. Just calling
1206 dbxout_type_index won't work anyways, because the type hasn't been
1207 defined yet. We make this work for both cases by checked to see
1208 whether this is a defined type, referring to it if it is, and using
1210 if (TYPE_SYMTAB_ADDRESS (type
) != 0)
1211 dbxout_type_index (type
);
1213 dbxout_type_index (integer_type_node
);
1216 if (TYPE_MIN_VALUE (type
) != 0
1217 && host_integerp (TYPE_MIN_VALUE (type
), 0))
1219 putc (';', asmfile
);
1221 if (print_int_cst_bounds_in_octal_p (type
))
1222 print_int_cst_octal (TYPE_MIN_VALUE (type
));
1224 print_wide_int (tree_low_cst (TYPE_MIN_VALUE (type
), 0));
1228 fprintf (asmfile
, ";0");
1232 if (TYPE_MAX_VALUE (type
) != 0
1233 && host_integerp (TYPE_MAX_VALUE (type
), 0))
1235 putc (';', asmfile
);
1237 if (print_int_cst_bounds_in_octal_p (type
))
1238 print_int_cst_octal (TYPE_MAX_VALUE (type
));
1240 print_wide_int (tree_low_cst (TYPE_MAX_VALUE (type
), 0));
1241 putc (';', asmfile
);
1246 fprintf (asmfile
, ";-1;");
1252 /* Output a reference to a type. If the type has not yet been
1253 described in the dbx output, output its definition now.
1254 For a type already defined, just refer to its definition
1255 using the type number.
1257 If FULL is nonzero, and the type has been described only with
1258 a forward-reference, output the definition now.
1259 If FULL is zero in this case, just refer to the forward-reference
1260 using the number previously allocated. */
1263 dbxout_type (tree type
, int full
)
1267 static int anonymous_type_number
= 0;
1269 if (TREE_CODE (type
) == VECTOR_TYPE
)
1270 /* The frontend feeds us a representation for the vector as a struct
1271 containing an array. Pull out the array type. */
1272 type
= TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type
)));
1274 /* If there was an input error and we don't really have a type,
1275 avoid crashing and write something that is at least valid
1276 by assuming `int'. */
1277 if (type
== error_mark_node
)
1278 type
= integer_type_node
;
1281 if (TYPE_NAME (type
)
1282 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1283 && TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type
)))
1287 /* Try to find the "main variant" with the same name. */
1288 if (TYPE_NAME (type
) && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1289 && DECL_ORIGINAL_TYPE (TYPE_NAME (type
)))
1290 main_variant
= TREE_TYPE (TYPE_NAME (type
));
1292 main_variant
= TYPE_MAIN_VARIANT (type
);
1294 /* If we are not using extensions, stabs does not distinguish const and
1295 volatile, so there is no need to make them separate types. */
1296 if (!use_gnu_debug_info_extensions
)
1297 type
= main_variant
;
1299 if (TYPE_SYMTAB_ADDRESS (type
) == 0)
1301 /* Type has no dbx number assigned. Assign next available number. */
1302 TYPE_SYMTAB_ADDRESS (type
) = next_type_number
++;
1304 /* Make sure type vector is long enough to record about this type. */
1306 if (next_type_number
== typevec_len
)
1309 = ggc_realloc (typevec
, (typevec_len
* 2 * sizeof typevec
[0]));
1310 memset (typevec
+ typevec_len
, 0, typevec_len
* sizeof typevec
[0]);
1314 #ifdef DBX_USE_BINCL
1315 emit_pending_bincls_if_required ();
1316 typevec
[TYPE_SYMTAB_ADDRESS (type
)].file_number
1317 = current_file
->file_number
;
1318 typevec
[TYPE_SYMTAB_ADDRESS (type
)].type_number
1319 = current_file
->next_type_number
++;
1323 if (flag_debug_only_used_symbols
)
1325 if ((TREE_CODE (type
) == RECORD_TYPE
1326 || TREE_CODE (type
) == UNION_TYPE
1327 || TREE_CODE (type
) == QUAL_UNION_TYPE
1328 || TREE_CODE (type
) == ENUMERAL_TYPE
)
1329 && TYPE_STUB_DECL (type
)
1330 && DECL_P (TYPE_STUB_DECL (type
))
1331 && ! DECL_IGNORED_P (TYPE_STUB_DECL (type
)))
1332 debug_queue_symbol (TYPE_STUB_DECL (type
));
1333 else if (TYPE_NAME (type
)
1334 && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
)
1335 debug_queue_symbol (TYPE_NAME (type
));
1338 /* Output the number of this type, to refer to it. */
1339 dbxout_type_index (type
);
1341 #ifdef DBX_TYPE_DEFINED
1342 if (DBX_TYPE_DEFINED (type
))
1346 /* If this type's definition has been output or is now being output,
1349 switch (typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
)
1354 /* If we have already had a cross reference,
1355 and either that's all we want or that's the best we could do,
1356 don't repeat the cross reference.
1357 Sun dbx crashes if we do. */
1358 if (! full
|| !COMPLETE_TYPE_P (type
)
1359 /* No way in DBX fmt to describe a variable size. */
1360 || ! host_integerp (TYPE_SIZE (type
), 1))
1368 /* For systems where dbx output does not allow the `=xsNAME:' syntax,
1369 leave the type-number completely undefined rather than output
1370 a cross-reference. If we have already used GNU debug info extensions,
1371 then it is OK to output a cross reference. This is necessary to get
1372 proper C++ debug output. */
1373 if ((TREE_CODE (type
) == RECORD_TYPE
|| TREE_CODE (type
) == UNION_TYPE
1374 || TREE_CODE (type
) == QUAL_UNION_TYPE
1375 || TREE_CODE (type
) == ENUMERAL_TYPE
)
1376 && ! use_gnu_debug_info_extensions
)
1377 /* We must use the same test here as we use twice below when deciding
1378 whether to emit a cross-reference. */
1379 if ((TYPE_NAME (type
) != 0
1380 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1381 && DECL_IGNORED_P (TYPE_NAME (type
)))
1383 || !COMPLETE_TYPE_P (type
)
1384 /* No way in DBX fmt to describe a variable size. */
1385 || ! host_integerp (TYPE_SIZE (type
), 1))
1387 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1392 /* Output a definition now. */
1394 fprintf (asmfile
, "=");
1397 /* Mark it as defined, so that if it is self-referent
1398 we will not get into an infinite recursion of definitions. */
1400 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_DEFINED
;
1402 /* If this type is a variant of some other, hand off. Types with
1403 different names are usefully distinguished. We only distinguish
1404 cv-qualified types if we're using extensions. */
1405 if (TYPE_READONLY (type
) > TYPE_READONLY (main_variant
))
1407 putc ('k', asmfile
);
1409 dbxout_type (build_type_variant (type
, 0, TYPE_VOLATILE (type
)), 0);
1412 else if (TYPE_VOLATILE (type
) > TYPE_VOLATILE (main_variant
))
1414 putc ('B', asmfile
);
1416 dbxout_type (build_type_variant (type
, TYPE_READONLY (type
), 0), 0);
1419 else if (main_variant
!= TYPE_MAIN_VARIANT (type
))
1421 if (flag_debug_only_used_symbols
)
1423 tree orig_type
= DECL_ORIGINAL_TYPE (TYPE_NAME (type
));
1425 if ((TREE_CODE (orig_type
) == RECORD_TYPE
1426 || TREE_CODE (orig_type
) == UNION_TYPE
1427 || TREE_CODE (orig_type
) == QUAL_UNION_TYPE
1428 || TREE_CODE (orig_type
) == ENUMERAL_TYPE
)
1429 && TYPE_STUB_DECL (orig_type
)
1430 && ! DECL_IGNORED_P (TYPE_STUB_DECL (orig_type
)))
1431 debug_queue_symbol (TYPE_STUB_DECL (orig_type
));
1433 /* 'type' is a typedef; output the type it refers to. */
1434 dbxout_type (DECL_ORIGINAL_TYPE (TYPE_NAME (type
)), 0);
1437 /* else continue. */
1439 switch (TREE_CODE (type
))
1443 /* For a void type, just define it as itself; i.e., "5=5".
1444 This makes us consider it defined
1445 without saying what it is. The debugger will make it
1446 a void type when the reference is seen, and nothing will
1447 ever override that default. */
1448 dbxout_type_index (type
);
1452 if (type
== char_type_node
&& ! TYPE_UNSIGNED (type
))
1454 /* Output the type `char' as a subrange of itself!
1455 I don't understand this definition, just copied it
1456 from the output of pcc.
1457 This used to use `r2' explicitly and we used to
1458 take care to make sure that `char' was type number 2. */
1459 fprintf (asmfile
, "r");
1461 dbxout_type_index (type
);
1462 fprintf (asmfile
, ";0;127;");
1466 /* If this is a subtype of another integer type, always prefer to
1467 write it as a subtype. */
1468 else if (TREE_TYPE (type
) != 0
1469 && TREE_CODE (TREE_TYPE (type
)) == INTEGER_TYPE
)
1471 /* If the size is non-standard, say what it is if we can use
1474 if (use_gnu_debug_info_extensions
1475 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
1477 have_used_extensions
= 1;
1478 fprintf (asmfile
, "@s%d;", TYPE_PRECISION (type
));
1482 dbxout_range_type (type
);
1487 /* If the size is non-standard, say what it is if we can use
1490 if (use_gnu_debug_info_extensions
1491 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
1493 have_used_extensions
= 1;
1494 fprintf (asmfile
, "@s%d;", TYPE_PRECISION (type
));
1498 if (print_int_cst_bounds_in_octal_p (type
))
1500 fprintf (asmfile
, "r");
1503 /* If this type derives from another type, output type index of
1504 parent type. This is particularly important when parent type
1505 is an enumerated type, because not generating the parent type
1506 index would transform the definition of this enumerated type
1507 into a plain unsigned type. */
1508 if (TREE_TYPE (type
) != 0)
1509 dbxout_type_index (TREE_TYPE (type
));
1511 dbxout_type_index (type
);
1513 fprintf (asmfile
, ";");
1515 print_int_cst_octal (TYPE_MIN_VALUE (type
));
1516 fprintf (asmfile
, ";");
1518 print_int_cst_octal (TYPE_MAX_VALUE (type
));
1519 fprintf (asmfile
, ";");
1524 /* Output other integer types as subranges of `int'. */
1525 dbxout_range_type (type
);
1531 /* This used to say `r1' and we used to take care
1532 to make sure that `int' was type number 1. */
1533 fprintf (asmfile
, "r");
1535 dbxout_type_index (integer_type_node
);
1536 putc (';', asmfile
);
1538 print_wide_int (int_size_in_bytes (type
));
1539 fputs (";0;", asmfile
);
1544 if (use_gnu_debug_info_extensions
)
1546 have_used_extensions
= 1;
1547 fputs ("@s", asmfile
);
1549 print_wide_int (BITS_PER_UNIT
* int_size_in_bytes (type
));
1550 fputs (";-20;", asmfile
);
1555 /* Output the type `char' as a subrange of itself.
1556 That is what pcc seems to do. */
1557 fprintf (asmfile
, "r");
1559 dbxout_type_index (char_type_node
);
1560 fprintf (asmfile
, ";0;%d;", TYPE_UNSIGNED (type
) ? 255 : 127);
1566 if (use_gnu_debug_info_extensions
)
1568 have_used_extensions
= 1;
1569 fputs ("@s", asmfile
);
1571 print_wide_int (BITS_PER_UNIT
* int_size_in_bytes (type
));
1572 fputs (";-16;", asmfile
);
1575 else /* Define as enumeral type (False, True) */
1577 fprintf (asmfile
, "eFalse:0,True:1,;");
1583 putc ('d', asmfile
);
1585 dbxout_type (TREE_TYPE (type
), 0);
1589 /* Differs from the REAL_TYPE by its new data type number.
1590 R3 is NF_COMPLEX. We don't try to use any of the other NF_*
1591 codes since gdb doesn't care anyway. */
1593 if (TREE_CODE (TREE_TYPE (type
)) == REAL_TYPE
)
1595 fputs ("R3;", asmfile
);
1597 print_wide_int (2 * int_size_in_bytes (TREE_TYPE (type
)));
1598 fputs (";0;", asmfile
);
1603 /* Output a complex integer type as a structure,
1604 pending some other way to do it. */
1605 putc ('s', asmfile
);
1607 print_wide_int (int_size_in_bytes (type
));
1608 fprintf (asmfile
, "real:");
1611 dbxout_type (TREE_TYPE (type
), 0);
1612 fprintf (asmfile
, ",0,%d;", TYPE_PRECISION (TREE_TYPE (type
)));
1614 fprintf (asmfile
, "imag:");
1616 dbxout_type (TREE_TYPE (type
), 0);
1617 fprintf (asmfile
, ",%d,%d;;", TYPE_PRECISION (TREE_TYPE (type
)),
1618 TYPE_PRECISION (TREE_TYPE (type
)));
1624 if (use_gnu_debug_info_extensions
)
1626 have_used_extensions
= 1;
1627 fputs ("@s", asmfile
);
1629 print_wide_int (BITS_PER_UNIT
* int_size_in_bytes (type
));
1630 putc (';', asmfile
);
1633 /* Check if a bitstring type, which in Chill is
1634 different from a [power]set. */
1635 if (TYPE_STRING_FLAG (type
))
1637 fprintf (asmfile
, "@S;");
1641 putc ('S', asmfile
);
1643 dbxout_type (TYPE_DOMAIN (type
), 0);
1647 /* Make arrays of packed bits look like bitstrings for chill. */
1648 if (TYPE_PACKED (type
) && use_gnu_debug_info_extensions
)
1650 have_used_extensions
= 1;
1651 fputs ("@s", asmfile
);
1653 print_wide_int (BITS_PER_UNIT
* int_size_in_bytes (type
));
1654 fprintf (asmfile
, ";@S;S");
1656 dbxout_type (TYPE_DOMAIN (type
), 0);
1660 /* Output "a" followed by a range type definition
1661 for the index type of the array
1662 followed by a reference to the target-type.
1663 ar1;0;N;M for a C array of type M and size N+1. */
1664 /* Check if a character string type, which in Chill is
1665 different from an array of characters. */
1666 if (TYPE_STRING_FLAG (type
) && use_gnu_debug_info_extensions
)
1668 have_used_extensions
= 1;
1669 fprintf (asmfile
, "@S;");
1672 tem
= TYPE_DOMAIN (type
);
1675 fprintf (asmfile
, "ar");
1677 dbxout_type_index (integer_type_node
);
1678 fprintf (asmfile
, ";0;-1;");
1683 fprintf (asmfile
, "a");
1685 dbxout_range_type (tem
);
1688 dbxout_type (TREE_TYPE (type
), 0);
1693 case QUAL_UNION_TYPE
:
1695 tree binfo
= TYPE_BINFO (type
);
1697 /* Output a structure type. We must use the same test here as we
1698 use in the DBX_NO_XREFS case above. */
1699 if ((TYPE_NAME (type
) != 0
1700 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1701 && DECL_IGNORED_P (TYPE_NAME (type
)))
1703 || !COMPLETE_TYPE_P (type
)
1704 /* No way in DBX fmt to describe a variable size. */
1705 || ! host_integerp (TYPE_SIZE (type
), 1))
1707 /* If the type is just a cross reference, output one
1708 and mark the type as partially described.
1709 If it later becomes defined, we will output
1710 its real definition.
1711 If the type has a name, don't nest its definition within
1712 another type's definition; instead, output an xref
1713 and let the definition come when the name is defined. */
1714 fputs ((TREE_CODE (type
) == RECORD_TYPE
) ? "xs" : "xu", asmfile
);
1716 #if 0 /* This assertion is legitimately false in C++. */
1717 /* We shouldn't be outputting a reference to a type before its
1718 definition unless the type has a tag name.
1719 A typedef name without a tag name should be impossible. */
1720 gcc_assert (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
);
1722 if (TYPE_NAME (type
) != 0)
1723 dbxout_type_name (type
);
1726 fprintf (asmfile
, "$$%d", anonymous_type_number
++);
1730 fprintf (asmfile
, ":");
1732 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1736 /* Identify record or union, and print its size. */
1737 putc (((TREE_CODE (type
) == RECORD_TYPE
) ? 's' : 'u'), asmfile
);
1739 print_wide_int (int_size_in_bytes (type
));
1745 VEC (tree
) *accesses
= BINFO_BASE_ACCESSES (binfo
);
1747 if (use_gnu_debug_info_extensions
)
1749 if (BINFO_N_BASE_BINFOS (binfo
))
1751 have_used_extensions
= 1;
1752 fprintf (asmfile
, "!%u,", BINFO_N_BASE_BINFOS (binfo
));
1756 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, child
); i
++)
1758 tree access
= (accesses
? VEC_index (tree
, accesses
, i
)
1759 : access_public_node
);
1761 if (use_gnu_debug_info_extensions
)
1763 have_used_extensions
= 1;
1764 putc (BINFO_VIRTUAL_P (child
) ? '1' : '0', asmfile
);
1765 putc (access
== access_public_node
? '2' :
1766 (access
== access_protected_node
? '1' :'0'),
1769 if (BINFO_VIRTUAL_P (child
)
1770 && strcmp (lang_hooks
.name
, "GNU C++") == 0)
1771 /* For a virtual base, print the (negative)
1772 offset within the vtable where we must look
1773 to find the necessary adjustment. */
1775 (tree_low_cst (BINFO_VPTR_FIELD (child
), 0)
1778 print_wide_int (tree_low_cst (BINFO_OFFSET (child
), 0)
1780 putc (',', asmfile
);
1782 dbxout_type (BINFO_TYPE (child
), 0);
1783 putc (';', asmfile
);
1788 /* Print out the base class information with
1789 fields which have the same names at the types
1791 dbxout_type_name (BINFO_TYPE (child
));
1792 putc (':', asmfile
);
1794 dbxout_type (BINFO_TYPE (child
), full
);
1795 putc (',', asmfile
);
1797 print_wide_int (tree_low_cst (BINFO_OFFSET (child
), 0)
1799 putc (',', asmfile
);
1802 (tree_low_cst (TYPE_SIZE (BINFO_TYPE (child
)), 0)
1804 putc (';', asmfile
);
1811 /* Write out the field declarations. */
1812 dbxout_type_fields (type
);
1813 if (use_gnu_debug_info_extensions
&& TYPE_METHODS (type
) != NULL_TREE
)
1815 have_used_extensions
= 1;
1816 dbxout_type_methods (type
);
1819 putc (';', asmfile
);
1822 if (use_gnu_debug_info_extensions
&& TREE_CODE (type
) == RECORD_TYPE
1823 /* Avoid the ~ if we don't really need it--it confuses dbx. */
1824 && TYPE_VFIELD (type
))
1826 have_used_extensions
= 1;
1828 /* Tell GDB+ that it may keep reading. */
1829 putc ('~', asmfile
);
1832 /* We need to write out info about what field this class
1833 uses as its "main" vtable pointer field, because if this
1834 field is inherited from a base class, GDB cannot necessarily
1835 figure out which field it's using in time. */
1836 if (TYPE_VFIELD (type
))
1838 putc ('%', asmfile
);
1840 dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type
)), 0);
1843 putc (';', asmfile
);
1849 /* We must use the same test here as we use in the DBX_NO_XREFS case
1850 above. We simplify it a bit since an enum will never have a variable
1852 if ((TYPE_NAME (type
) != 0
1853 && ! (TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
1854 && DECL_IGNORED_P (TYPE_NAME (type
)))
1856 || !COMPLETE_TYPE_P (type
))
1858 fprintf (asmfile
, "xe");
1860 dbxout_type_name (type
);
1861 typevec
[TYPE_SYMTAB_ADDRESS (type
)].status
= TYPE_XREF
;
1862 putc (':', asmfile
);
1866 if (use_gnu_debug_info_extensions
1867 && TYPE_PRECISION (type
) != TYPE_PRECISION (integer_type_node
))
1869 fprintf (asmfile
, "@s%d;", TYPE_PRECISION (type
));
1873 putc ('e', asmfile
);
1875 for (tem
= TYPE_VALUES (type
); tem
; tem
= TREE_CHAIN (tem
))
1877 fprintf (asmfile
, "%s:", IDENTIFIER_POINTER (TREE_PURPOSE (tem
)));
1878 CHARS (IDENTIFIER_LENGTH (TREE_PURPOSE (tem
)) + 1);
1879 if (TREE_INT_CST_HIGH (TREE_VALUE (tem
)) == 0)
1880 print_wide_int (TREE_INT_CST_LOW (TREE_VALUE (tem
)));
1881 else if (TREE_INT_CST_HIGH (TREE_VALUE (tem
)) == -1
1882 && (HOST_WIDE_INT
) TREE_INT_CST_LOW (TREE_VALUE (tem
)) < 0)
1883 print_wide_int (TREE_INT_CST_LOW (TREE_VALUE (tem
)));
1885 print_int_cst_octal (TREE_VALUE (tem
));
1887 putc (',', asmfile
);
1889 if (TREE_CHAIN (tem
) != 0)
1893 putc (';', asmfile
);
1898 putc ('*', asmfile
);
1900 dbxout_type (TREE_TYPE (type
), 0);
1904 if (use_gnu_debug_info_extensions
)
1906 have_used_extensions
= 1;
1907 putc ('#', asmfile
);
1910 /* Write the argument types out longhand. */
1911 dbxout_type (TYPE_METHOD_BASETYPE (type
), 0);
1912 putc (',', asmfile
);
1914 dbxout_type (TREE_TYPE (type
), 0);
1915 dbxout_args (TYPE_ARG_TYPES (type
));
1916 putc (';', asmfile
);
1920 /* Treat it as a function type. */
1921 dbxout_type (TREE_TYPE (type
), 0);
1925 if (use_gnu_debug_info_extensions
)
1927 have_used_extensions
= 1;
1928 putc ('@', asmfile
);
1930 dbxout_type (TYPE_OFFSET_BASETYPE (type
), 0);
1931 putc (',', asmfile
);
1933 dbxout_type (TREE_TYPE (type
), 0);
1936 /* Should print as an int, because it is really just an offset. */
1937 dbxout_type (integer_type_node
, 0);
1940 case REFERENCE_TYPE
:
1941 if (use_gnu_debug_info_extensions
)
1942 have_used_extensions
= 1;
1943 putc (use_gnu_debug_info_extensions
? '&' : '*', asmfile
);
1945 dbxout_type (TREE_TYPE (type
), 0);
1949 putc ('f', asmfile
);
1951 dbxout_type (TREE_TYPE (type
), 0);
1959 /* Return nonzero if the given type represents an integer whose bounds
1960 should be printed in octal format. */
1963 print_int_cst_bounds_in_octal_p (tree type
)
1965 /* If we can use GDB extensions and the size is wider than a long
1966 (the size used by GDB to read them) or we may have trouble writing
1967 the bounds the usual way, write them in octal. Note the test is for
1968 the *target's* size of "long", not that of the host. The host test
1969 is just to make sure we can write it out in case the host wide int
1970 is narrower than the target "long".
1972 For unsigned types, we use octal if they are the same size or larger.
1973 This is because we print the bounds as signed decimal, and hence they
1974 can't span same size unsigned types. */
1976 if (use_gnu_debug_info_extensions
1977 && TYPE_MIN_VALUE (type
) != 0
1978 && TREE_CODE (TYPE_MIN_VALUE (type
)) == INTEGER_CST
1979 && TYPE_MAX_VALUE (type
) != 0
1980 && TREE_CODE (TYPE_MAX_VALUE (type
)) == INTEGER_CST
1981 && (TYPE_PRECISION (type
) > TYPE_PRECISION (integer_type_node
)
1982 || ((TYPE_PRECISION (type
) == TYPE_PRECISION (integer_type_node
))
1983 && TYPE_UNSIGNED (type
))
1984 || TYPE_PRECISION (type
) > HOST_BITS_PER_WIDE_INT
1985 || (TYPE_PRECISION (type
) == HOST_BITS_PER_WIDE_INT
1986 && TYPE_UNSIGNED (type
))))
1992 /* Print the value of integer constant C, in octal,
1993 handling double precision. */
1996 print_int_cst_octal (tree c
)
1998 unsigned HOST_WIDE_INT high
= TREE_INT_CST_HIGH (c
);
1999 unsigned HOST_WIDE_INT low
= TREE_INT_CST_LOW (c
);
2000 int excess
= (3 - (HOST_BITS_PER_WIDE_INT
% 3));
2001 unsigned int width
= TYPE_PRECISION (TREE_TYPE (c
));
2003 /* GDB wants constants with no extra leading "1" bits, so
2004 we need to remove any sign-extension that might be
2006 if (width
== HOST_BITS_PER_WIDE_INT
* 2)
2008 else if (width
> HOST_BITS_PER_WIDE_INT
)
2009 high
&= (((HOST_WIDE_INT
) 1 << (width
- HOST_BITS_PER_WIDE_INT
)) - 1);
2010 else if (width
== HOST_BITS_PER_WIDE_INT
)
2013 high
= 0, low
&= (((HOST_WIDE_INT
) 1 << width
) - 1);
2015 fprintf (asmfile
, "0");
2020 print_octal (high
, HOST_BITS_PER_WIDE_INT
/ 3);
2021 print_octal (low
, HOST_BITS_PER_WIDE_INT
/ 3);
2025 unsigned HOST_WIDE_INT beg
= high
>> excess
;
2026 unsigned HOST_WIDE_INT middle
2027 = ((high
& (((HOST_WIDE_INT
) 1 << excess
) - 1)) << (3 - excess
)
2028 | (low
>> (HOST_BITS_PER_WIDE_INT
/ 3 * 3)));
2029 unsigned HOST_WIDE_INT end
2030 = low
& (((unsigned HOST_WIDE_INT
) 1
2031 << (HOST_BITS_PER_WIDE_INT
/ 3 * 3))
2034 fprintf (asmfile
, "%o%01o", (int) beg
, (int) middle
);
2036 print_octal (end
, HOST_BITS_PER_WIDE_INT
/ 3);
2041 print_octal (unsigned HOST_WIDE_INT value
, int digits
)
2045 for (i
= digits
- 1; i
>= 0; i
--)
2046 fprintf (asmfile
, "%01o", (int) ((value
>> (3 * i
)) & 7));
2051 /* Output C in decimal while adjusting the number of digits written. */
2054 print_wide_int (HOST_WIDE_INT c
)
2058 fprintf (asmfile
, HOST_WIDE_INT_PRINT_DEC
, c
);
2069 /* Output the name of type TYPE, with no punctuation.
2070 Such names can be set up either by typedef declarations
2071 or by struct, enum and union tags. */
2074 dbxout_type_name (tree type
)
2076 tree t
= TYPE_NAME (type
);
2079 switch (TREE_CODE (t
))
2081 case IDENTIFIER_NODE
:
2090 fprintf (asmfile
, "%s", IDENTIFIER_POINTER (t
));
2091 CHARS (IDENTIFIER_LENGTH (t
));
2094 /* Output leading leading struct or class names needed for qualifying
2095 type whose scope is limited to a struct or class. */
2098 dbxout_class_name_qualifiers (tree decl
)
2100 tree context
= decl_type_context (decl
);
2102 if (context
!= NULL_TREE
2103 && TREE_CODE(context
) == RECORD_TYPE
2104 && TYPE_NAME (context
) != 0
2105 && (TREE_CODE (TYPE_NAME (context
)) == IDENTIFIER_NODE
2106 || (DECL_NAME (TYPE_NAME (context
)) != 0)))
2108 tree name
= TYPE_NAME (context
);
2110 emit_pending_bincls_if_required ();
2112 if (TREE_CODE (name
) == TYPE_DECL
)
2114 dbxout_class_name_qualifiers (name
);
2115 name
= DECL_NAME (name
);
2117 fprintf (asmfile
, "%s::", IDENTIFIER_POINTER (name
));
2118 CHARS (IDENTIFIER_LENGTH (name
) + 2);
2122 /* Output a .stabs for the symbol defined by DECL,
2123 which must be a ..._DECL node in the normal namespace.
2124 It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
2125 LOCAL is nonzero if the scope is less than the entire file.
2126 Return 1 if a stabs might have been emitted. */
2129 dbxout_symbol (tree decl
, int local ATTRIBUTE_UNUSED
)
2131 tree type
= TREE_TYPE (decl
);
2132 tree context
= NULL_TREE
;
2135 /* "Intercept" dbxout_symbol() calls like we do all debug_hooks. */
2138 /* Ignore nameless syms, but don't ignore type tags. */
2140 if ((DECL_NAME (decl
) == 0 && TREE_CODE (decl
) != TYPE_DECL
)
2141 || DECL_IGNORED_P (decl
))
2142 DBXOUT_DECR_NESTING_AND_RETURN (0);
2144 /* If we are to generate only the symbols actually used then such
2145 symbol nodees are flagged with TREE_USED. Ignore any that
2146 aren't flaged as TREE_USED. */
2148 if (flag_debug_only_used_symbols
2149 && (!TREE_USED (decl
)
2150 && (TREE_CODE (decl
) != VAR_DECL
|| !DECL_INITIAL (decl
))))
2151 DBXOUT_DECR_NESTING_AND_RETURN (0);
2153 /* If dbxout_init has not yet run, queue this symbol for later. */
2156 preinit_symbols
= tree_cons (0, decl
, preinit_symbols
);
2157 DBXOUT_DECR_NESTING_AND_RETURN (0);
2160 if (flag_debug_only_used_symbols
)
2164 /* We now have a used symbol. We need to generate the info for
2165 the symbol's type in addition to the symbol itself. These
2166 type symbols are queued to be generated after were done with
2167 the symbol itself (done because the symbol's info is generated
2168 with fprintf's, etc. as it determines what's needed).
2170 Note, because the TREE_TYPE(type) might be something like a
2171 pointer to a named type we need to look for the first name
2172 we see following the TREE_TYPE chain. */
2175 while (POINTER_TYPE_P (t
))
2178 /* RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, and ENUMERAL_TYPE
2179 need special treatment. The TYPE_STUB_DECL field in these
2180 types generally represents the tag name type we want to
2181 output. In addition there could be a typedef type with
2182 a different name. In that case we also want to output
2185 if ((TREE_CODE (t
) == RECORD_TYPE
2186 || TREE_CODE (t
) == UNION_TYPE
2187 || TREE_CODE (t
) == QUAL_UNION_TYPE
2188 || TREE_CODE (t
) == ENUMERAL_TYPE
)
2189 && TYPE_STUB_DECL (t
)
2190 && TYPE_STUB_DECL (t
) != decl
2191 && DECL_P (TYPE_STUB_DECL (t
))
2192 && ! DECL_IGNORED_P (TYPE_STUB_DECL (t
)))
2194 debug_queue_symbol (TYPE_STUB_DECL (t
));
2196 && TYPE_NAME (t
) != TYPE_STUB_DECL (t
)
2197 && TYPE_NAME (t
) != decl
2198 && DECL_P (TYPE_NAME (t
)))
2199 debug_queue_symbol (TYPE_NAME (t
));
2201 else if (TYPE_NAME (t
)
2202 && TYPE_NAME (t
) != decl
2203 && DECL_P (TYPE_NAME (t
)))
2204 debug_queue_symbol (TYPE_NAME (t
));
2207 emit_pending_bincls_if_required ();
2209 dbxout_prepare_symbol (decl
);
2211 /* The output will always start with the symbol name,
2212 so always count that in the length-output-so-far. */
2214 if (DECL_NAME (decl
) != 0)
2215 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (decl
));
2217 switch (TREE_CODE (decl
))
2220 /* Enum values are defined by defining the enum type. */
2224 if (DECL_RTL (decl
) == 0)
2225 DBXOUT_DECR_NESTING_AND_RETURN (0);
2226 if (DECL_EXTERNAL (decl
))
2228 /* Don't mention a nested function under its parent. */
2229 context
= decl_function_context (decl
);
2230 if (context
== current_function_decl
)
2232 if (!MEM_P (DECL_RTL (decl
))
2233 || GET_CODE (XEXP (DECL_RTL (decl
), 0)) != SYMBOL_REF
)
2237 fprintf (asmfile
, "%s\"%s:%c", ASM_STABS_OP
,
2238 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)),
2239 TREE_PUBLIC (decl
) ? 'F' : 'f');
2242 current_sym_code
= N_FUN
;
2243 current_sym_addr
= XEXP (DECL_RTL (decl
), 0);
2245 if (TREE_TYPE (type
))
2246 dbxout_type (TREE_TYPE (type
), 0);
2248 dbxout_type (void_type_node
, 0);
2250 /* For a nested function, when that function is compiled,
2251 mention the containing function name
2252 as well as (since dbx wants it) our own assembler-name. */
2254 fprintf (asmfile
, ",%s,%s",
2255 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)),
2256 IDENTIFIER_POINTER (DECL_NAME (context
)));
2258 dbxout_finish_symbol (decl
);
2262 /* Don't output the same typedef twice.
2263 And don't output what language-specific stuff doesn't want output. */
2264 if (TREE_ASM_WRITTEN (decl
) || TYPE_DECL_SUPPRESS_DEBUG (decl
))
2265 DBXOUT_DECR_NESTING_AND_RETURN (0);
2267 /* Don't output typedefs for types with magic type numbers (XCOFF). */
2268 #ifdef DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER
2270 int fundamental_type_number
=
2271 DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER (decl
);
2273 if (fundamental_type_number
!= 0)
2275 TREE_ASM_WRITTEN (decl
) = 1;
2276 TYPE_SYMTAB_ADDRESS (TREE_TYPE (decl
)) = fundamental_type_number
;
2277 DBXOUT_DECR_NESTING_AND_RETURN (0);
2287 if (DECL_NAME (decl
))
2289 /* Nonzero means we must output a tag as well as a typedef. */
2292 /* Handle the case of a C++ structure or union
2293 where the TYPE_NAME is a TYPE_DECL
2294 which gives both a typedef name and a tag. */
2295 /* dbx requires the tag first and the typedef second. */
2296 if ((TREE_CODE (type
) == RECORD_TYPE
2297 || TREE_CODE (type
) == UNION_TYPE
2298 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
2299 && TYPE_NAME (type
) == decl
2300 && !(use_gnu_debug_info_extensions
&& have_used_extensions
)
2301 && !TREE_ASM_WRITTEN (TYPE_NAME (type
))
2302 /* Distinguish the implicit typedefs of C++
2303 from explicit ones that might be found in C. */
2304 && DECL_ARTIFICIAL (decl
)
2305 /* Do not generate a tag for incomplete records. */
2306 && COMPLETE_TYPE_P (type
)
2307 /* Do not generate a tag for records of variable size,
2308 since this type can not be properly described in the
2309 DBX format, and it confuses some tools such as objdump. */
2310 && host_integerp (TYPE_SIZE (type
), 1))
2312 tree name
= TYPE_NAME (type
);
2313 if (TREE_CODE (name
) == TYPE_DECL
)
2314 name
= DECL_NAME (name
);
2316 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
2317 current_sym_value
= 0;
2318 current_sym_addr
= 0;
2319 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (name
);
2321 fprintf (asmfile
, "%s\"%s:T", ASM_STABS_OP
,
2322 IDENTIFIER_POINTER (name
));
2323 dbxout_type (type
, 1);
2324 dbxout_finish_symbol (NULL_TREE
);
2327 /* Output .stabs (or whatever) and leading double quote. */
2328 fprintf (asmfile
, "%s\"", ASM_STABS_OP
);
2330 if (use_gnu_debug_info_extensions
)
2332 /* Output leading class/struct qualifiers. */
2333 dbxout_class_name_qualifiers (decl
);
2336 /* Output typedef name. */
2337 fprintf (asmfile
, "%s:", IDENTIFIER_POINTER (DECL_NAME (decl
)));
2339 /* Short cut way to output a tag also. */
2340 if ((TREE_CODE (type
) == RECORD_TYPE
2341 || TREE_CODE (type
) == UNION_TYPE
2342 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
2343 && TYPE_NAME (type
) == decl
2344 /* Distinguish the implicit typedefs of C++
2345 from explicit ones that might be found in C. */
2346 && DECL_ARTIFICIAL (decl
))
2348 if (use_gnu_debug_info_extensions
&& have_used_extensions
)
2350 putc ('T', asmfile
);
2351 TREE_ASM_WRITTEN (TYPE_NAME (type
)) = 1;
2353 #if 0 /* Now we generate the tag for this case up above. */
2359 putc ('t', asmfile
);
2360 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
2362 dbxout_type (type
, 1);
2363 dbxout_finish_symbol (decl
);
2367 /* Don't output a tag if this is an incomplete type. This prevents
2368 the sun4 Sun OS 4.x dbx from crashing. */
2370 if (tag_needed
&& TYPE_NAME (type
) != 0
2371 && (TREE_CODE (TYPE_NAME (type
)) == IDENTIFIER_NODE
2372 || (DECL_NAME (TYPE_NAME (type
)) != 0))
2373 && COMPLETE_TYPE_P (type
)
2374 && !TREE_ASM_WRITTEN (TYPE_NAME (type
)))
2376 /* For a TYPE_DECL with no name, but the type has a name,
2378 This is what represents `struct foo' with no typedef. */
2379 /* In C++, the name of a type is the corresponding typedef.
2380 In C, it is an IDENTIFIER_NODE. */
2381 tree name
= TYPE_NAME (type
);
2382 if (TREE_CODE (name
) == TYPE_DECL
)
2383 name
= DECL_NAME (name
);
2385 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
2386 current_sym_value
= 0;
2387 current_sym_addr
= 0;
2388 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (name
);
2390 fprintf (asmfile
, "%s\"%s:T", ASM_STABS_OP
,
2391 IDENTIFIER_POINTER (name
));
2392 dbxout_type (type
, 1);
2393 dbxout_finish_symbol (NULL_TREE
);
2397 /* If an enum type has no name, it cannot be referred to,
2398 but we must output it anyway, since the enumeration constants
2399 can be referred to. */
2400 if (!did_output
&& TREE_CODE (type
) == ENUMERAL_TYPE
)
2402 current_sym_code
= DBX_TYPE_DECL_STABS_CODE
;
2403 current_sym_value
= 0;
2404 current_sym_addr
= 0;
2405 current_sym_nchars
= 2;
2407 /* Some debuggers fail when given NULL names, so give this a
2408 harmless name of ` '. */
2409 fprintf (asmfile
, "%s\" :T", ASM_STABS_OP
);
2410 dbxout_type (type
, 1);
2411 dbxout_finish_symbol (NULL_TREE
);
2414 /* Prevent duplicate output of a typedef. */
2415 TREE_ASM_WRITTEN (decl
) = 1;
2420 /* Parm decls go in their own separate chains
2421 and are output by dbxout_reg_parms and dbxout_parms. */
2425 /* Named return value, treat like a VAR_DECL. */
2427 if (! DECL_RTL_SET_P (decl
))
2428 DBXOUT_DECR_NESTING_AND_RETURN (0);
2429 /* Don't mention a variable that is external.
2430 Let the file that defines it describe it. */
2431 if (DECL_EXTERNAL (decl
))
2434 /* If the variable is really a constant
2435 and not written in memory, inform the debugger. */
2436 if (TREE_STATIC (decl
) && TREE_READONLY (decl
)
2437 && DECL_INITIAL (decl
) != 0
2438 && host_integerp (DECL_INITIAL (decl
), 0)
2439 && ! TREE_ASM_WRITTEN (decl
)
2440 && (DECL_CONTEXT (decl
) == NULL_TREE
2441 || TREE_CODE (DECL_CONTEXT (decl
)) == BLOCK
))
2443 if (TREE_PUBLIC (decl
) == 0)
2445 /* The sun4 assembler does not grok this. */
2446 const char *name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
2448 if (TREE_CODE (TREE_TYPE (decl
)) == INTEGER_TYPE
2449 || TREE_CODE (TREE_TYPE (decl
)) == ENUMERAL_TYPE
)
2451 HOST_WIDE_INT ival
= tree_low_cst (DECL_INITIAL (decl
), 0);
2452 fprintf (asmfile
, "%s\"%s:c=i" HOST_WIDE_INT_PRINT_DEC
2454 ASM_STABS_OP
, name
, ival
, N_LSYM
);
2455 DBXOUT_DECR_NESTING
;
2458 else if (TREE_CODE (TREE_TYPE (decl
)) == REAL_TYPE
)
2460 /* Don't know how to do this yet. */
2464 /* else it is something we handle like a normal variable. */
2467 SET_DECL_RTL (decl
, eliminate_regs (DECL_RTL (decl
), 0, NULL_RTX
));
2468 #ifdef LEAF_REG_REMAP
2469 if (current_function_uses_only_leaf_regs
)
2470 leaf_renumber_regs_insn (DECL_RTL (decl
));
2473 result
= dbxout_symbol_location (decl
, type
, 0, DECL_RTL (decl
));
2479 DBXOUT_DECR_NESTING
;
2483 /* Output the stab for DECL, a VAR_DECL, RESULT_DECL or PARM_DECL.
2484 Add SUFFIX to its name, if SUFFIX is not 0.
2485 Describe the variable as residing in HOME
2486 (usually HOME is DECL_RTL (DECL), but not always).
2487 Returns 1 if the stab was really emitted. */
2490 dbxout_symbol_location (tree decl
, tree type
, const char *suffix
, rtx home
)
2495 emit_pending_bincls_if_required ();
2497 /* Don't mention a variable at all
2498 if it was completely optimized into nothingness.
2500 If the decl was from an inline function, then its rtl
2501 is not identically the rtl that was used in this
2502 particular compilation. */
2503 if (GET_CODE (home
) == SUBREG
)
2507 while (GET_CODE (value
) == SUBREG
)
2508 value
= SUBREG_REG (value
);
2511 if (REGNO (value
) >= FIRST_PSEUDO_REGISTER
)
2514 home
= alter_subreg (&home
);
2518 regno
= REGNO (home
);
2519 if (regno
>= FIRST_PSEUDO_REGISTER
)
2523 /* The kind-of-variable letter depends on where
2524 the variable is and on the scope of its name:
2525 G and N_GSYM for static storage and global scope,
2526 S for static storage and file scope,
2527 V for static storage and local scope,
2528 for those two, use N_LCSYM if data is in bss segment,
2529 N_STSYM if in data segment, N_FUN otherwise.
2530 (We used N_FUN originally, then changed to N_STSYM
2531 to please GDB. However, it seems that confused ld.
2532 Now GDB has been fixed to like N_FUN, says Kingdon.)
2533 no letter at all, and N_LSYM, for auto variable,
2534 r and N_RSYM for register variable. */
2537 && GET_CODE (XEXP (home
, 0)) == SYMBOL_REF
)
2539 if (TREE_PUBLIC (decl
))
2542 current_sym_code
= N_GSYM
;
2546 current_sym_addr
= XEXP (home
, 0);
2548 letter
= decl_function_context (decl
) ? 'V' : 'S';
2550 /* This should be the same condition as in assemble_variable, but
2551 we don't have access to dont_output_data here. So, instead,
2552 we rely on the fact that error_mark_node initializers always
2553 end up in bss for C++ and never end up in bss for C. */
2554 if (DECL_INITIAL (decl
) == 0
2555 || (!strcmp (lang_hooks
.name
, "GNU C++")
2556 && DECL_INITIAL (decl
) == error_mark_node
))
2557 current_sym_code
= N_LCSYM
;
2558 else if (DECL_IN_TEXT_SECTION (decl
))
2559 /* This is not quite right, but it's the closest
2560 of all the codes that Unix defines. */
2561 current_sym_code
= DBX_STATIC_CONST_VAR_CODE
;
2564 /* Some ports can transform a symbol ref into a label ref,
2565 because the symbol ref is too far away and has to be
2566 dumped into a constant pool. Alternatively, the symbol
2567 in the constant pool might be referenced by a different
2569 if (GET_CODE (current_sym_addr
) == SYMBOL_REF
2570 && CONSTANT_POOL_ADDRESS_P (current_sym_addr
))
2573 rtx tmp
= get_pool_constant_mark (current_sym_addr
, &marked
);
2575 if (GET_CODE (tmp
) == SYMBOL_REF
)
2577 current_sym_addr
= tmp
;
2578 if (CONSTANT_POOL_ADDRESS_P (current_sym_addr
))
2579 get_pool_constant_mark (current_sym_addr
, &marked
);
2583 else if (GET_CODE (tmp
) == LABEL_REF
)
2585 current_sym_addr
= tmp
;
2589 /* If all references to the constant pool were optimized
2590 out, we just ignore the symbol. */
2595 /* Ultrix `as' seems to need this. */
2596 #ifdef DBX_STATIC_STAB_DATA_SECTION
2599 current_sym_code
= N_STSYM
;
2603 else if (regno
>= 0)
2606 current_sym_code
= N_RSYM
;
2607 current_sym_value
= DBX_REGISTER_NUMBER (regno
);
2609 else if (MEM_P (home
)
2610 && (MEM_P (XEXP (home
, 0))
2611 || (REG_P (XEXP (home
, 0))
2612 && REGNO (XEXP (home
, 0)) != HARD_FRAME_POINTER_REGNUM
2613 && REGNO (XEXP (home
, 0)) != STACK_POINTER_REGNUM
2614 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2615 && REGNO (XEXP (home
, 0)) != ARG_POINTER_REGNUM
2618 /* If the value is indirect by memory or by a register
2619 that isn't the frame pointer
2620 then it means the object is variable-sized and address through
2621 that register or stack slot. DBX has no way to represent this
2622 so all we can do is output the variable as a pointer.
2623 If it's not a parameter, ignore it. */
2625 if (REG_P (XEXP (home
, 0)))
2628 current_sym_code
= N_RSYM
;
2629 if (REGNO (XEXP (home
, 0)) >= FIRST_PSEUDO_REGISTER
)
2631 current_sym_value
= DBX_REGISTER_NUMBER (REGNO (XEXP (home
, 0)));
2635 current_sym_code
= N_LSYM
;
2636 /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
2637 We want the value of that CONST_INT. */
2639 = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home
, 0), 0));
2642 /* Effectively do build_pointer_type, but don't cache this type,
2643 since it might be temporary whereas the type it points to
2644 might have been saved for inlining. */
2645 /* Don't use REFERENCE_TYPE because dbx can't handle that. */
2646 type
= make_node (POINTER_TYPE
);
2647 TREE_TYPE (type
) = TREE_TYPE (decl
);
2649 else if (MEM_P (home
)
2650 && REG_P (XEXP (home
, 0)))
2652 current_sym_code
= N_LSYM
;
2653 current_sym_value
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
2655 else if (MEM_P (home
)
2656 && GET_CODE (XEXP (home
, 0)) == PLUS
2657 && GET_CODE (XEXP (XEXP (home
, 0), 1)) == CONST_INT
)
2659 current_sym_code
= N_LSYM
;
2660 /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
2661 We want the value of that CONST_INT. */
2662 current_sym_value
= DEBUGGER_AUTO_OFFSET (XEXP (home
, 0));
2664 else if (MEM_P (home
)
2665 && GET_CODE (XEXP (home
, 0)) == CONST
)
2667 /* Handle an obscure case which can arise when optimizing and
2668 when there are few available registers. (This is *always*
2669 the case for i386/i486 targets). The RTL looks like
2670 (MEM (CONST ...)) even though this variable is a local `auto'
2671 or a local `register' variable. In effect, what has happened
2672 is that the reload pass has seen that all assignments and
2673 references for one such a local variable can be replaced by
2674 equivalent assignments and references to some static storage
2675 variable, thereby avoiding the need for a register. In such
2676 cases we're forced to lie to debuggers and tell them that
2677 this variable was itself `static'. */
2678 current_sym_code
= N_LCSYM
;
2680 current_sym_addr
= XEXP (XEXP (home
, 0), 0);
2682 else if (GET_CODE (home
) == CONCAT
)
2686 /* If TYPE is not a COMPLEX_TYPE (it might be a RECORD_TYPE,
2687 for example), then there is no easy way to figure out
2688 what SUBTYPE should be. So, we give up. */
2689 if (TREE_CODE (type
) != COMPLEX_TYPE
)
2692 subtype
= TREE_TYPE (type
);
2694 /* If the variable's storage is in two parts,
2695 output each as a separate stab with a modified name. */
2696 if (WORDS_BIG_ENDIAN
)
2697 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 0));
2699 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 0));
2701 dbxout_prepare_symbol (decl
);
2703 if (WORDS_BIG_ENDIAN
)
2704 dbxout_symbol_location (decl
, subtype
, "$real", XEXP (home
, 1));
2706 dbxout_symbol_location (decl
, subtype
, "$imag", XEXP (home
, 1));
2710 /* Address might be a MEM, when DECL is a variable-sized object.
2711 Or it might be const0_rtx, meaning previous passes
2712 want us to ignore this variable. */
2715 /* Ok, start a symtab entry and output the variable name. */
2718 #ifdef DBX_STATIC_BLOCK_START
2719 DBX_STATIC_BLOCK_START (asmfile
, current_sym_code
);
2722 dbxout_symbol_name (decl
, suffix
, letter
);
2723 dbxout_type (type
, 0);
2724 dbxout_finish_symbol (decl
);
2726 #ifdef DBX_STATIC_BLOCK_END
2727 DBX_STATIC_BLOCK_END (asmfile
, current_sym_code
);
2732 /* Output the symbol name of DECL for a stabs, with suffix SUFFIX.
2733 Then output LETTER to indicate the kind of location the symbol has. */
2736 dbxout_symbol_name (tree decl
, const char *suffix
, int letter
)
2740 if (DECL_CONTEXT (decl
)
2741 && (TYPE_P (DECL_CONTEXT (decl
))
2742 || TREE_CODE (DECL_CONTEXT (decl
)) == NAMESPACE_DECL
))
2743 /* One slight hitch: if this is a VAR_DECL which is a class member
2744 or a namespace member, we must put out the mangled name instead of the
2745 DECL_NAME. Note also that static member (variable) names DO NOT begin
2746 with underscores in .stabs directives. */
2747 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
2749 /* ...but if we're function-local, we don't want to include the junk
2750 added by ASM_FORMAT_PRIVATE_NAME. */
2751 name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
2755 fprintf (asmfile
, "%s\"%s%s:", ASM_STABS_OP
, name
,
2756 (suffix
? suffix
: ""));
2759 putc (letter
, asmfile
);
2763 dbxout_prepare_symbol (tree decl ATTRIBUTE_UNUSED
)
2766 const char *filename
= DECL_SOURCE_FILE (decl
);
2768 dbxout_source_file (asmfile
, filename
);
2771 /* Initialize variables used to communicate each symbol's debug
2772 information to dbxout_finish_symbol with zeroes. */
2774 /* Cast avoids warning in old compilers. */
2775 current_sym_code
= (STAB_CODE_TYPE
) 0;
2776 current_sym_value
= 0;
2777 current_sym_addr
= 0;
2781 dbxout_finish_symbol (tree sym
)
2783 #ifdef DBX_FINISH_SYMBOL
2784 DBX_FINISH_SYMBOL (sym
);
2787 if (use_gnu_debug_info_extensions
&& sym
!= 0)
2788 line
= DECL_SOURCE_LINE (sym
);
2790 fprintf (asmfile
, "\",%d,0,%d,", current_sym_code
, line
);
2791 if (current_sym_addr
)
2792 output_addr_const (asmfile
, current_sym_addr
);
2794 fprintf (asmfile
, "%d", current_sym_value
);
2795 putc ('\n', asmfile
);
2799 /* Output definitions of all the decls in a chain. Return nonzero if
2800 anything was output */
2803 dbxout_syms (tree syms
)
2808 result
+= dbxout_symbol (syms
, 1);
2809 syms
= TREE_CHAIN (syms
);
2814 /* The following two functions output definitions of function parameters.
2815 Each parameter gets a definition locating it in the parameter list.
2816 Each parameter that is a register variable gets a second definition
2817 locating it in the register.
2819 Printing or argument lists in gdb uses the definitions that
2820 locate in the parameter list. But reference to the variable in
2821 expressions uses preferentially the definition as a register. */
2823 /* Output definitions, referring to storage in the parmlist,
2824 of all the parms in PARMS, which is a chain of PARM_DECL nodes. */
2827 dbxout_parms (tree parms
)
2831 emit_pending_bincls_if_required ();
2833 for (; parms
; parms
= TREE_CHAIN (parms
))
2834 if (DECL_NAME (parms
)
2835 && TREE_TYPE (parms
) != error_mark_node
2836 && DECL_RTL_SET_P (parms
)
2837 && DECL_INCOMING_RTL (parms
))
2839 dbxout_prepare_symbol (parms
);
2841 /* Perform any necessary register eliminations on the parameter's rtl,
2842 so that the debugging output will be accurate. */
2843 DECL_INCOMING_RTL (parms
)
2844 = eliminate_regs (DECL_INCOMING_RTL (parms
), 0, NULL_RTX
);
2845 SET_DECL_RTL (parms
, eliminate_regs (DECL_RTL (parms
), 0, NULL_RTX
));
2846 #ifdef LEAF_REG_REMAP
2847 if (current_function_uses_only_leaf_regs
)
2849 leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms
));
2850 leaf_renumber_regs_insn (DECL_RTL (parms
));
2854 if (PARM_PASSED_IN_MEMORY (parms
))
2856 rtx addr
= XEXP (DECL_INCOMING_RTL (parms
), 0);
2858 /* ??? Here we assume that the parm address is indexed
2859 off the frame pointer or arg pointer.
2860 If that is not true, we produce meaningless results,
2861 but do not crash. */
2862 if (GET_CODE (addr
) == PLUS
2863 && GET_CODE (XEXP (addr
, 1)) == CONST_INT
)
2864 current_sym_value
= INTVAL (XEXP (addr
, 1));
2866 current_sym_value
= 0;
2868 current_sym_code
= N_PSYM
;
2869 current_sym_addr
= 0;
2872 if (DECL_NAME (parms
))
2874 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (parms
));
2876 fprintf (asmfile
, "%s\"%s:%c", ASM_STABS_OP
,
2877 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2878 DBX_MEMPARM_STABS_LETTER
);
2882 current_sym_nchars
= 8;
2883 fprintf (asmfile
, "%s\"(anon):%c", ASM_STABS_OP
,
2884 DBX_MEMPARM_STABS_LETTER
);
2887 /* It is quite tempting to use:
2889 dbxout_type (TREE_TYPE (parms), 0);
2891 as the next statement, rather than using DECL_ARG_TYPE(), so
2892 that gcc reports the actual type of the parameter, rather
2893 than the promoted type. This certainly makes GDB's life
2894 easier, at least for some ports. The change is a bad idea
2895 however, since GDB expects to be able access the type without
2896 performing any conversions. So for example, if we were
2897 passing a float to an unprototyped function, gcc will store a
2898 double on the stack, but if we emit a stab saying the type is a
2899 float, then gdb will only read in a single value, and this will
2900 produce an erroneous value. */
2901 dbxout_type (DECL_ARG_TYPE (parms
), 0);
2902 current_sym_value
= DEBUGGER_ARG_OFFSET (current_sym_value
, addr
);
2903 dbxout_finish_symbol (parms
);
2905 else if (REG_P (DECL_RTL (parms
)))
2908 char regparm_letter
;
2910 /* Parm passed in registers and lives in registers or nowhere. */
2912 current_sym_code
= DBX_REGPARM_STABS_CODE
;
2913 regparm_letter
= DBX_REGPARM_STABS_LETTER
;
2914 current_sym_addr
= 0;
2916 /* If parm lives in a register, use that register;
2917 pretend the parm was passed there. It would be more consistent
2918 to describe the register where the parm was passed,
2919 but in practice that register usually holds something else.
2921 If we use DECL_RTL, then we must use the declared type of
2922 the variable, not the type that it arrived in. */
2923 if (REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
2925 best_rtl
= DECL_RTL (parms
);
2926 parm_type
= TREE_TYPE (parms
);
2928 /* If the parm lives nowhere, use the register where it was
2929 passed. It is also better to use the declared type here. */
2932 best_rtl
= DECL_INCOMING_RTL (parms
);
2933 parm_type
= TREE_TYPE (parms
);
2935 current_sym_value
= DBX_REGISTER_NUMBER (REGNO (best_rtl
));
2938 if (DECL_NAME (parms
))
2940 current_sym_nchars
= 2 + IDENTIFIER_LENGTH (DECL_NAME (parms
));
2941 fprintf (asmfile
, "%s\"%s:%c", ASM_STABS_OP
,
2942 IDENTIFIER_POINTER (DECL_NAME (parms
)),
2947 current_sym_nchars
= 8;
2948 fprintf (asmfile
, "%s\"(anon):%c", ASM_STABS_OP
,
2952 dbxout_type (parm_type
, 0);
2953 dbxout_finish_symbol (parms
);
2955 else if (MEM_P (DECL_RTL (parms
))
2956 && REG_P (XEXP (DECL_RTL (parms
), 0))
2957 && REGNO (XEXP (DECL_RTL (parms
), 0)) != HARD_FRAME_POINTER_REGNUM
2958 && REGNO (XEXP (DECL_RTL (parms
), 0)) != STACK_POINTER_REGNUM
2959 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2960 && REGNO (XEXP (DECL_RTL (parms
), 0)) != ARG_POINTER_REGNUM
2964 /* Parm was passed via invisible reference.
2965 That is, its address was passed in a register.
2966 Output it as if it lived in that register.
2967 The debugger will know from the type
2968 that it was actually passed by invisible reference. */
2970 char regparm_letter
;
2971 /* Parm passed in registers and lives in registers or nowhere. */
2973 current_sym_code
= DBX_REGPARM_STABS_CODE
;
2974 if (use_gnu_debug_info_extensions
)
2975 regparm_letter
= GDB_INV_REF_REGPARM_STABS_LETTER
;
2977 regparm_letter
= DBX_REGPARM_STABS_LETTER
;
2979 /* DECL_RTL looks like (MEM (REG...). Get the register number.
2980 If it is an unallocated pseudo-reg, then use the register where
2981 it was passed instead. */
2982 if (REGNO (XEXP (DECL_RTL (parms
), 0)) < FIRST_PSEUDO_REGISTER
)
2983 current_sym_value
= REGNO (XEXP (DECL_RTL (parms
), 0));
2985 current_sym_value
= REGNO (DECL_INCOMING_RTL (parms
));
2987 current_sym_addr
= 0;
2990 if (DECL_NAME (parms
))
2993 = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms
)));
2995 fprintf (asmfile
, "%s\"%s:%c", ASM_STABS_OP
,
2996 IDENTIFIER_POINTER (DECL_NAME (parms
)),
3001 current_sym_nchars
= 8;
3002 fprintf (asmfile
, "%s\"(anon):%c", ASM_STABS_OP
,
3006 dbxout_type (TREE_TYPE (parms
), 0);
3007 dbxout_finish_symbol (parms
);
3009 else if (MEM_P (DECL_RTL (parms
))
3010 && MEM_P (XEXP (DECL_RTL (parms
), 0)))
3012 /* Parm was passed via invisible reference, with the reference
3013 living on the stack. DECL_RTL looks like
3014 (MEM (MEM (PLUS (REG ...) (CONST_INT ...)))) or it
3015 could look like (MEM (MEM (REG))). */
3016 const char *const decl_name
= (DECL_NAME (parms
)
3017 ? IDENTIFIER_POINTER (DECL_NAME (parms
))
3019 if (REG_P (XEXP (XEXP (DECL_RTL (parms
), 0), 0)))
3020 current_sym_value
= 0;
3023 = INTVAL (XEXP (XEXP (XEXP (DECL_RTL (parms
), 0), 0), 1));
3024 current_sym_addr
= 0;
3025 current_sym_code
= N_PSYM
;
3028 fprintf (asmfile
, "%s\"%s:v", ASM_STABS_OP
, decl_name
);
3031 = DEBUGGER_ARG_OFFSET (current_sym_value
,
3032 XEXP (XEXP (DECL_RTL (parms
), 0), 0));
3033 dbxout_type (TREE_TYPE (parms
), 0);
3034 dbxout_finish_symbol (parms
);
3036 else if (MEM_P (DECL_RTL (parms
))
3037 && XEXP (DECL_RTL (parms
), 0) != const0_rtx
3038 /* ??? A constant address for a parm can happen
3039 when the reg it lives in is equiv to a constant in memory.
3040 Should make this not happen, after 2.4. */
3041 && ! CONSTANT_P (XEXP (DECL_RTL (parms
), 0)))
3043 /* Parm was passed in registers but lives on the stack. */
3045 current_sym_code
= N_PSYM
;
3046 /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
3047 in which case we want the value of that CONST_INT,
3049 in which case we use a value of zero. */
3050 if (REG_P (XEXP (DECL_RTL (parms
), 0)))
3051 current_sym_value
= 0;
3054 = INTVAL (XEXP (XEXP (DECL_RTL (parms
), 0), 1));
3056 current_sym_addr
= 0;
3058 /* Make a big endian correction if the mode of the type of the
3059 parameter is not the same as the mode of the rtl. */
3060 if (BYTES_BIG_ENDIAN
3061 && TYPE_MODE (TREE_TYPE (parms
)) != GET_MODE (DECL_RTL (parms
))
3062 && GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms
))) < UNITS_PER_WORD
)
3064 current_sym_value
+=
3065 GET_MODE_SIZE (GET_MODE (DECL_RTL (parms
)))
3066 - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms
)));
3070 if (DECL_NAME (parms
))
3073 = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms
)));
3075 fprintf (asmfile
, "%s\"%s:%c", ASM_STABS_OP
,
3076 IDENTIFIER_POINTER (DECL_NAME (parms
)),
3077 DBX_MEMPARM_STABS_LETTER
);
3081 current_sym_nchars
= 8;
3082 fprintf (asmfile
, "%s\"(anon):%c", ASM_STABS_OP
,
3083 DBX_MEMPARM_STABS_LETTER
);
3087 = DEBUGGER_ARG_OFFSET (current_sym_value
,
3088 XEXP (DECL_RTL (parms
), 0));
3089 dbxout_type (TREE_TYPE (parms
), 0);
3090 dbxout_finish_symbol (parms
);
3093 DBXOUT_DECR_NESTING
;
3096 /* Output definitions for the places where parms live during the function,
3097 when different from where they were passed, when the parms were passed
3100 It is not useful to do this for parms passed in registers
3101 that live during the function in different registers, because it is
3102 impossible to look in the passed register for the passed value,
3103 so we use the within-the-function register to begin with.
3105 PARMS is a chain of PARM_DECL nodes. */
3108 dbxout_reg_parms (tree parms
)
3112 for (; parms
; parms
= TREE_CHAIN (parms
))
3113 if (DECL_NAME (parms
) && PARM_PASSED_IN_MEMORY (parms
))
3115 dbxout_prepare_symbol (parms
);
3117 /* Report parms that live in registers during the function
3118 but were passed in memory. */
3119 if (REG_P (DECL_RTL (parms
))
3120 && REGNO (DECL_RTL (parms
)) < FIRST_PSEUDO_REGISTER
)
3121 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
3122 0, DECL_RTL (parms
));
3123 else if (GET_CODE (DECL_RTL (parms
)) == CONCAT
)
3124 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
3125 0, DECL_RTL (parms
));
3126 /* Report parms that live in memory but not where they were passed. */
3127 else if (MEM_P (DECL_RTL (parms
))
3128 && ! rtx_equal_p (DECL_RTL (parms
), DECL_INCOMING_RTL (parms
)))
3129 dbxout_symbol_location (parms
, TREE_TYPE (parms
),
3130 0, DECL_RTL (parms
));
3132 DBXOUT_DECR_NESTING
;
3135 /* Given a chain of ..._TYPE nodes (as come in a parameter list),
3136 output definitions of those names, in raw form */
3139 dbxout_args (tree args
)
3143 putc (',', asmfile
);
3144 dbxout_type (TREE_VALUE (args
), 0);
3146 args
= TREE_CHAIN (args
);
3150 /* Subroutine of dbxout_block. Emit an N_LBRAC stab referencing LABEL.
3151 BEGIN_LABEL is the name of the beginning of the function, which may
3154 dbx_output_lbrac (const char *label
,
3155 const char *begin_label ATTRIBUTE_UNUSED
)
3157 #ifdef DBX_OUTPUT_LBRAC
3158 DBX_OUTPUT_LBRAC (asmfile
, label
);
3160 fprintf (asmfile
, "%s%d,0,0,", ASM_STABN_OP
, N_LBRAC
);
3161 assemble_name (asmfile
, label
);
3162 #if DBX_BLOCKS_FUNCTION_RELATIVE
3163 putc ('-', asmfile
);
3164 assemble_name (asmfile
, begin_label
);
3166 fprintf (asmfile
, "\n");
3170 /* Subroutine of dbxout_block. Emit an N_RBRAC stab referencing LABEL.
3171 BEGIN_LABEL is the name of the beginning of the function, which may
3174 dbx_output_rbrac (const char *label
,
3175 const char *begin_label ATTRIBUTE_UNUSED
)
3177 #ifdef DBX_OUTPUT_RBRAC
3178 DBX_OUTPUT_RBRAC (asmfile
, label
);
3180 fprintf (asmfile
, "%s%d,0,0,", ASM_STABN_OP
, N_RBRAC
);
3181 assemble_name (asmfile
, label
);
3182 #if DBX_BLOCKS_FUNCTION_RELATIVE
3183 putc ('-', asmfile
);
3184 assemble_name (asmfile
, begin_label
);
3186 fprintf (asmfile
, "\n");
3190 /* Output everything about a symbol block (a BLOCK node
3191 that represents a scope level),
3192 including recursive output of contained blocks.
3194 BLOCK is the BLOCK node.
3195 DEPTH is its depth within containing symbol blocks.
3196 ARGS is usually zero; but for the outermost block of the
3197 body of a function, it is a chain of PARM_DECLs for the function parameters.
3198 We output definitions of all the register parms
3199 as if they were local variables of that block.
3201 If -g1 was used, we count blocks just the same, but output nothing
3202 except for the outermost block.
3204 Actually, BLOCK may be several blocks chained together.
3205 We handle them all in sequence. */
3208 dbxout_block (tree block
, int depth
, tree args
)
3210 const char *begin_label
;
3211 if (current_function_func_begin_label
!= NULL
)
3212 begin_label
= current_function_func_begin_label
;
3214 begin_label
= XSTR (XEXP (DECL_RTL (current_function_decl
), 0), 0);
3218 /* Ignore blocks never expanded or otherwise marked as real. */
3219 if (TREE_USED (block
) && TREE_ASM_WRITTEN (block
))
3222 int blocknum
= BLOCK_NUMBER (block
);
3224 /* In dbx format, the syms of a block come before the N_LBRAC.
3225 If nothing is output, we don't need the N_LBRAC, either. */
3227 if (debug_info_level
!= DINFO_LEVEL_TERSE
|| depth
== 0)
3228 did_output
= dbxout_syms (BLOCK_VARS (block
));
3230 dbxout_reg_parms (args
);
3232 /* Now output an N_LBRAC symbol to represent the beginning of
3233 the block. Use the block's tree-walk order to generate
3234 the assembler symbols LBBn and LBEn
3235 that final will define around the code in this block. */
3239 const char *scope_start
;
3242 /* The outermost block doesn't get LBB labels; use
3243 the function symbol. */
3244 scope_start
= begin_label
;
3247 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBB", blocknum
);
3251 if (BLOCK_HANDLER_BLOCK (block
))
3253 /* A catch block. Must precede N_LBRAC. */
3254 tree decl
= BLOCK_VARS (block
);
3257 fprintf (asmfile
, "%s\"%s:C1\",%d,0,0,", ASM_STABS_OP
,
3258 IDENTIFIER_POINTER (DECL_NAME (decl
)), N_CATCH
);
3259 assemble_name (asmfile
, scope_start
);
3260 fprintf (asmfile
, "\n");
3261 decl
= TREE_CHAIN (decl
);
3264 dbx_output_lbrac (scope_start
, begin_label
);
3267 /* Output the subblocks. */
3268 dbxout_block (BLOCK_SUBBLOCKS (block
), depth
+ 1, NULL_TREE
);
3270 /* Refer to the marker for the end of the block. */
3275 /* The outermost block doesn't get LBE labels;
3276 use the "scope" label which will be emitted
3277 by dbxout_function_end. */
3278 ASM_GENERATE_INTERNAL_LABEL (buf
, "Lscope", scope_labelno
);
3280 ASM_GENERATE_INTERNAL_LABEL (buf
, "LBE", blocknum
);
3282 dbx_output_rbrac (buf
, begin_label
);
3285 block
= BLOCK_CHAIN (block
);
3289 /* Output the information about a function and its arguments and result.
3290 Usually this follows the function's code,
3291 but on some systems, it comes before. */
3293 #if defined (DBX_DEBUGGING_INFO)
3295 dbxout_begin_function (tree decl
)
3297 int saved_tree_used1
= TREE_USED (decl
);
3298 TREE_USED (decl
) = 1;
3299 if (DECL_NAME (DECL_RESULT (decl
)) != 0)
3301 int saved_tree_used2
= TREE_USED (DECL_RESULT (decl
));
3302 TREE_USED (DECL_RESULT (decl
)) = 1;
3303 dbxout_symbol (decl
, 0);
3304 TREE_USED (DECL_RESULT (decl
)) = saved_tree_used2
;
3307 dbxout_symbol (decl
, 0);
3308 TREE_USED (decl
) = saved_tree_used1
;
3310 dbxout_parms (DECL_ARGUMENTS (decl
));
3311 if (DECL_NAME (DECL_RESULT (decl
)) != 0)
3312 dbxout_symbol (DECL_RESULT (decl
), 1);
3314 #endif /* DBX_DEBUGGING_INFO */
3316 #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */
3318 #include "gt-dbxout.h"