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

builtins.c (expand_builtin_profile_func): Avoid C++ keywords. 

* builtins.c (expand_builtin_profile_func): Avoid C++ keywords.
	* calls.c (avoid_likely_spilled_reg): Likewise.
	* cfgexpand.c (gimple_assign_rhs_to_tree): Likewise.
	* cgraph.c (cgraph_clone_edge, cgraph_clone_node): Likewise.
	* config/i386/i386.c (ix86_expand_special_args_builtin,
	ix86_secondary_reload): Likewise.
	* except.c (struct eh_region, gen_eh_region_catch,
	remove_unreachable_regions, duplicate_eh_regions,
	assign_filter_values, build_post_landing_pads,
	sjlj_find_directly_reachable_regions, remove_eh_handler,
	reachable_next_level, foreach_reachable_handler,
	can_throw_internal_1, can_throw_external_1,
	collect_one_action_chain): Likewise.
	* expr.c (expand_expr_real_1, vector_mode_valid_p): Likewise.
	* fold-const.c (twoval_comparison_p, eval_subst): Likewise.
	* function.c (update_temp_slot_address, instantiate_new_reg,
	instantiate_virtual_regs_in_rtx,
	instantiate_virtual_regs_in_insn): Likewise.
	* gimple.c (extract_ops_from_tree, gimple_seq_copy): Likewise.
	* gimplify.c (gimplify_call_expr, gimplify_init_constructor,
	gimplify_cleanup_point_expr): Likewise.
	* ipa-cp.c (ipcp_lattice_changed): Likewise.
	* passes.c (next_pass_1): Likewise.
	* print-tree.c (print_node_brief, print_node): Likewise.
	* profile.c (branch_prob): Likewise.
	* tree-dump.c (dump_register): Likewise.
	* tree-eh.c (replace_goto_queue_cond_clause, lower_catch):
	Likewise.
	* tree-inline.c (remap_ssa_name, remap_type_1, remap_blocks,
	copy_statement_list, remap_gimple_op_r, copy_tree_body_r,
	copy_edges_for_bb, copy_cfg_body, copy_tree_r,
	copy_arguments_for_versioning, copy_static_chain): Likewise.
	* tree-into-ssa.c (names_replaced_by, add_to_repl_tbl,
	add_new_name_mapping, register_new_name_mapping): Likewise.
	* tree-mudflap.c (mf_xform_derefs): Likewise.
	* tree-predcom.c (struct chain, dump_chain, replace_ref_with,
	get_init_expr, combine_chains): Likewise.
	* tree-pretty-print.c (dump_generic_node): Likewise.
	* tree-ssa-structalias.c (create_variable_info_for): Likewise.
	* tree-vrp.c (simplify_cond_using_ranges): Likewise.
	* tree.c (substitute_in_expr, iterative_hash_expr): Likewise.
	* value-prof.c (gimple_duplicate_stmt_histograms): Likewise.

From-SVN: r138809
This commit is contained in:
Kaveh R. Ghazi 2008-08-06 15:57:09 +00:00 committed by Kaveh Ghazi
parent 01973e2672
commit 82d6e6fc38
27 changed files with 485 additions and 437 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

45
gcc/ChangeLog
View File

@ -1,3 +1,48 @@
2008-08-06 Kaveh R. Ghazi <ghazi@caip.rutgers.edu>
* builtins.c (expand_builtin_profile_func): Avoid C++ keywords.
* calls.c (avoid_likely_spilled_reg): Likewise.
* cfgexpand.c (gimple_assign_rhs_to_tree): Likewise.
* cgraph.c (cgraph_clone_edge, cgraph_clone_node): Likewise.
* config/i386/i386.c (ix86_expand_special_args_builtin,
ix86_secondary_reload): Likewise.
* except.c (struct eh_region, gen_eh_region_catch,
remove_unreachable_regions, duplicate_eh_regions,
assign_filter_values, build_post_landing_pads,
sjlj_find_directly_reachable_regions, remove_eh_handler,
reachable_next_level, foreach_reachable_handler,
can_throw_internal_1, can_throw_external_1,
collect_one_action_chain): Likewise.
* expr.c (expand_expr_real_1, vector_mode_valid_p): Likewise.
* fold-const.c (twoval_comparison_p, eval_subst): Likewise.
* function.c (update_temp_slot_address, instantiate_new_reg,
instantiate_virtual_regs_in_rtx,
instantiate_virtual_regs_in_insn): Likewise.
* gimple.c (extract_ops_from_tree, gimple_seq_copy): Likewise.
* gimplify.c (gimplify_call_expr, gimplify_init_constructor,
gimplify_cleanup_point_expr): Likewise.
* ipa-cp.c (ipcp_lattice_changed): Likewise.
* passes.c (next_pass_1): Likewise.
* print-tree.c (print_node_brief, print_node): Likewise.
* profile.c (branch_prob): Likewise.
* tree-dump.c (dump_register): Likewise.
* tree-eh.c (replace_goto_queue_cond_clause, lower_catch):
Likewise.
* tree-inline.c (remap_ssa_name, remap_type_1, remap_blocks,
copy_statement_list, remap_gimple_op_r, copy_tree_body_r,
copy_edges_for_bb, copy_cfg_body, copy_tree_r,
copy_arguments_for_versioning, copy_static_chain): Likewise.
* tree-into-ssa.c (names_replaced_by, add_to_repl_tbl,
add_new_name_mapping, register_new_name_mapping): Likewise.
* tree-mudflap.c (mf_xform_derefs): Likewise.
* tree-predcom.c (struct chain, dump_chain, replace_ref_with,
get_init_expr, combine_chains): Likewise.
* tree-pretty-print.c (dump_generic_node): Likewise.
* tree-ssa-structalias.c (create_variable_info_for): Likewise.
* tree-vrp.c (simplify_cond_using_ranges): Likewise.
* tree.c (substitute_in_expr, iterative_hash_expr): Likewise.
* value-prof.c (gimple_duplicate_stmt_histograms): Likewise.
2008-08-06 H.J. Lu <hongjiu.lu@intel.com> 2008-08-06 H.J. Lu <hongjiu.lu@intel.com>
PR middle-end/37010 PR middle-end/37010

10
gcc/builtins.c
View File

