[turbofan] Handle inlining of API getters/setters.

src/compiler/js-native-context-specialization.cc

 // Copyright 2015 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/compiler/js-native-context-specialization.h"
 
 #include "src/accessors.h"
 #include "src/code-factory.h"
 #include "src/compilation-dependencies.h"
 #include "src/compiler/access-builder.h"
@@ skipping 851 matching lines @@
                                                    1, 0, shared_info);
         Node* frame_state0 = graph()->NewNode(
             common()->FrameState(BailoutId::None(),
                                  OutputFrameStateCombine::Ignore(),
                                  frame_info0),
             graph()->NewNode(common()->StateValues(1), receiver),
             jsgraph()->EmptyStateValues(), jsgraph()->EmptyStateValues(),
             context, target, frame_state);
 
         // Introduce the call to the getter function.
-        value = effect = graph()->NewNode(
-            javascript()->CallFunction(
-                2, 0.0f, VectorSlotPair(),
-                ConvertReceiverMode::kNotNullOrUndefined),
-            target, receiver, context, frame_state0, effect, control);
-        control = graph()->NewNode(common()->IfSuccess(), value);
+        if (access_info.constant()->IsJSFunction()) {
+          value = effect = graph()->NewNode(
+              javascript()->CallFunction(
+                  2, 0.0f, VectorSlotPair(),
+                  ConvertReceiverMode::kNotNullOrUndefined),
+              target, receiver, context, frame_state0, effect, control);
+          control = graph()->NewNode(common()->IfSuccess(), value);
+        } else {
+          DCHECK(access_info.constant()->IsFunctionTemplateInfo());
+          Handle<FunctionTemplateInfo> function_template_info(
+              Handle<FunctionTemplateInfo>::cast(access_info.constant()));
+          DCHECK(!function_template_info->call_code()->IsUndefined(isolate()));
+          ZoneVector<Node*> stack_parameters(graph()->zone());
+          ValueEffectControl value_effect_control = InlineApiCall(
+              receiver, context, target, frame_state0, &stack_parameters,
+              effect, control, shared_info, function_template_info);
+          value = value_effect_control.value();
+          effect = value_effect_control.effect();
+          control = value_effect_control.control();
+        }
         break;
       }
       case AccessMode::kStore: {
         // We need a FrameState for the setter stub to restore the correct
         // context and return the appropriate value to fullcodegen.
         FrameStateFunctionInfo const* frame_info0 =
             common()->CreateFrameStateFunctionInfo(FrameStateType::kSetterStub,
                                                    2, 0, shared_info);
         Node* frame_state0 = graph()->NewNode(
             common()->FrameState(BailoutId::None(),
                                  OutputFrameStateCombine::Ignore(),
                                  frame_info0),
             graph()->NewNode(common()->StateValues(2), receiver, value),
             jsgraph()->EmptyStateValues(), jsgraph()->EmptyStateValues(),
             context, target, frame_state);
 
         // Introduce the call to the setter function.
-        effect = graph()->NewNode(javascript()->CallFunction(
-                                      3, 0.0f, VectorSlotPair(),
-                                      ConvertReceiverMode::kNotNullOrUndefined),
-                                  target, receiver, value, context,
-                                  frame_state0, effect, control);
-        control = graph()->NewNode(common()->IfSuccess(), effect);
+        if (access_info.constant()->IsJSFunction()) {
+          effect = graph()->NewNode(
+              javascript()->CallFunction(
+                  3, 0.0f, VectorSlotPair(),
+                  ConvertReceiverMode::kNotNullOrUndefined),
+              target, receiver, value, context, frame_state0, effect, control);
+          control = graph()->NewNode(common()->IfSuccess(), effect);
+        } else {
+          DCHECK(access_info.constant()->IsFunctionTemplateInfo());
+          Handle<FunctionTemplateInfo> function_template_info(
+              Handle<FunctionTemplateInfo>::cast(access_info.constant()));
+          DCHECK(!function_template_info->call_code()->IsUndefined(isolate()));
+          ZoneVector<Node*> stack_parameters(graph()->zone());
+          stack_parameters.push_back(value);
+          ValueEffectControl value_effect_control = InlineApiCall(
+              receiver, context, target, frame_state0, &stack_parameters,
+              effect, control, shared_info, function_template_info);
+          value = value_effect_control.value();
+          effect = value_effect_control.effect();
+          control = value_effect_control.control();
+        }
         break;
       }
     }
   } else {
     DCHECK(access_info.IsDataField());
     FieldIndex const field_index = access_info.field_index();
     Type* const field_type = access_info.field_type();
     MachineRepresentation const field_representation =
         access_info.field_representation();
     if (access_mode == AccessMode::kLoad) {
@@ skipping 405 matching lines @@
 
       // Perform the actual element access.
       effect = graph()->NewNode(simplified()->StoreElement(element_access),
                                 elements, index, value, effect, control);
     }
   }
 
   return ValueEffectControl(value, effect, control);
 }
 
