#include "config.h"
#include "system.h"
#include "tree.h"
#include "rtl.h"
#include "flags.h"
#include "regs.h"
#include "insn-config.h"
#include "reload.h"
#include "output.h"
#include "dbxout.h"
#include "toplev.h"
#include "tm_p.h"
#include "ggc.h"
#include "debug.h"
#include "function.h"
#include "target.h"
#include "langhooks.h"
#ifdef XCOFF_DEBUGGING_INFO
#include "xcoffout.h"
#endif
#ifdef PFE
#include "pfe/pfe.h"
#include "pfe/pfe-header.h"
enum dbxout_code {
DBXOUT_INIT,
DBXOUT_FINISH,
DBXOUT_DEFINE,
DBXOUT_UNDEF,
DBXOUT_START_SOURCE_FILE,
DBXOUT_END_SOURCE_FILE,
DBXOUT_BEGIN_BLOCK,
DBXOUT_END_BLOCK,
DBXOUT_IGNORE_BLOCK,
DBXOUT_SOURCE_LINE,
DBXOUT_BEGIN_PROLOGUE,
DBXOUT_END_PROLOGUE,
DBXOUT_END_EPILOGUE,
DBXOUT_BEGIN_FUNCTION,
DBXOUT_END_FUNCTION,
DBXOUT_FUNCTION_DECL,
DBXOUT_GLOBAL_DECL,
DBXOUT_DEFERRED_INLINE_FUNCTION,
DBXOUT_OUTLINING_INLINE_FUNCTION,
DBXOUT_LABEL,
DBXOUT_SYMBOL,
DBXOUT_PARMS,
DBXOUT_REG_PARMS
};
#define DBXOUT_TRACK_NESTING
static int dbxout_nesting = 0;
#define DBXOUT_DECR_NESTING --dbxout_nesting
#define DBXOUT_DECR_NESTING_AND_RETURN(x) \
do {--dbxout_nesting; return (x);} while (0)
#define DBXOUT_SAVE_ARGUMENTS(code...) \
if (pfe_operation == PFE_DUMP) \
dbxout_save_arguments (code);
struct dbxout_stabs_t {
ENUM_BITFIELD(dbxout_code) code;
union {
const char *s;
struct {
unsigned int line;
const char *s;
} f;
unsigned int line;
struct {
unsigned int line;
unsigned int n;
} b;
tree node;
struct rtx_def *insn;
struct {
tree decl;
int local;
} sym;
} u;
};
static struct dbxout_stabs_t *dbxout_data_array = NULL;
#define DBXOUT_DATA_ARRAY_INITIAL_SIZE 40000
#define DBXOUT_DATA_ARRAY_INCR 10000
static int dbxout_data_array_size = 0;
static int dbxout_data_array_next = 0;
static int dbxout_data_array_incr = DBXOUT_DATA_ARRAY_INITIAL_SIZE;
static void freeze_thaw_dbxout_data_array PARAMS ((struct dbxout_stabs_t **));
static void dbxout_save_arguments PARAMS ((enum dbxout_code code, ...));
static void dbxout_intercept_init PARAMS ((const char *main_filename));
static void dbxout_intercept_finish PARAMS ((const char *main_filename));
static void dbxout_intercept_define PARAMS ((unsigned int line, const char *text));
static void dbxout_intercept_undef PARAMS ((unsigned int line, const char *macro));
static void dbxout_intercept_start_source_file PARAMS ((unsigned int line, const char *file));
static void dbxout_intercept_end_source_file PARAMS ((unsigned int line));
static void dbxout_intercept_begin_block PARAMS ((unsigned int line, unsigned int n));
static void dbxout_intercept_end_block PARAMS ((unsigned int line, unsigned int n));
static bool dbxout_intercept_ignore_block PARAMS ((union tree_node *));
static void dbxout_intercept_source_line PARAMS ((unsigned int line, const char *file));
static void dbxout_intercept_begin_prologue PARAMS ((unsigned int line, const char *file));
static void dbxout_intercept_end_prologue PARAMS ((unsigned int line));
static void dbxout_intercept_end_epilogue PARAMS ((void));
static void dbxout_intercept_begin_function PARAMS ((union tree_node *decl));
static void dbxout_intercept_end_function PARAMS ((unsigned int line));
static void dbxout_intercept_function_decl PARAMS ((union tree_node *decl));
static void dbxout_intercept_global_decl PARAMS ((union tree_node *decl));
static void dbxout_intercept_deferred_inline_function PARAMS ((union tree_node *decl));
static void dbxout_intercept_outlining_inline_function PARAMS ((union tree_node *decl));
static void dbxout_intercept_label PARAMS ((struct rtx_def *insn));
struct gcc_debug_hooks intercept_debug_hooks =
{
dbxout_intercept_init,
dbxout_intercept_finish,
dbxout_intercept_define,
dbxout_intercept_undef,
dbxout_intercept_start_source_file,
dbxout_intercept_end_source_file,
dbxout_intercept_begin_block,
dbxout_intercept_end_block,
dbxout_intercept_ignore_block,
dbxout_intercept_source_line,
dbxout_intercept_begin_prologue,
dbxout_intercept_end_prologue,
dbxout_intercept_end_epilogue,
dbxout_intercept_begin_function,
dbxout_intercept_end_function,
dbxout_intercept_function_decl,
dbxout_intercept_global_decl,
dbxout_intercept_deferred_inline_function,
dbxout_intercept_outlining_inline_function,
dbxout_intercept_label
};
struct gcc_debug_hooks *actual_debug_hooks;
#endif
#ifdef DBX_ONLY_USED_SYMBOLS
extern int flag_debug_only_used_symbols;
static void dbxout_flush_symbol_queue PARAMS ((void));
static void dbxout_queue_symbol PARAMS ((tree decl));
static tree *symbol_queue;
static int symbol_queue_index = 0;
static int symbol_queue_size = 0;
#ifndef PFE
#define DBXOUT_TRACK_NESTING
static int dbxout_nesting = 0;
#define DBXOUT_SAVE_ARGUMENTS(code...)
#endif
#undef DBXOUT_DECR_NESTING
#define DBXOUT_DECR_NESTING \
if (--dbxout_nesting == 0 && symbol_queue_index > 0) \
dbxout_flush_symbol_queue ()
#undef DBXOUT_DECR_NESTING_AND_RETURN
#define DBXOUT_DECR_NESTING_AND_RETURN(x) \
do {--dbxout_nesting; return (x);} while (0)
#endif
#ifndef DBXOUT_TRACK_NESTING
#define DBXOUT_DECR_NESTING
#define DBXOUT_DECR_NESTING_AND_RETURN(x) return (x)
#endif
#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
#ifndef DBX_STATIC_CONST_VAR_CODE
#define DBX_STATIC_CONST_VAR_CODE N_FUN
#endif
#ifndef DBX_REGPARM_STABS_CODE
#define DBX_REGPARM_STABS_CODE N_RSYM
#endif
#ifndef DBX_REGPARM_STABS_LETTER
#define DBX_REGPARM_STABS_LETTER 'P'
#endif
#ifndef GDB_INV_REF_REGPARM_STABS_LETTER
#define GDB_INV_REF_REGPARM_STABS_LETTER 'a'
#endif
#ifndef DBX_MEMPARM_STABS_LETTER
#define DBX_MEMPARM_STABS_LETTER 'p'
#endif
#ifndef FILE_NAME_JOINER
#define FILE_NAME_JOINER "/"
#endif
#ifndef STABS_GCC_MARKER
#define STABS_GCC_MARKER "gcc2_compiled."
#endif
#if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
static int have_used_extensions = 0;
#if defined (DBX_DEBUGGING_INFO) && !defined (DBX_OUTPUT_SOURCE_FILENAME)
static int source_label_number = 1;
#endif
#ifdef DEBUG_SYMS_TEXT
#define FORCE_TEXT text_section ();
#else
#define FORCE_TEXT
#endif
#include "gstab.h"
#define STAB_CODE_TYPE enum __stab_debug_code
#define PARM_PASSED_IN_MEMORY(PARM) \
(GET_CODE (DECL_INCOMING_RTL (PARM)) == MEM)
#ifndef DEBUGGER_AUTO_OFFSET
#define DEBUGGER_AUTO_OFFSET(X) \
(GET_CODE (X) == PLUS ? INTVAL (XEXP (X, 1)) : 0)
#endif
#ifndef DEBUGGER_ARG_OFFSET
#define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET)
#endif
static FILE *asmfile;
static const char *lastfile;
static const char *cwd;
enum typestatus {TYPE_UNSEEN, TYPE_XREF, TYPE_DEFINED};
struct typeinfo
{
enum typestatus status;
#ifdef DBX_USE_BINCL
int file_number;
int type_number;
#endif
};
struct typeinfo *typevec;
static int typevec_len;
static int next_type_number;
#ifdef DBX_USE_BINCL
struct dbx_file
{
struct dbx_file *next;
int file_number;
int next_type_number;
};
static struct dbx_file *current_file;
static int next_file_number;
#endif
static STAB_CODE_TYPE current_sym_code;
static int current_sym_value;
static rtx current_sym_addr;
static int current_sym_nchars;
#define CHARS(N) (current_sym_nchars += (N))
#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
static void dbxout_init PARAMS ((const char *));
static void dbxout_finish PARAMS ((const char *));
static void dbxout_start_source_file PARAMS ((unsigned, const char *));
static void dbxout_end_source_file PARAMS ((unsigned));
static void dbxout_typedefs PARAMS ((tree));
static void dbxout_type_index PARAMS ((tree));
#if DBX_CONTIN_LENGTH > 0
static void dbxout_continue PARAMS ((void));
#endif
static void dbxout_args PARAMS ((tree));
static void dbxout_type_fields PARAMS ((tree));
static void dbxout_type_method_1 PARAMS ((tree, const char *));
static void dbxout_type_methods PARAMS ((tree));
static void dbxout_range_type PARAMS ((tree));
static void dbxout_type PARAMS ((tree, int));
static void print_int_cst_octal PARAMS ((tree));
static void print_octal PARAMS ((unsigned HOST_WIDE_INT, int));
static void print_wide_int PARAMS ((HOST_WIDE_INT));
static void dbxout_type_name PARAMS ((tree));
static int dbxout_symbol_location PARAMS ((tree, tree, const char *, rtx));
static void dbxout_symbol_name PARAMS ((tree, const char *, int));
static void dbxout_prepare_symbol PARAMS ((tree));
static void dbxout_finish_symbol PARAMS ((tree));
static void dbxout_block PARAMS ((tree, int, tree));
static void dbxout_global_decl PARAMS ((tree));
#if defined (DBX_DEBUGGING_INFO)
static void dbxout_source_line PARAMS ((unsigned int, const char *));
static void dbxout_source_file PARAMS ((FILE *, const char *));
static void dbxout_function_end PARAMS ((void));
static void dbxout_begin_function PARAMS ((tree));
static void dbxout_begin_block PARAMS ((unsigned, unsigned));
static void dbxout_end_block PARAMS ((unsigned, unsigned));
static void dbxout_function_decl PARAMS ((tree));
struct gcc_debug_hooks dbx_debug_hooks =
{
dbxout_init,
dbxout_finish,
debug_nothing_int_charstar,
debug_nothing_int_charstar,
dbxout_start_source_file,
dbxout_end_source_file,
dbxout_begin_block,
dbxout_end_block,
debug_true_tree,
dbxout_source_line,
dbxout_source_line,
debug_nothing_int,
debug_nothing_void,
#ifdef DBX_FUNCTION_FIRST
dbxout_begin_function,
#else
debug_nothing_tree,
#endif
debug_nothing_int,
dbxout_function_decl,
dbxout_global_decl,
debug_nothing_tree,
debug_nothing_tree,
debug_nothing_rtx
};
#endif
#if defined (XCOFF_DEBUGGING_INFO)
struct gcc_debug_hooks xcoff_debug_hooks =
{
dbxout_init,
dbxout_finish,
debug_nothing_int_charstar,
debug_nothing_int_charstar,
dbxout_start_source_file,
dbxout_end_source_file,
xcoffout_begin_block,
xcoffout_end_block,
debug_true_tree,
xcoffout_source_line,
xcoffout_begin_prologue,
debug_nothing_int,
xcoffout_end_epilogue,
debug_nothing_tree,
xcoffout_end_function,
debug_nothing_tree,
dbxout_global_decl,
debug_nothing_tree,
debug_nothing_tree,
debug_nothing_rtx
};
#endif
#if defined (DBX_DEBUGGING_INFO)
static void
dbxout_function_end ()
{
static int scope_labelno = 0;
char lscope_label_name[100];
ASM_GENERATE_INTERNAL_LABEL (lscope_label_name, "Lscope", scope_labelno);
ASM_OUTPUT_INTERNAL_LABEL (asmfile, "Lscope", scope_labelno);
scope_labelno++;
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
static void
dbxout_init (input_file_name)
const char *input_file_name;
{
char ltext_label_name[100];
tree syms = getdecls ();
asmfile = asm_out_file;
typevec_len = 100;
typevec = (struct typeinfo *) xcalloc (typevec_len, sizeof typevec[0]);
ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext", 0);
#ifndef DBX_WORKING_DIRECTORY
if (use_gnu_debug_info_extensions)
#endif
{
if (!cwd && (cwd = getpwd ()) && (!*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
fprintf (asmfile, "%s", ASM_STABS_OP);
output_quoted_string (asmfile, cwd);
fprintf (asmfile, ",%d,0,0,", N_SO);
assemble_name (asmfile, ltext_label_name);
fputc ('\n', asmfile);
#endif
}
}
#ifdef DBX_OUTPUT_MAIN_SOURCE_FILENAME
DBX_OUTPUT_MAIN_SOURCE_FILENAME (asmfile, input_file_name);
#else
fprintf (asmfile, "%s", ASM_STABS_OP);
output_quoted_string (asmfile, input_file_name);
fprintf (asmfile, ",%d,0,0,", N_SO);
assemble_name (asmfile, ltext_label_name);
fputc ('\n', asmfile);
text_section ();
ASM_OUTPUT_INTERNAL_LABEL (asmfile, "Ltext", 0);
#endif
#ifdef DBX_OUTPUT_GCC_MARKER
DBX_OUTPUT_GCC_MARKER (asmfile);
#else
fprintf (asmfile, "%s\"%s\",%d,0,0,0\n",
ASM_STABS_OP, STABS_GCC_MARKER, N_OPT);
#endif
lastfile = input_file_name;
next_type_number = 1;
#ifdef DBX_USE_BINCL
current_file = (struct dbx_file *) xmalloc (sizeof *current_file);
current_file->next = NULL;
current_file->file_number = 0;
current_file->next_type_number = 1;
next_file_number = 1;
#endif
#ifdef PFE
if (pfe_operation != PFE_LOAD)
{
#ifdef DBX_OUTPUT_STANDARD_TYPES
DBX_OUTPUT_STANDARD_TYPES (syms);
#else
#ifndef DBX_ONLY_USED_SYMBOLS
dbxout_symbol (TYPE_NAME (integer_type_node), 0);
dbxout_symbol (TYPE_NAME (char_type_node), 0);
#endif
#endif
dbxout_typedefs (syms);
}
#else
#ifdef DBX_OUTPUT_STANDARD_TYPES
DBX_OUTPUT_STANDARD_TYPES (syms);
#else
dbxout_symbol (TYPE_NAME (integer_type_node), 0);
dbxout_symbol (TYPE_NAME (char_type_node), 0);
#endif
dbxout_typedefs (syms);
#endif
}
static void
dbxout_typedefs (syms)
tree syms;
{
if (syms)
{
dbxout_typedefs (TREE_CHAIN (syms));
if (TREE_CODE (syms) == TYPE_DECL)
{
tree type = TREE_TYPE (syms);
if (TYPE_NAME (type)
&& TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
&& COMPLETE_TYPE_P (type)
&& ! TREE_ASM_WRITTEN (TYPE_NAME (type)))
dbxout_symbol (TYPE_NAME (type), 0);
}
}
}
static void
dbxout_start_source_file (line, filename)
unsigned int line ATTRIBUTE_UNUSED;
const char *filename ATTRIBUTE_UNUSED;
{
#ifdef DBX_USE_BINCL
struct dbx_file *n = (struct dbx_file *) xmalloc (sizeof *n);
n->next = current_file;
n->file_number = next_file_number++;
n->next_type_number = 1;
current_file = n;
fprintf (asmfile, "%s", ASM_STABS_OP);
output_quoted_string (asmfile, filename);
fprintf (asmfile, ",%d,0,0,0\n", N_BINCL);
#endif
}
static void
dbxout_end_source_file (line)
unsigned int line ATTRIBUTE_UNUSED;
{
#ifdef DBX_USE_BINCL
struct dbx_file *next;
fprintf (asmfile, "%s%d,0,0,0\n", ASM_STABN_OP, N_EINCL);
next = current_file->next;
free (current_file);
current_file = next;
#endif
}
#if defined (DBX_DEBUGGING_INFO)
static void
dbxout_source_file (file, filename)
FILE *file;
const char *filename;
{
if (filename && (lastfile == 0 || strcmp (filename, lastfile)))
{
#ifdef DBX_OUTPUT_SOURCE_FILENAME
DBX_OUTPUT_SOURCE_FILENAME (file, filename);
#else
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)
;
else
text_section ();
ASM_OUTPUT_INTERNAL_LABEL (file, "Ltext", source_label_number);
source_label_number++;
#endif
lastfile = filename;
}
}
static void
dbxout_source_line (lineno, filename)
unsigned int lineno;
const char *filename;
{
dbxout_source_file (asmfile, filename);
#ifdef ASM_OUTPUT_SOURCE_LINE
ASM_OUTPUT_SOURCE_LINE (asmfile, lineno);
#else
fprintf (asmfile, "%s%d,0,%d\n", ASM_STABD_OP, N_SLINE, lineno);
#endif
}
static void
dbxout_begin_block (line, n)
unsigned int line ATTRIBUTE_UNUSED;
unsigned int n;
{
ASM_OUTPUT_INTERNAL_LABEL (asmfile, "LBB", n);
}
static void
dbxout_end_block (line, n)
unsigned int line ATTRIBUTE_UNUSED;
unsigned int n;
{
ASM_OUTPUT_INTERNAL_LABEL (asmfile, "LBE", n);
}
static void
dbxout_function_decl (decl)
tree decl;
{
#ifndef DBX_FUNCTION_FIRST
dbxout_begin_function (decl);
#endif
dbxout_block (DECL_INITIAL (decl), 0, DECL_ARGUMENTS (decl));
#ifdef DBX_OUTPUT_FUNCTION_END
DBX_OUTPUT_FUNCTION_END (asmfile, decl);
#endif
if (use_gnu_debug_info_extensions
#if defined(NO_DBX_FUNCTION_END)
&& ! NO_DBX_FUNCTION_END
#endif
&& targetm.have_named_sections)
dbxout_function_end ();
}
#endif
static void
dbxout_global_decl (decl)
tree decl;
{
if (TREE_CODE (decl) == VAR_DECL
&& ! DECL_EXTERNAL (decl)
&& DECL_RTL_SET_P (decl))
#ifdef DBX_ONLY_USED_SYMBOLS
{
int saved_tree_used = TREE_USED (decl);
TREE_USED (decl) = 1;
dbxout_symbol (decl, 0);
TREE_USED (decl) = saved_tree_used;
}
#else
dbxout_symbol (decl, 0);
#endif
}
static void
dbxout_finish (filename)
const char *filename ATTRIBUTE_UNUSED;
{
#ifdef DBX_OUTPUT_MAIN_SOURCE_FILE_END
DBX_OUTPUT_MAIN_SOURCE_FILE_END (asmfile, filename);
#endif
#ifdef DBX_ONLY_USED_SYMBOLS
if (symbol_queue)
{
free (symbol_queue);
symbol_queue = NULL;
symbol_queue_size = 0;
}
#endif
}
static void
dbxout_type_index (type)
tree type;
{
#ifndef DBX_USE_BINCL
fprintf (asmfile, "%d", TYPE_SYMTAB_ADDRESS (type));
CHARS (3);
#else
struct typeinfo *t = &typevec[TYPE_SYMTAB_ADDRESS (type)];
fprintf (asmfile, "(%d,%d)", t->file_number, t->type_number);
CHARS (9);
#endif
}
#if DBX_CONTIN_LENGTH > 0
static void
dbxout_continue ()
{
#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
static void
dbxout_type_fields (type)
tree type;
{
tree tem;
for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
{
if (TREE_CODE (tem) == TYPE_DECL
|| (TREE_CODE (tem) == FIELD_DECL
&& (! host_integerp (bit_position (tem), 0)
|| ! DECL_SIZE (tem)
|| ! host_integerp (DECL_SIZE (tem), 1)))
|| DECL_IGNORED_P (tem))
continue;
else if (TREE_CODE (tem) != CONST_DECL)
{
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);
}
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);
}
dbxout_type ((TREE_CODE (tem) == FIELD_DECL
&& DECL_BIT_FIELD_TYPE (tem))
? DECL_BIT_FIELD_TYPE (tem) : TREE_TYPE (tem), 0);
if (TREE_CODE (tem) == VAR_DECL)
{
if (TREE_STATIC (tem) && use_gnu_debug_info_extensions)
{
tree name = DECL_ASSEMBLER_NAME (tem);
have_used_extensions = 1;
fprintf (asmfile, ":%s;", IDENTIFIER_POINTER (name));
CHARS (IDENTIFIER_LENGTH (name) + 2);
}
else
{
fprintf (asmfile, ",0,0;");
CHARS (5);
}
}
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);
}
}
}
}
static void
dbxout_type_method_1 (decl, debug_name)
tree decl;
const char *debug_name;
{
char c1 = 'A', c2;
if (TREE_CODE (TREE_TYPE (decl)) == FUNCTION_TYPE)
c2 = '?';
else
{
tree firstarg = TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)));
if (TYPE_READONLY (TREE_TYPE (firstarg)))
c1 += 1;
if (TYPE_VOLATILE (TREE_TYPE (firstarg)))
c1 += 2;
if (DECL_VINDEX (decl))
c2 = '*';
else
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))));
if (DECL_VINDEX (decl) && host_integerp (DECL_VINDEX (decl), 0))
{
print_wide_int (tree_low_cst (DECL_VINDEX (decl), 0));
putc (';', asmfile);
CHARS (1);
dbxout_type (DECL_CONTEXT (decl), 0);
fprintf (asmfile, ";");
CHARS (1);
}
}
static void
dbxout_type_methods (type)
tree type;
{
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
{
const char *ptr = IDENTIFIER_POINTER (type_encoding);
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)
fndecl = TREE_VEC_ELT (methods, 0);
else
fndecl = TREE_VEC_ELT (methods, 1);
while (fndecl)
{
int need_prefix = 1;
for (last = NULL_TREE;
fndecl && (last == NULL_TREE || DECL_NAME (fndecl) == DECL_NAME (last));
fndecl = TREE_CHAIN (fndecl))
{
const char *debug_name;
if (TREE_CODE (fndecl) != FUNCTION_DECL)
continue;
debug_name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl));
CONTIN;
last = fndecl;
if (DECL_IGNORED_P (fndecl) || DECL_ABSTRACT (fndecl))
continue;
if (need_prefix)
{
tree name = DECL_NAME (fndecl);
fprintf (asmfile, "%s::", IDENTIFIER_POINTER (name));
CHARS (IDENTIFIER_LENGTH (name) + 2);
need_prefix = 0;
}
dbxout_type (TREE_TYPE (fndecl), 0);
dbxout_type_method_1 (fndecl, debug_name);
}
if (!need_prefix)
{
putc (';', asmfile);
CHARS (1);
}
}
}
static void
dbxout_range_type (type)
tree type;
{
fprintf (asmfile, "r");
if (TREE_TYPE (type))
dbxout_type (TREE_TYPE (type), 0);
else if (TREE_CODE (type) != INTEGER_TYPE)
dbxout_type (type, 0);
else
{
if (TYPE_SYMTAB_ADDRESS (type) != 0)
dbxout_type_index (type);
else
dbxout_type_index (integer_type_node);
}
if (TYPE_MIN_VALUE (type) != 0
&& host_integerp (TYPE_MIN_VALUE (type), 0))
{
putc (';', asmfile);
CHARS (1);
print_wide_int (tree_low_cst (TYPE_MIN_VALUE (type), 0));
}
else
{
fprintf (asmfile, ";0");
CHARS (2);
}
if (TYPE_MAX_VALUE (type) != 0
&& host_integerp (TYPE_MAX_VALUE (type), 0))
{
putc (';', asmfile);
CHARS (1);
print_wide_int (tree_low_cst (TYPE_MAX_VALUE (type), 0));
putc (';', asmfile);
CHARS (1);
}
else
{
fprintf (asmfile, ";-1;");
CHARS (4);
}
}
#ifdef DBX_ONLY_USED_SYMBOLS
static void
dbxout_flush_symbol_queue ()
{
int i;
++dbxout_nesting;
for (i = 0; i < symbol_queue_index; ++i)
{
int saved_tree_used = TREE_USED (symbol_queue[i]);
int saved_suppress_debug = TYPE_DECL_SUPPRESS_DEBUG (symbol_queue[i]);
TREE_USED (symbol_queue[i]) = 1;
TYPE_DECL_SUPPRESS_DEBUG (symbol_queue[i]) = 0;
dbxout_symbol (symbol_queue[i], 0);
TREE_USED (symbol_queue[i]) = saved_tree_used;
TYPE_DECL_SUPPRESS_DEBUG (symbol_queue[i]) = saved_suppress_debug;
}
symbol_queue_index = 0;
--dbxout_nesting;
}
static void
dbxout_queue_symbol (decl)
tree decl;
{
if (symbol_queue_index >= symbol_queue_size)
{
symbol_queue_size += 10;
symbol_queue = (tree *) xrealloc (symbol_queue,
symbol_queue_size * sizeof (tree));
}
symbol_queue[symbol_queue_index++] = decl;
}
#endif
static void
dbxout_type (type, full)
tree type;
int full;
{
tree tem;
tree main_variant;
static int anonymous_type_number = 0;
if (TREE_CODE (type) == VECTOR_TYPE)
type = TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type)));
if (type == error_mark_node)
type = integer_type_node;
else
{
if (TYPE_NAME (type)
&& TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
&& TYPE_DECL_SUPPRESS_DEBUG (TYPE_NAME (type)))
full = 0;
}
if (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
&& DECL_ORIGINAL_TYPE (TYPE_NAME (type)))
main_variant = TREE_TYPE (TYPE_NAME (type));
else
main_variant = TYPE_MAIN_VARIANT (type);
if (!use_gnu_debug_info_extensions)
type = main_variant;
if (TYPE_SYMTAB_ADDRESS (type) == 0)
{
TYPE_SYMTAB_ADDRESS (type) = next_type_number++;
if (next_type_number == typevec_len)
{
typevec
= (struct typeinfo *) xrealloc (typevec,
typevec_len * 2 * sizeof typevec[0]);
memset ((char *) (typevec + typevec_len), 0,
typevec_len * sizeof typevec[0]);
typevec_len *= 2;
}
#ifdef DBX_USE_BINCL
typevec[TYPE_SYMTAB_ADDRESS (type)].file_number
= current_file->file_number;
typevec[TYPE_SYMTAB_ADDRESS (type)].type_number
= current_file->next_type_number++;
#endif
#ifdef DBX_ONLY_USED_SYMBOLS
if (flag_debug_only_used_symbols)
{
if ((TREE_CODE (type) == RECORD_TYPE
|| TREE_CODE (type) == UNION_TYPE
|| TREE_CODE (type) == QUAL_UNION_TYPE
|| TREE_CODE (type) == ENUMERAL_TYPE)
&& TYPE_STUB_DECL (type)
&& TREE_CODE_CLASS (TREE_CODE (TYPE_STUB_DECL (type))) == 'd'
&& ! DECL_IGNORED_P (TYPE_STUB_DECL (type)))
dbxout_queue_symbol (TYPE_STUB_DECL (type));
else if (TYPE_NAME (type)
&& TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
dbxout_queue_symbol (TYPE_NAME (type));
}
#endif
}
dbxout_type_index (type);
#ifdef DBX_TYPE_DEFINED
if (DBX_TYPE_DEFINED (type))
return;
#endif
switch (typevec[TYPE_SYMTAB_ADDRESS (type)].status)
{
case TYPE_UNSEEN:
break;
case TYPE_XREF:
if (! full || !COMPLETE_TYPE_P (type)
|| ! host_integerp (TYPE_SIZE (type), 1))
return;
break;
case TYPE_DEFINED:
return;
}
#ifdef DBX_NO_XREFS
if ((TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE
|| TREE_CODE (type) == QUAL_UNION_TYPE
|| TREE_CODE (type) == ENUMERAL_TYPE)
&& ! use_gnu_debug_info_extensions)
if ((TYPE_NAME (type) != 0
&& ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
&& DECL_IGNORED_P (TYPE_NAME (type)))
&& !full)
|| !COMPLETE_TYPE_P (type)
|| ! host_integerp (TYPE_SIZE (type), 1))
{
typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
return;
}
#endif
fprintf (asmfile, "=");
CHARS (1);
typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_DEFINED;
if (TYPE_READONLY (type) > TYPE_READONLY (main_variant))
{
putc ('k', asmfile);
CHARS (1);
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);
dbxout_type (build_type_variant (type, TYPE_READONLY (type), 0), 0);
return;
}
else if (main_variant != TYPE_MAIN_VARIANT (type))
{
#ifdef DBX_ONLY_USED_SYMBOLS
if (flag_debug_only_used_symbols)
{
tree orig_type = DECL_ORIGINAL_TYPE (TYPE_NAME (type));
if ((TREE_CODE (orig_type) == RECORD_TYPE
|| TREE_CODE (orig_type) == UNION_TYPE
|| TREE_CODE (orig_type) == QUAL_UNION_TYPE
|| TREE_CODE (orig_type) == ENUMERAL_TYPE)
&& TYPE_STUB_DECL (orig_type)
&& ! DECL_IGNORED_P (TYPE_STUB_DECL (orig_type)))
dbxout_queue_symbol (TYPE_STUB_DECL (orig_type));
}
#endif
dbxout_type (DECL_ORIGINAL_TYPE (TYPE_NAME (type)), 0);
return;
}
switch (TREE_CODE (type))
{
case VOID_TYPE:
case LANG_TYPE:
dbxout_type_index (type);
break;
case INTEGER_TYPE:
if (type == char_type_node && ! TREE_UNSIGNED (type))
{
fprintf (asmfile, "r");
CHARS (1);
dbxout_type_index (type);
fprintf (asmfile, ";0;127;");
CHARS (7);
}
else if (TREE_TYPE (type) != 0
&& TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE)
dbxout_range_type (type);
else
{
if (use_gnu_debug_info_extensions
&& TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
{
have_used_extensions = 1;
fprintf (asmfile, "@s%d;", TYPE_PRECISION (type));
CHARS (5);
}
if (use_gnu_debug_info_extensions
&& TYPE_MIN_VALUE (type) != 0
&& TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST
&& TYPE_MAX_VALUE (type) != 0
&& TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST
&& (TYPE_PRECISION (type) > TYPE_PRECISION (integer_type_node)
|| ((TYPE_PRECISION (type)
== TYPE_PRECISION (integer_type_node))
&& TREE_UNSIGNED (type))
|| TYPE_PRECISION (type) > HOST_BITS_PER_WIDE_INT
|| (TYPE_PRECISION (type) == HOST_BITS_PER_WIDE_INT
&& TREE_UNSIGNED (type))))
{
fprintf (asmfile, "r");
CHARS (1);
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);
}
else
dbxout_range_type (type);
}
break;
case REAL_TYPE:
fprintf (asmfile, "r");
CHARS (1);
dbxout_type_index (integer_type_node);
putc (';', asmfile);
CHARS (1);
print_wide_int (int_size_in_bytes (type));
fputs (";0;", asmfile);
CHARS (3);
break;
case CHAR_TYPE:
if (use_gnu_debug_info_extensions)
{
have_used_extensions = 1;
fputs ("@s", asmfile);
CHARS (2);
print_wide_int (BITS_PER_UNIT * int_size_in_bytes (type));
fputs (";-20;", asmfile);
CHARS (4);
}
else
{
fprintf (asmfile, "r");
CHARS (1);
dbxout_type_index (char_type_node);
fprintf (asmfile, ";0;%d;", TREE_UNSIGNED (type) ? 255 : 127);
CHARS (7);
}
break;
case BOOLEAN_TYPE:
if (use_gnu_debug_info_extensions)
{
have_used_extensions = 1;
fputs ("@s", asmfile);
CHARS (2);
print_wide_int (BITS_PER_UNIT * int_size_in_bytes (type));
fputs (";-16;", asmfile);
CHARS (4);
}
else
{
fprintf (asmfile, "eFalse:0,True:1,;");
CHARS (17);
}
break;
case FILE_TYPE:
putc ('d', asmfile);
CHARS (1);
dbxout_type (TREE_TYPE (type), 0);
break;
case COMPLEX_TYPE:
if (TREE_CODE (TREE_TYPE (type)) == REAL_TYPE)
{
fprintf (asmfile, "r");
CHARS (1);
dbxout_type_index (type);
putc (';', asmfile);
CHARS (1);
print_wide_int (2 * int_size_in_bytes (TREE_TYPE (type)));
fputs (";0;", asmfile);
CHARS (3);
}
else
{
putc ('s', asmfile);
CHARS (1);
print_wide_int (int_size_in_bytes (type));
fprintf (asmfile, "real:");
CHARS (5);
dbxout_type (TREE_TYPE (type), 0);
fprintf (asmfile, ",0,%d;", TYPE_PRECISION (TREE_TYPE (type)));
CHARS (7);
fprintf (asmfile, "imag:");
CHARS (5);
dbxout_type (TREE_TYPE (type), 0);
fprintf (asmfile, ",%d,%d;;", TYPE_PRECISION (TREE_TYPE (type)),
TYPE_PRECISION (TREE_TYPE (type)));
CHARS (10);
}
break;
case SET_TYPE:
if (use_gnu_debug_info_extensions)
{
have_used_extensions = 1;
fputs ("@s", asmfile);
CHARS (2);
print_wide_int (BITS_PER_UNIT * int_size_in_bytes (type));
putc (';', asmfile);
CHARS (1);
if (TYPE_STRING_FLAG (type))
{
fprintf (asmfile, "@S;");
CHARS (3);
}
}
putc ('S', asmfile);
CHARS (1);
dbxout_type (TYPE_DOMAIN (type), 0);
break;
case ARRAY_TYPE:
if (TYPE_PACKED (type) && use_gnu_debug_info_extensions)
{
have_used_extensions = 1;
fputs ("@s", asmfile);
CHARS (2);
print_wide_int (BITS_PER_UNIT * int_size_in_bytes (type));
fprintf (asmfile, ";@S;S");
CHARS (5);
dbxout_type (TYPE_DOMAIN (type), 0);
break;
}
if (TYPE_STRING_FLAG (type) && use_gnu_debug_info_extensions)
{
have_used_extensions = 1;
fprintf (asmfile, "@S;");
CHARS (3);
}
tem = TYPE_DOMAIN (type);
if (tem == NULL)
{
fprintf (asmfile, "ar");
CHARS (2);
dbxout_type_index (integer_type_node);
fprintf (asmfile, ";0;-1;");
CHARS (6);
}
else
{
fprintf (asmfile, "a");
CHARS (1);
dbxout_range_type (tem);
}
dbxout_type (TREE_TYPE (type), 0);
break;
case RECORD_TYPE:
case UNION_TYPE:
case QUAL_UNION_TYPE:
{
int i, n_baseclasses = 0;
if (TYPE_BINFO (type) != 0
&& TREE_CODE (TYPE_BINFO (type)) == TREE_VEC
&& TYPE_BINFO_BASETYPES (type) != 0)
n_baseclasses = TREE_VEC_LENGTH (TYPE_BINFO_BASETYPES (type));
if ((TYPE_NAME (type) != 0
&& ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
&& DECL_IGNORED_P (TYPE_NAME (type)))
&& !full)
|| !COMPLETE_TYPE_P (type)
|| ! host_integerp (TYPE_SIZE (type), 1))
{
fputs ((TREE_CODE (type) == RECORD_TYPE) ? "xs" : "xu", asmfile);
CHARS (2);
#if 0
if (TREE_CODE (TYPE_NAME (type)) != IDENTIFIER_NODE)
abort ();
#endif
if (TYPE_NAME (type) != 0)
dbxout_type_name (type);
else
{
fprintf (asmfile, "$$%d", anonymous_type_number++);
CHARS (5);
}
fprintf (asmfile, ":");
CHARS (1);
typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
break;
}
putc (((TREE_CODE (type) == RECORD_TYPE) ? 's' : 'u'), asmfile);
CHARS (1);
print_wide_int (int_size_in_bytes (type));
if (use_gnu_debug_info_extensions)
{
if (n_baseclasses)
{
have_used_extensions = 1;
fprintf (asmfile, "!%d,", n_baseclasses);
CHARS (8);
}
}
for (i = 0; i < n_baseclasses; i++)
{
tree child = TREE_VEC_ELT (BINFO_BASETYPES (TYPE_BINFO (type)), i);
if (use_gnu_debug_info_extensions)
{
have_used_extensions = 1;
putc (TREE_VIA_VIRTUAL (child) ? '1' : '0', asmfile);
putc (TREE_VIA_PUBLIC (child) ? '2' : '0', asmfile);
CHARS (2);
if (TREE_VIA_VIRTUAL (child) && strcmp (lang_hooks.name, "GNU C++") == 0)
print_wide_int (tree_low_cst (BINFO_VPTR_FIELD (child), 0)
* BITS_PER_UNIT);
else
print_wide_int (tree_low_cst (BINFO_OFFSET (child), 0)
* BITS_PER_UNIT);
putc (',', asmfile);
CHARS (1);
dbxout_type (BINFO_TYPE (child), 0);
putc (';', asmfile);
CHARS (1);
}
else
{
dbxout_type_name (BINFO_TYPE (child));
putc (':', asmfile);
CHARS (1);
dbxout_type (BINFO_TYPE (child), full);
putc (',', asmfile);
CHARS (1);
print_wide_int (tree_low_cst (BINFO_OFFSET (child), 0)
* BITS_PER_UNIT);
putc (',', asmfile);
CHARS (1);
print_wide_int (tree_low_cst (DECL_SIZE
(TYPE_NAME
(BINFO_TYPE (child))),
0)
* BITS_PER_UNIT);
putc (';', asmfile);
CHARS (1);
}
}
}
dbxout_type_fields (type);
if (use_gnu_debug_info_extensions && TYPE_METHODS (type) != NULL_TREE)
{
have_used_extensions = 1;
dbxout_type_methods (type);
}
putc (';', asmfile);
CHARS (1);
if (use_gnu_debug_info_extensions && TREE_CODE (type) == RECORD_TYPE
&& TYPE_VFIELD (type))
{
have_used_extensions = 1;
putc ('~', asmfile);
CHARS (1);
if (TYPE_VFIELD (type))
{
putc ('%', asmfile);
CHARS (1);
dbxout_type (DECL_FCONTEXT (TYPE_VFIELD (type)), 0);
}
putc (';', asmfile);
CHARS (1);
}
break;
case ENUMERAL_TYPE:
if ((TYPE_NAME (type) != 0
&& ! (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
&& DECL_IGNORED_P (TYPE_NAME (type)))
&& !full)
|| !COMPLETE_TYPE_P (type))
{
fprintf (asmfile, "xe");
CHARS (2);
dbxout_type_name (type);
typevec[TYPE_SYMTAB_ADDRESS (type)].status = TYPE_XREF;
putc (':', asmfile);
CHARS (1);
return;
}
#ifdef DBX_OUTPUT_ENUM
DBX_OUTPUT_ENUM (asmfile, type);
#else
if (use_gnu_debug_info_extensions
&& TYPE_PRECISION (type) != TYPE_PRECISION (integer_type_node))
{
fprintf (asmfile, "@s%d;", TYPE_PRECISION (type));
CHARS (5);
}
putc ('e', asmfile);
CHARS (1);
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);
if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == 0)
print_wide_int (TREE_INT_CST_LOW (TREE_VALUE (tem)));
else if (TREE_INT_CST_HIGH (TREE_VALUE (tem)) == -1
&& (HOST_WIDE_INT) TREE_INT_CST_LOW (TREE_VALUE (tem)) < 0)
print_wide_int (TREE_INT_CST_LOW (TREE_VALUE (tem)));
else
print_int_cst_octal (TREE_VALUE (tem));
putc (',', asmfile);
CHARS (1);
if (TREE_CHAIN (tem) != 0)
CONTIN;
}
putc (';', asmfile);
CHARS (1);
#endif
break;
case POINTER_TYPE:
putc ('*', asmfile);
CHARS (1);
dbxout_type (TREE_TYPE (type), 0);
break;
case METHOD_TYPE:
if (use_gnu_debug_info_extensions)
{
have_used_extensions = 1;
putc ('#', asmfile);
CHARS (1);
dbxout_type (TYPE_METHOD_BASETYPE (type), 0);
putc (',', asmfile);
CHARS (1);
dbxout_type (TREE_TYPE (type), 0);
dbxout_args (TYPE_ARG_TYPES (type));
putc (';', asmfile);
CHARS (1);
}
else
dbxout_type (TREE_TYPE (type), 0);
break;
case OFFSET_TYPE:
if (use_gnu_debug_info_extensions)
{
have_used_extensions = 1;
putc ('@', asmfile);
CHARS (1);
dbxout_type (TYPE_OFFSET_BASETYPE (type), 0);
putc (',', asmfile);
CHARS (1);
dbxout_type (TREE_TYPE (type), 0);
}
else
dbxout_type (integer_type_node, 0);
break;
case REFERENCE_TYPE:
if (use_gnu_debug_info_extensions)
have_used_extensions = 1;
putc (use_gnu_debug_info_extensions ? '&' : '*', asmfile);
CHARS (1);
dbxout_type (TREE_TYPE (type), 0);
break;
case FUNCTION_TYPE:
putc ('f', asmfile);
CHARS (1);
dbxout_type (TREE_TYPE (type), 0);
break;
default:
abort ();
}
}
static void
print_int_cst_octal (c)
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));
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 (value, digits)
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);
}
static void
print_wide_int (c)
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);
}
static void
dbxout_type_name (type)
tree type;
{
tree t;
if (TYPE_NAME (type) == 0)
abort ();
if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
{
t = TYPE_NAME (type);
}
else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL)
{
t = DECL_NAME (TYPE_NAME (type));
}
else
abort ();
fprintf (asmfile, "%s", IDENTIFIER_POINTER (t));
CHARS (IDENTIFIER_LENGTH (t));
}
int
dbxout_symbol (decl, local)
tree decl;
int local ATTRIBUTE_UNUSED;
{
tree type = TREE_TYPE (decl);
tree context = NULL_TREE;
int result = 0;
#ifdef DBXOUT_TRACK_NESTING
++dbxout_nesting;
DBXOUT_SAVE_ARGUMENTS (DBXOUT_SYMBOL, decl, local);
if (pfe_operation == PFE_DUMP)
DBXOUT_DECR_NESTING_AND_RETURN (0);
#endif
current_sym_code = (STAB_CODE_TYPE) 0;
current_sym_value = 0;
current_sym_addr = 0;
if ((DECL_NAME (decl) == 0 && TREE_CODE (decl) != TYPE_DECL)
|| DECL_IGNORED_P (decl))
DBXOUT_DECR_NESTING_AND_RETURN (0);
#ifdef DBX_ONLY_USED_SYMBOLS
if (flag_debug_only_used_symbols)
{
tree t;
if (!TREE_USED (decl))
DBXOUT_DECR_NESTING_AND_RETURN (0);
t = type;
while (POINTER_TYPE_P (t))
t = TREE_TYPE (t);
if ((TREE_CODE (t) == RECORD_TYPE
|| TREE_CODE (t) == UNION_TYPE
|| TREE_CODE (t) == QUAL_UNION_TYPE
|| TREE_CODE (t) == ENUMERAL_TYPE)
&& TYPE_STUB_DECL (t)
&& TYPE_STUB_DECL (t) != decl
&& TREE_CODE_CLASS (TREE_CODE (TYPE_STUB_DECL (t))) == 'd'
&& ! DECL_IGNORED_P (TYPE_STUB_DECL (t)))
{
dbxout_queue_symbol (TYPE_STUB_DECL (t));
if (TYPE_NAME (t)
&& TYPE_NAME (t) != TYPE_STUB_DECL (t)
&& TYPE_NAME (t) != decl
&& TREE_CODE_CLASS (TREE_CODE (TYPE_NAME (t))) == 'd')
dbxout_queue_symbol (TYPE_NAME (t));
}
else if (TYPE_NAME (t)
&& TYPE_NAME (t) != decl
&& TREE_CODE_CLASS (TREE_CODE (TYPE_NAME (t))) == 'd')
dbxout_queue_symbol (TYPE_NAME (t));
}
#endif
dbxout_prepare_symbol (decl);
if (DECL_NAME (decl) != 0)
current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (decl));
switch (TREE_CODE (decl))
{
case CONST_DECL:
break;
case FUNCTION_DECL:
if (DECL_RTL (decl) == 0)
DBXOUT_DECR_NESTING_AND_RETURN (0);
if (DECL_EXTERNAL (decl))
break;
context = decl_function_context (decl);
if (context == current_function_decl)
break;
if (GET_CODE (DECL_RTL (decl)) != MEM
|| 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');
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
dbxout_type (void_type_node, 0);
if (context != 0)
fprintf (asmfile, ",%s,%s",
IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
IDENTIFIER_POINTER (DECL_NAME (context)));
dbxout_finish_symbol (decl);
break;
case TYPE_DECL:
#if 0
if (typevec[TYPE_SYMTAB_ADDRESS (type)].status == TYPE_DEFINED
&& TYPE_NAME (TREE_TYPE (decl)) == decl)
DBXOUT_DECR_NESTING_AND_RETURN (0);
#endif
if (TREE_ASM_WRITTEN (decl) || TYPE_DECL_SUPPRESS_DEBUG (decl))
DBXOUT_DECR_NESTING_AND_RETURN (0);
FORCE_TEXT;
result = 1;
{
int tag_needed = 1;
int did_output = 0;
if (DECL_NAME (decl))
{
tag_needed = 0;
if ((TREE_CODE (type) == RECORD_TYPE
|| TREE_CODE (type) == UNION_TYPE
|| TREE_CODE (type) == QUAL_UNION_TYPE)
&& TYPE_NAME (type) == decl
&& !(use_gnu_debug_info_extensions && have_used_extensions)
&& !TREE_ASM_WRITTEN (TYPE_NAME (type))
&& DECL_ARTIFICIAL (decl)
#ifdef DBX_ONLY_USED_SYMBOLS
&& COMPLETE_TYPE_P (type)
#endif
&& host_integerp (TYPE_SIZE (type), 1))
{
tree name = TYPE_NAME (type);
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_type (type, 1);
dbxout_finish_symbol (NULL_TREE);
}
fprintf (asmfile, "%s\"%s:", ASM_STABS_OP,
IDENTIFIER_POINTER (DECL_NAME (decl)));
if ((TREE_CODE (type) == RECORD_TYPE
|| TREE_CODE (type) == UNION_TYPE
|| TREE_CODE (type) == QUAL_UNION_TYPE)
&& TYPE_NAME (type) == decl
&& DECL_ARTIFICIAL (decl))
{
if (use_gnu_debug_info_extensions && have_used_extensions)
{
putc ('T', asmfile);
TREE_ASM_WRITTEN (TYPE_NAME (type)) = 1;
}
#if 0
else
tag_needed = 1;
#endif
}
putc ('t', asmfile);
current_sym_code = DBX_TYPE_DECL_STABS_CODE;
dbxout_type (type, 1);
dbxout_finish_symbol (decl);
did_output = 1;
}
if (tag_needed && TYPE_NAME (type) != 0
&& (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE
|| (DECL_NAME (TYPE_NAME (type)) != 0))
&& COMPLETE_TYPE_P (type)
&& !TREE_ASM_WRITTEN (TYPE_NAME (type)))
{
tree name = TYPE_NAME (type);
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_type (type, 1);
dbxout_finish_symbol (NULL_TREE);
did_output = 1;
}
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;
fprintf (asmfile, "%s\" :T", ASM_STABS_OP);
dbxout_type (type, 1);
dbxout_finish_symbol (NULL_TREE);
}
TREE_ASM_WRITTEN (decl) = 1;
break;
}
case PARM_DECL:
abort ();
case RESULT_DECL:
case VAR_DECL:
if (! DECL_RTL_SET_P (decl))
DBXOUT_DECR_NESTING_AND_RETURN (0);
if (DECL_EXTERNAL (decl))
break;
if (TREE_STATIC (decl) && TREE_READONLY (decl)
&& DECL_INITIAL (decl) != 0
&& host_integerp (DECL_INITIAL (decl), 0)
&& ! TREE_ASM_WRITTEN (decl)
&& (DECL_CONTEXT (decl) == NULL_TREE
|| TREE_CODE (DECL_CONTEXT (decl)) == BLOCK))
{
if (TREE_PUBLIC (decl) == 0)
{
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);
#ifdef DBX_OUTPUT_CONSTANT_SYMBOL
DBX_OUTPUT_CONSTANT_SYMBOL (asmfile, name, ival);
#else
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
DBXOUT_DECR_NESTING;
return 1;
}
else if (TREE_CODE (TREE_TYPE (decl)) == REAL_TYPE)
{
}
break;
}
}
SET_DECL_RTL (decl, eliminate_regs (DECL_RTL (decl), 0, NULL_RTX));
#ifdef LEAF_REG_REMAP
if (current_function_uses_only_leaf_regs)
leaf_renumber_regs_insn (DECL_RTL (decl));
#endif
result = dbxout_symbol_location (decl, type, 0, DECL_RTL (decl));
break;
default:
break;
}
DBXOUT_DECR_NESTING;
return result;
}
static int
dbxout_symbol_location (decl, type, suffix, home)
tree decl, type;
const char *suffix;
rtx home;
{
int letter = 0;
int regno = -1;
if (GET_CODE (home) == SUBREG)
{
rtx value = home;
while (GET_CODE (value) == SUBREG)
value = SUBREG_REG (value);
if (GET_CODE (value) == REG)
{
if (REGNO (value) >= FIRST_PSEUDO_REGISTER)
return 0;
}
home = alter_subreg (&home);
}
if (GET_CODE (home) == REG)
{
regno = REGNO (home);
if (regno >= FIRST_PSEUDO_REGISTER)
return 0;
}
if (GET_CODE (home) == MEM
&& GET_CODE (XEXP (home, 0)) == SYMBOL_REF)
{
if (TREE_PUBLIC (decl))
{
letter = 'G';
current_sym_code = N_GSYM;
}
else
{
current_sym_addr = XEXP (home, 0);
letter = decl_function_context (decl) ? 'V' : 'S';
if (DECL_INITIAL (decl) == 0
|| (!strcmp (lang_hooks.name, "GNU C++")
&& DECL_INITIAL (decl) == error_mark_node))
current_sym_code = N_LCSYM;
else if (DECL_IN_TEXT_SECTION (decl))
current_sym_code = DBX_STATIC_CONST_VAR_CODE;
else
{
if (GET_CODE (current_sym_addr) == SYMBOL_REF
&& CONSTANT_POOL_ADDRESS_P (current_sym_addr))
{
rtx tmp = get_pool_constant (current_sym_addr);
if (GET_CODE (tmp) == SYMBOL_REF
|| GET_CODE (tmp) == LABEL_REF)
current_sym_addr = tmp;
}
#ifdef DBX_STATIC_STAB_DATA_SECTION
data_section ();
#endif
current_sym_code = N_STSYM;
}
}
}
else if (regno >= 0)
{
letter = 'r';
current_sym_code = N_RSYM;
current_sym_value = DBX_REGISTER_NUMBER (regno);
}
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)) != STACK_POINTER_REGNUM
#if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
&& REGNO (XEXP (home, 0)) != ARG_POINTER_REGNUM
#endif
)))
{
if (GET_CODE (XEXP (home, 0)) == REG)
{
letter = 'r';
current_sym_code = N_RSYM;
if (REGNO (XEXP (home, 0)) >= FIRST_PSEUDO_REGISTER)
return 0;
current_sym_value = DBX_REGISTER_NUMBER (REGNO (XEXP (home, 0)));
}
else
{
current_sym_code = N_LSYM;
current_sym_value
= DEBUGGER_AUTO_OFFSET (XEXP (XEXP (home, 0), 0));
}
type = make_node (POINTER_TYPE);
TREE_TYPE (type) = TREE_TYPE (decl);
}
else if (GET_CODE (home) == MEM
&& GET_CODE (XEXP (home, 0)) == REG)
{
current_sym_code = N_LSYM;
current_sym_value = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
}
else if (GET_CODE (home) == MEM
&& GET_CODE (XEXP (home, 0)) == PLUS
&& GET_CODE (XEXP (XEXP (home, 0), 1)) == CONST_INT)
{
current_sym_code = N_LSYM;
current_sym_value = DEBUGGER_AUTO_OFFSET (XEXP (home, 0));
}
else if (GET_CODE (home) == MEM
&& GET_CODE (XEXP (home, 0)) == CONST)
{
current_sym_code = N_LCSYM;
letter = 'V';
current_sym_addr = XEXP (XEXP (home, 0), 0);
}
else if (GET_CODE (home) == CONCAT)
{
tree subtype;
if (TREE_CODE (type) != COMPLEX_TYPE)
return 0;
subtype = TREE_TYPE (type);
if (WORDS_BIG_ENDIAN)
dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 0));
else
dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 0));
current_sym_code = (STAB_CODE_TYPE) 0;
current_sym_value = 0;
current_sym_addr = 0;
dbxout_prepare_symbol (decl);
if (WORDS_BIG_ENDIAN)
dbxout_symbol_location (decl, subtype, "$real", XEXP (home, 1));
else
dbxout_symbol_location (decl, subtype, "$imag", XEXP (home, 1));
return 1;
}
else
return 0;
FORCE_TEXT;
#ifdef DBX_STATIC_BLOCK_START
DBX_STATIC_BLOCK_START (asmfile, current_sym_code);
#endif
dbxout_symbol_name (decl, suffix, letter);
dbxout_type (type, 0);
dbxout_finish_symbol (decl);
#ifdef DBX_STATIC_BLOCK_END
DBX_STATIC_BLOCK_END (asmfile, current_sym_code);
#endif
return 1;
}
static void
dbxout_symbol_name (decl, suffix, letter)
tree decl;
const char *suffix;
int letter;
{
const char *name;
if (DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl)))
name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
else
name = IDENTIFIER_POINTER (DECL_NAME (decl));
if (name == 0)
name = "(anon)";
fprintf (asmfile, "%s\"%s%s:", ASM_STABS_OP, name,
(suffix ? suffix : ""));
if (letter)
putc (letter, asmfile);
}
static void
dbxout_prepare_symbol (decl)
tree decl ATTRIBUTE_UNUSED;
{
#ifdef WINNING_GDB
const char *filename = DECL_SOURCE_FILE (decl);
dbxout_source_file (asmfile, filename);
#endif
}
static void
dbxout_finish_symbol (sym)
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
}
int
dbxout_syms (syms)
tree syms;
{
int result = 0;
while (syms)
{
result += dbxout_symbol (syms, 1);
syms = TREE_CHAIN (syms);
}
return result;
}
void
dbxout_parms (parms)
tree parms;
{
#ifdef DBXOUT_TRACK_NESTING
++dbxout_nesting;
DBXOUT_SAVE_ARGUMENTS (DBXOUT_PARMS, parms);
#endif
for (; parms; parms = TREE_CHAIN (parms))
if (DECL_NAME (parms) && TREE_TYPE (parms) != error_mark_node)
{
dbxout_prepare_symbol (parms);
DECL_INCOMING_RTL (parms)
= eliminate_regs (DECL_INCOMING_RTL (parms), 0, NULL_RTX);
SET_DECL_RTL (parms, eliminate_regs (DECL_RTL (parms), 0, NULL_RTX));
#ifdef LEAF_REG_REMAP
if (current_function_uses_only_leaf_regs)
{
leaf_renumber_regs_insn (DECL_INCOMING_RTL (parms));
leaf_renumber_regs_insn (DECL_RTL (parms));
}
#endif
if (PARM_PASSED_IN_MEMORY (parms))
{
rtx addr = XEXP (DECL_INCOMING_RTL (parms), 0);
if (GET_CODE (addr) == PLUS
&& GET_CODE (XEXP (addr, 1)) == CONST_INT)
current_sym_value = INTVAL (XEXP (addr, 1));
else
current_sym_value = 0;
current_sym_code = N_PSYM;
current_sym_addr = 0;
FORCE_TEXT;
if (DECL_NAME (parms))
{
current_sym_nchars = 2 + IDENTIFIER_LENGTH (DECL_NAME (parms));
fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
IDENTIFIER_POINTER (DECL_NAME (parms)),
DBX_MEMPARM_STABS_LETTER);
}
else
{
current_sym_nchars = 8;
fprintf (asmfile, "%s\"(anon):%c", ASM_STABS_OP,
DBX_MEMPARM_STABS_LETTER);
}
dbxout_type (DECL_ARG_TYPE (parms), 0);
current_sym_value = DEBUGGER_ARG_OFFSET (current_sym_value, addr);
dbxout_finish_symbol (parms);
}
else if (GET_CODE (DECL_RTL (parms)) == REG)
{
rtx best_rtl;
char regparm_letter;
tree parm_type;
current_sym_code = DBX_REGPARM_STABS_CODE;
regparm_letter = DBX_REGPARM_STABS_LETTER;
current_sym_addr = 0;
if (REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
{
best_rtl = DECL_RTL (parms);
parm_type = TREE_TYPE (parms);
}
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);
}
else
{
current_sym_nchars = 8;
fprintf (asmfile, "%s\"(anon):%c", ASM_STABS_OP,
regparm_letter);
}
dbxout_type (parm_type, 0);
dbxout_finish_symbol (parms);
}
else if (GET_CODE (DECL_RTL (parms)) == MEM
&& GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG
&& REGNO (XEXP (DECL_RTL (parms), 0)) != HARD_FRAME_POINTER_REGNUM
&& REGNO (XEXP (DECL_RTL (parms), 0)) != STACK_POINTER_REGNUM
#if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
&& REGNO (XEXP (DECL_RTL (parms), 0)) != ARG_POINTER_REGNUM
#endif
)
{
char regparm_letter;
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;
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)));
fprintf (asmfile, "%s\"%s:%c", ASM_STABS_OP,
IDENTIFIER_POINTER (DECL_NAME (parms)),
regparm_letter);
}
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);
}
else if (GET_CODE (DECL_RTL (parms)) == MEM
&& GET_CODE (XEXP (DECL_RTL (parms), 0)) == MEM)
{
const char *const decl_name = (DECL_NAME (parms)
? IDENTIFIER_POINTER (DECL_NAME (parms))
: "(anon)");
if (GET_CODE (XEXP (XEXP (DECL_RTL (parms), 0), 0)) == REG)
current_sym_value = 0;
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);
}
else if (GET_CODE (DECL_RTL (parms)) == MEM
&& XEXP (DECL_RTL (parms), 0) != const0_rtx
&& ! CONSTANT_P (XEXP (DECL_RTL (parms), 0)))
{
current_sym_code = N_PSYM;
if (GET_CODE (XEXP (DECL_RTL (parms), 0)) == REG)
current_sym_value = 0;
else
current_sym_value
= INTVAL (XEXP (XEXP (DECL_RTL (parms), 0), 1));
current_sym_addr = 0;
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);
}
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_DECR_NESTING;
}
void
dbxout_reg_parms (parms)
tree parms;
{
#ifdef DBXOUT_TRACK_NESTING
++dbxout_nesting;
DBXOUT_SAVE_ARGUMENTS (DBXOUT_REG_PARMS, parms);
#endif
for (; parms; parms = TREE_CHAIN (parms))
if (DECL_NAME (parms) && PARM_PASSED_IN_MEMORY (parms))
{
dbxout_prepare_symbol (parms);
if (GET_CODE (DECL_RTL (parms)) == REG
&& REGNO (DECL_RTL (parms)) < FIRST_PSEUDO_REGISTER)
dbxout_symbol_location (parms, TREE_TYPE (parms),
0, DECL_RTL (parms));
else if (GET_CODE (DECL_RTL (parms)) == CONCAT)
dbxout_symbol_location (parms, TREE_TYPE (parms),
0, DECL_RTL (parms));
else if (GET_CODE (DECL_RTL (parms)) == MEM
&& ! rtx_equal_p (DECL_RTL (parms), DECL_INCOMING_RTL (parms)))
dbxout_symbol_location (parms, TREE_TYPE (parms),
0, DECL_RTL (parms));
}
DBXOUT_DECR_NESTING;
}
static void
dbxout_args (args)
tree args;
{
while (args)
{
putc (',', asmfile);
dbxout_type (TREE_VALUE (args), 0);
CHARS (1);
args = TREE_CHAIN (args);
}
}
static void
dbxout_block (block, depth, args)
tree block;
int depth;
tree args;
{
int blocknum = -1;
#if DBX_BLOCKS_FUNCTION_RELATIVE
const char *begin_label;
if (current_function_func_begin_label != NULL_TREE)
begin_label = IDENTIFIER_POINTER (current_function_func_begin_label);
else
begin_label = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0);
#endif
while (block)
{
if (TREE_USED (block) && TREE_ASM_WRITTEN (block))
{
int did_output;
#ifdef DBX_LBRAC_FIRST
did_output = 1;
#else
did_output = 0;
if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
did_output = dbxout_syms (BLOCK_VARS (block));
if (args)
dbxout_reg_parms (args);
#endif
if (depth > 0 && did_output)
{
char buf[20];
blocknum = BLOCK_NUMBER (block);
ASM_GENERATE_INTERNAL_LABEL (buf, "LBB", blocknum);
if (BLOCK_HANDLER_BLOCK (block))
{
tree decl = BLOCK_VARS (block);
while (decl)
{
#ifdef DBX_OUTPUT_CATCH
DBX_OUTPUT_CATCH (asmfile, decl, buf);
#else
fprintf (asmfile, "%s\"%s:C1\",%d,0,0,", ASM_STABS_OP,
IDENTIFIER_POINTER (DECL_NAME (decl)), N_CATCH);
assemble_name (asmfile, buf);
fprintf (asmfile, "\n");
#endif
decl = TREE_CHAIN (decl);
}
}
#ifdef DBX_OUTPUT_LBRAC
DBX_OUTPUT_LBRAC (asmfile, buf);
#else
fprintf (asmfile, "%s%d,0,0,", ASM_STABN_OP, N_LBRAC);
assemble_name (asmfile, buf);
#if DBX_BLOCKS_FUNCTION_RELATIVE
putc ('-', asmfile);
assemble_name (asmfile, begin_label);
#endif
fprintf (asmfile, "\n");
#endif
}
#ifdef DBX_LBRAC_FIRST
if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
dbxout_syms (BLOCK_VARS (block));
if (args)
dbxout_reg_parms (args);
#endif
dbxout_block (BLOCK_SUBBLOCKS (block), depth + 1, NULL_TREE);
if (depth > 0 && did_output)
{
char buf[20];
ASM_GENERATE_INTERNAL_LABEL (buf, "LBE", blocknum);
#ifdef DBX_OUTPUT_RBRAC
DBX_OUTPUT_RBRAC (asmfile, buf);
#else
fprintf (asmfile, "%s%d,0,0,", ASM_STABN_OP, N_RBRAC);
assemble_name (asmfile, buf);
#if DBX_BLOCKS_FUNCTION_RELATIVE
putc ('-', asmfile);
assemble_name (asmfile, begin_label);
#endif
fprintf (asmfile, "\n");
#endif
}
}
block = BLOCK_CHAIN (block);
}
}
#if defined (DBX_DEBUGGING_INFO)
static void
dbxout_begin_function (decl)
tree decl;
{
#ifdef DBX_ONLY_USED_SYMBOLS
int saved_tree_used1 = TREE_USED (decl);
TREE_USED (decl) = 1;
if (DECL_NAME (DECL_RESULT (decl)) != 0)
{
int saved_tree_used2 = TREE_USED (DECL_RESULT (decl));
TREE_USED (DECL_RESULT (decl)) = 1;
dbxout_symbol (decl, 0);
TREE_USED (DECL_RESULT (decl)) = saved_tree_used2;
}
else
dbxout_symbol (decl, 0);
TREE_USED (decl) = saved_tree_used1;
#else
dbxout_symbol (decl, 0);
#endif
dbxout_parms (DECL_ARGUMENTS (decl));
if (DECL_NAME (DECL_RESULT (decl)) != 0)
#ifdef POSSIBLY_COMPILING_APPLE_KEXT_P
if (!(POSSIBLY_COMPILING_APPLE_KEXT_P ()
&& DECL_RESULT (decl) == DECL_ARGUMENTS (decl)))
#endif
dbxout_symbol (DECL_RESULT (decl), 1);
}
#endif
#endif
#ifdef PFE
void
pfe_freeze_thaw_dbxout (hdr)
pfe_compiler_state *hdr;
{
PFE_GLOBAL_TO_HDR_IF_FREEZING (dbxout_data_array_size);
PFE_HDR_TO_GLOBAL_IF_THAWING (dbxout_data_array_size);
PFE_GLOBAL_TO_HDR_IF_FREEZING (dbxout_data_array_next);
PFE_HDR_TO_GLOBAL_IF_THAWING (dbxout_data_array_next);
PFE_GLOBAL_TO_HDR_IF_FREEZING (dbxout_data_array);
freeze_thaw_dbxout_data_array (&hdr->dbxout_data_array);
PFE_HDR_TO_GLOBAL_IF_THAWING (dbxout_data_array);
}
static void
freeze_thaw_dbxout_data_array (dbxout_data_array_p)
struct dbxout_stabs_t **dbxout_data_array_p;
{
int i;
struct dbxout_stabs_t *dbxout_data_array;
dbxout_data_array = PFE_FREEZE_THAW_PTR (dbxout_data_array_p);
if (!dbxout_data_array)
return;
for (i = 0; i < dbxout_data_array_next; ++i)
{
switch (dbxout_data_array[i].code)
{
case DBXOUT_INIT:
case DBXOUT_FINISH:
pfe_freeze_thaw_ptr_fp (&dbxout_data_array[i].u.s);
break;
case DBXOUT_DEFINE:
case DBXOUT_UNDEF:
case DBXOUT_START_SOURCE_FILE:
case DBXOUT_SOURCE_LINE:
case DBXOUT_BEGIN_PROLOGUE:
pfe_freeze_thaw_ptr_fp (&dbxout_data_array[i].u.f.s);
break;
case DBXOUT_END_SOURCE_FILE:
case DBXOUT_END_PROLOGUE:
case DBXOUT_END_FUNCTION:
break;
case DBXOUT_BEGIN_BLOCK:
case DBXOUT_END_BLOCK:
break;
case DBXOUT_IGNORE_BLOCK:
case DBXOUT_BEGIN_FUNCTION:
case DBXOUT_FUNCTION_DECL:
case DBXOUT_GLOBAL_DECL:
case DBXOUT_DEFERRED_INLINE_FUNCTION:
case DBXOUT_OUTLINING_INLINE_FUNCTION:
PFE_FREEZE_THAW_WALK (dbxout_data_array[i].u.node);
break;
case DBXOUT_LABEL:
PFE_FREEZE_THAW_RTX (dbxout_data_array[i].u.insn);
break;
case DBXOUT_END_EPILOGUE:
break;
case DBXOUT_SYMBOL:
PFE_FREEZE_THAW_WALK (dbxout_data_array[i].u.sym.decl);
break;
case DBXOUT_PARMS:
case DBXOUT_REG_PARMS:
PFE_FREEZE_THAW_WALK (dbxout_data_array[i].u.node);
break;
default:
internal_error ("Invalid code (%d) detected by freeze_thaw_dbxout_data_array",
(int)dbxout_data_array[i].code);
}
}
}
void
dbxout_generate_loaded_stabs ()
{
int i;
for (i = 0; i < dbxout_data_array_next; ++i)
{
switch (dbxout_data_array[i].code)
{
case DBXOUT_INIT:
(*debug_hooks->init) (dbxout_data_array[i].u.s);
break;
case DBXOUT_FINISH:
(*debug_hooks->finish) (dbxout_data_array[i].u.s);
break;
case DBXOUT_DEFINE:
(*debug_hooks->define) (dbxout_data_array[i].u.f.line,
dbxout_data_array[i].u.f.s);
break;
case DBXOUT_UNDEF:
(*debug_hooks->undef) (dbxout_data_array[i].u.f.line,
dbxout_data_array[i].u.f.s);
break;
case DBXOUT_START_SOURCE_FILE:
(*debug_hooks->start_source_file) (dbxout_data_array[i].u.f.line,
dbxout_data_array[i].u.f.s);
break;
case DBXOUT_SOURCE_LINE:
(*debug_hooks->source_line) (dbxout_data_array[i].u.f.line,
dbxout_data_array[i].u.f.s);
break;
case DBXOUT_BEGIN_PROLOGUE:
(*debug_hooks->begin_prologue) (dbxout_data_array[i].u.f.line,
dbxout_data_array[i].u.f.s);
break;
case DBXOUT_END_SOURCE_FILE:
(*debug_hooks->end_source_file) (dbxout_data_array[i].u.line);
break;
case DBXOUT_END_PROLOGUE:
(*debug_hooks->end_prologue) (dbxout_data_array[i].u.line);
break;
case DBXOUT_END_FUNCTION:
(*debug_hooks->end_function) (dbxout_data_array[i].u.line);
break;
case DBXOUT_BEGIN_BLOCK:
(*debug_hooks->begin_block) (dbxout_data_array[i].u.b.line,
dbxout_data_array[i].u.b.n);
break;
case DBXOUT_END_BLOCK:
(*debug_hooks->end_block) (dbxout_data_array[i].u.b.line,
dbxout_data_array[i].u.b.n);
break;
case DBXOUT_IGNORE_BLOCK:
(*debug_hooks->ignore_block) (dbxout_data_array[i].u.node);
break;
case DBXOUT_BEGIN_FUNCTION:
(*debug_hooks->begin_function) (dbxout_data_array[i].u.node);
break;
case DBXOUT_FUNCTION_DECL:
(*debug_hooks->function_decl) (dbxout_data_array[i].u.node);
break;
case DBXOUT_GLOBAL_DECL:
(*debug_hooks->global_decl) (dbxout_data_array[i].u.node);
break;
case DBXOUT_DEFERRED_INLINE_FUNCTION:
(*debug_hooks->deferred_inline_function) (dbxout_data_array[i].u.node);
break;
case DBXOUT_OUTLINING_INLINE_FUNCTION:
(*debug_hooks->outlining_inline_function) (dbxout_data_array[i].u.node);
break;
case DBXOUT_LABEL:
(*debug_hooks->label) (dbxout_data_array[i].u.insn);
break;
case DBXOUT_END_EPILOGUE:
(*debug_hooks->end_epilogue) ();
break;
case DBXOUT_SYMBOL:
dbxout_symbol (dbxout_data_array[i].u.sym.decl,
dbxout_data_array[i].u.sym.local);
break;
case DBXOUT_PARMS:
dbxout_parms (dbxout_data_array[i].u.node);
break;
case DBXOUT_REG_PARMS:
dbxout_reg_parms (dbxout_data_array[i].u.node);
break;
default:
internal_error ("Invalid code (%d) detected by dbxout_generate_loaded_stabs",
(int)dbxout_data_array[i].code);
}
}
}
static void
dbxout_save_arguments VPARAMS ((enum dbxout_code code, ...))
{
#ifndef ANSI_PROTOTYPES
enum dbxout_code code;
#endif
va_list ap;
if (dbxout_nesting > 1)
return;
VA_START (ap, code);
#ifndef ANSI_PROTOTYPES
file = va_arg (ap, enum dbxout_code);
#endif
if (dbxout_data_array_next >= dbxout_data_array_size)
{
dbxout_data_array_size += dbxout_data_array_incr;
dbxout_data_array_incr = DBXOUT_DATA_ARRAY_INCR;
dbxout_data_array = (struct dbxout_stabs_t *)
pfe_realloc (dbxout_data_array,
sizeof (struct dbxout_stabs_t)
* dbxout_data_array_size);
}
dbxout_data_array[dbxout_data_array_next].code = (ENUM_BITFIELD(dbxout_code))code;
switch (code)
{
case DBXOUT_INIT:
case DBXOUT_FINISH:
dbxout_data_array[dbxout_data_array_next].u.s =
(const char *)PFE_SAVESTRING (va_arg (ap, char *));
break;
case DBXOUT_DEFINE:
case DBXOUT_UNDEF:
case DBXOUT_START_SOURCE_FILE:
case DBXOUT_SOURCE_LINE:
case DBXOUT_BEGIN_PROLOGUE:
dbxout_data_array[dbxout_data_array_next].u.f.line = va_arg (ap, unsigned int);
dbxout_data_array[dbxout_data_array_next].u.f.s =
(const char *)PFE_SAVESTRING (va_arg (ap, char *));
break;
case DBXOUT_END_SOURCE_FILE:
case DBXOUT_END_PROLOGUE:
case DBXOUT_END_FUNCTION:
dbxout_data_array[dbxout_data_array_next].u.line = va_arg (ap, unsigned int);
break;
case DBXOUT_BEGIN_BLOCK:
case DBXOUT_END_BLOCK:
dbxout_data_array[dbxout_data_array_next].u.b.line = va_arg (ap, unsigned int);
dbxout_data_array[dbxout_data_array_next].u.b.n = va_arg (ap, unsigned int);
break;
case DBXOUT_IGNORE_BLOCK:
case DBXOUT_BEGIN_FUNCTION:
case DBXOUT_FUNCTION_DECL:
case DBXOUT_GLOBAL_DECL:
case DBXOUT_DEFERRED_INLINE_FUNCTION:
case DBXOUT_OUTLINING_INLINE_FUNCTION:
dbxout_data_array[dbxout_data_array_next].u.node = va_arg (ap, tree);
break;
case DBXOUT_LABEL:
dbxout_data_array[dbxout_data_array_next].u.insn = va_arg (ap, struct rtx_def *);
break;
case DBXOUT_END_EPILOGUE:
break;
case DBXOUT_SYMBOL:
dbxout_data_array[dbxout_data_array_next].u.sym.decl = va_arg (ap, tree);
dbxout_data_array[dbxout_data_array_next].u.sym.local = va_arg (ap, int);
break;
case DBXOUT_PARMS:
case DBXOUT_REG_PARMS:
dbxout_data_array[dbxout_data_array_next].u.node = va_arg (ap, tree);
break;
default:
internal_error ("Invalid code (%d) sent to dbxout_save_arguments", (int)code);
}
va_end (ap);
++dbxout_data_array_next;
}
static void
dbxout_intercept_init (main_filename)
const char *main_filename;
{
++dbxout_nesting;
DBXOUT_SAVE_ARGUMENTS (DBXOUT_INIT, main_filename);
if (pfe_operation != PFE_DUMP)
(*actual_debug_hooks->init) (main_filename);
--dbxout_nesting;
}
static void
dbxout_intercept_finish (main_filename)
const char *main_filename;
{
#if 0
++dbxout_nesting;
DBXOUT_SAVE_ARGUMENTS (DBXOUT_FINISH, main_filename);
if (pfe_operation != PFE_DUMP)
(*actual_debug_hooks->finish) (main_filename);
--dbxout_nesting;
#else
if (pfe_operation != PFE_DUMP)
(*actual_debug_hooks->finish) (main_filename);
#endif
}
static void
dbxout_intercept_define (line, text)
unsigned int line;
const char *text;
{
++dbxout_nesting;
DBXOUT_SAVE_ARGUMENTS (DBXOUT_DEFINE, line, text);
if (pfe_operation != PFE_DUMP)
(*actual_debug_hooks->define) (line, text);
--dbxout_nesting;
}
static void
dbxout_intercept_undef (line, macro)
unsigned int line;
const char *macro;
{
++dbxout_nesting;
DBXOUT_SAVE_ARGUMENTS (DBXOUT_UNDEF, line, macro);
if (pfe_operation != PFE_DUMP)
(*actual_debug_hooks->undef) (line, macro);
--dbxout_nesting;
}
static void
dbxout_intercept_start_source_file (line, file)
unsigned int line;
const char *file;
{
++dbxout_nesting;
DBXOUT_SAVE_ARGUMENTS (DBXOUT_START_SOURCE_FILE, line, file);
if (pfe_operation != PFE_DUMP)
(*actual_debug_hooks->start_source_file) (line, file);
--dbxout_nesting;
}
static void
dbxout_intercept_end_source_file (line)
unsigned int line;
{
++dbxout_nesting;
DBXOUT_SAVE_ARGUMENTS (DBXOUT_END_SOURCE_FILE, line);
if (pfe_operation != PFE_DUMP)
(*actual_debug_hooks->end_source_file) (line);
--dbxout_nesting;
}
static void
dbxout_intercept_begin_block (line, n)
unsigned int line;
unsigned int n;
{
++dbxout_nesting;
DBXOUT_SAVE_ARGUMENTS (DBXOUT_BEGIN_BLOCK, line, n);
if (pfe_operation != PFE_DUMP)
(*actual_debug_hooks->begin_block) (line, n);
--dbxout_nesting;
}
static void
dbxout_intercept_end_block (line, n)
unsigned int line;
unsigned int n;
{
++dbxout_nesting;
DBXOUT_SAVE_ARGUMENTS (DBXOUT_END_BLOCK, line, n);
if (pfe_operation != PFE_DUMP)
(*actual_debug_hooks->end_block) (line, n);
--dbxout_nesting;
}
static bool
dbxout_intercept_ignore_block (node)
union tree_node *node;
{
bool result = true;
++dbxout_nesting;
DBXOUT_SAVE_ARGUMENTS (DBXOUT_IGNORE_BLOCK, node);
if (pfe_operation != PFE_DUMP)
result = (*actual_debug_hooks->ignore_block) (node);
--dbxout_nesting;
return result;
}
static void
dbxout_intercept_source_line (line, file)
unsigned int line;
const char *file;
{
++dbxout_nesting;
DBXOUT_SAVE_ARGUMENTS (DBXOUT_SOURCE_LINE, line, file);
if (pfe_operation != PFE_DUMP)
(*actual_debug_hooks->source_line) (line, file);
--dbxout_nesting;
}
static void
dbxout_intercept_begin_prologue (line, file)
unsigned int line;
const char *file;
{
++dbxout_nesting;
DBXOUT_SAVE_ARGUMENTS (DBXOUT_BEGIN_PROLOGUE, line, file);
if (pfe_operation != PFE_DUMP)
(*actual_debug_hooks->begin_prologue) (line, file);
--dbxout_nesting;
}
static void
dbxout_intercept_end_prologue (line)
unsigned int line;
{
++dbxout_nesting;
DBXOUT_SAVE_ARGUMENTS (DBXOUT_END_PROLOGUE, line);
if (pfe_operation != PFE_DUMP)
(*actual_debug_hooks->end_prologue) (line);
--dbxout_nesting;
}
static void
dbxout_intercept_end_epilogue ()
{
++dbxout_nesting;
DBXOUT_SAVE_ARGUMENTS (DBXOUT_END_EPILOGUE);
if (pfe_operation != PFE_DUMP)
(*actual_debug_hooks->end_epilogue) ();
--dbxout_nesting;
}
static void
dbxout_intercept_begin_function (decl)
union tree_node *decl;
{
++dbxout_nesting;
DBXOUT_SAVE_ARGUMENTS (DBXOUT_BEGIN_FUNCTION, decl);
if (pfe_operation != PFE_DUMP)
(*actual_debug_hooks->begin_function) (decl);
--dbxout_nesting;
}
static void
dbxout_intercept_end_function (line)
unsigned int line;
{
++dbxout_nesting;
DBXOUT_SAVE_ARGUMENTS (DBXOUT_END_FUNCTION, line);
if (pfe_operation != PFE_DUMP)
(*actual_debug_hooks->end_function) (line);
--dbxout_nesting;
}
static void
dbxout_intercept_function_decl (decl)
union tree_node *decl;
{
++dbxout_nesting;
DBXOUT_SAVE_ARGUMENTS (DBXOUT_FUNCTION_DECL, decl);
if (pfe_operation != PFE_DUMP)
(*actual_debug_hooks->function_decl) (decl);
--dbxout_nesting;
}
static void
dbxout_intercept_global_decl (decl)
union tree_node *decl;
{
++dbxout_nesting;
DBXOUT_SAVE_ARGUMENTS (DBXOUT_GLOBAL_DECL, decl);
if (pfe_operation != PFE_DUMP)
(*actual_debug_hooks->global_decl) (decl);
--dbxout_nesting;
}
static void
dbxout_intercept_deferred_inline_function (decl)
union tree_node *decl;
{
++dbxout_nesting;
DBXOUT_SAVE_ARGUMENTS (DBXOUT_DEFERRED_INLINE_FUNCTION, decl);
if (pfe_operation != PFE_DUMP)
(*actual_debug_hooks->deferred_inline_function) (decl);
--dbxout_nesting;
}
static void
dbxout_intercept_outlining_inline_function (decl)
union tree_node *decl;
{
++dbxout_nesting;
DBXOUT_SAVE_ARGUMENTS (DBXOUT_OUTLINING_INLINE_FUNCTION, decl);
if (pfe_operation != PFE_DUMP)
(*actual_debug_hooks->outlining_inline_function) (decl);
--dbxout_nesting;
}
static void
dbxout_intercept_label (insn)
struct rtx_def *insn;
{
++dbxout_nesting;
DBXOUT_SAVE_ARGUMENTS (DBXOUT_LABEL, insn);
if (pfe_operation != PFE_DUMP)
(*actual_debug_hooks->label) (insn);
--dbxout_nesting;
}
#endif