MemCopy(storage, reinterpret_cast<char*>(&thread_local_),

ArchiveSpacePerThread());

MemCopy(reinterpret_cast<char*>(&thread_local_), storage,

ArchiveSpacePerThread());

// Enter the debugger.

DebugScope debug_scope(this);

// Clear any one-shot breakpoints that may have been set by the other

// thread, and reapply breakpoints for this thread.

ClearOneShot();

if (thread_local_.last_step_action_ != StepNone) {

// Reset the previous step action for this thread.

PrepareStep(thread_local_.last_step_action_);

}

int Debug::ArchiveSpacePerThread() { return sizeof(ThreadLocal); }

void InitThread(const ExecutionAccess& lock) { ThreadInit(); }

isolate_->thread_manager()->InitThread(access);

void ThreadManager::InitThread(const ExecutionAccess& lock) {

isolate_->stack_guard()->InitThread(lock);

isolate_->debug()->InitThread(lock);

}

InitThread(access);

void InitThread(const ExecutionAccess&);

class ArchiveRestoreThread : public v8::base::Thread,

public v8::debug::DebugDelegate {

public:

ArchiveRestoreThread(v8::Isolate* isolate, int spawn_count)

: Thread(Options("ArchiveRestoreThread")),

isolate_(isolate),

debug_(reinterpret_cast<i::Isolate*>(isolate_)->debug()),

spawn_count_(spawn_count),

break_count_(0) {}

virtual void Run() {

v8::Locker locker(isolate_);

isolate_->Enter();

v8::HandleScope scope(isolate_);

v8::Local<v8::Context> context = v8::Context::New(isolate_);

v8::Context::Scope context_scope(context);

v8::Local<v8::Function> test = CompileFunction(isolate_,

"function test(n) {\n"

" debugger;\n"

" return n + 1;\n"

"}\n",

"test");

debug_->SetDebugDelegate(this);

v8::internal::DisableBreak enable_break(debug_, false);

v8::Local<v8::Value> args[1] = {v8::Integer::New(isolate_, spawn_count_)};

int result = test->Call(context, context->Global(), 1, args)

.ToLocalChecked()

->Int32Value(context)

.FromJust();

// Verify that test(spawn_count_) returned spawn_count_ + 1.

CHECK_EQ(spawn_count_ + 1, result);

isolate_->Exit();

}

void BreakProgramRequested(v8::Local<v8::Context> context,

const std::vector<v8::debug::BreakpointId>&) {

auto stack_traces = v8::debug::StackTraceIterator::Create(isolate_);

if (!stack_traces->Done()) {

v8::debug::Location location = stack_traces->GetSourceLocation();

i::PrintF("ArchiveRestoreThread #%d hit breakpoint at line %d\n",

spawn_count_, location.GetLineNumber());

switch (location.GetLineNumber()) {

case 1: // debugger;

CHECK_EQ(break_count_, 0);

// Attempt to stop on the next line after the first debugger

// statement. If debug->{Archive,Restore}Debug() improperly reset

// thread-local debug information, the debugger will fail to stop

// before the test function returns.

debug_->PrepareStep(StepNext);

// Spawning threads while handling the current breakpoint verifies

// that the parent thread correctly archived and restored the

// state necessary to stop on the next line. If not, then control

// will simply continue past the `return n + 1` statement.

MaybeSpawnChildThread();

break;

case 2: // return n + 1;

CHECK_EQ(break_count_, 1);

break;

default:

CHECK(false);

}

}

++break_count_;

}

void MaybeSpawnChildThread() {

if (spawn_count_ > 1) {

v8::Unlocker unlocker(isolate_);

// Spawn a thread that spawns a thread that spawns a thread (and so

// on) so that the ThreadManager is forced to archive and restore

// the current thread.

ArchiveRestoreThread child(isolate_, spawn_count_ - 1);

child.Start();

child.Join();

// The child thread sets itself as the debug delegate, so we need to

// usurp it after the child finishes, or else future breakpoints

// will be delegated to a destroyed ArchiveRestoreThread object.

debug_->SetDebugDelegate(this);

// This is the most important check in this test, since

// child.GetBreakCount() will return 1 if the debugger fails to stop

// on the `return n + 1` line after the grandchild thread returns.

CHECK_EQ(child.GetBreakCount(), 2);

}

}

int GetBreakCount() { return break_count_; }

private:

v8::Isolate* isolate_;

v8::internal::Debug* debug_;

const int spawn_count_;

int break_count_;

};

TEST(DebugArchiveRestore) {

v8::Isolate::CreateParams create_params;

create_params.array_buffer_allocator = CcTest::array_buffer_allocator();

v8::Isolate* isolate = v8::Isolate::New(create_params);

ArchiveRestoreThread thread(isolate, 5);

// Instead of calling thread.Start() and thread.Join() here, we call

// thread.Run() directly, to make sure we exercise archive/restore

// logic on the *current* thread as well as other threads.

thread.Run();

CHECK_EQ(thread.GetBreakCount(), 2);

isolate->Dispose();

}