intprops.h 26.3 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 28 29 30 31 32 33 34 35 36
/* If the compiler lacks __has_builtin, define it well enough for this
   source file only.  */
#ifndef __has_builtin
# define __has_builtin(x) _GL_HAS_##x
# if 5 <= __GNUC__ && !defined __ICC
#  define _GL_HAS___builtin_add_overflow 1
# else
#  define _GL_HAS___builtin_add_overflow 0
# endif
# define _GL_TEMPDEF___has_builtin
#endif

Paul Eggert's avatar
Paul Eggert committed
37 38 39
/* 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
40

Paul Eggert's avatar
Paul Eggert committed
41
/* 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
42
   <https://lists.gnu.org/r/bug-gnulib/2011-05/msg00406.html>.  */
Paul Eggert's avatar
Paul Eggert committed
43
#define _GL_INT_NEGATE_CONVERT(e, v) ((1 ? 0 : (e)) - (v))
Paul Eggert's avatar
Paul Eggert committed
44

Paul Eggert's avatar
Paul Eggert committed
45 46 47 48 49
/* 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
50
#define TYPE_IS_INTEGER(t) ((t) 1.5 == 1)
Paul Eggert's avatar
Paul Eggert committed
51

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

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

Paul Eggert's avatar
Paul Eggert committed
59

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

Paul Eggert's avatar
Paul Eggert committed
62
/* The width in bits of the integer type or expression T.
Paul Eggert's avatar
Paul Eggert committed
63
   Do not evaluate T.
Paul Eggert's avatar
Paul Eggert committed
64 65 66
   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
67
/* The maximum and minimum values for the integer type T.  */
Paul Eggert's avatar
Paul Eggert committed
68
#define TYPE_MINIMUM(t) ((t) ~ TYPE_MAXIMUM (t))
Paul Eggert's avatar
Paul Eggert committed
69 70 71
#define TYPE_MAXIMUM(t)                                                 \
  ((t) (! TYPE_SIGNED (t)                                               \
        ? (t) -1                                                        \
Paul Eggert's avatar
Paul Eggert committed
72
        : ((((t) 1 << (TYPE_WIDTH (t) - 2)) - 1) * 2 + 1)))
Paul Eggert's avatar
Paul Eggert committed
73

Paul Eggert's avatar
Paul Eggert committed
74
/* The maximum and minimum values for the type of the expression E,
Paul Eggert's avatar
Paul Eggert committed
75
   after integer promotion.  E is not evaluated.  */
Paul Eggert's avatar
Paul Eggert committed
76
#define _GL_INT_MINIMUM(e)                                              \
Paul Eggert's avatar
Paul Eggert committed
77
  (EXPR_SIGNED (e)                                                      \
Paul Eggert's avatar
Paul Eggert committed
78
   ? ~ _GL_SIGNED_INT_MAXIMUM (e)                                       \
Paul Eggert's avatar
Paul Eggert committed
79 80
   : _GL_INT_CONVERT (e, 0))
#define _GL_INT_MAXIMUM(e)                                              \
Paul Eggert's avatar
Paul Eggert committed
81
  (EXPR_SIGNED (e)                                                      \
Paul Eggert's avatar
Paul Eggert committed
82
   ? _GL_SIGNED_INT_MAXIMUM (e)                                         \
Paul Eggert's avatar
Paul Eggert committed
83
   : _GL_INT_NEGATE_CONVERT (e, 1))
Paul Eggert's avatar
Paul Eggert committed
84
#define _GL_SIGNED_INT_MAXIMUM(e)                                       \
Paul Eggert's avatar
Paul Eggert committed
85
  (((_GL_INT_CONVERT (e, 1) << (TYPE_WIDTH ((e) + 0) - 2)) - 1) * 2 + 1)
Paul Eggert's avatar
Paul Eggert committed
86

Paul Eggert's avatar
Paul Eggert committed
87 88 89 90 91 92
/* 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
93 94 95
/* 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
96
   This assumption is tested by the intprops-tests module.  */
Paul Eggert's avatar
Paul Eggert committed
97

Paul Eggert's avatar
Paul Eggert committed
98
/* Does the __typeof__ keyword work?  This could be done by
Paul Eggert's avatar
Paul Eggert committed
99
   'configure', but for now it's easier to do it by hand.  */
Paul Eggert's avatar
Paul Eggert committed
100 101
#if (2 <= __GNUC__ \
     || (1210 <= __IBMC__ && defined __IBM__TYPEOF__) \
Paul Eggert's avatar
Paul Eggert committed
102
     || (0x5110 <= __SUNPRO_C && !__STDC__))
Paul Eggert's avatar
Paul Eggert committed
103 104 105 106 107 108 109 110 111 112 113 114 115
# 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
116 117 118 119

