VM support for running Kernel binaries.

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"
 #include "vm/branch_optimizer.h"
 #include "vm/cha.h"
 #include "vm/code_generator.h"
 #include "vm/code_patcher.h"
 #include "vm/constant_propagator.h"
 #include "vm/dart_entry.h"
 #include "vm/debugger.h"
 #include "vm/deopt_instructions.h"
+#include "vm/dil.h"
+#include "vm/dil_to_il.h"
 #include "vm/disassembler.h"
 #include "vm/exceptions.h"
 #include "vm/flags.h"
 #include "vm/flow_graph.h"
 #include "vm/flow_graph_allocator.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
 #include "vm/flow_graph_inliner.h"
 #include "vm/flow_graph_range_analysis.h"
 #include "vm/flow_graph_type_propagator.h"
@@ skipping 48 matching lines @@
 DEFINE_FLAG(bool, verify_compiler, false,
     "Enable compiler verification assertions");
 
 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
 
-void DartCompilationPipeline::ParseFunction(ParsedFunction* parsed_function) {
-  Parser::ParseFunction(parsed_function);
-  parsed_function->AllocateVariables();
+
+bool UseDilFrontEndFor(ParsedFunction* parsed_function) {
+  const Function& function = parsed_function->function();
+  return (function.dil_function() != kNoDilNode) ||
+         (function.kind() == RawFunction::kNoSuchMethodDispatcher) ||
+         (function.kind() == RawFunction::kInvokeFieldDispatcher);
 }
 
 
+void DartCompilationPipeline::ParseFunction(ParsedFunction* parsed_function) {
+  if (!UseDilFrontEndFor(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) {
-  // Build the flow graph.
+  if (UseDilFrontEndFor(parsed_function)) {
+    dil::TreeNode* node = reinterpret_cast<dil::TreeNode*>(
+        parsed_function->function().dil_function());
+    dil::FlowGraphBuilder builder(
+        node, parsed_function, ic_data_array, 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);
 
   return builder.BuildGraph();
 }
 
 
 void DartCompilationPipeline::FinalizeCompilation(FlowGraph* flow_graph) { }
@@ skipping 912 matching lines @@
         }
 
         if (flow_graph->Canonicalize()) {
           flow_graph->Canonicalize();
         }
 
         // Attempt to sink allocations of temporary non-escaping objects to
         // the deoptimization path.
         AllocationSinking* sinking = NULL;
         if (FLAG_allocation_sinking &&
-            (flow_graph->graph_entry()->SuccessorCount()  == 1)) {
+            (flow_graph->graph_entry()->SuccessorCount() == 1)) {
           NOT_IN_PRODUCT(TimelineDurationScope tds2(
               thread(), compiler_timeline, "AllocationSinking::Optimize"));
           // TODO(fschneider): Support allocation sinking with try-catch.
           sinking = new AllocationSinking(flow_graph);
           sinking->Optimize();
         }
         DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
         DeadCodeElimination::EliminateDeadPhis(flow_graph);
         DEBUG_ASSERT(flow_graph->VerifyUseLists());
@@ skipping 655 matching lines @@
       NOT_IN_PRODUCT(
         VMTagScope tagScope(thread, VMTag::kCompileUnoptimizedTagId);
         TimelineDurationScope tds(thread, Timeline::GetCompilerStream(),
                                   "CompileStaticInitializer");
         if (tds.enabled()) {
           tds.SetNumArguments(1);
           tds.CopyArgument(0, "field", field.ToCString());
         }
       )
 
-      StackZone zone(thread);
-      ParsedFunction* parsed_function =
-          Parser::ParseStaticFieldInitializer(field);
+      StackZone _(thread);

[rmacnak, 2016/10/13 00:56:39]

StackZone stack_zone(thread);
Zone* zone = stack_zone.GetZone();

[Vyacheslav Egorov (Google), 2016/10/13 14:37:57]

Done.

+      Zone* zone = thread->zone();
+      ParsedFunction* parsed_function;
 
-      parsed_function->AllocateVariables();
+      // Create a one-time-use function to evaluate the initializer and invoke
+      // it immediately.
+      if (field.dil_field() != kNoDilNode) {
+        // kImplicitStaticFinalGetter is used for both implicit static getters
+        // and static initializers.  The Kernel graph builder will tell the
+        // difference by pattern matching on the name.
+        const String& name = String::Handle(zone,
+            Symbols::FromConcat(thread,
+                Symbols::InitPrefix(), String::Handle(zone, field.name())));
+        const Script& script = Script::Handle(zone, field.Script());
+        Object& owner = Object::Handle(zone, field.Owner());
+        owner = PatchClass::New(Class::Cast(owner), script);
+        const Function& function = Function::ZoneHandle(zone,
+            Function::New(name,
+                          RawFunction::kImplicitStaticFinalGetter,
+                          true,  // is_static
+                          false,  // is_const
+                          false,  // is_abstract
+                          false,  // is_external
+                          false,  // is_native
+                          owner,
+                          TokenPosition::kNoSource));
+        function.set_dil_function(field.dil_field());
+        function.set_result_type(AbstractType::Handle(zone, field.type()));
+        function.set_is_reflectable(false);
+        function.set_is_debuggable(false);
+        function.set_is_inlinable(false);
+        parsed_function = new(zone) ParsedFunction(thread, function);
+      } else {
+        parsed_function = Parser::ParseStaticFieldInitializer(field);
+        parsed_function->AllocateVariables();
+      }
+
       // Non-optimized code generator.
       DartCompilationPipeline pipeline;
       CompileParsedFunctionHelper helper(parsed_function, false, kNoOSRDeoptId);
       helper.Compile(&pipeline);
       initializer = parsed_function->function().raw();
       Code::Handle(initializer.unoptimized_code()).set_var_descriptors(
           Object::empty_var_descriptors());
     }
     // Invoke the function to evaluate the expression.
     return DartEntry::InvokeFunction(initializer, Object::empty_array());
@@ skipping 436 matching lines @@
   }
   if (start_task) {
     Dart::thread_pool()->Run(isolate->background_compiler());
   }
 }
 
 
 #else  // DART_PRECOMPILED_RUNTIME
 
 
+bool UseDilFrontEndFor(ParsedFunction* parsed_function) {
+  UNREACHABLE();
+  return false;
+}
+
+
 CompilationPipeline* CompilationPipeline::New(Zone* zone,
                                               const Function& function) {
   UNREACHABLE();
   return NULL;
 }
 
 
 DEFINE_RUNTIME_ENTRY(CompileFunction, 1) {
   const Function& function = Function::CheckedHandle(arguments.ArgAt(0));
   FATAL3("Precompilation missed function %s (%" Pd ", %s)\n",
@@ skipping 129 matching lines @@
 
 
 bool BackgroundCompiler::IsDisabled() {
   UNREACHABLE();
   return true;
 }
 
 #endif  // DART_PRECOMPILED_RUNTIME
 
 }  // namespace dart