diff --git a/runtime/bin/gen_snapshot.cc b/runtime/bin/gen_snapshot.cc
index c6685dad076..3598a3c2112 100644
--- a/runtime/bin/gen_snapshot.cc
+++ b/runtime/bin/gen_snapshot.cc
@@ -578,7 +578,7 @@ static void StreamingWriteCallback(void* callback_data,
                                    const uint8_t* buffer,
                                    intptr_t size) {
   File* file = reinterpret_cast<File*>(callback_data);
-  if (!file->WriteFully(buffer, size)) {
+  if ((file != nullptr) && !file->WriteFully(buffer, size)) {
     Syslog::PrintErr("Error: Unable to write snapshot file\n\n");
     Dart_ExitScope();
     Dart_ShutdownIsolate();
diff --git a/runtime/platform/utils.cc b/runtime/platform/utils.cc
index 4a234763d47..63142659fcd 100644
--- a/runtime/platform/utils.cc
+++ b/runtime/platform/utils.cc
@@ -176,7 +176,7 @@ void Utils::CalculateMagicAndShiftForDivRem(int64_t divisor,
   const uint64_t exp = 1LL << 63;
 
   // Initialize the computations.
-  uint64_t abs_d = (divisor >= 0) ? divisor : -divisor;
+  uint64_t abs_d = (divisor >= 0) ? divisor : -static_cast<uint64_t>(divisor);
   uint64_t sign_bit = static_cast<uint64_t>(divisor) >> 63;
   uint64_t tmp = exp + sign_bit;
   uint64_t abs_nc = tmp - 1 - (tmp % abs_d);
diff --git a/runtime/vm/datastream.h b/runtime/vm/datastream.h
index 89240d43c8e..a844493a6d6 100644
--- a/runtime/vm/datastream.h
+++ b/runtime/vm/datastream.h
@@ -133,10 +133,10 @@ class ReadStream : public ValueObject {
     using Unsigned = typename std::make_unsigned<T>::type;
     const uint8_t* c = current_;
     ASSERT(c < end_);
-    uint8_t b = *c++;
+    Unsigned b = *c++;
     if (b > kMaxUnsignedDataPerByte) {
       current_ = c;
-      return static_cast<Unsigned>(b) - end_byte_marker;
+      return b - end_byte_marker;
     }
     T r = 0;
     uint8_t s = 0;
@@ -147,156 +147,152 @@ class ReadStream : public ValueObject {
       b = *c++;
     } while (b <= kMaxUnsignedDataPerByte);
     current_ = c;
-    return r | ((static_cast<Unsigned>(b) - end_byte_marker) << s);
+    return r | (static_cast<Unsigned>(b - end_byte_marker) << s);
   }
 
   uint16_t Read16(uint8_t end_byte_marker) {
     const uint8_t* c = current_;
     ASSERT(c < end_);
-    uint8_t b = *c++;
+    uint16_t b = *c++;
     if (b > kMaxUnsignedDataPerByte) {
       current_ = c;
-      return static_cast<uint16_t>(b) - end_byte_marker;
+      return b - end_byte_marker;
     }
-    uint16_t r = 0;
-    r |= static_cast<uint16_t>(b);
+    uint16_t r = b;
     ASSERT(c < end_);
     b = *c++;
     if (b > kMaxUnsignedDataPerByte) {
       current_ = c;
-      return r | ((static_cast<uint16_t>(b) - end_byte_marker) << 7);
+      return r | (static_cast<uint16_t>(b - end_byte_marker) << 7);
     }
 
-    r |= static_cast<uint16_t>(b) << 7;
+    r |= b << 7;
     ASSERT(c < end_);
     b = *c++;
     ASSERT(b > kMaxUnsignedDataPerByte);
     current_ = c;
-    return r | ((static_cast<uint16_t>(b) - end_byte_marker) << 14);
+    return r | (static_cast<uint16_t>(b - end_byte_marker) << 14);
   }
 
   uint32_t Read32(uint8_t end_byte_marker) {
     const uint8_t* c = current_;
     ASSERT(c < end_);
-    uint8_t b = *c++;
+    uint32_t b = *c++;
     if (b > kMaxUnsignedDataPerByte) {
       current_ = c;
-      return static_cast<uint32_t>(b) - end_byte_marker;
+      return b - end_byte_marker;
     }
 
-    uint32_t r = 0;
-    r |= static_cast<uint32_t>(b);
+    uint32_t r = b;
     ASSERT(c < end_);
     b = *c++;
     if (b > kMaxUnsignedDataPerByte) {
       current_ = c;
-      return r | ((static_cast<uint32_t>(b) - end_byte_marker) << 7);
+      return r | (static_cast<uint32_t>(b - end_byte_marker) << 7);
     }
 
-    r |= static_cast<uint32_t>(b) << 7;
+    r |= b << 7;
     ASSERT(c < end_);
     b = *c++;
     if (b > kMaxUnsignedDataPerByte) {
       current_ = c;
-      return r | ((static_cast<uint32_t>(b) - end_byte_marker) << 14);
+      return r | (static_cast<uint32_t>(b - end_byte_marker) << 14);
     }
 
-    r |= static_cast<uint32_t>(b) << 14;
+    r |= b << 14;
     ASSERT(c < end_);
     b = *c++;
     if (b > kMaxUnsignedDataPerByte) {
       current_ = c;
-      return r | ((static_cast<uint32_t>(b) - end_byte_marker) << 21);
+      return r | (static_cast<uint32_t>(b - end_byte_marker) << 21);
     }
 
-    r |= static_cast<uint32_t>(b) << 21;
+    r |= b << 21;
     ASSERT(c < end_);
     b = *c++;
     ASSERT(b > kMaxUnsignedDataPerByte);
     current_ = c;
-    return r | ((static_cast<uint32_t>(b) - end_byte_marker) << 28);
+    return r | (static_cast<uint32_t>(b - end_byte_marker) << 28);
   }
 
   uint64_t Read64(uint8_t end_byte_marker) {
     const uint8_t* c = current_;
     ASSERT(c < end_);
-    uint8_t b = *c++;
+    uint64_t b = *c++;
     if (b > kMaxUnsignedDataPerByte) {
       current_ = c;
-      return static_cast<uint64_t>(b) - end_byte_marker;
+      return b - end_byte_marker;
     }
-    uint64_t r = 0;
-
-    r |= static_cast<uint64_t>(b);
+    uint64_t r = b;
     ASSERT(c < end_);
     b = *c++;
     if (b > kMaxUnsignedDataPerByte) {
       current_ = c;
-      return r | ((static_cast<uint64_t>(b) - end_byte_marker) << 7);
+      return r | (static_cast<uint64_t>(b - end_byte_marker) << 7);
     }
 
-    r |= static_cast<uint64_t>(b) << 7;
+    r |= b << 7;
     ASSERT(c < end_);
     b = *c++;
     if (b > kMaxUnsignedDataPerByte) {
       current_ = c;
-      return r | ((static_cast<uint64_t>(b) - end_byte_marker) << 14);
+      return r | (static_cast<uint64_t>(b - end_byte_marker) << 14);
     }
 
-    r |= static_cast<uint64_t>(b) << 14;
+    r |= b << 14;
     ASSERT(c < end_);
     b = *c++;
     if (b > kMaxUnsignedDataPerByte) {
       current_ = c;
-      return r | ((static_cast<uint64_t>(b) - end_byte_marker) << 21);
+      return r | (static_cast<uint64_t>(b - end_byte_marker) << 21);
     }
 
-    r |= static_cast<uint64_t>(b) << 21;
+    r |= b << 21;
     ASSERT(c < end_);
     b = *c++;
     if (b > kMaxUnsignedDataPerByte) {
       current_ = c;
-      return r | ((static_cast<uint64_t>(b) - end_byte_marker) << 28);
+      return r | (static_cast<uint64_t>(b - end_byte_marker) << 28);
     }
 
-    r |= static_cast<uint64_t>(b) << 28;
+    r |= b << 28;
     ASSERT(c < end_);
     b = *c++;
     if (b > kMaxUnsignedDataPerByte) {
       current_ = c;
-      return r | ((static_cast<uint64_t>(b) - end_byte_marker) << 35);
+      return r | (static_cast<uint64_t>(b - end_byte_marker) << 35);
     }
 
-    r |= static_cast<uint64_t>(b) << 35;
+    r |= b << 35;
     ASSERT(c < end_);
     b = *c++;
     if (b > kMaxUnsignedDataPerByte) {
       current_ = c;
-      return r | ((static_cast<uint64_t>(b) - end_byte_marker) << 42);
+      return r | (static_cast<uint64_t>(b - end_byte_marker) << 42);
     }
 
-    r |= static_cast<uint64_t>(b) << 42;
+    r |= b << 42;
     ASSERT(c < end_);
     b = *c++;
     if (b > kMaxUnsignedDataPerByte) {
       current_ = c;
-      return r | ((static_cast<uint64_t>(b) - end_byte_marker) << 49);
+      return r | (static_cast<uint64_t>(b - end_byte_marker) << 49);
     }
 
-    r |= static_cast<uint64_t>(b) << 49;
+    r |= b << 49;
     ASSERT(c < end_);
     b = *c++;
     if (b > kMaxUnsignedDataPerByte) {
       current_ = c;
-      return r | ((static_cast<uint64_t>(b) - end_byte_marker) << 56);
+      return r | (static_cast<uint64_t>(b - end_byte_marker) << 56);
     }
 
-    r |= static_cast<uint64_t>(b) << 56;
+    r |= b << 56;
     ASSERT(c < end_);
     b = *c++;
     ASSERT(b > kMaxUnsignedDataPerByte);
     current_ = c;
-    return r | ((static_cast<uint64_t>(b) - end_byte_marker) << 63);
+    return r | (static_cast<uint64_t>(b - end_byte_marker) << 63);
   }
 
   uint8_t ReadByte() {
diff --git a/runtime/vm/object.cc b/runtime/vm/object.cc
index 4237305b648..b92a5cd60c5 100644
--- a/runtime/vm/object.cc
+++ b/runtime/vm/object.cc
@@ -7247,7 +7247,8 @@ intptr_t Function::GetRequiredFlagIndex(intptr_t index,
                                         intptr_t* flag_mask) const {
   ASSERT(index >= num_fixed_parameters());
   index -= num_fixed_parameters();
-  *flag_mask = 1 << (index % compiler::target::kNumParameterFlagsPerElement);
+  *flag_mask = 1 << (static_cast<uintptr_t>(index) %
+                     compiler::target::kNumParameterFlagsPerElement);
   return NumParameters() +
          index / compiler::target::kNumParameterFlagsPerElement;
 }