From patchwork Tue Aug 27 17:44:14 2013 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Kenneth Zadeck X-Patchwork-Id: 270171 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) (using TLSv1 with cipher DHE-RSA-AES256-SHA (256/256 bits)) (Client CN "www.sourceware.org", Issuer "StartCom Class 1 Primary Intermediate Server CA" (not verified)) by ozlabs.org (Postfix) with ESMTPS id E0FB92C0082 for ; Wed, 28 Aug 2013 03:44:27 +1000 (EST) DomainKey-Signature: a=rsa-sha1; c=nofws; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender :message-id:date:from:mime-version:to:subject:content-type; q= dns; s=default; b=Mgjk965k02M722N7S20X7MrXxNsjsrJs/inlh/LsMKp2L9 6+yheDAzkanInBwSR7nQHqtA8D1hAiAWMQynVvwnJuq0ncH0RkTf2HIfxLQcUKrp MNvs3gSVUJzJMAPReKtJLkbdjWa2gKVCbjwCaMw3F1BJiS8o6BkC32XioYkHQ= 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 :message-id:date:from:mime-version:to:subject:content-type; s= default; bh=Q21S9W2K61agr6U80glc0e8ekrQ=; b=oDD2PC6l72lYRzWSzkte CwN4R6S+Dxxix8a82+/EFiomA2xkwvmYaQFCYMRP+eyNEPfIr93NQ4CQp2rI860Y R/HuMtxsIeGHe7dDItCMxBnwGt79WEGZAZMrU4RyRqW93Uk+H0guK1YTqE9uDZhX wRVt8Tm3sAht5GZPS7Sp2ME= Received: (qmail 13976 invoked by alias); 27 Aug 2013 17:44:20 -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 13966 invoked by uid 89); 27 Aug 2013 17:44:20 -0000 Received: from mail-ob0-f177.google.com (HELO mail-ob0-f177.google.com) (209.85.214.177) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with (AES128-SHA encrypted) ESMTPS; Tue, 27 Aug 2013 17:44:20 +0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-2.8 required=5.0 tests=ALL_TRUSTED, AWL, BAYES_00 autolearn=ham version=3.3.2 X-HELO: mail-ob0-f177.google.com Received: by mail-ob0-f177.google.com with SMTP id f8so5189320obp.36 for ; Tue, 27 Aug 2013 10:44:16 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20120113; h=x-gm-message-state:message-id:date:from:user-agent:mime-version:to :subject:content-type; bh=DkbzBvtknaoAdK77AKo1b2Pu5KSbUmhOAxXlZ1F3V3E=; b=Q/Jkuq8mftXqe/oZF/Gms9tI3L8OWjW6rCI9cYgMxoOYCF/b8F0NPujuS5i8E3j1sV pMldxhB70X7Or17q8hv+qni4WuPSvLdrPgVU1+RVkanmgE3E2zyCBpGZXIVTbb+TQSXH 4Y0nyNxkGkvoitaB2kwdIL4gdAmtrbnoQ77g4jrMsAnz9gdzcm5wvhqkiA4+86RzKEe4 POtVgaEb+birDBIY0J35sFJP9IIiXUeuIbgfZwUiEm1gePTqZ+KM22MTXg3gQ9FfJRha Mq9o3lDQ16Wke4evO+yDGVjsBWbcpeMds6IGC0WS/QzdlcmIdCzrQNL9nIkmVNkI4Anr whKw== X-Gm-Message-State: ALoCoQn1Tm9uEIErR9D5taPdJbqjKTxpqZZHLOvDPM7sSRdz3VOrgONp445EOK7+yRwyzdJJgw0e X-Received: by 10.50.114.168 with SMTP id jh8mr10598390igb.6.1377625456832; Tue, 27 Aug 2013 10:44:16 -0700 (PDT) Received: from moria.site (pool-98-113-157-218.nycmny.fios.verizon.net. [98.113.157.218]) by mx.google.com with ESMTPSA id q4sm25491809igp.6.1969.12.31.16.00.00 (version=TLSv1 cipher=ECDHE-RSA-RC4-SHA bits=128/128); Tue, 27 Aug 2013 10:44:16 -0700 (PDT) Message-ID: <521CE56E.5010605@naturalbridge.com> Date: Tue, 27 Aug 2013 13:44:14 -0400 From: Kenneth Zadeck User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:17.0) Gecko/20130801 Thunderbird/17.0.8 MIME-Version: 1.0 To: Richard Sandiford , rguenther@suse.de, Mike Stump , gcc-patches Subject: wide-int branch updated. removed all knowledge of SHIFT_COUNT_TRUNCATED from wide-int both Richard Biener and Richard Sandiford had commented negatively about this. fixed bug with wide-int::fits_uhwi_p. kenny Index: gcc/fold-const.c =================================================================== --- gcc/fold-const.c (revision 201985) +++ gcc/fold-const.c (working copy) @@ -992,9 +992,9 @@ int_const_binop_1 (enum tree_code code, /* It's unclear from the C standard whether shifts can overflow. The following code ignores overflow; perhaps a C standard interpretation ruling is needed. */ - res = op1.rshift (arg2, sign, GET_MODE_BITSIZE (TYPE_MODE (type)), TRUNC); + res = op1.rshift (arg2, sign, GET_MODE_BITSIZE (TYPE_MODE (type))); else - res = op1.lshift (arg2, GET_MODE_BITSIZE (TYPE_MODE (type)), TRUNC); + res = op1.lshift (arg2, GET_MODE_BITSIZE (TYPE_MODE (type))); break; case RROTATE_EXPR: Index: gcc/simplify-rtx.c =================================================================== --- gcc/simplify-rtx.c (revision 201985) +++ gcc/simplify-rtx.c (working copy) @@ -3507,9 +3507,7 @@ rtx simplify_const_binary_operation (enum rtx_code code, enum machine_mode mode, rtx op0, rtx op1) { -#if TARGET_SUPPORTS_WIDE_INT == 0 unsigned int width = GET_MODE_PRECISION (mode); -#endif if (VECTOR_MODE_P (mode) && code != VEC_CONCAT @@ -3787,40 +3785,45 @@ simplify_const_binary_operation (enum rt break; case LSHIFTRT: - if (wide_int (std::make_pair (op1, mode)).neg_p ()) - return NULL_RTX; - - result = wop0.rshiftu (pop1, bitsize, TRUNC); - break; - case ASHIFTRT: - if (wide_int (std::make_pair (op1, mode)).neg_p ()) - return NULL_RTX; - - result = wop0.rshifts (pop1, bitsize, TRUNC); - break; - case ASHIFT: - if (wide_int (std::make_pair (op1, mode)).neg_p ()) - return NULL_RTX; - - result = wop0.lshift (pop1, bitsize, TRUNC); - break; - case ROTATE: - if (wide_int (std::make_pair (op1, mode)).neg_p ()) - return NULL_RTX; - - result = wop0.lrotate (pop1); - break; - case ROTATERT: - if (wide_int (std::make_pair (op1, mode)).neg_p ()) - return NULL_RTX; + { + wide_int wop1 = pop1; + if (wop1.neg_p ()) + return NULL_RTX; - result = wop0.rrotate (pop1); - break; + if (SHIFT_COUNT_TRUNCATED) + wop1 = wop1.umod_trunc (width); + switch (code) + { + case LSHIFTRT: + result = wop0.rshiftu (wop1, bitsize); + break; + + case ASHIFTRT: + result = wop0.rshifts (wop1, bitsize); + break; + + case ASHIFT: + result = wop0.lshift (wop1, bitsize); + break; + + case ROTATE: + result = wop0.lrotate (wop1); + break; + + case ROTATERT: + result = wop0.rrotate (wop1); + break; + + default: + gcc_unreachable (); + } + break; + } default: return NULL_RTX; } Index: gcc/wide-int.cc =================================================================== --- gcc/wide-int.cc (revision 201985) +++ gcc/wide-int.cc (working copy) @@ -2404,7 +2404,12 @@ wide_int_ro::divmod_internal_2 (unsigned /* Do a truncating divide DIVISOR into DIVIDEND. The result is the - same size as the operands. SIGN is either SIGNED or UNSIGNED. */ + same size as the operands. SIGN is either SIGNED or UNSIGNED. If + COMPUTE_QUOTIENT is set, the quotient is computed and returned. If + it is not set, the result is undefined. If COMPUTE_REMAINDER is + set, the remaineder is returned in remainder. If it is not set, + the remainder is undefined. If OFLOW is not null, it is set to the + overflow value. */ wide_int_ro wide_int_ro::divmod_internal (bool compute_quotient, const HOST_WIDE_INT *dividend, @@ -2470,6 +2475,10 @@ wide_int_ro::divmod_internal (bool compu quotient.precision = dividend_prec; remainder->precision = dividend_prec; + /* Initialize the incoming overflow if it has been provided. */ + if (oflow) + *oflow = false; + /* If overflow is set, just get out. There will only be grief by continuing. */ if (overflow) Index: gcc/wide-int.h =================================================================== --- gcc/wide-int.h (revision 201995) +++ gcc/wide-int.h (working copy) @@ -259,19 +259,6 @@ const int addr_max_bitsize = 64; const int addr_max_precision = ((addr_max_bitsize + 4 + HOST_BITS_PER_WIDE_INT - 1) & ~(HOST_BITS_PER_WIDE_INT - 1)); -enum ShiftOp { - NONE, - /* There are two uses for the wide-int shifting functions. The - first use is as an emulation of the target hardware. The - second use is as service routines for other optimizations. The - first case needs to be identified by passing TRUNC as the value - of ShiftOp so that shift amount is properly handled according to the - SHIFT_COUNT_TRUNCATED flag. For the second case, the shift - amount is always truncated by the bytesize of the mode of - THIS. */ - TRUNC -}; - /* This is used to bundle an rtx and a mode together so that the pair can be used as the second operand of a wide int expression. If we ever put modes into rtx integer constants, this should go away and @@ -661,7 +648,7 @@ public: HOST_WIDE_INT extract_to_hwi (int, int) const; template - wide_int_ro lshift (const T &, unsigned int = 0, ShiftOp = NONE) const; + wide_int_ro lshift (const T &, unsigned int = 0) const; template wide_int_ro lshift_widen (const T &, unsigned int) const; @@ -672,14 +659,13 @@ public: wide_int_ro lrotate (unsigned HOST_WIDE_INT, unsigned int = 0) const; template - wide_int_ro rshift (const T &, signop, unsigned int = 0, - ShiftOp = NONE) const; + wide_int_ro rshift (const T &, signop, unsigned int = 0) const; template - wide_int_ro rshiftu (const T &, unsigned int = 0, ShiftOp = NONE) const; + wide_int_ro rshiftu (const T &, unsigned int = 0) const; template - wide_int_ro rshifts (const T &, unsigned int = 0, ShiftOp = NONE) const; + wide_int_ro rshifts (const T &, unsigned int = 0) const; template wide_int_ro rrotate (const T &, unsigned int = 0) const; @@ -749,13 +735,11 @@ private: signop, wide_int_ro *, bool, bool *); /* Private utility routines. */ + int trunc_shift (const HOST_WIDE_INT *cnt, unsigned int bitsize) const; wide_int_ro decompress (unsigned int, unsigned int) const; void canonize (); static wide_int_ro from_rtx (const rtx_mode_t); - int trunc_shift (const HOST_WIDE_INT *, unsigned int, unsigned int, - ShiftOp) const; - template static bool top_bit_set (T); @@ -1650,7 +1634,10 @@ wide_int_ro::fits_shwi_p () const inline bool wide_int_ro::fits_uhwi_p () const { - return (len == 1 && val[0] >= 0) || (len == 2 && val[1] == 0); + return (precision <= HOST_BITS_PER_WIDE_INT) + || (len == 1 && val[0] >= 0) + || (len == 2 && (precision >= 2 * HOST_BITS_PER_WIDE_INT) && (val[1] == 0)) + || (len == 2 && (sext_hwi (val[1], precision & (HOST_BITS_PER_WIDE_INT - 1)) == 0)); } /* Return the signed or unsigned min of THIS and C. */ @@ -2358,8 +2345,6 @@ wide_int_ro::div_trunc (const T &c, sign unsigned int cl; unsigned int p1, p2; - if (overflow) - *overflow = false; p1 = precision; s = to_shwi1 (ws, &cl, &p2, c); check_precision (&p1, &p2, false, true); @@ -2399,8 +2384,6 @@ wide_int_ro::div_floor (const T &c, sign unsigned int cl; unsigned int p1, p2; - if (overflow) - *overflow = false; p1 = precision; s = to_shwi1 (ws, &cl, &p2, c); check_precision (&p1, &p2, false, true); @@ -2440,8 +2423,6 @@ wide_int_ro::div_ceil (const T &c, signo unsigned int cl; unsigned int p1, p2; - if (overflow) - *overflow = false; p1 = precision; s = to_shwi1 (ws, &cl, &p2, c); check_precision (&p1, &p2, false, true); @@ -2469,8 +2450,6 @@ wide_int_ro::div_round (const T &c, sign unsigned int cl; unsigned int p1, p2; - if (overflow) - *overflow = false; p1 = precision; s = to_shwi1 (ws, &cl, &p2, c); check_precision (&p1, &p2, false, true); @@ -2544,7 +2523,7 @@ wide_int_ro::udivmod_trunc (const T &c, /* Divide DIVISOR into THIS. The remainder is also produced in REMAINDER. The result is the same size as the operands. - The sign is specified in SGN. The output is floor truncated. */ + The sign is specified in SGN. The outputs is floor truncated. */ template inline wide_int_ro wide_int_ro::divmod_floor (const T &c, wide_int_ro *remainder, @@ -2579,9 +2558,10 @@ wide_int_ro::sdivmod_floor (const T &c, } /* Divide DIVISOR into THIS producing the remainder. The result is - the same size as the operands. The sign is specified in SGN. - The output is truncated. If the pointer to OVERFLOW is not 0, - OVERFLOW is set to true if the result overflows, false otherwise. */ + the same size as the operands. The sign is specified in SGN. The + output is adjusted to be compatible with truncating divide. If the + pointer to OVERFLOW is not 0, OVERFLOW is set to true if the result + overflows, false otherwise. */ template inline wide_int_ro wide_int_ro::mod_trunc (const T &c, signop sgn, bool *overflow) const @@ -2592,8 +2572,6 @@ wide_int_ro::mod_trunc (const T &c, sign unsigned int cl; unsigned int p1, p2; - if (overflow) - *overflow = false; p1 = precision; s = to_shwi1 (ws, &cl, &p2, c); check_precision (&p1, &p2, false, true); @@ -2620,9 +2598,9 @@ wide_int_ro::umod_trunc (const T &c) con } /* Divide DIVISOR into THIS producing the remainder. The result is - the same size as the operands. The sign is specified in SGN. - The output is floor truncated. OVERFLOW is set to true if the - result overflows, false otherwise. */ + the same size as the operands. The sign is specified in SGN. The + output is adjusted to be compatible with floor divide. OVERFLOW is + set to true if the result overflows, false otherwise. */ template inline wide_int_ro wide_int_ro::mod_floor (const T &c, signop sgn, bool *overflow) const @@ -2634,8 +2612,6 @@ wide_int_ro::mod_floor (const T &c, sign unsigned int cl; unsigned int p1, p2; - if (overflow) - *overflow = false; p1 = precision; s = to_shwi1 (ws, &cl, &p2, c); check_precision (&p1, &p2, false, true); @@ -2657,9 +2633,10 @@ wide_int_ro::umod_floor (const T &c) con } /* Divide DIVISOR into THIS producing the remainder. The result is - the same size as the operands. The sign is specified in SGN. - The output is ceil truncated. If the pointer to OVERFLOW is not 0, - OVERFLOW is set to true if the result overflows, false otherwise. */ + the same size as the operands. The sign is specified in SGN. The + output is adjusted to be compatible with ceil divide. If the + pointer to OVERFLOW is not 0, OVERFLOW is set to true if the result + overflows, false otherwise. */ template inline wide_int_ro wide_int_ro::mod_ceil (const T &c, signop sgn, bool *overflow) const @@ -2671,8 +2648,6 @@ wide_int_ro::mod_ceil (const T &c, signo unsigned int cl; unsigned int p1, p2; - if (overflow) - *overflow = false; p1 = precision; s = to_shwi1 (ws, &cl, &p2, c); check_precision (&p1, &p2, false, true); @@ -2686,9 +2661,9 @@ wide_int_ro::mod_ceil (const T &c, signo } /* Divide DIVISOR into THIS producing the remainder. The result is - the same size as the operands. The sign is specified in SGN. - The output is round truncated. OVERFLOW is set to true if the - result overflows, false otherwise. */ + the same size as the operands. The sign is specified in SGN. The + output is adjusted to be compatible with rounding divide. OVERFLOW + is set to true if the result overflows, false otherwise. */ template inline wide_int_ro wide_int_ro::mod_round (const T &c, signop sgn, bool *overflow) const @@ -2700,8 +2675,6 @@ wide_int_ro::mod_round (const T &c, sign unsigned int cl; unsigned int p1, p2; - if (overflow) - *overflow = false; p1 = precision; s = to_shwi1 (ws, &cl, &p2, c); check_precision (&p1, &p2, false, true); @@ -2738,11 +2711,10 @@ wide_int_ro::mod_round (const T &c, sign } /* Left shift THIS by C. C must be non-negative. BITSIZE is the - width of *THIS used for truncating the shift amount. See the - definition of Op.TRUNC for how to set TRUNC_OP. */ + width of *THIS used for truncating the shift amount. */ template inline wide_int_ro -wide_int_ro::lshift (const T &c, unsigned int bitsize, ShiftOp trunc_op) const +wide_int_ro::lshift (const T &c, unsigned int bitsize) const { wide_int_ro result; HOST_WIDE_INT ws[WIDE_INT_MAX_ELTS]; @@ -2754,7 +2726,7 @@ wide_int_ro::lshift (const T &c, unsigne gcc_checking_assert (precision); - shift = trunc_shift (s, cl, bitsize, trunc_op); + shift = trunc_shift (s, bitsize); if (shift == -1) result = wide_int_ro::zero (precision); else if (shift == 0) @@ -2857,25 +2829,23 @@ wide_int_ro::lrotate (unsigned HOST_WIDE } /* Right shift THIS by C. BITSIZE is the width of *THIS used for - truncating the shift amount. SGN indicates the sign. TRUNC_OP - indicates the truncation option. C must be non-negative. */ + truncating the shift amount. SGN indicates the sign. C must be + non-negative. */ template inline wide_int_ro -wide_int_ro::rshift (const T &c, signop sgn, unsigned int bitsize, - ShiftOp trunc_op) const +wide_int_ro::rshift (const T &c, signop sgn, unsigned int bitsize) const { if (sgn == UNSIGNED) - return rshiftu (c, bitsize, trunc_op); + return rshiftu (c, bitsize); else - return rshifts (c, bitsize, trunc_op); + return rshifts (c, bitsize); } /* Unsigned right shift THIS by C. C must be non-negative. BITSIZE - is width of *THIS used for truncating the shift amount. See the - definition of Op.TRUNC for how to set TRUNC_OP. */ + is width of *THIS used for truncating the shift amount. */ template inline wide_int_ro -wide_int_ro::rshiftu (const T &c, unsigned int bitsize, ShiftOp trunc_op) const +wide_int_ro::rshiftu (const T &c, unsigned int bitsize) const { wide_int_ro result; HOST_WIDE_INT ws[WIDE_INT_MAX_ELTS]; @@ -2885,7 +2855,7 @@ wide_int_ro::rshiftu (const T &c, unsign s = to_shwi2 (ws, &cl, c); gcc_checking_assert (precision); - shift = trunc_shift (s, cl, bitsize, trunc_op); + shift = trunc_shift (s, bitsize); if (shift == 0) result = *this; @@ -2914,11 +2884,10 @@ wide_int_ro::rshiftu (const T &c, unsign } /* Signed right shift THIS by C. C must be non-negative, BITSIZE is - the width of *THIS used for truncating the shift amount. See the - definition of Op.TRUNC for how to set TRUNC_OP. */ + the width of *THIS used for truncating the shift amount. */ template inline wide_int_ro -wide_int_ro::rshifts (const T &c, unsigned int bitsize, ShiftOp trunc_op) const +wide_int_ro::rshifts (const T &c, unsigned int bitsize) const { wide_int_ro result; HOST_WIDE_INT ws[WIDE_INT_MAX_ELTS]; @@ -2928,7 +2897,7 @@ wide_int_ro::rshifts (const T &c, unsign s = to_shwi2 (ws, &cl, c); gcc_checking_assert (precision); - shift = trunc_shift (s, cl, bitsize, trunc_op); + shift = trunc_shift (s, bitsize); if (shift == 0) result = *this; @@ -3001,62 +2970,14 @@ wide_int_ro::rrotate (unsigned HOST_WIDE return result; } -/* If SHIFT_COUNT_TRUNCATED is defined, truncate CNT. - - At first look, the shift truncation code does not look right. - Shifts (and rotates) are done according to the precision of the - mode but the shift count is truncated according to the bitsize of - the mode. This is how real hardware works (Knuth's mix machine - is the only known exception to this rule, but it was never real). - - On an ideal machine, like Knuth's mix machine, a shift count is a - word long and all of the bits of that word are examined to - compute the shift amount. But on real hardware, especially on - machines with fast (single cycle shifts) that takes too long. - On these machines, the amount of time to perform a shift dictates - the cycle time of the machine so corners are cut to keep this - fast. A comparison of an entire 64 bit word would take something - like 6 gate delays before the shifting can even start. - - So real hardware only looks at a small part of the shift amount. - On IBM machines, this tends to be 1 more than what is necessary - to encode the shift amount. The rest of the world looks at only - the minimum number of bits. This means that only 3 gate delays - are necessary to set up the shifter. - - On the other hand, right shifts and rotates must be according to - the precision or the operation does not make any sense. - - This function is called in two contexts. If TRUNC_OP == TRUNC, - this function provides a count that matches the semantics of the - target machine depending on the value of SHIFT_COUNT_TRUNCATED. - Note that if SHIFT_COUNT_TRUNCATED is not defined, this function - may produce -1 as a value if the shift amount is greater than the - bitsize of the mode. -1 is a surrogate for a very large amount. - - If TRUNC_OP == NONE, then this function always truncates the shift - value to the bitsize because this shifting operation is a - function that is internal to GCC. */ +/* Truncate the value of the shift so that the value is within the + BITSIZE. */ inline int -wide_int_ro::trunc_shift (const HOST_WIDE_INT *cnt, - unsigned int len ATTRIBUTE_UNUSED, - unsigned int bitsize, ShiftOp trunc_op) const +wide_int_ro::trunc_shift (const HOST_WIDE_INT *cnt, unsigned int bitsize) const { gcc_checking_assert (cnt[0] >= 0); - if (trunc_op == TRUNC) - { - gcc_checking_assert (bitsize != 0); -#ifdef SHIFT_COUNT_TRUNCATED - return cnt[0] & (bitsize - 1); -#else - if (cnt[0] < bitsize && cnt[0] >= 0 && len == 1) - return cnt[0]; - else - return -1; -#endif - } - else if (bitsize == 0) + if (bitsize == 0) return cnt[0]; else return cnt[0] & (bitsize - 1); @@ -3477,20 +3398,19 @@ public: fixed_wide_int lrotate (unsigned HOST_WIDE_INT, unsigned int) const; template - fixed_wide_int lshift (const T &, unsigned int = 0, ShiftOp = NONE) const; + fixed_wide_int lshift (const T &, unsigned int = 0) const; template fixed_wide_int lshift_widen (const T &, unsigned int) const; template - fixed_wide_int rshift (const T &, signop, unsigned int = 0, - ShiftOp = NONE) const; + fixed_wide_int rshift (const T &, signop, unsigned int = 0) const; template - fixed_wide_int rshiftu (const T &, unsigned int = 0, ShiftOp = NONE) const; + fixed_wide_int rshiftu (const T &, unsigned int = 0) const; template - fixed_wide_int rshifts (const T &, unsigned int = 0, ShiftOp = NONE) const; + fixed_wide_int rshifts (const T &, unsigned int = 0) const; template fixed_wide_int rrotate (const T &, unsigned int) const; @@ -4026,10 +3946,9 @@ fixed_wide_int ::lrotate (unsig template template inline fixed_wide_int -fixed_wide_int ::lshift (const T &c, unsigned int bit_size, - ShiftOp z) const +fixed_wide_int ::lshift (const T &c, unsigned int bit_size) const { - return wide_int_ro::lshift (c, bit_size, z); + return wide_int_ro::lshift (c, bit_size); } template @@ -4044,28 +3963,28 @@ fixed_wide_int ::lshift_widen ( template template inline fixed_wide_int -fixed_wide_int ::rshift (const T &c, signop sgn, - unsigned int bit_size, ShiftOp z) const +fixed_wide_int ::rshift (const T &c, signop sgn, + unsigned int bit_size) const { - return wide_int_ro::rshift (c, sgn, bit_size, z); + return wide_int_ro::rshift (c, sgn, bit_size); } template template inline fixed_wide_int -fixed_wide_int ::rshiftu (const T &c, unsigned int bit_size, - ShiftOp z) const +fixed_wide_int ::rshiftu (const T &c, + unsigned int bit_size) const { - return wide_int_ro::rshiftu (c, bit_size, z); + return wide_int_ro::rshiftu (c, bit_size); } template template inline fixed_wide_int -fixed_wide_int ::rshifts (const T &c, unsigned int bit_size, - ShiftOp z) const +fixed_wide_int ::rshifts (const T &c, + unsigned int bit_size) const { - return wide_int_ro::rshifts (c, bit_size, z); + return wide_int_ro::rshifts (c, bit_size); } template