intprops.h 25 KB
Newer Older
Paul Eggert's avatar
Paul Eggert committed
1 2
/* intprops.h -- properties of integer types

Paul Eggert's avatar
Paul Eggert committed
3
   Copyright (C) 2001-2019 Free Software Foundation, Inc.
Paul Eggert's avatar
Paul Eggert committed
4

Paul Eggert's avatar
Paul Eggert committed
5 6 7
   This program is free software: you can redistribute it and/or modify it
   under the terms of the GNU General Public License as published
   by the Free Software Foundation; either version 3 of the License, or
Paul Eggert's avatar
Paul Eggert committed
8 9 10 11 12 13 14 15
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
Paul Eggert's avatar
Paul Eggert committed
16
   along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
Paul Eggert's avatar
Paul Eggert committed
17 18 19

/* Written by Paul Eggert.  */

Paul Eggert's avatar
Paul Eggert committed
20 21
#ifndef _GL_INTPROPS_H
#define _GL_INTPROPS_H
Paul Eggert's avatar
Paul Eggert committed
22

Paul Eggert's avatar
Paul Eggert committed
23 24
#include <limits.h>

Paul Eggert's avatar
Paul Eggert committed
25 26 27
/* Return a value with the common real type of E and V and the value of V.
   Do not evaluate E.  */
#define _GL_INT_CONVERT(e, v) ((1 ? 0 : (e)) + (v))
Paul Eggert's avatar
Paul Eggert committed
28

Paul Eggert's avatar
Paul Eggert committed
29
/* Act like _GL_INT_CONVERT (E, -V) but work around a bug in IRIX 6.5 cc; see
Paul Eggert's avatar
Paul Eggert committed
30
   <https://lists.gnu.org/r/bug-gnulib/2011-05/msg00406.html>.  */
Paul Eggert's avatar
Paul Eggert committed
31
#define _GL_INT_NEGATE_CONVERT(e, v) ((1 ? 0 : (e)) - (v))
Paul Eggert's avatar
Paul Eggert committed
32

Paul Eggert's avatar
Paul Eggert committed
33 34 35 36 37
/* The extra casts in the following macros work around compiler bugs,
   e.g., in Cray C 5.0.3.0.  */

/* True if the arithmetic type T is an integer type.  bool counts as
   an integer.  */
Paul Eggert's avatar
Paul Eggert committed
38
#define TYPE_IS_INTEGER(t) ((t) 1.5 == 1)
Paul Eggert's avatar
Paul Eggert committed
39

Paul Eggert's avatar
Paul Eggert committed
40
/* True if the real type T is signed.  */
Paul Eggert's avatar
Paul Eggert committed
41 42
#define TYPE_SIGNED(t) (! ((t) 0 < (t) -1))

Paul Eggert's avatar
Paul Eggert committed
43
/* Return 1 if the real expression E, after promotion, has a
Paul Eggert's avatar
Paul Eggert committed
44
   signed or floating type.  Do not evaluate E.  */
Paul Eggert's avatar
Paul Eggert committed
45
#define EXPR_SIGNED(e) (_GL_INT_NEGATE_CONVERT (e, 1) < 0)
Paul Eggert's avatar
Paul Eggert committed
46

Paul Eggert's avatar
Paul Eggert committed
47

Paul Eggert's avatar
Paul Eggert committed
48
/* Minimum and maximum values for integer types and expressions.  */
Paul Eggert's avatar
Paul Eggert committed
49

Paul Eggert's avatar
Paul Eggert committed
50
/* The width in bits of the integer type or expression T.
Paul Eggert's avatar
Paul Eggert committed
51
   Do not evaluate T.
Paul Eggert's avatar
Paul Eggert committed
52 53 54
   Padding bits are not supported; this is checked at compile-time below.  */
#define TYPE_WIDTH(t) (sizeof (t) * CHAR_BIT)

Paul Eggert's avatar
Paul Eggert committed
55
/* The maximum and minimum values for the integer type T.  */
Paul Eggert's avatar
Paul Eggert committed
56
#define TYPE_MINIMUM(t) ((t) ~ TYPE_MAXIMUM (t))
Paul Eggert's avatar
Paul Eggert committed
57 58 59
#define TYPE_MAXIMUM(t)                                                 \
  ((t) (! TYPE_SIGNED (t)                                               \
        ? (t) -1                                                        \
Paul Eggert's avatar
Paul Eggert committed
60
        : ((((t) 1 << (TYPE_WIDTH (t) - 2)) - 1) * 2 + 1)))
Paul Eggert's avatar
Paul Eggert committed
61

Paul Eggert's avatar
Paul Eggert committed
62
/* The maximum and minimum values for the type of the expression E,
Paul Eggert's avatar
Paul Eggert committed
63
   after integer promotion.  E is not evaluated.  */
