[kernel] Stream everything. Replace .kernel_function with .kernel_offset

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 97 matching lines @@
 DECLARE_FLAG(bool, huge_method_cutoff_in_code_size);
 DECLARE_FLAG(bool, trace_failed_optimization_attempts);
 DECLARE_FLAG(bool, trace_irregexp);
 
 
 #ifndef DART_PRECOMPILED_RUNTIME
 
 
 bool UseKernelFrontEndFor(ParsedFunction* parsed_function) {
   const Function& function = parsed_function->function();
-  return (function.kernel_function() != NULL) ||
+  return (function.kernel_offset() > 0) ||
          (function.kind() == RawFunction::kNoSuchMethodDispatcher) ||
          (function.kind() == RawFunction::kInvokeFieldDispatcher);
 }
 
 
 void DartCompilationPipeline::ParseFunction(ParsedFunction* parsed_function) {
   if (!UseKernelFrontEndFor(parsed_function)) {
     Parser::ParseFunction(parsed_function);
     parsed_function->AllocateVariables();
   }
 }
 
 
 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,
-                                     /* not building var desc */ NULL,
-                                     /* not inlining */ NULL, osr_id);
+    kernel::FlowGraphBuilder builder(
+        parsed_function->function().kernel_offset(), 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,
                            /* not building var desc */ NULL,
                            /* not inlining */ NULL, osr_id);
 
   return builder.BuildGraph();
 }
@@ skipping 1446 matching lines @@
 
     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,
+          parsed_function->function().kernel_offset(), 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, context_level_array));
     ASSERT(!var_descs.IsNull());
     code.set_var_descriptors(var_descs);
   } else {
@@ skipping 102 matching lines @@
         tds.CopyArgument(0, "field", field.ToCString());
       }
 #endif  // !defined(PRODUCT)
 
       StackZone stack_zone(thread);
       Zone* zone = stack_zone.GetZone();
       ParsedFunction* parsed_function;
 
       // Create a one-time-use function to evaluate the initializer and invoke
       // it immediately.
-      if (field.kernel_field() != NULL) {
+      if (field.kernel_offset() > 0) {
         parsed_function = kernel::ParseStaticFieldInitializer(zone, field);
       } else {
         parsed_function = Parser::ParseStaticFieldInitializer(field);
         parsed_function->AllocateVariables();
       }
 
       // Non-optimized code generator.
       DartCompilationPipeline pipeline;
       CompileParsedFunctionHelper helper(parsed_function, false, kNoOSRDeoptId);
       const Code& code = Code::Handle(helper.Compile(&pipeline));
@@ skipping 587 matching lines @@
 
 
 bool BackgroundCompiler::IsDisabled() {
   UNREACHABLE();
   return true;
 }
 
 #endif  // DART_PRECOMPILED_RUNTIME
 
 }  // namespace dart