Refactor ReadObjectImpl to use the as_reference field and eliminate ReadObjectRef and ReadInlinedOb…

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/native_entry.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/snapshot.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
@@ skipping 1331 matching lines @@
 
 
 RawObjectPool* ObjectPool::ReadFrom(SnapshotReader* reader,
                                     intptr_t object_id,
                                     intptr_t tags,
                                     Snapshot::Kind kind,
                                     bool as_reference) {
   ASSERT(reader->snapshot_code());
   ASSERT(kind == Snapshot::kFull);
 
-  intptr_t length = reader->Read<intptr_t>();
+  intptr_t len = reader->Read<intptr_t>();
+  ObjectPool* result = NULL;
+  DeserializeState state;
+  if (!as_reference) {
+    result = reinterpret_cast<ObjectPool*>(reader->GetBackRef(object_id));
+    state = kIsDeserialized;
+  } else {
+    state = kIsNotDeserialized;
+  }
+  if (result == NULL) {
+    result = &(ObjectPool::ZoneHandle(
+        reader->zone(), NEW_OBJECT_WITH_LEN(ObjectPool, len)));
+    reader->AddBackRef(object_id, result, state);
+  }
+  if (!as_reference) {
+    // Read all the individual elements for inlined objects.
+    const TypedData& info_array =
+        TypedData::Handle(reader->NewTypedData(kTypedDataInt8ArrayCid, len));
+    result->set_info_array(info_array);
 
-  ObjectPool* result =
-      reinterpret_cast<ObjectPool*>(reader->GetBackRef(object_id));
-  if (result == NULL) {
-    result =
-        &(ObjectPool::ZoneHandle(reader->zone(),
-                                 NEW_OBJECT_WITH_LEN(ObjectPool, length)));
-    reader->AddBackRef(object_id, result, kIsDeserialized);
-  }
-
-  const TypedData& info_array =
-      TypedData::Handle(reader->NewTypedData(kTypedDataInt8ArrayCid, length));
-  result->set_info_array(info_array);
-
-  NoSafepointScope no_safepoint;
-  for (intptr_t i = 0; i < length; i++) {
-    ObjectPool::EntryType entry_type =
-        static_cast<ObjectPool::EntryType>(reader->Read<int8_t>());
-    *reinterpret_cast<int8_t*>(info_array.DataAddr(i)) = entry_type;
-    switch (entry_type) {
-      case ObjectPool::kTaggedObject: {
-        (*reader->PassiveObjectHandle()) =
-            reader->ReadObjectImpl(kAsReference);
-        result->SetObjectAt(i, *(reader->PassiveObjectHandle()));
-        break;
+    NoSafepointScope no_safepoint;
+    for (intptr_t i = 0; i < len; i++) {
+      ObjectPool::EntryType entry_type =
+          static_cast<ObjectPool::EntryType>(reader->Read<int8_t>());
+      *reinterpret_cast<int8_t*>(info_array.DataAddr(i)) = entry_type;
+      switch (entry_type) {
+        case ObjectPool::kTaggedObject: {
+          (*reader->PassiveObjectHandle()) =
+              reader->ReadObjectImpl(kAsReference);
+          result->SetObjectAt(i, *(reader->PassiveObjectHandle()));
+          break;
+        }
+        case ObjectPool::kImmediate: {
+          intptr_t raw_value = reader->Read<intptr_t>();
+          result->SetRawValueAt(i, raw_value);
+          break;
+        }
+        case ObjectPool::kNativeEntry: {
+          // Read nothing. Initialize with the lazy link entry.
+          uword new_entry = NativeEntry::LinkNativeCallEntry();
+          result->SetRawValueAt(i, static_cast<intptr_t>(new_entry));
+          break;
+        }
+        default:
+          UNREACHABLE();
       }
-      case ObjectPool::kImmediate: {
-        intptr_t raw_value = reader->Read<intptr_t>();
-        result->SetRawValueAt(i, raw_value);
-        break;
-      }
-      case ObjectPool::kNativeEntry: {
-        // Read nothing. Initialize with the lazy link entry.
-        uword new_entry = NativeEntry::LinkNativeCallEntry();
-        result->SetRawValueAt(i, static_cast<intptr_t>(new_entry));
-        break;
-      }
-      default:
-        UNREACHABLE();
     }
   }
-
   return result->raw();
 }
 
 
 void RawObjectPool::WriteTo(SnapshotWriter* writer,
                             intptr_t object_id,
                             Snapshot::Kind kind,
                             bool as_reference) {
   ASSERT(writer->snapshot_code());
   ASSERT(kind == Snapshot::kFull);
@@ skipping 1151 matching lines @@
 
 RawArray* Array::ReadFrom(SnapshotReader* reader,
                           intptr_t object_id,
                           intptr_t tags,
                           Snapshot::Kind kind,
                           bool as_reference) {
   ASSERT(reader != NULL);
 
   // Read the length so that we can determine instance size to allocate.
   intptr_t len = reader->ReadSmiValue();
-  Array* array = reinterpret_cast<Array*>(
-      reader->GetBackRef(object_id));
+  Array* array = NULL;
+  DeserializeState state;
+  if (!as_reference) {
+    array = reinterpret_cast<Array*>(reader->GetBackRef(object_id));
+    state = kIsDeserialized;
+  } else {
+    state = kIsNotDeserialized;
+  }
   if (array == NULL) {
     array = &(Array::ZoneHandle(reader->zone(),
                                 NEW_OBJECT_WITH_LEN_SPACE(Array, len, kind)));
-    reader->AddBackRef(object_id, array, kIsDeserialized);
+    reader->AddBackRef(object_id, array, state);
   }
-  ASSERT(!RawObject::IsCanonical(tags));
-  reader->ArrayReadFrom(object_id, *array, len, tags);
+  if (!as_reference) {
+    // Read all the individual elements for inlined objects.
+    ASSERT(!RawObject::IsCanonical(tags));
+    reader->ArrayReadFrom(object_id, *array, len, tags);
+  }
   return array->raw();
 }
 
 
 RawImmutableArray* ImmutableArray::ReadFrom(SnapshotReader* reader,
                                             intptr_t object_id,
                                             intptr_t tags,
                                             Snapshot::Kind kind,
                                             bool as_reference) {
   ASSERT(reader != NULL);
 
   // Read the length so that we can determine instance size to allocate.
   intptr_t len = reader->ReadSmiValue();
-  Array* array = reinterpret_cast<Array*>(reader->GetBackRef(object_id));
+  Array* array = NULL;
+  DeserializeState state;
+  if (!as_reference) {
+    array = reinterpret_cast<Array*>(reader->GetBackRef(object_id));
+    state = kIsDeserialized;
+  } else {
+    state = kIsNotDeserialized;
+  }
   if (array == NULL) {
     array = &(Array::ZoneHandle(
         reader->zone(),
         NEW_OBJECT_WITH_LEN_SPACE(ImmutableArray, len, kind)));
-    reader->AddBackRef(object_id, array, kIsDeserialized);
+    reader->AddBackRef(object_id, array, state);
   }
-  reader->ArrayReadFrom(object_id, *array, len, tags);
-  if (RawObject::IsCanonical(tags)) {
-    if (kind == Snapshot::kFull) {
-      array->SetCanonical();
-    } else {
-      *array ^= array->CheckAndCanonicalize(NULL);
+  if (!as_reference) {
+    // Read all the individual elements for inlined objects.
+    reader->ArrayReadFrom(object_id, *array, len, tags);
+    if (RawObject::IsCanonical(tags)) {
+      if (kind == Snapshot::kFull) {
+        array->SetCanonical();
+      } else {
+        *array ^= array->CheckAndCanonicalize(NULL);
+      }
     }
   }
   return raw(*array);
 }
 
 
 void RawArray::WriteTo(SnapshotWriter* writer,
                        intptr_t object_id,
                        Snapshot::Kind kind,
                        bool as_reference) {
@@ skipping 832 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