Paul Eggert's avatar
Paul Eggert committed
64
#define _GL_INT_MINIMUM(e)                                              \
Paul Eggert's avatar
Paul Eggert committed
65
  (EXPR_SIGNED (e)                                                      \
Paul Eggert's avatar
Paul Eggert committed
66
   ? ~ _GL_SIGNED_INT_MAXIMUM (e)                                       \
Paul Eggert's avatar
Paul Eggert committed
67 68
   : _GL_INT_CONVERT (e, 0))
#define _GL_INT_MAXIMUM(e)                                              \
Paul Eggert's avatar
Paul Eggert committed
69
  (EXPR_SIGNED (e)                                                      \
Paul Eggert's avatar
Paul Eggert committed
70
   ? _GL_SIGNED_INT_MAXIMUM (e)                                         \
Paul Eggert's avatar
Paul Eggert committed
71
   : _GL_INT_NEGATE_CONVERT (e, 1))
Paul Eggert's avatar
Paul Eggert committed
72
#define _GL_SIGNED_INT_MAXIMUM(e)                                       \
Paul Eggert's avatar
Paul Eggert committed
73
  (((_GL_INT_CONVERT (e, 1) << (TYPE_WIDTH ((e) + 0) - 2)) - 1) * 2 + 1)
Paul Eggert's avatar
Paul Eggert committed
74

Paul Eggert's avatar
Paul Eggert committed
75 76 77 78 79 80
/* Work around OpenVMS incompatibility with C99.  */
#if !defined LLONG_MAX && defined __INT64_MAX
# define LLONG_MAX __INT64_MAX
# define LLONG_MIN __INT64_MIN
#endif

Paul Eggert's avatar
Paul Eggert committed
81 82 83
/* This include file assumes that signed types are two's complement without
   padding bits; the above macros have undefined behavior otherwise.
   If this is a problem for you, please let us know how to fix it for your host.
Paul Eggert's avatar
Paul Eggert committed
84
   This assumption is tested by the intprops-tests module.  */
Paul Eggert's avatar
Paul Eggert committed
85

Paul Eggert's avatar
Paul Eggert committed
86
/* Does the __typeof__ keyword work?  This could be done by
Paul Eggert's avatar
Paul Eggert committed
87
   'configure', but for now it's easier to do it by hand.  */
Paul Eggert's avatar
Paul Eggert committed
88 89
#if (2 <= __GNUC__ \
     || (1210 <= __IBMC__ && defined __IBM__TYPEOF__) \
Paul Eggert's avatar
Paul Eggert committed
90
     || (0x5110 <= __SUNPRO_C && !__STDC__))
Paul Eggert's avatar
Paul Eggert committed
91 92 93 94 95 96 97 98 99 100 101 102 103
# define _GL_HAVE___TYPEOF__ 1
#else
# define _GL_HAVE___TYPEOF__ 0
#endif

/* Return 1 if the integer type or expression T might be signed.  Return 0
   if it is definitely unsigned.  This macro does not evaluate its argument,
   and expands to an integer constant expression.  */
#if _GL_HAVE___TYPEOF__
# define _GL_SIGNED_TYPE_OR_EXPR(t) TYPE_SIGNED (__typeof__ (t))
#else
# define _GL_SIGNED_TYPE_OR_EXPR(t) 1
#endif
Paul Eggert's avatar
Paul Eggert committed
104 105 106 107

/* Bound on length of the string representing an unsigned integer
   value representable in B bits.  log10 (2.0) < 146/485.  The
   smallest value of B where this bound is not tight is 2621.  */
Paul Eggert's avatar
Paul Eggert committed
108
#define INT_BITS_STRLEN_BOUND(b) (((b) * 146 + 484) / 485)
Paul Eggert's avatar
Paul Eggert committed
109 110 111

/* Bound on length of the string representing an integer type or expression T.
   Subtract 1 for the sign bit if T is signed, and then add 1 more for
Paul Eggert's avatar
Paul Eggert committed
112 113
   a minus sign if needed.

Paul Eggert's avatar
Paul Eggert committed
114 115
   Because _GL_SIGNED_TYPE_OR_EXPR sometimes returns 1 when its argument is
   unsigned, this macro may overestimate the true bound by one byte when
Paul Eggert's avatar
Paul Eggert committed
116 117
   applied to unsigned types of size 2, 4, 16, ... bytes.  */
#define INT_STRLEN_BOUND(t)                                     \
Paul Eggert's avatar
Paul Eggert committed
118
  (INT_BITS_STRLEN_BOUND (TYPE_WIDTH (t) - _GL_SIGNED_TYPE_OR_EXPR (t)) \
Paul Eggert's avatar
Paul Eggert committed
119
   + _GL_SIGNED_TYPE_OR_EXPR (t))
Paul Eggert's avatar
Paul Eggert committed
120 121 122

/* Bound on buffer size needed to represent an integer type or expression T,
   including the terminating null.  */
Paul Eggert's avatar
Paul Eggert committed
123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181
#define INT_BUFSIZE_BOUND(t) (INT_STRLEN_BOUND (t) + 1)


