procyberian/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

gimple-expr.h (create_tmp_var_raw, [...]): Add default NULL value to last argument.

Browse source 
* gimple-expr.h (create_tmp_var_raw, create_tmp_var,
	create_tmp_reg): Add default NULL value to last argument.
	* tree-ssanames.h (make_ssa_name, copy_ssa_name): Likewise.
	* gimple-low.c (lower_builtin_posix_memalign): Remove NULL
	last argument from create_tmp_var_raw, create_tmp_var,
	create_tmp_reg, make_ssa_name and copy_ssa_name calls.
	* tree-ssa-strlen.c (get_string_length): Likewise.
	* tree-emutls.c (gen_emutls_addr, lower_emutls_1): Likewise.
	* tree-ssa-phiprop.c (phiprop_insert_phi): Likewise.
	* tree-vect-slp.c (vect_get_constant_vectors): Likewise.
	* ipa-prop.c (ipa_modify_call_arguments): Likewise.
	* tree-ssa-forwprop.c (simplify_rotate): Likewise.
	* tree-ssa-ccp.c (fold_builtin_alloca_with_align): Likewise.
	* asan.c (build_shadow_mem_access, maybe_create_ssa_name,
	maybe_cast_to_ptrmode, asan_expand_check_ifn): Likewise.
	* tsan.c (instrument_expr, instrument_builtin_call,
	instrument_func_entry): Likewise.
	* varpool.c (add_new_static_var): Likewise.
	* tree-loop-distribution.c (generate_memset_builtin): Likewise.
	* gimplify.c (internal_get_tmp_var, gimplify_return_expr,
	gimplify_modify_expr_to_memcpy, gimplify_modify_expr_to_memset,
	gimplify_init_ctor_eval_range, gimplify_init_constructor,
	gimplify_omp_atomic, gimplify_expr): Likewise.
	* gimple-builder.c (build_assign, build_type_cast): Likewise.
	* tree-vect-loop-manip.c (slpeel_update_phi_nodes_for_guard1,
	slpeel_update_phi_nodes_for_guard2, slpeel_tree_peel_loop_to_edge,
	vect_loop_versioning): Likewise.
	* tree-if-conv.c (version_loop_for_if_conversion): Likewise.
	* gimple-match-head.c (maybe_push_res_to_seq): Likewise.
	* tree-vect-patterns.c (vect_handle_widen_op_by_const,
	vect_recog_widen_mult_pattern, vect_operation_fits_smaller_type,
	vect_recog_over_widening_pattern): Likewise.
	* tree-sra.c (build_ref_for_offset, create_access_replacement):
	Likewise.
	* tree-cfg.c (make_blocks): Likewise.
	* tree-eh.c (lower_eh_constructs_2, lower_resx, lower_eh_dispatch):
	Likewise.
	* tree-ssa-propagate.c (update_call_from_tree): Likewise.
	* tree-complex.c (get_component_ssa_name, expand_complex_div_wide):
	Likewise.
	* tree-ssa-math-opts.c (build_and_insert_cast): Likewise.
	* tree-tailcall.c (update_accumulator_with_ops): Likewise.
	* tree-predcom.c (initialize_root_vars, initialize_root_vars_lm,
	execute_load_motion, reassociate_to_the_same_stmt): Likewise.
	* tree-ssa-reassoc.c (build_and_add_sum,
	optimize_range_tests_to_bit_test, update_ops,
	maybe_optimize_range_tests, rewrite_expr_tree, linearize_expr,
	negate_value, repropagate_negates): Likewise.
	* tree-vect-loop.c (vect_is_simple_reduction_1,
	vect_create_epilog_for_reduction): Likewise.
	* ipa-split.c (split_function): Likewise.
	* tree-inline.c (remap_ssa_name, setup_one_parameter,
	declare_return_variable, tree_function_versioning): Likewise.
	* tree-cfgcleanup.c (fixup_noreturn_call): Likewise.
	* cfgexpand.c (update_alias_info_with_stack_vars, expand_used_vars):
	Likewise.
	* tree-ssa-phiopt.c (conditional_replacement, abs_replacement,
	neg_replacement): Likewise.
	* gimplify-me.c (force_gimple_operand_1, gimple_regimplify_operands):
	Likewise.
	* tree-vrp.c (simplify_truth_ops_using_ranges,
	simplify_float_conversion_using_ranges,
	simplify_internal_call_using_ranges): Likewise.
	* tree-switch-conversion.c (emit_case_bit_tests,
	build_one_array, build_arrays, gen_def_assigns): Likewise.
	* gimple-fold.c (gimple_fold_builtin_memory_op,
	gimple_fold_builtin_strcat, gimple_fold_call, gimple_build): Likewise.
	* tree-vect-generic.c (expand_vector_divmod,
	optimize_vector_constructor): Likewise.
	* ubsan.c (ubsan_encode_value, ubsan_expand_null_ifn,
	ubsan_expand_objsize_ifn, instrument_si_overflow,
	instrument_bool_enum_load, instrument_nonnull_arg): Likewise.
	* tree-outof-ssa.c (insert_backedge_copies): Likewise.
	* tree-ssa-loop-manip.c (create_iv,
	tree_transform_and_unroll_loop): Likewise.
	* omp-low.c (scan_omp_parallel, lower_rec_simd_input_clauses,
	lower_rec_input_clauses, lower_lastprivate_clauses,
	expand_parallel_call, expand_omp_for_static_chunk,
	expand_omp_atomic_pipeline, expand_omp_target,
	maybe_add_implicit_barrier_cancel, lower_omp_single_simple,
	lower_omp_critical, lower_omp_for, task_copyfn_copy_decl,
	lower_depend_clauses, lower_omp_target, lower_omp_1,
	ipa_simd_modify_stmt_ops, simd_clone_adjust): Likewise.
	* tree-parloops.c (take_address_of, create_phi_for_local_result,
	create_call_for_reduction_1, separate_decls_in_region,
	create_parallel_loop): Likewise.
	* graphite-sese-to-poly.c (rewrite_cross_bb_scalar_dependence,
	handle_scalar_deps_crossing_scop_limits): Likewise.
	* trans-mem.c (lower_transaction, build_tm_load, build_tm_store,
	expand_assign_tm, expand_call_tm, expand_transaction,
	ipa_tm_insert_gettmclone_call): Likewise.
	* tree-vect-data-refs.c (bump_vector_ptr, vect_setup_realignment):
	Likewise.
	* tree-vect-stmts.c (vect_init_vector, vectorizable_mask_load_store,
	vectorizable_call, vectorizable_simd_clone_call,
	vectorizable_conversion, vectorizable_store, permute_vec_elements,
	vectorizable_load): Likewise.
c/
	* c-typeck.c (convert_lvalue_to_rvalue, build_atomic_assign,
	c_finish_stmt_expr): Remove NULL last argument from
	create_tmp_var_raw and create_tmp_var calls.
	* c-array-notation.c (fix_builtin_array_notation_fn,
	build_array_notation_expr, fix_conditional_array_notations_1,
	fix_array_notation_expr, fix_array_notation_call_expr): Likewise.
cp/
	* cp-gimplify.c (cxx_omp_clause_apply_fn): Remove NULL last argument
	from create_tmp_var calls.
c-family/
	* c-common.c (convert_vector_to_pointer_for_subscript): Remove NULL
	last argument from create_tmp_var_raw and create_tmp_var calls.
	* cilk.c (gimplify_cilk_spawn): Likewise.
	* c-omp.c (c_finish_omp_atomic): Likewise.
fortran/
	* trans-openmp.c (gfc_omp_finish_clause,
	gfc_trans_omp_array_reduction_or_udr, gfc_trans_omp_atomic): Remove
	NULL last argument from create_tmp_var_raw and create_tmp_var calls.

From-SVN: r218181
This commit is contained in:
Jakub Jelinek 2014-11-29 12:35:30 +01:00 • committed by Jakub Jelinek
parent d0e168a016
commit b731b39027
61 changed files with 405 additions and 300 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

100
gcc/ChangeLog
View file

@ -1,3 +1,103 @@
2014-11-29 Jakub Jelinek <jakub@redhat.com>
* gimple-expr.h (create_tmp_var_raw, create_tmp_var,
create_tmp_reg): Add default NULL value to last argument.
* tree-ssanames.h (make_ssa_name, copy_ssa_name): Likewise.
* gimple-low.c (lower_builtin_posix_memalign): Remove NULL
last argument from create_tmp_var_raw, create_tmp_var,
create_tmp_reg, make_ssa_name and copy_ssa_name calls.
* tree-ssa-strlen.c (get_string_length): Likewise.
* tree-emutls.c (gen_emutls_addr, lower_emutls_1): Likewise.
* tree-ssa-phiprop.c (phiprop_insert_phi): Likewise.
* tree-vect-slp.c (vect_get_constant_vectors): Likewise.
* ipa-prop.c (ipa_modify_call_arguments): Likewise.
* tree-ssa-forwprop.c (simplify_rotate): Likewise.
* tree-ssa-ccp.c (fold_builtin_alloca_with_align): Likewise.
* asan.c (build_shadow_mem_access, maybe_create_ssa_name,
maybe_cast_to_ptrmode, asan_expand_check_ifn): Likewise.
* tsan.c (instrument_expr, instrument_builtin_call,
instrument_func_entry): Likewise.
* varpool.c (add_new_static_var): Likewise.
* tree-loop-distribution.c (generate_memset_builtin): Likewise.
* gimplify.c (internal_get_tmp_var, gimplify_return_expr,
gimplify_modify_expr_to_memcpy, gimplify_modify_expr_to_memset,
gimplify_init_ctor_eval_range, gimplify_init_constructor,
gimplify_omp_atomic, gimplify_expr): Likewise.
* gimple-builder.c (build_assign, build_type_cast): Likewise.
* tree-vect-loop-manip.c (slpeel_update_phi_nodes_for_guard1,
slpeel_update_phi_nodes_for_guard2, slpeel_tree_peel_loop_to_edge,
vect_loop_versioning): Likewise.
* tree-if-conv.c (version_loop_for_if_conversion): Likewise.
* gimple-match-head.c (maybe_push_res_to_seq): Likewise.
* tree-vect-patterns.c (vect_handle_widen_op_by_const,
vect_recog_widen_mult_pattern, vect_operation_fits_smaller_type,
vect_recog_over_widening_pattern): Likewise.
* tree-sra.c (build_ref_for_offset, create_access_replacement):
Likewise.
* tree-cfg.c (make_blocks): Likewise.
* tree-eh.c (lower_eh_constructs_2, lower_resx, lower_eh_dispatch):
Likewise.
* tree-ssa-propagate.c (update_call_from_tree): Likewise.
* tree-complex.c (get_component_ssa_name, expand_complex_div_wide):
Likewise.
* tree-ssa-math-opts.c (build_and_insert_cast): Likewise.
* tree-tailcall.c (update_accumulator_with_ops): Likewise.
* tree-predcom.c (initialize_root_vars, initialize_root_vars_lm,
execute_load_motion, reassociate_to_the_same_stmt): Likewise.
* tree-ssa-reassoc.c (build_and_add_sum,
optimize_range_tests_to_bit_test, update_ops,
maybe_optimize_range_tests, rewrite_expr_tree, linearize_expr,
negate_value, repropagate_negates): Likewise.
* tree-vect-loop.c (vect_is_simple_reduction_1,
vect_create_epilog_for_reduction): Likewise.
* ipa-split.c (split_function): Likewise.
* tree-inline.c (remap_ssa_name, setup_one_parameter,
declare_return_variable, tree_function_versioning): Likewise.
* tree-cfgcleanup.c (fixup_noreturn_call): Likewise.
* cfgexpand.c (update_alias_info_with_stack_vars, expand_used_vars):
Likewise.
* tree-ssa-phiopt.c (conditional_replacement, abs_replacement,
neg_replacement): Likewise.
* gimplify-me.c (force_gimple_operand_1, gimple_regimplify_operands):
Likewise.
* tree-vrp.c (simplify_truth_ops_using_ranges,
simplify_float_conversion_using_ranges,
simplify_internal_call_using_ranges): Likewise.
* tree-switch-conversion.c (emit_case_bit_tests,
build_one_array, build_arrays, gen_def_assigns): Likewise.
* gimple-fold.c (gimple_fold_builtin_memory_op,
gimple_fold_builtin_strcat, gimple_fold_call, gimple_build): Likewise.
* tree-vect-generic.c (expand_vector_divmod,
optimize_vector_constructor): Likewise.
* ubsan.c (ubsan_encode_value, ubsan_expand_null_ifn,
ubsan_expand_objsize_ifn, instrument_si_overflow,
instrument_bool_enum_load, instrument_nonnull_arg): Likewise.
* tree-outof-ssa.c (insert_backedge_copies): Likewise.
* tree-ssa-loop-manip.c (create_iv,
tree_transform_and_unroll_loop): Likewise.
* omp-low.c (scan_omp_parallel, lower_rec_simd_input_clauses,
lower_rec_input_clauses, lower_lastprivate_clauses,
expand_parallel_call, expand_omp_for_static_chunk,
expand_omp_atomic_pipeline, expand_omp_target,
maybe_add_implicit_barrier_cancel, lower_omp_single_simple,
lower_omp_critical, lower_omp_for, task_copyfn_copy_decl,
lower_depend_clauses, lower_omp_target, lower_omp_1,
ipa_simd_modify_stmt_ops, simd_clone_adjust): Likewise.
* tree-parloops.c (take_address_of, create_phi_for_local_result,
create_call_for_reduction_1, separate_decls_in_region,
create_parallel_loop): Likewise.
* graphite-sese-to-poly.c (rewrite_cross_bb_scalar_dependence,
handle_scalar_deps_crossing_scop_limits): Likewise.
* trans-mem.c (lower_transaction, build_tm_load, build_tm_store,
expand_assign_tm, expand_call_tm, expand_transaction,
ipa_tm_insert_gettmclone_call): Likewise.
* tree-vect-data-refs.c (bump_vector_ptr, vect_setup_realignment):
Likewise.
* tree-vect-stmts.c (vect_init_vector, vectorizable_mask_load_store,
vectorizable_call, vectorizable_simd_clone_call,
vectorizable_conversion, vectorizable_store, permute_vec_elements,
vectorizable_load): Likewise.
2014-11-29 Tobias Burnus <burnus@net-b.de>
Manuel López-Ibáñez <manu@gcc.gnu.org>

35
gcc/asan.c
View file

