Revert of [Interpreter] Implements calls through CallICStub in the interpreter.

src/interpreter/bytecode-array-builder.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/bytecode-array-builder.h"
 #include "src/compiler.h"
 
 namespace v8 {
 namespace internal {
 namespace interpreter {
@@ skipping 1041 matching lines @@
 }
 
 void BytecodeArrayBuilder::EnsureReturn(FunctionLiteral* literal) {
   if (!exit_seen_in_block_) {
     LoadUndefined();
     SetReturnPosition(literal);
     Return();
   }
 }
 
-BytecodeArrayBuilder& BytecodeArrayBuilder::CallIC(
-    Register callable, Register receiver_args, size_t receiver_args_count,
-    int feedback_slot, TailCallMode tail_call_mode) {
-  Bytecode bytecode = BytecodeForCallIC(tail_call_mode);
+BytecodeArrayBuilder& BytecodeArrayBuilder::Call(Register callable,
+                                                 Register receiver_args,
+                                                 size_t receiver_args_count,
+                                                 int feedback_slot,
+                                                 TailCallMode tail_call_mode) {
+  Bytecode bytecode = BytecodeForCall(tail_call_mode);
   if (FitsInReg8Operand(callable) && FitsInReg8Operand(receiver_args) &&
       FitsInIdx8Operand(receiver_args_count) &&
       FitsInIdx8Operand(feedback_slot)) {
     Output(bytecode, callable.ToRawOperand(), receiver_args.ToRawOperand(),
            static_cast<uint8_t>(receiver_args_count),
            static_cast<uint8_t>(feedback_slot));
   } else if (FitsInReg16Operand(callable) &&
              FitsInReg16Operand(receiver_args) &&
              FitsInIdx16Operand(receiver_args_count) &&
              FitsInIdx16Operand(feedback_slot)) {
     bytecode = BytecodeForWideOperands(bytecode);
     Output(bytecode, callable.ToRawOperand(), receiver_args.ToRawOperand(),
            static_cast<uint16_t>(receiver_args_count),
            static_cast<uint16_t>(feedback_slot));
   } else {
     UNIMPLEMENTED();
   }
   return *this;
 }
 
-BytecodeArrayBuilder& BytecodeArrayBuilder::Call(Register callable,
-                                                 Register receiver_args,
-                                                 size_t receiver_args_count,
-                                                 TailCallMode tail_call_mode) {
-  Bytecode bytecode = BytecodeForCall(tail_call_mode);
-  if (FitsInReg8Operand(callable) && FitsInReg8Operand(receiver_args) &&
-      FitsInIdx8Operand(receiver_args_count)) {
-    Output(bytecode, callable.ToRawOperand(), receiver_args.ToRawOperand(),
-           static_cast<uint8_t>(receiver_args_count));
-  } else if (FitsInReg16Operand(callable) &&
-             FitsInReg16Operand(receiver_args) &&
-             FitsInIdx16Operand(receiver_args_count)) {
-    bytecode = BytecodeForWideOperands(bytecode);
-    Output(bytecode, callable.ToRawOperand(), receiver_args.ToRawOperand(),
-           static_cast<uint16_t>(receiver_args_count));
-  } else {
-    UNIMPLEMENTED();
-  }
-  return *this;
-}
 BytecodeArrayBuilder& BytecodeArrayBuilder::New(Register constructor,
                                                 Register first_arg,
                                                 size_t arg_count) {
   if (!first_arg.is_valid()) {
     DCHECK_EQ(0u, arg_count);
     first_arg = Register(0);
   }
   if (FitsInReg8Operand(constructor) && FitsInReg8Operand(first_arg) &&
       FitsInIdx8Operand(arg_count)) {
     Output(Bytecode::kNew, constructor.ToRawOperand(), first_arg.ToRawOperand(),
@@ skipping 321 matching lines @@
     default:
       UNREACHABLE();
       return static_cast<Bytecode>(-1);
   }
 }
 
 
 // static
 Bytecode BytecodeArrayBuilder::BytecodeForWideOperands(Bytecode bytecode) {
   switch (bytecode) {
-    case Bytecode::kCallIC:
-      return Bytecode::kCallICWide;
-    case Bytecode::kTailCallIC:
-      return Bytecode::kTailCallICWide;
     case Bytecode::kCall:
       return Bytecode::kCallWide;
     case Bytecode::kTailCall:
       return Bytecode::kTailCallWide;
     case Bytecode::kLoadIC:
       return Bytecode::kLoadICWide;
     case Bytecode::kKeyedLoadIC:
       return Bytecode::kKeyedLoadICWide;
     case Bytecode::kStoreICSloppy:
       return Bytecode::kStoreICSloppyWide;
@@ skipping 124 matching lines @@
       return Bytecode::kDeletePropertyStrict;
     case STRONG:
       UNIMPLEMENTED();
     default:
       UNREACHABLE();
   }
   return static_cast<Bytecode>(-1);
 }
 
 // static
-Bytecode BytecodeArrayBuilder::BytecodeForCallIC(TailCallMode tail_call_mode) {
-  switch (tail_call_mode) {
-    case TailCallMode::kDisallow:
-      return Bytecode::kCallIC;
-    case TailCallMode::kAllow:
-      return Bytecode::kTailCallIC;
-    default:
-      UNREACHABLE();
-  }
-  return static_cast<Bytecode>(-1);
-}
-
-// static
 Bytecode BytecodeArrayBuilder::BytecodeForCall(TailCallMode tail_call_mode) {
   switch (tail_call_mode) {
     case TailCallMode::kDisallow:
       return Bytecode::kCall;
     case TailCallMode::kAllow:
       return Bytecode::kTailCall;
     default:
       UNREACHABLE();
   }
   return static_cast<Bytecode>(-1);
@@ skipping 46 matching lines @@
 }
 
 // static
 bool BytecodeArrayBuilder::FitsInReg16OperandUntranslated(Register value) {
   return value.is_short_operand();
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8