Option to truncate integers to 64 bits, part 2

runtime/vm/dart_api_impl.cc

 // Copyright (c) 2013, 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.
 
 #include "include/dart_api.h"
 #include "include/dart_mirrors_api.h"
 #include "include/dart_native_api.h"
 
 #include "lib/stacktrace.h"
 #include "platform/assert.h"
@@ skipping 251 matching lines @@
     *value = static_cast<uint64_t>(arg_value);
     return true;
   }
   Thread* thread = arguments->thread();
   ASSERT(thread == Thread::Current());
   REUSABLE_OBJECT_HANDLESCOPE(thread);
   Object& obj = thread->ObjectHandle();
   obj = arguments->NativeArgAt(arg_index);
   intptr_t cid = obj.GetClassId();
   if (cid == kBigintCid) {
+    ASSERT(!Bigint::IsDisabled());
     const Bigint& bigint = Bigint::Cast(obj);
     if (bigint.FitsIntoUint64()) {
       *value = bigint.AsUint64Value();
       return true;
     }
   }
   return false;
 }
 
 static bool GetNativeDoubleArgument(NativeArguments* arguments,
@@ skipping 1723 matching lines @@
   // Slow path for Mints and Bigints.
   DARTSCOPE(thread);
   const Integer& int_obj = Api::UnwrapIntegerHandle(Z, integer);
   if (int_obj.IsNull()) {
     RETURN_TYPE_ERROR(Z, integer, Integer);
   }
   ASSERT(!int_obj.IsSmi());
   if (int_obj.IsMint()) {
     *fits = !int_obj.IsNegative();
   } else {
+    ASSERT(!Bigint::IsDisabled());
     *fits = Bigint::Cast(int_obj).FitsIntoUint64();
   }
   return Api::Success();
 }
 
 DART_EXPORT Dart_Handle Dart_NewInteger(int64_t value) {
   // Fast path for Smis.
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
   CHECK_ISOLATE(isolate);
   API_TIMELINE_DURATION;
   if (Smi::IsValid(value)) {
     NOHANDLESCOPE(thread);
     return Api::NewHandle(thread, Smi::New(static_cast<intptr_t>(value)));
   }
   // Slow path for Mints and Bigints.
   DARTSCOPE(thread);
   CHECK_CALLBACK_STATE(thread);
   return Api::NewHandle(thread, Integer::New(value));
 }
 
 DART_EXPORT Dart_Handle Dart_NewIntegerFromUint64(uint64_t value) {
   DARTSCOPE(Thread::Current());
   CHECK_CALLBACK_STATE(T);
   API_TIMELINE_DURATION;
-  return Api::NewHandle(T, Integer::NewFromUint64(value));
+  RawInteger* integer = Integer::NewFromUint64(value);
+  if (integer == Integer::null()) {
+    return Api::NewError("%s: Cannot create Dart integer from value %" Pu64,
+                         CURRENT_FUNC, value);
+  }
+  return Api::NewHandle(T, integer);
 }
 
 DART_EXPORT Dart_Handle Dart_NewIntegerFromHexCString(const char* str) {
   DARTSCOPE(Thread::Current());
   CHECK_CALLBACK_STATE(T);
   API_TIMELINE_DURATION;
   const String& str_obj = String::Handle(Z, String::New(str));
-  return Api::NewHandle(T, Integer::New(str_obj));
+  RawInteger* integer = Integer::New(str_obj);
+  if (integer == Integer::null()) {
+    return Api::NewError("%s: Cannot create Dart integer from string %s",
+                         CURRENT_FUNC, str);
+  }
+  return Api::NewHandle(T, integer);
 }
 
 DART_EXPORT Dart_Handle Dart_IntegerToInt64(Dart_Handle integer,
                                             int64_t* value) {
   // Fast path for Smis.
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
   CHECK_ISOLATE(isolate);
   if (Api::IsSmi(integer)) {
     *value = Api::SmiValue(integer);
     return Api::Success();
   }
   // Slow path for Mints and Bigints.
   DARTSCOPE(thread);
   const Integer& int_obj = Api::UnwrapIntegerHandle(Z, integer);
   if (int_obj.IsNull()) {
     RETURN_TYPE_ERROR(Z, integer, Integer);
   }
   ASSERT(!int_obj.IsSmi());
   if (int_obj.IsMint()) {
     *value = int_obj.AsInt64Value();
     return Api::Success();
   } else {
+    ASSERT(!Bigint::IsDisabled());
     const Bigint& bigint = Bigint::Cast(int_obj);
     if (bigint.FitsIntoInt64()) {
       *value = bigint.AsInt64Value();
       return Api::Success();
     }
   }
   return Api::NewError("%s: Integer %s cannot be represented as an int64_t.",
                        CURRENT_FUNC, int_obj.ToCString());
 }
 
