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

runtime/vm/intermediate_language_dbc.cc

 // Copyright (c) 2016, 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_DBC.
 #if defined(TARGET_ARCH_DBC)
 
 #include "vm/intermediate_language.h"
 
 #include "vm/cpu.h"
@@ skipping 1167 matching lines @@
   const intptr_t deopt_id = Thread::ToDeoptAfter(GetDeoptId());
   if (compiler->is_optimizing()) {
     compiler->AddDeoptIndexAtCall(deopt_id);
   } else {
     compiler->AddCurrentDescriptor(RawPcDescriptors::kDeopt, deopt_id,
                                    TokenPosition::kNoSource);
   }
   if (HasParallelMove()) {
     compiler->parallel_move_resolver()->EmitNativeCode(parallel_move());
   }
-  if (compiler->is_optimizing()) {
-    // In optimized code, variables at the catch block entry reside at the top
-    // of the allocatable register range.
-    const intptr_t num_non_copied_params =
-        compiler->flow_graph().num_non_copied_params();
-    const intptr_t exception_reg =
-        kNumberOfCpuRegisters -
-        (-exception_var().index() + num_non_copied_params);
-    const intptr_t stacktrace_reg =
-        kNumberOfCpuRegisters -
-        (-stacktrace_var().index() + num_non_copied_params);
-    __ MoveSpecial(exception_reg, Simulator::kExceptionSpecialIndex);
-    __ MoveSpecial(stacktrace_reg, Simulator::kStackTraceSpecialIndex);
+
+  Register context_reg = kNoRegister;
+
+  // 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());
+
+    const LocalVariable& current_context_var =
+        *parsed_function.current_context_var();
+
+    context_reg = compiler->is_optimizing()
+                      ? compiler->CatchEntryRegForVariable(current_context_var)
+                      : LocalVarIndex(0, current_context_var.index());
+
+    Register closure_reg;
+    if (closure_parameter->index() > 0) {
+      __ Move(context_reg, LocalVarIndex(0, closure_parameter->index()));
+      closure_reg = context_reg;
+    } else {
+      closure_reg = LocalVarIndex(0, closure_parameter->index());
+    }
+
+    __ LoadField(context_reg, closure_reg,
+                 Closure::context_offset() / kWordSize);
+  }
+
+  if (exception_var().is_captured()) {
+    ASSERT(stacktrace_var().is_captured());
+    ASSERT(context_reg != kNoRegister);
+    // This will be SP[1] register so we are free to use it as a temporary.
+    const Register temp = compiler->StackSize();
+    __ MoveSpecial(temp, Simulator::kExceptionSpecialIndex);
+    __ StoreField(context_reg,
+                  Context::variable_offset(exception_var().index()) / kWordSize,
+                  temp);
+    __ MoveSpecial(temp, Simulator::kStackTraceSpecialIndex);
+    __ StoreField(
+        context_reg,
+        Context::variable_offset(stacktrace_var().index()) / kWordSize, temp);
   } else {
-    __ MoveSpecial(LocalVarIndex(0, exception_var().index()),
-                   Simulator::kExceptionSpecialIndex);
-    __ MoveSpecial(LocalVarIndex(0, stacktrace_var().index()),
-                   Simulator::kStackTraceSpecialIndex);
+    if (compiler->is_optimizing()) {
+      const intptr_t exception_reg =
+          compiler->CatchEntryRegForVariable(exception_var());
+      const intptr_t stacktrace_reg =
+          compiler->CatchEntryRegForVariable(stacktrace_var());
+      __ MoveSpecial(exception_reg, Simulator::kExceptionSpecialIndex);
+      __ MoveSpecial(stacktrace_reg, Simulator::kStackTraceSpecialIndex);
+    } else {
+      __ MoveSpecial(LocalVarIndex(0, exception_var().index()),
+                     Simulator::kExceptionSpecialIndex);
+      __ MoveSpecial(LocalVarIndex(0, stacktrace_var().index()),
+                     Simulator::kStackTraceSpecialIndex);
+    }
   }
   __ SetFrame(compiler->StackSize());
 }
 
 
 EMIT_NATIVE_CODE(Throw, 0, Location::NoLocation(), LocationSummary::kCall) {
   __ Throw(0);
   compiler->AddCurrentDescriptor(RawPcDescriptors::kOther, deopt_id(),
                                  token_pos());
   compiler->RecordAfterCall(this, FlowGraphCompiler::kNoResult);
@@ skipping 834 matching lines @@
   }
   __ IfULe(length, index);
   compiler->EmitDeopt(deopt_id(), ICData::kDeoptCheckArrayBound,
                       (generalized_ ? ICData::kGeneralized : 0) |
                           (licm_hoisted_ ? ICData::kHoisted : 0));
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_DBC