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

3
   Copyright (C) 2001-2020 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__) \
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 224
/* True if __builtin_add_overflow (A, B, P) and __builtin_sub_overflow
   (A, B, P) work when P is non-null.  */
Paul Eggert's avatar
Paul Eggert committed
225
#if 5 <= __GNUC__ && !defined __ICC
Paul Eggert's avatar
Paul Eggert committed
226
# define _GL_HAS_BUILTIN_ADD_OVERFLOW 1
Paul Eggert's avatar
Paul Eggert committed
227 228
#elif defined __has_builtin
# define _GL_HAS_BUILTIN_ADD_OVERFLOW __has_builtin (__builtin_add_overflow)
Paul Eggert's avatar
Paul Eggert committed
229 230 231 232 233 234 235 236
#else
# define _GL_HAS_BUILTIN_ADD_OVERFLOW 0
#endif

/* True if __builtin_mul_overflow (A, B, P) works when P is non-null.  */
#ifdef __clang__
/* Work around Clang bug <https://bugs.llvm.org/show_bug.cgi?id=16404>.  */
# define _GL_HAS_BUILTIN_MUL_OVERFLOW 0
Paul Eggert's avatar
Paul Eggert committed
237
#else
Paul Eggert's avatar
Paul Eggert committed
238
# define _GL_HAS_BUILTIN_MUL_OVERFLOW _GL_HAS_BUILTIN_ADD_OVERFLOW
Paul Eggert's avatar
Paul Eggert committed
239
#endif
Paul Eggert's avatar
Paul Eggert committed
240

Paul Eggert's avatar
Paul Eggert committed
241 242
/* True if __builtin_add_overflow_p (A, B, C) works, and similarly for
   __builtin_mul_overflow_p and __builtin_mul_overflow_p.  */
Paul Eggert's avatar
Paul Eggert committed
243
#define _GL_HAS_BUILTIN_OVERFLOW_P (7 <= __GNUC__)
Paul Eggert's avatar
Paul Eggert committed
244 245 246 247 248

/* 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
249 250 251 252 253 254 255
#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
256 257 258 259 260 261 262 263 264 265 266 267 268 269 270
#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
271
#define _GL_DIVIDE_OVERFLOW(a, b, min, max)                             \
Paul Eggert's avatar
Paul Eggert committed
272
  ((min) < 0 ? (b) == _GL_INT_NEGATE_CONVERT (min, 1) && (a) < - (max)  \
Paul Eggert's avatar
Paul Eggert committed
273 274 275
   : (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
276
  ((min) < 0 ? (b) == _GL_INT_NEGATE_CONVERT (min, 1) && (a) < - (max)  \
Paul Eggert's avatar
Paul Eggert committed
277 278 279 280 281 282 283 284 285 286 287 288 289 290 291
   : (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
292
/* Check for integer overflow, and report low order bits of answer.
Paul Eggert's avatar
Paul Eggert committed
293 294 295

   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
296 297 298
   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
299
   These macros work correctly on all known practical hosts, and do not rely
Paul Eggert's avatar
Paul Eggert committed
300 301
   on undefined behavior due to signed arithmetic overflow.

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

Paul Eggert's avatar
Paul Eggert committed
304 305 306 307
     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
308

Paul Eggert's avatar
Paul Eggert committed
309 310 311 312 313 314
   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
315 316

   Restrictions on these macros:
Paul Eggert's avatar
Paul Eggert committed
317 318 319 320 321 322 323 324

   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
325
   The WRAPV macros are not constant expressions.  They support only
Paul Eggert's avatar
Paul Eggert committed
326 327 328
   +, binary -, and *.  Because the WRAPV macros convert the result,
   they report overflow in different circumstances than the OVERFLOW
   macros do.
Paul Eggert's avatar
Paul Eggert committed
329

Paul Eggert's avatar
Paul Eggert committed
330
   These macros are tuned for their last input argument being a constant.
Paul Eggert's avatar
Paul Eggert committed
331 332 333 334

   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
335
#define INT_ADD_OVERFLOW(a, b) \
Paul Eggert's avatar
Paul Eggert committed
336
  _GL_BINARY_OP_OVERFLOW (a, b, _GL_ADD_OVERFLOW)
Paul Eggert's avatar
Paul Eggert committed
337
#define INT_SUBTRACT_OVERFLOW(a, b) \
Paul Eggert's avatar
Paul Eggert committed
338
  _GL_BINARY_OP_OVERFLOW (a, b, _GL_SUBTRACT_OVERFLOW)
Paul Eggert's avatar
Paul Eggert committed
339
#if _GL_HAS_BUILTIN_OVERFLOW_P
Paul Eggert's avatar
Paul Eggert committed
340 341 342 343 344
# 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
345
#define INT_MULTIPLY_OVERFLOW(a, b) \
Paul Eggert's avatar
Paul Eggert committed
346 347 348 349 350 351 352 353 354 355 356 357
  _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
358
   Arguments should be free of side effects.  */
