Always initialize the debugger eagerly.

src/isolate.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stdlib.h>
 
 #include "v8.h"
 
 #include "ast.h"
 #include "bootstrapper.h"
@@ skipping 1404 matching lines @@
     : embedder_data_(),
       state_(UNINITIALIZED),
       entry_stack_(NULL),
       stack_trace_nesting_level_(0),
       incomplete_message_(NULL),
       bootstrapper_(NULL),
       runtime_profiler_(NULL),
       compilation_cache_(NULL),
       counters_(NULL),
       code_range_(NULL),
-      debugger_initialized_(false),
       logger_(NULL),
       stats_table_(NULL),
       stub_cache_(NULL),
       deoptimizer_data_(NULL),
       materialized_object_store_(NULL),
       capture_stack_trace_for_uncaught_exceptions_(false),
       stack_trace_for_uncaught_exceptions_frame_limit_(0),
       stack_trace_for_uncaught_exceptions_options_(StackTrace::kOverview),
       memory_allocator_(NULL),
       keyed_lookup_cache_(NULL),
@@ skipping 40 matching lines @@
   // ThreadManager is initialized early to support locking an isolate
   // before it is entered.
   thread_manager_ = new ThreadManager();
   thread_manager_->isolate_ = this;
 
 #ifdef DEBUG
   // heap_histograms_ initializes itself.
   memset(&js_spill_information_, 0, sizeof(js_spill_information_));
 #endif
 
-  debug_ = NULL;
-  debugger_ = NULL;
-
   handle_scope_data_.Initialize();
 
 #define ISOLATE_INIT_EXECUTE(type, name, initial_value)                        \
   name##_ = (initial_value);
   ISOLATE_INIT_LIST(ISOLATE_INIT_EXECUTE)
 #undef ISOLATE_INIT_EXECUTE
 
 #define ISOLATE_INIT_ARRAY_EXECUTE(type, name, length)                         \
   memset(name##_, 0, sizeof(type) * length);
   ISOLATE_INIT_ARRAY_LIST(ISOLATE_INIT_ARRAY_EXECUTE)
 #undef ISOLATE_INIT_ARRAY_EXECUTE
+
+  InitializeLoggingAndCounters();
+  debug_ = new Debug(this);
+  debugger_ = new Debugger(this);
 }
 
 
 void Isolate::TearDown() {
   TRACE_ISOLATE(tear_down);
 
   // Temporarily set this isolate as current so that various parts of
   // the isolate can access it in their destructors without having a
   // direct pointer. We don't use Enter/Exit here to avoid
   // initializing the thread data.
@@ skipping 247 matching lines @@
 void Isolate::InitializeLoggingAndCounters() {
   if (logger_ == NULL) {
     logger_ = new Logger(this);
   }
   if (counters_ == NULL) {
     counters_ = new Counters(this);
   }
 }
 
 
-void Isolate::InitializeDebugger() {
-  LockGuard<RecursiveMutex> lock_guard(debugger_access());
-  if (NoBarrier_Load(&debugger_initialized_)) return;
-  InitializeLoggingAndCounters();
-  debug_ = new Debug(this);
-  debugger_ = new Debugger(this);
-  Release_Store(&debugger_initialized_, true);
-}
-
-
 bool Isolate::Init(Deserializer* des) {
   ASSERT(state_ != INITIALIZED);
   TRACE_ISOLATE(init);
 
   stress_deopt_count_ = FLAG_deopt_every_n_times;
 
   has_fatal_error_ = false;
 
   use_crankshaft_ = FLAG_crankshaft
       && !Serializer::enabled(this)
       && CpuFeatures::SupportsCrankshaft();
 
   if (function_entry_hook() != NULL) {
     // When function entry hooking is in effect, we have to create the code
     // stubs from scratch to get entry hooks, rather than loading the previously
     // generated stubs from disk.
     // If this assert fires, the initialization path has regressed.
     ASSERT(des == NULL);
   }
 
   // The initialization process does not handle memory exhaustion.
   DisallowAllocationFailure disallow_allocation_failure(this);
 
-  InitializeLoggingAndCounters();
-
-  InitializeDebugger();
-
   memory_allocator_ = new MemoryAllocator(this);
   code_range_ = new CodeRange(this);
 
   // Safe after setting Heap::isolate_, and initializing StackGuard
   heap_.SetStackLimits();
 
 #define ASSIGN_ELEMENT(CamelName, hacker_name)                  \
   isolate_addresses_[Isolate::k##CamelName##Address] =          \
       reinterpret_cast<Address>(hacker_name##_address());
   FOR_EACH_ISOLATE_ADDRESS_NAME(ASSIGN_ELEMENT)
@@ skipping 94 matching lines @@
   }
 
   if (num_sweeper_threads_ > 0) {
     sweeper_thread_ = new SweeperThread*[num_sweeper_threads_];
     for (int i = 0; i < num_sweeper_threads_; i++) {
       sweeper_thread_[i] = new SweeperThread(this);
       sweeper_thread_[i]->Start();
     }
   }
 
-  debug_->SetUp(create_heap_objects);
-
   // If we are deserializing, read the state into the now-empty heap.
   if (!create_heap_objects) {
     des->Deserialize(this);
   }
   stub_cache_->Initialize();
 
   // Finish initialization of ThreadLocal after deserialization is done.
   clear_pending_exception();
   clear_pending_message();
   clear_scheduled_exception();
@@ skipping 316 matching lines @@
   handle_scope_implementer()->IncrementCallDepth();
   if (run_microtasks) Execution::RunMicrotasks(this);
   for (int i = 0; i < call_completed_callbacks_.length(); i++) {
     call_completed_callbacks_.at(i)();
   }
   handle_scope_implementer()->DecrementCallDepth();
 }
 
 
 } }  // namespace v8::internal