+2014-11-29 Jakub Jelinek <jakub@redhat.com>
+
+ * gimple-expr.h (create_tmp_var_raw, create_tmp_var,
+ create_tmp_reg): Add default NULL value to last argument.
+ * tree-ssanames.h (make_ssa_name, copy_ssa_name): Likewise.
+ * gimple-low.c (lower_builtin_posix_memalign): Remove NULL
+ last argument from create_tmp_var_raw, create_tmp_var,
+ create_tmp_reg, make_ssa_name and copy_ssa_name calls.
+ * tree-ssa-strlen.c (get_string_length): Likewise.
+ * tree-emutls.c (gen_emutls_addr, lower_emutls_1): Likewise.
+ * tree-ssa-phiprop.c (phiprop_insert_phi): Likewise.
+ * tree-vect-slp.c (vect_get_constant_vectors): Likewise.
+ * ipa-prop.c (ipa_modify_call_arguments): Likewise.
+ * tree-ssa-forwprop.c (simplify_rotate): Likewise.
+ * tree-ssa-ccp.c (fold_builtin_alloca_with_align): Likewise.
+ * asan.c (build_shadow_mem_access, maybe_create_ssa_name,
+ maybe_cast_to_ptrmode, asan_expand_check_ifn): Likewise.
+ * tsan.c (instrument_expr, instrument_builtin_call,
+ instrument_func_entry): Likewise.
+ * varpool.c (add_new_static_var): Likewise.
+ * tree-loop-distribution.c (generate_memset_builtin): Likewise.
+ * gimplify.c (internal_get_tmp_var, gimplify_return_expr,
+ gimplify_modify_expr_to_memcpy, gimplify_modify_expr_to_memset,
+ gimplify_init_ctor_eval_range, gimplify_init_constructor,
+ gimplify_omp_atomic, gimplify_expr): Likewise.
+ * gimple-builder.c (build_assign, build_type_cast): Likewise.
+ * tree-vect-loop-manip.c (slpeel_update_phi_nodes_for_guard1,
+ slpeel_update_phi_nodes_for_guard2, slpeel_tree_peel_loop_to_edge,
+ vect_loop_versioning): Likewise.
+ * tree-if-conv.c (version_loop_for_if_conversion): Likewise.
+ * gimple-match-head.c (maybe_push_res_to_seq): Likewise.
+ * tree-vect-patterns.c (vect_handle_widen_op_by_const,
+ vect_recog_widen_mult_pattern, vect_operation_fits_smaller_type,
+ vect_recog_over_widening_pattern): Likewise.
+ * tree-sra.c (build_ref_for_offset, create_access_replacement):
+ Likewise.
+ * tree-cfg.c (make_blocks): Likewise.
+ * tree-eh.c (lower_eh_constructs_2, lower_resx, lower_eh_dispatch):
+ Likewise.
+ * tree-ssa-propagate.c (update_call_from_tree): Likewise.
+ * tree-complex.c (get_component_ssa_name, expand_complex_div_wide):
+ Likewise.
+ * tree-ssa-math-opts.c (build_and_insert_cast): Likewise.
+ * tree-tailcall.c (update_accumulator_with_ops): Likewise.
+ * tree-predcom.c (initialize_root_vars, initialize_root_vars_lm,
+ execute_load_motion, reassociate_to_the_same_stmt): Likewise.
+ * tree-ssa-reassoc.c (build_and_add_sum,
+ optimize_range_tests_to_bit_test, update_ops,
+ maybe_optimize_range_tests, rewrite_expr_tree, linearize_expr,
+ negate_value, repropagate_negates): Likewise.
+ * tree-vect-loop.c (vect_is_simple_reduction_1,
+ vect_create_epilog_for_reduction): Likewise.
+ * ipa-split.c (split_function): Likewise.
+ * tree-inline.c (remap_ssa_name, setup_one_parameter,
+ declare_return_variable, tree_function_versioning): Likewise.
+ * tree-cfgcleanup.c (fixup_noreturn_call): Likewise.
+ * cfgexpand.c (update_alias_info_with_stack_vars, expand_used_vars):
+ Likewise.
+ * tree-ssa-phiopt.c (conditional_replacement, abs_replacement,
+ neg_replacement): Likewise.
+ * gimplify-me.c (force_gimple_operand_1, gimple_regimplify_operands):
+ Likewise.
+ * tree-vrp.c (simplify_truth_ops_using_ranges,
+ simplify_float_conversion_using_ranges,
+ simplify_internal_call_using_ranges): Likewise.
+ * tree-switch-conversion.c (emit_case_bit_tests,
+ build_one_array, build_arrays, gen_def_assigns): Likewise.
+ * gimple-fold.c (gimple_fold_builtin_memory_op,
+ gimple_fold_builtin_strcat, gimple_fold_call, gimple_build): Likewise.
+ * tree-vect-generic.c (expand_vector_divmod,
+ optimize_vector_constructor): Likewise.
+ * ubsan.c (ubsan_encode_value, ubsan_expand_null_ifn,
+ ubsan_expand_objsize_ifn, instrument_si_overflow,
+ instrument_bool_enum_load, instrument_nonnull_arg): Likewise.
+ * tree-outof-ssa.c (insert_backedge_copies): Likewise.
+ * tree-ssa-loop-manip.c (create_iv,
+ tree_transform_and_unroll_loop): Likewise.
+ * omp-low.c (scan_omp_parallel, lower_rec_simd_input_clauses,
+ lower_rec_input_clauses, lower_lastprivate_clauses,
+ expand_parallel_call, expand_omp_for_static_chunk,
+ expand_omp_atomic_pipeline, expand_omp_target,
+ maybe_add_implicit_barrier_cancel, lower_omp_single_simple,
+ lower_omp_critical, lower_omp_for, task_copyfn_copy_decl,
+ lower_depend_clauses, lower_omp_target, lower_omp_1,
+ ipa_simd_modify_stmt_ops, simd_clone_adjust): Likewise.
+ * tree-parloops.c (take_address_of, create_phi_for_local_result,
+ create_call_for_reduction_1, separate_decls_in_region,
+ create_parallel_loop): Likewise.
+ * graphite-sese-to-poly.c (rewrite_cross_bb_scalar_dependence,
+ handle_scalar_deps_crossing_scop_limits): Likewise.
+ * trans-mem.c (lower_transaction, build_tm_load, build_tm_store,
+ expand_assign_tm, expand_call_tm, expand_transaction,
+ ipa_tm_insert_gettmclone_call): Likewise.
+ * tree-vect-data-refs.c (bump_vector_ptr, vect_setup_realignment):
+ Likewise.
+ * tree-vect-stmts.c (vect_init_vector, vectorizable_mask_load_store,
+ vectorizable_call, vectorizable_simd_clone_call,
+ vectorizable_conversion, vectorizable_store, permute_vec_elements,
+ vectorizable_load): Likewise.
+
2014-11-29 Tobias Burnus <burnus@net-b.de>
Manuel López-Ibáñez <manu@gcc.gnu.org>
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);
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);
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);
/* 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);
{
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);
&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);
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);
+2014-11-29 Jakub Jelinek <jakub@redhat.com>
+
+ * c-common.c (convert_vector_to_pointer_for_subscript): Remove NULL
+ last argument from create_tmp_var_raw and create_tmp_var calls.
+ * cilk.c (gimplify_cilk_spawn): Likewise.
+ * c-omp.c (c_finish_omp_atomic): Likewise.
+
2014-11-28 Marek Polacek <polacek@redhat.com>
* c-ubsan.c (ubsan_instrument_shift): Use op1_utype for MINUS_EXPR
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)
{
/* 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);
}
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);
+2014-11-29 Jakub Jelinek <jakub@redhat.com>
+
+ * c-typeck.c (convert_lvalue_to_rvalue, build_atomic_assign,
+ c_finish_stmt_expr): Remove NULL last argument from
+ create_tmp_var_raw and create_tmp_var calls.
+ * c-array-notation.c (fix_builtin_array_notation_fn,
+ build_array_notation_expr, fix_conditional_array_notations_1,
+ fix_array_notation_expr, fix_array_notation_call_expr): Likewise.
+
2014-11-28 Marek Polacek <polacek@redhat.com>
PR c/63862
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,
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,
{
/* 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,
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,
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,
}
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,
/* 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;
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);
}
/* 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;
/* 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. */
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. */
{
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);
}
+2014-11-29 Jakub Jelinek <jakub@redhat.com>
+
+ * cp-gimplify.c (cxx_omp_clause_apply_fn): Remove NULL last argument
+ from create_tmp_var calls.
+
2014-11-28 Marek Polacek <polacek@redhat.com>
PR c/63862
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);
}
+2014-11-29 Jakub Jelinek <jakub@redhat.com>
+
+ * trans-openmp.c (gfc_omp_finish_clause,
+ gfc_trans_omp_array_reduction_or_udr, gfc_trans_omp_atomic): Remove
+ NULL last argument from create_tmp_var_raw and create_tmp_var calls.
+
2014-11-29 Tobias Burnus <burnus@net-b.de>
* scanner.c (skip_free_comments, gfc_gobble_whitespace): Use
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
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))
{
/* 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);
{
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);
}
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);
}
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);
}
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 *);
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);
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);
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);
{
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);
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
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
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);
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,
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);
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);
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);
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);
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);
&& 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]);
&& 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);
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);
}
}
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);
}
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);
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
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);
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);
/* 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. */
&& 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,
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;
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_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);
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;
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);
}
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);
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
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);
}
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)
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);
/* 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);
{
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
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;
{
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,
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
{
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
{
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
{
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);
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);
{
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,
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);
{
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));
}
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_);
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;
}
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));
{
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);
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)
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);
}
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);
/* 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. */
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,
{
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);
}
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);
|| 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);
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);
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);
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);
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
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;
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);
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);
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,
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);
/* 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);
{
tree temp;
- temp = create_tmp_reg (rettype, 0);
+ temp = create_tmp_reg (rettype);
gimple_call_set_lhs (stmt, temp);
g2 = gimple_build_assign (lhs,
&& 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));
/* 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);
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. */
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);
}
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
&& 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));
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);
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);
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);
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);
{
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);
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;
&& !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);
|| !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);
}
else if (!optimize)
{
- def = make_ssa_name (var, NULL);
+ def = make_ssa_name (var);
init_stmt = gimple_build_assign (def, rhs);
}
}
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));
&& 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);
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;
/* 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));
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);
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);
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);
/* 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;
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);
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);
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));
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++)
{
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];
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
/* 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,
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);
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
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);
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);
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
{
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
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);
{
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);
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;
}
}
- 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));
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);
/* 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);
{
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
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));
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. */
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);
&& (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));
{
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;
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);
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);
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));
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));
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);
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));
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);
}
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);
}
}
/* 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,
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]);
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));
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);
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
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);
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),
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);
((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);
}
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));
/** 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
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. */
/** 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
/** 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. */
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: */
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;
{
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,
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);
{
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)
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));
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));
{
/* 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);
}
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;
{
/* 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;
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;
|| 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;
}
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);
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);
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);
== 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,
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);
= 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;
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));
}
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));
{
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));
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,
= 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);
= 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);
{
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);
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;
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));
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)
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;
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);
}
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);
}
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
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,
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);
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);
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);
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
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
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,
/* 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);
/* 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);
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);
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);
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);
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]);
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);
{
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,
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);
{
/* 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)
{
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);
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)
= (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);
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);
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);
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);
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);
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;
projects / gcc.git / commitdiff