From d135e764dbacc23d45a6ba505b02e1d46f05e3fd Mon Sep 17 00:00:00 2001 From: "zhengxing.li" <zhengxing.li@intel.com> Date: Tue, 22 Nov 2016 19:37:50 -0800 Subject: [PATCH] X87: [turbofan] Advance bytecode offset after lazy deopt. port 93c65952009a611b840142e63237c58c7267bfd1 (r40887) original commit message: This changes {FrameState} nodes modeling "after" states to use bytecode offsets pointing to the deoptimizing bytecode. This is in sync with the normal execution, as the bytecode offset is advanced after operations complete in regular bytecode handlers. The change is necessary to ensure lazy deoptimized frames contain an accurate bytecode offset while they are on the stack. Such frames can be inspected by various stack walks. The continuation builtin will advance the bytecode offset upon return. BUG= Review-Url: https://codereview.chromium.org/2520203002 Cr-Commit-Position: refs/heads/master@{#41199} --- src/builtins/x87/builtins-x87.cc | 27 ++++++++++++++++++++++++++- 1 file changed, 26 insertions(+), 1 deletion(-) diff --git a/src/builtins/x87/builtins-x87.cc b/src/builtins/x87/builtins-x87.cc index e766023c67..069ca7702e 100644 --- a/src/builtins/x87/builtins-x87.cc +++ b/src/builtins/x87/builtins-x87.cc @@ -939,7 +939,7 @@ void Builtins::Generate_InterpreterPushArgsAndConstructArray( } } -void Builtins::Generate_InterpreterEnterBytecodeDispatch(MacroAssembler* masm) { +static void Generate_InterpreterEnterBytecode(MacroAssembler* masm) { // Set the return address to the correct point in the interpreter entry // trampoline. Smi* interpreter_entry_return_pc_offset( @@ -981,6 +981,31 @@ void Builtins::Generate_InterpreterEnterBytecodeDispatch(MacroAssembler* masm) { __ jmp(ebx); } +void Builtins::Generate_InterpreterEnterBytecodeAdvance(MacroAssembler* masm) { + // Advance the current bytecode offset stored within the given interpreter + // stack frame. This simulates what all bytecode handlers do upon completion + // of the underlying operation. + __ mov(ebx, Operand(ebp, InterpreterFrameConstants::kBytecodeArrayFromFp)); + __ mov(edx, Operand(ebp, InterpreterFrameConstants::kBytecodeOffsetFromFp)); + __ mov(esi, Operand(ebp, StandardFrameConstants::kContextOffset)); + { + FrameScope scope(masm, StackFrame::INTERNAL); + __ Push(kInterpreterAccumulatorRegister); + __ Push(ebx); // First argument is the bytecode array. + __ Push(edx); // Second argument is the bytecode offset. + __ CallRuntime(Runtime::kInterpreterAdvanceBytecodeOffset); + __ Move(edx, eax); // Result is the new bytecode offset. + __ Pop(kInterpreterAccumulatorRegister); + } + __ mov(Operand(ebp, InterpreterFrameConstants::kBytecodeOffsetFromFp), edx); + + Generate_InterpreterEnterBytecode(masm); +} + +void Builtins::Generate_InterpreterEnterBytecodeDispatch(MacroAssembler* masm) { + Generate_InterpreterEnterBytecode(masm); +} + void Builtins::Generate_CompileLazy(MacroAssembler* masm) { // ----------- S t a t e ------------- // -- eax : argument count (preserved for callee)