X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Fdbxout.c;h=f6948a0bd72e1d18cb49a633caeab96785fc6504;hb=1b716045fc9e347b54af8e6c4b669dc8caff23b8;hp=683745fc56b54c899a350254f4a5a2c7ea7959d8;hpb=95f3173abcfe8227ced09e97239440e3ad3c4af4;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/dbxout.c b/gcc/dbxout.c index 683745fc56b..f6948a0bd72 100644 --- a/gcc/dbxout.c +++ b/gcc/dbxout.c @@ -1,6 +1,6 @@ /* Output dbx-format symbol table information from GNU compiler. Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998, - 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc. + 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc. This file is part of GCC. @@ -93,6 +93,15 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA #include "xcoffout.h" #endif +#undef DBXOUT_DECR_NESTING +#define DBXOUT_DECR_NESTING \ + if (--debug_nesting == 0 && symbol_queue_index > 0) \ + { emit_pending_bincls_if_required (); debug_flush_symbol_queue (); } + +#undef DBXOUT_DECR_NESTING_AND_RETURN +#define DBXOUT_DECR_NESTING_AND_RETURN(x) \ + do {--debug_nesting; return (x);} while (0) + #ifndef ASM_STABS_OP #define ASM_STABS_OP "\t.stabs\t" #endif @@ -137,6 +146,10 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA #define STABS_GCC_MARKER "gcc2_compiled." #endif +#ifndef NO_DBX_FUNCTION_END +#define NO_DBX_FUNCTION_END 0 +#endif + enum typestatus {TYPE_UNSEEN, TYPE_XREF, TYPE_DEFINED}; /* Structure recording information about a C data type. @@ -170,52 +183,90 @@ static GTY(()) int typevec_len; static GTY(()) int next_type_number; +/* The C front end may call dbxout_symbol before dbxout_init runs. + We save all such decls in this list and output them when we get + to dbxout_init. */ + +static GTY(()) tree preinit_symbols; + +enum binclstatus {BINCL_NOT_REQUIRED, BINCL_PENDING, BINCL_PROCESSED}; + /* When using N_BINCL in dbx output, each type number is actually a pair of the file number and the type number within the file. This is a stack of input files. */ -struct dbx_file GTY(()) +struct dbx_file { struct dbx_file *next; int file_number; int next_type_number; + enum binclstatus bincl_status; /* Keep track of lazy bincl. */ + const char *pending_bincl_name; /* Name of bincl. */ + struct dbx_file *prev; /* Chain to traverse all pending bincls. */ }; -/* This is the top of the stack. */ - -static GTY(()) struct dbx_file *current_file; +/* This is the top of the stack. + + This is not saved for PCH, because restoring a PCH should not change it. + next_file_number does have to be saved, because the PCH may use some + file numbers; however, just before restoring a PCH, next_file_number + should always be 0 because we should not have needed any file numbers + yet. */ + +#if (defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)) \ + && defined (DBX_USE_BINCL) +static struct dbx_file *current_file; +#endif /* This is the next file number to use. */ static GTY(()) int next_file_number; -/* Typical USG systems don't have stab.h, and they also have - no use for DBX-format debugging info. */ +/* A counter for dbxout_function_end. */ -#if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO) +static GTY(()) int scope_labelno; -/* Last source file name mentioned in a NOTE insn. */ +/* A counter for dbxout_source_line. */ -static const char *lastfile; - -/* Current working directory. */ - -static const char *cwd; +static GTY(()) int dbxout_source_line_counter; /* Nonzero if we have actually used any of the GDB extensions to the debugging format. The idea is that we use them for the first time only if there's a strong reason, but once we have done that, we use them whenever convenient. */ -static int have_used_extensions = 0; +static GTY(()) int have_used_extensions = 0; /* Number for the next N_SOL filename stabs label. The number 0 is reserved for the N_SO filename stabs label. */ -#if defined (DBX_DEBUGGING_INFO) && !defined (DBX_OUTPUT_SOURCE_FILENAME) -static int source_label_number = 1; +static GTY(()) int source_label_number = 1; + +/* Last source file name mentioned in a NOTE insn. */ + +static GTY(()) const char *lastfile; + +/* Used by PCH machinery to detect if 'lastfile' should be reset to + base_input_file. */ +static GTY(()) int lastfile_is_base; + +/* Typical USG systems don't have stab.h, and they also have + no use for DBX-format debugging info. */ + +#if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO) + +#ifdef DBX_USE_BINCL +/* If zero then there is no pending BINCL. */ +static int pending_bincls = 0; #endif +/* The original input file name. */ +static const char *base_input_file; + +/* Current working directory. */ + +static const char *cwd; + #ifdef DEBUG_SYMS_TEXT #define FORCE_TEXT function_section (current_function_decl); #else @@ -229,7 +280,7 @@ static int source_label_number = 1; /* 1 if PARM is passed to this function in memory. */ #define PARM_PASSED_IN_MEMORY(PARM) \ - (GET_CODE (DECL_INCOMING_RTL (PARM)) == MEM) + (MEM_P (DECL_INCOMING_RTL (PARM))) /* A C expression for the integer offset value of an automatic variable (N_LSYM) having address X (an RTX). */ @@ -285,44 +336,53 @@ static int current_sym_nchars; #define CONTIN do { } while (0) #endif -static void dbxout_init PARAMS ((const char *)); -static void dbxout_finish PARAMS ((const char *)); -static void dbxout_start_source_file PARAMS ((unsigned, const char *)); -static void dbxout_end_source_file PARAMS ((unsigned)); -static void dbxout_typedefs PARAMS ((tree)); -static void dbxout_fptype_value PARAMS ((tree)); -static void dbxout_type_index PARAMS ((tree)); +#ifdef DBX_USE_BINCL +static void emit_bincl_stab (const char *c); +static void emit_pending_bincls (void); +#endif +static inline void emit_pending_bincls_if_required (void); + +static void dbxout_init (const char *); +static void dbxout_finish (const char *); +static void dbxout_start_source_file (unsigned, const char *); +static void dbxout_end_source_file (unsigned); +static void dbxout_typedefs (tree); +static void dbxout_type_index (tree); #if DBX_CONTIN_LENGTH > 0 -static void dbxout_continue PARAMS ((void)); +static void dbxout_continue (void); #endif -static void dbxout_args PARAMS ((tree)); -static void dbxout_type_fields PARAMS ((tree)); -static void dbxout_type_method_1 PARAMS ((tree, const char *)); -static void dbxout_type_methods PARAMS ((tree)); -static void dbxout_range_type PARAMS ((tree)); -static void dbxout_type PARAMS ((tree, int)); -static void print_int_cst_octal PARAMS ((tree)); -static void print_octal PARAMS ((unsigned HOST_WIDE_INT, int)); -static void print_wide_int PARAMS ((HOST_WIDE_INT)); -static void dbxout_type_name PARAMS ((tree)); -static void dbxout_class_name_qualifiers PARAMS ((tree)); -static int dbxout_symbol_location PARAMS ((tree, tree, const char *, rtx)); -static void dbxout_symbol_name PARAMS ((tree, const char *, int)); -static void dbxout_prepare_symbol PARAMS ((tree)); -static void dbxout_finish_symbol PARAMS ((tree)); -static void dbxout_block PARAMS ((tree, int, tree)); -static void dbxout_global_decl PARAMS ((tree)); +static void dbxout_args (tree); +static void dbxout_type_fields (tree); +static void dbxout_type_method_1 (tree, const char *); +static void dbxout_type_methods (tree); +static void dbxout_range_type (tree); +static void dbxout_type (tree, int); +static bool print_int_cst_bounds_in_octal_p (tree); +static void print_int_cst_octal (tree); +static void print_octal (unsigned HOST_WIDE_INT, int); +static void print_wide_int (HOST_WIDE_INT); +static void dbxout_type_name (tree); +static void dbxout_class_name_qualifiers (tree); +static int dbxout_symbol_location (tree, tree, const char *, rtx); +static void dbxout_symbol_name (tree, const char *, int); +static void dbxout_prepare_symbol (tree); +static void dbxout_finish_symbol (tree); +static void dbxout_block (tree, int, tree); +static void dbxout_global_decl (tree); +static void dbxout_type_decl (tree, int); +static void dbxout_handle_pch (unsigned); /* The debug hooks structure. */ #if defined (DBX_DEBUGGING_INFO) -static void dbxout_source_line PARAMS ((unsigned int, const char *)); -static void dbxout_source_file PARAMS ((FILE *, const char *)); -static void dbxout_function_end PARAMS ((void)); -static void dbxout_begin_function PARAMS ((tree)); -static void dbxout_begin_block PARAMS ((unsigned, unsigned)); -static void dbxout_end_block PARAMS ((unsigned, unsigned)); -static void dbxout_function_decl PARAMS ((tree)); +static void dbxout_source_line (unsigned int, const char *); +static void dbxout_begin_prologue (unsigned int, const char *); +static void dbxout_source_file (FILE *, const char *); +static void dbxout_function_end (void); +static void dbxout_begin_function (tree); +static void dbxout_begin_block (unsigned, unsigned); +static void dbxout_end_block (unsigned, unsigned); +static void dbxout_function_decl (tree); const struct gcc_debug_hooks dbx_debug_hooks = { @@ -334,22 +394,26 @@ const struct gcc_debug_hooks dbx_debug_hooks = dbxout_end_source_file, dbxout_begin_block, dbxout_end_block, - debug_true_tree, /* ignore_block */ - dbxout_source_line, /* source_line */ - dbxout_source_line, /* begin_prologue: just output line info */ - debug_nothing_int_charstar, /* end_prologue */ - debug_nothing_int_charstar, /* end_epilogue */ + debug_true_tree, /* ignore_block */ + dbxout_source_line, /* source_line */ + dbxout_begin_prologue, /* begin_prologue */ + debug_nothing_int_charstar, /* end_prologue */ + debug_nothing_int_charstar, /* end_epilogue */ #ifdef DBX_FUNCTION_FIRST dbxout_begin_function, #else - debug_nothing_tree, /* begin_function */ + debug_nothing_tree, /* begin_function */ #endif - debug_nothing_int, /* end_function */ + debug_nothing_int, /* end_function */ dbxout_function_decl, - dbxout_global_decl, /* global_decl */ - debug_nothing_tree, /* deferred_inline_function */ - debug_nothing_tree, /* outlining_inline_function */ - debug_nothing_rtx /* label */ + dbxout_global_decl, /* global_decl */ + dbxout_type_decl, /* type_decl */ + debug_nothing_tree_tree, /* imported_module_or_decl */ + debug_nothing_tree, /* deferred_inline_function */ + debug_nothing_tree, /* outlining_inline_function */ + debug_nothing_rtx, /* label */ + dbxout_handle_pch, /* handle_pch */ + debug_nothing_rtx /* var_location */ }; #endif /* DBX_DEBUGGING_INFO */ @@ -364,34 +428,50 @@ const struct gcc_debug_hooks xcoff_debug_hooks = dbxout_end_source_file, xcoffout_begin_block, xcoffout_end_block, - debug_true_tree, /* ignore_block */ + debug_true_tree, /* ignore_block */ xcoffout_source_line, - xcoffout_begin_prologue, /* begin_prologue */ - debug_nothing_int_charstar, /* end_prologue */ + xcoffout_begin_prologue, /* begin_prologue */ + debug_nothing_int_charstar, /* end_prologue */ xcoffout_end_epilogue, - debug_nothing_tree, /* begin_function */ + debug_nothing_tree, /* begin_function */ xcoffout_end_function, - debug_nothing_tree, /* function_decl */ - dbxout_global_decl, /* global_decl */ - debug_nothing_tree, /* deferred_inline_function */ - debug_nothing_tree, /* outlining_inline_function */ - debug_nothing_rtx /* label */ + debug_nothing_tree, /* function_decl */ + dbxout_global_decl, /* global_decl */ + dbxout_type_decl, /* type_decl */ + debug_nothing_tree_tree, /* imported_module_or_decl */ + debug_nothing_tree, /* deferred_inline_function */ + debug_nothing_tree, /* outlining_inline_function */ + debug_nothing_rtx, /* label */ + dbxout_handle_pch, /* handle_pch */ + debug_nothing_rtx /* var_location */ }; #endif /* XCOFF_DEBUGGING_INFO */ #if defined (DBX_DEBUGGING_INFO) static void -dbxout_function_end () +dbxout_function_end (void) { - static int scope_labelno = 0; char lscope_label_name[100]; + + /* The Lscope label must be emitted even if we aren't doing anything + else; dbxout_block needs it. */ + function_section (current_function_decl); + /* Convert Ltext into the appropriate format for local labels in case the system doesn't insert underscores in front of user generated labels. */ ASM_GENERATE_INTERNAL_LABEL (lscope_label_name, "Lscope", scope_labelno); - (*targetm.asm_out.internal_label) (asmfile, "Lscope", scope_labelno); + targetm.asm_out.internal_label (asmfile, "Lscope", scope_labelno); scope_labelno++; + /* The N_FUN tag at the end of the function is a GNU extension, + which may be undesirable, and is unnecessary if we do not have + named sections. */ + if (!use_gnu_debug_info_extensions + || NO_DBX_FUNCTION_END + || !targetm.have_named_sections) + return; + /* By convention, GCC will mark the end of a function with an N_FUN symbol and an empty string. */ #ifdef DBX_OUTPUT_NFUN @@ -403,6 +483,9 @@ dbxout_function_end () assemble_name (asmfile, XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0)); fprintf (asmfile, "\n"); #endif + + if (!flag_debug_only_used_symbols) + fprintf (asmfile, "%s%d,0,0\n", ASM_STABD_OP, N_ENSYM); } #endif /* DBX_DEBUGGING_INFO */ @@ -410,16 +493,15 @@ dbxout_function_end () Initialize `typevec' and output the standard data types of C. */ static void -dbxout_init (input_file_name) - const char *input_file_name; +dbxout_init (const char *input_file_name) { char ltext_label_name[100]; - tree syms = (*lang_hooks.decls.getdecls) (); + tree syms = lang_hooks.decls.getdecls (); asmfile = asm_out_file; typevec_len = 100; - typevec = (struct typeinfo *) ggc_calloc (typevec_len, sizeof typevec[0]); + typevec = ggc_calloc (typevec_len, sizeof typevec[0]); /* Convert Ltext into the appropriate format for local labels in case the system doesn't insert underscores in front of user generated @@ -427,12 +509,10 @@ dbxout_init (input_file_name) ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext", 0); /* Put the current working directory in an N_SO symbol. */ -#ifndef DBX_WORKING_DIRECTORY /* Only some versions of DBX want this, - but GDB always does. */ if (use_gnu_debug_info_extensions) -#endif { - if (!cwd && (cwd = getpwd ()) && (!*cwd || cwd[strlen (cwd) - 1] != '/')) + if (!cwd && (cwd = get_src_pwd ()) + && (!*cwd || cwd[strlen (cwd) - 1] != '/')) cwd = concat (cwd, FILE_NAME_JOINER, NULL); if (cwd) { @@ -449,8 +529,6 @@ dbxout_init (input_file_name) } #ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME - /* This should NOT be DBX_OUTPUT_SOURCE_FILENAME. That - would give us an N_SOL, and we want an N_SO. */ DBX_OUTPUT_MAIN_SOURCE_FILENAME (asmfile, input_file_name); #else /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */ /* We include outputting `Ltext:' here, @@ -462,7 +540,7 @@ dbxout_init (input_file_name) assemble_name (asmfile, ltext_label_name); fputc ('\n', asmfile); text_section (); - (*targetm.asm_out.internal_label) (asmfile, "Ltext", 0); + targetm.asm_out.internal_label (asmfile, "Ltext", 0); #endif /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */ #ifdef DBX_OUTPUT_GCC_MARKER @@ -473,105 +551,190 @@ dbxout_init (input_file_name) ASM_STABS_OP, STABS_GCC_MARKER, N_OPT); #endif - lastfile = input_file_name; + base_input_file = lastfile = input_file_name; next_type_number = 1; #ifdef DBX_USE_BINCL - current_file = (struct dbx_file *) ggc_alloc (sizeof *current_file); + current_file = xmalloc (sizeof *current_file); current_file->next = NULL; current_file->file_number = 0; current_file->next_type_number = 1; next_file_number = 1; + current_file->prev = NULL; + current_file->bincl_status = BINCL_NOT_REQUIRED; + current_file->pending_bincl_name = NULL; #endif - /* Make sure that types `int' and `char' have numbers 1 and 2. - Definitions of other integer types will refer to those numbers. - (Actually it should no longer matter what their numbers are. - Also, if any types with tags have been defined, dbxout_symbol - will output them first, so the numbers won't be 1 and 2. That - happens in C++. So it's a good thing it should no longer matter). */ - -#ifdef DBX_OUTPUT_STANDARD_TYPES - DBX_OUTPUT_STANDARD_TYPES (syms); -#else - dbxout_symbol (TYPE_NAME (integer_type_node), 0); - dbxout_symbol (TYPE_NAME (char_type_node), 0); -#endif - - /* Get all permanent types that have typedef names, - and output them all, except for those already output. */ - + /* Get all permanent types that have typedef names, and output them + all, except for those already output. Some language front ends + put these declarations in the top-level scope; some do not; + the latter are responsible for calling debug_hooks->type_decl from + their record_builtin_type function. */ dbxout_typedefs (syms); + + if (preinit_symbols) + { + tree t; + for (t = nreverse (preinit_symbols); t; t = TREE_CHAIN (t)) + dbxout_symbol (TREE_VALUE (t), 0); + preinit_symbols = 0; + } } -/* Output any typedef names for types described by TYPE_DECLs in SYMS, - in the reverse order from that which is found in SYMS. */ +/* Output any typedef names for types described by TYPE_DECLs in SYMS. */ static void -dbxout_typedefs (syms) - tree syms; +dbxout_typedefs (tree syms) { - if (syms) + for (; syms != NULL_TREE; syms = TREE_CHAIN (syms)) { - dbxout_typedefs (TREE_CHAIN (syms)); if (TREE_CODE (syms) == TYPE_DECL) { tree type = TREE_TYPE (syms); if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL - && COMPLETE_TYPE_P (type) + && COMPLETE_OR_VOID_TYPE_P (type) && ! TREE_ASM_WRITTEN (TYPE_NAME (type))) dbxout_symbol (TYPE_NAME (type), 0); } } } +#ifdef DBX_USE_BINCL +/* Emit BINCL stab using given name. */ +static void +emit_bincl_stab (const char *name) +{ + fprintf (asmfile, "%s", ASM_STABS_OP); + output_quoted_string (asmfile, name); + fprintf (asmfile, ",%d,0,0,0\n", N_BINCL); +} + +/* If there are pending bincls then it is time to emit all of them. */ + +static inline void +emit_pending_bincls_if_required (void) +{ + if (pending_bincls) + emit_pending_bincls (); +} + +/* Emit all pending bincls. */ + +static void +emit_pending_bincls (void) +{ + struct dbx_file *f = current_file; + + /* Find first pending bincl. */ + while (f->bincl_status == BINCL_PENDING) + f = f->next; + + /* Now emit all bincls. */ + f = f->prev; + + while (f) + { + if (f->bincl_status == BINCL_PENDING) + { + emit_bincl_stab (f->pending_bincl_name); + + /* Update file number and status. */ + f->file_number = next_file_number++; + f->bincl_status = BINCL_PROCESSED; + } + if (f == current_file) + break; + f = f->prev; + } + + /* All pending bincls have been emitted. */ + pending_bincls = 0; +} + +#else + +static inline void +emit_pending_bincls_if_required (void) {} +#endif + /* Change to reading from a new source file. Generate a N_BINCL stab. */ static void -dbxout_start_source_file (line, filename) - unsigned int line ATTRIBUTE_UNUSED; - const char *filename ATTRIBUTE_UNUSED; +dbxout_start_source_file (unsigned int line ATTRIBUTE_UNUSED, + const char *filename ATTRIBUTE_UNUSED) { #ifdef DBX_USE_BINCL - struct dbx_file *n = (struct dbx_file *) ggc_alloc (sizeof *n); + struct dbx_file *n = xmalloc (sizeof *n); n->next = current_file; - n->file_number = next_file_number++; n->next_type_number = 1; + /* Do not assign file number now. + Delay it until we actually emit BINCL. */ + n->file_number = 0; + n->prev = NULL; + current_file->prev = n; + n->bincl_status = BINCL_PENDING; + n->pending_bincl_name = filename; + pending_bincls = 1; current_file = n; - fprintf (asmfile, "%s", ASM_STABS_OP); - output_quoted_string (asmfile, filename); - fprintf (asmfile, ",%d,0,0,0\n", N_BINCL); #endif } /* Revert to reading a previous source file. Generate a N_EINCL stab. */ static void -dbxout_end_source_file (line) - unsigned int line ATTRIBUTE_UNUSED; +dbxout_end_source_file (unsigned int line ATTRIBUTE_UNUSED) { #ifdef DBX_USE_BINCL - fprintf (asmfile, "%s%d,0,0,0\n", ASM_STABN_OP, N_EINCL); + /* Emit EINCL stab only if BINCL is not pending. */ + if (current_file->bincl_status == BINCL_PROCESSED) + fprintf (asmfile, "%s%d,0,0,0\n", ASM_STABN_OP, N_EINCL); + current_file->bincl_status = BINCL_NOT_REQUIRED; current_file = current_file->next; #endif } +/* Handle a few odd cases that occur when trying to make PCH files work. */ + +static void +dbxout_handle_pch (unsigned at_end) +{ + if (! at_end) + { + /* When using the PCH, this file will be included, so we need to output + a BINCL. */ + dbxout_start_source_file (0, lastfile); + + /* The base file when using the PCH won't be the same as + the base file when it's being generated. */ + lastfile = NULL; + } + else + { + /* ... and an EINCL. */ + dbxout_end_source_file (0); + + /* Deal with cases where 'lastfile' was never actually changed. */ + lastfile_is_base = lastfile == NULL; + } +} + #if defined (DBX_DEBUGGING_INFO) /* Output debugging info to FILE to switch to sourcefile FILENAME. */ static void -dbxout_source_file (file, filename) - FILE *file; - const char *filename; +dbxout_source_file (FILE *file, const char *filename) { + if (lastfile == 0 && lastfile_is_base) + { + lastfile = base_input_file; + lastfile_is_base = 0; + } + if (filename && (lastfile == 0 || strcmp (filename, lastfile))) { -#ifdef DBX_OUTPUT_SOURCE_FILENAME - DBX_OUTPUT_SOURCE_FILENAME (file, filename); -#else char ltext_label_name[100]; ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext", @@ -585,26 +748,40 @@ dbxout_source_file (file, filename) && DECL_SECTION_NAME (current_function_decl) != NULL_TREE) ; /* Don't change section amid function. */ else - text_section (); - (*targetm.asm_out.internal_label) (file, "Ltext", source_label_number); + { + if (!in_text_section () && !in_unlikely_text_section ()) + text_section (); + } + targetm.asm_out.internal_label (file, "Ltext", source_label_number); source_label_number++; -#endif lastfile = filename; } } +/* Output N_BNSYM and line number symbol entry. */ + +static void +dbxout_begin_prologue (unsigned int lineno, const char *filename) +{ + if (use_gnu_debug_info_extensions + && !NO_DBX_FUNCTION_END + && !flag_debug_only_used_symbols) + fprintf (asmfile, "%s%d,0,0\n", ASM_STABD_OP, N_BNSYM); + + dbxout_source_line (lineno, filename); +} + /* Output a line number symbol entry for source file FILENAME and line number LINENO. */ static void -dbxout_source_line (lineno, filename) - unsigned int lineno; - const char *filename; +dbxout_source_line (unsigned int lineno, const char *filename) { dbxout_source_file (asmfile, filename); #ifdef ASM_OUTPUT_SOURCE_LINE - ASM_OUTPUT_SOURCE_LINE (asmfile, lineno); + dbxout_source_line_counter += 1; + ASM_OUTPUT_SOURCE_LINE (asmfile, lineno, dbxout_source_line_counter); #else fprintf (asmfile, "%s%d,0,%d\n", ASM_STABD_OP, N_SLINE, lineno); #endif @@ -613,21 +790,19 @@ dbxout_source_line (lineno, filename) /* Describe the beginning of an internal block within a function. */ static void -dbxout_begin_block (line, n) - unsigned int line ATTRIBUTE_UNUSED; - unsigned int n; +dbxout_begin_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int n) { - (*targetm.asm_out.internal_label) (asmfile, "LBB", n); + emit_pending_bincls_if_required (); + targetm.asm_out.internal_label (asmfile, "LBB", n); } /* Describe the end line-number of an internal block within a function. */ static void -dbxout_end_block (line, n) - unsigned int line ATTRIBUTE_UNUSED; - unsigned int n; +dbxout_end_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int n) { - (*targetm.asm_out.internal_label) (asmfile, "LBE", n); + emit_pending_bincls_if_required (); + targetm.asm_out.internal_label (asmfile, "LBE", n); } /* Output dbx data for a function definition. @@ -637,9 +812,9 @@ dbxout_end_block (line, n) (including all the auto variables of the function). */ static void -dbxout_function_decl (decl) - tree decl; +dbxout_function_decl (tree decl) { + emit_pending_bincls_if_required (); #ifndef DBX_FUNCTION_FIRST dbxout_begin_function (decl); #endif @@ -647,12 +822,7 @@ dbxout_function_decl (decl) #ifdef DBX_OUTPUT_FUNCTION_END DBX_OUTPUT_FUNCTION_END (asmfile, decl); #endif - if (use_gnu_debug_info_extensions -#if defined(NO_DBX_FUNCTION_END) - && ! NO_DBX_FUNCTION_END -#endif - && targetm.have_named_sections) - dbxout_function_end (); + dbxout_function_end (); } #endif /* DBX_DEBUGGING_INFO */ @@ -660,13 +830,25 @@ dbxout_function_decl (decl) /* Debug information for a global DECL. Called from toplev.c after compilation proper has finished. */ static void -dbxout_global_decl (decl) - tree decl; +dbxout_global_decl (tree decl) { if (TREE_CODE (decl) == VAR_DECL && ! DECL_EXTERNAL (decl) && DECL_RTL_SET_P (decl)) /* Not necessary? */ - dbxout_symbol (decl, 0); + { + int saved_tree_used = TREE_USED (decl); + TREE_USED (decl) = 1; + dbxout_symbol (decl, 0); + TREE_USED (decl) = saved_tree_used; + } +} + +/* This is just a function-type adapter; dbxout_symbol does exactly + what we want but returns an int. */ +static void +dbxout_type_decl (tree decl, int local) +{ + dbxout_symbol (decl, local); } /* At the end of compilation, finish writing the symbol table. @@ -674,74 +856,19 @@ dbxout_global_decl (decl) to do nothing. */ static void -dbxout_finish (filename) - const char *filename ATTRIBUTE_UNUSED; +dbxout_finish (const char *filename ATTRIBUTE_UNUSED) { #ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END DBX_OUTPUT_MAIN_SOURCE_FILE_END (asmfile, filename); #endif /* DBX_OUTPUT_MAIN_SOURCE_FILE_END */ -} - -/* Output floating point type values used by the 'R' stab letter. - These numbers come from include/aout/stab_gnu.h in binutils/gdb. - - There are only 3 real/complex types defined, and we need 7/6. - We use NF_SINGLE as a generic float type, and NF_COMPLEX as a generic - complex type. Since we have the type size anyways, we don't really need - to distinguish between different FP types, we only need to distinguish - between float and complex. This works fine with gdb. - - We only use this for complex types, to avoid breaking backwards - compatibility for real types. complex types aren't in ISO C90, so it is - OK if old debuggers don't understand the debug info we emit for them. */ - -/* ??? These are supposed to be IEEE types, but we don't check for that. - We could perhaps add additional numbers for non-IEEE types if we need - them. */ - -static void -dbxout_fptype_value (type) - tree type; -{ - char value = '0'; - enum machine_mode mode = TYPE_MODE (type); - - if (TREE_CODE (type) == REAL_TYPE) - { - if (mode == SFmode) - value = '1'; - else if (mode == DFmode) - value = '2'; - else if (mode == TFmode || mode == XFmode) - value = '6'; - else - /* Use NF_SINGLE as a generic real type for other sizes. */ - value = '1'; - } - else if (TREE_CODE (type) == COMPLEX_TYPE) - { - if (mode == SCmode) - value = '3'; - else if (mode == DCmode) - value = '4'; - else if (mode == TCmode || mode == XCmode) - value = '5'; - else - /* Use NF_COMPLEX as a generic complex type for other sizes. */ - value = '3'; - } - else - abort (); - putc (value, asmfile); - CHARS (1); + debug_free_queue (); } /* Output the index of a type. */ static void -dbxout_type_index (type) - tree type; +dbxout_type_index (tree type) { #ifndef DBX_USE_BINCL fprintf (asmfile, "%d", TYPE_SYMTAB_ADDRESS (type)); @@ -761,8 +888,9 @@ dbxout_type_index (type) .stabs "...rest",code,0,value */ static void -dbxout_continue () +dbxout_continue (void) { + emit_pending_bincls_if_required (); #ifdef DBX_CONTIN_CHAR fprintf (asmfile, "%c", DBX_CONTIN_CHAR); #else @@ -779,8 +907,7 @@ dbxout_continue () recursive calls. */ static void -dbxout_type_fields (type) - tree type; +dbxout_type_fields (tree type) { tree tem; @@ -788,6 +915,11 @@ dbxout_type_fields (type) field that we can support. */ for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem)) { + /* If one of the nodes is an error_mark or its type is then + return early. */ + if (tem == error_mark_node || TREE_TYPE (tem) == error_mark_node) + return; + /* Omit here local type decls until we know how to support them. */ if (TREE_CODE (tem) == TYPE_DECL /* Omit fields whose position or size are variable or too large to @@ -870,9 +1002,7 @@ dbxout_type_fields (type) now. */ static void -dbxout_type_method_1 (decl, debug_name) - tree decl; - const char *debug_name; +dbxout_type_method_1 (tree decl, const char *debug_name) { char c1 = 'A', c2; @@ -917,8 +1047,7 @@ dbxout_type_method_1 (decl, debug_name) in TYPE. */ static void -dbxout_type_methods (type) - tree type; +dbxout_type_methods (tree type) { /* C++: put out the method names and their parameter lists */ tree methods = TYPE_METHODS (type); @@ -1023,8 +1152,7 @@ dbxout_type_methods (type) TYPE is an INTEGER_TYPE. */ static void -dbxout_range_type (type) - tree type; +dbxout_range_type (tree type) { fprintf (asmfile, "r"); if (TREE_TYPE (type)) @@ -1056,7 +1184,10 @@ dbxout_range_type (type) { putc (';', asmfile); CHARS (1); - print_wide_int (tree_low_cst (TYPE_MIN_VALUE (type), 0)); + if (print_int_cst_bounds_in_octal_p (type)) + print_int_cst_octal (TYPE_MIN_VALUE (type)); + else + print_wide_int (tree_low_cst (TYPE_MIN_VALUE (type), 0)); } else { @@ -1069,7 +1200,10 @@ dbxout_range_type (type) { putc (';', asmfile); CHARS (1); - print_wide_int (tree_low_cst (TYPE_MAX_VALUE (type), 0)); + if (print_int_cst_bounds_in_octal_p (type)) + print_int_cst_octal (TYPE_MAX_VALUE (type)); + else + print_wide_int (tree_low_cst (TYPE_MAX_VALUE (type), 0)); putc (';', asmfile); CHARS (1); } @@ -1080,6 +1214,7 @@ dbxout_range_type (type) } } + /* Output a reference to a type. If the type has not yet been described in the dbx output, output its definition now. For a type already defined, just refer to its definition @@ -1091,9 +1226,7 @@ dbxout_range_type (type) using the number previously allocated. */ static void -dbxout_type (type, full) - tree type; - int full; +dbxout_type (tree type, int full) { tree tem; tree main_variant; @@ -1139,15 +1272,13 @@ dbxout_type (type, full) if (next_type_number == typevec_len) { typevec - = (struct typeinfo *) ggc_realloc (typevec, - (typevec_len * 2 - * sizeof typevec[0])); - memset ((char *) (typevec + typevec_len), 0, - typevec_len * sizeof typevec[0]); + = ggc_realloc (typevec, (typevec_len * 2 * sizeof typevec[0])); + memset (typevec + typevec_len, 0, typevec_len * sizeof typevec[0]); typevec_len *= 2; } #ifdef DBX_USE_BINCL + emit_pending_bincls_if_required (); typevec[TYPE_SYMTAB_ADDRESS (type)].file_number = current_file->file_number; typevec[TYPE_SYMTAB_ADDRESS (type)].type_number @@ -1155,6 +1286,21 @@ dbxout_type (type, full) #endif } + if (flag_debug_only_used_symbols) + { + if ((TREE_CODE (type) == RECORD_TYPE + || TREE_CODE (type) == UNION_TYPE + || TREE_CODE (type) == QUAL_UNION_TYPE + || TREE_CODE (type) == ENUMERAL_TYPE) + && TYPE_STUB_DECL (type) + && TREE_CODE_CLASS (TREE_CODE (TYPE_STUB_DECL (type))) == 'd' + && ! DECL_IGNORED_P (TYPE_STUB_DECL (type))) + debug_queue_symbol (TYPE_STUB_DECL (type)); + else if (TYPE_NAME (type) + && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL) + debug_queue_symbol (TYPE_NAME (type)); + } + /* Output the number of this type, to refer to it. */ dbxout_type_index (type); @@ -1238,6 +1384,18 @@ dbxout_type (type, full) } else if (main_variant != TYPE_MAIN_VARIANT (type)) { + if (flag_debug_only_used_symbols) + { + tree orig_type = DECL_ORIGINAL_TYPE (TYPE_NAME (type)); + + if ((TREE_CODE (orig_type) == RECORD_TYPE + || TREE_CODE (orig_type) == UNION_TYPE + || TREE_CODE (orig_type) == QUAL_UNION_TYPE + || TREE_CODE (orig_type) == ENUMERAL_TYPE) + && TYPE_STUB_DECL (orig_type) + && ! DECL_IGNORED_P (TYPE_STUB_DECL (orig_type))) + debug_queue_symbol (TYPE_STUB_DECL (orig_type)); + } /* 'type' is a typedef; output the type it refers to. */ dbxout_type (DECL_ORIGINAL_TYPE (TYPE_NAME (type)), 0); return; @@ -1257,7 +1415,7 @@ dbxout_type (type, full) break; case INTEGER_TYPE: - if (type == char_type_node && ! TREE_UNSIGNED (type)) + if (type == char_type_node && ! TYPE_UNSIGNED (type)) { /* Output the type `char' as a subrange of itself! I don't understand this definition, just copied it @@ -1303,34 +1461,21 @@ dbxout_type (type, full) CHARS (5); } - /* If we can use GDB extensions and the size is wider than a - long (the size used by GDB to read them) or we may have - trouble writing the bounds the usual way, write them in - octal. Note the test is for the *target's* size of "long", - not that of the host. The host test is just to make sure we - can write it out in case the host wide int is narrower than the - target "long". */ - - /* For unsigned types, we use octal if they are the same size or - larger. This is because we print the bounds as signed decimal, - and hence they can't span same size unsigned types. */ - - if (use_gnu_debug_info_extensions - && TYPE_MIN_VALUE (type) != 0 - && TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST - && TYPE_MAX_VALUE (type) != 0 - && TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST - && (TYPE_PRECISION (type) > TYPE_PRECISION (integer_type_node) - || ((TYPE_PRECISION (type) - == TYPE_PRECISION (integer_type_node)) - && TREE_UNSIGNED (type)) - || TYPE_PRECISION (type) > HOST_BITS_PER_WIDE_INT - || (TYPE_PRECISION (type) == HOST_BITS_PER_WIDE_INT - && TREE_UNSIGNED (type)))) + if (print_int_cst_bounds_in_octal_p (type)) { fprintf (asmfile, "r"); CHARS (1); - dbxout_type_index (type); + + /* If this type derives from another type, output type index of + parent type. This is particularly important when parent type + is an enumerated type, because not generating the parent type + index would transform the definition of this enumerated type + into a plain unsigned type. */ + if (TREE_TYPE (type) != 0) + dbxout_type_index (TREE_TYPE (type)); + else + dbxout_type_index (type); + fprintf (asmfile, ";"); CHARS (1); print_int_cst_octal (TYPE_MIN_VALUE (type)); @@ -1378,7 +1523,7 @@ dbxout_type (type, full) fprintf (asmfile, "r"); CHARS (1); dbxout_type_index (char_type_node); - fprintf (asmfile, ";0;%d;", TREE_UNSIGNED (type) ? 255 : 127); + fprintf (asmfile, ";0;%d;", TYPE_UNSIGNED (type) ? 255 : 127); CHARS (7); } break; @@ -1407,15 +1552,14 @@ dbxout_type (type, full) break; case COMPLEX_TYPE: - /* Differs from the REAL_TYPE by its new data type number */ + /* Differs from the REAL_TYPE by its new data type number. + R3 is NF_COMPLEX. We don't try to use any of the other NF_* + codes since gdb doesn't care anyway. */ if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE) { - putc ('R', asmfile); - CHARS (1); - dbxout_fptype_value (type); - putc (';', asmfile); - CHARS (1); + fputs ("R3;", asmfile); + CHARS (3); print_wide_int (2 * int_size_in_bytes (TREE_TYPE (type))); fputs (";0;", asmfile); CHARS (3); @@ -1514,12 +1658,7 @@ dbxout_type (type, full) case UNION_TYPE: case QUAL_UNION_TYPE: { - int i, n_baseclasses = 0; - - if (TYPE_BINFO (type) != 0 - && TREE_CODE (TYPE_BINFO (type)) == TREE_VEC - && TYPE_BINFO_BASETYPES (type) != 0) - n_baseclasses = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type)); + tree binfo = TYPE_BINFO (type); /* Output a structure type. We must use the same test here as we use in the DBX_NO_XREFS case above. */ @@ -1566,65 +1705,72 @@ dbxout_type (type, full) CHARS (1); print_wide_int (int_size_in_bytes (type)); - if (use_gnu_debug_info_extensions) - { - if (n_baseclasses) - { - have_used_extensions = 1; - fprintf (asmfile, "!%d,", n_baseclasses); - CHARS (8); - } - } - for (i = 0; i < n_baseclasses; i++) + if (binfo) { - tree binfo = TYPE_BINFO (type); - tree child = BINFO_BASETYPE (binfo, i); - tree access = (BINFO_BASEACCESSES (binfo) - ? BINFO_BASEACCESS (binfo, i) : access_public_node); + int i; + tree child; + VEC (tree) *accesses = BINFO_BASE_ACCESSES (binfo); if (use_gnu_debug_info_extensions) { - have_used_extensions = 1; - putc (TREE_VIA_VIRTUAL (child) ? '1' : '0', asmfile); - putc (access == access_public_node ? '2' : '0', asmfile); - CHARS (2); - if (TREE_VIA_VIRTUAL (child) - && strcmp (lang_hooks.name, "GNU C++") == 0) - /* For a virtual base, print the (negative) offset within - the vtable where we must look to find the necessary - adjustment. */ - print_wide_int (tree_low_cst (BINFO_VPTR_FIELD (child), 0) - * BITS_PER_UNIT); - else - print_wide_int (tree_low_cst (BINFO_OFFSET (child), 0) - * BITS_PER_UNIT); - putc (',', asmfile); - CHARS (1); - dbxout_type (BINFO_TYPE (child), 0); - putc (';', asmfile); - CHARS (1); + if (BINFO_N_BASE_BINFOS (binfo)) + { + have_used_extensions = 1; + fprintf (asmfile, "!%u,", BINFO_N_BASE_BINFOS (binfo)); + CHARS (8); + } } - else + for (i = 0; BINFO_BASE_ITERATE (binfo, i, child); i++) { - /* Print out the base class information with fields - which have the same names at the types they hold. */ - dbxout_type_name (BINFO_TYPE (child)); - putc (':', asmfile); - CHARS (1); - dbxout_type (BINFO_TYPE (child), full); - putc (',', asmfile); - CHARS (1); - print_wide_int (tree_low_cst (BINFO_OFFSET (child), 0) - * BITS_PER_UNIT); - putc (',', asmfile); - CHARS (1); - print_wide_int (tree_low_cst (DECL_SIZE - (TYPE_NAME - (BINFO_TYPE (child))), - 0) - * BITS_PER_UNIT); - putc (';', asmfile); - CHARS (1); + tree access = (accesses ? VEC_index (tree, accesses, i) + : access_public_node); + + if (use_gnu_debug_info_extensions) + { + have_used_extensions = 1; + putc (BINFO_VIRTUAL_P (child) ? '1' : '0', asmfile); + putc (access == access_public_node ? '2' : + (access == access_protected_node ? '1' :'0'), + asmfile); + CHARS (2); + if (BINFO_VIRTUAL_P (child) + && strcmp (lang_hooks.name, "GNU C++") == 0) + /* For a virtual base, print the (negative) + offset within the vtable where we must look + to find the necessary adjustment. */ + print_wide_int + (tree_low_cst (BINFO_VPTR_FIELD (child), 0) + * BITS_PER_UNIT); + else + print_wide_int (tree_low_cst (BINFO_OFFSET (child), 0) + * BITS_PER_UNIT); + putc (',', asmfile); + CHARS (1); + dbxout_type (BINFO_TYPE (child), 0); + putc (';', asmfile); + CHARS (1); + } + else + { + /* Print out the base class information with + fields which have the same names at the types + they hold. */ + dbxout_type_name (BINFO_TYPE (child)); + putc (':', asmfile); + CHARS (1); + dbxout_type (BINFO_TYPE (child), full); + putc (',', asmfile); + CHARS (1); + print_wide_int (tree_low_cst (BINFO_OFFSET (child), 0) + * BITS_PER_UNIT); + putc (',', asmfile); + CHARS (1); + print_wide_int + (tree_low_cst (TYPE_SIZE (BINFO_TYPE (child)), 0) + * BITS_PER_UNIT); + putc (';', asmfile); + CHARS (1); + } } } } @@ -1684,9 +1830,6 @@ dbxout_type (type, full) CHARS (1); return; } -#ifdef DBX_OUTPUT_ENUM - DBX_OUTPUT_ENUM (asmfile, type); -#else if (use_gnu_debug_info_extensions && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node)) { @@ -1716,7 +1859,6 @@ dbxout_type (type, full) putc (';', asmfile); CHARS (1); -#endif break; case POINTER_TYPE: @@ -1781,12 +1923,44 @@ dbxout_type (type, full) } } +/* Return nonzero if the given type represents an integer whose bounds + should be printed in octal format. */ + +static bool +print_int_cst_bounds_in_octal_p (tree type) +{ + /* If we can use GDB extensions and the size is wider than a long + (the size used by GDB to read them) or we may have trouble writing + the bounds the usual way, write them in octal. Note the test is for + the *target's* size of "long", not that of the host. The host test + is just to make sure we can write it out in case the host wide int + is narrower than the target "long". + + For unsigned types, we use octal if they are the same size or larger. + This is because we print the bounds as signed decimal, and hence they + can't span same size unsigned types. */ + + if (use_gnu_debug_info_extensions + && TYPE_MIN_VALUE (type) != 0 + && TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST + && TYPE_MAX_VALUE (type) != 0 + && TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST + && (TYPE_PRECISION (type) > TYPE_PRECISION (integer_type_node) + || ((TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)) + && TYPE_UNSIGNED (type)) + || TYPE_PRECISION (type) > HOST_BITS_PER_WIDE_INT + || (TYPE_PRECISION (type) == HOST_BITS_PER_WIDE_INT + && TYPE_UNSIGNED (type)))) + return TRUE; + else + return FALSE; +} + /* Print the value of integer constant C, in octal, handling double precision. */ static void -print_int_cst_octal (c) - tree c; +print_int_cst_octal (tree c) { unsigned HOST_WIDE_INT high = TREE_INT_CST_HIGH (c); unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (c); @@ -1831,9 +2005,7 @@ print_int_cst_octal (c) } static void -print_octal (value, digits) - unsigned HOST_WIDE_INT value; - int digits; +print_octal (unsigned HOST_WIDE_INT value, int digits) { int i; @@ -1846,8 +2018,7 @@ print_octal (value, digits) /* Output C in decimal while adjusting the number of digits written. */ static void -print_wide_int (c) - HOST_WIDE_INT c; +print_wide_int (HOST_WIDE_INT c) { int digs = 0; @@ -1867,8 +2038,7 @@ print_wide_int (c) or by struct, enum and union tags. */ static void -dbxout_type_name (type) - tree type; +dbxout_type_name (tree type) { tree t; if (TYPE_NAME (type) == 0) @@ -1892,19 +2062,20 @@ dbxout_type_name (type) type whose scope is limited to a struct or class. */ static void -dbxout_class_name_qualifiers (decl) - tree decl; +dbxout_class_name_qualifiers (tree decl) { tree context = decl_type_context (decl); - if (context != NULL_TREE + if (context != NULL_TREE && TREE_CODE(context) == RECORD_TYPE - && TYPE_NAME (context) != 0 + && TYPE_NAME (context) != 0 && (TREE_CODE (TYPE_NAME (context)) == IDENTIFIER_NODE || (DECL_NAME (TYPE_NAME (context)) != 0))) { tree name = TYPE_NAME (context); + emit_pending_bincls_if_required (); + if (TREE_CODE (name) == TYPE_DECL) { dbxout_class_name_qualifiers (name); @@ -1922,24 +2093,85 @@ dbxout_class_name_qualifiers (decl) Return 1 if a stabs might have been emitted. */ int -dbxout_symbol (decl, local) - tree decl; - int local ATTRIBUTE_UNUSED; +dbxout_symbol (tree decl, int local ATTRIBUTE_UNUSED) { tree type = TREE_TYPE (decl); tree context = NULL_TREE; int result = 0; - /* Cast avoids warning in old compilers. */ - current_sym_code = (STAB_CODE_TYPE) 0; - current_sym_value = 0; - current_sym_addr = 0; + /* "Intercept" dbxout_symbol() calls like we do all debug_hooks. */ + ++debug_nesting; /* Ignore nameless syms, but don't ignore type tags. */ if ((DECL_NAME (decl) == 0 && TREE_CODE (decl) != TYPE_DECL) || DECL_IGNORED_P (decl)) - return 0; + DBXOUT_DECR_NESTING_AND_RETURN (0); + + /* If we are to generate only the symbols actually used then such + symbol nodees are flagged with TREE_USED. Ignore any that + aren't flaged as TREE_USED. */ + + if (flag_debug_only_used_symbols + && (!TREE_USED (decl) + && (TREE_CODE (decl) != VAR_DECL || !DECL_INITIAL (decl)))) + DBXOUT_DECR_NESTING_AND_RETURN (0); + + /* If dbxout_init has not yet run, queue this symbol for later. */ + if (!typevec) + { + preinit_symbols = tree_cons (0, decl, preinit_symbols); + DBXOUT_DECR_NESTING_AND_RETURN (0); + } + + if (flag_debug_only_used_symbols) + { + tree t; + + /* We now have a used symbol. We need to generate the info for + the symbol's type in addition to the symbol itself. These + type symbols are queued to be generated after were done with + the symbol itself (done because the symbol's info is generated + with fprintf's, etc. as it determines what's needed). + + Note, because the TREE_TYPE(type) might be something like a + pointer to a named type we need to look for the first name + we see following the TREE_TYPE chain. */ + + t = type; + while (POINTER_TYPE_P (t)) + t = TREE_TYPE (t); + + /* RECORD_TYPE, UNION_TYPE, QUAL_UNION_TYPE, and ENUMERAL_TYPE + need special treatment. The TYPE_STUB_DECL field in these + types generally represents the tag name type we want to + output. In addition there could be a typedef type with + a different name. In that case we also want to output + that. */ + + if ((TREE_CODE (t) == RECORD_TYPE + || TREE_CODE (t) == UNION_TYPE + || TREE_CODE (t) == QUAL_UNION_TYPE + || TREE_CODE (t) == ENUMERAL_TYPE) + && TYPE_STUB_DECL (t) + && TYPE_STUB_DECL (t) != decl + && TREE_CODE_CLASS (TREE_CODE (TYPE_STUB_DECL (t))) == 'd' + && ! DECL_IGNORED_P (TYPE_STUB_DECL (t))) + { + debug_queue_symbol (TYPE_STUB_DECL (t)); + if (TYPE_NAME (t) + && TYPE_NAME (t) != TYPE_STUB_DECL (t) + && TYPE_NAME (t) != decl + && TREE_CODE_CLASS (TREE_CODE (TYPE_NAME (t))) == 'd') + debug_queue_symbol (TYPE_NAME (t)); + } + else if (TYPE_NAME (t) + && TYPE_NAME (t) != decl + && TREE_CODE_CLASS (TREE_CODE (TYPE_NAME (t))) == 'd') + debug_queue_symbol (TYPE_NAME (t)); + } + + emit_pending_bincls_if_required (); dbxout_prepare_symbol (decl); @@ -1957,14 +2189,14 @@ dbxout_symbol (decl, local) case FUNCTION_DECL: if (DECL_RTL (decl) == 0) - return 0; + DBXOUT_DECR_NESTING_AND_RETURN (0); if (DECL_EXTERNAL (decl)) break; /* Don't mention a nested function under its parent. */ context = decl_function_context (decl); if (context == current_function_decl) break; - if (GET_CODE (DECL_RTL (decl)) != MEM + if (!MEM_P (DECL_RTL (decl)) || GET_CODE (XEXP (DECL_RTL (decl), 0)) != SYMBOL_REF) break; FORCE_TEXT; @@ -1994,23 +2226,25 @@ dbxout_symbol (decl, local) break; case TYPE_DECL: -#if 0 - /* This seems all wrong. Outputting most kinds of types gives no name - at all. A true definition gives no name; a cross-ref for a - structure can give the tag name, but not a type name. - It seems that no typedef name is defined by outputting a type. */ - - /* If this typedef name was defined by outputting the type, - don't duplicate it. */ - if (typevec[TYPE_SYMTAB_ADDRESS (type)].status == TYPE_DEFINED - && TYPE_NAME (TREE_TYPE (decl)) == decl) - return 0; -#endif /* Don't output the same typedef twice. And don't output what language-specific stuff doesn't want output. */ if (TREE_ASM_WRITTEN (decl) || TYPE_DECL_SUPPRESS_DEBUG (decl)) - return 0; + DBXOUT_DECR_NESTING_AND_RETURN (0); + /* Don't output typedefs for types with magic type numbers (XCOFF). */ +#ifdef DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER + { + int fundamental_type_number = + DBX_ASSIGN_FUNDAMENTAL_TYPE_NUMBER (decl); + + if (fundamental_type_number != 0) + { + TREE_ASM_WRITTEN (decl) = 1; + TYPE_SYMTAB_ADDRESS (TREE_TYPE (decl)) = fundamental_type_number; + DBXOUT_DECR_NESTING_AND_RETURN (0); + } + } +#endif FORCE_TEXT; result = 1; { @@ -2035,6 +2269,8 @@ dbxout_symbol (decl, local) /* Distinguish the implicit typedefs of C++ from explicit ones that might be found in C. */ && DECL_ARTIFICIAL (decl) + /* Do not generate a tag for incomplete records. */ + && COMPLETE_TYPE_P (type) /* Do not generate a tag for records of variable size, since this type can not be properly described in the DBX format, and it confuses some tools such as objdump. */ @@ -2156,7 +2392,7 @@ dbxout_symbol (decl, local) /* Named return value, treat like a VAR_DECL. */ case VAR_DECL: if (! DECL_RTL_SET_P (decl)) - return 0; + DBXOUT_DECR_NESTING_AND_RETURN (0); /* Don't mention a variable that is external. Let the file that defines it describe it. */ if (DECL_EXTERNAL (decl)) @@ -2180,19 +2416,15 @@ dbxout_symbol (decl, local) || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE) { HOST_WIDE_INT ival = tree_low_cst (DECL_INITIAL (decl), 0); -#ifdef DBX_OUTPUT_CONSTANT_SYMBOL - DBX_OUTPUT_CONSTANT_SYMBOL (asmfile, name, ival); -#else - fprintf (asmfile, "%s\"%s:c=i", ASM_STABS_OP, name); - - fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, ival); - fprintf (asmfile, "\",0x%x,0,0,0\n", N_LSYM); -#endif + fprintf (asmfile, "%s\"%s:c=i" HOST_WIDE_INT_PRINT_DEC + "\",0x%x,0,0,0\n", + ASM_STABS_OP, name, ival, N_LSYM); + DBXOUT_DECR_NESTING; return 1; } else if (TREE_CODE (TREE_TYPE (decl)) == REAL_TYPE) { - /* don't know how to do this yet. */ + /* Don't know how to do this yet. */ } break; } @@ -2211,6 +2443,7 @@ dbxout_symbol (decl, local) default: break; } + DBXOUT_DECR_NESTING; return result; } @@ -2221,14 +2454,13 @@ dbxout_symbol (decl, local) Returns 1 if the stab was really emitted. */ static int -dbxout_symbol_location (decl, type, suffix, home) - tree decl, type; - const char *suffix; - rtx home; +dbxout_symbol_location (tree decl, tree type, const char *suffix, rtx home) { int letter = 0; int regno = -1; + emit_pending_bincls_if_required (); + /* Don't mention a variable at all if it was completely optimized into nothingness. @@ -2241,14 +2473,14 @@ dbxout_symbol_location (decl, type, suffix, home) while (GET_CODE (value) == SUBREG) value = SUBREG_REG (value); - if (GET_CODE (value) == REG) + if (REG_P (value)) { if (REGNO (value) >= FIRST_PSEUDO_REGISTER) return 0; } home = alter_subreg (&home); } - if (GET_CODE (home) == REG) + if (REG_P (home)) { regno = REGNO (home); if (regno >= FIRST_PSEUDO_REGISTER) @@ -2268,7 +2500,7 @@ dbxout_symbol_location (decl, type, suffix, home) no letter at all, and N_LSYM, for auto variable, r and N_RSYM for register variable. */ - if (GET_CODE (home) == MEM + if (MEM_P (home) && GET_CODE (XEXP (home, 0)) == SYMBOL_REF) { if (TREE_PUBLIC (decl)) @@ -2304,11 +2536,27 @@ dbxout_symbol_location (decl, type, suffix, home) if (GET_CODE (current_sym_addr) == SYMBOL_REF && CONSTANT_POOL_ADDRESS_P (current_sym_addr)) { - rtx tmp = get_pool_constant (current_sym_addr); + bool marked; + rtx tmp = get_pool_constant_mark (current_sym_addr, &marked); - if (GET_CODE (tmp) == SYMBOL_REF - || GET_CODE (tmp) == LABEL_REF) - current_sym_addr = tmp; + if (GET_CODE (tmp) == SYMBOL_REF) + { + current_sym_addr = tmp; + if (CONSTANT_POOL_ADDRESS_P (current_sym_addr)) + get_pool_constant_mark (current_sym_addr, &marked); + else + marked = true; + } + else if (GET_CODE (tmp) == LABEL_REF) + { + current_sym_addr = tmp; + marked = true; + } + + /* If all references to the constant pool were optimized + out, we just ignore the symbol. */ + if (!marked) + return 0; } /* Ultrix `as' seems to need this. */ @@ -2325,9 +2573,9 @@ dbxout_symbol_location (decl, type, suffix, home) current_sym_code = N_RSYM; current_sym_value = DBX_REGISTER_NUMBER (regno); } - else if (GET_CODE (home) == MEM - && (GET_CODE (XEXP (home, 0)) == MEM - || (GET_CODE (XEXP (home, 0)) == REG + else if (MEM_P (home) + && (MEM_P (XEXP (home, 0)) + || (REG_P (XEXP (home, 0)) && REGNO (XEXP (home, 0)) != HARD_FRAME_POINTER_REGNUM && REGNO (XEXP (home, 0)) != STACK_POINTER_REGNUM #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM @@ -2339,10 +2587,9 @@ dbxout_symbol_location (decl, type, suffix, home) then it means the object is variable-sized and address through that register or stack slot. DBX has no way to represent this so all we can do is output the variable as a pointer. - If it's not a parameter, ignore it. - (VAR_DECLs like this can be made by integrate.c.) */ + If it's not a parameter, ignore it. */ { - if (GET_CODE (XEXP (home, 0)) == REG) + if (REG_P (XEXP (home, 0))) { letter = 'r'; current_sym_code = N_RSYM; @@ -2366,13 +2613,13 @@ dbxout_symbol_location (decl, type, suffix, home) type = make_node (POINTER_TYPE); TREE_TYPE (type) = TREE_TYPE (decl); } - else if (GET_CODE (home) == MEM - && GET_CODE (XEXP (home, 0)) == REG) + else if (MEM_P (home) + && REG_P (XEXP (home, 0))) { current_sym_code = N_LSYM; current_sym_value = DEBUGGER_AUTO_OFFSET (XEXP (home, 0)); } - else if (GET_CODE (home) == MEM + else if (MEM_P (home) && GET_CODE (XEXP (home, 0)) == PLUS && GET_CODE (XEXP (XEXP (home, 0), 1)) == CONST_INT) { @@ -2381,7 +2628,7 @@ dbxout_symbol_location (decl, type, suffix, home) We want the value of that CONST_INT. */ current_sym_value = DEBUGGER_AUTO_OFFSET (XEXP (home, 0)); } - else if (GET_CODE (home) == MEM + else if (MEM_P (home) && GET_CODE (XEXP (home, 0)) == CONST) { /* Handle an obscure case which can arise when optimizing and @@ -2418,10 +2665,6 @@ dbxout_symbol_location (decl, type, suffix, home) else dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 0)); - /* Cast avoids warning in old compilers. */ - current_sym_code = (STAB_CODE_TYPE) 0; - current_sym_value = 0; - current_sym_addr = 0; dbxout_prepare_symbol (decl); if (WORDS_BIG_ENDIAN) @@ -2457,16 +2700,15 @@ dbxout_symbol_location (decl, type, suffix, home) Then output LETTER to indicate the kind of location the symbol has. */ static void -dbxout_symbol_name (decl, suffix, letter) - tree decl; - const char *suffix; - int letter; +dbxout_symbol_name (tree decl, const char *suffix, int letter) { const char *name; - if (DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl))) - /* One slight hitch: if this is a VAR_DECL which is a static - class member, we must put out the mangled name instead of the + if (DECL_CONTEXT (decl) + && (TYPE_P (DECL_CONTEXT (decl)) + || TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL)) + /* One slight hitch: if this is a VAR_DECL which is a class member + or a namespace member, we must put out the mangled name instead of the DECL_NAME. Note also that static member (variable) names DO NOT begin with underscores in .stabs directives. */ name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)); @@ -2485,19 +2727,25 @@ dbxout_symbol_name (decl, suffix, letter) } static void -dbxout_prepare_symbol (decl) - tree decl ATTRIBUTE_UNUSED; +dbxout_prepare_symbol (tree decl ATTRIBUTE_UNUSED) { #ifdef WINNING_GDB const char *filename = DECL_SOURCE_FILE (decl); dbxout_source_file (asmfile, filename); #endif + + /* Initialize variables used to communicate each symbol's debug + information to dbxout_finish_symbol with zeroes. */ + + /* Cast avoids warning in old compilers. */ + current_sym_code = (STAB_CODE_TYPE) 0; + current_sym_value = 0; + current_sym_addr = 0; } static void -dbxout_finish_symbol (sym) - tree sym; +dbxout_finish_symbol (tree sym) { #ifdef DBX_FINISH_SYMBOL DBX_FINISH_SYMBOL (sym); @@ -2519,8 +2767,7 @@ dbxout_finish_symbol (sym) anything was output */ int -dbxout_syms (syms) - tree syms; +dbxout_syms (tree syms) { int result = 0; while (syms) @@ -2544,11 +2791,17 @@ dbxout_syms (syms) of all the parms in PARMS, which is a chain of PARM_DECL nodes. */ void -dbxout_parms (parms) - tree parms; +dbxout_parms (tree parms) { + ++debug_nesting; + + emit_pending_bincls_if_required (); + for (; parms; parms = TREE_CHAIN (parms)) - if (DECL_NAME (parms) && TREE_TYPE (parms) != error_mark_node) + if (DECL_NAME (parms) + && TREE_TYPE (parms) != error_mark_node + && DECL_RTL_SET_P (parms) + && DECL_INCOMING_RTL (parms)) { dbxout_prepare_symbol (parms); @@ -2616,7 +2869,7 @@ dbxout_parms (parms) current_sym_value = DEBUGGER_ARG_OFFSET (current_sym_value, addr); dbxout_finish_symbol (parms); } - else if (GET_CODE (DECL_RTL (parms)) == REG) + else if (REG_P (DECL_RTL (parms))) { rtx best_rtl; char regparm_letter; @@ -2666,8 +2919,8 @@ dbxout_parms (parms) dbxout_type (parm_type, 0); dbxout_finish_symbol (parms); } - else if (GET_CODE (DECL_RTL (parms)) == MEM - && GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG + else if (MEM_P (DECL_RTL (parms)) + && REG_P (XEXP (DECL_RTL (parms), 0)) && REGNO (XEXP (DECL_RTL (parms), 0)) != HARD_FRAME_POINTER_REGNUM && REGNO (XEXP (DECL_RTL (parms), 0)) != STACK_POINTER_REGNUM #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM @@ -2720,8 +2973,8 @@ dbxout_parms (parms) dbxout_type (TREE_TYPE (parms), 0); dbxout_finish_symbol (parms); } - else if (GET_CODE (DECL_RTL (parms)) == MEM - && GET_CODE (XEXP (DECL_RTL (parms), 0)) == MEM) + else if (MEM_P (DECL_RTL (parms)) + && MEM_P (XEXP (DECL_RTL (parms), 0))) { /* Parm was passed via invisible reference, with the reference living on the stack. DECL_RTL looks like @@ -2730,7 +2983,7 @@ dbxout_parms (parms) const char *const decl_name = (DECL_NAME (parms) ? IDENTIFIER_POINTER (DECL_NAME (parms)) : "(anon)"); - if (GET_CODE (XEXP (XEXP (DECL_RTL (parms), 0), 0)) == REG) + if (REG_P (XEXP (XEXP (DECL_RTL (parms), 0), 0))) current_sym_value = 0; else current_sym_value @@ -2747,7 +3000,7 @@ dbxout_parms (parms) dbxout_type (TREE_TYPE (parms), 0); dbxout_finish_symbol (parms); } - else if (GET_CODE (DECL_RTL (parms)) == MEM + else if (MEM_P (DECL_RTL (parms)) && XEXP (DECL_RTL (parms), 0) != const0_rtx /* ??? A constant address for a parm can happen when the reg it lives in is equiv to a constant in memory. @@ -2761,7 +3014,7 @@ dbxout_parms (parms) in which case we want the value of that CONST_INT, or (MEM (REG ...)), in which case we use a value of zero. */ - if (GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG) + if (REG_P (XEXP (DECL_RTL (parms), 0))) current_sym_value = 0; else current_sym_value @@ -2804,6 +3057,7 @@ dbxout_parms (parms) dbxout_finish_symbol (parms); } } + DBXOUT_DECR_NESTING; } /* Output definitions for the places where parms live during the function, @@ -2818,9 +3072,10 @@ dbxout_parms (parms) PARMS is a chain of PARM_DECL nodes. */ void -dbxout_reg_parms (parms) - tree parms; +dbxout_reg_parms (tree parms) { + ++debug_nesting; + for (; parms; parms = TREE_CHAIN (parms)) if (DECL_NAME (parms) && PARM_PASSED_IN_MEMORY (parms)) { @@ -2828,7 +3083,7 @@ dbxout_reg_parms (parms) /* Report parms that live in registers during the function but were passed in memory. */ - if (GET_CODE (DECL_RTL (parms)) == REG + if (REG_P (DECL_RTL (parms)) && REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER) dbxout_symbol_location (parms, TREE_TYPE (parms), 0, DECL_RTL (parms)); @@ -2836,19 +3091,19 @@ dbxout_reg_parms (parms) dbxout_symbol_location (parms, TREE_TYPE (parms), 0, DECL_RTL (parms)); /* Report parms that live in memory but not where they were passed. */ - else if (GET_CODE (DECL_RTL (parms)) == MEM + else if (MEM_P (DECL_RTL (parms)) && ! rtx_equal_p (DECL_RTL (parms), DECL_INCOMING_RTL (parms))) dbxout_symbol_location (parms, TREE_TYPE (parms), 0, DECL_RTL (parms)); } + DBXOUT_DECR_NESTING; } /* Given a chain of ..._TYPE nodes (as come in a parameter list), output definitions of those names, in raw form */ static void -dbxout_args (args) - tree args; +dbxout_args (tree args) { while (args) { @@ -2859,6 +3114,46 @@ dbxout_args (args) } } +/* Subroutine of dbxout_block. Emit an N_LBRAC stab referencing LABEL. + BEGIN_LABEL is the name of the beginning of the function, which may + be required. */ +static void +dbx_output_lbrac (const char *label, + const char *begin_label ATTRIBUTE_UNUSED) +{ +#ifdef DBX_OUTPUT_LBRAC + DBX_OUTPUT_LBRAC (asmfile, label); +#else + fprintf (asmfile, "%s%d,0,0,", ASM_STABN_OP, N_LBRAC); + assemble_name (asmfile, label); +#if DBX_BLOCKS_FUNCTION_RELATIVE + putc ('-', asmfile); + assemble_name (asmfile, begin_label); +#endif + fprintf (asmfile, "\n"); +#endif +} + +/* Subroutine of dbxout_block. Emit an N_RBRAC stab referencing LABEL. + BEGIN_LABEL is the name of the beginning of the function, which may + be required. */ +static void +dbx_output_rbrac (const char *label, + const char *begin_label ATTRIBUTE_UNUSED) +{ +#ifdef DBX_OUTPUT_RBRAC + DBX_OUTPUT_RBRAC (asmfile, label); +#else + fprintf (asmfile, "%s%d,0,0,", ASM_STABN_OP, N_RBRAC); + assemble_name (asmfile, label); +#if DBX_BLOCKS_FUNCTION_RELATIVE + putc ('-', asmfile); + assemble_name (asmfile, begin_label); +#endif + fprintf (asmfile, "\n"); +#endif +} + /* Output everything about a symbol block (a BLOCK node that represents a scope level), including recursive output of contained blocks. @@ -2877,20 +3172,13 @@ dbxout_args (args) We handle them all in sequence. */ static void -dbxout_block (block, depth, args) - tree block; - int depth; - tree args; +dbxout_block (tree block, int depth, tree args) { - int blocknum = -1; - -#if DBX_BLOCKS_FUNCTION_RELATIVE const char *begin_label; if (current_function_func_begin_label != NULL_TREE) begin_label = IDENTIFIER_POINTER (current_function_func_begin_label); else begin_label = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0); -#endif while (block) { @@ -2898,10 +3186,8 @@ dbxout_block (block, depth, args) if (TREE_USED (block) && TREE_ASM_WRITTEN (block)) { int did_output; + int blocknum = BLOCK_NUMBER (block); -#ifdef DBX_LBRAC_FIRST - did_output = 1; -#else /* In dbx format, the syms of a block come before the N_LBRAC. If nothing is output, we don't need the N_LBRAC, either. */ did_output = 0; @@ -2909,17 +3195,25 @@ dbxout_block (block, depth, args) did_output = dbxout_syms (BLOCK_VARS (block)); if (args) dbxout_reg_parms (args); -#endif /* Now output an N_LBRAC symbol to represent the beginning of the block. Use the block's tree-walk order to generate the assembler symbols LBBn and LBEn that final will define around the code in this block. */ - if (depth > 0 && did_output) + if (did_output) { char buf[20]; - blocknum = BLOCK_NUMBER (block); - ASM_GENERATE_INTERNAL_LABEL (buf, "LBB", blocknum); + const char *scope_start; + + if (depth == 0) + /* The outermost block doesn't get LBB labels; use + the function symbol. */ + scope_start = begin_label; + else + { + ASM_GENERATE_INTERNAL_LABEL (buf, "LBB", blocknum); + scope_start = buf; + } if (BLOCK_HANDLER_BLOCK (block)) { @@ -2927,59 +3221,32 @@ dbxout_block (block, depth, args) tree decl = BLOCK_VARS (block); while (decl) { -#ifdef DBX_OUTPUT_CATCH - DBX_OUTPUT_CATCH (asmfile, decl, buf); -#else fprintf (asmfile, "%s\"%s:C1\",%d,0,0,", ASM_STABS_OP, IDENTIFIER_POINTER (DECL_NAME (decl)), N_CATCH); - assemble_name (asmfile, buf); + assemble_name (asmfile, scope_start); fprintf (asmfile, "\n"); -#endif decl = TREE_CHAIN (decl); } } - -#ifdef DBX_OUTPUT_LBRAC - DBX_OUTPUT_LBRAC (asmfile, buf); -#else - fprintf (asmfile, "%s%d,0,0,", ASM_STABN_OP, N_LBRAC); - assemble_name (asmfile, buf); -#if DBX_BLOCKS_FUNCTION_RELATIVE - putc ('-', asmfile); - assemble_name (asmfile, begin_label); -#endif - fprintf (asmfile, "\n"); -#endif + dbx_output_lbrac (scope_start, begin_label); } -#ifdef DBX_LBRAC_FIRST - /* On some weird machines, the syms of a block - come after the N_LBRAC. */ - if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0) - dbxout_syms (BLOCK_VARS (block)); - if (args) - dbxout_reg_parms (args); -#endif - /* Output the subblocks. */ dbxout_block (BLOCK_SUBBLOCKS (block), depth + 1, NULL_TREE); /* Refer to the marker for the end of the block. */ - if (depth > 0 && did_output) + if (did_output) { - char buf[20]; - ASM_GENERATE_INTERNAL_LABEL (buf, "LBE", blocknum); -#ifdef DBX_OUTPUT_RBRAC - DBX_OUTPUT_RBRAC (asmfile, buf); -#else - fprintf (asmfile, "%s%d,0,0,", ASM_STABN_OP, N_RBRAC); - assemble_name (asmfile, buf); -#if DBX_BLOCKS_FUNCTION_RELATIVE - putc ('-', asmfile); - assemble_name (asmfile, begin_label); -#endif - fprintf (asmfile, "\n"); -#endif + char buf[100]; + if (depth == 0) + /* The outermost block doesn't get LBE labels; + use the "scope" label which will be emitted + by dbxout_function_end. */ + ASM_GENERATE_INTERNAL_LABEL (buf, "Lscope", scope_labelno); + else + ASM_GENERATE_INTERNAL_LABEL (buf, "LBE", blocknum); + + dbx_output_rbrac (buf, begin_label); } } block = BLOCK_CHAIN (block); @@ -2992,10 +3259,21 @@ dbxout_block (block, depth, args) #if defined (DBX_DEBUGGING_INFO) static void -dbxout_begin_function (decl) - tree decl; +dbxout_begin_function (tree decl) { - dbxout_symbol (decl, 0); + int saved_tree_used1 = TREE_USED (decl); + TREE_USED (decl) = 1; + if (DECL_NAME (DECL_RESULT (decl)) != 0) + { + int saved_tree_used2 = TREE_USED (DECL_RESULT (decl)); + TREE_USED (DECL_RESULT (decl)) = 1; + dbxout_symbol (decl, 0); + TREE_USED (DECL_RESULT (decl)) = saved_tree_used2; + } + else + dbxout_symbol (decl, 0); + TREE_USED (decl) = saved_tree_used1; + dbxout_parms (DECL_ARGUMENTS (decl)); if (DECL_NAME (DECL_RESULT (decl)) != 0) dbxout_symbol (DECL_RESULT (decl), 1);