Implementation of message reader for converting a message snapshot into a C structure

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/visitor.h"
 
 namespace dart {
 
 #define NEW_OBJECT(type)                                                       \
   ((kind == Snapshot::kFull) ? reader->New##type() : type::New())
 
 #define NEW_OBJECT_WITH_LEN(type, len)                                         \
   ((kind == Snapshot::kFull) ? reader->New##type(len) : type::New(len))
 
 
-static RawSmi* AsSmi(intptr_t value) {
-  ASSERT((value & kSmiTagMask) == 0);
-  return reinterpret_cast<RawSmi*>(value);
-}
-
-
-static intptr_t GetSmiValue(intptr_t value) {
-  return Smi::Value(AsSmi(value));
-}
-
-
 static uword ZoneAllocator(intptr_t size) {
   Zone* zone = Isolate::Current()->current_zone();
   return zone->Allocate(size);
 }
 
 
 RawClass* Class::ReadFrom(SnapshotReader* reader,
                           intptr_t object_id,
                           intptr_t tags,
                           Snapshot::Kind kind) {
@@ skipping 309 matching lines @@
 }
 
 
 RawTypeArguments* TypeArguments::ReadFrom(SnapshotReader* reader,
                                           intptr_t object_id,
                                           intptr_t tags,
                                           Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
   // Read the length so that we can determine instance size to allocate.
-  intptr_t len = GetSmiValue(reader->ReadIntptrValue());
+  intptr_t len = reader->ReadSmiValue();
 
   TypeArguments& type_arguments = TypeArguments::ZoneHandle(
       reader->isolate(), NEW_OBJECT_WITH_LEN(TypeArguments, len));
   reader->AddBackwardReference(object_id, &type_arguments);
 
   // Now set all the object fields.
   for (intptr_t i = 0; i < len; i++) {
     *reader->TypeHandle() ^= reader->ReadObject();
     type_arguments.SetTypeAt(i, *reader->TypeHandle());
   }
@@ skipping 207 matching lines @@
 
 
 RawTokenStream* TokenStream::ReadFrom(SnapshotReader* reader,
                                       intptr_t object_id,
                                       intptr_t tags,
                                       Snapshot::Kind kind) {
   ASSERT(reader != NULL);
   ASSERT(kind != Snapshot::kMessage && !RawObject::IsCreatedFromSnapshot(tags));
 
   // Read the length so that we can determine number of tokens to read.
-  intptr_t len = GetSmiValue(reader->ReadIntptrValue());
+  intptr_t len = reader->ReadSmiValue();
 
   // Create the token stream object.
   TokenStream& token_stream = TokenStream::ZoneHandle(
       reader->isolate(), NEW_OBJECT_WITH_LEN(TokenStream, len));
   reader->AddBackwardReference(object_id, &token_stream);
 
   // Set the object tags.
   token_stream.set_tags(tags);
 
   // Read the token stream into the TokenStream.
   for (intptr_t i = 0; i < len; i++) {
-    Token::Kind kind = static_cast<Token::Kind>(
-        GetSmiValue(reader->ReadIntptrValue()));
+    Token::Kind kind = static_cast<Token::Kind>(reader->ReadSmiValue());
     *reader->StringHandle() ^= reader->ReadObject();
     token_stream.SetTokenAt(i, kind, *reader->StringHandle());
   }
   return token_stream.raw();
 }
 
 
 void RawTokenStream::WriteTo(SnapshotWriter* writer,
                              intptr_t object_id,
                              Snapshot::Kind kind) {
@@ skipping 656 matching lines @@
   }
 }
 
 
 RawOneByteString* OneByteString::ReadFrom(SnapshotReader* reader,
                                           intptr_t object_id,
                                           intptr_t tags,
                                           Snapshot::Kind kind) {
   // Read the length so that we can determine instance size to allocate.
   ASSERT(reader != NULL);
-  intptr_t len = GetSmiValue(reader->ReadIntptrValue());
-  intptr_t hash = GetSmiValue(reader->ReadIntptrValue());
+  intptr_t len = reader->ReadSmiValue();
+  intptr_t hash = reader->ReadSmiValue();
   OneByteString& str_obj = OneByteString::ZoneHandle(reader->isolate(),
                                                      OneByteString::null());
 
   if (kind == Snapshot::kFull) {
     ASSERT(reader->isolate()->no_gc_scope_depth() != 0);
     RawOneByteString* obj = reader->NewOneByteString(len);
     str_obj = obj;
     str_obj.set_tags(tags);
     obj->ptr()->hash_ = Smi::New(hash);
     uint8_t* raw_ptr = (len > 0) ? str_obj.CharAddr(0) : NULL;
@@ skipping 10 matching lines @@
   return str_obj.raw();
 }
 
 
 RawTwoByteString* TwoByteString::ReadFrom(SnapshotReader* reader,
                                           intptr_t object_id,
                                           intptr_t tags,
                                           Snapshot::Kind kind) {
   // Read the length so that we can determine instance size to allocate.
   ASSERT(reader != NULL);
-  intptr_t len = GetSmiValue(reader->ReadIntptrValue());
-  intptr_t hash = GetSmiValue(reader->ReadIntptrValue());
+  intptr_t len = reader->ReadSmiValue();
+  intptr_t hash = reader->ReadSmiValue();
   TwoByteString& str_obj = TwoByteString::ZoneHandle(reader->isolate(),
                                                      TwoByteString::null());
 
   if (kind == Snapshot::kFull) {
     RawTwoByteString* obj = reader->NewTwoByteString(len);
     str_obj = obj;
     str_obj.set_tags(tags);
     obj->ptr()->hash_ = Smi::New(hash);
     uint16_t* raw_ptr = (len > 0)? str_obj.CharAddr(0) : NULL;
     for (intptr_t i = 0; i < len; i++) {
       ASSERT(str_obj.CharAddr(i) == raw_ptr);  // Will trigger assertions.
       *raw_ptr = reader->Read<uint16_t>();
       raw_ptr += 1;
     }
     ASSERT(String::Hash(str_obj, 0, str_obj.Length()) == hash);
   } else {
     ReadFromImpl<TwoByteString, uint16_t>(reader, &str_obj, len, tags);
   }
   reader->AddBackwardReference(object_id, &str_obj);
   return str_obj.raw();
 }
 
 
 RawFourByteString* FourByteString::ReadFrom(SnapshotReader* reader,
                                             intptr_t object_id,
                                             intptr_t tags,
                                             Snapshot::Kind kind) {
   // Read the length so that we can determine instance size to allocate.
   ASSERT(reader != NULL);
-  intptr_t len = GetSmiValue(reader->ReadIntptrValue());
-  intptr_t hash = GetSmiValue(reader->ReadIntptrValue());
+  intptr_t len = reader->ReadSmiValue();
+  intptr_t hash = reader->ReadSmiValue();
   FourByteString& str_obj = FourByteString::ZoneHandle(reader->isolate(),
                                                        FourByteString::null());
 
   if (kind == Snapshot::kFull) {
     RawFourByteString* obj = reader->NewFourByteString(len);
     str_obj = obj;
     str_obj.set_tags(tags);
     obj->ptr()->hash_ = Smi::New(hash);
     uint32_t* raw_ptr = (len > 0)? str_obj.CharAddr(0) : NULL;
     for (intptr_t i = 0; i < len; i++) {
@@ skipping 194 matching lines @@
 }
 
 
 RawArray* Array::ReadFrom(SnapshotReader* reader,
                           intptr_t object_id,
                           intptr_t tags,
                           Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
   // Read the length so that we can determine instance size to allocate.
-  intptr_t len = GetSmiValue(reader->ReadIntptrValue());
+  intptr_t len = reader->ReadSmiValue();
   Array& array = Array::ZoneHandle(reader->isolate(),
                                    NEW_OBJECT_WITH_LEN(Array, len));
   reader->AddBackwardReference(object_id, &array);
   ArrayReadFrom(reader, array, len, tags);
   return array.raw();
 }
 
 
 RawImmutableArray* ImmutableArray::ReadFrom(SnapshotReader* reader,
                                             intptr_t object_id,
                                             intptr_t tags,
                                             Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
   // Read the length so that we can determine instance size to allocate.
-  intptr_t len = GetSmiValue(reader->ReadIntptrValue());
+  intptr_t len = reader->ReadSmiValue();
   ImmutableArray& array = ImmutableArray::ZoneHandle(
       reader->isolate(), NEW_OBJECT_WITH_LEN(ImmutableArray, len));
   reader->AddBackwardReference(object_id, &array);
   ArrayReadFrom(reader, array, len, tags);
   return array.raw();
 }
 
 
 static void ArrayWriteTo(SnapshotWriter* writer,
                          intptr_t object_id,
@@ skipping 62 matching lines @@
 }
 
 
 RawInternalByteArray* InternalByteArray::ReadFrom(SnapshotReader* reader,
                                                   intptr_t object_id,
                                                   intptr_t tags,
                                                   Snapshot::Kind kind) {
   ASSERT(reader != NULL);
 
   // Read the length so that we can determine instance size to allocate.
-  intptr_t len = GetSmiValue(reader->ReadIntptrValue());
+  intptr_t len = reader->ReadSmiValue();
   Heap::Space space = (kind == Snapshot::kFull) ? Heap::kOld : Heap::kNew;
   InternalByteArray& result =
       InternalByteArray::ZoneHandle(reader->isolate(),
                                     InternalByteArray::New(len, space));
   reader->AddBackwardReference(object_id, &result);
 
   // Set the object tags.
   result.set_tags(tags);
 
   // Setup the array elements.
@@ skipping 106 matching lines @@
 
 
 RawJSRegExp* JSRegExp::ReadFrom(SnapshotReader* reader,
                                 intptr_t object_id,
                                 intptr_t tags,
                                 Snapshot::Kind kind) {
   ASSERT(reader != NULL);
   ASSERT(kind == Snapshot::kMessage);
 
   // Read the length so that we can determine instance size to allocate.
-  intptr_t len = GetSmiValue(reader->ReadIntptrValue());
+  intptr_t len = reader->ReadSmiValue();
 
   // Allocate JSRegExp object.
   JSRegExp& regex = JSRegExp::ZoneHandle(
       reader->isolate(),
       JSRegExp::New(len, (kind == Snapshot::kFull) ? Heap::kOld : Heap::kNew));
   reader->AddBackwardReference(object_id, &regex);
 
   // Set the object tags.
   regex.set_tags(tags);
 
   // Read and Set all the other fields.
-  regex.raw_ptr()->num_bracket_expressions_ = AsSmi(reader->ReadIntptrValue());
+  regex.raw_ptr()->num_bracket_expressions_ = reader->ReadAsSmi();
   *reader->StringHandle() ^= reader->ReadObject();
   regex.raw_ptr()->pattern_ = (*reader->StringHandle()).raw();
   regex.raw_ptr()->type_ = reader->ReadIntptrValue();
   regex.raw_ptr()->flags_ = reader->ReadIntptrValue();
 
   // TODO(5411462): Need to implement a way of recompiling the regex.
 
   return regex.raw();
 }
 
@@ skipping 16 matching lines @@
   // Write out all the other fields.
   writer->Write<RawObject*>(ptr()->num_bracket_expressions_);
   writer->WriteObject(ptr()->pattern_);
   writer->WriteIntptrValue(ptr()->type_);
   writer->WriteIntptrValue(ptr()->flags_);
 
   // Do not write out the data part which is native.
 }
 
 }  // namespace dart