/* Output dbx-format symbol table information from GNU compiler.
- Copyright (C) 1987, 88, 92-96, 1997 Free Software Foundation, Inc.
+ Copyright (C) 1987, 88, 92-97, 1998 Free Software Foundation, Inc.
This file is part of GNU CC.
For more on data type definitions, see `dbxout_type'. */
-/* Include these first, because they may define MIN and MAX. */
-#include <stdio.h>
-#include <errno.h>
-
#include "config.h"
+#include "system.h"
+
#include "tree.h"
#include "rtl.h"
#include "flags.h"
#include "reload.h"
#include "defaults.h"
#include "output.h" /* ASM_OUTPUT_SOURCE_LINE may refer to sdb functions. */
-
-#ifndef errno
-extern int errno;
-#endif
+#include "dbxout.h"
+#include "toplev.h"
#ifdef XCOFF_DEBUGGING_INFO
#include "xcoffout.h"
#endif
#endif
+char *getpwd ();
+
+/* Typical USG systems don't have stab.h, and they also have
+ no use for DBX-format debugging info. */
+
+#if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
+
static int flag_minimal_debug = MINIMAL_DEBUG;
/* Nonzero if we have actually used any of the GDB extensions
static int source_label_number = 1;
-static int scope_labelno = 0;
-
-char *getpwd ();
-
-/* Typical USG systems don't have stab.h, and they also have
- no use for DBX-format debugging info. */
-
-#if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
-
#ifdef DEBUG_SYMS_TEXT
#define FORCE_TEXT text_section ();
#else
#define FORCE_TEXT
#endif
-#if defined (USG) || defined (NO_STAB_H) || defined (CROSS_COMPILE)
-#include "gstab.h" /* If doing DBX on sysV, use our own stab.h. */
+/* If there is a system stabs.h, use it. Otherwise, use our own. */
+
+#ifndef HAVE_STABS_H
+#include "gstab.h"
#else
-#include <stab.h> /* On BSD, use the system's stab.h. */
+#include <stab.h>
/* This is a GNU extension we need to reference in this file. */
#ifndef N_CATCH
#define N_CATCH 0x54
#endif
-#endif /* not USG */
+#endif
#ifdef __GNU_STAB__
#define STAB_CODE_TYPE enum __stab_debug_code
void dbxout_args ();
void dbxout_symbol ();
+#if defined(ASM_OUTPUT_SECTION_NAME)
static void dbxout_function_end PROTO((void));
+#endif
static void dbxout_typedefs PROTO((tree));
static void dbxout_type_index PROTO((tree));
+#if DBX_CONTIN_LENGTH > 0
static void dbxout_continue PROTO((void));
+#endif
static void dbxout_type_fields PROTO((tree));
static void dbxout_type_method_1 PROTO((tree, char *));
static void dbxout_type_methods PROTO((tree));
static void dbxout_block PROTO((tree, int, tree));
static void dbxout_really_begin_function PROTO((tree));
\f
+#if defined(ASM_OUTPUT_SECTION_NAME)
static void
dbxout_function_end ()
{
+ static int scope_labelno = 0;
char lscope_label_name[100];
/* Convert Ltext into the appropriate format for local labels in case
the system doesn't insert underscores in front of user generated
assemble_name (asmfile, lscope_label_name);
fputc ('-', asmfile);
assemble_name (asmfile, XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0));
- fprintf (asmfile, "-1\n");
+ fprintf (asmfile, "\n");
}
+#endif /* ! NO_DBX_FUNCTION_END */
/* At the beginning of compilation, start writing the symbol table.
Initialize `typevec' and output the standard data types of C. */
n->file_number = next_file_number++;
n->next_type_number = 1;
current_file = n;
- fprintf (asmfile, "%s \"%s\",%d,0,0,0\n", ASM_STABS_OP, filename, N_BINCL);
+ fprintf (asmfile, "%s ", ASM_STABS_OP);
+ output_quoted_string (asmfile, filename);
+ fprintf (asmfile, ",%d,0,0,0\n", N_BINCL);
#endif
}
#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
fprintf (asmfile, "%s \"", ASM_STABS_OP);
current_sym_nchars = 0;
}
+#endif /* DBX_CONTIN_LENGTH > 0 */
\f
/* Subroutine of `dbxout_type'. Output the type fields of TYPE.
This must be a separate function because anonymous unions require
|| TREE_CODE (DECL_SIZE (tem)) != INTEGER_CST))
continue;
/* Omit here the nameless fields that are used to skip bits. */
+ else if (DECL_IGNORED_P (tem))
+ continue;
else if (TREE_CODE (tem) != CONST_DECL)
{
/* Continue the line if necessary,
but not before the first field. */
if (tem != TYPE_FIELDS (type))
- CONTIN;
+ {
+ CONTIN;
+ }
if (use_gnu_debug_info_extensions
&& flag_minimal_debug
dbxout_type (DECL_FCONTEXT (tem), 0, 0);
fprintf (asmfile, ":");
dbxout_type (TREE_TYPE (tem), 0, 0);
- fprintf (asmfile, ",%d;",
+ fputc (',', asmfile);
+ fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
TREE_INT_CST_LOW (DECL_FIELD_BITPOS (tem)));
+ fputc (';', asmfile);
continue;
}
}
else if (TREE_CODE (DECL_FIELD_BITPOS (tem)) == INTEGER_CST)
{
- fprintf (asmfile, ",%d,%d;",
- TREE_INT_CST_LOW (DECL_FIELD_BITPOS (tem)),
+ fputc (',', asmfile);
+ fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
+ TREE_INT_CST_LOW (DECL_FIELD_BITPOS (tem)));
+ fputc (',', asmfile);
+ fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
TREE_INT_CST_LOW (DECL_SIZE (tem)));
+ fputc (';', asmfile);
}
CHARS (23);
}
- (debug_name - IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))));
if (DECL_VINDEX (decl))
{
- fprintf (asmfile, "%d;",
+ fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
TREE_INT_CST_LOW (DECL_VINDEX (decl)));
+ fputc (';', asmfile);
dbxout_type (DECL_CONTEXT (decl), 0, 0);
fprintf (asmfile, ";");
CHARS (8);
{
static int warned;
if (!warned)
- {
warned = 1;
-#ifdef HAVE_TEMPLATES
- if (warn_template_debugging)
- warning ("dbx info for template class methods not yet supported");
-#endif
- }
return;
}
}
sprintf(formatted_type_identifier_length, "%d", type_identifier_length);
- if (TREE_CODE (methods) == FUNCTION_DECL)
+ if (TREE_CODE (methods) != TREE_VEC)
fndecl = methods;
else if (TREE_VEC_ELT (methods, 0) != NULL_TREE)
fndecl = TREE_VEC_ELT (methods, 0);
were defined to be sub-ranges of int. Unfortunately, this
does not allow us to distinguish true sub-ranges from integer
types. So, instead we define integer (non-sub-range) types as
- sub-ranges of themselves. */
- dbxout_type_index (type);
+ sub-ranges of themselves. This matters for Chill. If this isn't
+ a subrange type, then we want to define it in terms of itself.
+ However, in C, this may be an anonymous integer type, and we don't
+ want to emit debug info referring to it. Just calling
+ dbxout_type_index won't work anyways, because the type hasn't been
+ defined yet. We make this work for both cases by checked to see
+ whether this is a defined type, referring to it if it is, and using
+ 'int' otherwise. */
+ if (TYPE_SYMTAB_ADDRESS (type) != 0)
+ dbxout_type_index (type);
+ else
+ dbxout_type_index (integer_type_node);
}
if (TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST)
- fprintf (asmfile, ";%d",
- TREE_INT_CST_LOW (TYPE_MIN_VALUE (type)));
+ {
+ fputc (';', asmfile);
+ fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
+ TREE_INT_CST_LOW (TYPE_MIN_VALUE (type)));
+ }
else
fprintf (asmfile, ";0");
- if (TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST)
- fprintf (asmfile, ";%d;",
- TREE_INT_CST_LOW (TYPE_MAX_VALUE (type)));
+ if (TYPE_MAX_VALUE (type)
+ && TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST)
+ {
+ fputc (';', asmfile);
+ fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
+ TREE_INT_CST_LOW (TYPE_MAX_VALUE (type)));
+ fputc (';', asmfile);
+ }
else
fprintf (asmfile, ";-1;");
}
dbxout_type_index (type);
fprintf (asmfile, ";0;127;");
}
+ /* This used to check if the type's precision was more than
+ HOST_BITS_PER_WIDE_INT. That is wrong since gdb uses a
+ long (it has no concept of HOST_BITS_PER_WIDE_INT). */
else if (use_gnu_debug_info_extensions
&& (TYPE_PRECISION (type) > TYPE_PRECISION (integer_type_node)
- || TYPE_PRECISION (type) > HOST_BITS_PER_WIDE_INT))
+ || TYPE_PRECISION (type) >= HOST_BITS_PER_LONG))
{
/* This used to say `r1' and we used to take care
to make sure that `int' was type number 1. */
to make sure that `int' was type number 1. */
fprintf (asmfile, "r");
dbxout_type_index (integer_type_node);
- fprintf (asmfile, ";%d;0;", int_size_in_bytes (type));
+ fputc (';', asmfile);
+ fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, int_size_in_bytes (type));
+ fputs (";0;", asmfile);
CHARS (13);
break;
case CHAR_TYPE:
if (use_gnu_debug_info_extensions)
- fprintf (asmfile, "@s%d;-20;",
- BITS_PER_UNIT * int_size_in_bytes (type));
+ {
+ fputs ("@s", asmfile);
+ fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
+ BITS_PER_UNIT * int_size_in_bytes (type));
+ fputs (";-20;", asmfile);
+ }
else
{
/* Output the type `char' as a subrange of itself.
case BOOLEAN_TYPE:
if (use_gnu_debug_info_extensions)
- fprintf (asmfile, "@s%d;-16;",
- BITS_PER_UNIT * int_size_in_bytes (type));
+ {
+ fputs ("@s", asmfile);
+ fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
+ BITS_PER_UNIT * int_size_in_bytes (type));
+ fputs (";-16;", asmfile);
+ }
else /* Define as enumeral type (False, True) */
fprintf (asmfile, "eFalse:0,True:1,;");
CHARS (17);
{
fprintf (asmfile, "r");
dbxout_type_index (type);
- fprintf (asmfile, ";%d;0;",
+ fputc (';', asmfile);
+ fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
int_size_in_bytes (TREE_TYPE (type)));
+ fputs (";0;", asmfile);
CHARS (12); /* The number is probably incorrect here. */
}
else
{
/* Output a complex integer type as a structure,
pending some other way to do it. */
- fprintf (asmfile, "s%d", int_size_in_bytes (type));
+ fputc ('s', asmfile);
+ fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, int_size_in_bytes (type));
fprintf (asmfile, "real:");
CHARS (10);
if (use_gnu_debug_info_extensions)
{
have_used_extensions = 1;
- fprintf (asmfile, "@s%d;",
+ fputs ("@s", asmfile);
+ fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
BITS_PER_UNIT * int_size_in_bytes (type));
+ fputc (';', asmfile);
/* Check if a bitstring type, which in Chill is
different from a [power]set. */
if (TYPE_STRING_FLAG (type))
break;
case ARRAY_TYPE:
+ /* Make arrays of packed bits look like bitstrings for chill. */
+ if (TYPE_PACKED (type) && use_gnu_debug_info_extensions)
+ {
+ have_used_extensions = 1;
+ fputs ("@s", asmfile);
+ fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
+ BITS_PER_UNIT * int_size_in_bytes (type));
+ fputc (';', asmfile);
+ fprintf (asmfile, "@S;");
+ putc ('S', asmfile);
+ CHARS (1);
+ dbxout_type (TYPE_DOMAIN (type), 0, 0);
+ break;
+ }
/* Output "a" followed by a range type definition
for the index type of the array
followed by a reference to the target-type.
{
int i, n_baseclasses = 0;
- if (TYPE_BINFO (type) != 0 && TYPE_BINFO_BASETYPES (type) != 0)
+ if (TYPE_BINFO (type) != 0
+ && TREE_CODE (TYPE_BINFO (type)) == TREE_VEC
+ && TYPE_BINFO_BASETYPES (type) != 0)
n_baseclasses = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type));
/* Output a structure type. We must use the same test here as we
}
/* Identify record or union, and print its size. */
- fprintf (asmfile, (TREE_CODE (type) == RECORD_TYPE) ? "s%d" : "u%d",
+ fputc (((TREE_CODE (type) == RECORD_TYPE) ? 's' : 'u'), asmfile);
+ fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
int_size_in_bytes (type));
if (use_gnu_debug_info_extensions)
putc (TREE_VIA_PUBLIC (child) ? '2'
: '0',
asmfile);
- fprintf (asmfile, "%d,",
+ fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
TREE_INT_CST_LOW (BINFO_OFFSET (child)) * BITS_PER_UNIT);
+ fputc (',', asmfile);
CHARS (15);
dbxout_type (BINFO_TYPE (child), 0, 0);
putc (';', asmfile);
dbxout_type_name (BINFO_TYPE (child));
putc (':', asmfile);
dbxout_type (BINFO_TYPE (child), full, 0);
- fprintf (asmfile, ",%d,%d;",
- TREE_INT_CST_LOW (BINFO_OFFSET (child)) * BITS_PER_UNIT,
+ fputc (',', asmfile);
+ fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
+ TREE_INT_CST_LOW (BINFO_OFFSET (child)) * BITS_PER_UNIT);
+ fputc (',', asmfile);
+ fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
TREE_INT_CST_LOW (DECL_SIZE (TYPE_NAME (BINFO_TYPE (child)))) * BITS_PER_UNIT);
+ fputc (';', asmfile);
CHARS (20);
}
}
{
fprintf (asmfile, "%s:", IDENTIFIER_POINTER (TREE_PURPOSE (tem)));
if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == 0)
- fprintf (asmfile, "%lu",
- (unsigned long) TREE_INT_CST_LOW (TREE_VALUE (tem)));
+ fprintf (asmfile, HOST_WIDE_INT_PRINT_UNSIGNED,
+ TREE_INT_CST_LOW (TREE_VALUE (tem)));
else if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == -1
&& TREE_INT_CST_LOW (TREE_VALUE (tem)) < 0)
- fprintf (asmfile, "%ld",
- (long) TREE_INT_CST_LOW (TREE_VALUE (tem)));
+ fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC,
+ TREE_INT_CST_LOW (TREE_VALUE (tem)));
else
print_int_cst_octal (TREE_VALUE (tem));
fprintf (asmfile, ",");
CHARS (20 + IDENTIFIER_LENGTH (TREE_PURPOSE (tem)));
if (TREE_CHAIN (tem) != 0)
- CONTIN;
+ {
+ CONTIN;
+ }
}
putc (';', asmfile);
CHARS (1);
<< (HOST_BITS_PER_WIDE_INT / 3 * 3))
- 1);
- fprintf (asmfile, "%o%01o", beg, middle);
+ fprintf (asmfile, "%o%01o", (int)beg, (int)middle);
print_octal (end, HOST_BITS_PER_WIDE_INT / 3);
}
}
int i;
for (i = digits - 1; i >= 0; i--)
- fprintf (asmfile, "%01o", ((value >> (3 * i)) & 7));
+ fprintf (asmfile, "%01o", (int)((value >> (3 * i)) & 7));
}
/* Output the name of type TYPE, with no punctuation.
#ifdef DBX_OUTPUT_CONSTANT_SYMBOL
DBX_OUTPUT_CONSTANT_SYMBOL (asmfile, name, ival);
#else
- fprintf (asmfile, "%s \"%s:c=i%d\",0x%x,0,0,0\n",
- ASM_STABS_OP, name, ival, N_LSYM);
+ fprintf (asmfile, "%s \"%s:c=i", ASM_STABS_OP, name);
+
+ fprintf (asmfile, HOST_WIDE_INT_PRINT_DEC, ival);
+ fprintf (asmfile, "\",0x%x,0,0,0\n", N_LSYM);
#endif
return;
}
/* else it is something we handle like a normal variable. */
}
- DECL_RTL (decl) = eliminate_regs (DECL_RTL (decl), 0, NULL_RTX, 0);
+ DECL_RTL (decl) = eliminate_regs (DECL_RTL (decl), 0, NULL_RTX);
#ifdef LEAF_REG_REMAP
if (leaf_function)
leaf_renumber_regs_insn (DECL_RTL (decl));
#endif
dbxout_symbol_location (decl, type, 0, DECL_RTL (decl));
+ break;
+
+ default:
+ break;
}
}
\f
/* Don't mention a variable at all
if it was completely optimized into nothingness.
- If the decl was from an inline function, then it's rtl
+ If the decl was from an inline function, then its rtl
is not identically the rtl that was used in this
particular compilation. */
if (GET_CODE (home) == REG)
else if (GET_CODE (home) == MEM
&& (GET_CODE (XEXP (home, 0)) == MEM
|| (GET_CODE (XEXP (home, 0)) == REG
- && REGNO (XEXP (home, 0)) != HARD_FRAME_POINTER_REGNUM)))
+ && REGNO (XEXP (home, 0)) != HARD_FRAME_POINTER_REGNUM
+ && REGNO (XEXP (home, 0)) != STACK_POINTER_REGNUM
+#if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
+ && REGNO (XEXP (home, 0)) != ARG_POINTER_REGNUM
+#endif
+ )))
/* If the value is indirect by memory or by a register
that isn't the frame pointer
then it means the object is variable-sized and address through
/* Perform any necessary register eliminations on the parameter's rtl,
so that the debugging output will be accurate. */
DECL_INCOMING_RTL (parms)
- = eliminate_regs (DECL_INCOMING_RTL (parms), 0, NULL_RTX, 0);
- DECL_RTL (parms) = eliminate_regs (DECL_RTL (parms), 0, NULL_RTX, 0);
+ = eliminate_regs (DECL_INCOMING_RTL (parms), 0, NULL_RTX);
+ DECL_RTL (parms) = eliminate_regs (DECL_RTL (parms), 0, NULL_RTX);
#ifdef LEAF_REG_REMAP
if (leaf_function)
{
DBX_MEMPARM_STABS_LETTER);
}
- dbxout_type (DECL_ARG_TYPE (parms), 0, 0);
+ /* It is quite tempting to use:
+
+ dbxout_type (TREE_TYPE (parms), 0, 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 erropneous value. */
+ dbxout_type (DECL_ARG_TYPE (parms), 0, 0);
current_sym_value = DEBUGGER_ARG_OFFSET (current_sym_value, addr);
dbxout_finish_symbol (parms);
}
current_sym_value = INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1));
current_sym_addr = 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 += UNITS_PER_WORD - GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (parms)));
+ }
+
FORCE_TEXT;
if (DECL_NAME (parms))
{
dbxout_function_end ();
#endif
}
-#endif /* DBX_DEBUGGING_INFO */
+#endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */
OSDN Git Service