@ -1585,29 +1585,25 @@ build_shadow_mem_access (gimple_stmt_iterator *gsi, location_t location,
gimple g;
t = build_int_cst (uintptr_type, ASAN_SHADOW_SHIFT);
g = gimple_build_assign_with_ops (RSHIFT_EXPR,
make_ssa_name (uintptr_type, NULL),
g = gimple_build_assign_with_ops (RSHIFT_EXPR, make_ssa_name (uintptr_type),
base_addr, t);
gimple_set_location (g, location);
gsi_insert_after (gsi, g, GSI_NEW_STMT);
t = build_int_cst (uintptr_type, asan_shadow_offset ());
g = gimple_build_assign_with_ops (PLUS_EXPR,
make_ssa_name (uintptr_type, NULL),
g = gimple_build_assign_with_ops (PLUS_EXPR, make_ssa_name (uintptr_type),
gimple_assign_lhs (g), t);
gimple_set_location (g, location);
gsi_insert_after (gsi, g, GSI_NEW_STMT);
g = gimple_build_assign_with_ops (NOP_EXPR,
make_ssa_name (shadow_ptr_type, NULL),
g = gimple_build_assign_with_ops (NOP_EXPR, make_ssa_name (shadow_ptr_type),
gimple_assign_lhs (g));
gimple_set_location (g, location);
gsi_insert_after (gsi, g, GSI_NEW_STMT);
t = build2 (MEM_REF, shadow_type, gimple_assign_lhs (g),
build_int_cst (shadow_ptr_type, 0));
g = gimple_build_assign_with_ops (MEM_REF,
make_ssa_name (shadow_type, NULL), t);
g = gimple_build_assign_with_ops (MEM_REF, make_ssa_name (shadow_type), t);
gimple_set_location (g, location);
gsi_insert_after (gsi, g, GSI_NEW_STMT);
return gimple_assign_lhs (g);
@ -1624,8 +1620,7 @@ maybe_create_ssa_name (location_t loc, tree base, gimple_stmt_iterator *iter,
return base;
gimple g
= gimple_build_assign_with_ops (TREE_CODE (base),
make_ssa_name (TREE_TYPE (base), NULL),
base);
make_ssa_name (TREE_TYPE (base)), base);
gimple_set_location (g, loc);
if (before_p)
gsi_insert_before (iter, g, GSI_SAME_STMT);
@ -1645,8 +1640,8 @@ maybe_cast_to_ptrmode (location_t loc, tree len, gimple_stmt_iterator *iter,
return len;
gimple g
= gimple_build_assign_with_ops (NOP_EXPR,
make_ssa_name (pointer_sized_int_node,
NULL), len);
make_ssa_name (pointer_sized_int_node),
len);
gimple_set_location (g, loc);
if (before_p)
gsi_insert_before (iter, g, GSI_SAME_STMT);
@ -2549,8 +2544,8 @@ asan_expand_check_ifn (gimple_stmt_iterator *iter, bool use_calls)
/* Instrument using callbacks. */
gimple g
= gimple_build_assign_with_ops (NOP_EXPR,
make_ssa_name (pointer_sized_int_node,
NULL), base);
make_ssa_name (pointer_sized_int_node),
base);
gimple_set_location (g, loc);
gsi_insert_before (iter, g, GSI_SAME_STMT);
tree base_addr = gimple_assign_lhs (g);
@ -2563,8 +2558,8 @@ asan_expand_check_ifn (gimple_stmt_iterator *iter, bool use_calls)
{
gcc_assert (nargs == 2);
g = gimple_build_assign_with_ops (NOP_EXPR,
make_ssa_name (pointer_sized_int_node,
NULL), len);
make_ssa_name (pointer_sized_int_node),
len);
gimple_set_location (g, loc);
gsi_insert_before (iter, g, GSI_SAME_STMT);
tree sz_arg = gimple_assign_lhs (g);
@ -2622,8 +2617,8 @@ asan_expand_check_ifn (gimple_stmt_iterator *iter, bool use_calls)
&else_bb);
g = gimple_build_assign_with_ops (NOP_EXPR,
make_ssa_name (pointer_sized_int_node,
NULL), base);
make_ssa_name (pointer_sized_int_node),
base);
gimple_set_location (g, loc);
gsi_insert_before (&gsi, g, GSI_NEW_STMT);
tree base_addr = gimple_assign_lhs (g);
@ -2676,14 +2671,14 @@ asan_expand_check_ifn (gimple_stmt_iterator *iter, bool use_calls)
if (size_in_bytes == -1)
{
g = gimple_build_assign_with_ops (MINUS_EXPR,
make_ssa_name (pointer_sized_int_node, NULL),
make_ssa_name (pointer_sized_int_node),
len,
build_int_cst (pointer_sized_int_node, 1));
gimple_set_location (g, loc);
gsi_insert_after (&gsi, g, GSI_NEW_STMT);
tree last = gimple_assign_lhs (g);
g = gimple_build_assign_with_ops (PLUS_EXPR,
make_ssa_name (pointer_sized_int_node, NULL),
make_ssa_name (pointer_sized_int_node),
base_addr,
last);
gimple_set_location (g, loc);

7
gcc/c-family/ChangeLog
View file

@ -1,3 +1,10 @@
2014-11-29 Jakub Jelinek <jakub@redhat.com>
* c-common.c (convert_vector_to_pointer_for_subscript): Remove NULL
last argument from create_tmp_var_raw and create_tmp_var calls.
* cilk.c (gimplify_cilk_spawn): Likewise.
* c-omp.c (c_finish_omp_atomic): Likewise.
2014-11-28 Marek Polacek <polacek@redhat.com>
* c-ubsan.c (ubsan_instrument_shift): Use op1_utype for MINUS_EXPR

2
gcc/c-family/c-common.c
View file

@ -12052,7 +12052,7 @@ convert_vector_to_pointer_for_subscript (location_t loc,
if (ret)
{
tree tmp = create_tmp_var_raw (type, NULL);
tree tmp = create_tmp_var_raw (type);
DECL_SOURCE_LOCATION (tmp) = loc;
*vecp = c_save_expr (*vecp);
if (TREE_CODE (*vecp) == C_MAYBE_CONST_EXPR)

2
gcc/c-family/c-omp.c
View file

@ -170,7 +170,7 @@ c_finish_omp_atomic (location_t loc, enum tree_code code,
{
/* Make sure LHS is simple enough so that goa_lhs_expr_p can recognize
it even after unsharing function body. */
tree var = create_tmp_var_raw (TREE_TYPE (addr), NULL);
tree var = create_tmp_var_raw (TREE_TYPE (addr));
DECL_CONTEXT (var) = current_function_decl;
addr = build4 (TARGET_EXPR, TREE_TYPE (addr), var, addr, NULL, NULL);
}

2
gcc/c-family/cilk.c
View file

@ -792,7 +792,7 @@ gimplify_cilk_spawn (tree *spawn_p)
tree frame_ptr = build1 (ADDR_EXPR, f_ptr_type, cfun->cilk_frame_decl);
tree save_fp = build_call_expr (cilk_save_fp_fndecl, 1, frame_ptr);
append_to_statement_list (save_fp, spawn_p);
setjmp_value = create_tmp_var (TREE_TYPE (call1), NULL);
setjmp_value = create_tmp_var (TREE_TYPE (call1));
setjmp_expr = fold_build2 (MODIFY_EXPR, void_type_node, setjmp_value, call1);
append_to_statement_list_force (setjmp_expr, spawn_p);

9
gcc/c/ChangeLog
View file

@ -1,3 +1,12 @@
2014-11-29 Jakub Jelinek <jakub@redhat.com>
* c-typeck.c (convert_lvalue_to_rvalue, build_atomic_assign,
c_finish_stmt_expr): Remove NULL last argument from
create_tmp_var_raw and create_tmp_var calls.
* c-array-notation.c (fix_builtin_array_notation_fn,
build_array_notation_expr, fix_conditional_array_notations_1,
fix_array_notation_expr, fix_array_notation_call_expr): Likewise.
2014-11-28 Marek Polacek <polacek@redhat.com>
PR c/63862

14
gcc/c/c-array-notation.c
View file

@ -295,7 +295,7 @@ fix_builtin_array_notation_fn (tree an_builtin_fn, tree *new_var)
for (ii = 0; ii < rank; ii++)
{
an_loop_info[ii].var = create_tmp_var (integer_type_node, NULL);
an_loop_info[ii].var = create_tmp_var (integer_type_node);
an_loop_info[ii].ind_init =
build_modify_expr (location, an_loop_info[ii].var,
TREE_TYPE (an_loop_info[ii].var), NOP_EXPR,
@ -795,8 +795,7 @@ build_array_notation_expr (location_t location, tree lhs, tree lhs_origtype,
for (ii = 0; ii < lhs_rank; ii++)
if (lhs_an_info[0][ii].is_vector)
{
lhs_an_loop_info[ii].var = create_tmp_var (integer_type_node,
NULL);
lhs_an_loop_info[ii].var = create_tmp_var (integer_type_node);
lhs_an_loop_info[ii].ind_init = build_modify_expr
(location, lhs_an_loop_info[ii].var,
TREE_TYPE (lhs_an_loop_info[ii].var), NOP_EXPR,
@ -807,8 +806,7 @@ build_array_notation_expr (location_t location, tree lhs, tree lhs_origtype,
{
/* When we have a polynomial, we assume that the indices are of type
integer. */
rhs_an_loop_info[ii].var = create_tmp_var (integer_type_node,
NULL);
rhs_an_loop_info[ii].var = create_tmp_var (integer_type_node);
rhs_an_loop_info[ii].ind_init = build_modify_expr
(location, rhs_an_loop_info[ii].var,
TREE_TYPE (rhs_an_loop_info[ii].var), NOP_EXPR,
@ -984,7 +982,7 @@ fix_conditional_array_notations_1 (tree stmt)
cilkplus_extract_an_triplets (array_list, list_size, rank, &an_info);
for (ii = 0; ii < rank; ii++)
{
an_loop_info[ii].var = create_tmp_var (integer_type_node, NULL);
an_loop_info[ii].var = create_tmp_var (integer_type_node);
an_loop_info[ii].ind_init =
build_modify_expr (location, an_loop_info[ii].var,
TREE_TYPE (an_loop_info[ii].var), NOP_EXPR,
@ -1080,7 +1078,7 @@ fix_array_notation_expr (location_t location, enum tree_code code,
loop_init = push_stmt_list ();
for (ii = 0; ii < rank; ii++)
{
an_loop_info[ii].var = create_tmp_var (integer_type_node, NULL);
an_loop_info[ii].var = create_tmp_var (integer_type_node);
an_loop_info[ii].ind_init =
build_modify_expr (location, an_loop_info[ii].var,
TREE_TYPE (an_loop_info[ii].var), NOP_EXPR,
@ -1175,7 +1173,7 @@ fix_array_notation_call_expr (tree arg)
}
for (ii = 0; ii < rank; ii++)
{
an_loop_info[ii].var = create_tmp_var (integer_type_node, NULL);
an_loop_info[ii].var = create_tmp_var (integer_type_node);
an_loop_info[ii].ind_init =
build_modify_expr (location, an_loop_info[ii].var,
TREE_TYPE (an_loop_info[ii].var), NOP_EXPR, location,

10
gcc/c/c-typeck.c
View file

@ -2012,7 +2012,7 @@ convert_lvalue_to_rvalue (location_t loc, struct c_expr exp,
/* Remove the qualifiers for the rest of the expressions and
create the VAL temp variable to hold the RHS. */
nonatomic_type = build_qualified_type (expr_type, TYPE_UNQUALIFIED);
tmp = create_tmp_var (nonatomic_type, NULL);
tmp = create_tmp_var (nonatomic_type);
tmp_addr = build_unary_op (loc, ADDR_EXPR, tmp, 0);
TREE_ADDRESSABLE (tmp) = 1;
TREE_NO_WARNING (tmp) = 1;
@ -3632,7 +3632,7 @@ build_atomic_assign (location_t loc, tree lhs, enum tree_code modifycode,
the VAL temp variable to hold the RHS. */
nonatomic_lhs_type = build_qualified_type (lhs_type, TYPE_UNQUALIFIED);
nonatomic_rhs_type = build_qualified_type (rhs_type, TYPE_UNQUALIFIED);
val = create_tmp_var (nonatomic_rhs_type, NULL);
val = create_tmp_var (nonatomic_rhs_type);
TREE_ADDRESSABLE (val) = 1;
TREE_NO_WARNING (val) = 1;
rhs = build2 (MODIFY_EXPR, nonatomic_rhs_type, val, rhs);
@ -3661,12 +3661,12 @@ build_atomic_assign (location_t loc, tree lhs, enum tree_code modifycode,
}
/* Create the variables and labels required for the op= form. */
old = create_tmp_var (nonatomic_lhs_type, NULL);
old = create_tmp_var (nonatomic_lhs_type);
old_addr = build_unary_op (loc, ADDR_EXPR, old, 0);
TREE_ADDRESSABLE (old) = 1;
TREE_NO_WARNING (old) = 1;
newval = create_tmp_var (nonatomic_lhs_type, NULL);
newval = create_tmp_var (nonatomic_lhs_type);
newval_addr = build_unary_op (loc, ADDR_EXPR, newval, 0);
TREE_ADDRESSABLE (newval) = 1;
@ -9956,7 +9956,7 @@ c_finish_stmt_expr (location_t loc, tree body)
/* Now that we've located the expression containing the value, it seems
silly to make voidify_wrapper_expr repeat the process. Create a
temporary of the appropriate type and stick it in a TARGET_EXPR. */
tmp = create_tmp_var_raw (type, NULL);
tmp = create_tmp_var_raw (type);
/* Unwrap a no-op NOP_EXPR as added by c_finish_expr_stmt. This avoids
tree_expr_nonnegative_p giving up immediately. */

6
gcc/cfgexpand.c
View file

@ -690,8 +690,8 @@ update_alias_info_with_stack_vars (void)
as base during alias-oracle queries on RTL for bases that
have been partitioned. */
if (var == NULL_TREE)
var = create_tmp_var (ptr_type_node, NULL);
name = make_ssa_name (var, NULL);
var = create_tmp_var (ptr_type_node);
name = make_ssa_name (var);
/* Create bitmaps representing partitions. They will be used for
points-to sets later, so use GGC alloc. */
@ -1738,7 +1738,7 @@ expand_used_vars (void)
{
tree *slot = &ssa_name_decls.get_or_insert (TREE_TYPE (var));
if (!*slot)
*slot = create_tmp_reg (TREE_TYPE (var), NULL);
*slot = create_tmp_reg (TREE_TYPE (var));
replace_ssa_name_symbol (var, *slot);
}

5
gcc/cp/ChangeLog
View file

@ -1,3 +1,8 @@
2014-11-29 Jakub Jelinek <jakub@redhat.com>
* cp-gimplify.c (cxx_omp_clause_apply_fn): Remove NULL last argument
from create_tmp_var calls.
2014-11-28 Marek Polacek <polacek@redhat.com>
PR c/63862

4
gcc/cp/cp-gimplify.c
View file

@ -1410,13 +1410,13 @@ cxx_omp_clause_apply_fn (tree fn, tree arg1, tree arg2)
end1 = TYPE_SIZE_UNIT (TREE_TYPE (arg1));
end1 = fold_build_pointer_plus (start1, end1);
p1 = create_tmp_var (TREE_TYPE (start1), NULL);
p1 = create_tmp_var (TREE_TYPE (start1));
t = build2 (MODIFY_EXPR, TREE_TYPE (p1), p1, start1);
append_to_statement_list (t, &ret);
if (arg2)
{
p2 = create_tmp_var (TREE_TYPE (start2), NULL);
p2 = create_tmp_var (TREE_TYPE (start2));
t = build2 (MODIFY_EXPR, TREE_TYPE (p2), p2, start2);
append_to_statement_list (t, &ret);
}

6
gcc/fortran/ChangeLog
View file

@ -1,3 +1,9 @@
2014-11-29 Jakub Jelinek <jakub@redhat.com>
* trans-openmp.c (gfc_omp_finish_clause,
gfc_trans_omp_array_reduction_or_udr, gfc_trans_omp_atomic): Remove
NULL last argument from create_tmp_var_raw and create_tmp_var calls.
2014-11-29 Tobias Burnus <burnus@net-b.de>
* scanner.c (skip_free_comments, gfc_gobble_whitespace): Use

6
gcc/fortran/trans-openmp.c
View file

@ -1069,7 +1069,7 @@ gfc_omp_finish_clause (tree c, gimple_seq *pre_p)
OMP_CLAUSE_MAP_KIND (c3) = OMP_CLAUSE_MAP_POINTER;
OMP_CLAUSE_DECL (c3) = gfc_conv_descriptor_data_get (decl);
OMP_CLAUSE_SIZE (c3) = size_int (0);
tree size = create_tmp_var (gfc_array_index_type, NULL);
tree size = create_tmp_var (gfc_array_index_type);
tree elemsz = TYPE_SIZE_UNIT (gfc_get_element_type (type));
elemsz = fold_convert (gfc_array_index_type, elemsz);
if (GFC_TYPE_ARRAY_AKIND (type) == GFC_ARRAY_POINTER
@ -1361,7 +1361,7 @@ gfc_trans_omp_array_reduction_or_udr (tree c, gfc_omp_namelist *n, locus where)
decl = OMP_CLAUSE_DECL (c);
gfc_current_locus = where;
type = TREE_TYPE (decl);
outer_decl = create_tmp_var_raw (type, NULL);
outer_decl = create_tmp_var_raw (type);
if (TREE_CODE (decl) == PARM_DECL
&& TREE_CODE (type) == REFERENCE_TYPE
&& GFC_DESCRIPTOR_TYPE_P (TREE_TYPE (type))
@ -2689,7 +2689,7 @@ gfc_trans_omp_atomic (gfc_code *code)
{
/* Make sure LHS is simple enough so that goa_lhs_expr_p can recognize
it even after unsharing function body. */
tree var = create_tmp_var_raw (TREE_TYPE (lhsaddr), NULL);
tree var = create_tmp_var_raw (TREE_TYPE (lhsaddr));
DECL_CONTEXT (var) = current_function_decl;
lhsaddr = build4 (TARGET_EXPR, TREE_TYPE (lhsaddr), var, lhsaddr,
NULL_TREE, NULL_TREE);

6
gcc/gimple-builder.c
View file

@ -65,7 +65,7 @@ build_assign (enum tree_code code, tree op1, int val, tree lhs)
{
tree op2 = build_int_cst (TREE_TYPE (op1), val);
if (lhs == NULL_TREE)
lhs = make_ssa_name (get_expr_type (code, op1), NULL);
lhs = make_ssa_name (get_expr_type (code, op1));
return gimple_build_assign_with_ops (code, lhs, op1, op2);
}
@ -88,7 +88,7 @@ gassign *
build_assign (enum tree_code code, tree op1, tree op2, tree lhs)
{
if (lhs == NULL_TREE)
lhs = make_ssa_name (get_expr_type (code, op1), NULL);
lhs = make_ssa_name (get_expr_type (code, op1));
return gimple_build_assign_with_ops (code, lhs, op1, op2);
}
@ -119,7 +119,7 @@ gassign *
build_type_cast (tree to_type, tree op, tree lhs)
{
if (lhs == NULL_TREE)
lhs = make_ssa_name (to_type, NULL);
lhs = make_ssa_name (to_type);
return gimple_build_assign_with_ops (NOP_EXPR, lhs, op);
}

6
gcc/gimple-expr.h
View file

@ -30,9 +30,9 @@ extern const char *gimple_decl_printable_name (tree, int);
extern tree copy_var_decl (tree, tree, tree);
extern bool gimple_can_coalesce_p (tree, tree);
extern tree create_tmp_var_name (const char *);
extern tree create_tmp_var_raw (tree, const char *);
extern tree create_tmp_var (tree, const char *);
extern tree create_tmp_reg (tree, const char *);
extern tree create_tmp_var_raw (tree, const char * = NULL);
extern tree create_tmp_var (tree, const char * = NULL);
extern tree create_tmp_reg (tree, const char * = NULL);
extern tree create_tmp_reg_fn (struct function *, tree, const char *);

37
gcc/gimple-fold.c
View file

@ -860,8 +860,7 @@ gimple_fold_builtin_memory_op (gimple_stmt_iterator *gsi,
srcmem = make_ssa_name (TREE_TYPE (srcmem),
new_stmt);
else
srcmem = create_tmp_reg (TREE_TYPE (srcmem),
NULL);
srcmem = create_tmp_reg (TREE_TYPE (srcmem));
gimple_assign_set_lhs (new_stmt, srcmem);
gimple_set_vuse (new_stmt, gimple_vuse (stmt));
gsi_insert_before (gsi, new_stmt, GSI_SAME_STMT);
@ -1146,7 +1145,7 @@ gimple_fold_builtin_memory_op (gimple_stmt_iterator *gsi,
if (gimple_in_ssa_p (cfun))
srcvar = make_ssa_name (TREE_TYPE (srcvar), new_stmt);
else
srcvar = create_tmp_reg (TREE_TYPE (srcvar), NULL);
srcvar = create_tmp_reg (TREE_TYPE (srcvar));
gimple_assign_set_lhs (new_stmt, srcvar);
gimple_set_vuse (new_stmt, gimple_vuse (stmt));
gsi_insert_before (gsi, new_stmt, GSI_SAME_STMT);
@ -1554,9 +1553,9 @@ gimple_fold_builtin_strcat (gimple_stmt_iterator *gsi, tree dst, tree src)
gimple repl = gimple_build_call (strlen_fn, 1, dst);
gimple_set_location (repl, loc);
if (gimple_in_ssa_p (cfun))
newdst = make_ssa_name (size_type_node, NULL);
newdst = make_ssa_name (size_type_node);
else
newdst = create_tmp_reg (size_type_node, NULL);
newdst = create_tmp_reg (size_type_node);
gimple_call_set_lhs (repl, newdst);
gimple_seq_add_stmt_without_update (&stmts, repl);
@ -2685,7 +2684,7 @@ gimple_fold_call (gimple_stmt_iterator *gsi, bool inplace)
{
if (TREE_CODE (lhs) == SSA_NAME)
{
tree var = create_tmp_var (TREE_TYPE (lhs), NULL);
tree var = create_tmp_var (TREE_TYPE (lhs));
tree def = get_or_create_ssa_default_def (cfun, var);
gimple new_stmt = gimple_build_assign (lhs, def);
gsi_insert_before (gsi, new_stmt, GSI_SAME_STMT);
@ -2700,7 +2699,7 @@ gimple_fold_call (gimple_stmt_iterator *gsi, bool inplace)
gimple_set_location (new_stmt, gimple_location (stmt));
if (lhs && TREE_CODE (lhs) == SSA_NAME)
{
tree var = create_tmp_var (TREE_TYPE (lhs), NULL);
tree var = create_tmp_var (TREE_TYPE (lhs));
tree def = get_or_create_ssa_default_def (cfun, var);
/* To satisfy condition for
@ -5666,9 +5665,9 @@ gimple_build (gimple_seq *seq, location_t loc,
if (!res)
{
if (gimple_in_ssa_p (cfun))
res = make_ssa_name (type, NULL);
res = make_ssa_name (type);
else
res = create_tmp_reg (type, NULL);
res = create_tmp_reg (type);
gimple stmt;
if (code == REALPART_EXPR
|| code == IMAGPART_EXPR
@ -5698,9 +5697,9 @@ gimple_build (gimple_seq *seq, location_t loc,
if (!res)
{
if (gimple_in_ssa_p (cfun))
res = make_ssa_name (type, NULL);
res = make_ssa_name (type);
else
res = create_tmp_reg (type, NULL);
res = create_tmp_reg (type);
gimple stmt = gimple_build_assign_with_ops (code, res, op0, op1);
gimple_set_location (stmt, loc);
gimple_seq_add_stmt_without_update (seq, stmt);
@ -5724,9 +5723,9 @@ gimple_build (gimple_seq *seq, location_t loc,
if (!res)
{
if (gimple_in_ssa_p (cfun))
res = make_ssa_name (type, NULL);
res = make_ssa_name (type);
else
res = create_tmp_reg (type, NULL);
res = create_tmp_reg (type);
gimple stmt;
if (code == BIT_FIELD_REF)
stmt = gimple_build_assign_with_ops (code, res,
@ -5760,9 +5759,9 @@ gimple_build (gimple_seq *seq, location_t loc,
if (!VOID_TYPE_P (type))
{
if (gimple_in_ssa_p (cfun))
res = make_ssa_name (type, NULL);
res = make_ssa_name (type);
else
res = create_tmp_reg (type, NULL);
res = create_tmp_reg (type);
gimple_call_set_lhs (stmt, res);
}
gimple_set_location (stmt, loc);
@ -5791,9 +5790,9 @@ gimple_build (gimple_seq *seq, location_t loc,
if (!VOID_TYPE_P (type))
{
if (gimple_in_ssa_p (cfun))
res = make_ssa_name (type, NULL);
res = make_ssa_name (type);
else
res = create_tmp_reg (type, NULL);
res = create_tmp_reg (type);
gimple_call_set_lhs (stmt, res);
}
gimple_set_location (stmt, loc);
@ -5823,9 +5822,9 @@ gimple_build (gimple_seq *seq, location_t loc,
if (!VOID_TYPE_P (type))
{
if (gimple_in_ssa_p (cfun))
res = make_ssa_name (type, NULL);
res = make_ssa_name (type);
else
res = create_tmp_reg (type, NULL);
res = create_tmp_reg (type);
gimple_call_set_lhs (stmt, res);
}
gimple_set_location (stmt, loc);

6
gcc/gimple-low.c
View file

@ -828,10 +828,10 @@ lower_builtin_posix_memalign (gimple_stmt_iterator *gsi)
tree pptr = gimple_call_arg (call, 0);
tree align = gimple_call_arg (call, 1);
tree res = gimple_call_lhs (call);
tree ptr = create_tmp_reg (ptr_type_node, NULL);
tree ptr = create_tmp_reg (ptr_type_node);
if (TREE_CODE (pptr) == ADDR_EXPR)
{
tree tem = create_tmp_var (ptr_type_node, NULL);
tree tem = create_tmp_var (ptr_type_node);
TREE_ADDRESSABLE (tem) = 1;
gimple_call_set_arg (call, 0, build_fold_addr_expr (tem));
stmt = gimple_build_assign (ptr, tem);
@ -842,7 +842,7 @@ lower_builtin_posix_memalign (gimple_stmt_iterator *gsi)
build_int_cst (ptr_type_node, 0)));
if (res == NULL_TREE)
{
res = create_tmp_reg (integer_type_node, NULL);
res = create_tmp_reg (integer_type_node);
gimple_call_set_lhs (call, res);
}
tree align_label = create_artificial_label (UNKNOWN_LOCATION);

4
gcc/gimple-match-head.c
View file

@ -330,7 +330,7 @@ maybe_push_res_to_seq (code_helper rcode, tree type, tree *ops,
&& SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ops[2])))
return NULL_TREE;
if (!res)
res = make_ssa_name (type, NULL);
res = make_ssa_name (type);
maybe_build_generic_op (rcode, type, &ops[0], ops[1], ops[2]);
gimple new_stmt = gimple_build_assign_with_ops (rcode, res,
ops[0], ops[1], ops[2]);
@ -358,7 +358,7 @@ maybe_push_res_to_seq (code_helper rcode, tree type, tree *ops,
&& SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ops[2])))
return NULL_TREE;
if (!res)
res = make_ssa_name (type, NULL);
res = make_ssa_name (type);
gimple new_stmt = gimple_build_call (decl, nargs, ops[0], ops[1], ops[2]);
gimple_call_set_lhs (new_stmt, res);
gimple_seq_add_stmt_without_update (seq, new_stmt);

6
gcc/gimplify-me.c
View file

@ -78,7 +78,7 @@ force_gimple_operand_1 (tree expr, gimple_seq *stmts,
if (var)
{
if (gimple_in_ssa_p (cfun) && is_gimple_reg (var))
var = make_ssa_name (var, NULL);
var = make_ssa_name (var);
expr = build2 (MODIFY_EXPR, TREE_TYPE (var), var, expr);
}
@ -313,9 +313,9 @@ gimple_regimplify_operands (gimple stmt, gimple_stmt_iterator *gsi_p)
}
if (need_temp)
{
tree temp = create_tmp_reg (TREE_TYPE (lhs), NULL);
tree temp = create_tmp_reg (TREE_TYPE (lhs));
if (gimple_in_ssa_p (cfun))
temp = make_ssa_name (temp, NULL);
temp = make_ssa_name (temp);
gimple_set_lhs (stmt, temp);
post_stmt = gimple_build_assign (lhs, temp);
}

16
gcc/gimplify.c
View file

@ -530,7 +530,7 @@ internal_get_tmp_var (tree val, gimple_seq *pre_p, gimple_seq *post_p,
if (gimplify_ctxp->into_ssa
&& is_gimple_reg_type (TREE_TYPE (val)))
t = make_ssa_name (TYPE_MAIN_VARIANT (TREE_TYPE (val)), NULL);
t = make_ssa_name (TYPE_MAIN_VARIANT (TREE_TYPE (val)));
else
t = lookup_tmp_var (val, is_formal);
@ -1271,7 +1271,7 @@ gimplify_return_expr (tree stmt, gimple_seq *pre_p)
result = gimplify_ctxp->return_temp;
else
{
result = create_tmp_reg (TREE_TYPE (result_decl), NULL);
result = create_tmp_reg (TREE_TYPE (result_decl));
/* ??? With complex control flow (usually involving abnormal edges),
we can wind up warning about an uninitialized value for this. Due
@ -3263,7 +3263,7 @@ gimplify_modify_expr_to_memcpy (tree *expr_p, tree size, bool want_value,
if (want_value)
{
/* tmp = memcpy() */
t = create_tmp_var (TREE_TYPE (to_ptr), NULL);
t = create_tmp_var (TREE_TYPE (to_ptr));
gimple_call_set_lhs (gs, t);
gimplify_seq_add_stmt (seq_p, gs);
@ -3310,7 +3310,7 @@ gimplify_modify_expr_to_memset (tree *expr_p, tree size, bool want_value,
if (want_value)
{
/* tmp = memset() */
t = create_tmp_var (TREE_TYPE (to_ptr), NULL);
t = create_tmp_var (TREE_TYPE (to_ptr));
gimple_call_set_lhs (gs, t);
gimplify_seq_add_stmt (seq_p, gs);
@ -3486,7 +3486,7 @@ gimplify_init_ctor_eval_range (tree object, tree lower, tree upper,
/* Create and initialize the index variable. */
var_type = TREE_TYPE (upper);
var = create_tmp_var (var_type, NULL);
var = create_tmp_var (var_type);
gimplify_seq_add_stmt (pre_p, gimple_build_assign (var, lower));
/* Add the loop entry label. */
@ -3945,7 +3945,7 @@ gimplify_init_constructor (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
&& num_nonzero_elements > 0
&& vec_safe_length (elts) > 1)
{
tree temp = create_tmp_var (TYPE_MAIN_VARIANT (type), NULL);
tree temp = create_tmp_var (TYPE_MAIN_VARIANT (type));
TREE_OPERAND (*expr_p, 0) = temp;
*expr_p = build2 (COMPOUND_EXPR, TREE_TYPE (*expr_p),
*expr_p,
@ -7374,7 +7374,7 @@ gimplify_omp_atomic (tree *expr_p, gimple_seq *pre_p)
gomp_atomic_load *loadstmt;
gomp_atomic_store *storestmt;
tmp_load = create_tmp_reg (type, NULL);
tmp_load = create_tmp_reg (type);
if (rhs && goa_stabilize_expr (&rhs, pre_p, addr, tmp_load) < 0)
return GS_ERROR;
@ -7791,7 +7791,7 @@ gimplify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
ret = GS_OK;
break;
}
tree tmp = create_tmp_var (type, NULL);
tree tmp = create_tmp_var (type);
gimplify_arg (&cond, pre_p, EXPR_LOCATION (*expr_p));
gcall *call
= gimple_build_call_internal (IFN_ANNOTATE, 2, cond, kind);

4
gcc/graphite-sese-to-poly.c
View file

@ -2347,7 +2347,7 @@ rewrite_cross_bb_scalar_dependence (scop_p scop, tree zero_dim_array,
gcc_assert (gimple_code (use_stmt) != GIMPLE_PHI);
name = copy_ssa_name (def, NULL);
name = copy_ssa_name (def);
name_stmt = gimple_build_assign (name, zero_dim_array);
gimple_assign_set_lhs (name_stmt, name);
@ -2367,7 +2367,7 @@ rewrite_cross_bb_scalar_dependence (scop_p scop, tree zero_dim_array,
static void
handle_scalar_deps_crossing_scop_limits (scop_p scop, tree def, gimple stmt)
{
tree var = create_tmp_reg (TREE_TYPE (def), NULL);
tree var = create_tmp_reg (TREE_TYPE (def));
tree new_name = make_ssa_name (var, stmt);
bool needs_copy = false;
use_operand_p use_p;

2
gcc/ipa-prop.c
View file

@ -4004,7 +4004,7 @@ ipa_modify_call_arguments (struct cgraph_edge *cs, gcall *stmt,
expr = make_ssa_name (TREE_TYPE (expr), tem);
}
else
expr = create_tmp_reg (TREE_TYPE (expr), NULL);
expr = create_tmp_reg (TREE_TYPE (expr));
gimple_assign_set_lhs (tem, expr);
gsi_insert_before (&gsi, tem, GSI_SAME_STMT);
}

6
gcc/ipa-split.c
View file

@ -1584,7 +1584,7 @@ split_function (struct split_point *split_point)
if (!useless_type_conversion_p (TREE_TYPE (retval), restype))
{
gimple cpy;
tree tem = create_tmp_reg (restype, NULL);
tree tem = create_tmp_reg (restype);
tem = make_ssa_name (tem, call);
cpy = gimple_build_assign_with_ops (NOP_EXPR, retval,
tem);
@ -1614,14 +1614,14 @@ split_function (struct split_point *split_point)
if (chkp_function_instrumented_p (current_function_decl)
&& BOUNDED_P (retval))
retbnd = create_tmp_reg (pointer_bounds_type_node, NULL);
retbnd = create_tmp_reg (pointer_bounds_type_node);
/* We use temporary register to hold value when aggregate_value_p
is false. Similarly for DECL_BY_REFERENCE we must avoid extra
copy. */
if (!aggregate_value_p (retval, TREE_TYPE (current_function_decl))
&& !DECL_BY_REFERENCE (retval))
retval = create_tmp_reg (TREE_TYPE (retval), NULL);
retval = create_tmp_reg (TREE_TYPE (retval));
if (is_gimple_reg (retval))
{
/* When returning by reference, there is only one SSA name

79
gcc/omp-low.c
View file

@ -2110,7 +2110,7 @@ scan_omp_parallel (gimple_stmt_iterator *gsi, omp_context *outer_ctx)
count += fd.collapse - 1;
for (i = 0; i < count; i++)
{
tree temp = create_tmp_var (type, NULL);
tree temp = create_tmp_var (type);
tree c = build_omp_clause (UNKNOWN_LOCATION,
OMP_CLAUSE__LOOPTEMP_);
insert_decl_map (&outer_ctx->cb, temp, temp);
@ -3165,15 +3165,15 @@ lower_rec_simd_input_clauses (tree new_var, omp_context *ctx, int &max_vf,
}
if (max_vf > 1)
{
idx = create_tmp_var (unsigned_type_node, NULL);
lane = create_tmp_var (unsigned_type_node, NULL);
idx = create_tmp_var (unsigned_type_node);
lane = create_tmp_var (unsigned_type_node);
}
}
if (max_vf == 1)
return false;
tree atype = build_array_type_nelts (TREE_TYPE (new_var), max_vf);
tree avar = create_tmp_var_raw (atype, NULL);
tree avar = create_tmp_var_raw (atype);
if (TREE_ADDRESSABLE (new_var))
TREE_ADDRESSABLE (avar) = 1;
DECL_ATTRIBUTES (avar)
@ -3343,7 +3343,7 @@ lower_rec_input_clauses (tree clauses, gimple_seq *ilist, gimple_seq *dlist,
t = build_call_expr_loc (clause_loc, t2, 2, t,
omp_clause_aligned_alignment (c));
t = fold_convert_loc (clause_loc, ptype, t);
x = create_tmp_var (ptype, NULL);
x = create_tmp_var (ptype);
t = build2 (MODIFY_EXPR, ptype, x, t);
gimplify_and_add (t, ilist);
t = build_simple_mem_ref_loc (clause_loc, x);
@ -3386,7 +3386,7 @@ lower_rec_input_clauses (tree clauses, gimple_seq *ilist, gimple_seq *dlist,
/* void *tmp = __builtin_alloca */
atmp = builtin_decl_explicit (BUILT_IN_ALLOCA);
stmt = gimple_build_call (atmp, 1, x);
tmp = create_tmp_var_raw (ptr_type_node, NULL);
tmp = create_tmp_var_raw (ptr_type_node);
gimple_add_tmp_var (tmp);
gimple_call_set_lhs (stmt, tmp);
@ -3622,7 +3622,7 @@ lower_rec_input_clauses (tree clauses, gimple_seq *ilist, gimple_seq *dlist,
{
if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LINEAR)
{
tree iv = create_tmp_var (TREE_TYPE (new_var), NULL);
tree iv = create_tmp_var (TREE_TYPE (new_var));
x = lang_hooks.decls.omp_clause_copy_ctor (c, iv, x);
gimplify_and_add (x, ilist);
gimple_stmt_iterator gsi
@ -3851,7 +3851,7 @@ lower_rec_input_clauses (tree clauses, gimple_seq *ilist, gimple_seq *dlist,
for (int i = 0; i < 2; i++)
if (llist[i])
{
tree vf = create_tmp_var (unsigned_type_node, NULL);
tree vf = create_tmp_var (unsigned_type_node);
g = gimple_build_call_internal (IFN_GOMP_SIMD_VF, 1, uid);
gimple_call_set_lhs (g, vf);
gimple_seq *seq = i == 0 ? ilist : dlist;
@ -4009,7 +4009,7 @@ lower_lastprivate_clauses (tree clauses, tree predicate, gimple_seq *stmt_list,
{
if (lastlane == NULL)
{
lastlane = create_tmp_var (unsigned_type_node, NULL);
lastlane = create_tmp_var (unsigned_type_node);
gcall *g
= gimple_build_call_internal (IFN_GOMP_SIMD_LAST_LANE,
2, simduid,
@ -4464,12 +4464,12 @@ expand_parallel_call (struct omp_region *region, basic_block bb,
edge e, e_then, e_else;
tree tmp_then, tmp_else, tmp_join, tmp_var;
tmp_var = create_tmp_var (TREE_TYPE (val), NULL);
tmp_var = create_tmp_var (TREE_TYPE (val));
if (gimple_in_ssa_p (cfun))
{
tmp_then = make_ssa_name (tmp_var, NULL);
tmp_else = make_ssa_name (tmp_var, NULL);
tmp_join = make_ssa_name (tmp_var, NULL);
tmp_then = make_ssa_name (tmp_var);
tmp_else = make_ssa_name (tmp_var);
tmp_join = make_ssa_name (tmp_var);
}
else
{
@ -6572,9 +6572,9 @@ expand_omp_for_static_chunk (struct omp_region *region,
trip_var = create_tmp_reg (itype, ".trip");
if (gimple_in_ssa_p (cfun))
{
trip_init = make_ssa_name (trip_var, NULL);
trip_main = make_ssa_name (trip_var, NULL);
trip_back = make_ssa_name (trip_var, NULL);
trip_init = make_ssa_name (trip_var);
trip_main = make_ssa_name (trip_var);
trip_back = make_ssa_name (trip_var);
}
else
{
@ -8009,16 +8009,16 @@ expand_omp_atomic_pipeline (basic_block load_bb, basic_block store_bb,
tree iaddr_val;
iaddr = create_tmp_reg (build_pointer_type_for_mode (itype, ptr_mode,
true), NULL);
true));
iaddr_val
= force_gimple_operand_gsi (&si,
fold_convert (TREE_TYPE (iaddr), addr),
false, NULL_TREE, true, GSI_SAME_STMT);
stmt = gimple_build_assign (iaddr, iaddr_val);
gsi_insert_before (&si, stmt, GSI_SAME_STMT);
loadedi = create_tmp_var (itype, NULL);
loadedi = create_tmp_var (itype);
if (gimple_in_ssa_p (cfun))
loadedi = make_ssa_name (loadedi, NULL);
loadedi = make_ssa_name (loadedi);
}
else
{
@ -8102,7 +8102,7 @@ expand_omp_atomic_pipeline (basic_block load_bb, basic_block store_bb,
old_vali = loadedi;
else
{
old_vali = create_tmp_var (TREE_TYPE (loadedi), NULL);
old_vali = create_tmp_var (TREE_TYPE (loadedi));
stmt = gimple_build_assign (old_vali, loadedi);
gsi_insert_before (&si, stmt, GSI_SAME_STMT);
@ -8508,7 +8508,7 @@ expand_omp_target (struct omp_region *region)
edge e;
tree tmp_var;
tmp_var = create_tmp_var (TREE_TYPE (device), NULL);
tmp_var = create_tmp_var (TREE_TYPE (device));
if (kind != GF_OMP_TARGET_KIND_REGION)
{
gsi = gsi_last_bb (new_bb);
@ -8930,7 +8930,7 @@ maybe_add_implicit_barrier_cancel (omp_context *ctx, gimple_seq *body)
{
tree fndecl = builtin_decl_explicit (BUILT_IN_GOMP_CANCEL);
tree c_bool_type = TREE_TYPE (TREE_TYPE (fndecl));
tree lhs = create_tmp_var (c_bool_type, NULL);
tree lhs = create_tmp_var (c_bool_type);
gimple_omp_return_set_lhs (omp_return, lhs);
tree fallthru_label = create_artificial_label (UNKNOWN_LOCATION);
gimple g = gimple_build_cond (NE_EXPR, lhs,
@ -9059,7 +9059,7 @@ lower_omp_single_simple (gomp_single *single_stmt, gimple_seq *pre_p)
tree lhs, decl;
decl = builtin_decl_explicit (BUILT_IN_GOMP_SINGLE_START);
lhs = create_tmp_var (TREE_TYPE (TREE_TYPE (decl)), NULL);
lhs = create_tmp_var (TREE_TYPE (TREE_TYPE (decl)));
call = gimple_build_call (decl, 0);
gimple_call_set_lhs (call, lhs);
gimple_seq_add_stmt (pre_p, call);
@ -9355,7 +9355,7 @@ lower_omp_critical (gimple_stmt_iterator *gsi_p, omp_context *ctx)
{
char *new_str;
decl = create_tmp_var_raw (ptr_type_node, NULL);
decl = create_tmp_var_raw (ptr_type_node);
new_str = ACONCAT ((".gomp_critical_user_",
IDENTIFIER_POINTER (name), NULL));
@ -9555,7 +9555,7 @@ lower_omp_for (gimple_stmt_iterator *gsi_p, omp_context *ctx)
}
else
{
temp = create_tmp_var (type, NULL);
temp = create_tmp_var (type);
insert_decl_map (&ctx->outer->cb, temp, temp);
}
*pc = build_omp_clause (UNKNOWN_LOCATION, OMP_CLAUSE__LOOPTEMP_);
@ -9675,7 +9675,7 @@ task_copyfn_copy_decl (tree var, copy_body_data *cb)
struct omp_taskcopy_context *tcctx = (struct omp_taskcopy_context *) cb;
if (splay_tree_lookup (tcctx->ctx->sfield_map, (splay_tree_key) var))
return create_tmp_var (TREE_TYPE (var), NULL);
return create_tmp_var (TREE_TYPE (var));
return var;
}
@ -9964,7 +9964,7 @@ lower_depend_clauses (gimple stmt, gimple_seq *iseq, gimple_seq *oseq)
gcc_unreachable ();
}
tree type = build_array_type_nelts (ptr_type_node, n_in + n_out + 2);
tree array = create_tmp_var (type, NULL);
tree array = create_tmp_var (type);
tree r = build4 (ARRAY_REF, ptr_type_node, array, size_int (0), NULL_TREE,
NULL_TREE);
g = gimple_build_assign (r, build_int_cst (ptr_type_node, n_in + n_out));
@ -10306,7 +10306,7 @@ lower_omp_target (gimple_stmt_iterator *gsi_p, omp_context *ctx)
{
gcc_assert (kind == GF_OMP_TARGET_KIND_REGION);
tree avar
= create_tmp_var (TREE_TYPE (TREE_TYPE (x)), NULL);
= create_tmp_var (TREE_TYPE (TREE_TYPE (x)));
mark_addressable (avar);
gimplify_assign (avar, build_fold_addr_expr (var), &ilist);
talign = DECL_ALIGN_UNIT (avar);
@ -10316,7 +10316,7 @@ lower_omp_target (gimple_stmt_iterator *gsi_p, omp_context *ctx)
else if (is_gimple_reg (var))
{
gcc_assert (kind == GF_OMP_TARGET_KIND_REGION);
tree avar = create_tmp_var (TREE_TYPE (var), NULL);
tree avar = create_tmp_var (TREE_TYPE (var));
mark_addressable (avar);
if (OMP_CLAUSE_MAP_KIND (c) != OMP_CLAUSE_MAP_ALLOC
&& OMP_CLAUSE_MAP_KIND (c) != OMP_CLAUSE_MAP_FROM)
@ -10685,7 +10685,7 @@ lower_omp_1 (gimple_stmt_iterator *gsi_p, omp_context *ctx)
gimple_call_set_fntype (call_stmt, TREE_TYPE (fndecl));
}
tree lhs;
lhs = create_tmp_var (TREE_TYPE (TREE_TYPE (fndecl)), NULL);
lhs = create_tmp_var (TREE_TYPE (TREE_TYPE (fndecl)));
gimple_call_set_lhs (call_stmt, lhs);
tree fallthru_label;
fallthru_label = create_artificial_label (UNKNOWN_LOCATION);
@ -11924,8 +11924,7 @@ ipa_simd_modify_stmt_ops (tree *tp, int *walk_subtrees, void *data)
}
else
{
stmt = gimple_build_assign (make_ssa_name (TREE_TYPE (repl),
NULL), repl);
stmt = gimple_build_assign (make_ssa_name (TREE_TYPE (repl)), repl);
repl = gimple_assign_lhs (stmt);
}
gimple_stmt_iterator gsi = gsi_for_stmt (info->stmt);
@ -12090,8 +12089,8 @@ simd_clone_adjust (struct cgraph_node *node)
/* Adjust all uses of vector arguments accordingly. Adjust all
return values accordingly. */
tree iter = create_tmp_var (unsigned_type_node, "iter");
tree iter1 = make_ssa_name (iter, NULL);
tree iter2 = make_ssa_name (iter, NULL);
tree iter1 = make_ssa_name (iter);
tree iter2 = make_ssa_name (iter);
ipa_simd_modify_function_body (node, adjustments, retval, iter1);
/* Initialize the iteration variable. */
@ -12140,7 +12139,7 @@ simd_clone_adjust (struct cgraph_node *node)
gimple_stmt_iterator gsi = gsi_last_bb (loop->header);
tree mask_array
= node->simdclone->args[node->simdclone->nargs - 1].simd_array;
tree mask = make_ssa_name (TREE_TYPE (TREE_TYPE (mask_array)), NULL);
tree mask = make_ssa_name (TREE_TYPE (TREE_TYPE (mask_array)));
tree aref = build4 (ARRAY_REF,
TREE_TYPE (TREE_TYPE (mask_array)),
mask_array, iter1,
@ -12152,7 +12151,7 @@ simd_clone_adjust (struct cgraph_node *node)
{
aref = build1 (VIEW_CONVERT_EXPR,
build_nonstandard_integer_type (bitsize, 0), mask);
mask = make_ssa_name (TREE_TYPE (aref), NULL);
mask = make_ssa_name (TREE_TYPE (aref));
g = gimple_build_assign (mask, aref);
gsi_insert_after (&gsi, g, GSI_CONTINUE_LINKING);
}
@ -12234,12 +12233,12 @@ simd_clone_adjust (struct cgraph_node *node)
if (!useless_type_conversion_p (TREE_TYPE (orig_arg),
ptr_type_node))
need_cvt = true;
tree t = make_ssa_name (need_cvt ? ptr_type_node : orig_arg, NULL);
tree t = make_ssa_name (need_cvt ? ptr_type_node : orig_arg);
gimple_call_set_lhs (g, t);
gimple_seq_add_stmt_without_update (&seq, g);
if (need_cvt)
{
t = make_ssa_name (orig_arg, NULL);
t = make_ssa_name (orig_arg);
g = gimple_build_assign_with_ops (NOP_EXPR, t,
gimple_call_lhs (g));
gimple_seq_add_stmt_without_update (&seq, g);
@ -12274,8 +12273,8 @@ simd_clone_adjust (struct cgraph_node *node)
|| POINTER_TYPE_P (TREE_TYPE (orig_arg)));
if (def && !has_zero_uses (def))
{
iter1 = make_ssa_name (orig_arg, NULL);
iter2 = make_ssa_name (orig_arg, NULL);
iter1 = make_ssa_name (orig_arg);
iter2 = make_ssa_name (orig_arg);
phi = create_phi_node (iter1, body_bb);
add_phi_arg (phi, def, preheader_edge, UNKNOWN_LOCATION);
add_phi_arg (phi, iter2, latch_edge, UNKNOWN_LOCATION);

22
gcc/trans-mem.c
View file

@ -1675,7 +1675,7 @@ lower_transaction (gimple_stmt_iterator *gsi, struct walk_stmt_info *wi)
g = gimple_build_call (builtin_decl_explicit (BUILT_IN_EH_POINTER),
1, integer_zero_node);
ptr = create_tmp_var (ptr_type_node, NULL);
ptr = create_tmp_var (ptr_type_node);
gimple_call_set_lhs (g, ptr);
gimple_seq_add_stmt (&e_seq, g);
@ -2195,7 +2195,7 @@ build_tm_load (location_t loc, tree lhs, tree rhs, gimple_stmt_iterator *gsi)
gimple g;
tree temp;
temp = create_tmp_reg (t, NULL);
temp = create_tmp_reg (t);
gimple_call_set_lhs (gcall, temp);
gsi_insert_before (gsi, gcall, GSI_SAME_STMT);
@ -2273,7 +2273,7 @@ build_tm_store (location_t loc, tree lhs, tree rhs, gimple_stmt_iterator *gsi)
gimple g;
tree temp;
temp = create_tmp_reg (simple_type, NULL);
temp = create_tmp_reg (simple_type);
t = fold_build1 (VIEW_CONVERT_EXPR, simple_type, rhs);
g = gimple_build_assign (temp, t);
gimple_set_location (g, loc);
@ -2339,7 +2339,7 @@ expand_assign_tm (struct tm_region *region, gimple_stmt_iterator *gsi)
if (load_p && is_gimple_reg (lhs))
{
tmp = create_tmp_var (TREE_TYPE (lhs), NULL);
tmp = create_tmp_var (TREE_TYPE (lhs));
lhs_addr = build_fold_addr_expr (tmp);
}
else
@ -2466,7 +2466,7 @@ expand_call_tm (struct tm_region *region,
if (lhs && requires_barrier (region->entry_block, lhs, stmt)
&& !gimple_call_return_slot_opt_p (stmt))
{
tree tmp = create_tmp_reg (TREE_TYPE (lhs), NULL);
tree tmp = create_tmp_reg (TREE_TYPE (lhs));
location_t loc = gimple_location (stmt);
edge fallthru_edge = NULL;
gassign *assign_stmt;
@ -2805,7 +2805,7 @@ expand_transaction (struct tm_region *region, void *data ATTRIBUTE_UNUSED)
if (region->restart_block == region->entry_block)
region->restart_block = test_bb;
tree t1 = create_tmp_reg (tm_state_type, NULL);
tree t1 = create_tmp_reg (tm_state_type);
tree t2 = build_int_cst (tm_state_type, A_RESTORELIVEVARIABLES);
gimple stmt = gimple_build_assign_with_ops (BIT_AND_EXPR, t1,
tm_state, t2);
@ -2846,7 +2846,7 @@ expand_transaction (struct tm_region *region, void *data ATTRIBUTE_UNUSED)
if (region->restart_block == region->entry_block)
region->restart_block = test_bb;
tree t1 = create_tmp_reg (tm_state_type, NULL);
tree t1 = create_tmp_reg (tm_state_type);
tree t2 = build_int_cst (tm_state_type, A_ABORTTRANSACTION);
gimple stmt = gimple_build_assign_with_ops (BIT_AND_EXPR, t1,
tm_state, t2);
@ -2888,7 +2888,7 @@ expand_transaction (struct tm_region *region, void *data ATTRIBUTE_UNUSED)
if (region->restart_block == region->entry_block)
region->restart_block = test_bb;
tree t1 = create_tmp_reg (tm_state_type, NULL);
tree t1 = create_tmp_reg (tm_state_type);
tree t2 = build_int_cst (tm_state_type, A_RUNUNINSTRUMENTEDCODE);
gimple stmt = gimple_build_assign_with_ops (BIT_AND_EXPR, t1,
@ -5053,7 +5053,7 @@ ipa_tm_insert_gettmclone_call (struct cgraph_node *node,
safe = is_tm_safe (TREE_TYPE (old_fn));
gettm_fn = builtin_decl_explicit (safe ? BUILT_IN_TM_GETTMCLONE_SAFE
: BUILT_IN_TM_GETTMCLONE_IRR);
ret = create_tmp_var (ptr_type_node, NULL);
ret = create_tmp_var (ptr_type_node);
if (!safe)
transaction_subcode_ior (region, GTMA_MAY_ENTER_IRREVOCABLE);
@ -5074,7 +5074,7 @@ ipa_tm_insert_gettmclone_call (struct cgraph_node *node,
/* Cast return value from tm_gettmclone* into appropriate function
pointer. */
callfn = create_tmp_var (TREE_TYPE (old_fn), NULL);
callfn = create_tmp_var (TREE_TYPE (old_fn));
g2 = gimple_build_assign (callfn,
fold_build1 (NOP_EXPR, TREE_TYPE (callfn), ret));
callfn = make_ssa_name (callfn, g2);
@ -5099,7 +5099,7 @@ ipa_tm_insert_gettmclone_call (struct cgraph_node *node,
{
tree temp;
temp = create_tmp_reg (rettype, 0);
temp = create_tmp_reg (rettype);
gimple_call_set_lhs (stmt, temp);
g2 = gimple_build_assign (lhs,

2
gcc/tree-cfg.c
View file

@ -546,7 +546,7 @@ make_blocks (gimple_seq seq)
&& is_gimple_reg_type (TREE_TYPE (gimple_get_lhs (stmt))))
{
tree lhs = gimple_get_lhs (stmt);
tree tmp = create_tmp_var (TREE_TYPE (lhs), NULL);
tree tmp = create_tmp_var (TREE_TYPE (lhs));
gimple s = gimple_build_assign (lhs, tmp);
gimple_set_location (s, gimple_location (stmt));
gimple_set_block (s, gimple_block (stmt));

2
gcc/tree-cfgcleanup.c
View file

@ -598,7 +598,7 @@ fixup_noreturn_call (gimple stmt)
/* We need to fix up the SSA name to avoid checking errors. */
if (TREE_CODE (lhs) == SSA_NAME)
{
tree new_var = create_tmp_reg (TREE_TYPE (lhs), NULL);
tree new_var = create_tmp_reg (TREE_TYPE (lhs));
SET_SSA_NAME_VAR_OR_IDENTIFIER (lhs, new_var);
SSA_NAME_DEF_STMT (lhs) = gimple_build_nop ();
set_ssa_default_def (cfun, new_var, lhs);

10
gcc/tree-complex.c
View file

@ -514,7 +514,7 @@ get_component_ssa_name (tree ssa_name, bool imag_p)
ret = get_component_var (SSA_NAME_VAR (ssa_name), imag_p);
else
ret = TREE_TYPE (TREE_TYPE (ssa_name));
ret = make_ssa_name (ret, NULL);
ret = make_ssa_name (ret);
/* Copy some properties from the original. In particular, whether it
is used in an abnormal phi, and whether it's uninitialized. */
@ -1143,11 +1143,11 @@ expand_complex_div_wide (gimple_stmt_iterator *gsi, tree inner_type,
gimple stmt;
tree cond, tmp;
tmp = create_tmp_var (boolean_type_node, NULL);
tmp = create_tmp_var (boolean_type_node);
stmt = gimple_build_assign (tmp, compare);
if (gimple_in_ssa_p (cfun))
{
tmp = make_ssa_name (tmp, stmt);
tmp = make_ssa_name (tmp, stmt);
gimple_assign_set_lhs (stmt, tmp);
}
@ -1182,8 +1182,8 @@ expand_complex_div_wide (gimple_stmt_iterator *gsi, tree inner_type,
set_immediate_dominator (CDI_DOMINATORS, bb_false, bb_cond);
}
rr = create_tmp_reg (inner_type, NULL);
ri = create_tmp_reg (inner_type, NULL);
rr = create_tmp_reg (inner_type);
ri = create_tmp_reg (inner_type);
}
/* In the TRUE branch, we compute

8
gcc/tree-eh.c
View file

@ -2044,7 +2044,7 @@ lower_eh_constructs_2 (struct leh_state *state, gimple_stmt_iterator *gsi)
&& is_gimple_reg_type (TREE_TYPE (gimple_get_lhs (stmt))))
{
tree lhs = gimple_get_lhs (stmt);
tree tmp = create_tmp_var (TREE_TYPE (lhs), NULL);
tree tmp = create_tmp_var (TREE_TYPE (lhs));
gimple s = gimple_build_assign (lhs, tmp);
gimple_set_location (s, gimple_location (stmt));
gimple_set_block (s, gimple_block (stmt));
@ -3286,7 +3286,7 @@ lower_resx (basic_block bb, gresx *stmt,
fn = builtin_decl_implicit (BUILT_IN_EH_POINTER);
src_nr = build_int_cst (integer_type_node, src_r->index);
x = gimple_build_call (fn, 1, src_nr);
var = create_tmp_var (ptr_type_node, NULL);
var = create_tmp_var (ptr_type_node);
var = make_ssa_name (var, x);
gimple_call_set_lhs (x, var);
gsi_insert_before (&gsi, x, GSI_SAME_STMT);
@ -3652,7 +3652,7 @@ lower_eh_dispatch (basic_block src, geh_dispatch *stmt)
fn = builtin_decl_implicit (BUILT_IN_EH_FILTER);
x = gimple_build_call (fn, 1, build_int_cst (integer_type_node,
region_nr));
filter = create_tmp_var (TREE_TYPE (TREE_TYPE (fn)), NULL);
filter = create_tmp_var (TREE_TYPE (TREE_TYPE (fn)));
filter = make_ssa_name (filter, x);
gimple_call_set_lhs (x, filter);
gsi_insert_before (&gsi, x, GSI_SAME_STMT);
@ -3675,7 +3675,7 @@ lower_eh_dispatch (basic_block src, geh_dispatch *stmt)
fn = builtin_decl_implicit (BUILT_IN_EH_FILTER);
x = gimple_build_call (fn, 1, build_int_cst (integer_type_node,
region_nr));
filter = create_tmp_var (TREE_TYPE (TREE_TYPE (fn)), NULL);
filter = create_tmp_var (TREE_TYPE (TREE_TYPE (fn)));
filter = make_ssa_name (filter, x);
gimple_call_set_lhs (x, filter);
gsi_insert_before (&gsi, x, GSI_SAME_STMT);

4
gcc/tree-emutls.c
View file

@ -425,7 +425,7 @@ gen_emutls_addr (tree decl, struct lower_emutls_data *d)
cdecl = cvar->decl;
TREE_ADDRESSABLE (cdecl) = 1;
addr = create_tmp_var (build_pointer_type (TREE_TYPE (decl)), NULL);
addr = create_tmp_var (build_pointer_type (TREE_TYPE (decl)));
x = gimple_build_call (d->builtin_decl, 1, build_fold_addr_expr (cdecl));
gimple_set_location (x, d->loc);
@ -493,7 +493,7 @@ lower_emutls_1 (tree *ptr, int *walk_subtrees, void *cb_data)
{
gimple x;
addr = create_tmp_var (TREE_TYPE (t), NULL);
addr = create_tmp_var (TREE_TYPE (t));
x = gimple_build_assign (addr, t);
gimple_set_location (x, d->loc);

2
gcc/tree-if-conv.c
View file

@ -2108,7 +2108,7 @@ static bool
version_loop_for_if_conversion (struct loop *loop)
{
basic_block cond_bb;
tree cond = make_ssa_name (boolean_type_node, NULL);
tree cond = make_ssa_name (boolean_type_node);
struct loop *new_loop;
gimple g;
gimple_stmt_iterator gsi;

10
gcc/tree-inline.c
View file

@ -260,7 +260,7 @@ remap_ssa_name (tree name, copy_body_data *id)
&& !DECL_NAME (var)))
{
struct ptr_info_def *pi;
new_tree = make_ssa_name (remap_type (TREE_TYPE (name), id), NULL);
new_tree = make_ssa_name (remap_type (TREE_TYPE (name), id));
if (!var && SSA_NAME_IDENTIFIER (name))
SET_SSA_NAME_VAR_OR_IDENTIFIER (new_tree, SSA_NAME_IDENTIFIER (name));
insert_decl_map (id, name, new_tree);
@ -294,7 +294,7 @@ remap_ssa_name (tree name, copy_body_data *id)
|| !id->transform_return_to_modify))
{
struct ptr_info_def *pi;
new_tree = make_ssa_name (new_tree, NULL);
new_tree = make_ssa_name (new_tree);
insert_decl_map (id, name, new_tree);
SSA_NAME_OCCURS_IN_ABNORMAL_PHI (new_tree)
= SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name);
@ -3189,7 +3189,7 @@ setup_one_parameter (copy_body_data *id, tree p, tree value, tree fn,
}
else if (!optimize)
{
def = make_ssa_name (var, NULL);
def = make_ssa_name (var);
init_stmt = gimple_build_assign (def, rhs);
}
}
@ -3454,7 +3454,7 @@ declare_return_variable (copy_body_data *id, tree return_slot, tree modify_dest,
if (gimple_in_ssa_p (id->src_cfun)
&& is_gimple_reg (result))
{
temp = make_ssa_name (temp, NULL);
temp = make_ssa_name (temp);
insert_decl_map (id, ssa_default_def (id->src_cfun, result), temp);
}
insert_init_stmt (id, entry_bb, gimple_build_assign (temp, var));
@ -5719,7 +5719,7 @@ tree_function_versioning (tree old_decl, tree new_decl,
&& DECL_BY_REFERENCE (DECL_RESULT (old_decl))
&& (old_name = ssa_default_def (id.src_cfun, DECL_RESULT (old_decl))))
{
tree new_name = make_ssa_name (DECL_RESULT (new_decl), NULL);
tree new_name = make_ssa_name (DECL_RESULT (new_decl));
insert_decl_map (&id, old_name, new_name);
SSA_NAME_DEF_STMT (new_name) = gimple_build_nop ();
set_ssa_default_def (cfun, DECL_RESULT (new_decl), new_name);

2
gcc/tree-loop-distribution.c
View file

@ -822,7 +822,7 @@ generate_memset_builtin (struct loop *loop, partition_t partition)
val = fold_convert (integer_type_node, val);
else if (!useless_type_conversion_p (integer_type_node, TREE_TYPE (val)))
{
tree tem = make_ssa_name (integer_type_node, NULL);
tree tem = make_ssa_name (integer_type_node);
gimple cstmt = gimple_build_assign_with_ops (NOP_EXPR, tem, val);
gsi_insert_after (&gsi, cstmt, GSI_CONTINUE_LINKING);
val = tem;

2
gcc/tree-outof-ssa.c
View file

@ -1169,7 +1169,7 @@ insert_backedge_copies (void)
/* Create a new instance of the underlying variable of the
PHI result. */
name = copy_ssa_name (result, NULL);
name = copy_ssa_name (result);
stmt = gimple_build_assign (name,
gimple_phi_arg_def (phi, i));

16
gcc/tree-parloops.c
View file

@ -533,7 +533,7 @@ take_address_of (tree obj, tree type, edge entry,
if (obj_name)
name = make_temp_ssa_name (TREE_TYPE (addr), NULL, obj_name);
else
name = make_ssa_name (TREE_TYPE (addr), NULL);
name = make_ssa_name (TREE_TYPE (addr));
stmt = gimple_build_assign (name, addr);
gsi_insert_on_edge_immediate (entry, stmt);
@ -1057,7 +1057,7 @@ create_phi_for_local_result (reduction_info **slot, struct loop *loop)
e = EDGE_PRED (store_bb, 1);
else
e = EDGE_PRED (store_bb, 0);
local_res = copy_ssa_name (gimple_assign_lhs (reduc->reduc_stmt), NULL);
local_res = copy_ssa_name (gimple_assign_lhs (reduc->reduc_stmt));
locus = gimple_location (reduc->reduc_stmt);
new_phi = create_phi_node (local_res, store_bb);
add_phi_arg (new_phi, reduc->init, e, locus);
@ -1107,8 +1107,8 @@ create_call_for_reduction_1 (reduction_info **slot, struct clsn_data *clsn_data)
e = split_block (bb, t);
new_bb = e->dest;
tmp_load = create_tmp_var (TREE_TYPE (TREE_TYPE (addr)), NULL);
tmp_load = make_ssa_name (tmp_load, NULL);
tmp_load = create_tmp_var (TREE_TYPE (TREE_TYPE (addr)));
tmp_load = make_ssa_name (tmp_load);
load = gimple_build_omp_atomic_load (tmp_load, addr);
SSA_NAME_DEF_STMT (tmp_load) = load;
gsi = gsi_start_bb (new_bb);
@ -1388,7 +1388,7 @@ separate_decls_in_region (edge entry, edge exit,
/* Create the loads and stores. */
*arg_struct = create_tmp_var (type, ".paral_data_store");
nvar = create_tmp_var (build_pointer_type (type), ".paral_data_load");
*new_arg_struct = make_ssa_name (nvar, NULL);
*new_arg_struct = make_ssa_name (nvar);
ld_st_data->store = *arg_struct;
ld_st_data->load = *new_arg_struct;
@ -1406,7 +1406,7 @@ separate_decls_in_region (edge entry, edge exit,
reduction_list
->traverse <struct clsn_data *, create_stores_for_reduction>
(ld_st_data);
clsn_data.load = make_ssa_name (nvar, NULL);
clsn_data.load = make_ssa_name (nvar);
clsn_data.load_bb = exit->dest;
clsn_data.store = ld_st_data->store;
create_final_loads_for_reduction (reduction_list, &clsn_data);
@ -1649,7 +1649,7 @@ create_parallel_loop (struct loop *loop, tree loop_fn, tree data,
gsi = gsi_after_labels (bb);
param = make_ssa_name (DECL_ARGUMENTS (loop_fn), NULL);
param = make_ssa_name (DECL_ARGUMENTS (loop_fn));
assign_stmt = gimple_build_assign (param, build_fold_addr_expr (data));
gsi_insert_before (&gsi, assign_stmt, GSI_SAME_STMT);
@ -1673,7 +1673,7 @@ create_parallel_loop (struct loop *loop, tree loop_fn, tree data,
cvar_base = SSA_NAME_VAR (cvar);
phi = SSA_NAME_DEF_STMT (cvar);
cvar_init = PHI_ARG_DEF_FROM_EDGE (phi, loop_preheader_edge (loop));
initvar = copy_ssa_name (cvar, NULL);
initvar = copy_ssa_name (cvar);
SET_USE (PHI_ARG_DEF_PTR_FROM_EDGE (phi, loop_preheader_edge (loop)),
initvar);
cvar_next = PHI_ARG_DEF_FROM_EDGE (phi, loop_latch_edge (loop));

10
gcc/tree-predcom.c
View file

@ -1491,7 +1491,7 @@ initialize_root_vars (struct loop *loop, chain_p chain, bitmap tmp_vars)
chain->vars.quick_push (chain->vars[0]);
FOR_EACH_VEC_ELT (chain->vars, i, var)
chain->vars[i] = make_ssa_name (var, NULL);
chain->vars[i] = make_ssa_name (var);
for (i = 0; i < n; i++)
{
@ -1555,7 +1555,7 @@ initialize_root_vars_lm (struct loop *loop, dref root, bool written,
vars->quick_push ((*vars)[0]);
FOR_EACH_VEC_ELT (*vars, i, var)
(*vars)[i] = make_ssa_name (var, NULL);
(*vars)[i] = make_ssa_name (var);
var = (*vars)[0];
@ -1613,7 +1613,7 @@ execute_load_motion (struct loop *loop, chain_p chain, bitmap tmp_vars)
if (n_writes)
{
var = vars[0];
var = make_ssa_name (SSA_NAME_VAR (var), NULL);
var = make_ssa_name (SSA_NAME_VAR (var));
vars[0] = var;
}
else
@ -2191,11 +2191,11 @@ reassociate_to_the_same_stmt (tree name1, tree name2)
/* Insert the new statement combining NAME1 and NAME2 before S1, and
combine it with the rhs of S1. */
var = create_tmp_reg (type, "predreastmp");
new_name = make_ssa_name (var, NULL);
new_name = make_ssa_name (var);
new_stmt = gimple_build_assign_with_ops (code, new_name, name1, name2);
var = create_tmp_reg (type, "predreastmp");
tmp_name = make_ssa_name (var, NULL);
tmp_name = make_ssa_name (var);
/* Rhs of S1 may now be either a binary expression with operation
CODE, or gimple_val (in case that stmt1 == s1 or stmt2 == s1,

4
gcc/tree-sra.c
View file

@ -1548,7 +1548,7 @@ build_ref_for_offset (location_t loc, tree base, HOST_WIDE_INT offset,
tree tmp, addr;
gcc_checking_assert (gsi);
tmp = make_ssa_name (build_pointer_type (TREE_TYPE (prev_base)), NULL);
tmp = make_ssa_name (build_pointer_type (TREE_TYPE (prev_base)));
addr = build_fold_addr_expr (unshare_expr (prev_base));
STRIP_USELESS_TYPE_CONVERSION (addr);
stmt = gimple_build_assign (tmp, addr);
@ -1990,7 +1990,7 @@ create_access_replacement (struct access *access)
if (access->grp_to_be_debug_replaced)
{
repl = create_tmp_var_raw (access->type, NULL);
repl = create_tmp_var_raw (access->type);
DECL_CONTEXT (repl) = current_function_decl;
}
else

2
gcc/tree-ssa-ccp.c
View file

@ -2065,7 +2065,7 @@ fold_builtin_alloca_with_align (gimple stmt)
elem_type = build_nonstandard_integer_type (BITS_PER_UNIT, 1);
n_elem = size * 8 / BITS_PER_UNIT;
array_type = build_array_type_nelts (elem_type, n_elem);
var = create_tmp_var (array_type, NULL);
var = create_tmp_var (array_type);
DECL_ALIGN (var) = TREE_INT_CST_LOW (gimple_call_arg (stmt, 1));
{
struct ptr_info_def *pi = SSA_NAME_PTR_INFO (lhs);

6
gcc/tree-ssa-forwprop.c
View file

@ -1723,14 +1723,14 @@ simplify_rotate (gimple_stmt_iterator *gsi)
TREE_TYPE (rotcnt)))
{
g = gimple_build_assign_with_ops (NOP_EXPR,
make_ssa_name (TREE_TYPE (def_arg2[0]),
NULL), rotcnt);
make_ssa_name (TREE_TYPE (def_arg2[0])),
rotcnt);
gsi_insert_before (gsi, g, GSI_SAME_STMT);
rotcnt = gimple_assign_lhs (g);
}
lhs = gimple_assign_lhs (stmt);
if (!useless_type_conversion_p (rtype, TREE_TYPE (def_arg1[0])))
lhs = make_ssa_name (TREE_TYPE (def_arg1[0]), NULL);
lhs = make_ssa_name (TREE_TYPE (def_arg1[0]));
g = gimple_build_assign_with_ops (((def_code[0] == LSHIFT_EXPR) ^ swapped_p)
? LROTATE_EXPR : RROTATE_EXPR,
lhs, def_arg1[0], rotcnt);

8
gcc/tree-ssa-loop-manip.c
View file

@ -92,8 +92,8 @@ create_iv (tree base, tree step, tree var, struct loop *loop,
if (var != NULL_TREE)
{
vb = make_ssa_name (var, NULL);
va = make_ssa_name (var, NULL);
vb = make_ssa_name (var);
va = make_ssa_name (var);
}
else
{
@ -1158,11 +1158,11 @@ tree_transform_and_unroll_loop (struct loop *loop, unsigned factor,
if (TREE_CODE (next) == SSA_NAME
&& useless_type_conversion_p (TREE_TYPE (next),
TREE_TYPE (init)))
new_init = copy_ssa_name (next, NULL);
new_init = copy_ssa_name (next);
else if (TREE_CODE (init) == SSA_NAME
&& useless_type_conversion_p (TREE_TYPE (init),
TREE_TYPE (next)))
new_init = copy_ssa_name (init, NULL);
new_init = copy_ssa_name (init);
else if (useless_type_conversion_p (TREE_TYPE (next), TREE_TYPE (init)))
new_init = make_temp_ssa_name (TREE_TYPE (next), NULL, "unrinittmp");
else

2
gcc/tree-ssa-math-opts.c
View file

@ -1129,7 +1129,7 @@ static tree
build_and_insert_cast (gimple_stmt_iterator *gsi, location_t loc,
tree type, tree val)
{
tree result = make_ssa_name (type, NULL);
tree result = make_ssa_name (type);
gassign *stmt = gimple_build_assign_with_ops (NOP_EXPR, result, val);
gimple_set_location (stmt, loc);
gsi_insert_before (gsi, stmt, GSI_SAME_STMT);

16
gcc/tree-ssa-phiopt.c
View file

@ -536,7 +536,7 @@ conditional_replacement (basic_block cond_bb, basic_block middle_bb,
{
source_location locus_0, locus_1;
new_var2 = make_ssa_name (TREE_TYPE (result), NULL);
new_var2 = make_ssa_name (TREE_TYPE (result));
new_stmt = gimple_build_assign_with_ops (CONVERT_EXPR, new_var2,
new_var);
gsi_insert_before (&gsi, new_stmt, GSI_SAME_STMT);
@ -1253,7 +1253,7 @@ abs_replacement (basic_block cond_bb, basic_block middle_bb,
result = duplicate_ssa_name (result, NULL);
if (negate)
lhs = make_ssa_name (TREE_TYPE (result), NULL);
lhs = make_ssa_name (TREE_TYPE (result));
else
lhs = result;
@ -1370,7 +1370,7 @@ neg_replacement (basic_block cond_bb, basic_block middle_bb,
}
}
tree cond_val = make_ssa_name (boolean_type_node, NULL);
tree cond_val = make_ssa_name (boolean_type_node);
new_stmt = gimple_build_assign_with_ops (cond_code, cond_val,
gimple_cond_lhs (cond),
gimple_cond_rhs (cond));
@ -1381,7 +1381,7 @@ neg_replacement (basic_block cond_bb, basic_block middle_bb,
condition. */
if (invert)
{
tree tmp = make_ssa_name (boolean_type_node, NULL);
tree tmp = make_ssa_name (boolean_type_node);
new_stmt = gimple_build_assign_with_ops (BIT_XOR_EXPR, tmp,
cond_val, boolean_true_node);
gsi_insert_after (&gsi, new_stmt, GSI_NEW_STMT);
@ -1390,22 +1390,22 @@ neg_replacement (basic_block cond_bb, basic_block middle_bb,
/* Get the condition in the right type so that we can perform
logical and arithmetic operations on it. */
tree cond_val_converted = make_ssa_name (TREE_TYPE (rhs), NULL);
tree cond_val_converted = make_ssa_name (TREE_TYPE (rhs));
new_stmt = gimple_build_assign_with_ops (NOP_EXPR, cond_val_converted,
cond_val);
gsi_insert_after (&gsi, new_stmt, GSI_NEW_STMT);
tree neg_cond_val_converted = make_ssa_name (TREE_TYPE (rhs), NULL);
tree neg_cond_val_converted = make_ssa_name (TREE_TYPE (rhs));
new_stmt = gimple_build_assign_with_ops (NEGATE_EXPR, neg_cond_val_converted,
cond_val_converted);
gsi_insert_after (&gsi, new_stmt, GSI_NEW_STMT);
tree tmp = make_ssa_name (TREE_TYPE (rhs), NULL);
tree tmp = make_ssa_name (TREE_TYPE (rhs));
new_stmt = gimple_build_assign_with_ops (BIT_XOR_EXPR, tmp,
rhs, neg_cond_val_converted);
gsi_insert_after (&gsi, new_stmt, GSI_NEW_STMT);
tree new_lhs = make_ssa_name (TREE_TYPE (rhs), NULL);
tree new_lhs = make_ssa_name (TREE_TYPE (rhs));
new_stmt = gimple_build_assign_with_ops (PLUS_EXPR, new_lhs,
tmp, cond_val_converted);
gsi_insert_after (&gsi, new_stmt, GSI_NEW_STMT);

2
gcc/tree-ssa-phiprop.c
View file

@ -208,7 +208,7 @@ phiprop_insert_phi (basic_block bb, gphi *phi, gimple use_stmt,
{
tree rhs = gimple_assign_rhs1 (use_stmt);
gcc_assert (TREE_CODE (old_arg) == ADDR_EXPR);
new_var = make_ssa_name (TREE_TYPE (rhs), NULL);
new_var = make_ssa_name (TREE_TYPE (rhs));
if (!is_gimple_min_invariant (old_arg))
old_arg = PHI_ARG_DEF_FROM_EDGE (phi, e);
else

4
gcc/tree-ssa-propagate.c
View file

@ -835,9 +835,9 @@ update_call_from_tree (gimple_stmt_iterator *si_p, tree expr)
with a dummy (unused) lhs variable. */
STRIP_USELESS_TYPE_CONVERSION (expr);
if (gimple_in_ssa_p (cfun))
lhs = make_ssa_name (TREE_TYPE (expr), NULL);
lhs = make_ssa_name (TREE_TYPE (expr));
else
lhs = create_tmp_var (TREE_TYPE (expr), NULL);
lhs = create_tmp_var (TREE_TYPE (expr));
new_stmt = gimple_build_assign (lhs, expr);
gimple_set_vuse (new_stmt, gimple_vuse (stmt));
gimple_set_vdef (new_stmt, gimple_vdef (stmt));

20
gcc/tree-ssa-reassoc.c
View file

@ -1341,7 +1341,7 @@ build_and_add_sum (tree type, tree op1, tree op2, enum tree_code opcode)
gassign *sum;
/* Create the addition statement. */
op = make_ssa_name (type, NULL);
op = make_ssa_name (type);
sum = gimple_build_assign_with_ops (opcode, op, op1, op2);
/* Find an insertion place and insert. */
@ -2594,8 +2594,7 @@ optimize_range_tests_to_bit_test (enum tree_code opcode, int first, int length,
gimple_set_visited (SSA_NAME_DEF_STMT (exp), true);
gimple g
= gimple_build_assign_with_ops (BIT_IOR_EXPR,
make_ssa_name (optype, NULL),
tem, exp);
make_ssa_name (optype), tem, exp);
gimple_set_location (g, loc);
gimple_seq_add_stmt_without_update (&seq, g);
exp = gimple_assign_lhs (g);
@ -2999,7 +2998,7 @@ update_ops (tree var, enum tree_code code, vec<operand_entry_t> ops,
&& (rhs[2] != rhs[1] || rhs[3] != rhs[0]))
{
gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
var = make_ssa_name (TREE_TYPE (var), NULL);
var = make_ssa_name (TREE_TYPE (var));
gassign *g = gimple_build_assign_with_ops (gimple_assign_rhs_code (stmt),
var, rhs[2], rhs[3]);
gimple_set_uid (g, gimple_uid (stmt));
@ -3296,7 +3295,7 @@ maybe_optimize_range_tests (gimple stmt)
{
gcc_assert (bb == last_bb);
tree lhs = gimple_assign_lhs (cast_stmt);
tree new_lhs = make_ssa_name (TREE_TYPE (lhs), NULL);
tree new_lhs = make_ssa_name (TREE_TYPE (lhs));
enum tree_code rhs_code
= gimple_assign_rhs_code (cast_stmt);
gassign *g;
@ -3518,7 +3517,7 @@ rewrite_expr_tree (gimple stmt, unsigned int opindex,
if (changed)
{
gimple insert_point = find_insert_point (stmt, oe1->op, oe2->op);
lhs = make_ssa_name (TREE_TYPE (lhs), NULL);
lhs = make_ssa_name (TREE_TYPE (lhs));
stmt
= gimple_build_assign_with_ops (gimple_assign_rhs_code (stmt),
lhs, oe1->op, oe2->op);
@ -3583,7 +3582,7 @@ rewrite_expr_tree (gimple stmt, unsigned int opindex,
unsigned int uid = gimple_uid (stmt);
gimple insert_point = find_insert_point (stmt, new_rhs1, oe->op);
lhs = make_ssa_name (TREE_TYPE (lhs), NULL);
lhs = make_ssa_name (TREE_TYPE (lhs));
stmt = gimple_build_assign_with_ops (gimple_assign_rhs_code (stmt),
lhs, new_rhs1, oe->op);
gimple_set_uid (stmt, uid);
@ -3802,7 +3801,7 @@ linearize_expr (gimple stmt)
gimple_assign_set_rhs2 (stmt, gimple_assign_rhs1 (binrhs));
binrhs = gimple_build_assign_with_ops (gimple_assign_rhs_code (binrhs),
make_ssa_name (TREE_TYPE (lhs), NULL),
make_ssa_name (TREE_TYPE (lhs)),
gimple_assign_lhs (binlhs),
gimple_assign_rhs2 (binrhs));
gimple_assign_set_rhs1 (stmt, gimple_assign_lhs (binrhs));
@ -3890,7 +3889,7 @@ negate_value (tree tonegate, gimple_stmt_iterator *gsip)
rhs2 = negate_value (rhs2, &gsi);
gsi = gsi_for_stmt (negatedefstmt);
lhs = make_ssa_name (TREE_TYPE (lhs), NULL);
lhs = make_ssa_name (TREE_TYPE (lhs));
gimple_set_visited (negatedefstmt, true);
g = gimple_build_assign_with_ops (PLUS_EXPR, lhs, rhs1, rhs2);
gimple_set_uid (g, gimple_uid (negatedefstmt));
@ -4217,8 +4216,7 @@ repropagate_negates (void)
tree b = gimple_assign_rhs2 (user);
gimple_stmt_iterator gsi = gsi_for_stmt (feed);
gimple_stmt_iterator gsi2 = gsi_for_stmt (user);
tree x = make_ssa_name (TREE_TYPE (gimple_assign_lhs (feed)),
NULL);
tree x = make_ssa_name (TREE_TYPE (gimple_assign_lhs (feed)));
gimple g = gimple_build_assign_with_ops (PLUS_EXPR, x, a, b);
gsi_insert_before (&gsi2, g, GSI_SAME_STMT);
gimple_assign_set_rhs_with_ops (&gsi2, NEGATE_EXPR, x);

2
gcc/tree-ssa-strlen.c
View file

@ -468,7 +468,7 @@ get_string_length (strinfo si)
lenstmt
= gimple_build_assign_with_ops
(POINTER_PLUS_EXPR,
make_ssa_name (TREE_TYPE (gimple_call_arg (stmt, 0)), NULL),
make_ssa_name (TREE_TYPE (gimple_call_arg (stmt, 0))),
tem, lhs);
gsi_insert_before (&gsi, lenstmt, GSI_SAME_STMT);
gimple_call_set_arg (stmt, 0, gimple_assign_lhs (lenstmt));

4
gcc/tree-ssanames.h
View file

@ -102,7 +102,7 @@ extern void replace_ssa_name_symbol (tree, tree);
in function cfun. */
static inline tree
make_ssa_name (tree var, gimple stmt)
make_ssa_name (tree var, gimple stmt = NULL)
{
return make_ssa_name_fn (cfun, var, stmt);
}
@ -111,7 +111,7 @@ make_ssa_name (tree var, gimple stmt)
statement STMT in function cfun. */
static inline tree
copy_ssa_name (tree var, gimple stmt)
copy_ssa_name (tree var, gimple stmt = NULL)
{
return copy_ssa_name_fn (cfun, var, stmt);
}

8
gcc/tree-switch-conversion.c
View file

@ -444,7 +444,7 @@ emit_case_bit_tests (gswitch *swtch, tree index_expr,
}
/* csui = (1 << (word_mode) idx) */
csui = make_ssa_name (word_type_node, NULL);
csui = make_ssa_name (word_type_node);
tmp = fold_build2 (LSHIFT_EXPR, word_type_node, word_mode_one,
fold_convert (word_type_node, idx));
tmp = force_gimple_operand_gsi (&gsi, tmp,
@ -1047,7 +1047,7 @@ build_one_array (gswitch *swtch, int num, tree arr_index_type,
gcc_assert (info->default_values[num]);
name = copy_ssa_name (PHI_RESULT (phi), NULL);
name = copy_ssa_name (PHI_RESULT (phi));
info->target_inbound_names[num] = name;
cst = constructor_contains_same_values_p (info->constructors[num]);
@ -1123,7 +1123,7 @@ build_arrays (gswitch *swtch, struct switch_conv_info *info)
utype = lang_hooks.types.type_for_mode (TYPE_MODE (utype), 1);
arr_index_type = build_index_type (info->range_size);
tidx = make_ssa_name (utype, NULL);
tidx = make_ssa_name (utype);
sub = fold_build2_loc (loc, MINUS_EXPR, utype,
fold_convert_loc (loc, utype, info->index_expr),
fold_convert_loc (loc, utype, info->range_min));
@ -1151,7 +1151,7 @@ gen_def_assigns (gimple_stmt_iterator *gsi, struct switch_conv_info *info)
for (i = 0; i < info->phi_count; i++)
{
tree name = copy_ssa_name (info->target_inbound_names[i], NULL);
tree name = copy_ssa_name (info->target_inbound_names[i]);
info->target_outbound_names[i] = name;
assign = gimple_build_assign (name, info->default_values[i]);
gsi_insert_before (gsi, assign, GSI_SAME_STMT);

2
gcc/tree-tailcall.c
View file

@ -694,7 +694,7 @@ update_accumulator_with_ops (enum tree_code code, tree acc, tree op1,
gimple_stmt_iterator gsi)
{
gassign *stmt;
tree var = copy_ssa_name (acc, NULL);
tree var = copy_ssa_name (acc);
if (types_compatible_p (TREE_TYPE (acc), TREE_TYPE (op1)))
stmt = gimple_build_assign_with_ops (code, var, acc, op1);
else

6
gcc/tree-vect-data-refs.c
View file

@ -4347,7 +4347,7 @@ bump_vector_ptr (tree dataref_ptr, gimple ptr_incr, gimple_stmt_iterator *gsi,
if (bump)
update = bump;
new_dataref_ptr = copy_ssa_name (dataref_ptr, NULL);
new_dataref_ptr = copy_ssa_name (dataref_ptr);
incr_stmt = gimple_build_assign_with_ops (POINTER_PLUS_EXPR, new_dataref_ptr,
dataref_ptr, update);
vect_finish_stmt_generation (stmt, incr_stmt, gsi);
@ -4879,7 +4879,7 @@ vect_setup_realignment (gimple stmt, gimple_stmt_iterator *gsi,
ptr = vect_create_data_ref_ptr (stmt, vectype, loop_for_initial_load,
NULL_TREE, &init_addr, NULL, &inc,
true, &inv_p);
new_temp = copy_ssa_name (ptr, NULL);
new_temp = copy_ssa_name (ptr);
new_stmt = gimple_build_assign_with_ops
(BIT_AND_EXPR, new_temp, ptr,
build_int_cst (TREE_TYPE (ptr),
@ -4967,7 +4967,7 @@ vect_setup_realignment (gimple stmt, gimple_stmt_iterator *gsi,
pe = loop_preheader_edge (containing_loop);
vec_dest = vect_create_destination_var (scalar_dest, vectype);
msq = make_ssa_name (vec_dest, NULL);
msq = make_ssa_name (vec_dest);
phi_stmt = create_phi_node (msq, containing_loop->header);
add_phi_arg (phi_stmt, msq_init, pe, UNKNOWN_LOCATION);

4
gcc/tree-vect-generic.c
View file

@ -639,7 +639,7 @@ expand_vector_divmod (gimple_stmt_iterator *gsi, tree type, tree op0,
((unsigned HOST_WIDE_INT) 1
<< shifts[i]) - 1);
cst = build_vector (type, vec);
addend = make_ssa_name (type, NULL);
addend = make_ssa_name (type);
stmt = gimple_build_assign_with_ops (VEC_COND_EXPR, addend,
cond, cst, zero);
gsi_insert_before (gsi, stmt, GSI_SAME_STMT);
@ -1080,7 +1080,7 @@ optimize_vector_constructor (gimple_stmt_iterator *gsi)
}
for (i = 0; i < nelts; i++)
CONSTRUCTOR_ELT (rhs, i)->value = base;
g = gimple_build_assign (make_ssa_name (type, NULL), rhs);
g = gimple_build_assign (make_ssa_name (type), rhs);
gsi_insert_before (gsi, g, GSI_SAME_STMT);
g = gimple_build_assign_with_ops (PLUS_EXPR, lhs, gimple_assign_lhs (g),
build_vector (type, cst));

14
gcc/tree-vect-loop-manip.c
View file

@ -432,7 +432,7 @@ slpeel_update_phi_nodes_for_guard1 (edge guard_edge, struct loop *loop,
/** 1. Handle new-merge-point phis **/
/* 1.1. Generate new phi node in NEW_MERGE_BB: */
new_res = copy_ssa_name (PHI_RESULT (orig_phi), NULL);
new_res = copy_ssa_name (PHI_RESULT (orig_phi));
new_phi = create_phi_node (new_res, new_merge_bb);
/* 1.2. NEW_MERGE_BB has two incoming edges: GUARD_EDGE and the exit-edge
@ -462,7 +462,7 @@ slpeel_update_phi_nodes_for_guard1 (edge guard_edge, struct loop *loop,
continue;
/* 2.1. Generate new phi node in NEW_EXIT_BB: */
new_res = copy_ssa_name (PHI_RESULT (orig_phi), NULL);
new_res = copy_ssa_name (PHI_RESULT (orig_phi));
new_phi = create_phi_node (new_res, *new_exit_bb);
/* 2.2. NEW_EXIT_BB has one incoming edge: the exit-edge of the loop. */
@ -576,7 +576,7 @@ slpeel_update_phi_nodes_for_guard2 (edge guard_edge, struct loop *loop,
/** 1. Handle new-merge-point phis **/
/* 1.1. Generate new phi node in NEW_MERGE_BB: */
new_res = copy_ssa_name (PHI_RESULT (orig_phi), NULL);
new_res = copy_ssa_name (PHI_RESULT (orig_phi));
new_phi = create_phi_node (new_res, new_merge_bb);
/* 1.2. NEW_MERGE_BB has two incoming edges: GUARD_EDGE and the exit-edge
@ -618,7 +618,7 @@ slpeel_update_phi_nodes_for_guard2 (edge guard_edge, struct loop *loop,
/** 2. Handle loop-closed-ssa-form phis **/
/* 2.1. Generate new phi node in NEW_EXIT_BB: */
new_res = copy_ssa_name (PHI_RESULT (orig_phi), NULL);
new_res = copy_ssa_name (PHI_RESULT (orig_phi));
new_phi = create_phi_node (new_res, *new_exit_bb);
/* 2.2. NEW_EXIT_BB has one incoming edge: the exit-edge of the loop. */
@ -653,7 +653,7 @@ slpeel_update_phi_nodes_for_guard2 (edge guard_edge, struct loop *loop,
arg = guard_arg;
/* 3.2. Generate new phi node in GUARD_BB: */
new_res = copy_ssa_name (PHI_RESULT (orig_phi), NULL);
new_res = copy_ssa_name (PHI_RESULT (orig_phi));
new_phi = create_phi_node (new_res, guard_edge->src);
/* 3.3. GUARD_BB has one incoming edge: */
@ -1224,7 +1224,7 @@ slpeel_tree_peel_loop_to_edge (struct loop *loop, struct loop *scalar_loop,
break;
if (gsi_end_p (gsi))
{
tree new_vop = copy_ssa_name (PHI_RESULT (phi), NULL);
tree new_vop = copy_ssa_name (PHI_RESULT (phi));
gphi *new_phi = create_phi_node (new_vop, exit_e->dest);
tree vop = PHI_ARG_DEF_FROM_EDGE (phi, EDGE_SUCC (loop->latch, 0));
imm_use_iterator imm_iter;
@ -2439,7 +2439,7 @@ vect_loop_versioning (loop_vec_info loop_vinfo,
{
tree new_res;
orig_phi = gsi.phi ();
new_res = copy_ssa_name (PHI_RESULT (orig_phi), NULL);
new_res = copy_ssa_name (PHI_RESULT (orig_phi));
new_phi = create_phi_node (new_res, new_exit_bb);
arg = PHI_ARG_DEF_FROM_EDGE (orig_phi, e);
add_phi_arg (new_phi, arg, new_exit_e,

8
gcc/tree-vect-loop.c
View file

@ -2502,7 +2502,7 @@ vect_is_simple_reduction_1 (loop_vec_info loop_info, gimple phi,
if (orig_code == MINUS_EXPR)
{
tree rhs = gimple_assign_rhs2 (def_stmt);
tree negrhs = make_ssa_name (TREE_TYPE (rhs), NULL);
tree negrhs = make_ssa_name (TREE_TYPE (rhs));
gimple negate_stmt = gimple_build_assign_with_ops (NEGATE_EXPR, negrhs,
rhs);
gimple_stmt_iterator gsi = gsi_for_stmt (def_stmt);
@ -4074,7 +4074,7 @@ vect_create_epilog_for_reduction (vec<tree> vect_defs, gimple stmt,
{
for (j = 0; j < ncopies; j++)
{
tree new_def = copy_ssa_name (def, NULL);
tree new_def = copy_ssa_name (def);
phi = create_phi_node (new_def, exit_bb);
set_vinfo_for_stmt (phi, new_stmt_vec_info (phi, loop_vinfo, NULL));
if (j == 0)
@ -4099,7 +4099,7 @@ vect_create_epilog_for_reduction (vec<tree> vect_defs, gimple stmt,
inner_phis.create (vect_defs.length ());
FOR_EACH_VEC_ELT (new_phis, i, phi)
{
tree new_result = copy_ssa_name (PHI_RESULT (phi), NULL);
tree new_result = copy_ssa_name (PHI_RESULT (phi));
gphi *outer_phi = create_phi_node (new_result, exit_bb);
SET_PHI_ARG_DEF (outer_phi, single_exit (loop)->dest_idx,
PHI_RESULT (phi));
@ -4111,7 +4111,7 @@ vect_create_epilog_for_reduction (vec<tree> vect_defs, gimple stmt,
while (STMT_VINFO_RELATED_STMT (vinfo_for_stmt (phi)))
{
phi = STMT_VINFO_RELATED_STMT (vinfo_for_stmt (phi));
new_result = copy_ssa_name (PHI_RESULT (phi), NULL);
new_result = copy_ssa_name (PHI_RESULT (phi));
outer_phi = create_phi_node (new_result, exit_bb);
SET_PHI_ARG_DEF (outer_phi, single_exit (loop)->dest_idx,
PHI_RESULT (phi));

10
gcc/tree-vect-patterns.c
View file

@ -759,7 +759,7 @@ vect_handle_widen_op_by_const (gimple stmt, enum tree_code code,
{
/* Create a_T = (NEW_TYPE) a_t; */
*oprnd = gimple_assign_rhs1 (def_stmt);
new_oprnd = make_ssa_name (new_type, NULL);
new_oprnd = make_ssa_name (new_type);
new_stmt = gimple_build_assign_with_ops (NOP_EXPR, new_oprnd, *oprnd);
STMT_VINFO_RELATED_STMT (vinfo_for_stmt (def_stmt)) = new_stmt;
stmts->safe_push (def_stmt);
@ -932,7 +932,7 @@ vect_recog_widen_mult_pattern (vec<gimple> *stmts,
}
tree old_oprnd = gimple_assign_rhs1 (def_stmt);
tree new_oprnd = make_ssa_name (half_type0, NULL);
tree new_oprnd = make_ssa_name (half_type0);
new_stmt = gimple_build_assign_with_ops (NOP_EXPR, new_oprnd,
old_oprnd);
*oprnd = new_oprnd;
@ -1439,7 +1439,7 @@ vect_operation_fits_smaller_type (gimple stmt, tree def, tree *new_type,
{
/* Create NEW_OPRND = (INTERM_TYPE) OPRND. */
oprnd = gimple_assign_rhs1 (def_stmt);
new_oprnd = make_ssa_name (interm_type, NULL);
new_oprnd = make_ssa_name (interm_type);
new_stmt = gimple_build_assign_with_ops (NOP_EXPR, new_oprnd,
oprnd);
STMT_VINFO_RELATED_STMT (vinfo_for_stmt (def_stmt)) = new_stmt;
@ -1458,7 +1458,7 @@ vect_operation_fits_smaller_type (gimple stmt, tree def, tree *new_type,
if (interm_type)
{
/* Create a type conversion HALF_TYPE->INTERM_TYPE. */
new_oprnd = make_ssa_name (interm_type, NULL);
new_oprnd = make_ssa_name (interm_type);
new_stmt = gimple_build_assign_with_ops (NOP_EXPR, new_oprnd,
oprnd);
oprnd = new_oprnd;
@ -1590,7 +1590,7 @@ vect_recog_over_widening_pattern (vec<gimple> *stmts,
|| TYPE_PRECISION (new_type) != TYPE_PRECISION (use_type))
{
/* Create NEW_TYPE->USE_TYPE conversion. */
new_oprnd = make_ssa_name (use_type, NULL);
new_oprnd = make_ssa_name (use_type);
pattern_stmt = gimple_build_assign_with_ops (NOP_EXPR, new_oprnd,
var);
STMT_VINFO_RELATED_STMT (vinfo_for_stmt (use_stmt)) = pattern_stmt;

3
gcc/tree-vect-slp.c
View file

@ -2669,8 +2669,7 @@ vect_get_constant_vectors (tree op, slp_tree slp_node,
}
else
{
tree new_temp
= make_ssa_name (TREE_TYPE (vector_type), NULL);
tree new_temp = make_ssa_name (TREE_TYPE (vector_type));
gimple init_stmt;
op = build1 (VIEW_CONVERT_EXPR, TREE_TYPE (vector_type),
op);

54
gcc/tree-vect-stmts.c
View file

@ -1331,7 +1331,7 @@ vect_init_vector (gimple stmt, tree val, tree type, gimple_stmt_iterator *gsi)
val = fold_unary (VIEW_CONVERT_EXPR, TREE_TYPE (type), val);
else
{
new_temp = make_ssa_name (TREE_TYPE (type), NULL);
new_temp = make_ssa_name (TREE_TYPE (type));
init_stmt = gimple_build_assign_with_ops (NOP_EXPR,
new_temp, val);
vect_init_vector_1 (stmt, init_stmt, gsi);
@ -1966,7 +1966,7 @@ vectorizable_mask_load_store (gimple stmt, gimple_stmt_iterator *gsi,
gcc_assert (TYPE_VECTOR_SUBPARTS (TREE_TYPE (op))
== TYPE_VECTOR_SUBPARTS (idxtype));
var = vect_get_new_vect_var (idxtype, vect_simple_var, NULL);
var = make_ssa_name (var, NULL);
var = make_ssa_name (var);
op = build1 (VIEW_CONVERT_EXPR, idxtype, op);
new_stmt
= gimple_build_assign_with_ops (VIEW_CONVERT_EXPR, var, op);
@ -1995,7 +1995,7 @@ vectorizable_mask_load_store (gimple stmt, gimple_stmt_iterator *gsi,
== TYPE_VECTOR_SUBPARTS (masktype));
var = vect_get_new_vect_var (masktype, vect_simple_var,
NULL);
var = make_ssa_name (var, NULL);
var = make_ssa_name (var);
mask_op = build1 (VIEW_CONVERT_EXPR, masktype, mask_op);
new_stmt
= gimple_build_assign_with_ops (VIEW_CONVERT_EXPR, var,
@ -2017,7 +2017,7 @@ vectorizable_mask_load_store (gimple stmt, gimple_stmt_iterator *gsi,
op = make_ssa_name (var, new_stmt);
gimple_call_set_lhs (new_stmt, op);
vect_finish_stmt_generation (stmt, new_stmt, gsi);
var = make_ssa_name (vec_dest, NULL);
var = make_ssa_name (vec_dest);
op = build1 (VIEW_CONVERT_EXPR, vectype, op);
new_stmt
= gimple_build_assign_with_ops (VIEW_CONVERT_EXPR, var, op);
@ -2158,7 +2158,7 @@ vectorizable_mask_load_store (gimple stmt, gimple_stmt_iterator *gsi,
= gimple_build_call_internal (IFN_MASK_LOAD, 3, dataref_ptr,
gimple_call_arg (stmt, 1),
vec_mask);
gimple_call_set_lhs (new_stmt, make_ssa_name (vec_dest, NULL));
gimple_call_set_lhs (new_stmt, make_ssa_name (vec_dest));
vect_finish_stmt_generation (stmt, new_stmt, gsi);
if (i == 0)
STMT_VINFO_VEC_STMT (stmt_info) = *vec_stmt = new_stmt;
@ -2467,7 +2467,7 @@ vectorizable_call (gimple gs, gimple_stmt_iterator *gsi, gimple *vec_stmt,
new_temp = make_ssa_name (new_var, init_stmt);
gimple_assign_set_lhs (init_stmt, new_temp);
vect_init_vector_1 (stmt, init_stmt, NULL);
new_temp = make_ssa_name (vec_dest, NULL);
new_temp = make_ssa_name (vec_dest);
new_stmt = gimple_build_assign (new_temp,
gimple_assign_lhs (init_stmt));
}
@ -2971,7 +2971,7 @@ vectorizable_simd_clone_call (gimple stmt, gimple_stmt_iterator *gsi,
size_int (prec),
bitsize_int ((m & (k - 1)) * prec));
new_stmt
= gimple_build_assign (make_ssa_name (atype, NULL),
= gimple_build_assign (make_ssa_name (atype),
vec_oprnd0);
vect_finish_stmt_generation (stmt, new_stmt, gsi);
vargs.safe_push (gimple_assign_lhs (new_stmt));
@ -3007,7 +3007,7 @@ vectorizable_simd_clone_call (gimple stmt, gimple_stmt_iterator *gsi,
{
vec_oprnd0 = build_constructor (atype, ctor_elts);
new_stmt
= gimple_build_assign (make_ssa_name (atype, NULL),
= gimple_build_assign (make_ssa_name (atype),
vec_oprnd0);
vect_finish_stmt_generation (stmt, new_stmt, gsi);
vargs.safe_push (gimple_assign_lhs (new_stmt));
@ -3032,7 +3032,7 @@ vectorizable_simd_clone_call (gimple stmt, gimple_stmt_iterator *gsi,
new_bb = gsi_insert_seq_on_edge_immediate (pe, stmts);
gcc_assert (!new_bb);
}
tree phi_res = copy_ssa_name (op, NULL);
tree phi_res = copy_ssa_name (op);
gphi *new_phi = create_phi_node (phi_res, loop->header);
set_vinfo_for_stmt (new_phi,
new_stmt_vec_info (new_phi, loop_vinfo,
@ -3048,7 +3048,7 @@ vectorizable_simd_clone_call (gimple stmt, gimple_stmt_iterator *gsi,
= wi::mul (bestn->simdclone->args[i].linear_step,
ncopies * nunits);
tree tcst = wide_int_to_tree (type, cst);
tree phi_arg = copy_ssa_name (op, NULL);
tree phi_arg = copy_ssa_name (op);
new_stmt = gimple_build_assign_with_ops (code, phi_arg,
phi_res, tcst);
gimple_stmt_iterator si = gsi_after_labels (loop->header);
@ -3072,7 +3072,7 @@ vectorizable_simd_clone_call (gimple stmt, gimple_stmt_iterator *gsi,
= wi::mul (bestn->simdclone->args[i].linear_step,
j * nunits);
tree tcst = wide_int_to_tree (type, cst);
new_temp = make_ssa_name (TREE_TYPE (op), NULL);
new_temp = make_ssa_name (TREE_TYPE (op));
new_stmt
= gimple_build_assign_with_ops (code, new_temp,
arginfo[i].op, tcst);
@ -3091,7 +3091,7 @@ vectorizable_simd_clone_call (gimple stmt, gimple_stmt_iterator *gsi,
{
gcc_assert (ratype || TYPE_VECTOR_SUBPARTS (rtype) == nunits);
if (ratype)
new_temp = create_tmp_var (ratype, NULL);
new_temp = create_tmp_var (ratype);
else if (TYPE_VECTOR_SUBPARTS (vectype)
== TYPE_VECTOR_SUBPARTS (rtype))
new_temp = make_ssa_name (vec_dest, new_stmt);
@ -3123,7 +3123,7 @@ vectorizable_simd_clone_call (gimple stmt, gimple_stmt_iterator *gsi,
t = build3 (BIT_FIELD_REF, vectype, new_temp,
size_int (prec), bitsize_int (l * prec));
new_stmt
= gimple_build_assign (make_ssa_name (vectype, NULL), t);
= gimple_build_assign (make_ssa_name (vectype), t);
vect_finish_stmt_generation (stmt, new_stmt, gsi);
if (j == 0 && l == 0)
STMT_VINFO_VEC_STMT (stmt_info) = *vec_stmt = new_stmt;
@ -3157,8 +3157,7 @@ vectorizable_simd_clone_call (gimple stmt, gimple_stmt_iterator *gsi,
tree tem = build4 (ARRAY_REF, rtype, new_temp,
size_int (m), NULL_TREE, NULL_TREE);
new_stmt
= gimple_build_assign (make_ssa_name (rtype, NULL),
tem);
= gimple_build_assign (make_ssa_name (rtype), tem);
vect_finish_stmt_generation (stmt, new_stmt, gsi);
CONSTRUCTOR_APPEND_ELT (ret_ctor_elts, NULL_TREE,
gimple_assign_lhs (new_stmt));
@ -3174,8 +3173,7 @@ vectorizable_simd_clone_call (gimple stmt, gimple_stmt_iterator *gsi,
continue;
vec_oprnd0 = build_constructor (vectype, ret_ctor_elts);
new_stmt
= gimple_build_assign (make_ssa_name (vec_dest, NULL),
vec_oprnd0);
= gimple_build_assign (make_ssa_name (vec_dest), vec_oprnd0);
vect_finish_stmt_generation (stmt, new_stmt, gsi);
if ((unsigned) j == k - 1)
@ -3192,7 +3190,7 @@ vectorizable_simd_clone_call (gimple stmt, gimple_stmt_iterator *gsi,
t = build2 (MEM_REF, vectype, t,
build_int_cst (TREE_TYPE (t), 0));
new_stmt
= gimple_build_assign (make_ssa_name (vec_dest, NULL), t);
= gimple_build_assign (make_ssa_name (vec_dest), t);
vect_finish_stmt_generation (stmt, new_stmt, gsi);
tree clobber = build_constructor (ratype, NULL);
TREE_THIS_VOLATILE (clobber) = 1;
@ -3939,7 +3937,7 @@ vectorizable_conversion (gimple stmt, gimple_stmt_iterator *gsi,
else
{
gcc_assert (TREE_CODE_LENGTH (codecvt1) == unary_op);
new_temp = make_ssa_name (vec_dest, NULL);
new_temp = make_ssa_name (vec_dest);
new_stmt = gimple_build_assign_with_ops (codecvt1,
new_temp, vop0);
}
@ -3996,7 +3994,7 @@ vectorizable_conversion (gimple stmt, gimple_stmt_iterator *gsi,
else
{
gcc_assert (TREE_CODE_LENGTH (codecvt1) == unary_op);
new_temp = make_ssa_name (vec_dest, NULL);
new_temp = make_ssa_name (vec_dest);
new_stmt = gimple_build_assign_with_ops (codecvt1, new_temp,
vop0);
}
@ -5465,7 +5463,7 @@ vectorizable_store (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt,
tree perm_dest
= vect_create_destination_var (gimple_assign_rhs1 (stmt),
vectype);
tree new_temp = make_ssa_name (perm_dest, NULL);
tree new_temp = make_ssa_name (perm_dest);
/* Generate the permute statement. */
gimple perm_stmt
@ -5557,7 +5555,7 @@ permute_vec_elements (tree x, tree y, tree mask_vec, gimple stmt,
gimple perm_stmt;
perm_dest = vect_create_destination_var (gimple_get_lhs (stmt), vectype);
data_ref = make_ssa_name (perm_dest, NULL);
data_ref = make_ssa_name (perm_dest);
/* Generate the permute statement. */
perm_stmt = gimple_build_assign_with_ops (VEC_PERM_EXPR, data_ref,
@ -5993,7 +5991,7 @@ vectorizable_load (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt,
gcc_assert (TYPE_VECTOR_SUBPARTS (TREE_TYPE (op))
== TYPE_VECTOR_SUBPARTS (idxtype));
var = vect_get_new_vect_var (idxtype, vect_simple_var, NULL);
var = make_ssa_name (var, NULL);
var = make_ssa_name (var);
op = build1 (VIEW_CONVERT_EXPR, idxtype, op);
new_stmt
= gimple_build_assign_with_ops (VIEW_CONVERT_EXPR, var, op);
@ -6012,7 +6010,7 @@ vectorizable_load (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt,
op = make_ssa_name (var, new_stmt);
gimple_call_set_lhs (new_stmt, op);
vect_finish_stmt_generation (stmt, new_stmt, gsi);
var = make_ssa_name (vec_dest, NULL);
var = make_ssa_name (vec_dest);
op = build1 (VIEW_CONVERT_EXPR, vectype, op);
new_stmt
= gimple_build_assign_with_ops (VIEW_CONVERT_EXPR, var, op);
@ -6118,7 +6116,7 @@ vectorizable_load (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt,
NULL_TREE, true,
GSI_SAME_STMT);
CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, newref);
newoff = copy_ssa_name (running_off, NULL);
newoff = copy_ssa_name (running_off);
incr = gimple_build_assign_with_ops (POINTER_PLUS_EXPR, newoff,
running_off, stride_step);
vect_finish_stmt_generation (stmt, incr, gsi);
@ -6457,7 +6455,7 @@ vectorizable_load (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt,
dr_explicit_realign,
dataref_ptr, NULL);
ptr = copy_ssa_name (dataref_ptr, NULL);
ptr = copy_ssa_name (dataref_ptr);
new_stmt = gimple_build_assign_with_ops
(BIT_AND_EXPR, ptr, dataref_ptr,
build_int_cst
@ -6496,7 +6494,7 @@ vectorizable_load (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt,
break;
}
case dr_explicit_realign_optimized:
new_temp = copy_ssa_name (dataref_ptr, NULL);
new_temp = copy_ssa_name (dataref_ptr);
new_stmt = gimple_build_assign_with_ops
(BIT_AND_EXPR, new_temp, dataref_ptr,
build_int_cst
@ -6566,7 +6564,7 @@ vectorizable_load (gimple stmt, gimple_stmt_iterator *gsi, gimple *vec_stmt,
dump_gimple_stmt (MSG_NOTE, TDF_SLIM, stmt, 0);
dump_printf (MSG_NOTE, "\n");
}
tree tem = copy_ssa_name (scalar_dest, NULL);
tree tem = copy_ssa_name (scalar_dest);
gsi_insert_on_edge_immediate
(loop_preheader_edge (loop),
gimple_build_assign (tem,

13
gcc/tree-vrp.c
View file

@ -8966,7 +8966,7 @@ simplify_truth_ops_using_ranges (gimple_stmt_iterator *gsi, gimple stmt)
/* For A != B we substitute A ^ B. Either with conversion. */
else if (need_conversion)
{
tree tem = make_ssa_name (TREE_TYPE (op0), NULL);
tree tem = make_ssa_name (TREE_TYPE (op0));
gassign *newop
= gimple_build_assign_with_ops (BIT_XOR_EXPR, tem, op0, op1);
gsi_insert_before (gsi, newop, GSI_SAME_STMT);
@ -9734,7 +9734,7 @@ simplify_float_conversion_using_ranges (gimple_stmt_iterator *gsi, gimple stmt)
/* It works, insert a truncation or sign-change before the
float conversion. */
tem = make_ssa_name (build_nonstandard_integer_type
(GET_MODE_PRECISION (mode), 0), NULL);
(GET_MODE_PRECISION (mode), 0));
conv = gimple_build_assign_with_ops (NOP_EXPR, tem, rhs1);
gsi_insert_before (gsi, conv, GSI_SAME_STMT);
gimple_assign_set_rhs1 (stmt, tem);
@ -9809,7 +9809,7 @@ simplify_internal_call_using_ranges (gimple_stmt_iterator *gsi, gimple stmt)
else if (!useless_type_conversion_p (utype, TREE_TYPE (op0)))
{
g = gimple_build_assign_with_ops (NOP_EXPR,
make_ssa_name (utype, NULL), op0);
make_ssa_name (utype), op0);
gimple_set_location (g, loc);
gsi_insert_before (gsi, g, GSI_SAME_STMT);
op0 = gimple_assign_lhs (g);
@ -9819,19 +9819,18 @@ simplify_internal_call_using_ranges (gimple_stmt_iterator *gsi, gimple stmt)
else if (!useless_type_conversion_p (utype, TREE_TYPE (op1)))
{
g = gimple_build_assign_with_ops (NOP_EXPR,
make_ssa_name (utype, NULL), op1);
make_ssa_name (utype), op1);
gimple_set_location (g, loc);
gsi_insert_before (gsi, g, GSI_SAME_STMT);
op1 = gimple_assign_lhs (g);
}
g = gimple_build_assign_with_ops (subcode, make_ssa_name (utype, NULL),
g = gimple_build_assign_with_ops (subcode, make_ssa_name (utype),
op0, op1);
gimple_set_location (g, loc);
gsi_insert_before (gsi, g, GSI_SAME_STMT);
if (utype != type)
{
g = gimple_build_assign_with_ops (NOP_EXPR,
make_ssa_name (type, NULL),
g = gimple_build_assign_with_ops (NOP_EXPR, make_ssa_name (type),
gimple_assign_lhs (g));
gimple_set_location (g, loc);
gsi_insert_before (gsi, g, GSI_SAME_STMT);

20
gcc/tsan.c
View file

@ -168,8 +168,7 @@ instrument_expr (gimple_stmt_iterator gsi, tree expr, bool is_write)
seq = NULL;
if (!is_gimple_val (expr_ptr))
{
g = gimple_build_assign (make_ssa_name (TREE_TYPE (expr_ptr), NULL),
expr_ptr);
g = gimple_build_assign (make_ssa_name (TREE_TYPE (expr_ptr)), expr_ptr);
expr_ptr = gimple_assign_lhs (g);
gimple_set_location (g, loc);
gimple_seq_add_stmt_without_update (&seq, g);
@ -500,17 +499,16 @@ instrument_builtin_call (gimple_stmt_iterator *gsi)
if (!useless_type_conversion_p (TREE_TYPE (lhs),
TREE_TYPE (args[1])))
{
tree var = make_ssa_name (TREE_TYPE (lhs), NULL);
tree var = make_ssa_name (TREE_TYPE (lhs));
g = gimple_build_assign_with_ops (NOP_EXPR, var, args[1]);
gsi_insert_after (gsi, g, GSI_NEW_STMT);
args[1] = var;
}
gimple_call_set_lhs (stmt,
make_ssa_name (TREE_TYPE (lhs), NULL));
gimple_call_set_lhs (stmt, make_ssa_name (TREE_TYPE (lhs)));
/* BIT_NOT_EXPR stands for NAND. */
if (tsan_atomic_table[i].code == BIT_NOT_EXPR)
{
tree var = make_ssa_name (TREE_TYPE (lhs), NULL);
tree var = make_ssa_name (TREE_TYPE (lhs));
g = gimple_build_assign_with_ops (BIT_AND_EXPR, var,
gimple_call_lhs (stmt),
args[1]);
@ -550,14 +548,13 @@ instrument_builtin_call (gimple_stmt_iterator *gsi)
args[j] = gimple_call_arg (stmt, j);
t = TYPE_ARG_TYPES (TREE_TYPE (decl));
t = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (t)));
t = create_tmp_var (t, NULL);
t = create_tmp_var (t);
mark_addressable (t);
if (!useless_type_conversion_p (TREE_TYPE (t),
TREE_TYPE (args[1])))
{
g = gimple_build_assign_with_ops (NOP_EXPR,
make_ssa_name (TREE_TYPE (t),
NULL),
make_ssa_name (TREE_TYPE (t)),
args[1]);
gsi_insert_before (gsi, g, GSI_SAME_STMT);
args[1] = gimple_assign_lhs (g);
@ -575,8 +572,7 @@ instrument_builtin_call (gimple_stmt_iterator *gsi)
{
tree cond;
stmt = gsi_stmt (*gsi);
g = gimple_build_assign (make_ssa_name (TREE_TYPE (t), NULL),
t);
g = gimple_build_assign (make_ssa_name (TREE_TYPE (t)), t);
gsi_insert_after (gsi, g, GSI_NEW_STMT);
t = make_ssa_name (TREE_TYPE (TREE_TYPE (decl)), stmt);
cond = build2 (NE_EXPR, boolean_type_node, t,
@ -671,7 +667,7 @@ instrument_func_entry (void)
builtin_decl = builtin_decl_implicit (BUILT_IN_RETURN_ADDRESS);
g = gimple_build_call (builtin_decl, 1, integer_zero_node);
ret_addr = make_ssa_name (ptr_type_node, NULL);
ret_addr = make_ssa_name (ptr_type_node);
gimple_call_set_lhs (g, ret_addr);
gimple_set_location (g, cfun->function_start_locus);
gsi_insert_before (&gsi, g, GSI_SAME_STMT);

21
gcc/ubsan.c
View file

@ -172,7 +172,7 @@ ubsan_encode_value (tree t, bool in_expand_p)
{
/* The reason for this is that we don't want to pessimize
code by making vars unnecessarily addressable. */
tree var = create_tmp_var (type, NULL);
tree var = create_tmp_var (type);
tree tem = build2 (MODIFY_EXPR, void_type_node, var, t);
if (in_expand_p)
{
@ -747,7 +747,7 @@ ubsan_expand_null_ifn (gimple_stmt_iterator *gsip)
unsigned int ptralign = get_pointer_alignment (ptr) / BITS_PER_UNIT;
if (compare_tree_int (align, ptralign) == 1)
{
check_align = make_ssa_name (pointer_sized_int_node, NULL);
check_align = make_ssa_name (pointer_sized_int_node);
g = gimple_build_assign_with_ops (NOP_EXPR, check_align, ptr);
gimple_set_location (g, loc);
gsi_insert_before (&gsi, g, GSI_SAME_STMT);
@ -871,8 +871,7 @@ ubsan_expand_null_ifn (gimple_stmt_iterator *gsip)
tree mask = build_int_cst (pointer_sized_int_node,
tree_to_uhwi (align) - 1);
g = gimple_build_assign_with_ops (BIT_AND_EXPR,
make_ssa_name (pointer_sized_int_node,
NULL),
make_ssa_name (pointer_sized_int_node),
check_align, mask);
gimple_set_location (g, loc);
if (check_null)
@ -944,7 +943,7 @@ ubsan_expand_objsize_ifn (gimple_stmt_iterator *gsi)
= (flag_sanitize_recover & SANITIZE_OBJECT_SIZE)
? BUILT_IN_UBSAN_HANDLE_TYPE_MISMATCH
: BUILT_IN_UBSAN_HANDLE_TYPE_MISMATCH_ABORT;
tree p = make_ssa_name (pointer_sized_int_node, NULL);
tree p = make_ssa_name (pointer_sized_int_node);
g = gimple_build_assign_with_ops (NOP_EXPR, p, ptr);
gimple_set_location (g, loc);
gsi_insert_before (gsi, g, GSI_SAME_STMT);
@ -1113,7 +1112,7 @@ instrument_si_overflow (gimple_stmt_iterator gsi)
a = build_int_cst (lhstype, 0);
b = gimple_assign_rhs1 (stmt);
g = gimple_build_call_internal (IFN_UBSAN_CHECK_SUB, 2, a, b);
a = make_ssa_name (lhstype, NULL);
a = make_ssa_name (lhstype);
gimple_call_set_lhs (g, a);
gimple_set_location (g, gimple_location (stmt));
gsi_insert_before (&gsi, g, GSI_SAME_STMT);
@ -1176,13 +1175,13 @@ instrument_bool_enum_load (gimple_stmt_iterator *gsi)
tree lhs = gimple_assign_lhs (stmt);
tree ptype = build_pointer_type (TREE_TYPE (rhs));
tree atype = reference_alias_ptr_type (rhs);
gimple g = gimple_build_assign (make_ssa_name (ptype, NULL),
gimple g = gimple_build_assign (make_ssa_name (ptype),
build_fold_addr_expr (rhs));
gimple_set_location (g, loc);
gsi_insert_before (gsi, g, GSI_SAME_STMT);
tree mem = build2 (MEM_REF, utype, gimple_assign_lhs (g),
build_int_cst (atype, 0));
tree urhs = make_ssa_name (utype, NULL);
tree urhs = make_ssa_name (utype);
if (can_throw)
{
gimple_assign_set_lhs (stmt, urhs);
@ -1205,8 +1204,7 @@ instrument_bool_enum_load (gimple_stmt_iterator *gsi)
maxv = fold_convert (utype, maxv);
if (!integer_zerop (minv))
{
g = gimple_build_assign_with_ops (MINUS_EXPR,
make_ssa_name (utype, NULL),
g = gimple_build_assign_with_ops (MINUS_EXPR, make_ssa_name (utype),
urhs, minv);
gimple_set_location (g, loc);
gsi_insert_before (gsi, g, GSI_SAME_STMT);
@ -1399,8 +1397,7 @@ instrument_nonnull_arg (gimple_stmt_iterator *gsi)
gimple g;
if (!is_gimple_val (arg))
{
g = gimple_build_assign (make_ssa_name (TREE_TYPE (arg), NULL),
arg);
g = gimple_build_assign (make_ssa_name (TREE_TYPE (arg)), arg);
gimple_set_location (g, loc[0]);
gsi_insert_before (gsi, g, GSI_SAME_STMT);
arg = gimple_assign_lhs (g);

2
gcc/varpool.c
View file

@ -752,7 +752,7 @@ add_new_static_var (tree type)
tree new_decl;
varpool_node *new_node;
new_decl = create_tmp_var_raw (type, NULL);
new_decl = create_tmp_var_raw (type);
DECL_NAME (new_decl) = create_tmp_var_name (NULL);
TREE_READONLY (new_decl) = 0;
TREE_STATIC (new_decl) = 1;