@ -5576,18 +5576,18 @@ expand_builtin_sprintf (tree exp, rtx target, enum machine_mode mode)
static rtx static rtx
expand_builtin_profile_func (bool exitp) expand_builtin_profile_func (bool exitp)
{ {
rtx this, which; rtx this_rtx, which;
this = DECL_RTL (current_function_decl); this_rtx = DECL_RTL (current_function_decl);
gcc_assert (MEM_P (this)); gcc_assert (MEM_P (this_rtx));
this = XEXP (this, 0); this_rtx = XEXP (this_rtx, 0);
if (exitp) if (exitp)
which = profile_function_exit_libfunc; which = profile_function_exit_libfunc;
else else
which = profile_function_entry_libfunc; which = profile_function_entry_libfunc;
emit_library_call (which, LCT_NORMAL, VOIDmode, 2, this, Pmode, emit_library_call (which, LCT_NORMAL, VOIDmode, 2, this_rtx, Pmode,
expand_builtin_return_addr (BUILT_IN_RETURN_ADDRESS, expand_builtin_return_addr (BUILT_IN_RETURN_ADDRESS,
0), 0),
Pmode); Pmode);

8
gcc/calls.c
View File

@ -1877,7 +1877,7 @@ shift_return_value (enum machine_mode mode, bool left_p, rtx value)
static rtx static rtx
avoid_likely_spilled_reg (rtx x) avoid_likely_spilled_reg (rtx x)
{ {
rtx new; rtx new_rtx;
if (REG_P (x) if (REG_P (x)
&& HARD_REGISTER_P (x) && HARD_REGISTER_P (x)
@ -1888,10 +1888,10 @@ avoid_likely_spilled_reg (rtx x)
and the whole point of this function is to avoid and the whole point of this function is to avoid
using the hard register directly in such a situation. */ using the hard register directly in such a situation. */
generating_concat_p = 0; generating_concat_p = 0;
new = gen_reg_rtx (GET_MODE (x)); new_rtx = gen_reg_rtx (GET_MODE (x));
generating_concat_p = 1; generating_concat_p = 1;
emit_move_insn (new, x); emit_move_insn (new_rtx, x);
return new; return new_rtx;
} }
return x; return x;
} }

10
gcc/cfgexpand.c
View File

@ -50,20 +50,20 @@ tree
gimple_assign_rhs_to_tree (gimple stmt) gimple_assign_rhs_to_tree (gimple stmt)
{ {
tree t; tree t;
enum gimple_rhs_class class; enum gimple_rhs_class grhs_class;
class = get_gimple_rhs_class (gimple_expr_code (stmt)); grhs_class = get_gimple_rhs_class (gimple_expr_code (stmt));
if (class == GIMPLE_BINARY_RHS) if (grhs_class == GIMPLE_BINARY_RHS)
t = build2 (gimple_assign_rhs_code (stmt), t = build2 (gimple_assign_rhs_code (stmt),
TREE_TYPE (gimple_assign_lhs (stmt)), TREE_TYPE (gimple_assign_lhs (stmt)),
gimple_assign_rhs1 (stmt), gimple_assign_rhs1 (stmt),
gimple_assign_rhs2 (stmt)); gimple_assign_rhs2 (stmt));
else if (class == GIMPLE_UNARY_RHS) else if (grhs_class == GIMPLE_UNARY_RHS)
t = build1 (gimple_assign_rhs_code (stmt), t = build1 (gimple_assign_rhs_code (stmt),
TREE_TYPE (gimple_assign_lhs (stmt)), TREE_TYPE (gimple_assign_lhs (stmt)),
gimple_assign_rhs1 (stmt)); gimple_assign_rhs1 (stmt));
else if (class == GIMPLE_SINGLE_RHS) else if (grhs_class == GIMPLE_SINGLE_RHS)
t = gimple_assign_rhs1 (stmt); t = gimple_assign_rhs1 (stmt);
else else
gcc_unreachable (); gcc_unreachable ();

56
gcc/cgraph.c
View File

@ -1159,25 +1159,25 @@ cgraph_clone_edge (struct cgraph_edge *e, struct cgraph_node *n,
gimple call_stmt, gcov_type count_scale, int freq_scale, gimple call_stmt, gcov_type count_scale, int freq_scale,
int loop_nest, bool update_original) int loop_nest, bool update_original)
{ {
struct cgraph_edge *new; struct cgraph_edge *new_edge;
gcov_type count = e->count * count_scale / REG_BR_PROB_BASE; gcov_type count = e->count * count_scale / REG_BR_PROB_BASE;
gcov_type freq = e->frequency * (gcov_type) freq_scale / CGRAPH_FREQ_BASE; gcov_type freq = e->frequency * (gcov_type) freq_scale / CGRAPH_FREQ_BASE;
if (freq > CGRAPH_FREQ_MAX) if (freq > CGRAPH_FREQ_MAX)
freq = CGRAPH_FREQ_MAX; freq = CGRAPH_FREQ_MAX;
new = cgraph_create_edge (n, e->callee, call_stmt, count, freq, new_edge = cgraph_create_edge (n, e->callee, call_stmt, count, freq,
e->loop_nest + loop_nest); e->loop_nest + loop_nest);
new->inline_failed = e->inline_failed; new_edge->inline_failed = e->inline_failed;
new->indirect_call = e->indirect_call; new_edge->indirect_call = e->indirect_call;
if (update_original) if (update_original)
{ {
e->count -= new->count; e->count -= new_edge->count;
if (e->count < 0) if (e->count < 0)
e->count = 0; e->count = 0;
} }
cgraph_call_edge_duplication_hooks (e, new); cgraph_call_edge_duplication_hooks (e, new_edge);
return new; return new_edge;
} }
/* Create node representing clone of N executed COUNT times. Decrease /* Create node representing clone of N executed COUNT times. Decrease
@ -1190,25 +1190,25 @@ struct cgraph_node *
cgraph_clone_node (struct cgraph_node *n, gcov_type count, int freq, cgraph_clone_node (struct cgraph_node *n, gcov_type count, int freq,
int loop_nest, bool update_original) int loop_nest, bool update_original)
{ {
struct cgraph_node *new = cgraph_create_node (); struct cgraph_node *new_node = cgraph_create_node ();
struct cgraph_edge *e; struct cgraph_edge *e;
gcov_type count_scale; gcov_type count_scale;
new->decl = n->decl; new_node->decl = n->decl;
new->origin = n->origin; new_node->origin = n->origin;
if (new->origin) if (new_node->origin)
{ {
new->next_nested = new->origin->nested; new_node->next_nested = new_node->origin->nested;
new->origin->nested = new; new_node->origin->nested = new_node;
} }
new->analyzed = n->analyzed; new_node->analyzed = n->analyzed;
new->local = n->local; new_node->local = n->local;
new->global = n->global; new_node->global = n->global;
new->rtl = n->rtl; new_node->rtl = n->rtl;
new->master_clone = n->master_clone; new_node->master_clone = n->master_clone;
new->count = count; new_node->count = count;
if (n->count) if (n->count)
count_scale = new->count * REG_BR_PROB_BASE / n->count; count_scale = new_node->count * REG_BR_PROB_BASE / n->count;
else else
count_scale = 0; count_scale = 0;
if (update_original) if (update_original)
@ -1219,17 +1219,17 @@ cgraph_clone_node (struct cgraph_node *n, gcov_type count, int freq,
} }
for (e = n->callees;e; e=e->next_callee) for (e = n->callees;e; e=e->next_callee)
cgraph_clone_edge (e, new, e->call_stmt, count_scale, freq, loop_nest, cgraph_clone_edge (e, new_node, e->call_stmt, count_scale, freq, loop_nest,
update_original); update_original);
new->next_clone = n->next_clone; new_node->next_clone = n->next_clone;
new->prev_clone = n; new_node->prev_clone = n;
n->next_clone = new; n->next_clone = new_node;
if (new->next_clone) if (new_node->next_clone)
new->next_clone->prev_clone = new; new_node->next_clone->prev_clone = new_node;
cgraph_call_node_duplication_hooks (n, new); cgraph_call_node_duplication_hooks (n, new_node);
return new; return new_node;
} }
/* Return true if N is an master_clone, (see cgraph_master_clone). */ /* Return true if N is an master_clone, (see cgraph_master_clone). */

20
gcc/config/i386/i386.c
View File

@ -22434,7 +22434,7 @@ ix86_expand_special_args_builtin (const struct builtin_description *d,
bool last_arg_constant = false; bool last_arg_constant = false;
const struct insn_data *insn_p = &insn_data[icode]; const struct insn_data *insn_p = &insn_data[icode];
enum machine_mode tmode = insn_p->operand[0].mode; enum machine_mode tmode = insn_p->operand[0].mode;
enum { load, store } class; enum { load, store } klass;
switch ((enum ix86_special_builtin_type) d->flag) switch ((enum ix86_special_builtin_type) d->flag)
{ {
@ -22446,7 +22446,7 @@ ix86_expand_special_args_builtin (const struct builtin_description *d,
case V4SF_FTYPE_PCFLOAT: case V4SF_FTYPE_PCFLOAT:
case V2DF_FTYPE_PCDOUBLE: case V2DF_FTYPE_PCDOUBLE:
nargs = 1; nargs = 1;
class = load; klass = load;
memory = 0; memory = 0;
break; break;
case VOID_FTYPE_PV2SF_V4SF: case VOID_FTYPE_PV2SF_V4SF:
@ -22457,14 +22457,14 @@ ix86_expand_special_args_builtin (const struct builtin_description *d,
case VOID_FTYPE_PDI_DI: case VOID_FTYPE_PDI_DI:
case VOID_FTYPE_PINT_INT: case VOID_FTYPE_PINT_INT:
nargs = 1; nargs = 1;
class = store; klass = store;
/* Reserve memory operand for target. */ /* Reserve memory operand for target. */
memory = ARRAY_SIZE (args); memory = ARRAY_SIZE (args);
break; break;
case V4SF_FTYPE_V4SF_PCV2SF: case V4SF_FTYPE_V4SF_PCV2SF:
case V2DF_FTYPE_V2DF_PCDOUBLE: case V2DF_FTYPE_V2DF_PCDOUBLE:
nargs = 2; nargs = 2;
class = load; klass = load;
memory = 1; memory = 1;
break; break;
default: default:
@ -22473,7 +22473,7 @@ ix86_expand_special_args_builtin (const struct builtin_description *d,
gcc_assert (nargs <= ARRAY_SIZE (args)); gcc_assert (nargs <= ARRAY_SIZE (args));
if (class == store) if (klass == store)
{ {
arg = CALL_EXPR_ARG (exp, 0); arg = CALL_EXPR_ARG (exp, 0);
op = expand_normal (arg); op = expand_normal (arg);
@ -22550,7 +22550,7 @@ ix86_expand_special_args_builtin (const struct builtin_description *d,
if (! pat) if (! pat)
return 0; return 0;
emit_insn (pat); emit_insn (pat);
return class == store ? 0 : target; return klass == store ? 0 : target;
} }
/* Return the integer constant in ARG. Constrain it to be in the range /* Return the integer constant in ARG. Constrain it to be in the range
@ -23417,16 +23417,16 @@ ix86_preferred_output_reload_class (rtx x, enum reg_class regclass)
} }
static enum reg_class static enum reg_class
ix86_secondary_reload (bool in_p, rtx x, enum reg_class class, ix86_secondary_reload (bool in_p, rtx x, enum reg_class rclass,
enum machine_mode mode, enum machine_mode mode,
secondary_reload_info *sri ATTRIBUTE_UNUSED) secondary_reload_info *sri ATTRIBUTE_UNUSED)
{ {
/* QImode spills from non-QI registers require /* QImode spills from non-QI registers require
intermediate register on 32bit targets. */ intermediate register on 32bit targets. */
if (!in_p && mode == QImode && !TARGET_64BIT if (!in_p && mode == QImode && !TARGET_64BIT
&& (class == GENERAL_REGS && (rclass == GENERAL_REGS
|| class == LEGACY_REGS || rclass == LEGACY_REGS
|| class == INDEX_REGS)) || rclass == INDEX_REGS))
{ {
int regno; int regno;

110
gcc/except.c
View File

@ -148,9 +148,9 @@ struct eh_region GTY(())
/* A list of catch blocks, a surrounding try block, /* A list of catch blocks, a surrounding try block,
and the label for continuing after a catch. */ and the label for continuing after a catch. */
struct eh_region_u_try { struct eh_region_u_try {
struct eh_region *catch; struct eh_region *eh_catch;
struct eh_region *last_catch; struct eh_region *last_catch;
} GTY ((tag ("ERT_TRY"))) try; } GTY ((tag ("ERT_TRY"))) eh_try;
/* The list through the catch handlers, the list of type objects /* The list through the catch handlers, the list of type objects
matched, and the list of associated filters. */ matched, and the list of associated filters. */
@ -159,7 +159,7 @@ struct eh_region GTY(())
struct eh_region *prev_catch; struct eh_region *prev_catch;
tree type_list; tree type_list;
tree filter_list; tree filter_list;
} GTY ((tag ("ERT_CATCH"))) catch; } GTY ((tag ("ERT_CATCH"))) eh_catch;
/* A tree_list of allowed types. */ /* A tree_list of allowed types. */
struct eh_region_u_allowed { struct eh_region_u_allowed {
@ -171,7 +171,7 @@ struct eh_region GTY(())
for a throw. */ for a throw. */
struct eh_region_u_throw { struct eh_region_u_throw {
tree type; tree type;
} GTY ((tag ("ERT_THROW"))) throw; } GTY ((tag ("ERT_THROW"))) eh_throw;
/* Retain the cleanup expression even after expansion so that /* Retain the cleanup expression even after expansion so that
we can match up fixup regions. */ we can match up fixup regions. */
@ -479,14 +479,14 @@ gen_eh_region_catch (struct eh_region *t, tree type_or_list)
} }
c = gen_eh_region (ERT_CATCH, t->outer); c = gen_eh_region (ERT_CATCH, t->outer);
c->u.catch.type_list = type_list; c->u.eh_catch.type_list = type_list;
l = t->u.try.last_catch; l = t->u.eh_try.last_catch;
c->u.catch.prev_catch = l; c->u.eh_catch.prev_catch = l;
if (l) if (l)
l->u.catch.next_catch = c; l->u.eh_catch.next_catch = c;
else else
t->u.try.catch = c; t->u.eh_try.eh_catch = c;
t->u.try.last_catch = c; t->u.eh_try.last_catch = c;
return c; return c;
} }
@ -683,7 +683,7 @@ remove_unreachable_regions (rtx insns)
/* TRY regions are reachable if any of its CATCH regions /* TRY regions are reachable if any of its CATCH regions
are reachable. */ are reachable. */
struct eh_region *c; struct eh_region *c;
for (c = r->u.try.catch; c ; c = c->u.catch.next_catch) for (c = r->u.eh_try.eh_catch; c ; c = c->u.eh_catch.next_catch)
if (reachable[c->region_number]) if (reachable[c->region_number])
{ {
kill_it = false; kill_it = false;
@ -988,17 +988,17 @@ duplicate_eh_regions (struct function *ifun, duplicate_eh_regions_map map,
switch (cur->type) switch (cur->type)
{ {
case ERT_TRY: case ERT_TRY:
if (cur->u.try.catch) if (cur->u.eh_try.eh_catch)
REMAP (cur->u.try.catch); REMAP (cur->u.eh_try.eh_catch);
if (cur->u.try.last_catch) if (cur->u.eh_try.last_catch)
REMAP (cur->u.try.last_catch); REMAP (cur->u.eh_try.last_catch);
break; break;
case ERT_CATCH: case ERT_CATCH:
if (cur->u.catch.next_catch) if (cur->u.eh_catch.next_catch)
REMAP (cur->u.catch.next_catch); REMAP (cur->u.eh_catch.next_catch);
if (cur->u.catch.prev_catch) if (cur->u.eh_catch.prev_catch)
REMAP (cur->u.catch.prev_catch); REMAP (cur->u.eh_catch.prev_catch);
break; break;
case ERT_CLEANUP: case ERT_CLEANUP:
@ -1290,21 +1290,21 @@ assign_filter_values (void)
case ERT_CATCH: case ERT_CATCH:
/* Whatever type_list is (NULL or true list), we build a list /* Whatever type_list is (NULL or true list), we build a list
of filters for the region. */ of filters for the region. */
r->u.catch.filter_list = NULL_TREE; r->u.eh_catch.filter_list = NULL_TREE;
if (r->u.catch.type_list != NULL) if (r->u.eh_catch.type_list != NULL)
{ {
/* Get a filter value for each of the types caught and store /* Get a filter value for each of the types caught and store
them in the region's dedicated list. */ them in the region's dedicated list. */
tree tp_node = r->u.catch.type_list; tree tp_node = r->u.eh_catch.type_list;
for (;tp_node; tp_node = TREE_CHAIN (tp_node)) for (;tp_node; tp_node = TREE_CHAIN (tp_node))
{ {
int flt = add_ttypes_entry (ttypes, TREE_VALUE (tp_node)); int flt = add_ttypes_entry (ttypes, TREE_VALUE (tp_node));
tree flt_node = build_int_cst (NULL_TREE, flt); tree flt_node = build_int_cst (NULL_TREE, flt);
r->u.catch.filter_list r->u.eh_catch.filter_list
= tree_cons (NULL_TREE, flt_node, r->u.catch.filter_list); = tree_cons (NULL_TREE, flt_node, r->u.eh_catch.filter_list);
} }
} }
else else
@ -1314,8 +1314,8 @@ assign_filter_values (void)
int flt = add_ttypes_entry (ttypes, NULL); int flt = add_ttypes_entry (ttypes, NULL);
tree flt_node = build_int_cst (NULL_TREE, flt); tree flt_node = build_int_cst (NULL_TREE, flt);
r->u.catch.filter_list r->u.eh_catch.filter_list
= tree_cons (NULL_TREE, flt_node, r->u.catch.filter_list); = tree_cons (NULL_TREE, flt_node, r->u.eh_catch.filter_list);
} }
break; break;
@ -1400,17 +1400,17 @@ build_post_landing_pads (void)
Rapid prototyping sez a sequence of ifs. */ Rapid prototyping sez a sequence of ifs. */
{ {
struct eh_region *c; struct eh_region *c;
for (c = region->u.try.catch; c ; c = c->u.catch.next_catch) for (c = region->u.eh_try.eh_catch; c ; c = c->u.eh_catch.next_catch)
{ {
if (c->u.catch.type_list == NULL) if (c->u.eh_catch.type_list == NULL)
emit_jump (c->label); emit_jump (c->label);
else else
{ {
/* Need for one cmp/jump per type caught. Each type /* Need for one cmp/jump per type caught. Each type
list entry has a matching entry in the filter list list entry has a matching entry in the filter list
(see assign_filter_values). */ (see assign_filter_values). */
tree tp_node = c->u.catch.type_list; tree tp_node = c->u.eh_catch.type_list;
tree flt_node = c->u.catch.filter_list; tree flt_node = c->u.eh_catch.filter_list;
for (; tp_node; ) for (; tp_node; )
{ {
@ -1437,7 +1437,7 @@ build_post_landing_pads (void)
seq = get_insns (); seq = get_insns ();
end_sequence (); end_sequence ();
emit_to_new_bb_before (seq, region->u.try.catch->label); emit_to_new_bb_before (seq, region->u.eh_try.eh_catch->label);
break; break;
@ -1651,7 +1651,7 @@ sjlj_find_directly_reachable_regions (struct sjlj_lp_info *lp_info)
type_thrown = NULL_TREE; type_thrown = NULL_TREE;
if (region->type == ERT_THROW) if (region->type == ERT_THROW)
{ {
type_thrown = region->u.throw.type; type_thrown = region->u.eh_throw.type;
region = region->outer; region = region->outer;
} }
@ -2204,28 +2204,28 @@ remove_eh_handler (struct eh_region *region)
if (region->type == ERT_CATCH) if (region->type == ERT_CATCH)
{ {
struct eh_region *try, *next, *prev; struct eh_region *eh_try, *next, *prev;
for (try = region->next_peer; for (eh_try = region->next_peer;
try->type == ERT_CATCH; eh_try->type == ERT_CATCH;
try = try->next_peer) eh_try = eh_try->next_peer)
continue; continue;
gcc_assert (try->type == ERT_TRY); gcc_assert (eh_try->type == ERT_TRY);
next = region->u.catch.next_catch; next = region->u.eh_catch.next_catch;
prev = region->u.catch.prev_catch; prev = region->u.eh_catch.prev_catch;
if (next) if (next)
next->u.catch.prev_catch = prev; next->u.eh_catch.prev_catch = prev;
else else
try->u.try.last_catch = prev; eh_try->u.eh_try.last_catch = prev;
if (prev) if (prev)
prev->u.catch.next_catch = next; prev->u.eh_catch.next_catch = next;
else else
{ {
try->u.try.catch = next; eh_try->u.eh_try.eh_catch = next;
if (! next) if (! next)
remove_eh_handler (try); remove_eh_handler (eh_try);
} }
} }
} }
@ -2388,10 +2388,10 @@ reachable_next_level (struct eh_region *region, tree type_thrown,
struct eh_region *c; struct eh_region *c;
enum reachable_code ret = RNL_NOT_CAUGHT; enum reachable_code ret = RNL_NOT_CAUGHT;
for (c = region->u.try.catch; c ; c = c->u.catch.next_catch) for (c = region->u.eh_try.eh_catch; c ; c = c->u.eh_catch.next_catch)
{ {
/* A catch-all handler ends the search. */ /* A catch-all handler ends the search. */
if (c->u.catch.type_list == NULL) if (c->u.eh_catch.type_list == NULL)
{ {
add_reachable_handler (info, region, c); add_reachable_handler (info, region, c);
return RNL_CAUGHT; return RNL_CAUGHT;
@ -2400,7 +2400,7 @@ reachable_next_level (struct eh_region *region, tree type_thrown,
if (type_thrown) if (type_thrown)
{ {
/* If we have at least one type match, end the search. */ /* If we have at least one type match, end the search. */
tree tp_node = c->u.catch.type_list; tree tp_node = c->u.eh_catch.type_list;
for (; tp_node; tp_node = TREE_CHAIN (tp_node)) for (; tp_node; tp_node = TREE_CHAIN (tp_node))
{ {
@ -2438,7 +2438,7 @@ reachable_next_level (struct eh_region *region, tree type_thrown,
ret = RNL_MAYBE_CAUGHT; ret = RNL_MAYBE_CAUGHT;
else else
{ {
tree tp_node = c->u.catch.type_list; tree tp_node = c->u.eh_catch.type_list;
bool maybe_reachable = false; bool maybe_reachable = false;
/* Compute the potential reachability of this handler and /* Compute the potential reachability of this handler and
@ -2562,7 +2562,7 @@ foreach_reachable_handler (int region_number, bool is_resx,
} }
else if (region->type == ERT_THROW) else if (region->type == ERT_THROW)
{ {
type_thrown = region->u.throw.type; type_thrown = region->u.eh_throw.type;
region = region->outer; region = region->outer;
} }
@ -2645,7 +2645,7 @@ can_throw_internal_1 (int region_number, bool is_resx)
region = region->outer; region = region->outer;
else if (region->type == ERT_THROW) else if (region->type == ERT_THROW)
{ {
type_thrown = region->u.throw.type; type_thrown = region->u.eh_throw.type;
region = region->outer; region = region->outer;
} }
@ -2705,7 +2705,7 @@ can_throw_external_1 (int region_number, bool is_resx)
region = region->outer; region = region->outer;
else if (region->type == ERT_THROW) else if (region->type == ERT_THROW)
{ {
type_thrown = region->u.throw.type; type_thrown = region->u.eh_throw.type;
region = region->outer; region = region->outer;
} }
@ -3109,14 +3109,14 @@ collect_one_action_chain (htab_t ar_hash, struct eh_region *region)
search outer regions. Use a magic -3 value to record search outer regions. Use a magic -3 value to record
that we haven't done the outer search. */ that we haven't done the outer search. */
next = -3; next = -3;
for (c = region->u.try.last_catch; c ; c = c->u.catch.prev_catch) for (c = region->u.eh_try.last_catch; c ; c = c->u.eh_catch.prev_catch)
{ {
if (c->u.catch.type_list == NULL) if (c->u.eh_catch.type_list == NULL)
{ {
/* Retrieve the filter from the head of the filter list /* Retrieve the filter from the head of the filter list
where we have stored it (see assign_filter_values). */ where we have stored it (see assign_filter_values). */
int filter int filter
= TREE_INT_CST_LOW (TREE_VALUE (c->u.catch.filter_list)); = TREE_INT_CST_LOW (TREE_VALUE (c->u.eh_catch.filter_list));
next = add_action_record (ar_hash, filter, 0); next = add_action_record (ar_hash, filter, 0);
} }
@ -3141,7 +3141,7 @@ collect_one_action_chain (htab_t ar_hash, struct eh_region *region)
next = add_action_record (ar_hash, 0, 0); next = add_action_record (ar_hash, 0, 0);
} }
flt_node = c->u.catch.filter_list; flt_node = c->u.eh_catch.filter_list;
for (; flt_node; flt_node = TREE_CHAIN (flt_node)) for (; flt_node; flt_node = TREE_CHAIN (flt_node))
{ {
int filter = TREE_INT_CST_LOW (TREE_VALUE (flt_node)); int filter = TREE_INT_CST_LOW (TREE_VALUE (flt_node));

34
gcc/expr.c
View File

@ -7944,20 +7944,20 @@ expand_expr_real_1 (tree exp, rtx target, enum machine_mode tmode,
if (mode == BLKmode) if (mode == BLKmode)
{ {
HOST_WIDE_INT size = GET_MODE_BITSIZE (ext_mode); HOST_WIDE_INT size = GET_MODE_BITSIZE (ext_mode);
rtx new; rtx new_rtx;
/* If the reference doesn't use the alias set of its type, /* If the reference doesn't use the alias set of its type,
we cannot create the temporary using that type. */ we cannot create the temporary using that type. */
if (component_uses_parent_alias_set (exp)) if (component_uses_parent_alias_set (exp))
{ {
new = assign_stack_local (ext_mode, size, 0); new_rtx = assign_stack_local (ext_mode, size, 0);
set_mem_alias_set (new, get_alias_set (exp)); set_mem_alias_set (new_rtx, get_alias_set (exp));
} }
else else
new = assign_stack_temp_for_type (ext_mode, size, 0, type); new_rtx = assign_stack_temp_for_type (ext_mode, size, 0, type);
emit_move_insn (new, op0); emit_move_insn (new_rtx, op0);
op0 = copy_rtx (new); op0 = copy_rtx (new_rtx);
PUT_MODE (op0, BLKmode); PUT_MODE (op0, BLKmode);
set_mem_attributes (op0, exp, 1); set_mem_attributes (op0, exp, 1);
} }
@ -8198,9 +8198,9 @@ expand_expr_real_1 (tree exp, rtx target, enum machine_mode tmode,
HOST_WIDE_INT temp_size HOST_WIDE_INT temp_size
= MAX (int_size_in_bytes (inner_type), = MAX (int_size_in_bytes (inner_type),
(HOST_WIDE_INT) GET_MODE_SIZE (TYPE_MODE (type))); (HOST_WIDE_INT) GET_MODE_SIZE (TYPE_MODE (type)));
rtx new = assign_stack_temp_for_type (TYPE_MODE (type), rtx new_rtx = assign_stack_temp_for_type (TYPE_MODE (type),
temp_size, 0, type); temp_size, 0, type);
rtx new_with_op0_mode = adjust_address (new, GET_MODE (op0), 0); rtx new_with_op0_mode = adjust_address (new_rtx, GET_MODE (op0), 0);
gcc_assert (!TREE_ADDRESSABLE (exp)); gcc_assert (!TREE_ADDRESSABLE (exp));
@ -8212,7 +8212,7 @@ expand_expr_real_1 (tree exp, rtx target, enum machine_mode tmode,
else else
emit_move_insn (new_with_op0_mode, op0); emit_move_insn (new_with_op0_mode, op0);
op0 = new; op0 = new_rtx;
} }
op0 = adjust_address (op0, TYPE_MODE (type), 0); op0 = adjust_address (op0, TYPE_MODE (type), 0);
@ -9997,16 +9997,16 @@ try_tablejump (tree index_type, tree index_expr, tree minval, tree range,
int int
vector_mode_valid_p (enum machine_mode mode) vector_mode_valid_p (enum machine_mode mode)
{ {
enum mode_class class = GET_MODE_CLASS (mode); enum mode_class mclass = GET_MODE_CLASS (mode);
enum machine_mode innermode; enum machine_mode innermode;
/* Doh! What's going on? */ /* Doh! What's going on? */
if (class != MODE_VECTOR_INT if (mclass != MODE_VECTOR_INT
&& class != MODE_VECTOR_FLOAT && mclass != MODE_VECTOR_FLOAT
&& class != MODE_VECTOR_FRACT && mclass != MODE_VECTOR_FRACT
&& class != MODE_VECTOR_UFRACT && mclass != MODE_VECTOR_UFRACT
&& class != MODE_VECTOR_ACCUM && mclass != MODE_VECTOR_ACCUM
&& class != MODE_VECTOR_UACCUM) && mclass != MODE_VECTOR_UACCUM)
return 0; return 0;
/* Hardware support. Woo hoo! */ /* Hardware support. Woo hoo! */

28
gcc/fold-const.c
View File

@ -3391,17 +3391,17 @@ static int
twoval_comparison_p (tree arg, tree *cval1, tree *cval2, int *save_p) twoval_comparison_p (tree arg, tree *cval1, tree *cval2, int *save_p)
{ {
enum tree_code code = TREE_CODE (arg); enum tree_code code = TREE_CODE (arg);
enum tree_code_class class = TREE_CODE_CLASS (code); enum tree_code_class tclass = TREE_CODE_CLASS (code);
/* We can handle some of the tcc_expression cases here. */ /* We can handle some of the tcc_expression cases here. */
if (class == tcc_expression && code == TRUTH_NOT_EXPR) if (tclass == tcc_expression && code == TRUTH_NOT_EXPR)
class = tcc_unary; tclass = tcc_unary;
else if (class == tcc_expression else if (tclass == tcc_expression
&& (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR
|| code == COMPOUND_EXPR)) || code == COMPOUND_EXPR))
class = tcc_binary; tclass = tcc_binary;
else if (class == tcc_expression && code == SAVE_EXPR else if (tclass == tcc_expression && code == SAVE_EXPR
&& ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg, 0))) && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg, 0)))
{ {
/* If we've already found a CVAL1 or CVAL2, this expression is /* If we've already found a CVAL1 or CVAL2, this expression is
@ -3409,11 +3409,11 @@ twoval_comparison_p (tree arg, tree *cval1, tree *cval2, int *save_p)
if (*cval1 || *cval2) if (*cval1 || *cval2)
return 0; return 0;
class = tcc_unary; tclass = tcc_unary;
*save_p = 1; *save_p = 1;
} }
switch (class) switch (tclass)
{ {
case tcc_unary: case tcc_unary:
return twoval_comparison_p (TREE_OPERAND (arg, 0), cval1, cval2, save_p); return twoval_comparison_p (TREE_OPERAND (arg, 0), cval1, cval2, save_p);
@ -3484,16 +3484,16 @@ eval_subst (tree arg, tree old0, tree new0, tree old1, tree new1)
{ {
tree type = TREE_TYPE (arg); tree type = TREE_TYPE (arg);
enum tree_code code = TREE_CODE (arg); enum tree_code code = TREE_CODE (arg);
enum tree_code_class class = TREE_CODE_CLASS (code); enum tree_code_class tclass = TREE_CODE_CLASS (code);
/* We can handle some of the tcc_expression cases here. */ /* We can handle some of the tcc_expression cases here. */
if (class == tcc_expression && code == TRUTH_NOT_EXPR) if (tclass == tcc_expression && code == TRUTH_NOT_EXPR)
class = tcc_unary; tclass = tcc_unary;
else if (class == tcc_expression else if (tclass == tcc_expression
&& (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR)) && (code == TRUTH_ANDIF_EXPR || code == TRUTH_ORIF_EXPR))
class = tcc_binary; tclass = tcc_binary;
switch (class) switch (tclass)
{ {
case tcc_unary: case tcc_unary:
return fold_build1 (code, type, return fold_build1 (code, type,

131
gcc/function.c
View File

@ -932,59 +932,60 @@ find_temp_slot_from_address (rtx x)
return 0; return 0;
} }
/* Indicate that NEW is an alternate way of referring to the temp slot /* Indicate that NEW_RTX is an alternate way of referring to the temp
that previously was known by OLD. */ slot that previously was known by OLD_RTX. */
void void
update_temp_slot_address (rtx old, rtx new) update_temp_slot_address (rtx old_rtx, rtx new_rtx)
{ {
struct temp_slot *p; struct temp_slot *p;
if (rtx_equal_p (old, new)) if (rtx_equal_p (old_rtx, new_rtx))
return; return;
p = find_temp_slot_from_address (old); p = find_temp_slot_from_address (old_rtx);
/* If we didn't find one, see if both OLD is a PLUS. If so, and NEW /* If we didn't find one, see if both OLD_RTX is a PLUS. If so, and
is a register, see if one operand of the PLUS is a temporary NEW_RTX is a register, see if one operand of the PLUS is a
location. If so, NEW points into it. Otherwise, if both OLD and temporary location. If so, NEW_RTX points into it. Otherwise,
NEW are a PLUS and if there is a register in common between them. if both OLD_RTX and NEW_RTX are a PLUS and if there is a register
If so, try a recursive call on those values. */ in common between them. If so, try a recursive call on those
values. */
if (p == 0) if (p == 0)
{ {
if (GET_CODE (old) != PLUS) if (GET_CODE (old_rtx) != PLUS)
return; return;
if (REG_P (new)) if (REG_P (new_rtx))
{ {
update_temp_slot_address (XEXP (old, 0), new); update_temp_slot_address (XEXP (old_rtx, 0), new_rtx);
update_temp_slot_address (XEXP (old, 1), new); update_temp_slot_address (XEXP (old_rtx, 1), new_rtx);
return; return;
} }
else if (GET_CODE (new) != PLUS) else if (GET_CODE (new_rtx) != PLUS)
return; return;
if (rtx_equal_p (XEXP (old, 0), XEXP (new, 0))) if (rtx_equal_p (XEXP (old_rtx, 0), XEXP (new_rtx, 0)))
update_temp_slot_address (XEXP (old, 1), XEXP (new, 1)); update_temp_slot_address (XEXP (old_rtx, 1), XEXP (new_rtx, 1));
else if (rtx_equal_p (XEXP (old, 1), XEXP (new, 0))) else if (rtx_equal_p (XEXP (old_rtx, 1), XEXP (new_rtx, 0)))
update_temp_slot_address (XEXP (old, 0), XEXP (new, 1)); update_temp_slot_address (XEXP (old_rtx, 0), XEXP (new_rtx, 1));
else if (rtx_equal_p (XEXP (old, 0), XEXP (new, 1))) else if (rtx_equal_p (XEXP (old_rtx, 0), XEXP (new_rtx, 1)))
update_temp_slot_address (XEXP (old, 1), XEXP (new, 0)); update_temp_slot_address (XEXP (old_rtx, 1), XEXP (new_rtx, 0));
else if (rtx_equal_p (XEXP (old, 1), XEXP (new, 1))) else if (rtx_equal_p (XEXP (old_rtx, 1), XEXP (new_rtx, 1)))
update_temp_slot_address (XEXP (old, 0), XEXP (new, 0)); update_temp_slot_address (XEXP (old_rtx, 0), XEXP (new_rtx, 0));
return; return;
} }
/* Otherwise add an alias for the temp's address. */ /* Otherwise add an alias for the temp's address. */
else if (p->address == 0) else if (p->address == 0)
p->address = new; p->address = new_rtx;
else else
{ {
if (GET_CODE (p->address) != EXPR_LIST) if (GET_CODE (p->address) != EXPR_LIST)
p->address = gen_rtx_EXPR_LIST (VOIDmode, p->address, NULL_RTX); p->address = gen_rtx_EXPR_LIST (VOIDmode, p->address, NULL_RTX);
p->address = gen_rtx_EXPR_LIST (VOIDmode, new, p->address); p->address = gen_rtx_EXPR_LIST (VOIDmode, new_rtx, p->address);
} }
} }
@ -1210,7 +1211,7 @@ static int cfa_offset;
static rtx static rtx
instantiate_new_reg (rtx x, HOST_WIDE_INT *poffset) instantiate_new_reg (rtx x, HOST_WIDE_INT *poffset)
{ {
rtx new; rtx new_rtx;
HOST_WIDE_INT offset; HOST_WIDE_INT offset;
if (x == virtual_incoming_args_rtx) if (x == virtual_incoming_args_rtx)
@ -1219,24 +1220,24 @@ instantiate_new_reg (rtx x, HOST_WIDE_INT *poffset)
{ {
/* Replace virtual_incoming_args_rtx with internal arg /* Replace virtual_incoming_args_rtx with internal arg
pointer if DRAP is used to realign stack. */ pointer if DRAP is used to realign stack. */
new = crtl->args.internal_arg_pointer; new_rtx = crtl->args.internal_arg_pointer;
offset = 0; offset = 0;
} }
else else
new = arg_pointer_rtx, offset = in_arg_offset; new_rtx = arg_pointer_rtx, offset = in_arg_offset;
} }
else if (x == virtual_stack_vars_rtx) else if (x == virtual_stack_vars_rtx)
new = frame_pointer_rtx, offset = var_offset; new_rtx = frame_pointer_rtx, offset = var_offset;
else if (x == virtual_stack_dynamic_rtx) else if (x == virtual_stack_dynamic_rtx)
new = stack_pointer_rtx, offset = dynamic_offset; new_rtx = stack_pointer_rtx, offset = dynamic_offset;
else if (x == virtual_outgoing_args_rtx) else if (x == virtual_outgoing_args_rtx)
new = stack_pointer_rtx, offset = out_arg_offset; new_rtx = stack_pointer_rtx, offset = out_arg_offset;
else if (x == virtual_cfa_rtx) else if (x == virtual_cfa_rtx)
{ {
#ifdef FRAME_POINTER_CFA_OFFSET #ifdef FRAME_POINTER_CFA_OFFSET
new = frame_pointer_rtx; new_rtx = frame_pointer_rtx;
#else #else
new = arg_pointer_rtx; new_rtx = arg_pointer_rtx;
#endif #endif
offset = cfa_offset; offset = cfa_offset;
} }
@ -1244,7 +1245,7 @@ instantiate_new_reg (rtx x, HOST_WIDE_INT *poffset)
return NULL_RTX; return NULL_RTX;
*poffset = offset; *poffset = offset;
return new; return new_rtx;
} }
/* A subroutine of instantiate_virtual_regs, called via for_each_rtx. /* A subroutine of instantiate_virtual_regs, called via for_each_rtx.
@ -1258,7 +1259,7 @@ instantiate_virtual_regs_in_rtx (rtx *loc, void *data)
{ {
HOST_WIDE_INT offset; HOST_WIDE_INT offset;
bool *changed = (bool *) data; bool *changed = (bool *) data;
rtx x, new; rtx x, new_rtx;
x = *loc; x = *loc;
if (x == 0) if (x == 0)
@ -1267,21 +1268,21 @@ instantiate_virtual_regs_in_rtx (rtx *loc, void *data)
switch (GET_CODE (x)) switch (GET_CODE (x))
{ {
case REG: case REG:
new = instantiate_new_reg (x, &offset); new_rtx = instantiate_new_reg (x, &offset);
if (new) if (new_rtx)
{ {
*loc = plus_constant (new, offset); *loc = plus_constant (new_rtx, offset);
if (changed) if (changed)
*changed = true; *changed = true;
} }
return -1; return -1;
case PLUS: case PLUS:
new = instantiate_new_reg (XEXP (x, 0), &offset); new_rtx = instantiate_new_reg (XEXP (x, 0), &offset);
if (new) if (new_rtx)
{ {
new = plus_constant (new, offset); new_rtx = plus_constant (new_rtx, offset);
*loc = simplify_gen_binary (PLUS, GET_MODE (x), new, XEXP (x, 1)); *loc = simplify_gen_binary (PLUS, GET_MODE (x), new_rtx, XEXP (x, 1));
if (changed) if (changed)
*changed = true; *changed = true;
return -1; return -1;
@ -1327,7 +1328,7 @@ instantiate_virtual_regs_in_insn (rtx insn)
HOST_WIDE_INT offset; HOST_WIDE_INT offset;
int insn_code, i; int insn_code, i;
bool any_change = false; bool any_change = false;
rtx set, new, x, seq; rtx set, new_rtx, x, seq;
/* There are some special cases to be handled first. */ /* There are some special cases to be handled first. */
set = single_set (insn); set = single_set (insn);
@ -1337,17 +1338,17 @@ instantiate_virtual_regs_in_insn (rtx insn)
to mean that the underlying register gets assigned the inverse to mean that the underlying register gets assigned the inverse
transformation. This is used, for example, in the handling of transformation. This is used, for example, in the handling of
non-local gotos. */ non-local gotos. */
new = instantiate_new_reg (SET_DEST (set), &offset); new_rtx = instantiate_new_reg (SET_DEST (set), &offset);
if (new) if (new_rtx)
{ {
start_sequence (); start_sequence ();
for_each_rtx (&SET_SRC (set), instantiate_virtual_regs_in_rtx, NULL); for_each_rtx (&SET_SRC (set), instantiate_virtual_regs_in_rtx, NULL);
x = simplify_gen_binary (PLUS, GET_MODE (new), SET_SRC (set), x = simplify_gen_binary (PLUS, GET_MODE (new_rtx), SET_SRC (set),
GEN_INT (-offset)); GEN_INT (-offset));
x = force_operand (x, new); x = force_operand (x, new_rtx);
if (x != new) if (x != new_rtx)
emit_move_insn (new, x); emit_move_insn (new_rtx, x);
seq = get_insns (); seq = get_insns ();
end_sequence (); end_sequence ();
@ -1361,15 +1362,15 @@ instantiate_virtual_regs_in_insn (rtx insn)
new add insn. The difference between this and falling through new add insn. The difference between this and falling through
to the generic case is avoiding a new pseudo and eliminating a to the generic case is avoiding a new pseudo and eliminating a
move insn in the initial rtl stream. */ move insn in the initial rtl stream. */
new = instantiate_new_reg (SET_SRC (set), &offset); new_rtx = instantiate_new_reg (SET_SRC (set), &offset);
if (new && offset != 0 if (new_rtx && offset != 0
&& REG_P (SET_DEST (set)) && REG_P (SET_DEST (set))
&& REGNO (SET_DEST (set)) > LAST_VIRTUAL_REGISTER) && REGNO (SET_DEST (set)) > LAST_VIRTUAL_REGISTER)
{ {
start_sequence (); start_sequence ();
x = expand_simple_binop (GET_MODE (SET_DEST (set)), PLUS, x = expand_simple_binop (GET_MODE (SET_DEST (set)), PLUS,
new, GEN_INT (offset), SET_DEST (set), new_rtx, GEN_INT (offset), SET_DEST (set),
1, OPTAB_LIB_WIDEN); 1, OPTAB_LIB_WIDEN);
if (x != SET_DEST (set)) if (x != SET_DEST (set))
emit_move_insn (SET_DEST (set), x); emit_move_insn (SET_DEST (set), x);
@ -1392,7 +1393,7 @@ instantiate_virtual_regs_in_insn (rtx insn)
&& recog_data.operand_loc[1] == &XEXP (SET_SRC (set), 0) && recog_data.operand_loc[1] == &XEXP (SET_SRC (set), 0)
&& recog_data.operand_loc[2] == &XEXP (SET_SRC (set), 1) && recog_data.operand_loc[2] == &XEXP (SET_SRC (set), 1)
&& GET_CODE (recog_data.operand[2]) == CONST_INT && GET_CODE (recog_data.operand[2]) == CONST_INT
&& (new = instantiate_new_reg (recog_data.operand[1], &offset))) && (new_rtx = instantiate_new_reg (recog_data.operand[1], &offset)))
{ {
offset += INTVAL (recog_data.operand[2]); offset += INTVAL (recog_data.operand[2]);
@ -1402,7 +1403,7 @@ instantiate_virtual_regs_in_insn (rtx insn)
&& REGNO (SET_DEST (set)) > LAST_VIRTUAL_REGISTER) && REGNO (SET_DEST (set)) > LAST_VIRTUAL_REGISTER)
{ {
start_sequence (); start_sequence ();
emit_move_insn (SET_DEST (set), new); emit_move_insn (SET_DEST (set), new_rtx);
seq = get_insns (); seq = get_insns ();
end_sequence (); end_sequence ();
@ -1416,10 +1417,10 @@ instantiate_virtual_regs_in_insn (rtx insn)
/* Using validate_change and apply_change_group here leaves /* Using validate_change and apply_change_group here leaves
recog_data in an invalid state. Since we know exactly what recog_data in an invalid state. Since we know exactly what
we want to check, do those two by hand. */ we want to check, do those two by hand. */
if (safe_insn_predicate (insn_code, 1, new) if (safe_insn_predicate (insn_code, 1, new_rtx)
&& safe_insn_predicate (insn_code, 2, x)) && safe_insn_predicate (insn_code, 2, x))
{ {
*recog_data.operand_loc[1] = recog_data.operand[1] = new; *recog_data.operand_loc[1] = recog_data.operand[1] = new_rtx;
*recog_data.operand_loc[2] = recog_data.operand[2] = x; *recog_data.operand_loc[2] = recog_data.operand[2] = x;
any_change = true; any_change = true;
@ -1474,11 +1475,11 @@ instantiate_virtual_regs_in_insn (rtx insn)
break; break;
case REG: case REG:
new = instantiate_new_reg (x, &offset); new_rtx = instantiate_new_reg (x, &offset);
if (new == NULL) if (new_rtx == NULL)
continue; continue;
if (offset == 0) if (offset == 0)
x = new; x = new_rtx;
else else
{ {
start_sequence (); start_sequence ();
@ -1489,7 +1490,7 @@ instantiate_virtual_regs_in_insn (rtx insn)
/* ??? Recognize address_operand and/or "p" constraints /* ??? Recognize address_operand and/or "p" constraints
to see if (plus new offset) is a valid before we put to see if (plus new offset) is a valid before we put
this through expand_simple_binop. */ this through expand_simple_binop. */
x = expand_simple_binop (GET_MODE (x), PLUS, new, x = expand_simple_binop (GET_MODE (x), PLUS, new_rtx,
GEN_INT (offset), NULL_RTX, GEN_INT (offset), NULL_RTX,
1, OPTAB_LIB_WIDEN); 1, OPTAB_LIB_WIDEN);
seq = get_insns (); seq = get_insns ();
@ -1499,21 +1500,21 @@ instantiate_virtual_regs_in_insn (rtx insn)
break; break;
case SUBREG: case SUBREG:
new = instantiate_new_reg (SUBREG_REG (x), &offset); new_rtx = instantiate_new_reg (SUBREG_REG (x), &offset);
if (new == NULL) if (new_rtx == NULL)
continue; continue;
if (offset != 0) if (offset != 0)
{ {
start_sequence (); start_sequence ();
new = expand_simple_binop (GET_MODE (new), PLUS, new, new_rtx = expand_simple_binop (GET_MODE (new_rtx), PLUS, new_rtx,
GEN_INT (offset), NULL_RTX, GEN_INT (offset), NULL_RTX,
1, OPTAB_LIB_WIDEN); 1, OPTAB_LIB_WIDEN);
seq = get_insns (); seq = get_insns ();
end_sequence (); end_sequence ();
emit_insn_before (seq, insn); emit_insn_before (seq, insn);
} }
x = simplify_gen_subreg (recog_data.operand_mode[i], new, x = simplify_gen_subreg (recog_data.operand_mode[i], new_rtx,
GET_MODE (new), SUBREG_BYTE (x)); GET_MODE (new_rtx), SUBREG_BYTE (x));
break; break;
default: default:

16
gcc/gimple.c
View File

@ -370,22 +370,22 @@ void
extract_ops_from_tree (tree expr, enum tree_code *subcode_p, tree *op1_p, extract_ops_from_tree (tree expr, enum tree_code *subcode_p, tree *op1_p,
tree *op2_p) tree *op2_p)
{ {
enum gimple_rhs_class class; enum gimple_rhs_class grhs_class;
*subcode_p = TREE_CODE (expr); *subcode_p = TREE_CODE (expr);
class = get_gimple_rhs_class (*subcode_p); grhs_class = get_gimple_rhs_class (*subcode_p);
if (class == GIMPLE_BINARY_RHS) if (grhs_class == GIMPLE_BINARY_RHS)
{ {
*op1_p = TREE_OPERAND (expr, 0); *op1_p = TREE_OPERAND (expr, 0);
*op2_p = TREE_OPERAND (expr, 1); *op2_p = TREE_OPERAND (expr, 1);
} }
else if (class == GIMPLE_UNARY_RHS) else if (grhs_class == GIMPLE_UNARY_RHS)
{ {
*op1_p = TREE_OPERAND (expr, 0); *op1_p = TREE_OPERAND (expr, 0);
*op2_p = NULL_TREE; *op2_p = NULL_TREE;
} }
else if (class == GIMPLE_SINGLE_RHS) else if (grhs_class == GIMPLE_SINGLE_RHS)
{ {
*op1_p = expr; *op1_p = expr;
*op2_p = NULL_TREE; *op2_p = NULL_TREE;
@ -1276,16 +1276,16 @@ gimple_seq
gimple_seq_copy (gimple_seq src) gimple_seq_copy (gimple_seq src)
{ {
gimple_stmt_iterator gsi; gimple_stmt_iterator gsi;
gimple_seq new = gimple_seq_alloc (); gimple_seq new_seq = gimple_seq_alloc ();
gimple stmt; gimple stmt;
for (gsi = gsi_start (src); !gsi_end_p (gsi); gsi_next (&gsi)) for (gsi = gsi_start (src); !gsi_end_p (gsi); gsi_next (&gsi))
{ {
stmt = gimple_copy (gsi_stmt (gsi)); stmt = gimple_copy (gsi_stmt (gsi));
gimple_seq_add_stmt (&new, stmt); gimple_seq_add_stmt (&new_seq, stmt);
} }
return new; return new_seq;
} }

40
gcc/gimplify.c
View File

@ -2294,14 +2294,14 @@ gimplify_call_expr (tree *expr_p, gimple_seq *pre_p, bool want_value)
fndecl = get_callee_fndecl (*expr_p); fndecl = get_callee_fndecl (*expr_p);
if (fndecl && DECL_BUILT_IN (fndecl)) if (fndecl && DECL_BUILT_IN (fndecl))
{ {
tree new = fold_call_expr (*expr_p, !want_value); tree new_tree = fold_call_expr (*expr_p, !want_value);
if (new && new != *expr_p) if (new_tree && new_tree != *expr_p)
{ {
/* There was a transformation of this call which computes the /* There was a transformation of this call which computes the
same value, but in a more efficient way. Return and try same value, but in a more efficient way. Return and try
again. */ again. */
*expr_p = new; *expr_p = new_tree;
return GS_OK; return GS_OK;
} }
@ -2452,14 +2452,14 @@ gimplify_call_expr (tree *expr_p, gimple_seq *pre_p, bool want_value)
/* Try this again in case gimplification exposed something. */ /* Try this again in case gimplification exposed something. */
if (ret != GS_ERROR) if (ret != GS_ERROR)
{ {
tree new = fold_call_expr (*expr_p, !want_value); tree new_tree = fold_call_expr (*expr_p, !want_value);
if (new && new != *expr_p) if (new_tree && new_tree != *expr_p)
{ {
/* There was a transformation of this call which computes the /* There was a transformation of this call which computes the
same value, but in a more efficient way. Return and try same value, but in a more efficient way. Return and try
again. */ again. */
*expr_p = new; *expr_p = new_tree;
return GS_OK; return GS_OK;
} }
} }
@ -3636,25 +3636,25 @@ gimplify_init_constructor (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
if (size > 0 && !can_move_by_pieces (size, align)) if (size > 0 && !can_move_by_pieces (size, align))
{ {
tree new; tree new_tree;
if (notify_temp_creation) if (notify_temp_creation)
return GS_ERROR; return GS_ERROR;
new = create_tmp_var_raw (type, "C"); new_tree = create_tmp_var_raw (type, "C");
gimple_add_tmp_var (new); gimple_add_tmp_var (new_tree);
TREE_STATIC (new) = 1; TREE_STATIC (new_tree) = 1;
TREE_READONLY (new) = 1; TREE_READONLY (new_tree) = 1;
DECL_INITIAL (new) = ctor; DECL_INITIAL (new_tree) = ctor;
if (align > DECL_ALIGN (new)) if (align > DECL_ALIGN (new_tree))
{ {
DECL_ALIGN (new) = align; DECL_ALIGN (new_tree) = align;
DECL_USER_ALIGN (new) = 1; DECL_USER_ALIGN (new_tree) = 1;
} }
walk_tree (&DECL_INITIAL (new), force_labels_r, NULL, NULL); walk_tree (&DECL_INITIAL (new_tree), force_labels_r, NULL, NULL);
TREE_OPERAND (*expr_p, 1) = new; TREE_OPERAND (*expr_p, 1) = new_tree;
/* This is no longer an assignment of a CONSTRUCTOR, but /* This is no longer an assignment of a CONSTRUCTOR, but
we still may have processing to do on the LHS. So we still may have processing to do on the LHS. So
@ -4844,7 +4844,7 @@ gimplify_cleanup_point_expr (tree *expr_p, gimple_seq *pre_p)
} }
else else
{ {
gimple try; gimple gtry;
gimple_seq seq; gimple_seq seq;
enum gimple_try_flags kind; enum gimple_try_flags kind;
@ -4854,10 +4854,10 @@ gimplify_cleanup_point_expr (tree *expr_p, gimple_seq *pre_p)
kind = GIMPLE_TRY_FINALLY; kind = GIMPLE_TRY_FINALLY;
seq = gsi_split_seq_after (iter); seq = gsi_split_seq_after (iter);
try = gimple_build_try (seq, gimple_wce_cleanup (wce), kind); gtry = gimple_build_try (seq, gimple_wce_cleanup (wce), kind);
/* Do not use gsi_replace here, as it may scan operands. /* Do not use gsi_replace here, as it may scan operands.
We want to do a simple structural modification only. */ We want to do a simple structural modification only. */
*gsi_stmt_ptr (&iter) = try; *gsi_stmt_ptr (&iter) = gtry;
iter = gsi_start (seq); iter = gsi_start (seq);
} }
} }

12
gcc/ipa-cp.c
View File

@ -281,15 +281,17 @@ ipcp_lattice_from_jfunc (struct ipa_node_params *info, struct ipcp_lattice *lat,
lat->type = IPA_BOTTOM; lat->type = IPA_BOTTOM;
} }
/* True when OLD and NEW values are not the same. */ /* True when OLD_LAT and NEW_LAT values are not the same. */
static bool static bool
ipcp_lattice_changed (struct ipcp_lattice *old, struct ipcp_lattice *new) ipcp_lattice_changed (struct ipcp_lattice *old_lat,
struct ipcp_lattice *new_lat)
{ {
if (old->type == new->type) if (old_lat->type == new_lat->type)
{ {
if (!ipcp_lat_is_const (old)) if (!ipcp_lat_is_const (old_lat))
return false; return false;
if (ipcp_lats_are_equal (old, new)) if (ipcp_lats_are_equal (old_lat, new_lat))
return false; return false;
} }
return true; return true;

14
gcc/passes.c
View File

@ -447,13 +447,13 @@ next_pass_1 (struct opt_pass **list, struct opt_pass *pass)
pass is already in the list. */ pass is already in the list. */
if (pass->static_pass_number) if (pass->static_pass_number)
{ {
struct opt_pass *new; struct opt_pass *new_pass;
new = XNEW (struct opt_pass); new_pass = XNEW (struct opt_pass);
memcpy (new, pass, sizeof (*new)); memcpy (new_pass, pass, sizeof (*new_pass));
new->next = NULL; new_pass->next = NULL;
new->todo_flags_start &= ~TODO_mark_first_instance; new_pass->todo_flags_start &= ~TODO_mark_first_instance;
/* Indicate to register_dump_files that this pass has duplicates, /* Indicate to register_dump_files that this pass has duplicates,
and so it should rename the dump file. The first instance will and so it should rename the dump file. The first instance will
@ -462,10 +462,10 @@ next_pass_1 (struct opt_pass **list, struct opt_pass *pass)
if (pass->name) if (pass->name)
{ {
pass->static_pass_number -= 1; pass->static_pass_number -= 1;
new->static_pass_number = -pass->static_pass_number; new_pass->static_pass_number = -pass->static_pass_number;
} }
*list = new; *list = new_pass;
} }
else else
{ {

18
gcc/print-tree.c
View File

@ -74,12 +74,12 @@ dump_addr (FILE *file, const char *prefix, const void *addr)
void void
print_node_brief (FILE *file, const char *prefix, const_tree node, int indent) print_node_brief (FILE *file, const char *prefix, const_tree node, int indent)
{ {
enum tree_code_class class; enum tree_code_class tclass;
if (node == 0) if (node == 0)
return; return;
class = TREE_CODE_CLASS (TREE_CODE (node)); tclass = TREE_CODE_CLASS (TREE_CODE (node));
/* Always print the slot this node is in, and its code, address and /* Always print the slot this node is in, and its code, address and
name if any. */ name if any. */
@ -88,7 +88,7 @@ print_node_brief (FILE *file, const char *prefix, const_tree node, int indent)
fprintf (file, "%s <%s", prefix, tree_code_name[(int) TREE_CODE (node)]); fprintf (file, "%s <%s", prefix, tree_code_name[(int) TREE_CODE (node)]);
dump_addr (file, " ", node); dump_addr (file, " ", node);
if (class == tcc_declaration) if (tclass == tcc_declaration)
{ {
if (DECL_NAME (node)) if (DECL_NAME (node))
fprintf (file, " %s", IDENTIFIER_POINTER (DECL_NAME (node))); fprintf (file, " %s", IDENTIFIER_POINTER (DECL_NAME (node)));
@ -99,7 +99,7 @@ print_node_brief (FILE *file, const char *prefix, const_tree node, int indent)
fprintf (file, " %c.%u", TREE_CODE (node) == CONST_DECL ? 'C' : 'D', fprintf (file, " %c.%u", TREE_CODE (node) == CONST_DECL ? 'C' : 'D',
DECL_UID (node)); DECL_UID (node));
} }
else if (class == tcc_type) else if (tclass == tcc_type)
{ {
if (TYPE_NAME (node)) if (TYPE_NAME (node))
{ {
@ -188,7 +188,7 @@ print_node (FILE *file, const char *prefix, tree node, int indent)
int hash; int hash;
struct bucket *b; struct bucket *b;
enum machine_mode mode; enum machine_mode mode;
enum tree_code_class class; enum tree_code_class tclass;
int len; int len;
int i; int i;
expanded_location xloc; expanded_location xloc;
@ -198,7 +198,7 @@ print_node (FILE *file, const char *prefix, tree node, int indent)
return; return;
code = TREE_CODE (node); code = TREE_CODE (node);
class = TREE_CODE_CLASS (code); tclass = TREE_CODE_CLASS (code);
/* Don't get too deep in nesting. If the user wants to see deeper, /* Don't get too deep in nesting. If the user wants to see deeper,
it is easy to use the address of a lowest-level node it is easy to use the address of a lowest-level node
@ -210,7 +210,7 @@ print_node (FILE *file, const char *prefix, tree node, int indent)
return; return;
} }
if (indent > 8 && (class == tcc_type || class == tcc_declaration)) if (indent > 8 && (tclass == tcc_type || tclass == tcc_declaration))
{ {
print_node_brief (file, prefix, node, indent); print_node_brief (file, prefix, node, indent);
return; return;
@ -251,7 +251,7 @@ print_node (FILE *file, const char *prefix, tree node, int indent)
dump_addr (file, " ", node); dump_addr (file, " ", node);
/* Print the name, if any. */ /* Print the name, if any. */
if (class == tcc_declaration) if (tclass == tcc_declaration)
{ {
if (DECL_NAME (node)) if (DECL_NAME (node))
fprintf (file, " %s", IDENTIFIER_POINTER (DECL_NAME (node))); fprintf (file, " %s", IDENTIFIER_POINTER (DECL_NAME (node)));
@ -262,7 +262,7 @@ print_node (FILE *file, const char *prefix, tree node, int indent)
fprintf (file, " %c.%u", TREE_CODE (node) == CONST_DECL ? 'C' : 'D', fprintf (file, " %c.%u", TREE_CODE (node) == CONST_DECL ? 'C' : 'D',
DECL_UID (node)); DECL_UID (node));
} }
else if (class == tcc_type) else if (tclass == tcc_type)
{ {
if (TYPE_NAME (node)) if (TYPE_NAME (node))
{ {

4
gcc/profile.c
View File

@ -821,8 +821,8 @@ branch_prob (void)
|| (LOCATION_LINE (e->goto_locus) || (LOCATION_LINE (e->goto_locus)
!= LOCATION_LINE (gimple_location (last))))) != LOCATION_LINE (gimple_location (last)))))
{ {
basic_block new = split_edge (e); basic_block new_bb = split_edge (e);
single_succ_edge (new)->goto_locus = e->goto_locus; single_succ_edge (new_bb)->goto_locus = e->goto_locus;
} }
if ((e->flags & (EDGE_ABNORMAL | EDGE_ABNORMAL_CALL)) if ((e->flags & (EDGE_ABNORMAL | EDGE_ABNORMAL_CALL))
&& e->dest != EXIT_BLOCK_PTR) && e->dest != EXIT_BLOCK_PTR)

18
gcc/tree-dump.c
View File

@ -832,9 +832,9 @@ dump_register (const char *suffix, const char *swtch, const char *glob,
static int next_dump = FIRST_AUTO_NUMBERED_DUMP; static int next_dump = FIRST_AUTO_NUMBERED_DUMP;
int num = next_dump++; int num = next_dump++;
size_t this = extra_dump_files_in_use++; size_t count = extra_dump_files_in_use++;
if (this >= extra_dump_files_alloced) if (count >= extra_dump_files_alloced)
{ {
if (extra_dump_files_alloced == 0) if (extra_dump_files_alloced == 0)
extra_dump_files_alloced = 32; extra_dump_files_alloced = 32;
@ -845,14 +845,14 @@ dump_register (const char *suffix, const char *swtch, const char *glob,
extra_dump_files_alloced); extra_dump_files_alloced);
} }
memset (&extra_dump_files[this], 0, sizeof (struct dump_file_info)); memset (&extra_dump_files[count], 0, sizeof (struct dump_file_info));
extra_dump_files[this].suffix = suffix; extra_dump_files[count].suffix = suffix;
extra_dump_files[this].swtch = swtch; extra_dump_files[count].swtch = swtch;
extra_dump_files[this].glob = glob; extra_dump_files[count].glob = glob;
extra_dump_files[this].flags = flags; extra_dump_files[count].flags = flags;
extra_dump_files[this].num = num; extra_dump_files[count].num = num;
return this + TDI_end; return count + TDI_end;
} }

28
gcc/tree-eh.c
View File

@ -480,18 +480,18 @@ replace_goto_queue_cond_clause (tree *tp, struct leh_tf_state *tf,
gimple_stmt_iterator *gsi) gimple_stmt_iterator *gsi)
{ {
tree label; tree label;
gimple_seq new; gimple_seq new_seq;
treemple temp; treemple temp;
temp.tp = tp; temp.tp = tp;
new = find_goto_replacement (tf, temp); new_seq = find_goto_replacement (tf, temp);
if (!new) if (!new_seq)
return; return;
if (gimple_seq_singleton_p (new) if (gimple_seq_singleton_p (new_seq)
&& gimple_code (gimple_seq_first_stmt (new)) == GIMPLE_GOTO) && gimple_code (gimple_seq_first_stmt (new_seq)) == GIMPLE_GOTO)
{ {
*tp = gimple_goto_dest (gimple_seq_first_stmt (new)); *tp = gimple_goto_dest (gimple_seq_first_stmt (new_seq));
return; return;
} }
@ -500,7 +500,7 @@ replace_goto_queue_cond_clause (tree *tp, struct leh_tf_state *tf,
*tp = label; *tp = label;
gsi_insert_after (gsi, gimple_build_label (label), GSI_CONTINUE_LINKING); gsi_insert_after (gsi, gimple_build_label (label), GSI_CONTINUE_LINKING);
gsi_insert_seq_after (gsi, gimple_seq_copy (new), GSI_CONTINUE_LINKING); gsi_insert_seq_after (gsi, gimple_seq_copy (new_seq), GSI_CONTINUE_LINKING);
} }
/* The real work of replace_goto_queue. Returns with TSI updated to /* The real work of replace_goto_queue. Returns with TSI updated to
@ -1665,15 +1665,15 @@ lower_catch (struct leh_state *state, gimple tp)
{ {
struct eh_region *catch_region; struct eh_region *catch_region;
tree eh_label; tree eh_label;
gimple x, catch; gimple x, gcatch;
catch = gsi_stmt (gsi); gcatch = gsi_stmt (gsi);
catch_region = gen_eh_region_catch (try_region, catch_region = gen_eh_region_catch (try_region,
gimple_catch_types (catch)); gimple_catch_types (gcatch));
this_state.cur_region = catch_region; this_state.cur_region = catch_region;
this_state.prev_try = state->prev_try; this_state.prev_try = state->prev_try;
lower_eh_constructs_1 (&this_state, gimple_catch_handler (catch)); lower_eh_constructs_1 (&this_state, gimple_catch_handler (gcatch));
eh_label = create_artificial_label (); eh_label = create_artificial_label ();
set_eh_region_tree_label (catch_region, eh_label); set_eh_region_tree_label (catch_region, eh_label);
@ -1681,16 +1681,16 @@ lower_catch (struct leh_state *state, gimple tp)
x = gimple_build_label (eh_label); x = gimple_build_label (eh_label);
gsi_insert_before (&gsi, x, GSI_SAME_STMT); gsi_insert_before (&gsi, x, GSI_SAME_STMT);
if (gimple_seq_may_fallthru (gimple_catch_handler (catch))) if (gimple_seq_may_fallthru (gimple_catch_handler (gcatch)))
{ {
if (!out_label) if (!out_label)
out_label = create_artificial_label (); out_label = create_artificial_label ();
x = gimple_build_goto (out_label); x = gimple_build_goto (out_label);
gimple_seq_add_stmt (gimple_catch_handler_ptr (catch), x); gimple_seq_add_stmt (gimple_catch_handler_ptr (gcatch), x);
} }
gsi_insert_seq_before (&gsi, gimple_catch_handler (catch), gsi_insert_seq_before (&gsi, gimple_catch_handler (gcatch),
GSI_SAME_STMT); GSI_SAME_STMT);
gsi_remove (&gsi, false); gsi_remove (&gsi, false);
} }

190
gcc/tree-inline.c
View File

@ -154,7 +154,7 @@ insert_decl_map (copy_body_data *id, tree key, tree value)
static tree static tree
remap_ssa_name (tree name, copy_body_data *id) remap_ssa_name (tree name, copy_body_data *id)
{ {
tree new; tree new_tree;
tree *n; tree *n;
gcc_assert (TREE_CODE (name) == SSA_NAME); gcc_assert (TREE_CODE (name) == SSA_NAME);
@ -165,7 +165,7 @@ remap_ssa_name (tree name, copy_body_data *id)
/* Do not set DEF_STMT yet as statement is not copied yet. We do that /* Do not set DEF_STMT yet as statement is not copied yet. We do that
in copy_bb. */ in copy_bb. */
new = remap_decl (SSA_NAME_VAR (name), id); new_tree = remap_decl (SSA_NAME_VAR (name), id);
/* We might've substituted constant or another SSA_NAME for /* We might've substituted constant or another SSA_NAME for
the variable. the variable.
@ -173,15 +173,15 @@ remap_ssa_name (tree name, copy_body_data *id)
Replace the SSA name representing RESULT_DECL by variable during Replace the SSA name representing RESULT_DECL by variable during
inlining: this saves us from need to introduce PHI node in a case inlining: this saves us from need to introduce PHI node in a case
return value is just partly initialized. */ return value is just partly initialized. */
if ((TREE_CODE (new) == VAR_DECL || TREE_CODE (new) == PARM_DECL) if ((TREE_CODE (new_tree) == VAR_DECL || TREE_CODE (new_tree) == PARM_DECL)
&& (TREE_CODE (SSA_NAME_VAR (name)) != RESULT_DECL && (TREE_CODE (SSA_NAME_VAR (name)) != RESULT_DECL
|| !id->transform_return_to_modify)) || !id->transform_return_to_modify))
{ {
new = make_ssa_name (new, NULL); new_tree = make_ssa_name (new_tree, NULL);
insert_decl_map (id, name, new); insert_decl_map (id, name, new_tree);
SSA_NAME_OCCURS_IN_ABNORMAL_PHI (new) SSA_NAME_OCCURS_IN_ABNORMAL_PHI (new_tree)
= SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name); = SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name);
TREE_TYPE (new) = TREE_TYPE (SSA_NAME_VAR (new)); TREE_TYPE (new_tree) = TREE_TYPE (SSA_NAME_VAR (new_tree));
if (gimple_nop_p (SSA_NAME_DEF_STMT (name))) if (gimple_nop_p (SSA_NAME_DEF_STMT (name)))
{ {
/* By inlining function having uninitialized variable, we might /* By inlining function having uninitialized variable, we might
@ -202,24 +202,24 @@ remap_ssa_name (tree name, copy_body_data *id)
gimple_stmt_iterator gsi = gsi_last_bb (id->entry_bb); gimple_stmt_iterator gsi = gsi_last_bb (id->entry_bb);
gimple init_stmt; gimple init_stmt;
init_stmt = gimple_build_assign (new, init_stmt = gimple_build_assign (new_tree,
fold_convert (TREE_TYPE (new), fold_convert (TREE_TYPE (new_tree),
integer_zero_node)); integer_zero_node));
gsi_insert_after (&gsi, init_stmt, GSI_NEW_STMT); gsi_insert_after (&gsi, init_stmt, GSI_NEW_STMT);
SSA_NAME_IS_DEFAULT_DEF (new) = 0; SSA_NAME_IS_DEFAULT_DEF (new_tree) = 0;
} }
else else
{ {
SSA_NAME_DEF_STMT (new) = gimple_build_nop (); SSA_NAME_DEF_STMT (new_tree) = gimple_build_nop ();
if (gimple_default_def (id->src_cfun, SSA_NAME_VAR (name)) if (gimple_default_def (id->src_cfun, SSA_NAME_VAR (name))
== name) == name)
set_default_def (SSA_NAME_VAR (new), new); set_default_def (SSA_NAME_VAR (new_tree), new_tree);
} }
} }
} }
else else
insert_decl_map (id, name, new); insert_decl_map (id, name, new_tree);
return new; return new_tree;
} }
/* Remap DECL during the copying of the BLOCK tree for the function. */ /* Remap DECL during the copying of the BLOCK tree for the function. */
@ -295,31 +295,31 @@ remap_decl (tree decl, copy_body_data *id)
static tree static tree
remap_type_1 (tree type, copy_body_data *id) remap_type_1 (tree type, copy_body_data *id)
{ {
tree new, t; tree new_tree, t;
/* We do need a copy. build and register it now. If this is a pointer or /* We do need a copy. build and register it now. If this is a pointer or
reference type, remap the designated type and make a new pointer or reference type, remap the designated type and make a new pointer or
reference type. */ reference type. */
if (TREE_CODE (type) == POINTER_TYPE) if (TREE_CODE (type) == POINTER_TYPE)
{ {
new = build_pointer_type_for_mode (remap_type (TREE_TYPE (type), id), new_tree = build_pointer_type_for_mode (remap_type (TREE_TYPE (type), id),
TYPE_MODE (type), TYPE_MODE (type),
TYPE_REF_CAN_ALIAS_ALL (type)); TYPE_REF_CAN_ALIAS_ALL (type));
insert_decl_map (id, type, new); insert_decl_map (id, type, new_tree);
return new; return new_tree;
} }
else if (TREE_CODE (type) == REFERENCE_TYPE) else if (TREE_CODE (type) == REFERENCE_TYPE)
{ {
new = build_reference_type_for_mode (remap_type (TREE_TYPE (type), id), new_tree = build_reference_type_for_mode (remap_type (TREE_TYPE (type), id),
TYPE_MODE (type), TYPE_MODE (type),
TYPE_REF_CAN_ALIAS_ALL (type)); TYPE_REF_CAN_ALIAS_ALL (type));
insert_decl_map (id, type, new); insert_decl_map (id, type, new_tree);
return new; return new_tree;
} }
else else
new = copy_node (type); new_tree = copy_node (type);
insert_decl_map (id, type, new); insert_decl_map (id, type, new_tree);
/* This is a new type, not a copy of an old type. Need to reassociate /* This is a new type, not a copy of an old type. Need to reassociate
variants. We can handle everything except the main variant lazily. */ variants. We can handle everything except the main variant lazily. */
@ -327,47 +327,47 @@ remap_type_1 (tree type, copy_body_data *id)
if (type != t) if (type != t)
{ {
t = remap_type (t, id); t = remap_type (t, id);
TYPE_MAIN_VARIANT (new) = t; TYPE_MAIN_VARIANT (new_tree) = t;
TYPE_NEXT_VARIANT (new) = TYPE_NEXT_VARIANT (t); TYPE_NEXT_VARIANT (new_tree) = TYPE_NEXT_VARIANT (t);
TYPE_NEXT_VARIANT (t) = new; TYPE_NEXT_VARIANT (t) = new_tree;
} }
else else
{ {
TYPE_MAIN_VARIANT (new) = new; TYPE_MAIN_VARIANT (new_tree) = new_tree;
TYPE_NEXT_VARIANT (new) = NULL; TYPE_NEXT_VARIANT (new_tree) = NULL;
} }
if (TYPE_STUB_DECL (type)) if (TYPE_STUB_DECL (type))
TYPE_STUB_DECL (new) = remap_decl (TYPE_STUB_DECL (type), id); TYPE_STUB_DECL (new_tree) = remap_decl (TYPE_STUB_DECL (type), id);
/* Lazily create pointer and reference types. */ /* Lazily create pointer and reference types. */
TYPE_POINTER_TO (new) = NULL; TYPE_POINTER_TO (new_tree) = NULL;
TYPE_REFERENCE_TO (new) = NULL; TYPE_REFERENCE_TO (new_tree) = NULL;
switch (TREE_CODE (new)) switch (TREE_CODE (new_tree))
{ {
case INTEGER_TYPE: case INTEGER_TYPE:
case REAL_TYPE: case REAL_TYPE:
case FIXED_POINT_TYPE: case FIXED_POINT_TYPE:
case ENUMERAL_TYPE: case ENUMERAL_TYPE:
case BOOLEAN_TYPE: case BOOLEAN_TYPE:
t = TYPE_MIN_VALUE (new); t = TYPE_MIN_VALUE (new_tree);
if (t && TREE_CODE (t) != INTEGER_CST) if (t && TREE_CODE (t) != INTEGER_CST)
walk_tree (&TYPE_MIN_VALUE (new), copy_tree_body_r, id, NULL); walk_tree (&TYPE_MIN_VALUE (new_tree), copy_tree_body_r, id, NULL);
t = TYPE_MAX_VALUE (new); t = TYPE_MAX_VALUE (new_tree);
if (t && TREE_CODE (t) != INTEGER_CST) if (t && TREE_CODE (t) != INTEGER_CST)
walk_tree (&TYPE_MAX_VALUE (new), copy_tree_body_r, id, NULL); walk_tree (&TYPE_MAX_VALUE (new_tree), copy_tree_body_r, id, NULL);
return new; return new_tree;
case FUNCTION_TYPE: case FUNCTION_TYPE:
TREE_TYPE (new) = remap_type (TREE_TYPE (new), id); TREE_TYPE (new_tree) = remap_type (TREE_TYPE (new_tree), id);
walk_tree (&TYPE_ARG_TYPES (new), copy_tree_body_r, id, NULL); walk_tree (&TYPE_ARG_TYPES (new_tree), copy_tree_body_r, id, NULL);
return new; return new_tree;
case ARRAY_TYPE: case ARRAY_TYPE:
TREE_TYPE (new) = remap_type (TREE_TYPE (new), id); TREE_TYPE (new_tree) = remap_type (TREE_TYPE (new_tree), id);
TYPE_DOMAIN (new) = remap_type (TYPE_DOMAIN (new), id); TYPE_DOMAIN (new_tree) = remap_type (TYPE_DOMAIN (new_tree), id);
break; break;
case RECORD_TYPE: case RECORD_TYPE:
@ -376,14 +376,14 @@ remap_type_1 (tree type, copy_body_data *id)
{ {
tree f, nf = NULL; tree f, nf = NULL;
for (f = TYPE_FIELDS (new); f ; f = TREE_CHAIN (f)) for (f = TYPE_FIELDS (new_tree); f ; f = TREE_CHAIN (f))
{ {
t = remap_decl (f, id); t = remap_decl (f, id);
DECL_CONTEXT (t) = new; DECL_CONTEXT (t) = new_tree;
TREE_CHAIN (t) = nf; TREE_CHAIN (t) = nf;
nf = t; nf = t;
} }
TYPE_FIELDS (new) = nreverse (nf); TYPE_FIELDS (new_tree) = nreverse (nf);
} }
break; break;
@ -393,10 +393,10 @@ remap_type_1 (tree type, copy_body_data *id)
gcc_unreachable (); gcc_unreachable ();
} }
walk_tree (&TYPE_SIZE (new), copy_tree_body_r, id, NULL); walk_tree (&TYPE_SIZE (new_tree), copy_tree_body_r, id, NULL);
walk_tree (&TYPE_SIZE_UNIT (new), copy_tree_body_r, id, NULL); walk_tree (&TYPE_SIZE_UNIT (new_tree), copy_tree_body_r, id, NULL);
return new; return new_tree;
} }
tree tree
@ -504,28 +504,28 @@ static tree
remap_blocks (tree block, copy_body_data *id) remap_blocks (tree block, copy_body_data *id)
{ {
tree t; tree t;
tree new = block; tree new_tree = block;
if (!block) if (!block)
return NULL; return NULL;
remap_block (&new, id); remap_block (&new_tree, id);
gcc_assert (new != block); gcc_assert (new_tree != block);
for (t = BLOCK_SUBBLOCKS (block); t ; t = BLOCK_CHAIN (t)) for (t = BLOCK_SUBBLOCKS (block); t ; t = BLOCK_CHAIN (t))
add_lexical_block (new, remap_blocks (t, id)); add_lexical_block (new_tree, remap_blocks (t, id));
return new; return new_tree;
} }
static void static void
copy_statement_list (tree *tp) copy_statement_list (tree *tp)
{ {
tree_stmt_iterator oi, ni; tree_stmt_iterator oi, ni;
tree new; tree new_tree;
new = alloc_stmt_list (); new_tree = alloc_stmt_list ();
ni = tsi_start (new); ni = tsi_start (new_tree);
oi = tsi_start (*tp); oi = tsi_start (*tp);
*tp = new; *tp = new_tree;
for (; !tsi_end_p (oi); tsi_next (&oi)) for (; !tsi_end_p (oi); tsi_next (&oi))
tsi_link_after (&ni, tsi_stmt (oi), TSI_NEW_STMT); tsi_link_after (&ni, tsi_stmt (oi), TSI_NEW_STMT);
@ -679,7 +679,7 @@ remap_gimple_op_r (tree *tp, int *walk_subtrees, void *data)
n = (tree *) pointer_map_contains (id->decl_map, decl); n = (tree *) pointer_map_contains (id->decl_map, decl);
if (n) if (n)
{ {
tree type, new, old; tree type, new_tree, old;
/* If we happen to get an ADDR_EXPR in n->value, strip /* If we happen to get an ADDR_EXPR in n->value, strip
it manually here as we'll eventually get ADDR_EXPRs it manually here as we'll eventually get ADDR_EXPRs
@ -689,23 +689,23 @@ remap_gimple_op_r (tree *tp, int *walk_subtrees, void *data)
fold_indirect_ref does other useful transformations, fold_indirect_ref does other useful transformations,
try that first, though. */ try that first, though. */
type = TREE_TYPE (TREE_TYPE (*n)); type = TREE_TYPE (TREE_TYPE (*n));
new = unshare_expr (*n); new_tree = unshare_expr (*n);
old = *tp; old = *tp;
*tp = gimple_fold_indirect_ref (new); *tp = gimple_fold_indirect_ref (new_tree);
if (!*tp) if (!*tp)
{ {
if (TREE_CODE (new) == ADDR_EXPR) if (TREE_CODE (new_tree) == ADDR_EXPR)
{ {
*tp = fold_indirect_ref_1 (type, new); *tp = fold_indirect_ref_1 (type, new_tree);
/* ??? We should either assert here or build /* ??? We should either assert here or build
a VIEW_CONVERT_EXPR instead of blindly leaking a VIEW_CONVERT_EXPR instead of blindly leaking
incompatible types to our IL. */ incompatible types to our IL. */
if (! *tp) if (! *tp)
*tp = TREE_OPERAND (new, 0); *tp = TREE_OPERAND (new_tree, 0);
} }
else else
{ {
*tp = build1 (INDIRECT_REF, type, new); *tp = build1 (INDIRECT_REF, type, new_tree);
TREE_THIS_VOLATILE (*tp) = TREE_THIS_VOLATILE (old); TREE_THIS_VOLATILE (*tp) = TREE_THIS_VOLATILE (old);
} }
} }
@ -908,7 +908,7 @@ copy_tree_body_r (tree *tp, int *walk_subtrees, void *data)
n = (tree *) pointer_map_contains (id->decl_map, decl); n = (tree *) pointer_map_contains (id->decl_map, decl);
if (n) if (n)
{ {
tree new; tree new_tree;
tree old; tree old;
/* If we happen to get an ADDR_EXPR in n->value, strip /* If we happen to get an ADDR_EXPR in n->value, strip
it manually here as we'll eventually get ADDR_EXPRs it manually here as we'll eventually get ADDR_EXPRs
@ -917,23 +917,23 @@ copy_tree_body_r (tree *tp, int *walk_subtrees, void *data)
but we absolutely rely on that. As fold_indirect_ref but we absolutely rely on that. As fold_indirect_ref
does other useful transformations, try that first, though. */ does other useful transformations, try that first, though. */
tree type = TREE_TYPE (TREE_TYPE (*n)); tree type = TREE_TYPE (TREE_TYPE (*n));
new = unshare_expr (*n); new_tree = unshare_expr (*n);
old = *tp; old = *tp;
*tp = gimple_fold_indirect_ref (new); *tp = gimple_fold_indirect_ref (new_tree);
if (! *tp) if (! *tp)
{ {
if (TREE_CODE (new) == ADDR_EXPR) if (TREE_CODE (new_tree) == ADDR_EXPR)
{ {
*tp = fold_indirect_ref_1 (type, new); *tp = fold_indirect_ref_1 (type, new_tree);
/* ??? We should either assert here or build /* ??? We should either assert here or build
a VIEW_CONVERT_EXPR instead of blindly leaking a VIEW_CONVERT_EXPR instead of blindly leaking
incompatible types to our IL. */ incompatible types to our IL. */
if (! *tp) if (! *tp)
*tp = TREE_OPERAND (new, 0); *tp = TREE_OPERAND (new_tree, 0);
} }
else else
{ {
*tp = build1 (INDIRECT_REF, type, new); *tp = build1 (INDIRECT_REF, type, new_tree);
TREE_THIS_VOLATILE (*tp) = TREE_THIS_VOLATILE (old); TREE_THIS_VOLATILE (*tp) = TREE_THIS_VOLATILE (old);
TREE_SIDE_EFFECTS (*tp) = TREE_SIDE_EFFECTS (old); TREE_SIDE_EFFECTS (*tp) = TREE_SIDE_EFFECTS (old);
} }
@ -1547,7 +1547,7 @@ copy_edges_for_bb (basic_block bb, gcov_type count_scale, basic_block ret_bb)
FOR_EACH_EDGE (old_edge, ei, bb->succs) FOR_EACH_EDGE (old_edge, ei, bb->succs)
if (!(old_edge->flags & EDGE_EH)) if (!(old_edge->flags & EDGE_EH))
{ {
edge new; edge new_edge;
flags = old_edge->flags; flags = old_edge->flags;
@ -1555,9 +1555,9 @@ copy_edges_for_bb (basic_block bb, gcov_type count_scale, basic_block ret_bb)
if (old_edge->dest->index == EXIT_BLOCK && !old_edge->flags if (old_edge->dest->index == EXIT_BLOCK && !old_edge->flags
&& old_edge->dest->aux != EXIT_BLOCK_PTR) && old_edge->dest->aux != EXIT_BLOCK_PTR)
flags |= EDGE_FALLTHRU; flags |= EDGE_FALLTHRU;
new = make_edge (new_bb, (basic_block) old_edge->dest->aux, flags); new_edge = make_edge (new_bb, (basic_block) old_edge->dest->aux, flags);
new->count = old_edge->count * count_scale / REG_BR_PROB_BASE; new_edge->count = old_edge->count * count_scale / REG_BR_PROB_BASE;
new->probability = old_edge->probability; new_edge->probability = old_edge->probability;
} }
if (bb->index == ENTRY_BLOCK || bb->index == EXIT_BLOCK) if (bb->index == ENTRY_BLOCK || bb->index == EXIT_BLOCK)
@ -1795,9 +1795,9 @@ copy_cfg_body (copy_body_data * id, gcov_type count, int frequency,
/* Use aux pointers to map the original blocks to copy. */ /* Use aux pointers to map the original blocks to copy. */
FOR_EACH_BB_FN (bb, cfun_to_copy) FOR_EACH_BB_FN (bb, cfun_to_copy)
{ {
basic_block new = copy_bb (id, bb, frequency_scale, count_scale); basic_block new_bb = copy_bb (id, bb, frequency_scale, count_scale);
bb->aux = new; bb->aux = new_bb;
new->aux = bb; new_bb->aux = bb;
} }
last = last_basic_block; last = last_basic_block;
@ -3554,18 +3554,18 @@ copy_tree_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
{ {
/* Because the chain gets clobbered when we make a copy, we save it /* Because the chain gets clobbered when we make a copy, we save it
here. */ here. */
tree chain = NULL_TREE, new; tree chain = NULL_TREE, new_tree;
chain = TREE_CHAIN (*tp); chain = TREE_CHAIN (*tp);
/* Copy the node. */ /* Copy the node. */
new = copy_node (*tp); new_tree = copy_node (*tp);
/* Propagate mudflap marked-ness. */ /* Propagate mudflap marked-ness. */
if (flag_mudflap && mf_marked_p (*tp)) if (flag_mudflap && mf_marked_p (*tp))
mf_mark (new); mf_mark (new_tree);
*tp = new; *tp = new_tree;
/* Now, restore the chain, if appropriate. That will cause /* Now, restore the chain, if appropriate. That will cause
walk_tree to walk into the chain as well. */ walk_tree to walk into the chain as well. */
@ -3583,17 +3583,17 @@ copy_tree_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
{ {
/* CONSTRUCTOR nodes need special handling because /* CONSTRUCTOR nodes need special handling because
we need to duplicate the vector of elements. */ we need to duplicate the vector of elements. */
tree new; tree new_tree;
new = copy_node (*tp); new_tree = copy_node (*tp);
/* Propagate mudflap marked-ness. */ /* Propagate mudflap marked-ness. */
if (flag_mudflap && mf_marked_p (*tp)) if (flag_mudflap && mf_marked_p (*tp))
mf_mark (new); mf_mark (new_tree);
CONSTRUCTOR_ELTS (new) = VEC_copy (constructor_elt, gc, CONSTRUCTOR_ELTS (new_tree) = VEC_copy (constructor_elt, gc,
CONSTRUCTOR_ELTS (*tp)); CONSTRUCTOR_ELTS (*tp));
*tp = new; *tp = new_tree;
} }
else if (TREE_CODE_CLASS (code) == tcc_type) else if (TREE_CODE_CLASS (code) == tcc_type)
*walk_subtrees = 0; *walk_subtrees = 0;
@ -4093,10 +4093,10 @@ copy_arguments_for_versioning (tree orig_parm, copy_body_data * id)
arg_copy = &orig_parm; arg_copy = &orig_parm;
for (parg = arg_copy; *parg; parg = &TREE_CHAIN (*parg)) for (parg = arg_copy; *parg; parg = &TREE_CHAIN (*parg))
{ {
tree new = remap_decl (*parg, id); tree new_tree = remap_decl (*parg, id);
lang_hooks.dup_lang_specific_decl (new); lang_hooks.dup_lang_specific_decl (new_tree);
TREE_CHAIN (new) = TREE_CHAIN (*parg); TREE_CHAIN (new_tree) = TREE_CHAIN (*parg);
*parg = new; *parg = new_tree;
} }
return orig_parm; return orig_parm;
} }
@ -4110,10 +4110,10 @@ copy_static_chain (tree static_chain, copy_body_data * id)
chain_copy = &static_chain; chain_copy = &static_chain;
for (pvar = chain_copy; *pvar; pvar = &TREE_CHAIN (*pvar)) for (pvar = chain_copy; *pvar; pvar = &TREE_CHAIN (*pvar))
{ {
tree new = remap_decl (*pvar, id); tree new_tree = remap_decl (*pvar, id);
lang_hooks.dup_lang_specific_decl (new); lang_hooks.dup_lang_specific_decl (new_tree);
TREE_CHAIN (new) = TREE_CHAIN (*pvar); TREE_CHAIN (new_tree) = TREE_CHAIN (*pvar);
*pvar = new; *pvar = new_tree;
} }
return static_chain; return static_chain;
} }

40
gcc/tree-into-ssa.c
View File

@ -638,15 +638,15 @@ repl_map_free (void *p)
} }
/* Return the names replaced by NEW (i.e., REPL_TBL[NEW].SET). */ /* Return the names replaced by NEW_TREE (i.e., REPL_TBL[NEW_TREE].SET). */
static inline bitmap static inline bitmap
names_replaced_by (tree new) names_replaced_by (tree new_tree)
{ {
struct repl_map_d m; struct repl_map_d m;
void **slot; void **slot;
m.name = new; m.name = new_tree;
slot = htab_find_slot (repl_tbl, (void *) &m, NO_INSERT); slot = htab_find_slot (repl_tbl, (void *) &m, NO_INSERT);
/* If N was not registered in the replacement table, return NULL. */ /* If N was not registered in the replacement table, return NULL. */
@ -657,20 +657,20 @@ names_replaced_by (tree new)
} }
/* Add OLD to REPL_TBL[NEW].SET. */ /* Add OLD to REPL_TBL[NEW_TREE].SET. */
static inline void static inline void
add_to_repl_tbl (tree new, tree old) add_to_repl_tbl (tree new_tree, tree old)
{ {
struct repl_map_d m, *mp; struct repl_map_d m, *mp;
void **slot; void **slot;
m.name = new; m.name = new_tree;
slot = htab_find_slot (repl_tbl, (void *) &m, INSERT); slot = htab_find_slot (repl_tbl, (void *) &m, INSERT);
if (*slot == NULL) if (*slot == NULL)
{ {
mp = XNEW (struct repl_map_d); mp = XNEW (struct repl_map_d);
mp->name = new; mp->name = new_tree;
mp->set = BITMAP_ALLOC (NULL); mp->set = BITMAP_ALLOC (NULL);
*slot = (void *) mp; *slot = (void *) mp;
} }
@ -681,23 +681,23 @@ add_to_repl_tbl (tree new, tree old)
} }
/* Add a new mapping NEW -> OLD REPL_TBL. Every entry N_i in REPL_TBL /* Add a new mapping NEW_TREE -> OLD REPL_TBL. Every entry N_i in REPL_TBL
represents the set of names O_1 ... O_j replaced by N_i. This is represents the set of names O_1 ... O_j replaced by N_i. This is
used by update_ssa and its helpers to introduce new SSA names in an used by update_ssa and its helpers to introduce new SSA names in an
already formed SSA web. */ already formed SSA web. */
static void static void
add_new_name_mapping (tree new, tree old) add_new_name_mapping (tree new_tree, tree old)
{ {
timevar_push (TV_TREE_SSA_INCREMENTAL); timevar_push (TV_TREE_SSA_INCREMENTAL);
/* OLD and NEW must be different SSA names for the same symbol. */ /* OLD and NEW_TREE must be different SSA names for the same symbol. */
gcc_assert (new != old && SSA_NAME_VAR (new) == SSA_NAME_VAR (old)); gcc_assert (new_tree != old && SSA_NAME_VAR (new_tree) == SSA_NAME_VAR (old));
/* If this mapping is for virtual names, we will need to update /* If this mapping is for virtual names, we will need to update
virtual operands. If this is a mapping for .MEM, then we gather virtual operands. If this is a mapping for .MEM, then we gather
the symbols associated with each name. */ the symbols associated with each name. */
if (!is_gimple_reg (new)) if (!is_gimple_reg (new_tree))
{ {
tree sym; tree sym;
@ -712,7 +712,7 @@ add_new_name_mapping (tree new, tree old)
will make more sense to rename the symbols from scratch. will make more sense to rename the symbols from scratch.
Otherwise, the insertion of PHI nodes for each of the old Otherwise, the insertion of PHI nodes for each of the old
names in these mappings will be very slow. */ names in these mappings will be very slow. */
sym = SSA_NAME_VAR (new); sym = SSA_NAME_VAR (new_tree);
bitmap_set_bit (update_ssa_stats.virtual_symbols, DECL_UID (sym)); bitmap_set_bit (update_ssa_stats.virtual_symbols, DECL_UID (sym));
} }
@ -726,16 +726,16 @@ add_new_name_mapping (tree new, tree old)
} }
/* Update the REPL_TBL table. */ /* Update the REPL_TBL table. */
add_to_repl_tbl (new, old); add_to_repl_tbl (new_tree, old);
/* If OLD had already been registered as a new name, then all the /* If OLD had already been registered as a new name, then all the
names that OLD replaces should also be replaced by NEW. */ names that OLD replaces should also be replaced by NEW_TREE. */
if (is_new_name (old)) if (is_new_name (old))
bitmap_ior_into (names_replaced_by (new), names_replaced_by (old)); bitmap_ior_into (names_replaced_by (new_tree), names_replaced_by (old));
/* Register NEW and OLD in NEW_SSA_NAMES and OLD_SSA_NAMES, /* Register NEW_TREE and OLD in NEW_SSA_NAMES and OLD_SSA_NAMES,
respectively. */ respectively. */
SET_BIT (new_ssa_names, SSA_NAME_VERSION (new)); SET_BIT (new_ssa_names, SSA_NAME_VERSION (new_tree));
SET_BIT (old_ssa_names, SSA_NAME_VERSION (old)); SET_BIT (old_ssa_names, SSA_NAME_VERSION (old));
/* Update mapping counter to use in the virtual mapping heuristic. */ /* Update mapping counter to use in the virtual mapping heuristic. */
@ -2757,12 +2757,12 @@ create_new_def_for (tree old_name, gimple stmt, def_operand_p def)
update_ssa. */ update_ssa. */
void void
register_new_name_mapping (tree new ATTRIBUTE_UNUSED, tree old ATTRIBUTE_UNUSED) register_new_name_mapping (tree new_Tree ATTRIBUTE_UNUSED, tree old ATTRIBUTE_UNUSED)
{ {
if (need_to_initialize_update_ssa_p) if (need_to_initialize_update_ssa_p)
init_update_ssa (); init_update_ssa ();
add_new_name_mapping (new, old); add_new_name_mapping (new_Tree, old);
} }

6
gcc/tree-mudflap.c
View File

@ -897,7 +897,7 @@ mf_xform_derefs (void)
basic_block bb, next; basic_block bb, next;
gimple_stmt_iterator i; gimple_stmt_iterator i;
int saved_last_basic_block = last_basic_block; int saved_last_basic_block = last_basic_block;
enum gimple_rhs_class class; enum gimple_rhs_class grhs_class;
bb = ENTRY_BLOCK_PTR ->next_bb; bb = ENTRY_BLOCK_PTR ->next_bb;
do do
@ -915,8 +915,8 @@ mf_xform_derefs (void)
gimple_location (s), integer_one_node); gimple_location (s), integer_one_node);
mf_xform_derefs_1 (&i, gimple_assign_rhs1_ptr (s), mf_xform_derefs_1 (&i, gimple_assign_rhs1_ptr (s),
gimple_location (s), integer_zero_node); gimple_location (s), integer_zero_node);
class = get_gimple_rhs_class (gimple_assign_rhs_code (s)); grhs_class = get_gimple_rhs_class (gimple_assign_rhs_code (s));
if (class == GIMPLE_BINARY_RHS) if (grhs_class == GIMPLE_BINARY_RHS)
mf_xform_derefs_1 (&i, gimple_assign_rhs2_ptr (s), mf_xform_derefs_1 (&i, gimple_assign_rhs2_ptr (s),
gimple_location (s), integer_zero_node); gimple_location (s), integer_zero_node);
break; break;

20
gcc/tree-predcom.c
View File

@ -267,7 +267,7 @@ typedef struct chain
/* For combination chains, the operator and the two chains that are /* For combination chains, the operator and the two chains that are
combined, and the type of the result. */ combined, and the type of the result. */
enum tree_code operator; enum tree_code op;
tree rslt_type; tree rslt_type;
struct chain *ch1, *ch2; struct chain *ch1, *ch2;
@ -409,7 +409,7 @@ dump_chain (FILE *file, chain_p chain)
if (chain->type == CT_COMBINATION) if (chain->type == CT_COMBINATION)
{ {
fprintf (file, " equal to %p %s %p in type ", fprintf (file, " equal to %p %s %p in type ",
(void *) chain->ch1, op_symbol_code (chain->operator), (void *) chain->ch1, op_symbol_code (chain->op),
(void *) chain->ch2); (void *) chain->ch2);
print_generic_expr (file, chain->rslt_type, TDF_SLIM); print_generic_expr (file, chain->rslt_type, TDF_SLIM);
fprintf (file, "\n"); fprintf (file, "\n");
@ -1224,12 +1224,12 @@ determine_roots (struct loop *loop,
} }
/* Replace the reference in statement STMT with temporary variable /* Replace the reference in statement STMT with temporary variable
NEW. If SET is true, NEW is instead initialized to the value of NEW_TREE. If SET is true, NEW_TREE is instead initialized to the value of
the reference in the statement. IN_LHS is true if the reference the reference in the statement. IN_LHS is true if the reference
is in the lhs of STMT, false if it is in rhs. */ is in the lhs of STMT, false if it is in rhs. */
static void static void
replace_ref_with (gimple stmt, tree new, bool set, bool in_lhs) replace_ref_with (gimple stmt, tree new_tree, bool set, bool in_lhs)
{ {
tree val; tree val;
gimple new_stmt; gimple new_stmt;
@ -1245,7 +1245,7 @@ replace_ref_with (gimple stmt, tree new, bool set, bool in_lhs)
remove_phi_node (&psi, false); remove_phi_node (&psi, false);
/* Turn the phi node into GIMPLE_ASSIGN. */ /* Turn the phi node into GIMPLE_ASSIGN. */
new_stmt = gimple_build_assign (val, new); new_stmt = gimple_build_assign (val, new_tree);
gsi_insert_before (&bsi, new_stmt, GSI_NEW_STMT); gsi_insert_before (&bsi, new_stmt, GSI_NEW_STMT);
return; return;
} }
@ -1256,11 +1256,11 @@ replace_ref_with (gimple stmt, tree new, bool set, bool in_lhs)
bsi = gsi_for_stmt (stmt); bsi = gsi_for_stmt (stmt);
/* If we do not need to initialize NEW, just replace the use of OLD. */ /* If we do not need to initialize NEW_TREE, just replace the use of OLD. */
if (!set) if (!set)
{ {
gcc_assert (!in_lhs); gcc_assert (!in_lhs);
gimple_assign_set_rhs_from_tree (&bsi, new); gimple_assign_set_rhs_from_tree (&bsi, new_tree);
stmt = gsi_stmt (bsi); stmt = gsi_stmt (bsi);
update_stmt (stmt); update_stmt (stmt);
return; return;
@ -1306,7 +1306,7 @@ replace_ref_with (gimple stmt, tree new, bool set, bool in_lhs)
val = gimple_assign_lhs (stmt); val = gimple_assign_lhs (stmt);
} }
new_stmt = gimple_build_assign (new, unshare_expr (val)); new_stmt = gimple_build_assign (new_tree, unshare_expr (val));
gsi_insert_after (&bsi, new_stmt, GSI_NEW_STMT); gsi_insert_after (&bsi, new_stmt, GSI_NEW_STMT);
} }
@ -1406,7 +1406,7 @@ get_init_expr (chain_p chain, unsigned index)
tree e1 = get_init_expr (chain->ch1, index); tree e1 = get_init_expr (chain->ch1, index);
tree e2 = get_init_expr (chain->ch2, index); tree e2 = get_init_expr (chain->ch2, index);
return fold_build2 (chain->operator, chain->rslt_type, e1, e2); return fold_build2 (chain->op, chain->rslt_type, e1, e2);
} }
else else
return VEC_index (tree, chain->inits, index); return VEC_index (tree, chain->inits, index);
@ -2347,7 +2347,7 @@ combine_chains (chain_p ch1, chain_p ch2)
new_chain = XCNEW (struct chain); new_chain = XCNEW (struct chain);
new_chain->type = CT_COMBINATION; new_chain->type = CT_COMBINATION;
new_chain->operator = op; new_chain->op = op;
new_chain->ch1 = ch1; new_chain->ch1 = ch1;
new_chain->ch2 = ch2; new_chain->ch2 = ch2;
new_chain->rslt_type = rslt_type; new_chain->rslt_type = rslt_type;

8
gcc/tree-pretty-print.c
View File

@ -519,7 +519,7 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
case BOOLEAN_TYPE: case BOOLEAN_TYPE:
{ {
unsigned int quals = TYPE_QUALS (node); unsigned int quals = TYPE_QUALS (node);
enum tree_code_class class; enum tree_code_class tclass;
if (quals & TYPE_QUAL_CONST) if (quals & TYPE_QUAL_CONST)
pp_string (buffer, "const "); pp_string (buffer, "const ");
@ -528,16 +528,16 @@ dump_generic_node (pretty_printer *buffer, tree node, int spc, int flags,
else if (quals & TYPE_QUAL_RESTRICT) else if (quals & TYPE_QUAL_RESTRICT)
pp_string (buffer, "restrict "); pp_string (buffer, "restrict ");
class = TREE_CODE_CLASS (TREE_CODE (node)); tclass = TREE_CODE_CLASS (TREE_CODE (node));
if (class == tcc_declaration) if (tclass == tcc_declaration)
{ {
if (DECL_NAME (node)) if (DECL_NAME (node))
dump_decl_name (buffer, node, flags); dump_decl_name (buffer, node, flags);
else else
pp_string (buffer, "<unnamed type decl>"); pp_string (buffer, "<unnamed type decl>");
} }
else if (class == tcc_type) else if (tclass == tcc_type)
{ {
if (TYPE_NAME (node)) if (TYPE_NAME (node))
{ {

6
gcc/tree-ssa-structalias.c
View File

@ -4346,8 +4346,8 @@ create_variable_info_for (tree decl, const char *name)
{ {
unsigned int index = VEC_length (varinfo_t, varmap); unsigned int index = VEC_length (varinfo_t, varmap);
varinfo_t vi; varinfo_t vi;
tree decltype = TREE_TYPE (decl); tree decl_type = TREE_TYPE (decl);
tree declsize = DECL_P (decl) ? DECL_SIZE (decl) : TYPE_SIZE (decltype); tree declsize = DECL_P (decl) ? DECL_SIZE (decl) : TYPE_SIZE (decl_type);
bool is_global = DECL_P (decl) ? is_global_var (decl) : false; bool is_global = DECL_P (decl) ? is_global_var (decl) : false;
VEC (fieldoff_s,heap) *fieldstack = NULL; VEC (fieldoff_s,heap) *fieldstack = NULL;
@ -4355,7 +4355,7 @@ create_variable_info_for (tree decl, const char *name)
return create_function_info_for (decl, name); return create_function_info_for (decl, name);
if (var_can_have_subvars (decl) && use_field_sensitive) if (var_can_have_subvars (decl) && use_field_sensitive)
push_fields_onto_fieldstack (decltype, &fieldstack, 0); push_fields_onto_fieldstack (decl_type, &fieldstack, 0);
/* If the variable doesn't have subvars, we may end up needing to /* If the variable doesn't have subvars, we may end up needing to
sort the field list and create fake variables for all the sort the field list and create fake variables for all the

12
gcc/tree-vrp.c
View File

@ -6383,9 +6383,9 @@ simplify_cond_using_ranges (gimple stmt)
able to simplify this conditional. */ able to simplify this conditional. */
if (vr->type == VR_RANGE) if (vr->type == VR_RANGE)
{ {
tree new = test_for_singularity (cond_code, op0, op1, vr); tree new_tree = test_for_singularity (cond_code, op0, op1, vr);
if (new) if (new_tree)
{ {
if (dump_file) if (dump_file)
{ {
@ -6396,7 +6396,7 @@ simplify_cond_using_ranges (gimple stmt)
gimple_cond_set_code (stmt, EQ_EXPR); gimple_cond_set_code (stmt, EQ_EXPR);
gimple_cond_set_lhs (stmt, op0); gimple_cond_set_lhs (stmt, op0);
gimple_cond_set_rhs (stmt, new); gimple_cond_set_rhs (stmt, new_tree);
update_stmt (stmt); update_stmt (stmt);
@ -6413,9 +6413,9 @@ simplify_cond_using_ranges (gimple stmt)
with integral types here, so no need to worry about with integral types here, so no need to worry about
issues with inverting FP comparisons. */ issues with inverting FP comparisons. */
cond_code = invert_tree_comparison (cond_code, false); cond_code = invert_tree_comparison (cond_code, false);
new = test_for_singularity (cond_code, op0, op1, vr); new_tree = test_for_singularity (cond_code, op0, op1, vr);
if (new) if (new_tree)
{ {
if (dump_file) if (dump_file)
{ {
@ -6426,7 +6426,7 @@ simplify_cond_using_ranges (gimple stmt)
gimple_cond_set_code (stmt, NE_EXPR); gimple_cond_set_code (stmt, NE_EXPR);
gimple_cond_set_lhs (stmt, op0); gimple_cond_set_lhs (stmt, op0);
gimple_cond_set_rhs (stmt, new); gimple_cond_set_rhs (stmt, new_tree);
update_stmt (stmt); update_stmt (stmt);

26
gcc/tree.c
View File

@ -2594,7 +2594,7 @@ substitute_in_expr (tree exp, tree f, tree r)
{ {
enum tree_code code = TREE_CODE (exp); enum tree_code code = TREE_CODE (exp);
tree op0, op1, op2, op3; tree op0, op1, op2, op3;
tree new, inner; tree new_tree, inner;
/* We handle TREE_LIST and COMPONENT_REF separately. */ /* We handle TREE_LIST and COMPONENT_REF separately. */
if (code == TREE_LIST) if (code == TREE_LIST)
@ -2626,7 +2626,7 @@ substitute_in_expr (tree exp, tree f, tree r)
if (op0 == TREE_OPERAND (exp, 0)) if (op0 == TREE_OPERAND (exp, 0))
return exp; return exp;
new = fold_build3 (COMPONENT_REF, TREE_TYPE (exp), new_tree = fold_build3 (COMPONENT_REF, TREE_TYPE (exp),
op0, TREE_OPERAND (exp, 1), NULL_TREE); op0, TREE_OPERAND (exp, 1), NULL_TREE);
} }
else else
@ -2652,7 +2652,7 @@ substitute_in_expr (tree exp, tree f, tree r)
if (op0 == TREE_OPERAND (exp, 0)) if (op0 == TREE_OPERAND (exp, 0))
return exp; return exp;
new = fold_build1 (code, TREE_TYPE (exp), op0); new_tree = fold_build1 (code, TREE_TYPE (exp), op0);
break; break;
case 2: case 2:
@ -2662,7 +2662,7 @@ substitute_in_expr (tree exp, tree f, tree r)
if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)) if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1))
return exp; return exp;
new = fold_build2 (code, TREE_TYPE (exp), op0, op1); new_tree = fold_build2 (code, TREE_TYPE (exp), op0, op1);
break; break;
case 3: case 3:
@ -2674,7 +2674,7 @@ substitute_in_expr (tree exp, tree f, tree r)
&& op2 == TREE_OPERAND (exp, 2)) && op2 == TREE_OPERAND (exp, 2))
return exp; return exp;
new = fold_build3 (code, TREE_TYPE (exp), op0, op1, op2); new_tree = fold_build3 (code, TREE_TYPE (exp), op0, op1, op2);
break; break;
case 4: case 4:
@ -2688,7 +2688,7 @@ substitute_in_expr (tree exp, tree f, tree r)
&& op3 == TREE_OPERAND (exp, 3)) && op3 == TREE_OPERAND (exp, 3))
return exp; return exp;
new = fold (build4 (code, TREE_TYPE (exp), op0, op1, op2, op3)); new_tree = fold (build4 (code, TREE_TYPE (exp), op0, op1, op2, op3));
break; break;
default: default:
@ -2714,7 +2714,7 @@ substitute_in_expr (tree exp, tree f, tree r)
} }
if (copy) if (copy)
new = fold (copy); new_tree = fold (copy);
else else
return exp; return exp;
} }
@ -2724,8 +2724,8 @@ substitute_in_expr (tree exp, tree f, tree r)
gcc_unreachable (); gcc_unreachable ();
} }
TREE_READONLY (new) = TREE_READONLY (exp); TREE_READONLY (new_tree) = TREE_READONLY (exp);
return new; return new_tree;
} }
/* Similar, but look for a PLACEHOLDER_EXPR in EXP and find a replacement /* Similar, but look for a PLACEHOLDER_EXPR in EXP and find a replacement
@ -5253,7 +5253,7 @@ iterative_hash_expr (const_tree t, hashval_t val)
{ {
int i; int i;
enum tree_code code; enum tree_code code;
char class; char tclass;
if (t == NULL_TREE) if (t == NULL_TREE)
return iterative_hash_pointer (t, val); return iterative_hash_pointer (t, val);
@ -5322,16 +5322,16 @@ iterative_hash_expr (const_tree t, hashval_t val)
} }
/* else FALL THROUGH */ /* else FALL THROUGH */
default: default:
class = TREE_CODE_CLASS (code); tclass = TREE_CODE_CLASS (code);
if (class == tcc_declaration) if (tclass == tcc_declaration)
{ {
/* DECL's have a unique ID */ /* DECL's have a unique ID */
val = iterative_hash_host_wide_int (DECL_UID (t), val); val = iterative_hash_host_wide_int (DECL_UID (t), val);
} }
else else
{ {
gcc_assert (IS_EXPR_CODE_CLASS (class)); gcc_assert (IS_EXPR_CODE_CLASS (tclass));
val = iterative_hash_object (code, val); val = iterative_hash_object (code, val);

12
gcc/value-prof.c
View File

@ -333,12 +333,12 @@ gimple_duplicate_stmt_histograms (struct function *fun, gimple stmt,
histogram_value val; histogram_value val;
for (val = gimple_histogram_value (ofun, ostmt); val != NULL; val = val->hvalue.next) for (val = gimple_histogram_value (ofun, ostmt); val != NULL; val = val->hvalue.next)
{ {
histogram_value new = gimple_alloc_histogram_value (fun, val->type, NULL, NULL); histogram_value new_val = gimple_alloc_histogram_value (fun, val->type, NULL, NULL);
memcpy (new, val, sizeof (*val)); memcpy (new_val, val, sizeof (*val));
new->hvalue.stmt = stmt; new_val->hvalue.stmt = stmt;
new->hvalue.counters = XNEWVAR (gcov_type, sizeof (*new->hvalue.counters) * new->n_counters); new_val->hvalue.counters = XNEWVAR (gcov_type, sizeof (*new_val->hvalue.counters) * new_val->n_counters);
memcpy (new->hvalue.counters, val->hvalue.counters, sizeof (*new->hvalue.counters) * new->n_counters); memcpy (new_val->hvalue.counters, val->hvalue.counters, sizeof (*new_val->hvalue.counters) * new_val->n_counters);
gimple_add_histogram_value (fun, stmt, new); gimple_add_histogram_value (fun, stmt, new_val);
} }
} }