Preserve argument count for calls.

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 42 matching lines @@
     __ PushReturnAddressFrom(ecx);
   }
 
   // JumpToExternalReference expects eax to contain the number of arguments
   // including the receiver and the extra arguments.
   __ add(eax, Immediate(num_extra_args + 1));
 
   __ JumpToExternalReference(ExternalReference(id, masm->isolate()));
 }
 
-
-static void CallRuntimePassFunction(
-    MacroAssembler* masm, Runtime::FunctionId function_id) {
+static void CallRuntimePassFunction(MacroAssembler* masm,
+                                    Runtime::FunctionId function_id,
+                                    Register output) {

[Michael Starzinger, 2016/02/09 11:52:19]

Instead of passing an output register this function, we could merge it entirely
into GenerateTailCallToReturnedCode which internally can preserve the eax
register. So in the end we would have two function. WDYT?

static void GenerateTailCallToSharedCode(MacroAssembler* masm);

static void GenerateTailCallToReturnedCode(MacroAssembler* masm,
                                           Runtime::FunctionId function_id);

[mvstanton, 2016/02/09 18:47:47]

Most excellent idea, thanks!

   // ----------- S t a t e -------------
+  //  -- eax : argument count (preserved for callee)
   //  -- edx : new target (preserved for callee)
   //  -- edi : target function (preserved for callee)
   // -----------------------------------
-
+  DCHECK(!output.is(eax) && !output.is(edx) && !output.is(edi));
   FrameScope scope(masm, StackFrame::INTERNAL);
+  // Push the number of arguments to the callee.
+  __ SmiTag(eax);
+  __ push(eax);
   // Push a copy of the target function and the new target.
   __ push(edi);
   __ push(edx);
   // Function is also the parameter to the runtime call.
   __ push(edi);
 
   __ CallRuntime(function_id, 1);
+  __ mov(output, eax);
+
   // Restore target function and new target.
   __ pop(edx);
   __ pop(edi);
+  __ pop(eax);
+  __ SmiUntag(eax);
+}
+
+static void GenerateTailCallToSharedCode(MacroAssembler* masm,
+                                         Register scratch) {
+  DCHECK(!scratch.is(eax) && !scratch.is(edi));
+  __ mov(scratch, FieldOperand(edi, JSFunction::kSharedFunctionInfoOffset));
+  __ mov(scratch, FieldOperand(scratch, SharedFunctionInfo::kCodeOffset));
+  __ lea(scratch, FieldOperand(scratch, Code::kHeaderSize));
+  __ jmp(scratch);
+}
+
+static void GenerateTailCallToReturnedCode(MacroAssembler* masm,
+                                           Register code) {
+  __ lea(code, FieldOperand(code, Code::kHeaderSize));
+  __ jmp(code);
 }
 
 
-static void GenerateTailCallToSharedCode(MacroAssembler* masm) {
-  __ mov(eax, FieldOperand(edi, JSFunction::kSharedFunctionInfoOffset));
-  __ mov(eax, FieldOperand(eax, SharedFunctionInfo::kCodeOffset));
-  __ lea(eax, FieldOperand(eax, Code::kHeaderSize));
-  __ jmp(eax);
-}
-
-
-static void GenerateTailCallToReturnedCode(MacroAssembler* masm) {
-  __ lea(eax, FieldOperand(eax, Code::kHeaderSize));
-  __ jmp(eax);
-}
-
-
 void Builtins::Generate_InOptimizationQueue(MacroAssembler* masm) {
   // Checking whether the queued function is ready for install is optional,
   // since we come across interrupts and stack checks elsewhere.  However,
   // not checking may delay installing ready functions, and always checking
   // would be quite expensive.  A good compromise is to first check against
   // stack limit as a cue for an interrupt signal.
   Label ok;
   ExternalReference stack_limit =
       ExternalReference::address_of_stack_limit(masm->isolate());
   __ cmp(esp, Operand::StaticVariable(stack_limit));
   __ j(above_equal, &ok, Label::kNear);
 
-  CallRuntimePassFunction(masm, Runtime::kTryInstallOptimizedCode);
-  GenerateTailCallToReturnedCode(masm);
+  CallRuntimePassFunction(masm, Runtime::kTryInstallOptimizedCode, ebx);
+  GenerateTailCallToReturnedCode(masm, ebx);
 
   __ bind(&ok);
-  GenerateTailCallToSharedCode(masm);
+  GenerateTailCallToSharedCode(masm, ebx);
 }
 
 
 static void Generate_JSConstructStubHelper(MacroAssembler* masm,
                                            bool is_api_function,
                                            bool create_implicit_receiver,
                                            bool check_derived_construct) {
   // ----------- S t a t e -------------
   //  -- eax: number of arguments
   //  -- edi: constructor function
@@ skipping 715 matching lines @@
   // This simulates the initial call to bytecode handlers in interpreter entry
   // trampoline. The return will never actually be taken, but our stack walker
   // uses this address to determine whether a frame is interpreted.
   __ Push(masm->isolate()->builtins()->InterpreterEntryTrampoline());
 
   Generate_EnterBytecodeDispatch(masm);
 }
 
 
 void Builtins::Generate_CompileLazy(MacroAssembler* masm) {
-  CallRuntimePassFunction(masm, Runtime::kCompileLazy);
-  GenerateTailCallToReturnedCode(masm);
+  CallRuntimePassFunction(masm, Runtime::kCompileLazy, ebx);
+  GenerateTailCallToReturnedCode(masm, ebx);
 }
 
 
 void Builtins::Generate_CompileOptimized(MacroAssembler* masm) {
-  CallRuntimePassFunction(masm, Runtime::kCompileOptimized_NotConcurrent);
-  GenerateTailCallToReturnedCode(masm);
+  CallRuntimePassFunction(masm, Runtime::kCompileOptimized_NotConcurrent, ebx);
+  GenerateTailCallToReturnedCode(masm, ebx);
 }
 
 
 void Builtins::Generate_CompileOptimizedConcurrent(MacroAssembler* masm) {
-  CallRuntimePassFunction(masm, Runtime::kCompileOptimized_Concurrent);
-  GenerateTailCallToReturnedCode(masm);
+  CallRuntimePassFunction(masm, Runtime::kCompileOptimized_Concurrent, ebx);
+  GenerateTailCallToReturnedCode(masm, ebx);
 }
 
 
 static void GenerateMakeCodeYoungAgainCommon(MacroAssembler* masm) {
   // For now, we are relying on the fact that make_code_young doesn't do any
   // garbage collection which allows us to save/restore the registers without
   // worrying about which of them contain pointers. We also don't build an
   // internal frame to make the code faster, since we shouldn't have to do stack
   // crawls in MakeCodeYoung. This seems a bit fragile.
 
@@ skipping 1897 matching lines @@
 
   __ bind(&ok);
   __ ret(0);
 }
 
 #undef __
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_TARGET_ARCH_IA32