VM support for running Kernel binaries.

runtime/vm/flow_graph_inliner.cc

 // Copyright (c) 2013, 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_inliner.h"
 
 #include "vm/aot_optimizer.h"
 #include "vm/block_scheduler.h"
 #include "vm/branch_optimizer.h"
 #include "vm/compiler.h"
+#include "vm/kernel.h"
+#include "vm/kernel_to_il.h"
 #include "vm/flags.h"
 #include "vm/flow_graph.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
 #include "vm/flow_graph_type_propagator.h"
 #include "vm/il_printer.h"
 #include "vm/jit_optimizer.h"
 #include "vm/longjump.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
@@ skipping 692 matching lines @@
     thread()->set_deopt_id(0);
     Error& error = Error::Handle();
     {
       // Install bailout jump.
       LongJumpScope jump;
       if (setjmp(*jump.Set()) == 0) {
         Isolate* isolate = Isolate::Current();
         // Makes sure no classes are loaded during parsing in background.
         const intptr_t loading_invalidation_gen_at_start =
             isolate->loading_invalidation_gen();
-        // Parse the callee function.
-        bool in_cache;
-        ParsedFunction* parsed_function;
-       {
-          CSTAT_TIMER_SCOPE(thread(), graphinliner_parse_timer);
-          parsed_function = GetParsedFunction(function, &in_cache);
-        }
 
         if (Compiler::IsBackgroundCompilation()) {
           if (isolate->IsTopLevelParsing() ||
                   (loading_invalidation_gen_at_start !=
                    isolate->loading_invalidation_gen())) {
             // Loading occured while parsing. We need to abort here because
             // state changed while compiling.
             Compiler::AbortBackgroundCompilation(Thread::kNoDeoptId,
                 "Loading occured while parsing in inliner");
           }
         }
 
         // Load IC data for the callee.
         ZoneGrowableArray<const ICData*>* ic_data_array =
               new(Z) ZoneGrowableArray<const ICData*>();
         const bool clone_ic_data = Compiler::IsBackgroundCompilation();
         function.RestoreICDataMap(ic_data_array, clone_ic_data);
         if (Compiler::IsBackgroundCompilation() &&
             (function.ic_data_array() == Array::null())) {
           Compiler::AbortBackgroundCompilation(Thread::kNoDeoptId,
               "ICData cleared while inlining");
         }
 
+        // Parse the callee function.
+        bool in_cache;
+        ParsedFunction* parsed_function;
+        {
+          CSTAT_TIMER_SCOPE(thread(), graphinliner_parse_timer);
+          parsed_function = GetParsedFunction(function, &in_cache);
+        }
+
         // Build the callee graph.
         InlineExitCollector* exit_collector =
             new(Z) InlineExitCollector(caller_graph_, call);
-        FlowGraphBuilder builder(*parsed_function,
-                                 *ic_data_array,
-                                 exit_collector,
-                                 Compiler::kNoOSRDeoptId);
-        builder.SetInitialBlockId(caller_graph_->max_block_id());
         FlowGraph* callee_graph;
-        {
-          CSTAT_TIMER_SCOPE(thread(), graphinliner_build_timer);
-          callee_graph = builder.BuildGraph();
+        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,
+                                           exit_collector,
+                                           Compiler::kNoOSRDeoptId,
+                                           caller_graph_->max_block_id() + 1);
+          {
+            CSTAT_TIMER_SCOPE(thread(), graphinliner_build_timer);
+            callee_graph = builder.BuildGraph();
+          }
+        } else {
+          FlowGraphBuilder builder(*parsed_function,
+                                   *ic_data_array,
+                                   exit_collector,
+                                   Compiler::kNoOSRDeoptId);
+          builder.SetInitialBlockId(caller_graph_->max_block_id());
+          {
+            CSTAT_TIMER_SCOPE(thread(), graphinliner_build_timer);
+            callee_graph = builder.BuildGraph();
+          }
         }
 
         // The parameter stubs are a copy of the actual arguments providing
         // concrete information about the values, for example constant values,
         // without linking between the caller and callee graphs.
         // TODO(zerny): Put more information in the stubs, eg, type information.
         ZoneGrowableArray<Definition*>* param_stubs =
             new(Z) ZoneGrowableArray<Definition*>(
                 function.NumParameters());
 
@@ skipping 356 matching lines @@
     for (intptr_t i = 0; i < function_cache_.length(); ++i) {
       ParsedFunction* parsed_function = function_cache_[i];
       if (parsed_function->function().raw() == function.raw()) {
         *in_cache = true;
         return parsed_function;
       }
     }
     *in_cache = false;
     ParsedFunction* parsed_function =
         new(Z) ParsedFunction(thread(), function);
-    Parser::ParseFunction(parsed_function);
-    parsed_function->AllocateVariables();
+    if (!UseKernelFrontEndFor(parsed_function)) {
+      Parser::ParseFunction(parsed_function);
+      parsed_function->AllocateVariables();
+    }
     return parsed_function;
   }
 
   void InlineStaticCalls() {
     const GrowableArray<CallSites::StaticCallInfo>& call_info =
         inlining_call_sites_->static_calls();
     TRACE_INLINING(THR_Print("  Static Calls (%" Pd ")\n", call_info.length()));
     for (intptr_t call_idx = 0; call_idx < call_info.length(); ++call_idx) {
       StaticCallInstr* call = call_info[call_idx].call;
       const Function& target = call->function();
@@ skipping 2631 matching lines @@
       return true;
     }
 
     default:
       return false;
   }
 }
 
 
 }  // namespace dart