Import a new V8 revision 1746.
r1746 can turn off debugger support to save code size.
diff --git a/v8/REVISION b/v8/REVISION
index 2996207..f745a4c 100644
--- a/v8/REVISION
+++ b/v8/REVISION
@@ -1 +1 @@
-https://v8.googlecode.com/svn/branches/bleeding_edge@1738
+https://v8.googlecode.com/svn/branches/bleeding_edge@1746
diff --git a/v8/SConstruct b/v8/SConstruct
index 1024a5b..0c8e3c0 100644
--- a/v8/SConstruct
+++ b/v8/SConstruct
@@ -94,6 +94,7 @@
'CCFLAGS': ['-g', '-O0'],
'CPPDEFINES': ['ENABLE_DISASSEMBLER', 'DEBUG'],
'os:android': {
+ 'CPPDEFINES': ['ENABLE_DEBUGGER_SUPPORT'],
'CCFLAGS': ['-mthumb']
}
},
@@ -102,7 +103,7 @@
'-ffunction-sections'],
'os:android': {
'CCFLAGS': ['-mthumb', '-Os'],
- 'CPPDEFINES': ['SK_RELEASE', 'NDEBUG']
+ 'CPPDEFINES': ['SK_RELEASE', 'NDEBUG', 'ENABLE_DEBUGGER_SUPPORT']
}
},
'os:linux': {
@@ -160,14 +161,18 @@
}
},
'mode:release': {
- 'CCFLAGS': ['/O2', '/GL'],
- 'LINKFLAGS': ['/OPT:REF', '/OPT:ICF', '/LTCG'],
- 'ARFLAGS': ['/LTCG'],
+ 'CCFLAGS': ['/O2'],
+ 'LINKFLAGS': ['/OPT:REF', '/OPT:ICF'],
'msvcrt:static': {
'CCFLAGS': ['/MT']
},
'msvcrt:shared': {
'CCFLAGS': ['/MD']
+ },
+ 'msvcltcg:on': {
+ 'CCFLAGS': ['/GL'],
+ 'LINKFLAGS': ['/LTCG'],
+ 'ARFLAGS': ['/LTCG'],
}
},
}
@@ -360,12 +365,16 @@
},
'mode:release': {
'CCFLAGS': ['/O2'],
- 'LINKFLAGS': ['/OPT:REF', '/OPT:ICF', '/LTCG'],
+ 'LINKFLAGS': ['/OPT:REF', '/OPT:ICF'],
'msvcrt:static': {
'CCFLAGS': ['/MT']
},
'msvcrt:shared': {
'CCFLAGS': ['/MD']
+ },
+ 'msvcltcg:on': {
+ 'CCFLAGS': ['/GL'],
+ 'LINKFLAGS': ['/LTCG'],
}
},
'mode:debug': {
@@ -474,7 +483,12 @@
'msvcrt': {
'values': ['static', 'shared'],
'default': 'static',
- 'help': 'the type of MSVCRT library to use'
+ 'help': 'the type of Microsoft Visual C++ runtime library to use'
+ },
+ 'msvcltcg': {
+ 'values': ['on', 'off'],
+ 'default': 'on',
+ 'help': 'use Microsoft Visual C++ link-time code generation'
},
'wordsize': {
'values': ['64', '32'],
diff --git a/v8/src/api.cc b/v8/src/api.cc
index a5af312..ca76c5e 100644
--- a/v8/src/api.cc
+++ b/v8/src/api.cc
@@ -3180,7 +3180,7 @@
// --- D e b u g S u p p o r t ---
-
+#ifdef ENABLE_DEBUGGER_SUPPORT
bool Debug::SetDebugEventListener(DebugEventCallback that, Handle<Value> data) {
EnsureInitialized("v8::Debug::SetDebugEventListener()");
ON_BAILOUT("v8::Debug::SetDebugEventListener()", return false);
@@ -3263,7 +3263,7 @@
bool Debug::EnableAgent(const char* name, int port) {
return i::Debugger::StartAgent(name, port);
}
-
+#endif // ENABLE_DEBUGGER_SUPPORT
namespace internal {
diff --git a/v8/src/assembler.cc b/v8/src/assembler.cc
index 977be7d..ec0e4fd 100644
--- a/v8/src/assembler.cc
+++ b/v8/src/assembler.cc
@@ -521,10 +521,10 @@
ExternalReference::ExternalReference(const IC_Utility& ic_utility)
: address_(ic_utility.address()) {}
-
+#ifdef ENABLE_DEBUGGER_SUPPORT
ExternalReference::ExternalReference(const Debug_Address& debug_address)
: address_(debug_address.address()) {}
-
+#endif
ExternalReference::ExternalReference(StatsCounter* counter)
: address_(reinterpret_cast<Address>(counter->GetInternalPointer())) {}
@@ -557,31 +557,25 @@
}
-ExternalReference ExternalReference::debug_break() {
- return ExternalReference(FUNCTION_ADDR(Debug::Break));
-}
-
-
ExternalReference ExternalReference::new_space_start() {
return ExternalReference(Heap::NewSpaceStart());
}
+
ExternalReference ExternalReference::new_space_allocation_top_address() {
return ExternalReference(Heap::NewSpaceAllocationTopAddress());
}
+
ExternalReference ExternalReference::heap_always_allocate_scope_depth() {
return ExternalReference(Heap::always_allocate_scope_depth_address());
}
+
ExternalReference ExternalReference::new_space_allocation_limit_address() {
return ExternalReference(Heap::NewSpaceAllocationLimitAddress());
}
-ExternalReference ExternalReference::debug_step_in_fp_address() {
- return ExternalReference(Debug::step_in_fp_addr());
-}
-
static double add_two_doubles(double x, double y) {
return x + y;
@@ -618,4 +612,16 @@
return ExternalReference(FUNCTION_ADDR(function));
}
+
+#ifdef ENABLE_DEBUGGER_SUPPORT
+ExternalReference ExternalReference::debug_break() {
+ return ExternalReference(FUNCTION_ADDR(Debug::Break));
+}
+
+
+ExternalReference ExternalReference::debug_step_in_fp_address() {
+ return ExternalReference(Debug::step_in_fp_addr());
+}
+#endif
+
} } // namespace v8::internal
diff --git a/v8/src/assembler.h b/v8/src/assembler.h
index 0352a70..8abdbc7 100644
--- a/v8/src/assembler.h
+++ b/v8/src/assembler.h
@@ -346,8 +346,10 @@
//----------------------------------------------------------------------------
class IC_Utility;
-class Debug_Address;
class SCTableReference;
+#ifdef ENABLE_DEBUGGER_SUPPORT
+class Debug_Address;
+#endif
// An ExternalReference represents a C++ address called from the generated
// code. All references to C++ functions and must be encapsulated in an
@@ -365,7 +367,9 @@
explicit ExternalReference(const IC_Utility& ic_utility);
+#ifdef ENABLE_DEBUGGER_SUPPORT
explicit ExternalReference(const Debug_Address& debug_address);
+#endif
explicit ExternalReference(StatsCounter* counter);
@@ -388,9 +392,6 @@
// Static variable RegExpStack::limit_address()
static ExternalReference address_of_regexp_stack_limit();
- // Function Debug::Break()
- static ExternalReference debug_break();
-
// Static variable Heap::NewSpaceStart()
static ExternalReference new_space_start();
static ExternalReference heap_always_allocate_scope_depth();
@@ -399,13 +400,18 @@
static ExternalReference new_space_allocation_top_address();
static ExternalReference new_space_allocation_limit_address();
- // Used to check if single stepping is enabled in generated code.
- static ExternalReference debug_step_in_fp_address();
-
static ExternalReference double_fp_operation(Token::Value operation);
Address address() const {return address_;}
+#ifdef ENABLE_DEBUGGER_SUPPORT
+ // Function Debug::Break()
+ static ExternalReference debug_break();
+
+ // Used to check if single stepping is enabled in generated code.
+ static ExternalReference debug_step_in_fp_address();
+#endif
+
private:
explicit ExternalReference(void* address)
: address_(reinterpret_cast<Address>(address)) {}
diff --git a/v8/src/bootstrapper.cc b/v8/src/bootstrapper.cc
index 0a0ed83..d1b638c 100644
--- a/v8/src/bootstrapper.cc
+++ b/v8/src/bootstrapper.cc
@@ -832,12 +832,16 @@
bool Genesis::CompileNative(Vector<const char> name, Handle<String> source) {
HandleScope scope;
+#ifdef ENABLE_DEBUGGER_SUPPORT
Debugger::set_compiling_natives(true);
+#endif
bool result =
CompileScriptCached(name, source, &natives_cache, NULL, true);
ASSERT(Top::has_pending_exception() != result);
if (!result) Top::clear_pending_exception();
+#ifdef ENABLE_DEBUGGER_SUPPORT
Debugger::set_compiling_natives(false);
+#endif
return result;
}
@@ -1132,6 +1136,7 @@
Handle<JSObject>(js_global->builtins()), DONT_ENUM);
}
+#ifdef ENABLE_DEBUGGER_SUPPORT
// Expose the debug global object in global if a name for it is specified.
if (FLAG_expose_debug_as != NULL && strlen(FLAG_expose_debug_as) != 0) {
// If loading fails we just bail out without installing the
@@ -1149,6 +1154,7 @@
SetProperty(js_global, debug_string,
Handle<Object>(Debug::debug_context()->global_proxy()), DONT_ENUM);
}
+#endif
return true;
}
diff --git a/v8/src/builtins-ia32.cc b/v8/src/builtins-ia32.cc
index 0e9de8c..ac84b76 100644
--- a/v8/src/builtins-ia32.cc
+++ b/v8/src/builtins-ia32.cc
@@ -69,10 +69,12 @@
Label rt_call, allocated;
if (FLAG_inline_new) {
Label undo_allocation;
+#ifdef ENABLE_DEBUGGER_SUPPORT
ExternalReference debug_step_in_fp =
ExternalReference::debug_step_in_fp_address();
__ cmp(Operand::StaticVariable(debug_step_in_fp), Immediate(0));
__ j(not_equal, &rt_call);
+#endif
// Check that function is not a Smi.
__ test(edi, Immediate(kSmiTagMask));
__ j(zero, &rt_call);
diff --git a/v8/src/builtins.cc b/v8/src/builtins.cc
index c3935f1..b27974f 100644
--- a/v8/src/builtins.cc
+++ b/v8/src/builtins.cc
@@ -559,6 +559,7 @@
}
+#ifdef ENABLE_DEBUGGER_SUPPORT
static void Generate_LoadIC_DebugBreak(MacroAssembler* masm) {
Debug::GenerateLoadICDebugBreak(masm);
}
@@ -597,7 +598,7 @@
static void Generate_StubNoRegisters_DebugBreak(MacroAssembler* masm) {
Debug::GenerateStubNoRegistersDebugBreak(masm);
}
-
+#endif
Object* Builtins::builtins_[builtin_count] = { NULL, };
const char* Builtins::names_[builtin_count] = { NULL, };
diff --git a/v8/src/builtins.h b/v8/src/builtins.h
index 853c90e..4e74a3c 100644
--- a/v8/src/builtins.h
+++ b/v8/src/builtins.h
@@ -83,6 +83,7 @@
V(FunctionApply, BUILTIN, UNINITIALIZED)
+#ifdef ENABLE_DEBUGGER_SUPPORT
// Define list of builtins used by the debugger implemented in assembly.
#define BUILTIN_LIST_DEBUG_A(V) \
V(Return_DebugBreak, BUILTIN, DEBUG_BREAK) \
@@ -93,7 +94,9 @@
V(KeyedLoadIC_DebugBreak, KEYED_LOAD_IC, DEBUG_BREAK) \
V(StoreIC_DebugBreak, STORE_IC, DEBUG_BREAK) \
V(KeyedStoreIC_DebugBreak, KEYED_STORE_IC, DEBUG_BREAK)
-
+#else
+#define BUILTIN_LIST_DEBUG_A(V)
+#endif
// Define list of builtins implemented in JavaScript.
#define BUILTINS_LIST_JS(V) \
diff --git a/v8/src/codegen-arm.cc b/v8/src/codegen-arm.cc
index 2386b97..5a4f6f5 100644
--- a/v8/src/codegen-arm.cc
+++ b/v8/src/codegen-arm.cc
@@ -2335,7 +2335,9 @@
VirtualFrame::SpilledScope spilled_scope(this);
Comment cmnt(masm_, "[ DebuggerStatament");
CodeForStatementPosition(node);
+#ifdef ENABLE_DEBUGGER_SUPPORT
frame_->CallRuntime(Runtime::kDebugBreak, 0);
+#endif
// Ignore the return value.
ASSERT(frame_->height() == original_height);
}
diff --git a/v8/src/codegen-ia32.cc b/v8/src/codegen-ia32.cc
index 47c3538..aa64377 100644
--- a/v8/src/codegen-ia32.cc
+++ b/v8/src/codegen-ia32.cc
@@ -3179,10 +3179,12 @@
ASSERT(!in_spilled_code());
Comment cmnt(masm_, "[ DebuggerStatement");
CodeForStatementPosition(node);
+#ifdef ENABLE_DEBUGGER_SUPPORT
// Spill everything, even constants, to the frame.
frame_->SpillAll();
frame_->CallRuntime(Runtime::kDebugBreak, 0);
// Ignore the return value.
+#endif
}
diff --git a/v8/src/codegen.cc b/v8/src/codegen.cc
index edc498d..ed7ee2f 100644
--- a/v8/src/codegen.cc
+++ b/v8/src/codegen.cc
@@ -304,8 +304,10 @@
node->is_expression(), false, script_,
node->inferred_name());
+#ifdef ENABLE_DEBUGGER_SUPPORT
// Notify debugger that a new function has been added.
Debugger::OnNewFunction(function);
+#endif
// Set the expected number of properties for instances and return
// the resulting function.
diff --git a/v8/src/compiler.cc b/v8/src/compiler.cc
index 63fed4a..62e838e 100644
--- a/v8/src/compiler.cc
+++ b/v8/src/compiler.cc
@@ -92,8 +92,10 @@
StackGuard guard;
PostponeInterruptsScope postpone;
+#ifdef ENABLE_DEBUGGER_SUPPORT
// Notify debugger
Debugger::OnBeforeCompile(script);
+#endif
// Only allow non-global compiles for eval.
ASSERT(is_eval || is_global);
@@ -160,8 +162,10 @@
// the instances of the function.
SetExpectedNofPropertiesFromEstimate(fun, lit->expected_property_count());
+#ifdef ENABLE_DEBUGGER_SUPPORT
// Notify debugger
Debugger::OnAfterCompile(script, fun);
+#endif
return fun;
}
diff --git a/v8/src/d8.cc b/v8/src/d8.cc
index 9648168..70143c3 100644
--- a/v8/src/d8.cc
+++ b/v8/src/d8.cc
@@ -163,6 +163,22 @@
}
+Handle<Value> Shell::Read(const Arguments& args) {
+ if (args.Length() != 1) {
+ return ThrowException(String::New("Bad parameters"));
+ }
+ String::Utf8Value file(args[0]);
+ if (*file == NULL) {
+ return ThrowException(String::New("Error loading file"));
+ }
+ Handle<String> source = ReadFile(*file);
+ if (source.IsEmpty()) {
+ return ThrowException(String::New("Error loading file"));
+ }
+ return source;
+}
+
+
Handle<Value> Shell::Load(const Arguments& args) {
for (int i = 0; i < args.Length(); i++) {
HandleScope handle_scope;
@@ -246,6 +262,7 @@
}
+#ifdef ENABLE_DEBUGGER_SUPPORT
Handle<Object> Shell::DebugMessageDetails(Handle<String> message) {
Context::Scope context_scope(utility_context_);
Handle<Object> global = utility_context_->Global();
@@ -266,6 +283,7 @@
Handle<Value> val = Handle<Function>::Cast(fun)->Call(global, kArgc, argv);
return val;
}
+#endif
int32_t* Counter::Bind(const char* name, bool is_histogram) {
@@ -381,6 +399,7 @@
HandleScope scope;
Handle<ObjectTemplate> global_template = ObjectTemplate::New();
global_template->Set(String::New("print"), FunctionTemplate::New(Print));
+ global_template->Set(String::New("read"), FunctionTemplate::New(Read));
global_template->Set(String::New("load"), FunctionTemplate::New(Load));
global_template->Set(String::New("quit"), FunctionTemplate::New(Quit));
global_template->Set(String::New("version"), FunctionTemplate::New(Version));
@@ -406,11 +425,13 @@
global_template->Set(String::New("arguments"),
Utils::ToLocal(arguments_jsarray));
+#ifdef ENABLE_DEBUGGER_SUPPORT
// Install the debugger object in the utility scope
i::Debug::Load();
i::JSObject* debug = i::Debug::debug_context()->global();
utility_context_->Global()->Set(String::New("$debug"),
Utils::ToLocal(&debug));
+#endif
// Run the d8 shell utility script in the utility context
int source_index = i::NativesCollection<i::D8>::GetIndex("d8");
@@ -436,8 +457,10 @@
evaluation_context_ = Context::New(NULL, global_template);
evaluation_context_->SetSecurityToken(Undefined());
+#ifdef ENABLE_DEBUGGER_SUPPORT
// Set the security token of the debug context to allow access.
i::Debug::debug_context()->set_security_token(i::Heap::undefined_value());
+#endif
}
@@ -555,6 +578,8 @@
Handle<ObjectTemplate> global_template = ObjectTemplate::New();
global_template->Set(String::New("print"),
FunctionTemplate::New(Shell::Print));
+ global_template->Set(String::New("read"),
+ FunctionTemplate::New(Shell::Read));
global_template->Set(String::New("load"),
FunctionTemplate::New(Shell::Load));
global_template->Set(String::New("yield"),
@@ -690,6 +715,7 @@
Locker::StartPreemption(preemption_interval);
}
+#ifdef ENABLE_DEBUGGER_SUPPORT
// Run the remote debugger if requested.
if (i::FLAG_remote_debugger) {
RunRemoteDebugger(i::FLAG_debugger_port);
@@ -705,6 +731,7 @@
if (i::FLAG_debugger && !i::FLAG_debugger_agent) {
v8::Debug::SetDebugEventListener(HandleDebugEvent);
}
+#endif
}
if (run_shell)
RunShell();
diff --git a/v8/src/d8.h b/v8/src/d8.h
index 342a0d2..092e3a3 100644
--- a/v8/src/d8.h
+++ b/v8/src/d8.h
@@ -132,13 +132,16 @@
static int Main(int argc, char* argv[]);
static Handle<Array> GetCompletions(Handle<String> text,
Handle<String> full);
+#ifdef ENABLE_DEBUGGER_SUPPORT
static Handle<Object> DebugMessageDetails(Handle<String> message);
static Handle<Value> DebugCommandToJSONRequest(Handle<String> command);
+#endif
static Handle<Value> Print(const Arguments& args);
static Handle<Value> Yield(const Arguments& args);
static Handle<Value> Quit(const Arguments& args);
static Handle<Value> Version(const Arguments& args);
+ static Handle<Value> Read(const Arguments& args);
static Handle<Value> Load(const Arguments& args);
// The OS object on the global object contains methods for performing
// operating system calls:
diff --git a/v8/src/debug-agent.cc b/v8/src/debug-agent.cc
index e865e0e..24d89b0 100644
--- a/v8/src/debug-agent.cc
+++ b/v8/src/debug-agent.cc
@@ -29,9 +29,9 @@
#include "v8.h"
#include "debug-agent.h"
+#ifdef ENABLE_DEBUGGER_SUPPORT
namespace v8 { namespace internal {
-
// Public V8 debugger API message handler function. This function just delegates
// to the debugger agent through it's data parameter.
void DebuggerAgentMessageHandler(const uint16_t* message, int length,
@@ -410,5 +410,6 @@
return total_received;
}
-
} } // namespace v8::internal
+
+#endif // ENABLE_DEBUGGER_SUPPORT
diff --git a/v8/src/debug-agent.h b/v8/src/debug-agent.h
index 177af0c..54dc683 100644
--- a/v8/src/debug-agent.h
+++ b/v8/src/debug-agent.h
@@ -28,12 +28,12 @@
#ifndef V8_V8_DEBUG_AGENT_H_
#define V8_V8_DEBUG_AGENT_H_
+#ifdef ENABLE_DEBUGGER_SUPPORT
#include "../include/v8-debug.h"
#include "platform.h"
namespace v8 { namespace internal {
-
// Forward decelrations.
class DebuggerAgentSession;
@@ -111,7 +111,8 @@
static int ReceiveAll(const Socket* conn, char* data, int len);
};
-
} } // namespace v8::internal
+#endif // ENABLE_DEBUGGER_SUPPORT
+
#endif // V8_V8_DEBUG_AGENT_H_
diff --git a/v8/src/debug-arm.cc b/v8/src/debug-arm.cc
index f935a8f..db14ed0 100644
--- a/v8/src/debug-arm.cc
+++ b/v8/src/debug-arm.cc
@@ -32,7 +32,7 @@
namespace v8 { namespace internal {
-
+#ifdef ENABLE_DEBUGGER_SUPPORT
// Currently debug break is not supported in frame exit code on ARM.
bool BreakLocationIterator::IsDebugBreakAtReturn() {
return false;
@@ -191,5 +191,6 @@
#undef __
+#endif // ENABLE_DEBUGGER_SUPPORT
} } // namespace v8::internal
diff --git a/v8/src/debug-ia32.cc b/v8/src/debug-ia32.cc
index 6d59889..c9b9e49 100644
--- a/v8/src/debug-ia32.cc
+++ b/v8/src/debug-ia32.cc
@@ -33,6 +33,7 @@
namespace v8 { namespace internal {
+#ifdef ENABLE_DEBUGGER_SUPPORT
// A debug break in the frame exit code is identified by a call instruction.
bool BreakLocationIterator::IsDebugBreakAtReturn() {
@@ -214,5 +215,6 @@
#undef __
+#endif // ENABLE_DEBUGGER_SUPPORT
} } // namespace v8::internal
diff --git a/v8/src/debug.cc b/v8/src/debug.cc
index a4bb04d..99ae423 100644
--- a/v8/src/debug.cc
+++ b/v8/src/debug.cc
@@ -41,6 +41,7 @@
namespace v8 { namespace internal {
+#ifdef ENABLE_DEBUGGER_SUPPORT
static void PrintLn(v8::Local<v8::Value> value) {
v8::Local<v8::String> s = value->ToString();
char* data = NewArray<char>(s->Length() + 1);
@@ -2223,5 +2224,6 @@
queue_.Clear();
}
+#endif // ENABLE_DEBUGGER_SUPPORT
} } // namespace v8::internal
diff --git a/v8/src/debug.h b/v8/src/debug.h
index 8822c50..e46b816 100644
--- a/v8/src/debug.h
+++ b/v8/src/debug.h
@@ -28,7 +28,6 @@
#ifndef V8_V8_DEBUG_H_
#define V8_V8_DEBUG_H_
-#include "../include/v8-debug.h"
#include "assembler.h"
#include "code-stubs.h"
#include "debug-agent.h"
@@ -38,6 +37,8 @@
#include "string-stream.h"
#include "v8threads.h"
+#ifdef ENABLE_DEBUGGER_SUPPORT
+#include "../include/v8-debug.h"
namespace v8 { namespace internal {
@@ -719,4 +720,6 @@
} } // namespace v8::internal
+#endif // ENABLE_DEBUGGER_SUPPORT
+
#endif // V8_V8_DEBUG_H_
diff --git a/v8/src/execution.cc b/v8/src/execution.cc
index 03017d0..be04a5b 100644
--- a/v8/src/execution.cc
+++ b/v8/src/execution.cc
@@ -305,6 +305,7 @@
}
+#ifdef ENABLE_DEBUGGER_SUPPORT
bool StackGuard::IsDebugBreak() {
ExecutionAccess access;
return thread_local_.interrupt_flags_ & DEBUGBREAK;
@@ -331,7 +332,7 @@
set_limits(kInterruptLimit, access);
}
}
-
+#endif
void StackGuard::Continue(InterruptFlag after_what) {
ExecutionAccess access;
@@ -539,6 +540,7 @@
ContextSwitcher::PreemptionReceived();
+#ifdef ENABLE_DEBUGGER_SUPPORT
if (Debug::InDebugger()) {
// If currently in the debugger don't do any actual preemption but record
// that preemption occoured while in the debugger.
@@ -548,11 +550,17 @@
v8::Unlocker unlocker;
Thread::YieldCPU();
}
+#else
+ // Perform preemption.
+ v8::Unlocker unlocker;
+ Thread::YieldCPU();
+#endif
return Heap::undefined_value();
}
+#ifdef ENABLE_DEBUGGER_SUPPORT
Object* Execution::DebugBreakHelper() {
// Just continue if breaks are disabled.
if (Debug::disable_break()) {
@@ -598,12 +606,14 @@
// Return to continue execution.
return Heap::undefined_value();
}
-
+#endif
Object* Execution::HandleStackGuardInterrupt() {
+#ifdef ENABLE_DEBUGGER_SUPPORT
if (StackGuard::IsDebugBreak() || StackGuard::IsDebugCommand()) {
DebugBreakHelper();
}
+#endif
if (StackGuard::IsPreempted()) RuntimePreempt();
if (StackGuard::IsInterrupted()) {
// interrupt
diff --git a/v8/src/execution.h b/v8/src/execution.h
index 6531572..6f2f689 100644
--- a/v8/src/execution.h
+++ b/v8/src/execution.h
@@ -118,8 +118,9 @@
Handle<JSFunction> fun,
Handle<Object> pos,
Handle<Object> is_global);
-
+#ifdef ENABLE_DEBUGGER_SUPPORT
static Object* DebugBreakHelper();
+#endif
// If the stack guard is triggered, but it is not an actual
// stack overflow, then handle the interruption accordingly.
@@ -158,11 +159,13 @@
static void Preempt();
static bool IsInterrupted();
static void Interrupt();
- static bool IsDebugBreak();
- static void DebugBreak();
- static bool IsDebugCommand();
- static void DebugCommand();
static void Continue(InterruptFlag after_what);
+#ifdef ENABLE_DEBUGGER_SUPPORT
+ static void DebugBreak();
+ static void DebugCommand();
+ static bool IsDebugBreak();
+ static bool IsDebugCommand();
+#endif
private:
// You should hold the ExecutionAccess lock when calling this method.
diff --git a/v8/src/factory.cc b/v8/src/factory.cc
index e29c84d..2d126a7 100644
--- a/v8/src/factory.cc
+++ b/v8/src/factory.cc
@@ -671,6 +671,7 @@
}
+#ifdef ENABLE_DEBUGGER_SUPPORT
Handle<DebugInfo> Factory::NewDebugInfo(Handle<SharedFunctionInfo> shared) {
// Get the original code of the function.
Handle<Code> code(shared->code());
@@ -700,6 +701,7 @@
return debug_info;
}
+#endif
Handle<JSObject> Factory::NewArgumentsObject(Handle<Object> callee,
diff --git a/v8/src/factory.h b/v8/src/factory.h
index 2564c3c..54f2089 100644
--- a/v8/src/factory.h
+++ b/v8/src/factory.h
@@ -310,8 +310,9 @@
uint32_t key,
Handle<Object> value);
+#ifdef ENABLE_DEBUGGER_SUPPORT
static Handle<DebugInfo> NewDebugInfo(Handle<SharedFunctionInfo> shared);
-
+#endif
// Return a map using the map cache in the global context.
// The key the an ordered set of property names.
diff --git a/v8/src/handles.cc b/v8/src/handles.cc
index a834564..b023201 100644
--- a/v8/src/handles.cc
+++ b/v8/src/handles.cc
@@ -652,6 +652,7 @@
// We shouldn't get here if compiling the script failed.
ASSERT(!boilerplate.is_null());
+#ifdef ENABLE_DEBUGGER_SUPPORT
// When the debugger running in its own context touches lazy loaded
// functions loading can be triggered. In that case ensure that the
// execution of the boilerplate is in the correct context.
@@ -660,6 +661,7 @@
Top::context() == *Debug::debug_context()) {
Top::set_context(*compile_context);
}
+#endif
// Reset the lazy load data before running the script to make sure
// not to get recursive lazy loading.
diff --git a/v8/src/heap.cc b/v8/src/heap.cc
index 7a8b728..a57884c 100644
--- a/v8/src/heap.cc
+++ b/v8/src/heap.cc
@@ -2679,7 +2679,10 @@
SYNCHRONIZE_TAG("bootstrapper");
Top::Iterate(v);
SYNCHRONIZE_TAG("top");
+
+#ifdef ENABLE_DEBUGGER_SUPPORT
Debug::Iterate(v);
+#endif
SYNCHRONIZE_TAG("debug");
CompilationCache::Iterate(v);
SYNCHRONIZE_TAG("compilationcache");
diff --git a/v8/src/ic-inl.h b/v8/src/ic-inl.h
index f5ce0ad..bb56962 100644
--- a/v8/src/ic-inl.h
+++ b/v8/src/ic-inl.h
@@ -39,6 +39,7 @@
// Get the address of the call.
Address result = pc() - Assembler::kTargetAddrToReturnAddrDist;
+#ifdef ENABLE_DEBUGGER_SUPPORT
// First check if any break points are active if not just return the address
// of the call.
if (!Debug::has_break_points()) return result;
@@ -55,6 +56,9 @@
// No break point here just return the address of the call.
return result;
}
+#else
+ return result;
+#endif
}
diff --git a/v8/src/ic.cc b/v8/src/ic.cc
index d7bd764..a8ae1b6 100644
--- a/v8/src/ic.cc
+++ b/v8/src/ic.cc
@@ -100,6 +100,7 @@
}
+#ifdef ENABLE_DEBUGGER_SUPPORT
Address IC::OriginalCodeAddress() {
HandleScope scope;
// Compute the JavaScript frame for the frame pointer of this IC
@@ -126,7 +127,7 @@
int delta = original_code->instruction_start() - code->instruction_start();
return addr + delta;
}
-
+#endif
IC::State IC::StateFrom(Code* target, Object* receiver) {
IC::State state = target->ic_state();
@@ -356,6 +357,7 @@
if (opt->IsJSFunction()) return opt;
}
+#ifdef ENABLE_DEBUGGER_SUPPORT
// Handle stepping into a function if step into is active.
if (Debug::StepInActive()) {
// Protect the result in a handle as the debugger can allocate and might
@@ -365,6 +367,7 @@
Debug::HandleStepIn(function, fp(), false);
return *function;
}
+#endif
return result;
}
diff --git a/v8/src/ic.h b/v8/src/ic.h
index bbe1f6d..d79b436 100644
--- a/v8/src/ic.h
+++ b/v8/src/ic.h
@@ -107,9 +107,11 @@
Address fp() const { return fp_; }
Address pc() const { return *pc_address_; }
+#ifdef ENABLE_DEBUGGER_SUPPORT
// Computes the address in the original code when the code running is
// containing break points (calls to DebugBreakXXX builtins).
Address OriginalCodeAddress();
+#endif
// Set the call-site target.
void set_target(Code* code) { SetTargetAtAddress(address(), code); }
diff --git a/v8/src/macro-assembler-arm.cc b/v8/src/macro-assembler-arm.cc
index ef2ffab..b2994c9 100644
--- a/v8/src/macro-assembler-arm.cc
+++ b/v8/src/macro-assembler-arm.cc
@@ -320,16 +320,19 @@
add(r6, fp, Operand(r4, LSL, kPointerSizeLog2));
add(r6, r6, Operand(ExitFrameConstants::kPPDisplacement - kPointerSize));
+#ifdef ENABLE_DEBUGGER_SUPPORT
// Save the state of all registers to the stack from the memory
// location. This is needed to allow nested break points.
if (type == StackFrame::EXIT_DEBUG) {
// Use sp as base to push.
CopyRegistersFromMemoryToStack(sp, kJSCallerSaved);
}
+#endif
}
void MacroAssembler::LeaveExitFrame(StackFrame::Type type) {
+#ifdef ENABLE_DEBUGGER_SUPPORT
// Restore the memory copy of the registers by digging them out from
// the stack. This is needed to allow nested break points.
if (type == StackFrame::EXIT_DEBUG) {
@@ -339,6 +342,7 @@
add(r3, fp, Operand(kOffset));
CopyRegistersFromStackToMemory(r3, r2, kJSCallerSaved);
}
+#endif
// Clear top frame.
mov(r3, Operand(0));
@@ -491,6 +495,7 @@
}
+#ifdef ENABLE_DEBUGGER_SUPPORT
void MacroAssembler::SaveRegistersToMemory(RegList regs) {
ASSERT((regs & ~kJSCallerSaved) == 0);
// Copy the content of registers to memory location.
@@ -548,7 +553,7 @@
}
}
}
-
+#endif
void MacroAssembler::PushTryHandler(CodeLocation try_location,
HandlerType type) {
diff --git a/v8/src/macro-assembler-arm.h b/v8/src/macro-assembler-arm.h
index 60ef77a..ed2a2a4 100644
--- a/v8/src/macro-assembler-arm.h
+++ b/v8/src/macro-assembler-arm.h
@@ -138,6 +138,7 @@
InvokeFlag flag);
+#ifdef ENABLE_DEBUGGER_SUPPORT
// ---------------------------------------------------------------------------
// Debugger Support
@@ -147,7 +148,7 @@
void CopyRegistersFromStackToMemory(Register base,
Register scratch,
RegList regs);
-
+#endif
// ---------------------------------------------------------------------------
// Exception handling
diff --git a/v8/src/macro-assembler-ia32.cc b/v8/src/macro-assembler-ia32.cc
index 4fad3be..8b8e6fd 100644
--- a/v8/src/macro-assembler-ia32.cc
+++ b/v8/src/macro-assembler-ia32.cc
@@ -216,6 +216,7 @@
}
+#ifdef ENABLE_DEBUGGER_SUPPORT
void MacroAssembler::SaveRegistersToMemory(RegList regs) {
ASSERT((regs & ~kJSCallerSaved) == 0);
// Copy the content of registers to memory location.
@@ -290,7 +291,7 @@
}
}
}
-
+#endif
void MacroAssembler::Set(Register dst, const Immediate& x) {
if (x.is_zero()) {
@@ -378,6 +379,7 @@
mov(edi, Operand(eax));
lea(esi, Operand(ebp, eax, times_4, offset));
+#ifdef ENABLE_DEBUGGER_SUPPORT
// Save the state of all registers to the stack from the memory
// location. This is needed to allow nested break points.
if (type == StackFrame::EXIT_DEBUG) {
@@ -389,6 +391,7 @@
// associated with this issue).
PushRegistersFromMemory(kJSCallerSaved);
}
+#endif
// Reserve space for two arguments: argc and argv.
sub(Operand(esp), Immediate(2 * kPointerSize));
@@ -406,6 +409,7 @@
void MacroAssembler::LeaveExitFrame(StackFrame::Type type) {
+#ifdef ENABLE_DEBUGGER_SUPPORT
// Restore the memory copy of the registers by digging them out from
// the stack. This is needed to allow nested break points.
if (type == StackFrame::EXIT_DEBUG) {
@@ -416,6 +420,7 @@
lea(ebx, Operand(ebp, kOffset));
CopyRegistersFromStackToMemory(ebx, ecx, kJSCallerSaved);
}
+#endif
// Get the return address from the stack and restore the frame pointer.
mov(ecx, Operand(ebp, 1 * kPointerSize));
diff --git a/v8/src/macro-assembler-ia32.h b/v8/src/macro-assembler-ia32.h
index 40aa84a..5d87381 100644
--- a/v8/src/macro-assembler-ia32.h
+++ b/v8/src/macro-assembler-ia32.h
@@ -73,7 +73,7 @@
Register value,
Register scratch);
-
+#ifdef ENABLE_DEBUGGER_SUPPORT
// ---------------------------------------------------------------------------
// Debugger Support
@@ -84,7 +84,7 @@
void CopyRegistersFromStackToMemory(Register base,
Register scratch,
RegList regs);
-
+#endif
// ---------------------------------------------------------------------------
// Activation frames
diff --git a/v8/src/objects-inl.h b/v8/src/objects-inl.h
index c2143ea..50608f7 100644
--- a/v8/src/objects-inl.h
+++ b/v8/src/objects-inl.h
@@ -2057,6 +2057,7 @@
ACCESSORS(Script, type, Smi, kTypeOffset)
ACCESSORS(Script, line_ends, Object, kLineEndsOffset)
+#ifdef ENABLE_DEBUGGER_SUPPORT
ACCESSORS(DebugInfo, shared, SharedFunctionInfo, kSharedFunctionInfoIndex)
ACCESSORS(DebugInfo, original_code, Code, kOriginalCodeIndex)
ACCESSORS(DebugInfo, code, Code, kPatchedCodeIndex)
@@ -2066,6 +2067,7 @@
ACCESSORS(BreakPointInfo, source_position, Smi, kSourcePositionIndex)
ACCESSORS(BreakPointInfo, statement_position, Smi, kStatementPositionIndex)
ACCESSORS(BreakPointInfo, break_point_objects, Object, kBreakPointObjectsIndex)
+#endif
ACCESSORS(SharedFunctionInfo, name, Object, kNameOffset)
ACCESSORS(SharedFunctionInfo, instance_class_name, Object,
diff --git a/v8/src/objects.cc b/v8/src/objects.cc
index 3273291..82f93cc 100644
--- a/v8/src/objects.cc
+++ b/v8/src/objects.cc
@@ -4661,6 +4661,7 @@
it.rinfo()->set_target_object(code);
}
+#ifdef ENABLE_DEBUGGER_SUPPORT
if (Debug::has_break_points()) {
for (RelocIterator it(this, RelocInfo::ModeMask(RelocInfo::JS_RETURN));
!it.done();
@@ -4674,6 +4675,7 @@
}
}
}
+#endif
set_ic_flag(IC_TARGET_IS_OBJECT);
}
@@ -4695,10 +4697,12 @@
v->VisitCodeTarget(it.rinfo());
} else if (rmode == RelocInfo::EXTERNAL_REFERENCE) {
v->VisitExternalReference(it.rinfo()->target_reference_address());
+#ifdef ENABLE_DEBUGGER_SUPPORT
} else if (Debug::has_break_points() &&
RelocInfo::IsJSReturn(rmode) &&
it.rinfo()->IsCallInstruction()) {
v->VisitDebugTarget(it.rinfo());
+#endif
} else if (rmode == RelocInfo::RUNTIME_ENTRY) {
v->VisitRuntimeEntry(it.rinfo());
}
@@ -4723,6 +4727,7 @@
it.rinfo()->set_target_address(code->instruction_start());
}
+#ifdef ENABLE_DEBUGGER_SUPPORT
if (Debug::has_break_points()) {
for (RelocIterator it(this, RelocInfo::ModeMask(RelocInfo::JS_RETURN));
!it.done();
@@ -4734,6 +4739,7 @@
}
}
}
+#endif
set_ic_flag(IC_TARGET_IS_ADDRESS);
}
@@ -7162,6 +7168,7 @@
}
+#ifdef ENABLE_DEBUGGER_SUPPORT
// Check if there is a break point at this code position.
bool DebugInfo::HasBreakPoint(int code_position) {
// Get the break point info object for this code position.
@@ -7405,6 +7412,6 @@
// Multiple break points.
return FixedArray::cast(break_point_objects())->length();
}
-
+#endif
} } // namespace v8::internal
diff --git a/v8/src/objects.h b/v8/src/objects.h
index b12875e..89e5182 100644
--- a/v8/src/objects.h
+++ b/v8/src/objects.h
@@ -389,7 +389,7 @@
// Note that for subtle reasons related to the ordering or numerical values of
// type tags, elements in this list have to be added to the INSTANCE_TYPE_LIST
// manually.
-#define STRUCT_LIST(V) \
+#define STRUCT_LIST_ALL(V) \
V(ACCESSOR_INFO, AccessorInfo, accessor_info) \
V(ACCESS_CHECK_INFO, AccessCheckInfo, access_check_info) \
V(INTERCEPTOR_INFO, InterceptorInfo, interceptor_info) \
@@ -398,10 +398,19 @@
V(OBJECT_TEMPLATE_INFO, ObjectTemplateInfo, object_template_info) \
V(SIGNATURE_INFO, SignatureInfo, signature_info) \
V(TYPE_SWITCH_INFO, TypeSwitchInfo, type_switch_info) \
- V(DEBUG_INFO, DebugInfo, debug_info) \
- V(BREAK_POINT_INFO, BreakPointInfo, break_point_info) \
V(SCRIPT, Script, script)
+#ifdef ENABLE_DEBUGGER_SUPPORT
+#define STRUCT_LIST_DEBUGGER(V) \
+ V(DEBUG_INFO, DebugInfo, debug_info) \
+ V(BREAK_POINT_INFO, BreakPointInfo, break_point_info)
+#else
+#define STRUCT_LIST_DEBUGGER(V)
+#endif
+
+#define STRUCT_LIST(V) \
+ STRUCT_LIST_ALL(V) \
+ STRUCT_LIST_DEBUGGER(V)
// We use the full 8 bits of the instance_type field to encode heap object
// instance types. The high-order bit (bit 7) is set if the object is not a
@@ -4151,6 +4160,7 @@
};
+#ifdef ENABLE_DEBUGGER_SUPPORT
// The DebugInfo class holds additional information for a function being
// debugged.
class DebugInfo: public Struct {
@@ -4256,6 +4266,7 @@
private:
DISALLOW_IMPLICIT_CONSTRUCTORS(BreakPointInfo);
};
+#endif // ENABLE_DEBUGGER_SUPPORT
#undef DECL_BOOLEAN_ACCESSORS
diff --git a/v8/src/runtime.cc b/v8/src/runtime.cc
index 93c4b7a..309700e 100644
--- a/v8/src/runtime.cc
+++ b/v8/src/runtime.cc
@@ -4159,10 +4159,12 @@
JSFunction* function = JSFunction::cast(constructor);
// Handle stepping into constructors if step into is active.
+#ifdef ENABLE_DEBUGGER_SUPPORT
if (Debug::StepInActive()) {
HandleScope scope;
Debug::HandleStepIn(Handle<JSFunction>(function), 0, true);
}
+#endif
if (function->has_initial_map() &&
function->initial_map()->instance_type() == JS_FUNCTION_TYPE) {
@@ -4526,12 +4528,6 @@
}
-static Object* Runtime_DebugBreak(Arguments args) {
- ASSERT(args.length() == 0);
- return Execution::DebugBreakHelper();
-}
-
-
static Object* Runtime_StackGuard(Arguments args) {
ASSERT(args.length() == 1);
@@ -4893,26 +4889,6 @@
}
-static Object* Runtime_CompileScript(Arguments args) {
- HandleScope scope;
- ASSERT(args.length() == 4);
-
- CONVERT_ARG_CHECKED(String, source, 0);
- CONVERT_ARG_CHECKED(String, script, 1);
- CONVERT_CHECKED(Smi, line_attrs, args[2]);
- int line = line_attrs->value();
- CONVERT_CHECKED(Smi, col_attrs, args[3]);
- int col = col_attrs->value();
- Handle<JSFunction> boilerplate =
- Compiler::Compile(source, script, line, col, NULL, NULL);
- if (boilerplate.is_null()) return Failure::Exception();
- Handle<JSFunction> fun =
- Factory::NewFunctionFromBoilerplate(boilerplate,
- Handle<Context>(Top::context()));
- return *fun;
-}
-
-
static Object* Runtime_SetNewFunctionAttributes(Arguments args) {
// This utility adjusts the property attributes for newly created Function
// object ("new Function(...)") by changing the map.
@@ -5317,6 +5293,13 @@
}
+#ifdef ENABLE_DEBUGGER_SUPPORT
+static Object* Runtime_DebugBreak(Arguments args) {
+ ASSERT(args.length() == 0);
+ return Execution::DebugBreakHelper();
+}
+
+
// Helper functions for wrapping and unwrapping stack frame ids.
static Smi* WrapFrameId(StackFrame::Id id) {
ASSERT(IsAligned(OffsetFrom(id), 4));
@@ -6797,6 +6780,22 @@
}
+static Object* Runtime_FunctionGetAssemblerCode(Arguments args) {
+#ifdef DEBUG
+ HandleScope scope;
+ ASSERT(args.length() == 1);
+ // Get the function and make sure it is compiled.
+ CONVERT_ARG_CHECKED(JSFunction, func, 0);
+ if (!func->is_compiled() && !CompileLazy(func, KEEP_EXCEPTION)) {
+ return Failure::Exception();
+ }
+ func->code()->PrintLn();
+#endif // DEBUG
+ return Heap::undefined_value();
+}
+#endif // ENABLE_DEBUGGER_SUPPORT
+
+
// Finds the script object from the script data. NOTE: This operation uses
// heap traversal to find the function generated for the source position
// for the requested break point. For lazily compiled functions several heap
@@ -6846,21 +6845,6 @@
}
-static Object* Runtime_FunctionGetAssemblerCode(Arguments args) {
-#ifdef DEBUG
- HandleScope scope;
- ASSERT(args.length() == 1);
- // Get the function and make sure it is compiled.
- CONVERT_ARG_CHECKED(JSFunction, func, 0);
- if (!func->is_compiled() && !CompileLazy(func, KEEP_EXCEPTION)) {
- return Failure::Exception();
- }
- func->code()->PrintLn();
-#endif // DEBUG
- return Heap::undefined_value();
-}
-
-
static Object* Runtime_Abort(Arguments args) {
ASSERT(args.length() == 2);
OS::PrintError("abort: %s\n", reinterpret_cast<char*>(args[0]) +
diff --git a/v8/src/runtime.h b/v8/src/runtime.h
index 657e5c5..4d52b31 100644
--- a/v8/src/runtime.h
+++ b/v8/src/runtime.h
@@ -195,7 +195,6 @@
\
/* Globals */ \
F(CompileString, 2) \
- F(CompileScript, 4) \
F(GlobalPrint, 1) \
\
/* Eval */ \
@@ -215,42 +214,6 @@
F(DefineAccessor, -1 /* 4 or 5 */) \
F(LookupAccessor, 3) \
\
- /* Debugging */ \
- F(SetDebugEventListener, 2) \
- F(Break, 0) \
- F(DebugGetPropertyDetails, 2) \
- F(DebugGetProperty, 2) \
- F(DebugLocalPropertyNames, 1) \
- F(DebugLocalElementNames, 1) \
- F(DebugPropertyTypeFromDetails, 1) \
- F(DebugPropertyAttributesFromDetails, 1) \
- F(DebugPropertyIndexFromDetails, 1) \
- F(DebugInterceptorInfo, 1) \
- F(DebugNamedInterceptorPropertyNames, 1) \
- F(DebugIndexedInterceptorElementNames, 1) \
- F(DebugNamedInterceptorPropertyValue, 2) \
- F(DebugIndexedInterceptorElementValue, 2) \
- F(CheckExecutionState, 1) \
- F(GetFrameCount, 1) \
- F(GetFrameDetails, 2) \
- F(GetCFrames, 1) \
- F(GetThreadCount, 1) \
- F(GetThreadDetails, 2) \
- F(GetBreakLocations, 1) \
- F(SetFunctionBreakPoint, 3) \
- F(SetScriptBreakPoint, 3) \
- F(ClearBreakPoint, 1) \
- F(ChangeBreakOnException, 2) \
- F(PrepareStep, 3) \
- F(ClearStepping, 0) \
- F(DebugEvaluate, 4) \
- F(DebugEvaluateGlobal, 3) \
- F(DebugGetLoadedScripts, 0) \
- F(DebugReferencedBy, 3) \
- F(DebugConstructedBy, 2) \
- F(DebugGetPrototype, 1) \
- F(SystemBreak, 0) \
- \
/* Literals */ \
F(MaterializeRegExpLiteral, 4)\
F(CreateArrayLiteralBoilerplate, 3) \
@@ -290,8 +253,6 @@
F(DebugTrace, 0) \
F(TraceEnter, 0) \
F(TraceExit, 1) \
- F(DebugBreak, 0) \
- F(FunctionGetAssemblerCode, 1) \
F(Abort, 2) \
/* Logging */ \
F(Log, 2) \
@@ -299,6 +260,48 @@
/* Pseudo functions - handled as macros by parser */ \
F(IS_VAR, 1)
+#ifdef ENABLE_DEBUGGER_SUPPORT
+#define RUNTIME_FUNCTION_LIST_DEBUGGER_SUPPORT(F) \
+ /* Debugger support*/ \
+ F(DebugBreak, 0) \
+ F(SetDebugEventListener, 2) \
+ F(Break, 0) \
+ F(DebugGetPropertyDetails, 2) \
+ F(DebugGetProperty, 2) \
+ F(DebugLocalPropertyNames, 1) \
+ F(DebugLocalElementNames, 1) \
+ F(DebugPropertyTypeFromDetails, 1) \
+ F(DebugPropertyAttributesFromDetails, 1) \
+ F(DebugPropertyIndexFromDetails, 1) \
+ F(DebugInterceptorInfo, 1) \
+ F(DebugNamedInterceptorPropertyNames, 1) \
+ F(DebugIndexedInterceptorElementNames, 1) \
+ F(DebugNamedInterceptorPropertyValue, 2) \
+ F(DebugIndexedInterceptorElementValue, 2) \
+ F(CheckExecutionState, 1) \
+ F(GetFrameCount, 1) \
+ F(GetFrameDetails, 2) \
+ F(GetCFrames, 1) \
+ F(GetThreadCount, 1) \
+ F(GetThreadDetails, 2) \
+ F(GetBreakLocations, 1) \
+ F(SetFunctionBreakPoint, 3) \
+ F(SetScriptBreakPoint, 3) \
+ F(ClearBreakPoint, 1) \
+ F(ChangeBreakOnException, 2) \
+ F(PrepareStep, 3) \
+ F(ClearStepping, 0) \
+ F(DebugEvaluate, 4) \
+ F(DebugEvaluateGlobal, 3) \
+ F(DebugGetLoadedScripts, 0) \
+ F(DebugReferencedBy, 3) \
+ F(DebugConstructedBy, 2) \
+ F(DebugGetPrototype, 1) \
+ F(SystemBreak, 0) \
+ F(FunctionGetAssemblerCode, 1)
+#else
+#define RUNTIME_FUNCTION_LIST_DEBUGGER_SUPPORT(F)
+#endif
#ifdef DEBUG
#define RUNTIME_FUNCTION_LIST_DEBUG(F) \
@@ -316,7 +319,8 @@
#define RUNTIME_FUNCTION_LIST(F) \
RUNTIME_FUNCTION_LIST_ALWAYS(F) \
- RUNTIME_FUNCTION_LIST_DEBUG(F)
+ RUNTIME_FUNCTION_LIST_DEBUG(F) \
+ RUNTIME_FUNCTION_LIST_DEBUGGER_SUPPORT(F)
// ----------------------------------------------------------------------------
// Runtime provides access to all C++ runtime functions.
diff --git a/v8/src/serialize.cc b/v8/src/serialize.cc
index ef2517c..e15c003 100644
--- a/v8/src/serialize.cc
+++ b/v8/src/serialize.cc
@@ -548,6 +548,7 @@
AddFromId(ref_table[i].type, ref_table[i].id, ref_table[i].name);
}
+#ifdef ENABLE_DEBUGGER_SUPPORT
// Debug addresses
Add(Debug_Address(Debug::k_after_break_target_address).address(),
DEBUG_ADDRESS,
@@ -567,6 +568,7 @@
Debug::k_register_address << kDebugIdShift | i,
name.start());
}
+#endif
// Stat counters
struct StatsRefTableEntry {
@@ -659,10 +661,6 @@
UNCLASSIFIED,
4,
"RegExpStack::limit_address()");
- Add(ExternalReference::debug_break().address(),
- UNCLASSIFIED,
- 5,
- "Debug::Break()");
Add(ExternalReference::new_space_start().address(),
UNCLASSIFIED,
6,
@@ -679,6 +677,11 @@
UNCLASSIFIED,
9,
"Heap::NewSpaceAllocationTopAddress()");
+#ifdef ENABLE_DEBUGGER_SUPPORT
+ Add(ExternalReference::debug_break().address(),
+ UNCLASSIFIED,
+ 5,
+ "Debug::Break()");
Add(ExternalReference::debug_step_in_fp_address().address(),
UNCLASSIFIED,
10,
@@ -695,6 +698,7 @@
UNCLASSIFIED,
13,
"mul_two_doubles");
+#endif
}
diff --git a/v8/src/stub-cache.cc b/v8/src/stub-cache.cc
index 35e3d42..6811fd2 100644
--- a/v8/src/stub-cache.cc
+++ b/v8/src/stub-cache.cc
@@ -594,6 +594,7 @@
}
+#ifdef ENABLE_DEBUGGER_SUPPORT
Object* StubCache::ComputeCallDebugBreak(int argc) {
Code::Flags flags =
Code::ComputeFlags(Code::CALL_IC, DEBUG_BREAK, NORMAL, argc);
@@ -612,6 +613,7 @@
StubCompiler compiler;
return FillCache(compiler.CompileCallDebugPrepareStepIn(flags));
}
+#endif
Object* StubCache::ComputeLazyCompile(int argc) {
@@ -836,6 +838,7 @@
}
+#ifdef ENABLE_DEBUGGER_SUPPORT
Object* StubCompiler::CompileCallDebugBreak(Code::Flags flags) {
HandleScope scope;
Debug::GenerateCallICDebugBreak(masm());
@@ -864,6 +867,7 @@
}
return result;
}
+#endif
Object* StubCompiler::GetCodeWithFlags(Code::Flags flags, const char* name) {
diff --git a/v8/src/stub-cache.h b/v8/src/stub-cache.h
index 05845e5..824f4ff 100644
--- a/v8/src/stub-cache.h
+++ b/v8/src/stub-cache.h
@@ -157,8 +157,10 @@
// Finds the Code object stored in the Heap::non_monomorphic_cache().
static Code* FindCallInitialize(int argc);
+#ifdef ENABLE_DEBUGGER_SUPPORT
static Object* ComputeCallDebugBreak(int argc);
static Object* ComputeCallDebugPrepareStepIn(int argc);
+#endif
static Object* ComputeLazyCompile(int argc);
@@ -288,8 +290,10 @@
Object* CompileCallNormal(Code::Flags flags);
Object* CompileCallMegamorphic(Code::Flags flags);
Object* CompileCallMiss(Code::Flags flags);
+#ifdef ENABLE_DEBUGGER_SUPPORT
Object* CompileCallDebugBreak(Code::Flags flags);
Object* CompileCallDebugPrepareStepIn(Code::Flags flags);
+#endif
Object* CompileLazyCompile(Code::Flags flags);
// Static functions for generating parts of stubs.
diff --git a/v8/src/top.cc b/v8/src/top.cc
index 3c4b8dd..96f98a5 100644
--- a/v8/src/top.cc
+++ b/v8/src/top.cc
@@ -728,8 +728,10 @@
bool should_return_exception = ShouldReportException(&is_caught_externally);
bool report_exception = !is_out_of_memory && should_return_exception;
+#ifdef ENABLE_DEBUGGER_SUPPORT
// Notify debugger of exception.
Debugger::OnException(exception_handle, report_exception);
+#endif
// Generate the message.
Handle<Object> message_obj;
diff --git a/v8/src/v8.cc b/v8/src/v8.cc
index 9158b52..fbe3d5d 100644
--- a/v8/src/v8.cc
+++ b/v8/src/v8.cc
@@ -72,7 +72,9 @@
v8::Locker::StartPreemption(100);
}
+#ifdef ENABLE_DEBUGGER_SUPPORT
Debug::Setup(create_heap_objects);
+#endif
StubCache::Initialize(create_heap_objects);
// If we are deserializing, read the state into the now-empty heap.
@@ -111,7 +113,9 @@
Heap::TearDown();
Logger::TearDown();
+#ifdef ENABLE_DEBUGGER_SUPPORT
Debugger::TearDown();
+#endif
has_been_setup_ = false;
has_been_disposed_ = true;
diff --git a/v8/src/v8.h b/v8/src/v8.h
index 4cf0b70..4ced0d2 100644
--- a/v8/src/v8.h
+++ b/v8/src/v8.h
@@ -51,6 +51,11 @@
#error both DEBUG and NDEBUG are set
#endif
+// Enable debugger support by default, unless it is in ANDROID
+#if !defined(ENABLE_DEBUGGER_SUPPORT) && !defined(ANDROID)
+#define ENABLE_DEBUGGER_SUPPORT
+#endif
+
// Basic includes
#include "../include/v8.h"
#include "globals.h"
diff --git a/v8/src/v8threads.cc b/v8/src/v8threads.cc
index e8f6f9b..2439476 100644
--- a/v8/src/v8threads.cc
+++ b/v8/src/v8threads.cc
@@ -144,7 +144,9 @@
char* from = state->data();
from = HandleScopeImplementer::RestoreThread(from);
from = Top::RestoreThread(from);
+#ifdef ENABLE_DEBUGGER_SUPPORT
from = Debug::RestoreDebug(from);
+#endif
from = StackGuard::RestoreStackGuard(from);
from = RegExpStack::RestoreStack(from);
from = Bootstrapper::RestoreState(from);
@@ -172,7 +174,9 @@
static int ArchiveSpacePerThread() {
return HandleScopeImplementer::ArchiveSpacePerThread() +
Top::ArchiveSpacePerThread() +
+#ifdef ENABLE_DEBUGGER_SUPPORT
Debug::ArchiveSpacePerThread() +
+#endif
StackGuard::ArchiveSpacePerThread() +
RegExpStack::ArchiveSpacePerThread() +
Bootstrapper::ArchiveSpacePerThread();
@@ -259,7 +263,9 @@
char* to = state->data();
to = HandleScopeImplementer::ArchiveThread(to);
to = Top::ArchiveThread(to);
+#ifdef ENABLE_DEBUGGER_SUPPORT
to = Debug::ArchiveDebug(to);
+#endif
to = StackGuard::ArchiveStackGuard(to);
to = RegExpStack::ArchiveStack(to);
to = Bootstrapper::ArchiveState(to);
