[Interpreter] Support compiling for baseline on return from interpreted function.

src/x64/builtins-x64.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_X64
 
 #include "src/code-factory.h"
 #include "src/codegen.h"
 #include "src/deoptimizer.h"
 #include "src/full-codegen/full-codegen.h"
@@ skipping 707 matching lines @@
   __ bind(&bytecode_array_not_present);
   __ leave();  // Leave the frame so we can tail call.
   __ movp(rcx, FieldOperand(rdi, JSFunction::kSharedFunctionInfoOffset));
   __ movp(rcx, FieldOperand(rcx, SharedFunctionInfo::kCodeOffset));
   __ leap(rcx, FieldOperand(rcx, Code::kHeaderSize));
   __ movp(FieldOperand(rdi, JSFunction::kCodeEntryOffset), rcx);
   __ RecordWriteCodeEntryField(rdi, rcx, r15);
   __ jmp(rcx);
 }
 
-
 void Builtins::Generate_InterpreterExitTrampoline(MacroAssembler* masm) {
   // The return value is in accumulator, which is already in rax.
 
-  // Leave the frame (also dropping the register file).
+  // Save the interpreter frame's function and callee pc to check if it has
+  // been marked for baseline compilation on return.
+  __ movp(rcx, Operand(rsp, 0));
+  __ movp(rdi, Operand(rbp, StandardFrameConstants::kFunctionOffset));
+
+  // Leave the frame (also dropping the register file). Do this before checking
+  // for baseline compile so that we don't count as an activation on the stack.
   __ leave();
 
+  // Check if the function has been marked for baseline compilation on return.
+  Label not_marked_for_baseline;
+  ExternalReference external(Builtins::kInterpreterMarkBaselineOnReturn,
+                             masm->isolate());
+  __ movp(rbx, masm->ExternalOperand(external));
+  __ leap(rbx, FieldOperand(rbx, Code::kHeaderSize));
+  __ cmpp(rcx, rbx);
+  __ j(not_equal, &not_marked_for_baseline, Label::kNear);
+
+  {
+    FrameScope frame_scope(masm, StackFrame::INTERNAL);
+    // Push bytecode array and rax for return.
+    __ Push(kInterpreterBytecodeArrayRegister);
+    __ Push(rax);
+
+    // Push function as argument and compile for baseline.
+    __ Push(rdi);
+    __ CallRuntime(Runtime::kCompileBaseline);
+
+    // Restore bytecode array and rax.
+    __ Pop(rax);
+    __ Pop(kInterpreterBytecodeArrayRegister);
+  }
+
+  __ bind(&not_marked_for_baseline);
+
   // Drop receiver + arguments and return.
   __ movl(rbx, FieldOperand(kInterpreterBytecodeArrayRegister,
                             BytecodeArray::kParameterSizeOffset));
   __ PopReturnAddressTo(rcx);
   __ addp(rsp, rbx);
   __ PushReturnAddressFrom(rcx);
+
   __ ret(0);
 }
 
+void Builtins::Generate_InterpreterMarkBaselineOnReturn(MacroAssembler* masm) {
+  // This builtin is only used as a marker to be checked in
+  // InterpreterExitTrampoline and should never be called itself.
+  __ Abort(kUnexpectedCallToMarkBaselineOnReturn);
+}
 
 static void Generate_InterpreterPushArgs(MacroAssembler* masm,
                                          bool push_receiver) {
   // ----------- 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.
   // -----------------------------------
 
@@ skipping 2212 matching lines @@
   __ ret(0);
 }
 
 
 #undef __
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_TARGET_ARCH_X64