[Interpreter] Implements calls through CallICStub in the interpreter.

src/ia32/builtins-ia32.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #if V8_TARGET_ARCH_IA32
 
 #include "src/code-factory.h"
 #include "src/codegen.h"
 #include "src/deoptimizer.h"
 #include "src/full-codegen/full-codegen.h"
@@ skipping 657 matching lines @@
   Label loop_header, loop_check;
   __ jmp(&loop_check);
   __ bind(&loop_header);
   __ Push(Operand(ebx, 0));
   __ sub(ebx, Immediate(kPointerSize));
   __ bind(&loop_check);
   __ cmp(ebx, array_limit);
   __ j(greater, &loop_header, Label::kNear);
 }
 
+static void Generate_InterpreterComputeLastArgumentAddress(
+    MacroAssembler* masm) {
+  // Find the address of the last argument.
+  // ----------- S t a t e -------------
+  //  input: ebx : Address of the first argument.
+  //  output: ecx: Address of the last argument.
+  // -----------------------------------
+  __ mov(ecx, eax);
+  __ add(ecx, Immediate(1));  // Add one for receiver.
+  __ shl(ecx, kPointerSizeLog2);
+  __ neg(ecx);
+  __ add(ecx, ebx);
+}
 
 // static
 void Builtins::Generate_InterpreterPushArgsAndCall(MacroAssembler* masm) {
   // ----------- 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).
   // -----------------------------------
 
   // Pop return address to allow tail-call after pushing arguments.
   __ Pop(edx);
 
-  // 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_InterpreterComputeLastArgumentAddress(masm);
   Generate_InterpreterPushArgs(masm, ecx);
 
   // Call the target.
   __ Push(edx);  // Re-push return address.
   __ Jump(masm->isolate()->builtins()->Call(), RelocInfo::CODE_TARGET);
 }
 
 
 // static
+void Builtins::Generate_InterpreterPushArgsAndCallIC(MacroAssembler* masm) {
+  // ----------- 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 in a virtual register.
+    ExternalReference virtual_register =

[mvstanton, 2016/02/15 11:13:45]

I'd love it if we don't have to expand the usage of this virtual register, which
was quite a hack just to support the ia32 fast case on store ics. Is there any
other option?

[rmcilroy, 2016/02/15 11:20:50]

Sorry, this was my fault suggesting it as I thought it was cleaner than the
approach of pushing things to a random point on the stack. The messiness with
that approach is that we need to push it higher than the current sp since we are
about to push arguments on the stack - i.e., (in patch set 1):

  721     // Store the feedback vector below where arguments are going to be
pushed.
  722     // This would act like a temporary store without disturbing the stack.
  723     // We push eax + 1 values, so adjust the displacement accordingly.
  724     __ neg(eax);
  725     __ mov(Operand(esp, eax, times_pointer_size, -2 * kPointerSize), ecx);
  726     __ neg(eax);
  ...
  <Push arguments between the previous sp and where we have just pushed feedback
vector>
  ...
  738     // Restore feedback vector to ebx from the stack.
  739     __ mov(ebx, Operand(esp, -kPointerSize));

Happy to go back to that approach if you think it's better.

[mvstanton, 2016/02/15 11:32:04]

LOL, I know, I am tempted too..! I think the virtual register will bite us
though, or at least more usage of it will make it harder to remove at some
point, so let's use that somewhat tricky stack code.

[mythria, 2016/02/17 11:02:48]

Done.

+        ExternalReference::virtual_handler_register(masm->isolate());
+    __ mov(Operand::StaticVariable(virtual_register), ecx);
+
+    Generate_InterpreterComputeLastArgumentAddress(masm);

[mvstanton, 2016/02/15 11:13:45]

It would be nice if InterpreterComputeLastArgumentAddress took it's registers as
input. It's like a small helper function, it would be nice to be able to see
what it clobbers just by reading the call site.

[mythria, 2016/02/17 11:02:48]

We just clobber ecx, though we use eax and ebx as well. Would it be better if I
pass eax and ebx?

+    Generate_InterpreterPushArgs(masm, ecx);
+
+    // Restore feedback vector to ebx from the virtual register.
+    __ mov(ebx, Operand::StaticVariable(virtual_register));
+
+    // Call via the CallIC stub.
+    CallICState call_ic_state(0, ConvertReceiverMode::kAny,
+                              TailCallMode::kDisallow, 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_InterpreterPushArgsAndConstruct(MacroAssembler* masm) {
   // ----------- S t a t e -------------
   //  -- eax : the number of arguments (not including the receiver)
   //  -- edx : the new target
   //  -- edi : the constructor
   //  -- 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.
   // -----------------------------------
 
@@ skipping 2054 matching lines @@
 
   __ bind(&ok);
   __ ret(0);
 }
 
 #undef __
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_TARGET_ARCH_IA32