/* Output dbx-format symbol table information from GNU compiler.
Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
- 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
+ 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
+ 2011 Free Software Foundation, Inc.
This file is part of GCC.
GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
-Software Foundation; either version 2, or (at your option) any later
+Software Foundation; either version 3, or (at your option) any later
version.
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
for more details.
You should have received a copy of the GNU General Public License
-along with GCC; see the file COPYING. If not, write to the Free
-Software Foundation, 59 Temple Place - Suite 330, Boston, MA
-02111-1307, USA. */
+along with GCC; see the file COPYING3. If not see
+<http://www.gnu.org/licenses/>. */
/* Output dbx-format symbol table data.
#include "reload.h"
#include "output.h"
#include "dbxout.h"
+#include "diagnostic-core.h"
#include "toplev.h"
#include "tm_p.h"
#include "ggc.h"
#include "debug.h"
#include "function.h"
#include "target.h"
+#include "common/common-target.h"
#include "langhooks.h"
+#include "obstack.h"
+#include "expr.h"
+#include "cgraph.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
#define NO_DBX_BNSYM_ENSYM 0
#endif
+#ifndef NO_DBX_MAIN_SOURCE_DIRECTORY
+#define NO_DBX_MAIN_SOURCE_DIRECTORY 0
+#endif
+
#ifndef DBX_BLOCKS_FUNCTION_RELATIVE
#define DBX_BLOCKS_FUNCTION_RELATIVE 0
#endif
#define DBX_LINES_FUNCTION_RELATIVE 0
#endif
+#ifndef DBX_CONTIN_LENGTH
+#define DBX_CONTIN_LENGTH 80
+#endif
+
+#ifndef DBX_CONTIN_CHAR
+#define DBX_CONTIN_CHAR '\\'
+#endif
+
enum typestatus {TYPE_UNSEEN, TYPE_XREF, TYPE_DEFINED};
/* Structure recording information about a C data type.
The file_number and type_number elements are used if DBX_USE_BINCL
is defined. */
-struct typeinfo GTY(())
-{
+struct GTY(()) typeinfo {
enum typestatus status;
int file_number;
int type_number;
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
static GTY(()) int dbxout_source_line_counter;
-/* Nonzero if we have actually used any of the GDB extensions
- to the debugging format. The idea is that we use them for the
- first time only if there's a strong reason, but once we have done that,
- we use them whenever convenient. */
-
-static GTY(()) int have_used_extensions = 0;
-
/* Number for the next N_SOL filename stabs label. The number 0 is reserved
for the N_SO filename stabs label. */
static const char *base_input_file;
#ifdef DEBUG_SYMS_TEXT
-#define FORCE_TEXT function_section (current_function_decl);
+#define FORCE_TEXT switch_to_section (current_function_section ())
#else
#define FORCE_TEXT
#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) \
#endif
/* A C expression for the integer offset value of an argument (N_PSYM)
- having address X (an RTX). The nominal offset is OFFSET. */
+ having address X (an RTX). The nominal offset is OFFSET.
+ Note that we use OFFSET + 0 here to avoid the self-assign warning
+ when the macro is called in a context like
+ number = DEBUGGER_ARG_OFFSET(number, X) */
#ifndef DEBUGGER_ARG_OFFSET
-#define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET)
+#define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET + 0)
#endif
-/* 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 STAB_CODE_TYPE current_sym_code;
-static int current_sym_value;
-static rtx current_sym_addr;
-
-/* Number of chars of symbol-description generated so far for the
- current symbol. Used by CHARS and CONTIN. */
-
-static int current_sym_nchars;
-
-/* Report having output N chars of the current symbol-description. */
-
-#define CHARS(N) (current_sym_nchars += (N))
-
-/* Break the current symbol-description, generating a continuation,
- if it has become long. */
-
-#ifndef DBX_CONTIN_LENGTH
-#define DBX_CONTIN_LENGTH 80
-#endif
-
-#if DBX_CONTIN_LENGTH > 0
-#define CONTIN \
- do {if (current_sym_nchars > DBX_CONTIN_LENGTH) dbxout_continue ();} while (0)
-#else
-#define CONTIN do { } while (0)
-#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 inline void emit_pending_bincls_if_required (void);
static void dbxout_init (const char *);
-#ifndef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
-static unsigned int get_lang_number (void);
-#endif
+
static void dbxout_finish (const char *);
static void dbxout_start_source_file (unsigned, const char *);
static void dbxout_end_source_file (unsigned);
static void dbxout_typedefs (tree);
static void dbxout_type_index (tree);
-#if DBX_CONTIN_LENGTH > 0
-static void dbxout_continue (void);
-#endif
static void dbxout_args (tree);
static void dbxout_type_fields (tree);
-static void dbxout_type_method_1 (tree, const char *);
+static void dbxout_type_method_1 (tree);
static void dbxout_type_methods (tree);
-static void dbxout_range_type (tree);
+static void dbxout_range_type (tree, tree, tree);
static void dbxout_type (tree, int);
-static bool print_int_cst_bounds_in_octal_p (tree);
-static void print_int_cst_octal (tree);
-static void print_octal (unsigned HOST_WIDE_INT, int);
-static void print_wide_int (HOST_WIDE_INT);
+static bool print_int_cst_bounds_in_octal_p (tree, tree, tree);
+static bool is_fortran (void);
static void dbxout_type_name (tree);
static void dbxout_class_name_qualifiers (tree);
static int dbxout_symbol_location (tree, tree, const char *, rtx);
static void dbxout_symbol_name (tree, const char *, int);
-static void dbxout_prepare_symbol (tree);
-static void dbxout_finish_symbol (tree);
-static void dbxout_block (tree, int, tree);
+static void dbxout_common_name (tree, const char *, stab_code_type);
+static const char *dbxout_common_check (tree, int *);
static void dbxout_global_decl (tree);
static void dbxout_type_decl (tree, int);
static void dbxout_handle_pch (unsigned);
+static void debug_free_queue (void);
\f
/* The debug hooks structure. */
#if defined (DBX_DEBUGGING_INFO)
-static void dbxout_source_line (unsigned int, const char *);
+static void dbxout_source_line (unsigned int, const char *, int, bool);
static void dbxout_begin_prologue (unsigned int, const char *);
-static void dbxout_source_file (FILE *, const char *);
-static void dbxout_function_end (void);
+static void dbxout_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);
{
dbxout_init,
dbxout_finish,
+ debug_nothing_void,
debug_nothing_int_charstar,
debug_nothing_int_charstar,
dbxout_start_source_file,
dbxout_end_source_file,
dbxout_begin_block,
dbxout_end_block,
- debug_true_tree, /* ignore_block */
+ debug_true_const_tree, /* ignore_block */
dbxout_source_line, /* source_line */
dbxout_begin_prologue, /* begin_prologue */
debug_nothing_int_charstar, /* end_prologue */
+ debug_nothing_int_charstar, /* begin_epilogue */
debug_nothing_int_charstar, /* end_epilogue */
#ifdef DBX_FUNCTION_FIRST
dbxout_begin_function,
dbxout_function_decl,
dbxout_global_decl, /* global_decl */
dbxout_type_decl, /* type_decl */
- debug_nothing_tree_tree, /* imported_module_or_decl */
+ debug_nothing_tree_tree_tree_bool, /* 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 */
+ debug_nothing_rtx, /* var_location */
+ debug_nothing_void, /* switch_text_section */
+ debug_nothing_tree_tree, /* set_name */
+ 0, /* start_end_main_source_file */
+ TYPE_SYMTAB_IS_ADDRESS /* tree_type_symtab_field */
};
#endif /* DBX_DEBUGGING_INFO */
{
dbxout_init,
dbxout_finish,
+ debug_nothing_void,
debug_nothing_int_charstar,
debug_nothing_int_charstar,
dbxout_start_source_file,
dbxout_end_source_file,
xcoffout_begin_block,
xcoffout_end_block,
- debug_true_tree, /* ignore_block */
+ debug_true_const_tree, /* ignore_block */
xcoffout_source_line,
xcoffout_begin_prologue, /* begin_prologue */
debug_nothing_int_charstar, /* end_prologue */
+ debug_nothing_int_charstar, /* begin_epilogue */
xcoffout_end_epilogue,
debug_nothing_tree, /* begin_function */
xcoffout_end_function,
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_tree_tree_bool, /* 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 */
+ debug_nothing_rtx, /* var_location */
+ debug_nothing_void, /* switch_text_section */
+ debug_nothing_tree_tree, /* set_name */
+ 0, /* start_end_main_source_file */
+ TYPE_SYMTAB_IS_ADDRESS /* tree_type_symtab_field */
};
#endif /* XCOFF_DEBUGGING_INFO */
\f
+/* 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++;
+ }
+}
+
+\f
+/* 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 = XOBFINISH (&stabstr_ob, char *);
+
+ /* 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 = XOBFINISH (&stabstr_ob, char *);
+
+ 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) || defined (XCOFF_DEBUGGING_INFO)
+
+/* When -gused is used, emit debug info for only used symbols. But in
+ addition to the standard intercepted debug_hooks there are some
+ direct calls into this file, i.e., dbxout_symbol, dbxout_parms, and
+ dbxout_reg_params. Those routines may also be called from a higher
+ level intercepted routine. So to prevent recording data for an inner
+ call to one of these for an intercept, we maintain an intercept
+ nesting counter (debug_nesting). We only save the intercepted
+ arguments if the nesting is 1. */
+static int debug_nesting = 0;
+
+static tree *symbol_queue;
+static int symbol_queue_index = 0;
+static int symbol_queue_size = 0;
+
+#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)
+
+#endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */
+
#if defined (DBX_DEBUGGING_INFO)
+
static void
-dbxout_function_end (void)
+dbxout_function_end (tree decl ATTRIBUTE_UNUSED)
{
char lscope_label_name[100];
/* The Lscope label must be emitted even if we aren't doing anything
else; dbxout_block needs it. */
- function_section (current_function_decl);
-
- /* Convert Ltext into the appropriate format for local labels in case
+ switch_to_section (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);
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)
+ || !targetm_common.have_named_sections)
return;
/* By convention, GCC will mark the end of a function with an N_FUN
symbol and an empty string. */
-#ifdef DBX_OUTPUT_NFUN
- DBX_OUTPUT_NFUN (asm_out_file, lscope_label_name, current_function_decl);
-#else
- fprintf (asm_out_file, "%s\"\",%d,0,0,", ASM_STABS_OP, N_FUN);
- assemble_name (asm_out_file, lscope_label_name);
- putc ('-', asm_out_file);
- assemble_name (asm_out_file, XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0));
- fprintf (asm_out_file, "\n");
-#endif
+ if (flag_reorder_blocks_and_partition)
+ {
+ dbxout_begin_empty_stabs (N_FUN);
+ dbxout_stab_value_label_diff (crtl->subsections.hot_section_end_label,
+ crtl->subsections.hot_section_label);
+ dbxout_begin_empty_stabs (N_FUN);
+ dbxout_stab_value_label_diff (crtl->subsections.cold_section_end_label,
+ crtl->subsections.cold_section_label);
+ }
+ else
+ {
+ char begin_label[20];
+ /* Reference current function start using LFBB. */
+ ASM_GENERATE_INTERNAL_LABEL (begin_label, "LFBB", scope_labelno);
+ dbxout_begin_empty_stabs (N_FUN);
+ dbxout_stab_value_label_diff (lscope_label_name, begin_label);
+ }
if (!NO_DBX_BNSYM_ENSYM && !flag_debug_only_used_symbols)
- fprintf (asm_out_file, "%s%d,0,0\n", ASM_STABD_OP, N_ENSYM);
+ dbxout_stabd (N_ENSYM, 0);
}
#endif /* DBX_DEBUGGING_INFO */
-#ifndef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
/* Get lang description for N_SO stab. */
-
-static unsigned int
+static unsigned int ATTRIBUTE_UNUSED
get_lang_number (void)
{
const char *language_string = lang_hooks.name;
return N_SO_CC;
else if (strcmp (language_string, "GNU F77") == 0)
return N_SO_FORTRAN;
- else if (strcmp (language_string, "GNU F95") == 0)
+ else if (strcmp (language_string, "GNU Fortran") == 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 if (strcmp (language_string, "GNU Objective-C++") == 0)
+ return N_SO_OBJCPLUS;
else
return 0;
}
-#endif
+
+static bool
+is_fortran (void)
+{
+ unsigned int lang = get_lang_number ();
+
+ return (lang == N_SO_FORTRAN) || (lang == N_SO_FORTRAN90);
+}
/* At the beginning of compilation, start writing the symbol table.
Initialize `typevec' and output the standard data types of C. */
dbxout_init (const char *input_file_name)
{
char ltext_label_name[100];
+ bool used_ltext_label_name = false;
tree syms = lang_hooks.decls.getdecls ();
+ const char *mapped_name;
typevec_len = 100;
- typevec = ggc_calloc (typevec_len, sizeof typevec[0]);
+ typevec = ggc_alloc_cleared_vec_typeinfo (typevec_len);
+
+ /* 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
ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext", 0);
/* Put the current working directory in an N_SO symbol. */
- if (use_gnu_debug_info_extensions)
+ if (use_gnu_debug_info_extensions && !NO_DBX_MAIN_SOURCE_DIRECTORY)
{
static const char *cwd;
cwd = "/";
else if (!IS_DIR_SEPARATOR (cwd[strlen (cwd) - 1]))
cwd = concat (cwd, "/", NULL);
+ cwd = remap_debug_filename (cwd);
}
-
#ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asm_out_file, cwd);
#else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
- fprintf (asm_out_file, "%s", ASM_STABS_OP);
- output_quoted_string (asm_out_file, cwd);
- fprintf (asm_out_file, ",%d,0,%d,", N_SO, get_lang_number ());
- assemble_name (asm_out_file, ltext_label_name);
- fputc ('\n', asm_out_file);
+ 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 */
}
+ mapped_name = remap_debug_filename (input_file_name);
#ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
- DBX_OUTPUT_MAIN_SOURCE_FILENAME (asm_out_file, 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 (asm_out_file, "%s", ASM_STABS_OP);
- output_quoted_string (asm_out_file, input_file_name);
- fprintf (asm_out_file, ",%d,0,%d,", N_SO, get_lang_number ());
- assemble_name (asm_out_file, ltext_label_name);
- fputc ('\n', asm_out_file);
- text_section ();
- targetm.asm_out.internal_label (asm_out_file, "Ltext", 0);
-#endif /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
-
-#ifdef DBX_OUTPUT_GCC_MARKER
- DBX_OUTPUT_GCC_MARKER (asm_out_file);
+ DBX_OUTPUT_MAIN_SOURCE_FILENAME (asm_out_file, mapped_name);
#else
+ dbxout_begin_simple_stabs_desc (mapped_name, N_SO, get_lang_number ());
+ dbxout_stab_value_label (ltext_label_name);
+ used_ltext_label_name = true;
+#endif
+
+ if (used_ltext_label_name)
+ {
+ switch_to_section (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. */
- fprintf (asm_out_file, "%s\"gcc2_compiled.\",%d,0,0,0\n",
- ASM_STABS_OP, N_OPT);
+#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 = xmalloc (sizeof *current_file);
+ current_file = XNEW (struct dbx_file);
current_file->next = NULL;
current_file->file_number = 0;
current_file->next_type_number = 1;
static void
dbxout_typedefs (tree syms)
{
- for (; syms != NULL_TREE; syms = TREE_CHAIN (syms))
+ for (; syms != NULL_TREE; syms = DECL_CHAIN (syms))
{
if (TREE_CODE (syms) == TYPE_DECL)
{
static void
emit_bincl_stab (const char *name)
{
- fprintf (asm_out_file, "%s", ASM_STABS_OP);
- output_quoted_string (asm_out_file, name);
- fprintf (asm_out_file, ",%d,0,0,0\n", N_BINCL);
+ 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. */
const char *filename ATTRIBUTE_UNUSED)
{
#ifdef DBX_USE_BINCL
- struct dbx_file *n = xmalloc (sizeof *n);
+ struct dbx_file *n = XNEW (struct dbx_file);
n->next = current_file;
n->next_type_number = 1;
- /* Do not assign file number now.
+ /* 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;
+ n->pending_bincl_name = remap_debug_filename (filename);
pending_bincls = 1;
current_file = n;
#endif
#ifdef DBX_USE_BINCL
/* Emit EINCL stab only if BINCL is not pending. */
if (current_file->bincl_status == BINCL_PROCESSED)
- fprintf (asm_out_file, "%s%d,0,0,0\n", ASM_STABN_OP, N_EINCL);
+ {
+ dbxout_begin_stabn (N_EINCL);
+ dbxout_stab_value_zero ();
+ }
current_file->bincl_status = BINCL_NOT_REQUIRED;
current_file = current_file->next;
#endif
}
#if defined (DBX_DEBUGGING_INFO)
+
+static void dbxout_block (tree, int, tree);
+
/* Output debugging info to FILE to switch to sourcefile FILENAME. */
static void
-dbxout_source_file (FILE *file, const char *filename)
+dbxout_source_file (const char *filename)
{
if (lastfile == 0 && lastfile_is_base)
{
if (filename && (lastfile == 0 || strcmp (filename, lastfile)))
{
- 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 (asm_out_file, ",%d,0,0,", N_SOL);
- assemble_name (asm_out_file, ltext_label_name);
- fputc ('\n', asm_out_file);
- if (current_function_decl != NULL_TREE
- && DECL_SECTION_NAME (current_function_decl) != NULL_TREE)
- ; /* Don't change section amid function. */
- else
- {
- if (!in_text_section () && !in_unlikely_text_section ())
- text_section ();
- }
- targetm.asm_out.internal_label (file, "Ltext", source_label_number);
- source_label_number++;
+ /* Don't change section amid function. */
+ if (current_function_decl == NULL_TREE)
+ switch_to_section (text_section);
+
+ dbxout_begin_simple_stabs (remap_debug_filename (filename), N_SOL);
+ dbxout_stab_value_internal_label ("Ltext", &source_label_number);
lastfile = filename;
}
}
-/* Output N_BNSYM and line number symbol entry. */
+/* Output N_BNSYM, line number symbol entry, and local symbol at
+ function scope */
static void
dbxout_begin_prologue (unsigned int lineno, const char *filename)
&& !NO_DBX_FUNCTION_END
&& !NO_DBX_BNSYM_ENSYM
&& !flag_debug_only_used_symbols)
- fprintf (asm_out_file, "%s%d,0,0\n", ASM_STABD_OP, N_BNSYM);
+ dbxout_stabd (N_BNSYM, 0);
+
+ /* pre-increment the scope counter */
+ scope_labelno++;
- dbxout_source_line (lineno, filename);
+ dbxout_source_line (lineno, filename, 0, true);
+ /* Output function begin block at function scope, referenced
+ by dbxout_block, dbxout_source_line and dbxout_function_end. */
+ emit_pending_bincls_if_required ();
+ targetm.asm_out.internal_label (asm_out_file, "LFBB", scope_labelno);
}
/* Output a line number symbol entry for source file FILENAME and line
number LINENO. */
static void
-dbxout_source_line (unsigned int lineno, const char *filename)
+dbxout_source_line (unsigned int lineno, const char *filename,
+ int discriminator ATTRIBUTE_UNUSED,
+ bool is_stmt ATTRIBUTE_UNUSED)
{
- dbxout_source_file (asm_out_file, filename);
+ dbxout_source_file (filename);
#ifdef DBX_OUTPUT_SOURCE_LINE
- dbxout_source_line_counter += 1;
DBX_OUTPUT_SOURCE_LINE (asm_out_file, lineno, dbxout_source_line_counter);
#else
if (DBX_LINES_FUNCTION_RELATIVE)
{
- char label[100];
- dbxout_source_line_counter += 1;
-
- ASM_GENERATE_INTERNAL_LABEL (label, "LM", dbxout_source_line_counter);
- fprintf (asm_out_file, "%s%d,0,%d,", ASM_STABN_OP, N_SLINE, lineno);
- assemble_name (asm_out_file, label);
- putc ('-', asm_out_file);
- assemble_name (asm_out_file,
- XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0));
- putc ('\n', asm_out_file);
- targetm.asm_out.internal_label (asm_out_file, "LM",
- dbxout_source_line_counter);
+ char begin_label[20];
+ dbxout_begin_stabn_sline (lineno);
+ /* Reference current function start using LFBB. */
+ ASM_GENERATE_INTERNAL_LABEL (begin_label, "LFBB", scope_labelno);
+ dbxout_stab_value_internal_label_diff ("LM", &dbxout_source_line_counter,
+ begin_label);
}
else
- fprintf (asm_out_file, "%s%d,0,%d\n", ASM_STABD_OP, N_SLINE, lineno);
+ dbxout_stabd (N_SLINE, lineno);
#endif
}
dbxout_begin_function (decl);
#endif
dbxout_block (DECL_INITIAL (decl), 0, DECL_ARGUMENTS (decl));
- dbxout_function_end ();
+ dbxout_function_end (decl);
}
#endif /* DBX_DEBUGGING_INFO */
static void
dbxout_global_decl (tree decl)
{
- if (TREE_CODE (decl) == VAR_DECL
- && ! DECL_EXTERNAL (decl)
- && DECL_RTL_SET_P (decl)) /* Not necessary? */
+ if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl))
{
int saved_tree_used = TREE_USED (decl);
TREE_USED (decl) = 1;
DBX_OUTPUT_MAIN_SOURCE_FILE_END (asm_out_file, filename);
#elif defined DBX_OUTPUT_NULL_N_SO_AT_MAIN_SOURCE_FILE_END
{
- char letext_label[100];
- ASM_GENERATE_INTERNAL_LABEL (letext_label, "Letext", 0);
- fprintf (asm_out_file, "%s\"\",%d,0,0,", ASM_STABS_OP, N_SO);
- assemble_name (asm_out_file, letext_label);
- putc ('\n', asm_out_file);
- targetm.asm_out.internal_label (asm_out_file, "Letext", 0);
+ switch_to_section (text_section);
+ dbxout_begin_empty_stabs (N_SO);
+ dbxout_stab_value_internal_label ("Letext", 0);
}
#endif
debug_free_queue ();
dbxout_type_index (tree type)
{
#ifndef DBX_USE_BINCL
- fprintf (asm_out_file, "%d", TYPE_SYMTAB_ADDRESS (type));
- CHARS (3);
+ stabstr_D (TYPE_SYMTAB_ADDRESS (type));
#else
struct typeinfo *t = &typevec[TYPE_SYMTAB_ADDRESS (type)];
- fprintf (asm_out_file, "(%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 */
+\f
+/* Generate the symbols for any queued up type symbols we encountered
+ while generating the type info for some originally used symbol.
+ This might generate additional entries in the queue. Only when
+ the nesting depth goes to 0 is this routine called. */
static void
-dbxout_continue (void)
+debug_flush_symbol_queue (void)
{
- emit_pending_bincls_if_required ();
-#ifdef DBX_CONTIN_CHAR
- fprintf (asm_out_file, "%c", DBX_CONTIN_CHAR);
-#else
- fprintf (asm_out_file, "\\\\");
+ int i;
+
+ /* Make sure that additionally queued items are not flushed
+ prematurely. */
+
+ ++debug_nesting;
+
+ for (i = 0; i < symbol_queue_index; ++i)
+ {
+ /* If we pushed queued symbols then such symbols must be
+ output no matter what anyone else says. Specifically,
+ we need to make sure dbxout_symbol() thinks the symbol was
+ used and also we need to override TYPE_DECL_SUPPRESS_DEBUG
+ which may be set for outside reasons. */
+ int saved_tree_used = TREE_USED (symbol_queue[i]);
+ int saved_suppress_debug = TYPE_DECL_SUPPRESS_DEBUG (symbol_queue[i]);
+ TREE_USED (symbol_queue[i]) = 1;
+ TYPE_DECL_SUPPRESS_DEBUG (symbol_queue[i]) = 0;
+
+#ifdef DBX_DEBUGGING_INFO
+ dbxout_symbol (symbol_queue[i], 0);
#endif
- dbxout_finish_symbol (NULL_TREE);
- fprintf (asm_out_file, "%s\"", ASM_STABS_OP);
- current_sym_nchars = 0;
+
+ TREE_USED (symbol_queue[i]) = saved_tree_used;
+ TYPE_DECL_SUPPRESS_DEBUG (symbol_queue[i]) = saved_suppress_debug;
+ }
+
+ symbol_queue_index = 0;
+ --debug_nesting;
+}
+
+/* Queue a type symbol needed as part of the definition of a decl
+ symbol. These symbols are generated when debug_flush_symbol_queue()
+ is called. */
+
+static void
+debug_queue_symbol (tree decl)
+{
+ if (symbol_queue_index >= symbol_queue_size)
+ {
+ symbol_queue_size += 10;
+ symbol_queue = XRESIZEVEC (tree, symbol_queue, symbol_queue_size);
+ }
+
+ symbol_queue[symbol_queue_index++] = decl;
+}
+
+/* Free symbol queue. */
+static void
+debug_free_queue (void)
+{
+ if (symbol_queue)
+ {
+ free (symbol_queue);
+ symbol_queue = NULL;
+ symbol_queue_size = 0;
+ }
}
-#endif /* DBX_CONTIN_LENGTH > 0 */
\f
+/* 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. */
/* Output the name, type, position (in bits), size (in bits) of each
field that we can support. */
- for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
+ for (tem = TYPE_FIELDS (type); tem; tem = DECL_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)
+ if (error_operand_p (tem))
return;
/* Omit here local type decls until we know how to support them. */
if (TREE_CODE (tem) == TYPE_DECL
+ /* Omit here the nameless fields that are used to skip bits. */
+ || DECL_IGNORED_P (tem)
/* Omit fields whose position or size are variable or too large to
represent. */
|| (TREE_CODE (tem) == FIELD_DECL
&& (! host_integerp (bit_position (tem), 0)
|| ! DECL_SIZE (tem)
- || ! host_integerp (DECL_SIZE (tem), 1)))
- /* Omit here the nameless fields that are used to skip bits. */
- || DECL_IGNORED_P (tem))
+ || ! host_integerp (DECL_SIZE (tem), 1))))
continue;
else if (TREE_CODE (tem) != CONST_DECL)
CONTIN;
if (DECL_NAME (tem))
- {
- fprintf (asm_out_file, "%s:", IDENTIFIER_POINTER (DECL_NAME (tem)));
- CHARS (2 + IDENTIFIER_LENGTH (DECL_NAME (tem)));
- }
- else
- {
- fprintf (asm_out_file, ":");
- 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 ('/', asm_out_file);
- putc ((TREE_PRIVATE (tem) ? '0'
- : TREE_PROTECTED (tem) ? '1' : '2'),
- asm_out_file);
- CHARS (2);
+ stabstr_C ('/');
+ stabstr_C (DECL_ACCESSIBILITY_CHAR (tem));
}
dbxout_type ((TREE_CODE (tem) == FIELD_DECL
{
tree name = DECL_ASSEMBLER_NAME (tem);
- have_used_extensions = 1;
- fprintf (asm_out_file, ":%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 (asm_out_file, ",0,0;");
- CHARS (5);
- }
+ /* If TEM is non-static, GDB won't understand it. */
+ stabstr_S (",0,0;");
}
else
{
- putc (',', asm_out_file);
- print_wide_int (int_bit_position (tem));
- putc (',', asm_out_file);
- print_wide_int (tree_low_cst (DECL_SIZE (tem), 1));
- putc (';', asm_out_file);
- CHARS (3);
+ stabstr_C (',');
+ stabstr_D (int_bit_position (tem));
+ stabstr_C (',');
+ stabstr_D (tree_low_cst (DECL_SIZE (tem), 1));
+ stabstr_C (';');
}
}
}
}
\f
/* 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 (tree decl, const char *debug_name)
+dbxout_type_method_1 (tree decl)
{
char c1 = 'A', c2;
c2 = '.';
}
- fprintf (asm_out_file, ":%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 (';', asm_out_file);
- CHARS (1);
+ stabstr_D (tree_low_cst (DECL_VINDEX (decl), 0));
+ stabstr_C (';');
dbxout_type (DECL_CONTEXT (decl), 0);
- fprintf (asm_out_file, ";");
- CHARS (1);
+ stabstr_C (';');
}
}
\f
{
/* 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));
-
- 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)
These differ in the types of the arguments. */
for (last = NULL_TREE;
fndecl && (last == NULL_TREE || DECL_NAME (fndecl) == DECL_NAME (last));
- fndecl = TREE_CHAIN (fndecl))
+ fndecl = DECL_CHAIN (fndecl))
/* Output the name of the field (after overloading), as
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;
expects. */
if (need_prefix)
{
- tree name = DECL_NAME (fndecl);
- fprintf (asm_out_file, "%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 (';', asm_out_file);
- CHARS (1);
- }
+ stabstr_C (';');
}
}
/* Emit a "range" type specification, which has the form:
"r<index type>;<lower bound>;<upper bound>;".
- TYPE is an INTEGER_TYPE. */
+ TYPE is an INTEGER_TYPE, LOW and HIGH are the bounds. */
static void
-dbxout_range_type (tree type)
+dbxout_range_type (tree type, tree low, tree high)
{
- fprintf (asm_out_file, "r");
+ stabstr_C ('r');
if (TREE_TYPE (type))
dbxout_type (TREE_TYPE (type), 0);
else if (TREE_CODE (type) != INTEGER_TYPE)
dbxout_type_index (integer_type_node);
}
- if (TYPE_MIN_VALUE (type) != 0
- && host_integerp (TYPE_MIN_VALUE (type), 0))
+ stabstr_C (';');
+ if (low && host_integerp (low, 0))
{
- putc (';', asm_out_file);
- CHARS (1);
- if (print_int_cst_bounds_in_octal_p (type))
- print_int_cst_octal (TYPE_MIN_VALUE (type));
+ if (print_int_cst_bounds_in_octal_p (type, low, high))
+ stabstr_O (low);
else
- print_wide_int (tree_low_cst (TYPE_MIN_VALUE (type), 0));
+ stabstr_D (tree_low_cst (low, 0));
}
else
- {
- fprintf (asm_out_file, ";0");
- CHARS (2);
- }
+ stabstr_C ('0');
- if (TYPE_MAX_VALUE (type) != 0
- && host_integerp (TYPE_MAX_VALUE (type), 0))
+ stabstr_C (';');
+ if (high && host_integerp (high, 0))
{
- putc (';', asm_out_file);
- CHARS (1);
- if (print_int_cst_bounds_in_octal_p (type))
- print_int_cst_octal (TYPE_MAX_VALUE (type));
+ if (print_int_cst_bounds_in_octal_p (type, low, high))
+ stabstr_O (high);
else
- print_wide_int (tree_low_cst (TYPE_MAX_VALUE (type), 0));
- putc (';', asm_out_file);
- CHARS (1);
+ stabstr_D (tree_low_cst (high, 0));
+ stabstr_C (';');
}
else
- {
- fprintf (asm_out_file, ";-1;");
- CHARS (4);
- }
+ stabstr_S ("-1;");
}
\f
static void
dbxout_type (tree type, int full)
{
- tree tem;
- tree main_variant;
static int anonymous_type_number = 0;
+ tree tem, main_variant, low, high;
+
+ if (TREE_CODE (type) == INTEGER_TYPE)
+ {
+ if (TREE_TYPE (type) == 0)
+ {
+ low = TYPE_MIN_VALUE (type);
+ high = TYPE_MAX_VALUE (type);
+ }
- if (TREE_CODE (type) == VECTOR_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)));
+ else if (subrange_type_for_debug_p (type, &low, &high))
+ ;
+
+ /* If this is a subtype that should not be emitted as a subrange type,
+ use the base type. */
+ else
+ {
+ type = TREE_TYPE (type);
+ low = TYPE_MIN_VALUE (type);
+ high = TYPE_MAX_VALUE (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
if (next_type_number == typevec_len)
{
- typevec
- = ggc_realloc (typevec, (typevec_len * 2 * sizeof typevec[0]));
+ typevec = GGC_RESIZEVEC (struct typeinfo, typevec, typevec_len * 2);
memset (typevec + typevec_len, 0, typevec_len * sizeof typevec[0]);
typevec_len *= 2;
}
#endif
/* Output a definition now. */
-
- fprintf (asm_out_file, "=");
- 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. */
cv-qualified types if we're using extensions. */
if (TYPE_READONLY (type) > TYPE_READONLY (main_variant))
{
- putc ('k', asm_out_file);
- 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', asm_out_file);
- CHARS (1);
+ stabstr_C ('B');
dbxout_type (build_type_variant (type, TYPE_READONLY (type), 0), 0);
return;
}
switch (TREE_CODE (type))
{
case VOID_TYPE:
+ case NULLPTR_TYPE:
case LANG_TYPE:
/* For a void type, just define it as itself; i.e., "5=5".
This makes us consider it defined
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 (asm_out_file, "r");
- CHARS (1);
+ stabstr_C ('r');
dbxout_type_index (type);
- fprintf (asm_out_file, ";0;127;");
- CHARS (7);
+ stabstr_S (";0;127;");
}
/* If this is a subtype of another integer type, always prefer to
if (use_gnu_debug_info_extensions
&& TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
{
- have_used_extensions = 1;
- fprintf (asm_out_file, "@s%d;", TYPE_PRECISION (type));
- CHARS (5);
+ stabstr_S ("@s");
+ stabstr_D (TYPE_PRECISION (type));
+ stabstr_C (';');
}
- dbxout_range_type (type);
+ dbxout_range_type (type, low, high);
}
else
if (use_gnu_debug_info_extensions
&& TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
{
- have_used_extensions = 1;
- fprintf (asm_out_file, "@s%d;", TYPE_PRECISION (type));
- CHARS (5);
+ stabstr_S ("@s");
+ stabstr_D (TYPE_PRECISION (type));
+ stabstr_C (';');
}
- if (print_int_cst_bounds_in_octal_p (type))
+ if (print_int_cst_bounds_in_octal_p (type, low, high))
{
- fprintf (asm_out_file, "r");
- 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
else
dbxout_type_index (type);
- fprintf (asm_out_file, ";");
- CHARS (1);
- print_int_cst_octal (TYPE_MIN_VALUE (type));
- fprintf (asm_out_file, ";");
- CHARS (1);
- print_int_cst_octal (TYPE_MAX_VALUE (type));
- fprintf (asm_out_file, ";");
- CHARS (1);
+ stabstr_C (';');
+ stabstr_O (low);
+ stabstr_C (';');
+ stabstr_O (high);
+ stabstr_C (';');
}
else
/* Output other integer types as subranges of `int'. */
- dbxout_range_type (type);
+ dbxout_range_type (type, low, high);
}
break;
case REAL_TYPE:
+ case FIXED_POINT_TYPE:
/* This used to say `r1' and we used to take care
to make sure that `int' was type number 1. */
- fprintf (asm_out_file, "r");
- CHARS (1);
+ stabstr_C ('r');
dbxout_type_index (integer_type_node);
- putc (';', asm_out_file);
- CHARS (1);
- print_wide_int (int_size_in_bytes (type));
- fputs (";0;", asm_out_file);
- CHARS (3);
- break;
-
- case CHAR_TYPE:
- if (use_gnu_debug_info_extensions)
- {
- have_used_extensions = 1;
- fputs ("@s", asm_out_file);
- CHARS (2);
- print_wide_int (BITS_PER_UNIT * int_size_in_bytes (type));
- fputs (";-20;", asm_out_file);
- CHARS (4);
- }
- else
- {
- /* Output the type `char' as a subrange of itself.
- That is what pcc seems to do. */
- fprintf (asm_out_file, "r");
- CHARS (1);
- dbxout_type_index (char_type_node);
- fprintf (asm_out_file, ";0;%d;", TYPE_UNSIGNED (type) ? 255 : 127);
- CHARS (7);
- }
+ stabstr_C (';');
+ stabstr_D (int_size_in_bytes (type));
+ stabstr_S (";0;");
break;
case BOOLEAN_TYPE:
if (use_gnu_debug_info_extensions)
{
- have_used_extensions = 1;
- fputs ("@s", asm_out_file);
- CHARS (2);
- print_wide_int (BITS_PER_UNIT * int_size_in_bytes (type));
- fputs (";-16;", asm_out_file);
- 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 (asm_out_file, "eFalse:0,True:1,;");
- CHARS (17);
- }
- break;
-
- case FILE_TYPE:
- putc ('d', asm_out_file);
- CHARS (1);
- dbxout_type (TREE_TYPE (type), 0);
+ stabstr_S ("eFalse:0,True:1,;");
break;
case COMPLEX_TYPE:
if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
{
- fputs ("R3;", asm_out_file);
- CHARS (3);
- print_wide_int (2 * int_size_in_bytes (TREE_TYPE (type)));
- fputs (";0;", asm_out_file);
- 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', asm_out_file);
- CHARS (1);
- print_wide_int (int_size_in_bytes (type));
- fprintf (asm_out_file, "real:");
- CHARS (5);
+ stabstr_C ('s');
+ stabstr_D (int_size_in_bytes (type));
+ stabstr_S ("real:");
dbxout_type (TREE_TYPE (type), 0);
- fprintf (asm_out_file, ",0,%d;", TYPE_PRECISION (TREE_TYPE (type)));
- CHARS (7);
- fprintf (asm_out_file, "imag:");
- CHARS (5);
- dbxout_type (TREE_TYPE (type), 0);
- fprintf (asm_out_file, ",%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", asm_out_file);
- CHARS (2);
- print_wide_int (BITS_PER_UNIT * int_size_in_bytes (type));
- putc (';', asm_out_file);
- CHARS (1);
-
- /* Check if a bitstring type, which in Chill is
- different from a [power]set. */
- if (TYPE_STRING_FLAG (type))
- {
- fprintf (asm_out_file, "@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', asm_out_file);
- CHARS (1);
- dbxout_type (TYPE_DOMAIN (type), 0);
break;
case ARRAY_TYPE:
/* Make arrays of packed bits look like bitstrings for chill. */
if (TYPE_PACKED (type) && use_gnu_debug_info_extensions)
{
- have_used_extensions = 1;
- fputs ("@s", asm_out_file);
- CHARS (2);
- print_wide_int (BITS_PER_UNIT * int_size_in_bytes (type));
- fprintf (asm_out_file, ";@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;
}
different from an array of characters. */
if (TYPE_STRING_FLAG (type) && use_gnu_debug_info_extensions)
{
- have_used_extensions = 1;
- fprintf (asm_out_file, "@S;");
- CHARS (3);
+ stabstr_S ("@S;");
}
tem = TYPE_DOMAIN (type);
if (tem == NULL)
{
- fprintf (asm_out_file, "ar");
- CHARS (2);
+ stabstr_S ("ar");
dbxout_type_index (integer_type_node);
- fprintf (asm_out_file, ";0;-1;");
- CHARS (6);
+ stabstr_S (";0;-1;");
}
else
{
- fprintf (asm_out_file, "a");
- CHARS (1);
- dbxout_range_type (tem);
+ stabstr_C ('a');
+ dbxout_range_type (tem, TYPE_MIN_VALUE (tem), TYPE_MAX_VALUE (tem));
}
dbxout_type (TREE_TYPE (type), 0);
break;
+ case VECTOR_TYPE:
+ /* Make vectors look like an array. */
+ if (use_gnu_debug_info_extensions)
+ stabstr_S ("@V;");
+
+ /* Output "a" followed by a range type definition
+ for the index type of the array
+ followed by a reference to the target-type.
+ ar1;0;N;M for a C array of type M and size N+1. */
+ stabstr_C ('a');
+ dbxout_range_type (integer_type_node, size_zero_node,
+ size_int (TYPE_VECTOR_SUBPARTS (type) - 1));
+
+ dbxout_type (TREE_TYPE (type), 0);
+ break;
+
case RECORD_TYPE:
case UNION_TYPE:
case QUAL_UNION_TYPE:
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", asm_out_file);
- CHARS (2);
- if (TYPE_NAME (type) != 0)
+ stabstr_S ((TREE_CODE (type) == RECORD_TYPE) ? "xs" : "xu");
+ if (TYPE_NAME (type) != 0
+ /* The C frontend creates for anonymous variable length
+ records/unions TYPE_NAME with DECL_NAME NULL. */
+ && (TREE_CODE (TYPE_NAME (type)) != TYPE_DECL
+ || DECL_NAME (TYPE_NAME (type))))
dbxout_type_name (type);
else
{
- fprintf (asm_out_file, "$$%d", anonymous_type_number++);
- CHARS (5);
+ stabstr_S ("$$");
+ stabstr_D (anonymous_type_number++);
}
- fprintf (asm_out_file, ":");
- 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'), asm_out_file);
- 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 (binfo)
{
int i;
tree child;
- VEC (tree) *accesses = BINFO_BASE_ACCESSES (binfo);
-
+ VEC(tree,gc) *accesses = BINFO_BASE_ACCESSES (binfo);
+
if (use_gnu_debug_info_extensions)
{
if (BINFO_N_BASE_BINFOS (binfo))
{
- have_used_extensions = 1;
- fprintf (asm_out_file, "!%u,", BINFO_N_BASE_BINFOS (binfo));
- CHARS (8);
+ stabstr_C ('!');
+ stabstr_U (BINFO_N_BASE_BINFOS (binfo));
+ stabstr_C (',');
}
}
for (i = 0; BINFO_BASE_ITERATE (binfo, i, child); i++)
if (use_gnu_debug_info_extensions)
{
- have_used_extensions = 1;
- putc (BINFO_VIRTUAL_P (child) ? '1' : '0', asm_out_file);
- putc (access == access_public_node ? '2' :
- (access == access_protected_node ? '1' :'0'),
- asm_out_file);
- CHARS (2);
+ 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)
+ && (strcmp (lang_hooks.name, "GNU C++") == 0
+ || strcmp (lang_hooks.name, "GNU Objective-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
+ stabstr_D
(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 (',', asm_out_file);
- CHARS (1);
+ stabstr_D (tree_low_cst (BINFO_OFFSET (child), 0)
+ * BITS_PER_UNIT);
+ stabstr_C (',');
dbxout_type (BINFO_TYPE (child), 0);
- putc (';', asm_out_file);
- CHARS (1);
+ stabstr_C (';');
}
else
{
fields which have the same names at the types
they hold. */
dbxout_type_name (BINFO_TYPE (child));
- putc (':', asm_out_file);
- CHARS (1);
+ stabstr_C (':');
dbxout_type (BINFO_TYPE (child), full);
- putc (',', asm_out_file);
- CHARS (1);
- print_wide_int (tree_low_cst (BINFO_OFFSET (child), 0)
- * BITS_PER_UNIT);
- putc (',', asm_out_file);
- CHARS (1);
- print_wide_int
+ 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);
- putc (';', asm_out_file);
- CHARS (1);
+ stabstr_C (';');
}
}
}
dbxout_type_fields (type);
if (use_gnu_debug_info_extensions && TYPE_METHODS (type) != NULL_TREE)
{
- have_used_extensions = 1;
dbxout_type_methods (type);
}
- putc (';', asm_out_file);
- 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. */
&& TYPE_VFIELD (type))
{
- have_used_extensions = 1;
-
- /* Tell GDB+ that it may keep reading. */
- putc ('~', asm_out_file);
- 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 ('%', asm_out_file);
- CHARS (1);
- dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type)), 0);
- }
-
- putc (';', asm_out_file);
- CHARS (1);
+ figure out which field it's using in time. */
+ stabstr_S ("~%");
+ dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type)), 0);
+ stabstr_C (';');
}
break;
&& !full)
|| !COMPLETE_TYPE_P (type))
{
- fprintf (asm_out_file, "xe");
- CHARS (2);
+ stabstr_S ("xe");
dbxout_type_name (type);
typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
- putc (':', asm_out_file);
- CHARS (1);
+ stabstr_C (':');
return;
}
if (use_gnu_debug_info_extensions
&& TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
{
- fprintf (asm_out_file, "@s%d;", TYPE_PRECISION (type));
- CHARS (5);
+ stabstr_S ("@s");
+ stabstr_D (TYPE_PRECISION (type));
+ stabstr_C (';');
}
- putc ('e', asm_out_file);
- CHARS (1);
+ stabstr_C ('e');
for (tem = TYPE_VALUES (type); tem; tem = TREE_CHAIN (tem))
{
- fprintf (asm_out_file, "%s:", IDENTIFIER_POINTER (TREE_PURPOSE (tem)));
- CHARS (IDENTIFIER_LENGTH (TREE_PURPOSE (tem)) + 1);
- if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == 0)
- print_wide_int (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)));
+ tree value = TREE_VALUE (tem);
+
+ stabstr_I (TREE_PURPOSE (tem));
+ stabstr_C (':');
+
+ if (TREE_CODE (value) == CONST_DECL)
+ value = DECL_INITIAL (value);
+
+ if (TREE_INT_CST_HIGH (value) == 0)
+ stabstr_D (TREE_INT_CST_LOW (value));
+ else if (TREE_INT_CST_HIGH (value) == -1
+ && (HOST_WIDE_INT) TREE_INT_CST_LOW (value) < 0)
+ stabstr_D (TREE_INT_CST_LOW (value));
else
- print_int_cst_octal (TREE_VALUE (tem));
+ stabstr_O (value);
- putc (',', asm_out_file);
- CHARS (1);
+ stabstr_C (',');
if (TREE_CHAIN (tem) != 0)
CONTIN;
}
- putc (';', asm_out_file);
- CHARS (1);
+ stabstr_C (';');
break;
case POINTER_TYPE:
- putc ('*', asm_out_file);
- CHARS (1);
+ stabstr_C ('*');
dbxout_type (TREE_TYPE (type), 0);
break;
case METHOD_TYPE:
if (use_gnu_debug_info_extensions)
{
- have_used_extensions = 1;
- putc ('#', asm_out_file);
- CHARS (1);
+ stabstr_C ('#');
/* Write the argument types out longhand. */
dbxout_type (TYPE_METHOD_BASETYPE (type), 0);
- putc (',', asm_out_file);
- CHARS (1);
+ stabstr_C (',');
dbxout_type (TREE_TYPE (type), 0);
dbxout_args (TYPE_ARG_TYPES (type));
- putc (';', asm_out_file);
- CHARS (1);
+ stabstr_C (';');
}
else
/* Treat it as a function type. */
case OFFSET_TYPE:
if (use_gnu_debug_info_extensions)
{
- have_used_extensions = 1;
- putc ('@', asm_out_file);
- CHARS (1);
+ stabstr_C ('@');
dbxout_type (TYPE_OFFSET_BASETYPE (type), 0);
- putc (',', asm_out_file);
- CHARS (1);
+ stabstr_C (',');
dbxout_type (TREE_TYPE (type), 0);
}
else
case REFERENCE_TYPE:
if (use_gnu_debug_info_extensions)
- have_used_extensions = 1;
- putc (use_gnu_debug_info_extensions ? '&' : '*', asm_out_file);
- CHARS (1);
+ {
+ stabstr_C ('&');
+ }
+ else
+ stabstr_C ('*');
dbxout_type (TREE_TYPE (type), 0);
break;
case FUNCTION_TYPE:
- putc ('f', asm_out_file);
- CHARS (1);
+ stabstr_C ('f');
dbxout_type (TREE_TYPE (type), 0);
break;
should be printed in octal format. */
static bool
-print_int_cst_bounds_in_octal_p (tree type)
+print_int_cst_bounds_in_octal_p (tree type, tree low, tree high)
{
/* 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
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
+ && low && TREE_CODE (low) == INTEGER_CST
+ && high && TREE_CODE (high) == INTEGER_CST
&& (TYPE_PRECISION (type) > TYPE_PRECISION (integer_type_node)
|| ((TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
&& TYPE_UNSIGNED (type))
return FALSE;
}
-/* Print the value of integer constant C, in octal,
- handling double precision. */
-
-static void
-print_int_cst_octal (tree c)
-{
- unsigned HOST_WIDE_INT high = TREE_INT_CST_HIGH (c);
- unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (c);
- 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);
-
- fprintf (asm_out_file, "0");
- CHARS (1);
-
- if (excess == 3)
- {
- print_octal (high, HOST_BITS_PER_WIDE_INT / 3);
- print_octal (low, HOST_BITS_PER_WIDE_INT / 3);
- }
- 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 (asm_out_file, "%o%01o", (int) beg, (int) middle);
- CHARS (2);
- print_octal (end, HOST_BITS_PER_WIDE_INT / 3);
- }
-}
-
-static void
-print_octal (unsigned HOST_WIDE_INT value, int digits)
-{
- int i;
-
- for (i = digits - 1; i >= 0; i--)
- fprintf (asm_out_file, "%01o", (int) ((value >> (3 * i)) & 7));
-
- CHARS (digits);
-}
-
-/* Output C in decimal while adjusting the number of digits written. */
-
-static void
-print_wide_int (HOST_WIDE_INT c)
-{
- int digs = 0;
-
- fprintf (asm_out_file, HOST_WIDE_INT_PRINT_DEC, c);
-
- if (c < 0)
- digs++, c = -c;
-
- while (c > 0)
- c /= 10; digs++;
-
- CHARS (digs);
-}
-
/* Output the name of type TYPE, with no punctuation.
Such names can be set up either by typedef declarations
or by struct, enum and union tags. */
dbxout_type_name (tree type)
{
tree t = TYPE_NAME (type);
-
+
gcc_assert (t);
switch (TREE_CODE (t))
{
gcc_unreachable ();
}
- fprintf (asm_out_file, "%s", IDENTIFIER_POINTER (t));
- CHARS (IDENTIFIER_LENGTH (t));
+ stabstr_I (t);
}
/* Output leading leading struct or class names needed for qualifying
{
tree name = TYPE_NAME (context);
- emit_pending_bincls_if_required ();
-
if (TREE_CODE (name) == TYPE_DECL)
{
dbxout_class_name_qualifiers (name);
name = DECL_NAME (name);
}
- fprintf (asm_out_file, "%s::", IDENTIFIER_POINTER (name));
- CHARS (IDENTIFIER_LENGTH (name) + 2);
+ stabstr_I (name);
+ stabstr_S ("::");
}
}
\f
+/* This is a specialized subset of expand_expr for use by dbxout_symbol in
+ evaluating DECL_VALUE_EXPR. In particular, we stop if we find decls that
+ haven't been expanded, or if the expression is getting so complex we won't
+ be able to represent it in stabs anyway. Returns NULL on failure. */
+
+static rtx
+dbxout_expand_expr (tree expr)
+{
+ switch (TREE_CODE (expr))
+ {
+ case VAR_DECL:
+ /* We can't handle emulated tls variables, because the address is an
+ offset to the return value of __emutls_get_address, and there is no
+ way to express that in stabs. Also, there are name mangling issues
+ here. We end up with references to undefined symbols if we don't
+ disable debug info for these variables. */
+ if (!targetm.have_tls && DECL_THREAD_LOCAL_P (expr))
+ return NULL;
+ if (TREE_STATIC (expr)
+ && !TREE_ASM_WRITTEN (expr)
+ && !DECL_HAS_VALUE_EXPR_P (expr)
+ && !TREE_PUBLIC (expr)
+ && DECL_RTL_SET_P (expr)
+ && MEM_P (DECL_RTL (expr)))
+ {
+ /* If this is a var that might not be actually output,
+ return NULL, otherwise stabs might reference an undefined
+ symbol. */
+ struct varpool_node *node = varpool_get_node (expr);
+ if (!node || !node->needed)
+ return NULL;
+ }
+ /* FALLTHRU */
+
+ case PARM_DECL:
+ case RESULT_DECL:
+ if (DECL_HAS_VALUE_EXPR_P (expr))
+ return dbxout_expand_expr (DECL_VALUE_EXPR (expr));
+ /* FALLTHRU */
+
+ case CONST_DECL:
+ return DECL_RTL_IF_SET (expr);
+
+ case INTEGER_CST:
+ return expand_expr (expr, NULL_RTX, VOIDmode, EXPAND_INITIALIZER);
+
+ case COMPONENT_REF:
+ case ARRAY_REF:
+ case ARRAY_RANGE_REF:
+ case BIT_FIELD_REF:
+ {
+ enum machine_mode mode;
+ HOST_WIDE_INT bitsize, bitpos;
+ tree offset, tem;
+ int volatilep = 0, unsignedp = 0;
+ rtx x;
+
+ tem = get_inner_reference (expr, &bitsize, &bitpos, &offset,
+ &mode, &unsignedp, &volatilep, true);
+
+ x = dbxout_expand_expr (tem);
+ if (x == NULL || !MEM_P (x))
+ return NULL;
+ if (offset != NULL)
+ {
+ if (!host_integerp (offset, 0))
+ return NULL;
+ x = adjust_address_nv (x, mode, tree_low_cst (offset, 0));
+ }
+ if (bitpos != 0)
+ x = adjust_address_nv (x, mode, bitpos / BITS_PER_UNIT);
+
+ return x;
+ }
+
+ default:
+ return NULL;
+ }
+}
+
+/* Helper function for output_used_types. Queue one entry from the
+ used types hash to be output. */
+
+static int
+output_used_types_helper (void **slot, void *data)
+{
+ tree type = (tree) *slot;
+ VEC(tree, heap) **types_p = (VEC(tree, heap) **) data;
+
+ 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)))
+ VEC_quick_push (tree, *types_p, TYPE_STUB_DECL (type));
+ else if (TYPE_NAME (type)
+ && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
+ VEC_quick_push (tree, *types_p, TYPE_NAME (type));
+
+ return 1;
+}
+
+/* This is a qsort callback which sorts types and declarations into a
+ predictable order (types, then declarations, sorted by UID
+ within). */
+
+static int
+output_types_sort (const void *pa, const void *pb)
+{
+ const tree lhs = *((const tree *)pa);
+ const tree rhs = *((const tree *)pb);
+
+ if (TYPE_P (lhs))
+ {
+ if (TYPE_P (rhs))
+ return TYPE_UID (lhs) - TYPE_UID (rhs);
+ else
+ return 1;
+ }
+ else
+ {
+ if (TYPE_P (rhs))
+ return -1;
+ else
+ return DECL_UID (lhs) - DECL_UID (rhs);
+ }
+}
+
+
+/* Force all types used by this function to be output in debug
+ information. */
+
+static void
+output_used_types (void)
+{
+ if (cfun && cfun->used_types_hash)
+ {
+ VEC(tree, heap) *types;
+ int i;
+ tree type;
+
+ types = VEC_alloc (tree, heap, htab_elements (cfun->used_types_hash));
+ htab_traverse (cfun->used_types_hash, output_used_types_helper, &types);
+
+ /* Sort by UID to prevent dependence on hash table ordering. */
+ VEC_qsort (tree, types, output_types_sort);
+
+ FOR_EACH_VEC_ELT (tree, types, i, type)
+ debug_queue_symbol (type);
+
+ VEC_free (tree, heap, types);
+ }
+}
+
/* Output a .stabs for the symbol defined by DECL,
which must be a ..._DECL node in the normal namespace.
It may be a CONST_DECL, a FUNCTION_DECL, a PARM_DECL or a VAR_DECL.
tree type = TREE_TYPE (decl);
tree context = NULL_TREE;
int result = 0;
+ rtx decl_rtl;
/* "Intercept" dbxout_symbol() calls like we do all debug_hooks. */
++debug_nesting;
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. */
+ symbol nodes are flagged with TREE_USED. Ignore any that
+ aren't flagged as TREE_USED. */
if (flag_debug_only_used_symbols
&& (!TREE_USED (decl)
/* We now have a used symbol. We need to generate the info for
the symbol's type in addition to the symbol itself. These
type symbols are queued to be generated after were done with
- the symbol itself (done because the symbol's info is generated
- with fprintf's, etc. as it determines what's needed).
+ 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
emit_pending_bincls_if_required ();
- dbxout_prepare_symbol (decl);
-
- /* The output will always start with the symbol name,
- so always count that in the length-output-so-far. */
-
- if (DECL_NAME (decl) != 0)
- current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (decl));
-
switch (TREE_CODE (decl))
{
case CONST_DECL:
break;
case FUNCTION_DECL:
- if (DECL_RTL (decl) == 0)
+ decl_rtl = DECL_RTL_IF_SET (decl);
+ if (!decl_rtl)
DBXOUT_DECR_NESTING_AND_RETURN (0);
if (DECL_EXTERNAL (decl))
break;
context = decl_function_context (decl);
if (context == current_function_decl)
break;
- if (!MEM_P (DECL_RTL (decl))
- || GET_CODE (XEXP (DECL_RTL (decl), 0)) != SYMBOL_REF)
+ /* Don't mention an inline instance of a nested function. */
+ if (context && DECL_FROM_INLINE (decl))
+ break;
+ if (!MEM_P (decl_rtl)
+ || GET_CODE (XEXP (decl_rtl, 0)) != SYMBOL_REF)
break;
- FORCE_TEXT;
- fprintf (asm_out_file, "%s\"%s:%c", ASM_STABS_OP,
- IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
- TREE_PUBLIC (decl) ? 'F' : 'f');
- result = 1;
+ if (flag_debug_only_used_symbols)
+ output_used_types ();
- current_sym_code = N_FUN;
- current_sym_addr = XEXP (DECL_RTL (decl), 0);
+ dbxout_begin_complex_stabs ();
+ stabstr_I (DECL_ASSEMBLER_NAME (decl));
+ stabstr_S (TREE_PUBLIC (decl) ? ":F" : ":f");
+ result = 1;
if (TREE_TYPE (type))
dbxout_type (TREE_TYPE (type), 0);
mention the containing function name
as well as (since dbx wants it) our own assembler-name. */
if (context != 0)
- fprintf (asm_out_file, ",%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, 0), 0, 0);
break;
case TYPE_DECL:
|| TREE_CODE (type) == UNION_TYPE
|| TREE_CODE (type) == QUAL_UNION_TYPE)
&& TYPE_NAME (type) == decl
- && !(use_gnu_debug_info_extensions && have_used_extensions)
+ && !use_gnu_debug_info_extensions
&& !TREE_ASM_WRITTEN (TYPE_NAME (type))
/* Distinguish the implicit typedefs of C++
from explicit ones that might be found in C. */
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 (asm_out_file, "%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 (asm_out_file, "%s\"", ASM_STABS_OP);
+ dbxout_begin_complex_stabs ();
+ /* Output leading class/struct qualifiers. */
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 (asm_out_file, "%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
from explicit ones that might be found in C. */
&& DECL_ARTIFICIAL (decl))
{
- if (use_gnu_debug_info_extensions && have_used_extensions)
+ if (use_gnu_debug_info_extensions)
{
- putc ('T', asm_out_file);
+ stabstr_C ('T');
TREE_ASM_WRITTEN (TYPE_NAME (type)) = 1;
}
}
- putc ('t', asm_out_file);
- 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;
}
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 (asm_out_file, "%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 (asm_out_file, "%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. */
}
case PARM_DECL:
- /* Parm decls go in their own separate chains
- and are output by dbxout_reg_parms and dbxout_parms. */
- gcc_unreachable ();
+ if (DECL_HAS_VALUE_EXPR_P (decl))
+ decl = DECL_VALUE_EXPR (decl);
+
+ /* PARM_DECLs go in their own separate chain and are output by
+ dbxout_reg_parms and dbxout_parms, except for those that are
+ disguised VAR_DECLs like Out parameters in Ada. */
+ gcc_assert (TREE_CODE (decl) == VAR_DECL);
+
+ /* ... fall through ... */
case RESULT_DECL:
- /* Named return value, treat like a VAR_DECL. */
case VAR_DECL:
- if (! DECL_RTL_SET_P (decl))
- 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))
+ && (DECL_FILE_SCOPE_P (decl)
+ || TREE_CODE (DECL_CONTEXT (decl)) == BLOCK
+ || TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL)
+ && TREE_PUBLIC (decl) == 0)
{
- if (TREE_PUBLIC (decl) == 0)
- {
- /* The sun4 assembler does not grok this. */
- const char *name = IDENTIFIER_POINTER (DECL_NAME (decl));
+ /* The sun4 assembler does not grok this. */
- 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);
- fprintf (asm_out_file, "%s\"%s:c=i" HOST_WIDE_INT_PRINT_DEC
- "\",0x%x,0,0,0\n",
- ASM_STABS_OP, name, ival, N_LSYM);
- DBXOUT_DECR_NESTING;
- return 1;
- }
- else if (TREE_CODE (TREE_TYPE (decl)) == REAL_TYPE)
- {
- /* Don't know how to do this yet. */
- }
- 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 ();
+ dbxout_symbol_name (decl, NULL, 'c');
+ stabstr_S ("=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. */
+
+ decl_rtl = dbxout_expand_expr (decl);
+ if (!decl_rtl)
+ DBXOUT_DECR_NESTING_AND_RETURN (0);
- SET_DECL_RTL (decl, eliminate_regs (DECL_RTL (decl), 0, NULL_RTX));
+ decl_rtl = eliminate_regs (decl_rtl, VOIDmode, NULL_RTX);
#ifdef LEAF_REG_REMAP
if (current_function_uses_only_leaf_regs)
- leaf_renumber_regs_insn (DECL_RTL (decl));
+ leaf_renumber_regs_insn (decl_rtl);
#endif
- result = dbxout_symbol_location (decl, type, 0, DECL_RTL (decl));
+ result = dbxout_symbol_location (decl, type, 0, decl_rtl);
break;
default:
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;
- emit_pending_bincls_if_required ();
-
/* Don't mention a variable at all
if it was completely optimized into nothingness.
no letter at all, and N_LSYM, for auto variable,
r and N_RSYM for register variable. */
- if (MEM_P (home)
- && GET_CODE (XEXP (home, 0)) == SYMBOL_REF)
+ if (MEM_P (home) && GET_CODE (XEXP (home, 0)) == SYMBOL_REF)
{
if (TREE_PUBLIC (decl))
{
+ int offs;
letter = 'G';
- current_sym_code = N_GSYM;
+ code = N_GSYM;
+ if (NULL != dbxout_common_check (decl, &offs))
+ {
+ letter = 'V';
+ addr = 0;
+ number = offs;
+ }
}
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
if (DECL_INITIAL (decl) == 0
|| (!strcmp (lang_hooks.name, "GNU C++")
&& DECL_INITIAL (decl) == error_mark_node))
- current_sym_code = N_LCSYM;
+ {
+ int offs;
+ code = N_LCSYM;
+ if (NULL != dbxout_common_check (decl, &offs))
+ {
+ addr = 0;
+ number = offs;
+ letter = 'V';
+ code = N_GSYM;
+ }
+ }
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))
- {
- bool marked;
- rtx tmp = get_pool_constant_mark (current_sym_addr, &marked);
-
- if (GET_CODE (tmp) == SYMBOL_REF)
- {
- current_sym_addr = tmp;
- if (CONSTANT_POOL_ADDRESS_P (current_sym_addr))
- get_pool_constant_mark (current_sym_addr, &marked);
- else
- marked = true;
- }
- else if (GET_CODE (tmp) == LABEL_REF)
- {
- current_sym_addr = tmp;
- marked = true;
- }
-
- /* If all references to the constant pool were optimized
- out, we just ignore the symbol. */
- if (!marked)
- return 0;
- }
-
/* Ultrix `as' seems to need this. */
#ifdef DBX_STATIC_STAB_DATA_SECTION
- data_section ();
+ switch_to_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 (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
+#if !HARD_FRAME_POINTER_IS_ARG_POINTER
&& REGNO (XEXP (home, 0)) != ARG_POINTER_REGNUM
#endif
)))
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,
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 (MEM_P (home)
&& GET_CODE (XEXP (home, 0)) == PLUS
- && GET_CODE (XEXP (XEXP (home, 0), 1)) == CONST_INT)
+ && CONST_INT_P (XEXP (XEXP (home, 0), 1)))
{
- 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 (MEM_P (home)
&& GET_CODE (XEXP (home, 0)) == CONST)
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;
+ int offs;
+ code = N_LCSYM;
letter = 'V';
- current_sym_addr = XEXP (XEXP (home, 0), 0);
+ if (NULL == dbxout_common_check (decl, &offs))
+ addr = XEXP (XEXP (home, 0), 0);
+ else
+ {
+ addr = 0;
+ number = offs;
+ code = N_GSYM;
+ }
}
else if (GET_CODE (home) == CONCAT)
{
else
dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 0));
- dbxout_prepare_symbol (decl);
-
if (WORDS_BIG_ENDIAN)
dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 1));
else
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 (asm_out_file, 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 (asm_out_file, current_sym_code);
+ DBX_STATIC_BLOCK_END (asm_out_file, code);
#endif
return 1;
}
static void
dbxout_symbol_name (tree decl, const char *suffix, int letter)
{
- const char *name;
+ tree name;
- if (DECL_CONTEXT (decl)
+ 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 (asm_out_file, "%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, asm_out_file);
+ stabstr_C (letter);
}
+
+/* Output the common block name for DECL in a stabs.
+
+ Symbols in global common (.comm) get wrapped with an N_BCOMM/N_ECOMM pair
+ around each group of symbols in the same .comm area. The N_GSYM stabs
+ that are emitted only contain the offset in the common area. This routine
+ emits the N_BCOMM and N_ECOMM stabs. */
+
static void
-dbxout_prepare_symbol (tree decl ATTRIBUTE_UNUSED)
+dbxout_common_name (tree decl, const char *name, stab_code_type op)
{
- /* Initialize variables used to communicate each symbol's debug
- information to dbxout_finish_symbol with zeroes. */
-
- /* Cast avoids warning in old compilers. */
- current_sym_code = (STAB_CODE_TYPE) 0;
- current_sym_value = 0;
- current_sym_addr = 0;
+ dbxout_begin_complex_stabs ();
+ stabstr_S (name);
+ dbxout_finish_complex_stabs (decl, op, NULL_RTX, NULL, 0);
}
-static void
-dbxout_finish_symbol (tree sym)
+/* Check decl to determine whether it is a VAR_DECL destined for storage in a
+ common area. If it is, the return value will be a non-null string giving
+ the name of the common storage block it will go into. If non-null, the
+ value is the offset into the common block for that symbol's storage. */
+
+static const char *
+dbxout_common_check (tree decl, int *value)
{
-#ifdef DBX_FINISH_SYMBOL
- DBX_FINISH_SYMBOL (asm_out_file, sym);
-#else
- int line = 0;
- if (use_gnu_debug_info_extensions && sym != 0)
- line = DECL_SOURCE_LINE (sym);
+ rtx home;
+ rtx sym_addr;
+ const char *name = NULL;
+
+ /* If the decl isn't a VAR_DECL, or if it isn't static, or if
+ it does not have a value (the offset into the common area), or if it
+ is thread local (as opposed to global) then it isn't common, and shouldn't
+ be handled as such.
+
+ ??? DECL_THREAD_LOCAL_P check prevents problems with improper .stabs
+ for thread-local symbols. Can be handled via same mechanism as used
+ in dwarf2out.c. */
+ if (TREE_CODE (decl) != VAR_DECL
+ || !TREE_STATIC(decl)
+ || !DECL_HAS_VALUE_EXPR_P(decl)
+ || DECL_THREAD_LOCAL_P (decl)
+ || !is_fortran ())
+ return NULL;
+
+ home = DECL_RTL (decl);
+ if (home == NULL_RTX || GET_CODE (home) != MEM)
+ return NULL;
+
+ sym_addr = dbxout_expand_expr (DECL_VALUE_EXPR (decl));
+ if (sym_addr == NULL_RTX || GET_CODE (sym_addr) != MEM)
+ return NULL;
+
+ sym_addr = XEXP (sym_addr, 0);
+ if (GET_CODE (sym_addr) == CONST)
+ sym_addr = XEXP (sym_addr, 0);
+ if ((GET_CODE (sym_addr) == SYMBOL_REF || GET_CODE (sym_addr) == PLUS)
+ && DECL_INITIAL (decl) == 0)
+ {
- fprintf (asm_out_file, "\",%d,0,%d,", current_sym_code, line);
- if (current_sym_addr)
- output_addr_const (asm_out_file, current_sym_addr);
+ /* We have a sym that will go into a common area, meaning that it
+ will get storage reserved with a .comm/.lcomm assembler pseudo-op.
+
+ Determine name of common area this symbol will be an offset into,
+ and offset into that area. Also retrieve the decl for the area
+ that the symbol is offset into. */
+ tree cdecl = NULL;
+
+ switch (GET_CODE (sym_addr))
+ {
+ case PLUS:
+ if (CONST_INT_P (XEXP (sym_addr, 0)))
+ {
+ name =
+ targetm.strip_name_encoding(XSTR (XEXP (sym_addr, 1), 0));
+ *value = INTVAL (XEXP (sym_addr, 0));
+ cdecl = SYMBOL_REF_DECL (XEXP (sym_addr, 1));
+ }
+ else
+ {
+ name =
+ targetm.strip_name_encoding(XSTR (XEXP (sym_addr, 0), 0));
+ *value = INTVAL (XEXP (sym_addr, 1));
+ cdecl = SYMBOL_REF_DECL (XEXP (sym_addr, 0));
+ }
+ break;
+
+ case SYMBOL_REF:
+ name = targetm.strip_name_encoding(XSTR (sym_addr, 0));
+ *value = 0;
+ cdecl = SYMBOL_REF_DECL (sym_addr);
+ break;
+
+ default:
+ error ("common symbol debug info is not structured as "
+ "symbol+offset");
+ }
+
+ /* Check area common symbol is offset into. If this is not public, then
+ it is not a symbol in a common block. It must be a .lcomm symbol, not
+ a .comm symbol. */
+ if (cdecl == NULL || !TREE_PUBLIC(cdecl))
+ name = NULL;
+ }
else
- fprintf (asm_out_file, "%d", current_sym_value);
- putc ('\n', asm_out_file);
-#endif
+ name = NULL;
+
+ return name;
}
/* Output definitions of all the decls in a chain. Return nonzero if
dbxout_syms (tree syms)
{
int result = 0;
+ const char *comm_prev = NULL;
+ tree syms_prev = NULL;
+
while (syms)
{
+ int temp, copen, cclos;
+ const char *comm_new;
+
+ /* Check for common symbol, and then progression into a new/different
+ block of common symbols. Emit closing/opening common bracket if
+ necessary. */
+ comm_new = dbxout_common_check (syms, &temp);
+ copen = comm_new != NULL
+ && (comm_prev == NULL || strcmp (comm_new, comm_prev));
+ cclos = comm_prev != NULL
+ && (comm_new == NULL || strcmp (comm_new, comm_prev));
+ if (cclos)
+ dbxout_common_name (syms_prev, comm_prev, N_ECOMM);
+ if (copen)
+ {
+ dbxout_common_name (syms, comm_new, N_BCOMM);
+ syms_prev = syms;
+ }
+ comm_prev = comm_new;
+
result += dbxout_symbol (syms, 1);
- syms = TREE_CHAIN (syms);
+ syms = DECL_CHAIN (syms);
}
+
+ if (comm_prev != NULL)
+ dbxout_common_name (syms_prev, comm_prev, N_ECOMM);
+
return result;
}
\f
dbxout_parms (tree parms)
{
++debug_nesting;
-
emit_pending_bincls_if_required ();
- for (; parms; parms = TREE_CHAIN (parms))
+ for (; parms; parms = DECL_CHAIN (parms))
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. */
DECL_INCOMING_RTL (parms)
- = eliminate_regs (DECL_INCOMING_RTL (parms), 0, NULL_RTX);
- SET_DECL_RTL (parms, eliminate_regs (DECL_RTL (parms), 0, NULL_RTX));
+ = eliminate_regs (DECL_INCOMING_RTL (parms), VOIDmode, NULL_RTX);
+ SET_DECL_RTL (parms,
+ eliminate_regs (DECL_RTL (parms), VOIDmode, NULL_RTX));
#ifdef LEAF_REG_REMAP
if (current_function_uses_only_leaf_regs)
{
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));
+ if (GET_CODE (inrtl) == PLUS
+ && CONST_INT_P (XEXP (inrtl, 1)))
+ number = INTVAL (XEXP (inrtl, 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 (asm_out_file, "%s\"%s:p", ASM_STABS_OP,
- IDENTIFIER_POINTER (DECL_NAME (parms)));
- }
- else
- {
- current_sym_nchars = 8;
- fprintf (asm_out_file, "%s\"(anon):p", ASM_STABS_OP);
- }
-
- /* 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 (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 (asm_out_file, "%s\"%s:%c", ASM_STABS_OP,
- IDENTIFIER_POINTER (DECL_NAME (parms)),
- regparm_letter);
- }
+ best_rtl = DECL_RTL (parms);
+ else if (GET_CODE (DECL_INCOMING_RTL (parms)) == PARALLEL)
+ best_rtl = XEXP (XVECEXP (DECL_INCOMING_RTL (parms), 0, 0), 0);
else
- {
- current_sym_nchars = 8;
- fprintf (asm_out_file, "%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 (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
+#if !HARD_FRAME_POINTER_IS_ARG_POINTER
&& REGNO (XEXP (DECL_RTL (parms), 0)) != ARG_POINTER_REGNUM
#endif
)
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;
+ code = DBX_REGPARM_STABS_CODE;
- if (use_gnu_debug_info_extensions)
- /* GDB likes this marked with a special letter. */
- regparm_letter = 'a';
- else
- regparm_letter = DBX_REGPARM_STABS_LETTER;
+ /* 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 (asm_out_file, "%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 (asm_out_file, "%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 (MEM_P (DECL_RTL (parms))
&& MEM_P (XEXP (DECL_RTL (parms), 0)))
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 (REG_P (XEXP (XEXP (DECL_RTL (parms), 0), 0)))
- 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 (asm_out_file, "%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 (MEM_P (DECL_RTL (parms))
&& XEXP (DECL_RTL (parms), 0) != const0_rtx
{
/* 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 (REG_P (XEXP (DECL_RTL (parms), 0)))
- 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)));
+ 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;
- fprintf (asm_out_file, "%s\"%s:p", ASM_STABS_OP,
- IDENTIFIER_POINTER (DECL_NAME (parms)));
- }
- else
- {
- current_sym_nchars = 8;
- fprintf (asm_out_file, "%s\"(anon):p", ASM_STABS_OP);
- }
+ dbxout_begin_complex_stabs ();
- current_sym_value
- = DEBUGGER_ARG_OFFSET (current_sym_value,
- XEXP (DECL_RTL (parms), 0));
- dbxout_type (TREE_TYPE (parms), 0);
- dbxout_finish_symbol (parms);
+ 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;
}
{
++debug_nesting;
- for (; parms; parms = TREE_CHAIN (parms))
+ for (; parms; parms = DECL_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 (REG_P (DECL_RTL (parms))
{
while (args)
{
- putc (',', asm_out_file);
+ stabstr_C (',');
dbxout_type (TREE_VALUE (args), 0);
- CHARS (1);
args = TREE_CHAIN (args);
}
}
\f
+#if defined (DBX_DEBUGGING_INFO)
+
/* 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. */
dbx_output_lbrac (const char *label,
const char *begin_label ATTRIBUTE_UNUSED)
{
-#ifdef DBX_OUTPUT_LBRAC
- DBX_OUTPUT_LBRAC (asm_out_file, label);
-#else
- fprintf (asm_out_file, "%s%d,0,0,", ASM_STABN_OP, N_LBRAC);
- assemble_name (asm_out_file, label);
+ dbxout_begin_stabn (N_LBRAC);
if (DBX_BLOCKS_FUNCTION_RELATIVE)
- {
- putc ('-', asm_out_file);
- assemble_name (asm_out_file, begin_label);
- }
- fprintf (asm_out_file, "\n");
-#endif
+ dbxout_stab_value_label_diff (label, begin_label);
+ else
+ dbxout_stab_value_label (label);
}
/* Subroutine of dbxout_block. Emit an N_RBRAC stab referencing LABEL.
dbx_output_rbrac (const char *label,
const char *begin_label ATTRIBUTE_UNUSED)
{
-#ifdef DBX_OUTPUT_RBRAC
- DBX_OUTPUT_RBRAC (asm_out_file, label);
-#else
- fprintf (asm_out_file, "%s%d,0,0,", ASM_STABN_OP, N_RBRAC);
- assemble_name (asm_out_file, label);
+ dbxout_begin_stabn (N_RBRAC);
if (DBX_BLOCKS_FUNCTION_RELATIVE)
- {
- putc ('-', asm_out_file);
- assemble_name (asm_out_file, begin_label);
- }
- fprintf (asm_out_file, "\n");
-#endif
+ dbxout_stab_value_label_diff (label, begin_label);
+ else
+ dbxout_stab_value_label (label);
}
/* Output everything about a symbol block (a BLOCK node
static void
dbxout_block (tree block, int depth, tree args)
{
- const char *begin_label;
- begin_label = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0);
+ char begin_label[20];
+ /* Reference current function start using LFBB. */
+ ASM_GENERATE_INTERNAL_LABEL (begin_label, "LFBB", scope_labelno);
while (block)
{
if (depth == 0)
/* The outermost block doesn't get LBB labels; use
- the function symbol. */
+ the LFBB local symbol emitted by dbxout_begin_prologue. */
scope_start = begin_label;
else
{
scope_start = buf;
}
- if (BLOCK_HANDLER_BLOCK (block))
- {
- /* A catch block. Must precede N_LBRAC. */
- tree decl = BLOCK_VARS (block);
- while (decl)
- {
- fprintf (asm_out_file, "%s\"%s:C1\",%d,0,0,", ASM_STABS_OP,
- IDENTIFIER_POINTER (DECL_NAME (decl)), N_CATCH);
- assemble_name (asm_out_file, scope_start);
- fprintf (asm_out_file, "\n");
- decl = TREE_CHAIN (decl);
- }
- }
dbx_output_lbrac (scope_start, begin_label);
}
Usually this follows the function's code,
but on some systems, it comes before. */
-#if defined (DBX_DEBUGGING_INFO)
static void
dbxout_begin_function (tree decl)
{
- int saved_tree_used1 = TREE_USED (decl);
+ int saved_tree_used1;
+
+ saved_tree_used1 = TREE_USED (decl);
TREE_USED (decl) = 1;
if (DECL_NAME (DECL_RESULT (decl)) != 0)
{