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

runtime/vm/flow_graph_compiler.cc

 // Copyright (c) 2013, 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/globals.h"  // Needed here to get TARGET_ARCH_XXX.
 
 #include "vm/flow_graph_compiler.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
+#include "vm/compiler.h"
 #include "vm/dart_entry.h"
 #include "vm/debugger.h"
 #include "vm/deopt_instructions.h"
 #include "vm/exceptions.h"
 #include "vm/flow_graph_allocator.h"
 #include "vm/il_printer.h"
 #include "vm/intrinsifier.h"
 #include "vm/locations.h"
 #include "vm/log.h"
 #include "vm/longjump.h"
@@ skipping 13 matching lines @@
 DEFINE_FLAG(bool, enable_simd_inline, true,
     "Enable inlining of SIMD related method calls.");
 DEFINE_FLAG(int, min_optimization_counter_threshold, 5000,
     "The minimum invocation count for a function.");
 DEFINE_FLAG(int, optimization_counter_scale, 2000,
     "The scale of invocation count, by size of the function.");
 DEFINE_FLAG(bool, source_lines, false, "Emit source line as assembly comment.");
 DEFINE_FLAG(bool, use_megamorphic_stub, true, "Out of line megamorphic lookup");
 
 DECLARE_FLAG(bool, code_comments);
-DECLARE_FLAG(int, deoptimize_every);
+DECLARE_FLAG(bool, deoptimize_alot);
+DECLARE_FLAG(bool, deoptimize_every);
 DECLARE_FLAG(charp, deoptimize_filter);
 DECLARE_FLAG(bool, disassemble);
 DECLARE_FLAG(bool, disassemble_optimized);
 DECLARE_FLAG(bool, emit_edge_counters);
+DECLARE_FLAG(bool, ic_range_profiling);
 DECLARE_FLAG(bool, intrinsify);
+DECLARE_FLAG(bool, load_deferred_eagerly);
 DECLARE_FLAG(int, optimization_counter_threshold);
 DECLARE_FLAG(bool, propagate_ic_data);
 DECLARE_FLAG(int, regexp_optimization_counter_threshold);
 DECLARE_FLAG(int, reoptimization_counter_threshold);
 DECLARE_FLAG(int, stacktrace_every);
 DECLARE_FLAG(charp, stacktrace_filter);
 DECLARE_FLAG(bool, support_debugger);
+DECLARE_FLAG(bool, use_field_guards);
 DECLARE_FLAG(bool, use_cha);
-DECLARE_FLAG(bool, use_field_guards);
 DECLARE_FLAG(bool, use_osr);
 DECLARE_FLAG(bool, warn_on_javascript_compatibility);
-DECLARE_FLAG(bool, ic_range_profiling);
+
 
 static void NooptModeHandler(bool value) {
   if (value) {
     FLAG_always_megamorphic_calls = value;
     FLAG_optimization_counter_threshold = -1;
     FLAG_use_field_guards = false;
     FLAG_use_osr = false;
     FLAG_emit_edge_counters = false;
     FLAG_support_debugger = false;
     FLAG_ic_range_profiling = false;
     FLAG_collect_code = false;
+    FLAG_load_deferred_eagerly = true;
+    FLAG_deoptimize_alot = false;  // Used in some tests.
+    FLAG_deoptimize_every = 0;  // Used in some tests.
+    FLAG_collect_code = false;
+    Compiler::set_always_optimize(true);
+    Compiler::set_guess_other_cid(false);
+    // TODO(srdjan): Enable CHA when eager class finalization is
+    // implemented, either with precompilation or as a special pass.
+    FLAG_use_cha = false;
   }
 }
 
 
 // --noopt disables optimizer and tunes unoptimized code to run as fast
 // as possible.
 DEFINE_FLAG_HANDLER(NooptModeHandler,
                     noopt,
                     "Run fast unoptimized code only.");
 
@@ skipping 116 matching lines @@
       BlockEntryInstr* entry = block_order_[i];
       for (ForwardInstructionIterator it(entry); !it.Done(); it.Advance()) {
         Instruction* current = it.Current();
         if (current->IsBranch()) {
           current = current->AsBranch()->comparison();
         }
         // In optimized code, ICData is always set in the instructions.
         const ICData* ic_data = NULL;
         if (current->IsInstanceCall()) {
           ic_data = current->AsInstanceCall()->ic_data();
-          ASSERT(ic_data != NULL);
         }
         if ((ic_data != NULL) && (ic_data->NumberOfUsedChecks() == 0)) {
           may_reoptimize_ = true;
         }
         if (is_leaf &&
             !current->IsCheckStackOverflow() &&
             !current->IsParallelMove()) {
           // Note that we do not care if the code contains instructions that
           // can deoptimize.
           LocationSummary* locs = current->locs();
@@ skipping 619 matching lines @@
 }
 
 
 Label* FlowGraphCompiler::AddDeoptStub(intptr_t deopt_id,
                                        ICData::DeoptReasonId reason,
                                        uint32_t flags) {
   if (intrinsic_mode()) {
     return &intrinsic_slow_path_label_;
   }
 
+  // No deoptimization allowed when 'always_optimize' is set.
+  ASSERT(!Compiler::always_optimize());
   ASSERT(is_optimizing_);
   CompilerDeoptInfoWithStub* stub =
       new CompilerDeoptInfoWithStub(deopt_id,
                                     reason,
                                     flags,
                                     pending_deoptimization_env_);
   deopt_infos_.Add(stub);
   return stub->entry_label();
 }
 
@@ skipping 15 matching lines @@
       pc_descriptors_list_->FinalizePcDescriptors(code.EntryPoint()));
   if (!is_optimizing_) descriptors.Verify(parsed_function_.function());
   code.set_pc_descriptors(descriptors);
   code.set_entry_patch_pc_offset(entry_patch_pc_offset_);
   code.set_patch_code_pc_offset(patch_code_pc_offset_);
   code.set_lazy_deopt_pc_offset(lazy_deopt_pc_offset_);
 }
 
 
 RawArray* FlowGraphCompiler::CreateDeoptInfo(Assembler* assembler) {
+  // No deopt information if we 'always_optimize' (no deoptimization allowed).
+  if (Compiler::always_optimize()) {
+    return Array::empty_array().raw();
+  }
   // For functions with optional arguments, all incoming arguments are copied
   // to spill slots. The deoptimization environment does not track them.
   const Function& function = parsed_function().function();
   const intptr_t incoming_arg_count =
       function.HasOptionalParameters() ? 0 : function.num_fixed_parameters();
   DeoptInfoBuilder builder(zone(), incoming_arg_count, assembler);
 
   intptr_t deopt_info_table_size = DeoptTable::SizeFor(deopt_infos_.length());
   if (deopt_info_table_size == 0) {
     return Object::empty_array().raw();
@@ skipping 825 matching lines @@
 
 
 void FlowGraphCompiler::FrameStateClear() {
   ASSERT(!is_optimizing());
   frame_state_.TruncateTo(0);
 }
 #endif
 
 
 }  // namespace dart