Do not try to serialize VM objects, these are read only canonical objects and should be referred to…

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/dart_api_message.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
+#include "vm/symbols.h"
 
 namespace dart {
 
 // TODO(sgjesse): When the external message format is done these
 // duplicate constants from snapshot.cc should be removed.
 enum {
   kInstanceId = ObjectStore::kMaxId,
   kMaxPredefinedObjectIds,
 };
 static const int kNumInitialReferences = 4;
@@ skipping 21 matching lines @@
 }
 
 
 Dart_CObject* ApiMessageReader::ReadMessage() {
   // Read the object out of the message.
   return ReadObject();
 }
 
 
 intptr_t ApiMessageReader::LookupInternalClass(intptr_t class_header) {
-  SerializedHeaderType header_type = SerializedHeaderTag::decode(class_header);
-  ASSERT(header_type == kObjectId);
-  intptr_t header_value = SerializedHeaderData::decode(class_header);
-  return header_value;
+  if (IsVMIsolateObject(class_header)) {
+    return GetVMIsolateObjectId(class_header);
+  }
+  ASSERT(SerializedHeaderTag::decode(class_header) == kObjectId);
+  return SerializedHeaderData::decode(class_header);
 }
 
 
 Dart_CObject* ApiMessageReader::AllocateDartCObject(Dart_CObject::Type type) {
   Dart_CObject* value =
       reinterpret_cast<Dart_CObject*>(alloc_(NULL, 0, sizeof(Dart_CObject)));
   ASSERT(value != NULL);
   value->type = type;
   return value;
 }
@@ skipping 147 matching lines @@
     for (int i = 0; i < len; i++) {
       value->value.as_array.values[i] = ReadObjectRef();
     }
     return value;
   }
 
   return ReadInternalVMObject(class_id, object_id);
 }
 
 
