First steps toward a two stages new compiler.

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/code_generator.h"
 #include "vm/code_patcher.h"
@@ skipping 120 matching lines @@
 }
 
 
 static void CompileParsedFunctionHelper(
     const ParsedFunction& parsed_function, bool optimized) {
   Isolate* isolate = Isolate::Current();
   TimerScope timer(FLAG_compiler_stats, &CompilerStats::codegen_timer);
   const Function& function = parsed_function.function();
   const char* function_fullname = function.ToFullyQualifiedCString();
   bool is_compiled = false;
-  if (FLAG_use_new_compiler) {
-    ASSERT(!optimized);
+  // TODO(srdjan): Remove once the old compiler has been ripped out.
+#if defined(TARGET_ARCH_X64)
+  const bool use_new_compiler = true;
+#else
+  const bool use_new_compiler = FLAG_use_new_compiler;
+#endif
+  if (use_new_compiler) {
     LongJump* old_base = isolate->long_jump_base();
     LongJump bailout_jump;
     isolate->set_long_jump_base(&bailout_jump);
     if (setjmp(*bailout_jump.Set()) == 0) {
       FlowGraphBuilder graph_builder(parsed_function);
-      graph_builder.BuildGraph();
+      graph_builder.BuildGraph(optimized);
 
       // The non-optimizing compiler compiles blocks in reverse postorder,
       // because it is a 'natural' order for the human reader of the
       // generated code.
       intptr_t length = graph_builder.postorder_block_entries().length();
       GrowableArray<BlockEntryInstr*> block_order(length);
       for (intptr_t i = length - 1; i >= 0; --i) {
         block_order.Add(graph_builder.postorder_block_entries()[i]);
       }
 
+      if (optimized) {
+        // Transition to optimized code only from unoptimized code ...
+        // for now.
+        ASSERT(function.HasCode());
+        ASSERT(!function.HasOptimizedCode());
+        // Do not use type feedback to optimize a function that was
+        // deoptimized too often.
+        if (parsed_function.function().deoptimization_counter() <
+            FLAG_deoptimization_counter_threshold) {
+          // Extract type feedback etc.
+        }
+      }
       Assembler assembler;
       FlowGraphCompiler graph_compiler(&assembler, parsed_function,
-                                       block_order);
+                                       block_order, optimized);
       graph_compiler.CompileGraph();
 
       TimerScope timer(FLAG_compiler_stats,
                        &CompilerStats::codefinalizer_timer);
       const Code& code =
           Code::Handle(Code::FinalizeCode(function_fullname, &assembler));
-      code.set_is_optimized(false);
+      code.set_is_optimized(optimized);
       graph_compiler.FinalizePcDescriptors(code);
       graph_compiler.FinalizeStackmaps(code);
       graph_compiler.FinalizeVarDescriptors(code);
       graph_compiler.FinalizeExceptionHandlers(code);
-      function.set_unoptimized_code(code);
-      function.SetCode(code);
-      ASSERT(CodePatcher::CodeIsPatchable(code));
+      if (optimized) {
+        function.SetCode(code);
+        CodePatcher::PatchEntry(Code::Handle(function.unoptimized_code()));
+        if (FLAG_trace_compiler) {
+          OS::Print("--> patching entry 0x%x\n",
+                    Code::Handle(function.unoptimized_code()).EntryPoint());
+        }
+      } else {
+        function.set_unoptimized_code(code);
+        function.SetCode(code);
+        ASSERT(CodePatcher::CodeIsPatchable(code));
+      }
       is_compiled = true;
     } else {
       // We bailed out.
       Error& bailout_error = Error::Handle(
           isolate->object_store()->sticky_error());
       isolate->object_store()->clear_sticky_error();
       if (FLAG_trace_bailout) {
         OS::Print("%s\n", bailout_error.ToErrorCString());
       }
     }
@@ skipping 254 matching lines @@
     isolate->object_store()->clear_sticky_error();
     isolate->set_long_jump_base(base);
     return result.raw();
   }
   UNREACHABLE();
   return Object::null();
 }
 
 
 }  // namespace dart