/* 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
120
#define INT_BITS_STRLEN_BOUND(b) (((b) * 146 + 484) / 485)
Paul Eggert's avatar
Paul Eggert committed
121 122 123

/* 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
124 125
   a minus sign if needed.

Paul Eggert's avatar
Paul Eggert committed
126 127
   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
128 129
   applied to unsigned types of size 2, 4, 16, ... bytes.  */
#define INT_STRLEN_BOUND(t)                                     \
Paul Eggert's avatar
Paul Eggert committed
130
  (INT_BITS_STRLEN_BOUND (TYPE_WIDTH (t) - _GL_SIGNED_TYPE_OR_EXPR (t)) \
Paul Eggert's avatar
Paul Eggert committed
131
   + _GL_SIGNED_TYPE_OR_EXPR (t))
Paul Eggert's avatar
Paul Eggert committed
132 133 134

/* Bound on buffer size needed to represent an integer type or expression T,
   including the terminating null.  */
Paul Eggert's avatar
Paul Eggert committed
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 182 183 184 185 186 187 188 189 190 191 192 193
#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
194 195
   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
196
   <https://lists.gnu.org/r/bug-gnulib/2011-05/msg00401.html>.  */
Paul Eggert's avatar
Paul Eggert committed
197 198 199 200
#define INT_MULTIPLY_RANGE_OVERFLOW(a, b, min, max)     \
  ((b) < 0                                              \
   ? ((a) < 0                                           \
      ? (a) < (max) / (b)                               \
Paul Eggert's avatar
Paul Eggert committed
201 202 203 204 205 206 207 208
      : (b) == -1                                       \
      ? 0                                               \
      : (min) / (b) < (a))                              \
   : (b) == 0                                           \
   ? 0                                                  \
   : ((a) < 0                                           \
      ? (a) < (min) / (b)                               \
      : (max) / (b) < (a)))
Paul Eggert's avatar
Paul Eggert committed
209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234

/* 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
235 236 237 238 239 240 241 242 243 244 245 246
/* True if __builtin_add_overflow (A, B, P) and __builtin_sub_overflow
   (A, B, P) work when P is non-null.  */
#if __has_builtin (__builtin_add_overflow)
# define _GL_HAS_BUILTIN_ADD_OVERFLOW 1
#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
247
#else
Paul Eggert's avatar
Paul Eggert committed
248
# define _GL_HAS_BUILTIN_MUL_OVERFLOW _GL_HAS_BUILTIN_ADD_OVERFLOW
Paul Eggert's avatar
Paul Eggert committed
249
#endif
Paul Eggert's avatar
Paul Eggert committed
250

Paul Eggert's avatar
Paul Eggert committed
251 252
/* 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
253
#define _GL_HAS_BUILTIN_OVERFLOW_P (7 <= __GNUC__)
Paul Eggert's avatar
Paul Eggert committed
254 255 256 257 258

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

   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
306 307 308
   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
309
   These macros work correctly on all known practical hosts, and do not rely
Paul Eggert's avatar
Paul Eggert committed
310 311
   on undefined behavior due to signed arithmetic overflow.

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

Paul Eggert's avatar
Paul Eggert committed
314 315 316 317
     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
318

Paul Eggert's avatar
Paul Eggert committed
319 320 321 322 323 324
   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
325 326

   Restrictions on these macros:
Paul Eggert's avatar
Paul Eggert committed
327 328 329 330 331 332 333 334

   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
335
   The WRAPV macros are not constant expressions.  They support only
Paul Eggert's avatar
Paul Eggert committed
336 337 338
   +, 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
339

Paul Eggert's avatar
Paul Eggert committed
340
   These macros are tuned for their last input argument being a constant.
Paul Eggert's avatar
Paul Eggert committed
341 342 343 344

   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
345
#define INT_ADD_OVERFLOW(a, b) \
Paul Eggert's avatar
Paul Eggert committed
346
  _GL_BINARY_OP_OVERFLOW (a, b, _GL_ADD_OVERFLOW)
Paul Eggert's avatar
Paul Eggert committed
347
#define INT_SUBTRACT_OVERFLOW(a, b) \
Paul Eggert's avatar
Paul Eggert committed
348
  _GL_BINARY_OP_OVERFLOW (a, b, _GL_SUBTRACT_OVERFLOW)
Paul Eggert's avatar
Paul Eggert committed
349
#if _GL_HAS_BUILTIN_OVERFLOW_P
Paul Eggert's avatar
Paul Eggert committed
350 351 352 353 354
# 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
355
#define INT_MULTIPLY_OVERFLOW(a, b) \
Paul Eggert's avatar
Paul Eggert committed
356 357 358 359 360 361 362 363 364 365 366 367
  _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
368
   Arguments should be free of side effects.  */
