* RFC Speed up dbxout.c a bit
@ 2004-10-14 9:12 Zack Weinberg
2004-10-14 9:32 ` Richard Earnshaw
` (3 more replies)
0 siblings, 4 replies; 9+ messages in thread
From: Zack Weinberg @ 2004-10-14 9:12 UTC (permalink / raw)
To: gcc-patches
[-- Attachment #1: Type: text/plain, Size: 1785 bytes --]
This patch restructures dbxout.c not to use printf under any
circumstances. It also overhauls the handling of continued stabs
strings -- formerly each place that emitted part of a string would
keep count of how many characters had been emitted, and at designated
'continuation points' the line would be split if there were too
many. This meant that DBX_CONTIN_LENGTH had to be viewed as more of a
guideline than an upper limit; there are several target headers which
complain about not being able to use the correct value. Also, this
structure forced the subsequent parameters to the .stabs directive to
be carried around in global variables.
Now we build the .stabs string in an obstack and break it up into
appropriately-sized chunks when it's done. This means that
DBX_CONTIN_LENGTH is now accurate, and the globals go away. Note that
the obstack is used even when there is no limit on the length of a
.stabs string. This is because it would take more #ifdefs to write
straight to stdio in that case. Also, strange but true, writing
straight to stdio is slower. Yes, I profiled it.
On powerpc-darwin, I see 1.5-2.5% improvement in user and wall time
from this patch (--disable-checking configuration). The patch
produces no regressions in the GCC test suite on powerpc-darwin or
i686-linux. In addition, on i686-linux there are no regressions in
the GDB testsuite either in default mode (DWARF) or with
--target_board=unix/gdb:debug_flags=-gstabs+ (forces use of stabs).
dbxout.c has a lot of tentacles into the target headers; I would
appreciate review of those changes by target maintainers. There is a
bit more refactoring in here than is strictly necessary, and I suspect
I haven't updated all the relevant bits of the documentation.
Comments appreciated.
zw
[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #2: Type: text/x-patch, Size: 124180 bytes --]
* dbxout.c: Include obstack.h. Remove unnecessary #undefs.
(asmfile): Globally replace with asm_out_file; delete
definition and assignments.
(ASM_STABS_OP, ASM_STABN_OP): Default definition moved to defaults.h.
(NO_DBX_MAIN_SOURCE_DIRECTORY, DBX_FINISH_STABS, DBX_OUTPUT_NFUN)
(DBX_MAIN_SOURCE_FILE_DESC_VALUE, DBX_BLOCKS_FUNCTION_RELATIVE)
(DBX_LINES_FUNCTION_RELATIVE, DBX_CONTIN_LENGTH, DBX_CONTIN_CHAR)
(DBX_OUTPUT_MAIN_SOURCE_FILE, DBX_OUTPUT_GCC_MARKER)
(DBX_OUTPUT_MAIN_SOURCE_FILE_END)
Provide default definition; use unconditionally, not with #ifdef.
(current_sym_code, current_sym_value, current_sym_addr)
(current_sym_nchars, CHARS, CONTIN, dbxout_continue)
(STABS_GCC_MARKER, print_int_cst_octal, print_octal)
(print_wide_int, dbxout_prepare_symbol, dbxout_finish_symbol): Delete.
(stabstr_ob): New file-scope variable.
(NUMBER_FMT_LOOP, stabstr_C, stabstr_S, stabstr_I)
(DECL_ACCESSIBILITY_CHAR): New macros.
(dbxout_int, dbxout_stab_value_zero, dbxout_stab_value_label)
(dbxout_stab_value_label_diff, dbxout_stab_value_internal_label)
(dbxout_stab_value_internal_label_diff, dbxout_stabd)
(dbxout_begin_stabn, dbxout_begin_stabn_nodesc)
(dbxout_begin_empty_stabs, dbxout_begin_simple_stabs)
(dbxout_begin_simple_stabs_nodesc, dbxout_begin_complex_stabs)
(stabstr_D, stabstr_U, stabstr_O, dbxout_finish_complex_stabs)
(dbx_output_null_n_so_at_main_source_file_end): New functions.
(dbxout_init): Initialize stabstr_ob. Only emit .Ltext label
if it's used.
(dbxout_function_decl): Don't use DBX_OUTPUT_FUNCTION_END.
(dbxout_type_method_1): Remove second argument which was
always DECL_ASSEMBLER_NAME (decl).
(get_lang_number): Tag with ATTRIBUTE_UNUSED.
(dbxout_function_end, dbxout_init, emit_bincl_stab)
(dbxout_end_source_file, dbxout_source_file, dbxout_type_index)
(dbxout_begin_prologue, dbxout_source_line, dbxout_finish)
(dbxout_type_fields, dbxout_type_method_1, dbxout_type_methods)
(dbxout_range_type, dbxout_type, dbxout_type_name)
(dbxout_class_name_qualifiers, dbxout_symbol, dbxout_symbol_location)
(dbxout_symbol_name, dbxout_parms, dbxout_reg_parms, dbxout_args)
(dbx_output_lbrac, dbx_output_rbrac, dbxout_block):
Use new functions and macros.
* defaults.h (ASM_STABS_OP, ASM_STABN_OP): Default-define here.
* output.h: Prototype new dbxout_* functions.
* system.h: Poison DBX_OUTPUT_FUNCTION_END,
DBX_OUTPUT_MAIN_SOURCE_FILENAME, and STABS_GCC_MARKER.
* varasm.c: No need to default-define ASM_STABS_OP.
(default_stabs_asm_out_constructor)
(default_stabs_asm_out_destructor): Use new dbxout.c functions
instead of emitting the .stabs directive by hand. Call sorry()
if DBX_DEBUGGING_INFO and XCOFF_DEBUGGING_INFO are not defined.
* xcoffout.h (ASM_STABS_OP, DBX_OUTPUT_MAIN_SOURCE_FILE_DIRECTORY):
Don't define.
(NO_DBX_MAIN_SOURCE_DIRECTORY): Define.
(DBX_FINISH_SYMBOL): Rename to DBX_FINISH_STABS and restructure.
(DBX_OUTPUT_MAIN_SOURCE_FILENAME): Rename DBX_OUTPUT_MAIN_SOURCE_FILE.
(DBX_OUTPUT_MAIN_SOURCE_FILE_END): FILE argument removed.
(DBX_OUTPUT_GCC_MARKER): Likewise. Don't use STABS_GCC_MARKER.
* config/darwin.h, config/dbxcoff.h, config/dbxelf.h, config/ptx4.h
* config/h8300/coff.h, config/mcore/mcore-pe.h, config/pa/som.h
* config/sh/elf.h
If appropriate, define DBX_OUTPUT_NULL_N_SO_AT_MAIN_SOURCE_FILE_END
instead of overriding definition of DBX_OUTPUT_MAIN_SOURCE_FILE_END.
If appropriate, define DBX_LINES_FUNCTION_RELATIVE instead of
overriding definition of ASM_OUTPUT_SOURCE_LINE.
Remove unncessary #undefs.
* config/alpha/alpha.c (alpha_output_filename)
* config/m32r/m32r.h (ASM_OUTPUT_SOURCE_LINE)
* config/rs6000/linux64.h (ASM_OUTPUT_SOURCE_LINE, DBX_OUTPUT_BRAC)
(DBX_OUTPUT_NFUN): Use new dbxout.c functions.
* config/arm/aout.h: Define DBX_MAIN_SOURCE_FILENAME_DESC_VALUE
instead of overriding DBX_OUTPUT_MAIN_SOURCE_FILENAME.
* config/c4x/c4x.h, config/pa/pa.h: Remove unnecessary definition
of ASM_STABS_OP and/or ASM_STABN_OP (identical with default).
* config/rs6000/linux64.h: Do not use
current_function_func_begin_label for stabs.
* config/vax/elf.h: Don't define DBX_OUTPUT_FUNCTION_END.
* doc/tm.texi: Update documentation of modified macros.
===================================================================
Index: dbxout.c
--- dbxout.c 6 Oct 2004 22:13:14 -0000 1.205
+++ dbxout.c 14 Oct 2004 08:18:54 -0000
@@ -88,28 +88,19 @@ Software Foundation, 59 Temple Place - S
#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"
-#endif
-
-#ifndef ASM_STABN_OP
-#define ASM_STABN_OP "\t.stabn\t"
-#endif
-
#ifndef DBX_TYPE_DECL_STABS_CODE
#define DBX_TYPE_DECL_STABS_CODE N_LSYM
#endif
@@ -139,13 +130,6 @@ Software Foundation, 59 Temple Place - S
#define FILE_NAME_JOINER "/"
#endif
-/* GDB needs to know that the stabs were generated by GCC. We emit an
- N_OPT stab at the beginning of the source file to indicate this.
- The string is historical, and different on a very few targets. */
-#ifndef STABS_GCC_MARKER
-#define STABS_GCC_MARKER "gcc2_compiled."
-#endif
-
#ifndef NO_DBX_FUNCTION_END
#define NO_DBX_FUNCTION_END 0
#endif
@@ -154,6 +138,30 @@ Software Foundation, 59 Temple Place - S
#define NO_DBX_BNSYM_ENSYM 0
#endif
+#ifndef NO_DBX_MAIN_SOURCE_DIRECTORY
+#define NO_DBX_MAIN_SOURCE_DIRECTORY 0
+#endif
+
+#ifndef DBX_MAIN_SOURCE_FILE_DESC_VALUE
+#define DBX_MAIN_SOURCE_FILE_DESC_VALUE get_lang_number ()
+#endif
+
+#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};
/* Structure recording information about a C data type.
@@ -299,47 +307,14 @@ static const char *cwd;
#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))
+/* 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;
/* 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
-
#ifdef DBX_USE_BINCL
static void emit_bincl_stab (const char *c);
static void emit_pending_bincls (void);
@@ -347,33 +322,23 @@ static void emit_pending_bincls
static inline void emit_pending_bincls_if_required (void);
static void dbxout_init (const char *);
-#ifndef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
-static unsigned int get_lang_number (void);
-#endif
+
static void dbxout_finish (const char *);
static void dbxout_start_source_file (unsigned, const char *);
static void dbxout_end_source_file (unsigned);
static void dbxout_typedefs (tree);
static void dbxout_type_index (tree);
-#if DBX_CONTIN_LENGTH > 0
-static void dbxout_continue (void);
-#endif
static void dbxout_args (tree);
static void dbxout_type_fields (tree);
-static void dbxout_type_method_1 (tree, const char *);
+static void dbxout_type_method_1 (tree);
static void dbxout_type_methods (tree);
static void dbxout_range_type (tree);
static void dbxout_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);
@@ -384,7 +349,7 @@ static void dbxout_handle_pch (unsigned)
static void dbxout_source_line (unsigned int, const char *);
static void dbxout_begin_prologue (unsigned int, const char *);
-static void dbxout_source_file (FILE *, const char *);
+static void dbxout_source_file (const char *);
static void dbxout_function_end (void);
static void dbxout_begin_function (tree);
static void dbxout_begin_block (unsigned, unsigned);
@@ -454,7 +419,449 @@ const struct gcc_debug_hooks xcoff_debug
};
#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);
+}
+
+/* As above, but does not print a desc field. */
+void
+dbxout_begin_stabn_nodesc (int stype)
+{
+ fputs (ASM_STABN_OP, asm_out_file);
+ dbxout_int (stype);
+ fputs (",0,", 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 does not print a desc field. */
+void
+dbxout_begin_simple_stabs_nodesc (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,", 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);
+}
+
+/* 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);
+}
+
+/* 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).
+
+ 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(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 = sym ? DECL_SOURCE_LINE (sym) : 0;
+ size_t len = obstack_object_size (&stabstr_ob);
+ char *str = obstack_finish (&stabstr_ob);
+ char *p = str;
+
+#if DBX_CONTIN_LENGTH != 0
+ /* The +1 is so that we do not get a single-character continued stab
+ (we could have put the single character in the place of the
+ continuation character). */
+ while (len > DBX_CONTIN_LENGTH + 1)
+ {
+ /* The first ASM_STABS_OP was written out by
+ dbxout_begin_complex_stabs. */
+ size_t count = fwrite (p, 1, DBX_CONTIN_LENGTH, asm_out_file);
+ len -= count;
+ p += count;
+
+ /* Must double a backslash. */
+ if (DBX_CONTIN_CHAR == '\\')
+ putc ('\\', asm_out_file);
+ putc (DBX_CONTIN_CHAR, asm_out_file);
+ fputs ("\",", asm_out_file);
+
+ /* Only put SYM's line on the last stab in the sequence. */
+ DBX_FINISH_SYMBOL (0, code, addr, label, number);
+
+ /* We know we're going to need at least one more of these. */
+ fputs (ASM_STABS_OP, asm_out_file);
+ putc ('"', asm_out_file);
+ }
+#endif
+
+ fwrite (p, 1, len, asm_out_file);
+ fputs ("\",", asm_out_file);
+ DBX_FINISH_STABS (code, line, addr, label, number);
+
+ obstack_free (&stabstr_ob, str);
+}
+
#if defined (DBX_DEBUGGING_INFO)
+
+#ifndef DBX_OUTPUT_NFUN
+#define DBX_OUTPUT_NFUN(FILE, LSCOPE, DECL) do { \
+ const char *fnsym = XSTR (XEXP (DECL_RTL (DECL), 0), 0); \
+ dbxout_begin_empty_stabs (N_FUN); \
+ dbxout_stab_value_label_diff (LSCOPE, fnsym); \
+} while (0)
+#endif
+
static void
dbxout_function_end (void)
{
@@ -468,7 +875,7 @@ dbxout_function_end (void)
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,
@@ -481,25 +888,15 @@ dbxout_function_end (void)
/* By convention, GCC will mark the end of a function with an N_FUN
symbol and an empty string. */
-#ifdef DBX_OUTPUT_NFUN
- DBX_OUTPUT_NFUN (asmfile, lscope_label_name, current_function_decl);
-#else
- fprintf (asmfile, "%s\"\",%d,0,0,", ASM_STABS_OP, N_FUN);
- assemble_name (asmfile, lscope_label_name);
- putc ('-', asmfile);
- assemble_name (asmfile, XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0));
- fprintf (asmfile, "\n");
-#endif
+ DBX_OUTPUT_NFUN (asm_out_file, lscope_label_name, current_function_decl);
if (!NO_DBX_BNSYM_ENSYM && !flag_debug_only_used_symbols)
- fprintf (asmfile, "%s%d,0,0\n", ASM_STABD_OP, N_ENSYM);
+ dbxout_stabd (N_ENSYM, 0);
}
#endif /* DBX_DEBUGGING_INFO */
-#ifndef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
/* Get lang description for N_SO stab. */
-
-static unsigned int
+static unsigned int ATTRIBUTE_UNUSED
get_lang_number (void)
{
const char *language_string = lang_hooks.name;
@@ -520,6 +917,22 @@ get_lang_number (void)
return 0;
}
+
+#ifndef DBX_OUTPUT_MAIN_SOURCE_FILE
+#define DBX_OUTPUT_MAIN_SOURCE_FILE(FILENAME) do { \
+ dbxout_begin_simple_stabs_nodesc (FILENAME, N_SO); \
+ dbxout_int (DBX_MAIN_SOURCE_FILE_DESC_VALUE); \
+ putc (',', asm_out_file); \
+ dbxout_stab_value_label (ltext_label_name); \
+ used_ltext_label_name = true; \
+} while (0)
+#endif
+
+#ifndef DBX_OUTPUT_GCC_MARKER
+#define DBX_OUTPUT_GCC_MARKER() do { \
+ dbxout_begin_simple_stabs ("gcc2_compiled.", N_OPT); \
+ dbxout_stab_value_zero (); \
+} while (0)
#endif
/* At the beginning of compilation, start writing the symbol table.
@@ -529,60 +942,46 @@ static void
dbxout_init (const char *input_file_name)
{
char ltext_label_name[100];
+ bool used_ltext_label_name = false;
tree syms = lang_hooks.decls.getdecls ();
- asmfile = asm_out_file;
-
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)
{
-#ifdef DBX_OUTPUT_MAIN_SOURCE_DIRECTORY
- DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (asmfile, cwd);
-#else /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
- fprintf (asmfile, "%s", ASM_STABS_OP);
- output_quoted_string (asmfile, cwd);
- fprintf (asmfile, ",%d,0,%d,", N_SO, get_lang_number ());
- assemble_name (asmfile, ltext_label_name);
- fputc ('\n', asmfile);
-#endif /* no DBX_OUTPUT_MAIN_SOURCE_DIRECTORY */
+ dbxout_begin_simple_stabs_nodesc (cwd, N_SO);
+ dbxout_int (get_lang_number ());
+ putc (',', asm_out_file);
+ dbxout_stab_value_label (ltext_label_name);
+ used_ltext_label_name = true;
}
}
-#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,%d,", N_SO, get_lang_number ());
- 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 */
+ DBX_OUTPUT_MAIN_SOURCE_FILE (input_file_name);
-#ifdef DBX_OUTPUT_GCC_MARKER
- DBX_OUTPUT_GCC_MARKER (asmfile);
-#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);
-#endif
+ if (used_ltext_label_name)
+ {
+ text_section ();
+ targetm.asm_out.internal_label (asm_out_file, "Ltext", 0);
+ }
+
+ DBX_OUTPUT_GCC_MARKER ();
base_input_file = lastfile = input_file_name;
@@ -639,9 +1038,8 @@ dbxout_typedefs (tree syms)
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. */
@@ -723,7 +1121,10 @@ dbxout_end_source_file (unsigned int lin
#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
@@ -758,7 +1159,7 @@ dbxout_handle_pch (unsigned at_end)
/* 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)
{
@@ -768,15 +1169,6 @@ dbxout_source_file (FILE *file, const ch
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. */
@@ -785,8 +1177,9 @@ dbxout_source_file (FILE *file, const ch
if (!in_text_section () && !in_unlikely_text_section ())
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;
}
}
@@ -800,7 +1193,7 @@ dbxout_begin_prologue (unsigned int line
&& !NO_DBX_FUNCTION_END
&& !NO_DBX_BNSYM_ENSYM
&& !flag_debug_only_used_symbols)
- fprintf (asmfile, "%s%d,0,0\n", ASM_STABD_OP, N_BNSYM);
+ dbxout_stabd (N_BNSYM, 0);
dbxout_source_line (lineno, filename);
}
@@ -811,13 +1204,25 @@ dbxout_begin_prologue (unsigned int line
static void
dbxout_source_line (unsigned int lineno, const char *filename)
{
- dbxout_source_file (asmfile, filename);
+ const char *begin_label = XSTR(XEXP(DECL_RTL(current_function_decl), 0), 0);
+
+ dbxout_source_file (filename);
#ifdef ASM_OUTPUT_SOURCE_LINE
dbxout_source_line_counter += 1;
- ASM_OUTPUT_SOURCE_LINE (asmfile, lineno, dbxout_source_line_counter);
+ ASM_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)
+ {
+ dbxout_begin_stabn_nodesc (N_SLINE);
+ dbxout_int (lineno);
+ putc (',', asm_out_file);
+ dbxout_stab_value_internal_label_diff ("LM", &dbxout_source_line_counter,
+ begin_label);
+
+ }
+ else
+ dbxout_stabd (N_SLINE, lineno);
#endif
}
@@ -827,7 +1232,7 @@ static void
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. */
@@ -836,7 +1241,7 @@ static void
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.
@@ -853,9 +1258,6 @@ dbxout_function_decl (tree decl)
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
dbxout_function_end ();
}
@@ -885,17 +1287,35 @@ dbxout_type_decl (tree decl, int local)
dbxout_symbol (decl, local);
}
-/* At the end of compilation, finish writing the symbol table.
- Unless you define DBX_OUTPUT_MAIN_SOURCE_FILE_END, the default is
- to do nothing. */
+/* A common thing to need to do at the end of the main source file is
+ emit an empty N_SO stab. This function does just that. To use it,
+ do not define DBX_OUTPUT_MAIN_SOURCE_FILE_END; instead define
+ DBX_OUTPUT_NULL_N_SO_AT_MAIN_SOURCE_FILE_END (to nothing). */
+#ifndef DBX_OUTPUT_MAIN_SOURCE_FILE_END
+# ifdef DBX_OUTPUT_NULL_N_SO_AT_MAIN_SOURCE_FILE_END
static void
-dbxout_finish (const char *filename ATTRIBUTE_UNUSED)
+dbx_output_null_n_so_at_main_source_file_end (void)
{
-#ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
- DBX_OUTPUT_MAIN_SOURCE_FILE_END (asmfile, filename);
-#endif /* DBX_OUTPUT_MAIN_SOURCE_FILE_END */
+ text_section ();
+ dbxout_begin_empty_stabs (N_SO);
+ dbxout_stab_value_internal_label ("Letext", 0);
+}
+# define DBX_OUTPUT_MAIN_SOURCE_FILE_END(FILENAME) \
+ dbx_output_null_n_so_at_main_source_file_end ()
+# else
+# define DBX_OUTPUT_MAIN_SOURCE_FILE_END(FILENAME) do { } while (0)
+# endif
+#endif
+
+/* 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 other than free the pending symbol queue. */
+static void
+dbxout_finish (const char *filename ATTRIBUTE_UNUSED)
+{
+ DBX_OUTPUT_MAIN_SOURCE_FILE_END (filename);
debug_free_queue ();
}
@@ -905,37 +1325,24 @@ static void
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. */
@@ -968,32 +1375,17 @@ dbxout_type_fields (tree type)
else if (TREE_CODE (tem) != CONST_DECL)
{
- /* Continue the line if necessary,
- but not before the first field. */
- if (tem != TYPE_FIELDS (type))
- CONTIN;
-
if (DECL_NAME (tem))
- {
- fprintf (asmfile, "%s:", IDENTIFIER_POINTER (DECL_NAME (tem)));
- CHARS (2 + IDENTIFIER_LENGTH (DECL_NAME (tem)));
- }
- else
- {
- fprintf (asmfile, ":");
- CHARS (1);
- }
+ stabstr_I (DECL_NAME (tem));
+ stabstr_C (':');
if (use_gnu_debug_info_extensions
&& (TREE_PRIVATE (tem) || TREE_PROTECTED (tem)
|| TREE_CODE (tem) != FIELD_DECL))
{
have_used_extensions = 1;
- putc ('/', asmfile);
- putc ((TREE_PRIVATE (tem) ? '0'
- : TREE_PROTECTED (tem) ? '1' : '2'),
- asmfile);
- CHARS (2);
+ stabstr_C ('/');
+ stabstr_C (DECL_ACCESSIBILITY_CHAR (tem));
}
dbxout_type ((TREE_CODE (tem) == FIELD_DECL
@@ -1007,36 +1399,31 @@ dbxout_type_fields (tree type)
tree name = DECL_ASSEMBLER_NAME (tem);
have_used_extensions = 1;
- fprintf (asmfile, ":%s;", IDENTIFIER_POINTER (name));
- CHARS (IDENTIFIER_LENGTH (name) + 2);
+ stabstr_C (':');
+ stabstr_I (name);
+ stabstr_C (';');
}
else
- {
- /* If TEM is non-static, GDB won't understand it. */
- fprintf (asmfile, ",0,0;");
- CHARS (5);
- }
+ /* If TEM is non-static, GDB won't understand it. */
+ stabstr_S (",0,0;");
}
else
{
- putc (',', asmfile);
- print_wide_int (int_bit_position (tem));
- putc (',', asmfile);
- print_wide_int (tree_low_cst (DECL_SIZE (tem), 1));
- putc (';', asmfile);
- CHARS (3);
+ stabstr_C (',');
+ stabstr_D (int_bit_position (tem));
+ stabstr_C (',');
+ stabstr_D (tree_low_cst (DECL_SIZE (tem), 1));
+ stabstr_C (';');
}
}
}
}
\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;
@@ -1060,20 +1447,21 @@ dbxout_type_method_1 (tree decl, const c
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
@@ -1085,39 +1473,12 @@ dbxout_type_methods (tree type)
{
/* C++: put out the method names and their parameter lists */
tree methods = TYPE_METHODS (type);
- tree type_encoding;
tree fndecl;
tree last;
- char formatted_type_identifier_length[16];
- int type_identifier_length;
if (methods == NULL_TREE)
return;
- type_encoding = DECL_NAME (TYPE_NAME (type));
-
-#if 0
- /* C++: Template classes break some assumptions made by this code about
- the class names, constructor names, and encodings for assembler
- label names. For now, disable output of dbx info for them. */
- {
- const char *ptr = IDENTIFIER_POINTER (type_encoding);
- /* This should use index. (mrs) */
- while (*ptr && *ptr != '<') ptr++;
- if (*ptr != 0)
- {
- static int warned;
- if (!warned)
- warned = 1;
- return;
- }
- }
-#endif
-
- type_identifier_length = IDENTIFIER_LENGTH (type_encoding);
-
- sprintf (formatted_type_identifier_length, "%d", type_identifier_length);
-
if (TREE_CODE (methods) != TREE_VEC)
fndecl = methods;
else if (TREE_VEC_ELT (methods, 0) != NULL_TREE)
@@ -1138,20 +1499,12 @@ dbxout_type_methods (tree type)
well as the name of the field before overloading, along
with its parameter list */
{
- /* This is the "mangled" name of the method.
- It encodes the argument types. */
- const char *debug_name;
-
/* Skip methods that aren't FUNCTION_DECLs. (In C++, these
include TEMPLATE_DECLs.) The debugger doesn't know what
to do with such entities anyhow. */
if (TREE_CODE (fndecl) != FUNCTION_DECL)
continue;
- debug_name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl));
-
- CONTIN;
-
last = fndecl;
/* Also ignore abstract methods; those are only interesting to
@@ -1163,21 +1516,16 @@ dbxout_type_methods (tree type)
expects. */
if (need_prefix)
{
- tree name = DECL_NAME (fndecl);
- fprintf (asmfile, "%s::", IDENTIFIER_POINTER (name));
- CHARS (IDENTIFIER_LENGTH (name) + 2);
+ stabstr_I (DECL_NAME (fndecl));
+ stabstr_S ("::");
need_prefix = 0;
}
dbxout_type (TREE_TYPE (fndecl), 0);
-
- dbxout_type_method_1 (fndecl, debug_name);
+ dbxout_type_method_1 (fndecl);
}
if (!need_prefix)
- {
- putc (';', asmfile);
- CHARS (1);
- }
+ stabstr_C (';');
}
}
@@ -1188,7 +1536,7 @@ dbxout_type_methods (tree type)
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)
@@ -1213,39 +1561,30 @@ dbxout_range_type (tree 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
@@ -1390,9 +1729,7 @@ dbxout_type (tree type, int full)
#endif
/* Output a definition now. */
-
- fprintf (asmfile, "=");
- CHARS (1);
+ stabstr_C ('=');
/* Mark it as defined, so that if it is self-referent
we will not get into an infinite recursion of definitions. */
@@ -1404,15 +1741,13 @@ dbxout_type (tree type, int full)
cv-qualified types if we're using extensions. */
if (TYPE_READONLY (type) > TYPE_READONLY (main_variant))
{
- putc ('k', asmfile);
- CHARS (1);
+ stabstr_C ('k');
dbxout_type (build_type_variant (type, 0, TYPE_VOLATILE (type)), 0);
return;
}
else if (TYPE_VOLATILE (type) > TYPE_VOLATILE (main_variant))
{
- putc ('B', asmfile);
- CHARS (1);
+ stabstr_C ('B');
dbxout_type (build_type_variant (type, TYPE_READONLY (type), 0), 0);
return;
}
@@ -1456,11 +1791,9 @@ dbxout_type (tree type, int full)
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
@@ -1475,8 +1808,9 @@ dbxout_type (tree type, int full)
&& TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
{
have_used_extensions = 1;
- fprintf (asmfile, "@s%d;", TYPE_PRECISION (type));
- CHARS (5);
+ stabstr_S ("@s");
+ stabstr_D (TYPE_PRECISION (type));
+ stabstr_C (';');
}
dbxout_range_type (type);
@@ -1491,14 +1825,14 @@ dbxout_type (tree type, int full)
&& TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
{
have_used_extensions = 1;
- fprintf (asmfile, "@s%d;", TYPE_PRECISION (type));
- CHARS (5);
+ stabstr_S ("@s");
+ stabstr_D (TYPE_PRECISION (type));
+ stabstr_C (';');
}
if (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
@@ -1510,14 +1844,11 @@ dbxout_type (tree type, int full)
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
@@ -1530,35 +1861,28 @@ dbxout_type (tree type, int full)
case REAL_TYPE:
/* This used to say `r1' and we used to take care
to make sure that `int' was type number 1. */
- fprintf (asmfile, "r");
- CHARS (1);
+ stabstr_C ('r');
dbxout_type_index (integer_type_node);
- putc (';', asmfile);
- CHARS (1);
- print_wide_int (int_size_in_bytes (type));
- fputs (";0;", asmfile);
- CHARS (3);
+ stabstr_C (';');
+ stabstr_D (int_size_in_bytes (type));
+ stabstr_S (";0;");
break;
case CHAR_TYPE:
if (use_gnu_debug_info_extensions)
{
have_used_extensions = 1;
- fputs ("@s", asmfile);
- CHARS (2);
- print_wide_int (BITS_PER_UNIT * int_size_in_bytes (type));
- fputs (";-20;", asmfile);
- CHARS (4);
+ stabstr_S ("@s");
+ stabstr_D (BITS_PER_UNIT * int_size_in_bytes (type));
+ stabstr_S (";-20;");
}
else
{
/* Output the type `char' as a subrange of itself.
That is what pcc seems to do. */
- fprintf (asmfile, "r");
- CHARS (1);
+ stabstr_C ('r');
dbxout_type_index (char_type_node);
- fprintf (asmfile, ";0;%d;", TYPE_UNSIGNED (type) ? 255 : 127);
- CHARS (7);
+ stabstr_S (TYPE_UNSIGNED (type) ? ";0;255;" : ";0;127;");
}
break;
@@ -1566,22 +1890,16 @@ dbxout_type (tree type, int full)
if (use_gnu_debug_info_extensions)
{
have_used_extensions = 1;
- fputs ("@s", asmfile);
- CHARS (2);
- print_wide_int (BITS_PER_UNIT * int_size_in_bytes (type));
- fputs (";-16;", asmfile);
- CHARS (4);
+ stabstr_S ("@s");
+ stabstr_D (BITS_PER_UNIT * int_size_in_bytes (type));
+ stabstr_S (";-16;");
}
else /* Define as enumeral type (False, True) */
- {
- fprintf (asmfile, "eFalse:0,True:1,;");
- CHARS (17);
- }
+ stabstr_S ("eFalse:0,True:1,;");
break;
case FILE_TYPE:
- putc ('d', asmfile);
- CHARS (1);
+ stabstr_C ('d');
dbxout_type (TREE_TYPE (type), 0);
break;
@@ -1592,31 +1910,28 @@ dbxout_type (tree type, int full)
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);
+ stabstr_S (",0,");
+ stabstr_D (TYPE_PRECISION (TREE_TYPE (type)));
+ stabstr_S (";imag:");
dbxout_type (TREE_TYPE (type), 0);
- fprintf (asmfile, ",%d,%d;;", TYPE_PRECISION (TREE_TYPE (type)),
- TYPE_PRECISION (TREE_TYPE (type)));
- CHARS (10);
+ stabstr_C (',');
+ stabstr_D (TYPE_PRECISION (TREE_TYPE (type)));
+ stabstr_C (',');
+ stabstr_D (TYPE_PRECISION (TREE_TYPE (type)));
+ stabstr_S (";;");
}
break;
@@ -1624,22 +1939,16 @@ dbxout_type (tree type, int full)
if (use_gnu_debug_info_extensions)
{
have_used_extensions = 1;
- fputs ("@s", asmfile);
- CHARS (2);
- print_wide_int (BITS_PER_UNIT * int_size_in_bytes (type));
- putc (';', asmfile);
- CHARS (1);
+ stabstr_S ("@s");
+ stabstr_D (BITS_PER_UNIT * int_size_in_bytes (type));
+ stabstr_C (';');
/* 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 ("@S;");
}
- putc ('S', asmfile);
- CHARS (1);
+ stabstr_C ('S');
dbxout_type (TYPE_DOMAIN (type), 0);
break;
@@ -1648,11 +1957,9 @@ dbxout_type (tree type, int full)
if (TYPE_PACKED (type) && use_gnu_debug_info_extensions)
{
have_used_extensions = 1;
- fputs ("@s", asmfile);
- CHARS (2);
- print_wide_int (BITS_PER_UNIT * int_size_in_bytes (type));
- fprintf (asmfile, ";@S;S");
- CHARS (5);
+ stabstr_S ("@s");
+ stabstr_D (BITS_PER_UNIT * int_size_in_bytes (type));
+ stabstr_S (";@S;S");
dbxout_type (TYPE_DOMAIN (type), 0);
break;
}
@@ -1666,22 +1973,18 @@ dbxout_type (tree type, int full)
if (TYPE_STRING_FLAG (type) && use_gnu_debug_info_extensions)
{
have_used_extensions = 1;
- fprintf (asmfile, "@S;");
- CHARS (3);
+ stabstr_S ("@S;");
}
tem = TYPE_DOMAIN (type);
if (tem == NULL)
{
- fprintf (asmfile, "ar");
- CHARS (2);
+ stabstr_S ("ar");
dbxout_type_index (integer_type_node);
- fprintf (asmfile, ";0;-1;");
- CHARS (6);
+ stabstr_S (";0;-1;");
}
else
{
- fprintf (asmfile, "a");
- CHARS (1);
+ stabstr_C ('a');
dbxout_range_type (tem);
}
@@ -1711,32 +2014,24 @@ dbxout_type (tree type, int full)
If the type has a name, don't nest its definition within
another type's definition; instead, output an xref
and let the definition come when the name is defined. */
- fputs ((TREE_CODE (type) == RECORD_TYPE) ? "xs" : "xu", asmfile);
- CHARS (2);
-#if 0 /* This assertion is legitimately false in C++. */
- /* We shouldn't be outputting a reference to a type before its
- definition unless the type has a tag name.
- A typedef name without a tag name should be impossible. */
- gcc_assert (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE);
-#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 (binfo)
{
@@ -1749,8 +2044,9 @@ dbxout_type (tree type, int full)
if (BINFO_N_BASE_BINFOS (binfo))
{
have_used_extensions = 1;
- fprintf (asmfile, "!%u,", BINFO_N_BASE_BINFOS (binfo));
- CHARS (8);
+ stabstr_C ('!');
+ stabstr_U (BINFO_N_BASE_BINFOS (binfo));
+ stabstr_C (',');
}
}
for (i = 0; BINFO_BASE_ITERATE (binfo, i, child); i++)
@@ -1761,27 +2057,24 @@ dbxout_type (tree type, int full)
if (use_gnu_debug_info_extensions)
{
have_used_extensions = 1;
- putc (BINFO_VIRTUAL_P (child) ? '1' : '0', asmfile);
- putc (access == access_public_node ? '2' :
- (access == access_protected_node ? '1' :'0'),
- asmfile);
- CHARS (2);
+ stabstr_C (BINFO_VIRTUAL_P (child) ? '1' : '0');
+ stabstr_C (access == access_public_node ? '2' :
+ access == access_protected_node
+ ? '1' :'0');
if (BINFO_VIRTUAL_P (child)
&& strcmp (lang_hooks.name, "GNU C++") == 0)
/* For a virtual base, print the (negative)
offset within the vtable where we must look
to find the necessary adjustment. */
- print_wide_int
+ stabstr_D
(tree_low_cst (BINFO_VPTR_FIELD (child), 0)
* BITS_PER_UNIT);
else
- print_wide_int (tree_low_cst (BINFO_OFFSET (child), 0)
- * BITS_PER_UNIT);
- putc (',', asmfile);
- CHARS (1);
+ stabstr_D (tree_low_cst (BINFO_OFFSET (child), 0)
+ * BITS_PER_UNIT);
+ stabstr_C (',');
dbxout_type (BINFO_TYPE (child), 0);
- putc (';', asmfile);
- CHARS (1);
+ stabstr_C (';');
}
else
{
@@ -1789,20 +2082,16 @@ dbxout_type (tree type, int full)
fields which have the same names at the types
they hold. */
dbxout_type_name (BINFO_TYPE (child));
- putc (':', asmfile);
- CHARS (1);
+ stabstr_C (':');
dbxout_type (BINFO_TYPE (child), full);
- putc (',', asmfile);
- CHARS (1);
- print_wide_int (tree_low_cst (BINFO_OFFSET (child), 0)
- * BITS_PER_UNIT);
- putc (',', asmfile);
- CHARS (1);
- print_wide_int
+ stabstr_C (',');
+ stabstr_D (tree_low_cst (BINFO_OFFSET (child), 0)
+ * BITS_PER_UNIT);
+ stabstr_C (',');
+ stabstr_D
(tree_low_cst (TYPE_SIZE (BINFO_TYPE (child)), 0)
* BITS_PER_UNIT);
- putc (';', asmfile);
- CHARS (1);
+ stabstr_C (';');
}
}
}
@@ -1816,8 +2105,7 @@ dbxout_type (tree type, int full)
dbxout_type_methods (type);
}
- putc (';', asmfile);
- CHARS (1);
+ stabstr_C (';');
if (use_gnu_debug_info_extensions && TREE_CODE (type) == RECORD_TYPE
/* Avoid the ~ if we don't really need it--it confuses dbx. */
@@ -1825,23 +2113,13 @@ dbxout_type (tree type, int full)
{
have_used_extensions = 1;
- /* Tell GDB+ that it may keep reading. */
- putc ('~', asmfile);
- CHARS (1);
-
/* We need to write out info about what field this class
uses as its "main" vtable pointer field, because if this
field is inherited from a base class, GDB cannot necessarily
figure out which field it's using in time. */
- if (TYPE_VFIELD (type))
- {
- putc ('%', asmfile);
- CHARS (1);
- dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type)), 0);
- }
-
- putc (';', asmfile);
- CHARS (1);
+ stabstr_S ("~%");
+ dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type)), 0);
+ stabstr_C (';');
}
break;
@@ -1855,48 +2133,43 @@ dbxout_type (tree type, int full)
&& !full)
|| !COMPLETE_TYPE_P (type))
{
- fprintf (asmfile, "xe");
- CHARS (2);
+ stabstr_S ("xe");
dbxout_type_name (type);
typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
- putc (':', asmfile);
- CHARS (1);
+ stabstr_C (':');
return;
}
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);
- if (TREE_CHAIN (tem) != 0)
- CONTIN;
+ stabstr_C (',');
}
- putc (';', asmfile);
- CHARS (1);
+ stabstr_C (';');
break;
case POINTER_TYPE:
- putc ('*', asmfile);
- CHARS (1);
+ stabstr_C ('*');
dbxout_type (TREE_TYPE (type), 0);
break;
@@ -1904,17 +2177,14 @@ dbxout_type (tree type, int full)
if (use_gnu_debug_info_extensions)
{
have_used_extensions = 1;
- putc ('#', asmfile);
- CHARS (1);
+ stabstr_C ('#');
/* Write the argument types out longhand. */
dbxout_type (TYPE_METHOD_BASETYPE (type), 0);
- putc (',', asmfile);
- CHARS (1);
+ stabstr_C (',');
dbxout_type (TREE_TYPE (type), 0);
dbxout_args (TYPE_ARG_TYPES (type));
- putc (';', asmfile);
- CHARS (1);
+ stabstr_C (';');
}
else
/* Treat it as a function type. */
@@ -1925,11 +2195,9 @@ dbxout_type (tree type, int full)
if (use_gnu_debug_info_extensions)
{
have_used_extensions = 1;
- putc ('@', asmfile);
- CHARS (1);
+ stabstr_C ('@');
dbxout_type (TYPE_OFFSET_BASETYPE (type), 0);
- putc (',', asmfile);
- CHARS (1);
+ stabstr_C (',');
dbxout_type (TREE_TYPE (type), 0);
}
else
@@ -1939,15 +2207,17 @@ dbxout_type (tree type, int full)
case REFERENCE_TYPE:
if (use_gnu_debug_info_extensions)
- have_used_extensions = 1;
- putc (use_gnu_debug_info_extensions ? '&' : '*', asmfile);
- CHARS (1);
+ {
+ have_used_extensions = 1;
+ stabstr_C ('&');
+ }
+ else
+ stabstr_C ('*');
dbxout_type (TREE_TYPE (type), 0);
break;
case FUNCTION_TYPE:
- putc ('f', asmfile);
- CHARS (1);
+ stabstr_C ('f');
dbxout_type (TREE_TYPE (type), 0);
break;
@@ -1989,83 +2259,6 @@ print_int_cst_bounds_in_octal_p (tree ty
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. */
@@ -2087,8 +2280,7 @@ dbxout_type_name (tree type)
gcc_unreachable ();
}
- fprintf (asmfile, "%s", IDENTIFIER_POINTER (t));
- CHARS (IDENTIFIER_LENGTH (t));
+ stabstr_I (t);
}
/* Output leading leading struct or class names needed for qualifying
@@ -2107,15 +2299,13 @@ dbxout_class_name_qualifiers (tree decl)
{
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
@@ -2164,8 +2354,8 @@ dbxout_symbol (tree decl, int local ATTR
/* 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
@@ -2208,14 +2398,6 @@ dbxout_symbol (tree decl, int local ATTR
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:
@@ -2234,16 +2416,12 @@ dbxout_symbol (tree decl, int local ATTR
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
@@ -2253,11 +2431,15 @@ dbxout_symbol (tree decl, int local ATTR
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:
@@ -2315,28 +2497,27 @@ dbxout_symbol (tree decl, int local ATTR
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
@@ -2349,20 +2530,15 @@ dbxout_symbol (tree decl, int local ATTR
{
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;
}
@@ -2384,33 +2560,26 @@ dbxout_symbol (tree decl, int local ATTR
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. */
@@ -2434,7 +2603,9 @@ dbxout_symbol (tree decl, int local ATTR
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)
@@ -2445,21 +2616,18 @@ dbxout_symbol (tree decl, int local ATTR
if (TREE_PUBLIC (decl) == 0)
{
/* The sun4 assembler does not grok this. */
- const char *name = IDENTIFIER_POINTER (DECL_NAME (decl));
if (TREE_CODE (TREE_TYPE (decl)) == INTEGER_TYPE
|| TREE_CODE (TREE_TYPE (decl)) == ENUMERAL_TYPE)
{
- HOST_WIDE_INT ival = tree_low_cst (DECL_INITIAL (decl), 0);
- 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. */
+ 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_AND_RETURN (1);
}
break;
}
@@ -2492,10 +2660,11 @@ static int
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.
@@ -2535,17 +2704,16 @@ dbxout_symbol_location (tree decl, tree
no letter at all, and N_LSYM, for auto variable,
r and N_RSYM for register variable. */
- if (MEM_P (home)
- && GET_CODE (XEXP (home, 0)) == SYMBOL_REF)
+ if (MEM_P (home) && GET_CODE (XEXP (home, 0)) == SYMBOL_REF)
{
if (TREE_PUBLIC (decl))
{
letter = 'G';
- current_sym_code = N_GSYM;
+ code = N_GSYM;
}
else
{
- current_sym_addr = XEXP (home, 0);
+ addr = XEXP (home, 0);
letter = decl_function_context (decl) ? 'V' : 'S';
@@ -2556,11 +2724,11 @@ dbxout_symbol_location (tree decl, tree
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,
@@ -2568,23 +2736,23 @@ dbxout_symbol_location (tree decl, tree
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))
+ if (GET_CODE (addr) == SYMBOL_REF
+ && CONSTANT_POOL_ADDRESS_P (addr))
{
bool marked;
- rtx tmp = get_pool_constant_mark (current_sym_addr, &marked);
+ rtx tmp = get_pool_constant_mark (addr, &marked);
if (GET_CODE (tmp) == SYMBOL_REF)
{
- current_sym_addr = tmp;
- if (CONSTANT_POOL_ADDRESS_P (current_sym_addr))
- get_pool_constant_mark (current_sym_addr, &marked);
+ addr = tmp;
+ if (CONSTANT_POOL_ADDRESS_P (addr))
+ get_pool_constant_mark (addr, &marked);
else
marked = true;
}
else if (GET_CODE (tmp) == LABEL_REF)
{
- current_sym_addr = tmp;
+ addr = tmp;
marked = true;
}
@@ -2598,15 +2766,15 @@ dbxout_symbol_location (tree decl, tree
#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 (MEM_P (home)
&& (MEM_P (XEXP (home, 0))
@@ -2627,18 +2795,17 @@ dbxout_symbol_location (tree decl, tree
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,
@@ -2651,17 +2818,17 @@ dbxout_symbol_location (tree decl, tree
else if (MEM_P (home)
&& REG_P (XEXP (home, 0)))
{
- current_sym_code = N_LSYM;
- current_sym_value = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
+ code = N_LSYM;
+ number = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
}
else if (MEM_P (home)
&& GET_CODE (XEXP (home, 0)) == PLUS
&& GET_CODE (XEXP (XEXP (home, 0), 1)) == CONST_INT)
{
- current_sym_code = N_LSYM;
+ code = N_LSYM;
/* RTL looks like (MEM (PLUS (REG...) (CONST_INT...)))
We want the value of that CONST_INT. */
- current_sym_value = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
+ number = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
}
else if (MEM_P (home)
&& GET_CODE (XEXP (home, 0)) == CONST)
@@ -2677,9 +2844,9 @@ dbxout_symbol_location (tree decl, tree
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)
{
@@ -2700,8 +2867,6 @@ dbxout_symbol_location (tree decl, tree
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
@@ -2715,18 +2880,18 @@ dbxout_symbol_location (tree decl, tree
return 0;
/* Ok, start a symtab entry and output the variable name. */
- 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 ();
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;
}
@@ -2737,7 +2902,7 @@ dbxout_symbol_location (tree decl, tree
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))
@@ -2746,56 +2911,22 @@ dbxout_symbol_name (tree decl, const cha
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
@@ -2829,7 +2960,6 @@ void
dbxout_parms (tree parms)
{
++debug_nesting;
-
emit_pending_bincls_if_required ();
for (; parms; parms = TREE_CHAIN (parms))
@@ -2838,7 +2968,10 @@ dbxout_parms (tree parms)
&& DECL_RTL_SET_P (parms)
&& DECL_INCOMING_RTL (parms))
{
- dbxout_prepare_symbol (parms);
+ tree eff_type;
+ char letter;
+ STAB_CODE_TYPE code;
+ int number;
/* Perform any necessary register eliminations on the parameter's rtl,
so that the debugging output will be accurate. */
@@ -2855,104 +2988,60 @@ dbxout_parms (tree parms)
if (PARM_PASSED_IN_MEMORY (parms))
{
- rtx addr = XEXP (DECL_INCOMING_RTL (parms), 0);
+ rtx inrtl = XEXP (DECL_INCOMING_RTL (parms), 0);
/* ??? Here we assume that the parm address is indexed
off the frame pointer or arg pointer.
If that is not true, we produce meaningless results,
but do not crash. */
- if (GET_CODE (addr) == PLUS
- && GET_CODE (XEXP (addr, 1)) == CONST_INT)
- current_sym_value = INTVAL (XEXP (addr, 1));
+ if (GET_CODE (inrtl) == PLUS
+ && GET_CODE (XEXP (inrtl, 1)) == CONST_INT)
+ number = INTVAL (XEXP (inrtl, 1));
else
- current_sym_value = 0;
-
- current_sym_code = N_PSYM;
- current_sym_addr = 0;
+ number = 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);
- }
- 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);
+ code = N_PSYM;
+ number = DEBUGGER_ARG_OFFSET (number, inrtl);
+ letter = DBX_MEMPARM_STABS_LETTER;
+
+ /* It is quite tempting to use TREE_TYPE (parms) instead
+ of DECL_ARG_TYPE (parms) for the eff_type, so that gcc
+ reports the actual type of the parameter, rather than
+ the promoted type. This certainly makes GDB's life
+ easier, at least for some ports. The change is a bad
+ idea however, since GDB expects to be able access the
+ type without performing any conversions. So for
+ example, if we were passing a float to an unprototyped
+ function, gcc will store a double on the stack, but if
+ we emit a stab saying the type is a float, then gdb
+ will only read in a single value, and this will produce
+ an erroneous value. */
+ eff_type = DECL_ARG_TYPE (parms);
}
else if (REG_P (DECL_RTL (parms)))
{
rtx best_rtl;
- char regparm_letter;
- tree parm_type;
- /* Parm passed in registers and lives in registers or nowhere. */
- current_sym_code = DBX_REGPARM_STABS_CODE;
- regparm_letter = DBX_REGPARM_STABS_LETTER;
- current_sym_addr = 0;
-
- /* If parm lives in a register, use that register;
- pretend the parm was passed there. It would be more consistent
- to describe the register where the parm was passed,
- but in practice that register usually holds something else.
+ /* Parm passed in registers and lives in registers or nowhere. */
+ code = DBX_REGPARM_STABS_CODE;
+ letter = DBX_REGPARM_STABS_LETTER;
- If we use DECL_RTL, then we must use the declared type of
- the variable, not the type that it arrived in. */
+ /* For parms passed in registers, it is better to use the
+ declared type of the variable, not the type it arrived in. */
+ eff_type = TREE_TYPE (parms);
+
+ /* If parm lives in a register, use that register; pretend
+ the parm was passed there. It would be more consistent
+ to describe the register where the parm was passed, but
+ in practice that register usually holds something else.
+ If the parm lives nowhere, use the register where it
+ was passed. */
if (REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
- {
- best_rtl = DECL_RTL (parms);
- parm_type = TREE_TYPE (parms);
- }
- /* If the parm lives nowhere, use the register where it was
- passed. It is also better to use the declared type here. */
- else
- {
- best_rtl = DECL_INCOMING_RTL (parms);
- parm_type = TREE_TYPE (parms);
- }
- current_sym_value = DBX_REGISTER_NUMBER (REGNO (best_rtl));
-
- FORCE_TEXT;
- if (DECL_NAME (parms))
- {
- current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (parms));
- fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
- IDENTIFIER_POINTER (DECL_NAME (parms)),
- regparm_letter);
- }
+ best_rtl = DECL_RTL (parms);
else
- {
- current_sym_nchars = 8;
- fprintf (asmfile, "%s\"(anon):%c", ASM_STABS_OP,
- regparm_letter);
- }
+ best_rtl = DECL_INCOMING_RTL (parms);
- dbxout_type (parm_type, 0);
- dbxout_finish_symbol (parms);
+ number = DBX_REGISTER_NUMBER (REGNO (best_rtl));
}
else if (MEM_P (DECL_RTL (parms))
&& REG_P (XEXP (DECL_RTL (parms), 0))
@@ -2967,46 +3056,23 @@ dbxout_parms (tree parms)
That is, its address was passed in a register.
Output it as if it lived in that register.
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. */
+ that it was actually passed by invisible reference. */
- 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;
+ letter = (use_gnu_debug_info_extensions
+ ? GDB_INV_REF_REGPARM_STABS_LETTER
+ : 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 (MEM_P (DECL_RTL (parms))
&& MEM_P (XEXP (DECL_RTL (parms), 0)))
@@ -3015,25 +3081,18 @@ dbxout_parms (tree parms)
living on the stack. DECL_RTL looks like
(MEM (MEM (PLUS (REG ...) (CONST_INT ...)))) or it
could look like (MEM (MEM (REG))). */
- const char *const decl_name = (DECL_NAME (parms)
- ? IDENTIFIER_POINTER (DECL_NAME (parms))
- : "(anon)");
- if (REG_P (XEXP (XEXP (DECL_RTL (parms), 0), 0)))
- current_sym_value = 0;
+
+ code = N_PSYM;
+ letter = 'v';
+ eff_type = TREE_TYPE (parms);
+
+ if (!REG_P (XEXP (XEXP (DECL_RTL (parms), 0), 0)))
+ number = INTVAL (XEXP (XEXP (XEXP (DECL_RTL (parms), 0), 0), 1));
else
- current_sym_value
- = INTVAL (XEXP (XEXP (XEXP (DECL_RTL (parms), 0), 0), 1));
- current_sym_addr = 0;
- current_sym_code = N_PSYM;
-
- FORCE_TEXT;
- fprintf (asmfile, "%s\"%s:v", ASM_STABS_OP, decl_name);
-
- current_sym_value
- = DEBUGGER_ARG_OFFSET (current_sym_value,
- XEXP (XEXP (DECL_RTL (parms), 0), 0));
- dbxout_type (TREE_TYPE (parms), 0);
- dbxout_finish_symbol (parms);
+ number = 0;
+
+ number = DEBUGGER_ARG_OFFSET (number,
+ XEXP (XEXP (DECL_RTL (parms), 0), 0));
}
else if (MEM_P (DECL_RTL (parms))
&& XEXP (DECL_RTL (parms), 0) != const0_rtx
@@ -3044,53 +3103,43 @@ dbxout_parms (tree parms)
{
/* Parm was passed in registers but lives on the stack. */
- current_sym_code = N_PSYM;
+ code = N_PSYM;
+ letter = DBX_MEMPARM_STABS_LETTER;
+ eff_type = TREE_TYPE (parms);
+
/* DECL_RTL looks like (MEM (PLUS (REG...) (CONST_INT...))),
in which case we want the value of that CONST_INT,
or (MEM (REG ...)),
in which case we use a value of zero. */
- if (REG_P (XEXP (DECL_RTL (parms), 0)))
- current_sym_value = 0;
+ if (!REG_P (XEXP (DECL_RTL (parms), 0)))
+ number = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1));
else
- current_sym_value
- = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1));
-
- current_sym_addr = 0;
+ number = 0;
/* Make a big endian correction if the mode of the type of the
parameter is not the same as the mode of the rtl. */
if (BYTES_BIG_ENDIAN
&& TYPE_MODE (TREE_TYPE (parms)) != GET_MODE (DECL_RTL (parms))
&& GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms))) < UNITS_PER_WORD)
- {
- current_sym_value +=
- GET_MODE_SIZE (GET_MODE (DECL_RTL (parms)))
- - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms)));
- }
-
- FORCE_TEXT;
- if (DECL_NAME (parms))
- {
- current_sym_nchars
- = 2 + strlen (IDENTIFIER_POINTER (DECL_NAME (parms)));
-
- fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
- IDENTIFIER_POINTER (DECL_NAME (parms)),
- DBX_MEMPARM_STABS_LETTER);
- }
- else
- {
- current_sym_nchars = 8;
- fprintf (asmfile, "%s\"(anon):%c", ASM_STABS_OP,
- DBX_MEMPARM_STABS_LETTER);
- }
+ number += (GET_MODE_SIZE (GET_MODE (DECL_RTL (parms)))
+ - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms))));
+ }
+ else
+ /* ??? We don't know how to represent this argument. */
+ continue;
- current_sym_value
- = DEBUGGER_ARG_OFFSET (current_sym_value,
- XEXP (DECL_RTL (parms), 0));
- dbxout_type (TREE_TYPE (parms), 0);
- dbxout_finish_symbol (parms);
+ dbxout_begin_complex_stabs ();
+
+ if (DECL_NAME (parms))
+ {
+ stabstr_I (DECL_NAME (parms));
+ stabstr_C (':');
}
+ else
+ stabstr_S ("(anon):");
+ stabstr_C (letter);
+ dbxout_type (eff_type, 0);
+ dbxout_finish_complex_stabs (parms, code, 0, 0, number);
}
DBXOUT_DECR_NESTING;
}
@@ -3114,8 +3163,6 @@ dbxout_reg_parms (tree parms)
for (; parms; parms = TREE_CHAIN (parms))
if (DECL_NAME (parms) && PARM_PASSED_IN_MEMORY (parms))
{
- dbxout_prepare_symbol (parms);
-
/* Report parms that live in registers during the function
but were passed in memory. */
if (REG_P (DECL_RTL (parms))
@@ -3142,9 +3189,8 @@ dbxout_args (tree args)
{
while (args)
{
- putc (',', asmfile);
+ stabstr_C (',');
dbxout_type (TREE_VALUE (args), 0);
- CHARS (1);
args = TREE_CHAIN (args);
}
}
@@ -3157,15 +3203,13 @@ dbx_output_lbrac (const char *label,
const char *begin_label ATTRIBUTE_UNUSED)
{
#ifdef DBX_OUTPUT_LBRAC
- DBX_OUTPUT_LBRAC (asmfile, label);
+ DBX_OUTPUT_LBRAC (asm_out_file, label);
#else
- fprintf (asmfile, "%s%d,0,0,", ASM_STABN_OP, N_LBRAC);
- assemble_name (asmfile, label);
-#if DBX_BLOCKS_FUNCTION_RELATIVE
- putc ('-', asmfile);
- assemble_name (asmfile, begin_label);
-#endif
- fprintf (asmfile, "\n");
+ 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
}
@@ -3177,15 +3221,13 @@ dbx_output_rbrac (const char *label,
const char *begin_label ATTRIBUTE_UNUSED)
{
#ifdef DBX_OUTPUT_RBRAC
- DBX_OUTPUT_RBRAC (asmfile, label);
+ DBX_OUTPUT_RBRAC (asm_out_file, label);
#else
- fprintf (asmfile, "%s%d,0,0,", ASM_STABN_OP, N_RBRAC);
- assemble_name (asmfile, label);
-#if DBX_BLOCKS_FUNCTION_RELATIVE
- putc ('-', asmfile);
- assemble_name (asmfile, begin_label);
-#endif
- fprintf (asmfile, "\n");
+ 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
}
@@ -3209,11 +3251,7 @@ dbx_output_rbrac (const char *label,
static void
dbxout_block (tree block, int depth, tree args)
{
- const char *begin_label;
- if (current_function_func_begin_label != NULL)
- begin_label = current_function_func_begin_label;
- else
- begin_label = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0);
+ const char *begin_label = XSTR(XEXP(DECL_RTL(current_function_decl), 0), 0);
while (block)
{
@@ -3256,10 +3294,11 @@ dbxout_block (tree block, int depth, tre
tree decl = BLOCK_VARS (block);
while (decl)
{
- fprintf (asmfile, "%s\"%s:C1\",%d,0,0,", ASM_STABS_OP,
- IDENTIFIER_POINTER (DECL_NAME (decl)), N_CATCH);
- assemble_name (asmfile, scope_start);
- fprintf (asmfile, "\n");
+ dbxout_begin_complex_stabs ();
+ stabstr_I (DECL_NAME (decl));
+ stabstr_S (":C1");
+ dbxout_finish_complex_stabs (0, N_CATCH, 0,
+ scope_start, 0);
decl = TREE_CHAIN (decl);
}
}
===================================================================
Index: defaults.h
--- defaults.h 12 Oct 2004 19:28:55 -0000 1.159
+++ defaults.h 14 Oct 2004 08:18:54 -0000
@@ -73,6 +73,18 @@ Software Foundation, 59 Temple Place - S
} while (0)
#endif
+#ifndef ASM_STABS_OP
+# 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
===================================================================
Index: output.h
--- output.h 15 Sep 2004 17:02:56 -0000 1.146
+++ output.h 14 Oct 2004 08:18:54 -0000
@@ -522,4 +522,24 @@ extern bool default_valid_pointer_mode (
extern int default_address_cost (rtx);
+/* dbxout helper functions */
+#if defined DBX_DEBUGGING_INFO || defined XCOFF_DEBUGGING_INFO
+
+extern void dbxout_int (int);
+extern void dbxout_stabd (int, int);
+extern void dbxout_begin_stabn (int);
+extern void dbxout_begin_stabn_nodesc (int);
+extern void dbxout_begin_empty_stabs (int);
+extern void dbxout_begin_simple_stabs (const char *, int);
+extern void dbxout_begin_simple_stabs_nodesc (const char *, int);
+
+extern void dbxout_stab_value_zero (void);
+extern void dbxout_stab_value_label (const char *);
+extern void dbxout_stab_value_label_diff (const char *, const char *);
+extern void dbxout_stab_value_internal_label (const char *, int *);
+extern void dbxout_stab_value_internal_label_diff (const char *, int *,
+ const char *);
+
+#endif
+
#endif /* ! GCC_OUTPUT_H */
===================================================================
Index: system.h
--- system.h 6 Oct 2004 22:20:31 -0000 1.230
+++ system.h 14 Oct 2004 08:18:54 -0000
@@ -653,7 +653,9 @@ extern void fancy_abort (const char *, i
SUNOS4_SHARED_LIBRARIES PROMOTE_FOR_CALL_ONLY \
SPACE_AFTER_L_OPTION NO_RECURSIVE_FUNCTION_CSE \
DEFAULT_MAIN_RETURN TARGET_MEM_FUNCTIONS EXPAND_BUILTIN_VA_ARG \
- COLLECT_PARSE_FLAG DWARF2_GENERATE_TEXT_SECTION_LABEL
+ COLLECT_PARSE_FLAG DWARF2_GENERATE_TEXT_SECTION_LABEL \
+ DBX_OUTPUT_FUNCTION_END DBX_OUTPUT_MAIN_SOURCE_FILENAME \
+ STABS_GCC_MARKER
/* Hooks that are no longer used. */
#pragma GCC poison LANG_HOOKS_FUNCTION_MARK LANG_HOOKS_FUNCTION_FREE \
===================================================================
Index: varasm.c
--- varasm.c 21 Sep 2004 23:40:21 -0000 1.453
+++ varasm.c 14 Oct 2004 08:18:54 -0000
@@ -57,10 +57,6 @@ Software Foundation, 59 Temple Place - S
declarations for e.g. AIX 4.x. */
#endif
-#ifndef ASM_STABS_OP
-#define ASM_STABS_OP "\t.stabs\t"
-#endif
-
/* The (assembler) name of the first globally-visible object output. */
const char *first_global_object_name;
const char *weak_global_object_name;
@@ -1017,12 +1013,15 @@ assemble_asm (tree string)
void
default_stabs_asm_out_destructor (rtx symbol, int priority ATTRIBUTE_UNUSED)
{
+#if defined DBX_DEBUGGING_INFO || defined XCOFF_DEBUGGING_INFO
/* Tell GNU LD that this is part of the static destructor set.
This will work for any system that uses stabs, most usefully
aout systems. */
- fprintf (asm_out_file, "%s\"___DTOR_LIST__\",22,0,0,", ASM_STABS_OP);
- assemble_name (asm_out_file, XSTR (symbol, 0));
- fputc ('\n', asm_out_file);
+ dbxout_begin_simple_stabs ("___DTOR_LIST__", 22 /* N_SETT */);
+ dbxout_stab_value_label (XSTR (symbol, 0));
+#else
+ sorry ("global destructors not supported on this target");
+#endif
}
void
@@ -1074,12 +1073,15 @@ default_dtor_section_asm_out_destructor
void
default_stabs_asm_out_constructor (rtx symbol, int priority ATTRIBUTE_UNUSED)
{
+#if defined DBX_DEBUGGING_INFO || defined XCOFF_DEBUGGING_INFO
/* Tell GNU LD that this is part of the static destructor set.
This will work for any system that uses stabs, most usefully
aout systems. */
- fprintf (asm_out_file, "%s\"___CTOR_LIST__\",22,0,0,", ASM_STABS_OP);
- assemble_name (asm_out_file, XSTR (symbol, 0));
- fputc ('\n', asm_out_file);
+ dbxout_begin_simple_stabs ("___CTOR_LIST__", 22 /* N_SETT */);
+ dbxout_stab_value_label (XSTR (symbol, 0));
+#else
+ sorry ("global constructors not supported on this target");
+#endif
}
void
===================================================================
Index: xcoffout.h
--- xcoffout.h 6 Jul 2004 15:37:55 -0000 1.24
+++ xcoffout.h 14 Oct 2004 08:18:54 -0000
@@ -21,8 +21,6 @@ Software Foundation, 59 Temple Place - S
02111-1307, USA. */
-#define ASM_STABS_OP "\t.stabx\t"
-
/* Tags and typedefs are C_DECL in XCOFF, not C_LSYM. */
#define DBX_TYPE_DECL_STABS_CODE N_DECL
@@ -70,31 +68,35 @@ Software Foundation, 59 Temple Place - S
/* Define our own finish symbol function, since xcoff stabs have their
own different format. */
-#define DBX_FINISH_SYMBOL(SYM) \
-{ \
- if (current_sym_addr && current_sym_code == N_FUN) \
- fprintf (asmfile, "\",."); \
- else \
- fprintf (asmfile, "\","); \
- /* If we are writing a function name, we must ensure that \
- there is no storage-class suffix on the name. */ \
- if (current_sym_addr && current_sym_code == N_FUN \
- && GET_CODE (current_sym_addr) == SYMBOL_REF) \
- { \
- const char *_p = XSTR (current_sym_addr, 0); \
- if (*_p == '*') \
- fprintf (asmfile, "%s", _p+1); \
- else \
- for (; *_p != '[' && *_p; _p++) \
- fprintf (asmfile, "%c", *_p); \
- } \
- else if (current_sym_addr) \
- output_addr_const (asmfile, current_sym_addr); \
- else if (current_sym_code == N_GSYM) \
- assemble_name (asmfile, XSTR (XEXP (DECL_RTL (SYM), 0), 0)); \
- else \
- fprintf (asmfile, "%d", current_sym_value); \
- fprintf (asmfile, ",%d,0\n", stab_to_sclass (current_sym_code)); \
+#define DBX_FINISH_STABS(CODE, LINE, ADDR, LABEL, NUMBER) do {
+ if (ADDR)
+ {
+ /* If we are writing a function name, we must ensure that
+ there is no storage-class suffix on the name. */
+ if (CODE == N_FUN && GET_CODE (ADDR) == SYMBOL_REF)
+ {
+ const char *_p = XSTR (current_sym_addr, 0);
+ if (*_p == '*')
+ fputs (_p+1, asm_out_file);
+ else
+ for (; *_p != '[' && *_p; _p++)
+ putc (*_p, asm_out_file);
+ }
+ else
+ {
+ if (CODE == N_FUN)
+ putc ('.', asm_out_file);
+ output_addr_const (asm_out_file, ADDR);
+ }
+ }
+ else if (LABEL)
+ assemble_name (LABEL, asm_out_file);
+ else
+ dbxout_int (NUMBER);
+ putc (',', asm_out_file);
+ dbxout_int (stab_to_sclass (current_sym_code);
+ putc (',', asm_out_file);
+ dbxout_value_zero ();
}
/* These are IBM XCOFF extensions we need to reference in dbxout.c
@@ -128,35 +130,35 @@ extern char *xcoff_read_only_section_nam
extern const char *xcoff_lastfile;
/* Don't write out path name for main source file. */
-#define DBX_OUTPUT_MAIN_SOURCE_DIRECTORY(FILE,FILENAME)
+#define NO_DBX_MAIN_SOURCE_DIRECTORY
/* Write out main source file name using ".file" rather than ".stabs".
We don't actually do this here, because the assembler gets confused if there
is more than one .file directive. rs6000_xcoff_file_start is already
emitting a .file directory, so we don't output one here also.
Initialize xcoff_lastfile. */
-#define DBX_OUTPUT_MAIN_SOURCE_FILENAME(FILE,FILENAME) \
+#define DBX_OUTPUT_MAIN_SOURCE_FILE(FILENAME) \
xcoff_lastfile = (FILENAME)
/* If we are still in an include file, its end must be marked. */
-#define DBX_OUTPUT_MAIN_SOURCE_FILE_END(FILE, FILENAME) \
-{ \
+#define DBX_OUTPUT_MAIN_SOURCE_FILE_END(FILENAME) \
+do { \
if (xcoff_current_include_file) \
{ \
- fputs ("\t.ei\t", (FILE)); \
- output_quoted_string ((FILE), xcoff_current_include_file); \
- putc ('\n', (FILE)); \
+ fputs ("\t.ei\t", asm_out_file); \
+ output_quoted_string (asm_out_file, xcoff_current_include_file); \
+ putc ('\n', asm_out_file); \
xcoff_current_include_file = NULL; \
} \
-}
+} while (0)
/* .stabx has the type in a different place. */
#if 0 /* Do not emit any marker for XCOFF until assembler allows XFT_CV. */
-#define DBX_OUTPUT_GCC_MARKER(FILE) \
- fprintf ((FILE), "%s\"%s\",0,%d,0\n", ASM_STABS_OP, STABS_GCC_MARKER, \
+#define DBX_OUTPUT_GCC_MARKER() \
+ fprintf (asm_out_file, "%s\"gcc2_compiled.\",0,%d,0\n", ASM_STABS_OP, \
stab_to_sclass (N_GSYM))
#else
-#define DBX_OUTPUT_GCC_MARKER(FILE)
+#define DBX_OUTPUT_GCC_MARKER() /* nothing */
#endif
/* Do not break .stabs pseudos into continuations. */
===================================================================
Index: config/darwin.h
--- config/darwin.h 16 Sep 2004 06:49:58 -0000 1.96
+++ config/darwin.h 14 Oct 2004 08:18:54 -0000
@@ -358,13 +358,7 @@ extern const char *darwin_fix_and_contin
#define DBX_CONTIN_LENGTH 0
/* gdb needs a null N_SO at the end of each file for scattered loading. */
-
-#undef DBX_OUTPUT_MAIN_SOURCE_FILE_END
-#define DBX_OUTPUT_MAIN_SOURCE_FILE_END(FILE, FILENAME) \
-do { text_section (); \
- fprintf (FILE, \
- "\t.stabs \"%s\",%d,0,0,Letext\nLetext:\n", "" , N_SO); \
- } while (0)
+#define DBX_OUTPUT_NULL_N_SO_AT_MAIN_SOURCE_FILE_END
/* Making a symbols weak on Darwin requires more than just setting DECL_WEAK. */
#define MAKE_DECL_ONE_ONLY(DECL) darwin_make_decl_one_only (DECL)
===================================================================
Index: config/dbxcoff.h
--- config/dbxcoff.h 27 Sep 2003 04:48:11 -0000 1.8
+++ config/dbxcoff.h 14 Oct 2004 08:18:54 -0000
@@ -39,38 +39,17 @@ Boston, MA 02111-1307, USA. */
/* but, to make this work, functions must appear prior to line info. */
-#undef DBX_FUNCTION_FIRST
#define DBX_FUNCTION_FIRST
/* Generate a blank trailing N_SO to mark the end of the .o file, since
we can't depend upon the linker to mark .o file boundaries with
embedded stabs. */
-
-#undef DBX_OUTPUT_MAIN_SOURCE_FILE_END
-#define DBX_OUTPUT_MAIN_SOURCE_FILE_END(FILE, FILENAME) \
- asm_fprintf (FILE, \
- "\t.text\n\t.stabs \"\",%d,0,0,%LLetext\n%LLetext:\n", N_SO)
+#define DBX_OUTPUT_NULL_N_SO_AT_MAIN_SOURCE_FILE_END
/* Like block addresses, stabs line numbers are relative to the
current function. */
-#undef ASM_OUTPUT_SOURCE_LINE
-#define ASM_OUTPUT_SOURCE_LINE(FILE, LINE, COUNTER) \
-{ if (write_symbols == SDB_DEBUG) { \
- fprintf ((FILE), "\t.ln\t%d\n", \
- ((sdb_begin_function_line > -1) \
- ? (LINE) - sdb_begin_function_line : 1)); \
- } else if (write_symbols == DBX_DEBUG) { \
- char buffer[256]; \
- ASM_GENERATE_INTERNAL_LABEL (buffer, "LM", COUNTER); \
- fprintf (FILE, ".stabn 68,0,%d,", LINE); \
- assemble_name (FILE, buffer); \
- putc ('-', FILE); \
- assemble_name (FILE, \
- XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0)); \
- putc ('\n', FILE); \
- (*targetm.asm_out.internal_label) (FILE, "LM", COUNTER); \
- } }
+#define DBX_LINES_FUNCTION_RELATIVE 1
/* When generating stabs debugging, use N_BINCL entries. */
===================================================================
Index: config/dbxelf.h
--- config/dbxelf.h 27 Sep 2003 04:48:11 -0000 1.9
+++ config/dbxelf.h 14 Oct 2004 08:18:54 -0000
@@ -39,7 +39,6 @@ Boston, MA 02111-1307, USA. */
/* ... but, to make this work, functions must appear prior to line info. */
-#undef DBX_FUNCTION_FIRST
#define DBX_FUNCTION_FIRST
/* When generating stabs debugging, use N_BINCL entries. */
@@ -56,29 +55,11 @@ Boston, MA 02111-1307, USA. */
/* Like block addresses, stabs line numbers are relative to the
current function. */
-#undef ASM_OUTPUT_SOURCE_LINE
-#define ASM_OUTPUT_SOURCE_LINE(FILE, LINE, COUNTER) \
-do \
- { \
- char temp[256]; \
- ASM_GENERATE_INTERNAL_LABEL (temp, "LM", COUNTER); \
- fprintf (FILE, "\t.stabn 68,0,%d,", LINE); \
- assemble_name (FILE, temp); \
- putc ('-', FILE); \
- assemble_name (FILE, \
- XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0));\
- putc ('\n', FILE); \
- (*targetm.asm_out.internal_label) (FILE, "LM", COUNTER); \
- } \
-while (0)
+#define DBX_LINES_FUNCTION_RELATIVE 1
/* Generate a blank trailing N_SO to mark the end of the .o file, since
we can't depend upon the linker to mark .o file boundaries with
embedded stabs. */
-
-#undef DBX_OUTPUT_MAIN_SOURCE_FILE_END
-#define DBX_OUTPUT_MAIN_SOURCE_FILE_END(FILE, FILENAME) \
- asm_fprintf (FILE, \
- "\t.text\n\t.stabs \"\",%d,0,0,%LLetext\n%LLetext:\n", N_SO)
+#define DBX_OUTPUT_NULL_N_SO_AT_MAIN_SOURCE_FILE_END
#endif /* ! GCC_DBX_ELF_H */
===================================================================
Index: config/ptx4.h
--- config/ptx4.h 24 Dec 2003 00:14:19 -0000 1.24
+++ config/ptx4.h 14 Oct 2004 08:18:54 -0000
@@ -183,27 +183,12 @@ Boston, MA 02111-1307, USA.
/* Like block addresses, stabs line numbers are relative to the
current function. */
-
-#undef ASM_OUTPUT_SOURCE_LINE
-#define ASM_OUTPUT_SOURCE_LINE(file, line, counter) \
-do \
- { \
- fprintf (file, ".stabn 68,0,%d,.LM%d-", \
- line, counter); \
- assemble_name (file, \
- XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0));\
- fprintf (file, "\n.LM%d:\n", counter); \
- } \
-while (0)
+#define DBX_LINES_FUNCTION_RELATIVE 1
/* Generate a blank trailing N_SO to mark the end of the .o file, since
we can't depend upon the linker to mark .o file boundaries with
embedded stabs. */
-
-#undef DBX_OUTPUT_MAIN_SOURCE_FILE_END
-#define DBX_OUTPUT_MAIN_SOURCE_FILE_END(FILE, FILENAME) \
- fprintf (FILE, \
- "\t.text\n\t.stabs \"\",%d,0,0,.Letext\n.Letext:\n", N_SO)
+#define DBX_OUTPUT_NULL_N_SO_AT_MAIN_SOURCE_FILE_END
/* Define the actual types of some ANSI-mandated types. (These
definitions should work for most SVR4 systems). */
===================================================================
Index: config/alpha/alpha.c
--- config/alpha/alpha.c 30 Sep 2004 08:21:27 -0000 1.397
+++ config/alpha/alpha.c 14 Oct 2004 08:18:54 -0000
@@ -7172,7 +7172,6 @@ void
alpha_output_filename (FILE *stream, const char *name)
{
static int first_time = TRUE;
- char ltext_label_name[100];
if (first_time)
{
@@ -7188,10 +7187,11 @@ alpha_output_filename (FILE *stream, con
else if (write_symbols == DBX_DEBUG)
{
+ char ltext_label_name[100];
ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext", 0);
- fprintf (stream, "%s", ASM_STABS_OP);
- output_quoted_string (stream, name);
- fprintf (stream, ",%d,0,0,%s\n", N_SOL, <ext_label_name[1]);
+
+ dbxout_begin_simple_stabs (name, N_SOL);
+ dbxout_stab_value_label (ltext_label_name);
}
else if (name != current_function_file
@@ -7214,17 +7214,19 @@ alpha_output_filename (FILE *stream, con
/* Emit a linenumber to a stream. */
void
-alpha_output_lineno (FILE *stream, int line)
+alpha_output_lineno (FILE *stream ATTRIBUTE_UNUSED, int line)
{
if (write_symbols == DBX_DEBUG)
{
/* mips-tfile doesn't understand .stabd directives. */
- ++sym_lineno;
- fprintf (stream, "$LM%d:\n%s%d,0,%d,$LM%d\n",
- sym_lineno, ASM_STABN_OP, N_SLINE, line, sym_lineno);
+ dbxout_begin_stabn_nodesc (N_SLINE);
+ /* The desc is the line number. */
+ dbxout_int (line);
+ putc (',', asmfile);
+ dbxout_stab_value_internal_label ("LM", &sym_lineno);
}
else
- fprintf (stream, "\n\t.loc\t%d %d\n", num_source_filenames, line);
+ fprintf (asmfile, "\n\t.loc\t%d %d\n", num_source_filenames, line);
}
\f
/* Structure to show the current status of registers and memory. */
===================================================================
Index: config/arm/aout.h
--- config/arm/aout.h 16 Mar 2004 18:14:32 -0000 1.37
+++ config/arm/aout.h 14 Oct 2004 08:18:54 -0000
@@ -195,17 +195,8 @@
/* Output a source filename for the debugger. RISCiX dbx insists that the
``desc'' field is set to compiler version number >= 315 (sic). */
-#define DBX_OUTPUT_MAIN_SOURCE_FILENAME(STREAM, NAME) \
- do \
- { \
- fprintf (STREAM, ".stabs "); \
- output_quoted_string (STREAM, NAME); \
- fprintf (STREAM, ",%d,0,315,%s\n", N_SO, <ext_label_name[1]); \
- text_section (); \
- (*targetm.asm_out.internal_label) (STREAM, "Ltext", 0); \
- } \
- while (0)
-
+#define DBX_MAIN_SOURCE_FILENAME_DESC_VALUE 315
+
/* Output a function label definition. */
#ifndef ASM_DECLARE_FUNCTION_NAME
#define ASM_DECLARE_FUNCTION_NAME(STREAM, NAME, DECL) \
===================================================================
Index: config/c4x/c4x.h
--- config/c4x/c4x.h 18 Sep 2004 19:19:31 -0000 1.148
+++ config/c4x/c4x.h 14 Oct 2004 08:18:54 -0000
@@ -1452,8 +1452,6 @@ fini_section () \
} \
}
-#define ASM_STABS_OP "\t.stabs\t"
-
/* Switch into a generic section. */
#define TARGET_ASM_NAMED_SECTION c4x_asm_named_section
===================================================================
Index: config/h8300/coff.h
--- config/h8300/coff.h 21 Jan 2004 20:19:22 -0000 1.3
+++ config/h8300/coff.h 14 Oct 2004 08:18:54 -0000
@@ -27,15 +27,10 @@ Boston, MA 02111-1307, USA. */
#define SDB_DEBUGGING_INFO 1
#define SDB_DELIM "\n"
-/* Override definition in dbxcoff.h. */
/* Generate a blank trailing N_SO to mark the end of the .o file, since
we can't depend upon the linker to mark .o file boundaries with
embedded stabs. */
-
-#undef DBX_OUTPUT_MAIN_SOURCE_FILE_END
-#define DBX_OUTPUT_MAIN_SOURCE_FILE_END(FILE, FILENAME) \
- fprintf (FILE, \
- "\t.text\n.stabs \"\",%d,0,0,.Letext\n.Letext:\n", N_SO)
+#define DBX_OUTPUT_NULL_N_SO_AT_MAIN_SOURCE_FILE_END
/* This is how to output an assembler line
that says to advance the location counter by SIZE bytes. */
===================================================================
Index: config/m32r/m32r.h
--- config/m32r/m32r.h 8 Oct 2004 08:21:38 -0000 1.118
+++ config/m32r/m32r.h 14 Oct 2004 08:18:54 -0000
@@ -1517,26 +1517,24 @@ L2: .word STATIC
/* Globalizing directive for a label. */
#define GLOBAL_ASM_OP "\t.global\t"
-/* If -Os, don't force line number labels to begin at the beginning of
- the word; we still want the assembler to try to put things in parallel,
- should that be possible.
- For m32r/d, instructions are never in parallel (other than with a nop)
- and the simulator and stub both handle a breakpoint in the middle of
- a word so don't ever force line number labels to begin at the beginning
- of a word. */
+/* We do not use DBX_LINES_FUNCTION_RELATIVE here because we need to use
+ .debugsym for the special label. */
#undef ASM_OUTPUT_SOURCE_LINE
#define ASM_OUTPUT_SOURCE_LINE(file, line, counter) \
do \
{ \
- fprintf (file, ".stabn 68,0,%d,.LM%d-", \
- line, counter); \
- assemble_name \
- (file, XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0)); \
- fprintf (file, (optimize_size || TARGET_M32R) \
- ? "\n\t.debugsym .LM%d\n" \
- : "\n.LM%d:\n", \
- counter); \
+ char label[64]; \
+ ASM_GENERATE_INTERNAL_LABEL (label, "LM", counter); \
+ \
+ dbxout_begin_stabn_nodesc (N_SLINE); \
+ dbxout_int (line); \
+ assemble_name (file, label); \
+ putc ('-', file); \
+ assemble_name (file, begin_label); \
+ fputs ("\n\t.debugsym ", file); \
+ assemble_name (file, label); \
+ putc ('\n', file); \
} \
while (0)
===================================================================
Index: config/mcore/mcore-pe.h
--- config/mcore/mcore-pe.h 27 Sep 2003 04:48:25 -0000 1.20
+++ config/mcore/mcore-pe.h 14 Oct 2004 08:18:54 -0000
@@ -103,24 +103,7 @@ drectve_section () \
while (0);
#define TARGET_ASM_FILE_START_FILE_DIRECTIVE true
-
-#undef ASM_OUTPUT_SOURCE_LINE
-#define ASM_OUTPUT_SOURCE_LINE(FILE, LINE, COUNTER) \
- { \
- if (write_symbols == DBX_DEBUG) \
- { \
- char buffer[256]; \
- \
- ASM_GENERATE_INTERNAL_LABEL (buffer, "LM", COUNTER); \
- fprintf (FILE, ".stabn 68,0,%d,", LINE); \
- assemble_name (FILE, buffer); \
- putc ('-', FILE); \
- assemble_name (FILE, \
- XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0)); \
- putc ('\n', FILE); \
- (*targetm.asm_out.internal_label) (FILE, "LM", COUNTER); \
- } \
- }
+#define DBX_LINES_FUNCTION_RELATIVE 1
#define STARTFILE_SPEC "crt0.o%s"
#define ENDFILE_SPEC "%{!mno-lsim:-lsim}"
===================================================================
Index: config/pa/pa.h
--- config/pa/pa.h 7 Oct 2004 05:34:30 -0000 1.236
+++ config/pa/pa.h 14 Oct 2004 08:18:54 -0000
@@ -369,10 +369,6 @@ extern int target_flags;
#undef DBX_CONTIN_LENGTH
#define DBX_CONTIN_LENGTH 3000
-/* Only labels should ever begin in column zero. */
-#define ASM_STABS_OP "\t.stabs\t"
-#define ASM_STABN_OP "\t.stabn\t"
-
/* GDB always assumes the current function's frame begins at the value
of the stack pointer upon entry to the current function. Accessing
local variables and parameters passed on the stack is done using the
===================================================================
Index: config/pa/som.h
--- config/pa/som.h 20 Aug 2004 15:11:43 -0000 1.50
+++ config/pa/som.h 14 Oct 2004 08:18:54 -0000
@@ -27,33 +27,10 @@ Boston, MA 02111-1307, USA. */
from other embedded stabs implementations. */
#undef DBX_USE_BINCL
-/* We make the first line stab special to avoid adding several
- gross hacks to GAS. */
-#undef ASM_OUTPUT_SOURCE_LINE
-#define ASM_OUTPUT_SOURCE_LINE(file, line, counter) \
- { static tree last_function_decl = NULL; \
- if (current_function_decl == last_function_decl) \
- { \
- rtx func = DECL_RTL (current_function_decl); \
- const char *name = XSTR (XEXP (func, 0), 0); \
- fprintf (file, "\t.stabn 68,0,%d,L$M%d-%s\nL$M%d:\n", \
- line, counter, \
- (* targetm.strip_name_encoding) (name), \
- counter); \
- } \
- else \
- fprintf (file, "\t.stabn 68,0,%d,0\n", line); \
- last_function_decl = current_function_decl; \
- }
+#define DBX_LINES_FUNCTION_RELATIVE 1
/* gdb needs a null N_SO at the end of each file for scattered loading. */
-
-#undef DBX_OUTPUT_MAIN_SOURCE_FILE_END
-#define DBX_OUTPUT_MAIN_SOURCE_FILE_END(FILE, FILENAME) \
- text_section (); \
- fputs ("\t.SPACE $TEXT$\n\t.NSUBSPA $CODE$,QUAD=0,ALIGN=8,ACCESS=44,CODE_ONLY\n", FILE); \
- fprintf (FILE, \
- "\t.stabs \"\",%d,0,0,L$text_end0000\nL$text_end0000:\n", N_SO)
+#define DBX_OUTPUT_NULL_N_SO_AT_MAIN_SOURCE_FILE_END
/* Select a format to encode pointers in exception handling data. CODE
is 0 for data, 1 for code labels, 2 for function pointers. GLOBAL is
===================================================================
Index: config/rs6000/linux64.h
--- config/rs6000/linux64.h 5 Oct 2004 12:43:52 -0000 1.71
+++ config/rs6000/linux64.h 14 Oct 2004 08:18:54 -0000
@@ -491,7 +491,9 @@ do \
char temp[256]; \
const char *s; \
ASM_GENERATE_INTERNAL_LABEL (temp, "LM", COUNTER); \
- fprintf (FILE, "\t.stabn 68,0,%d,", LINE); \
+ dbxout_begin_stabn_nodesc (N_SLINE); \
+ dbxout_int (LINE); \
+ putc (',', FILE); \
assemble_name (FILE, temp); \
putc ('-', FILE); \
s = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0); \
@@ -501,23 +503,18 @@ do \
} \
while (0)
-/* Similarly, we want the function code label here. */
-#define DBX_OUTPUT_BRAC(FILE, NAME, BRAC) \
+/* Similarly, we want the function code label here. Cannot use
+ dbxout_stab_value_label_diff, as we have to use
+ rs6000_output_function_entry. FIXME. */
+#define DBX_OUTPUT_BRAC(FILE, NAME, BRAC) \
do \
{ \
const char *s; \
- fprintf (FILE, "%s%d,0,0,", ASM_STABN_OP, BRAC); \
+ dbxout_begin_stabn (BRAC); \
assemble_name (FILE, NAME); \
putc ('-', FILE); \
- if (current_function_func_begin_label != NULL) \
- { \
- assemble_name (FILE, current_function_func_begin_label); \
- } \
- else \
- { \
- s = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0); \
- rs6000_output_function_entry (FILE, s); \
- } \
+ s = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0); \
+ rs6000_output_function_entry (FILE, s); \
putc ('\n', FILE); \
} \
while (0)
@@ -530,7 +527,7 @@ while (0)
do \
{ \
const char *s; \
- fprintf (FILE, "%s\"\",%d,0,0,", ASM_STABS_OP, N_FUN); \
+ dbxout_begin_empty_stabs (N_FUN); \
assemble_name (FILE, LSCOPE); \
putc ('-', FILE); \
s = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0); \
===================================================================
Index: config/sh/elf.h
--- config/sh/elf.h 29 Jul 2004 06:10:03 -0000 1.35
+++ config/sh/elf.h 14 Oct 2004 08:18:54 -0000
@@ -82,24 +82,8 @@ Boston, MA 02111-1307, USA. */
#define ASM_GENERATE_INTERNAL_LABEL(STRING, PREFIX, NUM) \
sprintf ((STRING), "*%s%s%ld", LOCAL_LABEL_PREFIX, (PREFIX), (long)(NUM))
-#undef ASM_OUTPUT_SOURCE_LINE
-#define ASM_OUTPUT_SOURCE_LINE(file, line, counter) \
-do \
- { \
- asm_fprintf ((file), ".stabn 68,0,%d,%LLM%d-", \
- (line), (counter)); \
- assemble_name ((file), \
- XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0));\
- asm_fprintf ((file), "\n%LLM%d:\n", (counter)); \
- } \
-while (0)
-
-#undef DBX_OUTPUT_MAIN_SOURCE_FILE_END
-#define DBX_OUTPUT_MAIN_SOURCE_FILE_END(FILE, FILENAME) \
-do { \
- text_section (); \
- asm_fprintf ((FILE), "\t.stabs \"\",%d,0,0,%LLetext\n%LLetext:\n", N_SO); \
-} while (0)
+#define DBX_LINES_FUNCTION_RELATIVE 1
+#define DBX_OUTPUT_NULL_N_SO_AT_MAIN_SOURCE_FILE_END
#undef STARTFILE_SPEC
#define STARTFILE_SPEC \
===================================================================
Index: config/vax/elf.h
--- config/vax/elf.h 2 Oct 2003 00:44:29 -0000 1.5
+++ config/vax/elf.h 14 Oct 2004 08:18:54 -0000
@@ -42,9 +42,6 @@ Boston, MA 02111-1307, USA. */
/* Let's be re-entrant. */
#undef PCC_STATIC_STRUCT_RETURN
-/* Make sure .stabs for a function are always the same section. */
-#define DBX_OUTPUT_FUNCTION_END(file,decl) function_section(decl)
-
/* Before the prologue, the top of the frame is below the argument
count pushed by the CALLS and before the start of the saved registers. */
#define INCOMING_FRAME_SP_OFFSET 0
===================================================================
Index: doc/tm.texi
--- doc/tm.texi 13 Oct 2004 14:09:05 -0000 1.381
+++ doc/tm.texi 14 Oct 2004 08:18:55 -0000
@@ -8053,33 +8053,57 @@ feature off without disturbing the rest
@c prevent bad page break with this line
This describes file names in DBX format.
-@defmac DBX_OUTPUT_MAIN_SOURCE_FILENAME (@var{stream}, @var{name})
+@defmac DBX_OUTPUT_MAIN_SOURCE_FILE (@var{name})
A C statement to output DBX debugging information to the stdio stream
-@var{stream} which indicates that file @var{name} is the main source
+@var{asmfile}, which indicates that file @var{name} is the main source
file---the file specified as the input file for compilation.
This macro is called only once, at the beginning of compilation.
This macro need not be defined if the standard form of output
for DBX debugging information is appropriate.
+
+It may be necessary to refer to a label equal to the beginning of the
+text section. You can use @samp{assemble_name (asmfile,
+ltext_label_name)} to do so. If you do this, you must also set the
+variable @var{used_ltext_label_name} to @code{true}.
@end defmac
-@defmac DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (@var{stream}, @var{name})
-A C statement to output DBX debugging information to the stdio stream
-@var{stream} which indicates that the current directory during
-compilation is named @var{name}.
+@defmac DBX_MAIN_SOURCE_FILE_DESC_VALUE
+Define this macro instead of @code{DBX_OUTPUT_MAIN_SOURCE_FILENAME} if
+the default behavior is correct except for the @var{desc} value (the
+third number in the stab). It should expand to a C expression giving
+the proper value.
+@end defmac
-This macro need not be defined if the standard form of output
-for DBX debugging information is appropriate.
+@defmac NO_DBX_MAIN_SOURCE_DIRECTORY
+Define this macro if GCC should not emit an indication of the current
+directory for compilation and current source language at the beginning
+of the file.
@end defmac
-@defmac DBX_OUTPUT_MAIN_SOURCE_FILE_END (@var{stream}, @var{name})
+@defmac DBX_OUTPUT_MAIN_SOURCE_FILE_END (@var{name})
A C statement to output DBX debugging information at the end of
-compilation of the main source file @var{name}.
+compilation of the main source file @var{name}. Output should be
+written to the stdio stream @var{asmfile}.
If you don't define this macro, nothing special is output at the end
of compilation, which is correct for most machines.
@end defmac
+@defmac DBX_OUTPUT_NULL_N_SO_AT_MAIN_SOURCE_FILE_END
+A common thing to need to do at the end of the main source file is
+emit an @code{N_SO} stab with an empty filename and an address equal
+to the current text address. To do this, define this macro
+@emph{instead of} defining @code{DBX_OUTPUT_MAIN_SOURCE_FILE_END}.
+@end defmac
+
+@defmac DBX_OUTPUT_GCC_MARKER ()
+A C statement to write to @var{asmfile} an indication that this object
+file was compiled by GCC@. This indication should in some way contain
+the literal string @samp{gcc2_compiled.} The default is to emit an
+@code{N_OPT} stab with that string as the text.
+@end defmac
+
@need 2000
@node SDB and DWARF
@subsection Macros for SDB and DWARF Output
^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: RFC Speed up dbxout.c a bit
2004-10-14 9:12 RFC Speed up dbxout.c a bit Zack Weinberg
@ 2004-10-14 9:32 ` Richard Earnshaw
2004-10-14 16:57 ` Zack Weinberg
2004-10-14 14:46 ` Daniel Jacobowitz
` (2 subsequent siblings)
3 siblings, 1 reply; 9+ messages in thread
From: Richard Earnshaw @ 2004-10-14 9:32 UTC (permalink / raw)
To: Zack Weinberg; +Cc: gcc-patches
On Thu, 2004-10-14 at 09:49, Zack Weinberg wrote:
> * config/arm/aout.h: Define DBX_MAIN_SOURCE_FILENAME_DESC_VALUE
> instead of overriding DBX_OUTPUT_MAIN_SOURCE_FILENAME.
The comment above the changed code says that this was for RISC iX. We
don't support that OS any more, so this entire chunk is dead.
R.
^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: RFC Speed up dbxout.c a bit
2004-10-14 9:12 RFC Speed up dbxout.c a bit Zack Weinberg
2004-10-14 9:32 ` Richard Earnshaw
@ 2004-10-14 14:46 ` Daniel Jacobowitz
2004-10-14 17:04 ` Zack Weinberg
2004-10-15 2:34 ` tm_gccmail
2004-10-15 21:15 ` Mike Stump
3 siblings, 1 reply; 9+ messages in thread
From: Daniel Jacobowitz @ 2004-10-14 14:46 UTC (permalink / raw)
To: Zack Weinberg; +Cc: gcc-patches
On Thu, Oct 14, 2004 at 01:49:05AM -0700, Zack Weinberg wrote:
>
> This patch restructures dbxout.c not to use printf under any
> circumstances. It also overhauls the handling of continued stabs
> strings -- formerly each place that emitted part of a string would
> keep count of how many characters had been emitted, and at designated
> 'continuation points' the line would be split if there were too
> many. This meant that DBX_CONTIN_LENGTH had to be viewed as more of a
> guideline than an upper limit; there are several target headers which
> complain about not being able to use the correct value. Also, this
> structure forced the subsequent parameters to the .stabs directive to
> be carried around in global variables.
>
> Now we build the .stabs string in an obstack and break it up into
> appropriately-sized chunks when it's done. This means that
> DBX_CONTIN_LENGTH is now accurate, and the globals go away. Note that
> the obstack is used even when there is no limit on the length of a
> .stabs string. This is because it would take more #ifdefs to write
> straight to stdio in that case. Also, strange but true, writing
> straight to stdio is slower. Yes, I profiled it.
Unfortunately this won't work. Did you test on a target which breaks
up stab strings? GDB (and probably other consumers) do a similar
process of only putting the string back together in certain places.
The majority of the code will fall down if you insert backslashes
arbitrarily.
I can't figure out what targets are affected, since the default is 80
rather than 0. At least MIPS, Alpha, SPARC.
You could fix this but I'm not sure how many other programs may be
affected.
--
Daniel Jacobowitz
^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: RFC Speed up dbxout.c a bit
2004-10-14 9:32 ` Richard Earnshaw
@ 2004-10-14 16:57 ` Zack Weinberg
0 siblings, 0 replies; 9+ messages in thread
From: Zack Weinberg @ 2004-10-14 16:57 UTC (permalink / raw)
To: Richard Earnshaw; +Cc: gcc-patches
Richard Earnshaw <rearnsha@gcc.gnu.org> writes:
> On Thu, 2004-10-14 at 09:49, Zack Weinberg wrote:
>> * config/arm/aout.h: Define DBX_MAIN_SOURCE_FILENAME_DESC_VALUE
>> instead of overriding DBX_OUTPUT_MAIN_SOURCE_FILENAME.
>
> The comment above the changed code says that this was for RISC iX. We
> don't support that OS any more, so this entire chunk is dead.
Good to know.
Dan Jacobowitz has informed me that the way I did stab-string
splitting doesn't work, so I'm going to have to revise the patch
anyway, so I'll try to peel off the changes that affect target
headers.
zw
^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: RFC Speed up dbxout.c a bit
2004-10-14 14:46 ` Daniel Jacobowitz
@ 2004-10-14 17:04 ` Zack Weinberg
2004-10-14 17:39 ` Daniel Jacobowitz
0 siblings, 1 reply; 9+ messages in thread
From: Zack Weinberg @ 2004-10-14 17:04 UTC (permalink / raw)
To: gcc-patches
Daniel Jacobowitz <drow@false.org> writes:
> Unfortunately this won't work. Did you test on a target which breaks
> up stab strings? GDB (and probably other consumers) do a similar
> process of only putting the string back together in certain places.
> The majority of the code will fall down if you insert backslashes
> arbitrarily.
Ugh. I guess I didn't test on such a target. Do you know what the
constraints are? If it's a simple rule like 'only at semicolons' it
won't be that hard to do after the fact.
zw
^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: RFC Speed up dbxout.c a bit
2004-10-14 17:04 ` Zack Weinberg
@ 2004-10-14 17:39 ` Daniel Jacobowitz
2004-10-14 18:48 ` Zack Weinberg
0 siblings, 1 reply; 9+ messages in thread
From: Daniel Jacobowitz @ 2004-10-14 17:39 UTC (permalink / raw)
To: Zack Weinberg; +Cc: gcc-patches
On Thu, Oct 14, 2004 at 10:00:29AM -0700, Zack Weinberg wrote:
> Daniel Jacobowitz <drow@false.org> writes:
>
> > Unfortunately this won't work. Did you test on a target which breaks
> > up stab strings? GDB (and probably other consumers) do a similar
> > process of only putting the string back together in certain places.
> > The majority of the code will fall down if you insert backslashes
> > arbitrarily.
>
> Ugh. I guess I didn't test on such a target. Do you know what the
> constraints are? If it's a simple rule like 'only at semicolons' it
> won't be that hard to do after the fact.
They're quite arbitrary. Take a look at STABS_CONTINUE (and one call
in dbxread.c; you'll find it if you search for "cretinous").
--
Daniel Jacobowitz
^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: RFC Speed up dbxout.c a bit
2004-10-14 17:39 ` Daniel Jacobowitz
@ 2004-10-14 18:48 ` Zack Weinberg
0 siblings, 0 replies; 9+ messages in thread
From: Zack Weinberg @ 2004-10-14 18:48 UTC (permalink / raw)
To: gcc-patches
Daniel Jacobowitz <drow@false.org> writes:
> On Thu, Oct 14, 2004 at 10:00:29AM -0700, Zack Weinberg wrote:
>> Daniel Jacobowitz <drow@false.org> writes:
>>
>> > Unfortunately this won't work. Did you test on a target which breaks
>> > up stab strings? GDB (and probably other consumers) do a similar
>> > process of only putting the string back together in certain places.
>> > The majority of the code will fall down if you insert backslashes
>> > arbitrarily.
>>
>> Ugh. I guess I didn't test on such a target. Do you know what the
>> constraints are? If it's a simple rule like 'only at semicolons' it
>> won't be that hard to do after the fact.
>
> They're quite arbitrary. Take a look at STABS_CONTINUE (and one call
> in dbxread.c; you'll find it if you search for "cretinous").
Looking at that, it seems wisest to put back the old semantics of
continuing only at explicitly marked points. I think I have figured
out how to do that in the new framework.
zw
^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: RFC Speed up dbxout.c a bit
2004-10-14 9:12 RFC Speed up dbxout.c a bit Zack Weinberg
2004-10-14 9:32 ` Richard Earnshaw
2004-10-14 14:46 ` Daniel Jacobowitz
@ 2004-10-15 2:34 ` tm_gccmail
2004-10-15 21:15 ` Mike Stump
3 siblings, 0 replies; 9+ messages in thread
From: tm_gccmail @ 2004-10-15 2:34 UTC (permalink / raw)
To: Zack Weinberg; +Cc: gcc-patches
On Thu, 14 Oct 2004, Zack Weinberg wrote:
>
> This patch restructures dbxout.c not to use printf under any
> circumstances.
You might want to poison printf in that file to prevent people from adding
any more references after you've removed them.
Toshi
^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: RFC Speed up dbxout.c a bit
2004-10-14 9:12 RFC Speed up dbxout.c a bit Zack Weinberg
` (2 preceding siblings ...)
2004-10-15 2:34 ` tm_gccmail
@ 2004-10-15 21:15 ` Mike Stump
3 siblings, 0 replies; 9+ messages in thread
From: Mike Stump @ 2004-10-15 21:15 UTC (permalink / raw)
To: Zack Weinberg; +Cc: gcc-patches
On Thursday, October 14, 2004, at 01:49 AM, Zack Weinberg wrote:
> This patch restructures dbxout.c not to use printf under any
> circumstances.
> The patch produces no regressions in the GCC test suite on
> powerpc-darwin or
> i686-linux. In addition, on i686-linux there are no regressions in
> the GDB testsuite either in default mode (DWARF) or with
> --target_board=unix/gdb:debug_flags=-gstabs+ (forces use of stabs).
I thought I'd mention one of the ways that I might use to get a warm
fuzzy... pick some hairy C/C++ code (single translation unit), compile
it with the before and after compilers, and then compare the two .s
files directly. Maybe pre-edit the two .s files so that wrapped lines
are unwrapped.
^ permalink raw reply [flat|nested] 9+ messages in thread
end of thread, other threads:[~2004-10-15 21:02 UTC | newest]
Thread overview: 9+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2004-10-14 9:12 RFC Speed up dbxout.c a bit Zack Weinberg
2004-10-14 9:32 ` Richard Earnshaw
2004-10-14 16:57 ` Zack Weinberg
2004-10-14 14:46 ` Daniel Jacobowitz
2004-10-14 17:04 ` Zack Weinberg
2004-10-14 17:39 ` Daniel Jacobowitz
2004-10-14 18:48 ` Zack Weinberg
2004-10-15 2:34 ` tm_gccmail
2004-10-15 21:15 ` Mike Stump
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).