Mercurial > hg > CbC > CbC_gcc
diff gcc/gimple-fold.c @ 132:d34655255c78
update gcc-8.2
| author | mir3636 |
|---|---|
| date | Thu, 25 Oct 2018 10:21:07 +0900 |
| parents | 84e7813d76e9 |
| children | 1830386684a0 |
line wrap: on
line diff
--- a/gcc/gimple-fold.c Thu Oct 25 08:08:40 2018 +0900 +++ b/gcc/gimple-fold.c Thu Oct 25 10:21:07 2018 +0900 @@ -1,5 +1,5 @@ /* Statement simplification on GIMPLE. - Copyright (C) 2010-2017 Free Software Foundation, Inc. + Copyright (C) 2010-2018 Free Software Foundation, Inc. Split out from tree-ssa-ccp.c. This file is part of GCC. @@ -30,6 +30,7 @@ #include "ssa.h" #include "cgraph.h" #include "gimple-pretty-print.h" +#include "gimple-ssa-warn-restrict.h" #include "fold-const.h" #include "stmt.h" #include "expr.h" @@ -40,6 +41,7 @@ #include "gimple-iterator.h" #include "tree-into-ssa.h" #include "tree-dfa.h" +#include "tree-object-size.h" #include "tree-ssa.h" #include "tree-ssa-propagate.h" #include "ipa-utils.h" @@ -53,12 +55,16 @@ #include "gomp-constants.h" #include "optabs-query.h" #include "omp-general.h" -#include "ipa-chkp.h" #include "tree-cfg.h" #include "fold-const-call.h" #include "stringpool.h" #include "attribs.h" #include "asan.h" +#include "diagnostic-core.h" +#include "intl.h" +#include "calls.h" +#include "tree-vector-builder.h" +#include "tree-ssa-strlen.h" /* Return true when DECL can be referenced from current unit. FROM_DECL (if non-null) specify constructor of variable DECL was taken from. @@ -341,8 +347,7 @@ { if (dump_enabled_p ()) { - location_t loc = gimple_location_safe (stmt); - dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, loc, + dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, stmt, "resolving virtual function address " "reference to function %s\n", targets.length () == 1 @@ -625,7 +630,9 @@ tree inner = var; while (handled_component_p (inner)) inner = TREE_OPERAND (inner, 0); - return SSA_VAR_P (inner); + return (DECL_P (inner) + || (TREE_CODE (inner) == MEM_REF + && TREE_CODE (TREE_OPERAND (inner, 0)) == ADDR_EXPR)); } /* If the SIZE argument representing the size of an object is in a range @@ -638,11 +645,11 @@ if (integer_zerop (size)) return true; - if (TREE_CODE (size) != SSA_NAME) + if (TREE_CODE (size) != SSA_NAME || !INTEGRAL_TYPE_P (TREE_TYPE (size))) return false; wide_int min, max; - enum value_range_type rtype = get_range_info (size, &min, &max); + enum value_range_kind rtype = get_range_info (size, &min, &max); if (rtype != VR_ANTI_RANGE) return false; @@ -658,13 +665,12 @@ return wi::eq_p (min, wone) && wi::geu_p (max, ssize_max); } -/* Fold function call to builtin mem{{,p}cpy,move}. Return - false if no simplification can be made. - If ENDP is 0, return DEST (like memcpy). - If ENDP is 1, return DEST+LEN (like mempcpy). - If ENDP is 2, return DEST+LEN-1 (like stpcpy). - If ENDP is 3, return DEST, additionally *SRC and *DEST may overlap - (memmove). */ +/* Fold function call to builtin mem{{,p}cpy,move}. Try to detect and + diagnose (otherwise undefined) overlapping copies without preventing + folding. When folded, GCC guarantees that overlapping memcpy has + the same semantics as memmove. Call to the library memcpy need not + provide the same guarantee. Return false if no simplification can + be made. */ static bool gimple_fold_builtin_memory_op (gimple_stmt_iterator *gsi, @@ -676,6 +682,8 @@ tree destvar, srcvar; location_t loc = gimple_location (stmt); + bool nowarn = gimple_no_warning_p (stmt); + /* If the LEN parameter is a constant zero or in range where the only valid value is zero, return DEST. */ if (size_must_be_zero_p (len)) @@ -699,6 +707,9 @@ DEST{,+LEN,+LEN-1}. */ if (operand_equal_p (src, dest, 0)) { + /* Avoid diagnosing exact overlap in calls to __builtin_memcpy. + It's safe and may even be emitted by GCC itself (see bug + 32667). */ unlink_stmt_vdef (stmt); if (gimple_vdef (stmt) && TREE_CODE (gimple_vdef (stmt)) == SSA_NAME) release_ssa_name (gimple_vdef (stmt)); @@ -714,18 +725,8 @@ tree srctype, desttype; unsigned int src_align, dest_align; tree off0; - - /* Inlining of memcpy/memmove may cause bounds lost (if we copy - pointers as wide integer) and also may result in huge function - size because of inlined bounds copy. Thus don't inline for - functions we want to instrument. */ - if (flag_check_pointer_bounds - && chkp_instrumentable_p (cfun->decl) - /* Even if data may contain pointers we can inline if copy - less than a pointer size. */ - && (!tree_fits_uhwi_p (len) - || compare_tree_int (len, POINTER_SIZE_UNITS) >= 0)) - return false; + const char *tmp_str; + unsigned HOST_WIDE_INT tmp_len; /* Build accesses at offset zero with a ref-all character type. */ off0 = build_int_cst (build_pointer_type_for_mode (char_type_node, @@ -743,11 +744,20 @@ confuses the tree-ssa-strlen.c. This doesn't handle the case in gcc.dg/strlenopt-8.c which is XFAILed for that reason. */ - && !c_strlen (src, 2)) + && !c_strlen (src, 2) + && !((tmp_str = c_getstr (src, &tmp_len)) != NULL + && memchr (tmp_str, 0, tmp_len) == NULL)) { unsigned ilen = tree_to_uhwi (len); if (pow2p_hwi (ilen)) { + /* Detect invalid bounds and overlapping copies and issue + either -Warray-bounds or -Wrestrict. */ + if (!nowarn + && check_bounds_or_overlap (as_a <gcall *>(stmt), + dest, src, len, len)) + gimple_set_no_warning (stmt, true); + scalar_int_mode mode; tree type = lang_hooks.types.type_for_size (ilen * 8, 1); if (type @@ -838,8 +848,8 @@ && TREE_CODE (dest) == ADDR_EXPR) { tree src_base, dest_base, fn; - HOST_WIDE_INT src_offset = 0, dest_offset = 0; - HOST_WIDE_INT maxsize; + poly_int64 src_offset = 0, dest_offset = 0; + poly_uint64 maxsize; srcvar = TREE_OPERAND (src, 0); src_base = get_addr_base_and_unit_offset (srcvar, &src_offset); @@ -850,16 +860,14 @@ &dest_offset); if (dest_base == NULL) dest_base = destvar; - if (tree_fits_uhwi_p (len)) - maxsize = tree_to_uhwi (len); - else + if (!poly_int_tree_p (len, &maxsize)) maxsize = -1; if (SSA_VAR_P (src_base) && SSA_VAR_P (dest_base)) { if (operand_equal_p (src_base, dest_base, 0) - && ranges_overlap_p (src_offset, maxsize, - dest_offset, maxsize)) + && ranges_maybe_overlap_p (src_offset, maxsize, + dest_offset, maxsize)) return false; } else if (TREE_CODE (src_base) == MEM_REF @@ -868,17 +876,12 @@ if (! operand_equal_p (TREE_OPERAND (src_base, 0), TREE_OPERAND (dest_base, 0), 0)) return false; - offset_int off = mem_ref_offset (src_base) + src_offset; - if (!wi::fits_shwi_p (off)) - return false; - src_offset = off.to_shwi (); - - off = mem_ref_offset (dest_base) + dest_offset; - if (!wi::fits_shwi_p (off)) - return false; - dest_offset = off.to_shwi (); - if (ranges_overlap_p (src_offset, maxsize, - dest_offset, maxsize)) + poly_offset_int full_src_offset + = mem_ref_offset (src_base) + src_offset; + poly_offset_int full_dest_offset + = mem_ref_offset (dest_base) + dest_offset; + if (ranges_maybe_overlap_p (full_src_offset, maxsize, + full_dest_offset, maxsize)) return false; } else @@ -923,12 +926,6 @@ if (!tree_fits_shwi_p (len)) return false; - /* FIXME: - This logic lose for arguments like (type *)malloc (sizeof (type)), - since we strip the casts of up to VOID return value from malloc. - Perhaps we ought to inherit type from non-VOID argument here? */ - STRIP_NOPS (src); - STRIP_NOPS (dest); if (!POINTER_TYPE_P (TREE_TYPE (src)) || !POINTER_TYPE_P (TREE_TYPE (dest))) return false; @@ -938,37 +935,14 @@ using that type. In theory we could always use a char[len] type but that only gains us that the destination and source possibly no longer will have their address taken. */ - /* As we fold (void *)(p + CST) to (void *)p + CST undo this here. */ - if (TREE_CODE (src) == POINTER_PLUS_EXPR) - { - tree tem = TREE_OPERAND (src, 0); - STRIP_NOPS (tem); - if (tem != TREE_OPERAND (src, 0)) - src = build1 (NOP_EXPR, TREE_TYPE (tem), src); - } - if (TREE_CODE (dest) == POINTER_PLUS_EXPR) - { - tree tem = TREE_OPERAND (dest, 0); - STRIP_NOPS (tem); - if (tem != TREE_OPERAND (dest, 0)) - dest = build1 (NOP_EXPR, TREE_TYPE (tem), dest); - } srctype = TREE_TYPE (TREE_TYPE (src)); if (TREE_CODE (srctype) == ARRAY_TYPE && !tree_int_cst_equal (TYPE_SIZE_UNIT (srctype), len)) - { - srctype = TREE_TYPE (srctype); - STRIP_NOPS (src); - src = build1 (NOP_EXPR, build_pointer_type (srctype), src); - } + srctype = TREE_TYPE (srctype); desttype = TREE_TYPE (TREE_TYPE (dest)); if (TREE_CODE (desttype) == ARRAY_TYPE && !tree_int_cst_equal (TYPE_SIZE_UNIT (desttype), len)) - { - desttype = TREE_TYPE (desttype); - STRIP_NOPS (dest); - dest = build1 (NOP_EXPR, build_pointer_type (desttype), dest); - } + desttype = TREE_TYPE (desttype); if (TREE_ADDRESSABLE (srctype) || TREE_ADDRESSABLE (desttype)) return false; @@ -996,43 +970,34 @@ || src_align < TYPE_ALIGN (srctype)) return false; - destvar = dest; - STRIP_NOPS (destvar); - if (TREE_CODE (destvar) == ADDR_EXPR - && var_decl_component_p (TREE_OPERAND (destvar, 0)) + destvar = NULL_TREE; + if (TREE_CODE (dest) == ADDR_EXPR + && var_decl_component_p (TREE_OPERAND (dest, 0)) && tree_int_cst_equal (TYPE_SIZE_UNIT (desttype), len)) - destvar = fold_build2 (MEM_REF, desttype, destvar, off0); - else - destvar = NULL_TREE; - - srcvar = src; - STRIP_NOPS (srcvar); - if (TREE_CODE (srcvar) == ADDR_EXPR - && var_decl_component_p (TREE_OPERAND (srcvar, 0)) + destvar = fold_build2 (MEM_REF, desttype, dest, off0); + + srcvar = NULL_TREE; + if (TREE_CODE (src) == ADDR_EXPR + && var_decl_component_p (TREE_OPERAND (src, 0)) && tree_int_cst_equal (TYPE_SIZE_UNIT (srctype), len)) { if (!destvar || src_align >= TYPE_ALIGN (desttype)) srcvar = fold_build2 (MEM_REF, destvar ? desttype : srctype, - srcvar, off0); + src, off0); else if (!STRICT_ALIGNMENT) { srctype = build_aligned_type (TYPE_MAIN_VARIANT (desttype), src_align); - srcvar = fold_build2 (MEM_REF, srctype, srcvar, off0); + srcvar = fold_build2 (MEM_REF, srctype, src, off0); } - else - srcvar = NULL_TREE; } - else - srcvar = NULL_TREE; if (srcvar == NULL_TREE && destvar == NULL_TREE) return false; if (srcvar == NULL_TREE) { - STRIP_NOPS (src); if (src_align >= TYPE_ALIGN (desttype)) srcvar = fold_build2 (MEM_REF, desttype, src, off0); else @@ -1046,7 +1011,6 @@ } else if (destvar == NULL_TREE) { - STRIP_NOPS (dest); if (dest_align >= TYPE_ALIGN (srctype)) destvar = fold_build2 (MEM_REF, srctype, dest, off0); else @@ -1059,6 +1023,11 @@ } } + /* Detect invalid bounds and overlapping copies and issue either + -Warray-bounds or -Wrestrict. */ + if (!nowarn) + check_bounds_or_overlap (as_a <gcall *>(stmt), dest, src, len, len); + gimple *new_stmt; if (is_gimple_reg_type (TREE_TYPE (srcvar))) { @@ -1074,8 +1043,24 @@ gimple_set_vuse (new_stmt, gimple_vuse (stmt)); gsi_insert_before (gsi, new_stmt, GSI_SAME_STMT); } + new_stmt = gimple_build_assign (destvar, srcvar); + goto set_vop_and_replace; } - new_stmt = gimple_build_assign (destvar, srcvar); + + /* We get an aggregate copy. Use an unsigned char[] type to + perform the copying to preserve padding and to avoid any issues + with TREE_ADDRESSABLE types or float modes behavior on copying. */ + desttype = build_array_type_nelts (unsigned_char_type_node, + tree_to_uhwi (len)); + srctype = desttype; + if (src_align > TYPE_ALIGN (srctype)) + srctype = build_aligned_type (srctype, src_align); + if (dest_align > TYPE_ALIGN (desttype)) + desttype = build_aligned_type (desttype, dest_align); + new_stmt + = gimple_build_assign (fold_build2 (MEM_REF, desttype, dest, off0), + fold_build2 (MEM_REF, srctype, src, off0)); +set_vop_and_replace: gimple_set_vuse (new_stmt, gimple_vuse (stmt)); gimple_set_vdef (new_stmt, gimple_vdef (stmt)); if (gimple_vdef (new_stmt) @@ -1281,42 +1266,67 @@ value of ARG in LENGTH[0] and LENGTH[1], respectively. If ARG is an SSA name variable, follow its use-def chains. When TYPE == 0, if LENGTH[1] is not equal to the length we determine or - if we are unable to determine the length or value, return False. + if we are unable to determine the length or value, return false. VISITED is a bitmap of visited variables. TYPE is 0 if string length should be obtained, 1 for maximum string length and 2 for maximum value ARG can have. - When FUZZY is set and the length of a string cannot be determined, + When FUZZY is non-zero and the length of a string cannot be determined, the function instead considers as the maximum possible length the - size of a character array it may refer to. + size of a character array it may refer to. If FUZZY is 2, it will handle + PHIs and COND_EXPRs optimistically, if we can determine string length + minimum and maximum, it will use the minimum from the ones where it + can be determined. Set *FLEXP to true if the range of the string lengths has been obtained from the upper bound of an array at the end of a struct. Such an array may hold a string that's longer than its upper bound - due to it being used as a poor-man's flexible array member. */ + due to it being used as a poor-man's flexible array member. + Pass NONSTR through to children. + ELTSIZE is 1 for normal single byte character strings, and 2 or + 4 for wide characer strings. ELTSIZE is by default 1. */ static bool get_range_strlen (tree arg, tree length[2], bitmap *visited, int type, - bool fuzzy, bool *flexp) + int fuzzy, bool *flexp, unsigned eltsize, tree *nonstr) { - tree var, val; + tree var, val = NULL_TREE; gimple *def_stmt; - /* The minimum and maximum length. The MAXLEN pointer stays unchanged - but MINLEN may be cleared during the execution of the function. */ - tree *minlen = length; + /* The minimum and maximum length. */ + tree *const minlen = length; tree *const maxlen = length + 1; if (TREE_CODE (arg) != SSA_NAME) { /* We can end up with &(*iftmp_1)[0] here as well, so handle it. */ if (TREE_CODE (arg) == ADDR_EXPR - && TREE_CODE (TREE_OPERAND (arg, 0)) == ARRAY_REF - && integer_zerop (TREE_OPERAND (TREE_OPERAND (arg, 0), 1))) + && TREE_CODE (TREE_OPERAND (arg, 0)) == ARRAY_REF) { - tree aop0 = TREE_OPERAND (TREE_OPERAND (arg, 0), 0); - if (TREE_CODE (aop0) == INDIRECT_REF - && TREE_CODE (TREE_OPERAND (aop0, 0)) == SSA_NAME) - return get_range_strlen (TREE_OPERAND (aop0, 0), - length, visited, type, fuzzy, flexp); + tree op = TREE_OPERAND (arg, 0); + if (integer_zerop (TREE_OPERAND (op, 1))) + { + tree aop0 = TREE_OPERAND (op, 0); + if (TREE_CODE (aop0) == INDIRECT_REF + && TREE_CODE (TREE_OPERAND (aop0, 0)) == SSA_NAME) + return get_range_strlen (TREE_OPERAND (aop0, 0), length, + visited, type, fuzzy, flexp, + eltsize, nonstr); + } + else if (TREE_CODE (TREE_OPERAND (op, 0)) == COMPONENT_REF && fuzzy) + { + /* Fail if an array is the last member of a struct object + since it could be treated as a (fake) flexible array + member. */ + tree idx = TREE_OPERAND (op, 1); + + arg = TREE_OPERAND (op, 0); + tree optype = TREE_TYPE (arg); + if (tree dom = TYPE_DOMAIN (optype)) + if (tree bound = TYPE_MAX_VALUE (dom)) + if (TREE_CODE (bound) == INTEGER_CST + && TREE_CODE (idx) == INTEGER_CST + && tree_int_cst_lt (bound, idx)) + return false; + } } if (type == 2) @@ -1327,29 +1337,84 @@ return false; } else - val = c_strlen (arg, 1); + { + c_strlen_data data; + memset (&data, 0, sizeof (c_strlen_data)); + val = c_strlen (arg, 1, &data, eltsize); + + /* If we potentially had a non-terminated string, then + bubble that information up to the caller. */ + if (!val && data.decl) + { + *nonstr = data.decl; + *minlen = data.len; + *maxlen = data.len; + return type == 0 ? false : true; + } + } if (!val && fuzzy) { if (TREE_CODE (arg) == ADDR_EXPR) return get_range_strlen (TREE_OPERAND (arg, 0), length, - visited, type, fuzzy, flexp); - - if (TREE_CODE (arg) == COMPONENT_REF - && TREE_CODE (TREE_TYPE (TREE_OPERAND (arg, 1))) == ARRAY_TYPE) + visited, type, fuzzy, flexp, + eltsize, nonstr); + + if (TREE_CODE (arg) == ARRAY_REF) + { + tree type = TREE_TYPE (TREE_OPERAND (arg, 0)); + + /* Determine the "innermost" array type. */ + while (TREE_CODE (type) == ARRAY_TYPE + && TREE_CODE (TREE_TYPE (type)) == ARRAY_TYPE) + type = TREE_TYPE (type); + + /* Avoid arrays of pointers. */ + tree eltype = TREE_TYPE (type); + if (TREE_CODE (type) != ARRAY_TYPE + || !INTEGRAL_TYPE_P (eltype)) + return false; + + val = TYPE_SIZE_UNIT (type); + if (!val || integer_zerop (val)) + return false; + + val = fold_build2 (MINUS_EXPR, TREE_TYPE (val), val, + integer_one_node); + /* Set the minimum size to zero since the string in + the array could have zero length. */ + *minlen = ssize_int (0); + + if (TREE_CODE (TREE_OPERAND (arg, 0)) == COMPONENT_REF + && type == TREE_TYPE (TREE_OPERAND (arg, 0)) + && array_at_struct_end_p (TREE_OPERAND (arg, 0))) + *flexp = true; + } + else if (TREE_CODE (arg) == COMPONENT_REF + && (TREE_CODE (TREE_TYPE (TREE_OPERAND (arg, 1))) + == ARRAY_TYPE)) { /* Use the type of the member array to determine the upper bound on the length of the array. This may be overly optimistic if the array itself isn't NUL-terminated and the caller relies on the subsequent member to contain - the NUL. + the NUL but that would only be considered valid if + the array were the last member of a struct. Set *FLEXP to true if the array whose bound is being used is at the end of a struct. */ if (array_at_struct_end_p (arg)) *flexp = true; arg = TREE_OPERAND (arg, 1); - val = TYPE_SIZE_UNIT (TREE_TYPE (arg)); + + tree type = TREE_TYPE (arg); + + while (TREE_CODE (type) == ARRAY_TYPE + && TREE_CODE (TREE_TYPE (type)) == ARRAY_TYPE) + type = TREE_TYPE (type); + + /* Fail when the array bound is unknown or zero. */ + val = TYPE_SIZE_UNIT (type); if (!val || integer_zerop (val)) return false; val = fold_build2 (MINUS_EXPR, TREE_TYPE (val), val, @@ -1358,17 +1423,37 @@ the array could have zero length. */ *minlen = ssize_int (0); } + + if (VAR_P (arg)) + { + tree type = TREE_TYPE (arg); + if (POINTER_TYPE_P (type)) + type = TREE_TYPE (type); + + if (TREE_CODE (type) == ARRAY_TYPE) + { + val = TYPE_SIZE_UNIT (type); + if (!val + || TREE_CODE (val) != INTEGER_CST + || integer_zerop (val)) + return false; + val = wide_int_to_tree (TREE_TYPE (val), + wi::sub (wi::to_wide (val), 1)); + /* Set the minimum size to zero since the string in + the array could have zero length. */ + *minlen = ssize_int (0); + } + } } if (!val) return false; - if (minlen - && (!*minlen - || (type > 0 - && TREE_CODE (*minlen) == INTEGER_CST - && TREE_CODE (val) == INTEGER_CST - && tree_int_cst_lt (val, *minlen)))) + if (!*minlen + || (type > 0 + && TREE_CODE (*minlen) == INTEGER_CST + && TREE_CODE (val) == INTEGER_CST + && tree_int_cst_lt (val, *minlen))) *minlen = val; if (*maxlen) @@ -1415,24 +1500,31 @@ || gimple_assign_unary_nop_p (def_stmt)) { tree rhs = gimple_assign_rhs1 (def_stmt); - return get_range_strlen (rhs, length, visited, type, fuzzy, flexp); + return get_range_strlen (rhs, length, visited, type, fuzzy, flexp, + eltsize, nonstr); } else if (gimple_assign_rhs_code (def_stmt) == COND_EXPR) { - tree op2 = gimple_assign_rhs2 (def_stmt); - tree op3 = gimple_assign_rhs3 (def_stmt); - return get_range_strlen (op2, length, visited, type, fuzzy, flexp) - && get_range_strlen (op3, length, visited, type, fuzzy, flexp); - } + tree ops[2] = { gimple_assign_rhs2 (def_stmt), + gimple_assign_rhs3 (def_stmt) }; + + for (unsigned int i = 0; i < 2; i++) + if (!get_range_strlen (ops[i], length, visited, type, fuzzy, + flexp, eltsize, nonstr)) + { + if (fuzzy == 2) + *maxlen = build_all_ones_cst (size_type_node); + else + return false; + } + return true; + } return false; case GIMPLE_PHI: - { - /* All the arguments of the PHI node must have the same constant - length. */ - unsigned i; - - for (i = 0; i < gimple_phi_num_args (def_stmt); i++) + /* All the arguments of the PHI node must have the same constant + length. */ + for (unsigned i = 0; i < gimple_phi_num_args (def_stmt); i++) { tree arg = gimple_phi_arg (def_stmt, i)->def; @@ -1445,15 +1537,15 @@ if (arg == gimple_phi_result (def_stmt)) continue; - if (!get_range_strlen (arg, length, visited, type, fuzzy, flexp)) + if (!get_range_strlen (arg, length, visited, type, fuzzy, flexp, + eltsize, nonstr)) { - if (fuzzy) + if (fuzzy == 2) *maxlen = build_all_ones_cst (size_type_node); else return false; } } - } return true; default: @@ -1467,23 +1559,46 @@ character arrays, use the upper bound of the array as the maximum length. For example, given an expression like 'x ? array : "xyz"' and array declared as 'char array[8]', MINMAXLEN[0] will be set - to 3 and MINMAXLEN[1] to 7, the longest string that could be + to 0 and MINMAXLEN[1] to 7, the longest string that could be stored in array. Return true if the range of the string lengths has been obtained from the upper bound of an array at the end of a struct. Such an array may hold a string that's longer than its upper bound - due to it being used as a poor-man's flexible array member. */ + due to it being used as a poor-man's flexible array member. + + STRICT is true if it will handle PHIs and COND_EXPRs conservatively + and false if PHIs and COND_EXPRs are to be handled optimistically, + if we can determine string length minimum and maximum; it will use + the minimum from the ones where it can be determined. + STRICT false should be only used for warning code. + When non-null, clear *NONSTR if ARG refers to a constant array + that is known not be nul-terminated. Otherwise set it to + the declaration of the constant non-terminated array. + + ELTSIZE is 1 for normal single byte character strings, and 2 or + 4 for wide characer strings. ELTSIZE is by default 1. */ bool -get_range_strlen (tree arg, tree minmaxlen[2]) +get_range_strlen (tree arg, tree minmaxlen[2], unsigned eltsize, + bool strict, tree *nonstr /* = NULL */) { bitmap visited = NULL; minmaxlen[0] = NULL_TREE; minmaxlen[1] = NULL_TREE; + tree nonstrbuf; + if (!nonstr) + nonstr = &nonstrbuf; + *nonstr = NULL_TREE; + bool flexarray = false; - get_range_strlen (arg, minmaxlen, &visited, 1, true, &flexarray); + if (!get_range_strlen (arg, minmaxlen, &visited, 1, strict ? 1 : 2, + &flexarray, eltsize, nonstr)) + { + minmaxlen[0] = NULL_TREE; + minmaxlen[1] = NULL_TREE; + } if (visited) BITMAP_FREE (visited); @@ -1491,19 +1606,39 @@ return flexarray; } +/* Return the maximum string length for ARG, counting by TYPE + (1, 2 or 4 for normal or wide chars). NONSTR indicates + if the caller is prepared to handle unterminated strings. + + If an unterminated string is discovered and our caller handles + unterminated strings, then bubble up the offending DECL and + return the maximum size. Otherwise return NULL. */ + tree -get_maxval_strlen (tree arg, int type) +get_maxval_strlen (tree arg, int type, tree *nonstr /* = NULL */) { bitmap visited = NULL; tree len[2] = { NULL_TREE, NULL_TREE }; bool dummy; - if (!get_range_strlen (arg, len, &visited, type, false, &dummy)) + /* Set to non-null if ARG refers to an untermianted array. */ + tree mynonstr = NULL_TREE; + if (!get_range_strlen (arg, len, &visited, type, 0, &dummy, 1, &mynonstr)) len[1] = NULL_TREE; if (visited) BITMAP_FREE (visited); - return len[1]; + if (nonstr) + { + /* For callers prepared to handle unterminated arrays set + *NONSTR to point to the declaration of the array and return + the maximum length/size. */ + *nonstr = mynonstr; + return len[1]; + } + + /* Fail if the constant array isn't nul-terminated. */ + return mynonstr ? NULL_TREE : len[1]; } @@ -1515,12 +1650,26 @@ gimple_fold_builtin_strcpy (gimple_stmt_iterator *gsi, tree dest, tree src) { - location_t loc = gimple_location (gsi_stmt (*gsi)); + gimple *stmt = gsi_stmt (*gsi); + location_t loc = gimple_location (stmt); tree fn; /* If SRC and DEST are the same (and not volatile), return DEST. */ if (operand_equal_p (src, dest, 0)) { + /* Issue -Wrestrict unless the pointers are null (those do + not point to objects and so do not indicate an overlap; + such calls could be the result of sanitization and jump + threading). */ + if (!integer_zerop (dest) && !gimple_no_warning_p (stmt)) + { + tree func = gimple_call_fndecl (stmt); + + warning_at (loc, OPT_Wrestrict, + "%qD source argument is the same as destination", + func); + } + replace_call_with_value (gsi, dest); return true; } @@ -1532,7 +1681,19 @@ if (!fn) return false; - tree len = get_maxval_strlen (src, 0); + /* Set to non-null if ARG refers to an unterminated array. */ + tree nonstr = NULL; + tree len = get_maxval_strlen (src, 0, &nonstr); + + if (nonstr) + { + /* Avoid folding calls with unterminated arrays. */ + if (!gimple_no_warning_p (stmt)) + warn_string_no_nul (loc, "strcpy", src, nonstr); + gimple_set_no_warning (stmt, true); + return false; + } + if (!len) return false; @@ -1553,12 +1714,33 @@ gimple_fold_builtin_strncpy (gimple_stmt_iterator *gsi, tree dest, tree src, tree len) { - location_t loc = gimple_location (gsi_stmt (*gsi)); - tree fn; + gimple *stmt = gsi_stmt (*gsi); + location_t loc = gimple_location (stmt); + bool nonstring = get_attr_nonstring_decl (dest) != NULL_TREE; /* If the LEN parameter is zero, return DEST. */ if (integer_zerop (len)) { + /* Avoid warning if the destination refers to a an array/pointer + decorate with attribute nonstring. */ + if (!nonstring) + { + tree fndecl = gimple_call_fndecl (stmt); + + /* Warn about the lack of nul termination: the result is not + a (nul-terminated) string. */ + tree slen = get_maxval_strlen (src, 0); + if (slen && !integer_zerop (slen)) + warning_at (loc, OPT_Wstringop_truncation, + "%G%qD destination unchanged after copying no bytes " + "from a string of length %E", + stmt, fndecl, slen); + else + warning_at (loc, OPT_Wstringop_truncation, + "%G%qD destination unchanged after copying no bytes", + stmt, fndecl); + } + replace_call_with_value (gsi, dest); return true; } @@ -1573,16 +1755,20 @@ if (!slen || TREE_CODE (slen) != INTEGER_CST) return false; - slen = size_binop_loc (loc, PLUS_EXPR, slen, ssize_int (1)); + /* The size of the source string including the terminating nul. */ + tree ssize = size_binop_loc (loc, PLUS_EXPR, slen, ssize_int (1)); /* We do not support simplification of this case, though we do support it when expanding trees into RTL. */ /* FIXME: generate a call to __builtin_memset. */ - if (tree_int_cst_lt (slen, len)) + if (tree_int_cst_lt (ssize, len)) return false; + /* Diagnose truncation that leaves the copy unterminated. */ + maybe_diag_stxncpy_trunc (*gsi, src, len); + /* OK transform into builtin memcpy. */ - fn = builtin_decl_implicit (BUILT_IN_MEMCPY); + tree fn = builtin_decl_implicit (BUILT_IN_MEMCPY); if (!fn) return false; @@ -1591,6 +1777,7 @@ NULL_TREE, true, GSI_SAME_STMT); gimple *repl = gimple_build_call (fn, 3, dest, src, len); replace_call_with_call_and_fold (gsi, repl); + return true; } @@ -1872,7 +2059,7 @@ static bool gimple_fold_builtin_strncat (gimple_stmt_iterator *gsi) { - gcall *stmt = as_a <gcall *> (gsi_stmt (*gsi)); + gimple *stmt = gsi_stmt (*gsi); tree dst = gimple_call_arg (stmt, 0); tree src = gimple_call_arg (stmt, 1); tree len = gimple_call_arg (stmt, 2); @@ -1887,24 +2074,73 @@ return true; } - /* If the requested len is greater than or equal to the string - length, call strcat. */ - if (TREE_CODE (len) == INTEGER_CST && p - && compare_tree_int (len, strlen (p)) >= 0) - { - tree fn = builtin_decl_implicit (BUILT_IN_STRCAT); - - /* If the replacement _DECL isn't initialized, don't do the - transformation. */ - if (!fn) - return false; - - gcall *repl = gimple_build_call (fn, 2, dst, src); - replace_call_with_call_and_fold (gsi, repl); - return true; - } - - return false; + if (TREE_CODE (len) != INTEGER_CST || !p) + return false; + + unsigned srclen = strlen (p); + + int cmpsrc = compare_tree_int (len, srclen); + + /* Return early if the requested len is less than the string length. + Warnings will be issued elsewhere later. */ + if (cmpsrc < 0) + return false; + + unsigned HOST_WIDE_INT dstsize; + + bool nowarn = gimple_no_warning_p (stmt); + + if (!nowarn && compute_builtin_object_size (dst, 1, &dstsize)) + { + int cmpdst = compare_tree_int (len, dstsize); + + if (cmpdst >= 0) + { + tree fndecl = gimple_call_fndecl (stmt); + + /* Strncat copies (at most) LEN bytes and always appends + the terminating NUL so the specified bound should never + be equal to (or greater than) the size of the destination. + If it is, the copy could overflow. */ + location_t loc = gimple_location (stmt); + nowarn = warning_at (loc, OPT_Wstringop_overflow_, + cmpdst == 0 + ? G_("%G%qD specified bound %E equals " + "destination size") + : G_("%G%qD specified bound %E exceeds " + "destination size %wu"), + stmt, fndecl, len, dstsize); + if (nowarn) + gimple_set_no_warning (stmt, true); + } + } + + if (!nowarn && cmpsrc == 0) + { + tree fndecl = gimple_call_fndecl (stmt); + location_t loc = gimple_location (stmt); + + /* To avoid possible overflow the specified bound should also + not be equal to the length of the source, even when the size + of the destination is unknown (it's not an uncommon mistake + to specify as the bound to strncpy the length of the source). */ + if (warning_at (loc, OPT_Wstringop_overflow_, + "%G%qD specified bound %E equals source length", + stmt, fndecl, len)) + gimple_set_no_warning (stmt, true); + } + + tree fn = builtin_decl_implicit (BUILT_IN_STRCAT); + + /* If the replacement _DECL isn't initialized, don't do the + transformation. */ + if (!fn) + return false; + + /* Otherwise, emit a call to strcat. */ + gcall *repl = gimple_build_call (fn, 2, dst, src); + replace_call_with_call_and_fold (gsi, repl); + return true; } /* Fold a call to the __strncat_chk builtin with arguments DEST, SRC, @@ -2037,12 +2273,14 @@ switch (fcode) { case BUILT_IN_STRCMP: + case BUILT_IN_STRCMP_EQ: { r = strcmp (p1, p2); known_result = true; break; } case BUILT_IN_STRNCMP: + case BUILT_IN_STRNCMP_EQ: { if (length == -1) break; @@ -2061,7 +2299,7 @@ r = strncmp (p1, p2, length); if (r == 0) known_result = true; - break;; + break; } default: gcc_unreachable (); @@ -2076,6 +2314,7 @@ bool nonzero_length = length >= 1 || fcode == BUILT_IN_STRCMP + || fcode == BUILT_IN_STRCMP_EQ || fcode == BUILT_IN_STRCASECMP; location_t loc = gimple_location (stmt); @@ -2141,6 +2380,21 @@ return true; } + /* If length is larger than the length of one constant string, + replace strncmp with corresponding strcmp */ + if (fcode == BUILT_IN_STRNCMP + && length > 0 + && ((p2 && (size_t) length > strlen (p2)) + || (p1 && (size_t) length > strlen (p1)))) + { + tree fn = builtin_decl_implicit (BUILT_IN_STRCMP); + if (!fn) + return false; + gimple *repl = gimple_build_call (fn, 2, str1, str2); + replace_call_with_call_and_fold (gsi, repl); + return true; + } + return false; } @@ -2404,6 +2658,19 @@ /* If SRC and DEST are the same (and not volatile), return DEST. */ if (fcode == BUILT_IN_STRCPY_CHK && operand_equal_p (src, dest, 0)) { + /* Issue -Wrestrict unless the pointers are null (those do + not point to objects and so do not indicate an overlap; + such calls could be the result of sanitization and jump + threading). */ + if (!integer_zerop (dest) && !gimple_no_warning_p (stmt)) + { + tree func = gimple_call_fndecl (stmt); + + warning_at (loc, OPT_Wrestrict, + "%qD source argument is the same as destination", + func); + } + replace_call_with_value (gsi, dest); return true; } @@ -2545,7 +2812,7 @@ location_t loc = gimple_location (stmt); tree dest = gimple_call_arg (stmt, 0); tree src = gimple_call_arg (stmt, 1); - tree fn, len, lenp1; + tree fn, lenp1; /* If the result is unused, replace stpcpy with strcpy. */ if (gimple_call_lhs (stmt) == NULL_TREE) @@ -2558,10 +2825,26 @@ return true; } - len = c_strlen (src, 1); + /* Set to non-null if ARG refers to an unterminated array. */ + c_strlen_data data; + memset (&data, 0, sizeof (c_strlen_data)); + tree len = c_strlen (src, 1, &data, 1); if (!len || TREE_CODE (len) != INTEGER_CST) - return false; + { + data.decl = unterminated_array (src); + if (!data.decl) + return false; + } + + if (data.decl) + { + /* Avoid folding calls with unterminated arrays. */ + if (!gimple_no_warning_p (stmt)) + warn_string_no_nul (loc, "stpcpy", src, data.decl); + gimple_set_no_warning (stmt, true); + return false; + } if (optimize_function_for_size_p (cfun) /* If length is zero it's small enough. */ @@ -2824,6 +3107,12 @@ 'format' is known to contain no % formats. */ gimple_seq stmts = NULL; gimple *repl = gimple_build_call (fn, 2, dest, fmt); + + /* Propagate the NO_WARNING bit to avoid issuing the same + warning more than once. */ + if (gimple_no_warning_p (stmt)) + gimple_set_no_warning (repl, true); + gimple_seq_add_stmt_without_update (&stmts, repl); if (gimple_call_lhs (stmt)) { @@ -2872,6 +3161,12 @@ /* Convert sprintf (str1, "%s", str2) into strcpy (str1, str2). */ gimple_seq stmts = NULL; gimple *repl = gimple_build_call (fn, 2, dest, orig); + + /* Propagate the NO_WARNING bit to avoid issuing the same + warning more than once. */ + if (gimple_no_warning_p (stmt)) + gimple_set_no_warning (repl, true); + gimple_seq_add_stmt_without_update (&stmts, repl); if (gimple_call_lhs (stmt)) { @@ -3234,23 +3529,13 @@ && (int) len > 0) { char *newstr; - tree offset_node, string_cst; /* Create a NUL-terminated string that's one char shorter than the original, stripping off the trailing '\n'. */ - newarg = build_string_literal (len, str); - string_cst = string_constant (newarg, &offset_node); - gcc_checking_assert (string_cst - && (TREE_STRING_LENGTH (string_cst) - == (int) len) - && integer_zerop (offset_node) - && (unsigned char) - TREE_STRING_POINTER (string_cst)[len - 1] - == target_newline); - /* build_string_literal creates a new STRING_CST, - modify it in place to avoid double copying. */ - newstr = CONST_CAST (char *, TREE_STRING_POINTER (string_cst)); + newstr = xstrdup (str); newstr[len - 1] = '\0'; + newarg = build_string_literal (len, newstr); + free (newstr); if (fn_puts) { gcall *repl = gimple_build_call (fn_puts, 1, newarg); @@ -3307,12 +3592,49 @@ gimple_fold_builtin_strlen (gimple_stmt_iterator *gsi) { gimple *stmt = gsi_stmt (*gsi); - tree len = get_maxval_strlen (gimple_call_arg (stmt, 0), 0); - if (!len) - return false; - len = force_gimple_operand_gsi (gsi, len, true, NULL, true, GSI_SAME_STMT); - replace_call_with_value (gsi, len); - return true; + tree arg = gimple_call_arg (stmt, 0); + + wide_int minlen; + wide_int maxlen; + + /* Set to non-null if ARG refers to an unterminated array. */ + tree nonstr; + tree lenrange[2]; + if (!get_range_strlen (arg, lenrange, 1, true, &nonstr) + && !nonstr + && lenrange[0] && TREE_CODE (lenrange[0]) == INTEGER_CST + && lenrange[1] && TREE_CODE (lenrange[1]) == INTEGER_CST) + { + /* The range of lengths refers to either a single constant + string or to the longest and shortest constant string + referenced by the argument of the strlen() call, or to + the strings that can possibly be stored in the arrays + the argument refers to. */ + minlen = wi::to_wide (lenrange[0]); + maxlen = wi::to_wide (lenrange[1]); + } + else + { + unsigned prec = TYPE_PRECISION (sizetype); + + minlen = wi::shwi (0, prec); + maxlen = wi::to_wide (max_object_size (), prec) - 2; + } + + if (minlen == maxlen) + { + lenrange[0] = force_gimple_operand_gsi (gsi, lenrange[0], true, NULL, + true, GSI_SAME_STMT); + replace_call_with_value (gsi, lenrange[0]); + return true; + } + + if (tree lhs = gimple_call_lhs (stmt)) + if (TREE_CODE (lhs) == SSA_NAME + && INTEGRAL_TYPE_P (TREE_TYPE (lhs))) + set_range_info (lhs, VR_RANGE, minlen, maxlen); + + return false; } /* Fold a call to __builtin_acc_on_device. */ @@ -3449,8 +3771,10 @@ case BUILT_IN_STRSTR: return gimple_fold_builtin_strstr (gsi); case BUILT_IN_STRCMP: + case BUILT_IN_STRCMP_EQ: case BUILT_IN_STRCASECMP: case BUILT_IN_STRNCMP: + case BUILT_IN_STRNCMP_EQ: case BUILT_IN_STRNCASECMP: return gimple_fold_builtin_string_compare (gsi); case BUILT_IN_MEMCHR: @@ -3566,15 +3890,23 @@ { int axis = oacc_get_ifn_dim_arg (call); int size = oacc_get_fn_dim_size (current_function_decl, axis); - bool is_pos = gimple_call_internal_fn (call) == IFN_GOACC_DIM_POS; tree result = NULL_TREE; - - /* If the size is 1, or we only want the size and it is not dynamic, - we know the answer. */ - if (size == 1 || (!is_pos && size)) - { - tree type = TREE_TYPE (gimple_call_lhs (call)); - result = build_int_cst (type, size - is_pos); + tree type = TREE_TYPE (gimple_call_lhs (call)); + + switch (gimple_call_internal_fn (call)) + { + case IFN_GOACC_DIM_POS: + /* If the size is 1, we know the answer. */ + if (size == 1) + result = build_int_cst (type, 0); + break; + case IFN_GOACC_DIM_SIZE: + /* If the size is not dynamic, we know the answer. */ + if (size) + result = build_int_cst (type, size); + break; + default: + break; } return result; @@ -3623,7 +3955,8 @@ /* Don't optimize floating point expected vars, VIEW_CONVERT_EXPRs might not preserve all the bits. See PR71716. */ || SCALAR_FLOAT_TYPE_P (etype) - || TYPE_PRECISION (etype) != GET_MODE_BITSIZE (TYPE_MODE (etype))) + || maybe_ne (TYPE_PRECISION (etype), + GET_MODE_BITSIZE (TYPE_MODE (etype)))) return false; tree weak = gimple_call_arg (stmt, 3); @@ -3639,7 +3972,7 @@ && optab_handler (sync_compare_and_swap_optab, mode) == CODE_FOR_nothing) return false; - if (int_size_in_bytes (etype) != GET_MODE_SIZE (mode)) + if (maybe_ne (int_size_in_bytes (etype), GET_MODE_SIZE (mode))) return false; return true; @@ -3690,7 +4023,7 @@ gimple_set_vuse (g, gimple_vuse (stmt)); SSA_NAME_DEF_STMT (gimple_vdef (g)) = g; tree oldlhs = gimple_call_lhs (stmt); - if (stmt_can_throw_internal (stmt)) + if (stmt_can_throw_internal (cfun, stmt)) { throws = true; e = find_fallthru_edge (gsi_bb (*gsi)->succs); @@ -3743,9 +4076,6 @@ arith_overflowed_p (enum tree_code code, const_tree type, const_tree arg0, const_tree arg1) { - typedef FIXED_WIDE_INT (WIDE_INT_MAX_PRECISION * 2) widest2_int; - typedef generic_wide_int <wi::extended_tree <WIDE_INT_MAX_PRECISION * 2> > - widest2_int_cst; widest2_int warg0 = widest2_int_cst (arg0); widest2_int warg1 = widest2_int_cst (arg1); widest2_int wres; @@ -3819,8 +4149,7 @@ tree lhs = gimple_call_lhs (stmt); if (dump_enabled_p ()) { - location_t loc = gimple_location_safe (stmt); - dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, loc, + dump_printf_loc (MSG_OPTIMIZED_LOCATIONS, stmt, "folding virtual function call to %s\n", targets.length () == 1 ? targets[0]->name () @@ -3927,7 +4256,8 @@ result = fold_builtin_expect (gimple_location (stmt), gimple_call_arg (stmt, 0), gimple_call_arg (stmt, 1), - gimple_call_arg (stmt, 2)); + gimple_call_arg (stmt, 2), + NULL_TREE); break; case IFN_UBSAN_OBJECT_SIZE: { @@ -4113,34 +4443,29 @@ static bool replace_stmt_with_simplification (gimple_stmt_iterator *gsi, - code_helper rcode, tree *ops, + gimple_match_op *res_op, gimple_seq *seq, bool inplace) { gimple *stmt = gsi_stmt (*gsi); + tree *ops = res_op->ops; + unsigned int num_ops = res_op->num_ops; /* Play safe and do not allow abnormals to be mentioned in newly created statements. See also maybe_push_res_to_seq. As an exception allow such uses if there was a use of the same SSA name on the old stmt. */ - if ((TREE_CODE (ops[0]) == SSA_NAME - && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ops[0]) - && !has_use_on_stmt (ops[0], stmt)) - || (ops[1] - && TREE_CODE (ops[1]) == SSA_NAME - && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ops[1]) - && !has_use_on_stmt (ops[1], stmt)) - || (ops[2] - && TREE_CODE (ops[2]) == SSA_NAME - && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ops[2]) - && !has_use_on_stmt (ops[2], stmt)) - || (COMPARISON_CLASS_P (ops[0]) - && ((TREE_CODE (TREE_OPERAND (ops[0], 0)) == SSA_NAME - && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (TREE_OPERAND (ops[0], 0)) - && !has_use_on_stmt (TREE_OPERAND (ops[0], 0), stmt)) - || (TREE_CODE (TREE_OPERAND (ops[0], 1)) == SSA_NAME - && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (TREE_OPERAND (ops[0], 1)) - && !has_use_on_stmt (TREE_OPERAND (ops[0], 1), stmt))))) - return false; + for (unsigned int i = 0; i < num_ops; ++i) + if (TREE_CODE (ops[i]) == SSA_NAME + && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ops[i]) + && !has_use_on_stmt (ops[i], stmt)) + return false; + + if (num_ops > 0 && COMPARISON_CLASS_P (ops[0])) + for (unsigned int i = 0; i < 2; ++i) + if (TREE_CODE (TREE_OPERAND (ops[0], i)) == SSA_NAME + && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (TREE_OPERAND (ops[0], i)) + && !has_use_on_stmt (TREE_OPERAND (ops[0], i), stmt)) + return false; /* Don't insert new statements when INPLACE is true, even if we could reuse STMT for the final statement. */ @@ -4149,19 +4474,19 @@ if (gcond *cond_stmt = dyn_cast <gcond *> (stmt)) { - gcc_assert (rcode.is_tree_code ()); - if (TREE_CODE_CLASS ((enum tree_code)rcode) == tcc_comparison + gcc_assert (res_op->code.is_tree_code ()); + if (TREE_CODE_CLASS ((enum tree_code) res_op->code) == tcc_comparison /* GIMPLE_CONDs condition may not throw. */ && (!flag_exceptions || !cfun->can_throw_non_call_exceptions - || !operation_could_trap_p (rcode, + || !operation_could_trap_p (res_op->code, FLOAT_TYPE_P (TREE_TYPE (ops[0])), false, NULL_TREE))) - gimple_cond_set_condition (cond_stmt, rcode, ops[0], ops[1]); - else if (rcode == SSA_NAME) + gimple_cond_set_condition (cond_stmt, res_op->code, ops[0], ops[1]); + else if (res_op->code == SSA_NAME) gimple_cond_set_condition (cond_stmt, NE_EXPR, ops[0], build_zero_cst (TREE_TYPE (ops[0]))); - else if (rcode == INTEGER_CST) + else if (res_op->code == INTEGER_CST) { if (integer_zerop (ops[0])) gimple_cond_make_false (cond_stmt); @@ -4170,8 +4495,7 @@ } else if (!inplace) { - tree res = maybe_push_res_to_seq (rcode, boolean_type_node, - ops, seq); + tree res = maybe_push_res_to_seq (res_op, seq); if (!res) return false; gimple_cond_set_condition (cond_stmt, NE_EXPR, res, @@ -4191,14 +4515,16 @@ return true; } else if (is_gimple_assign (stmt) - && rcode.is_tree_code ()) + && res_op->code.is_tree_code ()) { if (!inplace - || gimple_num_ops (stmt) > get_gimple_rhs_num_ops (rcode)) + || gimple_num_ops (stmt) > get_gimple_rhs_num_ops (res_op->code)) { - maybe_build_generic_op (rcode, - TREE_TYPE (gimple_assign_lhs (stmt)), ops); - gimple_assign_set_rhs_with_ops (gsi, rcode, ops[0], ops[1], ops[2]); + maybe_build_generic_op (res_op); + gimple_assign_set_rhs_with_ops (gsi, res_op->code, + res_op->op_or_null (0), + res_op->op_or_null (1), + res_op->op_or_null (2)); if (dump_file && (dump_flags & TDF_DETAILS)) { fprintf (dump_file, "gimple_simplified to "); @@ -4211,17 +4537,12 @@ return true; } } - else if (rcode.is_fn_code () - && gimple_call_combined_fn (stmt) == rcode) - { - unsigned i; - for (i = 0; i < gimple_call_num_args (stmt); ++i) - { - gcc_assert (ops[i] != NULL_TREE); - gimple_call_set_arg (stmt, i, ops[i]); - } - if (i < 3) - gcc_assert (ops[i] == NULL_TREE); + else if (res_op->code.is_fn_code () + && gimple_call_combined_fn (stmt) == res_op->code) + { + gcc_assert (num_ops == gimple_call_num_args (stmt)); + for (unsigned int i = 0; i < num_ops; ++i) + gimple_call_set_arg (stmt, i, ops[i]); if (dump_file && (dump_flags & TDF_DETAILS)) { fprintf (dump_file, "gimple_simplified to "); @@ -4237,8 +4558,7 @@ if (gimple_has_lhs (stmt)) { tree lhs = gimple_get_lhs (stmt); - if (!maybe_push_res_to_seq (rcode, TREE_TYPE (lhs), - ops, seq, lhs)) + if (!maybe_push_res_to_seq (res_op, seq, lhs)) return false; if (dump_file && (dump_flags & TDF_DETAILS)) { @@ -4317,7 +4637,7 @@ || handled_component_p (TREE_OPERAND (addr, 0)))) { tree base; - HOST_WIDE_INT coffset; + poly_int64 coffset; base = get_addr_base_and_unit_offset (TREE_OPERAND (addr, 0), &coffset); if (!base) @@ -4504,12 +4824,11 @@ || gimple_code (stmt) == GIMPLE_COND) { gimple_seq seq = NULL; - code_helper rcode; - tree ops[3] = {}; - if (gimple_simplify (stmt, &rcode, ops, inplace ? NULL : &seq, + gimple_match_op res_op; + if (gimple_simplify (stmt, &res_op, inplace ? NULL : &seq, valueize, valueize)) { - if (replace_stmt_with_simplification (gsi, rcode, ops, &seq, inplace)) + if (replace_stmt_with_simplification (gsi, &res_op, &seq, inplace)) changed = true; else gimple_seq_discard (seq); @@ -4720,6 +5039,14 @@ return val; } +/* Valueization callback that follows all SSA edges. */ + +tree +follow_all_ssa_edges (tree val) +{ + return val; +} + /* Fold the statement pointed to by GSI. In some cases, this function may replace the whole statement with a new one. Returns true iff folding makes any changes. @@ -5851,19 +6178,18 @@ gimple_fold_stmt_to_constant_1 (gimple *stmt, tree (*valueize) (tree), tree (*gvalueize) (tree)) { - code_helper rcode; - tree ops[3] = {}; + gimple_match_op res_op; /* ??? The SSA propagators do not correctly deal with following SSA use-def edges if there are intermediate VARYING defs. For this reason do not follow SSA edges here even though SCCVN can technically just deal fine with that. */ - if (gimple_simplify (stmt, &rcode, ops, NULL, gvalueize, valueize)) + if (gimple_simplify (stmt, &res_op, NULL, gvalueize, valueize)) { tree res = NULL_TREE; - if (gimple_simplified_result_is_gimple_val (rcode, ops)) - res = ops[0]; + if (gimple_simplified_result_is_gimple_val (&res_op)) + res = res_op.ops[0]; else if (mprts_hook) - res = mprts_hook (rcode, gimple_expr_type (stmt), ops); + res = mprts_hook (&res_op); if (res) { if (dump_file && dump_flags & TDF_DETAILS) @@ -5903,7 +6229,7 @@ else if (TREE_CODE (rhs) == ADDR_EXPR && !is_gimple_min_invariant (rhs)) { - HOST_WIDE_INT offset = 0; + poly_int64 offset = 0; tree base; base = get_addr_base_and_unit_offset_1 (TREE_OPERAND (rhs, 0), &offset, @@ -5916,14 +6242,14 @@ } else if (TREE_CODE (rhs) == CONSTRUCTOR && TREE_CODE (TREE_TYPE (rhs)) == VECTOR_TYPE - && (CONSTRUCTOR_NELTS (rhs) - == TYPE_VECTOR_SUBPARTS (TREE_TYPE (rhs)))) + && known_eq (CONSTRUCTOR_NELTS (rhs), + TYPE_VECTOR_SUBPARTS (TREE_TYPE (rhs)))) { unsigned i, nelts; tree val; - nelts = TYPE_VECTOR_SUBPARTS (TREE_TYPE (rhs)); - auto_vec<tree, 32> vec (nelts); + nelts = CONSTRUCTOR_NELTS (rhs); + tree_vector_builder vec (TREE_TYPE (rhs), nelts, 1); FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (rhs), i, val) { val = (*valueize) (val); @@ -5935,7 +6261,7 @@ return NULL_TREE; } - return build_vector (TREE_TYPE (rhs), vec); + return vec.build (); } if (subcode == OBJ_TYPE_REF) { @@ -6115,8 +6441,7 @@ fn = (*valueize) (gimple_call_fn (stmt)); if (TREE_CODE (fn) == ADDR_EXPR - && TREE_CODE (TREE_OPERAND (fn, 0)) == FUNCTION_DECL - && DECL_BUILT_IN (TREE_OPERAND (fn, 0)) + && fndecl_built_in_p (TREE_OPERAND (fn, 0)) && gimple_builtin_call_types_compatible_p (stmt, TREE_OPERAND (fn, 0))) { @@ -6171,21 +6496,17 @@ is not explicitly available, but it is known to be zero such as 'static const int a;'. */ static tree -get_base_constructor (tree base, HOST_WIDE_INT *bit_offset, +get_base_constructor (tree base, poly_int64_pod *bit_offset, tree (*valueize)(tree)) { - HOST_WIDE_INT bit_offset2, size, max_size; + poly_int64 bit_offset2, size, max_size; bool reverse; if (TREE_CODE (base) == MEM_REF) { - if (!integer_zerop (TREE_OPERAND (base, 1))) - { - if (!tree_fits_shwi_p (TREE_OPERAND (base, 1))) - return NULL_TREE; - *bit_offset += (mem_ref_offset (base).to_short_addr () - * BITS_PER_UNIT); - } + poly_offset_int boff = *bit_offset + mem_ref_offset (base) * BITS_PER_UNIT; + if (!boff.to_shwi (bit_offset)) + return NULL_TREE; if (valueize && TREE_CODE (TREE_OPERAND (base, 0)) == SSA_NAME) @@ -6226,7 +6547,7 @@ case COMPONENT_REF: base = get_ref_base_and_extent (base, &bit_offset2, &size, &max_size, &reverse); - if (max_size == -1 || size != max_size) + if (!known_size_p (max_size) || maybe_ne (size, max_size)) return NULL_TREE; *bit_offset += bit_offset2; return get_base_constructor (base, bit_offset, valueize); @@ -6242,14 +6563,19 @@ } } -/* CTOR is CONSTRUCTOR of an array type. Fold reference of type TYPE and size - SIZE to the memory at bit OFFSET. */ +/* CTOR is CONSTRUCTOR of an array type. Fold a reference of SIZE bits + to the memory at bit OFFSET. When non-null, TYPE is the expected + type of the reference; otherwise the type of the referenced element + is used instead. When SIZE is zero, attempt to fold a reference to + the entire element which OFFSET refers to. Increment *SUBOFF by + the bit offset of the accessed element. */ static tree fold_array_ctor_reference (tree type, tree ctor, unsigned HOST_WIDE_INT offset, unsigned HOST_WIDE_INT size, - tree from_decl) + tree from_decl, + unsigned HOST_WIDE_INT *suboff) { offset_int low_bound; offset_int elt_size; @@ -6274,12 +6600,13 @@ return NULL_TREE; elt_size = wi::to_offset (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (ctor)))); - /* We can handle only constantly sized accesses that are known to not - be larger than size of array element. */ - if (!TYPE_SIZE_UNIT (type) - || TREE_CODE (TYPE_SIZE_UNIT (type)) != INTEGER_CST - || elt_size < wi::to_offset (TYPE_SIZE_UNIT (type)) - || elt_size == 0) + /* When TYPE is non-null, verify that it specifies a constant-sized + accessed not larger than size of array element. */ + if (type + && (!TYPE_SIZE_UNIT (type) + || TREE_CODE (TYPE_SIZE_UNIT (type)) != INTEGER_CST + || elt_size < wi::to_offset (TYPE_SIZE_UNIT (type)) + || elt_size == 0)) return NULL_TREE; /* Compute the array index we look for. */ @@ -6295,21 +6622,42 @@ if (inner_offset + size > elt_size.to_uhwi () * BITS_PER_UNIT) return NULL_TREE; if (tree val = get_array_ctor_element_at_index (ctor, access_index)) - return fold_ctor_reference (type, val, inner_offset, size, from_decl); - - /* When memory is not explicitely mentioned in constructor, - it is 0 (or out of range). */ - return build_zero_cst (type); + { + if (!size && TREE_CODE (val) != CONSTRUCTOR) + { + /* For the final reference to the entire accessed element + (SIZE is zero), reset INNER_OFFSET, disegard TYPE (which + may be null) in favor of the type of the element, and set + SIZE to the size of the accessed element. */ + inner_offset = 0; + type = TREE_TYPE (val); + size = elt_size.to_uhwi () * BITS_PER_UNIT; + } + + *suboff += (access_index * elt_size * BITS_PER_UNIT).to_uhwi (); + return fold_ctor_reference (type, val, inner_offset, size, from_decl, + suboff); + } + + /* Memory not explicitly mentioned in constructor is 0 (or + the reference is out of range). */ + return type ? build_zero_cst (type) : NULL_TREE; } -/* CTOR is CONSTRUCTOR of an aggregate or vector. - Fold reference of type TYPE and size SIZE to the memory at bit OFFSET. */ +/* CTOR is CONSTRUCTOR of an aggregate or vector. Fold a reference + of SIZE bits to the memory at bit OFFSET. When non-null, TYPE + is the expected type of the reference; otherwise the type of + the referenced member is used instead. When SIZE is zero, + attempt to fold a reference to the entire member which OFFSET + refers to; in this case. Increment *SUBOFF by the bit offset + of the accessed member. */ static tree fold_nonarray_ctor_reference (tree type, tree ctor, unsigned HOST_WIDE_INT offset, unsigned HOST_WIDE_INT size, - tree from_decl) + tree from_decl, + unsigned HOST_WIDE_INT *suboff) { unsigned HOST_WIDE_INT cnt; tree cfield, cval; @@ -6320,8 +6668,13 @@ tree byte_offset = DECL_FIELD_OFFSET (cfield); tree field_offset = DECL_FIELD_BIT_OFFSET (cfield); tree field_size = DECL_SIZE (cfield); - offset_int bitoffset; - offset_int bitoffset_end, access_end; + + if (!field_size) + { + /* Determine the size of the flexible array member from + the size of the initializer provided for it. */ + field_size = TYPE_SIZE (TREE_TYPE (cval)); + } /* Variable sized objects in static constructors makes no sense, but field_size can be NULL for flexible array members. */ @@ -6332,53 +6685,90 @@ : TREE_CODE (TREE_TYPE (cfield)) == ARRAY_TYPE)); /* Compute bit offset of the field. */ - bitoffset = (wi::to_offset (field_offset) - + (wi::to_offset (byte_offset) << LOG2_BITS_PER_UNIT)); + offset_int bitoffset + = (wi::to_offset (field_offset) + + (wi::to_offset (byte_offset) << LOG2_BITS_PER_UNIT)); /* Compute bit offset where the field ends. */ + offset_int bitoffset_end; if (field_size != NULL_TREE) bitoffset_end = bitoffset + wi::to_offset (field_size); else bitoffset_end = 0; - access_end = offset_int (offset) + size; - - /* Is there any overlap between [OFFSET, OFFSET+SIZE) and - [BITOFFSET, BITOFFSET_END)? */ + /* Compute the bit offset of the end of the desired access. + As a special case, if the size of the desired access is + zero, assume the access is to the entire field (and let + the caller make any necessary adjustments by storing + the actual bounds of the field in FIELDBOUNDS). */ + offset_int access_end = offset_int (offset); + if (size) + access_end += size; + else + access_end = bitoffset_end; + + /* Is there any overlap between the desired access at + [OFFSET, OFFSET+SIZE) and the offset of the field within + the object at [BITOFFSET, BITOFFSET_END)? */ if (wi::cmps (access_end, bitoffset) > 0 && (field_size == NULL_TREE || wi::lts_p (offset, bitoffset_end))) { - offset_int inner_offset = offset_int (offset) - bitoffset; - /* We do have overlap. Now see if field is large enough to - cover the access. Give up for accesses spanning multiple - fields. */ + *suboff += bitoffset.to_uhwi (); + + if (!size && TREE_CODE (cval) != CONSTRUCTOR) + { + /* For the final reference to the entire accessed member + (SIZE is zero), reset OFFSET, disegard TYPE (which may + be null) in favor of the type of the member, and set + SIZE to the size of the accessed member. */ + offset = bitoffset.to_uhwi (); + type = TREE_TYPE (cval); + size = (bitoffset_end - bitoffset).to_uhwi (); + } + + /* We do have overlap. Now see if the field is large enough + to cover the access. Give up for accesses that extend + beyond the end of the object or that span multiple fields. */ if (wi::cmps (access_end, bitoffset_end) > 0) return NULL_TREE; if (offset < bitoffset) return NULL_TREE; + + offset_int inner_offset = offset_int (offset) - bitoffset; return fold_ctor_reference (type, cval, inner_offset.to_uhwi (), size, - from_decl); + from_decl, suboff); } } - /* When memory is not explicitely mentioned in constructor, it is 0. */ - return build_zero_cst (type); + /* Memory not explicitly mentioned in constructor is 0. */ + return type ? build_zero_cst (type) : NULL_TREE; } -/* CTOR is value initializing memory, fold reference of type TYPE and size SIZE - to the memory at bit OFFSET. */ +/* CTOR is value initializing memory. Fold a reference of TYPE and + bit size POLY_SIZE to the memory at bit POLY_OFFSET. When SIZE + is zero, attempt to fold a reference to the entire subobject + which OFFSET refers to. This is used when folding accesses to + string members of aggregates. When non-null, set *SUBOFF to + the bit offset of the accessed subobject. */ tree -fold_ctor_reference (tree type, tree ctor, unsigned HOST_WIDE_INT offset, - unsigned HOST_WIDE_INT size, tree from_decl) +fold_ctor_reference (tree type, tree ctor, const poly_uint64 &poly_offset, + const poly_uint64 &poly_size, tree from_decl, + unsigned HOST_WIDE_INT *suboff /* = NULL */) { tree ret; /* We found the field with exact match. */ - if (useless_type_conversion_p (type, TREE_TYPE (ctor)) - && !offset) + if (type + && useless_type_conversion_p (type, TREE_TYPE (ctor)) + && known_eq (poly_offset, 0U)) return canonicalize_constructor_val (unshare_expr (ctor), from_decl); + /* The remaining optimizations need a constant size and offset. */ + unsigned HOST_WIDE_INT size, offset; + if (!poly_size.is_constant (&size) || !poly_offset.is_constant (&offset)) + return NULL_TREE; + /* We are at the end of walk, see if we can view convert the result. */ if (!AGGREGATE_TYPE_P (TREE_TYPE (ctor)) && !offset @@ -6411,14 +6801,17 @@ } if (TREE_CODE (ctor) == CONSTRUCTOR) { + unsigned HOST_WIDE_INT dummy = 0; + if (!suboff) + suboff = &dummy; if (TREE_CODE (TREE_TYPE (ctor)) == ARRAY_TYPE || TREE_CODE (TREE_TYPE (ctor)) == VECTOR_TYPE) return fold_array_ctor_reference (type, ctor, offset, size, - from_decl); - else - return fold_nonarray_ctor_reference (type, ctor, offset, size, - from_decl); + from_decl, suboff); + + return fold_nonarray_ctor_reference (type, ctor, offset, size, + from_decl, suboff); } return NULL_TREE; @@ -6432,7 +6825,7 @@ fold_const_aggregate_ref_1 (tree t, tree (*valueize) (tree)) { tree ctor, idx, base; - HOST_WIDE_INT offset, size, max_size; + poly_int64 offset, size, max_size; tree tem; bool reverse; @@ -6458,23 +6851,23 @@ if (TREE_CODE (TREE_OPERAND (t, 1)) == SSA_NAME && valueize && (idx = (*valueize) (TREE_OPERAND (t, 1))) - && TREE_CODE (idx) == INTEGER_CST) + && poly_int_tree_p (idx)) { tree low_bound, unit_size; /* If the resulting bit-offset is constant, track it. */ if ((low_bound = array_ref_low_bound (t), - TREE_CODE (low_bound) == INTEGER_CST) + poly_int_tree_p (low_bound)) && (unit_size = array_ref_element_size (t), tree_fits_uhwi_p (unit_size))) { - offset_int woffset - = wi::sext (wi::to_offset (idx) - wi::to_offset (low_bound), + poly_offset_int woffset + = wi::sext (wi::to_poly_offset (idx) + - wi::to_poly_offset (low_bound), TYPE_PRECISION (TREE_TYPE (idx))); - if (wi::fits_shwi_p (woffset)) + if (woffset.to_shwi (&offset)) { - offset = woffset.to_shwi (); /* TODO: This code seems wrong, multiply then check to see if it fits. */ offset *= tree_to_uhwi (unit_size); @@ -6487,7 +6880,7 @@ return build_zero_cst (TREE_TYPE (t)); /* Out of bound array access. Value is undefined, but don't fold. */ - if (offset < 0) + if (maybe_lt (offset, 0)) return NULL_TREE; /* We can not determine ctor. */ if (!ctor) @@ -6512,14 +6905,14 @@ if (ctor == error_mark_node) return build_zero_cst (TREE_TYPE (t)); /* We do not know precise address. */ - if (max_size == -1 || max_size != size) + if (!known_size_p (max_size) || maybe_ne (max_size, size)) return NULL_TREE; /* We can not determine ctor. */ if (!ctor) return NULL_TREE; /* Out of bound array access. Value is undefined, but don't fold. */ - if (offset < 0) + if (maybe_lt (offset, 0)) return NULL_TREE; return fold_ctor_reference (TREE_TYPE (t), ctor, offset, size, @@ -6586,7 +6979,6 @@ gcc_assert (init); if (init == error_mark_node) { - gcc_assert (in_lto_p); /* Pass down that we lost track of the target. */ if (can_refer) *can_refer = false; @@ -6612,12 +7004,13 @@ access_index = offset / BITS_PER_UNIT / elt_size; gcc_checking_assert (offset % (elt_size * BITS_PER_UNIT) == 0); - /* This code makes an assumption that there are no - indexed fileds produced by C++ FE, so we can directly index the array. */ + /* The C++ FE can now produce indexed fields, and we check if the indexes + match. */ if (access_index < CONSTRUCTOR_NELTS (init)) { fn = CONSTRUCTOR_ELT (init, access_index)->value; - gcc_checking_assert (!CONSTRUCTOR_ELT (init, access_index)->index); + tree idx = CONSTRUCTOR_ELT (init, access_index)->index; + gcc_checking_assert (!idx || tree_to_uhwi (idx) == access_index); STRIP_NOPS (fn); } else @@ -6763,8 +7156,8 @@ = tree_to_shwi (part_width) / BITS_PER_UNIT; unsigned HOST_WIDE_INT indexi = offset * BITS_PER_UNIT; tree index = bitsize_int (indexi); - if (offset / part_widthi - < TYPE_VECTOR_SUBPARTS (TREE_TYPE (addrtype))) + if (known_lt (offset / part_widthi, + TYPE_VECTOR_SUBPARTS (TREE_TYPE (addrtype)))) return fold_build3 (BIT_FIELD_REF, type, TREE_OPERAND (addr, 0), part_width, index); } @@ -6957,14 +7350,20 @@ statements possibly defining it to SEQ. */ tree -gimple_build (gimple_seq *seq, location_t loc, - enum built_in_function fn, tree type, tree arg0) +gimple_build (gimple_seq *seq, location_t loc, combined_fn fn, + tree type, tree arg0) { tree res = gimple_simplify (fn, type, arg0, seq, gimple_build_valueize); if (!res) { - tree decl = builtin_decl_implicit (fn); - gimple *stmt = gimple_build_call (decl, 1, arg0); + gcall *stmt; + if (internal_fn_p (fn)) + stmt = gimple_build_call_internal (as_internal_fn (fn), 1, arg0); + else + { + tree decl = builtin_decl_implicit (as_builtin_fn (fn)); + stmt = gimple_build_call (decl, 1, arg0); + } if (!VOID_TYPE_P (type)) { res = create_tmp_reg_or_ssa_name (type); @@ -6983,14 +7382,20 @@ statements possibly defining it to SEQ. */ tree -gimple_build (gimple_seq *seq, location_t loc, - enum built_in_function fn, tree type, tree arg0, tree arg1) +gimple_build (gimple_seq *seq, location_t loc, combined_fn fn, + tree type, tree arg0, tree arg1) { tree res = gimple_simplify (fn, type, arg0, arg1, seq, gimple_build_valueize); if (!res) { - tree decl = builtin_decl_implicit (fn); - gimple *stmt = gimple_build_call (decl, 2, arg0, arg1); + gcall *stmt; + if (internal_fn_p (fn)) + stmt = gimple_build_call_internal (as_internal_fn (fn), 2, arg0, arg1); + else + { + tree decl = builtin_decl_implicit (as_builtin_fn (fn)); + stmt = gimple_build_call (decl, 2, arg0, arg1); + } if (!VOID_TYPE_P (type)) { res = create_tmp_reg_or_ssa_name (type); @@ -7009,16 +7414,22 @@ statements possibly defining it to SEQ. */ tree -gimple_build (gimple_seq *seq, location_t loc, - enum built_in_function fn, tree type, - tree arg0, tree arg1, tree arg2) +gimple_build (gimple_seq *seq, location_t loc, combined_fn fn, + tree type, tree arg0, tree arg1, tree arg2) { tree res = gimple_simplify (fn, type, arg0, arg1, arg2, seq, gimple_build_valueize); if (!res) { - tree decl = builtin_decl_implicit (fn); - gimple *stmt = gimple_build_call (decl, 3, arg0, arg1, arg2); + gcall *stmt; + if (internal_fn_p (fn)) + stmt = gimple_build_call_internal (as_internal_fn (fn), + 3, arg0, arg1, arg2); + else + { + tree decl = builtin_decl_implicit (as_builtin_fn (fn)); + stmt = gimple_build_call (decl, 3, arg0, arg1, arg2); + } if (!VOID_TYPE_P (type)) { res = create_tmp_reg_or_ssa_name (type); @@ -7066,6 +7477,10 @@ gimple_build_vector_from_val (gimple_seq *seq, location_t loc, tree type, tree op) { + if (!TYPE_VECTOR_SUBPARTS (type).is_constant () + && !CONSTANT_CLASS_P (op)) + return gimple_build (seq, loc, VEC_DUPLICATE_EXPR, type, op); + tree res, vec = build_vector_from_val (type, op); if (is_gimple_val (vec)) return vec; @@ -7079,23 +7494,30 @@ return res; } -/* Build a vector of type TYPE in which the elements have the values - given by ELTS. Return a gimple value for the result, appending any - new instructions to SEQ. */ +/* Build a vector from BUILDER, handling the case in which some elements + are non-constant. Return a gimple value for the result, appending any + new instructions to SEQ. + + BUILDER must not have a stepped encoding on entry. This is because + the function is not geared up to handle the arithmetic that would + be needed in the variable case, and any code building a vector that + is known to be constant should use BUILDER->build () directly. */ tree -gimple_build_vector (gimple_seq *seq, location_t loc, tree type, - vec<tree> elts) +gimple_build_vector (gimple_seq *seq, location_t loc, + tree_vector_builder *builder) { - unsigned int nelts = elts.length (); - gcc_assert (nelts == TYPE_VECTOR_SUBPARTS (type)); - for (unsigned int i = 0; i < nelts; ++i) - if (!TREE_CONSTANT (elts[i])) + gcc_assert (builder->nelts_per_pattern () <= 2); + unsigned int encoded_nelts = builder->encoded_nelts (); + for (unsigned int i = 0; i < encoded_nelts; ++i) + if (!TREE_CONSTANT ((*builder)[i])) { + tree type = builder->type (); + unsigned int nelts = TYPE_VECTOR_SUBPARTS (type).to_constant (); vec<constructor_elt, va_gc> *v; vec_alloc (v, nelts); for (i = 0; i < nelts; ++i) - CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, elts[i]); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, builder->elt (i)); tree res; if (gimple_in_ssa_p (cfun)) @@ -7107,7 +7529,7 @@ gimple_seq_add_stmt_without_update (seq, stmt); return res; } - return build_vector (type, elts); + return builder->build (); } /* Return true if the result of assignment STMT is known to be non-negative.