Faster invocation of fields as methods.

runtime/vm/object.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/object.h"
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/cpu.h"
@@ skipping 1500 matching lines @@
 void Class::InitEmptyFields() {
   if (Object::empty_array().raw() == Array::null()) {
     // The empty array has not been initialized yet.
     return;
   }
   StorePointer(&raw_ptr()->interfaces_, Object::empty_array().raw());
   StorePointer(&raw_ptr()->constants_, Object::empty_array().raw());
   StorePointer(&raw_ptr()->canonical_types_, Object::empty_array().raw());
   StorePointer(&raw_ptr()->functions_, Object::empty_array().raw());
   StorePointer(&raw_ptr()->fields_, Object::empty_array().raw());
-  StorePointer(&raw_ptr()->no_such_method_cache_, Object::empty_array().raw());
+  StorePointer(&raw_ptr()->invocation_dispatcher_cache_,
+               Object::empty_array().raw());
 }
 
 
 bool Class::HasInstanceFields() const {
   const Array& field_array = Array::Handle(fields());
   Field& field = Field::Handle();
   for (intptr_t i = 0; i < field_array.Length(); ++i) {
     field ^= field_array.At(i);
     if (!field.is_static()) {
       return true;
@@ skipping 235 matching lines @@
       ASSERT(field.Offset() == 0);
       field.SetOffset(offset);
       offset += kWordSize;
     }
   }
   set_instance_size(RoundedAllocationSize(offset));
   set_next_field_offset(offset);
 }
 
 