/* Range overflow checks.

   The INT_<op>_RANGE_OVERFLOW macros return 1 if the corresponding C
   operators might not yield numerically correct answers due to
   arithmetic overflow.  They do not rely on undefined or
   implementation-defined behavior.  Their implementations are simple
   and straightforward, but they are a bit harder to use than the
   INT_<op>_OVERFLOW macros described below.

   Example usage:

     long int i = ...;
     long int j = ...;
     if (INT_MULTIPLY_RANGE_OVERFLOW (i, j, LONG_MIN, LONG_MAX))
       printf ("multiply would overflow");
     else
       printf ("product is %ld", i * j);

   Restrictions on *_RANGE_OVERFLOW macros:

   These macros do not check for all possible numerical problems or
   undefined or unspecified behavior: they do not check for division
   by zero, for bad shift counts, or for shifting negative numbers.

   These macros may evaluate their arguments zero or multiple times,
   so the arguments should not have side effects.  The arithmetic
   arguments (including the MIN and MAX arguments) must be of the same
   integer type after the usual arithmetic conversions, and the type
   must have minimum value MIN and maximum MAX.  Unsigned types should
   use a zero MIN of the proper type.

   These macros are tuned for constant MIN and MAX.  For commutative
   operations such as A + B, they are also tuned for constant B.  */

/* Return 1 if A + B would overflow in [MIN,MAX] arithmetic.
   See above for restrictions.  */
#define INT_ADD_RANGE_OVERFLOW(a, b, min, max)          \
  ((b) < 0                                              \
   ? (a) < (min) - (b)                                  \
   : (max) - (b) < (a))

/* Return 1 if A - B would overflow in [MIN,MAX] arithmetic.
   See above for restrictions.  */
#define INT_SUBTRACT_RANGE_OVERFLOW(a, b, min, max)     \
  ((b) < 0                                              \
   ? (max) + (b) < (a)                                  \
   : (a) < (min) + (b))

/* Return 1 if - A would overflow in [MIN,MAX] arithmetic.
   See above for restrictions.  */
#define INT_NEGATE_RANGE_OVERFLOW(a, min, max)          \
  ((min) < 0                                            \
   ? (a) < - (max)                                      \
   : 0 < (a))

/* Return 1 if A * B would overflow in [MIN,MAX] arithmetic.
Paul Eggert's avatar
Paul Eggert committed
182 183
   See above for restrictions.  Avoid && and || as they tickle
   bugs in Sun C 5.11 2010/08/13 and other compilers; see
Paul Eggert's avatar
Paul Eggert committed
184
   <https://lists.gnu.org/r/bug-gnulib/2011-05/msg00401.html>.  */
Paul Eggert's avatar
Paul Eggert committed
185 186 187 188
#define INT_MULTIPLY_RANGE_OVERFLOW(a, b, min, max)     \
  ((b) < 0                                              \
   ? ((a) < 0                                           \
      ? (a) < (max) / (b)                               \
Paul Eggert's avatar
Paul Eggert committed
189 190 191 192 193 194 195 196
      : (b) == -1                                       \
      ? 0                                               \
      : (min) / (b) < (a))                              \
   : (b) == 0                                           \
   ? 0                                                  \
   : ((a) < 0                                           \
      ? (a) < (min) / (b)                               \
      : (max) / (b) < (a)))
Paul Eggert's avatar
Paul Eggert committed
197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222

/* Return 1 if A / B would overflow in [MIN,MAX] arithmetic.
   See above for restrictions.  Do not check for division by zero.  */
#define INT_DIVIDE_RANGE_OVERFLOW(a, b, min, max)       \
  ((min) < 0 && (b) == -1 && (a) < - (max))

/* Return 1 if A % B would overflow in [MIN,MAX] arithmetic.
   See above for restrictions.  Do not check for division by zero.
   Mathematically, % should never overflow, but on x86-like hosts
   INT_MIN % -1 traps, and the C standard permits this, so treat this
   as an overflow too.  */
#define INT_REMAINDER_RANGE_OVERFLOW(a, b, min, max)    \
  INT_DIVIDE_RANGE_OVERFLOW (a, b, min, max)

/* Return 1 if A << B would overflow in [MIN,MAX] arithmetic.
   See above for restrictions.  Here, MIN and MAX are for A only, and B need
   not be of the same type as the other arguments.  The C standard says that
   behavior is undefined for shifts unless 0 <= B < wordwidth, and that when
   A is negative then A << B has undefined behavior and A >> B has
   implementation-defined behavior, but do not check these other
   restrictions.  */
#define INT_LEFT_SHIFT_RANGE_OVERFLOW(a, b, min, max)   \
  ((a) < 0                                              \
   ? (a) < (min) >> (b)                                 \
   : (max) >> (b) < (a))

Paul Eggert's avatar
Paul Eggert committed
223
/* True if __builtin_add_overflow (A, B, P) works when P is non-null.  */
Paul Eggert's avatar
Paul Eggert committed
224 225 226 227 228
#if 5 <= __GNUC__ && !defined __ICC
# define _GL_HAS_BUILTIN_OVERFLOW 1
#else
# define _GL_HAS_BUILTIN_OVERFLOW 0
#endif
Paul Eggert's avatar
Paul Eggert committed
229 230