Paul Eggert's avatar
Paul Eggert committed
369 370
#define _GL_BINARY_OP_OVERFLOW(a, b, op_result_overflow)        \
  op_result_overflow (a, b,                                     \
Paul Eggert's avatar
Paul Eggert committed
371 372
                      _GL_INT_MINIMUM (_GL_INT_CONVERT (a, b)), \
                      _GL_INT_MAXIMUM (_GL_INT_CONVERT (a, b)))
Paul Eggert's avatar
Paul Eggert committed
373

Paul Eggert's avatar
Paul Eggert committed
374
/* Store the low-order bits of A + B, A - B, A * B, respectively, into *R.
Paul Eggert's avatar
Paul Eggert committed
375
   Return 1 if the result overflows.  See above for restrictions.  */
Paul Eggert's avatar
Paul Eggert committed
376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395
#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
/* 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))
#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
396 397 398 399 400

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

Paul Eggert's avatar
Paul Eggert committed
409
/* Store the low-order bits of A <op> B into *R, where OP specifies
Paul Eggert's avatar
Paul Eggert committed
410 411 412 413
   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
414 415 416
   (_Generic \
    (*(r), \
     signed char: \
Paul Eggert's avatar
Paul Eggert committed
417
       _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned int, \
Paul Eggert's avatar
Paul Eggert committed
418
                        signed char, SCHAR_MIN, SCHAR_MAX), \
Paul Eggert's avatar
Paul Eggert committed
419 420 421
     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
422
     short int: \
Paul Eggert's avatar
Paul Eggert committed
423
       _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned int, \
Paul Eggert's avatar
Paul Eggert committed
424
                        short int, SHRT_MIN, SHRT_MAX), \
Paul Eggert's avatar
Paul Eggert committed
425 426 427
     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
428 429 430
     int: \
       _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned int, \
                        int, INT_MIN, INT_MAX), \
Paul Eggert's avatar
Paul Eggert committed
431 432 433
     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
434 435 436
     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
437 438 439
     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
440 441
     long long int: \
       _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned long long int, \
Paul Eggert's avatar
Paul Eggert committed
442
                        long long int, LLONG_MIN, LLONG_MAX), \
Paul Eggert's avatar
Paul Eggert committed
443 444
     unsigned long long int: \
       _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned long long int, \
Paul Eggert's avatar
Paul Eggert committed
445
                        unsigned long long int, 0, ULLONG_MAX)))
Paul Eggert's avatar
Paul Eggert committed
446
#else
Paul Eggert's avatar
Paul Eggert committed
447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467
/* 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
468
# define _GL_INT_OP_WRAPV(a, b, r, op, overflow) \
Paul Eggert's avatar
Paul Eggert committed
469
   (sizeof *(r) == sizeof (signed char) \
Paul Eggert's avatar
Paul Eggert committed
470 471 472
    ? _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
473
    : sizeof *(r) == sizeof (short int) \
Paul Eggert's avatar
Paul Eggert committed
474 475 476
    ? _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
477
    : sizeof *(r) == sizeof (int) \
Paul Eggert's avatar
Paul Eggert committed
478 479 480 481 482
    ? (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
483
    : _GL_INT_OP_WRAPV_LONGISH(a, b, r, op, overflow))
Paul Eggert's avatar
Paul Eggert committed
484
# ifdef LLONG_MAX
Paul Eggert's avatar
Paul Eggert committed
485 486
#  define _GL_INT_OP_WRAPV_LONGISH(a, b, r, op, overflow) \
    (sizeof *(r) == sizeof (long int) \
Paul Eggert's avatar
Paul Eggert committed
487 488 489 490 491 492 493 494 495 496
     ? (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
497
# else
Paul Eggert's avatar
Paul Eggert committed
498
#  define _GL_INT_OP_WRAPV_LONGISH(a, b, r, op, overflow) \
Paul Eggert's avatar
Paul Eggert committed
499 500 501 502 503
    (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
504 505 506
# endif
#endif

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

Paul Eggert's avatar
Paul Eggert committed
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 573 574 575 576 577
/* 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
578 579
         ? 0 < (a) + (tmin) \
         : 0 < (a) && -1 - (tmin) < (a) - 1) \
Paul Eggert's avatar
Paul Eggert committed
580 581 582 583 584 585 586 587 588
      : (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
589 590 591 592 593 594
#ifdef _GL_TEMPDEF___has_builtin
# undef __has_builtin
# undef _GL_HAS___builtin_add_overflow
# undef _GL_TEMPDEF___has_builtin
#endif

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