On Thu, Oct 26, 2017 at 2:23 PM, Richard Biener <richard.guent...@gmail.com> wrote: > On Mon, Oct 23, 2017 at 1:20 PM, Richard Sandiford > <richard.sandif...@linaro.org> wrote: >> Similarly to the VEC_DUPLICATE_{CST,EXPR}, this patch adds two >> tree code equivalents of the VEC_SERIES rtx code. VEC_SERIES_EXPR >> is for non-constant inputs and is a normal tcc_binary. VEC_SERIES_CST >> is a tcc_constant. >> >> Like VEC_DUPLICATE_CST, VEC_SERIES_CST is only used for variable-length >> vectors. This avoids the need to handle combinations of VECTOR_CST >> and VEC_SERIES_CST. > > Similar to the other patch can you document and verify that VEC_SERIES_CST > is only used on variable length vectors? > > Ok with that change.
Btw, did you think of merging VEC_DUPLICATE_CST with VEC_SERIES_CST via setting step == 0? I think you can do {1, 1, 1, 1... } + {1, 2,3 ,4,5 } constant folding but you don't implement that. Propagation can also turn VEC_SERIES_EXPR into VEC_SERIES_CST and VEC_DUPLICATE_EXPR into VEC_DUPLICATE_CST (didn't see the former, don't remember the latter). Richard. > Thanks, > Richard. > >> >> 2017-10-23 Richard Sandiford <richard.sandif...@linaro.org> >> Alan Hayward <alan.hayw...@arm.com> >> David Sherwood <david.sherw...@arm.com> >> >> gcc/ >> * doc/generic.texi (VEC_SERIES_CST, VEC_SERIES_EXPR): Document. >> * doc/md.texi (vec_series@var{m}): Document. >> * tree.def (VEC_SERIES_CST, VEC_SERIES_EXPR): New tree codes. >> * tree.h (TREE_OVERFLOW): Add VEC_SERIES_CST to the list of valid >> codes. >> (VEC_SERIES_CST_BASE, VEC_SERIES_CST_STEP): New macros. >> (build_vec_series_cst, build_vec_series): Declare. >> * tree.c (tree_node_structure_for_code, tree_code_size, tree_size) >> (add_expr, walk_tree_1, drop_tree_overflow): Handle VEC_SERIES_CST. >> (build_vec_series_cst, build_vec_series): New functions. >> * cfgexpand.c (expand_debug_expr): Handle the new codes. >> * tree-pretty-print.c (dump_generic_node): Likewise. >> * dwarf2out.c (rtl_for_decl_init): Handle VEC_SERIES_CST. >> * gimple-expr.h (is_gimple_constant): Likewise. >> * gimplify.c (gimplify_expr): Likewise. >> * graphite-scop-detection.c (scan_tree_for_params): Likewise. >> * ipa-icf-gimple.c (func_checker::compare_cst_or_decl): Likewise. >> (func_checker::compare_operand): Likewise. >> * ipa-icf.c (sem_item::add_expr, sem_variable::equals): Likewise. >> * print-tree.c (print_node): Likewise. >> * tree-ssa-loop.c (for_each_index): Likewise. >> * tree-ssa-pre.c (create_component_ref_by_pieces_1): Likewise. >> * tree-ssa-sccvn.c (copy_reference_ops_from_ref): Likewise. >> (ao_ref_init_from_vn_reference): Likewise. >> * varasm.c (const_hash_1, compare_constant): Likewise. >> * fold-const.c (negate_expr_p, fold_negate_expr_1, operand_equal_p) >> (fold_checksum_tree): Likewise. >> (vec_series_equivalent_p): New function. >> (const_binop): Use it. Fold VEC_SERIES_EXPRs of constants. >> * expmed.c (make_tree): Handle VEC_SERIES. >> * gimple-pretty-print.c (dump_binary_rhs): Likewise. >> * tree-inline.c (estimate_operator_cost): Likewise. >> * expr.c (const_vector_element): Include VEC_SERIES_CST in comment. >> (expand_expr_real_2): Handle VEC_SERIES_EXPR. >> (expand_expr_real_1): Handle VEC_SERIES_CST. >> * optabs.def (vec_series_optab): New optab. >> * optabs.h (expand_vec_series_expr): Declare. >> * optabs.c (expand_vec_series_expr): New function. >> * optabs-tree.c (optab_for_tree_code): Handle VEC_SERIES_EXPR. >> * tree-cfg.c (verify_gimple_assign_binary): Handle VEC_SERIES_EXPR. >> (verify_gimple_assign_single): Handle VEC_SERIES_CST. >> * tree-vect-generic.c (expand_vector_operations_1): Check that >> the operands also have vector type. >> >> Index: gcc/doc/generic.texi >> =================================================================== >> --- gcc/doc/generic.texi 2017-10-23 11:41:51.760448406 +0100 >> +++ gcc/doc/generic.texi 2017-10-23 11:42:34.910720660 +0100 >> @@ -1037,6 +1037,7 @@ As this example indicates, the operands >> @tindex COMPLEX_CST >> @tindex VECTOR_CST >> @tindex VEC_DUPLICATE_CST >> +@tindex VEC_SERIES_CST >> @tindex STRING_CST >> @findex TREE_STRING_LENGTH >> @findex TREE_STRING_POINTER >> @@ -1098,6 +1099,16 @@ instead. The scalar element value is gi >> @code{VEC_DUPLICATE_CST_ELT} and has the same restrictions as the >> element of a @code{VECTOR_CST}. >> >> +@item VEC_SERIES_CST >> +These nodes represent a vector constant in which element @var{i} >> +has the value @samp{@var{base} + @var{i} * @var{step}}, for some >> +constant @var{base} and @var{step}. The value of @var{base} is >> +given by @code{VEC_SERIES_CST_BASE} and the value of @var{step} is >> +given by @code{VEC_SERIES_CST_STEP}. >> + >> +These nodes are restricted to integral types, in order to avoid >> +specifying the rounding behavior for floating-point types. >> + >> @item STRING_CST >> These nodes represent string-constants. The @code{TREE_STRING_LENGTH} >> returns the length of the string, as an @code{int}. The >> @@ -1702,6 +1713,7 @@ a value from @code{enum annot_expr_kind} >> @node Vectors >> @subsection Vectors >> @tindex VEC_DUPLICATE_EXPR >> +@tindex VEC_SERIES_EXPR >> @tindex VEC_LSHIFT_EXPR >> @tindex VEC_RSHIFT_EXPR >> @tindex VEC_WIDEN_MULT_HI_EXPR >> @@ -1721,6 +1733,14 @@ a value from @code{enum annot_expr_kind} >> This node has a single operand and represents a vector in which every >> element is equal to that operand. >> >> +@item VEC_SERIES_EXPR >> +This node represents a vector formed from a scalar base and step, >> +given as the first and second operands respectively. Element @var{i} >> +of the result is equal to @samp{@var{base} + @var{i}*@var{step}}. >> + >> +This node is restricted to integral types, in order to avoid >> +specifying the rounding behavior for floating-point types. >> + >> @item VEC_LSHIFT_EXPR >> @itemx VEC_RSHIFT_EXPR >> These nodes represent whole vector left and right shifts, respectively. >> Index: gcc/doc/md.texi >> =================================================================== >> --- gcc/doc/md.texi 2017-10-23 11:41:51.761413027 +0100 >> +++ gcc/doc/md.texi 2017-10-23 11:42:34.911720660 +0100 >> @@ -4899,6 +4899,19 @@ vectors go through the @code{mov@var{m}} >> >> This pattern is not allowed to @code{FAIL}. >> >> +@cindex @code{vec_series@var{m}} instruction pattern >> +@item @samp{vec_series@var{m}} >> +Initialize vector output operand 0 so that element @var{i} is equal to >> +operand 1 plus @var{i} times operand 2. In other words, create a linear >> +series whose base value is operand 1 and whose step is operand 2. >> + >> +The vector output has mode @var{m} and the scalar inputs have the mode >> +appropriate for one element of @var{m}. This pattern is not used for >> +floating-point vectors, in order to avoid having to specify the >> +rounding behavior for @var{i} > 1. >> + >> +This pattern is not allowed to @code{FAIL}. >> + >> @cindex @code{vec_cmp@var{m}@var{n}} instruction pattern >> @item @samp{vec_cmp@var{m}@var{n}} >> Output a vector comparison. Operand 0 of mode @var{n} is the destination >> for >> Index: gcc/tree.def >> =================================================================== >> --- gcc/tree.def 2017-10-23 11:41:51.774917721 +0100 >> +++ gcc/tree.def 2017-10-23 11:42:34.924720660 +0100 >> @@ -308,6 +308,10 @@ DEFTREECODE (VECTOR_CST, "vector_cst", t >> VEC_DUPLICATE_CST_ELT. */ >> DEFTREECODE (VEC_DUPLICATE_CST, "vec_duplicate_cst", tcc_constant, 0) >> >> +/* Represents a vector constant in which element i is equal to >> + VEC_SERIES_CST_BASE + i * VEC_SERIES_CST_STEP. */ >> +DEFTREECODE (VEC_SERIES_CST, "vec_series_cst", tcc_constant, 0) >> + >> /* Contents are TREE_STRING_LENGTH and the actual contents of the string. >> */ >> DEFTREECODE (STRING_CST, "string_cst", tcc_constant, 0) >> >> @@ -541,6 +545,16 @@ DEFTREECODE (COND_EXPR, "cond_expr", tcc >> /* Represents a vector in which every element is equal to operand 0. */ >> DEFTREECODE (VEC_DUPLICATE_EXPR, "vec_duplicate_expr", tcc_unary, 1) >> >> +/* Vector series created from a start (base) value and a step. >> + >> + A = VEC_SERIES_EXPR (B, C) >> + >> + means >> + >> + for (i = 0; i < N; i++) >> + A[i] = B + C * i; */ >> +DEFTREECODE (VEC_SERIES_EXPR, "vec_series_expr", tcc_binary, 2) >> + >> /* Vector conditional expression. It is like COND_EXPR, but with >> vector operands. >> >> Index: gcc/tree.h >> =================================================================== >> --- gcc/tree.h 2017-10-23 11:41:51.775882341 +0100 >> +++ gcc/tree.h 2017-10-23 11:42:34.925720660 +0100 >> @@ -730,8 +730,8 @@ #define TREE_SYMBOL_REFERENCED(NODE) \ >> #define TYPE_REF_CAN_ALIAS_ALL(NODE) \ >> (PTR_OR_REF_CHECK (NODE)->base.static_flag) >> >> -/* In an INTEGER_CST, REAL_CST, COMPLEX_CST, VECTOR_CST or >> VEC_DUPLICATE_CST, >> - this means there was an overflow in folding. */ >> +/* In an INTEGER_CST, REAL_CST, COMPLEX_CST, VECTOR_CST, VEC_DUPLICATE_CST >> + or VEC_SERES_CST, this means there was an overflow in folding. */ >> >> #define TREE_OVERFLOW(NODE) (CST_CHECK (NODE)->base.public_flag) >> >> @@ -1034,6 +1034,12 @@ #define VECTOR_CST_ELT(NODE,IDX) (VECTOR >> #define VEC_DUPLICATE_CST_ELT(NODE) \ >> (VEC_DUPLICATE_CST_CHECK (NODE)->vector.elts[0]) >> >> +/* In a VEC_SERIES_CST node. */ >> +#define VEC_SERIES_CST_BASE(NODE) \ >> + (VEC_SERIES_CST_CHECK (NODE)->vector.elts[0]) >> +#define VEC_SERIES_CST_STEP(NODE) \ >> + (VEC_SERIES_CST_CHECK (NODE)->vector.elts[1]) >> + >> /* Define fields and accessors for some special-purpose tree nodes. */ >> >> #define IDENTIFIER_LENGTH(NODE) \ >> @@ -4030,9 +4036,11 @@ extern tree build_int_cstu (tree type, u >> extern tree build_int_cst_type (tree, HOST_WIDE_INT); >> extern tree make_vector (unsigned CXX_MEM_STAT_INFO); >> extern tree build_vec_duplicate_cst (tree, tree CXX_MEM_STAT_INFO); >> +extern tree build_vec_series_cst (tree, tree, tree CXX_MEM_STAT_INFO); >> extern tree build_vector (tree, vec<tree> CXX_MEM_STAT_INFO); >> extern tree build_vector_from_ctor (tree, vec<constructor_elt, va_gc> *); >> extern tree build_vector_from_val (tree, tree); >> +extern tree build_vec_series (tree, tree, tree); >> extern void recompute_constructor_flags (tree); >> extern void verify_constructor_flags (tree); >> extern tree build_constructor (tree, vec<constructor_elt, va_gc> *); >> Index: gcc/tree.c >> =================================================================== >> --- gcc/tree.c 2017-10-23 11:41:51.774917721 +0100 >> +++ gcc/tree.c 2017-10-23 11:42:34.924720660 +0100 >> @@ -465,6 +465,7 @@ tree_node_structure_for_code (enum tree_ >> case COMPLEX_CST: return TS_COMPLEX; >> case VECTOR_CST: return TS_VECTOR; >> case VEC_DUPLICATE_CST: return TS_VECTOR; >> + case VEC_SERIES_CST: return TS_VECTOR; >> case STRING_CST: return TS_STRING; >> /* tcc_exceptional cases. */ >> case ERROR_MARK: return TS_COMMON; >> @@ -818,6 +819,8 @@ tree_code_size (enum tree_code code) >> case COMPLEX_CST: return sizeof (struct tree_complex); >> case VECTOR_CST: return sizeof (struct tree_vector); >> case VEC_DUPLICATE_CST: return sizeof (struct tree_vector); >> + case VEC_SERIES_CST: >> + return sizeof (struct tree_vector) + sizeof (tree); >> case STRING_CST: gcc_unreachable (); >> default: >> return lang_hooks.tree_size (code); >> @@ -880,6 +883,9 @@ tree_size (const_tree node) >> case VEC_DUPLICATE_CST: >> return sizeof (struct tree_vector); >> >> + case VEC_SERIES_CST: >> + return sizeof (struct tree_vector) + sizeof (tree); >> + >> case STRING_CST: >> return TREE_STRING_LENGTH (node) + offsetof (struct tree_string, str) >> + 1; >> >> @@ -1711,6 +1717,31 @@ build_vec_duplicate_cst (tree type, tree >> return t; >> } >> >> +/* Build a new VEC_SERIES_CST with type TYPE, base BASE and step STEP. >> + >> + Note that this function is only suitable for callers that specifically >> + need a VEC_SERIES_CST node. Use build_vec_series to build a general >> + series vector from a general base and step. */ >> + >> +tree >> +build_vec_series_cst (tree type, tree base, tree step MEM_STAT_DECL) >> +{ >> + int length = sizeof (struct tree_vector) + sizeof (tree); >> + >> + record_node_allocation_statistics (VEC_SERIES_CST, length); >> + >> + tree t = ggc_alloc_cleared_tree_node_stat (length PASS_MEM_STAT); >> + >> + TREE_SET_CODE (t, VEC_SERIES_CST); >> + TREE_TYPE (t) = type; >> + t->base.u.nelts = 2; >> + VEC_SERIES_CST_BASE (t) = base; >> + VEC_SERIES_CST_STEP (t) = step; >> + TREE_CONSTANT (t) = 1; >> + >> + return t; >> +} >> + >> /* Build a newly constructed VECTOR_CST node of length LEN. */ >> >> tree >> @@ -1821,6 +1852,19 @@ build_vector_from_val (tree vectype, tre >> } >> } >> >> +/* Build a vector series of type TYPE in which element I has the value >> + BASE + I * STEP. */ >> + >> +tree >> +build_vec_series (tree type, tree base, tree step) >> +{ >> + if (integer_zerop (step)) >> + return build_vector_from_val (type, base); >> + if (CONSTANT_CLASS_P (base) && CONSTANT_CLASS_P (step)) >> + return build_vec_series_cst (type, base, step); >> + return build2 (VEC_SERIES_EXPR, type, base, step); >> +} >> + >> /* Something has messed with the elements of CONSTRUCTOR C after it was >> built; >> calculate TREE_CONSTANT and TREE_SIDE_EFFECTS. */ >> >> @@ -7136,6 +7180,10 @@ add_expr (const_tree t, inchash::hash &h >> case VEC_DUPLICATE_CST: >> inchash::add_expr (VEC_DUPLICATE_CST_ELT (t), hstate); >> return; >> + case VEC_SERIES_CST: >> + inchash::add_expr (VEC_SERIES_CST_BASE (t), hstate); >> + inchash::add_expr (VEC_SERIES_CST_STEP (t), hstate); >> + return; >> case SSA_NAME: >> /* We can just compare by pointer. */ >> hstate.add_wide_int (SSA_NAME_VERSION (t)); >> @@ -11150,6 +11198,7 @@ #define WALK_SUBTREE_TAIL(NODE) >> \ >> case FIXED_CST: >> case VECTOR_CST: >> case VEC_DUPLICATE_CST: >> + case VEC_SERIES_CST: >> case STRING_CST: >> case BLOCK: >> case PLACEHOLDER_EXPR: >> @@ -12442,6 +12491,15 @@ drop_tree_overflow (tree t) >> if (TREE_OVERFLOW (*elt)) >> *elt = drop_tree_overflow (*elt); >> } >> + if (TREE_CODE (t) == VEC_SERIES_CST) >> + { >> + tree *elt = &VEC_SERIES_CST_BASE (t); >> + if (TREE_OVERFLOW (*elt)) >> + *elt = drop_tree_overflow (*elt); >> + elt = &VEC_SERIES_CST_STEP (t); >> + if (TREE_OVERFLOW (*elt)) >> + *elt = drop_tree_overflow (*elt); >> + } >> return t; >> } >> >> Index: gcc/cfgexpand.c >> =================================================================== >> --- gcc/cfgexpand.c 2017-10-23 11:41:51.760448406 +0100 >> +++ gcc/cfgexpand.c 2017-10-23 11:42:34.909720660 +0100 >> @@ -5051,6 +5051,8 @@ expand_debug_expr (tree exp) >> case VEC_PERM_EXPR: >> case VEC_DUPLICATE_CST: >> case VEC_DUPLICATE_EXPR: >> + case VEC_SERIES_CST: >> + case VEC_SERIES_EXPR: >> return NULL; >> >> /* Misc codes. */ >> Index: gcc/tree-pretty-print.c >> =================================================================== >> --- gcc/tree-pretty-print.c 2017-10-23 11:41:51.772023858 +0100 >> +++ gcc/tree-pretty-print.c 2017-10-23 11:42:34.921720660 +0100 >> @@ -1808,6 +1808,14 @@ dump_generic_node (pretty_printer *pp, t >> pp_string (pp, ", ... }"); >> break; >> >> + case VEC_SERIES_CST: >> + pp_string (pp, "{ "); >> + dump_generic_node (pp, VEC_SERIES_CST_BASE (node), spc, flags, false); >> + pp_string (pp, ", +, "); >> + dump_generic_node (pp, VEC_SERIES_CST_STEP (node), spc, flags, false); >> + pp_string (pp, "}"); >> + break; >> + >> case FUNCTION_TYPE: >> case METHOD_TYPE: >> dump_generic_node (pp, TREE_TYPE (node), spc, flags, false); >> @@ -3221,6 +3229,7 @@ dump_generic_node (pretty_printer *pp, t >> pp_string (pp, " > "); >> break; >> >> + case VEC_SERIES_EXPR: >> case VEC_WIDEN_MULT_HI_EXPR: >> case VEC_WIDEN_MULT_LO_EXPR: >> case VEC_WIDEN_MULT_EVEN_EXPR: >> Index: gcc/dwarf2out.c >> =================================================================== >> --- gcc/dwarf2out.c 2017-10-23 11:41:51.763342269 +0100 >> +++ gcc/dwarf2out.c 2017-10-23 11:42:34.913720660 +0100 >> @@ -18863,6 +18863,7 @@ rtl_for_decl_init (tree init, tree type) >> { >> case VECTOR_CST: >> case VEC_DUPLICATE_CST: >> + case VEC_SERIES_CST: >> break; >> case CONSTRUCTOR: >> if (TREE_CONSTANT (init)) >> Index: gcc/gimple-expr.h >> =================================================================== >> --- gcc/gimple-expr.h 2017-10-23 11:41:51.765271511 +0100 >> +++ gcc/gimple-expr.h 2017-10-23 11:42:34.916720660 +0100 >> @@ -135,6 +135,7 @@ is_gimple_constant (const_tree t) >> case COMPLEX_CST: >> case VECTOR_CST: >> case VEC_DUPLICATE_CST: >> + case VEC_SERIES_CST: >> case STRING_CST: >> return true; >> >> Index: gcc/gimplify.c >> =================================================================== >> --- gcc/gimplify.c 2017-10-23 11:41:51.766236132 +0100 >> +++ gcc/gimplify.c 2017-10-23 11:42:34.917720660 +0100 >> @@ -11507,6 +11507,7 @@ gimplify_expr (tree *expr_p, gimple_seq >> case COMPLEX_CST: >> case VECTOR_CST: >> case VEC_DUPLICATE_CST: >> + case VEC_SERIES_CST: >> /* Drop the overflow flag on constants, we do not want >> that in the GIMPLE IL. */ >> if (TREE_OVERFLOW_P (*expr_p)) >> Index: gcc/graphite-scop-detection.c >> =================================================================== >> --- gcc/graphite-scop-detection.c 2017-10-23 11:41:51.767200753 +0100 >> +++ gcc/graphite-scop-detection.c 2017-10-23 11:42:34.917720660 +0100 >> @@ -1244,6 +1244,7 @@ scan_tree_for_params (sese_info_p s, tre >> case COMPLEX_CST: >> case VECTOR_CST: >> case VEC_DUPLICATE_CST: >> + case VEC_SERIES_CST: >> break; >> >> default: >> Index: gcc/ipa-icf-gimple.c >> =================================================================== >> --- gcc/ipa-icf-gimple.c 2017-10-23 11:41:51.767200753 +0100 >> +++ gcc/ipa-icf-gimple.c 2017-10-23 11:42:34.917720660 +0100 >> @@ -334,6 +334,7 @@ func_checker::compare_cst_or_decl (tree >> case COMPLEX_CST: >> case VECTOR_CST: >> case VEC_DUPLICATE_CST: >> + case VEC_SERIES_CST: >> case STRING_CST: >> case REAL_CST: >> { >> @@ -530,6 +531,7 @@ func_checker::compare_operand (tree t1, >> case COMPLEX_CST: >> case VECTOR_CST: >> case VEC_DUPLICATE_CST: >> + case VEC_SERIES_CST: >> case STRING_CST: >> case REAL_CST: >> case FUNCTION_DECL: >> Index: gcc/ipa-icf.c >> =================================================================== >> --- gcc/ipa-icf.c 2017-10-23 11:41:51.768165374 +0100 >> +++ gcc/ipa-icf.c 2017-10-23 11:42:34.918720660 +0100 >> @@ -1479,6 +1479,7 @@ sem_item::add_expr (const_tree exp, inch >> case COMPLEX_CST: >> case VECTOR_CST: >> case VEC_DUPLICATE_CST: >> + case VEC_SERIES_CST: >> inchash::add_expr (exp, hstate); >> break; >> case CONSTRUCTOR: >> @@ -2034,6 +2035,11 @@ sem_variable::equals (tree t1, tree t2) >> case VEC_DUPLICATE_CST: >> return sem_variable::equals (VEC_DUPLICATE_CST_ELT (t1), >> VEC_DUPLICATE_CST_ELT (t2)); >> + case VEC_SERIES_CST: >> + return (sem_variable::equals (VEC_SERIES_CST_BASE (t1), >> + VEC_SERIES_CST_BASE (t2)) >> + && sem_variable::equals (VEC_SERIES_CST_STEP (t1), >> + VEC_SERIES_CST_STEP (t2))); >> case ARRAY_REF: >> case ARRAY_RANGE_REF: >> { >> Index: gcc/print-tree.c >> =================================================================== >> --- gcc/print-tree.c 2017-10-23 11:41:51.769129995 +0100 >> +++ gcc/print-tree.c 2017-10-23 11:42:34.919720660 +0100 >> @@ -787,6 +787,11 @@ print_node (FILE *file, const char *pref >> print_node (file, "elt", VEC_DUPLICATE_CST_ELT (node), indent + 4); >> break; >> >> + case VEC_SERIES_CST: >> + print_node (file, "base", VEC_SERIES_CST_BASE (node), indent + 4); >> + print_node (file, "step", VEC_SERIES_CST_STEP (node), indent + 4); >> + break; >> + >> case COMPLEX_CST: >> print_node (file, "real", TREE_REALPART (node), indent + 4); >> print_node (file, "imag", TREE_IMAGPART (node), indent + 4); >> Index: gcc/tree-ssa-loop.c >> =================================================================== >> --- gcc/tree-ssa-loop.c 2017-10-23 11:41:51.772023858 +0100 >> +++ gcc/tree-ssa-loop.c 2017-10-23 11:42:34.921720660 +0100 >> @@ -617,6 +617,7 @@ for_each_index (tree *addr_p, bool (*cbc >> case RESULT_DECL: >> case VECTOR_CST: >> case VEC_DUPLICATE_CST: >> + case VEC_SERIES_CST: >> case COMPLEX_CST: >> case INTEGER_CST: >> case REAL_CST: >> Index: gcc/tree-ssa-pre.c >> =================================================================== >> --- gcc/tree-ssa-pre.c 2017-10-23 11:41:51.772023858 +0100 >> +++ gcc/tree-ssa-pre.c 2017-10-23 11:42:34.922720660 +0100 >> @@ -2676,6 +2676,7 @@ create_component_ref_by_pieces_1 (basic_ >> case COMPLEX_CST: >> case VECTOR_CST: >> case VEC_DUPLICATE_CST: >> + case VEC_SERIES_CST: >> case REAL_CST: >> case CONSTRUCTOR: >> case VAR_DECL: >> Index: gcc/tree-ssa-sccvn.c >> =================================================================== >> --- gcc/tree-ssa-sccvn.c 2017-10-23 11:41:51.773953100 +0100 >> +++ gcc/tree-ssa-sccvn.c 2017-10-23 11:42:34.922720660 +0100 >> @@ -859,6 +859,7 @@ copy_reference_ops_from_ref (tree ref, v >> case COMPLEX_CST: >> case VECTOR_CST: >> case VEC_DUPLICATE_CST: >> + case VEC_SERIES_CST: >> case REAL_CST: >> case FIXED_CST: >> case CONSTRUCTOR: >> @@ -1052,6 +1053,7 @@ ao_ref_init_from_vn_reference (ao_ref *r >> case COMPLEX_CST: >> case VECTOR_CST: >> case VEC_DUPLICATE_CST: >> + case VEC_SERIES_CST: >> case REAL_CST: >> case CONSTRUCTOR: >> case CONST_DECL: >> Index: gcc/varasm.c >> =================================================================== >> --- gcc/varasm.c 2017-10-23 11:41:51.775882341 +0100 >> +++ gcc/varasm.c 2017-10-23 11:42:34.927720660 +0100 >> @@ -3065,6 +3065,10 @@ const_hash_1 (const tree exp) >> return (const_hash_1 (TREE_OPERAND (exp, 0)) * 9 >> + const_hash_1 (TREE_OPERAND (exp, 1))); >> >> + case VEC_SERIES_CST: >> + return (const_hash_1 (VEC_SERIES_CST_BASE (exp)) * 11 >> + + const_hash_1 (VEC_SERIES_CST_STEP (exp))); >> + >> CASE_CONVERT: >> return const_hash_1 (TREE_OPERAND (exp, 0)) * 7 + 2; >> >> @@ -3165,6 +3169,12 @@ compare_constant (const tree t1, const t >> return compare_constant (VEC_DUPLICATE_CST_ELT (t1), >> VEC_DUPLICATE_CST_ELT (t2)); >> >> + case VEC_SERIES_CST: >> + return (compare_constant (VEC_SERIES_CST_BASE (t1), >> + VEC_SERIES_CST_BASE (t2)) >> + && compare_constant (VEC_SERIES_CST_STEP (t1), >> + VEC_SERIES_CST_STEP (t2))); >> + >> case CONSTRUCTOR: >> { >> vec<constructor_elt, va_gc> *v1, *v2; >> Index: gcc/fold-const.c >> =================================================================== >> --- gcc/fold-const.c 2017-10-23 11:41:51.765271511 +0100 >> +++ gcc/fold-const.c 2017-10-23 11:42:34.916720660 +0100 >> @@ -421,6 +421,10 @@ negate_expr_p (tree t) >> case VEC_DUPLICATE_CST: >> return negate_expr_p (VEC_DUPLICATE_CST_ELT (t)); >> >> + case VEC_SERIES_CST: >> + return (negate_expr_p (VEC_SERIES_CST_BASE (t)) >> + && negate_expr_p (VEC_SERIES_CST_STEP (t))); >> + >> case COMPLEX_EXPR: >> return negate_expr_p (TREE_OPERAND (t, 0)) >> && negate_expr_p (TREE_OPERAND (t, 1)); >> @@ -590,6 +594,17 @@ fold_negate_expr_1 (location_t loc, tree >> return build_vector_from_val (type, sub); >> } >> >> + case VEC_SERIES_CST: >> + { >> + tree neg_base = fold_negate_expr (loc, VEC_SERIES_CST_BASE (t)); >> + if (!neg_base) >> + return NULL_TREE; >> + tree neg_step = fold_negate_expr (loc, VEC_SERIES_CST_STEP (t)); >> + if (!neg_step) >> + return NULL_TREE; >> + return build_vec_series (type, neg_base, neg_step); >> + } >> + >> case COMPLEX_EXPR: >> if (negate_expr_p (t)) >> return fold_build2_loc (loc, COMPLEX_EXPR, type, >> @@ -1131,6 +1146,28 @@ int_const_binop (enum tree_code code, co >> return int_const_binop_1 (code, arg1, arg2, 1); >> } >> >> +/* Return true if EXP is a VEC_DUPLICATE_CST or a VEC_SERIES_CST, >> + and if so express it as a linear series in *BASE_OUT and *STEP_OUT. >> + The step will be zero for VEC_DUPLICATE_CST. */ >> + >> +static bool >> +vec_series_equivalent_p (const_tree exp, tree *base_out, tree *step_out) >> +{ >> + if (TREE_CODE (exp) == VEC_SERIES_CST) >> + { >> + *base_out = VEC_SERIES_CST_BASE (exp); >> + *step_out = VEC_SERIES_CST_STEP (exp); >> + return true; >> + } >> + if (TREE_CODE (exp) == VEC_DUPLICATE_CST) >> + { >> + *base_out = VEC_DUPLICATE_CST_ELT (exp); >> + *step_out = build_zero_cst (TREE_TYPE (*base_out)); >> + return true; >> + } >> + return false; >> +} >> + >> /* Combine two constants ARG1 and ARG2 under operation CODE to produce a new >> constant. We assume ARG1 and ARG2 have the same data type, or at least >> are the same kind of constant and the same machine mode. Return zero if >> @@ -1457,6 +1494,20 @@ const_binop (enum tree_code code, tree a >> return build_vector_from_val (TREE_TYPE (arg1), sub); >> } >> >> + tree base1, step1, base2, step2; >> + if ((code == PLUS_EXPR || code == MINUS_EXPR) >> + && vec_series_equivalent_p (arg1, &base1, &step1) >> + && vec_series_equivalent_p (arg2, &base2, &step2)) >> + { >> + tree new_base = const_binop (code, base1, base2); >> + if (!new_base) >> + return NULL_TREE; >> + tree new_step = const_binop (code, step1, step2); >> + if (!new_step) >> + return NULL_TREE; >> + return build_vec_series (TREE_TYPE (arg1), new_base, new_step); >> + } >> + >> /* Shifts allow a scalar offset for a vector. */ >> if (TREE_CODE (arg1) == VECTOR_CST >> && TREE_CODE (arg2) == INTEGER_CST) >> @@ -1505,6 +1556,12 @@ const_binop (enum tree_code code, tree t >> result as argument put those cases that need it here. */ >> switch (code) >> { >> + case VEC_SERIES_EXPR: >> + if (CONSTANT_CLASS_P (arg1) >> + && CONSTANT_CLASS_P (arg2)) >> + return build_vec_series (type, arg1, arg2); >> + return NULL_TREE; >> + >> case COMPLEX_EXPR: >> if ((TREE_CODE (arg1) == REAL_CST >> && TREE_CODE (arg2) == REAL_CST) >> @@ -3008,6 +3065,12 @@ operand_equal_p (const_tree arg0, const_ >> return operand_equal_p (VEC_DUPLICATE_CST_ELT (arg0), >> VEC_DUPLICATE_CST_ELT (arg1), flags); >> >> + case VEC_SERIES_CST: >> + return (operand_equal_p (VEC_SERIES_CST_BASE (arg0), >> + VEC_SERIES_CST_BASE (arg1), flags) >> + && operand_equal_p (VEC_SERIES_CST_STEP (arg0), >> + VEC_SERIES_CST_STEP (arg1), flags)); >> + >> case COMPLEX_CST: >> return (operand_equal_p (TREE_REALPART (arg0), TREE_REALPART (arg1), >> flags) >> @@ -12050,6 +12113,10 @@ fold_checksum_tree (const_tree expr, str >> case VEC_DUPLICATE_CST: >> fold_checksum_tree (VEC_DUPLICATE_CST_ELT (expr), ctx, ht); >> break; >> + case VEC_SERIES_CST: >> + fold_checksum_tree (VEC_SERIES_CST_BASE (expr), ctx, ht); >> + fold_checksum_tree (VEC_SERIES_CST_STEP (expr), ctx, ht); >> + break; >> default: >> break; >> } >> Index: gcc/expmed.c >> =================================================================== >> --- gcc/expmed.c 2017-10-23 11:41:39.186050437 +0100 >> +++ gcc/expmed.c 2017-10-23 11:42:34.914720660 +0100 >> @@ -5253,6 +5253,13 @@ make_tree (tree type, rtx x) >> tree elt_tree = make_tree (TREE_TYPE (type), XEXP (op, 0)); >> return build_vector_from_val (type, elt_tree); >> } >> + if (GET_CODE (op) == VEC_SERIES) >> + { >> + tree itype = TREE_TYPE (type); >> + tree base_tree = make_tree (itype, XEXP (op, 0)); >> + tree step_tree = make_tree (itype, XEXP (op, 1)); >> + return build_vec_series (type, base_tree, step_tree); >> + } >> return make_tree (type, op); >> } >> >> Index: gcc/gimple-pretty-print.c >> =================================================================== >> --- gcc/gimple-pretty-print.c 2017-10-23 11:41:25.500318672 +0100 >> +++ gcc/gimple-pretty-print.c 2017-10-23 11:42:34.916720660 +0100 >> @@ -438,6 +438,7 @@ dump_binary_rhs (pretty_printer *buffer, >> case VEC_PACK_FIX_TRUNC_EXPR: >> case VEC_WIDEN_LSHIFT_HI_EXPR: >> case VEC_WIDEN_LSHIFT_LO_EXPR: >> + case VEC_SERIES_EXPR: >> for (p = get_tree_code_name (code); *p; p++) >> pp_character (buffer, TOUPPER (*p)); >> pp_string (buffer, " <"); >> Index: gcc/tree-inline.c >> =================================================================== >> --- gcc/tree-inline.c 2017-10-23 11:41:51.771059237 +0100 >> +++ gcc/tree-inline.c 2017-10-23 11:42:34.921720660 +0100 >> @@ -4003,6 +4003,7 @@ estimate_operator_cost (enum tree_code c >> case VEC_WIDEN_LSHIFT_HI_EXPR: >> case VEC_WIDEN_LSHIFT_LO_EXPR: >> case VEC_DUPLICATE_EXPR: >> + case VEC_SERIES_EXPR: >> >> return 1; >> >> Index: gcc/expr.c >> =================================================================== >> --- gcc/expr.c 2017-10-23 11:41:51.764306890 +0100 >> +++ gcc/expr.c 2017-10-23 11:42:34.915720660 +0100 >> @@ -7704,7 +7704,7 @@ expand_operands (tree exp0, tree exp1, r >> >> >> /* Expand constant vector element ELT, which has mode MODE. This is used >> - for members of VECTOR_CST and VEC_DUPLICATE_CST. */ >> + for members of VECTOR_CST, VEC_DUPLICATE_CST and VEC_SERIES_CST. */ >> >> static rtx >> const_vector_element (scalar_mode mode, const_tree elt) >> @@ -9587,6 +9587,10 @@ #define REDUCE_BIT_FIELD(expr) (reduce_b >> gcc_assert (target); >> return target; >> >> + case VEC_SERIES_EXPR: >> + expand_operands (treeop0, treeop1, NULL_RTX, &op0, &op1, modifier); >> + return expand_vec_series_expr (mode, op0, op1, target); >> + >> case BIT_INSERT_EXPR: >> { >> unsigned bitpos = tree_to_uhwi (treeop2); >> @@ -10044,6 +10048,13 @@ expand_expr_real_1 (tree exp, rtx target >> VEC_DUPLICATE_CST_ELT (exp)); >> return gen_const_vec_duplicate (mode, op0); >> >> + case VEC_SERIES_CST: >> + op0 = const_vector_element (GET_MODE_INNER (mode), >> + VEC_SERIES_CST_BASE (exp)); >> + op1 = const_vector_element (GET_MODE_INNER (mode), >> + VEC_SERIES_CST_STEP (exp)); >> + return gen_const_vec_series (mode, op0, op1); >> + >> case CONST_DECL: >> if (modifier == EXPAND_WRITE) >> { >> Index: gcc/optabs.def >> =================================================================== >> --- gcc/optabs.def 2017-10-23 11:41:51.769129995 +0100 >> +++ gcc/optabs.def 2017-10-23 11:42:34.919720660 +0100 >> @@ -366,3 +366,4 @@ OPTAB_D (get_thread_pointer_optab, "get_ >> OPTAB_D (set_thread_pointer_optab, "set_thread_pointer$I$a") >> >> OPTAB_DC (vec_duplicate_optab, "vec_duplicate$a", VEC_DUPLICATE) >> +OPTAB_DC (vec_series_optab, "vec_series$a", VEC_SERIES) >> Index: gcc/optabs.h >> =================================================================== >> --- gcc/optabs.h 2017-10-23 11:41:51.769129995 +0100 >> +++ gcc/optabs.h 2017-10-23 11:42:34.919720660 +0100 >> @@ -316,6 +316,9 @@ extern rtx expand_vec_cmp_expr (tree, tr >> /* Generate code for VEC_COND_EXPR. */ >> extern rtx expand_vec_cond_expr (tree, tree, tree, tree, rtx); >> >> +/* Generate code for VEC_SERIES_EXPR. */ >> +extern rtx expand_vec_series_expr (machine_mode, rtx, rtx, rtx); >> + >> /* Generate code for MULT_HIGHPART_EXPR. */ >> extern rtx expand_mult_highpart (machine_mode, rtx, rtx, rtx, bool); >> >> Index: gcc/optabs.c >> =================================================================== >> --- gcc/optabs.c 2017-10-23 11:41:51.769129995 +0100 >> +++ gcc/optabs.c 2017-10-23 11:42:34.919720660 +0100 >> @@ -5693,6 +5693,27 @@ expand_vec_cond_expr (tree vec_cond_type >> return ops[0].value; >> } >> >> +/* Generate VEC_SERIES_EXPR <OP0, OP1>, returning a value of mode VMODE. >> + Use TARGET for the result if nonnull and convenient. */ >> + >> +rtx >> +expand_vec_series_expr (machine_mode vmode, rtx op0, rtx op1, rtx target) >> +{ >> + struct expand_operand ops[3]; >> + enum insn_code icode; >> + machine_mode emode = GET_MODE_INNER (vmode); >> + >> + icode = direct_optab_handler (vec_series_optab, vmode); >> + gcc_assert (icode != CODE_FOR_nothing); >> + >> + create_output_operand (&ops[0], target, vmode); >> + create_input_operand (&ops[1], op0, emode); >> + create_input_operand (&ops[2], op1, emode); >> + >> + expand_insn (icode, 3, ops); >> + return ops[0].value; >> +} >> + >> /* Generate insns for a vector comparison into a mask. */ >> >> rtx >> Index: gcc/optabs-tree.c >> =================================================================== >> --- gcc/optabs-tree.c 2017-10-23 11:41:51.768165374 +0100 >> +++ gcc/optabs-tree.c 2017-10-23 11:42:34.918720660 +0100 >> @@ -213,6 +213,9 @@ optab_for_tree_code (enum tree_code code >> case VEC_DUPLICATE_EXPR: >> return vec_duplicate_optab; >> >> + case VEC_SERIES_EXPR: >> + return vec_series_optab; >> + >> default: >> break; >> } >> Index: gcc/tree-cfg.c >> =================================================================== >> --- gcc/tree-cfg.c 2017-10-23 11:41:51.770094616 +0100 >> +++ gcc/tree-cfg.c 2017-10-23 11:42:34.920720660 +0100 >> @@ -4119,6 +4119,23 @@ verify_gimple_assign_binary (gassign *st >> /* Continue with generic binary expression handling. */ >> break; >> >> + case VEC_SERIES_EXPR: >> + if (!useless_type_conversion_p (rhs1_type, rhs2_type)) >> + { >> + error ("type mismatch in series expression"); >> + debug_generic_expr (rhs1_type); >> + debug_generic_expr (rhs2_type); >> + return true; >> + } >> + if (TREE_CODE (lhs_type) != VECTOR_TYPE >> + || !useless_type_conversion_p (TREE_TYPE (lhs_type), rhs1_type)) >> + { >> + error ("vector type expected in series expression"); >> + debug_generic_expr (lhs_type); >> + return true; >> + } >> + return false; >> + >> default: >> gcc_unreachable (); >> } >> @@ -4485,6 +4502,7 @@ verify_gimple_assign_single (gassign *st >> case COMPLEX_CST: >> case VECTOR_CST: >> case VEC_DUPLICATE_CST: >> + case VEC_SERIES_CST: >> case STRING_CST: >> return res; >> >> Index: gcc/tree-vect-generic.c >> =================================================================== >> --- gcc/tree-vect-generic.c 2017-10-23 11:41:51.773953100 +0100 >> +++ gcc/tree-vect-generic.c 2017-10-23 11:42:34.922720660 +0100 >> @@ -1595,7 +1595,8 @@ expand_vector_operations_1 (gimple_stmt_ >> if (rhs_class == GIMPLE_BINARY_RHS) >> rhs2 = gimple_assign_rhs2 (stmt); >> >> - if (TREE_CODE (type) != VECTOR_TYPE) >> + if (!VECTOR_TYPE_P (type) >> + || !VECTOR_TYPE_P (TREE_TYPE (rhs1))) >> return; >> >> /* If the vector operation is operating on all same vector elements