@@ skipping 17 matching lines @@
     RETURN_TYPE_ERROR(Z, integer, Integer);
   }
   if (int_obj.IsSmi()) {
     ASSERT(int_obj.IsNegative());
   } else if (int_obj.IsMint()) {
     if (!int_obj.IsNegative()) {
       *value = int_obj.AsInt64Value();
       return Api::Success();
     }
   } else {
+    ASSERT(!Bigint::IsDisabled());
     const Bigint& bigint = Bigint::Cast(int_obj);
     if (bigint.FitsIntoUint64()) {
       *value = bigint.AsUint64Value();
       return Api::Success();
     }
   }
   return Api::NewError("%s: Integer %s cannot be represented as a uint64_t.",
                        CURRENT_FUNC, int_obj.ToCString());
 }
 
@@ skipping 959 matching lines @@
       type = Dart_TypedData_kUint32;
       break;
     case kTypedDataInt64ArrayCid:
     case kTypedDataInt64ArrayViewCid:
     case kExternalTypedDataInt64ArrayCid:
       type = Dart_TypedData_kInt64;
       break;
     case kTypedDataUint64ArrayCid:
     case kTypedDataUint64ArrayViewCid:
     case kExternalTypedDataUint64ArrayCid:
+      // TODO(alexmarkov): Figure out if Uint64 should be rejected in

[zra, 2017/07/14 17:36:30]

I think we'll probably need to keep these. When we pull them out of the array,
we can either complain or make a BigInt depending on whether their enabled.

[alexmarkov, 2017/07/14 18:23:45]

Done.

+      // --limit-ints-to-64-bits mode.
       type = Dart_TypedData_kUint64;
       break;
     case kTypedDataFloat32ArrayCid:
     case kTypedDataFloat32ArrayViewCid:
     case kExternalTypedDataFloat32ArrayCid:
       type = Dart_TypedData_kFloat32;
       break;
     case kTypedDataFloat64ArrayCid:
     case kTypedDataFloat64ArrayViewCid:
     case kExternalTypedDataFloat64ArrayCid:
@@ skipping 148 matching lines @@
       return NewTypedData(T, kTypedDataInt16ArrayCid, length);
     case Dart_TypedData_kUint16:
       return NewTypedData(T, kTypedDataUint16ArrayCid, length);
     case Dart_TypedData_kInt32:
       return NewTypedData(T, kTypedDataInt32ArrayCid, length);
     case Dart_TypedData_kUint32:
       return NewTypedData(T, kTypedDataUint32ArrayCid, length);
     case Dart_TypedData_kInt64:
       return NewTypedData(T, kTypedDataInt64ArrayCid, length);
     case Dart_TypedData_kUint64:
+      // TODO(alexmarkov): Figure out if Uint64 should be rejected in

[zra, 2017/07/14 17:36:30]

ditto

[alexmarkov, 2017/07/14 18:23:45]

Done.

+      // --limit-ints-to-64-bits mode.
       return NewTypedData(T, kTypedDataUint64ArrayCid, length);
     case Dart_TypedData_kFloat32:
       return NewTypedData(T, kTypedDataFloat32ArrayCid, length);
     case Dart_TypedData_kFloat64:
       return NewTypedData(T, kTypedDataFloat64ArrayCid, length);
     case Dart_TypedData_kFloat32x4:
       return NewTypedData(T, kTypedDataFloat32x4ArrayCid, length);
     default:
       return Api::NewError("%s expects argument 'type' to be of 'TypedData'",
                            CURRENT_FUNC);
@@ skipping 31 matching lines @@
     case Dart_TypedData_kInt32:
       return NewExternalTypedData(T, kExternalTypedDataInt32ArrayCid, data,
                                   length);
     case Dart_TypedData_kUint32:
       return NewExternalTypedData(T, kExternalTypedDataUint32ArrayCid, data,
                                   length);
     case Dart_TypedData_kInt64:
       return NewExternalTypedData(T, kExternalTypedDataInt64ArrayCid, data,
                                   length);
     case Dart_TypedData_kUint64:
+      // TODO(alexmarkov): Figure out if Uint64 should be rejected in
+      // --limit-ints-to-64-bits mode.
       return NewExternalTypedData(T, kExternalTypedDataUint64ArrayCid, data,
                                   length);
     case Dart_TypedData_kFloat32:
       return NewExternalTypedData(T, kExternalTypedDataFloat32ArrayCid, data,
                                   length);
     case Dart_TypedData_kFloat64:
       return NewExternalTypedData(T, kExternalTypedDataFloat64ArrayCid, data,
                                   length);
     case Dart_TypedData_kFloat32x4:
       return NewExternalTypedData(T, kExternalTypedDataFloat32x4ArrayCid, data,
@@ skipping 3339 matching lines @@
 #endif
 }
 
 DART_EXPORT void Dart_DumpNativeStackTrace(void* context) {
 #ifndef PRODUCT
   Profiler::DumpStackTrace(context);
 #endif
 }
 
 }  // namespace dart