Remove the debugger_ field from Isolate in a PRODUCT build

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 1037 matching lines @@
   node->value()->Visit(&for_value);
   Append(for_value);
   Value* return_value = for_value.value();
 
   // 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()->function();
-  if (FLAG_support_debugger && node->token_pos().IsDebugPause() &&
-      !function.is_native()) {
+#if !defined(PRODUCT)
+  if (node->token_pos().IsDebugPause() && !function.is_native()) {
     AddInstruction(new (Z) DebugStepCheckInstr(node->token_pos(),
                                                RawPcDescriptors::kRuntimeCall,
                                                owner()->GetNextDeoptId()));
   }
+#endif
 
   NestedContextAdjustment context_adjustment(owner(), owner()->context_level());
 
   if (node->inlined_finally_list_length() > 0) {
     LocalVariable* temp = owner()->parsed_function().finally_return_temp_var();
     ASSERT(temp != NULL);
     Do(BuildStoreLocal(*temp, return_value, node->token_pos()));
     for (intptr_t i = 0; i < node->inlined_finally_list_length(); i++) {
       InlineBailout("EffectGraphVisitor::VisitReturnNode (exception)");
       EffectGraphVisitor for_effect(owner());
@@ skipping 956 matching lines @@
     if (nested_loop.break_target() == NULL) {
       exit_ = for_test.CreateFalseSuccessor();
     } else {
       for_test.IfFalseGoto(nested_loop.break_target());
       exit_ = nested_loop.break_target();
     }
   }
 }
 
 void EffectGraphVisitor::VisitJumpNode(JumpNode* node) {
-  if (FLAG_support_debugger && owner()->function().is_debuggable()) {
+#if !defined(PRODUCT)
+  if (owner()->function().is_debuggable()) {
     AddInstruction(new (Z) DebugStepCheckInstr(node->token_pos(),
                                                RawPcDescriptors::kRuntimeCall,
                                                owner()->GetNextDeoptId()));
   }
+#endif
 
   NestedContextAdjustment context_adjustment(owner(), owner()->context_level());
 
   for (intptr_t i = 0; i < node->inlined_finally_list_length(); i++) {
     EffectGraphVisitor for_effect(owner());
     node->InlinedFinallyNodeAt(i)->Visit(&for_effect);
     Append(for_effect);
     if (!is_open()) return;
   }
 
@@ skipping 1265 matching lines @@
 }
 
 void ValueGraphVisitor::VisitLoadLocalNode(LoadLocalNode* node) {
   Definition* load = BuildLoadLocal(node->local(), node->token_pos());
   ReturnDefinition(load);
 }
 
 // <Expression> ::= StoreLocal { local: LocalVariable
 //                               value: <Expression> }
 void EffectGraphVisitor::VisitStoreLocalNode(StoreLocalNode* node) {
+#if !defined(PRODUCT)
   // 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. Exception: don't do this when assigning to or from internal
   // variables, or for generated code that has no source position.
-  if (FLAG_support_debugger) {
-    AstNode* rhs = node->value();
-    if (rhs->IsAssignableNode()) {
-      rhs = rhs->AsAssignableNode()->expr();
-    }
-    if ((rhs->IsLiteralNode() || rhs->IsLoadStaticFieldNode() ||
-         (rhs->IsLoadLocalNode() &&
-          !rhs->AsLoadLocalNode()->local().IsInternal()) ||
-         rhs->IsClosureNode()) &&
-        !node->local().IsInternal() && node->token_pos().IsDebugPause()) {
-      AddInstruction(new (Z) DebugStepCheckInstr(node->token_pos(),
-                                                 RawPcDescriptors::kRuntimeCall,
-                                                 owner()->GetNextDeoptId()));
-    }
+  AstNode* rhs = node->value();
+  if (rhs->IsAssignableNode()) {
+    rhs = rhs->AsAssignableNode()->expr();
   }
+  if ((rhs->IsLiteralNode() || rhs->IsLoadStaticFieldNode() ||
+       (rhs->IsLoadLocalNode() &&
+        !rhs->AsLoadLocalNode()->local().IsInternal()) ||
+       rhs->IsClosureNode()) &&
+      !node->local().IsInternal() && node->token_pos().IsDebugPause()) {
+    AddInstruction(new (Z) DebugStepCheckInstr(node->token_pos(),
+                                               RawPcDescriptors::kRuntimeCall,
+                                               owner()->GetNextDeoptId()));
+  }
+#endif
 
   ValueGraphVisitor for_value(owner());
   node->value()->Visit(&for_value);
   Append(for_value);
   Value* store_value = for_value.value();
   if (Isolate::Current()->type_checks()) {
     store_value =
         BuildAssignableValue(node->value()->token_pos(), store_value,
                              node->local().type(), node->local().name());
   }
@@ skipping 64 matching lines @@
       Field::ZoneHandle(Z, node->field().Original()), token_pos));
   LoadStaticFieldInstr* load =
       new (Z) LoadStaticFieldInstr(field_value, token_pos);
   ReturnDefinition(load);
 }
 
 Definition* EffectGraphVisitor::BuildStoreStaticField(
     StoreStaticFieldNode* node,
     bool result_is_needed,
     TokenPosition token_pos) {
-  if (FLAG_support_debugger) {
-    // 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.
-    AstNode* rhs = node->value();
-    if (rhs->IsAssignableNode()) {
-      rhs = rhs->AsAssignableNode()->expr();
-    }
-    if ((rhs->IsLiteralNode() || rhs->IsLoadLocalNode() ||
-         rhs->IsLoadStaticFieldNode() || rhs->IsClosureNode()) &&
-        node->token_pos().IsDebugPause()) {
-      AddInstruction(new (Z) DebugStepCheckInstr(node->token_pos(),
-                                                 RawPcDescriptors::kRuntimeCall,
-                                                 owner()->GetNextDeoptId()));
-    }
+#if !defined(PRODUCT)
+  // 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.
+  AstNode* rhs = node->value();
+  if (rhs->IsAssignableNode()) {
+    rhs = rhs->AsAssignableNode()->expr();
   }
+  if ((rhs->IsLiteralNode() || rhs->IsLoadLocalNode() ||
+       rhs->IsLoadStaticFieldNode() || rhs->IsClosureNode()) &&
+      node->token_pos().IsDebugPause()) {
+    AddInstruction(new (Z) DebugStepCheckInstr(node->token_pos(),
+                                               RawPcDescriptors::kRuntimeCall,
+                                               owner()->GetNextDeoptId()));
+  }
+#endif
 
   ValueGraphVisitor for_value(owner());
   node->value()->Visit(&for_value);
   Append(for_value);
   Value* store_value = NULL;
   if (result_is_needed) {
     store_value = Bind(BuildStoreExprTemp(for_value.value(), token_pos));
   } else {
     store_value = for_value.value();
   }
@@ skipping 380 matching lines @@
     // Call _asyncSetThreadStackTrace
     const intptr_t kTypeArgsLen = 0;
     StaticCallInstr* call_async_set_thread_stack_trace = new (Z)
         StaticCallInstr(node->token_pos().ToSynthetic(),
                         async_set_thread_stack_trace, kTypeArgsLen,
                         Object::null_array(), arguments,
                         owner()->ic_data_array(), owner()->GetNextDeoptId());
     Do(call_async_set_thread_stack_trace);
   }
 
-  if (FLAG_support_debugger && is_top_level_sequence &&
-      function.is_debuggable()) {
+#if !defined(PRODUCT)
+  if (is_top_level_sequence && function.is_debuggable()) {
     // Place a debug check at method entry to ensure breaking on a method always
     // happens, even if there are no assignments/calls/runtimecalls in the first
     // basic block. Place this check at the last parameter to ensure parameters
     // are in scope in the debugger at method entry.
     const int num_params = function.NumParameters();
     TokenPosition check_pos = TokenPosition::kNoSource;
     if (num_params > 0) {
       const LocalVariable& parameter = *scope->VariableAt(num_params - 1);
       check_pos = parameter.token_pos();
     }
 
     if (check_pos.IsNoSource() || (check_pos.Pos() < node->token_pos().Pos())) {
       // No parameters or synthetic parameters, e.g. 'this'.
       check_pos = node->token_pos();
       ASSERT(check_pos.IsDebugPause());
     }
     AddInstruction(new (Z) DebugStepCheckInstr(
         check_pos, RawPcDescriptors::kRuntimeCall, owner()->GetNextDeoptId()));
   }
+#endif
 
   // This check may be deleted if the generated code is leaf.
   // Native functions don't need a stack check at entry.
   if (is_top_level_sequence && !function.is_native()) {
     // Always allocate CheckOverflowInstr so that deopt-ids match regardless
     // if we inline or not.
     if (!function.IsImplicitGetterFunction() &&
         !function.IsImplicitSetterFunction()) {
       CheckStackOverflowInstr* check = new (Z) CheckStackOverflowInstr(
           node->token_pos(), 0, owner()->GetNextDeoptId());
@@ skipping 379 matching lines @@
              cls, Library::PrivateCoreLibName(Symbols::ThrowNew()),
              kTypeArgsLen, arguments->length(), Object::null_array()));
   ASSERT(!func.IsNull());
   return new (Z) StaticCallInstr(token_pos, func, kTypeArgsLen,
                                  Object::null_array(),  // No names.
                                  arguments, owner()->ic_data_array(),
                                  owner()->GetNextDeoptId());
 }
 
 void EffectGraphVisitor::BuildThrowNode(ThrowNode* node) {
-  if (FLAG_support_debugger) {
-    if (node->exception()->IsLiteralNode() ||
-        node->exception()->IsLoadLocalNode() ||
-        node->exception()->IsLoadStaticFieldNode() ||
-        node->exception()->IsClosureNode()) {
-      AddInstruction(new (Z) DebugStepCheckInstr(node->token_pos(),
-                                                 RawPcDescriptors::kRuntimeCall,
-                                                 owner()->GetNextDeoptId()));
-    }
+#if !defined(PRODUCT)
+  if (node->exception()->IsLiteralNode() ||
+      node->exception()->IsLoadLocalNode() ||
+      node->exception()->IsLoadStaticFieldNode() ||
+      node->exception()->IsClosureNode()) {
+    AddInstruction(new (Z) DebugStepCheckInstr(node->token_pos(),
+                                               RawPcDescriptors::kRuntimeCall,
+                                               owner()->GetNextDeoptId()));
   }
+#endif
   ValueGraphVisitor for_exception(owner());
   node->exception()->Visit(&for_exception);
   Append(for_exception);
   PushArgument(for_exception.value());
   Instruction* instr = NULL;
   if (node->stacktrace() == NULL) {
     instr = new (Z) ThrowInstr(node->token_pos(), owner()->GetNextDeoptId());
   } else {
     ValueGraphVisitor for_stack_trace(owner());
     node->stacktrace()->Visit(&for_stack_trace);
@@ skipping 120 matching lines @@
   ASSERT(type.HasResolvedTypeClass());
   const Class& type_class = Class::Handle(type.type_class());
   // Bail if the type has any type parameters.
   if (type_class.IsGeneric()) return false;
 
   // Finally a simple class for instance of checking.
   return true;
 }
 
 }  // namespace dart