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,
@@ skipping 10 matching lines @@
   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 46 matching lines @@
   // Use previously compiled code.
   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(
+static void CompileParsedFunctionHelper(
     const ParsedFunction& parsed_function, bool optimized) {
-  bool is_compiled = false;
+  TimerScope timer(FLAG_compiler_stats, &CompilerStats::codegen_timer);
   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;
     // TimerScope needs an isolate to be properly terminated in case of a
@@ skipping 74 matching lines @@
         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());
-    }
-    is_compiled = false;
+    UNREACHABLE();

[srdjan, 2012/06/26 16:06:51]

We can bailout of optimized code (e.g., during ssa code generation) in which
case we should continue in unoptimized code). Try running with --use-ssa (see
bailout above).

   }
   // 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.
@@ skipping 215 matching lines @@
     isolate->object_store()->clear_sticky_error();
     isolate->set_long_jump_base(base);
     return result.raw();
   }
   UNREACHABLE();
   return Object::null();
 }
 
 
 }  // namespace dart