Finishes removing intptr_t from raw object fields.

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 239 matching lines @@
       return view_class_names[i].type;
     }
     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 class_header = Read<int32_t>();
+  intptr_t tags = Read<int32_t>();
   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 121 matching lines @@
   ASSERT((value64 <= kIntptrMax) && (value64 >= kIntptrMin));
   intptr_t value = static_cast<intptr_t>(value64);
   if (IsVMIsolateObject(value)) {
     return ReadVMIsolateObject(value);
   }
   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();
+  intptr_t class_header = Read<int32_t>();
 
   // Reading of regular dart instances has limited support in order to
   // read typed data views.
   if (SerializedHeaderData::decode(class_header) == kInstanceObjectId) {
     intptr_t object_id = SerializedHeaderData::decode(value);
     Dart_CObject_Internal* object =
         AllocateDartCObjectInternal(Dart_CObject_Internal::kUninitialized);
     AddBackRef(object_id, object, kIsNotDeserialized);
     // Read class of object.
     object->cls = reinterpret_cast<Dart_CObject_Internal*>(ReadObjectImpl());
     ASSERT(object->cls->type ==
            static_cast<Dart_CObject_Type>(Dart_CObject_Internal::kClass));
     return object;
   }
   ASSERT((class_header & kSmiTagMask) != 0);
   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 = Read<int32_t>();
   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 42 matching lines @@
         if (type != &dynamic_type_marker) {
           return AllocateDartCObjectUnsupported();
         }
       }
       return value;
     }
     case kTypeParameterCid: {
       // TODO(sgjesse): Fix this workaround ignoring the type parameter.
       Dart_CObject* value = &dynamic_type_marker;
       AddBackRef(object_id, value, kIsDeserialized);
-      intptr_t index = ReadIntptrValue();
+      intptr_t index = Read<int32_t>();
       USE(index);
-      intptr_t token_index = ReadIntptrValue();
+      intptr_t token_index = Read<int32_t>();
       USE(token_index);
       int8_t type_state = Read<int8_t>();
       USE(type_state);
       Dart_CObject* parameterized_class = ReadObjectImpl();
       // The type parameter is finalized, therefore parameterized_class is null.
       ASSERT(parameterized_class->type == Dart_CObject_kNull);
       Dart_CObject* name = ReadObjectImpl();
       ASSERT(name->type == Dart_CObject_kString);
       return value;
     }
     case kMintCid: {
       int64_t value64 = Read<int64_t>();
       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();
+      intptr_t len = Read<int32_t>();
       Dart_CObject* object = AllocateDartCObjectBigint(len);
       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';
       return object;
     }
     case kDoubleCid: {
@@ skipping 246 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);
+  Write<int32_t>(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);
+  Write<int32_t>(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);
+    Write<int32_t>(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);
+  Write<int32_t>(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);
+      Write<int32_t>(0);
       // Write hex string length and content
       intptr_t len = strlen(hex_string);
-      WriteIntptrValue(len);
+      Write<int32_t>(len);
       for (intptr_t i = 0; i < len; i++) {
         Write<uint8_t>(hex_string[i]);
       }
       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);
       if (!Utf8::IsValid(utf8_str, utf8_len)) {
         return false;
       }
 
       Utf8::Type type;
       intptr_t len = Utf8::CodeUnitCount(utf8_str, utf8_len, &type);
       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);
+      Write<int32_t>(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));
+      Write<int32_t>(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(
+      Write<int32_t>(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