+Dart_CObject* ApiMessageReader::ReadVMSymbol(intptr_t object_id) {
+  RawOneByteString* str =
+      reinterpret_cast<RawOneByteString*>(Symbols::GetVMSymbol(object_id));
+  if (str == OneByteString::null()) {

[Ivan Posva, 2012/08/03 00:26:50]

It would be nice if we did not have to rely on the side effect of returning null
from GetVMSymbol when the id is out of range, e.g. predefined class id.

[siva, 2012/08/06 21:20:56]

Added a Symbols::IsVMSymbolId method which is checked before calling
Symbols:GetVMSymbol instead of relying on it returning null.

On 2012/08/03 00:26:50, Ivan Posva wrote:

+    return AllocateDartCObjectNull();
+  }
+  intptr_t len = Smi::Value(str->ptr()->length_);

[Ivan Posva, 2012/08/03 00:26:50]

No GC scope because we are touching ptr()->data_?

[siva, 2012/08/06 21:20:56]

Can't do a No GC Scope here as there is no isolate here when this code is run
(run by the native event handler thread). This object is in the VM isolate and
is read only so we should be safe in terms of GC right?

+  Dart_CObject* object = AllocateDartCObjectString(len);
+  char* p = object->value.as_string;
+  memmove(p, str->ptr()->data_, len);
+  p[len] = '\0';
+  return object;
+}
+
+
 Dart_CObject* ApiMessageReader::ReadObjectRef() {
   int64_t value = Read<int64_t>();
   if ((value & kSmiTagMask) == 0) {
     int64_t untagged_value = value >> kSmiTagShift;
     if (kMinInt32 <= untagged_value && untagged_value <= kMaxInt32) {
       return AllocateDartCObjectInt32(untagged_value);
     } else {
       return AllocateDartCObjectInt64(untagged_value);
     }
   }
   ASSERT((value <= kIntptrMax) && (value >= kIntptrMin));
-  SerializedHeaderType header_type = SerializedHeaderTag::decode(value);
-  intptr_t header_value = SerializedHeaderData::decode(value);
-
-  if (header_type == kObjectId) {
-    return ReadIndexedObject(header_value);
+  if (IsVMIsolateObject(value)) {
+    intptr_t object_id = GetVMIsolateObjectId(value);
+    if (object_id == Object::kNullObject) {
+      return AllocateDartCObjectNull();
+    }
+    return ReadVMSymbol(object_id);
   }
-  ASSERT(header_type == kInlined);
+  if (SerializedHeaderTag::decode(value) == kObjectId) {
+    return ReadIndexedObject(SerializedHeaderData::decode(value));
+  }
+  ASSERT(SerializedHeaderTag::decode(value) == kInlined);
   // Read the class header information and lookup the class.
   intptr_t class_header = ReadIntptrValue();
 
   // Reading of regular dart instances is not supported.
   if (SerializedHeaderData::decode(class_header) == kInstanceId) {
     return AllocateDartCObjectUnsupported();
   }
   ASSERT((class_header & kSmiTagMask) != 0);
-  intptr_t object_id = header_value;
+  intptr_t object_id = SerializedHeaderData::decode(value);
   intptr_t class_id = LookupInternalClass(class_header);
   if (class_id == ObjectStore::kArrayClass ||
       class_id == ObjectStore::kImmutableArrayClass) {
     ASSERT(GetBackRef(object_id) == NULL);
     intptr_t len = ReadSmiValue();
     Dart_CObject* value = AllocateDartCObjectArray(len);
     AddBackRef(object_id, value, kIsNotDeserialized);
     return value;
   }
   intptr_t tags = ReadIntptrValue();
@@ skipping 102 matching lines @@
       return object;
     }
     default:
       // Everything else not supported.
       return AllocateDartCObjectUnsupported();
   }
 }
 
 
 Dart_CObject* ApiMessageReader::ReadIndexedObject(intptr_t object_id) {
-  if (object_id == Object::kNullObject) {
-    return AllocateDartCObjectNull();
-  }
   if (object_id == ObjectStore::kTrueValue) {
     return AllocateDartCObjectBool(true);
   }
   if (object_id == ObjectStore::kFalseValue) {
     return AllocateDartCObjectBool(false);
   }
   if (object_id == ObjectStore::kDynamicType ||
       object_id == ObjectStore::kDoubleInterface ||
       object_id == ObjectStore::kIntInterface ||
       object_id == ObjectStore::kBoolInterface ||
@@ skipping 24 matching lines @@
   int64_t value = Read<int64_t>();
   if ((value & kSmiTagMask) == 0) {
     int64_t untagged_value = value >> kSmiTagShift;
     if (kMinInt32 <= untagged_value && untagged_value <= kMaxInt32) {
       return AllocateDartCObjectInt32(untagged_value);
     } else {
       return AllocateDartCObjectInt64(untagged_value);
     }
   }
   ASSERT((value <= kIntptrMax) && (value >= kIntptrMin));
-  SerializedHeaderType header_type = SerializedHeaderTag::decode(value);
-  intptr_t header_value = SerializedHeaderData::decode(value);
-
-  if (header_type == kObjectId) {
-    return ReadIndexedObject(header_value);
+  if (IsVMIsolateObject(value)) {
+    intptr_t object_id = GetVMIsolateObjectId(value);
+    if (object_id == Object::kNullObject) {
+      return AllocateDartCObjectNull();
+    }
+    return ReadVMSymbol(object_id);
   }
-  ASSERT(header_type == kInlined);
-  return ReadInlinedObject(header_value);
+  if (SerializedHeaderTag::decode(value) == kObjectId) {
+    return ReadIndexedObject(SerializedHeaderData::decode(value));
+  }
+  ASSERT(SerializedHeaderTag::decode(value) == kInlined);
+  return ReadInlinedObject(SerializedHeaderData::decode(value));
 }
 
 
 void ApiMessageReader::AddBackRef(intptr_t id,
                                   Dart_CObject* obj,
                                   DeserializeState state) {
   intptr_t index = (id - kMaxPredefinedObjectIds);
   ASSERT(index == backward_references_.length());
   BackRefNode* node = AllocateBackRefNode(obj, state);
   ASSERT(node != NULL);
   backward_references_.Add(node);
 }
 
 
 Dart_CObject* ApiMessageReader::GetBackRef(intptr_t id) {
   ASSERT(id >= kMaxPredefinedObjectIds);
   intptr_t index = (id - kMaxPredefinedObjectIds);
   if (index < backward_references_.length()) {
     return backward_references_[index]->reference();
   }
   return NULL;
 }
 
 
 void ApiMessageWriter::WriteMessage(intptr_t field_count, intptr_t *data) {
   // Write out the serialization header value for this object.
-  WriteSerializationMarker(kInlined, kMaxPredefinedObjectIds);
+  WriteInlinedObjectHeader(kMaxPredefinedObjectIds);
 
   // Write out the class and tags information.
-  WriteObjectHeader(ObjectStore::kArrayClass, 0);
+  WriteIndexedObject(ObjectStore::kArrayClass);
+  WriteIntptrValue(0);
 
   // Write out the length field.
   Write<RawObject*>(Smi::New(field_count));
 
   // Write out the type arguments.
-  WriteIndexedObject(Object::kNullObject);
+  WriteNullObject();
 
   // Write out the individual Smis.
   for (int i = 0; i < field_count; i++) {
     Write<RawObject*>(Integer::New(data[i]));
   }
 
   FinalizeBuffer();
 }
 
 
@@ skipping 58 matching lines @@
   forward_id_ += 1;
 }
 
 
 void ApiMessageWriter::WriteSmi(int64_t value) {
   ASSERT(Smi::IsValid64(value));
   Write<RawObject*>(Smi::New(value));
 }
 
 
+void ApiMessageWriter::WriteNullObject() {
+  WriteVMIsolateObject(Object::kNullObject);
+}
+
+
 void ApiMessageWriter::WriteMint(Dart_CObject* object, int64_t value) {
   ASSERT(!Smi::IsValid64(value));
   // Write out the serialization header value for mint object.
   WriteInlinedHeader(object);
   // Write out the class and tags information.
-  WriteObjectHeader(ObjectStore::kMintClass, 0);
+  WriteIndexedObject(ObjectStore::kMintClass);
+  WriteIntptrValue(0);
   // Write the 64-bit value.
   Write<int64_t>(value);
 }
 
 
 void ApiMessageWriter::WriteInt32(Dart_CObject* object) {
   int64_t value = object->value.as_int32;
   if (Smi::IsValid64(value)) {
     WriteSmi(value);
   } else {
     WriteMint(object, value);
   }
 }
 
 
 void ApiMessageWriter::WriteInt64(Dart_CObject* object) {
   int64_t value = object->value.as_int64;
   if (Smi::IsValid64(value)) {
     WriteSmi(value);
   } else {
     WriteMint(object, value);
   }
 }
 
 
 void ApiMessageWriter::WriteInlinedHeader(Dart_CObject* object) {
   // Write out the serialization header value for this object.
-  WriteSerializationMarker(kInlined, kMaxPredefinedObjectIds + object_id_);
+  WriteInlinedObjectHeader(kMaxPredefinedObjectIds + object_id_);
   // Mark object with its object id.
   MarkCObject(object, object_id_);
   // Advance object id.
   object_id_++;
 }
 
 
 void ApiMessageWriter::WriteCObject(Dart_CObject* object) {
   if (IsCObjectMarked(object)) {
     intptr_t object_id = GetMarkedCObjectMark(object);
     WriteIndexedObject(kMaxPredefinedObjectIds + object_id);
     return;
   }
 
   Dart_CObject::Type type = object->type;
   if (type == Dart_CObject::kArray) {
     // Write out the serialization header value for this object.
     WriteInlinedHeader(object);
     // Write out the class and tags information.
-    WriteObjectHeader(ObjectStore::kArrayClass, 0);
+    WriteIndexedObject(ObjectStore::kArrayClass);
+    WriteIntptrValue(0);
+
     WriteSmi(object->value.as_array.length);
     // Write out the type arguments.
-    WriteIndexedObject(Object::kNullObject);
+    WriteNullObject();
     // Write out array elements.
     for (int i = 0; i < object->value.as_array.length; i++) {
       WriteCObjectRef(object->value.as_array.values[i]);
     }
     return;
   }
   return WriteCObjectInlined(object, type);
 }
 
 
@@ skipping 21 matching lines @@
 
 
 void ApiMessageWriter::WriteForwardedCObject(Dart_CObject* object) {
   ASSERT(IsCObjectMarked(object));
   Dart_CObject::Type type =
       static_cast<Dart_CObject::Type>(object->type & kDartCObjectTypeMask);
   ASSERT(type == Dart_CObject::kArray);
 
   // Write out the serialization header value for this object.
   intptr_t object_id = GetMarkedCObjectMark(object);
-  WriteSerializationMarker(kInlined, kMaxPredefinedObjectIds + object_id);
+  WriteInlinedObjectHeader(kMaxPredefinedObjectIds + object_id);
   // Write out the class and tags information.
-  WriteObjectHeader(ObjectStore::kArrayClass, 0);
+  WriteIndexedObject(ObjectStore::kArrayClass);
+  WriteIntptrValue(0);
+
   WriteSmi(object->value.as_array.length);
   // Write out the type arguments.
-  WriteIndexedObject(Object::kNullObject);
+  WriteNullObject();
   // Write out array elements.
   for (int i = 0; i < object->value.as_array.length; i++) {
     WriteCObjectRef(object->value.as_array.values[i]);
   }
 }
 
 
 void ApiMessageWriter::WriteCObjectInlined(Dart_CObject* object,
                                            Dart_CObject::Type type) {
   switch (type) {
     case Dart_CObject::kNull:
-      WriteIndexedObject(Object::kNullObject);
+      WriteNullObject();
       break;
     case Dart_CObject::kBool:
       if (object->value.as_bool) {
         WriteIndexedObject(ObjectStore::kTrueValue);
       } else {
         WriteIndexedObject(ObjectStore::kFalseValue);
       }
       break;
     case Dart_CObject::kInt32:
       WriteInt32(object);
       break;
     case Dart_CObject::kInt64:
       WriteInt64(object);
       break;
     case Dart_CObject::kBigint: {
       // Write out the serialization header value for this object.
       WriteInlinedHeader(object);
       // Write out the class and tags information.
-      WriteObjectHeader(ObjectStore::kBigintClass, 0);
+      WriteIndexedObject(ObjectStore::kBigintClass);
+      WriteIntptrValue(0);
       // Write hex string length and content
       char* hex_string = object->value.as_bigint;
       intptr_t len = strlen(hex_string);
       WriteIntptrValue(len);
       for (intptr_t i = 0; i < len; i++) {
         Write<uint8_t>(hex_string[i]);
       }
       break;
     }
     case Dart_CObject::kDouble:
       // Write out the serialization header value for this object.
       WriteInlinedHeader(object);
       // Write out the class and tags information.
-      WriteObjectHeader(ObjectStore::kDoubleClass, 0);
+      WriteIndexedObject(ObjectStore::kDoubleClass);
+      WriteIntptrValue(0);
       // Write double value.
       Write<double>(object->value.as_double);
       break;
     case Dart_CObject::kString: {
       // Write out the serialization header value for this object.
       WriteInlinedHeader(object);
       // Write out the class and tags information.
-      WriteObjectHeader(ObjectStore::kOneByteStringClass, 0);
+      WriteIndexedObject(ObjectStore::kOneByteStringClass);
+      WriteIntptrValue(0);
       // Write string length, hash and content
       char* str = object->value.as_string;
       intptr_t len = strlen(str);
       WriteSmi(len);
       WriteSmi(0);  // TODO(sgjesse): Hash - not written.
       for (intptr_t i = 0; i < len; i++) {
         Write<uint8_t>(str[i]);
       }
       break;
     }
     case Dart_CObject::kUint8Array: {
       // Write out the serialization header value for this object.
       WriteInlinedHeader(object);
       // Write out the class and tags information.
-      WriteObjectHeader(ObjectStore::kUint8ArrayClass, 0);
+      WriteIndexedObject(ObjectStore::kUint8ArrayClass);
+      WriteIntptrValue(0);
       uint8_t* bytes = object->value.as_byte_array.values;
       intptr_t len = object->value.as_byte_array.length;
       WriteSmi(len);
       for (intptr_t i = 0; i < len; i++) {
         Write<uint8_t>(bytes[i]);
       }
       break;
     }
     case Dart_CObject::kExternalUint8Array: {
       // 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.
       WriteInlinedHeader(object);
       // Write out the class and tag information.
-      WriteObjectHeader(ObjectStore::kExternalUint8ArrayClass, 0);
+      WriteIndexedObject(ObjectStore::kExternalUint8ArrayClass);
+      WriteIntptrValue(0);
       int length = object->value.as_external_byte_array.length;
       uint8_t* data = object->value.as_external_byte_array.data;
       void* peer = object->value.as_external_byte_array.peer;
       Dart_PeerFinalizer callback =
           object->value.as_external_byte_array.callback;
       WriteSmi(length);
       WriteIntptrValue(reinterpret_cast<intptr_t>(data));
       WriteIntptrValue(reinterpret_cast<intptr_t>(peer));
       WriteIntptrValue(reinterpret_cast<intptr_t>(callback));
       break;
@@ skipping 10 matching lines @@
   // not been serialized yet. These would typically be fields of arrays.
   // NOTE: The forward list might grow as we process the list.
   for (intptr_t i = 0; i < forward_id_; i++) {
     WriteForwardedCObject(forward_list_[i]);
   }
   UnmarkAllCObjects(object);
   FinalizeBuffer();
 }
 
 }  // namespace dart