emil-e · Feb 22, 2017 · Jan 8, 2018 · Aug 16, 2020 · Oct 2, 2021 · Nov 13, 2021
diff --git a/include/rapidcheck/detail/BitStream.hpp b/include/rapidcheck/detail/BitStream.hpp
@@ -38,7 +38,13 @@ T BitStream<Source>::next(int /*nbits*/, std::true_type) {
 
 template <typename Source>
 template <typename T>
-T BitStream<Source>::next(int nbits, std::false_type) {
+T BitStream<Source>::next(int nbits, std::false_type) 
+#ifdef __clang__
+  __attribute__((no_sanitize("implicit-signed-integer-truncation"))) 
+  __attribute__((no_sanitize("implicit-integer-sign-change"))) 
+  __attribute__((no_sanitize("shift-exponent")))
+#endif
+{
   using SourceType = decltype(m_source.next());
   nbits = std::min(nbits, numBits<T>());
 

diff --git a/include/rapidcheck/detail/Results.hpp b/include/rapidcheck/detail/Results.hpp
@@ -1,5 +1,7 @@
 #pragma once
 
+#include <cstdint>
+
 namespace rc {
 namespace detail {
 

diff --git a/include/rapidcheck/detail/Utility.h b/include/rapidcheck/detail/Utility.h
@@ -96,7 +96,11 @@ inline uint64_t avalanche(uint64_t x) {
 /// Returns a bitmask of the given type with the lowest `nbits` bits set to 1
 /// and the rest set to 0.
 template <typename T>
-constexpr T bitMask(int nbits) {
+constexpr T bitMask(int nbits) 
+#ifdef __clang__
+  __attribute__((no_sanitize("unsigned-shift-base")))
+#endif
+{
   using UT = typename std::make_unsigned<T>::type;
   using UTP = typename std::common_type<UT, unsigned>::type;
   // There are two pieces of undefined behavior we're avoiding here,

diff --git a/include/rapidcheck/gen/Numeric.hpp b/include/rapidcheck/gen/Numeric.hpp
@@ -5,6 +5,7 @@
 #include "rapidcheck/shrink/Shrink.h"
 #include "rapidcheck/gen/Transform.h"
 #include "rapidcheck/gen/detail/ScaleInteger.h"
+#include <cstring>
 
 namespace rc {
 namespace gen {
@@ -88,6 +89,9 @@ struct DefaultArbitrary<bool> {
 } // namespace detail
 
 template <typename T>
+#if defined(__clang__)
+__attribute__((no_sanitize("undefined"))) 
+#endif
 Gen<T> inRange(T min, T max) {
   return [=](const Random &random, int size) {
     if (max <= min) {
@@ -97,9 +101,16 @@ Gen<T> inRange(T min, T max) {
       throw GenerationFailure(msg);
     }
 
+    int64_t i_min = static_cast<int64_t>(min);
+    Random::Number u_min;
+    memcpy(&u_min, &i_min, sizeof(u_min));
+    int64_t i_max = static_cast<int64_t>(max);
+    Random::Number u_max;
+    memcpy(&u_max, &i_max, sizeof(u_max));
+
     const auto rangeSize =
-        detail::scaleInteger(static_cast<Random::Number>(max) -
-                                 static_cast<Random::Number>(min) - 1,
+        detail::scaleInteger(u_max -
+                                 u_min - 1,
                              size) +
         1;
     const auto value =

diff --git a/include/rapidcheck/shrink/Shrink.hpp b/include/rapidcheck/shrink/Shrink.hpp
@@ -11,7 +11,7 @@ namespace rc {
 namespace shrink {
 namespace detail {
 
-template <typename T>
+template <typename T, typename Enable = void>
 class TowardsSeq {
 public:
   using UInt = typename std::make_unsigned<T>::type;
@@ -37,6 +37,35 @@ class TowardsSeq {
   bool m_down;
 };
 
+template <typename T>
+class TowardsSeq<
+    T,
+    typename std::enable_if<std::is_floating_point<T>::value>::type> {
+public:
+  TowardsSeq(T value, T target)
+      : m_value(value)
+      , m_target(target) {}
+
+  Maybe<T> operator()() {
+    if (m_value == m_target) {
+      return Nothing;
+    }
+
+    T new_value = (m_value / 2) + (m_target / 2);
+
+    if (new_value == m_value) {
+      new_value = m_target;
+    }
+
+    m_value = new_value;
+    return m_value;
+  }
+
+private:
+  T m_value;
+  T m_target;
+};
+
 template <typename Container>
 class RemoveChunksSeq {
 public:

diff --git a/src/Random.cpp b/src/Random.cpp
@@ -67,7 +67,11 @@ void Random::append(bool x) {
   m_bitsi++;
 }
 
-void Random::mash(Block &output) {
+void Random::mash(Block &output) 
+#ifdef __clang__
+  __attribute__((no_sanitize("unsigned-shift-base")))
+#endif
+{
   // Input
   uint64_t b0 = m_bits;
   uint64_t b1 = m_counter;

diff --git a/src/gen/detail/ScaleInteger.cpp b/src/gen/detail/ScaleInteger.cpp
@@ -46,6 +46,9 @@ uint64_t mulDiv(uint64_t a, uint32_t b, uint32_t c) {
 
 } // namespace
 
+#if defined(__clang__)
+__attribute__((no_sanitize("undefined"))) 
+#endif
 uint64_t scaleInteger(uint64_t x, int size) {
   const auto clampedSize = std::min(kNominalSize, size);
   return mulDiv(x, clampedSize, kNominalSize);