With --noopt run unoptimized code through optimizer, more optimizations can be done later.

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/block_scheduler.h"
@@ skipping 51 matching lines @@
 DEFINE_FLAG(bool, trace_bailout, false, "Print bailout from ssa compiler.");
 DEFINE_FLAG(bool, use_inlining, true, "Enable call-site inlining");
 DEFINE_FLAG(bool, verify_compiler, false,
     "Enable compiler verification assertions");
 
 DECLARE_FLAG(bool, trace_failed_optimization_attempts);
 DECLARE_FLAG(bool, trace_inlining_intervals);
 DECLARE_FLAG(bool, trace_irregexp);
 DECLARE_FLAG(bool, trace_patching);
 
+
+bool Compiler::always_optimize_ = false;
+bool Compiler::guess_other_cid_ = true;
+
+
 // TODO(zerny): Factor out unoptimizing/optimizing pipelines and remove
 // separate helpers functions & `optimizing` args.
 class CompilationPipeline : public ZoneAllocated {
  public:
   static CompilationPipeline* New(Zone* zone, const Function& function);
 
   virtual void ParseFunction(ParsedFunction* parsed_function) = 0;
   virtual FlowGraph* BuildFlowGraph(
       Zone* zone,
       ParsedFunction* parsed_function,
@@ skipping 65 matching lines @@
   }
 
   virtual void FinalizeCompilation() {
     backtrack_goto_->ComputeOffsetTable();
   }
 
  private:
   IndirectGotoInstr* backtrack_goto_;
 };
 
+
 CompilationPipeline* CompilationPipeline::New(Zone* zone,
                                               const Function& function) {
   if (function.IsIrregexpFunction()) {
     return new(zone) IrregexpCompilationPipeline();
   } else {
     return new(zone) DartCompilationPipeline();
   }
 }
 
 
