Merge libv1.

runtime/vm/object.h

 // 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.
 
 #ifndef VM_OBJECT_H_
 #define VM_OBJECT_H_
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/utils.h"
@@ skipping 132 matching lines @@
     return raw()->ptr();                                                       \
   }                                                                            \
   SNAPSHOT_READER_SUPPORT(object)                                              \
   friend class StackFrame;                                                     \
 
 class Object {
  public:
   virtual ~Object() { }
 
   RawObject* raw() const { return raw_; }
-  void operator=(RawObject* value) { SetRaw(value); }
+  void operator=(RawObject* value) {
+    initializeHandle(this, value);
+  }
 
   void set_tags(intptr_t value) const {
     // TODO(asiva): Remove the capability of setting tags in general. The mask
     // here only allows for canonical and from_snapshot flags to be set.
     ASSERT(!IsNull());
     uword tags = raw()->ptr()->tags_ & ~0x0000000c;
     raw()->ptr()->tags_ = tags | (value & 0x0000000c);
   }
   void SetCreatedFromSnapshot() const {
     ASSERT(!IsNull());
     raw()->SetCreatedFromSnapshot();
   }
   bool IsCanonical() const {
     ASSERT(!IsNull());
     return raw()->IsCanonical();
   }
   void SetCanonical() const {
     ASSERT(!IsNull());
     raw()->SetCanonical();
   }
 
   inline RawClass* clazz() const;
   static intptr_t tags_offset() { return OFFSET_OF(RawObject, tags_); }
 
   // Class testers.
 #define DEFINE_CLASS_TESTER(clazz)                                             \
   virtual bool Is##clazz() const { return false; }
-CLASS_LIST_NO_OBJECT(DEFINE_CLASS_TESTER);
+  CLASS_LIST_FOR_HANDLES(DEFINE_CLASS_TESTER);
 #undef DEFINE_CLASS_TESTER
 
   bool IsNull() const { return raw_ == null_; }
 
   virtual const char* ToCString() const {
     if (IsNull()) {
       return "null";
     } else {
       return "Object";
     }
@@ skipping 13 matching lines @@
   void Print() const;
 
   bool IsZoneHandle() const {
     return VMHandles::IsZoneHandle(reinterpret_cast<uword>(this));
   }
 
   static RawObject* Clone(const Object& src, Heap::Space space = Heap::kNew);
 
   static Object& Handle(Isolate* isolate, RawObject* raw_ptr) {
     Object* obj = reinterpret_cast<Object*>(VMHandles::AllocateHandle(isolate));
-    obj->SetRaw(raw_ptr);
+    initializeHandle(obj, raw_ptr);
     return *obj;
   }
 
   static Object& Handle() {
     return Handle(Isolate::Current(), null_);
   }
 
   static Object& Handle(Isolate* isolate) {
     return Handle(isolate, null_);
   }
 
   static Object& Handle(RawObject* raw_ptr) {
     return Handle(Isolate::Current(), raw_ptr);
   }
 
   static Object& ZoneHandle(Isolate* isolate, RawObject* raw_ptr) {
     Object* obj = reinterpret_cast<Object*>(
         VMHandles::AllocateZoneHandle(isolate));
-    obj->SetRaw(raw_ptr);
+    initializeHandle(obj, raw_ptr);
     return *obj;
   }
 
   static Object& ZoneHandle() {
     return ZoneHandle(Isolate::Current(), null_);
   }
 
   static Object& ZoneHandle(RawObject* raw_ptr) {
     return ZoneHandle(Isolate::Current(), raw_ptr);
   }
@@ skipping 119 matching lines @@
   static RawClass* CreateAndRegisterInterface(const char* cname,
                                               const Script& script,
                                               const Library& lib);
   static void RegisterClass(const Class& cls,
                             const String& name,
                             const Library& lib);
   static void RegisterPrivateClass(const Class& cls,
                                    const String& name,
                                    const Library& lib);
 
+  /* Initialize the handle based on the raw_ptr in the presence of null. */
+  static void initializeHandle(Object* obj, RawObject* raw_ptr) {
+    if (raw_ptr != Object::null()) {
+      obj->SetRaw(raw_ptr);
+    } else {
+      obj->raw_ = Object::null();
+      Object fake_object;
+      obj->set_vtable(fake_object.vtable());
+    }
+  }
+
   cpp_vtable* vtable_address() const {
     uword vtable_addr = reinterpret_cast<uword>(this);
     return reinterpret_cast<cpp_vtable*>(vtable_addr);
   }
 
   static cpp_vtable handle_vtable_;
   static cpp_vtable builtin_vtables_[kNumPredefinedCids];
 
   // The static values below are singletons shared between the different
   // isolates. They are all allocated in the non-GC'd Dart::vm_isolate_.
@@ skipping 34 matching lines @@
   static RawClass* subtypetestcache_class_;  // Class of SubtypeTestCache.
   static RawClass* api_error_class_;  // Class of ApiError.
   static RawClass* language_error_class_;  // Class of LanguageError.
   static RawClass* unhandled_exception_class_;  // Class of UnhandledException.
   static RawClass* unwind_error_class_;  // Class of UnwindError.
 
   friend void ClassTable::Register(const Class& cls);
   friend void RawObject::Validate(Isolate* isolate) const;
   friend class Closure;
   friend class SnapshotReader;
+  friend class OneByteString;
+  friend class TwoByteString;
+  friend class ExternalOneByteString;
+  friend class ExternalTwoByteString;
 
   // Disallow allocation.
   void* operator new(size_t size);
   // Disallow copy constructor.
   DISALLOW_COPY_AND_ASSIGN(Object);
 };
 
 
 class Class : public Object {
  public:
@@ skipping 270 matching lines @@
   static RawClass* New(const String& name,
                        const Script& script,
                        intptr_t token_pos);
   static RawClass* NewInterface(const String& name,
                                 const Script& script,
                                 intptr_t token_pos);
   static RawClass* NewNativeWrapper(const Library& library,
                                     const String& name,
                                     int num_fields);
 
+  // Allocate the raw string classes.
+  static RawClass* NewStringClass(intptr_t class_id);
+
   // Allocate a class representing a function signature described by
   // signature_function, which must be a closure function or a signature
   // function.
   // The class may be type parameterized unless the signature_function is in a
   // static scope. In that case, the type parameters are copied from the owner
   // class of signature_function.
   static RawClass* NewSignatureClass(const String& name,
                                      const Function& signature_function,
                                      const Script& script);
 
@@ skipping 1828 matching lines @@
 
   // Each (*node_ids)[n] has a an extracted ic data array (*arrays)[n].
   // Returns the maximum id found.
   intptr_t ExtractIcDataArraysAtCalls(
       GrowableArray<intptr_t>* node_ids,
       const GrowableObjectArray& ic_data_objs) const;
 
   // Returns an array indexed by deopt id, containing the extracted ICData.
   RawArray* ExtractTypeFeedbackArray() const;
 
+  // Returns deopt-ids of all static calls that were never resolved, i.e.,
+  // never executed.
+  void ExtractUncalledStaticCallDeoptIds(
+      GrowableArray<intptr_t>* deopt_ids) const;
+
  private:
   // An object finder visitor interface.
   class FindRawCodeVisitor : public FindObjectVisitor {
    public:
     explicit FindRawCodeVisitor(uword pc)
         : FindObjectVisitor(Isolate::Current()), pc_(pc) { }
     virtual ~FindRawCodeVisitor() { }
 
     // Check if object matches find condition.
     virtual bool FindObject(RawObject* obj);
@@ skipping 1076 matching lines @@
   intptr_t Length() const { return Smi::Value(raw_ptr()->length_); }
   static intptr_t length_offset() { return OFFSET_OF(RawString, length_); }
 
   virtual intptr_t Hash() const;
   static intptr_t hash_offset() { return OFFSET_OF(RawString, hash_); }
   static intptr_t Hash(const String& str, intptr_t begin_index, intptr_t len);
   static intptr_t Hash(const uint8_t* characters, intptr_t len);
   static intptr_t Hash(const uint16_t* characters, intptr_t len);
   static intptr_t Hash(const uint32_t* characters, intptr_t len);
 
-  virtual int32_t CharAt(intptr_t index) const;
+  int32_t CharAt(intptr_t index) const;
 
-  virtual intptr_t CharSize() const;
+  intptr_t CharSize() const;
 
   inline bool Equals(const String& str) const;
   inline bool Equals(const String& str,
                      intptr_t begin_index,  // begin index on 'str'.
                      intptr_t len) const;  // len on 'str'.
   bool Equals(const char* str) const;
   bool Equals(const uint8_t* characters, intptr_t len) const;
   bool Equals(const uint16_t* characters, intptr_t len) const;
   bool Equals(const uint32_t* characters, intptr_t len) const;
 
   virtual bool Equals(const Instance& other) const;
 
   intptr_t CompareTo(const String& other) const;
 
   bool StartsWith(const String& other) const;
 
   virtual RawInstance* Canonicalize() const;
 
   bool IsSymbol() const { return raw()->IsCanonical(); }
 
-  virtual bool IsExternal() const { return false; }
-  virtual void* GetPeer() const {
-    UNREACHABLE();
-    return NULL;
+  bool IsOneByteString() const {
+    return raw()->GetClassId() == kOneByteStringCid;
   }
 
+  bool IsTwoByteString() const {
+    return raw()->GetClassId() == kTwoByteStringCid;
+  }
+
+  bool IsExternalOneByteString() const {
+    return raw()->GetClassId() == kExternalOneByteStringCid;
+  }
+
+  bool IsExternalTwoByteString() const {
+    return raw()->GetClassId() == kExternalTwoByteStringCid;
+  }
+
+  bool IsExternal() const {
+    return RawObject::IsExternalStringClassId(raw()->GetClassId());
+  }
+
+  void* GetPeer() const;
+
   void ToUTF8(uint8_t* utf8_array, intptr_t array_len) const;
 
   // Creates a new String object from a C string that is assumed to contain
   // UTF-8 encoded characters and '\0' is considered a termination character.
   static RawString* New(const char* cstr, Heap::Space space = Heap::kNew);
 
   // Creates a new String object from an array of UTF-8 encoded characters.
   static RawString* New(const uint8_t* utf8_array,
                         intptr_t array_len,
                         Heap::Space space = Heap::kNew);
@@ skipping 83 matching lines @@
   }
 
   void SetHash(intptr_t value) const {
     // This is only safe because we create a new Smi, which does not cause
     // heap allocation.
     raw_ptr()->hash_ = Smi::New(value);
   }
 
   template<typename HandleType, typename ElementType>
   static void ReadFromImpl(SnapshotReader* reader,
-                           HandleType* str_obj,
+                           String* str_obj,
                            intptr_t len,
                            intptr_t tags,
                            Snapshot::Kind kind);
 
   HEAP_OBJECT_IMPLEMENTATION(String, Instance);
 
+  friend class Class;
   friend class Symbols;
+  friend class OneByteString;
+  friend class TwoByteString;
+  friend class ExternalOneByteString;
+  friend class ExternalTwoByteString;
 };
 
 
-class OneByteString : public String {
+class OneByteString : public AllStatic {
  public:
-  virtual int32_t CharAt(intptr_t index) const {
-    return *CharAddr(index);
+  static int32_t CharAt(const String& str, intptr_t index) {
+    return *CharAddr(str, index);
   }
 
-  virtual intptr_t CharSize() const {
-    return kOneByteChar;
-  }
+  static RawOneByteString* EscapeSpecialCharacters(const String& str,
+                                                   bool raw_str);
 
-  RawOneByteString* EscapeSpecialCharacters(bool raw_str) const;
-
-  bool EqualsIgnoringPrivateKey(const OneByteString& str) const;
+  static bool EqualsIgnoringPrivateKey(const String& str1,
+                                       const String& str2);
 
   // We use the same maximum elements for all strings.
   static const intptr_t kBytesPerElement = 1;
   static const intptr_t kMaxElements = String::kMaxElements;
 
   static intptr_t data_offset() { return OFFSET_OF(RawOneByteString, data_); }
 
   static intptr_t InstanceSize() {
     ASSERT(sizeof(RawOneByteString) == OFFSET_OF(RawOneByteString, data_));
     return 0;
   }
 
   static intptr_t InstanceSize(intptr_t len) {
-    ASSERT(sizeof(RawOneByteString) == kSizeofRawString);
+    ASSERT(sizeof(RawOneByteString) == String::kSizeofRawString);
     ASSERT(0 <= len && len <= kMaxElements);
-    return RoundedAllocationSize(
+    return String::RoundedAllocationSize(
         sizeof(RawOneByteString) + (len * kBytesPerElement));
   }
 
   static RawOneByteString* New(intptr_t len,
                                Heap::Space space);
   static RawOneByteString* New(const char* c_string,
                                Heap::Space space = Heap::kNew) {
     return New(reinterpret_cast<const uint8_t*>(c_string),
                strlen(c_string),
                space);
   }
   static RawOneByteString* New(const uint8_t* characters,
                                intptr_t len,
                                Heap::Space space);
   static RawOneByteString* New(const uint16_t* characters,
                                intptr_t len,
                                Heap::Space space);
   static RawOneByteString* New(const uint32_t* characters,
                                intptr_t len,
                                Heap::Space space);
-  static RawOneByteString* New(const OneByteString& str,
+  static RawOneByteString* New(const String& str,
                                Heap::Space space);
 
   static RawOneByteString* Concat(const String& str1,
                                   const String& str2,
                                   Heap::Space space);
   static RawOneByteString* ConcatAll(const Array& strings,
                                      intptr_t len,
                                      Heap::Space space);
 
   static RawOneByteString* Transform(int32_t (*mapping)(int32_t ch),
                                      const String& str,
                                      Heap::Space space);
 
- private:
-  uint8_t* CharAddr(intptr_t index) const {
-    // TODO(iposva): Determine if we should throw an exception here.
-    ASSERT((index >= 0) && (index < Length()));
-    return &raw_ptr()->data_[index];
+  static const ClassId kClassId = kOneByteStringCid;
+
+  static RawOneByteString* null() {
+    return reinterpret_cast<RawOneByteString*>(Object::null());
   }
 
-  HEAP_OBJECT_IMPLEMENTATION(OneByteString, String);
+ private:
+  static RawOneByteString* raw(const String& str) {
+    return reinterpret_cast<RawOneByteString*>(str.raw());
+  }
+
+  static RawOneByteString* raw_ptr(const String& str) {
+    return reinterpret_cast<RawOneByteString*>(str.raw_ptr());
+  }
+
+  static uint8_t* CharAddr(const String& str, intptr_t index) {
+    ASSERT((index >= 0) && (index < str.Length()));
+    ASSERT(str.IsOneByteString());
+    NoGCScope no_gc;
+    return &raw_ptr(str)->data_[index];
+  }
+
+  static RawOneByteString* ReadFrom(SnapshotReader* reader,
+                                    intptr_t object_id,
+                                    intptr_t tags,
+                                    Snapshot::Kind kind);
+
   friend class Class;
   friend class String;
+  friend class SnapshotReader;
 };
 
 
-class TwoByteString : public String {
+class TwoByteString : public AllStatic {
  public:
-  virtual int32_t CharAt(intptr_t index) const {
-    return *CharAddr(index);
+  static int32_t CharAt(const String& str, intptr_t index) {
+    return *CharAddr(str, index);
   }
 
-  virtual intptr_t CharSize() const {
-    return kTwoByteChar;
-  }
-
-  RawTwoByteString* EscapeSpecialCharacters(bool raw_str) const;
+  static RawTwoByteString* EscapeSpecialCharacters(const String& str,
+                                                   bool raw_str);
 
   // We use the same maximum elements for all strings.
   static const intptr_t kBytesPerElement = 2;
   static const intptr_t kMaxElements = String::kMaxElements;
 
   static intptr_t data_offset() { return OFFSET_OF(RawTwoByteString, data_); }
 
   static intptr_t InstanceSize() {
     ASSERT(sizeof(RawTwoByteString) == OFFSET_OF(RawTwoByteString, data_));
     return 0;
   }
 
   static intptr_t InstanceSize(intptr_t len) {
-    ASSERT(sizeof(RawTwoByteString) == kSizeofRawString);
+    ASSERT(sizeof(RawTwoByteString) == String::kSizeofRawString);
     ASSERT(0 <= len && len <= kMaxElements);
-    return RoundedAllocationSize(
+    return String::RoundedAllocationSize(
         sizeof(RawTwoByteString) + (len * kBytesPerElement));
   }
 
   static RawTwoByteString* New(intptr_t len,
                                Heap::Space space);
   static RawTwoByteString* New(const uint16_t* characters,
                                intptr_t len,
                                Heap::Space space);
   static RawTwoByteString* New(intptr_t utf16_len,
                                const uint32_t* characters,
                                intptr_t len,
                                Heap::Space space);
-  static RawTwoByteString* New(const TwoByteString& str,
+  static RawTwoByteString* New(const String& str,
                                Heap::Space space);
 
   static RawTwoByteString* Concat(const String& str1,
                                   const String& str2,
                                   Heap::Space space);
   static RawTwoByteString* ConcatAll(const Array& strings,
                                      intptr_t len,
                                      Heap::Space space);
 
   static RawTwoByteString* Transform(int32_t (*mapping)(int32_t ch),
                                      const String& str,
                                      Heap::Space space);
 
- private:
-  uint16_t* CharAddr(intptr_t index) const {
-    ASSERT((index >= 0) && (index < Length()));
-    return &raw_ptr()->data_[index];
+  static RawTwoByteString* null() {
+    return reinterpret_cast<RawTwoByteString*>(Object::null());
   }
 
-  HEAP_OBJECT_IMPLEMENTATION(TwoByteString, String);
+
+  static const ClassId kClassId = kTwoByteStringCid;
+
+ private:
+  static RawTwoByteString* raw(const String& str) {
+    return reinterpret_cast<RawTwoByteString*>(str.raw());
+  }
+
+  static RawTwoByteString* raw_ptr(const String& str) {
+    return reinterpret_cast<RawTwoByteString*>(str.raw_ptr());
+  }
+
+  static uint16_t* CharAddr(const String& str, intptr_t index) {
+    ASSERT((index >= 0) && (index < str.Length()));
+    ASSERT(str.IsTwoByteString());
+    NoGCScope no_gc;
+    return &raw_ptr(str)->data_[index];
+  }
+
+  static RawTwoByteString* ReadFrom(SnapshotReader* reader,
+                                    intptr_t object_id,
+                                    intptr_t tags,
+                                    Snapshot::Kind kind);
+
   friend class Class;
   friend class String;
+  friend class SnapshotReader;
 };
 
 
-class ExternalOneByteString : public String {
+class ExternalOneByteString : public AllStatic {
  public:
-  virtual int32_t CharAt(intptr_t index) const {
-    return *CharAddr(index);
+  static int32_t CharAt(const String& str, intptr_t index) {
+    return *CharAddr(str, index);
   }
 
-  virtual intptr_t CharSize() const {
-    return kOneByteChar;
-  }
-
-  virtual bool IsExternal() const { return true; }
-  virtual void* GetPeer() const {
-    return raw_ptr()->external_data_->peer();
+  static void* GetPeer(const String& str) {
+    return raw_ptr(str)->external_data_->peer();
   }
 
   // We use the same maximum elements for all strings.
   static const intptr_t kBytesPerElement = 1;
   static const intptr_t kMaxElements = String::kMaxElements;
 
   static intptr_t InstanceSize() {
-    return RoundedAllocationSize(sizeof(RawExternalOneByteString));
+    return String::RoundedAllocationSize(sizeof(RawExternalOneByteString));
   }
 
   static RawExternalOneByteString* New(const uint8_t* characters,
                                        intptr_t len,
                                        void* peer,
                                        Dart_PeerFinalizer callback,
                                        Heap::Space space);
 
- private:
-  const uint8_t* CharAddr(intptr_t index) const {
-    // TODO(iposva): Determine if we should throw an exception here.
-    ASSERT((index >= 0) && (index < Length()));
-    return &(raw_ptr()->external_data_->data()[index]);
+  static RawExternalOneByteString* null() {
+    return reinterpret_cast<RawExternalOneByteString*>(Object::null());
   }
 
-  void SetExternalData(ExternalStringData<uint8_t>* data) {
-    raw_ptr()->external_data_ = data;
+  static const ClassId kClassId = kExternalOneByteStringCid;
+
+ private:
+  static RawExternalOneByteString* raw(const String& str) {
+    return reinterpret_cast<RawExternalOneByteString*>(str.raw());
+  }
+
+  static RawExternalOneByteString* raw_ptr(const String& str) {
+    return reinterpret_cast<RawExternalOneByteString*>(str.raw_ptr());
+  }
+
+  static const uint8_t* CharAddr(const String& str, intptr_t index) {
+    ASSERT((index >= 0) && (index < str.Length()));
+    ASSERT(str.IsExternalOneByteString());
+    NoGCScope no_gc;
+    return &(raw_ptr(str)->external_data_->data()[index]);
+  }
+
+  static void SetExternalData(const String& str,
+                              ExternalStringData<uint8_t>* data) {
+    ASSERT(str.IsExternalOneByteString());
+    NoGCScope no_gc;
+    raw_ptr(str)->external_data_ = data;
   }
 
   static void Finalize(Dart_Handle handle, void* peer);
 
-  HEAP_OBJECT_IMPLEMENTATION(ExternalOneByteString, String);
+  static RawExternalOneByteString* ReadFrom(SnapshotReader* reader,
+                                            intptr_t object_id,
+                                            intptr_t tags,
+                                            Snapshot::Kind kind);
+
   friend class Class;
   friend class String;
+  friend class SnapshotReader;
 };
 
 
-class ExternalTwoByteString : public String {
+class ExternalTwoByteString : public AllStatic {
  public:
-  virtual int32_t CharAt(intptr_t index) const {
-    return *CharAddr(index);
+  static int32_t CharAt(const String& str, intptr_t index) {
+    return *CharAddr(str, index);
   }
 
-  virtual intptr_t CharSize() const {
-    return kTwoByteChar;
-  }
-
-  virtual bool IsExternal() const { return true; }
-  virtual void* GetPeer() const {
-    return raw_ptr()->external_data_->peer();
+  static void* GetPeer(const String& str) {
+    return raw_ptr(str)->external_data_->peer();
   }
 
   // We use the same maximum elements for all strings.
   static const intptr_t kBytesPerElement = 2;
   static const intptr_t kMaxElements = String::kMaxElements;
 
   static intptr_t InstanceSize() {
-    return RoundedAllocationSize(sizeof(RawExternalTwoByteString));
+    return String::RoundedAllocationSize(sizeof(RawExternalTwoByteString));
   }
 
   static RawExternalTwoByteString* New(const uint16_t* characters,
                                        intptr_t len,
                                        void* peer,
                                        Dart_PeerFinalizer callback,
                                        Heap::Space space = Heap::kNew);
 
- private:
-  const uint16_t* CharAddr(intptr_t index) const {
-    // TODO(iposva): Determine if we should throw an exception here.
-    ASSERT((index >= 0) && (index < Length()));
-    return &(raw_ptr()->external_data_->data()[index]);
+  static RawExternalTwoByteString* null() {
+    return reinterpret_cast<RawExternalTwoByteString*>(Object::null());
   }
 
-  void SetExternalData(ExternalStringData<uint16_t>* data) {
-    raw_ptr()->external_data_ = data;
+  static const ClassId kClassId = kExternalTwoByteStringCid;
+
+ private:
+  static RawExternalTwoByteString* raw(const String& str) {
+    return reinterpret_cast<RawExternalTwoByteString*>(str.raw());
+  }
+
+  static RawExternalTwoByteString* raw_ptr(const String& str) {
+    return reinterpret_cast<RawExternalTwoByteString*>(str.raw_ptr());
+  }
+
+  static const uint16_t* CharAddr(const String& str, intptr_t index) {
+    ASSERT((index >= 0) && (index < str.Length()));
+    ASSERT(str.IsExternalTwoByteString());
+    NoGCScope no_gc;
+    return &(raw_ptr(str)->external_data_->data()[index]);
+  }
+
+  static void SetExternalData(const String& str,
+                              ExternalStringData<uint16_t>* data) {
+    ASSERT(str.IsExternalTwoByteString());
+    NoGCScope no_gc;
+    raw_ptr(str)->external_data_ = data;
   }
 
   static void Finalize(Dart_Handle handle, void* peer);
 
-  HEAP_OBJECT_IMPLEMENTATION(ExternalTwoByteString, String);
+  static RawExternalTwoByteString* ReadFrom(SnapshotReader* reader,
+                                            intptr_t object_id,
+                                            intptr_t tags,
+                                            Snapshot::Kind kind);
+
   friend class Class;
   friend class String;
+  friend class SnapshotReader;
 };
 
 
 // Class Bool implements Dart core class bool.
 class Bool : public Instance {
  public:
   bool value() const {
     return raw_ptr()->value_;
   }
 
@@ skipping 1619 matching lines @@
 
 
 void Object::SetRaw(RawObject* value) {
   // NOTE: The assignment "raw_ = value" should be the first statement in
   // this function. Also do not use 'value' in this function after the
   // assignment (use 'raw_' instead).
   raw_ = value;
   if ((reinterpret_cast<uword>(raw_) & kSmiTagMask) == kSmiTag) {
     set_vtable(Smi::handle_vtable_);
     return;
-  } else if (raw_ == null_) {
-    set_vtable(handle_vtable_);
-    return;
   }
-
+  intptr_t cid = raw_->GetClassId();
+  if (cid >= kNumPredefinedCids) {
+      cid = kInstanceCid;
+  }
+  set_vtable(builtin_vtables_[cid]);
 #if defined(DEBUG)
   Isolate* isolate = Isolate::Current();
   if (FLAG_verify_handles) {
     Heap* isolate_heap = isolate->heap();
     Heap* vm_isolate_heap = Dart::vm_isolate()->heap();
     ASSERT(isolate_heap->Contains(reinterpret_cast<uword>(raw_->ptr())) ||
            vm_isolate_heap->Contains(reinterpret_cast<uword>(raw_->ptr())));
   }
+  ASSERT(builtin_vtables_[cid] ==
+         isolate->class_table()->At(cid)->ptr()->handle_vtable_);
 #endif
-  intptr_t cid = raw_->GetClassId();
-  if (cid < kNumPredefinedCids) {
-#if defined(DEBUG)
-    ASSERT(builtin_vtables_[cid] ==
-           isolate->class_table()->At(cid)->ptr()->handle_vtable_);
-#endif
-    set_vtable(builtin_vtables_[cid]);
-  } else {
-    set_vtable(builtin_vtables_[kInstanceCid]);
-  }
 }
 
 
 bool Function::HasCode() const {
   return raw_ptr()->code_ != Code::null();
 }
 
 
 intptr_t Field::Offset() const {
   ASSERT(!is_static());  // Offset is valid only for instance fields.
@@ skipping 37 matching lines @@
     if (this->CharAt(i) != str.CharAt(begin_index + i)) {
       return false;
     }
   }
   return true;
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_