Always include debugger support.

src/execution.cc

 // Copyright 2014 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 "execution.h"
 
 #include "bootstrapper.h"
 #include "codegen.h"
 #include "deoptimizer.h"
 #include "isolate-inl.h"
@@ skipping 85 matching lines @@
 
 #ifdef VERIFY_HEAP
   value->Verify();
 #endif
 
   // Update the pending exception flag and return the value.
   bool has_exception = value->IsException();
   ASSERT(has_exception == isolate->has_pending_exception());
   if (has_exception) {
     isolate->ReportPendingMessages();
-#ifdef ENABLE_DEBUGGER_SUPPORT
     // Reset stepping state when script exits with uncaught exception.
     if (isolate->debugger()->IsDebuggerActive()) {
       isolate->debug()->ClearStepping();
     }
-#endif  // ENABLE_DEBUGGER_SUPPORT
     return MaybeHandle<Object>();
   } else {
     isolate->clear_pending_message();
   }
 
   return Handle<Object>(value, isolate);
 }
 
 
 MaybeHandle<Object> Execution::Call(Isolate* isolate,
@@ skipping 349 matching lines @@
 }
 
 
 void StackGuard::DeoptMarkedAllocationSites() {
   ExecutionAccess access(isolate_);
   thread_local_.interrupt_flags_ |= DEOPT_MARKED_ALLOCATION_SITES;
   set_interrupt_limits(access);
 }
 
 
-#ifdef ENABLE_DEBUGGER_SUPPORT
 bool StackGuard::IsDebugBreak() {
   ExecutionAccess access(isolate_);
   return thread_local_.interrupt_flags_ & DEBUGBREAK;
 }
 
 
 void StackGuard::DebugBreak() {
   ExecutionAccess access(isolate_);
   thread_local_.interrupt_flags_ |= DEBUGBREAK;
   set_interrupt_limits(access);
 }
 
 
 bool StackGuard::IsDebugCommand() {
   ExecutionAccess access(isolate_);
   return thread_local_.interrupt_flags_ & DEBUGCOMMAND;
 }
 
 
 void StackGuard::DebugCommand() {
   ExecutionAccess access(isolate_);
   thread_local_.interrupt_flags_ |= DEBUGCOMMAND;
   set_interrupt_limits(access);
 }
-#endif
+
 
 void StackGuard::Continue(InterruptFlag after_what) {
   ExecutionAccess access(isolate_);
   thread_local_.interrupt_flags_ &= ~static_cast<int>(after_what);
   if (!should_postpone_interrupts(access) && !has_pending_interrupts(access)) {
     reset_limits(access);
   }
 }
 
 
@@ skipping 317 matching lines @@
   }
 
   return Handle<String>::cast(result);
 }
 
 
 static Object* RuntimePreempt(Isolate* isolate) {
   // Clear the preempt request flag.
   isolate->stack_guard()->Continue(PREEMPT);
 
-#ifdef ENABLE_DEBUGGER_SUPPORT
   if (isolate->debug()->InDebugger()) {
     // If currently in the debugger don't do any actual preemption but record
     // that preemption occoured while in the debugger.
     isolate->debug()->PreemptionWhileInDebugger();
   } else {
     // Perform preemption.
     v8::Unlocker unlocker(reinterpret_cast<v8::Isolate*>(isolate));
     Thread::YieldCPU();
   }
-#else
-  { // NOLINT
-    // Perform preemption.
-    v8::Unlocker unlocker(reinterpret_cast<v8::Isolate*>(isolate));
-    Thread::YieldCPU();
-  }
-#endif
 
   return isolate->heap()->undefined_value();
 }
 
 
-#ifdef ENABLE_DEBUGGER_SUPPORT
 Object* Execution::DebugBreakHelper(Isolate* isolate) {
   // Just continue if breaks are disabled.
   if (isolate->debug()->disable_break()) {
     return isolate->heap()->undefined_value();
   }
 
   // Ignore debug break during bootstrapping.
   if (isolate->bootstrapper()->IsActive()) {
     return isolate->heap()->undefined_value();
   }
@@ skipping 55 matching lines @@
   EnterDebugger debugger(isolate);
   if (debugger.FailedToEnter()) {
     return;
   }
 
   // Notify the debug event listeners. Indicate auto continue if the break was
   // a debug command break.
   isolate->debugger()->OnDebugBreak(isolate->factory()->undefined_value(),
                                     debug_command_only);
 }
-#endif
+
 
 Object* Execution::HandleStackGuardInterrupt(Isolate* isolate) {
   StackGuard* stack_guard = isolate->stack_guard();
   if (stack_guard->ShouldPostponeInterrupts()) {
     return isolate->heap()->undefined_value();
   }
 
   if (stack_guard->IsAPIInterrupt()) {
     stack_guard->InvokeInterruptCallback();
     stack_guard->Continue(API_INTERRUPT);
   }
 
   if (stack_guard->IsGCRequest()) {
     isolate->heap()->CollectAllGarbage(Heap::kNoGCFlags,
                                        "StackGuard GC request");
     stack_guard->Continue(GC_REQUEST);
   }
 
   isolate->counters()->stack_interrupts()->Increment();
   isolate->counters()->runtime_profiler_ticks()->Increment();
-#ifdef ENABLE_DEBUGGER_SUPPORT
   if (stack_guard->IsDebugBreak() || stack_guard->IsDebugCommand()) {
     DebugBreakHelper(isolate);
   }
-#endif
   if (stack_guard->IsPreempted()) RuntimePreempt(isolate);
   if (stack_guard->IsTerminateExecution()) {
     stack_guard->Continue(TERMINATE);
     return isolate->TerminateExecution();
   }
   if (stack_guard->IsInterrupted()) {
     stack_guard->Continue(INTERRUPT);
     return isolate->StackOverflow();
   }
   if (stack_guard->IsFullDeopt()) {
     stack_guard->Continue(FULL_DEOPT);
     Deoptimizer::DeoptimizeAll(isolate);
   }
   if (stack_guard->IsDeoptMarkedAllocationSites()) {
     stack_guard->Continue(DEOPT_MARKED_ALLOCATION_SITES);
     isolate->heap()->DeoptMarkedAllocationSites();
   }
   if (stack_guard->IsInstallCodeRequest()) {
     ASSERT(isolate->concurrent_recompilation_enabled());
     stack_guard->Continue(INSTALL_CODE);
     isolate->optimizing_compiler_thread()->InstallOptimizedFunctions();
   }
   isolate->runtime_profiler()->OptimizeNow();
   return isolate->heap()->undefined_value();
 }
 
 } }  // namespace v8::internal