New bigint implementation in the vm.

runtime/vm/dart_api_message.cc

 // Copyright (c) 2012, 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 "vm/bigint_operations.h"
 #include "vm/dart_api_message.h"
 #include "vm/object.h"
 #include "vm/snapshot_ids.h"
 #include "vm/symbols.h"
 #include "vm/unicode.h"
 
 namespace dart {
 
 static const int kNumInitialReferences = 4;
 
@@ skipping 69 matching lines @@
 }
 
 
 Dart_CObject* ApiMessageReader::AllocateDartCObjectInt64(int64_t val) {
   Dart_CObject* value = AllocateDartCObject(Dart_CObject_kInt64);
   value->value.as_int64 = val;
   return value;
 }
 
 
-Dart_CObject* ApiMessageReader::AllocateDartCObjectBigint(intptr_t length) {
-  // Allocate a Dart_CObject structure followed by an array of chars
-  // for the bigint hex string content. The pointer to the bigint
-  // content is set up to this area.
-  Dart_CObject* value =
-      reinterpret_cast<Dart_CObject*>(
-          alloc_(NULL, 0, sizeof(Dart_CObject) + length + 1));
-  value->value.as_bigint = reinterpret_cast<char*>(value) + sizeof(*value);
+Dart_CObject* ApiMessageReader::AllocateDartCObjectBigint() {
+  Dart_CObject* value = AllocateDartCObject(Dart_CObject_kBigint);
+  value->value.as_bigint.neg = false;
+  value->value.as_bigint.used = 0;
+  value->value.as_bigint.digits = NULL;
   value->type = Dart_CObject_kBigint;
   return value;
 }
 
 
 Dart_CObject* ApiMessageReader::AllocateDartCObjectDouble(double val) {
   Dart_CObject* value = AllocateDartCObject(Dart_CObject_kDouble);
   value->value.as_double = val;
   return value;
 }
@@ skipping 402 matching lines @@
       Dart_CObject* object;
       if ((kMinInt32 <= value64) && (value64 <= kMaxInt32)) {
         object = AllocateDartCObjectInt32(static_cast<int32_t>(value64));
       } else {
         object = AllocateDartCObjectInt64(value64);
       }
       AddBackRef(object_id, object, kIsDeserialized);
       return object;
     }
     case kBigintCid: {
-      // Read in the hex string representation of the bigint.
-      intptr_t len = ReadIntptrValue();
-      Dart_CObject* object = AllocateDartCObjectBigint(len);
+      // Allocate an empty bigint which will be updated when its contents
+      // has been deserialized.
+      Dart_CObject* object = AllocateDartCObjectBigint();
       AddBackRef(object_id, object, kIsDeserialized);
-      char* p = object->value.as_bigint;
-      for (intptr_t i = 0; i < len; i++) {
-        p[i] = Read<uint8_t>();
-      }
-      p[len] = '\0';
+      Dart_CObject* neg_obj = ReadObjectImpl();
+      ASSERT(neg_obj->type == Dart_CObject_kBool);
+      const bool neg = neg_obj->value.as_bool;
+      Dart_CObject* used_obj = ReadObjectImpl();
+      ASSERT(used_obj->type == Dart_CObject_kInt32);
+      const intptr_t used = used_obj->value.as_int32;
+      Dart_CObject* digits = ReadObjectImpl();
+      ASSERT(digits->type == Dart_CObject_kTypedData);
+      ASSERT(digits->value.as_typed_data.type == Dart_TypedData_kUint32);
+      ASSERT(digits->value.as_typed_data.length >= 4*used);
+      // Update the bigint object.
+      object->value.as_bigint.neg = neg;
+      object->value.as_bigint.used = used;
+      object->value.as_bigint.digits = digits;
       return object;
     }
     case kDoubleCid: {
       // Doubles are handled specially when being sent as part of message
       // snapshots.
       UNREACHABLE();
     }
     case kOneByteStringCid: {
       intptr_t len = ReadSmiValue();
       intptr_t hash = ReadSmiValue();
@@ skipping 489 matching lines @@
         WriteVMIsolateObject(kFalseValue);
       }
       break;
     case Dart_CObject_kInt32:
       WriteInt32(object);
       break;
     case Dart_CObject_kInt64:
       WriteInt64(object);
       break;
     case Dart_CObject_kBigint: {
-      char* hex_string = object->value.as_bigint;
-      const intptr_t chunk_len =
-          BigintOperations::ComputeChunkLength(hex_string);
-      if (chunk_len < 0 ||
-          chunk_len > Bigint::kMaxElements) {
-        return false;
-      }
       // Write out the serialization header value for this object.
       WriteInlinedHeader(object);
       // Write out the class and tags information.
       WriteIndexedObject(kBigintCid);
       WriteTags(0);
-      // Write hex string length and content
-      intptr_t len = strlen(hex_string);
-      WriteIntptrValue(len);
-      for (intptr_t i = 0; i < len; i++) {
-        Write<uint8_t>(hex_string[i]);
+      // Write neg field.
+      if (object->value.as_bigint.neg) {
+        WriteVMIsolateObject(kTrueValue);
+      } else {
+        WriteVMIsolateObject(kFalseValue);
       }
+      // Write used field.
+      WriteSmi(object->value.as_bigint.used);
+      // Write digits as TypedData (or NullObject).
+      WriteCObject(object->value.as_bigint.digits);
       break;
     }
     case Dart_CObject_kDouble:
       WriteVMIsolateObject(kDoubleObject);
       WriteDouble(object->value.as_double);
       break;
     case Dart_CObject_kString: {
       const uint8_t* utf8_str =
           reinterpret_cast<const uint8_t*>(object->value.as_string);
       intptr_t utf8_len = strlen(object->value.as_string);
@@ skipping 46 matching lines @@
       WriteInlinedHeader(object);
       // Write out the class and tags information.
       intptr_t class_id;
       switch (object->value.as_typed_data.type) {
         case Dart_TypedData_kInt8:
           class_id = kTypedDataInt8ArrayCid;
           break;
         case Dart_TypedData_kUint8:
           class_id = kTypedDataUint8ArrayCid;
           break;
+        case Dart_TypedData_kUint32:
+          class_id = kTypedDataUint32ArrayCid;
+          break;
         default:
           class_id = kTypedDataUint8ArrayCid;
           UNIMPLEMENTED();
       }
 
       intptr_t len = object->value.as_typed_data.length;
       if (len < 0 ||
           len > TypedData::MaxElements(class_id)) {
         return false;
       }
 
       WriteIndexedObject(class_id);
       WriteTags(RawObject::ClassIdTag::update(class_id, 0));
       WriteSmi(len);
-      uint8_t* bytes = object->value.as_typed_data.values;
-      for (intptr_t i = 0; i < len; i++) {
-        Write<uint8_t>(bytes[i]);
+      switch (class_id) {
+        case kTypedDataInt8ArrayCid:
+        case kTypedDataUint8ArrayCid: {
+          uint8_t* bytes = object->value.as_typed_data.values;
+          for (intptr_t i = 0; i < len; i++) {
+            Write<uint8_t>(bytes[i]);
+          }
+          break;
+        }
+        case kTypedDataUint32ArrayCid: {
+          uint32_t* words =
+              reinterpret_cast<uint32_t*>(object->value.as_typed_data.values);
+          for (intptr_t i = 0; i < len; i++) {
+            Write<uint32_t>(words[i]);
+          }
+          break;
+        }
+        default:
+          UNIMPLEMENTED();
       }
       break;
     }
     case Dart_CObject_kExternalTypedData: {
       // TODO(ager): we are writing C pointers into the message in
       // order to post external arrays through ports. We need to make
       // sure that messages containing pointers can never be posted
       // to other processes.
 
       // Write out serialization header value for this object.
@@ skipping 40 matching lines @@
     if (!success) {
       UnmarkAllCObjects(object);
       return false;
     }
   }
   UnmarkAllCObjects(object);
   return true;
 }
 
 }  // namespace dart