New bigint implementation in the vm.

runtime/vm/raw_object_snapshot.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/object.h"
 #include "vm/object_store.h"
 #include "vm/snapshot.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 #include "vm/visitor.h"
 
 namespace dart {
 
 #define NEW_OBJECT(type)                                                       \
   ((kind == Snapshot::kFull) ? reader->New##type() : type::New())
 
 #define NEW_OBJECT_WITH_LEN(type, len)                                         \
   ((kind == Snapshot::kFull) ? reader->New##type(len) : type::New(len))
 
 #define NEW_OBJECT_WITH_LEN_SPACE(type, len, kind)                             \
   ((kind == Snapshot::kFull) ?                                                 \
   reader->New##type(len) : type::New(len, HEAP_SPACE(kind)))
 
 
-static uword BigintAllocator(intptr_t size) {
-  Zone* zone = Isolate::Current()->current_zone();
-  return zone->AllocUnsafe(size);
-}
-
-
 RawClass* Class::ReadFrom(SnapshotReader* reader,
                           intptr_t object_id,
                           intptr_t tags,
                           Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
   Class& cls = Class::ZoneHandle(reader->isolate(), Class::null());
   if ((kind == Snapshot::kFull) ||
       (kind == Snapshot::kScript && !RawObject::IsCreatedFromSnapshot(tags))) {
     // Read in the base information.
@@ skipping 1663 matching lines @@
   // Write out the class and tags information.
   writer->WriteIndexedObject(kMintCid);
   writer->WriteTags(writer->GetObjectTags(this));
 
   // Write out the 64 bit value.
   writer->Write<int64_t>(ptr()->value_);
 }
 
 
 RawBigint* Bigint::ReadFrom(SnapshotReader* reader,
-                            intptr_t object_id,
-                            intptr_t tags,
-                            Snapshot::Kind kind) {
+                              intptr_t object_id,
+                              intptr_t tags,
+                              Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
-  // Read in the HexCString representation of the bigint.
-  intptr_t len = reader->ReadIntptrValue();
-  char* str = reader->isolate()->current_zone()->Alloc<char>(len + 1);
-  str[len] = '\0';
-  reader->ReadBytes(reinterpret_cast<uint8_t*>(str), len);
+  // Allocate bigint object.
+  Bigint& obj = Bigint::ZoneHandle(reader->isolate(), NEW_OBJECT(Bigint));
+  reader->AddBackRef(object_id, &obj, kIsDeserialized);
 
-  // Create a Bigint object from HexCString.
-  Bigint& obj = Bigint::ZoneHandle(
-      reader->isolate(),
-      ((kind == Snapshot::kFull) ? reader->NewBigint(str) :
-       BigintOperations::FromHexCString(str, HEAP_SPACE(kind))));
+  // Set all the object fields.
+  // TODO(5411462): Need to assert No GC can happen here, even though
+  // allocations may happen.
+  intptr_t num_flds = (obj.raw()->to() - obj.raw()->from());
+  for (intptr_t i = 0; i <= num_flds; i++) {
+    (*reader->PassiveObjectHandle()) = reader->ReadObjectRef();
+    obj.StorePointer(obj.raw()->from() + i,
+                     reader->PassiveObjectHandle()->raw());
+  }
 
   // If it is a canonical constant make it one.
   // When reading a full snapshot we don't need to canonicalize the object
   // as it would already be a canonical object.
   // When reading a script snapshot we need to canonicalize only those object
   // references that are objects from the core library (loaded from a
   // full snapshot). Objects that are only in the script need not be
   // canonicalized as they are already canonical.
   // When reading a message snapshot we always have to canonicalize the object.
   if ((kind != Snapshot::kFull) && RawObject::IsCanonical(tags) &&
       (RawObject::IsCreatedFromSnapshot(tags) ||
        (kind == Snapshot::kMessage))) {
     obj ^= obj.CheckAndCanonicalize(NULL);
     ASSERT(!obj.IsNull());
   }
-  reader->AddBackRef(object_id, &obj, kIsDeserialized);
 
   // Set the object tags.
   obj.set_tags(tags);
 
   return obj.raw();
 }
 
 
 void RawBigint::WriteTo(SnapshotWriter* writer,
-                        intptr_t object_id,
-                        Snapshot::Kind kind) {
+                         intptr_t object_id,
+                         Snapshot::Kind kind) {
   ASSERT(writer != NULL);
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteIndexedObject(kBigintCid);
   writer->WriteTags(writer->GetObjectTags(this));
 
-  // Write out the bigint value as a HEXCstring.
-  intptr_t length = ptr()->signed_length_;
-  bool is_negative = false;
-  if (length <= 0) {
-    length = -length;
-    is_negative = true;
-  }
-  uword data_start = reinterpret_cast<uword>(ptr()) + sizeof(RawBigint);
-  const char* str = BigintOperations::ToHexCString(
-      length,
-      is_negative,
-      reinterpret_cast<void*>(data_start),
-      &BigintAllocator);
-  bool neg = false;
-  if (*str == '-') {
-    neg = true;
-    str++;
-  }
-  intptr_t len = strlen(str);
-  ASSERT(len > 2 && str[0] == '0' && str[1] == 'x');
-  if (neg) {
-    writer->WriteIntptrValue(len - 1);  // Include '-' in length.
-    writer->Write<uint8_t>('-');
-  } else {
-    writer->WriteIntptrValue(len - 2);
-  }
-  writer->WriteBytes(reinterpret_cast<const uint8_t*>(&(str[2])), (len - 2));
+  // Write out all the object pointer fields.
+  SnapshotWriterVisitor visitor(writer);
+  visitor.VisitPointers(from(), to());
 }
 
 
 RawDouble* Double::ReadFrom(SnapshotReader* reader,
                             intptr_t object_id,
                             intptr_t tags,
                             Snapshot::Kind kind) {
   ASSERT(reader != NULL);
   ASSERT(kind != Snapshot::kMessage);
   // Read the double value for the object.
@@ skipping 1065 matching lines @@
     // We do not allow objects with native fields in an isolate message.
     writer->SetWriteException(Exceptions::kArgument,
                               "Illegal argument in isolate message"
                               " : (object is a UserTag)");
   } else {
     UNREACHABLE();
   }
 }
 
 }  // namespace dart