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

runtime/vm/flow_graph_builder.cc

 // Copyright (c) 2012, 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/flow_graph_builder.h"
 
 #include "lib/invocation_mirror.h"
 #include "vm/ast_printer.h"
 #include "vm/bit_vector.h"
 #include "vm/compiler.h"
@@ skipping 147 matching lines @@
 }
 
 
 void NestedStatement::AdjustContextLevel(intptr_t context_level) {
   // There must be a NestedContextAdjustment on the nesting stack.
   ASSERT(outer() != NULL);
   outer()->AdjustContextLevel(context_level);
 }
 
 
+intptr_t FlowGraphBuilder::GetNextDeoptId() const {
+  intptr_t deopt_id = thread()->GetNextDeoptId();
+  if (context_level_array_ != NULL) {
+    intptr_t level = context_level();
+    context_level_array_->Add(deopt_id);
+    context_level_array_->Add(level);
+  }
+  return deopt_id;
+}
+
+
 intptr_t FlowGraphBuilder::context_level() const {
   return (nesting_stack() == NULL) ? 0 : nesting_stack()->ContextLevel();
 }
 
 
 JoinEntryInstr* NestedStatement::BreakTargetFor(SourceLabel* label) {
   if (label != label_) return NULL;
   if (break_target_ == NULL) {
     break_target_ = new (owner()->zone()) JoinEntryInstr(
         owner()->AllocateBlockId(), try_index(), owner()->GetNextDeoptId());
@@ skipping 116 matching lines @@
     }
     return case_targets_[i];
   }
   return NULL;
 }
 
 
 FlowGraphBuilder::FlowGraphBuilder(
     const ParsedFunction& parsed_function,
     const ZoneGrowableArray<const ICData*>& ic_data_array,
+    ZoneGrowableArray<intptr_t>* context_level_array,
     InlineExitCollector* exit_collector,
     intptr_t osr_id)
     : parsed_function_(parsed_function),
       ic_data_array_(ic_data_array),
+      context_level_array_(context_level_array),
       num_copied_params_(parsed_function.num_copied_params()),
       // All parameters are copied if any parameter is.
       num_non_copied_params_(
           (num_copied_params_ == 0)
               ? parsed_function.function().num_fixed_parameters()
               : 0),
       num_stack_locals_(parsed_function.num_stack_locals()),
       exit_collector_(exit_collector),
       last_used_block_id_(0),  // 0 is used for the graph entry.
       try_index_(CatchClauseNode::kInvalidTryIndex),
@@ skipping 779 matching lines @@
 
   // Call to stub that checks whether the debugger is in single
   // step mode. This call must happen before the contexts are
   // unchained so that captured variables can be inspected.
   // No debugger check is done in native functions or for return
   // statements for which there is no associated source position.
   const Function& function = owner()->function();
   if (FLAG_support_debugger && node->token_pos().IsDebugPause() &&
       !function.is_native()) {
     AddInstruction(new (Z) DebugStepCheckInstr(node->token_pos(),
-                                               RawPcDescriptors::kRuntimeCall));
+                                               RawPcDescriptors::kRuntimeCall,
+                                               owner()->GetNextDeoptId()));
   }
 
   NestedContextAdjustment context_adjustment(owner(), owner()->context_level());
 
   if (node->inlined_finally_list_length() > 0) {
     LocalVariable* temp = owner()->parsed_function().finally_return_temp_var();
     ASSERT(temp != NULL);
     Do(BuildStoreLocal(*temp, return_value, node->token_pos()));
     for (intptr_t i = 0; i < node->inlined_finally_list_length(); i++) {
       InlineBailout("EffectGraphVisitor::VisitReturnNode (exception)");
@@ skipping 371 matching lines @@
     instantiator_type_arguments = BuildNullValue(token_pos);
   } else {
     instantiator_type_arguments = BuildInstantiatorTypeArguments(token_pos);
   }
   if (dst_type.IsInstantiated(kFunctions)) {
     function_type_arguments = BuildNullValue(token_pos);
   } else {
     function_type_arguments = BuildFunctionTypeArguments(token_pos);
   }
 
-  const intptr_t deopt_id = Thread::Current()->GetNextDeoptId();
+  const intptr_t deopt_id = owner()->GetNextDeoptId();
   return new (Z) AssertAssignableInstr(
       token_pos, value, instantiator_type_arguments, function_type_arguments,
       dst_type, dst_name, deopt_id);
 }
 
 
 // Used for type casts and to test assignments.
 Value* EffectGraphVisitor::BuildAssignableValue(TokenPosition token_pos,
                                                 Value* value,
                                                 const AbstractType& dst_type,
@@ skipping 595 matching lines @@
       for_test.IfFalseGoto(nested_loop.break_target());
       exit_ = nested_loop.break_target();
     }
   }
 }
 
 
 void EffectGraphVisitor::VisitJumpNode(JumpNode* node) {
   if (FLAG_support_debugger && owner()->function().is_debuggable()) {
     AddInstruction(new (Z) DebugStepCheckInstr(node->token_pos(),
-                                               RawPcDescriptors::kRuntimeCall));
+                                               RawPcDescriptors::kRuntimeCall,
+                                               owner()->GetNextDeoptId()));
   }
 
   NestedContextAdjustment context_adjustment(owner(), owner()->context_level());
 
   for (intptr_t i = 0; i < node->inlined_finally_list_length(); i++) {
     EffectGraphVisitor for_effect(owner());
     node->InlinedFinallyNodeAt(i)->Visit(&for_effect);
     Append(for_effect);
     if (!is_open()) return;
   }
