Revert of [interpreter] Create custom call opcodes for specific argument counts

src/interpreter/interpreter.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/interpreter/interpreter.h"
 
-#include <array>
 #include <fstream>
 #include <memory>
 
 #include "src/ast/prettyprinter.h"
 #include "src/builtins/builtins-arguments.h"
 #include "src/builtins/builtins-constructor.h"
 #include "src/builtins/builtins-object.h"
 #include "src/code-factory.h"
 #include "src/compilation-info.h"
 #include "src/compiler.h"
@@ skipping 105 matching lines @@
   for (size_t index = 0; index < arraysize(dispatch_table_); ++index) {
     if (dispatch_table_[index] == nullptr) {
       dispatch_table_[index] = dispatch_table_[illegal_index];
     }
   }
 
   // Initialization should have been successful.
   DCHECK(IsDispatchTableInitialized());
 }
 
-bool Interpreter::ReuseExistingHandler(Bytecode bytecode,
-                                       OperandScale operand_scale) {
-  size_t index = GetDispatchTableIndex(bytecode, operand_scale);
-  switch (bytecode) {
-    case Bytecode::kCallProperty:
-    case Bytecode::kCallProperty0:
-    case Bytecode::kCallProperty1:
-    case Bytecode::kCallProperty2: {
-      const int offset = static_cast<int>(Bytecode::kCallProperty) -
-                         static_cast<int>(Bytecode::kCall);
-      STATIC_ASSERT(offset ==
-                    static_cast<int>(Bytecode::kCallProperty0) -
-                        static_cast<int>(Bytecode::kCall0));
-      STATIC_ASSERT(offset ==
-                    static_cast<int>(Bytecode::kCallProperty1) -
-                        static_cast<int>(Bytecode::kCall1));
-      STATIC_ASSERT(offset ==
-                    static_cast<int>(Bytecode::kCallProperty2) -
-                        static_cast<int>(Bytecode::kCall2));
-      CHECK_LT(offset, index);
-      dispatch_table_[index] = dispatch_table_[index - offset];
-      return true;
-      break;
-    }
-    default:
-      return false;
-  }
-}
-
 void Interpreter::InstallBytecodeHandler(Zone* zone, Bytecode bytecode,
                                          OperandScale operand_scale,
                                          BytecodeGeneratorFunc generator) {
   if (!Bytecodes::BytecodeHasHandler(bytecode, operand_scale)) return;
-  if (ReuseExistingHandler(bytecode, operand_scale)) return;
 
-  size_t index = GetDispatchTableIndex(bytecode, operand_scale);
   InterpreterDispatchDescriptor descriptor(isolate_);
   compiler::CodeAssemblerState state(
       isolate_, zone, descriptor, Code::ComputeFlags(Code::BYTECODE_HANDLER),
       Bytecodes::ToString(bytecode), Bytecodes::ReturnCount(bytecode));
   InterpreterAssembler assembler(&state, bytecode, operand_scale);
   if (Bytecodes::MakesCallAlongCriticalPath(bytecode)) {
     assembler.SaveBytecodeOffset();
   }
   (this->*generator)(&assembler);
   Handle<Code> code = compiler::CodeAssembler::GenerateCode(&state);
+  size_t index = GetDispatchTableIndex(bytecode, operand_scale);
   dispatch_table_[index] = code->entry();
   TraceCodegen(code);
   PROFILE(isolate_, CodeCreateEvent(
                         CodeEventListener::BYTECODE_HANDLER_TAG,
                         AbstractCode::cast(*code),
                         Bytecodes::ToString(bytecode, operand_scale).c_str()));
 }
 
 Code* Interpreter::GetBytecodeHandler(Bytecode bytecode,
                                       OperandScale operand_scale) {
@@ skipping 1996 matching lines @@
   Node* slot_id = __ BytecodeOperandIdx(3);
   Node* feedback_vector = __ LoadFeedbackVector();
   Node* context = __ GetContext();
   Node* result =
       __ CallJSWithFeedback(function, context, receiver_arg, args_count,
                             slot_id, feedback_vector, tail_call_mode);
   __ SetAccumulator(result);
   __ Dispatch();
 }
 
