Create and cache method extraction stub in the ICData.

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/bigint_operations.h"
@@ skipping 1418 matching lines @@
   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;
     }
   }
   return false;
 }
 
+
 void Class::SetFunctions(const Array& value) const {
   ASSERT(!value.IsNull());
 #if defined(DEBUG)
   // Verify that all the functions in the array have this class as owner.
   Function& func = Function::Handle();
   intptr_t len = value.Length();
   for (intptr_t i = 0; i < len; i++) {
     func ^= value.At(i);
     ASSERT(func.Owner() == raw());
   }
 #endif
   StorePointer(&raw_ptr()->functions_, value.raw());
 }
 
 
+void Class::AddFunction(const Function& function) const {
+  const Array& arr = Array::Handle(functions());
+  const Array& new_arr = Array::Handle(Array::Grow(arr, arr.Length() + 1));
+  new_arr.SetAt(arr.Length(), function);
+  SetFunctions(new_arr);
+}
+
+
 void Class::AddClosureFunction(const Function& function) const {
   GrowableObjectArray& closures =
       GrowableObjectArray::Handle(raw_ptr()->closure_functions_);
   if (closures.IsNull()) {
     closures = GrowableObjectArray::New(4);
     StorePointer(&raw_ptr()->closure_functions_, closures.raw());
   }
   ASSERT(function.IsNonImplicitClosureFunction());
   closures.Add(function);
 }
@@ skipping 1749 matching lines @@
   if (IsClosureFunction()) {
     const Object& obj = Object::Handle(raw_ptr()->data_);
     ASSERT(!obj.IsNull());
     ClosureData::Cast(obj).set_closure_allocation_stub(value);
     return;
   }
   UNREACHABLE();
 }
 
 
+RawFunction* Function::extracted_method_closure() const {
+  ASSERT(kind() == RawFunction::kMethodExtractor);
+  const Object& obj = Object::Handle(raw_ptr()->data_);
+  ASSERT(obj.IsFunction());
+  return Function::Cast(obj).raw();
+}
+
+
+void Function::set_extracted_method_closure(const Function& value) const {
+  ASSERT(kind() == RawFunction::kMethodExtractor);
+  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();
   }
   return Function::null();
 }
 
 
@@ skipping 1069 matching lines @@
       break;
     case RawFunction::kImplicitGetter:
       kind_str = " getter";
       break;
     case RawFunction::kImplicitSetter:
       kind_str = " setter";
       break;
     case RawFunction::kConstImplicitGetter:
       kind_str = " const-getter";
       break;
+    case RawFunction::kMethodExtractor:
+      kind_str = " method-extractor";
+      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 8174 matching lines @@
   }
   return result.raw();
 }
 
 
 const char* WeakProperty::ToCString() const {
   return "_WeakProperty";
 }
 
 }  // namespace dart