Remove old code generator.

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"
 #include "vm/dart_entry.h"
 #include "vm/debugger.h"
 #include "vm/disassembler.h"
 #include "vm/exceptions.h"
 #include "vm/flags.h"
 #include "vm/flow_graph_allocator.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
 #include "vm/flow_graph_optimizer.h"
 #include "vm/longjump.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
-#include "vm/opt_code_generator.h"
 #include "vm/os.h"
 #include "vm/parser.h"
 #include "vm/scanner.h"
 #include "vm/timer.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, disassemble, false, "Disassemble dart code.");
 DEFINE_FLAG(bool, trace_compiler, false, "Trace compiler operations.");
 DEFINE_FLAG(int, deoptimization_counter_threshold, 5,
     "How many times we allow deoptimization before we disallow"
     " certain optimizations");
-DEFINE_FLAG(bool, use_new_compiler, true, "Use the new compiler backend.");
-DEFINE_FLAG(bool, trace_bailout, false, "Print bailout from new compiler.");
+DEFINE_FLAG(bool, trace_bailout, false, "Print bailout from ssa compiler.");
 DECLARE_FLAG(bool, use_ssa);
 
 
 // Compile a function. Should call only if the function has not been compiled.
 //   Arg0: function object.
 DEFINE_RUNTIME_ENTRY(CompileFunction, 1) {
   ASSERT(arguments.Count() == kCompileFunctionRuntimeEntry.argument_count());
   const Function& function = Function::CheckedHandle(arguments.At(0));
   ASSERT(!function.HasCode());
   const Error& error = Error::Handle(Compiler::CompileFunction(function));
   if (!error.IsNull()) {
     Exceptions::PropagateError(error);
   }
 }
 
 
-// Extracts IC data associated with a node id.
-// TODO(srdjan): Check performance impact of node id search loop.
-static void ExtractTypeFeedback(const Code& code,
-                                SequenceNode* sequence_node) {
-  ASSERT(!code.IsNull() && !code.is_optimized());
-  GrowableArray<AstNode*> all_nodes;
-  sequence_node->CollectAllNodes(&all_nodes);
-  GrowableArray<intptr_t> node_ids;
-  const GrowableObjectArray& ic_data_objs =
-      GrowableObjectArray::Handle(GrowableObjectArray::New());
-  code.ExtractIcDataArraysAtCalls(&node_ids, ic_data_objs);
-  ICData& ic_data_obj = ICData::Handle();
-  for (intptr_t i = 0; i < node_ids.length(); i++) {
-    intptr_t node_id = node_ids[i];
-    bool found_node = false;
-    for (intptr_t n = 0; n < all_nodes.length(); n++) {
-      if (all_nodes[n]->id() == node_id) {
-        found_node = true;
-        // Make sure we assign ic data array only once.
-        ASSERT(all_nodes[n]->ic_data().IsNull());
-        ic_data_obj ^= ic_data_objs.At(i);
-        all_nodes[n]->set_ic_data(ic_data_obj);
-      }
-    }
-    ASSERT(found_node);
-  }
-}
-
-
 // Returns an array indexed by computation id, containing the extracted ICData.
 static RawArray* ExtractTypeFeedbackArray(const Code& code) {
   ASSERT(!code.IsNull() && !code.is_optimized());
   GrowableArray<intptr_t> computation_ids;
   const GrowableObjectArray& ic_data_objs =
       GrowableObjectArray::Handle(GrowableObjectArray::New());
   const intptr_t max_id =
       code.ExtractIcDataArraysAtCalls(&computation_ids, ic_data_objs);
   const Array& result = Array::Handle(Array::New(max_id + 1));
   for (intptr_t i = 0; i < computation_ids.length(); i++) {
@@ skipping 47 matching lines @@
   function.SetCode(Code::Handle(function.unoptimized_code()));
   CodePatcher::RestoreEntry(Code::Handle(function.unoptimized_code()));
   if (FLAG_trace_compiler) {
     OS::Print("--> restoring entry at 0x%x\n",
               Code::Handle(function.unoptimized_code()).EntryPoint());
   }
 }
 
 
 // Return false if bailed out.
-static bool CompileWithNewCompiler(
-    const ParsedFunction& parsed_function, bool optimized) {
+static bool CompileParsedFunctionHelper(
+    const ParsedFunction& parsed_function, bool optimized, bool use_ssa) {
+  TimerScope timer(FLAG_compiler_stats, &CompilerStats::codegen_timer);
   bool is_compiled = false;
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate->ic_data_array() == Array::null());  // Must be reset to null.
   const intptr_t prev_cid = isolate->computation_id();
   isolate->set_computation_id(0);
   LongJump* old_base = isolate->long_jump_base();
   LongJump bailout_jump;
   isolate->set_long_jump_base(&bailout_jump);
   if (setjmp(*bailout_jump.Set()) == 0) {
     GrowableArray<BlockEntryInstr*> block_order;
@@ skipping 14 matching lines @@
         // deoptimized too often.
         if (parsed_function.function().deoptimization_counter() <
             FLAG_deoptimization_counter_threshold) {
           const Code& unoptimized_code =
               Code::Handle(parsed_function.function().unoptimized_code());
           isolate->set_ic_data_array(
               ExtractTypeFeedbackArray(unoptimized_code));
         }
       }
       FlowGraphBuilder graph_builder(parsed_function);
-      graph_builder.BuildGraph(optimized);
+      graph_builder.BuildGraph(optimized, use_ssa);
 
       // 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();
       for (intptr_t i = length - 1; i >= 0; --i) {
         block_order.Add(graph_builder.postorder_block_entries()[i]);
       }
       if (optimized) {
         FlowGraphOptimizer optimizer(block_order);
         optimizer.ApplyICData();
 
-        if (FLAG_use_ssa) {
+        if (use_ssa) {
           // Perform register allocation on the SSA graph.
           FlowGraphAllocator allocator(graph_builder.postorder_block_entries(),
                                        graph_builder.current_ssa_temp_index());
           allocator.ResolveConstraints();
           allocator.AnalyzeLiveness();
 
           // Temporary bailout until we support code generation from SSA form.
           graph_builder.Bailout("No SSA code generation support.");
         }
       }
@@ skipping 41 matching lines @@
     }
     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());
     }