/* True if __builtin_add_overflow_p (A, B, C) works.  */
Paul Eggert's avatar
Paul Eggert committed
231
#define _GL_HAS_BUILTIN_OVERFLOW_P (7 <= __GNUC__)
Paul Eggert's avatar
Paul Eggert committed
232 233 234 235 236

/* The _GL*_OVERFLOW macros have the same restrictions as the
   *_RANGE_OVERFLOW macros, except that they do not assume that operands
   (e.g., A and B) have the same type as MIN and MAX.  Instead, they assume
   that the result (e.g., A + B) has that type.  */
Paul Eggert's avatar
Paul Eggert committed
237 238 239 240 241 242 243
#if _GL_HAS_BUILTIN_OVERFLOW_P
# define _GL_ADD_OVERFLOW(a, b, min, max)                               \
   __builtin_add_overflow_p (a, b, (__typeof__ ((a) + (b))) 0)
# define _GL_SUBTRACT_OVERFLOW(a, b, min, max)                          \
   __builtin_sub_overflow_p (a, b, (__typeof__ ((a) - (b))) 0)
# define _GL_MULTIPLY_OVERFLOW(a, b, min, max)                          \
   __builtin_mul_overflow_p (a, b, (__typeof__ ((a) * (b))) 0)
Paul Eggert's avatar
Paul Eggert committed
244 245 246 247 248 249 250 251 252 253 254 255 256 257 258
#else
# define _GL_ADD_OVERFLOW(a, b, min, max)                                \
   ((min) < 0 ? INT_ADD_RANGE_OVERFLOW (a, b, min, max)                  \
    : (a) < 0 ? (b) <= (a) + (b)                                         \
    : (b) < 0 ? (a) <= (a) + (b)                                         \
    : (a) + (b) < (b))
# define _GL_SUBTRACT_OVERFLOW(a, b, min, max)                           \
   ((min) < 0 ? INT_SUBTRACT_RANGE_OVERFLOW (a, b, min, max)             \
    : (a) < 0 ? 1                                                        \
    : (b) < 0 ? (a) - (b) <= (a)                                         \
    : (a) < (b))
# define _GL_MULTIPLY_OVERFLOW(a, b, min, max)                           \
   (((min) == 0 && (((a) < 0 && 0 < (b)) || ((b) < 0 && 0 < (a))))       \
    || INT_MULTIPLY_RANGE_OVERFLOW (a, b, min, max))
#endif
Paul Eggert's avatar
Paul Eggert committed
259
#define _GL_DIVIDE_OVERFLOW(a, b, min, max)                             \
Paul Eggert's avatar
Paul Eggert committed
260
  ((min) < 0 ? (b) == _GL_INT_NEGATE_CONVERT (min, 1) && (a) < - (max)  \
Paul Eggert's avatar
Paul Eggert committed
261 262 263
   : (a) < 0 ? (b) <= (a) + (b) - 1                                     \
   : (b) < 0 && (a) + (b) <= (a))
#define _GL_REMAINDER_OVERFLOW(a, b, min, max)                          \
Paul Eggert's avatar
Paul Eggert committed
264
  ((min) < 0 ? (b) == _GL_INT_NEGATE_CONVERT (min, 1) && (a) < - (max)  \
Paul Eggert's avatar
Paul Eggert committed
265 266 267 268 269 270 271 272 273 274 275 276 277 278 279
   : (a) < 0 ? (a) % (b) != ((max) - (b) + 1) % (b)                     \
   : (b) < 0 && ! _GL_UNSIGNED_NEG_MULTIPLE (a, b, max))

/* Return a nonzero value if A is a mathematical multiple of B, where
   A is unsigned, B is negative, and MAX is the maximum value of A's
   type.  A's type must be the same as (A % B)'s type.  Normally (A %
   -B == 0) suffices, but things get tricky if -B would overflow.  */
#define _GL_UNSIGNED_NEG_MULTIPLE(a, b, max)                            \
  (((b) < -_GL_SIGNED_INT_MAXIMUM (b)                                   \
    ? (_GL_SIGNED_INT_MAXIMUM (b) == (max)                              \
       ? (a)                                                            \
       : (a) % (_GL_INT_CONVERT (a, _GL_SIGNED_INT_MAXIMUM (b)) + 1))   \
    : (a) % - (b))                                                      \
   == 0)

