Simplify SnapshotReader::LookupInternalClass.

runtime/vm/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/snapshot.h"
 
 #include "platform/assert.h"
 #include "vm/bootstrap.h"
 #include "vm/class_finalizer.h"
 #include "vm/exceptions.h"
@@ skipping 286 matching lines @@
     intptr_t instance_size = cls_.instance_size();
     ASSERT(instance_size > 0);
     if (kind_ == Snapshot::kFull) {
       result ^= AllocateUninitialized(cls_.id(), instance_size);
     } else {
       result ^= Object::Allocate(cls_.id(), instance_size, HEAP_SPACE(kind_));
     }
     return result.raw();
   }
   ASSERT((class_header & kSmiTagMask) != kSmiTag);
-  cls_ = LookupInternalClass(class_header);
-  ASSERT(!cls_.IsNull());
 
   // Similarly Array and ImmutableArray objects are also similarly only
   // allocated here, the individual array elements are read later.
-  intptr_t class_id = cls_.id();
+  intptr_t class_id = LookupInternalClass(class_header);
   if (class_id == kArrayCid) {
     // Read the length and allocate an object based on the len.
     intptr_t len = ReadSmiValue();
     Array& array = Array::ZoneHandle(
         isolate(),
         ((kind_ == Snapshot::kFull) ?
          NewArray(len) : Array::New(len, HEAP_SPACE(kind_))));
     AddBackRef(object_id, &array, kIsNotDeserialized);
 
     return array.raw();
@@ skipping 476 matching lines @@
   }
   return Mint::NewCanonical(value);
 }
 
 
 RawStacktrace* SnapshotReader::NewStacktrace() {
   ALLOC_NEW_OBJECT(Stacktrace);
 }
 
 
-RawClass* SnapshotReader::LookupInternalClass(intptr_t class_header) {
+intptr_t SnapshotReader::LookupInternalClass(intptr_t class_header) {
   // If the header is an object Id, lookup singleton VM classes or classes
   // stored in the object store.
   if (IsVMIsolateObject(class_header)) {
     intptr_t class_id = GetVMIsolateObjectId(class_header);
-    if (IsSingletonClassId(class_id)) {
-      return isolate()->class_table()->At(class_id);  // get singleton class.
-    }
-  } else if (SerializedHeaderTag::decode(class_header) == kObjectId) {
-    intptr_t class_id = SerializedHeaderData::decode(class_header);
-    if (IsObjectStoreClassId(class_id)) {
-      return isolate()->class_table()->At(class_id);  // get singleton class.
-    }
+    ASSERT(IsSingletonClassId(class_id));
+    return class_id;
   }
-  return Class::null();
+  ASSERT(SerializedHeaderTag::decode(class_header) == kObjectId);
+  intptr_t class_id = SerializedHeaderData::decode(class_header);
+  ASSERT(IsObjectStoreClassId(class_id));
+  return class_id;
 }
 
 
 RawObject* SnapshotReader::AllocateUninitialized(intptr_t class_id,
                                                  intptr_t size) {
   ASSERT(isolate()->no_gc_scope_depth() != 0);
   ASSERT(Utils::IsAligned(size, kObjectAlignment));
 
   uword address =
       old_space()->TryAllocateDataBumpLocked(size, PageSpace::kForceGrowth);
@@ skipping 150 matching lines @@
         offset += kWordSize;
       }
       result->SetCreatedFromSnapshot();
     } else if (result->IsCanonical()) {
       *result = result->CheckAndCanonicalize(NULL);
       ASSERT(!result->IsNull());
     }
     return result->raw();
   }
   ASSERT((class_header & kSmiTagMask) != kSmiTag);
-  cls_ = LookupInternalClass(class_header);
-  ASSERT(!cls_.IsNull());
-  switch (cls_.id()) {
+  intptr_t class_id = LookupInternalClass(class_header);
+  switch (class_id) {
 #define SNAPSHOT_READ(clazz)                                                   \
     case clazz::kClassId: {                                                    \
       pobj_ = clazz::ReadFrom(this, object_id, tags, kind_);                   \
       break;                                                                   \
     }
     CLASS_LIST_NO_OBJECT(SNAPSHOT_READ)
 #undef SNAPSHOT_READ
 #define SNAPSHOT_READ(clazz)                                                   \
     case kTypedData##clazz##Cid:                                               \
 
     CLASS_LIST_TYPED_DATA(SNAPSHOT_READ) {
-      tags = RawObject::ClassIdTag::update(cls_.id(), tags);
+      tags = RawObject::ClassIdTag::update(class_id, tags);
       pobj_ = TypedData::ReadFrom(this, object_id, tags, kind_);
       break;
     }
 #undef SNAPSHOT_READ
 #define SNAPSHOT_READ(clazz)                                                   \
     case kExternalTypedData##clazz##Cid:                                       \
 
     CLASS_LIST_TYPED_DATA(SNAPSHOT_READ) {
-      tags = RawObject::ClassIdTag::update(cls_.id(), tags);
+      tags = RawObject::ClassIdTag::update(class_id, tags);
       pobj_ = ExternalTypedData::ReadFrom(this, object_id, tags, kind_);
       break;
     }
 #undef SNAPSHOT_READ
     default: UNREACHABLE(); break;
   }
   if (kind_ == Snapshot::kFull) {
     pobj_.SetCreatedFromSnapshot();
   }
   return pobj_.raw();
@@ skipping 737 matching lines @@
     NoGCScope no_gc;
     WriteObject(obj.raw());
     UnmarkAll();
   } else {
     ThrowException(exception_type(), exception_msg());
   }
 }
 
 
 }  // namespace dart