Always include debugger support.

src/isolate.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 1034 matching lines @@
   bool should_report_exception =
       ShouldReportException(&can_be_caught_externally, catchable_by_javascript);
   bool report_exception = catchable_by_javascript && should_report_exception;
   bool try_catch_needs_message =
       can_be_caught_externally && try_catch_handler()->capture_message_ &&
       !thread_local_top()->rethrowing_message_;
   bool bootstrapping = bootstrapper()->IsActive();
 
   thread_local_top()->rethrowing_message_ = false;
 
-#ifdef ENABLE_DEBUGGER_SUPPORT
   // Notify debugger of exception.
   if (catchable_by_javascript) {
     debugger_->OnException(
         exception_handle, report_exception, factory()->undefined_value());
   }
-#endif
 
   // Generate the message if required.
   if (report_exception || try_catch_needs_message) {
     MessageLocation potential_computed_location;
     if (location == NULL) {
       // If no location was specified we use a computed one instead.
       ComputeLocation(&potential_computed_location);
       location = &potential_computed_location;
     }
     // It's not safe to try to make message objects or collect stack traces
@@ skipping 248 matching lines @@
 }
 
 
 Handle<Context> Isolate::global_context() {
   return Handle<Context>(context()->global_object()->global_context());
 }
 
 
 Handle<Context> Isolate::GetCallingNativeContext() {
   JavaScriptFrameIterator it(this);
-#ifdef ENABLE_DEBUGGER_SUPPORT
   if (debug_->InDebugger()) {
     while (!it.done()) {
       JavaScriptFrame* frame = it.frame();
       Context* context = Context::cast(frame->context());
       if (context->native_context() == *debug_->debug_context()) {
         it.Advance();
       } else {
         break;
       }
     }
   }
-#endif  // ENABLE_DEBUGGER_SUPPORT
   if (it.done()) return Handle<Context>::null();
   JavaScriptFrame* frame = it.frame();
   Context* context = Context::cast(frame->context());
   return Handle<Context>(context->native_context());
 }
 
 
 char* Isolate::ArchiveThread(char* to) {
   OS::MemCopy(to, reinterpret_cast<char*>(thread_local_top()),
               sizeof(ThreadLocalTop));
@@ skipping 151 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
 
-#ifdef ENABLE_DEBUGGER_SUPPORT
   debug_ = NULL;
   debugger_ = NULL;
-#endif
 
   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);
@@ skipping 35 matching lines @@
 
 void Isolate::GlobalTearDown() {
   delete thread_data_table_;
 }
 
 
 void Isolate::Deinit() {
   if (state_ == INITIALIZED) {
     TRACE_ISOLATE(deinit);
 
-#ifdef ENABLE_DEBUGGER_SUPPORT
     debugger()->UnloadDebugger();
-#endif
 
     if (concurrent_recompilation_enabled()) {
       optimizing_compiler_thread_->Stop();
       delete optimizing_compiler_thread_;
       optimizing_compiler_thread_ = NULL;
     }
 
     for (int i = 0; i < num_sweeper_threads_; i++) {
       sweeper_thread_[i]->Stop();
       delete sweeper_thread_[i];
@@ skipping 147 matching lines @@
 
   delete string_stream_debug_object_cache_;
   string_stream_debug_object_cache_ = NULL;
 
   delete external_reference_table_;
   external_reference_table_ = NULL;
 
   delete random_number_generator_;
   random_number_generator_ = NULL;
 
-#ifdef ENABLE_DEBUGGER_SUPPORT
   delete debugger_;
   debugger_ = NULL;
   delete debug_;
   debug_ = NULL;
-#endif
 }
 
 
 void Isolate::InitializeThreadLocal() {
   thread_local_top_.isolate_ = this;
   thread_local_top_.Initialize();
 }
 
 
 void Isolate::PropagatePendingExceptionToExternalTryCatch() {
@@ skipping 33 matching lines @@
   if (logger_ == NULL) {
     logger_ = new Logger(this);
   }
   if (counters_ == NULL) {
     counters_ = new Counters(this);
   }
 }
 
 
 void Isolate::InitializeDebugger() {
-#ifdef ENABLE_DEBUGGER_SUPPORT
   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);
-#endif
 }
 
 
 bool Isolate::Init(Deserializer* des) {
   ASSERT(state_ != INITIALIZED);
   TRACE_ISOLATE(init);
 
   stress_deopt_count_ = FLAG_deopt_every_n_times;
 
   has_fatal_error_ = false;
@@ skipping 124 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();
     }
   }
 
-#ifdef ENABLE_DEBUGGER_SUPPORT
   debug_->SetUp(create_heap_objects);
-#endif
 
   // 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();
@@ skipping 284 matching lines @@
       Handle<JSObject> obj = factory()->NewJSObjectFromMap(map);
       JSObject::NormalizeProperties(obj, KEEP_INOBJECT_PROPERTIES, 8);
       JSObject::SetProperty(registry, name, obj, NONE, STRICT).Assert();
     }
   }
   return Handle<JSObject>::cast(factory()->symbol_registry());
 }
 
 
 } }  // namespace v8::internal