Paul Eggert's avatar
Paul Eggert committed
280
/* Check for integer overflow, and report low order bits of answer.
Paul Eggert's avatar
Paul Eggert committed
281 282 283

   The INT_<op>_OVERFLOW macros return 1 if the corresponding C operators
   might not yield numerically correct answers due to arithmetic overflow.
Paul Eggert's avatar
Paul Eggert committed
284 285 286
   The INT_<op>_WRAPV macros compute the low-order bits of the sum,
   difference, and product of two C integers, and return 1 if these
   low-order bits are not numerically correct.
Paul Eggert's avatar
Paul Eggert committed
287
   These macros work correctly on all known practical hosts, and do not rely
Paul Eggert's avatar
Paul Eggert committed
288 289
   on undefined behavior due to signed arithmetic overflow.

Paul Eggert's avatar
Paul Eggert committed
290
   Example usage, assuming A and B are long int:
Paul Eggert's avatar
Paul Eggert committed
291

Paul Eggert's avatar
Paul Eggert committed
292 293 294 295
     if (INT_MULTIPLY_OVERFLOW (a, b))
       printf ("result would overflow\n");
     else
       printf ("result is %ld (no overflow)\n", a * b);
Paul Eggert's avatar
Paul Eggert committed
296

Paul Eggert's avatar
Paul Eggert committed
297 298 299 300 301 302
   Example usage with WRAPV flavor:

     long int result;
     bool overflow = INT_MULTIPLY_WRAPV (a, b, &result);
     printf ("result is %ld (%s)\n", result,
             overflow ? "after overflow" : "no overflow");
Paul Eggert's avatar
Paul Eggert committed
303 304

   Restrictions on these macros:
Paul Eggert's avatar
Paul Eggert committed
305 306 307 308 309 310 311 312

   These macros do not check for all possible numerical problems or
   undefined or unspecified behavior: they do not check for division
   by zero, for bad shift counts, or for shifting negative numbers.

   These macros may evaluate their arguments zero or multiple times, so the
   arguments should not have side effects.

Paul Eggert's avatar
Paul Eggert committed
313
   The WRAPV macros are not constant expressions.  They support only
Paul Eggert's avatar
Paul Eggert committed
314 315 316 317
   +, binary -, and *.  The result type must be either signed, or an
   unsigned type that is 'unsigned int' or wider.  Because the WRAPV
   macros convert the result, the report overflow in different
   circumstances than the OVERFLOW macros do.
Paul Eggert's avatar
Paul Eggert committed
318

Paul Eggert's avatar
Paul Eggert committed
319
   These macros are tuned for their last input argument being a constant.
Paul Eggert's avatar
Paul Eggert committed
320 321 322 323

   Return 1 if the integer expressions A * B, A - B, -A, A * B, A / B,
   A % B, and A << B would overflow, respectively.  */

Paul Eggert's avatar
Paul Eggert committed
324
#define INT_ADD_OVERFLOW(a, b) \
Paul Eggert's avatar
Paul Eggert committed
325
  _GL_BINARY_OP_OVERFLOW (a, b, _GL_ADD_OVERFLOW)
Paul Eggert's avatar
Paul Eggert committed
326
#define INT_SUBTRACT_OVERFLOW(a, b) \
Paul Eggert's avatar
Paul Eggert committed
327
  _GL_BINARY_OP_OVERFLOW (a, b, _GL_SUBTRACT_OVERFLOW)
Paul Eggert's avatar
Paul Eggert committed
328
#if _GL_HAS_BUILTIN_OVERFLOW_P
Paul Eggert's avatar
Paul Eggert committed
329 330 331 332 333
# define INT_NEGATE_OVERFLOW(a) INT_SUBTRACT_OVERFLOW (0, a)
#else
# define INT_NEGATE_OVERFLOW(a) \
   INT_NEGATE_RANGE_OVERFLOW (a, _GL_INT_MINIMUM (a), _GL_INT_MAXIMUM (a))
#endif
Paul Eggert's avatar
Paul Eggert committed
334
#define INT_MULTIPLY_OVERFLOW(a, b) \
Paul Eggert's avatar
Paul Eggert committed
335 336 337 338 339 340 341 342 343 344 345 346
  _GL_BINARY_OP_OVERFLOW (a, b, _GL_MULTIPLY_OVERFLOW)
#define INT_DIVIDE_OVERFLOW(a, b) \
  _GL_BINARY_OP_OVERFLOW (a, b, _GL_DIVIDE_OVERFLOW)
#define INT_REMAINDER_OVERFLOW(a, b) \
  _GL_BINARY_OP_OVERFLOW (a, b, _GL_REMAINDER_OVERFLOW)
#define INT_LEFT_SHIFT_OVERFLOW(a, b) \
  INT_LEFT_SHIFT_RANGE_OVERFLOW (a, b, \
                                 _GL_INT_MINIMUM (a), _GL_INT_MAXIMUM (a))

/* Return 1 if the expression A <op> B would overflow,
   where OP_RESULT_OVERFLOW (A, B, MIN, MAX) does the actual test,
   assuming MIN and MAX are the minimum and maximum for the result type.
Paul Eggert's avatar
Paul Eggert committed
347
   Arguments should be free of side effects.  */
Paul Eggert's avatar
Paul Eggert committed
348 349
#define _GL_BINARY_OP_OVERFLOW(a, b, op_result_overflow)        \
  op_result_overflow (a, b,                                     \
Paul Eggert's avatar
Paul Eggert committed
350 351
                      _GL_INT_MINIMUM (_GL_INT_CONVERT (a, b)), \
                      _GL_INT_MAXIMUM (_GL_INT_CONVERT (a, b)))