+JSNativeContextSpecialization::ValueEffectControl
+JSNativeContextSpecialization::InlineApiCall(
+    Node* receiver, Node* context, Node* target, Node* frame_state,
+    ZoneVector<Node*>* stack_parameters, Node* effect, Node* control,
+    Handle<SharedFunctionInfo> shared_info,
+    Handle<FunctionTemplateInfo> function_template_info) {
+  Handle<CallHandlerInfo> call_handler_info = handle(
+      CallHandlerInfo::cast(function_template_info->call_code()), isolate());
+  Handle<Object> call_data_object(call_handler_info->data(), isolate());
+
+  // The stub always expects the receiver as the first param on the stack.
+  CallApiCallbackStub stub(
+      isolate(), static_cast<int>(stack_parameters->size()),
+      call_data_object->IsUndefined(isolate()),
+      true /* TODO(epertoso): similar to CallOptimization */);
+  CallInterfaceDescriptor call_interface_descriptor =
+      stub.GetCallInterfaceDescriptor();
+  CallDescriptor* call_descriptor = Linkage::GetStubCallDescriptor(
+      isolate(), graph()->zone(), call_interface_descriptor,
+      call_interface_descriptor.GetStackParameterCount() +
+          static_cast<int>(stack_parameters->size()) + 1,
+      CallDescriptor::kNeedsFrameState, Operator::kNoProperties,
+      MachineType::AnyTagged(), 1);
+
+  Node* data = jsgraph()->Constant(call_data_object);
+  ApiFunction function(v8::ToCData<Address>(call_handler_info->callback()));
+  Node* function_reference =
+      graph()->NewNode(common()->ExternalConstant(ExternalReference(
+          &function, ExternalReference::DIRECT_API_CALL, isolate())));
+  Node* code = jsgraph()->HeapConstant(stub.GetCode());
+
+  ZoneVector<Node*> inputs(zone());
+  inputs.push_back(code);
+
+  // CallApiCallbackStub's register arguments.
+  inputs.push_back(target);
+  inputs.push_back(data);
+  inputs.push_back(receiver);
+  inputs.push_back(function_reference);
+
+  // Stack parameters: CallApiCallbackStub expects the first one to be the
+  // receiver.
+  inputs.push_back(receiver);
+  for (Node* node : *stack_parameters) {
+    inputs.push_back(node);
+  }
+  inputs.push_back(context);
+  inputs.push_back(frame_state);
+  inputs.push_back(effect);
+  inputs.push_back(control);
+
+  Node* effect0;
+  Node* value0 = effect0 =
+      graph()->NewNode(common()->Call(call_descriptor),
+                       static_cast<int>(inputs.size()), inputs.data());
+  Node* control0 = graph()->NewNode(common()->IfSuccess(), value0);
+  return ValueEffectControl(value0, effect0, control0);
+}
+
 Node* JSNativeContextSpecialization::BuildCheckMaps(
     Node* receiver, Node* effect, Node* control,
     std::vector<Handle<Map>> const& maps) {
   HeapObjectMatcher m(receiver);
   if (m.HasValue()) {
     Handle<Map> receiver_map(m.Value()->map(), isolate());
     if (receiver_map->is_stable()) {
       for (Handle<Map> map : maps) {
         if (map.is_identical_to(receiver_map)) {
           dependencies()->AssumeMapStable(receiver_map);
@@ skipping 199 matching lines @@
   return jsgraph()->javascript();
 }
 
 SimplifiedOperatorBuilder* JSNativeContextSpecialization::simplified() const {
   return jsgraph()->simplified();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8