+    // We only bail out from generating ssa code.
+    ASSERT(optimized && use_ssa);
     is_compiled = false;
   }
   // Reset global isolate state.
   isolate->set_ic_data_array(Array::null());
   isolate->set_long_jump_base(old_base);
   isolate->set_computation_id(prev_cid);
   return is_compiled;
 }
 
 
-static void CompileWithOldCompiler(
-    const ParsedFunction& parsed_function, bool optimized) {
-  const Function& function = parsed_function.function();
-  Assembler assembler;
-  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) {
-      TimerScope timer(FLAG_compiler_stats,
-                       &CompilerStats::graphbuilder_timer);
-      ExtractTypeFeedback(
-          Code::Handle(parsed_function.function().unoptimized_code()),
-          parsed_function.node_sequence());
-    }
-    OptimizingCodeGenerator code_gen(&assembler, parsed_function);
-    {
-      TimerScope timer(FLAG_compiler_stats,
-                       &CompilerStats::graphcompiler_timer);
-      code_gen.GenerateCode();
-    }
-    {
-      TimerScope timer(FLAG_compiler_stats,
-                       &CompilerStats::codefinalizer_timer);
-      Code& code = Code::Handle(Code::FinalizeCode(function, &assembler));
-      code.set_is_optimized(true);
-      code_gen.FinalizePcDescriptors(code);
-      code_gen.FinalizeStackmaps(code);
-      code_gen.FinalizeExceptionHandlers(code);
-      code_gen.FinalizeComments(code);
-      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 {
-    // Compile unoptimized code.
-    ASSERT(!function.HasCode());
-    // Compiling first time.
-    CodeGenerator code_gen(&assembler, parsed_function);
-    {
-      TimerScope timer(FLAG_compiler_stats,
-                       &CompilerStats::graphcompiler_timer);
-      code_gen.GenerateCode();
-    }
-    {
-      TimerScope timer(FLAG_compiler_stats,
-                       &CompilerStats::codefinalizer_timer);
-      const Code& code = Code::Handle(Code::FinalizeCode(function, &assembler));
-      code.set_is_optimized(false);
-      code_gen.FinalizePcDescriptors(code);
-      code_gen.FinalizeStackmaps(code);
-      code_gen.FinalizeVarDescriptors(code);
-      code_gen.FinalizeExceptionHandlers(code);
-      code_gen.FinalizeComments(code);
-      function.set_unoptimized_code(code);
-      function.SetCode(code);
-      ASSERT(CodePatcher::CodeIsPatchable(code));
-    }
-  }
-}
-
-static void CompileParsedFunctionHelper(
-    const ParsedFunction& parsed_function, bool optimized) {
-  TimerScope timer(FLAG_compiler_stats, &CompilerStats::codegen_timer);
-  bool is_compiled = false;
-  // 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) {
-    is_compiled = CompileWithNewCompiler(parsed_function, optimized);
-    if (!is_compiled && optimized) {
-      // When bailing out from the optimizing compiler, mark function as
-      // non-optimizable and return.
-      parsed_function.function().set_is_optimizable(false);
-      return;
-    }
-  }
-
-  if (!is_compiled) {
-    CompileWithOldCompiler(parsed_function, optimized);
-  }
-}
-
-
 static RawError* CompileFunctionHelper(const Function& function,
                                        bool optimized) {
   Isolate* isolate = Isolate::Current();
   LongJump* base = isolate->long_jump_base();
   LongJump jump;
   isolate->set_long_jump_base(&jump);
   // Skips parsing if we need to only install unoptimized code.
   if (!optimized && !Code::Handle(function.unoptimized_code()).IsNull()) {
     InstallUnoptimizedCode(function);
     isolate->set_long_jump_base(base);
     return Error::null();
   }
   if (setjmp(*jump.Set()) == 0) {
     TIMERSCOPE(time_compilation);
     ParsedFunction parsed_function(function);
     if (FLAG_trace_compiler) {
       OS::Print("Compiling %sfunction: '%s' @ token %d\n",
                 (optimized ? "optimized " : ""),
                 function.ToFullyQualifiedCString(),
                 function.token_pos());
     }
     Parser::ParseFunction(&parsed_function);
     parsed_function.AllocateVariables();
 
-    CompileParsedFunctionHelper(parsed_function, optimized);
+    if (!CompileParsedFunctionHelper(parsed_function,
+                                     optimized,
+                                     FLAG_use_ssa)) {
+      // Compile again using non-ssa code generation.
+      CompileParsedFunctionHelper(parsed_function, optimized, false);
+    }
 
     if (FLAG_trace_compiler) {
       OS::Print("--> '%s' entry: 0x%x\n",
                 function.ToFullyQualifiedCString(),
                 Code::Handle(function.CurrentCode()).EntryPoint());
     }
     if (Isolate::Current()->debugger()->IsActive()) {
       Isolate::Current()->debugger()->NotifyCompilation(function);
     }
     if (FLAG_disassemble) {
@@ skipping 90 matching lines @@
 }
 
 
 RawError* Compiler::CompileParsedFunction(
     const ParsedFunction& parsed_function) {
   Isolate* isolate = Isolate::Current();
   LongJump* base = isolate->long_jump_base();
   LongJump jump;
   isolate->set_long_jump_base(&jump);
   if (setjmp(*jump.Set()) == 0) {
-    CompileParsedFunctionHelper(parsed_function, false);  // Non-optimized.
+    // Non-optimized, non-ssa code generator.
+    CompileParsedFunctionHelper(parsed_function, false, false);
     isolate->set_long_jump_base(base);
     return Error::null();
   } else {
     Error& error = Error::Handle();
     // We got an error during compilation.
     error = isolate->object_store()->sticky_error();
     isolate->object_store()->clear_sticky_error();
     isolate->set_long_jump_base(base);
     return error.raw();
   }
@@ skipping 53 matching lines @@
     // would compile func automatically. We are checking fewer invariants
     // here.
     ParsedFunction parsed_function(func);
     parsed_function.SetNodeSequence(fragment);
     parsed_function.set_default_parameter_values(Array::Handle());
     parsed_function.set_expression_temp_var(
         ParsedFunction::CreateExpressionTempVar(0));
     fragment->scope()->AddVariable(parsed_function.expression_temp_var());
     parsed_function.AllocateVariables();
 
-    CompileParsedFunctionHelper(parsed_function, false);  // Non-optimized.
+    // Non-optimized, non-ssa code generator.
+    CompileParsedFunctionHelper(parsed_function, false, false);
 
     GrowableArray<const Object*> arguments;  // no arguments.
     const Array& kNoArgumentNames = Array::Handle();
     Object& result = Object::Handle();
     result = DartEntry::InvokeStatic(func,
                                      arguments,
                                      kNoArgumentNames);
     isolate->set_long_jump_base(base);
     return result.raw();
   } else {
     Object& result = Object::Handle();
     result = isolate->object_store()->sticky_error();
     isolate->object_store()->clear_sticky_error();
     isolate->set_long_jump_base(base);
     return result.raw();
   }
   UNREACHABLE();
   return Object::null();
 }
 
 
 }  // namespace dart