OpenE2K/gcc
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Cleanup whitespacing

Browse Source 
From-SVN: r123536
This commit is contained in:
Mike Stump 2007-04-06 00:58:34 +00:00
parent c7b89fc411
commit 2878ea7352
1 changed files with 100 additions and 100 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

200
gcc/dwarf2out.c
View File

@ -468,13 +468,13 @@ expand_builtin_init_dwarf_reg_sizes (tree address)
for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
{
int rnum = DWARF2_FRAME_REG_OUT (DWARF_FRAME_REGNUM (i), 1);
if (rnum < DWARF_FRAME_REGISTERS)
{
HOST_WIDE_INT offset = rnum * GET_MODE_SIZE (mode);
enum machine_mode save_mode = reg_raw_mode[i];
HOST_WIDE_INT size;
if (HARD_REGNO_CALL_PART_CLOBBERED (i, save_mode))
save_mode = choose_hard_reg_mode (i, 1, true);
if (DWARF_FRAME_REGNUM (i) == DWARF_FRAME_RETURN_COLUMN)
@ -486,7 +486,7 @@ expand_builtin_init_dwarf_reg_sizes (tree address)
size = GET_MODE_SIZE (save_mode);
if (offset < 0)
continue;
emit_move_insn (adjust_address (mem, mode, offset),
gen_int_mode (size, mode));
}
@ -2218,7 +2218,7 @@ output_call_frame_info (int for_eh)
&& for_eh)
for (i = 0; i < fde_table_in_use; i++)
if ((fde_table[i].nothrow || fde_table[i].all_throwers_are_sibcalls)
&& !fde_table[i].uses_eh_lsda
&& !fde_table[i].uses_eh_lsda
&& ! DECL_WEAK (fde_table[i].decl))
targetm.asm_out.unwind_label (asm_out_file, fde_table[i].decl,
for_eh, /* empty */ 1);
@ -2234,7 +2234,7 @@ output_call_frame_info (int for_eh)
for (i = 0; i < fde_table_in_use; i++)
if (fde_table[i].uses_eh_lsda)
any_eh_needed = any_lsda_needed = true;
else if (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde_table[i].decl))
else if (TARGET_USES_WEAK_UNWIND_INFO && DECL_WEAK (fde_table[i].decl))
any_eh_needed = true;
else if (! fde_table[i].nothrow
&& ! fde_table[i].all_throwers_are_sibcalls)
@ -2422,9 +2422,9 @@ output_call_frame_info (int for_eh)
"FDE initial location");
if (fde->dw_fde_switched_sections)
{
rtx sym_ref2 = gen_rtx_SYMBOL_REF (Pmode,
rtx sym_ref2 = gen_rtx_SYMBOL_REF (Pmode,
fde->dw_fde_unlikely_section_label);
rtx sym_ref3= gen_rtx_SYMBOL_REF (Pmode,
rtx sym_ref3= gen_rtx_SYMBOL_REF (Pmode,
fde->dw_fde_hot_section_label);
SYMBOL_REF_FLAGS (sym_ref2) |= SYMBOL_FLAG_LOCAL;
SYMBOL_REF_FLAGS (sym_ref3) |= SYMBOL_FLAG_LOCAL;
@ -2462,7 +2462,7 @@ output_call_frame_info (int for_eh)
dw2_asm_output_addr (DWARF2_ADDR_SIZE,
fde->dw_fde_unlikely_section_label,
"FDE initial location");
dw2_asm_output_delta (DWARF2_ADDR_SIZE,
dw2_asm_output_delta (DWARF2_ADDR_SIZE,
fde->dw_fde_unlikely_section_end_label,
fde->dw_fde_unlikely_section_label,
"FDE address range");
@ -3838,14 +3838,14 @@ limbo_die_node;
/* Fixed size portion of the address range info. */
#define DWARF_ARANGES_HEADER_SIZE \
(DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
DWARF2_ADDR_SIZE * 2) \
DWARF2_ADDR_SIZE * 2) \
- DWARF_INITIAL_LENGTH_SIZE)
/* Size of padding portion in the address range info. It must be
aligned to twice the pointer size. */
#define DWARF_ARANGES_PAD_SIZE \
(DWARF_ROUND (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4, \
DWARF2_ADDR_SIZE * 2) \
DWARF2_ADDR_SIZE * 2) \
- (DWARF_INITIAL_LENGTH_SIZE + DWARF_OFFSET_SIZE + 4))
/* Use assembler line directives if available. */
@ -4347,7 +4347,7 @@ static int maybe_emit_file (struct dwarf_file_data *fd);
static char text_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
static char text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
static char cold_text_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
static char cold_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
static char cold_end_label[MAX_ARTIFICIAL_LABEL_BYTES];
static char abbrev_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
static char debug_info_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
static char debug_line_section_label[MAX_ARTIFICIAL_LABEL_BYTES];
@ -4863,7 +4863,7 @@ block_ultimate_origin (tree block)
? BLOCK_ABSTRACT_ORIGIN (ret_val) : NULL);
}
while (lookahead != NULL && lookahead != ret_val);
/* The block's abstract origin chain may not be the *ultimate* origin of
the block. It could lead to a DECL that has an abstract origin set.
If so, we want that DECL's abstract origin (which is what DECL_ORIGIN
@ -4906,7 +4906,7 @@ add_dwarf_attr (dw_die_ref die, dw_attr_ref attr)
/* Maybe this should be an assert? */
if (die == NULL)
return;
if (die->die_attr == NULL)
die->die_attr = VEC_alloc (dw_attr_node, gc, 1);
VEC_safe_push (dw_attr_node, gc, die->die_attr, attr);
@ -5345,7 +5345,7 @@ get_AT (dw_die_ref die, enum dwarf_attribute attr_kind)
else if (a->dw_attr == DW_AT_specification
|| a->dw_attr == DW_AT_abstract_origin)
spec = AT_ref (a);
if (spec)
return get_AT (spec, attr_kind);
@ -5443,7 +5443,7 @@ static inline bool
is_cxx (void)
{
unsigned int lang = get_AT_unsigned (comp_unit_die, DW_AT_language);
return lang == DW_LANG_C_plus_plus || lang == DW_LANG_ObjC_plus_plus;
}
@ -5530,7 +5530,7 @@ static void
remove_child_TAG (dw_die_ref die, enum dwarf_tag tag)
{
dw_die_ref c;
c = die->die_child;
if (c) do {
dw_die_ref prev = c;
@ -5568,7 +5568,7 @@ add_child_die (dw_die_ref die, dw_die_ref child_die)
}
/* Move CHILD, which must be a child of PARENT or the DIE for which PARENT
is the specification, to the end of PARENT's list of children.
is the specification, to the end of PARENT's list of children.
This is done by removing and re-adding it. */
static void
@ -5589,7 +5589,7 @@ splice_child_die (dw_die_ref parent, dw_die_ref child)
gcc_assert (child->die_parent == parent
|| (child->die_parent
== get_AT_ref (parent, DW_AT_specification)));
for (p = child->die_parent->die_child; ; p = p->die_sib)
if (p->die_sib == child)
{
@ -6145,7 +6145,7 @@ same_die_p (dw_die_ref die1, dw_die_ref die2, int *mark)
if (VEC_length (dw_attr_node, die1->die_attr)
!= VEC_length (dw_attr_node, die2->die_attr))
return 0;
for (ix = 0; VEC_iterate (dw_attr_node, die1->die_attr, ix, a1); ix++)
if (!same_attr_p (a1, VEC_index (dw_attr_node, die2->die_attr, ix), mark))
return 0;
@ -6450,7 +6450,7 @@ break_out_includes (dw_die_ref die)
/* This DIE is for a secondary CU; remove it from the main one. */
remove_child_with_prev (c, prev);
if (c->die_tag == DW_TAG_GNU_BINCL)
unit = push_new_compile_unit (unit, c);
else if (c->die_tag == DW_TAG_GNU_EINCL)
@ -6558,16 +6558,16 @@ build_abbrev_table (dw_die_ref die)
dw_attr_ref die_a, abbrev_a;
unsigned ix;
bool ok = true;
if (abbrev->die_tag != die->die_tag)
continue;
if ((abbrev->die_child != NULL) != (die->die_child != NULL))
continue;
if (VEC_length (dw_attr_node, abbrev->die_attr)
!= VEC_length (dw_attr_node, die->die_attr))
continue;
for (ix = 0; VEC_iterate (dw_attr_node, die->die_attr, ix, die_a); ix++)
{
abbrev_a = VEC_index (dw_attr_node, abbrev->die_attr, ix);
@ -6775,7 +6775,7 @@ unmark_all_dies (dw_die_ref die)
unmark_all_dies (AT_ref (a));
}
/* Return the size of the .debug_pubnames or .debug_pubtypes table
/* Return the size of the .debug_pubnames or .debug_pubtypes table
generated for the compilation unit. */
static unsigned long
@ -7255,7 +7255,7 @@ output_die (dw_die_ref die)
case dw_val_class_file:
{
int f = maybe_emit_file (a->dw_attr_val.v.val_file);
dw2_asm_output_data (constant_size (f), f, "%s (%s)", name,
a->dw_attr_val.v.val_file->filename);
break;
@ -7284,7 +7284,7 @@ output_compilation_unit_header (void)
dw2_asm_output_data (4, 0xffffffff,
"Initial length escape value indicating 64-bit DWARF extension");
dw2_asm_output_data (DWARF_OFFSET_SIZE,
next_die_offset - DWARF_INITIAL_LENGTH_SIZE,
next_die_offset - DWARF_INITIAL_LENGTH_SIZE,
"Length of Compilation Unit Info");
dw2_asm_output_data (2, DWARF_VERSION, "DWARF version number");
dw2_asm_output_offset (DWARF_OFFSET_SIZE, abbrev_section_label,
@ -7389,11 +7389,11 @@ add_pubtype (tree decl, dw_die_ref die)
else if (TREE_CODE (TYPE_NAME (decl)) == TYPE_DECL
&& DECL_NAME (TYPE_NAME (decl)))
e.name = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (decl)));
else
else
e.name = xstrdup ((const char *) get_AT_string (die, DW_AT_name));
}
}
else
else
e.name = xstrdup (dwarf2_name (decl, 1));
/* If we don't have a name for the type, there's no point in adding
@ -7431,7 +7431,7 @@ output_pubnames (VEC (pubname_entry, gc) * names)
for (i = 0; VEC_iterate (pubname_entry, names, i, pub); i++)
{
/* We shouldn't see pubnames for DIEs outside of the main CU. */
/* We shouldn't see pubnames for DIEs outside of the main CU. */
if (names == pubname_table)
gcc_assert (pub->die->die_mark);
@ -7508,7 +7508,7 @@ output_aranges (void)
text_section_label, "Length");
if (flag_reorder_blocks_and_partition)
{
dw2_asm_output_addr (DWARF2_ADDR_SIZE, cold_text_section_label,
dw2_asm_output_addr (DWARF2_ADDR_SIZE, cold_text_section_label,
"Address");
dw2_asm_output_delta (DWARF2_ADDR_SIZE, cold_end_label,
cold_text_section_label, "Length");
@ -7690,7 +7690,7 @@ file_info_cmp (const void *p1, const void *p2)
}
}
struct file_name_acquire_data
struct file_name_acquire_data
{
struct file_info *files;
int used_files;
@ -7720,12 +7720,12 @@ file_name_acquire (void ** slot, void *data)
f = d->filename;
while (f[0] == '.' && IS_DIR_SEPARATOR (f[1]))
f += 2;
/* Create a new array entry. */
fi->path = f;
fi->length = strlen (f);
fi->file_idx = d;
/* Search for the file name part. */
f = strrchr (f, DIR_SEPARATOR);
#if defined (DIR_SEPARATOR_2)
@ -8396,26 +8396,26 @@ is_subrange_type (tree type)
&& tree_int_cst_equal (TYPE_MAX_VALUE (type), TYPE_MAX_VALUE (subtype)))
{
/* The type and its subtype have the same representation. If in
addition the two types also have the same name, then the given
type is not a subrange type, but rather a plain base type. */
addition the two types also have the same name, then the given
type is not a subrange type, but rather a plain base type. */
/* FIXME: brobecker/2004-03-22:
Sizetype INTEGER_CSTs nodes are canonicalized. It should
therefore be sufficient to check the TYPE_SIZE node pointers
rather than checking the actual size. Unfortunately, we have
found some cases, such as in the Ada "integer" type, where
this is not the case. Until this problem is solved, we need to
keep checking the actual size. */
Sizetype INTEGER_CSTs nodes are canonicalized. It should
therefore be sufficient to check the TYPE_SIZE node pointers
rather than checking the actual size. Unfortunately, we have
found some cases, such as in the Ada "integer" type, where
this is not the case. Until this problem is solved, we need to
keep checking the actual size. */
tree type_name = TYPE_NAME (type);
tree subtype_name = TYPE_NAME (subtype);
if (type_name != NULL && TREE_CODE (type_name) == TYPE_DECL)
type_name = DECL_NAME (type_name);
type_name = DECL_NAME (type_name);
if (subtype_name != NULL && TREE_CODE (subtype_name) == TYPE_DECL)
subtype_name = DECL_NAME (subtype_name);
subtype_name = DECL_NAME (subtype_name);
if (type_name == subtype_name)
return false;
return false;
}
return true;
@ -8438,16 +8438,16 @@ subrange_type_die (tree type, dw_die_ref context_die)
if (int_size_in_bytes (TREE_TYPE (type)) != size_in_bytes)
{
/* The size of the subrange type and its base type do not match,
so we need to generate a size attribute for the subrange type. */
so we need to generate a size attribute for the subrange type. */
add_AT_unsigned (subrange_die, DW_AT_byte_size, size_in_bytes);
}
if (TYPE_MIN_VALUE (type) != NULL)
add_bound_info (subrange_die, DW_AT_lower_bound,
TYPE_MIN_VALUE (type));
TYPE_MIN_VALUE (type));
if (TYPE_MAX_VALUE (type) != NULL)
add_bound_info (subrange_die, DW_AT_upper_bound,
TYPE_MAX_VALUE (type));
TYPE_MAX_VALUE (type));
return subrange_die;
}
@ -8475,7 +8475,7 @@ modified_type_die (tree type, int is_const_type, int is_volatile_type,
= get_qualified_type (type,
((is_const_type ? TYPE_QUAL_CONST : 0)
| (is_volatile_type ? TYPE_QUAL_VOLATILE : 0)));
/* If we do, then we can just use its DIE, if it exists. */
if (qualified_type)
{
@ -8483,14 +8483,14 @@ modified_type_die (tree type, int is_const_type, int is_volatile_type,
if (mod_type_die)
return mod_type_die;
}
name = qualified_type ? TYPE_NAME (qualified_type) : NULL;
/* Handle C typedef types. */
if (name && TREE_CODE (name) == TYPE_DECL && DECL_ORIGINAL_TYPE (name))
{
tree dtype = TREE_TYPE (name);
if (qualified_type == dtype)
{
/* For a named type, use the typedef. */
@ -8509,7 +8509,7 @@ modified_type_die (tree type, int is_const_type, int is_volatile_type,
context_die);
/* Else cv-qualified version of named type; fall through. */
}
if (is_const_type)
{
mod_type_die = new_die (DW_TAG_const_type, comp_unit_die, type);
@ -8544,7 +8544,7 @@ modified_type_die (tree type, int is_const_type, int is_volatile_type,
else
{
gen_type_die (type, context_die);
/* We have to get the type_main_variant here (and pass that to the
`lookup_type_die' routine) because the ..._TYPE node we have
might simply be a *copy* of some original type node (where the
@ -8558,7 +8558,7 @@ modified_type_die (tree type, int is_const_type, int is_volatile_type,
not the main variant. */
return lookup_type_die (type);
}
/* Builtin types don't have a DECL_ORIGINAL_TYPE. For those,
don't output a DW_TAG_typedef, since there isn't one in the
user's program; just attach a DW_AT_name to the type. */
@ -8572,7 +8572,7 @@ modified_type_die (tree type, int is_const_type, int is_volatile_type,
name = DECL_NAME (name);
add_name_attribute (mod_type_die, IDENTIFIER_POINTER (name));
}
if (qualified_type)
equate_type_number_to_die (qualified_type, mod_type_die);
@ -8795,9 +8795,9 @@ based_loc_descr (rtx reg, HOST_WIDE_INT offset)
}
gcc_assert (elim == (frame_pointer_needed ? hard_frame_pointer_rtx
: stack_pointer_rtx));
offset += frame_pointer_fb_offset;
offset += frame_pointer_fb_offset;
return new_loc_descr (DW_OP_fbreg, offset, 0);
return new_loc_descr (DW_OP_fbreg, offset, 0);
}
}
@ -9277,7 +9277,7 @@ loc_descriptor_from_tree_1 (tree loc, int want_address)
if (rtl == NULL_RTX)
return 0;
else if (GET_CODE (rtl) == CONST_INT)
else if (GET_CODE (rtl) == CONST_INT)
{
HOST_WIDE_INT val = INTVAL (rtl);
if (TYPE_UNSIGNED (TREE_TYPE (loc)))
@ -9528,13 +9528,13 @@ loc_descriptor_from_tree_1 (tree loc, int want_address)
case MIN_EXPR:
case MAX_EXPR:
{
const enum tree_code code =
TREE_CODE (loc) == MIN_EXPR ? GT_EXPR : LT_EXPR;
const enum tree_code code =
TREE_CODE (loc) == MIN_EXPR ? GT_EXPR : LT_EXPR;
loc = build3 (COND_EXPR, TREE_TYPE (loc),
loc = build3 (COND_EXPR, TREE_TYPE (loc),
build2 (code, integer_type_node,
TREE_OPERAND (loc, 0), TREE_OPERAND (loc, 1)),
TREE_OPERAND (loc, 1), TREE_OPERAND (loc, 0));
TREE_OPERAND (loc, 1), TREE_OPERAND (loc, 0));
}
/* ... fall through ... */
@ -9577,7 +9577,7 @@ loc_descriptor_from_tree_1 (tree loc, int want_address)
/* Leave front-end specific codes as simply unknown. This comes
up, for instance, with the C STMT_EXPR. */
if ((unsigned int) TREE_CODE (loc)
>= (unsigned int) LAST_AND_UNUSED_TREE_CODE)
>= (unsigned int) LAST_AND_UNUSED_TREE_CODE)
return 0;
#ifdef ENABLE_CHECKING
@ -10117,7 +10117,7 @@ reference_to_unused (tree * tp, int * walk_subtrees,
{
if (! EXPR_P (*tp) && ! GIMPLE_STMT_P (*tp) && ! CONSTANT_CLASS_P (*tp))
*walk_subtrees = 0;
if (DECL_P (*tp) && ! TREE_PUBLIC (*tp) && ! TREE_USED (*tp)
&& ! TREE_ASM_WRITTEN (*tp))
return *tp;
@ -10137,7 +10137,7 @@ reference_to_unused (tree * tp, int * walk_subtrees,
{
struct cgraph_node *node = cgraph_node (*tp);
if (!node->output)
return *tp;
return *tp;
}
return NULL_TREE;
@ -10173,7 +10173,7 @@ rtl_for_decl_init (tree init, tree type)
CONCAT: FIXME! */
else if (AGGREGATE_TYPE_P (type) || TREE_CODE (type) == COMPLEX_TYPE)
;
/* Vectors only work if their mode is supported by the target.
/* Vectors only work if their mode is supported by the target.
FIXME: generic vectors ought to work too. */
else if (TREE_CODE (type) == VECTOR_TYPE && TYPE_MODE (type) == BLKmode)
;
@ -10448,7 +10448,7 @@ add_location_or_const_value_attribute (dw_die_ref die, tree decl,
gcc_assert (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL
|| TREE_CODE (decl) == RESULT_DECL);
/* See if we possibly have multiple locations for this variable. */
loc_list = lookup_decl_loc (decl);
@ -10461,7 +10461,7 @@ add_location_or_const_value_attribute (dw_die_ref die, tree decl,
rtx varloc;
/* Now that we know what section we are using for a base,
actually construct the list of locations.
actually construct the list of locations.
The first location information is what is passed to the
function that creates the location list, and the remaining
locations just get added on to that list.
@ -10515,14 +10515,14 @@ add_location_or_const_value_attribute (dw_die_ref die, tree decl,
/* Try to get some constant RTL for this decl, and use that as the value of
the location. */
rtl = rtl_for_decl_location (decl);
if (rtl && (CONSTANT_P (rtl) || GET_CODE (rtl) == CONST_STRING))
{
add_const_value_attribute (die, rtl);
return;
}
/* If we have tried to generate the location otherwise, and it
didn't work out (we wouldn't be here if we did), and we have a one entry
location list, try generating a location from that. */
@ -11004,7 +11004,7 @@ add_abstract_origin_attribute (dw_die_ref die, tree origin)
if (TYPE_P (fn))
fn = TYPE_STUB_DECL (fn);
fn = decl_function_context (fn);
if (fn)
dwarf2out_abstract_function (fn);
@ -11907,7 +11907,7 @@ gen_subprogram_die (tree decl, dw_die_ref context_die)
{
if (DECL_DECLARED_INLINE_P (decl))
{
if (cgraph_function_possibly_inlined_p (decl))
if (cgraph_function_possibly_inlined_p (decl))
add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_inlined);
else
add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_declared_not_inlined);
@ -11915,9 +11915,9 @@ gen_subprogram_die (tree decl, dw_die_ref context_die)
else
{
if (cgraph_function_possibly_inlined_p (decl))
add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_inlined);
add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_inlined);
else
add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_not_inlined);
add_AT_unsigned (subr_die, DW_AT_inline, DW_INL_not_inlined);
}
equate_decl_number_to_die (decl, subr_die);
@ -11937,7 +11937,7 @@ gen_subprogram_die (tree decl, dw_die_ref context_die)
ASM_GENERATE_INTERNAL_LABEL (label_id, FUNC_END_LABEL,
current_function_funcdef_no);
add_AT_lbl_id (subr_die, DW_AT_high_pc, label_id);
add_pubname (decl, subr_die);
add_arange (decl, subr_die);
}
@ -11986,7 +11986,7 @@ gen_subprogram_die (tree decl, dw_die_ref context_die)
/* Compute a displacement from the "steady-state frame pointer" to
the CFA. The former is what all stack slots and argument slots
will reference in the rtl; the later is what we've told the
will reference in the rtl; the later is what we've told the
debugger about. We'll need to adjust all frame_base references
by this displacement. */
compute_frame_pointer_to_fb_displacement (cfa_fb_offset);
@ -12109,17 +12109,17 @@ gen_variable_die (tree decl, dw_die_ref context_die)
the program. For example, consider the C++
test case:
template <class T>
struct S { static const int i = 7; };
template <class T>
struct S { static const int i = 7; };
template <class T>
const int S<T>::i;
template <class T>
const int S<T>::i;
int f() { return S<int>::i; }
int f() { return S<int>::i; }
Here, S<int>::i is not DECL_EXTERNAL, but no
definition is required, so the compiler will
not emit a definition. */
not emit a definition. */
|| (TREE_CODE (decl) == VAR_DECL
&& DECL_COMDAT (decl) && !TREE_ASM_WRITTEN (decl))
|| class_or_namespace_scope_p (context_die));
@ -12997,8 +12997,8 @@ gen_block_die (tree stmt, dw_die_ref context_die, int depth)
if (debug_info_level > DINFO_LEVEL_TERSE)
/* We are not in terse mode so *any* local declaration counts
as being a "significant" one. */
must_output_die = (BLOCK_VARS (stmt) != NULL
&& (TREE_USED (stmt)
must_output_die = (BLOCK_VARS (stmt) != NULL
&& (TREE_USED (stmt)
|| TREE_ASM_WRITTEN (stmt)
|| BLOCK_ABSTRACT (stmt)));
else
@ -13055,14 +13055,14 @@ decls_for_scope (tree stmt, dw_die_ref context_die, int depth)
for (decl = BLOCK_VARS (stmt); decl != NULL; decl = TREE_CHAIN (decl))
{
dw_die_ref die;
if (TREE_CODE (decl) == FUNCTION_DECL)
die = lookup_decl_die (decl);
else if (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl))
die = lookup_type_die (TREE_TYPE (decl));
else
die = NULL;
if (die != NULL && die->die_parent == NULL)
add_child_die (context_die, die);
/* Do not produce debug information for static variables since
@ -13622,7 +13622,7 @@ dwarf2out_decl (tree decl)
if (debug_info_level <= DINFO_LEVEL_TERSE)
return;
if (lookup_decl_die (decl) != NULL)
return;
return;
break;
case TYPE_DECL:
@ -13773,7 +13773,7 @@ maybe_emit_file (struct dwarf_file_data * fd)
else
fd->emitted_number = 1;
last_emitted_file = fd;
if (DWARF2_ASM_LINE_DEBUG_INFO)
{
fprintf (asm_out_file, "\t.file %u ", fd->emitted_number);
@ -13781,7 +13781,7 @@ maybe_emit_file (struct dwarf_file_data * fd)
fputc ('\n', asm_out_file);
}
}
return fd->emitted_number;
}
@ -13844,7 +13844,7 @@ static void
dwarf2out_begin_function (tree fun)
{
htab_empty (decl_loc_table);
if (function_section (fun) != text_section)
have_multiple_function_sections = true;
}
@ -13860,7 +13860,7 @@ dwarf2out_source_line (unsigned int line, const char *filename)
&& line != 0)
{
int file_num = maybe_emit_file (lookup_filename (filename));
switch_to_section (current_function_section ());
/* If requested, emit something human-readable. */
@ -13879,7 +13879,7 @@ dwarf2out_source_line (unsigned int line, const char *filename)
else if (function_section (current_function_decl) != text_section)
{
dw_separate_line_info_ref line_info;
targetm.asm_out.internal_label (asm_out_file,
targetm.asm_out.internal_label (asm_out_file,
SEPARATE_LINE_CODE_LABEL,
separate_line_info_table_in_use);
@ -14090,7 +14090,7 @@ dwarf2out_init (const char *filename ATTRIBUTE_UNUSED)
ASM_GENERATE_INTERNAL_LABEL (abbrev_section_label,
DEBUG_ABBREV_SECTION_LABEL, 0);
ASM_GENERATE_INTERNAL_LABEL (text_section_label, TEXT_SECTION_LABEL, 0);
ASM_GENERATE_INTERNAL_LABEL (cold_text_section_label,
ASM_GENERATE_INTERNAL_LABEL (cold_text_section_label,
COLD_TEXT_SECTION_LABEL, 0);
ASM_GENERATE_INTERNAL_LABEL (cold_end_label, COLD_END_LABEL, 0);
@ -14149,7 +14149,7 @@ static void
verify_marks_clear (dw_die_ref die)
{
dw_die_ref c;
gcc_assert (! die->die_mark);
FOR_EACH_CHILD (die, c, verify_marks_clear (c));
}
@ -14162,7 +14162,7 @@ static void
prune_unmark_dies (dw_die_ref die)
{
dw_die_ref c;
if (die->die_mark)
die->die_mark = 0;
FOR_EACH_CHILD (die, c, prune_unmark_dies (c));
@ -14215,9 +14215,9 @@ prune_unused_types_mark (dw_die_ref die, int dokids)
prune_unused_types_walk_attribs (die);
/* If this node is a specification,
also mark the definition, if it exists. */
also mark the definition, if it exists. */
if (get_AT_flag (die, DW_AT_declaration) && die->die_definition)
prune_unused_types_mark (die->die_definition, 1);
prune_unused_types_mark (die->die_definition, 1);
}
if (dokids && die->die_mark != 2)
@ -14329,7 +14329,7 @@ prune_unused_types_prune (dw_die_ref die)
if (! die->die_child)
return;
c = die->die_child;
do {
dw_die_ref prev = c;
@ -14574,7 +14574,7 @@ dwarf2out_finish (const char *filename)
output_pubnames (pubtype_table);
}
#endif
/* Output the address range information. We only put functions in the arange
table, so don't write it out if we don't have any. */
if (fde_table_in_use)