static void gen_inlined_structure_type_die (tree, dw_die_ref);
static void gen_inlined_union_type_die (tree, dw_die_ref);
static dw_die_ref gen_enumeration_type_die (tree, dw_die_ref);
-static dw_die_ref gen_formal_parameter_die (tree, dw_die_ref);
+static dw_die_ref gen_formal_parameter_die (tree, tree, dw_die_ref);
static void gen_unspecified_parameters_die (tree, dw_die_ref);
static void gen_formal_types_die (tree, dw_die_ref);
static void gen_subprogram_die (tree, dw_die_ref);
-static void gen_variable_die (tree, dw_die_ref);
+static void gen_variable_die (tree, tree, dw_die_ref);
static void gen_const_die (tree, dw_die_ref);
static void gen_label_die (tree, dw_die_ref);
static void gen_lexical_block_die (tree, dw_die_ref, int);
static void decls_for_scope (tree, dw_die_ref, int);
static int is_redundant_typedef (const_tree);
static void gen_namespace_die (tree);
-static void gen_decl_die (tree, dw_die_ref);
+static void gen_decl_die (tree, tree, dw_die_ref);
static dw_die_ref force_decl_die (tree);
static dw_die_ref force_type_die (tree);
static dw_die_ref setup_namespace_context (tree, dw_die_ref);
argument type of some subprogram type. */
static dw_die_ref
-gen_formal_parameter_die (tree node, dw_die_ref context_die)
+gen_formal_parameter_die (tree node, tree origin, dw_die_ref context_die)
{
+ tree node_or_origin = node ? node : origin;
dw_die_ref parm_die
= new_die (DW_TAG_formal_parameter, context_die, node);
- tree origin;
- switch (TREE_CODE_CLASS (TREE_CODE (node)))
+ switch (TREE_CODE_CLASS (TREE_CODE (node_or_origin)))
{
case tcc_declaration:
- origin = decl_ultimate_origin (node);
+ if (!origin)
+ origin = decl_ultimate_origin (node);
if (origin != NULL)
add_abstract_origin_attribute (parm_die, origin);
else
add_AT_flag (parm_die, DW_AT_artificial, 1);
}
- equate_decl_number_to_die (node, parm_die);
- if (! DECL_ABSTRACT (node))
- add_location_or_const_value_attribute (parm_die, node, DW_AT_location);
+ if (node)
+ equate_decl_number_to_die (node, parm_die);
+ if (! DECL_ABSTRACT (node_or_origin))
+ add_location_or_const_value_attribute (parm_die, node_or_origin,
+ DW_AT_location);
break;
case tcc_type:
/* We were called with some kind of a ..._TYPE node. */
- add_type_attribute (parm_die, node, 0, 0, context_die);
+ add_type_attribute (parm_die, node_or_origin, 0, 0, context_die);
break;
default:
break;
/* Output a (nameless) DIE to represent the formal parameter itself. */
- parm_die = gen_formal_parameter_die (formal_type, context_die);
+ parm_die = gen_formal_parameter_die (formal_type, NULL, context_die);
if ((TREE_CODE (function_or_method_type) == METHOD_TYPE
&& link == first_parm_type)
|| (arg && DECL_ARTIFICIAL (arg)))
}
}
else
- gen_variable_die (member, type_die);
+ gen_variable_die (member, NULL_TREE, type_die);
pop_decl_scope ();
}
"__builtin_va_alist"))
gen_unspecified_parameters_die (parm, subr_die);
else
- gen_decl_die (parm, subr_die);
+ gen_decl_die (parm, NULL, subr_die);
}
/* Decide whether we need an unspecified_parameters DIE at the end.
{
/* Emit a DW_TAG_variable DIE for a named return value. */
if (DECL_NAME (DECL_RESULT (decl)))
- gen_decl_die (DECL_RESULT (decl), subr_die);
+ gen_decl_die (DECL_RESULT (decl), NULL, subr_die);
current_function_has_inlines = 0;
decls_for_scope (outer_scope, subr_die, 0);
return d->decl_id == e->decl_id && d->die_parent == e->die_parent;
}
-/* Generate a DIE to represent a declared data object. */
+/* Generate a DIE to represent a declared data object.
+ Either DECL or ORIGIN must be non-null. */
static void
-gen_variable_die (tree decl, dw_die_ref context_die)
+gen_variable_die (tree decl, tree origin, dw_die_ref context_die)
{
HOST_WIDE_INT off;
tree com_decl;
+ tree decl_or_origin = decl ? decl : origin;
dw_die_ref var_die;
- tree origin = decl_ultimate_origin (decl);
- dw_die_ref old_die = lookup_decl_die (decl);
- int declaration = (DECL_EXTERNAL (decl)
+ dw_die_ref old_die = decl ? lookup_decl_die (decl) : NULL;
+ int declaration = (DECL_EXTERNAL (decl_or_origin)
/* If DECL is COMDAT and has not actually been
emitted, we cannot take its address; there
might end up being no definition anywhere in
Here, S<int>::i is not DECL_EXTERNAL, but no
definition is required, so the compiler will
not emit a definition. */
- || (TREE_CODE (decl) == VAR_DECL
- && DECL_COMDAT (decl) && !TREE_ASM_WRITTEN (decl))
+ || (TREE_CODE (decl_or_origin) == VAR_DECL
+ && DECL_COMDAT (decl_or_origin)
+ && !TREE_ASM_WRITTEN (decl_or_origin))
|| class_or_namespace_scope_p (context_die));
- com_decl = fortran_common (decl, &off);
+ if (!origin)
+ origin = decl_ultimate_origin (decl);
+
+ com_decl = fortran_common (decl_or_origin, &off);
/* Symbol in common gets emitted as a child of the common block, in the form
of a data member. */
dw_loc_descr_ref loc;
die_node com_die_arg;
- var_die = lookup_decl_die (decl);
+ var_die = lookup_decl_die (decl_or_origin);
if (var_die)
{
if (get_AT (var_die, DW_AT_location) == NULL)
if (declaration)
add_AT_flag (var_die, DW_AT_declaration, 1);
- if (DECL_ABSTRACT (decl) || declaration)
+ if (decl && (DECL_ABSTRACT (decl) || declaration))
equate_decl_number_to_die (decl, var_die);
- if (! declaration && ! DECL_ABSTRACT (decl))
+ if (! declaration && ! DECL_ABSTRACT (decl_or_origin))
{
- if (TREE_CODE (decl) == VAR_DECL && TREE_STATIC (decl)
- && !TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
- defer_location (decl, var_die);
+ if (TREE_CODE (decl_or_origin) == VAR_DECL && TREE_STATIC (decl_or_origin)
+ && !TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl_or_origin)))
+ defer_location (decl_or_origin, var_die);
else
- add_location_or_const_value_attribute (var_die, decl, DW_AT_location);
- add_pubname (decl, var_die);
+ add_location_or_const_value_attribute (var_die,
+ decl_or_origin,
+ DW_AT_location);
+ add_pubname (decl_or_origin, var_die);
}
else
- tree_add_const_value_attribute (var_die, decl);
+ tree_add_const_value_attribute (var_die, decl_or_origin);
}
/* Generate a DIE to represent a named constant. */
{
dw_die_ref stmt_die = new_die (DW_TAG_lexical_block, context_die, stmt);
- if (! BLOCK_ABSTRACT (stmt))
+ if (! BLOCK_ABSTRACT (stmt) && TREE_ASM_WRITTEN (stmt))
add_high_low_attributes (stmt, stmt_die);
decls_for_scope (stmt, stmt_die, depth);
= new_die (DW_TAG_inlined_subroutine, context_die, stmt);
add_abstract_origin_attribute (subr_die, decl);
- add_high_low_attributes (stmt, subr_die);
+ if (TREE_ASM_WRITTEN (stmt))
+ add_high_low_attributes (stmt, subr_die);
add_call_src_coords_attributes (stmt, subr_die);
decls_for_scope (stmt, subr_die, depth);
if (child)
splice_child_die (context_die, child);
else
- gen_decl_die (member, context_die);
+ gen_decl_die (member, NULL, context_die);
}
/* Now output info about the function members (if any). */
if (child)
splice_child_die (context_die, child);
else
- gen_decl_die (member, context_die);
+ gen_decl_die (member, NULL, context_die);
}
}
gcc_assert (DECL_ORIGINAL_TYPE (TYPE_NAME (type)) != type);
TREE_ASM_WRITTEN (type) = 1;
- gen_decl_die (TYPE_NAME (type), context_die);
+ gen_decl_die (TYPE_NAME (type), NULL, context_die);
return;
}
gen_block_die (tree stmt, dw_die_ref context_die, int depth)
{
int must_output_die = 0;
- tree decl;
bool inlined_func;
/* Ignore blocks that are NULL. */
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
+ must_output_die = ((BLOCK_VARS (stmt) != NULL
+ || BLOCK_NUM_NONLOCALIZED_VARS (stmt))
&& (TREE_USED (stmt)
|| TREE_ASM_WRITTEN (stmt)
|| BLOCK_ABSTRACT (stmt)));
- else
- /* We are in terse mode, so only local (nested) function
- definitions count as "significant" local declarations. */
- for (decl = BLOCK_VARS (stmt);
- decl != NULL; decl = TREE_CHAIN (decl))
- if (TREE_CODE (decl) == FUNCTION_DECL
- && DECL_INITIAL (decl))
- {
- must_output_die = 1;
- break;
- }
+ else if ((TREE_USED (stmt)
+ || TREE_ASM_WRITTEN (stmt)
+ || BLOCK_ABSTRACT (stmt))
+ && !dwarf2out_ignore_block (stmt))
+ must_output_die = 1;
}
/* It would be a waste of space to generate a Dwarf DW_TAG_lexical_block
decls_for_scope (stmt, context_die, depth);
}
+/* Process variable DECL (or variable with origin ORIGIN) within
+ block STMT and add it to CONTEXT_DIE. */
+static void
+process_scope_var (tree stmt, tree decl, tree origin, dw_die_ref context_die)
+{
+ dw_die_ref die;
+ tree decl_or_origin = decl ? decl : origin;
+ tree ultimate_origin = origin ? decl_ultimate_origin (origin) : NULL;
+
+ if (ultimate_origin)
+ origin = ultimate_origin;
+
+ if (TREE_CODE (decl_or_origin) == FUNCTION_DECL)
+ die = lookup_decl_die (decl_or_origin);
+ else if (TREE_CODE (decl_or_origin) == TYPE_DECL
+ && TYPE_DECL_IS_STUB (decl_or_origin))
+ die = lookup_type_die (TREE_TYPE (decl_or_origin));
+ else
+ die = NULL;
+
+ if (die != NULL && die->die_parent == NULL)
+ add_child_die (context_die, die);
+ else if (TREE_CODE (decl_or_origin) == IMPORTED_DECL)
+ dwarf2out_imported_module_or_decl_1 (decl_or_origin, DECL_NAME (decl_or_origin),
+ stmt, context_die);
+ else
+ gen_decl_die (decl, origin, context_die);
+}
+
/* Generate all of the decls declared within a given scope and (recursively)
all of its sub-blocks. */
decls_for_scope (tree stmt, dw_die_ref context_die, int depth)
{
tree decl;
+ unsigned int i;
tree subblocks;
/* Ignore NULL blocks. */
if (stmt == NULL_TREE)
return;
- if (TREE_USED (stmt))
- {
- /* Output the DIEs to represent all of the data objects and typedefs
- declared directly within this block but not within any nested
- sub-blocks. Also, nested function and tag DIEs have been
- generated with a parent of NULL; fix that up now. */
- 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);
- else if (TREE_CODE (decl) == IMPORTED_DECL)
- dwarf2out_imported_module_or_decl_1 (decl, DECL_NAME (decl),
- stmt, context_die);
- else
- gen_decl_die (decl, context_die);
- }
- }
+ /* Output the DIEs to represent all of the data objects and typedefs
+ declared directly within this block but not within any nested
+ sub-blocks. Also, nested function and tag DIEs have been
+ generated with a parent of NULL; fix that up now. */
+ for (decl = BLOCK_VARS (stmt); decl != NULL; decl = TREE_CHAIN (decl))
+ process_scope_var (stmt, decl, NULL_TREE, context_die);
+ for (i = 0; i < BLOCK_NUM_NONLOCALIZED_VARS (stmt); i++)
+ process_scope_var (stmt, NULL, BLOCK_NONLOCALIZED_VAR (stmt, i),
+ context_die);
/* If we're at -g1, we're not interested in subblocks. */
if (debug_info_level <= DINFO_LEVEL_TERSE)
gen_decl_die() call. */
saved_external_flag = DECL_EXTERNAL (decl);
DECL_EXTERNAL (decl) = 1;
- gen_decl_die (decl, context_die);
+ gen_decl_die (decl, NULL, context_die);
DECL_EXTERNAL (decl) = saved_external_flag;
break;
if (is_fortran ())
return ns_context;
if (DECL_P (thing))
- gen_decl_die (thing, ns_context);
+ gen_decl_die (thing, NULL, ns_context);
else
gen_type_die (thing, ns_context);
}
/* Generate Dwarf debug information for a decl described by DECL. */
static void
-gen_decl_die (tree decl, dw_die_ref context_die)
+gen_decl_die (tree decl, tree origin, dw_die_ref context_die)
{
- tree origin;
+ tree decl_or_origin = decl ? decl : origin;
+ tree class_origin = NULL;
- if (DECL_P (decl) && DECL_IGNORED_P (decl))
+ if (DECL_P (decl_or_origin) && DECL_IGNORED_P (decl_or_origin))
return;
- switch (TREE_CODE (decl))
+ switch (TREE_CODE (decl_or_origin))
{
case ERROR_MARK:
break;
case FUNCTION_DECL:
/* Don't output any DIEs to represent mere function declarations,
unless they are class members or explicit block externs. */
- if (DECL_INITIAL (decl) == NULL_TREE && DECL_CONTEXT (decl) == NULL_TREE
- && (current_function_decl == NULL_TREE || DECL_ARTIFICIAL (decl)))
+ if (DECL_INITIAL (decl_or_origin) == NULL_TREE
+ && DECL_CONTEXT (decl_or_origin) == NULL_TREE
+ && (current_function_decl == NULL_TREE
+ || DECL_ARTIFICIAL (decl_or_origin)))
break;
#if 0
#endif
/* If we're emitting a clone, emit info for the abstract instance. */
- if (DECL_ORIGIN (decl) != decl)
- dwarf2out_abstract_function (DECL_ABSTRACT_ORIGIN (decl));
+ if (origin || DECL_ORIGIN (decl) != decl)
+ dwarf2out_abstract_function (origin ? origin : DECL_ABSTRACT_ORIGIN (decl));
/* If we're emitting an out-of-line copy of an inline function,
emit info for the abstract instance and set up to refer to it. */
gen_type_die (DECL_CONTEXT (decl), context_die);
/* And its containing type. */
- origin = decl_class_context (decl);
+ if (!origin)
+ origin = decl_class_context (decl);
if (origin != NULL_TREE)
gen_type_die_for_member (origin, decl, context_die);
}
/* Now output a DIE to represent the function itself. */
- gen_subprogram_die (decl, context_die);
+ if (decl)
+ gen_subprogram_die (decl, context_die);
break;
case TYPE_DECL:
/* Output any DIEs that are needed to specify the type of this data
object. */
- if (TREE_CODE (decl) == RESULT_DECL && DECL_BY_REFERENCE (decl))
- gen_type_die (TREE_TYPE (TREE_TYPE (decl)), context_die);
+ if (TREE_CODE (decl_or_origin) == RESULT_DECL
+ && DECL_BY_REFERENCE (decl_or_origin))
+ gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin)), context_die);
else
- gen_type_die (TREE_TYPE (decl), context_die);
+ gen_type_die (TREE_TYPE (decl_or_origin), context_die);
/* And its containing type. */
- origin = decl_class_context (decl);
- if (origin != NULL_TREE)
- gen_type_die_for_member (origin, decl, context_die);
+ class_origin = decl_class_context (decl_or_origin);
+ if (class_origin != NULL_TREE)
+ gen_type_die_for_member (class_origin, decl_or_origin, context_die);
/* And its containing namespace. */
- context_die = declare_in_namespace (decl, context_die);
+ context_die = declare_in_namespace (decl_or_origin, context_die);
/* Now output the DIE to represent the data object itself. This gets
complicated because of the possibility that the VAR_DECL really
represents an inlined instance of a formal parameter for an inline
function. */
- origin = decl_ultimate_origin (decl);
+ if (!origin)
+ origin = decl_ultimate_origin (decl);
if (origin != NULL_TREE && TREE_CODE (origin) == PARM_DECL)
- gen_formal_parameter_die (decl, context_die);
+ gen_formal_parameter_die (decl, origin, context_die);
else
- gen_variable_die (decl, context_die);
+ gen_variable_die (decl, origin, context_die);
break;
case FIELD_DECL:
break;
case PARM_DECL:
- if (DECL_BY_REFERENCE (decl))
- gen_type_die (TREE_TYPE (TREE_TYPE (decl)), context_die);
+ if (DECL_BY_REFERENCE (decl_or_origin))
+ gen_type_die (TREE_TYPE (TREE_TYPE (decl_or_origin)), context_die);
else
- gen_type_die (TREE_TYPE (decl), context_die);
- gen_formal_parameter_die (decl, context_die);
+ gen_type_die (TREE_TYPE (decl_or_origin), context_die);
+ gen_formal_parameter_die (decl, origin, context_die);
break;
case NAMESPACE_DECL:
return;
}
- gen_decl_die (decl, context_die);
+ gen_decl_die (decl, NULL, context_die);
}
/* Output a marker (i.e. a label) for the beginning of the generated code for
dwarf2out_ignore_block (const_tree block)
{
tree decl;
+ unsigned int i;
for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl))
if (TREE_CODE (decl) == FUNCTION_DECL
|| (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)))
return 0;
+ for (i = 0; i < BLOCK_NUM_NONLOCALIZED_VARS (block); i++)
+ {
+ decl = BLOCK_NONLOCALIZED_VAR (block, i);
+ if (TREE_CODE (decl) == FUNCTION_DECL
+ || (TREE_CODE (decl) == TYPE_DECL && TYPE_DECL_IS_STUB (decl)))
+ return 0;
+ }
return 1;
}
static tree declare_return_variable (copy_body_data *, tree, tree, tree *);
static bool inlinable_function_p (tree);
static void remap_block (tree *, copy_body_data *);
-static tree remap_decls (tree, copy_body_data *);
static void copy_bind_expr (tree *, int *, copy_body_data *);
static tree mark_local_for_remap_r (tree *, int *, void *);
static void unsave_expr_1 (tree);
return tmp;
}
+/* Decide if DECL can be put into BLOCK_NONLOCAL_VARs. */
+
+static bool
+can_be_nonlocal (tree decl, copy_body_data *id)
+{
+ /* We can not duplicate function decls. */
+ if (TREE_CODE (decl) == FUNCTION_DECL)
+ return true;
+
+ /* Local static vars must be non-local or we get multiple declaration
+ problems. */
+ if (TREE_CODE (decl) == VAR_DECL
+ && !auto_var_in_fn_p (decl, id->src_fn))
+ return true;
+
+ /* At the moment dwarf2out can handle only these types of nodes. We
+ can support more later. */
+ if (TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != PARM_DECL)
+ return false;
+
+ /* We must use global type. */
+ if (TREE_TYPE (decl) != remap_type (TREE_TYPE (decl), id))
+ return false;
+
+ /* Wihtout SSA we can't tell if variable is used. */
+ if (!gimple_in_ssa_p (cfun))
+ return false;
+
+ /* Live variables must be copied so we can attach DECL_RTL. */
+ if (var_ann (decl))
+ return false;
+
+ return true;
+}
+
static tree
-remap_decls (tree decls, copy_body_data *id)
+remap_decls (tree decls, VEC(tree,gc) **nonlocalized_list, copy_body_data *id)
{
tree old_var;
tree new_decls = NULL_TREE;
for (old_var = decls; old_var; old_var = TREE_CHAIN (old_var))
{
tree new_var;
+ tree origin_var = DECL_ORIGIN (old_var);
- /* We cannot chain the local static declarations into the local_decls
- as we can't duplicate them or break one decl rule. Go ahead
- and link them into local_decls. */
-
- if (!auto_var_in_fn_p (old_var, id->src_fn)
- && !DECL_EXTERNAL (old_var))
+ if (can_be_nonlocal (old_var, id))
{
- cfun->local_decls = tree_cons (NULL_TREE, old_var,
- cfun->local_decls);
+ if (TREE_CODE (old_var) == VAR_DECL
+ && (var_ann (old_var) || !gimple_in_ssa_p (cfun)))
+ cfun->local_decls = tree_cons (NULL_TREE, old_var,
+ cfun->local_decls);
+ if (debug_info_level > DINFO_LEVEL_TERSE
+ && !DECL_IGNORED_P (old_var)
+ && nonlocalized_list)
+ VEC_safe_push (tree, gc, *nonlocalized_list, origin_var);
continue;
}
/* If we didn't remap this variable, we can't mess with its
TREE_CHAIN. If we remapped this variable to the return slot, it's
already declared somewhere else, so don't declare it here. */
- if (!new_var || new_var == id->retvar)
+
+ if (new_var == id->retvar)
;
+ else if (!new_var)
+ {
+ if (debug_info_level > DINFO_LEVEL_TERSE
+ && !DECL_IGNORED_P (old_var)
+ && nonlocalized_list)
+ VEC_safe_push (tree, gc, *nonlocalized_list, origin_var);
+ }
else
{
gcc_assert (DECL_P (new_var));
TREE_USED (new_block) = TREE_USED (old_block);
BLOCK_ABSTRACT_ORIGIN (new_block) = old_block;
BLOCK_SOURCE_LOCATION (new_block) = BLOCK_SOURCE_LOCATION (old_block);
+ BLOCK_NONLOCALIZED_VARS (new_block)
+ = VEC_copy (tree, gc, BLOCK_NONLOCALIZED_VARS (old_block));
*block = new_block;
/* Remap its variables. */
- BLOCK_VARS (new_block) = remap_decls (BLOCK_VARS (old_block), id);
+ BLOCK_VARS (new_block) = remap_decls (BLOCK_VARS (old_block),
+ &BLOCK_NONLOCALIZED_VARS (new_block),
+ id);
fn = id->dst_fn;
if (BIND_EXPR_VARS (*tp))
/* This will remap a lot of the same decls again, but this should be
harmless. */
- BIND_EXPR_VARS (*tp) = remap_decls (BIND_EXPR_VARS (*tp), id);
+ BIND_EXPR_VARS (*tp) = remap_decls (BIND_EXPR_VARS (*tp), NULL, id);
}
harmless. */
new_vars = gimple_bind_vars (stmt);
if (new_vars)
- new_vars = remap_decls (new_vars, id);
+ new_vars = remap_decls (new_vars, NULL, id);
new_bind = gimple_build_bind (new_vars, new_body, new_block);
cfun->local_decls = tree_cons (NULL_TREE, var,
cfun->local_decls);
}
- else
- {
- cfun->local_decls = tree_cons (NULL_TREE, remap_decl (var, id),
- cfun->local_decls);
- }
+ else if (!can_be_nonlocal (var, id))
+ cfun->local_decls = tree_cons (NULL_TREE, remap_decl (var, id),
+ cfun->local_decls);
}
/* This is it. Duplicate the callee body. Assume callee is
/* This will remap a lot of the same decls again, but this should be
harmless. */
if (gimple_bind_vars (stmt))
- gimple_bind_set_vars (stmt, remap_decls (gimple_bind_vars (stmt), id));
+ gimple_bind_set_vars (stmt, remap_decls (gimple_bind_vars (stmt), NULL, id));
}
/* Keep iterating. */
tree var = TREE_VALUE (t_step);
if (TREE_STATIC (var) && !TREE_ASM_WRITTEN (var))
cfun->local_decls = tree_cons (NULL_TREE, var, cfun->local_decls);
- else
+ else if (!can_be_nonlocal (var, &id))
cfun->local_decls =
tree_cons (NULL_TREE, remap_decl (var, &id),
cfun->local_decls);
projects / gcc.git / commitdiff