Implement a simple register allocator that tries to keep instruction results in registers.

runtime/vm/code_generator.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/code_generator.h"
 
 #include "vm/assembler_macros.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
 #include "vm/dart_api_impl.h"
@@ skipping 14 matching lines @@
 DEFINE_FLAG(bool, trace_deopt, false, "Trace deoptimization");
 DEFINE_FLAG(bool, trace_ic, false, "trace IC handling");
 DEFINE_FLAG(bool, trace_patching, false, "Trace patching of code.");
 DEFINE_FLAG(bool, trace_runtime_calls, false, "Trace runtime calls.");
 DEFINE_FLAG(int, optimization_counter_threshold, 2000,
     "function's usage-counter value before it is optimized, -1 means never.");
 DECLARE_FLAG(bool, enable_type_checks);
 DECLARE_FLAG(bool, trace_type_checks);
 DECLARE_FLAG(bool, report_usage_count);
 DECLARE_FLAG(int, deoptimization_counter_threshold);
+DEFINE_FLAG(charp, optimization_filter, NULL, "Optimize only named function");
 
 
 bool CodeGenerator::CanOptimize() {
   return
       !FLAG_report_usage_count &&
       (FLAG_optimization_counter_threshold >= 0) &&
       !Isolate::Current()->debugger()->IsActive();
 }
 
 
@@ skipping 1289 matching lines @@
   }
   if (function.HasOptimizedCode()) {
     // The caller has been already optimized.
     // TODO(srdjan): This is a significant slowdown, the caller is probably in
     // a loop. Maybe test if the code has been optimized before calling.
     // If this happens from optimized code, then it means that the optimized
     // code needs to be reoptimized.
     function.set_usage_counter(kLowInvocationCount);
     return;
   }
+  if ((FLAG_optimization_filter != NULL) &&
+      (strncmp(function.ToFullyQualifiedCString(),
+               FLAG_optimization_filter,
+               strlen(FLAG_optimization_filter)) != 0)) {
+    function.set_usage_counter(kLowInvocationCount);

[srdjan, 2012/06/18 16:33:20]

Why not doing this in the compiler and "Bailout" from optimizing this function?

[Vyacheslav Egorov (Google), 2012/06/18 17:51:16]

I don't see any profit in bailing out so late in the pipeline compared to
bailing out later. This is a purely debug flag.

+    return;
+  }
   if (function.is_optimizable()) {
     ASSERT(!function.HasOptimizedCode());
     const Code& unoptimized_code = Code::Handle(function.unoptimized_code());
     // Compilation patches the entry of unoptimized code.
     const Error& error =
         Error::Handle(Compiler::CompileOptimizedFunction(function));
     if (!error.IsNull()) {
       Exceptions::PropagateError(error);
     }
     const Code& optimized_code = Code::Handle(function.CurrentCode());
@@ skipping 214 matching lines @@
       }
     }
   }
   // The cache is null terminated, therefore the loop above should never
   // terminate by itself.
   UNREACHABLE();
   return Code::null();
 }
 
 }  // namespace dart