Revert of Rework CallApi*Stubs.

src/crankshaft/hydrogen.cc

 // Copyright 2013 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/crankshaft/hydrogen.h"
 
 #include <sstream>
 
 #include "src/allocation-site-scopes.h"
 #include "src/ast/ast-numbering.h"
@@ skipping 9223 matching lines @@
     int argc, BailoutId ast_id, ApiCallType call_type,
     TailCallMode syntactic_tail_call_mode) {
   if (function->IsJSFunction() &&
       Handle<JSFunction>::cast(function)->context()->native_context() !=
           top_info()->closure()->context()->native_context()) {
     return false;
   }
   if (syntactic_tail_call_mode == TailCallMode::kAllow) {
     return false;
   }
-  if (argc > CallApiCallbackStub::kArgMax) {
-    return false;
-  }
-
   CallOptimization optimization(function);
   if (!optimization.is_simple_api_call()) return false;
   Handle<Map> holder_map;
   for (int i = 0; i < receiver_maps->length(); ++i) {
     auto map = receiver_maps->at(i);
     // Don't inline calls to receivers requiring accesschecks.
     if (map->is_access_check_needed()) return false;
   }
   if (call_type == kCallApiFunction) {
     // Cannot embed a direct reference to the global proxy map
@@ skipping 75 matching lines @@
   ApiFunction fun(v8::ToCData<Address>(api_call_info->callback()));
   ExternalReference ref = ExternalReference(&fun,
                                             ExternalReference::DIRECT_API_CALL,
                                             isolate());
   HValue* api_function_address = Add<HConstant>(ExternalReference(ref));
 
   HValue* op_vals[] = {context(), Add<HConstant>(function), call_data, holder,
                        api_function_address, nullptr};
 
   HInstruction* call = nullptr;
-  CHECK(argc <= CallApiCallbackStub::kArgMax);
   if (!is_function) {
-    CallApiCallbackStub stub(isolate(), is_store, call_data_undefined,
+    CallApiAccessorStub stub(isolate(), is_store, call_data_undefined,
                              !optimization.is_constant_call());
     Handle<Code> code = stub.GetCode();
     HConstant* code_value = Add<HConstant>(code);
+    ApiAccessorDescriptor descriptor(isolate());
     call = New<HCallWithDescriptor>(
-        code_value, argc + 1, stub.GetCallInterfaceDescriptor(),
+        code_value, argc + 1, descriptor,
         Vector<HValue*>(op_vals, arraysize(op_vals) - 1));
-  } else {
-    CallApiCallbackStub stub(isolate(), argc, call_data_undefined);
+  } else if (argc <= CallApiFunctionWithFixedArgsStub::kMaxFixedArgs) {
+    CallApiFunctionWithFixedArgsStub stub(isolate(), argc, call_data_undefined);
     Handle<Code> code = stub.GetCode();
     HConstant* code_value = Add<HConstant>(code);
+    ApiFunctionWithFixedArgsDescriptor descriptor(isolate());
     call = New<HCallWithDescriptor>(
-        code_value, argc + 1, stub.GetCallInterfaceDescriptor(),
+        code_value, argc + 1, descriptor,
         Vector<HValue*>(op_vals, arraysize(op_vals) - 1));
     Drop(1);  // Drop function.
+  } else {
+    op_vals[arraysize(op_vals) - 1] = Add<HConstant>(argc);
+    CallApiFunctionStub stub(isolate(), call_data_undefined);
+    Handle<Code> code = stub.GetCode();
+    HConstant* code_value = Add<HConstant>(code);
+    ApiFunctionDescriptor descriptor(isolate());
+    call =
+        New<HCallWithDescriptor>(code_value, argc + 1, descriptor,
+                                 Vector<HValue*>(op_vals, arraysize(op_vals)));
+    Drop(1);  // Drop function.
   }
 
   ast_context()->ReturnInstruction(call, ast_id);
   return true;
 }
 
 
 void HOptimizedGraphBuilder::HandleIndirectCall(Call* expr, HValue* function,
                                                 int arguments_count) {
   Handle<JSFunction> known_function;
@@ skipping 4140 matching lines @@
     isolate()->GetHTracer()->TraceHydrogen(name(), graph_);
   }
 
 #ifdef DEBUG
   graph_->Verify(false);  // No full verify.
 #endif
 }
 
 }  // namespace internal
 }  // namespace v8