overflow.h

Go to the documentation of this file.

 
 
#pragma once
 
#include <assert.h>
#include <limits.h>
#include <math.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
 
static inline bool sadd_overflow(int a, int b, int *res) {
  assert(res != NULL);
 
  // delegate to hardware optimized implementations where possible
#if defined(__clang__)
  return __builtin_sadd_overflow(a, b, res);
#elif defined(__GNUC__) && __GNUC__ > 4 // GCC ≥ 5
  return __builtin_sadd_overflow(a, b, res);
#endif
 
  if (a > 0 && INT_MAX - a < b) {
    return true;
  }
  if (a < 0 && INT_MIN - a > b) {
    return true;
  }
 
  *res = a + b;
  return false;
}
 
static inline int sadd_saturate(int a, int b) {
 
  // overflow?
  if (b > 0 && INT_MAX - b < a) {
    return INT_MAX;
  }
 
  // underflow?
  if (b < 0 && INT_MIN - b > a) {
    return INT_MIN;
  }
 
  return a + b;
}
 
static inline bool size_overflow(size_t a, size_t b, size_t *res) {
  assert(res != NULL);
 
  // delegate to hardware optimized implementations where possible
#if defined(__clang__)
  return __builtin_add_overflow(a, b, res);
#elif defined(__GNUC__) && __GNUC__ > 4 // GCC ≥ 5
  return __builtin_add_overflow(a, b, res);
#endif
 
  if (SIZE_MAX - a < b) {
    return true;
  }
 
  *res = a + b;
  return false;
}
 
static inline bool u64add_overflow(uint64_t a, uint64_t b, uint64_t *res) {
  assert(res != NULL);
 
  // delegate to hardware optimized implementations where possible
#if defined(__clang__)
  return __builtin_add_overflow(a, b, res);
#elif defined(__GNUC__) && __GNUC__ > 4 // GCC ≥ 5
  return __builtin_add_overflow(a, b, res);
#endif
 
  if (UINT64_MAX - a < b) {
    return true;
  }
 
  *res = a + b;
  return false;
}
 
static inline bool u64mul_overflow(uint64_t a, uint64_t b, uint64_t *res) {
  assert(res != NULL);
 
  // delegate to hardware optimized implementations where possible
#if defined(__clang__)
  return __builtin_mul_overflow(a, b, res);
#elif defined(__GNUC__) && __GNUC__ > 4 // GCC ≥ 5
  return __builtin_mul_overflow(a, b, res);
#endif
 
  if (a > 0 && UINT64_MAX / a < b) {
    return true;
  }
 
  *res = a * b;
  return false;
}
 
static inline bool fdiv_overflow(double n, double d, double *res) {
  assert(res != NULL);
 
  const double r = n / d;
 
  // did we overflow?
  if (!isfinite(r)) {
    return true;
  }
 
  *res = r;
  return false;
}
 
static inline bool fdivf_overflow(float n, float d, float *res) {
  assert(res != NULL);
 
  const float r = n / d;
 
  // did we overflow?
  if (!isfinite(r)) {
    return true;
  }
 
  *res = r;
  return false;
}