Fix for issue 6359 - Make snapshots platform independent.

vm/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/snapshot.h"
 
 #include "platform/assert.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
 #include "vm/exceptions.h"
@@ skipping 113 matching lines @@
   ASSERT(kObjectId ==
          ((1 << RawObject::kFreeBit) | (1 << RawObject::kMarkBit)));
   ASSERT((kObjectAlignmentMask & kObjectId) == kObjectId);
   const Snapshot* snapshot = reinterpret_cast<const Snapshot*>(raw_memory);
   return snapshot;
 }
 
 
 RawSmi* BaseReader::ReadAsSmi() {
   intptr_t value = ReadIntptrValue();
-  ASSERT((value & kSmiTagMask) == 0);
+  ASSERT((value & kSmiTagMask) == kSmiTag);
   return reinterpret_cast<RawSmi*>(value);
 }
 
 
 intptr_t BaseReader::ReadSmiValue() {
   return  Smi::Value(ReadAsSmi());
 }
 
 
 SnapshotReader::SnapshotReader(const uint8_t* buffer,
@@ skipping 27 matching lines @@
     }
   }
   return obj.raw();
 }
 
 
 RawClass* SnapshotReader::ReadClassId(intptr_t object_id) {
   ASSERT(kind_ != Snapshot::kFull);
   // Read the class header information and lookup the class.
   intptr_t class_header = ReadIntptrValue();
-  ASSERT((class_header & kSmiTagMask) != 0);
+  ASSERT((class_header & kSmiTagMask) != kSmiTag);
   Class& cls = Class::ZoneHandle(isolate(), Class::null());
   cls = LookupInternalClass(class_header);
   AddBackRef(object_id, &cls, kIsDeserialized);
   if (cls.IsNull()) {
     // Read the library/class information and lookup the class.
     str_ ^= ReadObjectImpl(class_header);
     library_ = Library::LookupLibrary(str_);
     ASSERT(!library_.IsNull());
     str_ ^= ReadObjectImpl();
     cls = library_.LookupClass(str_);
   }
   ASSERT(!cls.IsNull());
   return cls.raw();
 }
 
 
 RawObject* SnapshotReader::ReadObjectImpl() {
   int64_t value = Read<int64_t>();
-  if ((value & kSmiTagMask) == 0) {
-    return Integer::New((value >> kSmiTagShift), HEAP_SPACE(kind_));
+  if ((value & kSmiTagMask) == kSmiTag) {
+    return NewInteger(value);
   }
   return ReadObjectImpl(value);
 }
 
 
 RawObject* SnapshotReader::ReadObjectImpl(intptr_t header_value) {
   ASSERT((header_value <= kIntptrMax) && (header_value >= kIntptrMin));
   if (IsVMIsolateObject(header_value)) {
     return ReadVMIsolateObject(header_value);
   } else {
     if (SerializedHeaderTag::decode(header_value) == kObjectId) {
       return ReadIndexedObject(SerializedHeaderData::decode(header_value));
     }
     ASSERT(SerializedHeaderTag::decode(header_value) == kInlined);
     return ReadInlinedObject(SerializedHeaderData::decode(header_value));
   }
 }
 
 
 RawObject* SnapshotReader::ReadObjectRef() {
   int64_t header_value = Read<int64_t>();
-  if ((header_value & kSmiTagMask) == 0) {
-    return Integer::New((header_value >> kSmiTagShift), HEAP_SPACE(kind_));
+  if ((header_value & kSmiTagMask) == kSmiTag) {
+    return NewInteger(header_value);
   }
   ASSERT((header_value <= kIntptrMax) && (header_value >= kIntptrMin));
   if (IsVMIsolateObject(header_value)) {
     return ReadVMIsolateObject(header_value);
   } else if (SerializedHeaderTag::decode(header_value) == kObjectId) {
     return ReadIndexedObject(SerializedHeaderData::decode(header_value));
   }
   ASSERT(SerializedHeaderTag::decode(header_value) == kInlined);
   intptr_t object_id = SerializedHeaderData::decode(header_value);
   ASSERT(GetBackRef(object_id) == NULL);
@@ skipping 12 matching lines @@
     ASSERT(!cls_.IsNull());
     intptr_t instance_size = cls_.instance_size();
     ASSERT(instance_size > 0);
     if (kind_ == Snapshot::kFull) {
       result ^= AllocateUninitialized(cls_, instance_size);
     } else {
       result ^= Object::Allocate(cls_.id(), instance_size, HEAP_SPACE(kind_));
     }
     return result.raw();
   }
-  ASSERT((class_header & kSmiTagMask) != 0);
+  ASSERT((class_header & kSmiTagMask) != kSmiTag);
   cls_ = LookupInternalClass(class_header);
   ASSERT(!cls_.IsNull());
 
   // Similarly Array and ImmutableArray objects are also similarly only
   // allocated here, the individual array elements are read later.
   intptr_t class_id = cls_.id();
   if (class_id == kArrayCid) {
     // Read the length and allocate an object based on the len.
     intptr_t len = ReadSmiValue();
     Array& array = Array::ZoneHandle(
@@ skipping 298 matching lines @@
 RawApiError* SnapshotReader::NewApiError() {
   ALLOC_NEW_OBJECT(ApiError, Object::api_error_class());
 }
 
 
 RawLanguageError* SnapshotReader::NewLanguageError() {
   ALLOC_NEW_OBJECT(LanguageError, Object::language_error_class());
 }
 
 
+RawObject* SnapshotReader::NewInteger(int64_t value) {
+  ASSERT((value & kSmiTagMask) == kSmiTag);
+  value = value >> kSmiTagShift;
+  if ((value <= Smi::kMaxValue) && (value >= Smi::kMinValue)) {
+    return Smi::New(value);
+  }
+  if (kind_ == Snapshot::kFull) {
+    return NewMint(value);
+  }
+  return Mint::NewCanonical(value);
+}
+
+
 RawClass* SnapshotReader::LookupInternalClass(intptr_t class_header) {
   // If the header is an object Id, lookup singleton VM classes or classes
   // stored in the object store.
   if (IsVMIsolateObject(class_header)) {
     intptr_t class_id = GetVMIsolateObjectId(class_header);
     if (IsSingletonClassId(class_id)) {
       return isolate()->class_table()->At(class_id);  // get singleton class.
     }
   } else if (SerializedHeaderTag::decode(class_header) == kObjectId) {
     intptr_t class_id = SerializedHeaderData::decode(class_header);
@@ skipping 110 matching lines @@
       result->SetFieldAtOffset(offset, obj_);
       offset += kWordSize;
     }
     if (kind_ == Snapshot::kFull) {
       result->SetCreatedFromSnapshot();
     } else if (result->IsCanonical()) {
       *result = result->Canonicalize();
     }
     return result->raw();
   }
-  ASSERT((class_header & kSmiTagMask) != 0);
+  ASSERT((class_header & kSmiTagMask) != kSmiTag);
   cls_ = LookupInternalClass(class_header);
   ASSERT(!cls_.IsNull());
   switch (cls_.id()) {
 #define SNAPSHOT_READ(clazz)                                                   \
     case clazz::kClassId: {                                                    \
       obj_ = clazz::ReadFrom(this, object_id, tags, kind_);                    \
       break;                                                                   \
     }
     CLASS_LIST_NO_OBJECT(SNAPSHOT_READ)
 #undef SNAPSHOT_READ
@@ skipping 295 matching lines @@
     WriteIndexedObject(kTrueValue);
     return true;
   }
 
   // Check if it is a singleton boolean false value.
   if (rawobj == object_store()->false_value()) {
     WriteIndexedObject(kFalseValue);
     return true;
   }
 
+  // Check if the object is a Mint and could potentially be a Smi
+  // on other architectures (64 bit), if so write it out as int64_t value.
+  if (rawobj->GetClassId() == kMintCid) {
+    int64_t value = reinterpret_cast<RawMint*>(rawobj)->ptr()->value_;
+    const intptr_t kSmi64Bits = 62;
+    const int64_t kSmi64Max = (static_cast<int64_t>(1) << kSmi64Bits) - 1;
+    const int64_t kSmi64Min = -(static_cast<int64_t>(1) << kSmi64Bits);
+    if (value <= kSmi64Max && value >= kSmi64Min) {
+      Write<int64_t>((value << kSmiTagShift) | kSmiTag);
+      return true;
+    }
+  }
+
   // Check if it is a code object in that case just write a Null object
   // as we do not want code objects in the snapshot.
   if (rawobj->GetClassId() == kCodeCid) {
     WriteVMIsolateObject(kNullObject);
     return true;
   }
 
   // Check if classes are not being serialized and it is preinitialized type.
   if (kind_ != Snapshot::kFull) {
     RawType* raw_type = reinterpret_cast<RawType*>(rawobj);
@@ skipping 49 matching lines @@
     if (cls->ptr()->num_native_fields_ != 0) {
       // We do not allow objects with native fields in an isolate message.
       set_exception_type(Exceptions::kArgument);
       // TODO(6726): Allocate these constant strings once in the VM isolate.
       set_exception_msg("Illegal argument in isolate message"
                         " : (object extends NativeWrapper)");
 
       Isolate::Current()->long_jump_base()->Jump(1, *ErrorHandle());
     }
     // Object is regular dart instance.
-    intptr_t instance_size = cls->ptr()->instance_size_;
+    intptr_t instance_size =
+        cls->ptr()->instance_size_in_words_ << kWordSizeLog2;
     ASSERT(instance_size != 0);
 
     // Write out the serialization header value for this object.
     WriteInlinedObjectHeader(object_id);
 
     // Indicate this is an instance object.
     WriteIntptrValue(SerializedHeaderData::encode(kInstanceObjectId));
 
     // Write out the tags.
     WriteIntptrValue(tags);
@@ skipping 167 matching lines @@
     UnmarkAll();
     isolate->set_long_jump_base(base);
   } else {
     isolate->set_long_jump_base(base);
     ThrowException(exception_type(), exception_msg());
   }
 }
 
 
 }  // namespace dart