[vm] Fix various UBSan failures.

Bug: #39427
Change-Id: I74e0eee623d88005fb2893d03e284a87daa09260
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/146696
Reviewed-by: Alexander Markov <[email protected]>
Commit-Queue: Ryan Macnak <[email protected]>

Author: rmacnak-google

runtime/bin/file_android.cc

@@ -484,7 +484,7 @@ int64_t File::LengthFromPath(Namespace* namespc, const char* name) {
 static void MillisecondsToTimespec(int64_t millis, struct timespec* t) {
   ASSERT(t != NULL);
   t->tv_sec = millis / kMillisecondsPerSecond;
-  t->tv_nsec = (millis - (t->tv_sec * kMillisecondsPerSecond)) * 1000L;
+  t->tv_nsec = (millis % kMillisecondsPerSecond) * 1000L;
 }
 
 void File::Stat(Namespace* namespc, const char* name, int64_t* data) {

runtime/bin/file_fuchsia.cc

@@ -480,7 +480,7 @@ static int64_t TimespecToMilliseconds(const struct timespec& t) {
 static void MillisecondsToTimespec(int64_t millis, struct timespec* t) {
   ASSERT(t != NULL);
   t->tv_sec = millis / kMillisecondsPerSecond;
-  t->tv_nsec = (millis - (t->tv_sec * kMillisecondsPerSecond)) * 1000L;
+  t->tv_nsec = (millis % kMillisecondsPerSecond) * 1000L;
 }
 
 void File::Stat(Namespace* namespc, const char* name, int64_t* data) {

runtime/bin/file_linux.cc

@@ -489,7 +489,7 @@ static int64_t TimespecToMilliseconds(const struct timespec& t) {
 static void MillisecondsToTimespec(int64_t millis, struct timespec* t) {
   ASSERT(t != NULL);
   t->tv_sec = millis / kMillisecondsPerSecond;
-  t->tv_nsec = (millis - (t->tv_sec * kMillisecondsPerSecond)) * 1000L;
+  t->tv_nsec = (millis % kMillisecondsPerSecond) * 1000L;
 }
 
 void File::Stat(Namespace* namespc, const char* name, int64_t* data) {

runtime/bin/hashmap_test.cc

@@ -123,12 +123,12 @@ void TestSet(IntKeyHash hash, int size) {
   EXPECT_EQ(0u, set.occupancy());
 
   // Insert a long series of values.
-  const int start = 453;
-  const int factor = 13;
-  const int offset = 7;
+  const uint32_t start = 453;
+  const uint32_t factor = 13;
+  const uint32_t offset = 7;
   const uint32_t n = size;
 
-  int x = start;
+  uint32_t x = start;
   for (uint32_t i = 0; i < n; i++) {
     EXPECT_EQ(i, set.occupancy());
     set.Insert(x);

runtime/bin/process_test.cc

@@ -6,6 +6,14 @@
 #include <stdlib.h>
 #include <string.h>
 
+#if defined(__GNUC__) || defined(__Clang__)
+__attribute__((no_sanitize("undefined")))
+#endif
+void Crash() {
+  int* segfault = NULL;
+  *segfault = 1;
+}
+
 /*
  * Run ./process_test <outstream> <echocount> <exitcode> <crash>
  * <outstream>: 0 = stdout, 1 = stderr, 2 = stdout and stderr
@@ -32,8 +40,7 @@ int main(int argc, char* argv[]) {
   int crash = atoi(argv[4]);
 
   if (crash == 1) {
-    int* segfault = NULL;
-    *segfault = 1;
+    Crash();
   }
 
   const int kLineSize = 128;

runtime/lib/double.cc

@@ -89,8 +89,8 @@ DEFINE_NATIVE_ENTRY(Double_hashCode, 0, 1) {
   if (FLAG_trace_intrinsified_natives) {
     OS::PrintErr("Double_hashCode %f\n", val);
   }
-  if (val >= static_cast<double>(kMinInt64) &&
-      val <= static_cast<double>(kMaxInt64)) {
+  if ((val >= kMinInt64RepresentableAsDouble) &&
+      (val <= kMaxInt64RepresentableAsDouble)) {
     int64_t ival = static_cast<int64_t>(val);
     if (static_cast<double>(ival) == val) {
       return Integer::New(ival);

runtime/platform/globals.h

@@ -459,6 +459,8 @@ const int32_t kMaxInt32 = 0x7FFFFFFF;
 const uint32_t kMaxUint32 = 0xFFFFFFFF;
 const int64_t kMinInt64 = DART_INT64_C(0x8000000000000000);
 const int64_t kMaxInt64 = DART_INT64_C(0x7FFFFFFFFFFFFFFF);
+const int64_t kMinInt64RepresentableAsDouble = kMinInt64;
+const int64_t kMaxInt64RepresentableAsDouble = DART_INT64_C(0x7FFFFFFFFFFFFC00);
 const uint64_t kMaxUint64 = DART_2PART_UINT64_C(0xFFFFFFFF, FFFFFFFF);
 const int64_t kSignBitDouble = DART_INT64_C(0x8000000000000000);
 
@@ -636,36 +638,6 @@ inline D bit_copy(const S& source) {
   return destination;
 }
 
-#if defined(HOST_ARCH_ARM) || defined(HOST_ARCH_ARM64)
-// Similar to bit_copy and bit_cast, but does take the type from the argument.
-template <typename T>
-static inline T ReadUnaligned(const T* ptr) {
-  T value;
-  memcpy(reinterpret_cast<void*>(&value), reinterpret_cast<const void*>(ptr),
-         sizeof(value));
-  return value;
-}
-
-// Similar to bit_copy and bit_cast, but does take the type from the argument.
-template <typename T>
-static inline void StoreUnaligned(T* ptr, T value) {
-  memcpy(reinterpret_cast<void*>(ptr), reinterpret_cast<const void*>(&value),
-         sizeof(value));
-}
-#else   // !(HOST_ARCH_ARM || HOST_ARCH_ARM64)
-// Similar to bit_copy and bit_cast, but does take the type from the argument.
-template <typename T>
-static inline T ReadUnaligned(const T* ptr) {
-  return *ptr;
-}
-
-// Similar to bit_copy and bit_cast, but does take the type from the argument.
-template <typename T>
-static inline void StoreUnaligned(T* ptr, T value) {
-  *ptr = value;
-}
-#endif  // !(HOST_ARCH_ARM || HOST_ARCH_ARM64)
-
 // On Windows the reentrent version of strtok is called
 // strtok_s. Unify on the posix name strtok_r.
 #if defined(HOST_OS_WINDOWS)

runtime/platform/growable_array.h

@@ -205,6 +205,9 @@ class BaseGrowableArray : public B {
 template <typename T, typename B, typename Allocator>
 inline void BaseGrowableArray<T, B, Allocator>::Sort(int compare(const T*,
                                                                  const T*)) {
+  // Avoid calling qsort with a null array.
+  if (length_ == 0) return;
+
   typedef int (*CompareFunction)(const void*, const void*);
   qsort(data_, length_, sizeof(T), reinterpret_cast<CompareFunction>(compare));
 }

runtime/platform/safe_stack.h

@@ -5,8 +5,6 @@
 #ifndef RUNTIME_PLATFORM_SAFE_STACK_H_
 #define RUNTIME_PLATFORM_SAFE_STACK_H_
 
-#include "platform/globals.h"
-
 #if defined(__has_feature)
 #if __has_feature(safe_stack)
 #define USING_SAFE_STACK

runtime/platform/unaligned.h

@@ -0,0 +1,43 @@
+// Copyright (c) 2020, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+#ifndef RUNTIME_PLATFORM_UNALIGNED_H_
+#define RUNTIME_PLATFORM_UNALIGNED_H_
+
+#include "platform/globals.h"
+#include "platform/undefined_behavior_sanitizer.h"
+
+namespace dart {
+
+#if defined(HOST_ARCH_ARM) || defined(HOST_ARCH_ARM64)
+template <typename T>
+static inline T LoadUnaligned(const T* ptr) {
+  T value;
+  memcpy(reinterpret_cast<void*>(&value), reinterpret_cast<const void*>(ptr),
+         sizeof(value));
+  return value;
+}
+
+template <typename T>
+static inline void StoreUnaligned(T* ptr, T value) {
+  memcpy(reinterpret_cast<void*>(ptr), reinterpret_cast<const void*>(&value),
+         sizeof(value));
+}
+#else   // !(HOST_ARCH_ARM || HOST_ARCH_ARM64)
+template <typename T>
+NO_SANITIZE_UNDEFINED("alignment")
+static inline T LoadUnaligned(const T* ptr) {
+  return *ptr;
+}
+
+template <typename T>
+NO_SANITIZE_UNDEFINED("alignment")
+static inline void StoreUnaligned(T* ptr, T value) {
+  *ptr = value;
+}
+#endif  // !(HOST_ARCH_ARM || HOST_ARCH_ARM64)
+
+}  // namespace dart
+
+#endif  // RUNTIME_PLATFORM_UNALIGNED_H_