-RawFunction* Class::GetNoSuchMethodDispatcher(const String& target_name,
-                                              const Array& args_desc) const {
+RawFunction* Class::GetInvocationDispatcher(const String& target_name,
+                                            const Array& args_desc,
+                                            RawFunction::Kind kind) const {
   enum {
     kNameIndex = 0,
     kArgsDescIndex,
     kFunctionIndex,
     kEntrySize
   };
 
+  ASSERT(kind == RawFunction::kNoSuchMethodDispatcher ||
+         kind == RawFunction::kInvokeFieldDispatcher);
   Function& dispatcher = Function::Handle();
-  Array& cache = Array::Handle(no_such_method_cache());
+  Array& cache = Array::Handle(invocation_dispatcher_cache());
   ASSERT(!cache.IsNull());
   String& name = String::Handle();
   Array& desc = Array::Handle();
   intptr_t i = 0;
   for (; i < cache.Length(); i += kEntrySize) {
     name ^= cache.At(i + kNameIndex);
     if (name.IsNull()) break;  // Reached last entry.
     if (!name.Equals(target_name)) continue;
     desc ^= cache.At(i + kArgsDescIndex);
-    if (desc.raw() == args_desc.raw()) {
+    if (desc.raw() != args_desc.raw()) continue;
+    dispatcher ^= cache.At(i + kFunctionIndex);
+    if (dispatcher.kind() == kind) {
       // Found match.
-      dispatcher ^= cache.At(i + kFunctionIndex);
       ASSERT(dispatcher.IsFunction());
       break;
     }
   }
 
   if (dispatcher.IsNull()) {
     if (i == cache.Length()) {
       // Allocate new larger cache.
       intptr_t new_len = (cache.Length() == 0)
           ? static_cast<intptr_t>(kEntrySize)
           : cache.Length() * 2;
       cache ^= Array::Grow(cache, new_len);
-      set_no_such_method_cache(cache);
+      set_invocation_dispatcher_cache(cache);
     }
-    dispatcher ^= CreateNoSuchMethodDispatcher(target_name, args_desc);
+    dispatcher ^= CreateInvocationDispatcher(target_name, args_desc, kind);
     cache.SetAt(i + kNameIndex, target_name);
     cache.SetAt(i + kArgsDescIndex, args_desc);
     cache.SetAt(i + kFunctionIndex, dispatcher);
   }
   return dispatcher.raw();
 }
 
 
-RawFunction* Class::CreateNoSuchMethodDispatcher(const String& target_name,
-                                                 const Array& args_desc) const {
+RawFunction* Class::CreateInvocationDispatcher(const String& target_name,
+                                               const Array& args_desc,
+                                               RawFunction::Kind kind) const {
   Function& invocation = Function::Handle(
       Function::New(String::Handle(Symbols::New(target_name)),
-                    RawFunction::kNoSuchMethodDispatcher,
+                    kind,
                     false,  // Not static.
                     false,  // Not const.
                     false,  // Not abstract.
                     false,  // Not external.
                     *this,
                     0));  // No token position.
   ArgumentsDescriptor desc(args_desc);
   invocation.set_num_fixed_parameters(desc.PositionalCount());
   invocation.SetNumOptionalParameters(desc.NamedCount(),
                                       false);  // Not positional.
@@ skipping 20 matching lines @@
     invocation.SetParameterNameAt(i, String::Handle(desc.NameAt(index)));
   }
   invocation.set_result_type(Type::Handle(Type::DynamicType()));
   invocation.set_is_visible(false);  // Not visible in stack trace.
   invocation.set_saved_args_desc(args_desc);
 
   return invocation.raw();
 }
 
 
-RawArray* Class::no_such_method_cache() const {
-  return raw_ptr()->no_such_method_cache_;
+RawArray* Class::invocation_dispatcher_cache() const {
+  return raw_ptr()->invocation_dispatcher_cache_;
 }
 
 
-void Class::set_no_such_method_cache(const Array& cache) const {
-  StorePointer(&raw_ptr()->no_such_method_cache_, cache.raw());
+void Class::set_invocation_dispatcher_cache(const Array& cache) const {
+  StorePointer(&raw_ptr()->invocation_dispatcher_cache_, cache.raw());
 }
 
 
 void Class::Finalize() const {
   ASSERT(!is_finalized());
   // Prefinalized classes have a VM internal representation and no Dart fields.
   // Their instance size  is precomputed and field offsets are known.
   if (!is_prefinalized()) {
     // Compute offsets of instance fields and instance size.
     CalculateFieldOffsets();
@@ skipping 1824 matching lines @@
 
 
 void Function::set_extracted_method_closure(const Function& value) const {
   ASSERT(kind() == RawFunction::kMethodExtractor);
   ASSERT(raw_ptr()->data_ == Object::null());
   set_data(value);
 }
 
 
 RawArray* Function::saved_args_desc() const {
-  ASSERT(kind() == RawFunction::kNoSuchMethodDispatcher);
+  ASSERT(kind() == RawFunction::kNoSuchMethodDispatcher ||
+         kind() == RawFunction::kInvokeFieldDispatcher);
   const Object& obj = Object::Handle(raw_ptr()->data_);
   ASSERT(obj.IsArray());
   return Array::Cast(obj).raw();
 }
 
 
 void Function::set_saved_args_desc(const Array& value) const {
-  ASSERT(kind() == RawFunction::kNoSuchMethodDispatcher);
+  ASSERT(kind() == RawFunction::kNoSuchMethodDispatcher ||
+         kind() == RawFunction::kInvokeFieldDispatcher);
   ASSERT(raw_ptr()->data_ == Object::null());
   set_data(value);
 }
 
 
 RawFunction* Function::parent_function() const {
   if (IsClosureFunction()) {
     const Object& obj = Object::Handle(raw_ptr()->data_);
     ASSERT(!obj.IsNull());
     return ClosureData::Cast(obj).parent_function();
@@ skipping 1129 matching lines @@
       break;
     case RawFunction::kConstImplicitGetter:
       kind_str = " const-getter";
       break;
     case RawFunction::kMethodExtractor:
       kind_str = " method-extractor";
       break;
     case RawFunction::kNoSuchMethodDispatcher:
       kind_str = " no-such-method-dispatcher";
       break;
+    case RawFunction::kInvokeFieldDispatcher:
+      kind_str = "invoke-field-dispatcher";
+      break;
     default:
       UNREACHABLE();
   }
   const char* kFormat = "Function '%s':%s%s%s%s.";
   const char* function_name = String::Handle(name()).ToCString();
   intptr_t len = OS::SNPrint(NULL, 0, kFormat, function_name,
                              static_str, abstract_str, kind_str, const_str) + 1;
   char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
   OS::SNPrint(chars, len, kFormat, function_name,
               static_str, abstract_str, kind_str, const_str);
@@ skipping 9261 matching lines @@
 }
 
 
 void MirrorReference::PrintToJSONStream(JSONStream* stream, bool ref) const {
   stream->OpenObject();
   stream->CloseObject();
 }
 
 
 }  // namespace dart