Fix a crash in debugger, add flag --stress-test-background-compilation, add asserts.

runtime/vm/code_generator.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/code_generator.h"
 
 #include "vm/assembler.h"
 #include "vm/ast.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
@@ skipping 13 matching lines @@
 #include "vm/symbols.h"
 #include "vm/thread_registry.h"
 #include "vm/verifier.h"
 
 namespace dart {
 
 DEFINE_FLAG(int, max_subtype_cache_entries, 100,
     "Maximum number of subtype cache entries (number of checks cached).");
 DEFINE_FLAG(int, regexp_optimization_counter_threshold, 1000,
     "RegExp's usage-counter value before it is optimized, -1 means never");
-DEFINE_FLAG(charp, optimization_filter, NULL, "Optimize only named function");
 DEFINE_FLAG(int, reoptimization_counter_threshold, 4000,
     "Counter threshold before a function gets reoptimized.");
-DEFINE_FLAG(bool, stop_on_excessive_deoptimization, false,
-    "Debugging: stops program if deoptimizing same function too often");
 DEFINE_FLAG(bool, trace_deoptimization, false, "Trace deoptimization");
 DEFINE_FLAG(bool, trace_deoptimization_verbose, false,
     "Trace deoptimization verbose");
-DEFINE_FLAG(bool, trace_failed_optimization_attempts, false,
-    "Traces all failed optimization attempts");
 DEFINE_FLAG(bool, trace_ic, false, "Trace IC handling");
 DEFINE_FLAG(bool, trace_ic_miss_in_optimized, false,
     "Trace IC miss in optimized code");
 DEFINE_FLAG(bool, trace_optimized_ic_calls, false,
     "Trace IC calls in optimized code.");
 DEFINE_FLAG(bool, trace_patching, false, "Trace patching of code.");
 DEFINE_FLAG(bool, trace_runtime_calls, false, "Trace runtime calls");
 DEFINE_FLAG(bool, trace_type_checks, false, "Trace runtime type checks.");
 
 DECLARE_FLAG(int, max_deoptimization_counter_threshold);
@@ skipping 1134 matching lines @@
   const Object& result = Object::Handle(
       DartEntry::InvokeNoSuchMethod(receiver,
                                     original_function_name,
                                     orig_arguments,
                                     orig_arguments_desc));
   CheckResultError(result);
   arguments.SetReturn(result);
 }
 
 