Paul Eggert's avatar
Paul Eggert committed
359 360
#define _GL_BINARY_OP_OVERFLOW(a, b, op_result_overflow)        \
  op_result_overflow (a, b,                                     \
Paul Eggert's avatar
Paul Eggert committed
361 362
                      _GL_INT_MINIMUM (_GL_INT_CONVERT (a, b)), \
                      _GL_INT_MAXIMUM (_GL_INT_CONVERT (a, b)))
Paul Eggert's avatar
Paul Eggert committed
363

Paul Eggert's avatar
Paul Eggert committed
364
/* Store the low-order bits of A + B, A - B, A * B, respectively, into *R.
Paul Eggert's avatar
Paul Eggert committed
365
   Return 1 if the result overflows.  See above for restrictions.  */
Paul Eggert's avatar
Paul Eggert committed
366 367 368 369 370 371 372 373 374 375
#if _GL_HAS_BUILTIN_ADD_OVERFLOW
# define INT_ADD_WRAPV(a, b, r) __builtin_add_overflow (a, b, r)
# define INT_SUBTRACT_WRAPV(a, b, r) __builtin_sub_overflow (a, b, r)
#else
# define INT_ADD_WRAPV(a, b, r) \
   _GL_INT_OP_WRAPV (a, b, r, +, _GL_INT_ADD_RANGE_OVERFLOW)
# define INT_SUBTRACT_WRAPV(a, b, r) \
   _GL_INT_OP_WRAPV (a, b, r, -, _GL_INT_SUBTRACT_RANGE_OVERFLOW)
#endif
#if _GL_HAS_BUILTIN_MUL_OVERFLOW
Paul Eggert's avatar
Paul Eggert committed
376 377 378 379 380 381 382 383 384 385 386
# if (9 < __GNUC__ + (3 <= __GNUC_MINOR__) \
      || (__GNUC__ == 8 && 4 <= __GNUC_MINOR__))
#  define INT_MULTIPLY_WRAPV(a, b, r) __builtin_mul_overflow (a, b, r)
# else
   /* Work around GCC bug 91450.  */
#  define INT_MULTIPLY_WRAPV(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))
# endif
Paul Eggert's avatar
Paul Eggert committed
387 388 389 390
#else
# define INT_MULTIPLY_WRAPV(a, b, r) \
   _GL_INT_OP_WRAPV (a, b, r, *, _GL_INT_MULTIPLY_RANGE_OVERFLOW)
#endif
Paul Eggert's avatar
Paul Eggert committed
391 392 393 394 395

/* 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
Paul Eggert's avatar
Paul Eggert committed
396 397
   warnings for _Generic.  This matters only for compilers that
   lack relevant builtins.  */
Paul Eggert's avatar
Paul Eggert committed
398 399
#if __GNUC__
# define _GL__GENERIC_BOGUS 1
Paul Eggert's avatar
Paul Eggert committed
400
#else
Paul Eggert's avatar
Paul Eggert committed
401 402
# define _GL__GENERIC_BOGUS 0
#endif
Paul Eggert's avatar
Paul Eggert committed
403

Paul Eggert's avatar
Paul Eggert committed
404
/* Store the low-order bits of A <op> B into *R, where OP specifies
Paul Eggert's avatar
Paul Eggert committed
405 406 407 408
   the operation and OVERFLOW the overflow predicate.  Return 1 if the
   result overflows.  See above for restrictions.  */
#if 201112 <= __STDC_VERSION__ && !_GL__GENERIC_BOGUS
# define _GL_INT_OP_WRAPV(a, b, r, op, overflow) \
Paul Eggert's avatar
Paul Eggert committed
409 410 411
   (_Generic \
    (*(r), \
     signed char: \
Paul Eggert's avatar
Paul Eggert committed
412
       _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned int, \
Paul Eggert's avatar
Paul Eggert committed
413
                        signed char, SCHAR_MIN, SCHAR_MAX), \
Paul Eggert's avatar
Paul Eggert committed
414 415 416
     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
417
     short int: \
Paul Eggert's avatar
Paul Eggert committed
418
       _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned int, \
Paul Eggert's avatar
Paul Eggert committed
419
                        short int, SHRT_MIN, SHRT_MAX), \
Paul Eggert's avatar
Paul Eggert committed
420 421 422
     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
423 424 425
     int: \
       _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned int, \
                        int, INT_MIN, INT_MAX), \
Paul Eggert's avatar
Paul Eggert committed
426 427 428
     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
429 430 431
     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
432 433 434
     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
435 436
     long long int: \
       _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned long long int, \
Paul Eggert's avatar
Paul Eggert committed
437
                        long long int, LLONG_MIN, LLONG_MAX), \
