v8::Local<v8::String> s = value->ToString();

char* data = NewArray<char>(s->Length() + 1);

if (data == NULL) {

V8::FatalProcessOutOfMemory("PrintLn");

return;

}

s->WriteAscii(data);

PrintF("%s\n", data);

DeleteArray(data);

BreakLocatorType type) {

debug_info_ = debug_info;

type_ = type;

// Get the stub early to avoid possible GC during iterations. We may need

// this stub to detect debugger calls generated from debugger statements.

debug_break_stub_ = RuntimeStub(Runtime::kDebugBreak, 0).GetCode();

reloc_iterator_ = NULL;

reloc_iterator_original_ = NULL;

Reset(); // Initialize the rest of the member variables.

AssertNoAllocation nogc;

ASSERT(!RinfoDone());

// Iterate through reloc info for code and original code stopping at each

// breakable code target.

bool first = break_point_ == -1;

while (!RinfoDone()) {

if (!first) RinfoNext();

first = false;

if (RinfoDone()) return;

// Whenever a statement position or (plain) position is passed update the

// current value of these.

if (RelocInfo::IsPosition(rmode())) {

if (RelocInfo::IsStatementPosition(rmode())) {

statement_position_ =

rinfo()->data() - debug_info_->shared()->start_position();

}

// Always update the position as we don't want that to be before the

// statement position.

position_ = rinfo()->data() - debug_info_->shared()->start_position();

ASSERT(position_ >= 0);

ASSERT(statement_position_ >= 0);

}

// Check for breakable code target. Look in the original code as setting

// break points can cause the code targets in the running (debugged) code to

// be of a different kind than in the original code.

if (RelocInfo::IsCodeTarget(rmode())) {

Address target = original_rinfo()->target_address();

Code* code = Code::GetCodeFromTargetAddress(target);

if (code->is_inline_cache_stub() || RelocInfo::IsConstructCall(rmode())) {

break_point_++;

return;

}

if (code->kind() == Code::STUB) {

if (IsDebuggerStatement()) {

break_point_++;

return;

}

if (type_ == ALL_BREAK_LOCATIONS) {

if (Debug::IsBreakStub(code)) {

break_point_++;

return;

}

} else {

ASSERT(type_ == SOURCE_BREAK_LOCATIONS);

if (Debug::IsSourceBreakStub(code)) {

break_point_++;

return;

}

}

}

}

// Check for break at return.

if (RelocInfo::IsJSReturn(rmode())) {

// Set the positions to the end of the function.

if (debug_info_->shared()->HasSourceCode()) {

position_ = debug_info_->shared()->end_position() -

debug_info_->shared()->start_position();

} else {

position_ = 0;

}

statement_position_ = position_;

break_point_++;

return;

}

}

while (count > 0) {

Next();

count--;

}

// Run through all break points to locate the one closest to the address.

int closest_break_point = 0;

int distance = kMaxInt;

while (!Done()) {

// Check if this break point is closer that what was previously found.

if (this->pc() < pc && pc - this->pc() < distance) {

closest_break_point = break_point();

distance = pc - this->pc();

// Check whether we can't get any closer.

if (distance == 0) break;

}

Next();

}

// Move to the break point found.

Reset();

Next(closest_break_point);

// Run through all break points to locate the one closest to the source

// position.

int closest_break_point = 0;

int distance = kMaxInt;

while (!Done()) {

// Check if this break point is closer that what was previously found.

if (position <= statement_position() &&

statement_position() - position < distance) {

closest_break_point = break_point();

distance = statement_position() - position;

// Check whether we can't get any closer.

if (distance == 0) break;

}

Next();

}

// Move to the break point found.

Reset();

Next(closest_break_point);

// Create relocation iterators for the two code objects.

if (reloc_iterator_ != NULL) delete reloc_iterator_;

if (reloc_iterator_original_ != NULL) delete reloc_iterator_original_;

reloc_iterator_ = new RelocIterator(debug_info_->code());

reloc_iterator_original_ = new RelocIterator(debug_info_->original_code());

// Position at the first break point.

break_point_ = -1;

position_ = 1;

statement_position_ = 1;

Next();

// If there is not already a real break point here patch code with debug

// break.

if (!HasBreakPoint()) {

SetDebugBreak();

}

ASSERT(IsDebugBreak() || IsDebuggerStatement());

// Set the break point information.

DebugInfo::SetBreakPoint(debug_info_, code_position(),

position(), statement_position(),

break_point_object);

// Clear the break point information.

DebugInfo::ClearBreakPoint(debug_info_, code_position(), break_point_object);

// If there are no more break points here remove the debug break.

if (!HasBreakPoint()) {

ClearDebugBreak();

ASSERT(!IsDebugBreak());

}

// Debugger statement always calls debugger. No need to modify it.

if (IsDebuggerStatement()) {

return;

}

// If there is a real break point here no more to do.

if (HasBreakPoint()) {

ASSERT(IsDebugBreak());

return;

}

// Patch code with debug break.

SetDebugBreak();

// Debugger statement always calls debugger. No need to modify it.

if (IsDebuggerStatement()) {

return;

}

// If there is a real break point here no more to do.

if (HasBreakPoint()) {

ASSERT(IsDebugBreak());

return;

}

// Patch code removing debug break.

ClearDebugBreak();

ASSERT(!IsDebugBreak());

// Debugger statement always calls debugger. No need to modify it.

if (IsDebuggerStatement()) {

return;

}

// If there is already a break point here just return. This might happen if

// the same code is flooded with break points twice. Flooding the same

// function twice might happen when stepping in a function with an exception

// handler as the handler and the function is the same.

if (IsDebugBreak()) {

return;

}

if (RelocInfo::IsJSReturn(rmode())) {

// Patch the frame exit code with a break point.

SetDebugBreakAtReturn();

} else {

// Patch the IC call.

SetDebugBreakAtIC();

}

ASSERT(IsDebugBreak());

// Debugger statement always calls debugger. No need to modify it.

if (IsDebuggerStatement()) {

return;

}

if (RelocInfo::IsJSReturn(rmode())) {

// Restore the frame exit code.

ClearDebugBreakAtReturn();

} else {

// Patch the IC call.

ClearDebugBreakAtIC();

}

ASSERT(!IsDebugBreak());

HandleScope scope;

// Step in can only be prepared if currently positioned on an IC call,

// construct call or CallFunction stub call.

Address target = rinfo()->target_address();

Handle<Code> code(Code::GetCodeFromTargetAddress(target));

if (code->is_call_stub()) {

// Step in through IC call is handled by the runtime system. Therefore make

// sure that the any current IC is cleared and the runtime system is

// called. If the executing code has a debug break at the location change

// the call in the original code as it is the code there that will be

// executed in place of the debug break call.

Handle<Code> stub = ComputeCallDebugPrepareStepIn(code->arguments_count());

if (IsDebugBreak()) {

original_rinfo()->set_target_address(stub->entry());

} else {

rinfo()->set_target_address(stub->entry());

}

} else {

#ifdef DEBUG

// All the following stuff is needed only for assertion checks so the code

// is wrapped in ifdef.

Handle<Code> maybe_call_function_stub = code;

if (IsDebugBreak()) {

Address original_target = original_rinfo()->target_address();

maybe_call_function_stub =

Handle<Code>(Code::GetCodeFromTargetAddress(original_target));

}

bool is_call_function_stub =

(maybe_call_function_stub->kind() == Code::STUB &&

maybe_call_function_stub->major_key() == CodeStub::CallFunction);

// Step in through construct call requires no changes to the running code.

// Step in through getters/setters should already be prepared as well

// because caller of this function (Debug::PrepareStep) is expected to

// flood the top frame's function with one shot breakpoints.

// Step in through CallFunction stub should also be prepared by caller of

// this function (Debug::PrepareStep) which should flood target function

// with breakpoints.

ASSERT(RelocInfo::IsConstructCall(rmode()) || code->is_inline_cache_stub()

|| is_call_function_stub);

#endif

}

if (RelocInfo::IsJSReturn(rmode())) {

return IsDebugBreakAtReturn();

} else {

return Debug::IsDebugBreak(rinfo()->target_address());

}

// Patch the original code with the current address as the current address

// might have changed by the inline caching since the code was copied.

original_rinfo()->set_target_address(rinfo()->target_address());

RelocInfo::Mode mode = rmode();

if (RelocInfo::IsCodeTarget(mode)) {

Address target = rinfo()->target_address();

Handle<Code> code(Code::GetCodeFromTargetAddress(target));

// Patch the code to invoke the builtin debug break function matching the

// calling convention used by the call site.

Handle<Code> dbgbrk_code(Debug::FindDebugBreak(code, mode));

rinfo()->set_target_address(dbgbrk_code->entry());

// For stubs that refer back to an inlined version clear the cached map for

// the inlined case to always go through the IC. As long as the break point

// is set the patching performed by the runtime system will take place in

// the code copy and will therefore have no effect on the running code

// keeping it from using the inlined code.

if (code->is_keyed_load_stub()) KeyedLoadIC::ClearInlinedVersion(pc());

if (code->is_keyed_store_stub()) KeyedStoreIC::ClearInlinedVersion(pc());

}

// Patch the code to the original invoke.

rinfo()->set_target_address(original_rinfo()->target_address());

RelocInfo::Mode mode = rmode();

if (RelocInfo::IsCodeTarget(mode)) {

Address target = original_rinfo()->target_address();

Handle<Code> code(Code::GetCodeFromTargetAddress(target));

// Restore the inlined version of keyed stores to get back to the

// fast case. We need to patch back the keyed store because no

// patching happens when running normally. For keyed loads, the

// map check will get patched back when running normally after ICs

// have been cleared at GC.

if (code->is_keyed_store_stub()) KeyedStoreIC::RestoreInlinedVersion(pc());

}

if (RelocInfo::IsCodeTarget(rmode())) {

Address target = original_rinfo()->target_address();

Code* code = Code::GetCodeFromTargetAddress(target);

if (code->kind() == Code::STUB) {

CodeStub::Major major_key = code->major_key();

if (major_key == CodeStub::Runtime) {

return (*debug_break_stub_ == code);

}

}

}

return false;

while (!Done()) {

ClearDebugBreak();

Next();

}

reloc_iterator_->next();

reloc_iterator_original_->next();

#ifdef DEBUG

ASSERT(reloc_iterator_->done() == reloc_iterator_original_->done());

if (!reloc_iterator_->done()) {

ASSERT(rmode() == original_rmode());

}

#endif

thread_local_.break_count_ = 0;

thread_local_.break_id_ = 0;

thread_local_.break_frame_id_ = StackFrame::NO_ID;

thread_local_.last_step_action_ = StepNone;

thread_local_.last_statement_position_ = RelocInfo::kNoPosition;

thread_local_.step_count_ = 0;

thread_local_.last_fp_ = 0;

thread_local_.step_into_fp_ = 0;

thread_local_.step_out_fp_ = 0;

thread_local_.after_break_target_ = 0;

thread_local_.debugger_entry_ = NULL;

thread_local_.pending_interrupts_ = 0;

// Create an entry in the hash map for the script.

int id = Smi::cast(script->id())->value();

HashMap::Entry* entry =

HashMap::Lookup(reinterpret_cast<void*>(id), Hash(id), true);

if (entry->value != NULL) {

ASSERT(*script == *reinterpret_cast<Script**>(entry->value));

return;

}

// Globalize the script object, make it weak and use the location of the

// global handle as the value in the hash map.

Handle<Script> script_ =

Handle<Script>::cast((GlobalHandles::Create(*script)));

GlobalHandles::MakeWeak(reinterpret_cast<Object**>(script_.location()),

this, ScriptCache::HandleWeakScript);

entry->value = script_.location();

Handle<FixedArray> instances = Factory::NewFixedArray(occupancy());

int count = 0;

for (HashMap::Entry* entry = Start(); entry != NULL; entry = Next(entry)) {

ASSERT(entry->value != NULL);

if (entry->value != NULL) {

instances->set(count, *reinterpret_cast<Script**>(entry->value));

count++;

}

}

return instances;

for (int i = 0; i < collected_scripts_.length(); i++) {

Debugger::OnScriptCollected(collected_scripts_[i]);

}

collected_scripts_.Clear();

// Iterate the script cache to get rid of all the weak handles.

for (HashMap::Entry* entry = Start(); entry != NULL; entry = Next(entry)) {

ASSERT(entry != NULL);

Object** location = reinterpret_cast<Object**>(entry->value);

ASSERT((*location)->IsScript());

GlobalHandles::ClearWeakness(location);

GlobalHandles::Destroy(location);

}

// Clear the content of the hash map.

HashMap::Clear();

ScriptCache* script_cache = reinterpret_cast<ScriptCache*>(data);

// Find the location of the global handle.

Script** location =

reinterpret_cast<Script**>(Utils::OpenHandle(*obj).location());

ASSERT((*location)->IsScript());

// Remove the entry from the cache.

int id = Smi::cast((*location)->id())->value();

script_cache->Remove(reinterpret_cast<void*>(id), Hash(id));

script_cache->collected_scripts_.Add(id);

// Clear the weak handle.

obj.Dispose();

obj.Clear();

ThreadInit();

if (create_heap_objects) {

// Get code to handle debug break on return.

debug_break_return_ =

Builtins::builtin(Builtins::Return_DebugBreak);

ASSERT(debug_break_return_->IsCode());

}

DebugInfoListNode* node = reinterpret_cast<DebugInfoListNode*>(data);

RemoveDebugInfo(node->debug_info());

#ifdef DEBUG

node = Debug::debug_info_list_;

while (node != NULL) {

ASSERT(node != reinterpret_cast<DebugInfoListNode*>(data));

node = node->next();

}

#endif

// Globalize the request debug info object and make it weak.

debug_info_ = Handle<DebugInfo>::cast((GlobalHandles::Create(debug_info)));

GlobalHandles::MakeWeak(reinterpret_cast<Object**>(debug_info_.location()),

this, Debug::HandleWeakDebugInfo);

HandleScope scope;

// Bail out if the index is invalid.

if (index == -1) {

return false;

}

// Find source and name for the requested script.

Handle<String> source_code = Bootstrapper::NativesSourceLookup(index);

Vector<const char> name = Natives::GetScriptName(index);

Handle<String> script_name = Factory::NewStringFromAscii(name);

// Compile the script.

bool allow_natives_syntax = FLAG_allow_natives_syntax;

FLAG_allow_natives_syntax = true;

Handle<JSFunction> boilerplate;

boilerplate = Compiler::Compile(source_code, script_name, 0, 0, NULL, NULL);

FLAG_allow_natives_syntax = allow_natives_syntax;

// Silently ignore stack overflows during compilation.

if (boilerplate.is_null()) {

ASSERT(Top::has_pending_exception());

Top::clear_pending_exception();

return false;

}

// Execute the boilerplate function in the debugger context.

Handle<Context> context = Top::global_context();

bool caught_exception = false;

Handle<JSFunction> function =

Factory::NewFunctionFromBoilerplate(boilerplate, context);

Handle<Object> result =

Execution::TryCall(function, Handle<Object>(context->global()),

0, NULL, &caught_exception);

// Check for caught exceptions.

if (caught_exception) {

Handle<Object> message = MessageHandler::MakeMessageObject(

"error_loading_debugger", NULL, Vector<Handle<Object> >::empty(),

Handle<String>());

MessageHandler::ReportMessage(NULL, message);

return false;

}

// Mark this script as native and return successfully.

Handle<Script> script(Script::cast(function->shared()->script()));

script->set_type(Smi::FromInt(Script::TYPE_NATIVE));

return true;

// Return if debugger is already loaded.

if (IsLoaded()) return true;

// Bail out if we're already in the process of compiling the native

// JavaScript source code for the debugger.

if (Debugger::compiling_natives() || Debugger::is_loading_debugger())

return false;

Debugger::set_loading_debugger(true);

// Disable breakpoints and interrupts while compiling and running the

// debugger scripts including the context creation code.

DisableBreak disable(true);

PostponeInterruptsScope postpone;

// Create the debugger context.

HandleScope scope;

Handle<Context> context =

Bootstrapper::CreateEnvironment(Handle<Object>::null(),

v8::Handle<ObjectTemplate>(),

NULL);

// Use the debugger context.

SaveContext save;

Top::set_context(*context);

// Expose the builtins object in the debugger context.

Handle<String> key = Factory::LookupAsciiSymbol("builtins");

Handle<GlobalObject> global = Handle<GlobalObject>(context->global());

SetProperty(global, key, Handle<Object>(global->builtins()), NONE);

// Compile the JavaScript for the debugger in the debugger context.

Debugger::set_compiling_natives(true);

bool caught_exception =

!CompileDebuggerScript(Natives::GetIndex("mirror")) ||

!CompileDebuggerScript(Natives::GetIndex("debug"));

Debugger::set_compiling_natives(false);

// Make sure we mark the debugger as not loading before we might

// return.

Debugger::set_loading_debugger(false);

// Check for caught exceptions.

if (caught_exception) return false;

// Debugger loaded.

debug_context_ = Handle<Context>::cast(GlobalHandles::Create(*context));

return true;

// Return debugger is not loaded.

if (!IsLoaded()) {

return;

}

// Clear the script cache.

DestroyScriptCache();

// Clear debugger context global handle.

GlobalHandles::Destroy(reinterpret_cast<Object**>(debug_context_.location()));

debug_context_ = Handle<Context>();

int break_points_hit_count = 0;

Handle<JSArray> break_points_hit = Factory::NewJSArray(1);

// If there are multiple break points they are in a FixedArray.

ASSERT(!break_point_objects->IsUndefined());

if (break_point_objects->IsFixedArray()) {

Handle<FixedArray> array(FixedArray::cast(*break_point_objects));

for (int i = 0; i < array->length(); i++) {

Handle<Object> o(array->get(i));

if (CheckBreakPoint(o)) {

break_points_hit->SetElement(break_points_hit_count++, *o);

}

}

} else {

if (CheckBreakPoint(break_point_objects)) {

break_points_hit->SetElement(break_points_hit_count++,

*break_point_objects);

}

}

// Return undefined if no break points where triggered.

if (break_points_hit_count == 0) {

return Factory::undefined_value();

}

return break_points_hit;

HandleScope scope;

// Ignore check if break point object is not a JSObject.

if (!break_point_object->IsJSObject()) return true;

// Get the function CheckBreakPoint (defined in debug.js).

Handle<JSFunction> check_break_point =

Handle<JSFunction>(JSFunction::cast(

debug_context()->global()->GetProperty(

*Factory::LookupAsciiSymbol("IsBreakPointTriggered"))));

// Get the break id as an object.

Handle<Object> break_id = Factory::NewNumberFromInt(Debug::break_id());

// Call HandleBreakPointx.

bool caught_exception = false;

const int argc = 2;

Object** argv[argc] = {

break_id.location(),

reinterpret_cast<Object**>(break_point_object.location())

};

Handle<Object> result = Execution::TryCall(check_break_point,

Top::builtins(), argc, argv,

&caught_exception);

// If exception or non boolean result handle as not triggered

if (caught_exception || !result->IsBoolean()) {

return false;

}

// Return whether the break point is triggered.

return *result == Heap::true_value();

int source_position,

Handle<Object> break_point_object) {

HandleScope scope;

if (!EnsureDebugInfo(shared)) {

// Return if retrieving debug info failed.

return;

}

Handle<DebugInfo> debug_info = GetDebugInfo(shared);

// Source positions starts with zero.

ASSERT(source_position >= 0);

// Find the break point and change it.

BreakLocationIterator it(debug_info, SOURCE_BREAK_LOCATIONS);

it.FindBreakLocationFromPosition(source_position);

it.SetBreakPoint(break_point_object);

// At least one active break point now.