Create and cache method extraction stub in the ICData.

runtime/vm/stub_code.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/stub_code.h"
 
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/disassembler.h"
 #include "vm/flags.h"
+#include "vm/symbols.h"
 #include "vm/virtual_memory.h"
 #include "vm/visitor.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, disassemble_stubs, false, "Disassemble generated stubs.");
 
 #define STUB_CODE_DECLARE(name)                                                \
   StubEntry* StubCode::name##_entry_ = NULL;
 VM_STUB_CODE_LIST(STUB_CODE_DECLARE);
@@ skipping 126 matching lines @@
   if (FLAG_disassemble_stubs) {
     OS::Print("Code for stub '%s': {\n", name);
     Disassembler::Disassemble(code.EntryPoint(),
                               code.EntryPoint() + assembler.CodeSize());
     OS::Print("}\n");
   }
   return code.raw();
 }
 
 
+static const char* CreateMethodExtractorName(const Function& closure_function) {
+  const char* kFormat = "[MethodExtractor:%s]";
+  const char* function_name =
+      String::Handle(closure_function.name()).ToCString();
+  intptr_t len = OS::SNPrint(NULL, 0, kFormat, function_name) + 1;
+  char* chars = Isolate::Current()->current_zone()->Alloc<char>(len);
+  OS::SNPrint(chars, len, kFormat, function_name);
+  return chars;
+}
+
+
+RawFunction* StubCode::GetMethodExtractor(const Function& closure_function) {
+  Function& extractor = Function::Handle(closure_function.method_extractor());
+  if (extractor.IsNull()) {
+    Assembler assembler;
+
+    const char* name = CreateMethodExtractorName(closure_function);
+
+    StubCode::GenerateMethodExtractor(&assembler, closure_function);
+    const Code& code = Code::Handle(Code::FinalizeCode(name, &assembler));
+    if (FLAG_disassemble_stubs) {
+      OS::Print("Code for stub '%s': {\n", name);
+      Disassembler::Disassemble(code.EntryPoint(),
+                                code.EntryPoint() + assembler.CodeSize());
+      OS::Print("}\n");
+    }
+
+    const Class& cls =
+        Class::Handle(Type::Handle(Type::Function()).type_class());
+    extractor ^= Function::New(String::Handle(Symbols::New(name)),
+                               RawFunction::kMethodExtractor,
+                               false,  // Not static.
+                               false,  // Not const.
+                               false,  // Not abstract.
+                               false,  // Not external.
+                               cls,
+                               0);  // No token position.
+    extractor.SetCode(code);
+    extractor.set_extracted_method_closure(closure_function);
+  }
+  return extractor.raw();
+}
+
+
 const char* StubCode::NameOfStub(uword entry_point) {
 #define STUB_CODE_TESTER(name) \
   if ((name##_entry() != NULL) && (entry_point == name##EntryPoint())) {       \
     return ""#name;                                                            \
   }
 
   VM_STUB_CODE_LIST(STUB_CODE_TESTER);
   Isolate* isolate = Isolate::Current();
   if ((isolate != NULL) && (isolate->stub_code() != NULL)) {
     STUB_CODE_LIST(STUB_CODE_TESTER);
   }
 #undef STUB_CODE_TESTER
   return NULL;
 }
 
 }  // namespace dart