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

runtime/vm/compiler.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/compiler.h"
 
 #include "vm/assembler.h"
 
 #include "vm/ast_printer.h"
 #include "vm/block_scheduler.h"
@@ skipping 119 matching lines @@
 
 
 FlowGraph* DartCompilationPipeline::BuildFlowGraph(
     Zone* zone,
     ParsedFunction* parsed_function,
     const ZoneGrowableArray<const ICData*>& ic_data_array,
     intptr_t osr_id) {
   if (UseKernelFrontEndFor(parsed_function)) {
     kernel::TreeNode* node = static_cast<kernel::TreeNode*>(
         parsed_function->function().kernel_function());
-    kernel::FlowGraphBuilder builder(node, parsed_function, ic_data_array, NULL,
-                                     osr_id);
+    kernel::FlowGraphBuilder builder(node, parsed_function, ic_data_array,
+                                     /* not building var desc */ NULL,
+                                     /* not inlining */ NULL, osr_id);
     FlowGraph* graph = builder.BuildGraph();
     ASSERT(graph != NULL);
     return graph;
   }
   FlowGraphBuilder builder(*parsed_function, ic_data_array,
-                           NULL,  // NULL = not inlining.
-                           osr_id);
+                           /* not building var desc */ NULL,
+                           /* not inlining */ NULL, osr_id);
 
   return builder.BuildGraph();
 }
 
 
 void DartCompilationPipeline::FinalizeCompilation(FlowGraph* flow_graph) {}
 
 
 void IrregexpCompilationPipeline::ParseFunction(
     ParsedFunction* parsed_function) {
@@ skipping 10 matching lines @@
   // Compile to the dart IR.
   RegExpEngine::CompilationResult result = RegExpEngine::CompileIR(
       parsed_function->regexp_compile_data(), parsed_function, ic_data_array);
   backtrack_goto_ = result.backtrack_goto;
 
   // Allocate variables now that we know the number of locals.
   parsed_function->AllocateIrregexpVariables(result.num_stack_locals);
 
   // Build the flow graph.
   FlowGraphBuilder builder(*parsed_function, ic_data_array,
-                           NULL,  // NULL = not inlining.
-                           osr_id);
+                           /* not building var desc */ NULL,
+                           /* not inlining */ NULL, osr_id);
 
   return new (zone)
       FlowGraph(*parsed_function, result.graph_entry, result.num_blocks);
 }
 
 
 void IrregexpCompilationPipeline::FinalizeCompilation(FlowGraph* flow_graph) {
   backtrack_goto_->ComputeOffsetTable();
 }
 
@@ skipping 1389 matching lines @@
 void Compiler::ComputeLocalVarDescriptors(const Code& code) {
   ASSERT(!code.is_optimized());
   const Function& function = Function::Handle(code.function());
   ParsedFunction* parsed_function = new ParsedFunction(
       Thread::Current(), Function::ZoneHandle(function.raw()));
   ASSERT(code.var_descriptors() == Object::null());
   // IsIrregexpFunction have eager var descriptors generation.
   ASSERT(!function.IsIrregexpFunction());
   // In background compilation, parser can produce 'errors": bailouts
   // if state changed while compiling in background.
+  const intptr_t prev_deopt_id = Thread::Current()->deopt_id();
+  Thread::Current()->set_deopt_id(0);
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
-    if (function.kernel_function() == NULL) {
+    ZoneGrowableArray<const ICData*>* ic_data_array =
+        new ZoneGrowableArray<const ICData*>();
+    ZoneGrowableArray<intptr_t>* context_level_array =
+        new ZoneGrowableArray<intptr_t>();
+
+    if (!UseKernelFrontEndFor(parsed_function)) {
       Parser::ParseFunction(parsed_function);
       parsed_function->AllocateVariables();
+      FlowGraphBuilder builder(
+          *parsed_function, *ic_data_array, context_level_array,
+          /* not inlining */ NULL, Compiler::kNoOSRDeoptId);
+      builder.BuildGraph();
     } else {
       parsed_function->EnsureKernelScopes();
+      kernel::TreeNode* node = static_cast<kernel::TreeNode*>(
+          parsed_function->function().kernel_function());
+      kernel::FlowGraphBuilder builder(
+          node, parsed_function, *ic_data_array, context_level_array,
+          /* not inlining */ NULL, Compiler::kNoOSRDeoptId);
+      builder.BuildGraph();
     }
+
     const LocalVarDescriptors& var_descs = LocalVarDescriptors::Handle(
-        parsed_function->node_sequence()->scope()->GetVarDescriptors(function));
+        parsed_function->node_sequence()->scope()->GetVarDescriptors(
+            function, context_level_array));
     ASSERT(!var_descs.IsNull());
     code.set_var_descriptors(var_descs);
   } else {
     // Only possible with background compilation.
     ASSERT(Compiler::IsBackgroundCompilation());
   }
+  Thread::Current()->set_deopt_id(prev_deopt_id);
 }
 
 
 RawError* Compiler::CompileAllFunctions(const Class& cls) {
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
   Object& result = Object::Handle(zone);
   Array& functions = Array::Handle(zone, cls.functions());
   Function& func = Function::Handle(zone);
   // Class dynamic lives in the vm isolate. Its array fields cannot be set to
@@ skipping 696 matching lines @@
 
 
 bool BackgroundCompiler::IsDisabled() {
   UNREACHABLE();
   return true;
 }
 
 #endif  // DART_PRECOMPILED_RUNTIME
 
 }  // namespace dart