This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
[PATCH] Use = NULL default value for {make,copy}_ssa_name and create_tmp_{reg,var{,_raw}} last argument
- From: Jakub Jelinek <jakub at redhat dot com>
- To: Richard Biener <rguenther at suse dot de>
- Cc: gcc-patches at gcc dot gnu dot org
- Date: Fri, 28 Nov 2014 20:02:23 +0100
- Subject: [PATCH] Use = NULL default value for {make,copy}_ssa_name and create_tmp_{reg,var{,_raw}} last argument
- Authentication-results: sourceware.org; auth=none
- Reply-to: Jakub Jelinek <jakub at redhat dot com>
Hi!
As the following patch shows, , NULL) is passed to these 5 functions
way too often that forcing everybody to spell it everywhere seems to
verbose, leading to formatting issues and making code less readable.
Bootstrapped/regtested on x86_64-linux and i686-linux, ok for trunk?
As possible follow-up, I wonder if gimple_build_assign_with_ops
isn't too long and too verbose either, couldn't we just
use overloads of gimple_build_assign instead?
Either with the argument order of gimple_build_assign_with_ops,
i.e. tree_code, lhs, operands... , or perhaps swap the lhs and
tree_code, so lhs, tree_code, operands... In either case, I'd
find it to be pretty much unambiguous with the current two operand
gimple_build_assign which takes lhs, treeop, the presence of
enum tree_code would make it obvious that you are supplying ops for it
rather than building it from what is extracted from the tree.
Thoughts on that?
2014-11-28 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.
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.
--- gcc/gimple-expr.h.jj 2014-09-25 15:03:09.000000000 +0200
+++ gcc/gimple-expr.h 2014-11-28 15:47:18.113147394 +0100
@@ -30,9 +30,9 @@ extern const char *gimple_decl_printable
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 *);
--- gcc/tree-ssanames.h.jj 2014-09-25 15:03:14.000000000 +0200
+++ gcc/tree-ssanames.h 2014-11-28 15:45:34.269983617 +0100
@@ -102,7 +102,7 @@ extern void replace_ssa_name_symbol (tre
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);
}
--- gcc/gimple-low.c.jj 2014-11-20 17:06:26.000000000 +0100
+++ gcc/gimple-low.c 2014-11-28 16:31:49.360905976 +0100
@@ -828,10 +828,10 @@ lower_builtin_posix_memalign (gimple_stm
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_stm
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);
--- gcc/tree-ssa-strlen.c.jj 2014-11-21 18:04:58.000000000 +0100
+++ gcc/tree-ssa-strlen.c 2014-11-28 16:13:53.869939836 +0100
@@ -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));
--- gcc/tree-emutls.c.jj 2014-11-20 17:06:25.000000000 +0100
+++ gcc/tree-emutls.c 2014-11-28 16:36:48.634608571 +0100
@@ -425,7 +425,7 @@ gen_emutls_addr (tree decl, struct lower
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_sub
{
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);
--- gcc/fortran/trans-openmp.c.jj 2014-11-28 14:40:59.000000000 +0100
+++ gcc/fortran/trans-openmp.c 2014-11-28 16:44:30.791441726 +0100
@@ -1069,7 +1069,7 @@ gfc_omp_finish_clause (tree c, gimple_se
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 (tr
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);
--- gcc/tree-ssa-phiprop.c.jj 2014-11-20 17:06:26.000000000 +0100
+++ gcc/tree-ssa-phiprop.c 2014-11-28 16:12:00.269949796 +0100
@@ -208,7 +208,7 @@ phiprop_insert_phi (basic_block bb, gphi
{
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
--- gcc/tree-vect-slp.c.jj 2014-11-28 14:41:00.000000000 +0100
+++ gcc/tree-vect-slp.c 2014-11-28 16:18:11.609379571 +0100
@@ -2669,8 +2669,7 @@ vect_get_constant_vectors (tree op, slp_
}
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);
--- gcc/ipa-prop.c.jj 2014-11-28 14:40:59.000000000 +0100
+++ gcc/ipa-prop.c 2014-11-28 16:32:58.907674937 +0100
@@ -4004,7 +4004,7 @@ ipa_modify_call_arguments (struct cgraph
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);
}
--- gcc/tree-ssa-forwprop.c.jj 2014-11-20 17:06:26.000000000 +0100
+++ gcc/tree-ssa-forwprop.c 2014-11-28 16:08:49.322328292 +0100
@@ -1723,14 +1723,14 @@ simplify_rotate (gimple_stmt_iterator *g
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);
--- gcc/tree-ssa-ccp.c.jj 2014-11-20 17:06:26.000000000 +0100
+++ gcc/tree-ssa-ccp.c 2014-11-28 16:37:29.408886831 +0100
@@ -2065,7 +2065,7 @@ fold_builtin_alloca_with_align (gimple s
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);
--- gcc/asan.c.jj 2014-11-28 14:40:59.000000000 +0100
+++ gcc/asan.c 2014-11-28 15:51:42.660473720 +0100
@@ -1585,29 +1585,25 @@ build_shadow_mem_access (gimple_stmt_ite
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, t
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, t
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_itera
/* 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_itera
{
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_itera
&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_itera
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);
--- gcc/tsan.c.jj 2014-11-19 17:18:37.000000000 +0100
+++ gcc/tsan.c 2014-11-28 16:22:47.469497923 +0100
@@ -168,8 +168,7 @@ instrument_expr (gimple_stmt_iterator gs
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_ite
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_ite
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_ite
{
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);
--- gcc/varpool.c.jj 2014-11-19 17:18:37.000000000 +0100
+++ gcc/varpool.c 2014-11-28 16:39:23.026878169 +0100
@@ -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;
--- gcc/tree-loop-distribution.c.jj 2014-11-20 17:06:24.000000000 +0100
+++ gcc/tree-loop-distribution.c 2014-11-28 16:04:07.164320602 +0100
@@ -822,7 +822,7 @@ generate_memset_builtin (struct loop *lo
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;
--- gcc/gimplify.c.jj 2014-11-20 17:06:26.000000000 +0100
+++ gcc/gimplify.c 2014-11-28 16:32:22.430320618 +0100
@@ -530,7 +530,7 @@ internal_get_tmp_var (tree val, gimple_s
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_
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 *ex
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 *ex
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 obje
/* 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,
&& 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, gimpl
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
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);
--- gcc/gimple-builder.c.jj 2014-11-20 17:06:26.000000000 +0100
+++ gcc/gimple-builder.c 2014-11-28 15:53:54.189150044 +0100
@@ -65,7 +65,7 @@ build_assign (enum tree_code code, tree
{
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);
}
--- gcc/tree-vect-loop-manip.c.jj 2014-11-20 17:06:25.000000000 +0100
+++ gcc/tree-vect-loop-manip.c 2014-11-28 16:28:58.700926805 +0100
@@ -432,7 +432,7 @@ slpeel_update_phi_nodes_for_guard1 (edge
/** 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
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
/** 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
/** 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
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 lo
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
{
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,
--- gcc/tree-if-conv.c.jj 2014-11-20 17:06:26.000000000 +0100
+++ gcc/tree-if-conv.c 2014-11-28 16:02:34.728953830 +0100
@@ -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;
--- gcc/gimple-match-head.c.jj 2014-11-28 14:40:59.000000000 +0100
+++ gcc/gimple-match-head.c 2014-11-28 15:56:05.523829795 +0100
@@ -330,7 +330,7 @@ maybe_push_res_to_seq (code_helper rcode
&& 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
&& 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);
--- gcc/tree-vect-patterns.c.jj 2014-11-20 17:06:26.000000000 +0100
+++ gcc/tree-vect-patterns.c 2014-11-28 16:17:47.425807458 +0100
@@ -759,7 +759,7 @@ vect_handle_widen_op_by_const (gimple st
{
/* 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<gimpl
}
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
{
/* 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
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<gi
|| 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;
--- gcc/tree-sra.c.jj 2014-11-28 14:40:59.000000000 +0100
+++ gcc/tree-sra.c 2014-11-28 16:07:33.610667882 +0100
@@ -1548,7 +1548,7 @@ build_ref_for_offset (location_t loc, tr
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
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
--- gcc/tree-cfg.c.jj 2014-11-28 14:40:59.000000000 +0100
+++ gcc/tree-cfg.c 2014-11-28 16:35:24.101104888 +0100
@@ -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));
--- gcc/c-family/c-common.c.jj 2014-11-21 18:04:57.000000000 +0100
+++ gcc/c-family/c-common.c 2014-11-28 16:42:22.145714162 +0100
@@ -12052,7 +12052,7 @@ convert_vector_to_pointer_for_subscript
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)
--- gcc/c-family/cilk.c.jj 2014-11-12 09:31:57.000000000 +0100
+++ gcc/c-family/cilk.c 2014-11-28 16:42:40.701386389 +0100
@@ -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);
--- gcc/c-family/c-omp.c.jj 2014-09-25 15:01:57.000000000 +0200
+++ gcc/c-family/c-omp.c 2014-11-28 16:43:25.837589090 +0100
@@ -170,7 +170,7 @@ c_finish_omp_atomic (location_t loc, enu
{
/* 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);
}
--- gcc/tree-eh.c.jj 2014-11-20 17:06:26.000000000 +0100
+++ gcc/tree-eh.c 2014-11-28 16:36:29.698943749 +0100
@@ -2044,7 +2044,7 @@ lower_eh_constructs_2 (struct leh_state
&& 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_
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_
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);
--- gcc/tree-ssa-propagate.c.jj 2014-11-20 17:06:26.000000000 +0100
+++ gcc/tree-ssa-propagate.c 2014-11-28 16:12:28.395452163 +0100
@@ -835,9 +835,9 @@ update_call_from_tree (gimple_stmt_itera
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));
--- gcc/tree-complex.c.jj 2014-11-20 17:06:24.000000000 +0100
+++ gcc/tree-complex.c 2014-11-28 16:02:04.497487920 +0100
@@ -514,7 +514,7 @@ get_component_ssa_name (tree ssa_name, b
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_ite
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_ite
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
--- gcc/tree-ssa-math-opts.c.jj 2014-11-20 17:06:26.000000000 +0100
+++ gcc/tree-ssa-math-opts.c 2014-11-28 16:09:43.394371578 +0100
@@ -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);
--- gcc/tree-tailcall.c.jj 2014-11-20 17:06:25.000000000 +0100
+++ gcc/tree-tailcall.c 2014-11-28 16:27:17.853711888 +0100
@@ -694,7 +694,7 @@ update_accumulator_with_ops (enum tree_c
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
--- gcc/tree-predcom.c.jj 2014-11-28 14:40:59.000000000 +0100
+++ gcc/tree-predcom.c 2014-11-28 16:05:32.589809142 +0100
@@ -1491,7 +1491,7 @@ initialize_root_vars (struct loop *loop,
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 *lo
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,
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
/* 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,
--- gcc/tree-ssa-reassoc.c.jj 2014-11-20 17:06:26.000000000 +0100
+++ gcc/tree-ssa-reassoc.c 2014-11-28 16:13:22.614492848 +0100
@@ -1341,7 +1341,7 @@ build_and_add_sum (tree type, tree op1,
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 t
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 cod
&& (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
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
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
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);
--- gcc/tree-vect-loop.c.jj 2014-11-28 14:40:59.000000000 +0100
+++ gcc/tree-vect-loop.c 2014-11-28 16:28:15.697688000 +0100
@@ -2502,7 +2502,7 @@ vect_is_simple_reduction_1 (loop_vec_inf
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<tr
{
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<tr
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<tr
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));
--- gcc/ipa-split.c.jj 2014-11-20 17:06:26.000000000 +0100
+++ gcc/ipa-split.c 2014-11-28 16:33:21.855268745 +0100
@@ -1584,7 +1584,7 @@ split_function (struct split_point *spli
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 *spli
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
--- gcc/tree-inline.c.jj 2014-11-28 14:40:59.000000000 +0100
+++ gcc/tree-inline.c 2014-11-28 16:03:11.881297471 +0100
@@ -260,7 +260,7 @@ remap_ssa_name (tree name, copy_body_dat
&& !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_dat
|| !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,
}
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
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,
&& 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);
--- gcc/tree-cfgcleanup.c.jj 2014-11-20 17:06:26.000000000 +0100
+++ gcc/tree-cfgcleanup.c 2014-11-28 16:35:41.520796544 +0100
@@ -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);
--- gcc/cfgexpand.c.jj 2014-11-20 17:06:26.000000000 +0100
+++ gcc/cfgexpand.c 2014-11-28 16:30:52.472912942 +0100
@@ -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);
}
--- gcc/tree-ssa-phiopt.c.jj 2014-11-20 17:06:26.000000000 +0100
+++ gcc/tree-ssa-phiopt.c 2014-11-28 16:10:45.119279460 +0100
@@ -536,7 +536,7 @@ conditional_replacement (basic_block con
{
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, ba
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, ba
}
}
- 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, ba
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, ba
/* 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);
--- gcc/gimplify-me.c.jj 2014-11-20 17:06:25.000000000 +0100
+++ gcc/gimplify-me.c 2014-11-28 15:57:36.881215813 +0100
@@ -78,7 +78,7 @@ force_gimple_operand_1 (tree expr, gimpl
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,
}
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);
}
--- gcc/cp/cp-gimplify.c.jj 2014-11-18 18:17:53.000000000 +0100
+++ gcc/cp/cp-gimplify.c 2014-11-28 16:43:47.897199423 +0100
@@ -1410,13 +1410,13 @@ cxx_omp_clause_apply_fn (tree fn, tree a
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);
}
--- gcc/tree-vrp.c.jj 2014-11-28 14:40:53.000000000 +0100
+++ gcc/tree-vrp.c 2014-11-28 16:21:32.595823252 +0100
@@ -8966,7 +8966,7 @@ simplify_truth_ops_using_ranges (gimple_
/* 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 (
/* 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 (gim
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 (gim
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);
--- gcc/tree-switch-conversion.c.jj 2014-11-20 17:06:26.000000000 +0100
+++ gcc/tree-switch-conversion.c 2014-11-28 16:26:49.636211363 +0100
@@ -444,7 +444,7 @@ emit_case_bit_tests (gswitch *swtch, tre
}
/* 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
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 swi
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 *g
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);
--- gcc/gimple-fold.c.jj 2014-11-28 14:40:59.000000000 +0100
+++ gcc/gimple-fold.c 2014-11-28 15:55:19.934635205 +0100
@@ -860,8 +860,7 @@ gimple_fold_builtin_memory_op (gimple_st
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_st
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_
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 *
{
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 *
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_
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_
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_
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_
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_
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_
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);
--- gcc/c/c-typeck.c.jj 2014-11-28 14:40:54.000000000 +0100
+++ gcc/c/c-typeck.c 2014-11-28 16:42:04.310029216 +0100
@@ -2012,7 +2012,7 @@ convert_lvalue_to_rvalue (location_t loc
/* 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, tre
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, tre
}
/* 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
/* 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. */
--- gcc/c/c-array-notation.c.jj 2014-09-25 15:01:57.000000000 +0200
+++ gcc/c/c-array-notation.c 2014-11-28 16:41:39.883460694 +0100
@@ -295,7 +295,7 @@ fix_builtin_array_notation_fn (tree an_b
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 lo
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 lo
{
/* 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
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 loca
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,
--- gcc/tree-vect-generic.c.jj 2014-11-20 17:06:26.000000000 +0100
+++ gcc/tree-vect-generic.c 2014-11-28 16:16:01.647679024 +0100
@@ -639,7 +639,7 @@ expand_vector_divmod (gimple_stmt_iterat
((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
}
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));
--- gcc/ubsan.c.jj 2014-11-20 17:06:26.000000000 +0100
+++ gcc/ubsan.c 2014-11-28 16:23:50.625380010 +0100
@@ -172,7 +172,7 @@ ubsan_encode_value (tree t, bool in_expa
{
/* 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_itera
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_itera
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_it
= (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_iter
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_i
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_i
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_iter
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);
--- gcc/tree-outof-ssa.c.jj 2014-11-20 17:06:26.000000000 +0100
+++ gcc/tree-outof-ssa.c 2014-11-28 16:25:11.451949309 +0100
@@ -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));
--- gcc/tree-ssa-loop-manip.c.jj 2014-11-20 17:06:25.000000000 +0100
+++ gcc/tree-ssa-loop-manip.c 2014-11-28 16:26:23.378676144 +0100
@@ -92,8 +92,8 @@ create_iv (tree base, tree step, tree va
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 l
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
--- gcc/omp-low.c.jj 2014-11-28 15:35:54.000000000 +0100
+++ gcc/omp-low.c 2014-11-28 16:34:05.418497638 +0100
@@ -2110,7 +2110,7 @@ scan_omp_parallel (gimple_stmt_iterator
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_v
}
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, g
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, g
/* 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, g
{
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, g
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,
{
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
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_
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
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
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 *re
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_c
{
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 *si
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
{
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
}
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_bo
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, gimpl
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 *
{
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 *
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
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
}
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 *n
/* 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 *n
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 *n
{
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 *n
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 *n
|| 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);
--- gcc/tree-parloops.c.jj 2014-11-20 17:06:26.000000000 +0100
+++ gcc/tree-parloops.c 2014-11-28 16:26:02.451046581 +0100
@@ -533,7 +533,7 @@ take_address_of (tree obj, tree type, ed
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_i
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_i
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, ed
/* 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, ed
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,
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,
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));
--- gcc/graphite-sese-to-poly.c.jj 2014-11-20 17:06:26.000000000 +0100
+++ gcc/graphite-sese-to-poly.c 2014-11-28 16:24:34.777598477 +0100
@@ -2347,7 +2347,7 @@ rewrite_cross_bb_scalar_dependence (scop
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
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;
--- gcc/trans-mem.c.jj 2014-11-20 17:06:26.000000000 +0100
+++ gcc/trans-mem.c 2014-11-28 16:34:57.960567598 +0100
@@ -1675,7 +1675,7 @@ lower_transaction (gimple_stmt_iterator
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,
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
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 *regi
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 *re
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 *re
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 *re
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 cg
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 cg
/* 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 cg
{
tree temp;
- temp = create_tmp_reg (rettype, 0);
+ temp = create_tmp_reg (rettype);
gimple_call_set_lhs (stmt, temp);
g2 = gimple_build_assign (lhs,
--- gcc/tree-vect-data-refs.c.jj 2014-11-20 17:06:26.000000000 +0100
+++ gcc/tree-vect-data-refs.c 2014-11-28 16:27:41.416294810 +0100
@@ -4347,7 +4347,7 @@ bump_vector_ptr (tree dataref_ptr, gimpl
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, gim
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, gim
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);
--- gcc/tree-vect-stmts.c.jj 2014-11-28 14:40:59.000000000 +0100
+++ gcc/tree-vect-stmts.c 2014-11-28 16:30:13.622600627 +0100
@@ -1331,7 +1331,7 @@ vect_init_vector (gimple stmt, tree val,
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 stm
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 stm
== 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 stm
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 stm
= 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_stm
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 stm
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 stm
{
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 stm
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 stm
= 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 stm
= 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 stm
{
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 stm
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 stm
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 stm
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 stm
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, gi
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, gi
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_
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, tr
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_s
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_s
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_s
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_s
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_s
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_s
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,
Jakub