Omits size bits when writing RawObject tags to a snapshot.

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"
@@ skipping 240 matching lines @@
     }
     i++;
   }
   return Dart_TypedData_kInvalid;
 }
 
 
 Dart_CObject* ApiMessageReader::ReadInlinedObject(intptr_t object_id) {
   // Read the class header information and lookup the class.
   intptr_t class_header = ReadIntptrValue();
-  intptr_t tags = ReadIntptrValue();
+  intptr_t tags = ReadTags();
   USE(tags);
   intptr_t class_id;
 
   // There is limited support for reading regular dart instances. Only
   // typed data views are currently handled.
   if (SerializedHeaderData::decode(class_header) == kInstanceObjectId) {
     Dart_CObject_Internal* object =
         reinterpret_cast<Dart_CObject_Internal*>(GetBackRef(object_id));
     if (object == NULL) {
       object =
@@ skipping 147 matching lines @@
   intptr_t object_id = SerializedHeaderData::decode(value);
   intptr_t class_id = LookupInternalClass(class_header);
   if ((class_id == kArrayCid) || (class_id == kImmutableArrayCid)) {
     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();
+  intptr_t tags = ReadTags();
   USE(tags);
 
   return ReadInternalVMObject(class_id, object_id);
 }
 
 
 Dart_CObject* ApiMessageReader::ReadVMIsolateObject(intptr_t value) {
   intptr_t object_id = GetVMIsolateObjectId(value);
   if (object_id == kNullObject) {
     return AllocateDartCObjectNull();
@@ skipping 335 matching lines @@
   return NULL;
 }
 
 
 void ApiMessageWriter::WriteMessage(intptr_t field_count, intptr_t *data) {
   // Write out the serialization header value for this object.
   WriteInlinedObjectHeader(kMaxPredefinedObjectIds);
 
   // Write out the class and tags information.
   WriteIndexedObject(kArrayCid);
-  WriteIntptrValue(0);
+  WriteTags(0);
 
   // Write out the length field.
   Write<RawObject*>(Smi::New(field_count));
 
   // Write out the type arguments.
   WriteNullObject();
 
   // Write out the individual Smis.
   for (int i = 0; i < field_count; i++) {
     Write<RawObject*>(Integer::New(data[i]));
@@ skipping 75 matching lines @@
   WriteVMIsolateObject(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.
   WriteIndexedObject(kMintCid);
-  WriteIntptrValue(0);
+  WriteTags(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 {
@@ skipping 34 matching lines @@
     const intptr_t array_length = object->value.as_array.length;
     if (array_length < 0 ||
         array_length > Array::kMaxElements) {
       return false;
     }
 
     // Write out the serialization header value for this object.
     WriteInlinedHeader(object);
     // Write out the class and tags information.
     WriteIndexedObject(kArrayCid);
-    WriteIntptrValue(0);
+    WriteTags(0);
     // Write out the length information.
     WriteSmi(array_length);
     // Write out the type arguments.
     WriteNullObject();
     // Write out array elements.
     for (int i = 0; i < array_length; i++) {
       bool success = WriteCObjectRef(object->value.as_array.values[i]);
       if (!success) return false;
     }
     return true;
@@ skipping 39 matching lines @@
   if (array_length < 0 ||
       array_length > Array::kMaxElements) {
     return false;
   }
 
   // Write out the serialization header value for this object.
   intptr_t object_id = GetMarkedCObjectMark(object);
   WriteInlinedObjectHeader(kMaxPredefinedObjectIds + object_id);
   // Write out the class and tags information.
   WriteIndexedObject(kArrayCid);
-  WriteIntptrValue(0);
+  WriteTags(0);
   // Write out the length information.
   WriteSmi(array_length);
   // Write out the type arguments.
   WriteNullObject();
   // Write out array elements.
   for (int i = 0; i < array_length; i++) {
     bool success = WriteCObjectRef(object->value.as_array.values[i]);
     if (!success) return false;
   }
   return true;
@@ skipping 24 matching lines @@
       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);
-      WriteIntptrValue(0);
+      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]);
       }
       break;
     }
     case Dart_CObject_kDouble:
       WriteVMIsolateObject(kDoubleObject);
@@ skipping 12 matching lines @@
       ASSERT(len > 0);
       if (len > String::kMaxElements) {
         return false;
       }
 
       // Write out the serialization header value for this object.
       WriteInlinedHeader(object);
       // Write out the class and tags information.
       WriteIndexedObject(type == Utf8::kLatin1 ? kOneByteStringCid
                                                : kTwoByteStringCid);
-      WriteIntptrValue(0);
+      WriteTags(0);
       // Write string length, hash and content
       WriteSmi(len);
       WriteSmi(0);  // TODO(sgjesse): Hash - not written.
       if (type == Utf8::kLatin1) {
         uint8_t* latin1_str =
             reinterpret_cast<uint8_t*>(::malloc(len * sizeof(uint8_t)));
         bool success = Utf8::DecodeToLatin1(utf8_str,
                                             utf8_len,
                                             latin1_str,
                                             len);
@@ skipping 31 matching lines @@
           UNIMPLEMENTED();
       }
 
       intptr_t len = object->value.as_typed_data.length;
       if (len < 0 ||
           len > TypedData::MaxElements(class_id)) {
         return false;
       }
 
       WriteIndexedObject(class_id);
-      WriteIntptrValue(RawObject::ClassIdTag::update(class_id, 0));
+      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]);
       }
       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.
       WriteInlinedHeader(object);
       // Write out the class and tag information.
       WriteIndexedObject(kExternalTypedDataUint8ArrayCid);
-      WriteIntptrValue(RawObject::ClassIdTag::update(
+      WriteTags(RawObject::ClassIdTag::update(
           kExternalTypedDataUint8ArrayCid, 0));
       intptr_t length = object->value.as_external_typed_data.length;
       if (length < 0 ||
           length > ExternalTypedData::MaxElements(
               kExternalTypedDataUint8ArrayCid)) {
         return false;
       }
       uint8_t* data = object->value.as_external_typed_data.data;
       void* peer = object->value.as_external_typed_data.peer;
       Dart_WeakPersistentHandleFinalizer callback =
@@ skipping 26 matching lines @@
     if (!success) {
       UnmarkAllCObjects(object);
       return false;
     }
   }
   UnmarkAllCObjects(object);
   return true;
 }
 
 }  // namespace dart