/* 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
+ 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 "regs.h"
#include "insn-config.h"
#include "reload.h"
-#include "output.h" /* ASM_OUTPUT_SOURCE_LINE may refer to sdb functions. */
+#include "output.h"
#include "dbxout.h"
#include "toplev.h"
#include "tm_p.h"
#include "function.h"
#include "target.h"
#include "langhooks.h"
+#include "obstack.h"
+#include "expr.h"
#ifdef XCOFF_DEBUGGING_INFO
#include "xcoffout.h"
#endif
-#undef DBXOUT_DECR_NESTING
#define DBXOUT_DECR_NESTING \
if (--debug_nesting == 0 && symbol_queue_index > 0) \
{ emit_pending_bincls_if_required (); debug_flush_symbol_queue (); }
-#undef DBXOUT_DECR_NESTING_AND_RETURN
#define DBXOUT_DECR_NESTING_AND_RETURN(x) \
do {--debug_nesting; return (x);} while (0)
#ifndef ASM_STABS_OP
-#define ASM_STABS_OP "\t.stabs\t"
+# 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 DBX_REGPARM_STABS_LETTER 'P'
#endif
-/* This is used for parameters passed by invisible reference in a register. */
-#ifndef GDB_INV_REF_REGPARM_STABS_LETTER
-#define GDB_INV_REF_REGPARM_STABS_LETTER 'a'
+#ifndef NO_DBX_FUNCTION_END
+#define NO_DBX_FUNCTION_END 0
+#endif
+
+#ifndef NO_DBX_BNSYM_ENSYM
+#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
-#ifndef DBX_MEMPARM_STABS_LETTER
-#define DBX_MEMPARM_STABS_LETTER 'p'
+#ifndef DBX_LINES_FUNCTION_RELATIVE
+#define DBX_LINES_FUNCTION_RELATIVE 0
#endif
-#ifndef FILE_NAME_JOINER
-#define FILE_NAME_JOINER "/"
+#ifndef DBX_CONTIN_LENGTH
+#define DBX_CONTIN_LENGTH 80
#endif
-/* GDB needs to know that the stabs were generated by GCC. We emit an
- N_OPT stab at the beginning of the source file to indicate this.
- The string is historical, and different on a very few targets. */
-#ifndef STABS_GCC_MARKER
-#define STABS_GCC_MARKER "gcc2_compiled."
+#ifndef DBX_CONTIN_CHAR
+#define DBX_CONTIN_CHAR '\\'
#endif
enum typestatus {TYPE_UNSEEN, TYPE_XREF, TYPE_DEFINED};
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. */
/* The original input file name. */
static const char *base_input_file;
-/* Current working directory. */
-
-static const char *cwd;
-
#ifdef DEBUG_SYMS_TEXT
-#define FORCE_TEXT function_section (current_function_decl);
+#define FORCE_TEXT switch_to_section (current_function_section ())
#else
#define FORCE_TEXT
#endif
#define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET)
#endif
-/* Stream for writing to assembler file. */
-
-static FILE *asmfile;
-
-/* 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 *);
+
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_type (tree, int);
static bool print_int_cst_bounds_in_octal_p (tree);
-static void print_int_cst_octal (tree);
-static void print_octal (unsigned HOST_WIDE_INT, int);
-static void print_wide_int (HOST_WIDE_INT);
static void dbxout_type_name (tree);
static void dbxout_class_name_qualifiers (tree);
static int dbxout_symbol_location (tree, tree, const char *, rtx);
static void dbxout_symbol_name (tree, const char *, int);
-static void dbxout_prepare_symbol (tree);
-static void dbxout_finish_symbol (tree);
-static void dbxout_block (tree, int, tree);
static void dbxout_global_decl (tree);
static void dbxout_type_decl (tree, int);
static void dbxout_handle_pch (unsigned);
#if defined (DBX_DEBUGGING_INFO)
static void dbxout_source_line (unsigned int, const char *);
-static void dbxout_source_file (FILE *, const char *);
-static void dbxout_function_end (void);
+static void dbxout_begin_prologue (unsigned int, const char *);
+static void dbxout_source_file (const char *);
+static void dbxout_function_end (tree);
static void dbxout_begin_function (tree);
static void dbxout_begin_block (unsigned, unsigned);
static void dbxout_end_block (unsigned, unsigned);
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_source_line, /* begin_prologue: just output
- line info */
+ dbxout_begin_prologue, /* begin_prologue */
debug_nothing_int_charstar, /* end_prologue */
debug_nothing_int_charstar, /* end_epilogue */
#ifdef DBX_FUNCTION_FIRST
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 */
+ 0 /* start_end_main_source_file */
};
#endif /* DBX_DEBUGGING_INFO */
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_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 */
+ 0 /* start_end_main_source_file */
};
#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)
+
static void
-dbxout_function_end (void)
+dbxout_function_end (tree decl)
{
char lscope_label_name[100];
- function_section (current_function_decl);
+ /* The Lscope label must be emitted even if we aren't doing anything
+ else; dbxout_block needs it. */
+ switch_to_section (function_section (current_function_decl));
- /* Convert Ltext into the appropriate format for local labels in case
+ /* 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 (asmfile, "Lscope", scope_labelno);
- scope_labelno++;
+ targetm.asm_out.internal_label (asm_out_file, "Lscope", scope_labelno);
+
+ /* The N_FUN tag at the end of the function is a GNU extension,
+ which may be undesirable, and is unnecessary if we do not have
+ named sections. */
+ if (!use_gnu_debug_info_extensions
+ || NO_DBX_FUNCTION_END
+ || !targetm.have_named_sections
+ || DECL_IGNORED_P (decl))
+ return;
/* By convention, GCC will mark the end of a function with an N_FUN
symbol and an empty string. */
-#ifdef DBX_OUTPUT_NFUN
- DBX_OUTPUT_NFUN (asmfile, lscope_label_name, current_function_decl);
-#else
- fprintf (asmfile, "%s\"\",%d,0,0,", ASM_STABS_OP, N_FUN);
- assemble_name (asmfile, lscope_label_name);
- putc ('-', asmfile);
- assemble_name (asmfile, XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0));
- fprintf (asmfile, "\n");
-#endif
+ if (flag_reorder_blocks_and_partition)
+ {
+ dbxout_begin_empty_stabs (N_FUN);
+ dbxout_stab_value_label_diff (cfun->hot_section_end_label,
+ cfun->hot_section_label);
+ dbxout_begin_empty_stabs (N_FUN);
+ dbxout_stab_value_label_diff (cfun->cold_section_end_label,
+ cfun->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)
+ dbxout_stabd (N_ENSYM, 0);
}
#endif /* DBX_DEBUGGING_INFO */
+/* Get lang description for N_SO stab. */
+static unsigned int ATTRIBUTE_UNUSED
+get_lang_number (void)
+{
+ const char *language_string = lang_hooks.name;
+
+ if (strcmp (language_string, "GNU C") == 0)
+ return N_SO_C;
+ else if (strcmp (language_string, "GNU C++") == 0)
+ return N_SO_CC;
+ else if (strcmp (language_string, "GNU F77") == 0)
+ return N_SO_FORTRAN;
+ else if (strcmp (language_string, "GNU F95") == 0)
+ return N_SO_FORTRAN90; /* CHECKME */
+ else if (strcmp (language_string, "GNU Pascal") == 0)
+ return N_SO_PASCAL;
+ else if (strcmp (language_string, "GNU Objective-C") == 0)
+ return N_SO_OBJC;
+ else if (strcmp (language_string, "GNU Objective-C++") == 0)
+ return N_SO_OBJCPLUS;
+ else
+ return 0;
+
+}
+
/* 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 ();
-
- asmfile = asm_out_file;
+ const char *mapped_name;
typevec_len = 100;
typevec = ggc_calloc (typevec_len, sizeof typevec[0]);
+ /* stabstr_ob contains one string, which will be just fine with
+ 1-byte alignment. */
+ obstack_specify_allocation (&stabstr_ob, 0, 1, xmalloc, free);
+
/* Convert Ltext into the appropriate format for local labels in case
the system doesn't insert underscores in front of user generated
labels. */
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)
{
- if (!cwd && (cwd = get_src_pwd ())
- && (!*cwd || cwd[strlen (cwd) - 1] != '/'))
- cwd = concat (cwd, FILE_NAME_JOINER, NULL);
- if (cwd)
+ static const char *cwd;
+
+ if (!cwd)
{
+ cwd = get_src_pwd ();
+ if (cwd[0] == '\0')
+ cwd = "/";
+ else if (!IS_DIR_SEPARATOR (cwd[strlen (cwd) - 1]))
+ cwd = concat (cwd, "/", NULL);
+ cwd = remap_debug_filename (cwd);
+ }
#ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
- DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asmfile, cwd);
+ DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asm_out_file, cwd);
#else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
- fprintf (asmfile, "%s", ASM_STABS_OP);
- output_quoted_string (asmfile, cwd);
- fprintf (asmfile, ",%d,0,0,", N_SO);
- assemble_name (asmfile, ltext_label_name);
- fputc ('\n', asmfile);
+ dbxout_begin_simple_stabs_desc (cwd, N_SO, get_lang_number ());
+ dbxout_stab_value_label (ltext_label_name);
+ used_ltext_label_name = true;
#endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
- }
}
+ mapped_name = remap_debug_filename (input_file_name);
#ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
- DBX_OUTPUT_MAIN_SOURCE_FILENAME (asmfile, input_file_name);
-#else /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
- /* We include outputting `Ltext:' here,
- because that gives you a way to override it. */
- /* Used to put `Ltext:' before the reference, but that loses on sun 4. */
- fprintf (asmfile, "%s", ASM_STABS_OP);
- output_quoted_string (asmfile, input_file_name);
- fprintf (asmfile, ",%d,0,0,", N_SO);
- assemble_name (asmfile, ltext_label_name);
- fputc ('\n', asmfile);
- text_section ();
- targetm.asm_out.internal_label (asmfile, "Ltext", 0);
-#endif /* no DBX_OUTPUT_MAIN_SOURCE_FILENAME */
-
-#ifdef DBX_OUTPUT_GCC_MARKER
- DBX_OUTPUT_GCC_MARKER (asmfile);
+ DBX_OUTPUT_MAIN_SOURCE_FILENAME (asm_out_file, mapped_name);
#else
- /* Emit an N_OPT stab to indicate that this file was compiled by GCC. */
- fprintf (asmfile, "%s\"%s\",%d,0,0,0\n",
- ASM_STABS_OP, STABS_GCC_MARKER, N_OPT);
+ dbxout_begin_simple_stabs_desc (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. */
+#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
emit_bincl_stab (const char *name)
{
- fprintf (asmfile, "%s", ASM_STABS_OP);
- output_quoted_string (asmfile, name);
- fprintf (asmfile, ",%d,0,0,0\n", N_BINCL);
+ 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;
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 (asmfile, "%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 (asmfile, ",%d,0,0,", N_SOL);
- assemble_name (asmfile, ltext_label_name);
- fputc ('\n', asmfile);
- if (current_function_decl != NULL_TREE
- && DECL_SECTION_NAME (current_function_decl) != NULL_TREE)
- ; /* Don't change section amid function. */
- else
- {
- 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, line number symbol entry, and local symbol at
+ function scope */
+
+static void
+dbxout_begin_prologue (unsigned int lineno, const char *filename)
+{
+ if (use_gnu_debug_info_extensions
+ && !NO_DBX_FUNCTION_END
+ && !NO_DBX_BNSYM_ENSYM
+ && !flag_debug_only_used_symbols)
+ dbxout_stabd (N_BNSYM, 0);
+
+ /* pre-increment the scope counter */
+ scope_labelno++;
+
+ dbxout_source_line (lineno, filename);
+ /* 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_file (asmfile, filename);
+ dbxout_source_file (filename);
-#ifdef ASM_OUTPUT_SOURCE_LINE
- dbxout_source_line_counter += 1;
- ASM_OUTPUT_SOURCE_LINE (asmfile, lineno, dbxout_source_line_counter);
+#ifdef DBX_OUTPUT_SOURCE_LINE
+ DBX_OUTPUT_SOURCE_LINE (asm_out_file, lineno, dbxout_source_line_counter);
#else
- fprintf (asmfile, "%s%d,0,%d\n", ASM_STABD_OP, N_SLINE, lineno);
+ if (DBX_LINES_FUNCTION_RELATIVE)
+ {
+ 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
+ dbxout_stabd (N_SLINE, lineno);
#endif
}
dbxout_begin_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int n)
{
emit_pending_bincls_if_required ();
- targetm.asm_out.internal_label (asmfile, "LBB", n);
+ targetm.asm_out.internal_label (asm_out_file, "LBB", n);
}
/* Describe the end line-number of an internal block within a function. */
dbxout_end_block (unsigned int line ATTRIBUTE_UNUSED, unsigned int n)
{
emit_pending_bincls_if_required ();
- targetm.asm_out.internal_label (asmfile, "LBE", n);
+ targetm.asm_out.internal_label (asm_out_file, "LBE", n);
}
/* Output dbx data for a function definition.
dbxout_begin_function (decl);
#endif
dbxout_block (DECL_INITIAL (decl), 0, DECL_ARGUMENTS (decl));
-#ifdef DBX_OUTPUT_FUNCTION_END
- DBX_OUTPUT_FUNCTION_END (asmfile, decl);
-#endif
- if (use_gnu_debug_info_extensions
-#if defined(NO_DBX_FUNCTION_END)
- && ! NO_DBX_FUNCTION_END
-#endif
- && targetm.have_named_sections)
- dbxout_function_end ();
+ dbxout_function_end (decl);
}
#endif /* DBX_DEBUGGING_INFO */
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;
}
/* At the end of compilation, finish writing the symbol table.
- Unless you define DBX_OUTPUT_MAIN_SOURCE_FILE_END, the default is
- to do nothing. */
+ The default is to call debug_free_queue but do nothing else. */
static void
dbxout_finish (const char *filename ATTRIBUTE_UNUSED)
{
#ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
- DBX_OUTPUT_MAIN_SOURCE_FILE_END (asmfile, filename);
-#endif /* DBX_OUTPUT_MAIN_SOURCE_FILE_END */
-
+ DBX_OUTPUT_MAIN_SOURCE_FILE_END (asm_out_file, filename);
+#elif defined DBX_OUTPUT_NULL_N_SO_AT_MAIN_SOURCE_FILE_END
+ {
+ 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 (asmfile, "%d", TYPE_SYMTAB_ADDRESS (type));
- CHARS (3);
+ stabstr_D (TYPE_SYMTAB_ADDRESS (type));
#else
struct typeinfo *t = &typevec[TYPE_SYMTAB_ADDRESS (type)];
- fprintf (asmfile, "(%d,%d)", t->file_number, t->type_number);
- CHARS (9);
+ stabstr_C ('(');
+ stabstr_D (t->file_number);
+ stabstr_C (',');
+ stabstr_D (t->type_number);
+ stabstr_C (')');
#endif
}
-#if DBX_CONTIN_LENGTH > 0
-/* Continue a symbol-description that gets too big.
- End one symbol table entry with a double-backslash
- and start a new one, eventually producing something like
- .stabs "start......\\",code,0,value
- .stabs "...rest",code,0,value */
-
-static void
-dbxout_continue (void)
-{
- emit_pending_bincls_if_required ();
-#ifdef DBX_CONTIN_CHAR
- fprintf (asmfile, "%c", DBX_CONTIN_CHAR);
-#else
- fprintf (asmfile, "\\\\");
-#endif
- dbxout_finish_symbol (NULL_TREE);
- fprintf (asmfile, "%s\"", ASM_STABS_OP);
- current_sym_nchars = 0;
-}
-#endif /* DBX_CONTIN_LENGTH > 0 */
\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. */
/* 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 (asmfile, "%s:", IDENTIFIER_POINTER (DECL_NAME (tem)));
- CHARS (2 + IDENTIFIER_LENGTH (DECL_NAME (tem)));
- }
- else
- {
- fprintf (asmfile, ":");
- CHARS (1);
- }
+ stabstr_I (DECL_NAME (tem));
+ stabstr_C (':');
if (use_gnu_debug_info_extensions
&& (TREE_PRIVATE (tem) || TREE_PROTECTED (tem)
|| TREE_CODE (tem) != FIELD_DECL))
{
- have_used_extensions = 1;
- putc ('/', asmfile);
- putc ((TREE_PRIVATE (tem) ? '0'
- : TREE_PROTECTED (tem) ? '1' : '2'),
- asmfile);
- CHARS (2);
+ stabstr_C ('/');
+ stabstr_C (DECL_ACCESSIBILITY_CHAR (tem));
}
dbxout_type ((TREE_CODE (tem) == FIELD_DECL
{
tree name = DECL_ASSEMBLER_NAME (tem);
- have_used_extensions = 1;
- fprintf (asmfile, ":%s;", IDENTIFIER_POINTER (name));
- CHARS (IDENTIFIER_LENGTH (name) + 2);
+ stabstr_C (':');
+ stabstr_I (name);
+ stabstr_C (';');
}
else
- {
- /* If TEM is non-static, GDB won't understand it. */
- fprintf (asmfile, ",0,0;");
- CHARS (5);
- }
+ /* If TEM is non-static, GDB won't understand it. */
+ stabstr_S (",0,0;");
}
else
{
- putc (',', asmfile);
- print_wide_int (int_bit_position (tem));
- putc (',', asmfile);
- print_wide_int (tree_low_cst (DECL_SIZE (tem), 1));
- putc (';', asmfile);
- CHARS (3);
+ stabstr_C (',');
+ stabstr_D (int_bit_position (tem));
+ stabstr_C (',');
+ stabstr_D (tree_low_cst (DECL_SIZE (tem), 1));
+ stabstr_C (';');
}
}
}
}
\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 (asmfile, ":%s;%c%c%c", debug_name,
- TREE_PRIVATE (decl) ? '0'
- : TREE_PROTECTED (decl) ? '1' : '2', c1, c2);
- CHARS (IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (decl)) + 6
- - (debug_name - IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))));
+ /* ??? Output the mangled name, which contains an encoding of the
+ method's type signature. May not be necessary anymore. */
+ stabstr_C (':');
+ stabstr_I (DECL_ASSEMBLER_NAME (decl));
+ stabstr_C (';');
+ stabstr_C (DECL_ACCESSIBILITY_CHAR (decl));
+ stabstr_C (c1);
+ stabstr_C (c2);
if (DECL_VINDEX (decl) && host_integerp (DECL_VINDEX (decl), 0))
{
- print_wide_int (tree_low_cst (DECL_VINDEX (decl), 0));
- putc (';', asmfile);
- CHARS (1);
+ stabstr_D (tree_low_cst (DECL_VINDEX (decl), 0));
+ stabstr_C (';');
dbxout_type (DECL_CONTEXT (decl), 0);
- fprintf (asmfile, ";");
- CHARS (1);
+ stabstr_C (';');
}
}
\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));
-
-#if 0
- /* C++: Template classes break some assumptions made by this code about
- the class names, constructor names, and encodings for assembler
- label names. For now, disable output of dbx info for them. */
- {
- const char *ptr = IDENTIFIER_POINTER (type_encoding);
- /* This should use index. (mrs) */
- while (*ptr && *ptr != '<') ptr++;
- if (*ptr != 0)
- {
- static int warned;
- if (!warned)
- warned = 1;
- return;
- }
- }
-#endif
-
- type_identifier_length = IDENTIFIER_LENGTH (type_encoding);
-
- sprintf (formatted_type_identifier_length, "%d", type_identifier_length);
-
if (TREE_CODE (methods) != TREE_VEC)
fndecl = methods;
else if (TREE_VEC_ELT (methods, 0) != NULL_TREE)
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 (asmfile, "%s::", IDENTIFIER_POINTER (name));
- CHARS (IDENTIFIER_LENGTH (name) + 2);
+ stabstr_I (DECL_NAME (fndecl));
+ stabstr_S ("::");
need_prefix = 0;
}
dbxout_type (TREE_TYPE (fndecl), 0);
-
- dbxout_type_method_1 (fndecl, debug_name);
+ dbxout_type_method_1 (fndecl);
}
if (!need_prefix)
- {
- putc (';', asmfile);
- CHARS (1);
- }
+ stabstr_C (';');
}
}
static void
dbxout_range_type (tree type)
{
- fprintf (asmfile, "r");
+ stabstr_C ('r');
if (TREE_TYPE (type))
dbxout_type (TREE_TYPE (type), 0);
else if (TREE_CODE (type) != INTEGER_TYPE)
dbxout_type_index (integer_type_node);
}
+ stabstr_C (';');
if (TYPE_MIN_VALUE (type) != 0
&& host_integerp (TYPE_MIN_VALUE (type), 0))
{
- putc (';', asmfile);
- CHARS (1);
if (print_int_cst_bounds_in_octal_p (type))
- print_int_cst_octal (TYPE_MIN_VALUE (type));
+ stabstr_O (TYPE_MIN_VALUE (type));
else
- print_wide_int (tree_low_cst (TYPE_MIN_VALUE (type), 0));
+ stabstr_D (tree_low_cst (TYPE_MIN_VALUE (type), 0));
}
else
- {
- fprintf (asmfile, ";0");
- CHARS (2);
- }
+ stabstr_C ('0');
+ stabstr_C (';');
if (TYPE_MAX_VALUE (type) != 0
&& host_integerp (TYPE_MAX_VALUE (type), 0))
{
- putc (';', asmfile);
- CHARS (1);
if (print_int_cst_bounds_in_octal_p (type))
- print_int_cst_octal (TYPE_MAX_VALUE (type));
+ stabstr_O (TYPE_MAX_VALUE (type));
else
- print_wide_int (tree_low_cst (TYPE_MAX_VALUE (type), 0));
- putc (';', asmfile);
- CHARS (1);
+ stabstr_D (tree_low_cst (TYPE_MAX_VALUE (type), 0));
+ stabstr_C (';');
}
else
- {
- fprintf (asmfile, ";-1;");
- CHARS (4);
- }
+ stabstr_S ("-1;");
}
\f
tree tem;
tree main_variant;
static int anonymous_type_number = 0;
+ bool vector_type = false;
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)));
+ {
+ /* 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)));
+ vector_type = true;
+ }
/* If there was an input error and we don't really have a type,
avoid crashing and write something that is at least valid
|| TREE_CODE (type) == QUAL_UNION_TYPE
|| TREE_CODE (type) == ENUMERAL_TYPE)
&& TYPE_STUB_DECL (type)
- && TREE_CODE_CLASS (TREE_CODE (TYPE_STUB_DECL (type))) == 'd'
+ && DECL_P (TYPE_STUB_DECL (type))
&& ! DECL_IGNORED_P (TYPE_STUB_DECL (type)))
debug_queue_symbol (TYPE_STUB_DECL (type));
else if (TYPE_NAME (type)
#endif
/* Output a definition now. */
-
- fprintf (asmfile, "=");
- CHARS (1);
+ stabstr_C ('=');
/* Mark it as defined, so that if it is self-referent
we will not get into an infinite recursion of definitions. */
cv-qualified types if we're using extensions. */
if (TYPE_READONLY (type) > TYPE_READONLY (main_variant))
{
- putc ('k', asmfile);
- CHARS (1);
+ stabstr_C ('k');
dbxout_type (build_type_variant (type, 0, TYPE_VOLATILE (type)), 0);
return;
}
else if (TYPE_VOLATILE (type) > TYPE_VOLATILE (main_variant))
{
- putc ('B', asmfile);
- CHARS (1);
+ stabstr_C ('B');
dbxout_type (build_type_variant (type, TYPE_READONLY (type), 0), 0);
return;
}
{
case VOID_TYPE:
case LANG_TYPE:
- /* For a void type, just define it as itself; ie, "5=5".
+ /* For a void type, just define it as itself; i.e., "5=5".
This makes us consider it defined
without saying what it is. The debugger will make it
a void type when the reference is seen, and nothing will
from the output of pcc.
This used to use `r2' explicitly and we used to
take care to make sure that `char' was type number 2. */
- fprintf (asmfile, "r");
- CHARS (1);
+ stabstr_C ('r');
dbxout_type_index (type);
- fprintf (asmfile, ";0;127;");
- CHARS (7);
+ stabstr_S (";0;127;");
}
/* If this is a subtype of another integer type, always prefer to
if (use_gnu_debug_info_extensions
&& TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
{
- have_used_extensions = 1;
- fprintf (asmfile, "@s%d;", TYPE_PRECISION (type));
- CHARS (5);
+ stabstr_S ("@s");
+ stabstr_D (TYPE_PRECISION (type));
+ stabstr_C (';');
}
dbxout_range_type (type);
if (use_gnu_debug_info_extensions
&& TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
{
- have_used_extensions = 1;
- fprintf (asmfile, "@s%d;", TYPE_PRECISION (type));
- CHARS (5);
+ stabstr_S ("@s");
+ stabstr_D (TYPE_PRECISION (type));
+ stabstr_C (';');
}
if (print_int_cst_bounds_in_octal_p (type))
{
- fprintf (asmfile, "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 (asmfile, ";");
- CHARS (1);
- print_int_cst_octal (TYPE_MIN_VALUE (type));
- fprintf (asmfile, ";");
- CHARS (1);
- print_int_cst_octal (TYPE_MAX_VALUE (type));
- fprintf (asmfile, ";");
- CHARS (1);
+ stabstr_C (';');
+ stabstr_O (TYPE_MIN_VALUE (type));
+ stabstr_C (';');
+ stabstr_O (TYPE_MAX_VALUE (type));
+ stabstr_C (';');
}
else
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 (asmfile, "r");
- CHARS (1);
+ stabstr_C ('r');
dbxout_type_index (integer_type_node);
- putc (';', asmfile);
- CHARS (1);
- print_wide_int (int_size_in_bytes (type));
- fputs (";0;", asmfile);
- CHARS (3);
- break;
-
- case CHAR_TYPE:
- if (use_gnu_debug_info_extensions)
- {
- have_used_extensions = 1;
- fputs ("@s", asmfile);
- CHARS (2);
- print_wide_int (BITS_PER_UNIT * int_size_in_bytes (type));
- fputs (";-20;", asmfile);
- CHARS (4);
- }
- else
- {
- /* Output the type `char' as a subrange of itself.
- That is what pcc seems to do. */
- fprintf (asmfile, "r");
- CHARS (1);
- dbxout_type_index (char_type_node);
- fprintf (asmfile, ";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", asmfile);
- CHARS (2);
- print_wide_int (BITS_PER_UNIT * int_size_in_bytes (type));
- fputs (";-16;", asmfile);
- CHARS (4);
+ stabstr_S ("@s");
+ stabstr_D (BITS_PER_UNIT * int_size_in_bytes (type));
+ stabstr_S (";-16;");
}
else /* Define as enumeral type (False, True) */
- {
- fprintf (asmfile, "eFalse:0,True:1,;");
- CHARS (17);
- }
- break;
-
- case FILE_TYPE:
- putc ('d', asmfile);
- 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;", asmfile);
- CHARS (3);
- print_wide_int (2 * int_size_in_bytes (TREE_TYPE (type)));
- fputs (";0;", asmfile);
- CHARS (3);
+ stabstr_S ("R3;");
+ stabstr_D (2 * int_size_in_bytes (TREE_TYPE (type)));
+ stabstr_S (";0;");
}
else
{
/* Output a complex integer type as a structure,
pending some other way to do it. */
- putc ('s', asmfile);
- CHARS (1);
- print_wide_int (int_size_in_bytes (type));
- fprintf (asmfile, "real:");
- CHARS (5);
-
- dbxout_type (TREE_TYPE (type), 0);
- fprintf (asmfile, ",0,%d;", TYPE_PRECISION (TREE_TYPE (type)));
- CHARS (7);
- fprintf (asmfile, "imag:");
- CHARS (5);
- dbxout_type (TREE_TYPE (type), 0);
- fprintf (asmfile, ",%d,%d;;", TYPE_PRECISION (TREE_TYPE (type)),
- TYPE_PRECISION (TREE_TYPE (type)));
- CHARS (10);
- }
- break;
-
- case SET_TYPE:
- if (use_gnu_debug_info_extensions)
- {
- have_used_extensions = 1;
- fputs ("@s", asmfile);
- CHARS (2);
- print_wide_int (BITS_PER_UNIT * int_size_in_bytes (type));
- putc (';', asmfile);
- CHARS (1);
-
- /* Check if a bitstring type, which in Chill is
- different from a [power]set. */
- if (TYPE_STRING_FLAG (type))
- {
- fprintf (asmfile, "@S;");
- CHARS (3);
- }
+ stabstr_C ('s');
+ stabstr_D (int_size_in_bytes (type));
+
+ stabstr_S ("real:");
+ dbxout_type (TREE_TYPE (type), 0);
+ stabstr_S (",0,");
+ stabstr_D (TYPE_PRECISION (TREE_TYPE (type)));
+
+ stabstr_S (";imag:");
+ dbxout_type (TREE_TYPE (type), 0);
+ stabstr_C (',');
+ stabstr_D (TYPE_PRECISION (TREE_TYPE (type)));
+ stabstr_C (',');
+ stabstr_D (TYPE_PRECISION (TREE_TYPE (type)));
+ stabstr_S (";;");
}
- putc ('S', asmfile);
- CHARS (1);
- dbxout_type (TYPE_DOMAIN (type), 0);
break;
case ARRAY_TYPE:
/* 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", asmfile);
- CHARS (2);
- print_wide_int (BITS_PER_UNIT * int_size_in_bytes (type));
- fprintf (asmfile, ";@S;S");
- CHARS (5);
+ stabstr_S ("@s");
+ stabstr_D (BITS_PER_UNIT * int_size_in_bytes (type));
+ stabstr_S (";@S;S");
dbxout_type (TYPE_DOMAIN (type), 0);
break;
}
+ if (use_gnu_debug_info_extensions && vector_type)
+ 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.
different from an array of characters. */
if (TYPE_STRING_FLAG (type) && use_gnu_debug_info_extensions)
{
- have_used_extensions = 1;
- fprintf (asmfile, "@S;");
- CHARS (3);
+ stabstr_S ("@S;");
}
tem = TYPE_DOMAIN (type);
if (tem == NULL)
{
- fprintf (asmfile, "ar");
- CHARS (2);
+ stabstr_S ("ar");
dbxout_type_index (integer_type_node);
- fprintf (asmfile, ";0;-1;");
- CHARS (6);
+ stabstr_S (";0;-1;");
}
else
{
- fprintf (asmfile, "a");
- CHARS (1);
+ stabstr_C ('a');
dbxout_range_type (tem);
}
If the type has a name, don't nest its definition within
another type's definition; instead, output an xref
and let the definition come when the name is defined. */
- fputs ((TREE_CODE (type) == RECORD_TYPE) ? "xs" : "xu", asmfile);
- CHARS (2);
-#if 0 /* This assertion is legitimately false in C++. */
- /* We shouldn't be outputting a reference to a type before its
- definition unless the type has a tag name.
- A typedef name without a tag name should be impossible. */
- if (TREE_CODE (TYPE_NAME (type)) != IDENTIFIER_NODE)
- abort ();
-#endif
- 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 (asmfile, "$$%d", anonymous_type_number++);
- CHARS (5);
+ stabstr_S ("$$");
+ stabstr_D (anonymous_type_number++);
}
- fprintf (asmfile, ":");
- CHARS (1);
+ stabstr_C (':');
typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
break;
}
/* Identify record or union, and print its size. */
- putc (((TREE_CODE (type) == RECORD_TYPE) ? 's' : 'u'), asmfile);
- CHARS (1);
- print_wide_int (int_size_in_bytes (type));
+ stabstr_C ((TREE_CODE (type) == RECORD_TYPE) ? 's' : 'u');
+ stabstr_D (int_size_in_bytes (type));
if (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 (asmfile, "!%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', asmfile);
- putc (access == access_public_node ? '2' :
- (access == access_protected_node ? '1' :'0'),
- asmfile);
- 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 (',', asmfile);
- CHARS (1);
+ stabstr_D (tree_low_cst (BINFO_OFFSET (child), 0)
+ * BITS_PER_UNIT);
+ stabstr_C (',');
dbxout_type (BINFO_TYPE (child), 0);
- putc (';', asmfile);
- CHARS (1);
+ stabstr_C (';');
}
else
{
fields which have the same names at the types
they hold. */
dbxout_type_name (BINFO_TYPE (child));
- putc (':', asmfile);
- CHARS (1);
+ stabstr_C (':');
dbxout_type (BINFO_TYPE (child), full);
- putc (',', asmfile);
- CHARS (1);
- print_wide_int (tree_low_cst (BINFO_OFFSET (child), 0)
- * BITS_PER_UNIT);
- putc (',', asmfile);
- CHARS (1);
- print_wide_int
+ 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 (';', asmfile);
- 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 (';', asmfile);
- CHARS (1);
+ stabstr_C (';');
if (use_gnu_debug_info_extensions && TREE_CODE (type) == RECORD_TYPE
/* Avoid the ~ if we don't really need it--it confuses dbx. */
&& TYPE_VFIELD (type))
{
- have_used_extensions = 1;
-
- /* Tell GDB+ that it may keep reading. */
- putc ('~', asmfile);
- CHARS (1);
/* We need to write out info about what field this class
uses as its "main" vtable pointer field, because if this
field is inherited from a base class, GDB cannot necessarily
figure out which field it's using in time. */
- if (TYPE_VFIELD (type))
- {
- putc ('%', asmfile);
- CHARS (1);
- dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type)), 0);
- }
-
- putc (';', asmfile);
- CHARS (1);
+ stabstr_S ("~%");
+ dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type)), 0);
+ stabstr_C (';');
}
break;
&& !full)
|| !COMPLETE_TYPE_P (type))
{
- fprintf (asmfile, "xe");
- CHARS (2);
+ stabstr_S ("xe");
dbxout_type_name (type);
typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
- putc (':', asmfile);
- CHARS (1);
+ stabstr_C (':');
return;
}
if (use_gnu_debug_info_extensions
&& TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
{
- fprintf (asmfile, "@s%d;", TYPE_PRECISION (type));
- CHARS (5);
+ stabstr_S ("@s");
+ stabstr_D (TYPE_PRECISION (type));
+ stabstr_C (';');
}
- putc ('e', asmfile);
- CHARS (1);
+ stabstr_C ('e');
for (tem = TYPE_VALUES (type); tem; tem = TREE_CHAIN (tem))
{
- fprintf (asmfile, "%s:", IDENTIFIER_POINTER (TREE_PURPOSE (tem)));
- CHARS (IDENTIFIER_LENGTH (TREE_PURPOSE (tem)) + 1);
+ stabstr_I (TREE_PURPOSE (tem));
+ stabstr_C (':');
+
if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == 0)
- print_wide_int (TREE_INT_CST_LOW (TREE_VALUE (tem)));
+ stabstr_D (TREE_INT_CST_LOW (TREE_VALUE (tem)));
else if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == -1
&& (HOST_WIDE_INT) TREE_INT_CST_LOW (TREE_VALUE (tem)) < 0)
- print_wide_int (TREE_INT_CST_LOW (TREE_VALUE (tem)));
+ stabstr_D (TREE_INT_CST_LOW (TREE_VALUE (tem)));
else
- print_int_cst_octal (TREE_VALUE (tem));
+ stabstr_O (TREE_VALUE (tem));
- putc (',', asmfile);
- CHARS (1);
+ stabstr_C (',');
if (TREE_CHAIN (tem) != 0)
CONTIN;
}
- putc (';', asmfile);
- CHARS (1);
+ stabstr_C (';');
break;
case POINTER_TYPE:
- putc ('*', asmfile);
- 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 ('#', asmfile);
- CHARS (1);
+ stabstr_C ('#');
/* Write the argument types out longhand. */
dbxout_type (TYPE_METHOD_BASETYPE (type), 0);
- putc (',', asmfile);
- CHARS (1);
+ stabstr_C (',');
dbxout_type (TREE_TYPE (type), 0);
dbxout_args (TYPE_ARG_TYPES (type));
- putc (';', asmfile);
- CHARS (1);
+ stabstr_C (';');
}
else
/* Treat it as a function type. */
case OFFSET_TYPE:
if (use_gnu_debug_info_extensions)
{
- have_used_extensions = 1;
- putc ('@', asmfile);
- CHARS (1);
+ stabstr_C ('@');
dbxout_type (TYPE_OFFSET_BASETYPE (type), 0);
- putc (',', asmfile);
- CHARS (1);
+ stabstr_C (',');
dbxout_type (TREE_TYPE (type), 0);
}
else
case REFERENCE_TYPE:
if (use_gnu_debug_info_extensions)
- have_used_extensions = 1;
- putc (use_gnu_debug_info_extensions ? '&' : '*', asmfile);
- CHARS (1);
+ {
+ stabstr_C ('&');
+ }
+ else
+ stabstr_C ('*');
dbxout_type (TREE_TYPE (type), 0);
break;
case FUNCTION_TYPE:
- putc ('f', asmfile);
- CHARS (1);
+ stabstr_C ('f');
dbxout_type (TREE_TYPE (type), 0);
break;
default:
- abort ();
+ gcc_unreachable ();
}
}
return FALSE;
}
-/* Print the value of integer constant C, in octal,
- handling double precision. */
+/* 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. */
static void
-print_int_cst_octal (tree c)
+dbxout_type_name (tree type)
{
- unsigned HOST_WIDE_INT high = TREE_INT_CST_HIGH (c);
- unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (c);
- int excess = (3 - (HOST_BITS_PER_WIDE_INT % 3));
- unsigned int width = TYPE_PRECISION (TREE_TYPE (c));
+ tree t = TYPE_NAME (type);
+
+ gcc_assert (t);
+ switch (TREE_CODE (t))
+ {
+ case IDENTIFIER_NODE:
+ break;
+ case TYPE_DECL:
+ t = DECL_NAME (t);
+ break;
+ default:
+ gcc_unreachable ();
+ }
- /* 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);
+ stabstr_I (t);
+}
+
+/* Output leading leading struct or class names needed for qualifying
+ type whose scope is limited to a struct or class. */
- fprintf (asmfile, "0");
- CHARS (1);
+static void
+dbxout_class_name_qualifiers (tree decl)
+{
+ tree context = decl_type_context (decl);
- if (excess == 3)
- {
- print_octal (high, HOST_BITS_PER_WIDE_INT / 3);
- print_octal (low, HOST_BITS_PER_WIDE_INT / 3);
- }
- else
+ if (context != NULL_TREE
+ && TREE_CODE(context) == RECORD_TYPE
+ && TYPE_NAME (context) != 0
+ && (TREE_CODE (TYPE_NAME (context)) == IDENTIFIER_NODE
+ || (DECL_NAME (TYPE_NAME (context)) != 0)))
{
- unsigned HOST_WIDE_INT beg = high >> excess;
- unsigned HOST_WIDE_INT middle
- = ((high & (((HOST_WIDE_INT) 1 << excess) - 1)) << (3 - excess)
- | (low >> (HOST_BITS_PER_WIDE_INT / 3 * 3)));
- unsigned HOST_WIDE_INT end
- = low & (((unsigned HOST_WIDE_INT) 1
- << (HOST_BITS_PER_WIDE_INT / 3 * 3))
- - 1);
-
- fprintf (asmfile, "%o%01o", (int) beg, (int) middle);
- CHARS (2);
- print_octal (end, HOST_BITS_PER_WIDE_INT / 3);
+ tree name = TYPE_NAME (context);
+
+ if (TREE_CODE (name) == TYPE_DECL)
+ {
+ dbxout_class_name_qualifiers (name);
+ name = DECL_NAME (name);
+ }
+ 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
+ havn'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 void
-print_octal (unsigned HOST_WIDE_INT value, int digits)
+static rtx
+dbxout_expand_expr (tree expr)
{
- int i;
+ 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;
+ /* FALLTHRU */
- for (i = digits - 1; i >= 0; i--)
- fprintf (asmfile, "%01o", (int) ((value >> (3 * i)) & 7));
+ case PARM_DECL:
+ if (DECL_HAS_VALUE_EXPR_P (expr))
+ return dbxout_expand_expr (DECL_VALUE_EXPR (expr));
+ /* FALLTHRU */
- CHARS (digits);
-}
+ case CONST_DECL:
+ case RESULT_DECL:
+ return DECL_RTL_IF_SET (expr);
-/* Output C in decimal while adjusting the number of digits written. */
+ case INTEGER_CST:
+ return expand_expr (expr, NULL_RTX, VOIDmode, EXPAND_INITIALIZER);
-static void
-print_wide_int (HOST_WIDE_INT c)
-{
- int digs = 0;
+ 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;
+ }
+}
- fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, c);
+/* Helper function for output_used_types. Queue one entry from the
+ used types hash to be output. */
- if (c < 0)
- digs++, c = -c;
+static int
+output_used_types_helper (void **slot, void *data)
+{
+ tree type = *slot;
+ VEC(tree, heap) **types_p = data;
- while (c > 0)
- c /= 10; digs++;
+ 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));
- CHARS (digs);
+ return 1;
}
-/* 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. */
+/* This is a qsort callback which sorts types and declarations into a
+ predictable order (types, then declarations, sorted by UID
+ within). */
-static void
-dbxout_type_name (tree type)
+static int
+output_types_sort (const void *pa, const void *pb)
{
- tree t;
- if (TYPE_NAME (type) == 0)
- abort ();
- if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
+ const tree lhs = *((const tree *)pa);
+ const tree rhs = *((const tree *)pb);
+
+ if (TYPE_P (lhs))
{
- t = TYPE_NAME (type);
+ if (TYPE_P (rhs))
+ return TYPE_UID (lhs) - TYPE_UID (rhs);
+ else
+ return 1;
}
- else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
+ else
{
- t = DECL_NAME (TYPE_NAME (type));
+ if (TYPE_P (rhs))
+ return -1;
+ else
+ return DECL_UID (lhs) - DECL_UID (rhs);
}
- else
- abort ();
-
- fprintf (asmfile, "%s", IDENTIFIER_POINTER (t));
- CHARS (IDENTIFIER_LENGTH (t));
}
-/* Output leading leading struct or class names needed for qualifying
- type whose scope is limited to a struct or class. */
+
+/* Force all types used by this function to be output in debug
+ information. */
static void
-dbxout_class_name_qualifiers (tree decl)
+output_used_types (void)
{
- tree context = decl_type_context (decl);
-
- if (context != NULL_TREE
- && TREE_CODE(context) == RECORD_TYPE
- && TYPE_NAME (context) != 0
- && (TREE_CODE (TYPE_NAME (context)) == IDENTIFIER_NODE
- || (DECL_NAME (TYPE_NAME (context)) != 0)))
+ if (cfun && cfun->used_types_hash)
{
- tree name = TYPE_NAME (context);
+ VEC(tree, heap) *types;
+ int i;
+ tree type;
- emit_pending_bincls_if_required ();
+ types = VEC_alloc (tree, heap, htab_elements (cfun->used_types_hash));
+ htab_traverse (cfun->used_types_hash, output_used_types_helper, &types);
- if (TREE_CODE (name) == TYPE_DECL)
- {
- dbxout_class_name_qualifiers (name);
- name = DECL_NAME (name);
- }
- fprintf (asmfile, "%s::", IDENTIFIER_POINTER (name));
- CHARS (IDENTIFIER_LENGTH (name) + 2);
+ /* Sort by UID to prevent dependence on hash table ordering. */
+ qsort (VEC_address (tree, types), VEC_length (tree, types),
+ sizeof (tree), output_types_sort);
+
+ for (i = 0; VEC_iterate (tree, types, i, type); i++)
+ debug_queue_symbol (type);
+
+ VEC_free (tree, heap, types);
}
}
-\f
+
/* 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
+ symbol nodes are flagged with TREE_USED. Ignore any that
aren't flaged as TREE_USED. */
if (flag_debug_only_used_symbols
/* 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
a different name. In that case we also want to output
that. */
- if ((TREE_CODE (t) == RECORD_TYPE
+ if (TREE_CODE (t) == RECORD_TYPE
|| TREE_CODE (t) == UNION_TYPE
|| TREE_CODE (t) == QUAL_UNION_TYPE
|| TREE_CODE (t) == ENUMERAL_TYPE)
- && TYPE_STUB_DECL (t)
- && TYPE_STUB_DECL (t) != decl
- && TREE_CODE_CLASS (TREE_CODE (TYPE_STUB_DECL (t))) == 'd'
- && ! DECL_IGNORED_P (TYPE_STUB_DECL (t)))
{
- debug_queue_symbol (TYPE_STUB_DECL (t));
- if (TYPE_NAME (t)
- && TYPE_NAME (t) != TYPE_STUB_DECL (t)
- && TYPE_NAME (t) != decl
- && TREE_CODE_CLASS (TREE_CODE (TYPE_NAME (t))) == 'd')
- debug_queue_symbol (TYPE_NAME (t));
- }
+ if (TYPE_STUB_DECL (t)
+ && TYPE_STUB_DECL (t) != decl
+ && DECL_P (TYPE_STUB_DECL (t))
+ && ! DECL_IGNORED_P (TYPE_STUB_DECL (t)))
+ {
+ debug_queue_symbol (TYPE_STUB_DECL (t));
+ if (TYPE_NAME (t)
+ && TYPE_NAME (t) != TYPE_STUB_DECL (t)
+ && TYPE_NAME (t) != decl
+ && DECL_P (TYPE_NAME (t)))
+ debug_queue_symbol (TYPE_NAME (t));
+ }
+ }
else if (TYPE_NAME (t)
&& TYPE_NAME (t) != decl
- && TREE_CODE_CLASS (TREE_CODE (TYPE_NAME (t))) == 'd')
+ && DECL_P (TYPE_NAME (t)))
debug_queue_symbol (TYPE_NAME (t));
}
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 (asmfile, "%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 (asmfile, ",%s,%s",
- IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
- IDENTIFIER_POINTER (DECL_NAME (context)));
+ {
+ stabstr_C (',');
+ stabstr_I (DECL_ASSEMBLER_NAME (decl));
+ stabstr_C (',');
+ stabstr_I (DECL_NAME (context));
+ }
- dbxout_finish_symbol (decl);
+ dbxout_finish_complex_stabs (decl, N_FUN, XEXP (decl_rtl, 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 (asmfile, "%s\"%s:T", ASM_STABS_OP,
- IDENTIFIER_POINTER (name));
+ dbxout_begin_complex_stabs ();
+ stabstr_I (name);
+ stabstr_S (":T");
dbxout_type (type, 1);
- dbxout_finish_symbol (NULL_TREE);
+ dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE,
+ 0, 0, 0);
}
- /* Output .stabs (or whatever) and leading double quote. */
- fprintf (asmfile, "%s\"", ASM_STABS_OP);
+ dbxout_begin_complex_stabs ();
+ /* Output leading class/struct qualifiers. */
if (use_gnu_debug_info_extensions)
- {
- /* Output leading class/struct qualifiers. */
- dbxout_class_name_qualifiers (decl);
- }
+ dbxout_class_name_qualifiers (decl);
/* Output typedef name. */
- fprintf (asmfile, "%s:", IDENTIFIER_POINTER (DECL_NAME (decl)));
+ stabstr_I (DECL_NAME (decl));
+ stabstr_C (':');
/* Short cut way to output a tag also. */
if ((TREE_CODE (type) == RECORD_TYPE
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', asmfile);
+ stabstr_C ('T');
TREE_ASM_WRITTEN (TYPE_NAME (type)) = 1;
}
-#if 0 /* Now we generate the tag for this case up above. */
- else
- tag_needed = 1;
-#endif
}
- putc ('t', asmfile);
- current_sym_code = DBX_TYPE_DECL_STABS_CODE;
-
+ stabstr_C ('t');
dbxout_type (type, 1);
- dbxout_finish_symbol (decl);
+ dbxout_finish_complex_stabs (decl, DBX_TYPE_DECL_STABS_CODE,
+ 0, 0, 0);
did_output = 1;
}
if (TREE_CODE (name) == TYPE_DECL)
name = DECL_NAME (name);
- current_sym_code = DBX_TYPE_DECL_STABS_CODE;
- current_sym_value = 0;
- current_sym_addr = 0;
- current_sym_nchars = 2 + IDENTIFIER_LENGTH (name);
-
- fprintf (asmfile, "%s\"%s:T", ASM_STABS_OP,
- IDENTIFIER_POINTER (name));
+ dbxout_begin_complex_stabs ();
+ stabstr_I (name);
+ stabstr_S (":T");
dbxout_type (type, 1);
- dbxout_finish_symbol (NULL_TREE);
+ dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE, 0, 0, 0);
did_output = 1;
}
- /* If an enum type has no name, it cannot be referred to,
- but we must output it anyway, since the enumeration constants
- can be referred to. */
+ /* If an enum type has no name, it cannot be referred to, but
+ we must output it anyway, to record the enumeration
+ constants. */
+
if (!did_output && TREE_CODE (type) == ENUMERAL_TYPE)
{
- current_sym_code = DBX_TYPE_DECL_STABS_CODE;
- current_sym_value = 0;
- current_sym_addr = 0;
- current_sym_nchars = 2;
-
+ dbxout_begin_complex_stabs ();
/* Some debuggers fail when given NULL names, so give this a
- harmless name of ` '. */
- fprintf (asmfile, "%s\" :T", ASM_STABS_OP);
+ harmless name of " " (Why not "(anon)"?). */
+ stabstr_S (" :T");
dbxout_type (type, 1);
- dbxout_finish_symbol (NULL_TREE);
+ dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE, 0, 0, 0);
}
/* Prevent duplicate output of a typedef. */
case PARM_DECL:
/* Parm decls go in their own separate chains
and are output by dbxout_reg_parms and dbxout_parms. */
- abort ();
+ gcc_unreachable ();
case RESULT_DECL:
- /* Named return value, treat like a VAR_DECL. */
case VAR_DECL:
- if (! DECL_RTL_SET_P (decl))
- DBXOUT_DECR_NESTING_AND_RETURN (0);
/* Don't mention a variable that is external.
Let the file that defines it describe it. */
if (DECL_EXTERNAL (decl))
break;
/* If the variable is really a constant
- and not written in memory, inform the debugger. */
+ and not written in memory, inform the debugger.
+
+ ??? Why do we skip emitting the type and location in this case? */
if (TREE_STATIC (decl) && TREE_READONLY (decl)
&& DECL_INITIAL (decl) != 0
&& host_integerp (DECL_INITIAL (decl), 0)
&& ! TREE_ASM_WRITTEN (decl)
&& (DECL_CONTEXT (decl) == NULL_TREE
- || TREE_CODE (DECL_CONTEXT (decl)) == BLOCK))
+ || TREE_CODE (DECL_CONTEXT (decl)) == BLOCK
+ || TREE_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 (asmfile, "%s\"%s:c=i" HOST_WIDE_INT_PRINT_DEC
- "\",0x%x,0,0,0\n",
- ASM_STABS_OP, name, ival, N_LSYM);
- DBXOUT_DECR_NESTING;
- return 1;
- }
- else if (TREE_CODE (TREE_TYPE (decl)) == REAL_TYPE)
- {
- /* Don't know how to do this yet. */
- }
- 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. */
- SET_DECL_RTL (decl, eliminate_regs (DECL_RTL (decl), 0, NULL_RTX));
+ decl_rtl = dbxout_expand_expr (decl);
+ if (!decl_rtl)
+ DBXOUT_DECR_NESTING_AND_RETURN (0);
+
+ decl_rtl = eliminate_regs (decl_rtl, 0, 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))
{
letter = 'G';
- current_sym_code = N_GSYM;
+ code = N_GSYM;
}
else
{
- current_sym_addr = XEXP (home, 0);
+ addr = XEXP (home, 0);
letter = decl_function_context (decl) ? 'V' : 'S';
+ /* Some ports can transform a symbol ref into a label ref,
+ because the symbol ref is too far away and has to be
+ dumped into a constant pool. Alternatively, the symbol
+ in the constant pool might be referenced by a different
+ symbol. */
+ if (GET_CODE (addr) == SYMBOL_REF
+ && CONSTANT_POOL_ADDRESS_P (addr))
+ {
+ bool marked;
+ rtx tmp = get_pool_constant_mark (addr, &marked);
+
+ if (GET_CODE (tmp) == SYMBOL_REF)
+ {
+ addr = tmp;
+ if (CONSTANT_POOL_ADDRESS_P (addr))
+ get_pool_constant_mark (addr, &marked);
+ else
+ marked = true;
+ }
+ else if (GET_CODE (tmp) == LABEL_REF)
+ {
+ addr = tmp;
+ marked = true;
+ }
+
+ /* If all references to the constant pool were optimized
+ out, we just ignore the symbol. */
+ if (!marked)
+ return 0;
+ }
+
/* This should be the same condition as in assemble_variable, but
we don't have access to dont_output_data here. So, instead,
we rely on the fact that error_mark_node initializers always
if (DECL_INITIAL (decl) == 0
|| (!strcmp (lang_hooks.name, "GNU C++")
&& DECL_INITIAL (decl) == error_mark_node))
- current_sym_code = N_LCSYM;
+ code = N_LCSYM;
else if (DECL_IN_TEXT_SECTION (decl))
/* This is not quite right, but it's the closest
of all the codes that Unix defines. */
- current_sym_code = DBX_STATIC_CONST_VAR_CODE;
+ code = DBX_STATIC_CONST_VAR_CODE;
else
{
- /* Some ports can transform a symbol ref into a label ref,
- because the symbol ref is too far away and has to be
- dumped into a constant pool. Alternatively, the symbol
- in the constant pool might be referenced by a different
- symbol. */
- if (GET_CODE (current_sym_addr) == SYMBOL_REF
- && CONSTANT_POOL_ADDRESS_P (current_sym_addr))
- {
- 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))
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)
{
- 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;
+ code = N_LCSYM;
letter = 'V';
- current_sym_addr = XEXP (XEXP (home, 0), 0);
+ addr = XEXP (XEXP (home, 0), 0);
}
else if (GET_CODE (home) == CONCAT)
{
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 (asmfile, current_sym_code);
+ DBX_STATIC_BLOCK_START (asm_out_file, code);
#endif
+ dbxout_begin_complex_stabs_noforcetext ();
dbxout_symbol_name (decl, suffix, letter);
dbxout_type (type, 0);
- dbxout_finish_symbol (decl);
+ dbxout_finish_complex_stabs (decl, code, addr, 0, number);
#ifdef DBX_STATIC_BLOCK_END
- DBX_STATIC_BLOCK_END (asmfile, current_sym_code);
+ DBX_STATIC_BLOCK_END (asm_out_file, code);
#endif
return 1;
}
static void
dbxout_symbol_name (tree decl, const char *suffix, int letter)
{
- const char *name;
+ tree name;
if (DECL_CONTEXT (decl)
&& (TYPE_P (DECL_CONTEXT (decl))
or a namespace member, we must put out the mangled name instead of the
DECL_NAME. Note also that static member (variable) names DO NOT begin
with underscores in .stabs directives. */
- name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
+ name = DECL_ASSEMBLER_NAME (decl);
else
/* ...but if we're function-local, we don't want to include the junk
added by ASM_FORMAT_PRIVATE_NAME. */
- name = IDENTIFIER_POINTER (DECL_NAME (decl));
+ name = DECL_NAME (decl);
- if (name == 0)
- name = "(anon)";
- fprintf (asmfile, "%s\"%s%s:", ASM_STABS_OP, name,
- (suffix ? suffix : ""));
+ if (name)
+ stabstr_I (name);
+ else
+ stabstr_S ("(anon)");
+ if (suffix)
+ stabstr_S (suffix);
+ stabstr_C (':');
if (letter)
- putc (letter, asmfile);
-}
-
-static void
-dbxout_prepare_symbol (tree decl ATTRIBUTE_UNUSED)
-{
-#ifdef WINNING_GDB
- const char *filename = DECL_SOURCE_FILE (decl);
-
- dbxout_source_file (asmfile, filename);
-#endif
-
- /* Initialize variables used to communicate each symbol's debug
- information to dbxout_finish_symbol with zeroes. */
-
- /* Cast avoids warning in old compilers. */
- current_sym_code = (STAB_CODE_TYPE) 0;
- current_sym_value = 0;
- current_sym_addr = 0;
-}
-
-static void
-dbxout_finish_symbol (tree sym)
-{
-#ifdef DBX_FINISH_SYMBOL
- DBX_FINISH_SYMBOL (sym);
-#else
- int line = 0;
- if (use_gnu_debug_info_extensions && sym != 0)
- line = DECL_SOURCE_LINE (sym);
-
- fprintf (asmfile, "\",%d,0,%d,", current_sym_code, line);
- if (current_sym_addr)
- output_addr_const (asmfile, current_sym_addr);
- else
- fprintf (asmfile, "%d", current_sym_value);
- putc ('\n', asmfile);
-#endif
+ stabstr_C (letter);
}
/* Output definitions of all the decls in a chain. Return nonzero if
dbxout_parms (tree parms)
{
++debug_nesting;
-
emit_pending_bincls_if_required ();
for (; parms; parms = TREE_CHAIN (parms))
&& 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. */
if (PARM_PASSED_IN_MEMORY (parms))
{
- rtx addr = XEXP (DECL_INCOMING_RTL (parms), 0);
+ rtx inrtl = XEXP (DECL_INCOMING_RTL (parms), 0);
/* ??? Here we assume that the parm address is indexed
off the frame pointer or arg pointer.
If that is not true, we produce meaningless results,
but do not crash. */
- if (GET_CODE (addr) == PLUS
- && GET_CODE (XEXP (addr, 1)) == CONST_INT)
- current_sym_value = INTVAL (XEXP (addr, 1));
- else
- current_sym_value = 0;
-
- current_sym_code = N_PSYM;
- current_sym_addr = 0;
-
- FORCE_TEXT;
- if (DECL_NAME (parms))
- {
- current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (parms));
-
- fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
- IDENTIFIER_POINTER (DECL_NAME (parms)),
- DBX_MEMPARM_STABS_LETTER);
- }
+ if (GET_CODE (inrtl) == PLUS
+ && GET_CODE (XEXP (inrtl, 1)) == CONST_INT)
+ number = INTVAL (XEXP (inrtl, 1));
else
- {
- current_sym_nchars = 8;
- fprintf (asmfile, "%s\"(anon):%c", ASM_STABS_OP,
- DBX_MEMPARM_STABS_LETTER);
- }
-
- /* It is quite tempting to use:
-
- dbxout_type (TREE_TYPE (parms), 0);
-
- as the next statement, rather than using DECL_ARG_TYPE(), so
- that gcc reports the actual type of the parameter, rather
- than the promoted type. This certainly makes GDB's life
- easier, at least for some ports. The change is a bad idea
- however, since GDB expects to be able access the type without
- performing any conversions. So for example, if we were
- passing a float to an unprototyped function, gcc will store a
- double on the stack, but if we emit a stab saying the type is a
- float, then gdb will only read in a single value, and this will
- produce an erroneous value. */
- dbxout_type (DECL_ARG_TYPE (parms), 0);
- current_sym_value = DEBUGGER_ARG_OFFSET (current_sym_value, addr);
- dbxout_finish_symbol (parms);
+ number = 0;
+
+ code = N_PSYM;
+ number = DEBUGGER_ARG_OFFSET (number, inrtl);
+ letter = 'p';
+
+ /* It is quite tempting to use TREE_TYPE (parms) instead
+ of DECL_ARG_TYPE (parms) for the eff_type, so that gcc
+ reports the actual type of the parameter, rather than
+ the promoted type. This certainly makes GDB's life
+ easier, at least for some ports. The change is a bad
+ idea however, since GDB expects to be able access the
+ type without performing any conversions. So for
+ example, if we were passing a float to an unprototyped
+ function, gcc will store a double on the stack, but if
+ we emit a stab saying the type is a float, then gdb
+ will only read in a single value, and this will produce
+ an erroneous value. */
+ eff_type = DECL_ARG_TYPE (parms);
}
else if (REG_P (DECL_RTL (parms)))
{
rtx best_rtl;
- char regparm_letter;
- tree parm_type;
- /* Parm passed in registers and lives in registers or nowhere. */
- current_sym_code = DBX_REGPARM_STABS_CODE;
- regparm_letter = DBX_REGPARM_STABS_LETTER;
- current_sym_addr = 0;
-
- /* If parm lives in a register, use that register;
- pretend the parm was passed there. It would be more consistent
- to describe the register where the parm was passed,
- but in practice that register usually holds something else.
-
- If we use DECL_RTL, then we must use the declared type of
- the variable, not the type that it arrived in. */
+ /* Parm passed in registers and lives in registers or nowhere. */
+ code = DBX_REGPARM_STABS_CODE;
+ letter = DBX_REGPARM_STABS_LETTER;
+
+ /* For parms passed in registers, it is better to use the
+ declared type of the variable, not the type it arrived in. */
+ eff_type = TREE_TYPE (parms);
+
+ /* If parm lives in a register, use that register; pretend
+ the parm was passed there. It would be more consistent
+ to describe the register where the parm was passed, but
+ in practice that register usually holds something else.
+ If the parm lives nowhere, use the register where it
+ was passed. */
if (REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
- {
- best_rtl = DECL_RTL (parms);
- parm_type = TREE_TYPE (parms);
- }
- /* If the parm lives nowhere, use the register where it was
- passed. It is also better to use the declared type here. */
- else
- {
- best_rtl = DECL_INCOMING_RTL (parms);
- parm_type = TREE_TYPE (parms);
- }
- current_sym_value = DBX_REGISTER_NUMBER (REGNO (best_rtl));
-
- FORCE_TEXT;
- if (DECL_NAME (parms))
- {
- current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (parms));
- fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
- IDENTIFIER_POINTER (DECL_NAME (parms)),
- regparm_letter);
- }
+ best_rtl = DECL_RTL (parms);
else
- {
- current_sym_nchars = 8;
- fprintf (asmfile, "%s\"(anon):%c", ASM_STABS_OP,
- regparm_letter);
- }
+ best_rtl = DECL_INCOMING_RTL (parms);
- dbxout_type (parm_type, 0);
- dbxout_finish_symbol (parms);
+ number = DBX_REGISTER_NUMBER (REGNO (best_rtl));
}
else if (MEM_P (DECL_RTL (parms))
&& REG_P (XEXP (DECL_RTL (parms), 0))
The debugger will know from the type
that it was actually passed by invisible reference. */
- char regparm_letter;
- /* Parm passed in registers and lives in registers or nowhere. */
-
- current_sym_code = DBX_REGPARM_STABS_CODE;
- if (use_gnu_debug_info_extensions)
- regparm_letter = GDB_INV_REF_REGPARM_STABS_LETTER;
- else
- regparm_letter = DBX_REGPARM_STABS_LETTER;
+ code = DBX_REGPARM_STABS_CODE;
+
+ /* GDB likes this marked with a special letter. */
+ letter = (use_gnu_debug_info_extensions
+ ? 'a' : DBX_REGPARM_STABS_LETTER);
+ eff_type = TREE_TYPE (parms);
/* DECL_RTL looks like (MEM (REG...). Get the register number.
If it is an unallocated pseudo-reg, then use the register where
- it was passed instead. */
- if (REGNO (XEXP (DECL_RTL (parms), 0)) < FIRST_PSEUDO_REGISTER)
- current_sym_value = REGNO (XEXP (DECL_RTL (parms), 0));
- else
- current_sym_value = REGNO (DECL_INCOMING_RTL (parms));
-
- current_sym_addr = 0;
+ it was passed instead.
+ ??? Why is DBX_REGISTER_NUMBER not used here? */
- FORCE_TEXT;
- if (DECL_NAME (parms))
- {
- current_sym_nchars
- = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms)));
-
- fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
- IDENTIFIER_POINTER (DECL_NAME (parms)),
- regparm_letter);
- }
+ if (REGNO (XEXP (DECL_RTL (parms), 0)) < FIRST_PSEUDO_REGISTER)
+ number = REGNO (XEXP (DECL_RTL (parms), 0));
else
- {
- current_sym_nchars = 8;
- fprintf (asmfile, "%s\"(anon):%c", ASM_STABS_OP,
- regparm_letter);
- }
-
- dbxout_type (TREE_TYPE (parms), 0);
- dbxout_finish_symbol (parms);
+ number = REGNO (DECL_INCOMING_RTL (parms));
}
else if (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 (asmfile, "%s\"%s:v", ASM_STABS_OP, decl_name);
-
- current_sym_value
- = DEBUGGER_ARG_OFFSET (current_sym_value,
- XEXP (XEXP (DECL_RTL (parms), 0), 0));
- dbxout_type (TREE_TYPE (parms), 0);
- dbxout_finish_symbol (parms);
+ number = 0;
+
+ number = DEBUGGER_ARG_OFFSET (number,
+ XEXP (XEXP (DECL_RTL (parms), 0), 0));
}
else if (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)));
-
- fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
- IDENTIFIER_POINTER (DECL_NAME (parms)),
- DBX_MEMPARM_STABS_LETTER);
- }
- else
- {
- current_sym_nchars = 8;
- fprintf (asmfile, "%s\"(anon):%c", ASM_STABS_OP,
- DBX_MEMPARM_STABS_LETTER);
- }
+ number += (GET_MODE_SIZE (GET_MODE (DECL_RTL (parms)))
+ - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms))));
+ }
+ else
+ /* ??? We don't know how to represent this argument. */
+ continue;
- current_sym_value
- = DEBUGGER_ARG_OFFSET (current_sym_value,
- XEXP (DECL_RTL (parms), 0));
- dbxout_type (TREE_TYPE (parms), 0);
- dbxout_finish_symbol (parms);
+ dbxout_begin_complex_stabs ();
+
+ if (DECL_NAME (parms))
+ {
+ stabstr_I (DECL_NAME (parms));
+ stabstr_C (':');
}
+ else
+ stabstr_S ("(anon):");
+ stabstr_C (letter);
+ dbxout_type (eff_type, 0);
+ dbxout_finish_complex_stabs (parms, code, 0, 0, number);
}
DBXOUT_DECR_NESTING;
}
for (; parms; parms = TREE_CHAIN (parms))
if (DECL_NAME (parms) && PARM_PASSED_IN_MEMORY (parms))
{
- dbxout_prepare_symbol (parms);
-
/* Report parms that live in registers during the function
but were passed in memory. */
if (REG_P (DECL_RTL (parms))
{
while (args)
{
- putc (',', asmfile);
+ 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 (asmfile, label);
-#else
- fprintf (asmfile, "%s%d,0,0,", ASM_STABN_OP, N_LBRAC);
- assemble_name (asmfile, label);
-#if DBX_BLOCKS_FUNCTION_RELATIVE
- putc ('-', asmfile);
- assemble_name (asmfile, begin_label);
-#endif
- fprintf (asmfile, "\n");
-#endif
+ dbxout_begin_stabn (N_LBRAC);
+ if (DBX_BLOCKS_FUNCTION_RELATIVE)
+ 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 (asmfile, label);
-#else
- fprintf (asmfile, "%s%d,0,0,", ASM_STABN_OP, N_RBRAC);
- assemble_name (asmfile, label);
-#if DBX_BLOCKS_FUNCTION_RELATIVE
- putc ('-', asmfile);
- assemble_name (asmfile, begin_label);
-#endif
- fprintf (asmfile, "\n");
-#endif
+ dbxout_begin_stabn (N_RBRAC);
+ if (DBX_BLOCKS_FUNCTION_RELATIVE)
+ 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;
- if (current_function_func_begin_label != NULL_TREE)
- begin_label = IDENTIFIER_POINTER (current_function_func_begin_label);
- else
- begin_label = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0);
+ 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
{
tree decl = BLOCK_VARS (block);
while (decl)
{
- fprintf (asmfile, "%s\"%s:C1\",%d,0,0,", ASM_STABS_OP,
- IDENTIFIER_POINTER (DECL_NAME (decl)), N_CATCH);
- assemble_name (asmfile, scope_start);
- fprintf (asmfile, "\n");
+ dbxout_begin_complex_stabs ();
+ stabstr_I (DECL_NAME (decl));
+ stabstr_S (":C1");
+ dbxout_finish_complex_stabs (0, N_CATCH, 0,
+ scope_start, 0);
decl = TREE_CHAIN (decl);
}
}
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;
+
+ if (DECL_IGNORED_P (decl))
+ return;
+
+ saved_tree_used1 = TREE_USED (decl);
TREE_USED (decl) = 1;
if (DECL_NAME (DECL_RESULT (decl)) != 0)
{