Add flag —enable-debugger (default true) in order to disable debugger single stepping code.

runtime/vm/flow_graph_builder.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/flow_graph_builder.h"
 
 #include "lib/invocation_mirror.h"
 #include "vm/ast_printer.h"
 #include "vm/bit_vector.h"
 #include "vm/class_finalizer.h"
@@ skipping 24 matching lines @@
             "Eliminate type checks when allowed by static type analysis.");
 DEFINE_FLAG(bool, print_ast, false, "Print abstract syntax tree.");
 DEFINE_FLAG(bool, print_scopes, false, "Print scopes of local variables.");
 DEFINE_FLAG(bool, trace_type_check_elimination, false,
             "Trace type check elimination at compile time.");
 DEFINE_FLAG(bool, warn_on_javascript_compatibility, false,
             "Warn on incompatibilities between vm and dart2js.");
 DECLARE_FLAG(bool, enable_type_checks);
 DECLARE_FLAG(bool, warning_as_error);
 DECLARE_FLAG(bool, silent_warnings);
+DECLARE_FLAG(int, optimization_counter_threshold);
 
+DECLARE_FLAG(bool, enable_debugger);
 
 // TODO(srdjan): Allow compiler to add constants as they are encountered in
 // the compilation.
 const double kCommonDoubleConstants[] =
     {-1.0, -0.5, -0.1, 0.0, 0.1, 0.5, 1.0, 2.0, 4.0, 5.0,
      10.0, 20.0, 30.0, 64.0, 255.0, NAN,
      // From dart:math
      2.718281828459045, 2.302585092994046, 0.6931471805599453,
      1.4426950408889634, 0.4342944819032518, 3.1415926535897932,
      0.7071067811865476, 1.4142135623730951};
@@ skipping 936 matching lines @@
     return_value = Bind(BuildLoadLocal(*temp));
   }
 
   // Call to stub that checks whether the debugger is in single
   // step mode. This call must happen before the contexts are
   // unchained so that captured variables can be inspected.
   // No debugger check is done in native functions or for return
   // statements for which there is no associated source position.
   const Function& function = owner()->parsed_function()->function();
   if ((node->token_pos() != Scanner::kNoSourcePos) &&
-      !function.is_native()) {
+      !function.is_native() && FLAG_enable_debugger) {
     AddInstruction(new DebugStepCheckInstr(node->token_pos(),
                                            PcDescriptors::kReturn));
   }
 
   if (FLAG_enable_type_checks) {
     const bool is_implicit_dynamic_getter =
         (!function.is_static() &&
         ((function.kind() == RawFunction::kImplicitGetter) ||
          (function.kind() == RawFunction::kImplicitStaticFinalGetter)));
     // Implicit getters do not need a type check at return, unless they compute
@@ skipping 2088 matching lines @@
 
 
 // <Expression> ::= StoreLocal { local: LocalVariable
 //                               value: <Expression> }
 void EffectGraphVisitor::VisitStoreLocalNode(StoreLocalNode* node) {
   // If the right hand side is an expression that does not contain
   // a safe point for the debugger to stop, add an explicit stub
   // call.
   if (node->value()->IsLiteralNode() ||
       node->value()->IsLoadLocalNode()) {
-    AddInstruction(new DebugStepCheckInstr(node->token_pos(),
-                                           PcDescriptors::kRuntimeCall));
+    if (FLAG_enable_debugger) {
+      AddInstruction(new DebugStepCheckInstr(node->token_pos(),
+                                             PcDescriptors::kRuntimeCall));
+    }
   }
 
   ValueGraphVisitor for_value(owner());
   node->value()->Visit(&for_value);
   Append(for_value);
   Value* store_value = for_value.value();
   if (FLAG_enable_type_checks) {
     store_value = BuildAssignableValue(node->value()->token_pos(),
                                        store_value,
                                        node->local().type(),
@@ skipping 36 matching lines @@
   Value* store_value = for_value.value();
   if (FLAG_enable_type_checks) {
     const AbstractType& type = AbstractType::ZoneHandle(node->field().type());
     const String& dst_name = String::ZoneHandle(node->field().name());
     store_value = BuildAssignableValue(node->value()->token_pos(),
                                        store_value,
                                        type,
                                        dst_name);
   }
 
-  store_value = Bind(BuildStoreExprTemp(store_value));
-  GuardFieldInstr* guard =
-      new GuardFieldInstr(store_value,
-                          node->field(),
-                          Isolate::Current()->GetNextDeoptId());
-  AddInstruction(guard);
+  if (FLAG_optimization_counter_threshold >= 0) {
+    store_value = Bind(BuildStoreExprTemp(store_value));
+    GuardFieldInstr* guard =
+        new GuardFieldInstr(store_value,
+                            node->field(),
+                            Isolate::Current()->GetNextDeoptId());
+    AddInstruction(guard);
+    store_value = Bind(BuildLoadExprTemp());
+  }
 
-  store_value = Bind(BuildLoadExprTemp());
   StoreInstanceFieldInstr* store =
       new StoreInstanceFieldInstr(node->field(),
                                   for_instance.value(),
                                   store_value,
                                   kEmitStoreBarrier,
                                   node->token_pos());
   store->set_is_initialization(true);  // Maybe initializing store.
   ReturnDefinition(store);
 }
 
@@ skipping 325 matching lines @@
             Isolate::Current()->object_store()->empty_context())))));
   }
 
   // This check may be deleted if the generated code is leaf.
   // Native functions don't need a stack check at entry.
   const Function& function = owner()->parsed_function()->function();
   if ((node == owner()->parsed_function()->node_sequence()) &&
       !function.is_native()) {
     // Always allocate CheckOverflowInstr so that deopt-ids match regardless
     // if we inline or not.
-    CheckStackOverflowInstr* check =
-        new CheckStackOverflowInstr(function.token_pos(), 0);
-    // If we are inlining don't actually attach the stack check. We must still
-    // create the stack check in order to allocate a deopt id.
-    if (!owner()->IsInlining()) {
-      AddInstruction(check);
+    if (!function.IsImplicitGetterFunction() &&
+        !function.IsImplicitSetterFunction()) {
+      CheckStackOverflowInstr* check =
+          new CheckStackOverflowInstr(function.token_pos(), 0);
+      // If we are inlining don't actually attach the stack check. We must still
+      // create the stack check in order to allocate a deopt id.
+      if (!owner()->IsInlining()) {
+        AddInstruction(check);
+      }
     }
   }
 
   if (FLAG_enable_type_checks &&
       (node == owner()->parsed_function()->node_sequence())) {
     const Function& function = owner()->parsed_function()->function();
     const int num_params = function.NumParameters();
     int pos = 0;
     if (function.IsConstructor()) {
       // Skip type checking of receiver and phase for constructor functions.
@@ skipping 428 matching lines @@
                                   LanguageError::kBailout,
                                   Heap::kNew,
                                   "FlowGraphBuilder Bailout: %s %s",
                                   String::Handle(function.name()).ToCString(),
                                   reason));
   Isolate::Current()->long_jump_base()->Jump(1, error);
   UNREACHABLE();
 }
 
 }  // namespace dart