-void Interpreter::DoJSCallN(InterpreterAssembler* assembler, int arg_count) {
-  const int kReceiverOperandIndex = 1;
-  const int kReceiverOperandCount = 1;
-  const int kSlotOperandIndex =
-      kReceiverOperandIndex + kReceiverOperandCount + arg_count;
-  const int kBoilerplatParameterCount = 7;
-  const int kReceiverParameterIndex = 5;
-
-  Node* function_reg = __ BytecodeOperandReg(0);
-  Node* function = __ LoadRegister(function_reg);
-  std::array<Node*, Bytecodes::kMaxOperands + kBoilerplatParameterCount> temp;
-  Callable call_ic = CodeFactory::CallIC(isolate_);
-  temp[0] = __ HeapConstant(call_ic.code());
-  temp[1] = function;
-  temp[2] = __ Int32Constant(arg_count);
-  temp[3] = __ BytecodeOperandIdxInt32(kSlotOperandIndex);
-  temp[4] = __ LoadFeedbackVector();
-  for (int i = 0; i < (arg_count + kReceiverOperandCount); ++i) {
-    Node* reg = __ BytecodeOperandReg(i + kReceiverOperandIndex);
-    temp[kReceiverParameterIndex + i] = __ LoadRegister(reg);
-  }
-  temp[kReceiverParameterIndex + arg_count + kReceiverOperandCount] =
-      __ GetContext();
-  Node* result = __ CallStubN(call_ic.descriptor(), 1,
-                              arg_count + kBoilerplatParameterCount, &temp[0]);
-  __ SetAccumulator(result);
-  __ Dispatch();
-}
-
 // Call <callable> <receiver> <arg_count> <feedback_slot_id>
 //
 // Call a JSfunction or Callable in |callable| with the |receiver| and
 // |arg_count| arguments in subsequent registers. Collect type feedback
 // into |feedback_slot_id|
 void Interpreter::DoCall(InterpreterAssembler* assembler) {
   DoJSCall(assembler, TailCallMode::kDisallow);
 }
 
-void Interpreter::DoCall0(InterpreterAssembler* assembler) {
-  DoJSCallN(assembler, 0);
-}
-
-void Interpreter::DoCall1(InterpreterAssembler* assembler) {
-  DoJSCallN(assembler, 1);
-}
-
-void Interpreter::DoCall2(InterpreterAssembler* assembler) {
-  DoJSCallN(assembler, 2);
-}
-
+// CallProperty <callable> <receiver> <arg_count> <feedback_slot_id>
+//
+// Call a JSfunction or Callable in |callable| with the |receiver| and
+// |arg_count| arguments in subsequent registers. Collect type feedback into
+// |feedback_slot_id|. The callable is known to be a property of the receiver.
 void Interpreter::DoCallProperty(InterpreterAssembler* assembler) {
-  // Same as Call
-  UNREACHABLE();
-}
-
-void Interpreter::DoCallProperty0(InterpreterAssembler* assembler) {
-  // Same as Call0
-  UNREACHABLE();
-}
-
-void Interpreter::DoCallProperty1(InterpreterAssembler* assembler) {
-  // Same as Call1
-  UNREACHABLE();
-}
-
-void Interpreter::DoCallProperty2(InterpreterAssembler* assembler) {
-  // Same as Call2
-  UNREACHABLE();
+  // TODO(leszeks): Look into making the interpreter use the fact that the
+  // receiver is non-null.
+  DoJSCall(assembler, TailCallMode::kDisallow);
 }
 
 // TailCall <callable> <receiver> <arg_count> <feedback_slot_id>
 //
 // Tail call a JSfunction or Callable in |callable| with the |receiver| and
 // |arg_count| arguments in subsequent registers. Collect type feedback
 // into |feedback_slot_id|
 void Interpreter::DoTailCall(InterpreterAssembler* assembler) {
   DoJSCall(assembler, TailCallMode::kAllow);
 }
@@ skipping 39 matching lines @@
 // <first_return + 1>
 void Interpreter::DoCallRuntimeForPair(InterpreterAssembler* assembler) {
   // Call the runtime function.
   Node* function_id = __ BytecodeOperandRuntimeId(0);
   Node* first_arg_reg = __ BytecodeOperandReg(1);
   Node* first_arg = __ RegisterLocation(first_arg_reg);
   Node* args_count = __ BytecodeOperandCount(2);
   Node* context = __ GetContext();
   Node* result_pair =
       __ CallRuntimeN(function_id, context, first_arg, args_count, 2);
+
   // Store the results in <first_return> and <first_return + 1>
   Node* first_return_reg = __ BytecodeOperandReg(3);
   Node* second_return_reg = __ NextRegister(first_return_reg);
   Node* result0 = __ Projection(0, result_pair);
   Node* result1 = __ Projection(1, result_pair);
   __ StoreRegister(result0, first_return_reg);
   __ StoreRegister(result1, second_return_reg);
   __ Dispatch();
 }
 
@@ skipping 1126 matching lines @@
   __ StoreObjectField(generator, JSGeneratorObject::kContinuationOffset,
       __ SmiTag(new_state));
   __ SetAccumulator(old_state);
 
   __ Dispatch();
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8