From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 42671 invoked by alias); 9 Dec 2016 13:30:00 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Received: (qmail 42631 invoked by uid 89); 9 Dec 2016 13:29:57 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-4.9 required=5.0 tests=BAYES_00,RP_MATCHES_RCVD,SPF_PASS autolearn=ham version=3.3.2 spammy=30408, representative X-HELO: foss.arm.com Received: from foss.arm.com (HELO foss.arm.com) (217.140.101.70) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Fri, 09 Dec 2016 13:29:47 +0000 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.72.51.249]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 46DDEC14; Fri, 9 Dec 2016 05:29:46 -0800 (PST) Received: from localhost (e105548-lin.manchester.arm.com [10.45.32.67]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id C58A63F477 for ; Fri, 9 Dec 2016 05:29:45 -0800 (PST) From: Richard Sandiford To: gcc-patches@gcc.gnu.org Mail-Followup-To: gcc-patches@gcc.gnu.org, richard.sandiford@arm.com Subject: [51/67] Use opt_scalar_int_mode when iterating over integer modes References: <87h96dp8u6.fsf@e105548-lin.cambridge.arm.com> Date: Fri, 09 Dec 2016 13:30:00 -0000 In-Reply-To: <87h96dp8u6.fsf@e105548-lin.cambridge.arm.com> (Richard Sandiford's message of "Fri, 09 Dec 2016 12:48:01 +0000") Message-ID: <87d1h1grhz.fsf@e105548-lin.cambridge.arm.com> User-Agent: Gnus/5.130012 (Ma Gnus v0.12) Emacs/24.3 (gnu/linux) MIME-Version: 1.0 Content-Type: text/plain X-SW-Source: 2016-12/txt/msg00827.txt.bz2 This patch uses opt_scalar_int_mode rather than machine_mode when iterating over scalar_int_modes, in cases where that helps with future patches. (Using machine_mode is still OK in places that don't really care about the mode being a scalar integer.) gcc/ 2016-11-24 Richard Sandiford Alan Hayward David Sherwood * cse.c (cse_insn): Use opt_scalar_int_mode for the mode iterator. * explow.c (hard_function_value): Likewise. * expmed.c (init_expmed_one_mode): Likewise. (extract_fixed_bit_field_1): Likewise. Move the convert_to_mode call outside the loop. * expr.c (alignment_for_piecewise_move): Use opt_scalar_int_mode for the mode iterator. Require the mode specified by max_pieces to exist. (emit_block_move_via_movmem): Use opt_scalar_int_mode for the mode iterator. (copy_blkmode_to_reg): Likewise. (set_storage_via_setmem): Likewise. * optabs.c (prepare_cmp_insn): Likewise. * rtlanal.c (init_num_sign_bit_copies): Likewise. * stor-layout.c (finish_bitfield_repreentation): Likewise. gcc/fortran/ 2016-11-24 Richard Sandiford Alan Hayward David Sherwood * trans-types.c (gfc_init_kinds): Use opt_scalar_int_mode for the mode iterator. diff --git a/gcc/cse.c b/gcc/cse.c index 4d22d78..81db2a0 100644 --- a/gcc/cse.c +++ b/gcc/cse.c @@ -4885,11 +4885,12 @@ cse_insn (rtx_insn *insn) && GET_CODE (src) == AND && CONST_INT_P (XEXP (src, 1)) && GET_MODE_SIZE (int_mode) < UNITS_PER_WORD) { - machine_mode tmode; + opt_scalar_int_mode tmode_iter; rtx new_and = gen_rtx_AND (VOIDmode, NULL_RTX, XEXP (src, 1)); - FOR_EACH_WIDER_MODE (tmode, int_mode) + FOR_EACH_WIDER_MODE (tmode_iter, int_mode) { + scalar_int_mode tmode = *tmode_iter; if (GET_MODE_SIZE (tmode) > UNITS_PER_WORD) break; @@ -4932,7 +4933,6 @@ cse_insn (rtx_insn *insn) { struct rtx_def memory_extend_buf; rtx memory_extend_rtx = &memory_extend_buf; - machine_mode tmode; /* Set what we are trying to extend and the operation it might have been extended with. */ @@ -4940,10 +4940,12 @@ cse_insn (rtx_insn *insn) PUT_CODE (memory_extend_rtx, extend_op); XEXP (memory_extend_rtx, 0) = src; - FOR_EACH_WIDER_MODE (tmode, int_mode) + opt_scalar_int_mode tmode_iter; + FOR_EACH_WIDER_MODE (tmode_iter, int_mode) { struct table_elt *larger_elt; + scalar_int_mode tmode = *tmode_iter; if (GET_MODE_SIZE (tmode) > UNITS_PER_WORD) break; diff --git a/gcc/explow.c b/gcc/explow.c index 65b78ab..6348035 100644 --- a/gcc/explow.c +++ b/gcc/explow.c @@ -1911,7 +1911,7 @@ hard_function_value (const_tree valtype, const_tree func, const_tree fntype, && GET_MODE (val) == BLKmode) { unsigned HOST_WIDE_INT bytes = int_size_in_bytes (valtype); - machine_mode tmpmode; + opt_scalar_int_mode tmpmode; /* int_size_in_bytes can return -1. We don't need a check here since the value of bytes will then be large enough that no @@ -1920,14 +1920,11 @@ hard_function_value (const_tree valtype, const_tree func, const_tree fntype, FOR_EACH_MODE_IN_CLASS (tmpmode, MODE_INT) { /* Have we found a large enough mode? */ - if (GET_MODE_SIZE (tmpmode) >= bytes) + if (GET_MODE_SIZE (*tmpmode) >= bytes) break; } - /* No suitable mode found. */ - gcc_assert (tmpmode != VOIDmode); - - PUT_MODE (val, tmpmode); + PUT_MODE (val, *tmpmode); } return val; } diff --git a/gcc/expmed.c b/gcc/expmed.c index 71e1fa8..5ae4842 100644 --- a/gcc/expmed.c +++ b/gcc/expmed.c @@ -205,8 +205,9 @@ init_expmed_one_mode (struct init_expmed_rtl *all, scalar_int_mode int_mode_to; if (is_a (mode, &int_mode_to)) { - FOR_EACH_MODE_IN_CLASS (mode_from, MODE_INT) - init_expmed_one_conv (all, int_mode_to, mode_from, speed); + opt_scalar_int_mode int_mode_from; + FOR_EACH_MODE_IN_CLASS (int_mode_from, MODE_INT) + init_expmed_one_conv (all, int_mode_to, *int_mode_from, speed); scalar_int_mode wider_mode; if (GET_MODE_CLASS (int_mode_to) == MODE_INT @@ -2009,12 +2010,13 @@ extract_fixed_bit_field_1 (machine_mode tmode, rtx op0, /* Find the narrowest integer mode that contains the field. */ - FOR_EACH_MODE_IN_CLASS (mode, MODE_INT) - if (GET_MODE_BITSIZE (mode) >= bitsize + bitnum) - { - op0 = convert_to_mode (mode, op0, 0); - break; - } + opt_scalar_int_mode mode_iter; + FOR_EACH_MODE_IN_CLASS (mode_iter, MODE_INT) + if (GET_MODE_BITSIZE (*mode_iter) >= bitsize + bitnum) + break; + + mode = *mode_iter; + op0 = convert_to_mode (mode, op0, 0); if (mode != tmode) target = 0; diff --git a/gcc/expr.c b/gcc/expr.c index f682925..ec88d35 100644 --- a/gcc/expr.c +++ b/gcc/expr.c @@ -697,18 +697,17 @@ convert_modes (machine_mode mode, machine_mode oldmode, rtx x, int unsignedp) static unsigned int alignment_for_piecewise_move (unsigned int max_pieces, unsigned int align) { - machine_mode tmode; + scalar_int_mode tmode = *int_mode_for_size (max_pieces * BITS_PER_UNIT, 1); - tmode = mode_for_size (max_pieces * BITS_PER_UNIT, MODE_INT, 1); if (align >= GET_MODE_ALIGNMENT (tmode)) align = GET_MODE_ALIGNMENT (tmode); else { - machine_mode tmode, xmode; - - xmode = NARROWEST_INT_MODE; - FOR_EACH_MODE_IN_CLASS (tmode, MODE_INT) + scalar_int_mode xmode = NARROWEST_INT_MODE; + opt_scalar_int_mode mode_iter; + FOR_EACH_MODE_IN_CLASS (mode_iter, MODE_INT) { + tmode = *mode_iter; if (GET_MODE_SIZE (tmode) > max_pieces || SLOW_UNALIGNED_ACCESS (tmode, align)) break; @@ -1704,7 +1703,6 @@ emit_block_move_via_movmem (rtx x, rtx y, rtx size, unsigned int align, unsigned HOST_WIDE_INT probable_max_size) { int save_volatile_ok = volatile_ok; - machine_mode mode; if (expected_align < align) expected_align = align; @@ -1723,8 +1721,10 @@ emit_block_move_via_movmem (rtx x, rtx y, rtx size, unsigned int align, including more than one in the machine description unless the more limited one has some advantage. */ - FOR_EACH_MODE_IN_CLASS (mode, MODE_INT) + opt_scalar_int_mode mode_iter; + FOR_EACH_MODE_IN_CLASS (mode_iter, MODE_INT) { + scalar_int_mode mode = *mode_iter; enum insn_code code = direct_optab_handler (movmem_optab, mode); if (code != CODE_FOR_nothing @@ -2784,13 +2784,13 @@ copy_blkmode_to_reg (machine_mode mode, tree src) { /* Find the smallest integer mode large enough to hold the entire structure. */ - FOR_EACH_MODE_IN_CLASS (mode, MODE_INT) - /* Have we found a large enough mode? */ - if (GET_MODE_SIZE (mode) >= bytes) + opt_scalar_int_mode mode_iter; + FOR_EACH_MODE_IN_CLASS (mode_iter, MODE_INT) + if (GET_MODE_SIZE (*mode_iter) >= bytes) break; /* A suitable mode should have been found. */ - gcc_assert (mode != VOIDmode); + mode = *mode_iter; } if (GET_MODE_SIZE (mode) < GET_MODE_SIZE (word_mode)) @@ -3028,8 +3028,6 @@ set_storage_via_setmem (rtx object, rtx size, rtx val, unsigned int align, including more than one in the machine description unless the more limited one has some advantage. */ - machine_mode mode; - if (expected_align < align) expected_align = align; if (expected_size != -1) @@ -3040,8 +3038,10 @@ set_storage_via_setmem (rtx object, rtx size, rtx val, unsigned int align, expected_size = min_size; } - FOR_EACH_MODE_IN_CLASS (mode, MODE_INT) + opt_scalar_int_mode mode_iter; + FOR_EACH_MODE_IN_CLASS (mode_iter, MODE_INT) { + scalar_int_mode mode = *mode_iter; enum insn_code code = direct_optab_handler (setmem_optab, mode); if (code != CODE_FOR_nothing diff --git a/gcc/fortran/trans-types.c b/gcc/fortran/trans-types.c index 50aae8e..de6ce42 100644 --- a/gcc/fortran/trans-types.c +++ b/gcc/fortran/trans-types.c @@ -347,15 +347,16 @@ gfc_init_c_interop_kinds (void) void gfc_init_kinds (void) { - machine_mode_enum mode; + opt_scalar_int_mode int_mode_iter; opt_scalar_float_mode float_mode_iter; int i_index, r_index, kind; bool saw_i4 = false, saw_i8 = false; bool saw_r4 = false, saw_r8 = false, saw_r10 = false, saw_r16 = false; - for (i_index = 0, mode = MIN_MODE_INT; mode <= MAX_MODE_INT; - mode = (machine_mode_enum) ((int) mode + 1)) + i_index = 0; + FOR_EACH_MODE_IN_CLASS (int_mode_iter, MODE_INT) { + scalar_int_mode mode = *int_mode_iter; int kind, bitsize; if (!targetm.scalar_mode_supported_p (mode)) diff --git a/gcc/optabs.c b/gcc/optabs.c index 054457a..509f0d3 100644 --- a/gcc/optabs.c +++ b/gcc/optabs.c @@ -3797,8 +3797,10 @@ prepare_cmp_insn (rtx x, rtx y, enum rtx_code comparison, rtx size, /* Try to use a memory block compare insn - either cmpstr or cmpmem will do. */ - FOR_EACH_MODE_IN_CLASS (cmp_mode, MODE_INT) + opt_scalar_int_mode cmp_mode_iter; + FOR_EACH_MODE_IN_CLASS (cmp_mode_iter, MODE_INT) { + scalar_int_mode cmp_mode = *cmp_mode_iter; cmp_code = direct_optab_handler (cmpmem_optab, cmp_mode); if (cmp_code == CODE_FOR_nothing) cmp_code = direct_optab_handler (cmpstr_optab, cmp_mode); diff --git a/gcc/rtlanal.c b/gcc/rtlanal.c index 42d08a2..f74bf14 100644 --- a/gcc/rtlanal.c +++ b/gcc/rtlanal.c @@ -5603,12 +5603,14 @@ get_condition (rtx_insn *jump, rtx_insn **earliest, int allow_cc_mode, static void init_num_sign_bit_copies_in_rep (void) { - machine_mode mode, in_mode; + opt_scalar_int_mode in_mode_iter; + scalar_int_mode mode; - FOR_EACH_MODE_IN_CLASS (in_mode, MODE_INT) - FOR_EACH_MODE_UNTIL (mode, in_mode) + FOR_EACH_MODE_IN_CLASS (in_mode_iter, MODE_INT) + FOR_EACH_MODE_UNTIL (mode, *in_mode_iter) { - machine_mode i; + scalar_int_mode in_mode = *in_mode_iter; + scalar_int_mode i; /* Currently, it is assumed that TARGET_MODE_REP_EXTENDED extends to the next widest mode. */ @@ -5621,7 +5623,7 @@ init_num_sign_bit_copies_in_rep (void) { /* This must always exist (for the last iteration it will be IN_MODE). */ - machine_mode wider = *GET_MODE_WIDER_MODE (i); + scalar_int_mode wider = *GET_MODE_WIDER_MODE (i); if (targetm.mode_rep_extended (i, wider) == SIGN_EXTEND /* We can only check sign-bit copies starting from the diff --git a/gcc/stor-layout.c b/gcc/stor-layout.c index d872dae..8ff73ef 100644 --- a/gcc/stor-layout.c +++ b/gcc/stor-layout.c @@ -1818,7 +1818,6 @@ static void finish_bitfield_representative (tree repr, tree field) { unsigned HOST_WIDE_INT bitsize, maxbitsize; - machine_mode mode; tree nextf, size; size = size_diffop (DECL_FIELD_OFFSET (field), @@ -1882,15 +1881,15 @@ finish_bitfield_representative (tree repr, tree field) gcc_assert (maxbitsize % BITS_PER_UNIT == 0); /* Find the smallest nice mode to use. */ - FOR_EACH_MODE_IN_CLASS (mode, MODE_INT) - if (GET_MODE_BITSIZE (mode) >= bitsize) + opt_scalar_int_mode mode_iter; + FOR_EACH_MODE_IN_CLASS (mode_iter, MODE_INT) + if (GET_MODE_BITSIZE (*mode_iter) >= bitsize) break; - if (mode != VOIDmode - && (GET_MODE_BITSIZE (mode) > maxbitsize - || GET_MODE_BITSIZE (mode) > MAX_FIXED_MODE_SIZE)) - mode = VOIDmode; - if (mode == VOIDmode) + scalar_int_mode mode; + if (!mode_iter.exists (&mode) + || GET_MODE_BITSIZE (mode) > maxbitsize + || GET_MODE_BITSIZE (mode) > MAX_FIXED_MODE_SIZE) { /* We really want a BLKmode representative only as a last resort, considering the member b in