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:
parent
01973e2672
commit
82d6e6fc38
|
@ -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
|
||||||
|
|
|
@ -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);
|
||||||
|
|
|
@ -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;
|
||||||
}
|
}
|
||||||
|
|
|
@ -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
56
gcc/cgraph.c
|
@ -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). */
|
||||||
|
|
|
@ -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
110
gcc/except.c
|
@ -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));
|
||||||
|
|
32
gcc/expr.c
32
gcc/expr.c
|
@ -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! */
|
||||||
|
|
|
@ -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
131
gcc/function.c
|
@ -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
16
gcc/gimple.c
|
@ -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;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
|
@ -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
12
gcc/ipa-cp.c
|
@ -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
14
gcc/passes.c
|
@ -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
|
||||||
{
|
{
|
||||||
|
|
|
@ -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))
|
||||||
{
|
{
|
||||||
|
|
|
@ -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)
|
||||||
|
|
|
@ -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;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
|
@ -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);
|
||||||
}
|
}
|
||||||
|
|
|
@ -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;
|
||||||
}
|
}
|
||||||
|
|
|
@ -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);
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
|
@ -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;
|
||||||
|
|
|
@ -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;
|
||||||
|
|
|
@ -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))
|
||||||
{
|
{
|
||||||
|
|
|
@ -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
|
||||||
|
|
|
@ -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
26
gcc/tree.c
|
@ -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);
|
||||||
|
|
||||||
|
|
|
@ -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);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
Loading…
Reference in New Issue