Paul Eggert's avatar
Paul Eggert committed
352

Paul Eggert's avatar
Paul Eggert committed
353
/* Store the low-order bits of A + B, A - B, A * B, respectively, into *R.
Paul Eggert's avatar
Paul Eggert committed
354 355
   Return 1 if the result overflows.  See above for restrictions.  */
#define INT_ADD_WRAPV(a, b, r) \
Paul Eggert's avatar
Paul Eggert committed
356 357
  _GL_INT_OP_WRAPV (a, b, r, +, __builtin_add_overflow, \
                    _GL_INT_ADD_RANGE_OVERFLOW)
Paul Eggert's avatar
Paul Eggert committed
358
#define INT_SUBTRACT_WRAPV(a, b, r) \
Paul Eggert's avatar
Paul Eggert committed
359 360
  _GL_INT_OP_WRAPV (a, b, r, -, __builtin_sub_overflow, \
                    _GL_INT_SUBTRACT_RANGE_OVERFLOW)
Paul Eggert's avatar
Paul Eggert committed
361
#define INT_MULTIPLY_WRAPV(a, b, r) \
Paul Eggert's avatar
Paul Eggert committed
362 363 364 365 366 367 368 369 370
   _GL_INT_OP_WRAPV (a, b, r, *, _GL_BUILTIN_MUL_OVERFLOW, \
                     _GL_INT_MULTIPLY_RANGE_OVERFLOW)

/* Like __builtin_mul_overflow, but work around GCC bug 91450.  */
#define _GL_BUILTIN_MUL_OVERFLOW(a, b, r) \
  ((!_GL_SIGNED_TYPE_OR_EXPR (*(r)) && EXPR_SIGNED (a) && EXPR_SIGNED (b) \
    && _GL_INT_MULTIPLY_RANGE_OVERFLOW (a, b, 0, (__typeof__ (*(r))) -1)) \
   ? ((void) __builtin_mul_overflow (a, b, r), 1) \
   : __builtin_mul_overflow (a, b, r))
Paul Eggert's avatar
Paul Eggert committed
371 372 373 374 375 376 377 378 379

/* Nonzero if this compiler has GCC bug 68193 or Clang bug 25390.  See:
   https://gcc.gnu.org/bugzilla/show_bug.cgi?id=68193
   https://llvm.org/bugs/show_bug.cgi?id=25390
   For now, assume all versions of GCC-like compilers generate bogus
   warnings for _Generic.  This matters only for older compilers that
   lack __builtin_add_overflow.  */
#if __GNUC__
# define _GL__GENERIC_BOGUS 1
Paul Eggert's avatar
Paul Eggert committed
380
#else
Paul Eggert's avatar
Paul Eggert committed
381 382
# define _GL__GENERIC_BOGUS 0
#endif
Paul Eggert's avatar
Paul Eggert committed
383

Paul Eggert's avatar
Paul Eggert committed
384 385 386 387
/* Store the low-order bits of A <op> B into *R, where OP specifies
   the operation.  BUILTIN is the builtin operation, and OVERFLOW the
   overflow predicate.  Return 1 if the result overflows.  See above
   for restrictions.  */
Paul Eggert's avatar
Paul Eggert committed
388
#if _GL_HAS_BUILTIN_OVERFLOW
Paul Eggert's avatar
Paul Eggert committed
389 390 391 392 393 394
# define _GL_INT_OP_WRAPV(a, b, r, op, builtin, overflow) builtin (a, b, r)
#elif 201112 <= __STDC_VERSION__ && !_GL__GENERIC_BOGUS
# define _GL_INT_OP_WRAPV(a, b, r, op, builtin, overflow) \
   (_Generic \
    (*(r), \
     signed char: \
Paul Eggert's avatar
Paul Eggert committed
395
       _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned int, \
Paul Eggert's avatar
Paul Eggert committed
396
                        signed char, SCHAR_MIN, SCHAR_MAX), \
Paul Eggert's avatar
Paul Eggert committed
397 398 399
     unsigned char: \
       _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned int, \
                        unsigned char, 0, UCHAR_MAX), \
Paul Eggert's avatar
Paul Eggert committed
400
     short int: \
Paul Eggert's avatar
Paul Eggert committed
401
       _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned int, \
Paul Eggert's avatar
Paul Eggert committed
402
                        short int, SHRT_MIN, SHRT_MAX), \
Paul Eggert's avatar
Paul Eggert committed
403 404 405
     unsigned short int: \
       _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned int, \
                        unsigned short int, 0, USHRT_MAX), \
Paul Eggert's avatar
Paul Eggert committed
406 407 408
     int: \
       _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned int, \
                        int, INT_MIN, INT_MAX), \
Paul Eggert's avatar
Paul Eggert committed
409 410 411
     unsigned int: \
       _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned int, \
                        unsigned int, 0, UINT_MAX), \
Paul Eggert's avatar
Paul Eggert committed
412 413 414
     long int: \
       _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned long int, \
                        long int, LONG_MIN, LONG_MAX), \
