Remove the debugger_ field from Isolate in a PRODUCT build

runtime/vm/isolate.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/isolate.h"
 
 #include "include/dart_api.h"
 #include "include/dart_native_api.h"
 #include "platform/assert.h"
 #include "platform/text_buffer.h"
@@ skipping 326 matching lines @@
             priority == Isolate::kBeforeNextEventAction /* at_head */);
       }
       break;
     }
     case Isolate::kInterruptMsg: {
       // [ OOB, kInterruptMsg, pause capability ]
       if (message.Length() != 3) return Error::null();
       Object& obj = Object::Handle(zone, message.At(2));
       if (!I->VerifyPauseCapability(obj)) return Error::null();
 
+#if !defined(PRODUCT)
       // If we are already paused, don't pause again.
-      if (FLAG_support_debugger && (I->debugger()->PauseEvent() == NULL)) {
+      if (I->debugger()->PauseEvent() == NULL) {
         return I->debugger()->PauseInterrupted();
       }
+#endif
       break;
     }
 
     case Isolate::kAddExitMsg:
     case Isolate::kDelExitMsg:
     case Isolate::kAddErrorMsg:
     case Isolate::kDelErrorMsg: {
       // [ OOB, msg, listener port ]
       if (message.Length() < 3) return Error::null();
       const Object& obj = Object::Handle(zone, message.At(2));
@@ skipping 294 matching lines @@
     // whether errors are fatal for the current isolate.
     return StoreError(T, result);
   } else {
     bool has_listener = I->NotifyErrorListeners(exc_str, stacktrace_str);
     if (I->ErrorsFatal()) {
       if (has_listener) {
         T->clear_sticky_error();
       } else {
         T->set_sticky_error(result);
       }
+#if !defined(PRODUCT)
       // Notify the debugger about specific unhandled exceptions which are
       // withheld when being thrown. Do this after setting the sticky error
       // so the isolate has an error set when paused with the unhandled
       // exception.
       if (result.IsUnhandledException()) {
         const UnhandledException& error = UnhandledException::Cast(result);
         RawInstance* exception = error.exception();
         if ((exception == I->object_store()->out_of_memory()) ||
             (exception == I->object_store()->stack_overflow())) {
           // We didn't notify the debugger when the stack was full. Do it now.
-          if (FLAG_support_debugger) {
-            I->debugger()->PauseException(Instance::Handle(exception));
-          }
+          I->debugger()->PauseException(Instance::Handle(exception));
         }
       }
+#endif  // !defined(PRODUCT)
       return kError;
     }
   }
   return kOK;
 }
 
 void Isolate::FlagsInitialize(Dart_IsolateFlags* api_flags) {
   api_flags->version = DART_FLAGS_CURRENT_VERSION;
 #define INIT_FROM_FLAG(name, isolate_flag, flag) api_flags->isolate_flag = flag;
   ISOLATE_FLAG_LIST(INIT_FROM_FLAG)
@@ skipping 58 matching lines @@
       start_time_micros_(OS::GetCurrentMonotonicMicros()),
       main_port_(0),
       origin_id_(0),
       pause_capability_(0),
       terminate_capability_(0),
       errors_fatal_(true),
       init_callback_data_(NULL),
       environment_callback_(NULL),
       library_tag_handler_(NULL),
       api_state_(NULL),
+#if !defined(PRODUCT)
       debugger_(NULL),
+#endif
       resume_request_(false),
       last_resume_timestamp_(OS::GetCurrentTimeMillis()),
       random_(),
       simulator_(NULL),
       mutex_(new Mutex()),
       symbols_mutex_(new Mutex()),
       type_canonicalization_mutex_(new Mutex()),
       constant_canonicalization_mutex_(new Mutex()),
       megamorphic_lookup_mutex_(new Mutex()),
       message_handler_(NULL),
@@ skipping 49 matching lines @@
 #undef REUSABLE_HANDLE_INITIALIZERS
 
 Isolate::~Isolate() {
   free(name_);
   free(debugger_name_);
   delete store_buffer_;
   delete heap_;
   delete object_store_;
   delete api_state_;
 #ifndef PRODUCT
-  if (FLAG_support_debugger) {
-    delete debugger_;
-  }
+  delete debugger_;
 #endif  // !PRODUCT
 #if defined(USING_SIMULATOR)
   delete simulator_;
 #endif
   delete mutex_;
   mutex_ = NULL;  // Fail fast if interrupts are scheduled on a dead isolate.
   delete symbols_mutex_;
   symbols_mutex_ = NULL;
   delete type_canonicalization_mutex_;
   type_canonicalization_mutex_ = NULL;
@@ skipping 72 matching lines @@
 #if defined(DEBUG)
   // Verify that we are never reusing a live origin id.
   VerifyOriginId id_verifier(result->main_port());
   Isolate::VisitIsolates(&id_verifier);
 #endif
   result->set_origin_id(result->main_port());
   result->set_pause_capability(result->random()->NextUInt64());
   result->set_terminate_capability(result->random()->NextUInt64());
 
   result->BuildName(name_prefix);
-  if (FLAG_support_debugger) {
-    result->debugger_ = new Debugger();
-    result->debugger_->Initialize(result);
-  }
+#if !defined(PRODUCT)
+  result->debugger_ = new Debugger();
+  result->debugger_->Initialize(result);
+#endif
   if (FLAG_trace_isolates) {
     if (name_prefix == NULL || strcmp(name_prefix, "vm-isolate") != 0) {
       OS::Print(
           "[+] Starting isolate:\n"
           "\tisolate:    %s\n",
           result->name());
     }
   }
 
 #ifndef PRODUCT
@@ skipping 37 matching lines @@
 void Isolate::set_debugger_name(const char* name) {
   free(debugger_name_);
   debugger_name_ = strdup(name);
 }
 
 int64_t Isolate::UptimeMicros() const {
   return OS::GetCurrentMonotonicMicros() - start_time_micros_;
 }
 
 bool Isolate::IsPaused() const {
+#if defined(PRODUCT)
+  return false;
+#else
   return (debugger_ != NULL) && (debugger_->PauseEvent() != NULL);
+#endif
 }
 
 RawError* Isolate::PausePostRequest() {
-  if (!FLAG_support_debugger) {
-    return Error::null();
-  }
+#if !defined(PRODUCT)
   if (debugger_ == NULL) {
     return Error::null();
   }
   ASSERT(!IsPaused());
   const Error& error = Error::Handle(debugger_->PausePostRequest());
   if (!error.IsNull()) {
     if (Thread::Current()->top_exit_frame_info() == 0) {
       return error.raw();
     } else {
       Exceptions::PropagateError(error);
       UNREACHABLE();
     }
   }
+#endif
   return Error::null();
 }
 
 void Isolate::BuildName(const char* name_prefix) {
   ASSERT(name_ == NULL);
   if (name_prefix == NULL) {
     name_prefix = "isolate";
   }
   set_debugger_name(name_prefix);
   if (ServiceIsolate::NameEquals(name_prefix)) {
@@ skipping 71 matching lines @@
   MutexLocker ml(mutex_);
   // Check if we are in a valid state to make the isolate runnable.
   if (is_runnable() == true) {
     return false;  // Already runnable.
   }
   // Set the isolate as runnable and if we are being spawned schedule
   // isolate on thread pool for execution.
   ASSERT(object_store()->root_library() != Library::null());
   set_is_runnable(true);
 #ifndef PRODUCT
-  if (FLAG_support_debugger) {
-    if (!ServiceIsolate::IsServiceIsolate(this)) {
-      debugger()->OnIsolateRunnable();
-      if (FLAG_pause_isolates_on_unhandled_exceptions) {
-        debugger()->SetExceptionPauseInfo(kPauseOnUnhandledExceptions);
-      }
+  if (!ServiceIsolate::IsServiceIsolate(this)) {
+    debugger()->OnIsolateRunnable();
+    if (FLAG_pause_isolates_on_unhandled_exceptions) {
+      debugger()->SetExceptionPauseInfo(kPauseOnUnhandledExceptions);
     }
   }
 #endif  // !PRODUCT
   IsolateSpawnState* state = spawn_state();
   if (state != NULL) {
     ASSERT(this == state->isolate());
     Run();
   }
 #ifndef PRODUCT
   if (FLAG_support_timeline) {
@@ skipping 266 matching lines @@
     ASSERT(result.IsFunction());
     Function& func = Function::Handle(thread->zone());
     func ^= result.raw();
 
     // TODO(turnidge): Currently we need a way to force a one-time
     // breakpoint for all spawned isolates to support isolate
     // debugging.  Remove this once the vmservice becomes the standard
     // way to debug. Set the breakpoint on the static function instead
     // of its implicit closure function because that latter is merely
     // a dispatcher that is marked as undebuggable.
-    if (FLAG_support_debugger && FLAG_break_at_isolate_spawn) {
+#if !defined(PRODUCT)
+    if (FLAG_break_at_isolate_spawn) {
       isolate->debugger()->OneTimeBreakAtEntry(func);
     }
+#endif
 
     func = func.ImplicitClosureFunction();
 
     const Array& capabilities = Array::Handle(Array::New(2));
     Capability& capability = Capability::Handle();
     capability = Capability::New(isolate->pause_capability());
     capabilities.SetAt(0, capability);
     // Check whether this isolate should be started in paused state.
     if (state->paused()) {
       bool added = isolate->AddResumeCapability(capability);
@@ skipping 156 matching lines @@
 
   // Notify exit listeners that this isolate is shutting down.
   if (object_store() != NULL) {
     const Error& error = Error::Handle(thread->sticky_error());
     if (error.IsNull() || !error.IsUnwindError() ||
         UnwindError::Cast(error).is_user_initiated()) {
       NotifyExitListeners();
     }
   }
 
+#if !defined(PRODUCT)
   // Clean up debugger resources.
-  if (FLAG_support_debugger) {
-    debugger()->Shutdown();
-  }
+  debugger()->Shutdown();
+#endif
 
   // Close all the ports owned by this isolate.
   PortMap::ClosePorts(message_handler());
 
   // Fail fast if anybody tries to post any more messages to this isolate.
   delete message_handler();
   set_message_handler(NULL);
   if (FLAG_support_timeline) {
     // Before analyzing the isolate's timeline blocks- reclaim all cached
     // blocks.
@@ skipping 196 matching lines @@
   // Visit the registered service extension handlers.
   visitor->VisitPointer(
       reinterpret_cast<RawObject**>(&registered_service_extension_handlers_));
 
   // Visit the boxed_field_list_.
   // 'boxed_field_list_' access via mutator and background compilation threads
   // is guarded with a monitor. This means that we can visit it only
   // when at safepoint or the field_list_mutex_ lock has been taken.
   visitor->VisitPointer(reinterpret_cast<RawObject**>(&boxed_field_list_));
 
+#if !defined(PRODUCT)
   // Visit objects in the debugger.
-  if (FLAG_support_debugger) {
-    debugger()->VisitObjectPointers(visitor);
-  }
+  debugger()->VisitObjectPointers(visitor);
 
-#if !defined(PRODUCT)
   // Visit objects that are being used for isolate reload.
   if (reload_context() != NULL) {
     reload_context()->VisitObjectPointers(visitor);
   }
   if (ServiceIsolate::IsServiceIsolate(this)) {
     ServiceIsolate::VisitObjectPointers(visitor);
   }
 #endif  // !defined(PRODUCT)
 
 #if !defined(DART_PRECOMPILED_RUNTIME)
@@ skipping 1031 matching lines @@
 void IsolateSpawnState::DecrementSpawnCount() {
   ASSERT(spawn_count_monitor_ != NULL);
   ASSERT(spawn_count_ != NULL);
   MonitorLocker ml(spawn_count_monitor_);
   ASSERT(*spawn_count_ > 0);
   *spawn_count_ = *spawn_count_ - 1;
   ml.Notify();
 }
 
 }  // namespace dart