[compiler-rt][NFC] Avoid implicit-integer-sign-change in FuzzedDataProvider::ConsumeIntegralInRange

[MarcoFalke]

Summary

This makes the implicit conversion that is happening explicit.
Otherwise, each user is forced to suppress this
implicit-integer-sign-change runtime error in their their UBSAN
suppressions file.

For example, the runtime error might look like:

runtime error: implicit conversion from type 'long' of value -9223372036854775808 (64-bit, signed) to type 'uint64_t' (aka 'unsigned long') changed the value to 9223372036854775808 (64-bit, unsigned)
    #0 0x55fe29dea91d in long FuzzedDataProvider::ConsumeIntegralInRange<long>(long, long) src/./test/fuzz/FuzzedDataProvider.h:233:25
    [...]
 SUMMARY: UndefinedBehaviorSanitizer: implicit-integer-sign-change test/fuzz/FuzzedDataProvider.h:233:25 in

[MarcoFalke]

Fix both places

[MarcoFalke]

I went ahead and merged this, because it should be trivially correct. Feel free to revert or let me know if there are any issues.

compiler-rt/include/fuzzer/FuzzedDataProvider.h

 T FuzzedDataProvider::ConsumeIntegralInRange(T min, T max) {
   static_assert(std::is_integral<T>::value, "An integral type is required.");
   static_assert(sizeof(T) <= sizeof(uint64_t), "Unsupported integral type.");
 
   if (min > max)
     abort();
 
   // Use the biggest type possible to hold the range and the result.
-  uint64_t range = static_cast<uint64_t>(max) - min;
+  uint64_t range = static_cast<uint64_t>(max) - static_cast<uint64_t>(min);
   uint64_t result = 0;
   size_t offset = 0;
 
   while (offset < sizeof(T) * CHAR_BIT && (range >> offset) > 0 &&
          remaining_bytes_ != 0) {
     // Pull bytes off the end of the seed data. Experimentally, this seems to
     // allow the fuzzer to more easily explore the input space. This makes
     // sense, since it works by modifying inputs that caused new code to run,
     // and this data is often used to encode length of data read by
     // |ConsumeBytes|. Separating out read lengths makes it easier modify the
     // contents of the data that is actually read.
     --remaining_bytes_;
     result = (result << CHAR_BIT) | data_ptr_[remaining_bytes_];
     offset += CHAR_BIT;
   }
 
   // Avoid division by 0, in case |range + 1| results in overflow.
   if (range != std::numeric_limits<decltype(range)>::max())
     result = result % (range + 1);
 
-  return static_cast<T>(min + result);
+  return static_cast<T>(static_cast<uint64_t>(min) + result);
 }
 
 // Returns a floating point value in the range [Type's lowest, Type's max] by
 // consuming bytes from the input data. If there's no input data left, always
 // returns approximately 0.
 template <typename T> T FuzzedDataProvider::ConsumeFloatingPoint() {
   return ConsumeFloatingPointInRange<T>(std::numeric_limits<T>::lowest(),
                                         std::numeric_limits<T>::max());