@@ skipping 235 matching lines @@
       // constructor and unregisters itself upon destruction.
       CHA cha(thread);
 
       // TimerScope needs an isolate to be properly terminated in case of a
       // LongJump.
       {
         CSTAT_TIMER_SCOPE(isolate, graphbuilder_timer);
         ZoneGrowableArray<const ICData*>* ic_data_array =
             new(zone) ZoneGrowableArray<const ICData*>();
         if (optimized) {
-          ASSERT(function.HasCode());
           // Extract type feedback before the graph is built, as the graph
           // builder uses it to attach it to nodes.
           ASSERT(function.deoptimization_counter() <
                  FLAG_deoptimization_counter_threshold);
           function.RestoreICDataMap(ic_data_array);
           if (FLAG_print_ic_data_map) {
             for (intptr_t i = 0; i < ic_data_array->length(); i++) {
               if ((*ic_data_array)[i] != NULL) {
                 ISL_Print("%" Pd " ", i);
                 FlowGraphPrinter::PrintICData(*(*ic_data_array)[i]);
@@ skipping 46 matching lines @@
       // Collect all instance fields that are loaded in the graph and
       // have non-generic type feedback attached to them that can
       // potentially affect optimizations.
       if (optimized) {
         inline_id_to_function.Add(&function);
         // Top scope function has no caller (-1).
         caller_inline_id.Add(-1);
         CSTAT_TIMER_SCOPE(isolate, graphoptimizer_timer);
 
         FlowGraphOptimizer optimizer(flow_graph);
+        if (Compiler::always_optimize()) {
+          optimizer.PopulateWithICData();
+        }
         optimizer.ApplyICData();
         DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
         // Optimize (a << b) & c patterns, merge operations.
         // Run early in order to have more opportunity to optimize left shifts.
         optimizer.TryOptimizePatterns();
         DEBUG_ASSERT(flow_graph->VerifyUseLists());
 
         FlowGraphInliner::SetInliningId(flow_graph, 0);
 
@@ skipping 242 matching lines @@
 
         graph_compiler.FinalizePcDescriptors(code);
         code.set_deopt_info_array(deopt_info_array);
 
         graph_compiler.FinalizeStackmaps(code);
         graph_compiler.FinalizeVarDescriptors(code);
         graph_compiler.FinalizeExceptionHandlers(code);
         graph_compiler.FinalizeStaticCallTargetsTable(code);
 
         if (optimized) {
-          if (osr_id == Isolate::kNoDeoptId) {
+          // We may not have previous code if 'always_optimize' is set.
+          if ((osr_id == Isolate::kNoDeoptId) && function.HasCode()) {
             CodePatcher::PatchEntry(Code::Handle(function.CurrentCode()));
             if (FLAG_trace_compiler || FLAG_trace_patching) {
               if (FLAG_trace_compiler) {
                 ISL_Print("  ");
               }
               ISL_Print("Patch unoptimized '%s' entry point %#" Px "\n",
                   function.ToFullyQualifiedCString(),
                   Code::Handle(function.unoptimized_code()).EntryPoint());
             }
           }
           function.AttachCode(code);
 
           // Register code with the classes it depends on because of CHA.
           for (intptr_t i = 0;
                i < thread->cha()->leaf_classes().length();
                ++i) {
             thread->cha()->leaf_classes()[i]->RegisterCHACode(code);
           }
 
           for (intptr_t i = 0;
                i < flow_graph->guarded_fields()->length();
                i++) {
             const Field* field = (*flow_graph->guarded_fields())[i];
             field->RegisterDependentCode(code);
           }
         } else {  // not optimized.
-          if (function.ic_data_array() == Array::null()) {
+          if (!Compiler::always_optimize() &&
+              (function.ic_data_array() == Array::null())) {
             function.SaveICDataMap(graph_compiler.deopt_id_to_ic_data());
           }
           function.set_unoptimized_code(code);
           function.AttachCode(code);
           ASSERT(CodePatcher::CodeIsPatchable(code));
         }
         if (parsed_function->HasDeferredPrefixes()) {
           ZoneGrowableArray<const LibraryPrefix*>* prefixes =
               parsed_function->deferred_prefixes();
           for (intptr_t i = 0; i < prefixes->length(); i++) {
@@ skipping 187 matching lines @@
     Thread* const thread = Thread::Current();
     Isolate* const isolate = thread->isolate();
     StackZone stack_zone(isolate);
     Zone* const zone = stack_zone.GetZone();
     TIMERSCOPE(isolate, time_compilation);
     Timer per_compile_timer(FLAG_trace_compiler, "Compilation time");
     per_compile_timer.Start();
 
     // Restore unoptimized code if needed.
     if (optimized) {
-      const Error& error = Error::Handle(
-          zone, Compiler::EnsureUnoptimizedCode(Thread::Current(), function));
-      if (!error.IsNull()) {
-        return error.raw();
+      if (!Compiler::always_optimize()) {
+        const Error& error = Error::Handle(
+            zone, Compiler::EnsureUnoptimizedCode(Thread::Current(), function));
+        if (!error.IsNull()) {
+          return error.raw();
+        }
       }
     }
 
     ParsedFunction* parsed_function = new(zone) ParsedFunction(
         thread, Function::ZoneHandle(zone, function.raw()));
     if (FLAG_trace_compiler) {
       ISL_Print("Compiling %s%sfunction: '%s' @ token %" Pd ", size %" Pd "\n",
                 (osr_id == Isolate::kNoDeoptId ? "" : "osr "),
                 (optimized ? "optimized " : ""),
                 function.ToFullyQualifiedCString(),
                 function.token_pos(),
                 (function.end_token_pos() - function.token_pos()));
     }
     {
       HANDLESCOPE(isolate);
       pipeline->ParseFunction(parsed_function);
     }
 
     const bool success = CompileParsedFunctionHelper(pipeline,
                                                      parsed_function,
                                                      optimized,
                                                      osr_id);
     if (!success) {
       if (optimized) {
-        // Optimizer bailed out. Disable optimizations and to never try again.
+        ASSERT(!Compiler::always_optimize());  // Optimized is the only code.
+        // Optimizer bailed out. Disable optimizations and never try again.
         if (FLAG_trace_compiler) {
           ISL_Print("--> disabling optimizations for '%s'\n",
                     function.ToFullyQualifiedCString());
         } else if (FLAG_trace_failed_optimization_attempts) {
           ISL_Print("Cannot optimize: %s\n",
                     function.ToFullyQualifiedCString());
         }
         function.SetIsOptimizable(false);
         return Error::null();
       }
@@ skipping 36 matching lines @@
   UNREACHABLE();
   return Error::null();
 }
 
 
 RawError* Compiler::CompileFunction(Thread* thread,
                                     const Function& function) {
   VMTagScope tagScope(thread->isolate(), VMTag::kCompileUnoptimizedTagId);
   CompilationPipeline* pipeline =
       CompilationPipeline::New(thread->zone(), function);
-  return CompileFunctionHelper(pipeline, function, false, Isolate::kNoDeoptId);
+
+  const bool optimized =
+      Compiler::always_optimize() && function.IsOptimizable();
+
+  return CompileFunctionHelper(pipeline, function, optimized,
+      Isolate::kNoDeoptId);
 }
 
 
 RawError* Compiler::EnsureUnoptimizedCode(Thread* thread,
                                      const Function& function) {
   if (function.unoptimized_code() != Object::null()) {
     return Error::null();
   }
   Code& original_code = Code::ZoneHandle(thread->zone());
   if (function.HasCode()) {
@@ skipping 234 matching lines @@
     const Object& result =
       PassiveObject::Handle(isolate->object_store()->sticky_error());
     isolate->object_store()->clear_sticky_error();
     return result.raw();
   }
   UNREACHABLE();
   return Object::null();
 }
 
 }  // namespace dart