Implement Fast Accessor Builder

src/api.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/api.h"
 
 #include <string.h>  // For memcpy, strlen.
 #ifdef V8_USE_ADDRESS_SANITIZER
 #include <sanitizer/asan_interface.h>
 #endif  // V8_USE_ADDRESS_SANITIZER
 #include <cmath>  // For isnan.
 #include "include/v8-debug.h"
 #include "include/v8-profiler.h"
 #include "include/v8-testing.h"
 #include "src/api-natives.h"
 #include "src/assert-scope.h"
 #include "src/background-parsing-task.h"
 #include "src/base/functional.h"
 #include "src/base/platform/platform.h"
 #include "src/base/platform/time.h"
 #include "src/base/utils/random-number-generator.h"
 #include "src/bootstrapper.h"
 #include "src/char-predicates-inl.h"
 #include "src/code-stubs.h"
 #include "src/compiler.h"
+#include "src/compiler/fast-accessor-assembler.h"
 #include "src/context-measure.h"
 #include "src/contexts.h"
 #include "src/conversions-inl.h"
 #include "src/counters.h"
 #include "src/debug/debug.h"
 #include "src/deoptimizer.h"
 #include "src/execution.h"
 #include "src/global-handles.h"
 #include "src/icu_util.h"
 #include "src/isolate-inl.h"
@@ skipping 954 matching lines @@
   auto info = Utils::OpenHandle(this);
   EnsureNotInstantiated(info, "v8::FunctionTemplate::Inherit");
   i::Isolate* isolate = info->GetIsolate();
   ENTER_V8(isolate);
   info->set_parent_template(*Utils::OpenHandle(*value));
 }
 
 
 static Local<FunctionTemplate> FunctionTemplateNew(
     i::Isolate* isolate, FunctionCallback callback,
-    v8::Local<Value> fast_handler, v8::Local<Value> data,
+    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);
   i::Handle<i::FunctionTemplateInfo> obj =
       i::Handle<i::FunctionTemplateInfo>::cast(struct_obj);
   InitializeFunctionTemplate(obj);
   obj->set_do_not_cache(do_not_cache);
   int next_serial_number = 0;
   if (!do_not_cache) {
     next_serial_number = isolate->next_serial_number() + 1;
@@ skipping 20 matching lines @@
                                               FunctionCallback callback,
                                               v8::Local<Value> data,
                                               v8::Local<Signature> signature,
                                               int length) {
   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
   // Changes to the environment cannot be captured in the snapshot. Expect no
   // function templates when the isolate is created for serialization.
   DCHECK(!i_isolate->serializer_enabled());
   LOG_API(i_isolate, "FunctionTemplate::New");
   ENTER_V8(i_isolate);
-  return FunctionTemplateNew(i_isolate, callback, v8::Local<Value>(), data,
-                             signature, length, false);
+  return FunctionTemplateNew(i_isolate, callback, nullptr, data, signature,
+                             length, false);
 }
 
 
 Local<FunctionTemplate> FunctionTemplate::NewWithFastHandler(
-    Isolate* isolate, FunctionCallback callback, v8::Local<Value> fast_handler,
-    v8::Local<Value> data, v8::Local<Signature> signature, int length) {
+    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);
 }
 
@@ skipping 44 matching lines @@
   return 0;
 }
 
 
 #define SET_FIELD_WRAPPED(obj, setter, cdata) do {                      \
     i::Handle<i::Object> foreign = FromCData(obj->GetIsolate(), cdata); \
     (obj)->setter(*foreign);                                            \
   } while (false)
 
 
-void FunctionTemplate::SetCallHandler(FunctionCallback callback,
-                                      v8::Local<Value> data,
-                                      v8::Local<Value> fast_handler) {
+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();
   ENTER_V8(isolate);
   i::HandleScope scope(isolate);
   i::Handle<i::Struct> struct_obj =
       isolate->factory()->NewStruct(i::CALL_HANDLER_INFO_TYPE);
   i::Handle<i::CallHandlerInfo> obj =
       i::Handle<i::CallHandlerInfo>::cast(struct_obj);
   SET_FIELD_WRAPPED(obj, set_callback, callback);
-  if (!fast_handler.IsEmpty()) {
-    i::Handle<i::Object> code = Utils::OpenHandle(*fast_handler);
-    CHECK(code->IsCode());
+  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));
   }
   obj->set_data(*Utils::OpenHandle(*data));
   info->set_call_code(*obj);
 }
 
 
 static i::Handle<i::AccessorInfo> SetAccessorInfoProperties(
@@ skipping 3243 matching lines @@
   RETURN_TO_LOCAL_UNCHECKED(CallAsConstructor(context, argc, argv_cast), Value);
 }
 
 
 MaybeLocal<Function> Function::New(Local<Context> context,
                                    FunctionCallback callback, Local<Value> data,
                                    int length) {
   i::Isolate* isolate = Utils::OpenHandle(*context)->GetIsolate();
   LOG_API(isolate, "Function::New");
   ENTER_V8(isolate);
-  return FunctionTemplateNew(isolate, callback, Local<Value>(), data,
+  return FunctionTemplateNew(isolate, callback, nullptr, data,
                              Local<Signature>(), length, true)
       ->GetFunction(context);
 }
 
 
 Local<Function> Function::New(Isolate* v8_isolate, FunctionCallback callback,
                               Local<Value> data, int length) {
   return Function::New(v8_isolate->GetCurrentContext(), callback, data, length)
       .FromMaybe(Local<Function>());
 }
@@ skipping 3958 matching lines @@
 
 
 // TODO(svenpanne) Deprecate this.
 void Testing::DeoptimizeAll() {
   i::Isolate* isolate = i::Isolate::Current();
   i::HandleScope scope(isolate);
   internal::Deoptimizer::DeoptimizeAll(isolate);
 }
 
 
+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::GetCallTarget() {
+  return reinterpret_cast<internal::compiler::FastAccessorAssembler*>(impl_)
+      ->GetCallTarget();
+}
+
+FastAccessorBuilder::ValueId FastAccessorBuilder::GetParameter(
+    size_t parameter_no) {
+  return reinterpret_cast<internal::compiler::FastAccessorAssembler*>(impl_)
+      ->GetParameter(parameter_no);
+}
+
+FastAccessorBuilder::ValueId FastAccessorBuilder::GetInternalField(
+    ValueId value, int field_no) {
+  return reinterpret_cast<internal::compiler::FastAccessorAssembler*>(impl_)
+      ->GetInternalField(value, field_no);
+}
+
+}  // namespace experimental
+
+
 namespace internal {
 
 
 void HandleScopeImplementer::FreeThreadResources() {
   Free();
 }
 
 
 char* HandleScopeImplementer::ArchiveThread(char* storage) {
   HandleScopeData* current = isolate_->handle_scope_data();
@@ skipping 151 matching lines @@
   Address callback_address =
       reinterpret_cast<Address>(reinterpret_cast<intptr_t>(callback));
   VMState<EXTERNAL> state(isolate);
   ExternalCallbackScope call_scope(isolate, callback_address);
   callback(info);
 }
 
 
 }  // namespace internal
 }  // namespace v8