VM: [Kernel] Implement CatchBlockEntryInstr::should_restore_closure_context on all platforms.

runtime/vm/intermediate_language_arm64.cc

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/globals.h"  // Needed here to get TARGET_ARCH_ARM64.
 #if defined(TARGET_ARCH_ARM64)
 
 #include "vm/intermediate_language.h"
 
 #include "vm/compiler.h"
@@ skipping 2599 matching lines @@
     compiler->parallel_move_resolver()->EmitNativeCode(parallel_move());
   }
 
   // Restore SP from FP as we are coming from a throw and the code for
   // popping arguments has not been run.
   const intptr_t fp_sp_dist =
       (kFirstLocalSlotFromFp + 1 - compiler->StackSize()) * kWordSize;
   ASSERT(fp_sp_dist <= 0);
   __ AddImmediate(SP, FP, fp_sp_dist);
 
-  // Restore stack and initialize the two exception variables:
-  // exception and stack trace variables.
-  __ StoreToOffset(kExceptionObjectReg, FP,
-                   exception_var().index() * kWordSize);
-  __ StoreToOffset(kStackTraceObjectReg, FP,
-                   stacktrace_var().index() * kWordSize);
+  // Auxiliary variables introduced by the try catch can be captured if we are
+  // inside a function with yield/resume points. In this case we first need
+  // to restore the context to match the context at entry into the closure.
+  if (should_restore_closure_context()) {
+    const ParsedFunction& parsed_function = compiler->parsed_function();
+    ASSERT(parsed_function.function().IsClosureFunction());
+    LocalScope* scope = parsed_function.node_sequence()->scope();
+
+    LocalVariable* closure_parameter = scope->VariableAt(0);
+    ASSERT(!closure_parameter->is_captured());
+    __ ldr(CTX, Address(FP, closure_parameter->index() * kWordSize));

[zra, 2017/04/05 16:10:45]

Is the closure_parameter index known to be something small? If it might ever not
be, then this load should use LoadFromOffset().

Since the stores below use StoreToOffset, I'm thinking this load and the next
should just use LoadFromOffset to be consistent.

Looks like arm should be changed as well.

[Vyacheslav Egorov (Google), 2017/04/05 16:23:30]

Done (both arm and arm64)

+    __ ldr(CTX, FieldAddress(CTX, Closure::context_offset()));
+
+    const intptr_t context_index =
+        parsed_function.current_context_var()->index();
+    __ StoreToOffset(CTX, FP, context_index * kWordSize);
+  }
+
+  // Initialize exception and stack trace variables.
+  if (exception_var().is_captured()) {
+    ASSERT(stacktrace_var().is_captured());
+    __ StoreIntoObjectOffset(CTX,
+                             Context::variable_offset(exception_var().index()),
+                             kExceptionObjectReg);
+    __ StoreIntoObjectOffset(CTX,
+                             Context::variable_offset(stacktrace_var().index()),
+                             kStackTraceObjectReg);
+  } else {
+    // Restore stack and initialize the two exception variables:
+    // exception and stack trace variables.
+    __ StoreToOffset(kExceptionObjectReg, FP,
+                     exception_var().index() * kWordSize);
+    __ StoreToOffset(kStackTraceObjectReg, FP,
+                     stacktrace_var().index() * kWordSize);
+  }
 }
 
 
 LocationSummary* CheckStackOverflowInstr::MakeLocationSummary(Zone* zone,
                                                               bool opt) const {
   const intptr_t kNumInputs = 0;
   const intptr_t kNumTemps = 1;
   LocationSummary* summary = new (zone) LocationSummary(
       zone, kNumInputs, kNumTemps, LocationSummary::kCallOnSlowPath);
   summary->set_temp(0, Location::RequiresRegister());
@@ skipping 3414 matching lines @@
   compiler->GenerateRuntimeCall(TokenPosition::kNoSource, deopt_id(),
                                 kGrowRegExpStackRuntimeEntry, 1, locs());
   __ Drop(1);
   __ Pop(result);
 }
 
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_ARM64