Remember deopt-id -> context-level mappings in var descriptors.

runtime/vm/kernel_to_il.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 <set>
 
 #include "vm/kernel_to_il.h"
 
 #include "vm/compiler.h"
 #include "vm/intermediate_language.h"
@@ skipping 1995 matching lines @@
     H.ReportError(Error::Cast(result), "error evaluating constant constructor");
   }
   return result;
 }
 
 
 FlowGraphBuilder::FlowGraphBuilder(
     TreeNode* node,
     ParsedFunction* parsed_function,
     const ZoneGrowableArray<const ICData*>& ic_data_array,
+    ZoneGrowableArray<intptr_t>* context_level_array,
     InlineExitCollector* exit_collector,
     intptr_t osr_id,
     intptr_t first_block_id)
     : translation_helper_(Thread::Current()),
       thread_(translation_helper_.thread()),
       zone_(translation_helper_.zone()),
       node_(node),
       parsed_function_(parsed_function),
       osr_id_(osr_id),
       ic_data_array_(ic_data_array),
+      context_level_array_(context_level_array),
       exit_collector_(exit_collector),
       next_block_id_(first_block_id),
       next_function_id_(0),
       context_depth_(0),
       loop_depth_(0),
       try_depth_(0),
       catch_depth_(0),
       for_in_depth_(0),
       stack_(NULL),
       pending_argument_count_(0),