Paul Eggert's avatar
Paul Eggert committed
438 439
     unsigned long long int: \
       _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned long long int, \
Paul Eggert's avatar
Paul Eggert committed
440
                        unsigned long long int, 0, ULLONG_MAX)))
Paul Eggert's avatar
Paul Eggert committed
441
#else
Paul Eggert's avatar
Paul Eggert committed
442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462
/* Store the low-order bits of A <op> B into *R, where OP specifies
   the operation and OVERFLOW the overflow predicate.  If *R is
   signed, its type is ST with bounds SMIN..SMAX; otherwise its type
   is UT with bounds U..UMAX.  ST and UT are narrower than int.
   Return 1 if the result overflows.  See above for restrictions.  */
# if _GL_HAVE___TYPEOF__
#  define _GL_INT_OP_WRAPV_SMALLISH(a,b,r,op,overflow,st,smin,smax,ut,umax) \
    (TYPE_SIGNED (__typeof__ (*(r))) \
     ? _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned int, st, smin, smax) \
     : _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned int, ut, 0, umax))
# else
#  define _GL_INT_OP_WRAPV_SMALLISH(a,b,r,op,overflow,st,smin,smax,ut,umax) \
    (overflow (a, b, smin, smax) \
     ? (overflow (a, b, 0, umax) \
        ? (*(r) = _GL_INT_OP_WRAPV_VIA_UNSIGNED (a,b,op,unsigned,st), 1) \
        : (*(r) = _GL_INT_OP_WRAPV_VIA_UNSIGNED (a,b,op,unsigned,st)) < 0) \
     : (overflow (a, b, 0, umax) \
        ? (*(r) = _GL_INT_OP_WRAPV_VIA_UNSIGNED (a,b,op,unsigned,st)) >= 0 \
        : (*(r) = _GL_INT_OP_WRAPV_VIA_UNSIGNED (a,b,op,unsigned,st), 0)))
# endif

Paul Eggert's avatar
Paul Eggert committed
463
# define _GL_INT_OP_WRAPV(a, b, r, op, overflow) \
Paul Eggert's avatar
Paul Eggert committed
464
   (sizeof *(r) == sizeof (signed char) \
Paul Eggert's avatar
Paul Eggert committed
465 466 467
    ? _GL_INT_OP_WRAPV_SMALLISH (a, b, r, op, overflow, \
                                 signed char, SCHAR_MIN, SCHAR_MAX, \
                                 unsigned char, UCHAR_MAX) \
Paul Eggert's avatar
Paul Eggert committed
468
    : sizeof *(r) == sizeof (short int) \
Paul Eggert's avatar
Paul Eggert committed
469 470 471
    ? _GL_INT_OP_WRAPV_SMALLISH (a, b, r, op, overflow, \
                                 short int, SHRT_MIN, SHRT_MAX, \
                                 unsigned short int, USHRT_MAX) \
Paul Eggert's avatar
Paul Eggert committed
472
    : sizeof *(r) == sizeof (int) \
Paul Eggert's avatar
Paul Eggert committed
473 474 475 476 477
    ? (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
478
    : _GL_INT_OP_WRAPV_LONGISH(a, b, r, op, overflow))
Paul Eggert's avatar
Paul Eggert committed
479
# ifdef LLONG_MAX
Paul Eggert's avatar
Paul Eggert committed
480 481
#  define _GL_INT_OP_WRAPV_LONGISH(a, b, r, op, overflow) \
    (sizeof *(r) == sizeof (long int) \
Paul Eggert's avatar
Paul Eggert committed
482 483 484 485 486 487 488 489 490 491
     ? (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
492
# else
Paul Eggert's avatar
Paul Eggert committed
493
#  define _GL_INT_OP_WRAPV_LONGISH(a, b, r, op, overflow) \
Paul Eggert's avatar
Paul Eggert committed
494 495 496 497 498
    (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
499 500 501
# endif
#endif

Paul Eggert's avatar
Paul Eggert committed
502 503
/* 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
504 505
   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
506
#define _GL_INT_OP_CALC(a, b, r, op, overflow, ut, t, tmin, tmax) \
Paul Eggert's avatar
Paul Eggert committed
507
  (overflow (a, b, tmin, tmax) \
Paul Eggert's avatar
Paul Eggert committed
508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523
   ? (*(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
524
   https://lists.gnu.org/r/bug-gnulib/2017-04/msg00049.html
Paul Eggert's avatar
Paul Eggert committed
525 526 527 528 529
   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
530

Paul Eggert's avatar
Paul Eggert committed
531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572
/* 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) \
Paul Eggert's avatar
Paul Eggert committed
573 574
         ? 0 < (a) + (tmin) \
         : 0 < (a) && -1 - (tmin) < (a) - 1) \
Paul Eggert's avatar
Paul Eggert committed
575 576 577 578 579 580 581 582 583
      : (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
584
#endif /* _GL_INTPROPS_H */