Paul Eggert's avatar
Paul Eggert committed
415 416 417
     unsigned long int: \
       _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned long int, \
                        unsigned long int, 0, ULONG_MAX), \
Paul Eggert's avatar
Paul Eggert committed
418 419
     long long int: \
       _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned long long int, \
Paul Eggert's avatar
Paul Eggert committed
420 421 422 423
                        long long int, LLONG_MIN, LLONG_MAX),
     unsigned long long int: \
       _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned long long int, \
                        unsigned long long int, ULLONG_MIN, ULLONG_MAX)))
Paul Eggert's avatar
Paul Eggert committed
424
#else
Paul Eggert's avatar
Paul Eggert committed
425 426 427 428 429
/* This fallback implementation uses _GL_SIGNED_TYPE_OR_EXPR, and so
   may guess wrong on some non-GNU pre-C11 compilers when the type of
   *R is unsigned char or unsigned short.  This is why the
   documentation for INT_ADD_WRAPV says that the result type, if
   unsigned, should be unsigned int or wider.  */
Paul Eggert's avatar
Paul Eggert committed
430 431
# define _GL_INT_OP_WRAPV(a, b, r, op, builtin, overflow) \
   (sizeof *(r) == sizeof (signed char) \
Paul Eggert's avatar
Paul Eggert committed
432 433 434 435 436
    ? (_GL_SIGNED_TYPE_OR_EXPR (*(r)) \
       ? _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned int, \
                          signed char, SCHAR_MIN, SCHAR_MAX) \
       : _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned int, \
                          unsigned char, 0, UCHAR_MAX)) \
Paul Eggert's avatar
Paul Eggert committed
437
    : sizeof *(r) == sizeof (short int) \
Paul Eggert's avatar
Paul Eggert committed
438 439 440 441 442
    ? (_GL_SIGNED_TYPE_OR_EXPR (*(r)) \
       ? _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned int, \
                          short int, SHRT_MIN, SHRT_MAX) \
       : _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned int, \
                          unsigned short int, 0, USHRT_MAX)) \
Paul Eggert's avatar
Paul Eggert committed
443
    : sizeof *(r) == sizeof (int) \
Paul Eggert's avatar
Paul Eggert committed
444 445 446 447 448
    ? (EXPR_SIGNED (*(r)) \
       ? _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned int, \
                          int, INT_MIN, INT_MAX) \
       : _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned int, \
                          unsigned int, 0, UINT_MAX)) \
Paul Eggert's avatar
Paul Eggert committed
449
    : _GL_INT_OP_WRAPV_LONGISH(a, b, r, op, overflow))
Paul Eggert's avatar
Paul Eggert committed
450
# ifdef LLONG_MAX
Paul Eggert's avatar
Paul Eggert committed
451 452
#  define _GL_INT_OP_WRAPV_LONGISH(a, b, r, op, overflow) \
    (sizeof *(r) == sizeof (long int) \
Paul Eggert's avatar
Paul Eggert committed
453 454 455 456 457 458 459 460 461 462
     ? (EXPR_SIGNED (*(r)) \
        ? _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned long int, \
                           long int, LONG_MIN, LONG_MAX) \
        : _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned long int, \
                           unsigned long int, 0, ULONG_MAX)) \
     : (EXPR_SIGNED (*(r)) \
        ? _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned long long int, \
                           long long int, LLONG_MIN, LLONG_MAX) \
        : _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned long long int, \
                           unsigned long long int, 0, ULLONG_MAX)))
Paul Eggert's avatar
Paul Eggert committed
463
# else
Paul Eggert's avatar
Paul Eggert committed
464
#  define _GL_INT_OP_WRAPV_LONGISH(a, b, r, op, overflow) \
Paul Eggert's avatar
Paul Eggert committed
465 466 467 468 469
    (EXPR_SIGNED (*(r)) \
     ? _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned long int, \
                        long int, LONG_MIN, LONG_MAX) \
     : _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned long int, \
                        unsigned long int, 0, ULONG_MAX))
Paul Eggert's avatar
Paul Eggert committed
470 471 472
# endif
#endif

Paul Eggert's avatar
Paul Eggert committed
473 474
/* Store the low-order bits of A <op> B into *R, where the operation
   is given by OP.  Use the unsigned type UT for calculation to avoid
Paul Eggert's avatar
Paul Eggert committed
475 476
   overflow problems.  *R's type is T, with extrema TMIN and TMAX.
   T must be a signed integer type.  Return 1 if the result overflows.  */
Paul Eggert's avatar
Paul Eggert committed
477
#define _GL_INT_OP_CALC(a, b, r, op, overflow, ut, t, tmin, tmax) \
Paul Eggert's avatar
Paul Eggert committed
478
  (overflow (a, b, tmin, tmax) \
Paul Eggert's avatar
Paul Eggert committed
479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494
   ? (*(r) = _GL_INT_OP_WRAPV_VIA_UNSIGNED (a, b, op, ut, t), 1) \
   : (*(r) = _GL_INT_OP_WRAPV_VIA_UNSIGNED (a, b, op, ut, t), 0))

