X-Git-Url: http://git.sourceforge.jp/view?p=pf3gnuchains%2Fgcc-fork.git;a=blobdiff_plain;f=gcc%2Fdbxout.c;h=6383d48d0e9434c4ab905713c66a3e1150eff16e;hp=9d27fa7c72afe4efff738001c291681526cf48b5;hb=66f900025b8d2e912a9c254d539b991683e52312;hpb=5ffa81d96ae779c9d0371db78aec8c899c664fec diff --git a/gcc/dbxout.c b/gcc/dbxout.c index 9d27fa7c72a..6383d48d0e9 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 Free Software Foundation, Inc. + 1999, 2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc. This file is part of GCC. @@ -70,6 +70,8 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA #include "config.h" #include "system.h" +#include "coretypes.h" +#include "tm.h" #include "tree.h" #include "rtl.h" @@ -77,7 +79,7 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA #include "regs.h" #include "insn-config.h" #include "reload.h" -#include "output.h" /* ASM_OUTPUT_SOURCE_LINE may refer to sdb functions. */ +#include "output.h" #include "dbxout.h" #include "toplev.h" #include "tm_p.h" @@ -86,19 +88,35 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA #include "function.h" #include "target.h" #include "langhooks.h" +#include "obstack.h" #ifdef XCOFF_DEBUGGING_INFO #include "xcoffout.h" #endif +#define DBXOUT_DECR_NESTING \ + if (--debug_nesting == 0 && symbol_queue_index > 0) \ + { emit_pending_bincls_if_required (); debug_flush_symbol_queue (); } + +#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" +# ifdef XCOFF_DEBUGGING_INFO +# define ASM_STABS_OP "\t.stabx\t" +# else +# define ASM_STABS_OP "\t.stabs\t" +# endif #endif #ifndef ASM_STABN_OP #define ASM_STABN_OP "\t.stabn\t" #endif +#ifndef ASM_STABD_OP +#define ASM_STABD_OP "\t.stabd\t" +#endif + #ifndef DBX_TYPE_DECL_STABS_CODE #define DBX_TYPE_DECL_STABS_CODE N_LSYM #endif @@ -115,85 +133,34 @@ Software Foundation, 59 Temple Place - Suite 330, Boston, MA #define DBX_REGPARM_STABS_LETTER 'P' #endif -/* This is used for parameters passed by invisible reference in a register. */ -#ifndef GDB_INV_REF_REGPARM_STABS_LETTER -#define GDB_INV_REF_REGPARM_STABS_LETTER 'a' +#ifndef NO_DBX_FUNCTION_END +#define NO_DBX_FUNCTION_END 0 #endif -#ifndef DBX_MEMPARM_STABS_LETTER -#define DBX_MEMPARM_STABS_LETTER 'p' +#ifndef NO_DBX_BNSYM_ENSYM +#define NO_DBX_BNSYM_ENSYM 0 #endif -#ifndef FILE_NAME_JOINER -#define FILE_NAME_JOINER "/" +#ifndef NO_DBX_MAIN_SOURCE_DIRECTORY +#define NO_DBX_MAIN_SOURCE_DIRECTORY 0 #endif -/* GDB needs to know that the stabs were generated by GCC. We emit an - N_OPT stab at the beginning of the source file to indicate this. - The string is historical, and different on a very few targets. */ -#ifndef STABS_GCC_MARKER -#define STABS_GCC_MARKER "gcc2_compiled." -#endif - -/* 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) - -/* 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; - -/* 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; +#ifndef DBX_BLOCKS_FUNCTION_RELATIVE +#define DBX_BLOCKS_FUNCTION_RELATIVE 0 #endif -#ifdef DEBUG_SYMS_TEXT -#define FORCE_TEXT function_section (current_function_decl); -#else -#define FORCE_TEXT +#ifndef DBX_LINES_FUNCTION_RELATIVE +#define DBX_LINES_FUNCTION_RELATIVE 0 #endif -#include "gstab.h" - -#define STAB_CODE_TYPE enum __stab_debug_code - -/* 1 if PARM is passed to this function in memory. */ - -#define PARM_PASSED_IN_MEMORY(PARM) \ - (GET_CODE (DECL_INCOMING_RTL (PARM)) == MEM) - -/* A C expression for the integer offset value of an automatic variable - (N_LSYM) having address X (an RTX). */ -#ifndef DEBUGGER_AUTO_OFFSET -#define DEBUGGER_AUTO_OFFSET(X) \ - (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0) +#ifndef DBX_CONTIN_LENGTH +#define DBX_CONTIN_LENGTH 80 #endif -/* A C expression for the integer offset value of an argument (N_PSYM) - having address X (an RTX). The nominal offset is OFFSET. */ -#ifndef DEBUGGER_ARG_OFFSET -#define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET) +#ifndef DBX_CONTIN_CHAR +#define DBX_CONTIN_CHAR '\\' #endif -/* Stream for writing to assembler file. */ - -static FILE *asmfile; - -/* Last source file name mentioned in a NOTE insn. */ - -static const char *lastfile; - -/* Current working directory. */ - -static const char *cwd; - enum typestatus {TYPE_UNSEEN, TYPE_XREF, TYPE_DEFINED}; /* Structure recording information about a C data type. @@ -203,13 +170,11 @@ enum typestatus {TYPE_UNSEEN, TYPE_XREF, TYPE_DEFINED}; The file_number and type_number elements are used if DBX_USE_BINCL is defined. */ -struct typeinfo +struct typeinfo GTY(()) { enum typestatus status; -#ifdef DBX_USE_BINCL int file_number; int type_number; -#endif }; /* Vector recording information about C data types. @@ -217,19 +182,25 @@ struct typeinfo we assign it a number using next_type_number. That is its index in this vector. */ -struct typeinfo *typevec; +static GTY ((length ("typevec_len"))) struct typeinfo *typevec; /* Number of elements of space allocated in `typevec'. */ -static int typevec_len; +static GTY(()) int typevec_len; /* In dbx output, each type gets a unique number. This is the number for the next type output. The number, once assigned, is in the TYPE_SYMTAB_ADDRESS field. */ -static int next_type_number; +static GTY(()) int next_type_number; -#ifdef DBX_USE_BINCL +/* 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. @@ -240,92 +211,143 @@ 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. */ +/* 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 int next_file_number; +static GTY(()) int next_file_number; -#endif /* DBX_USE_BINCL */ +/* A counter for dbxout_function_end. */ -/* These variables are for dbxout_symbol to communicate to - dbxout_finish_symbol. - current_sym_code is the symbol-type-code, a symbol N_... define in stab.h. - current_sym_value and current_sym_addr are two ways to address the - value to store in the symtab entry. - current_sym_addr if nonzero represents the value as an rtx. - If that is zero, current_sym_value is used. This is used - when the value is an offset (such as for auto variables, - register variables and parms). */ +static GTY(()) int scope_labelno; -static STAB_CODE_TYPE current_sym_code; -static int current_sym_value; -static rtx current_sym_addr; +/* A counter for dbxout_source_line. */ -/* Number of chars of symbol-description generated so far for the - current symbol. Used by CHARS and CONTIN. */ +static GTY(()) int dbxout_source_line_counter; -static int current_sym_nchars; +/* 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. */ -/* Report having output N chars of the current symbol-description. */ +static GTY(()) int have_used_extensions = 0; -#define CHARS(N) (current_sym_nchars += (N)) +/* Number for the next N_SOL filename stabs label. The number 0 is reserved + for the N_SO filename stabs label. */ -/* Break the current symbol-description, generating a continuation, - if it has become long. */ +static GTY(()) int source_label_number = 1; -#ifndef DBX_CONTIN_LENGTH -#define DBX_CONTIN_LENGTH 80 +/* 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 -#if DBX_CONTIN_LENGTH > 0 -#define CONTIN \ - do {if (current_sym_nchars > DBX_CONTIN_LENGTH) dbxout_continue ();} while (0) +/* The original input file name. */ +static const char *base_input_file; + +#ifdef DEBUG_SYMS_TEXT +#define FORCE_TEXT function_section (current_function_decl); #else -#define CONTIN do { } while (0) +#define FORCE_TEXT #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_type_index PARAMS ((tree)); -#if DBX_CONTIN_LENGTH > 0 -static void dbxout_continue PARAMS ((void)); +#include "gstab.h" + +#define STAB_CODE_TYPE enum __stab_debug_code + +/* 1 if PARM is passed to this function in memory. */ + +#define PARM_PASSED_IN_MEMORY(PARM) \ + (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). */ +#ifndef DEBUGGER_AUTO_OFFSET +#define DEBUGGER_AUTO_OFFSET(X) \ + (GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0) +#endif + +/* A C expression for the integer offset value of an argument (N_PSYM) + having address X (an RTX). The nominal offset is OFFSET. */ +#ifndef DEBUGGER_ARG_OFFSET +#define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET) +#endif + +/* This obstack holds the stab string currently being constructed. We + build it up here, then write it out, so we can split long lines up + properly (see dbxout_finish_complex_stabs). */ +static struct obstack stabstr_ob; +static size_t stabstr_last_contin_point; + +#ifdef DBX_USE_BINCL +static void emit_bincl_stab (const char *c); +static void emit_pending_bincls (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 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); +static void dbxout_args (tree); +static void dbxout_type_fields (tree); +static void dbxout_type_method_1 (tree); +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 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_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 (const char *); +static void dbxout_function_end (tree); +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 = { @@ -337,22 +359,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 */ @@ -367,62 +393,595 @@ 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 */ +/* Numeric formatting helper macro. Note that this does not handle + hexadecimal. */ +#define NUMBER_FMT_LOOP(P, NUM, BASE) \ + do \ + { \ + int digit = NUM % BASE; \ + NUM /= BASE; \ + *--P = digit + '0'; \ + } \ + while (NUM > 0) + +/* Utility: write a decimal integer NUM to asm_out_file. */ +void +dbxout_int (int num) +{ + char buf[64]; + char *p = buf + sizeof buf; + unsigned int unum; + + if (num == 0) + { + putc ('0', asm_out_file); + return; + } + if (num < 0) + { + putc ('-', asm_out_file); + unum = -num; + } + else + unum = num; + + NUMBER_FMT_LOOP (p, unum, 10); + + while (p < buf + sizeof buf) + { + putc (*p, asm_out_file); + p++; + } +} + + +/* Primitives for emitting simple stabs directives. All other stabs + routines should use these functions instead of directly emitting + stabs. They are exported because machine-dependent code may need + to invoke them, e.g. in a DBX_OUTPUT_* macro whose definition + forwards to code in CPU.c. */ + +/* The following functions should all be called immediately after one + of the dbxout_begin_stab* functions (below). They write out + various things as the value of a stab. */ + +/* Write out a literal zero as the value of a stab. */ +void +dbxout_stab_value_zero (void) +{ + fputs ("0\n", asm_out_file); +} + +/* Write out the label LABEL as the value of a stab. */ +void +dbxout_stab_value_label (const char *label) +{ + assemble_name (asm_out_file, label); + putc ('\n', asm_out_file); +} + +/* Write out the difference of two labels, LABEL - BASE, as the value + of a stab. */ +void +dbxout_stab_value_label_diff (const char *label, const char *base) +{ + assemble_name (asm_out_file, label); + putc ('-', asm_out_file); + assemble_name (asm_out_file, base); + putc ('\n', asm_out_file); +} + +/* Write out an internal label as the value of a stab, and immediately + emit that internal label. This should be used only when + dbxout_stabd will not work. STEM is the name stem of the label, + COUNTERP is a pointer to a counter variable which will be used to + guarantee label uniqueness. */ +void +dbxout_stab_value_internal_label (const char *stem, int *counterp) +{ + char label[100]; + int counter = counterp ? (*counterp)++ : 0; + + ASM_GENERATE_INTERNAL_LABEL (label, stem, counter); + dbxout_stab_value_label (label); + targetm.asm_out.internal_label (asm_out_file, stem, counter); +} + +/* Write out the difference between BASE and an internal label as the + value of a stab, and immediately emit that internal label. STEM and + COUNTERP are as for dbxout_stab_value_internal_label. */ +void +dbxout_stab_value_internal_label_diff (const char *stem, int *counterp, + const char *base) +{ + char label[100]; + int counter = counterp ? (*counterp)++ : 0; + + ASM_GENERATE_INTERNAL_LABEL (label, stem, counter); + dbxout_stab_value_label_diff (label, base); + targetm.asm_out.internal_label (asm_out_file, stem, counter); +} + +/* The following functions produce specific kinds of stab directives. */ + +/* Write a .stabd directive with type STYPE and desc SDESC to asm_out_file. */ +void +dbxout_stabd (int stype, int sdesc) +{ + fputs (ASM_STABD_OP, asm_out_file); + dbxout_int (stype); + fputs (",0,", asm_out_file); + dbxout_int (sdesc); + putc ('\n', asm_out_file); +} + +/* Write a .stabn directive with type STYPE. This function stops + short of emitting the value field, which is the responsibility of + the caller (normally it will be either a symbol or the difference + of two symbols). */ + +void +dbxout_begin_stabn (int stype) +{ + fputs (ASM_STABN_OP, asm_out_file); + dbxout_int (stype); + fputs (",0,0,", asm_out_file); +} + +/* Write a .stabn directive with type N_SLINE and desc LINE. As above, + the value field is the responsibility of the caller. */ +void +dbxout_begin_stabn_sline (int lineno) +{ + fputs (ASM_STABN_OP, asm_out_file); + dbxout_int (N_SLINE); + fputs (",0,", asm_out_file); + dbxout_int (lineno); + putc (',', asm_out_file); +} + +/* Begin a .stabs directive with string "", type STYPE, and desc and + other fields 0. The value field is the responsibility of the + caller. This function cannot be used for .stabx directives. */ +void +dbxout_begin_empty_stabs (int stype) +{ + fputs (ASM_STABS_OP, asm_out_file); + fputs ("\"\",", asm_out_file); + dbxout_int (stype); + fputs (",0,0,", asm_out_file); +} + +/* Begin a .stabs directive with string STR, type STYPE, and desc 0. + The value field is the responsibility of the caller. */ +void +dbxout_begin_simple_stabs (const char *str, int stype) +{ + fputs (ASM_STABS_OP, asm_out_file); + output_quoted_string (asm_out_file, str); + putc (',', asm_out_file); + dbxout_int (stype); + fputs (",0,0,", asm_out_file); +} + +/* As above but use SDESC for the desc field. */ +void +dbxout_begin_simple_stabs_desc (const char *str, int stype, int sdesc) +{ + fputs (ASM_STABS_OP, asm_out_file); + output_quoted_string (asm_out_file, str); + putc (',', asm_out_file); + dbxout_int (stype); + fputs (",0,", asm_out_file); + dbxout_int (sdesc); + putc (',', asm_out_file); +} + +/* The next set of functions are entirely concerned with production of + "complex" .stabs directives: that is, .stabs directives whose + strings have to be constructed piecemeal. dbxout_type, + dbxout_symbol, etc. use these routines heavily. The string is queued + up in an obstack, then written out by dbxout_finish_complex_stabs, which + is also responsible for splitting it up if it exceeds DBX_CONTIN_LENGTH. + (You might think it would be more efficient to go straight to stdio + when DBX_CONTIN_LENGTH is 0 (i.e. no length limit) but that turns + out not to be the case, and anyway this needs fewer #ifdefs.) */ + +/* Begin a complex .stabs directive. If we can, write the initial + ASM_STABS_OP to the asm_out_file. */ + +static void +dbxout_begin_complex_stabs (void) +{ + emit_pending_bincls_if_required (); + FORCE_TEXT; + fputs (ASM_STABS_OP, asm_out_file); + putc ('"', asm_out_file); + gcc_assert (stabstr_last_contin_point == 0); +} + +/* As above, but do not force text or emit pending bincls. This is + used by dbxout_symbol_location, which needs to do something else. */ +static void +dbxout_begin_complex_stabs_noforcetext (void) +{ + fputs (ASM_STABS_OP, asm_out_file); + putc ('"', asm_out_file); + gcc_assert (stabstr_last_contin_point == 0); +} + +/* Add CHR, a single character, to the string being built. */ +#define stabstr_C(chr) obstack_1grow (&stabstr_ob, chr) + +/* Add STR, a normal C string, to the string being built. */ +#define stabstr_S(str) obstack_grow (&stabstr_ob, str, strlen(str)) + +/* Add the text of ID, an IDENTIFIER_NODE, to the string being built. */ +#define stabstr_I(id) obstack_grow (&stabstr_ob, \ + IDENTIFIER_POINTER (id), \ + IDENTIFIER_LENGTH (id)) + +/* Add NUM, a signed decimal number, to the string being built. */ +static void +stabstr_D (HOST_WIDE_INT num) +{ + char buf[64]; + char *p = buf + sizeof buf; + unsigned int unum; + + if (num == 0) + { + stabstr_C ('0'); + return; + } + if (num < 0) + { + stabstr_C ('-'); + unum = -num; + } + else + unum = num; + + NUMBER_FMT_LOOP (p, unum, 10); + + obstack_grow (&stabstr_ob, p, (buf + sizeof buf) - p); +} + +/* Add NUM, an unsigned decimal number, to the string being built. */ +static void +stabstr_U (unsigned HOST_WIDE_INT num) +{ + char buf[64]; + char *p = buf + sizeof buf; + if (num == 0) + { + stabstr_C ('0'); + return; + } + NUMBER_FMT_LOOP (p, num, 10); + obstack_grow (&stabstr_ob, p, (buf + sizeof buf) - p); +} + +/* Add CST, an INTEGER_CST tree, to the string being built as an + unsigned octal number. This routine handles values which are + larger than a single HOST_WIDE_INT. */ +static void +stabstr_O (tree cst) +{ + unsigned HOST_WIDE_INT high = TREE_INT_CST_HIGH (cst); + unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (cst); + + char buf[128]; + char *p = buf + sizeof buf; + + /* GDB wants constants with no extra leading "1" bits, so + we need to remove any sign-extension that might be + present. */ + { + const unsigned int width = TYPE_PRECISION (TREE_TYPE (cst)); + if (width == HOST_BITS_PER_WIDE_INT * 2) + ; + else if (width > HOST_BITS_PER_WIDE_INT) + high &= (((HOST_WIDE_INT) 1 << (width - HOST_BITS_PER_WIDE_INT)) - 1); + else if (width == HOST_BITS_PER_WIDE_INT) + high = 0; + else + high = 0, low &= (((HOST_WIDE_INT) 1 << width) - 1); + } + + /* Leading zero for base indicator. */ + stabstr_C ('0'); + + /* If the value is zero, the base indicator will serve as the value + all by itself. */ + if (high == 0 && low == 0) + return; + + /* If the high half is zero, we need only print the low half normally. */ + if (high == 0) + NUMBER_FMT_LOOP (p, low, 8); + else + { + /* When high != 0, we need to print enough zeroes from low to + give the digits from high their proper place-values. Hence + NUMBER_FMT_LOOP cannot be used. */ + const int n_digits = HOST_BITS_PER_WIDE_INT / 3; + int i; + + for (i = 1; i <= n_digits; i++) + { + unsigned int digit = low % 8; + low /= 8; + *--p = '0' + digit; + } + + /* Octal digits carry exactly three bits of information. The + width of a HOST_WIDE_INT is not normally a multiple of three. + Therefore, the next digit printed probably needs to carry + information from both low and high. */ + if (HOST_BITS_PER_WIDE_INT % 3 != 0) + { + const int n_leftover_bits = HOST_BITS_PER_WIDE_INT % 3; + const int n_bits_from_high = 3 - n_leftover_bits; + + const unsigned HOST_WIDE_INT + low_mask = (((unsigned HOST_WIDE_INT)1) << n_leftover_bits) - 1; + const unsigned HOST_WIDE_INT + high_mask = (((unsigned HOST_WIDE_INT)1) << n_bits_from_high) - 1; + + unsigned int digit; + + /* At this point, only the bottom n_leftover_bits bits of low + should be set. */ + gcc_assert (!(low & ~low_mask)); + + digit = (low | ((high & high_mask) << n_leftover_bits)); + high >>= n_bits_from_high; + + *--p = '0' + digit; + } + + /* Now we can format high in the normal manner. However, if + the only bits of high that were set were handled by the + digit split between low and high, high will now be zero, and + we don't want to print extra digits in that case. */ + if (high) + NUMBER_FMT_LOOP (p, high, 8); + } + + obstack_grow (&stabstr_ob, p, (buf + sizeof buf) - p); +} + +/* Called whenever it is safe to break a stabs string into multiple + .stabs directives. If the current string has exceeded the limit + set by DBX_CONTIN_LENGTH, mark the current position in the buffer + as a continuation point by inserting DBX_CONTIN_CHAR (doubled if + it is a backslash) and a null character. */ +static inline void +stabstr_continue (void) +{ + if (DBX_CONTIN_LENGTH > 0 + && obstack_object_size (&stabstr_ob) - stabstr_last_contin_point + > DBX_CONTIN_LENGTH) + { + if (DBX_CONTIN_CHAR == '\\') + obstack_1grow (&stabstr_ob, '\\'); + obstack_1grow (&stabstr_ob, DBX_CONTIN_CHAR); + obstack_1grow (&stabstr_ob, '\0'); + stabstr_last_contin_point = obstack_object_size (&stabstr_ob); + } +} +#define CONTIN stabstr_continue () + +/* Macro subroutine of dbxout_finish_complex_stabs, which emits + all of the arguments to the .stabs directive after the string. + Overridden by xcoffout.h. CODE is the stabs code for this symbol; + LINE is the source line to write into the desc field (in extended + mode); SYM is the symbol itself. + + ADDR, LABEL, and NUMBER are three different ways to represent the + stabs value field. At most one of these should be nonzero. + + ADDR is used most of the time; it represents the value as an + RTL address constant. + + LABEL is used (currently) only for N_CATCH stabs; it represents + the value as a string suitable for assemble_name. + + NUMBER is used when the value is an offset from an implicit base + pointer (e.g. for a stack variable), or an index (e.g. for a + register variable). It represents the value as a decimal integer. */ + +#ifndef DBX_FINISH_STABS +#define DBX_FINISH_STABS(SYM, CODE, LINE, ADDR, LABEL, NUMBER) \ +do { \ + int line_ = use_gnu_debug_info_extensions ? LINE : 0; \ + \ + dbxout_int (CODE); \ + fputs (",0,", asm_out_file); \ + dbxout_int (line_); \ + putc (',', asm_out_file); \ + if (ADDR) \ + output_addr_const (asm_out_file, ADDR); \ + else if (LABEL) \ + assemble_name (asm_out_file, LABEL); \ + else \ + dbxout_int (NUMBER); \ + putc ('\n', asm_out_file); \ +} while (0) +#endif + +/* Finish the emission of a complex .stabs directive. When DBX_CONTIN_LENGTH + is zero, this has only to emit the close quote and the remainder of + the arguments. When it is nonzero, the string has been marshalled in + stabstr_ob, and this routine is responsible for breaking it up into + DBX_CONTIN_LENGTH-sized chunks. + + SYM is the DECL of the symbol under consideration; it is used only + for its DECL_SOURCE_LINE. The other arguments are all passed directly + to DBX_FINISH_STABS; see above for details. */ + +static void +dbxout_finish_complex_stabs (tree sym, STAB_CODE_TYPE code, + rtx addr, const char *label, int number) +{ + int line ATTRIBUTE_UNUSED; + char *str; + size_t len; + + line = sym ? DECL_SOURCE_LINE (sym) : 0; + if (DBX_CONTIN_LENGTH > 0) + { + char *chunk; + size_t chunklen; + + /* Nul-terminate the growing string, then get its size and + address. */ + obstack_1grow (&stabstr_ob, '\0'); + + len = obstack_object_size (&stabstr_ob); + chunk = str = obstack_finish (&stabstr_ob); + + /* Within the buffer are a sequence of NUL-separated strings, + each of which is to be written out as a separate stab + directive. */ + for (;;) + { + chunklen = strlen (chunk); + fwrite (chunk, 1, chunklen, asm_out_file); + fputs ("\",", asm_out_file); + + /* Must add an extra byte to account for the NUL separator. */ + chunk += chunklen + 1; + len -= chunklen + 1; + + /* Only put a line number on the last stab in the sequence. */ + DBX_FINISH_STABS (sym, code, len == 0 ? line : 0, + addr, label, number); + if (len == 0) + break; + + fputs (ASM_STABS_OP, asm_out_file); + putc ('"', asm_out_file); + } + stabstr_last_contin_point = 0; + } + else + { + /* No continuations - we can put the whole string out at once. + It is faster to augment the string with the close quote and + comma than to do a two-character fputs. */ + obstack_grow (&stabstr_ob, "\",", 2); + len = obstack_object_size (&stabstr_ob); + str = obstack_finish (&stabstr_ob); + + fwrite (str, 1, len, asm_out_file); + DBX_FINISH_STABS (sym, code, line, addr, label, number); + } + obstack_free (&stabstr_ob, str); +} + #if defined (DBX_DEBUGGING_INFO) + static void -dbxout_function_end () +dbxout_function_end (tree decl) { - static int scope_labelno = 0; char lscope_label_name[100]; - /* Convert Ltext into the appropriate format for local labels in case + + /* The Lscope label must be emitted even if we aren't doing anything + else; dbxout_block needs it. */ + function_section (current_function_decl); + + /* Convert Lscope 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); - ASM_OUTPUT_INTERNAL_LABEL (asmfile, "Lscope", scope_labelno); + targetm.asm_out.internal_label (asm_out_file, "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 + || DECL_IGNORED_P (decl)) + return; + /* By convention, GCC will mark the end of a function with an N_FUN symbol and an empty string. */ #ifdef DBX_OUTPUT_NFUN - DBX_OUTPUT_NFUN (asmfile, lscope_label_name, current_function_decl); + DBX_OUTPUT_NFUN (asm_out_file, lscope_label_name, current_function_decl); #else - fprintf (asmfile, "%s\"\",%d,0,0,", ASM_STABS_OP, N_FUN); - assemble_name (asmfile, lscope_label_name); - putc ('-', asmfile); - assemble_name (asmfile, XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0)); - fprintf (asmfile, "\n"); + dbxout_begin_empty_stabs (N_FUN); + dbxout_stab_value_label_diff (lscope_label_name, + XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0)); + #endif + + if (!NO_DBX_BNSYM_ENSYM && !flag_debug_only_used_symbols) + dbxout_stabd (N_ENSYM, 0); } #endif /* DBX_DEBUGGING_INFO */ +/* Get lang description for N_SO stab. */ +static unsigned int ATTRIBUTE_UNUSED +get_lang_number (void) +{ + const char *language_string = lang_hooks.name; + + if (strcmp (language_string, "GNU C") == 0) + return N_SO_C; + else if (strcmp (language_string, "GNU C++") == 0) + return N_SO_CC; + else if (strcmp (language_string, "GNU F77") == 0) + return N_SO_FORTRAN; + else if (strcmp (language_string, "GNU F95") == 0) + return N_SO_FORTRAN90; /* CHECKME */ + else if (strcmp (language_string, "GNU Pascal") == 0) + return N_SO_PASCAL; + else if (strcmp (language_string, "GNU Objective-C") == 0) + return N_SO_OBJC; + else + return 0; + +} + /* At the beginning of compilation, start writing the symbol table. 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) (); - - asmfile = asm_out_file; + bool used_ltext_label_name = false; + tree syms = lang_hooks.decls.getdecls (); typevec_len = 100; - typevec = (struct typeinfo *) xcalloc (typevec_len, sizeof typevec[0]); + typevec = ggc_calloc (typevec_len, sizeof typevec[0]); + + /* stabstr_ob contains one string, which will be just fine with + 1-byte alignment. */ + obstack_specify_allocation (&stabstr_ob, 0, 1, xmalloc, free); /* Convert Ltext into the appropriate format for local labels in case the system doesn't insert underscores in front of user generated @@ -430,211 +989,298 @@ 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 (use_gnu_debug_info_extensions && !NO_DBX_MAIN_SOURCE_DIRECTORY) { - if (!cwd && (cwd = getpwd ()) && (!*cwd || cwd[strlen (cwd) - 1] != '/')) - cwd = concat (cwd, FILE_NAME_JOINER, NULL); - if (cwd) + static const char *cwd; + + if (!cwd) { + cwd = get_src_pwd (); + if (cwd[0] == '\0') + cwd = "/"; + else if (!IS_DIR_SEPARATOR (cwd[strlen (cwd) - 1])) + cwd = concat (cwd, "/", NULL); + } #ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY - DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asmfile, cwd); + DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asm_out_file, cwd); #else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */ - fprintf (asmfile, "%s", ASM_STABS_OP); - output_quoted_string (asmfile, cwd); - fprintf (asmfile, ",%d,0,0,", N_SO); - assemble_name (asmfile, ltext_label_name); - fputc ('\n', asmfile); + dbxout_begin_simple_stabs_desc (cwd, N_SO, get_lang_number ()); + dbxout_stab_value_label (ltext_label_name); + used_ltext_label_name = true; #endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */ - } } #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, - because that gives you a way to override it. */ - /* Used to put `Ltext:' before the reference, but that loses on sun 4. */ - fprintf (asmfile, "%s", ASM_STABS_OP); - output_quoted_string (asmfile, input_file_name); - fprintf (asmfile, ",%d,0,0,", N_SO); - assemble_name (asmfile, ltext_label_name); - fputc ('\n', asmfile); - text_section (); - ASM_OUTPUT_INTERNAL_LABEL (asmfile, "Ltext", 0); -#endif /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */ - -#ifdef DBX_OUTPUT_GCC_MARKER - DBX_OUTPUT_GCC_MARKER (asmfile); + DBX_OUTPUT_MAIN_SOURCE_FILENAME (asm_out_file, input_file_name); #else - /* Emit an N_OPT stab to indicate that this file was compiled by GCC. */ - fprintf (asmfile, "%s\"%s\",%d,0,0,0\n", - ASM_STABS_OP, STABS_GCC_MARKER, N_OPT); + dbxout_begin_simple_stabs_desc (input_file_name, N_SO, get_lang_number ()); + dbxout_stab_value_label (ltext_label_name); + used_ltext_label_name = true; #endif - lastfile = input_file_name; + if (used_ltext_label_name) + { + text_section (); + targetm.asm_out.internal_label (asm_out_file, "Ltext", 0); + } + + /* Emit an N_OPT stab to indicate that this file was compiled by GCC. + The string used is historical. */ +#ifndef NO_DBX_GCC_MARKER + dbxout_begin_simple_stabs ("gcc2_compiled.", N_OPT); + dbxout_stab_value_zero (); +#endif + + base_input_file = lastfile = input_file_name; next_type_number = 1; #ifdef DBX_USE_BINCL - current_file = (struct dbx_file *) xmalloc (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) +{ + dbxout_begin_simple_stabs (name, N_BINCL); + dbxout_stab_value_zero (); +} + +/* 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 *) xmalloc (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 - struct dbx_file *next; - - fprintf (asmfile, "%s%d,0,0,0\n", ASM_STABN_OP, N_EINCL); - next = current_file->next; - free (current_file); - current_file = next; + /* Emit EINCL stab only if BINCL is not pending. */ + if (current_file->bincl_status == BINCL_PROCESSED) + { + dbxout_begin_stabn (N_EINCL); + dbxout_stab_value_zero (); + } + 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 (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", - source_label_number); - fprintf (file, "%s", ASM_STABS_OP); - output_quoted_string (file, filename); - fprintf (asmfile, ",%d,0,0,", N_SOL); - assemble_name (asmfile, ltext_label_name); - fputc ('\n', asmfile); - if (current_function_decl != NULL_TREE - && DECL_SECTION_NAME (current_function_decl) != NULL_TREE) - ; /* Don't change section amid function. */ - else + /* Don't change section amid function. */ + if (current_function_decl == NULL_TREE) text_section (); - ASM_OUTPUT_INTERNAL_LABEL (file, "Ltext", source_label_number); - source_label_number++; -#endif + + dbxout_begin_simple_stabs (filename, N_SOL); + dbxout_stab_value_internal_label ("Ltext", &source_label_number); 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 + && !NO_DBX_BNSYM_ENSYM + && !flag_debug_only_used_symbols) + dbxout_stabd (N_BNSYM, 0); + + 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); + dbxout_source_file (filename); -#ifdef ASM_OUTPUT_SOURCE_LINE - ASM_OUTPUT_SOURCE_LINE (asmfile, lineno); +#ifdef DBX_OUTPUT_SOURCE_LINE + DBX_OUTPUT_SOURCE_LINE (asm_out_file, lineno, dbxout_source_line_counter); #else - fprintf (asmfile, "%s%d,0,%d\n", ASM_STABD_OP, N_SLINE, lineno); + if (DBX_LINES_FUNCTION_RELATIVE) + { + rtx begin_label = XEXP (DECL_RTL (current_function_decl), 0); + dbxout_begin_stabn_sline (lineno); + dbxout_stab_value_internal_label_diff ("LM", &dbxout_source_line_counter, + XSTR (begin_label, 0)); + + } + else + dbxout_stabd (N_SLINE, lineno); #endif } /* 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) { - ASM_OUTPUT_INTERNAL_LABEL (asmfile, "LBB", n); + emit_pending_bincls_if_required (); + targetm.asm_out.internal_label (asm_out_file, "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) { - ASM_OUTPUT_INTERNAL_LABEL (asmfile, "LBE", n); + emit_pending_bincls_if_required (); + targetm.asm_out.internal_label (asm_out_file, "LBE", n); } /* Output dbx data for a function definition. @@ -644,22 +1290,14 @@ 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 dbxout_block (DECL_INITIAL (decl), 0, DECL_ARGUMENTS (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 (decl); } #endif /* DBX_DEBUGGING_INFO */ @@ -667,72 +1305,75 @@ 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. - Unless you define DBX_OUTPUT_MAIN_SOURCE_FILE_END, the default is - to do nothing. */ + The default is to call debug_free_queue but do nothing else. */ 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 */ + DBX_OUTPUT_MAIN_SOURCE_FILE_END (asm_out_file, filename); +#elif defined DBX_OUTPUT_NULL_N_SO_AT_MAIN_SOURCE_FILE_END + { + text_section (); + dbxout_begin_empty_stabs (N_SO); + dbxout_stab_value_internal_label ("Letext", 0); + } +#endif + 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)); - CHARS (3); + stabstr_D (TYPE_SYMTAB_ADDRESS (type)); #else struct typeinfo *t = &typevec[TYPE_SYMTAB_ADDRESS (type)]; - fprintf (asmfile, "(%d,%d)", t->file_number, t->type_number); - CHARS (9); + stabstr_C ('('); + stabstr_D (t->file_number); + stabstr_C (','); + stabstr_D (t->type_number); + stabstr_C (')'); #endif } -#if DBX_CONTIN_LENGTH > 0 -/* Continue a symbol-description that gets too big. - End one symbol table entry with a double-backslash - and start a new one, eventually producing something like - .stabs "start......\\",code,0,value - .stabs "...rest",code,0,value */ - -static void -dbxout_continue () -{ -#ifdef DBX_CONTIN_CHAR - fprintf (asmfile, "%c", DBX_CONTIN_CHAR); -#else - fprintf (asmfile, "\\\\"); -#endif - dbxout_finish_symbol (NULL_TREE); - fprintf (asmfile, "%s\"", ASM_STABS_OP); - current_sym_nchars = 0; -} -#endif /* DBX_CONTIN_LENGTH > 0 */ + +/* Used in several places: evaluates to '0' for a private decl, + '1' for a protected decl, '2' for a public decl. */ +#define DECL_ACCESSIBILITY_CHAR(DECL) \ +(TREE_PRIVATE (DECL) ? '0' : TREE_PROTECTED (DECL) ? '1' : '2') + /* Subroutine of `dbxout_type'. Output the type fields of TYPE. This must be a separate function because anonymous unions require recursive calls. */ static void -dbxout_type_fields (type) - tree type; +dbxout_type_fields (tree type) { tree tem; @@ -740,6 +1381,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 @@ -760,26 +1406,16 @@ dbxout_type_fields (type) CONTIN; if (DECL_NAME (tem)) - { - fprintf (asmfile, "%s:", IDENTIFIER_POINTER (DECL_NAME (tem))); - CHARS (2 + IDENTIFIER_LENGTH (DECL_NAME (tem))); - } - else - { - fprintf (asmfile, ":"); - CHARS (1); - } + stabstr_I (DECL_NAME (tem)); + stabstr_C (':'); if (use_gnu_debug_info_extensions && (TREE_PRIVATE (tem) || TREE_PROTECTED (tem) || TREE_CODE (tem) != FIELD_DECL)) { have_used_extensions = 1; - putc ('/', asmfile); - putc ((TREE_PRIVATE (tem) ? '0' - : TREE_PROTECTED (tem) ? '1' : '2'), - asmfile); - CHARS (2); + stabstr_C ('/'); + stabstr_C (DECL_ACCESSIBILITY_CHAR (tem)); } dbxout_type ((TREE_CODE (tem) == FIELD_DECL @@ -793,38 +1429,31 @@ dbxout_type_fields (type) tree name = DECL_ASSEMBLER_NAME (tem); have_used_extensions = 1; - fprintf (asmfile, ":%s;", IDENTIFIER_POINTER (name)); - CHARS (IDENTIFIER_LENGTH (name) + 2); + stabstr_C (':'); + stabstr_I (name); + stabstr_C (';'); } else - { - /* If TEM is non-static, GDB won't understand it. */ - fprintf (asmfile, ",0,0;"); - CHARS (5); - } + /* If TEM is non-static, GDB won't understand it. */ + stabstr_S (",0,0;"); } else { - putc (',', asmfile); - print_wide_int (int_bit_position (tem)); - putc (',', asmfile); - print_wide_int (tree_low_cst (DECL_SIZE (tem), 1)); - putc (';', asmfile); - CHARS (3); + stabstr_C (','); + stabstr_D (int_bit_position (tem)); + stabstr_C (','); + stabstr_D (tree_low_cst (DECL_SIZE (tem), 1)); + stabstr_C (';'); } } } } /* Subroutine of `dbxout_type_methods'. Output debug info about the - method described DECL. DEBUG_NAME is an encoding of the method's - type signature. ??? We may be able to do without DEBUG_NAME altogether - now. */ + method described DECL. */ static void -dbxout_type_method_1 (decl, debug_name) - tree decl; - const char *debug_name; +dbxout_type_method_1 (tree decl) { char c1 = 'A', c2; @@ -848,20 +1477,21 @@ dbxout_type_method_1 (decl, debug_name) c2 = '.'; } - fprintf (asmfile, ":%s;%c%c%c", debug_name, - TREE_PRIVATE (decl) ? '0' - : TREE_PROTECTED (decl) ? '1' : '2', c1, c2); - CHARS (IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (decl)) + 6 - - (debug_name - IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)))); + /* ??? Output the mangled name, which contains an encoding of the + method's type signature. May not be necessary anymore. */ + stabstr_C (':'); + stabstr_I (DECL_ASSEMBLER_NAME (decl)); + stabstr_C (';'); + stabstr_C (DECL_ACCESSIBILITY_CHAR (decl)); + stabstr_C (c1); + stabstr_C (c2); if (DECL_VINDEX (decl) && host_integerp (DECL_VINDEX (decl), 0)) { - print_wide_int (tree_low_cst (DECL_VINDEX (decl), 0)); - putc (';', asmfile); - CHARS (1); + stabstr_D (tree_low_cst (DECL_VINDEX (decl), 0)); + stabstr_C (';'); dbxout_type (DECL_CONTEXT (decl), 0); - fprintf (asmfile, ";"); - CHARS (1); + stabstr_C (';'); } } @@ -869,44 +1499,16 @@ 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); - tree type_encoding; tree fndecl; tree last; - char formatted_type_identifier_length[16]; - int type_identifier_length; if (methods == NULL_TREE) return; - type_encoding = DECL_NAME (TYPE_NAME (type)); - -#if 0 - /* C++: Template classes break some assumptions made by this code about - the class names, constructor names, and encodings for assembler - label names. For now, disable output of dbx info for them. */ - { - const char *ptr = IDENTIFIER_POINTER (type_encoding); - /* This should use index. (mrs) */ - while (*ptr && *ptr != '<') ptr++; - if (*ptr != 0) - { - static int warned; - if (!warned) - warned = 1; - return; - } - } -#endif - - type_identifier_length = IDENTIFIER_LENGTH (type_encoding); - - sprintf (formatted_type_identifier_length, "%d", type_identifier_length); - if (TREE_CODE (methods) != TREE_VEC) fndecl = methods; else if (TREE_VEC_ELT (methods, 0) != NULL_TREE) @@ -927,18 +1529,12 @@ dbxout_type_methods (type) well as the name of the field before overloading, along with its parameter list */ { - /* This is the "mangled" name of the method. - It encodes the argument types. */ - const char *debug_name; - /* Skip methods that aren't FUNCTION_DECLs. (In C++, these include TEMPLATE_DECLs.) The debugger doesn't know what to do with such entities anyhow. */ if (TREE_CODE (fndecl) != FUNCTION_DECL) continue; - debug_name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl)); - CONTIN; last = fndecl; @@ -952,21 +1548,16 @@ dbxout_type_methods (type) expects. */ if (need_prefix) { - tree name = DECL_NAME (fndecl); - fprintf (asmfile, "%s::", IDENTIFIER_POINTER (name)); - CHARS (IDENTIFIER_LENGTH (name) + 2); + stabstr_I (DECL_NAME (fndecl)); + stabstr_S ("::"); need_prefix = 0; } dbxout_type (TREE_TYPE (fndecl), 0); - - dbxout_type_method_1 (fndecl, debug_name); + dbxout_type_method_1 (fndecl); } if (!need_prefix) - { - putc (';', asmfile); - CHARS (1); - } + stabstr_C (';'); } } @@ -975,10 +1566,9 @@ 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"); + stabstr_C ('r'); if (TREE_TYPE (type)) dbxout_type (TREE_TYPE (type), 0); else if (TREE_CODE (type) != INTEGER_TYPE) @@ -1003,35 +1593,33 @@ dbxout_range_type (type) dbxout_type_index (integer_type_node); } + stabstr_C (';'); if (TYPE_MIN_VALUE (type) != 0 && host_integerp (TYPE_MIN_VALUE (type), 0)) { - putc (';', asmfile); - CHARS (1); - print_wide_int (tree_low_cst (TYPE_MIN_VALUE (type), 0)); + if (print_int_cst_bounds_in_octal_p (type)) + stabstr_O (TYPE_MIN_VALUE (type)); + else + stabstr_D (tree_low_cst (TYPE_MIN_VALUE (type), 0)); } else - { - fprintf (asmfile, ";0"); - CHARS (2); - } + stabstr_C ('0'); + stabstr_C (';'); if (TYPE_MAX_VALUE (type) != 0 && host_integerp (TYPE_MAX_VALUE (type), 0)) { - putc (';', asmfile); - CHARS (1); - print_wide_int (tree_low_cst (TYPE_MAX_VALUE (type), 0)); - putc (';', asmfile); - CHARS (1); + if (print_int_cst_bounds_in_octal_p (type)) + stabstr_O (TYPE_MAX_VALUE (type)); + else + stabstr_D (tree_low_cst (TYPE_MAX_VALUE (type), 0)); + stabstr_C (';'); } else - { - fprintf (asmfile, ";-1;"); - CHARS (4); - } + stabstr_S ("-1;"); } + /* 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 @@ -1043,16 +1631,16 @@ 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; static int anonymous_type_number = 0; if (TREE_CODE (type) == VECTOR_TYPE) - type = TYPE_DEBUG_REPRESENTATION_TYPE (type); + /* The frontend feeds us a representation for the vector as a struct + containing an array. Pull out the array type. */ + type = TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type))); /* If there was an input error and we don't really have a type, avoid crashing and write something that is at least valid @@ -1089,14 +1677,13 @@ dbxout_type (type, full) if (next_type_number == typevec_len) { typevec - = (struct typeinfo *) xrealloc (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 @@ -1104,6 +1691,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) + && DECL_P (TYPE_STUB_DECL (type)) + && ! 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); @@ -1159,9 +1761,7 @@ dbxout_type (type, full) #endif /* Output a definition now. */ - - fprintf (asmfile, "="); - CHARS (1); + stabstr_C ('='); /* Mark it as defined, so that if it is self-referent we will not get into an infinite recursion of definitions. */ @@ -1173,20 +1773,30 @@ dbxout_type (type, full) cv-qualified types if we're using extensions. */ if (TYPE_READONLY (type) > TYPE_READONLY (main_variant)) { - putc ('k', asmfile); - CHARS (1); + stabstr_C ('k'); dbxout_type (build_type_variant (type, 0, TYPE_VOLATILE (type)), 0); return; } else if (TYPE_VOLATILE (type) > TYPE_VOLATILE (main_variant)) { - putc ('B', asmfile); - CHARS (1); + stabstr_C ('B'); dbxout_type (build_type_variant (type, TYPE_READONLY (type), 0), 0); return; } 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; @@ -1197,7 +1807,7 @@ dbxout_type (type, full) { case VOID_TYPE: case LANG_TYPE: - /* For a void type, just define it as itself; ie, "5=5". + /* For a void type, just define it as itself; i.e., "5=5". This makes us consider it defined without saying what it is. The debugger will make it a void type when the reference is seen, and nothing will @@ -1206,18 +1816,16 @@ 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 from the output of pcc. This used to use `r2' explicitly and we used to take care to make sure that `char' was type number 2. */ - fprintf (asmfile, "r"); - CHARS (1); + stabstr_C ('r'); dbxout_type_index (type); - fprintf (asmfile, ";0;127;"); - CHARS (7); + stabstr_S (";0;127;"); } /* If this is a subtype of another integer type, always prefer to @@ -1232,8 +1840,9 @@ dbxout_type (type, full) && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node)) { have_used_extensions = 1; - fprintf (asmfile, "@s%d;", TYPE_PRECISION (type)); - CHARS (5); + stabstr_S ("@s"); + stabstr_D (TYPE_PRECISION (type)); + stabstr_C (';'); } dbxout_range_type (type); @@ -1248,46 +1857,30 @@ dbxout_type (type, full) && TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node)) { have_used_extensions = 1; - fprintf (asmfile, "@s%d;", TYPE_PRECISION (type)); - CHARS (5); + stabstr_S ("@s"); + stabstr_D (TYPE_PRECISION (type)); + stabstr_C (';'); } - /* 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); - fprintf (asmfile, ";"); - CHARS (1); - print_int_cst_octal (TYPE_MIN_VALUE (type)); - fprintf (asmfile, ";"); - CHARS (1); - print_int_cst_octal (TYPE_MAX_VALUE (type)); - fprintf (asmfile, ";"); - CHARS (1); + stabstr_C ('r'); + + /* 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); + + stabstr_C (';'); + stabstr_O (TYPE_MIN_VALUE (type)); + stabstr_C (';'); + stabstr_O (TYPE_MAX_VALUE (type)); + stabstr_C (';'); } else @@ -1300,35 +1893,28 @@ dbxout_type (type, full) case REAL_TYPE: /* This used to say `r1' and we used to take care to make sure that `int' was type number 1. */ - fprintf (asmfile, "r"); - CHARS (1); + stabstr_C ('r'); dbxout_type_index (integer_type_node); - putc (';', asmfile); - CHARS (1); - print_wide_int (int_size_in_bytes (type)); - fputs (";0;", asmfile); - CHARS (3); + stabstr_C (';'); + stabstr_D (int_size_in_bytes (type)); + stabstr_S (";0;"); break; case CHAR_TYPE: if (use_gnu_debug_info_extensions) { have_used_extensions = 1; - fputs ("@s", asmfile); - CHARS (2); - print_wide_int (BITS_PER_UNIT * int_size_in_bytes (type)); - fputs (";-20;", asmfile); - CHARS (4); + stabstr_S ("@s"); + stabstr_D (BITS_PER_UNIT * int_size_in_bytes (type)); + stabstr_S (";-20;"); } else { /* Output the type `char' as a subrange of itself. That is what pcc seems to do. */ - fprintf (asmfile, "r"); - CHARS (1); + stabstr_C ('r'); dbxout_type_index (char_type_node); - fprintf (asmfile, ";0;%d;", TREE_UNSIGNED (type) ? 255 : 127); - CHARS (7); + stabstr_S (TYPE_UNSIGNED (type) ? ";0;255;" : ";0;127;"); } break; @@ -1336,82 +1922,50 @@ dbxout_type (type, full) if (use_gnu_debug_info_extensions) { have_used_extensions = 1; - fputs ("@s", asmfile); - CHARS (2); - print_wide_int (BITS_PER_UNIT * int_size_in_bytes (type)); - fputs (";-16;", asmfile); - CHARS (4); + stabstr_S ("@s"); + stabstr_D (BITS_PER_UNIT * int_size_in_bytes (type)); + stabstr_S (";-16;"); } else /* Define as enumeral type (False, True) */ - { - fprintf (asmfile, "eFalse:0,True:1,;"); - CHARS (17); - } + stabstr_S ("eFalse:0,True:1,;"); break; case FILE_TYPE: - putc ('d', asmfile); - CHARS (1); + stabstr_C ('d'); dbxout_type (TREE_TYPE (type), 0); 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) { - fprintf (asmfile, "r"); - CHARS (1); - dbxout_type_index (type); - putc (';', asmfile); - CHARS (1); - print_wide_int (2 * int_size_in_bytes (TREE_TYPE (type))); - fputs (";0;", asmfile); - CHARS (3); + stabstr_S ("R3;"); + stabstr_D (2 * int_size_in_bytes (TREE_TYPE (type))); + stabstr_S (";0;"); } else { /* Output a complex integer type as a structure, pending some other way to do it. */ - putc ('s', asmfile); - CHARS (1); - print_wide_int (int_size_in_bytes (type)); - fprintf (asmfile, "real:"); - CHARS (5); + stabstr_C ('s'); + stabstr_D (int_size_in_bytes (type)); + stabstr_S ("real:"); dbxout_type (TREE_TYPE (type), 0); - fprintf (asmfile, ",0,%d;", TYPE_PRECISION (TREE_TYPE (type))); - CHARS (7); - fprintf (asmfile, "imag:"); - CHARS (5); - dbxout_type (TREE_TYPE (type), 0); - fprintf (asmfile, ",%d,%d;;", TYPE_PRECISION (TREE_TYPE (type)), - TYPE_PRECISION (TREE_TYPE (type))); - CHARS (10); - } - break; + stabstr_S (",0,"); + stabstr_D (TYPE_PRECISION (TREE_TYPE (type))); - case SET_TYPE: - if (use_gnu_debug_info_extensions) - { - have_used_extensions = 1; - fputs ("@s", asmfile); - CHARS (2); - print_wide_int (BITS_PER_UNIT * int_size_in_bytes (type)); - putc (';', asmfile); - CHARS (1); - - /* Check if a bitstring type, which in Chill is - different from a [power]set. */ - if (TYPE_STRING_FLAG (type)) - { - fprintf (asmfile, "@S;"); - CHARS (3); - } + stabstr_S (";imag:"); + dbxout_type (TREE_TYPE (type), 0); + stabstr_C (','); + stabstr_D (TYPE_PRECISION (TREE_TYPE (type))); + stabstr_C (','); + stabstr_D (TYPE_PRECISION (TREE_TYPE (type))); + stabstr_S (";;"); } - putc ('S', asmfile); - CHARS (1); - dbxout_type (TYPE_DOMAIN (type), 0); break; case ARRAY_TYPE: @@ -1419,11 +1973,9 @@ dbxout_type (type, full) if (TYPE_PACKED (type) && use_gnu_debug_info_extensions) { have_used_extensions = 1; - fputs ("@s", asmfile); - CHARS (2); - print_wide_int (BITS_PER_UNIT * int_size_in_bytes (type)); - fprintf (asmfile, ";@S;S"); - CHARS (5); + stabstr_S ("@s"); + stabstr_D (BITS_PER_UNIT * int_size_in_bytes (type)); + stabstr_S (";@S;S"); dbxout_type (TYPE_DOMAIN (type), 0); break; } @@ -1437,22 +1989,18 @@ dbxout_type (type, full) if (TYPE_STRING_FLAG (type) && use_gnu_debug_info_extensions) { have_used_extensions = 1; - fprintf (asmfile, "@S;"); - CHARS (3); + stabstr_S ("@S;"); } tem = TYPE_DOMAIN (type); if (tem == NULL) { - fprintf (asmfile, "ar"); - CHARS (2); + stabstr_S ("ar"); dbxout_type_index (integer_type_node); - fprintf (asmfile, ";0;-1;"); - CHARS (6); + stabstr_S (";0;-1;"); } else { - fprintf (asmfile, "a"); - CHARS (1); + stabstr_C ('a'); dbxout_range_type (tem); } @@ -1463,12 +2011,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. */ @@ -1487,89 +2030,84 @@ dbxout_type (type, full) If the type has a name, don't nest its definition within another type's definition; instead, output an xref and let the definition come when the name is defined. */ - fputs ((TREE_CODE (type) == RECORD_TYPE) ? "xs" : "xu", asmfile); - CHARS (2); -#if 0 /* This assertion is legitimately false in C++. */ - /* We shouldn't be outputting a reference to a type before its - definition unless the type has a tag name. - A typedef name without a tag name should be impossible. */ - if (TREE_CODE (TYPE_NAME (type)) != IDENTIFIER_NODE) - abort (); -#endif + stabstr_S ((TREE_CODE (type) == RECORD_TYPE) ? "xs" : "xu"); if (TYPE_NAME (type) != 0) dbxout_type_name (type); else { - fprintf (asmfile, "$$%d", anonymous_type_number++); - CHARS (5); + stabstr_S ("$$"); + stabstr_D (anonymous_type_number++); } - fprintf (asmfile, ":"); - CHARS (1); + stabstr_C (':'); typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF; break; } /* Identify record or union, and print its size. */ - putc (((TREE_CODE (type) == RECORD_TYPE) ? 's' : 'u'), asmfile); - CHARS (1); - print_wide_int (int_size_in_bytes (type)); + stabstr_C ((TREE_CODE (type) == RECORD_TYPE) ? 's' : 'u'); + stabstr_D (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 child = TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (type)), i); - + 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 (TREE_VIA_PUBLIC (child) ? '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; + stabstr_C ('!'); + stabstr_U (BINFO_N_BASE_BINFOS (binfo)); + stabstr_C (','); + } } - 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; + stabstr_C (BINFO_VIRTUAL_P (child) ? '1' : '0'); + stabstr_C (access == access_public_node ? '2' : + access == access_protected_node + ? '1' :'0'); + 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. */ + stabstr_D + (tree_low_cst (BINFO_VPTR_FIELD (child), 0) + * BITS_PER_UNIT); + else + stabstr_D (tree_low_cst (BINFO_OFFSET (child), 0) + * BITS_PER_UNIT); + stabstr_C (','); + dbxout_type (BINFO_TYPE (child), 0); + stabstr_C (';'); + } + 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)); + stabstr_C (':'); + dbxout_type (BINFO_TYPE (child), full); + stabstr_C (','); + stabstr_D (tree_low_cst (BINFO_OFFSET (child), 0) + * BITS_PER_UNIT); + stabstr_C (','); + stabstr_D + (tree_low_cst (TYPE_SIZE (BINFO_TYPE (child)), 0) + * BITS_PER_UNIT); + stabstr_C (';'); + } } } } @@ -1582,8 +2120,7 @@ dbxout_type (type, full) dbxout_type_methods (type); } - putc (';', asmfile); - CHARS (1); + stabstr_C (';'); if (use_gnu_debug_info_extensions && TREE_CODE (type) == RECORD_TYPE /* Avoid the ~ if we don't really need it--it confuses dbx. */ @@ -1591,23 +2128,13 @@ dbxout_type (type, full) { have_used_extensions = 1; - /* Tell GDB+ that it may keep reading. */ - putc ('~', asmfile); - CHARS (1); - /* We need to write out info about what field this class uses as its "main" vtable pointer field, because if this field is inherited from a base class, GDB cannot necessarily figure out which field it's using in time. */ - if (TYPE_VFIELD (type)) - { - putc ('%', asmfile); - CHARS (1); - dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type)), 0); - } - - putc (';', asmfile); - CHARS (1); + stabstr_S ("~%"); + dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type)), 0); + stabstr_C (';'); } break; @@ -1621,52 +2148,45 @@ dbxout_type (type, full) && !full) || !COMPLETE_TYPE_P (type)) { - fprintf (asmfile, "xe"); - CHARS (2); + stabstr_S ("xe"); dbxout_type_name (type); typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF; - putc (':', asmfile); - CHARS (1); + stabstr_C (':'); 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)) { - fprintf (asmfile, "@s%d;", TYPE_PRECISION (type)); - CHARS (5); + have_used_extensions = 1; + stabstr_S ("@s"); + stabstr_D (TYPE_PRECISION (type)); + stabstr_C (';'); } - putc ('e', asmfile); - CHARS (1); + stabstr_C ('e'); for (tem = TYPE_VALUES (type); tem; tem = TREE_CHAIN (tem)) { - fprintf (asmfile, "%s:", IDENTIFIER_POINTER (TREE_PURPOSE (tem))); - CHARS (IDENTIFIER_LENGTH (TREE_PURPOSE (tem)) + 1); + stabstr_I (TREE_PURPOSE (tem)); + stabstr_C (':'); + if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == 0) - print_wide_int (TREE_INT_CST_LOW (TREE_VALUE (tem))); + stabstr_D (TREE_INT_CST_LOW (TREE_VALUE (tem))); else if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == -1 && (HOST_WIDE_INT) TREE_INT_CST_LOW (TREE_VALUE (tem)) < 0) - print_wide_int (TREE_INT_CST_LOW (TREE_VALUE (tem))); + stabstr_D (TREE_INT_CST_LOW (TREE_VALUE (tem))); else - print_int_cst_octal (TREE_VALUE (tem)); + stabstr_O (TREE_VALUE (tem)); - putc (',', asmfile); - CHARS (1); + stabstr_C (','); if (TREE_CHAIN (tem) != 0) CONTIN; } - putc (';', asmfile); - CHARS (1); -#endif + stabstr_C (';'); break; case POINTER_TYPE: - putc ('*', asmfile); - CHARS (1); + stabstr_C ('*'); dbxout_type (TREE_TYPE (type), 0); break; @@ -1674,17 +2194,14 @@ dbxout_type (type, full) if (use_gnu_debug_info_extensions) { have_used_extensions = 1; - putc ('#', asmfile); - CHARS (1); + stabstr_C ('#'); /* Write the argument types out longhand. */ dbxout_type (TYPE_METHOD_BASETYPE (type), 0); - putc (',', asmfile); - CHARS (1); + stabstr_C (','); dbxout_type (TREE_TYPE (type), 0); dbxout_args (TYPE_ARG_TYPES (type)); - putc (';', asmfile); - CHARS (1); + stabstr_C (';'); } else /* Treat it as a function type. */ @@ -1695,11 +2212,9 @@ dbxout_type (type, full) if (use_gnu_debug_info_extensions) { have_used_extensions = 1; - putc ('@', asmfile); - CHARS (1); + stabstr_C ('@'); dbxout_type (TYPE_OFFSET_BASETYPE (type), 0); - putc (',', asmfile); - CHARS (1); + stabstr_C (','); dbxout_type (TREE_TYPE (type), 0); } else @@ -1709,102 +2224,56 @@ dbxout_type (type, full) case REFERENCE_TYPE: if (use_gnu_debug_info_extensions) - have_used_extensions = 1; - putc (use_gnu_debug_info_extensions ? '&' : '*', asmfile); - CHARS (1); + { + have_used_extensions = 1; + stabstr_C ('&'); + } + else + stabstr_C ('*'); dbxout_type (TREE_TYPE (type), 0); break; case FUNCTION_TYPE: - putc ('f', asmfile); - CHARS (1); + stabstr_C ('f'); dbxout_type (TREE_TYPE (type), 0); break; default: - abort (); + gcc_unreachable (); } } -/* Print the value of integer constant C, in octal, - handling double precision. */ +/* Return nonzero if the given type represents an integer whose bounds + should be printed in octal format. */ -static void -print_int_cst_octal (c) - tree c; +static bool +print_int_cst_bounds_in_octal_p (tree type) { - unsigned HOST_WIDE_INT high = TREE_INT_CST_HIGH (c); - unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (c); - int excess = (3 - (HOST_BITS_PER_WIDE_INT % 3)); - unsigned int width = TYPE_PRECISION (TREE_TYPE (c)); - - /* GDB wants constants with no extra leading "1" bits, so - we need to remove any sign-extension that might be - present. */ - if (width == HOST_BITS_PER_WIDE_INT * 2) - ; - else if (width > HOST_BITS_PER_WIDE_INT) - high &= (((HOST_WIDE_INT) 1 << (width - HOST_BITS_PER_WIDE_INT)) - 1); - else if (width == HOST_BITS_PER_WIDE_INT) - high = 0; - else - high = 0, low &= (((HOST_WIDE_INT) 1 << width) - 1); + /* 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". - fprintf (asmfile, "0"); - CHARS (1); + 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 (excess == 3) - { - print_octal (high, HOST_BITS_PER_WIDE_INT / 3); - print_octal (low, HOST_BITS_PER_WIDE_INT / 3); - } + 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 - { - unsigned HOST_WIDE_INT beg = high >> excess; - unsigned HOST_WIDE_INT middle - = ((high & (((HOST_WIDE_INT) 1 << excess) - 1)) << (3 - excess) - | (low >> (HOST_BITS_PER_WIDE_INT / 3 * 3))); - unsigned HOST_WIDE_INT end - = low & (((unsigned HOST_WIDE_INT) 1 - << (HOST_BITS_PER_WIDE_INT / 3 * 3)) - - 1); - - fprintf (asmfile, "%o%01o", (int) beg, (int) middle); - CHARS (2); - print_octal (end, HOST_BITS_PER_WIDE_INT / 3); - } -} - -static void -print_octal (value, digits) - unsigned HOST_WIDE_INT value; - int digits; -{ - int i; - - for (i = digits - 1; i >= 0; i--) - fprintf (asmfile, "%01o", (int) ((value >> (3 * i)) & 7)); - - CHARS (digits); -} - -/* Output C in decimal while adjusting the number of digits written. */ - -static void -print_wide_int (c) - HOST_WIDE_INT c; -{ - int digs = 0; - - fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, c); - - if (c < 0) - digs++, c = -c; - - while (c > 0) - c /= 10; digs++; - - CHARS (digs); + return FALSE; } /* Output the name of type TYPE, with no punctuation. @@ -1812,39 +2281,36 @@ 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) - abort (); - if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE) - { - t = TYPE_NAME (type); - } - else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL) + tree t = TYPE_NAME (type); + + gcc_assert (t); + switch (TREE_CODE (t)) { - t = DECL_NAME (TYPE_NAME (type)); + case IDENTIFIER_NODE: + break; + case TYPE_DECL: + t = DECL_NAME (t); + break; + default: + gcc_unreachable (); } - else - abort (); - fprintf (asmfile, "%s", IDENTIFIER_POINTER (t)); - CHARS (IDENTIFIER_LENGTH (t)); + stabstr_I (t); } /* Output leading leading struct or class names needed for qualifying 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))) { @@ -1855,8 +2321,8 @@ dbxout_class_name_qualifiers (decl) dbxout_class_name_qualifiers (name); name = DECL_NAME (name); } - fprintf (asmfile, "%s::", IDENTIFIER_POINTER (name)); - CHARS (IDENTIFIER_LENGTH (name) + 2); + stabstr_I (name); + stabstr_S ("::"); } } @@ -1867,32 +2333,87 @@ 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. */ - dbxout_prepare_symbol (decl); + if (flag_debug_only_used_symbols + && (!TREE_USED (decl) + && (TREE_CODE (decl) != VAR_DECL || !DECL_INITIAL (decl)))) + DBXOUT_DECR_NESTING_AND_RETURN (0); - /* The output will always start with the symbol name, - so always count that in the length-output-so-far. */ + /* 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 (otherwise they would fight over the + stabstr obstack). + + 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) + { + if (TYPE_STUB_DECL (t) + && TYPE_STUB_DECL (t) != decl + && DECL_P (TYPE_STUB_DECL (t)) + && ! 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 + && DECL_P (TYPE_NAME (t))) + debug_queue_symbol (TYPE_NAME (t)); + } + } + else if (TYPE_NAME (t) + && TYPE_NAME (t) != decl + && DECL_P (TYPE_NAME (t))) + debug_queue_symbol (TYPE_NAME (t)); + } - if (DECL_NAME (decl) != 0) - current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (decl)); + emit_pending_bincls_if_required (); switch (TREE_CODE (decl)) { @@ -1902,26 +2423,25 @@ 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 + /* Don't mention an inline instance of a nested function. */ + if (context && DECL_FROM_INLINE (decl)) + break; + if (!MEM_P (DECL_RTL (decl)) || GET_CODE (XEXP (DECL_RTL (decl), 0)) != SYMBOL_REF) break; - FORCE_TEXT; - fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP, - IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)), - TREE_PUBLIC (decl) ? 'F' : 'f'); + dbxout_begin_complex_stabs (); + stabstr_I (DECL_ASSEMBLER_NAME (decl)); + stabstr_S (TREE_PUBLIC (decl) ? ":F" : ":f"); result = 1; - current_sym_code = N_FUN; - current_sym_addr = XEXP (DECL_RTL (decl), 0); - if (TREE_TYPE (type)) dbxout_type (TREE_TYPE (type), 0); else @@ -1931,31 +2451,37 @@ dbxout_symbol (decl, local) mention the containing function name as well as (since dbx wants it) our own assembler-name. */ if (context != 0) - fprintf (asmfile, ",%s,%s", - IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)), - IDENTIFIER_POINTER (DECL_NAME (context))); + { + stabstr_C (','); + stabstr_I (DECL_ASSEMBLER_NAME (decl)); + stabstr_C (','); + stabstr_I (DECL_NAME (context)); + } - dbxout_finish_symbol (decl); + dbxout_finish_complex_stabs (decl, N_FUN, XEXP (DECL_RTL (decl), 0), + 0, 0); 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; { @@ -1980,6 +2506,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. */ @@ -1989,28 +2517,27 @@ dbxout_symbol (decl, local) if (TREE_CODE (name) == TYPE_DECL) name = DECL_NAME (name); - current_sym_code = DBX_TYPE_DECL_STABS_CODE; - current_sym_value = 0; - current_sym_addr = 0; - current_sym_nchars = 2 + IDENTIFIER_LENGTH (name); - - fprintf (asmfile, "%s\"%s:T", ASM_STABS_OP, - IDENTIFIER_POINTER (name)); + dbxout_begin_complex_stabs (); + stabstr_I (name); + stabstr_S (":T"); dbxout_type (type, 1); - dbxout_finish_symbol (NULL_TREE); + dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE, + 0, 0, 0); } - /* Output .stabs (or whatever) and leading double quote. */ - fprintf (asmfile, "%s\"", ASM_STABS_OP); + dbxout_begin_complex_stabs (); + /* Output leading class/struct qualifiers. + ??? why not set have_used_extensions here ... because + then the test of it below would always be true, I + guess. But it's not clear to me why we shouldn't do + that always in extended mode. */ if (use_gnu_debug_info_extensions) - { - /* Output leading class/struct qualifiers. */ - dbxout_class_name_qualifiers (decl); - } + dbxout_class_name_qualifiers (decl); /* Output typedef name. */ - fprintf (asmfile, "%s:", IDENTIFIER_POINTER (DECL_NAME (decl))); + stabstr_I (DECL_NAME (decl)); + stabstr_C (':'); /* Short cut way to output a tag also. */ if ((TREE_CODE (type) == RECORD_TYPE @@ -2023,20 +2550,15 @@ dbxout_symbol (decl, local) { if (use_gnu_debug_info_extensions && have_used_extensions) { - putc ('T', asmfile); + stabstr_C ('T'); TREE_ASM_WRITTEN (TYPE_NAME (type)) = 1; } -#if 0 /* Now we generate the tag for this case up above. */ - else - tag_needed = 1; -#endif } - putc ('t', asmfile); - current_sym_code = DBX_TYPE_DECL_STABS_CODE; - + stabstr_C ('t'); dbxout_type (type, 1); - dbxout_finish_symbol (decl); + dbxout_finish_complex_stabs (decl, DBX_TYPE_DECL_STABS_CODE, + 0, 0, 0); did_output = 1; } @@ -2058,33 +2580,26 @@ dbxout_symbol (decl, local) if (TREE_CODE (name) == TYPE_DECL) name = DECL_NAME (name); - current_sym_code = DBX_TYPE_DECL_STABS_CODE; - current_sym_value = 0; - current_sym_addr = 0; - current_sym_nchars = 2 + IDENTIFIER_LENGTH (name); - - fprintf (asmfile, "%s\"%s:T", ASM_STABS_OP, - IDENTIFIER_POINTER (name)); + dbxout_begin_complex_stabs (); + stabstr_I (name); + stabstr_S (":T"); dbxout_type (type, 1); - dbxout_finish_symbol (NULL_TREE); + dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE, 0, 0, 0); did_output = 1; } - /* If an enum type has no name, it cannot be referred to, - but we must output it anyway, since the enumeration constants - can be referred to. */ + /* If an enum type has no name, it cannot be referred to, but + we must output it anyway, to record the enumeration + constants. */ + if (!did_output && TREE_CODE (type) == ENUMERAL_TYPE) { - current_sym_code = DBX_TYPE_DECL_STABS_CODE; - current_sym_value = 0; - current_sym_addr = 0; - current_sym_nchars = 2; - + dbxout_begin_complex_stabs (); /* Some debuggers fail when given NULL names, so give this a - harmless name of ` '. */ - fprintf (asmfile, "%s\" :T", ASM_STABS_OP); + harmless name of " " (Why not "(anon)"?). */ + stabstr_S (" :T"); dbxout_type (type, 1); - dbxout_finish_symbol (NULL_TREE); + dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE, 0, 0, 0); } /* Prevent duplicate output of a typedef. */ @@ -2095,54 +2610,49 @@ dbxout_symbol (decl, local) case PARM_DECL: /* Parm decls go in their own separate chains and are output by dbxout_reg_parms and dbxout_parms. */ - abort (); + gcc_unreachable (); case RESULT_DECL: /* 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)) break; /* If the variable is really a constant - and not written in memory, inform the debugger. */ + and not written in memory, inform the debugger. + + ??? Why do we skip emitting the type and location in this case? */ if (TREE_STATIC (decl) && TREE_READONLY (decl) && DECL_INITIAL (decl) != 0 && host_integerp (DECL_INITIAL (decl), 0) && ! TREE_ASM_WRITTEN (decl) && (DECL_CONTEXT (decl) == NULL_TREE - || TREE_CODE (DECL_CONTEXT (decl)) == BLOCK)) + || TREE_CODE (DECL_CONTEXT (decl)) == BLOCK) + && TREE_PUBLIC (decl) == 0) { - if (TREE_PUBLIC (decl) == 0) - { - /* The sun4 assembler does not grok this. */ - const char *name = IDENTIFIER_POINTER (DECL_NAME (decl)); - - if (TREE_CODE (TREE_TYPE (decl)) == INTEGER_TYPE - || 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); + /* The sun4 assembler does not grok this. */ - fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, ival); - fprintf (asmfile, "\",0x%x,0,0,0\n", N_LSYM); -#endif - return 1; - } - else if (TREE_CODE (TREE_TYPE (decl)) == REAL_TYPE) - { - /* don't know how to do this yet. */ - } - break; + if (TREE_CODE (TREE_TYPE (decl)) == INTEGER_TYPE + || TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE) + { + HOST_WIDE_INT ival = TREE_INT_CST_LOW (DECL_INITIAL (decl)); + + dbxout_begin_complex_stabs (); + stabstr_I (DECL_NAME (decl)); + stabstr_S (":c=i"); + stabstr_D (ival); + dbxout_finish_complex_stabs (0, N_LSYM, 0, 0, 0); + DBXOUT_DECR_NESTING; + return 1; } - /* else it is something we handle like a normal variable. */ + else + break; } + /* else it is something we handle like a normal variable. */ SET_DECL_RTL (decl, eliminate_regs (DECL_RTL (decl), 0, NULL_RTX)); #ifdef LEAF_REG_REMAP @@ -2156,6 +2666,7 @@ dbxout_symbol (decl, local) default: break; } + DBXOUT_DECR_NESTING; return result; } @@ -2166,12 +2677,12 @@ 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; + STAB_CODE_TYPE code; + rtx addr = 0; + int number = 0; int regno = -1; /* Don't mention a variable at all @@ -2186,14 +2697,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) @@ -2213,20 +2724,50 @@ 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 - && GET_CODE (XEXP (home, 0)) == SYMBOL_REF) + if (MEM_P (home) && GET_CODE (XEXP (home, 0)) == SYMBOL_REF) { if (TREE_PUBLIC (decl)) { letter = 'G'; - current_sym_code = N_GSYM; + code = N_GSYM; } else { - current_sym_addr = XEXP (home, 0); + addr = XEXP (home, 0); letter = decl_function_context (decl) ? 'V' : 'S'; + /* Some ports can transform a symbol ref into a label ref, + because the symbol ref is too far away and has to be + dumped into a constant pool. Alternatively, the symbol + in the constant pool might be referenced by a different + symbol. */ + if (GET_CODE (addr) == SYMBOL_REF + && CONSTANT_POOL_ADDRESS_P (addr)) + { + bool marked; + rtx tmp = get_pool_constant_mark (addr, &marked); + + if (GET_CODE (tmp) == SYMBOL_REF) + { + addr = tmp; + if (CONSTANT_POOL_ADDRESS_P (addr)) + get_pool_constant_mark (addr, &marked); + else + marked = true; + } + else if (GET_CODE (tmp) == LABEL_REF) + { + addr = tmp; + marked = true; + } + + /* If all references to the constant pool were optimized + out, we just ignore the symbol. */ + if (!marked) + return 0; + } + /* This should be the same condition as in assemble_variable, but we don't have access to dont_output_data here. So, instead, we rely on the fact that error_mark_node initializers always @@ -2234,45 +2775,30 @@ dbxout_symbol_location (decl, type, suffix, home) if (DECL_INITIAL (decl) == 0 || (!strcmp (lang_hooks.name, "GNU C++") && DECL_INITIAL (decl) == error_mark_node)) - current_sym_code = N_LCSYM; + code = N_LCSYM; else if (DECL_IN_TEXT_SECTION (decl)) /* This is not quite right, but it's the closest of all the codes that Unix defines. */ - current_sym_code = DBX_STATIC_CONST_VAR_CODE; + code = DBX_STATIC_CONST_VAR_CODE; else { - /* Some ports can transform a symbol ref into a label ref, - because the symbol ref is too far away and has to be - dumped into a constant pool. Alternatively, the symbol - in the constant pool might be referenced by a different - symbol. */ - if (GET_CODE (current_sym_addr) == SYMBOL_REF - && CONSTANT_POOL_ADDRESS_P (current_sym_addr)) - { - rtx tmp = get_pool_constant (current_sym_addr); - - if (GET_CODE (tmp) == SYMBOL_REF - || GET_CODE (tmp) == LABEL_REF) - current_sym_addr = tmp; - } - /* Ultrix `as' seems to need this. */ #ifdef DBX_STATIC_STAB_DATA_SECTION data_section (); #endif - current_sym_code = N_STSYM; + code = N_STSYM; } } } else if (regno >= 0) { letter = 'r'; - current_sym_code = N_RSYM; - current_sym_value = DBX_REGISTER_NUMBER (regno); + code = N_RSYM; + number = 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 @@ -2284,24 +2810,22 @@ 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; + code = N_RSYM; if (REGNO (XEXP (home, 0)) >= FIRST_PSEUDO_REGISTER) return 0; - current_sym_value = DBX_REGISTER_NUMBER (REGNO (XEXP (home, 0))); + number = DBX_REGISTER_NUMBER (REGNO (XEXP (home, 0))); } else { - current_sym_code = N_LSYM; + code = N_LSYM; /* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))). We want the value of that CONST_INT. */ - current_sym_value - = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home, 0), 0)); + number = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home, 0), 0)); } /* Effectively do build_pointer_type, but don't cache this type, @@ -2311,22 +2835,22 @@ 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)); + code = N_LSYM; + number = 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) { - current_sym_code = N_LSYM; + code = N_LSYM; /* RTL looks like (MEM (PLUS (REG...) (CONST_INT...))) We want the value of that CONST_INT. */ - current_sym_value = DEBUGGER_AUTO_OFFSET (XEXP (home, 0)); + number = 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 @@ -2340,9 +2864,9 @@ dbxout_symbol_location (decl, type, suffix, home) variable, thereby avoiding the need for a register. In such cases we're forced to lie to debuggers and tell them that this variable was itself `static'. */ - current_sym_code = N_LCSYM; + code = N_LCSYM; letter = 'V'; - current_sym_addr = XEXP (XEXP (home, 0), 0); + addr = XEXP (XEXP (home, 0), 0); } else if (GET_CODE (home) == CONCAT) { @@ -2363,12 +2887,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) dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 1)); else @@ -2382,18 +2900,20 @@ dbxout_symbol_location (decl, type, suffix, home) return 0; /* Ok, start a symtab entry and output the variable name. */ + emit_pending_bincls_if_required (); FORCE_TEXT; #ifdef DBX_STATIC_BLOCK_START - DBX_STATIC_BLOCK_START (asmfile, current_sym_code); + DBX_STATIC_BLOCK_START (asm_out_file, code); #endif + dbxout_begin_complex_stabs_noforcetext (); dbxout_symbol_name (decl, suffix, letter); dbxout_type (type, 0); - dbxout_finish_symbol (decl); + dbxout_finish_complex_stabs (decl, code, addr, 0, number); #ifdef DBX_STATIC_BLOCK_END - DBX_STATIC_BLOCK_END (asmfile, current_sym_code); + DBX_STATIC_BLOCK_END (asm_out_file, code); #endif return 1; } @@ -2402,70 +2922,40 @@ 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; + tree 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)); + name = DECL_ASSEMBLER_NAME (decl); else /* ...but if we're function-local, we don't want to include the junk added by ASM_FORMAT_PRIVATE_NAME. */ - name = IDENTIFIER_POINTER (DECL_NAME (decl)); + name = DECL_NAME (decl); - if (name == 0) - name = "(anon)"; - fprintf (asmfile, "%s\"%s%s:", ASM_STABS_OP, name, - (suffix ? suffix : "")); + if (name) + stabstr_I (name); + else + stabstr_S ("(anon)"); + if (suffix) + stabstr_S (suffix); + stabstr_C (':'); if (letter) - putc (letter, asmfile); -} - -static void -dbxout_prepare_symbol (decl) - tree decl ATTRIBUTE_UNUSED; -{ -#ifdef WINNING_GDB - const char *filename = DECL_SOURCE_FILE (decl); - - dbxout_source_file (asmfile, filename); -#endif -} - -static void -dbxout_finish_symbol (sym) - tree sym; -{ -#ifdef DBX_FINISH_SYMBOL - DBX_FINISH_SYMBOL (sym); -#else - int line = 0; - if (use_gnu_debug_info_extensions && sym != 0) - line = DECL_SOURCE_LINE (sym); - - fprintf (asmfile, "\",%d,0,%d,", current_sym_code, line); - if (current_sym_addr) - output_addr_const (asmfile, current_sym_addr); - else - fprintf (asmfile, "%d", current_sym_value); - putc ('\n', asmfile); -#endif + stabstr_C (letter); } /* Output definitions of all the decls in a chain. Return nonzero if anything was output */ int -dbxout_syms (syms) - tree syms; +dbxout_syms (tree syms) { int result = 0; while (syms) @@ -2489,13 +2979,21 @@ 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); + tree eff_type; + char letter; + STAB_CODE_TYPE code; + int number; /* Perform any necessary register eliminations on the parameter's rtl, so that the debugging output will be accurate. */ @@ -2512,107 +3010,63 @@ dbxout_parms (parms) if (PARM_PASSED_IN_MEMORY (parms)) { - rtx addr = XEXP (DECL_INCOMING_RTL (parms), 0); + rtx inrtl = XEXP (DECL_INCOMING_RTL (parms), 0); /* ??? Here we assume that the parm address is indexed off the frame pointer or arg pointer. If that is not true, we produce meaningless results, but do not crash. */ - if (GET_CODE (addr) == PLUS - && GET_CODE (XEXP (addr, 1)) == CONST_INT) - current_sym_value = INTVAL (XEXP (addr, 1)); - else - current_sym_value = 0; - - current_sym_code = N_PSYM; - current_sym_addr = 0; - - FORCE_TEXT; - if (DECL_NAME (parms)) - { - current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (parms)); - - fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP, - IDENTIFIER_POINTER (DECL_NAME (parms)), - DBX_MEMPARM_STABS_LETTER); - } + if (GET_CODE (inrtl) == PLUS + && GET_CODE (XEXP (inrtl, 1)) == CONST_INT) + number = INTVAL (XEXP (inrtl, 1)); else - { - current_sym_nchars = 8; - fprintf (asmfile, "%s\"(anon):%c", ASM_STABS_OP, - DBX_MEMPARM_STABS_LETTER); - } - - /* It is quite tempting to use: - - dbxout_type (TREE_TYPE (parms), 0); - - as the next statement, rather than using DECL_ARG_TYPE(), so - that gcc reports the actual type of the parameter, rather - than the promoted type. This certainly makes GDB's life - easier, at least for some ports. The change is a bad idea - however, since GDB expects to be able access the type without - performing any conversions. So for example, if we were - passing a float to an unprototyped function, gcc will store a - double on the stack, but if we emit a stab saying the type is a - float, then gdb will only read in a single value, and this will - produce an erroneous value. */ - dbxout_type (DECL_ARG_TYPE (parms), 0); - current_sym_value = DEBUGGER_ARG_OFFSET (current_sym_value, addr); - dbxout_finish_symbol (parms); + number = 0; + + code = N_PSYM; + number = DEBUGGER_ARG_OFFSET (number, inrtl); + letter = 'p'; + + /* It is quite tempting to use TREE_TYPE (parms) instead + of DECL_ARG_TYPE (parms) for the eff_type, so that gcc + reports the actual type of the parameter, rather than + the promoted type. This certainly makes GDB's life + easier, at least for some ports. The change is a bad + idea however, since GDB expects to be able access the + type without performing any conversions. So for + example, if we were passing a float to an unprototyped + function, gcc will store a double on the stack, but if + we emit a stab saying the type is a float, then gdb + will only read in a single value, and this will produce + an erroneous value. */ + eff_type = DECL_ARG_TYPE (parms); } - else if (GET_CODE (DECL_RTL (parms)) == REG) + else if (REG_P (DECL_RTL (parms))) { rtx best_rtl; - char regparm_letter; - tree parm_type; - /* Parm passed in registers and lives in registers or nowhere. */ - - current_sym_code = DBX_REGPARM_STABS_CODE; - regparm_letter = DBX_REGPARM_STABS_LETTER; - current_sym_addr = 0; - /* If parm lives in a register, use that register; - pretend the parm was passed there. It would be more consistent - to describe the register where the parm was passed, - but in practice that register usually holds something else. - - If we use DECL_RTL, then we must use the declared type of - the variable, not the type that it arrived in. */ + /* Parm passed in registers and lives in registers or nowhere. */ + code = DBX_REGPARM_STABS_CODE; + letter = DBX_REGPARM_STABS_LETTER; + + /* For parms passed in registers, it is better to use the + declared type of the variable, not the type it arrived in. */ + eff_type = TREE_TYPE (parms); + + /* If parm lives in a register, use that register; pretend + the parm was passed there. It would be more consistent + to describe the register where the parm was passed, but + in practice that register usually holds something else. + If the parm lives nowhere, use the register where it + was passed. */ if (REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER) - { - best_rtl = DECL_RTL (parms); - parm_type = TREE_TYPE (parms); - } - /* If the parm lives nowhere, use the register where it was - passed. It is also better to use the declared type here. */ - else - { - best_rtl = DECL_INCOMING_RTL (parms); - parm_type = TREE_TYPE (parms); - } - current_sym_value = DBX_REGISTER_NUMBER (REGNO (best_rtl)); - - FORCE_TEXT; - if (DECL_NAME (parms)) - { - current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (parms)); - fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP, - IDENTIFIER_POINTER (DECL_NAME (parms)), - regparm_letter); - } + best_rtl = DECL_RTL (parms); else - { - current_sym_nchars = 8; - fprintf (asmfile, "%s\"(anon):%c", ASM_STABS_OP, - regparm_letter); - } + best_rtl = DECL_INCOMING_RTL (parms); - dbxout_type (parm_type, 0); - dbxout_finish_symbol (parms); + number = DBX_REGISTER_NUMBER (REGNO (best_rtl)); } - 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 @@ -2626,73 +3080,44 @@ dbxout_parms (parms) The debugger will know from the type that it was actually passed by invisible reference. */ - char regparm_letter; - /* Parm passed in registers and lives in registers or nowhere. */ - - current_sym_code = DBX_REGPARM_STABS_CODE; - if (use_gnu_debug_info_extensions) - regparm_letter = GDB_INV_REF_REGPARM_STABS_LETTER; - else - regparm_letter = DBX_REGPARM_STABS_LETTER; + code = DBX_REGPARM_STABS_CODE; + + /* GDB likes this marked with a special letter. */ + letter = (use_gnu_debug_info_extensions + ? 'a' : DBX_REGPARM_STABS_LETTER); + eff_type = TREE_TYPE (parms); /* DECL_RTL looks like (MEM (REG...). Get the register number. If it is an unallocated pseudo-reg, then use the register where - it was passed instead. */ - if (REGNO (XEXP (DECL_RTL (parms), 0)) < FIRST_PSEUDO_REGISTER) - current_sym_value = REGNO (XEXP (DECL_RTL (parms), 0)); - else - current_sym_value = REGNO (DECL_INCOMING_RTL (parms)); + it was passed instead. + ??? Why is DBX_REGISTER_NUMBER not used here? */ - current_sym_addr = 0; - - FORCE_TEXT; - if (DECL_NAME (parms)) - { - current_sym_nchars - = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms))); - - fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP, - IDENTIFIER_POINTER (DECL_NAME (parms)), - regparm_letter); - } + if (REGNO (XEXP (DECL_RTL (parms), 0)) < FIRST_PSEUDO_REGISTER) + number = REGNO (XEXP (DECL_RTL (parms), 0)); else - { - current_sym_nchars = 8; - fprintf (asmfile, "%s\"(anon):%c", ASM_STABS_OP, - regparm_letter); - } - - dbxout_type (TREE_TYPE (parms), 0); - dbxout_finish_symbol (parms); + number = REGNO (DECL_INCOMING_RTL (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 (MEM (MEM (PLUS (REG ...) (CONST_INT ...)))) or it could look like (MEM (MEM (REG))). */ - 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) - current_sym_value = 0; + + code = N_PSYM; + letter = 'v'; + eff_type = TREE_TYPE (parms); + + if (!REG_P (XEXP (XEXP (DECL_RTL (parms), 0), 0))) + number = INTVAL (XEXP (XEXP (XEXP (DECL_RTL (parms), 0), 0), 1)); else - current_sym_value - = INTVAL (XEXP (XEXP (XEXP (DECL_RTL (parms), 0), 0), 1)); - current_sym_addr = 0; - current_sym_code = N_PSYM; - - FORCE_TEXT; - fprintf (asmfile, "%s\"%s:v", ASM_STABS_OP, decl_name); - - current_sym_value - = DEBUGGER_ARG_OFFSET (current_sym_value, - XEXP (XEXP (DECL_RTL (parms), 0), 0)); - dbxout_type (TREE_TYPE (parms), 0); - dbxout_finish_symbol (parms); + number = 0; + + number = DEBUGGER_ARG_OFFSET (number, + XEXP (XEXP (DECL_RTL (parms), 0), 0)); } - 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. @@ -2701,54 +3126,45 @@ dbxout_parms (parms) { /* Parm was passed in registers but lives on the stack. */ - current_sym_code = N_PSYM; + code = N_PSYM; + letter = 'p'; + eff_type = TREE_TYPE (parms); + /* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))), 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) - current_sym_value = 0; + if (!REG_P (XEXP (DECL_RTL (parms), 0))) + number = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1)); else - current_sym_value - = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1)); - - current_sym_addr = 0; + number = 0; /* Make a big endian correction if the mode of the type of the parameter is not the same as the mode of the rtl. */ if (BYTES_BIG_ENDIAN && TYPE_MODE (TREE_TYPE (parms)) != GET_MODE (DECL_RTL (parms)) && GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms))) < UNITS_PER_WORD) - { - current_sym_value += - GET_MODE_SIZE (GET_MODE (DECL_RTL (parms))) - - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms))); - } - - FORCE_TEXT; - if (DECL_NAME (parms)) - { - current_sym_nchars - = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms))); - - fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP, - IDENTIFIER_POINTER (DECL_NAME (parms)), - DBX_MEMPARM_STABS_LETTER); - } - else - { - current_sym_nchars = 8; - fprintf (asmfile, "%s\"(anon):%c", ASM_STABS_OP, - DBX_MEMPARM_STABS_LETTER); - } + number += (GET_MODE_SIZE (GET_MODE (DECL_RTL (parms))) + - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms)))); + } + else + /* ??? We don't know how to represent this argument. */ + continue; - current_sym_value - = DEBUGGER_ARG_OFFSET (current_sym_value, - XEXP (DECL_RTL (parms), 0)); - dbxout_type (TREE_TYPE (parms), 0); - dbxout_finish_symbol (parms); + dbxout_begin_complex_stabs (); + + if (DECL_NAME (parms)) + { + stabstr_I (DECL_NAME (parms)); + stabstr_C (':'); } + else + stabstr_S ("(anon):"); + stabstr_C (letter); + dbxout_type (eff_type, 0); + dbxout_finish_complex_stabs (parms, code, 0, 0, number); } + DBXOUT_DECR_NESTING; } /* Output definitions for the places where parms live during the function, @@ -2763,17 +3179,16 @@ 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)) { - dbxout_prepare_symbol (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)); @@ -2781,29 +3196,64 @@ 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) { - putc (',', asmfile); + stabstr_C (','); dbxout_type (TREE_VALUE (args), 0); - CHARS (1); args = TREE_CHAIN (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 (asm_out_file, label); +#else + dbxout_begin_stabn (N_LBRAC); + if (DBX_BLOCKS_FUNCTION_RELATIVE) + dbxout_stab_value_label_diff (label, begin_label); + else + dbxout_stab_value_label (label); +#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 (asm_out_file, label); +#else + dbxout_begin_stabn (N_RBRAC); + if (DBX_BLOCKS_FUNCTION_RELATIVE) + dbxout_stab_value_label_diff (label, begin_label); + else + dbxout_stab_value_label (label); +#endif +} + /* Output everything about a symbol block (a BLOCK node that represents a scope level), including recursive output of contained blocks. @@ -2822,20 +3272,10 @@ 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 + const char *begin_label + = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0); while (block) { @@ -2843,10 +3283,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; @@ -2854,17 +3292,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)) { @@ -2872,59 +3318,33 @@ 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); - fprintf (asmfile, "\n"); -#endif + dbxout_begin_complex_stabs (); + stabstr_I (DECL_NAME (decl)); + stabstr_S (":C1"); + dbxout_finish_complex_stabs (0, N_CATCH, 0, + scope_start, 0); 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); @@ -2937,10 +3357,26 @@ 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; + + if (DECL_IGNORED_P (decl)) + return; + + 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); @@ -2948,3 +3384,5 @@ dbxout_begin_function (decl) #endif /* DBX_DEBUGGING_INFO */ #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */ + +#include "gt-dbxout.h"