- Get handle vtable from a static table for predefined classes.

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 361 matching lines @@
 
  private:
   static void InitializeObject(uword address, intptr_t id, intptr_t size);
 
   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_[kNumPredefinedKinds];
 
   // The static values below are singletons shared between the different
   // isolates. They are all allocated in the non-GC'd Dart::vm_isolate_.
   static RawObject* null_;
   static RawInstance* sentinel_;
   static RawInstance* transition_sentinel_;
 
   static RawClass* class_class_;  // Class of the Class vm object.
   static RawClass* null_class_;  // Class of the null object.
   static RawClass* dynamic_class_;  // Class of the 'Dynamic' type.
@@ skipping 19 matching lines @@
   static RawClass* exception_handlers_class_;  // Class of ExceptionHandlers.
   static RawClass* context_class_;  // Class of the Context vm object.
   static RawClass* context_scope_class_;  // Class of ContextScope vm object.
   static RawClass* icdata_class_;  // Class of ICData.
   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 SnapshotReader;
 
   // Disallow allocation.
   void* operator new(size_t size);
   // Disallow copy constructor.
   DISALLOW_COPY_AND_ASSIGN(Object);
 };
 
 
@@ skipping 4463 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;
   }
-#ifdef DEBUG
-  Heap* isolate_heap = Isolate::Current()->heap();
+#if defined(DEBUG)
+  Isolate* isolate = Isolate::Current();
+  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())));
 #endif
   if (raw_ == null_) {
     set_vtable(handle_vtable_);

[siva, 2012/06/07 17:32:25]

I am wondering if we should pull the "if (raw_ == null_)" case above just after
the Smi check and return.

The rest of the code would indent better without the need for the 'else'.

[Ivan Posva, 2012/06/07 20:00:56]

Done. https://chromiumcodereview.appspot.com/10541061

On 2012/06/07 17:32:25, asiva wrote:

   } else {
-    RawClass* raw_class =
-      Isolate::Current()->class_table()->At(raw_->GetClassId());
-    set_vtable(raw_class->ptr()->handle_vtable_);
+    intptr_t cid = raw_->GetClassId();
+    if (cid < kNumPredefinedKinds) {
+      ASSERT(builtin_vtables_[cid] ==
+             isolate->class_table()->At(cid)->ptr()->handle_vtable_);
+      set_vtable(builtin_vtables_[cid]);
+    } else {
+#if !defined(DEBUG)
+      Isolate* isolate = Isolate::Current();
+#endif
+      RawClass* raw_class = isolate->class_table()->At(cid);
+      set_vtable(raw_class->ptr()->handle_vtable_);
+    }
   }
 }
 
 
 bool Function::HasCode() const {
   return raw_ptr()->code_ != Code::null();
 }
 
 
 intptr_t Field::Offset() const {
@@ skipping 33 matching lines @@
 }
 
 
 intptr_t Stackmap::SizeInBits() const {
   return (Smi::Value(raw_ptr()->bitmap_size_in_bytes_) * kBitsPerByte);
 }
 
 }  // namespace dart
 
 #endif  // VM_OBJECT_H_