diff --git a/src/arm/builtins-arm.cc b/src/arm/builtins-arm.cc
index 06c57b3d49..398478eecf 100644
--- a/src/arm/builtins-arm.cc
+++ b/src/arm/builtins-arm.cc
@@ -976,46 +976,6 @@ static void Generate_InterpreterPushArgs(MacroAssembler* masm, Register index,
   __ b(gt, &loop_header);
 }
 
-static void Generate_InterpreterComputeLastArgumentAddress(
-    MacroAssembler* masm, Register num_args, Register start_address,
-    Register output_reg) {
-  __ add(output_reg, num_args, Operand(1));  // Add one for receiver.
-  __ mov(output_reg, Operand(output_reg, LSL, kPointerSizeLog2));
-  __ sub(output_reg, start_address, output_reg);
-}
-
-// static
-void Builtins::Generate_InterpreterPushArgsAndCallICImpl(
-    MacroAssembler* masm, TailCallMode tail_call_mode) {
-  // ----------- S t a t e -------------
-  //  -- r0 : the number of arguments (not including the receiver)
-  //  -- r4 : the address of the first argument to be pushed. Subsequent
-  //          arguments should be consecutive above this, in the same order as
-  //          they are to be pushed onto the stack.
-  //  -- r1 : the target to call (can be any Object).
-  //  -- r3 : feedback vector slot id
-  //  -- r2 : type feedback vector
-  // -----------------------------------
-
-  {
-    FrameScope scope(masm, StackFrame::INTERNAL);
-
-    // Find the address of the last argument.
-    Generate_InterpreterComputeLastArgumentAddress(masm, r0, r4, r5);
-
-    // Push the arguments.
-    Generate_InterpreterPushArgs(masm, r4, r5, r6);
-
-    // Call via the CallIC stub.
-    CallICState call_ic_state(0, ConvertReceiverMode::kAny, tail_call_mode,
-                              true);
-    CallICStub stub(masm->isolate(), call_ic_state);
-    // TODO(mythria): This should be replaced by a TailCallStub, when we
-    // update the code to find the target IC from jump instructions.
-    __ CallStub(&stub);
-  }
-  __ Ret();
-}
 
 // static
 void Builtins::Generate_InterpreterPushArgsAndCallImpl(
@@ -1029,7 +989,9 @@ void Builtins::Generate_InterpreterPushArgsAndCallImpl(
   // -----------------------------------
 
   // Find the address of the last argument.
-  Generate_InterpreterComputeLastArgumentAddress(masm, r0, r2, r3);
+  __ add(r3, r0, Operand(1));  // Add one for receiver.
+  __ mov(r3, Operand(r3, LSL, kPointerSizeLog2));
+  __ sub(r3, r2, r3);
 
   // Push the arguments.
   Generate_InterpreterPushArgs(masm, r2, r3, r4);
@@ -1980,17 +1942,6 @@ void PrepareForTailCall(MacroAssembler* masm, Register args_reg,
   __ cmp(scratch1, Operand(0));
   __ b(ne, &done);
 
-  // Drop possible internal frame pushed for calling CallICStub.
-  // TODO(mythria): when we tail call the CallICStub, remove this.
-  {
-    Label no_internal_callic_frame;
-    __ ldr(scratch3, MemOperand(fp, StandardFrameConstants::kMarkerOffset));
-    __ cmp(scratch3, Operand(Smi::FromInt(StackFrame::INTERNAL)));
-    __ b(ne, &no_internal_callic_frame);
-    __ ldr(fp, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
-    __ bind(&no_internal_callic_frame);
-  }
-
   // Drop possible interpreter handler/stub frame.
   {
     Label no_interpreter_frame;
diff --git a/src/arm/code-stubs-arm.cc b/src/arm/code-stubs-arm.cc
index 6b6268c7aa..239eddd28e 100644
--- a/src/arm/code-stubs-arm.cc
+++ b/src/arm/code-stubs-arm.cc
@@ -2067,6 +2067,8 @@ void CallICStub::HandleArrayCase(MacroAssembler* masm, Label* miss) {
   __ cmp(r1, r5);
   __ b(ne, miss);
 
+  __ mov(r0, Operand(arg_count()));
+
   // Increment the call count for monomorphic function calls.
   __ add(r2, r2, Operand::PointerOffsetFromSmiKey(r3));
   __ add(r2, r2, Operand(FixedArray::kHeaderSize + kPointerSize));
@@ -2076,30 +2078,18 @@ void CallICStub::HandleArrayCase(MacroAssembler* masm, Label* miss) {
 
   __ mov(r2, r4);
   __ mov(r3, r1);
-  if (argc_in_register()) {
-    // Pass a default ArgumentCountKey::Any since the argc is only available
-    // in r0. We do not have the actual count here.
-    ArrayConstructorStub stub(masm->isolate());
-    __ TailCallStub(&stub);
-  } else {
-    // arg_count() is expected in r0 if the arg_count() >= 2
-    // (ArgumentCountKey::MORE_THAN_ONE).
-    ArrayConstructorStub stub(masm->isolate(), arg_count());
-    __ TailCallStub(&stub);
-  }
+  ArrayConstructorStub stub(masm->isolate(), arg_count());
+  __ TailCallStub(&stub);
 }
 
 
 void CallICStub::Generate(MacroAssembler* masm) {
-  // r0 - number of arguments if argc_in_register() is true
   // r1 - function
   // r3 - slot id (Smi)
   // r2 - vector
   Label extra_checks_or_miss, call, call_function;
-  if (!argc_in_register()) {
-    int argc = arg_count();
-    __ mov(r0, Operand(argc));
-  }
+  int argc = arg_count();
+  ParameterCount actual(argc);
 
   // The checks. First, does r1 match the recorded monomorphic target?
   __ add(r4, r2, Operand::PointerOffsetFromSmiKey(r3));
@@ -2135,6 +2125,7 @@ void CallICStub::Generate(MacroAssembler* masm) {
   __ str(r3, FieldMemOperand(r2, 0));
 
   __ bind(&call_function);
+  __ mov(r0, Operand(argc));
   __ Jump(masm->isolate()->builtins()->CallFunction(convert_mode(),
                                                     tail_call_mode()),
           RelocInfo::CODE_TARGET);
@@ -2174,6 +2165,7 @@ void CallICStub::Generate(MacroAssembler* masm) {
   __ str(ip, FieldMemOperand(r4, FixedArray::kHeaderSize));
 
   __ bind(&call);
+  __ mov(r0, Operand(argc));
   __ Jump(masm->isolate()->builtins()->Call(convert_mode(), tail_call_mode()),
           RelocInfo::CODE_TARGET);
 
@@ -2211,13 +2203,9 @@ void CallICStub::Generate(MacroAssembler* masm) {
   {
     FrameScope scope(masm, StackFrame::INTERNAL);
     CreateWeakCellStub create_stub(masm->isolate());
-    __ SmiTag(r0);
-    __ Push(r0);
     __ Push(r1);
     __ CallStub(&create_stub);
     __ Pop(r1);
-    __ Pop(r0);
-    __ SmiUntag(r0);
   }
 
   __ jmp(&call_function);
@@ -2234,10 +2222,6 @@ void CallICStub::Generate(MacroAssembler* masm) {
 void CallICStub::GenerateMiss(MacroAssembler* masm) {
   FrameAndConstantPoolScope scope(masm, StackFrame::INTERNAL);
 
-  // Store the number of arguments that is required later.
-  __ SmiTag(r0);
-  __ Push(r0);
-
   // Push the receiver and the function and feedback info.
   __ Push(r1, r2, r3);
 
@@ -2246,10 +2230,6 @@ void CallICStub::GenerateMiss(MacroAssembler* masm) {
 
   // Move result to edi and exit the internal frame.
   __ mov(r1, r0);
-
-  // Restore back the number of arguments to r0.
-  __ Pop(r0);
-  __ SmiUntag(r0);
 }
 
 
diff --git a/src/arm/interface-descriptors-arm.cc b/src/arm/interface-descriptors-arm.cc
index 433afab61b..0adee1387f 100644
--- a/src/arm/interface-descriptors-arm.cc
+++ b/src/arm/interface-descriptors-arm.cc
@@ -443,18 +443,6 @@ void InterpreterDispatchDescriptor::InitializePlatformSpecific(
   data->InitializePlatformSpecific(arraysize(registers), registers);
 }
 
-void InterpreterPushArgsAndCallICDescriptor::InitializePlatformSpecific(
-    CallInterfaceDescriptorData* data) {
-  Register registers[] = {
-      r0,  // argument count (not including receiver)
-      r4,  // address of first argument
-      r1,  // the target callable to be call
-      r3,  // slot id
-      r2   // type feedback vector
-  };
-  data->InitializePlatformSpecific(arraysize(registers), registers);
-}
-
 void InterpreterPushArgsAndCallDescriptor::InitializePlatformSpecific(
     CallInterfaceDescriptorData* data) {
   Register registers[] = {
diff --git a/src/arm64/builtins-arm64.cc b/src/arm64/builtins-arm64.cc
index 17693b3bc9..0962c88ee2 100644
--- a/src/arm64/builtins-arm64.cc
+++ b/src/arm64/builtins-arm64.cc
@@ -1981,17 +1981,6 @@ void PrepareForTailCall(MacroAssembler* masm, Register args_reg,
   __ Cmp(scratch1, Operand(0));
   __ B(ne, &done);
 
-  // Drop possible internal frame pushed for calling CallICStub.
-  // TODO(mythria): when we tail call the CallICStub, remove this.
-  {
-    Label no_internal_callic_frame;
-    __ Ldr(scratch3, MemOperand(fp, StandardFrameConstants::kMarkerOffset));
-    __ Cmp(scratch3, Operand(Smi::FromInt(StackFrame::INTERNAL)));
-    __ B(ne, &no_internal_callic_frame);
-    __ Ldr(fp, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
-    __ bind(&no_internal_callic_frame);
-  }
-
   // Drop possible interpreter handler/stub frame.
   {
     Label no_interpreter_frame;
@@ -2475,57 +2464,6 @@ void Builtins::Generate_Construct(MacroAssembler* masm) {
           RelocInfo::CODE_TARGET);
 }
 
-static void Generate_InterpreterPushArgs(MacroAssembler* masm,
-                                         Register num_args,
-                                         Register start_addr) {
-  // Find the address of the last argument.
-  __ add(x5, num_args, Operand(1));  // Add one for receiver.
-  __ lsl(x5, x5, kPointerSizeLog2);
-  __ sub(x6, start_addr, x5);
-
-  // Push the arguments.
-  Label loop_header, loop_check;
-  __ Mov(x7, jssp);
-  __ Claim(x5, 1);
-  __ B(&loop_check);
-  __ Bind(&loop_header);
-  // TODO(rmcilroy): Push two at a time once we ensure we keep stack aligned.
-  __ Ldr(x5, MemOperand(start_addr, -kPointerSize, PostIndex));
-  __ Str(x5, MemOperand(x7, -kPointerSize, PreIndex));
-  __ Bind(&loop_check);
-  __ Cmp(start_addr, x6);
-  __ B(gt, &loop_header);
-}
-
-// static
-void Builtins::Generate_InterpreterPushArgsAndCallICImpl(
-    MacroAssembler* masm, TailCallMode tail_call_mode) {
-  // ----------- S t a t e -------------
-  //  -- x0 : the number of arguments (not including the receiver)
-  //  -- x4 : the address of the first argument to be pushed. Subsequent
-  //          arguments should be consecutive above this, in the same order as
-  //          they are to be pushed onto the stack.
-  //  -- x1 : the target to call (can be any Object).
-  //  -- x3 : feedback vector slot id
-  //  -- x2 : type feedback vector
-  // -----------------------------------
-
-  {
-    FrameScope scope(masm, StackFrame::INTERNAL);
-
-    // Push arguments to stack. Clobbers x5-x7 registers.
-    Generate_InterpreterPushArgs(masm, x0, x4);
-
-    // Call via the CallIC stub.
-    CallICState call_ic_state(0, ConvertReceiverMode::kAny, tail_call_mode,
-                              true);
-    CallICStub stub(masm->isolate(), call_ic_state);
-    // TODO(mythria): This should be replaced by a TailCallStub, when we
-    // update the code to find the target IC from jump instructions.
-    __ CallStub(&stub);
-  }
-  __ Ret();
-}
 
 // static
 void Builtins::Generate_InterpreterPushArgsAndCallImpl(
@@ -2538,8 +2476,23 @@ void Builtins::Generate_InterpreterPushArgsAndCallImpl(
   //  -- x1 : the target to call (can be any Object).
   // -----------------------------------
 
-  // Push arguments to stack. Clobbers x5-x7 registers.
-  Generate_InterpreterPushArgs(masm, x0, x2);
+  // Find the address of the last argument.
+  __ add(x3, x0, Operand(1));  // Add one for receiver.
+  __ lsl(x3, x3, kPointerSizeLog2);
+  __ sub(x4, x2, x3);
+
+  // Push the arguments.
+  Label loop_header, loop_check;
+  __ Mov(x5, jssp);
+  __ Claim(x3, 1);
+  __ B(&loop_check);
+  __ Bind(&loop_header);
+  // TODO(rmcilroy): Push two at a time once we ensure we keep stack aligned.
+  __ Ldr(x3, MemOperand(x2, -kPointerSize, PostIndex));
+  __ Str(x3, MemOperand(x5, -kPointerSize, PreIndex));
+  __ Bind(&loop_check);
+  __ Cmp(x2, x4);
+  __ B(gt, &loop_header);
 
   // Call the target.
   __ Jump(masm->isolate()->builtins()->Call(ConvertReceiverMode::kAny,
diff --git a/src/arm64/code-stubs-arm64.cc b/src/arm64/code-stubs-arm64.cc
index f5ed9aafca..57a0ffde92 100644
--- a/src/arm64/code-stubs-arm64.cc
+++ b/src/arm64/code-stubs-arm64.cc
@@ -2289,7 +2289,6 @@ void CallConstructStub::Generate(MacroAssembler* masm) {
 
 
 void CallICStub::HandleArrayCase(MacroAssembler* masm, Label* miss) {
-  // x0 - number of arguments
   // x1 - function
   // x3 - slot id
   // x2 - vector
@@ -2304,6 +2303,8 @@ void CallICStub::HandleArrayCase(MacroAssembler* masm, Label* miss) {
   __ Cmp(function, scratch);
   __ B(ne, miss);
 
+  __ Mov(x0, Operand(arg_count()));
+
   // Increment the call count for monomorphic function calls.
   __ Add(feedback_vector, feedback_vector,
          Operand::UntagSmiAndScale(index, kPointerSizeLog2));
@@ -2318,31 +2319,20 @@ void CallICStub::HandleArrayCase(MacroAssembler* masm, Label* miss) {
   Register new_target_arg = index;
   __ Mov(allocation_site_arg, allocation_site);
   __ Mov(new_target_arg, function);
-  if (argc_in_register()) {
-    // Pass a default ArgumentCountKey::Any since the argc is only available
-    // in r0. We do not have the actual count here.
-    ArrayConstructorStub stub(masm->isolate());
-    __ TailCallStub(&stub);
-  } else {
-    // arg_count() is expected in r0 if the arg_count() >= 2
-    // (ArgumentCountKey::MORE_THAN_ONE).
-    ArrayConstructorStub stub(masm->isolate(), arg_count());
-    __ TailCallStub(&stub);
-  }
+  ArrayConstructorStub stub(masm->isolate(), arg_count());
+  __ TailCallStub(&stub);
 }
 
 
 void CallICStub::Generate(MacroAssembler* masm) {
   ASM_LOCATION("CallICStub");
 
-  // x0 - number of arguments if argc_in_register() is true
   // x1 - function
   // x3 - slot id (Smi)
   // x2 - vector
   Label extra_checks_or_miss, call, call_function;
-  if (!argc_in_register()) {
-    __ Mov(x0, arg_count());
-  }
+  int argc = arg_count();
+  ParameterCount actual(argc);
 
   Register function = x1;
   Register feedback_vector = x2;
@@ -2385,6 +2375,7 @@ void CallICStub::Generate(MacroAssembler* masm) {
   __ Str(index, FieldMemOperand(feedback_vector, 0));
 
   __ Bind(&call_function);
+  __ Mov(x0, argc);
   __ Jump(masm->isolate()->builtins()->CallFunction(convert_mode(),
                                                     tail_call_mode()),
           RelocInfo::CODE_TARGET);
@@ -2419,6 +2410,7 @@ void CallICStub::Generate(MacroAssembler* masm) {
   __ Str(x5, FieldMemOperand(x4, FixedArray::kHeaderSize));
 
   __ Bind(&call);
+  __ Mov(x0, argc);
   __ Jump(masm->isolate()->builtins()->Call(convert_mode(), tail_call_mode()),
           RelocInfo::CODE_TARGET);
 
@@ -2456,13 +2448,9 @@ void CallICStub::Generate(MacroAssembler* masm) {
   {
     FrameScope scope(masm, StackFrame::INTERNAL);
     CreateWeakCellStub create_stub(masm->isolate());
-    __ SmiTag(x0);
-    __ Push(x0);
     __ Push(function);
     __ CallStub(&create_stub);
     __ Pop(function);
-    __ Pop(x0);
-    __ SmiUntag(x0);
   }
 
   __ B(&call_function);
@@ -2481,10 +2469,6 @@ void CallICStub::GenerateMiss(MacroAssembler* masm) {
 
   FrameScope scope(masm, StackFrame::INTERNAL);
 
-  // Store number of arguments.
-  __ SmiTag(x0);
-  __ Push(x0);
-
   // Push the receiver and the function and feedback info.
   __ Push(x1, x2, x3);
 
@@ -2493,10 +2477,6 @@ void CallICStub::GenerateMiss(MacroAssembler* masm) {
 
   // Move result to edi and exit the internal frame.
   __ Mov(x1, x0);
-
-  // Restore number of arguments.
-  __ Pop(x0);
-  __ SmiUntag(x0);
 }
 
 
diff --git a/src/arm64/interface-descriptors-arm64.cc b/src/arm64/interface-descriptors-arm64.cc
index b59cba50b9..169c709a27 100644
--- a/src/arm64/interface-descriptors-arm64.cc
+++ b/src/arm64/interface-descriptors-arm64.cc
@@ -478,18 +478,6 @@ void InterpreterDispatchDescriptor::InitializePlatformSpecific(
   data->InitializePlatformSpecific(arraysize(registers), registers);
 }
 
-void InterpreterPushArgsAndCallICDescriptor::InitializePlatformSpecific(
-    CallInterfaceDescriptorData* data) {
-  Register registers[] = {
-      x0,  // argument count (not including receiver)
-      x4,  // address of first argument
-      x1,  // the target callable to be call
-      x3,  // slot id
-      x2   // type feedback vector
-  };
-  data->InitializePlatformSpecific(arraysize(registers), registers);
-}
-
 void InterpreterPushArgsAndCallDescriptor::InitializePlatformSpecific(
     CallInterfaceDescriptorData* data) {
   Register registers[] = {
diff --git a/src/builtins.cc b/src/builtins.cc
index 1eb6e89927..ae07df23cb 100644
--- a/src/builtins.cc
+++ b/src/builtins.cc
@@ -3999,18 +3999,6 @@ Handle<Code> Builtins::InterpreterPushArgsAndCall(TailCallMode tail_call_mode) {
   return Handle<Code>::null();
 }
 
-Handle<Code> Builtins::InterpreterPushArgsAndCallIC(
-    TailCallMode tail_call_mode) {
-  switch (tail_call_mode) {
-    case TailCallMode::kDisallow:
-      return InterpreterPushArgsAndCallIC();
-    case TailCallMode::kAllow:
-      return InterpreterPushArgsAndTailCallIC();
-  }
-  UNREACHABLE();
-  return Handle<Code>::null();
-}
-
 namespace {
 
 class RelocatableArguments
diff --git a/src/builtins.h b/src/builtins.h
index e35079c09e..93e6e3d7f2 100644
--- a/src/builtins.h
+++ b/src/builtins.h
@@ -216,8 +216,6 @@ inline bool operator&(BuiltinExtraArguments lhs, BuiltinExtraArguments rhs) {
                                                                                \
   V(InterpreterEntryTrampoline, BUILTIN, UNINITIALIZED, kNoExtraICState)       \
   V(InterpreterExitTrampoline, BUILTIN, UNINITIALIZED, kNoExtraICState)        \
-  V(InterpreterPushArgsAndCallIC, BUILTIN, UNINITIALIZED, kNoExtraICState)     \
-  V(InterpreterPushArgsAndTailCallIC, BUILTIN, UNINITIALIZED, kNoExtraICState) \
   V(InterpreterPushArgsAndCall, BUILTIN, UNINITIALIZED, kNoExtraICState)       \
   V(InterpreterPushArgsAndTailCall, BUILTIN, UNINITIALIZED, kNoExtraICState)   \
   V(InterpreterPushArgsAndConstruct, BUILTIN, UNINITIALIZED, kNoExtraICState)  \
@@ -369,7 +367,6 @@ class Builtins {
                     TailCallMode tail_call_mode = TailCallMode::kDisallow);
   Handle<Code> CallBoundFunction(TailCallMode tail_call_mode);
   Handle<Code> InterpreterPushArgsAndCall(TailCallMode tail_call_mode);
-  Handle<Code> InterpreterPushArgsAndCallIC(TailCallMode tail_call_mode);
 
   Code* builtin(Name name) {
     // Code::cast cannot be used here since we access builtins
@@ -585,16 +582,6 @@ class Builtins {
 
   static void Generate_InterpreterEntryTrampoline(MacroAssembler* masm);
   static void Generate_InterpreterExitTrampoline(MacroAssembler* masm);
-  static void Generate_InterpreterPushArgsAndCallIC(MacroAssembler* masm) {
-    return Generate_InterpreterPushArgsAndCallICImpl(masm,
-                                                     TailCallMode::kDisallow);
-  }
-  static void Generate_InterpreterPushArgsAndTailCallIC(MacroAssembler* masm) {
-    return Generate_InterpreterPushArgsAndCallICImpl(masm,
-                                                     TailCallMode::kAllow);
-  }
-  static void Generate_InterpreterPushArgsAndCallICImpl(
-      MacroAssembler* masm, TailCallMode tail_call_mode);
   static void Generate_InterpreterPushArgsAndCall(MacroAssembler* masm) {
     return Generate_InterpreterPushArgsAndCallImpl(masm,
                                                    TailCallMode::kDisallow);
diff --git a/src/code-factory.cc b/src/code-factory.cc
index cc47d5ec37..acec002c40 100644
--- a/src/code-factory.cc
+++ b/src/code-factory.cc
@@ -345,13 +345,6 @@ Callable CodeFactory::ConstructFunction(Isolate* isolate) {
                   ConstructTrampolineDescriptor(isolate));
 }
 
-// static
-Callable CodeFactory::InterpreterPushArgsAndCallIC(
-    Isolate* isolate, TailCallMode tail_call_mode) {
-  return Callable(
-      isolate->builtins()->InterpreterPushArgsAndCallIC(tail_call_mode),
-      InterpreterPushArgsAndCallICDescriptor(isolate));
-}
 
 // static
 Callable CodeFactory::InterpreterPushArgsAndCall(Isolate* isolate,
@@ -361,6 +354,7 @@ Callable CodeFactory::InterpreterPushArgsAndCall(Isolate* isolate,
       InterpreterPushArgsAndCallDescriptor(isolate));
 }
 
+
 // static
 Callable CodeFactory::InterpreterPushArgsAndConstruct(Isolate* isolate) {
   return Callable(isolate->builtins()->InterpreterPushArgsAndConstruct(),
diff --git a/src/code-factory.h b/src/code-factory.h
index 81cdc3b702..fb1a165053 100644
--- a/src/code-factory.h
+++ b/src/code-factory.h
@@ -106,8 +106,6 @@ class CodeFactory final {
   static Callable Construct(Isolate* isolate);
   static Callable ConstructFunction(Isolate* isolate);
 
-  static Callable InterpreterPushArgsAndCallIC(Isolate* isolate,
-                                               TailCallMode tail_call_mode);
   static Callable InterpreterPushArgsAndCall(Isolate* isolate,
                                              TailCallMode tail_call_mode);
   static Callable InterpreterPushArgsAndConstruct(Isolate* isolate);
diff --git a/src/code-stubs.h b/src/code-stubs.h
index f58fbc09b8..4f3020ed5d 100644
--- a/src/code-stubs.h
+++ b/src/code-stubs.h
@@ -973,13 +973,9 @@ class CallICStub: public PlatformCodeStub {
   }
 
  protected:
-  int arg_count() const {
-    DCHECK(!argc_in_register());
-    return state().argc();
-  }
+  int arg_count() const { return state().argc(); }
   ConvertReceiverMode convert_mode() const { return state().convert_mode(); }
   TailCallMode tail_call_mode() const { return state().tail_call_mode(); }
-  bool argc_in_register() const { return state().argc_in_register(); }
 
   CallICState state() const {
     return CallICState(static_cast<ExtraICState>(minor_key_));
diff --git a/src/compiler/bytecode-graph-builder.cc b/src/compiler/bytecode-graph-builder.cc
index 1fe11b33ed..e28c19d844 100644
--- a/src/compiler/bytecode-graph-builder.cc
+++ b/src/compiler/bytecode-graph-builder.cc
@@ -501,7 +501,10 @@ Node* BytecodeGraphBuilder::BuildLoadNativeContextField(int index) {
 
 
 VectorSlotPair BytecodeGraphBuilder::CreateVectorSlotPair(int slot_id) {
-  FeedbackVectorSlot slot = feedback_vector()->ToSlot(slot_id);
+  FeedbackVectorSlot slot;
+  if (slot_id >= TypeFeedbackVector::kReservedIndexCount) {
+    slot = feedback_vector()->ToSlot(slot_id);
+  }
   return VectorSlotPair(feedback_vector(), slot);
 }
 
@@ -989,42 +992,6 @@ Node* BytecodeGraphBuilder::ProcessCallArguments(const Operator* call_op,
   return value;
 }
 
-void BytecodeGraphBuilder::BuildCallWithFeedbackSlot(
-    TailCallMode tail_call_mode) {
-  FrameStateBeforeAndAfter states(this);
-  // TODO(rmcilroy): Set receiver_hint correctly based on whether the receiver
-  // register has been loaded with null / undefined explicitly or we are sure it
-  // is not null / undefined.
-  ConvertReceiverMode receiver_hint = ConvertReceiverMode::kAny;
-  Node* callee =
-      environment()->LookupRegister(bytecode_iterator().GetRegisterOperand(0));
-  interpreter::Register receiver = bytecode_iterator().GetRegisterOperand(1);
-  size_t arg_count = bytecode_iterator().GetRegisterCountOperand(2);
-  int slot_id = bytecode_iterator().GetIndexOperand(3);
-  VectorSlotPair feedback = CreateVectorSlotPair(slot_id);
-
-  const Operator* call = javascript()->CallFunction(
-      arg_count + 1, feedback, receiver_hint, tail_call_mode);
-  Node* value = ProcessCallArguments(call, callee, receiver, arg_count + 1);
-  environment()->BindAccumulator(value, &states);
-}
-
-void BytecodeGraphBuilder::VisitCallIC() {
-  BuildCallWithFeedbackSlot(TailCallMode::kDisallow);
-}
-
-void BytecodeGraphBuilder::VisitCallICWide() {
-  BuildCallWithFeedbackSlot(TailCallMode::kDisallow);
-}
-
-void BytecodeGraphBuilder::VisitTailCallIC() {
-  BuildCallWithFeedbackSlot(TailCallMode::kAllow);
-}
-
-void BytecodeGraphBuilder::VisitTailCallICWide() {
-  BuildCallWithFeedbackSlot(TailCallMode::kAllow);
-}
-
 void BytecodeGraphBuilder::BuildCall(TailCallMode tail_call_mode) {
   FrameStateBeforeAndAfter states(this);
   // TODO(rmcilroy): Set receiver_hint correctly based on whether the receiver
@@ -1035,9 +1002,11 @@ void BytecodeGraphBuilder::BuildCall(TailCallMode tail_call_mode) {
       environment()->LookupRegister(bytecode_iterator().GetRegisterOperand(0));
   interpreter::Register receiver = bytecode_iterator().GetRegisterOperand(1);
   size_t arg_count = bytecode_iterator().GetRegisterCountOperand(2);
+  VectorSlotPair feedback =
+      CreateVectorSlotPair(bytecode_iterator().GetIndexOperand(3));
 
   const Operator* call = javascript()->CallFunction(
-      arg_count + 1, VectorSlotPair(), receiver_hint, tail_call_mode);
+      arg_count + 1, feedback, receiver_hint, tail_call_mode);
   Node* value = ProcessCallArguments(call, callee, receiver, arg_count + 1);
   environment()->BindAccumulator(value, &states);
 }
diff --git a/src/compiler/bytecode-graph-builder.h b/src/compiler/bytecode-graph-builder.h
index d55db8e434..2fa5967c86 100644
--- a/src/compiler/bytecode-graph-builder.h
+++ b/src/compiler/bytecode-graph-builder.h
@@ -124,7 +124,6 @@ class BytecodeGraphBuilder {
   void BuildLdaLookupSlot(TypeofMode typeof_mode);
   void BuildStaLookupSlot(LanguageMode language_mode);
   void BuildCall(TailCallMode tail_call_mode);
-  void BuildCallWithFeedbackSlot(TailCallMode tail_call_mode);
   void BuildCallJSRuntime();
   void BuildCallRuntime();
   void BuildCallRuntimeForPair();
diff --git a/src/ia32/builtins-ia32.cc b/src/ia32/builtins-ia32.cc
index 314aac0506..acaecd110c 100644
--- a/src/ia32/builtins-ia32.cc
+++ b/src/ia32/builtins-ia32.cc
@@ -559,58 +559,6 @@ static void Generate_InterpreterPushArgs(MacroAssembler* masm,
   __ j(greater, &loop_header, Label::kNear);
 }
 
-static void Generate_InterpreterComputeLastArgumentAddress(MacroAssembler* masm,
-                                                           Register r) {
-  // Find the address of the last argument.
-  // ----------- S t a t e -------------
-  //  input: eax : Number of arguments.
-  //  input: ebx : Address of the first argument.
-  //  output: Register |r|: Address of the last argument.
-  // -----------------------------------
-  __ mov(r, eax);
-  __ add(r, Immediate(1));  // Add one for receiver.
-  __ shl(r, kPointerSizeLog2);
-  __ neg(r);
-  __ add(r, ebx);
-}
-
-// static
-void Builtins::Generate_InterpreterPushArgsAndCallICImpl(
-    MacroAssembler* masm, TailCallMode tail_call_mode) {
-  // ----------- S t a t e -------------
-  //  -- eax : the number of arguments (not including the receiver)
-  //  -- ebx : the address of the first argument to be pushed. Subsequent
-  //           arguments should be consecutive above this, in the same order as
-  //           they are to be pushed onto the stack.
-  //  -- edi : the target to call (can be any Object).
-  //  -- edx : feedback slot id.
-  //  -- ecx : type feedback vector.
-  // -----------------------------------
-
-  {
-    FrameScope scope(masm, StackFrame::INTERNAL);
-    // Store type feedback vector on the stack since we ran out of registers.
-    __ Push(ecx);
-
-    // computes the address of last argument in ecx.
-    // ecx = ebx - (eax + 1) * kPointerSize.
-    Generate_InterpreterComputeLastArgumentAddress(masm, ecx);
-    Generate_InterpreterPushArgs(masm, ecx);
-
-    // Restore feedback vector to ebx from the stack. It was pushed
-    // before the arguments were pushed, so compute the correct offset.
-    __ mov(ebx, Operand(esp, eax, times_pointer_size, 1 * kPointerSize));
-
-    // Call via the CallIC stub.
-    CallICState call_ic_state(0, ConvertReceiverMode::kAny, tail_call_mode,
-                              true);
-    CallICStub stub(masm->isolate(), call_ic_state);
-    // TODO(mythria): This should be replaced by a TailCallStub, when we
-    // update the code to find the target IC from jump instructions.
-    __ CallStub(&stub);
-  }
-  __ Ret();
-}
 
 // static
 void Builtins::Generate_InterpreterPushArgsAndCallImpl(
@@ -626,9 +574,13 @@ void Builtins::Generate_InterpreterPushArgsAndCallImpl(
   // Pop return address to allow tail-call after pushing arguments.
   __ Pop(edx);
 
-  // computes the address of last argument in ecx.
-  // ecx = ebx - (eax + 1) * kPointerSize.
-  Generate_InterpreterComputeLastArgumentAddress(masm, ecx);
+  // Find the address of the last argument.
+  __ mov(ecx, eax);
+  __ add(ecx, Immediate(1));  // Add one for receiver.
+  __ shl(ecx, kPointerSizeLog2);
+  __ neg(ecx);
+  __ add(ecx, ebx);
+
   Generate_InterpreterPushArgs(masm, ecx);
 
   // Call the target.
@@ -638,6 +590,7 @@ void Builtins::Generate_InterpreterPushArgsAndCallImpl(
           RelocInfo::CODE_TARGET);
 }
 
+
 // static
 void Builtins::Generate_InterpreterPushArgsAndConstruct(MacroAssembler* masm) {
   // ----------- S t a t e -------------
@@ -649,24 +602,27 @@ void Builtins::Generate_InterpreterPushArgsAndConstruct(MacroAssembler* masm) {
   //           they are to be pushed onto the stack.
   // -----------------------------------
 
+  // Save number of arguments on the stack below where arguments are going
+  // to be pushed.
+  __ mov(ecx, eax);
+  __ neg(ecx);
+  __ mov(Operand(esp, ecx, times_pointer_size, -kPointerSize), eax);
+  __ mov(eax, ecx);
+
   // Pop return address to allow tail-call after pushing arguments.
   __ Pop(ecx);
 
-  // Push edi in the slot meant for receiver. We need an extra register so
-  // store edi temporarily on the stack.
-  __ Push(edi);
-
   // Find the address of the last argument.
-  __ mov(edi, eax);
-  __ neg(edi);
-  __ shl(edi, kPointerSizeLog2);
-  __ add(edi, ebx);
+  __ shl(eax, kPointerSizeLog2);
+  __ add(eax, ebx);
 
-  Generate_InterpreterPushArgs(masm, edi);
+  // Push padding for receiver.
+  __ Push(Immediate(0));
 
-  // Restore number of arguments from slot on stack. edi was pushed at
-  // the slot meant for receiver.
-  __ mov(edi, Operand(esp, eax, times_pointer_size, 0));
+  Generate_InterpreterPushArgs(masm, eax);
+
+  // Restore number of arguments from slot on stack.
+  __ mov(eax, Operand(esp, -kPointerSize));
 
   // Re-push return address.
   __ Push(ecx);
@@ -1917,17 +1873,6 @@ void PrepareForTailCall(MacroAssembler* masm, Register args_reg,
   __ cmp(scratch1, Immediate(0));
   __ j(not_equal, &done, Label::kNear);
 
-  // Drop possible internal frame pushed for calling CallICStub.
-  // TODO(mythria): when we tail call the CallICStub, remove this.
-  {
-    Label no_internal_callic_frame;
-    __ cmp(Operand(ebp, StandardFrameConstants::kMarkerOffset),
-           Immediate(Smi::FromInt(StackFrame::INTERNAL)));
-    __ j(not_equal, &no_internal_callic_frame, Label::kNear);
-    __ mov(ebp, Operand(ebp, StandardFrameConstants::kCallerFPOffset));
-    __ bind(&no_internal_callic_frame);
-  }
-
   // Drop possible interpreter handler/stub frame.
   {
     Label no_interpreter_frame;
diff --git a/src/ia32/code-stubs-ia32.cc b/src/ia32/code-stubs-ia32.cc
index 9a9e7dd2c4..2565c45d31 100644
--- a/src/ia32/code-stubs-ia32.cc
+++ b/src/ia32/code-stubs-ia32.cc
@@ -1624,11 +1624,11 @@ void CallICStub::HandleArrayCase(MacroAssembler* masm, Label* miss) {
   // edi - function
   // edx - slot id
   // ebx - vector
-  // eax - number of arguments - if argc_in_register() is true.
   __ LoadGlobalFunction(Context::ARRAY_FUNCTION_INDEX, ecx);
   __ cmp(edi, ecx);
   __ j(not_equal, miss);
 
+  __ mov(eax, arg_count());
   // Reload ecx.
   __ mov(ecx, FieldOperand(ebx, edx, times_half_pointer_size,
                            FixedArray::kHeaderSize));
@@ -1640,17 +1640,9 @@ void CallICStub::HandleArrayCase(MacroAssembler* masm, Label* miss) {
 
   __ mov(ebx, ecx);
   __ mov(edx, edi);
-  if (argc_in_register()) {
-    // Pass a default ArgumentCountKey::Any since the argc is only available
-    // in eax. We do not have the actual count here.
-    ArrayConstructorStub stub(masm->isolate());
-    __ TailCallStub(&stub);
-  } else {
-    // arg_count() is expected in rax if the arg_count() >= 2
-    // (ArgumentCountKey::MORE_THAN_ONE).
-    ArrayConstructorStub stub(masm->isolate(), arg_count());
-    __ TailCallStub(&stub);
-  }
+  ArrayConstructorStub stub(masm->isolate(), arg_count());
+  __ TailCallStub(&stub);
+
   // Unreachable.
 }
 
@@ -1659,13 +1651,10 @@ void CallICStub::Generate(MacroAssembler* masm) {
   // edi - function
   // edx - slot id
   // ebx - vector
-  // eax - number of arguments - if argc_in_register() is true.
   Isolate* isolate = masm->isolate();
   Label extra_checks_or_miss, call, call_function;
-  if (!argc_in_register()) {
-    int argc = arg_count();
-    __ Set(eax, argc);
-  }
+  int argc = arg_count();
+  ParameterCount actual(argc);
 
   // The checks. First, does edi match the recorded monomorphic target?
   __ mov(ecx, FieldOperand(ebx, edx, times_half_pointer_size,
@@ -1698,6 +1687,7 @@ void CallICStub::Generate(MacroAssembler* masm) {
          Immediate(Smi::FromInt(CallICNexus::kCallCountIncrement)));
 
   __ bind(&call_function);
+  __ Set(eax, argc);
   __ Jump(masm->isolate()->builtins()->CallFunction(convert_mode(),
                                                     tail_call_mode()),
           RelocInfo::CODE_TARGET);
@@ -1737,6 +1727,7 @@ void CallICStub::Generate(MacroAssembler* masm) {
       Immediate(TypeFeedbackVector::MegamorphicSentinel(isolate)));
 
   __ bind(&call);
+  __ Set(eax, argc);
   __ Jump(masm->isolate()->builtins()->Call(convert_mode(), tail_call_mode()),
           RelocInfo::CODE_TARGET);
 
@@ -1773,15 +1764,9 @@ void CallICStub::Generate(MacroAssembler* masm) {
   {
     FrameScope scope(masm, StackFrame::INTERNAL);
     CreateWeakCellStub create_stub(isolate);
-    __ SmiTag(eax);
-    __ push(eax);
     __ push(edi);
-
     __ CallStub(&create_stub);
-
     __ pop(edi);
-    __ pop(eax);
-    __ SmiUntag(eax);
   }
 
   __ jmp(&call_function);
@@ -1801,9 +1786,6 @@ void CallICStub::Generate(MacroAssembler* masm) {
 void CallICStub::GenerateMiss(MacroAssembler* masm) {
   FrameScope scope(masm, StackFrame::INTERNAL);
 
-  // Store eax since we need it later.
-  __ SmiTag(eax);
-  __ push(eax);
   // Push the function and feedback info.
   __ push(edi);
   __ push(ebx);
@@ -1814,10 +1796,6 @@ void CallICStub::GenerateMiss(MacroAssembler* masm) {
 
   // Move result to edi and exit the internal frame.
   __ mov(edi, eax);
-
-  // Restore eax.
-  __ pop(eax);
-  __ SmiUntag(eax);
 }
 
 
diff --git a/src/ia32/interface-descriptors-ia32.cc b/src/ia32/interface-descriptors-ia32.cc
index bd8a2dac23..f138bff38f 100644
--- a/src/ia32/interface-descriptors-ia32.cc
+++ b/src/ia32/interface-descriptors-ia32.cc
@@ -433,18 +433,6 @@ void InterpreterPushArgsAndCallDescriptor::InitializePlatformSpecific(
   data->InitializePlatformSpecific(arraysize(registers), registers);
 }
 
-void InterpreterPushArgsAndCallICDescriptor::InitializePlatformSpecific(
-    CallInterfaceDescriptorData* data) {
-  Register registers[] = {
-      eax,  // argument count (not including receiver)
-      ebx,  // address of first argument
-      edi,  // the target callable to be call
-      edx,  // feedback vector slot id
-      ecx   // type feedback vector
-  };
-  data->InitializePlatformSpecific(arraysize(registers), registers);
-}
-
 void InterpreterPushArgsAndConstructDescriptor::InitializePlatformSpecific(
     CallInterfaceDescriptorData* data) {
   Register registers[] = {
diff --git a/src/ic/ic-state.h b/src/ic/ic-state.h
index bd8df781ab..e1d33f8678 100644
--- a/src/ic/ic-state.h
+++ b/src/ic/ic-state.h
@@ -26,11 +26,10 @@ class CallICState final BASE_EMBEDDED {
   explicit CallICState(ExtraICState extra_ic_state)
       : bit_field_(extra_ic_state) {}
   CallICState(int argc, ConvertReceiverMode convert_mode,
-              TailCallMode tail_call_mode, bool is_argc_in_reg = false)
+              TailCallMode tail_call_mode)
       : bit_field_(ArgcBits::encode(argc) |
                    ConvertModeBits::encode(convert_mode) |
-                   TailCallModeBits::encode(tail_call_mode) |
-                   ArgcInRegBits::encode(is_argc_in_reg)) {}
+                   TailCallModeBits::encode(tail_call_mode)) {}
 
   ExtraICState GetExtraICState() const { return bit_field_; }
 
@@ -45,13 +44,11 @@ class CallICState final BASE_EMBEDDED {
   TailCallMode tail_call_mode() const {
     return TailCallModeBits::decode(bit_field_);
   }
-  bool argc_in_register() { return ArgcInRegBits::decode(bit_field_); }
 
  private:
   typedef BitField<int, 0, Code::kArgumentsBits> ArgcBits;
   typedef BitField<ConvertReceiverMode, ArgcBits::kNext, 2> ConvertModeBits;
   typedef BitField<TailCallMode, ConvertModeBits::kNext, 1> TailCallModeBits;
-  typedef BitField<bool, TailCallModeBits::kNext, 1> ArgcInRegBits;
 
   int const bit_field_;
 };
diff --git a/src/interface-descriptors.h b/src/interface-descriptors.h
index 222d06ffac..d62bee5203 100644
--- a/src/interface-descriptors.h
+++ b/src/interface-descriptors.h
@@ -78,7 +78,6 @@ class PlatformInterfaceDescriptor;
   V(GrowArrayElements)                        \
   V(InterpreterDispatch)                      \
   V(InterpreterPushArgsAndCall)               \
-  V(InterpreterPushArgsAndCallIC)             \
   V(InterpreterPushArgsAndConstruct)          \
   V(InterpreterCEntry)
 
@@ -758,18 +757,13 @@ class InterpreterDispatchDescriptor  : public CallInterfaceDescriptor {
   static const int kContextParameter = 5;
 };
 
-class InterpreterPushArgsAndCallICDescriptor : public CallInterfaceDescriptor {
- public:
-  DECLARE_DESCRIPTOR(InterpreterPushArgsAndCallICDescriptor,
-                     CallInterfaceDescriptor)
-};
-
 class InterpreterPushArgsAndCallDescriptor : public CallInterfaceDescriptor {
  public:
   DECLARE_DESCRIPTOR(InterpreterPushArgsAndCallDescriptor,
                      CallInterfaceDescriptor)
 };
 
+
 class InterpreterPushArgsAndConstructDescriptor
     : public CallInterfaceDescriptor {
  public:
diff --git a/src/interpreter/bytecode-array-builder.cc b/src/interpreter/bytecode-array-builder.cc
index 6b764bf60b..7103c72178 100644
--- a/src/interpreter/bytecode-array-builder.cc
+++ b/src/interpreter/bytecode-array-builder.cc
@@ -1059,10 +1059,12 @@ void BytecodeArrayBuilder::EnsureReturn(FunctionLiteral* literal) {
   }
 }
 
-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)) {
@@ -1083,26 +1085,6 @@ BytecodeArrayBuilder& BytecodeArrayBuilder::CallIC(
   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) {
@@ -1444,10 +1426,6 @@ Bytecode BytecodeArrayBuilder::BytecodeForCompareOperation(Token::Value op) {
 // 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:
@@ -1591,19 +1569,6 @@ Bytecode BytecodeArrayBuilder::BytecodeForDelete(LanguageMode language_mode) {
   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) {
diff --git a/src/interpreter/bytecode-array-builder.h b/src/interpreter/bytecode-array-builder.h
index a777c266c7..fe69337184 100644
--- a/src/interpreter/bytecode-array-builder.h
+++ b/src/interpreter/bytecode-array-builder.h
@@ -163,28 +163,18 @@ class BytecodeArrayBuilder final : public ZoneObject, private RegisterMover {
   // <receiver_args + receiver_arg_count - 1>.
   BytecodeArrayBuilder& Call(
       Register callable, Register receiver_args, size_t receiver_arg_count,
-      TailCallMode tail_call_mode = TailCallMode::kDisallow);
+      int feedback_slot, TailCallMode tail_call_mode = TailCallMode::kDisallow);
 
   BytecodeArrayBuilder& TailCall(Register callable, Register receiver_args,
-                                 size_t receiver_arg_count) {
-    return Call(callable, receiver_args, receiver_arg_count,
+                                 size_t receiver_arg_count, int feedback_slot) {
+    return Call(callable, receiver_args, receiver_arg_count, feedback_slot,
                 TailCallMode::kAllow);
   }
 
-  // Call a JS function. The JSFunction or Callable to be called should be in
-  // |callable|, the receiver should be in |receiver_args| and all subsequent
-  // arguments should be in registers <receiver_args + 1> to
-  // <receiver_args + receiver_arg_count - 1>.
-  // Call through CallICStub to get Typefeedback.
-  BytecodeArrayBuilder& CallIC(Register callable, Register receiver_args,
-                               size_t receiver_arg_count, int feedback_slot,
-                               TailCallMode tail_call_mode);
-
   // Call the new operator. The accumulator holds the |new_target|.
   // The |constructor| is in a register followed by |arg_count|
   // consecutive arguments starting at |first_arg| for the constuctor
   // invocation.
-
   BytecodeArrayBuilder& New(Register constructor, Register first_arg,
                             size_t arg_count);
 
@@ -297,7 +287,6 @@ class BytecodeArrayBuilder final : public ZoneObject, private RegisterMover {
   static Bytecode BytecodeForCreateArguments(CreateArgumentsType type);
   static Bytecode BytecodeForDelete(LanguageMode language_mode);
   static Bytecode BytecodeForCall(TailCallMode tail_call_mode);
-  static Bytecode BytecodeForCallIC(TailCallMode tail_call_mode);
 
   static bool FitsInIdx8Operand(int value);
   static bool FitsInIdx8Operand(size_t value);
diff --git a/src/interpreter/bytecode-generator.cc b/src/interpreter/bytecode-generator.cc
index a313e20fd9..6f4dc275c1 100644
--- a/src/interpreter/bytecode-generator.cc
+++ b/src/interpreter/bytecode-generator.cc
@@ -2457,15 +2457,9 @@ void BytecodeGenerator::VisitCall(Call* expr) {
   }
 
   builder()->SetExpressionPosition(expr);
-  if (expr->CallFeedbackICSlot().IsInvalid()) {
-    builder()->Call(callee, receiver, 1 + args->length(),
-                    expr->tail_call_mode());
-  } else {
-    DCHECK(call_type != Call::POSSIBLY_EVAL_CALL);
-    builder()->CallIC(callee, receiver, 1 + args->length(),
-                      feedback_index(expr->CallFeedbackICSlot()),
-                      expr->tail_call_mode());
-  }
+  builder()->Call(callee, receiver, 1 + args->length(),
+                  feedback_index(expr->CallFeedbackICSlot()),
+                  expr->tail_call_mode());
   execution_result()->SetResultInAccumulator();
 }
 
diff --git a/src/interpreter/bytecodes.cc b/src/interpreter/bytecodes.cc
index be5a7b772c..5f7a9085ae 100644
--- a/src/interpreter/bytecodes.cc
+++ b/src/interpreter/bytecodes.cc
@@ -278,10 +278,8 @@ bool Bytecodes::IsJump(Bytecode bytecode) {
 // static
 bool Bytecodes::IsCallOrNew(Bytecode bytecode) {
   return bytecode == Bytecode::kCall || bytecode == Bytecode::kTailCall ||
-         bytecode == Bytecode::kNew || bytecode == Bytecode::kCallIC ||
-         bytecode == Bytecode::kCallWide ||
-         bytecode == Bytecode::kTailCallWide ||
-         bytecode == Bytecode::kNewWide || bytecode == Bytecode::kCallICWide;
+         bytecode == Bytecode::kNew || bytecode == Bytecode::kCallWide ||
+         bytecode == Bytecode::kTailCallWide || bytecode == Bytecode::kNewWide;
 }
 
 // static
diff --git a/src/interpreter/bytecodes.h b/src/interpreter/bytecodes.h
index 0eecc4fc5c..d892bdbb14 100644
--- a/src/interpreter/bytecodes.h
+++ b/src/interpreter/bytecodes.h
@@ -169,20 +169,14 @@ namespace interpreter {
   V(DeletePropertySloppy, OperandType::kReg8)                                  \
                                                                                \
   /* Call operations */                                                        \
-  V(CallIC, OperandType::kReg8, OperandType::kReg8, OperandType::kRegCount8,   \
+  V(Call, OperandType::kReg8, OperandType::kReg8, OperandType::kRegCount8,     \
     OperandType::kIdx8)                                                        \
-  V(CallICWide, OperandType::kReg16, OperandType::kReg16,                      \
-    OperandType::kRegCount16, OperandType::kIdx16)                             \
-  V(TailCallIC, OperandType::kReg8, OperandType::kReg8,                        \
-    OperandType::kRegCount8, OperandType::kIdx8)                               \
-  V(TailCallICWide, OperandType::kReg16, OperandType::kReg16,                  \
-    OperandType::kRegCount16, OperandType::kIdx16)                             \
-  V(Call, OperandType::kReg8, OperandType::kReg8, OperandType::kRegCount8)     \
   V(CallWide, OperandType::kReg16, OperandType::kReg16,                        \
-    OperandType::kRegCount16)                                                  \
-  V(TailCall, OperandType::kReg8, OperandType::kReg8, OperandType::kRegCount8) \
+    OperandType::kRegCount16, OperandType::kIdx16)                             \
+  V(TailCall, OperandType::kReg8, OperandType::kReg8, OperandType::kRegCount8, \
+    OperandType::kIdx8)                                                        \
   V(TailCallWide, OperandType::kReg16, OperandType::kReg16,                    \
-    OperandType::kRegCount16)                                                  \
+    OperandType::kRegCount16, OperandType::kIdx16)                             \
   V(CallRuntime, OperandType::kIdx16, OperandType::kMaybeReg8,                 \
     OperandType::kRegCount8)                                                   \
   V(CallRuntimeWide, OperandType::kIdx16, OperandType::kMaybeReg16,            \
diff --git a/src/interpreter/interpreter-assembler.cc b/src/interpreter/interpreter-assembler.cc
index e0e216d6b8..440e879c48 100644
--- a/src/interpreter/interpreter-assembler.cc
+++ b/src/interpreter/interpreter-assembler.cc
@@ -345,19 +345,6 @@ Node* InterpreterAssembler::CallJS(Node* function, Node* context,
                   first_arg, function);
 }
 
-Node* InterpreterAssembler::CallJSWithFeedback(Node* function, Node* context,
-                                               Node* first_arg, Node* arg_count,
-                                               Node* slot_id,
-                                               Node* type_feedback_vector,
-                                               TailCallMode tail_call_mode) {
-  Callable callable =
-      CodeFactory::InterpreterPushArgsAndCallIC(isolate(), tail_call_mode);
-  Node* code_target = HeapConstant(callable.code());
-
-  return CallStub(callable.descriptor(), code_target, context, arg_count,
-                  first_arg, function, slot_id, type_feedback_vector);
-}
-
 Node* InterpreterAssembler::CallConstruct(Node* constructor, Node* context,
                                           Node* new_target, Node* first_arg,
                                           Node* arg_count) {
diff --git a/src/interpreter/interpreter-assembler.h b/src/interpreter/interpreter-assembler.h
index f77f43ac78..9600dfb6c5 100644
--- a/src/interpreter/interpreter-assembler.h
+++ b/src/interpreter/interpreter-assembler.h
@@ -87,18 +87,6 @@ class InterpreterAssembler : public compiler::CodeStubAssembler {
                          compiler::Node* first_arg, compiler::Node* arg_count,
                          TailCallMode tail_call_mode);
 
-  // Call JSFunction or Callable |function| with |arg_count|
-  // arguments (not including receiver) and the first argument
-  // located at |first_arg| with feedback slot id |slot_id| and
-  // type feedback vector |type_feedback_vector|.
-  compiler::Node* CallJSWithFeedback(compiler::Node* function,
-                                     compiler::Node* context,
-                                     compiler::Node* first_arg,
-                                     compiler::Node* arg_count,
-                                     compiler::Node* slot_id,
-                                     compiler::Node* type_feedback_vector,
-                                     TailCallMode tail_call_mode);
-
   // Call constructor |constructor| with |arg_count| arguments (not
   // including receiver) and the first argument located at
   // |first_arg|. The |new_target| is the same as the
diff --git a/src/interpreter/interpreter.cc b/src/interpreter/interpreter.cc
index 3356eca9ab..43a7ead281 100644
--- a/src/interpreter/interpreter.cc
+++ b/src/interpreter/interpreter.cc
@@ -934,58 +934,6 @@ void Interpreter::DoDeletePropertySloppy(InterpreterAssembler* assembler) {
   DoDelete(Runtime::kDeleteProperty_Sloppy, assembler);
 }
 
-void Interpreter::DoJSCallWithFeedback(InterpreterAssembler* assembler,
-                                       TailCallMode tail_call_mode) {
-  Node* function_reg = __ BytecodeOperandReg(0);
-  Node* function = __ LoadRegister(function_reg);
-  Node* receiver_reg = __ BytecodeOperandReg(1);
-  Node* receiver_arg = __ RegisterLocation(receiver_reg);
-  Node* receiver_args_count = __ BytecodeOperandCount(2);
-  Node* receiver_count = __ Int32Constant(1);
-  Node* args_count = __ Int32Sub(receiver_args_count, receiver_count);
-  Node* slot_id_raw = __ BytecodeOperandIdx(3);
-  Node* slot_id = __ SmiTag(slot_id_raw);
-  Node* type_feedback_vector = __ LoadTypeFeedbackVector();
-  Node* context = __ GetContext();
-  Node* result =
-      __ CallJSWithFeedback(function, context, receiver_arg, args_count,
-                            slot_id, type_feedback_vector, tail_call_mode);
-  __ SetAccumulator(result);
-  __ Dispatch();
-}
-
-// Call <callable> <receiver> <arg_count>
-//
-// Call a JSfunction or Callable in |callable| with the |receiver| and
-// |arg_count| arguments in subsequent registers.
-void Interpreter::DoCallIC(InterpreterAssembler* assembler) {
-  DoJSCallWithFeedback(assembler, TailCallMode::kDisallow);
-}
-
-// CallWide <callable> <receiver> <arg_count>
-//
-// Call a JSfunction or Callable in |callable| with the |receiver| and
-// |arg_count| arguments in subsequent registers.
-void Interpreter::DoCallICWide(InterpreterAssembler* assembler) {
-  DoJSCallWithFeedback(assembler, TailCallMode::kDisallow);
-}
-
-// Call <callable> <receiver> <arg_count>
-//
-// Call a JSfunction or Callable in |callable| with the |receiver| and
-// |arg_count| arguments in subsequent registers.
-void Interpreter::DoTailCallIC(InterpreterAssembler* assembler) {
-  DoJSCallWithFeedback(assembler, TailCallMode::kAllow);
-}
-
-// CallWide <callable> <receiver> <arg_count>
-//
-// Call a JSfunction or Callable in |callable| with the |receiver| and
-// |arg_count| arguments in subsequent registers.
-void Interpreter::DoTailCallICWide(InterpreterAssembler* assembler) {
-  DoJSCallWithFeedback(assembler, TailCallMode::kAllow);
-}
-
 void Interpreter::DoJSCall(InterpreterAssembler* assembler,
                            TailCallMode tail_call_mode) {
   Node* function_reg = __ BytecodeOperandReg(0);
@@ -996,6 +944,7 @@ void Interpreter::DoJSCall(InterpreterAssembler* assembler,
   Node* receiver_count = __ Int32Constant(1);
   Node* args_count = __ Int32Sub(receiver_args_count, receiver_count);
   Node* context = __ GetContext();
+  // TODO(rmcilroy): Use the call type feedback slot to call via CallStub.
   Node* result =
       __ CallJS(function, context, receiver_arg, args_count, tail_call_mode);
   __ SetAccumulator(result);
diff --git a/src/interpreter/interpreter.h b/src/interpreter/interpreter.h
index a500a7b873..e02e9142b3 100644
--- a/src/interpreter/interpreter.h
+++ b/src/interpreter/interpreter.h
@@ -94,10 +94,6 @@ class Interpreter {
   // Generates code to perform a JS call.
   void DoJSCall(InterpreterAssembler* assembler, TailCallMode tail_call_mode);
 
-  // Generates code to perform a JS call with feedback.
-  void DoJSCallWithFeedback(InterpreterAssembler* assembler,
-                            TailCallMode tail_call_mode);
-
   // Generates code to perform a runtime call.
   void DoCallRuntimeCommon(InterpreterAssembler* assembler);
 
diff --git a/src/mips/builtins-mips.cc b/src/mips/builtins-mips.cc
index c31d866239..281dc62c6b 100644
--- a/src/mips/builtins-mips.cc
+++ b/src/mips/builtins-mips.cc
@@ -961,58 +961,6 @@ void Builtins::Generate_InterpreterExitTrampoline(MacroAssembler* masm) {
   __ Jump(ra);
 }
 
-static void Generate_InterpreterPushArgs(MacroAssembler* masm, Register index,
-                                         Register limit, Register scratch) {
-  Label loop_header, loop_check;
-  __ Branch(&loop_check);
-  __ bind(&loop_header);
-  __ lw(scratch, MemOperand(index));
-  __ Addu(index, index, Operand(-kPointerSize));
-  __ push(scratch);
-  __ bind(&loop_check);
-  __ Branch(&loop_header, gt, index, Operand(limit));
-}
-
-static void Generate_InterpreterComputeLastArgumentAddress(
-    MacroAssembler* masm, Register num_args, Register start_address,
-    Register output_reg) {
-  __ Addu(output_reg, num_args, Operand(1));  // Add one for receiver.
-  __ sll(output_reg, output_reg, kPointerSizeLog2);
-  __ Subu(output_reg, start_address, output_reg);
-}
-
-// static
-void Builtins::Generate_InterpreterPushArgsAndCallICImpl(
-    MacroAssembler* masm, TailCallMode tail_call_mode) {
-  // ----------- S t a t e -------------
-  //  -- a0 : the number of arguments (not including the receiver)
-  //  -- t0 : the address of the first argument to be pushed. Subsequent
-  //          arguments should be consecutive above this, in the same order as
-  //          they are to be pushed onto the stack.
-  //  -- a1 : the target to call (can be any Object).
-  //  -- a3 : feedback vector slot id
-  //  -- a2 : type feedback vector
-  // -----------------------------------
-
-  {
-    FrameScope scope(masm, StackFrame::INTERNAL);
-
-    // Computes the address of last argument in t1.
-    Generate_InterpreterComputeLastArgumentAddress(masm, a0, t0, t1);
-
-    // Push the arguments.
-    Generate_InterpreterPushArgs(masm, t0, t1, at);
-
-    // Call via the CallIC stub.
-    CallICState call_ic_state(0, ConvertReceiverMode::kAny, tail_call_mode,
-                              true);
-    CallICStub stub(masm->isolate(), call_ic_state);
-    // TODO(mythria): This should be replaced by a TailCallStub, when we
-    // update the code to find the target IC from jump instructions.
-    __ CallStub(&stub);
-  }
-  __ Ret();
-}
 
 // static
 void Builtins::Generate_InterpreterPushArgsAndCallImpl(
@@ -1025,11 +973,20 @@ void Builtins::Generate_InterpreterPushArgsAndCallImpl(
   //  -- a1 : the target to call (can be any Object).
   // -----------------------------------
 
-  // Computes the address of last argument in a3.
-  Generate_InterpreterComputeLastArgumentAddress(masm, a0, a2, a3);
+  // Find the address of the last argument.
+  __ Addu(a3, a0, Operand(1));  // Add one for receiver.
+  __ sll(a3, a3, kPointerSizeLog2);
+  __ Subu(a3, a2, Operand(a3));
 
   // Push the arguments.
-  Generate_InterpreterPushArgs(masm, a2, a3, at);
+  Label loop_header, loop_check;
+  __ Branch(&loop_check);
+  __ bind(&loop_header);
+  __ lw(t0, MemOperand(a2));
+  __ Addu(a2, a2, Operand(-kPointerSize));
+  __ push(t0);
+  __ bind(&loop_check);
+  __ Branch(&loop_header, gt, a2, Operand(a3));
 
   // Call the target.
   __ Jump(masm->isolate()->builtins()->Call(ConvertReceiverMode::kAny,
@@ -1037,6 +994,7 @@ void Builtins::Generate_InterpreterPushArgsAndCallImpl(
           RelocInfo::CODE_TARGET);
 }
 
+
 // static
 void Builtins::Generate_InterpreterPushArgsAndConstruct(MacroAssembler* masm) {
   // ----------- S t a t e -------------
@@ -2011,17 +1969,6 @@ void PrepareForTailCall(MacroAssembler* masm, Register args_reg,
   __ lb(scratch1, MemOperand(at));
   __ Branch(&done, ne, scratch1, Operand(zero_reg));
 
-  // Drop possible internal frame pushed for calling CallICStub.
-  // TODO(mythria): when we tail call the CallICStub, remove this.
-  {
-    Label no_internal_callic_frame;
-    __ lw(scratch3, MemOperand(fp, StandardFrameConstants::kMarkerOffset));
-    __ Branch(&no_internal_callic_frame, ne, scratch3,
-              Operand(Smi::FromInt(StackFrame::INTERNAL)));
-    __ lw(fp, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
-    __ bind(&no_internal_callic_frame);
-  }
-
   // Drop possible interpreter handler/stub frame.
   {
     Label no_interpreter_frame;
diff --git a/src/mips/code-stubs-mips.cc b/src/mips/code-stubs-mips.cc
index 1427a3bb45..dc224a985d 100644
--- a/src/mips/code-stubs-mips.cc
+++ b/src/mips/code-stubs-mips.cc
@@ -2181,7 +2181,6 @@ void CallConstructStub::Generate(MacroAssembler* masm) {
 
 
 void CallICStub::HandleArrayCase(MacroAssembler* masm, Label* miss) {
-  // a0 - number of arguments - if argc_in_register() is true.
   // a1 - function
   // a3 - slot id
   // a2 - vector
@@ -2189,6 +2188,8 @@ void CallICStub::HandleArrayCase(MacroAssembler* masm, Label* miss) {
   __ LoadNativeContextSlot(Context::ARRAY_FUNCTION_INDEX, at);
   __ Branch(miss, ne, a1, Operand(at));
 
+  __ li(a0, Operand(arg_count()));
+
   // Increment the call count for monomorphic function calls.
   __ Lsa(at, a2, a3, kPointerSizeLog2 - kSmiTagSize);
   __ lw(a3, FieldMemOperand(at, FixedArray::kHeaderSize + kPointerSize));
@@ -2197,32 +2198,20 @@ void CallICStub::HandleArrayCase(MacroAssembler* masm, Label* miss) {
 
   __ mov(a2, t0);
   __ mov(a3, a1);
-  if (argc_in_register()) {
-    // Pass a default ArgumentCountKey::Any since the argc is only available
-    // in a0. We do not have the actual count here.
-    ArrayConstructorStub stub(masm->isolate());
-    __ TailCallStub(&stub);
-  } else {
-    // arg_count() is expected in a0 if the arg_count() >= 2
-    // (ArgumentCountKey::MORE_THAN_ONE).
-    ArrayConstructorStub stub(masm->isolate(), arg_count());
-    __ TailCallStub(&stub);
-  }
+  ArrayConstructorStub stub(masm->isolate(), arg_count());
+  __ TailCallStub(&stub);
 }
 
 
 void CallICStub::Generate(MacroAssembler* masm) {
-  // a0 - number of arguments - if argc_in_register() is true.
   // a1 - function
   // a3 - slot id (Smi)
   // a2 - vector
   Label extra_checks_or_miss, call, call_function;
-  if (!argc_in_register()) {
-    int argc = arg_count();
-    __ li(a0, argc);
-  }
+  int argc = arg_count();
+  ParameterCount actual(argc);
 
-  // The checks. First, does a1 match the recorded monomorphic target?
+  // The checks. First, does r1 match the recorded monomorphic target?
   __ Lsa(t0, a2, a3, kPointerSizeLog2 - kSmiTagSize);
   __ lw(t0, FieldMemOperand(t0, FixedArray::kHeaderSize));
 
@@ -2256,7 +2245,9 @@ void CallICStub::Generate(MacroAssembler* masm) {
   __ bind(&call_function);
   __ Jump(masm->isolate()->builtins()->CallFunction(convert_mode(),
                                                     tail_call_mode()),
-          RelocInfo::CODE_TARGET, al, zero_reg, Operand(zero_reg));
+          RelocInfo::CODE_TARGET, al, zero_reg, Operand(zero_reg),
+          USE_DELAY_SLOT);
+  __ li(a0, Operand(argc));  // In delay slot.
 
   __ bind(&extra_checks_or_miss);
   Label uninitialized, miss, not_allocation_site;
@@ -2293,7 +2284,9 @@ void CallICStub::Generate(MacroAssembler* masm) {
 
   __ bind(&call);
   __ Jump(masm->isolate()->builtins()->Call(convert_mode(), tail_call_mode()),
-          RelocInfo::CODE_TARGET, al, zero_reg, Operand(zero_reg));
+          RelocInfo::CODE_TARGET, al, zero_reg, Operand(zero_reg),
+          USE_DELAY_SLOT);
+  __ li(a0, Operand(argc));  // In delay slot.
 
   __ bind(&uninitialized);
 
@@ -2327,11 +2320,9 @@ void CallICStub::Generate(MacroAssembler* masm) {
   {
     FrameScope scope(masm, StackFrame::INTERNAL);
     CreateWeakCellStub create_stub(masm->isolate());
-    __ SmiTag(a0);
-    __ Push(a0, a1);
+    __ Push(a1);
     __ CallStub(&create_stub);
-    __ Pop(a0, a1);
-    __ SmiUntag(a0);
+    __ Pop(a1);
   }
 
   __ Branch(&call_function);
@@ -2348,19 +2339,14 @@ void CallICStub::Generate(MacroAssembler* masm) {
 void CallICStub::GenerateMiss(MacroAssembler* masm) {
   FrameScope scope(masm, StackFrame::INTERNAL);
 
-  __ SmiTag(a0);
-  // Push number of arguments, receiver, function and feedback info.
-  __ Push(a0, a1, a2, a3);
+  // Push the receiver and the function and feedback info.
+  __ Push(a1, a2, a3);
 
   // Call the entry.
   __ CallRuntime(Runtime::kCallIC_Miss);
 
   // Move result to a1 and exit the internal frame.
   __ mov(a1, v0);
-
-  // Restore a0.
-  __ Pop(a0);
-  __ SmiUntag(a0);
 }
 
 
diff --git a/src/mips/interface-descriptors-mips.cc b/src/mips/interface-descriptors-mips.cc
index a48b9cdf4d..f8b2876313 100644
--- a/src/mips/interface-descriptors-mips.cc
+++ b/src/mips/interface-descriptors-mips.cc
@@ -428,18 +428,6 @@ void InterpreterPushArgsAndCallDescriptor::InitializePlatformSpecific(
   data->InitializePlatformSpecific(arraysize(registers), registers);
 }
 
-void InterpreterPushArgsAndCallICDescriptor::InitializePlatformSpecific(
-    CallInterfaceDescriptorData* data) {
-  Register registers[] = {
-      a0,  // argument count (not including receiver)
-      t0,  // address of first argument
-      a1,  // the target callable to be call
-      a3,  // feedback vector slot id
-      a2   // type feedback vector
-  };
-  data->InitializePlatformSpecific(arraysize(registers), registers);
-}
-
 void InterpreterPushArgsAndConstructDescriptor::InitializePlatformSpecific(
     CallInterfaceDescriptorData* data) {
   Register registers[] = {
diff --git a/src/mips64/builtins-mips64.cc b/src/mips64/builtins-mips64.cc
index 4c44ee8c3b..ce4716bdd1 100644
--- a/src/mips64/builtins-mips64.cc
+++ b/src/mips64/builtins-mips64.cc
@@ -1077,58 +1077,6 @@ void Builtins::Generate_InterpreterExitTrampoline(MacroAssembler* masm) {
   __ Jump(ra);
 }
 
-static void Generate_InterpreterPushArgs(MacroAssembler* masm, Register index,
-                                         Register limit, Register scratch) {
-  Label loop_header, loop_check;
-  __ Branch(&loop_check);
-  __ bind(&loop_header);
-  __ ld(scratch, MemOperand(index));
-  __ Daddu(index, index, Operand(-kPointerSize));
-  __ push(scratch);
-  __ bind(&loop_check);
-  __ Branch(&loop_header, gt, index, Operand(limit));
-}
-
-static void Generate_InterpreterComputeLastArgumentAddress(
-    MacroAssembler* masm, Register num_args, Register start_address,
-    Register output_reg) {
-  __ Daddu(output_reg, num_args, Operand(1));  // Add one for receiver.
-  __ dsll(output_reg, output_reg, kPointerSizeLog2);
-  __ Dsubu(output_reg, start_address, output_reg);
-}
-
-// static
-void Builtins::Generate_InterpreterPushArgsAndCallICImpl(
-    MacroAssembler* masm, TailCallMode tail_call_mode) {
-  // ----------- S t a t e -------------
-  //  -- a0 : the number of arguments (not including the receiver)
-  //  -- a4 : the address of the first argument to be pushed. Subsequent
-  //          arguments should be consecutive above this, in the same order as
-  //          they are to be pushed onto the stack.
-  //  -- a1 : the target to call (can be any Object).
-  //  -- a3 : feedback vector slot id
-  //  -- a2 : type feedback vector
-  // -----------------------------------
-
-  {
-    FrameScope scope(masm, StackFrame::INTERNAL);
-
-    // Computes the address of last argument in a5.
-    Generate_InterpreterComputeLastArgumentAddress(masm, a0, a4, a5);
-
-    // Push the arguments.
-    Generate_InterpreterPushArgs(masm, a4, a5, at);
-
-    // Call via the CallIC stub.
-    CallICState call_ic_state(0, ConvertReceiverMode::kAny, tail_call_mode,
-                              true);
-    CallICStub stub(masm->isolate(), call_ic_state);
-    // TODO(mythria): This should be replaced by a TailCallStub, when we
-    // update the code to find the target IC from jump instructions.
-    __ CallStub(&stub);
-  }
-  __ Ret();
-}
 
 // static
 void Builtins::Generate_InterpreterPushArgsAndCallImpl(
@@ -1141,11 +1089,20 @@ void Builtins::Generate_InterpreterPushArgsAndCallImpl(
   //  -- a1 : the target to call (can be any Object).
   // -----------------------------------
 
-  // Computes the address of last argument in a3.
-  Generate_InterpreterComputeLastArgumentAddress(masm, a0, a2, a3);
+  // Find the address of the last argument.
+  __ Daddu(a3, a0, Operand(1));  // Add one for receiver.
+  __ dsll(a3, a3, kPointerSizeLog2);
+  __ Dsubu(a3, a2, Operand(a3));
 
   // Push the arguments.
-  Generate_InterpreterPushArgs(masm, a2, a3, at);
+  Label loop_header, loop_check;
+  __ Branch(&loop_check);
+  __ bind(&loop_header);
+  __ ld(t0, MemOperand(a2));
+  __ Daddu(a2, a2, Operand(-kPointerSize));
+  __ push(t0);
+  __ bind(&loop_check);
+  __ Branch(&loop_header, gt, a2, Operand(a3));
 
   // Call the target.
   __ Jump(masm->isolate()->builtins()->Call(ConvertReceiverMode::kAny,
@@ -2131,17 +2088,6 @@ void PrepareForTailCall(MacroAssembler* masm, Register args_reg,
   __ lb(scratch1, MemOperand(at));
   __ Branch(&done, ne, scratch1, Operand(zero_reg));
 
-  // Drop possible internal frame pushed for calling CallICStub.
-  // TODO(mythria): when we tail call the CallICStub, remove this.
-  {
-    Label no_internal_callic_frame;
-    __ ld(scratch3, MemOperand(fp, StandardFrameConstants::kMarkerOffset));
-    __ Branch(&no_internal_callic_frame, ne, scratch3,
-              Operand(Smi::FromInt(StackFrame::INTERNAL)));
-    __ ld(fp, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
-    __ bind(&no_internal_callic_frame);
-  }
-
   // Drop possible interpreter handler/stub frame.
   {
     Label no_interpreter_frame;
diff --git a/src/mips64/code-stubs-mips64.cc b/src/mips64/code-stubs-mips64.cc
index 70e86cb454..8a71aacb0b 100644
--- a/src/mips64/code-stubs-mips64.cc
+++ b/src/mips64/code-stubs-mips64.cc
@@ -2224,7 +2224,6 @@ void StringCharCodeAtGenerator::GenerateFast(MacroAssembler* masm) {
 
 
 void CallICStub::HandleArrayCase(MacroAssembler* masm, Label* miss) {
-  // a0 - number of arguments - if argc_in_register() is true.
   // a1 - function
   // a3 - slot id
   // a2 - vector
@@ -2232,42 +2231,32 @@ void CallICStub::HandleArrayCase(MacroAssembler* masm, Label* miss) {
   __ LoadNativeContextSlot(Context::ARRAY_FUNCTION_INDEX, at);
   __ Branch(miss, ne, a1, Operand(at));
 
+  __ li(a0, Operand(arg_count()));
+
   // Increment the call count for monomorphic function calls.
-  __ dsrl(a5, a3, kSmiShiftSize + 1 - kPointerSizeLog2);
-  __ Daddu(a3, a2, Operand(a5));
-  __ ld(a5, FieldMemOperand(a3, FixedArray::kHeaderSize + kPointerSize));
-  __ Daddu(a5, a5, Operand(Smi::FromInt(CallICNexus::kCallCountIncrement)));
-  __ sd(a5, FieldMemOperand(a3, FixedArray::kHeaderSize + kPointerSize));
+  __ dsrl(t0, a3, 32 - kPointerSizeLog2);
+  __ Daddu(a3, a2, Operand(t0));
+  __ ld(t0, FieldMemOperand(a3, FixedArray::kHeaderSize + kPointerSize));
+  __ Daddu(t0, t0, Operand(Smi::FromInt(CallICNexus::kCallCountIncrement)));
+  __ sd(t0, FieldMemOperand(a3, FixedArray::kHeaderSize + kPointerSize));
 
   __ mov(a2, a4);
   __ mov(a3, a1);
-  if (argc_in_register()) {
-    // Pass a default ArgumentCountKey::Any since the argc is only available
-    // in a0. We do not have the actual count here.
-    ArrayConstructorStub stub(masm->isolate());
-    __ TailCallStub(&stub);
-  } else {
-    // arg_count() is expected in a0 if the arg_count() >= 2
-    // (ArgumentCountKey::MORE_THAN_ONE).
-    ArrayConstructorStub stub(masm->isolate(), arg_count());
-    __ TailCallStub(&stub);
-  }
+  ArrayConstructorStub stub(masm->isolate(), arg_count());
+  __ TailCallStub(&stub);
 }
 
 
 void CallICStub::Generate(MacroAssembler* masm) {
-  // a0 - number of arguments - if argc_in_register() is true.
   // a1 - function
   // a3 - slot id (Smi)
   // a2 - vector
   Label extra_checks_or_miss, call, call_function;
-  if (!argc_in_register()) {
-    int argc = arg_count();
-    __ li(a0, argc);
-  }
+  int argc = arg_count();
+  ParameterCount actual(argc);
 
-  // The checks. First, does a1 match the recorded monomorphic target?
-  __ dsrl(a4, a3, kSmiShiftSize + 1 - kPointerSizeLog2);
+  // The checks. First, does r1 match the recorded monomorphic target?
+  __ dsrl(a4, a3, 32 - kPointerSizeLog2);
   __ Daddu(a4, a2, Operand(a4));
   __ ld(a4, FieldMemOperand(a4, FixedArray::kHeaderSize));
 
@@ -2302,7 +2291,9 @@ void CallICStub::Generate(MacroAssembler* masm) {
   __ bind(&call_function);
   __ Jump(masm->isolate()->builtins()->CallFunction(convert_mode(),
                                                     tail_call_mode()),
-          RelocInfo::CODE_TARGET, al, zero_reg, Operand(zero_reg));
+          RelocInfo::CODE_TARGET, al, zero_reg, Operand(zero_reg),
+          USE_DELAY_SLOT);
+  __ li(a0, Operand(argc));  // In delay slot.
 
   __ bind(&extra_checks_or_miss);
   Label uninitialized, miss, not_allocation_site;
@@ -2340,7 +2331,9 @@ void CallICStub::Generate(MacroAssembler* masm) {
 
   __ bind(&call);
   __ Jump(masm->isolate()->builtins()->Call(convert_mode(), tail_call_mode()),
-          RelocInfo::CODE_TARGET, al, zero_reg, Operand(zero_reg));
+          RelocInfo::CODE_TARGET, al, zero_reg, Operand(zero_reg),
+          USE_DELAY_SLOT);
+  __ li(a0, Operand(argc));  // In delay slot.
 
   __ bind(&uninitialized);
 
@@ -2375,11 +2368,9 @@ void CallICStub::Generate(MacroAssembler* masm) {
   {
     FrameScope scope(masm, StackFrame::INTERNAL);
     CreateWeakCellStub create_stub(masm->isolate());
-    __ SmiTag(a0);
-    __ Push(a0, a1);
+    __ Push(a1);
     __ CallStub(&create_stub);
-    __ Pop(a0, a1);
-    __ SmiUntag(a0);
+    __ Pop(a1);
   }
 
   __ Branch(&call_function);
@@ -2396,19 +2387,14 @@ void CallICStub::Generate(MacroAssembler* masm) {
 void CallICStub::GenerateMiss(MacroAssembler* masm) {
   FrameScope scope(masm, StackFrame::INTERNAL);
 
-  __ SmiTag(a0);
-  // Push number of arguments, receiver, function and feedback info.
-  __ Push(a0, a1, a2, a3);
+  // Push the receiver and the function and feedback info.
+  __ Push(a1, a2, a3);
 
   // Call the entry.
   __ CallRuntime(Runtime::kCallIC_Miss);
 
   // Move result to a1 and exit the internal frame.
   __ mov(a1, v0);
-
-  // Restore a0.
-  __ Pop(a0);
-  __ SmiUntag(a0);
 }
 
 
diff --git a/src/mips64/interface-descriptors-mips64.cc b/src/mips64/interface-descriptors-mips64.cc
index 844e5af574..1ef13b377d 100644
--- a/src/mips64/interface-descriptors-mips64.cc
+++ b/src/mips64/interface-descriptors-mips64.cc
@@ -428,18 +428,6 @@ void InterpreterPushArgsAndCallDescriptor::InitializePlatformSpecific(
   data->InitializePlatformSpecific(arraysize(registers), registers);
 }
 
-void InterpreterPushArgsAndCallICDescriptor::InitializePlatformSpecific(
-    CallInterfaceDescriptorData* data) {
-  Register registers[] = {
-      a0,  // argument count (not including receiver)
-      a4,  // address of first argument
-      a1,  // the target callable to be call
-      a3,  // feedback vector slot id
-      a2   // type feedback vector
-  };
-  data->InitializePlatformSpecific(arraysize(registers), registers);
-}
-
 void InterpreterPushArgsAndConstructDescriptor::InitializePlatformSpecific(
     CallInterfaceDescriptorData* data) {
   Register registers[] = {
diff --git a/src/x64/builtins-x64.cc b/src/x64/builtins-x64.cc
index 35a3cc88e2..c0a0421a5e 100644
--- a/src/x64/builtins-x64.cc
+++ b/src/x64/builtins-x64.cc
@@ -639,38 +639,6 @@ static void Generate_InterpreterPushArgs(MacroAssembler* masm,
 }
 
 
-// static
-void Builtins::Generate_InterpreterPushArgsAndCallICImpl(
-    MacroAssembler* masm, TailCallMode tail_call_mode) {
-  // ----------- S t a t e -------------
-  //  -- rax : the number of arguments (not including the receiver)
-  //  -- rbx : the address of the first argument to be pushed. Subsequent
-  //           arguments should be consecutive above this, in the same order as
-  //           they are to be pushed onto the stack.
-  //  -- rdi : the target to call (can be any Object).
-  //  -- rdx : Feedback vector slot-id.
-  //  -- r9 : type feedback vector. // TODO(mythria): move to rbx to match
-  //                                   CallICStub expectation.
-  // -----------------------------------
-
-  {
-    FrameScope scope(masm, StackFrame::INTERNAL);
-
-    Generate_InterpreterPushArgs(masm, true);
-
-    __ Move(rbx, r9);
-
-    // Call via the CallIC stub.
-    CallICState call_ic_state(0, ConvertReceiverMode::kAny, tail_call_mode,
-                              true);
-    CallICStub stub(masm->isolate(), call_ic_state);
-    // TODO(mythria): This should be replaced by a TailCallStub, when we
-    // update the code to find the target IC from jump instructions.
-    __ CallStub(&stub);
-  }
-  __ Ret();
-}
-
 // static
 void Builtins::Generate_InterpreterPushArgsAndCallImpl(
     MacroAssembler* masm, TailCallMode tail_call_mode) {
@@ -694,6 +662,7 @@ void Builtins::Generate_InterpreterPushArgsAndCallImpl(
           RelocInfo::CODE_TARGET);
 }
 
+
 // static
 void Builtins::Generate_InterpreterPushArgsAndConstruct(MacroAssembler* masm) {
   // ----------- S t a t e -------------
@@ -2104,17 +2073,6 @@ void PrepareForTailCall(MacroAssembler* masm, Register args_reg,
   __ cmpb(Operand(kScratchRegister, 0), Immediate(0));
   __ j(not_equal, &done);
 
-  // Drop possible internal frame pushed for calling CallICStub.
-  // TODO(mythria): when we tail call the CallICStub, remove this.
-  {
-    Label no_internal_callic_frame;
-    __ Cmp(Operand(rbp, StandardFrameConstants::kMarkerOffset),
-           Smi::FromInt(StackFrame::INTERNAL));
-    __ j(not_equal, &no_internal_callic_frame, Label::kNear);
-    __ movp(rbp, Operand(rbp, StandardFrameConstants::kCallerFPOffset));
-    __ bind(&no_internal_callic_frame);
-  }
-
   // Drop possible interpreter handler/stub frame.
   {
     Label no_interpreter_frame;
diff --git a/src/x64/code-stubs-x64.cc b/src/x64/code-stubs-x64.cc
index a32db1b569..4b3d02841b 100644
--- a/src/x64/code-stubs-x64.cc
+++ b/src/x64/code-stubs-x64.cc
@@ -1500,12 +1500,13 @@ void CallICStub::HandleArrayCase(MacroAssembler* masm, Label* miss) {
   // rdi - function
   // rdx - slot id
   // rbx - vector
-  // rax - number of arguments if argc_in_register() is true.
   // rcx - allocation site (loaded from vector[slot]).
   __ LoadNativeContextSlot(Context::ARRAY_FUNCTION_INDEX, r8);
   __ cmpp(rdi, r8);
   __ j(not_equal, miss);
 
+  __ movp(rax, Immediate(arg_count()));
+
   // Increment the call count for monomorphic function calls.
   __ SmiAddConstant(FieldOperand(rbx, rdx, times_pointer_size,
                                  FixedArray::kHeaderSize + kPointerSize),
@@ -1513,17 +1514,8 @@ void CallICStub::HandleArrayCase(MacroAssembler* masm, Label* miss) {
 
   __ movp(rbx, rcx);
   __ movp(rdx, rdi);
-  if (argc_in_register()) {
-    // Pass a default ArgumentCountKey::Any since the argc is only available
-    // in rax. We do not have the actual count here.
-    ArrayConstructorStub stub(masm->isolate());
-    __ TailCallStub(&stub);
-  } else {
-    // arg_count() is expected in rax if the arg_count() >= 2
-    // (ArgumentCountKey::MORE_THAN_ONE).
-    ArrayConstructorStub stub(masm->isolate(), arg_count());
-    __ TailCallStub(&stub);
-  }
+  ArrayConstructorStub stub(masm->isolate(), arg_count());
+  __ TailCallStub(&stub);
 }
 
 
@@ -1532,14 +1524,12 @@ void CallICStub::Generate(MacroAssembler* masm) {
   // -- rdi - function
   // -- rdx - slot id
   // -- rbx - vector
-  // -- rax - number of arguments if argc_in_register() is true.
   // -----------------------------------
   Isolate* isolate = masm->isolate();
   Label extra_checks_or_miss, call, call_function;
-  if (!argc_in_register()) {
-    int argc = arg_count();
-    __ Set(rax, argc);
-  }
+  int argc = arg_count();
+  StackArgumentsAccessor args(rsp, argc);
+  ParameterCount actual(argc);
 
   // The checks. First, does rdi match the recorded monomorphic target?
   __ SmiToInteger32(rdx, rdx);
@@ -1573,6 +1563,7 @@ void CallICStub::Generate(MacroAssembler* masm) {
                     Smi::FromInt(CallICNexus::kCallCountIncrement));
 
   __ bind(&call_function);
+  __ Set(rax, argc);
   __ Jump(masm->isolate()->builtins()->CallFunction(convert_mode(),
                                                     tail_call_mode()),
           RelocInfo::CODE_TARGET);
@@ -1611,6 +1602,7 @@ void CallICStub::Generate(MacroAssembler* masm) {
           TypeFeedbackVector::MegamorphicSentinel(isolate));
 
   __ bind(&call);
+  __ Set(rax, argc);
   __ Jump(masm->isolate()->builtins()->Call(convert_mode(), tail_call_mode()),
           RelocInfo::CODE_TARGET);
 
@@ -1648,16 +1640,10 @@ void CallICStub::Generate(MacroAssembler* masm) {
     FrameScope scope(masm, StackFrame::INTERNAL);
     CreateWeakCellStub create_stub(isolate);
 
-    __ Integer32ToSmi(rax, rax);
-    __ Push(rax);
     __ Integer32ToSmi(rdx, rdx);
     __ Push(rdi);
-
     __ CallStub(&create_stub);
-
     __ Pop(rdi);
-    __ Pop(rax);
-    __ SmiToInteger32(rax, rax);
   }
 
   __ jmp(&call_function);
@@ -1677,10 +1663,6 @@ void CallICStub::Generate(MacroAssembler* masm) {
 void CallICStub::GenerateMiss(MacroAssembler* masm) {
   FrameScope scope(masm, StackFrame::INTERNAL);
 
-  // Store the number of arguments to be used later.
-  __ Integer32ToSmi(rax, rax);
-  __ Push(rax);
-
   // Push the receiver and the function and feedback info.
   __ Push(rdi);
   __ Push(rbx);
@@ -1692,10 +1674,6 @@ void CallICStub::GenerateMiss(MacroAssembler* masm) {
 
   // Move result to edi and exit the internal frame.
   __ movp(rdi, rax);
-  // rdi, rbx, rdx are arguments to CallIC_Miss. They will be popped by
-  // Runtime_CallIC_Miss.
-  __ Pop(rax);
-  __ SmiToInteger32(rax, rax);
 }
 
 
diff --git a/src/x64/interface-descriptors-x64.cc b/src/x64/interface-descriptors-x64.cc
index c3e007dfba..333486ad8a 100644
--- a/src/x64/interface-descriptors-x64.cc
+++ b/src/x64/interface-descriptors-x64.cc
@@ -415,19 +415,6 @@ void InterpreterDispatchDescriptor::InitializePlatformSpecific(
   data->InitializePlatformSpecific(arraysize(registers), registers);
 }
 
-void InterpreterPushArgsAndCallICDescriptor::InitializePlatformSpecific(
-    CallInterfaceDescriptorData* data) {
-  Register registers[] = {
-      rax,  // argument count (not including receiver)
-      rbx,  // address of first argument
-      rdi,  // the target callable to be call
-      rdx,  // slot id
-      r9,   // type feedback vector // TODO(mythria): move to rbx to match
-            //   CallICStub.
-  };
-  data->InitializePlatformSpecific(arraysize(registers), registers);
-}
-
 void InterpreterPushArgsAndCallDescriptor::InitializePlatformSpecific(
     CallInterfaceDescriptorData* data) {
   Register registers[] = {
diff --git a/test/cctest/cctest.status b/test/cctest/cctest.status
index 7ecb6e9032..5acd1b8b0f 100644
--- a/test/cctest/cctest.status
+++ b/test/cctest/cctest.status
@@ -563,18 +563,6 @@
   'test-run-jsexceptions/ThrowMessagePosition': [FAIL],
   'test-api/TryCatchMixedNesting': [FAIL],
 
-  # TODO(4680): Related to lack of code-ageing in interpreter.
-  'test-heap/Regress169209': [FAIL],
-
-  # TODO(4680): Related to lack of code-ageing and/or lack of compilation cache
-  # in interpreter.
-  'test-heap/CompilationCacheCachingBehavior': [FAIL],
-
-  # TODO(4680): Use CallConstructStub for new operator.
-  'test-heap/IncrementalMarkingPreservesMonomorphicConstructor': [FAIL],
-  'test-heap/IncrementalMarkingClearsMonomorphicConstructor': [FAIL],
-  'test-heap/WeakFunctionInConstructor': [FAIL],
-
   # TODO(rmcilroy,4680): Test assert errors.
   'test-cpu-profiler/CodeEvents': [FAIL],
   'test-cpu-profiler/TickEvents': [FAIL],
@@ -599,8 +587,17 @@
   'test-profile-generator/LineNumber': [FAIL],
   'test-profile-generator/ProfileNodeScriptId': [FAIL],
   'test-profile-generator/RecordStackTraceAtStartProfiling': [FAIL],
+  'test-feedback-vector/VectorCallICStates': [FAIL],
+  'test-compiler/FeedbackVectorPreservedAcrossRecompiles': [FAIL],
   'test-api/PromiseRejectCallback': [FAIL],
   'test-api/SetJitCodeEventHandler': [FAIL],
+  'test-heap/WeakFunctionInConstructor': [FAIL],
+  'test-heap/Regress169209': [FAIL],
+  'test-heap/IncrementalMarkingClearsMonomorphicConstructor': [FAIL],
+  'test-heap/IncrementalMarkingPreservesMonomorphicConstructor': [FAIL],
+  'test-heap/IncrementalMarkingPreservesMonomorphicCallIC': [FAIL],
+  'test-heap/CompilationCacheCachingBehavior': [FAIL],
+  'test-heap/CellsInOptimizedCodeAreWeak': [FAIL],
   'test-run-inlining/InlineTwice': [FAIL],
   'test-serialize/SerializeInternalReference': [FAIL, ['arch == arm or arch == arm64', PASS]],
 }],  # ignition == True
diff --git a/test/cctest/compiler/test-run-bytecode-graph-builder.cc b/test/cctest/compiler/test-run-bytecode-graph-builder.cc
index 13180b50ad..9a038221a1 100644
--- a/test/cctest/compiler/test-run-bytecode-graph-builder.cc
+++ b/test/cctest/compiler/test-run-bytecode-graph-builder.cc
@@ -136,9 +136,6 @@ class BytecodeGraphTester {
     compilation_info.MarkAsDeoptimizationEnabled();
     compiler::Pipeline pipeline(&compilation_info);
     Handle<Code> code = pipeline.GenerateCode();
-    // We do not actually record weak dependencies between objects and
-    // code objects. We just clear the dependencies for now.
-    compilation_info.dependencies()->Commit(compilation_info.code());
     function->ReplaceCode(*code);
 
     return function;
diff --git a/test/cctest/interpreter/test-bytecode-generator.cc b/test/cctest/interpreter/test-bytecode-generator.cc
index 737cc7b2f9..73767eb3c6 100644
--- a/test/cctest/interpreter/test-bytecode-generator.cc
+++ b/test/cctest/interpreter/test-bytecode-generator.cc
@@ -1512,7 +1512,7 @@ TEST(PropertyCall) {
            B(Star), R(1),                                              //
            B(LoadIC), R(1), U8(0), U8(vector->GetIndex(slot2)),  //
            B(Star), R(0),                                              //
-           B(CallIC), R(0), R(1), U8(1), U8(vector->GetIndex(slot1)),  //
+           B(Call), R(0), R(1), U8(1), U8(vector->GetIndex(slot1)),    //
            B(Return),                                                  //
        },
        1,
@@ -1531,7 +1531,7 @@ TEST(PropertyCall) {
            B(Star), R(2),                                              //
            B(Ldar), A(3, 4),                                           //
            B(Star), R(3),                                              //
-           B(CallIC), R(0), R(1), U8(3), U8(vector->GetIndex(slot1)),  //
+           B(Call), R(0), R(1), U8(3), U8(vector->GetIndex(slot1)),    //
            B(Return)                                                   //
        },
        1,
@@ -1553,7 +1553,7 @@ TEST(PropertyCall) {
            B(Star), R(2),                                              //
            B(Ldar), A(2, 3),                                           //
            B(Star), R(3),                                              //
-           B(CallIC), R(0), R(1), U8(3), U8(vector->GetIndex(slot1)),  //
+           B(Call), R(0), R(1), U8(3), U8(vector->GetIndex(slot1)),    //
            B(Return),                                                  //
        },
        1,
@@ -1577,7 +1577,7 @@ TEST(PropertyCall) {
            B(Star), R(1),                                                  //
            B(LoadICWide), R(1), U16(0), U16(wide_idx + 4),           //
            B(Star), R(0),                                                  //
-           B(CallICWide), R16(0), R16(1), U16(1), U16(wide_idx + 2),       //
+           B(CallWide), R16(0), R16(1), U16(1), U16(wide_idx + 2),         //
            B(Return),                                                      //
        },
        1,
@@ -1826,13 +1826,13 @@ TEST(CallGlobal) {
        1,
        15,
        {
-           B(StackCheck),                                              //
-           B(LdaUndefined),                                            //
-           B(Star), R(1),                                              //
-           B(LdaGlobal), U8(0), U8(vector->GetIndex(slot2)),           //
-           B(Star), R(0),                                              //
-           B(CallIC), R(0), R(1), U8(1), U8(vector->GetIndex(slot1)),  //
-           B(Return)                                                   //
+           B(StackCheck),                                            //
+           B(LdaUndefined),                                          //
+           B(Star), R(1),                                            //
+           B(LdaGlobal), U8(0), U8(vector->GetIndex(slot2)),   //
+           B(Star), R(0),                                            //
+           B(Call), R(0), R(1), U8(1), U8(vector->GetIndex(slot1)),  //
+           B(Return)                                                 //
        },
        1,
        {"t"}},
@@ -1841,19 +1841,19 @@ TEST(CallGlobal) {
        1,
        27,
        {
-           B(StackCheck),                                              //
-           B(LdaUndefined),                                            //
-           B(Star), R(1),                                              //
-           B(LdaGlobal), U8(0), U8(vector->GetIndex(slot2)),           //
-           B(Star), R(0),                                              //
-           B(LdaSmi8), U8(1),                                          //
-           B(Star), R(2),                                              //
-           B(LdaSmi8), U8(2),                                          //
-           B(Star), R(3),                                              //
-           B(LdaSmi8), U8(3),                                          //
-           B(Star), R(4),                                              //
-           B(CallIC), R(0), R(1), U8(4), U8(vector->GetIndex(slot1)),  //
-           B(Return)                                                   //
+           B(StackCheck),                                            //
+           B(LdaUndefined),                                          //
+           B(Star), R(1),                                            //
+           B(LdaGlobal), U8(0), U8(vector->GetIndex(slot2)),   //
+           B(Star), R(0),                                            //
+           B(LdaSmi8), U8(1),                                        //
+           B(Star), R(2),                                            //
+           B(LdaSmi8), U8(2),                                        //
+           B(Star), R(3),                                            //
+           B(LdaSmi8), U8(3),                                        //
+           B(Star), R(4),                                            //
+           B(Call), R(0), R(1), U8(4), U8(vector->GetIndex(slot1)),  //
+           B(Return)                                                 //
        },
        1,
        {"t"}},
@@ -2300,7 +2300,7 @@ TEST(DeclareGlobals) {
            B(Star), R(2),                                                //
            B(LdaGlobal), U8(1), U8(load_vector->GetIndex(load_slot_1)),  //
            B(Star), R(1),                                                //
-           B(CallIC), R(1), R(2), U8(1),                                 //
+           B(Call), R(1), R(2), U8(1),                                   //
            /*                */ U8(load_vector->GetIndex(call_slot_1)),  //
            B(Star), R(0),                                                //
            B(Return)                                                     //
@@ -3774,13 +3774,13 @@ TEST(FunctionLiterals) {
        1,
        15,
        {
-           B(StackCheck),                                             //
-           B(LdaUndefined),                                           //
-           B(Star), R(1),                                             //
-           B(CreateClosure), U8(0), U8(0),                            //
-           B(Star), R(0),                                             //
-           B(CallIC), R(0), R(1), U8(1), U8(vector->GetIndex(slot)),  //
-           B(Return)                                                  //
+           B(StackCheck),                                           //
+           B(LdaUndefined),                                         //
+           B(Star), R(1),                                           //
+           B(CreateClosure), U8(0), U8(0),                          //
+           B(Star), R(0),                                           //
+           B(Call), R(0), R(1), U8(1), U8(vector->GetIndex(slot)),  //
+           B(Return)                                                //
        },
        1,
        {InstanceType::SHARED_FUNCTION_INFO_TYPE}},
@@ -3789,15 +3789,15 @@ TEST(FunctionLiterals) {
        1,
        19,
        {
-           B(StackCheck),                                             //
-           B(LdaUndefined),                                           //
-           B(Star), R(1),                                             //
-           B(CreateClosure), U8(0), U8(0),                            //
-           B(Star), R(0),                                             //
-           B(LdaSmi8), U8(1),                                         //
-           B(Star), R(2),                                             //
-           B(CallIC), R(0), R(1), U8(2), U8(vector->GetIndex(slot)),  //
-           B(Return)                                                  //
+           B(StackCheck),                                           //
+           B(LdaUndefined),                                         //
+           B(Star), R(1),                                           //
+           B(CreateClosure), U8(0), U8(0),                          //
+           B(Star), R(0),                                           //
+           B(LdaSmi8), U8(1),                                       //
+           B(Star), R(2),                                           //
+           B(Call), R(0), R(1), U8(2), U8(vector->GetIndex(slot)),  //
+           B(Return)                                                //
        },
        1,
        {InstanceType::SHARED_FUNCTION_INFO_TYPE}},
@@ -3861,7 +3861,7 @@ TEST(RegExpLiterals) {
            B(Star), R(0),                                              //
            B(LdaConstant), U8(2),                                      //
            B(Star), R(2),                                              //
-           B(CallIC), R(0), R(1), U8(2), U8(vector->GetIndex(slot1)),  //
+           B(Call), R(0), R(1), U8(2), U8(vector->GetIndex(slot1)),    //
            B(Return),                                                  //
        },
        3,
@@ -5036,17 +5036,17 @@ TEST(ContextVariables) {
        1,
        25,
        {
-           B(CallRuntime), U16(Runtime::kNewFunctionContext),         //
-           /*           */ R(closure), U8(1),                         //
-           B(PushContext), R(0),                                      //
-           B(StackCheck),                                             //
-           B(LdaUndefined),                                           //
-           B(Star), R(2),                                             //
-           B(CreateClosure), U8(0), U8(0),                            //
-           B(Star), R(1),                                             //
-           B(CallIC), R(1), R(2), U8(1), U8(vector->GetIndex(slot)),  //
-           B(LdaContextSlot), R(context), U8(first_context_slot),     //
-           B(Return),                                                 //
+           B(CallRuntime), U16(Runtime::kNewFunctionContext),       //
+           /*           */ R(closure), U8(1),                       //
+           B(PushContext), R(0),                                    //
+           B(StackCheck),                                           //
+           B(LdaUndefined),                                         //
+           B(Star), R(2),                                           //
+           B(CreateClosure), U8(0), U8(0),                          //
+           B(Star), R(1),                                           //
+           B(Call), R(1), R(2), U8(1), U8(vector->GetIndex(slot)),  //
+           B(LdaContextSlot), R(context), U8(first_context_slot),   //
+           B(Return),                                               //
        },
        1,
        {InstanceType::SHARED_FUNCTION_INFO_TYPE}},
@@ -5087,7 +5087,7 @@ TEST(ContextVariables) {
        "return b",
        3 * kPointerSize,
        1,
-       1041,
+       1042,
        {
            B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure),  //
            /*           */ U8(1),                                          //
@@ -5104,9 +5104,9 @@ TEST(ContextVariables) {
                       B(StaContextSlot), R(context), U8(wide_slot++)),     //
            B(LdaUndefined),                                                //
            B(Star), R(2),                                                  //
-           B(LdaGlobal), U8(0), U8(1),                                     //
+           B(LdaGlobal), U8(0), U8(1),                               //
            B(Star), R(1),                                                  //
-           B(Call), R(1), R(2), U8(1),                                     //
+           B(Call), R(1), R(2), U8(1), U8(0),                              //
            B(LdaSmi8), U8(100),                                            //
            B(StaContextSlotWide), R(context), U16(256),                    //
            B(LdaContextSlotWide), R(context), U16(256),                    //
@@ -6324,13 +6324,13 @@ DISABLED_TEST(ForOf) {
            B(LdaConstant), U8(1),                                           //
            B(KeyedLoadIC), R(5), U8(vector->GetIndex(slot2)),         //
            B(Star), R(4),                                                   //
-           B(CallIC), R(4), R(5), U8(1), U8(vector->GetIndex(slot1)),       //
+           B(Call), R(4), R(5), U8(1), U8(vector->GetIndex(slot1)),         //
            B(Star), R(1),                                                   //
            B(Ldar), R(1),                                                   //
            B(Star), R(6),                                                   //
            B(LoadIC), R(6), U8(2), U8(vector->GetIndex(slot4)),       //
            B(Star), R(5),                                                   //
-           B(CallIC), R(5), R(6), U8(1), U8(vector->GetIndex(slot3)),       //
+           B(Call), R(5), R(6), U8(1), U8(vector->GetIndex(slot3)),         //
            B(Star), R(2),                                                   //
            B(Star), R(4),                                                   //
            B(CallRuntime), U16(Runtime::kInlineIsJSReceiver), R(4), U8(1),  //
@@ -6373,13 +6373,13 @@ DISABLED_TEST(ForOf) {
            B(LdaConstant), U8(1),                                           //
            B(KeyedLoadIC), R(6), U8(vector->GetIndex(slot2)),         //
            B(Star), R(5),                                                   //
-           B(CallIC), R(5), R(6), U8(1), U8(vector->GetIndex(slot1)),       //
+           B(Call), R(5), R(6), U8(1), U8(vector->GetIndex(slot1)),         //
            B(Star), R(1),                                                   //
            B(Ldar), R(1),                                                   //
            B(Star), R(7),                                                   //
            B(LoadIC), R(7), U8(2), U8(vector->GetIndex(slot4)),       //
            B(Star), R(6),                                                   //
-           B(CallIC), R(6), R(7), U8(1), U8(vector->GetIndex(slot3)),       //
+           B(Call), R(6), R(7), U8(1), U8(vector->GetIndex(slot3)),         //
            B(Star), R(2),                                                   //
            B(Star), R(5),                                                   //
            B(CallRuntime), U16(Runtime::kInlineIsJSReceiver), R(5), U8(1),  //
@@ -6424,13 +6424,13 @@ DISABLED_TEST(ForOf) {
            B(LdaConstant), U8(1),                                           //
            B(KeyedLoadIC), R(5), U8(vector->GetIndex(slot2)),         //
            B(Star), R(4),                                                   //
-           B(CallIC), R(4), R(5), U8(1), U8(vector->GetIndex(slot1)),       //
+           B(Call), R(4), R(5), U8(1), U8(vector->GetIndex(slot1)),         //
            B(Star), R(1),                                                   //
            B(Ldar), R(1),                                                   //
            B(Star), R(6),                                                   //
            B(LoadIC), R(6), U8(2), U8(vector->GetIndex(slot4)),       //
            B(Star), R(5),                                                   //
-           B(CallIC), R(5), R(6), U8(1), U8(vector->GetIndex(slot3)),       //
+           B(Call), R(5), R(6), U8(1), U8(vector->GetIndex(slot3)),         //
            B(Star), R(2),                                                   //
            B(Star), R(4),                                                   //
            B(CallRuntime), U16(Runtime::kInlineIsJSReceiver), R(4), U8(1),  //
@@ -6486,13 +6486,13 @@ DISABLED_TEST(ForOf) {
            B(LdaConstant), U8(2),                                           //
            B(KeyedLoadIC), R(4), U8(vector->GetIndex(slot2)),         //
            B(Star), R(3),                                                   //
-           B(CallIC), R(3), R(4), U8(1), U8(vector->GetIndex(slot1)),       //
+           B(Call), R(3), R(4), U8(1), U8(vector->GetIndex(slot1)),         //
            B(Star), R(0),                                                   //
            B(Ldar), R(0),                                                   //
            B(Star), R(5),                                                   //
            B(LoadIC), R(5), U8(3), U8(vector->GetIndex(slot4)),       //
            B(Star), R(4),                                                   //
-           B(CallIC), R(4), R(5), U8(1), U8(vector->GetIndex(slot3)),       //
+           B(Call), R(4), R(5), U8(1), U8(vector->GetIndex(slot3)),         //
            B(Star), R(1),                                                   //
            B(Star), R(3),                                                   //
            B(CallRuntime), U16(Runtime::kInlineIsJSReceiver), R(3), U8(1),  //
@@ -7440,7 +7440,7 @@ TEST(Eval) {
       {"return eval('1;');",
        9 * kPointerSize,
        1,
-       64,
+       65,
        {
            B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure),   //
            /*           */ U8(1),                                           //
@@ -7468,7 +7468,7 @@ TEST(Eval) {
            B(CallRuntime), U16(Runtime::kResolvePossiblyDirectEval), R(4),  //
            /*           */ U8(5),                                           //
            B(Star), R(1),                                                   //
-           B(Call), R(1), R(2), U8(2),                                      //
+           B(Call), R(1), R(2), U8(2), U8(0),                               //
            B(Return),                                                       //
        },
        2,
@@ -7498,7 +7498,7 @@ TEST(LookupSlot) {
       {"eval('var x = 10;'); return x;",
        9 * kPointerSize,
        1,
-       66,
+       67,
        {
            B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure),   //
            /*           */ U8(1),                                           //
@@ -7526,7 +7526,7 @@ TEST(LookupSlot) {
            B(CallRuntime), U16(Runtime::kResolvePossiblyDirectEval), R(4),  //
                            U8(5),                                           //
            B(Star), R(1),                                                   //
-           B(Call), R(1), R(2), U8(2),                                      //
+           B(Call), R(1), R(2), U8(2), U8(0),                               //
            B(LdaLookupSlot), U8(2),                                         //
            B(Return),                                                       //
        },
@@ -7535,7 +7535,7 @@ TEST(LookupSlot) {
       {"eval('var x = 10;'); return typeof x;",
        9 * kPointerSize,
        1,
-       67,
+       68,
        {
            B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure),   //
            /*           */ U8(1),                                           //
@@ -7563,7 +7563,7 @@ TEST(LookupSlot) {
            B(CallRuntime), U16(Runtime::kResolvePossiblyDirectEval), R(4),  //
            /*           */ U8(5),                                           //
            B(Star), R(1),                                                   //
-           B(Call), R(1), R(2), U8(2),                                      //
+           B(Call), R(1), R(2), U8(2), U8(0),                               //
            B(LdaLookupSlotInsideTypeof), U8(2),                             //
            B(TypeOf),                                                       //
            B(Return),                                                       //
@@ -7573,7 +7573,7 @@ TEST(LookupSlot) {
       {"x = 20; return eval('');",
        9 * kPointerSize,
        1,
-       68,
+       69,
        {
            B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure),   //
                            U8(1),                                           //
@@ -7603,7 +7603,7 @@ TEST(LookupSlot) {
            B(CallRuntime), U16(Runtime::kResolvePossiblyDirectEval), R(4),  //
            /*           */ U8(5),                                           //
            B(Star), R(1),                                                   //
-           B(Call), R(1), R(2), U8(2),                                      //
+           B(Call), R(1), R(2), U8(2), U8(0),                               //
            B(Return),                                                       //
        },
        3,
@@ -7641,7 +7641,7 @@ TEST(CallLookupSlot) {
       {"g = function(){}; eval(''); return g();",
        9 * kPointerSize,
        1,
-       84,
+       85,
        {
            B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure),   //
            /*           */ U8(1),                                           //
@@ -7671,12 +7671,12 @@ TEST(CallLookupSlot) {
            B(CallRuntime), U16(Runtime::kResolvePossiblyDirectEval), R(4),  //
                            U8(5),                                           //
            B(Star), R(1),                                                   //
-           B(Call), R(1), R(2), U8(2),                                      //
+           B(Call), R(1), R(2), U8(2), U8(0),                               //
            B(LdaConstant), U8(1),                                           //
            B(Star), R(3),                                                   //
            B(CallRuntimeForPair), U16(Runtime::kLoadLookupSlotForCall),     //
                                   R(3), U8(1), R(1),                        //
-           B(CallIC), R(1), R(2), U8(1), U8(vector->GetIndex(slot2)),       //
+           B(Call), R(1), R(2), U8(1), U8(vector->GetIndex(slot2)),         //
            B(Return),                                                       //
        },
        4,
@@ -9069,7 +9069,7 @@ TEST(ClassDeclarations) {
        B(Star), R(6),                                                         //
        B(CallRuntime), U16(Runtime::kDefineClass), R(3), U8(4),               //
        B(Star), R(3),                                                         //
-       B(LoadIC), R(3), U8(1), U8(1),                                         //
+       B(LoadIC), R(3), U8(1), U8(1),                                   //
        B(Star), R(4),                                                         //
        B(CallRuntime), U16(Runtime::kFinalizeClassDefinition), R(3), U8(2),   //
        B(Star), R(0),                                                         //
@@ -9096,113 +9096,6 @@ TEST(ClassDeclarations) {
   }
 }
 
-TEST(TailCall) {
-  bool old_tailcall_flag = FLAG_harmony_tailcalls;
-  FLAG_harmony_tailcalls = true;
-
-  InitializedHandleScope handle_scope;
-  BytecodeGeneratorHelper helper;
-
-  int closure = Register::function_closure().index();
-  int context = Register::current_context().index();
-  int new_target = Register::new_target().index();
-
-  // clang-format off
-  ExpectedSnippet<const char*> snippets[] = {
-      {"function g() { throw new Error('foo'); };"
-       "var eval = g;"
-       "function f() {"
-       " 'use strict';"
-       " return eval('g()');"
-       "}",
-       9 * kPointerSize,
-       1,
-       63,
-       {
-           B(CallRuntime), U16(Runtime::kNewFunctionContext), R(closure),   //
-                           U8(1),                                           //
-           B(PushContext), R(0),                                            //
-           B(Ldar), THIS(1),                                                //
-           B(StaContextSlot), R(context), U8(4),                            //
-           B(CreateUnmappedArguments),                                      //
-           B(StaContextSlot), R(context), U8(5),                            //
-           B(Ldar), R(new_target),                                          //
-           B(StaContextSlot), R(context), U8(6),                            //
-           B(StackCheck),                                                   //
-           B(LdaUndefined),                                                 //
-           B(Star), R(2),                                                   //
-           B(LdaGlobal), U8(0), U8(1),                                      //
-           B(Star), R(1),                                                   //
-           B(LdaConstant), U8(1),                                           //
-           B(Star), R(3),                                                   //
-           B(Mov), R(1), R(4),                                              //
-           B(Mov), R(3), R(5),                                              //
-           B(Mov), R(closure), R(6),                                        //
-           B(LdaSmi8), U8(1),                                               //
-           B(Star), R(7),                                                   //
-           B(LdaSmi8), U8(64),                                              //
-           B(Star), R(8),                                                   //
-           B(CallRuntime), U16(Runtime::kResolvePossiblyDirectEval), R(4),  //
-                           U8(5),                                           //
-           B(Star), R(1),                                                   //
-           B(TailCall), R(1), R(2), U8(2),                                  //
-           B(Return),                                                       //
-       },
-       2,
-       {"eval",
-        "g()"}}
-  };
-  // clang-format on
-
-  for (size_t i = 0; i < arraysize(snippets); i++) {
-    Handle<BytecodeArray> bytecode_array =
-        helper.MakeBytecodeForFunction(snippets[i].code_snippet);
-    CheckBytecodeArrayEqual(snippets[i], bytecode_array);
-  }
-
-  FLAG_harmony_tailcalls = old_tailcall_flag;
-}
-
-TEST(TailCallIC) {
-  bool old_tailcall_flag = FLAG_harmony_tailcalls;
-  FLAG_harmony_tailcalls = true;
-
-  InitializedHandleScope handle_scope;
-  BytecodeGeneratorHelper helper;
-
-  // clang-format off
-  ExpectedSnippet<const char*> snippets[] = {
-      {"function g() { return 0; };"
-       "function f() {"
-       " 'use strict';"
-       " return g();"
-       "}",
-       2 * kPointerSize,
-       1,
-       15,
-       {
-           B(StackCheck),                            //
-           B(LdaUndefined),                          //
-           B(Star), R(1),                            //
-           B(LdaGlobal), U8(0), U8(3),               //
-           B(Star), R(0),                            //
-           B(TailCallIC), R(0), R(1), U8(1), U8(1),  //
-           B(Return),
-       },
-       1,
-       {"g"}}
-  };
-  // clang-format on
-
-  for (size_t i = 0; i < arraysize(snippets); i++) {
-    Handle<BytecodeArray> bytecode_array =
-        helper.MakeBytecodeForFunction(snippets[i].code_snippet);
-    CheckBytecodeArrayEqual(snippets[i], bytecode_array);
-  }
-
-  FLAG_harmony_tailcalls = old_tailcall_flag;
-}
-
 // TODO(oth): Add tests for super keyword.
 
 }  // namespace interpreter
diff --git a/test/cctest/interpreter/test-interpreter.cc b/test/cctest/interpreter/test-interpreter.cc
index 32921cfb03..69cf0e18bd 100644
--- a/test/cctest/interpreter/test-interpreter.cc
+++ b/test/cctest/interpreter/test-interpreter.cc
@@ -928,8 +928,7 @@ TEST(InterpreterStoreKeyedProperty) {
   CHECK_EQ(Smi::cast(*result), Smi::FromInt(999));
 }
 
-static void TestInterpreterCall(TailCallMode tail_call_mode,
-                                bool has_feedback_slot) {
+static void TestInterpreterCall(TailCallMode tail_call_mode) {
   HandleAndZoneScope handles;
   i::Isolate* isolate = handles.main_isolate();
   i::Factory* factory = isolate->factory();
@@ -937,15 +936,10 @@ static void TestInterpreterCall(TailCallMode tail_call_mode,
 
   i::FeedbackVectorSpec feedback_spec(&zone);
   i::FeedbackVectorSlot slot = feedback_spec.AddLoadICSlot();
-  i::FeedbackVectorSlot call_slot = feedback_spec.AddCallICSlot();
 
   Handle<i::TypeFeedbackVector> vector =
       i::NewTypeFeedbackVector(isolate, &feedback_spec);
   int slot_index = vector->GetIndex(slot);
-  int call_slot_index = -1;
-  if (has_feedback_slot) {
-    call_slot_index = vector->GetIndex(call_slot);
-  }
 
   Handle<i::String> name = factory->NewStringFromAsciiChecked("func");
   name = factory->string_table()->LookupString(isolate, name);
@@ -955,16 +949,9 @@ static void TestInterpreterCall(TailCallMode tail_call_mode,
     BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone(), 1,
                                  0, 1);
     builder.LoadNamedProperty(builder.Parameter(0), name, slot_index)
-        .StoreAccumulatorInRegister(Register(0));
-
-    if (has_feedback_slot) {
-      builder.CallIC(Register(0), builder.Parameter(0), 1, call_slot_index,
-                     tail_call_mode);
-    } else {
-      builder.Call(Register(0), builder.Parameter(0), 1, tail_call_mode);
-    }
-
-    builder.Return();
+        .StoreAccumulatorInRegister(Register(0))
+        .Call(Register(0), builder.Parameter(0), 1, 0, tail_call_mode)
+        .Return();
     Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
 
     InterpreterTester tester(handles.main_isolate(), bytecode_array, vector);
@@ -981,14 +968,9 @@ static void TestInterpreterCall(TailCallMode tail_call_mode,
     BytecodeArrayBuilder builder(handles.main_isolate(), handles.main_zone(), 1,
                                  0, 1);
     builder.LoadNamedProperty(builder.Parameter(0), name, slot_index)
-        .StoreAccumulatorInRegister(Register(0));
-    if (has_feedback_slot) {
-      builder.CallIC(Register(0), builder.Parameter(0), 1, call_slot_index,
-                     tail_call_mode);
-    } else {
-      builder.Call(Register(0), builder.Parameter(0), 1, tail_call_mode);
-    }
-    builder.Return();
+        .StoreAccumulatorInRegister(Register(0))
+        .Call(Register(0), builder.Parameter(0), 1, 0, tail_call_mode)
+        .Return();
     Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
 
     InterpreterTester tester(handles.main_isolate(), bytecode_array, vector);
@@ -1014,17 +996,9 @@ static void TestInterpreterCall(TailCallMode tail_call_mode,
         .LoadLiteral(Smi::FromInt(51))
         .StoreAccumulatorInRegister(Register(2))
         .LoadLiteral(Smi::FromInt(11))
-        .StoreAccumulatorInRegister(Register(3));
-
-    if (has_feedback_slot) {
-      builder.CallIC(Register(0), Register(1), 3, call_slot_index,
-                     tail_call_mode);
-    } else {
-      builder.Call(Register(0), Register(1), 3, tail_call_mode);
-    }
-
-    builder.Return();
-
+        .StoreAccumulatorInRegister(Register(3))
+        .Call(Register(0), Register(1), 3, 0, tail_call_mode)
+        .Return();
     Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
 
     InterpreterTester tester(handles.main_isolate(), bytecode_array, vector);
@@ -1065,17 +1039,9 @@ static void TestInterpreterCall(TailCallMode tail_call_mode,
         .LoadLiteral(factory->NewStringFromAsciiChecked("i"))
         .StoreAccumulatorInRegister(Register(10))
         .LoadLiteral(factory->NewStringFromAsciiChecked("j"))
-        .StoreAccumulatorInRegister(Register(11));
-
-    if (has_feedback_slot) {
-      builder.CallIC(Register(0), Register(1), 11, call_slot_index,
-                     tail_call_mode);
-    } else {
-      builder.Call(Register(0), Register(1), 11, tail_call_mode);
-    }
-
-    builder.Return();
-
+        .StoreAccumulatorInRegister(Register(11))
+        .Call(Register(0), Register(1), 11, 0, tail_call_mode)
+        .Return();
     Handle<BytecodeArray> bytecode_array = builder.ToBytecodeArray();
 
     InterpreterTester tester(handles.main_isolate(), bytecode_array, vector);
@@ -1095,13 +1061,9 @@ static void TestInterpreterCall(TailCallMode tail_call_mode,
   }
 }
 
-TEST(InterpreterCall) { TestInterpreterCall(TailCallMode::kDisallow, false); }
+TEST(InterpreterCall) { TestInterpreterCall(TailCallMode::kDisallow); }
 
-TEST(InterpreterTailCall) { TestInterpreterCall(TailCallMode::kAllow, false); }
-
-TEST(InterpreterCallIC) { TestInterpreterCall(TailCallMode::kDisallow, true); }
-
-TEST(InterpreterTailCallIC) { TestInterpreterCall(TailCallMode::kAllow, true); }
+TEST(InterpreterTailCall) { TestInterpreterCall(TailCallMode::kAllow); }
 
 static BytecodeArrayBuilder& SetRegister(BytecodeArrayBuilder& builder,
                                          Register reg, int value,
diff --git a/test/mjsunit/mjsunit.status b/test/mjsunit/mjsunit.status
index 7a68261902..738bf9f59d 100644
--- a/test/mjsunit/mjsunit.status
+++ b/test/mjsunit/mjsunit.status
@@ -918,12 +918,6 @@
   'unicodelctest-no-optimization': [SKIP],
 }],  # ignition == True and (arch == arm or arch == arm64)
 
-['ignition == True and arch == x64', {
-  # TODO(mythria,4680): Stack call size exceeds limit.
-  # Try to tail call CallICStub from PushArgsAndCallIC builtin.
-  'regress/regress-353551': [FAIL],
-}],  # ignition == True and arch == x64
-
 ##############################################################################
 ['gcov_coverage', {
   # Tests taking too long.
diff --git a/test/unittests/interpreter/bytecode-array-builder-unittest.cc b/test/unittests/interpreter/bytecode-array-builder-unittest.cc
index ee28e6da87..839215f743 100644
--- a/test/unittests/interpreter/bytecode-array-builder-unittest.cc
+++ b/test/unittests/interpreter/bytecode-array-builder-unittest.cc
@@ -94,14 +94,10 @@ TEST_F(BytecodeArrayBuilderTest, AllBytecodesGenerated) {
       .CreateObjectLiteral(factory->NewFixedArray(1), 0, 0);
 
   // Call operations.
-  builder.Call(reg, other, 1)
-      .Call(reg, wide, 1)
-      .TailCall(reg, other, 1)
-      .TailCall(reg, wide, 1)
-      .CallIC(reg, other, 1, 0, TailCallMode::kDisallow)
-      .CallIC(reg, other, 1, 0, TailCallMode::kAllow)
-      .CallIC(reg, wide, 1, 0, TailCallMode::kDisallow)
-      .CallIC(reg, wide, 1, 0, TailCallMode::kAllow)
+  builder.Call(reg, other, 1, 0)
+      .Call(reg, wide, 1, 0)
+      .TailCall(reg, other, 1, 0)
+      .TailCall(reg, wide, 1, 0)
       .CallRuntime(Runtime::kIsArray, reg, 1)
       .CallRuntime(Runtime::kIsArray, wide, 1)
       .CallRuntimeForPair(Runtime::kLoadLookupSlotForCall, reg, 1, other)