Set the current context to the function's context when entering to LAP.

src/x64/code-stubs-x64.cc

 // Copyright 2013 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/api-arguments.h"
 #include "src/bootstrapper.h"
 #include "src/code-stubs.h"
 #include "src/codegen.h"
@@ skipping 2718 matching lines @@
   STATIC_ASSERT(FCA::kHolderIndex == 0);
   STATIC_ASSERT(FCA::kNewTargetIndex == 7);
   STATIC_ASSERT(FCA::kArgsLength == 8);
 
   __ PopReturnAddressTo(return_address);
 
   // new target
   __ PushRoot(Heap::kUndefinedValueRootIndex);
 
   // context save
   __ Push(context);

[Toon Verwaest, 2017/06/19 08:45:05]

This is now the context after loading the LAP context though, so we won't
restore correctly after the call returns below (&context_restore_operand).

[Yuki, 2017/06/20 14:35:13]

Ah, I see.  I confirmed that it worked locally.
Let me revise the CL tomorrow.

 
   // callee
   __ Push(callee);
 
   // call data
   __ Push(call_data);
 
   // return value
   __ PushRoot(Heap::kUndefinedValueRootIndex);
   // return value default
   __ PushRoot(Heap::kUndefinedValueRootIndex);
   // isolate
   Register scratch = call_data;
   __ Move(scratch, ExternalReference::isolate_address(masm->isolate()));
   __ Push(scratch);
   // holder
   __ Push(holder);
 
+#if 0  // TEMPORARILY COMMENTED OUT: MOVED TO
+       // PropertyHandlerCompiler::GenerateApiAccessorCall
+  if (this->is_lazy()) {
+    // load context from holder
+    __ movp(scratch, FieldOperand(holder, HeapObject::kMapOffset));
+    __ GetMapConstructor(scratch, scratch, context);
+    __ movp(context, FieldOperand(scratch, JSFunction::kContextOffset));
+  } else {
+    // load context from callee
+    __ movp(context, FieldOperand(callee, JSFunction::kContextOffset));
+  }
+#endif
+
   __ movp(scratch, rsp);
   // Push return address back on stack.
   __ PushReturnAddressFrom(return_address);
 
-  if (!this->is_lazy()) {
-    // load context from callee
-    __ movp(context, FieldOperand(callee, JSFunction::kContextOffset));
-  }
-
   // Allocate the v8::Arguments structure in the arguments' space since
   // it's not controlled by GC.
   const int kApiStackSpace = 3;
 
   PrepareCallApiFunction(masm, kApiStackSpace);
 
   // FunctionCallbackInfo::implicit_args_.
   int argc = this->argc();
   __ movp(StackSpaceOperand(0), scratch);
   __ addp(scratch, Immediate((argc + FCA::kArgsLength - 1) * kPointerSize));
@@ skipping 117 matching lines @@
                            kStackUnwindSpace, nullptr, return_value_operand,
                            NULL);
 }
 
 #undef __
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_TARGET_ARCH_X64