Implement Fast Accessor Builder

src/api.cc

Index: src/api.cc
diff --git a/src/api.cc b/src/api.cc
index 23829034ebd69561afd7ccb2f81cd57c5ff64a6f..af7d79cc147ca47a60abc5105792696f8b0be5b0 100644
--- a/src/api.cc
+++ b/src/api.cc
@@ -59,6 +59,9 @@
 #include "src/version.h"
 #include "src/vm-state-inl.h"
 
+// ???
+#include "src/compiler/fast-accessor-assembler.h"
+
 
 namespace v8 {
 
@@ -996,7 +999,8 @@ void FunctionTemplate::Inherit(v8::Local<FunctionTemplate> value) {
 
 
 static Local<FunctionTemplate> FunctionTemplateNew(
-    i::Isolate* isolate, FunctionCallback callback, v8::Local<Value> data,
+    i::Isolate* isolate, FunctionCallback callback,
+    experimental::FastAccessorBuilder* fast_handler, v8::Local<Value> data,
     v8::Local<Signature> signature, int length, bool do_not_cache) {
   i::Handle<i::Struct> struct_obj =
       isolate->factory()->NewStruct(i::FUNCTION_TEMPLATE_INFO_TYPE);
@@ -1014,7 +1018,7 @@ static Local<FunctionTemplate> FunctionTemplateNew(
     if (data.IsEmpty()) {
       data = v8::Undefined(reinterpret_cast<v8::Isolate*>(isolate));
     }
-    Utils::ToLocal(obj)->SetCallHandler(callback, data);
+    Utils::ToLocal(obj)->SetCallHandler(callback, data, fast_handler);
   }
   obj->set_length(length);
   obj->set_undetectable(false);
@@ -1025,6 +1029,7 @@ static Local<FunctionTemplate> FunctionTemplateNew(
   return Utils::ToLocal(obj);
 }
 
+
 Local<FunctionTemplate> FunctionTemplate::New(Isolate* isolate,
                                               FunctionCallback callback,
                                               v8::Local<Value> data,
@@ -1036,8 +1041,23 @@ Local<FunctionTemplate> FunctionTemplate::New(Isolate* isolate,
   DCHECK(!i_isolate->serializer_enabled());
   LOG_API(i_isolate, "FunctionTemplate::New");
   ENTER_V8(i_isolate);
-  return FunctionTemplateNew(
-      i_isolate, callback, data, signature, length, false);
+  return FunctionTemplateNew(i_isolate, callback, nullptr, data, signature,
+                             length, false);
+}
+
+
+Local<FunctionTemplate> FunctionTemplate::NewWithFastHandler(
+    Isolate* isolate, FunctionCallback callback,
+    experimental::FastAccessorBuilder* fast_handler, v8::Local<Value> data,
+    v8::Local<Signature> signature, int length) {
+  // TODO(vogelheim): 'fast_handler' should have a more specific type than
+  // Local<Value>.
+  i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
+  DCHECK(!i_isolate->serializer_enabled());
+  LOG_API(i_isolate, "FunctionTemplate::NewWithFastHandler");
+  ENTER_V8(i_isolate);
+  return FunctionTemplateNew(i_isolate, callback, fast_handler, data, signature,
+                             length, false);
 }
 
 
@@ -1094,8 +1114,9 @@ int TypeSwitch::match(v8::Local<Value> value) {
   } while (false)
 
 
-void FunctionTemplate::SetCallHandler(FunctionCallback callback,
-                                      v8::Local<Value> data) {
+void FunctionTemplate::SetCallHandler(
+    FunctionCallback callback, v8::Local<Value> data,
+    experimental::FastAccessorBuilder* fast_handler) {
   auto info = Utils::OpenHandle(this);
   EnsureNotInstantiated(info, "v8::FunctionTemplate::SetCallHandler");
   i::Isolate* isolate = info->GetIsolate();
@@ -1106,6 +1127,16 @@ void FunctionTemplate::SetCallHandler(FunctionCallback callback,
   i::Handle<i::CallHandlerInfo> obj =
       i::Handle<i::CallHandlerInfo>::cast(struct_obj);
   SET_FIELD_WRAPPED(obj, set_callback, callback);
+
+  if (fast_handler != nullptr) {
+    auto faa = *reinterpret_cast<internal::compiler::FastAccessorAssembler**>(
+        fast_handler);
+    i::Handle<i::Code> code = faa->Build();
+    CHECK(!code.is_null());
+    obj->set_fast_handler(*code);
+    delete fast_handler;
+  }
+
   if (data.IsEmpty()) {
     data = v8::Undefined(reinterpret_cast<v8::Isolate*>(isolate));
   }
@@ -4368,8 +4399,9 @@ MaybeLocal<Function> Function::New(Local<Context> context,
   i::Isolate* isolate = Utils::OpenHandle(*context)->GetIsolate();
   LOG_API(isolate, "Function::New");
   ENTER_V8(isolate);
-  return FunctionTemplateNew(isolate, callback, data, Local<Signature>(),
-                             length, true)->GetFunction(context);
+  return FunctionTemplateNew(isolate, callback, nullptr, data,
+                             Local<Signature>(), length, true)
+      ->GetFunction(context);
 }
 
 
@@ -8346,6 +8378,48 @@ void Testing::DeoptimizeAll() {
 }
 
 
+namespace experimental {
+
+
+FastAccessorBuilder::FastAccessorBuilder() : impl_(nullptr) {}
+
+
+FastAccessorBuilder::~FastAccessorBuilder() {
+  CHECK_NOT_NULL(impl_);
+  delete reinterpret_cast<internal::compiler::FastAccessorAssembler*>(impl_);
+}
+
+
+FastAccessorBuilder* FastAccessorBuilder::New(Isolate* isolate) {
+  i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
+  internal::compiler::FastAccessorAssembler* faa =
+      new internal::compiler::FastAccessorAssembler(i_isolate);
+  FastAccessorBuilder* fab = new FastAccessorBuilder;
+  fab->impl_ = faa;
+  return fab;
+}
+
+FastAccessorBuilder::ValueId FastAccessorBuilder::IntegerConstant(
+    int const_value) {
+  return reinterpret_cast<internal::compiler::FastAccessorAssembler*>(impl_)
+      ->IntegerConstant(const_value);
+}
+
+
+void FastAccessorBuilder::ReturnValue(ValueId value) {
+  reinterpret_cast<internal::compiler::FastAccessorAssembler*>(impl_)
+      ->ReturnValue(value);
+}
+
+
+FastAccessorBuilder::ValueId FastAccessorBuilder::GetParameter(
+    size_t parameter_no) {
+  return reinterpret_cast<internal::compiler::FastAccessorAssembler*>(impl_)
+      ->GetParameter(parameter_no);
+}
+}  // namespace experimental
+
+
 namespace internal {