@@ skipping 1330 matching lines @@
   if (FLAG_support_debugger) {
     AstNode* rhs = node->value();
     if (rhs->IsAssignableNode()) {
       rhs = rhs->AsAssignableNode()->expr();
     }
     if ((rhs->IsLiteralNode() || rhs->IsLoadStaticFieldNode() ||
          (rhs->IsLoadLocalNode() &&
           !rhs->AsLoadLocalNode()->local().IsInternal()) ||
          rhs->IsClosureNode()) &&
         !node->local().IsInternal() && node->token_pos().IsDebugPause()) {
-      AddInstruction(new (Z) DebugStepCheckInstr(
-          node->token_pos(), RawPcDescriptors::kRuntimeCall));
+      AddInstruction(new (Z) DebugStepCheckInstr(node->token_pos(),
+                                                 RawPcDescriptors::kRuntimeCall,
+                                                 owner()->GetNextDeoptId()));
     }
   }
 
   ValueGraphVisitor for_value(owner());
   node->value()->Visit(&for_value);
   Append(for_value);
   Value* store_value = for_value.value();
   if (Isolate::Current()->type_checks()) {
     store_value =
         BuildAssignableValue(node->value()->token_pos(), store_value,
@@ skipping 81 matching lines @@
     // If the right hand side is an expression that does not contain
     // a safe point for the debugger to stop, add an explicit stub
     // call.
     AstNode* rhs = node->value();
     if (rhs->IsAssignableNode()) {
       rhs = rhs->AsAssignableNode()->expr();
     }
     if ((rhs->IsLiteralNode() || rhs->IsLoadLocalNode() ||
          rhs->IsLoadStaticFieldNode() || rhs->IsClosureNode()) &&
         node->token_pos().IsDebugPause()) {
-      AddInstruction(new (Z) DebugStepCheckInstr(
-          node->token_pos(), RawPcDescriptors::kRuntimeCall));
+      AddInstruction(new (Z) DebugStepCheckInstr(node->token_pos(),
+                                                 RawPcDescriptors::kRuntimeCall,
+                                                 owner()->GetNextDeoptId()));
     }
   }
 
   ValueGraphVisitor for_value(owner());
   node->value()->Visit(&for_value);
   Append(for_value);
   Value* store_value = NULL;
   if (result_is_needed) {
     store_value = Bind(BuildStoreExprTemp(for_value.value(), token_pos));
   } else {
@@ skipping 339 matching lines @@
     if (num_params > 0) {
       const LocalVariable& parameter = *scope->VariableAt(num_params - 1);
       check_pos = parameter.token_pos();
     }
 
     if (check_pos.IsNoSource() || (check_pos.Pos() < node->token_pos().Pos())) {
       // No parameters or synthetic parameters, e.g. 'this'.
       check_pos = node->token_pos();
       ASSERT(check_pos.IsDebugPause());
     }
-    AddInstruction(
-        new (Z) DebugStepCheckInstr(check_pos, RawPcDescriptors::kRuntimeCall));
+    AddInstruction(new (Z) DebugStepCheckInstr(
+        check_pos, RawPcDescriptors::kRuntimeCall, owner()->GetNextDeoptId()));
   }
 
   // This check may be deleted if the generated code is leaf.
   // Native functions don't need a stack check at entry.
   if (is_top_level_sequence && !function.is_native()) {
     // Always allocate CheckOverflowInstr so that deopt-ids match regardless
     // if we inline or not.
     if (!function.IsImplicitGetterFunction() &&
         !function.IsImplicitSetterFunction()) {
       CheckStackOverflowInstr* check = new (Z) CheckStackOverflowInstr(
@@ skipping 215 matching lines @@
   // and ':stack_trace_var' can never be captured variables.
   ASSERT(!catch_block->context_var().is_captured());
   ASSERT(!catch_block->exception_var().is_captured());
   ASSERT(!catch_block->stacktrace_var().is_captured());
 
   CatchBlockEntryInstr* catch_entry = new (Z) CatchBlockEntryInstr(
       catch_block->token_pos(), (node->token_pos() == TokenPosition::kNoSource),
       owner()->AllocateBlockId(), catch_handler_index, owner()->graph_entry(),
       catch_block->handler_types(), try_handler_index,
       catch_block->exception_var(), catch_block->stacktrace_var(),
-      catch_block->needs_stacktrace(), Thread::Current()->GetNextDeoptId());
+      catch_block->needs_stacktrace(), owner()->GetNextDeoptId());
   owner()->AddCatchEntry(catch_entry);
   AppendFragment(catch_entry, for_catch);
 
   if (for_catch.is_open()) {
     JoinEntryInstr* join = new (Z)
         JoinEntryInstr(owner()->AllocateBlockId(), original_handler_index,
                        owner()->GetNextDeoptId());
     for_catch.Goto(join);
     if (is_open()) Goto(join);
     exit_ = join;
@@ skipping 25 matching lines @@
     ASSERT(!for_finally.is_open());
 
     const Array& types = Array::ZoneHandle(Z, Array::New(1, Heap::kOld));
     types.SetAt(0, Object::dynamic_type());
     CatchBlockEntryInstr* finally_entry = new (Z) CatchBlockEntryInstr(
         finally_block->token_pos(),
         true,  // this is not a catch block from user code.
         owner()->AllocateBlockId(), original_handler_index,
         owner()->graph_entry(), types, catch_handler_index,
         catch_block->exception_var(), catch_block->stacktrace_var(),
-        catch_block->needs_stacktrace(), Thread::Current()->GetNextDeoptId());
+        catch_block->needs_stacktrace(), owner()->GetNextDeoptId());
     owner()->AddCatchEntry(finally_entry);
     AppendFragment(finally_entry, for_finally);
   }
 
   // Generate code for the finally block if one exists.
   if ((finally_block != NULL) && is_open()) {
     EffectGraphVisitor for_finally_block(owner());
     finally_block->Visit(&for_finally_block);
     Append(for_finally_block);
   }
@@ skipping 108 matching lines @@
                                  owner()->GetNextDeoptId());
 }
 
 
 void EffectGraphVisitor::BuildThrowNode(ThrowNode* node) {
   if (FLAG_support_debugger) {
     if (node->exception()->IsLiteralNode() ||
         node->exception()->IsLoadLocalNode() ||
         node->exception()->IsLoadStaticFieldNode() ||
         node->exception()->IsClosureNode()) {
-      AddInstruction(new (Z) DebugStepCheckInstr(
-          node->token_pos(), RawPcDescriptors::kRuntimeCall));
+      AddInstruction(new (Z) DebugStepCheckInstr(node->token_pos(),
+                                                 RawPcDescriptors::kRuntimeCall,
+                                                 owner()->GetNextDeoptId()));
     }
   }
   ValueGraphVisitor for_exception(owner());
   node->exception()->Visit(&for_exception);
   Append(for_exception);
   PushArgument(for_exception.value());
   Instruction* instr = NULL;
   if (node->stacktrace() == NULL) {
     instr = new (Z) ThrowInstr(node->token_pos(), owner()->GetNextDeoptId());
   } else {
@@ skipping 138 matching lines @@
   ASSERT(type.HasResolvedTypeClass());
   const Class& type_class = Class::Handle(type.type_class());
   // Bail if the type has any type parameters.
   if (type_class.IsGeneric()) return false;
 
   // Finally a simple class for instance of checking.
   return true;
 }
 
 }  // namespace dart