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

src/arm/builtins-arm.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_ARM
 
 #include "src/codegen.h"
 #include "src/debug/debug.h"
 #include "src/deoptimizer.h"
 #include "src/full-codegen/full-codegen.h"
@@ skipping 1059 matching lines @@
   __ bind(&bytecode_array_not_present);
   __ LeaveFrame(StackFrame::JAVA_SCRIPT);
   __ ldr(r4, FieldMemOperand(r1, JSFunction::kSharedFunctionInfoOffset));
   __ ldr(r4, FieldMemOperand(r4, SharedFunctionInfo::kCodeOffset));
   __ add(r4, r4, Operand(Code::kHeaderSize - kHeapObjectTag));
   __ str(r4, FieldMemOperand(r1, JSFunction::kCodeEntryOffset));
   __ RecordWriteCodeEntryField(r1, r4, r5);
   __ Jump(r4);
 }
 
-
 void Builtins::Generate_InterpreterExitTrampoline(MacroAssembler* masm) {
   // The return value is in accumulator, which is already in r0.
 
-  // 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.
+  __ ldr(r2, MemOperand(sp, -kPointerSize));
+  __ ldr(r1, MemOperand(fp, 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.
   __ LeaveFrame(StackFrame::JAVA_SCRIPT);
 
+  // Check if the function has been marked for baseline compilation on return.
+  Label not_marked_for_baseline;
+  __ mov(r3, Operand(ExternalReference(
+                 Builtins::kInterpreterMarkBaselineOnReturn, masm->isolate())));
+  __ ldr(r3, MemOperand(r3));
+  __ add(r3, r3, Operand(Code::kHeaderSize - kHeapObjectTag));
+  __ cmp(r2, Operand(r3));
+  __ b(ne, &not_marked_for_baseline);
+
+  {
+    FrameScope frame_scope(masm, StackFrame::INTERNAL);
+    // Push bytecode array and r0 for return.
+    __ push(kInterpreterBytecodeArrayRegister);
+    __ push(r0);
+
+    // Push function as argument and compile for baseline.
+    __ push(r1);
+    __ CallRuntime(Runtime::kCompileBaseline);
+
+    // Restore bytecode array and r0.
+    __ pop(r0);
+    __ pop(kInterpreterBytecodeArrayRegister);
+  }
+
+  __ bind(&not_marked_for_baseline);
+
   // Drop receiver + arguments and return.
   __ ldr(ip, FieldMemOperand(kInterpreterBytecodeArrayRegister,
                              BytecodeArray::kParameterSizeOffset));
   __ add(sp, sp, ip, LeaveCC);
   __ Jump(lr);
 }
 
+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, Register index,
                                          Register limit, Register scratch) {
   Label loop_header, loop_check;
   __ b(al, &loop_check);
   __ bind(&loop_header);
   __ ldr(scratch, MemOperand(index, -kPointerSize, PostIndex));
   __ push(scratch);
   __ bind(&loop_check);
   __ cmp(index, limit);
@@ skipping 1716 matching lines @@
   }
 }
 
 
 #undef __
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_TARGET_ARCH_ARM