From patchwork Mon Oct 23 17:41:11 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Richard Sandiford X-Patchwork-Id: 116846 Delivered-To: patch@linaro.org Received: by 10.140.22.164 with SMTP id 33csp4904350qgn; Mon, 23 Oct 2017 10:41:48 -0700 (PDT) X-Received: by 10.98.200.138 with SMTP id i10mr13776805pfk.222.1508780508566; Mon, 23 Oct 2017 10:41:48 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1508780508; cv=none; d=google.com; s=arc-20160816; b=R4L6HzFlshKkmVdNCvaID2WxfPo0C793rsGlxpinanrEDZc4xdvWD71N3Ju8nMcFi0 6FVRT42iElT1dle+WNEe961040h0LS/bDidPReDZ94qM4itHZn2u6amRfZPhVUlcMQIo BcSizvHqUpNGF94yEvMqpZ2dq23LkDp/KD1eADsjSDO7ZrvCrbqwzW85U3klfUkUP1fl usKibWOLipnIunzebxwMRI0di6ZZ8XZUe86seC2Hw8pC0ON5Qbb1R4HsClQ1d8Gxl0jX Y94rfYALRYQALJf1Ta5TFmgXfCt2E0qXLk4MhjW+605pKRAQRUnmvCN5gUUc4Rl1iWIA YD7w== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=mime-version:user-agent:message-id:in-reply-to:date:references :subject:mail-followup-to:to:from:delivered-to:sender:list-help :list-post:list-archive:list-unsubscribe:list-id:precedence :mailing-list:dkim-signature:domainkey-signature :arc-authentication-results; bh=MWfeENhY92aQS5YWSvXqL/8idNppNuj+dTZzKCo5hqE=; b=wCjhGsuLid9hFK9cRqsg1iwiYlB6hnU7o1slMiC+TjyUFO8rqew9v2pkV437Hxh5n5 fcq6VfFqkEsQzmtLvxrKm05HZJxtQiC2VnGIY18za9N9QSGQx1sdyH76fCVo0caZHfC6 UFRvorjXVHOVv920SPO1DvGL4lrXeH0zGBXAgOL3VIgZ5GGC7sPf3Ujklg8eclSjOkjU ZyYf4UMBWme/n8mhsKQ0wEuVLjV/HI65O8kqb3zLEx8Pd20HtxIhdTvqXuKj2XVD35ZG WD1K3c24qFz1K2OFla1K6GZQzmSDqjUfZFNioh06Dwbj2Btf53/4hzwMcXXE1+rtDYjR G6VA== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@gcc.gnu.org header.s=default header.b=MBh/zQg4; spf=pass (google.com: domain of gcc-patches-return-464877-patch=linaro.org@gcc.gnu.org designates 209.132.180.131 as permitted sender) smtp.mailfrom=gcc-patches-return-464877-patch=linaro.org@gcc.gnu.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from sourceware.org (server1.sourceware.org. [209.132.180.131]) by mx.google.com with ESMTPS id k62si5204647pga.452.2017.10.23.10.41.48 for (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Mon, 23 Oct 2017 10:41:48 -0700 (PDT) Received-SPF: pass (google.com: domain of gcc-patches-return-464877-patch=linaro.org@gcc.gnu.org designates 209.132.180.131 as permitted sender) client-ip=209.132.180.131; Authentication-Results: mx.google.com; dkim=pass header.i=@gcc.gnu.org header.s=default header.b=MBh/zQg4; spf=pass (google.com: domain of gcc-patches-return-464877-patch=linaro.org@gcc.gnu.org designates 209.132.180.131 as permitted sender) smtp.mailfrom=gcc-patches-return-464877-patch=linaro.org@gcc.gnu.org; dmarc=fail (p=NONE sp=NONE dis=NONE) header.from=linaro.org DomainKey-Signature: a=rsa-sha1; c=nofws; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:from :to:subject:references:date:in-reply-to:message-id:mime-version :content-type; q=dns; s=default; b=mrUQ/IQVqoU3Vsf9pPK2N8KeyhC5v EDnWci2NwtbLynr4MDiURf1mqU4JfMRAOSqvzirYDmLnCoAG7q+vLosogvW1BH4X LMEytCYRrkMLOXDZb2gRsH9F7w/wfANKbeXG7k1A5aHLSU6jrYUwonZMEFx5/6oc 7qqqPS28jaOPaQ= DKIM-Signature: v=1; a=rsa-sha1; c=relaxed; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:from :to:subject:references:date:in-reply-to:message-id:mime-version :content-type; s=default; bh=BPyjlQZ1O1VsAv0bi1LrW4V3SsQ=; b=MBh /zQg4lHg+c3BVUFs+mVz/NjGDo8/YwD7Q9wdYTyWlQWNgcDzCCtuAdeeK5Uxjb5c d+g55Ac6C2j/2I/8u2QLWlsIgYcHpwE/aUqgJPVT7hPnNSWJ+t3ShBH1lgIVvpAI JLFyhVw9oDBRL+CVei7MUYXxnbyw1ly6dHM4FXng= Received: (qmail 122862 invoked by alias); 23 Oct 2017 17:41:21 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Delivered-To: mailing list gcc-patches@gcc.gnu.org Received: (qmail 122852 invoked by uid 89); 23 Oct 2017 17:41:20 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-15.6 required=5.0 tests=AWL, BAYES_00, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, KAM_ASCII_DIVIDERS, RCVD_IN_DNSWL_NONE, SPF_PASS autolearn=ham version=3.3.2 spammy= X-HELO: mail-wr0-f179.google.com Received: from mail-wr0-f179.google.com (HELO mail-wr0-f179.google.com) (209.85.128.179) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Mon, 23 Oct 2017 17:41:16 +0000 Received: by mail-wr0-f179.google.com with SMTP id 15so4383973wrb.5 for ; Mon, 23 Oct 2017 10:41:15 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:mail-followup-to:subject:references:date :in-reply-to:message-id:user-agent:mime-version; bh=MWfeENhY92aQS5YWSvXqL/8idNppNuj+dTZzKCo5hqE=; b=SN+KsidtWY9EHyk9Jidzmne5p3mOoQcltAT0qFkGn1KxNIKNZ58DrBXPJ9QcYYC3t9 hj8GFkRlbdOXVq2a6yKyjWV1pnGZs9yJPjDcN43ENghzKZLurkf4Jsh9+oQE1LvY8e2A ek70h/r5cvqfzL9R6nBXKsNqAZ8/RC0kCWmoxlx12p80ElOe4O51HG3Bxyp/54xxeJIM vFn5ZN2AwRhQHzGDWdRhQTiwfMgrdIIxXStyaOaOtBz0spQUhRB9jXD6kMwRZFh6Ml9o KbYiO+zaE1UyvKm+3AsQbgYuRRKCjLNklJ045stmwKCW1OSzrBPfNUiQca6YsgPPR4Lp mEmg== X-Gm-Message-State: AMCzsaXjP6M27X7RTYUEN7Zik7EB4J695DJtDbvuzcH137PIFjzAvBQ4 PNzg34u+g4Asn3g95vrKbZtg6/HtOwE= X-Google-Smtp-Source: ABhQp+SOHl2JMhU0Nxmw6fYUraKgyUdb/yUrP4i8IuOrhz54NW+uOSEilgnBwFVRRpOJTkAAmZf//w== X-Received: by 10.223.188.13 with SMTP id s13mr13155540wrg.39.1508780473160; Mon, 23 Oct 2017 10:41:13 -0700 (PDT) Received: from localhost ([2.26.27.199]) by smtp.gmail.com with ESMTPSA id 5sm6047870wrj.22.2017.10.23.10.41.11 for (version=TLS1_2 cipher=ECDHE-RSA-CHACHA20-POLY1305 bits=256/256); Mon, 23 Oct 2017 10:41:12 -0700 (PDT) From: Richard Sandiford To: gcc-patches@gcc.gnu.org Mail-Followup-To: gcc-patches@gcc.gnu.org, richard.sandiford@linaro.org Subject: [101/nnn] poly_int: GET_MODE_NUNITS References: <871sltvm7r.fsf@linaro.org> Date: Mon, 23 Oct 2017 18:41:11 +0100 In-Reply-To: <871sltvm7r.fsf@linaro.org> (Richard Sandiford's message of "Mon, 23 Oct 2017 17:54:32 +0100") Message-ID: <87o9oxdao8.fsf@linaro.org> User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/25.2 (gnu/linux) MIME-Version: 1.0 This patch changes GET_MODE_NUNITS from unsigned char to poly_uint16, although it remains a macro when compiling target code with NUM_POLY_INT_COEFFS == 1. If the number of units isn't known at compile time, we use: (const:M (vec_duplicate:M X)) to represent a vector in which every element is equal to X. The code ensures that there is only a single instance of each constant, so that pointer equality is enough. (This is a requirement for the constants that go in const_tiny_rtx, but we might as well do it for all constants.) Similarly we use: (const:M (vec_series:M A B)) for a linear series starting at A and having step B. The to_constant call in make_vector_type goes away in a later patch. 2017-10-23 Richard Sandiford Alan Hayward David Sherwood gcc/ * machmode.h (mode_nunits): Change from unsigned char to poly_uint16_pod. (ONLY_FIXED_SIZE_MODES): New macro. (pod_mode::measurement_type, scalar_int_mode::measurement_type) (scalar_float_mode::measurement_type, scalar_mode::measurement_type) (complex_mode::measurement_type, fixed_size_mode::measurement_type): New typedefs. (mode_to_nunits): Return a poly_uint16 rather than an unsigned short. (GET_MODE_NUNITS): Return a constant if ONLY_FIXED_SIZE_MODES, or if measurement_type is not polynomial. * genmodes.c (ZERO_COEFFS): New macro. (emit_mode_nunits_inline): Make mode_nunits_inline return a poly_uint16. (emit_mode_nunits): Change the type of mode_nunits to poly_uint16_pod. Use ZERO_COEFFS when emitting initializers. * data-streamer.h (bp_pack_poly_value): New function. (bp_unpack_poly_value): Likewise. * lto-streamer-in.c (lto_input_mode_table): Use bp_unpack_poly_value for GET_MODE_NUNITS. * lto-streamer-out.c (lto_write_mode_table): Use bp_pack_poly_value for GET_MODE_NUNITS. * tree.c (make_vector_type): Remove temporary shim and make the real function take the number of units as a poly_uint64 rather than an int. (build_vector_type_for_mode): Handle polynomial nunits. * emit-rtl.c (gen_const_vec_duplicate_1): Likewise. (gen_const_vec_series, gen_rtx_CONST_VECTOR): Likewise. * genrecog.c (validate_pattern): Likewise. * optabs-query.c (can_mult_highpart_p): Likewise. * optabs-tree.c (expand_vec_cond_expr_p): Likewise. * optabs.c (expand_vector_broadcast, expand_binop_directly) (shift_amt_for_vec_perm_mask, expand_vec_perm, expand_vec_cond_expr) (expand_mult_highpart): Likewise. * rtlanal.c (subreg_get_info): Likewise. * simplify-rtx.c (simplify_unary_operation_1): Likewise. (simplify_const_unary_operation, simplify_binary_operation_1) (simplify_const_binary_operation, simplify_ternary_operation) (test_vector_ops_duplicate, test_vector_ops): Likewise. * tree-vect-data-refs.c (vect_grouped_store_supported): Likewise. (vect_grouped_load_supported): Likewise. * tree-vect-generic.c (type_for_widest_vector_mode): Likewise. * tree-vect-loop.c (have_whole_vector_shift): Likewise. gcc/ada/ * gcc-interface/misc.c (enumerate_modes): Handle polynomial GET_MODE_NUNITS. Index: gcc/machmode.h =================================================================== --- gcc/machmode.h 2017-10-23 17:11:54.535862371 +0100 +++ gcc/machmode.h 2017-10-23 17:25:48.620492005 +0100 @@ -25,7 +25,7 @@ typedef opt_mode opt_machi extern CONST_MODE_SIZE unsigned short mode_size[NUM_MACHINE_MODES]; extern const unsigned short mode_precision[NUM_MACHINE_MODES]; extern const unsigned char mode_inner[NUM_MACHINE_MODES]; -extern const unsigned char mode_nunits[NUM_MACHINE_MODES]; +extern const poly_uint16_pod mode_nunits[NUM_MACHINE_MODES]; extern CONST_MODE_UNIT_SIZE unsigned char mode_unit_size[NUM_MACHINE_MODES]; extern const unsigned short mode_unit_precision[NUM_MACHINE_MODES]; extern const unsigned char mode_wider[NUM_MACHINE_MODES]; @@ -76,6 +76,14 @@ struct mode_traits typedef machine_mode from_int; }; +/* Always treat machine modes as fixed-size while compiling code specific + to targets that have no variable-size modes. */ +#if defined (IN_TARGET_CODE) && NUM_POLY_INT_COEFFS == 1 +#define ONLY_FIXED_SIZE_MODES 1 +#else +#define ONLY_FIXED_SIZE_MODES 0 +#endif + /* Get the name of mode MODE as a string. */ extern const char * const mode_name[NUM_MACHINE_MODES]; @@ -313,6 +321,7 @@ opt_mode::exists (U *mode) const struct pod_mode { typedef typename mode_traits::from_int from_int; + typedef typename T::measurement_type measurement_type; machine_mode m_mode; ALWAYS_INLINE operator machine_mode () const { return m_mode; } @@ -391,6 +400,7 @@ is_a (machine_mode m, U *result) { public: typedef mode_traits::from_int from_int; + typedef unsigned short measurement_type; ALWAYS_INLINE scalar_int_mode () {} ALWAYS_INLINE scalar_int_mode (from_int m) : m_mode (machine_mode (m)) {} @@ -415,6 +425,7 @@ scalar_int_mode::includes_p (machine_mod { public: typedef mode_traits::from_int from_int; + typedef unsigned short measurement_type; ALWAYS_INLINE scalar_float_mode () {} ALWAYS_INLINE scalar_float_mode (from_int m) : m_mode (machine_mode (m)) {} @@ -439,6 +450,7 @@ scalar_float_mode::includes_p (machine_m { public: typedef mode_traits::from_int from_int; + typedef unsigned short measurement_type; ALWAYS_INLINE scalar_mode () {} ALWAYS_INLINE scalar_mode (from_int m) : m_mode (machine_mode (m)) {} @@ -480,6 +492,7 @@ scalar_mode::includes_p (machine_mode m) { public: typedef mode_traits::from_int from_int; + typedef unsigned short measurement_type; ALWAYS_INLINE complex_mode () {} ALWAYS_INLINE complex_mode (from_int m) : m_mode (machine_mode (m)) {} @@ -570,7 +583,7 @@ mode_to_unit_precision (machine_mode mod /* Return the base GET_MODE_NUNITS value for MODE. */ -ALWAYS_INLINE unsigned short +ALWAYS_INLINE poly_uint16 mode_to_nunits (machine_mode mode) { #if GCC_VERSION >= 4001 @@ -627,7 +640,29 @@ #define GET_MODE_UNIT_PRECISION(MODE) (m /* Get the number of units in an object of mode MODE. This is 2 for complex modes and the number of elements for vector modes. */ -#define GET_MODE_NUNITS(MODE) (mode_to_nunits (MODE)) +#if ONLY_FIXED_SIZE_MODES +#define GET_MODE_NUNITS(MODE) (mode_to_nunits (MODE).coeffs[0]) +#else +ALWAYS_INLINE poly_uint16 +GET_MODE_NUNITS (machine_mode mode) +{ + return mode_to_nunits (mode); +} + +template +ALWAYS_INLINE typename if_poly::t +GET_MODE_NUNITS (const T &mode) +{ + return mode_to_nunits (mode); +} + +template +ALWAYS_INLINE typename if_nonpoly::t +GET_MODE_NUNITS (const T &mode) +{ + return mode_to_nunits (mode).coeffs[0]; +} +#endif /* Get the next wider natural mode (eg, QI -> HI -> SI -> DI -> TI). */ @@ -660,6 +695,7 @@ #define GET_MODE_COMPLEX_MODE(MODE) ((ma { public: typedef mode_traits::from_int from_int; + typedef unsigned short measurement_type; ALWAYS_INLINE fixed_size_mode () {} ALWAYS_INLINE fixed_size_mode (from_int m) : m_mode (machine_mode (m)) {} Index: gcc/genmodes.c =================================================================== --- gcc/genmodes.c 2017-10-23 17:11:40.124715442 +0100 +++ gcc/genmodes.c 2017-10-23 17:25:48.618492077 +0100 @@ -901,6 +901,16 @@ calc_wider_mode (void) } } +/* Text to add to the constant part of a poly_int_pod initializer in + order to fill out te whole structure. */ +#if NUM_POLY_INT_COEFFS == 1 +#define ZERO_COEFFS "" +#elif NUM_POLY_INT_COEFFS == 2 +#define ZERO_COEFFS ", 0" +#else +#error "Unknown value of NUM_POLY_INT_COEFFS" +#endif + /* Output routines. */ #define tagged_printf(FMT, ARG, TAG) do { \ @@ -1008,11 +1018,10 @@ inline __attribute__((__always_inline__) #else\n\ extern __inline__ __attribute__((__always_inline__, __gnu_inline__))\n\ #endif\n\ -unsigned char\n\ +poly_uint16\n\ mode_nunits_inline (machine_mode mode)\n\ {\n\ - extern const unsigned char mode_nunits[NUM_MACHINE_MODES];\n\ - gcc_assert (mode >= 0 && mode < NUM_MACHINE_MODES);\n\ + extern poly_uint16_pod mode_nunits[NUM_MACHINE_MODES];\n\ switch (mode)\n\ {"); @@ -1381,10 +1390,10 @@ emit_mode_nunits (void) int c; struct mode_data *m; - print_decl ("unsigned char", "mode_nunits", "NUM_MACHINE_MODES"); + print_decl ("poly_uint16_pod", "mode_nunits", "NUM_MACHINE_MODES"); for_all_modes (c, m) - tagged_printf ("%u", m->ncomponents, m->name); + tagged_printf ("{ %u" ZERO_COEFFS " }", m->ncomponents, m->name); print_closer (); } Index: gcc/data-streamer.h =================================================================== --- gcc/data-streamer.h 2017-02-23 19:54:15.000000000 +0000 +++ gcc/data-streamer.h 2017-10-23 17:25:48.617492113 +0100 @@ -126,6 +126,17 @@ bp_pack_value (struct bitpack_d *bp, bit bp->pos = pos; } +/* Pack VAL into the bit-packing context BP, using NBITS for each + coefficient. */ +static inline void +bp_pack_poly_value (struct bitpack_d *bp, + const poly_int &val, + unsigned nbits) +{ + for (int i = 0; i < NUM_POLY_INT_COEFFS; ++i) + bp_pack_value (bp, val.coeffs[i], nbits); +} + /* Finishes bit-packing of BP. */ static inline void streamer_write_bitpack (struct bitpack_d *bp) @@ -174,6 +185,17 @@ bp_unpack_value (struct bitpack_d *bp, u return val & mask; } +/* Unpacks a polynomial value from the bit-packing context BP in which each + coefficient has NBITS bits. */ +static inline poly_int +bp_unpack_poly_value (struct bitpack_d *bp, unsigned nbits) +{ + poly_int_pod x; + for (int i = 0; i < NUM_POLY_INT_COEFFS; ++i) + x.coeffs[i] = bp_unpack_value (bp, nbits); + return x; +} + /* Write a character to the output block. */ Index: gcc/lto-streamer-in.c =================================================================== --- gcc/lto-streamer-in.c 2017-10-23 11:41:25.264312838 +0100 +++ gcc/lto-streamer-in.c 2017-10-23 17:25:48.619492041 +0100 @@ -1607,7 +1607,7 @@ lto_input_mode_table (struct lto_file_de unsigned int size = bp_unpack_value (&bp, 8); unsigned int prec = bp_unpack_value (&bp, 16); machine_mode inner = (machine_mode) bp_unpack_value (&bp, 8); - unsigned int nunits = bp_unpack_value (&bp, 8); + poly_uint16 nunits = bp_unpack_poly_value (&bp, 16); unsigned int ibit = 0, fbit = 0; unsigned int real_fmt_len = 0; const char *real_fmt_name = NULL; @@ -1645,7 +1645,7 @@ lto_input_mode_table (struct lto_file_de : GET_MODE_INNER (mr) != table[(int) inner]) || GET_MODE_IBIT (mr) != ibit || GET_MODE_FBIT (mr) != fbit - || GET_MODE_NUNITS (mr) != nunits) + || may_ne (GET_MODE_NUNITS (mr), nunits)) continue; else if ((mclass == MODE_FLOAT || mclass == MODE_DECIMAL_FLOAT) && strcmp (REAL_MODE_FORMAT (mr)->name, real_fmt_name) != 0) Index: gcc/lto-streamer-out.c =================================================================== --- gcc/lto-streamer-out.c 2017-10-23 17:11:40.246949037 +0100 +++ gcc/lto-streamer-out.c 2017-10-23 17:25:48.620492005 +0100 @@ -2775,7 +2775,7 @@ lto_write_mode_table (void) bp_pack_value (&bp, GET_MODE_SIZE (m), 8); bp_pack_value (&bp, GET_MODE_PRECISION (m), 16); bp_pack_value (&bp, GET_MODE_INNER (m), 8); - bp_pack_value (&bp, GET_MODE_NUNITS (m), 8); + bp_pack_poly_value (&bp, GET_MODE_NUNITS (m), 16); switch (GET_MODE_CLASS (m)) { case MODE_FRACT: Index: gcc/tree.c =================================================================== --- gcc/tree.c 2017-10-23 17:22:35.830905181 +0100 +++ gcc/tree.c 2017-10-23 17:25:48.625491825 +0100 @@ -9654,19 +9654,19 @@ omp_clause_operand_check_failed (int idx } #endif /* ENABLE_TREE_CHECKING */ -/* Create a new vector type node holding SUBPARTS units of type INNERTYPE, +/* Create a new vector type node holding NUNITS units of type INNERTYPE, and mapped to the machine mode MODE. Initialize its fields and build the information necessary for debugging output. */ static tree -make_vector_type (tree innertype, int nunits, machine_mode mode) +make_vector_type (tree innertype, poly_int64 nunits, machine_mode mode) { tree t; tree mv_innertype = TYPE_MAIN_VARIANT (innertype); t = make_node (VECTOR_TYPE); TREE_TYPE (t) = mv_innertype; - SET_TYPE_VECTOR_SUBPARTS (t, nunits); + SET_TYPE_VECTOR_SUBPARTS (t, nunits.to_constant ()); /* Temporary */ SET_TYPE_MODE (t, mode); if (TYPE_STRUCTURAL_EQUALITY_P (mv_innertype) || in_lto_p) @@ -9693,13 +9693,6 @@ make_vector_type (tree innertype, int nu return t; } -/* Temporary. */ -static tree -make_vector_type (tree innertype, poly_uint64 nunits, machine_mode mode) -{ - return make_vector_type (innertype, (int) nunits.to_constant (), mode); -} - static tree make_or_reuse_type (unsigned size, int unsignedp) { @@ -10557,7 +10550,7 @@ reconstruct_complex_type (tree type, tre tree build_vector_type_for_mode (tree innertype, machine_mode mode) { - int nunits; + poly_int64 nunits; unsigned int bitsize; switch (GET_MODE_CLASS (mode)) Index: gcc/emit-rtl.c =================================================================== --- gcc/emit-rtl.c 2017-10-23 17:25:30.703136044 +0100 +++ gcc/emit-rtl.c 2017-10-23 17:25:48.618492077 +0100 @@ -5926,8 +5926,8 @@ static GTY((deletable)) rtx spare_vec_du static rtx gen_const_vec_duplicate_1 (machine_mode mode, rtx el) { - int nunits = GET_MODE_NUNITS (mode); - if (1) + int nunits; + if (GET_MODE_NUNITS (mode).is_constant (&nunits)) { rtvec v = rtvec_alloc (nunits); @@ -6024,8 +6024,8 @@ gen_const_vec_series (machine_mode mode, { gcc_assert (CONSTANT_P (base) && CONSTANT_P (step)); - int nunits = GET_MODE_NUNITS (mode); - if (1) + int nunits; + if (GET_MODE_NUNITS (mode).is_constant (&nunits)) { rtvec v = rtvec_alloc (nunits); scalar_mode inner_mode = GET_MODE_INNER (mode); @@ -6089,7 +6089,7 @@ gen_const_vector (machine_mode mode, int rtx gen_rtx_CONST_VECTOR (machine_mode mode, rtvec v) { - gcc_assert (GET_MODE_NUNITS (mode) == GET_NUM_ELEM (v)); + gcc_assert (must_eq (GET_MODE_NUNITS (mode), GET_NUM_ELEM (v))); /* If the values are all the same, check to see if we can use one of the standard constant vectors. */ Index: gcc/genrecog.c =================================================================== --- gcc/genrecog.c 2017-10-23 17:16:50.367528682 +0100 +++ gcc/genrecog.c 2017-10-23 17:25:48.619492041 +0100 @@ -746,14 +746,20 @@ validate_pattern (rtx pattern, md_rtx_in = VECTOR_MODE_P (mode) ? GET_MODE_INNER (mode) : mode; if (GET_CODE (XEXP (pattern, 1)) == PARALLEL) { - int expected = VECTOR_MODE_P (mode) ? GET_MODE_NUNITS (mode) : 1; - if (XVECLEN (XEXP (pattern, 1), 0) != expected) + int expected = 1; + unsigned int nelems; + if (VECTOR_MODE_P (mode) + && !GET_MODE_NUNITS (mode).is_constant (&expected)) + error_at (info->loc, + "vec_select with variable-sized mode %s", + GET_MODE_NAME (mode)); + else if (XVECLEN (XEXP (pattern, 1), 0) != expected) error_at (info->loc, "vec_select parallel with %d elements, expected %d", XVECLEN (XEXP (pattern, 1), 0), expected); - else if (VECTOR_MODE_P (imode)) + else if (VECTOR_MODE_P (imode) + && GET_MODE_NUNITS (imode).is_constant (&nelems)) { - unsigned int nelems = GET_MODE_NUNITS (imode); int i; for (i = 0; i < expected; ++i) if (CONST_INT_P (XVECEXP (XEXP (pattern, 1), 0, i)) Index: gcc/optabs-query.c =================================================================== --- gcc/optabs-query.c 2017-10-23 17:22:32.723227539 +0100 +++ gcc/optabs-query.c 2017-10-23 17:25:48.620492005 +0100 @@ -445,7 +445,12 @@ can_mult_highpart_p (machine_mode mode, if (GET_MODE_CLASS (mode) != MODE_VECTOR_INT) return 0; - nunits = GET_MODE_NUNITS (mode); + /* We need a constant number of elements in order to construct + the permute mask below. */ + /* ??? Maybe we should have specific optabs for these permutations, + so that we can use them even for a variable number of units. */ + if (!GET_MODE_NUNITS (mode).is_constant (&nunits)) + return 0; op = uns_p ? vec_widen_umult_even_optab : vec_widen_smult_even_optab; if (optab_handler (op, mode) != CODE_FOR_nothing) Index: gcc/optabs-tree.c =================================================================== --- gcc/optabs-tree.c 2017-10-23 17:11:39.939361220 +0100 +++ gcc/optabs-tree.c 2017-10-23 17:25:48.620492005 +0100 @@ -338,7 +338,7 @@ expand_vec_cond_expr_p (tree value_type, return true; if (GET_MODE_SIZE (value_mode) != GET_MODE_SIZE (cmp_op_mode) - || GET_MODE_NUNITS (value_mode) != GET_MODE_NUNITS (cmp_op_mode)) + || may_ne (GET_MODE_NUNITS (value_mode), GET_MODE_NUNITS (cmp_op_mode))) return false; if (get_vcond_icode (TYPE_MODE (value_type), TYPE_MODE (cmp_op_type), Index: gcc/optabs.c =================================================================== --- gcc/optabs.c 2017-10-23 17:11:40.272998820 +0100 +++ gcc/optabs.c 2017-10-23 17:25:48.621491969 +0100 @@ -370,17 +370,15 @@ force_expand_binop (machine_mode mode, o rtx expand_vector_broadcast (machine_mode vmode, rtx op) { - enum insn_code icode; + int n; rtvec vec; - rtx ret; - int i, n; gcc_checking_assert (VECTOR_MODE_P (vmode)); if (CONSTANT_P (op)) return gen_const_vec_duplicate (vmode, op); - icode = optab_handler (vec_duplicate_optab, vmode); + insn_code icode = optab_handler (vec_duplicate_optab, vmode); if (icode != CODE_FOR_nothing) { struct expand_operand ops[2]; @@ -390,6 +388,9 @@ expand_vector_broadcast (machine_mode vm return ops[0].value; } + if (!GET_MODE_NUNITS (vmode).is_constant (&n)) + return NULL; + /* ??? If the target doesn't have a vec_init, then we have no easy way of performing this operation. Most of this sort of generic support is hidden away in the vector lowering support in gimple. */ @@ -398,11 +399,10 @@ expand_vector_broadcast (machine_mode vm if (icode == CODE_FOR_nothing) return NULL; - n = GET_MODE_NUNITS (vmode); vec = rtvec_alloc (n); - for (i = 0; i < n; ++i) + for (int i = 0; i < n; ++i) RTVEC_ELT (vec, i) = op; - ret = gen_reg_rtx (vmode); + rtx ret = gen_reg_rtx (vmode); emit_insn (GEN_FCN (icode) (ret, gen_rtx_PARALLEL (vmode, vec))); return ret; @@ -1068,7 +1068,7 @@ expand_binop_directly (enum insn_code ic arguments. */ tmp_mode = insn_data[(int) icode].operand[0].mode; if (VECTOR_MODE_P (mode) - && GET_MODE_NUNITS (tmp_mode) != 2 * GET_MODE_NUNITS (mode)) + && may_ne (GET_MODE_NUNITS (tmp_mode), 2 * GET_MODE_NUNITS (mode))) { delete_insns_since (last); return NULL_RTX; @@ -5385,16 +5385,15 @@ vector_compare_rtx (machine_mode cmp_mod static rtx shift_amt_for_vec_perm_mask (machine_mode op0_mode, rtx sel) { - unsigned int i, first, nelt = GET_MODE_NUNITS (GET_MODE (sel)); - unsigned int bitsize = GET_MODE_UNIT_BITSIZE (GET_MODE (sel)); - if (GET_CODE (sel) != CONST_VECTOR) return NULL_RTX; - first = INTVAL (CONST_VECTOR_ELT (sel, 0)); + unsigned int nelt = CONST_VECTOR_NUNITS (sel); + unsigned int bitsize = GET_MODE_UNIT_BITSIZE (GET_MODE (sel)); + unsigned int first = INTVAL (CONST_VECTOR_ELT (sel, 0)); if (first >= nelt) return NULL_RTX; - for (i = 1; i < nelt; i++) + for (unsigned int i = 1; i < nelt; i++) { int idx = INTVAL (CONST_VECTOR_ELT (sel, i)); unsigned int expected = i + first; @@ -5450,7 +5449,7 @@ expand_vec_perm (machine_mode mode, rtx { enum insn_code icode; machine_mode qimode; - unsigned int i, w, e, u; + unsigned int i, w, u; rtx tmp, sel_qi = NULL; rtvec vec; @@ -5458,7 +5457,6 @@ expand_vec_perm (machine_mode mode, rtx target = gen_reg_rtx (mode); w = GET_MODE_SIZE (mode); - e = GET_MODE_NUNITS (mode); u = GET_MODE_UNIT_SIZE (mode); /* Set QIMODE to a different vector mode with byte elements. @@ -5474,6 +5472,7 @@ expand_vec_perm (machine_mode mode, rtx { /* See if this can be handled with a vec_shr. We only do this if the second vector is all zeroes. */ + unsigned int e = CONST_VECTOR_NUNITS (sel); enum insn_code shift_code = optab_handler (vec_shr_optab, mode); enum insn_code shift_code_qi = ((qimode != VOIDmode && qimode != mode) ? optab_handler (vec_shr_optab, qimode) @@ -5688,7 +5687,8 @@ expand_vec_cond_expr (tree vec_cond_type gcc_assert (GET_MODE_SIZE (mode) == GET_MODE_SIZE (cmp_op_mode) - && GET_MODE_NUNITS (mode) == GET_MODE_NUNITS (cmp_op_mode)); + && must_eq (GET_MODE_NUNITS (mode), + GET_MODE_NUNITS (cmp_op_mode))); icode = get_vcond_icode (mode, cmp_op_mode, unsignedp); if (icode == CODE_FOR_nothing) @@ -5787,7 +5787,6 @@ expand_mult_highpart (machine_mode mode, machine_mode wmode; rtx m1, m2, perm; optab tab1, tab2; - rtvec v; method = can_mult_highpart_p (mode, uns_p); switch (method) @@ -5813,9 +5812,9 @@ expand_mult_highpart (machine_mode mode, } icode = optab_handler (tab1, mode); - nunits = GET_MODE_NUNITS (mode); wmode = insn_data[icode].operand[0].mode; - gcc_checking_assert (2 * GET_MODE_NUNITS (wmode) == nunits); + gcc_checking_assert (must_eq (2 * GET_MODE_NUNITS (wmode), + GET_MODE_NUNITS (mode))); gcc_checking_assert (GET_MODE_SIZE (wmode) == GET_MODE_SIZE (mode)); create_output_operand (&eops[0], gen_reg_rtx (wmode), wmode); @@ -5830,9 +5829,13 @@ expand_mult_highpart (machine_mode mode, expand_insn (optab_handler (tab2, mode), 3, eops); m2 = gen_lowpart (mode, eops[0].value); - v = rtvec_alloc (nunits); if (method == 2) { + /* ??? Might want a way of representing this with variable-width + vectors. */ + if (!GET_MODE_NUNITS (mode).is_constant (&nunits)) + return NULL_RTX; + rtvec v = rtvec_alloc (nunits); for (i = 0; i < nunits; ++i) RTVEC_ELT (v, i) = GEN_INT (!BYTES_BIG_ENDIAN + (i & ~1) + ((i & 1) ? nunits : 0)); Index: gcc/rtlanal.c =================================================================== --- gcc/rtlanal.c 2017-10-23 17:25:38.243864993 +0100 +++ gcc/rtlanal.c 2017-10-23 17:25:48.622491933 +0100 @@ -3706,11 +3706,11 @@ subreg_get_info (unsigned int xregno, ma if (HARD_REGNO_NREGS_HAS_PADDING (xregno, xmode)) { /* As a consequence, we must be dealing with a constant number of - scalars, and thus a constant offset. */ + scalars, and thus a constant offset and number of units. */ HOST_WIDE_INT coffset = offset.to_constant (); HOST_WIDE_INT cysize = ysize.to_constant (); nregs_xmode = HARD_REGNO_NREGS_WITH_PADDING (xregno, xmode); - unsigned int nunits = GET_MODE_NUNITS (xmode); + unsigned int nunits = GET_MODE_NUNITS (xmode).to_constant (); scalar_mode xmode_unit = GET_MODE_INNER (xmode); gcc_assert (HARD_REGNO_NREGS_HAS_PADDING (xregno, xmode_unit)); gcc_assert (nregs_xmode Index: gcc/simplify-rtx.c =================================================================== --- gcc/simplify-rtx.c 2017-10-23 17:18:47.665057096 +0100 +++ gcc/simplify-rtx.c 2017-10-23 17:25:48.622491933 +0100 @@ -1223,7 +1223,7 @@ simplify_unary_operation_1 (enum rtx_cod /* If we know that the value is already truncated, we can replace the TRUNCATE with a SUBREG. */ - if (GET_MODE_NUNITS (mode) == 1 + if (must_eq (GET_MODE_NUNITS (mode), 1) && (TRULY_NOOP_TRUNCATION_MODES_P (mode, GET_MODE (op)) || truncated_to_mode (mode, op))) { @@ -1740,9 +1740,10 @@ simplify_const_unary_operation (enum rtx } if (CONST_SCALAR_INT_P (op) || CONST_DOUBLE_AS_FLOAT_P (op)) return gen_const_vec_duplicate (mode, op); - if (GET_CODE (op) == CONST_VECTOR) + unsigned int n_elts; + if (GET_CODE (op) == CONST_VECTOR + && GET_MODE_NUNITS (mode).is_constant (&n_elts)) { - unsigned int n_elts = GET_MODE_NUNITS (mode); unsigned int in_n_elts = CONST_VECTOR_NUNITS (op); gcc_assert (in_n_elts < n_elts); gcc_assert ((n_elts % in_n_elts) == 0); @@ -1755,15 +1756,14 @@ simplify_const_unary_operation (enum rtx if (VECTOR_MODE_P (mode) && GET_CODE (op) == CONST_VECTOR) { - int elt_size = GET_MODE_UNIT_SIZE (mode); - unsigned n_elts = (GET_MODE_SIZE (mode) / elt_size); machine_mode opmode = GET_MODE (op); - int op_elt_size = GET_MODE_UNIT_SIZE (opmode); - unsigned op_n_elts = (GET_MODE_SIZE (opmode) / op_elt_size); + unsigned int n_elts = CONST_VECTOR_NUNITS (op); + gcc_assert (must_eq (GET_MODE_NUNITS (mode), n_elts)); + gcc_assert (must_eq (GET_MODE_NUNITS (opmode), n_elts)); + rtvec v = rtvec_alloc (n_elts); unsigned int i; - gcc_assert (op_n_elts == n_elts); for (i = 0; i < n_elts; i++) { rtx x = simplify_unary_operation (code, GET_MODE_INNER (mode), @@ -3614,13 +3614,14 @@ simplify_binary_operation_1 (enum rtx_co nested VEC_SELECT expressions. When input operand is a memory operand, this operation can be simplified to a simple scalar load from an offseted memory address. */ - if (GET_CODE (trueop0) == VEC_SELECT) + int n_elts; + if (GET_CODE (trueop0) == VEC_SELECT + && (GET_MODE_NUNITS (GET_MODE (XEXP (trueop0, 0))) + .is_constant (&n_elts))) { rtx op0 = XEXP (trueop0, 0); rtx op1 = XEXP (trueop0, 1); - int n_elts = GET_MODE_NUNITS (GET_MODE (op0)); - int i = INTVAL (XVECEXP (trueop1, 0, 0)); int elem; @@ -3645,9 +3646,11 @@ simplify_binary_operation_1 (enum rtx_co mode00 = GET_MODE (op00); mode01 = GET_MODE (op01); - /* Find out number of elements of each operand. */ - n_elts00 = GET_MODE_NUNITS (mode00); - n_elts01 = GET_MODE_NUNITS (mode01); + /* Find out the number of elements of each operand. + Since the concatenated result has a constant number + of elements, the operands must too. */ + n_elts00 = GET_MODE_NUNITS (mode00).to_constant (); + n_elts01 = GET_MODE_NUNITS (mode01).to_constant (); gcc_assert (n_elts == n_elts00 + n_elts01); @@ -3686,12 +3689,11 @@ simplify_binary_operation_1 (enum rtx_co if (GET_CODE (trueop0) == CONST_VECTOR) { - int elt_size = GET_MODE_UNIT_SIZE (mode); - unsigned n_elts = (GET_MODE_SIZE (mode) / elt_size); + unsigned n_elts = XVECLEN (trueop1, 0); rtvec v = rtvec_alloc (n_elts); unsigned int i; - gcc_assert (XVECLEN (trueop1, 0) == (int) n_elts); + gcc_assert (must_eq (n_elts, GET_MODE_NUNITS (mode))); for (i = 0; i < n_elts; i++) { rtx x = XVECEXP (trueop1, 0, i); @@ -3760,15 +3762,18 @@ simplify_binary_operation_1 (enum rtx_co } /* If we select one half of a vec_concat, return that. */ + int l0, l1; if (GET_CODE (trueop0) == VEC_CONCAT + && (GET_MODE_NUNITS (GET_MODE (XEXP (trueop0, 0))) + .is_constant (&l0)) + && (GET_MODE_NUNITS (GET_MODE (XEXP (trueop0, 1))) + .is_constant (&l1)) && CONST_INT_P (XVECEXP (trueop1, 0, 0))) { rtx subop0 = XEXP (trueop0, 0); rtx subop1 = XEXP (trueop0, 1); machine_mode mode0 = GET_MODE (subop0); machine_mode mode1 = GET_MODE (subop1); - int l0 = GET_MODE_NUNITS (mode0); - int l1 = GET_MODE_NUNITS (mode1); int i0 = INTVAL (XVECEXP (trueop1, 0, 0)); if (i0 == 0 && !side_effects_p (op1) && mode == mode0) { @@ -3875,7 +3880,7 @@ simplify_binary_operation_1 (enum rtx_co { rtx op0_subop1 = XEXP (trueop0, 1); gcc_assert (GET_CODE (op0_subop1) == PARALLEL); - gcc_assert (XVECLEN (trueop1, 0) == GET_MODE_NUNITS (mode)); + gcc_assert (must_eq (XVECLEN (trueop1, 0), GET_MODE_NUNITS (mode))); /* Apply the outer ordering vector to the inner one. (The inner ordering vector is expressly permitted to be of a different @@ -3919,15 +3924,16 @@ simplify_binary_operation_1 (enum rtx_co else gcc_assert (GET_MODE_INNER (mode) == op1_mode); + unsigned int n_elts, in_n_elts; if ((GET_CODE (trueop0) == CONST_VECTOR || CONST_SCALAR_INT_P (trueop0) || CONST_DOUBLE_AS_FLOAT_P (trueop0)) && (GET_CODE (trueop1) == CONST_VECTOR || CONST_SCALAR_INT_P (trueop1) - || CONST_DOUBLE_AS_FLOAT_P (trueop1))) + || CONST_DOUBLE_AS_FLOAT_P (trueop1)) + && GET_MODE_NUNITS (mode).is_constant (&n_elts) + && GET_MODE_NUNITS (op0_mode).is_constant (&in_n_elts)) { - unsigned n_elts = GET_MODE_NUNITS (mode); - unsigned in_n_elts = GET_MODE_NUNITS (op0_mode); rtvec v = rtvec_alloc (n_elts); unsigned int i; for (i = 0; i < n_elts; i++) @@ -4019,7 +4025,7 @@ simplify_const_binary_operation (enum rt { unsigned int n_elts = CONST_VECTOR_NUNITS (op0); gcc_assert (n_elts == (unsigned int) CONST_VECTOR_NUNITS (op1)); - gcc_assert (n_elts == GET_MODE_NUNITS (mode)); + gcc_assert (must_eq (n_elts, GET_MODE_NUNITS (mode))); rtvec v = rtvec_alloc (n_elts); unsigned int i; @@ -4045,7 +4051,9 @@ simplify_const_binary_operation (enum rt || CONST_DOUBLE_AS_FLOAT_P (op1) || GET_CODE (op1) == CONST_FIXED)) { - unsigned n_elts = GET_MODE_NUNITS (mode); + /* Both inputs have a constant number of elements, so the result + must too. */ + unsigned n_elts = GET_MODE_NUNITS (mode).to_constant (); rtvec v = rtvec_alloc (n_elts); gcc_assert (n_elts >= 2); @@ -4059,8 +4067,8 @@ simplify_const_binary_operation (enum rt } else { - unsigned op0_n_elts = GET_MODE_NUNITS (GET_MODE (op0)); - unsigned op1_n_elts = GET_MODE_NUNITS (GET_MODE (op1)); + unsigned op0_n_elts = GET_MODE_NUNITS (GET_MODE (op0)).to_constant (); + unsigned op1_n_elts = GET_MODE_NUNITS (GET_MODE (op1)).to_constant (); unsigned i; gcc_assert (GET_CODE (op0) == CONST_VECTOR); @@ -5563,6 +5571,7 @@ simplify_ternary_operation (enum rtx_cod bool any_change = false; rtx tem, trueop2; scalar_int_mode int_mode, int_op0_mode; + unsigned int n_elts; switch (code) { @@ -5748,9 +5757,9 @@ simplify_ternary_operation (enum rtx_cod gcc_assert (GET_MODE (op1) == mode); gcc_assert (VECTOR_MODE_P (mode)); trueop2 = avoid_constant_pool_reference (op2); - if (CONST_INT_P (trueop2)) + if (CONST_INT_P (trueop2) + && GET_MODE_NUNITS (mode).is_constant (&n_elts)) { - unsigned n_elts = GET_MODE_NUNITS (mode); unsigned HOST_WIDE_INT sel = UINTVAL (trueop2); unsigned HOST_WIDE_INT mask; if (n_elts == HOST_BITS_PER_WIDE_INT) @@ -5814,7 +5823,7 @@ simplify_ternary_operation (enum rtx_cod if (GET_CODE (op0) == VEC_DUPLICATE && GET_CODE (XEXP (op0, 0)) == VEC_SELECT && GET_CODE (XEXP (XEXP (op0, 0), 1)) == PARALLEL - && mode_nunits[GET_MODE (XEXP (op0, 0))] == 1) + && must_eq (GET_MODE_NUNITS (GET_MODE (XEXP (op0, 0))), 1)) { tem = XVECEXP ((XEXP (XEXP (op0, 0), 1)), 0, 0); if (CONST_INT_P (tem) && CONST_INT_P (op2)) @@ -6574,7 +6583,7 @@ test_vector_ops_duplicate (machine_mode { scalar_mode inner_mode = GET_MODE_INNER (mode); rtx duplicate = gen_rtx_VEC_DUPLICATE (mode, scalar_reg); - unsigned int nunits = GET_MODE_NUNITS (mode); + poly_uint64 nunits = GET_MODE_NUNITS (mode); if (GET_MODE_CLASS (mode) == MODE_VECTOR_INT) { /* Test some simple unary cases with VEC_DUPLICATE arguments. */ @@ -6611,11 +6620,15 @@ test_vector_ops_duplicate (machine_mode duplicate, zero_par)); /* And again with the final element. */ - rtx last_index = gen_int_mode (GET_MODE_NUNITS (mode) - 1, word_mode); - rtx last_par = gen_rtx_PARALLEL (VOIDmode, gen_rtvec (1, last_index)); - ASSERT_RTX_PTR_EQ (scalar_reg, - simplify_binary_operation (VEC_SELECT, inner_mode, - duplicate, last_par)); + unsigned HOST_WIDE_INT const_nunits; + if (nunits.is_constant (&const_nunits)) + { + rtx last_index = gen_int_mode (const_nunits - 1, word_mode); + rtx last_par = gen_rtx_PARALLEL (VOIDmode, gen_rtvec (1, last_index)); + ASSERT_RTX_PTR_EQ (scalar_reg, + simplify_binary_operation (VEC_SELECT, inner_mode, + duplicate, last_par)); + } /* Test a scalar subreg of a VEC_DUPLICATE. */ poly_uint64 offset = subreg_lowpart_offset (inner_mode, mode); @@ -6624,7 +6637,7 @@ test_vector_ops_duplicate (machine_mode mode, offset)); machine_mode narrower_mode; - if (nunits > 2 + if (may_gt (nunits, 2U) && mode_for_vector (inner_mode, 2).exists (&narrower_mode) && VECTOR_MODE_P (narrower_mode)) { @@ -6712,7 +6725,7 @@ test_vector_ops () rtx scalar_reg = make_test_reg (GET_MODE_INNER (mode)); test_vector_ops_duplicate (mode, scalar_reg); if (GET_MODE_CLASS (mode) == MODE_VECTOR_INT - && GET_MODE_NUNITS (mode) > 2) + && may_gt (GET_MODE_NUNITS (mode), 2)) test_vector_ops_series (mode, scalar_reg); } } Index: gcc/tree-vect-data-refs.c =================================================================== --- gcc/tree-vect-data-refs.c 2017-10-23 17:22:44.864968082 +0100 +++ gcc/tree-vect-data-refs.c 2017-10-23 17:25:48.623491897 +0100 @@ -4568,9 +4568,10 @@ vect_grouped_store_supported (tree vecty } /* Check that the permutation is supported. */ - if (VECTOR_MODE_P (mode)) + unsigned int nelt; + if (VECTOR_MODE_P (mode) && GET_MODE_NUNITS (mode).is_constant (&nelt)) { - unsigned int i, nelt = GET_MODE_NUNITS (mode); + unsigned int i; auto_vec_perm_indices sel (nelt); sel.quick_grow (nelt); @@ -5156,9 +5157,10 @@ vect_grouped_load_supported (tree vectyp } /* Check that the permutation is supported. */ - if (VECTOR_MODE_P (mode)) + unsigned int nelt; + if (VECTOR_MODE_P (mode) && GET_MODE_NUNITS (mode).is_constant (&nelt)) { - unsigned int i, j, nelt = GET_MODE_NUNITS (mode); + unsigned int i, j; auto_vec_perm_indices sel (nelt); sel.quick_grow (nelt); Index: gcc/tree-vect-generic.c =================================================================== --- gcc/tree-vect-generic.c 2017-10-23 17:22:45.856865193 +0100 +++ gcc/tree-vect-generic.c 2017-10-23 17:25:48.623491897 +0100 @@ -1159,7 +1159,7 @@ type_for_widest_vector_mode (tree type, { machine_mode inner_mode = TYPE_MODE (type); machine_mode best_mode = VOIDmode, mode; - int best_nunits = 0; + poly_int64 best_nunits = 0; if (SCALAR_FLOAT_MODE_P (inner_mode)) mode = MIN_MODE_VECTOR_FLOAT; @@ -1176,7 +1176,7 @@ type_for_widest_vector_mode (tree type, FOR_EACH_MODE_FROM (mode, mode) if (GET_MODE_INNER (mode) == inner_mode - && GET_MODE_NUNITS (mode) > best_nunits + && may_gt (GET_MODE_NUNITS (mode), best_nunits) && optab_handler (op, mode) != CODE_FOR_nothing) best_mode = mode, best_nunits = GET_MODE_NUNITS (mode); Index: gcc/tree-vect-loop.c =================================================================== --- gcc/tree-vect-loop.c 2017-10-23 17:22:37.879692661 +0100 +++ gcc/tree-vect-loop.c 2017-10-23 17:25:48.624491861 +0100 @@ -3750,10 +3750,13 @@ have_whole_vector_shift (machine_mode mo if (direct_optab_handler (vec_perm_const_optab, mode) == CODE_FOR_nothing) return false; - unsigned int i, nelt = GET_MODE_NUNITS (mode); - auto_vec_perm_indices sel (nelt); + /* Variable-length vectors should be handled via the optab. */ + unsigned int nelt; + if (!GET_MODE_NUNITS (mode).is_constant (&nelt)) + return false; - for (i = nelt/2; i >= 1; i/=2) + auto_vec_perm_indices sel (nelt); + for (unsigned int i = nelt / 2; i >= 1; i /= 2) { sel.truncate (0); calc_vec_perm_mask_for_shift (i, nelt, &sel); Index: gcc/ada/gcc-interface/misc.c =================================================================== --- gcc/ada/gcc-interface/misc.c 2017-10-23 11:41:24.995420946 +0100 +++ gcc/ada/gcc-interface/misc.c 2017-10-23 17:25:48.617492113 +0100 @@ -1298,9 +1298,10 @@ enumerate_modes (void (*f) (const char * } /* If no predefined C types were found, register the mode itself. */ - if (!skip_p) + int nunits; + if (!skip_p && GET_MODE_NUNITS (i).is_constant (&nunits)) f (GET_MODE_NAME (i), digs, complex_p, - vector_p ? GET_MODE_NUNITS (i) : 0, float_rep, + vector_p ? nunits : 0, float_rep, GET_MODE_PRECISION (i), GET_MODE_BITSIZE (i), GET_MODE_ALIGNMENT (i)); }