-static bool CanOptimizeFunction(const Function& function, Thread* thread) {
-  if (FLAG_support_debugger) {
-    Isolate* isolate = thread->isolate();
-    if (isolate->debugger()->IsStepping() ||
-        isolate->debugger()->HasBreakpoint(function, thread->zone())) {
-      // We cannot set breakpoints and single step in optimized code,
-      // so do not optimize the function.
-      function.set_usage_counter(0);
-      return false;
-    }
-  }
-  if (function.deoptimization_counter() >=
-      FLAG_max_deoptimization_counter_threshold) {
-    if (FLAG_trace_failed_optimization_attempts ||
-        FLAG_stop_on_excessive_deoptimization) {
-      THR_Print("Too many deoptimizations: %s\n",
-          function.ToFullyQualifiedCString());
-      if (FLAG_stop_on_excessive_deoptimization) {
-        FATAL("Stop on excessive deoptimization");
-      }
-    }
-    // The function will not be optimized any longer. This situation can occur
-    // mostly with small optimization counter thresholds.
-    function.SetIsOptimizable(false);
-    function.set_usage_counter(INT_MIN);
-    return false;
-  }
-  if (FLAG_optimization_filter != NULL) {
-    // FLAG_optimization_filter is a comma-separated list of strings that are
-    // matched against the fully-qualified function name.
-    char* save_ptr;  // Needed for strtok_r.
-    const char* function_name = function.ToFullyQualifiedCString();
-    intptr_t len = strlen(FLAG_optimization_filter) + 1;  // Length with \0.
-    char* filter = new char[len];
-    strncpy(filter, FLAG_optimization_filter, len);  // strtok modifies arg 1.
-    char* token = strtok_r(filter, ",", &save_ptr);
-    bool found = false;
-    while (token != NULL) {
-      if (strstr(function_name, token) != NULL) {
-        found = true;
-        break;
-      }
-      token = strtok_r(NULL, ",", &save_ptr);
-    }
-    delete[] filter;
-    if (!found) {
-      function.set_usage_counter(INT_MIN);
-      return false;
-    }
-  }
-  if (!function.IsOptimizable()) {
-    // Huge methods (code size above --huge_method_cutoff_in_code_size) become
-    // non-optimizable only after the code has been generated.
-    if (FLAG_trace_failed_optimization_attempts) {
-      THR_Print("Not optimizable: %s\n", function.ToFullyQualifiedCString());
-    }
-    function.set_usage_counter(INT_MIN);
-    return false;
-  }
-  return true;
-}
-
-
 DEFINE_RUNTIME_ENTRY(StackOverflow, 0) {
 #if defined(USING_SIMULATOR)
   uword stack_pos = Simulator::Current()->get_register(SPREG);
 #else
   uword stack_pos = Thread::GetCurrentStackPointer();
 #endif
   // Always clear the stack overflow flags.  They are meant for this
   // particular stack overflow runtime call and are not meant to
   // persist.
   uword stack_overflow_flags = thread->GetAndClearStackOverflowFlags();
@@ skipping 86 matching lines @@
     ASSERT(frame != NULL);
     const Code& code = Code::ZoneHandle(frame->LookupDartCode());
     ASSERT(!code.IsNull());
     const Function& function = Function::Handle(code.function());
     ASSERT(!function.IsNull());
     // Since the code is referenced from the frame and the ZoneHandle,
     // it cannot have been removed from the function.
     ASSERT(function.HasCode());
     // Don't do OSR on intrinsified functions: The intrinsic code expects to be
     // called like a regular function and can't be entered via OSR.
-    if (!CanOptimizeFunction(function, thread) || function.is_intrinsic()) {
+    if (!Compiler::CanOptimizeFunction(thread, function) ||
+        function.is_intrinsic()) {
       return;
     }
 
     // The unoptimized code is on the stack and should never be detached from
     // the function at this point.
     ASSERT(function.unoptimized_code() != Object::null());
     intptr_t osr_id =
         Code::Handle(function.unoptimized_code()).GetDeoptIdForOsr(frame->pc());
     ASSERT(osr_id != Compiler::kNoOSRDeoptId);
     if (FLAG_trace_osr) {
@@ skipping 49 matching lines @@
 // This is called from function that needs to be optimized.
 // The requesting function can be already optimized (reoptimization).
 // Returns the Code object where to continue execution.
 DEFINE_RUNTIME_ENTRY(OptimizeInvokedFunction, 1) {
 #if !defined(DART_PRECOMPILED_RUNTIME)
   const Function& function = Function::CheckedHandle(zone,
                                                      arguments.ArgAt(0));
   ASSERT(!function.IsNull());
   ASSERT(function.HasCode());
 
-  if (CanOptimizeFunction(function, thread)) {
+  if (Compiler::CanOptimizeFunction(thread, function)) {
     if (FLAG_background_compilation) {
       Field& field = Field::Handle(zone, isolate->GetDeoptimizingBoxedField());
       while (!field.IsNull()) {
         if (FLAG_trace_optimization || FLAG_trace_field_guards) {
           THR_Print("Lazy disabling unboxing of %s\n", field.ToCString());
         }
         field.set_is_unboxing_candidate(false);
         field.DeoptimizeDependentCode();
         // Get next field.
         field = isolate->GetDeoptimizingBoxedField();
@@ skipping 437 matching lines @@
   const intptr_t elm_size = old_data.ElementSizeInBytes();
   const TypedData& new_data =
       TypedData::Handle(TypedData::New(cid, new_size, Heap::kOld));
   TypedData::Copy(new_data, 0, old_data, 0, old_size * elm_size);
   typed_data_cell.SetAt(0, new_data);
   arguments.SetReturn(new_data);
 }
 
 
 }  // namespace dart