intprops.h 20.5 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-2018 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 114 115 116 117
   a minus sign if needed.

   Because _GL_SIGNED_TYPE_OR_EXPR sometimes returns 0 when its argument is
   signed, this macro may overestimate the true bound by one byte when
   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
   The INT_<op>_WRAPV macros also store the low-order bits of the answer.
Paul Eggert's avatar
Paul Eggert committed
285
   These macros work correctly on all known practical hosts, and do not rely
Paul Eggert's avatar
Paul Eggert committed
286 287
   on undefined behavior due to signed arithmetic overflow.

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

Paul Eggert's avatar
Paul Eggert committed
290 291 292 293
     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
294

Paul Eggert's avatar
Paul Eggert committed
295 296 297 298 299 300
   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
301 302

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

   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
311 312
   The WRAPV macros are not constant expressions.  They support only
   +, binary -, and *.  The result type must be signed.
Paul Eggert's avatar
Paul Eggert committed
313

Paul Eggert's avatar
Paul Eggert committed
314 315 316 317 318
   These macros are tuned for their last argument being a constant.

   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
319
#define INT_ADD_OVERFLOW(a, b) \
Paul Eggert's avatar
Paul Eggert committed
320
  _GL_BINARY_OP_OVERFLOW (a, b, _GL_ADD_OVERFLOW)
Paul Eggert's avatar
Paul Eggert committed
321
#define INT_SUBTRACT_OVERFLOW(a, b) \
Paul Eggert's avatar
Paul Eggert committed
322
  _GL_BINARY_OP_OVERFLOW (a, b, _GL_SUBTRACT_OVERFLOW)
Paul Eggert's avatar
Paul Eggert committed
323
#if _GL_HAS_BUILTIN_OVERFLOW_P
Paul Eggert's avatar
Paul Eggert committed
324 325 326 327 328
# 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
329
#define INT_MULTIPLY_OVERFLOW(a, b) \
Paul Eggert's avatar
Paul Eggert committed
330 331 332 333 334 335 336 337 338 339 340 341
  _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
342
   Arguments should be free of side effects.  */
Paul Eggert's avatar
Paul Eggert committed
343 344
#define _GL_BINARY_OP_OVERFLOW(a, b, op_result_overflow)        \
  op_result_overflow (a, b,                                     \
Paul Eggert's avatar
Paul Eggert committed
345 346
                      _GL_INT_MINIMUM ((1 ? 0 : (b)) + (a)),    \
                      _GL_INT_MAXIMUM ((1 ? 0 : (b)) + (a)))
Paul Eggert's avatar
Paul Eggert committed
347

Paul Eggert's avatar
Paul Eggert committed
348
/* Store the low-order bits of A + B, A - B, A * B, respectively, into *R.
Paul Eggert's avatar
Paul Eggert committed
349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364
   Return 1 if the result overflows.  See above for restrictions.  */
#define INT_ADD_WRAPV(a, b, r) \
  _GL_INT_OP_WRAPV (a, b, r, +, __builtin_add_overflow, INT_ADD_OVERFLOW)
#define INT_SUBTRACT_WRAPV(a, b, r) \
  _GL_INT_OP_WRAPV (a, b, r, -, __builtin_sub_overflow, INT_SUBTRACT_OVERFLOW)
#define INT_MULTIPLY_WRAPV(a, b, r) \
  _GL_INT_OP_WRAPV (a, b, r, *, __builtin_mul_overflow, INT_MULTIPLY_OVERFLOW)

/* 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
365
#else
Paul Eggert's avatar
Paul Eggert committed
366 367
# define _GL__GENERIC_BOGUS 0
#endif
Paul Eggert's avatar
Paul Eggert committed
368

Paul Eggert's avatar
Paul Eggert committed
369 370 371 372
/* 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
373
#if _GL_HAS_BUILTIN_OVERFLOW
Paul Eggert's avatar
Paul Eggert committed
374 375 376 377 378 379
# 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
380
       _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned int, \
Paul Eggert's avatar
Paul Eggert committed
381 382
                        signed char, SCHAR_MIN, SCHAR_MAX), \
     short int: \
Paul Eggert's avatar
Paul Eggert committed
383
       _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned int, \
Paul Eggert's avatar
Paul Eggert committed
384 385 386 387 388 389 390 391 392 393 394 395 396
                        short int, SHRT_MIN, SHRT_MAX), \
     int: \
       _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned int, \
                        int, INT_MIN, INT_MAX), \
     long int: \
       _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned long int, \
                        long int, LONG_MIN, LONG_MAX), \
     long long int: \
       _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned long long int, \
                        long long int, LLONG_MIN, LLONG_MAX)))
#else
# define _GL_INT_OP_WRAPV(a, b, r, op, builtin, overflow) \
   (sizeof *(r) == sizeof (signed char) \
Paul Eggert's avatar
Paul Eggert committed
397
    ? _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned int, \
Paul Eggert's avatar
Paul Eggert committed
398 399
                       signed char, SCHAR_MIN, SCHAR_MAX) \
    : sizeof *(r) == sizeof (short int) \
Paul Eggert's avatar
Paul Eggert committed
400
    ? _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned int, \
Paul Eggert's avatar
Paul Eggert committed
401 402 403 404 405
                       short int, SHRT_MIN, SHRT_MAX) \
    : sizeof *(r) == sizeof (int) \
    ? _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned int, \
                       int, INT_MIN, INT_MAX) \
    : _GL_INT_OP_WRAPV_LONGISH(a, b, r, op, overflow))
Paul Eggert's avatar
Paul Eggert committed
406
# ifdef LLONG_MAX
Paul Eggert's avatar
Paul Eggert committed
407 408 409 410 411 412
#  define _GL_INT_OP_WRAPV_LONGISH(a, b, r, op, overflow) \
    (sizeof *(r) == sizeof (long int) \
     ? _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 long int, \
                        long long int, LLONG_MIN, LLONG_MAX))
Paul Eggert's avatar
Paul Eggert committed
413
# else
Paul Eggert's avatar
Paul Eggert committed
414 415
#  define _GL_INT_OP_WRAPV_LONGISH(a, b, r, op, overflow) \
    _GL_INT_OP_CALC (a, b, r, op, overflow, unsigned long int, \
Paul Eggert's avatar
Paul Eggert committed
416
                     long int, LONG_MIN, LONG_MAX)
Paul Eggert's avatar
Paul Eggert committed
417 418 419
# endif
#endif

Paul Eggert's avatar
Paul Eggert committed
420 421
/* 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
422 423
   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
424 425 426 427 428 429
#define _GL_INT_OP_CALC(a, b, r, op, overflow, ut, t, tmin, tmax) \
  (sizeof ((a) op (b)) < sizeof (t) \
   ? _GL_INT_OP_CALC1 ((t) (a), (t) (b), r, op, overflow, ut, t, tmin, tmax) \
   : _GL_INT_OP_CALC1 (a, b, r, op, overflow, ut, t, tmin, tmax))
#define _GL_INT_OP_CALC1(a, b, r, op, overflow, ut, t, tmin, tmax) \
  ((overflow (a, b) \
Paul Eggert's avatar
Paul Eggert committed
430
    || (EXPR_SIGNED ((a) op (b)) && ((a) op (b)) < (tmin)) \
Paul Eggert's avatar
Paul Eggert committed
431
    || (tmax) < ((a) op (b))) \
Paul Eggert's avatar
Paul Eggert committed
432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447
   ? (*(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
448
   https://lists.gnu.org/r/bug-gnulib/2017-04/msg00049.html
Paul Eggert's avatar
Paul Eggert committed
449 450 451 452 453
   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
454

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