/* Output dbx-format symbol table information from GNU compiler.
Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
- 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
- Free Software Foundation, Inc.
+ 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
+ 2011 Free Software Foundation, Inc.
This file is part of GCC.
#include "reload.h"
#include "output.h"
#include "dbxout.h"
+#include "diagnostic-core.h"
#include "toplev.h"
#include "tm_p.h"
#include "ggc.h"
#include "debug.h"
#include "function.h"
#include "target.h"
+#include "common/common-target.h"
#include "langhooks.h"
#include "obstack.h"
#include "expr.h"
+#include "cgraph.h"
#ifdef XCOFF_DEBUGGING_INFO
#include "xcoffout.h"
#endif
-#define DBXOUT_DECR_NESTING \
- if (--debug_nesting == 0 && symbol_queue_index > 0) \
- { emit_pending_bincls_if_required (); debug_flush_symbol_queue (); }
-
-#define DBXOUT_DECR_NESTING_AND_RETURN(x) \
- do {--debug_nesting; return (x);} while (0)
-
#ifndef ASM_STABS_OP
# ifdef XCOFF_DEBUGGING_INFO
# define ASM_STABS_OP "\t.stabx\t"
struct dbx_file *prev; /* Chain to traverse all pending bincls. */
};
-/* This is the top of the stack.
-
+/* This is the top of the stack.
+
This is not saved for PCH, because restoring a PCH should not change it.
next_file_number does have to be saved, because the PCH may use some
file numbers; however, just before restoring a PCH, next_file_number
#endif
/* A C expression for the integer offset value of an argument (N_PSYM)
- having address X (an RTX). The nominal offset is OFFSET. */
+ having address X (an RTX). The nominal offset is OFFSET.
+ Note that we use OFFSET + 0 here to avoid the self-assign warning
+ when the macro is called in a context like
+ number = DEBUGGER_ARG_OFFSET(number, X) */
#ifndef DEBUGGER_ARG_OFFSET
-#define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET)
+#define DEBUGGER_ARG_OFFSET(OFFSET, X) (OFFSET + 0)
#endif
/* This obstack holds the stab string currently being constructed. We
static inline void emit_pending_bincls_if_required (void);
static void dbxout_init (const char *);
-
+
static void dbxout_finish (const char *);
static void dbxout_start_source_file (unsigned, const char *);
static void dbxout_end_source_file (unsigned);
static void dbxout_global_decl (tree);
static void dbxout_type_decl (tree, int);
static void dbxout_handle_pch (unsigned);
+static void debug_free_queue (void);
\f
/* The debug hooks structure. */
#if defined (DBX_DEBUGGING_INFO)
{
dbxout_init,
dbxout_finish,
+ debug_nothing_void,
debug_nothing_int_charstar,
debug_nothing_int_charstar,
dbxout_start_source_file,
dbxout_source_line, /* source_line */
dbxout_begin_prologue, /* begin_prologue */
debug_nothing_int_charstar, /* end_prologue */
+ debug_nothing_int_charstar, /* begin_epilogue */
debug_nothing_int_charstar, /* end_epilogue */
#ifdef DBX_FUNCTION_FIRST
dbxout_begin_function,
dbxout_handle_pch, /* handle_pch */
debug_nothing_rtx, /* var_location */
debug_nothing_void, /* switch_text_section */
- debug_nothing_tree, /* direct_call */
- debug_nothing_tree_int, /* virtual_call_token */
- debug_nothing_uid, /* virtual_call */
debug_nothing_tree_tree, /* set_name */
- 0 /* start_end_main_source_file */
+ 0, /* start_end_main_source_file */
+ TYPE_SYMTAB_IS_ADDRESS /* tree_type_symtab_field */
};
#endif /* DBX_DEBUGGING_INFO */
{
dbxout_init,
dbxout_finish,
+ debug_nothing_void,
debug_nothing_int_charstar,
debug_nothing_int_charstar,
dbxout_start_source_file,
xcoffout_source_line,
xcoffout_begin_prologue, /* begin_prologue */
debug_nothing_int_charstar, /* end_prologue */
+ debug_nothing_int_charstar, /* begin_epilogue */
xcoffout_end_epilogue,
debug_nothing_tree, /* begin_function */
xcoffout_end_function,
dbxout_handle_pch, /* handle_pch */
debug_nothing_rtx, /* var_location */
debug_nothing_void, /* switch_text_section */
- debug_nothing_tree, /* direct_call */
- debug_nothing_tree_int, /* virtual_call_token */
- debug_nothing_uid, /* virtual_call */
debug_nothing_tree_tree, /* set_name */
- 0 /* start_end_main_source_file */
+ 0, /* start_end_main_source_file */
+ TYPE_SYMTAB_IS_ADDRESS /* tree_type_symtab_field */
};
#endif /* XCOFF_DEBUGGING_INFO */
\f
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)
obstack_grow (&stabstr_ob, "\",", 2);
len = obstack_object_size (&stabstr_ob);
str = XOBFINISH (&stabstr_ob, char *);
-
+
fwrite (str, 1, len, asm_out_file);
DBX_FINISH_STABS (sym, code, line, addr, label, number);
}
obstack_free (&stabstr_ob, str);
}
+#if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
+
+/* When -gused is used, emit debug info for only used symbols. But in
+ addition to the standard intercepted debug_hooks there are some
+ direct calls into this file, i.e., dbxout_symbol, dbxout_parms, and
+ dbxout_reg_params. Those routines may also be called from a higher
+ level intercepted routine. So to prevent recording data for an inner
+ call to one of these for an intercept, we maintain an intercept
+ nesting counter (debug_nesting). We only save the intercepted
+ arguments if the nesting is 1. */
+static int debug_nesting = 0;
+
+static tree *symbol_queue;
+static int symbol_queue_index = 0;
+static int symbol_queue_size = 0;
+
+#define DBXOUT_DECR_NESTING \
+ if (--debug_nesting == 0 && symbol_queue_index > 0) \
+ { emit_pending_bincls_if_required (); debug_flush_symbol_queue (); }
+
+#define DBXOUT_DECR_NESTING_AND_RETURN(x) \
+ do {--debug_nesting; return (x);} while (0)
+
+#endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */
+
#if defined (DBX_DEBUGGING_INFO)
static void
/* The Lscope label must be emitted even if we aren't doing anything
else; dbxout_block needs it. */
switch_to_section (function_section (current_function_decl));
-
+
/* Convert Lscope into the appropriate format for local labels in case
the system doesn't insert underscores in front of user generated
labels. */
named sections. */
if (!use_gnu_debug_info_extensions
|| NO_DBX_FUNCTION_END
- || !targetm.have_named_sections)
+ || !targetm_common.have_named_sections)
return;
/* By convention, GCC will mark the end of a function with an N_FUN
if (flag_reorder_blocks_and_partition)
{
dbxout_begin_empty_stabs (N_FUN);
- dbxout_stab_value_label_diff (crtl->subsections.hot_section_end_label,
+ dbxout_stab_value_label_diff (crtl->subsections.hot_section_end_label,
crtl->subsections.hot_section_label);
dbxout_begin_empty_stabs (N_FUN);
- dbxout_stab_value_label_diff (crtl->subsections.cold_section_end_label,
+ dbxout_stab_value_label_diff (crtl->subsections.cold_section_end_label,
crtl->subsections.cold_section_label);
}
else
const char *mapped_name;
typevec_len = 100;
- typevec = GGC_CNEWVEC (struct typeinfo, typevec_len);
+ typevec = ggc_alloc_cleared_vec_typeinfo (typevec_len);
/* stabstr_ob contains one string, which will be just fine with
1-byte alignment. */
static void
dbxout_typedefs (tree syms)
{
- for (; syms != NULL_TREE; syms = TREE_CHAIN (syms))
+ for (; syms != NULL_TREE; syms = DECL_CHAIN (syms))
{
if (TREE_CODE (syms) == TYPE_DECL)
{
n->next = current_file;
n->next_type_number = 1;
- /* Do not assign file number now.
+ /* Do not assign file number now.
Delay it until we actually emit BINCL. */
n->file_number = 0;
n->prev = NULL;
}
}
-/* Output N_BNSYM, line number symbol entry, and local symbol at
+/* Output N_BNSYM, line number symbol entry, and local symbol at
function scope */
static void
scope_labelno++;
dbxout_source_line (lineno, filename, 0, true);
- /* Output function begin block at function scope, referenced
+ /* Output function begin block at function scope, referenced
by dbxout_block, dbxout_source_line and dbxout_function_end. */
emit_pending_bincls_if_required ();
targetm.asm_out.internal_label (asm_out_file, "LFBB", scope_labelno);
char begin_label[20];
dbxout_begin_stabn_sline (lineno);
/* Reference current function start using LFBB. */
- ASM_GENERATE_INTERNAL_LABEL (begin_label, "LFBB", scope_labelno);
+ ASM_GENERATE_INTERNAL_LABEL (begin_label, "LFBB", scope_labelno);
dbxout_stab_value_internal_label_diff ("LM", &dbxout_source_line_counter,
begin_label);
}
}
\f
+/* Generate the symbols for any queued up type symbols we encountered
+ while generating the type info for some originally used symbol.
+ This might generate additional entries in the queue. Only when
+ the nesting depth goes to 0 is this routine called. */
+
+static void
+debug_flush_symbol_queue (void)
+{
+ int i;
+
+ /* Make sure that additionally queued items are not flushed
+ prematurely. */
+
+ ++debug_nesting;
+
+ for (i = 0; i < symbol_queue_index; ++i)
+ {
+ /* If we pushed queued symbols then such symbols must be
+ output no matter what anyone else says. Specifically,
+ we need to make sure dbxout_symbol() thinks the symbol was
+ used and also we need to override TYPE_DECL_SUPPRESS_DEBUG
+ which may be set for outside reasons. */
+ 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;
+
+#ifdef DBX_DEBUGGING_INFO
+ dbxout_symbol (symbol_queue[i], 0);
+#endif
+
+ TREE_USED (symbol_queue[i]) = saved_tree_used;
+ TYPE_DECL_SUPPRESS_DEBUG (symbol_queue[i]) = saved_suppress_debug;
+ }
+
+ symbol_queue_index = 0;
+ --debug_nesting;
+}
+
+/* Queue a type symbol needed as part of the definition of a decl
+ symbol. These symbols are generated when debug_flush_symbol_queue()
+ is called. */
+static void
+debug_queue_symbol (tree decl)
+{
+ if (symbol_queue_index >= symbol_queue_size)
+ {
+ symbol_queue_size += 10;
+ symbol_queue = XRESIZEVEC (tree, symbol_queue, symbol_queue_size);
+ }
+
+ symbol_queue[symbol_queue_index++] = decl;
+}
+
+/* Free symbol queue. */
+static void
+debug_free_queue (void)
+{
+ if (symbol_queue)
+ {
+ free (symbol_queue);
+ symbol_queue = NULL;
+ symbol_queue_size = 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) \
/* Output the name, type, position (in bits), size (in bits) of each
field that we can support. */
- for (tem = TYPE_FIELDS (type); tem; tem = TREE_CHAIN (tem))
+ for (tem = TYPE_FIELDS (type); tem; tem = DECL_CHAIN (tem))
{
/* If one of the nodes is an error_mark or its type is then
return early. */
- if (tem == error_mark_node || TREE_TYPE (tem) == error_mark_node)
+ if (error_operand_p (tem))
return;
/* Omit here local type decls until we know how to support them. */
These differ in the types of the arguments. */
for (last = NULL_TREE;
fndecl && (last == NULL_TREE || DECL_NAME (fndecl) == DECL_NAME (last));
- fndecl = TREE_CHAIN (fndecl))
+ fndecl = DECL_CHAIN (fndecl))
/* Output the name of the field (after overloading), as
well as the name of the field before overloading, along
with its parameter list */
dbxout_type (tree type, int full)
{
static int anonymous_type_number = 0;
- bool vector_type = false;
tree tem, main_variant, low, high;
- if (TREE_CODE (type) == VECTOR_TYPE)
- {
- /* The frontend feeds us a representation for the vector as a struct
- containing an array. Pull out the array type. */
- type = TREE_TYPE (TYPE_FIELDS (TYPE_DEBUG_REPRESENTATION_TYPE (type)));
- vector_type = true;
- }
-
if (TREE_CODE (type) == INTEGER_TYPE)
{
if (TREE_TYPE (type) == 0)
switch (TREE_CODE (type))
{
case VOID_TYPE:
+ case NULLPTR_TYPE:
case LANG_TYPE:
/* For a void type, just define it as itself; i.e., "5=5".
This makes us consider it defined
break;
}
- if (use_gnu_debug_info_extensions && vector_type)
- stabstr_S ("@V;");
-
/* Output "a" followed by a range type definition
for the index type of the array
followed by a reference to the target-type.
dbxout_type (TREE_TYPE (type), 0);
break;
+ case VECTOR_TYPE:
+ /* Make vectors look like an array. */
+ if (use_gnu_debug_info_extensions)
+ stabstr_S ("@V;");
+
+ /* Output "a" followed by a range type definition
+ for the index type of the array
+ followed by a reference to the target-type.
+ ar1;0;N;M for a C array of type M and size N+1. */
+ stabstr_C ('a');
+ dbxout_range_type (integer_type_node, size_zero_node,
+ size_int (TYPE_VECTOR_SUBPARTS (type) - 1));
+
+ dbxout_type (TREE_TYPE (type), 0);
+ break;
+
case RECORD_TYPE:
case UNION_TYPE:
case QUAL_UNION_TYPE:
int i;
tree child;
VEC(tree,gc) *accesses = BINFO_BASE_ACCESSES (binfo);
-
+
if (use_gnu_debug_info_extensions)
{
if (BINFO_N_BASE_BINFOS (binfo))
dbxout_type_name (tree type)
{
tree t = TYPE_NAME (type);
-
+
gcc_assert (t);
switch (TREE_CODE (t))
{
disable debug info for these variables. */
if (!targetm.have_tls && DECL_THREAD_LOCAL_P (expr))
return NULL;
+ if (TREE_STATIC (expr)
+ && !TREE_ASM_WRITTEN (expr)
+ && !DECL_HAS_VALUE_EXPR_P (expr)
+ && !TREE_PUBLIC (expr)
+ && DECL_RTL_SET_P (expr)
+ && MEM_P (DECL_RTL (expr)))
+ {
+ /* If this is a var that might not be actually output,
+ return NULL, otherwise stabs might reference an undefined
+ symbol. */
+ struct varpool_node *node = varpool_get_node (expr);
+ if (!node || !node->needed)
+ return NULL;
+ }
/* FALLTHRU */
case PARM_DECL:
+ case RESULT_DECL:
if (DECL_HAS_VALUE_EXPR_P (expr))
return dbxout_expand_expr (DECL_VALUE_EXPR (expr));
/* FALLTHRU */
case CONST_DECL:
- case RESULT_DECL:
return DECL_RTL_IF_SET (expr);
case INTEGER_CST:
htab_traverse (cfun->used_types_hash, output_used_types_helper, &types);
/* Sort by UID to prevent dependence on hash table ordering. */
- qsort (VEC_address (tree, types), VEC_length (tree, types),
- sizeof (tree), output_types_sort);
+ VEC_qsort (tree, types, output_types_sort);
- for (i = 0; VEC_iterate (tree, types, i, type); i++)
+ FOR_EACH_VEC_ELT (tree, types, i, type)
debug_queue_symbol (type);
VEC_free (tree, heap, types);
&& DECL_INITIAL (decl) != 0
&& host_integerp (DECL_INITIAL (decl), 0)
&& ! TREE_ASM_WRITTEN (decl)
- && (DECL_CONTEXT (decl) == NULL_TREE
+ && (DECL_FILE_SCOPE_P (decl)
|| TREE_CODE (DECL_CONTEXT (decl)) == BLOCK
|| TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL)
&& TREE_PUBLIC (decl) == 0)
|| (REG_P (XEXP (home, 0))
&& REGNO (XEXP (home, 0)) != HARD_FRAME_POINTER_REGNUM
&& REGNO (XEXP (home, 0)) != STACK_POINTER_REGNUM
-#if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
+#if !HARD_FRAME_POINTER_IS_ARG_POINTER
&& REGNO (XEXP (home, 0)) != ARG_POINTER_REGNUM
#endif
)))
{
tree name;
- if (DECL_CONTEXT (decl)
+ if (DECL_CONTEXT (decl)
&& (TYPE_P (DECL_CONTEXT (decl))
|| TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL))
/* One slight hitch: if this is a VAR_DECL which is a class member
rtx home;
rtx sym_addr;
const char *name = NULL;
-
- /* If the decl isn't a VAR_DECL, or if it isn't public or static, or if
+
+ /* If the decl isn't a VAR_DECL, or if it isn't static, or if
it does not have a value (the offset into the common area), or if it
is thread local (as opposed to global) then it isn't common, and shouldn't
be handled as such.
-
+
??? DECL_THREAD_LOCAL_P check prevents problems with improper .stabs
for thread-local symbols. Can be handled via same mechanism as used
in dwarf2out.c. */
if (TREE_CODE (decl) != VAR_DECL
- || !TREE_PUBLIC(decl)
|| !TREE_STATIC(decl)
|| !DECL_HAS_VALUE_EXPR_P(decl)
|| DECL_THREAD_LOCAL_P (decl)
|| !is_fortran ())
return NULL;
- home = DECL_RTL (decl);
+ home = DECL_RTL (decl);
if (home == NULL_RTX || GET_CODE (home) != MEM)
return NULL;
comm_prev = comm_new;
result += dbxout_symbol (syms, 1);
- syms = TREE_CHAIN (syms);
+ syms = DECL_CHAIN (syms);
}
if (comm_prev != NULL)
++debug_nesting;
emit_pending_bincls_if_required ();
- for (; parms; parms = TREE_CHAIN (parms))
+ for (; parms; parms = DECL_CHAIN (parms))
if (DECL_NAME (parms)
&& TREE_TYPE (parms) != error_mark_node
&& DECL_RTL_SET_P (parms)
&& REG_P (XEXP (DECL_RTL (parms), 0))
&& REGNO (XEXP (DECL_RTL (parms), 0)) != HARD_FRAME_POINTER_REGNUM
&& REGNO (XEXP (DECL_RTL (parms), 0)) != STACK_POINTER_REGNUM
-#if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
+#if !HARD_FRAME_POINTER_IS_ARG_POINTER
&& REGNO (XEXP (DECL_RTL (parms), 0)) != ARG_POINTER_REGNUM
#endif
)
that it was actually passed by invisible reference. */
code = DBX_REGPARM_STABS_CODE;
-
+
/* GDB likes this marked with a special letter. */
letter = (use_gnu_debug_info_extensions
? 'a' : DBX_REGPARM_STABS_LETTER);
continue;
dbxout_begin_complex_stabs ();
-
+
if (DECL_NAME (parms))
{
stabstr_I (DECL_NAME (parms));
{
++debug_nesting;
- for (; parms; parms = TREE_CHAIN (parms))
+ for (; parms; parms = DECL_CHAIN (parms))
if (DECL_NAME (parms) && PARM_PASSED_IN_MEMORY (parms))
{
/* Report parms that live in registers during the function
OSDN Git Service
