Remove support for non-ssa optimizing code generation.

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 16 matching lines @@
 #include "vm/scanner.h"
 #include "vm/symbols.h"
 #include "vm/timer.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, disassemble, false, "Disassemble dart code.");
 DEFINE_FLAG(bool, disassemble_optimized, false, "Disassemble optimized code.");
 DEFINE_FLAG(bool, trace_bailout, false, "Print bailout from ssa compiler.");
 DEFINE_FLAG(bool, trace_compiler, false, "Trace compiler operations.");
-DEFINE_FLAG(bool, use_ssa, true, "Use SSA form");
 DEFINE_FLAG(bool, local_cse, true, "Do local subexpression elimination.");
 DEFINE_FLAG(int, deoptimization_counter_threshold, 5,
     "How many times we allow deoptimization before we disallow"
     " certain optimizations");
 DECLARE_FLAG(bool, print_flow_graph);
 
 
 // Compile a function. Should call only if the function has not been compiled.
 //   Arg0: function object.
 DEFINE_RUNTIME_ENTRY(CompileFunction, 1) {
@@ skipping 67 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 CompileParsedFunctionHelper(
-    const ParsedFunction& parsed_function, bool optimized, bool use_ssa) {
+static bool CompileParsedFunctionHelper(const ParsedFunction& parsed_function,
+                                        bool optimized) {
   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_deopt_id = isolate->deopt_id();
   isolate->set_deopt_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) {
@@ skipping 20 matching lines @@
           isolate->set_ic_data_array(
               ExtractTypeFeedbackArray(unoptimized_code));
         }
       }
 
       // Build the flow graph.
       FlowGraphBuilder builder(parsed_function);
       flow_graph = builder.BuildGraph();
 
       // Transform to SSA.
-      if (optimized && use_ssa) flow_graph->ComputeSSA();
+      if (optimized) {
+        flow_graph->ComputeSSA();
+      }
 
       if (FLAG_print_flow_graph) {
         OS::Print("Before Optimizations\n");
         FlowGraphPrinter printer(*flow_graph);
         printer.PrintBlocks();
       }
       if (Dart::flow_graph_writer() != NULL) {
         // Write flow graph to file.
         FlowGraphVisualizer printer(*flow_graph);
         printer.PrintFunction();
       }
 
       if (optimized) {
-        FlowGraphOptimizer optimizer(*flow_graph, use_ssa);
+        FlowGraphOptimizer optimizer(*flow_graph);
         optimizer.ApplyICData();
 
         // Propagate types and eliminate more type tests.
-        FlowGraphTypePropagator propagator(*flow_graph, optimized && use_ssa);
+        FlowGraphTypePropagator propagator(*flow_graph);
         propagator.PropagateTypes();
 
 
-        if (use_ssa) {
-          // Do optimizations that depend on the propagated type information.
-          optimizer.OptimizeComputations();
+        // Do optimizations that depend on the propagated type information.
+        optimizer.OptimizeComputations();
 
-          if (FLAG_local_cse) {
-            LocalCSE local_cse(*flow_graph);
-            local_cse.Optimize();
-          }
+        if (FLAG_local_cse) {
+          LocalCSE local_cse(*flow_graph);
+          local_cse.Optimize();
+        }
 
-          // Perform register allocation on the SSA graph.
-          FlowGraphAllocator allocator(*flow_graph);
-          allocator.AllocateRegisters();
-        }
+        // Perform register allocation on the SSA graph.
+        FlowGraphAllocator allocator(*flow_graph);
+        allocator.AllocateRegisters();
 
         if (FLAG_print_flow_graph) {
           OS::Print("After Optimizations:\n");
           FlowGraphPrinter printer(*flow_graph);
           printer.PrintBlocks();
         }
       }
     }
 
     bool is_leaf = false;
     if (optimized) {
       FlowGraphAnalyzer analyzer(*flow_graph);
       analyzer.Analyze();
       is_leaf = analyzer.is_leaf();
     }
     Assembler assembler;
     FlowGraphCompiler graph_compiler(&assembler,
                                      *flow_graph,
                                      optimized,
-                                     optimized && use_ssa,
                                      is_leaf);
     {
       TimerScope timer(FLAG_compiler_stats,
                        &CompilerStats::graphcompiler_timer,
                        isolate);
       graph_compiler.CompileGraph();
     }
     {
       TimerScope timer(FLAG_compiler_stats,
                        &CompilerStats::codefinalizer_timer,
@@ skipping 23 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);
+    ASSERT(optimized);
     is_compiled = false;
   }
   // Reset global isolate state.
   isolate->set_ic_data_array(Array::null());
   isolate->set_long_jump_base(old_base);
   isolate->set_deopt_id(prev_deopt_id);
   return is_compiled;
 }
 
 
@@ skipping 114 matching lines @@
     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();
 
-    if (!CompileParsedFunctionHelper(parsed_function,
-                                     optimized,
-                                     FLAG_use_ssa)) {
-      // Compile again using non-ssa code generation.
-      // Re-parse because of side-effects to the AST during compilation.
-      ParsedFunction parsed_function(function);
-      Parser::ParseFunction(&parsed_function);
-      parsed_function.AllocateVariables();
-      CompileParsedFunctionHelper(parsed_function, optimized, false);
-    }
+    CompileParsedFunctionHelper(parsed_function, optimized);

[Florian Schneider, 2012/08/21 12:50:01]

When bailing out, we should mark the function as not-optimizable. Otherwise,
we'll retry optimizing again without success.

 
     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 27 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) {
-    // Non-optimized, non-ssa code generator.
-    CompileParsedFunctionHelper(parsed_function, false, false);
+    // Non-optimized code generator.
+    CompileParsedFunctionHelper(parsed_function, 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 55 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();
 
-    // Non-optimized, non-ssa code generator.
-    CompileParsedFunctionHelper(parsed_function, false, false);
+    // Non-optimized code generator.
+    CompileParsedFunctionHelper(parsed_function, 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