/* Return the low-order bits of A <op> B, where the operation is given
   by OP.  Use the unsigned type UT for calculation to avoid undefined
   behavior on signed integer overflow, and convert the result to type T.
   UT is at least as wide as T and is no narrower than unsigned int,
   T is two's complement, and there is no padding or trap representations.
   Assume that converting UT to T yields the low-order bits, as is
   done in all known two's-complement C compilers.  E.g., see:
   https://gcc.gnu.org/onlinedocs/gcc/Integers-implementation.html

   According to the C standard, converting UT to T yields an
   implementation-defined result or signal for values outside T's
   range.  However, code that works around this theoretical problem
   runs afoul of a compiler bug in Oracle Studio 12.3 x86.  See:
Paul Eggert's avatar
Paul Eggert committed
495
   https://lists.gnu.org/r/bug-gnulib/2017-04/msg00049.html
Paul Eggert's avatar
Paul Eggert committed
496 497 498 499 500
   As the compiler bug is real, don't try to work around the
   theoretical problem.  */

#define _GL_INT_OP_WRAPV_VIA_UNSIGNED(a, b, op, ut, t) \
  ((t) ((ut) (a) op (ut) (b)))
Paul Eggert's avatar
Paul Eggert committed
501

Paul Eggert's avatar
Paul Eggert committed
502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554
/* Return true if the numeric values A + B, A - B, A * B fall outside
   the range TMIN..TMAX.  Arguments should be integer expressions
   without side effects.  TMIN should be signed and nonpositive.
   TMAX should be positive, and should be signed unless TMIN is zero.  */
#define _GL_INT_ADD_RANGE_OVERFLOW(a, b, tmin, tmax) \
  ((b) < 0 \
   ? (((tmin) \
       ? ((EXPR_SIGNED (_GL_INT_CONVERT (a, (tmin) - (b))) || (b) < (tmin)) \
          && (a) < (tmin) - (b)) \
       : (a) <= -1 - (b)) \
      || ((EXPR_SIGNED (a) ? 0 <= (a) : (tmax) < (a)) && (tmax) < (a) + (b))) \
   : (a) < 0 \
   ? (((tmin) \
       ? ((EXPR_SIGNED (_GL_INT_CONVERT (b, (tmin) - (a))) || (a) < (tmin)) \
          && (b) < (tmin) - (a)) \
       : (b) <= -1 - (a)) \
      || ((EXPR_SIGNED (_GL_INT_CONVERT (a, b)) || (tmax) < (b)) \
          && (tmax) < (a) + (b))) \
   : (tmax) < (b) || (tmax) - (b) < (a))
#define _GL_INT_SUBTRACT_RANGE_OVERFLOW(a, b, tmin, tmax) \
  (((a) < 0) == ((b) < 0) \
   ? ((a) < (b) \
      ? !(tmin) || -1 - (tmin) < (b) - (a) - 1 \
      : (tmax) < (a) - (b)) \
   : (a) < 0 \
   ? ((!EXPR_SIGNED (_GL_INT_CONVERT ((a) - (tmin), b)) && (a) - (tmin) < 0) \
      || (a) - (tmin) < (b)) \
   : ((! (EXPR_SIGNED (_GL_INT_CONVERT (tmax, b)) \
          && EXPR_SIGNED (_GL_INT_CONVERT ((tmax) + (b), a))) \
       && (tmax) <= -1 - (b)) \
      || (tmax) + (b) < (a)))
#define _GL_INT_MULTIPLY_RANGE_OVERFLOW(a, b, tmin, tmax) \
  ((b) < 0 \
   ? ((a) < 0 \
      ? (EXPR_SIGNED (_GL_INT_CONVERT (tmax, b)) \
         ? (a) < (tmax) / (b) \
         : ((INT_NEGATE_OVERFLOW (b) \
             ? _GL_INT_CONVERT (b, tmax) >> (TYPE_WIDTH (b) - 1) \
             : (tmax) / -(b)) \
            <= -1 - (a))) \
      : INT_NEGATE_OVERFLOW (_GL_INT_CONVERT (b, tmin)) && (b) == -1 \
      ? (EXPR_SIGNED (a) \
	 ? 0 < (a) + (tmin) \
	 : 0 < (a) && -1 - (tmin) < (a) - 1) \
      : (tmin) / (b) < (a)) \
   : (b) == 0 \
   ? 0 \
   : ((a) < 0 \
      ? (INT_NEGATE_OVERFLOW (_GL_INT_CONVERT (a, tmin)) && (a) == -1 \
         ? (EXPR_SIGNED (b) ? 0 < (b) + (tmin) : -1 - (tmin) < (b) - 1) \
         : (tmin) / (a) < (b)) \
      : (tmax) / (b) < (a)))

Paul Eggert's avatar
Paul Eggert committed
555
#endif /* _GL_INTPROPS_H */