@@ skipping 375 matching lines @@
                                            bool needs_stacktrace) {
   ASSERT(CurrentException()->is_captured() ==
          CurrentStackTrace()->is_captured());
   const bool should_restore_closure_context =
       CurrentException()->is_captured() || CurrentCatchContext()->is_captured();
   CatchBlockEntryInstr* entry = new (Z) CatchBlockEntryInstr(
       TokenPosition::kNoSource,  // Token position of catch block.
       false,                     // Not an artifact of compilation.
       AllocateBlockId(), CurrentTryIndex(), graph_entry_, handler_types,
       handler_index, *CurrentException(), *CurrentStackTrace(),
-      needs_stacktrace, H.thread()->GetNextDeoptId(),
-      should_restore_closure_context);
+      needs_stacktrace, GetNextDeoptId(), should_restore_closure_context);
   graph_entry_->AddCatchEntry(entry);
   Fragment instructions(entry);
 
   // :saved_try_context_var can be captured in the context of
   // of the closure, in this case CatchBlockEntryInstr restores
   // :current_context_var to point to closure context in the
   // same way as normal function prologue does.
   // Update current context depth to reflect that.
   const intptr_t saved_context_depth = context_depth_;
   ASSERT(!CurrentCatchContext()->is_captured() ||
@@ skipping 395 matching lines @@
 
 
 Fragment FlowGraphBuilder::StoreInstanceFieldGuarded(
     const dart::Field& field,
     bool is_initialization_store) {
   Fragment instructions;
   const dart::Field& field_clone = MayCloneField(Z, field);
   if (I->use_field_guards()) {
     LocalVariable* store_expression = MakeTemporary();
     instructions += LoadLocal(store_expression);
-    instructions += GuardFieldClass(field_clone, H.thread()->GetNextDeoptId());
+    instructions += GuardFieldClass(field_clone, GetNextDeoptId());
     instructions += LoadLocal(store_expression);
-    instructions += GuardFieldLength(field_clone, H.thread()->GetNextDeoptId());
+    instructions += GuardFieldLength(field_clone, GetNextDeoptId());
   }
   instructions += StoreInstanceField(field_clone, is_initialization_store);
   return instructions;
 }
 
 
 Fragment FlowGraphBuilder::StoreInstanceField(
     TokenPosition position,
     intptr_t offset,
     StoreBarrierType emit_store_barrier) {
@@ skipping 653 matching lines @@
         scope->LookupVariable(Symbols::AsyncStackTraceVar(), false);
     ASSERT((async_stack_trace_var != NULL) &&
            async_stack_trace_var->is_captured());
     instructions += LoadLocal(async_stack_trace_var);
     instructions += PushArgument();
 
     // Call _asyncSetThreadStackTrace
     instructions += StaticCall(TokenPosition::kNoSource, target, 1);
     instructions += Drop();
 
+    // TODO(29737): This sequence should be generated in order.
     body = instructions + body;
     context_depth_ = current_context_depth;
   }
 
   if (NeedsDebugStepCheck(dart_function, function->position())) {
+    const intptr_t current_context_depth = context_depth_;
+    context_depth_ = 0;
+
     // If a switch was added above: Start the switch by injecting a debuggable
     // safepoint so stepping over an await works.
     // If not, still start the body with a debuggable safepoint to ensure
     // breaking on a method always happens, even if there are no
     // assignments/calls/runtimecalls in the first basic block.
     // Place this check at the last parameter to ensure parameters
     // are in scope in the debugger at method entry.
     const int num_params = dart_function.NumParameters();
     TokenPosition check_pos = TokenPosition::kNoSource;
     if (num_params > 0) {
       LocalScope* scope = parsed_function_->node_sequence()->scope();
       const LocalVariable& parameter = *scope->VariableAt(num_params - 1);
       check_pos = parameter.token_pos();
     }
     if (!check_pos.IsDebugPause()) {
       // No parameters or synthetic parameters.
       check_pos = function->position();
       ASSERT(check_pos.IsDebugPause());
     }
+
+    // TODO(29737): This sequence should be generated in order.
     body = DebugStepCheck(check_pos) + body;
+    context_depth_ = current_context_depth;
   }
 
   normal_entry->LinkTo(body.entry);
 
   // When compiling for OSR, use a depth first search to prune instructions
   // unreachable from the OSR entry. Catch entries are always considered
   // reachable, even if they become unreachable after OSR.
   if (osr_id_ != Compiler::kNoOSRDeoptId) {
     BitVector* block_marks = new (Z) BitVector(Z, next_block_id_);
     bool found = graph_entry_->PruneUnreachable(graph_entry_, NULL, osr_id_,
@@ skipping 326 matching lines @@
   Definition* definition = value->definition();
   if (definition->IsConstant() || definition->IsLoadStaticField()) return true;
   if (definition->IsAllocateObject()) {
     return !definition->AsAllocateObject()->closure_function().IsNull();
   }
   return definition->IsLoadLocal() &&
          !definition->AsLoadLocal()->local().IsInternal();
 }
 
 Fragment FlowGraphBuilder::DebugStepCheck(TokenPosition position) {
-  return Fragment(
-      new (Z) DebugStepCheckInstr(position, RawPcDescriptors::kRuntimeCall));
+  return Fragment(new (Z) DebugStepCheckInstr(
+      position, RawPcDescriptors::kRuntimeCall, GetNextDeoptId()));
 }
 
 
 Fragment FlowGraphBuilder::EvaluateAssertion() {
   const dart::Class& klass = dart::Class::ZoneHandle(
       Z, dart::Library::LookupCoreClass(Symbols::AssertionError()));
   ASSERT(!klass.IsNull());
   const Function& target =
       Function::ZoneHandle(Z, klass.LookupStaticFunctionAllowPrivate(
                                   H.DartSymbol("_evaluateAssertion")));
@@ skipping 62 matching lines @@
 
   if (!dst_type.IsInstantiated(kFunctions)) {
     instructions += LoadFunctionTypeArguments();
   } else {
     instructions += NullConstant();
   }
   Value* function_type_args = Pop();
 
   AssertAssignableInstr* instr = new (Z) AssertAssignableInstr(
       TokenPosition::kNoSource, value, instantiator_type_args,
-      function_type_args, dst_type, dst_name, H.thread()->GetNextDeoptId());
+      function_type_args, dst_type, dst_name, GetNextDeoptId());
   Push(instr);
 
   instructions += Fragment(instr);
 
   return instructions;
 }
 
 
 FlowGraph* FlowGraphBuilder::BuildGraphOfMethodExtractor(
     const Function& method) {
@@ skipping 2859 matching lines @@
     thread->clear_sticky_error();
     return error.raw();
   }
 }
 
 
 }  // namespace kernel
 }  // namespace dart
 
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)