Finishes removing intptr_t from raw object fields.

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"
@@ skipping 811 matching lines @@
 
   // Create the literal token object.
   LiteralToken& literal_token = LiteralToken::ZoneHandle(
       reader->isolate(), NEW_OBJECT(LiteralToken));
   reader->AddBackRef(object_id, &literal_token, kIsDeserialized);
 
   // Set the object tags.
   literal_token.set_tags(tags);
 
   // Read the token attributes.
-  Token::Kind token_kind = static_cast<Token::Kind>(reader->ReadIntptrValue());
+  Token::Kind token_kind = static_cast<Token::Kind>(reader->Read<int32_t>());
   literal_token.set_kind(token_kind);
   *reader->StringHandle() ^= reader->ReadObjectImpl();
   literal_token.set_literal(*reader->StringHandle());
   *reader->PassiveObjectHandle() = reader->ReadObjectImpl();
   literal_token.set_value(*reader->PassiveObjectHandle());
 
   return literal_token.raw();
 }
 
 
 void RawLiteralToken::WriteTo(SnapshotWriter* writer,
                               intptr_t object_id,
                               Snapshot::Kind kind) {
   ASSERT(writer != NULL);
   ASSERT(kind != Snapshot::kMessage);
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteVMIsolateObject(kLiteralTokenCid);
   writer->WriteTags(writer->GetObjectTags(this));
 
   // Write out the kind field.
-  writer->Write<intptr_t>(ptr()->kind_);
+  writer->Write<int32_t>(ptr()->kind_);
 
   // Write out literal and value fields.
   writer->WriteObjectImpl(ptr()->literal_);
   writer->WriteObjectImpl(ptr()->value_);
 }
 
 
 RawTokenStream* TokenStream::ReadFrom(SnapshotReader* reader,
                                       intptr_t object_id,
                                       intptr_t tags,
@@ skipping 448 matching lines @@
 }
 
 
 RawContext* Context::ReadFrom(SnapshotReader* reader,
                               intptr_t object_id,
                               intptr_t tags,
                               Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
   // Allocate context object.
-  intptr_t num_vars = reader->ReadIntptrValue();
+  int32_t num_vars = reader->Read<int32_t>();
   Context& context = Context::ZoneHandle(reader->isolate(), Context::null());
   if (kind == Snapshot::kFull) {
     context = reader->NewContext(num_vars);
   } else {
     context = Context::New(num_vars, HEAP_SPACE(kind));
   }
   reader->AddBackRef(object_id, &context, kIsDeserialized);
 
   // Set the object tags.
   context.set_tags(tags);
@@ skipping 21 matching lines @@
   ASSERT(writer != NULL);
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteVMIsolateObject(kContextCid);
   writer->WriteTags(writer->GetObjectTags(this));
 
   // Write out num of variables in the context.
-  writer->WriteIntptrValue(ptr()->num_variables_);
+  writer->Write<int32_t>(ptr()->num_variables_);
 
   // Can't serialize the isolate pointer, we set it implicitly on read.
 
   // Write out all the object pointer fields.
   SnapshotWriterVisitor visitor(writer);
   visitor.VisitPointers(from(), to(ptr()->num_variables_));
 }
 
 
 RawContextScope* ContextScope::ReadFrom(SnapshotReader* reader,
@@ skipping 332 matching lines @@
 }
 
 
 RawBigint* Bigint::ReadFrom(SnapshotReader* reader,
                             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();
+  int32_t len = reader->Read<int32_t>();
   char* str = reader->isolate()->current_zone()->Alloc<char>(len + 1);
   str[len] = '\0';
   reader->ReadBytes(reinterpret_cast<uint8_t*>(str), len);
 
   // Create a Bigint object from HexCString.
   Bigint& obj = Bigint::ZoneHandle(
       reader->isolate(),
       ((kind == Snapshot::kFull) ? reader->NewBigint(str) :
        BigintOperations::FromHexCString(str, HEAP_SPACE(kind))));
 
@@ skipping 26 matching lines @@
   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_;
+  int32_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<int32_t>(len - 1);  // Include '-' in length.
     writer->Write<uint8_t>('-');
   } else {
-    writer->WriteIntptrValue(len - 2);
+    writer->Write<int32_t>(len - 2);
   }
   writer->WriteBytes(reinterpret_cast<const uint8_t*>(&(str[2])), (len - 2));
 }
 
 
 RawDouble* Double::ReadFrom(SnapshotReader* reader,
                             intptr_t object_id,
                             intptr_t tags,
                             Snapshot::Kind kind) {
   ASSERT(reader != NULL);
@@ skipping 946 matching lines @@
       reader->isolate(), JSRegExp::New(len, HEAP_SPACE(kind)));
   reader->AddBackRef(object_id, &regex, kIsDeserialized);
 
   // Set the object tags.
   regex.set_tags(tags);
 
   // Read and Set all the other fields.
   regex.raw_ptr()->num_bracket_expressions_ = reader->ReadAsSmi();
   *reader->StringHandle() ^= reader->ReadObjectImpl();
   regex.set_pattern(*reader->StringHandle());
-  regex.raw_ptr()->type_ = reader->ReadIntptrValue();
-  regex.raw_ptr()->flags_ = reader->ReadIntptrValue();
+  regex.raw_ptr()->type_flags_ = reader->Read<int8_t>();
 
   // TODO(5411462): Need to implement a way of recompiling the regex.
 
   return regex.raw();
 }
 
 
 void RawJSRegExp::WriteTo(SnapshotWriter* writer,
                           intptr_t object_id,
                           Snapshot::Kind kind) {
   ASSERT(writer != NULL);
   ASSERT(kind == Snapshot::kMessage);
 
   // Write out the serialization header value for this object.
   writer->WriteInlinedObjectHeader(object_id);
 
   // Write out the class and tags information.
   writer->WriteIndexedObject(kJSRegExpCid);
   writer->WriteTags(writer->GetObjectTags(this));
 
   // Write out the data length field.
   writer->Write<RawObject*>(ptr()->data_length_);
 
   // Write out all the other fields.
   writer->Write<RawObject*>(ptr()->num_bracket_expressions_);
   writer->WriteObjectImpl(ptr()->pattern_);
-  writer->WriteIntptrValue(ptr()->type_);
-  writer->WriteIntptrValue(ptr()->flags_);
+  writer->Write<int8_t>(ptr()->type_flags_);
 
   // Do not write out the data part which is native.
 }
 
 
 RawWeakProperty* WeakProperty::ReadFrom(SnapshotReader* reader,
                                         intptr_t object_id,
                                         intptr_t tags,
                                         Snapshot::Kind kind) {
   ASSERT(reader != NULL);
@@ skipping 71 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