/* 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 Free Software Foundation, Inc.
This file is part of GCC.
#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"
#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 DBX_MEMPARM_STABS_LETTER
-#define DBX_MEMPARM_STABS_LETTER 'p'
+#ifndef NO_DBX_BNSYM_ENSYM
+#define NO_DBX_BNSYM_ENSYM 0
#endif
-#ifndef FILE_NAME_JOINER
-#define FILE_NAME_JOINER "/"
+#ifndef NO_DBX_MAIN_SOURCE_DIRECTORY
+#define NO_DBX_MAIN_SOURCE_DIRECTORY 0
#endif
-/* GDB needs to know that the stabs were generated by GCC. We emit an
- N_OPT stab at the beginning of the source file to indicate this.
- The string is historical, and different on a very few targets. */
-#ifndef STABS_GCC_MARKER
-#define STABS_GCC_MARKER "gcc2_compiled."
+#ifndef DBX_BLOCKS_FUNCTION_RELATIVE
+#define DBX_BLOCKS_FUNCTION_RELATIVE 0
+#endif
+
+#ifndef DBX_LINES_FUNCTION_RELATIVE
+#define DBX_LINES_FUNCTION_RELATIVE 0
+#endif
+
+#ifndef DBX_CONTIN_LENGTH
+#define DBX_CONTIN_LENGTH 80
+#endif
+
+#ifndef DBX_CONTIN_CHAR
+#define DBX_CONTIN_CHAR '\\'
#endif
enum typestatus {TYPE_UNSEEN, TYPE_XREF, TYPE_DEFINED};
/* 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 current_function_section (current_function_decl);
#else
#define FORCE_TEXT
#endif
/* 1 if PARM is passed to this function in memory. */
#define PARM_PASSED_IN_MEMORY(PARM) \
- (GET_CODE (DECL_INCOMING_RTL (PARM)) == MEM)
+ (MEM_P (DECL_INCOMING_RTL (PARM)))
/* A C expression for the integer offset value of an automatic variable
(N_LSYM) having address X (an RTX). */
#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);
\f
/* The debug hooks structure. */
#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);
static void dbxout_function_decl (tree);
-static void dbxout_type_decl (tree, int);
const struct gcc_debug_hooks dbx_debug_hooks =
{
dbxout_end_block,
debug_true_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 */
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 = obstack_finish (&stabstr_ob);
+
+ /* Within the buffer are a sequence of NUL-separated strings,
+ each of which is to be written out as a separate stab
+ directive. */
+ for (;;)
+ {
+ chunklen = strlen (chunk);
+ fwrite (chunk, 1, chunklen, asm_out_file);
+ fputs ("\",", asm_out_file);
+
+ /* Must add an extra byte to account for the NUL separator. */
+ chunk += chunklen + 1;
+ len -= chunklen + 1;
+
+ /* Only put a line number on the last stab in the sequence. */
+ DBX_FINISH_STABS (sym, code, len == 0 ? line : 0,
+ addr, label, number);
+ if (len == 0)
+ break;
+
+ fputs (ASM_STABS_OP, asm_out_file);
+ putc ('"', asm_out_file);
+ }
+ stabstr_last_contin_point = 0;
+ }
+ else
+ {
+ /* No continuations - we can put the whole string out at once.
+ It is faster to augment the string with the close quote and
+ comma than to do a two-character fputs. */
+ obstack_grow (&stabstr_ob, "\",", 2);
+ len = obstack_object_size (&stabstr_ob);
+ str = obstack_finish (&stabstr_ob);
+
+ fwrite (str, 1, len, asm_out_file);
+ DBX_FINISH_STABS (sym, code, line, addr, label, number);
+ }
+ obstack_free (&stabstr_ob, str);
+}
+
#if defined (DBX_DEBUGGING_INFO)
+
static void
-dbxout_function_end (void)
+dbxout_function_end (tree decl)
{
char lscope_label_name[100];
- /* Convert Ltext into the appropriate format for local labels in case
+
+ /* The Lscope label must be emitted even if we aren't doing anything
+ else; dbxout_block needs it. */
+ function_section (current_function_decl);
+
+ /* Convert Lscope into the appropriate format for local labels in case
the system doesn't insert underscores in front of user generated
labels. */
ASM_GENERATE_INTERNAL_LABEL (lscope_label_name, "Lscope", scope_labelno);
- (*targetm.asm_out.internal_label) (asmfile, "Lscope", scope_labelno);
+ targetm.asm_out.internal_label (asm_out_file, "Lscope", scope_labelno);
scope_labelno++;
+ /* The N_FUN tag at the end of the function is a GNU extension,
+ which may be undesirable, and is unnecessary if we do not have
+ named sections. */
+ if (!use_gnu_debug_info_extensions
+ || NO_DBX_FUNCTION_END
+ || !targetm.have_named_sections
+ || DECL_IGNORED_P (decl))
+ return;
+
/* By convention, GCC will mark the end of a function with an N_FUN
symbol and an empty string. */
#ifdef DBX_OUTPUT_NFUN
- DBX_OUTPUT_NFUN (asmfile, lscope_label_name, current_function_decl);
+ DBX_OUTPUT_NFUN (asm_out_file, lscope_label_name, current_function_decl);
#else
- fprintf (asmfile, "%s\"\",%d,0,0,", ASM_STABS_OP, N_FUN);
- assemble_name (asmfile, lscope_label_name);
- putc ('-', asmfile);
- assemble_name (asmfile, XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0));
- fprintf (asmfile, "\n");
+ if (flag_reorder_blocks_and_partition)
+ {
+ dbxout_begin_empty_stabs (N_FUN);
+ dbxout_stab_value_label_diff (hot_section_end_label, hot_section_label);
+ dbxout_begin_empty_stabs (N_FUN);
+ dbxout_stab_value_label_diff (cold_section_end_label,
+ unlikely_section_label);
+ }
+ else
+ {
+ dbxout_begin_empty_stabs (N_FUN);
+ dbxout_stab_value_label_diff (lscope_label_name,
+ XSTR (XEXP (DECL_RTL (current_function_decl),
+ 0), 0));
+ }
+
#endif
+
+ if (!NO_DBX_BNSYM_ENSYM && !flag_debug_only_used_symbols)
+ dbxout_stabd (N_ENSYM, 0);
}
#endif /* DBX_DEBUGGING_INFO */
+/* Get lang description for N_SO stab. */
+static unsigned int ATTRIBUTE_UNUSED
+get_lang_number (void)
+{
+ const char *language_string = lang_hooks.name;
+
+ if (strcmp (language_string, "GNU C") == 0)
+ return N_SO_C;
+ else if (strcmp (language_string, "GNU C++") == 0)
+ return N_SO_CC;
+ else if (strcmp (language_string, "GNU F77") == 0)
+ return N_SO_FORTRAN;
+ else if (strcmp (language_string, "GNU F95") == 0)
+ return N_SO_FORTRAN90; /* CHECKME */
+ else if (strcmp (language_string, "GNU Pascal") == 0)
+ return N_SO_PASCAL;
+ else if (strcmp (language_string, "GNU Objective-C") == 0)
+ return N_SO_OBJC;
+ else
+ return 0;
+
+}
+
/* At the beginning of compilation, start writing the symbol table.
Initialize `typevec' and output the standard data types of C. */
dbxout_init (const char *input_file_name)
{
char ltext_label_name[100];
- tree syms = (*lang_hooks.decls.getdecls) ();
-
- asmfile = asm_out_file;
+ bool used_ltext_label_name = false;
+ tree syms = lang_hooks.decls.getdecls ();
typevec_len = 100;
typevec = 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);
+ }
#ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
- DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asmfile, cwd);
+ DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asm_out_file, cwd);
#else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
- fprintf (asmfile, "%s", ASM_STABS_OP);
- output_quoted_string (asmfile, cwd);
- fprintf (asmfile, ",%d,0,0,", N_SO);
- assemble_name (asmfile, ltext_label_name);
- fputc ('\n', asmfile);
+ dbxout_begin_simple_stabs_desc (cwd, N_SO, get_lang_number ());
+ dbxout_stab_value_label (ltext_label_name);
+ used_ltext_label_name = true;
#endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
- }
}
#ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
- 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, input_file_name);
#else
- /* Emit an N_OPT stab to indicate that this file was compiled by GCC. */
- fprintf (asmfile, "%s\"%s\",%d,0,0,0\n",
- ASM_STABS_OP, STABS_GCC_MARKER, N_OPT);
+ dbxout_begin_simple_stabs_desc (input_file_name, N_SO, get_lang_number ());
+ dbxout_stab_value_label (ltext_label_name);
+ used_ltext_label_name = true;
+#endif
+
+ if (used_ltext_label_name)
+ {
+ text_section ();
+ targetm.asm_out.internal_label (asm_out_file, "Ltext", 0);
+ }
+
+ /* Emit an N_OPT stab to indicate that this file was compiled by GCC.
+ The string used is historical. */
+#ifndef NO_DBX_GCC_MARKER
+ dbxout_begin_simple_stabs ("gcc2_compiled.", N_OPT);
+ dbxout_stab_value_zero ();
#endif
base_input_file = lastfile = input_file_name;
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. */
#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
/* 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
+ /* Don't change section amid function. */
+ if (current_function_decl == NULL_TREE)
text_section ();
- (*targetm.asm_out.internal_label) (file, "Ltext", source_label_number);
- source_label_number++;
+
+ dbxout_begin_simple_stabs (filename, N_SOL);
+ dbxout_stab_value_internal_label ("Ltext", &source_label_number);
lastfile = filename;
}
}
+/* Output N_BNSYM and line number symbol entry. */
+
+static void
+dbxout_begin_prologue (unsigned int lineno, const char *filename)
+{
+ if (use_gnu_debug_info_extensions
+ && !NO_DBX_FUNCTION_END
+ && !NO_DBX_BNSYM_ENSYM
+ && !flag_debug_only_used_symbols)
+ dbxout_stabd (N_BNSYM, 0);
+
+ dbxout_source_line (lineno, filename);
+}
+
/* Output a line number symbol entry for source file FILENAME and line
number LINENO. */
static void
dbxout_source_line (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)
+ {
+ rtx begin_label = XEXP (DECL_RTL (current_function_decl), 0);
+ dbxout_begin_stabn_sline (lineno);
+ dbxout_stab_value_internal_label_diff ("LM", &dbxout_source_line_counter,
+ XSTR (begin_label, 0));
+
+ }
+ else
+ dbxout_stabd (N_SLINE, lineno);
#endif
}
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 */
}
/* 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
+ {
+ 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. */
field that we can support. */
for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
{
-
- /* If on of the nodes is an error_mark or its type is then return early. */
+ /* If one of the nodes is an error_mark or its type is then
+ return early. */
if (tem == error_mark_node || TREE_TYPE (tem) == error_mark_node)
return;
/* Omit here local type decls until we know how to support them. */
if (TREE_CODE (tem) == TYPE_DECL
+ /* Omit 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
static void
dbxout_type_methods (tree type)
-{
- /* C++: put out the method names and their parameter lists */
- tree methods = TYPE_METHODS (type);
- tree type_encoding;
- tree fndecl;
- tree last;
- char formatted_type_identifier_length[16];
- int type_identifier_length;
-
- if (methods == NULL_TREE)
- return;
-
- type_encoding = DECL_NAME (TYPE_NAME (type));
-
-#if 0
- /* C++: Template classes break some assumptions made by this code about
- the class names, constructor names, and encodings for assembler
- label names. For now, disable output of dbx info for them. */
- {
- const char *ptr = IDENTIFIER_POINTER (type_encoding);
- /* This should use index. (mrs) */
- while (*ptr && *ptr != '<') ptr++;
- if (*ptr != 0)
- {
- static int warned;
- if (!warned)
- warned = 1;
- return;
- }
- }
-#endif
-
- type_identifier_length = IDENTIFIER_LENGTH (type_encoding);
+{
+ /* C++: put out the method names and their parameter lists */
+ tree methods = TYPE_METHODS (type);
+ tree fndecl;
+ tree last;
- sprintf (formatted_type_identifier_length, "%d", type_identifier_length);
+ if (methods == NULL_TREE)
+ return;
if (TREE_CODE (methods) != TREE_VEC)
fndecl = methods;
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_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
break;
case INTEGER_TYPE:
- if (type == char_type_node && ! TREE_UNSIGNED (type))
+ if (type == char_type_node && ! TYPE_UNSIGNED (type))
{
/* Output the type `char' as a subrange of itself!
I don't understand this definition, just copied it
from the output of pcc.
This used to use `r2' explicitly and we used to
take care to make sure that `char' was type number 2. */
- fprintf (asmfile, "r");
- CHARS (1);
+ stabstr_C ('r');
dbxout_type_index (type);
- fprintf (asmfile, ";0;127;");
- CHARS (7);
+ stabstr_S (";0;127;");
}
/* If this is a subtype of another integer type, always prefer to
&& 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);
&& 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
case REAL_TYPE:
/* This used to say `r1' and we used to take care
to make sure that `int' was type number 1. */
- fprintf (asmfile, "r");
- CHARS (1);
+ stabstr_C ('r');
dbxout_type_index (integer_type_node);
- putc (';', asmfile);
- CHARS (1);
- print_wide_int (int_size_in_bytes (type));
- fputs (";0;", asmfile);
- CHARS (3);
+ stabstr_C (';');
+ stabstr_D (int_size_in_bytes (type));
+ stabstr_S (";0;");
break;
case CHAR_TYPE:
if (use_gnu_debug_info_extensions)
{
have_used_extensions = 1;
- fputs ("@s", asmfile);
- CHARS (2);
- print_wide_int (BITS_PER_UNIT * int_size_in_bytes (type));
- fputs (";-20;", asmfile);
- CHARS (4);
+ stabstr_S ("@s");
+ stabstr_D (BITS_PER_UNIT * int_size_in_bytes (type));
+ stabstr_S (";-20;");
}
else
{
/* Output the type `char' as a subrange of itself.
That is what pcc seems to do. */
- fprintf (asmfile, "r");
- CHARS (1);
+ stabstr_C ('r');
dbxout_type_index (char_type_node);
- fprintf (asmfile, ";0;%d;", TREE_UNSIGNED (type) ? 255 : 127);
- CHARS (7);
+ stabstr_S (TYPE_UNSIGNED (type) ? ";0;255;" : ";0;127;");
}
break;
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);
+ stabstr_C ('s');
+ stabstr_D (int_size_in_bytes (type));
+ stabstr_S ("real:");
dbxout_type (TREE_TYPE (type), 0);
- fprintf (asmfile, ",0,%d;", TYPE_PRECISION (TREE_TYPE (type)));
- CHARS (7);
- fprintf (asmfile, "imag:");
- CHARS (5);
- dbxout_type (TREE_TYPE (type), 0);
- fprintf (asmfile, ",%d,%d;;", TYPE_PRECISION (TREE_TYPE (type)),
- TYPE_PRECISION (TREE_TYPE (type)));
- CHARS (10);
- }
- break;
+ stabstr_S (",0,");
+ stabstr_D (TYPE_PRECISION (TREE_TYPE (type)));
- case SET_TYPE:
- if (use_gnu_debug_info_extensions)
- {
- have_used_extensions = 1;
- fputs ("@s", asmfile);
- CHARS (2);
- print_wide_int (BITS_PER_UNIT * int_size_in_bytes (type));
- putc (';', asmfile);
- CHARS (1);
-
- /* Check if a bitstring type, which in Chill is
- different from a [power]set. */
- if (TYPE_STRING_FLAG (type))
- {
- fprintf (asmfile, "@S;");
- CHARS (3);
- }
+ stabstr_S (";imag:");
+ dbxout_type (TREE_TYPE (type), 0);
+ stabstr_C (',');
+ stabstr_D (TYPE_PRECISION (TREE_TYPE (type)));
+ stabstr_C (',');
+ stabstr_D (TYPE_PRECISION (TREE_TYPE (type)));
+ stabstr_S (";;");
}
- putc ('S', asmfile);
- CHARS (1);
- dbxout_type (TYPE_DOMAIN (type), 0);
break;
case ARRAY_TYPE:
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 (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);
}
case UNION_TYPE:
case QUAL_UNION_TYPE:
{
- int i, n_baseclasses = 0;
-
- if (TYPE_BINFO (type) != 0
- && TREE_CODE (TYPE_BINFO (type)) == TREE_VEC
- && TYPE_BINFO_BASETYPES (type) != 0)
- n_baseclasses = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type));
+ tree binfo = TYPE_BINFO (type);
/* Output a structure type. We must use the same test here as we
use in the DBX_NO_XREFS case above. */
If the type has a name, don't nest its definition within
another type's definition; instead, output an xref
and let the definition come when the name is defined. */
- fputs ((TREE_CODE (type) == RECORD_TYPE) ? "xs" : "xu", asmfile);
- CHARS (2);
-#if 0 /* This assertion is legitimately false in C++. */
- /* We shouldn't be outputting a reference to a type before its
- definition unless the type has a tag name.
- A typedef name without a tag name should be impossible. */
- if (TREE_CODE (TYPE_NAME (type)) != IDENTIFIER_NODE)
- abort ();
-#endif
+ stabstr_S ((TREE_CODE (type) == RECORD_TYPE) ? "xs" : "xu");
if (TYPE_NAME (type) != 0)
dbxout_type_name (type);
else
{
- fprintf (asmfile, "$$%d", anonymous_type_number++);
- CHARS (5);
+ stabstr_S ("$$");
+ stabstr_D (anonymous_type_number++);
}
- fprintf (asmfile, ":");
- CHARS (1);
+ stabstr_C (':');
typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
break;
}
/* Identify record or union, and print its size. */
- putc (((TREE_CODE (type) == RECORD_TYPE) ? 's' : 'u'), asmfile);
- CHARS (1);
- print_wide_int (int_size_in_bytes (type));
+ stabstr_C ((TREE_CODE (type) == RECORD_TYPE) ? 's' : 'u');
+ stabstr_D (int_size_in_bytes (type));
- if (use_gnu_debug_info_extensions)
- {
- if (n_baseclasses)
- {
- have_used_extensions = 1;
- fprintf (asmfile, "!%d,", n_baseclasses);
- CHARS (8);
- }
- }
- for (i = 0; i < n_baseclasses; i++)
+ if (binfo)
{
- tree binfo = TYPE_BINFO (type);
- tree child = BINFO_BASETYPE (binfo, i);
- tree access = (BINFO_BASEACCESSES (binfo)
- ? BINFO_BASEACCESS (binfo, i) : access_public_node);
-
+ int i;
+ tree child;
+ VEC (tree) *accesses = BINFO_BASE_ACCESSES (binfo);
+
if (use_gnu_debug_info_extensions)
{
- have_used_extensions = 1;
- putc (TREE_VIA_VIRTUAL (child) ? '1' : '0', asmfile);
- putc (access == access_public_node ? '2' :
- (access == access_protected_node ? '1' :'0'),
- asmfile);
- CHARS (2);
- if (TREE_VIA_VIRTUAL (child)
- && strcmp (lang_hooks.name, "GNU C++") == 0)
- /* For a virtual base, print the (negative) offset within
- the vtable where we must look to find the necessary
- adjustment. */
- print_wide_int (tree_low_cst (BINFO_VPTR_FIELD (child), 0)
- * BITS_PER_UNIT);
- else
- print_wide_int (tree_low_cst (BINFO_OFFSET (child), 0)
- * BITS_PER_UNIT);
- putc (',', asmfile);
- CHARS (1);
- dbxout_type (BINFO_TYPE (child), 0);
- putc (';', asmfile);
- CHARS (1);
+ if (BINFO_N_BASE_BINFOS (binfo))
+ {
+ have_used_extensions = 1;
+ stabstr_C ('!');
+ stabstr_U (BINFO_N_BASE_BINFOS (binfo));
+ stabstr_C (',');
+ }
}
- else
+ for (i = 0; BINFO_BASE_ITERATE (binfo, i, child); i++)
{
- /* Print out the base class information with fields
- which have the same names at the types they hold. */
- dbxout_type_name (BINFO_TYPE (child));
- putc (':', asmfile);
- CHARS (1);
- dbxout_type (BINFO_TYPE (child), full);
- putc (',', asmfile);
- CHARS (1);
- print_wide_int (tree_low_cst (BINFO_OFFSET (child), 0)
- * BITS_PER_UNIT);
- putc (',', asmfile);
- CHARS (1);
- print_wide_int (tree_low_cst (TYPE_SIZE (BINFO_TYPE (child)),
- 0)
- * BITS_PER_UNIT);
- putc (';', asmfile);
- CHARS (1);
+ tree access = (accesses ? VEC_index (tree, accesses, i)
+ : access_public_node);
+
+ if (use_gnu_debug_info_extensions)
+ {
+ have_used_extensions = 1;
+ stabstr_C (BINFO_VIRTUAL_P (child) ? '1' : '0');
+ stabstr_C (access == access_public_node ? '2' :
+ access == access_protected_node
+ ? '1' :'0');
+ if (BINFO_VIRTUAL_P (child)
+ && strcmp (lang_hooks.name, "GNU C++") == 0)
+ /* For a virtual base, print the (negative)
+ offset within the vtable where we must look
+ to find the necessary adjustment. */
+ stabstr_D
+ (tree_low_cst (BINFO_VPTR_FIELD (child), 0)
+ * BITS_PER_UNIT);
+ else
+ stabstr_D (tree_low_cst (BINFO_OFFSET (child), 0)
+ * BITS_PER_UNIT);
+ stabstr_C (',');
+ dbxout_type (BINFO_TYPE (child), 0);
+ stabstr_C (';');
+ }
+ else
+ {
+ /* Print out the base class information with
+ fields which have the same names at the types
+ they hold. */
+ dbxout_type_name (BINFO_TYPE (child));
+ stabstr_C (':');
+ dbxout_type (BINFO_TYPE (child), full);
+ stabstr_C (',');
+ stabstr_D (tree_low_cst (BINFO_OFFSET (child), 0)
+ * BITS_PER_UNIT);
+ stabstr_C (',');
+ stabstr_D
+ (tree_low_cst (TYPE_SIZE (BINFO_TYPE (child)), 0)
+ * BITS_PER_UNIT);
+ stabstr_C (';');
+ }
}
}
}
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. */
{
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);
+ have_used_extensions = 1;
+ stabstr_S ("@s");
+ stabstr_D (TYPE_PRECISION (type));
+ stabstr_C (';');
}
- putc ('e', asmfile);
- CHARS (1);
+ stabstr_C ('e');
for (tem = TYPE_VALUES (type); tem; tem = TREE_CHAIN (tem))
{
- fprintf (asmfile, "%s:", IDENTIFIER_POINTER (TREE_PURPOSE (tem)));
- CHARS (IDENTIFIER_LENGTH (TREE_PURPOSE (tem)) + 1);
+ stabstr_I (TREE_PURPOSE (tem));
+ stabstr_C (':');
+
if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == 0)
- print_wide_int (TREE_INT_CST_LOW (TREE_VALUE (tem)));
+ stabstr_D (TREE_INT_CST_LOW (TREE_VALUE (tem)));
else if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == -1
&& (HOST_WIDE_INT) TREE_INT_CST_LOW (TREE_VALUE (tem)) < 0)
- print_wide_int (TREE_INT_CST_LOW (TREE_VALUE (tem)));
+ stabstr_D (TREE_INT_CST_LOW (TREE_VALUE (tem)));
else
- print_int_cst_octal (TREE_VALUE (tem));
+ stabstr_O (TREE_VALUE (tem));
- putc (',', asmfile);
- CHARS (1);
+ stabstr_C (',');
if (TREE_CHAIN (tem) != 0)
CONTIN;
}
- putc (';', asmfile);
- CHARS (1);
+ stabstr_C (';');
break;
case POINTER_TYPE:
- putc ('*', asmfile);
- CHARS (1);
+ stabstr_C ('*');
dbxout_type (TREE_TYPE (type), 0);
break;
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. */
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);
+ {
+ have_used_extensions = 1;
+ stabstr_C ('&');
+ }
+ else
+ stabstr_C ('*');
dbxout_type (TREE_TYPE (type), 0);
break;
case FUNCTION_TYPE:
- putc ('f', asmfile);
- CHARS (1);
+ stabstr_C ('f');
dbxout_type (TREE_TYPE (type), 0);
break;
default:
- abort ();
+ gcc_unreachable ();
}
}
&& TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST
&& (TYPE_PRECISION (type) > TYPE_PRECISION (integer_type_node)
|| ((TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))
- && TREE_UNSIGNED (type))
+ && TYPE_UNSIGNED (type))
|| TYPE_PRECISION (type) > HOST_BITS_PER_WIDE_INT
|| (TYPE_PRECISION (type) == HOST_BITS_PER_WIDE_INT
- && TREE_UNSIGNED (type))))
+ && TYPE_UNSIGNED (type))))
return TRUE;
else
return FALSE;
}
-/* Print the value of integer constant C, in octal,
- handling double precision. */
-
-static void
-print_int_cst_octal (tree c)
-{
- unsigned HOST_WIDE_INT high = TREE_INT_CST_HIGH (c);
- unsigned HOST_WIDE_INT low = TREE_INT_CST_LOW (c);
- int excess = (3 - (HOST_BITS_PER_WIDE_INT % 3));
- unsigned int width = TYPE_PRECISION (TREE_TYPE (c));
-
- /* GDB wants constants with no extra leading "1" bits, so
- we need to remove any sign-extension that might be
- present. */
- if (width == HOST_BITS_PER_WIDE_INT * 2)
- ;
- else if (width > HOST_BITS_PER_WIDE_INT)
- high &= (((HOST_WIDE_INT) 1 << (width - HOST_BITS_PER_WIDE_INT)) - 1);
- else if (width == HOST_BITS_PER_WIDE_INT)
- high = 0;
- else
- high = 0, low &= (((HOST_WIDE_INT) 1 << width) - 1);
-
- fprintf (asmfile, "0");
- CHARS (1);
-
- if (excess == 3)
- {
- print_octal (high, HOST_BITS_PER_WIDE_INT / 3);
- print_octal (low, HOST_BITS_PER_WIDE_INT / 3);
- }
- else
- {
- unsigned HOST_WIDE_INT beg = high >> excess;
- unsigned HOST_WIDE_INT middle
- = ((high & (((HOST_WIDE_INT) 1 << excess) - 1)) << (3 - excess)
- | (low >> (HOST_BITS_PER_WIDE_INT / 3 * 3)));
- unsigned HOST_WIDE_INT end
- = low & (((unsigned HOST_WIDE_INT) 1
- << (HOST_BITS_PER_WIDE_INT / 3 * 3))
- - 1);
-
- fprintf (asmfile, "%o%01o", (int) beg, (int) middle);
- CHARS (2);
- print_octal (end, HOST_BITS_PER_WIDE_INT / 3);
- }
-}
-
-static void
-print_octal (unsigned HOST_WIDE_INT value, int digits)
-{
- int i;
-
- for (i = digits - 1; i >= 0; i--)
- fprintf (asmfile, "%01o", (int) ((value >> (3 * i)) & 7));
-
- CHARS (digits);
-}
-
-/* Output C in decimal while adjusting the number of digits written. */
-
-static void
-print_wide_int (HOST_WIDE_INT c)
-{
- int digs = 0;
-
- fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, c);
-
- if (c < 0)
- digs++, c = -c;
-
- while (c > 0)
- c /= 10; digs++;
-
- CHARS (digs);
-}
-
/* 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
dbxout_type_name (tree type)
{
- tree t;
- if (TYPE_NAME (type) == 0)
- abort ();
- if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
- {
- t = TYPE_NAME (type);
- }
- else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
+ tree t = TYPE_NAME (type);
+
+ gcc_assert (t);
+ switch (TREE_CODE (t))
{
- t = DECL_NAME (TYPE_NAME (type));
+ case IDENTIFIER_NODE:
+ break;
+ case TYPE_DECL:
+ t = DECL_NAME (t);
+ break;
+ default:
+ gcc_unreachable ();
}
- else
- abort ();
- fprintf (asmfile, "%s", IDENTIFIER_POINTER (t));
- CHARS (IDENTIFIER_LENGTH (t));
+ stabstr_I (t);
}
/* Output leading leading struct or class names needed for qualifying
{
tree name = TYPE_NAME (context);
- emit_pending_bincls_if_required ();
-
if (TREE_CODE (name) == TYPE_DECL)
{
dbxout_class_name_qualifiers (name);
name = DECL_NAME (name);
}
- fprintf (asmfile, "%s::", IDENTIFIER_POINTER (name));
- CHARS (IDENTIFIER_LENGTH (name) + 2);
+ stabstr_I (name);
+ stabstr_S ("::");
}
}
\f
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:
context = decl_function_context (decl);
if (context == current_function_decl)
break;
- if (GET_CODE (DECL_RTL (decl)) != MEM
+ /* Don't mention an inline instance of a nested function. */
+ if (context && DECL_FROM_INLINE (decl))
+ break;
+ if (!MEM_P (DECL_RTL (decl))
|| GET_CODE (XEXP (DECL_RTL (decl), 0)) != SYMBOL_REF)
break;
- FORCE_TEXT;
- fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
- IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
- TREE_PUBLIC (decl) ? 'F' : 'f');
+ dbxout_begin_complex_stabs ();
+ stabstr_I (DECL_ASSEMBLER_NAME (decl));
+ stabstr_S (TREE_PUBLIC (decl) ? ":F" : ":f");
result = 1;
- current_sym_code = N_FUN;
- current_sym_addr = XEXP (DECL_RTL (decl), 0);
-
if (TREE_TYPE (type))
dbxout_type (TREE_TYPE (type), 0);
else
mention the containing function name
as well as (since dbx wants it) our own assembler-name. */
if (context != 0)
- fprintf (asmfile, ",%s,%s",
- IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
- IDENTIFIER_POINTER (DECL_NAME (context)));
+ {
+ stabstr_C (',');
+ stabstr_I (DECL_ASSEMBLER_NAME (decl));
+ stabstr_C (',');
+ stabstr_I (DECL_NAME (context));
+ }
- dbxout_finish_symbol (decl);
+ dbxout_finish_complex_stabs (decl, N_FUN, XEXP (DECL_RTL (decl), 0),
+ 0, 0);
break;
case TYPE_DECL:
if (TREE_CODE (name) == TYPE_DECL)
name = DECL_NAME (name);
- current_sym_code = DBX_TYPE_DECL_STABS_CODE;
- current_sym_value = 0;
- current_sym_addr = 0;
- current_sym_nchars = 2 + IDENTIFIER_LENGTH (name);
-
- fprintf (asmfile, "%s\"%s:T", ASM_STABS_OP,
- IDENTIFIER_POINTER (name));
+ dbxout_begin_complex_stabs ();
+ stabstr_I (name);
+ stabstr_S (":T");
dbxout_type (type, 1);
- dbxout_finish_symbol (NULL_TREE);
+ dbxout_finish_complex_stabs (0, DBX_TYPE_DECL_STABS_CODE,
+ 0, 0, 0);
}
- /* Output .stabs (or whatever) and leading double quote. */
- fprintf (asmfile, "%s\"", ASM_STABS_OP);
+ dbxout_begin_complex_stabs ();
+ /* Output leading class/struct qualifiers.
+ ??? why not set have_used_extensions here ... because
+ then the test of it below would always be true, I
+ guess. But it's not clear to me why we shouldn't do
+ that always in extended mode. */
if (use_gnu_debug_info_extensions)
- {
- /* Output leading class/struct qualifiers. */
- dbxout_class_name_qualifiers (decl);
- }
+ dbxout_class_name_qualifiers (decl);
/* Output typedef name. */
- fprintf (asmfile, "%s:", IDENTIFIER_POINTER (DECL_NAME (decl)));
+ stabstr_I (DECL_NAME (decl));
+ stabstr_C (':');
/* Short cut way to output a tag also. */
if ((TREE_CODE (type) == RECORD_TYPE
{
if (use_gnu_debug_info_extensions && have_used_extensions)
{
- putc ('T', asmfile);
+ stabstr_C ('T');
TREE_ASM_WRITTEN (TYPE_NAME (type)) = 1;
}
-#if 0 /* Now we generate the tag for this case up above. */
- else
- tag_needed = 1;
-#endif
}
- putc ('t', asmfile);
- current_sym_code = DBX_TYPE_DECL_STABS_CODE;
-
+ stabstr_C ('t');
dbxout_type (type, 1);
- dbxout_finish_symbol (decl);
+ dbxout_finish_complex_stabs (decl, DBX_TYPE_DECL_STABS_CODE,
+ 0, 0, 0);
did_output = 1;
}
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. */
break;
/* If the variable is really a constant
- and not written in memory, inform the debugger. */
+ and not written in memory, inform the debugger.
+
+ ??? Why do we skip emitting the type and location in this case? */
if (TREE_STATIC (decl) && TREE_READONLY (decl)
&& DECL_INITIAL (decl) != 0
&& host_integerp (DECL_INITIAL (decl), 0)
&& ! TREE_ASM_WRITTEN (decl)
&& (DECL_CONTEXT (decl) == NULL_TREE
- || TREE_CODE (DECL_CONTEXT (decl)) == BLOCK))
+ || TREE_CODE (DECL_CONTEXT (decl)) == BLOCK)
+ && TREE_PUBLIC (decl) == 0)
{
- if (TREE_PUBLIC (decl) == 0)
- {
- /* The sun4 assembler does not grok this. */
- const char *name = IDENTIFIER_POINTER (DECL_NAME (decl));
+ /* 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 ();
+ stabstr_I (DECL_NAME (decl));
+ stabstr_S (":c=i");
+ stabstr_D (ival);
+ dbxout_finish_complex_stabs (0, N_LSYM, 0, 0, 0);
+ DBXOUT_DECR_NESTING;
+ return 1;
}
- /* else it is something we handle like a normal variable. */
+ else
+ break;
}
+ /* else it is something we handle like a normal variable. */
SET_DECL_RTL (decl, eliminate_regs (DECL_RTL (decl), 0, NULL_RTX));
#ifdef LEAF_REG_REMAP
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.
while (GET_CODE (value) == SUBREG)
value = SUBREG_REG (value);
- if (GET_CODE (value) == REG)
+ if (REG_P (value))
{
if (REGNO (value) >= FIRST_PSEUDO_REGISTER)
return 0;
}
home = alter_subreg (&home);
}
- if (GET_CODE (home) == REG)
+ if (REG_P (home))
{
regno = REGNO (home);
if (regno >= FIRST_PSEUDO_REGISTER)
no letter at all, and N_LSYM, for auto variable,
r and N_RSYM for register variable. */
- if (GET_CODE (home) == MEM
- && GET_CODE (XEXP (home, 0)) == SYMBOL_REF)
+ if (MEM_P (home) && GET_CODE (XEXP (home, 0)) == SYMBOL_REF)
{
if (TREE_PUBLIC (decl))
{
letter = 'G';
- current_sym_code = N_GSYM;
+ code = N_GSYM;
}
else
{
- current_sym_addr = XEXP (home, 0);
+ addr = XEXP (home, 0);
letter = decl_function_context (decl) ? 'V' : 'S';
+ /* Some ports can transform a symbol ref into a label ref,
+ because the symbol ref is too far away and has to be
+ dumped into a constant pool. Alternatively, the symbol
+ in the constant pool might be referenced by a different
+ symbol. */
+ if (GET_CODE (addr) == SYMBOL_REF
+ && CONSTANT_POOL_ADDRESS_P (addr))
+ {
+ bool marked;
+ rtx tmp = get_pool_constant_mark (addr, &marked);
+
+ if (GET_CODE (tmp) == SYMBOL_REF)
+ {
+ addr = tmp;
+ if (CONSTANT_POOL_ADDRESS_P (addr))
+ get_pool_constant_mark (addr, &marked);
+ else
+ marked = true;
+ }
+ else if (GET_CODE (tmp) == LABEL_REF)
+ {
+ addr = tmp;
+ marked = true;
+ }
+
+ /* If all references to the constant pool were optimized
+ out, we just ignore the symbol. */
+ if (!marked)
+ return 0;
+ }
+
/* This should be the same condition as in assemble_variable, but
we don't have access to dont_output_data here. So, instead,
we rely on the fact that error_mark_node initializers always
if (DECL_INITIAL (decl) == 0
|| (!strcmp (lang_hooks.name, "GNU C++")
&& DECL_INITIAL (decl) == error_mark_node))
- current_sym_code = N_LCSYM;
+ code = N_LCSYM;
else if (DECL_IN_TEXT_SECTION (decl))
/* This is not quite right, but it's the closest
of all the codes that Unix defines. */
- current_sym_code = DBX_STATIC_CONST_VAR_CODE;
+ code = DBX_STATIC_CONST_VAR_CODE;
else
{
- /* Some ports can transform a symbol ref into a label ref,
- because the symbol ref is too far away and has to be
- dumped into a constant pool. Alternatively, the symbol
- in the constant pool might be referenced by a different
- symbol. */
- if (GET_CODE (current_sym_addr) == SYMBOL_REF
- && CONSTANT_POOL_ADDRESS_P (current_sym_addr))
- {
- rtx tmp = get_pool_constant (current_sym_addr);
-
- if (GET_CODE (tmp) == SYMBOL_REF
- || GET_CODE (tmp) == LABEL_REF)
- current_sym_addr = tmp;
- }
-
/* Ultrix `as' seems to need this. */
#ifdef DBX_STATIC_STAB_DATA_SECTION
data_section ();
#endif
- current_sym_code = N_STSYM;
+ code = N_STSYM;
}
}
}
else if (regno >= 0)
{
letter = 'r';
- current_sym_code = N_RSYM;
- current_sym_value = DBX_REGISTER_NUMBER (regno);
+ code = N_RSYM;
+ number = DBX_REGISTER_NUMBER (regno);
}
- else if (GET_CODE (home) == MEM
- && (GET_CODE (XEXP (home, 0)) == MEM
- || (GET_CODE (XEXP (home, 0)) == REG
+ else if (MEM_P (home)
+ && (MEM_P (XEXP (home, 0))
+ || (REG_P (XEXP (home, 0))
&& REGNO (XEXP (home, 0)) != HARD_FRAME_POINTER_REGNUM
&& REGNO (XEXP (home, 0)) != STACK_POINTER_REGNUM
#if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
then it means the object is variable-sized and address through
that register or stack slot. DBX has no way to represent this
so all we can do is output the variable as a pointer.
- If it's not a parameter, ignore it.
- (VAR_DECLs like this can be made by integrate.c.) */
+ If it's not a parameter, ignore it. */
{
- if (GET_CODE (XEXP (home, 0)) == REG)
+ if (REG_P (XEXP (home, 0)))
{
letter = 'r';
- current_sym_code = N_RSYM;
+ code = N_RSYM;
if (REGNO (XEXP (home, 0)) >= FIRST_PSEUDO_REGISTER)
return 0;
- current_sym_value = DBX_REGISTER_NUMBER (REGNO (XEXP (home, 0)));
+ number = DBX_REGISTER_NUMBER (REGNO (XEXP (home, 0)));
}
else
{
- current_sym_code = N_LSYM;
+ code = N_LSYM;
/* RTL looks like (MEM (MEM (PLUS (REG...) (CONST_INT...)))).
We want the value of that CONST_INT. */
- current_sym_value
- = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home, 0), 0));
+ number = DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home, 0), 0));
}
/* Effectively do build_pointer_type, but don't cache this type,
type = make_node (POINTER_TYPE);
TREE_TYPE (type) = TREE_TYPE (decl);
}
- else if (GET_CODE (home) == MEM
- && GET_CODE (XEXP (home, 0)) == REG)
+ else if (MEM_P (home)
+ && REG_P (XEXP (home, 0)))
{
- current_sym_code = N_LSYM;
- current_sym_value = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
+ code = N_LSYM;
+ number = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
}
- else if (GET_CODE (home) == MEM
+ else if (MEM_P (home)
&& GET_CODE (XEXP (home, 0)) == PLUS
&& GET_CODE (XEXP (XEXP (home, 0), 1)) == CONST_INT)
{
- current_sym_code = N_LSYM;
+ code = N_LSYM;
/* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
We want the value of that CONST_INT. */
- current_sym_value = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
+ number = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
}
- else if (GET_CODE (home) == MEM
+ else if (MEM_P (home)
&& GET_CODE (XEXP (home, 0)) == CONST)
{
/* Handle an obscure case which can arise when optimizing and
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))
- if (DECL_NAME (parms) && TREE_TYPE (parms) != error_mark_node)
+ if (DECL_NAME (parms)
+ && TREE_TYPE (parms) != error_mark_node
+ && DECL_RTL_SET_P (parms)
+ && DECL_INCOMING_RTL (parms))
{
- dbxout_prepare_symbol (parms);
+ tree eff_type;
+ char letter;
+ STAB_CODE_TYPE code;
+ int number;
/* Perform any necessary register eliminations on the parameter's rtl,
so that the debugging output will be accurate. */
if (PARM_PASSED_IN_MEMORY (parms))
{
- rtx addr = XEXP (DECL_INCOMING_RTL (parms), 0);
+ rtx inrtl = XEXP (DECL_INCOMING_RTL (parms), 0);
/* ??? Here we assume that the parm address is indexed
off the frame pointer or arg pointer.
If that is not true, we produce meaningless results,
but do not crash. */
- if (GET_CODE (addr) == PLUS
- && GET_CODE (XEXP (addr, 1)) == CONST_INT)
- current_sym_value = INTVAL (XEXP (addr, 1));
- else
- current_sym_value = 0;
-
- current_sym_code = N_PSYM;
- current_sym_addr = 0;
-
- FORCE_TEXT;
- if (DECL_NAME (parms))
- {
- current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (parms));
-
- fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
- IDENTIFIER_POINTER (DECL_NAME (parms)),
- DBX_MEMPARM_STABS_LETTER);
- }
+ if (GET_CODE (inrtl) == PLUS
+ && GET_CODE (XEXP (inrtl, 1)) == CONST_INT)
+ number = INTVAL (XEXP (inrtl, 1));
else
- {
- current_sym_nchars = 8;
- fprintf (asmfile, "%s\"(anon):%c", ASM_STABS_OP,
- DBX_MEMPARM_STABS_LETTER);
- }
-
- /* It is quite tempting to use:
-
- dbxout_type (TREE_TYPE (parms), 0);
-
- as the next statement, rather than using DECL_ARG_TYPE(), so
- that gcc reports the actual type of the parameter, rather
- than the promoted type. This certainly makes GDB's life
- easier, at least for some ports. The change is a bad idea
- however, since GDB expects to be able access the type without
- performing any conversions. So for example, if we were
- passing a float to an unprototyped function, gcc will store a
- double on the stack, but if we emit a stab saying the type is a
- float, then gdb will only read in a single value, and this will
- produce an erroneous value. */
- dbxout_type (DECL_ARG_TYPE (parms), 0);
- current_sym_value = DEBUGGER_ARG_OFFSET (current_sym_value, addr);
- dbxout_finish_symbol (parms);
+ number = 0;
+
+ code = N_PSYM;
+ number = DEBUGGER_ARG_OFFSET (number, inrtl);
+ letter = 'p';
+
+ /* It is quite tempting to use TREE_TYPE (parms) instead
+ of DECL_ARG_TYPE (parms) for the eff_type, so that gcc
+ reports the actual type of the parameter, rather than
+ the promoted type. This certainly makes GDB's life
+ easier, at least for some ports. The change is a bad
+ idea however, since GDB expects to be able access the
+ type without performing any conversions. So for
+ example, if we were passing a float to an unprototyped
+ function, gcc will store a double on the stack, but if
+ we emit a stab saying the type is a float, then gdb
+ will only read in a single value, and this will produce
+ an erroneous value. */
+ eff_type = DECL_ARG_TYPE (parms);
}
- else if (GET_CODE (DECL_RTL (parms)) == REG)
+ else if (REG_P (DECL_RTL (parms)))
{
rtx best_rtl;
- char regparm_letter;
- tree parm_type;
- /* Parm passed in registers and lives in registers or nowhere. */
-
- current_sym_code = DBX_REGPARM_STABS_CODE;
- regparm_letter = DBX_REGPARM_STABS_LETTER;
- current_sym_addr = 0;
-
- /* If parm lives in a register, use that register;
- pretend the parm was passed there. It would be more consistent
- to describe the register where the parm was passed,
- but in practice that register usually holds something else.
- If we use DECL_RTL, then we must use the declared type of
- the variable, not the type that it arrived in. */
+ /* Parm passed in registers and lives in registers or nowhere. */
+ code = DBX_REGPARM_STABS_CODE;
+ letter = DBX_REGPARM_STABS_LETTER;
+
+ /* For parms passed in registers, it is better to use the
+ declared type of the variable, not the type it arrived in. */
+ eff_type = TREE_TYPE (parms);
+
+ /* If parm lives in a register, use that register; pretend
+ the parm was passed there. It would be more consistent
+ to describe the register where the parm was passed, but
+ in practice that register usually holds something else.
+ If the parm lives nowhere, use the register where it
+ was passed. */
if (REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
- {
- best_rtl = DECL_RTL (parms);
- parm_type = TREE_TYPE (parms);
- }
- /* If the parm lives nowhere, use the register where it was
- passed. It is also better to use the declared type here. */
- else
- {
- best_rtl = DECL_INCOMING_RTL (parms);
- parm_type = TREE_TYPE (parms);
- }
- current_sym_value = DBX_REGISTER_NUMBER (REGNO (best_rtl));
-
- FORCE_TEXT;
- if (DECL_NAME (parms))
- {
- current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (parms));
- fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
- IDENTIFIER_POINTER (DECL_NAME (parms)),
- regparm_letter);
- }
+ best_rtl = DECL_RTL (parms);
else
- {
- current_sym_nchars = 8;
- fprintf (asmfile, "%s\"(anon):%c", ASM_STABS_OP,
- regparm_letter);
- }
+ best_rtl = DECL_INCOMING_RTL (parms);
- dbxout_type (parm_type, 0);
- dbxout_finish_symbol (parms);
+ number = DBX_REGISTER_NUMBER (REGNO (best_rtl));
}
- else if (GET_CODE (DECL_RTL (parms)) == MEM
- && GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG
+ else if (MEM_P (DECL_RTL (parms))
+ && REG_P (XEXP (DECL_RTL (parms), 0))
&& REGNO (XEXP (DECL_RTL (parms), 0)) != HARD_FRAME_POINTER_REGNUM
&& REGNO (XEXP (DECL_RTL (parms), 0)) != STACK_POINTER_REGNUM
#if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
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;
-
- FORCE_TEXT;
- if (DECL_NAME (parms))
- {
- current_sym_nchars
- = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms)));
+ it was passed instead.
+ ??? Why is DBX_REGISTER_NUMBER not used here? */
- fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
- IDENTIFIER_POINTER (DECL_NAME (parms)),
- regparm_letter);
- }
+ if (REGNO (XEXP (DECL_RTL (parms), 0)) < FIRST_PSEUDO_REGISTER)
+ number = REGNO (XEXP (DECL_RTL (parms), 0));
else
- {
- current_sym_nchars = 8;
- fprintf (asmfile, "%s\"(anon):%c", ASM_STABS_OP,
- regparm_letter);
- }
-
- dbxout_type (TREE_TYPE (parms), 0);
- dbxout_finish_symbol (parms);
+ number = REGNO (DECL_INCOMING_RTL (parms));
}
- else if (GET_CODE (DECL_RTL (parms)) == MEM
- && GET_CODE (XEXP (DECL_RTL (parms), 0)) == MEM)
+ else if (MEM_P (DECL_RTL (parms))
+ && MEM_P (XEXP (DECL_RTL (parms), 0)))
{
/* Parm was passed via invisible reference, with the reference
living on the stack. DECL_RTL looks like
(MEM (MEM (PLUS (REG ...) (CONST_INT ...)))) or it
could look like (MEM (MEM (REG))). */
- const char *const decl_name = (DECL_NAME (parms)
- ? IDENTIFIER_POINTER (DECL_NAME (parms))
- : "(anon)");
- if (GET_CODE (XEXP (XEXP (DECL_RTL (parms), 0), 0)) == REG)
- current_sym_value = 0;
+
+ code = N_PSYM;
+ letter = 'v';
+ eff_type = TREE_TYPE (parms);
+
+ if (!REG_P (XEXP (XEXP (DECL_RTL (parms), 0), 0)))
+ number = INTVAL (XEXP (XEXP (XEXP (DECL_RTL (parms), 0), 0), 1));
else
- current_sym_value
- = INTVAL (XEXP (XEXP (XEXP (DECL_RTL (parms), 0), 0), 1));
- current_sym_addr = 0;
- current_sym_code = N_PSYM;
-
- FORCE_TEXT;
- fprintf (asmfile, "%s\"%s:v", ASM_STABS_OP, decl_name);
-
- current_sym_value
- = DEBUGGER_ARG_OFFSET (current_sym_value,
- XEXP (XEXP (DECL_RTL (parms), 0), 0));
- dbxout_type (TREE_TYPE (parms), 0);
- dbxout_finish_symbol (parms);
+ number = 0;
+
+ number = DEBUGGER_ARG_OFFSET (number,
+ XEXP (XEXP (DECL_RTL (parms), 0), 0));
}
- else if (GET_CODE (DECL_RTL (parms)) == MEM
+ else if (MEM_P (DECL_RTL (parms))
&& XEXP (DECL_RTL (parms), 0) != const0_rtx
/* ??? A constant address for a parm can happen
when the reg it lives in is equiv to a constant in memory.
{
/* Parm was passed in registers but lives on the stack. */
- current_sym_code = N_PSYM;
+ code = N_PSYM;
+ letter = 'p';
+ eff_type = TREE_TYPE (parms);
+
/* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
in which case we want the value of that CONST_INT,
or (MEM (REG ...)),
in which case we use a value of zero. */
- if (GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG)
- current_sym_value = 0;
+ if (!REG_P (XEXP (DECL_RTL (parms), 0)))
+ number = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1));
else
- current_sym_value
- = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1));
-
- current_sym_addr = 0;
+ number = 0;
/* Make a big endian correction if the mode of the type of the
parameter is not the same as the mode of the rtl. */
if (BYTES_BIG_ENDIAN
&& TYPE_MODE (TREE_TYPE (parms)) != GET_MODE (DECL_RTL (parms))
&& GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms))) < UNITS_PER_WORD)
- {
- current_sym_value +=
- GET_MODE_SIZE (GET_MODE (DECL_RTL (parms)))
- - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms)));
- }
-
- FORCE_TEXT;
- if (DECL_NAME (parms))
- {
- current_sym_nchars
- = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms)));
-
- fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
- IDENTIFIER_POINTER (DECL_NAME (parms)),
- DBX_MEMPARM_STABS_LETTER);
- }
- else
- {
- current_sym_nchars = 8;
- fprintf (asmfile, "%s\"(anon):%c", ASM_STABS_OP,
- DBX_MEMPARM_STABS_LETTER);
- }
+ number += (GET_MODE_SIZE (GET_MODE (DECL_RTL (parms)))
+ - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms))));
+ }
+ else
+ /* ??? We don't know how to represent this argument. */
+ continue;
- current_sym_value
- = DEBUGGER_ARG_OFFSET (current_sym_value,
- XEXP (DECL_RTL (parms), 0));
- dbxout_type (TREE_TYPE (parms), 0);
- dbxout_finish_symbol (parms);
+ dbxout_begin_complex_stabs ();
+
+ if (DECL_NAME (parms))
+ {
+ stabstr_I (DECL_NAME (parms));
+ stabstr_C (':');
}
+ else
+ stabstr_S ("(anon):");
+ stabstr_C (letter);
+ dbxout_type (eff_type, 0);
+ dbxout_finish_complex_stabs (parms, code, 0, 0, number);
}
DBXOUT_DECR_NESTING;
}
for (; parms; parms = TREE_CHAIN (parms))
if (DECL_NAME (parms) && PARM_PASSED_IN_MEMORY (parms))
{
- dbxout_prepare_symbol (parms);
-
/* Report parms that live in registers during the function
but were passed in memory. */
- if (GET_CODE (DECL_RTL (parms)) == REG
+ if (REG_P (DECL_RTL (parms))
&& REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
dbxout_symbol_location (parms, TREE_TYPE (parms),
0, DECL_RTL (parms));
dbxout_symbol_location (parms, TREE_TYPE (parms),
0, DECL_RTL (parms));
/* Report parms that live in memory but not where they were passed. */
- else if (GET_CODE (DECL_RTL (parms)) == MEM
+ else if (MEM_P (DECL_RTL (parms))
&& ! rtx_equal_p (DECL_RTL (parms), DECL_INCOMING_RTL (parms)))
dbxout_symbol_location (parms, TREE_TYPE (parms),
0, DECL_RTL (parms));
{
while (args)
{
- putc (',', asmfile);
+ stabstr_C (',');
dbxout_type (TREE_VALUE (args), 0);
- CHARS (1);
args = TREE_CHAIN (args);
}
}
\f
+/* Subroutine of dbxout_block. Emit an N_LBRAC stab referencing LABEL.
+ BEGIN_LABEL is the name of the beginning of the function, which may
+ be required. */
+static void
+dbx_output_lbrac (const char *label,
+ const char *begin_label ATTRIBUTE_UNUSED)
+{
+#ifdef DBX_OUTPUT_LBRAC
+ DBX_OUTPUT_LBRAC (asm_out_file, label);
+#else
+ dbxout_begin_stabn (N_LBRAC);
+ if (DBX_BLOCKS_FUNCTION_RELATIVE)
+ dbxout_stab_value_label_diff (label, begin_label);
+ else
+ dbxout_stab_value_label (label);
+#endif
+}
+
+/* Subroutine of dbxout_block. Emit an N_RBRAC stab referencing LABEL.
+ BEGIN_LABEL is the name of the beginning of the function, which may
+ be required. */
+static void
+dbx_output_rbrac (const char *label,
+ const char *begin_label ATTRIBUTE_UNUSED)
+{
+#ifdef DBX_OUTPUT_RBRAC
+ DBX_OUTPUT_RBRAC (asm_out_file, label);
+#else
+ dbxout_begin_stabn (N_RBRAC);
+ if (DBX_BLOCKS_FUNCTION_RELATIVE)
+ dbxout_stab_value_label_diff (label, begin_label);
+ else
+ dbxout_stab_value_label (label);
+#endif
+}
+
/* Output everything about a symbol block (a BLOCK node
that represents a scope level),
including recursive output of contained blocks.
static void
dbxout_block (tree block, int depth, tree args)
{
- int blocknum = -1;
-
-#if DBX_BLOCKS_FUNCTION_RELATIVE
- const char *begin_label;
- if (current_function_func_begin_label != NULL_TREE)
- begin_label = IDENTIFIER_POINTER (current_function_func_begin_label);
- else
- begin_label = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0);
-#endif
+ const char *begin_label
+ = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0);
while (block)
{
if (TREE_USED (block) && TREE_ASM_WRITTEN (block))
{
int did_output;
+ int blocknum = BLOCK_NUMBER (block);
/* In dbx format, the syms of a block come before the N_LBRAC.
If nothing is output, we don't need the N_LBRAC, either. */
the block. Use the block's tree-walk order to generate
the assembler symbols LBBn and LBEn
that final will define around the code in this block. */
- if (depth > 0 && did_output)
+ if (did_output)
{
char buf[20];
- blocknum = BLOCK_NUMBER (block);
- ASM_GENERATE_INTERNAL_LABEL (buf, "LBB", blocknum);
+ const char *scope_start;
+
+ if (depth == 0)
+ /* The outermost block doesn't get LBB labels; use
+ the function symbol. */
+ scope_start = begin_label;
+ else
+ {
+ ASM_GENERATE_INTERNAL_LABEL (buf, "LBB", blocknum);
+ scope_start = buf;
+ }
if (BLOCK_HANDLER_BLOCK (block))
{
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, buf);
- 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);
}
}
-
-#ifdef DBX_OUTPUT_LBRAC
- DBX_OUTPUT_LBRAC (asmfile, buf);
-#else
- fprintf (asmfile, "%s%d,0,0,", ASM_STABN_OP, N_LBRAC);
- assemble_name (asmfile, buf);
-#if DBX_BLOCKS_FUNCTION_RELATIVE
- putc ('-', asmfile);
- assemble_name (asmfile, begin_label);
-#endif
- fprintf (asmfile, "\n");
-#endif
+ dbx_output_lbrac (scope_start, begin_label);
}
/* Output the subblocks. */
dbxout_block (BLOCK_SUBBLOCKS (block), depth + 1, NULL_TREE);
/* Refer to the marker for the end of the block. */
- if (depth > 0 && did_output)
+ if (did_output)
{
- char buf[20];
- ASM_GENERATE_INTERNAL_LABEL (buf, "LBE", blocknum);
-#ifdef DBX_OUTPUT_RBRAC
- DBX_OUTPUT_RBRAC (asmfile, buf);
-#else
- fprintf (asmfile, "%s%d,0,0,", ASM_STABN_OP, N_RBRAC);
- assemble_name (asmfile, buf);
-#if DBX_BLOCKS_FUNCTION_RELATIVE
- putc ('-', asmfile);
- assemble_name (asmfile, begin_label);
-#endif
- fprintf (asmfile, "\n");
-#endif
+ char buf[100];
+ if (depth == 0)
+ /* The outermost block doesn't get LBE labels;
+ use the "scope" label which will be emitted
+ by dbxout_function_end. */
+ ASM_GENERATE_INTERNAL_LABEL (buf, "Lscope", scope_labelno);
+ else
+ ASM_GENERATE_INTERNAL_LABEL (buf, "LBE", blocknum);
+
+ dbx_output_rbrac (buf, begin_label);
}
}
block = BLOCK_CHAIN (block);
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)
{
OSDN Git Service
