From 74e3c262622d61ee507eaf6000537cc4cd39b907 Mon Sep 17 00:00:00 2001 From: Richard Biener Date: Fri, 16 Oct 2015 07:52:32 +0000 Subject: [PATCH] gimple-fold.c (gimple_fold_builtin_memory_op): Use gimple_build and get rid of force_gimple_operand_gsi. 2015-10-16 Richard Biener * gimple-fold.c (gimple_fold_builtin_memory_op): Use gimple_build and get rid of force_gimple_operand_gsi. (gimple_fold_builtin_memory_chk): Likewise. (gimple_fold_builtin_stxcpy_chk): Likewise. (rewrite_to_defined_overflow): Likewise. (gimple_convert_to_ptrofftype): New function. * gimple-fold.h (gimple_convert_to_ptrofftype): New overload, declare. From-SVN: r228863 --- gcc/ChangeLog | 11 ++++++++++ gcc/gimple-fold.c | 55 ++++++++++++++++++++++++++++++----------------- gcc/gimple-fold.h | 7 ++++++ 3 files changed, 53 insertions(+), 20 deletions(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 307f41e2b4d..99ce1298eab 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,14 @@ +2015-10-16 Richard Biener + + * gimple-fold.c (gimple_fold_builtin_memory_op): Use gimple_build + and get rid of force_gimple_operand_gsi. + (gimple_fold_builtin_memory_chk): Likewise. + (gimple_fold_builtin_stxcpy_chk): Likewise. + (rewrite_to_defined_overflow): Likewise. + (gimple_convert_to_ptrofftype): New function. + * gimple-fold.h (gimple_convert_to_ptrofftype): New overload, + declare. + 2015-10-16 Richard Biener * tree-nested.h (build_addr): Adjust prototype. diff --git a/gcc/gimple-fold.c b/gcc/gimple-fold.c index 17a23d65f39..2e5942afb87 100644 --- a/gcc/gimple-fold.c +++ b/gcc/gimple-fold.c @@ -1045,16 +1045,20 @@ gimple_fold_builtin_memory_op (gimple_stmt_iterator *gsi, } done: + gimple_seq stmts = NULL; if (endp == 0 || endp == 3) len = NULL_TREE; else if (endp == 2) - len = fold_build2_loc (loc, MINUS_EXPR, TREE_TYPE (len), len, - ssize_int (1)); + len = gimple_build (&stmts, loc, MINUS_EXPR, TREE_TYPE (len), len, + ssize_int (1)); if (endp == 2 || endp == 1) - dest = fold_build_pointer_plus_loc (loc, dest, len); + { + len = gimple_convert_to_ptrofftype (&stmts, loc, len); + dest = gimple_build (&stmts, loc, POINTER_PLUS_EXPR, + TREE_TYPE (dest), dest, len); + } - dest = force_gimple_operand_gsi (gsi, dest, false, NULL_TREE, true, - GSI_SAME_STMT); + gsi_insert_seq_before (gsi, stmts, GSI_SAME_STMT); gimple *repl = gimple_build_assign (lhs, dest); gsi_replace (gsi, repl, false); return true; @@ -1708,10 +1712,10 @@ gimple_fold_builtin_memory_chk (gimple_stmt_iterator *gsi, } else { - tree temp = fold_build_pointer_plus_loc (loc, dest, len); - temp = force_gimple_operand_gsi (gsi, temp, - false, NULL_TREE, true, - GSI_SAME_STMT); + gimple_seq stmts = NULL; + len = gimple_convert_to_ptrofftype (&stmts, loc, len); + tree temp = gimple_build (&stmts, loc, POINTER_PLUS_EXPR, dest, len); + gsi_insert_seq_before (gsi, stmts, GSI_SAME_STMT); replace_call_with_value (gsi, temp); return true; } @@ -1844,11 +1848,11 @@ gimple_fold_builtin_stxcpy_chk (gimple_stmt_iterator *gsi, if (!fn) return false; - len = fold_convert_loc (loc, size_type_node, len); - len = size_binop_loc (loc, PLUS_EXPR, len, - build_int_cst (size_type_node, 1)); - len = force_gimple_operand_gsi (gsi, len, true, NULL_TREE, - true, GSI_SAME_STMT); + gimple_seq stmts = NULL; + len = gimple_convert (&stmts, loc, size_type_node, len); + len = gimple_build (&stmts, loc, PLUS_EXPR, size_type_node, len, + build_int_cst (size_type_node, 1)); + gsi_insert_seq_before (gsi, stmts, GSI_SAME_STMT); gimple *repl = gimple_build_call (fn, 4, dest, src, len, size); replace_call_with_call_and_fold (gsi, repl); return true; @@ -5940,12 +5944,9 @@ rewrite_to_defined_overflow (gimple *stmt) gimple_seq stmts = NULL; for (unsigned i = 1; i < gimple_num_ops (stmt); ++i) { - gimple_seq stmts2 = NULL; - gimple_set_op (stmt, i, - force_gimple_operand (fold_convert (type, - gimple_op (stmt, i)), - &stmts2, true, NULL_TREE)); - gimple_seq_add_seq (&stmts, stmts2); + tree op = gimple_op (stmt, i); + op = gimple_convert (&stmts, type, op); + gimple_set_op (stmt, i, op); } gimple_assign_set_lhs (stmt, make_ssa_name (type, stmt)); if (gimple_assign_rhs_code (stmt) == POINTER_PLUS_EXPR) @@ -6154,6 +6155,20 @@ gimple_convert (gimple_seq *seq, location_t loc, tree type, tree op) return gimple_build (seq, loc, NOP_EXPR, type, op); } +/* Build the conversion (ptrofftype) OP with a result of a type + compatible with ptrofftype with location LOC if such conversion + is neccesary in GIMPLE, simplifying it first. + Returns the built expression value and appends + statements possibly defining it to SEQ. */ + +tree +gimple_convert_to_ptrofftype (gimple_seq *seq, location_t loc, tree op) +{ + if (ptrofftype_p (TREE_TYPE (op))) + return op; + return gimple_convert (seq, loc, sizetype, op); +} + /* Return true if the result of assignment STMT is known to be non-negative. If the return value is based on the assumption that signed overflow is undefined, set *STRICT_OVERFLOW_P to true; otherwise, don't change diff --git a/gcc/gimple-fold.h b/gcc/gimple-fold.h index c6b4609f834..61edd696041 100644 --- a/gcc/gimple-fold.h +++ b/gcc/gimple-fold.h @@ -112,6 +112,13 @@ gimple_convert (gimple_seq *seq, tree type, tree op) return gimple_convert (seq, UNKNOWN_LOCATION, type, op); } +extern tree gimple_convert_to_ptrofftype (gimple_seq *, location_t, tree); +inline tree +gimple_convert_to_ptrofftype (gimple_seq *seq, tree op) +{ + return gimple_convert_to_ptrofftype (seq, UNKNOWN_LOCATION, op); +} + extern bool gimple_stmt_nonnegative_warnv_p (gimple *, bool *, int = 0); /* In gimple-match.c. */ -- 2.30.2