LCOV - code coverage report
Current view: top level - gcc - wide-int.h (source / functions) Hit Total Coverage
Test: gcc.info Lines: 762 838 90.9 %
Date: 2020-03-28 11:57:23 Functions: 486 521 93.3 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : /* Operations with very long integers.  -*- C++ -*-
       2                 :            :    Copyright (C) 2012-2020 Free Software Foundation, Inc.
       3                 :            : 
       4                 :            : This file is part of GCC.
       5                 :            : 
       6                 :            : GCC is free software; you can redistribute it and/or modify it
       7                 :            : under the terms of the GNU General Public License as published by the
       8                 :            : Free Software Foundation; either version 3, or (at your option) any
       9                 :            : later version.
      10                 :            : 
      11                 :            : GCC is distributed in the hope that it will be useful, but WITHOUT
      12                 :            : ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
      13                 :            : FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      14                 :            : for more details.
      15                 :            : 
      16                 :            : You should have received a copy of the GNU General Public License
      17                 :            : along with GCC; see the file COPYING3.  If not see
      18                 :            : <http://www.gnu.org/licenses/>.  */
      19                 :            : 
      20                 :            : #ifndef WIDE_INT_H
      21                 :            : #define WIDE_INT_H
      22                 :            : 
      23                 :            : /* wide-int.[cc|h] implements a class that efficiently performs
      24                 :            :    mathematical operations on finite precision integers.  wide_ints
      25                 :            :    are designed to be transient - they are not for long term storage
      26                 :            :    of values.  There is tight integration between wide_ints and the
      27                 :            :    other longer storage GCC representations (rtl and tree).
      28                 :            : 
      29                 :            :    The actual precision of a wide_int depends on the flavor.  There
      30                 :            :    are three predefined flavors:
      31                 :            : 
      32                 :            :      1) wide_int (the default).  This flavor does the math in the
      33                 :            :      precision of its input arguments.  It is assumed (and checked)
      34                 :            :      that the precisions of the operands and results are consistent.
      35                 :            :      This is the most efficient flavor.  It is not possible to examine
      36                 :            :      bits above the precision that has been specified.  Because of
      37                 :            :      this, the default flavor has semantics that are simple to
      38                 :            :      understand and in general model the underlying hardware that the
      39                 :            :      compiler is targetted for.
      40                 :            : 
      41                 :            :      This flavor must be used at the RTL level of gcc because there
      42                 :            :      is, in general, not enough information in the RTL representation
      43                 :            :      to extend a value beyond the precision specified in the mode.
      44                 :            : 
      45                 :            :      This flavor should also be used at the TREE and GIMPLE levels of
      46                 :            :      the compiler except for the circumstances described in the
      47                 :            :      descriptions of the other two flavors.
      48                 :            : 
      49                 :            :      The default wide_int representation does not contain any
      50                 :            :      information inherent about signedness of the represented value,
      51                 :            :      so it can be used to represent both signed and unsigned numbers.
      52                 :            :      For operations where the results depend on signedness (full width
      53                 :            :      multiply, division, shifts, comparisons, and operations that need
      54                 :            :      overflow detected), the signedness must be specified separately.
      55                 :            : 
      56                 :            :      2) offset_int.  This is a fixed-precision integer that can hold
      57                 :            :      any address offset, measured in either bits or bytes, with at
      58                 :            :      least one extra sign bit.  At the moment the maximum address
      59                 :            :      size GCC supports is 64 bits.  With 8-bit bytes and an extra
      60                 :            :      sign bit, offset_int therefore needs to have at least 68 bits
      61                 :            :      of precision.  We round this up to 128 bits for efficiency.
      62                 :            :      Values of type T are converted to this precision by sign- or
      63                 :            :      zero-extending them based on the signedness of T.
      64                 :            : 
      65                 :            :      The extra sign bit means that offset_int is effectively a signed
      66                 :            :      128-bit integer, i.e. it behaves like int128_t.
      67                 :            : 
      68                 :            :      Since the values are logically signed, there is no need to
      69                 :            :      distinguish between signed and unsigned operations.  Sign-sensitive
      70                 :            :      comparison operators <, <=, > and >= are therefore supported.
      71                 :            :      Shift operators << and >> are also supported, with >> being
      72                 :            :      an _arithmetic_ right shift.
      73                 :            : 
      74                 :            :      [ Note that, even though offset_int is effectively int128_t,
      75                 :            :        it can still be useful to use unsigned comparisons like
      76                 :            :        wi::leu_p (a, b) as a more efficient short-hand for
      77                 :            :        "a >= 0 && a <= b". ]
      78                 :            : 
      79                 :            :      3) widest_int.  This representation is an approximation of
      80                 :            :      infinite precision math.  However, it is not really infinite
      81                 :            :      precision math as in the GMP library.  It is really finite
      82                 :            :      precision math where the precision is 4 times the size of the
      83                 :            :      largest integer that the target port can represent.
      84                 :            : 
      85                 :            :      Like offset_int, widest_int is wider than all the values that
      86                 :            :      it needs to represent, so the integers are logically signed.
      87                 :            :      Sign-sensitive comparison operators <, <=, > and >= are supported,
      88                 :            :      as are << and >>.
      89                 :            : 
      90                 :            :      There are several places in the GCC where this should/must be used:
      91                 :            : 
      92                 :            :      * Code that does induction variable optimizations.  This code
      93                 :            :        works with induction variables of many different types at the
      94                 :            :        same time.  Because of this, it ends up doing many different
      95                 :            :        calculations where the operands are not compatible types.  The
      96                 :            :        widest_int makes this easy, because it provides a field where
      97                 :            :        nothing is lost when converting from any variable,
      98                 :            : 
      99                 :            :      * There are a small number of passes that currently use the
     100                 :            :        widest_int that should use the default.  These should be
     101                 :            :        changed.
     102                 :            : 
     103                 :            :    There are surprising features of offset_int and widest_int
     104                 :            :    that the users should be careful about:
     105                 :            : 
     106                 :            :      1) Shifts and rotations are just weird.  You have to specify a
     107                 :            :      precision in which the shift or rotate is to happen in.  The bits
     108                 :            :      above this precision are zeroed.  While this is what you
     109                 :            :      want, it is clearly non obvious.
     110                 :            : 
     111                 :            :      2) Larger precision math sometimes does not produce the same
     112                 :            :      answer as would be expected for doing the math at the proper
     113                 :            :      precision.  In particular, a multiply followed by a divide will
     114                 :            :      produce a different answer if the first product is larger than
     115                 :            :      what can be represented in the input precision.
     116                 :            : 
     117                 :            :    The offset_int and the widest_int flavors are more expensive
     118                 :            :    than the default wide int, so in addition to the caveats with these
     119                 :            :    two, the default is the prefered representation.
     120                 :            : 
     121                 :            :    All three flavors of wide_int are represented as a vector of
     122                 :            :    HOST_WIDE_INTs.  The default and widest_int vectors contain enough elements
     123                 :            :    to hold a value of MAX_BITSIZE_MODE_ANY_INT bits.  offset_int contains only
     124                 :            :    enough elements to hold ADDR_MAX_PRECISION bits.  The values are stored
     125                 :            :    in the vector with the least significant HOST_BITS_PER_WIDE_INT bits
     126                 :            :    in element 0.
     127                 :            : 
     128                 :            :    The default wide_int contains three fields: the vector (VAL),
     129                 :            :    the precision and a length (LEN).  The length is the number of HWIs
     130                 :            :    needed to represent the value.  widest_int and offset_int have a
     131                 :            :    constant precision that cannot be changed, so they only store the
     132                 :            :    VAL and LEN fields.
     133                 :            : 
     134                 :            :    Since most integers used in a compiler are small values, it is
     135                 :            :    generally profitable to use a representation of the value that is
     136                 :            :    as small as possible.  LEN is used to indicate the number of
     137                 :            :    elements of the vector that are in use.  The numbers are stored as
     138                 :            :    sign extended numbers as a means of compression.  Leading
     139                 :            :    HOST_WIDE_INTs that contain strings of either -1 or 0 are removed
     140                 :            :    as long as they can be reconstructed from the top bit that is being
     141                 :            :    represented.
     142                 :            : 
     143                 :            :    The precision and length of a wide_int are always greater than 0.
     144                 :            :    Any bits in a wide_int above the precision are sign-extended from the
     145                 :            :    most significant bit.  For example, a 4-bit value 0x8 is represented as
     146                 :            :    VAL = { 0xf...fff8 }.  However, as an optimization, we allow other integer
     147                 :            :    constants to be represented with undefined bits above the precision.
     148                 :            :    This allows INTEGER_CSTs to be pre-extended according to TYPE_SIGN,
     149                 :            :    so that the INTEGER_CST representation can be used both in TYPE_PRECISION
     150                 :            :    and in wider precisions.
     151                 :            : 
     152                 :            :    There are constructors to create the various forms of wide_int from
     153                 :            :    trees, rtl and constants.  For trees the options are:
     154                 :            : 
     155                 :            :              tree t = ...;
     156                 :            :              wi::to_wide (t)     // Treat T as a wide_int
     157                 :            :              wi::to_offset (t)   // Treat T as an offset_int
     158                 :            :              wi::to_widest (t)   // Treat T as a widest_int
     159                 :            : 
     160                 :            :    All three are light-weight accessors that should have no overhead
     161                 :            :    in release builds.  If it is useful for readability reasons to
     162                 :            :    store the result in a temporary variable, the preferred method is:
     163                 :            : 
     164                 :            :              wi::tree_to_wide_ref twide = wi::to_wide (t);
     165                 :            :              wi::tree_to_offset_ref toffset = wi::to_offset (t);
     166                 :            :              wi::tree_to_widest_ref twidest = wi::to_widest (t);
     167                 :            : 
     168                 :            :    To make an rtx into a wide_int, you have to pair it with a mode.
     169                 :            :    The canonical way to do this is with rtx_mode_t as in:
     170                 :            : 
     171                 :            :              rtx r = ...
     172                 :            :              wide_int x = rtx_mode_t (r, mode);
     173                 :            : 
     174                 :            :    Similarly, a wide_int can only be constructed from a host value if
     175                 :            :    the target precision is given explicitly, such as in:
     176                 :            : 
     177                 :            :              wide_int x = wi::shwi (c, prec); // sign-extend C if necessary
     178                 :            :              wide_int y = wi::uhwi (c, prec); // zero-extend C if necessary
     179                 :            : 
     180                 :            :    However, offset_int and widest_int have an inherent precision and so
     181                 :            :    can be initialized directly from a host value:
     182                 :            : 
     183                 :            :              offset_int x = (int) c;          // sign-extend C
     184                 :            :              widest_int x = (unsigned int) c; // zero-extend C
     185                 :            : 
     186                 :            :    It is also possible to do arithmetic directly on rtx_mode_ts and
     187                 :            :    constants.  For example:
     188                 :            : 
     189                 :            :              wi::add (r1, r2);    // add equal-sized rtx_mode_ts r1 and r2
     190                 :            :              wi::add (r1, 1);     // add 1 to rtx_mode_t r1
     191                 :            :              wi::lshift (1, 100); // 1 << 100 as a widest_int
     192                 :            : 
     193                 :            :    Many binary operations place restrictions on the combinations of inputs,
     194                 :            :    using the following rules:
     195                 :            : 
     196                 :            :    - {rtx, wide_int} op {rtx, wide_int} -> wide_int
     197                 :            :        The inputs must be the same precision.  The result is a wide_int
     198                 :            :        of the same precision
     199                 :            : 
     200                 :            :    - {rtx, wide_int} op (un)signed HOST_WIDE_INT -> wide_int
     201                 :            :      (un)signed HOST_WIDE_INT op {rtx, wide_int} -> wide_int
     202                 :            :        The HOST_WIDE_INT is extended or truncated to the precision of
     203                 :            :        the other input.  The result is a wide_int of the same precision
     204                 :            :        as that input.
     205                 :            : 
     206                 :            :    - (un)signed HOST_WIDE_INT op (un)signed HOST_WIDE_INT -> widest_int
     207                 :            :        The inputs are extended to widest_int precision and produce a
     208                 :            :        widest_int result.
     209                 :            : 
     210                 :            :    - offset_int op offset_int -> offset_int
     211                 :            :      offset_int op (un)signed HOST_WIDE_INT -> offset_int
     212                 :            :      (un)signed HOST_WIDE_INT op offset_int -> offset_int
     213                 :            : 
     214                 :            :    - widest_int op widest_int -> widest_int
     215                 :            :      widest_int op (un)signed HOST_WIDE_INT -> widest_int
     216                 :            :      (un)signed HOST_WIDE_INT op widest_int -> widest_int
     217                 :            : 
     218                 :            :    Other combinations like:
     219                 :            : 
     220                 :            :    - widest_int op offset_int and
     221                 :            :    - wide_int op offset_int
     222                 :            : 
     223                 :            :    are not allowed.  The inputs should instead be extended or truncated
     224                 :            :    so that they match.
     225                 :            : 
     226                 :            :    The inputs to comparison functions like wi::eq_p and wi::lts_p
     227                 :            :    follow the same compatibility rules, although their return types
     228                 :            :    are different.  Unary functions on X produce the same result as
     229                 :            :    a binary operation X + X.  Shift functions X op Y also produce
     230                 :            :    the same result as X + X; the precision of the shift amount Y
     231                 :            :    can be arbitrarily different from X.  */
     232                 :            : 
     233                 :            : /* The MAX_BITSIZE_MODE_ANY_INT is automatically generated by a very
     234                 :            :    early examination of the target's mode file.  The WIDE_INT_MAX_ELTS
     235                 :            :    can accomodate at least 1 more bit so that unsigned numbers of that
     236                 :            :    mode can be represented as a signed value.  Note that it is still
     237                 :            :    possible to create fixed_wide_ints that have precisions greater than
     238                 :            :    MAX_BITSIZE_MODE_ANY_INT.  This can be useful when representing a
     239                 :            :    double-width multiplication result, for example.  */
     240                 :            : #define WIDE_INT_MAX_ELTS \
     241                 :            :   ((MAX_BITSIZE_MODE_ANY_INT + HOST_BITS_PER_WIDE_INT) / HOST_BITS_PER_WIDE_INT)
     242                 :            : 
     243                 :            : #define WIDE_INT_MAX_PRECISION (WIDE_INT_MAX_ELTS * HOST_BITS_PER_WIDE_INT)
     244                 :            : 
     245                 :            : /* This is the max size of any pointer on any machine.  It does not
     246                 :            :    seem to be as easy to sniff this out of the machine description as
     247                 :            :    it is for MAX_BITSIZE_MODE_ANY_INT since targets may support
     248                 :            :    multiple address sizes and may have different address sizes for
     249                 :            :    different address spaces.  However, currently the largest pointer
     250                 :            :    on any platform is 64 bits.  When that changes, then it is likely
     251                 :            :    that a target hook should be defined so that targets can make this
     252                 :            :    value larger for those targets.  */
     253                 :            : #define ADDR_MAX_BITSIZE 64
     254                 :            : 
     255                 :            : /* This is the internal precision used when doing any address
     256                 :            :    arithmetic.  The '4' is really 3 + 1.  Three of the bits are for
     257                 :            :    the number of extra bits needed to do bit addresses and the other bit
     258                 :            :    is to allow everything to be signed without loosing any precision.
     259                 :            :    Then everything is rounded up to the next HWI for efficiency.  */
     260                 :            : #define ADDR_MAX_PRECISION \
     261                 :            :   ((ADDR_MAX_BITSIZE + 4 + HOST_BITS_PER_WIDE_INT - 1) \
     262                 :            :    & ~(HOST_BITS_PER_WIDE_INT - 1))
     263                 :            : 
     264                 :            : /* The number of HWIs needed to store an offset_int.  */
     265                 :            : #define OFFSET_INT_ELTS (ADDR_MAX_PRECISION / HOST_BITS_PER_WIDE_INT)
     266                 :            : 
     267                 :            : /* The type of result produced by a binary operation on types T1 and T2.
     268                 :            :    Defined purely for brevity.  */
     269                 :            : #define WI_BINARY_RESULT(T1, T2) \
     270                 :            :   typename wi::binary_traits <T1, T2>::result_type
     271                 :            : 
     272                 :            : /* Likewise for binary operators, which excludes the case in which neither
     273                 :            :    T1 nor T2 is a wide-int-based type.  */
     274                 :            : #define WI_BINARY_OPERATOR_RESULT(T1, T2) \
     275                 :            :   typename wi::binary_traits <T1, T2>::operator_result
     276                 :            : 
     277                 :            : /* The type of result produced by T1 << T2.  Leads to substitution failure
     278                 :            :    if the operation isn't supported.  Defined purely for brevity.  */
     279                 :            : #define WI_SIGNED_SHIFT_RESULT(T1, T2) \
     280                 :            :   typename wi::binary_traits <T1, T2>::signed_shift_result_type
     281                 :            : 
     282                 :            : /* The type of result produced by a sign-agnostic binary predicate on
     283                 :            :    types T1 and T2.  This is bool if wide-int operations make sense for
     284                 :            :    T1 and T2 and leads to substitution failure otherwise.  */
     285                 :            : #define WI_BINARY_PREDICATE_RESULT(T1, T2) \
     286                 :            :   typename wi::binary_traits <T1, T2>::predicate_result
     287                 :            : 
     288                 :            : /* The type of result produced by a signed binary predicate on types T1 and T2.
     289                 :            :    This is bool if signed comparisons make sense for T1 and T2 and leads to
     290                 :            :    substitution failure otherwise.  */
     291                 :            : #define WI_SIGNED_BINARY_PREDICATE_RESULT(T1, T2) \
     292                 :            :   typename wi::binary_traits <T1, T2>::signed_predicate_result
     293                 :            : 
     294                 :            : /* The type of result produced by a unary operation on type T.  */
     295                 :            : #define WI_UNARY_RESULT(T) \
     296                 :            :   typename wi::binary_traits <T, T>::result_type
     297                 :            : 
     298                 :            : /* Define a variable RESULT to hold the result of a binary operation on
     299                 :            :    X and Y, which have types T1 and T2 respectively.  Define VAL to
     300                 :            :    point to the blocks of RESULT.  Once the user of the macro has
     301                 :            :    filled in VAL, it should call RESULT.set_len to set the number
     302                 :            :    of initialized blocks.  */
     303                 :            : #define WI_BINARY_RESULT_VAR(RESULT, VAL, T1, X, T2, Y) \
     304                 :            :   WI_BINARY_RESULT (T1, T2) RESULT = \
     305                 :            :     wi::int_traits <WI_BINARY_RESULT (T1, T2)>::get_binary_result (X, Y); \
     306                 :            :   HOST_WIDE_INT *VAL = RESULT.write_val ()
     307                 :            : 
     308                 :            : /* Similar for the result of a unary operation on X, which has type T.  */
     309                 :            : #define WI_UNARY_RESULT_VAR(RESULT, VAL, T, X) \
     310                 :            :   WI_UNARY_RESULT (T) RESULT = \
     311                 :            :     wi::int_traits <WI_UNARY_RESULT (T)>::get_binary_result (X, X); \
     312                 :            :   HOST_WIDE_INT *VAL = RESULT.write_val ()
     313                 :            : 
     314                 :            : template <typename T> class generic_wide_int;
     315                 :            : template <int N> class fixed_wide_int_storage;
     316                 :            : class wide_int_storage;
     317                 :            : 
     318                 :            : /* An N-bit integer.  Until we can use typedef templates, use this instead.  */
     319                 :            : #define FIXED_WIDE_INT(N) \
     320                 :            :   generic_wide_int < fixed_wide_int_storage <N> >
     321                 :            : 
     322                 :            : typedef generic_wide_int <wide_int_storage> wide_int;
     323                 :            : typedef FIXED_WIDE_INT (ADDR_MAX_PRECISION) offset_int;
     324                 :            : typedef FIXED_WIDE_INT (WIDE_INT_MAX_PRECISION) widest_int;
     325                 :            : /* Spelled out explicitly (rather than through FIXED_WIDE_INT)
     326                 :            :    so as not to confuse gengtype.  */
     327                 :            : typedef generic_wide_int < fixed_wide_int_storage <WIDE_INT_MAX_PRECISION * 2> > widest2_int;
     328                 :            : 
     329                 :            : /* wi::storage_ref can be a reference to a primitive type,
     330                 :            :    so this is the conservatively-correct setting.  */
     331                 :            : template <bool SE, bool HDP = true>
     332                 :            : class wide_int_ref_storage;
     333                 :            : 
     334                 :            : typedef generic_wide_int <wide_int_ref_storage <false> > wide_int_ref;
     335                 :            : 
     336                 :            : /* This can be used instead of wide_int_ref if the referenced value is
     337                 :            :    known to have type T.  It carries across properties of T's representation,
     338                 :            :    such as whether excess upper bits in a HWI are defined, and can therefore
     339                 :            :    help avoid redundant work.
     340                 :            : 
     341                 :            :    The macro could be replaced with a template typedef, once we're able
     342                 :            :    to use those.  */
     343                 :            : #define WIDE_INT_REF_FOR(T) \
     344                 :            :   generic_wide_int \
     345                 :            :     <wide_int_ref_storage <wi::int_traits <T>::is_sign_extended, \
     346                 :            :                            wi::int_traits <T>::host_dependent_precision> >
     347                 :            : 
     348                 :            : namespace wi
     349                 :            : {
     350                 :            :   /* Operations that calculate overflow do so even for
     351                 :            :      TYPE_OVERFLOW_WRAPS types.  For example, adding 1 to +MAX_INT in
     352                 :            :      an unsigned int is 0 and does not overflow in C/C++, but wi::add
     353                 :            :      will set the overflow argument in case it's needed for further
     354                 :            :      analysis.
     355                 :            : 
     356                 :            :      For operations that require overflow, these are the different
     357                 :            :      types of overflow.  */
     358                 :            :   enum overflow_type {
     359                 :            :     OVF_NONE = 0,
     360                 :            :     OVF_UNDERFLOW = -1,
     361                 :            :     OVF_OVERFLOW = 1,
     362                 :            :     /* There was an overflow, but we are unsure whether it was an
     363                 :            :        overflow or an underflow.  */
     364                 :            :     OVF_UNKNOWN = 2
     365                 :            :   };
     366                 :            : 
     367                 :            :   /* Classifies an integer based on its precision.  */
     368                 :            :   enum precision_type {
     369                 :            :     /* The integer has both a precision and defined signedness.  This allows
     370                 :            :        the integer to be converted to any width, since we know whether to fill
     371                 :            :        any extra bits with zeros or signs.  */
     372                 :            :     FLEXIBLE_PRECISION,
     373                 :            : 
     374                 :            :     /* The integer has a variable precision but no defined signedness.  */
     375                 :            :     VAR_PRECISION,
     376                 :            : 
     377                 :            :     /* The integer has a constant precision (known at GCC compile time)
     378                 :            :        and is signed.  */
     379                 :            :     CONST_PRECISION
     380                 :            :   };
     381                 :            : 
     382                 :            :   /* This class, which has no default implementation, is expected to
     383                 :            :      provide the following members:
     384                 :            : 
     385                 :            :      static const enum precision_type precision_type;
     386                 :            :        Classifies the type of T.
     387                 :            : 
     388                 :            :      static const unsigned int precision;
     389                 :            :        Only defined if precision_type == CONST_PRECISION.  Specifies the
     390                 :            :        precision of all integers of type T.
     391                 :            : 
     392                 :            :      static const bool host_dependent_precision;
     393                 :            :        True if the precision of T depends (or can depend) on the host.
     394                 :            : 
     395                 :            :      static unsigned int get_precision (const T &x)
     396                 :            :        Return the number of bits in X.
     397                 :            : 
     398                 :            :      static wi::storage_ref *decompose (HOST_WIDE_INT *scratch,
     399                 :            :                                         unsigned int precision, const T &x)
     400                 :            :        Decompose X as a PRECISION-bit integer, returning the associated
     401                 :            :        wi::storage_ref.  SCRATCH is available as scratch space if needed.
     402                 :            :        The routine should assert that PRECISION is acceptable.  */
     403                 :            :   template <typename T> struct int_traits;
     404                 :            : 
     405                 :            :   /* This class provides a single type, result_type, which specifies the
     406                 :            :      type of integer produced by a binary operation whose inputs have
     407                 :            :      types T1 and T2.  The definition should be symmetric.  */
     408                 :            :   template <typename T1, typename T2,
     409                 :            :             enum precision_type P1 = int_traits <T1>::precision_type,
     410                 :            :             enum precision_type P2 = int_traits <T2>::precision_type>
     411                 :            :   struct binary_traits;
     412                 :            : 
     413                 :            :   /* Specify the result type for each supported combination of binary
     414                 :            :      inputs.  Note that CONST_PRECISION and VAR_PRECISION cannot be
     415                 :            :      mixed, in order to give stronger type checking.  When both inputs
     416                 :            :      are CONST_PRECISION, they must have the same precision.  */
     417                 :            :   template <typename T1, typename T2>
     418                 :            :   struct binary_traits <T1, T2, FLEXIBLE_PRECISION, FLEXIBLE_PRECISION>
     419                 :            :   {
     420                 :            :     typedef widest_int result_type;
     421                 :            :     /* Don't define operators for this combination.  */
     422                 :            :   };
     423                 :            : 
     424                 :            :   template <typename T1, typename T2>
     425                 :            :   struct binary_traits <T1, T2, FLEXIBLE_PRECISION, VAR_PRECISION>
     426                 :            :   {
     427                 :            :     typedef wide_int result_type;
     428                 :            :     typedef result_type operator_result;
     429                 :            :     typedef bool predicate_result;
     430                 :            :   };
     431                 :            : 
     432                 :            :   template <typename T1, typename T2>
     433                 :            :   struct binary_traits <T1, T2, FLEXIBLE_PRECISION, CONST_PRECISION>
     434                 :            :   {
     435                 :            :     /* Spelled out explicitly (rather than through FIXED_WIDE_INT)
     436                 :            :        so as not to confuse gengtype.  */
     437                 :            :     typedef generic_wide_int < fixed_wide_int_storage
     438                 :            :                                <int_traits <T2>::precision> > result_type;
     439                 :            :     typedef result_type operator_result;
     440                 :            :     typedef bool predicate_result;
     441                 :            :     typedef result_type signed_shift_result_type;
     442                 :            :     typedef bool signed_predicate_result;
     443                 :            :   };
     444                 :            : 
     445                 :            :   template <typename T1, typename T2>
     446                 :            :   struct binary_traits <T1, T2, VAR_PRECISION, FLEXIBLE_PRECISION>
     447                 :            :   {
     448                 :            :     typedef wide_int result_type;
     449                 :            :     typedef result_type operator_result;
     450                 :            :     typedef bool predicate_result;
     451                 :            :   };
     452                 :            : 
     453                 :            :   template <typename T1, typename T2>
     454                 :            :   struct binary_traits <T1, T2, CONST_PRECISION, FLEXIBLE_PRECISION>
     455                 :            :   {
     456                 :            :     /* Spelled out explicitly (rather than through FIXED_WIDE_INT)
     457                 :            :        so as not to confuse gengtype.  */
     458                 :            :     typedef generic_wide_int < fixed_wide_int_storage
     459                 :            :                                <int_traits <T1>::precision> > result_type;
     460                 :            :     typedef result_type operator_result;
     461                 :            :     typedef bool predicate_result;
     462                 :            :     typedef result_type signed_shift_result_type;
     463                 :            :     typedef bool signed_predicate_result;
     464                 :            :   };
     465                 :            : 
     466                 :            :   template <typename T1, typename T2>
     467                 :            :   struct binary_traits <T1, T2, CONST_PRECISION, CONST_PRECISION>
     468                 :            :   {
     469                 :            :     STATIC_ASSERT (int_traits <T1>::precision == int_traits <T2>::precision);
     470                 :            :     /* Spelled out explicitly (rather than through FIXED_WIDE_INT)
     471                 :            :        so as not to confuse gengtype.  */
     472                 :            :     typedef generic_wide_int < fixed_wide_int_storage
     473                 :            :                                <int_traits <T1>::precision> > result_type;
     474                 :            :     typedef result_type operator_result;
     475                 :            :     typedef bool predicate_result;
     476                 :            :     typedef result_type signed_shift_result_type;
     477                 :            :     typedef bool signed_predicate_result;
     478                 :            :   };
     479                 :            : 
     480                 :            :   template <typename T1, typename T2>
     481                 :            :   struct binary_traits <T1, T2, VAR_PRECISION, VAR_PRECISION>
     482                 :            :   {
     483                 :            :     typedef wide_int result_type;
     484                 :            :     typedef result_type operator_result;
     485                 :            :     typedef bool predicate_result;
     486                 :            :   };
     487                 :            : }
     488                 :            : 
     489                 :            : /* Public functions for querying and operating on integers.  */
     490                 :            : namespace wi
     491                 :            : {
     492                 :            :   template <typename T>
     493                 :            :   unsigned int get_precision (const T &);
     494                 :            : 
     495                 :            :   template <typename T1, typename T2>
     496                 :            :   unsigned int get_binary_precision (const T1 &, const T2 &);
     497                 :            : 
     498                 :            :   template <typename T1, typename T2>
     499                 :            :   void copy (T1 &, const T2 &);
     500                 :            : 
     501                 :            : #define UNARY_PREDICATE \
     502                 :            :   template <typename T> bool
     503                 :            : #define UNARY_FUNCTION \
     504                 :            :   template <typename T> WI_UNARY_RESULT (T)
     505                 :            : #define BINARY_PREDICATE \
     506                 :            :   template <typename T1, typename T2> bool
     507                 :            : #define BINARY_FUNCTION \
     508                 :            :   template <typename T1, typename T2> WI_BINARY_RESULT (T1, T2)
     509                 :            : #define SHIFT_FUNCTION \
     510                 :            :   template <typename T1, typename T2> WI_UNARY_RESULT (T1)
     511                 :            : 
     512                 :            :   UNARY_PREDICATE fits_shwi_p (const T &);
     513                 :            :   UNARY_PREDICATE fits_uhwi_p (const T &);
     514                 :            :   UNARY_PREDICATE neg_p (const T &, signop = SIGNED);
     515                 :            : 
     516                 :            :   template <typename T>
     517                 :            :   HOST_WIDE_INT sign_mask (const T &);
     518                 :            : 
     519                 :            :   BINARY_PREDICATE eq_p (const T1 &, const T2 &);
     520                 :            :   BINARY_PREDICATE ne_p (const T1 &, const T2 &);
     521                 :            :   BINARY_PREDICATE lt_p (const T1 &, const T2 &, signop);
     522                 :            :   BINARY_PREDICATE lts_p (const T1 &, const T2 &);
     523                 :            :   BINARY_PREDICATE ltu_p (const T1 &, const T2 &);
     524                 :            :   BINARY_PREDICATE le_p (const T1 &, const T2 &, signop);
     525                 :            :   BINARY_PREDICATE les_p (const T1 &, const T2 &);
     526                 :            :   BINARY_PREDICATE leu_p (const T1 &, const T2 &);
     527                 :            :   BINARY_PREDICATE gt_p (const T1 &, const T2 &, signop);
     528                 :            :   BINARY_PREDICATE gts_p (const T1 &, const T2 &);
     529                 :            :   BINARY_PREDICATE gtu_p (const T1 &, const T2 &);
     530                 :            :   BINARY_PREDICATE ge_p (const T1 &, const T2 &, signop);
     531                 :            :   BINARY_PREDICATE ges_p (const T1 &, const T2 &);
     532                 :            :   BINARY_PREDICATE geu_p (const T1 &, const T2 &);
     533                 :            : 
     534                 :            :   template <typename T1, typename T2>
     535                 :            :   int cmp (const T1 &, const T2 &, signop);
     536                 :            : 
     537                 :            :   template <typename T1, typename T2>
     538                 :            :   int cmps (const T1 &, const T2 &);
     539                 :            : 
     540                 :            :   template <typename T1, typename T2>
     541                 :            :   int cmpu (const T1 &, const T2 &);
     542                 :            : 
     543                 :            :   UNARY_FUNCTION bit_not (const T &);
     544                 :            :   UNARY_FUNCTION neg (const T &);
     545                 :            :   UNARY_FUNCTION neg (const T &, overflow_type *);
     546                 :            :   UNARY_FUNCTION abs (const T &);
     547                 :            :   UNARY_FUNCTION ext (const T &, unsigned int, signop);
     548                 :            :   UNARY_FUNCTION sext (const T &, unsigned int);
     549                 :            :   UNARY_FUNCTION zext (const T &, unsigned int);
     550                 :            :   UNARY_FUNCTION set_bit (const T &, unsigned int);
     551                 :            : 
     552                 :            :   BINARY_FUNCTION min (const T1 &, const T2 &, signop);
     553                 :            :   BINARY_FUNCTION smin (const T1 &, const T2 &);
     554                 :            :   BINARY_FUNCTION umin (const T1 &, const T2 &);
     555                 :            :   BINARY_FUNCTION max (const T1 &, const T2 &, signop);
     556                 :            :   BINARY_FUNCTION smax (const T1 &, const T2 &);
     557                 :            :   BINARY_FUNCTION umax (const T1 &, const T2 &);
     558                 :            : 
     559                 :            :   BINARY_FUNCTION bit_and (const T1 &, const T2 &);
     560                 :            :   BINARY_FUNCTION bit_and_not (const T1 &, const T2 &);
     561                 :            :   BINARY_FUNCTION bit_or (const T1 &, const T2 &);
     562                 :            :   BINARY_FUNCTION bit_or_not (const T1 &, const T2 &);
     563                 :            :   BINARY_FUNCTION bit_xor (const T1 &, const T2 &);
     564                 :            :   BINARY_FUNCTION add (const T1 &, const T2 &);
     565                 :            :   BINARY_FUNCTION add (const T1 &, const T2 &, signop, overflow_type *);
     566                 :            :   BINARY_FUNCTION sub (const T1 &, const T2 &);
     567                 :            :   BINARY_FUNCTION sub (const T1 &, const T2 &, signop, overflow_type *);
     568                 :            :   BINARY_FUNCTION mul (const T1 &, const T2 &);
     569                 :            :   BINARY_FUNCTION mul (const T1 &, const T2 &, signop, overflow_type *);
     570                 :            :   BINARY_FUNCTION smul (const T1 &, const T2 &, overflow_type *);
     571                 :            :   BINARY_FUNCTION umul (const T1 &, const T2 &, overflow_type *);
     572                 :            :   BINARY_FUNCTION mul_high (const T1 &, const T2 &, signop);
     573                 :            :   BINARY_FUNCTION div_trunc (const T1 &, const T2 &, signop,
     574                 :            :                              overflow_type * = 0);
     575                 :            :   BINARY_FUNCTION sdiv_trunc (const T1 &, const T2 &);
     576                 :            :   BINARY_FUNCTION udiv_trunc (const T1 &, const T2 &);
     577                 :            :   BINARY_FUNCTION div_floor (const T1 &, const T2 &, signop,
     578                 :            :                              overflow_type * = 0);
     579                 :            :   BINARY_FUNCTION udiv_floor (const T1 &, const T2 &);
     580                 :            :   BINARY_FUNCTION sdiv_floor (const T1 &, const T2 &);
     581                 :            :   BINARY_FUNCTION div_ceil (const T1 &, const T2 &, signop,
     582                 :            :                             overflow_type * = 0);
     583                 :            :   BINARY_FUNCTION udiv_ceil (const T1 &, const T2 &);
     584                 :            :   BINARY_FUNCTION div_round (const T1 &, const T2 &, signop,
     585                 :            :                              overflow_type * = 0);
     586                 :            :   BINARY_FUNCTION divmod_trunc (const T1 &, const T2 &, signop,
     587                 :            :                                 WI_BINARY_RESULT (T1, T2) *);
     588                 :            :   BINARY_FUNCTION gcd (const T1 &, const T2 &, signop = UNSIGNED);
     589                 :            :   BINARY_FUNCTION mod_trunc (const T1 &, const T2 &, signop,
     590                 :            :                              overflow_type * = 0);
     591                 :            :   BINARY_FUNCTION smod_trunc (const T1 &, const T2 &);
     592                 :            :   BINARY_FUNCTION umod_trunc (const T1 &, const T2 &);
     593                 :            :   BINARY_FUNCTION mod_floor (const T1 &, const T2 &, signop,
     594                 :            :                              overflow_type * = 0);
     595                 :            :   BINARY_FUNCTION umod_floor (const T1 &, const T2 &);
     596                 :            :   BINARY_FUNCTION mod_ceil (const T1 &, const T2 &, signop,
     597                 :            :                             overflow_type * = 0);
     598                 :            :   BINARY_FUNCTION mod_round (const T1 &, const T2 &, signop,
     599                 :            :                              overflow_type * = 0);
     600                 :            : 
     601                 :            :   template <typename T1, typename T2>
     602                 :            :   bool multiple_of_p (const T1 &, const T2 &, signop);
     603                 :            : 
     604                 :            :   template <typename T1, typename T2>
     605                 :            :   bool multiple_of_p (const T1 &, const T2 &, signop,
     606                 :            :                       WI_BINARY_RESULT (T1, T2) *);
     607                 :            : 
     608                 :            :   SHIFT_FUNCTION lshift (const T1 &, const T2 &);
     609                 :            :   SHIFT_FUNCTION lrshift (const T1 &, const T2 &);
     610                 :            :   SHIFT_FUNCTION arshift (const T1 &, const T2 &);
     611                 :            :   SHIFT_FUNCTION rshift (const T1 &, const T2 &, signop sgn);
     612                 :            :   SHIFT_FUNCTION lrotate (const T1 &, const T2 &, unsigned int = 0);
     613                 :            :   SHIFT_FUNCTION rrotate (const T1 &, const T2 &, unsigned int = 0);
     614                 :            : 
     615                 :            : #undef SHIFT_FUNCTION
     616                 :            : #undef BINARY_PREDICATE
     617                 :            : #undef BINARY_FUNCTION
     618                 :            : #undef UNARY_PREDICATE
     619                 :            : #undef UNARY_FUNCTION
     620                 :            : 
     621                 :            :   bool only_sign_bit_p (const wide_int_ref &, unsigned int);
     622                 :            :   bool only_sign_bit_p (const wide_int_ref &);
     623                 :            :   int clz (const wide_int_ref &);
     624                 :            :   int clrsb (const wide_int_ref &);
     625                 :            :   int ctz (const wide_int_ref &);
     626                 :            :   int exact_log2 (const wide_int_ref &);
     627                 :            :   int floor_log2 (const wide_int_ref &);
     628                 :            :   int ffs (const wide_int_ref &);
     629                 :            :   int popcount (const wide_int_ref &);
     630                 :            :   int parity (const wide_int_ref &);
     631                 :            : 
     632                 :            :   template <typename T>
     633                 :            :   unsigned HOST_WIDE_INT extract_uhwi (const T &, unsigned int, unsigned int);
     634                 :            : 
     635                 :            :   template <typename T>
     636                 :            :   unsigned int min_precision (const T &, signop);
     637                 :            : 
     638                 :            :   static inline void accumulate_overflow (overflow_type &, overflow_type);
     639                 :            : }
     640                 :            : 
     641                 :            : namespace wi
     642                 :            : {
     643                 :            :   /* Contains the components of a decomposed integer for easy, direct
     644                 :            :      access.  */
     645                 :            :   class storage_ref
     646                 :            :   {
     647                 :            :   public:
     648                 :            :     storage_ref () {}
     649                 :            :     storage_ref (const HOST_WIDE_INT *, unsigned int, unsigned int);
     650                 :            : 
     651                 :            :     const HOST_WIDE_INT *val;
     652                 :            :     unsigned int len;
     653                 :            :     unsigned int precision;
     654                 :            : 
     655                 :            :     /* Provide enough trappings for this class to act as storage for
     656                 :            :        generic_wide_int.  */
     657                 :            :     unsigned int get_len () const;
     658                 :            :     unsigned int get_precision () const;
     659                 :            :     const HOST_WIDE_INT *get_val () const;
     660                 :            :   };
     661                 :            : }
     662                 :            : 
     663                 :40833794520 : inline::wi::storage_ref::storage_ref (const HOST_WIDE_INT *val_in,
     664                 :            :                                       unsigned int len_in,
     665                 :            :                                       unsigned int precision_in)
     666                 :            :   : val (val_in), len (len_in), precision (precision_in)
     667                 :            : {
     668                 :            : }
     669                 :            : 
     670                 :            : inline unsigned int
     671                 :24501733223 : wi::storage_ref::get_len () const
     672                 :            : {
     673                 :15450150984 :   return len;
     674                 :            : }
     675                 :            : 
     676                 :            : inline unsigned int
     677                 :13491798751 : wi::storage_ref::get_precision () const
     678                 :            : {
     679                 : 6973068652 :   return precision;
     680                 :            : }
     681                 :            : 
     682                 :            : inline const HOST_WIDE_INT *
     683                 :38534570037 : wi::storage_ref::get_val () const
     684                 :            : {
     685                 :34467188037 :   return val;
     686                 :            : }
     687                 :            : 
     688                 :            : /* This class defines an integer type using the storage provided by the
     689                 :            :    template argument.  The storage class must provide the following
     690                 :            :    functions:
     691                 :            : 
     692                 :            :    unsigned int get_precision () const
     693                 :            :      Return the number of bits in the integer.
     694                 :            : 
     695                 :            :    HOST_WIDE_INT *get_val () const
     696                 :            :      Return a pointer to the array of blocks that encodes the integer.
     697                 :            : 
     698                 :            :    unsigned int get_len () const
     699                 :            :      Return the number of blocks in get_val ().  If this is smaller
     700                 :            :      than the number of blocks implied by get_precision (), the
     701                 :            :      remaining blocks are sign extensions of block get_len () - 1.
     702                 :            : 
     703                 :            :    Although not required by generic_wide_int itself, writable storage
     704                 :            :    classes can also provide the following functions:
     705                 :            : 
     706                 :            :    HOST_WIDE_INT *write_val ()
     707                 :            :      Get a modifiable version of get_val ()
     708                 :            : 
     709                 :            :    unsigned int set_len (unsigned int len)
     710                 :            :      Set the value returned by get_len () to LEN.  */
     711                 :            : template <typename storage>
     712                 :            : class GTY(()) generic_wide_int : public storage
     713                 :            : {
     714                 :            : public:
     715                 :            :   generic_wide_int ();
     716                 :            : 
     717                 :            :   template <typename T>
     718                 :            :   generic_wide_int (const T &);
     719                 :            : 
     720                 :            :   template <typename T>
     721                 :            :   generic_wide_int (const T &, unsigned int);
     722                 :            : 
     723                 :            :   /* Conversions.  */
     724                 :            :   HOST_WIDE_INT to_shwi (unsigned int) const;
     725                 :            :   HOST_WIDE_INT to_shwi () const;
     726                 :            :   unsigned HOST_WIDE_INT to_uhwi (unsigned int) const;
     727                 :            :   unsigned HOST_WIDE_INT to_uhwi () const;
     728                 :            :   HOST_WIDE_INT to_short_addr () const;
     729                 :            : 
     730                 :            :   /* Public accessors for the interior of a wide int.  */
     731                 :            :   HOST_WIDE_INT sign_mask () const;
     732                 :            :   HOST_WIDE_INT elt (unsigned int) const;
     733                 :            :   HOST_WIDE_INT sext_elt (unsigned int) const;
     734                 :            :   unsigned HOST_WIDE_INT ulow () const;
     735                 :            :   unsigned HOST_WIDE_INT uhigh () const;
     736                 :            :   HOST_WIDE_INT slow () const;
     737                 :            :   HOST_WIDE_INT shigh () const;
     738                 :            : 
     739                 :            :   template <typename T>
     740                 :            :   generic_wide_int &operator = (const T &);
     741                 :            : 
     742                 :            : #define ASSIGNMENT_OPERATOR(OP, F) \
     743                 :            :   template <typename T> \
     744                 :            :     generic_wide_int &OP (const T &c) { return (*this = wi::F (*this, c)); }
     745                 :            : 
     746                 :            : /* Restrict these to cases where the shift operator is defined.  */
     747                 :            : #define SHIFT_ASSIGNMENT_OPERATOR(OP, OP2) \
     748                 :            :   template <typename T> \
     749                 :            :     generic_wide_int &OP (const T &c) { return (*this = *this OP2 c); }
     750                 :            : 
     751                 :            : #define INCDEC_OPERATOR(OP, DELTA) \
     752                 :            :   generic_wide_int &OP () { *this += DELTA; return *this; }
     753                 :            : 
     754                 :    6171256 :   ASSIGNMENT_OPERATOR (operator &=, bit_and)
     755                 :   22373469 :   ASSIGNMENT_OPERATOR (operator |=, bit_or)
     756                 :            :   ASSIGNMENT_OPERATOR (operator ^=, bit_xor)
     757                 : 3845481704 :   ASSIGNMENT_OPERATOR (operator +=, add)
     758                 :   24572644 :   ASSIGNMENT_OPERATOR (operator -=, sub)
     759                 :  429926540 :   ASSIGNMENT_OPERATOR (operator *=, mul)
     760                 :  908759777 :   ASSIGNMENT_OPERATOR (operator <<=, lshift)
     761                 :            :   SHIFT_ASSIGNMENT_OPERATOR (operator >>=, >>)
     762                 :     168253 :   INCDEC_OPERATOR (operator ++, 1)
     763                 :      15405 :   INCDEC_OPERATOR (operator --, -1)
     764                 :            : 
     765                 :            : #undef SHIFT_ASSIGNMENT_OPERATOR
     766                 :            : #undef ASSIGNMENT_OPERATOR
     767                 :            : #undef INCDEC_OPERATOR
     768                 :            : 
     769                 :            :   /* Debugging functions.  */
     770                 :            :   void dump () const;
     771                 :            : 
     772                 :            :   static const bool is_sign_extended
     773                 :            :     = wi::int_traits <generic_wide_int <storage> >::is_sign_extended;
     774                 :            : };
     775                 :            : 
     776                 :            : template <typename storage>
     777                 :33836031795 : inline generic_wide_int <storage>::generic_wide_int () {}
     778                 :            : 
     779                 :            : template <typename storage>
     780                 :            : template <typename T>
     781                 :47243735894 : inline generic_wide_int <storage>::generic_wide_int (const T &x)
     782                 :17917516023 :   : storage (x)
     783                 :            : {
     784                 :  326407972 : }
     785                 :            : 
     786                 :            : template <typename storage>
     787                 :            : template <typename T>
     788                 :36456078633 : inline generic_wide_int <storage>::generic_wide_int (const T &x,
     789                 :            :                                                      unsigned int precision)
     790                 :45346670292 :   : storage (x, precision)
     791                 :            : {
     792                 :            : }
     793                 :            : 
     794                 :            : /* Return THIS as a signed HOST_WIDE_INT, sign-extending from PRECISION.
     795                 :            :    If THIS does not fit in PRECISION, the information is lost.  */
     796                 :            : template <typename storage>
     797                 :            : inline HOST_WIDE_INT
     798                 :   34227776 : generic_wide_int <storage>::to_shwi (unsigned int precision) const
     799                 :            : {
     800                 :   34227776 :   if (precision < HOST_BITS_PER_WIDE_INT)
     801                 :   12859163 :     return sext_hwi (this->get_val ()[0], precision);
     802                 :            :   else
     803                 :   19017834 :     return this->get_val ()[0];
     804                 :            : }
     805                 :            : 
     806                 :            : /* Return THIS as a signed HOST_WIDE_INT, in its natural precision.  */
     807                 :            : template <typename storage>
     808                 :            : inline HOST_WIDE_INT
     809                 :10119166875 : generic_wide_int <storage>::to_shwi () const
     810                 :            : {
     811                 :            :   if (is_sign_extended)
     812                 :10105035524 :     return this->get_val ()[0];
     813                 :            :   else
     814                 :   36716079 :     return to_shwi (this->get_precision ());
     815                 :            : }
     816                 :            : 
     817                 :            : /* Return THIS as an unsigned HOST_WIDE_INT, zero-extending from
     818                 :            :    PRECISION.  If THIS does not fit in PRECISION, the information
     819                 :            :    is lost.  */
     820                 :            : template <typename storage>
     821                 :            : inline unsigned HOST_WIDE_INT
     822                 : 8390054696 : generic_wide_int <storage>::to_uhwi (unsigned int precision) const
     823                 :            : {
     824                 : 2668576038 :   if (precision < HOST_BITS_PER_WIDE_INT)
     825                 : 5209107885 :     return zext_hwi (this->get_val ()[0], precision);
     826                 :            :   else
     827                 :  557273248 :     return this->get_val ()[0];
     828                 :            : }
     829                 :            : 
     830                 :            : /* Return THIS as an signed HOST_WIDE_INT, in its natural precision.  */
     831                 :            : template <typename storage>
     832                 :            : inline unsigned HOST_WIDE_INT
     833                 : 8232572696 : generic_wide_int <storage>::to_uhwi () const
     834                 :            : {
     835                 : 7882833309 :   return to_uhwi (this->get_precision ());
     836                 :            : }
     837                 :            : 
     838                 :            : /* TODO: The compiler is half converted from using HOST_WIDE_INT to
     839                 :            :    represent addresses to using offset_int to represent addresses.
     840                 :            :    We use to_short_addr at the interface from new code to old,
     841                 :            :    unconverted code.  */
     842                 :            : template <typename storage>
     843                 :            : inline HOST_WIDE_INT
     844                 :    3276337 : generic_wide_int <storage>::to_short_addr () const
     845                 :            : {
     846                 :    3276337 :   return this->get_val ()[0];
     847                 :            : }
     848                 :            : 
     849                 :            : /* Return the implicit value of blocks above get_len ().  */
     850                 :            : template <typename storage>
     851                 :            : inline HOST_WIDE_INT
     852                 : 2712206114 : generic_wide_int <storage>::sign_mask () const
     853                 :            : {
     854                 : 2712206114 :   unsigned int len = this->get_len ();
     855                 : 2706707235 :   gcc_assert (len > 0);
     856                 :            : 
     857                 : 2712206114 :   unsigned HOST_WIDE_INT high = this->get_val ()[len - 1];
     858                 :            :   if (!is_sign_extended)
     859                 :            :     {
     860                 :   91239320 :       unsigned int precision = this->get_precision ();
     861                 :   91239320 :       int excess = len * HOST_BITS_PER_WIDE_INT - precision;
     862                 :   91239320 :       if (excess > 0)
     863                 :   41515465 :         high <<= excess;
     864                 :            :     }
     865                 : 2717704993 :   return (HOST_WIDE_INT) (high) < 0 ? -1 : 0;
     866                 :            : }
     867                 :            : 
     868                 :            : /* Return the signed value of the least-significant explicitly-encoded
     869                 :            :    block.  */
     870                 :            : template <typename storage>
     871                 :            : inline HOST_WIDE_INT
     872                 : 2701125599 : generic_wide_int <storage>::slow () const
     873                 :            : {
     874                 : 2701125599 :   return this->get_val ()[0];
     875                 :            : }
     876                 :            : 
     877                 :            : /* Return the signed value of the most-significant explicitly-encoded
     878                 :            :    block.  */
     879                 :            : template <typename storage>
     880                 :            : inline HOST_WIDE_INT
     881                 :            : generic_wide_int <storage>::shigh () const
     882                 :            : {
     883                 :            :   return this->get_val ()[this->get_len () - 1];
     884                 :            : }
     885                 :            : 
     886                 :            : /* Return the unsigned value of the least-significant
     887                 :            :    explicitly-encoded block.  */
     888                 :            : template <typename storage>
     889                 :            : inline unsigned HOST_WIDE_INT
     890                 : 8828638420 : generic_wide_int <storage>::ulow () const
     891                 :            : {
     892                 : 8192445420 :   return this->get_val ()[0];
     893                 :            : }
     894                 :            : 
     895                 :            : /* Return the unsigned value of the most-significant
     896                 :            :    explicitly-encoded block.  */
     897                 :            : template <typename storage>
     898                 :            : inline unsigned HOST_WIDE_INT
     899                 :   34177652 : generic_wide_int <storage>::uhigh () const
     900                 :            : {
     901                 :   29978252 :   return this->get_val ()[this->get_len () - 1];
     902                 :            : }
     903                 :            : 
     904                 :            : /* Return block I, which might be implicitly or explicit encoded.  */
     905                 :            : template <typename storage>
     906                 :            : inline HOST_WIDE_INT
     907                 :  337309347 : generic_wide_int <storage>::elt (unsigned int i) const
     908                 :            : {
     909                 :  146227077 :   if (i >= this->get_len ())
     910                 :    1104974 :     return sign_mask ();
     911                 :            :   else
     912                 :  184114769 :     return this->get_val ()[i];
     913                 :            : }
     914                 :            : 
     915                 :            : /* Like elt, but sign-extend beyond the upper bit, instead of returning
     916                 :            :    the raw encoding.  */
     917                 :            : template <typename storage>
     918                 :            : inline HOST_WIDE_INT
     919                 :     877312 : generic_wide_int <storage>::sext_elt (unsigned int i) const
     920                 :            : {
     921                 :     877312 :   HOST_WIDE_INT elt_i = elt (i);
     922                 :            :   if (!is_sign_extended)
     923                 :            :     {
     924                 :          0 :       unsigned int precision = this->get_precision ();
     925                 :          0 :       unsigned int lsb = i * HOST_BITS_PER_WIDE_INT;
     926                 :          0 :       if (precision - lsb < HOST_BITS_PER_WIDE_INT)
     927                 :          0 :         elt_i = sext_hwi (elt_i, precision - lsb);
     928                 :            :     }
     929                 :          0 :   return elt_i;
     930                 :            : }
     931                 :            : 
     932                 :            : template <typename storage>
     933                 :            : template <typename T>
     934                 :            : inline generic_wide_int <storage> &
     935                 : 3605194346 : generic_wide_int <storage>::operator = (const T &x)
     936                 :            : {
     937                 : 2385622918 :   storage::operator = (x);
     938                 :    2891895 :   return *this;
     939                 :            : }
     940                 :            : 
     941                 :            : /* Dump the contents of the integer to stderr, for debugging.  */
     942                 :            : template <typename storage>
     943                 :            : void
     944                 :          0 : generic_wide_int <storage>::dump () const
     945                 :            : {
     946                 :          0 :   unsigned int len = this->get_len ();
     947                 :          0 :   const HOST_WIDE_INT *val = this->get_val ();
     948                 :          0 :   unsigned int precision = this->get_precision ();
     949                 :          0 :   fprintf (stderr, "[");
     950                 :          0 :   if (len * HOST_BITS_PER_WIDE_INT < precision)
     951                 :          0 :     fprintf (stderr, "...,");
     952                 :          0 :   for (unsigned int i = 0; i < len - 1; ++i)
     953                 :          0 :     fprintf (stderr, HOST_WIDE_INT_PRINT_HEX ",", val[len - 1 - i]);
     954                 :          0 :   fprintf (stderr, HOST_WIDE_INT_PRINT_HEX "], precision = %d\n",
     955                 :            :            val[0], precision);
     956                 :          0 : }
     957                 :            : 
     958                 :            : namespace wi
     959                 :            : {
     960                 :            :   template <typename storage>
     961                 :            :   struct int_traits < generic_wide_int <storage> >
     962                 :            :     : public wi::int_traits <storage>
     963                 :            :   {
     964                 :            :     static unsigned int get_precision (const generic_wide_int <storage> &);
     965                 :            :     static wi::storage_ref decompose (HOST_WIDE_INT *, unsigned int,
     966                 :            :                                       const generic_wide_int <storage> &);
     967                 :            :   };
     968                 :            : }
     969                 :            : 
     970                 :            : template <typename storage>
     971                 :            : inline unsigned int
     972                 :42357501444 : wi::int_traits < generic_wide_int <storage> >::
     973                 :            : get_precision (const generic_wide_int <storage> &x)
     974                 :            : {
     975                 :42357501444 :   return x.get_precision ();
     976                 :            : }
     977                 :            : 
     978                 :            : template <typename storage>
     979                 :            : inline wi::storage_ref
     980                 :48832476876 : wi::int_traits < generic_wide_int <storage> >::
     981                 :            : decompose (HOST_WIDE_INT *, unsigned int precision,
     982                 :            :            const generic_wide_int <storage> &x)
     983                 :            : {
     984                 :16391339706 :   gcc_checking_assert (precision == x.get_precision ());
     985                 :32632284097 :   return wi::storage_ref (x.get_val (), x.get_len (), precision);
     986                 :            : }
     987                 :            : 
     988                 :            : /* Provide the storage for a wide_int_ref.  This acts like a read-only
     989                 :            :    wide_int, with the optimization that VAL is normally a pointer to
     990                 :            :    another integer's storage, so that no array copy is needed.  */
     991                 :            : template <bool SE, bool HDP>
     992                 :            : class wide_int_ref_storage : public wi::storage_ref
     993                 :            : {
     994                 :            : private:
     995                 :            :   /* Scratch space that can be used when decomposing the original integer.
     996                 :            :      It must live as long as this object.  */
     997                 :            :   HOST_WIDE_INT scratch[2];
     998                 :            : 
     999                 :            : public:
    1000                 :            :   wide_int_ref_storage () {}
    1001                 :            : 
    1002                 :            :   wide_int_ref_storage (const wi::storage_ref &);
    1003                 :            : 
    1004                 :            :   template <typename T>
    1005                 :            :   wide_int_ref_storage (const T &);
    1006                 :            : 
    1007                 :            :   template <typename T>
    1008                 :            :   wide_int_ref_storage (const T &, unsigned int);
    1009                 :            : };
    1010                 :            : 
    1011                 :            : /* Create a reference from an existing reference.  */
    1012                 :            : template <bool SE, bool HDP>
    1013                 : 5710102155 : inline wide_int_ref_storage <SE, HDP>::
    1014                 :            : wide_int_ref_storage (const wi::storage_ref &x)
    1015                 : 5710102155 :   : storage_ref (x)
    1016                 :            : {}
    1017                 :            : 
    1018                 :            : /* Create a reference to integer X in its natural precision.  Note
    1019                 :            :    that the natural precision is host-dependent for primitive
    1020                 :            :    types.  */
    1021                 :            : template <bool SE, bool HDP>
    1022                 :            : template <typename T>
    1023                 :21305178053 : inline wide_int_ref_storage <SE, HDP>::wide_int_ref_storage (const T &x)
    1024                 :21296896280 :   : storage_ref (wi::int_traits <T>::decompose (scratch,
    1025                 :            :                                                 wi::get_precision (x), x))
    1026                 :            : {
    1027                 :  954510919 : }
    1028                 :            : 
    1029                 :            : /* Create a reference to integer X in precision PRECISION.  */
    1030                 :            : template <bool SE, bool HDP>
    1031                 :            : template <typename T>
    1032                 :36456078633 : inline wide_int_ref_storage <SE, HDP>::
    1033                 :            : wide_int_ref_storage (const T &x, unsigned int precision)
    1034                 :38726152116 :   : storage_ref (wi::int_traits <T>::decompose (scratch, precision, x))
    1035                 :            : {
    1036                 :            : }
    1037                 :            : 
    1038                 :            : namespace wi
    1039                 :            : {
    1040                 :            :   template <bool SE, bool HDP>
    1041                 :            :   struct int_traits <wide_int_ref_storage <SE, HDP> >
    1042                 :            :   {
    1043                 :            :     static const enum precision_type precision_type = VAR_PRECISION;
    1044                 :            :     static const bool host_dependent_precision = HDP;
    1045                 :            :     static const bool is_sign_extended = SE;
    1046                 :            :   };
    1047                 :            : }
    1048                 :            : 
    1049                 :            : namespace wi
    1050                 :            : {
    1051                 :            :   unsigned int force_to_size (HOST_WIDE_INT *, const HOST_WIDE_INT *,
    1052                 :            :                               unsigned int, unsigned int, unsigned int,
    1053                 :            :                               signop sgn);
    1054                 :            :   unsigned int from_array (HOST_WIDE_INT *, const HOST_WIDE_INT *,
    1055                 :            :                            unsigned int, unsigned int, bool = true);
    1056                 :            : }
    1057                 :            : 
    1058                 :            : /* The storage used by wide_int.  */
    1059                 :            : class GTY(()) wide_int_storage
    1060                 :            : {
    1061                 :            : private:
    1062                 :            :   HOST_WIDE_INT val[WIDE_INT_MAX_ELTS];
    1063                 :            :   unsigned int len;
    1064                 :            :   unsigned int precision;
    1065                 :            : 
    1066                 :            : public:
    1067                 :            :   wide_int_storage ();
    1068                 :            :   template <typename T>
    1069                 :            :   wide_int_storage (const T &);
    1070                 :            : 
    1071                 :            :   /* The standard generic_wide_int storage methods.  */
    1072                 :            :   unsigned int get_precision () const;
    1073                 :            :   const HOST_WIDE_INT *get_val () const;
    1074                 :            :   unsigned int get_len () const;
    1075                 :            :   HOST_WIDE_INT *write_val ();
    1076                 :            :   void set_len (unsigned int, bool = false);
    1077                 :            : 
    1078                 :            :   template <typename T>
    1079                 :            :   wide_int_storage &operator = (const T &);
    1080                 :            : 
    1081                 :            :   static wide_int from (const wide_int_ref &, unsigned int, signop);
    1082                 :            :   static wide_int from_array (const HOST_WIDE_INT *, unsigned int,
    1083                 :            :                               unsigned int, bool = true);
    1084                 :            :   static wide_int create (unsigned int);
    1085                 :            : 
    1086                 :            :   /* FIXME: target-dependent, so should disappear.  */
    1087                 :            :   wide_int bswap () const;
    1088                 :            : };
    1089                 :            : 
    1090                 :            : namespace wi
    1091                 :            : {
    1092                 :            :   template <>
    1093                 :            :   struct int_traits <wide_int_storage>
    1094                 :            :   {
    1095                 :            :     static const enum precision_type precision_type = VAR_PRECISION;
    1096                 :            :     /* Guaranteed by a static assert in the wide_int_storage constructor.  */
    1097                 :            :     static const bool host_dependent_precision = false;
    1098                 :            :     static const bool is_sign_extended = true;
    1099                 :            :     template <typename T1, typename T2>
    1100                 :            :     static wide_int get_binary_result (const T1 &, const T2 &);
    1101                 :            :   };
    1102                 :            : }
    1103                 :            : 
    1104                 : 2341395093 : inline wide_int_storage::wide_int_storage () {}
    1105                 :            : 
    1106                 :            : /* Initialize the storage from integer X, in its natural precision.
    1107                 :            :    Note that we do not allow integers with host-dependent precision
    1108                 :            :    to become wide_ints; wide_ints must always be logically independent
    1109                 :            :    of the host.  */
    1110                 :            : template <typename T>
    1111                 : 2142534892 : inline wide_int_storage::wide_int_storage (const T &x)
    1112                 :            : {
    1113                 :            :   { STATIC_ASSERT (!wi::int_traits<T>::host_dependent_precision); }
    1114                 :            :   { STATIC_ASSERT (wi::int_traits<T>::precision_type != wi::CONST_PRECISION); }
    1115                 : 2142534892 :   WIDE_INT_REF_FOR (T) xi (x);
    1116                 : 2142534892 :   precision = xi.precision;
    1117                 : 2128732758 :   wi::copy (*this, xi);
    1118                 : 1080893277 : }
    1119                 :            : 
    1120                 :            : template <typename T>
    1121                 :            : inline wide_int_storage&
    1122                 :  111359428 : wide_int_storage::operator = (const T &x)
    1123                 :            : {
    1124                 :            :   { STATIC_ASSERT (!wi::int_traits<T>::host_dependent_precision); }
    1125                 :            :   { STATIC_ASSERT (wi::int_traits<T>::precision_type != wi::CONST_PRECISION); }
    1126                 :  111359428 :   WIDE_INT_REF_FOR (T) xi (x);
    1127                 :  111359428 :   precision = xi.precision;
    1128                 :  108427851 :   wi::copy (*this, xi);
    1129                 :   99164196 :   return *this;
    1130                 :            : }
    1131                 :            : 
    1132                 :            : inline unsigned int
    1133                 :20586345280 : wide_int_storage::get_precision () const
    1134                 :            : {
    1135                 : 9919690291 :   return precision;
    1136                 :            : }
    1137                 :            : 
    1138                 :            : inline const HOST_WIDE_INT *
    1139                 :10940689840 : wide_int_storage::get_val () const
    1140                 :            : {
    1141                 : 4698600153 :   return val;
    1142                 :            : }
    1143                 :            : 
    1144                 :            : inline unsigned int
    1145                 :11072713477 : wide_int_storage::get_len () const
    1146                 :            : {
    1147                 : 7450185910 :   return len;
    1148                 :            : }
    1149                 :            : 
    1150                 :            : inline HOST_WIDE_INT *
    1151                 : 8826287028 : wide_int_storage::write_val ()
    1152                 :            : {
    1153                 : 8105675278 :   return val;
    1154                 :            : }
    1155                 :            : 
    1156                 :            : inline void
    1157                 : 8437076406 : wide_int_storage::set_len (unsigned int l, bool is_sign_extended)
    1158                 :            : {
    1159                 : 8437076406 :   len = l;
    1160                 : 1154872614 :   if (!is_sign_extended && len * HOST_BITS_PER_WIDE_INT > precision)
    1161                 : 1687428143 :     val[len - 1] = sext_hwi (val[len - 1],
    1162                 :            :                              precision % HOST_BITS_PER_WIDE_INT);
    1163                 :  588585277 : }
    1164                 :            : 
    1165                 :            : /* Treat X as having signedness SGN and convert it to a PRECISION-bit
    1166                 :            :    number.  */
    1167                 :            : inline wide_int
    1168                 : 3584697939 : wide_int_storage::from (const wide_int_ref &x, unsigned int precision,
    1169                 :            :                         signop sgn)
    1170                 :            : {
    1171                 : 3584697939 :   wide_int result = wide_int::create (precision);
    1172                 : 3584697939 :   result.set_len (wi::force_to_size (result.write_val (), x.val, x.len,
    1173                 : 3584697939 :                                      x.precision, precision, sgn));
    1174                 : 3584697939 :   return result;
    1175                 :            : }
    1176                 :            : 
    1177                 :            : /* Create a wide_int from the explicit block encoding given by VAL and
    1178                 :            :    LEN.  PRECISION is the precision of the integer.  NEED_CANON_P is
    1179                 :            :    true if the encoding may have redundant trailing blocks.  */
    1180                 :            : inline wide_int
    1181                 :     734421 : wide_int_storage::from_array (const HOST_WIDE_INT *val, unsigned int len,
    1182                 :            :                               unsigned int precision, bool need_canon_p)
    1183                 :            : {
    1184                 :     734421 :   wide_int result = wide_int::create (precision);
    1185                 :     734421 :   result.set_len (wi::from_array (result.write_val (), val, len, precision,
    1186                 :            :                                   need_canon_p));
    1187                 :     734421 :   return result;
    1188                 :            : }
    1189                 :            : 
    1190                 :            : /* Return an uninitialized wide_int with precision PRECISION.  */
    1191                 :            : inline wide_int
    1192                 :15242366680 : wide_int_storage::create (unsigned int precision)
    1193                 :            : {
    1194                 :15242366680 :   wide_int x;
    1195                 :15242366680 :   x.precision = precision;
    1196                 : 6793874532 :   return x;
    1197                 :            : }
    1198                 :            : 
    1199                 :            : template <typename T1, typename T2>
    1200                 :            : inline wide_int
    1201                 :11378944938 : wi::int_traits <wide_int_storage>::get_binary_result (const T1 &x, const T2 &y)
    1202                 :            : {
    1203                 :            :   /* This shouldn't be used for two flexible-precision inputs.  */
    1204                 :            :   STATIC_ASSERT (wi::int_traits <T1>::precision_type != FLEXIBLE_PRECISION
    1205                 :            :                  || wi::int_traits <T2>::precision_type != FLEXIBLE_PRECISION);
    1206                 :            :   if (wi::int_traits <T1>::precision_type == FLEXIBLE_PRECISION)
    1207                 :   32134878 :     return wide_int::create (wi::get_precision (y));
    1208                 :            :   else
    1209                 :11346800259 :     return wide_int::create (wi::get_precision (x));
    1210                 :            : }
    1211                 :            : 
    1212                 :            : /* The storage used by FIXED_WIDE_INT (N).  */
    1213                 :            : template <int N>
    1214                 :            : class GTY(()) fixed_wide_int_storage
    1215                 :            : {
    1216                 :            : private:
    1217                 :            :   HOST_WIDE_INT val[(N + HOST_BITS_PER_WIDE_INT + 1) / HOST_BITS_PER_WIDE_INT];
    1218                 :            :   unsigned int len;
    1219                 :            : 
    1220                 :            : public:
    1221                 :            :   fixed_wide_int_storage ();
    1222                 :            :   template <typename T>
    1223                 :            :   fixed_wide_int_storage (const T &);
    1224                 :            : 
    1225                 :            :   /* The standard generic_wide_int storage methods.  */
    1226                 :            :   unsigned int get_precision () const;
    1227                 :            :   const HOST_WIDE_INT *get_val () const;
    1228                 :            :   unsigned int get_len () const;
    1229                 :            :   HOST_WIDE_INT *write_val ();
    1230                 :            :   void set_len (unsigned int, bool = false);
    1231                 :            : 
    1232                 :            :   static FIXED_WIDE_INT (N) from (const wide_int_ref &, signop);
    1233                 :            :   static FIXED_WIDE_INT (N) from_array (const HOST_WIDE_INT *, unsigned int,
    1234                 :            :                                         bool = true);
    1235                 :            : };
    1236                 :            : 
    1237                 :            : namespace wi
    1238                 :            : {
    1239                 :            :   template <int N>
    1240                 :            :   struct int_traits < fixed_wide_int_storage <N> >
    1241                 :            :   {
    1242                 :            :     static const enum precision_type precision_type = CONST_PRECISION;
    1243                 :            :     static const bool host_dependent_precision = false;
    1244                 :            :     static const bool is_sign_extended = true;
    1245                 :            :     static const unsigned int precision = N;
    1246                 :            :     template <typename T1, typename T2>
    1247                 :            :     static FIXED_WIDE_INT (N) get_binary_result (const T1 &, const T2 &);
    1248                 :            :   };
    1249                 :            : }
    1250                 :            : 
    1251                 :            : template <int N>
    1252                 :15182178862 : inline fixed_wide_int_storage <N>::fixed_wide_int_storage () {}
    1253                 :            : 
    1254                 :            : /* Initialize the storage from integer X, in precision N.  */
    1255                 :            : template <int N>
    1256                 :            : template <typename T>
    1257                 : 1619293005 : inline fixed_wide_int_storage <N>::fixed_wide_int_storage (const T &x)
    1258                 :            : {
    1259                 :            :   /* Check for type compatibility.  We don't want to initialize a
    1260                 :            :      fixed-width integer from something like a wide_int.  */
    1261                 :            :   WI_BINARY_RESULT (T, FIXED_WIDE_INT (N)) *assertion ATTRIBUTE_UNUSED;
    1262                 : 7495608239 :   wi::copy (*this, WIDE_INT_REF_FOR (T) (x, N));
    1263                 : 1505241832 : }
    1264                 :            : 
    1265                 :            : template <int N>
    1266                 :            : inline unsigned int
    1267                 :24451198723 : fixed_wide_int_storage <N>::get_precision () const
    1268                 :            : {
    1269                 :            :   return N;
    1270                 :            : }
    1271                 :            : 
    1272                 :            : template <int N>
    1273                 :            : inline const HOST_WIDE_INT *
    1274                 : 8044188728 : fixed_wide_int_storage <N>::get_val () const
    1275                 :            : {
    1276                 :18897451578 :   return val;
    1277                 :            : }
    1278                 :            : 
    1279                 :            : template <int N>
    1280                 :            : inline unsigned int
    1281                 :19195199906 : fixed_wide_int_storage <N>::get_len () const
    1282                 :            : {
    1283                 :            :   return len;
    1284                 :            : }
    1285                 :            : 
    1286                 :            : template <int N>
    1287                 :            : inline HOST_WIDE_INT *
    1288                 :17674377548 : fixed_wide_int_storage <N>::write_val ()
    1289                 :            : {
    1290                 : 4766821731 :   return val;
    1291                 :            : }
    1292                 :            : 
    1293                 :            : template <int N>
    1294                 :            : inline void
    1295                 :17673024139 : fixed_wide_int_storage <N>::set_len (unsigned int l, bool)
    1296                 :            : {
    1297                 :15544507098 :   len = l;
    1298                 :            :   /* There are no excess bits in val[len - 1].  */
    1299                 :            :   STATIC_ASSERT (N % HOST_BITS_PER_WIDE_INT == 0);
    1300                 : 8631586117 : }
    1301                 :            : 
    1302                 :            : /* Treat X as having signedness SGN and convert it to an N-bit number.  */
    1303                 :            : template <int N>
    1304                 :            : inline FIXED_WIDE_INT (N)
    1305                 : 1025203677 : fixed_wide_int_storage <N>::from (const wide_int_ref &x, signop sgn)
    1306                 :            : {
    1307                 : 1025192989 :   FIXED_WIDE_INT (N) result;
    1308                 : 1014088157 :   result.set_len (wi::force_to_size (result.write_val (), x.val, x.len,
    1309                 :  921774834 :                                      x.precision, N, sgn));
    1310                 :         44 :   return result;
    1311                 :            : }
    1312                 :            : 
    1313                 :            : /* Create a FIXED_WIDE_INT (N) from the explicit block encoding given by
    1314                 :            :    VAL and LEN.  NEED_CANON_P is true if the encoding may have redundant
    1315                 :            :    trailing blocks.  */
    1316                 :            : template <int N>
    1317                 :            : inline FIXED_WIDE_INT (N)
    1318                 :   31003039 : fixed_wide_int_storage <N>::from_array (const HOST_WIDE_INT *val,
    1319                 :            :                                         unsigned int len,
    1320                 :            :                                         bool need_canon_p)
    1321                 :            : {
    1322                 :   31003039 :   FIXED_WIDE_INT (N) result;
    1323                 :   31003039 :   result.set_len (wi::from_array (result.write_val (), val, len,
    1324                 :            :                                   N, need_canon_p));
    1325                 :            :   return result;
    1326                 :            : }
    1327                 :            : 
    1328                 :            : template <int N>
    1329                 :            : template <typename T1, typename T2>
    1330                 :            : inline FIXED_WIDE_INT (N)
    1331                 :16671944723 : wi::int_traits < fixed_wide_int_storage <N> >::
    1332                 :            : get_binary_result (const T1 &, const T2 &)
    1333                 :            : {
    1334                 :16671944723 :   return FIXED_WIDE_INT (N) ();
    1335                 :            : }
    1336                 :            : 
    1337                 :            : /* A reference to one element of a trailing_wide_ints structure.  */
    1338                 :            : class trailing_wide_int_storage
    1339                 :            : {
    1340                 :            : private:
    1341                 :            :   /* The precision of the integer, which is a fixed property of the
    1342                 :            :      parent trailing_wide_ints.  */
    1343                 :            :   unsigned int m_precision;
    1344                 :            : 
    1345                 :            :   /* A pointer to the length field.  */
    1346                 :            :   unsigned char *m_len;
    1347                 :            : 
    1348                 :            :   /* A pointer to the HWI array.  There are enough elements to hold all
    1349                 :            :      values of precision M_PRECISION.  */
    1350                 :            :   HOST_WIDE_INT *m_val;
    1351                 :            : 
    1352                 :            : public:
    1353                 :            :   trailing_wide_int_storage (unsigned int, unsigned char *, HOST_WIDE_INT *);
    1354                 :            : 
    1355                 :            :   /* The standard generic_wide_int storage methods.  */
    1356                 :            :   unsigned int get_len () const;
    1357                 :            :   unsigned int get_precision () const;
    1358                 :            :   const HOST_WIDE_INT *get_val () const;
    1359                 :            :   HOST_WIDE_INT *write_val ();
    1360                 :            :   void set_len (unsigned int, bool = false);
    1361                 :            : 
    1362                 :            :   template <typename T>
    1363                 :            :   trailing_wide_int_storage &operator = (const T &);
    1364                 :            : };
    1365                 :            : 
    1366                 :            : typedef generic_wide_int <trailing_wide_int_storage> trailing_wide_int;
    1367                 :            : 
    1368                 :            : /* trailing_wide_int behaves like a wide_int.  */
    1369                 :            : namespace wi
    1370                 :            : {
    1371                 :            :   template <>
    1372                 :            :   struct int_traits <trailing_wide_int_storage>
    1373                 :            :     : public int_traits <wide_int_storage> {};
    1374                 :            : }
    1375                 :            : 
    1376                 :            : /* An array of N wide_int-like objects that can be put at the end of
    1377                 :            :    a variable-sized structure.  Use extra_size to calculate how many
    1378                 :            :    bytes beyond the sizeof need to be allocated.  Use set_precision
    1379                 :            :    to initialize the structure.  */
    1380                 :            : template <int N>
    1381                 :            : struct GTY((user)) trailing_wide_ints
    1382                 :            : {
    1383                 :            : private:
    1384                 :            :   /* The shared precision of each number.  */
    1385                 :            :   unsigned short m_precision;
    1386                 :            : 
    1387                 :            :   /* The shared maximum length of each number.  */
    1388                 :            :   unsigned char m_max_len;
    1389                 :            : 
    1390                 :            :   /* The current length of each number.  */
    1391                 :            :   unsigned char m_len[N];
    1392                 :            : 
    1393                 :            :   /* The variable-length part of the structure, which always contains
    1394                 :            :      at least one HWI.  Element I starts at index I * M_MAX_LEN.  */
    1395                 :            :   HOST_WIDE_INT m_val[1];
    1396                 :            : 
    1397                 :            : public:
    1398                 :            :   typedef WIDE_INT_REF_FOR (trailing_wide_int_storage) const_reference;
    1399                 :            : 
    1400                 :            :   void set_precision (unsigned int);
    1401                 :            :   unsigned int get_precision () const { return m_precision; }
    1402                 :            :   trailing_wide_int operator [] (unsigned int);
    1403                 :            :   const_reference operator [] (unsigned int) const;
    1404                 :            :   static size_t extra_size (unsigned int);
    1405                 :            :   size_t extra_size () const { return extra_size (m_precision); }
    1406                 :            : };
    1407                 :            : 
    1408                 :  231834550 : inline trailing_wide_int_storage::
    1409                 :            : trailing_wide_int_storage (unsigned int precision, unsigned char *len,
    1410                 :            :                            HOST_WIDE_INT *val)
    1411                 :            :   : m_precision (precision), m_len (len), m_val (val)
    1412                 :            : {
    1413                 :            : }
    1414                 :            : 
    1415                 :            : inline unsigned int
    1416                 :          0 : trailing_wide_int_storage::get_len () const
    1417                 :            : {
    1418                 :          0 :   return *m_len;
    1419                 :            : }
    1420                 :            : 
    1421                 :            : inline unsigned int
    1422                 :  178455550 : trailing_wide_int_storage::get_precision () const
    1423                 :            : {
    1424                 :  178455550 :   return m_precision;
    1425                 :            : }
    1426                 :            : 
    1427                 :            : inline const HOST_WIDE_INT *
    1428                 :          0 : trailing_wide_int_storage::get_val () const
    1429                 :            : {
    1430                 :          0 :   return m_val;
    1431                 :            : }
    1432                 :            : 
    1433                 :            : inline HOST_WIDE_INT *
    1434                 :   53378500 : trailing_wide_int_storage::write_val ()
    1435                 :            : {
    1436                 :   53378500 :   return m_val;
    1437                 :            : }
    1438                 :            : 
    1439                 :            : inline void
    1440                 :   53378500 : trailing_wide_int_storage::set_len (unsigned int len, bool is_sign_extended)
    1441                 :            : {
    1442                 :   53378500 :   *m_len = len;
    1443                 :   34284300 :   if (!is_sign_extended && len * HOST_BITS_PER_WIDE_INT > m_precision)
    1444                 :   16590800 :     m_val[len - 1] = sext_hwi (m_val[len - 1],
    1445                 :            :                                m_precision % HOST_BITS_PER_WIDE_INT);
    1446                 :            : }
    1447                 :            : 
    1448                 :            : template <typename T>
    1449                 :            : inline trailing_wide_int_storage &
    1450                 :   53378530 : trailing_wide_int_storage::operator = (const T &x)
    1451                 :            : {
    1452                 :   53378530 :   WIDE_INT_REF_FOR (T) xi (x, m_precision);
    1453                 :   53378530 :   wi::copy (*this, xi);
    1454                 :   53378530 :   return *this;
    1455                 :            : }
    1456                 :            : 
    1457                 :            : /* Initialize the structure and record that all elements have precision
    1458                 :            :    PRECISION.  */
    1459                 :            : template <int N>
    1460                 :            : inline void
    1461                 :    5632030 : trailing_wide_ints <N>::set_precision (unsigned int precision)
    1462                 :            : {
    1463                 :    5632030 :   m_precision = precision;
    1464                 :    5632030 :   m_max_len = ((precision + HOST_BITS_PER_WIDE_INT - 1)
    1465                 :            :                / HOST_BITS_PER_WIDE_INT);
    1466                 :            : }
    1467                 :            : 
    1468                 :            : /* Return a reference to element INDEX.  */
    1469                 :            : template <int N>
    1470                 :            : inline trailing_wide_int
    1471                 :  231834550 : trailing_wide_ints <N>::operator [] (unsigned int index)
    1472                 :            : {
    1473                 :  226202550 :   return trailing_wide_int_storage (m_precision, &m_len[index],
    1474                 :  144318550 :                                     &m_val[index * m_max_len]);
    1475                 :            : }
    1476                 :            : 
    1477                 :            : template <int N>
    1478                 :            : inline typename trailing_wide_ints <N>::const_reference
    1479                 :          0 : trailing_wide_ints <N>::operator [] (unsigned int index) const
    1480                 :            : {
    1481                 :            :   return wi::storage_ref (&m_val[index * m_max_len],
    1482                 :          0 :                           m_len[index], m_precision);
    1483                 :            : }
    1484                 :            : 
    1485                 :            : /* Return how many extra bytes need to be added to the end of the structure
    1486                 :            :    in order to handle N wide_ints of precision PRECISION.  */
    1487                 :            : template <int N>
    1488                 :            : inline size_t
    1489                 :    9399140 : trailing_wide_ints <N>::extra_size (unsigned int precision)
    1490                 :            : {
    1491                 :    9399140 :   unsigned int max_len = ((precision + HOST_BITS_PER_WIDE_INT - 1)
    1492                 :            :                           / HOST_BITS_PER_WIDE_INT);
    1493                 :    9399140 :   return (N * max_len - 1) * sizeof (HOST_WIDE_INT);
    1494                 :            : }
    1495                 :            : 
    1496                 :            : /* This macro is used in structures that end with a trailing_wide_ints field
    1497                 :            :    called FIELD.  It declares get_NAME() and set_NAME() methods to access
    1498                 :            :    element I of FIELD.  */
    1499                 :            : #define TRAILING_WIDE_INT_ACCESSOR(NAME, FIELD, I) \
    1500                 :            :   trailing_wide_int get_##NAME () { return FIELD[I]; } \
    1501                 :            :   template <typename T> void set_##NAME (const T &x) { FIELD[I] = x; }
    1502                 :            : 
    1503                 :            : namespace wi
    1504                 :            : {
    1505                 :            :   /* Implementation of int_traits for primitive integer types like "int".  */
    1506                 :            :   template <typename T, bool signed_p>
    1507                 :            :   struct primitive_int_traits
    1508                 :            :   {
    1509                 :            :     static const enum precision_type precision_type = FLEXIBLE_PRECISION;
    1510                 :            :     static const bool host_dependent_precision = true;
    1511                 :            :     static const bool is_sign_extended = true;
    1512                 :            :     static unsigned int get_precision (T);
    1513                 :            :     static wi::storage_ref decompose (HOST_WIDE_INT *, unsigned int, T);
    1514                 :            :   };
    1515                 :            : }
    1516                 :            : 
    1517                 :            : template <typename T, bool signed_p>
    1518                 :            : inline unsigned int
    1519                 : 2789961689 : wi::primitive_int_traits <T, signed_p>::get_precision (T)
    1520                 :            : {
    1521                 :            :   return sizeof (T) * CHAR_BIT;
    1522                 :            : }
    1523                 :            : 
    1524                 :            : template <typename T, bool signed_p>
    1525                 :            : inline wi::storage_ref
    1526                 :16605145573 : wi::primitive_int_traits <T, signed_p>::decompose (HOST_WIDE_INT *scratch,
    1527                 :            :                                                    unsigned int precision, T x)
    1528                 :            : {
    1529                 :16585164927 :   scratch[0] = x;
    1530                 :  108259196 :   if (signed_p || scratch[0] >= 0 || precision <= HOST_BITS_PER_WIDE_INT)
    1531                 :16487466611 :     return wi::storage_ref (scratch, 1, precision);
    1532                 :       8598 :   scratch[1] = 0;
    1533                 :       8598 :   return wi::storage_ref (scratch, 2, precision);
    1534                 :            : }
    1535                 :            : 
    1536                 :            : /* Allow primitive C types to be used in wi:: routines.  */
    1537                 :            : namespace wi
    1538                 :            : {
    1539                 :            :   template <>
    1540                 :            :   struct int_traits <unsigned char>
    1541                 :            :     : public primitive_int_traits <unsigned char, false> {};
    1542                 :            : 
    1543                 :            :   template <>
    1544                 :            :   struct int_traits <unsigned short>
    1545                 :            :     : public primitive_int_traits <unsigned short, false> {};
    1546                 :            : 
    1547                 :            :   template <>
    1548                 :            :   struct int_traits <int>
    1549                 :            :     : public primitive_int_traits <int, true> {};
    1550                 :            : 
    1551                 :            :   template <>
    1552                 :            :   struct int_traits <unsigned int>
    1553                 :            :     : public primitive_int_traits <unsigned int, false> {};
    1554                 :            : 
    1555                 :            :   template <>
    1556                 :            :   struct int_traits <long>
    1557                 :            :     : public primitive_int_traits <long, true> {};
    1558                 :            : 
    1559                 :            :   template <>
    1560                 :            :   struct int_traits <unsigned long>
    1561                 :            :     : public primitive_int_traits <unsigned long, false> {};
    1562                 :            : 
    1563                 :            : #if defined HAVE_LONG_LONG
    1564                 :            :   template <>
    1565                 :            :   struct int_traits <long long>
    1566                 :            :     : public primitive_int_traits <long long, true> {};
    1567                 :            : 
    1568                 :            :   template <>
    1569                 :            :   struct int_traits <unsigned long long>
    1570                 :            :     : public primitive_int_traits <unsigned long long, false> {};
    1571                 :            : #endif
    1572                 :            : }
    1573                 :            : 
    1574                 :            : namespace wi
    1575                 :            : {
    1576                 :            :   /* Stores HWI-sized integer VAL, treating it as having signedness SGN
    1577                 :            :      and precision PRECISION.  */
    1578                 :            :   class hwi_with_prec
    1579                 :            :   {
    1580                 :            :   public:
    1581                 :            :     hwi_with_prec () {}
    1582                 :            :     hwi_with_prec (HOST_WIDE_INT, unsigned int, signop);
    1583                 :            :     HOST_WIDE_INT val;
    1584                 :            :     unsigned int precision;
    1585                 :            :     signop sgn;
    1586                 :            :   };
    1587                 :            : 
    1588                 :            :   hwi_with_prec shwi (HOST_WIDE_INT, unsigned int);
    1589                 :            :   hwi_with_prec uhwi (unsigned HOST_WIDE_INT, unsigned int);
    1590                 :            : 
    1591                 :            :   hwi_with_prec minus_one (unsigned int);
    1592                 :            :   hwi_with_prec zero (unsigned int);
    1593                 :            :   hwi_with_prec one (unsigned int);
    1594                 :            :   hwi_with_prec two (unsigned int);
    1595                 :            : }
    1596                 :            : 
    1597                 : 2898775748 : inline wi::hwi_with_prec::hwi_with_prec (HOST_WIDE_INT v, unsigned int p,
    1598                 :            :                                          signop s)
    1599                 :            :   : precision (p), sgn (s)
    1600                 :            : {
    1601                 : 2898775748 :   if (precision < HOST_BITS_PER_WIDE_INT)
    1602                 : 1052553849 :     val = sext_hwi (v, precision);
    1603                 :            :   else
    1604                 :            :     val = v;
    1605                 :            : }
    1606                 :            : 
    1607                 :            : /* Return a signed integer that has value VAL and precision PRECISION.  */
    1608                 :            : inline wi::hwi_with_prec
    1609                 : 2664660169 : wi::shwi (HOST_WIDE_INT val, unsigned int precision)
    1610                 :            : {
    1611                 : 3266670870 :   return hwi_with_prec (val, precision, SIGNED);
    1612                 :            : }
    1613                 :            : 
    1614                 :            : /* Return an unsigned integer that has value VAL and precision PRECISION.  */
    1615                 :            : inline wi::hwi_with_prec
    1616                 :  234108766 : wi::uhwi (unsigned HOST_WIDE_INT val, unsigned int precision)
    1617                 :            : {
    1618                 :  235019826 :   return hwi_with_prec (val, precision, UNSIGNED);
    1619                 :            : }
    1620                 :            : 
    1621                 :            : /* Return a wide int of -1 with precision PRECISION.  */
    1622                 :            : inline wi::hwi_with_prec
    1623                 :   33459065 : wi::minus_one (unsigned int precision)
    1624                 :            : {
    1625                 :   37543649 :   return wi::shwi (-1, precision);
    1626                 :            : }
    1627                 :            : 
    1628                 :            : /* Return a wide int of 0 with precision PRECISION.  */
    1629                 :            : inline wi::hwi_with_prec
    1630                 :   40688264 : wi::zero (unsigned int precision)
    1631                 :            : {
    1632                 :   40686820 :   return wi::shwi (0, precision);
    1633                 :            : }
    1634                 :            : 
    1635                 :            : /* Return a wide int of 1 with precision PRECISION.  */
    1636                 :            : inline wi::hwi_with_prec
    1637                 :  271329776 : wi::one (unsigned int precision)
    1638                 :            : {
    1639                 :  271673011 :   return wi::shwi (1, precision);
    1640                 :            : }
    1641                 :            : 
    1642                 :            : /* Return a wide int of 2 with precision PRECISION.  */
    1643                 :            : inline wi::hwi_with_prec
    1644                 :            : wi::two (unsigned int precision)
    1645                 :            : {
    1646                 :            :   return wi::shwi (2, precision);
    1647                 :            : }
    1648                 :            : 
    1649                 :            : namespace wi
    1650                 :            : {
    1651                 :            :   /* ints_for<T>::zero (X) returns a zero that, when asssigned to a T,
    1652                 :            :      gives that T the same precision as X.  */
    1653                 :            :   template<typename T, precision_type = int_traits<T>::precision_type>
    1654                 :            :   struct ints_for
    1655                 :            :   {
    1656                 :            :     static int zero (const T &) { return 0; }
    1657                 :            :   };
    1658                 :            : 
    1659                 :            :   template<typename T>
    1660                 :            :   struct ints_for<T, VAR_PRECISION>
    1661                 :            :   {
    1662                 :            :     static hwi_with_prec zero (const T &);
    1663                 :            :   };
    1664                 :            : }
    1665                 :            : 
    1666                 :            : template<typename T>
    1667                 :            : inline wi::hwi_with_prec
    1668                 :            : wi::ints_for<T, wi::VAR_PRECISION>::zero (const T &x)
    1669                 :            : {
    1670                 :            :   return wi::zero (wi::get_precision (x));
    1671                 :            : }
    1672                 :            : 
    1673                 :            : namespace wi
    1674                 :            : {
    1675                 :            :   template <>
    1676                 :            :   struct int_traits <wi::hwi_with_prec>
    1677                 :            :   {
    1678                 :            :     static const enum precision_type precision_type = VAR_PRECISION;
    1679                 :            :     /* hwi_with_prec has an explicitly-given precision, rather than the
    1680                 :            :        precision of HOST_WIDE_INT.  */
    1681                 :            :     static const bool host_dependent_precision = false;
    1682                 :            :     static const bool is_sign_extended = true;
    1683                 :            :     static unsigned int get_precision (const wi::hwi_with_prec &);
    1684                 :            :     static wi::storage_ref decompose (HOST_WIDE_INT *, unsigned int,
    1685                 :            :                                       const wi::hwi_with_prec &);
    1686                 :            :   };
    1687                 :            : }
    1688                 :            : 
    1689                 :            : inline unsigned int
    1690                 : 2892992984 : wi::int_traits <wi::hwi_with_prec>::get_precision (const wi::hwi_with_prec &x)
    1691                 :            : {
    1692                 : 2892992984 :   return x.precision;
    1693                 :            : }
    1694                 :            : 
    1695                 :            : inline wi::storage_ref
    1696                 : 2898778888 : wi::int_traits <wi::hwi_with_prec>::
    1697                 :            : decompose (HOST_WIDE_INT *scratch, unsigned int precision,
    1698                 :            :            const wi::hwi_with_prec &x)
    1699                 :            : {
    1700                 : 2898778888 :   gcc_checking_assert (precision == x.precision);
    1701                 : 2898778888 :   scratch[0] = x.val;
    1702                 : 2898778888 :   if (x.sgn == SIGNED || x.val >= 0 || precision <= HOST_BITS_PER_WIDE_INT)
    1703                 : 2898751757 :     return wi::storage_ref (scratch, 1, precision);
    1704                 :      27131 :   scratch[1] = 0;
    1705                 :      27131 :   return wi::storage_ref (scratch, 2, precision);
    1706                 :            : }
    1707                 :            : 
    1708                 :            : /* Private functions for handling large cases out of line.  They take
    1709                 :            :    individual length and array parameters because that is cheaper for
    1710                 :            :    the inline caller than constructing an object on the stack and
    1711                 :            :    passing a reference to it.  (Although many callers use wide_int_refs,
    1712                 :            :    we generally want those to be removed by SRA.)  */
    1713                 :            : namespace wi
    1714                 :            : {
    1715                 :            :   bool eq_p_large (const HOST_WIDE_INT *, unsigned int,
    1716                 :            :                    const HOST_WIDE_INT *, unsigned int, unsigned int);
    1717                 :            :   bool lts_p_large (const HOST_WIDE_INT *, unsigned int, unsigned int,
    1718                 :            :                     const HOST_WIDE_INT *, unsigned int);
    1719                 :            :   bool ltu_p_large (const HOST_WIDE_INT *, unsigned int, unsigned int,
    1720                 :            :                     const HOST_WIDE_INT *, unsigned int);
    1721                 :            :   int cmps_large (const HOST_WIDE_INT *, unsigned int, unsigned int,
    1722                 :            :                   const HOST_WIDE_INT *, unsigned int);
    1723                 :            :   int cmpu_large (const HOST_WIDE_INT *, unsigned int, unsigned int,
    1724                 :            :                   const HOST_WIDE_INT *, unsigned int);
    1725                 :            :   unsigned int sext_large (HOST_WIDE_INT *, const HOST_WIDE_INT *,
    1726                 :            :                            unsigned int,
    1727                 :            :                            unsigned int, unsigned int);
    1728                 :            :   unsigned int zext_large (HOST_WIDE_INT *, const HOST_WIDE_INT *,
    1729                 :            :                            unsigned int,
    1730                 :            :                            unsigned int, unsigned int);
    1731                 :            :   unsigned int set_bit_large (HOST_WIDE_INT *, const HOST_WIDE_INT *,
    1732                 :            :                               unsigned int, unsigned int, unsigned int);
    1733                 :            :   unsigned int lshift_large (HOST_WIDE_INT *, const HOST_WIDE_INT *,
    1734                 :            :                              unsigned int, unsigned int, unsigned int);
    1735                 :            :   unsigned int lrshift_large (HOST_WIDE_INT *, const HOST_WIDE_INT *,
    1736                 :            :                               unsigned int, unsigned int, unsigned int,
    1737                 :            :                               unsigned int);
    1738                 :            :   unsigned int arshift_large (HOST_WIDE_INT *, const HOST_WIDE_INT *,
    1739                 :            :                               unsigned int, unsigned int, unsigned int,
    1740                 :            :                               unsigned int);
    1741                 :            :   unsigned int and_large (HOST_WIDE_INT *, const HOST_WIDE_INT *, unsigned int,
    1742                 :            :                           const HOST_WIDE_INT *, unsigned int, unsigned int);
    1743                 :            :   unsigned int and_not_large (HOST_WIDE_INT *, const HOST_WIDE_INT *,
    1744                 :            :                               unsigned int, const HOST_WIDE_INT *,
    1745                 :            :                               unsigned int, unsigned int);
    1746                 :            :   unsigned int or_large (HOST_WIDE_INT *, const HOST_WIDE_INT *, unsigned int,
    1747                 :            :                          const HOST_WIDE_INT *, unsigned int, unsigned int);
    1748                 :            :   unsigned int or_not_large (HOST_WIDE_INT *, const HOST_WIDE_INT *,
    1749                 :            :                              unsigned int, const HOST_WIDE_INT *,
    1750                 :            :                              unsigned int, unsigned int);
    1751                 :            :   unsigned int xor_large (HOST_WIDE_INT *, const HOST_WIDE_INT *, unsigned int,
    1752                 :            :                           const HOST_WIDE_INT *, unsigned int, unsigned int);
    1753                 :            :   unsigned int add_large (HOST_WIDE_INT *, const HOST_WIDE_INT *, unsigned int,
    1754                 :            :                           const HOST_WIDE_INT *, unsigned int, unsigned int,
    1755                 :            :                           signop, overflow_type *);
    1756                 :            :   unsigned int sub_large (HOST_WIDE_INT *, const HOST_WIDE_INT *, unsigned int,
    1757                 :            :                           const HOST_WIDE_INT *, unsigned int, unsigned int,
    1758                 :            :                           signop, overflow_type *);
    1759                 :            :   unsigned int mul_internal (HOST_WIDE_INT *, const HOST_WIDE_INT *,
    1760                 :            :                              unsigned int, const HOST_WIDE_INT *,
    1761                 :            :                              unsigned int, unsigned int, signop,
    1762                 :            :                              overflow_type *, bool);
    1763                 :            :   unsigned int divmod_internal (HOST_WIDE_INT *, unsigned int *,
    1764                 :            :                                 HOST_WIDE_INT *, const HOST_WIDE_INT *,
    1765                 :            :                                 unsigned int, unsigned int,
    1766                 :            :                                 const HOST_WIDE_INT *,
    1767                 :            :                                 unsigned int, unsigned int,
    1768                 :            :                                 signop, overflow_type *);
    1769                 :            : }
    1770                 :            : 
    1771                 :            : /* Return the number of bits that integer X can hold.  */
    1772                 :            : template <typename T>
    1773                 :            : inline unsigned int
    1774                 :28941187336 : wi::get_precision (const T &x)
    1775                 :            : {
    1776                 : 8167624958 :   return wi::int_traits <T>::get_precision (x);
    1777                 :            : }
    1778                 :            : 
    1779                 :            : /* Return the number of bits that the result of a binary operation can
    1780                 :            :    hold when the input operands are X and Y.  */
    1781                 :            : template <typename T1, typename T2>
    1782                 :            : inline unsigned int
    1783                 :15180665914 : wi::get_binary_precision (const T1 &x, const T2 &y)
    1784                 :            : {
    1785                 : 9150556784 :   return get_precision (wi::int_traits <WI_BINARY_RESULT (T1, T2)>::
    1786                 :15180920282 :                         get_binary_result (x, y));
    1787                 :            : }
    1788                 :            : 
    1789                 :            : /* Copy the contents of Y to X, but keeping X's current precision.  */
    1790                 :            : template <typename T1, typename T2>
    1791                 :            : inline void
    1792                 : 8717987637 : wi::copy (T1 &x, const T2 &y)
    1793                 :            : {
    1794                 : 8759616637 :   HOST_WIDE_INT *xval = x.write_val ();
    1795                 : 8759616637 :   const HOST_WIDE_INT *yval = y.get_val ();
    1796                 : 8759616637 :   unsigned int len = y.get_len ();
    1797                 : 4228868211 :   unsigned int i = 0;
    1798                 :            :   do
    1799                 : 6616177137 :     xval[i] = yval[i];
    1800                 : 4297600408 :   while (++i < len);
    1801                 : 5736948494 :   x.set_len (len, y.is_sign_extended);
    1802                 :  645341732 : }
    1803                 :            : 
    1804                 :            : /* Return true if X fits in a HOST_WIDE_INT with no loss of precision.  */
    1805                 :            : template <typename T>
    1806                 :            : inline bool
    1807                 :12568660716 : wi::fits_shwi_p (const T &x)
    1808                 :            : {
    1809                 :10628880847 :   WIDE_INT_REF_FOR (T) xi (x);
    1810                 :  939005000 :   return xi.len == 1;
    1811                 :            : }
    1812                 :            : 
    1813                 :            : /* Return true if X fits in an unsigned HOST_WIDE_INT with no loss of
    1814                 :            :    precision.  */
    1815                 :            : template <typename T>
    1816                 :            : inline bool
    1817                 : 2800356744 : wi::fits_uhwi_p (const T &x)
    1818                 :            : {
    1819                 : 2800356744 :   WIDE_INT_REF_FOR (T) xi (x);
    1820                 : 2740621656 :   if (xi.precision <= HOST_BITS_PER_WIDE_INT)
    1821                 :            :     return true;
    1822                 : 2706285088 :   if (xi.len == 1)
    1823                 : 2701125599 :     return xi.slow () >= 0;
    1824                 :    5152497 :   return xi.len == 2 && xi.uhigh () == 0;
    1825                 :            : }
    1826                 :            : 
    1827                 :            : /* Return true if X is negative based on the interpretation of SGN.
    1828                 :            :    For UNSIGNED, this is always false.  */
    1829                 :            : template <typename T>
    1830                 :            : inline bool
    1831                 : 2844587233 : wi::neg_p (const T &x, signop sgn)
    1832                 :            : {
    1833                 : 2844594103 :   WIDE_INT_REF_FOR (T) xi (x);
    1834                 :   88370676 :   if (sgn == UNSIGNED)
    1835                 :            :     return false;
    1836                 : 2688873041 :   return xi.sign_mask () < 0;
    1837                 :            : }
    1838                 :            : 
    1839                 :            : /* Return -1 if the top bit of X is set and 0 if the top bit is clear.  */
    1840                 :            : template <typename T>
    1841                 :            : inline HOST_WIDE_INT
    1842                 :      17727 : wi::sign_mask (const T &x)
    1843                 :            : {
    1844                 :      17727 :   WIDE_INT_REF_FOR (T) xi (x);
    1845                 :      17727 :   return xi.sign_mask ();
    1846                 :            : }
    1847                 :            : 
    1848                 :            : /* Return true if X == Y.  X and Y must be binary-compatible.  */
    1849                 :            : template <typename T1, typename T2>
    1850                 :            : inline bool
    1851                 : 9627409589 : wi::eq_p (const T1 &x, const T2 &y)
    1852                 :            : {
    1853                 : 9625411362 :   unsigned int precision = get_binary_precision (x, y);
    1854                 : 7849937570 :   WIDE_INT_REF_FOR (T1) xi (x, precision);
    1855                 : 9627409589 :   WIDE_INT_REF_FOR (T2) yi (y, precision);
    1856                 :            :   if (xi.is_sign_extended && yi.is_sign_extended)
    1857                 :            :     {
    1858                 :            :       /* This case reduces to array equality.  */
    1859                 : 1830517890 :       if (xi.len != yi.len)
    1860                 :            :         return false;
    1861                 :            :       unsigned int i = 0;
    1862                 :            :       do
    1863                 : 4289156783 :         if (xi.val[i] != yi.val[i])
    1864                 :  211057434 :           return false;
    1865                 :  748629934 :       while (++i != xi.len);
    1866                 :            :       return true;
    1867                 :            :     }
    1868                 : 1421791684 :   if (__builtin_expect (yi.len == 1, true))
    1869                 :            :     {
    1870                 :            :       /* XI is only equal to YI if it too has a single HWI.  */
    1871                 : 5227526621 :       if (xi.len != 1)
    1872                 :            :         return false;
    1873                 :            :       /* Excess bits in xi.val[0] will be signs or zeros, so comparisons
    1874                 :            :          with 0 are simple.  */
    1875                 : 5222233156 :       if (STATIC_CONSTANT_P (yi.val[0] == 0))
    1876                 : 3744394484 :         return xi.val[0] == 0;
    1877                 :            :       /* Otherwise flush out any excess bits first.  */
    1878                 : 1477836055 :       unsigned HOST_WIDE_INT diff = xi.val[0] ^ yi.val[0];
    1879                 : 1477836055 :       int excess = HOST_BITS_PER_WIDE_INT - precision;
    1880                 : 1477836055 :       if (excess > 0)
    1881                 :  356513159 :         diff <<= excess;
    1882                 : 1477836055 :       return diff == 0;
    1883                 :            :     }
    1884                 :    3883092 :   return eq_p_large (xi.val, xi.len, yi.val, yi.len, precision);
    1885                 :            : }
    1886                 :            : 
    1887                 :            : /* Return true if X != Y.  X and Y must be binary-compatible.  */
    1888                 :            : template <typename T1, typename T2>
    1889                 :            : inline bool
    1890                 : 1315399238 : wi::ne_p (const T1 &x, const T2 &y)
    1891                 :            : {
    1892                 : 6128484404 :   return !eq_p (x, y);
    1893                 :            : }
    1894                 :            : 
    1895                 :            : /* Return true if X < Y when both are treated as signed values.  */
    1896                 :            : template <typename T1, typename T2>
    1897                 :            : inline bool
    1898                 : 1889779411 : wi::lts_p (const T1 &x, const T2 &y)
    1899                 :            : {
    1900                 : 1889779411 :   unsigned int precision = get_binary_precision (x, y);
    1901                 : 1889779411 :   WIDE_INT_REF_FOR (T1) xi (x, precision);
    1902                 : 1889779411 :   WIDE_INT_REF_FOR (T2) yi (y, precision);
    1903                 :            :   /* We optimize x < y, where y is 64 or fewer bits.  */
    1904                 : 1889779411 :   if (wi::fits_shwi_p (yi))
    1905                 :            :     {
    1906                 :            :       /* Make lts_p (x, 0) as efficient as wi::neg_p (x).  */
    1907                 : 1881338383 :       if (STATIC_CONSTANT_P (yi.val[0] == 0))
    1908                 :  165232388 :         return neg_p (xi);
    1909                 :            :       /* If x fits directly into a shwi, we can compare directly.  */
    1910                 : 1716105989 :       if (wi::fits_shwi_p (xi))
    1911                 : 1621340595 :         return xi.to_shwi () < yi.to_shwi ();
    1912                 :            :       /* If x doesn't fit and is negative, then it must be more
    1913                 :            :          negative than any value in y, and hence smaller than y.  */
    1914                 :   95142024 :       if (neg_p (xi))
    1915                 :            :         return true;
    1916                 :            :       /* If x is positive, then it must be larger than any value in y,
    1917                 :            :          and hence greater than y.  */
    1918                 :   95080281 :       return false;
    1919                 :            :     }
    1920                 :            :   /* Optimize the opposite case, if it can be detected at compile time.  */
    1921                 :    8437182 :   if (STATIC_CONSTANT_P (xi.len == 1))
    1922                 :            :     /* If YI is negative it is lower than the least HWI.
    1923                 :            :        If YI is positive it is greater than the greatest HWI.  */
    1924                 :       2298 :     return !neg_p (yi);
    1925                 :    8437083 :   return lts_p_large (xi.val, xi.len, precision, yi.val, yi.len);
    1926                 :            : }
    1927                 :            : 
    1928                 :            : /* Return true if X < Y when both are treated as unsigned values.  */
    1929                 :            : template <typename T1, typename T2>
    1930                 :            : inline bool
    1931                 : 3026248898 : wi::ltu_p (const T1 &x, const T2 &y)
    1932                 :            : {
    1933                 : 3000986989 :   unsigned int precision = get_binary_precision (x, y);
    1934                 : 3000982857 :   WIDE_INT_REF_FOR (T1) xi (x, precision);
    1935                 : 3026248898 :   WIDE_INT_REF_FOR (T2) yi (y, precision);
    1936                 :            :   /* Optimize comparisons with constants.  */
    1937                 :  244678181 :   if (STATIC_CONSTANT_P (yi.len == 1 && yi.val[0] >= 0))
    1938                 : 2845058469 :     return xi.len == 1 && xi.to_uhwi () < (unsigned HOST_WIDE_INT) yi.val[0];
    1939                 :  233097967 :   if (STATIC_CONSTANT_P (xi.len == 1 && xi.val[0] >= 0))
    1940                 :   75340957 :     return yi.len != 1 || yi.to_uhwi () > (unsigned HOST_WIDE_INT) xi.val[0];
    1941                 :            :   /* Optimize the case of two HWIs.  The HWIs are implicitly sign-extended
    1942                 :            :      for precisions greater than HOST_BITS_WIDE_INT, but sign-extending both
    1943                 :            :      values does not change the result.  */
    1944                 :  137691073 :   if (__builtin_expect (xi.len + yi.len == 2, true))
    1945                 :            :     {
    1946                 :  126445823 :       unsigned HOST_WIDE_INT xl = xi.to_uhwi ();
    1947                 :  126445823 :       unsigned HOST_WIDE_INT yl = yi.to_uhwi ();
    1948                 :  126445823 :       return xl < yl;
    1949                 :            :     }
    1950                 :   11245112 :   return ltu_p_large (xi.val, xi.len, precision, yi.val, yi.len);
    1951                 :            : }
    1952                 :            : 
    1953                 :            : /* Return true if X < Y.  Signedness of X and Y is indicated by SGN.  */
    1954                 :            : template <typename T1, typename T2>
    1955                 :            : inline bool
    1956                 :    9950953 : wi::lt_p (const T1 &x, const T2 &y, signop sgn)
    1957                 :            : {
    1958                 :    9950078 :   if (sgn == SIGNED)
    1959                 :    4108618 :     return lts_p (x, y);
    1960                 :            :   else
    1961                 :    5842335 :     return ltu_p (x, y);
    1962                 :            : }
    1963                 :            : 
    1964                 :            : /* Return true if X <= Y when both are treated as signed values.  */
    1965                 :            : template <typename T1, typename T2>
    1966                 :            : inline bool
    1967                 :  566206386 : wi::les_p (const T1 &x, const T2 &y)
    1968                 :            : {
    1969                 :  565781996 :   return !lts_p (y, x);
    1970                 :            : }
    1971                 :            : 
    1972                 :            : /* Return true if X <= Y when both are treated as unsigned values.  */
    1973                 :            : template <typename T1, typename T2>
    1974                 :            : inline bool
    1975                 :   17351392 : wi::leu_p (const T1 &x, const T2 &y)
    1976                 :            : {
    1977                 :   17785719 :   return !ltu_p (y, x);
    1978                 :            : }
    1979                 :            : 
    1980                 :            : /* Return true if X <= Y.  Signedness of X and Y is indicated by SGN.  */
    1981                 :            : template <typename T1, typename T2>
    1982                 :            : inline bool
    1983                 :   21561995 : wi::le_p (const T1 &x, const T2 &y, signop sgn)
    1984                 :            : {
    1985                 :   21561995 :   if (sgn == SIGNED)
    1986                 :    5383716 :     return les_p (x, y);
    1987                 :            :   else
    1988                 :   16178281 :     return leu_p (x, y);
    1989                 :            : }
    1990                 :            : 
    1991                 :            : /* Return true if X > Y when both are treated as signed values.  */
    1992                 :            : template <typename T1, typename T2>
    1993                 :            : inline bool
    1994                 :   25956833 : wi::gts_p (const T1 &x, const T2 &y)
    1995                 :            : {
    1996                 :    2500086 :   return lts_p (y, x);
    1997                 :            : }
    1998                 :            : 
    1999                 :            : /* Return true if X > Y when both are treated as unsigned values.  */
    2000                 :            : template <typename T1, typename T2>
    2001                 :            : inline bool
    2002                 :   29418477 : wi::gtu_p (const T1 &x, const T2 &y)
    2003                 :            : {
    2004                 :    9580721 :   return ltu_p (y, x);
    2005                 :            : }
    2006                 :            : 
    2007                 :            : /* Return true if X > Y.  Signedness of X and Y is indicated by SGN.  */
    2008                 :            : template <typename T1, typename T2>
    2009                 :            : inline bool
    2010                 :   37338561 : wi::gt_p (const T1 &x, const T2 &y, signop sgn)
    2011                 :            : {
    2012                 :   37337686 :   if (sgn == SIGNED)
    2013                 :    9824358 :     return gts_p (x, y);
    2014                 :            :   else
    2015                 :   27517481 :     return gtu_p (x, y);
    2016                 :            : }
    2017                 :            : 
    2018                 :            : /* Return true if X >= Y when both are treated as signed values.  */
    2019                 :            : template <typename T1, typename T2>
    2020                 :            : inline bool
    2021                 :    6603758 : wi::ges_p (const T1 &x, const T2 &y)
    2022                 :            : {
    2023                 :    6413838 :   return !lts_p (x, y);
    2024                 :            : }
    2025                 :            : 
    2026                 :            : /* Return true if X >= Y when both are treated as unsigned values.  */
    2027                 :            : template <typename T1, typename T2>
    2028                 :            : inline bool
    2029                 : 2905338274 : wi::geu_p (const T1 &x, const T2 &y)
    2030                 :            : {
    2031                 : 2874790063 :   return !ltu_p (x, y);
    2032                 :            : }
    2033                 :            : 
    2034                 :            : /* Return true if X >= Y.  Signedness of X and Y is indicated by SGN.  */
    2035                 :            : template <typename T1, typename T2>
    2036                 :            : inline bool
    2037                 :   52227738 : wi::ge_p (const T1 &x, const T2 &y, signop sgn)
    2038                 :            : {
    2039                 :   52227738 :   if (sgn == SIGNED)
    2040                 :    6385866 :     return ges_p (x, y);
    2041                 :            :   else
    2042                 :   46356954 :     return geu_p (x, y);
    2043                 :            : }
    2044                 :            : 
    2045                 :            : /* Return -1 if X < Y, 0 if X == Y and 1 if X > Y.  Treat both X and Y
    2046                 :            :    as signed values.  */
    2047                 :            : template <typename T1, typename T2>
    2048                 :            : inline int
    2049                 :  588815200 : wi::cmps (const T1 &x, const T2 &y)
    2050                 :            : {
    2051                 :  588815200 :   unsigned int precision = get_binary_precision (x, y);
    2052                 :  588815200 :   WIDE_INT_REF_FOR (T1) xi (x, precision);
    2053                 :  588815200 :   WIDE_INT_REF_FOR (T2) yi (y, precision);
    2054                 :  588815200 :   if (wi::fits_shwi_p (yi))
    2055                 :            :     {
    2056                 :            :       /* Special case for comparisons with 0.  */
    2057                 :  451798108 :       if (STATIC_CONSTANT_P (yi.val[0] == 0))
    2058                 :          0 :         return neg_p (xi) ? -1 : !(xi.len == 1 && xi.val[0] == 0);
    2059                 :            :       /* If x fits into a signed HWI, we can compare directly.  */
    2060                 :  451798108 :       if (wi::fits_shwi_p (xi))
    2061                 :            :         {
    2062                 :  450990118 :           HOST_WIDE_INT xl = xi.to_shwi ();
    2063                 :  450990118 :           HOST_WIDE_INT yl = yi.to_shwi ();
    2064                 :  450990118 :           return xl < yl ? -1 : xl > yl;
    2065                 :            :         }
    2066                 :            :       /* If x doesn't fit and is negative, then it must be more
    2067                 :            :          negative than any signed HWI, and hence smaller than y.  */
    2068                 :     807819 :       if (neg_p (xi))
    2069                 :            :         return -1;
    2070                 :            :       /* If x is positive, then it must be larger than any signed HWI,
    2071                 :            :          and hence greater than y.  */
    2072                 :     781825 :       return 1;
    2073                 :            :     }
    2074                 :            :   /* Optimize the opposite case, if it can be detected at compile time.  */
    2075                 :  137018116 :   if (STATIC_CONSTANT_P (xi.len == 1))
    2076                 :            :     /* If YI is negative it is lower than the least HWI.
    2077                 :            :        If YI is positive it is greater than the greatest HWI.  */
    2078                 :          7 :     return neg_p (yi) ? 1 : -1;
    2079                 :  137018116 :   return cmps_large (xi.val, xi.len, precision, yi.val, yi.len);
    2080                 :            : }
    2081                 :            : 
    2082                 :            : /* Return -1 if X < Y, 0 if X == Y and 1 if X > Y.  Treat both X and Y
    2083                 :            :    as unsigned values.  */
    2084                 :            : template <typename T1, typename T2>
    2085                 :            : inline int
    2086                 :   48365692 : wi::cmpu (const T1 &x, const T2 &y)
    2087                 :            : {
    2088                 :   48365692 :   unsigned int precision = get_binary_precision (x, y);
    2089                 :   48365692 :   WIDE_INT_REF_FOR (T1) xi (x, precision);
    2090                 :   48365692 :   WIDE_INT_REF_FOR (T2) yi (y, precision);
    2091                 :            :   /* Optimize comparisons with constants.  */
    2092                 :   57807331 :   if (STATIC_CONSTANT_P (yi.len == 1 && yi.val[0] >= 0))
    2093                 :            :     {
    2094                 :            :       /* If XI doesn't fit in a HWI then it must be larger than YI.  */
    2095                 :          6 :       if (xi.len != 1)
    2096                 :            :         return 1;
    2097                 :            :       /* Otherwise compare directly.  */
    2098                 :          6 :       unsigned HOST_WIDE_INT xl = xi.to_uhwi ();
    2099                 :          6 :       unsigned HOST_WIDE_INT yl = yi.val[0];
    2100                 :          6 :       return xl < yl ? -1 : xl > yl;
    2101                 :            :     }
    2102                 :   60779792 :   if (STATIC_CONSTANT_P (xi.len == 1 && xi.val[0] >= 0))
    2103                 :            :     {
    2104                 :            :       /* If YI doesn't fit in a HWI then it must be larger than XI.  */
    2105                 :   19544902 :       if (yi.len != 1)
    2106                 :            :         return -1;
    2107                 :            :       /* Otherwise compare directly.  */
    2108                 :   19011272 :       unsigned HOST_WIDE_INT xl = xi.val[0];
    2109                 :   19011272 :       unsigned HOST_WIDE_INT yl = yi.to_uhwi ();
    2110                 :   19011272 :       return xl < yl ? -1 : xl > yl;
    2111                 :            :     }
    2112                 :            :   /* Optimize the case of two HWIs.  The HWIs are implicitly sign-extended
    2113                 :            :      for precisions greater than HOST_BITS_WIDE_INT, but sign-extending both
    2114                 :            :      values does not change the result.  */
    2115                 :   28820778 :   if (__builtin_expect (xi.len + yi.len == 2, true))
    2116                 :            :     {
    2117                 :   28187644 :       unsigned HOST_WIDE_INT xl = xi.to_uhwi ();
    2118                 :   28187644 :       unsigned HOST_WIDE_INT yl = yi.to_uhwi ();
    2119                 :   28187644 :       return xl < yl ? -1 : xl > yl;
    2120                 :            :     }
    2121                 :     633141 :   return cmpu_large (xi.val, xi.len, precision, yi.val, yi.len);
    2122                 :            : }
    2123                 :            : 
    2124                 :            : /* Return -1 if X < Y, 0 if X == Y and 1 if X > Y.  Signedness of
    2125                 :            :    X and Y indicated by SGN.  */
    2126                 :            : template <typename T1, typename T2>
    2127                 :            : inline int
    2128                 :   61196200 : wi::cmp (const T1 &x, const T2 &y, signop sgn)
    2129                 :            : {
    2130                 :   61196200 :   if (sgn == SIGNED)
    2131                 :   15590721 :     return cmps (x, y);
    2132                 :            :   else
    2133                 :   45605548 :     return cmpu (x, y);
    2134                 :            : }
    2135                 :            : 
    2136                 :            : /* Return ~x.  */
    2137                 :            : template <typename T>
    2138                 :            : inline WI_UNARY_RESULT (T)
    2139                 :    7297304 : wi::bit_not (const T &x)
    2140                 :            : {
    2141                 :    7297304 :   WI_UNARY_RESULT_VAR (result, val, T, x);
    2142                 :    7297304 :   WIDE_INT_REF_FOR (T) xi (x, get_precision (result));
    2143                 :   14601651 :   for (unsigned int i = 0; i < xi.len; ++i)
    2144                 :    7304343 :     val[i] = ~xi.val[i];
    2145                 :    7297304 :   result.set_len (xi.len);
    2146                 :    5818903 :   return result;
    2147                 :            : }
    2148                 :            : 
    2149                 :            : /* Return -x.  */
    2150                 :            : template <typename T>
    2151                 :            : inline WI_UNARY_RESULT (T)
    2152                 :   18711240 : wi::neg (const T &x)
    2153                 :            : {
    2154                 :    4551043 :   return sub (0, x);
    2155                 :            : }
    2156                 :            : 
    2157                 :            : /* Return -x.  Indicate in *OVERFLOW if performing the negation would
    2158                 :            :    cause an overflow.  */
    2159                 :            : template <typename T>
    2160                 :            : inline WI_UNARY_RESULT (T)
    2161                 :   11934315 : wi::neg (const T &x, overflow_type *overflow)
    2162                 :            : {
    2163                 :   11934315 :   *overflow = only_sign_bit_p (x) ? OVF_OVERFLOW : OVF_NONE;
    2164                 :   11934315 :   return sub (0, x);
    2165                 :            : }
    2166                 :            : 
    2167                 :            : /* Return the absolute value of x.  */
    2168                 :            : template <typename T>
    2169                 :            : inline WI_UNARY_RESULT (T)
    2170                 :   15532580 : wi::abs (const T &x)
    2171                 :            : {
    2172                 :   15532580 :   return neg_p (x) ? neg (x) : WI_UNARY_RESULT (T) (x);
    2173                 :            : }
    2174                 :            : 
    2175                 :            : /* Return the result of sign-extending the low OFFSET bits of X.  */
    2176                 :            : template <typename T>
    2177                 :            : inline WI_UNARY_RESULT (T)
    2178                 : 1114032630 : wi::sext (const T &x, unsigned int offset)
    2179                 :            : {
    2180                 : 1114032630 :   WI_UNARY_RESULT_VAR (result, val, T, x);
    2181                 : 1114032630 :   unsigned int precision = get_precision (result);
    2182                 : 1114032630 :   WIDE_INT_REF_FOR (T) xi (x, precision);
    2183                 :            : 
    2184                 : 1114032630 :   if (offset <= HOST_BITS_PER_WIDE_INT)
    2185                 :            :     {
    2186                 : 1509867738 :       val[0] = sext_hwi (xi.ulow (), offset);
    2187                 : 1114032630 :       result.set_len (1, true);
    2188                 :            :     }
    2189                 :            :   else
    2190                 :    1713526 :     result.set_len (sext_large (val, xi.val, xi.len, precision, offset));
    2191                 : 1114032630 :   return result;
    2192                 :            : }
    2193                 :            : 
    2194                 :            : /* Return the result of zero-extending the low OFFSET bits of X.  */
    2195                 :            : template <typename T>
    2196                 :            : inline WI_UNARY_RESULT (T)
    2197                 :  816683405 : wi::zext (const T &x, unsigned int offset)
    2198                 :            : {
    2199                 :  816683405 :   WI_UNARY_RESULT_VAR (result, val, T, x);
    2200                 :  816683405 :   unsigned int precision = get_precision (result);
    2201                 :  816683405 :   WIDE_INT_REF_FOR (T) xi (x, precision);
    2202                 :            : 
    2203                 :            :   /* This is not just an optimization, it is actually required to
    2204                 :            :      maintain canonization.  */
    2205                 :  816683405 :   if (offset >= precision)
    2206                 :            :     {
    2207                 :  519571390 :       wi::copy (result, xi);
    2208                 :  413879000 :       return result;
    2209                 :            :     }
    2210                 :            : 
    2211                 :            :   /* In these cases we know that at least the top bit will be clear,
    2212                 :            :      so no sign extension is necessary.  */
    2213                 :  389668561 :   if (offset < HOST_BITS_PER_WIDE_INT)
    2214                 :            :     {
    2215                 :  106242766 :       val[0] = zext_hwi (xi.ulow (), offset);
    2216                 :  816683405 :       result.set_len (1, true);
    2217                 :            :     }
    2218                 :            :   else
    2219                 :  321047536 :     result.set_len (zext_large (val, xi.val, xi.len, precision, offset), true);
    2220                 :            :   return result;
    2221                 :            : }
    2222                 :            : 
    2223                 :            : /* Return the result of extending the low OFFSET bits of X according to
    2224                 :            :    signedness SGN.  */
    2225                 :            : template <typename T>
    2226                 :            : inline WI_UNARY_RESULT (T)
    2227                 :  176176716 : wi::ext (const T &x, unsigned int offset, signop sgn)
    2228                 :            : {
    2229                 :  176176716 :   return sgn == SIGNED ? sext (x, offset) : zext (x, offset);
    2230                 :            : }
    2231                 :            : 
    2232                 :            : /* Return an integer that represents X | (1 << bit).  */
    2233                 :            : template <typename T>
    2234                 :            : inline WI_UNARY_RESULT (T)
    2235                 :         37 : wi::set_bit (const T &x, unsigned int bit)
    2236                 :            : {
    2237                 :         37 :   WI_UNARY_RESULT_VAR (result, val, T, x);
    2238                 :         37 :   unsigned int precision = get_precision (result);
    2239                 :         37 :   WIDE_INT_REF_FOR (T) xi (x, precision);
    2240                 :         37 :   if (precision <= HOST_BITS_PER_WIDE_INT)
    2241                 :            :     {
    2242                 :         35 :       val[0] = xi.ulow () | (HOST_WIDE_INT_1U << bit);
    2243                 :         37 :       result.set_len (1);
    2244                 :            :     }
    2245                 :            :   else
    2246                 :          2 :     result.set_len (set_bit_large (val, xi.val, xi.len, precision, bit));
    2247                 :         37 :   return result;
    2248                 :            : }
    2249                 :            : 
    2250                 :            : /* Return the mininum of X and Y, treating them both as having
    2251                 :            :    signedness SGN.  */
    2252                 :            : template <typename T1, typename T2>
    2253                 :            : inline WI_BINARY_RESULT (T1, T2)
    2254                 :    7673543 : wi::min (const T1 &x, const T2 &y, signop sgn)
    2255                 :            : {
    2256                 :    7673543 :   WI_BINARY_RESULT_VAR (result, val ATTRIBUTE_UNUSED, T1, x, T2, y);
    2257                 :    7673543 :   unsigned int precision = get_precision (result);
    2258                 :    7673543 :   if (wi::le_p (x, y, sgn))
    2259                 :   14361930 :     wi::copy (result, WIDE_INT_REF_FOR (T1) (x, precision));
    2260                 :            :   else
    2261                 :     984567 :     wi::copy (result, WIDE_INT_REF_FOR (T2) (y, precision));
    2262                 :    7673543 :   return result;
    2263                 :            : }
    2264                 :            : 
    2265                 :            : /* Return the minimum of X and Y, treating both as signed values.  */
    2266                 :            : template <typename T1, typename T2>
    2267                 :            : inline WI_BINARY_RESULT (T1, T2)
    2268                 :     387433 : wi::smin (const T1 &x, const T2 &y)
    2269                 :            : {
    2270                 :     387433 :   return wi::min (x, y, SIGNED);
    2271                 :            : }
    2272                 :            : 
    2273                 :            : /* Return the minimum of X and Y, treating both as unsigned values.  */
    2274                 :            : template <typename T1, typename T2>
    2275                 :            : inline WI_BINARY_RESULT (T1, T2)
    2276                 :      15529 : wi::umin (const T1 &x, const T2 &y)
    2277                 :            : {
    2278                 :      15529 :   return wi::min (x, y, UNSIGNED);
    2279                 :            : }
    2280                 :            : 
    2281                 :            : /* Return the maxinum of X and Y, treating them both as having
    2282                 :            :    signedness SGN.  */
    2283                 :            : template <typename T1, typename T2>
    2284                 :            : inline WI_BINARY_RESULT (T1, T2)
    2285                 :   29717725 : wi::max (const T1 &x, const T2 &y, signop sgn)
    2286                 :            : {
    2287                 :   29717725 :   WI_BINARY_RESULT_VAR (result, val ATTRIBUTE_UNUSED, T1, x, T2, y);
    2288                 :   29717725 :   unsigned int precision = get_precision (result);
    2289                 :   29717725 :   if (wi::ge_p (x, y, sgn))
    2290                 :   29306855 :     wi::copy (result, WIDE_INT_REF_FOR (T1) (x, precision));
    2291                 :            :   else
    2292                 :   30127990 :     wi::copy (result, WIDE_INT_REF_FOR (T2) (y, precision));
    2293                 :   29717725 :   return result;
    2294                 :            : }
    2295                 :            : 
    2296                 :            : /* Return the maximum of X and Y, treating both as signed values.  */
    2297                 :            : template <typename T1, typename T2>
    2298                 :            : inline WI_BINARY_RESULT (T1, T2)
    2299                 :     708274 : wi::smax (const T1 &x, const T2 &y)
    2300                 :            : {
    2301                 :     697576 :   return wi::max (x, y, SIGNED);
    2302                 :            : }
    2303                 :            : 
    2304                 :            : /* Return the maximum of X and Y, treating both as unsigned values.  */
    2305                 :            : template <typename T1, typename T2>
    2306                 :            : inline WI_BINARY_RESULT (T1, T2)
    2307                 :     223782 : wi::umax (const T1 &x, const T2 &y)
    2308                 :            : {
    2309                 :     223782 :   return wi::max (x, y, UNSIGNED);
    2310                 :            : }
    2311                 :            : 
    2312                 :            : /* Return X & Y.  */
    2313                 :            : template <typename T1, typename T2>
    2314                 :            : inline WI_BINARY_RESULT (T1, T2)
    2315                 :  521180008 : wi::bit_and (const T1 &x, const T2 &y)
    2316                 :            : {
    2317                 :  521180008 :   WI_BINARY_RESULT_VAR (result, val, T1, x, T2, y);
    2318                 :  521180008 :   unsigned int precision = get_precision (result);
    2319                 :  521180008 :   WIDE_INT_REF_FOR (T1) xi (x, precision);
    2320                 :  521180008 :   WIDE_INT_REF_FOR (T2) yi (y, precision);
    2321                 :  521180008 :   bool is_sign_extended = xi.is_sign_extended && yi.is_sign_extended;
    2322                 :  521180008 :   if (__builtin_expect (xi.len + yi.len == 2, true))
    2323                 :            :     {
    2324                 :  517811313 :       val[0] = xi.ulow () & yi.ulow ();
    2325                 :  517811313 :       result.set_len (1, is_sign_extended);
    2326                 :            :     }
    2327                 :            :   else
    2328                 :    3368794 :     result.set_len (and_large (val, xi.val, xi.len, yi.val, yi.len,
    2329                 :            :                                precision), is_sign_extended);
    2330                 :  521180008 :   return result;
    2331                 :            : }
    2332                 :            : 
    2333                 :            : /* Return X & ~Y.  */
    2334                 :            : template <typename T1, typename T2>
    2335                 :            : inline WI_BINARY_RESULT (T1, T2)
    2336                 :  426350581 : wi::bit_and_not (const T1 &x, const T2 &y)
    2337                 :            : {
    2338                 :  426350581 :   WI_BINARY_RESULT_VAR (result, val, T1, x, T2, y);
    2339                 :  426350581 :   unsigned int precision = get_precision (result);
    2340                 :  426350581 :   WIDE_INT_REF_FOR (T1) xi (x, precision);
    2341                 :  426350581 :   WIDE_INT_REF_FOR (T2) yi (y, precision);
    2342                 :  426350581 :   bool is_sign_extended = xi.is_sign_extended && yi.is_sign_extended;
    2343                 :  426350581 :   if (__builtin_expect (xi.len + yi.len == 2, true))
    2344                 :            :     {
    2345                 :  395346786 :       val[0] = xi.ulow () & ~yi.ulow ();
    2346                 :  395346786 :       result.set_len (1, is_sign_extended);
    2347                 :            :     }
    2348                 :            :   else
    2349                 :   31004906 :     result.set_len (and_not_large (val, xi.val, xi.len, yi.val, yi.len,
    2350                 :            :                                    precision), is_sign_extended);
    2351                 :  426350581 :   return result;
    2352                 :            : }
    2353                 :            : 
    2354                 :            : /* Return X | Y.  */
    2355                 :            : template <typename T1, typename T2>
    2356                 :            : inline WI_BINARY_RESULT (T1, T2)
    2357                 :  455302514 : wi::bit_or (const T1 &x, const T2 &y)
    2358                 :            : {
    2359                 :  455302514 :   WI_BINARY_RESULT_VAR (result, val, T1, x, T2, y);
    2360                 :  455302514 :   unsigned int precision = get_precision (result);
    2361                 :  455302514 :   WIDE_INT_REF_FOR (T1) xi (x, precision);
    2362                 :  455302514 :   WIDE_INT_REF_FOR (T2) yi (y, precision);
    2363                 :  455302514 :   bool is_sign_extended = xi.is_sign_extended && yi.is_sign_extended;
    2364                 :  455302514 :   if (__builtin_expect (xi.len + yi.len == 2, true))
    2365                 :            :     {
    2366                 :  433549086 :       val[0] = xi.ulow () | yi.ulow ();
    2367                 :  433549086 :       result.set_len (1, is_sign_extended);
    2368                 :            :     }
    2369                 :            :   else
    2370                 :   21753356 :     result.set_len (or_large (val, xi.val, xi.len,
    2371                 :            :                               yi.val, yi.len, precision), is_sign_extended);
    2372                 :  455302514 :   return result;
    2373                 :            : }
    2374                 :            : 
    2375                 :            : /* Return X | ~Y.  */
    2376                 :            : template <typename T1, typename T2>
    2377                 :            : inline WI_BINARY_RESULT (T1, T2)
    2378                 :            : wi::bit_or_not (const T1 &x, const T2 &y)
    2379                 :            : {
    2380                 :            :   WI_BINARY_RESULT_VAR (result, val, T1, x, T2, y);
    2381                 :            :   unsigned int precision = get_precision (result);
    2382                 :            :   WIDE_INT_REF_FOR (T1) xi (x, precision);
    2383                 :            :   WIDE_INT_REF_FOR (T2) yi (y, precision);
    2384                 :            :   bool is_sign_extended = xi.is_sign_extended && yi.is_sign_extended;
    2385                 :            :   if (__builtin_expect (xi.len + yi.len == 2, true))
    2386                 :            :     {
    2387                 :            :       val[0] = xi.ulow () | ~yi.ulow ();
    2388                 :            :       result.set_len (1, is_sign_extended);
    2389                 :            :     }
    2390                 :            :   else
    2391                 :            :     result.set_len (or_not_large (val, xi.val, xi.len, yi.val, yi.len,
    2392                 :            :                                   precision), is_sign_extended);
    2393                 :            :   return result;
    2394                 :            : }
    2395                 :            : 
    2396                 :            : /* Return X ^ Y.  */
    2397                 :            : template <typename T1, typename T2>
    2398                 :            : inline WI_BINARY_RESULT (T1, T2)
    2399                 :  163522994 : wi::bit_xor (const T1 &x, const T2 &y)
    2400                 :            : {
    2401                 :  163522994 :   WI_BINARY_RESULT_VAR (result, val, T1, x, T2, y);
    2402                 :  163522994 :   unsigned int precision = get_precision (result);
    2403                 :  163522994 :   WIDE_INT_REF_FOR (T1) xi (x, precision);
    2404                 :  163522994 :   WIDE_INT_REF_FOR (T2) yi (y, precision);
    2405                 :  163522994 :   bool is_sign_extended = xi.is_sign_extended && yi.is_sign_extended;
    2406                 :  163522994 :   if (__builtin_expect (xi.len + yi.len == 2, true))
    2407                 :            :     {
    2408                 :  162166274 :       val[0] = xi.ulow () ^ yi.ulow ();
    2409                 :  162166274 :       result.set_len (1, is_sign_extended);
    2410                 :            :     }
    2411                 :            :   else
    2412                 :    1356734 :     result.set_len (xor_large (val, xi.val, xi.len,
    2413                 :            :                                yi.val, yi.len, precision), is_sign_extended);
    2414                 :  163522994 :   return result;
    2415                 :            : }
    2416                 :            : 
    2417                 :            : /* Return X + Y.  */
    2418                 :            : template <typename T1, typename T2>
    2419                 :            : inline WI_BINARY_RESULT (T1, T2)
    2420                 : 4616297370 : wi::add (const T1 &x, const T2 &y)
    2421                 :            : {
    2422                 : 4616297370 :   WI_BINARY_RESULT_VAR (result, val, T1, x, T2, y);
    2423                 : 4616297370 :   unsigned int precision = get_precision (result);
    2424                 : 4616297370 :   WIDE_INT_REF_FOR (T1) xi (x, precision);
    2425                 : 4616297370 :   WIDE_INT_REF_FOR (T2) yi (y, precision);
    2426                 :  105992659 :   if (precision <= HOST_BITS_PER_WIDE_INT)
    2427                 :            :     {
    2428                 :  105253882 :       val[0] = xi.ulow () + yi.ulow ();
    2429                 : 4616297370 :       result.set_len (1);
    2430                 :            :     }
    2431                 :            :   /* If the precision is known at compile time to be greater than
    2432                 :            :      HOST_BITS_PER_WIDE_INT, we can optimize the single-HWI case
    2433                 :            :      knowing that (a) all bits in those HWIs are significant and
    2434                 :            :      (b) the result has room for at least two HWIs.  This provides
    2435                 :            :      a fast path for things like offset_int and widest_int.
    2436                 :            : 
    2437                 :            :      The STATIC_CONSTANT_P test prevents this path from being
    2438                 :            :      used for wide_ints.  wide_ints with precisions greater than
    2439                 :            :      HOST_BITS_PER_WIDE_INT are relatively rare and there's not much
    2440                 :            :      point handling them inline.  */
    2441                 :            :   else if (STATIC_CONSTANT_P (precision > HOST_BITS_PER_WIDE_INT)
    2442                 : 4511043483 :            && __builtin_expect (xi.len + yi.len == 2, true))
    2443                 :            :     {
    2444                 : 4502901092 :       unsigned HOST_WIDE_INT xl = xi.ulow ();
    2445                 : 4502901092 :       unsigned HOST_WIDE_INT yl = yi.ulow ();
    2446                 : 4502901092 :       unsigned HOST_WIDE_INT resultl = xl + yl;
    2447                 : 4502901092 :       val[0] = resultl;
    2448                 : 4502901092 :       val[1] = (HOST_WIDE_INT) resultl < 0 ? 0 : -1;
    2449                 : 9119198326 :       result.set_len (1 + (((resultl ^ xl) & (resultl ^ yl))
    2450                 : 4502901092 :                            >> (HOST_BITS_PER_WIDE_INT - 1)));
    2451                 :            :     }
    2452                 :            :   else
    2453                 :    8146206 :     result.set_len (add_large (val, xi.val, xi.len,
    2454                 :            :                                yi.val, yi.len, precision,
    2455                 :            :                                UNSIGNED, 0));
    2456                 : 4616297370 :   return result;
    2457                 :            : }
    2458                 :            : 
    2459                 :            : /* Return X + Y.  Treat X and Y as having the signednes given by SGN
    2460                 :            :    and indicate in *OVERFLOW whether the operation overflowed.  */
    2461                 :            : template <typename T1, typename T2>
    2462                 :            : inline WI_BINARY_RESULT (T1, T2)
    2463                 :  139943572 : wi::add (const T1 &x, const T2 &y, signop sgn, overflow_type *overflow)
    2464                 :            : {
    2465                 :  139943572 :   WI_BINARY_RESULT_VAR (result, val, T1, x, T2, y);
    2466                 :  139943572 :   unsigned int precision = get_precision (result);
    2467                 :  139943572 :   WIDE_INT_REF_FOR (T1) xi (x, precision);
    2468                 :  139943572 :   WIDE_INT_REF_FOR (T2) yi (y, precision);
    2469                 :  133513922 :   if (precision <= HOST_BITS_PER_WIDE_INT)
    2470                 :            :     {
    2471                 :  119071719 :       unsigned HOST_WIDE_INT xl = xi.ulow ();
    2472                 :  119071719 :       unsigned HOST_WIDE_INT yl = yi.ulow ();
    2473                 :  119071719 :       unsigned HOST_WIDE_INT resultl = xl + yl;
    2474                 :  119071719 :       if (sgn == SIGNED)
    2475                 :            :         {
    2476                 :   32807715 :           if ((((resultl ^ xl) & (resultl ^ yl))
    2477                 :   32807715 :                >> (precision - 1)) & 1)
    2478                 :            :             {
    2479                 :    4451919 :               if (xl > resultl)
    2480                 :    1345082 :                 *overflow = OVF_UNDERFLOW;
    2481                 :    3106837 :               else if (xl < resultl)
    2482                 :    3106837 :                 *overflow = OVF_OVERFLOW;
    2483                 :            :               else
    2484                 :          0 :                 *overflow = OVF_NONE;
    2485                 :            :             }
    2486                 :            :           else
    2487                 :   28355812 :             *overflow = OVF_NONE;
    2488                 :            :         }
    2489                 :            :       else
    2490                 :   86264004 :         *overflow = ((resultl << (HOST_BITS_PER_WIDE_INT - precision))
    2491                 :   86264004 :                      < (xl << (HOST_BITS_PER_WIDE_INT - precision)))
    2492                 :            :           ? OVF_OVERFLOW : OVF_NONE;
    2493                 :  119071719 :       val[0] = resultl;
    2494                 :  139943572 :       result.set_len (1);
    2495                 :            :     }
    2496                 :            :   else
    2497                 :   20871383 :     result.set_len (add_large (val, xi.val, xi.len,
    2498                 :            :                                yi.val, yi.len, precision,
    2499                 :            :                                sgn, overflow));
    2500                 :  139943572 :   return result;
    2501                 :            : }
    2502                 :            : 
    2503                 :            : /* Return X - Y.  */
    2504                 :            : template <typename T1, typename T2>
    2505                 :            : inline WI_BINARY_RESULT (T1, T2)
    2506                 :  834970816 : wi::sub (const T1 &x, const T2 &y)
    2507                 :            : {
    2508                 :  834970816 :   WI_BINARY_RESULT_VAR (result, val, T1, x, T2, y);
    2509                 :  834970816 :   unsigned int precision = get_precision (result);
    2510                 :  834970816 :   WIDE_INT_REF_FOR (T1) xi (x, precision);
    2511                 :  834970816 :   WIDE_INT_REF_FOR (T2) yi (y, precision);
    2512                 :   81714098 :   if (precision <= HOST_BITS_PER_WIDE_INT)
    2513                 :            :     {
    2514                 :   81167529 :       val[0] = xi.ulow () - yi.ulow ();
    2515                 :  834970816 :       result.set_len (1);
    2516                 :            :     }
    2517                 :            :   /* If the precision is known at compile time to be greater than
    2518                 :            :      HOST_BITS_PER_WIDE_INT, we can optimize the single-HWI case
    2519                 :            :      knowing that (a) all bits in those HWIs are significant and
    2520                 :            :      (b) the result has room for at least two HWIs.  This provides
    2521                 :            :      a fast path for things like offset_int and widest_int.
    2522                 :            : 
    2523                 :            :      The STATIC_CONSTANT_P test prevents this path from being
    2524                 :            :      used for wide_ints.  wide_ints with precisions greater than
    2525                 :            :      HOST_BITS_PER_WIDE_INT are relatively rare and there's not much
    2526                 :            :      point handling them inline.  */
    2527                 :            :   else if (STATIC_CONSTANT_P (precision > HOST_BITS_PER_WIDE_INT)
    2528                 :  753783995 :            && __builtin_expect (xi.len + yi.len == 2, true))
    2529                 :            :     {
    2530                 :  750116070 :       unsigned HOST_WIDE_INT xl = xi.ulow ();
    2531                 :  750116070 :       unsigned HOST_WIDE_INT yl = yi.ulow ();
    2532                 :  750116070 :       unsigned HOST_WIDE_INT resultl = xl - yl;
    2533                 :  750116070 :       val[0] = resultl;
    2534                 :  750116070 :       val[1] = (HOST_WIDE_INT) resultl < 0 ? 0 : -1;
    2535                 : 1585068022 :       result.set_len (1 + (((resultl ^ xl) & (xl ^ yl))
    2536                 :  750116070 :                            >> (HOST_BITS_PER_WIDE_INT - 1)));
    2537                 :            :     }
    2538                 :            :   else
    2539                 :    3706318 :     result.set_len (sub_large (val, xi.val, xi.len,
    2540                 :            :                                yi.val, yi.len, precision,
    2541                 :            :                                UNSIGNED, 0));
    2542                 :  834951636 :   return result;
    2543                 :            : }
    2544                 :            : 
    2545                 :            : /* Return X - Y.  Treat X and Y as having the signednes given by SGN
    2546                 :            :    and indicate in *OVERFLOW whether the operation overflowed.  */
    2547                 :            : template <typename T1, typename T2>
    2548                 :            : inline WI_BINARY_RESULT (T1, T2)
    2549                 :   37563972 : wi::sub (const T1 &x, const T2 &y, signop sgn, overflow_type *overflow)
    2550                 :            : {
    2551                 :   37563972 :   WI_BINARY_RESULT_VAR (result, val, T1, x, T2, y);
    2552                 :   37563972 :   unsigned int precision = get_precision (result);
    2553                 :   37563972 :   WIDE_INT_REF_FOR (T1) xi (x, precision);
    2554                 :   37563972 :   WIDE_INT_REF_FOR (T2) yi (y, precision);
    2555                 :   37558460 :   if (precision <= HOST_BITS_PER_WIDE_INT)
    2556                 :            :     {
    2557                 :   37369223 :       unsigned HOST_WIDE_INT xl = xi.ulow ();
    2558                 :   37369223 :       unsigned HOST_WIDE_INT yl = yi.ulow ();
    2559                 :   37369223 :       unsigned HOST_WIDE_INT resultl = xl - yl;
    2560                 :   37369223 :       if (sgn == SIGNED)
    2561                 :            :         {
    2562                 :   14108055 :           if ((((xl ^ yl) & (resultl ^ xl)) >> (precision - 1)) & 1)
    2563                 :            :             {
    2564                 :    1384787 :               if (xl > yl)
    2565                 :     610135 :                 *overflow = OVF_UNDERFLOW;
    2566                 :     774657 :               else if (xl < yl)
    2567                 :     774657 :                 *overflow = OVF_OVERFLOW;
    2568                 :            :               else
    2569                 :          0 :                 *overflow = OVF_NONE;
    2570                 :            :             }
    2571                 :            :           else
    2572                 :   12723314 :             *overflow = OVF_NONE;
    2573                 :            :         }
    2574                 :            :       else
    2575                 :   23261158 :         *overflow = ((resultl << (HOST_BITS_PER_WIDE_INT - precision))
    2576                 :   23261158 :                      > (xl << (HOST_BITS_PER_WIDE_INT - precision)))
    2577                 :            :           ? OVF_UNDERFLOW : OVF_NONE;
    2578                 :   37369223 :       val[0] = resultl;
    2579                 :   37563972 :       result.set_len (1);
    2580                 :            :     }
    2581                 :            :   else
    2582                 :     194700 :     result.set_len (sub_large (val, xi.val, xi.len,
    2583                 :            :                                yi.val, yi.len, precision,
    2584                 :            :                                sgn, overflow));
    2585                 :   37563972 :   return result;
    2586                 :            : }
    2587                 :            : 
    2588                 :            : /* Return X * Y.  */
    2589                 :            : template <typename T1, typename T2>
    2590                 :            : inline WI_BINARY_RESULT (T1, T2)
    2591                 :  644706110 : wi::mul (const T1 &x, const T2 &y)
    2592                 :            : {
    2593                 :  644706110 :   WI_BINARY_RESULT_VAR (result, val, T1, x, T2, y);
    2594                 :  644706110 :   unsigned int precision = get_precision (result);
    2595                 :  644706110 :   WIDE_INT_REF_FOR (T1) xi (x, precision);
    2596                 :  634275268 :   WIDE_INT_REF_FOR (T2) yi (y, precision);
    2597                 :     418244 :   if (precision <= HOST_BITS_PER_WIDE_INT)
    2598                 :            :     {
    2599                 :     404212 :       val[0] = xi.ulow () * yi.ulow ();
    2600                 :  644706110 :       result.set_len (1);
    2601                 :            :     }
    2602                 :            :   else
    2603                 :  677921928 :     result.set_len (mul_internal (val, xi.val, xi.len, yi.val, yi.len,
    2604                 :            :                                   precision, UNSIGNED, 0, false));
    2605                 :  599761962 :   return result;
    2606                 :            : }
    2607                 :            : 
    2608                 :            : /* Return X * Y.  Treat X and Y as having the signednes given by SGN
    2609                 :            :    and indicate in *OVERFLOW whether the operation overflowed.  */
    2610                 :            : template <typename T1, typename T2>
    2611                 :            : inline WI_BINARY_RESULT (T1, T2)
    2612                 :  133243575 : wi::mul (const T1 &x, const T2 &y, signop sgn, overflow_type *overflow)
    2613                 :            : {
    2614                 :  133243575 :   WI_BINARY_RESULT_VAR (result, val, T1, x, T2, y);
    2615                 :  133243575 :   unsigned int precision = get_precision (result);
    2616                 :  133243575 :   WIDE_INT_REF_FOR (T1) xi (x, precision);
    2617                 :  133243575 :   WIDE_INT_REF_FOR (T2) yi (y, precision);
    2618                 :  133243866 :   result.set_len (mul_internal (val, xi.val, xi.len,
    2619                 :            :                                 yi.val, yi.len, precision,
    2620                 :            :                                 sgn, overflow, false));
    2621                 :  133243284 :   return result;
    2622                 :            : }
    2623                 :            : 
    2624                 :            : /* Return X * Y, treating both X and Y as signed values.  Indicate in
    2625                 :            :    *OVERFLOW whether the operation overflowed.  */
    2626                 :            : template <typename T1, typename T2>
    2627                 :            : inline WI_BINARY_RESULT (T1, T2)
    2628                 :        291 : wi::smul (const T1 &x, const T2 &y, overflow_type *overflow)
    2629                 :            : {
    2630                 :        291 :   return mul (x, y, SIGNED, overflow);
    2631                 :            : }
    2632                 :            : 
    2633                 :            : /* Return X * Y, treating both X and Y as unsigned values.  Indicate in
    2634                 :            :   *OVERFLOW if the result overflows.  */
    2635                 :            : template <typename T1, typename T2>
    2636                 :            : inline WI_BINARY_RESULT (T1, T2)
    2637                 :     455455 : wi::umul (const T1 &x, const T2 &y, overflow_type *overflow)
    2638                 :            : {
    2639                 :     455455 :   return mul (x, y, UNSIGNED, overflow);
    2640                 :            : }
    2641                 :            : 
    2642                 :            : /* Perform a widening multiplication of X and Y, extending the values
    2643                 :            :    according to SGN, and return the high part of the result.  */
    2644                 :            : template <typename T1, typename T2>
    2645                 :            : inline WI_BINARY_RESULT (T1, T2)
    2646                 :       2044 : wi::mul_high (const T1 &x, const T2 &y, signop sgn)
    2647                 :            : {
    2648                 :       2044 :   WI_BINARY_RESULT_VAR (result, val, T1, x, T2, y);
    2649                 :       2044 :   unsigned int precision = get_precision (result);
    2650                 :       2044 :   WIDE_INT_REF_FOR (T1) xi (x, precision);
    2651                 :       2044 :   WIDE_INT_REF_FOR (T2) yi (y, precision);
    2652                 :       2044 :   result.set_len (mul_internal (val, xi.val, xi.len,
    2653                 :            :                                 yi.val, yi.len, precision,
    2654                 :            :                                 sgn, 0, true));
    2655                 :       2044 :   return result;
    2656                 :            : }
    2657                 :            : 
    2658                 :            : /* Return X / Y, rouding towards 0.  Treat X and Y as having the
    2659                 :            :    signedness given by SGN.  Indicate in *OVERFLOW if the result
    2660                 :            :    overflows.  */
    2661                 :            : template <typename T1, typename T2>
    2662                 :            : inline WI_BINARY_RESULT (T1, T2)
    2663                 :   91100713 : wi::div_trunc (const T1 &x, const T2 &y, signop sgn, overflow_type *overflow)
    2664                 :            : {
    2665                 :   91100713 :   WI_BINARY_RESULT_VAR (quotient, quotient_val, T1, x, T2, y);
    2666                 :   91100713 :   unsigned int precision = get_precision (quotient);
    2667                 :   91098710 :   WIDE_INT_REF_FOR (T1) xi (x, precision);
    2668                 :   91100713 :   WIDE_INT_REF_FOR (T2) yi (y);
    2669                 :            : 
    2670                 :   91102675 :   quotient.set_len (divmod_internal (quotient_val, 0, 0, xi.val, xi.len,
    2671                 :            :                                      precision,
    2672                 :            :                                      yi.val, yi.len, yi.precision,
    2673                 :            :                                      sgn, overflow));
    2674                 :   91094745 :   return quotient;
    2675                 :            : }
    2676                 :            : 
    2677                 :            : /* Return X / Y, rouding towards 0.  Treat X and Y as signed values.  */
    2678                 :            : template <typename T1, typename T2>
    2679                 :            : inline WI_BINARY_RESULT (T1, T2)
    2680                 :      36212 : wi::sdiv_trunc (const T1 &x, const T2 &y)
    2681                 :            : {
    2682                 :      36212 :   return div_trunc (x, y, SIGNED);
    2683                 :            : }
    2684                 :            : 
    2685                 :            : /* Return X / Y, rouding towards 0.  Treat X and Y as unsigned values.  */
    2686                 :            : template <typename T1, typename T2>
    2687                 :            : inline WI_BINARY_RESULT (T1, T2)
    2688                 :    3858076 : wi::udiv_trunc (const T1 &x, const T2 &y)
    2689                 :            : {
    2690                 :    3858076 :   return div_trunc (x, y, UNSIGNED);
    2691                 :            : }
    2692                 :            : 
    2693                 :            : /* Return X / Y, rouding towards -inf.  Treat X and Y as having the
    2694                 :            :    signedness given by SGN.  Indicate in *OVERFLOW if the result
    2695                 :            :    overflows.  */
    2696                 :            : template <typename T1, typename T2>
    2697                 :            : inline WI_BINARY_RESULT (T1, T2)
    2698                 :   26499318 : wi::div_floor (const T1 &x, const T2 &y, signop sgn, overflow_type *overflow)
    2699                 :            : {
    2700                 :   26499318 :   WI_BINARY_RESULT_VAR (quotient, quotient_val, T1, x, T2, y);
    2701                 :   26499318 :   WI_BINARY_RESULT_VAR (remainder, remainder_val, T1, x, T2, y);
    2702                 :   26499318 :   unsigned int precision = get_precision (quotient);
    2703                 :   26499318 :   WIDE_INT_REF_FOR (T1) xi (x, precision);
    2704                 :   26499318 :   WIDE_INT_REF_FOR (T2) yi (y);
    2705                 :            : 
    2706                 :            :   unsigned int remainder_len;
    2707                 :   26499318 :   quotient.set_len (divmod_internal (quotient_val,
    2708                 :            :                                      &remainder_len, remainder_val,
    2709                 :            :                                      xi.val, xi.len, precision,
    2710                 :            :                                      yi.val, yi.len, yi.precision, sgn,
    2711                 :            :                                      overflow));
    2712                 :   29641998 :   remainder.set_len (remainder_len);
    2713                 :   26545721 :   if (wi::neg_p (x, sgn) != wi::neg_p (y, sgn) && remainder != 0)
    2714                 :       2231 :     return quotient - 1;
    2715                 :   26497092 :   return quotient;
    2716                 :            : }
    2717                 :            : 
    2718                 :            : /* Return X / Y, rouding towards -inf.  Treat X and Y as signed values.  */
    2719                 :            : template <typename T1, typename T2>
    2720                 :            : inline WI_BINARY_RESULT (T1, T2)
    2721                 :      19180 : wi::sdiv_floor (const T1 &x, const T2 &y)
    2722                 :            : {
    2723                 :      19180 :   return div_floor (x, y, SIGNED);
    2724                 :            : }
    2725                 :            : 
    2726                 :            : /* Return X / Y, rouding towards -inf.  Treat X and Y as unsigned values.  */
    2727                 :            : /* ??? Why do we have both this and udiv_trunc.  Aren't they the same?  */
    2728                 :            : template <typename T1, typename T2>
    2729                 :            : inline WI_BINARY_RESULT (T1, T2)
    2730                 :     531515 : wi::udiv_floor (const T1 &x, const T2 &y)
    2731                 :            : {
    2732                 :     531515 :   return div_floor (x, y, UNSIGNED);
    2733                 :            : }
    2734                 :            : 
    2735                 :            : /* Return X / Y, rouding towards +inf.  Treat X and Y as having the
    2736                 :            :    signedness given by SGN.  Indicate in *OVERFLOW if the result
    2737                 :            :    overflows.  */
    2738                 :            : template <typename T1, typename T2>
    2739                 :            : inline WI_BINARY_RESULT (T1, T2)
    2740                 :   15790236 : wi::div_ceil (const T1 &x, const T2 &y, signop sgn, overflow_type *overflow)
    2741                 :            : {
    2742                 :   15790236 :   WI_BINARY_RESULT_VAR (quotient, quotient_val, T1, x, T2, y);
    2743                 :   15790236 :   WI_BINARY_RESULT_VAR (remainder, remainder_val, T1, x, T2, y);
    2744                 :   15790236 :   unsigned int precision = get_precision (quotient);
    2745                 :   15790236 :   WIDE_INT_REF_FOR (T1) xi (x, precision);
    2746                 :   15790236 :   WIDE_INT_REF_FOR (T2) yi (y);
    2747                 :            : 
    2748                 :            :   unsigned int remainder_len;
    2749                 :   15790236 :   quotient.set_len (divmod_internal (quotient_val,
    2750                 :            :                                      &remainder_len, remainder_val,
    2751                 :            :                                      xi.val, xi.len, precision,
    2752                 :            :                                      yi.val, yi.len, yi.precision, sgn,
    2753                 :            :                                      overflow));
    2754                 :   15916936 :   remainder.set_len (remainder_len);
    2755                 :   15790672 :   if (wi::neg_p (x, sgn) == wi::neg_p (y, sgn) && remainder != 0)
    2756                 :      31742 :     return quotient + 1;
    2757                 :   15758452 :   return quotient;
    2758                 :            : }
    2759                 :            : 
    2760                 :            : /* Return X / Y, rouding towards +inf.  Treat X and Y as unsigned values.  */
    2761                 :            : template <typename T1, typename T2>
    2762                 :            : inline WI_BINARY_RESULT (T1, T2)
    2763                 :          0 : wi::udiv_ceil (const T1 &x, const T2 &y)
    2764                 :            : {
    2765                 :          0 :   return div_ceil (x, y, UNSIGNED);
    2766                 :            : }
    2767                 :            : 
    2768                 :            : /* Return X / Y, rouding towards nearest with ties away from zero.
    2769                 :            :    Treat X and Y as having the signedness given by SGN.  Indicate
    2770                 :            :    in *OVERFLOW if the result overflows.  */
    2771                 :            : template <typename T1, typename T2>
    2772                 :            : inline WI_BINARY_RESULT (T1, T2)
    2773                 :          0 : wi::div_round (const T1 &x, const T2 &y, signop sgn, overflow_type *overflow)
    2774                 :            : {
    2775                 :          0 :   WI_BINARY_RESULT_VAR (quotient, quotient_val, T1, x, T2, y);
    2776                 :          0 :   WI_BINARY_RESULT_VAR (remainder, remainder_val, T1, x, T2, y);
    2777                 :          0 :   unsigned int precision = get_precision (quotient);
    2778                 :          0 :   WIDE_INT_REF_FOR (T1) xi (x, precision);
    2779                 :          0 :   WIDE_INT_REF_FOR (T2) yi (y);
    2780                 :            : 
    2781                 :            :   unsigned int remainder_len;
    2782                 :          0 :   quotient.set_len (divmod_internal (quotient_val,
    2783                 :            :                                      &remainder_len, remainder_val,
    2784                 :            :                                      xi.val, xi.len, precision,
    2785                 :            :                                      yi.val, yi.len, yi.precision, sgn,
    2786                 :            :                                      overflow));
    2787                 :          0 :   remainder.set_len (remainder_len);
    2788                 :            : 
    2789                 :          0 :   if (remainder != 0)
    2790                 :            :     {
    2791                 :          0 :       if (sgn == SIGNED)
    2792                 :            :         {
    2793                 :          0 :           WI_BINARY_RESULT (T1, T2) abs_remainder = wi::abs (remainder);
    2794                 :          0 :           if (wi::geu_p (abs_remainder, wi::sub (wi::abs (y), abs_remainder)))
    2795                 :            :             {
    2796                 :          0 :               if (wi::neg_p (x, sgn) != wi::neg_p (y, sgn))
    2797                 :          0 :                 return quotient - 1;
    2798                 :            :               else
    2799                 :          0 :                 return quotient + 1;
    2800                 :            :             }
    2801                 :            :         }
    2802                 :            :       else
    2803                 :            :         {
    2804                 :          0 :           if (wi::geu_p (remainder, wi::sub (y, remainder)))
    2805                 :          0 :             return quotient + 1;
    2806                 :            :         }
    2807                 :            :     }
    2808                 :          0 :   return quotient;
    2809                 :            : }
    2810                 :            : 
    2811                 :            : /* Return X / Y, rouding towards 0.  Treat X and Y as having the
    2812                 :            :    signedness given by SGN.  Store the remainder in *REMAINDER_PTR.  */
    2813                 :            : template <typename T1, typename T2>
    2814                 :            : inline WI_BINARY_RESULT (T1, T2)
    2815                 :    4905073 : wi::divmod_trunc (const T1 &x, const T2 &y, signop sgn,
    2816                 :            :                   WI_BINARY_RESULT (T1, T2) *remainder_ptr)
    2817                 :            : {
    2818                 :    4905073 :   WI_BINARY_RESULT_VAR (quotient, quotient_val, T1, x, T2, y);
    2819                 :    4905073 :   WI_BINARY_RESULT_VAR (remainder, remainder_val, T1, x, T2, y);
    2820                 :    4905073 :   unsigned int precision = get_precision (quotient);
    2821                 :    4905073 :   WIDE_INT_REF_FOR (T1) xi (x, precision);
    2822                 :    4905073 :   WIDE_INT_REF_FOR (T2) yi (y);
    2823                 :            : 
    2824                 :            :   unsigned int remainder_len;
    2825                 :    4905073 :   quotient.set_len (divmod_internal (quotient_val,
    2826                 :            :                                      &remainder_len, remainder_val,
    2827                 :            :                                      xi.val, xi.len, precision,
    2828                 :            :                                      yi.val, yi.len, yi.precision, sgn, 0));
    2829                 :    4905073 :   remainder.set_len (remainder_len);
    2830                 :            : 
    2831                 :    4905073 :   *remainder_ptr = remainder;
    2832                 :    4905073 :   return quotient;
    2833                 :            : }
    2834                 :            : 
    2835                 :            : /* Compute the greatest common divisor of two numbers A and B using
    2836                 :            :    Euclid's algorithm.  */
    2837                 :            : template <typename T1, typename T2>
    2838                 :            : inline WI_BINARY_RESULT (T1, T2)
    2839                 :        875 : wi::gcd (const T1 &a, const T2 &b, signop sgn)
    2840                 :            : {
    2841                 :        875 :   T1 x, y, z;
    2842                 :            : 
    2843                 :        875 :   x = wi::abs (a);
    2844                 :        875 :   y = wi::abs (b);
    2845                 :            : 
    2846                 :       3348 :   while (gt_p (x, 0, sgn))
    2847                 :            :     {
    2848                 :       2473 :       z = mod_trunc (y, x, sgn);
    2849                 :       2473 :       y = x;
    2850                 :       2473 :       x = z;
    2851                 :            :     }
    2852                 :            : 
    2853                 :        875 :   return y;
    2854                 :            : }
    2855                 :            : 
    2856                 :            : /* Compute X / Y, rouding towards 0, and return the remainder.
    2857                 :            :    Treat X and Y as having the signedness given by SGN.  Indicate
    2858                 :            :    in *OVERFLOW if the division overflows.  */
    2859                 :            : template <typename T1, typename T2>
    2860                 :            : inline WI_BINARY_RESULT (T1, T2)
    2861                 :    4855267 : wi::mod_trunc (const T1 &x, const T2 &y, signop sgn, overflow_type *overflow)
    2862                 :            : {
    2863                 :    4855267 :   WI_BINARY_RESULT_VAR (remainder, remainder_val, T1, x, T2, y);
    2864                 :    4855267 :   unsigned int precision = get_precision (remainder);
    2865                 :    4855267 :   WIDE_INT_REF_FOR (T1) xi (x, precision);
    2866                 :    4855267 :   WIDE_INT_REF_FOR (T2) yi (y);
    2867                 :            : 
    2868                 :            :   unsigned int remainder_len;
    2869                 :    4855267 :   divmod_internal (0, &remainder_len, remainder_val,
    2870                 :            :                    xi.val, xi.len, precision,
    2871                 :            :                    yi.val, yi.len, yi.precision, sgn, overflow);
    2872                 :    4855267 :   remainder.set_len (remainder_len);
    2873                 :            : 
    2874                 :    4850886 :   return remainder;
    2875                 :            : }
    2876                 :            : 
    2877                 :            : /* Compute X / Y, rouding towards 0, and return the remainder.
    2878                 :            :    Treat X and Y as signed values.  */
    2879                 :            : template <typename T1, typename T2>
    2880                 :            : inline WI_BINARY_RESULT (T1, T2)
    2881                 :      20698 : wi::smod_trunc (const T1 &x, const T2 &y)
    2882                 :            : {
    2883                 :      20698 :   return mod_trunc (x, y, SIGNED);
    2884                 :            : }
    2885                 :            : 
    2886                 :            : /* Compute X / Y, rouding towards 0, and return the remainder.
    2887                 :            :    Treat X and Y as unsigned values.  */
    2888                 :            : template <typename T1, typename T2>
    2889                 :            : inline WI_BINARY_RESULT (T1, T2)
    2890                 :    2071069 : wi::umod_trunc (const T1 &x, const T2 &y)
    2891                 :            : {
    2892                 :    2071069 :   return mod_trunc (x, y, UNSIGNED);
    2893                 :            : }
    2894                 :            : 
    2895                 :            : /* Compute X / Y, rouding towards -inf, and return the remainder.
    2896                 :            :    Treat X and Y as having the signedness given by SGN.  Indicate
    2897                 :            :    in *OVERFLOW if the division overflows.  */
    2898                 :            : template <typename T1, typename T2>
    2899                 :            : inline WI_BINARY_RESULT (T1, T2)
    2900                 :   19355019 : wi::mod_floor (const T1 &x, const T2 &y, signop sgn, overflow_type *overflow)
    2901                 :            : {
    2902                 :   19355019 :   WI_BINARY_RESULT_VAR (quotient, quotient_val, T1, x, T2, y);
    2903                 :   19355019 :   WI_BINARY_RESULT_VAR (remainder, remainder_val, T1, x, T2, y);
    2904                 :   19355019 :   unsigned int precision = get_precision (quotient);
    2905                 :   19355019 :   WIDE_INT_REF_FOR (T1) xi (x, precision);
    2906                 :   19355019 :   WIDE_INT_REF_FOR (T2) yi (y);
    2907                 :            : 
    2908                 :            :   unsigned int remainder_len;
    2909                 :   19355019 :   quotient.set_len (divmod_internal (quotient_val,
    2910                 :            :                                      &remainder_len, remainder_val,
    2911                 :            :                                      xi.val, xi.len, precision,
    2912                 :            :                                      yi.val, yi.len, yi.precision, sgn,
    2913                 :            :                                      overflow));
    2914                 :   19372119 :   remainder.set_len (remainder_len);
    2915                 :            : 
    2916                 :   19356919 :   if (wi::neg_p (x, sgn) != wi::neg_p (y, sgn) && remainder != 0)
    2917                 :   19355019 :     return remainder + y;
    2918                 :   19353819 :   return remainder;
    2919                 :            : }
    2920                 :            : 
    2921                 :            : /* Compute X / Y, rouding towards -inf, and return the remainder.
    2922                 :            :    Treat X and Y as unsigned values.  */
    2923                 :            : /* ??? Why do we have both this and umod_trunc.  Aren't they the same?  */
    2924                 :            : template <typename T1, typename T2>
    2925                 :            : inline WI_BINARY_RESULT (T1, T2)
    2926                 :      55619 : wi::umod_floor (const T1 &x, const T2 &y)
    2927                 :            : {
    2928                 :      55619 :   return mod_floor (x, y, UNSIGNED);
    2929                 :            : }
    2930                 :            : 
    2931                 :            : /* Compute X / Y, rouding towards +inf, and return the remainder.
    2932                 :            :    Treat X and Y as having the signedness given by SGN.  Indicate
    2933                 :            :    in *OVERFLOW if the division overflows.  */
    2934                 :            : template <typename T1, typename T2>
    2935                 :            : inline WI_BINARY_RESULT (T1, T2)
    2936                 :          0 : wi::mod_ceil (const T1 &x, const T2 &y, signop sgn, overflow_type *overflow)
    2937                 :            : {
    2938                 :          0 :   WI_BINARY_RESULT_VAR (quotient, quotient_val, T1, x, T2, y);
    2939                 :          0 :   WI_BINARY_RESULT_VAR (remainder, remainder_val, T1, x, T2, y);
    2940                 :          0 :   unsigned int precision = get_precision (quotient);
    2941                 :          0 :   WIDE_INT_REF_FOR (T1) xi (x, precision);
    2942                 :          0 :   WIDE_INT_REF_FOR (T2) yi (y);
    2943                 :            : 
    2944                 :            :   unsigned int remainder_len;
    2945                 :          0 :   quotient.set_len (divmod_internal (quotient_val,
    2946                 :            :                                      &remainder_len, remainder_val,
    2947                 :            :                                      xi.val, xi.len, precision,
    2948                 :            :                                      yi.val, yi.len, yi.precision, sgn,
    2949                 :            :                                      overflow));
    2950                 :          0 :   remainder.set_len (remainder_len);
    2951                 :            : 
    2952                 :          0 :   if (wi::neg_p (x, sgn) == wi::neg_p (y, sgn) && remainder != 0)
    2953                 :          0 :     return remainder - y;
    2954                 :          0 :   return remainder;
    2955                 :            : }
    2956                 :            : 
    2957                 :            : /* Compute X / Y, rouding towards nearest with ties away from zero,
    2958                 :            :    and return the remainder.  Treat X and Y as having the signedness
    2959                 :            :    given by SGN.  Indicate in *OVERFLOW if the division overflows.  */
    2960                 :            : template <typename T1, typename T2>
    2961                 :            : inline WI_BINARY_RESULT (T1, T2)
    2962                 :          0 : wi::mod_round (const T1 &x, const T2 &y, signop sgn, overflow_type *overflow)
    2963                 :            : {
    2964                 :          0 :   WI_BINARY_RESULT_VAR (quotient, quotient_val, T1, x, T2, y);
    2965                 :          0 :   WI_BINARY_RESULT_VAR (remainder, remainder_val, T1, x, T2, y);
    2966                 :          0 :   unsigned int precision = get_precision (quotient);
    2967                 :          0 :   WIDE_INT_REF_FOR (T1) xi (x, precision);
    2968                 :          0 :   WIDE_INT_REF_FOR (T2) yi (y);
    2969                 :            : 
    2970                 :            :   unsigned int remainder_len;
    2971                 :          0 :   quotient.set_len (divmod_internal (quotient_val,
    2972                 :            :                                      &remainder_len, remainder_val,
    2973                 :            :                                      xi.val, xi.len, precision,
    2974                 :            :                                      yi.val, yi.len, yi.precision, sgn,
    2975                 :            :                                      overflow));
    2976                 :          0 :   remainder.set_len (remainder_len);
    2977                 :            : 
    2978                 :          0 :   if (remainder != 0)
    2979                 :            :     {
    2980                 :          0 :       if (sgn == SIGNED)
    2981                 :            :         {
    2982                 :          0 :           WI_BINARY_RESULT (T1, T2) abs_remainder = wi::abs (remainder);
    2983                 :          0 :           if (wi::geu_p (abs_remainder, wi::sub (wi::abs (y), abs_remainder)))
    2984                 :            :             {
    2985                 :          0 :               if (wi::neg_p (x, sgn) != wi::neg_p (y, sgn))
    2986                 :          0 :                 return remainder + y;
    2987                 :            :               else
    2988                 :          0 :                 return remainder - y;
    2989                 :            :             }
    2990                 :            :         }
    2991                 :            :       else
    2992                 :            :         {
    2993                 :          0 :           if (wi::geu_p (remainder, wi::sub (y, remainder)))
    2994                 :          0 :             return remainder - y;
    2995                 :            :         }
    2996                 :            :     }
    2997                 :          0 :   return remainder;
    2998                 :            : }
    2999                 :            : 
    3000                 :            : /* Return true if X is a multiple of Y.  Treat X and Y as having the
    3001                 :            :    signedness given by SGN.  */
    3002                 :            : template <typename T1, typename T2>
    3003                 :            : inline bool
    3004                 :    2237381 : wi::multiple_of_p (const T1 &x, const T2 &y, signop sgn)
    3005                 :            : {
    3006                 :    2237381 :   return wi::mod_trunc (x, y, sgn) == 0;
    3007                 :            : }
    3008                 :            : 
    3009                 :            : /* Return true if X is a multiple of Y, storing X / Y in *RES if so.
    3010                 :            :    Treat X and Y as having the signedness given by SGN.  */
    3011                 :            : template <typename T1, typename T2>
    3012                 :            : inline bool
    3013                 :     295083 : wi::multiple_of_p (const T1 &x, const T2 &y, signop sgn,
    3014                 :            :                    WI_BINARY_RESULT (T1, T2) *res)
    3015                 :            : {
    3016                 :     295083 :   WI_BINARY_RESULT (T1, T2) remainder;
    3017                 :            :   WI_BINARY_RESULT (T1, T2) quotient
    3018                 :     295083 :     = divmod_trunc (x, y, sgn, &remainder);
    3019                 :     845353 :   if (remainder == 0)
    3020                 :            :     {
    3021                 :     255187 :       *res = quotient;
    3022                 :     255187 :       return true;
    3023                 :            :     }
    3024                 :            :   return false;
    3025                 :            : }
    3026                 :            : 
    3027                 :            : /* Return X << Y.  Return 0 if Y is greater than or equal to
    3028                 :            :    the precision of X.  */
    3029                 :            : template <typename T1, typename T2>
    3030                 :            : inline WI_UNARY_RESULT (T1)
    3031                 : 2658810048 : wi::lshift (const T1 &x, const T2 &y)
    3032                 :            : {
    3033                 : 2658810048 :   WI_UNARY_RESULT_VAR (result, val, T1, x);
    3034                 : 2658810048 :   unsigned int precision = get_precision (result);
    3035                 : 2658810048 :   WIDE_INT_REF_FOR (T1) xi (x, precision);
    3036                 : 2658810048 :   WIDE_INT_REF_FOR (T2) yi (y);
    3037                 :            :   /* Handle the simple cases quickly.   */
    3038                 : 2658810048 :   if (geu_p (yi, precision))
    3039                 :            :     {
    3040                 :    1377022 :       val[0] = 0;
    3041                 : 2658810048 :       result.set_len (1);
    3042                 :            :     }
    3043                 :            :   else
    3044                 :            :     {
    3045                 : 2657432998 :       unsigned int shift = yi.to_uhwi ();
    3046                 :            :       /* For fixed-precision integers like offset_int and widest_int,
    3047                 :            :          handle the case where the shift value is constant and the
    3048                 :            :          result is a single nonnegative HWI (meaning that we don't
    3049                 :            :          need to worry about val[1]).  This is particularly common
    3050                 :            :          for converting a byte count to a bit count.
    3051                 :            : 
    3052                 :            :          For variable-precision integers like wide_int, handle HWI
    3053                 :            :          and sub-HWI integers inline.  */
    3054                 :   25884249 :       if (STATIC_CONSTANT_P (xi.precision > HOST_BITS_PER_WIDE_INT)
    3055                 :            :           ? (STATIC_CONSTANT_P (shift < HOST_BITS_PER_WIDE_INT - 1)
    3056                 :            :              && xi.len == 1
    3057                 :            :              && IN_RANGE (xi.val[0], 0, HOST_WIDE_INT_MAX >> shift))
    3058                 :            :           : precision <= HOST_BITS_PER_WIDE_INT)
    3059                 :            :         {
    3060                 :   25611751 :           val[0] = xi.ulow () << shift;
    3061                 : 2658810048 :           result.set_len (1);
    3062                 :            :         }
    3063                 :            :       else
    3064                 : 2631821222 :         result.set_len (lshift_large (val, xi.val, xi.len,
    3065                 :            :                                       precision, shift));
    3066                 :            :     }
    3067                 : 2658810048 :   return result;
    3068                 :            : }
    3069                 :            : 
    3070                 :            : /* Return X >> Y, using a logical shift.  Return 0 if Y is greater than
    3071                 :            :    or equal to the precision of X.  */
    3072                 :            : template <typename T1, typename T2>
    3073                 :            : inline WI_UNARY_RESULT (T1)
    3074                 :   10307237 : wi::lrshift (const T1 &x, const T2 &y)
    3075                 :            : {
    3076                 :   10307237 :   WI_UNARY_RESULT_VAR (result, val, T1, x);
    3077                 :            :   /* Do things in the precision of the input rather than the output,
    3078                 :            :      since the result can be no larger than that.  */
    3079                 :   10307237 :   WIDE_INT_REF_FOR (T1) xi (x);
    3080                 :   10307237 :   WIDE_INT_REF_FOR (T2) yi (y);
    3081                 :            :   /* Handle the simple cases quickly.   */
    3082                 :   10307237 :   if (geu_p (yi, xi.precision))
    3083                 :            :     {
    3084                 :       3379 :       val[0] = 0;
    3085                 :   10307237 :       result.set_len (1);
    3086                 :            :     }
    3087                 :            :   else
    3088                 :            :     {
    3089                 :   10303855 :       unsigned int shift = yi.to_uhwi ();
    3090                 :            :       /* For fixed-precision integers like offset_int and widest_int,
    3091                 :            :          handle the case where the shift value is constant and the
    3092                 :            :          shifted value is a single nonnegative HWI (meaning that all
    3093                 :            :          bits above the HWI are zero).  This is particularly common
    3094                 :            :          for converting a bit count to a byte count.
    3095                 :            : 
    3096                 :            :          For variable-precision integers like wide_int, handle HWI
    3097                 :            :          and sub-HWI integers inline.  */
    3098                 :    6553329 :       if (STATIC_CONSTANT_P (xi.precision > HOST_BITS_PER_WIDE_INT)
    3099                 :            :           ? (shift < HOST_BITS_PER_WIDE_INT
    3100                 :            :              && xi.len == 1
    3101                 :            :              && xi.val[0] >= 0)
    3102                 :            :           : xi.precision <= HOST_BITS_PER_WIDE_INT)
    3103                 :            :         {
    3104                 :    6503509 :           val[0] = xi.to_uhwi () >> shift;
    3105                 :   10307237 :           result.set_len (1);
    3106                 :            :         }
    3107                 :            :       else
    3108                 :    3800340 :         result.set_len (lrshift_large (val, xi.val, xi.len, xi.precision,
    3109                 :            :                                        get_precision (result), shift));
    3110                 :            :     }
    3111                 :   10307237 :   return result;
    3112                 :            : }
    3113                 :            : 
    3114                 :            : /* Return X >> Y, using an arithmetic shift.  Return a sign mask if
    3115                 :            :    Y is greater than or equal to the precision of X.  */
    3116                 :            : template <typename T1, typename T2>
    3117                 :            : inline WI_UNARY_RESULT (T1)
    3118                 :  120437827 : wi::arshift (const T1 &x, const T2 &y)
    3119                 :            : {
    3120                 :  120437827 :   WI_UNARY_RESULT_VAR (result, val, T1, x);
    3121                 :            :   /* Do things in the precision of the input rather than the output,
    3122                 :            :      since the result can be no larger than that.  */
    3123                 :  120437827 :   WIDE_INT_REF_FOR (T1) xi (x);
    3124                 :  120437827 :   WIDE_INT_REF_FOR (T2) yi (y);
    3125                 :            :   /* Handle the simple cases quickly.   */
    3126                 :  120452571 :   if (geu_p (yi, xi.precision))
    3127                 :            :     {
    3128                 :      14744 :       val[0] = sign_mask (x);
    3129                 :  120437827 :       result.set_len (1);
    3130                 :            :     }
    3131                 :            :   else
    3132                 :            :     {
    3133                 :  120423083 :       unsigned int shift = yi.to_uhwi ();
    3134                 :  120210067 :       if (xi.precision <= HOST_BITS_PER_WIDE_INT)
    3135                 :            :         {
    3136                 :    2503182 :           val[0] = sext_hwi (xi.ulow () >> shift, xi.precision - shift);
    3137                 :  120437827 :           result.set_len (1, true);
    3138                 :            :         }
    3139                 :            :       else
    3140                 :  119170115 :         result.set_len (arshift_large (val, xi.val, xi.len, xi.precision,
    3141                 :            :                                        get_precision (result), shift));
    3142                 :            :     }
    3143                 :  120437827 :   return result;
    3144                 :            : }
    3145                 :            : 
    3146                 :            : /* Return X >> Y, using an arithmetic shift if SGN is SIGNED and a
    3147                 :            :    logical shift otherwise.  */
    3148                 :            : template <typename T1, typename T2>
    3149                 :            : inline WI_UNARY_RESULT (T1)
    3150                 :    6638620 : wi::rshift (const T1 &x, const T2 &y, signop sgn)
    3151                 :            : {
    3152                 :    6638620 :   if (sgn == UNSIGNED)
    3153                 :    5221265 :     return lrshift (x, y);
    3154                 :            :   else
    3155                 :    1417360 :     return arshift (x, y);
    3156                 :            : }
    3157                 :            : 
    3158                 :            : /* Return the result of rotating the low WIDTH bits of X left by Y
    3159                 :            :    bits and zero-extending the result.  Use a full-width rotate if
    3160                 :            :    WIDTH is zero.  */
    3161                 :            : template <typename T1, typename T2>
    3162                 :            : WI_UNARY_RESULT (T1)
    3163                 :       6581 : wi::lrotate (const T1 &x, const T2 &y, unsigned int width)
    3164                 :            : {
    3165                 :       6581 :   unsigned int precision = get_binary_precision (x, x);
    3166                 :       6581 :   if (width == 0)
    3167                 :       6455 :     width = precision;
    3168                 :       6581 :   WI_UNARY_RESULT (T2) ymod = umod_trunc (y, width);
    3169                 :       6581 :   WI_UNARY_RESULT (T1) left = wi::lshift (x, ymod);
    3170                 :       6581 :   WI_UNARY_RESULT (T1) right = wi::lrshift (x, wi::sub (width, ymod));
    3171                 :       6581 :   if (width != precision)
    3172                 :        252 :     return wi::zext (left, width) | wi::zext (right, width);
    3173                 :       6581 :   return left | right;
    3174                 :            : }
    3175                 :            : 
    3176                 :            : /* Return the result of rotating the low WIDTH bits of X right by Y
    3177                 :            :    bits and zero-extending the result.  Use a full-width rotate if
    3178                 :            :    WIDTH is zero.  */
    3179                 :            : template <typename T1, typename T2>
    3180                 :            : WI_UNARY_RESULT (T1)
    3181                 :      38962 : wi::rrotate (const T1 &x, const T2 &y, unsigned int width)
    3182                 :            : {
    3183                 :      38962 :   unsigned int precision = get_binary_precision (x, x);
    3184                 :      38962 :   if (width == 0)
    3185                 :      19228 :     width = precision;
    3186                 :      38962 :   WI_UNARY_RESULT (T2) ymod = umod_trunc (y, width);
    3187                 :      38962 :   WI_UNARY_RESULT (T1) right = wi::lrshift (x, ymod);
    3188                 :      38962 :   WI_UNARY_RESULT (T1) left = wi::lshift (x, wi::sub (width, ymod));
    3189                 :      38962 :   if (width != precision)
    3190                 :      39468 :     return wi::zext (left, width) | wi::zext (right, width);
    3191                 :      38962 :   return left | right;
    3192                 :            : }
    3193                 :            : 
    3194                 :            : /* Return 0 if the number of 1s in X is even and 1 if the number of 1s
    3195                 :            :    is odd.  */
    3196                 :            : inline int
    3197                 :        454 : wi::parity (const wide_int_ref &x)
    3198                 :            : {
    3199                 :        454 :   return popcount (x) & 1;
    3200                 :            : }
    3201                 :            : 
    3202                 :            : /* Extract WIDTH bits from X, starting at BITPOS.  */
    3203                 :            : template <typename T>
    3204                 :            : inline unsigned HOST_WIDE_INT
    3205                 :   39268895 : wi::extract_uhwi (const T &x, unsigned int bitpos, unsigned int width)
    3206                 :            : {
    3207                 :   39268895 :   unsigned precision = get_precision (x);
    3208                 :   39268895 :   if (precision < bitpos + width)
    3209                 :            :     precision = bitpos + width;
    3210                 :   39268895 :   WIDE_INT_REF_FOR (T) xi (x, precision);
    3211                 :            : 
    3212                 :            :   /* Handle this rare case after the above, so that we assert about
    3213                 :            :      bogus BITPOS values.  */
    3214                 :   39268895 :   if (width == 0)
    3215                 :            :     return 0;
    3216                 :            : 
    3217                 :   39253120 :   unsigned int start = bitpos / HOST_BITS_PER_WIDE_INT;
    3218                 :   39253120 :   unsigned int shift = bitpos % HOST_BITS_PER_WIDE_INT;
    3219                 :   39253120 :   unsigned HOST_WIDE_INT res = xi.elt (start);
    3220                 :   39253120 :   res >>= shift;
    3221                 :   39253120 :   if (shift + width > HOST_BITS_PER_WIDE_INT)
    3222                 :            :     {
    3223                 :     153110 :       unsigned HOST_WIDE_INT upper = xi.elt (start + 1);
    3224                 :     153110 :       res |= upper << (-shift % HOST_BITS_PER_WIDE_INT);
    3225                 :            :     }
    3226                 :   39268895 :   return zext_hwi (res, width);
    3227                 :            : }
    3228                 :            : 
    3229                 :            : /* Return the minimum precision needed to store X with sign SGN.  */
    3230                 :            : template <typename T>
    3231                 :            : inline unsigned int
    3232                 :    7942401 : wi::min_precision (const T &x, signop sgn)
    3233                 :            : {
    3234                 :    3168063 :   if (sgn == SIGNED)
    3235                 :    1007048 :     return get_precision (x) - clrsb (x);
    3236                 :            :   else
    3237                 :    6936057 :     return get_precision (x) - clz (x);
    3238                 :            : }
    3239                 :            : 
    3240                 :            : #define SIGNED_BINARY_PREDICATE(OP, F)                  \
    3241                 :            :   template <typename T1, typename T2>                     \
    3242                 :            :     inline WI_SIGNED_BINARY_PREDICATE_RESULT (T1, T2)   \
    3243                 :            :     OP (const T1 &x, const T2 &y)                       \
    3244                 :            :     {                                                   \
    3245                 :            :       return wi::F (x, y);                              \
    3246                 :            :     }
    3247                 :            : 
    3248                 : 1282042398 : SIGNED_BINARY_PREDICATE (operator <, lts_p)
    3249                 :  560588884 : SIGNED_BINARY_PREDICATE (operator <=, les_p)
    3250                 :    4684202 : SIGNED_BINARY_PREDICATE (operator >, gts_p)
    3251                 :     198418 : SIGNED_BINARY_PREDICATE (operator >=, ges_p)
    3252                 :            : 
    3253                 :            : #undef SIGNED_BINARY_PREDICATE
    3254                 :            : 
    3255                 :            : #define UNARY_OPERATOR(OP, F) \
    3256                 :            :   template<typename T> \
    3257                 :            :   WI_UNARY_RESULT (generic_wide_int<T>) \
    3258                 :            :   OP (const generic_wide_int<T> &x) \
    3259                 :            :   { \
    3260                 :            :     return wi::F (x); \
    3261                 :            :   }
    3262                 :            : 
    3263                 :            : #define BINARY_PREDICATE(OP, F) \
    3264                 :            :   template<typename T1, typename T2> \
    3265                 :            :   WI_BINARY_PREDICATE_RESULT (T1, T2) \
    3266                 :            :   OP (const T1 &x, const T2 &y) \
    3267                 :            :   { \
    3268                 :            :     return wi::F (x, y); \
    3269                 :            :   }
    3270                 :            : 
    3271                 :            : #define BINARY_OPERATOR(OP, F) \
    3272                 :            :   template<typename T1, typename T2> \
    3273                 :            :   WI_BINARY_OPERATOR_RESULT (T1, T2) \
    3274                 :            :   OP (const T1 &x, const T2 &y) \
    3275                 :            :   { \
    3276                 :            :     return wi::F (x, y); \
    3277                 :            :   }
    3278                 :            : 
    3279                 :            : #define SHIFT_OPERATOR(OP, F) \
    3280                 :            :   template<typename T1, typename T2> \
    3281                 :            :   WI_BINARY_OPERATOR_RESULT (T1, T1) \
    3282                 :            :   OP (const T1 &x, const T2 &y) \
    3283                 :            :   { \
    3284                 :            :     return wi::F (x, y); \
    3285                 :            :   }
    3286                 :            : 
    3287                 :    8462397 : UNARY_OPERATOR (operator ~, bit_not)
    3288                 :   17746236 : UNARY_OPERATOR (operator -, neg)
    3289                 : 7012037628 : BINARY_PREDICATE (operator ==, eq_p)
    3290                 : 8313428951 : BINARY_PREDICATE (operator !=, ne_p)
    3291                 :  501772633 : BINARY_OPERATOR (operator &, bit_and)
    3292                 :  249109339 : BINARY_OPERATOR (operator |, bit_or)
    3293                 :  163443673 : BINARY_OPERATOR (operator ^, bit_xor)
    3294                 :  671441484 : BINARY_OPERATOR (operator +, add)
    3295                 :  774407583 : BINARY_OPERATOR (operator -, sub)
    3296                 :  186022747 : BINARY_OPERATOR (operator *, mul)
    3297                 : 1745020122 : SHIFT_OPERATOR (operator <<, lshift)
    3298                 :            : 
    3299                 :            : #undef UNARY_OPERATOR
    3300                 :            : #undef BINARY_PREDICATE
    3301                 :            : #undef BINARY_OPERATOR
    3302                 :            : #undef SHIFT_OPERATOR
    3303                 :            : 
    3304                 :            : template <typename T1, typename T2>
    3305                 :            : inline WI_SIGNED_SHIFT_RESULT (T1, T2)
    3306                 :  118992342 : operator >> (const T1 &x, const T2 &y)
    3307                 :            : {
    3308                 :  118992342 :   return wi::arshift (x, y);
    3309                 :            : }
    3310                 :            : 
    3311                 :            : template <typename T1, typename T2>
    3312                 :            : inline WI_SIGNED_SHIFT_RESULT (T1, T2)
    3313                 :      17100 : operator / (const T1 &x, const T2 &y)
    3314                 :            : {
    3315                 :      17100 :   return wi::sdiv_trunc (x, y);
    3316                 :            : }
    3317                 :            : 
    3318                 :            : template <typename T1, typename T2>
    3319                 :            : inline WI_SIGNED_SHIFT_RESULT (T1, T2)
    3320                 :      20698 : operator % (const T1 &x, const T2 &y)
    3321                 :            : {
    3322                 :      20698 :   return wi::smod_trunc (x, y);
    3323                 :            : }
    3324                 :            : 
    3325                 :            : template<typename T>
    3326                 :            : void
    3327                 :      46045 : gt_ggc_mx (generic_wide_int <T> *)
    3328                 :            : {
    3329                 :            : }
    3330                 :            : 
    3331                 :            : template<typename T>
    3332                 :            : void
    3333                 :          0 : gt_pch_nx (generic_wide_int <T> *)
    3334                 :            : {
    3335                 :            : }
    3336                 :            : 
    3337                 :            : template<typename T>
    3338                 :            : void
    3339                 :          0 : gt_pch_nx (generic_wide_int <T> *, void (*) (void *, void *), void *)
    3340                 :            : {
    3341                 :            : }
    3342                 :            : 
    3343                 :            : template<int N>
    3344                 :            : void
    3345                 :            : gt_ggc_mx (trailing_wide_ints <N> *)
    3346                 :            : {
    3347                 :            : }
    3348                 :            : 
    3349                 :            : template<int N>
    3350                 :            : void
    3351                 :            : gt_pch_nx (trailing_wide_ints <N> *)
    3352                 :            : {
    3353                 :            : }
    3354                 :            : 
    3355                 :            : template<int N>
    3356                 :            : void
    3357                 :            : gt_pch_nx (trailing_wide_ints <N> *, void (*) (void *, void *), void *)
    3358                 :            : {
    3359                 :            : }
    3360                 :            : 
    3361                 :            : namespace wi
    3362                 :            : {
    3363                 :            :   /* Used for overloaded functions in which the only other acceptable
    3364                 :            :      scalar type is a pointer.  It stops a plain 0 from being treated
    3365                 :            :      as a null pointer.  */
    3366                 :            :   struct never_used1 {};
    3367                 :            :   struct never_used2 {};
    3368                 :            : 
    3369                 :            :   wide_int min_value (unsigned int, signop);
    3370                 :            :   wide_int min_value (never_used1 *);
    3371                 :            :   wide_int min_value (never_used2 *);
    3372                 :            :   wide_int max_value (unsigned int, signop);
    3373                 :            :   wide_int max_value (never_used1 *);
    3374                 :            :   wide_int max_value (never_used2 *);
    3375                 :            : 
    3376                 :            :   /* FIXME: this is target dependent, so should be elsewhere.
    3377                 :            :      It also seems to assume that CHAR_BIT == BITS_PER_UNIT.  */
    3378                 :            :   wide_int from_buffer (const unsigned char *, unsigned int);
    3379                 :            : 
    3380                 :            : #ifndef GENERATOR_FILE
    3381                 :            :   void to_mpz (const wide_int_ref &, mpz_t, signop);
    3382                 :            : #endif
    3383                 :            : 
    3384                 :            :   wide_int mask (unsigned int, bool, unsigned int);
    3385                 :            :   wide_int shifted_mask (unsigned int, unsigned int, bool, unsigned int);
    3386                 :            :   wide_int set_bit_in_zero (unsigned int, unsigned int);
    3387                 :            :   wide_int insert (const wide_int &x, const wide_int &y, unsigned int,
    3388                 :            :                    unsigned int);
    3389                 :            :   wide_int round_down_for_mask (const wide_int &, const wide_int &);
    3390                 :            :   wide_int round_up_for_mask (const wide_int &, const wide_int &);
    3391                 :            : 
    3392                 :            :   template <typename T>
    3393                 :            :   T mask (unsigned int, bool);
    3394                 :            : 
    3395                 :            :   template <typename T>
    3396                 :            :   T shifted_mask (unsigned int, unsigned int, bool);
    3397                 :            : 
    3398                 :            :   template <typename T>
    3399                 :            :   T set_bit_in_zero (unsigned int);
    3400                 :            : 
    3401                 :            :   unsigned int mask (HOST_WIDE_INT *, unsigned int, bool, unsigned int);
    3402                 :            :   unsigned int shifted_mask (HOST_WIDE_INT *, unsigned int, unsigned int,
    3403                 :            :                              bool, unsigned int);
    3404                 :            :   unsigned int from_array (HOST_WIDE_INT *, const HOST_WIDE_INT *,
    3405                 :            :                            unsigned int, unsigned int, bool);
    3406                 :            : }
    3407                 :            : 
    3408                 :            : /* Return a PRECISION-bit integer in which the low WIDTH bits are set
    3409                 :            :    and the other bits are clear, or the inverse if NEGATE_P.  */
    3410                 :            : inline wide_int
    3411                 :  111339402 : wi::mask (unsigned int width, bool negate_p, unsigned int precision)
    3412                 :            : {
    3413                 :  111339402 :   wide_int result = wide_int::create (precision);
    3414                 :  111339402 :   result.set_len (mask (result.write_val (), width, negate_p, precision));
    3415                 :  111339402 :   return result;
    3416                 :            : }
    3417                 :            : 
    3418                 :            : /* Return a PRECISION-bit integer in which the low START bits are clear,
    3419                 :            :    the next WIDTH bits are set, and the other bits are clear,
    3420                 :            :    or the inverse if NEGATE_P.  */
    3421                 :            : inline wide_int
    3422                 :  156827356 : wi::shifted_mask (unsigned int start, unsigned int width, bool negate_p,
    3423                 :            :                   unsigned int precision)
    3424                 :            : {
    3425                 :  156827356 :   wide_int result = wide_int::create (precision);
    3426                 :  156827356 :   result.set_len (shifted_mask (result.write_val (), start, width, negate_p,
    3427                 :            :                                 precision));
    3428                 :  156827356 :   return result;
    3429                 :            : }
    3430                 :            : 
    3431                 :            : /* Return a PRECISION-bit integer in which bit BIT is set and all the
    3432                 :            :    others are clear.  */
    3433                 :            : inline wide_int
    3434                 :  156612167 : wi::set_bit_in_zero (unsigned int bit, unsigned int precision)
    3435                 :            : {
    3436                 :  156612167 :   return shifted_mask (bit, 1, false, precision);
    3437                 :            : }
    3438                 :            : 
    3439                 :            : /* Return an integer of type T in which the low WIDTH bits are set
    3440                 :            :    and the other bits are clear, or the inverse if NEGATE_P.  */
    3441                 :            : template <typename T>
    3442                 :            : inline T
    3443                 :   15887018 : wi::mask (unsigned int width, bool negate_p)
    3444                 :            : {
    3445                 :            :   STATIC_ASSERT (wi::int_traits<T>::precision);
    3446                 :   15887018 :   T result;
    3447                 :   15887018 :   result.set_len (mask (result.write_val (), width, negate_p,
    3448                 :            :                         wi::int_traits <T>::precision));
    3449                 :    2601970 :   return result;
    3450                 :            : }
    3451                 :            : 
    3452                 :            : /* Return an integer of type T in which the low START bits are clear,
    3453                 :            :    the next WIDTH bits are set, and the other bits are clear, or the
    3454                 :            :    inverse if NEGATE_P.  */
    3455                 :            : template <typename T>
    3456                 :            : inline T
    3457                 :      12965 : wi::shifted_mask (unsigned int start, unsigned int width, bool negate_p)
    3458                 :            : {
    3459                 :            :   STATIC_ASSERT (wi::int_traits<T>::precision);
    3460                 :      12965 :   T result;
    3461                 :      21606 :   result.set_len (shifted_mask (result.write_val (), start, width,
    3462                 :            :                                 negate_p,
    3463                 :            :                                 wi::int_traits <T>::precision));
    3464                 :            :   return result;
    3465                 :            : }
    3466                 :            : 
    3467                 :            : /* Return an integer of type T in which bit BIT is set and all the
    3468                 :            :    others are clear.  */
    3469                 :            : template <typename T>
    3470                 :            : inline T
    3471                 :       8641 : wi::set_bit_in_zero (unsigned int bit)
    3472                 :            : {
    3473                 :       8641 :   return shifted_mask <T> (bit, 1, false);
    3474                 :            : }
    3475                 :            : 
    3476                 :            : /* Accumulate a set of overflows into OVERFLOW.  */
    3477                 :            : 
    3478                 :            : static inline void
    3479                 :            : wi::accumulate_overflow (wi::overflow_type &overflow,
    3480                 :            :                          wi::overflow_type suboverflow)
    3481                 :            : {
    3482                 :            :   if (!suboverflow)
    3483                 :            :     return;
    3484                 :            :   if (!overflow)
    3485                 :            :     overflow = suboverflow;
    3486                 :            :   else if (overflow != suboverflow)
    3487                 :            :     overflow = wi::OVF_UNKNOWN;
    3488                 :            : }
    3489                 :            : 
    3490                 :            : #endif /* WIDE_INT_H */

Generated by: LCOV version 1.0

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto --enable-host-shared. GCC test suite is run with the built compiler.